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