PosixProcess.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "PosixProcess.h"
#include "pedigree/kernel/process/Scheduler.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include <signal.h>
 
#include "IntervalTimerState.h"
#include "ProcFs.h"
#include "TerminalControl.h"
#include "modules/system/vfs/VFS.h"
 
PosixProcess::PosixProcess()
    : Process(DeferredPublication(), Posix),
      m_AccountingLifetime(false),
      m_SessionId(0),
      m_pProcessGroup(nullptr),
      m_GroupPrevious(nullptr),
      m_GroupNext(nullptr),
      m_ExecCommitted(false),
      m_GroupMembership(NoGroup),
      m_Mask(0),
      m_RealIntervalTimer(this, IntervalTimer::Hardware),
      m_VirtualIntervalTimer(this, IntervalTimer::Virtual),
      m_ProfileIntervalTimer(this, IntervalTimer::Profile),
      m_Credentials(),
      m_RealUserId(0),
      m_bRegistered(false) {
  initializeJobControl(nullptr);
  publishCredentialReadCache();
  enableTimeAccountingReports(0);
}
 
PosixProcess::PosixProcess(Process* pParent, bool bCopyOnWrite,
                           FilesystemContextMode filesystemContext, bool emptyAddressSpace)
    : Process(DeferredPublication(), pParent, bCopyOnWrite, filesystemContext, emptyAddressSpace,
              Posix),
      m_AccountingLifetime(true),
      m_SessionId(0),
      m_pProcessGroup(nullptr),
      m_GroupPrevious(nullptr),
      m_GroupNext(nullptr),
      m_ExecCommitted(false),
      m_GroupMembership(NoGroup),
      m_Mask(0),
      m_RealIntervalTimer(this, IntervalTimer::Hardware),
      m_VirtualIntervalTimer(this, IntervalTimer::Virtual),
      m_ProfileIntervalTimer(this, IntervalTimer::Profile),
      m_Credentials(),
      m_RealUserId(0),
      m_bRegistered(false) {
  initializeJobControl(pParent);
  enableTimeAccountingReports(0);
 
  if (pParent->getType() == Posix) {
    PosixProcess* pPosixParent = static_cast<PosixProcess*>(pParent);
 
    // Child inherits parent's mask.
    m_Mask = pPosixParent->getMask();
 
    m_Credentials = pPosixParent->snapshotCredentials();
  } else {
    FilesystemCredentials inherited;
    if (pParent->snapshotFilesystemCredentials(nullptr, inherited)) {
      m_Credentials.ruid = m_Credentials.euid = m_Credentials.suid = inherited.uid;
      m_Credentials.rgid = m_Credentials.egid = m_Credentials.sgid = inherited.gid;
      m_Credentials.groupCount = inherited.groupCount;
      for (size_t i = 0; i < inherited.groupCount; ++i)
        m_Credentials.groups[i] = inherited.groups[i];
    }
  }
  publishCredentialReadCache();
}
 
void PosixProcess::publishCredentialReadCache() {
  __atomic_store_n(&m_RealUserId, m_Credentials.ruid, __ATOMIC_RELEASE);
}
 
PosixProcess::~PosixProcess() {
  prepareForDestruction();
  leaveProcessGroup();
  unregisterProcess();
}
 
void PosixProcess::publish() {
  // Scheduler enumeration must not observe this object until the caller has
  // installed all child-side state and a non-runnable initial Thread.
  assert(jobControlReady());
  Process::publish();
  registerProcess();
}
 
void PosixProcess::setMask(uint32_t mask) {
  m_Mask = mask;
}
 
uint32_t PosixProcess::getMask() const {
  return m_Mask;
}
 
void PosixProcess::registerProcess() {
  ProcFs::publishProcess(this);
  m_bRegistered = true;
  if (!pidNamespaceReady()) {
    ThreadLease recipient;
    if (getSubsystem() && acquireProcessSignalThread(recipient)) {
      getSubsystem()->kill(Subsystem::Unknown, recipient.get());
    }
  }
}
 
