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

21 files changed, 396 insertions, 298 deletions

diff --git a/src/arch/alpha/linux/process.cc b/src/arch/alpha/linux/process.cc
index 357ebdada..56342dbc5 100644
--- a/src/arch/alpha/linux/process.cc
+++ b/src/arch/alpha/linux/process.cc
@@ -47,7 +47,7 @@ using namespace AlphaISA;
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, Process *process,
+unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     TypedBufferArg<Linux::utsname> name(tc->getSyscallArg(0));
@@ -66,7 +66,7 @@ unameFunc(SyscallDesc *desc, int callnum, Process *process,
 /// borrowed from Tru64, the subcases that get used appear to be
 /// different in practice from those used by Tru64 processes.
 static SyscallReturn
-osf_getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
+osf_getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                    ThreadContext *tc)
 {
     unsigned op = tc->getSyscallArg(0);
@@ -93,7 +93,7 @@ osf_getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
 
 /// Target osf_setsysinfo() handler.
 static SyscallReturn
-osf_setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
+osf_setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                    ThreadContext *tc)
 {
     unsigned op = tc->getSyscallArg(0);
@@ -575,9 +575,15 @@ AlphaLinuxProcess::AlphaLinuxProcess(const std::string &name,
                                      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)
     : AlphaLiveProcess(name, objFile, system, stdin_fd, stdout_fd,
-            stderr_fd, argv, envp),
+            stderr_fd, argv, envp, _uid, _euid, _gid, _egid, _pid, _ppid),
      Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
 {
     //init_regs->intRegFile[0] = 0;
diff --git a/src/arch/alpha/linux/process.hh b/src/arch/alpha/linux/process.hh
index 9cc7dc7b6..b23904844 100644
--- a/src/arch/alpha/linux/process.hh
+++ b/src/arch/alpha/linux/process.hh
@@ -45,7 +45,10 @@ class AlphaLinuxProcess : public AlphaLiveProcess
                       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 SyscallDesc* getDesc(int callnum);
 
diff --git a/src/arch/alpha/process.cc b/src/arch/alpha/process.cc
index 32fb97229..9e360e80f 100644
--- a/src/arch/alpha/process.cc
+++ b/src/arch/alpha/process.cc
@@ -42,9 +42,11 @@ using namespace std;
 
 AlphaLiveProcess::AlphaLiveProcess(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> &argv, std::vector<std::string> &envp,
+        uint64_t _uid, uint64_t _euid, uint64_t _gid, uint64_t _egid,
+        uint64_t _pid, uint64_t _ppid)
     : LiveProcess(nm, objFile, _system, stdin_fd, stdout_fd, stderr_fd,
-        argv, envp)
+        argv, envp, _uid, _euid, _gid, _egid, _pid, _ppid)
 {
     brk_point = objFile->dataBase() + objFile->dataSize() + objFile->bssSize();
     brk_point = roundUp(brk_point, VMPageSize);
diff --git a/src/arch/alpha/process.hh b/src/arch/alpha/process.hh
index 5d5c9a52e..c4aeb1885 100644
--- a/src/arch/alpha/process.hh
+++ b/src/arch/alpha/process.hh
@@ -46,7 +46,10 @@ class AlphaLiveProcess : public LiveProcess
     AlphaLiveProcess(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);
 
     void startup();
 };
