github.com/google/syzkaller@v0.0.0-20251211124644-a066d2bc4b02/sys/linux/dev_kvm_amd64.txt

# Copyright 2024 syzkaller project authors. All rights reserved.
# Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.

# x86(-64)-specific KVM syscall declarations.

meta arches["386", "amd64"]

include <linux/kvm.h>
include <linux/kvm_host.h>
include <asm/mce.h>

# kvm_syz_vm is a VM handler used by syzos-related pseudo-syscalls. It is actually an opaque pointer under the hood.
resource kvm_syz_vm$x86[int64]
resource fd_sgx_provision[fd]
resource fd_sev[fd]
resource sev_handle[int32]

# Map the given memory into the VM and set up syzos there.
syz_kvm_setup_syzos_vm$x86(fd fd_kvmvm, usermem vma[1024]) kvm_syz_vm$x86

# Create a VCPU inside a kvm_syz_vm VM.
# Prohibit flattening the input arguments, so that it is easier to reason about them.
syz_kvm_add_vcpu$x86(vm kvm_syz_vm$x86, text ptr[in, kvm_text$x86]) fd_kvmcpu (no_squash)

# Test assertions, will not be used by the fuzzer.
syz_kvm_assert_syzos_uexit$x86(run kvm_run_ptr, exitcode intptr) (no_generate)
syz_kvm_assert_syzos_kvm_exit$x86(run kvm_run_ptr, exitcode intptr) (no_generate)

# Pseudo call that setups VCPU into a reasonable interesting state for execution.
# The interface is designed for extensibility so that addition of new options does not invalidate all existing programs.
syz_kvm_setup_cpu$x86(fd fd_kvmvm, cpufd fd_kvmcpu, usermem vma[24], text ptr[in, array[kvm_text_x86, 1]], ntext len[text], flags flags[kvm_setup_flags], opts ptr[in, array[kvm_setup_opt_x86, 0:2]], nopt len[opts])

kvm_text$x86 {
	typ	const[0, intptr]
	text	ptr[in, array[syzos_api_call$x86, 1:32]]
	size	bytesize[text, int64]
}

syzos_api_code$x86 {
	insns	text[x86_64]
	ret	const[0xc3, int8]
} [packed]

type syzos_api$x86[NUM, PAYLOAD] {
	call	const[NUM, int64]
	size	bytesize[parent, int64]
	payload	PAYLOAD
}

syzos_api_cpuid {
	eax	int32
	ecx	int32
}

syzos_api_wrmsr {
	arg_reg		flags[msr_index, int64]
	arg_value	int64
}

syzos_api_rdmsr {
	arg_reg	flags[msr_index, int64]
}

# CR1 and CR5-7 are reserved.
x86_cr_reg_ids = 0, 2, 3, 4, 8

syzos_api_wr_crn {
	arg_reg		flags[x86_cr_reg_ids, int64]
	arg_value	int64
}

# Depending on CR4.DE, registers DR4 and DR5 either alias DR6 and DR7, or generate an #UD.
syzos_api_wr_drn {
	arg_reg		int64[0:7]
	arg_value	int64
}

x86_in_out_size = 1, 2, 4

syzos_api_in_dx {
	arg_port	int64[0:65535]
	arg_size	flags[x86_in_out_size, int64]
}

# In fact the accepted value always fit into int32.
syzos_api_out_dx {
	arg_port	int64[0:65535]
	arg_size	flags[x86_in_out_size, int64]
	arg_val		int64
}

syzos_api_set_irq_handler {
	arg_vector		int64[0:255]
	arg_handler_type	int64[0:2]
}

type syzos_api_vm_id int64[0:3]

syzos_api_nested_load_code {
	vm_id	syzos_api_vm_id
	insns	text[x86_64]
} [packed]

# VMCS Component Encoding is a 32-bit value, but only bits 0:15 are used.
# Certain bit combinations are invalid, because the number encodes additional
# parameters like access type and width.
# Constants as per Intel SDM vol. 3C, Appendix B.
vmcs_field_encoding [
	control16	int64[0x0:0x4, 2]
	guest16		int64[0x800:0x812, 2]
	host16		int64[0xc00:0xc0c, 2]
	control64	int64[0x2000:0x2033]
	ro64		int64[0x2400:0x2401]
	guest64		int64[0x2800:0x2813]
	host64		int64[0x2c00:0x2c05]
	control32	int64[0x4000:0x4022, 2]
	ro32		int64[0x4400:0x440e, 2]
	guest32		int64[0x4800:0x482e, 2]
	host32		int64[0x4c00:0x4c00]
	control_nat	int64[0x6000:0x600e, 2]
	ro_nat		int64[0x6400:0x640a, 2]
	guest_nat	int64[0x6800:0x6826, 2]
	host_nat	int64[0x6c00:0x6c16, 2]
]

syzos_api_nested_intel_vmwrite_mask {
	vm_id		syzos_api_vm_id
	field		vmcs_field_encoding
	set_mask	int64
	unset_mask	int64
	flip_mask	int64
}

# See AMD Secure Virtual Machine Architecture Reference Manual,
# Appendix C: Layout of VMCB.
vmcb_offset [
	control_area	int64[0x0:0xc0]
	save_area	int64[0x400:0x698]
]

syzos_api_nested_amd_vmcb_write_mask {
	vm_id		syzos_api_vm_id
	offset		vmcb_offset
	set_mask	int64
	unset_mask	int64
	flip_mask	int64
}

# IDs here must match those in executor/common_kvm_amd64_syzos.h.
syzos_api_call$x86 [
	uexit				syzos_api$x86[0, intptr]
	code				syzos_api$x86[10, syzos_api_code$x86]
	cpuid				syzos_api$x86[100, syzos_api_cpuid]
	wrmsr				syzos_api$x86[101, syzos_api_wrmsr]
	rdmsr				syzos_api$x86[102, syzos_api_rdmsr]
	wr_crn				syzos_api$x86[103, syzos_api_wr_crn]
	wr_drn				syzos_api$x86[104, syzos_api_wr_drn]
	in_dx				syzos_api$x86[105, syzos_api_in_dx]
	out_dx				syzos_api$x86[106, syzos_api_out_dx]
	set_irq_handler			syzos_api$x86[200, syzos_api_set_irq_handler]
	enable_nested			syzos_api$x86[300, const[0, intptr]]
	nested_create_vm		syzos_api$x86[301, syzos_api_vm_id]
	nested_load_code		syzos_api$x86[302, syzos_api_nested_load_code]
	nested_vmlaunch			syzos_api$x86[303, syzos_api_vm_id]
	nested_vmresume			syzos_api$x86[304, syzos_api_vm_id]
	nested_intel_vmwrite_mask	syzos_api$x86[340, syzos_api_nested_intel_vmwrite_mask]
	nested_amd_vmcb_write_mask	syzos_api$x86[380, syzos_api_nested_amd_vmcb_write_mask]
] [varlen]

kvm_text_x86 [
	textreal	kvm_text_x86_real
	text16		kvm_text_x86_16
	text32		kvm_text_x86_32
	text64		kvm_text_x86_64
]

kvm_text_x86_real {
	typ	const[8, intptr]
	text	ptr[in, text[x86_real]]
	size	len[text, intptr]
}

kvm_text_x86_16 {
	typ	const[16, intptr]
	text	ptr[in, text[x86_16]]
	size	len[text, intptr]
}

kvm_text_x86_32 {
	typ	const[32, intptr]
	text	ptr[in, text[x86_32]]
	size	len[text, intptr]
}

kvm_text_x86_64 {
	typ	const[64, intptr]
	text	ptr[in, text[x86_64]]
	size	len[text, intptr]
}

kvm_setup_opt_x86 [
	cr0	kvm_setup_opt_cr0
	cr4	kvm_setup_opt_cr4
	efer	kvm_setup_opt_efer
	flags	kvm_setup_opt_flags
	cstype0	kvm_setup_opt_cstype0
	cstype3	kvm_setup_opt_cstype3
	dstype0	kvm_setup_opt_dstype0
	dstype3	kvm_setup_opt_dstype3
	vmwrite	kvm_setup_opt_vmwrite
]

kvm_setup_opt_cr0 {
	typ	const[0, int64]
	val	flags[kvm_x86_cr0, int64]
}

kvm_setup_opt_cr4 {
	typ	const[1, int64]
	val	flags[kvm_x86_cr4, int64]
}

kvm_setup_opt_efer {
	typ	const[2, int64]
	val	flags[kvm_x86_efer, int64]
}

kvm_setup_opt_flags {
	typ	const[3, int64]
	val	flags[kvm_x86_rflags, int64]
}

kvm_setup_opt_cstype0 {
	typ	const[4, int64]
	val	int64[0:15]
}

kvm_setup_opt_cstype3 {
	typ	const[5, int64]
	val	int64[0:15]
}

kvm_setup_opt_dstype0 {
	typ	const[6, int64]
	val	int64[0:15]
}

kvm_setup_opt_dstype3 {
	typ	const[7, int64]
	val	int64[0:15]
}

kvm_setup_opt_vmwrite {
	typ	const[8, int64]
# Low 16 bits are field index, high 48 bits are value.
	sz	const[0, int64:1]
	fld	int64:5
	pad0	const[0, int64:4]
	ftyp	int64:2
	pad1	const[0, int64:1]
	fsz	int64:2
	pad2	const[0, int64:1]
	val	int64:48
}

kvm_setup_flags = KVM_SETUP_PAGING, KVM_SETUP_PAE, KVM_SETUP_PROTECTED, KVM_SETUP_CPL3, KVM_SETUP_VIRT86, KVM_SETUP_SMM, KVM_SETUP_VM

