diff options
| -rw-r--r-- | arch/alpha/alpha_linux_process.cc | 839 | ||||
| -rw-r--r-- | arch/alpha/alpha_linux_process.hh | 47 | ||||
| -rw-r--r-- | arch/alpha/alpha_tru64_process.cc (renamed from arch/alpha/fake_syscall.cc) | 1805 | ||||
| -rw-r--r-- | arch/alpha/alpha_tru64_process.hh | 47 | ||||
| -rw-r--r-- | base/loader/aout_object.cc | 9 | ||||
| -rw-r--r-- | base/loader/aout_object.hh | 3 | ||||
| -rw-r--r-- | base/loader/ecoff_object.cc | 8 | ||||
| -rw-r--r-- | base/loader/ecoff_object.hh | 3 | ||||
| -rw-r--r-- | base/loader/elf_object.cc | 10 | ||||
| -rw-r--r-- | base/loader/elf_object.hh | 3 | ||||
| -rw-r--r-- | base/loader/object_file.cc | 6 | ||||
| -rw-r--r-- | base/loader/object_file.hh | 22 | ||||
| -rw-r--r-- | cpu/exec_context.cc | 2 | ||||
| -rw-r--r-- | cpu/exec_context.hh | 30 | ||||
| -rw-r--r-- | cpu/simple_cpu/simple_cpu.cc | 1 | ||||
| -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.cc | 197 | ||||
| -rw-r--r-- | sim/syscall_emul.hh | 465 |
19 files changed, 2602 insertions, 993 deletions
diff --git a/arch/alpha/alpha_linux_process.cc b/arch/alpha/alpha_linux_process.cc new file mode 100644 index 000000000..13d1f5366 --- /dev/null +++ b/arch/alpha/alpha_linux_process.cc @@ -0,0 +1,839 @@ +/* + * 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 <errno.h> +#include <unistd.h> +#include <fcntl.h> // for host open() flags +#include <sys/types.h> +#include <sys/stat.h> +#include <string.h> // for memset() +#include <dirent.h> + +#include "sim/host.hh" +#include "cpu/base_cpu.hh" +#include "mem/functional_mem/functional_memory.hh" +#include "sim/process.hh" +#include "cpu/exec_context.hh" +#include "sim/fake_syscall.hh" +#include "sim/sim_events.hh" + +#include "sim/syscall_emul.hh" +#include "arch/alpha/alpha_common_syscall_emul.hh" +#include "sim/universe.hh" // for curTick & ticksPerSecond + +#include "arch/alpha/alpha_linux_process.hh" + +#include "base/trace.hh" + +using namespace std; + +class Linux { + +public: + +// +// basic Linux types +// + +typedef uint64_t size_t; +typedef uint64_t off_t; +typedef int64_t time_t; +typedef uint32_t uid_t; +typedef uint32_t gid_t; + +// open(2) flags +static const int TGT_O_RDONLY = 00000000; +static const int TGT_O_WRONLY = 00000001; +static const int TGT_O_RDWR = 00000002; +static const int TGT_O_NONBLOCK = 00000004; +static const int TGT_O_APPEND = 00000010; +static const int TGT_O_CREAT = 00001000; +static const int TGT_O_TRUNC = 00002000; +static const int TGT_O_EXCL = 00004000; +static const int TGT_O_NOCTTY = 00010000; +static const int TGT_O_SYNC = 00040000; +static const int TGT_O_DRD = 00100000; +static const int TGT_O_DIRECTIO = 00200000; +static const int TGT_O_CACHE = 00400000; +static const int TGT_O_DSYNC = 02000000; +static const int TGT_O_RSYNC = 04000000; + +static OpenFlagTransTable openFlagTable[]; +static const int NUM_OPEN_FLAGS; + +// +// Stat buffer. +// + +struct tgt_stat { + uint32_t st_dev; + uint32_t st_ino; + uint32_t st_mode; + uint32_t st_nlink; + uint32_t st_uid; + uint32_t st_gid; + uint32_t st_rdev; + int64_t st_size; + uint64_t st_atimeX; + uint64_t st_mtimeX; + uint64_t st_ctimeX; + uint32_t st_blksize; + int32_t st_blocks; + uint32_t st_flags; + uint32_t st_gen; +}; + + +// +// for uname() +// + +static const int _SYS_NMLN = 65; + +struct utsname { + char sysname[_SYS_NMLN]; + char nodename[_SYS_NMLN]; + char release[_SYS_NMLN]; + char version[_SYS_NMLN]; + char machine[_SYS_NMLN]; +}; + + +// +// for ioctl() +// + +static const unsigned TIOCGETP = 0x40067408; +static const unsigned TIOCSETP = 0x80067409; +static const unsigned TIOCSETN = 0x8006740a; +static const unsigned TIOCSETC = 0x80067411; +static const unsigned TIOCGETC = 0x40067412; +static const unsigned FIONREAD = 0x4004667f; +static const unsigned TIOCISATTY = 0x2000745e; + +// +// for getrlimit() +// + +enum rlimit_resources { + RLIMIT_CPU = 0, + RLIMIT_FSIZE = 1, + RLIMIT_DATA = 2, + RLIMIT_STACK = 3, + RLIMIT_CORE = 4, + RLIMIT_RSS = 5, + RLIMIT_NOFILE = 6, + RLIMIT_AS = 7, + RLIMIT_VMEM = 7, + RLIMIT_NPROC = 8, + RLIMIT_MEMLOCK = 9, + RLIMIT_LOCKS = 10 +}; + +struct rlimit { + uint64_t rlim_cur; // soft limit + uint64_t rlim_max; // hard limit +}; + + +// +// for mmap() +// + static const unsigned TGT_MAP_ANONYMOUS = 0x10; + +// +// for gettimeofday +// + +struct timeval { + int64_t tv_sec; + int64_t tv_usec; +}; + +// +// for getrusage +// + + +static const int RUSAGE_SELF = 0; +static const int RUSAGE_CHILDREN = -1; +static const int RUSAGE_BOTH = -2; + +struct rusage { + struct timeval ru_utime; // user time used + struct timeval ru_stime; // system time used + int64_t ru_maxrss; + int64_t ru_ixrss; // integral shared memory size + int64_t ru_idrss; // integral unshared data " + int64_t ru_isrss; // integral unshared stack " + int64_t ru_minflt; // page reclaims - total vmfaults + int64_t ru_majflt; // page faults + int64_t ru_nswap; // swaps + int64_t ru_inblock; // block input operations + int64_t ru_oublock; // block output operations + int64_t ru_msgsnd; // messages sent + int64_t ru_msgrcv; // messages received + int64_t ru_nsignals; // signals received + int64_t ru_nvcsw; // voluntary context switches + int64_t ru_nivcsw; // involuntary " +}; + +static +void +copyOutStatBuf(FunctionalMemory *mem, Addr addr, struct stat *host) +{ + TypedBufferArg<Linux::tgt_stat> tgt(addr); + + tgt->st_dev = host->st_dev; + tgt->st_ino = host->st_ino; + tgt->st_mode = host->st_mode; + tgt->st_nlink = host->st_nlink; + tgt->st_uid = host->st_uid; + tgt->st_gid = host->st_gid; + tgt->st_rdev = host->st_rdev; + tgt->st_size = host->st_size; + tgt->st_atimeX = host->st_atime; + tgt->st_mtimeX = host->st_mtime; + tgt->st_ctimeX = host->st_ctime; + tgt->st_blksize = host->st_blksize; + tgt->st_blocks = host->st_blocks; + + tgt.copyOut(mem); +} + + +static const char *hostname; + +static +int +unameFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + TypedBufferArg<Linux::utsname> name(xc->getSyscallArg(0)); + + strcpy(name->sysname, "Linux"); + strcpy(name->nodename, hostname); + strcpy(name->release, "2.4.20"); + strcpy(name->version, "#1 Mon Aug 18 11:32:15 EDT 2003"); + strcpy(name->machine, "alpha"); + + name.copyOut(xc->mem); + return 0; +} + + +static +int +osf_getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + unsigned op = xc->getSyscallArg(0); + // unsigned nbytes = xc->getSyscallArg(2); + + switch (op) { + + case 45: { // GSI_IEEE_FP_CONTROL + TypedBufferArg<uint64_t> fpcr(xc->getSyscallArg(1)); + // I don't think this exactly matches the HW FPCR + *fpcr = 0; + fpcr.copyOut(xc->mem); + return 1; + } + + default: + cerr << "osf_getsysinfo: unknown op " << op << endl; + abort(); + break; + } + + return 0; +} + + +static +int +osf_setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + unsigned op = xc->getSyscallArg(0); + // unsigned nbytes = xc->getSyscallArg(2); + + switch (op) { + + case 14: { // SSI_IEEE_FP_CONTROL + TypedBufferArg<uint64_t> fpcr(xc->getSyscallArg(1)); + // I don't think this exactly matches the HW FPCR + fpcr.copyIn(xc->mem); + DPRINTFR(SyscallVerbose, "osf_setsysinfo(SSI_IEEE_FP_CONTROL): " + " setting FPCR to 0x%x\n", *(uint64_t*)fpcr); + return 1; + } + + default: + cerr << "osf_getsysinfo: unknown op " << op << endl; + abort(); + break; + } + + return 0; +} + + +static +int +fcntlFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + int fd = xc->getSyscallArg(0); + + if (fd < 0 || process->sim_fd(fd) < 0) + return -EBADF; + + int cmd = xc->getSyscallArg(1); + switch (cmd) { + case 0: // F_DUPFD + // if we really wanted to support this, we'd need to do it + // in the target fd space. + warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd); + return -EMFILE; + + case 1: // F_GETFD (get close-on-exec flag) + case 2: // F_SETFD (set close-on-exec flag) + return 0; + + case 3: // F_GETFL (get file flags) + case 4: // F_SETFL (set file flags) + // not sure if this is totally valid, but we'll pass it through + // to the underlying OS + warn("fcntl(%d, %d) passed through to host\n", fd, cmd); + return fcntl(process->sim_fd(fd), cmd); + // return 0; + + case 7: // F_GETLK (get lock) + case 8: // F_SETLK (set lock) + case 9: // F_SETLKW (set lock and wait) + // don't mess with file locking... just act like it's OK + warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd); + return 0; + + default: + warn("Unknown fcntl command %d\n", cmd); + return 0; + } +} + +static SyscallDesc syscallDescs[]; + +static const int Num_Syscall_Descs; + +static const int Max_Syscall_Desc; + +static +void +doSyscall(int callnum, Process *process, ExecContext *xc) +{ + if (callnum < 0 || callnum > Max_Syscall_Desc) { + fatal("Syscall %d out of range", callnum); + } + + SyscallDesc *desc = &syscallDescs[callnum]; + + desc->doSyscall(callnum, process, xc); +} + + +}; // class Linux + + +// open(2) flags translation table +OpenFlagTransTable Linux::openFlagTable[] = { + /* target flag */ /* host flag */ +#ifdef _MSC_VER + { Linux::TGT_O_RDONLY, _O_RDONLY }, + { Linux::TGT_O_WRONLY, _O_WRONLY }, + { Linux::TGT_O_RDWR, _O_RDWR }, + { Linux::TGT_O_APPEND, _O_APPEND }, + { Linux::TGT_O_CREAT, _O_CREAT }, + { Linux::TGT_O_TRUNC, _O_TRUNC }, + { Linux::TGT_O_EXCL, _O_EXCL }, +#ifdef _O_NONBLOCK + { Linux::TGT_O_NONBLOCK, _O_NONBLOCK }, +#endif +#ifdef _O_NOCTTY + { Linux::TGT_O_NOCTTY, _O_NOCTTY }, +#endif +#ifdef _O_SYNC + { Linux::TGT_O_SYNC, _O_SYNC }, +#endif +#else /* !_MSC_VER */ + { Linux::TGT_O_RDONLY, O_RDONLY }, + { Linux::TGT_O_WRONLY, O_WRONLY }, + { Linux::TGT_O_RDWR, O_RDWR }, + { Linux::TGT_O_APPEND, O_APPEND }, + { Linux::TGT_O_CREAT, O_CREAT }, + { Linux::TGT_O_TRUNC, O_TRUNC }, + { Linux::TGT_O_EXCL, O_EXCL }, + { Linux::TGT_O_NONBLOCK, O_NONBLOCK }, + { Linux::TGT_O_NOCTTY, O_NOCTTY }, +#ifdef O_SYNC + { Linux::TGT_O_SYNC, O_SYNC }, +#endif +#endif /* _MSC_VER */ +}; + +const int Linux::NUM_OPEN_FLAGS = (sizeof(Linux::openFlagTable)/sizeof(Linux::openFlagTable[0])); + +const char *Linux::hostname = "m5.eecs.umich.edu"; + +SyscallDesc Linux::syscallDescs[] = { + /* 0 */ SyscallDesc("osf_syscall", unimplementedFunc), + /* 1 */ SyscallDesc("exit", exitFunc), + /* 2 */ SyscallDesc("fork", unimplementedFunc), + /* 3 */ SyscallDesc("read", readFunc), + /* 4 */ SyscallDesc("write", writeFunc), + /* 5 */ SyscallDesc("osf_old_open", unimplementedFunc), + /* 6 */ SyscallDesc("close", closeFunc), + /* 7 */ SyscallDesc("osf_wait4", unimplementedFunc), + /* 8 */ SyscallDesc("osf_old_creat", unimplementedFunc), + /* 9 */ SyscallDesc("link", unimplementedFunc), + /* 10 */ SyscallDesc("unlink", unimplementedFunc), + /* 11 */ SyscallDesc("osf_execve", unimplementedFunc), + /* 12 */ SyscallDesc("chdir", unimplementedFunc), + /* 13 */ SyscallDesc("fchdir", unimplementedFunc), + /* 14 */ SyscallDesc("mknod", unimplementedFunc), + /* 15 */ SyscallDesc("chmod", unimplementedFunc), + /* 16 */ SyscallDesc("chown", unimplementedFunc), + /* 17 */ SyscallDesc("brk", obreakFunc), + /* 18 */ SyscallDesc("osf_getfsstat", unimplementedFunc), + /* 19 */ SyscallDesc("lseek", lseekFunc), + /* 20 */ SyscallDesc("getxpid", getpidFunc), + /* 21 */ SyscallDesc("osf_mount", unimplementedFunc), + /* 22 */ SyscallDesc("umount", unimplementedFunc), + /* 23 */ SyscallDesc("setuid", setuidFunc), + /* 24 */ SyscallDesc("getxuid", getuidFunc), + /* 25 */ SyscallDesc("exec_with_loader", unimplementedFunc), + /* 26 */ SyscallDesc("osf_ptrace", unimplementedFunc), + /* 27 */ SyscallDesc("osf_nrecvmsg", unimplementedFunc), + /* 28 */ SyscallDesc("osf_nsendmsg", unimplementedFunc), + /* 29 */ SyscallDesc("osf_nrecvfrom", unimplementedFunc), + /* 30 */ SyscallDesc("osf_naccept", unimplementedFunc), + /* 31 */ SyscallDesc("osf_ngetpeername", unimplementedFunc), + /* 32 */ SyscallDesc("osf_ngetsockname", unimplementedFunc), + /* 33 */ SyscallDesc("access", unimplementedFunc), + /* 34 */ SyscallDesc("osf_chflags", unimplementedFunc), + /* 35 */ SyscallDesc("osf_fchflags", unimplementedFunc), + /* 36 */ SyscallDesc("sync", unimplementedFunc), + /* 37 */ SyscallDesc("kill", unimplementedFunc), + /* 38 */ SyscallDesc("osf_old_stat", unimplementedFunc), + /* 39 */ SyscallDesc("setpgid", unimplementedFunc), + /* 40 */ SyscallDesc("osf_old_lstat", unimplementedFunc), + /* 41 */ SyscallDesc("dup", unimplementedFunc), + /* 42 */ SyscallDesc("pipe", unimplementedFunc), + /* 43 */ SyscallDesc("osf_set_program_attributes", unimplementedFunc), + /* 44 */ SyscallDesc("osf_profil", unimplementedFunc), + /* 45 */ SyscallDesc("open", openFunc<Linux>), + /* 46 */ SyscallDesc("osf_old_sigaction", unimplementedFunc), + /* 47 */ SyscallDesc("getxgid", getgidFunc), + /* 48 */ SyscallDesc("osf_sigprocmask", ignoreFunc), + /* 49 */ SyscallDesc("osf_getlogin", unimplementedFunc), + /* 50 */ SyscallDesc("osf_setlogin", unimplementedFunc), + /* 51 */ SyscallDesc("acct", unimplementedFunc), + /* 52 */ SyscallDesc("sigpending", unimplementedFunc), + /* 53 */ SyscallDesc("osf_classcntl", unimplementedFunc), + /* 54 */ SyscallDesc("ioctl", ioctlFunc<Linux>), + /* 55 */ SyscallDesc("osf_reboot", unimplementedFunc), + /* 56 */ SyscallDesc("osf_revoke", unimplementedFunc), + /* 57 */ SyscallDesc("symlink", unimplementedFunc), + /* 58 */ SyscallDesc("readlink", unimplementedFunc), + /* 59 */ SyscallDesc("execve", unimplementedFunc), + /* 60 */ SyscallDesc("umask", unimplementedFunc), + /* 61 */ SyscallDesc("chroot", unimplementedFunc), + /* 62 */ SyscallDesc("osf_old_fstat", unimplementedFunc), + /* 63 */ SyscallDesc("getpgrp", unimplementedFunc), + /* 64 */ SyscallDesc("getpagesize", getpagesizeFunc), + /* 65 */ SyscallDesc("osf_mremap", unimplementedFunc), + /* 66 */ SyscallDesc("vfork", unimplementedFunc), + /* 67 */ SyscallDesc("stat", statFunc<Linux>), + /* 68 */ SyscallDesc("lstat", lstatFunc<Linux>), + /* 69 */ SyscallDesc("osf_sbrk", unimplementedFunc), + /* 70 */ SyscallDesc("osf_sstk", unimplementedFunc), + /* 71 */ SyscallDesc("mmap", mmapFunc<Linux>), + /* 72 */ SyscallDesc("osf_old_vadvise", unimplementedFunc), + /* 73 */ SyscallDesc("munmap", munmapFunc), + /* 74 */ SyscallDesc("mprotect", ignoreFunc), + /* 75 */ SyscallDesc("madvise", unimplementedFunc), + /* 76 */ SyscallDesc("vhangup", unimplementedFunc), + /* 77 */ SyscallDesc("osf_kmodcall", unimplementedFunc), + /* 78 */ SyscallDesc("osf_mincore", unimplementedFunc), + /* 79 */ SyscallDesc("getgroups", unimplementedFunc), + /* 80 */ SyscallDesc("setgroups", unimplementedFunc), + /* 81 */ SyscallDesc("osf_old_getpgrp", unimplementedFunc), + /* 82 */ SyscallDesc("setpgrp", unimplementedFunc), + /* 83 */ SyscallDesc("osf_setitimer", unimplementedFunc), + /* 84 */ SyscallDesc("osf_old_wait", unimplementedFunc), + /* 85 */ SyscallDesc("osf_table", unimplementedFunc), + /* 86 */ SyscallDesc("osf_getitimer", unimplementedFunc), + /* 87 */ SyscallDesc("gethostname", gethostnameFunc), + /* 88 */ SyscallDesc("sethostname", unimplementedFunc), + /* 89 */ SyscallDesc("getdtablesize", unimplementedFunc), + /* 90 */ SyscallDesc("dup2", unimplementedFunc), + /* 91 */ SyscallDesc("fstat", fstatFunc<Linux>), + /* 92 */ SyscallDesc("fcntl", fcntlFunc), + /* 93 */ SyscallDesc("osf_select", unimplementedFunc), + /* 94 */ SyscallDesc("poll", unimplementedFunc), + /* 95 */ SyscallDesc("fsync", unimplementedFunc), + /* 96 */ SyscallDesc("setpriority", unimplementedFunc), + /* 97 */ SyscallDesc("socket", unimplementedFunc), + /* 98 */ SyscallDesc("connect", unimplementedFunc), + /* 99 */ SyscallDesc("accept", unimplementedFunc), + /* 100 */ SyscallDesc("getpriority", unimplementedFunc), + /* 101 */ SyscallDesc("send", unimplementedFunc), + /* 102 */ SyscallDesc("recv", unimplementedFunc), + /* 103 */ SyscallDesc("sigreturn", unimplementedFunc), + /* 104 */ SyscallDesc("bind", unimplementedFunc), + /* 105 */ SyscallDesc("setsockopt", unimplementedFunc), + /* 106 */ SyscallDesc("listen", unimplementedFunc), + /* 107 */ SyscallDesc("osf_plock", unimplementedFunc), + /* 108 */ SyscallDesc("osf_old_sigvec", unimplementedFunc), + /* 109 */ SyscallDesc("osf_old_sigblock", unimplementedFunc), + /* 110 */ SyscallDesc("osf_old_sigsetmask", unimplementedFunc), + /* 111 */ SyscallDesc("sigsuspend", unimplementedFunc), + /* 112 */ SyscallDesc("osf_sigstack", ignoreFunc), + /* 113 */ SyscallDesc("recvmsg", unimplementedFunc), + /* 114 */ SyscallDesc("sendmsg", unimplementedFunc), + /* 115 */ SyscallDesc("osf_old_vtrace", unimplementedFunc), + /* 116 */ SyscallDesc("osf_gettimeofday", unimplementedFunc), + /* 117 */ SyscallDesc("osf_getrusage", unimplementedFunc), + /* 118 */ SyscallDesc("getsockopt", unimplementedFunc), + /* 119 */ SyscallDesc("numa_syscalls", unimplementedFunc), + /* 120 */ SyscallDesc("readv", unimplementedFunc), + /* 121 */ SyscallDesc("writev", unimplementedFunc), + /* 122 */ SyscallDesc("osf_settimeofday", unimplementedFunc), + /* 123 */ SyscallDesc("fchown", unimplementedFunc), + /* 124 */ SyscallDesc("fchmod", unimplementedFunc), + /* 125 */ SyscallDesc("recvfrom", unimplementedFunc), + /* 126 */ SyscallDesc("setreuid", unimplementedFunc), + /* 127 */ SyscallDesc("setregid", unimplementedFunc), + /* 128 */ SyscallDesc("rename", unimplementedFunc), + /* 129 */ SyscallDesc("truncate", unimplementedFunc), + /* 130 */ SyscallDesc("ftruncate", unimplementedFunc), + /* 131 */ SyscallDesc("flock", unimplementedFunc), + /* 132 */ SyscallDesc("setgid", unimplementedFunc), + /* 133 */ SyscallDesc("sendto", unimplementedFunc), + /* 134 */ SyscallDesc("shutdown", unimplementedFunc), + /* 135 */ SyscallDesc("socketpair", unimplementedFunc), + /* 136 */ SyscallDesc("mkdir", unimplementedFunc), + /* 137 */ SyscallDesc("rmdir", unimplementedFunc), + /* 138 */ SyscallDesc("osf_utimes", unimplementedFunc), + /* 139 */ SyscallDesc("osf_old_sigreturn", unimplementedFunc), + /* 140 */ SyscallDesc("osf_adjtime", unimplementedFunc), + /* 141 */ SyscallDesc("getpeername", unimplementedFunc), + /* 142 */ SyscallDesc("osf_gethostid", unimplementedFunc), + /* 143 */ SyscallDesc("osf_sethostid", unimplementedFunc), + /* 144 */ SyscallDesc("getrlimit", getrlimitFunc<Linux>), + /* 145 */ SyscallDesc("setrlimit", unimplementedFunc), + /* 146 */ SyscallDesc("osf_old_killpg", unimplementedFunc), + /* 147 */ SyscallDesc("setsid", unimplementedFunc), + /* 148 */ SyscallDesc("quotactl", unimplementedFunc), + /* 149 */ SyscallDesc("osf_oldquota", unimplementedFunc), + /* 150 */ SyscallDesc("getsockname", unimplementedFunc), + /* 151 */ SyscallDesc("osf_pread", unimplementedFunc), + /* 152 */ SyscallDesc("osf_pwrite", unimplementedFunc), + /* 153 */ SyscallDesc("osf_pid_block", unimplementedFunc), + /* 154 */ SyscallDesc("osf_pid_unblock", unimplementedFunc), + /* 155 */ SyscallDesc("osf_signal_urti", unimplementedFunc), + /* 156 */ SyscallDesc("sigaction", ignoreFunc), + /* 157 */ SyscallDesc("osf_sigwaitprim", unimplementedFunc), + /* 158 */ SyscallDesc("osf_nfssvc", unimplementedFunc), + /* 159 */ SyscallDesc("osf_getdirentries", unimplementedFunc), + /* 160 */ SyscallDesc("osf_statfs", unimplementedFunc), + /* 161 */ SyscallDesc("osf_fstatfs", unimplementedFunc), + /* 162 */ SyscallDesc("unknown #162", unimplementedFunc), + /* 163 */ SyscallDesc("osf_async_daemon", unimplementedFunc), + /* 164 */ SyscallDesc("osf_getfh", unimplementedFunc), + /* 165 */ SyscallDesc("osf_getdomainname", unimplementedFunc), + /* 166 */ SyscallDesc("setdomainname", unimplementedFunc), + /* 167 */ SyscallDesc("unknown #167", unimplementedFunc), + /* 168 */ SyscallDesc("unknown #168", unimplementedFunc), + /* 169 */ SyscallDesc("osf_exportfs", unimplementedFunc), + /* 170 */ SyscallDesc("unknown #170", unimplementedFunc), + /* 171 */ SyscallDesc("unknown #171", unimplementedFunc), + /* 172 */ SyscallDesc("unknown #172", unimplementedFunc), + /* 173 */ SyscallDesc("unknown #173", unimplementedFunc), + /* 174 */ SyscallDesc("unknown #174", unimplementedFunc), + /* 175 */ SyscallDesc("unknown #175", unimplementedFunc), + /* 176 */ SyscallDesc("unknown #176", unimplementedFunc), + /* 177 */ SyscallDesc("unknown #177", unimplementedFunc), + /* 178 */ SyscallDesc("unknown #178", unimplementedFunc), + /* 179 */ SyscallDesc("unknown #179", unimplementedFunc), + /* 180 */ SyscallDesc("unknown #180", unimplementedFunc), + /* 181 */ SyscallDesc("osf_alt_plock", unimplementedFunc), + /* 182 */ SyscallDesc("unknown #182", unimplementedFunc), + /* 183 */ SyscallDesc("unknown #183", unimplementedFunc), + /* 184 */ SyscallDesc("osf_getmnt", unimplementedFunc), + /* 185 */ SyscallDesc("unknown #185", unimplementedFunc), + /* 186 */ SyscallDesc("unknown #186", unimplementedFunc), + /* 187 */ SyscallDesc("osf_alt_sigpending", unimplementedFunc), + /* 188 */ SyscallDesc("osf_alt_setsid", unimplementedFunc), + /* 189 */ SyscallDesc("unknown #189", unimplementedFunc), + /* 190 */ SyscallDesc("unknown #190", unimplementedFunc), + /* 191 */ SyscallDesc("unknown #191", unimplementedFunc), + /* 192 */ SyscallDesc("unknown #192", unimplementedFunc), + /* 193 */ SyscallDesc("unknown #193", unimplementedFunc), + /* 194 */ SyscallDesc("unknown #194", unimplementedFunc), + /* 195 */ SyscallDesc("unknown #195", unimplementedFunc), + /* 196 */ SyscallDesc("unknown #196", unimplementedFunc), + /* 197 */ SyscallDesc("unknown #197", unimplementedFunc), + /* 198 */ SyscallDesc("unknown #198", unimplementedFunc), + /* 199 */ SyscallDesc("osf_swapon", unimplementedFunc), + /* 200 */ SyscallDesc("msgctl", unimplementedFunc), + /* 201 */ SyscallDesc("msgget", unimplementedFunc), + /* 202 */ SyscallDesc("msgrcv", unimplementedFunc), + /* 203 */ SyscallDesc("msgsnd", unimplementedFunc), + /* 204 */ SyscallDesc("semctl", unimplementedFunc), + /* 205 */ SyscallDesc("semget", unimplementedFunc), + /* 206 */ SyscallDesc("semop", unimplementedFunc), + /* 207 */ SyscallDesc("osf_utsname", unimplementedFunc), + /* 208 */ SyscallDesc("lchown", unimplementedFunc), + /* 209 */ SyscallDesc("osf_shmat", unimplementedFunc), + /* 210 */ SyscallDesc("shmctl", unimplementedFunc), + /* 211 */ SyscallDesc("shmdt", unimplementedFunc), + /* 212 */ SyscallDesc("shmget", unimplementedFunc), + /* 213 */ SyscallDesc("osf_mvalid", unimplementedFunc), + /* 214 */ SyscallDesc("osf_getaddressconf", unimplementedFunc), + /* 215 */ SyscallDesc("osf_msleep", unimplementedFunc), + /* 216 */ SyscallDesc("osf_mwakeup", unimplementedFunc), + /* 217 */ SyscallDesc("msync", unimplementedFunc), + /* 218 */ SyscallDesc("osf_signal", unimplementedFunc), + /* 219 */ SyscallDesc("osf_utc_gettime", unimplementedFunc), + /* 220 */ SyscallDesc("osf_utc_adjtime", unimplementedFunc), + /* 221 */ SyscallDesc("unknown #221", unimplementedFunc), + /* 222 */ SyscallDesc("osf_security", unimplementedFunc), + /* 223 */ SyscallDesc("osf_kloadcall", unimplementedFunc), + /* 224 */ SyscallDesc("unknown #224", unimplementedFunc), + /* 225 */ SyscallDesc("unknown #225", unimplementedFunc), + /* 226 */ SyscallDesc("unknown #226", unimplementedFunc), + /* 227 */ SyscallDesc("unknown #227", unimplementedFunc), + /* 228 */ SyscallDesc("unknown #228", unimplementedFunc), + /* 229 */ SyscallDesc("unknown #229", unimplementedFunc), + /* 230 */ SyscallDesc("unknown #230", unimplementedFunc), + /* 231 */ SyscallDesc("unknown #231", unimplementedFunc), + /* 232 */ SyscallDesc("unknown #232", unimplementedFunc), + /* 233 */ SyscallDesc("getpgid", unimplementedFunc), + /* 234 */ SyscallDesc("getsid", unimplementedFunc), + /* 235 */ SyscallDesc("sigaltstack", ignoreFunc), + /* 236 */ SyscallDesc("osf_waitid", unimplementedFunc), + /* 237 */ SyscallDesc("osf_priocntlset", unimplementedFunc), + /* 238 */ SyscallDesc("osf_sigsendset", unimplementedFunc), + /* 239 */ SyscallDesc("osf_set_speculative", unimplementedFunc), + /* 240 */ SyscallDesc("osf_msfs_syscall", unimplementedFunc), + /* 241 */ SyscallDesc("osf_sysinfo", unimplementedFunc), + /* 242 */ SyscallDesc("osf_uadmin", unimplementedFunc), + /* 243 */ SyscallDesc("osf_fuser", unimplementedFunc), + /* 244 */ SyscallDesc("osf_proplist_syscall", unimplementedFunc), + /* 245 */ SyscallDesc("osf_ntp_adjtime", unimplementedFunc), + /* 246 */ SyscallDesc("osf_ntp_gettime", unimplementedFunc), + /* 247 */ SyscallDesc("osf_pathconf", unimplementedFunc), + /* 248 */ SyscallDesc("osf_fpathconf", unimplementedFunc), + /* 249 */ SyscallDesc("unknown #249", unimplementedFunc), + /* 250 */ SyscallDesc("osf_uswitch", unimplementedFunc), + /* 251 */ SyscallDesc("osf_usleep_thread", unimplementedFunc), + /* 252 */ SyscallDesc("osf_audcntl", unimplementedFunc), + /* 253 */ SyscallDesc("osf_audgen", unimplementedFunc), + /* 254 */ SyscallDesc("sysfs", unimplementedFunc), + /* 255 */ SyscallDesc("osf_subsys_info", unimplementedFunc), + /* 256 */ SyscallDesc("osf_getsysinfo", osf_getsysinfoFunc), + /* 257 */ SyscallDesc("osf_setsysinfo", osf_setsysinfoFunc), + /* 258 */ SyscallDesc("osf_afs_syscall", unimplementedFunc), + /* 259 */ SyscallDesc("osf_swapctl", unimplementedFunc), + /* 260 */ SyscallDesc("osf_memcntl", unimplementedFunc), + /* 261 */ SyscallDesc("osf_fdatasync", unimplementedFunc), + /* 262 */ SyscallDesc("unknown #262", unimplementedFunc), + /* 263 */ SyscallDesc("unknown #263", unimplementedFunc), + /* 264 */ SyscallDesc("unknown #264", unimplementedFunc), + /* 265 */ SyscallDesc("unknown #265", unimplementedFunc), + /* 266 */ SyscallDesc("unknown #266", unimplementedFunc), + /* 267 */ SyscallDesc("unknown #267", unimplementedFunc), + /* 268 */ SyscallDesc("unknown #268", unimplementedFunc), + /* 269 */ SyscallDesc("unknown #269", unimplementedFunc), + /* 270 */ SyscallDesc("unknown #270", unimplementedFunc), + /* 271 */ SyscallDesc("unknown #271", unimplementedFunc), + /* 272 */ SyscallDesc("unknown #272", unimplementedFunc), + /* 273 */ SyscallDesc("unknown #273", unimplementedFunc), + /* 274 */ SyscallDesc("unknown #274", unimplementedFunc), + /* 275 */ SyscallDesc("unknown #275", unimplementedFunc), + /* 276 */ SyscallDesc("unknown #276", unimplementedFunc), + /* 277 */ SyscallDesc("unknown #277", unimplementedFunc), + /* 278 */ SyscallDesc("unknown #278", unimplementedFunc), + /* 279 */ SyscallDesc("unknown #279", unimplementedFunc), + /* 280 */ SyscallDesc("unknown #280", unimplementedFunc), + /* 281 */ SyscallDesc("unknown #281", unimplementedFunc), + /* 282 */ SyscallDesc("unknown #282", unimplementedFunc), + /* 283 */ SyscallDesc("unknown #283", unimplementedFunc), + /* 284 */ SyscallDesc("unknown #284", unimplementedFunc), + /* 285 */ SyscallDesc("unknown #285", unimplementedFunc), + /* 286 */ SyscallDesc("unknown #286", unimplementedFunc), + /* 287 */ SyscallDesc("unknown #287", unimplementedFunc), + /* 288 */ SyscallDesc("unknown #288", unimplementedFunc), + /* 289 */ SyscallDesc("unknown #289", unimplementedFunc), + /* 290 */ SyscallDesc("unknown #290", unimplementedFunc), + /* 291 */ SyscallDesc("unknown #291", unimplementedFunc), + /* 292 */ SyscallDesc("unknown #292", unimplementedFunc), + /* 293 */ SyscallDesc("unknown #293", unimplementedFunc), + /* 294 */ SyscallDesc("unknown #294", unimplementedFunc), + /* 295 */ SyscallDesc("unknown #295", unimplementedFunc), + /* 296 */ SyscallDesc("unknown #296", unimplementedFunc), + /* 297 */ SyscallDesc("unknown #297", unimplementedFunc), + /* 298 */ SyscallDesc("unknown #298", unimplementedFunc), + /* 299 */ SyscallDesc("unknown #299", unimplementedFunc), +/* + * Linux-specific system calls begin at 300 + */ + /* 300 */ SyscallDesc("bdflush", unimplementedFunc), + /* 301 */ SyscallDesc("sethae", unimplementedFunc), + /* 302 */ SyscallDesc("mount", unimplementedFunc), + /* 303 */ SyscallDesc("old_adjtimex", unimplementedFunc), + /* 304 */ SyscallDesc("swapoff", unimplementedFunc), + /* 305 */ SyscallDesc("getdents", unimplementedFunc), + /* 306 */ SyscallDesc("create_module", unimplementedFunc), + /* 307 */ SyscallDesc("init_module", unimplementedFunc), + /* 308 */ SyscallDesc("delete_module", unimplementedFunc), + /* 309 */ SyscallDesc("get_kernel_syms", unimplementedFunc), + /* 310 */ SyscallDesc("syslog", unimplementedFunc), + /* 311 */ SyscallDesc("reboot", unimplementedFunc), + /* 312 */ SyscallDesc("clone", unimplementedFunc), + /* 313 */ SyscallDesc("uselib", unimplementedFunc), + /* 314 */ SyscallDesc("mlock", unimplementedFunc), + /* 315 */ SyscallDesc("munlock", unimplementedFunc), + /* 316 */ SyscallDesc("mlockall", unimplementedFunc), + /* 317 */ SyscallDesc("munlockall", unimplementedFunc), + /* 318 */ SyscallDesc("sysinfo", unimplementedFunc), + /* 319 */ SyscallDesc("_sysctl", unimplementedFunc), + /* 320 */ SyscallDesc("was sys_idle", unimplementedFunc), + /* 321 */ SyscallDesc("oldumount", unimplementedFunc), + /* 322 */ SyscallDesc("swapon", unimplementedFunc), + /* 323 */ SyscallDesc("times", unimplementedFunc), + /* 324 */ SyscallDesc("personality", unimplementedFunc), + /* 325 */ SyscallDesc("setfsuid", unimplementedFunc), + /* 326 */ SyscallDesc("setfsgid", unimplementedFunc), + /* 327 */ SyscallDesc("ustat", unimplementedFunc), + /* 328 */ SyscallDesc("statfs", unimplementedFunc), + /* 329 */ SyscallDesc("fstatfs", unimplementedFunc), + /* 330 */ SyscallDesc("sched_setparam", unimplementedFunc), + /* 331 */ SyscallDesc("sched_getparam", unimplementedFunc), + /* 332 */ SyscallDesc("sched_setscheduler", unimplementedFunc), + /* 333 */ SyscallDesc("sched_getscheduler", unimplementedFunc), + /* 334 */ SyscallDesc("sched_yield", unimplementedFunc), + /* 335 */ SyscallDesc("sched_get_priority_max", unimplementedFunc), + /* 336 */ SyscallDesc("sched_get_priority_min", unimplementedFunc), + /* 337 */ SyscallDesc("sched_rr_get_interval", unimplementedFunc), + /* 338 */ SyscallDesc("afs_syscall", unimplementedFunc), + /* 339 */ SyscallDesc("uname", unameFunc), + /* 340 */ SyscallDesc("nanosleep", unimplementedFunc), + /* 341 */ SyscallDesc("mremap", unimplementedFunc), + /* 342 */ SyscallDesc("nfsservctl", unimplementedFunc), + /* 343 */ SyscallDesc("setresuid", unimplementedFunc), + /* 344 */ SyscallDesc("getresuid", unimplementedFunc), + /* 345 */ SyscallDesc("pciconfig_read", unimplementedFunc), + /* 346 */ SyscallDesc("pciconfig_write", unimplementedFunc), + /* 347 */ SyscallDesc("query_module", unimplementedFunc), + /* 348 */ SyscallDesc("prctl", unimplementedFunc), + /* 349 */ SyscallDesc("pread", unimplementedFunc), + /* 350 */ SyscallDesc("pwrite", unimplementedFunc), + /* 351 */ SyscallDesc("rt_sigreturn", unimplementedFunc), + /* 352 */ SyscallDesc("rt_sigaction", unimplementedFunc), + /* 353 */ SyscallDesc("rt_sigprocmask", unimplementedFunc), + /* 354 */ SyscallDesc("rt_sigpending", unimplementedFunc), + /* 355 */ SyscallDesc("rt_sigtimedwait", unimplementedFunc), + /* 356 */ SyscallDesc("rt_sigqueueinfo", unimplementedFunc), + /* 357 */ SyscallDesc("rt_sigsuspend", unimplementedFunc), + /* 358 */ SyscallDesc("select", unimplementedFunc), + /* 359 */ SyscallDesc("gettimeofday", gettimeofdayFunc<Linux>), + /* 360 */ SyscallDesc("settimeofday", unimplementedFunc), + /* 361 */ SyscallDesc("getitimer", unimplementedFunc), + /* 362 */ SyscallDesc("setitimer", unimplementedFunc), + /* 363 */ SyscallDesc("utimes", unimplementedFunc), + /* 364 */ SyscallDesc("getrusage", getrusageFunc<Linux>), + /* 365 */ SyscallDesc("wait4", unimplementedFunc), + /* 366 */ SyscallDesc("adjtimex", unimplementedFunc), + /* 367 */ SyscallDesc("getcwd", unimplementedFunc), + /* 368 */ SyscallDesc("capget", unimplementedFunc), + /* 369 */ SyscallDesc("capset", unimplementedFunc), + /* 370 */ SyscallDesc("sendfile", unimplementedFunc), + /* 371 */ SyscallDesc("setresgid", unimplementedFunc), + /* 372 */ SyscallDesc("getresgid", unimplementedFunc), + /* 373 */ SyscallDesc("dipc", unimplementedFunc), + /* 374 */ SyscallDesc("pivot_root", unimplementedFunc), + /* 375 */ SyscallDesc("mincore", unimplementedFunc), + /* 376 */ SyscallDesc("pciconfig_iobase", unimplementedFunc), + /* 377 */ SyscallDesc("getdents64", unimplementedFunc), + /* 378 */ SyscallDesc("gettid", unimplementedFunc), + /* 379 */ SyscallDesc("readahead", unimplementedFunc), + /* 380 */ SyscallDesc("security", unimplementedFunc), + /* 381 */ SyscallDesc("tkill", unimplementedFunc), + /* 382 */ SyscallDesc("setxattr", unimplementedFunc), + /* 383 */ SyscallDesc("lsetxattr", unimplementedFunc), + /* 384 */ SyscallDesc("fsetxattr", unimplementedFunc), + /* 385 */ SyscallDesc("getxattr", unimplementedFunc), + /* 386 */ SyscallDesc("lgetxattr", unimplementedFunc), + /* 387 */ SyscallDesc("fgetxattr", unimplementedFunc), + /* 388 */ SyscallDesc("listxattr", unimplementedFunc), + /* 389 */ SyscallDesc("llistxattr", unimplementedFunc), + /* 390 */ SyscallDesc("flistxattr", unimplementedFunc), + /* 391 */ SyscallDesc("removexattr", unimplementedFunc), + /* 392 */ SyscallDesc("lremovexattr", unimplementedFunc), + /* 393 */ SyscallDesc("fremovexattr", unimplementedFunc), +}; + +const int Linux::Num_Syscall_Descs = + sizeof(Linux::syscallDescs) / sizeof(SyscallDesc); + +const int Linux::Max_Syscall_Desc = Linux::Num_Syscall_Descs - 1; + + +void +AlphaLinuxProcess::syscall(ExecContext *xc) +{ + num_syscalls++; + + int64_t callnum = xc->regs.intRegFile[ReturnValueReg]; + + Linux::doSyscall(callnum, this, xc); +} + + +AlphaLinuxProcess::AlphaLinuxProcess(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) + : LiveProcess(name, objFile, stdin_fd, stdout_fd, stderr_fd, argv, envp) +{ +} diff --git a/arch/alpha/alpha_linux_process.hh b/arch/alpha/alpha_linux_process.hh new file mode 100644 index 000000000..0d2f7641f --- /dev/null +++ b/arch/alpha/alpha_linux_process.hh @@ -0,0 +1,47 @@ +/* + * 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 __ALPHA_LINUX_PROCESS_HH__ +#define __ALPHA_LINUX_PROCESS_HH__ + +#include "sim/process.hh" + +class AlphaLinuxProcess : public LiveProcess +{ + public: + AlphaLinuxProcess(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); +}; + + +#endif // __ALPHA_LINUX_PROCESS_HH__ diff --git a/arch/alpha/fake_syscall.cc b/arch/alpha/alpha_tru64_process.cc index dc5619def..85648e68c 100644 --- a/arch/alpha/fake_syscall.cc +++ b/arch/alpha/alpha_tru64_process.cc @@ -28,6 +28,7 @@ #include <errno.h> #include <unistd.h> +#include <fcntl.h> // for host open() flags #include <sys/types.h> #include <sys/stat.h> #include <string.h> // for memset() @@ -36,303 +37,434 @@ #include "sim/host.hh" #include "cpu/base_cpu.hh" #include "mem/functional_mem/functional_memory.hh" -#include "sim/prog.hh" +#include "sim/process.hh" #include "cpu/exec_context.hh" #include "sim/fake_syscall.hh" -#include "sim/sim_events.hh" -#include "targetarch/osf_syscalls.h" +#include "arch/alpha/alpha_common_syscall_emul.hh" +#include "arch/alpha/alpha_tru64_process.hh" + +#include "sim/syscall_emul.hh" #include "sim/universe.hh" // for curTick & ticksPerSecond #include "base/trace.hh" using namespace std; +class Tru64 { + +public: + // -// System call descriptor +// basic Tru64 types // -class SyscallDesc { - public: +typedef uint64_t size_t; +typedef uint64_t off_t; +typedef uint16_t nlink_t; +typedef int32_t dev_t; +typedef uint32_t uid_t; +typedef uint32_t gid_t; +typedef uint32_t time_t; +typedef uint32_t mode_t; +typedef uint32_t ino_t; + +// open(2) flags +static const int TGT_O_RDONLY = 00000000; +static const int TGT_O_WRONLY = 00000001; +static const int TGT_O_RDWR = 00000002; +static const int TGT_O_NONBLOCK = 00000004; +static const int TGT_O_APPEND = 00000010; +static const int TGT_O_CREAT = 00001000; +static const int TGT_O_TRUNC = 00002000; +static const int TGT_O_EXCL = 00004000; +static const int TGT_O_NOCTTY = 00010000; +static const int TGT_O_SYNC = 00040000; +static const int TGT_O_DRD = 00100000; +static const int TGT_O_DIRECTIO = 00200000; +static const int TGT_O_CACHE = 00400000; +static const int TGT_O_DSYNC = 02000000; +static const int TGT_O_RSYNC = 04000000; + +static OpenFlagTransTable openFlagTable[]; +static const int NUM_OPEN_FLAGS; - typedef int (*FuncPtr)(SyscallDesc *, int num, - Process *, ExecContext *); +// +// Stat buffer. Note that Tru64 v5.0+ use a new "F64" stat structure, +// and a new set of syscall numbers for stat calls. Backwards +// compatibility with v4.x should be feasible by implementing another +// set of stat functions using the old structure definition and +// binding them to the old syscall numbers, but we haven't done that +// yet. +// - const char *name; - FuncPtr funcPtr; - int flags; +struct F64_stat { + dev_t st_dev; + int32_t st_retired1; + mode_t st_mode; + nlink_t st_nlink; + uint16_t st_nlink_reserved; + uid_t st_uid; + gid_t st_gid; + dev_t st_rdev; + dev_t st_ldev; + off_t st_size; + time_t st_retired2; + int32_t st_uatime; + time_t st_retired3; + int32_t st_umtime; + time_t st_retired4; + int32_t st_uctime; + int32_t st_retired5; + int32_t st_retired6; + uint32_t st_flags; + uint32_t st_gen; + uint64_t st_spare[4]; + ino_t st_ino; + int32_t st_ino_reserved; + time_t st_atimeX; + int32_t st_atime_reserved; + time_t st_mtimeX; + int32_t st_mtime_reserved; + time_t st_ctimeX; + int32_t st_ctime_reserved; + uint64_t st_blksize; + uint64_t st_blocks; +}; - enum Flags { - SuppressReturnValue = 1 - }; - SyscallDesc(const char *_name, FuncPtr _funcPtr, int _flags = 0) - : name(_name), funcPtr(_funcPtr), flags(_flags) - { - } +// +// for getdirentries() +// - int doFunc(int num, Process *proc, ExecContext *xc) - { - return (*funcPtr)(this, num, proc, xc); - } +struct dirent +{ + ino_t d_ino; /* file number of entry */ + uint16_t d_reclen; /* length of this record */ + uint16_t d_namlen; /* length of string in d_name */ + char d_name[256]; /* dummy name length */ }; -class BaseBufferArg { - - public: +// +// for uname() +// - 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); - } +static const int _SYS_NMLN = 32; - virtual ~BaseBufferArg() { delete [] bufPtr; } +struct utsname { + char sysname[_SYS_NMLN]; + char nodename[_SYS_NMLN]; + char release[_SYS_NMLN]; + char version[_SYS_NMLN]; + char machine[_SYS_NMLN]; +}; - // - // 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 - } +// +// for ioctl() +// - protected: - Addr addr; - int size; - uint8_t *bufPtr; -}; +static const unsigned TIOCGETP = 0x40067408; +static const unsigned TIOCSETP = 0x80067409; +static const unsigned TIOCSETN = 0x8006740a; +static const unsigned TIOCSETC = 0x80067411; +static const unsigned TIOCGETC = 0x40067412; +static const unsigned FIONREAD = 0x4004667f; +static const unsigned TIOCISATTY = 0x2000745e; +// +// for getrlimit() +// -class BufferArg : public BaseBufferArg -{ - public: - BufferArg(Addr _addr, int _size) : BaseBufferArg(_addr, _size) { } - void *bufferPtr() { return bufPtr; } +enum rlimit_resources { + RLIMIT_CPU = 0, + RLIMIT_FSIZE = 1, + RLIMIT_DATA = 2, + RLIMIT_STACK = 3, + RLIMIT_CORE = 4, + RLIMIT_RSS = 5, + RLIMIT_NOFILE = 6, + RLIMIT_AS = 7, + RLIMIT_VMEM = 7 }; -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]; } +struct rlimit { + uint64_t rlim_cur; // soft limit + uint64_t rlim_max; // hard limit }; -static IntReg -getArg(ExecContext *xc, int i) -{ - return xc->regs.intRegFile[ArgumentReg0 + i]; -} - - // -// used to shift args for indirect syscall +// for mmap() // -static void -setArg(ExecContext *xc, int i, IntReg val) -{ - xc->regs.intRegFile[ArgumentReg0 + i] = val; -} - - -static void -set_return_value(ExecContext *xc, int64_t return_value) -{ - // check for error condition. Alpha syscall convention is to - // indicate success/failure in reg a3 (r19) and put the - // return value itself in the standard return value reg (v0). - const int RegA3 = 19; // only place this is used - if (return_value >= 0) { - // no error - xc->regs.intRegFile[RegA3] = 0; - xc->regs.intRegFile[ReturnValueReg] = return_value; - } else { - // got an error, return details - xc->regs.intRegFile[RegA3] = (IntReg) -1; - xc->regs.intRegFile[ReturnValueReg] = -return_value; - } -} - - -int -getpagesizeFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - return VMPageSize; -} - - -int -obreakFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - // change brk addr to first arg - process->brk_point = getArg(xc, 0); - return process->brk_point; -} - - -int -ioctlFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int fd = getArg(xc, 0); - unsigned req = getArg(xc, 1); + static const unsigned TGT_MAP_ANONYMOUS = 0x10; - 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; - } +// +// for getsysinfo() +// - switch (req) { - case OSF::TIOCISATTY: - case OSF::TIOCGETP: - case OSF::TIOCSETP: - case OSF::TIOCSETN: - case OSF::TIOCSETC: - case OSF::TIOCGETC: - return -ENOTTY; +static const unsigned GSI_PLATFORM_NAME = 103; // get platform name as string +static const unsigned GSI_CPU_INFO = 59; // CPU information +static const unsigned GSI_PROC_TYPE = 60; // get proc_type +static const unsigned GSI_MAX_CPU = 30; // max # cpu's on this machine +static const unsigned GSI_CPUS_IN_BOX = 55; // number of processors in system +static const unsigned GSI_PHYSMEM = 19; // Amount of physical memory in KB +static const unsigned GSI_CLK_TCK = 42; // clock freq in Hz + +struct cpu_info { + uint32_t current_cpu; + uint32_t cpus_in_box; + uint32_t cpu_type; + uint32_t ncpus; + uint64_t cpus_present; + uint64_t cpus_running; + uint64_t cpu_binding; + uint64_t cpu_ex_binding; + uint32_t mhz; + uint32_t unused[3]; // future expansion +}; - default: - fatal("Unsupported ioctl call: ioctl(%d, 0x%x, ...)\n", fd, req); - } -} +// +// for gettimeofday +// +struct timeval { + uint32_t tv_sec; + uint32_t tv_usec; +}; -int -openFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - string path; +// +// for getrusage +// - if (xc->mem->readString(path, getArg(xc, 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; - } +static const int RUSAGE_THREAD = 1; +static const int RUSAGE_SELF = 0; +static const int RUSAGE_CHILDREN = -1; + +struct rusage { + struct timeval ru_utime; // user time used + struct timeval ru_stime; // system time used + uint64_t ru_maxrss; + uint64_t ru_ixrss; // integral shared memory size + uint64_t ru_idrss; // integral unshared data " + uint64_t ru_isrss; // integral unshared stack " + uint64_t ru_minflt; // page reclaims - total vmfaults + uint64_t ru_majflt; // page faults + uint64_t ru_nswap; // swaps + uint64_t ru_inblock; // block input operations + uint64_t ru_oublock; // block output operations + uint64_t ru_msgsnd; // messages sent + uint64_t ru_msgrcv; // messages received + uint64_t ru_nsignals; // signals received + uint64_t ru_nvcsw; // voluntary context switches + uint64_t ru_nivcsw; // involuntary " +}; - int osfFlags = getArg(xc, 1); - int mode = getArg(xc, 2); - int hostFlags = 0; +// +// for sigreturn +// - // translate open flags - for (int i = 0; i < OSF::NUM_OPEN_FLAGS; i++) { - if (osfFlags & OSF::openFlagTable[i].osfFlag) { - osfFlags &= ~OSF::openFlagTable[i].osfFlag; - hostFlags |= OSF::openFlagTable[i].hostFlag; - } - } +struct sigcontext { + int64_t sc_onstack; // sigstack state to restore + int64_t sc_mask; // signal mask to restore + int64_t sc_pc; // pc at time of signal + int64_t sc_ps; // psl to retore + int64_t sc_regs[32]; // processor regs 0 to 31 + int64_t sc_ownedfp; // fp has been used + int64_t sc_fpregs[32]; // fp regs 0 to 31 + uint64_t sc_fpcr; // floating point control reg + uint64_t sc_fp_control; // software fpcr + int64_t sc_reserved1; // reserved for kernel + uint32_t sc_kreserved1; // reserved for kernel + uint32_t sc_kreserved2; // reserved for kernel + size_t sc_ssize; // stack size + caddr_t sc_sbase; // stack start + uint64_t sc_traparg_a0; // a0 argument to trap on exc + uint64_t sc_traparg_a1; // a1 argument to trap on exc + uint64_t sc_traparg_a2; // a2 argument to trap on exc + uint64_t sc_fp_trap_pc; // imprecise pc + uint64_t sc_fp_trigger_sum; // Exception summary at trigg + uint64_t sc_fp_trigger_inst; // Instruction at trigger pc +}; - // any target flags left? - if (osfFlags != 0) - cerr << "Syscall: open: cannot decode flags: " << osfFlags << endl; -#ifdef __CYGWIN32__ - hostFlags |= O_BINARY; -#endif +// +// for table +// +static const int TBL_SYSINFO = 12; + +struct tbl_sysinfo { + uint64_t si_user; // User time + uint64_t si_nice; // Nice time + uint64_t si_sys; // System time + uint64_t si_idle; // Idle time + uint64_t si_hz; + uint64_t si_phz; + uint64_t si_boottime; // Boot time in seconds + uint64_t wait; // Wait time + uint32_t si_max_procs; // rpb->rpb_numprocs + uint32_t pad; +}; - // open the file - int fd = open(path.c_str(), hostFlags, mode); - - return (fd == -1) ? -errno : process->open_fd(fd); -} +// +// for stack_create +// -int -closeFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int fd = process->sim_fd(getArg(xc, 0)); - return close(fd); -} +struct vm_stack { + // void * + Addr address; // address hint + size_t rsize; // red zone size + size_t ysize; // yellow zone size + size_t gsize; // green zone size + size_t swap; // amount of swap to reserve + size_t incr; // growth increment + uint64_t align; // address alignment + uint64_t flags; // MAP_FIXED etc. + // struct memalloc_attr * + Addr attr; // allocation policy + uint64_t reserved; +}; +// +// return values for nxm calls +// +enum { + KERN_NOT_RECEIVER = 7, + KERN_NOT_IN_SET = 12 +}; -int -readFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int fd = process->sim_fd(getArg(xc, 0)); - int nbytes = getArg(xc, 2); - BufferArg bufArg(getArg(xc, 1), nbytes); +// +// for nxm_task_init +// - int bytes_read = read(fd, bufArg.bufferPtr(), nbytes); +static const int NXM_TASK_INIT_VP = 2; // initial thread is VP - if (bytes_read != -1) - bufArg.copyOut(xc->mem); +struct nxm_task_attr { + int64_t nxm_callback; + unsigned int nxm_version; + unsigned short nxm_uniq_offset; + unsigned short flags; + int nxm_quantum; + int pad1; + int64_t pad2; +}; - return bytes_read; -} +typedef uint64_t sigset_t; + +struct ushared_state { + sigset_t sigmask; // thread signal mask + sigset_t sig; // thread pending mask + // struct nxm_pth_state * + Addr pth_id; // out-of-line state + int flags; // shared flags +#define US_SIGSTACK 0x1 // thread called sigaltstack +#define US_ONSTACK 0x2 // thread is running on altstack +#define US_PROFILE 0x4 // thread called profil +#define US_SYSCALL 0x8 // thread in syscall +#define US_TRAP 0x10 // thread has trapped +#define US_YELLOW 0x20 // thread has mellowed yellow +#define US_YZONE 0x40 // thread has zoned out +#define US_FP_OWNED 0x80 // thread used floating point + + int cancel_state; // thread's cancelation state +#define US_CANCEL 0x1 // cancel pending +#define US_NOCANCEL 0X2 // synch cancel disabled +#define US_SYS_NOCANCEL 0x4 // syscall cancel disabled +#define US_ASYNC_NOCANCEL 0x8 // asynch cancel disabled +#define US_CANCEL_BITS (US_NOCANCEL|US_SYS_NOCANCEL|US_ASYNC_NOCANCEL) +#define US_CANCEL_MASK (US_CANCEL|US_NOCANCEL|US_SYS_NOCANCEL| \ + US_ASYNC_NOCANCEL) + + // These are semi-shared. They are always visible to + // the kernel but are never context-switched by the library. + + int nxm_ssig; // scheduler's synchronous signals + int reserved1; + int64_t nxm_active; // scheduler active + int64_t reserved2; +}; -int -writeFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int fd = process->sim_fd(getArg(xc, 0)); - int nbytes = getArg(xc, 2); - BufferArg bufArg(getArg(xc, 1), nbytes); +struct nxm_sched_state { + struct ushared_state nxm_u; // state own by user thread + unsigned int nxm_bits; // scheduler state / slot + int nxm_quantum; // quantum count-down value + int nxm_set_quantum; // quantum reset value + int nxm_sysevent; // syscall state + // struct nxm_upcall * + Addr nxm_uc_ret; // stack ptr of null thread + // void * + Addr nxm_tid; // scheduler's thread id + int64_t nxm_va; // page fault address + // struct nxm_pth_state * + Addr nxm_pthid; // id of null thread + uint64_t nxm_bound_pcs_count; // bound PCS thread count + int64_t pad[2]; +}; - bufArg.copyIn(xc->mem); +struct nxm_shared { + int64_t nxm_callback; // address of upcall routine + unsigned int nxm_version; // version number + unsigned short nxm_uniq_offset; // correction factor for TEB + unsigned short pad1; + int64_t space[2]; // future growth + struct nxm_sched_state nxm_ss[1]; // array of shared areas +}; - int bytes_written = write(fd, bufArg.bufferPtr(), nbytes); +enum nxm_slot_state_t { + NXM_SLOT_AVAIL, + NXM_SLOT_BOUND, + NXM_SLOT_UNBOUND, + NXM_SLOT_EMPTY +}; - fsync(fd); - return bytes_written; -} +struct nxm_config_info { + int nxm_nslots_per_rad; // max number of VP slots per RAD + int nxm_nrads; // max number of RADs + // nxm_slot_state_t * + Addr nxm_slot_state; // per-VP slot state + // struct nxm_shared * + Addr nxm_rad[1]; // per-RAD shared areas +}; +// +// for nxm_thread_create +// -int -lseekFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int fd = process->sim_fd(getArg(xc, 0)); - uint64_t offs = getArg(xc, 1); - int whence = getArg(xc, 2); +enum nxm_thread_type { + NXM_TYPE_SCS = 0, + NXM_TYPE_VP = 1, + NXM_TYPE_MANAGER = 2 +}; - off_t result = lseek(fd, offs, whence); - return (result == (off_t)-1) ? -errno : result; -} +struct nxm_thread_attr { + int version; + int type; + int cancel_flags; + int priority; + int policy; + int signal_type; + // void * + Addr pthid; + sigset_t sigmask; + struct { + uint64_t pc; + uint64_t sp; + uint64_t a0; + } registers; + uint64_t pad2[2]; +}; static void copyOutStatBuf(FunctionalMemory *mem, Addr addr, struct stat *host) { - TypedBufferArg<OSF::F64_stat> tgt(addr); + TypedBufferArg<Tru64::F64_stat> tgt(addr); tgt->st_dev = host->st_dev; tgt->st_ino = host->st_ino; @@ -351,107 +483,14 @@ copyOutStatBuf(FunctionalMemory *mem, Addr addr, struct stat *host) tgt.copyOut(mem); } -int -statFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - string path; - - if (xc->mem->readString(path, getArg(xc, 0)) != No_Fault) - return -EFAULT; - - struct stat hostBuf; - int result = stat(path.c_str(), &hostBuf); - - if (result < 0) - return -errno; - - copyOutStatBuf(xc->mem, getArg(xc, 1), &hostBuf); - - return 0; -} - - -int -lstatFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - string path; - - if (xc->mem->readString(path, getArg(xc, 0)) != No_Fault) - return -EFAULT; - - struct stat hostBuf; - int result = lstat(path.c_str(), &hostBuf); - - if (result < 0) - return -errno; - - copyOutStatBuf(xc->mem, getArg(xc, 1), &hostBuf); - - return 0; -} - -int -fstatFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int fd = process->sim_fd(getArg(xc, 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; - - copyOutStatBuf(xc->mem, getArg(xc, 1), &hostBuf); - - return 0; -} - - -// -// We don't handle mmap(). If the target is really mmaping /dev/zero, -// we can get away with doing nothing (since 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 an mmap to anything else. -// -int -mmapFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - Addr start = getArg(xc, 0); - uint64_t length = getArg(xc, 1); - int prot = getArg(xc, 2); - int flags = getArg(xc, 3); - int fd = process->sim_fd(getArg(xc, 4)); - int offset = getArg(xc, 5); - - cerr << "Warning: ignoring syscall mmap(" - << start << ", " << length << ", " - << prot << ", " << flags << ", " - << fd << " " << getArg(xc, 4) << ", " - << offset << ")" << endl; - - return start; -} - - -const char *hostname = "m5.eecs.umich.edu"; +static const char *hostname; +static int unameFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - TypedBufferArg<OSF::utsname> name(getArg(xc, 0)); + TypedBufferArg<Tru64::utsname> name(xc->getSyscallArg(0)); strcpy(name->sysname, "OSF1"); strcpy(name->nodename, hostname); @@ -464,53 +503,39 @@ unameFunc(SyscallDesc *desc, int callnum, Process *process, } -int -gethostnameFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int name_len = getArg(xc, 1); - BufferArg name(getArg(xc, 0), name_len); - - strncpy((char *)name.bufferPtr(), hostname, name_len); - - name.copyOut(xc->mem); - - return 0; -} - - +static int getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - unsigned op = getArg(xc, 0); - unsigned nbytes = getArg(xc, 2); + unsigned op = xc->getSyscallArg(0); + unsigned nbytes = xc->getSyscallArg(2); switch (op) { - case OSF::GSI_MAX_CPU: { - TypedBufferArg<uint32_t> max_cpu(getArg(xc, 1)); + case Tru64::GSI_MAX_CPU: { + TypedBufferArg<uint32_t> max_cpu(xc->getSyscallArg(1)); *max_cpu = process->numCpus(); max_cpu.copyOut(xc->mem); return 1; } - case OSF::GSI_CPUS_IN_BOX: { - TypedBufferArg<uint32_t> cpus_in_box(getArg(xc, 1)); + case Tru64::GSI_CPUS_IN_BOX: { + TypedBufferArg<uint32_t> cpus_in_box(xc->getSyscallArg(1)); *cpus_in_box = process->numCpus(); cpus_in_box.copyOut(xc->mem); return 1; } - case OSF::GSI_PHYSMEM: { - TypedBufferArg<uint64_t> physmem(getArg(xc, 1)); + case Tru64::GSI_PHYSMEM: { + TypedBufferArg<uint64_t> physmem(xc->getSyscallArg(1)); *physmem = 1024 * 1024; // physical memory in KB physmem.copyOut(xc->mem); return 1; } - case OSF::GSI_CPU_INFO: { - TypedBufferArg<OSF::cpu_info> infop(getArg(xc, 1)); + case Tru64::GSI_CPU_INFO: { + TypedBufferArg<Tru64::cpu_info> infop(xc->getSyscallArg(1)); infop->current_cpu = 0; infop->cpus_in_box = process->numCpus(); @@ -526,15 +551,15 @@ getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process, return 1; } - case OSF::GSI_PROC_TYPE: { - TypedBufferArg<uint64_t> proc_type(getArg(xc, 1)); + case Tru64::GSI_PROC_TYPE: { + TypedBufferArg<uint64_t> proc_type(xc->getSyscallArg(1)); *proc_type = 11; proc_type.copyOut(xc->mem); return 1; } - case OSF::GSI_PLATFORM_NAME: { - BufferArg bufArg(getArg(xc, 1), nbytes); + case Tru64::GSI_PLATFORM_NAME: { + BufferArg bufArg(xc->getSyscallArg(1), nbytes); strncpy((char *)bufArg.bufferPtr(), "COMPAQ Professional Workstation XP1000", nbytes); @@ -542,8 +567,8 @@ getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process, return 1; } - case OSF::GSI_CLK_TCK: { - TypedBufferArg<uint64_t> clk_hz(getArg(xc, 1)); + case Tru64::GSI_CLK_TCK: { + TypedBufferArg<uint64_t> clk_hz(xc->getSyscallArg(1)); *clk_hz = 1024; clk_hz.copyOut(xc->mem); return 1; @@ -558,64 +583,17 @@ getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process, return 0; } -int -getpidFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - // 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. - - // This is one of the funky syscalls that has two return values, - // with the second one (parent PID) going in r20. - xc->regs.intRegFile[20] = 99; - return 100; -} - - -int -getuidFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - // Make up a UID and EUID... it shouldn't matter, and we want the - // simulation to be deterministic. - - // EUID goes in r20. - xc->regs.intRegFile[20] = 100; // EUID - return 100; // UID -} - - -int -getgidFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - // Get current group ID. EGID goes in r20. - xc->regs.intRegFile[20] = 100; - return 100; -} - - -int -setuidFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - // can't fathom why a benchmark would call this. - warn("Ignoring call to setuid(%d)\n", getArg(xc, 0)); - return 0; -} - - +static int fcntlFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - int fd = getArg(xc,0); + int fd = xc->getSyscallArg(0); if (fd < 0 || process->sim_fd(fd) < 0) return -EBADF; - int cmd = getArg(xc,1); + int cmd = xc->getSyscallArg(1); switch (cmd) { case 0: // F_DUPFD // if we really wanted to support this, we'd need to do it @@ -623,8 +601,10 @@ fcntlFunc(SyscallDesc *desc, int callnum, Process *process, warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd); return -EMFILE; - case 1: // F_GETFD (get fd flags) - case 2: // F_SETFD (set fd flags) + case 1: // F_GETFD (get close-on-exec flag) + case 2: // F_SETFD (set close-on-exec flag) + return 0; + case 3: // F_GETFL (get file flags) case 4: // F_SETFL (set file flags) // not sure if this is totally valid, but we'll pass it through @@ -647,21 +627,22 @@ fcntlFunc(SyscallDesc *desc, int callnum, Process *process, } +static int getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - int fd = process->sim_fd(getArg(xc, 0)); - Addr tgt_buf = getArg(xc, 1); - int tgt_nbytes = getArg(xc, 2); - Addr tgt_basep = getArg(xc, 3); + int fd = process->sim_fd(xc->getSyscallArg(0)); + Addr tgt_buf = xc->getSyscallArg(1); + int tgt_nbytes = xc->getSyscallArg(2); + Addr tgt_basep = xc->getSyscallArg(3); char * const host_buf = new char[tgt_nbytes]; // just pass basep through uninterpreted. TypedBufferArg<int64_t> basep(tgt_basep); basep.copyIn(xc->mem); - off_t host_basep = (off_t)*basep; + ::off_t host_basep = (off_t)*basep; int host_result = getdirentries(fd, host_buf, tgt_nbytes, &host_basep); // check for error @@ -679,10 +660,10 @@ getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process, int namelen = strlen(host_dp->d_name); // Actual size includes padded string rounded up for alignment. - // Subtract 256 for dummy char array in OSF::dirent definition. + // Subtract 256 for dummy char array in Tru64::dirent definition. // Add 1 to namelen for terminating null char. - int tgt_bufsize = sizeof(OSF::dirent) - 256 + RoundUp(namelen+1, 8); - TypedBufferArg<OSF::dirent> tgt_dp(tgt_buf_ptr, tgt_bufsize); + int tgt_bufsize = sizeof(Tru64::dirent) - 256 + RoundUp(namelen+1, 8); + TypedBufferArg<Tru64::dirent> tgt_dp(tgt_buf_ptr, tgt_bufsize); tgt_dp->d_ino = host_dp->d_ino; tgt_dp->d_reclen = tgt_bufsize; tgt_dp->d_namlen = namelen; @@ -702,110 +683,13 @@ getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process, } -int -getrlimitFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - unsigned resource = getArg(xc, 0); - TypedBufferArg<OSF::rlimit> rlp(getArg(xc, 1)); - - switch (resource) { - case OSF::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 -static const int one_million = 1000000; - -// seconds since the epoch (1/1/1970)... about a billion, by my reckoning -static const unsigned seconds_since_epoch = 1000000000; - -// -// helper function: populate struct timeval with approximation of -// current elapsed time -// -static void -getElapsedTime(OSF::timeval *tp) -{ - int cycles_per_usec = ticksPerSecond / one_million; - - int elapsed_usecs = curTick / cycles_per_usec; - tp->tv_sec = elapsed_usecs / one_million; - tp->tv_usec = elapsed_usecs % one_million; -} - - -int -gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - TypedBufferArg<OSF::timeval> tp(getArg(xc, 0)); - - getElapsedTime(tp); - tp->tv_sec += seconds_since_epoch; - - tp.copyOut(xc->mem); - - return 0; -} - - -int -getrusageFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int who = getArg(xc, 0); // THREAD, SELF, or CHILDREN - TypedBufferArg<OSF::rusage> rup(getArg(xc, 1)); - - if (who != OSF::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); - 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; -} - - +static int sigreturnFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { RegFile *regs = &xc->regs; - TypedBufferArg<OSF::sigcontext> sc(getArg(xc, 0)); + TypedBufferArg<Tru64::sigcontext> sc(xc->getSyscallArg(0)); sc.copyIn(xc->mem); @@ -825,21 +709,22 @@ sigreturnFunc(SyscallDesc *desc, int callnum, Process *process, return 0; } +static int tableFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - int id = getArg(xc, 0); // table ID - int index = getArg(xc, 1); // index into table + int id = xc->getSyscallArg(0); // table ID + int index = xc->getSyscallArg(1); // index into table // arg 2 is buffer pointer; type depends on table ID - int nel = getArg(xc, 3); // number of elements - int lel = getArg(xc, 4); // expected element size + int nel = xc->getSyscallArg(3); // number of elements + int lel = xc->getSyscallArg(4); // expected element size switch (id) { - case OSF::TBL_SYSINFO: { - if (index != 0 || nel != 1 || lel != sizeof(OSF::tbl_sysinfo)) + case Tru64::TBL_SYSINFO: { + if (index != 0 || nel != 1 || lel != sizeof(Tru64::tbl_sysinfo)) return -EINVAL; - TypedBufferArg<OSF::tbl_sysinfo> elp(getArg(xc, 2)); + TypedBufferArg<Tru64::tbl_sysinfo> elp(xc->getSyscallArg(2)); const int clk_hz = one_million; elp->si_user = curTick / (ticksPerSecond / clk_hz); @@ -861,342 +746,22 @@ tableFunc(SyscallDesc *desc, int callnum, Process *process, } } -// -// forward declaration... defined below table -// -int -indirectSyscallFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc); - -// -// 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: " << getArg(xc, 0) << ", " << getArg(xc, 1) - << ", ..." << endl; - - abort(); -} +static SyscallDesc syscallDescs[]; - -// -// 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 - << "(" << getArg(xc, 0) - << ", " << getArg(xc, 1) - << ", ...)" << endl; - - return 0; -} - - -int -exitFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - new SimExitEvent("syscall caused exit", getArg(xc, 0) & 0xff); - - return 1; -} - - -SyscallDesc syscallDescs[] = { - /* 0 */ SyscallDesc("syscall (#0)", indirectSyscallFunc, SyscallDesc::SuppressReturnValue), - /* 1 */ SyscallDesc("exit", exitFunc), - /* 2 */ SyscallDesc("fork", unimplementedFunc), - /* 3 */ SyscallDesc("read", readFunc), - /* 4 */ SyscallDesc("write", writeFunc), - /* 5 */ SyscallDesc("old_open", unimplementedFunc), - /* 6 */ SyscallDesc("close", closeFunc), - /* 7 */ SyscallDesc("wait4", unimplementedFunc), - /* 8 */ SyscallDesc("old_creat", unimplementedFunc), - /* 9 */ SyscallDesc("link", unimplementedFunc), - /* 10 */ SyscallDesc("unlink", unimplementedFunc), - /* 11 */ SyscallDesc("execv", unimplementedFunc), - /* 12 */ SyscallDesc("chdir", unimplementedFunc), - /* 13 */ SyscallDesc("fchdir", unimplementedFunc), - /* 14 */ SyscallDesc("mknod", unimplementedFunc), - /* 15 */ SyscallDesc("chmod", unimplementedFunc), - /* 16 */ SyscallDesc("chown", unimplementedFunc), - /* 17 */ SyscallDesc("obreak", obreakFunc), - /* 18 */ SyscallDesc("pre_F64_getfsstat", unimplementedFunc), - /* 19 */ SyscallDesc("lseek", lseekFunc), - /* 20 */ SyscallDesc("getpid", getpidFunc), - /* 21 */ SyscallDesc("mount", unimplementedFunc), - /* 22 */ SyscallDesc("unmount", unimplementedFunc), - /* 23 */ SyscallDesc("setuid", setuidFunc), - /* 24 */ SyscallDesc("getuid", getuidFunc), - /* 25 */ SyscallDesc("exec_with_loader", unimplementedFunc), - /* 26 */ SyscallDesc("ptrace", unimplementedFunc), - /* 27 */ SyscallDesc("recvmsg", unimplementedFunc), - /* 28 */ SyscallDesc("sendmsg", unimplementedFunc), - /* 29 */ SyscallDesc("recvfrom", unimplementedFunc), - /* 30 */ SyscallDesc("accept", unimplementedFunc), - /* 31 */ SyscallDesc("getpeername", unimplementedFunc), - /* 32 */ SyscallDesc("getsockname", unimplementedFunc), - /* 33 */ SyscallDesc("access", unimplementedFunc), - /* 34 */ SyscallDesc("chflags", unimplementedFunc), - /* 35 */ SyscallDesc("fchflags", unimplementedFunc), - /* 36 */ SyscallDesc("sync", unimplementedFunc), - /* 37 */ SyscallDesc("kill", unimplementedFunc), - /* 38 */ SyscallDesc("old_stat", unimplementedFunc), - /* 39 */ SyscallDesc("setpgid", unimplementedFunc), - /* 40 */ SyscallDesc("old_lstat", unimplementedFunc), - /* 41 */ SyscallDesc("dup", unimplementedFunc), - /* 42 */ SyscallDesc("pipe", unimplementedFunc), - /* 43 */ SyscallDesc("set_program_attributes", unimplementedFunc), - /* 44 */ SyscallDesc("profil", unimplementedFunc), - /* 45 */ SyscallDesc("open", openFunc), - /* 46 */ SyscallDesc("obsolete osigaction", unimplementedFunc), - /* 47 */ SyscallDesc("getgid", getgidFunc), - /* 48 */ SyscallDesc("sigprocmask", ignoreFunc), - /* 49 */ SyscallDesc("getlogin", unimplementedFunc), - /* 50 */ SyscallDesc("setlogin", unimplementedFunc), - /* 51 */ SyscallDesc("acct", unimplementedFunc), - /* 52 */ SyscallDesc("sigpending", unimplementedFunc), - /* 53 */ SyscallDesc("classcntl", unimplementedFunc), - /* 54 */ SyscallDesc("ioctl", ioctlFunc), - /* 55 */ SyscallDesc("reboot", unimplementedFunc), - /* 56 */ SyscallDesc("revoke", unimplementedFunc), - /* 57 */ SyscallDesc("symlink", unimplementedFunc), - /* 58 */ SyscallDesc("readlink", unimplementedFunc), - /* 59 */ SyscallDesc("execve", unimplementedFunc), - /* 60 */ SyscallDesc("umask", unimplementedFunc), - /* 61 */ SyscallDesc("chroot", unimplementedFunc), - /* 62 */ SyscallDesc("old_fstat", unimplementedFunc), - /* 63 */ SyscallDesc("getpgrp", unimplementedFunc), - /* 64 */ SyscallDesc("getpagesize", getpagesizeFunc), - /* 65 */ SyscallDesc("mremap", unimplementedFunc), - /* 66 */ SyscallDesc("vfork", unimplementedFunc), - /* 67 */ SyscallDesc("pre_F64_stat", unimplementedFunc), - /* 68 */ SyscallDesc("pre_F64_lstat", unimplementedFunc), - /* 69 */ SyscallDesc("sbrk", unimplementedFunc), - /* 70 */ SyscallDesc("sstk", unimplementedFunc), - /* 71 */ SyscallDesc("mmap", mmapFunc), - /* 72 */ SyscallDesc("ovadvise", unimplementedFunc), - /* 73 */ SyscallDesc("munmap", unimplementedFunc), - /* 74 */ SyscallDesc("mprotect", ignoreFunc), - /* 75 */ SyscallDesc("madvise", unimplementedFunc), - /* 76 */ SyscallDesc("old_vhangup", unimplementedFunc), - /* 77 */ SyscallDesc("kmodcall", unimplementedFunc), - /* 78 */ SyscallDesc("mincore", unimplementedFunc), - /* 79 */ SyscallDesc("getgroups", unimplementedFunc), - /* 80 */ SyscallDesc("setgroups", unimplementedFunc), - /* 81 */ SyscallDesc("old_getpgrp", unimplementedFunc), - /* 82 */ SyscallDesc("setpgrp", unimplementedFunc), - /* 83 */ SyscallDesc("setitimer", unimplementedFunc), - /* 84 */ SyscallDesc("old_wait", unimplementedFunc), - /* 85 */ SyscallDesc("table", tableFunc), - /* 86 */ SyscallDesc("getitimer", unimplementedFunc), - /* 87 */ SyscallDesc("gethostname", gethostnameFunc), - /* 88 */ SyscallDesc("sethostname", unimplementedFunc), - /* 89 */ SyscallDesc("getdtablesize", unimplementedFunc), - /* 90 */ SyscallDesc("dup2", unimplementedFunc), - /* 91 */ SyscallDesc("pre_F64_fstat", unimplementedFunc), - /* 92 */ SyscallDesc("fcntl", fcntlFunc), - /* 93 */ SyscallDesc("select", unimplementedFunc), - /* 94 */ SyscallDesc("poll", unimplementedFunc), - /* 95 */ SyscallDesc("fsync", unimplementedFunc), - /* 96 */ SyscallDesc("setpriority", unimplementedFunc), - /* 97 */ SyscallDesc("socket", unimplementedFunc), - /* 98 */ SyscallDesc("connect", unimplementedFunc), - /* 99 */ SyscallDesc("old_accept", unimplementedFunc), - /* 100 */ SyscallDesc("getpriority", unimplementedFunc), - /* 101 */ SyscallDesc("old_send", unimplementedFunc), - /* 102 */ SyscallDesc("old_recv", unimplementedFunc), - /* 103 */ SyscallDesc("sigreturn", sigreturnFunc, SyscallDesc::SuppressReturnValue), - /* 104 */ SyscallDesc("bind", unimplementedFunc), - /* 105 */ SyscallDesc("setsockopt", unimplementedFunc), - /* 106 */ SyscallDesc("listen", unimplementedFunc), - /* 107 */ SyscallDesc("plock", unimplementedFunc), - /* 108 */ SyscallDesc("old_sigvec", unimplementedFunc), - /* 109 */ SyscallDesc("old_sigblock", unimplementedFunc), - /* 110 */ SyscallDesc("old_sigsetmask", unimplementedFunc), - /* 111 */ SyscallDesc("sigsuspend", unimplementedFunc), - /* 112 */ SyscallDesc("sigstack", ignoreFunc), - /* 113 */ SyscallDesc("old_recvmsg", unimplementedFunc), - /* 114 */ SyscallDesc("old_sendmsg", unimplementedFunc), - /* 115 */ SyscallDesc("obsolete vtrace", unimplementedFunc), - /* 116 */ SyscallDesc("gettimeofday", gettimeofdayFunc), - /* 117 */ SyscallDesc("getrusage", getrusageFunc), - /* 118 */ SyscallDesc("getsockopt", unimplementedFunc), - /* 119 */ SyscallDesc("numa_syscalls", unimplementedFunc), - /* 120 */ SyscallDesc("readv", unimplementedFunc), - /* 121 */ SyscallDesc("writev", unimplementedFunc), - /* 122 */ SyscallDesc("settimeofday", unimplementedFunc), - /* 123 */ SyscallDesc("fchown", unimplementedFunc), - /* 124 */ SyscallDesc("fchmod", unimplementedFunc), - /* 125 */ SyscallDesc("old_recvfrom", unimplementedFunc), - /* 126 */ SyscallDesc("setreuid", unimplementedFunc), - /* 127 */ SyscallDesc("setregid", unimplementedFunc), - /* 128 */ SyscallDesc("rename", unimplementedFunc), - /* 129 */ SyscallDesc("truncate", unimplementedFunc), - /* 130 */ SyscallDesc("ftruncate", unimplementedFunc), - /* 131 */ SyscallDesc("flock", unimplementedFunc), - /* 132 */ SyscallDesc("setgid", unimplementedFunc), - /* 133 */ SyscallDesc("sendto", unimplementedFunc), - /* 134 */ SyscallDesc("shutdown", unimplementedFunc), - /* 135 */ SyscallDesc("socketpair", unimplementedFunc), - /* 136 */ SyscallDesc("mkdir", unimplementedFunc), - /* 137 */ SyscallDesc("rmdir", unimplementedFunc), - /* 138 */ SyscallDesc("utimes", unimplementedFunc), - /* 139 */ SyscallDesc("obsolete 4.2 sigreturn", unimplementedFunc), - /* 140 */ SyscallDesc("adjtime", unimplementedFunc), - /* 141 */ SyscallDesc("old_getpeername", unimplementedFunc), - /* 142 */ SyscallDesc("gethostid", unimplementedFunc), - /* 143 */ SyscallDesc("sethostid", unimplementedFunc), - /* 144 */ SyscallDesc("getrlimit", getrlimitFunc), - /* 145 */ SyscallDesc("setrlimit", unimplementedFunc), - /* 146 */ SyscallDesc("old_killpg", unimplementedFunc), - /* 147 */ SyscallDesc("setsid", unimplementedFunc), - /* 148 */ SyscallDesc("quotactl", unimplementedFunc), - /* 149 */ SyscallDesc("oldquota", unimplementedFunc), - /* 150 */ SyscallDesc("old_getsockname", unimplementedFunc), - /* 151 */ SyscallDesc("pread", unimplementedFunc), - /* 152 */ SyscallDesc("pwrite", unimplementedFunc), - /* 153 */ SyscallDesc("pid_block", unimplementedFunc), - /* 154 */ SyscallDesc("pid_unblock", unimplementedFunc), - /* 155 */ SyscallDesc("signal_urti", unimplementedFunc), - /* 156 */ SyscallDesc("sigaction", ignoreFunc), - /* 157 */ SyscallDesc("sigwaitprim", unimplementedFunc), - /* 158 */ SyscallDesc("nfssvc", unimplementedFunc), - /* 159 */ SyscallDesc("getdirentries", getdirentriesFunc), - /* 160 */ SyscallDesc("pre_F64_statfs", unimplementedFunc), - /* 161 */ SyscallDesc("pre_F64_fstatfs", unimplementedFunc), - /* 162 */ SyscallDesc("unknown #162", unimplementedFunc), - /* 163 */ SyscallDesc("async_daemon", unimplementedFunc), - /* 164 */ SyscallDesc("getfh", unimplementedFunc), - /* 165 */ SyscallDesc("getdomainname", unimplementedFunc), - /* 166 */ SyscallDesc("setdomainname", unimplementedFunc), - /* 167 */ SyscallDesc("unknown #167", unimplementedFunc), - /* 168 */ SyscallDesc("unknown #168", unimplementedFunc), - /* 169 */ SyscallDesc("exportfs", unimplementedFunc), - /* 170 */ SyscallDesc("unknown #170", unimplementedFunc), - /* 171 */ SyscallDesc("unknown #171", unimplementedFunc), - /* 172 */ SyscallDesc("unknown #172", unimplementedFunc), - /* 173 */ SyscallDesc("unknown #173", unimplementedFunc), - /* 174 */ SyscallDesc("unknown #174", unimplementedFunc), - /* 175 */ SyscallDesc("unknown #175", unimplementedFunc), - /* 176 */ SyscallDesc("unknown #176", unimplementedFunc), - /* 177 */ SyscallDesc("unknown #177", unimplementedFunc), - /* 178 */ SyscallDesc("unknown #178", unimplementedFunc), - /* 179 */ SyscallDesc("unknown #179", unimplementedFunc), - /* 180 */ SyscallDesc("unknown #180", unimplementedFunc), - /* 181 */ SyscallDesc("alt_plock", unimplementedFunc), - /* 182 */ SyscallDesc("unknown #182", unimplementedFunc), - /* 183 */ SyscallDesc("unknown #183", unimplementedFunc), - /* 184 */ SyscallDesc("getmnt", unimplementedFunc), - /* 185 */ SyscallDesc("unknown #185", unimplementedFunc), - /* 186 */ SyscallDesc("unknown #186", unimplementedFunc), - /* 187 */ SyscallDesc("alt_sigpending", unimplementedFunc), - /* 188 */ SyscallDesc("alt_setsid", unimplementedFunc), - /* 189 */ SyscallDesc("unknown #189", unimplementedFunc), - /* 190 */ SyscallDesc("unknown #190", unimplementedFunc), - /* 191 */ SyscallDesc("unknown #191", unimplementedFunc), - /* 192 */ SyscallDesc("unknown #192", unimplementedFunc), - /* 193 */ SyscallDesc("unknown #193", unimplementedFunc), - /* 194 */ SyscallDesc("unknown #194", unimplementedFunc), - /* 195 */ SyscallDesc("unknown #195", unimplementedFunc), - /* 196 */ SyscallDesc("unknown #196", unimplementedFunc), - /* 197 */ SyscallDesc("unknown #197", unimplementedFunc), - /* 198 */ SyscallDesc("unknown #198", unimplementedFunc), - /* 199 */ SyscallDesc("swapon", unimplementedFunc), - /* 200 */ SyscallDesc("msgctl", unimplementedFunc), - /* 201 */ SyscallDesc("msgget", unimplementedFunc), - /* 202 */ SyscallDesc("msgrcv", unimplementedFunc), - /* 203 */ SyscallDesc("msgsnd", unimplementedFunc), - /* 204 */ SyscallDesc("semctl", unimplementedFunc), - /* 205 */ SyscallDesc("semget", unimplementedFunc), - /* 206 */ SyscallDesc("semop", unimplementedFunc), - /* 207 */ SyscallDesc("uname", unameFunc), - /* 208 */ SyscallDesc("lchown", unimplementedFunc), - /* 209 */ SyscallDesc("shmat", unimplementedFunc), - /* 210 */ SyscallDesc("shmctl", unimplementedFunc), - /* 211 */ SyscallDesc("shmdt", unimplementedFunc), - /* 212 */ SyscallDesc("shmget", unimplementedFunc), - /* 213 */ SyscallDesc("mvalid", unimplementedFunc), - /* 214 */ SyscallDesc("getaddressconf", unimplementedFunc), - /* 215 */ SyscallDesc("msleep", unimplementedFunc), - /* 216 */ SyscallDesc("mwakeup", unimplementedFunc), - /* 217 */ SyscallDesc("msync", unimplementedFunc), - /* 218 */ SyscallDesc("signal", unimplementedFunc), - /* 219 */ SyscallDesc("utc_gettime", unimplementedFunc), - /* 220 */ SyscallDesc("utc_adjtime", unimplementedFunc), - /* 221 */ SyscallDesc("unknown #221", unimplementedFunc), - /* 222 */ SyscallDesc("security", unimplementedFunc), - /* 223 */ SyscallDesc("kloadcall", unimplementedFunc), - /* 224 */ SyscallDesc("stat", statFunc), - /* 225 */ SyscallDesc("lstat", lstatFunc), - /* 226 */ SyscallDesc("fstat", fstatFunc), - /* 227 */ SyscallDesc("statfs", unimplementedFunc), - /* 228 */ SyscallDesc("fstatfs", unimplementedFunc), - /* 229 */ SyscallDesc("getfsstat", unimplementedFunc), - /* 230 */ SyscallDesc("gettimeofday64", unimplementedFunc), - /* 231 */ SyscallDesc("settimeofday64", unimplementedFunc), - /* 232 */ SyscallDesc("unknown #232", unimplementedFunc), - /* 233 */ SyscallDesc("getpgid", unimplementedFunc), - /* 234 */ SyscallDesc("getsid", unimplementedFunc), - /* 235 */ SyscallDesc("sigaltstack", ignoreFunc), - /* 236 */ SyscallDesc("waitid", unimplementedFunc), - /* 237 */ SyscallDesc("priocntlset", unimplementedFunc), - /* 238 */ SyscallDesc("sigsendset", unimplementedFunc), - /* 239 */ SyscallDesc("set_speculative", unimplementedFunc), - /* 240 */ SyscallDesc("msfs_syscall", unimplementedFunc), - /* 241 */ SyscallDesc("sysinfo", unimplementedFunc), - /* 242 */ SyscallDesc("uadmin", unimplementedFunc), - /* 243 */ SyscallDesc("fuser", unimplementedFunc), - /* 244 */ SyscallDesc("proplist_syscall", unimplementedFunc), - /* 245 */ SyscallDesc("ntp_adjtime", unimplementedFunc), - /* 246 */ SyscallDesc("ntp_gettime", unimplementedFunc), - /* 247 */ SyscallDesc("pathconf", unimplementedFunc), - /* 248 */ SyscallDesc("fpathconf", unimplementedFunc), - /* 249 */ SyscallDesc("sync2", unimplementedFunc), - /* 250 */ SyscallDesc("uswitch", unimplementedFunc), - /* 251 */ SyscallDesc("usleep_thread", unimplementedFunc), - /* 252 */ SyscallDesc("audcntl", unimplementedFunc), - /* 253 */ SyscallDesc("audgen", unimplementedFunc), - /* 254 */ SyscallDesc("sysfs", unimplementedFunc), - /* 255 */ SyscallDesc("subsys_info", unimplementedFunc), - /* 256 */ SyscallDesc("getsysinfo", getsysinfoFunc), - /* 257 */ SyscallDesc("setsysinfo", unimplementedFunc), - /* 258 */ SyscallDesc("afs_syscall", unimplementedFunc), - /* 259 */ SyscallDesc("swapctl", unimplementedFunc), - /* 260 */ SyscallDesc("memcntl", unimplementedFunc), - /* 261 */ SyscallDesc("fdatasync", unimplementedFunc), - /* 262 */ SyscallDesc("oflock", unimplementedFunc), - /* 263 */ SyscallDesc("F64_readv", unimplementedFunc), - /* 264 */ SyscallDesc("F64_writev", unimplementedFunc), - /* 265 */ SyscallDesc("cdslxlate", unimplementedFunc), - /* 266 */ SyscallDesc("sendfile", unimplementedFunc), -}; - -const int Num_Syscall_Descs = sizeof(syscallDescs) / sizeof(SyscallDesc); - -const int Max_Syscall_Desc = Num_Syscall_Descs - 1; +static const int Num_Syscall_Descs; +static const int Max_Syscall_Desc; // // Mach syscalls -- identified by negated syscall numbers // // Create a stack region for a thread. +static int stack_createFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - TypedBufferArg<OSF::vm_stack> argp(getArg(xc, 0)); + TypedBufferArg<Tru64::vm_stack> argp(xc->getSyscallArg(0)); argp.copyIn(xc->mem); @@ -1212,6 +777,7 @@ stack_createFunc(SyscallDesc *desc, int callnum, Process *process, return 0; } +static const int NXM_LIB_VERSION = 301003; // @@ -1219,12 +785,13 @@ const int NXM_LIB_VERSION = 301003; // schedulers by creating a shared-memory region. The shared memory // region has several structs, some global, some per-RAD, some per-VP. // +static int nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - TypedBufferArg<OSF::nxm_task_attr> attrp(getArg(xc, 0)); - TypedBufferArg<Addr> configptr_ptr(getArg(xc, 1)); + TypedBufferArg<Tru64::nxm_task_attr> attrp(xc->getSyscallArg(0)); + TypedBufferArg<Addr> configptr_ptr(xc->getSyscallArg(1)); attrp.copyIn(xc->mem); @@ -1235,9 +802,9 @@ nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process, abort(); } - if (attrp->flags != OSF::NXM_TASK_INIT_VP) { + if (attrp->flags != Tru64::NXM_TASK_INIT_VP) { cerr << "nxm_task_init: bad flag value " << attrp->flags - << " (expected " << OSF::NXM_TASK_INIT_VP << ")" << endl; + << " (expected " << Tru64::NXM_TASK_INIT_VP << ")" << endl; abort(); } @@ -1245,21 +812,21 @@ nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process, Addr cur_addr = base_addr; // next addresses to use // first comes the config_info struct Addr config_addr = cur_addr; - cur_addr += sizeof(OSF::nxm_config_info); + cur_addr += sizeof(Tru64::nxm_config_info); // next comes the per-cpu state vector Addr slot_state_addr = cur_addr; - int slot_state_size = process->numCpus() * sizeof(OSF::nxm_slot_state_t); + int slot_state_size = process->numCpus() * sizeof(Tru64::nxm_slot_state_t); cur_addr += slot_state_size; // now the per-RAD state struct (we only support one RAD) cur_addr = 0x14000; // bump up addr for alignment Addr rad_state_addr = cur_addr; int rad_state_size = - (sizeof(OSF::nxm_shared) - + (process->numCpus()-1) * sizeof(OSF::nxm_sched_state)); + (sizeof(Tru64::nxm_shared) + + (process->numCpus()-1) * sizeof(Tru64::nxm_sched_state)); cur_addr += rad_state_size; // now initialize a config_info struct and copy it out to user space - TypedBufferArg<OSF::nxm_config_info> config(config_addr); + TypedBufferArg<Tru64::nxm_config_info> config(config_addr); config->nxm_nslots_per_rad = process->numCpus(); config->nxm_nrads = 1; // only one RAD in our system! @@ -1269,11 +836,11 @@ nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process, config.copyOut(xc->mem); // initialize the slot_state array and copy it out - TypedBufferArg<OSF::nxm_slot_state_t> slot_state(slot_state_addr, + TypedBufferArg<Tru64::nxm_slot_state_t> slot_state(slot_state_addr, slot_state_size); for (int i = 0; i < process->numCpus(); ++i) { // CPU 0 is bound to the calling process; all others are available - slot_state[i] = (i == 0) ? OSF::NXM_SLOT_BOUND : OSF::NXM_SLOT_AVAIL; + slot_state[i] = (i == 0) ? Tru64::NXM_SLOT_BOUND : Tru64::NXM_SLOT_AVAIL; } slot_state.copyOut(xc->mem); @@ -1281,14 +848,14 @@ nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process, // same for the per-RAD "shared" struct. Note that we need to // allocate extra bytes for the per-VP array which is embedded at // the end. - TypedBufferArg<OSF::nxm_shared> rad_state(rad_state_addr, + TypedBufferArg<Tru64::nxm_shared> rad_state(rad_state_addr, rad_state_size); rad_state->nxm_callback = attrp->nxm_callback; rad_state->nxm_version = attrp->nxm_version; rad_state->nxm_uniq_offset = attrp->nxm_uniq_offset; for (int i = 0; i < process->numCpus(); ++i) { - OSF::nxm_sched_state *ssp = &rad_state->nxm_ss[i]; + Tru64::nxm_sched_state *ssp = &rad_state->nxm_ss[i]; ssp->nxm_u.sigmask = 0; ssp->nxm_u.sig = 0; ssp->nxm_u.flags = 0; @@ -1324,7 +891,7 @@ nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process, static void init_exec_context(ExecContext *ec, - OSF::nxm_thread_attr *attrp, uint64_t uniq_val) + Tru64::nxm_thread_attr *attrp, uint64_t uniq_val) { memset(&ec->regs, 0, sizeof(ec->regs)); @@ -1339,13 +906,14 @@ init_exec_context(ExecContext *ec, ec->setStatus(ExecContext::Active); } +static int nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - TypedBufferArg<OSF::nxm_thread_attr> attrp(getArg(xc, 0)); - TypedBufferArg<uint64_t> kidp(getArg(xc, 1)); - int thread_index = getArg(xc, 2); + TypedBufferArg<Tru64::nxm_thread_attr> attrp(xc->getSyscallArg(0)); + TypedBufferArg<uint64_t> kidp(xc->getSyscallArg(1)); + int thread_index = xc->getSyscallArg(2); // get attribute args attrp.copyIn(xc->mem); @@ -1368,16 +936,16 @@ nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process, // We don't have that luxury, so we just copy it in and then // back out again. int rad_state_size = - (sizeof(OSF::nxm_shared) + - (process->numCpus()-1) * sizeof(OSF::nxm_sched_state)); + (sizeof(Tru64::nxm_shared) + + (process->numCpus()-1) * sizeof(Tru64::nxm_sched_state)); - TypedBufferArg<OSF::nxm_shared> rad_state(0x14000, + TypedBufferArg<Tru64::nxm_shared> rad_state(0x14000, rad_state_size); rad_state.copyIn(xc->mem); uint64_t uniq_val = attrp->pthid - rad_state->nxm_uniq_offset; - if (attrp->type == OSF::NXM_TYPE_MANAGER) { + if (attrp->type == Tru64::NXM_TYPE_MANAGER) { // DEC pthreads seems to always create one of these (in // addition to N application threads), but we don't use it, // so don't bother creating it. @@ -1387,34 +955,34 @@ nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process, kidp.copyOut(xc->mem); return 0; - } else if (attrp->type == OSF::NXM_TYPE_VP) { + } else if (attrp->type == Tru64::NXM_TYPE_VP) { // A real "virtual processor" kernel thread. Need to fork // this thread on another CPU. - OSF::nxm_sched_state *ssp = &rad_state->nxm_ss[thread_index]; + Tru64::nxm_sched_state *ssp = &rad_state->nxm_ss[thread_index]; if (ssp->nxm_u.nxm_active != 0) - return OSF::KERN_NOT_RECEIVER; + return Tru64::KERN_NOT_RECEIVER; ssp->nxm_u.pth_id = attrp->pthid; ssp->nxm_u.nxm_active = uniq_val | 1; rad_state.copyOut(xc->mem); - Addr slot_state_addr = 0x12000 + sizeof(OSF::nxm_config_info); - int slot_state_size = process->numCpus() * sizeof(OSF::nxm_slot_state_t); + Addr slot_state_addr = 0x12000 + sizeof(Tru64::nxm_config_info); + int slot_state_size = process->numCpus() * sizeof(Tru64::nxm_slot_state_t); - TypedBufferArg<OSF::nxm_slot_state_t> slot_state(slot_state_addr, + TypedBufferArg<Tru64::nxm_slot_state_t> slot_state(slot_state_addr, slot_state_size); slot_state.copyIn(xc->mem); - if (slot_state[thread_index] != OSF::NXM_SLOT_AVAIL) { + if (slot_state[thread_index] != Tru64::NXM_SLOT_AVAIL) { cerr << "nxm_thread_createFunc: requested VP slot " << thread_index << " not available!" << endl; fatal(""); } - slot_state[thread_index] = OSF::NXM_SLOT_BOUND; + slot_state[thread_index] = Tru64::NXM_SLOT_BOUND; slot_state.copyOut(xc->mem); @@ -1449,6 +1017,7 @@ nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process, } +static int nxm_idleFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) @@ -1456,15 +1025,16 @@ nxm_idleFunc(SyscallDesc *desc, int callnum, Process *process, return 0; } +static int nxm_thread_blockFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - uint64_t tid = getArg(xc, 0); - uint64_t secs = getArg(xc, 1); - uint64_t flags = getArg(xc, 2); - uint64_t action = getArg(xc, 3); - uint64_t usecs = getArg(xc, 4); + uint64_t tid = xc->getSyscallArg(0); + uint64_t secs = xc->getSyscallArg(1); + uint64_t flags = xc->getSyscallArg(2); + uint64_t action = xc->getSyscallArg(3); + uint64_t usecs = xc->getSyscallArg(4); cout << xc->cpu->name() << ": nxm_thread_block " << tid << " " << secs << " " << flags << " " << action << " " << usecs << endl; @@ -1473,15 +1043,16 @@ nxm_thread_blockFunc(SyscallDesc *desc, int callnum, Process *process, } +static int nxm_blockFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - Addr uaddr = getArg(xc, 0); - uint64_t val = getArg(xc, 1); - uint64_t secs = getArg(xc, 2); - uint64_t usecs = getArg(xc, 3); - uint64_t flags = getArg(xc, 4); + Addr uaddr = xc->getSyscallArg(0); + uint64_t val = xc->getSyscallArg(1); + uint64_t secs = xc->getSyscallArg(2); + uint64_t usecs = xc->getSyscallArg(3); + uint64_t flags = xc->getSyscallArg(4); BaseCPU *cpu = xc->cpu; @@ -1493,11 +1064,12 @@ nxm_blockFunc(SyscallDesc *desc, int callnum, Process *process, } +static int nxm_unblockFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - Addr uaddr = getArg(xc, 0); + Addr uaddr = xc->getSyscallArg(0); cout << xc->cpu->name() << ": nxm_unblock " << hex << uaddr << dec << endl; @@ -1506,6 +1078,7 @@ nxm_unblockFunc(SyscallDesc *desc, int callnum, Process *process, } +static int swtch_priFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) @@ -1588,11 +1161,12 @@ m5_unlock_mutex(Addr uaddr, Process *process, ExecContext *xc) } +static int m5_mutex_lockFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - Addr uaddr = getArg(xc, 0); + Addr uaddr = xc->getSyscallArg(0); m5_lock_mutex(uaddr, process, xc); @@ -1603,11 +1177,12 @@ m5_mutex_lockFunc(SyscallDesc *desc, int callnum, Process *process, } +static int m5_mutex_trylockFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - Addr uaddr = getArg(xc, 0); + Addr uaddr = xc->getSyscallArg(0); TypedBufferArg<uint64_t> lockp(uaddr); lockp.copyIn(xc->mem); @@ -1623,11 +1198,12 @@ m5_mutex_trylockFunc(SyscallDesc *desc, int callnum, Process *process, } +static int m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - Addr uaddr = getArg(xc, 0); + Addr uaddr = xc->getSyscallArg(0); m5_unlock_mutex(uaddr, process, xc); @@ -1635,11 +1211,12 @@ m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, Process *process, } +static int m5_cond_signalFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - Addr cond_addr = getArg(xc, 0); + Addr cond_addr = xc->getSyscallArg(0); // Wqake up one process waiting on the condition variable. activate_waiting_context(cond_addr, process); @@ -1648,11 +1225,12 @@ m5_cond_signalFunc(SyscallDesc *desc, int callnum, Process *process, } +static int m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - Addr cond_addr = getArg(xc, 0); + Addr cond_addr = xc->getSyscallArg(0); // Wake up all processes waiting on the condition variable. activate_waiting_context(cond_addr, process, true); @@ -1661,12 +1239,13 @@ m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, Process *process, } +static int m5_cond_waitFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - Addr cond_addr = getArg(xc, 0); - Addr lock_addr = getArg(xc, 1); + Addr cond_addr = xc->getSyscallArg(0); + Addr lock_addr = xc->getSyscallArg(1); TypedBufferArg<uint64_t> condp(cond_addr); TypedBufferArg<uint64_t> lockp(lock_addr); @@ -1683,6 +1262,7 @@ m5_cond_waitFunc(SyscallDesc *desc, int callnum, Process *process, } +static int m5_thread_exitFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) @@ -1694,7 +1274,374 @@ m5_thread_exitFunc(SyscallDesc *desc, int callnum, Process *process, } -SyscallDesc machSyscallDescs[] = { +static SyscallDesc machSyscallDescs[]; + +static const int Num_Mach_Syscall_Descs; +static const int Max_Mach_Syscall_Desc; + +// Since negated values are used to identify Mach syscalls, the +// minimum (signed) valid syscall number is the negated max Mach +// syscall number. +static const int Min_Syscall_Desc; + +// +// helper function for invoking syscalls +// +static +void +doSyscall(int callnum, Process *process, ExecContext *xc) +{ + if (callnum < Min_Syscall_Desc || callnum > Max_Syscall_Desc) { + cerr << "Syscall " << callnum << " out of range" << endl; + abort(); + } + + SyscallDesc *desc = + (callnum < 0) ? &machSyscallDescs[-callnum] : &syscallDescs[callnum]; + + desc->doSyscall(callnum, process, xc); +} + +// +// Indirect syscall invocation (call #0) +// +static +int +indirectSyscallFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + int new_callnum = xc->getSyscallArg(0); + + for (int i = 0; i < 5; ++i) + xc->setSyscallArg(i, xc->getSyscallArg(i+1)); + + doSyscall(new_callnum, process, xc); + + return 0; +} + + +}; // class Tru64 + + +// open(2) flags translation table +OpenFlagTransTable Tru64::openFlagTable[] = { + /* target flag */ /* host flag */ +#ifdef _MSC_VER + { Tru64::TGT_O_RDONLY, _O_RDONLY }, + { Tru64::TGT_O_WRONLY, _O_WRONLY }, + { Tru64::TGT_O_RDWR, _O_RDWR }, + { Tru64::TGT_O_APPEND, _O_APPEND }, + { Tru64::TGT_O_CREAT, _O_CREAT }, + { Tru64::TGT_O_TRUNC, _O_TRUNC }, + { Tru64::TGT_O_EXCL, _O_EXCL }, +#ifdef _O_NONBLOCK + { Tru64::TGT_O_NONBLOCK, _O_NONBLOCK }, +#endif +#ifdef _O_NOCTTY + { Tru64::TGT_O_NOCTTY, _O_NOCTTY }, +#endif +#ifdef _O_SYNC + { Tru64::TGT_O_SYNC, _O_SYNC }, +#endif +#else /* !_MSC_VER */ + { Tru64::TGT_O_RDONLY, O_RDONLY }, + { Tru64::TGT_O_WRONLY, O_WRONLY }, + { Tru64::TGT_O_RDWR, O_RDWR }, + { Tru64::TGT_O_APPEND, O_APPEND }, + { Tru64::TGT_O_CREAT, O_CREAT }, + { Tru64::TGT_O_TRUNC, O_TRUNC }, + { Tru64::TGT_O_EXCL, O_EXCL }, + { Tru64::TGT_O_NONBLOCK, O_NONBLOCK }, + { Tru64::TGT_O_NOCTTY, O_NOCTTY }, +#ifdef O_SYNC + { Tru64::TGT_O_SYNC, O_SYNC }, +#endif +#endif /* _MSC_VER */ +}; + +const int Tru64::NUM_OPEN_FLAGS = (sizeof(Tru64::openFlagTable)/sizeof(Tru64::openFlagTable[0])); + +const char *Tru64::hostname = "m5.eecs.umich.edu"; + +SyscallDesc Tru64::syscallDescs[] = { + /* 0 */ SyscallDesc("syscall (#0)", indirectSyscallFunc, + SyscallDesc::SuppressReturnValue), + /* 1 */ SyscallDesc("exit", exitFunc), + /* 2 */ SyscallDesc("fork", unimplementedFunc), + /* 3 */ SyscallDesc("read", readFunc), + /* 4 */ SyscallDesc("write", writeFunc), + /* 5 */ SyscallDesc("old_open", unimplementedFunc), + /* 6 */ SyscallDesc("close", closeFunc), + /* 7 */ SyscallDesc("wait4", unimplementedFunc), + /* 8 */ SyscallDesc("old_creat", unimplementedFunc), + /* 9 */ SyscallDesc("link", unimplementedFunc), + /* 10 */ SyscallDesc("unlink", unimplementedFunc), + /* 11 */ SyscallDesc("execv", unimplementedFunc), + /* 12 */ SyscallDesc("chdir", unimplementedFunc), + /* 13 */ SyscallDesc("fchdir", unimplementedFunc), + /* 14 */ SyscallDesc("mknod", unimplementedFunc), + /* 15 */ SyscallDesc("chmod", unimplementedFunc), + /* 16 */ SyscallDesc("chown", unimplementedFunc), + /* 17 */ SyscallDesc("obreak", obreakFunc), + /* 18 */ SyscallDesc("pre_F64_getfsstat", unimplementedFunc), + /* 19 */ SyscallDesc("lseek", lseekFunc), + /* 20 */ SyscallDesc("getpid", getpidFunc), + /* 21 */ SyscallDesc("mount", unimplementedFunc), + /* 22 */ SyscallDesc("unmount", unimplementedFunc), + /* 23 */ SyscallDesc("setuid", setuidFunc), + /* 24 */ SyscallDesc("getuid", getuidFunc), + /* 25 */ SyscallDesc("exec_with_loader", unimplementedFunc), + /* 26 */ SyscallDesc("ptrace", unimplementedFunc), + /* 27 */ SyscallDesc("recvmsg", unimplementedFunc), + /* 28 */ SyscallDesc("sendmsg", unimplementedFunc), + /* 29 */ SyscallDesc("recvfrom", unimplementedFunc), + /* 30 */ SyscallDesc("accept", unimplementedFunc), + /* 31 */ SyscallDesc("getpeername", unimplementedFunc), + /* 32 */ SyscallDesc("getsockname", unimplementedFunc), + /* 33 */ SyscallDesc("access", unimplementedFunc), + /* 34 */ SyscallDesc("chflags", unimplementedFunc), + /* 35 */ SyscallDesc("fchflags", unimplementedFunc), + /* 36 */ SyscallDesc("sync", unimplementedFunc), + /* 37 */ SyscallDesc("kill", unimplementedFunc), + /* 38 */ SyscallDesc("old_stat", unimplementedFunc), + /* 39 */ SyscallDesc("setpgid", unimplementedFunc), + /* 40 */ SyscallDesc("old_lstat", unimplementedFunc), + /* 41 */ SyscallDesc("dup", unimplementedFunc), + /* 42 */ SyscallDesc("pipe", unimplementedFunc), + /* 43 */ SyscallDesc("set_program_attributes", unimplementedFunc), + /* 44 */ SyscallDesc("profil", unimplementedFunc), + /* 45 */ SyscallDesc("open", openFunc<Tru64>), + /* 46 */ SyscallDesc("obsolete osigaction", unimplementedFunc), + /* 47 */ SyscallDesc("getgid", getgidFunc), + /* 48 */ SyscallDesc("sigprocmask", ignoreFunc), + /* 49 */ SyscallDesc("getlogin", unimplementedFunc), + /* 50 */ SyscallDesc("setlogin", unimplementedFunc), + /* 51 */ SyscallDesc("acct", unimplementedFunc), + /* 52 */ SyscallDesc("sigpending", unimplementedFunc), + /* 53 */ SyscallDesc("classcntl", unimplementedFunc), + /* 54 */ SyscallDesc("ioctl", ioctlFunc<Tru64>), + /* 55 */ SyscallDesc("reboot", unimplementedFunc), + /* 56 */ SyscallDesc("revoke", unimplementedFunc), + /* 57 */ SyscallDesc("symlink", unimplementedFunc), + /* 58 */ SyscallDesc("readlink", unimplementedFunc), + /* 59 */ SyscallDesc("execve", unimplementedFunc), + /* 60 */ SyscallDesc("umask", unimplementedFunc), + /* 61 */ SyscallDesc("chroot", unimplementedFunc), + /* 62 */ SyscallDesc("old_fstat", unimplementedFunc), + /* 63 */ SyscallDesc("getpgrp", unimplementedFunc), + /* 64 */ SyscallDesc("getpagesize", getpagesizeFunc), + /* 65 */ SyscallDesc("mremap", unimplementedFunc), + /* 66 */ SyscallDesc("vfork", unimplementedFunc), + /* 67 */ SyscallDesc("pre_F64_stat", unimplementedFunc), + /* 68 */ SyscallDesc("pre_F64_lstat", unimplementedFunc), + /* 69 */ SyscallDesc("sbrk", unimplementedFunc), + /* 70 */ SyscallDesc("sstk", unimplementedFunc), + /* 71 */ SyscallDesc("mmap", mmapFunc<Tru64>), + /* 72 */ SyscallDesc("ovadvise", unimplementedFunc), + /* 73 */ SyscallDesc("munmap", munmapFunc), + /* 74 */ SyscallDesc("mprotect", ignoreFunc), + /* 75 */ SyscallDesc("madvise", unimplementedFunc), + /* 76 */ SyscallDesc("old_vhangup", unimplementedFunc), + /* 77 */ SyscallDesc("kmodcall", unimplementedFunc), + /* 78 */ SyscallDesc("mincore", unimplementedFunc), + /* 79 */ SyscallDesc("getgroups", unimplementedFunc), + /* 80 */ SyscallDesc("setgroups", unimplementedFunc), + /* 81 */ SyscallDesc("old_getpgrp", unimplementedFunc), + /* 82 */ SyscallDesc("setpgrp", unimplementedFunc), + /* 83 */ SyscallDesc("setitimer", unimplementedFunc), + /* 84 */ SyscallDesc("old_wait", unimplementedFunc), + /* 85 */ SyscallDesc("table", tableFunc), + /* 86 */ SyscallDesc("getitimer", unimplementedFunc), + /* 87 */ SyscallDesc("gethostname", gethostnameFunc), + /* 88 */ SyscallDesc("sethostname", unimplementedFunc), + /* 89 */ SyscallDesc("getdtablesize", unimplementedFunc), + /* 90 */ SyscallDesc("dup2", unimplementedFunc), + /* 91 */ SyscallDesc("pre_F64_fstat", unimplementedFunc), + /* 92 */ SyscallDesc("fcntl", fcntlFunc), + /* 93 */ SyscallDesc("select", unimplementedFunc), + /* 94 */ SyscallDesc("poll", unimplementedFunc), + /* 95 */ SyscallDesc("fsync", unimplementedFunc), + /* 96 */ SyscallDesc("setpriority", unimplementedFunc), + /* 97 */ SyscallDesc("socket", unimplementedFunc), + /* 98 */ SyscallDesc("connect", unimplementedFunc), + /* 99 */ SyscallDesc("old_accept", unimplementedFunc), + /* 100 */ SyscallDesc("getpriority", unimplementedFunc), + /* 101 */ SyscallDesc("old_send", unimplementedFunc), + /* 102 */ SyscallDesc("old_recv", unimplementedFunc), + /* 103 */ SyscallDesc("sigreturn", sigreturnFunc, + SyscallDesc::SuppressReturnValue), + /* 104 */ SyscallDesc("bind", unimplementedFunc), + /* 105 */ SyscallDesc("setsockopt", unimplementedFunc), + /* 106 */ SyscallDesc("listen", unimplementedFunc), + /* 107 */ SyscallDesc("plock", unimplementedFunc), + /* 108 */ SyscallDesc("old_sigvec", unimplementedFunc), + /* 109 */ SyscallDesc("old_sigblock", unimplementedFunc), + /* 110 */ SyscallDesc("old_sigsetmask", unimplementedFunc), + /* 111 */ SyscallDesc("sigsuspend", unimplementedFunc), + /* 112 */ SyscallDesc("sigstack", ignoreFunc), + /* 113 */ SyscallDesc("old_recvmsg", unimplementedFunc), + /* 114 */ SyscallDesc("old_sendmsg", unimplementedFunc), + /* 115 */ SyscallDesc("obsolete vtrace", unimplementedFunc), + /* 116 */ SyscallDesc("gettimeofday", gettimeofdayFunc<Tru64>), + /* 117 */ SyscallDesc("getrusage", getrusageFunc<Tru64>), + /* 118 */ SyscallDesc("getsockopt", unimplementedFunc), + /* 119 */ SyscallDesc("numa_syscalls", unimplementedFunc), + /* 120 */ SyscallDesc("readv", unimplementedFunc), + /* 121 */ SyscallDesc("writev", unimplementedFunc), + /* 122 */ SyscallDesc("settimeofday", unimplementedFunc), + /* 123 */ SyscallDesc("fchown", unimplementedFunc), + /* 124 */ SyscallDesc("fchmod", unimplementedFunc), + /* 125 */ SyscallDesc("old_recvfrom", unimplementedFunc), + /* 126 */ SyscallDesc("setreuid", unimplementedFunc), + /* 127 */ SyscallDesc("setregid", unimplementedFunc), + /* 128 */ SyscallDesc("rename", unimplementedFunc), + /* 129 */ SyscallDesc("truncate", unimplementedFunc), + /* 130 */ SyscallDesc("ftruncate", unimplementedFunc), + /* 131 */ SyscallDesc("flock", unimplementedFunc), + /* 132 */ SyscallDesc("setgid", unimplementedFunc), + /* 133 */ SyscallDesc("sendto", unimplementedFunc), + /* 134 */ SyscallDesc("shutdown", unimplementedFunc), + /* 135 */ SyscallDesc("socketpair", unimplementedFunc), + /* 136 */ SyscallDesc("mkdir", unimplementedFunc), + /* 137 */ SyscallDesc("rmdir", unimplementedFunc), + /* 138 */ SyscallDesc("utimes", unimplementedFunc), + /* 139 */ SyscallDesc("obsolete 4.2 sigreturn", unimplementedFunc), + /* 140 */ SyscallDesc("adjtime", unimplementedFunc), + /* 141 */ SyscallDesc("old_getpeername", unimplementedFunc), + /* 142 */ SyscallDesc("gethostid", unimplementedFunc), + /* 143 */ SyscallDesc("sethostid", unimplementedFunc), + /* 144 */ SyscallDesc("getrlimit", getrlimitFunc<Tru64>), + /* 145 */ SyscallDesc("setrlimit", unimplementedFunc), + /* 146 */ SyscallDesc("old_killpg", unimplementedFunc), + /* 147 */ SyscallDesc("setsid", unimplementedFunc), + /* 148 */ SyscallDesc("quotactl", unimplementedFunc), + /* 149 */ SyscallDesc("oldquota", unimplementedFunc), + /* 150 */ SyscallDesc("old_getsockname", unimplementedFunc), + /* 151 */ SyscallDesc("pread", unimplementedFunc), + /* 152 */ SyscallDesc("pwrite", unimplementedFunc), + /* 153 */ SyscallDesc("pid_block", unimplementedFunc), + /* 154 */ SyscallDesc("pid_unblock", unimplementedFunc), + /* 155 */ SyscallDesc("signal_urti", unimplementedFunc), + /* 156 */ SyscallDesc("sigaction", ignoreFunc), + /* 157 */ SyscallDesc("sigwaitprim", unimplementedFunc), + /* 158 */ SyscallDesc("nfssvc", unimplementedFunc), + /* 159 */ SyscallDesc("getdirentries", getdirentriesFunc), + /* 160 */ SyscallDesc("pre_F64_statfs", unimplementedFunc), + /* 161 */ SyscallDesc("pre_F64_fstatfs", unimplementedFunc), + /* 162 */ SyscallDesc("unknown #162", unimplementedFunc), + /* 163 */ SyscallDesc("async_daemon", unimplementedFunc), + /* 164 */ SyscallDesc("getfh", unimplementedFunc), + /* 165 */ SyscallDesc("getdomainname", unimplementedFunc), + /* 166 */ SyscallDesc("setdomainname", unimplementedFunc), + /* 167 */ SyscallDesc("unknown #167", unimplementedFunc), + /* 168 */ SyscallDesc("unknown #168", unimplementedFunc), + /* 169 */ SyscallDesc("exportfs", unimplementedFunc), + /* 170 */ SyscallDesc("unknown #170", unimplementedFunc), + /* 171 */ SyscallDesc("unknown #171", unimplementedFunc), + /* 172 */ SyscallDesc("unknown #172", unimplementedFunc), + /* 173 */ SyscallDesc("unknown #173", unimplementedFunc), + /* 174 */ SyscallDesc("unknown #174", unimplementedFunc), + /* 175 */ SyscallDesc("unknown #175", unimplementedFunc), + /* 176 */ SyscallDesc("unknown #176", unimplementedFunc), + /* 177 */ SyscallDesc("unknown #177", unimplementedFunc), + /* 178 */ SyscallDesc("unknown #178", unimplementedFunc), + /* 179 */ SyscallDesc("unknown #179", unimplementedFunc), + /* 180 */ SyscallDesc("unknown #180", unimplementedFunc), + /* 181 */ SyscallDesc("alt_plock", unimplementedFunc), + /* 182 */ SyscallDesc("unknown #182", unimplementedFunc), + /* 183 */ SyscallDesc("unknown #183", unimplementedFunc), + /* 184 */ SyscallDesc("getmnt", unimplementedFunc), + /* 185 */ SyscallDesc("unknown #185", unimplementedFunc), + /* 186 */ SyscallDesc("unknown #186", unimplementedFunc), + /* 187 */ SyscallDesc("alt_sigpending", unimplementedFunc), + /* 188 */ SyscallDesc("alt_setsid", unimplementedFunc), + /* 189 */ SyscallDesc("unknown #189", unimplementedFunc), + /* 190 */ SyscallDesc("unknown #190", unimplementedFunc), + /* 191 */ SyscallDesc("unknown #191", unimplementedFunc), + /* 192 */ SyscallDesc("unknown #192", unimplementedFunc), + /* 193 */ SyscallDesc("unknown #193", unimplementedFunc), + /* 194 */ SyscallDesc("unknown #194", unimplementedFunc), + /* 195 */ SyscallDesc("unknown #195", unimplementedFunc), + /* 196 */ SyscallDesc("unknown #196", unimplementedFunc), + /* 197 */ SyscallDesc("unknown #197", unimplementedFunc), + /* 198 */ SyscallDesc("unknown #198", unimplementedFunc), + /* 199 */ SyscallDesc("swapon", unimplementedFunc), + /* 200 */ SyscallDesc("msgctl", unimplementedFunc), + /* 201 */ SyscallDesc("msgget", unimplementedFunc), + /* 202 */ SyscallDesc("msgrcv", unimplementedFunc), + /* 203 */ SyscallDesc("msgsnd", unimplementedFunc), + /* 204 */ SyscallDesc("semctl", unimplementedFunc), + /* 205 */ SyscallDesc("semget", unimplementedFunc), + /* 206 */ SyscallDesc("semop", unimplementedFunc), + /* 207 */ SyscallDesc("uname", unameFunc), + /* 208 */ SyscallDesc("lchown", unimplementedFunc), + /* 209 */ SyscallDesc("shmat", unimplementedFunc), + /* 210 */ SyscallDesc("shmctl", unimplementedFunc), + /* 211 */ SyscallDesc("shmdt", unimplementedFunc), + /* 212 */ SyscallDesc("shmget", unimplementedFunc), + /* 213 */ SyscallDesc("mvalid", unimplementedFunc), + /* 214 */ SyscallDesc("getaddressconf", unimplementedFunc), + /* 215 */ SyscallDesc("msleep", unimplementedFunc), + /* 216 */ SyscallDesc("mwakeup", unimplementedFunc), + /* 217 */ SyscallDesc("msync", unimplementedFunc), + /* 218 */ SyscallDesc("signal", unimplementedFunc), + /* 219 */ SyscallDesc("utc_gettime", unimplementedFunc), + /* 220 */ SyscallDesc("utc_adjtime", unimplementedFunc), + /* 221 */ SyscallDesc("unknown #221", unimplementedFunc), + /* 222 */ SyscallDesc("security", unimplementedFunc), + /* 223 */ SyscallDesc("kloadcall", unimplementedFunc), + /* 224 */ SyscallDesc("stat", statFunc<Tru64>), + /* 225 */ SyscallDesc("lstat", lstatFunc<Tru64>), + /* 226 */ SyscallDesc("fstat", fstatFunc<Tru64>), + /* 227 */ SyscallDesc("statfs", unimplementedFunc), + /* 228 */ SyscallDesc("fstatfs", unimplementedFunc), + /* 229 */ SyscallDesc("getfsstat", unimplementedFunc), + /* 230 */ SyscallDesc("gettimeofday64", unimplementedFunc), + /* 231 */ SyscallDesc("settimeofday64", unimplementedFunc), + /* 232 */ SyscallDesc("unknown #232", unimplementedFunc), + /* 233 */ SyscallDesc("getpgid", unimplementedFunc), + /* 234 */ SyscallDesc("getsid", unimplementedFunc), + /* 235 */ SyscallDesc("sigaltstack", ignoreFunc), + /* 236 */ SyscallDesc("waitid", unimplementedFunc), + /* 237 */ SyscallDesc("priocntlset", unimplementedFunc), + /* 238 */ SyscallDesc("sigsendset", unimplementedFunc), + /* 239 */ SyscallDesc("set_speculative", unimplementedFunc), + /* 240 */ SyscallDesc("msfs_syscall", unimplementedFunc), + /* 241 */ SyscallDesc("sysinfo", unimplementedFunc), + /* 242 */ SyscallDesc("uadmin", unimplementedFunc), + /* 243 */ SyscallDesc("fuser", unimplementedFunc), + /* 244 */ SyscallDesc("proplist_syscall", unimplementedFunc), + /* 245 */ SyscallDesc("ntp_adjtime", unimplementedFunc), + /* 246 */ SyscallDesc("ntp_gettime", unimplementedFunc), + /* 247 */ SyscallDesc("pathconf", unimplementedFunc), + /* 248 */ SyscallDesc("fpathconf", unimplementedFunc), + /* 249 */ SyscallDesc("sync2", unimplementedFunc), + /* 250 */ SyscallDesc("uswitch", unimplementedFunc), + /* 251 */ SyscallDesc("usleep_thread", unimplementedFunc), + /* 252 */ SyscallDesc("audcntl", unimplementedFunc), + /* 253 */ SyscallDesc("audgen", unimplementedFunc), + /* 254 */ SyscallDesc("sysfs", unimplementedFunc), + /* 255 */ SyscallDesc("subsys_info", unimplementedFunc), + /* 256 */ SyscallDesc("getsysinfo", getsysinfoFunc), + /* 257 */ SyscallDesc("setsysinfo", unimplementedFunc), + /* 258 */ SyscallDesc("afs_syscall", unimplementedFunc), + /* 259 */ SyscallDesc("swapctl", unimplementedFunc), + /* 260 */ SyscallDesc("memcntl", unimplementedFunc), + /* 261 */ SyscallDesc("fdatasync", unimplementedFunc), + /* 262 */ SyscallDesc("oflock", unimplementedFunc), + /* 263 */ SyscallDesc("F64_readv", unimplementedFunc), + /* 264 */ SyscallDesc("F64_writev", unimplementedFunc), + /* 265 */ SyscallDesc("cdslxlate", unimplementedFunc), + /* 266 */ SyscallDesc("sendfile", unimplementedFunc), +}; + +const int Tru64::Num_Syscall_Descs = + sizeof(Tru64::syscallDescs) / sizeof(SyscallDesc); + +const int Tru64::Max_Syscall_Desc = Tru64::Num_Syscall_Descs - 1; + +SyscallDesc Tru64::machSyscallDescs[] = { /* 0 */ SyscallDesc("kern_invalid", unimplementedFunc), /* 1 */ SyscallDesc("m5_mutex_lock", m5_mutex_lockFunc), /* 2 */ SyscallDesc("m5_mutex_trylock", m5_mutex_trylockFunc), @@ -1780,66 +1727,30 @@ SyscallDesc machSyscallDescs[] = { /* 82 */ SyscallDesc("mach_sctimes_port_alloc_dealloc", unimplementedFunc) }; -const int Num_Mach_Syscall_Descs = - sizeof(machSyscallDescs) / sizeof(SyscallDesc); - -const int Max_Mach_Syscall_Desc = Num_Mach_Syscall_Descs - 1; - -// Since negated values are used to identify Mach syscalls, the -// minimum (signed) valid syscall number is the negated max Mach -// syscall number. -const int Min_Syscall_Desc = -Max_Mach_Syscall_Desc; +const int Tru64::Num_Mach_Syscall_Descs = + sizeof(Tru64::machSyscallDescs) / sizeof(SyscallDesc); +const int Tru64::Max_Mach_Syscall_Desc = Tru64::Num_Mach_Syscall_Descs - 1; +const int Tru64::Min_Syscall_Desc = -Tru64::Max_Mach_Syscall_Desc; -// -// helper function for invoking syscalls -// -static void -doSyscall(int callnum, Process *process, ExecContext *xc) +AlphaTru64Process::syscall(ExecContext *xc) { - if (callnum < Min_Syscall_Desc || callnum > Max_Syscall_Desc) { - cerr << "Syscall " << callnum << " out of range" << endl; - abort(); - } - - SyscallDesc *desc = - (callnum < 0) ? &machSyscallDescs[-callnum] : &syscallDescs[callnum]; - - DPRINTFR(SyscallVerbose, "%s: syscall %s called\n", - xc->cpu->name(), desc->name); - - int retval = desc->doFunc(callnum, process, xc); - - DPRINTFR(SyscallVerbose, "%s: syscall %s returns %d\n", - xc->cpu->name(), desc->name, retval); - - if (!((desc->flags & SyscallDesc::SuppressReturnValue) && retval == 0)) - set_return_value(xc, retval); -} - -// -// Indirect syscall invocation (call #0) -// -int -indirectSyscallFunc(SyscallDesc *desc, int callnum, Process *process, - ExecContext *xc) -{ - int new_callnum = getArg(xc, 0); - - for (int i = 0; i < 5; ++i) - setArg(xc, i, getArg(xc, i+1)); + num_syscalls++; - doSyscall(new_callnum, process, xc); + int64_t callnum = xc->regs.intRegFile[ReturnValueReg]; - return 0; + Tru64::doSyscall(callnum, this, xc); } -void -fake_syscall(Process *process, ExecContext *xc) +AlphaTru64Process::AlphaTru64Process(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) + : LiveProcess(name, objFile, stdin_fd, stdout_fd, stderr_fd, argv, envp) { - int64_t callnum = xc->regs.intRegFile[ReturnValueReg]; - - doSyscall(callnum, process, xc); } diff --git a/arch/alpha/alpha_tru64_process.hh b/arch/alpha/alpha_tru64_process.hh new file mode 100644 index 000000000..2b03d66b2 --- /dev/null +++ b/arch/alpha/alpha_tru64_process.hh @@ -0,0 +1,47 @@ +/* + * 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 __ALPHA_TRU64_PROCESS_HH__ +#define __ALPHA_TRU64_PROCESS_HH__ + +#include "sim/process.hh" + +class AlphaTru64Process : public LiveProcess +{ + public: + AlphaTru64Process(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); +}; + + +#endif // __ALPHA_TRU64_PROCESS_HH__ diff --git a/base/loader/aout_object.cc b/base/loader/aout_object.cc index 0270e02a3..42a376ed1 100644 --- a/base/loader/aout_object.cc +++ b/base/loader/aout_object.cc @@ -43,7 +43,9 @@ ObjectFile * AoutObject::tryFile(const string &fname, int fd, size_t len, uint8_t *data) { if (!N_BADMAG(*(aout_exechdr *)data)) { - return new AoutObject(fname, fd, len, data); + // right now this is only used for Alpha PAL code + return new AoutObject(fname, fd, len, data, + ObjectFile::Alpha, ObjectFile::UnknownOpSys); } else { return NULL; @@ -52,8 +54,9 @@ AoutObject::tryFile(const string &fname, int fd, size_t len, uint8_t *data) AoutObject::AoutObject(const string &_filename, int _fd, - size_t _len, uint8_t *_data) - : ObjectFile(_filename, _fd, _len, _data) + size_t _len, uint8_t *_data, + Arch _arch, OpSys _opSys) + : ObjectFile(_filename, _fd, _len, _data, _arch, _opSys) { execHdr = (aout_exechdr *)fileData; diff --git a/base/loader/aout_object.hh b/base/loader/aout_object.hh index 77c59aef6..9fb8cb3e8 100644 --- a/base/loader/aout_object.hh +++ b/base/loader/aout_object.hh @@ -40,7 +40,8 @@ class AoutObject : public ObjectFile aout_exechdr *execHdr; AoutObject(const std::string &_filename, int _fd, - size_t _len, uint8_t *_data); + size_t _len, uint8_t *_data, + Arch _arch, OpSys _opSys); public: virtual ~AoutObject() {} diff --git a/base/loader/ecoff_object.cc b/base/loader/ecoff_object.cc index 5e726a1c5..bab75944d 100644 --- a/base/loader/ecoff_object.cc +++ b/base/loader/ecoff_object.cc @@ -46,7 +46,8 @@ EcoffObject::tryFile(const string &fname, int fd, size_t len, uint8_t *data) { if (((ecoff_filehdr *)data)->f_magic == ECOFF_MAGIC_ALPHA) { // it's Alpha ECOFF - return new EcoffObject(fname, fd, len, data); + return new EcoffObject(fname, fd, len, data, + ObjectFile::Alpha, ObjectFile::Tru64); } else { return NULL; @@ -55,8 +56,9 @@ EcoffObject::tryFile(const string &fname, int fd, size_t len, uint8_t *data) EcoffObject::EcoffObject(const string &_filename, int _fd, - size_t _len, uint8_t *_data) - : ObjectFile(_filename, _fd, _len, _data) + size_t _len, uint8_t *_data, + Arch _arch, OpSys _opSys) + : ObjectFile(_filename, _fd, _len, _data, _arch, _opSys) { execHdr = (ecoff_exechdr *)fileData; fileHdr = &(execHdr->f); diff --git a/base/loader/ecoff_object.hh b/base/loader/ecoff_object.hh index 94b11c720..05d026d00 100644 --- a/base/loader/ecoff_object.hh +++ b/base/loader/ecoff_object.hh @@ -44,7 +44,8 @@ class EcoffObject : public ObjectFile ecoff_aouthdr *aoutHdr; EcoffObject(const std::string &_filename, int _fd, - size_t _len, uint8_t *_data); + size_t _len, uint8_t *_data, + Arch _arch, OpSys _opSys); public: virtual ~EcoffObject() {} diff --git a/base/loader/elf_object.cc b/base/loader/elf_object.cc index 605895c9c..30dec4c91 100644 --- a/base/loader/elf_object.cc +++ b/base/loader/elf_object.cc @@ -43,8 +43,9 @@ ObjectFile * ElfObject::tryFile(const string &fname, int fd, size_t len, uint8_t *data) { if (memcmp(((Elf64_Ehdr *)data)->e_ident, ELFMAG, SELFMAG) == 0) { - // for now we'll assume it's a 64-bit Alpha binary - return new ElfObject(fname, fd, len, data); + // for now we'll assume it's a 64-bit Alpha Linux binary + return new ElfObject(fname, fd, len, data, + ObjectFile::Alpha, ObjectFile::Linux); } else { return NULL; @@ -53,8 +54,9 @@ ElfObject::tryFile(const string &fname, int fd, size_t len, uint8_t *data) ElfObject::ElfObject(const string &_filename, int _fd, - size_t _len, uint8_t *_data) - : ObjectFile(_filename, _fd, _len, _data) + size_t _len, uint8_t *_data, + Arch _arch, OpSys _opSys) + : ObjectFile(_filename, _fd, _len, _data, _arch, _opSys) { ehdr = (Elf64_Ehdr *)fileData; diff --git a/base/loader/elf_object.hh b/base/loader/elf_object.hh index 28f6bb243..10d97d089 100644 --- a/base/loader/elf_object.hh +++ b/base/loader/elf_object.hh @@ -45,7 +45,8 @@ class ElfObject : public ObjectFile int dataPhdrIdx; ElfObject(const std::string &_filename, int _fd, - size_t _len, uint8_t *_data); + size_t _len, uint8_t *_data, + Arch _arch, OpSys _opSys); public: virtual ~ElfObject() {} diff --git a/base/loader/object_file.cc b/base/loader/object_file.cc index 5a13d180c..25e9b2d19 100644 --- a/base/loader/object_file.cc +++ b/base/loader/object_file.cc @@ -46,8 +46,10 @@ using namespace std; ObjectFile::ObjectFile(const string &_filename, int _fd, - size_t _len, uint8_t *_data) - : filename(_filename), descriptor(_fd), fileData(_data), len(_len) + size_t _len, uint8_t *_data, + Arch _arch, OpSys _opSys) + : filename(_filename), descriptor(_fd), fileData(_data), len(_len), + arch(_arch), opSys(_opSys) { } diff --git a/base/loader/object_file.hh b/base/loader/object_file.hh index 5950ea326..a29bdc153 100644 --- a/base/loader/object_file.hh +++ b/base/loader/object_file.hh @@ -36,14 +36,31 @@ class SymbolTable; class ObjectFile { + public: + + enum Arch { + UnknownArch, + Alpha + }; + + enum OpSys { + UnknownOpSys, + Tru64, + Linux + }; + protected: const std::string filename; int descriptor; uint8_t *fileData; size_t len; + Arch arch; + OpSys opSys; + ObjectFile(const std::string &_filename, int _fd, - size_t _len, uint8_t *_data); + size_t _len, uint8_t *_data, + Arch _arch, OpSys _opSys); public: virtual ~ObjectFile(); @@ -55,6 +72,9 @@ class ObjectFile virtual bool loadGlobalSymbols(SymbolTable *symtab) = 0; virtual bool loadLocalSymbols(SymbolTable *symtab) = 0; + Arch getArch() const { return arch; } + OpSys getOpSys() const { return opSys; } + protected: struct Section { diff --git a/cpu/exec_context.cc b/cpu/exec_context.cc index 92144bd93..7332b86a6 100644 --- a/cpu/exec_context.cc +++ b/cpu/exec_context.cc @@ -34,7 +34,7 @@ #ifdef FULL_SYSTEM #include "sim/system.hh" #else -#include "sim/prog.hh" +#include "sim/process.hh" #endif using namespace std; diff --git a/cpu/exec_context.hh b/cpu/exec_context.hh index 274a3778b..7999e3735 100644 --- a/cpu/exec_context.hh +++ b/cpu/exec_context.hh @@ -52,7 +52,7 @@ class MemoryController; #else // !FULL_SYSTEM -#include "sim/prog.hh" +#include "sim/process.hh" #endif // FULL_SYSTEM @@ -376,6 +376,34 @@ class ExecContext #endif #ifndef FULL_SYSTEM + IntReg getSyscallArg(int i) + { + return regs.intRegFile[ArgumentReg0 + i]; + } + + // used to shift args for indirect syscall + void setSyscallArg(int i, IntReg val) + { + regs.intRegFile[ArgumentReg0 + i] = val; + } + + void setSyscallReturn(int64_t return_value) + { + // check for error condition. Alpha syscall convention is to + // indicate success/failure in reg a3 (r19) and put the + // return value itself in the standard return value reg (v0). + const int RegA3 = 19; // only place this is used + if (return_value >= 0) { + // no error + regs.intRegFile[RegA3] = 0; + regs.intRegFile[ReturnValueReg] = return_value; + } else { + // got an error, return details + regs.intRegFile[RegA3] = (IntReg) -1; + regs.intRegFile[ReturnValueReg] = -return_value; + } + } + void syscall() { process->syscall(this); diff --git a/cpu/simple_cpu/simple_cpu.cc b/cpu/simple_cpu/simple_cpu.cc index a63f86098..476f28ea0 100644 --- a/cpu/simple_cpu/simple_cpu.cc +++ b/cpu/simple_cpu/simple_cpu.cc @@ -70,7 +70,6 @@ #else // !FULL_SYSTEM #include "eio/eio.hh" #include "mem/functional_mem/functional_memory.hh" -#include "sim/prog.hh" #endif // FULL_SYSTEM using namespace std; 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__ |