Alioth Code Coverage

Home / Commit a0deb75 / alioth/src/sys/linux/kvm.rs

kvm.rs0.00%

1// Copyright 2024 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::fmt::{Debug, Formatter, Result};
16
17#[cfg(target_arch = "aarch64")]
18use bitfield::bitfield;
19
20#[cfg(target_arch = "x86_64")]
21use crate::ioctl_writeread_buf;
22use crate::sys::ioctl::ioctl_ior;
23#[cfg(target_arch = "x86_64")]
24use crate::sys::ioctl::ioctl_iowr;
25use crate::{
26 bitflags, consts, ioctl_none, ioctl_read, ioctl_write_buf, ioctl_write_ptr, ioctl_write_val,
27 ioctl_writeread,
28};
29
30pub const KVMIO: u8 = 0xAE;
31pub const KVM_API_VERSION: i32 = 12;
32
33#[cfg(target_arch = "x86_64")]
34consts! {
35 pub struct KvmVmType(u64) {
36 DEFAULT = 0;
37 SW_PROTECTED = 1;
38 SEV = 2;
39 SEV_ES = 3;
40 SNP = 4;
41 TDX = 5;
42 }
43}
44
45#[cfg(target_arch = "aarch64")]
46pub struct KvmVmType(#[allow(dead_code)] pub u64);
47
48#[cfg(target_arch = "x86_64")]
49pub const KVM_MAX_CPUID_ENTRIES: usize = 256;
50
51bitflags! {
52 #[derive(Default)]
53 pub struct KvmCpuid2Flag(u32) {
54 SIGNIFCANT_INDEX = 1 << 0;
55 }
56}
57
58#[cfg(target_arch = "x86_64")]
59#[repr(C)]
60#[derive(Debug, Copy, Clone, Default)]
61pub struct KvmCpuidEntry2 {
62 pub function: u32,
63 pub index: u32,
64 pub flags: KvmCpuid2Flag,
65 pub eax: u32,
66 pub ebx: u32,
67 pub ecx: u32,
68 pub edx: u32,
69 pub padding: [u32; 3],
70}
71
72#[cfg(target_arch = "x86_64")]
73#[repr(C)]
74#[derive(Debug, Clone)]
75pub struct KvmCpuid2<const N: usize> {
76 pub nent: u32,
77 pub padding: u32,
78 pub entries: [KvmCpuidEntry2; N],
79}
80
81pub const KVM_CPUID_SIGNATURE: u32 = 0x4000_0000;
82pub const KVM_CPUID_FEATURES: u32 = 0x4000_0001;
83
84bitflags! {
85 pub struct KvmCpuidFeature(u32) {
86 CLOCKSOURCE = 1 << 0;
87 NOP_IO_DELAY = 1 << 1;
88 MMU_OP = 1 << 2;
89 CLOCKSOURCE2 = 1 << 3;
90 ASYNC_PF = 1 << 4;
91 STEAL_TIME = 1 << 5;
92 PV_EOI = 1 << 6;
93 PV_UNHALT = 1 << 7;
94 PV_TLB_FLUSH = 1 << 9;
95 ASYNC_PF_VMEXIT = 1 << 10;
96 PV_SEND_IPI = 1 << 11;
97 POLL_CONTROL = 1 << 12;
98 PV_SCHED_YIELD = 1 << 13;
99 ASYNC_PF_INT = 1 << 14;
100 MSI_EXT_DEST_ID = 1 << 15;
101 HC_MAP_GPA_RANGE = 1 << 16;
102 MIGRATION_CONTROL = 1 << 17;
103 }
104}
105
106#[cfg(target_arch = "x86_64")]
107#[repr(C)]
108#[derive(Debug, Copy, Clone, Default)]
109pub struct KvmMsrEntry {
110 pub index: u32,
111 pub _reserved: u32,
112 pub data: u64,
113}
114
115#[cfg(target_arch = "x86_64")]
116#[repr(C)]
117#[derive(Debug, Clone)]
118pub struct KvmMsrs<const N: usize> {
119 pub nmsrs: u32,
120 pub _pad: u32,
121 pub entries: [KvmMsrEntry; N],
122}
123
124#[cfg(target_arch = "x86_64")]
125pub const MAX_IO_MSRS: usize = 256;
126
127bitflags! {
128 #[derive(Default)]
129 pub struct KvmMemFlag(u32) {
130 LOG_DIRTY_PAGES = 1 << 0;
131 READONLY = 1 << 1;
132 GUEST_MEMFD = 1 << 2;
133 }
134}
135
136#[repr(C)]
137#[derive(Debug, Copy, Clone)]
138pub struct KvmUserspaceMemoryRegion {
139 pub slot: u32,
140 pub flags: KvmMemFlag,
141 pub guest_phys_addr: u64,
142 pub memory_size: u64,
143 pub userspace_addr: u64,
144}
145
146#[repr(C)]
147#[derive(Debug, Default, Copy, Clone)]
148pub struct KvmUserspaceMemoryRegion2 {
149 pub slot: u32,
150 pub flags: KvmMemFlag,
151 pub guest_phys_addr: u64,
152 pub memory_size: u64,
153 pub userspace_addr: u64,
154 pub guest_memfd_offset: u64,
155 pub guest_memfd: u32,
156 pub _pad1: u32,
157 pub _pad2: [u64; 14],
158}
159
160bitflags! {
161 #[derive(Default)]
162 pub struct KvmMemoryAttribute(u64) {
163 PRIVATE = 1 << 3;
164 }
165}
166
167#[repr(C)]
168#[derive(Debug, Default, Copy, Clone)]
169pub struct KvmMemoryAttributes {
170 pub address: u64,
171 pub size: u64,
172 pub attributes: KvmMemoryAttribute,
173 pub flags: u64,
174}
175
176#[cfg(target_arch = "x86_64")]
177#[repr(C)]
178#[derive(Debug, Copy, Clone, Default)]
179pub struct KvmCreateGuestMemfd {
180 pub size: u64,
181 pub flags: u64,
182 pub reserved: [u64; 6],
183}
184
185#[cfg(target_arch = "x86_64")]
186#[repr(C)]
187#[derive(Debug, Default, Copy, Clone)]
188pub struct KvmRegs {
189 pub rax: u64,
190 pub rbx: u64,
191 pub rcx: u64,
192 pub rdx: u64,
193 pub rsi: u64,
194 pub rdi: u64,
195 pub rsp: u64,
196 pub rbp: u64,
197 pub r8: u64,
198 pub r9: u64,
199 pub r10: u64,
200 pub r11: u64,
201 pub r12: u64,
202 pub r13: u64,
203 pub r14: u64,
204 pub r15: u64,
205 pub rip: u64,
206 pub rflags: u64,
207}
208
209#[cfg(target_arch = "x86_64")]
210#[repr(C)]
211#[derive(Debug, Default, Copy, Clone)]
212pub struct KvmSegment {
213 pub base: u64,
214 pub limit: u32,
215 pub selector: u16,
216 pub type_: u8,
217 pub present: u8,
218 pub dpl: u8,
219 pub db: u8,
220 pub s: u8,
221 pub l: u8,
222 pub g: u8,
223 pub avl: u8,
224 pub unusable: u8,
225 pub padding: u8,
226}
227
228#[cfg(target_arch = "x86_64")]
229#[repr(C)]
230#[derive(Debug, Default, Copy, Clone)]
231pub struct KvmDtable {
232 pub base: u64,
233 pub limit: u16,
234 pub padding: [u16; 3],
235}
236
237#[cfg(target_arch = "x86_64")]
238#[repr(C)]
239#[derive(Debug, Default, Copy, Clone)]
240pub struct KvmSregs {
241 pub cs: KvmSegment,
242 pub ds: KvmSegment,
243 pub es: KvmSegment,
244 pub fs: KvmSegment,
245 pub gs: KvmSegment,
246 pub ss: KvmSegment,
247 pub tr: KvmSegment,
248 pub ldt: KvmSegment,
249 pub gdt: KvmDtable,
250 pub idt: KvmDtable,
251 pub cr0: u64,
252 pub cr2: u64,
253 pub cr3: u64,
254 pub cr4: u64,
255 pub cr8: u64,
256 pub efer: u64,
257 pub apic_base: u64,
258 pub interrupt_bitmap: [u64; 4],
259}
260
261#[cfg(target_arch = "x86_64")]
262#[repr(C)]
263#[derive(Debug, Default, Copy, Clone)]
264pub struct KvmSregs2 {
265 pub cs: KvmSegment,
266 pub ds: KvmSegment,
267 pub es: KvmSegment,
268 pub fs: KvmSegment,
269 pub gs: KvmSegment,
270 pub ss: KvmSegment,
271 pub tr: KvmSegment,
272 pub ldt: KvmSegment,
273 pub gdt: KvmDtable,
274 pub idt: KvmDtable,
275 pub cr0: u64,
276 pub cr2: u64,
277 pub cr3: u64,
278 pub cr4: u64,
279 pub cr8: u64,
280 pub efer: u64,
281 pub apic_base: u64,
282 pub flags: u64,
283 pub pdptrs: [u64; 4],
284}
285
286consts! {
287 pub struct KvmExit(u32) {
288 IO = 2;
289 HYPERCALL = 3;
290 MMIO = 6;
291 SHUTDOWN = 8;
292 SYSTEM_EVENT = 24;
293 MEMORY_FAULT = 39;
294 }
295}
296
297consts! {
298 pub struct KvmSystemEvent(u32) {
299 SHUTDOWN = 1;
300 RESET = 2;
301 }
302}
303
304#[repr(C)]
305#[derive(Debug, Clone, Copy)]
306pub struct KvmRunExitSystemEvent {
307 pub type_: KvmSystemEvent,
308 pub flags: u64,
309}
310
311bitflags! {
312 pub struct KvmMemoryFaultFlag(u64) {
313 PRIVATE = 1 << 3;
314 }
315}
316
317#[repr(C)]
318#[derive(Debug, Clone, Copy)]
319pub struct KvmRunExitMemoryFault {
320 pub flags: KvmMemoryFaultFlag,
321 pub gpa: u64,
322 pub size: u64,
323}
324
325#[repr(C)]
326#[derive(Copy, Clone)]
327pub struct KvmRun {
328 pub request_interrupt_window: u8,
329 pub immediate_exit: u8,
330 pub padding1: [u8; 6],
331 pub exit_reason: KvmExit,
332 pub ready_for_interrupt_injection: u8,
333 pub if_flag: u8,
334 pub flags: u16,
335 pub cr8: u64,
336 pub apic_base: u64,
337 pub exit: KvmRunExit,
338 pub kvm_valid_regs: u64,
339 pub kvm_dirty_regs: u64,
340 pub s: KvmSyncRegsBlock,
341}
342
343#[repr(C)]
344#[derive(Copy, Clone)]
345pub union KvmRunExit {
346 pub mmio: KvmRunExitMmio,
347 pub io: KvmRunExitIo,
348 pub hypercall: KvmRunExitHypercall,
349 pub system_event: KvmRunExitSystemEvent,
350 pub memory_fault: KvmRunExitMemoryFault,
351 pub padding: [u8; 256],
352}
353
354#[repr(C)]
355#[derive(Debug, Clone, Copy)]
356pub struct KvmRunExitMmio {
357 pub phys_addr: u64,
358 pub data: [u8; 8],
359 pub len: u32,
360 pub is_write: u8,
361}
362
363consts! {
364 pub struct KvmExitIo(u8) {
365 IN = 0;
366 OUT = 1;
367 }
368}
369
370#[repr(C)]
371#[derive(Debug, Clone, Copy)]
372pub struct KvmRunExitIo {
373 pub direction: KvmExitIo,
374 pub size: u8,
375 pub port: u16,
376 pub count: u32,
377 pub data_offset: u64,
378}
379
380consts! {
381 pub struct KvmHypercall(u64) {
382 MAP_GPA_RANGE = 12;
383 }
384}
385
386#[repr(C)]
387#[derive(Debug, Copy, Clone)]
388pub struct KvmRunExitHypercall {
389 pub nr: KvmHypercall,
390 pub args: [u64; 6],
391 pub ret: u64,
392 pub flags: u64,
393}
394
395#[repr(C)]
396#[derive(Copy, Clone)]
397pub union KvmSyncRegsBlock {
398 pub padding: [u8; 2048],
399}
400
401bitflags! {
402 #[derive(Default)]
403 pub struct KvmIrqfdFlag(u32) {
404 DEASSIGN = 1 << 0;
405 RESAMPLE = 1 << 1;
406 }
407}
408
409#[repr(C)]
410#[derive(Debug, Default, Copy, Clone)]
411pub struct KvmIrqfd {
412 pub fd: u32,
413 pub gsi: u32,
414 pub flags: KvmIrqfdFlag,
415 pub resamplefd: u32,
416 pub pad: [u8; 16usize],
417}
418
419pub const KVM_IRQ_ROUTING_IRQCHIP: u32 = 1;
420pub const KVM_IRQ_ROUTING_MSI: u32 = 2;
421
422#[cfg(target_arch = "x86_64")]
423pub const KVM_IRQCHIP_IOAPIC: u32 = 2;
424
425#[derive(Debug, Clone, Copy, Default)]
426#[repr(C)]
427pub struct KvmIrqRoutingIrqchip {
428 pub irqchip: u32,
429 pub pin: u32,
430}
431
432#[derive(Clone, Copy, Debug, Default)]
433#[repr(C)]
434pub struct KvmIrqRoutingMsi {
435 pub address_lo: u32,
436 pub address_hi: u32,
437 pub data: u32,
438 pub devid: u32,
439}
440
441#[derive(Clone, Copy)]
442#[repr(C)]
443pub union KvmIrqRoutingType {
444 pub irqchip: KvmIrqRoutingIrqchip,
445 pub msi: KvmIrqRoutingMsi,
446 pub pad: [u32; 8],
447}
448
449impl Debug for KvmIrqRoutingType {
450 fn fmt(&self, f: &mut Formatter<'_>) -> Result {
451 f.debug_list().entries(unsafe { &self.pad }.iter()).finish()
452 }
453}
454
455impl Default for KvmIrqRoutingType {
456 fn default() -> Self {
457 KvmIrqRoutingType { pad: [0; 8] }
458 }
459}
460
461#[derive(Clone, Copy, Default)]
462#[repr(C)]
463pub struct KvmIrqRoutingEntry {
464 pub gsi: u32,
465 pub type_: u32,
466 pub flags: KvmMsiFlag,
467 pub pad: u32,
468 pub routing: KvmIrqRoutingType,
469}
470
471impl Debug for KvmIrqRoutingEntry {
472 fn fmt(&self, f: &mut Formatter<'_>) -> Result {
473 let mut debug_struct = f.debug_struct("KvmIrqRoutingEntry");
474 debug_struct.field("gsi", &self.gsi);
475 debug_struct.field("flags", &self.flags);
476 match self.type_ {
477 KVM_IRQ_ROUTING_IRQCHIP => {
478 debug_struct.field("irqchip", unsafe { &self.routing.irqchip })
479 }
480 KVM_IRQ_ROUTING_MSI => debug_struct.field("msi", unsafe { &self.routing.msi }),
481 _ => debug_struct.field("unknown", unsafe { &self.routing.pad }),
482 };
483 debug_struct.finish()
484 }
485}
486
487#[repr(C)]
488#[derive(Clone, Copy)]
489pub struct KvmIrqRouting<const N: usize> {
490 pub nr: u32,
491 pub _flags: u32,
492 pub entries: [KvmIrqRoutingEntry; N],
493}
494
495impl<const N: usize> Debug for KvmIrqRouting<N> {
496 fn fmt(&self, f: &mut Formatter<'_>) -> Result {
497 f.debug_list()
498 .entries(self.entries.iter().take(self.nr as usize))
499 .finish()
500 }
501}
502
503bitflags! {
504 #[derive(Default)]
505 pub struct KvmMsiFlag(u32) {
506 #[cfg(target_arch = "aarch64")]
507 VALID_DEVID = 1 << 0;
508 }
509}
510
511#[repr(C)]
512#[derive(Debug, Copy, Clone, Default)]
513pub struct KvmMsi {
514 pub address_lo: u32,
515 pub address_hi: u32,
516 pub data: u32,
517 pub flags: KvmMsiFlag,
518 pub devid: u32,
519 pub pad: [u8; 12usize],
520}
521
522consts! {
523 pub struct KvmCap(u32) {
524 IRQFD = 32;
525 KVMCLOCK_CTRL = 76;
526 SIGNAL_MSI = 77;
527 ARM_PSCI_0_2 = 102;
528 SPLIT_IRQCHIP = 121;
529 X2APIC_API = 129;
530 EXIT_HYPERCALL = 201;
531 // GUEST_MEMFD = 234;
532 // VM_TYPES = 235;
533 X86_APIC_BUS_CYCLES_NS = 237;
534 }
535}
536
537bitflags! {
538 pub struct KvmX2apicApiFlag(u64) {
539 USE_32BIT_IDS = 1 << 0;
540 DISABLE_BROADCAST_QUIRK = 1 << 1;
541 }
542}
543
544bitflags! {
545 pub struct KvmMapGpaRangeFlag(u64) {
546 PAGE_2M = 1 << 0;
547 PAGE_1G = 1 << 1;
548 ENCRYPTED = 1 << 4;
549 }
550}
551
552bitflags! {
553 #[derive(Default)]
554 pub struct KvmIoEventFdFlag(u32) {
555 DATA_MATCH = 1 << 0;
556 PIO = 1 << 1;
557 DEASSIGN = 1 << 2;
558 }
559}
560
561#[repr(C)]
562#[derive(Debug, Copy, Clone, Default)]
563pub struct KvmIoEventFd {
564 pub datamatch: u64,
565 pub addr: u64,
566 pub len: u32,
567 pub fd: i32,
568 pub flags: KvmIoEventFdFlag,
569 pub pad: [u32; 9],
570}
571
572#[repr(C)]
573#[derive(Debug, Copy, Clone)]
574pub struct KvmEncRegion {
575 pub addr: u64,
576 pub size: u64,
577}
578
579#[repr(C)]
580#[derive(Debug, Clone)]
581pub struct KvmEnableCap {
582 pub cap: KvmCap,
583 pub flags: u32,
584 pub args: [u64; 4],
585 pub pad: [u8; 64],
586}
587
588#[cfg(not(target_arch = "x86_64"))]
589#[repr(C)]
590#[derive(Debug, Copy, Clone, Default)]
591pub struct KvmOneReg {
592 pub id: u64,
593 pub addr: u64,
594}
595
596#[cfg(target_arch = "aarch64")]
597#[derive(Debug, Clone, Copy)]
598#[repr(C)]
599pub struct KvmCreateDevice {
600 pub type_: KvmDevType,
601 pub fd: i32,
602 pub flags: u32,
603}
604
605#[cfg(target_arch = "aarch64")]
606#[derive(Debug, Clone, Copy, Default)]
607#[repr(C)]
608pub struct KvmDeviceAttr {
609 pub _flags: u32,
610 pub group: u32,
611 pub attr: u64,
612 pub addr: u64,
613}
614
615#[cfg(target_arch = "aarch64")]
616consts! {
617 pub struct KvmDevType(u32) {
618 ARM_VGIC_V2 = 5;
619 ARM_VGIC_V3 = 7;
620 ARM_ITS = 8;
621 }
622}
623
624#[cfg(target_arch = "aarch64")]
625consts! {
626 pub struct KvmDevArmVgicGrp(u32) {
627 ADDR = 0;
628 DIST_REGS = 1;
629 CPU_REGS = 2;
630 NR_IRQS = 3;
631 CTL = 4;
632 REDIS_REG = 5;
633 CPU_SYSREGS = 6;
634 }
635}
636
637#[cfg(target_arch = "aarch64")]
638consts! {
639 pub struct KvmVgicAddrType(u64) {
640 DIST_V2 = 0;
641 CPU_V2 = 1;
642 DIST_V3 = 2;
643 REDIST_V3 = 3;
644 ITS = 4;
645 REDIST_REGION_V3 = 5;
646 }
647}
648
649#[cfg(target_arch = "aarch64")]
650consts! {
651 pub struct KvmDevArmVgicCtrl(u64) {
652 INIT = 0;
653 ITS_SAVE_TABLES = 1;
654 ITS_RESTORE_TABLES = 2;
655 VGIC_SAVE_PENDING_TABLES = 3;
656 ITS_RESET = 4;
657 }
658}
659
660#[cfg(target_arch = "aarch64")]
661bitfield! {
662 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
663 #[repr(transparent)]
664 pub struct KvmVgicV3RedistRegion(u64);
665 impl Debug;
666 pub count, set_count: 63, 52;
667 pub base, set_base: 51, 16;
668 pub index, set_index: 11, 0;
669}
670
671#[cfg(target_arch = "aarch64")]
672#[repr(C)]
673#[derive(Debug, Copy, Clone, Default)]
674pub struct KvmVcpuInit {
675 pub target: u32,
676 pub features: [u32; 7],
677}
678
679bitflags! {
680 pub struct KvmArmVcpuFeature(u32) {
681 POWER_OFF = 1 << 0;
682 EL1_32BIT = 1 << 1;
683 PSCI_0_2 = 1 << 2;
684 PMU_V3 = 1 << 3;
685 }
686}
687
688ioctl_none!(kvm_get_api_version, KVMIO, 0x00);
689ioctl_write_val!(kvm_create_vm, KVMIO, 0x01, KvmVmType);
690ioctl_write_val!(kvm_check_extension, KVMIO, 0x03, KvmCap);
691ioctl_none!(kvm_get_vcpu_mmap_size, KVMIO, 0x04);
692#[cfg(target_arch = "x86_64")]
693ioctl_writeread_buf!(kvm_get_supported_cpuid, KVMIO, 0x05, KvmCpuid2);
694
695ioctl_write_val!(kvm_create_vcpu, KVMIO, 0x41, u32);
696ioctl_write_ptr!(
697 kvm_set_user_memory_region,
698 KVMIO,
699 0x46,
700 KvmUserspaceMemoryRegion
701);
702#[cfg(target_arch = "x86_64")]
703ioctl_write_val!(kvm_set_tss_addr, KVMIO, 0x47, u64);
704#[cfg(target_arch = "x86_64")]
705ioctl_write_ptr!(kvm_set_identity_map_addr, KVMIO, 0x48, u64);
706ioctl_write_ptr!(
707 kvm_set_user_memory_region2,
708 KVMIO,
709 0x49,
710 KvmUserspaceMemoryRegion2
711);
712
713#[cfg(target_arch = "x86_64")]
714ioctl_none!(kvm_create_irqchip, KVMIO, 0x60);
715ioctl_write_buf!(kvm_set_gsi_routing, KVMIO, 0x6a, KvmIrqRouting);
716
717ioctl_write_ptr!(kvm_irqfd, KVMIO, 0x76, KvmIrqfd);
718ioctl_write_ptr!(kvm_ioeventfd, KVMIO, 0x79, KvmIoEventFd);
719
720ioctl_none!(kvm_run, KVMIO, 0x80);
721#[cfg(target_arch = "x86_64")]
722ioctl_read!(kvm_get_regs, KVMIO, 0x81, KvmRegs);
723#[cfg(target_arch = "x86_64")]
724ioctl_write_ptr!(kvm_set_regs, KVMIO, 0x82, KvmRegs);
725#[cfg(target_arch = "x86_64")]
726ioctl_read!(kvm_get_sregs, KVMIO, 0x83, KvmSregs);
727#[cfg(target_arch = "x86_64")]
728ioctl_write_ptr!(kvm_set_sregs, KVMIO, 0x84, KvmSregs);
729#[cfg(target_arch = "x86_64")]
730ioctl_write_buf!(kvm_set_msrs, KVMIO, 0x89, KvmMsrs);
731
732#[cfg(target_arch = "x86_64")]
733ioctl_write_buf!(kvm_set_cpuid2, KVMIO, 0x90, KvmCpuid2);
734
735ioctl_write_ptr!(kvm_enable_cap, KVMIO, 0xa3, KvmEnableCap);
736ioctl_write_ptr!(kvm_signal_msi, KVMIO, 0xa5, KvmMsi);
737
738#[cfg(not(target_arch = "x86_64"))]
739ioctl_write_ptr!(kvm_get_one_reg, KVMIO, 0xab, KvmOneReg);
740#[cfg(not(target_arch = "x86_64"))]
741ioctl_write_ptr!(kvm_set_one_reg, KVMIO, 0xac, KvmOneReg);
742
743ioctl_none!(kvm_kvmclock_ctrl, KVMIO, 0xad);
744
745#[cfg(target_arch = "aarch64")]
746ioctl_write_ptr!(kvm_arm_vcpu_init, KVMIO, 0xae, KvmVcpuInit);
747#[cfg(target_arch = "aarch64")]
748ioctl_read!(kvm_arm_preferred_target, KVMIO, 0xaf, KvmVcpuInit);
749
750#[cfg(target_arch = "x86_64")]
751ioctl_writeread!(kvm_memory_encrypt_op, ioctl_iowr::<u64>(KVMIO, 0xba));
752
753ioctl_write_ptr!(
754 kvm_memory_encrypt_reg_region,
755 ioctl_ior::<KvmEncRegion>(KVMIO, 0xbb),
756 KvmEncRegion
757);
758
759ioctl_write_ptr!(
760 kvm_memory_encrypt_unreg_region,
761 ioctl_ior::<KvmEncRegion>(KVMIO, 0xbc),
762 KvmEncRegion
763);
764
765#[cfg(target_arch = "x86_64")]
766ioctl_read!(kvm_get_sregs2, KVMIO, 0xcc, KvmSregs2);
767#[cfg(target_arch = "x86_64")]
768ioctl_write_ptr!(kvm_set_sregs2, KVMIO, 0xcd, KvmSregs2);
769
770ioctl_write_ptr!(kvm_set_memory_attributes, KVMIO, 0xd2, KvmMemoryAttributes);
771
772#[cfg(target_arch = "x86_64")]
773ioctl_writeread!(kvm_create_guest_memfd, KVMIO, 0xd4, KvmCreateGuestMemfd);
774
775#[cfg(target_arch = "aarch64")]
776ioctl_writeread!(kvm_create_device, KVMIO, 0xe0, KvmCreateDevice);
777#[cfg(target_arch = "aarch64")]
778ioctl_write_ptr!(kvm_set_device_attr, KVMIO, 0xe1, KvmDeviceAttr);
779#[cfg(target_arch = "aarch64")]
780ioctl_write_ptr!(kvm_get_device_attr, KVMIO, 0xe2, KvmDeviceAttr);
781