syscall_emul.cc revision 5282
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 "cpu/thread_context.hh" 42#include "cpu/base.hh" 43#include "mem/page_table.hh" 44#include "sim/process.hh" 45 46#include "sim/sim_exit.hh" 47 48using namespace std; 49using namespace TheISA; 50 51void 52SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc) 53{ 54 DPRINTFR(SyscallVerbose, "%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n", 55 curTick,tc->getCpuPtr()->name(), name, 56 tc->getSyscallArg(0),tc->getSyscallArg(1), 57 tc->getSyscallArg(2),tc->getSyscallArg(3)); 58 59 SyscallReturn retval = (*funcPtr)(this, callnum, process, tc); 60 61 DPRINTFR(SyscallVerbose, "%d: %s: syscall %s returns %d\n", 62 curTick,tc->getCpuPtr()->name(), name, retval.value()); 63 64 if (!(flags & SyscallDesc::SuppressReturnValue)) 65 tc->setSyscallReturn(retval); 66} 67 68 69SyscallReturn 70unimplementedFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 71 ThreadContext *tc) 72{ 73 fatal("syscall %s (#%d) unimplemented.", desc->name, callnum); 74 75 return 1; 76} 77 78 79SyscallReturn 80ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 81 ThreadContext *tc) 82{ 83 warn("ignoring syscall %s(%d, %d, ...)", desc->name, 84 tc->getSyscallArg(0), tc->getSyscallArg(1)); 85 86 return 0; 87} 88 89 90SyscallReturn 91exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 92 ThreadContext *tc) 93{ 94 if (tc->exit()) { 95 exitSimLoop("target called exit()", tc->getSyscallArg(0) & 0xff); 96 } 97 98 return 1; 99} 100 101 102SyscallReturn 103getpagesizeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 104{ 105 return (int)VMPageSize; 106} 107 108 109SyscallReturn 110obreakFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 111{ 112 Addr junk; 113 114 // change brk addr to first arg 115 Addr new_brk = tc->getSyscallArg(0); 116 if (new_brk != 0) { 117 for (ChunkGenerator gen(p->brk_point, new_brk - p->brk_point, 118 VMPageSize); !gen.done(); gen.next()) { 119 if (!p->pTable->translate(gen.addr(), junk)) 120 p->pTable->allocate(roundDown(gen.addr(), VMPageSize), 121 VMPageSize); 122 } 123 p->brk_point = new_brk; 124 } 125 DPRINTF(SyscallVerbose, "Break Point changed to: %#X\n", p->brk_point); 126 return p->brk_point; 127} 128 129 130SyscallReturn 131closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 132{ 133 int target_fd = tc->getSyscallArg(0); 134 int status = close(p->sim_fd(target_fd)); 135 if (status >= 0) 136 p->free_fd(target_fd); 137 return status; 138} 139 140 141SyscallReturn 142readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 143{ 144 int fd = p->sim_fd(tc->getSyscallArg(0)); 145 int nbytes = tc->getSyscallArg(2); 146 BufferArg bufArg(tc->getSyscallArg(1), nbytes); 147 148 int bytes_read = read(fd, bufArg.bufferPtr(), nbytes); 149 150 if (bytes_read != -1) 151 bufArg.copyOut(tc->getMemPort()); 152 153 return bytes_read; 154} 155 156SyscallReturn 157writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 158{ 159 int fd = p->sim_fd(tc->getSyscallArg(0)); 160 int nbytes = tc->getSyscallArg(2); 161 BufferArg bufArg(tc->getSyscallArg(1), nbytes); 162 163 bufArg.copyIn(tc->getMemPort()); 164 165 int bytes_written = write(fd, bufArg.bufferPtr(), nbytes); 166 167 fsync(fd); 168 169 return bytes_written; 170} 171 172 173SyscallReturn 174lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 175{ 176 int fd = p->sim_fd(tc->getSyscallArg(0)); 177 uint64_t offs = tc->getSyscallArg(1); 178 int whence = tc->getSyscallArg(2); 179 180 off_t result = lseek(fd, offs, whence); 181 182 return (result == (off_t)-1) ? -errno : result; 183} 184 185 186SyscallReturn 187_llseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 188{ 189 int fd = p->sim_fd(tc->getSyscallArg(0)); 190 uint64_t offset_high = tc->getSyscallArg(1); 191 uint32_t offset_low = tc->getSyscallArg(2); 192 Addr result_ptr = tc->getSyscallArg(3); 193 int whence = tc->getSyscallArg(4); 194 195 uint64_t offset = (offset_high << 32) | offset_low; 196 197 uint64_t result = lseek(fd, offset, whence); 198 result = TheISA::htog(result); 199 200 if (result == (off_t)-1) { 201 //The seek failed. 202 return -errno; 203 } else { 204 //The seek succeeded. 205 //Copy "result" to "result_ptr" 206 //XXX We'll assume that the size of loff_t is 64 bits on the 207 //target platform 208 BufferArg result_buf(result_ptr, sizeof(result)); 209 memcpy(result_buf.bufferPtr(), &result, sizeof(result)); 210 result_buf.copyOut(tc->getMemPort()); 211 return 0; 212 } 213 214 215 return (result == (off_t)-1) ? -errno : result; 216} 217 218 219SyscallReturn 220munmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 221{ 222 // given that we don't really implement mmap, munmap is really easy 223 return 0; 224} 225 226 227const char *hostname = "m5.eecs.umich.edu"; 228 229SyscallReturn 230gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 231{ 232 int name_len = tc->getSyscallArg(1); 233 BufferArg name(tc->getSyscallArg(0), name_len); 234 235 strncpy((char *)name.bufferPtr(), hostname, name_len); 236 237 name.copyOut(tc->getMemPort()); 238 239 return 0; 240} 241 242SyscallReturn 243unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 244{ 245 string path; 246 247 if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0))) 248 return (TheISA::IntReg)-EFAULT; 249 250 // Adjust path for current working directory 251 path = p->fullPath(path); 252 253 int result = unlink(path.c_str()); 254 return (result == -1) ? -errno : result; 255} 256 257SyscallReturn 258renameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 259{ 260 string old_name; 261 262 if (!tc->getMemPort()->tryReadString(old_name, tc->getSyscallArg(0))) 263 return -EFAULT; 264 265 string new_name; 266 267 if (!tc->getMemPort()->tryReadString(new_name, tc->getSyscallArg(1))) 268 return -EFAULT; 269 270 // Adjust path for current working directory 271 old_name = p->fullPath(old_name); 272 new_name = p->fullPath(new_name); 273 274 int64_t result = rename(old_name.c_str(), new_name.c_str()); 275 return (result == -1) ? -errno : result; 276} 277 278SyscallReturn 279truncateFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 280{ 281 string path; 282 283 if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0))) 284 return -EFAULT; 285 286 off_t length = tc->getSyscallArg(1); 287 288 // Adjust path for current working directory 289 path = p->fullPath(path); 290 291 int result = truncate(path.c_str(), length); 292 return (result == -1) ? -errno : result; 293} 294 295SyscallReturn 296ftruncateFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc) 297{ 298 int fd = process->sim_fd(tc->getSyscallArg(0)); 299 300 if (fd < 0) 301 return -EBADF; 302 303 off_t length = tc->getSyscallArg(1); 304 305 int result = ftruncate(fd, length); 306 return (result == -1) ? -errno : result; 307} 308 309SyscallReturn 310chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc) 311{ 312 string path; 313 314 if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0))) 315 return -EFAULT; 316 317 /* XXX endianess */ 318 uint32_t owner = tc->getSyscallArg(1); 319 uid_t hostOwner = owner; 320 uint32_t group = tc->getSyscallArg(2); 321 gid_t hostGroup = group; 322 323 // Adjust path for current working directory 324 path = p->fullPath(path); 325 326 int result = chown(path.c_str(), hostOwner, hostGroup); 327 return (result == -1) ? -errno : result; 328} 329 330SyscallReturn 331fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc) 332{ 333 int fd = process->sim_fd(tc->getSyscallArg(0)); 334 335 if (fd < 0) 336 return -EBADF; 337 338 /* XXX endianess */ 339 uint32_t owner = tc->getSyscallArg(1); 340 uid_t hostOwner = owner; 341 uint32_t group = tc->getSyscallArg(2); 342 gid_t hostGroup = group; 343 344 int result = fchown(fd, hostOwner, hostGroup); 345 return (result == -1) ? -errno : result; 346} 347 348 349SyscallReturn 350dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc) 351{ 352 int fd = process->sim_fd(tc->getSyscallArg(0)); 353 if (fd < 0) 354 return -EBADF; 355 356 Process::FdMap *fdo = process->sim_fd_obj(tc->getSyscallArg(0)); 357 358 int result = dup(fd); 359 return (result == -1) ? -errno : process->alloc_fd(result, fdo->filename, fdo->flags, fdo->mode, false); 360} 361 362 363SyscallReturn 364fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process, 365 ThreadContext *tc) 366{ 367 int fd = tc->getSyscallArg(0); 368 369 if (fd < 0 || process->sim_fd(fd) < 0) 370 return -EBADF; 371 372 int cmd = tc->getSyscallArg(1); 373 switch (cmd) { 374 case 0: // F_DUPFD 375 // if we really wanted to support this, we'd need to do it 376 // in the target fd space. 377 warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd); 378 return -EMFILE; 379 380 case 1: // F_GETFD (get close-on-exec flag) 381 case 2: // F_SETFD (set close-on-exec flag) 382 return 0; 383 384 case 3: // F_GETFL (get file flags) 385 case 4: // F_SETFL (set file flags) 386 // not sure if this is totally valid, but we'll pass it through 387 // to the underlying OS 388 warn("fcntl(%d, %d) passed through to host\n", fd, cmd); 389 return fcntl(process->sim_fd(fd), cmd); 390 // return 0; 391 392 case 7: // F_GETLK (get lock) 393 case 8: // F_SETLK (set lock) 394 case 9: // F_SETLKW (set lock and wait) 395 // don't mess with file locking... just act like it's OK 396 warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd); 397 return 0; 398 399 default: 400 warn("Unknown fcntl command %d\n", cmd); 401 return 0; 402 } 403} 404 405SyscallReturn 406fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process, 407 ThreadContext *tc) 408{ 409 int fd = tc->getSyscallArg(0); 410 411 if (fd < 0 || process->sim_fd(fd) < 0) 412 return -EBADF; 413 414 int cmd = tc->getSyscallArg(1); 415 switch (cmd) { 416 case 33: //F_GETLK64 417 warn("fcntl64(%d, F_GETLK64) not supported, error returned\n", fd); 418 return -EMFILE; 419 420 case 34: // F_SETLK64 421 case 35: // F_SETLKW64 422 warn("fcntl64(%d, F_SETLK(W)64) not supported, error returned\n", fd); 423 return -EMFILE; 424 425 default: 426 // not sure if this is totally valid, but we'll pass it through 427 // to the underlying OS 428 warn("fcntl64(%d, %d) passed through to host\n", fd, cmd); 429 return fcntl(process->sim_fd(fd), cmd); 430 // return 0; 431 } 432} 433 434SyscallReturn 435pipePseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 436 ThreadContext *tc) 437{ 438 int fds[2], sim_fds[2]; 439 int pipe_retval = pipe(fds); 440 441 if (pipe_retval < 0) { 442 // error 443 return pipe_retval; 444 } 445 446 sim_fds[0] = process->alloc_fd(fds[0], "PIPE-READ", O_WRONLY, -1, true); 447 sim_fds[1] = process->alloc_fd(fds[1], "PIPE-WRITE", O_RDONLY, -1, true); 448 449 process->setReadPipeSource(sim_fds[0], sim_fds[1]); 450 // Alpha Linux convention for pipe() is that fd[0] is returned as 451 // the return value of the function, and fd[1] is returned in r20. 452 tc->setIntReg(SyscallPseudoReturnReg, sim_fds[1]); 453 return sim_fds[0]; 454} 455 456 457SyscallReturn 458getpidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 459 ThreadContext *tc) 460{ 461 // Make up a PID. There's no interprocess communication in 462 // fake_syscall mode, so there's no way for a process to know it's 463 // not getting a unique value. 464 465 tc->setIntReg(SyscallPseudoReturnReg, process->ppid()); 466 return process->pid(); 467} 468 469 470SyscallReturn 471getuidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 472 ThreadContext *tc) 473{ 474 // Make up a UID and EUID... it shouldn't matter, and we want the 475 // simulation to be deterministic. 476 477 // EUID goes in r20. 478 tc->setIntReg(SyscallPseudoReturnReg, process->euid()); //EUID 479 return process->uid(); // UID 480} 481 482 483SyscallReturn 484getgidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 485 ThreadContext *tc) 486{ 487 // Get current group ID. EGID goes in r20. 488 tc->setIntReg(SyscallPseudoReturnReg, process->egid()); //EGID 489 return process->gid(); 490} 491 492 493SyscallReturn 494setuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 495 ThreadContext *tc) 496{ 497 // can't fathom why a benchmark would call this. 498 warn("Ignoring call to setuid(%d)\n", tc->getSyscallArg(0)); 499 return 0; 500} 501 502SyscallReturn 503getpidFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 504 ThreadContext *tc) 505{ 506 // Make up a PID. There's no interprocess communication in 507 // fake_syscall mode, so there's no way for a process to know it's 508 // not getting a unique value. 509 510 tc->setIntReg(SyscallPseudoReturnReg, process->ppid()); //PID 511 return process->pid(); 512} 513 514SyscallReturn 515getppidFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 516 ThreadContext *tc) 517{ 518 return process->ppid(); 519} 520 521SyscallReturn 522getuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 523 ThreadContext *tc) 524{ 525 return process->uid(); // UID 526} 527 528SyscallReturn 529geteuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 530 ThreadContext *tc) 531{ 532 return process->euid(); // UID 533} 534 535SyscallReturn 536getgidFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 537 ThreadContext *tc) 538{ 539 return process->gid(); 540} 541 542SyscallReturn 543getegidFunc(SyscallDesc *desc, int callnum, LiveProcess *process, 544 ThreadContext *tc) 545{ 546 return process->egid(); 547} 548 549 550