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

#ifdef THREADS

#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/process/Thread.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/StaticString.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/new"

#include "pedigree/kernel/Subsystem.h"

class VirtualAddressSpace;
class File;
class User;
class Group;
class DynamicLinker;

class EXPORTED_PUBLIC Process
{
    friend class Thread;

  public:
    enum ProcessType
    {
        Stock,
        Posix
    };

    enum ProcessState
    {
        Active,
        Suspended,
        Terminating,
        Terminated,
        Reaped,  
    };

    Process();

    Process(Process *pParent, bool bCopyOnWrite = true);

    virtual ~Process();

    size_t addThread(Thread *pThread);
    void removeThread(Thread *pThread);

    size_t getNumThreads();
    Thread *getThread(size_t n);

    size_t getId()
    {
        return m_Id;
    }

    LargeStaticString &description()
    {
        return str;
    }

    VirtualAddressSpace *getAddressSpace()
    {
        return m_pAddressSpace;
    }

    void setExitStatus(int code)
    {
        m_ExitStatus = code;
    }
    int getExitStatus()
    {
        return m_ExitStatus;
    }

    void reap()
    {
        m_State = Reaped;
    }

    void kill() NORETURN;
    void suspend();
    void resume();

    Process *getParent()
    {
        return m_pParent;
    }

    File *getCwd()
    {
        return m_Cwd;
    }
    void setCwd(File *f)
    {
        m_Cwd = f;
    }

    File *getCtty()
    {
        return m_Ctty;
    }
    void setCtty(File *f)
    {
        m_Ctty = f;
    }

    MemoryAllocator &getSpaceAllocator()
    {
        return m_SpaceAllocator;
    }
    MemoryAllocator &getDynamicSpaceAllocator()
    {
        return m_DynamicSpaceAllocator;
    }

    User *getUser() const
    {
        return m_pUser;
    }
    void setUser(User *pUser)
    {
        m_pUser = pUser;
    }

    User *getEffectiveUser() const
    {
        return m_pEffectiveUser;
    }
    void setEffectiveUser(User *pUser)
    {
        m_pEffectiveUser = pUser;
    }

    Group *getGroup() const
    {
        return m_pGroup;
    }
    void setGroup(Group *pGroup)
    {
        m_pGroup = pGroup;
    }

    Group *getEffectiveGroup() const
    {
        return m_pEffectiveGroup;
    }
    void setEffectiveGroup(Group *pGroup)
    {
        m_pEffectiveGroup = 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;

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

    virtual ProcessType getType()
    {
        return Stock;
    }

    void addWaiter(Semaphore *pWaiter);
    void removeWaiter(Semaphore *pWaiter);
    size_t waiterCount() const;

    bool hasSuspended()
    {
        bool bRet = m_bUnreportedSuspend;
        m_bUnreportedSuspend = false;
        return bRet;
    }
    bool hasResumed()
    {
        bool bRet = m_bUnreportedResume;
        m_bUnreportedResume = false;
        return bRet;
    }

    ProcessState getState() const
    {
        return m_State;
    }

    void markTerminating()
    {
        m_State = Terminating;
    }

    void trackHeap(ssize_t nBytes)
    {
        m_Metadata.heapUsage += nBytes;
    }

    void trackPages(ssize_t nVirtual, ssize_t nPhysical, ssize_t nShared)
    {
        m_Metadata.virtualPages += nVirtual;
        m_Metadata.physicalPages += nPhysical;
        m_Metadata.sharedPages += nShared;
    }

    void resetCounts()
    {
        m_Metadata.virtualPages = 0;
        m_Metadata.physicalPages = 0;
        m_Metadata.sharedPages = 0;
        m_Metadata.startTime = Time::getTimeNanoseconds();
    }

    void recordTime(bool bUserspace)
    {
        Time::Timestamp now = Time::getTimeNanoseconds();
        if (bUserspace)
        {
            m_LastUserspaceEntry = now;
        }
        else
        {
            m_LastKernelEntry = now;
        }
    }

    void trackTime(bool bUserspace)
    {
        Time::Timestamp now = Time::getTimeNanoseconds();
        if (bUserspace)
        {
            Time::Timestamp diff = now - m_LastUserspaceEntry;
            m_LastUserspaceEntry = now;
            m_Metadata.userTime += diff;

            reportTimesUpdated(diff, 0);
        }
        else
        {
            Time::Timestamp diff = now - m_LastKernelEntry;
            m_LastKernelEntry = now;
            m_Metadata.kernelTime += diff;

            reportTimesUpdated(0, diff);
        }
    }

    Time::Timestamp getUserTime() const
    {
        return m_Metadata.userTime;
    }
    Time::Timestamp getKernelTime() const
    {
        return m_Metadata.kernelTime;
    }
    Time::Timestamp getStartTime() const
    {
        return m_Metadata.startTime;
    }

    ssize_t getHeapUsage() const
    {
        return m_Metadata.heapUsage;
    }
    ssize_t getVirtualPageCount() const
    {
        return m_Metadata.virtualPages;
    }
    ssize_t getPhysicalPageCount() const
    {
        return m_Metadata.physicalPages;
    }
    ssize_t getSharedPageCount() const
    {
        return m_Metadata.sharedPages;
    }

    void setRootFile(File *pFile)
    {
        m_pRootFile = pFile;
    }

    File *getRootFile() const
    {
        return m_pRootFile;
    }

    bool hasSharedAddressSpace() const
    {
        return m_bSharedAddressSpace;
    }

    static Process *getInit();

    static void setInit(Process *pProcess);

  private:
    Process(const Process &);
    Process &operator=(const Process &);

    virtual void
    reportTimesUpdated(Time::Timestamp user, Time::Timestamp system)
    {
    }

    virtual void processTerminated()
    {
    }

    Vector<Thread *> m_Threads;
    Atomic<size_t> m_NextTid;
    size_t m_Id;
    LargeStaticString str;
    Process *m_pParent;
    VirtualAddressSpace *m_pAddressSpace;
    int m_ExitStatus;
    File *m_Cwd;
    File *m_Ctty;
    MemoryAllocator m_SpaceAllocator;
    MemoryAllocator m_DynamicSpaceAllocator;
    User *m_pUser;
    Group *m_pGroup;
    User *m_pEffectiveUser;
    Group *m_pEffectiveGroup;

    DynamicLinker *m_pDynamicLinker;

    Subsystem *m_pSubsystem;

    List<Semaphore *> m_Waiters;

    bool m_bUnreportedSuspend;

    bool m_bUnreportedResume;

    ProcessState m_State;

    Thread::Status m_BeforeSuspendState;

    Spinlock m_Lock;

    void notifyWaiters();

    struct ProcessMetadata
    {
        ProcessMetadata()
            : virtualPages(0), physicalPages(0), sharedPages(0), userTime(0),
              kernelTime(0), startTime(0)
        {
        }

        ssize_t heapUsage;
        ssize_t virtualPages;
        ssize_t physicalPages;
        ssize_t sharedPages;

        Time::Timestamp userTime;
        Time::Timestamp kernelTime;

        Time::Timestamp startTime;
    } m_Metadata;

    Time::Timestamp m_LastKernelEntry;

    Time::Timestamp m_LastUserspaceEntry;

    File *m_pRootFile;

    bool m_bSharedAddressSpace;

    static Process *m_pInitProcess;

  public:
    Semaphore m_DeadThreads;
};

#endif

#endif