src/sim/syscall_emul.cc

   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  *          Ali Saidi
  30  */
  31
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34
  35 #include <cstdio>
  36 #include <iostream>
  37 #include <string>
  38
  39 #include "arch/utility.hh"
  40 #include "sim/syscall_emul.hh"
  41 #include "base/chunk_generator.hh"
  42 #include "base/trace.hh"
  43 #include "config/the_isa.hh"
  44 #include "cpu/thread_context.hh"
  45 #include "cpu/base.hh"
  46 #include "mem/page_table.hh"
  47 #include "sim/process.hh"
  48 #include "sim/system.hh"
  49 #include "sim/sim_exit.hh"
  50
  51 using namespace std;
  52 using namespace TheISA;
  53
  54 void
  55 SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc)
  56 {
  57 #if TRACING_ON
  58     int index = 0;
  59 #endif
  60     DPRINTFR(SyscallVerbose,
  61              "%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n",
  62              curTick(), tc->getCpuPtr()->name(), name,
  63              process->getSyscallArg(tc, index),
  64              process->getSyscallArg(tc, index),
  65              process->getSyscallArg(tc, index),
  66              process->getSyscallArg(tc, index));
  67
  68     SyscallReturn retval = (*funcPtr)(this, callnum, process, tc);
  69
  70     DPRINTFR(SyscallVerbose, "%d: %s: syscall %s returns %d\n",
  71              curTick(),tc->getCpuPtr()->name(), name, retval.value());
  72
  73     if (!(flags & SyscallDesc::SuppressReturnValue))
  74         process->setSyscallReturn(tc, retval);
  75 }
  76
  77
  78 SyscallReturn
  79 unimplementedFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
  80                   ThreadContext *tc)
  81 {
  82     fatal("syscall %s (#%d) unimplemented.", desc->name, callnum);
  83
  84     return 1;
  85 }
  86
  87
  88 SyscallReturn
  89 ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
  90            ThreadContext *tc)
  91 {
  92     int index = 0;
  93     warn("ignoring syscall %s(%d, %d, ...)", desc->name,
  94          process->getSyscallArg(tc, index), process->getSyscallArg(tc, index));
  95
  96     return 0;
  97 }
  98
  99
 100 SyscallReturn
 101 exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 102          ThreadContext *tc)
 103 {
 104     if (process->system->numRunningContexts() == 1) {
 105         // Last running context... exit simulator
 106         int index = 0;
 107         exitSimLoop("target called exit()",
 108                     process->getSyscallArg(tc, index) & 0xff);
 109     } else {
 110         // other running threads... just halt this one
 111         tc->halt();
 112     }
 113
 114     return 1;
 115 }
 116
 117
 118 SyscallReturn
 119 exitGroupFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 120               ThreadContext *tc)
 121 {
 122     // really should just halt all thread contexts belonging to this
 123     // process in case there's another process running...
 124     int index = 0;
 125     exitSimLoop("target called exit()",
 126                 process->getSyscallArg(tc, index) & 0xff);
 127
 128     return 1;
 129 }
 130
 131
 132 SyscallReturn
 133 getpagesizeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 134 {
 135     return (int)VMPageSize;
 136 }
 137
 138
 139 SyscallReturn
 140 brkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 141 {
 142     // change brk addr to first arg
 143     int index = 0;
 144     Addr new_brk = p->getSyscallArg(tc, index);
 145
 146     // in Linux at least, brk(0) returns the current break value
 147     // (note that the syscall and the glibc function have different behavior)
 148     if (new_brk == 0)
 149         return p->brk_point;
 150
 151     if (new_brk > p->brk_point) {
 152         // might need to allocate some new pages
 153         for (ChunkGenerator gen(p->brk_point, new_brk - p->brk_point,
 154                                 VMPageSize); !gen.done(); gen.next()) {
 155             if (!p->pTable->translate(gen.addr()))
 156                 p->pTable->allocate(roundDown(gen.addr(), VMPageSize),
 157                                     VMPageSize);
 158
 159             // if the address is already there, zero it out
 160             else {
 161                 uint8_t zero  = 0;
 162                 TranslatingPort *tp = tc->getMemPort();
 163
 164                 // split non-page aligned accesses
 165                 Addr next_page = roundUp(gen.addr(), VMPageSize);
 166                 uint32_t size_needed = next_page - gen.addr();
 167                 tp->memsetBlob(gen.addr(), zero, size_needed);
 168                 if (gen.addr() + VMPageSize > next_page &&
 169                     next_page < new_brk &&
 170                     p->pTable->translate(next_page))
 171                 {
 172                     size_needed = VMPageSize - size_needed;
 173                     tp->memsetBlob(next_page, zero, size_needed);
 174                 }
 175             }
 176         }
 177     }
 178
 179     p->brk_point = new_brk;
 180     DPRINTF(SyscallVerbose, "Break Point changed to: %#X\n", p->brk_point);
 181     return p->brk_point;
 182 }
 183
 184
 185 SyscallReturn
 186 closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 187 {
 188     int index = 0;
 189     int target_fd = p->getSyscallArg(tc, index);
 190     int sim_fd = p->sim_fd(target_fd);
 191     int status = 0;
 192     if (sim_fd > 2)
 193         status = close(sim_fd);
 194     if (status >= 0)
 195         p->free_fd(target_fd);
 196     return status;
 197 }
 198
 199
 200 SyscallReturn
 201 readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 202 {
 203     int index = 0;
 204     int fd = p->sim_fd(p->getSyscallArg(tc, index));
 205     Addr bufPtr = p->getSyscallArg(tc, index);
 206     int nbytes = p->getSyscallArg(tc, index);
 207     BufferArg bufArg(bufPtr, nbytes);
 208
 209     int bytes_read = read(fd, bufArg.bufferPtr(), nbytes);
 210
 211     if (bytes_read != -1)
 212         bufArg.copyOut(tc->getMemPort());
 213
 214     return bytes_read;
 215 }
 216
 217 SyscallReturn
 218 writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 219 {
 220     int index = 0;
 221     int fd = p->sim_fd(p->getSyscallArg(tc, index));
 222     Addr bufPtr = p->getSyscallArg(tc, index);
 223     int nbytes = p->getSyscallArg(tc, index);
 224     BufferArg bufArg(bufPtr, nbytes);
 225
 226     bufArg.copyIn(tc->getMemPort());
 227
 228     int bytes_written = write(fd, bufArg.bufferPtr(), nbytes);
 229
 230     fsync(fd);
 231
 232     return bytes_written;
 233 }
 234
 235
 236 SyscallReturn
 237 lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 238 {
 239     int index = 0;
 240     int fd = p->sim_fd(p->getSyscallArg(tc, index));
 241     uint64_t offs = p->getSyscallArg(tc, index);
 242     int whence = p->getSyscallArg(tc, index);
 243
 244     off_t result = lseek(fd, offs, whence);
 245
 246     return (result == (off_t)-1) ? -errno : result;
 247 }
 248
 249
 250 SyscallReturn
 251 _llseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 252 {
 253     int index = 0;
 254     int fd = p->sim_fd(p->getSyscallArg(tc, index));
 255     uint64_t offset_high = p->getSyscallArg(tc, index);
 256     uint32_t offset_low = p->getSyscallArg(tc, index);
 257     Addr result_ptr = p->getSyscallArg(tc, index);
 258     int whence = p->getSyscallArg(tc, index);
 259
 260     uint64_t offset = (offset_high << 32) | offset_low;
 261
 262     uint64_t result = lseek(fd, offset, whence);
 263     result = TheISA::htog(result);
 264
 265     if (result == (off_t)-1) {
 266         //The seek failed.
 267         return -errno;
 268     } else {
 269         // The seek succeeded.
 270         // Copy "result" to "result_ptr"
 271         // XXX We'll assume that the size of loff_t is 64 bits on the
 272         // target platform
 273         BufferArg result_buf(result_ptr, sizeof(result));
 274         memcpy(result_buf.bufferPtr(), &result, sizeof(result));
 275         result_buf.copyOut(tc->getMemPort());
 276         return 0;
 277     }
 278
 279
 280     return (result == (off_t)-1) ? -errno : result;
 281 }
 282
 283
 284 SyscallReturn
 285 munmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 286 {
 287     // given that we don't really implement mmap, munmap is really easy
 288     return 0;
 289 }
 290
 291
 292 const char *hostname = "m5.eecs.umich.edu";
 293
 294 SyscallReturn
 295 gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 296 {
 297     int index = 0;
 298     Addr bufPtr = p->getSyscallArg(tc, index);
 299     int name_len = p->getSyscallArg(tc, index);
 300     BufferArg name(bufPtr, name_len);
 301
 302     strncpy((char *)name.bufferPtr(), hostname, name_len);
 303
 304     name.copyOut(tc->getMemPort());
 305
 306     return 0;
 307 }
 308
 309 SyscallReturn
 310 getcwdFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 311 {
 312     int result = 0;
 313     int index = 0;
 314     Addr bufPtr = p->getSyscallArg(tc, index);
 315     unsigned long size = p->getSyscallArg(tc, index);
 316     BufferArg buf(bufPtr, size);
 317
 318     // Is current working directory defined?
 319     string cwd = p->getcwd();
 320     if (!cwd.empty()) {
 321         if (cwd.length() >= size) {
 322             // Buffer too small
 323             return -ERANGE;
 324         }
 325         strncpy((char *)buf.bufferPtr(), cwd.c_str(), size);
 326         result = cwd.length();
 327     }
 328     else {
 329         if (getcwd((char *)buf.bufferPtr(), size) != NULL) {
 330             result = strlen((char *)buf.bufferPtr());
 331         }
 332         else {
 333             result = -1;
 334         }
 335     }
 336
 337     buf.copyOut(tc->getMemPort());
 338
 339     return (result == -1) ? -errno : result;
 340 }
 341
 342
 343 SyscallReturn
 344 readlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 345 {
 346     string path;
 347
 348     int index = 0;
 349     if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
 350         return (TheISA::IntReg)-EFAULT;
 351
 352     // Adjust path for current working directory
 353     path = p->fullPath(path);
 354
 355     Addr bufPtr = p->getSyscallArg(tc, index);
 356     size_t bufsiz = p->getSyscallArg(tc, index);
 357
 358     BufferArg buf(bufPtr, bufsiz);
 359
 360     int result = readlink(path.c_str(), (char *)buf.bufferPtr(), bufsiz);
 361
 362     buf.copyOut(tc->getMemPort());
 363
 364     return (result == -1) ? -errno : result;
 365 }
 366
 367 SyscallReturn
 368 unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 369 {
 370     string path;
 371
 372     int index = 0;
 373     if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
 374         return (TheISA::IntReg)-EFAULT;
 375
 376     // Adjust path for current working directory
 377     path = p->fullPath(path);
 378
 379     int result = unlink(path.c_str());
 380     return (result == -1) ? -errno : result;
 381 }
 382
 383
 384 SyscallReturn
 385 mkdirFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 386 {
 387     string path;
 388
 389     int index = 0;
 390     if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
 391         return (TheISA::IntReg)-EFAULT;
 392
 393     // Adjust path for current working directory
 394     path = p->fullPath(path);
 395
 396     mode_t mode = p->getSyscallArg(tc, index);
 397
 398     int result = mkdir(path.c_str(), mode);
 399     return (result == -1) ? -errno : result;
 400 }
 401
 402 SyscallReturn
 403 renameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 404 {
 405     string old_name;
 406
 407     int index = 0;
 408     if (!tc->getMemPort()->tryReadString(old_name, p->getSyscallArg(tc, index)))
 409         return -EFAULT;
 410
 411     string new_name;
 412
 413     if (!tc->getMemPort()->tryReadString(new_name, p->getSyscallArg(tc, index)))
 414         return -EFAULT;
 415
 416     // Adjust path for current working directory
 417     old_name = p->fullPath(old_name);
 418     new_name = p->fullPath(new_name);
 419
 420     int64_t result = rename(old_name.c_str(), new_name.c_str());
 421     return (result == -1) ? -errno : result;
 422 }
 423
 424 SyscallReturn
 425 truncateFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 426 {
 427     string path;
 428
 429     int index = 0;
 430     if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
 431         return -EFAULT;
 432
 433     off_t length = p->getSyscallArg(tc, index);
 434
 435     // Adjust path for current working directory
 436     path = p->fullPath(path);
 437
 438     int result = truncate(path.c_str(), length);
 439     return (result == -1) ? -errno : result;
 440 }
 441
 442 SyscallReturn
 443 ftruncateFunc(SyscallDesc *desc, int num,
 444               LiveProcess *process, ThreadContext *tc)
 445 {
 446     int index = 0;
 447     int fd = process->sim_fd(process->getSyscallArg(tc, index));
 448
 449     if (fd < 0)
 450         return -EBADF;
 451
 452     off_t length = process->getSyscallArg(tc, index);
 453
 454     int result = ftruncate(fd, length);
 455     return (result == -1) ? -errno : result;
 456 }
 457
 458 SyscallReturn
 459 truncate64Func(SyscallDesc *desc, int num,
 460                 LiveProcess *process, ThreadContext *tc)
 461 {
 462     int index = 0;
 463     string path;
 464
 465     if (!tc->getMemPort()->tryReadString(path, process->getSyscallArg(tc, index)))
 466        return -EFAULT;
 467
 468     int64_t length = process->getSyscallArg(tc, index, 64);
 469
 470     // Adjust path for current working directory
 471     path = process->fullPath(path);
 472
 473 #if NO_STAT64
 474     int result = truncate(path.c_str(), length);
 475 #else
 476     int result = truncate64(path.c_str(), length);
 477 #endif
 478     return (result == -1) ? -errno : result;
 479 }
 480
 481 SyscallReturn
 482 ftruncate64Func(SyscallDesc *desc, int num,
 483                 LiveProcess *process, ThreadContext *tc)
 484 {
 485     int index = 0;
 486     int fd = process->sim_fd(process->getSyscallArg(tc, index));
 487
 488     if (fd < 0)
 489         return -EBADF;
 490
 491     int64_t length = process->getSyscallArg(tc, index, 64);
 492
 493 #if NO_STAT64
 494     int result = ftruncate(fd, length);
 495 #else
 496     int result = ftruncate64(fd, length);
 497 #endif
 498     return (result == -1) ? -errno : result;
 499 }
 500
 501 SyscallReturn
 502 umaskFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
 503 {
 504     // Letting the simulated program change the simulator's umask seems like
 505     // a bad idea.  Compromise by just returning the current umask but not
 506     // changing anything.
 507     mode_t oldMask = umask(0);
 508     umask(oldMask);
 509     return (int)oldMask;
 510 }
 511
 512 SyscallReturn
 513 chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
 514 {
 515     string path;
 516
 517     int index = 0;
 518     if (!tc->getMemPort()->tryReadString(path, p->getSyscallArg(tc, index)))
 519         return -EFAULT;
 520
 521     /* XXX endianess */
 522     uint32_t owner = p->getSyscallArg(tc, index);
 523     uid_t hostOwner = owner;
 524     uint32_t group = p->getSyscallArg(tc, index);
 525     gid_t hostGroup = group;
 526
 527     // Adjust path for current working directory
 528     path = p->fullPath(path);
 529
 530     int result = chown(path.c_str(), hostOwner, hostGroup);
 531     return (result == -1) ? -errno : result;
 532 }
 533
 534 SyscallReturn
 535 fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
 536 {
 537     int index = 0;
 538     int fd = process->sim_fd(process->getSyscallArg(tc, index));
 539
 540     if (fd < 0)
 541         return -EBADF;
 542
 543     /* XXX endianess */
 544     uint32_t owner = process->getSyscallArg(tc, index);
 545     uid_t hostOwner = owner;
 546     uint32_t group = process->getSyscallArg(tc, index);
 547     gid_t hostGroup = group;
 548
 549     int result = fchown(fd, hostOwner, hostGroup);
 550     return (result == -1) ? -errno : result;
 551 }
 552
 553
 554 SyscallReturn
 555 dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
 556 {
 557     int index = 0;
 558     int fd = process->sim_fd(process->getSyscallArg(tc, index));
 559     if (fd < 0)
 560         return -EBADF;
 561
 562     Process::FdMap *fdo = process->sim_fd_obj(fd);
 563
 564     int result = dup(fd);
 565     return (result == -1) ? -errno :
 566         process->alloc_fd(result, fdo->filename, fdo->flags, fdo->mode, false);
 567 }
 568
 569
 570 SyscallReturn
 571 fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process,
 572           ThreadContext *tc)
 573 {
 574     int index = 0;
 575     int fd = process->getSyscallArg(tc, index);
 576
 577     if (fd < 0 || process->sim_fd(fd) < 0)
 578         return -EBADF;
 579
 580     int cmd = process->getSyscallArg(tc, index);
 581     switch (cmd) {
 582       case 0: // F_DUPFD
 583         // if we really wanted to support this, we'd need to do it
 584         // in the target fd space.
 585         warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd);
 586         return -EMFILE;
 587
 588       case 1: // F_GETFD (get close-on-exec flag)
 589       case 2: // F_SETFD (set close-on-exec flag)
 590         return 0;
 591
 592       case 3: // F_GETFL (get file flags)
 593       case 4: // F_SETFL (set file flags)
 594         // not sure if this is totally valid, but we'll pass it through
 595         // to the underlying OS
 596         warn("fcntl(%d, %d) passed through to host\n", fd, cmd);
 597         return fcntl(process->sim_fd(fd), cmd);
 598         // return 0;
 599
 600       case 7: // F_GETLK  (get lock)
 601       case 8: // F_SETLK  (set lock)
 602       case 9: // F_SETLKW (set lock and wait)
 603         // don't mess with file locking... just act like it's OK
 604         warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd);
 605         return 0;
 606
 607       default:
 608         warn("Unknown fcntl command %d\n", cmd);
 609         return 0;
 610     }
 611 }
 612
 613 SyscallReturn
 614 fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process,
 615             ThreadContext *tc)
 616 {
 617     int index = 0;
 618     int fd = process->getSyscallArg(tc, index);
 619
 620     if (fd < 0 || process->sim_fd(fd) < 0)
 621         return -EBADF;
 622
 623     int cmd = process->getSyscallArg(tc, index);
 624     switch (cmd) {
 625       case 33: //F_GETLK64
 626         warn("fcntl64(%d, F_GETLK64) not supported, error returned\n", fd);
 627         return -EMFILE;
 628
 629       case 34: // F_SETLK64
 630       case 35: // F_SETLKW64
 631         warn("fcntl64(%d, F_SETLK(W)64) not supported, error returned\n", fd);
 632         return -EMFILE;
 633
 634       default:
 635         // not sure if this is totally valid, but we'll pass it through
 636         // to the underlying OS
 637         warn("fcntl64(%d, %d) passed through to host\n", fd, cmd);
 638         return fcntl(process->sim_fd(fd), cmd);
 639         // return 0;
 640     }
 641 }
 642
 643 SyscallReturn
 644 pipePseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 645          ThreadContext *tc)
 646 {
 647     int fds[2], sim_fds[2];
 648     int pipe_retval = pipe(fds);
 649
 650     if (pipe_retval < 0) {
 651         // error
 652         return pipe_retval;
 653     }
 654
 655     sim_fds[0] = process->alloc_fd(fds[0], "PIPE-READ", O_WRONLY, -1, true);
 656     sim_fds[1] = process->alloc_fd(fds[1], "PIPE-WRITE", O_RDONLY, -1, true);
 657
 658     process->setReadPipeSource(sim_fds[0], sim_fds[1]);
 659     // Alpha Linux convention for pipe() is that fd[0] is returned as
 660     // the return value of the function, and fd[1] is returned in r20.
 661     tc->setIntReg(SyscallPseudoReturnReg, sim_fds[1]);
 662     return sim_fds[0];
 663 }
 664
 665
 666 SyscallReturn
 667 getpidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 668            ThreadContext *tc)
 669 {
 670     // Make up a PID.  There's no interprocess communication in
 671     // fake_syscall mode, so there's no way for a process to know it's
 672     // not getting a unique value.
 673
 674     tc->setIntReg(SyscallPseudoReturnReg, process->ppid());
 675     return process->pid();
 676 }
 677
 678
 679 SyscallReturn
 680 getuidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 681            ThreadContext *tc)
 682 {
 683     // Make up a UID and EUID... it shouldn't matter, and we want the
 684     // simulation to be deterministic.
 685
 686     // EUID goes in r20.
 687     tc->setIntReg(SyscallPseudoReturnReg, process->euid()); //EUID
 688     return process->uid();              // UID
 689 }
 690
 691
 692 SyscallReturn
 693 getgidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 694            ThreadContext *tc)
 695 {
 696     // Get current group ID.  EGID goes in r20.
 697     tc->setIntReg(SyscallPseudoReturnReg, process->egid()); //EGID
 698     return process->gid();
 699 }
 700
 701
 702 SyscallReturn
 703 setuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 704            ThreadContext *tc)
 705 {
 706     // can't fathom why a benchmark would call this.
 707     int index = 0;
 708     warn("Ignoring call to setuid(%d)\n", process->getSyscallArg(tc, index));
 709     return 0;
 710 }
 711
 712 SyscallReturn
 713 getpidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 714            ThreadContext *tc)
 715 {
 716     // Make up a PID.  There's no interprocess communication in
 717     // fake_syscall mode, so there's no way for a process to know it's
 718     // not getting a unique value.
 719
 720     tc->setIntReg(SyscallPseudoReturnReg, process->ppid()); //PID
 721     return process->pid();
 722 }
 723
 724 SyscallReturn
 725 getppidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 726            ThreadContext *tc)
 727 {
 728     return process->ppid();
 729 }
 730
 731 SyscallReturn
 732 getuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 733            ThreadContext *tc)
 734 {
 735     return process->uid();              // UID
 736 }
 737
 738 SyscallReturn
 739 geteuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 740            ThreadContext *tc)
 741 {
 742     return process->euid();             // UID
 743 }
 744
 745 SyscallReturn
 746 getgidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 747            ThreadContext *tc)
 748 {
 749     return process->gid();
 750 }
 751
 752 SyscallReturn
 753 getegidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 754            ThreadContext *tc)
 755 {
 756     return process->egid();
 757 }
 758
 759
 760 SyscallReturn
 761 cloneFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
 762            ThreadContext *tc)
 763 {
 764     int index = 0;
 765     IntReg flags = process->getSyscallArg(tc, index);
 766     IntReg newStack = process->getSyscallArg(tc, index);
 767
 768     DPRINTF(SyscallVerbose, "In sys_clone:\n");
 769     DPRINTF(SyscallVerbose, " Flags=%llx\n", flags);
 770     DPRINTF(SyscallVerbose, " Child stack=%llx\n", newStack);
 771
 772
 773     if (flags != 0x10f00) {
 774         warn("This sys_clone implementation assumes flags "
 775              "CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD "
 776              "(0x10f00), and may not work correctly with given flags "
 777              "0x%llx\n", flags);
 778     }
 779
 780     ThreadContext* ctc; // child thread context
 781     if ( ( ctc = process->findFreeContext() ) != NULL ) {
 782         DPRINTF(SyscallVerbose, " Found unallocated thread context\n");
 783
 784         ctc->clearArchRegs();
 785
 786         // Arch-specific cloning code
 787         #if THE_ISA == ALPHA_ISA or THE_ISA == X86_ISA
 788             // Cloning the misc. regs for these archs is enough
 789             TheISA::copyMiscRegs(tc, ctc);
 790         #elif THE_ISA == SPARC_ISA
 791             TheISA::copyRegs(tc, ctc);
 792
 793             // TODO: Explain what this code actually does :-)
 794             ctc->setIntReg(NumIntArchRegs + 6, 0);
 795             ctc->setIntReg(NumIntArchRegs + 4, 0);
 796             ctc->setIntReg(NumIntArchRegs + 3, NWindows - 2);
 797             ctc->setIntReg(NumIntArchRegs + 5, NWindows);
 798             ctc->setMiscReg(MISCREG_CWP, 0);
 799             ctc->setIntReg(NumIntArchRegs + 7, 0);
 800             ctc->setMiscRegNoEffect(MISCREG_TL, 0);
 801             ctc->setMiscRegNoEffect(MISCREG_ASI, ASI_PRIMARY);
 802
 803             for (int y = 8; y < 32; y++)
 804                 ctc->setIntReg(y, tc->readIntReg(y));
 805         #else
 806             fatal("sys_clone is not implemented for this ISA\n");
 807         #endif
 808
 809         // Set up stack register
 810         ctc->setIntReg(TheISA::StackPointerReg, newStack);
 811
 812         // Set up syscall return values in parent and child
 813         ctc->setIntReg(ReturnValueReg, 0); // return value, child
 814
 815         // Alpha needs SyscallSuccessReg=0 in child
 816         #if THE_ISA == ALPHA_ISA
 817             ctc->setIntReg(TheISA::SyscallSuccessReg, 0);
 818         #endif
 819
 820         // In SPARC/Linux, clone returns 0 on pseudo-return register if
 821         // parent, non-zero if child
 822         #if THE_ISA == SPARC_ISA
 823             tc->setIntReg(TheISA::SyscallPseudoReturnReg, 0);
 824             ctc->setIntReg(TheISA::SyscallPseudoReturnReg, 1);
 825         #endif
 826
 827         ctc->pcState(tc->nextInstAddr());
 828
 829         ctc->activate();
 830
 831         // Should return nonzero child TID in parent's syscall return register,
 832         // but for our pthread library any non-zero value will work
 833         return 1;
 834     } else {
 835         fatal("Called sys_clone, but no unallocated thread contexts found!\n");
 836         return 0;
 837     }
 838 }
 839