Process.h

/*
 * 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.
 */
 
#ifndef PROCESS_H
#define PROCESS_H
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/Subsystem.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/DeferredTimeAccounting.h"
#include "pedigree/kernel/process/FilesystemContext.h"
#include "pedigree/kernel/process/FilesystemCredentials.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/OperationBarrier.h"
#include "pedigree/kernel/process/TerminationDeferral.h"
#include "pedigree/kernel/process/Thread.h"
#include "pedigree/kernel/process/Uninterruptible.h"
#include "pedigree/kernel/process/WaitQueue.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/MemoryAllocator.h"
#include "pedigree/kernel/utilities/SharedPointer.h"
#include "pedigree/kernel/utilities/StaticString.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/new"
 
#include <config.h>
 
class VirtualAddressSpace;
class File;
class User;
class Group;
class DynamicLinker;
class ZombieProcess;
class ZombieQueue;
class Scheduler;
 
class Process;
 
class EXPORTED_PUBLIC UserspacePidNamespace {
 public:
  explicit UserspacePidNamespace(const SharedPointer<UserspacePidNamespace>& parent = {})
      : m_Parent(parent), m_NextPid(0) {}
  size_t allocate() {
    return m_NextPid += 1;
  }
  const SharedPointer<UserspacePidNamespace>& parent() const {
    return m_Parent;
  }
  bool dead() const {
    return __atomic_load_n(&m_Dead, __ATOMIC_ACQUIRE);
  }
  void close() {
    __atomic_store_n(&m_Dead, true, __ATOMIC_RELEASE);
  }
  Process* init() const {
    return __atomic_load_n(&m_Init, __ATOMIC_ACQUIRE);
  }
  void setInit(Process* process) {
    __atomic_store_n(&m_Init, process, __ATOMIC_RELEASE);
  }
  size_t depth() const {
    return m_Parent ? m_Parent->depth() + 1 : 1;
  }
 
 private:
  SharedPointer<UserspacePidNamespace> m_Parent;
  Atomic<size_t> m_NextPid;
  Process* m_Init = nullptr;
  bool m_Dead = false;
};
 
class EXPORTED_PUBLIC UserspacePid {
 public:
  explicit UserspacePid(const SharedPointer<UserspacePidNamespace>& space);
  size_t id(const UserspacePidNamespace* space = nullptr) const;
  const SharedPointer<UserspacePidNamespace>& space() const {
    return m_Namespace;
  }
 
 private:
  SharedPointer<UserspacePidNamespace> m_Namespace;
  Vector<size_t> m_Ids;
};
 
class EXPORTED_PUBLIC Process {
  friend class PerProcessorScheduler;
  friend class Scheduler;
  friend class Thread;
  friend class ZombieProcess;
  friend class ZombieQueue;
 
 public:
  class EXPORTED_PUBLIC ExecScope {
   public:
    explicit ExecScope(Process& process, bool active = true);
    ~ExecScope();
    explicit operator bool() const {
      return m_bAdmitted;
    }
    bool commit();
    void adoptLeaderIdentity();
 
   private:
    ExecScope(const ExecScope&) = delete;
    ExecScope& operator=(const ExecScope&) = delete;
    Process* m_pProcess;
    bool m_bAdmitted;
    TerminationDeferral m_TerminationDeferral;
  };
 
  class EXPORTED_PUBLIC ThreadCreationScope {
   public:
    explicit ThreadCreationScope(Process& process);
    ~ThreadCreationScope();
    explicit operator bool() const {
      return m_pProcess != nullptr;
    }
 
   private:
    ThreadCreationScope(const ThreadCreationScope&) = delete;
    ThreadCreationScope& operator=(const ThreadCreationScope&) = delete;
    Process* m_pProcess;
    TerminationDeferral m_TerminationDeferral;
  };
 
  class EXPORTED_PUBLIC ReaperClaim {
   public:
    ReaperClaim();
    ReaperClaim(ReaperClaim&& other) noexcept;
    ~ReaperClaim();
 
    ReaperClaim& operator=(ReaperClaim&& other) noexcept;
 
    explicit operator bool() const {
      return m_pProcess != nullptr;
    }
 
    void publish();
 
   private:
    friend class Process;
    explicit ReaperClaim(Process* process);
 
    ReaperClaim(const ReaperClaim&) = delete;
    ReaperClaim& operator=(const ReaperClaim&) = delete;
 
    Process* m_pProcess;
    TerminationDeferral m_TerminationDeferral;
  };
 
