The C and C++ Include Header Files

/usr/include/x86_64-linux-gnu/asm/kvm.h


$ cat -n /usr/include/x86_64-linux-gnu/asm/kvm.h

     1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
     2	#ifndef _ASM_X86_KVM_H
     3	#define _ASM_X86_KVM_H
     4	
     5	/*
     6	 * KVM x86 specific structures and definitions
     7	 *
     8	 */
     9	
    10	#include <linux/types.h>
    11	#include <linux/ioctl.h>
    12	#include <linux/stddef.h>
    13	
    14	#define KVM_PIO_PAGE_OFFSET 1
    15	#define KVM_COALESCED_MMIO_PAGE_OFFSET 2
    16	#define KVM_DIRTY_LOG_PAGE_OFFSET 64
    17	
    18	#define DE_VECTOR 0
    19	#define DB_VECTOR 1
    20	#define BP_VECTOR 3
    21	#define OF_VECTOR 4
    22	#define BR_VECTOR 5
    23	#define UD_VECTOR 6
    24	#define NM_VECTOR 7
    25	#define DF_VECTOR 8
    26	#define TS_VECTOR 10
    27	#define NP_VECTOR 11
    28	#define SS_VECTOR 12
    29	#define GP_VECTOR 13
    30	#define PF_VECTOR 14
    31	#define MF_VECTOR 16
    32	#define AC_VECTOR 17
    33	#define MC_VECTOR 18
    34	#define XM_VECTOR 19
    35	#define VE_VECTOR 20
    36	
    37	/* Select x86 specific features in <linux/kvm.h> */
    38	#define __KVM_HAVE_PIT
    39	#define __KVM_HAVE_IOAPIC
    40	#define __KVM_HAVE_IRQ_LINE
    41	#define __KVM_HAVE_MSI
    42	#define __KVM_HAVE_USER_NMI
    43	#define __KVM_HAVE_GUEST_DEBUG
    44	#define __KVM_HAVE_MSIX
    45	#define __KVM_HAVE_MCE
    46	#define __KVM_HAVE_PIT_STATE2
    47	#define __KVM_HAVE_XEN_HVM
    48	#define __KVM_HAVE_VCPU_EVENTS
    49	#define __KVM_HAVE_DEBUGREGS
    50	#define __KVM_HAVE_XSAVE
    51	#define __KVM_HAVE_XCRS
    52	#define __KVM_HAVE_READONLY_MEM
    53	
    54	/* Architectural interrupt line count. */
    55	#define KVM_NR_INTERRUPTS 256
    56	
    57	/* for KVM_GET_IRQCHIP and KVM_SET_IRQCHIP */
    58	struct kvm_pic_state {
    59		__u8 last_irr;	/* edge detection */
    60		__u8 irr;		/* interrupt request register */
    61		__u8 imr;		/* interrupt mask register */
    62		__u8 isr;		/* interrupt service register */
    63		__u8 priority_add;	/* highest irq priority */
    64		__u8 irq_base;
    65		__u8 read_reg_select;
    66		__u8 poll;
    67		__u8 special_mask;
    68		__u8 init_state;
    69		__u8 auto_eoi;
    70		__u8 rotate_on_auto_eoi;
    71		__u8 special_fully_nested_mode;
    72		__u8 init4;		/* true if 4 byte init */
    73		__u8 elcr;		/* PIIX edge/trigger selection */
    74		__u8 elcr_mask;
    75	};
    76	
    77	#define KVM_IOAPIC_NUM_PINS  24
    78	struct kvm_ioapic_state {
    79		__u64 base_address;
    80		__u32 ioregsel;
    81		__u32 id;
    82		__u32 irr;
    83		__u32 pad;
    84		union {
    85			__u64 bits;
    86			struct {
    87				__u8 vector;
    88				__u8 delivery_mode:3;
    89				__u8 dest_mode:1;
    90				__u8 delivery_status:1;
    91				__u8 polarity:1;
    92				__u8 remote_irr:1;
    93				__u8 trig_mode:1;
    94				__u8 mask:1;
    95				__u8 reserve:7;
    96				__u8 reserved[4];
    97				__u8 dest_id;
    98			} fields;
    99		} redirtbl[KVM_IOAPIC_NUM_PINS];
   100	};
   101	
   102	#define KVM_IRQCHIP_PIC_MASTER   0
   103	#define KVM_IRQCHIP_PIC_SLAVE    1
   104	#define KVM_IRQCHIP_IOAPIC       2
   105	#define KVM_NR_IRQCHIPS          3
   106	
   107	#define KVM_RUN_X86_SMM		 (1 << 0)
   108	#define KVM_RUN_X86_BUS_LOCK     (1 << 1)
   109	
   110	/* for KVM_GET_REGS and KVM_SET_REGS */
   111	struct kvm_regs {
   112		/* out (KVM_GET_REGS) / in (KVM_SET_REGS) */
   113		__u64 rax, rbx, rcx, rdx;
   114		__u64 rsi, rdi, rsp, rbp;
   115		__u64 r8,  r9,  r10, r11;
   116		__u64 r12, r13, r14, r15;
   117		__u64 rip, rflags;
   118	};
   119	
   120	/* for KVM_GET_LAPIC and KVM_SET_LAPIC */
   121	#define KVM_APIC_REG_SIZE 0x400
   122	struct kvm_lapic_state {
   123		char regs[KVM_APIC_REG_SIZE];
   124	};
   125	
   126	struct kvm_segment {
   127		__u64 base;
   128		__u32 limit;
   129		__u16 selector;
   130		__u8  type;
   131		__u8  present, dpl, db, s, l, g, avl;
   132		__u8  unusable;
   133		__u8  padding;
   134	};
   135	
   136	struct kvm_dtable {
   137		__u64 base;
   138		__u16 limit;
   139		__u16 padding[3];
   140	};
   141	
   142	
   143	/* for KVM_GET_SREGS and KVM_SET_SREGS */
   144	struct kvm_sregs {
   145		/* out (KVM_GET_SREGS) / in (KVM_SET_SREGS) */
   146		struct kvm_segment cs, ds, es, fs, gs, ss;
   147		struct kvm_segment tr, ldt;
   148		struct kvm_dtable gdt, idt;
   149		__u64 cr0, cr2, cr3, cr4, cr8;
   150		__u64 efer;
   151		__u64 apic_base;
   152		__u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64];
   153	};
   154	
   155	struct kvm_sregs2 {
   156		/* out (KVM_GET_SREGS2) / in (KVM_SET_SREGS2) */
   157		struct kvm_segment cs, ds, es, fs, gs, ss;
   158		struct kvm_segment tr, ldt;
   159		struct kvm_dtable gdt, idt;
   160		__u64 cr0, cr2, cr3, cr4, cr8;
   161		__u64 efer;
   162		__u64 apic_base;
   163		__u64 flags;
   164		__u64 pdptrs[4];
   165	};
   166	#define KVM_SREGS2_FLAGS_PDPTRS_VALID 1
   167	
   168	/* for KVM_GET_FPU and KVM_SET_FPU */
   169	struct kvm_fpu {
   170		__u8  fpr[8][16];
   171		__u16 fcw;
   172		__u16 fsw;
   173		__u8  ftwx;  /* in fxsave format */
   174		__u8  pad1;
   175		__u16 last_opcode;
   176		__u64 last_ip;
   177		__u64 last_dp;
   178		__u8  xmm[16][16];
   179		__u32 mxcsr;
   180		__u32 pad2;
   181	};
   182	
   183	struct kvm_msr_entry {
   184		__u32 index;
   185		__u32 reserved;
   186		__u64 data;
   187	};
   188	
   189	/* for KVM_GET_MSRS and KVM_SET_MSRS */
   190	struct kvm_msrs {
   191		__u32 nmsrs; /* number of msrs in entries */
   192		__u32 pad;
   193	
   194		struct kvm_msr_entry entries[];
   195	};
   196	
   197	/* for KVM_GET_MSR_INDEX_LIST */
   198	struct kvm_msr_list {
   199		__u32 nmsrs; /* number of msrs in entries */
   200		__u32 indices[];
   201	};
   202	
   203	/* Maximum size of any access bitmap in bytes */
   204	#define KVM_MSR_FILTER_MAX_BITMAP_SIZE 0x600
   205	
   206	/* for KVM_X86_SET_MSR_FILTER */
   207	struct kvm_msr_filter_range {
   208	#define KVM_MSR_FILTER_READ  (1 << 0)
   209	#define KVM_MSR_FILTER_WRITE (1 << 1)
   210	#define KVM_MSR_FILTER_RANGE_VALID_MASK (KVM_MSR_FILTER_READ | \
   211						 KVM_MSR_FILTER_WRITE)
   212		__u32 flags;
   213		__u32 nmsrs; /* number of msrs in bitmap */
   214		__u32 base;  /* MSR index the bitmap starts at */
   215		__u8 *bitmap; /* a 1 bit allows the operations in flags, 0 denies */
   216	};
   217	
   218	#define KVM_MSR_FILTER_MAX_RANGES 16
   219	struct kvm_msr_filter {
   220	#define KVM_MSR_FILTER_DEFAULT_ALLOW (0 << 0)
   221	#define KVM_MSR_FILTER_DEFAULT_DENY  (1 << 0)
   222	#define KVM_MSR_FILTER_VALID_MASK (KVM_MSR_FILTER_DEFAULT_DENY)
   223		__u32 flags;
   224		struct kvm_msr_filter_range ranges[KVM_MSR_FILTER_MAX_RANGES];
   225	};
   226	
   227	struct kvm_cpuid_entry {
   228		__u32 function;
   229		__u32 eax;
   230		__u32 ebx;
   231		__u32 ecx;
   232		__u32 edx;
   233		__u32 padding;
   234	};
   235	
   236	/* for KVM_SET_CPUID */
   237	struct kvm_cpuid {
   238		__u32 nent;
   239		__u32 padding;
   240		struct kvm_cpuid_entry entries[];
   241	};
   242	
   243	struct kvm_cpuid_entry2 {
   244		__u32 function;
   245		__u32 index;
   246		__u32 flags;
   247		__u32 eax;
   248		__u32 ebx;
   249		__u32 ecx;
   250		__u32 edx;
   251		__u32 padding[3];
   252	};
   253	
   254	#define KVM_CPUID_FLAG_SIGNIFCANT_INDEX		(1 << 0)
   255	#define KVM_CPUID_FLAG_STATEFUL_FUNC		(1 << 1)
   256	#define KVM_CPUID_FLAG_STATE_READ_NEXT		(1 << 2)
   257	
   258	/* for KVM_SET_CPUID2 */
   259	struct kvm_cpuid2 {
   260		__u32 nent;
   261		__u32 padding;
   262		struct kvm_cpuid_entry2 entries[];
   263	};
   264	
   265	/* for KVM_GET_PIT and KVM_SET_PIT */
   266	struct kvm_pit_channel_state {
   267		__u32 count; /* can be 65536 */
   268		__u16 latched_count;
   269		__u8 count_latched;
   270		__u8 status_latched;
   271		__u8 status;
   272		__u8 read_state;
   273		__u8 write_state;
   274		__u8 write_latch;
   275		__u8 rw_mode;
   276		__u8 mode;
   277		__u8 bcd;
   278		__u8 gate;
   279		__s64 count_load_time;
   280	};
   281	
   282	struct kvm_debug_exit_arch {
   283		__u32 exception;
   284		__u32 pad;
   285		__u64 pc;
   286		__u64 dr6;
   287		__u64 dr7;
   288	};
   289	
   290	#define KVM_GUESTDBG_USE_SW_BP		0x00010000
   291	#define KVM_GUESTDBG_USE_HW_BP		0x00020000
   292	#define KVM_GUESTDBG_INJECT_DB		0x00040000
   293	#define KVM_GUESTDBG_INJECT_BP		0x00080000
   294	#define KVM_GUESTDBG_BLOCKIRQ		0x00100000
   295	
   296	/* for KVM_SET_GUEST_DEBUG */
   297	struct kvm_guest_debug_arch {
   298		__u64 debugreg[8];
   299	};
   300	
   301	struct kvm_pit_state {
   302		struct kvm_pit_channel_state channels[3];
   303	};
   304	
   305	#define KVM_PIT_FLAGS_HPET_LEGACY     0x00000001
   306	#define KVM_PIT_FLAGS_SPEAKER_DATA_ON 0x00000002
   307	
   308	struct kvm_pit_state2 {
   309		struct kvm_pit_channel_state channels[3];
   310		__u32 flags;
   311		__u32 reserved[9];
   312	};
   313	
   314	struct kvm_reinject_control {
   315		__u8 pit_reinject;
   316		__u8 reserved[31];
   317	};
   318	
   319	/* When set in flags, include corresponding fields on KVM_SET_VCPU_EVENTS */
   320	#define KVM_VCPUEVENT_VALID_NMI_PENDING	0x00000001
   321	#define KVM_VCPUEVENT_VALID_SIPI_VECTOR	0x00000002
   322	#define KVM_VCPUEVENT_VALID_SHADOW	0x00000004
   323	#define KVM_VCPUEVENT_VALID_SMM		0x00000008
   324	#define KVM_VCPUEVENT_VALID_PAYLOAD	0x00000010
   325	#define KVM_VCPUEVENT_VALID_TRIPLE_FAULT	0x00000020
   326	
   327	/* Interrupt shadow states */
   328	#define KVM_X86_SHADOW_INT_MOV_SS	0x01
   329	#define KVM_X86_SHADOW_INT_STI		0x02
   330	
   331	/* for KVM_GET/SET_VCPU_EVENTS */
   332	struct kvm_vcpu_events {
   333		struct {
   334			__u8 injected;
   335			__u8 nr;
   336			__u8 has_error_code;
   337			__u8 pending;
   338			__u32 error_code;
   339		} exception;
   340		struct {
   341			__u8 injected;
   342			__u8 nr;
   343			__u8 soft;
   344			__u8 shadow;
   345		} interrupt;
   346		struct {
   347			__u8 injected;
   348			__u8 pending;
   349			__u8 masked;
   350			__u8 pad;
   351		} nmi;
   352		__u32 sipi_vector;
   353		__u32 flags;
   354		struct {
   355			__u8 smm;
   356			__u8 pending;
   357			__u8 smm_inside_nmi;
   358			__u8 latched_init;
   359		} smi;
   360		struct {
   361			__u8 pending;
   362		} triple_fault;
   363		__u8 reserved[26];
   364		__u8 exception_has_payload;
   365		__u64 exception_payload;
   366	};
   367	
   368	/* for KVM_GET/SET_DEBUGREGS */
   369	struct kvm_debugregs {
   370		__u64 db[4];
   371		__u64 dr6;
   372		__u64 dr7;
   373		__u64 flags;
   374		__u64 reserved[9];
   375	};
   376	
   377	/* for KVM_CAP_XSAVE and KVM_CAP_XSAVE2 */
   378	struct kvm_xsave {
   379		/*
   380		 * KVM_GET_XSAVE2 and KVM_SET_XSAVE write and read as many bytes
   381		 * as are returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2)
   382		 * respectively, when invoked on the vm file descriptor.
   383		 *
   384		 * The size value returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2)
   385		 * will always be at least 4096. Currently, it is only greater
   386		 * than 4096 if a dynamic feature has been enabled with
   387		 * ``arch_prctl()``, but this may change in the future.
   388		 *
   389		 * The offsets of the state save areas in struct kvm_xsave follow
   390		 * the contents of CPUID leaf 0xD on the host.
   391		 */
   392		__u32 region[1024];
   393		__u32 extra[];
   394	};
   395	
   396	#define KVM_MAX_XCRS	16
   397	
   398	struct kvm_xcr {
   399		__u32 xcr;
   400		__u32 reserved;
   401		__u64 value;
   402	};
   403	
   404	struct kvm_xcrs {
   405		__u32 nr_xcrs;
   406		__u32 flags;
   407		struct kvm_xcr xcrs[KVM_MAX_XCRS];
   408		__u64 padding[16];
   409	};
   410	
   411	#define KVM_SYNC_X86_REGS      (1UL << 0)
   412	#define KVM_SYNC_X86_SREGS     (1UL << 1)
   413	#define KVM_SYNC_X86_EVENTS    (1UL << 2)
   414	
   415	#define KVM_SYNC_X86_VALID_FIELDS \
   416		(KVM_SYNC_X86_REGS| \
   417		 KVM_SYNC_X86_SREGS| \
   418		 KVM_SYNC_X86_EVENTS)
   419	
   420	/* kvm_sync_regs struct included by kvm_run struct */
   421	struct kvm_sync_regs {
   422		/* Members of this structure are potentially malicious.
   423		 * Care must be taken by code reading, esp. interpreting,
   424		 * data fields from them inside KVM to prevent TOCTOU and
   425		 * double-fetch types of vulnerabilities.
   426		 */
   427		struct kvm_regs regs;
   428		struct kvm_sregs sregs;
   429		struct kvm_vcpu_events events;
   430	};
   431	
   432	#define KVM_X86_QUIRK_LINT0_REENABLED		(1 << 0)
   433	#define KVM_X86_QUIRK_CD_NW_CLEARED		(1 << 1)
   434	#define KVM_X86_QUIRK_LAPIC_MMIO_HOLE		(1 << 2)
   435	#define KVM_X86_QUIRK_OUT_7E_INC_RIP		(1 << 3)
   436	#define KVM_X86_QUIRK_MISC_ENABLE_NO_MWAIT	(1 << 4)
   437	#define KVM_X86_QUIRK_FIX_HYPERCALL_INSN	(1 << 5)
   438	#define KVM_X86_QUIRK_MWAIT_NEVER_UD_FAULTS	(1 << 6)
   439	
   440	#define KVM_STATE_NESTED_FORMAT_VMX	0
   441	#define KVM_STATE_NESTED_FORMAT_SVM	1
   442	
   443	#define KVM_STATE_NESTED_GUEST_MODE	0x00000001
   444	#define KVM_STATE_NESTED_RUN_PENDING	0x00000002
   445	#define KVM_STATE_NESTED_EVMCS		0x00000004
   446	#define KVM_STATE_NESTED_MTF_PENDING	0x00000008
   447	#define KVM_STATE_NESTED_GIF_SET	0x00000100
   448	
   449	#define KVM_STATE_NESTED_SMM_GUEST_MODE	0x00000001
   450	#define KVM_STATE_NESTED_SMM_VMXON	0x00000002
   451	
   452	#define KVM_STATE_NESTED_VMX_VMCS_SIZE	0x1000
   453	
   454	#define KVM_STATE_NESTED_SVM_VMCB_SIZE	0x1000
   455	
   456	#define KVM_STATE_VMX_PREEMPTION_TIMER_DEADLINE	0x00000001
   457	
   458	/* attributes for system fd (group 0) */
   459	#define KVM_X86_XCOMP_GUEST_SUPP	0
   460	
   461	struct kvm_vmx_nested_state_data {
   462		__u8 vmcs12[KVM_STATE_NESTED_VMX_VMCS_SIZE];
   463		__u8 shadow_vmcs12[KVM_STATE_NESTED_VMX_VMCS_SIZE];
   464	};
   465	
   466	struct kvm_vmx_nested_state_hdr {
   467		__u64 vmxon_pa;
   468		__u64 vmcs12_pa;
   469	
   470		struct {
   471			__u16 flags;
   472		} smm;
   473	
   474		__u16 pad;
   475	
   476		__u32 flags;
   477		__u64 preemption_timer_deadline;
   478	};
   479	
   480	struct kvm_svm_nested_state_data {
   481		/* Save area only used if KVM_STATE_NESTED_RUN_PENDING.  */
   482		__u8 vmcb12[KVM_STATE_NESTED_SVM_VMCB_SIZE];
   483	};
   484	
   485	struct kvm_svm_nested_state_hdr {
   486		__u64 vmcb_pa;
   487	};
   488	
   489	/* for KVM_CAP_NESTED_STATE */
   490	struct kvm_nested_state {
   491		__u16 flags;
   492		__u16 format;
   493		__u32 size;
   494	
   495		union {
   496			struct kvm_vmx_nested_state_hdr vmx;
   497			struct kvm_svm_nested_state_hdr svm;
   498	
   499			/* Pad the header to 128 bytes.  */
   500			__u8 pad[120];
   501		} hdr;
   502	
   503		/*
   504		 * Define data region as 0 bytes to preserve backwards-compatability
   505		 * to old definition of kvm_nested_state in order to avoid changing
   506		 * KVM_{GET,PUT}_NESTED_STATE ioctl values.
   507		 */
   508		union {
   509			__DECLARE_FLEX_ARRAY(struct kvm_vmx_nested_state_data, vmx);
   510			__DECLARE_FLEX_ARRAY(struct kvm_svm_nested_state_data, svm);
   511		} data;
   512	};
   513	
   514	/* for KVM_CAP_PMU_EVENT_FILTER */
   515	struct kvm_pmu_event_filter {
   516		__u32 action;
   517		__u32 nevents;
   518		__u32 fixed_counter_bitmap;
   519		__u32 flags;
   520		__u32 pad[4];
   521		__u64 events[];
   522	};
   523	
   524	#define KVM_PMU_EVENT_ALLOW 0
   525	#define KVM_PMU_EVENT_DENY 1
   526	
   527	#define KVM_PMU_EVENT_FLAG_MASKED_EVENTS BIT(0)
   528	#define KVM_PMU_EVENT_FLAGS_VALID_MASK (KVM_PMU_EVENT_FLAG_MASKED_EVENTS)
   529	
   530	/*
   531	 * Masked event layout.
   532	 * Bits   Description
   533	 * ----   -----------
   534	 * 7:0    event select (low bits)
   535	 * 15:8   umask match
   536	 * 31:16  unused
   537	 * 35:32  event select (high bits)
   538	 * 36:54  unused
   539	 * 55     exclude bit
   540	 * 63:56  umask mask
   541	 */
   542	
   543	#define KVM_PMU_ENCODE_MASKED_ENTRY(event_select, mask, match, exclude) \
   544		(((event_select) & 0xFFULL) | (((event_select) & 0XF00ULL) << 24) | \
   545		(((mask) & 0xFFULL) << 56) | \
   546		(((match) & 0xFFULL) << 8) | \
   547		((__u64)(!!(exclude)) << 55))
   548	
   549	#define KVM_PMU_MASKED_ENTRY_EVENT_SELECT \
   550		(GENMASK_ULL(7, 0) | GENMASK_ULL(35, 32))
   551	#define KVM_PMU_MASKED_ENTRY_UMASK_MASK		(GENMASK_ULL(63, 56))
   552	#define KVM_PMU_MASKED_ENTRY_UMASK_MATCH	(GENMASK_ULL(15, 8))
   553	#define KVM_PMU_MASKED_ENTRY_EXCLUDE		(BIT_ULL(55))
   554	#define KVM_PMU_MASKED_ENTRY_UMASK_MASK_SHIFT	(56)
   555	
   556	/* for KVM_{GET,SET,HAS}_DEVICE_ATTR */
   557	#define KVM_VCPU_TSC_CTRL 0 /* control group for the timestamp counter (TSC) */
   558	#define   KVM_VCPU_TSC_OFFSET 0 /* attribute for the TSC offset */
   559	
   560	/* x86-specific KVM_EXIT_HYPERCALL flags. */
   561	#define KVM_EXIT_HYPERCALL_LONG_MODE	BIT(0)
   562	
   563	#define KVM_X86_DEFAULT_VM	0
   564	#define KVM_X86_SW_PROTECTED_VM	1
   565	
   566	#endif /* _ASM_X86_KVM_H */