Finished changing how stat structures are translated, fixed the handling of various...

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

diff --git a/src/arch/alpha/linux/process.cc b/src/arch/alpha/linux/process.cc
index 357ebdada4c36a3996f9435f3e5d53bbd4ce59a4..56342dbc508517e3bde252f08ab6445bda695c10 100644 (file)
--- 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 9cc7dc7b641da953846b0464fd655b6341e7bc97..b239048445099cd2cea756bbccc11e2757cff26c 100644 (file)
--- 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 32fb9722957a14f1803be715ddc52a50e3b91f92..9e360e80f2ca535d6eed8c4718ab705b740b9872 100644 (file)
--- 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 5d5c9a52e02ee07db7884ed474d89476ba733de3..c4aeb1885a0efd26af6b8eecd268bd8efd2278d3 100644 (file)
--- 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 82e44b9e7024a4f66dd1259e3e59200ee7f766f6..55b8ebf8bd295d278b0002f1791b28a648d3ec6d 100644 (file)
--- 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 5d91f6ac164f3d34d40983c95ec02a36dfec6f2b..23429dad3d7c403552e46397fdb09097090832cc 100644 (file)
--- 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 17e735527107e53d9b595338b1008d5b1ae60240..d182cfa307722c3a2d5a9aed9492ea1177e8d22f 100644 (file)
--- 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 68da3227be3df744db84e54166620da5277693d8..06f86379c45f0faaa514668fdca630673c22be4e 100644 (file)
--- 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 031c2030ec10f3b6cc5b0467e0e1136001f8b808..4bc91ca24b068f793056554a8578ae080289666d 100644 (file)
--- 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 40059159973f2a031ff4746a9af3fdb0c4e5764a..fb004375d8a7b15acadb0a935fec3049b001f3ad 100644 (file)
--- 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 8c2de8ca355a5d273fa18223e9b8bf2cb1b517a1..44c893f2b2d121e00070d109654eefba60751e2c 100644 (file)
--- 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 4af8f0f7571285d4e1791876448051ae35a8e816..c758d5433ea99c5bab19c7d8ac27079e369c09a4 100644 (file)
--- 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 a3bb0eb1aa2f49adba783eef7c39f9ea8c7003c6..3323ba7a072162e1ab8ac24901ca1ec0364b68b8 100644 (file)
--- 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 7ba8d7109f2f04cf73175eb0ea46af0330a3f32f..7cc52e241459b99c15024f5a97b64bbad06e00f2 100644 (file)
--- 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 af055091090d65d347a06c197e27a63c84fb7924..ff466c8e61700e2ff09f72e3be6430408a4e8adb 100644 (file)
--- 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 3c0d7eba74a90e8d3e4a5b2e4d7fa71bcb48efa3..2cf329211c8472dfcedc06ce64b63aaa6b0a9dfc 100644 (file)
--- 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 63d4f3a9b38f81d60c8f6201d438571bd055bacf..87ac88007fcd20af88ec3a62b05adb026fddbe72 100644 (file)
--- 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 20f7fec2d0d053f8f721ab323b9966967dccf840..46ccd25964c7c40027922329776f4107435d87d7 100644 (file)
--- 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 d64cc3cf11ec04b9f575ae164c167c541aeb08d2..b2777170f820f74d9728a11023032ae350668507 100644 (file)
--- 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 fe0260223707a8bbe9a6392a07044c4779160370..9028d590bd0964312319c326f447c080c7399ddb 100644 (file)
--- 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 978e0bce772426fb75615e9c7e64072b43222083..edd4e331d84a7f1b4aa3d5cce7de73558026b4e7 100644 (file)
--- 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