PosixSubsystem.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 POSIX_SUBSYSTEM_H
#define POSIX_SUBSYSTEM_H
 
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/Subsystem.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Completion.h"
#include "pedigree/kernel/process/ConditionVariable.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/Rcu.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/process/SignalEvent.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/ExtensibleBitmap.h"
#include "pedigree/kernel/utilities/RadixTree.h"
#include "pedigree/kernel/utilities/SharedPointer.h"
#include "pedigree/kernel/utilities/Tree.h"
#include "pedigree/kernel/utilities/UnlikelyLock.h"
#include "pedigree/kernel/utilities/Vector.h"
 
#include "ResolvedPath.h"
#include "modules/subsys/posix/FileDescriptor.h"
#include "modules/subsys/posix/PosixMemoryLockAccount.h"
#include "modules/subsys/posix/logging.h"
#include "modules/subsys/posix/queued-signal.h"
#include "modules/subsys/posix/trace-context.h"
#include "modules/subsys/posix/uts-namespace.h"
#include "modules/system/vfs/Directory.h"
 
class File;
class Filesystem;
class UnixSocket;
class PosixSubsystem;
class ProcessGroup;
class String;
 
class DescriptorLease {
 public:
  DescriptorLease() : m_Descriptor() {}
 
  DescriptorLease(DescriptorLease&& other) noexcept
      : m_Descriptor(pedigree_std::move(other.m_Descriptor)) {}
 
  DescriptorLease& operator=(DescriptorLease&& other) noexcept {
    if (this != &other) {
      m_Descriptor = pedigree_std::move(other.m_Descriptor);
    }
    return *this;
  }
 
  DescriptorLease(const DescriptorLease&) = delete;
  DescriptorLease& operator=(const DescriptorLease&) = delete;
 
  FileDescriptor* operator->() const {
    return m_Descriptor.operator->();
  }
 
  FileDescriptor& operator*() const {
    return *m_Descriptor;
  }
 
  explicit operator bool() const {
    return static_cast<bool>(m_Descriptor);
  }
 
  void reset() {
    m_Descriptor.reset();
  }
 
 private:
  friend class PosixSubsystem;
  friend bool acquireDescriptor(int fd, DescriptorLease& descriptor);
  friend bool removeDescriptor(int fd, const DescriptorLease& descriptor);
  friend size_t installDescriptor(FileDescriptor* descriptor, DescriptorLease& lease);
 
  void retain(const SharedPointer<FileDescriptor>& descriptor) {
    m_Descriptor = descriptor;
  }
 
  SharedPointer<FileDescriptor> m_Descriptor;
};
 
extern PosixSubsystem* getSubsystem();
extern bool acquireDescriptor(int fd, DescriptorLease& descriptor);
extern void addDescriptor(int fd, FileDescriptor* f);
extern size_t installDescriptor(FileDescriptor* descriptor, DescriptorLease& lease);
extern bool removeDescriptor(int fd, const DescriptorLease& descriptor);
extern size_t getAvailableDescriptor();
 
// Grabs a subsystem for use.
#define GRAB_POSIX_SUBSYSTEM(returnValue)      \
  PosixSubsystem* pSubsystem = getSubsystem(); \
  if (!pSubsystem) {                           \
    return (returnValue);                      \
  }
#define GRAB_POSIX_SUBSYSTEM_NORET             \
  PosixSubsystem* pSubsystem = getSubsystem(); \
  if (!pSubsystem) {                           \
    return;                                    \
  }
 
class ProcessGroupManager {
 public:
  ProcessGroupManager();
  virtual ~ProcessGroupManager();
 
  static ProcessGroupManager& instance() {
    return m_Instance;
  }
 
  size_t allocateGroupId();
 
  void setGroupId(size_t gid);
 
  bool isGroupIdValid(size_t gid) const;
 
  void returnGroupId(size_t gid);
 
  void registerGroup(size_t gid, ProcessGroup* group);
  void unregisterGroup(size_t gid, ProcessGroup* group);
 
  ProcessGroup* findGroup(size_t gid) const;
  ProcessGroup* findGroup(size_t gid, const UserspacePidNamespace* space) const;
 
  Spinlock& lock() {
    return m_GroupLock;
  }
 
 private:
  static ProcessGroupManager m_Instance;
  ExtensibleBitmap m_GroupIds;
  ProcessGroup* m_Groups;
 
  mutable Spinlock m_GroupLock;
};
 
class EXPORTED_PUBLIC PosixSubsystem : public Subsystem {
 public:
  enum class DescriptorDuplicationResult { Success, BadSource, TargetBusy };
 