  class EXPORTED_PUBLIC ThreadLease {
   public:
    ThreadLease();
    ThreadLease(ThreadLease&& other) noexcept;
    ~ThreadLease();
 
    ThreadLease& operator=(ThreadLease&& other) noexcept;
 
    Thread* get() const {
      return m_pThread;
    }
 
    Thread* operator->() const {
      return m_pThread;
    }
 
    explicit operator bool() const {
      return m_pThread != nullptr;
    }
 
    void reset();
 
   private:
    friend class Process;
 
    ThreadLease(Process* process, Thread* thread);
    ThreadLease(const ThreadLease&) = delete;
    ThreadLease& operator=(const ThreadLease&) = delete;
 
    Process* m_pProcess;
    Thread* m_pThread;
    TerminationDeferral m_TerminationDeferral;
  };
 
  class ControllingTerminal;
 
  class EXPORTED_PUBLIC FileContextLease {
   public:
    FileContextLease();
    ~FileContextLease();
 
    File* get() const {
      return m_pFile;
    }
    SharedPointer<ControllingTerminal> context() const {
      return m_Context;
    }
 
    File* operator->() const {
      return m_pFile;
    }
 
    explicit operator bool() const {
      return m_pFile != nullptr;
    }
 
    void reset();
 
   private:
    friend class Process;
 
    FileContextLease(const FileContextLease&) = delete;
    FileContextLease& operator=(const FileContextLease&) = delete;
    FileContextLease(FileContextLease&&) = delete;
    FileContextLease& operator=(FileContextLease&&) = delete;
 
    File* m_pFile;
    TerminationDeferral m_TerminationDeferral;
    SharedPointer<ControllingTerminal> m_Context;
  };
 
  class EXPORTED_PUBLIC TerminalOwnerReservation {
   public:
    TerminalOwnerReservation();
    TerminalOwnerReservation(TerminalOwnerReservation&& other) noexcept;
    ~TerminalOwnerReservation();
 
    TerminalOwnerReservation& operator=(TerminalOwnerReservation&& other) noexcept;
 
    explicit operator bool() const {
      return m_pProcess != nullptr;
    }
 
    void install(Thread* owner);
 
   private:
    friend class Process;
 
    TerminalOwnerReservation(const TerminalOwnerReservation&) = delete;
    TerminalOwnerReservation& operator=(const TerminalOwnerReservation&) = delete;
 
    Process* m_pProcess;
    TerminationDeferral m_TerminationDeferral;
  };
 
  enum ProcessType { Stock, Posix };
 
  enum ProcessState {
    Active,
    Suspended,
    Terminating,
    Terminated,  
    Reaped,      
  };
 
#if PEDIGREE_BENCHMARK_SYSCALL_TRACE
  void setBenchmarkSyscallTrace(bool enabled) {
    __atomic_store_n(&m_BenchmarkSyscallTrace, enabled, __ATOMIC_RELEASE);
  }
 
  bool benchmarkSyscallTraceEnabled() const {
    return __atomic_load_n(&m_BenchmarkSyscallTrace, __ATOMIC_ACQUIRE);
  }
#endif
 
#if PEDIGREE_BENCHMARK_SYSCALL_TIMING
  static constexpr size_t SyscallTimingRawSlotCount = 512;
  static constexpr size_t SyscallTimingOverflowSlot = SyscallTimingRawSlotCount;
  static constexpr size_t SyscallTimingSlotCount = SyscallTimingRawSlotCount + 1;
 
  struct SyscallTimingEntry {
    uint64_t calls;
    uint64_t kernelNanoseconds;
  };
 
  static size_t syscallTimingSlot(size_t rawNumber) {
    return rawNumber < SyscallTimingRawSlotCount ? rawNumber : SyscallTimingOverflowSlot;
  }
 
  void setBenchmarkSyscallTiming(bool enabled) {
    __atomic_store_n(&m_BenchmarkSyscallTiming, enabled, __ATOMIC_RELEASE);
  }
 
  bool benchmarkSyscallTimingEnabled() const {
    return __atomic_load_n(&m_BenchmarkSyscallTiming, __ATOMIC_ACQUIRE);
  }
 
  void recordSyscallTimingCall(size_t slot) {
    __atomic_fetch_add(&m_SyscallTimingCalls[slot], static_cast<uint64_t>(1), __ATOMIC_RELAXED);
  }
 
  void recordSyscallTimingKernel(size_t slot, Time::Timestamp elapsed) {
    __atomic_fetch_add(&m_SyscallTimingKernelNanoseconds[slot], elapsed, __ATOMIC_RELAXED);
  }
 
