syscall_emul.hh revision 1450
1360SN/A/* 210850SGiacomo.Gabrielli@arm.com * Copyright (c) 2003-2004 The Regents of The University of Michigan 310796Sbrandon.potter@amd.com * All rights reserved. 410027SChris.Adeniyi-Jones@arm.com * 510027SChris.Adeniyi-Jones@arm.com * Redistribution and use in source and binary forms, with or without 610027SChris.Adeniyi-Jones@arm.com * modification, are permitted provided that the following conditions are 710027SChris.Adeniyi-Jones@arm.com * met: redistributions of source code must retain the above copyright 810027SChris.Adeniyi-Jones@arm.com * notice, this list of conditions and the following disclaimer; 910027SChris.Adeniyi-Jones@arm.com * redistributions in binary form must reproduce the above copyright 1010027SChris.Adeniyi-Jones@arm.com * notice, this list of conditions and the following disclaimer in the 1110027SChris.Adeniyi-Jones@arm.com * documentation and/or other materials provided with the distribution; 1210027SChris.Adeniyi-Jones@arm.com * neither the name of the copyright holders nor the names of its 1310027SChris.Adeniyi-Jones@arm.com * contributors may be used to endorse or promote products derived from 1410027SChris.Adeniyi-Jones@arm.com * this software without specific prior written permission. 151458SN/A * 16360SN/A * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17360SN/A * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18360SN/A * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19360SN/A * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20360SN/A * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21360SN/A * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22360SN/A * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23360SN/A * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24360SN/A * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25360SN/A * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26360SN/A * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27360SN/A */ 28360SN/A 29360SN/A#ifndef __SIM_SYSCALL_EMUL_HH__ 30360SN/A#define __SIM_SYSCALL_EMUL_HH__ 31360SN/A 32360SN/A/// 33360SN/A/// @file syscall_emul.hh 34360SN/A/// 35360SN/A/// This file defines objects used to emulate syscalls from the target 36360SN/A/// application on the host machine. 37360SN/A 38360SN/A#include <errno.h> 39360SN/A#include <string> 402665Ssaidi@eecs.umich.edu 412665Ssaidi@eecs.umich.edu#include "base/intmath.hh" // for RoundUp 422665Ssaidi@eecs.umich.edu#include "mem/functional_mem/functional_memory.hh" 43360SN/A#include "targetarch/isa_traits.hh" // for Addr 44360SN/A 451354SN/A#include "base/trace.hh" 461354SN/A#include "cpu/exec_context.hh" 47360SN/A#include "sim/process.hh" 4812018Sandreas.sandberg@arm.com 4912018Sandreas.sandberg@arm.com/// 5012018Sandreas.sandberg@arm.com/// System call descriptor. 5112018Sandreas.sandberg@arm.com/// 5212018Sandreas.sandberg@arm.comclass SyscallDesc { 5312018Sandreas.sandberg@arm.com 5412018Sandreas.sandberg@arm.com public: 552064SN/A 5612018Sandreas.sandberg@arm.com /// Typedef for target syscall handler functions. 5712018Sandreas.sandberg@arm.com typedef SyscallReturn (*FuncPtr)(SyscallDesc *, int num, 5812018Sandreas.sandberg@arm.com Process *, ExecContext *); 5912018Sandreas.sandberg@arm.com 6012018Sandreas.sandberg@arm.com const char *name; //!< Syscall name (e.g., "open"). 6112018Sandreas.sandberg@arm.com FuncPtr funcPtr; //!< Pointer to emulation function. 6211799Sbrandon.potter@amd.com int flags; //!< Flags (see Flags enum). 6312018Sandreas.sandberg@arm.com 6412018Sandreas.sandberg@arm.com /// Flag values for controlling syscall behavior. 6512018Sandreas.sandberg@arm.com enum Flags { 6612018Sandreas.sandberg@arm.com /// Don't set return regs according to funcPtr return value. 6712018Sandreas.sandberg@arm.com /// Used for syscalls with non-standard return conventions 6812018Sandreas.sandberg@arm.com /// that explicitly set the ExecContext regs (e.g., 6911799Sbrandon.potter@amd.com /// sigreturn). 70360SN/A SuppressReturnValue = 1 71360SN/A }; 72360SN/A 73360SN/A /// Constructor. 74360SN/A SyscallDesc(const char *_name, FuncPtr _funcPtr, int _flags = 0) 75360SN/A : name(_name), funcPtr(_funcPtr), flags(_flags) 761809SN/A { 7711800Sbrandon.potter@amd.com } 7811392Sbrandon.potter@amd.com 791809SN/A /// Emulate the syscall. Public interface for calling through funcPtr. 8011392Sbrandon.potter@amd.com void doSyscall(int callnum, Process *proc, ExecContext *xc); 8111383Sbrandon.potter@amd.com}; 8213568Sbrandon.potter@amd.com 833113Sgblack@eecs.umich.edu 8411799Sbrandon.potter@amd.comclass BaseBufferArg { 8511759Sbrandon.potter@amd.com 8611812Sbaz21@cam.ac.uk public: 8711812Sbaz21@cam.ac.uk 8811799Sbrandon.potter@amd.com BaseBufferArg(Addr _addr, int _size) : addr(_addr), size(_size) 898229Snate@binkert.org { 908229Snate@binkert.org bufPtr = new uint8_t[size]; 9111594Santhony.gutierrez@amd.com // clear out buffer: in case we only partially populate this, 927075Snate@binkert.org // and then do a copyOut(), we want to make sure we don't 938229Snate@binkert.org // introduce any random junk into the simulated address space 9411856Sbrandon.potter@amd.com memset(bufPtr, 0, size); 957075Snate@binkert.org } 96360SN/A 9712461Sgabeblack@google.com virtual ~BaseBufferArg() { delete [] bufPtr; } 9811886Sbrandon.potter@amd.com 9911800Sbrandon.potter@amd.com // 10011392Sbrandon.potter@amd.com // copy data into simulator space (read from target memory) 10112334Sgabeblack@google.com // 1021354SN/A virtual bool copyIn(FunctionalMemory *mem) 1036216Snate@binkert.org { 1046658Snate@binkert.org mem->access(Read, addr, bufPtr, size); 1052474SN/A return true; // no EFAULT detection for now 1062680Sktlim@umich.edu } 1078229Snate@binkert.org 10811886Sbrandon.potter@amd.com // 10910496Ssteve.reinhardt@amd.com // copy data out of simulator space (write to target memory) 11011911SBrandon.Potter@amd.com // 1118229Snate@binkert.org virtual bool copyOut(FunctionalMemory *mem) 11211794Sbrandon.potter@amd.com { 11311886Sbrandon.potter@amd.com mem->access(Write, addr, bufPtr, size); 11410497Ssteve.reinhardt@amd.com return true; // no EFAULT detection for now 11511794Sbrandon.potter@amd.com } 116360SN/A 117360SN/A protected: 118360SN/A Addr addr; 119360SN/A int size; 120360SN/A uint8_t *bufPtr; 121360SN/A}; 122360SN/A 123360SN/A 124360SN/Aclass BufferArg : public BaseBufferArg 125360SN/A{ 126378SN/A public: 1271706SN/A BufferArg(Addr _addr, int _size) : BaseBufferArg(_addr, _size) { } 12811851Sbrandon.potter@amd.com void *bufferPtr() { return bufPtr; } 129378SN/A}; 130378SN/A 131378SN/Atemplate <class T> 132378SN/Aclass TypedBufferArg : public BaseBufferArg 133378SN/A{ 1341706SN/A public: 13511851Sbrandon.potter@amd.com // user can optionally specify a specific number of bytes to 136360SN/A // allocate to deal with those structs that have variable-size 13711760Sbrandon.potter@amd.com // arrays at the end 13811760Sbrandon.potter@amd.com TypedBufferArg(Addr _addr, int _size = sizeof(T)) 13911851Sbrandon.potter@amd.com : BaseBufferArg(_addr, _size) 14011760Sbrandon.potter@amd.com { } 1416109Ssanchezd@stanford.edu 1421706SN/A // type case 14311851Sbrandon.potter@amd.com operator T*() { return (T *)bufPtr; } 144378SN/A 1456109Ssanchezd@stanford.edu // dereference operators 1466109Ssanchezd@stanford.edu T &operator*() { return *((T *)bufPtr); } 14711851Sbrandon.potter@amd.com T* operator->() { return (T *)bufPtr; } 1486109Ssanchezd@stanford.edu T &operator[](int i) { return ((T *)bufPtr)[i]; } 14911886Sbrandon.potter@amd.com}; 15011886Sbrandon.potter@amd.com 15111886Sbrandon.potter@amd.com////////////////////////////////////////////////////////////////////// 15211886Sbrandon.potter@amd.com// 153378SN/A// The following emulation functions are generic enough that they 1541706SN/A// don't need to be recompiled for different emulated OS's. They are 15511851Sbrandon.potter@amd.com// defined in sim/syscall_emul.cc. 156378SN/A// 1575748SSteve.Reinhardt@amd.com////////////////////////////////////////////////////////////////////// 1585748SSteve.Reinhardt@amd.com 15911851Sbrandon.potter@amd.com 160378SN/A/// Handler for unimplemented syscalls that we haven't thought about. 161378SN/ASyscallReturn unimplementedFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 1621706SN/A 16311851Sbrandon.potter@amd.com/// Handler for unimplemented syscalls that we never intend to 164378SN/A/// implement (signal handling, etc.) and should not affect the correct 16511886Sbrandon.potter@amd.com/// behavior of the program. Print a warning only if the appropriate 1661706SN/A/// trace flag is enabled. Return success to the target program. 16711851Sbrandon.potter@amd.comSyscallReturn ignoreFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 168378SN/A 169378SN/A/// Target exit() handler: terminate simulation. 1701706SN/ASyscallReturn exitFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 17111851Sbrandon.potter@amd.com 172378SN/A/// Target getpagesize() handler. 173378SN/ASyscallReturn getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 1741706SN/A 17511851Sbrandon.potter@amd.com/// Target obreak() handler: set brk address. 176378SN/ASyscallReturn obreakFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 1774118Sgblack@eecs.umich.edu 1784118Sgblack@eecs.umich.edu/// Target close() handler. 17911851Sbrandon.potter@amd.comSyscallReturn closeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 1804118Sgblack@eecs.umich.edu 181378SN/A/// Target read() handler. 1821706SN/ASyscallReturn readFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 18311851Sbrandon.potter@amd.com 184378SN/A/// Target write() handler. 18513568Sbrandon.potter@amd.comSyscallReturn writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 18613568Sbrandon.potter@amd.com 18713568Sbrandon.potter@amd.com/// Target lseek() handler. 18813568Sbrandon.potter@amd.comSyscallReturn lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 189378SN/A 1901706SN/A/// Target munmap() handler. 19111851Sbrandon.potter@amd.comSyscallReturn munmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 192360SN/A 1935513SMichael.Adler@intel.com/// Target gethostname() handler. 1945513SMichael.Adler@intel.comSyscallReturn gethostnameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 19511851Sbrandon.potter@amd.com 1965513SMichael.Adler@intel.com/// Target unlink() handler. 19710203SAli.Saidi@ARM.comSyscallReturn unlinkFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 19810203SAli.Saidi@ARM.com 19911851Sbrandon.potter@amd.com/// Target rename() handler. 20010203SAli.Saidi@ARM.comSyscallReturn renameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc); 2015513SMichael.Adler@intel.com 20211851Sbrandon.potter@amd.com/// This struct is used to build an target-OS-dependent table that 2035513SMichael.Adler@intel.com/// maps the target's open() flags to the host open() flags. 204511SN/Astruct OpenFlagTransTable { 20510633Smichaelupton@gmail.com int tgtFlag; //!< Target system flag value. 20611851Sbrandon.potter@amd.com int hostFlag; //!< Corresponding host system flag value. 20710633Smichaelupton@gmail.com}; 2081706SN/A 20911851Sbrandon.potter@amd.com 210511SN/A 21112795Smattdsinclair@gmail.com/// A readable name for 1,000,000, for converting microseconds to seconds. 21212795Smattdsinclair@gmail.comconst int one_million = 1000000; 21312795Smattdsinclair@gmail.com 21412795Smattdsinclair@gmail.com/// Approximate seconds since the epoch (1/1/1970). About a billion, 21512796Smattdsinclair@gmail.com/// by my reckoning. We want to keep this a constant (not use the 21612796Smattdsinclair@gmail.com/// real-world time) to keep simulations repeatable. 21712796Smattdsinclair@gmail.comconst unsigned seconds_since_epoch = 1000000000; 21812796Smattdsinclair@gmail.com 2195513SMichael.Adler@intel.com/// Helper function to convert current elapsed time to seconds and 2205513SMichael.Adler@intel.com/// microseconds. 22111851Sbrandon.potter@amd.comtemplate <class T1, class T2> 2225513SMichael.Adler@intel.comvoid 22313031Sbrandon.potter@amd.comgetElapsedTime(T1 &sec, T2 &usec) 22413031Sbrandon.potter@amd.com{ 22513031Sbrandon.potter@amd.com int cycles_per_usec = ticksPerSecond / one_million; 22613031Sbrandon.potter@amd.com 22713031Sbrandon.potter@amd.com int elapsed_usecs = curTick / cycles_per_usec; 22813031Sbrandon.potter@amd.com sec = elapsed_usecs / one_million; 22913031Sbrandon.potter@amd.com usec = elapsed_usecs % one_million; 23013031Sbrandon.potter@amd.com} 23113031Sbrandon.potter@amd.com 23213031Sbrandon.potter@amd.com////////////////////////////////////////////////////////////////////// 23313031Sbrandon.potter@amd.com// 23413031Sbrandon.potter@amd.com// The following emulation functions are generic, but need to be 235511SN/A// templated to account for differences in types, constants, etc. 2361706SN/A// 23711851Sbrandon.potter@amd.com////////////////////////////////////////////////////////////////////// 2381706SN/A 2391706SN/A/// Target ioctl() handler. For the most part, programs call ioctl() 2401706SN/A/// only to find out if their stdout is a tty, to determine whether to 2411706SN/A/// do line or block buffering. 24211851Sbrandon.potter@amd.comtemplate <class OS> 2431706SN/ASyscallReturn 2441706SN/AioctlFunc(SyscallDesc *desc, int callnum, Process *process, 2451706SN/A ExecContext *xc) 2461706SN/A{ 24711851Sbrandon.potter@amd.com int fd = xc->getSyscallArg(0); 2481706SN/A unsigned req = xc->getSyscallArg(1); 249511SN/A 2506703Svince@csl.cornell.edu // DPRINTFR(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", fd, req); 2516703Svince@csl.cornell.edu 25211851Sbrandon.potter@amd.com if (fd < 0 || process->sim_fd(fd) < 0) { 2536703Svince@csl.cornell.edu // doesn't map to any simulator fd: not a valid target fd 2546685Stjones1@inf.ed.ac.uk return SyscallReturn(-EBADF); 2556685Stjones1@inf.ed.ac.uk } 25611851Sbrandon.potter@amd.com 2576685Stjones1@inf.ed.ac.uk switch (req) { 2586685Stjones1@inf.ed.ac.uk case OS::TIOCISATTY: 2595513SMichael.Adler@intel.com case OS::TIOCGETP: 2605513SMichael.Adler@intel.com case OS::TIOCSETP: 26111851Sbrandon.potter@amd.com case OS::TIOCSETN: 2625513SMichael.Adler@intel.com case OS::TIOCSETC: 26311885Sbrandon.potter@amd.com case OS::TIOCGETC: 26411885Sbrandon.potter@amd.com case OS::TIOCGETS: 26511885Sbrandon.potter@amd.com case OS::TIOCGETA: 2665513SMichael.Adler@intel.com return SyscallReturn(-ENOTTY); 2671999SN/A 2681999SN/A default: 26911851Sbrandon.potter@amd.com fatal("Unsupported ioctl call: ioctl(%d, 0x%x, ...) @ 0x%llx\n", fd, req, xc->readPC()); 2701999SN/A } 27111885Sbrandon.potter@amd.com} 27211885Sbrandon.potter@amd.com 27311885Sbrandon.potter@amd.com/// Target open() handler. 2741999SN/Atemplate <class OS> 2751999SN/ASyscallReturn 2761999SN/AopenFunc(SyscallDesc *desc, int callnum, Process *process, 27711851Sbrandon.potter@amd.com ExecContext *xc) 2781999SN/A{ 2793079Sstever@eecs.umich.edu std::string path; 2803079Sstever@eecs.umich.edu 28111851Sbrandon.potter@amd.com if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault) 2823079Sstever@eecs.umich.edu return SyscallReturn(-EFAULT); 28311908SBrandon.Potter@amd.com 28411908SBrandon.Potter@amd.com if (path == "/dev/sysdev0") { 28511908SBrandon.Potter@amd.com // This is a memory-mapped high-resolution timer device on Alpha. 28611908SBrandon.Potter@amd.com // We don't support it, so just punt. 28711875Sbrandon.potter@amd.com DCOUT(SyscallWarnings) << "Ignoring open(" << path << ", ...)" << std::endl; 2882093SN/A return SyscallReturn(-ENOENT); 28911851Sbrandon.potter@amd.com } 2902093SN/A 2912687Sksewell@umich.edu int tgtFlags = xc->getSyscallArg(1); 2922687Sksewell@umich.edu int mode = xc->getSyscallArg(2); 29311851Sbrandon.potter@amd.com int hostFlags = 0; 2942687Sksewell@umich.edu 2952238SN/A // translate open flags 2962238SN/A for (int i = 0; i < OS::NUM_OPEN_FLAGS; i++) { 29711851Sbrandon.potter@amd.com if (tgtFlags & OS::openFlagTable[i].tgtFlag) { 2982238SN/A tgtFlags &= ~OS::openFlagTable[i].tgtFlag; 29911908SBrandon.Potter@amd.com hostFlags |= OS::openFlagTable[i].hostFlag; 30011908SBrandon.Potter@amd.com } 30111908SBrandon.Potter@amd.com } 30211908SBrandon.Potter@amd.com 30311908SBrandon.Potter@amd.com // any target flags left? 30411908SBrandon.Potter@amd.com if (tgtFlags != 0) 30511908SBrandon.Potter@amd.com std::cerr << "Syscall: open: cannot decode flags: " << tgtFlags << std::endl; 30611908SBrandon.Potter@amd.com 3072238SN/A#ifdef __CYGWIN32__ 3082238SN/A hostFlags |= O_BINARY; 30911851Sbrandon.potter@amd.com#endif 3102238SN/A 31113568Sbrandon.potter@amd.com // open the file 31213568Sbrandon.potter@amd.com int fd = open(path.c_str(), hostFlags, mode); 31313568Sbrandon.potter@amd.com 31413568Sbrandon.potter@amd.com return (fd == -1) ? SyscallReturn(-errno) : SyscallReturn(process->open_fd(fd)); 31513568Sbrandon.potter@amd.com} 31613568Sbrandon.potter@amd.com 31713568Sbrandon.potter@amd.com 31813568Sbrandon.potter@amd.com/// Target stat() handler. 31913568Sbrandon.potter@amd.comtemplate <class OS> 32013568Sbrandon.potter@amd.comSyscallReturn 32113568Sbrandon.potter@amd.comstatFunc(SyscallDesc *desc, int callnum, Process *process, 32213568Sbrandon.potter@amd.com ExecContext *xc) 32313448Sciro.santilli@arm.com{ 32413031Sbrandon.potter@amd.com std::string path; 32513031Sbrandon.potter@amd.com 32613031Sbrandon.potter@amd.com if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault) 32713448Sciro.santilli@arm.com return SyscallReturn(-EFAULT); 32813031Sbrandon.potter@amd.com 32913539Sjavier.setoain@arm.com struct stat hostBuf; 33013539Sjavier.setoain@arm.com int result = stat(path.c_str(), &hostBuf); 33113539Sjavier.setoain@arm.com 33213539Sjavier.setoain@arm.com if (result < 0) 33313539Sjavier.setoain@arm.com return SyscallReturn(errno); 33413539Sjavier.setoain@arm.com 33513031Sbrandon.potter@amd.com OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf); 3362238SN/A 33711851Sbrandon.potter@amd.com return SyscallReturn(0); 3382238SN/A} 3392238SN/A 3402238SN/A 34111851Sbrandon.potter@amd.com/// Target lstat() handler. 3422238SN/Atemplate <class OS> 3432238SN/ASyscallReturn 3442238SN/AlstatFunc(SyscallDesc *desc, int callnum, Process *process, 34511851Sbrandon.potter@amd.com ExecContext *xc) 3462238SN/A{ 3472238SN/A std::string path; 3482238SN/A 34911851Sbrandon.potter@amd.com if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault) 3502238SN/A return SyscallReturn(-EFAULT); 3512238SN/A 3522238SN/A struct stat hostBuf; 35311851Sbrandon.potter@amd.com int result = lstat(path.c_str(), &hostBuf); 3542238SN/A 3559455Smitch.hayenga+gem5@gmail.com if (result < 0) 3569455Smitch.hayenga+gem5@gmail.com return SyscallReturn(-errno); 35711851Sbrandon.potter@amd.com 35810203SAli.Saidi@ARM.com OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf); 35911851Sbrandon.potter@amd.com 36011851Sbrandon.potter@amd.com return SyscallReturn(0); 3619455Smitch.hayenga+gem5@gmail.com} 3629112Smarc.orr@gmail.com 36311906SBrandon.Potter@amd.com/// Target fstat() handler. 36411906SBrandon.Potter@amd.comtemplate <class OS> 3659112Smarc.orr@gmail.comSyscallReturn 3669112Smarc.orr@gmail.comfstatFunc(SyscallDesc *desc, int callnum, Process *process, 36711851Sbrandon.potter@amd.com ExecContext *xc) 3689112Smarc.orr@gmail.com{ 3699112Smarc.orr@gmail.com int fd = process->sim_fd(xc->getSyscallArg(0)); 37011911SBrandon.Potter@amd.com 3719112Smarc.orr@gmail.com // DPRINTFR(SyscallVerbose, "fstat(%d, ...)\n", fd); 37211911SBrandon.Potter@amd.com 37311911SBrandon.Potter@amd.com if (fd < 0) 37411911SBrandon.Potter@amd.com return SyscallReturn(-EBADF); 37511911SBrandon.Potter@amd.com 3769112Smarc.orr@gmail.com struct stat hostBuf; 37711911SBrandon.Potter@amd.com int result = fstat(fd, &hostBuf); 37811911SBrandon.Potter@amd.com 37911911SBrandon.Potter@amd.com if (result < 0) 38011911SBrandon.Potter@amd.com return SyscallReturn(-errno); 3819238Slluc.alvarez@bsc.es 3829112Smarc.orr@gmail.com OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf); 38311911SBrandon.Potter@amd.com 3849112Smarc.orr@gmail.com return SyscallReturn(0); 38511911SBrandon.Potter@amd.com} 38611911SBrandon.Potter@amd.com 38711911SBrandon.Potter@amd.com 38811911SBrandon.Potter@amd.com/// Target mmap() handler. 38911911SBrandon.Potter@amd.com/// 3909112Smarc.orr@gmail.com/// We don't really handle mmap(). If the target is mmaping an 39111911SBrandon.Potter@amd.com/// anonymous region or /dev/zero, we can get away with doing basically 39211911SBrandon.Potter@amd.com/// nothing (since memory is initialized to zero and the simulator 39311911SBrandon.Potter@amd.com/// doesn't really check addresses anyway). Always print a warning, 39411911SBrandon.Potter@amd.com/// since this could be seriously broken if we're not mapping 39511911SBrandon.Potter@amd.com/// /dev/zero. 39611911SBrandon.Potter@amd.com// 3979112Smarc.orr@gmail.com/// Someday we should explicitly check for /dev/zero in open, flag the 3989112Smarc.orr@gmail.com/// file descriptor, and fail (or implement!) a non-anonymous mmap to 39911911SBrandon.Potter@amd.com/// anything else. 40011911SBrandon.Potter@amd.comtemplate <class OS> 4019112Smarc.orr@gmail.comSyscallReturn 40211911SBrandon.Potter@amd.commmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc) 40311911SBrandon.Potter@amd.com{ 4049112Smarc.orr@gmail.com Addr start = xc->getSyscallArg(0); 4059112Smarc.orr@gmail.com uint64_t length = xc->getSyscallArg(1); 40611911SBrandon.Potter@amd.com // int prot = xc->getSyscallArg(2); 40711911SBrandon.Potter@amd.com int flags = xc->getSyscallArg(3); 4089112Smarc.orr@gmail.com // int fd = p->sim_fd(xc->getSyscallArg(4)); 4099112Smarc.orr@gmail.com // int offset = xc->getSyscallArg(5); 4102238SN/A 4112238SN/A if (start == 0) { 4122238SN/A // user didn't give an address... pick one from our "mmap region" 4132238SN/A start = p->mmap_end; 41411851Sbrandon.potter@amd.com p->mmap_end += RoundUp<Addr>(length, VMPageSize); 4152238SN/A } 4162238SN/A 4172238SN/A if (!(flags & OS::TGT_MAP_ANONYMOUS)) { 41811851Sbrandon.potter@amd.com DPRINTF(SyscallWarnings, "Warning: allowing mmap of file @ fd %d. " 4192238SN/A "This will break if not /dev/zero.", xc->getSyscallArg(4)); 4202238SN/A } 4212238SN/A 42211851Sbrandon.potter@amd.com return SyscallReturn(start); 4232238SN/A} 4242238SN/A 4252238SN/A/// Target getrlimit() handler. 42611851Sbrandon.potter@amd.comtemplate <class OS> 4272238SN/ASyscallReturn 4282238SN/AgetrlimitFunc(SyscallDesc *desc, int callnum, Process *process, 4291354SN/A ExecContext *xc) 4301354SN/A{ 43110796Sbrandon.potter@amd.com unsigned resource = xc->getSyscallArg(0); 43210796Sbrandon.potter@amd.com TypedBufferArg<typename OS::rlimit> rlp(xc->getSyscallArg(1)); 4331354SN/A 4341354SN/A switch (resource) { 4351354SN/A case OS::RLIMIT_STACK: 4361354SN/A // max stack size in bytes: make up a number (2MB for now) 4371354SN/A rlp->rlim_cur = rlp->rlim_max = 8 * 1024 * 1024; 4381354SN/A break; 4391354SN/A 4401354SN/A default: 4411354SN/A std::cerr << "getrlimitFunc: unimplemented resource " << resource << std::endl; 4421354SN/A abort(); 44310796Sbrandon.potter@amd.com break; 4441354SN/A } 44510796Sbrandon.potter@amd.com 4461354SN/A rlp.copyOut(xc->mem); 4471354SN/A return SyscallReturn(0); 4481354SN/A} 4491354SN/A 45010796Sbrandon.potter@amd.com/// Target gettimeofday() handler. 45110796Sbrandon.potter@amd.comtemplate <class OS> 45210796Sbrandon.potter@amd.comSyscallReturn 45310796Sbrandon.potter@amd.comgettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process, 45410796Sbrandon.potter@amd.com ExecContext *xc) 45510796Sbrandon.potter@amd.com{ 45610796Sbrandon.potter@amd.com TypedBufferArg<typename OS::timeval> tp(xc->getSyscallArg(0)); 45710796Sbrandon.potter@amd.com 45810796Sbrandon.potter@amd.com getElapsedTime(tp->tv_sec, tp->tv_usec); 45910796Sbrandon.potter@amd.com tp->tv_sec += seconds_since_epoch; 46010796Sbrandon.potter@amd.com 461360SN/A tp.copyOut(xc->mem); 462360SN/A 463360SN/A return SyscallReturn(0); 464360SN/A} 465360SN/A 466360SN/A 467360SN/A/// Target getrusage() function. 46811759Sbrandon.potter@amd.comtemplate <class OS> 4693113Sgblack@eecs.umich.eduSyscallReturn 4703113Sgblack@eecs.umich.edugetrusageFunc(SyscallDesc *desc, int callnum, Process *process, 4713113Sgblack@eecs.umich.edu ExecContext *xc) 4723113Sgblack@eecs.umich.edu{ 4733113Sgblack@eecs.umich.edu int who = xc->getSyscallArg(0); // THREAD, SELF, or CHILDREN 4743113Sgblack@eecs.umich.edu TypedBufferArg<typename OS::rusage> rup(xc->getSyscallArg(1)); 4753113Sgblack@eecs.umich.edu 4763113Sgblack@eecs.umich.edu if (who != OS::RUSAGE_SELF) { 4773113Sgblack@eecs.umich.edu // don't really handle THREAD or CHILDREN, but just warn and 4783113Sgblack@eecs.umich.edu // plow ahead 4793113Sgblack@eecs.umich.edu DCOUT(SyscallWarnings) 4803113Sgblack@eecs.umich.edu << "Warning: getrusage() only supports RUSAGE_SELF." 4813113Sgblack@eecs.umich.edu << " Parameter " << who << " ignored." << std::endl; 48212032Sandreas.sandberg@arm.com } 4833113Sgblack@eecs.umich.edu 4843113Sgblack@eecs.umich.edu getElapsedTime(rup->ru_utime.tv_sec, rup->ru_utime.tv_usec); 4854189Sgblack@eecs.umich.edu rup->ru_stime.tv_sec = 0; 4864189Sgblack@eecs.umich.edu rup->ru_stime.tv_usec = 0; 4873113Sgblack@eecs.umich.edu rup->ru_maxrss = 0; 4883113Sgblack@eecs.umich.edu rup->ru_ixrss = 0; 4893113Sgblack@eecs.umich.edu rup->ru_idrss = 0; 4903113Sgblack@eecs.umich.edu rup->ru_isrss = 0; 4918737Skoansin.tan@gmail.com rup->ru_minflt = 0; 4923113Sgblack@eecs.umich.edu rup->ru_majflt = 0; 4938737Skoansin.tan@gmail.com rup->ru_nswap = 0; 4943277Sgblack@eecs.umich.edu rup->ru_inblock = 0; 4955515SMichael.Adler@intel.com rup->ru_oublock = 0; 4965515SMichael.Adler@intel.com rup->ru_msgsnd = 0; 4975515SMichael.Adler@intel.com rup->ru_msgrcv = 0; 4985515SMichael.Adler@intel.com rup->ru_nsignals = 0; 4995515SMichael.Adler@intel.com rup->ru_nvcsw = 0; 5008737Skoansin.tan@gmail.com rup->ru_nivcsw = 0; 5013277Sgblack@eecs.umich.edu 5028737Skoansin.tan@gmail.com rup.copyOut(xc->mem); 5033277Sgblack@eecs.umich.edu 5048737Skoansin.tan@gmail.com return SyscallReturn(0); 5053277Sgblack@eecs.umich.edu} 5068737Skoansin.tan@gmail.com 5073113Sgblack@eecs.umich.edu#endif // __SIM_SYSCALL_EMUL_HH__ 5083113Sgblack@eecs.umich.edu