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/Subsystem.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/process/SignalEvent.h"
#include "pedigree/kernel/processor/types.h"

#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/utilities/ExtensibleBitmap.h"
#include "pedigree/kernel/utilities/LruCache.h"
#include "pedigree/kernel/utilities/RadixTree.h"
#include "pedigree/kernel/utilities/Tree.h"
#include "pedigree/kernel/utilities/UnlikelyLock.h"
#include "pedigree/kernel/utilities/Vector.h"

#include "modules/subsys/posix/logging.h"

class File;
class Filesystem;
class UnixSocket;
class LockedFile;
class FileDescriptor;
class PosixSubsystem;

extern PosixSubsystem *getSubsystem();
extern FileDescriptor *getDescriptor(int fd);
extern void addDescriptor(int fd, FileDescriptor *f);
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;                                  \
    }

extern RadixTree<LockedFile *> g_PosixGlobalLockedFiles;

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);

  private:
    static ProcessGroupManager m_Instance;
    ExtensibleBitmap m_GroupIds;
};

class EXPORTED_PUBLIC PosixSubsystem : public Subsystem
{
  public:
    static const size_t SafeRegion = 0x0;  // Region check is always done.
    static const size_t SafeRead = 0x1;
    static const size_t SafeWrite = 0x2;

    enum Abi
    {
        PosixAbi = 0,
        LinuxAbi = 1,
    };

    PosixSubsystem()
        : Subsystem(Posix), m_SignalHandlers(), m_SignalHandlersLock(),
          m_FdMap(), m_NextFd(0), m_FdLock(), m_FdBitmap(), m_LastFd(0),
          m_FreeCount(1), m_AltSigStack(), m_SyncObjects(), m_Threads(),
          m_ThreadWaiters(), m_NextThreadWaiter(0), m_Abi(PosixAbi),
          m_bAcquired(false), m_pAcquiredThread(nullptr)
    {
    }

    PosixSubsystem(PosixSubsystem &s);

    PosixSubsystem(SubsystemType type)
        : Subsystem(type), m_SignalHandlers(), m_SignalHandlersLock(),
          m_FdMap(), m_NextFd(0), m_FdLock(), m_FdBitmap(), m_LastFd(0),
          m_FreeCount(1), m_AltSigStack(), m_SyncObjects(), m_Threads(),
          m_ThreadWaiters(), m_NextThreadWaiter(0), m_Abi(PosixAbi),
          m_bAcquired(false), m_pAcquiredThread(nullptr)
    {
    }

    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);

    virtual bool kill(KillReason killReason, Thread *pThread);

    virtual void threadException(Thread *pThread, ExceptionType eType);

    virtual void sendSignal(Thread *pThread, int signal, bool yield = true);

    struct AlternateSignalStack
    {
        AlternateSignalStack() : base(0), size(0), inUse(false), enabled(false)
        {
        }

        uintptr_t base;

        size_t size;

        bool inUse;

        bool enabled;
    };

    AlternateSignalStack &getAlternateSignalStack()
    {
        return m_AltSigStack;
    }

    void setAlternateSignalStack(AlternateSignalStack &s)
    {
        m_AltSigStack = s;
    }

    struct SignalHandler
    {
        SignalHandler() : sig(255), pEvent(0), sigMask(), flags(0), type(0)
        {
        }

        SignalHandler(const SignalHandler &s)
            : sig(s.sig), pEvent(new SignalEvent(*(s.pEvent))),
              sigMask(s.sigMask), flags(s.flags), type(s.type)
        {
        }

        ~SignalHandler()
        {
            if (pEvent)
            {
                pEvent->waitForDeliveries();
                delete pEvent;
            }
        }

        SignalHandler &operator=(const SignalHandler &s)
        {
            if (this == &s)
            {
                return *this;
            }

            if (pEvent)
            {
                delete pEvent;
            }

            sig = s.sig;
            pEvent = new SignalEvent(*(s.pEvent));
            sigMask = s.sigMask;
            flags = s.flags;
            type = s.type;
            return *this;
        }

        size_t sig;

        SignalEvent *pEvent;

        uint32_t sigMask;

        uint32_t flags;

        int type;
    };

    void setSignalHandler(size_t sig, SignalHandler *handler);

    SignalHandler *getSignalHandler(size_t sig)
    {
        while (!m_SignalHandlersLock.enter())
            ;
        SignalHandler *ret = m_SignalHandlers.lookup(sig % 32);
        m_SignalHandlersLock.leave();
        return ret;
    }

    void exit(int code) NORETURN;

    bool copyDescriptors(PosixSubsystem *pSubsystem);

    size_t getFd();

    void allocateFd(size_t fdNum);

    void freeFd(size_t fdNum);

    void freeMultipleFds(
        bool bOnlyCloExec = false, size_t iFirst = 0, size_t iLast = -1);

    FileDescriptor *getFileDescriptor(size_t fd);

    void addFileDescriptor(size_t fd, FileDescriptor *pFd);

    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(true), returnValue(0), canReclaim(false),
              isDetached(false), m_ThreadData(), m_ThreadKeys(), lastDataKey(0),
              nextDataKey(0)
        {
        }
        ~PosixThread()
        {
        }

        Thread *pThread;
        Mutex 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(
        FileDescriptor *pFileDescriptor, bool bRead, bool bWrite,
        bool bExecute) const;

    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);

    virtual File *findFile(const String &path, File *workingDir);

    Abi getAbi() const
    {
        return m_Abi;
    }

    void setAbi(Abi which)
    {
        m_Abi = which;
    }

  private:
    virtual void threadRemoved(Thread *pThread);

    bool loadElf(
        File *pFile, uintptr_t mappedAddress, uintptr_t &newAddress,
        uintptr_t &finalAddress, bool &relocated);

    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 parseShebang(File *pFile, File *&outFile, Vector<String> &argv);

    Tree<size_t, SignalHandler *> m_SignalHandlers;

    UnlikelyLock m_SignalHandlersLock;

    Tree<size_t, FileDescriptor *> m_FdMap;
    size_t m_NextFd;
    UnlikelyLock m_FdLock;
    ExtensibleBitmap m_FdBitmap;
    size_t m_LastFd;
    int m_FreeCount;
    AlternateSignalStack m_AltSigStack;
    Tree<size_t, PosixSyncObject *> m_SyncObjects;
    Tree<size_t, PosixThread *> m_Threads;
    Tree<void *, Semaphore *> m_ThreadWaiters;
    size_t m_NextThreadWaiter;

    Abi m_Abi;

    bool m_bAcquired;

    Thread *m_pAcquiredThread;

    Spinlock m_Lock;

    LruCache<String, File *> m_FindFileCache;

    Filesystem *m_pRootFs = nullptr;
};

#endif