  static const size_t SafeRegion = 0x0;  // Region check is always done.
  static const size_t SafeRead = 0x1;
  static const size_t SafeWrite = 0x2;
  static const size_t SafeExecute = 0x4;
 
  static constexpr size_t LinuxPrivateSignalFirst = 32;
  static constexpr size_t MaximumSupportedSignal = 64;
  static constexpr size_t SignalDispositionCount = MaximumSupportedSignal + 1;
 
  enum Abi {
    PosixAbi = 0,
    LinuxAbi = 1,
  };
 
  PosixSubsystem()
      : Subsystem(Posix),
        m_SignalHandlers(),
        m_SignalHandlersLock(),
        m_AdvisoryOwner(AdvisoryOwner::Kind::Process),
        m_FdMap(),
        m_FdEntries(),
        m_NextFd(0),
        m_FdLock(),
        m_FdBitmap(),
        m_LastFd(0),
        m_FreeCount(1),
        m_SyncObjects(),
        m_Threads(),
        m_ThreadWaiters(),
        m_NextThreadWaiter(0),
        m_ImageMetadataLock(),
        m_ExecutablePath(),
        m_CommandLine(),
        m_Abi(PosixAbi),
        m_bAcquired(false),
        m_pAcquiredThread(nullptr) {}
 
  PosixSubsystem(PosixSubsystem& s, bool clearSignalHandlers = false);
 
  PosixSubsystem(SubsystemType type)
      : Subsystem(type),
        m_SignalHandlers(),
        m_SignalHandlersLock(),
        m_AdvisoryOwner(AdvisoryOwner::Kind::Process),
        m_FdMap(),
        m_FdEntries(),
        m_NextFd(0),
        m_FdLock(),
        m_FdBitmap(),
        m_LastFd(0),
        m_FreeCount(1),
        m_SyncObjects(),
        m_Threads(),
        m_ThreadWaiters(),
        m_NextThreadWaiter(0),
        m_ImageMetadataLock(),
        m_ExecutablePath(),
        m_CommandLine(),
        m_Abi(PosixAbi),
        m_bAcquired(false),
        m_pAcquiredThread(nullptr) {}
 
  SharedPointer<PosixNamespaceContext> namespaceContext() const {
    return m_Namespaces;
  }
 
  bool executablePath(String& result) const;
  bool executablePath(FilesystemPathRef& result) const;
  bool commandLine(Vector<String>& result) const;
 
  PosixTraceContext& traceContext() {
    return m_TraceContext;
  }
  bool tracePolicyAllowed() const {
    return affinityPolicyAllowed() && m_Abi == LinuxAbi;
  }
  UserReturnResult userReturnCheckpoint(Thread&, UserReturnFrame&) override;
  UserReturnEventResult userReturnEvent(Thread&, Event&, UserReturnFrame&) override;
  bool traceException(Thread&, int& signal, InterruptState&, ExceptionType, uintptr_t, uintptr_t);
  TraceStatus prepareTraceSignal(Thread&, int signal, int32_t pid, uint32_t uid,
                                 bool inheritReservation, UniquePointer<SignalEvent>&);
  bool publishTraceSignal(Thread&, UniquePointer<SignalEvent>&, SignalEvent* source);
 
  virtual ~PosixSubsystem();
 
  /* Acquire mutual exclusion on the PosixSubsystem. */
  virtual void acquire();
 
  virtual void release();
 
  static bool checkAddress(uintptr_t addr, size_t extent, size_t flags);
 
  static bool checkedUserBufferSize(size_t count, size_t elementSize, size_t& extent);
 
  static constexpr size_t MaximumExecArgumentBytes = 131072;
 
  static bool checkUserAddressRange(uintptr_t addr, size_t count, size_t elementSize,
                                    size_t* extent = nullptr);
 
  static bool checkUserBuffer(uintptr_t addr, size_t count, size_t elementSize, size_t flags,
                              size_t* extent = nullptr);
 
  static bool copyFromUser(void* destination, const void* source, size_t count,
                           size_t elementSize = 1);
 
  static bool copyToUser(void* destination, const void* source, size_t count,
                         size_t elementSize = 1);
 
  static size_t readCachedFile(File& file, uint64_t offset, void* destination, size_t count);
 
  enum UserStringResult { UserStringSuccess, UserStringBadAddress, UserStringTooLong };
 
  static UserStringResult copyUserString(const char* userString, String& copy, size_t maxLength);
 
