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/const.h>
11#include <linux/bits.h>
12#include <linux/types.h>
13#include <linux/ioctl.h>
14#include <linux/stddef.h>
15
16#define KVM_PIO_PAGE_OFFSET 1
17#define KVM_COALESCED_MMIO_PAGE_OFFSET 2
18#define KVM_DIRTY_LOG_PAGE_OFFSET 64
19
20#define DE_VECTOR 0
21#define DB_VECTOR 1
22#define BP_VECTOR 3
23#define OF_VECTOR 4
24#define BR_VECTOR 5
25#define UD_VECTOR 6
26#define NM_VECTOR 7
27#define DF_VECTOR 8
28#define TS_VECTOR 10
29#define NP_VECTOR 11
30#define SS_VECTOR 12
31#define GP_VECTOR 13
32#define PF_VECTOR 14
33#define MF_VECTOR 16
34#define AC_VECTOR 17
35#define MC_VECTOR 18
36#define XM_VECTOR 19
37#define VE_VECTOR 20
38#define CP_VECTOR 21
39
40#define HV_VECTOR 28
41#define VC_VECTOR 29
42#define SX_VECTOR 30
43
44/* Select x86 specific features in <linux/kvm.h> */
45#define __KVM_HAVE_PIT
46#define __KVM_HAVE_IOAPIC
47#define __KVM_HAVE_IRQ_LINE
48#define __KVM_HAVE_MSI
49#define __KVM_HAVE_USER_NMI
50#define __KVM_HAVE_MSIX
51#define __KVM_HAVE_MCE
52#define __KVM_HAVE_PIT_STATE2
53#define __KVM_HAVE_XEN_HVM
54#define __KVM_HAVE_VCPU_EVENTS
55#define __KVM_HAVE_DEBUGREGS
56#define __KVM_HAVE_XSAVE
57#define __KVM_HAVE_XCRS
58
59/* Architectural interrupt line count. */
60#define KVM_NR_INTERRUPTS 256
61
62/* for KVM_GET_IRQCHIP and KVM_SET_IRQCHIP */
63struct kvm_pic_state {
64 __u8 last_irr; /* edge detection */
65 __u8 irr; /* interrupt request register */
66 __u8 imr; /* interrupt mask register */
67 __u8 isr; /* interrupt service register */
68 __u8 priority_add; /* highest irq priority */
69 __u8 irq_base;
70 __u8 read_reg_select;
71 __u8 poll;
72 __u8 special_mask;
73 __u8 init_state;
74 __u8 auto_eoi;
75 __u8 rotate_on_auto_eoi;
76 __u8 special_fully_nested_mode;
77 __u8 init4; /* true if 4 byte init */
78 __u8 elcr; /* PIIX edge/trigger selection */
79 __u8 elcr_mask;
80};
81
82#define KVM_IOAPIC_NUM_PINS 24
83struct kvm_ioapic_state {
84 __u64 base_address;
85 __u32 ioregsel;
86 __u32 id;
87 __u32 irr;
88 __u32 pad;
89 union {
90 __u64 bits;
91 struct {
92 __u8 vector;
93 __u8 delivery_mode:3;
94 __u8 dest_mode:1;
95 __u8 delivery_status:1;
96 __u8 polarity:1;
97 __u8 remote_irr:1;
98 __u8 trig_mode:1;
99 __u8 mask:1;
100 __u8 reserve:7;
101 __u8 reserved[4];
102 __u8 dest_id;
103 } fields;
104 } redirtbl[KVM_IOAPIC_NUM_PINS];
105};
106
107#define KVM_IRQCHIP_PIC_MASTER 0
108#define KVM_IRQCHIP_PIC_SLAVE 1
109#define KVM_IRQCHIP_IOAPIC 2
110#define KVM_NR_IRQCHIPS 3
111
112#define KVM_RUN_X86_SMM (1 << 0)
113#define KVM_RUN_X86_BUS_LOCK (1 << 1)
114#define KVM_RUN_X86_GUEST_MODE (1 << 2)
115
116/* for KVM_GET_REGS and KVM_SET_REGS */
117struct kvm_regs {
118 /* out (KVM_GET_REGS) / in (KVM_SET_REGS) */
119 __u64 rax, rbx, rcx, rdx;
120 __u64 rsi, rdi, rsp, rbp;
121 __u64 r8, r9, r10, r11;
122 __u64 r12, r13, r14, r15;
123 __u64 rip, rflags;
124};
125
126/* for KVM_GET_LAPIC and KVM_SET_LAPIC */
127#define KVM_APIC_REG_SIZE 0x400
128struct kvm_lapic_state {
129 char regs[KVM_APIC_REG_SIZE];
130};
131
132struct kvm_segment {
133 __u64 base;
134 __u32 limit;
135 __u16 selector;
136 __u8 type;
137 __u8 present, dpl, db, s, l, g, avl;
138 __u8 unusable;
139 __u8 padding;
140};
141
142struct kvm_dtable {
143 __u64 base;
144 __u16 limit;
145 __u16 padding[3];
146};
147
148
149/* for KVM_GET_SREGS and KVM_SET_SREGS */
150struct kvm_sregs {
151 /* out (KVM_GET_SREGS) / in (KVM_SET_SREGS) */
152 struct kvm_segment cs, ds, es, fs, gs, ss;
153 struct kvm_segment tr, ldt;
154 struct kvm_dtable gdt, idt;
155 __u64 cr0, cr2, cr3, cr4, cr8;
156 __u64 efer;
157 __u64 apic_base;
158 __u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64];
159};
160
161struct kvm_sregs2 {
162 /* out (KVM_GET_SREGS2) / in (KVM_SET_SREGS2) */
163 struct kvm_segment cs, ds, es, fs, gs, ss;
164 struct kvm_segment tr, ldt;
165 struct kvm_dtable gdt, idt;
166 __u64 cr0, cr2, cr3, cr4, cr8;
167 __u64 efer;
168 __u64 apic_base;
169 __u64 flags;
170 __u64 pdptrs[4];
171};
172#define KVM_SREGS2_FLAGS_PDPTRS_VALID 1
173
174/* for KVM_GET_FPU and KVM_SET_FPU */
175struct kvm_fpu {
176 __u8 fpr[8][16];
177 __u16 fcw;
178 __u16 fsw;
179 __u8 ftwx; /* in fxsave format */
180 __u8 pad1;
181 __u16 last_opcode;
182 __u64 last_ip;
183 __u64 last_dp;
184 __u8 xmm[16][16];
185 __u32 mxcsr;
186 __u32 pad2;
187};
188
189struct kvm_msr_entry {
190 __u32 index;
191 __u32 reserved;
192 __u64 data;
193};
194
195/* for KVM_GET_MSRS and KVM_SET_MSRS */
196struct kvm_msrs {
197 __u32 nmsrs; /* number of msrs in entries */
198 __u32 pad;
199
200 __DECLARE_FLEX_ARRAY(struct kvm_msr_entry, entries);
201};
202
203/* for KVM_GET_MSR_INDEX_LIST */
204struct kvm_msr_list {
205 __u32 nmsrs; /* number of msrs in entries */
206 __DECLARE_FLEX_ARRAY(__u32, indices);
207};
208
209/* Maximum size of any access bitmap in bytes */
210#define KVM_MSR_FILTER_MAX_BITMAP_SIZE 0x600
211
212/* for KVM_X86_SET_MSR_FILTER */
213struct kvm_msr_filter_range {
214#define KVM_MSR_FILTER_READ (1 << 0)
215#define KVM_MSR_FILTER_WRITE (1 << 1)
216#define KVM_MSR_FILTER_RANGE_VALID_MASK (KVM_MSR_FILTER_READ | \
217 KVM_MSR_FILTER_WRITE)
218 __u32 flags;
219 __u32 nmsrs; /* number of msrs in bitmap */
220 __u32 base; /* MSR index the bitmap starts at */
221 __u8 *bitmap; /* a 1 bit allows the operations in flags, 0 denies */
222};
223
224#define KVM_MSR_FILTER_MAX_RANGES 16
225struct kvm_msr_filter {
226#define KVM_MSR_FILTER_DEFAULT_ALLOW (0 << 0)
227#define KVM_MSR_FILTER_DEFAULT_DENY (1 << 0)
228#define KVM_MSR_FILTER_VALID_MASK (KVM_MSR_FILTER_DEFAULT_DENY)
229 __u32 flags;
230 struct kvm_msr_filter_range ranges[KVM_MSR_FILTER_MAX_RANGES];
231};
232
233struct kvm_cpuid_entry {
234 __u32 function;
235 __u32 eax;
236 __u32 ebx;
237 __u32 ecx;
238 __u32 edx;
239 __u32 padding;
240};
241
242/* for KVM_SET_CPUID */
243struct kvm_cpuid {
244 __u32 nent;
245 __u32 padding;
246 __DECLARE_FLEX_ARRAY(struct kvm_cpuid_entry, entries);
247};
248
249struct kvm_cpuid_entry2 {
250 __u32 function;
251 __u32 index;
252 __u32 flags;
253 __u32 eax;
254 __u32 ebx;
255 __u32 ecx;
256 __u32 edx;
257 __u32 padding[3];
258};
259
260#define KVM_CPUID_FLAG_SIGNIFCANT_INDEX (1 << 0)
261#define KVM_CPUID_FLAG_STATEFUL_FUNC (1 << 1)
262#define KVM_CPUID_FLAG_STATE_READ_NEXT (1 << 2)
263
264/* for KVM_SET_CPUID2 */
265struct kvm_cpuid2 {
266 __u32 nent;
267 __u32 padding;
268 __DECLARE_FLEX_ARRAY(struct kvm_cpuid_entry2, entries);
269};
270
271/* for KVM_GET_PIT and KVM_SET_PIT */
272struct kvm_pit_channel_state {
273 __u32 count; /* can be 65536 */
274 __u16 latched_count;
275 __u8 count_latched;
276 __u8 status_latched;
277 __u8 status;
278 __u8 read_state;
279 __u8 write_state;
280 __u8 write_latch;
281 __u8 rw_mode;
282 __u8 mode;
283 __u8 bcd;
284 __u8 gate;
285 __s64 count_load_time;
286};
287
288struct kvm_debug_exit_arch {
289 __u32 exception;
290 __u32 pad;
291 __u64 pc;
292 __u64 dr6;
293 __u64 dr7;
294};
295
296#define KVM_GUESTDBG_USE_SW_BP 0x00010000
297#define KVM_GUESTDBG_USE_HW_BP 0x00020000
298#define KVM_GUESTDBG_INJECT_DB 0x00040000
299#define KVM_GUESTDBG_INJECT_BP 0x00080000
300#define KVM_GUESTDBG_BLOCKIRQ 0x00100000
301
302/* for KVM_SET_GUEST_DEBUG */
303struct kvm_guest_debug_arch {
304 __u64 debugreg[8];
305};
306
307struct kvm_pit_state {
308 struct kvm_pit_channel_state channels[3];
309};
310
311#define KVM_PIT_FLAGS_HPET_LEGACY 0x00000001
312#define KVM_PIT_FLAGS_SPEAKER_DATA_ON 0x00000002
313
314struct kvm_pit_state2 {
315 struct kvm_pit_channel_state channels[3];
316 __u32 flags;
317 __u32 reserved[9];
318};
319
320struct kvm_reinject_control {
321 __u8 pit_reinject;
322 __u8 reserved[31];
323};
324
325/* When set in flags, include corresponding fields on KVM_SET_VCPU_EVENTS */
326#define KVM_VCPUEVENT_VALID_NMI_PENDING 0x00000001
327#define KVM_VCPUEVENT_VALID_SIPI_VECTOR 0x00000002
328#define KVM_VCPUEVENT_VALID_SHADOW 0x00000004
329#define KVM_VCPUEVENT_VALID_SMM 0x00000008
330#define KVM_VCPUEVENT_VALID_PAYLOAD 0x00000010
331#define KVM_VCPUEVENT_VALID_TRIPLE_FAULT 0x00000020
332
333/* Interrupt shadow states */
334#define KVM_X86_SHADOW_INT_MOV_SS 0x01
335#define KVM_X86_SHADOW_INT_STI 0x02
336
337/* for KVM_GET/SET_VCPU_EVENTS */
338struct kvm_vcpu_events {
339 struct {
340 __u8 injected;
341 __u8 nr;
342 __u8 has_error_code;
343 __u8 pending;
344 __u32 error_code;
345 } exception;
346 struct {
347 __u8 injected;
348 __u8 nr;
349 __u8 soft;
350 __u8 shadow;
351 } interrupt;
352 struct {
353 __u8 injected;
354 __u8 pending;
355 __u8 masked;
356 __u8 pad;
357 } nmi;
358 __u32 sipi_vector;
359 __u32 flags;
360 struct {
361 __u8 smm;
362 __u8 pending;
363 __u8 smm_inside_nmi;
364 __u8 latched_init;
365 } smi;
366 struct {
367 __u8 pending;
368 } triple_fault;
369 __u8 reserved[26];
370 __u8 exception_has_payload;
371 __u64 exception_payload;
372};
373
374/* for KVM_GET/SET_DEBUGREGS */
375struct kvm_debugregs {
376 __u64 db[4];
377 __u64 dr6;
378 __u64 dr7;
379 __u64 flags;
380 __u64 reserved[9];
381};
382
383/* for KVM_CAP_XSAVE and KVM_CAP_XSAVE2 */
384struct kvm_xsave {
385 /*
386 * KVM_GET_XSAVE2 and KVM_SET_XSAVE write and read as many bytes
387 * as are returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2)
388 * respectively, when invoked on the vm file descriptor.
389 *
390 * The size value returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2)
391 * will always be at least 4096. Currently, it is only greater
392 * than 4096 if a dynamic feature has been enabled with
393 * ``arch_prctl()``, but this may change in the future.
394 *
395 * The offsets of the state save areas in struct kvm_xsave follow
396 * the contents of CPUID leaf 0xD on the host.
397 */
398 __u32 region[1024];
399 __DECLARE_FLEX_ARRAY(__u32, extra);
400};
401
402#define KVM_MAX_XCRS 16
403
404struct kvm_xcr {
405 __u32 xcr;
406 __u32 reserved;
407 __u64 value;
408};
409
410struct kvm_xcrs {
411 __u32 nr_xcrs;
412 __u32 flags;
413 struct kvm_xcr xcrs[KVM_MAX_XCRS];
414 __u64 padding[16];
415};
416
417#define KVM_X86_REG_TYPE_MSR 2
418#define KVM_X86_REG_TYPE_KVM 3
419
420#define KVM_X86_KVM_REG_SIZE(reg) \
421({ \
422 reg == KVM_REG_GUEST_SSP ? KVM_REG_SIZE_U64 : 0; \
423})
424
425#define KVM_X86_REG_TYPE_SIZE(type, reg) \
426({ \
427 __u64 type_size = (__u64)type << 32; \
428 \
429 type_size |= type == KVM_X86_REG_TYPE_MSR ? KVM_REG_SIZE_U64 : \
430 type == KVM_X86_REG_TYPE_KVM ? KVM_X86_KVM_REG_SIZE(reg) : \
431 0; \
432 type_size; \
433})
434
435#define KVM_X86_REG_ID(type, index) \
436 (KVM_REG_X86 | KVM_X86_REG_TYPE_SIZE(type, index) | index)
437
438#define KVM_X86_REG_MSR(index) \
439 KVM_X86_REG_ID(KVM_X86_REG_TYPE_MSR, index)
440#define KVM_X86_REG_KVM(index) \
441 KVM_X86_REG_ID(KVM_X86_REG_TYPE_KVM, index)
442
443/* KVM-defined registers starting from 0 */
444#define KVM_REG_GUEST_SSP 0
445
446#define KVM_SYNC_X86_REGS (1UL << 0)
447#define KVM_SYNC_X86_SREGS (1UL << 1)
448#define KVM_SYNC_X86_EVENTS (1UL << 2)
449
450#define KVM_SYNC_X86_VALID_FIELDS \
451 (KVM_SYNC_X86_REGS| \
452 KVM_SYNC_X86_SREGS| \
453 KVM_SYNC_X86_EVENTS)
454
455/* kvm_sync_regs struct included by kvm_run struct */
456struct kvm_sync_regs {
457 /* Members of this structure are potentially malicious.
458 * Care must be taken by code reading, esp. interpreting,
459 * data fields from them inside KVM to prevent TOCTOU and
460 * double-fetch types of vulnerabilities.
461 */
462 struct kvm_regs regs;
463 struct kvm_sregs sregs;
464 struct kvm_vcpu_events events;
465};
466
467#define KVM_X86_QUIRK_LINT0_REENABLED (1 << 0)
468#define KVM_X86_QUIRK_CD_NW_CLEARED (1 << 1)
469#define KVM_X86_QUIRK_LAPIC_MMIO_HOLE (1 << 2)
470#define KVM_X86_QUIRK_OUT_7E_INC_RIP (1 << 3)
471#define KVM_X86_QUIRK_MISC_ENABLE_NO_MWAIT (1 << 4)
472#define KVM_X86_QUIRK_FIX_HYPERCALL_INSN (1 << 5)
473#define KVM_X86_QUIRK_MWAIT_NEVER_UD_FAULTS (1 << 6)
474#define KVM_X86_QUIRK_SLOT_ZAP_ALL (1 << 7)
475#define KVM_X86_QUIRK_STUFF_FEATURE_MSRS (1 << 8)
476#define KVM_X86_QUIRK_IGNORE_GUEST_PAT (1 << 9)
477#define KVM_X86_QUIRK_VMCS12_ALLOW_FREEZE_IN_SMM (1 << 10)
478#define KVM_X86_QUIRK_NESTED_SVM_SHARED_PAT (1 << 11)
479
480#define KVM_STATE_NESTED_FORMAT_VMX 0
481#define KVM_STATE_NESTED_FORMAT_SVM 1
482
483#define KVM_STATE_NESTED_GUEST_MODE 0x00000001
484#define KVM_STATE_NESTED_RUN_PENDING 0x00000002
485#define KVM_STATE_NESTED_EVMCS 0x00000004
486#define KVM_STATE_NESTED_MTF_PENDING 0x00000008
487#define KVM_STATE_NESTED_GIF_SET 0x00000100
488
489#define KVM_STATE_NESTED_SMM_GUEST_MODE 0x00000001
490#define KVM_STATE_NESTED_SMM_VMXON 0x00000002
491
492#define KVM_STATE_NESTED_VMX_VMCS_SIZE 0x1000
493
494#define KVM_STATE_NESTED_SVM_VMCB_SIZE 0x1000
495
496#define KVM_STATE_VMX_PREEMPTION_TIMER_DEADLINE 0x00000001
497
498/* vendor-independent attributes for system fd (group 0) */
499#define KVM_X86_GRP_SYSTEM 0
500# define KVM_X86_XCOMP_GUEST_SUPP 0
501
502/* vendor-specific groups and attributes for system fd */
503#define KVM_X86_GRP_SEV 1
504# define KVM_X86_SEV_VMSA_FEATURES 0
505# define KVM_X86_SNP_POLICY_BITS 1
506# define KVM_X86_SEV_SNP_REQ_CERTS 2
507
508struct kvm_vmx_nested_state_data {
509 __u8 vmcs12[KVM_STATE_NESTED_VMX_VMCS_SIZE];
510 __u8 shadow_vmcs12[KVM_STATE_NESTED_VMX_VMCS_SIZE];
511};
512
513struct kvm_vmx_nested_state_hdr {
514 __u64 vmxon_pa;
515 __u64 vmcs12_pa;
516
517 struct {
518 __u16 flags;
519 } smm;
520
521 __u16 pad;
522
523 __u32 flags;
524 __u64 preemption_timer_deadline;
525};
526
527struct kvm_svm_nested_state_data {
528 /* Save area only used if KVM_STATE_NESTED_RUN_PENDING. */
529 __u8 vmcb12[KVM_STATE_NESTED_SVM_VMCB_SIZE];
530};
531
532struct kvm_svm_nested_state_hdr {
533 __u64 vmcb_pa;
534 __u64 gpat;
535};
536
537/* for KVM_CAP_NESTED_STATE */
538struct kvm_nested_state {
539 __u16 flags;
540 __u16 format;
541 __u32 size;
542
543 union {
544 struct kvm_vmx_nested_state_hdr vmx;
545 struct kvm_svm_nested_state_hdr svm;
546
547 /* Pad the header to 128 bytes. */
548 __u8 pad[120];
549 } hdr;
550
551 /*
552 * Define data region as 0 bytes to preserve backwards-compatability
553 * to old definition of kvm_nested_state in order to avoid changing
554 * KVM_{GET,PUT}_NESTED_STATE ioctl values.
555 */
556 union {
557 __DECLARE_FLEX_ARRAY(struct kvm_vmx_nested_state_data, vmx);
558 __DECLARE_FLEX_ARRAY(struct kvm_svm_nested_state_data, svm);
559 } data;
560};
561
562/* for KVM_CAP_PMU_EVENT_FILTER */
563struct kvm_pmu_event_filter {
564 __u32 action;
565 __u32 nevents;
566 __u32 fixed_counter_bitmap;
567 __u32 flags;
568 __u32 pad[4];
569 __DECLARE_FLEX_ARRAY(__u64, events);
570};
571
572#define KVM_PMU_EVENT_ALLOW 0
573#define KVM_PMU_EVENT_DENY 1
574
575#define KVM_PMU_EVENT_FLAG_MASKED_EVENTS _BITUL(0)
576#define KVM_PMU_EVENT_FLAGS_VALID_MASK (KVM_PMU_EVENT_FLAG_MASKED_EVENTS)
577
578/* for KVM_CAP_MCE */
579struct kvm_x86_mce {
580 __u64 status;
581 __u64 addr;
582 __u64 misc;
583 __u64 mcg_status;
584 __u8 bank;
585 __u8 pad1[7];
586 __u64 pad2[3];
587};
588
589/* for KVM_CAP_XEN_HVM */
590#define KVM_XEN_HVM_CONFIG_HYPERCALL_MSR (1 << 0)
591#define KVM_XEN_HVM_CONFIG_INTERCEPT_HCALL (1 << 1)
592#define KVM_XEN_HVM_CONFIG_SHARED_INFO (1 << 2)
593#define KVM_XEN_HVM_CONFIG_RUNSTATE (1 << 3)
594#define KVM_XEN_HVM_CONFIG_EVTCHN_2LEVEL (1 << 4)
595#define KVM_XEN_HVM_CONFIG_EVTCHN_SEND (1 << 5)
596#define KVM_XEN_HVM_CONFIG_RUNSTATE_UPDATE_FLAG (1 << 6)
597#define KVM_XEN_HVM_CONFIG_PVCLOCK_TSC_UNSTABLE (1 << 7)
598#define KVM_XEN_HVM_CONFIG_SHARED_INFO_HVA (1 << 8)
599
600#define KVM_XEN_MSR_MIN_INDEX 0x40000000u
601#define KVM_XEN_MSR_MAX_INDEX 0x4fffffffu
602
603struct kvm_xen_hvm_config {
604 __u32 flags;
605 __u32 msr;
606 __u64 blob_addr_32;
607 __u64 blob_addr_64;
608 __u8 blob_size_32;
609 __u8 blob_size_64;
610 __u8 pad2[30];
611};
612
613struct kvm_xen_hvm_attr {
614 __u16 type;
615 __u16 pad[3];
616 union {
617 __u8 long_mode;
618 __u8 vector;
619 __u8 runstate_update_flag;
620 union {
621 __u64 gfn;
622#define KVM_XEN_INVALID_GFN ((__u64)-1)
623 __u64 hva;
624 } shared_info;
625 struct {
626 __u32 send_port;
627 __u32 type; /* EVTCHNSTAT_ipi / EVTCHNSTAT_interdomain */
628 __u32 flags;
629#define KVM_XEN_EVTCHN_DEASSIGN (1 << 0)
630#define KVM_XEN_EVTCHN_UPDATE (1 << 1)
631#define KVM_XEN_EVTCHN_RESET (1 << 2)
632 /*
633 * Events sent by the guest are either looped back to
634 * the guest itself (potentially on a different port#)
635 * or signalled via an eventfd.
636 */
637 union {
638 struct {
639 __u32 port;
640 __u32 vcpu;
641 __u32 priority;
642 } port;
643 struct {
644 __u32 port; /* Zero for eventfd */
645 __s32 fd;
646 } eventfd;
647 __u32 padding[4];
648 } deliver;
649 } evtchn;
650 __u32 xen_version;
651 __u64 pad[8];
652 } u;
653};
654
655
656/* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_SHARED_INFO */
657#define KVM_XEN_ATTR_TYPE_LONG_MODE 0x0
658#define KVM_XEN_ATTR_TYPE_SHARED_INFO 0x1
659#define KVM_XEN_ATTR_TYPE_UPCALL_VECTOR 0x2
660/* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_EVTCHN_SEND */
661#define KVM_XEN_ATTR_TYPE_EVTCHN 0x3
662#define KVM_XEN_ATTR_TYPE_XEN_VERSION 0x4
663/* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_RUNSTATE_UPDATE_FLAG */
664#define KVM_XEN_ATTR_TYPE_RUNSTATE_UPDATE_FLAG 0x5
665/* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_SHARED_INFO_HVA */
666#define KVM_XEN_ATTR_TYPE_SHARED_INFO_HVA 0x6
667
668struct kvm_xen_vcpu_attr {
669 __u16 type;
670 __u16 pad[3];
671 union {
672 __u64 gpa;
673#define KVM_XEN_INVALID_GPA ((__u64)-1)
674 __u64 hva;
675 __u64 pad[8];
676 struct {
677 __u64 state;
678 __u64 state_entry_time;
679 __u64 time_running;
680 __u64 time_runnable;
681 __u64 time_blocked;
682 __u64 time_offline;
683 } runstate;
684 __u32 vcpu_id;
685 struct {
686 __u32 port;
687 __u32 priority;
688 __u64 expires_ns;
689 } timer;
690 __u8 vector;
691 } u;
692};
693
694/* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_SHARED_INFO */
695#define KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO 0x0
696#define KVM_XEN_VCPU_ATTR_TYPE_VCPU_TIME_INFO 0x1
697#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADDR 0x2
698#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_CURRENT 0x3
699#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_DATA 0x4
700#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADJUST 0x5
701/* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_EVTCHN_SEND */
702#define KVM_XEN_VCPU_ATTR_TYPE_VCPU_ID 0x6
703#define KVM_XEN_VCPU_ATTR_TYPE_TIMER 0x7
704#define KVM_XEN_VCPU_ATTR_TYPE_UPCALL_VECTOR 0x8
705/* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_SHARED_INFO_HVA */
706#define KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO_HVA 0x9
707
708/* Secure Encrypted Virtualization command */
709enum sev_cmd_id {
710 /* Guest initialization commands */
711 KVM_SEV_INIT = 0,
712 KVM_SEV_ES_INIT,
713 /* Guest launch commands */
714 KVM_SEV_LAUNCH_START,
715 KVM_SEV_LAUNCH_UPDATE_DATA,
716 KVM_SEV_LAUNCH_UPDATE_VMSA,
717 KVM_SEV_LAUNCH_SECRET,
718 KVM_SEV_LAUNCH_MEASURE,
719 KVM_SEV_LAUNCH_FINISH,
720 /* Guest migration commands (outgoing) */
721 KVM_SEV_SEND_START,
722 KVM_SEV_SEND_UPDATE_DATA,
723 KVM_SEV_SEND_UPDATE_VMSA,
724 KVM_SEV_SEND_FINISH,
725 /* Guest migration commands (incoming) */
726 KVM_SEV_RECEIVE_START,
727 KVM_SEV_RECEIVE_UPDATE_DATA,
728 KVM_SEV_RECEIVE_UPDATE_VMSA,
729 KVM_SEV_RECEIVE_FINISH,
730 /* Guest status and debug commands */
731 KVM_SEV_GUEST_STATUS,
732 KVM_SEV_DBG_DECRYPT,
733 KVM_SEV_DBG_ENCRYPT,
734 /* Guest certificates commands */
735 KVM_SEV_CERT_EXPORT,
736 /* Attestation report */
737 KVM_SEV_GET_ATTESTATION_REPORT,
738 /* Guest Migration Extension */
739 KVM_SEV_SEND_CANCEL,
740
741 /* Second time is the charm; improved versions of the above ioctls. */
742 KVM_SEV_INIT2,
743
744 /* SNP-specific commands */
745 KVM_SEV_SNP_LAUNCH_START = 100,
746 KVM_SEV_SNP_LAUNCH_UPDATE,
747 KVM_SEV_SNP_LAUNCH_FINISH,
748 KVM_SEV_SNP_ENABLE_REQ_CERTS,
749
750 KVM_SEV_NR_MAX,
751};
752
753struct kvm_sev_cmd {
754 __u32 id;
755 __u32 pad0;
756 __u64 data;
757 __u32 error;
758 __u32 sev_fd;
759};
760
761struct kvm_sev_init {
762 __u64 vmsa_features;
763 __u32 flags;
764 __u16 ghcb_version;
765 __u16 pad1;
766 __u32 pad2[8];
767};
768
769struct kvm_sev_launch_start {
770 __u32 handle;
771 __u32 policy;
772 __u64 dh_uaddr;
773 __u32 dh_len;
774 __u32 pad0;
775 __u64 session_uaddr;
776 __u32 session_len;
777 __u32 pad1;
778};
779
780struct kvm_sev_launch_update_data {
781 __u64 uaddr;
782 __u32 len;
783 __u32 pad0;
784};
785
786
787struct kvm_sev_launch_secret {
788 __u64 hdr_uaddr;
789 __u32 hdr_len;
790 __u32 pad0;
791 __u64 guest_uaddr;
792 __u32 guest_len;
793 __u32 pad1;
794 __u64 trans_uaddr;
795 __u32 trans_len;
796 __u32 pad2;
797};
798
799struct kvm_sev_launch_measure {
800 __u64 uaddr;
801 __u32 len;
802 __u32 pad0;
803};
804
805struct kvm_sev_guest_status {
806 __u32 handle;
807 __u32 policy;
808 __u32 state;
809};
810
811struct kvm_sev_dbg {
812 __u64 src_uaddr;
813 __u64 dst_uaddr;
814 __u32 len;
815 __u32 pad0;
816};
817
818struct kvm_sev_attestation_report {
819 __u8 mnonce[16];
820 __u64 uaddr;
821 __u32 len;
822 __u32 pad0;
823};
824
825struct kvm_sev_send_start {
826 __u32 policy;
827 __u32 pad0;
828 __u64 pdh_cert_uaddr;
829 __u32 pdh_cert_len;
830 __u32 pad1;
831 __u64 plat_certs_uaddr;
832 __u32 plat_certs_len;
833 __u32 pad2;
834 __u64 amd_certs_uaddr;
835 __u32 amd_certs_len;
836 __u32 pad3;
837 __u64 session_uaddr;
838 __u32 session_len;
839 __u32 pad4;
840};
841
842struct kvm_sev_send_update_data {
843 __u64 hdr_uaddr;
844 __u32 hdr_len;
845 __u32 pad0;
846 __u64 guest_uaddr;
847 __u32 guest_len;
848 __u32 pad1;
849 __u64 trans_uaddr;
850 __u32 trans_len;
851 __u32 pad2;
852};
853
854struct kvm_sev_receive_start {
855 __u32 handle;
856 __u32 policy;
857 __u64 pdh_uaddr;
858 __u32 pdh_len;
859 __u32 pad0;
860 __u64 session_uaddr;
861 __u32 session_len;
862 __u32 pad1;
863};
864
865struct kvm_sev_receive_update_data {
866 __u64 hdr_uaddr;
867 __u32 hdr_len;
868 __u32 pad0;
869 __u64 guest_uaddr;
870 __u32 guest_len;
871 __u32 pad1;
872 __u64 trans_uaddr;
873 __u32 trans_len;
874 __u32 pad2;
875};
876
877struct kvm_sev_snp_launch_start {
878 __u64 policy;
879 __u8 gosvw[16];
880 __u16 flags;
881 __u8 pad0[6];
882 __u64 pad1[4];
883};
884
885/* Kept in sync with firmware values for simplicity. */
886#define KVM_SEV_PAGE_TYPE_INVALID 0x0
887#define KVM_SEV_SNP_PAGE_TYPE_NORMAL 0x1
888#define KVM_SEV_SNP_PAGE_TYPE_ZERO 0x3
889#define KVM_SEV_SNP_PAGE_TYPE_UNMEASURED 0x4
890#define KVM_SEV_SNP_PAGE_TYPE_SECRETS 0x5
891#define KVM_SEV_SNP_PAGE_TYPE_CPUID 0x6
892
893struct kvm_sev_snp_launch_update {
894 __u64 gfn_start;
895 __u64 uaddr;
896 __u64 len;
897 __u8 type;
898 __u8 pad0;
899 __u16 flags;
900 __u32 pad1;
901 __u64 pad2[4];
902};
903
904#define KVM_SEV_SNP_ID_BLOCK_SIZE 96
905#define KVM_SEV_SNP_ID_AUTH_SIZE 4096
906#define KVM_SEV_SNP_FINISH_DATA_SIZE 32
907
908struct kvm_sev_snp_launch_finish {
909 __u64 id_block_uaddr;
910 __u64 id_auth_uaddr;
911 __u8 id_block_en;
912 __u8 auth_key_en;
913 __u8 vcek_disabled;
914 __u8 host_data[KVM_SEV_SNP_FINISH_DATA_SIZE];
915 __u8 pad0[3];
916 __u16 flags;
917 __u64 pad1[4];
918};
919
920#define KVM_X2APIC_API_USE_32BIT_IDS _BITULL(0)
921#define KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK _BITULL(1)
922#define KVM_X2APIC_ENABLE_SUPPRESS_EOI_BROADCAST _BITULL(2)
923#define KVM_X2APIC_DISABLE_SUPPRESS_EOI_BROADCAST _BITULL(3)
924
925struct kvm_hyperv_eventfd {
926 __u32 conn_id;
927 __s32 fd;
928 __u32 flags;
929 __u32 padding[3];
930};
931
932#define KVM_HYPERV_CONN_ID_MASK 0x00ffffff
933#define KVM_HYPERV_EVENTFD_DEASSIGN (1 << 0)
934
935/*
936 * Masked event layout.
937 * Bits Description
938 * ---- -----------
939 * 7:0 event select (low bits)
940 * 15:8 umask match
941 * 31:16 unused
942 * 35:32 event select (high bits)
943 * 36:54 unused
944 * 55 exclude bit
945 * 63:56 umask mask
946 */
947
948#define KVM_PMU_ENCODE_MASKED_ENTRY(event_select, mask, match, exclude) \
949 (((event_select) & 0xFFULL) | (((event_select) & 0XF00ULL) << 24) | \
950 (((mask) & 0xFFULL) << 56) | \
951 (((match) & 0xFFULL) << 8) | \
952 ((__u64)(!!(exclude)) << 55))
953
954#define KVM_PMU_MASKED_ENTRY_EVENT_SELECT \
955 (__GENMASK_ULL(7, 0) | __GENMASK_ULL(35, 32))
956#define KVM_PMU_MASKED_ENTRY_UMASK_MASK (__GENMASK_ULL(63, 56))
957#define KVM_PMU_MASKED_ENTRY_UMASK_MATCH (__GENMASK_ULL(15, 8))
958#define KVM_PMU_MASKED_ENTRY_EXCLUDE (_BITULL(55))
959#define KVM_PMU_MASKED_ENTRY_UMASK_MASK_SHIFT (56)
960
961/* for KVM_{GET,SET,HAS}_DEVICE_ATTR */
962#define KVM_VCPU_TSC_CTRL 0 /* control group for the timestamp counter (TSC) */
963#define KVM_VCPU_TSC_OFFSET 0 /* attribute for the TSC offset */
964
965/* x86-specific KVM_EXIT_HYPERCALL flags. */
966#define KVM_EXIT_HYPERCALL_LONG_MODE _BITULL(0)
967
968#define KVM_X86_DEFAULT_VM 0
969#define KVM_X86_SW_PROTECTED_VM 1
970#define KVM_X86_SEV_VM 2
971#define KVM_X86_SEV_ES_VM 3
972#define KVM_X86_SNP_VM 4
973#define KVM_X86_TDX_VM 5
974
975/* Trust Domain eXtension sub-ioctl() commands. */
976enum kvm_tdx_cmd_id {
977 KVM_TDX_CAPABILITIES = 0,
978 KVM_TDX_INIT_VM,
979 KVM_TDX_INIT_VCPU,
980 KVM_TDX_INIT_MEM_REGION,
981 KVM_TDX_FINALIZE_VM,
982 KVM_TDX_GET_CPUID,
983
984 KVM_TDX_CMD_NR_MAX,
985};
986
987struct kvm_tdx_cmd {
988 /* enum kvm_tdx_cmd_id */
989 __u32 id;
990 /* flags for sub-commend. If sub-command doesn't use this, set zero. */
991 __u32 flags;
992 /*
993 * data for each sub-command. An immediate or a pointer to the actual
994 * data in process virtual address. If sub-command doesn't use it,
995 * set zero.
996 */
997 __u64 data;
998 /*
999 * Auxiliary error code. The sub-command may return TDX SEAMCALL
1000 * status code in addition to -Exxx.
1001 */
1002 __u64 hw_error;
1003};
1004
1005struct kvm_tdx_capabilities {
1006 __u64 supported_attrs;
1007 __u64 supported_xfam;
1008
1009 __u64 kernel_tdvmcallinfo_1_r11;
1010 __u64 user_tdvmcallinfo_1_r11;
1011 __u64 kernel_tdvmcallinfo_1_r12;
1012 __u64 user_tdvmcallinfo_1_r12;
1013
1014 __u64 reserved[250];
1015
1016 /* Configurable CPUID bits for userspace */
1017 struct kvm_cpuid2 cpuid;
1018};
1019
1020struct kvm_tdx_init_vm {
1021 __u64 attributes;
1022 __u64 xfam;
1023 __u64 mrconfigid[6]; /* sha384 digest */
1024 __u64 mrowner[6]; /* sha384 digest */
1025 __u64 mrownerconfig[6]; /* sha384 digest */
1026
1027 /* The total space for TD_PARAMS before the CPUIDs is 256 bytes */
1028 __u64 reserved[12];
1029
1030 /*
1031 * Call KVM_TDX_INIT_VM before vcpu creation, thus before
1032 * KVM_SET_CPUID2.
1033 * This configuration supersedes KVM_SET_CPUID2s for VCPUs because the
1034 * TDX module directly virtualizes those CPUIDs without VMM. The user
1035 * space VMM, e.g. qemu, should make KVM_SET_CPUID2 consistent with
1036 * those values. If it doesn't, KVM may have wrong idea of vCPUIDs of
1037 * the guest, and KVM may wrongly emulate CPUIDs or MSRs that the TDX
1038 * module doesn't virtualize.
1039 */
1040 struct kvm_cpuid2 cpuid;
1041};
1042
1043#define KVM_TDX_MEASURE_MEMORY_REGION _BITULL(0)
1044
1045struct kvm_tdx_init_mem_region {
1046 __u64 source_addr;
1047 __u64 gpa;
1048 __u64 nr_pages;
1049};
1050
1051#endif /* _ASM_X86_KVM_H */