diff --git a/src/arch/alpha/tru64/process.cc b/src/arch/alpha/tru64/process.cc
index 82e44b9e7..55b8ebf8b 100644
--- a/src/arch/alpha/tru64/process.cc
+++ b/src/arch/alpha/tru64/process.cc
@@ -44,7 +44,7 @@ using namespace AlphaISA;
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, Process *process,
+unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     TypedBufferArg<AlphaTru64::utsname> name(tc->getSyscallArg(0));
@@ -61,7 +61,7 @@ unameFunc(SyscallDesc *desc, int callnum, Process *process,
 
 /// Target getsysyinfo() handler.
 static SyscallReturn
-getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
+getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                ThreadContext *tc)
 {
     unsigned op = tc->getSyscallArg(0);
@@ -140,7 +140,7 @@ getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
 
 /// Target setsysyinfo() handler.
 static SyscallReturn
-setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
+setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                ThreadContext *tc)
 {
     unsigned op = tc->getSyscallArg(0);
@@ -162,7 +162,7 @@ setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
 
 /// Target table() handler.
 static
-SyscallReturn tableFunc(SyscallDesc *desc, int callnum,Process *process,
+SyscallReturn tableFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                         ThreadContext *tc)
 {
     using namespace std;
@@ -269,8 +269,8 @@ SyscallDesc AlphaTru64Process::syscallDescs[] = {
     /* 64 */ SyscallDesc("getpagesize", getpagesizeFunc),
     /* 65 */ SyscallDesc("mremap", unimplementedFunc),
     /* 66 */ SyscallDesc("vfork", unimplementedFunc),
-    /* 67 */ SyscallDesc("pre_F64_stat", statFunc<AlphaTru64::PreF64>),
-    /* 68 */ SyscallDesc("pre_F64_lstat", lstatFunc<AlphaTru64::PreF64>),
+    /* 67 */ SyscallDesc("pre_F64_stat", statFunc<Tru64_PreF64>),
+    /* 68 */ SyscallDesc("pre_F64_lstat", lstatFunc<Tru64_PreF64>),
     /* 69 */ SyscallDesc("sbrk", unimplementedFunc),
     /* 70 */ SyscallDesc("sstk", unimplementedFunc),
     /* 71 */ SyscallDesc("mmap", mmapFunc<AlphaTru64>),
@@ -293,7 +293,7 @@ SyscallDesc AlphaTru64Process::syscallDescs[] = {
     /* 88 */ SyscallDesc("sethostname", unimplementedFunc),
     /* 89 */ SyscallDesc("getdtablesize", unimplementedFunc),
     /* 90 */ SyscallDesc("dup2", unimplementedFunc),
-    /* 91 */ SyscallDesc("pre_F64_fstat", fstatFunc<AlphaTru64::PreF64>),
+    /* 91 */ SyscallDesc("pre_F64_fstat", fstatFunc<Tru64_PreF64>),
     /* 92 */ SyscallDesc("fcntl", fcntlFunc),
     /* 93 */ SyscallDesc("select", unimplementedFunc),
     /* 94 */ SyscallDesc("poll", unimplementedFunc),
@@ -363,8 +363,8 @@ SyscallDesc AlphaTru64Process::syscallDescs[] = {
     /* 157 */ SyscallDesc("sigwaitprim", unimplementedFunc),
     /* 158 */ SyscallDesc("nfssvc", unimplementedFunc),
     /* 159 */ SyscallDesc("getdirentries", AlphaTru64::getdirentriesFunc),
-    /* 160 */ SyscallDesc("pre_F64_statfs", statfsFunc<AlphaTru64::PreF64>),
-    /* 161 */ SyscallDesc("pre_F64_fstatfs", fstatfsFunc<AlphaTru64::PreF64>),
+    /* 160 */ SyscallDesc("pre_F64_statfs", statfsFunc<Tru64_PreF64>),
+    /* 161 */ SyscallDesc("pre_F64_fstatfs", fstatfsFunc<Tru64_PreF64>),
     /* 162 */ SyscallDesc("unknown #162", unimplementedFunc),
     /* 163 */ SyscallDesc("async_daemon", unimplementedFunc),
     /* 164 */ SyscallDesc("getfh", unimplementedFunc),
@@ -427,11 +427,11 @@ SyscallDesc AlphaTru64Process::syscallDescs[] = {
     /* 221 */ SyscallDesc("unknown #221", unimplementedFunc),
     /* 222 */ SyscallDesc("security", unimplementedFunc),
     /* 223 */ SyscallDesc("kloadcall", unimplementedFunc),
-    /* 224 */ SyscallDesc("stat", statFunc<AlphaTru64::F64>),
-    /* 225 */ SyscallDesc("lstat", lstatFunc<AlphaTru64::F64>),
-    /* 226 */ SyscallDesc("fstat", fstatFunc<AlphaTru64::F64>),
-    /* 227 */ SyscallDesc("statfs", statfsFunc<AlphaTru64::F64>),
-    /* 228 */ SyscallDesc("fstatfs", fstatfsFunc<AlphaTru64::F64>),
+    /* 224 */ SyscallDesc("stat", statFunc<Tru64_F64>),
+    /* 225 */ SyscallDesc("lstat", lstatFunc<Tru64_F64>),
+    /* 226 */ SyscallDesc("fstat", fstatFunc<Tru64_F64>),
+    /* 227 */ SyscallDesc("statfs", statfsFunc<Tru64_F64>),
+    /* 228 */ SyscallDesc("fstatfs", fstatfsFunc<Tru64_F64>),
     /* 229 */ SyscallDesc("getfsstat", unimplementedFunc),
     /* 230 */ SyscallDesc("gettimeofday64", unimplementedFunc),
     /* 231 */ SyscallDesc("settimeofday64", unimplementedFunc),
@@ -580,9 +580,12 @@ AlphaTru64Process::AlphaTru64Process(const std::string &name,
                                      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)
     : AlphaLiveProcess(name, objFile, system, stdin_fd, stdout_fd,
-            stderr_fd, argv, envp),
+            stderr_fd, argv, envp, _uid, _euid, _gid, _egid, _pid, _ppid),
       Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc)),
       Num_Mach_Syscall_Descs(sizeof(machSyscallDescs) / sizeof(SyscallDesc))
 {
diff --git a/src/arch/alpha/tru64/process.hh b/src/arch/alpha/tru64/process.hh
index 5d91f6ac1..23429dad3 100644
--- a/src/arch/alpha/tru64/process.hh
+++ b/src/arch/alpha/tru64/process.hh
@@ -44,7 +44,10 @@ class AlphaTru64Process : public AlphaLiveProcess
                       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);
 
     /// Array of syscall descriptors, indexed by call number.
     static SyscallDesc syscallDescs[];
diff --git a/src/arch/mips/linux/process.cc b/src/arch/mips/linux/process.cc
index 17e735527..d182cfa30 100644
--- a/src/arch/mips/linux/process.cc
+++ b/src/arch/mips/linux/process.cc
@@ -44,7 +44,7 @@ using namespace MipsISA;
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, Process *process,
+unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     TypedBufferArg<Linux::utsname> name(tc->getSyscallArg(0));
@@ -63,7 +63,7 @@ unameFunc(SyscallDesc *desc, int callnum, Process *process,
 /// borrowed from Tru64, the subcases that get used appear to be
 /// different in practice from those used by Tru64 processes.
 static SyscallReturn
-sys_getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
+sys_getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                    ThreadContext *tc)
 {
     unsigned op = tc->getSyscallArg(0);
@@ -90,7 +90,7 @@ sys_getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
 
 /// Target sys_setsysinfo() handler.
 static SyscallReturn
-sys_setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
+sys_setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                    ThreadContext *tc)
 {
     unsigned op = tc->getSyscallArg(0);
@@ -410,9 +410,15 @@ MipsLinuxProcess::MipsLinuxProcess(const std::string &name,
                                      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)
     : MipsLiveProcess(name, objFile, system, stdin_fd, stdout_fd, stderr_fd,
-                      argv, envp),
+                      argv, envp, _uid, _euid, _gid, _egid, _pid, _ppid),
      Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
 { }
 
diff --git a/src/arch/mips/linux/process.hh b/src/arch/mips/linux/process.hh
index 68da3227b..06f86379c 100644
--- a/src/arch/mips/linux/process.hh
+++ b/src/arch/mips/linux/process.hh
@@ -42,7 +42,10 @@ class MipsLinuxProcess : public MipsLiveProcess
                       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 SyscallDesc* getDesc(int callnum);
 
diff --git a/src/arch/mips/process.cc b/src/arch/mips/process.cc
index 031c2030e..4bc91ca24 100644
--- a/src/arch/mips/process.cc
+++ b/src/arch/mips/process.cc
@@ -43,9 +43,11 @@ using namespace MipsISA;
 
 MipsLiveProcess::MipsLiveProcess(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> &argv, std::vector<std::string> &envp,
+        uint64_t _uid, uint64_t _euid, uint64_t _gid, uint64_t _egid,
+        uint64_t _pid, uint64_t _ppid)
     : LiveProcess(nm, objFile, _system, stdin_fd, stdout_fd, stderr_fd,
-        argv, envp)
+        argv, envp, _uid, _euid, _gid, _egid, _pid, _ppid)
 {
     // Set up stack. On MIPS, stack starts at the top of kuseg
     // user address space. MIPS stack grows down from here
diff --git a/src/arch/mips/process.hh b/src/arch/mips/process.hh
index 400591599..fb004375d 100644
--- a/src/arch/mips/process.hh
+++ b/src/arch/mips/process.hh
@@ -47,7 +47,10 @@ class MipsLiveProcess : public LiveProcess
     MipsLiveProcess(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);
 
     void startup();
 
diff --git a/src/arch/sparc/linux/process.cc b/src/arch/sparc/linux/process.cc
index 8c2de8ca3..44c893f2b 100644
--- a/src/arch/sparc/linux/process.cc
+++ b/src/arch/sparc/linux/process.cc
@@ -47,7 +47,7 @@ using namespace SparcISA;
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, Process *process,
+unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     TypedBufferArg<Linux::utsname> name(tc->getSyscallArg(0));
@@ -65,7 +65,7 @@ unameFunc(SyscallDesc *desc, int callnum, Process *process,
 
 
 SyscallReturn SparcISA::getresuidFunc(SyscallDesc *desc, int num,
-                                         Process *p, ThreadContext *tc)
+                                         LiveProcess *p, ThreadContext *tc)
 {
     const IntReg id = htog(100);
     Addr ruid = tc->getSyscallArg(0);
@@ -390,9 +390,13 @@ SparcLinuxProcess::SparcLinuxProcess(const std::string &name,
                                      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)
     : SparcLiveProcess(name, objFile, system,
-            stdin_fd, stdout_fd, stderr_fd, argv, envp),
+            stdin_fd, stdout_fd, stderr_fd, argv, envp,
+            _uid, _euid, _gid, _egid, _pid, _ppid),
      Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
 {
     // The sparc syscall table must be <= 284 entries because that is all there
diff --git a/src/arch/sparc/linux/process.hh b/src/arch/sparc/linux/process.hh
index 4af8f0f75..c758d5433 100644
--- a/src/arch/sparc/linux/process.hh
+++ b/src/arch/sparc/linux/process.hh
@@ -48,7 +48,10 @@ class SparcLinuxProcess : public SparcLiveProcess
                       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 SyscallDesc* getDesc(int callnum);
 
@@ -62,7 +65,7 @@ class SparcLinuxProcess : public SparcLiveProcess
 };
 
 SyscallReturn getresuidFunc(SyscallDesc *desc, int num,
-                                 Process *p, ThreadContext *tc);
+                                 LiveProcess *p, ThreadContext *tc);
 
 } // namespace SparcISA
 #endif // __ALPHA_LINUX_PROCESS_HH__
diff --git a/src/arch/sparc/process.cc b/src/arch/sparc/process.cc
index a3bb0eb1a..3323ba7a0 100644
--- a/src/arch/sparc/process.cc
+++ b/src/arch/sparc/process.cc
@@ -45,9 +45,11 @@ using namespace SparcISA;
 
 SparcLiveProcess::SparcLiveProcess(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> &argv, std::vector<std::string> &envp,
+        uint64_t _uid, uint64_t _euid, uint64_t _gid, uint64_t _egid,
+        uint64_t _pid, uint64_t _ppid)
     : LiveProcess(nm, objFile, _system, stdin_fd, stdout_fd, stderr_fd,
-        argv, envp)
+        argv, envp, _uid, _euid, _gid, _egid, _pid, _ppid)
 {
 
     // XXX all the below need to be updated for SPARC - Ali
@@ -190,10 +192,10 @@ SparcLiveProcess::argsInit(int intSize, int pageSize)
         //The entry point to the program
         auxv.push_back(buildAuxVect(SPARC_AT_ENTRY, objFile->entryPoint()));
         //Different user and group IDs
-        auxv.push_back(buildAuxVect(SPARC_AT_UID, uid));
-        auxv.push_back(buildAuxVect(SPARC_AT_EUID, euid));
-        auxv.push_back(buildAuxVect(SPARC_AT_GID, gid));
-        auxv.push_back(buildAuxVect(SPARC_AT_EGID, egid));
+        auxv.push_back(buildAuxVect(SPARC_AT_UID, uid()));
+        auxv.push_back(buildAuxVect(SPARC_AT_EUID, euid()));
+        auxv.push_back(buildAuxVect(SPARC_AT_GID, gid()));
+        auxv.push_back(buildAuxVect(SPARC_AT_EGID, egid()));
         //Whether to enable "secure mode" in the executable
         auxv.push_back(buildAuxVect(SPARC_AT_SECURE, 0));
     }