define KVM_SETUP_PAGING	(1<<0)
define KVM_SETUP_PAE	(1<<1)
define KVM_SETUP_PROTECTED	(1<<2)
define KVM_SETUP_CPL3	(1<<3)
define KVM_SETUP_VIRT86	(1<<4)
define KVM_SETUP_SMM	(1<<5)
define KVM_SETUP_VM	(1<<6)

# SGX-related
openat$sgx_provision(fd const[AT_FDCWD], file ptr[in, string["/dev/sgx_provision"]], flags flags[open_flags], mode const[0]) fd_sgx_provision
ioctl$KVM_CAP_SGX_ATTRIBUTE(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_SGX_ATTRIBUTE, fd_sgx_provision]])

# SEV-related (based on https://www.kernel.org/doc/html/latest/virt/kvm/x86/amd-memory-encryption.html)
openat$sev(fd const[AT_FDCWD], file ptr[in, string["/dev/sev"]], flags flags[open_flags], mode const[0]) fd_sev

ioctl$KVM_SEV_INIT(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_INIT, const[0, intptr]]])
ioctl$KVM_SEV_ES_INIT(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_ES_INIT, const[0, intptr]]])
ioctl$KVM_SEV_INIT2(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_INIT2, ptr[in, kvm_sev_init]]])

ioctl$KVM_SEV_LAUNCH_START(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_LAUNCH_START, ptr[inout, kvm_sev_launch_start]]])
ioctl$KVM_SEV_LAUNCH_UPDATE_DATA(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_LAUNCH_UPDATE_DATA, ptr[in, kvm_sev_launch_update_data]]])
ioctl$KVM_SEV_LAUNCH_UPDATE_VMSA(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_LAUNCH_UPDATE_VMSA, const[0, intptr]]])
ioctl$KVM_SEV_LAUNCH_SECRET(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_LAUNCH_SECRET, ptr[in, kvm_sev_launch_secret]]])
ioctl$KVM_SEV_LAUNCH_MEASURE(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_LAUNCH_MEASURE, ptr[in, kvm_sev_launch_measure]]])
ioctl$KVM_SEV_LAUNCH_FINISH(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_LAUNCH_FINISH, const[0, intptr]]])

ioctl$KVM_SEV_SEND_START(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_SEND_START, ptr[in, kvm_sev_send_start]]])
ioctl$KVM_SEV_SEND_UPDATE_DATA(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_SEND_UPDATE_DATA, ptr[in, kvm_sev_send_update_data]]])
ioctl$KVM_SEV_SEND_UPDATE_VMSA(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_SEND_UPDATE_VMSA, const[0, intptr]]])
ioctl$KVM_SEV_SEND_CANCEL(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_SEND_CANCEL, const[0, intptr]]])
ioctl$KVM_SEV_SEND_FINISH(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_SEND_FINISH, const[0, intptr]]])

ioctl$KVM_SEV_RECEIVE_START(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_RECEIVE_START, ptr[inout, kvm_sev_receive_start]]])
ioctl$KVM_SEV_RECEIVE_UPDATE_DATA(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_RECEIVE_UPDATE_DATA, ptr[in, kvm_sev_receive_update_data]]])
ioctl$KVM_SEV_RECEIVE_UPDATE_VMSA(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_RECEIVE_UPDATE_VMSA, const[0, intptr]]])
ioctl$KVM_SEV_RECEIVE_FINISH(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_RECEIVE_FINISH, const[0, intptr]]])

ioctl$KVM_SEV_GUEST_STATUS(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_GUEST_STATUS, ptr[out, kvm_sev_guest_status]]])
ioctl$KVM_SEV_DBG_DECRYPT(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_DBG_DECRYPT, ptr[in, kvm_sev_dbg]]])
ioctl$KVM_SEV_DBG_ENCRYPT(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_DBG_ENCRYPT, ptr[in, kvm_sev_dbg]]])
ioctl$KVM_SEV_CERT_EXPORT(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_CERT_EXPORT, const[0, intptr]]])
ioctl$KVM_SEV_GET_ATTESTATION_REPORT(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_GET_ATTESTATION_REPORT, ptr[in, kvm_sev_attestation_report]]])

ioctl$KVM_SEV_SNP_LAUNCH_START(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_SNP_LAUNCH_START, ptr[in, kvm_sev_snp_launch_start]]])
ioctl$KVM_SEV_SNP_LAUNCH_UPDATE(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_SNP_LAUNCH_UPDATE, ptr[in, kvm_sev_snp_launch_update]]])
ioctl$KVM_SEV_SNP_LAUNCH_FINISH(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_OP], arg ptr[inout, kvm_memory_encrypt_op[KVM_SEV_SNP_LAUNCH_FINISH, ptr[in, kvm_sev_snp_launch_finish]]])

# Apparently KVM_MEMORY_ENCRYPT_REG_REGION and KVM_MEMORY_ENCRYPT_UNREG_REGION are VM ioctls, despite
# https://docs.kernel.org/virt/kvm/api.html#kvm-memory-encrypt-reg-region says they are system.
ioctl$KVM_MEMORY_ENCRYPT_REG_REGION(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_REG_REGION], arg ptr[in, kvm_enc_region])
ioctl$KVM_MEMORY_ENCRYPT_UNREG_REGION(fd fd_kvmvm, cmd const[KVM_MEMORY_ENCRYPT_UNREG_REGION], arg ptr[in, kvm_enc_region])

type kvm_memory_encrypt_op[ID, DATA] {
	id	const[ID, int32]
	data	DATA
	error	int32	(out)
	sev_fd	fd_sev	(in)
}

kvm_sev_init {
	vmsa_features	int64
	flags		int32
	ghcb_version	int16
	pad1		const[0, int16]
	pad2		array[const[0, int32], 8]
}

kvm_sev_launch_start {
	handle		sev_handle	(inout)
	policy		int32
	dh_addr		vma64[1:4]
	dh_len		len[dh_addr, int32]
	pad0		const[0, int32]
	session_uaddr	vma64[1:4]
	session_len	len[session_uaddr, int32]
	pad1		const[0, int32]
}

kvm_sev_launch_update_data {
	uaddr	vma64[1:4]
	len	len[uaddr, int32]
	pad0	const[0, int32]
}

kvm_sev_launch_secret {
	hdr_uaddr	vma64[1:4]
	hdr_len		len[hdr_uaddr, int32]
	pad0		const[0, int32]
	guest_uaddr	vma64[1:4]
	guest_len	len[guest_uaddr, int32]
	pad1		const[0, int32]
	trans_uaddr	vma64[1:4]
	trans_len	len[trans_uaddr, int32]
	pad2		const[0, int32]
}

kvm_sev_launch_measure {
	uaddr	vma64[1:4]
	len	len[uaddr, int32]
	pad0	const[0, int32]
}

kvm_sev_guest_status {
	handle	sev_handle
	policy	int32
	state	int8
}

kvm_sev_dbg {
	src_uaddr	vma64[1:4]
	dst_uaddr	vma64[1:4]
	len		len[src_uaddr, int32]
}

kvm_sev_attestation_report {
	mnonce	array[int8, 16]
	uaddr	vma64[1:4]
	len	len[uaddr, int32]
	pad0	const[0, int32]
}

kvm_sev_send_start {
	policy			int32
	pad0			const[0, int32]
	pdh_cert_uaddr		vma64[1:4]
	pdh_cert_len		len[pdh_cert_uaddr, int32]
	pad1			const[0, int32]
	plat_certs_uaddr	vma64[1:4]
	plat_certs_len		len[plat_certs_uaddr, int32]
	pad2			const[0, int32]
	amd_certs_uaddr		vma64[1:4]
	amd_certs_len		len[amd_certs_uaddr, int32]
	pad3			const[0, int32]
	session_uaddr		vma64[1:4]
	session_len		len[session_uaddr, int32]
	pad4			const[0, int32]
}

kvm_sev_send_update_data {
	hdr_uaddr	vma64[1:4]
	hdr_len		len[hdr_uaddr, int32]
	pad0		const[0, int32]
	guest_uaddr	vma64[1:4]
	guest_len	len[guest_uaddr, int32]
	pad1		const[0, int32]
	trans_uaddr	vma64[1:4]
	trans_len	len[trans_uaddr, int32]
	pad2		const[0, int32]
}

kvm_sev_receive_start {
	handle		sev_handle	(inout)
	policy		int32
	pdh_addr	vma64[1:4]
	pdh_len		len[pdh_addr, int32]
	pad0		const[0, int32]
	session_uaddr	vma64[1:4]
	session_len	len[session_uaddr, int32]
	pad1		const[0, int32]
}

kvm_sev_receive_update_data {
	hdr_uaddr	vma64[1:4]
	hdr_len		len[hdr_uaddr, int32]
	pad0		const[0, int32]
	guest_uaddr	vma64[1:4]
	guest_len	len[guest_uaddr, int32]
	pad1		const[0, int32]
	trans_uaddr	vma64[1:4]
	trans_len	len[trans_uaddr, int32]
	pad2		const[0, int32]
}

kvm_sev_snp_launch_start {
	policy	int64
	gosvw	array[int8, 16]
	flags	int16
	pad0	array[const[0, int8], 6]
	pad1	array[const[0, int64], 4]
}

kvm_sev_snp_launch_update {
	gfn_start	int64
	uaddr		vma64[1:4]
	len		len[uaddr, int64]
	type		flags[snp_page_type, int8]
	pad0		const[0, int8]
	flags		int16
	pad1		const[0, int32]
	pad2		array[const[0, int64], 4]
}

