src/sim/syscall_emul.hh

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