  virtual bool kill(KillReason killReason, Thread* pThread);
 
  virtual void threadException(Thread* pThread, ExceptionType eType,
                               InterruptState* pState = nullptr, uintptr_t faultAddress = 0,
                               uintptr_t errorCode = 0);
 
  bool resolveUserPageFault(Thread& thread, InterruptState& state, uintptr_t faultAddress,
                            uintptr_t errorCode) override;
 
  virtual void sendSignal(Thread* pThread, int signal, bool yield = true,
                          bool processDirected = false);
 
  struct SignalHandler {
    SignalHandler() : sig(255), pEvent(0), sigMask(0), flags(0), restorer(0), type(0) {}
 
    SignalHandler(const SignalHandler& s)
        : sig(s.sig),
          pEvent(s.pEvent ? s.pEvent->cloneForDisposition() : nullptr),
          sigMask(s.sigMask),
          flags(s.flags),
          restorer(s.restorer),
          type(s.type) {}
 
    ~SignalHandler() {
      if (pEvent) {
        pEvent->retire();
      }
    }
 
    SignalHandler& operator=(const SignalHandler& s) {
      if (this == &s) {
        return *this;
      }
 
      if (pEvent) {
        pEvent->retire();
      }
 
      sig = s.sig;
      pEvent = s.pEvent ? s.pEvent->cloneForDisposition() : nullptr;
      sigMask = s.sigMask;
      flags = s.flags;
      restorer = s.restorer;
      type = s.type;
      return *this;
    }
 
    size_t sig;
 
    SignalEvent* pEvent;
 
    uint64_t sigMask;
 
    uint32_t flags;
 
    uintptr_t restorer;
 
    int type;
  };
 
  struct SignalDisposition {
    SignalDisposition() : handler(0), signalMask(0), flags(0), restorer(0), type(1) {}
 
    uintptr_t handler;
    uint64_t signalMask;
    uint32_t flags;
    uintptr_t restorer;
    int type;
  };
 
  enum class SignalDeliveryResult { Unavailable, Ignored, Rejected, Queued, Full };
 
  void setSignalHandler(size_t sig, SignalHandler* handler);
 
  bool admitLegacyUserSignals();
 
  // Affinity admission holds the VM operation gate through policy queuing.
  bool affinityPolicyAllowed() const {
    return m_CallbackSchedulingDomain != CallbackSchedulingDomain::LegacySignals;
  }
  void recordAffinityPolicyUse() {
    m_CallbackSchedulingDomain = CallbackSchedulingDomain::Affinity;
  }
 
  void resetSignalHandlersForExec(Thread* thread,
                                  SignalHandler* const handlers[SignalDispositionCount]);
 
  bool getSignalDisposition(size_t sig, SignalDisposition& disposition, bool beginDelivery = false);
 
  SignalDeliveryResult queueSignalDelivery(
      Thread* target, size_t sig, uint32_t* flags = nullptr, int32_t signalCode = 0,
      bool processDirected = false, uint64_t signalValue = 0,
      const SharedPointer<SignalEventState>& state = SharedPointer<SignalEventState>());
 
  void setProcess(Process* process) override;
 
  struct UserImageToken {
    VirtualAddressSpace* space = nullptr;
    uint64_t generation = 0;
  };
  // Tokens own no memory. Retain the Process and an outer VM operation guard
  // while using a snapshot, so an exec cannot replace its admitted image.
  bool snapshotUserImage(UserImageToken& token) const;
  bool matchesUserImage(const UserImageToken& token) const;
  void invalidateUserImage();
  bool publishUserImage(VirtualAddressSpace& space);
 
  SharedPointer<PendingSignalContext> pendingSignalContext() {
    return m_PendingSignals;
  }
  Mutex& pendingSignalLock() {
    return m_PendingSignals->lock;
  }
  ConditionVariable& pendingSignalChanged() {
    return m_PendingSignals->changed;
  }
 
  void retireDescriptor(FileDescriptor* descriptor);
 
  AdvisoryOwner& advisoryOwner() {
    return m_AdvisoryOwner;
  }
 
  PosixMemoryLockAccount& memoryLockAccount() {
    return m_MemoryLockAccount;
  }
 
  SignalHandler* getSignalHandler(size_t sig) {
    if (sig > MaximumSupportedSignal) {
      return nullptr;
    }
    m_SignalHandlersLock.enter();
    SignalHandler* ret = m_SignalHandlers.lookup(sig);
    m_SignalHandlersLock.leave();
    return ret;
  }
 
