sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

x86: Clean up style in process.cc.

Browse source
This commit is contained in:
Gabe Black 2014-12-02 22:01:51 -08:00
parent 2d9dae01fb
commit d67cf81f5d
1 changed files with 49 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

86
src/arch/x86/process.cc
View file

@ -285,11 +285,11 @@ X86_64LiveProcess::initState()
TSSDescLow.g = 1; // Page granularity TSSDescLow.g = 1; // Page granularity
TSSDescLow.limitHigh = 0xF; TSSDescLow.limitHigh = 0xF;
TSSDescLow.limitLow = 0xFFFF; TSSDescLow.limitLow = 0xFFFF;
TSSDescLow.baseLow = (((uint32_t)TSSVirtAddr) << 8) >> 8; TSSDescLow.baseLow = bits(TSSVirtAddr, 23, 0);
TSSDescLow.baseHigh = (uint8_t)(((uint32_t)TSSVirtAddr) >> 24); TSSDescLow.baseHigh = bits(TSSVirtAddr, 31, 24);
TSShigh TSSDescHigh = 0; TSShigh TSSDescHigh = 0;
TSSDescHigh.base = (uint32_t)(TSSVirtAddr >> 32); TSSDescHigh.base = bits(TSSVirtAddr, 63, 32);
struct TSSDesc { struct TSSDesc {
uint64_t low; uint64_t low;
@ -304,7 +304,9 @@ X86_64LiveProcess::initState()
SegSelector tssSel = 0; SegSelector tssSel = 0;
tssSel.si = numGDTEntries - 1; tssSel.si = numGDTEntries - 1;
uint64_t tss_base_addr = (TSSDescHigh.base << 32) | ((TSSDescLow.baseHigh << 24) | TSSDescLow.baseLow); uint64_t tss_base_addr = (TSSDescHigh.base << 32) |
(TSSDescLow.baseHigh << 24) |
TSSDescLow.baseLow;
uint64_t tss_limit = TSSDescLow.limitLow | (TSSDescLow.limitHigh << 16); uint64_t tss_limit = TSSDescLow.limitLow | (TSSDescLow.limitHigh << 16);
SegAttr tss_attr = 0; SegAttr tss_attr = 0;
@ -318,12 +320,12 @@ X86_64LiveProcess::initState()
for (int i = 0; i < contextIds.size(); i++) { for (int i = 0; i < contextIds.size(); i++) {
ThreadContext * tc = system->getThreadContext(contextIds[i]); ThreadContext * tc = system->getThreadContext(contextIds[i]);
tc->setMiscReg(MISCREG_CS, (MiscReg)cs); tc->setMiscReg(MISCREG_CS, cs);
tc->setMiscReg(MISCREG_DS, (MiscReg)ds); tc->setMiscReg(MISCREG_DS, ds);
tc->setMiscReg(MISCREG_ES, (MiscReg)ds); tc->setMiscReg(MISCREG_ES, ds);
tc->setMiscReg(MISCREG_FS, (MiscReg)ds); tc->setMiscReg(MISCREG_FS, ds);
tc->setMiscReg(MISCREG_GS, (MiscReg)ds); tc->setMiscReg(MISCREG_GS, ds);
tc->setMiscReg(MISCREG_SS, (MiscReg)ds); tc->setMiscReg(MISCREG_SS, ds);
// LDT // LDT
tc->setMiscReg(MISCREG_TSL, 0); tc->setMiscReg(MISCREG_TSL, 0);
@ -335,11 +337,11 @@ X86_64LiveProcess::initState()
tc->setMiscReg(MISCREG_TSG_BASE, GDTVirtAddr); tc->setMiscReg(MISCREG_TSG_BASE, GDTVirtAddr);
tc->setMiscReg(MISCREG_TSG_LIMIT, 8 * numGDTEntries - 1); tc->setMiscReg(MISCREG_TSG_LIMIT, 8 * numGDTEntries - 1);
tc->setMiscReg(MISCREG_TR, (MiscReg)tssSel); tc->setMiscReg(MISCREG_TR, tssSel);
tc->setMiscReg(MISCREG_SEG_BASE(SYS_SEGMENT_REG_TR), tss_base_addr); tc->setMiscReg(MISCREG_TR_BASE, tss_base_addr);
tc->setMiscReg(MISCREG_SEG_EFF_BASE(SYS_SEGMENT_REG_TR), 0); tc->setMiscReg(MISCREG_TR_EFF_BASE, 0);
tc->setMiscReg(MISCREG_SEG_LIMIT(SYS_SEGMENT_REG_TR), tss_limit); tc->setMiscReg(MISCREG_TR_LIMIT, tss_limit);
tc->setMiscReg(MISCREG_SEG_ATTR(SYS_SEGMENT_REG_TR), (MiscReg)tss_attr); tc->setMiscReg(MISCREG_TR_ATTR, tss_attr);
//Start using longmode segments. //Start using longmode segments.
installSegDesc(tc, SEGMENT_REG_CS, csDesc, true); installSegDesc(tc, SEGMENT_REG_CS, csDesc, true);
@ -409,11 +411,11 @@ X86_64LiveProcess::initState()
tc->setMiscReg(MISCREG_APIC_BASE, 0xfee00900); tc->setMiscReg(MISCREG_APIC_BASE, 0xfee00900);
tc->setMiscReg(MISCREG_SEG_BASE(MISCREG_TSG - MISCREG_SEG_SEL_BASE), GDTVirtAddr); tc->setMiscReg(MISCREG_TSG_BASE, GDTVirtAddr);
tc->setMiscReg(MISCREG_SEG_LIMIT(MISCREG_TSG - MISCREG_SEG_SEL_BASE), 0xffff); tc->setMiscReg(MISCREG_TSG_LIMIT, 0xffff);
tc->setMiscReg(MISCREG_SEG_BASE(MISCREG_IDTR - MISCREG_SEG_SEL_BASE), IDTVirtAddr); tc->setMiscReg(MISCREG_IDTR_BASE, IDTVirtAddr);
tc->setMiscReg(MISCREG_SEG_LIMIT(MISCREG_IDTR - MISCREG_SEG_SEL_BASE), 0xffff); tc->setMiscReg(MISCREG_IDTR_LIMIT, 0xffff);
/* enabling syscall and sysret */ /* enabling syscall and sysret */
MiscReg star = ((MiscReg)sret << 48) | ((MiscReg)scall << 32); MiscReg star = ((MiscReg)sret << 48) | ((MiscReg)scall << 32);
@ -424,10 +426,7 @@ X86_64LiveProcess::initState()
tc->setMiscReg(MISCREG_SF_MASK, sfmask); tc->setMiscReg(MISCREG_SF_MASK, sfmask);
} }
/* /* Set up the content of the TSS and write it to physical memory. */
* Setting up the content of the TSS
* and writting it to physical memory
*/
struct { struct {
uint32_t reserved0; // +00h uint32_t reserved0; // +00h
@ -461,8 +460,8 @@ X86_64LiveProcess::initState()
/** setting Interrupt Stack Table */ /** setting Interrupt Stack Table */
uint64_t IST_start = ISTVirtAddr + PageBytes; uint64_t IST_start = ISTVirtAddr + PageBytes;
tss.IST1_low = (uint32_t)IST_start; tss.IST1_low = IST_start;
tss.IST1_high = (uint32_t)(IST_start >> 32); tss.IST1_high = IST_start >> 32;
tss.RSP0_low = tss.IST1_low; tss.RSP0_low = tss.IST1_low;
tss.RSP0_high = tss.IST1_high; tss.RSP0_high = tss.IST1_high;
tss.RSP1_low = tss.IST1_low; tss.RSP1_low = tss.IST1_low;
@ -473,16 +472,16 @@ X86_64LiveProcess::initState()
/* Setting IDT gates */ /* Setting IDT gates */
GateDescriptorLow PFGateLow = 0; GateDescriptorLow PFGateLow = 0;
PFGateLow.offsetHigh = (uint16_t)((uint32_t)PFHandlerVirtAddr >> 16); PFGateLow.offsetHigh = bits(PFHandlerVirtAddr, 31, 16);
PFGateLow.offsetLow = (uint16_t)PFHandlerVirtAddr; PFGateLow.offsetLow = bits(PFHandlerVirtAddr, 15, 0);
PFGateLow.selector = (MiscReg)csLowPL; PFGateLow.selector = csLowPL;
PFGateLow.p = 1; PFGateLow.p = 1;
PFGateLow.dpl = 0; PFGateLow.dpl = 0;
PFGateLow.type = 0xe; // gate interrupt type PFGateLow.type = 0xe; // gate interrupt type
PFGateLow.IST = 0; // setting IST to 0 and using RSP0 PFGateLow.IST = 0; // setting IST to 0 and using RSP0
GateDescriptorHigh PFGateHigh = 0; GateDescriptorHigh PFGateHigh = 0;
PFGateHigh.offset = (uint32_t)(PFHandlerVirtAddr >> 32); PFGateHigh.offset = bits(PFHandlerVirtAddr, 63, 32);
struct { struct {
uint64_t low; uint64_t low;
@ -492,11 +491,13 @@ X86_64LiveProcess::initState()
physProxy.writeBlob(IDTPhysAddr + 0xE0, physProxy.writeBlob(IDTPhysAddr + 0xE0,
(uint8_t *)(&PFGate), sizeof(PFGate)); (uint8_t *)(&PFGate), sizeof(PFGate));
/** System call handler */ /* System call handler */
uint8_t syscallBlob[] = { uint8_t syscallBlob[] = {
// mov %rax, (0xffffc90000005600)
0x48, 0xa3, 0x00, 0x60, 0x00, 0x48, 0xa3, 0x00, 0x60, 0x00,
0x00,0x00,0xc9,0xff,0xff, // mov %rax, (0xffffc90000005600) 0x00, 0x00, 0xc9, 0xff, 0xff,
0x48,0x0f,0x07, // sysret // sysret
0x48, 0x0f, 0x07
}; };
physProxy.writeBlob(syscallCodePhysAddr, physProxy.writeBlob(syscallCodePhysAddr,
@ -504,10 +505,13 @@ X86_64LiveProcess::initState()
/** Page fault handler */ /** Page fault handler */
uint8_t faultBlob[] = { uint8_t faultBlob[] = {
// mov %rax, (0xffffc90000005700)
0x48, 0xa3, 0x00, 0x61, 0x00, 0x48, 0xa3, 0x00, 0x61, 0x00,
0x00,0x00,0xc9,0xff,0xff, // mov %rax, (0xffffc90000005700) 0x00, 0x00, 0xc9, 0xff, 0xff,
0x48,0x83,0xc4,0x08, // add $0x8,%rsp # skip error // add $0x8, %rsp # skip error
0x48,0xcf, // iretq 0x48, 0x83, 0xc4, 0x08,
// iretq
0x48, 0xcf
}; };
physProxy.writeBlob(PFHandlerPhysAddr, faultBlob, sizeof(faultBlob)); physProxy.writeBlob(PFHandlerPhysAddr, faultBlob, sizeof(faultBlob));
@ -784,8 +788,7 @@ X86LiveProcess::argsInit(int pageSize,
// Setup the auxilliary vectors. These will already have endian conversion. // Setup the auxilliary vectors. These will already have endian conversion.
// Auxilliary vectors are loaded only for elf formatted executables. // Auxilliary vectors are loaded only for elf formatted executables.
ElfObject * elfObject = dynamic_cast<ElfObject *>(objFile); ElfObject * elfObject = dynamic_cast<ElfObject *>(objFile);
if(elfObject) if (elfObject) {
{
uint64_t features = uint64_t features =
X86_OnboardFPU | X86_OnboardFPU |
X86_VirtualModeExtensions | X86_VirtualModeExtensions |
@ -873,13 +876,11 @@ X86LiveProcess::argsInit(int pageSize,
aux_data_size += platform.size() + 1; aux_data_size += platform.size() + 1;
int env_data_size = 0; int env_data_size = 0;
for (int i = 0; i < envp.size(); ++i) { for (int i = 0; i < envp.size(); ++i)
env_data_size += envp[i].size() + 1; env_data_size += envp[i].size() + 1;
}
int arg_data_size = 0; int arg_data_size = 0;
for (int i = 0; i < argv.size(); ++i) { for (int i = 0; i < argv.size(); ++i)
arg_data_size += argv[i].size() + 1; arg_data_size += argv[i].size() + 1;
}
//The info_block needs to be padded so it's size is a multiple of the //The info_block needs to be padded so it's size is a multiple of the
//alignment mask. Also, it appears that there needs to be at least some //alignment mask. Also, it appears that there needs to be at least some
@ -974,8 +975,7 @@ X86LiveProcess::argsInit(int pageSize,
auxv[auxv.size() - 1].a_val = aux_data_base + numRandomBytes; auxv[auxv.size() - 1].a_val = aux_data_base + numRandomBytes;
//Copy the aux stuff //Copy the aux stuff
for(int x = 0; x < auxv.size(); x++) for (int x = 0; x < auxv.size(); x++) {
{
initVirtMem.writeBlob(auxv_array_base + x * 2 * intSize, initVirtMem.writeBlob(auxv_array_base + x * 2 * intSize,
(uint8_t*)&(auxv[x].a_type), intSize); (uint8_t*)&(auxv[x].a_type), intSize);
initVirtMem.writeBlob(auxv_array_base + (x * 2 + 1) * intSize, initVirtMem.writeBlob(auxv_array_base + (x * 2 + 1) * intSize,