X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fsim%2Fprocess.hh;h=cb2a3e2beb3d17ea8cffd5f5137a730b86bb6287;hb=aa56ed4dc50255869e72b9399c671c21d88e88d4;hp=dd64fa607dabd26b08c4c5faece3443672235fd2;hpb=6a19b64de2044e5b166a9883be6531166cd69900;p=gem5.git diff --git a/src/sim/process.hh b/src/sim/process.hh index dd64fa607..cb2a3e2be 100644 --- a/src/sim/process.hh +++ b/src/sim/process.hh @@ -1,4 +1,5 @@ /* + * Copyright (c) 2014-2016 Advanced Micro Devices, Inc. * Copyright (c) 2001-2005 The Regents of The University of Michigan * All rights reserved. * @@ -27,253 +28,192 @@ * * Authors: Nathan Binkert * Steve Reinhardt + * Brandon Potter */ #ifndef __PROCESS_HH__ #define __PROCESS_HH__ -// -// The purpose of this code is to fake the loader & syscall mechanism -// when there's no OS: thus there's no reason to use it in FULL_SYSTEM -// mode when we do have an OS. -// -#include "config/full_system.hh" - -#if !FULL_SYSTEM +#include +#include #include #include +#include "arch/registers.hh" #include "base/statistics.hh" -#include "mem/translating_port.hh" -#include "sim/host.hh" +#include "base/types.hh" +#include "config/the_isa.hh" +#include "mem/se_translating_port_proxy.hh" +#include "sim/fd_array.hh" +#include "sim/fd_entry.hh" +#include "sim/mem_state.hh" #include "sim/sim_object.hh" -class ThreadContext; +struct ProcessParams; + +class EmulatedDriver; +class ObjectFile; +class EmulationPageTable; class SyscallDesc; -class PageTable; -class TranslatingPort; +class SyscallReturn; class System; -class GDBListener; -namespace TheISA -{ - class RemoteGDB; -} - -//This needs to be templated for cases where 32 bit pointers are needed. -template -void -copyStringArray(std::vector &strings, - AddrType array_ptr, AddrType data_ptr, - TranslatingPort* memPort) -{ - AddrType data_ptr_swap; - for (int i = 0; i < strings.size(); ++i) { - data_ptr_swap = htog(data_ptr); - memPort->writeBlob(array_ptr, (uint8_t*)&data_ptr_swap, - sizeof(AddrType)); - memPort->writeString(data_ptr, strings[i].c_str()); - array_ptr += sizeof(AddrType); - data_ptr += strings[i].size() + 1; - } - // add NULL terminator - data_ptr = 0; - - memPort->writeBlob(array_ptr, (uint8_t*)&data_ptr, sizeof(AddrType)); -} +class ThreadContext; class Process : public SimObject { public: + Process(ProcessParams *params, EmulationPageTable *pTable, + ObjectFile *obj_file); + + void serialize(CheckpointOut &cp) const override; + void unserialize(CheckpointIn &cp) override; + + void initState() override; + DrainState drain() override; + + virtual void syscall(int64_t callnum, ThreadContext *tc, Fault *fault); + 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; + + inline uint64_t uid() { return _uid; } + inline uint64_t euid() { return _euid; } + inline uint64_t gid() { return _gid; } + inline uint64_t egid() { return _egid; } + inline uint64_t pid() { return _pid; } + inline uint64_t ppid() { return _ppid; } + inline uint64_t pgid() { return _pgid; } + inline uint64_t tgid() { return _tgid; } + inline void setpgid(uint64_t pgid) { _pgid = pgid; } + + const char *progName() const { return executable.c_str(); } + std::string fullPath(const std::string &filename); + std::string getcwd() const { return cwd; } + + /** + * Find an emulated device driver. + * + * @param filename Name of the device (under /dev) + * @return Pointer to driver object if found, else nullptr + */ + EmulatedDriver *findDriver(std::string filename); + + // This function acts as a callback to update the bias value in + // the object file because the parameters needed to calculate the + // bias are not available when the object file is created. + void updateBias(); + Addr getBias(); + Addr getStartPC(); + ObjectFile *getInterpreter(); - /// Pointer to object representing the system this process is - /// 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; + // override of virtual SimObject method: register statistics + void regStats() override; - // remote gdb objects - std::vector remoteGDB; - std::vector gdbListen; - bool breakpoint(); + void allocateMem(Addr vaddr, int64_t size, bool clobber = false); - // number of CPUs (esxec contexts, really) assigned to this process. - unsigned int numCpus() { return threadContexts.size(); } + /// 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); - // record of blocked context - struct WaitRec + // After getting registered with system object, tell process which + // system-wide context id it is assigned. + void + assignThreadContext(ContextID context_id) { - Addr waitChan; - ThreadContext *waitingContext; - - 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 stack_base; // stack segment base (highest address) - unsigned stack_size; // initial stack size - Addr stack_min; // lowest address accessed on the stack - - // addr to use for next stack region (for multithreaded apps) - Addr next_thread_stack_base; - - // Base of region for mmaps (when user doesn't specify an address). - Addr mmap_start; - Addr mmap_end; - - // Base of region for nxm data - Addr nxm_start; - Addr nxm_end; - - std::string prog_fname; // file name - - 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); - - // post initialization startup - virtual void startup(); - - protected: - /// Memory object for initialization (image loading) - TranslatingPort *initVirtMem; - - public: - PageTable *pTable; - - private: - // file descriptor remapping support - static const int MAX_FD = 256; // max legal fd value - int fd_map[MAX_FD+1]; - - public: - // static helper functions to generate file descriptors for constructor - static int openInputFile(const std::string &filename); - static int openOutputFile(const std::string &filename); - - // 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); + contextIds.push_back(context_id); + } + // Find a free context to use + ThreadContext *findFreeContext(); + + /** + * After delegating a thread context to a child process + * no longer should relate to the ThreadContext + */ + void revokeThreadContext(int context_id); + + /** + * Does mmap region grow upward or downward from mmapEnd? Most + * platforms grow downward, but a few (such as Alpha) grow upward + * instead, so they can override this method to return false. + */ + virtual bool mmapGrowsDown() const { return true; } + + /** + * Maps a contiguous range of virtual addresses in this process's + * address space to a contiguous range of physical addresses. + * This function exists primarily to expose the map operation to + * python, so that configuration scripts can set up mappings in SE mode. + * + * @param vaddr The starting virtual address of the range. + * @param paddr The starting physical address of the range. + * @param size The length of the range in bytes. + * @param cacheable Specifies whether accesses are cacheable. + * @return True if the map operation was successful. (At this + * point in time, the map operation always succeeds.) + */ + bool map(Addr vaddr, Addr paddr, int size, bool cacheable = true); + + void replicatePage(Addr vaddr, Addr new_paddr, ThreadContext *old_tc, + ThreadContext *new_tc, bool alloc_page); + + virtual void clone(ThreadContext *old_tc, ThreadContext *new_tc, + Process *new_p, TheISA::IntReg flags); - void replaceThreadContext(ThreadContext *tc, int tcIndex); + // thread contexts associated with this process + std::vector contextIds; - // map simulator fd sim_fd to target fd tgt_fd - void dup_fd(int sim_fd, int tgt_fd); + // system object which owns this process + System *system; - // generate new target fd for sim_fd - int alloc_fd(int sim_fd); + Stats::Scalar numSyscalls; // track how many system calls are executed - // free target fd (e.g., after close) - void free_fd(int tgt_fd); + bool useArchPT; // flag for using architecture specific page table + bool kvmInSE; // running KVM requires special initialization - // look up simulator fd for given target fd - int sim_fd(int tgt_fd); + EmulationPageTable *pTable; - virtual void syscall(int64_t callnum, ThreadContext *tc) = 0; + SETranslatingPortProxy initVirtMem; // memory proxy for initial image load - void serialize(std::ostream &os); - void unserialize(Checkpoint *cp, const std::string §ion); -}; - -// -// "Live" process with system calls redirected to host system -// -class ObjectFile; -class LiveProcess : public Process -{ - protected: ObjectFile *objFile; std::vector argv; 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); + std::string executable; // Id of the owner of the process - uint64_t __uid; - uint64_t __euid; - uint64_t __gid; - uint64_t __egid; + uint64_t _uid; + uint64_t _euid; + uint64_t _gid; + uint64_t _egid; // pid of the process and it's parent - uint64_t __pid; - uint64_t __ppid; - - public: - - inline uint64_t uid() {return __uid;} - inline uint64_t euid() {return __euid;} - inline uint64_t gid() {return __gid;} - inline uint64_t egid() {return __egid;} - inline uint64_t pid() {return __pid;} - inline uint64_t ppid() {return __ppid;} + uint64_t _pid; + uint64_t _ppid; + uint64_t _pgid; + uint64_t _tgid; - std::string - fullPath(const std::string &filename) - { - if (filename[0] == '/' || cwd.empty()) - return filename; + // Emulated drivers available to this process + std::vector drivers; - std::string full = cwd; + std::shared_ptr fds; - if (cwd[cwd.size() - 1] != '/') - full += '/'; + bool *exitGroup; + std::shared_ptr memState; - return full + filename; - } + /** + * Calls a futex wakeup at the address specified by this pointer when + * this process exits. + */ + uint64_t childClearTID; - virtual void syscall(int64_t callnum, ThreadContext *tc); - - 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); + // Process was forked with SIGCHLD set. + bool *sigchld; }; - -#endif // !FULL_SYSTEM - #endif // __PROCESS_HH__