src/sim/syscall_emul.hh

   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 #include <errno.h>
  45 #include <string>
  46 #ifdef __CYGWIN32__
  47 #include <sys/fcntl.h>  // for O_BINARY
  48 #endif
  49 #include <sys/stat.h>
  50 #include <fcntl.h>
  51 #include <sys/uio.h>
  52
  53 #include "sim/host.hh"  // for Addr
  54 #include "base/chunk_generator.hh"
  55 #include "base/intmath.hh"      // for RoundUp
  56 #include "base/misc.hh"
  57 #include "base/trace.hh"
  58 #include "cpu/base.hh"
  59 #include "cpu/thread_context.hh"
  60 #include "mem/translating_port.hh"
  61 #include "mem/page_table.hh"
  62 #include "sim/process.hh"
  63
  64 ///
  65 /// System call descriptor.
  66 ///
  67 class SyscallDesc {
  68
  69   public:
  70
  71     /// Typedef for target syscall handler functions.
  72     typedef SyscallReturn (*FuncPtr)(SyscallDesc *, int num,
  73                            LiveProcess *, ThreadContext *);
  74
  75     const char *name;   //!< Syscall name (e.g., "open").
  76     FuncPtr funcPtr;    //!< Pointer to emulation function.
  77     int flags;          //!< Flags (see Flags enum).
  78
  79     /// Flag values for controlling syscall behavior.
  80     enum Flags {
  81         /// Don't set return regs according to funcPtr return value.
  82         /// Used for syscalls with non-standard return conventions
  83         /// that explicitly set the ThreadContext regs (e.g.,
  84         /// sigreturn).
  85         SuppressReturnValue = 1
  86     };
  87
  88     /// Constructor.
  89     SyscallDesc(const char *_name, FuncPtr _funcPtr, int _flags = 0)
  90         : name(_name), funcPtr(_funcPtr), flags(_flags)
  91     {
  92     }
  93
  94     /// Emulate the syscall.  Public interface for calling through funcPtr.
  95     void doSyscall(int callnum, LiveProcess *proc, ThreadContext *tc);
  96 };
  97
  98
  99 class BaseBufferArg {
 100
 101   public:
 102
 103     BaseBufferArg(Addr _addr, int _size) : addr(_addr), size(_size)
 104     {
 105         bufPtr = new uint8_t[size];
 106         // clear out buffer: in case we only partially populate this,
 107         // and then do a copyOut(), we want to make sure we don't
 108         // introduce any random junk into the simulated address space
 109         memset(bufPtr, 0, size);
 110     }
 111
 112     virtual ~BaseBufferArg() { delete [] bufPtr; }
 113
 114     //
 115     // copy data into simulator space (read from target memory)
 116     //
 117     virtual bool copyIn(TranslatingPort *memport)
 118     {
 119         memport->readBlob(addr, bufPtr, size);
 120         return true;    // no EFAULT detection for now
 121     }
 122
 123     //
 124     // copy data out of simulator space (write to target memory)
 125     //
 126     virtual bool copyOut(TranslatingPort *memport)
 127     {
 128         memport->writeBlob(addr, bufPtr, size);
 129         return true;    // no EFAULT detection for now
 130     }
 131
 132   protected:
 133     Addr addr;
 134     int size;
 135     uint8_t *bufPtr;
 136 };
 137
 138
 139 class BufferArg : public BaseBufferArg
 140 {
 141   public:
 142     BufferArg(Addr _addr, int _size) : BaseBufferArg(_addr, _size) { }
 143     void *bufferPtr()   { return bufPtr; }
 144 };
 145
 146 template <class T>
 147 class TypedBufferArg : public BaseBufferArg
 148 {
 149   public:
 150     // user can optionally specify a specific number of bytes to
 151     // allocate to deal with those structs that have variable-size
 152     // arrays at the end
 153     TypedBufferArg(Addr _addr, int _size = sizeof(T))
 154         : BaseBufferArg(_addr, _size)
 155     { }
 156
 157     // type case
 158     operator T*() { return (T *)bufPtr; }
 159
 160     // dereference operators
 161     T &operator*()       { return *((T *)bufPtr); }
 162     T* operator->()      { return (T *)bufPtr; }
 163     T &operator[](int i) { return ((T *)bufPtr)[i]; }
 164 };
 165
 166 //////////////////////////////////////////////////////////////////////
 167 //
 168 // The following emulation functions are generic enough that they
 169 // don't need to be recompiled for different emulated OS's.  They are
 170 // defined in sim/syscall_emul.cc.
 171 //
 172 //////////////////////////////////////////////////////////////////////
 173
 174
 175 /// Handler for unimplemented syscalls that we haven't thought about.
 176 SyscallReturn unimplementedFunc(SyscallDesc *desc, int num,
 177                                 LiveProcess *p, ThreadContext *tc);
 178
 179 /// Handler for unimplemented syscalls that we never intend to
 180 /// implement (signal handling, etc.) and should not affect the correct
 181 /// behavior of the program.  Print a warning only if the appropriate
 182 /// trace flag is enabled.  Return success to the target program.
 183 SyscallReturn ignoreFunc(SyscallDesc *desc, int num,
 184                          LiveProcess *p, ThreadContext *tc);
 185
 186 /// Target exit() handler: terminate simulation.
 187 SyscallReturn exitFunc(SyscallDesc *desc, int num,
 188                        LiveProcess *p, ThreadContext *tc);
 189
 190 /// Target getpagesize() handler.
 191 SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num,
 192                               LiveProcess *p, ThreadContext *tc);
 193
 194 /// Target obreak() handler: set brk address.
 195 SyscallReturn obreakFunc(SyscallDesc *desc, int num,
 196                          LiveProcess *p, ThreadContext *tc);
 197
 198 /// Target close() handler.
 199 SyscallReturn closeFunc(SyscallDesc *desc, int num,
 200                         LiveProcess *p, ThreadContext *tc);
 201
 202 /// Target read() handler.
 203 SyscallReturn readFunc(SyscallDesc *desc, int num,
 204                        LiveProcess *p, ThreadContext *tc);
 205
 206 /// Target write() handler.
 207 SyscallReturn writeFunc(SyscallDesc *desc, int num,
 208                         LiveProcess *p, ThreadContext *tc);
 209
 210 /// Target lseek() handler.
 211 SyscallReturn lseekFunc(SyscallDesc *desc, int num,
 212                         LiveProcess *p, ThreadContext *tc);
 213
 214 /// Target _llseek() handler.
 215 SyscallReturn _llseekFunc(SyscallDesc *desc, int num,
 216                         LiveProcess *p, ThreadContext *tc);
 217
 218 /// Target munmap() handler.
 219 SyscallReturn munmapFunc(SyscallDesc *desc, int num,
 220                          LiveProcess *p, ThreadContext *tc);
 221
 222 /// Target gethostname() handler.
 223 SyscallReturn gethostnameFunc(SyscallDesc *desc, int num,
 224                               LiveProcess *p, ThreadContext *tc);
 225
 226 /// Target unlink() handler.
 227 SyscallReturn unlinkFunc(SyscallDesc *desc, int num,
 228                          LiveProcess *p, ThreadContext *tc);
 229
 230 /// Target rename() handler.
 231 SyscallReturn renameFunc(SyscallDesc *desc, int num,
 232                          LiveProcess *p, ThreadContext *tc);
 233
 234
 235 /// Target truncate() handler.
 236 SyscallReturn truncateFunc(SyscallDesc *desc, int num,
 237                            LiveProcess *p, ThreadContext *tc);
 238
 239
 240 /// Target ftruncate() handler.
 241 SyscallReturn ftruncateFunc(SyscallDesc *desc, int num,
 242                             LiveProcess *p, ThreadContext *tc);
 243
 244
 245 /// Target chown() handler.
 246 SyscallReturn chownFunc(SyscallDesc *desc, int num,
 247                         LiveProcess *p, ThreadContext *tc);
 248
 249
 250 /// Target fchown() handler.
 251 SyscallReturn fchownFunc(SyscallDesc *desc, int num,
 252                          LiveProcess *p, ThreadContext *tc);
 253
 254 /// Target dup() handler.
 255 SyscallReturn dupFunc(SyscallDesc *desc, int num,
 256                       LiveProcess *process, ThreadContext *tc);
 257
 258 /// Target fnctl() handler.
 259 SyscallReturn fcntlFunc(SyscallDesc *desc, int num,
 260                         LiveProcess *process, ThreadContext *tc);
 261
 262 /// Target fcntl64() handler.
 263 SyscallReturn fcntl64Func(SyscallDesc *desc, int num,
 264                         LiveProcess *process, ThreadContext *tc);
 265
 266 /// Target setuid() handler.
 267 SyscallReturn setuidFunc(SyscallDesc *desc, int num,
 268                                LiveProcess *p, ThreadContext *tc);
 269
 270 /// Target getpid() handler.
 271 SyscallReturn getpidFunc(SyscallDesc *desc, int num,
 272                                LiveProcess *p, ThreadContext *tc);
 273
 274 /// Target getuid() handler.
 275 SyscallReturn getuidFunc(SyscallDesc *desc, int num,
 276                                LiveProcess *p, ThreadContext *tc);
 277
 278 /// Target getgid() handler.
 279 SyscallReturn getgidFunc(SyscallDesc *desc, int num,
 280                                LiveProcess *p, ThreadContext *tc);
 281
 282 /// Target getppid() handler.
 283 SyscallReturn getppidFunc(SyscallDesc *desc, int num,
 284                                LiveProcess *p, ThreadContext *tc);
 285
 286 /// Target geteuid() handler.
 287 SyscallReturn geteuidFunc(SyscallDesc *desc, int num,
 288                                LiveProcess *p, ThreadContext *tc);
 289
 290 /// Target getegid() handler.
 291 SyscallReturn getegidFunc(SyscallDesc *desc, int num,
 292                                LiveProcess *p, ThreadContext *tc);
 293
 294
 295
 296 /// Pseudo Funcs  - These functions use a different return convension,
 297 /// returning a second value in a register other than the normal return register
 298 SyscallReturn pipePseudoFunc(SyscallDesc *desc, int num,
 299                              LiveProcess *process, ThreadContext *tc);
 300
 301 /// Target getpidPseudo() handler.
 302 SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num,
 303                                LiveProcess *p, ThreadContext *tc);
 304
 305 /// Target getuidPseudo() handler.
 306 SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num,
 307                                LiveProcess *p, ThreadContext *tc);
 308
 309 /// Target getgidPseudo() handler.
 310 SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num,
 311                                LiveProcess *p, ThreadContext *tc);
 312
 313
 314 /// A readable name for 1,000,000, for converting microseconds to seconds.
 315 const int one_million = 1000000;
 316
 317 /// Approximate seconds since the epoch (1/1/1970).  About a billion,
 318 /// by my reckoning.  We want to keep this a constant (not use the
 319 /// real-world time) to keep simulations repeatable.
 320 const unsigned seconds_since_epoch = 1000000000;
 321
 322 /// Helper function to convert current elapsed time to seconds and
 323 /// microseconds.
 324 template <class T1, class T2>
 325 void
 326 getElapsedTime(T1 &sec, T2 &usec)
 327 {
 328     int elapsed_usecs = curTick / Clock::Int::us;
 329     sec = elapsed_usecs / one_million;
 330     usec = elapsed_usecs % one_million;
 331 }
 332
 333 //////////////////////////////////////////////////////////////////////
 334 //
 335 // The following emulation functions are generic, but need to be
 336 // templated to account for differences in types, constants, etc.
 337 //
 338 //////////////////////////////////////////////////////////////////////
 339
 340 #if NO_STAT64
 341     typedef struct stat hst_stat;
 342     typedef struct stat hst_stat64;
 343 #else
 344     typedef struct stat hst_stat;
 345     typedef struct stat64 hst_stat64;
 346 #endif
 347
 348 //// Helper function to convert a host stat buffer to a target stat
 349 //// buffer.  Also copies the target buffer out to the simulated
 350 //// memory space.  Used by stat(), fstat(), and lstat().
 351
 352 template <typename target_stat, typename host_stat>
 353 static void
 354 convertStatBuf(target_stat &tgt, host_stat *host, bool fakeTTY = false)
 355 {
 356     using namespace TheISA;
 357
 358     if (fakeTTY)
 359         tgt->st_dev = 0xA;
 360     else
 361         tgt->st_dev = host->st_dev;
 362     tgt->st_dev = htog(tgt->st_dev);
 363     tgt->st_ino = host->st_ino;
 364     tgt->st_ino = htog(tgt->st_ino);
 365     tgt->st_mode = host->st_mode;
 366     tgt->st_mode = htog(tgt->st_mode);
 367     tgt->st_nlink = host->st_nlink;
 368     tgt->st_nlink = htog(tgt->st_nlink);
 369     tgt->st_uid = host->st_uid;
 370     tgt->st_uid = htog(tgt->st_uid);
 371     tgt->st_gid = host->st_gid;
 372     tgt->st_gid = htog(tgt->st_gid);
 373     if (fakeTTY)
 374         tgt->st_rdev = 0x880d;
 375     else
 376         tgt->st_rdev = host->st_rdev;
 377     tgt->st_rdev = htog(tgt->st_rdev);
 378     tgt->st_size = host->st_size;
 379     tgt->st_size = htog(tgt->st_size);
 380     tgt->st_atimeX = host->st_atime;
 381     tgt->st_atimeX = htog(tgt->st_atimeX);
 382     tgt->st_mtimeX = host->st_mtime;
 383     tgt->st_mtimeX = htog(tgt->st_mtimeX);
 384     tgt->st_ctimeX = host->st_ctime;
 385     tgt->st_ctimeX = htog(tgt->st_ctimeX);
 386     // Force the block size to be 8k. This helps to ensure buffered io works
 387     // consistently across different hosts.
 388     tgt->st_blksize = 0x2000;
 389     tgt->st_blksize = htog(tgt->st_blksize);
 390     tgt->st_blocks = host->st_blocks;
 391     tgt->st_blocks = htog(tgt->st_blocks);
 392 }
 393
 394 // Same for stat64
 395
 396 template <typename target_stat, typename host_stat64>
 397 static void
 398 convertStat64Buf(target_stat &tgt, host_stat64 *host, bool fakeTTY = false)
 399 {
 400     using namespace TheISA;
 401
 402     convertStatBuf<target_stat, host_stat64>(tgt, host, fakeTTY);
 403 #if defined(STAT_HAVE_NSEC)
 404     tgt->st_atime_nsec = host->st_atime_nsec;
 405     tgt->st_atime_nsec = htog(tgt->st_atime_nsec);
 406     tgt->st_mtime_nsec = host->st_mtime_nsec;
 407     tgt->st_mtime_nsec = htog(tgt->st_mtime_nsec);
 408     tgt->st_ctime_nsec = host->st_ctime_nsec;
 409     tgt->st_ctime_nsec = htog(tgt->st_ctime_nsec);
 410 #else
 411     tgt->st_atime_nsec = 0;
 412     tgt->st_mtime_nsec = 0;
 413     tgt->st_ctime_nsec = 0;
 414 #endif
 415 }
 416
 417 //Here are a couple convenience functions
 418 template<class OS>
 419 static void
 420 copyOutStatBuf(TranslatingPort * mem, Addr addr,
 421         hst_stat *host, bool fakeTTY = false)
 422 {
 423     typedef TypedBufferArg<typename OS::tgt_stat> tgt_stat_buf;
 424     tgt_stat_buf tgt(addr);
 425     convertStatBuf<tgt_stat_buf, hst_stat>(tgt, host, fakeTTY);
 426     tgt.copyOut(mem);
 427 }
 428
 429 template<class OS>
 430 static void
 431 copyOutStat64Buf(TranslatingPort * mem, Addr addr,
 432         hst_stat64 *host, bool fakeTTY = false)
 433 {
 434     typedef TypedBufferArg<typename OS::tgt_stat64> tgt_stat_buf;
 435     tgt_stat_buf tgt(addr);
 436     convertStatBuf<tgt_stat_buf, hst_stat64>(tgt, host, fakeTTY);
 437     tgt.copyOut(mem);
 438 }
 439
 440 /// Target ioctl() handler.  For the most part, programs call ioctl()
 441 /// only to find out if their stdout is a tty, to determine whether to
 442 /// do line or block buffering.
 443 template <class OS>
 444 SyscallReturn
 445 ioctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 446           ThreadContext *tc)
 447 {
 448     int fd = tc->getSyscallArg(0);
 449     unsigned req = tc->getSyscallArg(1);
 450
 451     DPRINTF(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", fd, req);
 452
 453     if (fd < 0 || process->sim_fd(fd) < 0) {
 454         // doesn't map to any simulator fd: not a valid target fd
 455         return -EBADF;
 456     }
 457
 458     switch (req) {
 459       case OS::TIOCISATTY_:
 460       case OS::TIOCGETP_:
 461       case OS::TIOCSETP_:
 462       case OS::TIOCSETN_:
 463       case OS::TIOCSETC_:
 464       case OS::TIOCGETC_:
 465       case OS::TIOCGETS_:
 466       case OS::TIOCGETA_:
 467         return -ENOTTY;
 468
 469       default:
 470         fatal("Unsupported ioctl call: ioctl(%d, 0x%x, ...) @ 0x%llx\n",
 471               fd, req, tc->readPC());
 472     }
 473 }
 474
 475 /// Target open() handler.
 476 template <class OS>
 477 SyscallReturn
 478 openFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 479          ThreadContext *tc)
 480 {
 481     std::string path;
 482
 483     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 484         return -EFAULT;
 485
 486     if (path == "/dev/sysdev0") {
 487         // This is a memory-mapped high-resolution timer device on Alpha.
 488         // We don't support it, so just punt.
 489         warn("Ignoring open(%s, ...)\n", path);
 490         return -ENOENT;
 491     }
 492
 493     int tgtFlags = tc->getSyscallArg(1);
 494     int mode = tc->getSyscallArg(2);
 495     int hostFlags = 0;
 496
 497     // translate open flags
 498     for (int i = 0; i < OS::NUM_OPEN_FLAGS; i++) {
 499         if (tgtFlags & OS::openFlagTable[i].tgtFlag) {
 500             tgtFlags &= ~OS::openFlagTable[i].tgtFlag;
 501             hostFlags |= OS::openFlagTable[i].hostFlag;
 502         }
 503     }
 504
 505     // any target flags left?
 506     if (tgtFlags != 0)
 507         warn("Syscall: open: cannot decode flags 0x%x", tgtFlags);
 508
 509 #ifdef __CYGWIN32__
 510     hostFlags |= O_BINARY;
 511 #endif
 512
 513     // Adjust path for current working directory
 514     path = process->fullPath(path);
 515
 516     DPRINTF(SyscallVerbose, "opening file %s\n", path.c_str());
 517
 518     // open the file
 519     int fd = open(path.c_str(), hostFlags, mode);
 520
 521     return (fd == -1) ? -errno : process->alloc_fd(fd);
 522 }
 523
 524
 525 /// Target chmod() handler.
 526 template <class OS>
 527 SyscallReturn
 528 chmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 529           ThreadContext *tc)
 530 {
 531     std::string path;
 532
 533     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 534         return -EFAULT;
 535
 536     uint32_t mode = tc->getSyscallArg(1);
 537     mode_t hostMode = 0;
 538
 539     // XXX translate mode flags via OS::something???
 540     hostMode = mode;
 541
 542     // Adjust path for current working directory
 543     path = process->fullPath(path);
 544
 545     // do the chmod
 546     int result = chmod(path.c_str(), hostMode);
 547     if (result < 0)
 548         return -errno;
 549
 550     return 0;
 551 }
 552
 553
 554 /// Target fchmod() handler.
 555 template <class OS>
 556 SyscallReturn
 557 fchmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 558            ThreadContext *tc)
 559 {
 560     int fd = tc->getSyscallArg(0);
 561     if (fd < 0 || process->sim_fd(fd) < 0) {
 562         // doesn't map to any simulator fd: not a valid target fd
 563         return -EBADF;
 564     }
 565
 566     uint32_t mode = tc->getSyscallArg(1);
 567     mode_t hostMode = 0;
 568
 569     // XXX translate mode flags via OS::someting???
 570     hostMode = mode;
 571
 572     // do the fchmod
 573     int result = fchmod(process->sim_fd(fd), hostMode);
 574     if (result < 0)
 575         return -errno;
 576
 577     return 0;
 578 }
 579
 580
 581 /// Target stat() handler.
 582 template <class OS>
 583 SyscallReturn
 584 statFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 585          ThreadContext *tc)
 586 {
 587     std::string path;
 588
 589     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 590     return -EFAULT;
 591
 592     // Adjust path for current working directory
 593     path = process->fullPath(path);
 594
 595     struct stat hostBuf;
 596     int result = stat(path.c_str(), &hostBuf);
 597
 598     if (result < 0)
 599         return -errno;
 600
 601     copyOutStatBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 602
 603     return 0;
 604 }
 605
 606
 607 /// Target fstat64() handler.
 608 template <class OS>
 609 SyscallReturn
 610 fstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
 611             ThreadContext *tc)
 612 {
 613     int fd = tc->getSyscallArg(0);
 614     if (fd < 0 || process->sim_fd(fd) < 0) {
 615         // doesn't map to any simulator fd: not a valid target fd
 616         return -EBADF;
 617     }
 618
 619 #if NO_STAT64
 620     struct stat  hostBuf;
 621     int result = fstat(process->sim_fd(fd), &hostBuf);
 622 #else
 623     struct stat64  hostBuf;
 624     int result = fstat64(process->sim_fd(fd), &hostBuf);
 625 #endif
 626
 627     if (result < 0)
 628         return -errno;
 629
 630     copyOutStat64Buf<OS>(tc->getMemPort(), tc->getSyscallArg(1),
 631         &hostBuf, (fd == 1));
 632
 633     return 0;
 634 }
 635
 636
 637 /// Target lstat() handler.
 638 template <class OS>
 639 SyscallReturn
 640 lstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 641           ThreadContext *tc)
 642 {
 643     std::string path;
 644
 645     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 646       return -EFAULT;
 647
 648     // Adjust path for current working directory
 649     path = process->fullPath(path);
 650
 651     struct stat hostBuf;
 652     int result = lstat(path.c_str(), &hostBuf);
 653
 654     if (result < 0)
 655         return -errno;
 656
 657     copyOutStatBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 658
 659     return 0;
 660 }
 661
 662 /// Target lstat64() handler.
 663 template <class OS>
 664 SyscallReturn
 665 lstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
 666             ThreadContext *tc)
 667 {
 668     std::string path;
 669
 670     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 671       return -EFAULT;
 672
 673     // Adjust path for current working directory
 674     path = process->fullPath(path);
 675
 676 #if NO_STAT64
 677     struct stat hostBuf;
 678     int result = lstat(path.c_str(), &hostBuf);
 679 #else
 680     struct stat64 hostBuf;
 681     int result = lstat64(path.c_str(), &hostBuf);
 682 #endif
 683
 684     if (result < 0)
 685         return -errno;
 686
 687     copyOutStat64Buf<OS>(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 688
 689     return 0;
 690 }
 691
 692 /// Target fstat() handler.
 693 template <class OS>
 694 SyscallReturn
 695 fstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 696           ThreadContext *tc)
 697 {
 698     int fd = process->sim_fd(tc->getSyscallArg(0));
 699
 700     DPRINTF(SyscallVerbose, "fstat(%d, ...)\n", fd);
 701
 702     if (fd < 0)
 703         return -EBADF;
 704
 705     struct stat hostBuf;
 706     int result = fstat(fd, &hostBuf);
 707
 708     if (result < 0)
 709         return -errno;
 710
 711     copyOutStatBuf<OS>(tc->getMemPort(), tc->getSyscallArg(1),
 712         &hostBuf, (fd == 1));
 713
 714     return 0;
 715 }
 716
 717
 718 /// Target statfs() handler.
 719 template <class OS>
 720 SyscallReturn
 721 statfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 722            ThreadContext *tc)
 723 {
 724     std::string path;
 725
 726     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 727       return -EFAULT;
 728
 729     // Adjust path for current working directory
 730     path = process->fullPath(path);
 731
 732     struct statfs hostBuf;
 733     int result = statfs(path.c_str(), &hostBuf);
 734
 735     if (result < 0)
 736         return -errno;
 737
 738     OS::copyOutStatfsBuf(tc->getMemPort(),
 739             (Addr)(tc->getSyscallArg(1)), &hostBuf);
 740
 741     return 0;
 742 }
 743
 744
 745 /// Target fstatfs() handler.
 746 template <class OS>
 747 SyscallReturn
 748 fstatfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 749             ThreadContext *tc)
 750 {
 751     int fd = process->sim_fd(tc->getSyscallArg(0));
 752
 753     if (fd < 0)
 754         return -EBADF;
 755
 756     struct statfs hostBuf;
 757     int result = fstatfs(fd, &hostBuf);
 758
 759     if (result < 0)
 760         return -errno;
 761
 762     OS::copyOutStatfsBuf(tc->getMemPort(), tc->getSyscallArg(1),
 763         &hostBuf);
 764
 765     return 0;
 766 }
 767
 768
 769 /// Target writev() handler.
 770 template <class OS>
 771 SyscallReturn
 772 writevFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 773            ThreadContext *tc)
 774 {
 775     int fd = tc->getSyscallArg(0);
 776     if (fd < 0 || process->sim_fd(fd) < 0) {
 777         // doesn't map to any simulator fd: not a valid target fd
 778         return -EBADF;
 779     }
 780
 781     TranslatingPort *p = tc->getMemPort();
 782     uint64_t tiov_base = tc->getSyscallArg(1);
 783     size_t count = tc->getSyscallArg(2);
 784     struct iovec hiov[count];
 785     for (int i = 0; i < count; ++i)
 786     {
 787         typename OS::tgt_iovec tiov;
 788
 789         p->readBlob(tiov_base + i*sizeof(typename OS::tgt_iovec),
 790                     (uint8_t*)&tiov, sizeof(typename OS::tgt_iovec));
 791         hiov[i].iov_len = gtoh(tiov.iov_len);
 792         hiov[i].iov_base = new char [hiov[i].iov_len];
 793         p->readBlob(gtoh(tiov.iov_base), (uint8_t *)hiov[i].iov_base,
 794                     hiov[i].iov_len);
 795     }
 796
 797     int result = writev(process->sim_fd(fd), hiov, count);
 798
 799     for (int i = 0; i < count; ++i)
 800     {
 801         delete [] (char *)hiov[i].iov_base;
 802     }
 803
 804     if (result < 0)
 805         return -errno;
 806
 807     return 0;
 808 }
 809
 810
 811 /// Target mmap() handler.
 812 ///
 813 /// We don't really handle mmap().  If the target is mmaping an
 814 /// anonymous region or /dev/zero, we can get away with doing basically
 815 /// nothing (since memory is initialized to zero and the simulator
 816 /// doesn't really check addresses anyway).  Always print a warning,
 817 /// since this could be seriously broken if we're not mapping
 818 /// /dev/zero.
 819 //
 820 /// Someday we should explicitly check for /dev/zero in open, flag the
 821 /// file descriptor, and fail (or implement!) a non-anonymous mmap to
 822 /// anything else.
 823 template <class OS>
 824 SyscallReturn
 825 mmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 826 {
 827     Addr start = tc->getSyscallArg(0);
 828     uint64_t length = tc->getSyscallArg(1);
 829     // int prot = tc->getSyscallArg(2);
 830     int flags = tc->getSyscallArg(3);
 831     // int fd = p->sim_fd(tc->getSyscallArg(4));
 832     // int offset = tc->getSyscallArg(5);
 833
 834     if ((start  % TheISA::VMPageSize) != 0 ||
 835         (length % TheISA::VMPageSize) != 0) {
 836         warn("mmap failing: arguments not page-aligned: "
 837              "start 0x%x length 0x%x",
 838              start, length);
 839         return -EINVAL;
 840     }
 841
 842     if (start != 0) {
 843         warn("mmap: ignoring suggested map address 0x%x, using 0x%x",
 844              start, p->mmap_end);
 845     }
 846
 847     // pick next address from our "mmap region"
 848     start = p->mmap_end;
 849     p->pTable->allocate(start, length);
 850     p->mmap_end += length;
 851
 852     if (!(flags & OS::TGT_MAP_ANONYMOUS)) {
 853         warn("allowing mmap of file @ fd %d. "
 854              "This will break if not /dev/zero.", tc->getSyscallArg(4));
 855     }
 856
 857     return start;
 858 }
 859
 860 /// Target getrlimit() handler.
 861 template <class OS>
 862 SyscallReturn
 863 getrlimitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 864         ThreadContext *tc)
 865 {
 866     unsigned resource = tc->getSyscallArg(0);
 867     TypedBufferArg<typename OS::rlimit> rlp(tc->getSyscallArg(1));
 868
 869     switch (resource) {
 870         case OS::TGT_RLIMIT_STACK:
 871             // max stack size in bytes: make up a number (2MB for now)
 872             rlp->rlim_cur = rlp->rlim_max = 8 * 1024 * 1024;
 873             rlp->rlim_cur = htog(rlp->rlim_cur);
 874             rlp->rlim_max = htog(rlp->rlim_max);
 875             break;
 876
 877         default:
 878             std::cerr << "getrlimitFunc: unimplemented resource " << resource
 879                 << std::endl;
 880             abort();
 881             break;
 882     }
 883
 884     rlp.copyOut(tc->getMemPort());
 885     return 0;
 886 }
 887
 888 /// Target gettimeofday() handler.
 889 template <class OS>
 890 SyscallReturn
 891 gettimeofdayFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 892         ThreadContext *tc)
 893 {
 894     TypedBufferArg<typename OS::timeval> tp(tc->getSyscallArg(0));
 895
 896     getElapsedTime(tp->tv_sec, tp->tv_usec);
 897     tp->tv_sec += seconds_since_epoch;
 898     tp->tv_sec = htog(tp->tv_sec);
 899     tp->tv_usec = htog(tp->tv_usec);
 900
 901     tp.copyOut(tc->getMemPort());
 902
 903     return 0;
 904 }
 905
 906
 907 /// Target utimes() handler.
 908 template <class OS>
 909 SyscallReturn
 910 utimesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 911            ThreadContext *tc)
 912 {
 913     std::string path;
 914
 915     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 916       return -EFAULT;
 917
 918     TypedBufferArg<typename OS::timeval [2]> tp(tc->getSyscallArg(1));
 919     tp.copyIn(tc->getMemPort());
 920
 921     struct timeval hostTimeval[2];
 922     for (int i = 0; i < 2; ++i)
 923     {
 924         hostTimeval[i].tv_sec = gtoh((*tp)[i].tv_sec);
 925         hostTimeval[i].tv_usec = gtoh((*tp)[i].tv_usec);
 926     }
 927
 928     // Adjust path for current working directory
 929     path = process->fullPath(path);
 930
 931     int result = utimes(path.c_str(), hostTimeval);
 932
 933     if (result < 0)
 934         return -errno;
 935
 936     return 0;
 937 }
 938 /// Target getrusage() function.
 939 template <class OS>
 940 SyscallReturn
 941 getrusageFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 942               ThreadContext *tc)
 943 {
 944     int who = tc->getSyscallArg(0);     // THREAD, SELF, or CHILDREN
 945     TypedBufferArg<typename OS::rusage> rup(tc->getSyscallArg(1));
 946
 947     rup->ru_utime.tv_sec = 0;
 948     rup->ru_utime.tv_usec = 0;
 949     rup->ru_stime.tv_sec = 0;
 950     rup->ru_stime.tv_usec = 0;
 951     rup->ru_maxrss = 0;
 952     rup->ru_ixrss = 0;
 953     rup->ru_idrss = 0;
 954     rup->ru_isrss = 0;
 955     rup->ru_minflt = 0;
 956     rup->ru_majflt = 0;
 957     rup->ru_nswap = 0;
 958     rup->ru_inblock = 0;
 959     rup->ru_oublock = 0;
 960     rup->ru_msgsnd = 0;
 961     rup->ru_msgrcv = 0;
 962     rup->ru_nsignals = 0;
 963     rup->ru_nvcsw = 0;
 964     rup->ru_nivcsw = 0;
 965
 966     switch (who) {
 967       case OS::TGT_RUSAGE_SELF:
 968         getElapsedTime(rup->ru_utime.tv_sec, rup->ru_utime.tv_usec);
 969         rup->ru_utime.tv_sec = htog(rup->ru_utime.tv_sec);
 970         rup->ru_utime.tv_usec = htog(rup->ru_utime.tv_usec);
 971         break;
 972
 973       case OS::TGT_RUSAGE_CHILDREN:
 974         // do nothing.  We have no child processes, so they take no time.
 975         break;
 976
 977       default:
 978         // don't really handle THREAD or CHILDREN, but just warn and
 979         // plow ahead
 980         warn("getrusage() only supports RUSAGE_SELF.  Parameter %d ignored.",
 981              who);
 982     }
 983
 984     rup.copyOut(tc->getMemPort());
 985
 986     return 0;
 987 }
 988
 989
 990
 991
 992 #endif // __SIM_SYSCALL_EMUL_HH__