syscall_emul.hh revision 7823:dac01f14f20f 
1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Steve Reinhardt
29 *          Kevin Lim
30 */
31
32#ifndef __SIM_SYSCALL_EMUL_HH__
33#define __SIM_SYSCALL_EMUL_HH__
34
35#define NO_STAT64 (defined(__APPLE__) || defined(__OpenBSD__) || \
36                   defined(__FreeBSD__) || defined(__CYGWIN__))
37
38///
39/// @file syscall_emul.hh
40///
41/// This file defines objects used to emulate syscalls from the target
42/// application on the host machine.
43
44#ifdef __CYGWIN32__
45#include <sys/fcntl.h>  // for O_BINARY
46#endif
47#include <sys/stat.h>
48#include <errno.h>
49#include <fcntl.h>
50#include <sys/uio.h>
51#include <sys/time.h>
52
53#include <string>
54
55#include "base/chunk_generator.hh"
56#include "base/intmath.hh"      // for RoundUp
57#include "base/misc.hh"
58#include "base/trace.hh"
59#include "base/types.hh"
60#include "config/the_isa.hh"
61#include "cpu/base.hh"
62#include "cpu/thread_context.hh"
63#include "mem/translating_port.hh"
64#include "mem/page_table.hh"
65#include "sim/byteswap.hh"
66#include "sim/system.hh"
67#include "sim/process.hh"
68
69///
70/// System call descriptor.
71///
72class SyscallDesc {
73
74  public:
75
76    /// Typedef for target syscall handler functions.
77    typedef SyscallReturn (*FuncPtr)(SyscallDesc *, int num,
78                           LiveProcess *, ThreadContext *);
79
80    const char *name;   //!< Syscall name (e.g., "open").
81    FuncPtr funcPtr;    //!< Pointer to emulation function.
82    int flags;          //!< Flags (see Flags enum).
83
84    /// Flag values for controlling syscall behavior.
85    enum Flags {
86        /// Don't set return regs according to funcPtr return value.
87        /// Used for syscalls with non-standard return conventions
88        /// that explicitly set the ThreadContext regs (e.g.,
89        /// sigreturn).
90        SuppressReturnValue = 1
91    };
92
93    /// Constructor.
94    SyscallDesc(const char *_name, FuncPtr _funcPtr, int _flags = 0)
95        : name(_name), funcPtr(_funcPtr), flags(_flags)
96    {
97    }
98
99    /// Emulate the syscall.  Public interface for calling through funcPtr.
100    void doSyscall(int callnum, LiveProcess *proc, ThreadContext *tc);
101};
102
103
104class BaseBufferArg {
105
106  public:
107
108    BaseBufferArg(Addr _addr, int _size) : addr(_addr), size(_size)
109    {
110        bufPtr = new uint8_t[size];
111        // clear out buffer: in case we only partially populate this,
112        // and then do a copyOut(), we want to make sure we don't
113        // introduce any random junk into the simulated address space
114        memset(bufPtr, 0, size);
115    }
116
117    virtual ~BaseBufferArg() { delete [] bufPtr; }
118
119    //
120    // copy data into simulator space (read from target memory)
121    //
122    virtual bool copyIn(TranslatingPort *memport)
123    {
124        memport->readBlob(addr, bufPtr, size);
125        return true;    // no EFAULT detection for now
126    }
127
128    //
129    // copy data out of simulator space (write to target memory)
130    //
131    virtual bool copyOut(TranslatingPort *memport)
132    {
133        memport->writeBlob(addr, bufPtr, size);
134        return true;    // no EFAULT detection for now
135    }
136
137  protected:
138    Addr addr;
139    int size;
140    uint8_t *bufPtr;
141};
142
143
144class BufferArg : public BaseBufferArg
145{
146  public:
147    BufferArg(Addr _addr, int _size) : BaseBufferArg(_addr, _size) { }
148    void *bufferPtr()   { return bufPtr; }
149};
150
151template <class T>
152class TypedBufferArg : public BaseBufferArg
153{
154  public:
155    // user can optionally specify a specific number of bytes to
156    // allocate to deal with those structs that have variable-size
157    // arrays at the end
158    TypedBufferArg(Addr _addr, int _size = sizeof(T))
159        : BaseBufferArg(_addr, _size)
160    { }
161
162    // type case
163    operator T*() { return (T *)bufPtr; }
164
165    // dereference operators
166    T &operator*()       { return *((T *)bufPtr); }
167    T* operator->()      { return (T *)bufPtr; }
168    T &operator[](int i) { return ((T *)bufPtr)[i]; }
169};
170
171//////////////////////////////////////////////////////////////////////
172//
173// The following emulation functions are generic enough that they
174// don't need to be recompiled for different emulated OS's.  They are
175// defined in sim/syscall_emul.cc.
176//
177//////////////////////////////////////////////////////////////////////
178
179
180/// Handler for unimplemented syscalls that we haven't thought about.
181SyscallReturn unimplementedFunc(SyscallDesc *desc, int num,
182                                LiveProcess *p, ThreadContext *tc);
183
184/// Handler for unimplemented syscalls that we never intend to
185/// implement (signal handling, etc.) and should not affect the correct
186/// behavior of the program.  Print a warning only if the appropriate
187/// trace flag is enabled.  Return success to the target program.
188SyscallReturn ignoreFunc(SyscallDesc *desc, int num,
189                         LiveProcess *p, ThreadContext *tc);
190
191/// Target exit() handler: terminate current context.
192SyscallReturn exitFunc(SyscallDesc *desc, int num,
193                       LiveProcess *p, ThreadContext *tc);
194
195/// Target exit_group() handler: terminate simulation. (exit all threads)
196SyscallReturn exitGroupFunc(SyscallDesc *desc, int num,
197                       LiveProcess *p, ThreadContext *tc);
198
199/// Target getpagesize() handler.
200SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num,
201                              LiveProcess *p, ThreadContext *tc);
202
203/// Target brk() handler: set brk address.
204SyscallReturn brkFunc(SyscallDesc *desc, int num,
205                      LiveProcess *p, ThreadContext *tc);
206
207/// Target close() handler.
208SyscallReturn closeFunc(SyscallDesc *desc, int num,
209                        LiveProcess *p, ThreadContext *tc);
210
211/// Target read() handler.
212SyscallReturn readFunc(SyscallDesc *desc, int num,
213                       LiveProcess *p, ThreadContext *tc);
214
215/// Target write() handler.
216SyscallReturn writeFunc(SyscallDesc *desc, int num,
217                        LiveProcess *p, ThreadContext *tc);
218
219/// Target lseek() handler.
220SyscallReturn lseekFunc(SyscallDesc *desc, int num,
221                        LiveProcess *p, ThreadContext *tc);
222
223/// Target _llseek() handler.
224SyscallReturn _llseekFunc(SyscallDesc *desc, int num,
225                        LiveProcess *p, ThreadContext *tc);
226
227/// Target munmap() handler.
228SyscallReturn munmapFunc(SyscallDesc *desc, int num,
229                         LiveProcess *p, ThreadContext *tc);
230
231/// Target gethostname() handler.
232SyscallReturn gethostnameFunc(SyscallDesc *desc, int num,
233                              LiveProcess *p, ThreadContext *tc);
234
235/// Target getcwd() handler.
236SyscallReturn getcwdFunc(SyscallDesc *desc, int num,
237                         LiveProcess *p, ThreadContext *tc);
238
239/// Target unlink() handler.
240SyscallReturn readlinkFunc(SyscallDesc *desc, int num,
241                           LiveProcess *p, ThreadContext *tc);
242
243/// Target unlink() handler.
244SyscallReturn unlinkFunc(SyscallDesc *desc, int num,
245                         LiveProcess *p, ThreadContext *tc);
246
247/// Target mkdir() handler.
248SyscallReturn mkdirFunc(SyscallDesc *desc, int num,
249                        LiveProcess *p, ThreadContext *tc);
250
251/// Target rename() handler.
252SyscallReturn renameFunc(SyscallDesc *desc, int num,
253                         LiveProcess *p, ThreadContext *tc);
254
255
256/// Target truncate() handler.
257SyscallReturn truncateFunc(SyscallDesc *desc, int num,
258                           LiveProcess *p, ThreadContext *tc);
259
260
261/// Target ftruncate() handler.
262SyscallReturn ftruncateFunc(SyscallDesc *desc, int num,
263                            LiveProcess *p, ThreadContext *tc);
264
265
266/// Target truncate64() handler.
267SyscallReturn truncate64Func(SyscallDesc *desc, int num,
268                             LiveProcess *p, ThreadContext *tc);
269
270/// Target ftruncate64() handler.
271SyscallReturn ftruncate64Func(SyscallDesc *desc, int num,
272                              LiveProcess *p, ThreadContext *tc);
273
274
275/// Target umask() handler.
276SyscallReturn umaskFunc(SyscallDesc *desc, int num,
277                        LiveProcess *p, ThreadContext *tc);
278
279
280/// Target chown() handler.
281SyscallReturn chownFunc(SyscallDesc *desc, int num,
282                        LiveProcess *p, ThreadContext *tc);
283
284
285/// Target fchown() handler.
286SyscallReturn fchownFunc(SyscallDesc *desc, int num,
287                         LiveProcess *p, ThreadContext *tc);
288
289/// Target dup() handler.
290SyscallReturn dupFunc(SyscallDesc *desc, int num,
291                      LiveProcess *process, ThreadContext *tc);
292
293/// Target fnctl() handler.
294SyscallReturn fcntlFunc(SyscallDesc *desc, int num,
295                        LiveProcess *process, ThreadContext *tc);
296
297/// Target fcntl64() handler.
298SyscallReturn fcntl64Func(SyscallDesc *desc, int num,
299                        LiveProcess *process, ThreadContext *tc);
300
301/// Target setuid() handler.
302SyscallReturn setuidFunc(SyscallDesc *desc, int num,
303                               LiveProcess *p, ThreadContext *tc);
304
305/// Target getpid() handler.
306SyscallReturn getpidFunc(SyscallDesc *desc, int num,
307                               LiveProcess *p, ThreadContext *tc);
308
309/// Target getuid() handler.
310SyscallReturn getuidFunc(SyscallDesc *desc, int num,
311                               LiveProcess *p, ThreadContext *tc);
312
313/// Target getgid() handler.
314SyscallReturn getgidFunc(SyscallDesc *desc, int num,
315                               LiveProcess *p, ThreadContext *tc);
316
317/// Target getppid() handler.
318SyscallReturn getppidFunc(SyscallDesc *desc, int num,
319                               LiveProcess *p, ThreadContext *tc);
320
321/// Target geteuid() handler.
322SyscallReturn geteuidFunc(SyscallDesc *desc, int num,
323                               LiveProcess *p, ThreadContext *tc);
324
325/// Target getegid() handler.
326SyscallReturn getegidFunc(SyscallDesc *desc, int num,
327                               LiveProcess *p, ThreadContext *tc);
328
329/// Target clone() handler.
330SyscallReturn cloneFunc(SyscallDesc *desc, int num,
331                               LiveProcess *p, ThreadContext *tc);
332
333
334/// Pseudo Funcs  - These functions use a different return convension,
335/// returning a second value in a register other than the normal return register
336SyscallReturn pipePseudoFunc(SyscallDesc *desc, int num,
337                             LiveProcess *process, ThreadContext *tc);
338
339/// Target getpidPseudo() handler.
340SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num,
341                               LiveProcess *p, ThreadContext *tc);
342
343/// Target getuidPseudo() handler.
344SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num,
345                               LiveProcess *p, ThreadContext *tc);
346
347/// Target getgidPseudo() handler.
348SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num,
349                               LiveProcess *p, ThreadContext *tc);
350
351
352/// A readable name for 1,000,000, for converting microseconds to seconds.
353const int one_million = 1000000;
354
355/// Approximate seconds since the epoch (1/1/1970).  About a billion,
356/// by my reckoning.  We want to keep this a constant (not use the
357/// real-world time) to keep simulations repeatable.
358const unsigned seconds_since_epoch = 1000000000;
359
360/// Helper function to convert current elapsed time to seconds and
361/// microseconds.
362template <class T1, class T2>
363void
364getElapsedTime(T1 &sec, T2 &usec)
365{
366    int elapsed_usecs = curTick() / SimClock::Int::us;
367    sec = elapsed_usecs / one_million;
368    usec = elapsed_usecs % one_million;
369}
370
371//////////////////////////////////////////////////////////////////////
372//
373// The following emulation functions are generic, but need to be
374// templated to account for differences in types, constants, etc.
375//
376//////////////////////////////////////////////////////////////////////
377
378#if NO_STAT64
379    typedef struct stat hst_stat;
380    typedef struct stat hst_stat64;
381#else
382    typedef struct stat hst_stat;
383    typedef struct stat64 hst_stat64;
384#endif
385
386//// Helper function to convert a host stat buffer to a target stat
387//// buffer.  Also copies the target buffer out to the simulated
388//// memory space.  Used by stat(), fstat(), and lstat().
389
390template <typename target_stat, typename host_stat>
391static void
392convertStatBuf(target_stat &tgt, host_stat *host, bool fakeTTY = false)
393{
394    using namespace TheISA;
395
396    if (fakeTTY)
397        tgt->st_dev = 0xA;
398    else
399        tgt->st_dev = host->st_dev;
400    tgt->st_dev = htog(tgt->st_dev);
401    tgt->st_ino = host->st_ino;
402    tgt->st_ino = htog(tgt->st_ino);
403    tgt->st_mode = host->st_mode;
404    if (fakeTTY) {
405        // Claim to be a character device
406        tgt->st_mode &= ~S_IFMT;    // Clear S_IFMT
407        tgt->st_mode |= S_IFCHR;    // Set S_IFCHR
408    }
409    tgt->st_mode = htog(tgt->st_mode);
410    tgt->st_nlink = host->st_nlink;
411    tgt->st_nlink = htog(tgt->st_nlink);
412    tgt->st_uid = host->st_uid;
413    tgt->st_uid = htog(tgt->st_uid);
414    tgt->st_gid = host->st_gid;
415    tgt->st_gid = htog(tgt->st_gid);
416    if (fakeTTY)
417        tgt->st_rdev = 0x880d;
418    else
419        tgt->st_rdev = host->st_rdev;
420    tgt->st_rdev = htog(tgt->st_rdev);
421    tgt->st_size = host->st_size;
422    tgt->st_size = htog(tgt->st_size);
423    tgt->st_atimeX = host->st_atime;
424    tgt->st_atimeX = htog(tgt->st_atimeX);
425    tgt->st_mtimeX = host->st_mtime;
426    tgt->st_mtimeX = htog(tgt->st_mtimeX);
427    tgt->st_ctimeX = host->st_ctime;
428    tgt->st_ctimeX = htog(tgt->st_ctimeX);
429    // Force the block size to be 8k. This helps to ensure buffered io works
430    // consistently across different hosts.
431    tgt->st_blksize = 0x2000;
432    tgt->st_blksize = htog(tgt->st_blksize);
433    tgt->st_blocks = host->st_blocks;
434    tgt->st_blocks = htog(tgt->st_blocks);
435}
436
437// Same for stat64
438
439template <typename target_stat, typename host_stat64>
440static void
441convertStat64Buf(target_stat &tgt, host_stat64 *host, bool fakeTTY = false)
442{
443    using namespace TheISA;
444
445    convertStatBuf<target_stat, host_stat64>(tgt, host, fakeTTY);
446#if defined(STAT_HAVE_NSEC)
447    tgt->st_atime_nsec = host->st_atime_nsec;
448    tgt->st_atime_nsec = htog(tgt->st_atime_nsec);
449    tgt->st_mtime_nsec = host->st_mtime_nsec;
450    tgt->st_mtime_nsec = htog(tgt->st_mtime_nsec);
451    tgt->st_ctime_nsec = host->st_ctime_nsec;
452    tgt->st_ctime_nsec = htog(tgt->st_ctime_nsec);
453#else
454    tgt->st_atime_nsec = 0;
455    tgt->st_mtime_nsec = 0;
456    tgt->st_ctime_nsec = 0;
457#endif
458}
459
460//Here are a couple convenience functions
461template<class OS>
462static void
463copyOutStatBuf(TranslatingPort * mem, Addr addr,
464        hst_stat *host, bool fakeTTY = false)
465{
466    typedef TypedBufferArg<typename OS::tgt_stat> tgt_stat_buf;
467    tgt_stat_buf tgt(addr);
468    convertStatBuf<tgt_stat_buf, hst_stat>(tgt, host, fakeTTY);
469    tgt.copyOut(mem);
470}
471
472template<class OS>
473static void
474copyOutStat64Buf(TranslatingPort * mem, Addr addr,
475        hst_stat64 *host, bool fakeTTY = false)
476{
477    typedef TypedBufferArg<typename OS::tgt_stat64> tgt_stat_buf;
478    tgt_stat_buf tgt(addr);
479    convertStat64Buf<tgt_stat_buf, hst_stat64>(tgt, host, fakeTTY);
480    tgt.copyOut(mem);
481}
482
483/// Target ioctl() handler.  For the most part, programs call ioctl()
484/// only to find out if their stdout is a tty, to determine whether to
485/// do line or block buffering.
486template <class OS>
487SyscallReturn
488ioctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
489          ThreadContext *tc)
490{
491    int index = 0;
492    int fd = process->getSyscallArg(tc, index);
493    unsigned req = process->getSyscallArg(tc, index);
494
495    DPRINTF(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", fd, req);
496
497    if (fd < 0 || process->sim_fd(fd) < 0) {
498        // doesn't map to any simulator fd: not a valid target fd
499        return -EBADF;
500    }
501
502    switch (req) {
503      case OS::TIOCISATTY_:
504      case OS::TIOCGETP_:
505      case OS::TIOCSETP_:
506      case OS::TIOCSETN_:
507      case OS::TIOCSETC_:
508      case OS::TIOCGETC_:
509      case OS::TIOCGETS_:
510      case OS::TIOCGETA_:
511      case OS::TCSETAW_:
512        return -ENOTTY;
513
514      default:
515        fatal("Unsupported ioctl call: ioctl(%d, 0x%x, ...) @ \n",
516              fd, req, tc->pcState());
517    }
518}
519
520/// Target open() handler.
521template <class OS>
522SyscallReturn
523openFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
524         ThreadContext *tc)
525{
526    std::string path;
527
528    int index = 0;
529    if (!tc->getMemPort()->tryReadString(path,
530                process->getSyscallArg(tc, index)))
531        return -EFAULT;
532
533    if (path == "/dev/sysdev0") {
534        // This is a memory-mapped high-resolution timer device on Alpha.
535        // We don't support it, so just punt.
536        warn("Ignoring open(%s, ...)\n", path);
537        return -ENOENT;
538    }
539
540    int tgtFlags = process->getSyscallArg(tc, index);
541    int mode = process->getSyscallArg(tc, index);
542    int hostFlags = 0;
543
544    // translate open flags
545    for (int i = 0; i < OS::NUM_OPEN_FLAGS; i++) {
546        if (tgtFlags & OS::openFlagTable[i].tgtFlag) {
547            tgtFlags &= ~OS::openFlagTable[i].tgtFlag;
548            hostFlags |= OS::openFlagTable[i].hostFlag;
549        }
550    }
551
552    // any target flags left?
553    if (tgtFlags != 0)
554        warn("Syscall: open: cannot decode flags 0x%x", tgtFlags);
555
556#ifdef __CYGWIN32__
557    hostFlags |= O_BINARY;
558#endif
559
560    // Adjust path for current working directory
561    path = process->fullPath(path);
562
563    DPRINTF(SyscallVerbose, "opening file %s\n", path.c_str());
564
565    int fd;
566    if (!path.compare(0, 6, "/proc/") || !path.compare(0, 8, "/system/") ||
567        !path.compare(0, 10, "/platform/") || !path.compare(0, 5, "/sys/")) {
568        // It's a proc/sys entery and requires special handling
569        fd = OS::openSpecialFile(path, process, tc);
570        return (fd == -1) ? -1 : process->alloc_fd(fd,path.c_str(),hostFlags,mode, false);
571     } else {
572        // open the file
573        fd = open(path.c_str(), hostFlags, mode);
574        return (fd == -1) ? -errno : process->alloc_fd(fd,path.c_str(),hostFlags,mode, false);
575     }
576
577}
578
579/// Target sysinfo() handler.
580template <class OS>
581SyscallReturn
582sysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
583         ThreadContext *tc)
584{
585
586    int index = 0;
587    TypedBufferArg<typename OS::tgt_sysinfo>
588        sysinfo(process->getSyscallArg(tc, index));
589
590    sysinfo->uptime=seconds_since_epoch;
591    sysinfo->totalram=process->system->memSize();
592
593    sysinfo.copyOut(tc->getMemPort());
594
595    return 0;
596}
597
598/// Target chmod() handler.
599template <class OS>
600SyscallReturn
601chmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
602          ThreadContext *tc)
603{
604    std::string path;
605
606    int index = 0;
607    if (!tc->getMemPort()->tryReadString(path,
608                process->getSyscallArg(tc, index))) {
609        return -EFAULT;
610    }
611
612    uint32_t mode = process->getSyscallArg(tc, index);
613    mode_t hostMode = 0;
614
615    // XXX translate mode flags via OS::something???
616    hostMode = mode;
617
618    // Adjust path for current working directory
619    path = process->fullPath(path);
620
621    // do the chmod
622    int result = chmod(path.c_str(), hostMode);
623    if (result < 0)
624        return -errno;
625
626    return 0;
627}
628
629
630/// Target fchmod() handler.
631template <class OS>
632SyscallReturn
633fchmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
634           ThreadContext *tc)
635{
636    int index = 0;
637    int fd = process->getSyscallArg(tc, index);
638    if (fd < 0 || process->sim_fd(fd) < 0) {
639        // doesn't map to any simulator fd: not a valid target fd
640        return -EBADF;
641    }
642
643    uint32_t mode = process->getSyscallArg(tc, index);
644    mode_t hostMode = 0;
645
646    // XXX translate mode flags via OS::someting???
647    hostMode = mode;
648
649    // do the fchmod
650    int result = fchmod(process->sim_fd(fd), hostMode);
651    if (result < 0)
652        return -errno;
653
654    return 0;
655}
656
657/// Target mremap() handler.
658template <class OS>
659SyscallReturn
660mremapFunc(SyscallDesc *desc, int callnum, LiveProcess *process, ThreadContext *tc)
661{
662    int index = 0;
663    Addr start = process->getSyscallArg(tc, index);
664    uint64_t old_length = process->getSyscallArg(tc, index);
665    uint64_t new_length = process->getSyscallArg(tc, index);
666    uint64_t flags = process->getSyscallArg(tc, index);
667
668    if ((start % TheISA::VMPageSize != 0) ||
669            (new_length % TheISA::VMPageSize != 0)) {
670        warn("mremap failing: arguments not page aligned");
671        return -EINVAL;
672    }
673
674    if (new_length > old_length) {
675        if ((start + old_length) == process->mmap_end) {
676            uint64_t diff = new_length - old_length;
677            process->pTable->allocate(process->mmap_end, diff);
678            process->mmap_end += diff;
679            return start;
680        } else {
681            // sys/mman.h defined MREMAP_MAYMOVE
682            if (!(flags & 1)) {
683                warn("can't remap here and MREMAP_MAYMOVE flag not set\n");
684                return -ENOMEM;
685            } else {
686                process->pTable->remap(start, old_length, process->mmap_end);
687                warn("mremapping to totally new vaddr %08p-%08p, adding %d\n",
688                        process->mmap_end, process->mmap_end + new_length, new_length);
689                start = process->mmap_end;
690                // add on the remaining unallocated pages
691                process->pTable->allocate(start + old_length, new_length - old_length);
692                process->mmap_end += new_length;
693                warn("returning %08p as start\n", start);
694                return start;
695            }
696        }
697    } else {
698        process->pTable->deallocate(start + new_length, old_length -
699                new_length);
700        return start;
701    }
702}
703
704/// Target stat() handler.
705template <class OS>
706SyscallReturn
707statFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
708         ThreadContext *tc)
709{
710    std::string path;
711
712    int index = 0;
713    if (!tc->getMemPort()->tryReadString(path,
714                process->getSyscallArg(tc, index))) {
715        return -EFAULT;
716    }
717    Addr bufPtr = process->getSyscallArg(tc, index);
718
719    // Adjust path for current working directory
720    path = process->fullPath(path);
721
722    struct stat hostBuf;
723    int result = stat(path.c_str(), &hostBuf);
724
725    if (result < 0)
726        return -errno;
727
728    copyOutStatBuf<OS>(tc->getMemPort(), bufPtr, &hostBuf);
729
730    return 0;
731}
732
733
734/// Target stat64() handler.
735template <class OS>
736SyscallReturn
737stat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
738           ThreadContext *tc)
739{
740    std::string path;
741
742    int index = 0;
743    if (!tc->getMemPort()->tryReadString(path,
744                process->getSyscallArg(tc, index)))
745        return -EFAULT;
746    Addr bufPtr = process->getSyscallArg(tc, index);
747
748    // Adjust path for current working directory
749    path = process->fullPath(path);
750
751#if NO_STAT64
752    struct stat  hostBuf;
753    int result = stat(path.c_str(), &hostBuf);
754#else
755    struct stat64 hostBuf;
756    int result = stat64(path.c_str(), &hostBuf);
757#endif
758
759    if (result < 0)
760        return -errno;
761
762    copyOutStat64Buf<OS>(tc->getMemPort(), bufPtr, &hostBuf);
763
764    return 0;
765}
766
767
768/// Target fstat64() handler.
769template <class OS>
770SyscallReturn
771fstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
772            ThreadContext *tc)
773{
774    int index = 0;
775    int fd = process->getSyscallArg(tc, index);
776    Addr bufPtr = process->getSyscallArg(tc, index);
777    if (fd < 0 || process->sim_fd(fd) < 0) {
778        // doesn't map to any simulator fd: not a valid target fd
779        return -EBADF;
780    }
781
782#if NO_STAT64
783    struct stat  hostBuf;
784    int result = fstat(process->sim_fd(fd), &hostBuf);
785#else
786    struct stat64  hostBuf;
787    int result = fstat64(process->sim_fd(fd), &hostBuf);
788#endif
789
790    if (result < 0)
791        return -errno;
792
793    copyOutStat64Buf<OS>(tc->getMemPort(), bufPtr, &hostBuf, (fd == 1));
794
795    return 0;
796}
797
798
799/// Target lstat() handler.
800template <class OS>
801SyscallReturn
802lstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
803          ThreadContext *tc)
804{
805    std::string path;
806
807    int index = 0;
808    if (!tc->getMemPort()->tryReadString(path,
809                process->getSyscallArg(tc, index))) {
810        return -EFAULT;
811    }
812    Addr bufPtr = process->getSyscallArg(tc, index);
813
814    // Adjust path for current working directory
815    path = process->fullPath(path);
816
817    struct stat hostBuf;
818    int result = lstat(path.c_str(), &hostBuf);
819
820    if (result < 0)
821        return -errno;
822
823    copyOutStatBuf<OS>(tc->getMemPort(), bufPtr, &hostBuf);
824
825    return 0;
826}
827
828/// Target lstat64() handler.
829template <class OS>
830SyscallReturn
831lstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
832            ThreadContext *tc)
833{
834    std::string path;
835
836    int index = 0;
837    if (!tc->getMemPort()->tryReadString(path,
838                process->getSyscallArg(tc, index))) {
839        return -EFAULT;
840    }
841    Addr bufPtr = process->getSyscallArg(tc, index);
842
843    // Adjust path for current working directory
844    path = process->fullPath(path);
845
846#if NO_STAT64
847    struct stat hostBuf;
848    int result = lstat(path.c_str(), &hostBuf);
849#else
850    struct stat64 hostBuf;
851    int result = lstat64(path.c_str(), &hostBuf);
852#endif
853
854    if (result < 0)
855        return -errno;
856
857    copyOutStat64Buf<OS>(tc->getMemPort(), bufPtr, &hostBuf);
858
859    return 0;
860}
861
862/// Target fstat() handler.
863template <class OS>
864SyscallReturn
865fstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
866          ThreadContext *tc)
867{
868    int index = 0;
869    int fd = process->sim_fd(process->getSyscallArg(tc, index));
870    Addr bufPtr = process->getSyscallArg(tc, index);
871
872    DPRINTF(SyscallVerbose, "fstat(%d, ...)\n", fd);
873
874    if (fd < 0)
875        return -EBADF;
876
877    struct stat hostBuf;
878    int result = fstat(fd, &hostBuf);
879
880    if (result < 0)
881        return -errno;
882
883    copyOutStatBuf<OS>(tc->getMemPort(), bufPtr, &hostBuf, (fd == 1));
884
885    return 0;
886}
887
888
889/// Target statfs() handler.
890template <class OS>
891SyscallReturn
892statfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
893           ThreadContext *tc)
894{
895    std::string path;
896
897    int index = 0;
898    if (!tc->getMemPort()->tryReadString(path,
899                process->getSyscallArg(tc, index))) {
900        return -EFAULT;
901    }
902    Addr bufPtr = process->getSyscallArg(tc, index);
903
904    // Adjust path for current working directory
905    path = process->fullPath(path);
906
907    struct statfs hostBuf;
908    int result = statfs(path.c_str(), &hostBuf);
909
910    if (result < 0)
911        return -errno;
912
913    OS::copyOutStatfsBuf(tc->getMemPort(), bufPtr, &hostBuf);
914
915    return 0;
916}
917
918
919/// Target fstatfs() handler.
920template <class OS>
921SyscallReturn
922fstatfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
923            ThreadContext *tc)
924{
925    int index = 0;
926    int fd = process->sim_fd(process->getSyscallArg(tc, index));
927    Addr bufPtr = process->getSyscallArg(tc, index);
928
929    if (fd < 0)
930        return -EBADF;
931
932    struct statfs hostBuf;
933    int result = fstatfs(fd, &hostBuf);
934
935    if (result < 0)
936        return -errno;
937
938    OS::copyOutStatfsBuf(tc->getMemPort(), bufPtr, &hostBuf);
939
940    return 0;
941}
942
943
944/// Target writev() handler.
945template <class OS>
946SyscallReturn
947writevFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
948           ThreadContext *tc)
949{
950    int index = 0;
951    int fd = process->getSyscallArg(tc, index);
952    if (fd < 0 || process->sim_fd(fd) < 0) {
953        // doesn't map to any simulator fd: not a valid target fd
954        return -EBADF;
955    }
956
957    TranslatingPort *p = tc->getMemPort();
958    uint64_t tiov_base = process->getSyscallArg(tc, index);
959    size_t count = process->getSyscallArg(tc, index);
960    struct iovec hiov[count];
961    for (size_t i = 0; i < count; ++i) {
962        typename OS::tgt_iovec tiov;
963
964        p->readBlob(tiov_base + i*sizeof(typename OS::tgt_iovec),
965                    (uint8_t*)&tiov, sizeof(typename OS::tgt_iovec));
966        hiov[i].iov_len = gtoh(tiov.iov_len);
967        hiov[i].iov_base = new char [hiov[i].iov_len];
968        p->readBlob(gtoh(tiov.iov_base), (uint8_t *)hiov[i].iov_base,
969                    hiov[i].iov_len);
970    }
971
972    int result = writev(process->sim_fd(fd), hiov, count);
973
974    for (size_t i = 0; i < count; ++i)
975        delete [] (char *)hiov[i].iov_base;
976
977    if (result < 0)
978        return -errno;
979
980    return 0;
981}
982
983
984/// Target mmap() handler.
985///
986/// We don't really handle mmap().  If the target is mmaping an
987/// anonymous region or /dev/zero, we can get away with doing basically
988/// nothing (since memory is initialized to zero and the simulator
989/// doesn't really check addresses anyway).  Always print a warning,
990/// since this could be seriously broken if we're not mapping
991/// /dev/zero.
992//
993/// Someday we should explicitly check for /dev/zero in open, flag the
994/// file descriptor, and fail (or implement!) a non-anonymous mmap to
995/// anything else.
996template <class OS>
997SyscallReturn
998mmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
999{
1000    int index = 0;
1001    Addr start = p->getSyscallArg(tc, index);
1002    uint64_t length = p->getSyscallArg(tc, index);
1003    index++; // int prot = p->getSyscallArg(tc, index);
1004    int flags = p->getSyscallArg(tc, index);
1005    int fd = p->sim_fd(p->getSyscallArg(tc, index));
1006    // int offset = p->getSyscallArg(tc, index);
1007
1008
1009    if ((start  % TheISA::VMPageSize) != 0 ||
1010        (length % TheISA::VMPageSize) != 0) {
1011        warn("mmap failing: arguments not page-aligned: "
1012             "start 0x%x length 0x%x",
1013             start, length);
1014        return -EINVAL;
1015    }
1016
1017    if (start != 0) {
1018        warn("mmap: ignoring suggested map address 0x%x, using 0x%x",
1019             start, p->mmap_end);
1020    }
1021
1022    // pick next address from our "mmap region"
1023    if (OS::mmapGrowsDown()) {
1024        start = p->mmap_end - length;
1025        p->mmap_end = start;
1026    } else {
1027        start = p->mmap_end;
1028        p->mmap_end += length;
1029    }
1030    p->pTable->allocate(start, length);
1031
1032    if (!(flags & OS::TGT_MAP_ANONYMOUS)) {
1033        warn("allowing mmap of file @ fd %d. "
1034             "This will break if not /dev/zero.", fd);
1035    }
1036
1037    return start;
1038}
1039
1040/// Target getrlimit() handler.
1041template <class OS>
1042SyscallReturn
1043getrlimitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
1044        ThreadContext *tc)
1045{
1046    int index = 0;
1047    unsigned resource = process->getSyscallArg(tc, index);
1048    TypedBufferArg<typename OS::rlimit> rlp(process->getSyscallArg(tc, index));
1049
1050    switch (resource) {
1051        case OS::TGT_RLIMIT_STACK:
1052            // max stack size in bytes: make up a number (8MB for now)
1053            rlp->rlim_cur = rlp->rlim_max = 8 * 1024 * 1024;
1054            rlp->rlim_cur = htog(rlp->rlim_cur);
1055            rlp->rlim_max = htog(rlp->rlim_max);
1056            break;
1057
1058        case OS::TGT_RLIMIT_DATA:
1059            // max data segment size in bytes: make up a number
1060            rlp->rlim_cur = rlp->rlim_max = 256 * 1024 * 1024;
1061            rlp->rlim_cur = htog(rlp->rlim_cur);
1062            rlp->rlim_max = htog(rlp->rlim_max);
1063            break;
1064
1065        default:
1066            std::cerr << "getrlimitFunc: unimplemented resource " << resource
1067                << std::endl;
1068            abort();
1069            break;
1070    }
1071
1072    rlp.copyOut(tc->getMemPort());
1073    return 0;
1074}
1075
1076/// Target gettimeofday() handler.
1077template <class OS>
1078SyscallReturn
1079gettimeofdayFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
1080        ThreadContext *tc)
1081{
1082    int index = 0;
1083    TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, index));
1084
1085    getElapsedTime(tp->tv_sec, tp->tv_usec);
1086    tp->tv_sec += seconds_since_epoch;
1087    tp->tv_sec = TheISA::htog(tp->tv_sec);
1088    tp->tv_usec = TheISA::htog(tp->tv_usec);
1089
1090    tp.copyOut(tc->getMemPort());
1091
1092    return 0;
1093}
1094
1095
1096/// Target utimes() handler.
1097template <class OS>
1098SyscallReturn
1099utimesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
1100           ThreadContext *tc)
1101{
1102    std::string path;
1103
1104    int index = 0;
1105    if (!tc->getMemPort()->tryReadString(path,
1106                process->getSyscallArg(tc, index))) {
1107        return -EFAULT;
1108    }
1109
1110    TypedBufferArg<typename OS::timeval [2]>
1111        tp(process->getSyscallArg(tc, index));
1112    tp.copyIn(tc->getMemPort());
1113
1114    struct timeval hostTimeval[2];
1115    for (int i = 0; i < 2; ++i)
1116    {
1117        hostTimeval[i].tv_sec = gtoh((*tp)[i].tv_sec);
1118        hostTimeval[i].tv_usec = gtoh((*tp)[i].tv_usec);
1119    }
1120
1121    // Adjust path for current working directory
1122    path = process->fullPath(path);
1123
1124    int result = utimes(path.c_str(), hostTimeval);
1125
1126    if (result < 0)
1127        return -errno;
1128
1129    return 0;
1130}
1131/// Target getrusage() function.
1132template <class OS>
1133SyscallReturn
1134getrusageFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
1135              ThreadContext *tc)
1136{
1137    int index = 0;
1138    int who = process->getSyscallArg(tc, index); // THREAD, SELF, or CHILDREN
1139    TypedBufferArg<typename OS::rusage> rup(process->getSyscallArg(tc, index));
1140
1141    rup->ru_utime.tv_sec = 0;
1142    rup->ru_utime.tv_usec = 0;
1143    rup->ru_stime.tv_sec = 0;
1144    rup->ru_stime.tv_usec = 0;
1145    rup->ru_maxrss = 0;
1146    rup->ru_ixrss = 0;
1147    rup->ru_idrss = 0;
1148    rup->ru_isrss = 0;
1149    rup->ru_minflt = 0;
1150    rup->ru_majflt = 0;
1151    rup->ru_nswap = 0;
1152    rup->ru_inblock = 0;
1153    rup->ru_oublock = 0;
1154    rup->ru_msgsnd = 0;
1155    rup->ru_msgrcv = 0;
1156    rup->ru_nsignals = 0;
1157    rup->ru_nvcsw = 0;
1158    rup->ru_nivcsw = 0;
1159
1160    switch (who) {
1161      case OS::TGT_RUSAGE_SELF:
1162        getElapsedTime(rup->ru_utime.tv_sec, rup->ru_utime.tv_usec);
1163        rup->ru_utime.tv_sec = htog(rup->ru_utime.tv_sec);
1164        rup->ru_utime.tv_usec = htog(rup->ru_utime.tv_usec);
1165        break;
1166
1167      case OS::TGT_RUSAGE_CHILDREN:
1168        // do nothing.  We have no child processes, so they take no time.
1169        break;
1170
1171      default:
1172        // don't really handle THREAD or CHILDREN, but just warn and
1173        // plow ahead
1174        warn("getrusage() only supports RUSAGE_SELF.  Parameter %d ignored.",
1175             who);
1176    }
1177
1178    rup.copyOut(tc->getMemPort());
1179
1180    return 0;
1181}
1182
1183/// Target times() function.
1184template <class OS>
1185SyscallReturn
1186timesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
1187           ThreadContext *tc)
1188{
1189    int index = 0;
1190    TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, index));
1191
1192    // Fill in the time structure (in clocks)
1193    int64_t clocks = curTick() * OS::M5_SC_CLK_TCK / SimClock::Int::s;
1194    bufp->tms_utime = clocks;
1195    bufp->tms_stime = 0;
1196    bufp->tms_cutime = 0;
1197    bufp->tms_cstime = 0;
1198
1199    // Convert to host endianness
1200    bufp->tms_utime = htog(bufp->tms_utime);
1201
1202    // Write back
1203    bufp.copyOut(tc->getMemPort());
1204
1205    // Return clock ticks since system boot
1206    return clocks;
1207}
1208
1209/// Target time() function.
1210template <class OS>
1211SyscallReturn
1212timeFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
1213           ThreadContext *tc)
1214{
1215    typename OS::time_t sec, usec;
1216    getElapsedTime(sec, usec);
1217    sec += seconds_since_epoch;
1218
1219    int index = 0;
1220    Addr taddr = (Addr)process->getSyscallArg(tc, index);
1221    if(taddr != 0) {
1222        typename OS::time_t t = sec;
1223        t = htog(t);
1224        TranslatingPort *p = tc->getMemPort();
1225        p->writeBlob(taddr, (uint8_t*)&t, (int)sizeof(typename OS::time_t));
1226    }
1227    return sec;
1228}
1229
1230
1231#endif // __SIM_SYSCALL_EMUL_HH__
1232