snp_page_type = KVM_SEV_SNP_PAGE_TYPE_NORMAL, KVM_SEV_SNP_PAGE_TYPE_ZERO, KVM_SEV_SNP_PAGE_TYPE_UNMEASURED, KVM_SEV_SNP_PAGE_TYPE_SECRETS, KVM_SEV_SNP_PAGE_TYPE_CPUID

kvm_sev_snp_launch_finish {
	id_block_uaddr	vma64[1:4]
	id_auth_uaddr	vma64[1:4]
	id_block_en	int8
	auth_key_en	int8
	vcek_disabled	int8
	host_data	array[int8, KVM_SEV_SNP_FINISH_DATA_SIZE]
	pad0		array[const[0, int8], 3]
	flags		int16
	pad1		array[const[0, int64], 4]
}

kvm_enc_region {
	addr	flags[kvm_guest_addrs, int64]
	size	flags[kvm_guest_addr_size, int64]
}

#x86(-64) specific ioctls
ioctl$KVM_GET_MSR_INDEX_LIST(fd fd_kvm, cmd const[KVM_GET_MSR_INDEX_LIST], arg ptr[inout, kvm_msr_list])
ioctl$KVM_GET_MSR_FEATURE_INDEX_LIST(fd fd_kvm, cmd const[KVM_GET_MSR_FEATURE_INDEX_LIST], arg ptr[inout, kvm_msr_list])
ioctl$KVM_X86_GET_MCE_CAP_SUPPORTED(fd fd_kvm, cmd const[KVM_X86_GET_MCE_CAP_SUPPORTED], arg ptr[out, int64])
ioctl$KVM_SET_IRQCHIP(fd fd_kvmvm, cmd const[KVM_SET_IRQCHIP], arg ptr[in, kvm_irqchip])
ioctl$KVM_GET_IRQCHIP(fd fd_kvmvm, cmd const[KVM_GET_IRQCHIP], arg ptr[inout, kvm_irqchip])
ioctl$KVM_XEN_HVM_CONFIG(fd fd_kvmvm, cmd const[KVM_XEN_HVM_CONFIG], arg ptr[in, kvm_xen_hvm_config])
ioctl$KVM_GET_CLOCK(fd fd_kvmvm, cmd const[KVM_GET_CLOCK], arg ptr[out, kvm_clock_data])
ioctl$KVM_SET_CLOCK(fd fd_kvmvm, cmd const[KVM_SET_CLOCK], arg ptr[in, kvm_clock_data])
ioctl$KVM_SET_TSS_ADDR(fd fd_kvmvm, cmd const[KVM_SET_TSS_ADDR], arg flags[kvm_x86_tss_addr])
ioctl$KVM_SET_IDENTITY_MAP_ADDR(fd fd_kvmvm, cmd const[KVM_SET_IDENTITY_MAP_ADDR], arg ptr[in, flags[kvm_guest_addrs, int64]])
ioctl$KVM_SET_BOOT_CPU_ID(fd fd_kvmvm, cmd const[KVM_SET_BOOT_CPU_ID], arg ptr[in, intptr[0:2]])
ioctl$KVM_CREATE_PIT2(fd fd_kvmvm, cmd const[KVM_CREATE_PIT2], arg ptr[in, kvm_pit_config])
ioctl$KVM_GET_PIT(fd fd_kvmvm, cmd const[KVM_GET_PIT], arg ptr[out, kvm_pit_state2])
ioctl$KVM_SET_PIT(fd fd_kvmvm, cmd const[KVM_SET_PIT], arg ptr[in, kvm_pit_state2])
ioctl$KVM_GET_PIT2(fd fd_kvmvm, cmd const[KVM_GET_PIT2], arg ptr[out, kvm_pit_state2])
ioctl$KVM_SET_PIT2(fd fd_kvmvm, cmd const[KVM_SET_PIT2], arg ptr[in, kvm_pit_state2])
ioctl$KVM_SET_NR_MMU_PAGES(fd fd_kvmvm, cmd const[KVM_SET_NR_MMU_PAGES], arg intptr)
ioctl$KVM_GET_NR_MMU_PAGES(fd fd_kvmvm, cmd const[KVM_GET_NR_MMU_PAGES], arg intptr)
ioctl$KVM_REINJECT_CONTROL(fd fd_kvmvm, cmd const[KVM_REINJECT_CONTROL], arg ptr[in, kvm_reinject_control])
ioctl$KVM_HYPERV_EVENTFD(fd fd_kvmvm, cmd const[KVM_HYPERV_EVENTFD], arg ptr[in, kvm_hyperv_eventfd])
ioctl$KVM_X86_SET_MSR_FILTER(fd fd_kvmvm, cmd const[KVM_X86_SET_MSR_FILTER], arg ptr[in, kvm_msr_filter])

# Defined by include/linux/kvm_host.h, but for some reason wouldn't extract.
define KVM_MAX_IRQ_ROUTES	4096
ioctl$KVM_CAP_DISABLE_QUIRKS(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_DISABLE_QUIRKS, flags[kvm_x86_quirks, int64]]])
ioctl$KVM_CAP_DISABLE_QUIRKS2(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_DISABLE_QUIRKS2, flags[kvm_x86_quirks, int64]]])
ioctl$KVM_CAP_SPLIT_IRQCHIP(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_SPLIT_IRQCHIP, int64[0:KVM_MAX_IRQ_ROUTES]]])
ioctl$KVM_CAP_X2APIC_API(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_X2APIC_API, flags[kvm_x2apic_apis, int64]]])
ioctl$KVM_CAP_X86_DISABLE_EXITS(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_X86_DISABLE_EXITS, flags[kvm_x86_exits, int64]]])
ioctl$KVM_CAP_MSR_PLATFORM_INFO(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_MSR_PLATFORM_INFO, bool64]])
ioctl$KVM_CAP_EXCEPTION_PAYLOAD(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_EXCEPTION_PAYLOAD, bool64]])
ioctl$KVM_CAP_X86_USER_SPACE_MSR(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_X86_USER_SPACE_MSR, flags[kvm_msr_exit_reasons, int64]]])
ioctl$KVM_CAP_X86_BUS_LOCK_EXIT(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_X86_BUS_LOCK_EXIT, flags[kvm_bus_lock_exits, int64]]])
ioctl$KVM_CAP_VM_COPY_ENC_CONTEXT_FROM(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_VM_COPY_ENC_CONTEXT_FROM, fd_kvmvm]])
ioctl$KVM_CAP_EXIT_HYPERCALL(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_EXIT_HYPERCALL, flags[kvm_hypercall_exits, int64]]])
ioctl$KVM_CAP_EXIT_ON_EMULATION_FAILURE(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_EXIT_ON_EMULATION_FAILURE, bool64]])
ioctl$KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM, fd_kvmvm]])
ioctl$KVM_CAP_MEMORY_FAULT_INFO(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_MEMORY_FAULT_INFO, void]])
ioctl$KVM_CAP_X86_GUEST_MODE(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_X86_GUEST_MODE, void]])
ioctl$KVM_CAP_HYPERV_VP_INDEX(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_HYPERV_VP_INDEX, void]])
ioctl$KVM_CAP_HYPERV_TLBFLUSH(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_HYPERV_TLBFLUSH, void]])
ioctl$KVM_CAP_HYPERV_SEND_IPI(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_HYPERV_SEND_IPI, void]])
ioctl$KVM_CAP_STEAL_TIME(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_STEAL_TIME, void]])
ioctl$KVM_CAP_XEN_HVM(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_XEN_HVM, flags[kvm_xen_hvm_configs, int64]]])
ioctl$KVM_CAP_VM_DISABLE_NX_HUGE_PAGES(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_VM_DISABLE_NX_HUGE_PAGES, const[0, int64]]])
ioctl$KVM_CAP_VM_TYPES(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_VM_TYPES, flags[kvm_x86_vm_types, int64]]])

# TODO: need more precise handling for arguments below
ioctl$KVM_CAP_MAX_VCPU_ID(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_MAX_VCPU_ID, int64]])
ioctl$KVM_CAP_X86_NOTIFY_VMEXIT(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_X86_NOTIFY_VMEXIT, int64]])
ioctl$KVM_CAP_X86_APIC_BUS_CYCLES_NS(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_X86_APIC_BUS_CYCLES_NS, int64]])
ioctl$KVM_CAP_PMU_CAPABILITY(fd fd_kvmvm, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_PMU_CAPABILITY, int64]])

ioctl$KVM_TRANSLATE(fd fd_kvmcpu, cmd const[KVM_TRANSLATE], arg ptr[inout, kvm_translation])
# KVM_GET_MSRS can be both a system and a vcpu ioctl: https://docs.kernel.org/virt/kvm/api.html#kvm-get-msrs
ioctl$KVM_GET_MSRS_sys(fd fd_kvm, cmd const[KVM_GET_MSRS], arg ptr[inout, kvm_msrs])
ioctl$KVM_GET_MSRS_cpu(fd fd_kvmcpu, cmd const[KVM_GET_MSRS], arg ptr[inout, kvm_msrs])
ioctl$KVM_SET_MSRS(fd fd_kvmcpu, cmd const[KVM_SET_MSRS], arg ptr[in, kvm_msrs]) (no_squash)
ioctl$KVM_SET_CPUID(fd fd_kvmcpu, cmd const[KVM_SET_CPUID], arg ptr[in, kvm_cpuid]) (no_squash)
# NEED: we should be able to read kvm_cpuid2 with KVM_GET_CPUID2, alter few bits and then call KVM_SET_CPUID2 with that object.
ioctl$KVM_GET_CPUID2(fd fd_kvmcpu, cmd const[KVM_GET_CPUID2], arg ptr[out, kvm_cpuid2])
ioctl$KVM_SET_CPUID2(fd fd_kvmcpu, cmd const[KVM_SET_CPUID2], arg ptr[in, kvm_cpuid2]) (no_squash)
ioctl$KVM_GET_SUPPORTED_CPUID(fd fd_kvm, cmd const[KVM_GET_SUPPORTED_CPUID], arg ptr[inout, kvm_cpuid2])
# KVM_GET_SUPPORTED_HV_CPUID is both a system and a vcpu ioctl: https://docs.kernel.org/virt/kvm/api.html#kvm-get-supported-hv-cpuid
ioctl$KVM_GET_SUPPORTED_HV_CPUID_sys(fd fd_kvm, cmd const[KVM_GET_SUPPORTED_HV_CPUID], arg ptr[inout, kvm_cpuid2])
ioctl$KVM_GET_SUPPORTED_HV_CPUID_cpu(fd fd_kvmcpu, cmd const[KVM_GET_SUPPORTED_HV_CPUID], arg ptr[inout, kvm_cpuid2])
ioctl$KVM_GET_EMULATED_CPUID(fd fd_kvm, cmd const[KVM_GET_EMULATED_CPUID], arg ptr[inout, kvm_cpuid2])

