X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?p=palacios.git;a=blobdiff_plain;f=palacios%2Fsrc%2Fpalacios%2Fvmcs.c;h=a77de77a7a1755983d0d7258a07c9cbbabb74519;hp=2a4ef976c3fa729567671f839ef9c0f23d65f57b;hb=6541ca672276d841db22cc18a003303cf517ea89;hpb=4f7c3b759e3889870c5b5e7d09b3ffcc168e5632 diff --git a/palacios/src/palacios/vmcs.c b/palacios/src/palacios/vmcs.c index 2a4ef97..a77de77 100644 --- a/palacios/src/palacios/vmcs.c +++ b/palacios/src/palacios/vmcs.c @@ -1,521 +1,1348 @@ -/* Northwestern University */ -/* (c) 2008, Jack Lange */ +/* + * This file is part of the Palacios Virtual Machine Monitor developed + * by the V3VEE Project with funding from the United States National + * Science Foundation and the Department of Energy. + * + * The V3VEE Project is a joint project between Northwestern University + * and the University of New Mexico. You can find out more at + * http://www.v3vee.org + * + * Copyright (c) 2008, Jack Lange + * Copyright (c) 2008, The V3VEE Project + * All rights reserved. + * + * Author: Jack Lange + * + * This is free software. You are permitted to use, + * redistribute, and modify it as specified in the file "V3VEE_LICENSE". + */ #include +#include +#include +#include +#include +#include +#include -//extern char * exception_names; -// -// Ignores "HIGH" addresses - 32 bit only for now -// - - -#define CHK_VMCS_READ(tag, val) {if (VMCS_READ(tag, val) != 0) return -1;} -#define CHK_VMCS_WRITE(tag, val) {if (VMCS_WRITE(tag, val) != 0) return -1;} - - - -int CopyOutVMCSGuestStateArea(struct VMCSGuestStateArea *p) { - CHK_VMCS_READ(GUEST_CR0, &(p->cr0)); - CHK_VMCS_READ(GUEST_CR3, &(p->cr3)); - CHK_VMCS_READ(GUEST_CR4, &(p->cr4)); - CHK_VMCS_READ(GUEST_DR7, &(p->dr7)); - CHK_VMCS_READ(GUEST_RSP, &(p->rsp)); - CHK_VMCS_READ(GUEST_RIP, &(p->rip)); - CHK_VMCS_READ(GUEST_RFLAGS, &(p->rflags)); - CHK_VMCS_READ(VMCS_GUEST_CS_SELECTOR, &(p->cs.selector)); - CHK_VMCS_READ(VMCS_GUEST_SS_SELECTOR, &(p->ss.selector)); - CHK_VMCS_READ(VMCS_GUEST_DS_SELECTOR, &(p->ds.selector)); - CHK_VMCS_READ(VMCS_GUEST_ES_SELECTOR, &(p->es.selector)); - CHK_VMCS_READ(VMCS_GUEST_FS_SELECTOR, &(p->fs.selector)); - CHK_VMCS_READ(VMCS_GUEST_GS_SELECTOR, &(p->gs.selector)); - CHK_VMCS_READ(VMCS_GUEST_LDTR_SELECTOR, &(p->ldtr.selector)); - CHK_VMCS_READ(VMCS_GUEST_TR_SELECTOR, &(p->tr.selector)); - CHK_VMCS_READ(GUEST_CS_BASE, &(p->cs.baseAddr)); - CHK_VMCS_READ(GUEST_SS_BASE, &(p->ss.baseAddr)); - CHK_VMCS_READ(GUEST_DS_BASE, &(p->ds.baseAddr)); - CHK_VMCS_READ(GUEST_ES_BASE, &(p->es.baseAddr)); - CHK_VMCS_READ(GUEST_FS_BASE, &(p->fs.baseAddr)); - CHK_VMCS_READ(GUEST_GS_BASE, &(p->gs.baseAddr)); - CHK_VMCS_READ(GUEST_LDTR_BASE, &(p->ldtr.baseAddr)); - CHK_VMCS_READ(GUEST_TR_BASE, &(p->tr.baseAddr)); - CHK_VMCS_READ(GUEST_CS_LIMIT, &(p->cs.limit)); - CHK_VMCS_READ(GUEST_SS_LIMIT, &(p->ss.limit)); - CHK_VMCS_READ(GUEST_DS_LIMIT, &(p->ds.limit)); - CHK_VMCS_READ(GUEST_ES_LIMIT, &(p->es.limit)); - CHK_VMCS_READ(GUEST_FS_LIMIT, &(p->fs.limit)); - CHK_VMCS_READ(GUEST_GS_LIMIT, &(p->gs.limit)); - CHK_VMCS_READ(GUEST_LDTR_LIMIT, &(p->ldtr.limit)); - CHK_VMCS_READ(GUEST_TR_LIMIT, &(p->tr.limit)); - CHK_VMCS_READ(GUEST_CS_ACCESS, &(p->cs.access)); - CHK_VMCS_READ(GUEST_SS_ACCESS, &(p->ss.access)); - CHK_VMCS_READ(GUEST_DS_ACCESS, &(p->ds.access)); - CHK_VMCS_READ(GUEST_ES_ACCESS, &(p->es.access)); - CHK_VMCS_READ(GUEST_FS_ACCESS, &(p->fs.access)); - CHK_VMCS_READ(GUEST_GS_ACCESS, &(p->gs.access)); - CHK_VMCS_READ(GUEST_LDTR_ACCESS, &(p->ldtr.access)); - CHK_VMCS_READ(GUEST_TR_ACCESS, &(p->tr.access)); - CHK_VMCS_READ(GUEST_GDTR_BASE, &(p->gdtr.baseAddr)); - CHK_VMCS_READ(GUEST_IDTR_BASE, &(p->idtr.baseAddr)); - CHK_VMCS_READ(GUEST_GDTR_LIMIT, &(p->gdtr.limit)); - CHK_VMCS_READ(GUEST_IDTR_LIMIT, &(p->idtr.limit)); - CHK_VMCS_READ(GUEST_IA32_DEBUGCTL, &(p->dbg_ctrl)); - CHK_VMCS_READ(GUEST_IA32_DEBUGCTL_HIGH, ((char *)&(p->dbg_ctrl)) + 4); - CHK_VMCS_READ(GUEST_IA32_SYSENTER_CS, &(p->sysenter_cs)); - CHK_VMCS_READ(GUEST_IA32_SYSENTER_ESP, &(p->sysenter_esp)); - CHK_VMCS_READ(GUEST_IA32_SYSENTER_EIP, &(p->sysenter_eip)); - CHK_VMCS_READ(GUEST_SMBASE, &(p->smbase)); - - CHK_VMCS_READ(GUEST_ACTIVITY_STATE, &(p->activity)); - CHK_VMCS_READ(GUEST_INT_STATE, &(p->interrupt_state)); - CHK_VMCS_READ(GUEST_PENDING_DEBUG_EXCS, &(p->pending_dbg_exceptions)); - CHK_VMCS_READ(VMCS_LINK_PTR, &(p->vmcs_link)); - CHK_VMCS_READ(VMCS_LINK_PTR_HIGH, ((char *)&(p->vmcs_link)) + 4); - return 0; + + +static int inline check_vmcs_write(vmcs_field_t field, addr_t val) { + int ret = 0; + ret = vmcs_write(field, val); + + if (ret != VMX_SUCCESS) { + PrintError("VMWRITE error on %s!: %d\n", v3_vmcs_field_to_str(field), ret); + return 1; + } + + return 0; } +static int inline check_vmcs_read(vmcs_field_t field, void * val) { + int ret = 0; + ret = vmcs_read(field, val); + + if (ret != VMX_SUCCESS) { + PrintError("VMREAD error on %s!: %d\n", v3_vmcs_field_to_str(field), ret); + } -int CopyInVMCSGuestStateArea(struct VMCSGuestStateArea *p) { - CHK_VMCS_WRITE(GUEST_CR0, &(p->cr0)); - CHK_VMCS_WRITE(GUEST_CR3, &(p->cr3)); - CHK_VMCS_WRITE(GUEST_CR4, &(p->cr4)); - CHK_VMCS_WRITE(GUEST_DR7, &(p->dr7)); - CHK_VMCS_WRITE(GUEST_RSP, &(p->rsp)); - CHK_VMCS_WRITE(GUEST_RIP, &(p->rip)); - CHK_VMCS_WRITE(GUEST_RFLAGS, &(p->rflags)); - CHK_VMCS_WRITE(VMCS_GUEST_CS_SELECTOR, &(p->cs.selector)); - CHK_VMCS_WRITE(VMCS_GUEST_SS_SELECTOR, &(p->ss.selector)); - CHK_VMCS_WRITE(VMCS_GUEST_DS_SELECTOR, &(p->ds.selector)); - CHK_VMCS_WRITE(VMCS_GUEST_ES_SELECTOR, &(p->es.selector)); - CHK_VMCS_WRITE(VMCS_GUEST_FS_SELECTOR, &(p->fs.selector)); - CHK_VMCS_WRITE(VMCS_GUEST_GS_SELECTOR, &(p->gs.selector)); - CHK_VMCS_WRITE(VMCS_GUEST_LDTR_SELECTOR, &(p->ldtr.selector)); - CHK_VMCS_WRITE(VMCS_GUEST_TR_SELECTOR, &(p->tr.selector)); - CHK_VMCS_WRITE(GUEST_CS_BASE, &(p->cs.baseAddr)); - CHK_VMCS_WRITE(GUEST_SS_BASE, &(p->ss.baseAddr)); - CHK_VMCS_WRITE(GUEST_DS_BASE, &(p->ds.baseAddr)); - CHK_VMCS_WRITE(GUEST_ES_BASE, &(p->es.baseAddr)); - CHK_VMCS_WRITE(GUEST_FS_BASE, &(p->fs.baseAddr)); - CHK_VMCS_WRITE(GUEST_GS_BASE, &(p->gs.baseAddr)); - CHK_VMCS_WRITE(GUEST_LDTR_BASE, &(p->ldtr.baseAddr)); - CHK_VMCS_WRITE(GUEST_TR_BASE, &(p->tr.baseAddr)); - CHK_VMCS_WRITE(GUEST_CS_LIMIT, &(p->cs.limit)); - CHK_VMCS_WRITE(GUEST_SS_LIMIT, &(p->ss.limit)); - CHK_VMCS_WRITE(GUEST_DS_LIMIT, &(p->ds.limit)); - CHK_VMCS_WRITE(GUEST_ES_LIMIT, &(p->es.limit)); - CHK_VMCS_WRITE(GUEST_FS_LIMIT, &(p->fs.limit)); - CHK_VMCS_WRITE(GUEST_GS_LIMIT, &(p->gs.limit)); - CHK_VMCS_WRITE(GUEST_LDTR_LIMIT, &(p->ldtr.limit)); - CHK_VMCS_WRITE(GUEST_TR_LIMIT, &(p->tr.limit)); - CHK_VMCS_WRITE(GUEST_CS_ACCESS, &(p->cs.access)); - CHK_VMCS_WRITE(GUEST_SS_ACCESS, &(p->ss.access)); - CHK_VMCS_WRITE(GUEST_DS_ACCESS, &(p->ds.access)); - CHK_VMCS_WRITE(GUEST_ES_ACCESS, &(p->es.access)); - CHK_VMCS_WRITE(GUEST_FS_ACCESS, &(p->fs.access)); - CHK_VMCS_WRITE(GUEST_GS_ACCESS, &(p->gs.access)); - CHK_VMCS_WRITE(GUEST_LDTR_ACCESS, &(p->ldtr.access)); - CHK_VMCS_WRITE(GUEST_TR_ACCESS, &(p->tr.access)); - CHK_VMCS_WRITE(GUEST_GDTR_BASE, &(p->gdtr.baseAddr)); - CHK_VMCS_WRITE(GUEST_IDTR_BASE, &(p->idtr.baseAddr)); - CHK_VMCS_WRITE(GUEST_GDTR_LIMIT, &(p->gdtr.limit)); - CHK_VMCS_WRITE(GUEST_IDTR_LIMIT, &(p->idtr.limit)); - CHK_VMCS_WRITE(GUEST_IA32_DEBUGCTL, &(p->dbg_ctrl)); - CHK_VMCS_WRITE(GUEST_IA32_DEBUGCTL_HIGH, ((char *)&(p->dbg_ctrl)) + 4); - CHK_VMCS_WRITE(GUEST_IA32_SYSENTER_CS, &(p->sysenter_cs)); - CHK_VMCS_WRITE(GUEST_IA32_SYSENTER_ESP, &(p->sysenter_esp)); - CHK_VMCS_WRITE(GUEST_IA32_SYSENTER_EIP, &(p->sysenter_eip)); - CHK_VMCS_WRITE(GUEST_SMBASE, &(p->smbase)); - - CHK_VMCS_WRITE(GUEST_ACTIVITY_STATE, &(p->activity)); - CHK_VMCS_WRITE(GUEST_INT_STATE, &(p->interrupt_state)); - CHK_VMCS_WRITE(GUEST_PENDING_DEBUG_EXCS, &(p->pending_dbg_exceptions)); - CHK_VMCS_WRITE(VMCS_LINK_PTR, &(p->vmcs_link)); - CHK_VMCS_WRITE(VMCS_LINK_PTR_HIGH, ((char *)&(p->vmcs_link)) + 4); - return 0; + return ret; } -int CopyOutVMCSHostStateArea(struct VMCSHostStateArea *p) { - CHK_VMCS_READ(HOST_CR0, &(p->cr0)); - CHK_VMCS_READ(HOST_CR3, &(p->cr3)); - CHK_VMCS_READ(HOST_CR4, &(p->cr4)); - CHK_VMCS_READ(HOST_RSP, &(p->rsp)); - CHK_VMCS_READ(HOST_RIP, &(p->rip)); - CHK_VMCS_READ(VMCS_HOST_CS_SELECTOR, &(p->csSelector)); - CHK_VMCS_READ(VMCS_HOST_SS_SELECTOR, &(p->ssSelector)); - CHK_VMCS_READ(VMCS_HOST_DS_SELECTOR, &(p->dsSelector)); - CHK_VMCS_READ(VMCS_HOST_ES_SELECTOR, &(p->esSelector)); - CHK_VMCS_READ(VMCS_HOST_FS_SELECTOR, &(p->fsSelector)); - CHK_VMCS_READ(VMCS_HOST_GS_SELECTOR, &(p->gsSelector)); - CHK_VMCS_READ(VMCS_HOST_TR_SELECTOR, &(p->trSelector)); - CHK_VMCS_READ(HOST_FS_BASE, &(p->fsBaseAddr)); - CHK_VMCS_READ(HOST_GS_BASE, &(p->gsBaseAddr)); - CHK_VMCS_READ(HOST_TR_BASE, &(p->trBaseAddr)); - CHK_VMCS_READ(HOST_GDTR_BASE, &(p->gdtrBaseAddr)); - CHK_VMCS_READ(HOST_IDTR_BASE, &(p->idtrBaseAddr)); - CHK_VMCS_READ(HOST_IA32_SYSENTER_CS, &(p->sysenter_cs)); - CHK_VMCS_READ(HOST_IA32_SYSENTER_ESP, &(p->sysenter_esp)); - CHK_VMCS_READ(HOST_IA32_SYSENTER_EIP, &(p->sysenter_eip)); - return 0; + + + + +typedef enum { ES = 0, + CS = 2, + SS = 4, + DS = 6, + FS = 8, + GS = 10, + LDTR = 12, + TR = 14, + GDTR = 16, + IDTR = 18} vmcs_seg_offsets_t; + +typedef enum {BASE = VMCS_GUEST_ES_BASE, + LIMIT = VMCS_GUEST_ES_LIMIT, + ACCESS = VMCS_GUEST_ES_ACCESS, + SELECTOR = VMCS_GUEST_ES_SELECTOR } vmcs_seg_bases_t; + + + +static int v3_read_vmcs_segment(struct v3_segment * seg, vmcs_seg_offsets_t seg_type) { + vmcs_field_t selector = VMCS_GUEST_ES_SELECTOR + seg_type; + vmcs_field_t base = VMCS_GUEST_ES_BASE + seg_type; + vmcs_field_t limit = VMCS_GUEST_ES_LIMIT + seg_type; + vmcs_field_t access = VMCS_GUEST_ES_ACCESS + seg_type; + struct vmcs_segment vmcs_seg; + + memset(&vmcs_seg, 0, sizeof(struct vmcs_segment)); + + check_vmcs_read(limit, &(vmcs_seg.limit)); + check_vmcs_read(base, &(vmcs_seg.base)); + + if ((seg_type != GDTR) && (seg_type != IDTR)) { + check_vmcs_read(selector, &(vmcs_seg.selector)); + check_vmcs_read(access, &(vmcs_seg.access.val)); + } + + v3_vmxseg_to_seg(&vmcs_seg, seg); + + return 0; } +static int v3_write_vmcs_segment(struct v3_segment * seg, vmcs_seg_offsets_t seg_type) { + vmcs_field_t selector = VMCS_GUEST_ES_SELECTOR + seg_type; + vmcs_field_t base = VMCS_GUEST_ES_BASE + seg_type; + vmcs_field_t limit = VMCS_GUEST_ES_LIMIT + seg_type; + vmcs_field_t access = VMCS_GUEST_ES_ACCESS + seg_type; + struct vmcs_segment vmcs_seg; + v3_seg_to_vmxseg(seg, &vmcs_seg); -int CopyInVMCSHostStateArea(struct VMCSHostStateArea *p) { - CHK_VMCS_WRITE(HOST_CR0, &(p->cr0)); - CHK_VMCS_WRITE(HOST_CR3, &(p->cr3)); - CHK_VMCS_WRITE(HOST_CR4, &(p->cr4)); - CHK_VMCS_WRITE(HOST_RSP, &(p->rsp)); - CHK_VMCS_WRITE(HOST_RIP, &(p->rip)); - CHK_VMCS_WRITE(VMCS_HOST_CS_SELECTOR, &(p->csSelector)); - CHK_VMCS_WRITE(VMCS_HOST_SS_SELECTOR, &(p->ssSelector)); - CHK_VMCS_WRITE(VMCS_HOST_DS_SELECTOR, &(p->dsSelector)); - CHK_VMCS_WRITE(VMCS_HOST_ES_SELECTOR, &(p->esSelector)); - CHK_VMCS_WRITE(VMCS_HOST_FS_SELECTOR, &(p->fsSelector)); - CHK_VMCS_WRITE(VMCS_HOST_GS_SELECTOR, &(p->gsSelector)); - CHK_VMCS_WRITE(VMCS_HOST_TR_SELECTOR, &(p->trSelector)); - CHK_VMCS_WRITE(HOST_FS_BASE, &(p->fsBaseAddr)); - CHK_VMCS_WRITE(HOST_GS_BASE, &(p->gsBaseAddr)); - CHK_VMCS_WRITE(HOST_TR_BASE, &(p->trBaseAddr)); - CHK_VMCS_WRITE(HOST_GDTR_BASE, &(p->gdtrBaseAddr)); - CHK_VMCS_WRITE(HOST_IDTR_BASE, &(p->idtrBaseAddr)); - CHK_VMCS_WRITE(HOST_IA32_SYSENTER_CS, &(p->sysenter_cs)); - CHK_VMCS_WRITE(HOST_IA32_SYSENTER_ESP, &(p->sysenter_esp)); - CHK_VMCS_WRITE(HOST_IA32_SYSENTER_EIP, &(p->sysenter_eip)); - return 0; + check_vmcs_write(limit, vmcs_seg.limit); + check_vmcs_write(base, vmcs_seg.base); + + if ((seg_type != GDTR) && (seg_type != IDTR)) { + check_vmcs_write(access, vmcs_seg.access.val); + check_vmcs_write(selector, vmcs_seg.selector); + } + + return 0; } +int v3_read_vmcs_segments(struct v3_segments * segs) { + v3_read_vmcs_segment(&(segs->cs), CS); + v3_read_vmcs_segment(&(segs->ds), DS); + v3_read_vmcs_segment(&(segs->es), ES); + v3_read_vmcs_segment(&(segs->fs), FS); + v3_read_vmcs_segment(&(segs->gs), GS); + v3_read_vmcs_segment(&(segs->ss), SS); + v3_read_vmcs_segment(&(segs->ldtr), LDTR); + v3_read_vmcs_segment(&(segs->gdtr), GDTR); + v3_read_vmcs_segment(&(segs->idtr), IDTR); + v3_read_vmcs_segment(&(segs->tr), TR); -int CopyOutVMCSExitCtrlFields(struct VMCSExitCtrlFields *p) -{ - CHK_VMCS_READ(VM_EXIT_CTRLS,&(p->exitCtrls)); - CHK_VMCS_READ(VM_EXIT_MSR_STORE_COUNT,&(p->msrStoreCount)); - CHK_VMCS_READ(VM_EXIT_MSR_STORE_ADDR,&(p->msrStoreAddr)); - CHK_VMCS_READ(VM_EXIT_MSR_LOAD_COUNT,&(p->msrLoadCount)); - CHK_VMCS_READ(VM_EXIT_MSR_LOAD_ADDR,&(p->msrLoadAddr)); - return 0; + return 0; } -int CopyInVMCSExitCtrlFields(struct VMCSExitCtrlFields *p) -{ - CHK_VMCS_WRITE(VM_EXIT_CTRLS,&(p->exitCtrls)); - CHK_VMCS_WRITE(VM_EXIT_MSR_STORE_COUNT,&(p->msrStoreCount)); - CHK_VMCS_WRITE(VM_EXIT_MSR_STORE_ADDR,&(p->msrStoreAddr)); - CHK_VMCS_WRITE(VM_EXIT_MSR_LOAD_COUNT,&(p->msrLoadCount)); - CHK_VMCS_WRITE(VM_EXIT_MSR_LOAD_ADDR,&(p->msrLoadAddr)); - return 0; +int v3_write_vmcs_segments(struct v3_segments * segs) { + v3_write_vmcs_segment(&(segs->cs), CS); + v3_write_vmcs_segment(&(segs->ds), DS); + v3_write_vmcs_segment(&(segs->es), ES); + v3_write_vmcs_segment(&(segs->fs), FS); + v3_write_vmcs_segment(&(segs->gs), GS); + v3_write_vmcs_segment(&(segs->ss), SS); + v3_write_vmcs_segment(&(segs->ldtr), LDTR); + v3_write_vmcs_segment(&(segs->gdtr), GDTR); + v3_write_vmcs_segment(&(segs->idtr), IDTR); + v3_write_vmcs_segment(&(segs->tr), TR); + + return 0; } -int CopyOutVMCSEntryCtrlFields(struct VMCSEntryCtrlFields *p) -{ - CHK_VMCS_READ(VM_ENTRY_CTRLS,&(p->entryCtrls)); - CHK_VMCS_READ(VM_ENTRY_MSR_LOAD_COUNT,&(p->msrLoadCount)); - CHK_VMCS_READ(VM_ENTRY_MSR_LOAD_ADDR,&(p->msrLoadAddr)); - CHK_VMCS_READ(VM_ENTRY_INT_INFO_FIELD,&(p->intInfo)); - CHK_VMCS_READ(VM_ENTRY_EXCEPTION_ERROR,&(p->exceptionErrorCode)); - CHK_VMCS_READ(VM_ENTRY_INSTR_LENGTH,&(p->instrLength)); - return 0; +void v3_vmxseg_to_seg(struct vmcs_segment * vmcs_seg, struct v3_segment * seg) { + memset(seg, 0, sizeof(struct v3_segment)); + + seg->selector = vmcs_seg->selector; + seg->limit = vmcs_seg->limit; + seg->base = vmcs_seg->base; + + seg->type = vmcs_seg->access.type; + seg->system = vmcs_seg->access.desc_type; + seg->dpl = vmcs_seg->access.dpl; + seg->present = vmcs_seg->access.present; + seg->avail = vmcs_seg->access.avail; + seg->long_mode = vmcs_seg->access.long_mode; + seg->db = vmcs_seg->access.db; + seg->granularity = vmcs_seg->access.granularity; + seg->unusable = vmcs_seg->access.unusable; + } -int CopyInVMCSEntryCtrlFields(struct VMCSEntryCtrlFields *p) -{ - CHK_VMCS_WRITE(VM_ENTRY_CTRLS,&(p->entryCtrls)); - CHK_VMCS_WRITE(VM_ENTRY_MSR_LOAD_COUNT,&(p->msrLoadCount)); - CHK_VMCS_WRITE(VM_ENTRY_MSR_LOAD_ADDR,&(p->msrLoadAddr)); - CHK_VMCS_WRITE(VM_ENTRY_INT_INFO_FIELD,&(p->intInfo)); - CHK_VMCS_WRITE(VM_ENTRY_EXCEPTION_ERROR,&(p->exceptionErrorCode)); - CHK_VMCS_WRITE(VM_ENTRY_INSTR_LENGTH,&(p->instrLength)); - return 0; +void v3_seg_to_vmxseg(struct v3_segment * seg, struct vmcs_segment * vmcs_seg) { + memset(vmcs_seg, 0, sizeof(struct vmcs_segment)); + + vmcs_seg->selector = seg->selector; + vmcs_seg->limit = seg->limit; + vmcs_seg->base = seg->base; + + vmcs_seg->access.type = seg->type; + vmcs_seg->access.desc_type = seg->system; + vmcs_seg->access.dpl = seg->dpl; + vmcs_seg->access.present = seg->present; + vmcs_seg->access.avail = seg->avail; + vmcs_seg->access.long_mode = seg->long_mode; + vmcs_seg->access.db = seg->db; + vmcs_seg->access.granularity = seg->granularity; + vmcs_seg->access.unusable = seg->unusable; } -int CopyOutVMCSExitInfoFields(struct VMCSExitInfoFields *p) { - CHK_VMCS_READ(EXIT_REASON,&(p->reason)); - CHK_VMCS_READ(EXIT_QUALIFICATION,&(p->qualification)); - CHK_VMCS_READ(VM_EXIT_INT_INFO,&(p->intInfo)); - CHK_VMCS_READ(VM_EXIT_INT_ERROR,&(p->intErrorCode)); - CHK_VMCS_READ(IDT_VECTOR_INFO,&(p->idtVectorInfo)); - CHK_VMCS_READ(IDT_VECTOR_ERROR,&(p->idtVectorErrorCode)); - CHK_VMCS_READ(VM_EXIT_INSTR_LENGTH,&(p->instrLength)); - CHK_VMCS_READ(GUEST_LINEAR_ADDR,&(p->guestLinearAddr)); - CHK_VMCS_READ(VMX_INSTR_INFO,&(p->instrInfo)); - CHK_VMCS_READ(IO_RCX,&(p->ioRCX)); - CHK_VMCS_READ(IO_RSI,&(p->ioRSI)); - CHK_VMCS_READ(IO_RDI,&(p->ioRDI)); - CHK_VMCS_READ(IO_RIP,&(p->ioRIP)); - CHK_VMCS_READ(VM_INSTR_ERROR,&(p->instrErrorField)); - return 0; + + + +int v3_update_vmcs_ctrl_fields(struct guest_info * info) { + int vmx_ret = 0; + struct vmx_data * arch_data = (struct vmx_data *)(info->vmm_data); + + vmx_ret |= check_vmcs_write(VMCS_PIN_CTRLS, arch_data->pin_ctrls.value); + vmx_ret |= check_vmcs_write(VMCS_PROC_CTRLS, arch_data->pri_proc_ctrls.value); + + if (arch_data->pri_proc_ctrls.sec_ctrls) { + vmx_ret |= check_vmcs_write(VMCS_SEC_PROC_CTRLS, arch_data->sec_proc_ctrls.value); + } + + vmx_ret |= check_vmcs_write(VMCS_EXIT_CTRLS, arch_data->exit_ctrls.value); + vmx_ret |= check_vmcs_write(VMCS_ENTRY_CTRLS, arch_data->entry_ctrls.value); + + return vmx_ret; } -int CopyOutVMCSExecCtrlFields(struct VMCSExecCtrlFields *p) -{ - CHK_VMCS_READ(PIN_VM_EXEC_CTRLS,&(p->pinCtrls)); - CHK_VMCS_READ(PROC_VM_EXEC_CTRLS,&(p->procCtrls)); - CHK_VMCS_READ(EXCEPTION_BITMAP,&(p->execBitmap)); - CHK_VMCS_READ(PAGE_FAULT_ERROR_MASK,&(p->pageFaultErrorMask)); - CHK_VMCS_READ(PAGE_FAULT_ERROR_MATCH,&(p->pageFaultErrorMatch)); - CHK_VMCS_READ(IO_BITMAP_A_ADDR,&(p->ioBitmapA)); - CHK_VMCS_READ(IO_BITMAP_B_ADDR,&(p->ioBitmapB)); - CHK_VMCS_READ(TSC_OFFSET,&(p->tscOffset)); - CHK_VMCS_READ(CR0_GUEST_HOST_MASK,&(p->cr0GuestHostMask)); - CHK_VMCS_READ(CR0_READ_SHADOW,&(p->cr0ReadShadow)); - CHK_VMCS_READ(CR4_GUEST_HOST_MASK,&(p->cr4GuestHostMask)); - CHK_VMCS_READ(CR4_READ_SHADOW,&(p->cr4ReadShadow)); - CHK_VMCS_READ(CR3_TARGET_COUNT, &(p->cr3TargetCount)); - CHK_VMCS_READ(CR3_TARGET_VALUE_0, &(p->cr3TargetValue0)); - CHK_VMCS_READ(CR3_TARGET_VALUE_1, &(p->cr3TargetValue1)); - CHK_VMCS_READ(CR3_TARGET_VALUE_2, &(p->cr3TargetValue2)); - CHK_VMCS_READ(CR3_TARGET_VALUE_3, &(p->cr3TargetValue3)); - CHK_VMCS_READ(VIRT_APIC_PAGE_ADDR, &(p->virtApicPageAddr)); - CHK_VMCS_READ(TPR_THRESHOLD, &(p->tprThreshold)); - CHK_VMCS_READ(MSR_BITMAPS, &(p->MSRBitmapsBaseAddr)); - CHK_VMCS_READ(VMCS_EXEC_PTR,&(p->vmcsExecPtr)); - return 0; + + + + +int v3_vmx_save_vmcs(struct guest_info * info) { + struct vmx_data * vmx_info = (struct vmx_data *)(info->vmm_data); + int error = 0; + + check_vmcs_read(VMCS_GUEST_RIP, &(info->rip)); + check_vmcs_read(VMCS_GUEST_RSP, &(info->vm_regs.rsp)); + + check_vmcs_read(VMCS_GUEST_CR0, &(info->ctrl_regs.cr0)); + check_vmcs_read(VMCS_CR0_READ_SHDW, &(info->shdw_pg_state.guest_cr0)); + check_vmcs_read(VMCS_GUEST_CR3, &(info->ctrl_regs.cr3)); + check_vmcs_read(VMCS_GUEST_CR4, &(info->ctrl_regs.cr4)); + check_vmcs_read(VMCS_CR4_READ_SHDW, &(vmx_info->guest_cr4)); + check_vmcs_read(VMCS_GUEST_DR7, &(info->dbg_regs.dr7)); + + check_vmcs_read(VMCS_GUEST_RFLAGS, &(info->ctrl_regs.rflags)); + if (((struct vmx_data *)info->vmm_data)->ia32e_avail) { + check_vmcs_read(VMCS_GUEST_EFER, &(info->ctrl_regs.efer)); + } + + error = v3_read_vmcs_segments(&(info->segments)); + + return error; } -int CopyInVMCSExecCtrlFields(struct VMCSExecCtrlFields *p) -{ - CHK_VMCS_WRITE(PIN_VM_EXEC_CTRLS,&(p->pinCtrls)); - CHK_VMCS_WRITE(PROC_VM_EXEC_CTRLS,&(p->procCtrls)); - CHK_VMCS_WRITE(EXCEPTION_BITMAP,&(p->execBitmap)); - CHK_VMCS_WRITE(PAGE_FAULT_ERROR_MASK,&(p->pageFaultErrorMask)); - CHK_VMCS_WRITE(PAGE_FAULT_ERROR_MATCH,&(p->pageFaultErrorMatch)); - CHK_VMCS_WRITE(IO_BITMAP_A_ADDR,&(p->ioBitmapA)); - CHK_VMCS_WRITE(IO_BITMAP_B_ADDR,&(p->ioBitmapB)); - CHK_VMCS_WRITE(TSC_OFFSET,&(p->tscOffset)); - CHK_VMCS_WRITE(CR0_GUEST_HOST_MASK,&(p->cr0GuestHostMask)); - CHK_VMCS_WRITE(CR0_READ_SHADOW,&(p->cr0ReadShadow)); - CHK_VMCS_WRITE(CR4_GUEST_HOST_MASK,&(p->cr4GuestHostMask)); - CHK_VMCS_WRITE(CR4_READ_SHADOW,&(p->cr4ReadShadow)); - CHK_VMCS_WRITE(CR3_TARGET_COUNT, &(p->cr3TargetCount)); - CHK_VMCS_WRITE(CR3_TARGET_VALUE_0, &(p->cr3TargetValue0)); - CHK_VMCS_WRITE(CR3_TARGET_VALUE_1, &(p->cr3TargetValue1)); - CHK_VMCS_WRITE(CR3_TARGET_VALUE_2, &(p->cr3TargetValue2)); - CHK_VMCS_WRITE(CR3_TARGET_VALUE_3, &(p->cr3TargetValue3)); - CHK_VMCS_WRITE(VIRT_APIC_PAGE_ADDR, &(p->virtApicPageAddr)); - CHK_VMCS_WRITE(TPR_THRESHOLD, &(p->tprThreshold)); - CHK_VMCS_WRITE(MSR_BITMAPS, &(p->MSRBitmapsBaseAddr)); - CHK_VMCS_WRITE(VMCS_EXEC_PTR,&(p->vmcsExecPtr)); - return 0; +int v3_vmx_restore_vmcs(struct guest_info * info) { + struct vmx_data * vmx_info = (struct vmx_data *)(info->vmm_data); + int error = 0; + + check_vmcs_write(VMCS_GUEST_RIP, info->rip); + check_vmcs_write(VMCS_GUEST_RSP, info->vm_regs.rsp); + + check_vmcs_write(VMCS_GUEST_CR0, info->ctrl_regs.cr0); + check_vmcs_write(VMCS_CR0_READ_SHDW, info->shdw_pg_state.guest_cr0); + check_vmcs_write(VMCS_GUEST_CR3, info->ctrl_regs.cr3); + check_vmcs_write(VMCS_GUEST_CR4, info->ctrl_regs.cr4); + check_vmcs_write(VMCS_CR4_READ_SHDW, vmx_info->guest_cr4); + check_vmcs_write(VMCS_GUEST_DR7, info->dbg_regs.dr7); + + check_vmcs_write(VMCS_GUEST_RFLAGS, info->ctrl_regs.rflags); + + if (((struct vmx_data *)info->vmm_data)->ia32e_avail) { + check_vmcs_write(VMCS_GUEST_EFER, info->ctrl_regs.efer); + } + + error = v3_write_vmcs_segments(&(info->segments)); + + return error; + +} + + + +int v3_update_vmcs_host_state(struct guest_info * info) { + int vmx_ret = 0; + addr_t tmp; + struct vmx_data * arch_data = (struct vmx_data *)(info->vmm_data); + struct v3_msr tmp_msr; + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%cr0, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%cr0, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_CR0, tmp); + + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%cr3, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%cr3, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_CR3, tmp); + + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%cr4, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%cr4, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_CR4, tmp); + + + + vmx_ret |= check_vmcs_write(VMCS_HOST_GDTR_BASE, arch_data->host_state.gdtr.base); + vmx_ret |= check_vmcs_write(VMCS_HOST_IDTR_BASE, arch_data->host_state.idtr.base); + vmx_ret |= check_vmcs_write(VMCS_HOST_TR_BASE, arch_data->host_state.tr.base); + +#define FS_BASE_MSR 0xc0000100 +#define GS_BASE_MSR 0xc0000101 + + // FS.BASE MSR + v3_get_msr(FS_BASE_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); + vmx_ret |= check_vmcs_write(VMCS_HOST_FS_BASE, tmp_msr.value); + + // GS.BASE MSR + v3_get_msr(GS_BASE_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); + vmx_ret |= check_vmcs_write(VMCS_HOST_GS_BASE, tmp_msr.value); + + + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%cs, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%cs, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_CS_SELECTOR, tmp); + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%ss, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%ss, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_SS_SELECTOR, tmp); + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%ds, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%ds, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_DS_SELECTOR, tmp); + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%es, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%es, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_ES_SELECTOR, tmp); + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%fs, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%fs, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_FS_SELECTOR, tmp); + +#ifdef __V3_64BIT__ + __asm__ __volatile__ ( "movq %%gs, %0; " + : "=q"(tmp) + : + ); +#else + __asm__ __volatile__ ( "movl %%gs, %0; " + : "=q"(tmp) + : + ); +#endif + vmx_ret |= check_vmcs_write(VMCS_HOST_GS_SELECTOR, tmp); + + vmx_ret |= check_vmcs_write(VMCS_HOST_TR_SELECTOR, arch_data->host_state.tr.selector); + + +#define SYSENTER_CS_MSR 0x00000174 +#define SYSENTER_ESP_MSR 0x00000175 +#define SYSENTER_EIP_MSR 0x00000176 + + // SYSENTER CS MSR + v3_get_msr(SYSENTER_CS_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); + vmx_ret |= check_vmcs_write(VMCS_HOST_SYSENTER_CS, tmp_msr.lo); + + // SYSENTER_ESP MSR + v3_get_msr(SYSENTER_ESP_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); + vmx_ret |= check_vmcs_write(VMCS_HOST_SYSENTER_ESP, tmp_msr.value); + + // SYSENTER_EIP MSR + v3_get_msr(SYSENTER_EIP_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); + vmx_ret |= check_vmcs_write(VMCS_HOST_SYSENTER_EIP, tmp_msr.value); + + return vmx_ret; } -int CopyOutVMCSData(struct VMCSData *p) { - if (CopyOutVMCSGuestStateArea(&(p->guestStateArea)) != 0) { - return -1; - } - if (CopyOutVMCSHostStateArea(&(p->hostStateArea)) != 0) { - return -1; - } - if (CopyOutVMCSExecCtrlFields(&(p->execCtrlFields)) != 0) { - return -1; - } - if (CopyOutVMCSExitCtrlFields(&(p->exitCtrlFields)) != 0) { - return -1; - } - if (CopyOutVMCSEntryCtrlFields(&(p->entryCtrlFields)) != 0) { - return -1; - } - if (CopyOutVMCSExitInfoFields(&(p->exitInfoFields)) != 0) { - return -1; - } - return 0; + + + + +static inline void print_vmcs_field(vmcs_field_t vmcs_index) { + int len = v3_vmcs_get_field_len(vmcs_index); + addr_t val; + + if (vmcs_read(vmcs_index, &val) != VMX_SUCCESS) { + PrintError("VMCS_READ error for %s\n", v3_vmcs_field_to_str(vmcs_index)); + return; + }; + + if (len == 2) { + PrintDebug("\t%s: 0x%.4x\n", v3_vmcs_field_to_str(vmcs_index), (uint16_t)val); + } else if (len == 4) { + PrintDebug("\t%s: 0x%.8x\n", v3_vmcs_field_to_str(vmcs_index), (uint32_t)val); + } else if (len == 8) { + PrintDebug("\t%s: 0x%p\n", v3_vmcs_field_to_str(vmcs_index), (void *)(addr_t)val); + } } -int CopyInVMCSData(struct VMCSData *p) { - if (CopyInVMCSGuestStateArea(&(p->guestStateArea)) != 0) { - return -1; - } - if (CopyInVMCSHostStateArea(&(p->hostStateArea)) != 0) { - return -1; - } - if (CopyInVMCSExecCtrlFields(&(p->execCtrlFields)) != 0) { - return -1; - } - if (CopyInVMCSExitCtrlFields(&(p->exitCtrlFields)) != 0) { - return -1; - } - if (CopyInVMCSEntryCtrlFields(&(p->entryCtrlFields)) != 0) { - return -1; - } - return 0; +static void print_vmcs_segments() { + struct v3_segments segs; + + v3_read_vmcs_segments(&segs); + v3_print_segments(&segs); + + + PrintDebug(" ==> CS\n"); + print_vmcs_field(VMCS_GUEST_CS_SELECTOR); + print_vmcs_field(VMCS_GUEST_CS_BASE); + print_vmcs_field(VMCS_GUEST_CS_LIMIT); + print_vmcs_field(VMCS_GUEST_CS_ACCESS); + + PrintDebug(" ==> SS\n"); + print_vmcs_field(VMCS_GUEST_SS_SELECTOR); + print_vmcs_field(VMCS_GUEST_SS_BASE); + print_vmcs_field(VMCS_GUEST_SS_LIMIT); + print_vmcs_field(VMCS_GUEST_SS_ACCESS); + + PrintDebug(" ==> DS\n"); + print_vmcs_field(VMCS_GUEST_DS_SELECTOR); + print_vmcs_field(VMCS_GUEST_DS_BASE); + print_vmcs_field(VMCS_GUEST_DS_LIMIT); + print_vmcs_field(VMCS_GUEST_DS_ACCESS); + + PrintDebug(" ==> ES\n"); + print_vmcs_field(VMCS_GUEST_ES_SELECTOR); + print_vmcs_field(VMCS_GUEST_ES_BASE); + print_vmcs_field(VMCS_GUEST_ES_LIMIT); + print_vmcs_field(VMCS_GUEST_ES_ACCESS); + + PrintDebug(" ==> FS\n"); + print_vmcs_field(VMCS_GUEST_FS_SELECTOR); + print_vmcs_field(VMCS_GUEST_FS_BASE); + print_vmcs_field(VMCS_GUEST_FS_LIMIT); + print_vmcs_field(VMCS_GUEST_FS_ACCESS); + + PrintDebug(" ==> GS\n"); + print_vmcs_field(VMCS_GUEST_GS_SELECTOR); + print_vmcs_field(VMCS_GUEST_GS_BASE); + print_vmcs_field(VMCS_GUEST_GS_LIMIT); + print_vmcs_field(VMCS_GUEST_GS_ACCESS); + + PrintDebug(" ==> LDTR\n"); + print_vmcs_field(VMCS_GUEST_LDTR_SELECTOR); + print_vmcs_field(VMCS_GUEST_LDTR_BASE); + print_vmcs_field(VMCS_GUEST_LDTR_LIMIT); + print_vmcs_field(VMCS_GUEST_LDTR_ACCESS); + + PrintDebug(" ==> TR\n"); + print_vmcs_field(VMCS_GUEST_TR_SELECTOR); + print_vmcs_field(VMCS_GUEST_TR_BASE); + print_vmcs_field(VMCS_GUEST_TR_LIMIT); + print_vmcs_field(VMCS_GUEST_TR_ACCESS); + + PrintDebug(" ==> GDTR\n"); + print_vmcs_field(VMCS_GUEST_GDTR_BASE); + print_vmcs_field(VMCS_GUEST_GDTR_LIMIT); + + PrintDebug(" ==> IDTR\n"); + print_vmcs_field(VMCS_GUEST_IDTR_BASE); + print_vmcs_field(VMCS_GUEST_IDTR_LIMIT); + + } -void PrintTrace_VMX_Regs(struct VMXRegs * regs) { - PrintTrace("==>VMX Register values:\n"); - PrintTrace("EAX: %x\n", regs->eax); - PrintTrace("ECX: %x\n", regs->ecx); - PrintTrace("EDX: %x\n", regs->edx); - PrintTrace("EBX: %x\n", regs->ebx); - PrintTrace("ESP: %x\n", regs->esp); - PrintTrace("EBP: %x\n", regs->ebp); - PrintTrace("ESI: %x\n", regs->esi); - PrintTrace("EDI: %x\n", regs->edi); - PrintTrace("\n"); + + +static void print_guest_state() +{ + PrintDebug("VMCS_GUEST_STATE\n"); + print_vmcs_field(VMCS_GUEST_RIP); + print_vmcs_field(VMCS_GUEST_RSP); + print_vmcs_field(VMCS_GUEST_RFLAGS); + print_vmcs_field(VMCS_GUEST_CR0); + print_vmcs_field(VMCS_GUEST_CR3); + print_vmcs_field(VMCS_GUEST_CR4); + print_vmcs_field(VMCS_GUEST_DR7); + + + PrintDebug("\n"); + + print_vmcs_segments(); + + PrintDebug("\n"); + + print_vmcs_field(VMCS_GUEST_DBG_CTL); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_GUEST_DBG_CTL_HIGH); +#endif + print_vmcs_field(VMCS_GUEST_SYSENTER_CS); + print_vmcs_field(VMCS_GUEST_SYSENTER_ESP); + print_vmcs_field(VMCS_GUEST_SYSENTER_EIP); + + print_vmcs_field(VMCS_GUEST_PERF_GLOBAL_CTRL); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH); +#endif + + print_vmcs_field(VMCS_GUEST_SMBASE); + + + PrintDebug("GUEST_NON_REGISTER_STATE\n"); + + print_vmcs_field(VMCS_GUEST_ACTIVITY_STATE); + print_vmcs_field(VMCS_GUEST_INT_STATE); + print_vmcs_field(VMCS_GUEST_PENDING_DBG_EXCP); + } + +static void print_host_state() +{ + PrintDebug("VMCS_HOST_STATE\n"); + + print_vmcs_field(VMCS_HOST_RIP); + print_vmcs_field(VMCS_HOST_RSP); + print_vmcs_field(VMCS_HOST_CR0); + print_vmcs_field(VMCS_HOST_CR3); + print_vmcs_field(VMCS_HOST_CR4); + + PrintDebug("\n"); + print_vmcs_field(VMCS_HOST_CS_SELECTOR); + print_vmcs_field(VMCS_HOST_SS_SELECTOR); + print_vmcs_field(VMCS_HOST_DS_SELECTOR); + print_vmcs_field(VMCS_HOST_ES_SELECTOR); + print_vmcs_field(VMCS_HOST_FS_SELECTOR); + print_vmcs_field(VMCS_HOST_GS_SELECTOR); + print_vmcs_field(VMCS_HOST_TR_SELECTOR); + PrintDebug("\n"); + print_vmcs_field(VMCS_HOST_FS_BASE); + print_vmcs_field(VMCS_HOST_GS_BASE); + print_vmcs_field(VMCS_HOST_TR_BASE); + print_vmcs_field(VMCS_HOST_GDTR_BASE); + print_vmcs_field(VMCS_HOST_IDTR_BASE); -void PrintTrace_VMCSSegment(char * segname, struct VMCSSegment * seg, int abbr) { - PrintTrace("Segment: %s\n", segname); - if (abbr == 0) { - PrintTrace("\tSelector: %x\n", (uint_t)seg->selector); - PrintTrace("\tAccess: %x\n", *(uint_t*)&(seg->access)); - } - PrintTrace("\tBase Addr: %x\n", (uint_t)seg->baseAddr); - PrintTrace("\tLimit: %x\n", (uint_t)seg->limit); + PrintDebug("\n"); + print_vmcs_field(VMCS_HOST_SYSENTER_CS); + print_vmcs_field(VMCS_HOST_SYSENTER_ESP); + print_vmcs_field(VMCS_HOST_SYSENTER_EIP); + print_vmcs_field(VMCS_HOST_PERF_GLOBAL_CTRL); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_HOST_PERF_GLOBAL_CTRL_HIGH); +#endif } -void PrintTrace_VMCSGuestStateArea(struct VMCSGuestStateArea * guestState) { - PrintTrace("==>Guest State Area\n"); - PrintTrace("==>==> Guest Register State\n"); - PrintTrace("GUEST_CR0: %x\n",(uint_t) guestState->cr0); - PrintTrace("GUEST_CR3: %x\n",(uint_t)guestState->cr3); - PrintTrace("GUEST_CR4: %x\n",(uint_t)guestState->cr4); - PrintTrace("GUEST_DR7: %x\n",(uint_t)guestState->dr7); - PrintTrace("GUEST_RSP: %x\n",(uint_t)guestState->rsp); - PrintTrace("GUEST_RIP: %x\n",(uint_t)guestState->rip); - PrintTrace("GUEST_RFLAGS: %x\n",(uint_t)guestState->rflags); - - PrintTrace_VMCSSegment("Guest CS", &(guestState->cs), 0); - PrintTrace_VMCSSegment("Guest SS", &(guestState->ss), 0); - PrintTrace_VMCSSegment("Guest DS",&(guestState->ds), 0); - PrintTrace_VMCSSegment("Guest ES", &(guestState->es), 0); - PrintTrace_VMCSSegment("Guest FS", &(guestState->fs), 0); - PrintTrace_VMCSSegment("Guest GS", &(guestState->gs), 0); - PrintTrace_VMCSSegment("Guest LDTR", &(guestState->ldtr), 0); - PrintTrace_VMCSSegment("Guest TR", &(guestState->tr), 0); - PrintTrace_VMCSSegment("Guest GDTR", &(guestState->gdtr), 1); - PrintTrace_VMCSSegment("Guest IDTR", &(guestState->idtr), 1); - - - PrintTrace("GUEST_IA32_DEBUGCTL: %x\n",(uint_t)(guestState->dbg_ctrl & 0xffffffff)); - PrintTrace("GUEST_IA32_DEBUGCTL_HIGH: %x\n",(uint_t)(guestState->dbg_ctrl >> 32) & 0xffffffff); - PrintTrace("GUEST_IA32_SYSENTER_CS: %x\n",guestState->sysenter_cs); - PrintTrace("GUEST_IA32_SYSENTER_ESP: %x\n",(uint_t)guestState->sysenter_esp); - PrintTrace("GUEST_IA32_SYSENTER_EIP: %x\n",(uint_t)guestState->sysenter_eip); - PrintTrace("GUEST_SMBASE: %x\n", (uint_t)guestState->smbase); - - PrintTrace("==>==> Guest Non-Register State\n"); - PrintTrace("GUEST_ACTIVITY_STATE: %x\n", (uint_t)guestState->activity); - PrintTrace("GUEST_INT_STATE: %x\n", (uint_t)guestState->interrupt_state); - PrintTrace("GUEST_PENDING_DEBUG_EXCS: %x\n", (uint_t)guestState->pending_dbg_exceptions); - PrintTrace("VMCS_LINK_PTR: %x\n", (uint_t)guestState->vmcs_link & 0xffffffff); - PrintTrace("VMCS_LINK_PTR_HIGH: %x\n", (uint_t)(guestState->vmcs_link >> 32) & 0xffffffff); +static void print_exec_ctrls() { + PrintDebug("VMCS_EXEC_CTRL_FIELDS\n"); + print_vmcs_field(VMCS_PIN_CTRLS); + print_vmcs_field(VMCS_PROC_CTRLS); + print_vmcs_field(VMCS_SEC_PROC_CTRLS); + + print_vmcs_field(VMCS_EXCP_BITMAP); + print_vmcs_field(VMCS_PG_FAULT_ERR_MASK); + print_vmcs_field(VMCS_PG_FAULT_ERR_MATCH); + + print_vmcs_field(VMCS_IO_BITMAP_A_ADDR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_IO_BITMAP_A_ADDR_HIGH); +#endif + print_vmcs_field(VMCS_IO_BITMAP_B_ADDR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_IO_BITMAP_B_ADDR_HIGH); +#endif + + print_vmcs_field(VMCS_TSC_OFFSET); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_TSC_OFFSET_HIGH); +#endif + + PrintDebug("\n"); + + print_vmcs_field(VMCS_CR0_MASK); + print_vmcs_field(VMCS_CR0_READ_SHDW); + print_vmcs_field(VMCS_CR4_MASK); + print_vmcs_field(VMCS_CR4_READ_SHDW); + + print_vmcs_field(VMCS_CR3_TGT_CNT); + print_vmcs_field(VMCS_CR3_TGT_VAL_0); + print_vmcs_field(VMCS_CR3_TGT_VAL_1); + print_vmcs_field(VMCS_CR3_TGT_VAL_2); + print_vmcs_field(VMCS_CR3_TGT_VAL_3); + + PrintDebug("\n"); + + print_vmcs_field(VMCS_APIC_ACCESS_ADDR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_APIC_ACCESS_ADDR_HIGH); +#endif + + print_vmcs_field(VMCS_VAPIC_ADDR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_VAPIC_ADDR_HIGH); +#endif + + print_vmcs_field(VMCS_TPR_THRESHOLD); + + print_vmcs_field(VMCS_MSR_BITMAP); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_MSR_BITMAP_HIGH); +#endif + + print_vmcs_field(VMCS_EXEC_PTR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_EXEC_PTR_HIGH); +#endif } -void PrintTrace_VMCSHostStateArea(struct VMCSHostStateArea * hostState) { - PrintTrace("\n==> Host State Area\n"); - PrintTrace("HOST_CR0: %x\n", (uint_t)hostState->cr0); - PrintTrace("HOST_CR3: %x\n", (uint_t)hostState->cr3); - PrintTrace("HOST_CR4: %x\n", (uint_t)hostState->cr4); - PrintTrace("HOST_RSP: %x\n", (uint_t)hostState->rsp); - PrintTrace("HOST_RIP: %x\n", (uint_t)hostState->rip); - PrintTrace("VMCS_HOST_CS_SELECTOR: %x\n", (uint_t)hostState->csSelector); - PrintTrace("VMCS_HOST_SS_SELECTOR: %x\n", (uint_t)hostState->ssSelector); - PrintTrace("VMCS_HOST_DS_SELECTOR: %x\n", (uint_t)hostState->dsSelector); - PrintTrace("VMCS_HOST_ES_SELECTOR: %x\n", (uint_t)hostState->esSelector); - PrintTrace("VMCS_HOST_FS_SELECTOR: %x\n", (uint_t)hostState->fsSelector); - PrintTrace("VMCS_HOST_GS_SELECTOR: %x\n", (uint_t)hostState->gsSelector); - PrintTrace("VMCS_HOST_TR_SELECTOR: %x\n", (uint_t)hostState->trSelector); - PrintTrace("HOST_FS_BASE: %x\n", (uint_t)hostState->fsBaseAddr); - PrintTrace("HOST_GS_BASE: %x\n", (uint_t)hostState->gsBaseAddr); - PrintTrace("HOST_TR_BASE: %x\n", (uint_t)hostState->trBaseAddr); - PrintTrace("HOST_GDTR_BASE: %x\n", (uint_t)hostState->gdtrBaseAddr); - PrintTrace("HOST_IDTR_BASE: %x\n", (uint_t)hostState->idtrBaseAddr); - PrintTrace("HOST_IA32_SYSENTER_CS: %x\n", (uint_t)hostState->sysenter_cs); - PrintTrace("HOST_IA32_SYSENTER_ESP: %x\n", (uint_t)hostState->sysenter_esp); - PrintTrace("HOST_IA32_SYSENTER_EIP: %x\n", (uint_t)hostState->sysenter_eip); +static void print_exit_ctrls() { + PrintDebug("VMCS_EXIT_CTRLS\n"); + + print_vmcs_field(VMCS_EXIT_CTRLS); + + + print_vmcs_field(VMCS_EXIT_MSR_STORE_CNT); + print_vmcs_field(VMCS_EXIT_MSR_STORE_ADDR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_EXIT_MSR_STORE_ADDR_HIGH); +#endif + + print_vmcs_field(VMCS_EXIT_MSR_LOAD_CNT); + print_vmcs_field(VMCS_EXIT_MSR_LOAD_ADDR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_EXIT_MSR_LOAD_ADDR_HIGH); +#endif + } -void PrintTrace_VMCSExecCtrlFields(struct VMCSExecCtrlFields * execCtrls) { - PrintTrace("\n==> VM-Execution Controls:\n"); - PrintTrace("PIN_VM_EXEC_CTRLS: %x\n", (uint_t) execCtrls->pinCtrls); - PrintTrace("PROC_VM_EXEC_CTRLS: %x\n", (uint_t) execCtrls->procCtrls); - PrintTrace("EXCEPTION_BITMAP: %x\n", (uint_t) execCtrls->execBitmap); - PrintTrace("PAGE_FAULT_ERROR_MASK: %x\n", (uint_t) execCtrls->pageFaultErrorMask); - PrintTrace("PAGE_FAULT_ERROR_MATCH: %x\n", (uint_t) execCtrls->pageFaultErrorMatch); - PrintTrace("IO_BITMAP_A_ADDR: %x\n", (uint_t) execCtrls->ioBitmapA); - // PrintTrace("IO_BITMAP_A_ADDR_HIGH: %x\n", (uint_t) execCtrls->); - PrintTrace("IO_BITMAP_B_ADDR: %x\n", (uint_t) execCtrls->ioBitmapB); - // PrintTrace("IO_BITMAP_B_ADDR_HIGH: %x\n", (uint_t) execCtrls->); - PrintTrace("TSC_OFFSET: %x\n", (uint_t) execCtrls->tscOffset & 0xffffffff); - PrintTrace("TSC_OFFSET_HIGH: %x\n", (uint_t) (execCtrls->tscOffset >> 32) & 0xffffffff); - PrintTrace("CR0_GUEST_HOST_MASK: %x\n", (uint_t) execCtrls->cr0GuestHostMask); - PrintTrace("CR0_READ_SHADOW: %x\n", (uint_t) execCtrls->cr0ReadShadow); - PrintTrace("CR4_GUEST_HOST_MASK: %x\n", (uint_t) execCtrls->cr4GuestHostMask); - PrintTrace("CR4_READ_SHADOW: %x\n", (uint_t) execCtrls->cr4ReadShadow); - PrintTrace("CR3_TARGET_COUNT: %x\n", (uint_t) execCtrls->cr3TargetCount); - PrintTrace("CR3_TARGET_VALUE_0: %x\n", (uint_t) execCtrls->cr3TargetValue0); - PrintTrace("CR3_TARGET_VALUE_1: %x\n", (uint_t) execCtrls->cr3TargetValue1); - PrintTrace("CR3_TARGET_VALUE_2: %x\n", (uint_t) execCtrls->cr3TargetValue2); - PrintTrace("CR3_TARGET_VALUE_3: %x\n", (uint_t) execCtrls->cr3TargetValue3); - PrintTrace("VIRT_APIC_PAGE_ADDR: %x\n", (uint_t) execCtrls->virtApicPageAddr & 0xffffffff); - PrintTrace("VIRT_APIC_PAGE_ADDR_HIGH: %x\n", (uint_t) (execCtrls->virtApicPageAddr >> 32) & 0xffffffff); - PrintTrace("TPR_THRESHOLD: %x\n", (uint_t) execCtrls->tprThreshold); - PrintTrace("MSR_BITMAPS: %x\n", (uint_t) execCtrls->MSRBitmapsBaseAddr & 0xffffffff); - PrintTrace("MSR_BITMAPS_HIGH: %x\n", (uint_t) (execCtrls->MSRBitmapsBaseAddr >> 32) & 0xffffffff); - PrintTrace("VMCS_EXEC_PTR: %x\n", (uint_t) execCtrls->vmcsExecPtr & 0xffffffff); - PrintTrace("VMCS_EXEC_PTR_HIGH: %x\n", (uint_t) (execCtrls->vmcsExecPtr >> 32) & 0xffffffff); + +static void print_entry_ctrls() { + PrintDebug("VMCS_ENTRY_CTRLS\n"); + + print_vmcs_field(VMCS_ENTRY_CTRLS); + + print_vmcs_field(VMCS_ENTRY_MSR_LOAD_CNT); + print_vmcs_field(VMCS_ENTRY_MSR_LOAD_ADDR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_ENTRY_MSR_LOAD_ADDR_HIGH); +#endif + + print_vmcs_field(VMCS_ENTRY_INT_INFO); + print_vmcs_field(VMCS_ENTRY_EXCP_ERR); + print_vmcs_field(VMCS_ENTRY_INSTR_LEN); + + } -void PrintTrace_VMCSExitCtrlFields(struct VMCSExitCtrlFields * exitCtrls) { - PrintTrace("\n==> VM Exit Controls\n"); - PrintTrace("VM_EXIT_CTRLS: %x\n", (uint_t) exitCtrls->exitCtrls); - PrintTrace("VM_EXIT_MSR_STORE_COUNT: %x\n", (uint_t) exitCtrls->msrStoreCount); - PrintTrace("VM_EXIT_MSR_STORE_ADDR: %x\n", (uint_t) exitCtrls->msrStoreAddr & 0xffffffff); - PrintTrace("VM_EXIT_MSR_STORE_ADDR_HIGH: %x\n", (uint_t) (exitCtrls->msrStoreAddr >> 32) & 0xffffffff); - PrintTrace("VM_EXIT_MSR_LOAD_COUNT: %x\n", (uint_t) exitCtrls->msrLoadCount); - PrintTrace("VM_EXIT_MSR_LOAD_ADDR: %x\n", (uint_t) exitCtrls->msrLoadAddr & 0xffffffff); - PrintTrace("VM_EXIT_MSR_LOAD_ADDR_HIGH: %x\n", (uint_t) (exitCtrls->msrLoadAddr >> 32) & 0xffffffff); + +static void print_exit_info() { + PrintDebug("VMCS_EXIT_INFO\n"); + + print_vmcs_field(VMCS_EXIT_REASON); + print_vmcs_field(VMCS_EXIT_QUAL); + + print_vmcs_field(VMCS_EXIT_INT_INFO); + print_vmcs_field(VMCS_EXIT_INT_ERR); + + print_vmcs_field(VMCS_IDT_VECTOR_INFO); + print_vmcs_field(VMCS_IDT_VECTOR_ERR); + + print_vmcs_field(VMCS_EXIT_INSTR_LEN); + + print_vmcs_field(VMCS_GUEST_LINEAR_ADDR); + print_vmcs_field(VMCS_EXIT_INSTR_INFO); + + print_vmcs_field(VMCS_IO_RCX); + print_vmcs_field(VMCS_IO_RSI); + print_vmcs_field(VMCS_IO_RDI); + print_vmcs_field(VMCS_IO_RIP); + + + print_vmcs_field(VMCS_INSTR_ERR); } -void PrintTrace_VMCSEntryCtrlFields(struct VMCSEntryCtrlFields * entryCtrls) { - PrintTrace("\n==> VM Entry Controls\n"); - PrintTrace("VM_ENTRY_CTRLS: %x\n", (uint_t) entryCtrls->entryCtrls); - PrintTrace("VM_ENTRY_MSR_LOAD_COUNT: %x\n", (uint_t) entryCtrls->msrLoadCount); - PrintTrace("VM_ENTRY_MSR_LOAD_ADDR: %x\n", (uint_t) entryCtrls->msrLoadAddr & 0xffffffff); - PrintTrace("VM_ENTRY_MSR_LOAD_ADDR_HIGH: %x\n", (uint_t) (entryCtrls->msrLoadAddr >> 32) & 0xffffffff); - PrintTrace("VM_ENTRY_INT_INFO_FIELD: %x\n", (uint_t) entryCtrls->intInfo); - PrintTrace("VM_ENTRY_EXCEPTION_ERROR: %x\n", (uint_t) entryCtrls->exceptionErrorCode); - PrintTrace("VM_ENTRY_INSTR_LENGTH: %x\n", (uint_t) entryCtrls->instrLength); +void v3_print_vmcs() { + + print_vmcs_field(VMCS_LINK_PTR); +#ifdef __V3_32BIT__ + print_vmcs_field(VMCS_LINK_PTR_HIGH); +#endif + + print_guest_state(); + print_host_state(); + + print_exec_ctrls(); + print_exit_ctrls(); + print_entry_ctrls(); + print_exit_info(); + + + + } -void PrintTrace_VMCSExitInfoFields(struct VMCSExitInfoFields * exitInfo) { - PrintTrace("\n==> VM Exit Info\n"); - PrintTrace("EXIT_REASON: %x\n", (uint_t) exitInfo->reason); - PrintTrace("EXIT_QUALIFICATION: %x\n", (uint_t) exitInfo->qualification); - PrintTrace("VM_EXIT_INT_INFO: %x\n", (uint_t) exitInfo->intInfo); - PrintTrace("VM_EXIT_INT_ERROR: %x\n", (uint_t) exitInfo->intErrorCode); - PrintTrace("IDT_VECTOR_INFO: %x\n", (uint_t) exitInfo->idtVectorInfo); - PrintTrace("IDT_VECTOR_ERROR: %x\n", (uint_t) exitInfo->idtVectorErrorCode); - PrintTrace("VM_EXIT_INSTR_LENGTH: %x\n", (uint_t) exitInfo->instrLength); - PrintTrace("GUEST_LINEAR_ADDR: %x\n", (uint_t) exitInfo->guestLinearAddr); - PrintTrace("VMX_INSTR_INFO: %x\n", (uint_t) exitInfo->instrInfo); - PrintTrace("IO_RCX: %x\n", (uint_t) exitInfo->ioRCX); - PrintTrace("IO_RSI: %x\n", (uint_t) exitInfo->ioRSI); - PrintTrace("IO_RDI: %x\n", (uint_t) exitInfo->ioRDI); - PrintTrace("IO_RIP: %x\n", (uint_t) exitInfo->ioRIP); - PrintTrace("VM_INSTR_ERROR: %x\n", (uint_t) exitInfo->instrErrorField); + +/* + * Returns the field length in bytes + */ +int v3_vmcs_get_field_len(vmcs_field_t field) { + switch(field) { + /* 16 bit Control Fields */ + case VMCS_GUEST_ES_SELECTOR: + case VMCS_GUEST_CS_SELECTOR: + case VMCS_GUEST_SS_SELECTOR: + case VMCS_GUEST_DS_SELECTOR: + case VMCS_GUEST_FS_SELECTOR: + case VMCS_GUEST_GS_SELECTOR: + case VMCS_GUEST_LDTR_SELECTOR: + case VMCS_GUEST_TR_SELECTOR: + case VMCS_HOST_ES_SELECTOR: + case VMCS_HOST_CS_SELECTOR: + case VMCS_HOST_SS_SELECTOR: + case VMCS_HOST_DS_SELECTOR: + case VMCS_HOST_FS_SELECTOR: + case VMCS_HOST_GS_SELECTOR: + case VMCS_HOST_TR_SELECTOR: + return 2; + + /* 32 bit Control Fields */ + case VMCS_PIN_CTRLS: + case VMCS_PROC_CTRLS: + case VMCS_SEC_PROC_CTRLS: + case VMCS_EXCP_BITMAP: + case VMCS_PG_FAULT_ERR_MASK: + case VMCS_PG_FAULT_ERR_MATCH: + case VMCS_CR3_TGT_CNT: + case VMCS_EXIT_CTRLS: + case VMCS_EXIT_MSR_STORE_CNT: + case VMCS_EXIT_MSR_LOAD_CNT: + case VMCS_ENTRY_CTRLS: + case VMCS_ENTRY_MSR_LOAD_CNT: + case VMCS_ENTRY_INT_INFO: + case VMCS_ENTRY_EXCP_ERR: + case VMCS_ENTRY_INSTR_LEN: + case VMCS_TPR_THRESHOLD: + case VMCS_INSTR_ERR: + case VMCS_EXIT_REASON: + case VMCS_EXIT_INT_INFO: + case VMCS_EXIT_INT_ERR: + case VMCS_IDT_VECTOR_INFO: + case VMCS_IDT_VECTOR_ERR: + case VMCS_EXIT_INSTR_LEN: + case VMCS_EXIT_INSTR_INFO: + case VMCS_GUEST_ES_LIMIT: + case VMCS_GUEST_CS_LIMIT: + case VMCS_GUEST_SS_LIMIT: + case VMCS_GUEST_DS_LIMIT: + case VMCS_GUEST_FS_LIMIT: + case VMCS_GUEST_GS_LIMIT: + case VMCS_GUEST_LDTR_LIMIT: + case VMCS_GUEST_TR_LIMIT: + case VMCS_GUEST_GDTR_LIMIT: + case VMCS_GUEST_IDTR_LIMIT: + case VMCS_GUEST_ES_ACCESS: + case VMCS_GUEST_CS_ACCESS: + case VMCS_GUEST_SS_ACCESS: + case VMCS_GUEST_DS_ACCESS: + case VMCS_GUEST_FS_ACCESS: + case VMCS_GUEST_GS_ACCESS: + case VMCS_GUEST_LDTR_ACCESS: + case VMCS_GUEST_TR_ACCESS: + case VMCS_GUEST_INT_STATE: + case VMCS_GUEST_ACTIVITY_STATE: + case VMCS_GUEST_SMBASE: + case VMCS_GUEST_SYSENTER_CS: + case VMCS_HOST_SYSENTER_CS: + return 4; + + + /* high bits of variable width fields + * We can probably just delete most of these.... + */ + case VMCS_IO_BITMAP_A_ADDR_HIGH: + case VMCS_IO_BITMAP_B_ADDR_HIGH: + case VMCS_MSR_BITMAP_HIGH: + case VMCS_EXIT_MSR_STORE_ADDR_HIGH: + case VMCS_EXIT_MSR_LOAD_ADDR_HIGH: + case VMCS_ENTRY_MSR_LOAD_ADDR_HIGH: + case VMCS_EXEC_PTR_HIGH: + case VMCS_TSC_OFFSET_HIGH: + case VMCS_VAPIC_ADDR_HIGH: + case VMCS_APIC_ACCESS_ADDR_HIGH: + case VMCS_LINK_PTR_HIGH: + case VMCS_GUEST_DBG_CTL_HIGH: + case VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH: + case VMCS_HOST_PERF_GLOBAL_CTRL_HIGH: + return 4; + + /* Natural Width Control Fields */ + case VMCS_IO_BITMAP_A_ADDR: + case VMCS_IO_BITMAP_B_ADDR: + case VMCS_MSR_BITMAP: + case VMCS_EXIT_MSR_STORE_ADDR: + case VMCS_EXIT_MSR_LOAD_ADDR: + case VMCS_ENTRY_MSR_LOAD_ADDR: + case VMCS_EXEC_PTR: + case VMCS_TSC_OFFSET: + case VMCS_VAPIC_ADDR: + case VMCS_APIC_ACCESS_ADDR: + case VMCS_LINK_PTR: + case VMCS_GUEST_DBG_CTL: + case VMCS_GUEST_PERF_GLOBAL_CTRL: + case VMCS_HOST_PERF_GLOBAL_CTRL: + case VMCS_CR0_MASK: + case VMCS_CR4_MASK: + case VMCS_CR0_READ_SHDW: + case VMCS_CR4_READ_SHDW: + case VMCS_CR3_TGT_VAL_0: + case VMCS_CR3_TGT_VAL_1: + case VMCS_CR3_TGT_VAL_2: + case VMCS_CR3_TGT_VAL_3: + case VMCS_EXIT_QUAL: + case VMCS_IO_RCX: + case VMCS_IO_RSI: + case VMCS_IO_RDI: + case VMCS_IO_RIP: + case VMCS_GUEST_LINEAR_ADDR: + case VMCS_GUEST_CR0: + case VMCS_GUEST_CR3: + case VMCS_GUEST_CR4: + case VMCS_GUEST_ES_BASE: + case VMCS_GUEST_CS_BASE: + case VMCS_GUEST_SS_BASE: + case VMCS_GUEST_DS_BASE: + case VMCS_GUEST_FS_BASE: + case VMCS_GUEST_GS_BASE: + case VMCS_GUEST_LDTR_BASE: + case VMCS_GUEST_TR_BASE: + case VMCS_GUEST_GDTR_BASE: + case VMCS_GUEST_IDTR_BASE: + case VMCS_GUEST_DR7: + case VMCS_GUEST_RSP: + case VMCS_GUEST_RIP: + case VMCS_GUEST_RFLAGS: + case VMCS_GUEST_PENDING_DBG_EXCP: + case VMCS_GUEST_SYSENTER_ESP: + case VMCS_GUEST_SYSENTER_EIP: + case VMCS_HOST_CR0: + case VMCS_HOST_CR3: + case VMCS_HOST_CR4: + case VMCS_HOST_FS_BASE: + case VMCS_HOST_GS_BASE: + case VMCS_HOST_TR_BASE: + case VMCS_HOST_GDTR_BASE: + case VMCS_HOST_IDTR_BASE: + case VMCS_HOST_SYSENTER_ESP: + case VMCS_HOST_SYSENTER_EIP: + case VMCS_HOST_RSP: + case VMCS_HOST_RIP: + return sizeof(addr_t); + + default: + PrintError("Invalid VMCS field\n"); + return -1; + } } -void PrintTrace_VMCSData(struct VMCSData * vmcs) { - PrintTrace("VMCSData Structure\n"); - PrintTrace_VMCSGuestStateArea(&(vmcs->guestStateArea)); - PrintTrace_VMCSHostStateArea(&(vmcs->hostStateArea)); - PrintTrace_VMCSExecCtrlFields(&(vmcs->execCtrlFields)); - PrintTrace_VMCSExitCtrlFields(&(vmcs->exitCtrlFields)); - PrintTrace_VMCSEntryCtrlFields(&(vmcs->entryCtrlFields)); - PrintTrace_VMCSExitInfoFields(&(vmcs->exitInfoFields)); - PrintTrace("\n"); + + + + + + + + + +static const char VMCS_GUEST_ES_SELECTOR_STR[] = "GUEST_ES_SELECTOR"; +static const char VMCS_GUEST_CS_SELECTOR_STR[] = "GUEST_CS_SELECTOR"; +static const char VMCS_GUEST_SS_SELECTOR_STR[] = "GUEST_SS_SELECTOR"; +static const char VMCS_GUEST_DS_SELECTOR_STR[] = "GUEST_DS_SELECTOR"; +static const char VMCS_GUEST_FS_SELECTOR_STR[] = "GUEST_FS_SELECTOR"; +static const char VMCS_GUEST_GS_SELECTOR_STR[] = "GUEST_GS_SELECTOR"; +static const char VMCS_GUEST_LDTR_SELECTOR_STR[] = "GUEST_LDTR_SELECTOR"; +static const char VMCS_GUEST_TR_SELECTOR_STR[] = "GUEST_TR_SELECTOR"; +static const char VMCS_HOST_ES_SELECTOR_STR[] = "HOST_ES_SELECTOR"; +static const char VMCS_HOST_CS_SELECTOR_STR[] = "HOST_CS_SELECTOR"; +static const char VMCS_HOST_SS_SELECTOR_STR[] = "HOST_SS_SELECTOR"; +static const char VMCS_HOST_DS_SELECTOR_STR[] = "HOST_DS_SELECTOR"; +static const char VMCS_HOST_FS_SELECTOR_STR[] = "HOST_FS_SELECTOR"; +static const char VMCS_HOST_GS_SELECTOR_STR[] = "HOST_GS_SELECTOR"; +static const char VMCS_HOST_TR_SELECTOR_STR[] = "HOST_TR_SELECTOR"; +static const char VMCS_IO_BITMAP_A_ADDR_STR[] = "IO_BITMAP_A_ADDR"; +static const char VMCS_IO_BITMAP_A_ADDR_HIGH_STR[] = "IO_BITMAP_A_ADDR_HIGH"; +static const char VMCS_IO_BITMAP_B_ADDR_STR[] = "IO_BITMAP_B_ADDR"; +static const char VMCS_IO_BITMAP_B_ADDR_HIGH_STR[] = "IO_BITMAP_B_ADDR_HIGH"; +static const char VMCS_MSR_BITMAP_STR[] = "MSR_BITMAPS"; +static const char VMCS_MSR_BITMAP_HIGH_STR[] = "MSR_BITMAPS_HIGH"; +static const char VMCS_EXIT_MSR_STORE_ADDR_STR[] = "EXIT_MSR_STORE_ADDR"; +static const char VMCS_EXIT_MSR_STORE_ADDR_HIGH_STR[] = "EXIT_MSR_STORE_ADDR_HIGH"; +static const char VMCS_EXIT_MSR_LOAD_ADDR_STR[] = "EXIT_MSR_LOAD_ADDR"; +static const char VMCS_EXIT_MSR_LOAD_ADDR_HIGH_STR[] = "EXIT_MSR_LOAD_ADDR_HIGH"; +static const char VMCS_ENTRY_MSR_LOAD_ADDR_STR[] = "ENTRY_MSR_LOAD_ADDR"; +static const char VMCS_ENTRY_MSR_LOAD_ADDR_HIGH_STR[] = "ENTRY_MSR_LOAD_ADDR_HIGH"; +static const char VMCS_EXEC_PTR_STR[] = "VMCS_EXEC_PTR"; +static const char VMCS_EXEC_PTR_HIGH_STR[] = "VMCS_EXEC_PTR_HIGH"; +static const char VMCS_TSC_OFFSET_STR[] = "TSC_OFFSET"; +static const char VMCS_TSC_OFFSET_HIGH_STR[] = "TSC_OFFSET_HIGH"; +static const char VMCS_VAPIC_ADDR_STR[] = "VAPIC_PAGE_ADDR"; +static const char VMCS_VAPIC_ADDR_HIGH_STR[] = "VAPIC_PAGE_ADDR_HIGH"; +static const char VMCS_APIC_ACCESS_ADDR_STR[] = "APIC_ACCESS_ADDR"; +static const char VMCS_APIC_ACCESS_ADDR_HIGH_STR[] = "APIC_ACCESS_ADDR_HIGH"; +static const char VMCS_LINK_PTR_STR[] = "VMCS_LINK_PTR"; +static const char VMCS_LINK_PTR_HIGH_STR[] = "VMCS_LINK_PTR_HIGH"; +static const char VMCS_GUEST_DBG_CTL_STR[] = "GUEST_DEBUG_CTL"; +static const char VMCS_GUEST_DBG_CTL_HIGH_STR[] = "GUEST_DEBUG_CTL_HIGH"; +static const char VMCS_GUEST_PERF_GLOBAL_CTRL_STR[] = "GUEST_PERF_GLOBAL_CTRL"; +static const char VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH_STR[] = "GUEST_PERF_GLOBAL_CTRL_HIGH"; +static const char VMCS_HOST_PERF_GLOBAL_CTRL_STR[] = "HOST_PERF_GLOBAL_CTRL"; +static const char VMCS_HOST_PERF_GLOBAL_CTRL_HIGH_STR[] = "HOST_PERF_GLOBAL_CTRL_HIGH"; +static const char VMCS_PIN_CTRLS_STR[] = "PIN_VM_EXEC_CTRLS"; +static const char VMCS_PROC_CTRLS_STR[] = "PROC_VM_EXEC_CTRLS"; +static const char VMCS_EXCP_BITMAP_STR[] = "EXCEPTION_BITMAP"; +static const char VMCS_PG_FAULT_ERR_MASK_STR[] = "PAGE_FAULT_ERROR_MASK"; +static const char VMCS_PG_FAULT_ERR_MATCH_STR[] = "PAGE_FAULT_ERROR_MATCH"; +static const char VMCS_CR3_TGT_CNT_STR[] = "CR3_TARGET_COUNT"; +static const char VMCS_EXIT_CTRLS_STR[] = "VM_EXIT_CTRLS"; +static const char VMCS_EXIT_MSR_STORE_CNT_STR[] = "VM_EXIT_MSR_STORE_COUNT"; +static const char VMCS_EXIT_MSR_LOAD_CNT_STR[] = "VM_EXIT_MSR_LOAD_COUNT"; +static const char VMCS_ENTRY_CTRLS_STR[] = "VM_ENTRY_CTRLS"; +static const char VMCS_ENTRY_MSR_LOAD_CNT_STR[] = "VM_ENTRY_MSR_LOAD_COUNT"; +static const char VMCS_ENTRY_INT_INFO_STR[] = "VM_ENTRY_INT_INFO_FIELD"; +static const char VMCS_ENTRY_EXCP_ERR_STR[] = "VM_ENTRY_EXCEPTION_ERROR"; +static const char VMCS_ENTRY_INSTR_LEN_STR[] = "VM_ENTRY_INSTR_LENGTH"; +static const char VMCS_TPR_THRESHOLD_STR[] = "TPR_THRESHOLD"; +static const char VMCS_SEC_PROC_CTRLS_STR[] = "VMCS_SEC_PROC_CTRLS"; +static const char VMCS_INSTR_ERR_STR[] = "VM_INSTR_ERROR"; +static const char VMCS_EXIT_REASON_STR[] = "EXIT_REASON"; +static const char VMCS_EXIT_INT_INFO_STR[] = "VM_EXIT_INT_INFO"; +static const char VMCS_EXIT_INT_ERR_STR[] = "VM_EXIT_INT_ERROR"; +static const char VMCS_IDT_VECTOR_INFO_STR[] = "IDT_VECTOR_INFO"; +static const char VMCS_IDT_VECTOR_ERR_STR[] = "IDT_VECTOR_ERROR"; +static const char VMCS_EXIT_INSTR_LEN_STR[] = "VM_EXIT_INSTR_LENGTH"; +static const char VMCS_EXIT_INSTR_INFO_STR[] = "VMX_INSTR_INFO"; +static const char VMCS_GUEST_ES_LIMIT_STR[] = "GUEST_ES_LIMIT"; +static const char VMCS_GUEST_CS_LIMIT_STR[] = "GUEST_CS_LIMIT"; +static const char VMCS_GUEST_SS_LIMIT_STR[] = "GUEST_SS_LIMIT"; +static const char VMCS_GUEST_DS_LIMIT_STR[] = "GUEST_DS_LIMIT"; +static const char VMCS_GUEST_FS_LIMIT_STR[] = "GUEST_FS_LIMIT"; +static const char VMCS_GUEST_GS_LIMIT_STR[] = "GUEST_GS_LIMIT"; +static const char VMCS_GUEST_LDTR_LIMIT_STR[] = "GUEST_LDTR_LIMIT"; +static const char VMCS_GUEST_TR_LIMIT_STR[] = "GUEST_TR_LIMIT"; +static const char VMCS_GUEST_GDTR_LIMIT_STR[] = "GUEST_GDTR_LIMIT"; +static const char VMCS_GUEST_IDTR_LIMIT_STR[] = "GUEST_IDTR_LIMIT"; +static const char VMCS_GUEST_ES_ACCESS_STR[] = "GUEST_ES_ACCESS"; +static const char VMCS_GUEST_CS_ACCESS_STR[] = "GUEST_CS_ACCESS"; +static const char VMCS_GUEST_SS_ACCESS_STR[] = "GUEST_SS_ACCESS"; +static const char VMCS_GUEST_DS_ACCESS_STR[] = "GUEST_DS_ACCESS"; +static const char VMCS_GUEST_FS_ACCESS_STR[] = "GUEST_FS_ACCESS"; +static const char VMCS_GUEST_GS_ACCESS_STR[] = "GUEST_GS_ACCESS"; +static const char VMCS_GUEST_LDTR_ACCESS_STR[] = "GUEST_LDTR_ACCESS"; +static const char VMCS_GUEST_TR_ACCESS_STR[] = "GUEST_TR_ACCESS"; +static const char VMCS_GUEST_INT_STATE_STR[] = "GUEST_INT_STATE"; +static const char VMCS_GUEST_ACTIVITY_STATE_STR[] = "GUEST_ACTIVITY_STATE"; +static const char VMCS_GUEST_SMBASE_STR[] = "GUEST_SMBASE"; +static const char VMCS_GUEST_SYSENTER_CS_STR[] = "GUEST_SYSENTER_CS"; +static const char VMCS_HOST_SYSENTER_CS_STR[] = "HOST_SYSENTER_CS"; +static const char VMCS_CR0_MASK_STR[] = "CR0_GUEST_HOST_MASK"; +static const char VMCS_CR4_MASK_STR[] = "CR4_GUEST_HOST_MASK"; +static const char VMCS_CR0_READ_SHDW_STR[] = "CR0_READ_SHADOW"; +static const char VMCS_CR4_READ_SHDW_STR[] = "CR4_READ_SHADOW"; +static const char VMCS_CR3_TGT_VAL_0_STR[] = "CR3_TARGET_VALUE_0"; +static const char VMCS_CR3_TGT_VAL_1_STR[] = "CR3_TARGET_VALUE_1"; +static const char VMCS_CR3_TGT_VAL_2_STR[] = "CR3_TARGET_VALUE_2"; +static const char VMCS_CR3_TGT_VAL_3_STR[] = "CR3_TARGET_VALUE_3"; +static const char VMCS_EXIT_QUAL_STR[] = "EXIT_QUALIFICATION"; +static const char VMCS_IO_RCX_STR[] = "IO_RCX"; +static const char VMCS_IO_RSI_STR[] = "IO_RSI"; +static const char VMCS_IO_RDI_STR[] = "IO_RDI"; +static const char VMCS_IO_RIP_STR[] = "IO_RIP"; +static const char VMCS_GUEST_LINEAR_ADDR_STR[] = "GUEST_LINEAR_ADDR"; +static const char VMCS_GUEST_CR0_STR[] = "GUEST_CR0"; +static const char VMCS_GUEST_CR3_STR[] = "GUEST_CR3"; +static const char VMCS_GUEST_CR4_STR[] = "GUEST_CR4"; +static const char VMCS_GUEST_ES_BASE_STR[] = "GUEST_ES_BASE"; +static const char VMCS_GUEST_CS_BASE_STR[] = "GUEST_CS_BASE"; +static const char VMCS_GUEST_SS_BASE_STR[] = "GUEST_SS_BASE"; +static const char VMCS_GUEST_DS_BASE_STR[] = "GUEST_DS_BASE"; +static const char VMCS_GUEST_FS_BASE_STR[] = "GUEST_FS_BASE"; +static const char VMCS_GUEST_GS_BASE_STR[] = "GUEST_GS_BASE"; +static const char VMCS_GUEST_LDTR_BASE_STR[] = "GUEST_LDTR_BASE"; +static const char VMCS_GUEST_TR_BASE_STR[] = "GUEST_TR_BASE"; +static const char VMCS_GUEST_GDTR_BASE_STR[] = "GUEST_GDTR_BASE"; +static const char VMCS_GUEST_IDTR_BASE_STR[] = "GUEST_IDTR_BASE"; +static const char VMCS_GUEST_DR7_STR[] = "GUEST_DR7"; +static const char VMCS_GUEST_RSP_STR[] = "GUEST_RSP"; +static const char VMCS_GUEST_RIP_STR[] = "GUEST_RIP"; +static const char VMCS_GUEST_RFLAGS_STR[] = "GUEST_RFLAGS"; +static const char VMCS_GUEST_PENDING_DBG_EXCP_STR[] = "GUEST_PENDING_DEBUG_EXCS"; +static const char VMCS_GUEST_SYSENTER_ESP_STR[] = "GUEST_SYSENTER_ESP"; +static const char VMCS_GUEST_SYSENTER_EIP_STR[] = "GUEST_SYSENTER_EIP"; +static const char VMCS_HOST_CR0_STR[] = "HOST_CR0"; +static const char VMCS_HOST_CR3_STR[] = "HOST_CR3"; +static const char VMCS_HOST_CR4_STR[] = "HOST_CR4"; +static const char VMCS_HOST_FS_BASE_STR[] = "HOST_FS_BASE"; +static const char VMCS_HOST_GS_BASE_STR[] = "HOST_GS_BASE"; +static const char VMCS_HOST_TR_BASE_STR[] = "HOST_TR_BASE"; +static const char VMCS_HOST_GDTR_BASE_STR[] = "HOST_GDTR_BASE"; +static const char VMCS_HOST_IDTR_BASE_STR[] = "HOST_IDTR_BASE"; +static const char VMCS_HOST_SYSENTER_ESP_STR[] = "HOST_SYSENTER_ESP"; +static const char VMCS_HOST_SYSENTER_EIP_STR[] = "HOST_SYSENTER_EIP"; +static const char VMCS_HOST_RSP_STR[] = "HOST_RSP"; +static const char VMCS_HOST_RIP_STR[] = "HOST_RIP"; + + + +const char * v3_vmcs_field_to_str(vmcs_field_t field) { + switch (field) { + case VMCS_GUEST_ES_SELECTOR: + return VMCS_GUEST_ES_SELECTOR_STR; + case VMCS_GUEST_CS_SELECTOR: + return VMCS_GUEST_CS_SELECTOR_STR; + case VMCS_GUEST_SS_SELECTOR: + return VMCS_GUEST_SS_SELECTOR_STR; + case VMCS_GUEST_DS_SELECTOR: + return VMCS_GUEST_DS_SELECTOR_STR; + case VMCS_GUEST_FS_SELECTOR: + return VMCS_GUEST_FS_SELECTOR_STR; + case VMCS_GUEST_GS_SELECTOR: + return VMCS_GUEST_GS_SELECTOR_STR; + case VMCS_GUEST_LDTR_SELECTOR: + return VMCS_GUEST_LDTR_SELECTOR_STR; + case VMCS_GUEST_TR_SELECTOR: + return VMCS_GUEST_TR_SELECTOR_STR; + case VMCS_HOST_ES_SELECTOR: + return VMCS_HOST_ES_SELECTOR_STR; + case VMCS_HOST_CS_SELECTOR: + return VMCS_HOST_CS_SELECTOR_STR; + case VMCS_HOST_SS_SELECTOR: + return VMCS_HOST_SS_SELECTOR_STR; + case VMCS_HOST_DS_SELECTOR: + return VMCS_HOST_DS_SELECTOR_STR; + case VMCS_HOST_FS_SELECTOR: + return VMCS_HOST_FS_SELECTOR_STR; + case VMCS_HOST_GS_SELECTOR: + return VMCS_HOST_GS_SELECTOR_STR; + case VMCS_HOST_TR_SELECTOR: + return VMCS_HOST_TR_SELECTOR_STR; + case VMCS_IO_BITMAP_A_ADDR: + return VMCS_IO_BITMAP_A_ADDR_STR; + case VMCS_IO_BITMAP_A_ADDR_HIGH: + return VMCS_IO_BITMAP_A_ADDR_HIGH_STR; + case VMCS_IO_BITMAP_B_ADDR: + return VMCS_IO_BITMAP_B_ADDR_STR; + case VMCS_IO_BITMAP_B_ADDR_HIGH: + return VMCS_IO_BITMAP_B_ADDR_HIGH_STR; + case VMCS_MSR_BITMAP: + return VMCS_MSR_BITMAP_STR; + case VMCS_MSR_BITMAP_HIGH: + return VMCS_MSR_BITMAP_HIGH_STR; + case VMCS_EXIT_MSR_STORE_ADDR: + return VMCS_EXIT_MSR_STORE_ADDR_STR; + case VMCS_EXIT_MSR_STORE_ADDR_HIGH: + return VMCS_EXIT_MSR_STORE_ADDR_HIGH_STR; + case VMCS_EXIT_MSR_LOAD_ADDR: + return VMCS_EXIT_MSR_LOAD_ADDR_STR; + case VMCS_EXIT_MSR_LOAD_ADDR_HIGH: + return VMCS_EXIT_MSR_LOAD_ADDR_HIGH_STR; + case VMCS_ENTRY_MSR_LOAD_ADDR: + return VMCS_ENTRY_MSR_LOAD_ADDR_STR; + case VMCS_ENTRY_MSR_LOAD_ADDR_HIGH: + return VMCS_ENTRY_MSR_LOAD_ADDR_HIGH_STR; + case VMCS_EXEC_PTR: + return VMCS_EXEC_PTR_STR; + case VMCS_EXEC_PTR_HIGH: + return VMCS_EXEC_PTR_HIGH_STR; + case VMCS_TSC_OFFSET: + return VMCS_TSC_OFFSET_STR; + case VMCS_TSC_OFFSET_HIGH: + return VMCS_TSC_OFFSET_HIGH_STR; + case VMCS_VAPIC_ADDR: + return VMCS_VAPIC_ADDR_STR; + case VMCS_VAPIC_ADDR_HIGH: + return VMCS_VAPIC_ADDR_HIGH_STR; + case VMCS_APIC_ACCESS_ADDR: + return VMCS_APIC_ACCESS_ADDR_STR; + case VMCS_APIC_ACCESS_ADDR_HIGH: + return VMCS_APIC_ACCESS_ADDR_HIGH_STR; + case VMCS_LINK_PTR: + return VMCS_LINK_PTR_STR; + case VMCS_LINK_PTR_HIGH: + return VMCS_LINK_PTR_HIGH_STR; + case VMCS_GUEST_DBG_CTL: + return VMCS_GUEST_DBG_CTL_STR; + case VMCS_GUEST_DBG_CTL_HIGH: + return VMCS_GUEST_DBG_CTL_HIGH_STR; + case VMCS_GUEST_PERF_GLOBAL_CTRL: + return VMCS_GUEST_PERF_GLOBAL_CTRL_STR; + case VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH: + return VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH_STR; + case VMCS_HOST_PERF_GLOBAL_CTRL: + return VMCS_HOST_PERF_GLOBAL_CTRL_STR; + case VMCS_HOST_PERF_GLOBAL_CTRL_HIGH: + return VMCS_HOST_PERF_GLOBAL_CTRL_HIGH_STR; + case VMCS_PIN_CTRLS: + return VMCS_PIN_CTRLS_STR; + case VMCS_PROC_CTRLS: + return VMCS_PROC_CTRLS_STR; + case VMCS_EXCP_BITMAP: + return VMCS_EXCP_BITMAP_STR; + case VMCS_PG_FAULT_ERR_MASK: + return VMCS_PG_FAULT_ERR_MASK_STR; + case VMCS_PG_FAULT_ERR_MATCH: + return VMCS_PG_FAULT_ERR_MATCH_STR; + case VMCS_CR3_TGT_CNT: + return VMCS_CR3_TGT_CNT_STR; + case VMCS_EXIT_CTRLS: + return VMCS_EXIT_CTRLS_STR; + case VMCS_EXIT_MSR_STORE_CNT: + return VMCS_EXIT_MSR_STORE_CNT_STR; + case VMCS_EXIT_MSR_LOAD_CNT: + return VMCS_EXIT_MSR_LOAD_CNT_STR; + case VMCS_ENTRY_CTRLS: + return VMCS_ENTRY_CTRLS_STR; + case VMCS_ENTRY_MSR_LOAD_CNT: + return VMCS_ENTRY_MSR_LOAD_CNT_STR; + case VMCS_ENTRY_INT_INFO: + return VMCS_ENTRY_INT_INFO_STR; + case VMCS_ENTRY_EXCP_ERR: + return VMCS_ENTRY_EXCP_ERR_STR; + case VMCS_ENTRY_INSTR_LEN: + return VMCS_ENTRY_INSTR_LEN_STR; + case VMCS_TPR_THRESHOLD: + return VMCS_TPR_THRESHOLD_STR; + case VMCS_SEC_PROC_CTRLS: + return VMCS_SEC_PROC_CTRLS_STR; + case VMCS_INSTR_ERR: + return VMCS_INSTR_ERR_STR; + case VMCS_EXIT_REASON: + return VMCS_EXIT_REASON_STR; + case VMCS_EXIT_INT_INFO: + return VMCS_EXIT_INT_INFO_STR; + case VMCS_EXIT_INT_ERR: + return VMCS_EXIT_INT_ERR_STR; + case VMCS_IDT_VECTOR_INFO: + return VMCS_IDT_VECTOR_INFO_STR; + case VMCS_IDT_VECTOR_ERR: + return VMCS_IDT_VECTOR_ERR_STR; + case VMCS_EXIT_INSTR_LEN: + return VMCS_EXIT_INSTR_LEN_STR; + case VMCS_EXIT_INSTR_INFO: + return VMCS_EXIT_INSTR_INFO_STR; + case VMCS_GUEST_ES_LIMIT: + return VMCS_GUEST_ES_LIMIT_STR; + case VMCS_GUEST_CS_LIMIT: + return VMCS_GUEST_CS_LIMIT_STR; + case VMCS_GUEST_SS_LIMIT: + return VMCS_GUEST_SS_LIMIT_STR; + case VMCS_GUEST_DS_LIMIT: + return VMCS_GUEST_DS_LIMIT_STR; + case VMCS_GUEST_FS_LIMIT: + return VMCS_GUEST_FS_LIMIT_STR; + case VMCS_GUEST_GS_LIMIT: + return VMCS_GUEST_GS_LIMIT_STR; + case VMCS_GUEST_LDTR_LIMIT: + return VMCS_GUEST_LDTR_LIMIT_STR; + case VMCS_GUEST_TR_LIMIT: + return VMCS_GUEST_TR_LIMIT_STR; + case VMCS_GUEST_GDTR_LIMIT: + return VMCS_GUEST_GDTR_LIMIT_STR; + case VMCS_GUEST_IDTR_LIMIT: + return VMCS_GUEST_IDTR_LIMIT_STR; + case VMCS_GUEST_ES_ACCESS: + return VMCS_GUEST_ES_ACCESS_STR; + case VMCS_GUEST_CS_ACCESS: + return VMCS_GUEST_CS_ACCESS_STR; + case VMCS_GUEST_SS_ACCESS: + return VMCS_GUEST_SS_ACCESS_STR; + case VMCS_GUEST_DS_ACCESS: + return VMCS_GUEST_DS_ACCESS_STR; + case VMCS_GUEST_FS_ACCESS: + return VMCS_GUEST_FS_ACCESS_STR; + case VMCS_GUEST_GS_ACCESS: + return VMCS_GUEST_GS_ACCESS_STR; + case VMCS_GUEST_LDTR_ACCESS: + return VMCS_GUEST_LDTR_ACCESS_STR; + case VMCS_GUEST_TR_ACCESS: + return VMCS_GUEST_TR_ACCESS_STR; + case VMCS_GUEST_INT_STATE: + return VMCS_GUEST_INT_STATE_STR; + case VMCS_GUEST_ACTIVITY_STATE: + return VMCS_GUEST_ACTIVITY_STATE_STR; + case VMCS_GUEST_SMBASE: + return VMCS_GUEST_SMBASE_STR; + case VMCS_GUEST_SYSENTER_CS: + return VMCS_GUEST_SYSENTER_CS_STR; + case VMCS_HOST_SYSENTER_CS: + return VMCS_HOST_SYSENTER_CS_STR; + case VMCS_CR0_MASK: + return VMCS_CR0_MASK_STR; + case VMCS_CR4_MASK: + return VMCS_CR4_MASK_STR; + case VMCS_CR0_READ_SHDW: + return VMCS_CR0_READ_SHDW_STR; + case VMCS_CR4_READ_SHDW: + return VMCS_CR4_READ_SHDW_STR; + case VMCS_CR3_TGT_VAL_0: + return VMCS_CR3_TGT_VAL_0_STR; + case VMCS_CR3_TGT_VAL_1: + return VMCS_CR3_TGT_VAL_1_STR; + case VMCS_CR3_TGT_VAL_2: + return VMCS_CR3_TGT_VAL_2_STR; + case VMCS_CR3_TGT_VAL_3: + return VMCS_CR3_TGT_VAL_3_STR; + case VMCS_EXIT_QUAL: + return VMCS_EXIT_QUAL_STR; + case VMCS_IO_RCX: + return VMCS_IO_RCX_STR; + case VMCS_IO_RSI: + return VMCS_IO_RSI_STR; + case VMCS_IO_RDI: + return VMCS_IO_RDI_STR; + case VMCS_IO_RIP: + return VMCS_IO_RIP_STR; + case VMCS_GUEST_LINEAR_ADDR: + return VMCS_GUEST_LINEAR_ADDR_STR; + case VMCS_GUEST_CR0: + return VMCS_GUEST_CR0_STR; + case VMCS_GUEST_CR3: + return VMCS_GUEST_CR3_STR; + case VMCS_GUEST_CR4: + return VMCS_GUEST_CR4_STR; + case VMCS_GUEST_ES_BASE: + return VMCS_GUEST_ES_BASE_STR; + case VMCS_GUEST_CS_BASE: + return VMCS_GUEST_CS_BASE_STR; + case VMCS_GUEST_SS_BASE: + return VMCS_GUEST_SS_BASE_STR; + case VMCS_GUEST_DS_BASE: + return VMCS_GUEST_DS_BASE_STR; + case VMCS_GUEST_FS_BASE: + return VMCS_GUEST_FS_BASE_STR; + case VMCS_GUEST_GS_BASE: + return VMCS_GUEST_GS_BASE_STR; + case VMCS_GUEST_LDTR_BASE: + return VMCS_GUEST_LDTR_BASE_STR; + case VMCS_GUEST_TR_BASE: + return VMCS_GUEST_TR_BASE_STR; + case VMCS_GUEST_GDTR_BASE: + return VMCS_GUEST_GDTR_BASE_STR; + case VMCS_GUEST_IDTR_BASE: + return VMCS_GUEST_IDTR_BASE_STR; + case VMCS_GUEST_DR7: + return VMCS_GUEST_DR7_STR; + case VMCS_GUEST_RSP: + return VMCS_GUEST_RSP_STR; + case VMCS_GUEST_RIP: + return VMCS_GUEST_RIP_STR; + case VMCS_GUEST_RFLAGS: + return VMCS_GUEST_RFLAGS_STR; + case VMCS_GUEST_PENDING_DBG_EXCP: + return VMCS_GUEST_PENDING_DBG_EXCP_STR; + case VMCS_GUEST_SYSENTER_ESP: + return VMCS_GUEST_SYSENTER_ESP_STR; + case VMCS_GUEST_SYSENTER_EIP: + return VMCS_GUEST_SYSENTER_EIP_STR; + case VMCS_HOST_CR0: + return VMCS_HOST_CR0_STR; + case VMCS_HOST_CR3: + return VMCS_HOST_CR3_STR; + case VMCS_HOST_CR4: + return VMCS_HOST_CR4_STR; + case VMCS_HOST_FS_BASE: + return VMCS_HOST_FS_BASE_STR; + case VMCS_HOST_GS_BASE: + return VMCS_HOST_GS_BASE_STR; + case VMCS_HOST_TR_BASE: + return VMCS_HOST_TR_BASE_STR; + case VMCS_HOST_GDTR_BASE: + return VMCS_HOST_GDTR_BASE_STR; + case VMCS_HOST_IDTR_BASE: + return VMCS_HOST_IDTR_BASE_STR; + case VMCS_HOST_SYSENTER_ESP: + return VMCS_HOST_SYSENTER_ESP_STR; + case VMCS_HOST_SYSENTER_EIP: + return VMCS_HOST_SYSENTER_EIP_STR; + case VMCS_HOST_RSP: + return VMCS_HOST_RSP_STR; + case VMCS_HOST_RIP: + return VMCS_HOST_RIP_STR; + default: + return NULL; + } } + + +