src/sim/syscall_emul.cc

   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
  48 using namespace std;
  49 using namespace TheISA;
  50
  51 void
  52 SyscallDesc::doSyscall(int callnum, Process *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
  69 SyscallReturn
  70 unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
  71                   ThreadContext *tc)
  72 {
  73     fatal("syscall %s (#%d) unimplemented.", desc->name, callnum);
  74
  75     return 1;
  76 }
  77
  78
  79 SyscallReturn
  80 ignoreFunc(SyscallDesc *desc, int callnum, Process *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
  90 SyscallReturn
  91 exitFunc(SyscallDesc *desc, int callnum, Process *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
 102 SyscallReturn
 103 getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 104 {
 105     return (int)VMPageSize;
 106 }
 107
 108
 109 SyscallReturn
 110 obreakFunc(SyscallDesc *desc, int num, Process *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
 130 SyscallReturn
 131 closeFunc(SyscallDesc *desc, int num, Process *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
 141 SyscallReturn
 142 readFunc(SyscallDesc *desc, int num, Process *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
 156 SyscallReturn
 157 writeFunc(SyscallDesc *desc, int num, Process *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
 173 SyscallReturn
 174 lseekFunc(SyscallDesc *desc, int num, Process *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
 186 SyscallReturn
 187 munmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 188 {
 189     // given that we don't really implement mmap, munmap is really easy
 190     return 0;
 191 }
 192
 193
 194 const char *hostname = "m5.eecs.umich.edu";
 195
 196 SyscallReturn
 197 gethostnameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 198 {
 199     int name_len = tc->getSyscallArg(1);
 200     BufferArg name(tc->getSyscallArg(0), name_len);
 201
 202     strncpy((char *)name.bufferPtr(), hostname, name_len);
 203
 204     name.copyOut(tc->getMemPort());
 205
 206     return 0;
 207 }
 208
 209 SyscallReturn
 210 unlinkFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 211 {
 212     string path;
 213
 214     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 215         return (TheISA::IntReg)-EFAULT;
 216
 217     int result = unlink(path.c_str());
 218     return (result == -1) ? -errno : result;
 219 }
 220
 221 SyscallReturn
 222 renameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 223 {
 224     string old_name;
 225
 226     if (!tc->getMemPort()->tryReadString(old_name, tc->getSyscallArg(0)))
 227         return -EFAULT;
 228
 229     string new_name;
 230
 231     if (!tc->getMemPort()->tryReadString(new_name, tc->getSyscallArg(1)))
 232         return -EFAULT;
 233
 234     int64_t result = rename(old_name.c_str(), new_name.c_str());
 235     return (result == -1) ? -errno : result;
 236 }
 237
 238 SyscallReturn
 239 truncateFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 240 {
 241     string path;
 242
 243     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 244         return -EFAULT;
 245
 246     off_t length = tc->getSyscallArg(1);
 247
 248     int result = truncate(path.c_str(), length);
 249     return (result == -1) ? -errno : result;
 250 }
 251
 252 SyscallReturn
 253 ftruncateFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 254 {
 255     int fd = process->sim_fd(tc->getSyscallArg(0));
 256
 257     if (fd < 0)
 258         return -EBADF;
 259
 260     off_t length = tc->getSyscallArg(1);
 261
 262     int result = ftruncate(fd, length);
 263     return (result == -1) ? -errno : result;
 264 }
 265
 266 SyscallReturn
 267 chownFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 268 {
 269     string path;
 270
 271     if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
 272         return -EFAULT;
 273
 274     /* XXX endianess */
 275     uint32_t owner = tc->getSyscallArg(1);
 276     uid_t hostOwner = owner;
 277     uint32_t group = tc->getSyscallArg(2);
 278     gid_t hostGroup = group;
 279
 280     int result = chown(path.c_str(), hostOwner, hostGroup);
 281     return (result == -1) ? -errno : result;
 282 }
 283
 284 SyscallReturn
 285 fchownFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 286 {
 287     int fd = process->sim_fd(tc->getSyscallArg(0));
 288
 289     if (fd < 0)
 290         return -EBADF;
 291
 292     /* XXX endianess */
 293     uint32_t owner = tc->getSyscallArg(1);
 294     uid_t hostOwner = owner;
 295     uint32_t group = tc->getSyscallArg(2);
 296     gid_t hostGroup = group;
 297
 298     int result = fchown(fd, hostOwner, hostGroup);
 299     return (result == -1) ? -errno : result;
 300 }
 301
 302
 303 SyscallReturn
 304 fcntlFunc(SyscallDesc *desc, int num, Process *process,
 305           ThreadContext *tc)
 306 {
 307     int fd = tc->getSyscallArg(0);
 308
 309     if (fd < 0 || process->sim_fd(fd) < 0)
 310         return -EBADF;
 311
 312     int cmd = tc->getSyscallArg(1);
 313     switch (cmd) {
 314       case 0: // F_DUPFD
 315         // if we really wanted to support this, we'd need to do it
 316         // in the target fd space.
 317         warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd);
 318         return -EMFILE;
 319
 320       case 1: // F_GETFD (get close-on-exec flag)
 321       case 2: // F_SETFD (set close-on-exec flag)
 322         return 0;
 323
 324       case 3: // F_GETFL (get file flags)
 325       case 4: // F_SETFL (set file flags)
 326         // not sure if this is totally valid, but we'll pass it through
 327         // to the underlying OS
 328         warn("fcntl(%d, %d) passed through to host\n", fd, cmd);
 329         return fcntl(process->sim_fd(fd), cmd);
 330         // return 0;
 331
 332       case 7: // F_GETLK  (get lock)
 333       case 8: // F_SETLK  (set lock)
 334       case 9: // F_SETLKW (set lock and wait)
 335         // don't mess with file locking... just act like it's OK
 336         warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd);
 337         return 0;
 338
 339       default:
 340         warn("Unknown fcntl command %d\n", cmd);
 341         return 0;
 342     }
 343 }
 344
 345 SyscallReturn
 346 fcntl64Func(SyscallDesc *desc, int num, Process *process,
 347             ThreadContext *tc)
 348 {
 349     int fd = tc->getSyscallArg(0);
 350
 351     if (fd < 0 || process->sim_fd(fd) < 0)
 352         return -EBADF;
 353
 354     int cmd = tc->getSyscallArg(1);
 355     switch (cmd) {
 356       case 33: //F_GETLK64
 357         warn("fcntl64(%d, F_GETLK64) not supported, error returned\n", fd);
 358         return -EMFILE;
 359
 360       case 34: // F_SETLK64
 361       case 35: // F_SETLKW64
 362         warn("fcntl64(%d, F_SETLK(W)64) not supported, error returned\n", fd);
 363         return -EMFILE;
 364
 365       default:
 366         // not sure if this is totally valid, but we'll pass it through
 367         // to the underlying OS
 368         warn("fcntl64(%d, %d) passed through to host\n", fd, cmd);
 369         return fcntl(process->sim_fd(fd), cmd);
 370         // return 0;
 371     }
 372 }
 373
 374 SyscallReturn
 375 pipePseudoFunc(SyscallDesc *desc, int callnum, Process *process,
 376          ThreadContext *tc)
 377 {
 378     int fds[2], sim_fds[2];
 379     int pipe_retval = pipe(fds);
 380
 381     if (pipe_retval < 0) {
 382         // error
 383         return pipe_retval;
 384     }
 385
 386     sim_fds[0] = process->alloc_fd(fds[0]);
 387     sim_fds[1] = process->alloc_fd(fds[1]);
 388
 389     // Alpha Linux convention for pipe() is that fd[0] is returned as
 390     // the return value of the function, and fd[1] is returned in r20.
 391     tc->setIntReg(SyscallPseudoReturnReg, sim_fds[1]);
 392     return sim_fds[0];
 393 }
 394
 395
 396 SyscallReturn
 397 getpidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
 398            ThreadContext *tc)
 399 {
 400     // Make up a PID.  There's no interprocess communication in
 401     // fake_syscall mode, so there's no way for a process to know it's
 402     // not getting a unique value.
 403
 404     tc->setIntReg(SyscallPseudoReturnReg, process->ppid);
 405     return process->pid;
 406 }
 407
 408
 409 SyscallReturn
 410 getuidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
 411            ThreadContext *tc)
 412 {
 413     // Make up a UID and EUID... it shouldn't matter, and we want the
 414     // simulation to be deterministic.
 415
 416     // EUID goes in r20.
 417     tc->setIntReg(SyscallPseudoReturnReg, process->euid); //EUID
 418     return process->uid;                // UID
 419 }
 420
 421
 422 SyscallReturn
 423 getgidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
 424            ThreadContext *tc)
 425 {
 426     // Get current group ID.  EGID goes in r20.
 427     tc->setIntReg(SyscallPseudoReturnReg, process->egid); //EGID
 428     return process->gid;
 429 }
 430
 431
 432 SyscallReturn
 433 setuidFunc(SyscallDesc *desc, int callnum, Process *process,
 434            ThreadContext *tc)
 435 {
 436     // can't fathom why a benchmark would call this.
 437     warn("Ignoring call to setuid(%d)\n", tc->getSyscallArg(0));
 438     return 0;
 439 }
 440
 441 SyscallReturn
 442 getpidFunc(SyscallDesc *desc, int callnum, Process *process,
 443            ThreadContext *tc)
 444 {
 445     // Make up a PID.  There's no interprocess communication in
 446     // fake_syscall mode, so there's no way for a process to know it's
 447     // not getting a unique value.
 448
 449     tc->setIntReg(SyscallPseudoReturnReg, process->ppid); //PID
 450     return process->pid;
 451 }
 452
 453 SyscallReturn
 454 getppidFunc(SyscallDesc *desc, int callnum, Process *process,
 455            ThreadContext *tc)
 456 {
 457     return process->ppid;
 458 }
 459
 460 SyscallReturn
 461 getuidFunc(SyscallDesc *desc, int callnum, Process *process,
 462            ThreadContext *tc)
 463 {
 464     return process->uid;                // UID
 465 }
 466
 467 SyscallReturn
 468 geteuidFunc(SyscallDesc *desc, int callnum, Process *process,
 469            ThreadContext *tc)
 470 {
 471     return process->euid;               // UID
 472 }
 473
 474 SyscallReturn
 475 getgidFunc(SyscallDesc *desc, int callnum, Process *process,
 476            ThreadContext *tc)
 477 {
 478     return process->gid;
 479 }
 480
 481 SyscallReturn
 482 getegidFunc(SyscallDesc *desc, int callnum, Process *process,
 483            ThreadContext *tc)
 484 {
 485     return process->egid;
 486 }
 487
 488