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