  void getSyscallTimingEntry(size_t slot, SyscallTimingEntry& result) const {
    result.calls = __atomic_load_n(&m_SyscallTimingCalls[slot], __ATOMIC_ACQUIRE);
    result.kernelNanoseconds =
        __atomic_load_n(&m_SyscallTimingKernelNanoseconds[slot], __ATOMIC_ACQUIRE);
  }
#endif
 
#if PEDIGREE_BENCHMARK_VM_DIAGNOSTICS
  enum BenchmarkVmCounter : size_t {
    VmMmapCalls,
    VmMmapAnonymousCalls,
    VmMmapFileCalls,
    VmMmapPages,
    VmMmapLength1,
    VmMmapLength2To3,
    VmMmapLength4To15,
    VmMmapLength16To63,
    VmMmapLength64To255,
    VmMmapLength256Plus,
    VmPublishCalls,
    VmPublishObjectCount,
    VmPublishOverlapProbeVisits,
    VmPublishOverlapHits,
    VmPublishCommitRetries,
    VmReservationSnapshots,
    VmReservationExtents,
    VmReservationScratchAllocations,
    VmMunmapCalls,
    VmMunmapPages,
    VmMunmapLength1,
    VmMunmapLength2To3,
    VmMunmapLength4To15,
    VmMunmapLength16To63,
    VmMunmapLength64To255,
    VmMunmapLength256Plus,
    VmRemoveCalls,
    VmRemoveObjectCount,
    VmRemoveObjectVisits,
    VmRemoveSliceCalls,
    VmRemoveAffectedObjects,
    VmAllowsCalls,
    VmAllowsObjectCount,
    VmAllowsObjectVisits,
    VmFaultInRangeCalls,
    VmFaultInRangePages,
    VmFaultInObjectVisits,
    VmFaultInPresent,
    VmFaultInCopyOnWrite,
    VmFaultInTrap,
    VmFaultCalls,
    VmFaultObjectCount,
    VmFaultObjectVisits,
    VmFaultResolved,
    VmFaultBacking,
    VmFaultUnhandled,
    VmGuardEntries,
    VmGuardRecursiveEntries,
    VmDiscardTrackedPages,
    VmDiscardMappedPages,
    VmTableRetirementScans,
    VmDetachPteEntries,
    VmDetachPdeEntries,
    VmDetachPdptEntries,
    VmDetachTables,
    VmInvalidationActive,
    VmInvalidationInactive,
    BenchmarkVmCounterCount,
  };
 
  void setBenchmarkVmDiagnostics(bool enabled) {
    __atomic_store_n(&m_BenchmarkVmDiagnostics, enabled, __ATOMIC_RELEASE);
  }
 
  bool benchmarkVmDiagnosticsEnabled() const {
    return __atomic_load_n(&m_BenchmarkVmDiagnostics, __ATOMIC_ACQUIRE);
  }
 
  void recordBenchmarkVmCounter(BenchmarkVmCounter counter, uint64_t amount = 1) {
    if (benchmarkVmDiagnosticsEnabled() && amount) {
      __atomic_fetch_add(&m_BenchmarkVmCounters[counter], amount, __ATOMIC_RELAXED);
    }
  }
 
  uint64_t getBenchmarkVmCounter(size_t counter) const {
    return __atomic_load_n(&m_BenchmarkVmCounters[counter], __ATOMIC_ACQUIRE);
  }
#endif
 
  Process();
 
  Process(Process* pParent, bool bCopyOnWrite = true);
 
  virtual ~Process();
 
  size_t addThread(Thread* pThread);
  void threadExiting(Thread* pThread);
  void transferExecProcessSignals(Thread* pThread);
  void removeThread(Thread* pThread);
 
  size_t getNumThreads();
  MUST_USE_RESULT bool acquireThread(ThreadLease& lease, size_t n);
 
  MUST_USE_RESULT bool acquireProcessSignalThread(ThreadLease& lease);
 
  MUST_USE_RESULT bool acquireThreadById(ThreadLease& lease, size_t id);
 
  MUST_USE_RESULT bool acquireThreadByTaskId(ThreadLease& lease, size_t id);
  MUST_USE_RESULT bool acquireThreadByUserspaceId(ThreadLease& lease, size_t id,
                                                  const UserspacePidNamespace* space);
 
  MUST_USE_RESULT bool acquireThread(ThreadLease& lease, Thread* expected);
 
  TerminalOwnerReservation reserveTerminalOwner();
 
  size_t getId() {
    return m_Id;
  }
 
