Finished changing how stat structures are translated, fixed the handling of various ids as LiveProcess parameters.

src/arch/alpha/linux/process.cc:
src/arch/alpha/linux/process.hh:
src/arch/alpha/process.cc:
src/arch/alpha/process.hh:
src/arch/alpha/tru64/process.cc:
src/arch/alpha/tru64/process.hh:
src/arch/mips/linux/process.cc:
src/arch/mips/linux/process.hh:
src/arch/mips/process.cc:
src/arch/mips/process.hh:
src/arch/sparc/linux/process.cc:
src/arch/sparc/linux/process.hh:
src/arch/sparc/process.cc:
src/arch/sparc/process.hh:
src/arch/sparc/solaris/process.cc:
src/arch/sparc/solaris/process.hh:
src/sim/process.cc:
src/sim/process.hh:
src/sim/syscall_emul.cc:
src/sim/syscall_emul.hh:
    Changed Process to LiveProcess in syscall handlers and fixed the implementation of uid, euid, gid, egid, pid and ppid as LiveProcess parameters.
src/kern/tru64/tru64.hh:
    Changed Process to LiveProcess in syscall handlers and fixed the implementation of uid, euid, gid, egid, pid and ppid as LiveProcess parameters. Also fit tru64 in with the new way to handle stat calls.

--HG--
extra : convert_revision : 0198b838e5c09a730065dc6f018738145bc96269

4 files changed, 160 insertions, 123 deletions

diff --git a/src/sim/process.cc b/src/sim/process.cc
index 20f7fec2d..46ccd2596 100644
--- a/src/sim/process.cc
+++ b/src/sim/process.cc
@@ -278,10 +278,20 @@ copyStringArray(vector<string> &strings, Addr array_ptr, Addr data_ptr,
 LiveProcess::LiveProcess(const string &nm, ObjectFile *_objFile,
                          System *_system,
                          int stdin_fd, int stdout_fd, int stderr_fd,
-                         vector<string> &_argv, vector<string> &_envp)
+                         vector<string> &_argv, vector<string> &_envp,
+                         uint64_t _uid, uint64_t _euid,
+                         uint64_t _gid, uint64_t _egid,
+                         uint64_t _pid, uint64_t _ppid)
     : Process(nm, _system, stdin_fd, stdout_fd, stderr_fd),
       objFile(_objFile), argv(_argv), envp(_envp)
 {
+    __uid = _uid;
+    __euid = _euid;
+    __gid = _gid;
+    __egid = _egid;
+    __pid = _pid;
+    __ppid = _ppid;
+
     prog_fname = argv[0];
 
     // load up symbols, if any... these may be used for debugging or
@@ -381,7 +391,10 @@ LiveProcess *
 LiveProcess::create(const std::string &nm, System *system, int stdin_fd,
                     int stdout_fd, int stderr_fd, std::string executable,
                     std::vector<std::string> &argv,
-                    std::vector<std::string> &envp)
+                    std::vector<std::string> &envp,
+                    uint64_t _uid, uint64_t _euid,
+                    uint64_t _gid, uint64_t _egid,
+                    uint64_t _pid, uint64_t _ppid)
 {
     LiveProcess *process = NULL;
 
@@ -397,13 +410,15 @@ LiveProcess::create(const std::string &nm, System *system, int stdin_fd,
       case ObjectFile::Tru64:
         process = new AlphaTru64Process(nm, objFile, system,
                                         stdin_fd, stdout_fd, stderr_fd,
-                                        argv, envp);
+                                        argv, envp,
+                                        _uid, _euid, _gid, _egid, _pid, _ppid);
         break;
 
       case ObjectFile::Linux:
         process = new AlphaLinuxProcess(nm, objFile, system,
                                         stdin_fd, stdout_fd, stderr_fd,
-                                        argv, envp);
+                                        argv, envp,
+                                        _uid, _euid, _gid, _egid, _pid, _ppid);
         break;
 
       default:
@@ -416,14 +431,16 @@ LiveProcess::create(const std::string &nm, System *system, int stdin_fd,
       case ObjectFile::Linux:
         process = new SparcLinuxProcess(nm, objFile, system,
                                         stdin_fd, stdout_fd, stderr_fd,
-                                        argv, envp);
+                                        argv, envp,
+                                        _uid, _euid, _gid, _egid, _pid, _ppid);
         break;
 
 
       case ObjectFile::Solaris:
         process = new SparcSolarisProcess(nm, objFile, system,
                                         stdin_fd, stdout_fd, stderr_fd,
-                                        argv, envp);
+                                        argv, envp,
+                                        _uid, _euid, _gid, _egid, _pid, _ppid);
         break;
       default:
         fatal("Unknown/unsupported operating system.");
@@ -435,7 +452,8 @@ LiveProcess::create(const std::string &nm, System *system, int stdin_fd,
       case ObjectFile::Linux:
         process = new MipsLinuxProcess(nm, objFile, system,
                                         stdin_fd, stdout_fd, stderr_fd,
-                                        argv, envp);
+                                        argv, envp,
+                                        _uid, _euid, _gid, _egid, _pid, _ppid);
         break;
 
       default:
@@ -513,7 +531,8 @@ CREATE_SIM_OBJECT(LiveProcess)
     return LiveProcess::create(getInstanceName(), system,
                                stdin_fd, stdout_fd, stderr_fd,
                                (string)executable == "" ? cmd[0] : executable,
-                               cmd, env);
+                               cmd, env,
+                               uid, euid, gid, egid, pid, ppid);
 }
 
 
diff --git a/src/sim/process.hh b/src/sim/process.hh
index d64cc3cf1..b2777170f 100644
--- a/src/sim/process.hh
+++ b/src/sim/process.hh
@@ -75,16 +75,6 @@ class Process : public SimObject
     // number of CPUs (esxec contexts, really) assigned to this process.
     unsigned int numCpus() { return threadContexts.size(); }
 
-    // Id of the owner of the process
-    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;
-
     // record of blocked context
     struct WaitRec
     {
@@ -188,11 +178,32 @@ class LiveProcess : public Process
     LiveProcess(const std::string &nm, ObjectFile *objFile,
                 System *_system, int stdin_fd, int stdout_fd, int stderr_fd,
                 std::vector<std::string> &argv,
-                std::vector<std::string> &envp);
+                std::vector<std::string> &envp,
+                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);
 
+    // Id of the owner of the process
+    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;}
+
     virtual void syscall(int64_t callnum, ThreadContext *tc);
 
     virtual SyscallDesc* getDesc(int callnum) = 0;
@@ -205,7 +216,10 @@ class LiveProcess : public Process
                                int stdin_fd, int stdout_fd, int stderr_fd,
                                std::string executable,
                                std::vector<std::string> &argv,
-                               std::vector<std::string> &envp);
+                               std::vector<std::string> &envp,
+                               uint64_t _uid, uint64_t _euid,
+                               uint64_t _gid, uint64_t _egid,
+                               uint64_t _pid, uint64_t _ppid);
 };
 
 
diff --git a/src/sim/syscall_emul.cc b/src/sim/syscall_emul.cc
index fe0260223..9028d590b 100644
--- a/src/sim/syscall_emul.cc
+++ b/src/sim/syscall_emul.cc
@@ -49,7 +49,7 @@ using namespace std;
 using namespace TheISA;
 
 void
