From fd3e9f2b9720b9ba730938686b98cff3aa248984 Mon Sep 17 00:00:00 2001 From: Dmitry Vyukov Date: Wed, 27 Dec 2017 10:56:12 +0100 Subject: executor: introduce uint64/32/16/8 types The "define uint64_t unsigned long long" were too good to work. With a different toolchain I am getting: cstdint:69:11: error: expected unqualified-id using ::uint64_t; ^ executor/common.h:34:18: note: expanded from macro 'uint64_t' Do it the proper way: introduce uint64/32/16/8 types and use them. pkg/csource then does s/uint64/uint64_t/ to not clutter code with additional typedefs. --- executor/common_kvm_amd64.h | 188 ++++++++++++++++++++++---------------------- 1 file changed, 94 insertions(+), 94 deletions(-) (limited to 'executor/common_kvm_amd64.h') diff --git a/executor/common_kvm_amd64.h b/executor/common_kvm_amd64.h index 5dce25311..f3fb8f8b6 100644 --- a/executor/common_kvm_amd64.h +++ b/executor/common_kvm_amd64.h @@ -72,88 +72,88 @@ #define PDE64_G (1 << 8) struct tss16 { - uint16_t prev; - uint16_t sp0; - uint16_t ss0; - uint16_t sp1; - uint16_t ss1; - uint16_t sp2; - uint16_t ss2; - uint16_t ip; - uint16_t flags; - uint16_t ax; - uint16_t cx; - uint16_t dx; - uint16_t bx; - uint16_t sp; - uint16_t bp; - uint16_t si; - uint16_t di; - uint16_t es; - uint16_t cs; - uint16_t ss; - uint16_t ds; - uint16_t ldt; + uint16 prev; + uint16 sp0; + uint16 ss0; + uint16 sp1; + uint16 ss1; + uint16 sp2; + uint16 ss2; + uint16 ip; + uint16 flags; + uint16 ax; + uint16 cx; + uint16 dx; + uint16 bx; + uint16 sp; + uint16 bp; + uint16 si; + uint16 di; + uint16 es; + uint16 cs; + uint16 ss; + uint16 ds; + uint16 ldt; } __attribute__((packed)); struct tss32 { - uint16_t prev, prevh; - uint32_t sp0; - uint16_t ss0, ss0h; - uint32_t sp1; - uint16_t ss1, ss1h; - uint32_t sp2; - uint16_t ss2, ss2h; - uint32_t cr3; - uint32_t ip; - uint32_t flags; - uint32_t ax; - uint32_t cx; - uint32_t dx; - uint32_t bx; - uint32_t sp; - uint32_t bp; - uint32_t si; - uint32_t di; - uint16_t es, esh; - uint16_t cs, csh; - uint16_t ss, ssh; - uint16_t ds, dsh; - uint16_t fs, fsh; - uint16_t gs, gsh; - uint16_t ldt, ldth; - uint16_t trace; - uint16_t io_bitmap; + uint16 prev, prevh; + uint32 sp0; + uint16 ss0, ss0h; + uint32 sp1; + uint16 ss1, ss1h; + uint32 sp2; + uint16 ss2, ss2h; + uint32 cr3; + uint32 ip; + uint32 flags; + uint32 ax; + uint32 cx; + uint32 dx; + uint32 bx; + uint32 sp; + uint32 bp; + uint32 si; + uint32 di; + uint16 es, esh; + uint16 cs, csh; + uint16 ss, ssh; + uint16 ds, dsh; + uint16 fs, fsh; + uint16 gs, gsh; + uint16 ldt, ldth; + uint16 trace; + uint16 io_bitmap; } __attribute__((packed)); struct tss64 { - uint32_t reserved0; - uint64_t rsp[3]; - uint64_t reserved1; - uint64_t ist[7]; - uint64_t reserved2; - uint32_t reserved3; - uint32_t io_bitmap; + uint32 reserved0; + uint64 rsp[3]; + uint64 reserved1; + uint64 ist[7]; + uint64 reserved2; + uint32 reserved3; + uint32 io_bitmap; } __attribute__((packed)); -static void fill_segment_descriptor(uint64_t* dt, uint64_t* lt, struct kvm_segment* seg) +static void fill_segment_descriptor(uint64* dt, uint64* lt, struct kvm_segment* seg) { - uint16_t index = seg->selector >> 3; - uint64_t limit = seg->g ? seg->limit >> 12 : seg->limit; - uint64_t sd = (limit & 0xffff) | (seg->base & 0xffffff) << 16 | (uint64_t)seg->type << 40 | (uint64_t)seg->s << 44 | (uint64_t)seg->dpl << 45 | (uint64_t)seg->present << 47 | (limit & 0xf0000ULL) << 48 | (uint64_t)seg->avl << 52 | (uint64_t)seg->l << 53 | (uint64_t)seg->db << 54 | (uint64_t)seg->g << 55 | (seg->base & 0xff000000ULL) << 56; + uint16 index = seg->selector >> 3; + uint64 limit = seg->g ? seg->limit >> 12 : seg->limit; + uint64 sd = (limit & 0xffff) | (seg->base & 0xffffff) << 16 | (uint64)seg->type << 40 | (uint64)seg->s << 44 | (uint64)seg->dpl << 45 | (uint64)seg->present << 47 | (limit & 0xf0000ULL) << 48 | (uint64)seg->avl << 52 | (uint64)seg->l << 53 | (uint64)seg->db << 54 | (uint64)seg->g << 55 | (seg->base & 0xff000000ULL) << 56; NONFAILING(dt[index] = sd); NONFAILING(lt[index] = sd); } -static void fill_segment_descriptor_dword(uint64_t* dt, uint64_t* lt, struct kvm_segment* seg) +static void fill_segment_descriptor_dword(uint64* dt, uint64* lt, struct kvm_segment* seg) { fill_segment_descriptor(dt, lt, seg); - uint16_t index = seg->selector >> 3; + uint16 index = seg->selector >> 3; NONFAILING(dt[index + 1] = 0); NONFAILING(lt[index + 1] = 0); } -static void setup_syscall_msrs(int cpufd, uint16_t sel_cs, uint16_t sel_cs_cpl3) +static void setup_syscall_msrs(int cpufd, uint16 sel_cs, uint16 sel_cs_cpl3) { char buf[sizeof(struct kvm_msrs) + 5 * sizeof(struct kvm_msr_entry)]; memset(buf, 0, sizeof(buf)); @@ -166,7 +166,7 @@ static void setup_syscall_msrs(int cpufd, uint16_t sel_cs, uint16_t sel_cs_cpl3) msrs->entries[2].index = MSR_IA32_SYSENTER_EIP; msrs->entries[2].data = ADDR_VAR_SYSEXIT; msrs->entries[3].index = MSR_IA32_STAR; - msrs->entries[3].data = ((uint64_t)sel_cs << 32) | ((uint64_t)sel_cs_cpl3 << 48); + msrs->entries[3].data = ((uint64)sel_cs << 32) | ((uint64)sel_cs_cpl3 << 48); msrs->entries[4].index = MSR_IA32_LSTAR; msrs->entries[4].data = ADDR_VAR_SYSRET; ioctl(cpufd, KVM_SET_MSRS, msrs); @@ -176,7 +176,7 @@ static void setup_32bit_idt(struct kvm_sregs* sregs, char* host_mem, uintptr_t g { sregs->idt.base = guest_mem + ADDR_VAR_IDT; sregs->idt.limit = 0x1ff; - uint64_t* idt = (uint64_t*)(host_mem + sregs->idt.base); + uint64* idt = (uint64*)(host_mem + sregs->idt.base); int i; for (i = 0; i < 32; i++) { struct kvm_segment gate; @@ -229,7 +229,7 @@ static void setup_64bit_idt(struct kvm_sregs* sregs, char* host_mem, uintptr_t g { sregs->idt.base = guest_mem + ADDR_VAR_IDT; sregs->idt.limit = 0x1ff; - uint64_t* idt = (uint64_t*)(host_mem + sregs->idt.base); + uint64* idt = (uint64*)(host_mem + sregs->idt.base); int i; for (i = 0; i < 32; i++) { struct kvm_segment gate; @@ -255,8 +255,8 @@ struct kvm_text { }; struct kvm_opt { - uint64_t typ; - uint64_t val; + uint64 typ; + uint64 val; }; #define KVM_SETUP_PAGING (1 << 0) @@ -323,14 +323,14 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin regs.rsp = ADDR_STACK0; sregs.gdt.base = guest_mem + ADDR_GDT; - sregs.gdt.limit = 256 * sizeof(uint64_t) - 1; - uint64_t* gdt = (uint64_t*)(host_mem + sregs.gdt.base); + sregs.gdt.limit = 256 * sizeof(uint64) - 1; + uint64* gdt = (uint64*)(host_mem + sregs.gdt.base); struct kvm_segment seg_ldt; seg_ldt.selector = SEL_LDT; seg_ldt.type = 2; seg_ldt.base = guest_mem + ADDR_LDT; - seg_ldt.limit = 256 * sizeof(uint64_t) - 1; + seg_ldt.limit = 256 * sizeof(uint64) - 1; seg_ldt.present = 1; seg_ldt.dpl = 0; seg_ldt.s = 0; @@ -338,7 +338,7 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin seg_ldt.db = 1; seg_ldt.l = 0; sregs.ldt = seg_ldt; - uint64_t* ldt = (uint64_t*)(host_mem + sregs.ldt.base); + uint64* ldt = (uint64*)(host_mem + sregs.ldt.base); struct kvm_segment seg_cs16; seg_cs16.selector = SEL_CS16; @@ -518,8 +518,8 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin setup_32bit_idt(&sregs, host_mem, guest_mem); if (flags & KVM_SETUP_PAGING) { - uint64_t pd_addr = guest_mem + ADDR_PD; - uint64_t* pd = (uint64_t*)(host_mem + ADDR_PD); + uint64 pd_addr = guest_mem + ADDR_PD; + uint64* pd = (uint64*)(host_mem + ADDR_PD); // A single 4MB page to cover the memory region NONFAILING(pd[0] = PDE32_PRESENT | PDE32_RW | PDE32_USER | PDE32_PS); sregs.cr3 = pd_addr; @@ -566,8 +566,8 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin sregs.cs = seg_cs32; sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds32; - uint64_t pd_addr = guest_mem + ADDR_PD; - uint64_t* pd = (uint64_t*)(host_mem + ADDR_PD); + uint64 pd_addr = guest_mem + ADDR_PD; + uint64* pd = (uint64*)(host_mem + ADDR_PD); // A single 4MB page to cover the memory region NONFAILING(pd[0] = PDE32_PRESENT | PDE32_RW | PDE32_USER | PDE32_PS); sregs.cr3 = pd_addr; @@ -592,12 +592,12 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin sregs.cs = seg_cs32; sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds32; - uint64_t pml4_addr = guest_mem + ADDR_PML4; - uint64_t* pml4 = (uint64_t*)(host_mem + ADDR_PML4); - uint64_t pdpt_addr = guest_mem + ADDR_PDP; - uint64_t* pdpt = (uint64_t*)(host_mem + ADDR_PDP); - uint64_t pd_addr = guest_mem + ADDR_PD; - uint64_t* pd = (uint64_t*)(host_mem + ADDR_PD); + uint64 pml4_addr = guest_mem + ADDR_PML4; + uint64* pml4 = (uint64*)(host_mem + ADDR_PML4); + uint64 pdpt_addr = guest_mem + ADDR_PDP; + uint64* pdpt = (uint64*)(host_mem + ADDR_PDP); + uint64 pd_addr = guest_mem + ADDR_PD; + uint64* pd = (uint64*)(host_mem + ADDR_PD); NONFAILING(pml4[0] = PDE64_PRESENT | PDE64_RW | PDE64_USER | pdpt_addr); NONFAILING(pdpt[0] = PDE64_PRESENT | PDE64_RW | PDE64_USER | pd_addr); NONFAILING(pd[0] = PDE64_PRESENT | PDE64_RW | PDE64_USER | PDE64_PS); @@ -607,10 +607,10 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin if (flags & KVM_SETUP_VM) { sregs.cr0 |= CR0_NE; - NONFAILING(*((uint64_t*)(host_mem + ADDR_VAR_VMXON_PTR)) = ADDR_VAR_VMXON); - NONFAILING(*((uint64_t*)(host_mem + ADDR_VAR_VMCS_PTR)) = ADDR_VAR_VMCS); + NONFAILING(*((uint64*)(host_mem + ADDR_VAR_VMXON_PTR)) = ADDR_VAR_VMXON); + NONFAILING(*((uint64*)(host_mem + ADDR_VAR_VMCS_PTR)) = ADDR_VAR_VMCS); NONFAILING(memcpy(host_mem + ADDR_VAR_VMEXIT_CODE, kvm_asm64_vm_exit, sizeof(kvm_asm64_vm_exit) - 1)); - NONFAILING(*((uint64_t*)(host_mem + ADDR_VAR_VMEXIT_PTR)) = ADDR_VAR_VMEXIT_CODE); + NONFAILING(*((uint64*)(host_mem + ADDR_VAR_VMEXIT_PTR)) = ADDR_VAR_VMEXIT_CODE); text_prefix = kvm_asm64_init_vm; text_prefix_size = sizeof(kvm_asm64_init_vm) - 1; @@ -697,12 +697,12 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin // Replace 0xbadc0de in LJMP with offset of a next instruction. NONFAILING(patch = memmem(host_text, text_prefix_size, "\xde\xc0\xad\x0b", 4)); if (patch) - NONFAILING(*((uint32_t*)patch) = guest_mem + ADDR_TEXT + ((char*)patch - host_text) + 6); - uint16_t magic = PREFIX_SIZE; + NONFAILING(*((uint32*)patch) = guest_mem + ADDR_TEXT + ((char*)patch - host_text) + 6); + uint16 magic = PREFIX_SIZE; patch = 0; NONFAILING(patch = memmem(host_text, text_prefix_size, &magic, sizeof(magic))); if (patch) - NONFAILING(*((uint16_t*)patch) = guest_mem + ADDR_TEXT + text_prefix_size); + NONFAILING(*((uint16*)patch) = guest_mem + ADDR_TEXT + text_prefix_size); } NONFAILING(memcpy((void*)(host_text + text_prefix_size), text, text_size)); NONFAILING(*(host_text + text_prefix_size + text_size) = 0xf4); // hlt @@ -714,14 +714,14 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin NONFAILING(memcpy(host_mem + ADDR_VAR_SYSRET, "\x0f\x07\xf4", 3)); NONFAILING(memcpy(host_mem + ADDR_VAR_SYSEXIT, "\x0f\x35\xf4", 3)); - NONFAILING(*(uint64_t*)(host_mem + ADDR_VAR_VMWRITE_FLD) = 0); - NONFAILING(*(uint64_t*)(host_mem + ADDR_VAR_VMWRITE_VAL) = 0); + NONFAILING(*(uint64*)(host_mem + ADDR_VAR_VMWRITE_FLD) = 0); + NONFAILING(*(uint64*)(host_mem + ADDR_VAR_VMWRITE_VAL) = 0); if (opt_count > 2) opt_count = 2; for (i = 0; i < opt_count; i++) { - uint64_t typ = 0; - uint64_t val = 0; + uint64 typ = 0; + uint64 val = 0; NONFAILING(typ = opt_array_ptr[i].typ); NONFAILING(val = opt_array_ptr[i].val); switch (typ % 9) { @@ -766,8 +766,8 @@ static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1, uintptr_t a2, uin seg_ds64_cpl3.type = val & 0xf; break; case 8: - NONFAILING(*(uint64_t*)(host_mem + ADDR_VAR_VMWRITE_FLD) = (val & 0xffff)); - NONFAILING(*(uint64_t*)(host_mem + ADDR_VAR_VMWRITE_VAL) = (val >> 16)); + NONFAILING(*(uint64*)(host_mem + ADDR_VAR_VMWRITE_FLD) = (val & 0xffff)); + NONFAILING(*(uint64*)(host_mem + ADDR_VAR_VMWRITE_VAL) = (val >> 16)); break; default: fail("bad kvm setup opt"); -- cgit mrf-deployment