  size_t getUserspaceId() const {
    return m_UserspacePid ? m_UserspacePid->id() : 0;
  }
 
  size_t getUserspaceId(const UserspacePidNamespace* space) const {
    return m_UserspacePid ? m_UserspacePid->id(space) : 0;
  }
  SharedPointer<UserspacePidNamespace> pidNamespace() const {
    return m_UserspaceNamespace;
  }
  SharedPointer<UserspacePid> pidIdentity() const {
    return m_UserspacePid;
  }
  SharedPointer<UserspacePidNamespace> pidNamespaceForChildren();
  static SharedPointer<UserspacePidNamespace> rootPidNamespace();
  bool createPidNamespace();
  bool unsharePidNamespace();
  bool unsharePidNamespace(const SharedPointer<UserspacePidNamespace>& prepared);
  bool pidNamespaceReady() const;
 
  LargeStaticString& description() {
    return str;
  }
 
  VirtualAddressSpace* getAddressSpace() {
    return m_pAddressSpace;
  }
 
  class EXPORTED_PUBLIC VforkCompletion {
   public:
    void wait();
    void complete();
 
   private:
    WaitQueue m_Waiters;
    bool m_Complete = false;
  };
 
  Process* addressSpaceOwner() {
    return m_pVforkOwner ? m_pVforkOwner : this;
  }
  bool isVforkChild() const {
    return m_pVforkOwner != nullptr;
  }
  void borrowVforkAddressSpace(Process& parent, const SharedPointer<VforkCompletion>& completion);
  void releaseVforkAddressSpace();
 
  void setExitStatus(int code) {
    m_ExitStatus = code;
  }
  int getExitStatus() {
    return m_ExitStatus;
  }
 
  enum class ChildTransitionKind {
    None,
    Stopped,
    Continued,
  };
 
  struct ChildTransition {
    ChildTransition() : kind(ChildTransitionKind::None), stopSignal(0) {}
 
    ChildTransitionKind kind;
    int stopSignal;
  };
 
  void reap();
 
  bool prepareThreadExit();
 
  bool beginTermination(int code = 0, Subsystem::ExitCause cause = Subsystem::ExitCause::Normal);
 
  bool quiesceTermination();
 
  void finishTermination(bool notifyParent = false) NORETURN;
 
  ReaperClaim tryClaimReaper();
 
  void kill() NORETURN;
  void suspend(int stopSignal = 0);
  void suspendIfContinuationEpoch(int stopSignal, size_t continuationEpoch);
  void resume();
 
  size_t getContinuationEpoch();
 
  Process* getParent() {
    return __atomic_load_n(&m_pParent, __ATOMIC_ACQUIRE);
  }
 
  enum class FilesystemContextMode { Inherit, Deferred };
 
  FilesystemContextRef acquireFilesystemContext() const;
  MUST_USE_RESULT bool installFilesystemContext(FilesystemContextOwner&& context);
  bool replaceFilesystemContext(FilesystemContextOwner&& replacement,
                                const FilesystemContextRef& expected);
  bool filesystemContextReady() const;
  void releaseFilesystemContext();
 
  class EXPORTED_PUBLIC ControllingTerminal {
   public:
    virtual ~ControllingTerminal() = default;
    virtual File* file() const = 0;
  };
 
  SharedPointer<ControllingTerminal> acquireCttyContext() const;
  MUST_USE_RESULT File* acquireCtty(FileContextLease& lease) const;
  void setCttyContext(const SharedPointer<ControllingTerminal>& context);
  MUST_USE_RESULT bool setCtty(File* file);
 
  enum class UserRegion { Normal, Dynamic };
 
  struct UserReservationSnapshot {
    UserReservationSnapshot() : normal(false), dynamic(false), generation(0) {}
    MemoryAllocator normal;
    MemoryAllocator dynamic;
    uint64_t generation;
  };
 
  bool snapshotUserReservations(UserReservationSnapshot& result);
  bool commitUserReservations(uint64_t expectedGeneration, UserReservationSnapshot& replacement);
  bool allocateUserRange(UserRegion region, size_t length, uintptr_t& address);
  bool allocateSpecificUserRange(UserRegion region, uintptr_t address, size_t length);
  void freeUserRange(UserRegion region, uintptr_t address, size_t length);
  void resetUserReservations();
 
  virtual bool snapshotFilesystemCredentials(const Thread* task, FilesystemCredentials& out) const;
  static bool currentFilesystemCredentials(FilesystemCredentials& out);
  void inheritFilesystemIds(Thread& child, const Thread* creator) const;
  virtual bool installUserIdentity(User*, Group*, const uint32_t* groups, size_t count);
 
