From: Jack Lange Date: Thu, 16 Jul 2009 05:26:18 +0000 (-0500) Subject: updated VMCS field names X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?p=palacios.git;a=commitdiff_plain;h=bb96a58c91406a06af87c21d76d1f08872667ea5 updated VMCS field names --- diff --git a/palacios/include/palacios/vmcs.h b/palacios/include/palacios/vmcs.h index 2563c78..994e1f2 100644 --- a/palacios/include/palacios/vmcs.h +++ b/palacios/include/palacios/vmcs.h @@ -29,28 +29,28 @@ #include /* Pin Based VM Execution Controls */ /* INTEL MANUAL: 20-10 vol 3B */ -#define EXTERNAL_INTERRUPT_EXITING 0x00000001 -#define NMI_EXITING 0x00000008 +#define EXT_INTR_EXIT 0x00000001 +#define NMI_EXIT 0x00000008 #define VIRTUAL_NMIS 0x00000020 /* Processor Based VM Execution Controls */ /* INTEL MANUAL: 20-11 vol. 3B */ -#define INTERRUPT_WINDOWS_EXIT 0x00000004 -#define USE_TSC_OFFSETTING 0x00000008 -#define HLT_EXITING 0x00000080 -#define INVLPG_EXITING 0x00000200 -#define MWAIT_EXITING 0x00000400 -#define RDPMC_EXITING 0x00000800 -#define RDTSC_EXITING 0x00001000 -#define CR8_LOAD_EXITING 0x00080000 -#define CR8_STORE_EXITING 0x00100000 +#define INTR_WIN_EXIT 0x00000004 +#define USE_TSC_OFFSET 0x00000008 +#define HLT_EXIT 0x00000080 +#define INVLPG_EXIT 0x00000200 +#define MWAIT_EXIT 0x00000400 +#define RDPMC_EXIT 0x00000800 +#define RDTSC_EXIT 0x00001000 +#define CR8_LOAD_EXIT 0x00080000 +#define CR8_STORE_EXIT 0x00100000 #define USE_TPR_SHADOW 0x00200000 -#define NMI_WINDOW_EXITING 0x00400000 -#define MOVDR_EXITING 0x00800000 -#define UNCONDITION_IO_EXITING 0x01000000 +#define NMI_WINDOW_EXIT 0x00400000 +#define MOVDR_EXIT 0x00800000 +#define UNCOND_IO_EXIT 0x01000000 #define USE_IO_BITMAPS 0x02000000 #define USE_MSR_BITMAPS 0x10000000 -#define MONITOR_EXITING 0x20000000 -#define PAUSE_EXITING 0x40000000 +#define MONITOR_EXIT 0x20000000 +#define PAUSE_EXIT 0x40000000 /* VM-Exit Controls */ /* INTEL MANUAL: 20-16 vol. 3B */ #define HOST_ADDR_SPACE_SIZE 0x00000200 @@ -74,135 +74,135 @@ typedef enum { VMCS_HOST_GS_SELECTOR = 0x00000C0A, VMCS_HOST_TR_SELECTOR = 0x00000C0C, /* 64 bit control fields */ - IO_BITMAP_A_ADDR = 0x00002000, - IO_BITMAP_A_ADDR_HIGH = 0x00002001, - IO_BITMAP_B_ADDR = 0x00002002, - IO_BITMAP_B_ADDR_HIGH = 0x00002003, - MSR_BITMAPS = 0x00002004, - MSR_BITMAPS_HIGH = 0x00002005, - VM_EXIT_MSR_STORE_ADDR = 0x00002006, - VM_EXIT_MSR_STORE_ADDR_HIGH = 0x00002007, - VM_EXIT_MSR_LOAD_ADDR = 0x00002008, - VM_EXIT_MSR_LOAD_ADDR_HIGH = 0x00002009, - VM_ENTRY_MSR_LOAD_ADDR = 0x0000200A, - VM_ENTRY_MSR_LOAD_ADDR_HIGH = 0x0000200B, - VMCS_EXEC_PTR = 0x0000200C, - VMCS_EXEC_PTR_HIGH = 0x0000200D, - TSC_OFFSET = 0x00002010, - TSC_OFFSET_HIGH = 0x00002011, - VIRT_APIC_PAGE_ADDR = 0x00002012, - VIRT_APIC_PAGE_ADDR_HIGH = 0x00002013, + VMCS_IO_BITMAP_A_ADDR = 0x00002000, + VMCS_IO_BITMAP_A_ADDR_HIGH = 0x00002001, + VMCS_IO_BITMAP_B_ADDR = 0x00002002, + VMCS_IO_BITMAP_B_ADDR_HIGH = 0x00002003, + VMCS_MSR_BITMAP = 0x00002004, + VMCS_MSR_BITMAP_HIGH = 0x00002005, + VMCS_EXIT_MSR_STORE_ADDR = 0x00002006, + VMCS_EXIT_MSR_STORE_ADDR_HIGH = 0x00002007, + VMCS_EXIT_MSR_LOAD_ADDR = 0x00002008, + VMCS_EXIT_MSR_LOAD_ADDR_HIGH = 0x00002009, + VMCS_ENTRY_MSR_LOAD_ADDR = 0x0000200A, + VMCS_ENTRY_MSR_LOAD_ADDR_HIGH = 0x0000200B, + VMCS_EXEC_PTR = 0x0000200C, + VMCS_EXEC_PTR_HIGH = 0x0000200D, + VMCS_TSC_OFFSET = 0x00002010, + VMCS_TSC_OFFSET_HIGH = 0x00002011, + VMCS_VAPIC_ADDR = 0x00002012, + VMCS_VAPIC_ADDR_HIGH = 0x00002013, /* 64 bit guest state fields */ - VMCS_LINK_PTR = 0x00002800, - VMCS_LINK_PTR_HIGH = 0x00002801, - GUEST_IA32_DEBUGCTL = 0x00002802, - GUEST_IA32_DEBUGCTL_HIGH = 0x00002803, - GUEST_IA32_PERF_GLOBAL_CTRL = 0x00002808, - GUEST_IA32_PERF_GLOBAL_CTRL_HIGH = 0x00002809, + VMCS_LINK_PTR = 0x00002800, + VMCS_LINK_PTR_HIGH = 0x00002801, + VMCS_GUEST_DBG_CTL = 0x00002802, + VMCS_GUEST_DBG_CTL_HIGH = 0x00002803, + VMCS_GUEST_PERF_GLOBAL_CTRL = 0x00002808, + VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH = 0x00002809, /* 32 bit control fields */ - PIN_VM_EXEC_CTRLS = 0x00004000, - PROC_VM_EXEC_CTRLS = 0x00004002, - EXCEPTION_BITMAP = 0x00004004, - PAGE_FAULT_ERROR_MASK = 0x00004006, - PAGE_FAULT_ERROR_MATCH = 0x00004008, - CR3_TARGET_COUNT = 0x0000400A, - VM_EXIT_CTRLS = 0x0000400C, - VM_EXIT_MSR_STORE_COUNT = 0x0000400E, - VM_EXIT_MSR_LOAD_COUNT = 0x00004010, - VM_ENTRY_CTRLS = 0x00004012, - VM_ENTRY_MSR_LOAD_COUNT = 0x00004014, - VM_ENTRY_INT_INFO_FIELD = 0x00004016, - VM_ENTRY_EXCEPTION_ERROR = 0x00004018, - VM_ENTRY_INSTR_LENGTH = 0x0000401A, - TPR_THRESHOLD = 0x0000401C, + VMCS_PIN_CTRLS = 0x00004000, + VMCS_PROC_CTRLS = 0x00004002, + VMCS_EXCP_BITMAP = 0x00004004, + VMCS_PG_FAULT_ERR_MASK = 0x00004006, + VMCS_PG_FAULT_ERR_MATCH = 0x00004008, + VMCS_CR3_TGT_CNT = 0x0000400A, + VMCS_EXIT_CTRLS = 0x0000400C, + VMCS_EXIT_MSR_STORE_CNT = 0x0000400E, + VMCS_EXIT_MSR_LOAD_CNT = 0x00004010, + VMCS_ENTRY_CTRLS = 0x00004012, + VMCS_ENTRY_MSR_LOAD_CNT = 0x00004014, + VMCS_ENTRY_INT_INFO = 0x00004016, + VMCS_ENTRY_EXCP_ERR = 0x00004018, + VMCS_ENTRY_INSTR_LEN = 0x0000401A, + VMCS_TPR_THRESHOLD = 0x0000401C, /* 32 bit Read Only data fields */ - VM_INSTR_ERROR = 0x00004400, - EXIT_REASON = 0x00004402, - VM_EXIT_INT_INFO = 0x00004404, - VM_EXIT_INT_ERROR = 0x00004406, - IDT_VECTOR_INFO = 0x00004408, - IDT_VECTOR_ERROR = 0x0000440A, - VM_EXIT_INSTR_LENGTH = 0x0000440C, - VMX_INSTR_INFO = 0x0000440E, + VMCS_INSTR_ERR = 0x00004400, + VMCS_EXIT_REASON = 0x00004402, + VMCS_EXIT_INT_INFO = 0x00004404, + VMCS_EXIT_INT_ERR = 0x00004406, + VMCS_IDT_VECTOR_INFO = 0x00004408, + VMCS_IDT_VECTOR_ERR = 0x0000440A, + VMCS_EXIT_INSTR_LEN = 0x0000440C, + VMCS_VMX_INSTR_INFO = 0x0000440E, /* 32 bit Guest state fields */ - GUEST_ES_LIMIT = 0x00004800, - GUEST_CS_LIMIT = 0x00004802, - GUEST_SS_LIMIT = 0x00004804, - GUEST_DS_LIMIT = 0x00004806, - GUEST_FS_LIMIT = 0x00004808, - GUEST_GS_LIMIT = 0x0000480A, - GUEST_LDTR_LIMIT = 0x0000480C, - GUEST_TR_LIMIT = 0x0000480E, - GUEST_GDTR_LIMIT = 0x00004810, - GUEST_IDTR_LIMIT = 0x00004812, - GUEST_ES_ACCESS = 0x00004814, - GUEST_CS_ACCESS = 0x00004816, - GUEST_SS_ACCESS = 0x00004818, - GUEST_DS_ACCESS = 0x0000481A, - GUEST_FS_ACCESS = 0x0000481C, - GUEST_GS_ACCESS = 0x0000481E, - GUEST_LDTR_ACCESS = 0x00004820, - GUEST_TR_ACCESS = 0x00004822, - GUEST_INT_STATE = 0x00004824, - GUEST_ACTIVITY_STATE = 0x00004826, - GUEST_SMBASE = 0x00004828, - GUEST_IA32_SYSENTER_CS = 0x0000482A, + VMCS_GUEST_ES_LIMIT = 0x00004800, + VMCS_GUEST_CS_LIMIT = 0x00004802, + VMCS_GUEST_SS_LIMIT = 0x00004804, + VMCS_GUEST_DS_LIMIT = 0x00004806, + VMCS_GUEST_FS_LIMIT = 0x00004808, + VMCS_GUEST_GS_LIMIT = 0x0000480A, + VMCS_GUEST_LDTR_LIMIT = 0x0000480C, + VMCS_GUEST_TR_LIMIT = 0x0000480E, + VMCS_GUEST_GDTR_LIMIT = 0x00004810, + VMCS_GUEST_IDTR_LIMIT = 0x00004812, + VMCS_GUEST_ES_ACCESS = 0x00004814, + VMCS_GUEST_CS_ACCESS = 0x00004816, + VMCS_GUEST_SS_ACCESS = 0x00004818, + VMCS_GUEST_DS_ACCESS = 0x0000481A, + VMCS_GUEST_FS_ACCESS = 0x0000481C, + VMCS_GUEST_GS_ACCESS = 0x0000481E, + VMCS_GUEST_LDTR_ACCESS = 0x00004820, + VMCS_GUEST_TR_ACCESS = 0x00004822, + VMCS_GUEST_INT_STATE = 0x00004824, + VMCS_GUEST_ACTIVITY_STATE = 0x00004826, + VMCS_GUEST_SMBASE = 0x00004828, + VMCS_GUEST_SYSENTER_CS = 0x0000482A, /* 32 bit host state field */ - HOST_IA32_SYSENTER_CS = 0x00004C00, + VMCS_HOST_SYSENTER_CS = 0x00004C00, /* Natural Width Control Fields */ - CR0_GUEST_HOST_MASK = 0x00006000, - CR4_GUEST_HOST_MASK = 0x00006002, - CR0_READ_SHADOW = 0x00006004, - CR4_READ_SHADOW = 0x00006006, - CR3_TARGET_VALUE_0 = 0x00006008, - CR3_TARGET_VALUE_1 = 0x0000600A, - CR3_TARGET_VALUE_2 = 0x0000600C, - CR3_TARGET_VALUE_3 = 0x0000600E, + VMCS_CR0_MASK = 0x00006000, + VMCS_CR4_MASK = 0x00006002, + VMCS_CR0_READ_SHDW = 0x00006004, + VMCS_CR4_READ_SHDW = 0x00006006, + VMCS_CR3_TGT_VAL_0 = 0x00006008, + VMCS_CR3_TGT_VAL_1 = 0x0000600A, + VMCS_CR3_TGT_VAL_2 = 0x0000600C, + VMCS_CR3_TGT_VAL_3 = 0x0000600E, /* Natural Width Read Only Fields */ - EXIT_QUALIFICATION = 0x00006400, - IO_RCX = 0x00006402, - IO_RSI = 0x00006404, - IO_RDI = 0x00006406, - IO_RIP = 0x00006408, - GUEST_LINEAR_ADDR = 0x0000640A, + VMCS_EXIT_QUAL = 0x00006400, + VMCS_IO_RCX = 0x00006402, + VMCS_IO_RSI = 0x00006404, + VMCS_IO_RDI = 0x00006406, + VMCS_IO_RIP = 0x00006408, + VMCS_GUEST_LINEAR_ADDR = 0x0000640A, /* Natural Width Guest State Fields */ - GUEST_CR0 = 0x00006800, - GUEST_CR3 = 0x00006802, - GUEST_CR4 = 0x00006804, - GUEST_ES_BASE = 0x00006806, - GUEST_CS_BASE = 0x00006808, - GUEST_SS_BASE = 0x0000680A, - GUEST_DS_BASE = 0x0000680C, - GUEST_FS_BASE = 0x0000680E, - GUEST_GS_BASE = 0x00006810, - GUEST_LDTR_BASE = 0x00006812, - GUEST_TR_BASE = 0x00006814, - GUEST_GDTR_BASE = 0x00006816, - GUEST_IDTR_BASE = 0x00006818, - GUEST_DR7 = 0x0000681A, - GUEST_RSP = 0x0000681C, - GUEST_RIP = 0x0000681E, - GUEST_RFLAGS = 0x00006820, - GUEST_PENDING_DEBUG_EXCS = 0x00006822, - GUEST_IA32_SYSENTER_ESP = 0x00006824, - GUEST_IA32_SYSENTER_EIP = 0x00006826, + VMCS_GUEST_CR0 = 0x00006800, + VMCS_GUEST_CR3 = 0x00006802, + VMCS_GUEST_CR4 = 0x00006804, + VMCS_GUEST_ES_BASE = 0x00006806, + VMCS_GUEST_CS_BASE = 0x00006808, + VMCS_GUEST_SS_BASE = 0x0000680A, + VMCS_GUEST_DS_BASE = 0x0000680C, + VMCS_GUEST_FS_BASE = 0x0000680E, + VMCS_GUEST_GS_BASE = 0x00006810, + VMCS_GUEST_LDTR_BASE = 0x00006812, + VMCS_GUEST_TR_BASE = 0x00006814, + VMCS_GUEST_GDTR_BASE = 0x00006816, + VMCS_GUEST_IDTR_BASE = 0x00006818, + VMCS_GUEST_DR7 = 0x0000681A, + VMCS_GUEST_RSP = 0x0000681C, + VMCS_GUEST_RIP = 0x0000681E, + VMCS_GUEST_RFLAGS = 0x00006820, + VMCS_GUEST_PENDING_DBG_EXCP = 0x00006822, + VMCS_GUEST_SYSENTER_ESP = 0x00006824, + VMCS_GUEST_SYSENTER_EIP = 0x00006826, /* Natural Width Host State Fields */ - HOST_CR0 = 0x00006C00, - HOST_CR3 = 0x00006C02, - HOST_CR4 = 0x00006C04, - HOST_FS_BASE = 0x00006C06, - HOST_GS_BASE = 0x00006C08, - HOST_TR_BASE = 0x00006C0A, - HOST_GDTR_BASE = 0x00006C0C, - HOST_IDTR_BASE = 0x00006C0E, - HOST_IA32_SYSENTER_ESP = 0x00006C10, - HOST_IA32_SYSENTER_EIP = 0x00006C12, - HOST_RSP = 0x00006C14, - HOST_RIP = 0x00006C16, - } vmcs_field_t; + VMCS_HOST_CR0 = 0x00006C00, + VMCS_HOST_CR3 = 0x00006C02, + VMCS_HOST_CR4 = 0x00006C04, + VMCS_HOST_FS_BASE = 0x00006C06, + VMCS_HOST_GS_BASE = 0x00006C08, + VMCS_HOST_TR_BASE = 0x00006C0A, + VMCS_HOST_GDTR_BASE = 0x00006C0C, + VMCS_HOST_IDTR_BASE = 0x00006C0E, + VMCS_HOST_SYSENTER_ESP = 0x00006C10, + VMCS_HOST_SYSENTER_EIP = 0x00006C12, + VMCS_HOST_RSP = 0x00006C14, + VMCS_HOST_RIP = 0x00006C16, +} vmcs_field_t; int v3_vmcs_get_field_len(vmcs_field_t field); -char* v3_vmcs_get_field_name(vmcs_field_t field); +const char * v3_vmcs_get_field_name(vmcs_field_t field); diff --git a/palacios/src/palacios/vmcs.c b/palacios/src/palacios/vmcs.c index cf130fc..d1dac63 100644 --- a/palacios/src/palacios/vmcs.c +++ b/palacios/src/palacios/vmcs.c @@ -159,10 +159,9 @@ void print_vmcs_segment(char * name, vmcs_segment* seg) /* * Returns the field length in bytes */ -int v3_vmcs_get_field_len(vmcs_field_t field) -{ - switch(field) - { +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: @@ -171,7 +170,6 @@ int v3_vmcs_get_field_len(vmcs_field_t field) case VMCS_GUEST_GS_SELECTOR: case VMCS_GUEST_LDTR_SELECTOR: case VMCS_GUEST_TR_SELECTOR: - /* 16 bit host state */ case VMCS_HOST_ES_SELECTOR: case VMCS_HOST_CS_SELECTOR: case VMCS_HOST_SS_SELECTOR: @@ -180,410 +178,547 @@ int v3_vmcs_get_field_len(vmcs_field_t field) case VMCS_HOST_GS_SELECTOR: case VMCS_HOST_TR_SELECTOR: return 2; - /* 64 bit control fields */ - case IO_BITMAP_A_ADDR: - case IO_BITMAP_A_ADDR_HIGH: - case IO_BITMAP_B_ADDR: - case IO_BITMAP_B_ADDR_HIGH: - case MSR_BITMAPS: - case MSR_BITMAPS_HIGH: - case VM_EXIT_MSR_STORE_ADDR: - case VM_EXIT_MSR_STORE_ADDR_HIGH: - case VM_EXIT_MSR_LOAD_ADDR: - case VM_EXIT_MSR_LOAD_ADDR_HIGH: - case VM_ENTRY_MSR_LOAD_ADDR: - case VM_ENTRY_MSR_LOAD_ADDR_HIGH: + + /* 32 bit Control Fields */ + case VMCS_PIN_CTRLS: + case VMCS_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_VMX_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; + + /* 64 bit Control Fields */ + case VMCS_IO_BITMAP_A_ADDR: + case VMCS_IO_BITMAP_A_ADDR_HIGH: + case VMCS_IO_BITMAP_B_ADDR: + case VMCS_IO_BITMAP_B_ADDR_HIGH: + case VMCS_MSR_BITMAP: + case VMCS_MSR_BITMAP_HIGH: + case VMCS_EXIT_MSR_STORE_ADDR: + case VMCS_EXIT_MSR_STORE_ADDR_HIGH: + case VMCS_EXIT_MSR_LOAD_ADDR: + case VMCS_EXIT_MSR_LOAD_ADDR_HIGH: + case VMCS_ENTRY_MSR_LOAD_ADDR: + case VMCS_ENTRY_MSR_LOAD_ADDR_HIGH: case VMCS_EXEC_PTR: case VMCS_EXEC_PTR_HIGH: - case TSC_OFFSET: - case TSC_OFFSET_HIGH: - case VIRT_APIC_PAGE_ADDR: - case VIRT_APIC_PAGE_ADDR_HIGH: - /* 64 bit guest state fields */ + case VMCS_TSC_OFFSET: + case VMCS_TSC_OFFSET_HIGH: + case VMCS_VAPIC_ADDR: + case VMCS_VAPIC_ADDR_HIGH: case VMCS_LINK_PTR: case VMCS_LINK_PTR_HIGH: - case GUEST_IA32_DEBUGCTL: - case GUEST_IA32_DEBUGCTL_HIGH: - case GUEST_IA32_PERF_GLOBAL_CTRL: - case GUEST_IA32_PERF_GLOBAL_CTRL_HIGH: + case VMCS_GUEST_DBG_CTL: + case VMCS_GUEST_DBG_CTL_HIGH: + case VMCS_GUEST_PERF_GLOBAL_CTRL: + case VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH: return 8; - /* 32 bit control fields */ - case PIN_VM_EXEC_CTRLS: - case PROC_VM_EXEC_CTRLS: - case EXCEPTION_BITMAP: - case PAGE_FAULT_ERROR_MASK: - case PAGE_FAULT_ERROR_MATCH: - case CR3_TARGET_COUNT: - case VM_EXIT_CTRLS: - case VM_EXIT_MSR_STORE_COUNT: - case VM_EXIT_MSR_LOAD_COUNT: - case VM_ENTRY_CTRLS: - case VM_ENTRY_MSR_LOAD_COUNT: - case VM_ENTRY_INT_INFO_FIELD: - case VM_ENTRY_EXCEPTION_ERROR: - case VM_ENTRY_INSTR_LENGTH: - case TPR_THRESHOLD: - /* 32 bit Read Only data fields */ - case VM_INSTR_ERROR: - case EXIT_REASON: - case VM_EXIT_INT_INFO: - case VM_EXIT_INT_ERROR: - case IDT_VECTOR_INFO: - case IDT_VECTOR_ERROR: - case VM_EXIT_INSTR_LENGTH: - case VMX_INSTR_INFO: - /* 32 bit Guest state fields */ - case GUEST_ES_LIMIT: - case GUEST_CS_LIMIT: - case GUEST_SS_LIMIT: - case GUEST_DS_LIMIT: - case GUEST_FS_LIMIT: - case GUEST_GS_LIMIT: - case GUEST_LDTR_LIMIT: - case GUEST_TR_LIMIT: - case GUEST_GDTR_LIMIT: - case GUEST_IDTR_LIMIT: - case GUEST_ES_ACCESS: - case GUEST_CS_ACCESS: - case GUEST_SS_ACCESS: - case GUEST_DS_ACCESS: - case GUEST_FS_ACCESS: - case GUEST_GS_ACCESS: - case GUEST_LDTR_ACCESS: - case GUEST_TR_ACCESS: - case GUEST_INT_STATE: - case GUEST_ACTIVITY_STATE: - case GUEST_SMBASE: - case GUEST_IA32_SYSENTER_CS: - /* 32 bit host state field */ - case HOST_IA32_SYSENTER_CS: - return 4; + /* Natural Width Control Fields */ - case CR0_GUEST_HOST_MASK: - case CR4_GUEST_HOST_MASK: - case CR0_READ_SHADOW: - case CR4_READ_SHADOW: - case CR3_TARGET_VALUE_0: - case CR3_TARGET_VALUE_1: - case CR3_TARGET_VALUE_2: - case CR3_TARGET_VALUE_3: - /* Natural Width Read Only Fields */ - case EXIT_QUALIFICATION: - case IO_RCX: - case IO_RSI: - case IO_RDI: - case IO_RIP: - case GUEST_LINEAR_ADDR: - /* Natural Width Guest State Fields */ - case GUEST_CR0: - case GUEST_CR3: - case GUEST_CR4: - case GUEST_ES_BASE: - case GUEST_CS_BASE: - case GUEST_SS_BASE: - case GUEST_DS_BASE: - case GUEST_FS_BASE: - case GUEST_GS_BASE: - case GUEST_LDTR_BASE: - case GUEST_TR_BASE: - case GUEST_GDTR_BASE: - case GUEST_IDTR_BASE: - case GUEST_DR7: - case GUEST_RSP: - case GUEST_RIP: - case GUEST_RFLAGS: - case GUEST_PENDING_DEBUG_EXCS: - case GUEST_IA32_SYSENTER_ESP: - case GUEST_IA32_SYSENTER_EIP: - /* Natural Width Host State Fields */ - case HOST_CR0: - case HOST_CR3: - case HOST_CR4: - case HOST_FS_BASE: - case HOST_GS_BASE: - case HOST_TR_BASE: - case HOST_GDTR_BASE: - case HOST_IDTR_BASE: - case HOST_IA32_SYSENTER_ESP: - case HOST_IA32_SYSENTER_EIP: - case HOST_RSP: - case HOST_RIP: - #ifdef __V3_64BIT__ - return 8; -#else - return 4; -#endif + 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; } } -char* v3_vmcs_get_field_name(vmcs_field_t field) -{ - switch(field) - { + + + + + + + + + + + +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_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_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_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_VMX_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_get_field_name(vmcs_field_t field) { + switch (field) { case VMCS_GUEST_ES_SELECTOR: - return "VMCS_GUEST_ES_SELECTOR"; + return VMCS_GUEST_ES_SELECTOR_STR; case VMCS_GUEST_CS_SELECTOR: - return "VMCS_GUEST_CS_SELECTOR"; + return VMCS_GUEST_CS_SELECTOR_STR; case VMCS_GUEST_SS_SELECTOR: - return "VMCS_GUEST_SS_SELECTOR"; + return VMCS_GUEST_SS_SELECTOR_STR; case VMCS_GUEST_DS_SELECTOR: - return "VMCS_GUEST_DS_SELECTOR"; + return VMCS_GUEST_DS_SELECTOR_STR; case VMCS_GUEST_FS_SELECTOR: - return "VMCS_GUEST_FS_SELECTOR"; + return VMCS_GUEST_FS_SELECTOR_STR; case VMCS_GUEST_GS_SELECTOR: - return "VMCS_GUEST_GS_SELECTOR"; + return VMCS_GUEST_GS_SELECTOR_STR; case VMCS_GUEST_LDTR_SELECTOR: - return "VMCS_GUEST_LDTR_SELECTOR"; + return VMCS_GUEST_LDTR_SELECTOR_STR; case VMCS_GUEST_TR_SELECTOR: - return "VMCS_GUEST_TR_SELECTOR"; + return VMCS_GUEST_TR_SELECTOR_STR; case VMCS_HOST_ES_SELECTOR: - return "VMCS_HOST_ES_SELECTOR"; + return VMCS_HOST_ES_SELECTOR_STR; case VMCS_HOST_CS_SELECTOR: - return "VMCS_HOST_CS_SELECTOR"; + return VMCS_HOST_CS_SELECTOR_STR; case VMCS_HOST_SS_SELECTOR: - return "VMCS_HOST_SS_SELECTOR"; + return VMCS_HOST_SS_SELECTOR_STR; case VMCS_HOST_DS_SELECTOR: - return "VMCS_HOST_DS_SELECTOR"; + return VMCS_HOST_DS_SELECTOR_STR; case VMCS_HOST_FS_SELECTOR: - return "VMCS_HOST_FS_SELECTOR"; + return VMCS_HOST_FS_SELECTOR_STR; case VMCS_HOST_GS_SELECTOR: - return "VMCS_HOST_GS_SELECTOR"; + return VMCS_HOST_GS_SELECTOR_STR; case VMCS_HOST_TR_SELECTOR: - return "VMCS_HOST_TR_SELECTOR"; - case IO_BITMAP_A_ADDR: - return "IO_BITMAP_A_ADDR"; - case IO_BITMAP_A_ADDR_HIGH: - return "IO_BITMAP_A_ADDR_HIGH"; - case IO_BITMAP_B_ADDR: - return "IO_BITMAP_B_ADDR"; - case IO_BITMAP_B_ADDR_HIGH: - return "IO_BITMAP_B_ADDR_HIGH"; - case MSR_BITMAPS: - return "MSR_BITMAPS"; - case MSR_BITMAPS_HIGH: - return "MSR_BITMAPS_HIGH"; - case VM_EXIT_MSR_STORE_ADDR: - return "VM_EXIT_MSR_STORE_ADDR"; - case VM_EXIT_MSR_STORE_ADDR_HIGH: - return "VM_EXIT_MSR_STORE_ADDR_HIGH"; - case VM_EXIT_MSR_LOAD_ADDR: - return "VM_EXIT_MSR_LOAD_ADDR"; - case VM_EXIT_MSR_LOAD_ADDR_HIGH: - return "VM_EXIT_MSR_LOAD_ADDR_HIGH"; - case VM_ENTRY_MSR_LOAD_ADDR: - return "VM_ENTRY_MSR_LOAD_ADDR"; - case VM_ENTRY_MSR_LOAD_ADDR_HIGH: - return "VM_ENTRY_MSR_LOAD_ADDR_HIGH"; + 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"; + return VMCS_EXEC_PTR_STR; case VMCS_EXEC_PTR_HIGH: - return "VMCS_EXEC_PTR_HIGH"; - case TSC_OFFSET: - return "TSC_OFFSET"; - case TSC_OFFSET_HIGH: - return "TSC_OFFSET_HIGH"; - case VIRT_APIC_PAGE_ADDR: - return "VIRT_APIC_PAGE_ADDR"; - case VIRT_APIC_PAGE_ADDR_HIGH: - return "VIRT_APIC_PAGE_ADDR_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_LINK_PTR: - return "VMCS_LINK_PTR"; + return VMCS_LINK_PTR_STR; case VMCS_LINK_PTR_HIGH: - return "VMCS_LINK_PTR_HIGH"; - case GUEST_IA32_DEBUGCTL: - return "GUEST_IA32_DEBUGCTL"; - case GUEST_IA32_DEBUGCTL_HIGH: - return "GUEST_IA32_DEBUGCTL_HIGH"; - case GUEST_IA32_PERF_GLOBAL_CTRL: - return "GUEST_IA32_PERF_GLOBAL_CTRL"; - case GUEST_IA32_PERF_GLOBAL_CTRL_HIGH: - return "GUEST_IA32_PERF_GLOBAL_CTRL_HIGH"; - case PIN_VM_EXEC_CTRLS: - return "PIN_VM_EXEC_CTRLS"; - case PROC_VM_EXEC_CTRLS: - return "PROC_VM_EXEC_CTRLS"; - case EXCEPTION_BITMAP: - return "EXCEPTION_BITMAP"; - case PAGE_FAULT_ERROR_MASK: - return "PAGE_FAULT_ERROR_MASK"; - case PAGE_FAULT_ERROR_MATCH: - return "PAGE_FAULT_ERROR_MATCH"; - case CR3_TARGET_COUNT: - return "CR3_TARGET_COUNT"; - case VM_EXIT_CTRLS: - return "VM_EXIT_CTRLS"; - case VM_EXIT_MSR_STORE_COUNT: - return "VM_EXIT_MSR_STORE_COUNT"; - case VM_EXIT_MSR_LOAD_COUNT: - return "VM_EXIT_MSR_LOAD_COUNT"; - case VM_ENTRY_CTRLS: - return "VM_ENTRY_CTRLS"; - case VM_ENTRY_MSR_LOAD_COUNT: - return "VM_ENTRY_MSR_LOAD_COUNT"; - case VM_ENTRY_INT_INFO_FIELD: - return "VM_ENTRY_INT_INFO_FIELD"; - case VM_ENTRY_EXCEPTION_ERROR: - return "VM_ENTRY_EXCEPTION_ERROR"; - case VM_ENTRY_INSTR_LENGTH: - return "VM_ENTRY_INSTR_LENGTH"; - case TPR_THRESHOLD: - return "TPR_THRESHOLD"; - case VM_INSTR_ERROR: - return "VM_INSTR_ERROR"; - case EXIT_REASON: - return "EXIT_REASON"; - case VM_EXIT_INT_INFO: - return "VM_EXIT_INT_INFO"; - case VM_EXIT_INT_ERROR: - return "VM_EXIT_INT_ERROR"; - case IDT_VECTOR_INFO: - return "IDT_VECTOR_INFO"; - case IDT_VECTOR_ERROR: - return "IDT_VECTOR_ERROR"; - case VM_EXIT_INSTR_LENGTH: - return "VM_EXIT_INSTR_LENGTH"; - case VMX_INSTR_INFO: - return "VMX_INSTR_INFO"; - case GUEST_ES_LIMIT: - return "GUEST_ES_LIMIT"; - case GUEST_CS_LIMIT: - return "GUEST_CS_LIMIT"; - case GUEST_SS_LIMIT: - return "GUEST_SS_LIMIT"; - case GUEST_DS_LIMIT: - return "GUEST_DS_LIMIT"; - case GUEST_FS_LIMIT: - return "GUEST_FS_LIMIT"; - case GUEST_GS_LIMIT: - return "GUEST_GS_LIMIT"; - case GUEST_LDTR_LIMIT: - return "GUEST_LDTR_LIMIT"; - case GUEST_TR_LIMIT: - return "GUEST_TR_LIMIT"; - case GUEST_GDTR_LIMIT: - return "GUEST_GDTR_LIMIT"; - case GUEST_IDTR_LIMIT: - return "GUEST_IDTR_LIMIT"; - case GUEST_ES_ACCESS: - return "GUEST_ES_ACCESS"; - case GUEST_CS_ACCESS: - return "GUEST_CS_ACCESS"; - case GUEST_SS_ACCESS: - return "GUEST_SS_ACCESS"; - case GUEST_DS_ACCESS: - return "GUEST_DS_ACCESS"; - case GUEST_FS_ACCESS: - return "GUEST_FS_ACCESS"; - case GUEST_GS_ACCESS: - return "GUEST_GS_ACCESS"; - case GUEST_LDTR_ACCESS: - return "GUEST_LDTR_ACCESS"; - case GUEST_TR_ACCESS: - return "GUEST_TR_ACCESS"; - case GUEST_INT_STATE: - return "GUEST_INT_STATE"; - case GUEST_ACTIVITY_STATE: - return "GUEST_ACTIVITY_STATE"; - case GUEST_SMBASE: - return "GUEST_SMBASE"; - case GUEST_IA32_SYSENTER_CS: - return "GUEST_IA32_SYSENTER_CS"; - case HOST_IA32_SYSENTER_CS: - return "HOST_IA32_SYSENTER_CS"; - case CR0_GUEST_HOST_MASK: - return "CR0_GUEST_HOST_MASK"; - case CR4_GUEST_HOST_MASK: - return "CR4_GUEST_HOST_MASK"; - case CR0_READ_SHADOW: - return "CR0_READ_SHADOW"; - case CR4_READ_SHADOW: - return "CR4_READ_SHADOW"; - case CR3_TARGET_VALUE_0: - return "CR3_TARGET_VALUE_0"; - case CR3_TARGET_VALUE_1: - return "CR3_TARGET_VALUE_1"; - case CR3_TARGET_VALUE_2: - return "CR3_TARGET_VALUE_2"; - case CR3_TARGET_VALUE_3: - return "CR3_TARGET_VALUE_3"; - case EXIT_QUALIFICATION: - return "EXIT_QUALIFICATION"; - case IO_RCX: - return "IO_RCX"; - case IO_RSI: - return "IO_RSI"; - case IO_RDI: - return "IO_RDI"; - case IO_RIP: - return "IO_RIP"; - case GUEST_LINEAR_ADDR: - return "GUEST_LINEAR_ADDR"; - case GUEST_CR0: - return "GUEST_CR0"; - case GUEST_CR3: - return "GUEST_CR3"; - case GUEST_CR4: - return "GUEST_CR4"; - case GUEST_ES_BASE: - return "GUEST_ES_BASE"; - case GUEST_CS_BASE: - return "GUEST_CS_BASE"; - case GUEST_SS_BASE: - return "GUEST_SS_BASE"; - case GUEST_DS_BASE: - return "GUEST_DS_BASE"; - case GUEST_FS_BASE: - return "GUEST_FS_BASE"; - case GUEST_GS_BASE: - return "GUEST_GS_BASE"; - case GUEST_LDTR_BASE: - return "GUEST_LDTR_BASE"; - case GUEST_TR_BASE: - return "GUEST_TR_BASE"; - case GUEST_GDTR_BASE: - return "GUEST_GDTR_BASE"; - case GUEST_IDTR_BASE: - return "GUEST_IDTR_BASE"; - case GUEST_DR7: - return "GUEST_DR7"; - case GUEST_RSP: - return "GUEST_RSP"; - case GUEST_RIP: - return "GUEST_RIP"; - case GUEST_RFLAGS: - return "GUEST_RFLAGS"; - case GUEST_PENDING_DEBUG_EXCS: - return "GUEST_PENDING_DEBUG_EXCS"; - case GUEST_IA32_SYSENTER_ESP: - return "GUEST_IA32_SYSENTER_ESP"; - case GUEST_IA32_SYSENTER_EIP: - return "GUEST_IA32_SYSENTER_EIP"; - case HOST_CR0: - return "HOST_CR0"; - case HOST_CR3: - return "HOST_CR3"; - case HOST_CR4: - return "HOST_CR4"; - case HOST_FS_BASE: - return "HOST_FS_BASE"; - case HOST_GS_BASE: - return "HOST_GS_BASE"; - case HOST_TR_BASE: - return "HOST_TR_BASE"; - case HOST_GDTR_BASE: - return "HOST_GDTR_BASE"; - case HOST_IDTR_BASE: - return "HOST_IDTR_BASE"; - case HOST_IA32_SYSENTER_ESP: - return "HOST_IA32_SYSENTER_ESP"; - case HOST_IA32_SYSENTER_EIP: - return "HOST_IA32_SYSENTER_EIP"; - case HOST_RSP: - return "HOST_RSP"; - case HOST_RIP: - return "HOST_RIP"; + 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_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_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_VMX_INSTR_INFO: + return VMCS_VMX_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; } diff --git a/palacios/src/palacios/vmx.c b/palacios/src/palacios/vmx.c index a5bc97f..4f1ecb2 100644 --- a/palacios/src/palacios/vmx.c +++ b/palacios/src/palacios/vmx.c @@ -359,21 +359,21 @@ static int update_vmcs_host_state(struct guest_info * info) { : "=q"(tmp) : ); - vmcs_write(HOST_CR0, tmp); + vmcs_write(VMCS_HOST_CR0, tmp); __asm__ __volatile__ ( "movq %%cr3, %0; " : "=q"(tmp) : ); - vmcs_write(HOST_CR3, tmp); + vmcs_write(VMCS_HOST_CR3, tmp); __asm__ __volatile__ ( "movq %%cr4, %0; " : "=q"(tmp) : ); - vmcs_write(HOST_CR4, tmp); + vmcs_write(VMCS_HOST_CR4, tmp); @@ -383,7 +383,7 @@ static int update_vmcs_host_state(struct guest_info * info) { :"q"(&tmp_seg) : "memory" ); - vmcs_write(HOST_GDTR_BASE, tmp_seg.base); + vmcs_write(VMCS_HOST_GDTR_BASE, tmp_seg.base); __asm__ __volatile__ ("sidt (%0); " @@ -391,7 +391,7 @@ static int update_vmcs_host_state(struct guest_info * info) { :"q"(&tmp_seg) : "memory" ); - vmcs_write(HOST_IDTR_BASE, tmp_seg.base); + vmcs_write(VMCS_HOST_IDTR_BASE, tmp_seg.base); /* How do we handle this...? __asm__ __volatile__ ("str (%0); " @@ -399,7 +399,7 @@ static int update_vmcs_host_state(struct guest_info * info) { :"q"(&tmp_seg) : "memory" ); - vmcs_write(HOST_TR_BASE, tmp_seg.base); + vmcs_write(VMCS_HOST_TR_BASE, tmp_seg.base); */ #define FS_BASE_MSR 0xc0000100 @@ -407,11 +407,11 @@ static int update_vmcs_host_state(struct guest_info * info) { // FS.BASE MSR v3_get_msr(FS_BASE_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); - vmcs_write(HOST_FS_BASE, tmp_msr.value); + vmcs_write(VMCS_HOST_FS_BASE, tmp_msr.value); // GS.BASE MSR v3_get_msr(GS_BASE_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); - vmcs_write(HOST_GS_BASE, tmp_msr.value); + vmcs_write(VMCS_HOST_GS_BASE, tmp_msr.value); @@ -433,6 +433,12 @@ static int update_vmcs_host_state(struct guest_info * info) { ); vmcs_write(VMCS_HOST_DS_SELECTOR, tmp); + __asm__ __volatile__ ( "movq %%es, %0; " + : "=q"(tmp) + : + ); + vmcs_write(VMCS_HOST_ES_SELECTOR, tmp); + __asm__ __volatile__ ( "movq %%fs, %0; " : "=q"(tmp) : @@ -458,23 +464,21 @@ static int update_vmcs_host_state(struct guest_info * info) { // SYSENTER CS MSR v3_get_msr(SYSENTER_CS_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); - vmcs_write(HOST_IA32_SYSENTER_CS, tmp_msr.value); + vmcs_write(VMCS_HOST_SYSENTER_CS, tmp_msr.value); // SYSENTER_ESP MSR v3_get_msr(SYSENTER_ESP_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); - vmcs_write(HOST_IA32_SYSENTER_ESP, tmp_msr.value); - + vmcs_write(VMCS_HOST_SYSENTER_ESP, tmp_msr.value); // SYSENTER_EIP MSR v3_get_msr(SYSENTER_EIP_MSR, &(tmp_msr.hi), &(tmp_msr.lo)); - vmcs_write(HOST_IA32_SYSENTER_EIP, tmp_msr.value); + vmcs_write(VMCS_HOST_SYSENTER_EIP, tmp_msr.value); // RIP // RSP return 0; - }