void PosixProcess::unregisterProcess() {
  if (m_bRegistered) {
    ProcFs::unpublishProcess(this);
    m_bRegistered = false;
  }
}
 
IntervalTimer& PosixProcess::getRealIntervalTimer() {
  return m_RealIntervalTimer;
}
 
IntervalTimer& PosixProcess::getVirtualIntervalTimer() {
  return m_VirtualIntervalTimer;
}
 
IntervalTimer& PosixProcess::getProfileIntervalTimer() {
  return m_ProfileIntervalTimer;
}
 
void PosixProcess::reportTimesUpdated(Time::Timestamp userTotal, Time::Timestamp total) {
  m_VirtualIntervalTimer.consumeCpuTime(userTotal);
  m_ProfileIntervalTimer.consumeCpuTime(total);
}
 
void PosixProcess::processTerminated() {
  // Cancel all timers.
  m_RealIntervalTimer.disarm();
  m_VirtualIntervalTimer.disarm();
  m_ProfileIntervalTimer.disarm();
  posix_account_process_exit(*this, m_AccountingLifetime);
  TerminalControl::processTerminated(*this);
}
 
IntervalTimer::IntervalTimer(PosixProcess* pProcess, Mode mode)
    : m_Process(pProcess),
      m_Mode(mode),
      m_Value(0),
      m_Interval(0),
      m_LastTotal(0),
      m_Lock(false),
      m_Armed(false),
      m_pTimer(nullptr) {
  m_LastTotal = absoluteTotal();
  if (m_Mode == Hardware) {
    Timer* t = Machine::instance().getTimer();
    if (t && t->registerHandler(this)) {
      m_pTimer = t;
    } else {
      ERROR("IntervalTimer could not register its hardware callback");
    }
  }
}
 
IntervalTimer::~IntervalTimer() {
  if (m_pTimer) {
    if (!m_pTimer->unregisterHandler(this)) {
      FATAL("IntervalTimer could not drain its hardware callback");
    }
    m_pTimer = nullptr;
  }
}
 
void IntervalTimer::setInterval(Time::Timestamp interval, Time::Timestamp* prevInterval) {
  bool needsSignal = false;
  {
    LockGuard<Spinlock> guard(m_Lock);
    needsSignal = advanceTimeLocked(absoluteTotal());
 
    if (prevInterval) {
      *prevInterval = m_Interval;
    }
    m_Interval = interval;
    armHardwareLocked();
  }
  if (needsSignal) {
    signal();
  }
}
 
void IntervalTimer::setTimerValue(Time::Timestamp value, Time::Timestamp* prevValue) {
  bool needsSignal = false;
  {
    LockGuard<Spinlock> guard(m_Lock);
    needsSignal = advanceTimeLocked(absoluteTotal());
 
    if (prevValue) {
      *prevValue = m_Value;
    }
    m_Value = value;
    setArmedLocked(m_Value > 0);
    armHardwareLocked();
  }
  if (needsSignal) {
    signal();
  }
}
 
void IntervalTimer::setIntervalAndValue(Time::Timestamp interval, Time::Timestamp value,
                                        Time::Timestamp* prevInterval, Time::Timestamp* prevValue) {
  bool needsSignal = false;
  {
    LockGuard<Spinlock> guard(m_Lock);
    needsSignal = advanceTimeLocked(absoluteTotal());
 
    if (prevInterval) {
      *prevInterval = m_Interval;
    }
 
    if (prevValue) {
      *prevValue = m_Value;
    }
 
    m_Interval = interval;
    m_Value = value;
    setArmedLocked(m_Value > 0);
    armHardwareLocked();
  }
  if (needsSignal) {
    signal();
  }
}
 
void IntervalTimer::disarm() {
  LockGuard<Spinlock> guard(m_Lock);
  const Time::Timestamp current = absoluteTotal();
  if (current > m_LastTotal) {
    m_LastTotal = current;
  }
  m_Value = 0;
  m_Interval = 0;
  setArmedLocked(false);
  armHardwareLocked();
}
 
