X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fsim%2Fprocess.hh;h=f78ab595c1521698116409a7799b9c03058aa1b3;hb=24c23009980a11dfba147fb4ed93329f4dcf4c0d;hp=616c02c00920d70fc5c1f6fa658e6d403142231d;hpb=0a99750ebfe9a9b400ee5f0610ed429851345c4b;p=gem5.git diff --git a/src/sim/process.hh b/src/sim/process.hh index 616c02c00..f78ab595c 100644 --- a/src/sim/process.hh +++ b/src/sim/process.hh @@ -41,20 +41,35 @@ #if !FULL_SYSTEM +#include #include +#include "arch/registers.hh" #include "base/statistics.hh" +#include "base/types.hh" +#include "config/the_isa.hh" #include "sim/sim_object.hh" +#include "sim/syscallreturn.hh" -class ThreadContext; -class SyscallDesc; class PageTable; -class TranslatingPort; +class ProcessParams; +class LiveProcessParams; +class SyscallDesc; class System; +class ThreadContext; +class SETranslatingPortProxy; -void -copyStringArray(std::vector &strings, Addr array_ptr, - Addr data_ptr, TranslatingPort* memPort); +template +struct AuxVector +{ + IntType a_type; + IntType a_val; + + AuxVector() + {} + + AuxVector(IntType type, IntType val); +}; class Process : public SimObject { @@ -64,16 +79,11 @@ class Process : public SimObject /// running on. System *system; - // have we initialized a thread context from this process? If - // yes, subsequent contexts are assumed to be for dynamically - // created threads and are not initialized. - bool initialContextLoaded; - // thread contexts associated with this process - std::vector threadContexts; + std::vector contextIds; // number of CPUs (esxec contexts, really) assigned to this process. - unsigned int numCpus() { return threadContexts.size(); } + unsigned int numCpus() { return contextIds.size(); } // record of blocked context struct WaitRec @@ -83,17 +93,20 @@ class Process : public SimObject WaitRec(Addr chan, ThreadContext *ctx) : waitChan(chan), waitingContext(ctx) - { } + { } }; // list of all blocked contexts std::list waitList; - Addr brk_point; // top of the data segment + Addr brk_point; // top of the data segment + + Addr stack_base; // stack segment base (highest address) + unsigned stack_size; // initial stack size + Addr stack_min; // lowest address accessed on the stack - Addr stack_base; // stack segment base (highest address) - unsigned stack_size; // initial stack size - Addr stack_min; // lowest address accessed on the stack + // The maximum size allowed for the stack. + Addr max_stack_size; // addr to use for next stack region (for multithreaded apps) Addr next_thread_stack_base; @@ -106,33 +119,53 @@ class Process : public SimObject Addr nxm_start; Addr nxm_end; - std::string prog_fname; // file name + std::string prog_fname; // file name - Stats::Scalar<> num_syscalls; // number of syscalls executed + Stats::Scalar num_syscalls; // number of syscalls executed protected: // constructor - Process(const std::string &nm, - System *_system, - int stdin_fd, // initial I/O descriptors - int stdout_fd, - int stderr_fd); + Process(ProcessParams *params); - // post initialization startup - virtual void startup(); + virtual void initState(); protected: /// Memory object for initialization (image loading) - TranslatingPort *initVirtMem; + SETranslatingPortProxy *initVirtMem; public: PageTable *pTable; + //This id is assigned by m5 and is used to keep process' tlb entries + //separated. + uint64_t M5_pid; + + class FdMap + { + public: + int fd; + std::string filename; + int mode; + int flags; + bool isPipe; + int readPipeSource; + uint64_t fileOffset; + + FdMap() + : fd(-1), filename("NULL"), mode(0), flags(0), + isPipe(false), readPipeSource(0), fileOffset(0) + { } + + void serialize(std::ostream &os); + void unserialize(Checkpoint *cp, const std::string §ion); + }; + private: // file descriptor remapping support - static const int MAX_FD = 256; // max legal fd value - int fd_map[MAX_FD+1]; + static const int MAX_FD = 256; // max legal fd value + FdMap fd_map[MAX_FD+1]; + public: // static helper functions to generate file descriptors for constructor @@ -142,18 +175,22 @@ class Process : public SimObject // override of virtual SimObject method: register statistics virtual void regStats(); - // register a thread context for this process. - // returns tc's cpu number (index into threadContexts[]) - int registerThreadContext(ThreadContext *tc); - + // After getting registered with system object, tell process which + // system-wide context id it is assigned. + void assignThreadContext(int context_id) + { + contextIds.push_back(context_id); + } - void replaceThreadContext(ThreadContext *tc, int tcIndex); + // Find a free context to use + ThreadContext *findFreeContext(); // map simulator fd sim_fd to target fd tgt_fd void dup_fd(int sim_fd, int tgt_fd); // generate new target fd for sim_fd - int alloc_fd(int sim_fd); + int alloc_fd(int sim_fd, std::string filename, int flags, int mode, + bool pipe); // free target fd (e.g., after close) void free_fd(int tgt_fd); @@ -161,8 +198,26 @@ class Process : public SimObject // look up simulator fd for given target fd int sim_fd(int tgt_fd); + // look up simulator fd_map object for a given target fd + FdMap *sim_fd_obj(int tgt_fd); + + // fix all offsets for currently open files and save them + void fix_file_offsets(); + + // find all offsets for currently open files and save them + void find_file_offsets(); + + // set the source of this read pipe for a checkpoint resume + void setReadPipeSource(int read_pipe_fd, int source_fd); + virtual void syscall(int64_t callnum, ThreadContext *tc) = 0; + void allocateMem(Addr vaddr, int64_t size, bool clobber = false); + + /// Attempt to fix up a fault at vaddr by allocating a page on the stack. + /// @return Whether the fault has been fixed. + bool fixupStackFault(Addr vaddr); + void serialize(std::ostream &os); void unserialize(Checkpoint *cp, const std::string §ion); }; @@ -179,16 +234,7 @@ class LiveProcess : public Process std::vector envp; std::string cwd; - LiveProcess(const std::string &nm, ObjectFile *objFile, - System *_system, int stdin_fd, int stdout_fd, int stderr_fd, - std::vector &argv, - std::vector &envp, - const std::string &cwd, - uint64_t _uid, uint64_t _euid, - uint64_t _gid, uint64_t _egid, - uint64_t _pid, uint64_t _ppid); - - virtual void argsInit(int intSize, int pageSize); + LiveProcess(LiveProcessParams *params, ObjectFile *objFile); // Id of the owner of the process uint64_t __uid; @@ -202,6 +248,36 @@ class LiveProcess : public Process public: + enum AuxiliaryVectorType { + M5_AT_NULL = 0, + M5_AT_IGNORE = 1, + M5_AT_EXECFD = 2, + M5_AT_PHDR = 3, + M5_AT_PHENT = 4, + M5_AT_PHNUM = 5, + M5_AT_PAGESZ = 6, + M5_AT_BASE = 7, + M5_AT_FLAGS = 8, + M5_AT_ENTRY = 9, + M5_AT_NOTELF = 10, + M5_AT_UID = 11, + M5_AT_EUID = 12, + M5_AT_GID = 13, + M5_AT_EGID = 14, + // The following may be specific to Linux + M5_AT_PLATFORM = 15, + M5_AT_HWCAP = 16, + M5_AT_CLKTCK = 17, + + M5_AT_SECURE = 23, + M5_BASE_PLATFORM = 24, + M5_AT_RANDOM = 25, + + M5_AT_EXECFN = 31, + + M5_AT_VECTOR_SIZE = 44 + }; + inline uint64_t uid() {return __uid;} inline uint64_t euid() {return __euid;} inline uint64_t gid() {return __gid;} @@ -223,23 +299,23 @@ class LiveProcess : public Process return full + filename; } + std::string getcwd() const { return cwd; } + virtual void syscall(int64_t callnum, ThreadContext *tc); - virtual SyscallDesc* getDesc(int callnum) = 0; + virtual TheISA::IntReg getSyscallArg(ThreadContext *tc, int &i) = 0; + virtual TheISA::IntReg getSyscallArg(ThreadContext *tc, int &i, int width); + virtual void setSyscallArg(ThreadContext *tc, + int i, TheISA::IntReg val) = 0; + virtual void setSyscallReturn(ThreadContext *tc, + SyscallReturn return_value) = 0; + + virtual SyscallDesc *getDesc(int callnum) = 0; // this function is used to create the LiveProcess object, since // we can't tell which subclass of LiveProcess to use until we // open and look at the object file. - static LiveProcess *create(const std::string &nm, - System *_system, - int stdin_fd, int stdout_fd, int stderr_fd, - std::string executable, - std::vector &argv, - std::vector &envp, - const std::string &cwd, - uint64_t _uid, uint64_t _euid, - uint64_t _gid, uint64_t _egid, - uint64_t _pid, uint64_t _ppid); + static LiveProcess *create(LiveProcessParams *params); };