  class EXPORTED_PUBLIC FilesystemAccessScope {
   public:
    explicit FilesystemAccessScope(const FilesystemCredentials& credentials);
    ~FilesystemAccessScope();
 
   private:
    FilesystemAccessScope(const FilesystemAccessScope&) = delete;
    FilesystemAccessScope& operator=(const FilesystemAccessScope&) = delete;
    Uninterruptible m_Events;
    TerminationDeferral m_Termination;
    FilesystemCredentials m_Credentials;
    Thread* m_Thread;
    const FilesystemCredentials* m_Previous;
  };
 
  User* getUser() const;
  void setUser(User* pUser);
 
  User* getEffectiveUser() const;
  void setEffectiveUser(User* pUser);
 
  Group* getGroup() const;
  void setGroup(Group* pGroup);
 
  Group* getEffectiveGroup() const;
  void setEffectiveGroup(Group* pGroup);
 
  virtual int64_t getUserId() const;
  virtual int64_t getGroupId() const;
  virtual int64_t getEffectiveUserId() const;
  virtual int64_t getEffectiveGroupId() const;
  virtual void getSupplementalGroupIds(Vector<int64_t>& vec) const;
  virtual void setUserId(int64_t id);
  virtual void setGroupId(int64_t id);
  virtual void setEffectiveUserId(int64_t id);
  virtual void setEffectiveGroupId(int64_t id);
 
  void setLinker(DynamicLinker* pDl) {
    m_pDynamicLinker = pDl;
  }
  DynamicLinker* getLinker() {
    return m_pDynamicLinker;
  }
 
  void setSubsystem(Subsystem* pSubsystem) {
    m_pSubsystem = pSubsystem;
    m_pSubsystem->setProcess(this);
  }
  Subsystem* getSubsystem() {
    return m_pSubsystem;
  }
 
  ProcessType getType() const {
    return m_Type;
  }
 
  WaitQueue::Guard acquireChildStateWait() {
    return m_ChildStateWaiters.acquire();
  }
 
  bool waitUntilTerminationReapable();
 
  bool waitUntilTerminationReapableForTerminalCoordinator();
 
  bool selectPendingChildTransition(bool includeStopped, bool includeContinued, bool consume,
                                    ChildTransition& transition);
 
  bool takePendingChildTransition(bool includeStopped, bool includeContinued,
                                  ChildTransition& transition);
 
  ProcessState getState() const {
    return __atomic_load_n(&m_State, __ATOMIC_ACQUIRE);
  }
 
  bool isSuspended() {
    return getState() == Suspended;
  }
 
  void markTerminating();
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using TerminationElectionHook = void (*)(Process*, Thread*);
  static void setTerminationElectionHook(TerminationElectionHook hook);
 
  enum ExternalLeaseReleasePhase {
    ExternalLeaseFinalReleaseUnlocked,
    ExternalLeaseBeforeWaiterWake,
  };
  using ExternalLeaseReleaseHook = void (*)(Process*, ExternalLeaseReleasePhase);
  static void setExternalLeaseReleaseHookForHostedTest(Process* target,
                                                       ExternalLeaseReleaseHook hook);
 
  bool isTerminationReapableForHostedTest();
 
  enum class OrphanPublicationPhase {
    Preparing,
    Published,
  };
  using OrphanPublicationHook = void (*)(Process*, OrphanPublicationPhase, bool interruptsEnabled,
                                         bool processLockHeld);
  static void setOrphanPublicationHook(OrphanPublicationHook hook);
 
  void publishTimeAccountingForHostedTest(Time::Timestamp user, Time::Timestamp system);
 
  void closeTimeAccountingForHostedTest();
 
  bool timeAccountingPendingForHostedTest() const {
    return m_DeferredTimeAccounting.pending();
  }
  size_t timeAccountingInterestForHostedTest() const {
    return __atomic_load_n(&m_TimeAccountingReportInterest, __ATOMIC_ACQUIRE);
  }
#endif
 
  void trackHeap(ssize_t nBytes) {
    __atomic_fetch_add(&m_Metadata.heapUsage, nBytes, __ATOMIC_RELAXED);
  }
 
  void trackPages(ssize_t nVirtual, ssize_t nPhysical, ssize_t nShared) {
    __atomic_fetch_add(&m_Metadata.virtualPages, nVirtual, __ATOMIC_RELAXED);
    __atomic_fetch_add(&m_Metadata.physicalPages, nPhysical, __ATOMIC_RELAXED);
    __atomic_fetch_add(&m_Metadata.sharedPages, nShared, __ATOMIC_RELAXED);
  }
 
