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