ioctl$KVM_GET_FPU(fd fd_kvmcpu, cmd const[KVM_GET_FPU], arg ptr[out, kvm_fpu])
ioctl$KVM_SET_FPU(fd fd_kvmcpu, cmd const[KVM_SET_FPU], arg ptr[in, kvm_fpu])
ioctl$KVM_GET_DEBUGREGS(fd fd_kvmcpu, cmd const[KVM_GET_DEBUGREGS], arg ptr[out, kvm_debugregs])
ioctl$KVM_SET_DEBUGREGS(fd fd_kvmcpu, cmd const[KVM_SET_DEBUGREGS], arg ptr[in, kvm_debugregs])
ioctl$KVM_SET_GUEST_DEBUG_x86(fd fd_kvmcpu, cmd const[KVM_SET_GUEST_DEBUG], arg ptr[in, kvm_guest_debug[kvm_guest_debug_arch_x86]])
ioctl$KVM_GET_XCRS(fd fd_kvmcpu, cmd const[KVM_GET_XCRS], arg ptr[out, kvm_xcrs])
ioctl$KVM_SET_XCRS(fd fd_kvmcpu, cmd const[KVM_SET_XCRS], arg ptr[in, kvm_xcrs])
ioctl$KVM_GET_XSAVE(fd fd_kvmcpu, cmd const[KVM_GET_XSAVE], arg ptr[out, kvm_xsave])
ioctl$KVM_SET_XSAVE(fd fd_kvmcpu, cmd const[KVM_SET_XSAVE], arg ptr[in, kvm_xsave])
# KVM_SET_TSC_KHZ and KVM_GET_TSC_KHZ are both vcpu and vm ioctls: https://docs.kernel.org/virt/kvm/api.html#kvm-set-tsc-khz
ioctl$KVM_SET_TSC_KHZ_cpu(fd fd_kvmcpu, cmd const[KVM_SET_TSC_KHZ], arg intptr)
ioctl$KVM_SET_TSC_KHZ_vm(fd fd_kvmvm, cmd const[KVM_SET_TSC_KHZ], arg intptr)
ioctl$KVM_GET_TSC_KHZ_cpu(fd fd_kvmcpu, cmd const[KVM_GET_TSC_KHZ])
ioctl$KVM_GET_TSC_KHZ_vm(fd fd_kvmvm, cmd const[KVM_GET_TSC_KHZ])
ioctl$KVM_GET_LAPIC(fd fd_kvmcpu, cmd const[KVM_GET_LAPIC], arg ptr[out, kvm_lapic_state])
ioctl$KVM_SET_LAPIC(fd fd_kvmcpu, cmd const[KVM_SET_LAPIC], arg ptr[in, kvm_lapic_state])
ioctl$KVM_NMI(fd fd_kvmcpu, cmd const[KVM_NMI])
ioctl$KVM_SMI(fd fd_kvmcpu, cmd const[KVM_SMI])
ioctl$KVM_TPR_ACCESS_REPORTING(fd fd_kvmcpu, cmd const[KVM_TPR_ACCESS_REPORTING], arg ptr[in, kvm_tpr_access_ctl])
ioctl$KVM_SET_VAPIC_ADDR(fd fd_kvmcpu, cmd const[KVM_SET_VAPIC_ADDR], arg ptr[in, flags[kvm_guest_addrs, int64]])
ioctl$KVM_X86_SETUP_MCE(fd fd_kvmcpu, cmd const[KVM_X86_SETUP_MCE], arg ptr[in, kvm_mce_cap])
ioctl$KVM_X86_SET_MCE(fd fd_kvmcpu, cmd const[KVM_X86_SET_MCE], arg ptr[in, kvm_x86_mce])
ioctl$KVM_GET_NESTED_STATE(fd fd_kvmcpu, cmd const[KVM_GET_NESTED_STATE], arg ptr[inout, kvm_nested_state_arg])
ioctl$KVM_SET_NESTED_STATE(fd fd_kvmcpu, cmd const[KVM_SET_NESTED_STATE], arg ptr[in, kvm_nested_state_arg])
# NEED: arch constraints for syscalls. These are amd64/386-specific, but consts are present on all arches, so they are not disabled on other arches.
ioctl$KVM_CAP_HYPERV_SYNIC(fd fd_kvmcpu, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_HYPERV_SYNIC, void]])
ioctl$KVM_CAP_HYPERV_SYNIC2(fd fd_kvmcpu, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_HYPERV_SYNIC2, const[0, int64]]])
ioctl$KVM_CAP_HYPERV_ENLIGHTENED_VMCS(fd fd_kvmcpu, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_HYPERV_ENLIGHTENED_VMCS, ptr[out, int16]]])
ioctl$KVM_CAP_HYPERV_DIRECT_TLBFLUSH(fd fd_kvmcpu, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_HYPERV_DIRECT_TLBFLUSH, void]])
ioctl$KVM_CAP_HYPERV_ENFORCE_CPUID(fd fd_kvmcpu, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_HYPERV_ENFORCE_CPUID, bool64]])
ioctl$KVM_CAP_ENFORCE_PV_FEATURE_CPUID(fd fd_kvmcpu, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_ENFORCE_PV_FEATURE_CPUID, bool64]])
ioctl$KVM_CAP_SYNC_REGS(fd fd_kvmcpu, cmd const[KVM_ENABLE_CAP], arg ptr[in, kvm_enable_cap[KVM_CAP_SYNC_REGS, void]])

ioctl$KVM_SET_MEMORY_ATTRIBUTES(fd fd_kvmvm, cmd const[KVM_SET_MEMORY_ATTRIBUTES], arg ptr[in, kvm_memory_attributes])
ioctl$KVM_GET_XSAVE2(fd fd_kvmcpu, cmd const[KVM_GET_XSAVE2], arg vma)

# KVM_GET_SREGS2/KVM_SET_SREGS2 are only supported on x86 - unlike KVM_GET_SREGS/KVM_SET_SREGS.
# https://docs.kernel.org/virt/kvm/api.html#kvm-get-sregs2
ioctl$KVM_GET_SREGS2(fd fd_kvmcpu, cmd const[KVM_GET_SREGS2], arg ptr[out, kvm_sregs2])
ioctl$KVM_SET_SREGS2(fd fd_kvmcpu, cmd const[KVM_SET_SREGS2], arg ptr[in, kvm_sregs2])

kvm_guest_debug_arch_x86 {
	reg	array[int64, 8]
}

kvm_vmx_smm {
	flags	flags[kvm_nested_smm_flags, int16]
}

# Size must be 120 bytes to start data at 128 bytes.
kvm_vmx_nested_state_hdr {
	vmxon_pa			flags[kvm_guest_addrs, int64]
	vmcs12_pa			flags[kvm_guest_addrs, int64]
	smm				kvm_vmx_smm
	flags				flags[kvm_vmx_nested_state_hdr_flags, int32]
	preemption_timer_deadline	int64
} [size[120]]

kvm_vmx_nested_state_data {
	vmcs12		array[int8, KVM_STATE_NESTED_VMX_VMCS_SIZE]
	shadow_vmcs12	array[int8, KVM_STATE_NESTED_VMX_VMCS_SIZE]
}

# format = KVM_STATE_NESTED_FORMAT_VMX
kvm_nested_state_vmx {
	flags	flags[kvm_nested_state_flags, int16]
	format	const[0, int16]
	size	bytesize[parent, int32]
	hdr	kvm_vmx_nested_state_hdr
	data	kvm_vmx_nested_state_data
}

# SVM descriptions taken from https://elixir.bootlin.com/linux/latest/source/arch/x86/include/uapi/asm/kvm.h
# Size must be 120 bytes to start data at 128 bytes.
kvm_svm_nested_state_hdr {
	vmcb_pa	flags[kvm_guest_addrs, int64]
} [size[120]]

kvm_svm_nested_state_data {
	vmcb12	array[int8, KVM_STATE_NESTED_SVM_VMCB_SIZE]
}

# format = KVM_STATE_NESTED_FORMAT_SVM
kvm_nested_state_svm {
	flags	flags[kvm_nested_state_flags, int16]
	format	const[1, int16]
	size	bytesize[parent, int32]
	hdr	kvm_svm_nested_state_hdr
	data	kvm_svm_nested_state_data
}

# See https://docs.kernel.org/virt/kvm/api.html#kvm-get-nested-state.
kvm_nested_state_arg [
	vmx	kvm_nested_state_vmx
	svm	kvm_nested_state_svm
] [varlen]

