src/sim/process.cc

   1 /*
   2  * Copyright (c) 2014-2016 Advanced Micro Devices, Inc.
   3  * Copyright (c) 2012 ARM Limited
   4  * All rights reserved
   5  *
   6  * The license below extends only to copyright in the software and shall
   7  * not be construed as granting a license to any other intellectual
   8  * property including but not limited to intellectual property relating
   9  * to a hardware implementation of the functionality of the software
  10  * licensed hereunder.  You may use the software subject to the license
  11  * terms below provided that you ensure that this notice is replicated
  12  * unmodified and in its entirety in all distributions of the software,
  13  * modified or unmodified, in source code or in binary form.
  14  *
  15  * Copyright (c) 2001-2005 The Regents of The University of Michigan
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions are
  20  * met: redistributions of source code must retain the above copyright
  21  * notice, this list of conditions and the following disclaimer;
  22  * redistributions in binary form must reproduce the above copyright
  23  * notice, this list of conditions and the following disclaimer in the
  24  * documentation and/or other materials provided with the distribution;
  25  * neither the name of the copyright holders nor the names of its
  26  * contributors may be used to endorse or promote products derived from
  27  * this software without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  30  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  31  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  32  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  33  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  34  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  36  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  37  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  38  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  39  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  * Authors: Nathan Binkert
  42  *          Steve Reinhardt
  43  *          Ali Saidi
  44  *          Brandon Potter
  45  */
  46
  47 #include "sim/process.hh"
  48
  49 #include <fcntl.h>
  50 #include <unistd.h>
  51
  52 #include <array>
  53 #include <csignal>
  54 #include <map>
  55 #include <string>
  56 #include <vector>
  57
  58 #include "base/intmath.hh"
  59 #include "base/loader/object_file.hh"
  60 #include "base/loader/symtab.hh"
  61 #include "base/statistics.hh"
  62 #include "config/the_isa.hh"
  63 #include "cpu/thread_context.hh"
  64 #include "mem/page_table.hh"
  65 #include "mem/se_translating_port_proxy.hh"
  66 #include "params/Process.hh"
  67 #include "sim/emul_driver.hh"
  68 #include "sim/fd_array.hh"
  69 #include "sim/fd_entry.hh"
  70 #include "sim/syscall_desc.hh"
  71 #include "sim/system.hh"
  72
  73 #if THE_ISA == ALPHA_ISA
  74 #include "arch/alpha/linux/process.hh"
  75
  76 #elif THE_ISA == SPARC_ISA
  77 #include "arch/sparc/linux/process.hh"
  78 #include "arch/sparc/solaris/process.hh"
  79
  80 #elif THE_ISA == MIPS_ISA
  81 #include "arch/mips/linux/process.hh"
  82
  83 #elif THE_ISA == ARM_ISA
  84 #include "arch/arm/freebsd/process.hh"
  85 #include "arch/arm/linux/process.hh"
  86
  87 #elif THE_ISA == X86_ISA
  88 #include "arch/x86/linux/process.hh"
  89
  90 #elif THE_ISA == POWER_ISA
  91 #include "arch/power/linux/process.hh"
  92
  93 #elif THE_ISA == RISCV_ISA
  94 #include "arch/riscv/linux/process.hh"
  95
  96 #else
  97 #error "THE_ISA not set"
  98 #endif
  99
 100
 101 using namespace std;
 102 using namespace TheISA;
 103
 104 Process::Process(ProcessParams *params, EmulationPageTable *pTable,
 105                  ObjectFile *obj_file)
 106     : SimObject(params), system(params->system),
 107       useArchPT(params->useArchPT),
 108       kvmInSE(params->kvmInSE),
 109       pTable(pTable),
 110       initVirtMem(system->getSystemPort(), this,
 111                   SETranslatingPortProxy::Always),
 112       objFile(obj_file),
 113       argv(params->cmd), envp(params->env), cwd(params->cwd),
 114       executable(params->executable),
 115       _uid(params->uid), _euid(params->euid),
 116       _gid(params->gid), _egid(params->egid),
 117       _pid(params->pid), _ppid(params->ppid),
 118       _pgid(params->pgid), drivers(params->drivers),
 119       fds(make_shared<FDArray>(params->input, params->output, params->errout)),
 120       childClearTID(0)
 121 {
 122     if (_pid >= System::maxPID)
 123         fatal("_pid is too large: %d", _pid);
 124
 125     auto ret_pair = system->PIDs.emplace(_pid);
 126     if (!ret_pair.second)
 127         fatal("_pid %d is already used", _pid);
 128
 129     /**
 130      * Linux bundles together processes into this concept called a thread
 131      * group. The thread group is responsible for recording which processes
 132      * behave as threads within a process context. The thread group leader
 133      * is the process who's tgid is equal to its pid. Other processes which
 134      * belong to the thread group, but do not lead the thread group, are
 135      * treated as child threads. These threads are created by the clone system
 136      * call with options specified to create threads (differing from the
 137      * options used to implement a fork). By default, set up the tgid/pid
 138      * with a new, equivalent value. If CLONE_THREAD is specified, patch
 139      * the tgid value with the old process' value.
 140      */
 141     _tgid = params->pid;
 142
 143     exitGroup = new bool();
 144     sigchld = new bool();
 145
 146     if (!debugSymbolTable) {
 147         debugSymbolTable = new SymbolTable();
 148         if (!objFile->loadGlobalSymbols(debugSymbolTable) ||
 149             !objFile->loadLocalSymbols(debugSymbolTable) ||
 150             !objFile->loadWeakSymbols(debugSymbolTable)) {
 151             delete debugSymbolTable;
 152             debugSymbolTable = nullptr;
 153         }
 154     }
 155 }
 156
 157 void
 158 Process::clone(ThreadContext *otc, ThreadContext *ntc,
 159                Process *np, TheISA::IntReg flags)
 160 {
 161 #ifndef CLONE_VM
 162 #define CLONE_VM 0
 163 #endif
 164 #ifndef CLONE_FILES
 165 #define CLONE_FILES 0
 166 #endif
 167 #ifndef CLONE_THREAD
 168 #define CLONE_THREAD 0
 169 #endif
 170     if (CLONE_VM & flags) {
 171         /**
 172          * Share the process memory address space between the new process
 173          * and the old process. Changes in one will be visible in the other
 174          * due to the pointer use.
 175          */
 176         delete np->pTable;
 177         np->pTable = pTable;
 178         ntc->getMemProxy().setPageTable(np->pTable);
 179
 180         np->memState = memState;
 181     } else {
 182         /**
 183          * Duplicate the process memory address space. The state needs to be
 184          * copied over (rather than using pointers to share everything).
 185          */
 186         typedef std::vector<pair<Addr,Addr>> MapVec;
 187         MapVec mappings;
 188         pTable->getMappings(&mappings);
 189
 190         for (auto map : mappings) {
 191             Addr paddr, vaddr = map.first;
 192             bool alloc_page = !(np->pTable->translate(vaddr, paddr));
 193             np->replicatePage(vaddr, paddr, otc, ntc, alloc_page);
 194         }
 195
 196         *np->memState = *memState;
 197     }
 198
 199     if (CLONE_FILES & flags) {
 200         /**
 201          * The parent and child file descriptors are shared because the
 202          * two FDArray pointers are pointing to the same FDArray. Opening
 203          * and closing file descriptors will be visible to both processes.
 204          */
 205         np->fds = fds;
 206     } else {
 207         /**
 208          * Copy the file descriptors from the old process into the new
 209          * child process. The file descriptors entry can be opened and
 210          * closed independently of the other process being considered. The
 211          * host file descriptors are also dup'd so that the flags for the
 212          * host file descriptor is independent of the other process.
 213          */
 214         for (int tgt_fd = 0; tgt_fd < fds->getSize(); tgt_fd++) {
 215             std::shared_ptr<FDArray> nfds = np->fds;
 216             std::shared_ptr<FDEntry> this_fde = (*fds)[tgt_fd];
 217             if (!this_fde) {
 218                 nfds->setFDEntry(tgt_fd, nullptr);
 219                 continue;
 220             }
 221             nfds->setFDEntry(tgt_fd, this_fde->clone());
 222
 223             auto this_hbfd = std::dynamic_pointer_cast<HBFDEntry>(this_fde);
 224             if (!this_hbfd)
 225                 continue;
 226
 227             int this_sim_fd = this_hbfd->getSimFD();
 228             if (this_sim_fd <= 2)
 229                 continue;
 230
 231             int np_sim_fd = dup(this_sim_fd);
 232             assert(np_sim_fd != -1);
 233
 234             auto nhbfd = std::dynamic_pointer_cast<HBFDEntry>((*nfds)[tgt_fd]);
 235             nhbfd->setSimFD(np_sim_fd);
 236         }
 237     }
 238
 239     if (CLONE_THREAD & flags) {
 240         np->_tgid = _tgid;
 241         delete np->exitGroup;
 242         np->exitGroup = exitGroup;
 243     }
 244
 245     np->argv.insert(np->argv.end(), argv.begin(), argv.end());
 246     np->envp.insert(np->envp.end(), envp.begin(), envp.end());
 247 }
 248
 249 void
 250 Process::regStats()
 251 {
 252     SimObject::regStats();
 253
 254     using namespace Stats;
 255
 256     numSyscalls
 257         .name(name() + ".numSyscalls")
 258         .desc("Number of system calls")
 259         ;
 260 }
 261
 262 ThreadContext *
 263 Process::findFreeContext()
 264 {
 265     for (auto &it : system->threadContexts) {
 266         if (ThreadContext::Halted == it->status())
 267             return it;
 268     }
 269     return nullptr;
 270 }
 271
 272 void
 273 Process::revokeThreadContext(int context_id)
 274 {
 275     std::vector<ContextID>::iterator it;
 276     for (it = contextIds.begin(); it != contextIds.end(); it++) {
 277         if (*it == context_id) {
 278             contextIds.erase(it);
 279             return;
 280         }
 281     }
 282     warn("Unable to find thread context to revoke");
 283 }
 284
 285 void
 286 Process::initState()
 287 {
 288     if (contextIds.empty())
 289         fatal("Process %s is not associated with any HW contexts!\n", name());
 290
 291     // first thread context for this process... initialize & enable
 292     ThreadContext *tc = system->getThreadContext(contextIds[0]);
 293
 294     // mark this context as active so it will start ticking.
 295     tc->activate();
 296
 297     pTable->initState(tc);
 298 }
 299
 300 DrainState
 301 Process::drain()
 302 {
 303     fds->updateFileOffsets();
 304     return DrainState::Drained;
 305 }
 306
 307 void
 308 Process::allocateMem(Addr vaddr, int64_t size, bool clobber)
 309 {
 310     int npages = divCeil(size, (int64_t)PageBytes);
 311     Addr paddr = system->allocPhysPages(npages);
 312     pTable->map(vaddr, paddr, size,
 313                 clobber ? EmulationPageTable::Clobber :
 314                           EmulationPageTable::Zero);
 315 }
 316
 317 void
 318 Process::replicatePage(Addr vaddr, Addr new_paddr, ThreadContext *old_tc,
 319                        ThreadContext *new_tc, bool allocate_page)
 320 {
 321     if (allocate_page)
 322         new_paddr = system->allocPhysPages(1);
 323
 324     // Read from old physical page.
 325     uint8_t *buf_p = new uint8_t[PageBytes];
 326     old_tc->getMemProxy().readBlob(vaddr, buf_p, PageBytes);
 327
 328     // Create new mapping in process address space by clobbering existing
 329     // mapping (if any existed) and then write to the new physical page.
 330     bool clobber = true;
 331     pTable->map(vaddr, new_paddr, PageBytes, clobber);
 332     new_tc->getMemProxy().writeBlob(vaddr, buf_p, PageBytes);
 333     delete[] buf_p;
 334 }
 335
 336 bool
 337 Process::fixupStackFault(Addr vaddr)
 338 {
 339     Addr stack_min = memState->getStackMin();
 340     Addr stack_base = memState->getStackBase();
 341     Addr max_stack_size = memState->getMaxStackSize();
 342
 343     // Check if this is already on the stack and there's just no page there
 344     // yet.
 345     if (vaddr >= stack_min && vaddr < stack_base) {
 346         allocateMem(roundDown(vaddr, PageBytes), PageBytes);
 347         return true;
 348     }
 349
 350     // We've accessed the next page of the stack, so extend it to include
 351     // this address.
 352     if (vaddr < stack_min && vaddr >= stack_base - max_stack_size) {
 353         while (vaddr < stack_min) {
 354             stack_min -= TheISA::PageBytes;
 355             if (stack_base - stack_min > max_stack_size)
 356                 fatal("Maximum stack size exceeded\n");
 357             allocateMem(stack_min, TheISA::PageBytes);
 358             inform("Increasing stack size by one page.");
 359         }
 360         memState->setStackMin(stack_min);
 361         return true;
 362     }
 363     return false;
 364 }
 365
 366 void
 367 Process::serialize(CheckpointOut &cp) const
 368 {
 369     memState->serialize(cp);
 370     pTable->serialize(cp);
 371     /**
 372      * Checkpoints for file descriptors currently do not work. Need to
 373      * come back and fix them at a later date.
 374      */
 375
 376     warn("Checkpoints for file descriptors currently do not work.");
 377 #if 0
 378     for (int x = 0; x < fds->getSize(); x++)
 379         (*fds)[x].serializeSection(cp, csprintf("FDEntry%d", x));
 380 #endif
 381
 382 }
 383
 384 void
 385 Process::unserialize(CheckpointIn &cp)
 386 {
 387     memState->unserialize(cp);
 388     pTable->unserialize(cp);
 389     /**
 390      * Checkpoints for file descriptors currently do not work. Need to
 391      * come back and fix them at a later date.
 392      */
 393     warn("Checkpoints for file descriptors currently do not work.");
 394 #if 0
 395     for (int x = 0; x < fds->getSize(); x++)
 396         (*fds)[x]->unserializeSection(cp, csprintf("FDEntry%d", x));
 397     fds->restoreFileOffsets();
 398 #endif
 399     // The above returns a bool so that you could do something if you don't
 400     // find the param in the checkpoint if you wanted to, like set a default
 401     // but in this case we'll just stick with the instantiated value if not
 402     // found.
 403 }
 404
 405 bool
 406 Process::map(Addr vaddr, Addr paddr, int size, bool cacheable)
 407 {
 408     pTable->map(vaddr, paddr, size,
 409                 cacheable ? EmulationPageTable::Zero :
 410                             EmulationPageTable::Uncacheable);
 411     return true;
 412 }
 413
 414 void
 415 Process::syscall(int64_t callnum, ThreadContext *tc, Fault *fault)
 416 {
 417     numSyscalls++;
 418
 419     SyscallDesc *desc = getDesc(callnum);
 420     if (desc == nullptr)
 421         fatal("Syscall %d out of range", callnum);
 422
 423     desc->doSyscall(callnum, this, tc, fault);
 424 }
 425
 426 IntReg
 427 Process::getSyscallArg(ThreadContext *tc, int &i, int width)
 428 {
 429     return getSyscallArg(tc, i);
 430 }
 431
 432 EmulatedDriver *
 433 Process::findDriver(std::string filename)
 434 {
 435     for (EmulatedDriver *d : drivers) {
 436         if (d->match(filename))
 437             return d;
 438     }
 439
 440     return nullptr;
 441 }
 442
 443 void
 444 Process::updateBias()
 445 {
 446     ObjectFile *interp = objFile->getInterpreter();
 447
 448     if (!interp || !interp->relocatable())
 449         return;
 450
 451     // Determine how large the interpreters footprint will be in the process
 452     // address space.
 453     Addr interp_mapsize = roundUp(interp->mapSize(), TheISA::PageBytes);
 454
 455     // We are allocating the memory area; set the bias to the lowest address
 456     // in the allocated memory region.
 457     Addr mmap_end = memState->getMmapEnd();
 458     Addr ld_bias = mmapGrowsDown() ? mmap_end - interp_mapsize : mmap_end;
 459
 460     // Adjust the process mmap area to give the interpreter room; the real
 461     // execve system call would just invoke the kernel's internal mmap
 462     // functions to make these adjustments.
 463     mmap_end = mmapGrowsDown() ? ld_bias : mmap_end + interp_mapsize;
 464     memState->setMmapEnd(mmap_end);
 465
 466     interp->updateBias(ld_bias);
 467 }
 468
 469 ObjectFile *
 470 Process::getInterpreter()
 471 {
 472     return objFile->getInterpreter();
 473 }
 474
 475 Addr
 476 Process::getBias()
 477 {
 478     ObjectFile *interp = getInterpreter();
 479
 480     return interp ? interp->bias() : objFile->bias();
 481 }
 482
 483 Addr
 484 Process::getStartPC()
 485 {
 486     ObjectFile *interp = getInterpreter();
 487
 488     return interp ? interp->entryPoint() : objFile->entryPoint();
 489 }
 490
 491 Process *
 492 ProcessParams::create()
 493 {
 494     Process *process = nullptr;
 495
 496     // If not specified, set the executable parameter equal to the
 497     // simulated system's zeroth command line parameter
 498     if (executable == "") {
 499         executable = cmd[0];
 500     }
 501
 502     ObjectFile *obj_file = createObjectFile(executable);
 503     if (obj_file == nullptr) {
 504         fatal("Can't load object file %s", executable);
 505     }
 506
 507 #if THE_ISA == ALPHA_ISA
 508     if (obj_file->getArch() != ObjectFile::Alpha)
 509         fatal("Object file architecture does not match compiled ISA (Alpha).");
 510
 511     switch (obj_file->getOpSys()) {
 512       case ObjectFile::UnknownOpSys:
 513         warn("Unknown operating system; assuming Linux.");
 514         // fall through
 515       case ObjectFile::Linux:
 516         process = new AlphaLinuxProcess(this, obj_file);
 517         break;
 518
 519       default:
 520         fatal("Unknown/unsupported operating system.");
 521     }
 522 #elif THE_ISA == SPARC_ISA
 523     if (obj_file->getArch() != ObjectFile::SPARC64 &&
 524         obj_file->getArch() != ObjectFile::SPARC32)
 525         fatal("Object file architecture does not match compiled ISA (SPARC).");
 526     switch (obj_file->getOpSys()) {
 527       case ObjectFile::UnknownOpSys:
 528         warn("Unknown operating system; assuming Linux.");
 529         // fall through
 530       case ObjectFile::Linux:
 531         if (obj_file->getArch() == ObjectFile::SPARC64) {
 532             process = new Sparc64LinuxProcess(this, obj_file);
 533         } else {
 534             process = new Sparc32LinuxProcess(this, obj_file);
 535         }
 536         break;
 537
 538       case ObjectFile::Solaris:
 539         process = new SparcSolarisProcess(this, obj_file);
 540         break;
 541
 542       default:
 543         fatal("Unknown/unsupported operating system.");
 544     }
 545 #elif THE_ISA == X86_ISA
 546     if (obj_file->getArch() != ObjectFile::X86_64 &&
 547         obj_file->getArch() != ObjectFile::I386)
 548         fatal("Object file architecture does not match compiled ISA (x86).");
 549     switch (obj_file->getOpSys()) {
 550       case ObjectFile::UnknownOpSys:
 551         warn("Unknown operating system; assuming Linux.");
 552         // fall through
 553       case ObjectFile::Linux:
 554         if (obj_file->getArch() == ObjectFile::X86_64) {
 555             process = new X86_64LinuxProcess(this, obj_file);
 556         } else {
 557             process = new I386LinuxProcess(this, obj_file);
 558         }
 559         break;
 560
 561       default:
 562         fatal("Unknown/unsupported operating system.");
 563     }
 564 #elif THE_ISA == MIPS_ISA
 565     if (obj_file->getArch() != ObjectFile::Mips)
 566         fatal("Object file architecture does not match compiled ISA (MIPS).");
 567     switch (obj_file->getOpSys()) {
 568       case ObjectFile::UnknownOpSys:
 569         warn("Unknown operating system; assuming Linux.");
 570         // fall through
 571       case ObjectFile::Linux:
 572         process = new MipsLinuxProcess(this, obj_file);
 573         break;
 574
 575       default:
 576         fatal("Unknown/unsupported operating system.");
 577     }
 578 #elif THE_ISA == ARM_ISA
 579     ObjectFile::Arch arch = obj_file->getArch();
 580     if (arch != ObjectFile::Arm && arch != ObjectFile::Thumb &&
 581         arch != ObjectFile::Arm64)
 582         fatal("Object file architecture does not match compiled ISA (ARM).");
 583     switch (obj_file->getOpSys()) {
 584       case ObjectFile::UnknownOpSys:
 585         warn("Unknown operating system; assuming Linux.");
 586         // fall through
 587       case ObjectFile::Linux:
 588         if (arch == ObjectFile::Arm64) {
 589             process = new ArmLinuxProcess64(this, obj_file,
 590                                             obj_file->getArch());
 591         } else {
 592             process = new ArmLinuxProcess32(this, obj_file,
 593                                             obj_file->getArch());
 594         }
 595         break;
 596       case ObjectFile::FreeBSD:
 597         if (arch == ObjectFile::Arm64) {
 598             process = new ArmFreebsdProcess64(this, obj_file,
 599                                               obj_file->getArch());
 600         } else {
 601             process = new ArmFreebsdProcess32(this, obj_file,
 602                                               obj_file->getArch());
 603         }
 604         break;
 605       case ObjectFile::LinuxArmOABI:
 606         fatal("M5 does not support ARM OABI binaries. Please recompile with an"
 607               " EABI compiler.");
 608       default:
 609         fatal("Unknown/unsupported operating system.");
 610     }
 611 #elif THE_ISA == POWER_ISA
 612     if (obj_file->getArch() != ObjectFile::Power)
 613         fatal("Object file architecture does not match compiled ISA (Power).");
 614     switch (obj_file->getOpSys()) {
 615       case ObjectFile::UnknownOpSys:
 616         warn("Unknown operating system; assuming Linux.");
 617         // fall through
 618       case ObjectFile::Linux:
 619         process = new PowerLinuxProcess(this, obj_file);
 620         break;
 621
 622       default:
 623         fatal("Unknown/unsupported operating system.");
 624     }
 625 #elif THE_ISA == RISCV_ISA
 626     if (obj_file->getArch() != ObjectFile::Riscv)
 627         fatal("Object file architecture does not match compiled ISA (RISCV).");
 628     switch (obj_file->getOpSys()) {
 629       case ObjectFile::UnknownOpSys:
 630         warn("Unknown operating system; assuming Linux.");
 631         // fall through
 632       case ObjectFile::Linux:
 633         process = new RiscvLinuxProcess(this, obj_file);
 634         break;
 635       default:
 636         fatal("Unknown/unsupported operating system.");
 637     }
 638 #else
 639 #error "THE_ISA not set"
 640 #endif
 641
 642     if (process == nullptr)
 643         fatal("Unknown error creating process object.");
 644     return process;
 645 }
 646
 647 std::string
 648 Process::fullPath(const std::string &file_name)
 649 {
 650     if (file_name[0] == '/' || cwd.empty())
 651         return file_name;
 652
 653     std::string full = cwd;
 654
 655     if (cwd[cwd.size() - 1] != '/')
 656         full += '/';
 657
 658     return full + file_name;
 659 }