  void exit(int code, ExitCause cause = ExitCause::Normal) NORETURN;
 
  bool copyDescriptors(PosixSubsystem* pSubsystem);
 
  size_t getFd(size_t minimum = 0);
 
  void allocateFd(size_t fdNum);
 
  void freeFd(size_t fdNum);
 
  void freeMultipleFds(bool bOnlyCloExec = false, size_t iFirst = 0, size_t iLast = -1);
 
  bool acquireFileDescriptor(size_t fd, DescriptorLease& descriptor);
 
  bool acquireNextFileDescriptor(size_t minimum, size_t& fd, DescriptorLease& descriptor);
 
  bool descriptorMatchesOpenDescription(size_t fd,
                                        const FileDescriptor::OpenFileDescriptionLease& expected);
 
  bool closeFileDescriptor(size_t fd, const DescriptorLease& descriptor);
 
  void addFileDescriptor(size_t fd, FileDescriptor* pFd);
 
  DescriptorDuplicationResult duplicateFileDescriptor(size_t source, size_t target,
                                                      bool closeOnExec);
 
  size_t installFileDescriptor(FileDescriptor* descriptor, DescriptorLease& lease,
                               size_t minimum = 0);
 
  class PosixSyncObject {
   public:
    PosixSyncObject() : pObject(0), isMutex(false) {}
    ~PosixSyncObject() {}
 
    void* pObject;
    bool isMutex;
 
   private:
    PosixSyncObject(const PosixSyncObject&);
    const PosixSyncObject& operator=(const PosixSyncObject&);
  };
 
  PosixSyncObject* getSyncObject(size_t n) {
    return m_SyncObjects.lookup(n);
  }
 
  void insertSyncObject(size_t n, PosixSyncObject* sem) {
    PosixSyncObject* t = m_SyncObjects.lookup(n);
    if (t) {
      m_SyncObjects.remove(n);
      delete t;
    }
 
    m_SyncObjects.insert(n, sem);
  }
 
  void removeSyncObject(size_t n) {
    PosixSyncObject* t = m_SyncObjects.lookup(n);
    if (t) {
      m_SyncObjects.remove(n);
      delete t;
    }
  }
 
  struct PosixThreadKey {
    void (*destructor)(void*);
 
    void* buffer;
  };
 
  class PosixThread {
   public:
    PosixThread()
        : pThread(0),
          isRunning(),
          returnValue(0),
          canReclaim(false),
          isDetached(false),
          m_ThreadData(),
          m_ThreadKeys(),
          lastDataKey(0),
          nextDataKey(0) {}
    ~PosixThread() {}
 
    Thread* pThread;
    Completion isRunning;
    void* returnValue;
 
    bool canReclaim;
    bool isDetached;
 
    Tree<size_t, PosixThreadKey*> m_ThreadData;
    ExtensibleBitmap m_ThreadKeys;
 
    PosixThreadKey* getThreadData(size_t key) {
      return m_ThreadData.lookup(key);
    }
 
    void removeThreadData(size_t key) {
      m_ThreadData.remove(key);
    }
 
    bool addThreadData(size_t key, PosixThreadKey* info) {
      if (m_ThreadData.lookup(key))
        return false;
      m_ThreadData.insert(key, info);
      return true;
    }
 
    size_t lastDataKey;
 
    size_t nextDataKey;
 
   private:
    PosixThread(const PosixThread&);
    const PosixThread& operator=(const PosixThread&);
  };
 
  PosixThread* getThread(size_t n) {
    return m_Threads.lookup(n);
  }
 
  void insertThread(size_t n, PosixThread* thread) {
    PosixThread* t = m_Threads.lookup(n);
    if (t)
      m_Threads.remove(n);  
    return m_Threads.insert(n, thread);
  }
 
  void removeThread(size_t n) {
    m_Threads.remove(n);  
  }
 
  Semaphore* getThreadWaiter(void* n) {
    return m_ThreadWaiters.lookup(n);
  }
 
  void* insertThreadWaiter(Semaphore* waiter) {
    void* descriptor = reinterpret_cast<void*>(m_NextThreadWaiter++);
    Semaphore* t = m_ThreadWaiters.lookup(descriptor);
    if (t)
      m_ThreadWaiters.remove(descriptor);
    m_ThreadWaiters.insert(descriptor, waiter);
    return descriptor;
  }
 
  void removeThreadWaiter(void* n) {
    m_ThreadWaiters.remove(n);
  }
 
