From: Gabe Black Date: Fri, 27 Feb 2009 17:21:36 +0000 (-0800) Subject: X86: Distinguish the width of values on the stack between 32 and 64 bit processes. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=05de9f4e2cb0771a8f83dc1888c877852e19f1ad;p=gem5.git X86: Distinguish the width of values on the stack between 32 and 64 bit processes. --- diff --git a/src/arch/x86/linux/process.cc b/src/arch/x86/linux/process.cc index 8a3fc67ee..da22d9851 100644 --- a/src/arch/x86/linux/process.cc +++ b/src/arch/x86/linux/process.cc @@ -64,25 +64,16 @@ #include "kern/linux/linux.hh" #include "sim/process.hh" -#include "sim/syscall_emul.hh" using namespace std; using namespace X86ISA; -SyscallDesc* -X86LinuxProcess::getDesc(int callnum) -{ - if (callnum < 0 || callnum >= Num_Syscall_Descs) - return NULL; - return &syscallDescs[callnum]; -} - X86_64LinuxProcess::X86_64LinuxProcess(LiveProcessParams * params, ObjectFile *objFile) - : X86LinuxProcess(params, objFile, syscallDescs, 273) + : X86_64LiveProcess(params, objFile, syscallDescs, 273) {} I386LinuxProcess::I386LinuxProcess(LiveProcessParams * params, ObjectFile *objFile) - : X86LinuxProcess(params, objFile, syscallDescs, 324) + : I386LiveProcess(params, objFile, syscallDescs, 324) {} diff --git a/src/arch/x86/linux/process.hh b/src/arch/x86/linux/process.hh index e80b86537..2f37692e3 100644 --- a/src/arch/x86/linux/process.hh +++ b/src/arch/x86/linux/process.hh @@ -65,43 +65,26 @@ namespace X86ISA { -/// A process with emulated x86/Linux syscalls. -class X86LinuxProcess : public X86LiveProcess +class X86_64LinuxProcess : public X86_64LiveProcess { protected: - SyscallDesc *syscallDescs; - - const int Num_Syscall_Descs; - - /// Constructor. - X86LinuxProcess(LiveProcessParams * params, ObjectFile *objFile, - SyscallDesc *_syscallDescs, int numSyscallDescs) : - X86LiveProcess(params, objFile), syscallDescs(_syscallDescs), - Num_Syscall_Descs(numSyscallDescs) - {} - - public: - SyscallDesc* getDesc(int callnum); -}; + /// Array of syscall descriptors, indexed by call number. + static SyscallDesc syscallDescs[]; -class X86_64LinuxProcess : public X86LinuxProcess -{ public: /// Constructor. X86_64LinuxProcess(LiveProcessParams * params, ObjectFile *objFile); +}; +class I386LinuxProcess : public I386LiveProcess +{ + protected: /// Array of syscall descriptors, indexed by call number. static SyscallDesc syscallDescs[]; -}; -class I386LinuxProcess : public X86LinuxProcess -{ public: /// Constructor. I386LinuxProcess(LiveProcessParams * params, ObjectFile *objFile); - - /// Array of syscall descriptors, indexed by call number. - static SyscallDesc syscallDescs[]; }; } // namespace X86ISA diff --git a/src/arch/x86/process.cc b/src/arch/x86/process.cc index d6f3b2371..800dd44ef 100644 --- a/src/arch/x86/process.cc +++ b/src/arch/x86/process.cc @@ -98,48 +98,72 @@ #include "mem/page_table.hh" #include "mem/translating_port.hh" #include "sim/process_impl.hh" +#include "sim/syscall_emul.hh" #include "sim/system.hh" using namespace std; using namespace X86ISA; -X86LiveProcess::X86LiveProcess(LiveProcessParams * params, - ObjectFile *objFile) - : LiveProcess(params, objFile) +X86LiveProcess::X86LiveProcess(LiveProcessParams * params, ObjectFile *objFile, + SyscallDesc *_syscallDescs, int _numSyscallDescs) : + LiveProcess(params, objFile), syscallDescs(_syscallDescs), + numSyscallDescs(_numSyscallDescs) { brk_point = objFile->dataBase() + objFile->dataSize() + objFile->bssSize(); brk_point = roundUp(brk_point, VMPageSize); +} - // Set pointer for next thread stack. Reserve 8M for main stack. - next_thread_stack_base = stack_base - (8 * 1024 * 1024); - +X86_64LiveProcess::X86_64LiveProcess(LiveProcessParams *params, + ObjectFile *objFile, SyscallDesc *_syscallDescs, + int _numSyscallDescs) : + X86LiveProcess(params, objFile, _syscallDescs, _numSyscallDescs) +{ // Set up stack. On X86_64 Linux, stack goes from the top of memory // downward, less the hole for the kernel address space plus one page // for undertermined purposes. stack_base = (Addr)0x7FFFFFFFF000ULL; + // Set pointer for next thread stack. Reserve 8M for main stack. + next_thread_stack_base = stack_base - (8 * 1024 * 1024); + // Set up region for mmaps. This was determined empirically and may not // always be correct. mmap_start = mmap_end = (Addr)0x2aaaaaaab000ULL; } -void X86LiveProcess::handleTrap(int trapNum, ThreadContext *tc) +I386LiveProcess::I386LiveProcess(LiveProcessParams *params, + ObjectFile *objFile, SyscallDesc *_syscallDescs, + int _numSyscallDescs) : + X86LiveProcess(params, objFile, _syscallDescs, _numSyscallDescs) { - switch(trapNum) - { - default: - panic("Unimplemented trap to operating system: trap number %#x.\n", trapNum); - } + stack_base = (Addr)0xffffe000ULL; + + // Set pointer for next thread stack. Reserve 8M for main stack. + next_thread_stack_base = stack_base - (8 * 1024 * 1024); + + // Set up region for mmaps. This was determined empirically and may not + // always be correct. + mmap_start = mmap_end = (Addr)0xf7ffd000ULL; +} + +SyscallDesc* +X86LiveProcess::getDesc(int callnum) +{ + if (callnum < 0 || callnum >= numSyscallDescs) + return NULL; + return &syscallDescs[callnum]; } void -X86LiveProcess::startup() +X86_64LiveProcess::startup() { + LiveProcess::startup(); + if (checkpointRestored) return; - argsInit(sizeof(IntReg), VMPageSize); + argsInit(sizeof(uint64_t), VMPageSize); for (int i = 0; i < contextIds.size(); i++) { ThreadContext * tc = system->getThreadContext(contextIds[i]); @@ -198,12 +222,80 @@ X86LiveProcess::startup() } void -X86LiveProcess::argsInit(int intSize, int pageSize) +I386LiveProcess::startup() { - typedef AuxVector auxv_t; - std::vector auxv; + LiveProcess::startup(); + + if (checkpointRestored) + return; + + argsInit(sizeof(uint32_t), VMPageSize); + + for (int i = 0; i < contextIds.size(); i++) { + ThreadContext * tc = system->getThreadContext(contextIds[i]); + + SegAttr dataAttr = 0; + dataAttr.writable = 1; + dataAttr.readable = 1; + dataAttr.expandDown = 0; + dataAttr.dpl = 3; + dataAttr.defaultSize = 1; + dataAttr.longMode = 0; + + //Initialize the segment registers. + for(int seg = 0; seg < NUM_SEGMENTREGS; seg++) { + tc->setMiscRegNoEffect(MISCREG_SEG_BASE(seg), 0); + tc->setMiscRegNoEffect(MISCREG_SEG_EFF_BASE(seg), 0); + tc->setMiscRegNoEffect(MISCREG_SEG_ATTR(seg), dataAttr); + tc->setMiscRegNoEffect(MISCREG_SEG_SEL(seg), 0xB); + } + + SegAttr csAttr = 0; + csAttr.writable = 0; + csAttr.readable = 1; + csAttr.expandDown = 0; + csAttr.dpl = 3; + csAttr.defaultSize = 1; + csAttr.longMode = 0; + + tc->setMiscRegNoEffect(MISCREG_CS_ATTR, csAttr); + + //Set up the registers that describe the operating mode. + CR0 cr0 = 0; + cr0.pg = 1; // Turn on paging. + cr0.cd = 0; // Don't disable caching. + cr0.nw = 0; // This is bit is defined to be ignored. + cr0.am = 0; // No alignment checking + cr0.wp = 0; // Supervisor mode can write read only pages + cr0.ne = 1; + cr0.et = 1; // This should always be 1 + cr0.ts = 0; // We don't do task switching, so causing fp exceptions + // would be pointless. + cr0.em = 0; // Allow x87 instructions to execute natively. + cr0.mp = 1; // This doesn't really matter, but the manual suggests + // setting it to one. + cr0.pe = 1; // We're definitely in protected mode. + tc->setMiscReg(MISCREG_CR0, cr0); - Process::startup(); + Efer efer = 0; + efer.sce = 1; // Enable system call extensions. + efer.lme = 1; // Enable long mode. + efer.lma = 0; // Deactivate long mode. + efer.nxe = 1; // Enable nx support. + efer.svme = 0; // Disable svm support for now. It isn't implemented. + efer.ffxsr = 1; // Turn on fast fxsave and fxrstor. + tc->setMiscReg(MISCREG_EFER, efer); + } +} + +template +void +X86LiveProcess::argsInit(int pageSize) +{ + int intSize = sizeof(IntType); + + typedef AuxVector auxv_t; + std::vector auxv; string filename; if(argv.size() < 1) @@ -396,15 +488,15 @@ X86LiveProcess::argsInit(int intSize, int pageSize) roundUp(stack_size, pageSize)); // map out initial stack contents - Addr sentry_base = stack_base - sentry_size; - Addr file_name_base = sentry_base - file_name_size; - Addr env_data_base = file_name_base - env_data_size; - Addr arg_data_base = env_data_base - arg_data_size; - Addr aux_data_base = arg_data_base - info_block_padding - aux_data_size; - Addr auxv_array_base = aux_data_base - aux_array_size - aux_padding; - Addr envp_array_base = auxv_array_base - envp_array_size; - Addr argv_array_base = envp_array_base - argv_array_size; - Addr argc_base = argv_array_base - argc_size; + IntType sentry_base = stack_base - sentry_size; + IntType file_name_base = sentry_base - file_name_size; + IntType env_data_base = file_name_base - env_data_size; + IntType arg_data_base = env_data_base - arg_data_size; + IntType aux_data_base = arg_data_base - info_block_padding - aux_data_size; + IntType auxv_array_base = aux_data_base - aux_array_size - aux_padding; + IntType envp_array_base = auxv_array_base - envp_array_size; + IntType argv_array_base = envp_array_base - argv_array_size; + IntType argc_base = argv_array_base - argc_size; DPRINTF(Stack, "The addresses of items on the initial stack:\n"); DPRINTF(Stack, "0x%x - file name\n", file_name_base); @@ -420,11 +512,11 @@ X86LiveProcess::argsInit(int intSize, int pageSize) // write contents to stack // figure out argc - uint64_t argc = argv.size(); - uint64_t guestArgc = X86ISA::htog(argc); + IntType argc = argv.size(); + IntType guestArgc = X86ISA::htog(argc); //Write out the sentry void * - uint64_t sentry_NULL = 0; + IntType sentry_NULL = 0; initVirtMem->writeBlob(sentry_base, (uint8_t*)&sentry_NULL, sentry_size); @@ -470,3 +562,15 @@ X86LiveProcess::argsInit(int intSize, int pageSize) // num_processes++; } + +void +X86_64LiveProcess::argsInit(int intSize, int pageSize) +{ + X86LiveProcess::argsInit(pageSize); +} + +void +I386LiveProcess::argsInit(int intSize, int pageSize) +{ + X86LiveProcess::argsInit(pageSize); +} diff --git a/src/arch/x86/process.hh b/src/arch/x86/process.hh index d034d990e..8d77bd79d 100644 --- a/src/arch/x86/process.hh +++ b/src/arch/x86/process.hh @@ -62,22 +62,47 @@ #include #include "sim/process.hh" +class SyscallDesc; + namespace X86ISA { class X86LiveProcess : public LiveProcess { protected: - X86LiveProcess(LiveProcessParams * params, ObjectFile *objFile); + SyscallDesc *syscallDescs; + const int numSyscallDescs; - void startup(); + X86LiveProcess(LiveProcessParams * params, ObjectFile *objFile, + SyscallDesc *_syscallDescs, int _numSyscallDescs); + + template + void argsInit(int pageSize); + + public: + SyscallDesc* getDesc(int callnum); + }; + + class X86_64LiveProcess : public X86LiveProcess + { + protected: + X86_64LiveProcess(LiveProcessParams *params, ObjectFile *objFile, + SyscallDesc *_syscallDescs, int _numSyscallDescs); public: + void argsInit(int intSize, int pageSize); + void startup(); + }; - //Handles traps which request services from the operating system - virtual void handleTrap(int trapNum, ThreadContext *tc); + class I386LiveProcess : public X86LiveProcess + { + protected: + I386LiveProcess(LiveProcessParams *params, ObjectFile *objFile, + SyscallDesc *_syscallDescs, int _numSyscallDescs); + public: void argsInit(int intSize, int pageSize); + void startup(); }; }