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