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