  void resetCounts() {
    __atomic_store_n(&m_Metadata.virtualPages, static_cast<ssize_t>(0), __ATOMIC_RELEASE);
    __atomic_store_n(&m_Metadata.physicalPages, static_cast<ssize_t>(0), __ATOMIC_RELEASE);
    __atomic_store_n(&m_Metadata.sharedPages, static_cast<ssize_t>(0), __ATOMIC_RELEASE);
    __atomic_store_n(&m_Metadata.startTime, Time::getTimeNanoseconds(), __ATOMIC_RELEASE);
  }
 
  Time::Timestamp getUserTime() const {
    return totalTime(CpuTimeMode::User);
  }
  Time::Timestamp getKernelTime() const {
    return totalTime(CpuTimeMode::Kernel);
  }
  Time::Timestamp getReapedChildrenUserTime() const {
    return __atomic_load_n(&m_Metadata.reapedChildrenUserTime, __ATOMIC_ACQUIRE);
  }
  Time::Timestamp getReapedChildrenKernelTime() const {
    return __atomic_load_n(&m_Metadata.reapedChildrenKernelTime, __ATOMIC_ACQUIRE);
  }
 
#if PEDIGREE_SYSCALL_COUNTER
  static constexpr size_t SyscallLatencyBucketCount = 16;
 
  struct SyscallLatencySnapshot {
    uint64_t buckets[SyscallLatencyBucketCount];
  };
 
  void recordSyscall() {
    __atomic_fetch_add(&m_Metadata.syscallCount, static_cast<uint64_t>(1), __ATOMIC_RELAXED);
  }
 
  void recordSyscallDuration(Time::Timestamp duration) {
    size_t bucket = 0;
    Time::Timestamp limit = Time::Multiplier::Microsecond;
    while (bucket + 1 < SyscallLatencyBucketCount && duration >= limit) {
      ++bucket;
      limit <<= 1;
    }
    __atomic_fetch_add(&m_Metadata.syscallLatencyBuckets[bucket], static_cast<uint64_t>(1),
                       __ATOMIC_RELAXED);
  }
 
  uint64_t getSyscallCount() const {
    return __atomic_load_n(&m_Metadata.syscallCount, __ATOMIC_ACQUIRE);
  }
 
  uint64_t getReapedChildrenSyscallCount() const {
    return __atomic_load_n(&m_Metadata.reapedChildrenSyscallCount, __ATOMIC_ACQUIRE);
  }
 
  void getSyscallLatencySnapshot(SyscallLatencySnapshot& snapshot) const {
    for (size_t i = 0; i < SyscallLatencyBucketCount; ++i) {
      snapshot.buckets[i] =
          __atomic_load_n(&m_Metadata.syscallLatencyBuckets[i], __ATOMIC_ACQUIRE) +
          __atomic_load_n(&m_Metadata.reapedChildrenSyscallLatencyBuckets[i], __ATOMIC_ACQUIRE);
    }
  }
 
  void getReapedChildrenSyscallLatencySnapshot(SyscallLatencySnapshot& snapshot) const {
    for (size_t i = 0; i < SyscallLatencyBucketCount; ++i) {
      snapshot.buckets[i] =
          __atomic_load_n(&m_Metadata.reapedChildrenSyscallLatencyBuckets[i], __ATOMIC_ACQUIRE);
    }
  }
#endif
 
  void accountReapedChild(const Process* child, Time::Timestamp& user, Time::Timestamp& kernel);
 
  Time::Timestamp getStartTime() const {
    return __atomic_load_n(&m_Metadata.startTime, __ATOMIC_ACQUIRE);
  }
 
  ssize_t getHeapUsage() const {
    return __atomic_load_n(&m_Metadata.heapUsage, __ATOMIC_ACQUIRE);
  }
  ssize_t getVirtualPageCount() const {
    return __atomic_load_n(&m_Metadata.virtualPages, __ATOMIC_ACQUIRE);
  }
  ssize_t getPhysicalPageCount() const {
    return __atomic_load_n(&m_Metadata.physicalPages, __ATOMIC_ACQUIRE);
  }
  ssize_t getSharedPageCount() const {
    return __atomic_load_n(&m_Metadata.sharedPages, __ATOMIC_ACQUIRE);
  }
 
  bool hasSharedAddressSpace() const {
    return m_bSharedAddressSpace;
  }
 
  static Process* getInit();
 
