process.cc revision 13906:005b70666608
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 <climits> 54#include <csignal> 55#include <map> 56#include <string> 57#include <vector> 58 59#include "base/intmath.hh" 60#include "base/loader/object_file.hh" 61#include "base/loader/symtab.hh" 62#include "base/statistics.hh" 63#include "config/the_isa.hh" 64#include "cpu/thread_context.hh" 65#include "mem/page_table.hh" 66#include "mem/se_translating_port_proxy.hh" 67#include "params/Process.hh" 68#include "sim/emul_driver.hh" 69#include "sim/fd_array.hh" 70#include "sim/fd_entry.hh" 71#include "sim/redirect_path.hh" 72#include "sim/syscall_desc.hh" 73#include "sim/system.hh" 74 75#if THE_ISA == ALPHA_ISA 76#include "arch/alpha/linux/process.hh" 77 78#elif THE_ISA == SPARC_ISA 79#include "arch/sparc/linux/process.hh" 80#include "arch/sparc/solaris/process.hh" 81 82#elif THE_ISA == MIPS_ISA 83#include "arch/mips/linux/process.hh" 84 85#elif THE_ISA == ARM_ISA 86#include "arch/arm/freebsd/process.hh" 87#include "arch/arm/linux/process.hh" 88 89#elif THE_ISA == X86_ISA 90#include "arch/x86/linux/process.hh" 91 92#elif THE_ISA == POWER_ISA 93#include "arch/power/linux/process.hh" 94 95#elif THE_ISA == RISCV_ISA 96#include "arch/riscv/linux/process.hh" 97 98#else 99#error "THE_ISA not set" 100#endif 101 102 103using namespace std; 104using namespace TheISA; 105 106static std::string 107normalize(std::string& directory) 108{ 109 if (directory.back() != '/') 110 directory += '/'; 111 return directory; 112} 113 114Process::Process(ProcessParams *params, EmulationPageTable *pTable, 115 ObjectFile *obj_file) 116 : SimObject(params), system(params->system), 117 useArchPT(params->useArchPT), 118 kvmInSE(params->kvmInSE), 119 useForClone(false), 120 pTable(pTable), 121 initVirtMem(system->getSystemPort(), this, 122 SETranslatingPortProxy::Always), 123 objFile(obj_file), 124 argv(params->cmd), envp(params->env), 125 executable(params->executable), 126 tgtCwd(normalize(params->cwd)), 127 hostCwd(checkPathRedirect(tgtCwd)), 128 _uid(params->uid), _euid(params->euid), 129 _gid(params->gid), _egid(params->egid), 130 _pid(params->pid), _ppid(params->ppid), 131 _pgid(params->pgid), drivers(params->drivers), 132 fds(make_shared<FDArray>(params->input, params->output, params->errout)), 133 childClearTID(0) 134{ 135 if (_pid >= System::maxPID) 136 fatal("_pid is too large: %d", _pid); 137 138 auto ret_pair = system->PIDs.emplace(_pid); 139 if (!ret_pair.second) 140 fatal("_pid %d is already used", _pid); 141 142 /** 143 * Linux bundles together processes into this concept called a thread 144 * group. The thread group is responsible for recording which processes 145 * behave as threads within a process context. The thread group leader 146 * is the process who's tgid is equal to its pid. Other processes which 147 * belong to the thread group, but do not lead the thread group, are 148 * treated as child threads. These threads are created by the clone system 149 * call with options specified to create threads (differing from the 150 * options used to implement a fork). By default, set up the tgid/pid 151 * with a new, equivalent value. If CLONE_THREAD is specified, patch 152 * the tgid value with the old process' value. 153 */ 154 _tgid = params->pid; 155 156 exitGroup = new bool(); 157 sigchld = new bool(); 158 159 if (!debugSymbolTable) { 160 debugSymbolTable = new SymbolTable(); 161 if (!objFile->loadGlobalSymbols(debugSymbolTable) || 162 !objFile->loadLocalSymbols(debugSymbolTable) || 163 !objFile->loadWeakSymbols(debugSymbolTable)) { 164 delete debugSymbolTable; 165 debugSymbolTable = nullptr; 166 } 167 } 168} 169 170void 171Process::clone(ThreadContext *otc, ThreadContext *ntc, 172 Process *np, RegVal flags) 173{ 174#ifndef CLONE_VM 175#define CLONE_VM 0 176#endif 177#ifndef CLONE_FILES 178#define CLONE_FILES 0 179#endif 180#ifndef CLONE_THREAD 181#define CLONE_THREAD 0 182#endif 183 if (CLONE_VM & flags) { 184 /** 185 * Share the process memory address space between the new process 186 * and the old process. Changes in one will be visible in the other 187 * due to the pointer use. 188 */ 189 delete np->pTable; 190 np->pTable = pTable; 191 ntc->getMemProxy().setPageTable(np->pTable); 192 193 np->memState = memState; 194 } else { 195 /** 196 * Duplicate the process memory address space. The state needs to be 197 * copied over (rather than using pointers to share everything). 198 */ 199 typedef std::vector<pair<Addr,Addr>> MapVec; 200 MapVec mappings; 201 pTable->getMappings(&mappings); 202 203 for (auto map : mappings) { 204 Addr paddr, vaddr = map.first; 205 bool alloc_page = !(np->pTable->translate(vaddr, paddr)); 206 np->replicatePage(vaddr, paddr, otc, ntc, alloc_page); 207 } 208 209 *np->memState = *memState; 210 } 211 212 if (CLONE_FILES & flags) { 213 /** 214 * The parent and child file descriptors are shared because the 215 * two FDArray pointers are pointing to the same FDArray. Opening 216 * and closing file descriptors will be visible to both processes. 217 */ 218 np->fds = fds; 219 } else { 220 /** 221 * Copy the file descriptors from the old process into the new 222 * child process. The file descriptors entry can be opened and 223 * closed independently of the other process being considered. The 224 * host file descriptors are also dup'd so that the flags for the 225 * host file descriptor is independent of the other process. 226 */ 227 for (int tgt_fd = 0; tgt_fd < fds->getSize(); tgt_fd++) { 228 std::shared_ptr<FDArray> nfds = np->fds; 229 std::shared_ptr<FDEntry> this_fde = (*fds)[tgt_fd]; 230 if (!this_fde) { 231 nfds->setFDEntry(tgt_fd, nullptr); 232 continue; 233 } 234 nfds->setFDEntry(tgt_fd, this_fde->clone()); 235 236 auto this_hbfd = std::dynamic_pointer_cast<HBFDEntry>(this_fde); 237 if (!this_hbfd) 238 continue; 239 240 int this_sim_fd = this_hbfd->getSimFD(); 241 if (this_sim_fd <= 2) 242 continue; 243 244 int np_sim_fd = dup(this_sim_fd); 245 assert(np_sim_fd != -1); 246 247 auto nhbfd = std::dynamic_pointer_cast<HBFDEntry>((*nfds)[tgt_fd]); 248 nhbfd->setSimFD(np_sim_fd); 249 } 250 } 251 252 if (CLONE_THREAD & flags) { 253 np->_tgid = _tgid; 254 delete np->exitGroup; 255 np->exitGroup = exitGroup; 256 } 257 258 np->argv.insert(np->argv.end(), argv.begin(), argv.end()); 259 np->envp.insert(np->envp.end(), envp.begin(), envp.end()); 260} 261 262void 263Process::regStats() 264{ 265 SimObject::regStats(); 266 267 using namespace Stats; 268 269 numSyscalls 270 .name(name() + ".numSyscalls") 271 .desc("Number of system calls") 272 ; 273} 274 275ThreadContext * 276Process::findFreeContext() 277{ 278 for (auto &it : system->threadContexts) { 279 if (ThreadContext::Halted == it->status()) 280 return it; 281 } 282 return nullptr; 283} 284 285void 286Process::revokeThreadContext(int context_id) 287{ 288 std::vector<ContextID>::iterator it; 289 for (it = contextIds.begin(); it != contextIds.end(); it++) { 290 if (*it == context_id) { 291 contextIds.erase(it); 292 return; 293 } 294 } 295 warn("Unable to find thread context to revoke"); 296} 297 298void 299Process::initState() 300{ 301 if (contextIds.empty()) 302 fatal("Process %s is not associated with any HW contexts!\n", name()); 303 304 // first thread context for this process... initialize & enable 305 ThreadContext *tc = system->getThreadContext(contextIds[0]); 306 307 // mark this context as active so it will start ticking. 308 tc->activate(); 309 310 pTable->initState(tc); 311} 312 313DrainState 314Process::drain() 315{ 316 fds->updateFileOffsets(); 317 return DrainState::Drained; 318} 319 320void 321Process::allocateMem(Addr vaddr, int64_t size, bool clobber) 322{ 323 int npages = divCeil(size, (int64_t)PageBytes); 324 Addr paddr = system->allocPhysPages(npages); 325 pTable->map(vaddr, paddr, size, 326 clobber ? EmulationPageTable::Clobber : 327 EmulationPageTable::MappingFlags(0)); 328} 329 330void 331Process::replicatePage(Addr vaddr, Addr new_paddr, ThreadContext *old_tc, 332 ThreadContext *new_tc, bool allocate_page) 333{ 334 if (allocate_page) 335 new_paddr = system->allocPhysPages(1); 336 337 // Read from old physical page. 338 uint8_t *buf_p = new uint8_t[PageBytes]; 339 old_tc->getMemProxy().readBlob(vaddr, buf_p, PageBytes); 340 341 // Create new mapping in process address space by clobbering existing 342 // mapping (if any existed) and then write to the new physical page. 343 bool clobber = true; 344 pTable->map(vaddr, new_paddr, PageBytes, clobber); 345 new_tc->getMemProxy().writeBlob(vaddr, buf_p, PageBytes); 346 delete[] buf_p; 347} 348 349bool 350Process::fixupStackFault(Addr vaddr) 351{ 352 Addr stack_min = memState->getStackMin(); 353 Addr stack_base = memState->getStackBase(); 354 Addr max_stack_size = memState->getMaxStackSize(); 355 356 // Check if this is already on the stack and there's just no page there 357 // yet. 358 if (vaddr >= stack_min && vaddr < stack_base) { 359 allocateMem(roundDown(vaddr, PageBytes), PageBytes); 360 return true; 361 } 362 363 // We've accessed the next page of the stack, so extend it to include 364 // this address. 365 if (vaddr < stack_min && vaddr >= stack_base - max_stack_size) { 366 while (vaddr < stack_min) { 367 stack_min -= TheISA::PageBytes; 368 if (stack_base - stack_min > max_stack_size) 369 fatal("Maximum stack size exceeded\n"); 370 allocateMem(stack_min, TheISA::PageBytes); 371 inform("Increasing stack size by one page."); 372 } 373 memState->setStackMin(stack_min); 374 return true; 375 } 376 return false; 377} 378 379void 380Process::serialize(CheckpointOut &cp) const 381{ 382 memState->serialize(cp); 383 pTable->serialize(cp); 384 /** 385 * Checkpoints for file descriptors currently do not work. Need to 386 * come back and fix them at a later date. 387 */ 388 389 warn("Checkpoints for file descriptors currently do not work."); 390#if 0 391 for (int x = 0; x < fds->getSize(); x++) 392 (*fds)[x].serializeSection(cp, csprintf("FDEntry%d", x)); 393#endif 394 395} 396 397void 398Process::unserialize(CheckpointIn &cp) 399{ 400 memState->unserialize(cp); 401 pTable->unserialize(cp); 402 /** 403 * Checkpoints for file descriptors currently do not work. Need to 404 * come back and fix them at a later date. 405 */ 406 warn("Checkpoints for file descriptors currently do not work."); 407#if 0 408 for (int x = 0; x < fds->getSize(); x++) 409 (*fds)[x]->unserializeSection(cp, csprintf("FDEntry%d", x)); 410 fds->restoreFileOffsets(); 411#endif 412 // The above returns a bool so that you could do something if you don't 413 // find the param in the checkpoint if you wanted to, like set a default 414 // but in this case we'll just stick with the instantiated value if not 415 // found. 416} 417 418bool 419Process::map(Addr vaddr, Addr paddr, int size, bool cacheable) 420{ 421 pTable->map(vaddr, paddr, size, 422 cacheable ? EmulationPageTable::MappingFlags(0) : 423 EmulationPageTable::Uncacheable); 424 return true; 425} 426 427void 428Process::syscall(int64_t callnum, ThreadContext *tc, Fault *fault) 429{ 430 numSyscalls++; 431 432 SyscallDesc *desc = getDesc(callnum); 433 if (desc == nullptr) 434 fatal("Syscall %d out of range", callnum); 435 436 desc->doSyscall(callnum, this, tc, fault); 437} 438 439RegVal 440Process::getSyscallArg(ThreadContext *tc, int &i, int width) 441{ 442 return getSyscallArg(tc, i); 443} 444 445EmulatedDriver * 446Process::findDriver(std::string filename) 447{ 448 for (EmulatedDriver *d : drivers) { 449 if (d->match(filename)) 450 return d; 451 } 452 453 return nullptr; 454} 455 456std::string 457Process::checkPathRedirect(const std::string &filename) 458{ 459 // If the input parameter contains a relative path, convert it. 460 // The target version of the current working directory is fine since 461 // we immediately convert it using redirect paths into a host version. 462 auto abs_path = absolutePath(filename, false); 463 464 for (auto path : system->redirectPaths) { 465 // Search through the redirect paths to see if a starting substring of 466 // our path falls into any buckets which need to redirected. 467 if (startswith(abs_path, path->appPath())) { 468 std::string tail = abs_path.substr(path->appPath().size()); 469 470 // If this path needs to be redirected, search through a list 471 // of targets to see if we can match a valid file (or directory). 472 for (auto host_path : path->hostPaths()) { 473 if (access((host_path + tail).c_str(), R_OK) == 0) { 474 // Return the valid match. 475 return host_path + tail; 476 } 477 } 478 // The path needs to be redirected, but the file or directory 479 // does not exist on the host filesystem. Return the first 480 // host path as a default. 481 return path->hostPaths()[0] + tail; 482 } 483 } 484 485 // The path does not need to be redirected. 486 return abs_path; 487} 488 489void 490Process::updateBias() 491{ 492 ObjectFile *interp = objFile->getInterpreter(); 493 494 if (!interp || !interp->relocatable()) 495 return; 496 497 // Determine how large the interpreters footprint will be in the process 498 // address space. 499 Addr interp_mapsize = roundUp(interp->mapSize(), TheISA::PageBytes); 500 501 // We are allocating the memory area; set the bias to the lowest address 502 // in the allocated memory region. 503 Addr mmap_end = memState->getMmapEnd(); 504 Addr ld_bias = mmapGrowsDown() ? mmap_end - interp_mapsize : mmap_end; 505 506 // Adjust the process mmap area to give the interpreter room; the real 507 // execve system call would just invoke the kernel's internal mmap 508 // functions to make these adjustments. 509 mmap_end = mmapGrowsDown() ? ld_bias : mmap_end + interp_mapsize; 510 memState->setMmapEnd(mmap_end); 511 512 interp->updateBias(ld_bias); 513} 514 515ObjectFile * 516Process::getInterpreter() 517{ 518 return objFile->getInterpreter(); 519} 520 521Addr 522Process::getBias() 523{ 524 ObjectFile *interp = getInterpreter(); 525 526 return interp ? interp->bias() : objFile->bias(); 527} 528 529Addr 530Process::getStartPC() 531{ 532 ObjectFile *interp = getInterpreter(); 533 534 return interp ? interp->entryPoint() : objFile->entryPoint(); 535} 536 537std::string 538Process::absolutePath(const std::string &filename, bool host_filesystem) 539{ 540 if (filename.empty() || startswith(filename, "/")) 541 return filename; 542 543 // Construct the absolute path given the current working directory for 544 // either the host filesystem or target filesystem. The distinction only 545 // matters if filesystem redirection is utilized in the simulation. 546 auto path_base = std::string(); 547 if (host_filesystem) { 548 path_base = hostCwd; 549 assert(!hostCwd.empty()); 550 } else { 551 path_base = tgtCwd; 552 assert(!tgtCwd.empty()); 553 } 554 555 // Add a trailing '/' if the current working directory did not have one. 556 normalize(path_base); 557 558 // Append the filename onto the current working path. 559 auto absolute_path = path_base + filename; 560 561 return absolute_path; 562} 563 564Process * 565ProcessParams::create() 566{ 567 Process *process = nullptr; 568 569 // If not specified, set the executable parameter equal to the 570 // simulated system's zeroth command line parameter 571 if (executable == "") { 572 executable = cmd[0]; 573 } 574 575 ObjectFile *obj_file = createObjectFile(executable); 576 if (obj_file == nullptr) { 577 fatal("Can't load object file %s", executable); 578 } 579 580#if THE_ISA == ALPHA_ISA 581 if (obj_file->getArch() != ObjectFile::Alpha) 582 fatal("Object file architecture does not match compiled ISA (Alpha)."); 583 584 switch (obj_file->getOpSys()) { 585 case ObjectFile::UnknownOpSys: 586 warn("Unknown operating system; assuming Linux."); 587 // fall through 588 case ObjectFile::Linux: 589 process = new AlphaLinuxProcess(this, obj_file); 590 break; 591 592 default: 593 fatal("Unknown/unsupported operating system."); 594 } 595#elif THE_ISA == SPARC_ISA 596 if (obj_file->getArch() != ObjectFile::SPARC64 && 597 obj_file->getArch() != ObjectFile::SPARC32) 598 fatal("Object file architecture does not match compiled ISA (SPARC)."); 599 switch (obj_file->getOpSys()) { 600 case ObjectFile::UnknownOpSys: 601 warn("Unknown operating system; assuming Linux."); 602 // fall through 603 case ObjectFile::Linux: 604 if (obj_file->getArch() == ObjectFile::SPARC64) { 605 process = new Sparc64LinuxProcess(this, obj_file); 606 } else { 607 process = new Sparc32LinuxProcess(this, obj_file); 608 } 609 break; 610 611 case ObjectFile::Solaris: 612 process = new SparcSolarisProcess(this, obj_file); 613 break; 614 615 default: 616 fatal("Unknown/unsupported operating system."); 617 } 618#elif THE_ISA == X86_ISA 619 if (obj_file->getArch() != ObjectFile::X86_64 && 620 obj_file->getArch() != ObjectFile::I386) 621 fatal("Object file architecture does not match compiled ISA (x86)."); 622 switch (obj_file->getOpSys()) { 623 case ObjectFile::UnknownOpSys: 624 warn("Unknown operating system; assuming Linux."); 625 // fall through 626 case ObjectFile::Linux: 627 if (obj_file->getArch() == ObjectFile::X86_64) { 628 process = new X86_64LinuxProcess(this, obj_file); 629 } else { 630 process = new I386LinuxProcess(this, obj_file); 631 } 632 break; 633 634 default: 635 fatal("Unknown/unsupported operating system."); 636 } 637#elif THE_ISA == MIPS_ISA 638 if (obj_file->getArch() != ObjectFile::Mips) 639 fatal("Object file architecture does not match compiled ISA (MIPS)."); 640 switch (obj_file->getOpSys()) { 641 case ObjectFile::UnknownOpSys: 642 warn("Unknown operating system; assuming Linux."); 643 // fall through 644 case ObjectFile::Linux: 645 process = new MipsLinuxProcess(this, obj_file); 646 break; 647 648 default: 649 fatal("Unknown/unsupported operating system."); 650 } 651#elif THE_ISA == ARM_ISA 652 ObjectFile::Arch arch = obj_file->getArch(); 653 if (arch != ObjectFile::Arm && arch != ObjectFile::Thumb && 654 arch != ObjectFile::Arm64) 655 fatal("Object file architecture does not match compiled ISA (ARM)."); 656 switch (obj_file->getOpSys()) { 657 case ObjectFile::UnknownOpSys: 658 warn("Unknown operating system; assuming Linux."); 659 // fall through 660 case ObjectFile::Linux: 661 if (arch == ObjectFile::Arm64) { 662 process = new ArmLinuxProcess64(this, obj_file, 663 obj_file->getArch()); 664 } else { 665 process = new ArmLinuxProcess32(this, obj_file, 666 obj_file->getArch()); 667 } 668 break; 669 case ObjectFile::FreeBSD: 670 if (arch == ObjectFile::Arm64) { 671 process = new ArmFreebsdProcess64(this, obj_file, 672 obj_file->getArch()); 673 } else { 674 process = new ArmFreebsdProcess32(this, obj_file, 675 obj_file->getArch()); 676 } 677 break; 678 case ObjectFile::LinuxArmOABI: 679 fatal("M5 does not support ARM OABI binaries. Please recompile with an" 680 " EABI compiler."); 681 default: 682 fatal("Unknown/unsupported operating system."); 683 } 684#elif THE_ISA == POWER_ISA 685 if (obj_file->getArch() != ObjectFile::Power) 686 fatal("Object file architecture does not match compiled ISA (Power)."); 687 switch (obj_file->getOpSys()) { 688 case ObjectFile::UnknownOpSys: 689 warn("Unknown operating system; assuming Linux."); 690 // fall through 691 case ObjectFile::Linux: 692 process = new PowerLinuxProcess(this, obj_file); 693 break; 694 695 default: 696 fatal("Unknown/unsupported operating system."); 697 } 698#elif THE_ISA == RISCV_ISA 699 ObjectFile::Arch arch = obj_file->getArch(); 700 if (arch != ObjectFile::Riscv64 && arch != ObjectFile::Riscv32) 701 fatal("Object file architecture does not match compiled ISA (RISCV)."); 702 switch (obj_file->getOpSys()) { 703 case ObjectFile::UnknownOpSys: 704 warn("Unknown operating system; assuming Linux."); 705 // fall through 706 case ObjectFile::Linux: 707 if (arch == ObjectFile::Riscv64) { 708 process = new RiscvLinuxProcess64(this, obj_file); 709 } else { 710 process = new RiscvLinuxProcess32(this, obj_file); 711 } 712 break; 713 default: 714 fatal("Unknown/unsupported operating system."); 715 } 716#else 717#error "THE_ISA not set" 718#endif 719 720 if (process == nullptr) 721 fatal("Unknown error creating process object."); 722 return process; 723} 724