Merge zizzer:/bk/m5 into isabel.reinhardt.house:/z/stever/bk/m5

--HG--
extra : convert_revision : d66ebc598fdcfc9477ea5a1e455b21d7b9e56936

4 files changed, 733 insertions, 27 deletions

diff --git a/sim/prog.cc b/sim/process.cc
index fca4b4505..bb4333896 100644
--- a/sim/prog.cc
+++ b/sim/process.cc
@@ -42,9 +42,14 @@
 #include "mem/functional_mem/main_memory.hh"
 #include "sim/builder.hh"
 #include "sim/fake_syscall.hh"
-#include "sim/prog.hh"
+#include "sim/process.hh"
 #include "sim/sim_stats.hh"
 
+#ifdef TARGET_ALPHA
+#include "arch/alpha/alpha_tru64_process.hh"
+#include "arch/alpha/alpha_linux_process.hh"
+#endif
+
 using namespace std;
 
 //
@@ -53,13 +58,9 @@ using namespace std;
 // mode when we do have an OS
 //
 #ifdef FULL_SYSTEM
-#error "prog.cc not compatible with FULL_SYSTEM"
+#error "process.cc not compatible with FULL_SYSTEM"
 #endif
 
-// max allowable number of processes: should be no real cost to
-// cranking this up if necessary
-const int MAX_PROCESSES = 8;
-
 // current number of allocated processes
 int num_processes = 0;
 
@@ -242,16 +243,12 @@ copyStringArray(vector<string> &strings, Addr array_ptr, Addr data_ptr,
     memory->access(Write, array_ptr, &data_ptr, sizeof(Addr));
 }
 