void IntervalTimer::getIntervalAndValue(Time::Timestamp& interval, Time::Timestamp& value) {
  bool needsSignal = false;
  {
    LockGuard<Spinlock> guard(m_Lock);
    needsSignal = advanceTimeLocked(absoluteTotal());
 
    interval = m_Interval;
    value = m_Value;
    armHardwareLocked();
  }
  if (needsSignal) {
    signal();
  }
}
 
void IntervalTimer::consumeCpuTime(Time::Timestamp absoluteTotal) {
  if (m_Mode == Hardware) {
    return;
  }
 
  bool needsSignal = false;
  {
    LockGuard<Spinlock> guard(m_Lock);
    needsSignal = advanceTimeLocked(absoluteTotal);
  }
 
  if (needsSignal) {
    signal();
  }
}
 
Time::Timestamp IntervalTimer::absoluteTotal() const {
  if (m_Mode == Hardware) {
    return Time::getTicks();
  }
  if (m_Mode == Virtual) {
    return m_Process->getUserTime();
  }
  if (m_Mode == Profile) {
    return m_Process->getUserTime() + m_Process->getKernelTime();
  }
  return 0;
}
 
bool IntervalTimer::advanceTimeLocked(Time::Timestamp absoluteTotal) {
  const PosixIntervalTimerState::AbsoluteConsumption result =
      PosixIntervalTimerState::consumeAbsolute(m_Value, m_Interval, m_Armed, m_LastTotal,
                                               absoluteTotal);
  m_Value = result.timer.value;
  setArmedLocked(result.timer.armed);
  m_LastTotal = result.baseline;
  return result.timer.expired;
}
 
void IntervalTimer::armHardwareLocked() {
  if (m_Mode != Hardware || !m_pTimer || !m_pTimer->supportsDeadlines()) {
    return;
  }
  const Time::Timestamp maximum = Time::Infinity - 1;
  const Time::Timestamp deadline =
      !m_Armed ? 0 : (m_Value > maximum - m_LastTotal ? maximum : m_LastTotal + m_Value);
  if (!m_pTimer->armHandler(this, deadline)) {
    FATAL("IntervalTimer could not arm its hardware callback");
  }
}
 
void IntervalTimer::setArmedLocked(bool armed) {
  if (m_Armed == armed) {
    return;
  }
  m_Armed = armed;
  if (m_Mode != Hardware) {
    m_Process->setTimeAccountingReportInterest(size_t(1) << m_Mode, armed);
  }
}
 
Time::Timestamp IntervalTimer::getInterval() const {
  return m_Interval;
}
 
Time::Timestamp IntervalTimer::getValue() const {
  return m_Value;
}
 
void IntervalTimer::timer(uint64_t delta) {
  (void)delta;
  if (m_Mode != Hardware) {
    return;
  }
 
  bool needsSignal = false;
  {
    LockGuard<Spinlock> guard(m_Lock);
 
    if (!m_Armed) {
      // Disarmed - ignore the timer event.
      return;
    }
 
    needsSignal = advanceTimeLocked(absoluteTotal());
    armHardwareLocked();
  }
 
  if (needsSignal) {
    signal();
  }
}
 
void IntervalTimer::signal() {
  int signal = -1;
  switch (m_Mode) {
    case Hardware:
      signal = SIGALRM;
      break;
    case Virtual:
      signal = SIGVTALRM;
      break;
    case Profile:
      signal = SIGPROF;
      break;
  }
 
  Scheduler::ProcessLease process;
  if (!Scheduler::instance().acquireProcess(process, m_Process)) {
    return;
  }
  PosixSubsystem* pSubsystem = static_cast<PosixSubsystem*>(process->getSubsystem());
  Process::ThreadLease target;
  const bool targetAcquired = process->acquireProcessSignalThread(target);
  if (!pSubsystem || !targetAcquired) {
    return;
  }
 
  // Don't yield in the middle of the timer handler
  pSubsystem->sendSignal(target.get(), signal, false, true);
}