diff --git a/src/arch/sparc/process.hh b/src/arch/sparc/process.hh
index 7ba8d7109..7cc52e241 100644
--- a/src/arch/sparc/process.hh
+++ b/src/arch/sparc/process.hh
@@ -60,7 +60,10 @@ class SparcLiveProcess : public LiveProcess
     SparcLiveProcess(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);
 
     void startup();
 
diff --git a/src/arch/sparc/solaris/process.cc b/src/arch/sparc/solaris/process.cc
index af0550910..ff466c8e6 100644
--- a/src/arch/sparc/solaris/process.cc
+++ b/src/arch/sparc/solaris/process.cc
@@ -45,7 +45,7 @@ using namespace SparcISA;
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, Process *process,
+unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
           ThreadContext *tc)
 {
     TypedBufferArg<Solaris::utsname> name(tc->getSyscallArg(0));
@@ -328,9 +328,16 @@ SparcSolarisProcess::SparcSolarisProcess(const std::string &name,
                                      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)
     : SparcLiveProcess(name, objFile, system,
-            stdin_fd, stdout_fd, stderr_fd, argv, envp),
+            stdin_fd, stdout_fd, stderr_fd, argv, envp,
+            _uid, _euid, _gid, _egid, _pid, _ppid),
      Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
 {
     // The sparc syscall table must be <= 284 entries because that is all there
diff --git a/src/arch/sparc/solaris/process.hh b/src/arch/sparc/solaris/process.hh
index 3c0d7eba7..2cf329211 100644
--- a/src/arch/sparc/solaris/process.hh
+++ b/src/arch/sparc/solaris/process.hh
@@ -47,7 +47,10 @@ class SparcSolarisProcess : public SparcLiveProcess
                       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 SyscallDesc* getDesc(int callnum);
 
diff --git a/src/kern/tru64/tru64.hh b/src/kern/tru64/tru64.hh
index 63d4f3a9b..87ac88007 100644
--- a/src/kern/tru64/tru64.hh
+++ b/src/kern/tru64/tru64.hh
@@ -90,71 +90,6 @@ class Tru64 : public OperatingSystem
     typedef quad fsid_t;
     //@}
 
-    /// Stat buffer.  Note that Tru64 v5.0+ use a new "F64" stat
-    /// structure, and a new set of syscall numbers for stat calls.
-    /// On some hosts (notably Linux) define st_atime, st_mtime, and
-    /// st_ctime as macros, so we append an X to get around this.
-    struct F64_stat {
-        dev_t	st_dev;			//!< st_dev
-        int32_t	st_retired1;		//!< st_retired1
-        mode_t	st_mode;		//!< st_mode
-        nlink_t	st_nlink;		//!< st_nlink
-        uint16_t st_nlink_reserved;	//!< st_nlink_reserved
-        uid_t	st_uid;			//!< st_uid
-        gid_t	st_gid;			//!< st_gid
-        dev_t	st_rdev;		//!< st_rdev
-        dev_t	st_ldev;		//!< st_ldev
-        off_t	st_size;		//!< st_size
-        time_t	st_retired2;		//!< st_retired2
-        int32_t	st_uatime;		//!< st_uatime
-        time_t	st_retired3;		//!< st_retired3
-        int32_t	st_umtime;		//!< st_umtime
-        time_t	st_retired4;		//!< st_retired4
-        int32_t	st_uctime;		//!< st_uctime
-        int32_t	st_retired5;		//!< st_retired5
-        int32_t	st_retired6;		//!< st_retired6
-        uint32_t	st_flags;	//!< st_flags
-        uint32_t	st_gen;		//!< st_gen
-        uint64_t	st_spare[4];	//!< st_spare[4]
-        ino_t	st_ino;			//!< st_ino
-        int32_t	st_ino_reserved;	//!< st_ino_reserved
-        time_t	st_atimeX;		//!< st_atime
-        int32_t	st_atime_reserved;	//!< st_atime_reserved
-        time_t	st_mtimeX;		//!< st_mtime
-        int32_t	st_mtime_reserved;	//!< st_mtime_reserved
-        time_t	st_ctimeX;		//!< st_ctime
-        int32_t	st_ctime_reserved;	//!< st_ctime_reserved
-        uint64_t	st_blksize;	//!< st_blksize
-        uint64_t	st_blocks;	//!< st_blocks
-    };
-
-
-    /// Old Tru64 v4.x stat struct.
-    /// Tru64 maintains backwards compatibility with v4.x by
-    /// implementing another set of stat functions using the old
-    /// structure definition and binding them to the old syscall
-    /// numbers.
-
-    struct pre_F64_stat {
-        dev_t   st_dev;
-        ino_t   st_ino;
-        mode_t  st_mode;
-        nlink_t st_nlink;
-        uid_t   st_uid __attribute__ ((aligned(sizeof(uid_t))));
-        gid_t   st_gid;
-        dev_t   st_rdev;
-        off_t   st_size __attribute__ ((aligned(sizeof(off_t))));
-        time_t  st_atimeX;
-        int32_t st_uatime;
-        time_t  st_mtimeX;
-        int32_t st_umtime;
-        time_t  st_ctimeX;
-        int32_t st_uctime;
-        uint32_t st_blksize;
-        int32_t st_blocks;
-        uint32_t st_flags;
-        uint32_t st_gen;
-    };
 
     /// For statfs().
     struct F64_statfs {
@@ -458,7 +393,7 @@ class Tru64 : public OperatingSystem
         uint64_t pad2[2];	//!< pad2
     };
 
-    /// Helper function to convert a host stat buffer to a target stat
+    /*/// Helper function to convert a host stat buffer to a target stat
     /// buffer.  Also copies the target buffer out to the simulated
     /// memory space.  Used by stat(), fstat(), and lstat().
     template <class T>
@@ -484,7 +419,7 @@ class Tru64 : public OperatingSystem
         tgt->st_blocks = htog(host->st_blocks);
 
         tgt.copyOut(mem);
-    }
+    }*/
 
     /// Helper function to convert a host statfs buffer to a target statfs
     /// buffer.  Also copies the target buffer out to the simulated
@@ -515,37 +450,7 @@ class Tru64 : public OperatingSystem
         tgt.copyOut(mem);
     }
 