  bool checkAccess(const DescriptorLease& pFileDescriptor, bool bRead, bool bWrite,
                   bool bExecute) const;
  uint64_t filesystemAccess(const FilesystemPathRef* ancestry, size_t count) const override;
  bool filesystemConstrained() const override;
  bool filesystemReparent(const FilesystemPathRef* source, size_t sourceCount,
                          const FilesystemPathRef* destination,
                          size_t destinationCount) const override;
 
  virtual bool invoke(const char* name, Vector<String>& argv, Vector<String>& env);
 
  virtual bool invoke(const char* name, Vector<String>& argv, Vector<String>& env,
                      SyscallState& state);
 
  virtual bool invoke(File* originalFile, const String& originalName, Vector<String>& argv,
                      Vector<String>& env);
 
  virtual bool invoke(File* originalFile, const String& originalName, Vector<String>& argv,
                      Vector<String>& env, SyscallState& state);
 
  bool invoke(File* originalFile, const String& originalName, Vector<String>& argv,
              Vector<String>& env, SyscallState& state, bool descriptorPathInaccessible);
 
  bool invoke(const FilesystemPathRef& originalPath, const String& originalName,
              Vector<String>& argv, Vector<String>& env, SyscallState& state,
              bool descriptorPathInaccessible = false);
 
  File* findFileRetained(const String& path, ResolvedPath& result,
                         const FilesystemPathRef& workingDir = FilesystemPathRef(),
                         bool followFinal = false);
  File* followFile(ResolvedPath& selected);
 
  Abi getAbi() const {
    return m_Abi;
  }
 
  void setAbi(Abi which) {
    m_Abi = which;
  }
 
 private:
  struct ExecutableImage;
  struct FdEntry;
  static constexpr size_t FdBuckets = 16;
 
  void acquireFdLock();
  void publishFdEntry(size_t fd);
  void publishFdEntries();
 
  virtual void prepareThreadsForExec(Thread* owner);
  virtual void preserveProcessSignalsForThreadExit(Thread* thread);
  virtual void threadExiting(Thread* pThread);
  void clearChildTid(Thread* thread);
  virtual void threadRemoved(Thread* pThread);
 
  bool prepareExecutable(File* pFile, ExecutableImage& image, bool isInterpreter);
 
  bool loadElf(const ExecutableImage& image, uintptr_t& loadBias);
 
  bool invoke(const char* name, Vector<String>& argv, Vector<String>& env, SyscallState* state);
 
  bool invoke(File* originalFile, const String& originalName, Vector<String>& argv,
              Vector<String>& env, SyscallState* state, bool descriptorPathInaccessible = false,
              const FilesystemPathRef& originalPath = FilesystemPathRef());
 
  bool parseShebang(File* pFile, String& interpreter, String& optionalArgument,
                    bool& hasOptionalArgument);
 
  PosixTraceContext m_TraceContext;
  Tree<size_t, SignalHandler*> m_SignalHandlers;
 
  UnlikelyLock m_SignalHandlersLock;
  enum class CallbackSchedulingDomain { Unrestricted, LegacySignals, Affinity };
  CallbackSchedulingDomain m_CallbackSchedulingDomain = CallbackSchedulingDomain::Unrestricted;
  SharedPointer<PendingSignalContext> m_PendingSignals{new PendingSignalContext};
  AdvisoryOwner m_AdvisoryOwner;
  PosixMemoryLockAccount m_MemoryLockAccount;
  SharedPointer<PosixNamespaceContext> m_Namespaces{
      SharedPointer<PosixNamespaceContext>::tryAllocate()};
  VirtualAddressSpace* m_UserImageSpace = nullptr;
  uint64_t m_UserImageGeneration = 0;
  bool m_UserImageActive = false;
 
  Tree<size_t, SharedPointer<FileDescriptor>> m_FdMap;
  RcuPointer<FdEntry> m_FdEntries[FdBuckets];
  size_t m_NextFd;
  Mutex m_FdLock;
  ExtensibleBitmap m_FdBitmap;
  size_t m_LastFd;
  int m_FreeCount;
  Tree<size_t, PosixSyncObject*> m_SyncObjects;
  Tree<size_t, PosixThread*> m_Threads;
  Tree<void*, Semaphore*> m_ThreadWaiters;
  size_t m_NextThreadWaiter;
  mutable Mutex m_ImageMetadataLock;
  FilesystemPathRef m_ExecutablePath;
  Vector<String> m_CommandLine;
 
  Abi m_Abi;
 
  bool m_bAcquired;
 
  Thread* m_pAcquiredThread;
 
  Spinlock m_Lock;
};
 
#endif