  static void setInit(Process* pProcess);
 
 protected:
  mutable Spinlock m_CredentialLock;
  static bool loadFilesystemIds(const Thread&, uint32_t& uid, uint32_t& gid);
  static void publishFilesystemIds(Thread&, uint32_t uid, uint32_t gid);
  void publishAccountIdentity(User*, Group*);
 
  struct DeferredPublication {};
 
  Process(DeferredPublication, ProcessType type = Stock);
  Process(DeferredPublication, Process* pParent, bool bCopyOnWrite = true,
          FilesystemContextMode filesystemContext = FilesystemContextMode::Inherit,
          bool emptyAddressSpace = false, ProcessType type = Stock);
 
  void publish();
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  void makeOrphanBeforePublicationForHostedTest();
#endif
 
  void prepareForDestruction();
 
  void enableTimeAccountingReports(size_t initialInterest = ~size_t(0));
 
  void setTimeAccountingReportInterest(size_t interest, bool enabled);
 
 private:
  void finishTermination(bool abandonStack, bool notifyParent) NORETURN;
 
  Process(const Process&);
  Process& operator=(const Process&);
 
  virtual void reportTimesUpdated(Time::Timestamp userTotal, Time::Timestamp total) {}
 
  void drainDeferredTimeAccounting();
 
  void closeDeferredTimeAccounting();
 
  Time::Timestamp totalTime(CpuTimeMode mode) const;
 
  ALWAYS_INLINE void reportTimeAccounting(Time::Timestamp elapsed) {
    // Most processes have no armed CPU-time timer. Keep that path free of
    // worker publication and its lifecycle-admission load.
    if (__atomic_load_n(&m_TimeAccountingReportInterest, __ATOMIC_ACQUIRE) &&
        __atomic_load_n(&m_bTimeAccountingReportsEnabled, __ATOMIC_ACQUIRE)) {
      queueTimeAccountingReport(elapsed);
    }
  }
 
  void queueTimeAccountingReport(Time::Timestamp elapsed);
 
  virtual void processTerminated() {}
 
  Vector<Thread*> m_Threads;
  Atomic<size_t> m_NextTid;
  size_t m_Id;
  SharedPointer<UserspacePidNamespace> m_UserspaceNamespace;
  SharedPointer<UserspacePid> m_UserspacePid;
  SharedPointer<UserspacePidNamespace> m_ChildrenPidNamespace;
  LargeStaticString str;
  Process* m_pParent;
  VirtualAddressSpace* m_pAddressSpace;
  VirtualAddressSpace* m_pVforkPrivateAddressSpace = nullptr;
  Process* m_pVforkOwner = nullptr;
  SharedPointer<VforkCompletion> m_VforkCompletion;
  int m_ExitStatus;
  mutable Mutex m_FilesystemContextLock;
  FilesystemContextOwner m_FilesystemContext;
  bool m_bFilesystemContextReady;
  SharedPointer<ControllingTerminal> m_Ctty;
  MemoryAllocator m_SpaceAllocator;
  MemoryAllocator m_DynamicSpaceAllocator;
  Spinlock m_UserReservationLock;
  uint64_t m_UserReservationGeneration;
 
#if PEDIGREE_BENCHMARK_SYSCALL_TIMING
  bool m_BenchmarkSyscallTiming = false;
  uint64_t m_SyscallTimingCalls[SyscallTimingSlotCount] = {};
  uint64_t m_SyscallTimingKernelNanoseconds[SyscallTimingSlotCount] = {};
#endif
 
#if PEDIGREE_BENCHMARK_SYSCALL_TRACE
  bool m_BenchmarkSyscallTrace = false;
#endif
 
#if PEDIGREE_BENCHMARK_VM_DIAGNOSTICS
  bool m_BenchmarkVmDiagnostics = false;
  uint64_t m_BenchmarkVmCounters[BenchmarkVmCounterCount] = {};
#endif
 
  FilesystemCredentials m_NativeFilesystemCredentials;
  User* m_pUser;
  Group* m_pGroup;
  User* m_pEffectiveUser;
  Group* m_pEffectiveGroup;
 
  DynamicLinker* m_pDynamicLinker;
 
  Subsystem* m_pSubsystem;
 
  WaitQueue m_ChildStateWaiters;
 
  WaitQueue m_TerminationWaiters;
 
  WaitQueue m_SuspensionWaiters;
 
  size_t m_ContinuationEpoch;
 
  WaitQueue m_ThreadJoinWaiters;
 
  size_t m_nThreadJoinOperations;
 
