summaryrefslogtreecommitdiff
path: root/sim
diff options
context:
space:
mode:
Diffstat (limited to 'sim')
-rw-r--r--sim/process.cc (renamed from sim/prog.cc)72
-rw-r--r--sim/process.hh (renamed from sim/prog.hh)26
-rw-r--r--sim/syscall_emul.cc197
-rw-r--r--sim/syscall_emul.hh465
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__
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-12 13:22:10 +0000