1#![allow(clippy::missing_safety_doc)]
4#![allow(clippy::ptr_offset_with_cast)] #![allow(clippy::undocumented_unsafe_blocks)]
6#![allow(clippy::upper_case_acronyms)]
7#![allow(non_upper_case_globals)]
8#![allow(non_camel_case_types)]
9#![allow(non_snake_case)]
10#![allow(dead_code)]
11
12use zerocopy::FromBytes;
14use zerocopy::Immutable;
15use zerocopy::IntoBytes;
16use zerocopy::KnownLayout;
17
18pub const KVM_CAP_USER_CONFIGURE_NONCOHERENT_DMA_CROS_OLD: u32 = 236;
23pub const KVM_CAP_USER_CONFIGURE_NONCOHERENT_DMA_CROS_612: u32 = 239;
24pub const KVM_MEM_NON_COHERENT_DMA: u32 = 8;
25
26pub const KVM_CAP_ARM_PROTECTED_VM: u32 = 0xffbadab1;
28pub const KVM_CAP_ARM_PROTECTED_VM_FLAGS_SET_FW_IPA: u32 = 0;
29pub const KVM_CAP_ARM_PROTECTED_VM_FLAGS_INFO: u32 = 1;
30pub const KVM_CAP_ARM_PROTECTED_VM_FLAGS_SET_FFA: u32 = 2;
31pub const KVM_VM_TYPE_ARM_PROTECTED: u32 = 0x80000000;
32pub const KVM_X86_PKVM_PROTECTED_VM: u32 = 28;
33pub const KVM_CAP_X86_PROTECTED_VM: u32 = 0xffbadab2;
34pub const KVM_CAP_X86_PROTECTED_VM_FLAGS_SET_FW_GPA: u32 = 0;
35pub const KVM_CAP_X86_PROTECTED_VM_FLAGS_INFO: u32 = 1;
36pub const KVM_DEV_VFIO_PVIOMMU: u32 = 5;
37pub const KVM_DEV_VFIO_PVIOMMU_ATTACH: u32 = 1;
38#[repr(C)]
39#[derive(Debug, Default, Copy, Clone)]
40pub struct kvm_vfio_iommu_info {
41 pub size: u32,
42 pub device_fd: i32,
43 pub nr_sids: u32,
44 pub __reserved: u32,
45}
46pub const KVM_DEV_VFIO_PVIOMMU_GET_INFO: u32 = 2;
47#[repr(C)]
48#[derive(Debug, Default, Copy, Clone)]
49pub struct kvm_vfio_iommu_config {
50 pub size: u32,
51 pub device_fd: i32,
52 pub sid_idx: u32,
53 pub vsid: u32,
54 pub __reserved: u32,
55}
56
57#[repr(C)]
58#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
59pub struct __BindgenBitfieldUnit<Storage> {
60 storage: Storage,
61}
62impl<Storage> __BindgenBitfieldUnit<Storage> {
63 #[inline]
64 pub const fn new(storage: Storage) -> Self {
65 Self { storage }
66 }
67}
68impl<Storage> __BindgenBitfieldUnit<Storage>
69where
70 Storage: AsRef<[u8]> + AsMut<[u8]>,
71{
72 #[inline]
73 fn extract_bit(byte: u8, index: usize) -> bool {
74 let bit_index = if cfg!(target_endian = "big") {
75 7 - (index % 8)
76 } else {
77 index % 8
78 };
79 let mask = 1 << bit_index;
80 byte & mask == mask
81 }
82 #[inline]
83 pub fn get_bit(&self, index: usize) -> bool {
84 debug_assert!(index / 8 < self.storage.as_ref().len());
85 let byte_index = index / 8;
86 let byte = self.storage.as_ref()[byte_index];
87 Self::extract_bit(byte, index)
88 }
89 #[inline]
90 pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
91 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
92 let byte_index = index / 8;
93 let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize);
94 Self::extract_bit(byte, index)
95 }
96 #[inline]
97 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
98 let bit_index = if cfg!(target_endian = "big") {
99 7 - (index % 8)
100 } else {
101 index % 8
102 };
103 let mask = 1 << bit_index;
104 if val {
105 byte | mask
106 } else {
107 byte & !mask
108 }
109 }
110 #[inline]
111 pub fn set_bit(&mut self, index: usize, val: bool) {
112 debug_assert!(index / 8 < self.storage.as_ref().len());
113 let byte_index = index / 8;
114 let byte = &mut self.storage.as_mut()[byte_index];
115 *byte = Self::change_bit(*byte, index, val);
116 }
117 #[inline]
118 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
119 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
120 let byte_index = index / 8;
121 let byte =
122 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize);
123 *byte = Self::change_bit(*byte, index, val);
124 }
125 #[inline]
126 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
127 debug_assert!(bit_width <= 64);
128 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
129 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
130 let mut val = 0;
131 for i in 0..(bit_width as usize) {
132 if self.get_bit(i + bit_offset) {
133 let index = if cfg!(target_endian = "big") {
134 bit_width as usize - 1 - i
135 } else {
136 i
137 };
138 val |= 1 << index;
139 }
140 }
141 val
142 }
143 #[inline]
144 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
145 debug_assert!(bit_width <= 64);
146 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
147 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
148 let mut val = 0;
149 for i in 0..(bit_width as usize) {
150 if Self::raw_get_bit(this, i + bit_offset) {
151 let index = if cfg!(target_endian = "big") {
152 bit_width as usize - 1 - i
153 } else {
154 i
155 };
156 val |= 1 << index;
157 }
158 }
159 val
160 }
161 #[inline]
162 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
163 debug_assert!(bit_width <= 64);
164 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
165 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
166 for i in 0..(bit_width as usize) {
167 let mask = 1 << i;
168 let val_bit_is_set = val & mask == mask;
169 let index = if cfg!(target_endian = "big") {
170 bit_width as usize - 1 - i
171 } else {
172 i
173 };
174 self.set_bit(index + bit_offset, val_bit_is_set);
175 }
176 }
177 #[inline]
178 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
179 debug_assert!(bit_width <= 64);
180 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
181 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
182 for i in 0..(bit_width as usize) {
183 let mask = 1 << i;
184 let val_bit_is_set = val & mask == mask;
185 let index = if cfg!(target_endian = "big") {
186 bit_width as usize - 1 - i
187 } else {
188 i
189 };
190 Self::raw_set_bit(this, index + bit_offset, val_bit_is_set);
191 }
192 }
193}
194#[repr(C)]
195pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
196impl<T> __BindgenUnionField<T> {
197 #[inline]
198 pub const fn new() -> Self {
199 __BindgenUnionField(::std::marker::PhantomData)
200 }
201 #[inline]
202 pub unsafe fn as_ref(&self) -> &T {
203 ::std::mem::transmute(self)
204 }
205 #[inline]
206 pub unsafe fn as_mut(&mut self) -> &mut T {
207 ::std::mem::transmute(self)
208 }
209}
210impl<T> ::std::default::Default for __BindgenUnionField<T> {
211 #[inline]
212 fn default() -> Self {
213 Self::new()
214 }
215}
216impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
217 #[inline]
218 fn clone(&self) -> Self {
219 *self
220 }
221}
222impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
223impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
224 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
225 fmt.write_str("__BindgenUnionField")
226 }
227}
228impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
229 fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
230}
231impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
232 fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
233 true
234 }
235}
236impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
237pub const KVM_PIO_PAGE_OFFSET: u32 = 1;
238pub const KVM_COALESCED_MMIO_PAGE_OFFSET: u32 = 2;
239pub const KVM_DIRTY_LOG_PAGE_OFFSET: u32 = 64;
240pub const DE_VECTOR: u32 = 0;
241pub const DB_VECTOR: u32 = 1;
242pub const BP_VECTOR: u32 = 3;
243pub const OF_VECTOR: u32 = 4;
244pub const BR_VECTOR: u32 = 5;
245pub const UD_VECTOR: u32 = 6;
246pub const NM_VECTOR: u32 = 7;
247pub const DF_VECTOR: u32 = 8;
248pub const TS_VECTOR: u32 = 10;
249pub const NP_VECTOR: u32 = 11;
250pub const SS_VECTOR: u32 = 12;
251pub const GP_VECTOR: u32 = 13;
252pub const PF_VECTOR: u32 = 14;
253pub const MF_VECTOR: u32 = 16;
254pub const AC_VECTOR: u32 = 17;
255pub const MC_VECTOR: u32 = 18;
256pub const XM_VECTOR: u32 = 19;
257pub const VE_VECTOR: u32 = 20;
258pub const KVM_NR_INTERRUPTS: u32 = 256;
259pub const KVM_IOAPIC_NUM_PINS: u32 = 24;
260pub const KVM_IRQCHIP_PIC_MASTER: u32 = 0;
261pub const KVM_IRQCHIP_PIC_SLAVE: u32 = 1;
262pub const KVM_IRQCHIP_IOAPIC: u32 = 2;
263pub const KVM_NR_IRQCHIPS: u32 = 3;
264pub const KVM_RUN_X86_SMM: u32 = 1;
265pub const KVM_RUN_X86_BUS_LOCK: u32 = 2;
266pub const KVM_RUN_X86_GUEST_MODE: u32 = 4;
267pub const KVM_APIC_REG_SIZE: u32 = 1024;
268pub const KVM_SREGS2_FLAGS_PDPTRS_VALID: u32 = 1;
269pub const KVM_MSR_FILTER_MAX_BITMAP_SIZE: u32 = 1536;
270pub const KVM_MSR_FILTER_READ: u32 = 1;
271pub const KVM_MSR_FILTER_WRITE: u32 = 2;
272pub const KVM_MSR_FILTER_RANGE_VALID_MASK: u32 = 3;
273pub const KVM_MSR_FILTER_MAX_RANGES: u32 = 16;
274pub const KVM_MSR_FILTER_DEFAULT_ALLOW: u32 = 0;
275pub const KVM_MSR_FILTER_DEFAULT_DENY: u32 = 1;
276pub const KVM_MSR_FILTER_VALID_MASK: u32 = 1;
277pub const KVM_CPUID_FLAG_SIGNIFCANT_INDEX: u32 = 1;
278pub const KVM_CPUID_FLAG_STATEFUL_FUNC: u32 = 2;
279pub const KVM_CPUID_FLAG_STATE_READ_NEXT: u32 = 4;
280pub const KVM_GUESTDBG_USE_SW_BP: u32 = 65536;
281pub const KVM_GUESTDBG_USE_HW_BP: u32 = 131072;
282pub const KVM_GUESTDBG_INJECT_DB: u32 = 262144;
283pub const KVM_GUESTDBG_INJECT_BP: u32 = 524288;
284pub const KVM_GUESTDBG_BLOCKIRQ: u32 = 1048576;
285pub const KVM_PIT_FLAGS_HPET_LEGACY: u32 = 1;
286pub const KVM_PIT_FLAGS_SPEAKER_DATA_ON: u32 = 2;
287pub const KVM_VCPUEVENT_VALID_NMI_PENDING: u32 = 1;
288pub const KVM_VCPUEVENT_VALID_SIPI_VECTOR: u32 = 2;
289pub const KVM_VCPUEVENT_VALID_SHADOW: u32 = 4;
290pub const KVM_VCPUEVENT_VALID_SMM: u32 = 8;
291pub const KVM_VCPUEVENT_VALID_PAYLOAD: u32 = 16;
292pub const KVM_VCPUEVENT_VALID_TRIPLE_FAULT: u32 = 32;
293pub const KVM_X86_SHADOW_INT_MOV_SS: u32 = 1;
294pub const KVM_X86_SHADOW_INT_STI: u32 = 2;
295pub const KVM_MAX_XCRS: u32 = 16;
296pub const KVM_SYNC_X86_REGS: u32 = 1;
297pub const KVM_SYNC_X86_SREGS: u32 = 2;
298pub const KVM_SYNC_X86_EVENTS: u32 = 4;
299pub const KVM_SYNC_X86_VALID_FIELDS: u32 = 7;
300pub const KVM_X86_QUIRK_LINT0_REENABLED: u32 = 1;
301pub const KVM_X86_QUIRK_CD_NW_CLEARED: u32 = 2;
302pub const KVM_X86_QUIRK_LAPIC_MMIO_HOLE: u32 = 4;
303pub const KVM_X86_QUIRK_OUT_7E_INC_RIP: u32 = 8;
304pub const KVM_X86_QUIRK_MISC_ENABLE_NO_MWAIT: u32 = 16;
305pub const KVM_X86_QUIRK_FIX_HYPERCALL_INSN: u32 = 32;
306pub const KVM_X86_QUIRK_MWAIT_NEVER_UD_FAULTS: u32 = 64;
307pub const KVM_X86_QUIRK_SLOT_ZAP_ALL: u32 = 128;
308pub const KVM_STATE_NESTED_FORMAT_VMX: u32 = 0;
309pub const KVM_STATE_NESTED_FORMAT_SVM: u32 = 1;
310pub const KVM_STATE_NESTED_GUEST_MODE: u32 = 1;
311pub const KVM_STATE_NESTED_RUN_PENDING: u32 = 2;
312pub const KVM_STATE_NESTED_EVMCS: u32 = 4;
313pub const KVM_STATE_NESTED_MTF_PENDING: u32 = 8;
314pub const KVM_STATE_NESTED_GIF_SET: u32 = 256;
315pub const KVM_STATE_NESTED_SMM_GUEST_MODE: u32 = 1;
316pub const KVM_STATE_NESTED_SMM_VMXON: u32 = 2;
317pub const KVM_STATE_NESTED_VMX_VMCS_SIZE: u32 = 4096;
318pub const KVM_STATE_NESTED_SVM_VMCB_SIZE: u32 = 4096;
319pub const KVM_STATE_VMX_PREEMPTION_TIMER_DEADLINE: u32 = 1;
320pub const KVM_X86_GRP_SYSTEM: u32 = 0;
321pub const KVM_X86_XCOMP_GUEST_SUPP: u32 = 0;
322pub const KVM_X86_GRP_SEV: u32 = 1;
323pub const KVM_X86_SEV_VMSA_FEATURES: u32 = 0;
324pub const KVM_PMU_EVENT_ALLOW: u32 = 0;
325pub const KVM_PMU_EVENT_DENY: u32 = 1;
326pub const KVM_XEN_HVM_CONFIG_HYPERCALL_MSR: u32 = 1;
327pub const KVM_XEN_HVM_CONFIG_INTERCEPT_HCALL: u32 = 2;
328pub const KVM_XEN_HVM_CONFIG_SHARED_INFO: u32 = 4;
329pub const KVM_XEN_HVM_CONFIG_RUNSTATE: u32 = 8;
330pub const KVM_XEN_HVM_CONFIG_EVTCHN_2LEVEL: u32 = 16;
331pub const KVM_XEN_HVM_CONFIG_EVTCHN_SEND: u32 = 32;
332pub const KVM_XEN_HVM_CONFIG_RUNSTATE_UPDATE_FLAG: u32 = 64;
333pub const KVM_XEN_HVM_CONFIG_PVCLOCK_TSC_UNSTABLE: u32 = 128;
334pub const KVM_XEN_HVM_CONFIG_SHARED_INFO_HVA: u32 = 256;
335pub const KVM_XEN_EVTCHN_DEASSIGN: u32 = 1;
336pub const KVM_XEN_EVTCHN_UPDATE: u32 = 2;
337pub const KVM_XEN_EVTCHN_RESET: u32 = 4;
338pub const KVM_XEN_ATTR_TYPE_LONG_MODE: u32 = 0;
339pub const KVM_XEN_ATTR_TYPE_SHARED_INFO: u32 = 1;
340pub const KVM_XEN_ATTR_TYPE_UPCALL_VECTOR: u32 = 2;
341pub const KVM_XEN_ATTR_TYPE_EVTCHN: u32 = 3;
342pub const KVM_XEN_ATTR_TYPE_XEN_VERSION: u32 = 4;
343pub const KVM_XEN_ATTR_TYPE_RUNSTATE_UPDATE_FLAG: u32 = 5;
344pub const KVM_XEN_ATTR_TYPE_SHARED_INFO_HVA: u32 = 6;
345pub const KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO: u32 = 0;
346pub const KVM_XEN_VCPU_ATTR_TYPE_VCPU_TIME_INFO: u32 = 1;
347pub const KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADDR: u32 = 2;
348pub const KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_CURRENT: u32 = 3;
349pub const KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_DATA: u32 = 4;
350pub const KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADJUST: u32 = 5;
351pub const KVM_XEN_VCPU_ATTR_TYPE_VCPU_ID: u32 = 6;
352pub const KVM_XEN_VCPU_ATTR_TYPE_TIMER: u32 = 7;
353pub const KVM_XEN_VCPU_ATTR_TYPE_UPCALL_VECTOR: u32 = 8;
354pub const KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO_HVA: u32 = 9;
355pub const KVM_SEV_SNP_PAGE_TYPE_NORMAL: u32 = 1;
356pub const KVM_SEV_SNP_PAGE_TYPE_ZERO: u32 = 3;
357pub const KVM_SEV_SNP_PAGE_TYPE_UNMEASURED: u32 = 4;
358pub const KVM_SEV_SNP_PAGE_TYPE_SECRETS: u32 = 5;
359pub const KVM_SEV_SNP_PAGE_TYPE_CPUID: u32 = 6;
360pub const KVM_SEV_SNP_ID_BLOCK_SIZE: u32 = 96;
361pub const KVM_SEV_SNP_ID_AUTH_SIZE: u32 = 4096;
362pub const KVM_SEV_SNP_FINISH_DATA_SIZE: u32 = 32;
363pub const KVM_X2APIC_API_USE_32BIT_IDS: u32 = 1;
364pub const KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK: u32 = 2;
365pub const KVM_HYPERV_CONN_ID_MASK: u32 = 16777215;
366pub const KVM_HYPERV_EVENTFD_DEASSIGN: u32 = 1;
367pub const KVM_PMU_MASKED_ENTRY_UMASK_MASK_SHIFT: u32 = 56;
368pub const KVM_VCPU_TSC_CTRL: u32 = 0;
369pub const KVM_VCPU_TSC_OFFSET: u32 = 0;
370pub const KVM_X86_DEFAULT_VM: u32 = 0;
371pub const KVM_X86_SW_PROTECTED_VM: u32 = 1;
372pub const KVM_X86_SEV_VM: u32 = 2;
373pub const KVM_X86_SEV_ES_VM: u32 = 3;
374pub const KVM_X86_SNP_VM: u32 = 4;
375pub const KVM_API_VERSION: u32 = 12;
376pub const KVM_MEM_LOG_DIRTY_PAGES: u32 = 1;
377pub const KVM_MEM_READONLY: u32 = 2;
378pub const KVM_MEM_GUEST_MEMFD: u32 = 4;
379pub const KVM_PIT_SPEAKER_DUMMY: u32 = 1;
380pub const KVM_EXIT_HYPERV_SYNIC: u32 = 1;
381pub const KVM_EXIT_HYPERV_HCALL: u32 = 2;
382pub const KVM_EXIT_HYPERV_SYNDBG: u32 = 3;
383pub const KVM_EXIT_XEN_HCALL: u32 = 1;
384pub const KVM_S390_GET_SKEYS_NONE: u32 = 1;
385pub const KVM_S390_SKEYS_MAX: u32 = 1048576;
386pub const KVM_EXIT_UNKNOWN: u32 = 0;
387pub const KVM_EXIT_EXCEPTION: u32 = 1;
388pub const KVM_EXIT_IO: u32 = 2;
389pub const KVM_EXIT_HYPERCALL: u32 = 3;
390pub const KVM_EXIT_DEBUG: u32 = 4;
391pub const KVM_EXIT_HLT: u32 = 5;
392pub const KVM_EXIT_MMIO: u32 = 6;
393pub const KVM_EXIT_IRQ_WINDOW_OPEN: u32 = 7;
394pub const KVM_EXIT_SHUTDOWN: u32 = 8;
395pub const KVM_EXIT_FAIL_ENTRY: u32 = 9;
396pub const KVM_EXIT_INTR: u32 = 10;
397pub const KVM_EXIT_SET_TPR: u32 = 11;
398pub const KVM_EXIT_TPR_ACCESS: u32 = 12;
399pub const KVM_EXIT_S390_SIEIC: u32 = 13;
400pub const KVM_EXIT_S390_RESET: u32 = 14;
401pub const KVM_EXIT_DCR: u32 = 15;
402pub const KVM_EXIT_NMI: u32 = 16;
403pub const KVM_EXIT_INTERNAL_ERROR: u32 = 17;
404pub const KVM_EXIT_OSI: u32 = 18;
405pub const KVM_EXIT_PAPR_HCALL: u32 = 19;
406pub const KVM_EXIT_S390_UCONTROL: u32 = 20;
407pub const KVM_EXIT_WATCHDOG: u32 = 21;
408pub const KVM_EXIT_S390_TSCH: u32 = 22;
409pub const KVM_EXIT_EPR: u32 = 23;
410pub const KVM_EXIT_SYSTEM_EVENT: u32 = 24;
411pub const KVM_EXIT_S390_STSI: u32 = 25;
412pub const KVM_EXIT_IOAPIC_EOI: u32 = 26;
413pub const KVM_EXIT_HYPERV: u32 = 27;
414pub const KVM_EXIT_ARM_NISV: u32 = 28;
415pub const KVM_EXIT_X86_RDMSR: u32 = 29;
416pub const KVM_EXIT_X86_WRMSR: u32 = 30;
417pub const KVM_EXIT_DIRTY_RING_FULL: u32 = 31;
418pub const KVM_EXIT_AP_RESET_HOLD: u32 = 32;
419pub const KVM_EXIT_X86_BUS_LOCK: u32 = 33;
420pub const KVM_EXIT_XEN: u32 = 34;
421pub const KVM_EXIT_RISCV_SBI: u32 = 35;
422pub const KVM_EXIT_RISCV_CSR: u32 = 36;
423pub const KVM_EXIT_NOTIFY: u32 = 37;
424pub const KVM_EXIT_LOONGARCH_IOCSR: u32 = 38;
425pub const KVM_EXIT_MEMORY_FAULT: u32 = 39;
426pub const KVM_INTERNAL_ERROR_EMULATION: u32 = 1;
427pub const KVM_INTERNAL_ERROR_SIMUL_EX: u32 = 2;
428pub const KVM_INTERNAL_ERROR_DELIVERY_EV: u32 = 3;
429pub const KVM_INTERNAL_ERROR_UNEXPECTED_EXIT_REASON: u32 = 4;
430pub const KVM_INTERNAL_ERROR_EMULATION_FLAG_INSTRUCTION_BYTES: u32 = 1;
431pub const KVM_EXIT_IO_IN: u32 = 0;
432pub const KVM_EXIT_IO_OUT: u32 = 1;
433pub const KVM_SYSTEM_EVENT_SHUTDOWN: u32 = 1;
434pub const KVM_SYSTEM_EVENT_RESET: u32 = 2;
435pub const KVM_SYSTEM_EVENT_CRASH: u32 = 3;
436pub const KVM_SYSTEM_EVENT_WAKEUP: u32 = 4;
437pub const KVM_SYSTEM_EVENT_SUSPEND: u32 = 5;
438pub const KVM_SYSTEM_EVENT_SEV_TERM: u32 = 6;
439pub const KVM_MSR_EXIT_REASON_INVAL: u32 = 1;
440pub const KVM_MSR_EXIT_REASON_UNKNOWN: u32 = 2;
441pub const KVM_MSR_EXIT_REASON_FILTER: u32 = 4;
442pub const KVM_MSR_EXIT_REASON_VALID_MASK: u32 = 7;
443pub const KVM_NOTIFY_CONTEXT_INVALID: u32 = 1;
444pub const KVM_MEMORY_EXIT_FLAG_PRIVATE: u32 = 8;
445pub const SYNC_REGS_SIZE_BYTES: u32 = 2048;
446pub const KVM_MP_STATE_RUNNABLE: u32 = 0;
447pub const KVM_MP_STATE_UNINITIALIZED: u32 = 1;
448pub const KVM_MP_STATE_INIT_RECEIVED: u32 = 2;
449pub const KVM_MP_STATE_HALTED: u32 = 3;
450pub const KVM_MP_STATE_SIPI_RECEIVED: u32 = 4;
451pub const KVM_MP_STATE_STOPPED: u32 = 5;
452pub const KVM_MP_STATE_CHECK_STOP: u32 = 6;
453pub const KVM_MP_STATE_OPERATING: u32 = 7;
454pub const KVM_MP_STATE_LOAD: u32 = 8;
455pub const KVM_MP_STATE_AP_RESET_HOLD: u32 = 9;
456pub const KVM_MP_STATE_SUSPENDED: u32 = 10;
457pub const KVM_GUESTDBG_ENABLE: u32 = 1;
458pub const KVM_GUESTDBG_SINGLESTEP: u32 = 2;
459pub const KVM_X86_DISABLE_EXITS_MWAIT: u32 = 1;
460pub const KVM_X86_DISABLE_EXITS_HLT: u32 = 2;
461pub const KVM_X86_DISABLE_EXITS_PAUSE: u32 = 4;
462pub const KVM_X86_DISABLE_EXITS_CSTATE: u32 = 8;
463pub const KVM_X86_DISABLE_VALID_EXITS: u32 = 15;
464pub const KVMIO: u32 = 174;
465pub const KVM_VM_S390_UCONTROL: u32 = 1;
466pub const KVM_VM_PPC_HV: u32 = 1;
467pub const KVM_VM_PPC_PR: u32 = 2;
468pub const KVM_VM_MIPS_AUTO: u32 = 0;
469pub const KVM_VM_MIPS_VZ: u32 = 1;
470pub const KVM_VM_MIPS_TE: u32 = 2;
471pub const KVM_S390_SIE_PAGE_OFFSET: u32 = 1;
472pub const KVM_VM_TYPE_ARM_IPA_SIZE_MASK: u32 = 255;
473pub const KVM_CAP_IRQCHIP: u32 = 0;
474pub const KVM_CAP_HLT: u32 = 1;
475pub const KVM_CAP_MMU_SHADOW_CACHE_CONTROL: u32 = 2;
476pub const KVM_CAP_USER_MEMORY: u32 = 3;
477pub const KVM_CAP_SET_TSS_ADDR: u32 = 4;
478pub const KVM_CAP_VAPIC: u32 = 6;
479pub const KVM_CAP_EXT_CPUID: u32 = 7;
480pub const KVM_CAP_CLOCKSOURCE: u32 = 8;
481pub const KVM_CAP_NR_VCPUS: u32 = 9;
482pub const KVM_CAP_NR_MEMSLOTS: u32 = 10;
483pub const KVM_CAP_PIT: u32 = 11;
484pub const KVM_CAP_NOP_IO_DELAY: u32 = 12;
485pub const KVM_CAP_PV_MMU: u32 = 13;
486pub const KVM_CAP_MP_STATE: u32 = 14;
487pub const KVM_CAP_COALESCED_MMIO: u32 = 15;
488pub const KVM_CAP_SYNC_MMU: u32 = 16;
489pub const KVM_CAP_IOMMU: u32 = 18;
490pub const KVM_CAP_DESTROY_MEMORY_REGION_WORKS: u32 = 21;
491pub const KVM_CAP_USER_NMI: u32 = 22;
492pub const KVM_CAP_SET_GUEST_DEBUG: u32 = 23;
493pub const KVM_CAP_REINJECT_CONTROL: u32 = 24;
494pub const KVM_CAP_IRQ_ROUTING: u32 = 25;
495pub const KVM_CAP_IRQ_INJECT_STATUS: u32 = 26;
496pub const KVM_CAP_ASSIGN_DEV_IRQ: u32 = 29;
497pub const KVM_CAP_JOIN_MEMORY_REGIONS_WORKS: u32 = 30;
498pub const KVM_CAP_MCE: u32 = 31;
499pub const KVM_CAP_IRQFD: u32 = 32;
500pub const KVM_CAP_PIT2: u32 = 33;
501pub const KVM_CAP_SET_BOOT_CPU_ID: u32 = 34;
502pub const KVM_CAP_PIT_STATE2: u32 = 35;
503pub const KVM_CAP_IOEVENTFD: u32 = 36;
504pub const KVM_CAP_SET_IDENTITY_MAP_ADDR: u32 = 37;
505pub const KVM_CAP_XEN_HVM: u32 = 38;
506pub const KVM_CAP_ADJUST_CLOCK: u32 = 39;
507pub const KVM_CAP_INTERNAL_ERROR_DATA: u32 = 40;
508pub const KVM_CAP_VCPU_EVENTS: u32 = 41;
509pub const KVM_CAP_S390_PSW: u32 = 42;
510pub const KVM_CAP_PPC_SEGSTATE: u32 = 43;
511pub const KVM_CAP_HYPERV: u32 = 44;
512pub const KVM_CAP_HYPERV_VAPIC: u32 = 45;
513pub const KVM_CAP_HYPERV_SPIN: u32 = 46;
514pub const KVM_CAP_PCI_SEGMENT: u32 = 47;
515pub const KVM_CAP_PPC_PAIRED_SINGLES: u32 = 48;
516pub const KVM_CAP_INTR_SHADOW: u32 = 49;
517pub const KVM_CAP_DEBUGREGS: u32 = 50;
518pub const KVM_CAP_X86_ROBUST_SINGLESTEP: u32 = 51;
519pub const KVM_CAP_PPC_OSI: u32 = 52;
520pub const KVM_CAP_PPC_UNSET_IRQ: u32 = 53;
521pub const KVM_CAP_ENABLE_CAP: u32 = 54;
522pub const KVM_CAP_XSAVE: u32 = 55;
523pub const KVM_CAP_XCRS: u32 = 56;
524pub const KVM_CAP_PPC_GET_PVINFO: u32 = 57;
525pub const KVM_CAP_PPC_IRQ_LEVEL: u32 = 58;
526pub const KVM_CAP_ASYNC_PF: u32 = 59;
527pub const KVM_CAP_TSC_CONTROL: u32 = 60;
528pub const KVM_CAP_GET_TSC_KHZ: u32 = 61;
529pub const KVM_CAP_PPC_BOOKE_SREGS: u32 = 62;
530pub const KVM_CAP_SPAPR_TCE: u32 = 63;
531pub const KVM_CAP_PPC_SMT: u32 = 64;
532pub const KVM_CAP_PPC_RMA: u32 = 65;
533pub const KVM_CAP_MAX_VCPUS: u32 = 66;
534pub const KVM_CAP_PPC_HIOR: u32 = 67;
535pub const KVM_CAP_PPC_PAPR: u32 = 68;
536pub const KVM_CAP_SW_TLB: u32 = 69;
537pub const KVM_CAP_ONE_REG: u32 = 70;
538pub const KVM_CAP_S390_GMAP: u32 = 71;
539pub const KVM_CAP_TSC_DEADLINE_TIMER: u32 = 72;
540pub const KVM_CAP_S390_UCONTROL: u32 = 73;
541pub const KVM_CAP_SYNC_REGS: u32 = 74;
542pub const KVM_CAP_PCI_2_3: u32 = 75;
543pub const KVM_CAP_KVMCLOCK_CTRL: u32 = 76;
544pub const KVM_CAP_SIGNAL_MSI: u32 = 77;
545pub const KVM_CAP_PPC_GET_SMMU_INFO: u32 = 78;
546pub const KVM_CAP_S390_COW: u32 = 79;
547pub const KVM_CAP_PPC_ALLOC_HTAB: u32 = 80;
548pub const KVM_CAP_READONLY_MEM: u32 = 81;
549pub const KVM_CAP_IRQFD_RESAMPLE: u32 = 82;
550pub const KVM_CAP_PPC_BOOKE_WATCHDOG: u32 = 83;
551pub const KVM_CAP_PPC_HTAB_FD: u32 = 84;
552pub const KVM_CAP_S390_CSS_SUPPORT: u32 = 85;
553pub const KVM_CAP_PPC_EPR: u32 = 86;
554pub const KVM_CAP_ARM_PSCI: u32 = 87;
555pub const KVM_CAP_ARM_SET_DEVICE_ADDR: u32 = 88;
556pub const KVM_CAP_DEVICE_CTRL: u32 = 89;
557pub const KVM_CAP_IRQ_MPIC: u32 = 90;
558pub const KVM_CAP_PPC_RTAS: u32 = 91;
559pub const KVM_CAP_IRQ_XICS: u32 = 92;
560pub const KVM_CAP_ARM_EL1_32BIT: u32 = 93;
561pub const KVM_CAP_SPAPR_MULTITCE: u32 = 94;
562pub const KVM_CAP_EXT_EMUL_CPUID: u32 = 95;
563pub const KVM_CAP_HYPERV_TIME: u32 = 96;
564pub const KVM_CAP_IOAPIC_POLARITY_IGNORED: u32 = 97;
565pub const KVM_CAP_ENABLE_CAP_VM: u32 = 98;
566pub const KVM_CAP_S390_IRQCHIP: u32 = 99;
567pub const KVM_CAP_IOEVENTFD_NO_LENGTH: u32 = 100;
568pub const KVM_CAP_VM_ATTRIBUTES: u32 = 101;
569pub const KVM_CAP_ARM_PSCI_0_2: u32 = 102;
570pub const KVM_CAP_PPC_FIXUP_HCALL: u32 = 103;
571pub const KVM_CAP_PPC_ENABLE_HCALL: u32 = 104;
572pub const KVM_CAP_CHECK_EXTENSION_VM: u32 = 105;
573pub const KVM_CAP_S390_USER_SIGP: u32 = 106;
574pub const KVM_CAP_S390_VECTOR_REGISTERS: u32 = 107;
575pub const KVM_CAP_S390_MEM_OP: u32 = 108;
576pub const KVM_CAP_S390_USER_STSI: u32 = 109;
577pub const KVM_CAP_S390_SKEYS: u32 = 110;
578pub const KVM_CAP_MIPS_FPU: u32 = 111;
579pub const KVM_CAP_MIPS_MSA: u32 = 112;
580pub const KVM_CAP_S390_INJECT_IRQ: u32 = 113;
581pub const KVM_CAP_S390_IRQ_STATE: u32 = 114;
582pub const KVM_CAP_PPC_HWRNG: u32 = 115;
583pub const KVM_CAP_DISABLE_QUIRKS: u32 = 116;
584pub const KVM_CAP_X86_SMM: u32 = 117;
585pub const KVM_CAP_MULTI_ADDRESS_SPACE: u32 = 118;
586pub const KVM_CAP_GUEST_DEBUG_HW_BPS: u32 = 119;
587pub const KVM_CAP_GUEST_DEBUG_HW_WPS: u32 = 120;
588pub const KVM_CAP_SPLIT_IRQCHIP: u32 = 121;
589pub const KVM_CAP_IOEVENTFD_ANY_LENGTH: u32 = 122;
590pub const KVM_CAP_HYPERV_SYNIC: u32 = 123;
591pub const KVM_CAP_S390_RI: u32 = 124;
592pub const KVM_CAP_SPAPR_TCE_64: u32 = 125;
593pub const KVM_CAP_ARM_PMU_V3: u32 = 126;
594pub const KVM_CAP_VCPU_ATTRIBUTES: u32 = 127;
595pub const KVM_CAP_MAX_VCPU_ID: u32 = 128;
596pub const KVM_CAP_X2APIC_API: u32 = 129;
597pub const KVM_CAP_S390_USER_INSTR0: u32 = 130;
598pub const KVM_CAP_MSI_DEVID: u32 = 131;
599pub const KVM_CAP_PPC_HTM: u32 = 132;
600pub const KVM_CAP_SPAPR_RESIZE_HPT: u32 = 133;
601pub const KVM_CAP_PPC_MMU_RADIX: u32 = 134;
602pub const KVM_CAP_PPC_MMU_HASH_V3: u32 = 135;
603pub const KVM_CAP_IMMEDIATE_EXIT: u32 = 136;
604pub const KVM_CAP_MIPS_VZ: u32 = 137;
605pub const KVM_CAP_MIPS_TE: u32 = 138;
606pub const KVM_CAP_MIPS_64BIT: u32 = 139;
607pub const KVM_CAP_S390_GS: u32 = 140;
608pub const KVM_CAP_S390_AIS: u32 = 141;
609pub const KVM_CAP_SPAPR_TCE_VFIO: u32 = 142;
610pub const KVM_CAP_X86_DISABLE_EXITS: u32 = 143;
611pub const KVM_CAP_ARM_USER_IRQ: u32 = 144;
612pub const KVM_CAP_S390_CMMA_MIGRATION: u32 = 145;
613pub const KVM_CAP_PPC_FWNMI: u32 = 146;
614pub const KVM_CAP_PPC_SMT_POSSIBLE: u32 = 147;
615pub const KVM_CAP_HYPERV_SYNIC2: u32 = 148;
616pub const KVM_CAP_HYPERV_VP_INDEX: u32 = 149;
617pub const KVM_CAP_S390_AIS_MIGRATION: u32 = 150;
618pub const KVM_CAP_PPC_GET_CPU_CHAR: u32 = 151;
619pub const KVM_CAP_S390_BPB: u32 = 152;
620pub const KVM_CAP_GET_MSR_FEATURES: u32 = 153;
621pub const KVM_CAP_HYPERV_EVENTFD: u32 = 154;
622pub const KVM_CAP_HYPERV_TLBFLUSH: u32 = 155;
623pub const KVM_CAP_S390_HPAGE_1M: u32 = 156;
624pub const KVM_CAP_NESTED_STATE: u32 = 157;
625pub const KVM_CAP_ARM_INJECT_SERROR_ESR: u32 = 158;
626pub const KVM_CAP_MSR_PLATFORM_INFO: u32 = 159;
627pub const KVM_CAP_PPC_NESTED_HV: u32 = 160;
628pub const KVM_CAP_HYPERV_SEND_IPI: u32 = 161;
629pub const KVM_CAP_COALESCED_PIO: u32 = 162;
630pub const KVM_CAP_HYPERV_ENLIGHTENED_VMCS: u32 = 163;
631pub const KVM_CAP_EXCEPTION_PAYLOAD: u32 = 164;
632pub const KVM_CAP_ARM_VM_IPA_SIZE: u32 = 165;
633pub const KVM_CAP_MANUAL_DIRTY_LOG_PROTECT: u32 = 166;
634pub const KVM_CAP_HYPERV_CPUID: u32 = 167;
635pub const KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2: u32 = 168;
636pub const KVM_CAP_PPC_IRQ_XIVE: u32 = 169;
637pub const KVM_CAP_ARM_SVE: u32 = 170;
638pub const KVM_CAP_ARM_PTRAUTH_ADDRESS: u32 = 171;
639pub const KVM_CAP_ARM_PTRAUTH_GENERIC: u32 = 172;
640pub const KVM_CAP_PMU_EVENT_FILTER: u32 = 173;
641pub const KVM_CAP_ARM_IRQ_LINE_LAYOUT_2: u32 = 174;
642pub const KVM_CAP_HYPERV_DIRECT_TLBFLUSH: u32 = 175;
643pub const KVM_CAP_PPC_GUEST_DEBUG_SSTEP: u32 = 176;
644pub const KVM_CAP_ARM_NISV_TO_USER: u32 = 177;
645pub const KVM_CAP_ARM_INJECT_EXT_DABT: u32 = 178;
646pub const KVM_CAP_S390_VCPU_RESETS: u32 = 179;
647pub const KVM_CAP_S390_PROTECTED: u32 = 180;
648pub const KVM_CAP_PPC_SECURE_GUEST: u32 = 181;
649pub const KVM_CAP_HALT_POLL: u32 = 182;
650pub const KVM_CAP_ASYNC_PF_INT: u32 = 183;
651pub const KVM_CAP_LAST_CPU: u32 = 184;
652pub const KVM_CAP_SMALLER_MAXPHYADDR: u32 = 185;
653pub const KVM_CAP_S390_DIAG318: u32 = 186;
654pub const KVM_CAP_STEAL_TIME: u32 = 187;
655pub const KVM_CAP_X86_USER_SPACE_MSR: u32 = 188;
656pub const KVM_CAP_X86_MSR_FILTER: u32 = 189;
657pub const KVM_CAP_ENFORCE_PV_FEATURE_CPUID: u32 = 190;
658pub const KVM_CAP_SYS_HYPERV_CPUID: u32 = 191;
659pub const KVM_CAP_DIRTY_LOG_RING: u32 = 192;
660pub const KVM_CAP_X86_BUS_LOCK_EXIT: u32 = 193;
661pub const KVM_CAP_PPC_DAWR1: u32 = 194;
662pub const KVM_CAP_SET_GUEST_DEBUG2: u32 = 195;
663pub const KVM_CAP_SGX_ATTRIBUTE: u32 = 196;
664pub const KVM_CAP_VM_COPY_ENC_CONTEXT_FROM: u32 = 197;
665pub const KVM_CAP_PTP_KVM: u32 = 198;
666pub const KVM_CAP_HYPERV_ENFORCE_CPUID: u32 = 199;
667pub const KVM_CAP_SREGS2: u32 = 200;
668pub const KVM_CAP_EXIT_HYPERCALL: u32 = 201;
669pub const KVM_CAP_PPC_RPT_INVALIDATE: u32 = 202;
670pub const KVM_CAP_BINARY_STATS_FD: u32 = 203;
671pub const KVM_CAP_EXIT_ON_EMULATION_FAILURE: u32 = 204;
672pub const KVM_CAP_ARM_MTE: u32 = 205;
673pub const KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM: u32 = 206;
674pub const KVM_CAP_VM_GPA_BITS: u32 = 207;
675pub const KVM_CAP_XSAVE2: u32 = 208;
676pub const KVM_CAP_SYS_ATTRIBUTES: u32 = 209;
677pub const KVM_CAP_PPC_AIL_MODE_3: u32 = 210;
678pub const KVM_CAP_S390_MEM_OP_EXTENSION: u32 = 211;
679pub const KVM_CAP_PMU_CAPABILITY: u32 = 212;
680pub const KVM_CAP_DISABLE_QUIRKS2: u32 = 213;
681pub const KVM_CAP_VM_TSC_CONTROL: u32 = 214;
682pub const KVM_CAP_SYSTEM_EVENT_DATA: u32 = 215;
683pub const KVM_CAP_ARM_SYSTEM_SUSPEND: u32 = 216;
684pub const KVM_CAP_S390_PROTECTED_DUMP: u32 = 217;
685pub const KVM_CAP_X86_TRIPLE_FAULT_EVENT: u32 = 218;
686pub const KVM_CAP_X86_NOTIFY_VMEXIT: u32 = 219;
687pub const KVM_CAP_VM_DISABLE_NX_HUGE_PAGES: u32 = 220;
688pub const KVM_CAP_S390_ZPCI_OP: u32 = 221;
689pub const KVM_CAP_S390_CPU_TOPOLOGY: u32 = 222;
690pub const KVM_CAP_DIRTY_LOG_RING_ACQ_REL: u32 = 223;
691pub const KVM_CAP_S390_PROTECTED_ASYNC_DISABLE: u32 = 224;
692pub const KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP: u32 = 225;
693pub const KVM_CAP_PMU_EVENT_MASKED_EVENTS: u32 = 226;
694pub const KVM_CAP_COUNTER_OFFSET: u32 = 227;
695pub const KVM_CAP_ARM_EAGER_SPLIT_CHUNK_SIZE: u32 = 228;
696pub const KVM_CAP_ARM_SUPPORTED_BLOCK_SIZES: u32 = 229;
697pub const KVM_CAP_ARM_SUPPORTED_REG_MASK_RANGES: u32 = 230;
698pub const KVM_CAP_USER_MEMORY2: u32 = 231;
699pub const KVM_CAP_MEMORY_FAULT_INFO: u32 = 232;
700pub const KVM_CAP_MEMORY_ATTRIBUTES: u32 = 233;
701pub const KVM_CAP_GUEST_MEMFD: u32 = 234;
702pub const KVM_CAP_VM_TYPES: u32 = 235;
703pub const KVM_CAP_PRE_FAULT_MEMORY: u32 = 236;
704pub const KVM_CAP_X86_APIC_BUS_CYCLES_NS: u32 = 237;
705pub const KVM_CAP_X86_GUEST_MODE: u32 = 238;
706pub const KVM_IRQ_ROUTING_IRQCHIP: u32 = 1;
707pub const KVM_IRQ_ROUTING_MSI: u32 = 2;
708pub const KVM_IRQ_ROUTING_S390_ADAPTER: u32 = 3;
709pub const KVM_IRQ_ROUTING_HV_SINT: u32 = 4;
710pub const KVM_IRQ_ROUTING_XEN_EVTCHN: u32 = 5;
711pub const KVM_IRQFD_FLAG_DEASSIGN: u32 = 1;
712pub const KVM_IRQFD_FLAG_RESAMPLE: u32 = 2;
713pub const KVM_CLOCK_TSC_STABLE: u32 = 2;
714pub const KVM_CLOCK_REALTIME: u32 = 4;
715pub const KVM_CLOCK_HOST_TSC: u32 = 8;
716pub const KVM_MMU_FSL_BOOKE_NOHV: u32 = 0;
717pub const KVM_MMU_FSL_BOOKE_HV: u32 = 1;
718pub const KVM_REG_ARCH_MASK: i64 = -72057594037927936;
719pub const KVM_REG_GENERIC: u32 = 0;
720pub const KVM_REG_PPC: u64 = 1152921504606846976;
721pub const KVM_REG_X86: u64 = 2305843009213693952;
722pub const KVM_REG_IA64: u64 = 3458764513820540928;
723pub const KVM_REG_ARM: u64 = 4611686018427387904;
724pub const KVM_REG_S390: u64 = 5764607523034234880;
725pub const KVM_REG_ARM64: u64 = 6917529027641081856;
726pub const KVM_REG_MIPS: u64 = 8070450532247928832;
727pub const KVM_REG_RISCV: i64 = -9223372036854775808;
728pub const KVM_REG_LOONGARCH: i64 = -8070450532247928832;
729pub const KVM_REG_SIZE_SHIFT: u32 = 52;
730pub const KVM_REG_SIZE_MASK: u64 = 67553994410557440;
731pub const KVM_REG_SIZE_U8: u32 = 0;
732pub const KVM_REG_SIZE_U16: u64 = 4503599627370496;
733pub const KVM_REG_SIZE_U32: u64 = 9007199254740992;
734pub const KVM_REG_SIZE_U64: u64 = 13510798882111488;
735pub const KVM_REG_SIZE_U128: u64 = 18014398509481984;
736pub const KVM_REG_SIZE_U256: u64 = 22517998136852480;
737pub const KVM_REG_SIZE_U512: u64 = 27021597764222976;
738pub const KVM_REG_SIZE_U1024: u64 = 31525197391593472;
739pub const KVM_REG_SIZE_U2048: u64 = 36028797018963968;
740pub const KVM_MSI_VALID_DEVID: u32 = 1;
741pub const KVM_CREATE_DEVICE_TEST: u32 = 1;
742pub const KVM_DEV_VFIO_FILE: u32 = 1;
743pub const KVM_DEV_VFIO_FILE_ADD: u32 = 1;
744pub const KVM_DEV_VFIO_FILE_DEL: u32 = 2;
745pub const KVM_DEV_VFIO_GROUP: u32 = 1;
746pub const KVM_DEV_VFIO_GROUP_ADD: u32 = 1;
747pub const KVM_DEV_VFIO_GROUP_DEL: u32 = 2;
748pub const KVM_DEV_VFIO_GROUP_SET_SPAPR_TCE: u32 = 3;
749pub const KVM_S390_STORE_STATUS_NOADDR: i32 = -1;
750pub const KVM_S390_STORE_STATUS_PREFIXED: i32 = -2;
751pub const KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE: u32 = 1;
752pub const KVM_DIRTY_LOG_INITIALLY_SET: u32 = 2;
753pub const KVM_DIRTY_GFN_F_MASK: u32 = 3;
754pub const KVM_BUS_LOCK_DETECTION_OFF: u32 = 1;
755pub const KVM_BUS_LOCK_DETECTION_EXIT: u32 = 2;
756pub const KVM_PMU_CAP_DISABLE: u32 = 1;
757pub const KVM_STATS_TYPE_SHIFT: u32 = 0;
758pub const KVM_STATS_TYPE_MASK: u32 = 15;
759pub const KVM_STATS_TYPE_CUMULATIVE: u32 = 0;
760pub const KVM_STATS_TYPE_INSTANT: u32 = 1;
761pub const KVM_STATS_TYPE_PEAK: u32 = 2;
762pub const KVM_STATS_TYPE_LINEAR_HIST: u32 = 3;
763pub const KVM_STATS_TYPE_LOG_HIST: u32 = 4;
764pub const KVM_STATS_TYPE_MAX: u32 = 4;
765pub const KVM_STATS_UNIT_SHIFT: u32 = 4;
766pub const KVM_STATS_UNIT_MASK: u32 = 240;
767pub const KVM_STATS_UNIT_NONE: u32 = 0;
768pub const KVM_STATS_UNIT_BYTES: u32 = 16;
769pub const KVM_STATS_UNIT_SECONDS: u32 = 32;
770pub const KVM_STATS_UNIT_CYCLES: u32 = 48;
771pub const KVM_STATS_UNIT_BOOLEAN: u32 = 64;
772pub const KVM_STATS_UNIT_MAX: u32 = 64;
773pub const KVM_STATS_BASE_SHIFT: u32 = 8;
774pub const KVM_STATS_BASE_MASK: u32 = 3840;
775pub const KVM_STATS_BASE_POW10: u32 = 0;
776pub const KVM_STATS_BASE_POW2: u32 = 256;
777pub const KVM_STATS_BASE_MAX: u32 = 256;
778pub const KVM_X86_NOTIFY_VMEXIT_ENABLED: u32 = 1;
779pub const KVM_X86_NOTIFY_VMEXIT_USER: u32 = 2;
780pub const KVM_MEMORY_ATTRIBUTE_PRIVATE: u32 = 8;
781pub type __s128 = i128;
782pub type __u128 = u128;
783pub type __le16 = u16;
784pub type __be16 = u16;
785pub type __le32 = u32;
786pub type __be32 = u32;
787pub type __le64 = u64;
788pub type __be64 = u64;
789pub type __sum16 = u16;
790pub type __wsum = u32;
791pub type __poll_t = ::std::os::raw::c_uint;
792#[repr(C)]
793#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
794pub struct kvm_pic_state {
795 pub last_irr: u8,
796 pub irr: u8,
797 pub imr: u8,
798 pub isr: u8,
799 pub priority_add: u8,
800 pub irq_base: u8,
801 pub read_reg_select: u8,
802 pub poll: u8,
803 pub special_mask: u8,
804 pub init_state: u8,
805 pub auto_eoi: u8,
806 pub rotate_on_auto_eoi: u8,
807 pub special_fully_nested_mode: u8,
808 pub init4: u8,
809 pub elcr: u8,
810 pub elcr_mask: u8,
811}
812#[repr(C)]
813#[derive(Copy, Clone)]
814pub struct kvm_ioapic_state {
815 pub base_address: u64,
816 pub ioregsel: u32,
817 pub id: u32,
818 pub irr: u32,
819 pub pad: u32,
820 pub redirtbl: [kvm_ioapic_state__bindgen_ty_1; 24usize],
821}
822#[repr(C)]
823#[derive(Copy, Clone)]
824pub union kvm_ioapic_state__bindgen_ty_1 {
825 pub bits: u64,
826 pub fields: kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1,
827}
828#[repr(C)]
829#[derive(Debug, Default, Copy, Clone)]
830pub struct kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 {
831 pub vector: u8,
832 pub _bitfield_align_1: [u8; 0],
833 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
834 pub reserved: [u8; 4usize],
835 pub dest_id: u8,
836}
837impl kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 {
838 #[inline]
839 pub fn delivery_mode(&self) -> u8 {
840 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8) }
841 }
842 #[inline]
843 pub fn set_delivery_mode(&mut self, val: u8) {
844 unsafe {
845 let val: u8 = ::std::mem::transmute(val);
846 self._bitfield_1.set(0usize, 3u8, val as u64)
847 }
848 }
849 #[inline]
850 pub unsafe fn delivery_mode_raw(this: *const Self) -> u8 {
851 unsafe {
852 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
853 ::std::ptr::addr_of!((*this)._bitfield_1),
854 0usize,
855 3u8,
856 ) as u8)
857 }
858 }
859 #[inline]
860 pub unsafe fn set_delivery_mode_raw(this: *mut Self, val: u8) {
861 unsafe {
862 let val: u8 = ::std::mem::transmute(val);
863 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
864 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
865 0usize,
866 3u8,
867 val as u64,
868 )
869 }
870 }
871 #[inline]
872 pub fn dest_mode(&self) -> u8 {
873 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
874 }
875 #[inline]
876 pub fn set_dest_mode(&mut self, val: u8) {
877 unsafe {
878 let val: u8 = ::std::mem::transmute(val);
879 self._bitfield_1.set(3usize, 1u8, val as u64)
880 }
881 }
882 #[inline]
883 pub unsafe fn dest_mode_raw(this: *const Self) -> u8 {
884 unsafe {
885 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
886 ::std::ptr::addr_of!((*this)._bitfield_1),
887 3usize,
888 1u8,
889 ) as u8)
890 }
891 }
892 #[inline]
893 pub unsafe fn set_dest_mode_raw(this: *mut Self, val: u8) {
894 unsafe {
895 let val: u8 = ::std::mem::transmute(val);
896 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
897 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
898 3usize,
899 1u8,
900 val as u64,
901 )
902 }
903 }
904 #[inline]
905 pub fn delivery_status(&self) -> u8 {
906 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
907 }
908 #[inline]
909 pub fn set_delivery_status(&mut self, val: u8) {
910 unsafe {
911 let val: u8 = ::std::mem::transmute(val);
912 self._bitfield_1.set(4usize, 1u8, val as u64)
913 }
914 }
915 #[inline]
916 pub unsafe fn delivery_status_raw(this: *const Self) -> u8 {
917 unsafe {
918 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
919 ::std::ptr::addr_of!((*this)._bitfield_1),
920 4usize,
921 1u8,
922 ) as u8)
923 }
924 }
925 #[inline]
926 pub unsafe fn set_delivery_status_raw(this: *mut Self, val: u8) {
927 unsafe {
928 let val: u8 = ::std::mem::transmute(val);
929 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
930 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
931 4usize,
932 1u8,
933 val as u64,
934 )
935 }
936 }
937 #[inline]
938 pub fn polarity(&self) -> u8 {
939 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
940 }
941 #[inline]
942 pub fn set_polarity(&mut self, val: u8) {
943 unsafe {
944 let val: u8 = ::std::mem::transmute(val);
945 self._bitfield_1.set(5usize, 1u8, val as u64)
946 }
947 }
948 #[inline]
949 pub unsafe fn polarity_raw(this: *const Self) -> u8 {
950 unsafe {
951 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
952 ::std::ptr::addr_of!((*this)._bitfield_1),
953 5usize,
954 1u8,
955 ) as u8)
956 }
957 }
958 #[inline]
959 pub unsafe fn set_polarity_raw(this: *mut Self, val: u8) {
960 unsafe {
961 let val: u8 = ::std::mem::transmute(val);
962 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
963 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
964 5usize,
965 1u8,
966 val as u64,
967 )
968 }
969 }
970 #[inline]
971 pub fn remote_irr(&self) -> u8 {
972 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
973 }
974 #[inline]
975 pub fn set_remote_irr(&mut self, val: u8) {
976 unsafe {
977 let val: u8 = ::std::mem::transmute(val);
978 self._bitfield_1.set(6usize, 1u8, val as u64)
979 }
980 }
981 #[inline]
982 pub unsafe fn remote_irr_raw(this: *const Self) -> u8 {
983 unsafe {
984 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
985 ::std::ptr::addr_of!((*this)._bitfield_1),
986 6usize,
987 1u8,
988 ) as u8)
989 }
990 }
991 #[inline]
992 pub unsafe fn set_remote_irr_raw(this: *mut Self, val: u8) {
993 unsafe {
994 let val: u8 = ::std::mem::transmute(val);
995 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
996 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
997 6usize,
998 1u8,
999 val as u64,
1000 )
1001 }
1002 }
1003 #[inline]
1004 pub fn trig_mode(&self) -> u8 {
1005 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
1006 }
1007 #[inline]
1008 pub fn set_trig_mode(&mut self, val: u8) {
1009 unsafe {
1010 let val: u8 = ::std::mem::transmute(val);
1011 self._bitfield_1.set(7usize, 1u8, val as u64)
1012 }
1013 }
1014 #[inline]
1015 pub unsafe fn trig_mode_raw(this: *const Self) -> u8 {
1016 unsafe {
1017 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1018 ::std::ptr::addr_of!((*this)._bitfield_1),
1019 7usize,
1020 1u8,
1021 ) as u8)
1022 }
1023 }
1024 #[inline]
1025 pub unsafe fn set_trig_mode_raw(this: *mut Self, val: u8) {
1026 unsafe {
1027 let val: u8 = ::std::mem::transmute(val);
1028 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1029 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1030 7usize,
1031 1u8,
1032 val as u64,
1033 )
1034 }
1035 }
1036 #[inline]
1037 pub fn mask(&self) -> u8 {
1038 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
1039 }
1040 #[inline]
1041 pub fn set_mask(&mut self, val: u8) {
1042 unsafe {
1043 let val: u8 = ::std::mem::transmute(val);
1044 self._bitfield_1.set(8usize, 1u8, val as u64)
1045 }
1046 }
1047 #[inline]
1048 pub unsafe fn mask_raw(this: *const Self) -> u8 {
1049 unsafe {
1050 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1051 ::std::ptr::addr_of!((*this)._bitfield_1),
1052 8usize,
1053 1u8,
1054 ) as u8)
1055 }
1056 }
1057 #[inline]
1058 pub unsafe fn set_mask_raw(this: *mut Self, val: u8) {
1059 unsafe {
1060 let val: u8 = ::std::mem::transmute(val);
1061 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1062 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1063 8usize,
1064 1u8,
1065 val as u64,
1066 )
1067 }
1068 }
1069 #[inline]
1070 pub fn reserve(&self) -> u8 {
1071 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 7u8) as u8) }
1072 }
1073 #[inline]
1074 pub fn set_reserve(&mut self, val: u8) {
1075 unsafe {
1076 let val: u8 = ::std::mem::transmute(val);
1077 self._bitfield_1.set(9usize, 7u8, val as u64)
1078 }
1079 }
1080 #[inline]
1081 pub unsafe fn reserve_raw(this: *const Self) -> u8 {
1082 unsafe {
1083 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1084 ::std::ptr::addr_of!((*this)._bitfield_1),
1085 9usize,
1086 7u8,
1087 ) as u8)
1088 }
1089 }
1090 #[inline]
1091 pub unsafe fn set_reserve_raw(this: *mut Self, val: u8) {
1092 unsafe {
1093 let val: u8 = ::std::mem::transmute(val);
1094 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1095 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1096 9usize,
1097 7u8,
1098 val as u64,
1099 )
1100 }
1101 }
1102 #[inline]
1103 pub fn new_bitfield_1(
1104 delivery_mode: u8,
1105 dest_mode: u8,
1106 delivery_status: u8,
1107 polarity: u8,
1108 remote_irr: u8,
1109 trig_mode: u8,
1110 mask: u8,
1111 reserve: u8,
1112 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
1113 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
1114 __bindgen_bitfield_unit.set(0usize, 3u8, {
1115 let delivery_mode: u8 = unsafe { ::std::mem::transmute(delivery_mode) };
1116 delivery_mode as u64
1117 });
1118 __bindgen_bitfield_unit.set(3usize, 1u8, {
1119 let dest_mode: u8 = unsafe { ::std::mem::transmute(dest_mode) };
1120 dest_mode as u64
1121 });
1122 __bindgen_bitfield_unit.set(4usize, 1u8, {
1123 let delivery_status: u8 = unsafe { ::std::mem::transmute(delivery_status) };
1124 delivery_status as u64
1125 });
1126 __bindgen_bitfield_unit.set(5usize, 1u8, {
1127 let polarity: u8 = unsafe { ::std::mem::transmute(polarity) };
1128 polarity as u64
1129 });
1130 __bindgen_bitfield_unit.set(6usize, 1u8, {
1131 let remote_irr: u8 = unsafe { ::std::mem::transmute(remote_irr) };
1132 remote_irr as u64
1133 });
1134 __bindgen_bitfield_unit.set(7usize, 1u8, {
1135 let trig_mode: u8 = unsafe { ::std::mem::transmute(trig_mode) };
1136 trig_mode as u64
1137 });
1138 __bindgen_bitfield_unit.set(8usize, 1u8, {
1139 let mask: u8 = unsafe { ::std::mem::transmute(mask) };
1140 mask as u64
1141 });
1142 __bindgen_bitfield_unit.set(9usize, 7u8, {
1143 let reserve: u8 = unsafe { ::std::mem::transmute(reserve) };
1144 reserve as u64
1145 });
1146 __bindgen_bitfield_unit
1147 }
1148}
1149impl Default for kvm_ioapic_state__bindgen_ty_1 {
1150 fn default() -> Self {
1151 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1152 unsafe {
1153 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1154 s.assume_init()
1155 }
1156 }
1157}
1158impl Default for kvm_ioapic_state {
1159 fn default() -> Self {
1160 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1161 unsafe {
1162 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1163 s.assume_init()
1164 }
1165 }
1166}
1167#[repr(C)]
1168#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1169pub struct kvm_regs {
1170 pub rax: u64,
1171 pub rbx: u64,
1172 pub rcx: u64,
1173 pub rdx: u64,
1174 pub rsi: u64,
1175 pub rdi: u64,
1176 pub rsp: u64,
1177 pub rbp: u64,
1178 pub r8: u64,
1179 pub r9: u64,
1180 pub r10: u64,
1181 pub r11: u64,
1182 pub r12: u64,
1183 pub r13: u64,
1184 pub r14: u64,
1185 pub r15: u64,
1186 pub rip: u64,
1187 pub rflags: u64,
1188}
1189#[repr(C)]
1190#[derive(Debug, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1191pub struct kvm_lapic_state {
1192 pub regs: [::std::os::raw::c_char; 1024usize],
1193}
1194impl Default for kvm_lapic_state {
1195 fn default() -> Self {
1196 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1197 unsafe {
1198 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1199 s.assume_init()
1200 }
1201 }
1202}
1203#[repr(C)]
1204#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1205pub struct kvm_segment {
1206 pub base: u64,
1207 pub limit: u32,
1208 pub selector: u16,
1209 pub type_: u8,
1210 pub present: u8,
1211 pub dpl: u8,
1212 pub db: u8,
1213 pub s: u8,
1214 pub l: u8,
1215 pub g: u8,
1216 pub avl: u8,
1217 pub unusable: u8,
1218 pub padding: u8,
1219}
1220#[repr(C)]
1221#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1222pub struct kvm_dtable {
1223 pub base: u64,
1224 pub limit: u16,
1225 pub padding: [u16; 3usize],
1226}
1227#[repr(C)]
1228#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1229pub struct kvm_sregs {
1230 pub cs: kvm_segment,
1231 pub ds: kvm_segment,
1232 pub es: kvm_segment,
1233 pub fs: kvm_segment,
1234 pub gs: kvm_segment,
1235 pub ss: kvm_segment,
1236 pub tr: kvm_segment,
1237 pub ldt: kvm_segment,
1238 pub gdt: kvm_dtable,
1239 pub idt: kvm_dtable,
1240 pub cr0: u64,
1241 pub cr2: u64,
1242 pub cr3: u64,
1243 pub cr4: u64,
1244 pub cr8: u64,
1245 pub efer: u64,
1246 pub apic_base: u64,
1247 pub interrupt_bitmap: [u64; 4usize],
1248}
1249#[repr(C)]
1250#[derive(Debug, Default, Copy, Clone)]
1251pub struct kvm_sregs2 {
1252 pub cs: kvm_segment,
1253 pub ds: kvm_segment,
1254 pub es: kvm_segment,
1255 pub fs: kvm_segment,
1256 pub gs: kvm_segment,
1257 pub ss: kvm_segment,
1258 pub tr: kvm_segment,
1259 pub ldt: kvm_segment,
1260 pub gdt: kvm_dtable,
1261 pub idt: kvm_dtable,
1262 pub cr0: u64,
1263 pub cr2: u64,
1264 pub cr3: u64,
1265 pub cr4: u64,
1266 pub cr8: u64,
1267 pub efer: u64,
1268 pub apic_base: u64,
1269 pub flags: u64,
1270 pub pdptrs: [u64; 4usize],
1271}
1272#[repr(C)]
1273#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1274pub struct kvm_fpu {
1275 pub fpr: [[u8; 16usize]; 8usize],
1276 pub fcw: u16,
1277 pub fsw: u16,
1278 pub ftwx: u8,
1279 pub pad1: u8,
1280 pub last_opcode: u16,
1281 pub last_ip: u64,
1282 pub last_dp: u64,
1283 pub xmm: [[u8; 16usize]; 16usize],
1284 pub mxcsr: u32,
1285 pub pad2: u32,
1286}
1287#[repr(C)]
1288#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, KnownLayout)]
1289pub struct kvm_msr_entry {
1290 pub index: u32,
1291 pub reserved: u32,
1292 pub data: u64,
1293}
1294#[repr(C)]
1295#[derive(Debug, Default, FromBytes, Immutable, KnownLayout)]
1296pub struct kvm_msrs<FAM: ?Sized = [kvm_msr_entry; 0]> {
1297 pub nmsrs: u32,
1298 pub pad: u32,
1299 pub entries: FAM,
1300}
1301impl kvm_msrs<[kvm_msr_entry]> {}
1302impl kvm_msrs<[kvm_msr_entry; 0]> {}
1303#[repr(C)]
1304#[derive(Debug, Default, FromBytes, Immutable, KnownLayout)]
1305pub struct kvm_msr_list<FAM: ?Sized = [u32; 0]> {
1306 pub nmsrs: u32,
1307 pub indices: FAM,
1308}
1309impl kvm_msr_list<[u32]> {}
1310impl kvm_msr_list<[u32; 0]> {}
1311#[repr(C)]
1312#[derive(Debug, Copy, Clone)]
1313pub struct kvm_msr_filter_range {
1314 pub flags: u32,
1315 pub nmsrs: u32,
1316 pub base: u32,
1317 pub bitmap: *mut u8,
1318}
1319impl Default for kvm_msr_filter_range {
1320 fn default() -> Self {
1321 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1322 unsafe {
1323 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1324 s.assume_init()
1325 }
1326 }
1327}
1328#[repr(C)]
1329#[derive(Debug, Copy, Clone)]
1330pub struct kvm_msr_filter {
1331 pub flags: u32,
1332 pub ranges: [kvm_msr_filter_range; 16usize],
1333}
1334impl Default for kvm_msr_filter {
1335 fn default() -> Self {
1336 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1337 unsafe {
1338 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1339 s.assume_init()
1340 }
1341 }
1342}
1343#[repr(C)]
1344#[derive(Debug, Default, Copy, Clone)]
1345pub struct kvm_cpuid_entry {
1346 pub function: u32,
1347 pub eax: u32,
1348 pub ebx: u32,
1349 pub ecx: u32,
1350 pub edx: u32,
1351 pub padding: u32,
1352}
1353#[repr(C)]
1354#[derive(Debug, Default)]
1355pub struct kvm_cpuid<FAM: ?Sized = [kvm_cpuid_entry; 0]> {
1356 pub nent: u32,
1357 pub padding: u32,
1358 pub entries: FAM,
1359}
1360impl kvm_cpuid<[kvm_cpuid_entry]> {}
1361impl kvm_cpuid<[kvm_cpuid_entry; 0]> {}
1362#[repr(C)]
1363#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, KnownLayout)]
1364pub struct kvm_cpuid_entry2 {
1365 pub function: u32,
1366 pub index: u32,
1367 pub flags: u32,
1368 pub eax: u32,
1369 pub ebx: u32,
1370 pub ecx: u32,
1371 pub edx: u32,
1372 pub padding: [u32; 3usize],
1373}
1374#[repr(C)]
1375#[derive(Debug, Default, FromBytes, Immutable, KnownLayout)]
1376pub struct kvm_cpuid2<FAM: ?Sized = [kvm_cpuid_entry2; 0]> {
1377 pub nent: u32,
1378 pub padding: u32,
1379 pub entries: FAM,
1380}
1381impl kvm_cpuid2<[kvm_cpuid_entry2]> {}
1382impl kvm_cpuid2<[kvm_cpuid_entry2; 0]> {}
1383#[repr(C)]
1384#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1385pub struct kvm_pit_channel_state {
1386 pub count: u32,
1387 pub latched_count: u16,
1388 pub count_latched: u8,
1389 pub status_latched: u8,
1390 pub status: u8,
1391 pub read_state: u8,
1392 pub write_state: u8,
1393 pub write_latch: u8,
1394 pub rw_mode: u8,
1395 pub mode: u8,
1396 pub bcd: u8,
1397 pub gate: u8,
1398 pub count_load_time: i64,
1399}
1400#[repr(C)]
1401#[derive(Debug, Default, Copy, Clone)]
1402pub struct kvm_debug_exit_arch {
1403 pub exception: u32,
1404 pub pad: u32,
1405 pub pc: u64,
1406 pub dr6: u64,
1407 pub dr7: u64,
1408}
1409#[repr(C)]
1410#[derive(Debug, Default, Copy, Clone)]
1411pub struct kvm_guest_debug_arch {
1412 pub debugreg: [u64; 8usize],
1413}
1414#[repr(C)]
1415#[derive(Debug, Default, Copy, Clone)]
1416pub struct kvm_pit_state {
1417 pub channels: [kvm_pit_channel_state; 3usize],
1418}
1419#[repr(C)]
1420#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1421pub struct kvm_pit_state2 {
1422 pub channels: [kvm_pit_channel_state; 3usize],
1423 pub flags: u32,
1424 pub reserved: [u32; 9usize],
1425}
1426#[repr(C)]
1427#[derive(Debug, Default, Copy, Clone)]
1428pub struct kvm_reinject_control {
1429 pub pit_reinject: u8,
1430 pub reserved: [u8; 31usize],
1431}
1432#[repr(C)]
1433#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1434pub struct kvm_vcpu_events {
1435 pub exception: kvm_vcpu_events__bindgen_ty_1,
1436 pub interrupt: kvm_vcpu_events__bindgen_ty_2,
1437 pub nmi: kvm_vcpu_events__bindgen_ty_3,
1438 pub sipi_vector: u32,
1439 pub flags: u32,
1440 pub smi: kvm_vcpu_events__bindgen_ty_4,
1441 pub triple_fault: kvm_vcpu_events__bindgen_ty_5,
1442 pub reserved: [u8; 26usize],
1443 pub exception_has_payload: u8,
1444 pub exception_payload: u64,
1445}
1446#[repr(C)]
1447#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1448pub struct kvm_vcpu_events__bindgen_ty_1 {
1449 pub injected: u8,
1450 pub nr: u8,
1451 pub has_error_code: u8,
1452 pub pending: u8,
1453 pub error_code: u32,
1454}
1455#[repr(C)]
1456#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1457pub struct kvm_vcpu_events__bindgen_ty_2 {
1458 pub injected: u8,
1459 pub nr: u8,
1460 pub soft: u8,
1461 pub shadow: u8,
1462}
1463#[repr(C)]
1464#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1465pub struct kvm_vcpu_events__bindgen_ty_3 {
1466 pub injected: u8,
1467 pub pending: u8,
1468 pub masked: u8,
1469 pub pad: u8,
1470}
1471#[repr(C)]
1472#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1473pub struct kvm_vcpu_events__bindgen_ty_4 {
1474 pub smm: u8,
1475 pub pending: u8,
1476 pub smm_inside_nmi: u8,
1477 pub latched_init: u8,
1478}
1479#[repr(C)]
1480#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1481pub struct kvm_vcpu_events__bindgen_ty_5 {
1482 pub pending: u8,
1483}
1484#[repr(C)]
1485#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1486pub struct kvm_debugregs {
1487 pub db: [u64; 4usize],
1488 pub dr6: u64,
1489 pub dr7: u64,
1490 pub flags: u64,
1491 pub reserved: [u64; 9usize],
1492}
1493#[repr(C)]
1494#[derive(Debug)]
1495pub struct kvm_xsave<FAM: ?Sized = [u32; 0]> {
1496 pub region: [u32; 1024usize],
1497 pub extra: FAM,
1498}
1499impl kvm_xsave<[u32]> {}
1500impl kvm_xsave<[u32; 0]> {}
1501impl Default for kvm_xsave<[u32; 0]> {
1502 fn default() -> Self {
1503 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1504 unsafe {
1505 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1506 s.assume_init()
1507 }
1508 }
1509}
1510#[repr(C)]
1511#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1512pub struct kvm_xcr {
1513 pub xcr: u32,
1514 pub reserved: u32,
1515 pub value: u64,
1516}
1517#[repr(C)]
1518#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
1519pub struct kvm_xcrs {
1520 pub nr_xcrs: u32,
1521 pub flags: u32,
1522 pub xcrs: [kvm_xcr; 16usize],
1523 pub padding: [u64; 16usize],
1524}
1525#[repr(C)]
1526#[derive(Debug, Default, Copy, Clone)]
1527pub struct kvm_sync_regs {
1528 pub regs: kvm_regs,
1529 pub sregs: kvm_sregs,
1530 pub events: kvm_vcpu_events,
1531}
1532#[repr(C)]
1533#[derive(Debug, Copy, Clone)]
1534pub struct kvm_vmx_nested_state_data {
1535 pub vmcs12: [u8; 4096usize],
1536 pub shadow_vmcs12: [u8; 4096usize],
1537}
1538impl Default for kvm_vmx_nested_state_data {
1539 fn default() -> Self {
1540 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1541 unsafe {
1542 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1543 s.assume_init()
1544 }
1545 }
1546}
1547#[repr(C)]
1548#[derive(Debug, Default, Copy, Clone)]
1549pub struct kvm_vmx_nested_state_hdr {
1550 pub vmxon_pa: u64,
1551 pub vmcs12_pa: u64,
1552 pub smm: kvm_vmx_nested_state_hdr__bindgen_ty_1,
1553 pub pad: u16,
1554 pub flags: u32,
1555 pub preemption_timer_deadline: u64,
1556}
1557#[repr(C)]
1558#[derive(Debug, Default, Copy, Clone)]
1559pub struct kvm_vmx_nested_state_hdr__bindgen_ty_1 {
1560 pub flags: u16,
1561}
1562#[repr(C)]
1563#[derive(Debug, Copy, Clone)]
1564pub struct kvm_svm_nested_state_data {
1565 pub vmcb12: [u8; 4096usize],
1566}
1567impl Default for kvm_svm_nested_state_data {
1568 fn default() -> Self {
1569 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1570 unsafe {
1571 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1572 s.assume_init()
1573 }
1574 }
1575}
1576#[repr(C)]
1577#[derive(Debug, Default, Copy, Clone)]
1578pub struct kvm_svm_nested_state_hdr {
1579 pub vmcb_pa: u64,
1580}
1581#[repr(C)]
1582pub struct kvm_nested_state {
1583 pub flags: u16,
1584 pub format: u16,
1585 pub size: u32,
1586 pub hdr: kvm_nested_state__bindgen_ty_1,
1587 pub data: kvm_nested_state__bindgen_ty_2,
1588}
1589#[repr(C)]
1590#[derive(Copy, Clone)]
1591pub union kvm_nested_state__bindgen_ty_1 {
1592 pub vmx: kvm_vmx_nested_state_hdr,
1593 pub svm: kvm_svm_nested_state_hdr,
1594 pub pad: [u8; 120usize],
1595}
1596impl Default for kvm_nested_state__bindgen_ty_1 {
1597 fn default() -> Self {
1598 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1599 unsafe {
1600 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1601 s.assume_init()
1602 }
1603 }
1604}
1605#[repr(C)]
1606pub struct kvm_nested_state__bindgen_ty_2 {
1607 pub __bindgen_anon_1: __BindgenUnionField<kvm_nested_state__bindgen_ty_2__bindgen_ty_1>,
1608 pub __bindgen_anon_2: __BindgenUnionField<kvm_nested_state__bindgen_ty_2__bindgen_ty_2>,
1609 pub bindgen_union_field: [u8; 0usize],
1610}
1611#[repr(C)]
1612#[derive(Debug)]
1613pub struct kvm_nested_state__bindgen_ty_2__bindgen_ty_1<
1614 FAM: ?Sized = [kvm_vmx_nested_state_data; 0],
1615> {
1616 pub __empty_vmx: kvm_nested_state__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
1617 pub vmx: FAM,
1618}
1619#[repr(C)]
1620#[derive(Debug, Default, Copy, Clone)]
1621pub struct kvm_nested_state__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 {}
1622impl kvm_nested_state__bindgen_ty_2__bindgen_ty_1<[kvm_vmx_nested_state_data]> {}
1623impl kvm_nested_state__bindgen_ty_2__bindgen_ty_1<[kvm_vmx_nested_state_data; 0]> {}
1624impl Default for kvm_nested_state__bindgen_ty_2__bindgen_ty_1<[kvm_vmx_nested_state_data; 0]> {
1625 fn default() -> Self {
1626 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1627 unsafe {
1628 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1629 s.assume_init()
1630 }
1631 }
1632}
1633#[repr(C)]
1634#[derive(Debug)]
1635pub struct kvm_nested_state__bindgen_ty_2__bindgen_ty_2<
1636 FAM: ?Sized = [kvm_svm_nested_state_data; 0],
1637> {
1638 pub __empty_svm: kvm_nested_state__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1,
1639 pub svm: FAM,
1640}
1641#[repr(C)]
1642#[derive(Debug, Default, Copy, Clone)]
1643pub struct kvm_nested_state__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1 {}
1644impl kvm_nested_state__bindgen_ty_2__bindgen_ty_2<[kvm_svm_nested_state_data]> {}
1645impl kvm_nested_state__bindgen_ty_2__bindgen_ty_2<[kvm_svm_nested_state_data; 0]> {}
1646impl Default for kvm_nested_state__bindgen_ty_2__bindgen_ty_2<[kvm_svm_nested_state_data; 0]> {
1647 fn default() -> Self {
1648 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1649 unsafe {
1650 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1651 s.assume_init()
1652 }
1653 }
1654}
1655impl Default for kvm_nested_state__bindgen_ty_2 {
1656 fn default() -> Self {
1657 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1658 unsafe {
1659 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1660 s.assume_init()
1661 }
1662 }
1663}
1664impl Default for kvm_nested_state {
1665 fn default() -> Self {
1666 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1667 unsafe {
1668 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1669 s.assume_init()
1670 }
1671 }
1672}
1673#[repr(C)]
1674#[derive(Debug, Default)]
1675pub struct kvm_pmu_event_filter<FAM: ?Sized = [u64; 0]> {
1676 pub action: u32,
1677 pub nevents: u32,
1678 pub fixed_counter_bitmap: u32,
1679 pub flags: u32,
1680 pub pad: [u32; 4usize],
1681 pub events: FAM,
1682}
1683impl kvm_pmu_event_filter<[u64]> {}
1684impl kvm_pmu_event_filter<[u64; 0]> {}
1685#[repr(C)]
1686#[derive(Debug, Default, Copy, Clone)]
1687pub struct kvm_x86_mce {
1688 pub status: u64,
1689 pub addr: u64,
1690 pub misc: u64,
1691 pub mcg_status: u64,
1692 pub bank: u8,
1693 pub pad1: [u8; 7usize],
1694 pub pad2: [u64; 3usize],
1695}
1696#[repr(C)]
1697#[derive(Debug, Default, Copy, Clone)]
1698pub struct kvm_xen_hvm_config {
1699 pub flags: u32,
1700 pub msr: u32,
1701 pub blob_addr_32: u64,
1702 pub blob_addr_64: u64,
1703 pub blob_size_32: u8,
1704 pub blob_size_64: u8,
1705 pub pad2: [u8; 30usize],
1706}
1707#[repr(C)]
1708#[derive(Copy, Clone)]
1709pub struct kvm_xen_hvm_attr {
1710 pub type_: u16,
1711 pub pad: [u16; 3usize],
1712 pub u: kvm_xen_hvm_attr__bindgen_ty_1,
1713}
1714#[repr(C)]
1715#[derive(Copy, Clone)]
1716pub union kvm_xen_hvm_attr__bindgen_ty_1 {
1717 pub long_mode: u8,
1718 pub vector: u8,
1719 pub runstate_update_flag: u8,
1720 pub shared_info: kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_1,
1721 pub evtchn: kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2,
1722 pub xen_version: u32,
1723 pub pad: [u64; 8usize],
1724}
1725#[repr(C)]
1726#[derive(Copy, Clone)]
1727pub union kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_1 {
1728 pub gfn: u64,
1729 pub hva: u64,
1730}
1731impl Default for kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_1 {
1732 fn default() -> Self {
1733 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1734 unsafe {
1735 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1736 s.assume_init()
1737 }
1738 }
1739}
1740#[repr(C)]
1741#[derive(Copy, Clone)]
1742pub struct kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2 {
1743 pub send_port: u32,
1744 pub type_: u32,
1745 pub flags: u32,
1746 pub deliver: kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
1747}
1748#[repr(C)]
1749#[derive(Copy, Clone)]
1750pub union kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
1751 pub port: kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
1752 pub eventfd: kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2,
1753 pub padding: [u32; 4usize],
1754}
1755#[repr(C)]
1756#[derive(Debug, Default, Copy, Clone)]
1757pub struct kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 {
1758 pub port: u32,
1759 pub vcpu: u32,
1760 pub priority: u32,
1761}
1762#[repr(C)]
1763#[derive(Debug, Default, Copy, Clone)]
1764pub struct kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2 {
1765 pub port: u32,
1766 pub fd: i32,
1767}
1768impl Default for kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
1769 fn default() -> Self {
1770 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1771 unsafe {
1772 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1773 s.assume_init()
1774 }
1775 }
1776}
1777impl Default for kvm_xen_hvm_attr__bindgen_ty_1__bindgen_ty_2 {
1778 fn default() -> Self {
1779 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1780 unsafe {
1781 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1782 s.assume_init()
1783 }
1784 }
1785}
1786impl Default for kvm_xen_hvm_attr__bindgen_ty_1 {
1787 fn default() -> Self {
1788 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1789 unsafe {
1790 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1791 s.assume_init()
1792 }
1793 }
1794}
1795impl Default for kvm_xen_hvm_attr {
1796 fn default() -> Self {
1797 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1798 unsafe {
1799 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1800 s.assume_init()
1801 }
1802 }
1803}
1804#[repr(C)]
1805#[derive(Copy, Clone)]
1806pub struct kvm_xen_vcpu_attr {
1807 pub type_: u16,
1808 pub pad: [u16; 3usize],
1809 pub u: kvm_xen_vcpu_attr__bindgen_ty_1,
1810}
1811#[repr(C)]
1812#[derive(Copy, Clone)]
1813pub union kvm_xen_vcpu_attr__bindgen_ty_1 {
1814 pub gpa: u64,
1815 pub hva: u64,
1816 pub pad: [u64; 8usize],
1817 pub runstate: kvm_xen_vcpu_attr__bindgen_ty_1__bindgen_ty_1,
1818 pub vcpu_id: u32,
1819 pub timer: kvm_xen_vcpu_attr__bindgen_ty_1__bindgen_ty_2,
1820 pub vector: u8,
1821}
1822#[repr(C)]
1823#[derive(Debug, Default, Copy, Clone)]
1824pub struct kvm_xen_vcpu_attr__bindgen_ty_1__bindgen_ty_1 {
1825 pub state: u64,
1826 pub state_entry_time: u64,
1827 pub time_running: u64,
1828 pub time_runnable: u64,
1829 pub time_blocked: u64,
1830 pub time_offline: u64,
1831}
1832#[repr(C)]
1833#[derive(Debug, Default, Copy, Clone)]
1834pub struct kvm_xen_vcpu_attr__bindgen_ty_1__bindgen_ty_2 {
1835 pub port: u32,
1836 pub priority: u32,
1837 pub expires_ns: u64,
1838}
1839impl Default for kvm_xen_vcpu_attr__bindgen_ty_1 {
1840 fn default() -> Self {
1841 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1842 unsafe {
1843 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1844 s.assume_init()
1845 }
1846 }
1847}
1848impl Default for kvm_xen_vcpu_attr {
1849 fn default() -> Self {
1850 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1851 unsafe {
1852 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1853 s.assume_init()
1854 }
1855 }
1856}
1857pub const sev_cmd_id_KVM_SEV_INIT: sev_cmd_id = 0;
1858pub const sev_cmd_id_KVM_SEV_ES_INIT: sev_cmd_id = 1;
1859pub const sev_cmd_id_KVM_SEV_LAUNCH_START: sev_cmd_id = 2;
1860pub const sev_cmd_id_KVM_SEV_LAUNCH_UPDATE_DATA: sev_cmd_id = 3;
1861pub const sev_cmd_id_KVM_SEV_LAUNCH_UPDATE_VMSA: sev_cmd_id = 4;
1862pub const sev_cmd_id_KVM_SEV_LAUNCH_SECRET: sev_cmd_id = 5;
1863pub const sev_cmd_id_KVM_SEV_LAUNCH_MEASURE: sev_cmd_id = 6;
1864pub const sev_cmd_id_KVM_SEV_LAUNCH_FINISH: sev_cmd_id = 7;
1865pub const sev_cmd_id_KVM_SEV_SEND_START: sev_cmd_id = 8;
1866pub const sev_cmd_id_KVM_SEV_SEND_UPDATE_DATA: sev_cmd_id = 9;
1867pub const sev_cmd_id_KVM_SEV_SEND_UPDATE_VMSA: sev_cmd_id = 10;
1868pub const sev_cmd_id_KVM_SEV_SEND_FINISH: sev_cmd_id = 11;
1869pub const sev_cmd_id_KVM_SEV_RECEIVE_START: sev_cmd_id = 12;
1870pub const sev_cmd_id_KVM_SEV_RECEIVE_UPDATE_DATA: sev_cmd_id = 13;
1871pub const sev_cmd_id_KVM_SEV_RECEIVE_UPDATE_VMSA: sev_cmd_id = 14;
1872pub const sev_cmd_id_KVM_SEV_RECEIVE_FINISH: sev_cmd_id = 15;
1873pub const sev_cmd_id_KVM_SEV_GUEST_STATUS: sev_cmd_id = 16;
1874pub const sev_cmd_id_KVM_SEV_DBG_DECRYPT: sev_cmd_id = 17;
1875pub const sev_cmd_id_KVM_SEV_DBG_ENCRYPT: sev_cmd_id = 18;
1876pub const sev_cmd_id_KVM_SEV_CERT_EXPORT: sev_cmd_id = 19;
1877pub const sev_cmd_id_KVM_SEV_GET_ATTESTATION_REPORT: sev_cmd_id = 20;
1878pub const sev_cmd_id_KVM_SEV_SEND_CANCEL: sev_cmd_id = 21;
1879pub const sev_cmd_id_KVM_SEV_INIT2: sev_cmd_id = 22;
1880pub const sev_cmd_id_KVM_SEV_SNP_LAUNCH_START: sev_cmd_id = 100;
1881pub const sev_cmd_id_KVM_SEV_SNP_LAUNCH_UPDATE: sev_cmd_id = 101;
1882pub const sev_cmd_id_KVM_SEV_SNP_LAUNCH_FINISH: sev_cmd_id = 102;
1883pub const sev_cmd_id_KVM_SEV_NR_MAX: sev_cmd_id = 103;
1884pub type sev_cmd_id = ::std::os::raw::c_uint;
1885#[repr(C)]
1886#[derive(Debug, Default, Copy, Clone)]
1887pub struct kvm_sev_cmd {
1888 pub id: u32,
1889 pub pad0: u32,
1890 pub data: u64,
1891 pub error: u32,
1892 pub sev_fd: u32,
1893}
1894#[repr(C)]
1895#[derive(Debug, Default, Copy, Clone)]
1896pub struct kvm_sev_init {
1897 pub vmsa_features: u64,
1898 pub flags: u32,
1899 pub ghcb_version: u16,
1900 pub pad1: u16,
1901 pub pad2: [u32; 8usize],
1902}
1903#[repr(C)]
1904#[derive(Debug, Default, Copy, Clone)]
1905pub struct kvm_sev_launch_start {
1906 pub handle: u32,
1907 pub policy: u32,
1908 pub dh_uaddr: u64,
1909 pub dh_len: u32,
1910 pub pad0: u32,
1911 pub session_uaddr: u64,
1912 pub session_len: u32,
1913 pub pad1: u32,
1914}
1915#[repr(C)]
1916#[derive(Debug, Default, Copy, Clone)]
1917pub struct kvm_sev_launch_update_data {
1918 pub uaddr: u64,
1919 pub len: u32,
1920 pub pad0: u32,
1921}
1922#[repr(C)]
1923#[derive(Debug, Default, Copy, Clone)]
1924pub struct kvm_sev_launch_secret {
1925 pub hdr_uaddr: u64,
1926 pub hdr_len: u32,
1927 pub pad0: u32,
1928 pub guest_uaddr: u64,
1929 pub guest_len: u32,
1930 pub pad1: u32,
1931 pub trans_uaddr: u64,
1932 pub trans_len: u32,
1933 pub pad2: u32,
1934}
1935#[repr(C)]
1936#[derive(Debug, Default, Copy, Clone)]
1937pub struct kvm_sev_launch_measure {
1938 pub uaddr: u64,
1939 pub len: u32,
1940 pub pad0: u32,
1941}
1942#[repr(C)]
1943#[derive(Debug, Default, Copy, Clone)]
1944pub struct kvm_sev_guest_status {
1945 pub handle: u32,
1946 pub policy: u32,
1947 pub state: u32,
1948}
1949#[repr(C)]
1950#[derive(Debug, Default, Copy, Clone)]
1951pub struct kvm_sev_dbg {
1952 pub src_uaddr: u64,
1953 pub dst_uaddr: u64,
1954 pub len: u32,
1955 pub pad0: u32,
1956}
1957#[repr(C)]
1958#[derive(Debug, Default, Copy, Clone)]
1959pub struct kvm_sev_attestation_report {
1960 pub mnonce: [u8; 16usize],
1961 pub uaddr: u64,
1962 pub len: u32,
1963 pub pad0: u32,
1964}
1965#[repr(C)]
1966#[derive(Debug, Default, Copy, Clone)]
1967pub struct kvm_sev_send_start {
1968 pub policy: u32,
1969 pub pad0: u32,
1970 pub pdh_cert_uaddr: u64,
1971 pub pdh_cert_len: u32,
1972 pub pad1: u32,
1973 pub plat_certs_uaddr: u64,
1974 pub plat_certs_len: u32,
1975 pub pad2: u32,
1976 pub amd_certs_uaddr: u64,
1977 pub amd_certs_len: u32,
1978 pub pad3: u32,
1979 pub session_uaddr: u64,
1980 pub session_len: u32,
1981 pub pad4: u32,
1982}
1983#[repr(C)]
1984#[derive(Debug, Default, Copy, Clone)]
1985pub struct kvm_sev_send_update_data {
1986 pub hdr_uaddr: u64,
1987 pub hdr_len: u32,
1988 pub pad0: u32,
1989 pub guest_uaddr: u64,
1990 pub guest_len: u32,
1991 pub pad1: u32,
1992 pub trans_uaddr: u64,
1993 pub trans_len: u32,
1994 pub pad2: u32,
1995}
1996#[repr(C)]
1997#[derive(Debug, Default, Copy, Clone)]
1998pub struct kvm_sev_receive_start {
1999 pub handle: u32,
2000 pub policy: u32,
2001 pub pdh_uaddr: u64,
2002 pub pdh_len: u32,
2003 pub pad0: u32,
2004 pub session_uaddr: u64,
2005 pub session_len: u32,
2006 pub pad1: u32,
2007}
2008#[repr(C)]
2009#[derive(Debug, Default, Copy, Clone)]
2010pub struct kvm_sev_receive_update_data {
2011 pub hdr_uaddr: u64,
2012 pub hdr_len: u32,
2013 pub pad0: u32,
2014 pub guest_uaddr: u64,
2015 pub guest_len: u32,
2016 pub pad1: u32,
2017 pub trans_uaddr: u64,
2018 pub trans_len: u32,
2019 pub pad2: u32,
2020}
2021#[repr(C)]
2022#[derive(Debug, Default, Copy, Clone)]
2023pub struct kvm_sev_snp_launch_start {
2024 pub policy: u64,
2025 pub gosvw: [u8; 16usize],
2026 pub flags: u16,
2027 pub pad0: [u8; 6usize],
2028 pub pad1: [u64; 4usize],
2029}
2030#[repr(C)]
2031#[derive(Debug, Default, Copy, Clone)]
2032pub struct kvm_sev_snp_launch_update {
2033 pub gfn_start: u64,
2034 pub uaddr: u64,
2035 pub len: u64,
2036 pub type_: u8,
2037 pub pad0: u8,
2038 pub flags: u16,
2039 pub pad1: u32,
2040 pub pad2: [u64; 4usize],
2041}
2042#[repr(C)]
2043#[derive(Debug, Default, Copy, Clone)]
2044pub struct kvm_sev_snp_launch_finish {
2045 pub id_block_uaddr: u64,
2046 pub id_auth_uaddr: u64,
2047 pub id_block_en: u8,
2048 pub auth_key_en: u8,
2049 pub vcek_disabled: u8,
2050 pub host_data: [u8; 32usize],
2051 pub pad0: [u8; 3usize],
2052 pub flags: u16,
2053 pub pad1: [u64; 4usize],
2054}
2055#[repr(C)]
2056#[derive(Debug, Default, Copy, Clone)]
2057pub struct kvm_hyperv_eventfd {
2058 pub conn_id: u32,
2059 pub fd: i32,
2060 pub flags: u32,
2061 pub padding: [u32; 3usize],
2062}
2063#[repr(C)]
2064#[derive(Debug, Default, Copy, Clone)]
2065pub struct kvm_userspace_memory_region {
2066 pub slot: u32,
2067 pub flags: u32,
2068 pub guest_phys_addr: u64,
2069 pub memory_size: u64,
2070 pub userspace_addr: u64,
2071}
2072#[repr(C)]
2073#[derive(Debug, Default, Copy, Clone)]
2074pub struct kvm_userspace_memory_region2 {
2075 pub slot: u32,
2076 pub flags: u32,
2077 pub guest_phys_addr: u64,
2078 pub memory_size: u64,
2079 pub userspace_addr: u64,
2080 pub guest_memfd_offset: u64,
2081 pub guest_memfd: u32,
2082 pub pad1: u32,
2083 pub pad2: [u64; 14usize],
2084}
2085#[repr(C)]
2086#[derive(Copy, Clone)]
2087pub struct kvm_irq_level {
2088 pub __bindgen_anon_1: kvm_irq_level__bindgen_ty_1,
2089 pub level: u32,
2090}
2091#[repr(C)]
2092#[derive(Copy, Clone)]
2093pub union kvm_irq_level__bindgen_ty_1 {
2094 pub irq: u32,
2095 pub status: i32,
2096}
2097impl Default for kvm_irq_level__bindgen_ty_1 {
2098 fn default() -> Self {
2099 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2100 unsafe {
2101 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2102 s.assume_init()
2103 }
2104 }
2105}
2106impl Default for kvm_irq_level {
2107 fn default() -> Self {
2108 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2109 unsafe {
2110 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2111 s.assume_init()
2112 }
2113 }
2114}
2115#[repr(C)]
2116#[derive(Copy, Clone)]
2117pub struct kvm_irqchip {
2118 pub chip_id: u32,
2119 pub pad: u32,
2120 pub chip: kvm_irqchip__bindgen_ty_1,
2121}
2122#[repr(C)]
2123#[derive(Copy, Clone)]
2124pub union kvm_irqchip__bindgen_ty_1 {
2125 pub dummy: [::std::os::raw::c_char; 512usize],
2126 pub pic: kvm_pic_state,
2127 pub ioapic: kvm_ioapic_state,
2128}
2129impl Default for kvm_irqchip__bindgen_ty_1 {
2130 fn default() -> Self {
2131 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2132 unsafe {
2133 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2134 s.assume_init()
2135 }
2136 }
2137}
2138impl Default for kvm_irqchip {
2139 fn default() -> Self {
2140 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2141 unsafe {
2142 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2143 s.assume_init()
2144 }
2145 }
2146}
2147#[repr(C)]
2148#[derive(Debug, Default, Copy, Clone)]
2149pub struct kvm_pit_config {
2150 pub flags: u32,
2151 pub pad: [u32; 15usize],
2152}
2153#[repr(C)]
2154#[derive(Copy, Clone)]
2155pub struct kvm_hyperv_exit {
2156 pub type_: u32,
2157 pub pad1: u32,
2158 pub u: kvm_hyperv_exit__bindgen_ty_1,
2159}
2160#[repr(C)]
2161#[derive(Copy, Clone)]
2162pub union kvm_hyperv_exit__bindgen_ty_1 {
2163 pub synic: kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1,
2164 pub hcall: kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2,
2165 pub syndbg: kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_3,
2166}
2167#[repr(C)]
2168#[derive(Debug, Default, Copy, Clone)]
2169pub struct kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 {
2170 pub msr: u32,
2171 pub pad2: u32,
2172 pub control: u64,
2173 pub evt_page: u64,
2174 pub msg_page: u64,
2175}
2176#[repr(C)]
2177#[derive(Debug, Default, Copy, Clone)]
2178pub struct kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 {
2179 pub input: u64,
2180 pub result: u64,
2181 pub params: [u64; 2usize],
2182}
2183#[repr(C)]
2184#[derive(Debug, Default, Copy, Clone)]
2185pub struct kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_3 {
2186 pub msr: u32,
2187 pub pad2: u32,
2188 pub control: u64,
2189 pub status: u64,
2190 pub send_page: u64,
2191 pub recv_page: u64,
2192 pub pending_page: u64,
2193}
2194impl Default for kvm_hyperv_exit__bindgen_ty_1 {
2195 fn default() -> Self {
2196 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2197 unsafe {
2198 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2199 s.assume_init()
2200 }
2201 }
2202}
2203impl Default for kvm_hyperv_exit {
2204 fn default() -> Self {
2205 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2206 unsafe {
2207 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2208 s.assume_init()
2209 }
2210 }
2211}
2212#[repr(C)]
2213#[derive(Copy, Clone)]
2214pub struct kvm_xen_exit {
2215 pub type_: u32,
2216 pub u: kvm_xen_exit__bindgen_ty_1,
2217}
2218#[repr(C)]
2219#[derive(Copy, Clone)]
2220pub union kvm_xen_exit__bindgen_ty_1 {
2221 pub hcall: kvm_xen_exit__bindgen_ty_1__bindgen_ty_1,
2222}
2223#[repr(C)]
2224#[derive(Debug, Default, Copy, Clone)]
2225pub struct kvm_xen_exit__bindgen_ty_1__bindgen_ty_1 {
2226 pub longmode: u32,
2227 pub cpl: u32,
2228 pub input: u64,
2229 pub result: u64,
2230 pub params: [u64; 6usize],
2231}
2232impl Default for kvm_xen_exit__bindgen_ty_1 {
2233 fn default() -> Self {
2234 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2235 unsafe {
2236 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2237 s.assume_init()
2238 }
2239 }
2240}
2241impl Default for kvm_xen_exit {
2242 fn default() -> Self {
2243 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2244 unsafe {
2245 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2246 s.assume_init()
2247 }
2248 }
2249}
2250#[repr(C)]
2251#[derive(Copy, Clone)]
2252pub struct kvm_run {
2253 pub request_interrupt_window: u8,
2254 pub immediate_exit: u8,
2255 pub padding1: [u8; 6usize],
2256 pub exit_reason: u32,
2257 pub ready_for_interrupt_injection: u8,
2258 pub if_flag: u8,
2259 pub flags: u16,
2260 pub cr8: u64,
2261 pub apic_base: u64,
2262 pub __bindgen_anon_1: kvm_run__bindgen_ty_1,
2263 pub kvm_valid_regs: u64,
2264 pub kvm_dirty_regs: u64,
2265 pub s: kvm_run__bindgen_ty_2,
2266}
2267#[repr(C)]
2268#[derive(Copy, Clone)]
2269pub union kvm_run__bindgen_ty_1 {
2270 pub hw: kvm_run__bindgen_ty_1__bindgen_ty_1,
2271 pub fail_entry: kvm_run__bindgen_ty_1__bindgen_ty_2,
2272 pub ex: kvm_run__bindgen_ty_1__bindgen_ty_3,
2273 pub io: kvm_run__bindgen_ty_1__bindgen_ty_4,
2274 pub debug: kvm_run__bindgen_ty_1__bindgen_ty_5,
2275 pub mmio: kvm_run__bindgen_ty_1__bindgen_ty_6,
2276 pub iocsr_io: kvm_run__bindgen_ty_1__bindgen_ty_7,
2277 pub hypercall: kvm_run__bindgen_ty_1__bindgen_ty_8,
2278 pub tpr_access: kvm_run__bindgen_ty_1__bindgen_ty_9,
2279 pub s390_sieic: kvm_run__bindgen_ty_1__bindgen_ty_10,
2280 pub s390_reset_flags: u64,
2281 pub s390_ucontrol: kvm_run__bindgen_ty_1__bindgen_ty_11,
2282 pub dcr: kvm_run__bindgen_ty_1__bindgen_ty_12,
2283 pub internal: kvm_run__bindgen_ty_1__bindgen_ty_13,
2284 pub emulation_failure: kvm_run__bindgen_ty_1__bindgen_ty_14,
2285 pub osi: kvm_run__bindgen_ty_1__bindgen_ty_15,
2286 pub papr_hcall: kvm_run__bindgen_ty_1__bindgen_ty_16,
2287 pub s390_tsch: kvm_run__bindgen_ty_1__bindgen_ty_17,
2288 pub epr: kvm_run__bindgen_ty_1__bindgen_ty_18,
2289 pub system_event: kvm_run__bindgen_ty_1__bindgen_ty_19,
2290 pub s390_stsi: kvm_run__bindgen_ty_1__bindgen_ty_20,
2291 pub eoi: kvm_run__bindgen_ty_1__bindgen_ty_21,
2292 pub hyperv: kvm_hyperv_exit,
2293 pub arm_nisv: kvm_run__bindgen_ty_1__bindgen_ty_22,
2294 pub msr: kvm_run__bindgen_ty_1__bindgen_ty_23,
2295 pub xen: kvm_xen_exit,
2296 pub riscv_sbi: kvm_run__bindgen_ty_1__bindgen_ty_24,
2297 pub riscv_csr: kvm_run__bindgen_ty_1__bindgen_ty_25,
2298 pub notify: kvm_run__bindgen_ty_1__bindgen_ty_26,
2299 pub memory_fault: kvm_run__bindgen_ty_1__bindgen_ty_27,
2300 pub padding: [::std::os::raw::c_char; 256usize],
2301}
2302#[repr(C)]
2303#[derive(Debug, Default, Copy, Clone)]
2304pub struct kvm_run__bindgen_ty_1__bindgen_ty_1 {
2305 pub hardware_exit_reason: u64,
2306}
2307#[repr(C)]
2308#[derive(Debug, Default, Copy, Clone)]
2309pub struct kvm_run__bindgen_ty_1__bindgen_ty_2 {
2310 pub hardware_entry_failure_reason: u64,
2311 pub cpu: u32,
2312}
2313#[repr(C)]
2314#[derive(Debug, Default, Copy, Clone)]
2315pub struct kvm_run__bindgen_ty_1__bindgen_ty_3 {
2316 pub exception: u32,
2317 pub error_code: u32,
2318}
2319#[repr(C)]
2320#[derive(Debug, Default, Copy, Clone)]
2321pub struct kvm_run__bindgen_ty_1__bindgen_ty_4 {
2322 pub direction: u8,
2323 pub size: u8,
2324 pub port: u16,
2325 pub count: u32,
2326 pub data_offset: u64,
2327}
2328#[repr(C)]
2329#[derive(Debug, Default, Copy, Clone)]
2330pub struct kvm_run__bindgen_ty_1__bindgen_ty_5 {
2331 pub arch: kvm_debug_exit_arch,
2332}
2333#[repr(C)]
2334#[derive(Debug, Default, Copy, Clone)]
2335pub struct kvm_run__bindgen_ty_1__bindgen_ty_6 {
2336 pub phys_addr: u64,
2337 pub data: [u8; 8usize],
2338 pub len: u32,
2339 pub is_write: u8,
2340}
2341#[repr(C)]
2342#[derive(Debug, Default, Copy, Clone)]
2343pub struct kvm_run__bindgen_ty_1__bindgen_ty_7 {
2344 pub phys_addr: u64,
2345 pub data: [u8; 8usize],
2346 pub len: u32,
2347 pub is_write: u8,
2348}
2349#[repr(C)]
2350#[derive(Copy, Clone)]
2351pub struct kvm_run__bindgen_ty_1__bindgen_ty_8 {
2352 pub nr: u64,
2353 pub args: [u64; 6usize],
2354 pub ret: u64,
2355 pub __bindgen_anon_1: kvm_run__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
2356}
2357#[repr(C)]
2358#[derive(Copy, Clone)]
2359pub union kvm_run__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1 {
2360 pub longmode: u32,
2361 pub flags: u64,
2362}
2363impl Default for kvm_run__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1 {
2364 fn default() -> Self {
2365 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2366 unsafe {
2367 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2368 s.assume_init()
2369 }
2370 }
2371}
2372impl Default for kvm_run__bindgen_ty_1__bindgen_ty_8 {
2373 fn default() -> Self {
2374 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2375 unsafe {
2376 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2377 s.assume_init()
2378 }
2379 }
2380}
2381#[repr(C)]
2382#[derive(Debug, Default, Copy, Clone)]
2383pub struct kvm_run__bindgen_ty_1__bindgen_ty_9 {
2384 pub rip: u64,
2385 pub is_write: u32,
2386 pub pad: u32,
2387}
2388#[repr(C)]
2389#[derive(Debug, Default, Copy, Clone)]
2390pub struct kvm_run__bindgen_ty_1__bindgen_ty_10 {
2391 pub icptcode: u8,
2392 pub ipa: u16,
2393 pub ipb: u32,
2394}
2395#[repr(C)]
2396#[derive(Debug, Default, Copy, Clone)]
2397pub struct kvm_run__bindgen_ty_1__bindgen_ty_11 {
2398 pub trans_exc_code: u64,
2399 pub pgm_code: u32,
2400}
2401#[repr(C)]
2402#[derive(Debug, Default, Copy, Clone)]
2403pub struct kvm_run__bindgen_ty_1__bindgen_ty_12 {
2404 pub dcrn: u32,
2405 pub data: u32,
2406 pub is_write: u8,
2407}
2408#[repr(C)]
2409#[derive(Debug, Default, Copy, Clone)]
2410pub struct kvm_run__bindgen_ty_1__bindgen_ty_13 {
2411 pub suberror: u32,
2412 pub ndata: u32,
2413 pub data: [u64; 16usize],
2414}
2415#[repr(C)]
2416#[derive(Copy, Clone)]
2417pub struct kvm_run__bindgen_ty_1__bindgen_ty_14 {
2418 pub suberror: u32,
2419 pub ndata: u32,
2420 pub flags: u64,
2421 pub __bindgen_anon_1: kvm_run__bindgen_ty_1__bindgen_ty_14__bindgen_ty_1,
2422}
2423#[repr(C)]
2424#[derive(Copy, Clone)]
2425pub union kvm_run__bindgen_ty_1__bindgen_ty_14__bindgen_ty_1 {
2426 pub __bindgen_anon_1: kvm_run__bindgen_ty_1__bindgen_ty_14__bindgen_ty_1__bindgen_ty_1,
2427}
2428#[repr(C)]
2429#[derive(Debug, Default, Copy, Clone)]
2430pub struct kvm_run__bindgen_ty_1__bindgen_ty_14__bindgen_ty_1__bindgen_ty_1 {
2431 pub insn_size: u8,
2432 pub insn_bytes: [u8; 15usize],
2433}
2434impl Default for kvm_run__bindgen_ty_1__bindgen_ty_14__bindgen_ty_1 {
2435 fn default() -> Self {
2436 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2437 unsafe {
2438 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2439 s.assume_init()
2440 }
2441 }
2442}
2443impl Default for kvm_run__bindgen_ty_1__bindgen_ty_14 {
2444 fn default() -> Self {
2445 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2446 unsafe {
2447 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2448 s.assume_init()
2449 }
2450 }
2451}
2452#[repr(C)]
2453#[derive(Debug, Default, Copy, Clone)]
2454pub struct kvm_run__bindgen_ty_1__bindgen_ty_15 {
2455 pub gprs: [u64; 32usize],
2456}
2457#[repr(C)]
2458#[derive(Debug, Default, Copy, Clone)]
2459pub struct kvm_run__bindgen_ty_1__bindgen_ty_16 {
2460 pub nr: u64,
2461 pub ret: u64,
2462 pub args: [u64; 9usize],
2463}
2464#[repr(C)]
2465#[derive(Debug, Default, Copy, Clone)]
2466pub struct kvm_run__bindgen_ty_1__bindgen_ty_17 {
2467 pub subchannel_id: u16,
2468 pub subchannel_nr: u16,
2469 pub io_int_parm: u32,
2470 pub io_int_word: u32,
2471 pub ipb: u32,
2472 pub dequeued: u8,
2473}
2474#[repr(C)]
2475#[derive(Debug, Default, Copy, Clone)]
2476pub struct kvm_run__bindgen_ty_1__bindgen_ty_18 {
2477 pub epr: u32,
2478}
2479#[repr(C)]
2480#[derive(Copy, Clone)]
2481pub struct kvm_run__bindgen_ty_1__bindgen_ty_19 {
2482 pub type_: u32,
2483 pub ndata: u32,
2484 pub __bindgen_anon_1: kvm_run__bindgen_ty_1__bindgen_ty_19__bindgen_ty_1,
2485}
2486#[repr(C)]
2487#[derive(Copy, Clone)]
2488pub union kvm_run__bindgen_ty_1__bindgen_ty_19__bindgen_ty_1 {
2489 pub flags: u64,
2490 pub data: [u64; 16usize],
2491}
2492impl Default for kvm_run__bindgen_ty_1__bindgen_ty_19__bindgen_ty_1 {
2493 fn default() -> Self {
2494 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2495 unsafe {
2496 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2497 s.assume_init()
2498 }
2499 }
2500}
2501impl Default for kvm_run__bindgen_ty_1__bindgen_ty_19 {
2502 fn default() -> Self {
2503 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2504 unsafe {
2505 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2506 s.assume_init()
2507 }
2508 }
2509}
2510#[repr(C)]
2511#[derive(Debug, Default, Copy, Clone)]
2512pub struct kvm_run__bindgen_ty_1__bindgen_ty_20 {
2513 pub addr: u64,
2514 pub ar: u8,
2515 pub reserved: u8,
2516 pub fc: u8,
2517 pub sel1: u8,
2518 pub sel2: u16,
2519}
2520#[repr(C)]
2521#[derive(Debug, Default, Copy, Clone)]
2522pub struct kvm_run__bindgen_ty_1__bindgen_ty_21 {
2523 pub vector: u8,
2524}
2525#[repr(C)]
2526#[derive(Debug, Default, Copy, Clone)]
2527pub struct kvm_run__bindgen_ty_1__bindgen_ty_22 {
2528 pub esr_iss: u64,
2529 pub fault_ipa: u64,
2530}
2531#[repr(C)]
2532#[derive(Debug, Default, Copy, Clone)]
2533pub struct kvm_run__bindgen_ty_1__bindgen_ty_23 {
2534 pub error: u8,
2535 pub pad: [u8; 7usize],
2536 pub reason: u32,
2537 pub index: u32,
2538 pub data: u64,
2539}
2540#[repr(C)]
2541#[derive(Debug, Default, Copy, Clone)]
2542pub struct kvm_run__bindgen_ty_1__bindgen_ty_24 {
2543 pub extension_id: ::std::os::raw::c_ulong,
2544 pub function_id: ::std::os::raw::c_ulong,
2545 pub args: [::std::os::raw::c_ulong; 6usize],
2546 pub ret: [::std::os::raw::c_ulong; 2usize],
2547}
2548#[repr(C)]
2549#[derive(Debug, Default, Copy, Clone)]
2550pub struct kvm_run__bindgen_ty_1__bindgen_ty_25 {
2551 pub csr_num: ::std::os::raw::c_ulong,
2552 pub new_value: ::std::os::raw::c_ulong,
2553 pub write_mask: ::std::os::raw::c_ulong,
2554 pub ret_value: ::std::os::raw::c_ulong,
2555}
2556#[repr(C)]
2557#[derive(Debug, Default, Copy, Clone)]
2558pub struct kvm_run__bindgen_ty_1__bindgen_ty_26 {
2559 pub flags: u32,
2560}
2561#[repr(C)]
2562#[derive(Debug, Default, Copy, Clone)]
2563pub struct kvm_run__bindgen_ty_1__bindgen_ty_27 {
2564 pub flags: u64,
2565 pub gpa: u64,
2566 pub size: u64,
2567}
2568impl Default for kvm_run__bindgen_ty_1 {
2569 fn default() -> Self {
2570 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2571 unsafe {
2572 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2573 s.assume_init()
2574 }
2575 }
2576}
2577#[repr(C)]
2578#[derive(Copy, Clone)]
2579pub union kvm_run__bindgen_ty_2 {
2580 pub regs: kvm_sync_regs,
2581 pub padding: [::std::os::raw::c_char; 2048usize],
2582}
2583impl Default for kvm_run__bindgen_ty_2 {
2584 fn default() -> Self {
2585 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2586 unsafe {
2587 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2588 s.assume_init()
2589 }
2590 }
2591}
2592impl Default for kvm_run {
2593 fn default() -> Self {
2594 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2595 unsafe {
2596 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2597 s.assume_init()
2598 }
2599 }
2600}
2601#[repr(C)]
2602#[derive(Copy, Clone)]
2603pub struct kvm_coalesced_mmio_zone {
2604 pub addr: u64,
2605 pub size: u32,
2606 pub __bindgen_anon_1: kvm_coalesced_mmio_zone__bindgen_ty_1,
2607}
2608#[repr(C)]
2609#[derive(Copy, Clone)]
2610pub union kvm_coalesced_mmio_zone__bindgen_ty_1 {
2611 pub pad: u32,
2612 pub pio: u32,
2613}
2614impl Default for kvm_coalesced_mmio_zone__bindgen_ty_1 {
2615 fn default() -> Self {
2616 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2617 unsafe {
2618 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2619 s.assume_init()
2620 }
2621 }
2622}
2623impl Default for kvm_coalesced_mmio_zone {
2624 fn default() -> Self {
2625 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2626 unsafe {
2627 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2628 s.assume_init()
2629 }
2630 }
2631}
2632#[repr(C)]
2633#[derive(Copy, Clone)]
2634pub struct kvm_coalesced_mmio {
2635 pub phys_addr: u64,
2636 pub len: u32,
2637 pub __bindgen_anon_1: kvm_coalesced_mmio__bindgen_ty_1,
2638 pub data: [u8; 8usize],
2639}
2640#[repr(C)]
2641#[derive(Copy, Clone)]
2642pub union kvm_coalesced_mmio__bindgen_ty_1 {
2643 pub pad: u32,
2644 pub pio: u32,
2645}
2646impl Default for kvm_coalesced_mmio__bindgen_ty_1 {
2647 fn default() -> Self {
2648 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2649 unsafe {
2650 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2651 s.assume_init()
2652 }
2653 }
2654}
2655impl Default for kvm_coalesced_mmio {
2656 fn default() -> Self {
2657 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2658 unsafe {
2659 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2660 s.assume_init()
2661 }
2662 }
2663}
2664#[repr(C)]
2665pub struct kvm_coalesced_mmio_ring<FAM: ?Sized = [kvm_coalesced_mmio; 0]> {
2666 pub first: u32,
2667 pub last: u32,
2668 pub coalesced_mmio: FAM,
2669}
2670impl kvm_coalesced_mmio_ring<[kvm_coalesced_mmio]> {}
2671impl kvm_coalesced_mmio_ring<[kvm_coalesced_mmio; 0]> {}
2672impl Default for kvm_coalesced_mmio_ring<[kvm_coalesced_mmio; 0]> {
2673 fn default() -> Self {
2674 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2675 unsafe {
2676 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2677 s.assume_init()
2678 }
2679 }
2680}
2681#[repr(C)]
2682#[derive(Debug, Default, Copy, Clone)]
2683pub struct kvm_translation {
2684 pub linear_address: u64,
2685 pub physical_address: u64,
2686 pub valid: u8,
2687 pub writeable: u8,
2688 pub usermode: u8,
2689 pub pad: [u8; 5usize],
2690}
2691#[repr(C)]
2692#[derive(Debug, Default, Copy, Clone)]
2693pub struct kvm_interrupt {
2694 pub irq: u32,
2695}
2696#[repr(C)]
2697#[derive(Copy, Clone)]
2698pub struct kvm_dirty_log {
2699 pub slot: u32,
2700 pub padding1: u32,
2701 pub __bindgen_anon_1: kvm_dirty_log__bindgen_ty_1,
2702}
2703#[repr(C)]
2704#[derive(Copy, Clone)]
2705pub union kvm_dirty_log__bindgen_ty_1 {
2706 pub dirty_bitmap: *mut ::std::os::raw::c_void,
2707 pub padding2: u64,
2708}
2709impl Default for kvm_dirty_log__bindgen_ty_1 {
2710 fn default() -> Self {
2711 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2712 unsafe {
2713 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2714 s.assume_init()
2715 }
2716 }
2717}
2718impl Default for kvm_dirty_log {
2719 fn default() -> Self {
2720 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2721 unsafe {
2722 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2723 s.assume_init()
2724 }
2725 }
2726}
2727#[repr(C)]
2728#[derive(Copy, Clone)]
2729pub struct kvm_clear_dirty_log {
2730 pub slot: u32,
2731 pub num_pages: u32,
2732 pub first_page: u64,
2733 pub __bindgen_anon_1: kvm_clear_dirty_log__bindgen_ty_1,
2734}
2735#[repr(C)]
2736#[derive(Copy, Clone)]
2737pub union kvm_clear_dirty_log__bindgen_ty_1 {
2738 pub dirty_bitmap: *mut ::std::os::raw::c_void,
2739 pub padding2: u64,
2740}
2741impl Default for kvm_clear_dirty_log__bindgen_ty_1 {
2742 fn default() -> Self {
2743 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2744 unsafe {
2745 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2746 s.assume_init()
2747 }
2748 }
2749}
2750impl Default for kvm_clear_dirty_log {
2751 fn default() -> Self {
2752 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2753 unsafe {
2754 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2755 s.assume_init()
2756 }
2757 }
2758}
2759#[repr(C)]
2760#[derive(Debug, Default)]
2761pub struct kvm_signal_mask<FAM: ?Sized = [u8; 0]> {
2762 pub len: u32,
2763 pub sigset: FAM,
2764}
2765impl kvm_signal_mask<[u8]> {}
2766impl kvm_signal_mask<[u8; 0]> {}
2767#[repr(C)]
2768#[derive(Debug, Default, Copy, Clone)]
2769pub struct kvm_tpr_access_ctl {
2770 pub enabled: u32,
2771 pub flags: u32,
2772 pub reserved: [u32; 8usize],
2773}
2774#[repr(C)]
2775#[derive(Debug, Default, Copy, Clone)]
2776pub struct kvm_vapic_addr {
2777 pub vapic_addr: u64,
2778}
2779#[repr(C)]
2780#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
2781pub struct kvm_mp_state {
2782 pub mp_state: u32,
2783}
2784#[repr(C)]
2785#[derive(Debug, Default, Copy, Clone)]
2786pub struct kvm_guest_debug {
2787 pub control: u32,
2788 pub pad: u32,
2789 pub arch: kvm_guest_debug_arch,
2790}
2791pub const kvm_ioeventfd_flag_nr_datamatch: _bindgen_ty_1 = 0;
2792pub const kvm_ioeventfd_flag_nr_pio: _bindgen_ty_1 = 1;
2793pub const kvm_ioeventfd_flag_nr_deassign: _bindgen_ty_1 = 2;
2794pub const kvm_ioeventfd_flag_nr_virtio_ccw_notify: _bindgen_ty_1 = 3;
2795pub const kvm_ioeventfd_flag_nr_fast_mmio: _bindgen_ty_1 = 4;
2796pub const kvm_ioeventfd_flag_nr_max: _bindgen_ty_1 = 5;
2797pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
2798#[repr(C)]
2799#[derive(Debug, Copy, Clone)]
2800pub struct kvm_ioeventfd {
2801 pub datamatch: u64,
2802 pub addr: u64,
2803 pub len: u32,
2804 pub fd: i32,
2805 pub flags: u32,
2806 pub pad: [u8; 36usize],
2807}
2808impl Default for kvm_ioeventfd {
2809 fn default() -> Self {
2810 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2811 unsafe {
2812 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2813 s.assume_init()
2814 }
2815 }
2816}
2817#[repr(C)]
2818#[derive(Debug, Copy, Clone)]
2819pub struct kvm_enable_cap {
2820 pub cap: u32,
2821 pub flags: u32,
2822 pub args: [u64; 4usize],
2823 pub pad: [u8; 64usize],
2824}
2825impl Default for kvm_enable_cap {
2826 fn default() -> Self {
2827 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2828 unsafe {
2829 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2830 s.assume_init()
2831 }
2832 }
2833}
2834#[repr(C)]
2835#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, KnownLayout)]
2836pub struct kvm_irq_routing_irqchip {
2837 pub irqchip: u32,
2838 pub pin: u32,
2839}
2840#[repr(C)]
2841#[derive(Copy, Clone, FromBytes, Immutable, KnownLayout)]
2842pub struct kvm_irq_routing_msi {
2843 pub address_lo: u32,
2844 pub address_hi: u32,
2845 pub data: u32,
2846 pub __bindgen_anon_1: kvm_irq_routing_msi__bindgen_ty_1,
2847}
2848#[repr(C)]
2849#[derive(Copy, Clone, FromBytes, Immutable, KnownLayout)]
2850pub union kvm_irq_routing_msi__bindgen_ty_1 {
2851 pub pad: u32,
2852 pub devid: u32,
2853}
2854impl Default for kvm_irq_routing_msi__bindgen_ty_1 {
2855 fn default() -> Self {
2856 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2857 unsafe {
2858 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2859 s.assume_init()
2860 }
2861 }
2862}
2863impl Default for kvm_irq_routing_msi {
2864 fn default() -> Self {
2865 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2866 unsafe {
2867 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2868 s.assume_init()
2869 }
2870 }
2871}
2872#[repr(C)]
2873#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, KnownLayout)]
2874pub struct kvm_irq_routing_s390_adapter {
2875 pub ind_addr: u64,
2876 pub summary_addr: u64,
2877 pub ind_offset: u64,
2878 pub summary_offset: u32,
2879 pub adapter_id: u32,
2880}
2881#[repr(C)]
2882#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, KnownLayout)]
2883pub struct kvm_irq_routing_hv_sint {
2884 pub vcpu: u32,
2885 pub sint: u32,
2886}
2887#[repr(C)]
2888#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, KnownLayout)]
2889pub struct kvm_irq_routing_xen_evtchn {
2890 pub port: u32,
2891 pub vcpu: u32,
2892 pub priority: u32,
2893}
2894#[repr(C)]
2895#[derive(Copy, Clone, FromBytes, Immutable, KnownLayout)]
2896pub struct kvm_irq_routing_entry {
2897 pub gsi: u32,
2898 pub type_: u32,
2899 pub flags: u32,
2900 pub pad: u32,
2901 pub u: kvm_irq_routing_entry__bindgen_ty_1,
2902}
2903#[repr(C)]
2904#[derive(Copy, Clone, FromBytes, Immutable, KnownLayout)]
2905pub union kvm_irq_routing_entry__bindgen_ty_1 {
2906 pub irqchip: kvm_irq_routing_irqchip,
2907 pub msi: kvm_irq_routing_msi,
2908 pub adapter: kvm_irq_routing_s390_adapter,
2909 pub hv_sint: kvm_irq_routing_hv_sint,
2910 pub xen_evtchn: kvm_irq_routing_xen_evtchn,
2911 pub pad: [u32; 8usize],
2912}
2913impl Default for kvm_irq_routing_entry__bindgen_ty_1 {
2914 fn default() -> Self {
2915 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2916 unsafe {
2917 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2918 s.assume_init()
2919 }
2920 }
2921}
2922impl Default for kvm_irq_routing_entry {
2923 fn default() -> Self {
2924 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2925 unsafe {
2926 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2927 s.assume_init()
2928 }
2929 }
2930}
2931#[repr(C)]
2932#[derive(FromBytes, Immutable, KnownLayout)]
2933pub struct kvm_irq_routing<FAM: ?Sized = [kvm_irq_routing_entry; 0]> {
2934 pub nr: u32,
2935 pub flags: u32,
2936 pub entries: FAM,
2937}
2938impl kvm_irq_routing<[kvm_irq_routing_entry]> {}
2939impl kvm_irq_routing<[kvm_irq_routing_entry; 0]> {}
2940impl Default for kvm_irq_routing<[kvm_irq_routing_entry; 0]> {
2941 fn default() -> Self {
2942 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2943 unsafe {
2944 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2945 s.assume_init()
2946 }
2947 }
2948}
2949#[repr(C)]
2950#[derive(Debug, Default, Copy, Clone)]
2951pub struct kvm_irqfd {
2952 pub fd: u32,
2953 pub gsi: u32,
2954 pub flags: u32,
2955 pub resamplefd: u32,
2956 pub pad: [u8; 16usize],
2957}
2958#[repr(C)]
2959#[derive(Debug, Default, Copy, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
2960pub struct kvm_clock_data {
2961 pub clock: u64,
2962 pub flags: u32,
2963 pub pad0: u32,
2964 pub realtime: u64,
2965 pub host_tsc: u64,
2966 pub pad: [u32; 4usize],
2967}
2968#[repr(C)]
2969#[derive(Debug, Default, Copy, Clone)]
2970pub struct kvm_config_tlb {
2971 pub params: u64,
2972 pub array: u64,
2973 pub mmu_type: u32,
2974 pub array_len: u32,
2975}
2976#[repr(C)]
2977#[derive(Debug, Default, Copy, Clone)]
2978pub struct kvm_dirty_tlb {
2979 pub bitmap: u64,
2980 pub num_dirty: u32,
2981}
2982#[repr(C)]
2983#[derive(Debug, Default)]
2984pub struct kvm_reg_list<FAM: ?Sized = [u64; 0]> {
2985 pub n: u64,
2986 pub reg: FAM,
2987}
2988impl kvm_reg_list<[u64]> {}
2989impl kvm_reg_list<[u64; 0]> {}
2990#[repr(C)]
2991#[derive(Debug, Default, Copy, Clone)]
2992pub struct kvm_one_reg {
2993 pub id: u64,
2994 pub addr: u64,
2995}
2996#[repr(C)]
2997#[derive(Debug, Default, Copy, Clone)]
2998pub struct kvm_msi {
2999 pub address_lo: u32,
3000 pub address_hi: u32,
3001 pub data: u32,
3002 pub flags: u32,
3003 pub devid: u32,
3004 pub pad: [u8; 12usize],
3005}
3006#[repr(C)]
3007#[derive(Debug, Default, Copy, Clone)]
3008pub struct kvm_arm_device_addr {
3009 pub id: u64,
3010 pub addr: u64,
3011}
3012#[repr(C)]
3013#[derive(Debug, Default, Copy, Clone)]
3014pub struct kvm_create_device {
3015 pub type_: u32,
3016 pub fd: u32,
3017 pub flags: u32,
3018}
3019#[repr(C)]
3020#[derive(Debug, Default, Copy, Clone)]
3021pub struct kvm_device_attr {
3022 pub flags: u32,
3023 pub group: u32,
3024 pub attr: u64,
3025 pub addr: u64,
3026}
3027pub const kvm_device_type_KVM_DEV_TYPE_FSL_MPIC_20: kvm_device_type = 1;
3028pub const kvm_device_type_KVM_DEV_TYPE_FSL_MPIC_42: kvm_device_type = 2;
3029pub const kvm_device_type_KVM_DEV_TYPE_XICS: kvm_device_type = 3;
3030pub const kvm_device_type_KVM_DEV_TYPE_VFIO: kvm_device_type = 4;
3031pub const kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V2: kvm_device_type = 5;
3032pub const kvm_device_type_KVM_DEV_TYPE_FLIC: kvm_device_type = 6;
3033pub const kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V3: kvm_device_type = 7;
3034pub const kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_ITS: kvm_device_type = 8;
3035pub const kvm_device_type_KVM_DEV_TYPE_XIVE: kvm_device_type = 9;
3036pub const kvm_device_type_KVM_DEV_TYPE_ARM_PV_TIME: kvm_device_type = 10;
3037pub const kvm_device_type_KVM_DEV_TYPE_RISCV_AIA: kvm_device_type = 11;
3038pub const kvm_device_type_KVM_DEV_TYPE_MAX: kvm_device_type = 12;
3039pub type kvm_device_type = ::std::os::raw::c_uint;
3040#[repr(C)]
3041#[derive(Debug, Default, Copy, Clone)]
3042pub struct kvm_vfio_spapr_tce {
3043 pub groupfd: i32,
3044 pub tablefd: i32,
3045}
3046#[repr(C)]
3047#[derive(Debug, Default, Copy, Clone)]
3048pub struct kvm_enc_region {
3049 pub addr: u64,
3050 pub size: u64,
3051}
3052#[repr(C)]
3053#[derive(Debug, Default, Copy, Clone)]
3054pub struct kvm_dirty_gfn {
3055 pub flags: u32,
3056 pub slot: u32,
3057 pub offset: u64,
3058}
3059#[repr(C)]
3060#[derive(Debug, Default, Copy, Clone)]
3061pub struct kvm_stats_header {
3062 pub flags: u32,
3063 pub name_size: u32,
3064 pub num_desc: u32,
3065 pub id_offset: u32,
3066 pub desc_offset: u32,
3067 pub data_offset: u32,
3068}
3069#[repr(C)]
3070#[derive(Debug, Default)]
3071pub struct kvm_stats_desc<FAM: ?Sized = [::std::os::raw::c_char; 0]> {
3072 pub flags: u32,
3073 pub exponent: i16,
3074 pub size: u16,
3075 pub offset: u32,
3076 pub bucket_size: u32,
3077 pub name: FAM,
3078}
3079impl kvm_stats_desc<[::std::os::raw::c_char]> {}
3080impl kvm_stats_desc<[::std::os::raw::c_char; 0]> {}
3081#[repr(C)]
3082#[derive(Debug, Default, Copy, Clone)]
3083pub struct kvm_memory_attributes {
3084 pub address: u64,
3085 pub size: u64,
3086 pub attributes: u64,
3087 pub flags: u64,
3088}
3089#[repr(C)]
3090#[derive(Debug, Default, Copy, Clone)]
3091pub struct kvm_create_guest_memfd {
3092 pub size: u64,
3093 pub flags: u64,
3094 pub reserved: [u64; 6usize],
3095}
3096#[repr(C)]
3097#[derive(Debug, Default, Copy, Clone)]
3098pub struct kvm_pre_fault_memory {
3099 pub gpa: u64,
3100 pub size: u64,
3101 pub flags: u64,
3102 pub padding: [u64; 5usize],
3103}