vmcs12.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef __KVM_X86_VMX_VMCS12_H
  3#define __KVM_X86_VMX_VMCS12_H
  4
  5#include <linux/build_bug.h>
  6
  7#include "vmcs.h"
  8
  9/*
 10 * struct vmcs12 describes the state that our guest hypervisor (L1) keeps for a
 11 * single nested guest (L2), hence the name vmcs12. Any VMX implementation has
 12 * a VMCS structure, and vmcs12 is our emulated VMX's VMCS. This structure is
 13 * stored in guest memory specified by VMPTRLD, but is opaque to the guest,
 14 * which must access it using VMREAD/VMWRITE/VMCLEAR instructions.
 15 * More than one of these structures may exist, if L1 runs multiple L2 guests.
 16 * nested_vmx_run() will use the data here to build the vmcs02: a VMCS for the
 17 * underlying hardware which will be used to run L2.
 18 * This structure is packed to ensure that its layout is identical across
 19 * machines (necessary for live migration).
 20 *
 21 * IMPORTANT: Changing the layout of existing fields in this structure
 22 * will break save/restore compatibility with older kvm releases. When
 23 * adding new fields, either use space in the reserved padding* arrays
 24 * or add the new fields to the end of the structure.
 25 */
 26typedef u64 natural_width;
 27struct __packed vmcs12 {
 28	/* According to the Intel spec, a VMCS region must start with the
 29	 * following two fields. Then follow implementation-specific data.
 30	 */
 31	struct vmcs_hdr hdr;
 32	u32 abort;
 33
 34	u32 launch_state; /* set to 0 by VMCLEAR, to 1 by VMLAUNCH */
 35	u32 padding[7]; /* room for future expansion */
 36
 37	u64 io_bitmap_a;
 38	u64 io_bitmap_b;
 39	u64 msr_bitmap;
 40	u64 vm_exit_msr_store_addr;
 41	u64 vm_exit_msr_load_addr;
 42	u64 vm_entry_msr_load_addr;
 43	u64 tsc_offset;
 44	u64 virtual_apic_page_addr;
 45	u64 apic_access_addr;
 46	u64 posted_intr_desc_addr;
 47	u64 ept_pointer;
 48	u64 eoi_exit_bitmap0;
 49	u64 eoi_exit_bitmap1;
 50	u64 eoi_exit_bitmap2;
 51	u64 eoi_exit_bitmap3;
 52	u64 xss_exit_bitmap;
 53	u64 guest_physical_address;
 54	u64 vmcs_link_pointer;
 55	u64 guest_ia32_debugctl;
 56	u64 guest_ia32_pat;
 57	u64 guest_ia32_efer;
 58	u64 guest_ia32_perf_global_ctrl;
 59	u64 guest_pdptr0;
 60	u64 guest_pdptr1;
 61	u64 guest_pdptr2;
 62	u64 guest_pdptr3;
 63	u64 guest_bndcfgs;
 64	u64 host_ia32_pat;
 65	u64 host_ia32_efer;
 66	u64 host_ia32_perf_global_ctrl;
 67	u64 vmread_bitmap;
 68	u64 vmwrite_bitmap;
 69	u64 vm_function_control;
 70	u64 eptp_list_address;
 71	u64 pml_address;
 72	u64 encls_exiting_bitmap;
 73	u64 tsc_multiplier;
 74	u64 padding64[1]; /* room for future expansion */
 75	/*
 76	 * To allow migration of L1 (complete with its L2 guests) between
 77	 * machines of different natural widths (32 or 64 bit), we cannot have
 78	 * unsigned long fields with no explicit size. We use u64 (aliased
 79	 * natural_width) instead. Luckily, x86 is little-endian.
 80	 */
 81	natural_width cr0_guest_host_mask;
 82	natural_width cr4_guest_host_mask;
 83	natural_width cr0_read_shadow;
 84	natural_width cr4_read_shadow;
 85	natural_width dead_space[4]; /* Last remnants of cr3_target_value[0-3]. */
 86	natural_width exit_qualification;
 87	natural_width guest_linear_address;
 88	natural_width guest_cr0;
 89	natural_width guest_cr3;
 90	natural_width guest_cr4;
 91	natural_width guest_es_base;
 92	natural_width guest_cs_base;
 93	natural_width guest_ss_base;
 94	natural_width guest_ds_base;
 95	natural_width guest_fs_base;
 96	natural_width guest_gs_base;
 97	natural_width guest_ldtr_base;
 98	natural_width guest_tr_base;
 99	natural_width guest_gdtr_base;
100	natural_width guest_idtr_base;
101	natural_width guest_dr7;
102	natural_width guest_rsp;
103	natural_width guest_rip;
104	natural_width guest_rflags;
105	natural_width guest_pending_dbg_exceptions;
106	natural_width guest_sysenter_esp;
107	natural_width guest_sysenter_eip;
108	natural_width host_cr0;
109	natural_width host_cr3;
110	natural_width host_cr4;
111	natural_width host_fs_base;
112	natural_width host_gs_base;
113	natural_width host_tr_base;
114	natural_width host_gdtr_base;
115	natural_width host_idtr_base;
116	natural_width host_ia32_sysenter_esp;
117	natural_width host_ia32_sysenter_eip;
118	natural_width host_rsp;
119	natural_width host_rip;
120	natural_width host_s_cet;
121	natural_width host_ssp;
122	natural_width host_ssp_tbl;
123	natural_width guest_s_cet;
124	natural_width guest_ssp;
125	natural_width guest_ssp_tbl;
126	natural_width paddingl[2]; /* room for future expansion */
127	u32 pin_based_vm_exec_control;
128	u32 cpu_based_vm_exec_control;
129	u32 exception_bitmap;
130	u32 page_fault_error_code_mask;
131	u32 page_fault_error_code_match;
132	u32 cr3_target_count;
133	u32 vm_exit_controls;
134	u32 vm_exit_msr_store_count;
135	u32 vm_exit_msr_load_count;
136	u32 vm_entry_controls;
137	u32 vm_entry_msr_load_count;
138	u32 vm_entry_intr_info_field;
139	u32 vm_entry_exception_error_code;
140	u32 vm_entry_instruction_len;
141	u32 tpr_threshold;
142	u32 secondary_vm_exec_control;
143	u32 vm_instruction_error;
144	u32 vm_exit_reason;
145	u32 vm_exit_intr_info;
146	u32 vm_exit_intr_error_code;
147	u32 idt_vectoring_info_field;
148	u32 idt_vectoring_error_code;
149	u32 vm_exit_instruction_len;
150	u32 vmx_instruction_info;
151	u32 guest_es_limit;
152	u32 guest_cs_limit;
153	u32 guest_ss_limit;
154	u32 guest_ds_limit;
155	u32 guest_fs_limit;
156	u32 guest_gs_limit;
157	u32 guest_ldtr_limit;
158	u32 guest_tr_limit;
159	u32 guest_gdtr_limit;
160	u32 guest_idtr_limit;
161	u32 guest_es_ar_bytes;
162	u32 guest_cs_ar_bytes;
163	u32 guest_ss_ar_bytes;
164	u32 guest_ds_ar_bytes;
165	u32 guest_fs_ar_bytes;
166	u32 guest_gs_ar_bytes;
167	u32 guest_ldtr_ar_bytes;
168	u32 guest_tr_ar_bytes;
169	u32 guest_interruptibility_info;
170	u32 guest_activity_state;
171	u32 guest_sysenter_cs;
172	u32 host_ia32_sysenter_cs;
173	u32 vmx_preemption_timer_value;
174	u32 padding32[7]; /* room for future expansion */
175	u16 virtual_processor_id;
176	u16 posted_intr_nv;
177	u16 guest_es_selector;
178	u16 guest_cs_selector;
179	u16 guest_ss_selector;
180	u16 guest_ds_selector;
181	u16 guest_fs_selector;
182	u16 guest_gs_selector;
183	u16 guest_ldtr_selector;
184	u16 guest_tr_selector;
185	u16 guest_intr_status;
186	u16 host_es_selector;
187	u16 host_cs_selector;
188	u16 host_ss_selector;
189	u16 host_ds_selector;
190	u16 host_fs_selector;
191	u16 host_gs_selector;
192	u16 host_tr_selector;
193	u16 guest_pml_index;
194};
195
196/*
197 * VMCS12_REVISION is KVM's arbitrary ID for the layout of struct vmcs12.  KVM
198 * enumerates this value to L1 via MSR_IA32_VMX_BASIC, and checks the revision
199 * ID during nested VMPTRLD to verify that L1 is loading a VMCS that adhere's
200 * to KVM's virtual CPU definition.
201 *
202 * DO NOT change this value, as it will break save/restore compatibility with
203 * older KVM releases.
204 */
205#define VMCS12_REVISION 0x11e57ed0
206
207/*
208 * VMCS12_SIZE is the number of bytes L1 should allocate for the VMXON region
209 * and any VMCS region. Although only sizeof(struct vmcs12) are used by the
210 * current implementation, 4K are reserved to avoid future complications and
211 * to preserve userspace ABI.
212 */
213#define VMCS12_SIZE		KVM_STATE_NESTED_VMX_VMCS_SIZE
214
215/*
216 * For save/restore compatibility, the vmcs12 field offsets must not change,
217 * although appending fields and/or filling gaps is obviously allowed.
218 */
219#define CHECK_OFFSET(field, loc) \
220	ASSERT_STRUCT_OFFSET(struct vmcs12, field, loc)
221
222static inline void vmx_check_vmcs12_offsets(void)
223{
224	CHECK_OFFSET(hdr, 0);
225	CHECK_OFFSET(abort, 4);
226	CHECK_OFFSET(launch_state, 8);
227	CHECK_OFFSET(io_bitmap_a, 40);
228	CHECK_OFFSET(io_bitmap_b, 48);
229	CHECK_OFFSET(msr_bitmap, 56);
230	CHECK_OFFSET(vm_exit_msr_store_addr, 64);
231	CHECK_OFFSET(vm_exit_msr_load_addr, 72);
232	CHECK_OFFSET(vm_entry_msr_load_addr, 80);
233	CHECK_OFFSET(tsc_offset, 88);
234	CHECK_OFFSET(virtual_apic_page_addr, 96);
235	CHECK_OFFSET(apic_access_addr, 104);
236	CHECK_OFFSET(posted_intr_desc_addr, 112);
237	CHECK_OFFSET(ept_pointer, 120);
238	CHECK_OFFSET(eoi_exit_bitmap0, 128);
239	CHECK_OFFSET(eoi_exit_bitmap1, 136);
240	CHECK_OFFSET(eoi_exit_bitmap2, 144);
241	CHECK_OFFSET(eoi_exit_bitmap3, 152);
242	CHECK_OFFSET(xss_exit_bitmap, 160);
243	CHECK_OFFSET(guest_physical_address, 168);
244	CHECK_OFFSET(vmcs_link_pointer, 176);
245	CHECK_OFFSET(guest_ia32_debugctl, 184);
246	CHECK_OFFSET(guest_ia32_pat, 192);
247	CHECK_OFFSET(guest_ia32_efer, 200);
248	CHECK_OFFSET(guest_ia32_perf_global_ctrl, 208);
249	CHECK_OFFSET(guest_pdptr0, 216);
250	CHECK_OFFSET(guest_pdptr1, 224);
251	CHECK_OFFSET(guest_pdptr2, 232);
252	CHECK_OFFSET(guest_pdptr3, 240);
253	CHECK_OFFSET(guest_bndcfgs, 248);
254	CHECK_OFFSET(host_ia32_pat, 256);
255	CHECK_OFFSET(host_ia32_efer, 264);
256	CHECK_OFFSET(host_ia32_perf_global_ctrl, 272);
257	CHECK_OFFSET(vmread_bitmap, 280);
258	CHECK_OFFSET(vmwrite_bitmap, 288);
259	CHECK_OFFSET(vm_function_control, 296);
260	CHECK_OFFSET(eptp_list_address, 304);
261	CHECK_OFFSET(pml_address, 312);
262	CHECK_OFFSET(encls_exiting_bitmap, 320);
263	CHECK_OFFSET(tsc_multiplier, 328);
264	CHECK_OFFSET(cr0_guest_host_mask, 344);
265	CHECK_OFFSET(cr4_guest_host_mask, 352);
266	CHECK_OFFSET(cr0_read_shadow, 360);
267	CHECK_OFFSET(cr4_read_shadow, 368);
268	CHECK_OFFSET(dead_space, 376);
269	CHECK_OFFSET(exit_qualification, 408);
270	CHECK_OFFSET(guest_linear_address, 416);
271	CHECK_OFFSET(guest_cr0, 424);
272	CHECK_OFFSET(guest_cr3, 432);
273	CHECK_OFFSET(guest_cr4, 440);
274	CHECK_OFFSET(guest_es_base, 448);
275	CHECK_OFFSET(guest_cs_base, 456);
276	CHECK_OFFSET(guest_ss_base, 464);
277	CHECK_OFFSET(guest_ds_base, 472);
278	CHECK_OFFSET(guest_fs_base, 480);
279	CHECK_OFFSET(guest_gs_base, 488);
280	CHECK_OFFSET(guest_ldtr_base, 496);
281	CHECK_OFFSET(guest_tr_base, 504);
282	CHECK_OFFSET(guest_gdtr_base, 512);
283	CHECK_OFFSET(guest_idtr_base, 520);
284	CHECK_OFFSET(guest_dr7, 528);
285	CHECK_OFFSET(guest_rsp, 536);
286	CHECK_OFFSET(guest_rip, 544);
287	CHECK_OFFSET(guest_rflags, 552);
288	CHECK_OFFSET(guest_pending_dbg_exceptions, 560);
289	CHECK_OFFSET(guest_sysenter_esp, 568);
290	CHECK_OFFSET(guest_sysenter_eip, 576);
291	CHECK_OFFSET(host_cr0, 584);
292	CHECK_OFFSET(host_cr3, 592);
293	CHECK_OFFSET(host_cr4, 600);
294	CHECK_OFFSET(host_fs_base, 608);
295	CHECK_OFFSET(host_gs_base, 616);
296	CHECK_OFFSET(host_tr_base, 624);
297	CHECK_OFFSET(host_gdtr_base, 632);
298	CHECK_OFFSET(host_idtr_base, 640);
299	CHECK_OFFSET(host_ia32_sysenter_esp, 648);
300	CHECK_OFFSET(host_ia32_sysenter_eip, 656);
301	CHECK_OFFSET(host_rsp, 664);
302	CHECK_OFFSET(host_rip, 672);
303	CHECK_OFFSET(host_s_cet, 680);
304	CHECK_OFFSET(host_ssp, 688);
305	CHECK_OFFSET(host_ssp_tbl, 696);
306	CHECK_OFFSET(guest_s_cet, 704);
307	CHECK_OFFSET(guest_ssp, 712);
308	CHECK_OFFSET(guest_ssp_tbl, 720);
309	CHECK_OFFSET(pin_based_vm_exec_control, 744);
310	CHECK_OFFSET(cpu_based_vm_exec_control, 748);
311	CHECK_OFFSET(exception_bitmap, 752);
312	CHECK_OFFSET(page_fault_error_code_mask, 756);
313	CHECK_OFFSET(page_fault_error_code_match, 760);
314	CHECK_OFFSET(cr3_target_count, 764);
315	CHECK_OFFSET(vm_exit_controls, 768);
316	CHECK_OFFSET(vm_exit_msr_store_count, 772);
317	CHECK_OFFSET(vm_exit_msr_load_count, 776);
318	CHECK_OFFSET(vm_entry_controls, 780);
319	CHECK_OFFSET(vm_entry_msr_load_count, 784);
320	CHECK_OFFSET(vm_entry_intr_info_field, 788);
321	CHECK_OFFSET(vm_entry_exception_error_code, 792);
322	CHECK_OFFSET(vm_entry_instruction_len, 796);
323	CHECK_OFFSET(tpr_threshold, 800);
324	CHECK_OFFSET(secondary_vm_exec_control, 804);
325	CHECK_OFFSET(vm_instruction_error, 808);
326	CHECK_OFFSET(vm_exit_reason, 812);
327	CHECK_OFFSET(vm_exit_intr_info, 816);
328	CHECK_OFFSET(vm_exit_intr_error_code, 820);
329	CHECK_OFFSET(idt_vectoring_info_field, 824);
330	CHECK_OFFSET(idt_vectoring_error_code, 828);
331	CHECK_OFFSET(vm_exit_instruction_len, 832);
332	CHECK_OFFSET(vmx_instruction_info, 836);
333	CHECK_OFFSET(guest_es_limit, 840);
334	CHECK_OFFSET(guest_cs_limit, 844);
335	CHECK_OFFSET(guest_ss_limit, 848);
336	CHECK_OFFSET(guest_ds_limit, 852);
337	CHECK_OFFSET(guest_fs_limit, 856);
338	CHECK_OFFSET(guest_gs_limit, 860);
339	CHECK_OFFSET(guest_ldtr_limit, 864);
340	CHECK_OFFSET(guest_tr_limit, 868);
341	CHECK_OFFSET(guest_gdtr_limit, 872);
342	CHECK_OFFSET(guest_idtr_limit, 876);
343	CHECK_OFFSET(guest_es_ar_bytes, 880);
344	CHECK_OFFSET(guest_cs_ar_bytes, 884);
345	CHECK_OFFSET(guest_ss_ar_bytes, 888);
346	CHECK_OFFSET(guest_ds_ar_bytes, 892);
347	CHECK_OFFSET(guest_fs_ar_bytes, 896);
348	CHECK_OFFSET(guest_gs_ar_bytes, 900);
349	CHECK_OFFSET(guest_ldtr_ar_bytes, 904);
350	CHECK_OFFSET(guest_tr_ar_bytes, 908);
351	CHECK_OFFSET(guest_interruptibility_info, 912);
352	CHECK_OFFSET(guest_activity_state, 916);
353	CHECK_OFFSET(guest_sysenter_cs, 920);
354	CHECK_OFFSET(host_ia32_sysenter_cs, 924);
355	CHECK_OFFSET(vmx_preemption_timer_value, 928);
356	CHECK_OFFSET(virtual_processor_id, 960);
357	CHECK_OFFSET(posted_intr_nv, 962);
358	CHECK_OFFSET(guest_es_selector, 964);
359	CHECK_OFFSET(guest_cs_selector, 966);
360	CHECK_OFFSET(guest_ss_selector, 968);
361	CHECK_OFFSET(guest_ds_selector, 970);
362	CHECK_OFFSET(guest_fs_selector, 972);
363	CHECK_OFFSET(guest_gs_selector, 974);
364	CHECK_OFFSET(guest_ldtr_selector, 976);
365	CHECK_OFFSET(guest_tr_selector, 978);
366	CHECK_OFFSET(guest_intr_status, 980);
367	CHECK_OFFSET(host_es_selector, 982);
368	CHECK_OFFSET(host_cs_selector, 984);
369	CHECK_OFFSET(host_ss_selector, 986);
370	CHECK_OFFSET(host_ds_selector, 988);
371	CHECK_OFFSET(host_fs_selector, 990);
372	CHECK_OFFSET(host_gs_selector, 992);
373	CHECK_OFFSET(host_tr_selector, 994);
374	CHECK_OFFSET(guest_pml_index, 996);
375}
376
377extern const unsigned short vmcs12_field_offsets[];
378extern const unsigned int nr_vmcs12_fields;
379
380static inline short get_vmcs12_field_offset(unsigned long field)
381{
382	unsigned short offset;
383	unsigned int index;
384
385	if (field >> 15)
386		return -ENOENT;
387
388	index = ROL16(field, 6);
389	if (index >= nr_vmcs12_fields)
390		return -ENOENT;
391
392	index = array_index_nospec(index, nr_vmcs12_fields);
393	offset = vmcs12_field_offsets[index];
394	if (offset == 0)
395		return -ENOENT;
396	return offset;
397}
398
399static inline u64 vmcs12_read_any(struct vmcs12 *vmcs12, unsigned long field,
400				  u16 offset)
401{
402	char *p = (char *)vmcs12 + offset;
403
404	switch (vmcs_field_width(field)) {
405	case VMCS_FIELD_WIDTH_NATURAL_WIDTH:
406		return *((natural_width *)p);
407	case VMCS_FIELD_WIDTH_U16:
408		return *((u16 *)p);
409	case VMCS_FIELD_WIDTH_U32:
410		return *((u32 *)p);
411	case VMCS_FIELD_WIDTH_U64:
412		return *((u64 *)p);
413	default:
414		WARN_ON_ONCE(1);
415		return -1;
416	}
417}
418
419static inline void vmcs12_write_any(struct vmcs12 *vmcs12, unsigned long field,
420				    u16 offset, u64 field_value)
421{
422	char *p = (char *)vmcs12 + offset;
423
424	switch (vmcs_field_width(field)) {
425	case VMCS_FIELD_WIDTH_U16:
426		*(u16 *)p = field_value;
427		break;
428	case VMCS_FIELD_WIDTH_U32:
429		*(u32 *)p = field_value;
430		break;
431	case VMCS_FIELD_WIDTH_U64:
432		*(u64 *)p = field_value;
433		break;
434	case VMCS_FIELD_WIDTH_NATURAL_WIDTH:
435		*(natural_width *)p = field_value;
436		break;
437	default:
438		WARN_ON_ONCE(1);
439		break;
440	}
441}
442
443#endif /* __KVM_X86_VMX_VMCS12_H */