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