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