process.cc revision 5282 
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#include <string>
36
37#include "arch/remote_gdb.hh"
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 "params/Process.hh"
48#include "params/LiveProcess.hh"
49#include "sim/process.hh"
50#include "sim/process_impl.hh"
51#include "sim/stats.hh"
52#include "sim/syscall_emul.hh"
53#include "sim/system.hh"
54
55#include "arch/isa_specific.hh"
56#if THE_ISA == ALPHA_ISA
57#include "arch/alpha/linux/process.hh"
58#include "arch/alpha/tru64/process.hh"
59#elif THE_ISA == SPARC_ISA
60#include "arch/sparc/linux/process.hh"
61#include "arch/sparc/solaris/process.hh"
62#elif THE_ISA == MIPS_ISA
63#include "arch/mips/linux/process.hh"
64#elif THE_ISA == X86_ISA
65#include "arch/x86/linux/process.hh"
66#else
67#error "THE_ISA not set"
68#endif
69
70
71using namespace std;
72using namespace TheISA;
73
74//
75// The purpose of this code is to fake the loader & syscall mechanism
76// when there's no OS: thus there's no resone to use it in FULL_SYSTEM
77// mode when we do have an OS
78//
79#if FULL_SYSTEM
80#error "process.cc not compatible with FULL_SYSTEM"
81#endif
82
83// current number of allocated processes
84int num_processes = 0;
85
86Process::Process(ProcessParams * params)
87    : SimObject(params), system(params->system), checkpointRestored(false),
88    max_stack_size(params->max_stack_size)
89{
90    string in = params->input;
91    string out = params->output;
92
93    // initialize file descriptors to default: same as simulator
94    int stdin_fd, stdout_fd, stderr_fd;
95
96    if (in == "stdin" || in == "cin")
97        stdin_fd = STDIN_FILENO;
98    else if (in == "None")
99        stdin_fd = -1;
100    else
101        stdin_fd = Process::openInputFile(in);
102
103    if (out == "stdout" || out == "cout")
104        stdout_fd = STDOUT_FILENO;
105    else if (out == "stderr" || out == "cerr")
106        stdout_fd = STDERR_FILENO;
107    else if (out == "None")
108        stdout_fd = -1;
109    else
110        stdout_fd = Process::openOutputFile(out);
111
112    stderr_fd = (stdout_fd != STDOUT_FILENO) ? stdout_fd : STDERR_FILENO;
113
114    M5_pid = system->allocatePID();
115    // initialize first 3 fds (stdin, stdout, stderr)
116    Process::FdMap *fdo = &fd_map[STDIN_FILENO];
117    fdo->fd = stdin_fd;
118    fdo->filename = in;
119    fdo->flags = O_RDONLY;
120    fdo->mode = -1;
121    fdo->fileOffset = 0;
122
123    fdo =  &fd_map[STDOUT_FILENO];
124    fdo->fd = stdout_fd;
125    fdo->filename = out;
126    fdo->flags =  O_WRONLY | O_CREAT | O_TRUNC;
127    fdo->mode = 0774;
128    fdo->fileOffset = 0;
129
130    fdo = &fd_map[STDERR_FILENO];
131    fdo->fd = stderr_fd;
132    fdo->filename = "STDERR";
133    fdo->flags = O_WRONLY;
134    fdo->mode = -1;
135    fdo->fileOffset = 0;
136
137
138    // mark remaining fds as free
139    for (int i = 3; i <= MAX_FD; ++i) {
140        Process::FdMap *fdo = &fd_map[i];
141        fdo->fd = -1;
142    }
143
144    mmap_start = mmap_end = 0;
145    nxm_start = nxm_end = 0;
146    pTable = new PageTable(this);
147    // other parameters will be initialized when the program is loaded
148}
149
150
151void
152Process::regStats()
153{
154    using namespace Stats;
155
156    num_syscalls
157        .name(name() + ".PROG:num_syscalls")
158        .desc("Number of system calls")
159        ;
160}
161
162//
163// static helper functions
164//
165int
166Process::openInputFile(const string &filename)
167{
168    int fd = open(filename.c_str(), O_RDONLY);
169
170    if (fd == -1) {
171        perror(NULL);
172        cerr << "unable to open \"" << filename << "\" for reading\n";
173        fatal("can't open input file");
174    }
175
176    return fd;
177}
178
179
180int
181Process::openOutputFile(const string &filename)
182{
183    int fd = open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0774);
184
185    if (fd == -1) {
186        perror(NULL);
187        cerr << "unable to open \"" << filename << "\" for writing\n";
188        fatal("can't open output file");
189    }
190
191    return fd;
192}
193
194
195int
196Process::registerThreadContext(ThreadContext *tc)
197{
198    // add to list
199    int myIndex = threadContexts.size();
200    threadContexts.push_back(tc);
201
202    RemoteGDB *rgdb = new RemoteGDB(system, tc);
203    GDBListener *gdbl = new GDBListener(rgdb, 7000 + myIndex);
204    gdbl->listen();
205    //gdbl->accept();
206
207    remoteGDB.push_back(rgdb);
208
209    // return CPU number to caller
210    return myIndex;
211}
212
213void
214Process::startup()
215{
216    if (threadContexts.empty())
217        fatal("Process %s is not associated with any CPUs!\n", name());
218
219    // first thread context for this process... initialize & enable
220    ThreadContext *tc = threadContexts[0];
221
222    // mark this context as active so it will start ticking.
223    tc->activate(0);
224
225    Port *mem_port;
226    mem_port = system->physmem->getPort("functional");
227    initVirtMem = new TranslatingPort("process init port", this,
228            TranslatingPort::Always);
229    mem_port->setPeer(initVirtMem);
230    initVirtMem->setPeer(mem_port);
231}
232
233void
234Process::replaceThreadContext(ThreadContext *tc, int tcIndex)
235{
236    if (tcIndex >= threadContexts.size()) {
237        panic("replaceThreadContext: bad tcIndex, %d >= %d\n",
238              tcIndex, threadContexts.size());
239    }
240
241    threadContexts[tcIndex] = tc;
242}
243
244// map simulator fd sim_fd to target fd tgt_fd
245void
246Process::dup_fd(int sim_fd, int tgt_fd)
247{
248    if (tgt_fd < 0 || tgt_fd > MAX_FD)
249        panic("Process::dup_fd tried to dup past MAX_FD (%d)", tgt_fd);
250
251    Process::FdMap *fdo = &fd_map[tgt_fd];
252    fdo->fd = sim_fd;
253}
254
255
256// generate new target fd for sim_fd
257int
258Process::alloc_fd(int sim_fd, string filename, int flags, int mode, bool pipe)
259{
260    // in case open() returns an error, don't allocate a new fd
261    if (sim_fd == -1)
262        return -1;
263
264    // find first free target fd
265    for (int free_fd = 0; free_fd <= MAX_FD; ++free_fd) {
266        Process::FdMap *fdo = &fd_map[free_fd];
267        if (fdo->fd == -1) {
268            fdo->fd = sim_fd;
269            fdo->filename = filename;
270            fdo->mode = mode;
271            fdo->fileOffset = 0;
272            fdo->flags = flags;
273            fdo->isPipe = pipe;
274            fdo->readPipeSource = 0;
275            return free_fd;
276        }
277    }
278
279    panic("Process::alloc_fd: out of file descriptors!");
280}
281
282
283// free target fd (e.g., after close)
284void
285Process::free_fd(int tgt_fd)
286{
287    Process::FdMap *fdo = &fd_map[tgt_fd];
288    if (fdo->fd == -1)
289        warn("Process::free_fd: request to free unused fd %d", tgt_fd);
290
291    fdo->fd = -1;
292    fdo->filename = "NULL";
293    fdo->mode = 0;
294    fdo->fileOffset = 0;
295    fdo->flags = 0;
296    fdo->isPipe = false;
297    fdo->readPipeSource = 0;
298}
299
300
301// look up simulator fd for given target fd
302int
303Process::sim_fd(int tgt_fd)
304{
305    if (tgt_fd > MAX_FD)
306        return -1;
307
308    return fd_map[tgt_fd].fd;
309}
310
311Process::FdMap *
312Process::sim_fd_obj(int tgt_fd)
313{
314    if (tgt_fd > MAX_FD)
315        panic("sim_fd_obj called in fd out of range.");
316
317    return &fd_map[tgt_fd];
318}
319bool
320Process::checkAndAllocNextPage(Addr vaddr)
321{
322    // if this is an initial write we might not have
323    if (vaddr >= stack_min && vaddr < stack_base) {
324        pTable->allocate(roundDown(vaddr, VMPageSize), VMPageSize);
325        return true;
326    }
327
328    // We've accessed the next page of the stack, so extend the stack
329    // to cover it.
330    if (vaddr < stack_min && vaddr >= stack_base - max_stack_size) {
331        while (vaddr < stack_min) {
332            stack_min -= TheISA::PageBytes;
333            if(stack_base - stack_min > max_stack_size)
334                fatal("Maximum stack size exceeded\n");
335            if(stack_base - stack_min > 8*1024*1024)
336                fatal("Over max stack size for one thread\n");
337            pTable->allocate(stack_min, TheISA::PageBytes);
338            warn("Increasing stack size by one page.");
339        };
340        return true;
341    }
342    return false;
343}
344
345 // find all offsets for currently open files and save them
346void
347Process::fix_file_offsets() {
348    Process::FdMap *fdo_stdin = &fd_map[STDIN_FILENO];
349    Process::FdMap *fdo_stdout = &fd_map[STDOUT_FILENO];
350    Process::FdMap *fdo_stderr = &fd_map[STDERR_FILENO];
351    string in = fdo_stdin->filename;
352    string out = fdo_stdout->filename;
353
354    // initialize file descriptors to default: same as simulator
355    int stdin_fd, stdout_fd, stderr_fd;
356
357    if (in == "stdin" || in == "cin")
358        stdin_fd = STDIN_FILENO;
359    else if (in == "None")
360        stdin_fd = -1;
361    else{
362        //OPEN standard in and seek to the right location
363        stdin_fd = Process::openInputFile(in);
364        if (lseek(stdin_fd, fdo_stdin->fileOffset, SEEK_SET) < 0)
365            panic("Unable to seek to correct location in file: %s", in);
366    }
367
368    if (out == "stdout" || out == "cout")
369        stdout_fd = STDOUT_FILENO;
370    else if (out == "stderr" || out == "cerr")
371        stdout_fd = STDERR_FILENO;
372    else if (out == "None")
373        stdout_fd = -1;
374    else{
375        stdout_fd = Process::openOutputFile(out);
376        if (lseek(stdin_fd, fdo_stdout->fileOffset, SEEK_SET) < 0)
377            panic("Unable to seek to correct in file: %s", out);
378    }
379
380    stderr_fd = (stdout_fd != STDOUT_FILENO) ? stdout_fd : STDERR_FILENO;
381
382    fdo_stdin->fd = stdin_fd;
383    fdo_stdout->fd = stdout_fd;
384    fdo_stderr->fd = stderr_fd;
385
386
387    for (int free_fd = 3; free_fd <= MAX_FD; ++free_fd) {
388        Process::FdMap *fdo = &fd_map[free_fd];
389        if (fdo->fd != -1) {
390            if (fdo->isPipe){
391                if (fdo->filename == "PIPE-WRITE")
392                    continue;
393                else {
394                    assert (fdo->filename == "PIPE-READ");
395                    //create a new pipe
396                    int fds[2];
397                    int pipe_retval = pipe(fds);
398
399                    if (pipe_retval < 0) {
400                        // error
401                        panic("Unable to create new pipe.");
402                    }
403                    fdo->fd = fds[0]; //set read pipe
404                    Process::FdMap *fdo_write = &fd_map[fdo->readPipeSource];
405                    if (fdo_write->filename != "PIPE-WRITE")
406                        panic ("Couldn't find write end of the pipe");
407
408                    fdo_write->fd = fds[1];//set write pipe
409               }
410            } else {
411                //Open file
412                int fd = open(fdo->filename.c_str(), fdo->flags, fdo->mode);
413
414                if (fd == -1)
415                    panic("Unable to open file: %s", fdo->filename);
416                fdo->fd = fd;
417
418                //Seek to correct location before checkpoint
419                if (lseek(fd,fdo->fileOffset, SEEK_SET) < 0)
420                    panic("Unable to seek to correct location in file: %s", fdo->filename);
421            }
422        }
423    }
424}
425void
426Process::find_file_offsets(){
427    for (int free_fd = 0; free_fd <= MAX_FD; ++free_fd) {
428        Process::FdMap *fdo = &fd_map[free_fd];
429        if (fdo->fd != -1) {
430            fdo->fileOffset = lseek(fdo->fd, 0, SEEK_CUR);
431        }  else {
432                fdo->filename = "NULL";
433                fdo->fileOffset = 0;
434        }
435    }
436}
437
438void
439Process::setReadPipeSource(int read_pipe_fd, int source_fd){
440    Process::FdMap *fdo = &fd_map[read_pipe_fd];
441    fdo->readPipeSource = source_fd;
442}
443
444void
445Process::FdMap::serialize(std::ostream &os)
446{
447    SERIALIZE_SCALAR(fd);
448    SERIALIZE_SCALAR(isPipe);
449    SERIALIZE_SCALAR(filename);
450    SERIALIZE_SCALAR(flags);
451    SERIALIZE_SCALAR(readPipeSource);
452    SERIALIZE_SCALAR(fileOffset);
453}
454
455void
456Process::FdMap::unserialize(Checkpoint *cp, const std::string &section)
457{
458    UNSERIALIZE_SCALAR(fd);
459    UNSERIALIZE_SCALAR(isPipe);
460    UNSERIALIZE_SCALAR(filename);
461    UNSERIALIZE_SCALAR(flags);
462    UNSERIALIZE_SCALAR(readPipeSource);
463    UNSERIALIZE_SCALAR(fileOffset);
464}
465
466void
467Process::serialize(std::ostream &os)
468{
469    SERIALIZE_SCALAR(initialContextLoaded);
470    SERIALIZE_SCALAR(brk_point);
471    SERIALIZE_SCALAR(stack_base);
472    SERIALIZE_SCALAR(stack_size);
473    SERIALIZE_SCALAR(stack_min);
474    SERIALIZE_SCALAR(next_thread_stack_base);
475    SERIALIZE_SCALAR(mmap_start);
476    SERIALIZE_SCALAR(mmap_end);
477    SERIALIZE_SCALAR(nxm_start);
478    SERIALIZE_SCALAR(nxm_end);
479    find_file_offsets();
480    pTable->serialize(os);
481    for (int x = 0; x <= MAX_FD; x++) {
482        nameOut(os, csprintf("%s.FdMap%d", name(), x));
483        fd_map[x].serialize(os);
484    }
485
486}
487
488void
489Process::unserialize(Checkpoint *cp, const std::string &section)
490{
491    UNSERIALIZE_SCALAR(initialContextLoaded);
492    UNSERIALIZE_SCALAR(brk_point);
493    UNSERIALIZE_SCALAR(stack_base);
494    UNSERIALIZE_SCALAR(stack_size);
495    UNSERIALIZE_SCALAR(stack_min);
496    UNSERIALIZE_SCALAR(next_thread_stack_base);
497    UNSERIALIZE_SCALAR(mmap_start);
498    UNSERIALIZE_SCALAR(mmap_end);
499    UNSERIALIZE_SCALAR(nxm_start);
500    UNSERIALIZE_SCALAR(nxm_end);
501    pTable->unserialize(cp, section);
502    for (int x = 0; x <= MAX_FD; x++) {
503        fd_map[x].unserialize(cp, csprintf("%s.FdMap%d", section, x));
504     }
505    fix_file_offsets();
506
507    checkpointRestored = true;
508
509}
510
511
512////////////////////////////////////////////////////////////////////////
513//
514// LiveProcess member definitions
515//
516////////////////////////////////////////////////////////////////////////
517
518
519LiveProcess::LiveProcess(LiveProcessParams * params, ObjectFile *_objFile)
520    : Process(params), objFile(_objFile),
521      argv(params->cmd), envp(params->env), cwd(params->cwd)
522{
523    __uid = params->uid;
524    __euid = params->euid;
525    __gid = params->gid;
526    __egid = params->egid;
527    __pid = params->pid;
528    __ppid = params->ppid;
529
530    prog_fname = params->cmd[0];
531
532    // load up symbols, if any... these may be used for debugging or
533    // profiling.
534    if (!debugSymbolTable) {
535        debugSymbolTable = new SymbolTable();
536        if (!objFile->loadGlobalSymbols(debugSymbolTable) ||
537            !objFile->loadLocalSymbols(debugSymbolTable)) {
538            // didn't load any symbols
539            delete debugSymbolTable;
540            debugSymbolTable = NULL;
541        }
542    }
543}
544
545void
546LiveProcess::argsInit(int intSize, int pageSize)
547{
548    Process::startup();
549
550    // load object file into target memory
551    objFile->loadSections(initVirtMem);
552
553    // Calculate how much space we need for arg & env arrays.
554    int argv_array_size = intSize * (argv.size() + 1);
555    int envp_array_size = intSize * (envp.size() + 1);
556    int arg_data_size = 0;
557    for (int i = 0; i < argv.size(); ++i) {
558        arg_data_size += argv[i].size() + 1;
559    }
560    int env_data_size = 0;
561    for (int i = 0; i < envp.size(); ++i) {
562        env_data_size += envp[i].size() + 1;
563    }
564
565    int space_needed =
566        argv_array_size + envp_array_size + arg_data_size + env_data_size;
567    if (space_needed < 32*1024)
568        space_needed = 32*1024;
569
570    // set bottom of stack
571    stack_min = stack_base - space_needed;
572    // align it
573    stack_min = roundDown(stack_min, pageSize);
574    stack_size = stack_base - stack_min;
575    // map memory
576    pTable->allocate(stack_min, roundUp(stack_size, pageSize));
577
578    // map out initial stack contents
579    Addr argv_array_base = stack_min + intSize; // room for argc
580    Addr envp_array_base = argv_array_base + argv_array_size;
581    Addr arg_data_base = envp_array_base + envp_array_size;
582    Addr env_data_base = arg_data_base + arg_data_size;
583
584    // write contents to stack
585    uint64_t argc = argv.size();
586    if (intSize == 8)
587        argc = htog((uint64_t)argc);
588    else if (intSize == 4)
589        argc = htog((uint32_t)argc);
590    else
591        panic("Unknown int size");
592
593    initVirtMem->writeBlob(stack_min, (uint8_t*)&argc, intSize);
594
595    copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem);
596    copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
597
598    assert(NumArgumentRegs >= 2);
599    threadContexts[0]->setIntReg(ArgumentReg[0], argc);
600    threadContexts[0]->setIntReg(ArgumentReg[1], argv_array_base);
601    threadContexts[0]->setIntReg(StackPointerReg, stack_min);
602
603    Addr prog_entry = objFile->entryPoint();
604    threadContexts[0]->setPC(prog_entry);
605    threadContexts[0]->setNextPC(prog_entry + sizeof(MachInst));
606
607#if THE_ISA != ALPHA_ISA //e.g. MIPS or Sparc
608    threadContexts[0]->setNextNPC(prog_entry + (2 * sizeof(MachInst)));
609#endif
610
611    num_processes++;
612}
613
614void
615LiveProcess::syscall(int64_t callnum, ThreadContext *tc)
616{
617    num_syscalls++;
618
619    SyscallDesc *desc = getDesc(callnum);
620    if (desc == NULL)
621        fatal("Syscall %d out of range", callnum);
622
623    desc->doSyscall(callnum, this, tc);
624}
625
626LiveProcess *
627LiveProcess::create(LiveProcessParams * params)
628{
629    LiveProcess *process = NULL;
630
631    string executable =
632        params->executable == "" ? params->cmd[0] : params->executable;
633    ObjectFile *objFile = createObjectFile(executable);
634    if (objFile == NULL) {
635        fatal("Can't load object file %s", executable);
636    }
637
638    if (objFile->isDynamic())
639       fatal("Object file is a dynamic executable however only static "
640             "executables are supported!\n       Please recompile your "
641             "executable as a static binary and try again.\n");
642
643#if THE_ISA == ALPHA_ISA
644    if (objFile->hasTLS())
645        fatal("Object file has a TLS section and single threaded TLS is not\n"
646              "       currently supported for Alpha! Please recompile your "
647              "executable with \n       a non-TLS toolchain.\n");
648
649    if (objFile->getArch() != ObjectFile::Alpha)
650        fatal("Object file architecture does not match compiled ISA (Alpha).");
651    switch (objFile->getOpSys()) {
652      case ObjectFile::Tru64:
653        process = new AlphaTru64Process(params, objFile);
654        break;
655
656      case ObjectFile::Linux:
657        process = new AlphaLinuxProcess(params, objFile);
658        break;
659
660      default:
661        fatal("Unknown/unsupported operating system.");
662    }
663#elif THE_ISA == SPARC_ISA
664    if (objFile->getArch() != ObjectFile::SPARC64 && objFile->getArch() != ObjectFile::SPARC32)
665        fatal("Object file architecture does not match compiled ISA (SPARC).");
666    switch (objFile->getOpSys()) {
667      case ObjectFile::Linux:
668        if (objFile->getArch() == ObjectFile::SPARC64) {
669            process = new Sparc64LinuxProcess(params, objFile);
670        } else {
671            process = new Sparc32LinuxProcess(params, objFile);
672        }
673        break;
674
675
676      case ObjectFile::Solaris:
677        process = new SparcSolarisProcess(params, objFile);
678        break;
679      default:
680        fatal("Unknown/unsupported operating system.");
681    }
682#elif THE_ISA == X86_ISA
683    if (objFile->getArch() != ObjectFile::X86)
684        fatal("Object file architecture does not match compiled ISA (x86).");
685    switch (objFile->getOpSys()) {
686      case ObjectFile::Linux:
687        process = new X86LinuxProcess(params, objFile);
688        break;
689      default:
690        fatal("Unknown/unsupported operating system.");
691    }
692#elif THE_ISA == MIPS_ISA
693    if (objFile->getArch() != ObjectFile::Mips)
694        fatal("Object file architecture does not match compiled ISA (MIPS).");
695    switch (objFile->getOpSys()) {
696      case ObjectFile::Linux:
697        process = new MipsLinuxProcess(params, objFile);
698        break;
699
700      default:
701        fatal("Unknown/unsupported operating system.");
702    }
703#else
704#error "THE_ISA not set"
705#endif
706
707
708    if (process == NULL)
709        fatal("Unknown error creating process object.");
710    return process;
711}
712
713LiveProcess *
714LiveProcessParams::create()
715{
716    return LiveProcess::create(this);
717}
718