kvm/vmx/vmcs12.h

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #ifndef __KVM_X86_VMX_VMCS12_H
0003 #define __KVM_X86_VMX_VMCS12_H
0004
0005 #include <linux/build_bug.h>
0006
0007 #include "vmcs.h"
0008
0009 /*
0010  * struct vmcs12 describes the state that our guest hypervisor (L1) keeps for a
0011  * single nested guest (L2), hence the name vmcs12. Any VMX implementation has
0012  * a VMCS structure, and vmcs12 is our emulated VMX's VMCS. This structure is
0013  * stored in guest memory specified by VMPTRLD, but is opaque to the guest,
0014  * which must access it using VMREAD/VMWRITE/VMCLEAR instructions.
0015  * More than one of these structures may exist, if L1 runs multiple L2 guests.
0016  * nested_vmx_run() will use the data here to build the vmcs02: a VMCS for the
0017  * underlying hardware which will be used to run L2.
0018  * This structure is packed to ensure that its layout is identical across
0019  * machines (necessary for live migration).
0020  *
0021  * IMPORTANT: Changing the layout of existing fields in this structure
0022  * will break save/restore compatibility with older kvm releases. When
0023  * adding new fields, either use space in the reserved padding* arrays
0024  * or add the new fields to the end of the structure.
0025  */
0026 typedef u64 natural_width;
0027 struct __packed vmcs12 {
0028     /* According to the Intel spec, a VMCS region must start with the
0029      * following two fields. Then follow implementation-specific data.
0030      */
0031     struct vmcs_hdr hdr;
0032     u32 abort;
0033
0034     u32 launch_state; /* set to 0 by VMCLEAR, to 1 by VMLAUNCH */
0035     u32 padding[7]; /* room for future expansion */
0036
0037     u64 io_bitmap_a;
0038     u64 io_bitmap_b;
0039     u64 msr_bitmap;
0040     u64 vm_exit_msr_store_addr;
0041     u64 vm_exit_msr_load_addr;
0042     u64 vm_entry_msr_load_addr;
0043     u64 tsc_offset;
0044     u64 virtual_apic_page_addr;
0045     u64 apic_access_addr;
0046     u64 posted_intr_desc_addr;
0047     u64 ept_pointer;
0048     u64 eoi_exit_bitmap0;
0049     u64 eoi_exit_bitmap1;
0050     u64 eoi_exit_bitmap2;
0051     u64 eoi_exit_bitmap3;
0052     u64 xss_exit_bitmap;
0053     u64 guest_physical_address;
0054     u64 vmcs_link_pointer;
0055     u64 guest_ia32_debugctl;
0056     u64 guest_ia32_pat;
0057     u64 guest_ia32_efer;
0058     u64 guest_ia32_perf_global_ctrl;
0059     u64 guest_pdptr0;
0060     u64 guest_pdptr1;
0061     u64 guest_pdptr2;
0062     u64 guest_pdptr3;
0063     u64 guest_bndcfgs;
0064     u64 host_ia32_pat;
0065     u64 host_ia32_efer;
0066     u64 host_ia32_perf_global_ctrl;
0067     u64 vmread_bitmap;
0068     u64 vmwrite_bitmap;
0069     u64 vm_function_control;
0070     u64 eptp_list_address;
0071     u64 pml_address;
0072     u64 encls_exiting_bitmap;
0073     u64 tsc_multiplier;
0074     u64 padding64[1]; /* room for future expansion */
0075     /*
0076      * To allow migration of L1 (complete with its L2 guests) between
0077      * machines of different natural widths (32 or 64 bit), we cannot have
0078      * unsigned long fields with no explicit size. We use u64 (aliased
0079      * natural_width) instead. Luckily, x86 is little-endian.
0080      */
0081     natural_width cr0_guest_host_mask;
0082     natural_width cr4_guest_host_mask;
0083     natural_width cr0_read_shadow;
0084     natural_width cr4_read_shadow;
0085     natural_width dead_space[4]; /* Last remnants of cr3_target_value[0-3]. */
0086     natural_width exit_qualification;
0087     natural_width guest_linear_address;
0088     natural_width guest_cr0;
0089     natural_width guest_cr3;
0090     natural_width guest_cr4;
0091     natural_width guest_es_base;
0092     natural_width guest_cs_base;
0093     natural_width guest_ss_base;
0094     natural_width guest_ds_base;
0095     natural_width guest_fs_base;
0096     natural_width guest_gs_base;
0097     natural_width guest_ldtr_base;
0098     natural_width guest_tr_base;
0099     natural_width guest_gdtr_base;
0100     natural_width guest_idtr_base;
0101     natural_width guest_dr7;
0102     natural_width guest_rsp;
0103     natural_width guest_rip;
0104     natural_width guest_rflags;
0105     natural_width guest_pending_dbg_exceptions;
0106     natural_width guest_sysenter_esp;
0107     natural_width guest_sysenter_eip;
0108     natural_width host_cr0;
0109     natural_width host_cr3;
0110     natural_width host_cr4;
0111     natural_width host_fs_base;
0112     natural_width host_gs_base;
0113     natural_width host_tr_base;
0114     natural_width host_gdtr_base;
0115     natural_width host_idtr_base;
0116     natural_width host_ia32_sysenter_esp;
0117     natural_width host_ia32_sysenter_eip;
0118     natural_width host_rsp;
0119     natural_width host_rip;
0120     natural_width paddingl[8]; /* room for future expansion */
0121     u32 pin_based_vm_exec_control;
0122     u32 cpu_based_vm_exec_control;
0123     u32 exception_bitmap;
0124     u32 page_fault_error_code_mask;
0125     u32 page_fault_error_code_match;
0126     u32 cr3_target_count;
0127     u32 vm_exit_controls;
0128     u32 vm_exit_msr_store_count;
0129     u32 vm_exit_msr_load_count;
0130     u32 vm_entry_controls;
0131     u32 vm_entry_msr_load_count;
0132     u32 vm_entry_intr_info_field;
0133     u32 vm_entry_exception_error_code;
0134     u32 vm_entry_instruction_len;
0135     u32 tpr_threshold;
0136     u32 secondary_vm_exec_control;
0137     u32 vm_instruction_error;
0138     u32 vm_exit_reason;
0139     u32 vm_exit_intr_info;
0140     u32 vm_exit_intr_error_code;
0141     u32 idt_vectoring_info_field;
0142     u32 idt_vectoring_error_code;
0143     u32 vm_exit_instruction_len;
0144     u32 vmx_instruction_info;
0145     u32 guest_es_limit;
0146     u32 guest_cs_limit;
0147     u32 guest_ss_limit;
0148     u32 guest_ds_limit;
0149     u32 guest_fs_limit;
0150     u32 guest_gs_limit;
0151     u32 guest_ldtr_limit;
0152     u32 guest_tr_limit;
0153     u32 guest_gdtr_limit;
0154     u32 guest_idtr_limit;
0155     u32 guest_es_ar_bytes;
0156     u32 guest_cs_ar_bytes;
0157     u32 guest_ss_ar_bytes;
0158     u32 guest_ds_ar_bytes;
0159     u32 guest_fs_ar_bytes;
0160     u32 guest_gs_ar_bytes;
0161     u32 guest_ldtr_ar_bytes;
0162     u32 guest_tr_ar_bytes;
0163     u32 guest_interruptibility_info;
0164     u32 guest_activity_state;
0165     u32 guest_sysenter_cs;
0166     u32 host_ia32_sysenter_cs;
0167     u32 vmx_preemption_timer_value;
0168     u32 padding32[7]; /* room for future expansion */
0169     u16 virtual_processor_id;
0170     u16 posted_intr_nv;
0171     u16 guest_es_selector;
0172     u16 guest_cs_selector;
0173     u16 guest_ss_selector;
0174     u16 guest_ds_selector;
0175     u16 guest_fs_selector;
0176     u16 guest_gs_selector;
0177     u16 guest_ldtr_selector;
0178     u16 guest_tr_selector;
0179     u16 guest_intr_status;
0180     u16 host_es_selector;
0181     u16 host_cs_selector;
0182     u16 host_ss_selector;
0183     u16 host_ds_selector;
0184     u16 host_fs_selector;
0185     u16 host_gs_selector;
0186     u16 host_tr_selector;
0187     u16 guest_pml_index;
0188 };
0189
0190 /*
0191  * VMCS12_REVISION is an arbitrary id that should be changed if the content or
0192  * layout of struct vmcs12 is changed. MSR_IA32_VMX_BASIC returns this id, and
0193  * VMPTRLD verifies that the VMCS region that L1 is loading contains this id.
0194  *
0195  * IMPORTANT: Changing this value will break save/restore compatibility with
0196  * older kvm releases.
0197  */
0198 #define VMCS12_REVISION 0x11e57ed0
0199
0200 /*
0201  * VMCS12_SIZE is the number of bytes L1 should allocate for the VMXON region
0202  * and any VMCS region. Although only sizeof(struct vmcs12) are used by the
0203  * current implementation, 4K are reserved to avoid future complications and
0204  * to preserve userspace ABI.
0205  */
0206 #define VMCS12_SIZE     KVM_STATE_NESTED_VMX_VMCS_SIZE
0207
0208 /*
0209  * For save/restore compatibility, the vmcs12 field offsets must not change.
0210  */
0211 #define CHECK_OFFSET(field, loc)                \
0212     BUILD_BUG_ON_MSG(offsetof(struct vmcs12, field) != (loc),   \
0213         "Offset of " #field " in struct vmcs12 has changed.")
0214
0215 static inline void vmx_check_vmcs12_offsets(void)
0216 {
0217     CHECK_OFFSET(hdr, 0);
0218     CHECK_OFFSET(abort, 4);
0219     CHECK_OFFSET(launch_state, 8);
0220     CHECK_OFFSET(io_bitmap_a, 40);
0221     CHECK_OFFSET(io_bitmap_b, 48);
0222     CHECK_OFFSET(msr_bitmap, 56);
0223     CHECK_OFFSET(vm_exit_msr_store_addr, 64);
0224     CHECK_OFFSET(vm_exit_msr_load_addr, 72);
0225     CHECK_OFFSET(vm_entry_msr_load_addr, 80);
0226     CHECK_OFFSET(tsc_offset, 88);
0227     CHECK_OFFSET(virtual_apic_page_addr, 96);
0228     CHECK_OFFSET(apic_access_addr, 104);
0229     CHECK_OFFSET(posted_intr_desc_addr, 112);
0230     CHECK_OFFSET(ept_pointer, 120);
0231     CHECK_OFFSET(eoi_exit_bitmap0, 128);
0232     CHECK_OFFSET(eoi_exit_bitmap1, 136);
0233     CHECK_OFFSET(eoi_exit_bitmap2, 144);
0234     CHECK_OFFSET(eoi_exit_bitmap3, 152);
0235     CHECK_OFFSET(xss_exit_bitmap, 160);
0236     CHECK_OFFSET(guest_physical_address, 168);
0237     CHECK_OFFSET(vmcs_link_pointer, 176);
0238     CHECK_OFFSET(guest_ia32_debugctl, 184);
0239     CHECK_OFFSET(guest_ia32_pat, 192);
0240     CHECK_OFFSET(guest_ia32_efer, 200);
0241     CHECK_OFFSET(guest_ia32_perf_global_ctrl, 208);
0242     CHECK_OFFSET(guest_pdptr0, 216);
0243     CHECK_OFFSET(guest_pdptr1, 224);
0244     CHECK_OFFSET(guest_pdptr2, 232);
0245     CHECK_OFFSET(guest_pdptr3, 240);
0246     CHECK_OFFSET(guest_bndcfgs, 248);
0247     CHECK_OFFSET(host_ia32_pat, 256);
0248     CHECK_OFFSET(host_ia32_efer, 264);
0249     CHECK_OFFSET(host_ia32_perf_global_ctrl, 272);
0250     CHECK_OFFSET(vmread_bitmap, 280);
0251     CHECK_OFFSET(vmwrite_bitmap, 288);
0252     CHECK_OFFSET(vm_function_control, 296);
0253     CHECK_OFFSET(eptp_list_address, 304);
0254     CHECK_OFFSET(pml_address, 312);
0255     CHECK_OFFSET(encls_exiting_bitmap, 320);
0256     CHECK_OFFSET(tsc_multiplier, 328);
0257     CHECK_OFFSET(cr0_guest_host_mask, 344);
0258     CHECK_OFFSET(cr4_guest_host_mask, 352);
0259     CHECK_OFFSET(cr0_read_shadow, 360);
0260     CHECK_OFFSET(cr4_read_shadow, 368);
0261     CHECK_OFFSET(dead_space, 376);
0262     CHECK_OFFSET(exit_qualification, 408);
0263     CHECK_OFFSET(guest_linear_address, 416);
0264     CHECK_OFFSET(guest_cr0, 424);
0265     CHECK_OFFSET(guest_cr3, 432);
0266     CHECK_OFFSET(guest_cr4, 440);
0267     CHECK_OFFSET(guest_es_base, 448);
0268     CHECK_OFFSET(guest_cs_base, 456);
0269     CHECK_OFFSET(guest_ss_base, 464);
0270     CHECK_OFFSET(guest_ds_base, 472);
0271     CHECK_OFFSET(guest_fs_base, 480);
0272     CHECK_OFFSET(guest_gs_base, 488);
0273     CHECK_OFFSET(guest_ldtr_base, 496);
0274     CHECK_OFFSET(guest_tr_base, 504);
0275     CHECK_OFFSET(guest_gdtr_base, 512);
0276     CHECK_OFFSET(guest_idtr_base, 520);
0277     CHECK_OFFSET(guest_dr7, 528);
0278     CHECK_OFFSET(guest_rsp, 536);
0279     CHECK_OFFSET(guest_rip, 544);
0280     CHECK_OFFSET(guest_rflags, 552);
0281     CHECK_OFFSET(guest_pending_dbg_exceptions, 560);
0282     CHECK_OFFSET(guest_sysenter_esp, 568);
0283     CHECK_OFFSET(guest_sysenter_eip, 576);
0284     CHECK_OFFSET(host_cr0, 584);
0285     CHECK_OFFSET(host_cr3, 592);
0286     CHECK_OFFSET(host_cr4, 600);
0287     CHECK_OFFSET(host_fs_base, 608);
0288     CHECK_OFFSET(host_gs_base, 616);
0289     CHECK_OFFSET(host_tr_base, 624);
0290     CHECK_OFFSET(host_gdtr_base, 632);
0291     CHECK_OFFSET(host_idtr_base, 640);
0292     CHECK_OFFSET(host_ia32_sysenter_esp, 648);
0293     CHECK_OFFSET(host_ia32_sysenter_eip, 656);
0294     CHECK_OFFSET(host_rsp, 664);
0295     CHECK_OFFSET(host_rip, 672);
0296     CHECK_OFFSET(pin_based_vm_exec_control, 744);
0297     CHECK_OFFSET(cpu_based_vm_exec_control, 748);
0298     CHECK_OFFSET(exception_bitmap, 752);
0299     CHECK_OFFSET(page_fault_error_code_mask, 756);
0300     CHECK_OFFSET(page_fault_error_code_match, 760);
0301     CHECK_OFFSET(cr3_target_count, 764);
0302     CHECK_OFFSET(vm_exit_controls, 768);
0303     CHECK_OFFSET(vm_exit_msr_store_count, 772);
0304     CHECK_OFFSET(vm_exit_msr_load_count, 776);
0305     CHECK_OFFSET(vm_entry_controls, 780);
0306     CHECK_OFFSET(vm_entry_msr_load_count, 784);
0307     CHECK_OFFSET(vm_entry_intr_info_field, 788);
0308     CHECK_OFFSET(vm_entry_exception_error_code, 792);
0309     CHECK_OFFSET(vm_entry_instruction_len, 796);
0310     CHECK_OFFSET(tpr_threshold, 800);
0311     CHECK_OFFSET(secondary_vm_exec_control, 804);
0312     CHECK_OFFSET(vm_instruction_error, 808);
0313     CHECK_OFFSET(vm_exit_reason, 812);
0314     CHECK_OFFSET(vm_exit_intr_info, 816);
0315     CHECK_OFFSET(vm_exit_intr_error_code, 820);
0316     CHECK_OFFSET(idt_vectoring_info_field, 824);
0317     CHECK_OFFSET(idt_vectoring_error_code, 828);
0318     CHECK_OFFSET(vm_exit_instruction_len, 832);
0319     CHECK_OFFSET(vmx_instruction_info, 836);
0320     CHECK_OFFSET(guest_es_limit, 840);
0321     CHECK_OFFSET(guest_cs_limit, 844);
0322     CHECK_OFFSET(guest_ss_limit, 848);
0323     CHECK_OFFSET(guest_ds_limit, 852);
0324     CHECK_OFFSET(guest_fs_limit, 856);
0325     CHECK_OFFSET(guest_gs_limit, 860);
0326     CHECK_OFFSET(guest_ldtr_limit, 864);
0327     CHECK_OFFSET(guest_tr_limit, 868);
0328     CHECK_OFFSET(guest_gdtr_limit, 872);
0329     CHECK_OFFSET(guest_idtr_limit, 876);
0330     CHECK_OFFSET(guest_es_ar_bytes, 880);
0331     CHECK_OFFSET(guest_cs_ar_bytes, 884);
0332     CHECK_OFFSET(guest_ss_ar_bytes, 888);
0333     CHECK_OFFSET(guest_ds_ar_bytes, 892);
0334     CHECK_OFFSET(guest_fs_ar_bytes, 896);
0335     CHECK_OFFSET(guest_gs_ar_bytes, 900);
0336     CHECK_OFFSET(guest_ldtr_ar_bytes, 904);
0337     CHECK_OFFSET(guest_tr_ar_bytes, 908);
0338     CHECK_OFFSET(guest_interruptibility_info, 912);
0339     CHECK_OFFSET(guest_activity_state, 916);
0340     CHECK_OFFSET(guest_sysenter_cs, 920);
0341     CHECK_OFFSET(host_ia32_sysenter_cs, 924);
0342     CHECK_OFFSET(vmx_preemption_timer_value, 928);
0343     CHECK_OFFSET(virtual_processor_id, 960);
0344     CHECK_OFFSET(posted_intr_nv, 962);
0345     CHECK_OFFSET(guest_es_selector, 964);
0346     CHECK_OFFSET(guest_cs_selector, 966);
0347     CHECK_OFFSET(guest_ss_selector, 968);
0348     CHECK_OFFSET(guest_ds_selector, 970);
0349     CHECK_OFFSET(guest_fs_selector, 972);
0350     CHECK_OFFSET(guest_gs_selector, 974);
0351     CHECK_OFFSET(guest_ldtr_selector, 976);
0352     CHECK_OFFSET(guest_tr_selector, 978);
0353     CHECK_OFFSET(guest_intr_status, 980);
0354     CHECK_OFFSET(host_es_selector, 982);
0355     CHECK_OFFSET(host_cs_selector, 984);
0356     CHECK_OFFSET(host_ss_selector, 986);
0357     CHECK_OFFSET(host_ds_selector, 988);
0358     CHECK_OFFSET(host_fs_selector, 990);
0359     CHECK_OFFSET(host_gs_selector, 992);
0360     CHECK_OFFSET(host_tr_selector, 994);
0361     CHECK_OFFSET(guest_pml_index, 996);
0362 }
0363
0364 extern const unsigned short vmcs12_field_offsets[];
0365 extern const unsigned int nr_vmcs12_fields;
0366
0367 static inline short get_vmcs12_field_offset(unsigned long field)
0368 {
0369     unsigned short offset;
0370     unsigned int index;
0371
0372     if (field >> 15)
0373         return -ENOENT;
0374
0375     index = ROL16(field, 6);
0376     if (index >= nr_vmcs12_fields)
0377         return -ENOENT;
0378
0379     index = array_index_nospec(index, nr_vmcs12_fields);
0380     offset = vmcs12_field_offsets[index];
0381     if (offset == 0)
0382         return -ENOENT;
0383     return offset;
0384 }
0385
0386 static inline u64 vmcs12_read_any(struct vmcs12 *vmcs12, unsigned long field,
0387                   u16 offset)
0388 {
0389     char *p = (char *)vmcs12 + offset;
0390
0391     switch (vmcs_field_width(field)) {
0392     case VMCS_FIELD_WIDTH_NATURAL_WIDTH:
0393         return *((natural_width *)p);
0394     case VMCS_FIELD_WIDTH_U16:
0395         return *((u16 *)p);
0396     case VMCS_FIELD_WIDTH_U32:
0397         return *((u32 *)p);
0398     case VMCS_FIELD_WIDTH_U64:
0399         return *((u64 *)p);
0400     default:
0401         WARN_ON_ONCE(1);
0402         return -1;
0403     }
0404 }
0405
0406 static inline void vmcs12_write_any(struct vmcs12 *vmcs12, unsigned long field,
0407                     u16 offset, u64 field_value)
0408 {
0409     char *p = (char *)vmcs12 + offset;
0410
0411     switch (vmcs_field_width(field)) {
0412     case VMCS_FIELD_WIDTH_U16:
0413         *(u16 *)p = field_value;
0414         break;
0415     case VMCS_FIELD_WIDTH_U32:
0416         *(u32 *)p = field_value;
0417         break;
0418     case VMCS_FIELD_WIDTH_U64:
0419         *(u64 *)p = field_value;
0420         break;
0421     case VMCS_FIELD_WIDTH_NATURAL_WIDTH:
0422         *(natural_width *)p = field_value;
0423         break;
0424     default:
0425         WARN_ON_ONCE(1);
0426         break;
0427     }
0428 }
0429
0430 #endif /* __KVM_X86_VMX_VMCS12_H */