-    class F64 {
-      public:
-        static void copyOutStatBuf(TranslatingPort *mem, Addr addr,
-                                   global_stat *host)
-        {
-            Tru64::copyOutStatBuf<Tru64::F64_stat>(mem, addr, host);
-        }
-
-        static void copyOutStatfsBuf(TranslatingPort *mem, Addr addr,
-                                     global_statfs *host)
-        {
-            Tru64::copyOutStatfsBuf<Tru64::F64_statfs>(mem, addr, host);
-        }
-    };
-
-    class PreF64 {
-      public:
-        static void copyOutStatBuf(TranslatingPort *mem, Addr addr,
-                                   global_stat *host)
-        {
-            Tru64::copyOutStatBuf<Tru64::pre_F64_stat>(mem, addr, host);
-        }
-
-        static void copyOutStatfsBuf(TranslatingPort *mem, Addr addr,
-                                     global_statfs *host)
-        {
-            Tru64::copyOutStatfsBuf<Tru64::pre_F64_statfs>(mem, addr, host);
-        }
-    };
-
-    /// Helper function to convert a host stat buffer to an old pre-F64
+/*    /// Helper function to convert a host stat buffer to an old pre-F64
     /// (4.x) target stat buffer.  Also copies the target buffer out to
     /// the simulated memory space.  Used by pre_F64_stat(),
     /// pre_F64_fstat(), and pre_F64_lstat().
@@ -571,7 +476,7 @@ class Tru64 : public OperatingSystem
         tgt->st_blocks = htog(host->st_blocks);
 
         tgt.copyOut(mem);
-    }
+    }*/
 
 
     /// The target system's hostname.