kvm_nested_state_flags = KVM_STATE_NESTED_GUEST_MODE, KVM_STATE_NESTED_RUN_PENDING, KVM_STATE_NESTED_EVMCS, KVM_STATE_NESTED_MTF_PENDING, KVM_STATE_NESTED_GIF_SET
kvm_nested_smm_flags = KVM_STATE_NESTED_SMM_GUEST_MODE, KVM_STATE_NESTED_SMM_VMXON
kvm_vmx_nested_state_hdr_flags = KVM_STATE_VMX_PREEMPTION_TIMER_DEADLINE

kvm_cpuid_entry {
	func	flags[kvm_cpu_function, int32]
	eax	int32
	ebx	int32
	ecx	int32
	edx	int32
	pad	const[0, int32]
}

kvm_cpuid {
	n	len[entries, int32]
	pad	const[0, int32]
	entries	array[kvm_cpuid_entry]
}

kvm_cpuid_entry2 {
	func	flags[kvm_cpu_function, int32]
	index	int32
	flags	flags[kvm_cpuid_flags, int32]
	eax	int32
	ebx	int32
	ecx	int32
	edx	int32
	pad	array[const[0, int32], 3]
}

kvm_cpuid2 {
	n	len[entries, int32]
	pad	const[0, int32]
	entries	array[kvm_cpuid_entry2]
}

kvm_cpuid_flags = KVM_CPUID_FLAG_SIGNIFCANT_INDEX, KVM_CPUID_FLAG_STATEFUL_FUNC, KVM_CPUID_FLAG_STATE_READ_NEXT

kvm_x86_mce {
	status	flags[kvm_mce_status, int64]
	addr	flags[kvm_guest_addrs, int64]
	misc	int64
	mcg	flags[kvm_mcg_status, int64]
	bank	int8[0:32]
	pad1	array[const[0, int8], 7]
	pad2	array[const[0, int64], 3]
}

kvm_x86_quirks = KVM_X86_QUIRK_LINT0_REENABLED, KVM_X86_QUIRK_CD_NW_CLEARED, KVM_X86_QUIRK_LAPIC_MMIO_HOLE, KVM_X86_QUIRK_OUT_7E_INC_RIP, KVM_X86_QUIRK_MISC_ENABLE_NO_MWAIT, KVM_X86_QUIRK_FIX_HYPERCALL_INSN, KVM_X86_QUIRK_MWAIT_NEVER_UD_FAULTS
kvm_mce_status = MCI_STATUS_VAL, MCI_STATUS_OVER, MCI_STATUS_UC, MCI_STATUS_EN, MCI_STATUS_MISCV, MCI_STATUS_ADDRV, MCI_STATUS_PCC, MCI_STATUS_S, MCI_STATUS_AR
define KVM_X86_DEFAULT_VM_BIT	(1 << KVM_X86_DEFAULT_VM)
define KVM_X86_SW_PROTECTED_VM_BIT	(1 << KVM_X86_SW_PROTECTED_VM)
define KVM_X86_SEV_VM_BIT	(1 << KVM_X86_SEV_VM)
define KVM_X86_SEV_ES_VM_BIT	(1 << KVM_X86_SEV_ES_VM)

kvm_chip_id = KVM_IRQCHIP_PIC_MASTER, KVM_IRQCHIP_PIC_SLAVE, KVM_IRQCHIP_IOAPIC
kvm_mcg_status = MCG_STATUS_RIPV, MCG_STATUS_EIPV, MCG_STATUS_MCIP, MCG_STATUS_LMCES
kvm_bus_lock_exits = KVM_BUS_LOCK_DETECTION_OFF, KVM_BUS_LOCK_DETECTION_EXIT
kvm_mce_flags = 1, 2, 4
kvm_x86_vm_types = KVM_X86_DEFAULT_VM_BIT, KVM_X86_SW_PROTECTED_VM_BIT, KVM_X86_SEV_VM_BIT, KVM_X86_SEV_ES_VM_BIT
kvm_xen_hvm_configs = KVM_XEN_HVM_CONFIG_HYPERCALL_MSR, KVM_XEN_HVM_CONFIG_INTERCEPT_HCALL, KVM_XEN_HVM_CONFIG_SHARED_INFO, KVM_XEN_HVM_CONFIG_RUNSTATE, KVM_XEN_HVM_CONFIG_EVTCHN_2LEVEL, KVM_XEN_HVM_CONFIG_EVTCHN_SEND, KVM_XEN_HVM_CONFIG_RUNSTATE_UPDATE_FLAG, KVM_XEN_HVM_CONFIG_PVCLOCK_TSC_UNSTABLE
kvm_clock_flags = KVM_CLOCK_TSC_STABLE, KVM_CLOCK_REALTIME, KVM_CLOCK_HOST_TSC
kvm_x86_tss_addr = 0xd000
kvm_msr_exit_reasons = KVM_MSR_EXIT_REASON_INVAL, KVM_MSR_EXIT_REASON_UNKNOWN, KVM_MSR_EXIT_REASON_FILTER
kvm_x86_dr7 = 1, 2, 4, 8, 16, 32, 64, 128
kvm_x86_exits = KVM_X86_DISABLE_EXITS_MWAIT, KVM_X86_DISABLE_EXITS_HLT, KVM_X86_DISABLE_EXITS_PAUSE, KVM_X86_DISABLE_EXITS_CSTATE
kvm_hypercall_exits = KVM_HC_MAP_GPA_RANGE
kvm_cpu_function = 0, 1, 2, 4, 6, 7, 10, 11, 13, KVM_CPUID_SIGNATURE, KVM_CPUID_FEATURES, 0x80000000, 0x80000001, 0x80000007, 0x80000008, 0x80000019, 0xc0000000, 0xc0000001
kvm_x2apic_apis = KVM_X2APIC_API_USE_32BIT_IDS, KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK

kvm_tpr_access_ctl {
	enabled	int32
	flags	int32
	reserv	array[const[0, int32], 8]
}

kvm_reinject_control {
	reinjec	int8
	reserv	array[const[0, int8], 31]
}

kvm_xcr {
	xcr	int32
	reserv	const[0, int32]
	val	int64
}

kvm_xcrs {
	nr	int32[0:KVM_MAX_XCRS]
	flags	int32
	xcrs	array[kvm_xcr, KVM_MAX_XCRS]
	pad	array[const[0, int64], 16]
}

kvm_xsave {
	region	array[int32, 1024]
}

kvm_clock_data {
	clock		int64
	flags		flags[kvm_clock_flags, int32]
	pad0		int32
	realtime	int64
	host_tsc	int64
	pad		array[const[0, int32], 4]
}

kvm_xen_hvm_config {
	flags	int32
	msr	flags[msr_index, int32]
	addr32	ptr64[in, array[int8]]
	addr64	ptr64[in, array[int8]]
	size32	len[addr32, int8]
	size64	len[addr64, int8]
	pad	array[const[0, int8], 30]
}

kvm_mce_cap {
	banks	int8[0:32]
	flags	flags[kvm_mce_flags, int8]
	count	int8
	pad	const[0, int8]
}

kvm_translation {
	laddr		flags[kvm_guest_addrs, int64]
	paddr		flags[kvm_guest_addrs, int64]
	valid		int8
	writeable	int8
	usermode	int8
	pad		array[const[0, int8], 5]
}

kvm_hyperv_eventfd {
	conn_id	int32[0:4]
	fd	fd_event
	flags	bool32
	padding	array[const[0, int32], 3]
}

kvm_msr_filter_range_flags = KVM_MSR_FILTER_READ, KVM_MSR_FILTER_WRITE

kvm_msr_filter_range {
	flags	flags[kvm_msr_filter_range_flags, int32]
	nmsrs	bitsize[bitmap, int32]
	base	int32
	bitmap	ptr[in, array[int8]]
}

define KVM_MSR_FILTER_DEFAULT_ALLOW	(0 << 0)
define KVM_MSR_FILTER_DEFAULT_DENY	(1 << 0)
kvm_msr_filter_flags = KVM_MSR_FILTER_DEFAULT_ALLOW, KVM_MSR_FILTER_DEFAULT_DENY

kvm_msr_filter {
	flags	flags[kvm_msr_filter_flags, int32]
	ranges	array[kvm_msr_filter_range, KVM_MSR_FILTER_MAX_RANGES]
}

kvm_fpu {
	fpr		array[const[0, int64], 16]
	fcw		int16
	fsw		int16
	ftws		int8
	pad1		const[0, int8]
	last_opcode	int16
	last_ip		flags[kvm_guest_addrs, int64]
	last_dp		flags[kvm_guest_addrs, int64]
	xmm		array[const[0, int64], 32]
	mxcsr		int32
	pad2		const[0, int32]
}

kvm_pit_state2 {
	chans	array[kvm_pit_channel_state, 3]
	flags	int32
	pad	array[const[0, int32], 9]
}

kvm_pit_channel_state {
	count	int32
	lcount	int16
	latched	int8
	lstatus	int8
	status	int8
	rstate	int8
	wstate	int8
	wlatch	int8
	rw	int8
	mode	int8
	bcd	int8
	gate	int8
	ltime	int64
}

kvm_pit_config {
	flags	int32
	pad	array[const[0, int32], 15]
}

kvm_lapic_state {
	regs	array[int8, KVM_APIC_REG_SIZE]
}

kvm_msr_list {
	n	len[indices, int32]
	indices	array[const[0, int32]]
}

kvm_msrs {
	nmsrs	len[entries, int32]
	pad	const[0, int32]
	entries	array[kvm_msr_entry]
} [packed]

kvm_msr_entry {
	index	flags[msr_index, int32]
	reserv	const[0, int32]
	data	int64
}

