Optimize code by using new VMCS-cache macros

- Replaced vmcs_pending* fields, with the new automatically-generated function that updates VMCS based on vmcs_cache_w flags. Only `vmcs_pending_guest_cr3` has been preserved since it requires extra logic.

- Removed unnecessary vmread's at the end of `cpu_vmx_execute` that are not always required. Corresponding members in `vcpu_vmx_data` have been removed and function depending on them now call `vmcs_read`.

Signed-off-by: Alexandro Sanchez Bach <asanchez@kryptoslogic.com>

Author: AlexAltea

core/cpu.c

@@ -312,36 +312,6 @@ vmx_result_t cpu_vmx_run(struct vcpu_t *vcpu, struct hax_tunnel *htun)
     return result;
 }
 
-void vcpu_handle_vmcs_pending(struct vcpu_t *vcpu)
-{
-    if (!vcpu || !vcpu->vmcs_pending)
-        return;
-    if (vcpu->vmcs_pending_entry_error_code) {
-        vmwrite(vcpu, VMX_ENTRY_EXCEPTION_ERROR_CODE,
-                vmx(vcpu, entry_exception_error_code));
-        vcpu->vmcs_pending_entry_error_code = 0;
-    }
-
-    if (vcpu->vmcs_pending_entry_instr_length) {
-        vmwrite(vcpu, VMX_ENTRY_INSTRUCTION_LENGTH,
-                vmx(vcpu, entry_instr_length));
-        vcpu->vmcs_pending_entry_instr_length = 0;
-    }
-
-    if (vcpu->vmcs_pending_entry_intr_info) {
-        vmwrite(vcpu, VMX_ENTRY_INTERRUPT_INFO,
-                vmx(vcpu, entry_intr_info).raw);
-        vcpu->vmcs_pending_entry_intr_info = 0;
-    }
-
-    if (vcpu->vmcs_pending_guest_cr3) {
-        vmwrite(vcpu, GUEST_CR3, vtlb_get_cr3(vcpu));
-        vcpu->vmcs_pending_guest_cr3 = 0;
-    }
-    vcpu->vmcs_pending = 0;
-    return;
-}
-
 /* Return the value same as ioctl value */
 int cpu_vmx_execute(struct vcpu_t *vcpu, struct hax_tunnel *htun)
 {
@@ -416,16 +386,6 @@ int cpu_vmx_execute(struct vcpu_t *vcpu, struct hax_tunnel *htun)
 
         vmx(vcpu, exit_qualification).raw = vmread(
                 vcpu, VM_EXIT_INFO_QUALIFICATION);
-        vmx(vcpu, exit_intr_info).raw = vmread(
-                vcpu, VM_EXIT_INFO_INTERRUPT_INFO);
-        vmx(vcpu, exit_exception_error_code) = vmread(
-                vcpu, VM_EXIT_INFO_EXCEPTION_ERROR_CODE);
-        vmx(vcpu, exit_idt_vectoring) = vmread(
-                vcpu, VM_EXIT_INFO_IDT_VECTORING);
-        vmx(vcpu, exit_instr_length) = vmread(
-                vcpu, VM_EXIT_INFO_INSTRUCTION_LENGTH);
-        vmx(vcpu, exit_gpa) = vmread(
-                vcpu, VM_EXIT_INFO_GUEST_PHYSICAL_ADDRESS);
         vmx(vcpu, interruptibility_state).raw = vmread(
                 vcpu, GUEST_INTERRUPTIBILITY);
 

core/include/vcpu.h

@@ -154,10 +154,6 @@ struct vcpu_t {
 #define GS_STALE      0
 #define GS_VALID      1
         uint64_t cur_state                       : 1;
-        uint64_t vmcs_pending                    : 1;
-        uint64_t vmcs_pending_entry_error_code   : 1;
-        uint64_t vmcs_pending_entry_instr_length : 1;
-        uint64_t vmcs_pending_entry_intr_info    : 1;
         uint64_t vmcs_pending_guest_cr3          : 1;
         uint64_t debug_control_dirty             : 1;
         uint64_t dr_dirty                        : 1;

core/include/vmx.h

@@ -291,7 +291,7 @@ typedef enum component_index_t component_index_t;
  */
 #define VMCS_COMPS                                           \
     /* 64-bit components */                                  \
-    COMP(1, 1, W_64, VMX_IO_BITMAP_A)                        \
+    COMP(0, 0, W_64, VMX_IO_BITMAP_A)                        \
     COMP(0, 0, W_64, VMX_IO_BITMAP_B)                        \
     COMP(0, 0, W_64, VMX_MSR_BITMAP)                         \
     COMP(0, 0, W_64, VMX_EXIT_MSR_STORE_ADDRESS)             \
@@ -301,7 +301,7 @@ typedef enum component_index_t component_index_t;
     COMP(0, 0, W_64, VMX_VAPIC_PAGE)                         \
     COMP(0, 0, W_64, VMX_APIC_ACCESS_PAGE)                   \
     COMP(0, 0, W_64, VMX_EPTP)                               \
-    COMP(0, 0, W_64, VM_EXIT_INFO_GUEST_PHYSICAL_ADDRESS)    \
+    COMP(1, 0, W_64, VM_EXIT_INFO_GUEST_PHYSICAL_ADDRESS)    \
     COMP(0, 0, W_64, HOST_PAT)                               \
     COMP(0, 0, W_64, HOST_EFER)                              \
     COMP(0, 0, W_64, HOST_PERF_GLOBAL_CTRL)                  \
@@ -370,19 +370,19 @@ typedef enum component_index_t component_index_t;
     COMP(0, 0, W_32, VMX_EXIT_MSR_LOAD_COUNT)                \
     COMP(0, 0, W_32, VMX_ENTRY_CONTROLS)                     \
     COMP(0, 0, W_32, VMX_ENTRY_MSR_LOAD_COUNT)               \
-    COMP(0, 0, W_32, VMX_ENTRY_INTERRUPT_INFO)               \
-    COMP(0, 0, W_32, VMX_ENTRY_EXCEPTION_ERROR_CODE)         \
-    COMP(0, 0, W_32, VMX_ENTRY_INSTRUCTION_LENGTH)           \
+    COMP(0, 1, W_32, VMX_ENTRY_INTERRUPT_INFO)               \
+    COMP(0, 1, W_32, VMX_ENTRY_EXCEPTION_ERROR_CODE)         \
+    COMP(0, 1, W_32, VMX_ENTRY_INSTRUCTION_LENGTH)           \
     COMP(0, 0, W_32, VMX_TPR_THRESHOLD)                      \
     COMP(0, 0, W_32, VMX_CR3_TARGET_COUNT)                   \
     COMP(0, 0, W_32, VMX_PREEMPTION_TIMER)                   \
     COMP(0, 0, W_32, VMX_INSTRUCTION_ERROR_CODE)             \
     COMP(0, 0, W_32, VM_EXIT_INFO_REASON)                    \
-    COMP(0, 0, W_32, VM_EXIT_INFO_INTERRUPT_INFO)            \
-    COMP(0, 0, W_32, VM_EXIT_INFO_EXCEPTION_ERROR_CODE)      \
-    COMP(0, 0, W_32, VM_EXIT_INFO_IDT_VECTORING)             \
+    COMP(1, 0, W_32, VM_EXIT_INFO_INTERRUPT_INFO)            \
+    COMP(1, 0, W_32, VM_EXIT_INFO_EXCEPTION_ERROR_CODE)      \
+    COMP(1, 0, W_32, VM_EXIT_INFO_IDT_VECTORING)             \
     COMP(0, 0, W_32, VM_EXIT_INFO_IDT_VECTORING_ERROR_CODE)  \
-    COMP(0, 0, W_32, VM_EXIT_INFO_INSTRUCTION_LENGTH)        \
+    COMP(1, 0, W_32, VM_EXIT_INFO_INSTRUCTION_LENGTH)        \
     COMP(0, 0, W_32, VM_EXIT_INFO_INSTRUCTION_INFO)          \
     COMP(0, 0, W_32, HOST_SYSENTER_CS)                       \
     COMP(0, 0, W_32, GUEST_ES_AR)                            \
@@ -880,18 +880,12 @@ struct vcpu_vmx_data {
     uint32_t entry_exception_vector;
     uint32_t entry_exception_error_code;
 
-    uint32_t exit_exception_error_code;
-    interruption_info_t exit_intr_info;
     interruption_info_t entry_intr_info;
-    uint32_t exit_idt_vectoring;
-    uint32_t exit_instr_length;
     uint32_t entry_instr_length;
 
     exit_reason_t exit_reason;
     exit_qualification_t exit_qualification;
     interruptibility_state_t interruptibility_state;
-
-    uint64_t exit_gpa;
 };
 
 vmx_result_t ASMCALL asm_invept(uint type, struct invept_desc *desc);
@@ -946,11 +940,12 @@ void vmx_vmwrite(struct vcpu_t *vcpu, const char *name,
     static inline void vmcs_write_##name(struct vcpu_vmx_data* vcpu_vmx,      \
                                          COMP_TYPE_##width value) {           \
         vcpu_vmx->vmcs.name##_value = value;                                  \
-        vcpu_vmx->vmcs_cache_r.name##_cache = 1;                              \
+        /*vcpu_vmx->vmcs_cache_r.name##_cache = 1;*/                          \
         vcpu_vmx->vmcs_cache_w.name##_dirty = 1;                              \
+        vcpu_vmx->vmcs_cache_w.dirty = 1;                                     \
     }
 
-  // Declarations
+// Declarations
 #define COMP_R(cache_r, cache_w, width, name) \
     COMP_R_##cache_r(width, name);
 #define COMP_W(cache_r, cache_w, width, name) \
@@ -970,7 +965,7 @@ VMCS_COMPS
 #define vmcs_write(vcpu, name, value) \
     vmcs_write_##name(&vcpu->vmx, value)
 
-void vmcs_write_pending(struct vcpu_t *vcpu);
+void vcpu_handle_vmcs_pending(struct vcpu_t *vcpu);
 
 #define VMREAD_SEG(vcpu, seg, val)                                 \
         ((val).selector = vmread(vcpu, GUEST_##seg##_SELECTOR),    \

core/intr_exc.c

@@ -137,7 +137,7 @@ uint hax_intr_is_blocked(struct vcpu_t *vcpu)
 void hax_handle_idt_vectoring(struct vcpu_t *vcpu)
 {
     uint8_t vector;
-    uint32_t idt_vec = vmread(vcpu, VM_EXIT_INFO_IDT_VECTORING);
+    uint32_t idt_vec = vmcs_read(vcpu, VM_EXIT_INFO_IDT_VECTORING);
 
     if (idt_vec & 0x80000000) {
         if (!(idt_vec & 0x700)) {
@@ -147,9 +147,9 @@ void hax_handle_idt_vectoring(struct vcpu_t *vcpu)
             hax_debug("extern interrupt is vectoring....vector:%d\n", vector);
         } else {
             hax_debug("VM Exit @ IDT vectoring, type:%d, vector:%d,"
-                      " error code:%llx\n",
+                      " error code:%x\n",
                       (idt_vec & 0x700) >> 8, idt_vec & 0xff,
-                      vmread(vcpu, VM_EXIT_INFO_IDT_VECTORING_ERROR_CODE));
+                      vmcs_read(vcpu, VM_EXIT_INFO_IDT_VECTORING_ERROR_CODE));
         }
     }
 }
@@ -198,8 +198,8 @@ void hax_inject_exception(struct vcpu_t *vcpu, uint8_t vector, uint32_t error_co
 {
     uint32_t intr_info = 0;
     uint8_t first_vec;
-    uint32_t vect_info = vmx(vcpu, exit_idt_vectoring);
-    uint32_t exit_instr_length = vmx(vcpu, exit_instr_length);
+    uint32_t vect_info = vmcs_read(vcpu, VM_EXIT_INFO_IDT_VECTORING);
+    uint32_t exit_instr_length = vmcs_read(vcpu, VM_EXIT_INFO_INSTRUCTION_LENGTH);
 
     if (vcpu->event_injected == 1)
         hax_debug("Event is injected already!!:\n");
@@ -218,20 +218,16 @@ void hax_inject_exception(struct vcpu_t *vcpu, uint8_t vector, uint32_t error_co
         if (error_code != NO_ERROR_CODE) {
             intr_info |= 1 << 11;
             if (vector == VECTOR_PF) {
-                vcpu->vmcs_pending_entry_error_code = 1;
-                vmx(vcpu, entry_exception_error_code) = error_code;
+                vmcs_write(vcpu, VMX_ENTRY_EXCEPTION_ERROR_CODE, error_code);
             } else {
                 vmwrite(vcpu, VMX_ENTRY_EXCEPTION_ERROR_CODE, error_code);
             }
         }
     }
 
     if (vector == VECTOR_PF) {
-        vcpu->vmcs_pending_entry_instr_length = 1;
-        vmx(vcpu, entry_instr_length) = exit_instr_length;
-        vcpu->vmcs_pending_entry_intr_info = 1;
-        vmx(vcpu, entry_intr_info).raw = intr_info;
-        vcpu->vmcs_pending = 1;
+        vmcs_write(vcpu, VMX_ENTRY_INSTRUCTION_LENGTH, exit_instr_length);
+        vmcs_write(vcpu, VMX_ENTRY_INTERRUPT_INFO, intr_info);
     } else {
         vmwrite(vcpu, VMX_ENTRY_INSTRUCTION_LENGTH, exit_instr_length);
         vmwrite(vcpu, VMX_ENTRY_INTERRUPT_INFO, intr_info);

core/vcpu.c

@@ -1748,7 +1748,7 @@ static void advance_rip(struct vcpu_t *vcpu)
         vcpu->interruptibility_dirty = 1;
     }
 
-    state->_rip += vmx(vcpu, exit_instr_length);
+    state->_rip += vmcs_read(vcpu, VM_EXIT_INFO_INSTRUCTION_LENGTH);
     vcpu->rip_dirty = 1;
 }
 
@@ -2092,6 +2092,7 @@ static int vcpu_emulate_insn(struct vcpu_t *vcpu)
     em_mode_t mode;
     em_context_t *em_ctxt = &vcpu->emulate_ctxt;
     uint8_t instr[INSTR_MAX_LEN] = {0};
+    uint32_t exit_instr_length = vmcs_read(vcpu, VM_EXIT_INFO_INSTRUCTION_LENGTH);
     uint64_t cs_base = vcpu->state->_cs.base;
     uint64_t rip = vcpu->state->_rip;
     uint64_t va;
@@ -2138,25 +2139,25 @@ static int vcpu_emulate_insn(struct vcpu_t *vcpu)
         hax_panic_vcpu(vcpu, "em_decode_insn() failed: vcpu_id=%u,"
                        " len=%u, CS:IP=0x%llx:0x%llx, instr[0..5]="
                        "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", vcpu->vcpu_id,
-                       vcpu->vmx.exit_instr_length, cs_base, rip, instr[0],
-                       instr[1], instr[2], instr[3], instr[4], instr[5]);
+                       exit_instr_length, cs_base, rip, instr[0], instr[1],
+                       instr[2], instr[3], instr[4], instr[5]);
         dump_vmcs(vcpu);
         return HAX_RESUME;
     }
-    if (em_ctxt->len != vcpu->vmx.exit_instr_length) {
+    if (em_ctxt->len != exit_instr_length) {
         hax_debug("Inferred instruction length %u does not match VM-exit"
                   " instruction length %u (CS:IP=0x%llx:0x%llx, instr[0..5]="
                   "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x)\n", em_ctxt->len,
-                  vcpu->vmx.exit_instr_length, cs_base, rip, instr[0], instr[1],
+                  exit_instr_length, cs_base, rip, instr[0], instr[1],
                   instr[2], instr[3], instr[4], instr[5]);
     }
     rc = em_emulate_insn(em_ctxt);
     if (rc < 0) {
         hax_panic_vcpu(vcpu, "em_emulate_insn() failed: vcpu_id=%u,"
                        " len=%u, CS:IP=0x%llx:0x%llx, instr[0..5]="
                        "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", vcpu->vcpu_id,
-                       vcpu->vmx.exit_instr_length, cs_base, rip, instr[0],
-                       instr[1], instr[2], instr[3], instr[4], instr[5]);
+                       exit_instr_length, cs_base, rip, instr[0], instr[1],
+                       instr[2], instr[3], instr[4], instr[5]);
         dump_vmcs(vcpu);
         return HAX_RESUME;
     }
@@ -2233,7 +2234,7 @@ static em_status_t vcpu_read_memory(void *obj, uint64_t ea, uint64_t *value,
     uint64_t pa;
 
     if (flags & EM_OPS_NO_TRANSLATION) {
-        pa = vmx(vcpu, exit_gpa);
+        pa = vmcs_read(vcpu, VM_EXIT_INFO_GUEST_PHYSICAL_ADDRESS);
     } else {
         vcpu_translate(vcpu, ea, 0, &pa, NULL, false);
     }
@@ -2271,7 +2272,7 @@ static em_status_t vcpu_write_memory(void *obj, uint64_t ea, uint64_t *value,
     uint64_t pa;
 
     if (flags & EM_OPS_NO_TRANSLATION) {
-        pa = vmx(vcpu, exit_gpa);
+        pa = vmcs_read(vcpu, VM_EXIT_INFO_GUEST_PHYSICAL_ADDRESS);
     } else {
         vcpu_translate(vcpu, ea, 0, &pa, NULL, false);
     }
@@ -2321,7 +2322,7 @@ static int exit_exc_nmi(struct vcpu_t *vcpu, struct hax_tunnel *htun)
     struct vcpu_state_t *state = vcpu->state;
     interruption_info_t exit_intr_info;
 
-    exit_intr_info.raw = vmx(vcpu, exit_intr_info).raw;
+    exit_intr_info.raw = vmcs_read(vcpu, VM_EXIT_INFO_INTERRUPT_INFO);
     htun->_exit_reason = vmx(vcpu, exit_reason).basic_reason;
     hax_debug("exception vmexit vector:%x\n", exit_intr_info.vector);
 
@@ -3680,7 +3681,7 @@ static int exit_ept_misconfiguration(struct vcpu_t *vcpu,
 
     htun->_exit_reason = vmx(vcpu, exit_reason).basic_reason;
 #ifdef CONFIG_HAX_EPT2
-    gpa = vmx(vcpu, exit_gpa);
+    gpa = vmcs_read(vcpu, VM_EXIT_INFO_GUEST_PHYSICAL_ADDRESS);
     ret = ept_handle_misconfiguration(&vcpu->vm->gpa_space, &vcpu->vm->ept_tree,
                                       gpa);
     if (ret > 0) {
@@ -3712,7 +3713,7 @@ static int exit_ept_violation(struct vcpu_t *vcpu, struct hax_tunnel *htun)
         return HAX_RESUME;
     }
 
-    gpa = vmx(vcpu, exit_gpa);
+    gpa = vmcs_read(vcpu, VM_EXIT_INFO_GUEST_PHYSICAL_ADDRESS);
 
 #ifdef CONFIG_HAX_EPT2
     ret = ept_handle_access_violation(&vcpu->vm->gpa_space, &vcpu->vm->ept_tree,
@@ -3736,7 +3737,8 @@ static int exit_ept_violation(struct vcpu_t *vcpu, struct hax_tunnel *htun)
          * TODO: Handle this case properly.
          */
         hax_warning("%s: Unexpected EPT violation cause. Skipping instruction"
-                    " (len=%u)\n", __func__, vcpu->vmx.exit_instr_length);
+                    " (len=%u)\n", __func__,
+                    vmcs_read(vcpu, VM_EXIT_INFO_INSTRUCTION_LENGTH));
         advance_rip(vcpu);
         return HAX_EXIT;
     }

core/vmx.c

@@ -35,6 +35,7 @@
 #include "include/hax_core_interface.h"
 #include "include/ia32.h"
 #include "include/ia32_defs.h"
+#include "include/vtlb.h"
 
 static void _vmx_vmwrite(struct vcpu_t *vcpu, const char *name,
                          component_index_t component,
@@ -304,12 +305,17 @@ void get_interruption_info_t(interruption_info_t *info, uint8_t v, uint8_t t)
 #define COMP_PENDING(cache_r, cache_w, width, name) \
     COMP_PENDING_##cache_w(name)
 
-void vmcs_write_pending(struct vcpu_t* vcpu)
+void vcpu_handle_vmcs_pending(struct vcpu_t* vcpu)
 {
     if (!vcpu || !vcpu->vmx.vmcs_cache_w.dirty)
         return;
 
 #define COMP COMP_PENDING
     VMCS_COMPS
 #undef COMP
+    if (vcpu->vmcs_pending_guest_cr3) {
+        vmwrite(vcpu, GUEST_CR3, vtlb_get_cr3(vcpu));
+        vcpu->vmcs_pending_guest_cr3 = 0;
+    }
+    vcpu->vmx.vmcs_cache_w.dirty = 0;
 }

core/vtlb.c

@@ -781,7 +781,7 @@ static uint32_t vcpu_mmu_walk(struct vcpu_t *vcpu, hax_vaddr_t va, uint32_t acce
 
 bool handle_vtlb(struct vcpu_t *vcpu)
 {
-    uint32_t access = vmx(vcpu, exit_exception_error_code);
+    uint32_t access = vmcs_read(vcpu, VM_EXIT_INFO_EXCEPTION_ERROR_CODE);
     pagemode_t mode = vcpu_get_pagemode(vcpu);
     hax_paddr_t pdir = vcpu->state->_cr3 & (mode == PM_PAE ? ~0x1fULL : ~0xfffULL);
     hax_vaddr_t cr2 = vmx(vcpu, exit_qualification).address;