-SyscallDesc::doSyscall(int callnum, Process *process, ThreadContext *tc)
+SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc)
 {
     DPRINTFR(SyscallVerbose, "%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n",
              curTick,tc->getCpuPtr()->name(), name,
@@ -67,7 +67,7 @@ SyscallDesc::doSyscall(int callnum, Process *process, ThreadContext *tc)
 
 
 SyscallReturn
-unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
+unimplementedFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                   ThreadContext *tc)
 {
     fatal("syscall %s (#%d) unimplemented.", desc->name, callnum);
@@ -77,7 +77,7 @@ unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
 
 
 SyscallReturn
-ignoreFunc(SyscallDesc *desc, int callnum, Process *process,
+ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     warn("ignoring syscall %s(%d, %d, ...)", desc->name,
@@ -88,7 +88,7 @@ ignoreFunc(SyscallDesc *desc, int callnum, Process *process,
 
 
 SyscallReturn
-exitFunc(SyscallDesc *desc, int callnum, Process *process,
+exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
          ThreadContext *tc)
 {
     if (tc->exit()) {
@@ -100,14 +100,14 @@ exitFunc(SyscallDesc *desc, int callnum, Process *process,
 
 
 SyscallReturn
-getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+getpagesizeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     return (int)VMPageSize;
 }
 
 
 SyscallReturn
-obreakFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+obreakFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     Addr junk;
 
@@ -128,7 +128,7 @@ obreakFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 
 
 SyscallReturn
-closeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     int target_fd = tc->getSyscallArg(0);
     int status = close(p->sim_fd(target_fd));
@@ -139,7 +139,7 @@ closeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 
 
 SyscallReturn
-readFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     int fd = p->sim_fd(tc->getSyscallArg(0));
     int nbytes = tc->getSyscallArg(2);
@@ -154,7 +154,7 @@ readFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 }
 
 SyscallReturn
-writeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     int fd = p->sim_fd(tc->getSyscallArg(0));
     int nbytes = tc->getSyscallArg(2);
@@ -171,7 +171,7 @@ writeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 
 
 SyscallReturn
-lseekFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     int fd = p->sim_fd(tc->getSyscallArg(0));
     uint64_t offs = tc->getSyscallArg(1);
@@ -184,7 +184,7 @@ lseekFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 
 
 SyscallReturn
-munmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+munmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     // given that we don't really implement mmap, munmap is really easy
     return 0;
@@ -194,7 +194,7 @@ munmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 const char *hostname = "m5.eecs.umich.edu";
 
 SyscallReturn
-gethostnameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     int name_len = tc->getSyscallArg(1);
     BufferArg name(tc->getSyscallArg(0), name_len);
@@ -207,7 +207,7 @@ gethostnameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 }
 
 SyscallReturn
-unlinkFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     string path;
 
@@ -219,7 +219,7 @@ unlinkFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 }
 
 SyscallReturn
-renameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+renameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     string old_name;
 
@@ -236,7 +236,7 @@ renameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 }
 
 SyscallReturn
-truncateFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+truncateFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     string path;
 
@@ -250,7 +250,7 @@ truncateFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 }
 
 SyscallReturn
-ftruncateFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
+ftruncateFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
 {
     int fd = process->sim_fd(tc->getSyscallArg(0));
 
@@ -264,7 +264,7 @@ ftruncateFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 }
 
 SyscallReturn
-chownFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     string path;
 
@@ -282,7 +282,7 @@ chownFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 }
 
 SyscallReturn
-fchownFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
+fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
 {
     int fd = process->sim_fd(tc->getSyscallArg(0));
 
@@ -301,7 +301,7 @@ fchownFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 
 
 SyscallReturn
-dupFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
+dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
 {
     int fd = process->sim_fd(tc->getSyscallArg(0));
 
@@ -314,7 +314,7 @@ dupFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 
 
 SyscallReturn
-fcntlFunc(SyscallDesc *desc, int num, Process *process,
+fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process,
           ThreadContext *tc)
 {
     int fd = tc->getSyscallArg(0);
@@ -356,7 +356,7 @@ fcntlFunc(SyscallDesc *desc, int num, Process *process,
 }
 
 SyscallReturn
-fcntl64Func(SyscallDesc *desc, int num, Process *process,
+fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process,
             ThreadContext *tc)
 {
     int fd = tc->getSyscallArg(0);
@@ -385,7 +385,7 @@ fcntl64Func(SyscallDesc *desc, int num, Process *process,
 }
 
 SyscallReturn
-pipePseudoFunc(SyscallDesc *desc, int callnum, Process *process,
+pipePseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
          ThreadContext *tc)
 {
     int fds[2], sim_fds[2];
@@ -407,43 +407,43 @@ pipePseudoFunc(SyscallDesc *desc, int callnum, Process *process,
 
 
 SyscallReturn
-getpidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
+getpidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     // Make up a PID.  There's no interprocess communication in
     // fake_syscall mode, so there's no way for a process to know it's
     // not getting a unique value.
 
-    tc->setIntReg(SyscallPseudoReturnReg, process->ppid);
-    return process->pid;
+    tc->setIntReg(SyscallPseudoReturnReg, process->ppid());
+    return process->pid();
 }
 
 
 SyscallReturn
-getuidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
+getuidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     // Make up a UID and EUID... it shouldn't matter, and we want the
     // simulation to be deterministic.
 
     // EUID goes in r20.
-    tc->setIntReg(SyscallPseudoReturnReg, process->euid); //EUID
-    return process->uid;		// UID
+    tc->setIntReg(SyscallPseudoReturnReg, process->euid()); //EUID
+    return process->uid();		// UID
 }
 
 
 SyscallReturn
-getgidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
+getgidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     // Get current group ID.  EGID goes in r20.
-    tc->setIntReg(SyscallPseudoReturnReg, process->egid); //EGID
-    return process->gid;
+    tc->setIntReg(SyscallPseudoReturnReg, process->egid()); //EGID
+    return process->gid();
 }
 
 
 SyscallReturn
-setuidFunc(SyscallDesc *desc, int callnum, Process *process,
+setuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     // can't fathom why a benchmark would call this.
@@ -452,50 +452,50 @@ setuidFunc(SyscallDesc *desc, int callnum, Process *process,
 }
 
 SyscallReturn
-getpidFunc(SyscallDesc *desc, int callnum, Process *process,
+getpidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     // Make up a PID.  There's no interprocess communication in
     // fake_syscall mode, so there's no way for a process to know it's
     // not getting a unique value.
 
-    tc->setIntReg(SyscallPseudoReturnReg, process->ppid); //PID
-    return process->pid;
+    tc->setIntReg(SyscallPseudoReturnReg, process->ppid()); //PID
+    return process->pid();
 }
 
 SyscallReturn
-getppidFunc(SyscallDesc *desc, int callnum, Process *process,
+getppidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
-    return process->ppid;
+    return process->ppid();
 }
 
 SyscallReturn
-getuidFunc(SyscallDesc *desc, int callnum, Process *process,
+getuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
-    return process->uid;		// UID
+    return process->uid();		// UID
 }
 
 SyscallReturn
-geteuidFunc(SyscallDesc *desc, int callnum, Process *process,
+geteuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
-    return process->euid;		// UID
+    return process->euid();		// UID
 }
 
 SyscallReturn
-getgidFunc(SyscallDesc *desc, int callnum, Process *process,
+getgidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
-    return process->gid;
+    return process->gid();
 }
 
 SyscallReturn
-getegidFunc(SyscallDesc *desc, int callnum, Process *process,
+getegidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
-    return process->egid;
+    return process->egid();
 }
 
 
diff --git a/src/sim/syscall_emul.hh b/src/sim/syscall_emul.hh
index 978e0bce7..edd4e331d 100644
--- a/src/sim/syscall_emul.hh
+++ b/src/sim/syscall_emul.hh
@@ -70,7 +70,7 @@ class SyscallDesc {
 
     /// Typedef for target syscall handler functions.
     typedef SyscallReturn (*FuncPtr)(SyscallDesc *, int num,
-                           Process *, ThreadContext *);
+                           LiveProcess *, ThreadContext *);
 
     const char *name;	//!< Syscall name (e.g., "open").
     FuncPtr funcPtr;	//!< Pointer to emulation function.
@@ -92,7 +92,7 @@ class SyscallDesc {
     }
 
     /// Emulate the syscall.  Public interface for calling through funcPtr.
-    void doSyscall(int callnum, Process *proc, ThreadContext *tc);
+    void doSyscall(int callnum, LiveProcess *proc, ThreadContext *tc);
 };
 
 
@@ -174,137 +174,137 @@ class TypedBufferArg : public BaseBufferArg
 
 /// Handler for unimplemented syscalls that we haven't thought about.
 SyscallReturn unimplementedFunc(SyscallDesc *desc, int num,
-                                Process *p, ThreadContext *tc);
+                                LiveProcess *p, ThreadContext *tc);
 
 /// Handler for unimplemented syscalls that we never intend to
 /// implement (signal handling, etc.) and should not affect the correct
 /// behavior of the program.  Print a warning only if the appropriate
 /// trace flag is enabled.  Return success to the target program.
 SyscallReturn ignoreFunc(SyscallDesc *desc, int num,
-                         Process *p, ThreadContext *tc);
+                         LiveProcess *p, ThreadContext *tc);
 
 /// Target exit() handler: terminate simulation.
 SyscallReturn exitFunc(SyscallDesc *desc, int num,
-                       Process *p, ThreadContext *tc);
+                       LiveProcess *p, ThreadContext *tc);
 
 /// Target getpagesize() handler.
 SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num,
-                              Process *p, ThreadContext *tc);
+                              LiveProcess *p, ThreadContext *tc);
 
 /// Target obreak() handler: set brk address.
 SyscallReturn obreakFunc(SyscallDesc *desc, int num,
-                         Process *p, ThreadContext *tc);
+                         LiveProcess *p, ThreadContext *tc);
 
 /// Target close() handler.
 SyscallReturn closeFunc(SyscallDesc *desc, int num,
-                        Process *p, ThreadContext *tc);
+                        LiveProcess *p, ThreadContext *tc);
 
 /// Target read() handler.
 SyscallReturn readFunc(SyscallDesc *desc, int num,
-                       Process *p, ThreadContext *tc);
+                       LiveProcess *p, ThreadContext *tc);
 
 /// Target write() handler.
 SyscallReturn writeFunc(SyscallDesc *desc, int num,
-                        Process *p, ThreadContext *tc);
+                        LiveProcess *p, ThreadContext *tc);
 
 /// Target lseek() handler.
 SyscallReturn lseekFunc(SyscallDesc *desc, int num,
-                        Process *p, ThreadContext *tc);
+                        LiveProcess *p, ThreadContext *tc);
 
 /// Target munmap() handler.
 SyscallReturn munmapFunc(SyscallDesc *desc, int num,
-                         Process *p, ThreadContext *tc);
+                         LiveProcess *p, ThreadContext *tc);
 
 /// Target gethostname() handler.
 SyscallReturn gethostnameFunc(SyscallDesc *desc, int num,
-                              Process *p, ThreadContext *tc);
+                              LiveProcess *p, ThreadContext *tc);
 
 /// Target unlink() handler.
 SyscallReturn unlinkFunc(SyscallDesc *desc, int num,
-                         Process *p, ThreadContext *tc);
+                         LiveProcess *p, ThreadContext *tc);
 
 /// Target rename() handler.
 SyscallReturn renameFunc(SyscallDesc *desc, int num,
-                         Process *p, ThreadContext *tc);
+                         LiveProcess *p, ThreadContext *tc);
 
 
 /// Target truncate() handler.
 SyscallReturn truncateFunc(SyscallDesc *desc, int num,
-                           Process *p, ThreadContext *tc);
+                           LiveProcess *p, ThreadContext *tc);
 
 
 /// Target ftruncate() handler.
 SyscallReturn ftruncateFunc(SyscallDesc *desc, int num,
-                            Process *p, ThreadContext *tc);
+                            LiveProcess *p, ThreadContext *tc);
 
 
 /// Target chown() handler.
 SyscallReturn chownFunc(SyscallDesc *desc, int num,
-                        Process *p, ThreadContext *tc);
+                        LiveProcess *p, ThreadContext *tc);
 
 
 /// Target fchown() handler.
 SyscallReturn fchownFunc(SyscallDesc *desc, int num,
-                         Process *p, ThreadContext *tc);
+                         LiveProcess *p, ThreadContext *tc);
 
 /// Target dup() handler.
 SyscallReturn dupFunc(SyscallDesc *desc, int num,
-                      Process *process, ThreadContext *tc);
+                      LiveProcess *process, ThreadContext *tc);
 
 /// Target fnctl() handler.
 SyscallReturn fcntlFunc(SyscallDesc *desc, int num,
-                        Process *process, ThreadContext *tc);
+                        LiveProcess *process, ThreadContext *tc);
 
 /// Target fcntl64() handler.
 SyscallReturn fcntl64Func(SyscallDesc *desc, int num,
-                        Process *process, ThreadContext *tc);
+                        LiveProcess *process, ThreadContext *tc);
 
 /// Target setuid() handler.
 SyscallReturn setuidFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 /// Target getpid() handler.
 SyscallReturn getpidFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 /// Target getuid() handler.
 SyscallReturn getuidFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 /// Target getgid() handler.
 SyscallReturn getgidFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 /// Target getppid() handler.
 SyscallReturn getppidFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 /// Target geteuid() handler.
 SyscallReturn geteuidFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 /// Target getegid() handler.
 SyscallReturn getegidFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 
 
 /// Pseudo Funcs  - These functions use a different return convension,
 /// returning a second value in a register other than the normal return register
 SyscallReturn pipePseudoFunc(SyscallDesc *desc, int num,
-                             Process *process, ThreadContext *tc);
+                             LiveProcess *process, ThreadContext *tc);
 
 /// Target getpidPseudo() handler.
 SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 /// Target getuidPseudo() handler.
 SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 /// Target getgidPseudo() handler.
 SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num,
