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