@@ -580,7 +485,7 @@ class Tru64 : public OperatingSystem
 
     /// Target getdirentries() handler.
     static SyscallReturn
-    getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process,
+    getdirentriesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                       ThreadContext *tc)
     {
         using namespace TheISA;
@@ -641,7 +546,7 @@ class Tru64 : public OperatingSystem
 
     /// Target sigreturn() handler.
     static SyscallReturn
-    sigreturnFunc(SyscallDesc *desc, int callnum, Process *process,
+    sigreturnFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                   ThreadContext *tc)
     {
         using namespace TheISA;
@@ -674,7 +579,7 @@ class Tru64 : public OperatingSystem
 
     /// Create a stack region for a thread.
     static SyscallReturn
-    stack_createFunc(SyscallDesc *desc, int callnum, Process *process,
+    stack_createFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                      ThreadContext *tc)
     {
         using namespace TheISA;
@@ -704,7 +609,7 @@ class Tru64 : public OperatingSystem
     /// schedulers by creating a shared-memory region.  The shared memory
     /// region has several structs, some global, some per-RAD, some per-VP.
     static SyscallReturn
-    nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process,
+    nxm_task_initFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                       ThreadContext *tc)
     {
         using namespace std;
@@ -838,7 +743,7 @@ class Tru64 : public OperatingSystem
 
     /// Create thread.
     static SyscallReturn
-    nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process,
+    nxm_thread_createFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                           ThreadContext *tc)
     {
         using namespace std;
@@ -955,7 +860,7 @@ class Tru64 : public OperatingSystem
 
     /// Thread idle call (like yield()).
     static SyscallReturn
-    nxm_idleFunc(SyscallDesc *desc, int callnum, Process *process,
+    nxm_idleFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                  ThreadContext *tc)
     {
         return 0;
@@ -963,7 +868,7 @@ class Tru64 : public OperatingSystem
 
     /// Block thread.
     static SyscallReturn
-    nxm_thread_blockFunc(SyscallDesc *desc, int callnum, Process *process,
+    nxm_thread_blockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                          ThreadContext *tc)
     {
         using namespace std;
@@ -982,7 +887,7 @@ class Tru64 : public OperatingSystem
 
     /// block.
     static SyscallReturn
-    nxm_blockFunc(SyscallDesc *desc, int callnum, Process *process,
+    nxm_blockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                   ThreadContext *tc)
     {
         using namespace std;
@@ -1005,7 +910,7 @@ class Tru64 : public OperatingSystem
 
     /// Unblock thread.
     static SyscallReturn
-    nxm_unblockFunc(SyscallDesc *desc, int callnum, Process *process,
+    nxm_unblockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                     ThreadContext *tc)
     {
         using namespace std;
@@ -1020,7 +925,7 @@ class Tru64 : public OperatingSystem
 
     /// Switch thread priority.
     static SyscallReturn
-    swtch_priFunc(SyscallDesc *desc, int callnum, Process *process,
+    swtch_priFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                   ThreadContext *tc)
     {
         // Attempts to switch to another runnable thread (if there is
@@ -1037,7 +942,7 @@ class Tru64 : public OperatingSystem
     /// Activate thread context waiting on a channel.  Just activate one
     /// by default.
     static int
-    activate_waiting_context(Addr uaddr, Process *process,
+    activate_waiting_context(Addr uaddr, LiveProcess *process,
                              bool activate_all = false)
     {
         using namespace std;
@@ -1068,7 +973,7 @@ class Tru64 : public OperatingSystem
 
     /// M5 hacked-up lock acquire.
     static void
-    m5_lock_mutex(Addr uaddr, Process *process, ThreadContext *tc)
+    m5_lock_mutex(Addr uaddr, LiveProcess *process, ThreadContext *tc)
     {
         using namespace TheISA;
 
@@ -1089,7 +994,7 @@ class Tru64 : public OperatingSystem
 
     /// M5 unlock call.
     static void
-    m5_unlock_mutex(Addr uaddr, Process *process, ThreadContext *tc)
+    m5_unlock_mutex(Addr uaddr, LiveProcess *process, ThreadContext *tc)
     {
         TypedBufferArg<uint64_t> lockp(uaddr);
 
@@ -1108,7 +1013,7 @@ class Tru64 : public OperatingSystem
 
     /// Lock acquire syscall handler.
     static SyscallReturn
-    m5_mutex_lockFunc(SyscallDesc *desc, int callnum, Process *process,
+    m5_mutex_lockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                       ThreadContext *tc)
     {
         Addr uaddr = tc->getSyscallArg(0);
@@ -1123,7 +1028,7 @@ class Tru64 : public OperatingSystem
 
     /// Try lock (non-blocking).
     static SyscallReturn
-    m5_mutex_trylockFunc(SyscallDesc *desc, int callnum, Process *process,
+    m5_mutex_trylockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                          ThreadContext *tc)
     {
         using namespace TheISA;
@@ -1145,7 +1050,7 @@ class Tru64 : public OperatingSystem
 
     /// Unlock syscall handler.
     static SyscallReturn
-    m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, Process *process,
+    m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                         ThreadContext *tc)
     {
         Addr uaddr = tc->getSyscallArg(0);
@@ -1157,7 +1062,7 @@ class Tru64 : public OperatingSystem
 
     /// Signal ocndition.
     static SyscallReturn
-    m5_cond_signalFunc(SyscallDesc *desc, int callnum, Process *process,
+    m5_cond_signalFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                        ThreadContext *tc)
     {
         Addr cond_addr = tc->getSyscallArg(0);
@@ -1170,7 +1075,7 @@ class Tru64 : public OperatingSystem
 
     /// Wake up all processes waiting on the condition variable.
     static SyscallReturn
-    m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, Process *process,
+    m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                           ThreadContext *tc)
     {
         Addr cond_addr = tc->getSyscallArg(0);
@@ -1182,7 +1087,7 @@ class Tru64 : public OperatingSystem
 
     /// Wait on a condition.
     static SyscallReturn
-    m5_cond_waitFunc(SyscallDesc *desc, int callnum, Process *process,
+    m5_cond_waitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                      ThreadContext *tc)
     {
         using namespace TheISA;
@@ -1206,7 +1111,7 @@ class Tru64 : public OperatingSystem
 
     /// Thread exit.
     static SyscallReturn
-    m5_thread_exitFunc(SyscallDesc *desc, int callnum, Process *process,
+    m5_thread_exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                        ThreadContext *tc)
     {
         assert(tc->status() == ThreadContext::Active);
@@ -1217,18 +1122,16 @@ class Tru64 : public OperatingSystem
 
     /// Indirect syscall invocation (call #0).
     static SyscallReturn
-    indirectSyscallFunc(SyscallDesc *desc, int callnum, Process *process,
+    indirectSyscallFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
                         ThreadContext *tc)
     {
         int new_callnum = tc->getSyscallArg(0);
-        LiveProcess *lp = dynamic_cast<LiveProcess*>(process);
-        assert(lp);
 
         for (int i = 0; i < 5; ++i)
             tc->setSyscallArg(i, tc->getSyscallArg(i+1));
 
 
-        SyscallDesc *new_desc = lp->getDesc(new_callnum);
+        SyscallDesc *new_desc = process->getDesc(new_callnum);
         if (desc == NULL)
             fatal("Syscall %d out of range", callnum);
 
@@ -1239,6 +1142,108 @@ class Tru64 : public OperatingSystem
 
 };  // class Tru64
 
+class Tru64_F64 : public Tru64
+{
+  public:
+
+    /// Stat buffer.  Note that Tru64 v5.0+ use a new "F64" stat
+    /// structure, and a new set of syscall numbers for stat calls.
+    /// On some hosts (notably Linux) define st_atime, st_mtime, and
+    /// st_ctime as macros, so we append an X to get around this.
+    struct F64_stat {
+        dev_t	st_dev;			//!< st_dev
+        int32_t	st_retired1;		//!< st_retired1
+        mode_t	st_mode;		//!< st_mode
+        nlink_t	st_nlink;		//!< st_nlink
+        uint16_t st_nlink_reserved;	//!< st_nlink_reserved
+        uid_t	st_uid;			//!< st_uid
+        gid_t	st_gid;			//!< st_gid
+        dev_t	st_rdev;		//!< st_rdev
+        dev_t	st_ldev;		//!< st_ldev
+        off_t	st_size;		//!< st_size
+        time_t	st_retired2;		//!< st_retired2
+        int32_t	st_uatime;		//!< st_uatime
+        time_t	st_retired3;		//!< st_retired3
+        int32_t	st_umtime;		//!< st_umtime
+        time_t	st_retired4;		//!< st_retired4
+        int32_t	st_uctime;		//!< st_uctime
+        int32_t	st_retired5;		//!< st_retired5
+        int32_t	st_retired6;		//!< st_retired6
+        uint32_t	st_flags;	//!< st_flags
+        uint32_t	st_gen;		//!< st_gen
+        uint64_t	st_spare[4];	//!< st_spare[4]
+        ino_t	st_ino;			//!< st_ino
+        int32_t	st_ino_reserved;	//!< st_ino_reserved
+        time_t	st_atimeX;		//!< st_atime
+        int32_t	st_atime_reserved;	//!< st_atime_reserved
+        time_t	st_mtimeX;		//!< st_mtime
+        int32_t	st_mtime_reserved;	//!< st_mtime_reserved
+        time_t	st_ctimeX;		//!< st_ctime
+        int32_t	st_ctime_reserved;	//!< st_ctime_reserved
+        uint64_t	st_blksize;	//!< st_blksize
+        uint64_t	st_blocks;	//!< st_blocks
+    };
+
+    typedef F64_stat tgt_stat;
+/*
+    static void copyOutStatBuf(TranslatingPort *mem, Addr addr,
+                               global_stat *host)
+    {
+        Tru64::copyOutStatBuf<Tru64::F64_stat>(mem, addr, host);
+    }*/
+
+    static void copyOutStatfsBuf(TranslatingPort *mem, Addr addr,
+                                 global_statfs *host)
+    {
+        Tru64::copyOutStatfsBuf<Tru64::F64_statfs>(mem, addr, host);
+    }
+};
+
+class Tru64_PreF64 : public Tru64
+{
+  public:
+
+    /// Old Tru64 v4.x stat struct.
+    /// Tru64 maintains backwards compatibility with v4.x by
+    /// implementing another set of stat functions using the old
+    /// structure definition and binding them to the old syscall
+    /// numbers.
+
+    struct pre_F64_stat {
+        dev_t   st_dev;
+        ino_t   st_ino;
+        mode_t  st_mode;
+        nlink_t st_nlink;
+        uid_t   st_uid __attribute__ ((aligned(sizeof(uid_t))));
+        gid_t   st_gid;
+        dev_t   st_rdev;
+        off_t   st_size __attribute__ ((aligned(sizeof(off_t))));
+        time_t  st_atimeX;
+        int32_t st_uatime;
+        time_t  st_mtimeX;
+        int32_t st_umtime;
+        time_t  st_ctimeX;
+        int32_t st_uctime;
+        uint32_t st_blksize;
+        int32_t st_blocks;
+        uint32_t st_flags;
+        uint32_t st_gen;
+    };
+
+    typedef pre_F64_stat tgt_stat;
+/*
+    static void copyOutStatBuf(TranslatingPort *mem, Addr addr,
+                               global_stat *host)
+    {
+        Tru64::copyOutStatBuf<Tru64::pre_F64_stat>(mem, addr, host);
+    }*/
+
+    static void copyOutStatfsBuf(TranslatingPort *mem, Addr addr,
+                                 global_statfs *host)
+    {
+        Tru64::copyOutStatfsBuf<Tru64::pre_F64_statfs>(mem, addr, host);
+    }
+};
 
 #endif // FULL_SYSTEM
 
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