-LiveProcess::LiveProcess(const string &name,
+LiveProcess::LiveProcess(const string &name, ObjectFile *objFile,
                          int stdin_fd, int stdout_fd, int stderr_fd,
                          vector<string> &argv, vector<string> &envp)
     : Process(name, stdin_fd, stdout_fd, stderr_fd)
 {
     prog_fname = argv[0];
-    ObjectFile *objFile = createObjectFile(prog_fname);
-    if (objFile == NULL) {
-        fatal("Can't load object file %s", prog_fname);
-    }
 
     prog_entry = objFile->entryPoint();
     text_base = objFile->textBase();
@@ -267,6 +264,10 @@ LiveProcess::LiveProcess(const string &name,
     // code should get moved to some architecture-specific spot.
     stack_base = text_base - (409600+4096);
 
+    // Set up region for mmaps.  Tru64 seems to start just above 0 and
+    // grow up from there.
+    mmap_base = 0x10000;
+
     // Set pointer for next thread stack.  Reserve 8M for main stack.
     next_thread_stack_base = stack_base - (8 * 1024 * 1024);
 
@@ -316,12 +317,45 @@ LiveProcess::LiveProcess(const string &name,
 }
 
 
-void
-LiveProcess::syscall(ExecContext *xc)
+LiveProcess *
+LiveProcess::create(const string &name,
+                    int stdin_fd, int stdout_fd, int stderr_fd,
+                    vector<string> &argv, vector<string> &envp)
 {
-    num_syscalls++;
+    LiveProcess *process = NULL;
+    ObjectFile *objFile = createObjectFile(argv[0]);
+    if (objFile == NULL) {
+        fatal("Can't load object file %s", argv[0]);
+    }
+
+    // check object type & set up syscall emulation pointer
+    if (objFile->getArch() == ObjectFile::Alpha) {
+        switch (objFile->getOpSys()) {
+          case ObjectFile::Tru64:
+            process = new AlphaTru64Process(name, objFile,
+                                            stdin_fd, stdout_fd, stderr_fd,
+                                            argv, envp);
+            break;
+
+          case ObjectFile::Linux:
+            process = new AlphaLinuxProcess(name, objFile,
+                                            stdin_fd, stdout_fd, stderr_fd,
+                                            argv, envp);
+            break;
+
+          default:
+            fatal("Unknown/unsupported operating system.");
+        }
+    } else {
+        fatal("Unknown object file architecture.");
+    }
+
+    delete objFile;
+
+    if (process == NULL)
+        fatal("Unknown error creating process object.");
 
-    fake_syscall(this, xc);
+    return process;
 }
 
 
@@ -357,10 +391,10 @@ CREATE_SIM_OBJECT(LiveProcess)
 
     //  We do this with "temp" because of the bogus compiler warning
     //  you get with g++ 2.95 -O if you just "return new LiveProcess(..."
-    LiveProcess *temp = new LiveProcess(getInstanceName(),
-                                        stdin_fd, stdout_fd, stderr_fd,
-                                        cmd,
-                                        env.isValid() ? env : null_vec);
+    LiveProcess *temp = LiveProcess::create(getInstanceName(),
+                                            stdin_fd, stdout_fd, stderr_fd,
+                                            cmd,
+                                            env.isValid() ? env : null_vec);
 
     return temp;
 }
diff --git a/sim/prog.hh b/sim/process.hh
index e93dd684c..5df5736ff 100644
--- a/sim/prog.hh
+++ b/sim/process.hh
@@ -26,8 +26,8 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __PROG_HH__
-#define __PROG_HH__
+#ifndef __PROCESS_HH__
+#define __PROCESS_HH__
 
 //
 // The purpose of this code is to fake the loader & syscall mechanism
@@ -89,10 +89,12 @@ class Process : public SimObject
     unsigned stack_size;	// initial stack size
     Addr stack_min;		// lowest address accessed on the stack
 
-
     // addr to use for next stack region (for multithreaded apps)
     Addr next_thread_stack_base;
 
+    // Base of region for mmaps (when user doesn't specify an address).
+    Addr mmap_base;
+
     std::string prog_fname;	// file name
     Addr prog_entry;		// entry point (initial PC)
 
@@ -165,18 +167,26 @@ class Process : public SimObject
 //
 // "Live" process with system calls redirected to host system
 //
-class MainMemory;
+class ObjectFile;
 class LiveProcess : public Process
 {
-  public:
-    LiveProcess(const std::string &name,
+  protected:
+    LiveProcess(const std::string &name, ObjectFile *objFile,
                 int stdin_fd, int stdout_fd, int stderr_fd,
                 std::vector<std::string> &argv,
                 std::vector<std::string> &envp);
 
-    virtual void syscall(ExecContext *xc);
+  public:
+    // this function is used to create the LiveProcess object, since
+    // we can't tell which subclass of LiveProcess to use until we
+    // open and look at the object file.
+    static LiveProcess *create(const std::string &name,
+                               int stdin_fd, int stdout_fd, int stderr_fd,
+                               std::vector<std::string> &argv,
+                               std::vector<std::string> &envp);
 };
 
+
 #endif // !FULL_SYSTEM
 
-#endif // __PROG_HH__
+#endif // __PROCESS_HH__
diff --git a/sim/syscall_emul.cc b/sim/syscall_emul.cc
new file mode 100644
index 000000000..0e4e78612
--- /dev/null
+++ b/sim/syscall_emul.cc
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <unistd.h>
+
+#include <string>
+#include <iostream>
+
+#include "sim/syscall_emul.hh"
+#include "base/trace.hh"
+#include "cpu/exec_context.hh"
+#include "cpu/base_cpu.hh"
+#include "sim/process.hh"
+
+#include "sim/sim_events.hh"
+
+using namespace std;
+
+void
+SyscallDesc::doSyscall(int callnum, Process *process, ExecContext *xc)
+{
+    DPRINTFR(SyscallVerbose, "%s: syscall %s called\n",
+             xc->cpu->name(), name);
+
+    int retval = (*funcPtr)(this, callnum, process, xc);
+
+    DPRINTFR(SyscallVerbose, "%s: syscall %s returns %d\n",
+             xc->cpu->name(), name, retval);
+
+    if (!((flags & SyscallDesc::SuppressReturnValue) && retval == 0))
+        xc->setSyscallReturn(retval);
+}
+
+
+//
+// Handler for unimplemented syscalls that we haven't thought about.
+//
+int
+unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
+                  ExecContext *xc)
+{
+    cerr << "Error: syscall " << desc->name
+         << " (#" << callnum << ") unimplemented.";
+    cerr << "  Args: " << xc->getSyscallArg(0) << ", " << xc->getSyscallArg(1)
+         << ", ..." << endl;
+
+    abort();
+}
+
+
+//
+// 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.
+//
+int
+ignoreFunc(SyscallDesc *desc, int callnum, Process *process,
+           ExecContext *xc)
+{
+    DCOUT(SyscallWarnings) << "Warning: ignoring syscall " << desc->name
+                           << "(" << xc->getSyscallArg(0)
+                           << ", " << xc->getSyscallArg(1)
+                           << ", ...)" << endl;
+
+    return 0;
+}
+
+
+int
+exitFunc(SyscallDesc *desc, int callnum, Process *process,
+         ExecContext *xc)
+{
+    new SimExitEvent("syscall caused exit", xc->getSyscallArg(0) & 0xff);
+
+    return 1;
+}
+
+
+int
+getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    return VMPageSize;
+}
+
+
+int
+obreakFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    // change brk addr to first arg
+    p->brk_point = xc->getSyscallArg(0);
+    return p->brk_point;
+}
+
+
+int
+closeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    int fd = p->sim_fd(xc->getSyscallArg(0));
+    return close(fd);
+}
+
+
+int
+readFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    int fd = p->sim_fd(xc->getSyscallArg(0));
+    int nbytes = xc->getSyscallArg(2);
+    BufferArg bufArg(xc->getSyscallArg(1), nbytes);
+
+    int bytes_read = read(fd, bufArg.bufferPtr(), nbytes);
+
+    if (bytes_read != -1)
+        bufArg.copyOut(xc->mem);
+
+    return bytes_read;
+}
+
+int
+writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    int fd = p->sim_fd(xc->getSyscallArg(0));
+    int nbytes = xc->getSyscallArg(2);
+    BufferArg bufArg(xc->getSyscallArg(1), nbytes);
+
+    bufArg.copyIn(xc->mem);
+
+    int bytes_written = write(fd, bufArg.bufferPtr(), nbytes);
+
+    fsync(fd);
+
+    return bytes_written;
+}
+
+
+int
+lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    int fd = p->sim_fd(xc->getSyscallArg(0));
+    uint64_t offs = xc->getSyscallArg(1);
+    int whence = xc->getSyscallArg(2);
+
+    off_t result = lseek(fd, offs, whence);
+
+    return (result == (off_t)-1) ? -errno : result;
+}
+
+
+int
+munmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    // given that we don't really implement mmap, munmap is really easy
+    return 0;
+}
+
+
+const char *hostname = "m5.eecs.umich.edu";
+
+int
+gethostnameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    int name_len = xc->getSyscallArg(1);
+    BufferArg name(xc->getSyscallArg(0), name_len);
+
+    strncpy((char *)name.bufferPtr(), hostname, name_len);
+
+    name.copyOut(xc->mem);
+
+    return 0;
+}
+
+
diff --git a/sim/syscall_emul.hh b/sim/syscall_emul.hh
new file mode 100644
index 000000000..a02b4a608
--- /dev/null
+++ b/sim/syscall_emul.hh
@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __SYSCALL_EMUL_HH__
+#define __SYSCALL_EMUL_HH__
+
+///
+/// @file syscall_emul.hh
+///
+/// This file defines objects used to emulate syscalls from the target
+/// application on the host machine.
+
+#include <string>
+
+#include "base/intmath.hh"	// for RoundUp
+#include "targetarch/isa_traits.hh"	// for Addr
+#include "mem/functional_mem/functional_memory.hh"
+
+class Process;
+class ExecContext;
+
+///
+/// System call descriptor.
+///
+class SyscallDesc {
+
+  public:
+
+    typedef int (*FuncPtr)(SyscallDesc *, int num,
+                           Process *, ExecContext *);
+
+    const char *name;	//!< Syscall name (e.g., "open").
+    FuncPtr funcPtr;	//!< Pointer to emulation function.
+    int flags;		//!< Flags (see Flags enum).
+
+
+    /// Flag values for controlling syscall behavior.
+    enum Flags {
+        /// Don't set return regs according to funcPtr return value.
+        /// Used for syscalls with non-standard return conventions
+        /// that explicitly set the ExecContext regs (e.g.,
+        /// sigreturn).
+        SuppressReturnValue = 1
+    };
+
+    /// Constructor.
+    SyscallDesc(const char *_name, FuncPtr _funcPtr, int _flags = 0)
+        : name(_name), funcPtr(_funcPtr), flags(_flags)
+    {
+    }
+
+    /// Emulate the syscall.  Public interface for calling through funcPtr.
+    void doSyscall(int callnum, Process *proc, ExecContext *xc);
+};
+
+
+class BaseBufferArg {
+
+  public:
+
+    BaseBufferArg(Addr _addr, int _size) : addr(_addr), size(_size)
+    {
+        bufPtr = new uint8_t[size];
+        // clear out buffer: in case we only partially populate this,
+        // and then do a copyOut(), we want to make sure we don't
+        // introduce any random junk into the simulated address space
+        memset(bufPtr, 0, size);
+    }
+
+    virtual ~BaseBufferArg() { delete [] bufPtr; }
+
+    //
+    // copy data into simulator space (read from target memory)
+    //
+    virtual bool copyIn(FunctionalMemory *mem)
+    {
+        mem->access(Read, addr, bufPtr, size);
+        return true;	// no EFAULT detection for now
+    }
+
+    //
+    // copy data out of simulator space (write to target memory)
+    //
+    virtual bool copyOut(FunctionalMemory *mem)
+    {
+        mem->access(Write, addr, bufPtr, size);
+        return true;	// no EFAULT detection for now
+    }
+
+  protected:
+    Addr addr;
+    int size;
+    uint8_t *bufPtr;
+};
+
+
+class BufferArg : public BaseBufferArg
+{
+  public:
+    BufferArg(Addr _addr, int _size) : BaseBufferArg(_addr, _size) { }
+    void *bufferPtr()	{ return bufPtr; }
+};
+
+template <class T>
+class TypedBufferArg : public BaseBufferArg
+{
+  public:
+    // user can optionally specify a specific number of bytes to
+    // allocate to deal with those structs that have variable-size
+    // arrays at the end
+    TypedBufferArg(Addr _addr, int _size = sizeof(T))
+        : BaseBufferArg(_addr, _size)
+    { }
+
+    // type case
+    operator T*() { return (T *)bufPtr; }
+
+    // dereference operators
+    T& operator*()	 { return *((T *)bufPtr); }
+    T* operator->()	 { return (T *)bufPtr; }
+    T& operator[](int i) { return ((T *)bufPtr)[i]; }
+};
+
+//////////////////////////////////////////////////////////////////////
+//
+// The following emulation functions are generic enough that they
+// don't need to be recompiled for different emulated OS's.  They are
+// defined in sim/syscall_emul.cc.
+//
+//////////////////////////////////////////////////////////////////////
+
+
+int unimplementedFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int ignoreFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+
+int exitFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int obreakFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int closeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int readFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int munmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+int gethostnameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
+
+//////////////////////////////////////////////////////////////////////
+//
+// The following emulation functions are generic, but need to be
+// templated to account for differences in types, constants, etc.
+//
+//////////////////////////////////////////////////////////////////////
+
+template <class OS>
+int
+ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
+          ExecContext *xc)
+{
+    int fd = xc->getSyscallArg(0);
+    unsigned req = xc->getSyscallArg(1);
+
+    // DPRINTFR(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", fd, req);
+
+    if (fd < 0 || process->sim_fd(fd) < 0) {
+        // doesn't map to any simulator fd: not a valid target fd
+        return -EBADF;
+    }
+
+    switch (req) {
+      case OS::TIOCISATTY:
+      case OS::TIOCGETP:
+      case OS::TIOCSETP:
+      case OS::TIOCSETN:
+      case OS::TIOCSETC:
+      case OS::TIOCGETC:
+        return -ENOTTY;
+
+      default:
+        fatal("Unsupported ioctl call: ioctl(%d, 0x%x, ...)\n", fd, req);
+    }
+}
+
+struct OpenFlagTransTable {
+    int tgtFlag;
+    int hostFlag;
+};
+
+
+template <class OS>
+int
+openFunc(SyscallDesc *desc, int callnum, Process *process,
+         ExecContext *xc)
+{
+    std::string path;
+
+    if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault)
+        return -EFAULT;
+
+    if (path == "/dev/sysdev0") {
+        // This is a memory-mapped high-resolution timer device on Alpha.
+        // We don't support it, so just punt.
+        DCOUT(SyscallWarnings) << "Ignoring open(" << path << ", ...)" << endl;
+        return -ENOENT;
+    }
+
+    int tgtFlags = xc->getSyscallArg(1);
+    int mode = xc->getSyscallArg(2);
+    int hostFlags = 0;
+
+    // translate open flags
+    for (int i = 0; i < OS::NUM_OPEN_FLAGS; i++) {
+        if (tgtFlags & OS::openFlagTable[i].tgtFlag) {
+            tgtFlags &= ~OS::openFlagTable[i].tgtFlag;
+            hostFlags |= OS::openFlagTable[i].hostFlag;
+        }
+    }
+
+    // any target flags left?
+    if (tgtFlags != 0)
+        cerr << "Syscall: open: cannot decode flags: " <<  tgtFlags << endl;
+
+#ifdef __CYGWIN32__
+    hostFlags |= O_BINARY;
+#endif
+
+    // open the file
+    int fd = open(path.c_str(), hostFlags, mode);
+
+    return (fd == -1) ? -errno : process->open_fd(fd);
+}
+
+
+template <class OS>
+int
+statFunc(SyscallDesc *desc, int callnum, Process *process,
+         ExecContext *xc)
+{
+    std::string path;
+
+    if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault)
+        return -EFAULT;
+
+    struct stat hostBuf;
+    int result = stat(path.c_str(), &hostBuf);
+
+    if (result < 0)
+        return -errno;
+
+    OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf);
+
+    return 0;
+}
+
+
+template <class OS>
+int
+lstatFunc(SyscallDesc *desc, int callnum, Process *process,
+          ExecContext *xc)
+{
+    std::string path;
+
+    if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault)
+        return -EFAULT;
+
+    struct stat hostBuf;
+    int result = lstat(path.c_str(), &hostBuf);
+
+    if (result < 0)
+        return -errno;
+
+    OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf);
+
+    return 0;
+}
+
+template <class OS>
+int
+fstatFunc(SyscallDesc *desc, int callnum, Process *process,
+          ExecContext *xc)
+{
+    int fd = process->sim_fd(xc->getSyscallArg(0));
+
+    // DPRINTFR(SyscallVerbose, "fstat(%d, ...)\n", fd);
+
+    if (fd < 0)
+        return -EBADF;
+
+    struct stat hostBuf;
+    int result = fstat(fd, &hostBuf);
+
+    if (result < 0)
+        return -errno;
+
+    OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf);
+
+    return 0;
+}
+
+
+//
+// We don't really handle mmap().  If the target is mmaping an
+// anonymous region or /dev/zero, we can get away with doing basically
+// nothing (since memory is initialized to zero and the simulator
+// doesn't really check addresses anyway).  Always print a warning,
+// since this could be seriously broken if we're not mapping
+// /dev/zero.
+//
+// Someday we should explicitly check for /dev/zero in open, flag the
+// file descriptor, and fail (or implement!) a non-anonymous mmap to
+// anything else.
+//
+template <class OS>
+int
+mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+{
+    Addr start = xc->getSyscallArg(0);
+    uint64_t length = xc->getSyscallArg(1);
+    // int prot = xc->getSyscallArg(2);
+    int flags = xc->getSyscallArg(3);
+    int fd = p->sim_fd(xc->getSyscallArg(4));
+    // int offset = xc->getSyscallArg(5);
+
+    if (start == 0) {
+        // user didn't give an address... pick one from our "mmap region"
+        start = p->mmap_base;
+        p->mmap_base += RoundUp<Addr>(length, VMPageSize);
+    }
+
+    if (!(flags & OS::TGT_MAP_ANONYMOUS)) {
+        DPRINTF(SyscallWarnings, "Warning: allowing mmap of file @ fd %d.  "
+                "This will break if not /dev/zero.", fd);
+    }
+
+    return start;
+}
+
+
+template <class OS>
+int
+getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
+              ExecContext *xc)
+{
+    unsigned resource = xc->getSyscallArg(0);
+    TypedBufferArg<typename OS::rlimit> rlp(xc->getSyscallArg(1));
+
+    switch (resource) {
+      case OS::RLIMIT_STACK:
+        // max stack size in bytes: make up a number (2MB for now)
+        rlp->rlim_cur = rlp->rlim_max = 8 * 1024 * 1024;
+        break;
+
+      default:
+        cerr << "getrlimitFunc: unimplemented resource " << resource << endl;
+        abort();
+        break;
+    }
+
+    rlp.copyOut(xc->mem);
+    return 0;
+}
+
+// 1M usecs in 1 sec, for readability
+const int one_million = 1000000;
+
+// seconds since the epoch (1/1/1970)... about a billion, by my reckoning
+const unsigned seconds_since_epoch = 1000000000;
+
+//
+// helper function: populate struct timeval with approximation of
+// current elapsed time
+//
+template <class T1, class T2>
+void
+getElapsedTime(T1 &sec, T2 &usec)
+{
+    int cycles_per_usec = ticksPerSecond / one_million;
+
+    int elapsed_usecs = curTick / cycles_per_usec;
+    sec = elapsed_usecs / one_million;
+    usec = elapsed_usecs % one_million;
+}
+
+
+template <class OS>
+int
+gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
+                 ExecContext *xc)
+{
+    TypedBufferArg<typename OS::timeval> tp(xc->getSyscallArg(0));
+
+    getElapsedTime(tp->tv_sec, tp->tv_usec);
+    tp->tv_sec += seconds_since_epoch;
+
+    tp.copyOut(xc->mem);
+
+    return 0;
+}
+
+
+template <class OS>
+int
+getrusageFunc(SyscallDesc *desc, int callnum, Process *process,
+              ExecContext *xc)
+{
+    int who = xc->getSyscallArg(0);	// THREAD, SELF, or CHILDREN
+    TypedBufferArg<typename OS::rusage> rup(xc->getSyscallArg(1));
+
+    if (who != OS::RUSAGE_SELF) {
+        // don't really handle THREAD or CHILDREN, but just warn and
+        // plow ahead
+        DCOUT(SyscallWarnings)
+            << "Warning: getrusage() only supports RUSAGE_SELF."
+            << "  Parameter " << who << " ignored." << endl;
+    }
+
+    getElapsedTime(rup->ru_utime.tv_sec, rup->ru_utime.tv_usec);
+    rup->ru_stime.tv_sec = 0;
+    rup->ru_stime.tv_usec = 0;
+    rup->ru_maxrss = 0;
+    rup->ru_ixrss = 0;
+    rup->ru_idrss = 0;
+    rup->ru_isrss = 0;
+    rup->ru_minflt = 0;
+    rup->ru_majflt = 0;
+    rup->ru_nswap = 0;
+    rup->ru_inblock = 0;
+    rup->ru_oublock = 0;
+    rup->ru_msgsnd = 0;
+    rup->ru_msgrcv = 0;
+    rup->ru_nsignals = 0;
+    rup->ru_nvcsw = 0;
+    rup->ru_nivcsw = 0;
+
+    rup.copyOut(xc->mem);
+
+    return 0;
+}
+
+
+
+#endif // __SYSCALL_EMUL_HH__