msr_index = 0x0, 0x1, 0x10, 0x11, 0x12, 0x13, 0x17, 0x1b, 0x20, 0x21, 0x28, 0x29, 0x2a, 0x2c, 0x33, 0x34, 0x3a, 0x3b, 0x40, 0x60, 0x79, 0x88, 0x89, 0x8a, 0x8b, 0x9b, 0x9e, 0xc1, 0xc2, 0xcd, 0xce, 0xe2, 0xe7, 0xe8, 0xfe, 0x116, 0x118, 0x119, 0x11a, 0x11b, 0x11e, 0x174, 0x175, 0x176, 0x179, 0x17a, 0x17b, 0x180, 0x181, 0x182, 0x183, 0x184, 0x185, 0x186, 0x187, 0x188, 0x189, 0x18a, 0x198, 0x199, 0x19a, 0x19b, 0x19c, 0x19d, 0x1a0, 0x1a2, 0x1a6, 0x1a7, 0x1aa, 0x1ad, 0x1ae, 0x1af, 0x1b0, 0x1b1, 0x1b2, 0x1c8, 0x1c9, 0x1d9, 0x1db, 0x1dc, 0x1dd, 0x1de, 0x1e0, 0x1fc, 0x200, 0x201, 0x202, 0x203, 0x204, 0x205, 0x206, 0x207, 0x208, 0x209, 0x20a, 0x20b, 0x20c, 0x20d, 0x20e, 0x20f, 0x210, 0x211, 0x212, 0x213, 0x214, 0x215, 0x216, 0x217, 0x218, 0x219, 0x21a, 0x21b, 0x21c, 0x21d, 0x21e, 0x21f, 0x220, 0x221, 0x222, 0x223, 0x224, 0x225, 0x226, 0x227, 0x228, 0x229, 0x22a, 0x22b, 0x22c, 0x22d, 0x22e, 0x22f, 0x230, 0x231, 0x232, 0x233, 0x234, 0x235, 0x236, 0x237, 0x238, 0x239, 0x23a, 0x23b, 0x23c, 0x23d, 0x23e, 0x23f, 0x240, 0x241, 0x242, 0x243, 0x244, 0x245, 0x246, 0x247, 0x248, 0x249, 0x24a, 0x24b, 0x24c, 0x24d, 0x24e, 0x24f, 0x250, 0x251, 0x252, 0x253, 0x254, 0x255, 0x256, 0x257, 0x258, 0x259, 0x25a, 0x25b, 0x25c, 0x25d, 0x25e, 0x25f, 0x260, 0x261, 0x262, 0x263, 0x264, 0x265, 0x266, 0x267, 0x268, 0x269, 0x26a, 0x26b, 0x26c, 0x26d, 0x26e, 0x26f, 0x270, 0x271, 0x272, 0x273, 0x274, 0x275, 0x276, 0x277, 0x278, 0x279, 0x27a, 0x27b, 0x27c, 0x27d, 0x27e, 0x27f, 0x280, 0x281, 0x282, 0x283, 0x284, 0x285, 0x286, 0x287, 0x288, 0x289, 0x28a, 0x28b, 0x28c, 0x28d, 0x28e, 0x28f, 0x290, 0x291, 0x292, 0x293, 0x294, 0x295, 0x296, 0x297, 0x298, 0x299, 0x29a, 0x29b, 0x29c, 0x29d, 0x29e, 0x29f, 0x2a0, 0x2a1, 0x2a2, 0x2a3, 0x2a4, 0x2a5, 0x2a6, 0x2a7, 0x2a8, 0x2a9, 0x2aa, 0x2ab, 0x2ac, 0x2ad, 0x2ae, 0x2af, 0x2b0, 0x2b1, 0x2b2, 0x2b3, 0x2b4, 0x2b5, 0x2b6, 0x2b7, 0x2b8, 0x2b9, 0x2ba, 0x2bb, 0x2bc, 0x2bd, 0x2be, 0x2bf, 0x2c0, 0x2c1, 0x2c2, 0x2c3, 0x2c4, 0x2c5, 0x2c6, 0x2c7, 0x2c8, 0x2c9, 0x2ca, 0x2cb, 0x2cc, 0x2cd, 0x2ce, 0x2cf, 0x2d0, 0x2d1, 0x2d2, 0x2d3, 0x2d4, 0x2d5, 0x2d6, 0x2d7, 0x2d8, 0x2d9, 0x2da, 0x2db, 0x2dc, 0x2dd, 0x2de, 0x2df, 0x2e0, 0x2e1, 0x2e2, 0x2e3, 0x2e4, 0x2e5, 0x2e6, 0x2e7, 0x2e8, 0x2e9, 0x2ea, 0x2eb, 0x2ec, 0x2ed, 0x2ee, 0x2ef, 0x2f0, 0x2f1, 0x2f2, 0x2f3, 0x2f4, 0x2f5, 0x2f6, 0x2f7, 0x2f8, 0x2f9, 0x2fa, 0x2fb, 0x2fc, 0x2fd, 0x2fe, 0x2ff, 0x300, 0x301, 0x302, 0x303, 0x304, 0x305, 0x306, 0x307, 0x308, 0x309, 0x30a, 0x30b, 0x30c, 0x30d, 0x30e, 0x30f, 0x310, 0x311, 0x312, 0x313, 0x314, 0x315, 0x316, 0x317, 0x318, 0x319, 0x31a, 0x31b, 0x31c, 0x31d, 0x31e, 0x31f, 0x320, 0x321, 0x322, 0x323, 0x324, 0x325, 0x326, 0x327, 0x328, 0x329, 0x32a, 0x32b, 0x32c, 0x32d, 0x32e, 0x32f, 0x330, 0x331, 0x332, 0x333, 0x334, 0x335, 0x336, 0x337, 0x338, 0x339, 0x33a, 0x33b, 0x33c, 0x33d, 0x33e, 0x33f, 0x340, 0x341, 0x342, 0x343, 0x344, 0x345, 0x346, 0x347, 0x348, 0x349, 0x34a, 0x34b, 0x34c, 0x34d, 0x34e, 0x34f, 0x350, 0x351, 0x352, 0x353, 0x354, 0x355, 0x356, 0x357, 0x358, 0x359, 0x35a, 0x35b, 0x35c, 0x35d, 0x35e, 0x35f, 0x360, 0x361, 0x362, 0x363, 0x364, 0x365, 0x366, 0x367, 0x368, 0x369, 0x36a, 0x36b, 0x36c, 0x36d, 0x36e, 0x36f, 0x370, 0x371, 0x372, 0x373, 0x374, 0x375, 0x376, 0x377, 0x378, 0x379, 0x37a, 0x37b, 0x37c, 0x37d, 0x37e, 0x37f, 0x380, 0x381, 0x382, 0x383, 0x384, 0x385, 0x386, 0x387, 0x388, 0x389, 0x38a, 0x38b, 0x38c, 0x38d, 0x38e, 0x38f, 0x390, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39a, 0x39b, 0x39c, 0x39d, 0x39e, 0x39f, 0x3a0, 0x3a1, 0x3a2, 0x3a3, 0x3a4, 0x3a5, 0x3a6, 0x3a7, 0x3a8, 0x3a9, 0x3aa, 0x3ab, 0x3ac, 0x3ad, 0x3ae, 0x3af, 0x3b0, 0x3b1, 0x3b2, 0x3b3, 0x3b4, 0x3b5, 0x3b6, 0x3b7, 0x3b8, 0x3b9, 0x3ba, 0x3bb, 0x3bc, 0x3bd, 0x3be, 0x3bf, 0x3c2, 0x3c3, 0x3c4, 0x3c5, 0x3f1, 0x3f2, 0x3f6, 0x3f7, 0x3f8, 0x3f9, 0x3fa, 0x3fc, 0x3fd, 0x3fe, 0x3ff, 0x400, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407, 0x408, 0x409, 0x40a, 0x40b, 0x40c, 0x40d, 0x40e, 0x40f, 0x410, 0x411, 0x412, 0x413, 0x480, 0x481, 0x482, 0x483, 0x484, 0x485, 0x486, 0x487, 0x488, 0x489, 0x48a, 0x48b, 0x48c, 0x48d, 0x48e, 0x48f, 0x490, 0x491, 0x4c1, 0x4d0, 0x560, 0x561, 0x570, 0x571, 0x572, 0x580, 0x581, 0x582, 0x583, 0x584, 0x585, 0x586, 0x587, 0x600, 0x606, 0x60a, 0x60b, 0x60c, 0x60d, 0x610, 0x611, 0x613, 0x614, 0x618, 0x619, 0x61b, 0x61c, 0x630, 0x631, 0x632, 0x633, 0x634, 0x635, 0x638, 0x639, 0x63a, 0x63b, 0x640, 0x641, 0x642, 0x648, 0x649, 0x64a, 0x64b, 0x64c, 0x64d, 0x64e, 0x64f, 0x658, 0x659, 0x65a, 0x65b, 0x660, 0x668, 0x669, 0x680, 0x690, 0x6b0, 0x6b1, 0x6c0, 0x6e0, 0x770, 0x771, 0x772, 0x773, 0x774, 0x777, 0x800, 0x801, 0x802, 0x803, 0x804, 0x805, 0x806, 0x807, 0x808, 0x809, 0x80a, 0x80b, 0x80c, 0x80d, 0x80e, 0x80f, 0x810, 0x811, 0x812, 0x813, 0x814, 0x815, 0x816, 0x817, 0x818, 0x819, 0x81a, 0x81b, 0x81c, 0x81d, 0x81e, 0x81f, 0x820, 0x821, 0x822, 0x823, 0x824, 0x825, 0x826, 0x827, 0x828, 0x829, 0x82a, 0x82b, 0x82c, 0x82d, 0x82e, 0x82f, 0x830, 0x831, 0x832, 0x833, 0x834, 0x835, 0x836, 0x837, 0x838, 0x839, 0x83a, 0x83b, 0x83c, 0x83d, 0x83e, 0x83f, 0x840, 0x841, 0x842, 0x843, 0x844, 0x845, 0x846, 0x847, 0x848, 0x849, 0x84a, 0x84b, 0x84c, 0x84d, 0x84e, 0x84f, 0x850, 0x851, 0x852, 0x853, 0x854, 0x855, 0x856, 0x857, 0x858, 0x859, 0x85a, 0x85b, 0x85c, 0x85d, 0x85e, 0x85f, 0x860, 0x861, 0x862, 0x863, 0x864, 0x865, 0x866, 0x867, 0x868, 0x869, 0x86a, 0x86b, 0x86c, 0x86d, 0x86e, 0x86f, 0x870, 0x871, 0x872, 0x873, 0x874, 0x875, 0x876, 0x877, 0x878, 0x879, 0x87a, 0x87b, 0x87c, 0x87d, 0x87e, 0x87f, 0x880, 0x881, 0x882, 0x883, 0x884, 0x885, 0x886, 0x887, 0x888, 0x889, 0x88a, 0x88b, 0x88c, 0x88d, 0x88e, 0x88f, 0x890, 0x891, 0x892, 0x893, 0x894, 0x895, 0x896, 0x897, 0x898, 0x899, 0x89a, 0x89b, 0x89c, 0x89d, 0x89e, 0x89f, 0x8a0, 0x8a1, 0x8a2, 0x8a3, 0x8a4, 0x8a5, 0x8a6, 0x8a7, 0x8a8, 0x8a9, 0x8aa, 0x8ab, 0x8ac, 0x8ad, 0x8ae, 0x8af, 0x8b0, 0x8b1, 0x8b2, 0x8b3, 0x8b4, 0x8b5, 0x8b6, 0x8b7, 0x8b8, 0x8b9, 0x8ba, 0x8bb, 0x8bc, 0x8bd, 0x8be, 0x8bf, 0x8c0, 0x8c1, 0x8c2, 0x8c3, 0x8c4, 0x8c5, 0x8c6, 0x8c7, 0x8c8, 0x8c9, 0x8ca, 0x8cb, 0x8cc, 0x8cd, 0x8ce, 0x8cf, 0x8d0, 0x8d1, 0x8d2, 0x8d3, 0x8d4, 0x8d5, 0x8d6, 0x8d7, 0x8d8, 0x8d9, 0x8da, 0x8db, 0x8dc, 0x8dd, 0x8de, 0x8df, 0x8e0, 0x8e1, 0x8e2, 0x8e3, 0x8e4, 0x8e5, 0x8e6, 0x8e7, 0x8e8, 0x8e9, 0x8ea, 0x8eb, 0x8ec, 0x8ed, 0x8ee, 0x8ef, 0x8f0, 0x8f1, 0x8f2, 0x8f3, 0x8f4, 0x8f5, 0x8f6, 0x8f7, 0x8f8, 0x8f9, 0x8fa, 0x8fb, 0x8fc, 0x8fd, 0x8fe, 0x8ff, 0x900, 0x901, 0x902, 0x903, 0x904, 0x905, 0x906, 0x907, 0x908, 0x909, 0x90a, 0x90b, 0x90c, 0x90d, 0x90e, 0x90f, 0x910, 0x911, 0x912, 0x913, 0x914, 0x915, 0x916, 0x917, 0x918, 0x919, 0x91a, 0x91b, 0x91c, 0x91d, 0x91e, 0x91f, 0x920, 0x921, 0x922, 0x923, 0x924, 0x925, 0x926, 0x927, 0x928, 0x929, 0x92a, 0x92b, 0x92c, 0x92d, 0x92e, 0x92f, 0x930, 0x931, 0x932, 0x933, 0x934, 0x935, 0x936, 0x937, 0x938, 0x939, 0x93a, 0x93b, 0x93c, 0x93d, 0x93e, 0x93f, 0x940, 0x941, 0x942, 0x943, 0x944, 0x945, 0x946, 0x947, 0x948, 0x949, 0x94a, 0x94b, 0x94c, 0x94d, 0x94e, 0x94f, 0x950, 0x951, 0x952, 0x953, 0x954, 0x955, 0x956, 0x957, 0x958, 0x959, 0x95a, 0x95b, 0x95c, 0x95d, 0x95e, 0x95f, 0x960, 0x961, 0x962, 0x963, 0x964, 0x965, 0x966, 0x967, 0x968, 0x969, 0x96a, 0x96b, 0x96c, 0x96d, 0x96e, 0x96f, 0x970, 0x971, 0x972, 0x973, 0x974, 0x975, 0x976, 0x977, 0x978, 0x979, 0x97a, 0x97b, 0x97c, 0x97d, 0x97e, 0x97f, 0x980, 0x981, 0x982, 0x983, 0x984, 0x985, 0x986, 0x987, 0x988, 0x989, 0x98a, 0x98b, 0x98c, 0x98d, 0x98e, 0x98f, 0x990, 0x991, 0x992, 0x993, 0x994, 0x995, 0x996, 0x997, 0x998, 0x999, 0x99a, 0x99b, 0x99c, 0x99d, 0x99e, 0x99f, 0x9a0, 0x9a1, 0x9a2, 0x9a3, 0x9a4, 0x9a5, 0x9a6, 0x9a7, 0x9a8, 0x9a9, 0x9aa, 0x9ab, 0x9ac, 0x9ad, 0x9ae, 0x9af, 0x9b0, 0x9b1, 0x9b2, 0x9b3, 0x9b4, 0x9b5, 0x9b6, 0x9b7, 0x9b8, 0x9b9, 0x9ba, 0x9bb, 0x9bc, 0x9bd, 0x9be, 0x9bf, 0x9c0, 0x9c1, 0x9c2, 0x9c3, 0x9c4, 0x9c5, 0x9c6, 0x9c7, 0x9c8, 0x9c9, 0x9ca, 0x9cb, 0x9cc, 0x9cd, 0x9ce, 0x9cf, 0x9d0, 0x9d1, 0x9d2, 0x9d3, 0x9d4, 0x9d5, 0x9d6, 0x9d7, 0x9d8, 0x9d9, 0x9da, 0x9db, 0x9dc, 0x9dd, 0x9de, 0x9df, 0x9e0, 0x9e1, 0x9e2, 0x9e3, 0x9e4, 0x9e5, 0x9e6, 0x9e7, 0x9e8, 0x9e9, 0x9ea, 0x9eb, 0x9ec, 0x9ed, 0x9ee, 0x9ef, 0x9f0, 0x9f1, 0x9f2, 0x9f3, 0x9f4, 0x9f5, 0x9f6, 0x9f7, 0x9f8, 0x9f9, 0x9fa, 0x9fb, 0x9fc, 0x9fd, 0x9fe, 0x9ff, 0xa00, 0xa01, 0xa02, 0xa03, 0xa04, 0xa05, 0xa06, 0xa07, 0xa08, 0xa09, 0xa0a, 0xa0b, 0xa0c, 0xa0d, 0xa0e, 0xa0f, 0xa10, 0xa11, 0xa12, 0xa13, 0xa14, 0xa15, 0xa16, 0xa17, 0xa18, 0xa19, 0xa1a, 0xa1b, 0xa1c, 0xa1d, 0xa1e, 0xa1f, 0xa20, 0xa21, 0xa22, 0xa23, 0xa24, 0xa25, 0xa26, 0xa27, 0xa28, 0xa29, 0xa2a, 0xa2b, 0xa2c, 0xa2d, 0xa2e, 0xa2f, 0xa30, 0xa31, 0xa32, 0xa33, 0xa34, 0xa35, 0xa36, 0xa37, 0xa38, 0xa39, 0xa3a, 0xa3b, 0xa3c, 0xa3d, 0xa3e, 0xa3f, 0xa40, 0xa41, 0xa42, 0xa43, 0xa44, 0xa45, 0xa46, 0xa47, 0xa48, 0xa49, 0xa4a, 0xa4b, 0xa4c, 0xa4d, 0xa4e, 0xa4f, 0xa50, 0xa51, 0xa52, 0xa53, 0xa54, 0xa55, 0xa56, 0xa57, 0xa58, 0xa59, 0xa5a, 0xa5b, 0xa5c, 0xa5d, 0xa5e, 0xa5f, 0xa60, 0xa61, 0xa62, 0xa63, 0xa64, 0xa65, 0xa66, 0xa67, 0xa68, 0xa69, 0xa6a, 0xa6b, 0xa6c, 0xa6d, 0xa6e, 0xa6f, 0xa70, 0xa71, 0xa72, 0xa73, 0xa74, 0xa75, 0xa76, 0xa77, 0xa78, 0xa79, 0xa7a, 0xa7b, 0xa7c, 0xa7d, 0xa7e, 0xa7f, 0xa80, 0xa81, 0xa82, 0xa83, 0xa84, 0xa85, 0xa86, 0xa87, 0xa88, 0xa89, 0xa8a, 0xa8b, 0xa8c, 0xa8d, 0xa8e, 0xa8f, 0xa90, 0xa91, 0xa92, 0xa93, 0xa94, 0xa95, 0xa96, 0xa97, 0xa98, 0xa99, 0xa9a, 0xa9b, 0xa9c, 0xa9d, 0xa9e, 0xa9f, 0xaa0, 0xaa1, 0xaa2, 0xaa3, 0xaa4, 0xaa5, 0xaa6, 0xaa7, 0xaa8, 0xaa9, 0xaaa, 0xaab, 0xaac, 0xaad, 0xaae, 0xaaf, 0xab0, 0xab1, 0xab2, 0xab3, 0xab4, 0xab5, 0xab6, 0xab7, 0xab8, 0xab9, 0xaba, 0xabb, 0xabc, 0xabd, 0xabe, 0xabf, 0xac0, 0xac1, 0xac2, 0xac3, 0xac4, 0xac5, 0xac6, 0xac7, 0xac8, 0xac9, 0xaca, 0xacb, 0xacc, 0xacd, 0xace, 0xacf, 0xad0, 0xad1, 0xad2, 0xad3, 0xad4, 0xad5, 0xad6, 0xad7, 0xad8, 0xad9, 0xada, 0xadb, 0xadc, 0xadd, 0xade, 0xadf, 0xae0, 0xae1, 0xae2, 0xae3, 0xae4, 0xae5, 0xae6, 0xae7, 0xae8, 0xae9, 0xaea, 0xaeb, 0xaec, 0xaed, 0xaee, 0xaef, 0xaf0, 0xaf1, 0xaf2, 0xaf3, 0xaf4, 0xaf5, 0xaf6, 0xaf7, 0xaf8, 0xaf9, 0xafa, 0xafb, 0xafc, 0xafd, 0xafe, 0xaff, 0xb00, 0xb01, 0xb02, 0xb03, 0xb04, 0xb05, 0xb06, 0xb07, 0xb08, 0xb09, 0xb0a, 0xb0b, 0xb0c, 0xb0d, 0xb0e, 0xb0f, 0xb10, 0xb11, 0xb12, 0xb13, 0xb14, 0xb15, 0xb16, 0xb17, 0xb18, 0xb19, 0xb1a, 0xb1b, 0xb1c, 0xb1d, 0xb1e, 0xb1f, 0xb20, 0xb21, 0xb22, 0xb23, 0xb24, 0xb25, 0xb26, 0xb27, 0xb28, 0xb29, 0xb2a, 0xb2b, 0xb2c, 0xb2d, 0xb2e, 0xb2f, 0xb30, 0xb31, 0xb32, 0xb33, 0xb34, 0xb35, 0xb36, 0xb37, 0xb38, 0xb39, 0xb3a, 0xb3b, 0xb3c, 0xb3d, 0xb3e, 0xb3f, 0xb40, 0xb41, 0xb42, 0xb43, 0xb44, 0xb45, 0xb46, 0xb47, 0xb48, 0xb49, 0xb4a, 0xb4b, 0xb4c, 0xb4d, 0xb4e, 0xb4f, 0xb50, 0xb51, 0xb52, 0xb53, 0xb54, 0xb55, 0xb56, 0xb57, 0xb58, 0xb59, 0xb5a, 0xb5b, 0xb5c, 0xb5d, 0xb5e, 0xb5f, 0xb60, 0xb61, 0xb62, 0xb63, 0xb64, 0xb65, 0xb66, 0xb67, 0xb68, 0xb69, 0xb6a, 0xb6b, 0xb6c, 0xb6d, 0xb6e, 0xb6f, 0xb70, 0xb71, 0xb72, 0xb73, 0xb74, 0xb75, 0xb76, 0xb77, 0xb78, 0xb79, 0xb7a, 0xb7b, 0xb7c, 0xb7d, 0xb7e, 0xb7f, 0xb80, 0xb81, 0xb82, 0xb83, 0xb84, 0xb85, 0xb86, 0xb87, 0xb88, 0xb89, 0xb8a, 0xb8b, 0xb8c, 0xb8d, 0xb8e, 0xb8f, 0xb90, 0xb91, 0xb92, 0xb93, 0xb94, 0xb95, 0xb96, 0xb97, 0xb98, 0xb99, 0xb9a, 0xb9b, 0xb9c, 0xb9d, 0xb9e, 0xb9f, 0xba0, 0xba1, 0xba2, 0xba3, 0xba4, 0xba5, 0xba6, 0xba7, 0xba8, 0xba9, 0xbaa, 0xbab, 0xbac, 0xbad, 0xbae, 0xbaf, 0xbb0, 0xbb1, 0xbb2, 0xbb3, 0xbb4, 0xbb5, 0xbb6, 0xbb7, 0xbb8, 0xbb9, 0xbba, 0xbbb, 0xbbc, 0xbbd, 0xbbe, 0xbbf, 0xbc0, 0xbc1, 0xbc2, 0xbc3, 0xbc4, 0xbc5, 0xbc6, 0xbc7, 0xbc8, 0xbc9, 0xbca, 0xbcb, 0xbcc, 0xbcd, 0xbce, 0xbcf, 0xbd0, 0xbd1, 0xbd2, 0xbd3, 0xbd4, 0xbd5, 0xbd6, 0xbd7, 0xbd8, 0xbd9, 0xbda, 0xbdb, 0xbdc, 0xbdd, 0xbde, 0xbdf, 0xbe0, 0xbe1, 0xbe2, 0xbe3, 0xbe4, 0xbe5, 0xbe6, 0xbe7, 0xbe8, 0xbe9, 0xbea, 0xbeb, 0xbec, 0xbed, 0xbee, 0xbef, 0xbf0, 0xbf1, 0xbf2, 0xbf3, 0xbf4, 0xbf5, 0xbf6, 0xbf7, 0xbf8, 0xbf9, 0xbfa, 0xbfb, 0xbfc, 0xbfd, 0xbfe, 0xbff, 0xd90, 0xda0, 0xdc0, 0xdc1, 0xdc2, 0xdc3, 0xdc4, 0xdc5, 0xdc6, 0xdc7, 0x40000000, 0x40000001, 0x40000002, 0x40000003, 0x40000010, 0x40000020, 0x40000022, 0x40000023, 0x40000070, 0x40000071, 0x40000072, 0x40000073, 0x40000080, 0x40000081, 0x40000082, 0x40000083, 0x40000084, 0x40000090, 0x40000091, 0x40000092, 0x40000093, 0x40000094, 0x40000095, 0x40000096, 0x40000097, 0x40000098, 0x40000099, 0x4000009a, 0x4000009b, 0x4000009c, 0x4000009d, 0x4000009e, 0x4000009f, 0x400000b0, 0x400000b1, 0x400000b2, 0x400000b3, 0x400000b4, 0x400000b5, 0x400000b6, 0x400000b7, 0x40000100, 0x40000101, 0x40000102, 0x40000103, 0x40000104, 0x40000105, 0x4b564d00, 0x4b564d01, 0x4b564d02, 0x4b564d03, 0x4b564d04, 0xc0000080, 0xc0000081, 0xc0000082, 0xc0000083, 0xc0000084, 0xc0000100, 0xc0000101, 0xc0000102, 0xc0000103, 0xc0000104, 0xc001001f, 0xc0010020, 0xc0010044, 0xc0010062, 0xc0010063, 0xc0010064, 0xc0010114, 0xc0010115, 0xc0010117, 0xc0010140, 0xc0010141, 0xc0011020, 0xc0011022, 0xc001102a, 0xc0011030, 0xc0011031, 0xc0011032, 0xc0011033, 0xc0011034, 0xc0011035, 0xc0011036, 0xc0011037, 0xc0011038, 0xc0011039, 0xc001103a, 0xc001103b, 0xc001103d