-                               Process *p, ThreadContext *tc);
+                               LiveProcess *p, ThreadContext *tc);
 
 
 /// A readable name for 1,000,000, for converting microseconds to seconds.
@@ -363,11 +363,11 @@ convertStatBuf(target_stat &tgt, host_stat *host, bool fakeTTY = false)
     tgt->st_rdev = htog(tgt->st_rdev);
     tgt->st_size = host->st_size;
     tgt->st_size = htog(tgt->st_size);
-    tgt->st_atimeX = host->st_atimeX;
+    tgt->st_atimeX = host->st_atime;
     tgt->st_atimeX = htog(tgt->st_atimeX);
-    tgt->st_mtimeX = host->st_mtimeX;
+    tgt->st_mtimeX = host->st_mtime;
     tgt->st_mtimeX = htog(tgt->st_mtimeX);
-    tgt->st_ctimeX = host->st_ctimeX;
+    tgt->st_ctimeX = host->st_ctime;
     tgt->st_ctimeX = htog(tgt->st_ctimeX);
     tgt->st_blksize = host->st_blksize;
     tgt->st_blksize = htog(tgt->st_blksize);
@@ -424,7 +424,7 @@ copyOutStat64Buf(TranslatingPort * mem, Addr addr,
 /// do line or block buffering.
 template <class OS>
 SyscallReturn
-ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
+ioctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     int fd = tc->getSyscallArg(0);
@@ -457,7 +457,7 @@ ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target open() handler.
 template <class OS>
 SyscallReturn
-openFunc(SyscallDesc *desc, int callnum, Process *process,
+openFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
          ThreadContext *tc)
 {
     std::string path;
@@ -504,7 +504,7 @@ openFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target chmod() handler.
 template <class OS>
 SyscallReturn
-chmodFunc(SyscallDesc *desc, int callnum, Process *process,
+chmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     std::string path;
@@ -530,7 +530,7 @@ chmodFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target fchmod() handler.
 template <class OS>
 SyscallReturn
-fchmodFunc(SyscallDesc *desc, int callnum, Process *process,
+fchmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     int fd = tc->getSyscallArg(0);
@@ -557,7 +557,7 @@ fchmodFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target stat() handler.
 template <class OS>
 SyscallReturn
-statFunc(SyscallDesc *desc, int callnum, Process *process,
+statFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
          ThreadContext *tc)
 {
     std::string path;
@@ -580,7 +580,7 @@ statFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target fstat64() handler.
 template <class OS>
 SyscallReturn
-fstat64Func(SyscallDesc *desc, int callnum, Process *process,
+fstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
             ThreadContext *tc)
 {
     int fd = tc->getSyscallArg(0);
@@ -600,7 +600,8 @@ fstat64Func(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    copyOutStat64Buf<OS>(tc->getMemPort(), fd, tc->getSyscallArg(1), &hostBuf);
+    copyOutStat64Buf<OS>(tc->getMemPort(), tc->getSyscallArg(1),
+        &hostBuf, (fd == 1));
 
     return 0;
 }
@@ -609,7 +610,7 @@ fstat64Func(SyscallDesc *desc, int callnum, Process *process,
 /// Target lstat() handler.
 template <class OS>
 SyscallReturn
-lstatFunc(SyscallDesc *desc, int callnum, Process *process,
+lstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     std::string path;
@@ -631,7 +632,7 @@ lstatFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target lstat64() handler.
 template <class OS>
 SyscallReturn
-lstat64Func(SyscallDesc *desc, int callnum, Process *process,
+lstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
             ThreadContext *tc)
 {
     std::string path;
@@ -650,7 +651,7 @@ lstat64Func(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    copyOutStat64Buf<OS>(tc->getMemPort(), -1, tc->getSyscallArg(1), &hostBuf);
+    copyOutStat64Buf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 
     return 0;
 }
@@ -658,7 +659,7 @@ lstat64Func(SyscallDesc *desc, int callnum, Process *process,
 /// Target fstat() handler.
 template <class OS>
 SyscallReturn
-fstatFunc(SyscallDesc *desc, int callnum, Process *process,
+fstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     int fd = process->sim_fd(tc->getSyscallArg(0));
@@ -674,7 +675,8 @@ fstatFunc(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    copyOutStatBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
+    copyOutStatBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1),
+        &hostBuf, (fd == 1));
 
     return 0;
 }
@@ -683,7 +685,7 @@ fstatFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target statfs() handler.
 template <class OS>
 SyscallReturn
-statfsFunc(SyscallDesc *desc, int callnum, Process *process,
+statfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     std::string path;
@@ -697,7 +699,8 @@ statfsFunc(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    copyOutStatfsBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStatfsBuf(tc->getMemPort(),
+            (Addr)(tc->getSyscallArg(1)), &hostBuf);
 
     return 0;
 }
@@ -706,7 +709,7 @@ statfsFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target fstatfs() handler.
 template <class OS>
 SyscallReturn
-fstatfsFunc(SyscallDesc *desc, int callnum, Process *process,
+fstatfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
             ThreadContext *tc)
 {
     int fd = process->sim_fd(tc->getSyscallArg(0));
@@ -720,7 +723,8 @@ fstatfsFunc(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    copyOutStatfsBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStatfsBuf(tc->getMemPort(), tc->getSyscallArg(1),
+        &hostBuf);
 
     return 0;
 }
@@ -729,7 +733,7 @@ fstatfsFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target writev() handler.
 template <class OS>
 SyscallReturn
-writevFunc(SyscallDesc *desc, int callnum, Process *process,
+writevFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     int fd = tc->getSyscallArg(0);
@@ -782,7 +786,7 @@ writevFunc(SyscallDesc *desc, int callnum, Process *process,
 /// anything else.
 template <class OS>
 SyscallReturn
-mmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+mmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 {
     Addr start = tc->getSyscallArg(0);
     uint64_t length = tc->getSyscallArg(1);
@@ -820,7 +824,7 @@ mmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 /// Target getrlimit() handler.
 template <class OS>
 SyscallReturn
-getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
+getrlimitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
         ThreadContext *tc)
 {
     unsigned resource = tc->getSyscallArg(0);
@@ -848,7 +852,7 @@ getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target gettimeofday() handler.
 template <class OS>
 SyscallReturn
-gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
+gettimeofdayFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
         ThreadContext *tc)
 {
     TypedBufferArg<typename OS::timeval> tp(tc->getSyscallArg(0));
@@ -867,7 +871,7 @@ gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target utimes() handler.
 template <class OS>
 SyscallReturn
-utimesFunc(SyscallDesc *desc, int callnum, Process *process,
+utimesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
            ThreadContext *tc)
 {
     std::string path;
@@ -894,7 +898,7 @@ utimesFunc(SyscallDesc *desc, int callnum, Process *process,
 /// Target getrusage() function.
 template <class OS>
 SyscallReturn
-getrusageFunc(SyscallDesc *desc, int callnum, Process *process,
+getrusageFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
               ThreadContext *tc)
 {
     int who = tc->getSyscallArg(0);	// THREAD, SELF, or CHILDREN