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