x86/vmx: align with Linux kernel VMX definitions
cover x86/vmx: align with Linux kernel VMX definitions
This series modernizes VMX definitions to align with the canonical ones within Linux kernel source. Currently, kvm-unit-tests uses custom VMX constant definitions that have grown organically and have diverged from the kernel, increasing the overhead to grok from one code base to another.
This alignment provides several benefits:
- Reduces maintenance overhead by using authoritative definitions
- Eliminates potential bugs from definition mismatches
- Makes the test suite more consistent with kernel code
- Simplifies future updates when new VMX features are added
Given the lines touched, I've broken this up into two groups within the series:
Group 1: Import various headers from Linux kernel 6.16 (P01-04)
Headers were brought in with minimal adaptation outside of minor tweaks for includes, etc.
Group 2: Mechanically replace existing constants with equivalents (P05-17)
Replace custom VMX constant definitions in x86/vmx.h with Linux kernel equivalents from lib/linux/vmx.h. This systematic replacement covers:
- Pin-based VM-execution controls (PIN_* -> PIN_BASED_*)
- CPU-based VM-execution controls (CPU_* -> CPU_BASED_*, SECONDARY_EXEC_*)
- VM-exit controls (EXI_* -> VM_EXIT_*)
- VM-entry controls (ENT_* -> VM_ENTRY_*)
- VMCS field names (custom enum -> standard Linux enum)
- VMX exit reasons (VMX_* -> EXIT_REASON_*)
- Interrupt/exception type definitions
All functional behavior is preserved - only the constant names and values change to match Linux kernel definitions. All existing VMX tests pass with no functional changes.
There is still a bit of bulk in x86/vmx.h, which can be addressed in future patches as needed.
Jon Kohler (17):
lib: add linux vmx.h clone from 6.16
lib: add linux trapnr.h clone from 6.16
lib: add vmxfeatures.h clone from 6.16
lib: define __aligned() in compiler.h
x86/vmx: basic integration for new vmx.h
x86/vmx: switch to new vmx.h EPT violation defs x86/vmx: switch to new vmx.h EPT RWX defs
x86/vmx: switch to new vmx.h EPT access and dirty defs x86/vmx: switch to new vmx.h EPT capability and memory type defs x86/vmx: switch to new vmx.h primary processor-based VM-execution
controls
x86/vmx: switch to new vmx.h secondary execution control bit x86/vmx: switch to new vmx.h secondary execution controls x86/vmx: switch to new vmx.h pin based VM-execution controls x86/vmx: switch to new vmx.h exit controls
x86/vmx: switch to new vmx.h entry controls
x86/vmx: switch to new vmx.h interrupt defs
x86/vmx: align exit reasons with Linux uapi
lib/linux/compiler.h | 1 + lib/linux/trapnr.h | 44 ++ lib/linux/vmx.h | 672 ++++++++++++++++++ lib/linux/vmxfeatures.h | 93 +++ lib/x86/msr.h | 14 + x86/vmx.c | 230 +++--- x86/vmx.h | 356 ++-------- x86/vmx_tests.c | 1489 ++++++++++++++++++++++----------------- 8 files changed, 1876 insertions(+), 1023 deletions(-) create mode 100644 lib/linux/trapnr.h create mode 100644 lib/linux/vmx.h create mode 100644 lib/linux/vmxfeatures.h
base-commit: 890498d834b68104e79b57a801fa11fc6ce82846
Signature · 1 line
2.43.0
PATCH 1/17 lib: add linux vmx.h clone from 6.16
Add Linux's arch/x86/include/asm/vmx.h from [1] into lib/linux/vmx.h.
This copy will replace most (if not all) of the existing vmx.h in follow up commits, and will allow kvm-unit-tests to be directly aligned with how Linux defines vmx.h.
[1] e6a8578 ("KVM: TDX: Detect unexpected SEPT violations due to pending SPTEs")
--- lib/linux/vmx.h | 672 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 672 insertions(+) create mode 100644 lib/linux/vmx.h
lib/linux/vmx.h new file +672 -0
@@ -0,0 +1,672 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* vmx.h: VMX Architecture related definitions +* Copyright (c) 2004, Intel Corporation. +* +* A few random additions are: +* Copyright (C) 2006 Qumranet +* Avi Kivity <[email protected]> +* Yaniv Kamay <[email protected]> +*/ +#ifndef VMX_H +#define VMX_H + + +#include <linux/bitops.h> +#include <linux/bug.h> +#include <linux/types.h> + +#include <uapi/asm/vmx.h> +#include <asm/trapnr.h> +#include <asm/vmxfeatures.h> + +#define VMCS_CONTROL_BIT (x) BIT(VMX_FEATURE_##x & 0x1f) + +/* +* Definitions of Primary Processor-Based VM-Execution Controls. +*/ +#define CPU_BASED_INTR_WINDOW_EXITING VMCS_CONTROL_BIT(INTR_WINDOW_EXITING) +#define CPU_BASED_USE_TSC_OFFSETTING VMCS_CONTROL_BIT(USE_TSC_OFFSETTING) +#define CPU_BASED_HLT_EXITING VMCS_CONTROL_BIT(HLT_EXITING) +#define CPU_BASED_INVLPG_EXITING VMCS_CONTROL_BIT(INVLPG_EXITING) +#define CPU_BASED_MWAIT_EXITING VMCS_CONTROL_BIT(MWAIT_EXITING) +#define CPU_BASED_RDPMC_EXITING VMCS_CONTROL_BIT(RDPMC_EXITING) +#define CPU_BASED_RDTSC_EXITING VMCS_CONTROL_BIT(RDTSC_EXITING) +#define CPU_BASED_CR3_LOAD_EXITING VMCS_CONTROL_BIT(CR3_LOAD_EXITING) +#define CPU_BASED_CR3_STORE_EXITING VMCS_CONTROL_BIT(CR3_STORE_EXITING) +#define CPU_BASED_ACTIVATE_TERTIARY_CONTROLS VMCS_CONTROL_BIT(TERTIARY_CONTROLS) +#define CPU_BASED_CR8_LOAD_EXITING VMCS_CONTROL_BIT(CR8_LOAD_EXITING) +#define CPU_BASED_CR8_STORE_EXITING VMCS_CONTROL_BIT(CR8_STORE_EXITING) +#define CPU_BASED_TPR_SHADOW VMCS_CONTROL_BIT(VIRTUAL_TPR) +#define CPU_BASED_NMI_WINDOW_EXITING VMCS_CONTROL_BIT(NMI_WINDOW_EXITING) +#define CPU_BASED_MOV_DR_EXITING VMCS_CONTROL_BIT(MOV_DR_EXITING) +#define CPU_BASED_UNCOND_IO_EXITING VMCS_CONTROL_BIT(UNCOND_IO_EXITING) +#define CPU_BASED_USE_IO_BITMAPS VMCS_CONTROL_BIT(USE_IO_BITMAPS) +#define CPU_BASED_MONITOR_TRAP_FLAG VMCS_CONTROL_BIT(MONITOR_TRAP_FLAG) +#define CPU_BASED_USE_MSR_BITMAPS VMCS_CONTROL_BIT(USE_MSR_BITMAPS) +#define CPU_BASED_MONITOR_EXITING VMCS_CONTROL_BIT(MONITOR_EXITING) +#define CPU_BASED_PAUSE_EXITING VMCS_CONTROL_BIT(PAUSE_EXITING) +#define CPU_BASED_ACTIVATE_SECONDARY_CONTROLS VMCS_CONTROL_BIT(SEC_CONTROLS) + +#define CPU_BASED_ALWAYSON_WITHOUT_TRUE_MSR 0x0401e172 + +/* +* Definitions of Secondary Processor-Based VM-Execution Controls. +*/ +#define SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES VMCS_CONTROL_BIT(VIRT_APIC_ACCESSES) +#define SECONDARY_EXEC_ENABLE_EPT VMCS_CONTROL_BIT(EPT) +#define SECONDARY_EXEC_DESC VMCS_CONTROL_BIT(DESC_EXITING) +#define SECONDARY_EXEC_ENABLE_RDTSCP VMCS_CONTROL_BIT(RDTSCP) +#define SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE VMCS_CONTROL_BIT(VIRTUAL_X2APIC) +#define SECONDARY_EXEC_ENABLE_VPID VMCS_CONTROL_BIT(VPID) +#define SECONDARY_EXEC_WBINVD_EXITING VMCS_CONTROL_BIT(WBINVD_EXITING) +#define SECONDARY_EXEC_UNRESTRICTED_GUEST VMCS_CONTROL_BIT(UNRESTRICTED_GUEST) +#define SECONDARY_EXEC_APIC_REGISTER_VIRT VMCS_CONTROL_BIT(APIC_REGISTER_VIRT) +#define SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY VMCS_CONTROL_BIT(VIRT_INTR_DELIVERY) +#define SECONDARY_EXEC_PAUSE_LOOP_EXITING VMCS_CONTROL_BIT(PAUSE_LOOP_EXITING) +#define SECONDARY_EXEC_RDRAND_EXITING VMCS_CONTROL_BIT(RDRAND_EXITING) +#define SECONDARY_EXEC_ENABLE_INVPCID VMCS_CONTROL_BIT(INVPCID) +#define SECONDARY_EXEC_ENABLE_VMFUNC VMCS_CONTROL_BIT(VMFUNC) +#define SECONDARY_EXEC_SHADOW_VMCS VMCS_CONTROL_BIT(SHADOW_VMCS) +#define SECONDARY_EXEC_ENCLS_EXITING VMCS_CONTROL_BIT(ENCLS_EXITING) +#define SECONDARY_EXEC_RDSEED_EXITING VMCS_CONTROL_BIT(RDSEED_EXITING) +#define SECONDARY_EXEC_ENABLE_PML VMCS_CONTROL_BIT(PAGE_MOD_LOGGING) +#define SECONDARY_EXEC_EPT_VIOLATION_VE VMCS_CONTROL_BIT(EPT_VIOLATION_VE) +#define SECONDARY_EXEC_PT_CONCEAL_VMX VMCS_CONTROL_BIT(PT_CONCEAL_VMX) +#define SECONDARY_EXEC_ENABLE_XSAVES VMCS_CONTROL_BIT(XSAVES) +#define SECONDARY_EXEC_MODE_BASED_EPT_EXEC VMCS_CONTROL_BIT(MODE_BASED_EPT_EXEC) +#define SECONDARY_EXEC_PT_USE_GPA VMCS_CONTROL_BIT(PT_USE_GPA) +#define SECONDARY_EXEC_TSC_SCALING VMCS_CONTROL_BIT(TSC_SCALING) +#define SECONDARY_EXEC_ENABLE_USR_WAIT_PAUSE VMCS_CONTROL_BIT(USR_WAIT_PAUSE) +#define SECONDARY_EXEC_BUS_LOCK_DETECTION VMCS_CONTROL_BIT(BUS_LOCK_DETECTION) +#define SECONDARY_EXEC_NOTIFY_VM_EXITING VMCS_CONTROL_BIT(NOTIFY_VM_EXITING) + +/* +* Definitions of Tertiary Processor-Based VM-Execution Controls. +*/ +#define TERTIARY_EXEC_IPI_VIRT VMCS_CONTROL_BIT(IPI_VIRT) + +#define PIN_BASED_EXT_INTR_MASK VMCS_CONTROL_BIT(INTR_EXITING) +#define PIN_BASED_NMI_EXITING VMCS_CONTROL_BIT(NMI_EXITING) +#define PIN_BASED_VIRTUAL_NMIS VMCS_CONTROL_BIT(VIRTUAL_NMIS) +#define PIN_BASED_VMX_PREEMPTION_TIMER VMCS_CONTROL_BIT(PREEMPTION_TIMER) +#define PIN_BASED_POSTED_INTR VMCS_CONTROL_BIT(POSTED_INTR) + +#define PIN_BASED_ALWAYSON_WITHOUT_TRUE_MSR 0x00000016 + +#define VM_EXIT_SAVE_DEBUG_CONTROLS 0x00000004 +#define VM_EXIT_HOST_ADDR_SPACE_SIZE 0x00000200 +#define VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL 0x00001000 +#define VM_EXIT_ACK_INTR_ON_EXIT 0x00008000 +#define VM_EXIT_SAVE_IA32_PAT 0x00040000 +#define VM_EXIT_LOAD_IA32_PAT 0x00080000 +#define VM_EXIT_SAVE_IA32_EFER 0x00100000 +#define VM_EXIT_LOAD_IA32_EFER 0x00200000 +#define VM_EXIT_SAVE_VMX_PREEMPTION_TIMER 0x00400000 +#define VM_EXIT_CLEAR_BNDCFGS 0x00800000 +#define VM_EXIT_PT_CONCEAL_PIP 0x01000000 +#define VM_EXIT_CLEAR_IA32_RTIT_CTL 0x02000000 + +#define VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR 0x00036dff + +#define VM_ENTRY_LOAD_DEBUG_CONTROLS 0x00000004 +#define VM_ENTRY_IA32E_MODE 0x00000200 +#define VM_ENTRY_SMM 0x00000400 +#define VM_ENTRY_DEACT_DUAL_MONITOR 0x00000800 +#define VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL 0x00002000 +#define VM_ENTRY_LOAD_IA32_PAT 0x00004000 +#define VM_ENTRY_LOAD_IA32_EFER 0x00008000 +#define VM_ENTRY_LOAD_BNDCFGS 0x00010000 +#define VM_ENTRY_PT_CONCEAL_PIP 0x00020000 +#define VM_ENTRY_LOAD_IA32_RTIT_CTL 0x00040000 + +#define VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR 0x000011ff + +/* VMFUNC functions */ +#define VMFUNC_CONTROL_BIT (x) BIT((VMX_FEATURE_##x & 0x1f) - 28) + +#define VMX_VMFUNC_EPTP_SWITCHING VMFUNC_CONTROL_BIT(EPTP_SWITCHING) +#define VMFUNC_EPTP_ENTRIES 512 + +#define VMX_BASIC_32BIT_PHYS_ADDR_ONLY BIT_ULL(48) +#define VMX_BASIC_DUAL_MONITOR_TREATMENT BIT_ULL(49) +#define VMX_BASIC_INOUT BIT_ULL(54) +#define VMX_BASIC_TRUE_CTLS BIT_ULL(55) + +static inline u32 vmx_basic_vmcs_revision_id (u64 vmx_basic) +{ +return vmx_basic &GENMASK_ULL (30 ,0 ); +} + +static inline u32 vmx_basic_vmcs_size (u64 vmx_basic) +{ +return (vmx_basic &GENMASK_ULL (44 ,32 )) >>32 ; +} + +static inline u32 vmx_basic_vmcs_mem_type (u64 vmx_basic) +{ +return (vmx_basic &GENMASK_ULL (53 ,50 )) >>50 ; +} + +static inline u64 vmx_basic_encode_vmcs_info (u32 revision,u16 size,u8 memtype) +{ +return revision | ((u64 )size <<32 ) | ((u64 )memtype <<50 ); +} + +#define VMX_MISC_SAVE_EFER_LMA BIT_ULL(5) +#define VMX_MISC_ACTIVITY_HLT BIT_ULL(6) +#define VMX_MISC_ACTIVITY_SHUTDOWN BIT_ULL(7) +#define VMX_MISC_ACTIVITY_WAIT_SIPI BIT_ULL(8) +#define VMX_MISC_INTEL_PT BIT_ULL(14) +#define VMX_MISC_RDMSR_IN_SMM BIT_ULL(15) +#define VMX_MISC_VMXOFF_BLOCK_SMI BIT_ULL(28) +#define VMX_MISC_VMWRITE_SHADOW_RO_FIELDS BIT_ULL(29) +#define VMX_MISC_ZERO_LEN_INS BIT_ULL(30) +#define VMX_MISC_MSR_LIST_MULTIPLIER 512 + +static inline int vmx_misc_preemption_timer_rate (u64 vmx_misc) +{ +return vmx_misc &GENMASK_ULL (4 ,0 ); +} + +static inline int vmx_misc_cr3_count (u64 vmx_misc) +{ +return (vmx_misc &GENMASK_ULL (24 ,16 )) >>16 ; +} + +static inline int vmx_misc_max_msr (u64 vmx_misc) +{ +return (vmx_misc &GENMASK_ULL (27 ,25 )) >>25 ; +} + +static inline int vmx_misc_mseg_revid (u64 vmx_misc) +{ +return (vmx_misc &GENMASK_ULL (63 ,32 )) >>32 ; +} + +/* VMCS Encodings */ +enum vmcs_field { +VIRTUAL_PROCESSOR_ID =0x00000000 , +POSTED_INTR_NV =0x00000002 , +LAST_PID_POINTER_INDEX =0x00000008 , +GUEST_ES_SELECTOR =0x00000800 , +GUEST_CS_SELECTOR =0x00000802 , +GUEST_SS_SELECTOR =0x00000804 , +GUEST_DS_SELECTOR =0x00000806 , +GUEST_FS_SELECTOR =0x00000808 , +GUEST_GS_SELECTOR =0x0000080a , +GUEST_LDTR_SELECTOR =0x0000080c , +GUEST_TR_SELECTOR =0x0000080e , +GUEST_INTR_STATUS =0x00000810 , +GUEST_PML_INDEX =0x00000812 , +HOST_ES_SELECTOR =0x00000c00 , +HOST_CS_SELECTOR =0x00000c02 , +HOST_SS_SELECTOR =0x00000c04 , +HOST_DS_SELECTOR =0x00000c06 , +HOST_FS_SELECTOR =0x00000c08 , +HOST_GS_SELECTOR =0x00000c0a , +HOST_TR_SELECTOR =0x00000c0c , +IO_BITMAP_A =0x00002000 , +IO_BITMAP_A_HIGH =0x00002001 , +IO_BITMAP_B =0x00002002 , +IO_BITMAP_B_HIGH =0x00002003 , +MSR_BITMAP =0x00002004 , +MSR_BITMAP_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 , +PML_ADDRESS =0x0000200e , +PML_ADDRESS_HIGH =0x0000200f , +TSC_OFFSET =0x00002010 , +TSC_OFFSET_HIGH =0x00002011 , +VIRTUAL_APIC_PAGE_ADDR =0x00002012 , +VIRTUAL_APIC_PAGE_ADDR_HIGH =0x00002013 , +APIC_ACCESS_ADDR =0x00002014 , +APIC_ACCESS_ADDR_HIGH =0x00002015 , +POSTED_INTR_DESC_ADDR =0x00002016 , +POSTED_INTR_DESC_ADDR_HIGH =0x00002017 , +VM_FUNCTION_CONTROL =0x00002018 , +VM_FUNCTION_CONTROL_HIGH =0x00002019 , +EPT_POINTER =0x0000201a , +EPT_POINTER_HIGH =0x0000201b , +EOI_EXIT_BITMAP0 =0x0000201c , +EOI_EXIT_BITMAP0_HIGH =0x0000201d , +EOI_EXIT_BITMAP1 =0x0000201e , +EOI_EXIT_BITMAP1_HIGH =0x0000201f , +EOI_EXIT_BITMAP2 =0x00002020 , +EOI_EXIT_BITMAP2_HIGH =0x00002021 , +EOI_EXIT_BITMAP3 =0x00002022 , +EOI_EXIT_BITMAP3_HIGH =0x00002023 , +EPTP_LIST_ADDRESS =0x00002024 , +EPTP_LIST_ADDRESS_HIGH =0x00002025 , +VMREAD_BITMAP =0x00002026 , +VMREAD_BITMAP_HIGH =0x00002027 , +VMWRITE_BITMAP =0x00002028 , +VMWRITE_BITMAP_HIGH =0x00002029 , +VE_INFORMATION_ADDRESS =0x0000202A , +VE_INFORMATION_ADDRESS_HIGH =0x0000202B , +XSS_EXIT_BITMAP =0x0000202C , +XSS_EXIT_BITMAP_HIGH =0x0000202D , +ENCLS_EXITING_BITMAP =0x0000202E , +ENCLS_EXITING_BITMAP_HIGH =0x0000202F , +TSC_MULTIPLIER =0x00002032 , +TSC_MULTIPLIER_HIGH =0x00002033 , +TERTIARY_VM_EXEC_CONTROL =0x00002034 , +TERTIARY_VM_EXEC_CONTROL_HIGH =0x00002035 , +SHARED_EPT_POINTER =0x0000203C , +PID_POINTER_TABLE =0x00002042 , +PID_POINTER_TABLE_HIGH =0x00002043 , +GUEST_PHYSICAL_ADDRESS =0x00002400 , +GUEST_PHYSICAL_ADDRESS_HIGH =0x00002401 , +VMCS_LINK_POINTER =0x00002800 , +VMCS_LINK_POINTER_HIGH =0x00002801 , +GUEST_IA32_DEBUGCTL =0x00002802 , +GUEST_IA32_DEBUGCTL_HIGH =0x00002803 , +GUEST_IA32_PAT =0x00002804 , +GUEST_IA32_PAT_HIGH =0x00002805 , +GUEST_IA32_EFER =0x00002806 , +GUEST_IA32_EFER_HIGH =0x00002807 , +GUEST_IA32_PERF_GLOBAL_CTRL =0x00002808 , +GUEST_IA32_PERF_GLOBAL_CTRL_HIGH =0x00002809 , +GUEST_PDPTR0 =0x0000280a , +GUEST_PDPTR0_HIGH =0x0000280b , +GUEST_PDPTR1 =0x0000280c , +GUEST_PDPTR1_HIGH =0x0000280d , +GUEST_PDPTR2 =0x0000280e , +GUEST_PDPTR2_HIGH =0x0000280f , +GUEST_PDPTR3 =0x00002810 , +GUEST_PDPTR3_HIGH =0x00002811 , +GUEST_BNDCFGS =0x00002812 , +GUEST_BNDCFGS_HIGH =0x00002813 , +GUEST_IA32_RTIT_CTL =0x00002814 , +GUEST_IA32_RTIT_CTL_HIGH =0x00002815 , +HOST_IA32_PAT =0x00002c00 , +HOST_IA32_PAT_HIGH =0x00002c01 , +HOST_IA32_EFER =0x00002c02 , +HOST_IA32_EFER_HIGH =0x00002c03 , +HOST_IA32_PERF_GLOBAL_CTRL =0x00002c04 , +HOST_IA32_PERF_GLOBAL_CTRL_HIGH =0x00002c05 , +PIN_BASED_VM_EXEC_CONTROL =0x00004000 , +CPU_BASED_VM_EXEC_CONTROL =0x00004002 , +EXCEPTION_BITMAP =0x00004004 , +PAGE_FAULT_ERROR_CODE_MASK =0x00004006 , +PAGE_FAULT_ERROR_CODE_MATCH =0x00004008 , +CR3_TARGET_COUNT =0x0000400a , +VM_EXIT_CONTROLS =0x0000400c , +VM_EXIT_MSR_STORE_COUNT =0x0000400e , +VM_EXIT_MSR_LOAD_COUNT =0x00004010 , +VM_ENTRY_CONTROLS =0x00004012 , +VM_ENTRY_MSR_LOAD_COUNT =0x00004014 , +VM_ENTRY_INTR_INFO_FIELD =0x00004016 , +VM_ENTRY_EXCEPTION_ERROR_CODE =0x00004018 , +VM_ENTRY_INSTRUCTION_LEN =0x0000401a , +TPR_THRESHOLD =0x0000401c , +SECONDARY_VM_EXEC_CONTROL =0x0000401e , +PLE_GAP =0x00004020 , +PLE_WINDOW =0x00004022 , +NOTIFY_WINDOW =0x00004024 , +VM_INSTRUCTION_ERROR =0x00004400 , +VM_EXIT_REASON =0x00004402 , +VM_EXIT_INTR_INFO =0x00004404 , +VM_EXIT_INTR_ERROR_CODE =0x00004406 , +IDT_VECTORING_INFO_FIELD =0x00004408 , +IDT_VECTORING_ERROR_CODE =0x0000440a , +VM_EXIT_INSTRUCTION_LEN =0x0000440c , +VMX_INSTRUCTION_INFO =0x0000440e , +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_AR_BYTES =0x00004814 , +GUEST_CS_AR_BYTES =0x00004816 , +GUEST_SS_AR_BYTES =0x00004818 , +GUEST_DS_AR_BYTES =0x0000481a , +GUEST_FS_AR_BYTES =0x0000481c , +GUEST_GS_AR_BYTES =0x0000481e , +GUEST_LDTR_AR_BYTES =0x00004820 , +GUEST_TR_AR_BYTES =0x00004822 , +GUEST_INTERRUPTIBILITY_INFO =0x00004824 , +GUEST_ACTIVITY_STATE =0x00004826 , +GUEST_SYSENTER_CS =0x0000482A , +VMX_PREEMPTION_TIMER_VALUE =0x0000482E , +HOST_IA32_SYSENTER_CS =0x00004c00 , +CR0_GUEST_HOST_MASK =0x00006000 , +CR4_GUEST_HOST_MASK =0x00006002 , +CR0_READ_SHADOW =0x00006004 , +CR4_READ_SHADOW =0x00006006 , +CR3_TARGET_VALUE0 =0x00006008 , +CR3_TARGET_VALUE1 =0x0000600a , +CR3_TARGET_VALUE2 =0x0000600c , +CR3_TARGET_VALUE3 =0x0000600e , +EXIT_QUALIFICATION =0x00006400 , +GUEST_LINEAR_ADDRESS =0x0000640a , +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_DBG_EXCEPTIONS =0x00006822 , +GUEST_SYSENTER_ESP =0x00006824 , +GUEST_SYSENTER_EIP =0x00006826 , +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 , +}; + +/* +* Interruption-information format +*/ +#define INTR_INFO_VECTOR_MASK 0xff/* 7:0 */ +#define INTR_INFO_INTR_TYPE_MASK 0x700/* 10:8 */ +#define INTR_INFO_DELIVER_CODE_MASK 0x800/* 11 */ +#define INTR_INFO_UNBLOCK_NMI 0x1000/* 12 */ +#define INTR_INFO_VALID_MASK 0x80000000/* 31 */ +#define INTR_INFO_RESVD_BITS_MASK 0x7ffff000 + +#define VECTORING_INFO_VECTOR_MASK INTR_INFO_VECTOR_MASK +#define VECTORING_INFO_TYPE_MASK INTR_INFO_INTR_TYPE_MASK +#define VECTORING_INFO_DELIVER_CODE_MASK INTR_INFO_DELIVER_CODE_MASK +#define VECTORING_INFO_VALID_MASK INTR_INFO_VALID_MASK + +#define INTR_TYPE_EXT_INTR (EVENT_TYPE_EXTINT << 8)/* external interrupt */ +#define INTR_TYPE_RESERVED (EVENT_TYPE_RESERVED << 8)/* reserved */ +#define INTR_TYPE_NMI_INTR (EVENT_TYPE_NMI << 8)/* NMI */ +#define INTR_TYPE_HARD_EXCEPTION (EVENT_TYPE_HWEXC << 8)/* processor exception */ +#define INTR_TYPE_SOFT_INTR (EVENT_TYPE_SWINT << 8)/* software interrupt */ +#define INTR_TYPE_PRIV_SW_EXCEPTION (EVENT_TYPE_PRIV_SWEXC << 8)/* ICE breakpoint */ +#define INTR_TYPE_SOFT_EXCEPTION (EVENT_TYPE_SWEXC << 8)/* software exception */ +#define INTR_TYPE_OTHER_EVENT (EVENT_TYPE_OTHER << 8)/* other event */ + +/* GUEST_INTERRUPTIBILITY_INFO flags. */ +#define GUEST_INTR_STATE_STI 0x00000001 +#define GUEST_INTR_STATE_MOV_SS 0x00000002 +#define GUEST_INTR_STATE_SMI 0x00000004 +#define GUEST_INTR_STATE_NMI 0x00000008 +#define GUEST_INTR_STATE_ENCLAVE_INTR 0x00000010 + +/* GUEST_ACTIVITY_STATE flags */ +#define GUEST_ACTIVITY_ACTIVE 0 +#define GUEST_ACTIVITY_HLT 1 +#define GUEST_ACTIVITY_SHUTDOWN 2 +#define GUEST_ACTIVITY_WAIT_SIPI 3 + +/* +* Exit Qualifications for MOV for Control Register Access +*/ +#define CONTROL_REG_ACCESS_NUM 0x7/* 2:0, number of control reg.*/ +#define CONTROL_REG_ACCESS_TYPE 0x30/* 5:4, access type */ +#define CONTROL_REG_ACCESS_REG 0xf00/* 10:8, general purpose reg. */ +#define LMSW_SOURCE_DATA_SHIFT 16 +#define LMSW_SOURCE_DATA (0xFFFF << LMSW_SOURCE_DATA_SHIFT)/* 16:31 lmsw source */ +#define REG_EAX (0 << 8) +#define REG_ECX (1 << 8) +#define REG_EDX (2 << 8) +#define REG_EBX (3 << 8) +#define REG_ESP (4 << 8) +#define REG_EBP (5 << 8) +#define REG_ESI (6 << 8) +#define REG_EDI (7 << 8) +#define REG_R8 (8 << 8) +#define REG_R9 (9 << 8) +#define REG_R10 (10 << 8) +#define REG_R11 (11 << 8) +#define REG_R12 (12 << 8) +#define REG_R13 (13 << 8) +#define REG_R14 (14 << 8) +#define REG_R15 (15 << 8) + +/* +* Exit Qualifications for MOV for Debug Register Access +*/ +#define DEBUG_REG_ACCESS_NUM 0x7/* 2:0, number of debug reg. */ +#define DEBUG_REG_ACCESS_TYPE 0x10/* 4, direction of access */ +#define TYPE_MOV_TO_DR (0 << 4) +#define TYPE_MOV_FROM_DR (1 << 4) +#define DEBUG_REG_ACCESS_REG (eq) (((eq) >> 8) & 0xf)/* 11:8, general purpose reg. */ + + +/* +* Exit Qualifications for APIC-Access +*/ +#define APIC_ACCESS_OFFSET 0xfff/* 11:0, offset within the APIC page */ +#define APIC_ACCESS_TYPE 0xf000/* 15:12, access type */ +#define TYPE_LINEAR_APIC_INST_READ (0 << 12) +#define TYPE_LINEAR_APIC_INST_WRITE (1 << 12) +#define TYPE_LINEAR_APIC_INST_FETCH (2 << 12) +#define TYPE_LINEAR_APIC_EVENT (3 << 12) +#define TYPE_PHYSICAL_APIC_EVENT (10 << 12) +#define TYPE_PHYSICAL_APIC_INST (15 << 12) + +/* segment AR in VMCS -- these are different from what LAR reports */ +#define VMX_SEGMENT_AR_L_MASK (1 << 13) + +#define VMX_AR_TYPE_ACCESSES_MASK 1 +#define VMX_AR_TYPE_READABLE_MASK (1 << 1) +#define VMX_AR_TYPE_WRITEABLE_MASK (1 << 2) +#define VMX_AR_TYPE_CODE_MASK (1 << 3) +#define VMX_AR_TYPE_MASK 0x0f +#define VMX_AR_TYPE_BUSY_64_TSS 11 +#define VMX_AR_TYPE_BUSY_32_TSS 11 +#define VMX_AR_TYPE_BUSY_16_TSS 3 +#define VMX_AR_TYPE_LDT 2 + +#define VMX_AR_UNUSABLE_MASK (1 << 16) +#define VMX_AR_S_MASK (1 << 4) +#define VMX_AR_P_MASK (1 << 7) +#define VMX_AR_L_MASK (1 << 13) +#define VMX_AR_DB_MASK (1 << 14) +#define VMX_AR_G_MASK (1 << 15) +#define VMX_AR_DPL_SHIFT 5 +#define VMX_AR_DPL (ar) (((ar) >> VMX_AR_DPL_SHIFT) & 3) + +#define VMX_AR_RESERVD_MASK 0xfffe0f00 + +#define TSS_PRIVATE_MEMSLOT (KVM_USER_MEM_SLOTS + 0) +#define APIC_ACCESS_PAGE_PRIVATE_MEMSLOT (KVM_USER_MEM_SLOTS + 1) +#define IDENTITY_PAGETABLE_PRIVATE_MEMSLOT (KVM_USER_MEM_SLOTS + 2) + +#define VMX_NR_VPIDS (1 << 16) +#define VMX_VPID_EXTENT_INDIVIDUAL_ADDR 0 +#define VMX_VPID_EXTENT_SINGLE_CONTEXT 1 +#define VMX_VPID_EXTENT_ALL_CONTEXT 2 +#define VMX_VPID_EXTENT_SINGLE_NON_GLOBAL 3 + +#define VMX_EPT_EXTENT_CONTEXT 1 +#define VMX_EPT_EXTENT_GLOBAL 2 +#define VMX_EPT_EXTENT_SHIFT 24 + +#define VMX_EPT_EXECUTE_ONLY_BIT (1ull) +#define VMX_EPT_PAGE_WALK_4_BIT (1ull << 6) +#define VMX_EPT_PAGE_WALK_5_BIT (1ull << 7) +#define VMX_EPTP_UC_BIT (1ull << 8) +#define VMX_EPTP_WB_BIT (1ull << 14) +#define VMX_EPT_2MB_PAGE_BIT (1ull << 16) +#define VMX_EPT_1GB_PAGE_BIT (1ull << 17) +#define VMX_EPT_INVEPT_BIT (1ull << 20) +#define VMX_EPT_AD_BIT (1ull << 21) +#define VMX_EPT_EXTENT_CONTEXT_BIT (1ull << 25) +#define VMX_EPT_EXTENT_GLOBAL_BIT (1ull << 26) + +#define VMX_VPID_INVVPID_BIT (1ull << 0)/* (32 - 32) */ +#define VMX_VPID_EXTENT_INDIVIDUAL_ADDR_BIT (1ull << 8)/* (40 - 32) */ +#define VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT (1ull << 9)/* (41 - 32) */ +#define VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT (1ull << 10)/* (42 - 32) */ +#define VMX_VPID_EXTENT_SINGLE_NON_GLOBAL_BIT (1ull << 11)/* (43 - 32) */ + +#define VMX_EPT_MT_EPTE_SHIFT 3 +#define VMX_EPTP_PWL_MASK 0x38ull +#define VMX_EPTP_PWL_4 0x18ull +#define VMX_EPTP_PWL_5 0x20ull +#define VMX_EPTP_AD_ENABLE_BIT (1ull << 6) +/* The EPTP memtype is encoded in bits 2:0, i.e. doesn't need to be shifted. */ +#define VMX_EPTP_MT_MASK 0x7ull +#define VMX_EPTP_MT_WB X86_MEMTYPE_WB +#define VMX_EPTP_MT_UC X86_MEMTYPE_UC +#define VMX_EPT_READABLE_MASK 0x1ull +#define VMX_EPT_WRITABLE_MASK 0x2ull +#define VMX_EPT_EXECUTABLE_MASK 0x4ull +#define VMX_EPT_IPAT_BIT (1ull << 6) +#define VMX_EPT_ACCESS_BIT (1ull << 8) +#define VMX_EPT_DIRTY_BIT (1ull << 9) +#define VMX_EPT_SUPPRESS_VE_BIT (1ull << 63) +#define VMX_EPT_RWX_MASK (VMX_EPT_READABLE_MASK | \ + VMX_EPT_WRITABLE_MASK | \ + VMX_EPT_EXECUTABLE_MASK) +#define VMX_EPT_MT_MASK (7ull << VMX_EPT_MT_EPTE_SHIFT) + +static inline u8 vmx_eptp_page_walk_level (u64 eptp) +{ +u64 encoded_level = eptp &VMX_EPTP_PWL_MASK ; + +if (encoded_level ==VMX_EPTP_PWL_5 ) +return 5 ; + +/* @eptp must be pre-validated by the caller. */ +WARN_ON_ONCE (encoded_level !=VMX_EPTP_PWL_4 ); +return 4 ; +} + +/* The mask to use to trigger an EPT Misconfiguration in order to track MMIO */ +#define VMX_EPT_MISCONFIG_WX_VALUE (VMX_EPT_WRITABLE_MASK | \ + VMX_EPT_EXECUTABLE_MASK) + +#define VMX_EPT_IDENTITY_PAGETABLE_ADDR 0xfffbc000ul + +struct vmx_msr_entry { +u32 index; +u32 reserved; +u64 value; +}__aligned(16) ; + +/* +* Exit Qualifications for entry failure during or after loading guest state +*/ +enum vm_entry_failure_code { +ENTRY_FAIL_DEFAULT =0 , +ENTRY_FAIL_PDPTE =2 , +ENTRY_FAIL_NMI =3 , +ENTRY_FAIL_VMCS_LINK_PTR =4 , +}; + +/* +* Exit Qualifications for EPT Violations +*/ +#define EPT_VIOLATION_ACC_READ BIT(0) +#define EPT_VIOLATION_ACC_WRITE BIT(1) +#define EPT_VIOLATION_ACC_INSTR BIT(2) +#define EPT_VIOLATION_PROT_READ BIT(3) +#define EPT_VIOLATION_PROT_WRITE BIT(4) +#define EPT_VIOLATION_PROT_EXEC BIT(5) +#define EPT_VIOLATION_EXEC_FOR_RING3_LIN BIT(6) +#define EPT_VIOLATION_PROT_MASK (EPT_VIOLATION_PROT_READ | \ + EPT_VIOLATION_PROT_WRITE | \ + EPT_VIOLATION_PROT_EXEC) +#define EPT_VIOLATION_GVA_IS_VALID BIT(7) +#define EPT_VIOLATION_GVA_TRANSLATED BIT(8) + +#define EPT_VIOLATION_RWX_TO_PROT (__epte) (((__epte) & VMX_EPT_RWX_MASK) << 3) + +static_assert (EPT_VIOLATION_RWX_TO_PROT (VMX_EPT_RWX_MASK ) == + (EPT_VIOLATION_PROT_READ |EPT_VIOLATION_PROT_WRITE |EPT_VIOLATION_PROT_EXEC )); + +/* +* Exit Qualifications for NOTIFY VM EXIT +*/ +#define NOTIFY_VM_CONTEXT_INVALID BIT(0) + +/* +* VM-instruction error numbers +*/ +enum vm_instruction_error_number { +VMXERR_VMCALL_IN_VMX_ROOT_OPERATION =1 , +VMXERR_VMCLEAR_INVALID_ADDRESS =2 , +VMXERR_VMCLEAR_VMXON_POINTER =3 , +VMXERR_VMLAUNCH_NONCLEAR_VMCS =4 , +VMXERR_VMRESUME_NONLAUNCHED_VMCS =5 , +VMXERR_VMRESUME_AFTER_VMXOFF =6 , +VMXERR_ENTRY_INVALID_CONTROL_FIELD =7 , +VMXERR_ENTRY_INVALID_HOST_STATE_FIELD =8 , +VMXERR_VMPTRLD_INVALID_ADDRESS =9 , +VMXERR_VMPTRLD_VMXON_POINTER =10 , +VMXERR_VMPTRLD_INCORRECT_VMCS_REVISION_ID =11 , +VMXERR_UNSUPPORTED_VMCS_COMPONENT =12 , +VMXERR_VMWRITE_READ_ONLY_VMCS_COMPONENT =13 , +VMXERR_VMXON_IN_VMX_ROOT_OPERATION =15 , +VMXERR_ENTRY_INVALID_EXECUTIVE_VMCS_POINTER =16 , +VMXERR_ENTRY_NONLAUNCHED_EXECUTIVE_VMCS =17 , +VMXERR_ENTRY_EXECUTIVE_VMCS_POINTER_NOT_VMXON_POINTER =18 , +VMXERR_VMCALL_NONCLEAR_VMCS =19 , +VMXERR_VMCALL_INVALID_VM_EXIT_CONTROL_FIELDS =20 , +VMXERR_VMCALL_INCORRECT_MSEG_REVISION_ID =22 , +VMXERR_VMXOFF_UNDER_DUAL_MONITOR_TREATMENT_OF_SMIS_AND_SMM =23 , +VMXERR_VMCALL_INVALID_SMM_MONITOR_FEATURES =24 , +VMXERR_ENTRY_INVALID_VM_EXECUTION_CONTROL_FIELDS_IN_EXECUTIVE_VMCS =25 , +VMXERR_ENTRY_EVENTS_BLOCKED_BY_MOV_SS =26 , +VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID =28 , +}; + +/* +* VM-instruction errors that can be encountered on VM-Enter, used to trace +* nested VM-Enter failures reported by hardware. Errors unique to VM-Enter +* from a SMI Transfer Monitor are not included as things have gone seriously +* sideways if we get one of those... +*/ +#define VMX_VMENTER_INSTRUCTION_ERRORS \ + { VMXERR_VMLAUNCH_NONCLEAR_VMCS, "VMLAUNCH_NONCLEAR_VMCS" }, \ + { VMXERR_VMRESUME_NONLAUNCHED_VMCS, "VMRESUME_NONLAUNCHED_VMCS" }, \ + { VMXERR_VMRESUME_AFTER_VMXOFF, "VMRESUME_AFTER_VMXOFF" }, \ + { VMXERR_ENTRY_INVALID_CONTROL_FIELD, "VMENTRY_INVALID_CONTROL_FIELD" }, \ + { VMXERR_ENTRY_INVALID_HOST_STATE_FIELD, "VMENTRY_INVALID_HOST_STATE_FIELD" }, \ + { VMXERR_ENTRY_EVENTS_BLOCKED_BY_MOV_SS, "VMENTRY_EVENTS_BLOCKED_BY_MOV_SS" } + +enum vmx_l1d_flush_state { +VMENTER_L1D_FLUSH_AUTO , +VMENTER_L1D_FLUSH_NEVER , +VMENTER_L1D_FLUSH_COND , +VMENTER_L1D_FLUSH_ALWAYS , +VMENTER_L1D_FLUSH_EPT_DISABLED , +VMENTER_L1D_FLUSH_NOT_REQUIRED , +}; + +extern enum vmx_l1d_flush_state l1tf_vmx_mitigation; + +struct vmx_ve_information { +u32 exit_reason; +u32 delivery; +u64 exit_qualification; +u64 guest_linear_address; +u64 guest_physical_address; +u16 eptp_index; +}; + +#endif
Signature · 1 line
2.43.0
PATCH 2/17 lib: add linux trapnr.h clone from 6.16
In reply to Jon KohlerAdd Linux's arch/x86/include/asm/trapnr.h from [1] into lib/linux/trapnr.h, to allow definitions in vmx.h to resolve.
[1] 8df7193 ("x86/trapnr: Add event type macros to <asm/trapnr.h>")
--- lib/linux/trapnr.h | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 lib/linux/trapnr.h
lib/linux/trapnr.h new file +44 -0
@@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_TRAPNR_H +#define _ASM_X86_TRAPNR_H + +/* +* Event type codes used by FRED, Intel VT-x and AMD SVM +*/ +#define EVENT_TYPE_EXTINT 0 // External interrupt +#define EVENT_TYPE_RESERVED 1 +#define EVENT_TYPE_NMI 2 // NMI +#define EVENT_TYPE_HWEXC 3 // Hardware originated traps, exceptions +#define EVENT_TYPE_SWINT 4 // INT n +#define EVENT_TYPE_PRIV_SWEXC 5 // INT1 +#define EVENT_TYPE_SWEXC 6 // INTO, INT3 +#define EVENT_TYPE_OTHER 7 // FRED SYSCALL/SYSENTER, VT-x MTF + +/* Interrupts/Exceptions */ + +#define X86_TRAP_DE 0/* Divide-by-zero */ +#define X86_TRAP_DB 1/* Debug */ +#define X86_TRAP_NMI 2/* Non-maskable Interrupt */ +#define X86_TRAP_BP 3/* Breakpoint */ +#define X86_TRAP_OF 4/* Overflow */ +#define X86_TRAP_BR 5/* Bound Range Exceeded */ +#define X86_TRAP_UD 6/* Invalid Opcode */ +#define X86_TRAP_NM 7/* Device Not Available */ +#define X86_TRAP_DF 8/* Double Fault */ +#define X86_TRAP_OLD_MF 9/* Coprocessor Segment Overrun */ +#define X86_TRAP_TS 10/* Invalid TSS */ +#define X86_TRAP_NP 11/* Segment Not Present */ +#define X86_TRAP_SS 12/* Stack Segment Fault */ +#define X86_TRAP_GP 13/* General Protection Fault */ +#define X86_TRAP_PF 14/* Page Fault */ +#define X86_TRAP_SPURIOUS 15/* Spurious Interrupt */ +#define X86_TRAP_MF 16/* x87 Floating-Point Exception */ +#define X86_TRAP_AC 17/* Alignment Check */ +#define X86_TRAP_MC 18/* Machine Check */ +#define X86_TRAP_XF 19/* SIMD Floating-Point Exception */ +#define X86_TRAP_VE 20/* Virtualization Exception */ +#define X86_TRAP_CP 21/* Control Protection Exception */ +#define X86_TRAP_VC 29/* VMM Communication Exception */ +#define X86_TRAP_IRET 32/* IRET Exception */ + +#endif
Signature · 1 line
2.43.0
PATCH 3/17 lib: add vmxfeatures.h clone from 6.16
In reply to Jon KohlerInclude Linux's arch/x86/include/asm/vmxfeatures.h from [1] into lib/linux/vmxfeatures.h, to allow definitions in vmx.h to resolve.
[1] 78ce84b ("x86/cpufeatures: Flip the /proc/cpuinfo appearance logic")
--- lib/linux/vmxfeatures.h | 93 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 lib/linux/vmxfeatures.h
lib/linux/vmxfeatures.h new file +93 -0
@@ -0,0 +1,93 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_VMXFEATURES_H +#define _ASM_X86_VMXFEATURES_H + +/* +* Defines VMX CPU feature bits +*/ +#define NVMXINTS 5/* N 32-bit words worth of info */ + +/* +* Note: If the comment begins with a quoted string, that string is used +* in /proc/cpuinfo instead of the macro name. Otherwise, this feature bit +* is not displayed in /proc/cpuinfo at all. +*/ + +/* Pin-Based VM-Execution Controls, EPT/VPID, APIC and VM-Functions, word 0 */ +#define VMX_FEATURE_INTR_EXITING ( 0*32+ 0)/* VM-Exit on vectored interrupts */ +#define VMX_FEATURE_NMI_EXITING ( 0*32+ 3)/* VM-Exit on NMIs */ +#define VMX_FEATURE_VIRTUAL_NMIS ( 0*32+ 5)/* "vnmi" NMI virtualization */ +#define VMX_FEATURE_PREEMPTION_TIMER ( 0*32+ 6)/* "preemption_timer" VMX Preemption Timer */ +#define VMX_FEATURE_POSTED_INTR ( 0*32+ 7)/* "posted_intr" Posted Interrupts */ + +/* EPT/VPID features, scattered to bits 16-23 */ +#define VMX_FEATURE_INVVPID ( 0*32+ 16)/* "invvpid" INVVPID is supported */ +#define VMX_FEATURE_EPT_EXECUTE_ONLY ( 0*32+ 17)/* "ept_x_only" EPT entries can be execute only */ +#define VMX_FEATURE_EPT_AD ( 0*32+ 18)/* "ept_ad" EPT Accessed/Dirty bits */ +#define VMX_FEATURE_EPT_1GB ( 0*32+ 19)/* "ept_1gb" 1GB EPT pages */ +#define VMX_FEATURE_EPT_5LEVEL ( 0*32+ 20)/* "ept_5level" 5-level EPT paging */ + +/* Aggregated APIC features 24-27 */ +#define VMX_FEATURE_FLEXPRIORITY ( 0*32+ 24)/* "flexpriority" TPR shadow + virt APIC */ +#define VMX_FEATURE_APICV ( 0*32+ 25)/* "apicv" TPR shadow + APIC reg virt + virt intr delivery + posted interrupts */ + +/* VM-Functions, shifted to bits 28-31 */ +#define VMX_FEATURE_EPTP_SWITCHING ( 0*32+ 28)/* "eptp_switching" EPTP switching (in guest) */ + +/* Primary Processor-Based VM-Execution Controls, word 1 */ +#define VMX_FEATURE_INTR_WINDOW_EXITING ( 1*32+ 2)/* VM-Exit if INTRs are unblocked in guest */ +#define VMX_FEATURE_USE_TSC_OFFSETTING ( 1*32+ 3)/* "tsc_offset" Offset hardware TSC when read in guest */ +#define VMX_FEATURE_HLT_EXITING ( 1*32+ 7)/* VM-Exit on HLT */ +#define VMX_FEATURE_INVLPG_EXITING ( 1*32+ 9)/* VM-Exit on INVLPG */ +#define VMX_FEATURE_MWAIT_EXITING ( 1*32+ 10)/* VM-Exit on MWAIT */ +#define VMX_FEATURE_RDPMC_EXITING ( 1*32+ 11)/* VM-Exit on RDPMC */ +#define VMX_FEATURE_RDTSC_EXITING ( 1*32+ 12)/* VM-Exit on RDTSC */ +#define VMX_FEATURE_CR3_LOAD_EXITING ( 1*32+ 15)/* VM-Exit on writes to CR3 */ +#define VMX_FEATURE_CR3_STORE_EXITING ( 1*32+ 16)/* VM-Exit on reads from CR3 */ +#define VMX_FEATURE_TERTIARY_CONTROLS ( 1*32+ 17)/* Enable Tertiary VM-Execution Controls */ +#define VMX_FEATURE_CR8_LOAD_EXITING ( 1*32+ 19)/* VM-Exit on writes to CR8 */ +#define VMX_FEATURE_CR8_STORE_EXITING ( 1*32+ 20)/* VM-Exit on reads from CR8 */ +#define VMX_FEATURE_VIRTUAL_TPR ( 1*32+ 21)/* "vtpr" TPR virtualization, a.k.a. TPR shadow */ +#define VMX_FEATURE_NMI_WINDOW_EXITING ( 1*32+ 22)/* VM-Exit if NMIs are unblocked in guest */ +#define VMX_FEATURE_MOV_DR_EXITING ( 1*32+ 23)/* VM-Exit on accesses to debug registers */ +#define VMX_FEATURE_UNCOND_IO_EXITING ( 1*32+ 24)/* VM-Exit on *all* IN{S} and OUT{S}*/ +#define VMX_FEATURE_USE_IO_BITMAPS ( 1*32+ 25)/* VM-Exit based on I/O port */ +#define VMX_FEATURE_MONITOR_TRAP_FLAG ( 1*32+ 27)/* "mtf" VMX single-step VM-Exits */ +#define VMX_FEATURE_USE_MSR_BITMAPS ( 1*32+ 28)/* VM-Exit based on MSR index */ +#define VMX_FEATURE_MONITOR_EXITING ( 1*32+ 29)/* VM-Exit on MONITOR (MWAIT's accomplice) */ +#define VMX_FEATURE_PAUSE_EXITING ( 1*32+ 30)/* VM-Exit on PAUSE (unconditionally) */ +#define VMX_FEATURE_SEC_CONTROLS ( 1*32+ 31)/* Enable Secondary VM-Execution Controls */ + +/* Secondary Processor-Based VM-Execution Controls, word 2 */ +#define VMX_FEATURE_VIRT_APIC_ACCESSES ( 2*32+ 0)/* "vapic" Virtualize memory mapped APIC accesses */ +#define VMX_FEATURE_EPT ( 2*32+ 1)/* "ept" Extended Page Tables, a.k.a. Two-Dimensional Paging */ +#define VMX_FEATURE_DESC_EXITING ( 2*32+ 2)/* VM-Exit on {S,L}*DT instructions */ +#define VMX_FEATURE_RDTSCP ( 2*32+ 3)/* Enable RDTSCP in guest */ +#define VMX_FEATURE_VIRTUAL_X2APIC ( 2*32+ 4)/* Virtualize X2APIC for the guest */ +#define VMX_FEATURE_VPID ( 2*32+ 5)/* "vpid" Virtual Processor ID (TLB ASID modifier) */ +#define VMX_FEATURE_WBINVD_EXITING ( 2*32+ 6)/* VM-Exit on WBINVD */ +#define VMX_FEATURE_UNRESTRICTED_GUEST ( 2*32+ 7)/* "unrestricted_guest" Allow Big Real Mode and other "invalid" states */ +#define VMX_FEATURE_APIC_REGISTER_VIRT ( 2*32+ 8)/* "vapic_reg" Hardware emulation of reads to the virtual-APIC */ +#define VMX_FEATURE_VIRT_INTR_DELIVERY ( 2*32+ 9)/* "vid" Evaluation and delivery of pending virtual interrupts */ +#define VMX_FEATURE_PAUSE_LOOP_EXITING ( 2*32+ 10)/* "ple" Conditionally VM-Exit on PAUSE at CPL0 */ +#define VMX_FEATURE_RDRAND_EXITING ( 2*32+ 11)/* VM-Exit on RDRAND*/ +#define VMX_FEATURE_INVPCID ( 2*32+ 12)/* Enable INVPCID in guest */ +#define VMX_FEATURE_VMFUNC ( 2*32+ 13)/* Enable VM-Functions (leaf dependent) */ +#define VMX_FEATURE_SHADOW_VMCS ( 2*32+ 14)/* "shadow_vmcs" VMREAD/VMWRITE in guest can access shadow VMCS */ +#define VMX_FEATURE_ENCLS_EXITING ( 2*32+ 15)/* VM-Exit on ENCLS (leaf dependent) */ +#define VMX_FEATURE_RDSEED_EXITING ( 2*32+ 16)/* VM-Exit on RDSEED */ +#define VMX_FEATURE_PAGE_MOD_LOGGING ( 2*32+ 17)/* "pml" Log dirty pages into buffer */ +#define VMX_FEATURE_EPT_VIOLATION_VE ( 2*32+ 18)/* "ept_violation_ve" Conditionally reflect EPT violations as #VE exceptions */ +#define VMX_FEATURE_PT_CONCEAL_VMX ( 2*32+ 19)/* Suppress VMX indicators in Processor Trace */ +#define VMX_FEATURE_XSAVES ( 2*32+ 20)/* Enable XSAVES and XRSTORS in guest */ +#define VMX_FEATURE_MODE_BASED_EPT_EXEC ( 2*32+ 22)/* "ept_mode_based_exec" Enable separate EPT EXEC bits for supervisor vs. user */ +#define VMX_FEATURE_PT_USE_GPA ( 2*32+ 24)/* Processor Trace logs GPAs */ +#define VMX_FEATURE_TSC_SCALING ( 2*32+ 25)/* "tsc_scaling" Scale hardware TSC when read in guest */ +#define VMX_FEATURE_USR_WAIT_PAUSE ( 2*32+ 26)/* "usr_wait_pause" Enable TPAUSE, UMONITOR, UMWAIT in guest */ +#define VMX_FEATURE_ENCLV_EXITING ( 2*32+ 28)/* VM-Exit on ENCLV (leaf dependent) */ +#define VMX_FEATURE_BUS_LOCK_DETECTION ( 2*32+ 30)/* VM-Exit when bus lock caused */ +#define VMX_FEATURE_NOTIFY_VM_EXITING ( 2*32+ 31)/* "notify_vm_exiting" VM-Exit when no event windows after notify window */ + +/* Tertiary Processor-Based VM-Execution Controls, word 3 */ +#define VMX_FEATURE_IPI_VIRT ( 3*32+ 4)/* "ipi_virt" Enable IPI virtualization */ +#endif /* _ASM_X86_VMXFEATURES_H */
Signature · 1 line
2.43.0
PATCH 4/17 lib: define __aligned() in compiler.h
In reply to Jon KohlerAdd __aligned() to compiler.h, copied from Linux 6.16's include/linux/compiler_attributes.h to support __aligned(16) in vmx.h.
--- lib/linux/compiler.h | 1 + 1 file changed, 1 insertion(+)
lib/linux/compiler.h +1 -0
@@ -54,6 +54,7 @@#define __always_inline __inline __attribute__ ((__always_inline__))#define noinline __attribute__((noinline)) +#define __aligned (x) __attribute__((__aligned__(x)))#define __unused __attribute__((__unused__)) static __always_inline void __read_once_size(const volatile void *p, void *res, int size)
Signature · 1 line
2.43.0
PATCH 5/17 x86/vmx: basic integration for new vmx.h
In reply to Jon KohlerIntegrate Linux's vmx.h to vmx.c / vmx_tests.c, and do misc cleanup to remove conflicting definitions from the original vmx.h.
Make minor modifications to the new vmx.h to update includes to fit into the KUT repository as a standalone header file.
Replaced WARN_ON_ONCE in vmx_eptp_page_walk_level with report_info.
Renamed struct vmcs_field to struct vmcs_field_struct to avoid conflict with the new vmx.h's enum vmcs_field.
--- lib/linux/vmx.h | 15 +++++---- x86/vmx.c | 16 +++++----- x86/vmx.h | 82 ------------------------------------------------- x86/vmx_tests.c | 6 +--- 4 files changed, 17 insertions(+), 102 deletions(-)
lib/linux/vmx.h +7 -8
@@ -12,13 +12,10 @@#define VMX_H -#include <linux/bitops.h> -#include <linux/bug.h> -#include <linux/types.h> - -#include <uapi/asm/vmx.h> -#include <asm/trapnr.h> -#include <asm/vmxfeatures.h> +#include "bitops.h" +#include "libcflat.h" +#include "trapnr.h" +#include "util.h" #define VMCS_CONTROL_BIT (x) BIT(VMX_FEATURE_##x & 0x1f)
@@ -552,7 +549,9 @@ static inline u8 vmx_eptp_page_walk_level(u64 eptp)return 5 ;/* @eptp must be pre-validated by the caller. */ -WARN_ON_ONCE (encoded_level !=VMX_EPTP_PWL_4 ); +if (encoded_level !=VMX_EPTP_PWL_4 ) +report_info ("encoded_level %ld != VMX_EPTP_PWL_4" , encoded_level); +return 4 ; }
x86/vmx.c +9 -7
@@ -28,6 +28,8 @@* Author : Arthur Chunqi Li <[email protected]> */ +#include <linux/vmx.h> +#include "libcflat.h" #include "processor.h" #include "alloc_page.h"
@@ -83,7 +85,7 @@ static volatile u32 stage;static jmp_buf abort_target; -struct vmcs_field { +struct vmcs_field_struct {u64 mask;u64 encoding; };
@@ -91,7 +93,7 @@ struct vmcs_field {#define MASK (_bits) GENMASK_ULL((_bits) - 1, 0)#define MASK_NATURAL MASK(sizeof(unsigned long) * 8) -static struct vmcs_field vmcs_fields[] = { +static struct vmcs_field_struct vmcs_fields[] = { {MASK (16 ),VPID }, {MASK (16 ),PINV }, {MASK (16 ),EPTP_IDX },
@@ -250,12 +252,12 @@ enum vmcs_field_type { VMCS_FIELD_TYPES, }; -static inline int vmcs_field_type (struct vmcs_field *f) +static inline int vmcs_field_type (struct vmcs_field_struct *f) {return (f->encoding >>VMCS_FIELD_TYPE_SHIFT ) &0x3 ; } -static int vmcs_field_readonly (struct vmcs_field *f) +static int vmcs_field_readonly (struct vmcs_field_struct *f) {u64 ia32_vmx_misc;
@@ -264,7 +266,7 @@ static int vmcs_field_readonly(struct vmcs_field *f) (vmcs_field_type (f) ==VMCS_FIELD_TYPE_READ_ONLY_DATA ); } -static inline u64 vmcs_field_value (struct vmcs_field *f,u8 cookie) +static inline u64 vmcs_field_value (struct vmcs_field_struct *f,u8 cookie) {u64 value;
@@ -276,12 +278,12 @@ static inline u64 vmcs_field_value(struct vmcs_field *f, u8 cookie)return value & f->mask; } -static void set_vmcs_field (struct vmcs_field *f,u8 cookie) +static void set_vmcs_field (struct vmcs_field_struct *f,u8 cookie) {vmcs_write (f->encoding,vmcs_field_value (f, cookie)); } -static bool check_vmcs_field (struct vmcs_field *f,u8 cookie) +static bool check_vmcs_field (struct vmcs_field_struct *f,u8 cookie) {u64 expected;u64 actual;
x86/vmx.h +0 -82
170 lines not on this page · raw message
x86/vmx_tests.c +1 -5
@@ -5,6 +5,7 @@*/ #include <asm/debugreg.h> +#include <linux/vmx.h> #include "vmx.h" #include "msr.h"
@@ -1962,11 +1963,6 @@ static int dbgctls_exit_handler(union exit_reason exit_reason)return VMX_TEST_VMEXIT ; } -struct vmx_msr_entry { -u32 index; -u32 reserved; -u64 value; -} __attribute__((packed));#define MSR_MAGIC 0x31415926struct vmx_msr_entry *exit_msr_store, *entry_msr_load, *exit_msr_load;
Signature · 1 line
2.43.0
PATCH 6/17 x86/vmx: switch to new vmx.h EPT violation defs
In reply to Jon KohlerMigrate to new vmx.h's EPT violation defs, which makes it easier to grok from one code base to another.
Fix a few small formatting issues along the way.
No functional change intended.
--- x86/vmx.h | 11 ----- x86/vmx_tests.c | 127 +++++++++++++++++++++++++++++------------------- 2 files changed, 77 insertions(+), 61 deletions(-)
x86/vmx.h +0 -11
@@ -618,17 +618,6 @@ enum Intr_type {#define EPT_ADDR_MASK GENMASK_ULL(51, 12)#define PAGE_MASK_2M (~(PAGE_SIZE_2M-1)) -#define EPT_VLT_RD (1ull << 0) -#define EPT_VLT_WR (1ull << 1) -#define EPT_VLT_FETCH (1ull << 2) -#define EPT_VLT_PERM_RD (1ull << 3) -#define EPT_VLT_PERM_WR (1ull << 4) -#define EPT_VLT_PERM_EX (1ull << 5) -#define EPT_VLT_PERM_USER_EX (1ull << 6) -#define EPT_VLT_PERMS (EPT_VLT_PERM_RD | EPT_VLT_PERM_WR | \ - EPT_VLT_PERM_EX) -#define EPT_VLT_LADDR_VLD (1ull << 7) -#define EPT_VLT_PADDR (1ull << 8)#define EPT_VLT_GUEST_USER (1ull << 9)#define EPT_VLT_GUEST_RW (1ull << 10)#define EPT_VLT_GUEST_EX (1ull << 11)
x86/vmx_tests.c +77 -50
281 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 7/17 x86/vmx: switch to new vmx.h EPT RWX defs
In reply to Jon KohlerMigrate to new vmx.h's EPT RWX defs, which makes it easier to grok from one code base to another.
Fix a few small formatting issues along the way.
No functional change intended.
--- x86/vmx.c | 14 +-- x86/vmx.h | 4 - x86/vmx_tests.c | 245 +++++++++++++++++++++++++++++++----------------- 3 files changed, 165 insertions(+), 98 deletions(-)
x86/vmx.c +8 -6
@@ -823,7 +823,7 @@ static void split_large_ept_entry(unsigned long *ptep, int level)int i; pte = *ptep; -assert (pte &EPT_PRESENT ); +assert (pte &VMX_EPT_RWX_MASK );assert (pte &EPT_LARGE_PAGE );assert (level ==2 || level ==3 );
@@ -870,15 +870,17 @@ void install_ept_entry(unsigned long *pml4,for (level =EPT_PAGE_LEVEL ; level > pte_level; --level) { offset = (guest_addr >>EPT_LEVEL_SHIFT (level)) &EPT_PGDIR_MASK ; -if (!(pt[offset] & (EPT_PRESENT ))) { +if (!(pt[offset] & (VMX_EPT_RWX_MASK ))) {unsigned long *new_pt = pt_page;if (!new_pt) new_pt =alloc_page ();else pt_page =0 ;memset (new_pt,0 ,PAGE_SIZE ); - pt[offset] =virt_to_phys (new_pt) - |EPT_RA |EPT_WA |EPT_EA ; + pt[offset] =virt_to_phys (new_pt) | +VMX_EPT_READABLE_MASK | +VMX_EPT_WRITABLE_MASK | +VMX_EPT_EXECUTABLE_MASK ; }else if (pt[offset] &EPT_LARGE_PAGE )split_large_ept_entry (&pt[offset], level); pt =phys_to_virt (pt[offset] &EPT_ADDR_MASK );
@@ -965,7 +967,7 @@ bool get_ept_pte(unsigned long *pml4, unsigned long guest_addr, int level,break ;if (l <4 && (iter_pte &EPT_LARGE_PAGE ))return false; -if (!(iter_pte & (EPT_PRESENT ))) +if (!(iter_pte & (VMX_EPT_RWX_MASK )))return false; pt = (unsigned long *)(iter_pte &EPT_ADDR_MASK ); }
@@ -1089,7 +1091,7 @@ void set_ept_pte(unsigned long *pml4, unsigned long guest_addr, offset = (guest_addr >>EPT_LEVEL_SHIFT (l)) &EPT_PGDIR_MASK ;if (l == level)break ; -assert (pt[offset] &EPT_PRESENT ); +assert (pt[offset] &VMX_EPT_RWX_MASK ); pt = (unsigned long *)(pt[offset] &EPT_ADDR_MASK ); } offset = (guest_addr >>EPT_LEVEL_SHIFT (l)) &EPT_PGDIR_MASK ;
x86/vmx.h +0 -4
@@ -578,10 +578,6 @@ enum Intr_type {#define EPT_MEM_TYPE_WP 5ul#define EPT_MEM_TYPE_WB 6ul -#define EPT_RA 1ul -#define EPT_WA 2ul -#define EPT_EA 4ul -#define EPT_PRESENT (EPT_RA | EPT_WA | EPT_EA)#define EPT_ACCESS_FLAG (1ul << 8)#define EPT_DIRTY_FLAG (1ul << 9)#define EPT_LARGE_PAGE (1ul << 7)
x86/vmx_tests.c +157 -88
464 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 8/17 x86/vmx: switch to new vmx.h EPT access and dirty defs
In reply to Jon KohlerMigrate to new vmx.h's EPT defs for access and dirty bits, which makes it easier to grok from one code base to another.
No functional change intended.
--- x86/vmx.c | 20 +++++++++++--------- x86/vmx.h | 3 --- x86/vmx_tests.c | 43 ++++++++++++++++++++++++------------------- 3 files changed, 35 insertions(+), 31 deletions(-)
x86/vmx.c +11 -9
@@ -986,7 +986,7 @@ static void clear_ept_ad_pte(unsigned long *pml4, unsigned long guest_addr)for (l =EPT_PAGE_LEVEL ; ; --l) { offset = (guest_addr >>EPT_LEVEL_SHIFT (l)) &EPT_PGDIR_MASK ; - pt[offset] &= ~(EPT_ACCESS_FLAG |EPT_DIRTY_FLAG ); + pt[offset] &= ~(VMX_EPT_ACCESS_BIT |VMX_EPT_DIRTY_BIT ); pte = pt[offset];if (l ==1 || (l <4 && (pte &EPT_LARGE_PAGE )))break ;
@@ -1043,12 +1043,14 @@ void check_ept_ad(unsigned long *pml4, u64 guest_cr3, }if (!bad_pt_ad) { - bad_pt_ad |= (ept_pte & (EPT_ACCESS_FLAG |EPT_DIRTY_FLAG )) != expected_pt_ad; + bad_pt_ad |= + (ept_pte & (VMX_EPT_ACCESS_BIT |VMX_EPT_DIRTY_BIT )) != + expected_pt_ad;if (bad_pt_ad)report_fail ("EPT - guest level %d page table A=%d/D=%d" , l, - !!(expected_pt_ad &EPT_ACCESS_FLAG ), - !!(expected_pt_ad &EPT_DIRTY_FLAG )); + !!(expected_pt_ad &VMX_EPT_ACCESS_BIT ), + !!(expected_pt_ad &VMX_EPT_DIRTY_BIT )); } pte = pt[offset];
@@ -1061,8 +1063,8 @@ void check_ept_ad(unsigned long *pml4, u64 guest_cr3,if (!bad_pt_ad)report_pass ("EPT - guest page table structures A=%d/D=%d" , - !!(expected_pt_ad &EPT_ACCESS_FLAG ), - !!(expected_pt_ad &EPT_DIRTY_FLAG )); + !!(expected_pt_ad &VMX_EPT_ACCESS_BIT ), + !!(expected_pt_ad &VMX_EPT_DIRTY_BIT )); offset = (guest_addr >>EPT_LEVEL_SHIFT (l)) &EPT_PGDIR_MASK ; offset_in_page = guest_addr & ((1 <<EPT_LEVEL_SHIFT (l)) -1 );
@@ -1072,10 +1074,10 @@ void check_ept_ad(unsigned long *pml4, u64 guest_cr3,report_fail ("EPT - guest physical address is not mapped" );return ; } -report ((ept_pte & (EPT_ACCESS_FLAG |EPT_DIRTY_FLAG )) == expected_gpa_ad, +report ((ept_pte & (VMX_EPT_ACCESS_BIT |VMX_EPT_DIRTY_BIT )) == expected_gpa_ad,"EPT - guest physical address A=%d/D=%d" , - !!(expected_gpa_ad &EPT_ACCESS_FLAG ), - !!(expected_gpa_ad &EPT_DIRTY_FLAG )); + !!(expected_gpa_ad &VMX_EPT_ACCESS_BIT ), + !!(expected_gpa_ad &VMX_EPT_DIRTY_BIT )); } void set_ept_pte(unsigned long *pml4, unsigned long guest_addr,
x86/vmx.h +0 -3
@@ -570,7 +570,6 @@ enum Intr_type {#define EPTP_PG_WALK_LEN_MASK 0x38ul#define EPTP_RESERV_BITS_MASK 0x1ful#define EPTP_RESERV_BITS_SHIFT 0x7ul -#define EPTP_AD_FLAG (1ul << 6)#define EPT_MEM_TYPE_UC 0ul#define EPT_MEM_TYPE_WC 1ul
@@ -578,8 +577,6 @@ enum Intr_type {#define EPT_MEM_TYPE_WP 5ul#define EPT_MEM_TYPE_WB 6ul -#define EPT_ACCESS_FLAG (1ul << 8) -#define EPT_DIRTY_FLAG (1ul << 9)#define EPT_LARGE_PAGE (1ul << 7)#define EPT_MEM_TYPE_SHIFT 3ul#define EPT_MEM_TYPE_MASK 0x7ul
x86/vmx_tests.c +24 -19
114 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 9/17 x86/vmx: switch to new vmx.h EPT capability and memory type defs
In reply to Jon KohlerMigrate to new vmx.h's EPT definitions for capability and memory type, which makes it easier to grok from one code base to another.
Pickup new lib/x86/msr.h definitions for memory types, from:
e7e80b6 ("x86/cpu: KVM: Add common defines for architectural memory types (PAT, MTRRs, etc.)")
No functional change intended.
--- lib/x86/msr.h | 14 ++++++++++++++ x86/vmx.c | 18 +++++++++--------- x86/vmx.h | 33 ++++++++++----------------------- x86/vmx_tests.c | 14 +++++++------- 4 files changed, 40 insertions(+), 39 deletions(-)
lib/x86/msr.h +14 -0
@@ -31,6 +31,20 @@#define EFER_LMSLE (1<<_EFER_LMSLE)#define EFER_FFXSR (1<<_EFER_FFXSR) +/* +* Architectural memory types that are common to MTRRs, PAT, VMX MSRs, etc. +* Most MSRs support/allow only a subset of memory types, but the values +* themselves are common across all relevant MSRs. +*/ +#define X86_MEMTYPE_UC 0ull/* Uncacheable, a.k.a. Strong Uncacheable */ +#define X86_MEMTYPE_WC 1ull/* Write Combining */ +/* RESERVED 2 */ +/* RESERVED 3 */ +#define X86_MEMTYPE_WT 4ull/* Write Through */ +#define X86_MEMTYPE_WP 5ull/* Write Protected */ +#define X86_MEMTYPE_WB 6ull/* Write Back */ +#define X86_MEMTYPE_UC_MINUS 7ull/* Weak Uncacheabled (PAT only) */ +/* Intel MSRs. Some also available on other CPUs */ #define MSR_IA32_SPEC_CTRL 0x00000048#define SPEC_CTRL_IBRS BIT(0)
x86/vmx.c +9 -9
@@ -1641,15 +1641,15 @@ static void test_vmx_caps(void) "MSR_IA32_VMX_VMCS_ENUM"); fixed0 =-1ull ; - fixed0 &= ~(EPT_CAP_EXEC_ONLY | - EPT_CAP_PWL4 | - EPT_CAP_PWL5 | - EPT_CAP_UC | - EPT_CAP_WB | - EPT_CAP_2M_PAGE | - EPT_CAP_1G_PAGE | - EPT_CAP_INVEPT | - EPT_CAP_AD_FLAG | + fixed0 &= ~(VMX_EPT_EXECUTE_ONLY_BIT | + VMX_EPT_PAGE_WALK_4_BIT | + VMX_EPT_PAGE_WALK_5_BIT | + VMX_EPTP_UC_BIT | + VMX_EPTP_WB_BIT | + VMX_EPT_2MB_PAGE_BIT | + VMX_EPT_1GB_PAGE_BIT | + VMX_EPT_INVEPT_BIT | + VMX_EPT_AD_BIT | EPT_CAP_ADV_EPT_INFO | EPT_CAP_INVEPT_SINGLE | EPT_CAP_INVEPT_ALL |
x86/vmx.h +10 -23
@@ -571,27 +571,14 @@ enum Intr_type {#define EPTP_RESERV_BITS_MASK 0x1ful#define EPTP_RESERV_BITS_SHIFT 0x7ul -#define EPT_MEM_TYPE_UC 0ul#define EPT_MEM_TYPE_WC 1ul#define EPT_MEM_TYPE_WT 4ul#define EPT_MEM_TYPE_WP 5ul -#define EPT_MEM_TYPE_WB 6ul#define EPT_LARGE_PAGE (1ul << 7) -#define EPT_MEM_TYPE_SHIFT 3ul -#define EPT_MEM_TYPE_MASK 0x7ul#define EPT_IGNORE_PAT (1ul << 6)#define EPT_SUPPRESS_VE (1ull << 63) -#define EPT_CAP_EXEC_ONLY (1ull << 0) -#define EPT_CAP_PWL4 (1ull << 6) -#define EPT_CAP_PWL5 (1ull << 7) -#define EPT_CAP_UC (1ull << 8) -#define EPT_CAP_WB (1ull << 14) -#define EPT_CAP_2M_PAGE (1ull << 16) -#define EPT_CAP_1G_PAGE (1ull << 17) -#define EPT_CAP_INVEPT (1ull << 20) -#define EPT_CAP_AD_FLAG (1ull << 21)#define EPT_CAP_ADV_EPT_INFO (1ull << 22)#define EPT_CAP_INVEPT_SINGLE (1ull << 25)#define EPT_CAP_INVEPT_ALL (1ull << 26)
@@ -662,12 +649,12 @@ extern union vmx_ept_vpid ept_vpid;static inline bool ept_2m_supported (void ) { -return ept_vpid.val &EPT_CAP_2M_PAGE ; +return ept_vpid.val &VMX_EPT_2MB_PAGE_BIT ; }static inline bool ept_1g_supported (void ) { -return ept_vpid.val &EPT_CAP_1G_PAGE ; +return ept_vpid.val &VMX_EPT_1GB_PAGE_BIT ; }static inline bool ept_huge_pages_supported (int level)
@@ -682,31 +669,31 @@ static inline bool ept_huge_pages_supported(int level)static inline bool ept_execute_only_supported (void ) { -return ept_vpid.val &EPT_CAP_EXEC_ONLY ; +return ept_vpid.val &VMX_EPT_EXECUTE_ONLY_BIT ; }static inline bool ept_ad_bits_supported (void ) { -return ept_vpid.val &EPT_CAP_AD_FLAG ; +return ept_vpid.val &VMX_EPT_AD_BIT ; }static inline bool is_4_level_ept_supported (void ) { -return ept_vpid.val &EPT_CAP_PWL4 ; +return ept_vpid.val &VMX_EPT_PAGE_WALK_4_BIT ; }static inline bool is_5_level_ept_supported (void ) { -return ept_vpid.val &EPT_CAP_PWL5 ; +return ept_vpid.val &VMX_EPT_PAGE_WALK_5_BIT ; }static inline bool is_ept_memtype_supported (int type) { -if (type ==EPT_MEM_TYPE_UC ) -return ept_vpid.val &EPT_CAP_UC ; +if (type ==VMX_EPTP_MT_UC ) +return ept_vpid.val &VMX_EPTP_UC_BIT ; -if (type ==EPT_MEM_TYPE_WB ) -return ept_vpid.val &EPT_CAP_WB ; +if (type ==VMX_EPTP_MT_WB ) +return ept_vpid.val &VMX_EPTP_WB_BIT ;return false; }
x86/vmx_tests.c +7 -7
@@ -1050,7 +1050,7 @@ static int __setup_ept(u64 hpa, bool enable_ad)printf ("\tEPT is not supported\n" );return 1 ; } -if (!is_ept_memtype_supported (EPT_MEM_TYPE_WB )) { +if (!is_ept_memtype_supported (VMX_EPTP_MT_WB )) {printf ("\tWB memtype for EPT walks not supported\n" );return 1 ; }
@@ -1062,7 +1062,7 @@ static int __setup_ept(u64 hpa, bool enable_ad)return 1 ; } - eptp =EPT_MEM_TYPE_WB ; + eptp =VMX_EPTP_MT_WB ; eptp |= (3 <<EPTP_PG_WALK_LEN_SHIFT ); eptp |= hpa;if (enable_ad)
@@ -1385,7 +1385,7 @@ static int ept_exit_handler_common(union exit_reason exit_reason, bool have_ad)VMX_EPT_READABLE_MASK |VMX_EPT_WRITABLE_MASK |VMX_EPT_EXECUTABLE_MASK | - (2 << EPT_MEM_TYPE_SHIFT)); + (2 << VMX_EPT_MT_EPTE_SHIFT));invept (INVEPT_SINGLE , eptp);break ;case 3 :
@@ -4838,10 +4838,10 @@ static void test_ept_eptp(void) eptp =vmcs_read (EPTP );for (i =0 ; i <8 ; i++) { - eptp = (eptp & ~EPT_MEM_TYPE_MASK ) | i; + eptp = (eptp & ~VMX_EPTP_MT_MASK ) | i;vmcs_write (EPTP , eptp); -report_prefix_pushf ("Enable-EPT enabled; EPT memory type %lu" , - eptp &EPT_MEM_TYPE_MASK ); +report_prefix_pushf ("Enable-EPT enabled; EPT memory type %llu" , + eptp &VMX_EPTP_MT_MASK );if (is_ept_memtype_supported (i))test_vmx_valid_controls ();else
@@ -4849,7 +4849,7 @@ static void test_ept_eptp(void)report_prefix_pop (); } - eptp = (eptp & ~EPT_MEM_TYPE_MASK ) |6ul ; + eptp = (eptp & ~VMX_EPTP_MT_MASK ) |6ul ;/* * Page walk length (bits 5:3). Note, the value in VMCS.EPTP "is 1
Signature · 1 line
2.43.0
PATCH 10/17 x86/vmx: switch to new vmx.h primary processor-based VM-execution controls
In reply to Jon KohlerMigrate to new vmx.h's primary processor-based VM-execution controls, which makes it easier to grok from one code base to another.
Save secondary execution controls bit 31 for the next patch.
No functional change intended.
--- lib/linux/vmx.h | 1 + x86/vmx.c | 2 +- x86/vmx.h | 19 ------ x86/vmx_tests.c | 157 ++++++++++++++++++++++++++---------------------- 4 files changed, 87 insertions(+), 92 deletions(-)
lib/linux/vmx.h +1 -0
@@ -16,6 +16,7 @@#include "libcflat.h" #include "trapnr.h" #include "util.h" +#include "vmxfeatures.h" #define VMCS_CONTROL_BIT (x) BIT(VMX_FEATURE_##x & 0x1f)
x86/vmx.c +1 -1
@@ -1258,7 +1258,7 @@ int init_vmcs(struct vmcs **vmcs) ctrl_exit =EXI_LOAD_EFER |EXI_HOST_64 |EXI_LOAD_PAT ; ctrl_enter = (ENT_LOAD_EFER |ENT_GUEST_64 );/* DIsable IO instruction VMEXIT now */ - ctrl_cpu[0 ] &= (~(CPU_IO |CPU_IO_BITMAP )); + ctrl_cpu[0 ] &= (~(CPU_BASED_UNCOND_IO_EXITING |CPU_BASED_USE_IO_BITMAPS )); ctrl_cpu[1 ] =0 ; ctrl_pin = (ctrl_pin | ctrl_pin_rev.set) & ctrl_pin_rev.clr;
x86/vmx.h +0 -19
@@ -436,25 +436,6 @@ enum Ctrl_pin { };enum Ctrl0 { -CPU_INTR_WINDOW =1ul <<2 , -CPU_USE_TSC_OFFSET =1ul <<3 , -CPU_HLT =1ul <<7 , -CPU_INVLPG =1ul <<9 , -CPU_MWAIT =1ul <<10 , -CPU_RDPMC =1ul <<11 , -CPU_RDTSC =1ul <<12 , -CPU_CR3_LOAD =1ul <<15 , -CPU_CR3_STORE =1ul <<16 , -CPU_CR8_LOAD =1ul <<19 , -CPU_CR8_STORE =1ul <<20 , -CPU_TPR_SHADOW =1ul <<21 , -CPU_NMI_WINDOW =1ul <<22 , -CPU_IO =1ul <<24 , -CPU_IO_BITMAP =1ul <<25 , -CPU_MTF =1ul <<27 , -CPU_MSR_BITMAP =1ul <<28 , -CPU_MONITOR =1ul <<29 , -CPU_PAUSE =1ul <<30 ,CPU_SECONDARY =1ul <<31 , };
x86/vmx_tests.c +85 -72
448 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 11/17 x86/vmx: switch to new vmx.h secondary execution control bit
In reply to Jon KohlerMigrate to new vmx.h's secondary execution control bit 31, which makes it easier to grok from one code base to another.
No functional change intended.
--- x86/vmx.c | 4 +- x86/vmx.h | 6 +-- x86/vmx_tests.c | 102 ++++++++++++++++++++++++++++-------------------- 3 files changed, 63 insertions(+), 49 deletions(-)
x86/vmx.c +2 -2
@@ -1107,7 +1107,7 @@ static void init_vmcs_ctrl(void)vmcs_write (PIN_CONTROLS , ctrl_pin);/* Disable VMEXIT of IO instruction */ vmcs_write (CPU_EXEC_CTRL0 , ctrl_cpu[0 ]); -if (ctrl_cpu_rev[0 ].set &CPU_SECONDARY ) { +if (ctrl_cpu_rev[0 ].set &CPU_BASED_ACTIVATE_SECONDARY_CONTROLS ) { ctrl_cpu[1 ] = (ctrl_cpu[1 ] | ctrl_cpu_rev[1 ].set) & ctrl_cpu_rev[1 ].clr;vmcs_write (CPU_EXEC_CTRL1 , ctrl_cpu[1 ]);
@@ -1296,7 +1296,7 @@ static void init_vmx_caps(void) : MSR_IA32_VMX_ENTRY_CTLS); ctrl_cpu_rev[0 ].val =rdmsr (basic_msr.ctrl ?MSR_IA32_VMX_TRUE_PROC :MSR_IA32_VMX_PROCBASED_CTLS ); -if ((ctrl_cpu_rev[0 ].clr &CPU_SECONDARY ) !=0 ) +if ((ctrl_cpu_rev[0 ].clr &CPU_BASED_ACTIVATE_SECONDARY_CONTROLS ) !=0 ) ctrl_cpu_rev[1 ].val =rdmsr (MSR_IA32_VMX_PROCBASED_CTLS2 );else ctrl_cpu_rev[1 ].val =0 ;
x86/vmx.h +1 -5
@@ -435,10 +435,6 @@ enum Ctrl_pin { PIN_POST_INTR = 1ul << 7, }; -enum Ctrl0 { -CPU_SECONDARY =1ul <<31 , -}; -enum Ctrl1 {CPU_VIRT_APIC_ACCESSES =1ul <<0 ,CPU_EPT =1ul <<1 ,
@@ -689,7 +685,7 @@ static inline bool is_invept_type_supported(u64 type)static inline bool is_vpid_supported (void ) { -return (ctrl_cpu_rev[0 ].clr &CPU_SECONDARY ) && +return (ctrl_cpu_rev[0 ].clr &CPU_BASED_ACTIVATE_SECONDARY_CONTROLS ) && (ctrl_cpu_rev[1 ].clr &CPU_VPID ); }
x86/vmx_tests.c +60 -42
334 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 12/17 x86/vmx: switch to new vmx.h secondary execution controls
In reply to Jon KohlerMigrate to new vmx.h's secondary execution controls, which makes it easier to grok from one code base to another.
No functional change intended.
--- x86/vmx.c | 6 +- x86/vmx.h | 20 +---- x86/vmx_tests.c | 220 ++++++++++++++++++++++++++++-------------------- 3 files changed, 136 insertions(+), 110 deletions(-)
x86/vmx.c +4 -2
@@ -1300,7 +1300,8 @@ static void init_vmx_caps(void) ctrl_cpu_rev[1 ].val =rdmsr (MSR_IA32_VMX_PROCBASED_CTLS2 ); else ctrl_cpu_rev[1].val = 0; -if ((ctrl_cpu_rev[1 ].clr & (CPU_EPT |CPU_VPID )) !=0 ) +if ((ctrl_cpu_rev[1 ].clr & + (SECONDARY_EXEC_ENABLE_EPT |SECONDARY_EXEC_ENABLE_VPID )) !=0 ) ept_vpid.val =rdmsr (MSR_IA32_VMX_EPT_VPID_CAP );else ept_vpid.val =0 ;
@@ -1607,7 +1608,8 @@ static void test_vmx_caps(void) "MSR_IA32_VMX_BASIC"); val =rdmsr (MSR_IA32_VMX_MISC ); -report ((!(ctrl_cpu_rev[1 ].clr &CPU_URG ) || val & (1ul <<5 )) && +report ((!(ctrl_cpu_rev[1 ].clr & +SECONDARY_EXEC_UNRESTRICTED_GUEST ) || val & (1ul <<5 )) && ((val >>16 ) &0x1ff ) <=256 && (val &0x80007e00 ) ==0 ,"MSR_IA32_VMX_MISC" );
x86/vmx.h +1 -19
@@ -435,24 +435,6 @@ enum Ctrl_pin { PIN_POST_INTR = 1ul << 7, }; -enum Ctrl1 { -CPU_VIRT_APIC_ACCESSES =1ul <<0 , -CPU_EPT =1ul <<1 , -CPU_DESC_TABLE =1ul <<2 , -CPU_RDTSCP =1ul <<3 , -CPU_VIRT_X2APIC =1ul <<4 , -CPU_VPID =1ul <<5 , -CPU_WBINVD =1ul <<6 , -CPU_URG =1ul <<7 , -CPU_APIC_REG_VIRT =1ul <<8 , -CPU_VINTD =1ul <<9 , -CPU_RDRAND =1ul <<11 , -CPU_SHADOW_VMCS =1ul <<14 , -CPU_RDSEED =1ul <<16 , -CPU_PML =1ul <<17 , -CPU_USE_TSC_SCALING =1ul <<25 , -}; -enum Intr_type {VMX_INTR_TYPE_EXT_INTR =0 ,VMX_INTR_TYPE_NMI_INTR =2 ,
@@ -686,7 +668,7 @@ static inline bool is_invept_type_supported(u64 type)static inline bool is_vpid_supported (void ) {return (ctrl_cpu_rev[0 ].clr &CPU_BASED_ACTIVATE_SECONDARY_CONTROLS ) && - (ctrl_cpu_rev[1 ].clr &CPU_VPID ); + (ctrl_cpu_rev[1 ].clr &SECONDARY_EXEC_ENABLE_VPID ); }static inline bool is_invvpid_supported (void )
x86/vmx_tests.c +131 -89
588 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 13/17 x86/vmx: switch to new vmx.h pin based VM-execution controls
In reply to Jon KohlerMigrate to new vmx.h's pin based VM-execution controls, which makes it easier to grok from one code base to another.
No functional change intended.
--- x86/vmx.c | 4 +- x86/vmx.h | 8 ---- x86/vmx_tests.c | 125 +++++++++++++++++++++++++++--------------------- 3 files changed, 74 insertions(+), 63 deletions(-)
x86/vmx.c +3 -1
@@ -1254,7 +1254,9 @@ int init_vmcs(struct vmcs **vmcs)/* All settings to pin/exit/enter/cpu control fields should be placed here */ - ctrl_pin |=PIN_EXTINT |PIN_NMI |PIN_VIRT_NMI ; + ctrl_pin |=PIN_BASED_EXT_INTR_MASK | +PIN_BASED_NMI_EXITING | +PIN_BASED_VIRTUAL_NMIS ; ctrl_exit =EXI_LOAD_EFER |EXI_HOST_64 |EXI_LOAD_PAT ; ctrl_enter = (ENT_LOAD_EFER |ENT_GUEST_64 );/* DIsable IO instruction VMEXIT now */
x86/vmx.h +0 -8
@@ -427,14 +427,6 @@ enum Ctrl_ent {ENT_LOAD_BNDCFGS =1UL <<16 }; -enum Ctrl_pin { -PIN_EXTINT =1ul <<0 , -PIN_NMI =1ul <<3 , -PIN_VIRT_NMI =1ul <<5 , -PIN_PREEMPT =1ul <<6 , -PIN_POST_INTR =1ul <<7 , -}; -enum Intr_type {VMX_INTR_TYPE_EXT_INTR =0 ,VMX_INTR_TYPE_NMI_INTR =2 ,
x86/vmx_tests.c +71 -54
402 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 14/17 x86/vmx: switch to new vmx.h exit controls
In reply to Jon KohlerMigrate to new vmx.h's exit controls, which makes it easier to grok from one code base to another.
No functional change intended.
--- x86/vmx.c | 6 ++-- x86/vmx.h | 12 ------- x86/vmx_tests.c | 86 +++++++++++++++++++++++++++---------------------- 3 files changed, 52 insertions(+), 52 deletions(-)
x86/vmx.c +4 -2
@@ -1132,7 +1132,7 @@ static void init_vmcs_host(void)vmcs_write (HOST_CR4 ,read_cr4 ());vmcs_write (HOST_SYSENTER_EIP , (u64)(&entry_sysenter));vmcs_write (HOST_SYSENTER_CS ,KERNEL_CS ); -if (ctrl_exit_rev.clr &EXI_LOAD_PAT ) +if (ctrl_exit_rev.clr &VM_EXIT_LOAD_IA32_PAT )vmcs_write (HOST_PAT ,rdmsr (MSR_IA32_CR_PAT ));/* 26.2.3 */
@@ -1257,7 +1257,9 @@ int init_vmcs(struct vmcs **vmcs) ctrl_pin |=PIN_BASED_EXT_INTR_MASK |PIN_BASED_NMI_EXITING |PIN_BASED_VIRTUAL_NMIS ; - ctrl_exit =EXI_LOAD_EFER |EXI_HOST_64 |EXI_LOAD_PAT ; + ctrl_exit =VM_EXIT_LOAD_IA32_EFER | +VM_EXIT_HOST_ADDR_SPACE_SIZE | +VM_EXIT_LOAD_IA32_PAT ; ctrl_enter = (ENT_LOAD_EFER |ENT_GUEST_64 );/* DIsable IO instruction VMEXIT now */ ctrl_cpu[0 ] &= (~(CPU_BASED_UNCOND_IO_EXITING |CPU_BASED_USE_IO_BITMAPS ));
x86/vmx.h +0 -12
@@ -406,18 +406,6 @@ enum Reason { VMX_XRSTORS = 64, }; -enum Ctrl_exi { -EXI_SAVE_DBGCTLS =1UL <<2 , -EXI_HOST_64 =1UL <<9 , -EXI_LOAD_PERF =1UL <<12 , -EXI_INTA =1UL <<15 , -EXI_SAVE_PAT =1UL <<18 , -EXI_LOAD_PAT =1UL <<19 , -EXI_SAVE_EFER =1UL <<20 , -EXI_LOAD_EFER =1UL <<21 , -EXI_SAVE_PREEMPT =1UL <<22 , -}; -enum Ctrl_ent {ENT_LOAD_DBGCTLS =1UL <<2 ,ENT_GUEST_64 =1UL <<9 ,
x86/vmx_tests.c +48 -38
284 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 15/17 x86/vmx: switch to new vmx.h entry controls
In reply to Jon KohlerMigrate to new vmx.h's entry controls, which makes it easier to grok from one code base to another.
No functional change intended.
--- x86/vmx.c | 6 +-- x86/vmx.h | 9 ----- x86/vmx_tests.c | 97 ++++++++++++++++++++++++++----------------------- 3 files changed, 55 insertions(+), 57 deletions(-)
x86/vmx.c +3 -3
@@ -1167,11 +1167,11 @@ static void init_vmcs_guest(void) guest_cr0 =read_cr0 (); guest_cr4 =read_cr4 (); guest_cr3 =read_cr3 (); -if (ctrl_enter &ENT_GUEST_64 ) { +if (ctrl_enter &VM_ENTRY_IA32E_MODE ) { guest_cr0 |=X86_CR0_PG ; guest_cr4 |=X86_CR4_PAE ; } -if ((ctrl_enter &ENT_GUEST_64 ) ==0 ) +if ((ctrl_enter &VM_ENTRY_IA32E_MODE ) ==0 ) guest_cr4 &= (~X86_CR4_PCIDE );if (guest_cr0 &X86_CR0_PG ) guest_cr0 |=X86_CR0_PE ;
@@ -1260,7 +1260,7 @@ int init_vmcs(struct vmcs **vmcs) ctrl_exit =VM_EXIT_LOAD_IA32_EFER |VM_EXIT_HOST_ADDR_SPACE_SIZE |VM_EXIT_LOAD_IA32_PAT ; - ctrl_enter = (ENT_LOAD_EFER |ENT_GUEST_64 ); + ctrl_enter = (VM_ENTRY_LOAD_IA32_EFER |VM_ENTRY_IA32E_MODE );/* DIsable IO instruction VMEXIT now */ ctrl_cpu[0 ] &= (~(CPU_BASED_UNCOND_IO_EXITING |CPU_BASED_USE_IO_BITMAPS )); ctrl_cpu[1 ] =0 ;
x86/vmx.h +0 -9
@@ -406,15 +406,6 @@ enum Reason { VMX_XRSTORS = 64, }; -enum Ctrl_ent { -ENT_LOAD_DBGCTLS =1UL <<2 , -ENT_GUEST_64 =1UL <<9 , -ENT_LOAD_PERF =1UL <<13 , -ENT_LOAD_PAT =1UL <<14 , -ENT_LOAD_EFER =1UL <<15 , -ENT_LOAD_BNDCFGS =1UL <<16 -}; -enum Intr_type {VMX_INTR_TYPE_EXT_INTR =0 ,VMX_INTR_TYPE_NMI_INTR =2 ,
x86/vmx_tests.c +52 -45
288 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH 16/17 x86/vmx: switch to new vmx.h interrupt defs
In reply to Jon KohlerMigrate to new vmx.h's interrupt definitions, which makes it easier to grok from one code base to another.
No functional change intended.
--- x86/vmx.h | 22 ---------------------- x86/vmx_tests.c | 12 ++++++------ 2 files changed, 6 insertions(+), 28 deletions(-)
x86/vmx.h +0 -22
@@ -406,31 +406,9 @@ enum Reason { VMX_XRSTORS = 64, }; -enum Intr_type { -VMX_INTR_TYPE_EXT_INTR =0 , -VMX_INTR_TYPE_NMI_INTR =2 , -VMX_INTR_TYPE_HARD_EXCEPTION =3 , -VMX_INTR_TYPE_SOFT_INTR =4 , -VMX_INTR_TYPE_SOFT_EXCEPTION =6 , -}; - -/* -* Interruption-information format -*/ -#define INTR_INFO_VECTOR_MASK 0xff/* 7:0 */ -#define INTR_INFO_INTR_TYPE_MASK 0x700/* 10:8 */ -#define INTR_INFO_DELIVER_CODE_MASK 0x800/* 11 */ -#define INTR_INFO_UNBLOCK_NMI_MASK 0x1000/* 12 */ -#define INTR_INFO_VALID_MASK 0x80000000/* 31 */ #define INTR_INFO_INTR_TYPE_SHIFT 8 -/* -* Guest interruptibility state -*/ -#define GUEST_INTR_STATE_MOVSS (1 << 1) -#define GUEST_INTR_STATE_ENCLAVE (1 << 4) -#define SAVE_GPR \ "xchg %rax, regs\n\t" \
x86/vmx_tests.c +6 -6
@@ -1763,7 +1763,7 @@ static int interrupt_exit_handler(union exit_reason exit_reason)vmcs_write (GUEST_ACTV_STATE ,ACTV_HLT );vmcs_write (ENT_INTR_INFO ,TIMER_VECTOR | - (VMX_INTR_TYPE_EXT_INTR <<INTR_INFO_INTR_TYPE_SHIFT ) | +INTR_TYPE_EXT_INTR |INTR_INFO_VALID_MASK );break ; }
@@ -8803,7 +8803,7 @@ static void vmx_nmi_window_test(void)* is one byte.) */ report_prefix_push ("active, blocking by MOV-SS" ); -vmcs_write (GUEST_INTR_STATE ,GUEST_INTR_STATE_MOVSS ); +vmcs_write (GUEST_INTR_STATE ,GUEST_INTR_STATE_MOV_SS );enter_guest ();verify_nmi_window_exit (nop_addr +1 );report_prefix_pop ();
@@ -8969,7 +8969,7 @@ static void vmx_intr_window_test(void)* instruction. (NOP is one byte.) */ report_prefix_push ("active, blocking by MOV-SS, RFLAGS.IF=1" ); -vmcs_write (GUEST_INTR_STATE ,GUEST_INTR_STATE_MOVSS ); +vmcs_write (GUEST_INTR_STATE ,GUEST_INTR_STATE_MOV_SS );enter_guest ();verify_intr_window_exit (nop_addr +1 );report_prefix_pop ();
@@ -9479,7 +9479,7 @@ static void single_step_guest(const char *test_name, u64 starting_dr6,vmcs_write (GUEST_RFLAGS ,X86_EFLAGS_FIXED |X86_EFLAGS_TF );if (pending_debug_exceptions) {vmcs_write (GUEST_PENDING_DEBUG , pending_debug_exceptions); -vmcs_write (GUEST_INTR_STATE ,GUEST_INTR_STATE_MOVSS ); +vmcs_write (GUEST_INTR_STATE ,GUEST_INTR_STATE_MOV_SS ); }enter_guest (); }
@@ -10982,9 +10982,9 @@ static void handle_exception_in_l1(u32 vector)enter_guest ();if (vector ==BP_VECTOR || vector ==OF_VECTOR ) - intr_type =VMX_INTR_TYPE_SOFT_EXCEPTION ; + intr_type =EVENT_TYPE_SWEXC ;else - intr_type =VMX_INTR_TYPE_HARD_EXCEPTION ; + intr_type =EVENT_TYPE_HWEXC ; intr_info =vmcs_read (EXI_INTR_INFO ); report((vmcs_read(EXI_REASON) == VMX_EXC_NMI) &&
Signature · 1 line
2.43.0
PATCH 17/17 x86/vmx: align exit reasons with Linux uapi
In reply to Jon KohlerAlign x86/vmx.h' enum Reasons with Linux's arch/x86/include/uapi/asm/vmx.h EXIT_REASON_* definitions. Given how exit codes are wired up already in KUT, it doesn't make a whole lot of sense to switch to the uapi header itself; however, aligning the definitions makes it easier to grok from one code base to another.
Note: this change picks up several previously undefined exit reasons, such as UMWAIT, TPAUSE, BUS_LOCK, NOTIFY, TDCALL but does not add test cases for them.
Note: Fixed misc indentation issues picked up by checkpatch along the way.
No functional change intended.
--- x86/vmx.c | 134 ++++++++++++----------- x86/vmx.h | 125 +++++++++++---------- x86/vmx_tests.c | 283 +++++++++++++++++++++++++----------------------- 3 files changed, 280 insertions(+), 262 deletions(-)
x86/vmx.c +69 -65
@@ -582,67 +582,71 @@ static void __attribute__((__used__)) syscall_handler(u64 syscall_no) current->syscall_handler (syscall_no); } +/* Naming scheme aligns with Linux's arch/x86/include/uapi/asm/vmx.h */ static const char *const exit_reason_descriptions[] = { - [VMX_EXC_NMI ] ="VMX_EXC_NMI" , - [VMX_EXTINT ] ="VMX_EXTINT" , - [VMX_TRIPLE_FAULT ] ="VMX_TRIPLE_FAULT" , - [VMX_INIT ] ="VMX_INIT" , - [VMX_SIPI ] ="VMX_SIPI" , - [VMX_SMI_IO ] ="VMX_SMI_IO" , - [VMX_SMI_OTHER ] ="VMX_SMI_OTHER" , - [VMX_INTR_WINDOW ] ="VMX_INTR_WINDOW" , - [VMX_NMI_WINDOW ] ="VMX_NMI_WINDOW" , - [VMX_TASK_SWITCH ] ="VMX_TASK_SWITCH" , - [VMX_CPUID ] ="VMX_CPUID" , - [VMX_GETSEC ] ="VMX_GETSEC" , - [VMX_HLT ] ="VMX_HLT" , - [VMX_INVD ] ="VMX_INVD" , - [VMX_INVLPG ] ="VMX_INVLPG" , - [VMX_RDPMC ] ="VMX_RDPMC" , - [VMX_RDTSC ] ="VMX_RDTSC" , - [VMX_RSM ] ="VMX_RSM" , - [VMX_VMCALL ] ="VMX_VMCALL" , - [VMX_VMCLEAR ] ="VMX_VMCLEAR" , - [VMX_VMLAUNCH ] ="VMX_VMLAUNCH" , - [VMX_VMPTRLD ] ="VMX_VMPTRLD" , - [VMX_VMPTRST ] ="VMX_VMPTRST" , - [VMX_VMREAD ] ="VMX_VMREAD" , - [VMX_VMRESUME ] ="VMX_VMRESUME" , - [VMX_VMWRITE ] ="VMX_VMWRITE" , - [VMX_VMXOFF ] ="VMX_VMXOFF" , - [VMX_VMXON ] ="VMX_VMXON" , - [VMX_CR ] ="VMX_CR" , - [VMX_DR ] ="VMX_DR" , - [VMX_IO ] ="VMX_IO" , - [VMX_RDMSR ] ="VMX_RDMSR" , - [VMX_WRMSR ] ="VMX_WRMSR" , - [VMX_FAIL_STATE ] ="VMX_FAIL_STATE" , - [VMX_FAIL_MSR ] ="VMX_FAIL_MSR" , - [VMX_MWAIT ] ="VMX_MWAIT" , - [VMX_MTF ] ="VMX_MTF" , - [VMX_MONITOR ] ="VMX_MONITOR" , - [VMX_PAUSE ] ="VMX_PAUSE" , - [VMX_FAIL_MCHECK ] ="VMX_FAIL_MCHECK" , - [VMX_TPR_THRESHOLD ] ="VMX_TPR_THRESHOLD" , - [VMX_APIC_ACCESS ] ="VMX_APIC_ACCESS" , - [VMX_EOI_INDUCED ] ="VMX_EOI_INDUCED" , - [VMX_GDTR_IDTR ] ="VMX_GDTR_IDTR" , - [VMX_LDTR_TR ] ="VMX_LDTR_TR" , - [VMX_EPT_VIOLATION ] ="VMX_EPT_VIOLATION" , - [VMX_EPT_MISCONFIG ] ="VMX_EPT_MISCONFIG" , - [VMX_INVEPT ] ="VMX_INVEPT" , - [VMX_PREEMPT ] ="VMX_PREEMPT" , - [VMX_INVVPID ] ="VMX_INVVPID" , - [VMX_WBINVD ] ="VMX_WBINVD" , - [VMX_XSETBV ] ="VMX_XSETBV" , - [VMX_APIC_WRITE ] ="VMX_APIC_WRITE" , - [VMX_RDRAND ] ="VMX_RDRAND" , - [VMX_INVPCID ] ="VMX_INVPCID" , - [VMX_VMFUNC ] ="VMX_VMFUNC" , - [VMX_RDSEED ] ="VMX_RDSEED" , - [VMX_PML_FULL ] ="VMX_PML_FULL" , - [VMX_XSAVES ] ="VMX_XSAVES" , - [VMX_XRSTORS ] ="VMX_XRSTORS" , + [EXIT_REASON_EXCEPTION_NMI ] ="EXCEPTION_NMI" , + [EXIT_REASON_EXTERNAL_INTERRUPT ] ="EXTERNAL_INTERRUPT" , + [EXIT_REASON_TRIPLE_FAULT ] ="TRIPLE_FAULT" , + [EXIT_REASON_INIT_SIGNAL ] ="INIT_SIGNAL" , + [EXIT_REASON_SIPI_SIGNAL ] ="SIPI_SIGNAL" , + [EXIT_REASON_INTERRUPT_WINDOW ] ="INTERRUPT_WINDOW" , + [EXIT_REASON_NMI_WINDOW ] ="NMI_WINDOW" , + [EXIT_REASON_TASK_SWITCH ] ="TASK_SWITCH" , + [EXIT_REASON_CPUID ] ="CPUID" , + [EXIT_REASON_HLT ] ="HLT" , + [EXIT_REASON_INVD ] ="INVD" , + [EXIT_REASON_INVLPG ] ="INVLPG" , + [EXIT_REASON_RDPMC ] ="RDPMC" , + [EXIT_REASON_RDTSC ] ="RDTSC" , + [EXIT_REASON_VMCALL ] ="VMCALL" , + [EXIT_REASON_VMCLEAR ] ="VMCLEAR" , + [EXIT_REASON_VMLAUNCH ] ="VMLAUNCH" , + [EXIT_REASON_VMPTRLD ] ="VMPTRLD" , + [EXIT_REASON_VMPTRST ] ="VMPTRST" , + [EXIT_REASON_VMREAD ] ="VMREAD" , + [EXIT_REASON_VMRESUME ] ="VMRESUME" , + [EXIT_REASON_VMWRITE ] ="VMWRITE" , + [EXIT_REASON_VMOFF ] ="VMOFF" , + [EXIT_REASON_VMON ] ="VMON" , + [EXIT_REASON_CR_ACCESS ] ="CR_ACCESS" , + [EXIT_REASON_DR_ACCESS ] ="DR_ACCESS" , + [EXIT_REASON_IO_INSTRUCTION ] ="IO_INSTRUCTION" , + [EXIT_REASON_MSR_READ ] ="MSR_READ" , + [EXIT_REASON_MSR_WRITE ] ="MSR_WRITE" , + [EXIT_REASON_INVALID_STATE ] ="INVALID_STATE" , + [EXIT_REASON_MSR_LOAD_FAIL ] ="MSR_LOAD_FAIL" , + [EXIT_REASON_MWAIT_INSTRUCTION ] ="MWAIT_INSTRUCTION" , + [EXIT_REASON_MONITOR_TRAP_FLAG ] ="MONITOR_TRAP_FLAG" , + [EXIT_REASON_MONITOR_INSTRUCTION ] ="MONITOR_INSTRUCTION" , + [EXIT_REASON_PAUSE_INSTRUCTION ] ="PAUSE_INSTRUCTION" , + [EXIT_REASON_MCE_DURING_VMENTRY ] ="MCE_DURING_VMENTRY" , + [EXIT_REASON_TPR_BELOW_THRESHOLD ] ="TPR_BELOW_THRESHOLD" , + [EXIT_REASON_APIC_ACCESS ] ="APIC_ACCESS" , + [EXIT_REASON_EOI_INDUCED ] ="EOI_INDUCED" , + [EXIT_REASON_GDTR_IDTR ] ="GDTR_IDTR" , + [EXIT_REASON_LDTR_TR ] ="LDTR_TR" , + [EXIT_REASON_EPT_VIOLATION ] ="EPT_VIOLATION" , + [EXIT_REASON_EPT_MISCONFIG ] ="EPT_MISCONFIG" , + [EXIT_REASON_INVEPT ] ="INVEPT" , + [EXIT_REASON_RDTSCP ] ="RDTSCP" , + [EXIT_REASON_PREEMPTION_TIMER ] ="PREEMPTION_TIMER" , + [EXIT_REASON_INVVPID ] ="INVVPID" , + [EXIT_REASON_WBINVD ] ="WBINVD" , + [EXIT_REASON_XSETBV ] ="XSETBV" , + [EXIT_REASON_APIC_WRITE ] ="APIC_WRITE" , + [EXIT_REASON_RDRAND ] ="RDRAND" , + [EXIT_REASON_INVPCID ] ="INVPCID" , + [EXIT_REASON_VMFUNC ] ="VMFUNC" , + [EXIT_REASON_ENCLS ] ="ENCLS" , + [EXIT_REASON_RDSEED ] ="RDSEED" , + [EXIT_REASON_PML_FULL ] ="PML_FULL" , + [EXIT_REASON_XSAVES ] ="XSAVES" , + [EXIT_REASON_XRSTORS ] ="XRSTORS" , + [EXIT_REASON_UMWAIT ] ="UMWAIT" , + [EXIT_REASON_TPAUSE ] ="TPAUSE" , + [EXIT_REASON_BUS_LOCK ] ="BUS_LOCK" , + [EXIT_REASON_NOTIFY ] ="NOTIFY" , + [EXIT_REASON_TDCALL ] ="TDCALL" , };const char *exit_reason_description (u64 reason)
@@ -698,13 +702,13 @@ void print_vmentry_failure_info(struct vmentry_result *result) result->instr, result->exit_reason.full, qual);switch (result->exit_reason.basic) { -case VMX_FAIL_STATE : +case EXIT_REASON_INVALID_STATE :printf ("invalid guest state\n" );break ; -case VMX_FAIL_MSR : +case EXIT_REASON_MSR_LOAD_FAIL :printf ("MSR loading\n" );break ; -case VMX_FAIL_MCHECK : +case EXIT_REASON_MCE_DURING_VMENTRY :printf ("machine-check event\n" );break ;default :
@@ -1681,7 +1685,7 @@ void __attribute__((__used__)) hypercall(u32 hypercall_no)static bool is_hypercall (union exit_reason exit_reason) { -return exit_reason.basic ==VMX_VMCALL && +return exit_reason.basic ==EXIT_REASON_VMCALL && (hypercall_field &HYPERCALL_BIT ); }
@@ -2002,7 +2006,7 @@ void __enter_guest(u8 abort_flag, struct vmentry_result *result) }if (result->exit_reason.failed_vmentry) {if ((abort_flag &ABORT_ON_INVALID_GUEST_STATE ) || - result->exit_reason.basic !=VMX_FAIL_STATE ) + result->exit_reason.basic !=EXIT_REASON_INVALID_STATE ) goto do_abort;return ; }
x86/vmx.h +65 -60
132 lines not on this page · raw message
x86/vmx_tests.c +146 -137
871 lines not on this page · raw message
Signature · 1 line
2.43.0
Sean Christopherson
reviewerQuoted 12 lines · Jon Kohler
This series modernizes VMX definitions to align with the canonical ones within Linux kernel source. Currently, kvm-unit-tests uses custom VMX constant definitions that have grown organically and have diverged from the kernel, increasing the overhead to grok from one code base to another.
This alignment provides several benefits:
- Reduces maintenance overhead by using authoritative definitions
- Eliminates potential bugs from definition mismatches
- Makes the test suite more consistent with kernel code
- Simplifies future updates when new VMX features are added
Quoted 4 lines
Given the lines touched, I've broken this up into two groups within the series:
Group 1: Import various headers from Linux kernel 6.16 (P01-04)
Hrm. I'm definitely in favor of aligning names, and not opposed to pulling information from the kernel, but I don't think I like the idea of doing a straight copy+paste. The arch/x86/include/asm/vmxfeatures.h insanity in particular is pure overhead/noise in KUT. E.g. the layer of indirection to find out the bit number is _really_ annoying, and the shifting done for VMFUNC is downright gross, but at least in the kernel we get pretty printing in /proc/cpuinfo.
Similarly, I don't want to pull in trapnr.h verbatim, because KVM already provides <nr>_VECTOR in a uapi header, and I strongly prefer the <nr>_VECTOR macros ("trap" is very misleading when considering fault-like vs. trap-like exceptions).
This is also a good opportunity to align the third player: KVM selftests. Which kinda sorta copy the kernel headers, but with stale and annoying differences.
Lastly, if we're going to pull from the kernel, ideally we would have a script to semi-automate updating the KUT side of things.
So, I think/hope we can kill a bunch of birds at once by creating a script to parse the kernel's vmxfeatures.h, vmx.h, trapnr.h, msr-index.h (to replace lib/x86/msr.h), and generate the pieces we want. And if we do that for KVM selftests, then we can commit the script to the kernel repo, i.e. we can make it the kernel's responsibility to keep the script up-to-date, e.g. if there's a big rename or something.
Quoted 61 lines
Headers were brought in with minimal adaptation outside of minor tweaks for includes, etc.
Group 2: Mechanically replace existing constants with equivalents (P05-17)
Replace custom VMX constant definitions in
x86/vmx.hwith Linux kernel equivalents fromlib/linux/vmx.h. This systematic replacement covers:- Pin-based VM-execution controls (PIN_* -> PIN_BASED_*)
- CPU-based VM-execution controls (CPU_* -> CPU_BASED_*, SECONDARY_EXEC_*)
- VM-exit controls (EXI_* -> VM_EXIT_*)
- VM-entry controls (ENT_* -> VM_ENTRY_*)
- VMCS field names (custom enum -> standard Linux enum)
- VMX exit reasons (VMX_* -> EXIT_REASON_*)
- Interrupt/exception type definitionsAll functional behavior is preserved - only the constant names and values change to match Linux kernel definitions. All existing VMX tests pass with no functional changes.
There is still a bit of bulk in
x86/vmx.h, which can be addressed in future patches as needed.Jon Kohler (17):
lib: add linuxvmx.hclone from 6.16
lib: add linuxtrapnr.hclone from 6.16
lib: addvmxfeatures.hclone from 6.16
lib: define__aligned()incompiler.h
x86/vmx: basic integration for newvmx.h
x86/vmx: switch to newvmx.hEPT violation defs x86/vmx: switch to newvmx.hEPT RWX defs
x86/vmx: switch to newvmx.hEPT access and dirty defs x86/vmx: switch to newvmx.hEPT capability and memory type defs x86/vmx: switch to newvmx.hprimary processor-based VM-execution
controls
x86/vmx: switch to newvmx.hsecondary execution control bit x86/vmx: switch to newvmx.hsecondary execution controls x86/vmx: switch to newvmx.hpin based VM-execution controls x86/vmx: switch to newvmx.hexit controls
x86/vmx: switch to newvmx.hentry controls
x86/vmx: switch to newvmx.hinterrupt defs
x86/vmx: align exit reasons with Linux uapilib/linux/compiler.h | 1 + lib/linux/trapnr.h | 44 ++ lib/linux/vmx.h | 672 ++++++++++++++++++ lib/linux/vmxfeatures.h | 93 +++ lib/x86/msr.h | 14 + x86/vmx.c | 230 +++--- x86/vmx.h | 356 ++-------- x86/vmx_tests.c | 1489 ++++++++++++++++++++++----------------- 8 files changed, 1876 insertions(+), 1023 deletions(-) create mode 100644 lib/linux/trapnr.h create mode 100644 lib/linux/vmx.h create mode 100644 lib/linux/vmxfeatures.hbase-commit:
890498d834b68104e79b57a801fa11fc6ce82846Signature · 1 line
2.43.0
Quoted 44 lines · Sean Christopherson
!-------------------------------------------------------------------|
CAUTION: External Email|-------------------------------------------------------------------!
Quoted 12 lines · Jon Kohler
This series modernizes VMX definitions to align with the canonical ones within Linux kernel source. Currently, kvm-unit-tests uses custom VMX constant definitions that have grown organically and have diverged from the kernel, increasing the overhead to grok from one code base to another.
This alignment provides several benefits:
- Reduces maintenance overhead by using authoritative definitions
- Eliminates potential bugs from definition mismatches
- Makes the test suite more consistent with kernel code
- Simplifies future updates when new VMX features are addedQuoted 4 lines
Given the lines touched, I've broken this up into two groups within the series:
Group 1: Import various headers from Linux kernel 6.16 (P01-04)
Hrm. I'm definitely in favor of aligning names, and not opposed to pulling information from the kernel, but I don't think I like the idea of doing a straight copy+paste. The
arch/x86/include/asm/vmxfeatures.hinsanity in particular is pure overhead/noise in KUT. E.g. the layer of indirection to find out the bit number is _really_ annoying, and the shifting done for VMFUNC is downright gross, but at least in the kernel we get pretty printing in/proc/cpuinfo.Similarly, I don't want to pull in
trapnr.hverbatim, because KVM already provides <nr>_VECTOR in a uapi header, and I strongly prefer the <nr>_VECTOR macros ("trap" is very misleading when considering fault-like vs. trap-like exceptions).This is also a good opportunity to align the third player: KVM selftests. Which kinda sorta copy the kernel headers, but with stale and annoying differences.
Lastly, if we're going to pull from the kernel, ideally we would have a script to semi-automate updating the KUT side of things.
Quoted 6 lines
So, I think/hope we can kill a bunch of birds at once by creating a script to parse the kernel's
vmxfeatures.h,vmx.h,trapnr.h,msr-index.h(to replacelib/x86/msr.h), and generate the pieces we want. And if we do that for KVM selftests, then we can commit the script to the kernel repo, i.e. we can make it the kernel's responsibility to keep the script up-to-date, e.g. if there's a big rename or something.
Thanks, Sean - Happy to take a swing at if you don’t already have something cooked up to magic that into existence. Any chance any other subsystems do something similar? Want to make sure we don’t re-invent the wheel if so.
Otherwise, happy to start from scratch, thats fine too.
Jon
Quoted 61 lines
Quoted 61 lines
Headers were brought in with minimal adaptation outside of minor tweaks for includes, etc.
Group 2: Mechanically replace existing constants with equivalents (P05-17)
Replace custom VMX constant definitions in
x86/vmx.hwith Linux kernel equivalents fromlib/linux/vmx.h. This systematic replacement covers:- Pin-based VM-execution controls (PIN_* -> PIN_BASED_*)
- CPU-based VM-execution controls (CPU_* -> CPU_BASED_*, SECONDARY_EXEC_*)
- VM-exit controls (EXI_* -> VM_EXIT_*)
- VM-entry controls (ENT_* -> VM_ENTRY_*)
- VMCS field names (custom enum -> standard Linux enum)
- VMX exit reasons (VMX_* -> EXIT_REASON_*)
- Interrupt/exception type definitionsAll functional behavior is preserved - only the constant names and values change to match Linux kernel definitions. All existing VMX tests pass with no functional changes.
There is still a bit of bulk in
x86/vmx.h, which can be addressed in future patches as needed.Jon Kohler (17):
lib: add linuxvmx.hclone from 6.16
lib: add linuxtrapnr.hclone from 6.16
lib: addvmxfeatures.hclone from 6.16
lib: define__aligned()incompiler.h
x86/vmx: basic integration for newvmx.h
x86/vmx: switch to newvmx.hEPT violation defs x86/vmx: switch to newvmx.hEPT RWX defs
x86/vmx: switch to newvmx.hEPT access and dirty defs x86/vmx: switch to newvmx.hEPT capability and memory type defs x86/vmx: switch to newvmx.hprimary processor-based VM-execution
controls
x86/vmx: switch to newvmx.hsecondary execution control bit x86/vmx: switch to newvmx.hsecondary execution controls x86/vmx: switch to newvmx.hpin based VM-execution controls x86/vmx: switch to newvmx.hexit controls
x86/vmx: switch to newvmx.hentry controls
x86/vmx: switch to newvmx.hinterrupt defs
x86/vmx: align exit reasons with Linux uapilib/linux/compiler.h | 1 + lib/linux/trapnr.h | 44 ++ lib/linux/vmx.h | 672 ++++++++++++++++++ lib/linux/vmxfeatures.h | 93 +++ lib/x86/msr.h | 14 + x86/vmx.c | 230 +++--- x86/vmx.h | 356 ++-------- x86/vmx_tests.c | 1489 ++++++++++++++++++++++----------------- 8 files changed, 1876 insertions(+), 1023 deletions(-)create mode 100644
lib/linux/trapnr.h
create mode 100644lib/linux/vmx.h
create mode 100644lib/linux/vmxfeatures.hbase-commit:
890498d834b68104e79b57a801fa11fc6ce82846Signature · 1 line
2.43.0
Sean Christopherson
reviewerQuoted 43 lines · Jon Kohler
Quoted 36 lines · Sean Christopherson
Quoted 12 lines · Jon Kohler
This series modernizes VMX definitions to align with the canonical ones within Linux kernel source. Currently, kvm-unit-tests uses custom VMX constant definitions that have grown organically and have diverged from the kernel, increasing the overhead to grok from one code base to another.
This alignment provides several benefits:
- Reduces maintenance overhead by using authoritative definitions
- Eliminates potential bugs from definition mismatches
- Makes the test suite more consistent with kernel code
- Simplifies future updates when new VMX features are addedQuoted 4 lines
Given the lines touched, I've broken this up into two groups within the series:
Group 1: Import various headers from Linux kernel 6.16 (P01-04)
Hrm. I'm definitely in favor of aligning names, and not opposed to pulling information from the kernel, but I don't think I like the idea of doing a straight copy+paste. The
arch/x86/include/asm/vmxfeatures.hinsanity in particular is pure overhead/noise in KUT. E.g. the layer of indirection to find out the bit number is _really_ annoying, and the shifting done for VMFUNC is downright gross, but at least in the kernel we get pretty printing in/proc/cpuinfo.Similarly, I don't want to pull in
trapnr.hverbatim, because KVM already provides <nr>_VECTOR in a uapi header, and I strongly prefer the <nr>_VECTOR macros ("trap" is very misleading when considering fault-like vs. trap-like exceptions).This is also a good opportunity to align the third player: KVM selftests. Which kinda sorta copy the kernel headers, but with stale and annoying differences.
Lastly, if we're going to pull from the kernel, ideally we would have a script to semi-automate updating the KUT side of things.
Quoted 6 lines
So, I think/hope we can kill a bunch of birds at once by creating a script to parse the kernel's
vmxfeatures.h,vmx.h,trapnr.h,msr-index.h(to replacelib/x86/msr.h), and generate the pieces we want. And if we do that for KVM selftests, then we can commit the script to the kernel repo, i.e. we can make it the kernel's responsibility to keep the script up-to-date, e.g. if there's a big rename or something.
Quoted 3 lines
Thanks, Sean - Happy to take a swing at if you don’t already have something cooked up to magic that into existence. Any chance any other subsystems do something similar? Want to make sure we don’t re-invent the wheel if so.
AFAIK, there's no prior art. :-/
People do have scripts to manage headers, but they're for simple use cases of copying kernel headers elsewhere.