src/sim/process.cc

   1 /*
   2  * Copyright (c) 2001-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: Nathan Binkert
  29  *          Steve Reinhardt
  30  *          Ali Saidi
  31  */
  32
  33 #include <unistd.h>
  34 #include <fcntl.h>
  35
  36 #include <string>
  37
  38 #include "base/intmath.hh"
  39 #include "base/loader/object_file.hh"
  40 #include "base/loader/symtab.hh"
  41 #include "base/statistics.hh"
  42 #include "config/full_system.hh"
  43 #include "cpu/thread_context.hh"
  44 #include "mem/page_table.hh"
  45 #include "mem/physical.hh"
  46 #include "mem/translating_port.hh"
  47 #include "sim/builder.hh"
  48 #include "sim/process.hh"
  49 #include "sim/stats.hh"
  50 #include "sim/syscall_emul.hh"
  51 #include "sim/system.hh"
  52
  53 #include "arch/isa_specific.hh"
  54 #if THE_ISA == ALPHA_ISA
  55 #include "arch/alpha/linux/process.hh"
  56 #include "arch/alpha/tru64/process.hh"
  57 #elif THE_ISA == SPARC_ISA
  58 #include "arch/sparc/linux/process.hh"
  59 #include "arch/sparc/solaris/process.hh"
  60 #elif THE_ISA == MIPS_ISA
  61 #include "arch/mips/linux/process.hh"
  62 #else
  63 #error "THE_ISA not set"
  64 #endif
  65
  66
  67 using namespace std;
  68 using namespace TheISA;
  69
  70 //
  71 // The purpose of this code is to fake the loader & syscall mechanism
  72 // when there's no OS: thus there's no resone to use it in FULL_SYSTEM
  73 // mode when we do have an OS
  74 //
  75 #if FULL_SYSTEM
  76 #error "process.cc not compatible with FULL_SYSTEM"
  77 #endif
  78
  79 // current number of allocated processes
  80 int num_processes = 0;
  81
  82 Process::Process(const string &nm,
  83                  System *_system,
  84                  int stdin_fd,  // initial I/O descriptors
  85                  int stdout_fd,
  86                  int stderr_fd)
  87     : SimObject(nm), system(_system)
  88 {
  89     // initialize first 3 fds (stdin, stdout, stderr)
  90     fd_map[STDIN_FILENO] = stdin_fd;
  91     fd_map[STDOUT_FILENO] = stdout_fd;
  92     fd_map[STDERR_FILENO] = stderr_fd;
  93
  94     // mark remaining fds as free
  95     for (int i = 3; i <= MAX_FD; ++i) {
  96         fd_map[i] = -1;
  97     }
  98
  99     mmap_start = mmap_end = 0;
 100     nxm_start = nxm_end = 0;
 101     pTable = new PageTable(system);
 102     // other parameters will be initialized when the program is loaded
 103 }
 104
 105
 106 void
 107 Process::regStats()
 108 {
 109     using namespace Stats;
 110
 111     num_syscalls
 112         .name(name() + ".PROG:num_syscalls")
 113         .desc("Number of system calls")
 114         ;
 115 }
 116
 117 //
 118 // static helper functions
 119 //
 120 int
 121 Process::openInputFile(const string &filename)
 122 {
 123     int fd = open(filename.c_str(), O_RDONLY);
 124
 125     if (fd == -1) {
 126         perror(NULL);
 127         cerr << "unable to open \"" << filename << "\" for reading\n";
 128         fatal("can't open input file");
 129     }
 130
 131     return fd;
 132 }
 133
 134
 135 int
 136 Process::openOutputFile(const string &filename)
 137 {
 138     int fd = open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0774);
 139
 140     if (fd == -1) {
 141         perror(NULL);
 142         cerr << "unable to open \"" << filename << "\" for writing\n";
 143         fatal("can't open output file");
 144     }
 145
 146     return fd;
 147 }
 148
 149
 150 int
 151 Process::registerThreadContext(ThreadContext *tc)
 152 {
 153     // add to list
 154     int myIndex = threadContexts.size();
 155     threadContexts.push_back(tc);
 156
 157     // return CPU number to caller
 158     return myIndex;
 159 }
 160
 161 void
 162 Process::startup()
 163 {
 164     if (threadContexts.empty())
 165         fatal("Process %s is not associated with any CPUs!\n", name());
 166
 167     // first thread context for this process... initialize & enable
 168     ThreadContext *tc = threadContexts[0];
 169
 170     // mark this context as active so it will start ticking.
 171     tc->activate(0);
 172
 173     Port *mem_port;
 174     mem_port = system->physmem->getPort("functional");
 175     initVirtMem = new TranslatingPort("process init port", pTable, true);
 176     mem_port->setPeer(initVirtMem);
 177     initVirtMem->setPeer(mem_port);
 178 }
 179
 180 void
 181 Process::replaceThreadContext(ThreadContext *tc, int tcIndex)
 182 {
 183     if (tcIndex >= threadContexts.size()) {
 184         panic("replaceThreadContext: bad tcIndex, %d >= %d\n",
 185               tcIndex, threadContexts.size());
 186     }
 187
 188     threadContexts[tcIndex] = tc;
 189 }
 190
 191 // map simulator fd sim_fd to target fd tgt_fd
 192 void
 193 Process::dup_fd(int sim_fd, int tgt_fd)
 194 {
 195     if (tgt_fd < 0 || tgt_fd > MAX_FD)
 196         panic("Process::dup_fd tried to dup past MAX_FD (%d)", tgt_fd);
 197
 198     fd_map[tgt_fd] = sim_fd;
 199 }
 200
 201
 202 // generate new target fd for sim_fd
 203 int
 204 Process::alloc_fd(int sim_fd)
 205 {
 206     // in case open() returns an error, don't allocate a new fd
 207     if (sim_fd == -1)
 208         return -1;
 209
 210     // find first free target fd
 211     for (int free_fd = 0; free_fd < MAX_FD; ++free_fd) {
 212         if (fd_map[free_fd] == -1) {
 213             fd_map[free_fd] = sim_fd;
 214             return free_fd;
 215         }
 216     }
 217
 218     panic("Process::alloc_fd: out of file descriptors!");
 219 }
 220
 221
 222 // free target fd (e.g., after close)
 223 void
 224 Process::free_fd(int tgt_fd)
 225 {
 226     if (fd_map[tgt_fd] == -1)
 227         warn("Process::free_fd: request to free unused fd %d", tgt_fd);
 228
 229     fd_map[tgt_fd] = -1;
 230 }
 231
 232
 233 // look up simulator fd for given target fd
 234 int
 235 Process::sim_fd(int tgt_fd)
 236 {
 237     if (tgt_fd > MAX_FD)
 238         return -1;
 239
 240     return fd_map[tgt_fd];
 241 }
 242
 243 void
 244 Process::serialize(std::ostream &os)
 245 {
 246     SERIALIZE_SCALAR(initialContextLoaded);
 247     SERIALIZE_SCALAR(brk_point);
 248     SERIALIZE_SCALAR(stack_base);
 249     SERIALIZE_SCALAR(stack_size);
 250     SERIALIZE_SCALAR(stack_min);
 251     SERIALIZE_SCALAR(next_thread_stack_base);
 252     SERIALIZE_SCALAR(mmap_start);
 253     SERIALIZE_SCALAR(mmap_end);
 254     SERIALIZE_SCALAR(nxm_start);
 255     SERIALIZE_SCALAR(nxm_end);
 256     SERIALIZE_ARRAY(fd_map, MAX_FD);
 257
 258     pTable->serialize(os);
 259 }
 260
 261 void
 262 Process::unserialize(Checkpoint *cp, const std::string &section)
 263 {
 264     UNSERIALIZE_SCALAR(initialContextLoaded);
 265     UNSERIALIZE_SCALAR(brk_point);
 266     UNSERIALIZE_SCALAR(stack_base);
 267     UNSERIALIZE_SCALAR(stack_size);
 268     UNSERIALIZE_SCALAR(stack_min);
 269     UNSERIALIZE_SCALAR(next_thread_stack_base);
 270     UNSERIALIZE_SCALAR(mmap_start);
 271     UNSERIALIZE_SCALAR(mmap_end);
 272     UNSERIALIZE_SCALAR(nxm_start);
 273     UNSERIALIZE_SCALAR(nxm_end);
 274     UNSERIALIZE_ARRAY(fd_map, MAX_FD);
 275
 276     pTable->unserialize(cp, section);
 277 }
 278
 279
 280 //
 281 // need to declare these here since there is no concrete Process type
 282 // that can be constructed (i.e., no REGISTER_SIM_OBJECT() macro call,
 283 // which is where these get declared for concrete types).
 284 //
 285 DEFINE_SIM_OBJECT_CLASS_NAME("Process", Process)
 286
 287
 288 ////////////////////////////////////////////////////////////////////////
 289 //
 290 // LiveProcess member definitions
 291 //
 292 ////////////////////////////////////////////////////////////////////////
 293
 294
 295 void
 296 copyStringArray(vector<string> &strings, Addr array_ptr, Addr data_ptr,
 297                 TranslatingPort* memPort)
 298 {
 299     Addr data_ptr_swap;
 300     for (int i = 0; i < strings.size(); ++i) {
 301         data_ptr_swap = htog(data_ptr);
 302         memPort->writeBlob(array_ptr, (uint8_t*)&data_ptr_swap, sizeof(Addr));
 303         memPort->writeString(data_ptr, strings[i].c_str());
 304         array_ptr += sizeof(Addr);
 305         data_ptr += strings[i].size() + 1;
 306     }
 307     // add NULL terminator
 308     data_ptr = 0;
 309
 310     memPort->writeBlob(array_ptr, (uint8_t*)&data_ptr, sizeof(Addr));
 311 }
 312
 313 LiveProcess::LiveProcess(const string &nm, ObjectFile *_objFile,
 314                          System *_system,
 315                          int stdin_fd, int stdout_fd, int stderr_fd,
 316                          vector<string> &_argv, vector<string> &_envp,
 317                          const string &_cwd,
 318                          uint64_t _uid, uint64_t _euid,
 319                          uint64_t _gid, uint64_t _egid,
 320                          uint64_t _pid, uint64_t _ppid)
 321     : Process(nm, _system, stdin_fd, stdout_fd, stderr_fd),
 322       objFile(_objFile), argv(_argv), envp(_envp), cwd(_cwd)
 323 {
 324     __uid = _uid;
 325     __euid = _euid;
 326     __gid = _gid;
 327     __egid = _egid;
 328     __pid = _pid;
 329     __ppid = _ppid;
 330
 331     prog_fname = argv[0];
 332
 333     // load up symbols, if any... these may be used for debugging or
 334     // profiling.
 335     if (!debugSymbolTable) {
 336         debugSymbolTable = new SymbolTable();
 337         if (!objFile->loadGlobalSymbols(debugSymbolTable) ||
 338             !objFile->loadLocalSymbols(debugSymbolTable)) {
 339             // didn't load any symbols
 340             delete debugSymbolTable;
 341             debugSymbolTable = NULL;
 342         }
 343     }
 344 }
 345
 346 void
 347 LiveProcess::argsInit(int intSize, int pageSize)
 348 {
 349     Process::startup();
 350
 351     // load object file into target memory
 352     objFile->loadSections(initVirtMem);
 353
 354     // Calculate how much space we need for arg & env arrays.
 355     int argv_array_size = intSize * (argv.size() + 1);
 356     int envp_array_size = intSize * (envp.size() + 1);
 357     int arg_data_size = 0;
 358     for (int i = 0; i < argv.size(); ++i) {
 359         arg_data_size += argv[i].size() + 1;
 360     }
 361     int env_data_size = 0;
 362     for (int i = 0; i < envp.size(); ++i) {
 363         env_data_size += envp[i].size() + 1;
 364     }
 365
 366     int space_needed =
 367         argv_array_size + envp_array_size + arg_data_size + env_data_size;
 368     if (space_needed < 32*1024)
 369         space_needed = 32*1024;
 370
 371     // set bottom of stack
 372     stack_min = stack_base - space_needed;
 373     // align it
 374     stack_min = roundDown(stack_min, pageSize);
 375     stack_size = stack_base - stack_min;
 376     // map memory
 377     pTable->allocate(stack_min, roundUp(stack_size, pageSize));
 378
 379     // map out initial stack contents
 380     Addr argv_array_base = stack_min + intSize; // room for argc
 381     Addr envp_array_base = argv_array_base + argv_array_size;
 382     Addr arg_data_base = envp_array_base + envp_array_size;
 383     Addr env_data_base = arg_data_base + arg_data_size;
 384
 385     // write contents to stack
 386     uint64_t argc = argv.size();
 387     if (intSize == 8)
 388         argc = htog((uint64_t)argc);
 389     else if (intSize == 4)
 390         argc = htog((uint32_t)argc);
 391     else
 392         panic("Unknown int size");
 393
 394     initVirtMem->writeBlob(stack_min, (uint8_t*)&argc, intSize);
 395
 396     copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem);
 397     copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
 398
 399     threadContexts[0]->setIntReg(ArgumentReg0, argc);
 400     threadContexts[0]->setIntReg(ArgumentReg1, argv_array_base);
 401     threadContexts[0]->setIntReg(StackPointerReg, stack_min);
 402
 403     Addr prog_entry = objFile->entryPoint();
 404     threadContexts[0]->setPC(prog_entry);
 405     threadContexts[0]->setNextPC(prog_entry + sizeof(MachInst));
 406
 407 #if THE_ISA != ALPHA_ISA //e.g. MIPS or Sparc
 408     threadContexts[0]->setNextNPC(prog_entry + (2 * sizeof(MachInst)));
 409 #endif
 410
 411     num_processes++;
 412 }
 413
 414 void
 415 LiveProcess::syscall(int64_t callnum, ThreadContext *tc)
 416 {
 417     num_syscalls++;
 418
 419     SyscallDesc *desc = getDesc(callnum);
 420     if (desc == NULL)
 421         fatal("Syscall %d out of range", callnum);
 422
 423     desc->doSyscall(callnum, this, tc);
 424 }
 425
 426 LiveProcess *
 427 LiveProcess::create(const std::string &nm, System *system, int stdin_fd,
 428                     int stdout_fd, int stderr_fd, std::string executable,
 429                     std::vector<std::string> &argv,
 430                     std::vector<std::string> &envp,
 431                     const std::string &cwd,
 432                     uint64_t _uid, uint64_t _euid,
 433                     uint64_t _gid, uint64_t _egid,
 434                     uint64_t _pid, uint64_t _ppid)
 435 {
 436     LiveProcess *process = NULL;
 437
 438     ObjectFile *objFile = createObjectFile(executable);
 439     if (objFile == NULL) {
 440         fatal("Can't load object file %s", executable);
 441     }
 442
 443 #if THE_ISA == ALPHA_ISA
 444     if (objFile->getArch() != ObjectFile::Alpha)
 445         fatal("Object file architecture does not match compiled ISA (Alpha).");
 446     switch (objFile->getOpSys()) {
 447       case ObjectFile::Tru64:
 448         process = new AlphaTru64Process(nm, objFile, system,
 449                                         stdin_fd, stdout_fd, stderr_fd,
 450                                         argv, envp, cwd,
 451                                         _uid, _euid, _gid, _egid, _pid, _ppid);
 452         break;
 453
 454       case ObjectFile::Linux:
 455         process = new AlphaLinuxProcess(nm, objFile, system,
 456                                         stdin_fd, stdout_fd, stderr_fd,
 457                                         argv, envp, cwd,
 458                                         _uid, _euid, _gid, _egid, _pid, _ppid);
 459         break;
 460
 461       default:
 462         fatal("Unknown/unsupported operating system.");
 463     }
 464 #elif THE_ISA == SPARC_ISA
 465     if (objFile->getArch() != ObjectFile::SPARC)
 466         fatal("Object file architecture does not match compiled ISA (SPARC).");
 467     switch (objFile->getOpSys()) {
 468       case ObjectFile::Linux:
 469         process = new SparcLinuxProcess(nm, objFile, system,
 470                                         stdin_fd, stdout_fd, stderr_fd,
 471                                         argv, envp, cwd,
 472                                         _uid, _euid, _gid, _egid, _pid, _ppid);
 473         break;
 474
 475
 476       case ObjectFile::Solaris:
 477         process = new SparcSolarisProcess(nm, objFile, system,
 478                                         stdin_fd, stdout_fd, stderr_fd,
 479                                         argv, envp, cwd,
 480                                         _uid, _euid, _gid, _egid, _pid, _ppid);
 481         break;
 482       default:
 483         fatal("Unknown/unsupported operating system.");
 484     }
 485 #elif THE_ISA == MIPS_ISA
 486     if (objFile->getArch() != ObjectFile::Mips)
 487         fatal("Object file architecture does not match compiled ISA (MIPS).");
 488     switch (objFile->getOpSys()) {
 489       case ObjectFile::Linux:
 490         process = new MipsLinuxProcess(nm, objFile, system,
 491                                         stdin_fd, stdout_fd, stderr_fd,
 492                                         argv, envp, cwd,
 493                                         _uid, _euid, _gid, _egid, _pid, _ppid);
 494         break;
 495
 496       default:
 497         fatal("Unknown/unsupported operating system.");
 498     }
 499 #else
 500 #error "THE_ISA not set"
 501 #endif
 502
 503
 504     if (process == NULL)
 505         fatal("Unknown error creating process object.");
 506     return process;
 507 }
 508
 509
 510 BEGIN_DECLARE_SIM_OBJECT_PARAMS(LiveProcess)
 511
 512     VectorParam<string> cmd;
 513     Param<string> executable;
 514     Param<string> input;
 515     Param<string> output;
 516     VectorParam<string> env;
 517     Param<string> cwd;
 518     SimObjectParam<System *> system;
 519     Param<uint64_t> uid;
 520     Param<uint64_t> euid;
 521     Param<uint64_t> gid;
 522     Param<uint64_t> egid;
 523     Param<uint64_t> pid;
 524     Param<uint64_t> ppid;
 525
 526 END_DECLARE_SIM_OBJECT_PARAMS(LiveProcess)
 527
 528
 529 BEGIN_INIT_SIM_OBJECT_PARAMS(LiveProcess)
 530
 531     INIT_PARAM(cmd, "command line (executable plus arguments)"),
 532     INIT_PARAM(executable, "executable (overrides cmd[0] if set)"),
 533     INIT_PARAM(input, "filename for stdin (dflt: use sim stdin)"),
 534     INIT_PARAM(output, "filename for stdout/stderr (dflt: use sim stdout)"),
 535     INIT_PARAM(env, "environment settings"),
 536     INIT_PARAM(cwd, "current working directory"),
 537     INIT_PARAM(system, "system"),
 538     INIT_PARAM(uid, "user id"),
 539     INIT_PARAM(euid, "effective user id"),
 540     INIT_PARAM(gid, "group id"),
 541     INIT_PARAM(egid, "effective group id"),
 542     INIT_PARAM(pid, "process id"),
 543     INIT_PARAM(ppid, "parent process id")
 544
 545 END_INIT_SIM_OBJECT_PARAMS(LiveProcess)
 546
 547
 548 CREATE_SIM_OBJECT(LiveProcess)
 549 {
 550     string in = input;
 551     string out = output;
 552
 553     // initialize file descriptors to default: same as simulator
 554     int stdin_fd, stdout_fd, stderr_fd;
 555
 556     if (in == "stdin" || in == "cin")
 557         stdin_fd = STDIN_FILENO;
 558     else
 559         stdin_fd = Process::openInputFile(input);
 560
 561     if (out == "stdout" || out == "cout")
 562         stdout_fd = STDOUT_FILENO;
 563     else if (out == "stderr" || out == "cerr")
 564         stdout_fd = STDERR_FILENO;
 565     else
 566         stdout_fd = Process::openOutputFile(out);
 567
 568     stderr_fd = (stdout_fd != STDOUT_FILENO) ? stdout_fd : STDERR_FILENO;
 569
 570     return LiveProcess::create(getInstanceName(), system,
 571                                stdin_fd, stdout_fd, stderr_fd,
 572                                (string)executable == "" ? cmd[0] : executable,
 573                                cmd, env, cwd,
 574                                uid, euid, gid, egid, pid, ppid);
 575 }
 576
 577
 578 REGISTER_SIM_OBJECT("LiveProcess", LiveProcess)