kvm_irqchip {
	chipid	flags[kvm_chip_id, int32]
	pad	const[0, int32]
	chip	kvm_irq_chip
}

kvm_irq_chip [
	pic	kvm_pic_state
	ioapic	kvm_ioapic_state
] [size[512]]

kvm_pic_state {
	lastirr	int8
	irr	int8
	imr	int8
	isr	int8
	padd	int8
	irqbase	int8
	readreg	int8
	poll	int8
	special	int8
	initst	int8
	autoeoi	int8
	rotate	int8
	nestedm	int8
	init4	int8
	elcr	int8
	elcrmas	int8
}

kvm_ioapic_state {
	base	flags[kvm_guest_addrs, int64]
	ioregs	int32
	id	int32
	irr	int32
	pad	const[0, int32]
	redir	array[kvm_ioapic_redir, 24]
}

kvm_ioapic_redir {
	vector	int8
	f0	int8
	f1	int8
	reserv	array[const[0, int8], 4]
	destid	int8
}

kvm_debugregs {
	db	array[flags[kvm_guest_addrs, int64], 4]
	dr6	int64
	dr7	flags[kvm_x86_dr7, int64]
	flags	int64
	reserv	array[const[0, int64], 9]
}

kvm_memory_attribute_flags = KVM_MEMORY_ATTRIBUTE_PRIVATE

kvm_memory_attributes {
	address		flags[kvm_guest_addrs, int64]
	size		flags[kvm_guest_addr_size, int64]
	attributes	flags[kvm_memory_attribute_flags, int64]
	flags		const[0, int64]
}

kvm_sregs2_flags = KVM_SREGS2_FLAGS_PDPTRS_VALID

kvm_sregs2 {
	cs	kvm_segment
	ds	kvm_segment
	es	kvm_segment
	fs	kvm_segment
	gs	kvm_segment
	ss	kvm_segment
	tr	kvm_segment
	ldt	kvm_segment
	gdt	kvm_dtable
	idt	kvm_dtable
	cr0	flags[kvm_x86_cr0, int64]
	cr2	const[0, int64]
# TODO: this should point to page table
	cr3	flags[kvm_guest_addrs, int64]
	cr4	flags[kvm_x86_cr4, int64]
	cr8	int64[0:15]
	efer	flags[kvm_x86_efer, int64]
	apic	flags[kvm_guest_addrs, int64]
	flags	flags[kvm_sregs2_flags, int64]
	pdptrs	array[int64, 4]
}