  bool m_bThreadJoinAdmissionClosed;
 
  Spinlock m_ExternalLeaseLock;
 
  WaitQueue m_ExternalLeaseWaiters;
 
  size_t m_nExternalLeases;
 
  bool m_bExternalLeaseAdmissionClosed;
 
  bool m_bExternalLeaseReleaseInProgress;
 
  ChildTransition m_PendingChildTransition;
 
  ProcessState m_State;
 
  // Construction selects the actual class, independently of the parent's type.
  const ProcessType m_Type;
 
  bool transitionState(ProcessState expected, ProcessState desired);
 
  void suspendInternal(int stopSignal, bool checkContinuationEpoch, size_t continuationEpoch);
 
  void transitionToTerminating();
 
  bool m_bDestroying;
 
  bool m_bPublished;
 
  bool m_bUnregistered;
 
  Thread* m_pTerminatingThread;
 
  Thread* m_pExecOwner = nullptr;
  bool m_bExecCommitted = false;
  bool m_bExecExitForwarded = false;
  size_t m_nThreadCreations = 0;
  WaitQueue m_ExecWaiters;
 
  size_t m_nTerminationParticipants;
 
  bool m_bTerminationRendezvousStarted;
 
  bool m_bTerminalOwnerReserved;
 
  Thread* m_pReservedTerminalOwner;
 
  bool m_bTerminationCleanupStarted;
 
  bool m_bTerminationSealed;
 
  bool m_bTerminationReapable;
 
  enum ReaperState {
    ReaperUnclaimed,
    ReaperClaimed,
    ReaperPublished,
  };
 
  size_t m_ReaperState;
 
  Spinlock m_Lock;
 
  mutable Spinlock m_TimeAccountingLock;
 
  bool terminatingThreadReapable(Thread* pThread, bool& wakeOwner);
 
  void publishTerminationStatus(bool notifyParent);
 
  void publishTerminationReapable();
 
  void publishReaperClaim();
 
  bool beginThreadJoin();
 
  void endThreadJoin();
 
  bool beginExternalLease();
 
  void endExternalLease();
 
  void closeExternalLeaseAdmission();
 
  void drainExternalLeases();
 
  void releaseThreadLease(Thread* thread);
 
  void installTerminalOwner(Thread* owner);
 
  struct ProcessMetadata {
#if PEDIGREE_SYSCALL_COUNTER
    ProcessMetadata()
        : heapUsage(0),
          virtualPages(0),
          physicalPages(0),
          sharedPages(0),
          userTime(0),
          kernelTime(0),
          reapedChildrenUserTime(0),
          reapedChildrenKernelTime(0),
          syscallCount(0),
          reapedChildrenSyscallCount(0),
          syscallLatencyBuckets{},
          reapedChildrenSyscallLatencyBuckets{},
          startTime(0) {}
#else
    ProcessMetadata()
        : heapUsage(0),
          virtualPages(0),
          physicalPages(0),
          sharedPages(0),
          userTime(0),
          kernelTime(0),
          reapedChildrenUserTime(0),
          reapedChildrenKernelTime(0),
          startTime(0) {}
#endif
 
    ssize_t heapUsage;
    ssize_t virtualPages;
    ssize_t physicalPages;
    ssize_t sharedPages;
 
    Time::Timestamp userTime;
    Time::Timestamp kernelTime;
    Time::Timestamp reapedChildrenUserTime;
    Time::Timestamp reapedChildrenKernelTime;
 
#if PEDIGREE_SYSCALL_COUNTER
    uint64_t syscallCount;
    uint64_t reapedChildrenSyscallCount;
    uint64_t syscallLatencyBuckets[SyscallLatencyBucketCount];
    uint64_t reapedChildrenSyscallLatencyBuckets[SyscallLatencyBucketCount];
#endif
 
    Time::Timestamp startTime;
  } m_Metadata;
 
  DeferredTimeAccounting m_DeferredTimeAccounting;
 
  OperationBarrier m_TimeAccountingReports;
 
  OperationBarrier m_DeferredThreadReaps;
 
  bool m_bTimeAccountingReportsEnabled;
 
  size_t m_TimeAccountingReportInterest;
 
  bool m_bSharedAddressSpace;
 
  static Process* m_pInitProcess;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static TerminationElectionHook m_TerminationElectionHook;
  static ExternalLeaseReleaseHook m_ExternalLeaseReleaseHook;
  static Process* m_ExternalLeaseReleaseTarget;
  static OrphanPublicationHook m_OrphanPublicationHook;
#endif
};
 
#endif