From b06d296a1b34871683bd6684550441569d5da349 Mon Sep 17 00:00:00 2001 From: Daniel Verkamp Date: Mon, 24 Jun 2024 15:42:40 -0700 Subject: [PATCH] base: define ioctls as consts rather than functions For ioctl numbers that do not require any parameters, make ioctl_io_nr and related macros generate a constant rather than a function with no parameters. This makes the code that uses these constants more idiomatic and also allows using the constants in match statements (see an example in virtio/fs/passthrough.rs). BUG=None TEST=tools/dev_container tools/presubmit Change-Id: Id52817528d770c5dbbe2ce7928c9f31a15c83d83 Reviewed-on: https://chromium-review.googlesource.com/c/crosvm/crosvm/+/5648647 Reviewed-by: Noah Gold Reviewed-by: Frederick Mayle Commit-Queue: Daniel Verkamp --- base/src/sys/linux/ioctl.rs | 16 ++- base/src/sys/linux/mod.rs | 2 +- base/src/sys/windows/ioctl.rs | 15 ++- devices/src/irqchip/kvm/aarch64.rs | 8 +- devices/src/irqchip/kvm/riscv64.rs | 14 +-- .../src/usb/backend/fido_backend/hid_utils.rs | 4 +- devices/src/vfio.rs | 82 ++++++-------- devices/src/virtio/fs/passthrough.rs | 57 ++++------ devices/src/virtio/input/evdev.rs | 12 +- devices/src/virtio/wl.rs | 4 +- e2e_tests/tests/pci_hotplug.rs | 2 +- hypervisor/src/geniezone/mod.rs | 39 +++---- hypervisor/src/gunyah/mod.rs | 26 ++--- hypervisor/src/haxm/vcpu.rs | 20 ++-- hypervisor/src/haxm/vm.rs | 12 +- hypervisor/src/kvm/aarch64.rs | 31 +++--- hypervisor/src/kvm/mod.rs | 42 +++---- hypervisor/src/kvm/riscv64.rs | 4 +- hypervisor/src/kvm/x86_64.rs | 90 +++++++-------- hypervisor/tests/kvm/x86_64.rs | 2 +- kvm/src/lib.rs | 105 +++++++++--------- kvm_sys/tests/basic.rs | 6 +- net_util/src/sys/linux/tap.rs | 8 +- swap/src/userfaultfd.rs | 4 +- usb_util/src/device.rs | 28 ++--- vhost/src/lib.rs | 27 +++-- vhost/src/net.rs | 2 +- vhost/src/vsock.rs | 4 +- vm_memory/src/udmabuf/sys/linux.rs | 2 +- 29 files changed, 316 insertions(+), 352 deletions(-) diff --git a/base/src/sys/linux/ioctl.rs b/base/src/sys/linux/ioctl.rs index 0d83f4e70b..bacf3abd99 100644 --- a/base/src/sys/linux/ioctl.rs +++ b/base/src/sys/linux/ioctl.rs @@ -26,15 +26,13 @@ macro_rules! ioctl_expr { }; } -/// Raw macro to declare a function that returns an ioctl number. +/// Raw macro to declare a constant or a function that returns an ioctl number. #[macro_export] macro_rules! ioctl_ioc_nr { ($name:ident, $dir:expr, $ty:expr, $nr:expr, $size:expr) => { #[allow(non_snake_case)] - /// Generates ioctl request number. - pub const fn $name() -> $crate::linux::IoctlNr { - $crate::ioctl_expr!($dir, $ty, $nr, $size) - } + /// Constant ioctl request number. + pub const $name: $crate::linux::IoctlNr = $crate::ioctl_expr!($dir, $ty, $nr, $size); }; ($name:ident, $dir:expr, $ty:expr, $nr:expr, $size:expr, $($v:ident),+) => { #[allow(non_snake_case)] @@ -233,10 +231,10 @@ mod tests { #[test] fn ioctl_macros() { - assert_eq!(0x0000af01, VHOST_SET_OWNER()); - assert_eq!(0x800454cf, TUNGETFEATURES()); - assert_eq!(0x400454d9, TUNSETQUEUE()); - assert_eq!(0xc004af12, VHOST_GET_VRING_BASE()); + assert_eq!(0x0000af01, VHOST_SET_OWNER); + assert_eq!(0x800454cf, TUNGETFEATURES); + assert_eq!(0x400454d9, TUNSETQUEUE); + assert_eq!(0xc004af12, VHOST_GET_VRING_BASE); assert_eq!(0x80804522, EVIOCGBIT(2)); assert_eq!(0x00004509, FAKE_IOCTL_2_ARG(3, 5)); diff --git a/base/src/sys/linux/mod.rs b/base/src/sys/linux/mod.rs index d667eedcc9..6fabd36105 100644 --- a/base/src/sys/linux/mod.rs +++ b/base/src/sys/linux/mod.rs @@ -263,7 +263,7 @@ pub fn discard_block(file: &F, offset: u64, len: u64) -> Res // - ioctl(BLKDISCARD) does not hold the descriptor after the call. // - ioctl(BLKDISCARD) does not break the file descriptor. // - ioctl(BLKDISCARD) does not modify the given range. - syscall!(unsafe { libc::ioctl(file.as_raw_descriptor(), BLKDISCARD(), &range) }).map(|_| ()) + syscall!(unsafe { libc::ioctl(file.as_raw_descriptor(), BLKDISCARD, &range) }).map(|_| ()) } /// A trait used to abstract types that provide a process id that can be operated on. diff --git a/base/src/sys/windows/ioctl.rs b/base/src/sys/windows/ioctl.rs index 1c4adcda1d..521cf39c11 100644 --- a/base/src/sys/windows/ioctl.rs +++ b/base/src/sys/windows/ioctl.rs @@ -12,7 +12,6 @@ use std::ptr::null_mut; use winapi::um::errhandlingapi::GetLastError; use winapi::um::ioapiset::DeviceIoControl; -pub use winapi::um::winioctl::CTL_CODE; pub use winapi::um::winioctl::FILE_ANY_ACCESS; pub use winapi::um::winioctl::METHOD_BUFFERED; @@ -29,7 +28,7 @@ macro_rules! device_io_control_expr { // just use that for now. However, we may need to support more // options later. ($dtype:expr, $code:expr) => { - $crate::windows::CTL_CODE( + $crate::windows::ctl_code( $dtype, $code, $crate::windows::METHOD_BUFFERED, @@ -43,9 +42,7 @@ macro_rules! device_io_control_expr { macro_rules! ioctl_ioc_nr { ($name:ident, $dtype:expr, $code:expr) => { #[allow(non_snake_case)] - pub fn $name() -> ::std::os::raw::c_ulong { - $crate::device_io_control_expr!($dtype, $code) - } + pub const $name: ::std::os::raw::c_ulong = $crate::device_io_control_expr!($dtype, $code); }; ($name:ident, $dtype:expr, $code:expr, $($v:ident),+) => { #[allow(non_snake_case)] @@ -128,6 +125,14 @@ macro_rules! ioctl_iowr_nr { pub type IoctlNr = c_ulong; +/// Constructs an I/O control code. +/// +/// Shifts control code components into the appropriate bitfield locations: +/// +pub const fn ctl_code(device_type: u32, function: u32, method: u32, access: u32) -> IoctlNr { + (device_type << 16) | (access << 14) | (function << 2) | method +} + /// Run an ioctl with no arguments. // (colindr) b/144457461 : This will probably not be used on windows. // It's only used on linux for the ioctls that override the exit code to diff --git a/devices/src/irqchip/kvm/aarch64.rs b/devices/src/irqchip/kvm/aarch64.rs index f88d99b0f8..08cff517c7 100644 --- a/devices/src/irqchip/kvm/aarch64.rs +++ b/devices/src/irqchip/kvm/aarch64.rs @@ -107,14 +107,14 @@ impl KvmKernelIrqChip { // SAFETY: // Safe because we allocated the struct that's being passed in - let ret = unsafe { ioctl_with_ref(&vgic, KVM_SET_DEVICE_ATTR(), &cpu_redist_attr) }; + let ret = unsafe { ioctl_with_ref(&vgic, KVM_SET_DEVICE_ATTR, &cpu_redist_attr) }; if ret != 0 { return errno_result(); } // SAFETY: // Safe because we allocated the struct that's being passed in - let ret = unsafe { ioctl_with_ref(&vgic, KVM_SET_DEVICE_ATTR(), &dist_attr) }; + let ret = unsafe { ioctl_with_ref(&vgic, KVM_SET_DEVICE_ATTR, &dist_attr) }; if ret != 0 { return errno_result(); } @@ -130,7 +130,7 @@ impl KvmKernelIrqChip { }; // SAFETY: // Safe because we allocated the struct that's being passed in - let ret = unsafe { ioctl_with_ref(&vgic, KVM_SET_DEVICE_ATTR(), &nr_irqs_attr) }; + let ret = unsafe { ioctl_with_ref(&vgic, KVM_SET_DEVICE_ATTR, &nr_irqs_attr) }; if ret != 0 { return errno_result(); } @@ -183,7 +183,7 @@ impl IrqChipAArch64 for KvmKernelIrqChip { // SAFETY: // Safe because we allocated the struct that's being passed in - let ret = unsafe { ioctl_with_ref(&self.vgic, KVM_SET_DEVICE_ATTR(), &init_gic_attr) }; + let ret = unsafe { ioctl_with_ref(&self.vgic, KVM_SET_DEVICE_ATTR, &init_gic_attr) }; if ret != 0 { return errno_result(); } diff --git a/devices/src/irqchip/kvm/riscv64.rs b/devices/src/irqchip/kvm/riscv64.rs index 0e653d6697..56a0a21638 100644 --- a/devices/src/irqchip/kvm/riscv64.rs +++ b/devices/src/irqchip/kvm/riscv64.rs @@ -81,7 +81,7 @@ impl AiaDescriptor { // Safe because we allocated the struct that's being passed in, and raw_aia_mode is pointing // to a uniquely owned local, mutable variable. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR(), &init_attr) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR, &init_attr) }; if ret != 0 { return errno_result(); } @@ -101,7 +101,7 @@ impl AiaDescriptor { // Safe because we allocated the struct that's being passed in, and raw_num_ids is pointing // to a uniquely owned local, mutable variable. - let ret = unsafe { ioctl_with_ref(self, KVM_GET_DEVICE_ATTR(), &aia_num_ids_attr) }; + let ret = unsafe { ioctl_with_ref(self, KVM_GET_DEVICE_ATTR, &aia_num_ids_attr) }; if ret != 0 { return errno_result(); } @@ -119,7 +119,7 @@ impl AiaDescriptor { }; // Safe because we allocated the struct that's being passed in, and raw_aia_mode is pointing // to a uniquely owned local, mutable variable. - let ret = unsafe { ioctl_with_ref(self, KVM_GET_DEVICE_ATTR(), &aia_mode_attr) }; + let ret = unsafe { ioctl_with_ref(self, KVM_GET_DEVICE_ATTR, &aia_mode_attr) }; if ret != 0 { return errno_result(); } @@ -136,7 +136,7 @@ impl AiaDescriptor { }; // Safe because we allocated the struct that's being passed in, and raw_aia_mode is pointing // to a uniquely owned local, mutable variable. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR(), &kvm_attr) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR, &kvm_attr) }; if ret != 0 { return errno_result(); } @@ -153,7 +153,7 @@ impl AiaDescriptor { }; // Safe because we allocated the struct that's being passed in, and raw_aia_mode is pointing // to a uniquely owned local, mutable variable. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR(), &kvm_attr) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR, &kvm_attr) }; if ret != 0 { return errno_result(); } @@ -172,7 +172,7 @@ impl AiaDescriptor { }; // Safe because we allocated the struct that's being passed in, and raw_aplic_addr is // pointing to a uniquely owned local, mutable variable. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR(), &kvm_attr) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR, &kvm_attr) }; if ret != 0 { return errno_result(); } @@ -187,7 +187,7 @@ impl AiaDescriptor { }; // Safe because we allocated the struct that's being passed in, and raw_imsic_addr is // pointing to a uniquely owned local, mutable variable. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR(), &kvm_attr) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR, &kvm_attr) }; if ret != 0 { return errno_result(); } diff --git a/devices/src/usb/backend/fido_backend/hid_utils.rs b/devices/src/usb/backend/fido_backend/hid_utils.rs index 597521b1b1..99101e63e2 100644 --- a/devices/src/usb/backend/fido_backend/hid_utils.rs +++ b/devices/src/usb/backend/fido_backend/hid_utils.rs @@ -35,7 +35,7 @@ pub fn verify_is_fido_device(hidraw: &File) -> Result<()> { unsafe { let ret = handle_eintr_errno!(base::ioctl_with_mut_ref( hidraw, - HIDIOCGRDESCSIZE(), + HIDIOCGRDESCSIZE, &mut desc_size )); if ret < 0 || (desc_size as usize) < constants::HID_REPORT_DESC_HEADER.len() { @@ -55,7 +55,7 @@ pub fn verify_is_fido_device(hidraw: &File) -> Result<()> { unsafe { let ret = handle_eintr_errno!(base::ioctl_with_mut_ref( hidraw, - HIDIOCGRDESC(), + HIDIOCGRDESC, &mut descriptor )); if ret < 0 { diff --git a/devices/src/vfio.rs b/devices/src/vfio.rs index 5f21e53907..e1fca79f46 100644 --- a/devices/src/vfio.rs +++ b/devices/src/vfio.rs @@ -219,13 +219,8 @@ impl KvmVfioPviommu { // SAFETY: // Safe as we are the owner of vfio_dev_attr, which is valid. - let ret = unsafe { - ioctl_with_ref( - kvm_vfio_file, - kvm_sys::KVM_SET_DEVICE_ATTR(), - &vfio_dev_attr, - ) - }; + let ret = + unsafe { ioctl_with_ref(kvm_vfio_file, kvm_sys::KVM_SET_DEVICE_ATTR, &vfio_dev_attr) }; if ret < 0 { Err(VfioError::KvmSetDeviceAttr(get_error())) @@ -283,13 +278,8 @@ impl KvmVfioPviommu { // SAFETY: // Safe as we are the owner of vfio_dev_attr, which is valid. - let ret = unsafe { - ioctl_with_ref( - kvm_vfio_file, - kvm_sys::KVM_SET_DEVICE_ATTR(), - &vfio_dev_attr, - ) - }; + let ret = + unsafe { ioctl_with_ref(kvm_vfio_file, kvm_sys::KVM_SET_DEVICE_ATTR, &vfio_dev_attr) }; if ret < 0 { Err(VfioError::KvmSetDeviceAttr(get_error())) @@ -348,7 +338,7 @@ impl VfioContainer { pub fn new_from_container(container: File) -> Result { // SAFETY: // Safe as file is vfio container descriptor and ioctl is defined by kernel. - let version = unsafe { ioctl(&container, VFIO_GET_API_VERSION()) }; + let version = unsafe { ioctl(&container, VFIO_GET_API_VERSION) }; if version as u8 != VFIO_API_VERSION { return Err(VfioError::VfioApiVersion); } @@ -367,14 +357,14 @@ impl VfioContainer { fn check_extension(&self, val: IommuType) -> bool { // SAFETY: // Safe as file is vfio container and make sure val is valid. - let ret = unsafe { ioctl_with_val(self, VFIO_CHECK_EXTENSION(), val as c_ulong) }; + let ret = unsafe { ioctl_with_val(self, VFIO_CHECK_EXTENSION, val as c_ulong) }; ret != 0 } fn set_iommu(&mut self, val: IommuType) -> i32 { // SAFETY: // Safe as file is vfio container and make sure val is valid. - unsafe { ioctl_with_val(self, VFIO_SET_IOMMU(), val as c_ulong) } + unsafe { ioctl_with_val(self, VFIO_SET_IOMMU, val as c_ulong) } } fn set_iommu_checked(&mut self, val: IommuType) -> Result<()> { @@ -431,7 +421,7 @@ impl VfioContainer { dma_map.flags |= VFIO_DMA_MAP_FLAG_WRITE; } - let ret = ioctl_with_ref(self, VFIO_IOMMU_MAP_DMA(), &dma_map); + let ret = ioctl_with_ref(self, VFIO_IOMMU_MAP_DMA, &dma_map); if ret != 0 { return Err(VfioError::IommuDmaMap(get_error())); } @@ -463,7 +453,7 @@ impl VfioContainer { // SAFETY: // Safe as file is vfio container, dma_unmap is constructed by us, and // we check the return value - let ret = unsafe { ioctl_with_mut_ref(self, VFIO_IOMMU_UNMAP_DMA(), &mut dma_unmap) }; + let ret = unsafe { ioctl_with_mut_ref(self, VFIO_IOMMU_UNMAP_DMA, &mut dma_unmap) }; if ret != 0 || dma_unmap.size != size { return Err(VfioError::IommuDmaUnmap(get_error())); } @@ -494,7 +484,7 @@ impl VfioContainer { // SAFETY: // Safe as file is vfio container, iommu_info has valid values, // and we check the return value - let ret = unsafe { ioctl_with_mut_ref(self, VFIO_IOMMU_GET_INFO(), &mut iommu_info) }; + let ret = unsafe { ioctl_with_mut_ref(self, VFIO_IOMMU_GET_INFO, &mut iommu_info) }; if ret != 0 || (iommu_info.flags & VFIO_IOMMU_INFO_PGSIZES) == 0 { return Err(VfioError::IommuGetInfo(get_error())); } @@ -526,7 +516,7 @@ impl VfioContainer { // SAFETY: // Safe as file is vfio container, iommu_info_argsz has valid values, // and we check the return value - let ret = unsafe { ioctl_with_mut_ref(self, VFIO_IOMMU_GET_INFO(), &mut iommu_info_argsz) }; + let ret = unsafe { ioctl_with_mut_ref(self, VFIO_IOMMU_GET_INFO, &mut iommu_info_argsz) }; if ret != 0 { return Err(VfioError::IommuGetInfo(get_error())); } @@ -543,7 +533,7 @@ impl VfioContainer { // SAFETY: // Safe as file is vfio container, iommu_info has valid values, // and we check the return value - unsafe { ioctl_with_mut_ptr(self, VFIO_IOMMU_GET_INFO(), iommu_info.as_mut_ptr()) }; + unsafe { ioctl_with_mut_ptr(self, VFIO_IOMMU_GET_INFO, iommu_info.as_mut_ptr()) }; if ret != 0 { return Err(VfioError::IommuGetInfo(get_error())); } @@ -745,7 +735,7 @@ impl VfioGroup { let mut ret = // SAFETY: // Safe as we are the owner of group_file and group_status which are valid value. - unsafe { ioctl_with_mut_ref(&group_file, VFIO_GROUP_GET_STATUS(), &mut group_status) }; + unsafe { ioctl_with_mut_ref(&group_file, VFIO_GROUP_GET_STATUS, &mut group_status) }; if ret < 0 { return Err(VfioError::GetGroupStatus(get_error())); } @@ -761,7 +751,7 @@ impl VfioGroup { ret = unsafe { ioctl_with_ref( &group_file, - VFIO_GROUP_SET_CONTAINER(), + VFIO_GROUP_SET_CONTAINER, &container_raw_descriptor, ) }; @@ -817,11 +807,7 @@ impl VfioGroup { // Safe as we are the owner of vfio_dev_descriptor and vfio_dev_attr which are valid value, // and we verify the return value. if 0 != unsafe { - ioctl_with_ref( - kvm_vfio_file, - kvm_sys::KVM_SET_DEVICE_ATTR(), - &vfio_dev_attr, - ) + ioctl_with_ref(kvm_vfio_file, kvm_sys::KVM_SET_DEVICE_ATTR, &vfio_dev_attr) } { return Err(VfioError::KvmSetDeviceAttr(get_error())); } @@ -835,7 +821,7 @@ impl VfioGroup { // SAFETY: // Safe as we are the owner of self and path_ptr which are valid value. - let ret = unsafe { ioctl_with_ptr(self, VFIO_GROUP_GET_DEVICE_FD(), path_ptr) }; + let ret = unsafe { ioctl_with_ptr(self, VFIO_GROUP_GET_DEVICE_FD, path_ptr) }; if ret < 0 { return Err(VfioError::GroupGetDeviceFD(get_error())); } @@ -1168,7 +1154,7 @@ impl VfioDevice { device_feature[0].flags = VFIO_DEVICE_FEATURE_SET | VFIO_DEVICE_FEATURE_LOW_POWER_ENTRY; // SAFETY: // Safe as we are the owner of self and power_management which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_FEATURE(), &device_feature[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_FEATURE, &device_feature[0]) }; if ret < 0 { Err(VfioError::VfioPmLowPowerEnter(get_error())) } else { @@ -1200,7 +1186,7 @@ impl VfioDevice { } // SAFETY: // Safe as we are the owner of self and power_management which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_FEATURE(), &device_feature[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_FEATURE, &device_feature[0]) }; if ret < 0 { Err(VfioError::VfioPmLowPowerEnter(get_error())) } else { @@ -1215,7 +1201,7 @@ impl VfioDevice { device_feature[0].flags = VFIO_DEVICE_FEATURE_SET | VFIO_DEVICE_FEATURE_LOW_POWER_EXIT; // SAFETY: // Safe as we are the owner of self and power_management which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_FEATURE(), &device_feature[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_FEATURE, &device_feature[0]) }; if ret < 0 { Err(VfioError::VfioPmLowPowerExit(get_error())) } else { @@ -1236,7 +1222,7 @@ impl VfioDevice { } // SAFETY: // Safe as we are the owner of self and dsm which are valid value - let ret = unsafe { ioctl_with_mut_ref(&self.dev, VFIO_DEVICE_ACPI_DSM(), &mut dsm[0]) }; + let ret = unsafe { ioctl_with_mut_ref(&self.dev, VFIO_DEVICE_ACPI_DSM, &mut dsm[0]) }; if ret < 0 { Err(VfioError::VfioAcpiDsm(get_error())) } else { @@ -1270,7 +1256,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of self and irq_set which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS(), &irq_set[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS, &irq_set[0]) }; if ret < 0 { Err(VfioError::VfioAcpiNotificationEnable(get_error())) } else { @@ -1289,7 +1275,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of self and irq_set which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS(), &irq_set[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS, &irq_set[0]) }; if ret < 0 { Err(VfioError::VfioAcpiNotificationDisable(get_error())) } else { @@ -1316,7 +1302,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of self and irq_set which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS(), &irq_set[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS, &irq_set[0]) }; if ret < 0 { Err(VfioError::VfioAcpiNotificationTest(get_error())) } else { @@ -1363,7 +1349,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of self and irq_set which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS(), &irq_set[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS, &irq_set[0]) }; if ret < 0 { Err(VfioError::VfioIrqEnable(get_error())) } else { @@ -1400,7 +1386,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of self and irq_set which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS(), &irq_set[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS, &irq_set[0]) }; if ret < 0 { Err(VfioError::VfioIrqEnable(get_error())) } else { @@ -1419,7 +1405,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of self and irq_set which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS(), &irq_set[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS, &irq_set[0]) }; if ret < 0 { Err(VfioError::VfioIrqDisable(get_error())) } else { @@ -1438,7 +1424,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of self and irq_set which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS(), &irq_set[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS, &irq_set[0]) }; if ret < 0 { Err(VfioError::VfioIrqUnmask(get_error())) } else { @@ -1457,7 +1443,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of self and irq_set which are valid value - let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS(), &irq_set[0]) }; + let ret = unsafe { ioctl_with_ref(&self.dev, VFIO_DEVICE_SET_IRQS, &irq_set[0]) }; if ret < 0 { Err(VfioError::VfioIrqMask(get_error())) } else { @@ -1478,7 +1464,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of device_file and dev_info which are valid value, // and we verify the return value. - let ret = unsafe { ioctl_with_mut_ref(device_file, VFIO_DEVICE_GET_INFO(), &mut dev_info) }; + let ret = unsafe { ioctl_with_mut_ref(device_file, VFIO_DEVICE_GET_INFO, &mut dev_info) }; if ret < 0 { return Err(VfioError::VfioDeviceGetInfo(get_error())); } @@ -1517,11 +1503,7 @@ impl VfioDevice { // Safe as we are the owner of dev and irq_info which are valid value, // and we verify the return value. let ret = unsafe { - ioctl_with_mut_ref( - self.device_file(), - VFIO_DEVICE_GET_IRQ_INFO(), - &mut irq_info, - ) + ioctl_with_mut_ref(self.device_file(), VFIO_DEVICE_GET_IRQ_INFO, &mut irq_info) }; if ret < 0 || irq_info.count != 1 { return Err(VfioError::VfioDeviceGetInfo(get_error())); @@ -1553,7 +1535,7 @@ impl VfioDevice { // SAFETY: // Safe as we are the owner of dev and reg_info which are valid value, // and we verify the return value. - unsafe { ioctl_with_mut_ref(dev, VFIO_DEVICE_GET_REGION_INFO(), &mut reg_info) }; + unsafe { ioctl_with_mut_ref(dev, VFIO_DEVICE_GET_REGION_INFO, &mut reg_info) }; if ret < 0 { continue; } @@ -1576,7 +1558,7 @@ impl VfioDevice { let ret = unsafe { ioctl_with_mut_ref( dev, - VFIO_DEVICE_GET_REGION_INFO(), + VFIO_DEVICE_GET_REGION_INFO, &mut (region_with_cap[0].region_info), ) }; diff --git a/devices/src/virtio/fs/passthrough.rs b/devices/src/virtio/fs/passthrough.rs index 0e8a8bf8d3..3f61afe1fb 100644 --- a/devices/src/virtio/fs/passthrough.rs +++ b/devices/src/virtio/fs/passthrough.rs @@ -41,6 +41,7 @@ use base::unix::FileFlags; use base::warn; use base::AsRawDescriptor; use base::FromRawDescriptor; +use base::IoctlNr; use base::Protection; use base::RawDescriptor; use fuse::filesystem::Context; @@ -1317,7 +1318,7 @@ impl PassthroughFs { let res = // SAFETY: the kernel will only write to `arg` and we check the return value. - unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_GET_ENCRYPTION_POLICY_EX(), &mut arg) }; + unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_GET_ENCRYPTION_POLICY_EX, &mut arg) }; if res < 0 { Ok(IoctlReply::Done(Err(io::Error::last_os_error()))) } else { @@ -1336,7 +1337,7 @@ impl PassthroughFs { let mut buf = MaybeUninit::::zeroed(); // SAFETY: the kernel will only write to `buf` and we check the return value. - let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_FSGETXATTR(), buf.as_mut_ptr()) }; + let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_FSGETXATTR, buf.as_mut_ptr()) }; if res < 0 { Ok(IoctlReply::Done(Err(io::Error::last_os_error()))) } else { @@ -1372,7 +1373,7 @@ impl PassthroughFs { // Get the current fsxattr. let mut buf = MaybeUninit::::zeroed(); // SAFETY: the kernel will only write to `buf` and we check the return value. - let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_FSGETXATTR(), buf.as_mut_ptr()) }; + let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_FSGETXATTR, buf.as_mut_ptr()) }; if res < 0 { return Ok(IoctlReply::Done(Err(io::Error::last_os_error()))); } @@ -1411,7 +1412,7 @@ impl PassthroughFs { } // SAFETY: this doesn't modify any memory and we check the return value. - let res = unsafe { ioctl_with_ptr(&*data, FS_IOC_FSSETXATTR(), &in_attr) }; + let res = unsafe { ioctl_with_ptr(&*data, FS_IOC_FSSETXATTR, &in_attr) }; if res < 0 { Ok(IoctlReply::Done(Err(io::Error::last_os_error()))) } else { @@ -1430,7 +1431,7 @@ impl PassthroughFs { let mut flags: c_int = 0; // SAFETY: the kernel will only write to `flags` and we check the return value. - let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_GETFLAGS(), &mut flags) }; + let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_GETFLAGS, &mut flags) }; if res < 0 { Ok(IoctlReply::Done(Err(io::Error::last_os_error()))) } else { @@ -1464,7 +1465,7 @@ impl PassthroughFs { // Get the current flag. let mut buf = MaybeUninit::::zeroed(); // SAFETY: the kernel will only write to `buf` and we check the return value. - let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_GETFLAGS(), buf.as_mut_ptr()) }; + let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_GETFLAGS, buf.as_mut_ptr()) }; if res < 0 { return Ok(IoctlReply::Done(Err(io::Error::last_os_error()))); } @@ -1502,7 +1503,7 @@ impl PassthroughFs { } // SAFETY: this doesn't modify any memory and we check the return value. - let res = unsafe { ioctl_with_ptr(&*data, FS_IOC_SETFLAGS(), &in_flags) }; + let res = unsafe { ioctl_with_ptr(&*data, FS_IOC_SETFLAGS, &in_flags) }; if res < 0 { Ok(IoctlReply::Done(Err(io::Error::last_os_error()))) } else { @@ -1599,7 +1600,7 @@ impl PassthroughFs { } // SAFETY: this doesn't modify any memory and we check the return value. - let res = unsafe { ioctl_with_ptr(&*data, FS_IOC_ENABLE_VERITY(), &arg) }; + let res = unsafe { ioctl_with_ptr(&*data, FS_IOC_ENABLE_VERITY, &arg) }; if res < 0 { Ok(IoctlReply::Done(Err(io::Error::last_os_error()))) } else { @@ -1643,7 +1644,7 @@ impl PassthroughFs { }; // SAFETY: this will only modify `buf` and we check the return value. - let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_MEASURE_VERITY(), buf.as_mut_ptr()) }; + let res = unsafe { ioctl_with_mut_ptr(&*data, FS_IOC_MEASURE_VERITY, buf.as_mut_ptr()) }; if res < 0 { Ok(IoctlReply::Done(Err(io::Error::last_os_error()))) } else { @@ -3173,60 +3174,44 @@ impl FileSystem for PassthroughFs { ) -> io::Result { let _trace = fs_trace!(self.tag, "ioctl", inode, handle, cmd, in_size, out_size); - const GET_ENCRYPTION_POLICY_EX: u32 = FS_IOC_GET_ENCRYPTION_POLICY_EX() as u32; - const GET_FSXATTR: u32 = FS_IOC_FSGETXATTR() as u32; - const SET_FSXATTR: u32 = FS_IOC_FSSETXATTR() as u32; - const GET_FLAGS32: u32 = FS_IOC32_GETFLAGS() as u32; - const SET_FLAGS32: u32 = FS_IOC32_SETFLAGS() as u32; - const GET_FLAGS64: u32 = FS_IOC64_GETFLAGS() as u32; - const SET_FLAGS64: u32 = FS_IOC64_SETFLAGS() as u32; - const ENABLE_VERITY: u32 = FS_IOC_ENABLE_VERITY() as u32; - const MEASURE_VERITY: u32 = FS_IOC_MEASURE_VERITY() as u32; - // The following is ARCVM-specific ioctl - // Refer go/remove-mount-passthrough-fuse for more design details - #[cfg(feature = "arc_quota")] - const SET_PERMISSION: u32 = FS_IOC_SETPERMISSION() as u32; - #[cfg(feature = "arc_quota")] - const SETPATHXATTR: u32 = FS_IOC_SETPATHXATTR() as u32; - - match cmd { - GET_ENCRYPTION_POLICY_EX => self.get_encryption_policy_ex(inode, handle, r), - GET_FSXATTR => { + match cmd as IoctlNr { + FS_IOC_GET_ENCRYPTION_POLICY_EX => self.get_encryption_policy_ex(inode, handle, r), + FS_IOC_FSGETXATTR => { if out_size < size_of::() as u32 { Err(io::Error::from_raw_os_error(libc::ENOMEM)) } else { self.get_fsxattr(inode, handle) } } - SET_FSXATTR => { + FS_IOC_FSSETXATTR => { if in_size < size_of::() as u32 { Err(io::Error::from_raw_os_error(libc::EINVAL)) } else { self.set_fsxattr(ctx, inode, handle, r) } } - GET_FLAGS32 | GET_FLAGS64 => { + FS_IOC32_GETFLAGS | FS_IOC64_GETFLAGS => { if out_size < size_of::() as u32 { Err(io::Error::from_raw_os_error(libc::ENOMEM)) } else { self.get_flags(inode, handle) } } - SET_FLAGS32 | SET_FLAGS64 => { + FS_IOC32_SETFLAGS | FS_IOC64_SETFLAGS => { if in_size < size_of::() as u32 { Err(io::Error::from_raw_os_error(libc::ENOMEM)) } else { self.set_flags(ctx, inode, handle, r) } } - ENABLE_VERITY => { + FS_IOC_ENABLE_VERITY => { if in_size < size_of::() as u32 { Err(io::Error::from_raw_os_error(libc::ENOMEM)) } else { self.enable_verity(inode, handle, r) } } - MEASURE_VERITY => { + FS_IOC_MEASURE_VERITY => { if in_size < size_of::() as u32 || out_size < size_of::() as u32 { @@ -3235,8 +3220,10 @@ impl FileSystem for PassthroughFs { self.measure_verity(inode, handle, r, out_size) } } + // The following is ARCVM-specific ioctl + // Refer go/remove-mount-passthrough-fuse for more design details #[cfg(feature = "arc_quota")] - SET_PERMISSION => { + FS_IOC_SETPERMISSION => { if in_size == 0 { Err(io::Error::from_raw_os_error(libc::EINVAL)) } else { @@ -3244,7 +3231,7 @@ impl FileSystem for PassthroughFs { } } #[cfg(feature = "arc_quota")] - SETPATHXATTR => { + FS_IOC_SETPATHXATTR => { if in_size == 0 { Err(io::Error::from_raw_os_error(libc::EINVAL)) } else { diff --git a/devices/src/virtio/input/evdev.rs b/devices/src/virtio/input/evdev.rs index 07a2e2f2d3..a2b8b5c07f 100644 --- a/devices/src/virtio/input/evdev.rs +++ b/devices/src/virtio/input/evdev.rs @@ -119,7 +119,7 @@ pub fn device_ids(descriptor: &T) -> Result(descriptor: &T) -> Result> { // SAFETY: // Safe because the kernel won't write more than size of evdev_buffer and we check the // return value - unsafe { ioctl_with_mut_ref(descriptor, EVIOCGNAME(), &mut name) } + unsafe { ioctl_with_mut_ref(descriptor, EVIOCGNAME, &mut name) } }; if len < 0 { return Err(InputError::EvdevNameError(errno())); @@ -154,7 +154,7 @@ pub fn serial_name(descriptor: &T) -> Result> { // SAFETY: // Safe because the kernel won't write more than size of evdev_buffer and we check the // return value - unsafe { ioctl_with_mut_ref(descriptor, EVIOCGUNIQ(), &mut uniq) } + unsafe { ioctl_with_mut_ref(descriptor, EVIOCGUNIQ, &mut uniq) } }; if len < 0 { return Err(InputError::EvdevSerialError(errno())); @@ -169,7 +169,7 @@ pub fn properties(descriptor: &T) -> Result(descriptor: &mut T) -> Result<()> { let ret = { // SAFETY: // Safe because the kernel only read the value of the ptr and we check the return value - unsafe { ioctl_with_ref(descriptor, EVIOCGRAB(), &val) } + unsafe { ioctl_with_ref(descriptor, EVIOCGRAB, &val) } }; if ret == 0 { Ok(()) @@ -259,7 +259,7 @@ pub fn ungrab_evdev(descriptor: &mut T) -> Result<()> { // SAFETY: // Safe because the kernel only reads the value of the ptr (doesn't dereference) and // we check the return value - unsafe { ioctl_with_ptr(descriptor, EVIOCGRAB(), null::()) } + unsafe { ioctl_with_ptr(descriptor, EVIOCGRAB, null::()) } }; if ret == 0 { Ok(()) diff --git a/devices/src/virtio/wl.rs b/devices/src/virtio/wl.rs index 67078947ad..dc542fe80e 100644 --- a/devices/src/virtio/wl.rs +++ b/devices/src/virtio/wl.rs @@ -234,7 +234,7 @@ fn is_fence(f: &File) -> bool { let info = sync_file_info::default(); // SAFETY: // Safe as f is a valid file - unsafe { ioctl_with_ref(f, SYNC_IOC_FILE_INFO(), &info) == 0 } + unsafe { ioctl_with_ref(f, SYNC_IOC_FILE_INFO, &info) == 0 } } #[cfg(feature = "minigbm")] @@ -918,7 +918,7 @@ impl WlVfd { }; // SAFETY: // Safe as descriptor is a valid dmabuf and incorrect flags will return an error. - if unsafe { ioctl_with_ref(descriptor, DMA_BUF_IOCTL_SYNC(), &sync) } < 0 { + if unsafe { ioctl_with_ref(descriptor, DMA_BUF_IOCTL_SYNC, &sync) } < 0 { return Err(WlError::DmabufSync(io::Error::last_os_error())); } diff --git a/e2e_tests/tests/pci_hotplug.rs b/e2e_tests/tests/pci_hotplug.rs index c08fb384e6..8bd8ae08f0 100644 --- a/e2e_tests/tests/pci_hotplug.rs +++ b/e2e_tests/tests/pci_hotplug.rs @@ -49,7 +49,7 @@ fn setup_tap_device(tap_name: &[u8], ip_addr: Ipv4Addr, netmask: Ipv4Addr, mac_a let tap = Tap::new_with_name(tap_name, true, false).unwrap(); // SAFETY: // ioctl is safe since we call it with a valid tap fd and check the return value. - let ret = unsafe { ioctl_with_val(&tap, net_sys::TUNSETPERSIST(), 1) }; + let ret = unsafe { ioctl_with_val(&tap, net_sys::TUNSETPERSIST, 1) }; if ret < 0 { panic!("Failed to persist tap interface"); } diff --git a/hypervisor/src/geniezone/mod.rs b/hypervisor/src/geniezone/mod.rs index b97d5a9cd6..01a3e68234 100644 --- a/hypervisor/src/geniezone/mod.rs +++ b/hypervisor/src/geniezone/mod.rs @@ -82,13 +82,8 @@ impl Geniezone { pub fn get_guest_phys_addr_bits(&self) -> u8 { // SAFETY: // Safe because we know self is a real geniezone fd - match unsafe { - ioctl_with_val( - self, - GZVM_CHECK_EXTENSION(), - GZVM_CAP_ARM_VM_IPA_SIZE.into(), - ) - } { + match unsafe { ioctl_with_val(self, GZVM_CHECK_EXTENSION, GZVM_CAP_ARM_VM_IPA_SIZE.into()) } + { // Default physical address size is 40 bits if the extension is not supported. ret if ret <= 0 => 40, ipa => ipa as u8, @@ -198,7 +193,7 @@ impl VmAArch64 for GeniezoneVm { // SAFETY: // Safe because we allocated the struct and we know the kernel will modify exactly the size // of the struct. - let ret = unsafe { ioctl_with_ref(self, GZVM_SET_DTB_CONFIG(), &dtb_config) }; + let ret = unsafe { ioctl_with_ref(self, GZVM_SET_DTB_CONFIG, &dtb_config) }; if ret == 0 { Ok(()) } else { @@ -226,7 +221,7 @@ impl GeniezoneVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, GZVM_SET_ONE_REG(), &onereg) }; + let ret = unsafe { ioctl_with_ref(self, GZVM_SET_ONE_REG, &onereg) }; if ret == 0 { Ok(()) } else { @@ -255,7 +250,7 @@ impl GeniezoneVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, GZVM_GET_ONE_REG(), &onereg) }; + let ret = unsafe { ioctl_with_ref(self, GZVM_GET_ONE_REG, &onereg) }; if ret == 0 { Ok(()) } else { @@ -476,7 +471,7 @@ unsafe fn set_user_memory_region( userspace_addr: userspace_addr as u64, }; - let ret = ioctl_with_ref(descriptor, GZVM_SET_USER_MEMORY_REGION(), ®ion); + let ret = ioctl_with_ref(descriptor, GZVM_SET_USER_MEMORY_REGION, ®ion); if ret == 0 { Ok(()) } else { @@ -575,7 +570,7 @@ impl GeniezoneVm { // SAFETY: // Safe because we know gzvm is a real gzvm fd as this module is the only one that can make // gzvm objects. - let ret = unsafe { ioctl(geniezone, GZVM_CREATE_VM()) }; + let ret = unsafe { ioctl(geniezone, GZVM_CREATE_VM) }; if ret < 0 { return errno_result(); } @@ -622,7 +617,7 @@ impl GeniezoneVm { let fd = // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - unsafe { ioctl_with_val(self, GZVM_CREATE_VCPU(), c_ulong::try_from(id).unwrap()) }; + unsafe { ioctl_with_val(self, GZVM_CREATE_VCPU, c_ulong::try_from(id).unwrap()) }; if fd < 0 { return errno_result(); @@ -652,7 +647,7 @@ impl GeniezoneVm { pub fn create_irq_chip(&self) -> Result<()> { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let ret = unsafe { ioctl(self, GZVM_CREATE_IRQCHIP()) }; + let ret = unsafe { ioctl(self, GZVM_CREATE_IRQCHIP) }; if ret == 0 { Ok(()) } else { @@ -669,7 +664,7 @@ impl GeniezoneVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, GZVM_IRQ_LINE(), &irq_level) }; + let ret = unsafe { ioctl_with_ref(self, GZVM_IRQ_LINE, &irq_level) }; if ret == 0 { Ok(()) } else { @@ -699,7 +694,7 @@ impl GeniezoneVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, GZVM_IRQFD(), &irqfd) }; + let ret = unsafe { ioctl_with_ref(self, GZVM_IRQFD, &irqfd) }; if ret == 0 { Ok(()) } else { @@ -722,7 +717,7 @@ impl GeniezoneVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, GZVM_IRQFD(), &irqfd) }; + let ret = unsafe { ioctl_with_ref(self, GZVM_IRQFD, &irqfd) }; if ret == 0 { Ok(()) } else { @@ -780,7 +775,7 @@ impl GeniezoneVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, GZVM_IOEVENTFD(), &ioeventfd) }; + let ret = unsafe { ioctl_with_ref(self, GZVM_IOEVENTFD, &ioeventfd) }; if ret == 0 { Ok(()) } else { @@ -795,7 +790,7 @@ impl GeniezoneVm { // Safe because we know that our file is a GZVM fd, and if the cap is invalid GZVM assumes // it's an unavailable extension and returns 0. unsafe { - ioctl_with_ref(self, GZVM_CHECK_EXTENSION(), &cap); + ioctl_with_ref(self, GZVM_CHECK_EXTENSION, &cap); } cap == 1 } @@ -819,7 +814,7 @@ impl GeniezoneVm { }; // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct, and because we assume the caller has allocated the args appropriately. - let ret = ioctl_with_ref(self, GZVM_ENABLE_CAP(), &gzvm_cap); + let ret = ioctl_with_ref(self, GZVM_ENABLE_CAP, &gzvm_cap); if ret == 0 { Ok(gzvm_cap) } else { @@ -831,7 +826,7 @@ impl GeniezoneVm { // SAFETY: // Safe because we allocated the struct and we know the kernel will modify exactly the size // of the struct and the return value is checked. - let ret = unsafe { base::ioctl_with_ref(self, GZVM_CREATE_DEVICE(), &dev) }; + let ret = unsafe { base::ioctl_with_ref(self, GZVM_CREATE_DEVICE, &dev) }; if ret == 0 { Ok(()) } else { @@ -1143,7 +1138,7 @@ impl Vcpu for GeniezoneVcpu { fn run(&mut self) -> Result { // SAFETY: // Safe because we know that our file is a VCPU fd and we verify the return result. - let ret = unsafe { ioctl_with_val(self, GZVM_RUN(), self.run_mmap.as_ptr() as u64) }; + let ret = unsafe { ioctl_with_val(self, GZVM_RUN, self.run_mmap.as_ptr() as u64) }; if ret != 0 { return errno_result(); } diff --git a/hypervisor/src/gunyah/mod.rs b/hypervisor/src/gunyah/mod.rs index 0c666713df..fd624b4d44 100644 --- a/hypervisor/src/gunyah/mod.rs +++ b/hypervisor/src/gunyah/mod.rs @@ -127,7 +127,7 @@ unsafe fn android_lend_user_memory_region( userspace_addr: userspace_addr as u64, }; - let ret = ioctl_with_ref(vm, GH_VM_ANDROID_LEND_USER_MEM(), ®ion); + let ret = ioctl_with_ref(vm, GH_VM_ANDROID_LEND_USER_MEM, ®ion); if ret == 0 { Ok(()) } else { @@ -163,7 +163,7 @@ unsafe fn set_user_memory_region( userspace_addr: userspace_addr as u64, }; - let ret = ioctl_with_ref(vm, GH_VM_SET_USER_MEM_REGION(), ®ion); + let ret = ioctl_with_ref(vm, GH_VM_SET_USER_MEM_REGION, ®ion); if ret == 0 { Ok(()) } else { @@ -199,7 +199,7 @@ impl GunyahVm { // SAFETY: // Safe because we know gunyah is a real gunyah fd as this module is the only one that can // make Gunyah objects. - let ret = unsafe { ioctl_with_val(gh, GH_CREATE_VM(), 0 as c_ulong) }; + let ret = unsafe { ioctl_with_val(gh, GH_CREATE_VM, 0 as c_ulong) }; if ret < 0 { return errno_result(); } @@ -273,7 +273,7 @@ impl GunyahVm { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let fd = unsafe { ioctl_with_ref(self, GH_VM_ADD_FUNCTION(), &function_desc) }; + let fd = unsafe { ioctl_with_ref(self, GH_VM_ADD_FUNCTION, &function_desc) }; if fd < 0 { return errno_result(); } @@ -285,7 +285,7 @@ impl GunyahVm { // SAFETY: // Safe because we know this is a Gunyah VCPU - let res = unsafe { ioctl(&vcpu, GH_VCPU_MMAP_SIZE()) }; + let res = unsafe { ioctl(&vcpu, GH_VCPU_MMAP_SIZE) }; if res < 0 { return errno_result(); } @@ -321,7 +321,7 @@ impl GunyahVm { }; // SAFETY: safe because the return value is checked. - let ret = unsafe { ioctl_with_ref(self, GH_VM_ADD_FUNCTION(), &function_desc) }; + let ret = unsafe { ioctl_with_ref(self, GH_VM_ADD_FUNCTION, &function_desc) }; if ret == 0 { self.routes .lock() @@ -346,7 +346,7 @@ impl GunyahVm { }; // SAFETY: safe because memory is not modified and the return value is checked. - let ret = unsafe { ioctl_with_ref(self, GH_VM_REMOVE_FUNCTION(), &function_desc) }; + let ret = unsafe { ioctl_with_ref(self, GH_VM_REMOVE_FUNCTION, &function_desc) }; if ret == 0 { Ok(()) } else { @@ -377,7 +377,7 @@ impl GunyahVm { // SAFETY: // Safe because we know this is a Gunyah VM - let ret = unsafe { ioctl_with_ref(self, GH_VM_SET_DTB_CONFIG(), &dtb_config) }; + let ret = unsafe { ioctl_with_ref(self, GH_VM_SET_DTB_CONFIG, &dtb_config) }; if ret == 0 { Ok(()) } else { @@ -393,7 +393,7 @@ impl GunyahVm { // SAFETY: // Safe because we know this is a Gunyah VM - let ret = unsafe { ioctl_with_ref(self, GH_VM_ANDROID_SET_FW_CONFIG(), &fw_config) }; + let ret = unsafe { ioctl_with_ref(self, GH_VM_ANDROID_SET_FW_CONFIG, &fw_config) }; if ret == 0 { Ok(()) } else { @@ -403,7 +403,7 @@ impl GunyahVm { fn start(&self) -> Result<()> { // SAFETY: safe because memory is not modified and the return value is checked. - let ret = unsafe { ioctl(self, GH_VM_START()) }; + let ret = unsafe { ioctl(self, GH_VM_START) }; if ret == 0 { Ok(()) } else { @@ -592,7 +592,7 @@ impl Vm for GunyahVm { }; // SAFETY: safe because memory is not modified and the return value is checked. - let ret = unsafe { ioctl_with_ref(self, GH_VM_ADD_FUNCTION(), &function_desc) }; + let ret = unsafe { ioctl_with_ref(self, GH_VM_ADD_FUNCTION, &function_desc) }; if ret == 0 { Ok(()) } else { @@ -624,7 +624,7 @@ impl Vm for GunyahVm { }; // SAFETY: safe because memory is not modified and the return value is checked. - let ret = unsafe { ioctl_with_ref(self, GH_VM_REMOVE_FUNCTION(), &function_desc) }; + let ret = unsafe { ioctl_with_ref(self, GH_VM_REMOVE_FUNCTION, &function_desc) }; if ret == 0 { Ok(()) } else { @@ -738,7 +738,7 @@ impl Vcpu for GunyahVcpu { fn run(&mut self) -> Result { // SAFETY: // Safe because we know our file is a VCPU fd and we verify the return result. - let ret = unsafe { ioctl(self, GH_VCPU_RUN()) }; + let ret = unsafe { ioctl(self, GH_VCPU_RUN) }; if ret != 0 { return errno_result(); } diff --git a/hypervisor/src/haxm/vcpu.rs b/hypervisor/src/haxm/vcpu.rs index ed4a9f0f9a..cf31a0e8e6 100644 --- a/hypervisor/src/haxm/vcpu.rs +++ b/hypervisor/src/haxm/vcpu.rs @@ -106,7 +106,7 @@ impl HaxmVcpu { let mut state = vcpu_state_t::default(); // SAFETY: trivially safe with return value checked. - let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_GET_REGS(), &mut state) }; + let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_GET_REGS, &mut state) }; if ret != 0 { return errno_result(); } @@ -119,7 +119,7 @@ impl HaxmVcpu { fn set_vcpu_state(&self, state: &mut VcpuState) -> Result<()> { // SAFETY: trivially safe with return value checked. - let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_SET_REGS(), &mut state.state) }; + let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_SET_REGS, &mut state.state) }; if ret != 0 { return errno_result(); } @@ -290,7 +290,7 @@ impl Vcpu for HaxmVcpu { fn run(&mut self) -> Result { // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl(self, HAX_VCPU_IOCTL_RUN()) }; + let ret = unsafe { ioctl(self, HAX_VCPU_IOCTL_RUN) }; if ret != 0 { return errno_result(); } @@ -348,7 +348,7 @@ impl VcpuX86_64 for HaxmVcpu { let irq: u32 = irq.into(); // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl_with_ref(self, HAX_VCPU_IOCTL_INTERRUPT(), &irq) }; + let ret = unsafe { ioctl_with_ref(self, HAX_VCPU_IOCTL_INTERRUPT, &irq) }; if ret != 0 { return errno_result(); } @@ -392,7 +392,7 @@ impl VcpuX86_64 for HaxmVcpu { let mut fpu = fx_layout::default(); // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_IOCTL_GET_FPU(), &mut fpu) }; + let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_IOCTL_GET_FPU, &mut fpu) }; if ret != 0 { return errno_result(); @@ -406,7 +406,7 @@ impl VcpuX86_64 for HaxmVcpu { let mut current_fpu = fx_layout::default(); // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_IOCTL_GET_FPU(), &mut current_fpu) }; + let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_IOCTL_GET_FPU, &mut current_fpu) }; if ret != 0 { return errno_result(); @@ -420,7 +420,7 @@ impl VcpuX86_64 for HaxmVcpu { // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl_with_ref(self, HAX_VCPU_IOCTL_SET_FPU(), &new_fpu) }; + let ret = unsafe { ioctl_with_ref(self, HAX_VCPU_IOCTL_SET_FPU, &new_fpu) }; if ret != 0 { return errno_result(); @@ -480,7 +480,7 @@ impl VcpuX86_64 for HaxmVcpu { // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_IOCTL_GET_MSRS(), &mut msr_data) }; + let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_IOCTL_GET_MSRS, &mut msr_data) }; if ret != 0 { return errno_result(); } @@ -503,7 +503,7 @@ impl VcpuX86_64 for HaxmVcpu { // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_IOCTL_SET_MSRS(), &mut msr_data) }; + let ret = unsafe { ioctl_with_mut_ref(self, HAX_VCPU_IOCTL_SET_MSRS, &mut msr_data) }; if ret != 0 { return errno_result(); } @@ -528,7 +528,7 @@ impl VcpuX86_64 for HaxmVcpu { let ret = unsafe { ioctl_with_ptr_sized( self, - HAX_VCPU_IOCTL_SET_CPUID(), + HAX_VCPU_IOCTL_SET_CPUID, hax.as_ptr(), size_of::() + total * size_of::(), ) diff --git a/hypervisor/src/haxm/vm.rs b/hypervisor/src/haxm/vm.rs index def8d054d5..b2e46ffb71 100644 --- a/hypervisor/src/haxm/vm.rs +++ b/hypervisor/src/haxm/vm.rs @@ -78,7 +78,7 @@ impl HaxmVm { // SAFETY: // Safe because we know descriptor is a real haxm descriptor as this module is the only // one that can make Haxm objects. - let ret = unsafe { ioctl_with_mut_ref(haxm, HAX_IOCTL_CREATE_VM(), &mut vm_id) }; + let ret = unsafe { ioctl_with_mut_ref(haxm, HAX_IOCTL_CREATE_VM, &mut vm_id) }; if ret != 0 { return errno_result(); } @@ -116,7 +116,7 @@ impl HaxmVm { let ret = // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - unsafe { ioctl_with_mut_ref(&self.haxm, HAX_IOCTL_CAPABILITY(), &mut capability_info) }; + unsafe { ioctl_with_mut_ref(&self.haxm, HAX_IOCTL_CAPABILITY, &mut capability_info) }; if ret != 0 { return false; @@ -144,7 +144,7 @@ impl HaxmVm { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, HAX_VM_IOCTL_REGISTER_LOG_FILE(), &log_file) }; + let ret = unsafe { ioctl_with_ref(self, HAX_VM_IOCTL_REGISTER_LOG_FILE, &log_file) }; if ret != 0 { return errno_result(); @@ -194,7 +194,7 @@ unsafe fn set_user_memory_region( // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let ret = ioctl_with_ref(descriptor, HAX_VM_IOCTL_SET_RAM2(), &ram_info); + let ret = ioctl_with_ref(descriptor, HAX_VM_IOCTL_SET_RAM2, &ram_info); if ret != 0 { return errno_result(); } @@ -439,7 +439,7 @@ impl VmX86_64 for HaxmVm { fn create_vcpu(&self, id: usize) -> Result> { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let fd = unsafe { ioctl_with_ref(self, HAX_VM_IOCTL_VCPU_CREATE(), &(id as u32)) }; + let fd = unsafe { ioctl_with_ref(self, HAX_VM_IOCTL_VCPU_CREATE, &(id as u32)) }; if fd < 0 { return errno_result(); } @@ -452,7 +452,7 @@ impl VmX86_64 for HaxmVm { // SAFETY: // Safe because we created tunnel_info and we check the return code for errors let ret = unsafe { - ioctl_with_mut_ref(&descriptor, HAX_VCPU_IOCTL_SETUP_TUNNEL(), &mut tunnel_info) + ioctl_with_mut_ref(&descriptor, HAX_VCPU_IOCTL_SETUP_TUNNEL, &mut tunnel_info) }; if ret != 0 { diff --git a/hypervisor/src/kvm/aarch64.rs b/hypervisor/src/kvm/aarch64.rs index 7a8ae7a102..f7b95e085f 100644 --- a/hypervisor/src/kvm/aarch64.rs +++ b/hypervisor/src/kvm/aarch64.rs @@ -54,7 +54,7 @@ impl Kvm { // SAFETY: // Safe because we know self is a real kvm fd let ipa_size = match unsafe { - ioctl_with_val(self, KVM_CHECK_EXTENSION(), KVM_CAP_ARM_VM_IPA_SIZE.into()) + ioctl_with_val(self, KVM_CHECK_EXTENSION, KVM_CAP_ARM_VM_IPA_SIZE.into()) } { // Not supported? Use 0 as the machine type, which implies 40bit IPA ret if ret < 0 => 0, @@ -73,8 +73,7 @@ impl Kvm { pub fn get_guest_phys_addr_bits(&self) -> u8 { // SAFETY: // Safe because we know self is a real kvm fd - match unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION(), KVM_CAP_ARM_VM_IPA_SIZE.into()) } - { + match unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION, KVM_CAP_ARM_VM_IPA_SIZE.into()) } { // Default physical address size is 40 bits if the extension is not supported. ret if ret <= 0 => 40, ipa => ipa as u8, @@ -228,7 +227,7 @@ impl VmAArch64 for KvmVm { reserved: 0, }; // SAFETY: self.vm is a valid KVM fd - let ret = unsafe { ioctl_with_ref(&self.vm, KVM_ARM_SET_COUNTER_OFFSET(), &off) }; + let ret = unsafe { ioctl_with_ref(&self.vm, KVM_ARM_SET_COUNTER_OFFSET, &off) }; if ret != 0 { return errno_result(); } @@ -296,7 +295,7 @@ impl KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_ONE_REG(), &onereg) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_ONE_REG, &onereg) }; if ret == 0 { Ok(()) } else { @@ -335,7 +334,7 @@ impl KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, KVM_GET_ONE_REG(), &onereg) }; + let ret = unsafe { ioctl_with_ref(self, KVM_GET_ONE_REG, &onereg) }; if ret == 0 { Ok(()) } else { @@ -518,7 +517,7 @@ impl VcpuAArch64 for KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will write exactly the size // of the struct. - let ret = unsafe { ioctl_with_mut_ref(&self.vm, KVM_ARM_PREFERRED_TARGET(), &mut kvi) }; + let ret = unsafe { ioctl_with_mut_ref(&self.vm, KVM_ARM_PREFERRED_TARGET, &mut kvi) }; if ret != 0 { return errno_result(); } @@ -535,7 +534,7 @@ impl VcpuAArch64 for KvmVcpu { let check_extension = |ext: u32| -> bool { // SAFETY: // Safe because we know self.vm is a real kvm fd - unsafe { ioctl_with_val(&self.vm, KVM_CHECK_EXTENSION(), ext.into()) == 1 } + unsafe { ioctl_with_val(&self.vm, KVM_CHECK_EXTENSION, ext.into()) == 1 } }; if check_extension(KVM_CAP_ARM_PTRAUTH_ADDRESS) && check_extension(KVM_CAP_ARM_PTRAUTH_GENERIC) @@ -547,7 +546,7 @@ impl VcpuAArch64 for KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, KVM_ARM_VCPU_INIT(), &kvi) }; + let ret = unsafe { ioctl_with_ref(self, KVM_ARM_VCPU_INIT, &kvi) }; if ret == 0 { Ok(()) } else { @@ -570,7 +569,7 @@ impl VcpuAArch64 for KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_HAS_DEVICE_ATTR(), &irq_attr) }; + let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_HAS_DEVICE_ATTR, &irq_attr) }; if ret < 0 { return errno_result(); } @@ -578,7 +577,7 @@ impl VcpuAArch64 for KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_SET_DEVICE_ATTR(), &irq_attr) }; + let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_SET_DEVICE_ATTR, &irq_attr) }; if ret < 0 { return errno_result(); } @@ -592,7 +591,7 @@ impl VcpuAArch64 for KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_SET_DEVICE_ATTR(), &init_attr) }; + let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_SET_DEVICE_ATTR, &init_attr) }; if ret < 0 { return errno_result(); } @@ -612,7 +611,7 @@ impl VcpuAArch64 for KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_HAS_DEVICE_ATTR(), &pvtime_attr) }; + let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_HAS_DEVICE_ATTR, &pvtime_attr) }; ret >= 0 } @@ -631,7 +630,7 @@ impl VcpuAArch64 for KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_SET_DEVICE_ATTR(), &pvtime_attr) }; + let ret = unsafe { ioctl_with_ref(self, kvm_sys::KVM_SET_DEVICE_ATTR, &pvtime_attr) }; if ret < 0 { return errno_result(); } @@ -699,7 +698,7 @@ impl VcpuAArch64 for KvmVcpu { let max_hw_bps = unsafe { ioctl_with_val( &self.vm, - KVM_CHECK_EXTENSION(), + KVM_CHECK_EXTENSION, KVM_CAP_GUEST_DEBUG_HW_BPS.into(), ) }; @@ -749,7 +748,7 @@ impl VcpuAArch64 for KvmVcpu { // SAFETY: // Safe because the kernel won't read past the end of the kvm_guest_debug struct. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_GUEST_DEBUG(), &dbg) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_GUEST_DEBUG, &dbg) }; if ret == 0 { Ok(()) } else { diff --git a/hypervisor/src/kvm/mod.rs b/hypervisor/src/kvm/mod.rs index 02a785e447..a0f71341e8 100644 --- a/hypervisor/src/kvm/mod.rs +++ b/hypervisor/src/kvm/mod.rs @@ -122,7 +122,7 @@ unsafe fn set_user_memory_region( userspace_addr: userspace_addr as u64, }; - let ret = ioctl_with_ref(descriptor, KVM_SET_USER_MEMORY_REGION(), ®ion); + let ret = ioctl_with_ref(descriptor, KVM_SET_USER_MEMORY_REGION, ®ion); if ret == 0 { Ok(()) } else { @@ -160,7 +160,7 @@ impl Kvm { // SAFETY: // Safe because we know that the descriptor is valid and we verify the return result. - let version = unsafe { ioctl(&kvm, KVM_GET_API_VERSION()) }; + let version = unsafe { ioctl(&kvm, KVM_GET_API_VERSION) }; if version < 0 { return errno_result(); } @@ -187,7 +187,7 @@ impl Kvm { pub fn get_vcpu_mmap_size(&self) -> Result { // SAFETY: // Safe because we know that our file is a KVM fd and we verify the return result. - let res = unsafe { ioctl(self, KVM_GET_VCPU_MMAP_SIZE()) }; + let res = unsafe { ioctl(self, KVM_GET_VCPU_MMAP_SIZE) }; if res > 0 { Ok(res as usize) } else { @@ -214,7 +214,7 @@ impl Hypervisor for Kvm { // SAFETY: // this ioctl is safe because we know this kvm descriptor is valid, // and we are copying over the kvm capability (u32) as a c_ulong value. - unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION(), kvm_cap as c_ulong) == 1 } + unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION, kvm_cap as c_ulong) == 1 } } else { // this capability cannot be converted on this platform, so return false false @@ -241,7 +241,7 @@ impl KvmVm { let ret = unsafe { ioctl_with_val( kvm, - KVM_CREATE_VM(), + KVM_CREATE_VM, kvm.get_vm_type(cfg.protection_type)? as c_ulong, ) }; @@ -284,7 +284,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let fd = unsafe { ioctl_with_val(self, KVM_CREATE_VCPU(), c_ulong::try_from(id).unwrap()) }; + let fd = unsafe { ioctl_with_val(self, KVM_CREATE_VCPU, c_ulong::try_from(id).unwrap()) }; if fd < 0 { return errno_result(); } @@ -321,7 +321,7 @@ impl KvmVm { pub fn create_irq_chip(&self) -> Result<()> { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let ret = unsafe { ioctl(self, KVM_CREATE_IRQCHIP()) }; + let ret = unsafe { ioctl(self, KVM_CREATE_IRQCHIP) }; if ret == 0 { Ok(()) } else { @@ -338,7 +338,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_IRQ_LINE(), &irq_level) }; + let ret = unsafe { ioctl_with_ref(self, KVM_IRQ_LINE, &irq_level) }; if ret == 0 { Ok(()) } else { @@ -368,7 +368,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_IRQFD(), &irqfd) }; + let ret = unsafe { ioctl_with_ref(self, KVM_IRQFD, &irqfd) }; if ret == 0 { Ok(()) } else { @@ -391,7 +391,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_IRQFD(), &irqfd) }; + let ret = unsafe { ioctl_with_ref(self, KVM_IRQFD, &irqfd) }; if ret == 0 { Ok(()) } else { @@ -416,7 +416,7 @@ impl KvmVm { // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl_with_ref(self, KVM_SET_GSI_ROUTING(), &irq_routing[0]) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_GSI_ROUTING, &irq_routing[0]) }; if ret == 0 { Ok(()) } else { @@ -474,7 +474,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_IOEVENTFD(), &ioeventfd) }; + let ret = unsafe { ioctl_with_ref(self, KVM_IOEVENTFD, &ioeventfd) }; if ret == 0 { Ok(()) } else { @@ -487,7 +487,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a KVM fd, and if the cap is invalid KVM assumes // it's an unavailable extension and returns 0. - let ret = unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION(), capability as c_ulong) }; + let ret = unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION, capability as c_ulong) }; match capability { #[cfg(target_arch = "x86_64")] KvmCap::BusLockDetect => { @@ -524,7 +524,7 @@ impl KvmVm { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct, and because we assume the caller has allocated the args appropriately. - let ret = ioctl_with_ref(self, KVM_ENABLE_CAP(), &kvm_cap); + let ret = ioctl_with_ref(self, KVM_ENABLE_CAP, &kvm_cap); if ret == 0 { Ok(()) } else { @@ -753,7 +753,7 @@ impl Vm for KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only write correct // amount of memory to our pointer, and we verify the return result. - let ret = unsafe { base::ioctl_with_ref(self, KVM_CREATE_DEVICE(), &device) }; + let ret = unsafe { base::ioctl_with_ref(self, KVM_CREATE_DEVICE, &device) }; if ret == 0 { Ok( // SAFETY: @@ -781,7 +781,7 @@ impl Vm for KvmVm { // SAFETY: // Safe because the `dirty_bitmap` pointer assigned above is guaranteed to be valid (because // it's from a slice) and we checked that it will be large enough to hold the entire log. - let ret = unsafe { ioctl_with_ref(self, KVM_GET_DIRTY_LOG(), &dirty_log_kvm) }; + let ret = unsafe { ioctl_with_ref(self, KVM_GET_DIRTY_LOG, &dirty_log_kvm) }; if ret == 0 { Ok(()) } else { @@ -939,7 +939,7 @@ impl Vcpu for KvmVcpu { if self.cap_kvmclock_ctrl { // SAFETY: // The ioctl is safe because it does not read or write memory in this process. - if unsafe { ioctl(self, KVM_KVMCLOCK_CTRL()) } != 0 { + if unsafe { ioctl(self, KVM_KVMCLOCK_CTRL) } != 0 { // Even if the host kernel supports the capability, it may not be configured by // the guest - for example, when the guest kernel offlines a CPU. if Error::last().errno() != libc::EINVAL { @@ -960,7 +960,7 @@ impl Vcpu for KvmVcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct, and because we assume the caller has allocated the args appropriately. - let ret = ioctl_with_ref(self, KVM_ENABLE_CAP(), &kvm_cap); + let ret = ioctl_with_ref(self, KVM_ENABLE_CAP, &kvm_cap); if ret == 0 { Ok(()) } else { @@ -974,7 +974,7 @@ impl Vcpu for KvmVcpu { fn run(&mut self) -> Result { // SAFETY: // Safe because we know that our file is a VCPU fd and we verify the return result. - let ret = unsafe { ioctl(self, KVM_RUN()) }; + let ret = unsafe { ioctl(self, KVM_RUN) }; if ret != 0 { return errno_result(); } @@ -1149,7 +1149,7 @@ impl KvmVcpu { // Safe because we know that our file is a VCPU fd, we know the kernel will only write // the correct amount of memory to our pointer, and we verify the return // result. - unsafe { ioctl_with_mut_ref(self, KVM_GET_MP_STATE(), &mut state) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_MP_STATE, &mut state) } }; if ret < 0 { return errno_result(); @@ -1168,7 +1168,7 @@ impl KvmVcpu { let ret = { // SAFETY: // The ioctl is safe because the kernel will only read from the kvm_mp_state struct. - unsafe { ioctl_with_ref(self, KVM_SET_MP_STATE(), state) } + unsafe { ioctl_with_ref(self, KVM_SET_MP_STATE, state) } }; if ret < 0 { return errno_result(); diff --git a/hypervisor/src/kvm/riscv64.rs b/hypervisor/src/kvm/riscv64.rs index e6dfe6dd48..252f20b9ae 100644 --- a/hypervisor/src/kvm/riscv64.rs +++ b/hypervisor/src/kvm/riscv64.rs @@ -147,7 +147,7 @@ impl VcpuRiscv64 for KvmVcpu { }; // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_ONE_REG(), &onereg) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_ONE_REG, &onereg) }; if ret == 0 { Ok(()) } else { @@ -164,7 +164,7 @@ impl VcpuRiscv64 for KvmVcpu { // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = unsafe { ioctl_with_ref(self, KVM_GET_ONE_REG(), &onereg) }; + let ret = unsafe { ioctl_with_ref(self, KVM_GET_ONE_REG, &onereg) }; if ret == 0 { Ok(val) } else { diff --git a/hypervisor/src/kvm/x86_64.rs b/hypervisor/src/kvm/x86_64.rs index d4ced97154..6bdb323c38 100644 --- a/hypervisor/src/kvm/x86_64.rs +++ b/hypervisor/src/kvm/x86_64.rs @@ -174,11 +174,11 @@ impl Kvm { impl HypervisorX86_64 for Kvm { fn get_supported_cpuid(&self) -> Result { - self.get_cpuid(KVM_GET_SUPPORTED_CPUID()) + self.get_cpuid(KVM_GET_SUPPORTED_CPUID) } fn get_emulated_cpuid(&self) -> Result { - self.get_cpuid(KVM_GET_EMULATED_CPUID()) + self.get_cpuid(KVM_GET_EMULATED_CPUID) } fn get_msr_index_list(&self) -> Result> { @@ -192,7 +192,7 @@ impl HypervisorX86_64 for Kvm { // ioctl is unsafe. The kernel is trusted not to write beyond the bounds of the memory // allocated for the struct. The limit is read from nmsrs, which is set to the allocated // size (MAX_KVM_MSR_ENTRIES) above. - unsafe { ioctl_with_mut_ref(self, KVM_GET_MSR_INDEX_LIST(), &mut msr_list[0]) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_MSR_INDEX_LIST, &mut msr_list[0]) } }; if ret < 0 { return errno_result(); @@ -247,7 +247,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only write correct // amount of memory to our pointer, and we verify the return result. - unsafe { ioctl_with_mut_ref(self, KVM_GET_CLOCK(), &mut clock_data) }; + unsafe { ioctl_with_mut_ref(self, KVM_GET_CLOCK, &mut clock_data) }; if ret == 0 { Ok(ClockState::from(&clock_data)) } else { @@ -261,7 +261,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read correct // amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_CLOCK(), &clock_data) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_CLOCK, &clock_data) }; if ret == 0 { Ok(()) } else { @@ -281,7 +281,7 @@ impl KvmVm { // SAFETY: // Safe because we know our file is a VM fd, we know the kernel will only write // correct amount of memory to our pointer, and we verify the return result. - unsafe { ioctl_with_mut_ref(self, KVM_GET_IRQCHIP(), &mut irqchip_state) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_IRQCHIP, &mut irqchip_state) } }; if ret == 0 { Ok( @@ -307,7 +307,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_IRQCHIP(), &irqchip_state) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_IRQCHIP, &irqchip_state) }; if ret == 0 { Ok(()) } else { @@ -332,7 +332,7 @@ impl KvmVm { // SAFETY: // Safe because we know our file is a VM fd, we know the kernel will only write // correct amount of memory to our pointer, and we verify the return result. - unsafe { ioctl_with_mut_ref(self, KVM_GET_IRQCHIP(), &mut irqchip_state) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_IRQCHIP, &mut irqchip_state) } }; if ret == 0 { Ok( @@ -358,7 +358,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_IRQCHIP(), &irqchip_state) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_IRQCHIP, &irqchip_state) }; if ret == 0 { Ok(()) } else { @@ -374,7 +374,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_CREATE_PIT2(), &pit_config) }; + let ret = unsafe { ioctl_with_ref(self, KVM_CREATE_PIT2, &pit_config) }; if ret == 0 { Ok(()) } else { @@ -390,7 +390,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only write // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_PIT2(), &mut pit_state) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_PIT2, &mut pit_state) }; if ret == 0 { Ok(pit_state) } else { @@ -405,7 +405,7 @@ impl KvmVm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_PIT2(), pit_state) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_PIT2, pit_state) }; if ret == 0 { Ok(()) } else { @@ -425,7 +425,7 @@ impl KvmVm { // Safe because we know that our file is a VM fd, we know that the // kernel will only read correct amount of memory from our pointer, and // we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_ENABLE_CAP(), &cap) }; + let ret = unsafe { ioctl_with_ref(self, KVM_ENABLE_CAP, &cap) }; if ret < 0 { errno_result() } else { @@ -443,7 +443,7 @@ impl KvmVm { // SAFETY: // safe becuase we allocated the struct and we know the kernel will read // exactly the size of the struct - let ret = unsafe { ioctl_with_ref(self, KVM_ENABLE_CAP(), &cap) }; + let ret = unsafe { ioctl_with_ref(self, KVM_ENABLE_CAP, &cap) }; if ret < 0 { errno_result() } else { @@ -469,7 +469,7 @@ impl VmX86_64 for KvmVm { fn set_tss_addr(&self, addr: GuestAddress) -> Result<()> { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let ret = unsafe { ioctl_with_val(self, KVM_SET_TSS_ADDR(), addr.offset()) }; + let ret = unsafe { ioctl_with_val(self, KVM_SET_TSS_ADDR, addr.offset()) }; if ret == 0 { Ok(()) } else { @@ -483,7 +483,7 @@ impl VmX86_64 for KvmVm { fn set_identity_map_addr(&self, addr: GuestAddress) -> Result<()> { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_IDENTITY_MAP_ADDR(), &addr.offset()) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_IDENTITY_MAP_ADDR, &addr.offset()) }; if ret == 0 { Ok(()) } else { @@ -509,7 +509,7 @@ impl KvmVcpu { let size = { // SAFETY: // Safe because we know that our file is a valid VM fd - unsafe { ioctl_with_val(&self.vm, KVM_CHECK_EXTENSION(), KVM_CAP_XSAVE2 as u64) } + unsafe { ioctl_with_val(&self.vm, KVM_CHECK_EXTENSION, KVM_CAP_XSAVE2 as u64) } }; if size < 0 { return errno_result(); @@ -569,7 +569,7 @@ impl VcpuX86_64 for KvmVcpu { // SAFETY: // safe becuase we allocated the struct and we know the kernel will read // exactly the size of the struct - let ret = unsafe { ioctl_with_ref(self, KVM_INTERRUPT(), &interrupt) }; + let ret = unsafe { ioctl_with_ref(self, KVM_INTERRUPT, &interrupt) }; if ret == 0 { Ok(()) } else { @@ -580,7 +580,7 @@ impl VcpuX86_64 for KvmVcpu { fn inject_nmi(&self) -> Result<()> { // SAFETY: // Safe because we know that our file is a VCPU fd. - let ret = unsafe { ioctl(self, KVM_NMI()) }; + let ret = unsafe { ioctl(self, KVM_NMI) }; if ret == 0 { Ok(()) } else { @@ -595,7 +595,7 @@ impl VcpuX86_64 for KvmVcpu { // Safe because we know that our file is a VCPU fd, we know the kernel will only read // the correct amount of memory from our pointer, and we verify the return // result. - unsafe { ioctl_with_mut_ref(self, KVM_GET_REGS(), &mut regs) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_REGS, &mut regs) } }; if ret == 0 { Ok(Regs::from(®s)) @@ -611,7 +611,7 @@ impl VcpuX86_64 for KvmVcpu { // Safe because we know that our file is a VCPU fd, we know the kernel will only read // the correct amount of memory from our pointer, and we verify the return // result. - unsafe { ioctl_with_ref(self, KVM_SET_REGS(), ®s) } + unsafe { ioctl_with_ref(self, KVM_SET_REGS, ®s) } }; if ret == 0 { Ok(()) @@ -627,7 +627,7 @@ impl VcpuX86_64 for KvmVcpu { // Safe because we know that our file is a VCPU fd, we know the kernel will only write // the correct amount of memory to our pointer, and we verify the return // result. - unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS(), &mut regs) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS, &mut regs) } }; if ret == 0 { Ok(Sregs::from(®s)) @@ -643,7 +643,7 @@ impl VcpuX86_64 for KvmVcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS(), &mut kvm_sregs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS, &mut kvm_sregs) }; if ret != 0 { return errno_result(); } @@ -668,7 +668,7 @@ impl VcpuX86_64 for KvmVcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_SREGS(), &kvm_sregs) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_SREGS, &kvm_sregs) }; if ret == 0 { Ok(()) } else { @@ -681,7 +681,7 @@ impl VcpuX86_64 for KvmVcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_FPU(), &mut fpu) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_FPU, &mut fpu) }; if ret == 0 { Ok(Fpu::from(&fpu)) } else { @@ -694,7 +694,7 @@ impl VcpuX86_64 for KvmVcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_fpu struct. - unsafe { ioctl_with_ref(self, KVM_SET_FPU(), &fpu) } + unsafe { ioctl_with_ref(self, KVM_SET_FPU, &fpu) } }; if ret == 0 { Ok(()) @@ -707,9 +707,9 @@ impl VcpuX86_64 for KvmVcpu { fn get_xsave(&self) -> Result { let size = self.xsave_size()?; let ioctl_nr = if size > KVM_XSAVE_MAX_SIZE { - KVM_GET_XSAVE2() + KVM_GET_XSAVE2 } else { - KVM_GET_XSAVE() + KVM_GET_XSAVE }; let mut xsave = Xsave::new(size); @@ -737,7 +737,7 @@ impl VcpuX86_64 for KvmVcpu { // correct amount of memory to our pointer, and we verify the return result. // Because of the len check above, and because the layout of `struct kvm_xsave` is // compatible with a slice of `u32`, we can pass the pointer to `xsave` directly. - let ret = unsafe { ioctl_with_ptr(self, KVM_SET_XSAVE(), xsave.as_ptr()) }; + let ret = unsafe { ioctl_with_ptr(self, KVM_SET_XSAVE, xsave.as_ptr()) }; if ret == 0 { Ok(()) } else { @@ -752,7 +752,7 @@ impl VcpuX86_64 for KvmVcpu { // Safe because we know that our file is a VCPU fd, we know the kernel will only write // the correct amount of memory to our pointer, and we verify the return // result. - unsafe { ioctl_with_mut_ref(self, KVM_GET_VCPU_EVENTS(), &mut vcpu_evts) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_VCPU_EVENTS, &mut vcpu_evts) } }; if ret == 0 { Ok( @@ -777,7 +777,7 @@ impl VcpuX86_64 for KvmVcpu { // Safe because we know that our file is a VCPU fd, we know the kernel will only read // the correct amount of memory from our pointer, and we verify the return // result. - unsafe { ioctl_with_ref(self, KVM_SET_VCPU_EVENTS(), &vcpu_events) } + unsafe { ioctl_with_ref(self, KVM_SET_VCPU_EVENTS, &vcpu_events) } }; if ret == 0 { Ok(()) @@ -791,7 +791,7 @@ impl VcpuX86_64 for KvmVcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_DEBUGREGS(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_DEBUGREGS, &mut regs) }; if ret == 0 { Ok(DebugRegs::from(®s)) } else { @@ -804,7 +804,7 @@ impl VcpuX86_64 for KvmVcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_debugregs struct. - unsafe { ioctl_with_ref(self, KVM_SET_DEBUGREGS(), &dregs) } + unsafe { ioctl_with_ref(self, KVM_SET_DEBUGREGS, &dregs) } }; if ret == 0 { Ok(()) @@ -818,7 +818,7 @@ impl VcpuX86_64 for KvmVcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_XCRS(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_XCRS, &mut regs) }; if ret < 0 { return errno_result(); } @@ -842,7 +842,7 @@ impl VcpuX86_64 for KvmVcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_xcrs struct. - unsafe { ioctl_with_ref(self, KVM_SET_XCRS(), &kvm_xcr) } + unsafe { ioctl_with_ref(self, KVM_SET_XCRS, &kvm_xcr) } }; if ret == 0 { Ok(()) @@ -864,7 +864,7 @@ impl VcpuX86_64 for KvmVcpu { let ret = { // SAFETY: // Here we trust the kernel not to read or write past the end of the kvm_msrs struct. - unsafe { ioctl_with_ref(self, KVM_GET_MSRS(), &msrs[0]) } + unsafe { ioctl_with_ref(self, KVM_GET_MSRS, &msrs[0]) } }; if ret < 0 { return errno_result(); @@ -904,7 +904,7 @@ impl VcpuX86_64 for KvmVcpu { let ret = { // SAFETY: // Here we trust the kernel not to read or write past the end of the kvm_msrs struct. - unsafe { ioctl_with_ref(self, KVM_GET_MSRS(), &kvm_msrs[0]) } + unsafe { ioctl_with_ref(self, KVM_GET_MSRS, &kvm_msrs[0]) } }; if ret < 0 { return errno_result(); @@ -950,7 +950,7 @@ impl VcpuX86_64 for KvmVcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_msrs struct. - unsafe { ioctl_with_ref(self, KVM_SET_MSRS(), &kvm_msrs[0]) } + unsafe { ioctl_with_ref(self, KVM_SET_MSRS, &kvm_msrs[0]) } }; if ret < 0 { return errno_result(); @@ -970,7 +970,7 @@ impl VcpuX86_64 for KvmVcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_msrs struct. - unsafe { ioctl_with_ptr(self, KVM_SET_CPUID2(), cpuid.as_ptr()) } + unsafe { ioctl_with_ptr(self, KVM_SET_CPUID2, cpuid.as_ptr()) } }; if ret == 0 { Ok(()) @@ -1010,7 +1010,7 @@ impl VcpuX86_64 for KvmVcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_guest_debug struct. - unsafe { ioctl_with_ref(self, KVM_SET_GUEST_DEBUG(), &dbg) } + unsafe { ioctl_with_ref(self, KVM_SET_GUEST_DEBUG, &dbg) } }; if ret == 0 { Ok(()) @@ -1042,7 +1042,7 @@ impl KvmVcpu { // SAFETY: // The ioctl is unsafe unless you trust the kernel not to write past the end of the // local_apic struct. - unsafe { ioctl_with_mut_ref(self, KVM_GET_LAPIC(), &mut klapic) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_LAPIC, &mut klapic) } }; if ret < 0 { return errno_result(); @@ -1058,7 +1058,7 @@ impl KvmVcpu { let ret = { // SAFETY: // The ioctl is safe because the kernel will only read from the klapic struct. - unsafe { ioctl_with_ref(self, KVM_SET_LAPIC(), klapic) } + unsafe { ioctl_with_ref(self, KVM_SET_LAPIC, klapic) } }; if ret < 0 { return errno_result(); @@ -1088,7 +1088,7 @@ impl KvmVcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS, &mut regs) }; if ret >= 0 { Ok(regs.interrupt_bitmap) } else { @@ -1107,14 +1107,14 @@ impl KvmVcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS, &mut regs) }; if ret >= 0 { regs.interrupt_bitmap = interrupt_bitmap; // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only read // the correct amount of memory from our pointer, and we verify the return // result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_SREGS(), ®s) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_SREGS, ®s) }; if ret >= 0 { Ok(()) } else { diff --git a/hypervisor/tests/kvm/x86_64.rs b/hypervisor/tests/kvm/x86_64.rs index 7ff8374fad..f3ea2cf024 100644 --- a/hypervisor/tests/kvm/x86_64.rs +++ b/hypervisor/tests/kvm/x86_64.rs @@ -57,7 +57,7 @@ fn get_msr_index_list() { #[test] fn entries_double_on_error() { let hypervisor = Kvm::new().unwrap(); - let cpuid = get_cpuid_with_initial_capacity(&hypervisor, KVM_GET_SUPPORTED_CPUID(), 4).unwrap(); + let cpuid = get_cpuid_with_initial_capacity(&hypervisor, KVM_GET_SUPPORTED_CPUID, 4).unwrap(); assert!(cpuid.cpu_id_entries.len() > 4); } diff --git a/kvm/src/lib.rs b/kvm/src/lib.rs index f38b487841..ca71f6c11f 100644 --- a/kvm/src/lib.rs +++ b/kvm/src/lib.rs @@ -113,7 +113,7 @@ unsafe fn set_user_memory_region( userspace_addr: userspace_addr as u64, }; - let ret = ioctl_with_ref(fd, KVM_SET_USER_MEMORY_REGION(), ®ion); + let ret = ioctl_with_ref(fd, KVM_SET_USER_MEMORY_REGION, ®ion); if ret == 0 { Ok(()) } else { @@ -168,7 +168,7 @@ impl Kvm { // SAFETY: // Safe because we know that our file is a KVM fd and that the extension is one of the ones // defined by kernel. - unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION(), c as c_ulong) } + unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION, c as c_ulong) } } /// Checks if a particular `Cap` is available. @@ -180,7 +180,7 @@ impl Kvm { pub fn get_vcpu_mmap_size(&self) -> Result { // SAFETY: // Safe because we know that our file is a KVM fd and we verify the return result. - let res = unsafe { ioctl(self, KVM_GET_VCPU_MMAP_SIZE()) }; + let res = unsafe { ioctl(self, KVM_GET_VCPU_MMAP_SIZE) }; if res > 0 { Ok(res as usize) } else { @@ -208,13 +208,13 @@ impl Kvm { /// X86 specific call to get the system supported CPUID values #[cfg(target_arch = "x86_64")] pub fn get_supported_cpuid(&self) -> Result { - self.get_cpuid(KVM_GET_SUPPORTED_CPUID()) + self.get_cpuid(KVM_GET_SUPPORTED_CPUID) } /// X86 specific call to get the system emulated CPUID values #[cfg(target_arch = "x86_64")] pub fn get_emulated_cpuid(&self) -> Result { - self.get_cpuid(KVM_GET_EMULATED_CPUID()) + self.get_cpuid(KVM_GET_EMULATED_CPUID) } /// X86 specific call to get list of supported MSRS @@ -231,7 +231,7 @@ impl Kvm { // ioctl is unsafe. The kernel is trusted not to write beyond the bounds of the memory // allocated for the struct. The limit is read from nmsrs, which is set to the allocated // size (MAX_KVM_MSR_ENTRIES) above. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_MSR_INDEX_LIST(), &mut msr_list[0]) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_MSR_INDEX_LIST, &mut msr_list[0]) }; if ret < 0 { return errno_result(); } @@ -266,8 +266,7 @@ impl Kvm { pub fn get_vm_type(&self) -> c_ulong { // SAFETY: // Safe because we know self is a real kvm fd - match unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION(), KVM_CAP_ARM_VM_IPA_SIZE.into()) } - { + match unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION, KVM_CAP_ARM_VM_IPA_SIZE.into()) } { // Not supported? Use 0 as the machine type, which implies 40bit IPA ret if ret < 0 => 0, // Use the lower 8 bits representing the IPA space as the machine type @@ -351,7 +350,7 @@ impl Vm { // SAFETY: // Safe because we know kvm is a real kvm fd as this module is the only one that can make // Kvm objects. - let ret = unsafe { ioctl_with_val(kvm, KVM_CREATE_VM(), kvm.get_vm_type()) }; + let ret = unsafe { ioctl_with_val(kvm, KVM_CREATE_VM, kvm.get_vm_type()) }; if ret >= 0 { // SAFETY: // Safe because we verify the value of ret and we are the owners of the fd. @@ -392,7 +391,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a KVM fd and that the extension is one of the ones // defined by kernel. - unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION(), c as c_ulong) == 1 } + unsafe { ioctl_with_val(self, KVM_CHECK_EXTENSION, c as c_ulong) == 1 } } /// Inserts the given `mem` into the VM's address space at `guest_addr`. @@ -495,7 +494,7 @@ impl Vm { // Safe because the `dirty_bitmap` pointer assigned above is guaranteed to be valid // (because it's from a slice) and we checked that it will be large enough to hold // the entire log. - let ret = unsafe { ioctl_with_ref(self, KVM_GET_DIRTY_LOG(), &dirty_log_kvm) }; + let ret = unsafe { ioctl_with_ref(self, KVM_GET_DIRTY_LOG, &dirty_log_kvm) }; if ret == 0 { Ok(()) } else { @@ -521,7 +520,7 @@ impl Vm { pub fn set_identity_map_addr(&self, addr: GuestAddress) -> Result<()> { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_IDENTITY_MAP_ADDR(), &addr.offset()) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_IDENTITY_MAP_ADDR, &addr.offset()) }; if ret == 0 { Ok(()) } else { @@ -539,7 +538,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only write // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_CLOCK(), &mut clock_data) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_CLOCK, &mut clock_data) }; if ret == 0 { Ok(clock_data) } else { @@ -555,7 +554,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_CLOCK(), clock_data) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_CLOCK, clock_data) }; if ret == 0 { Ok(()) } else { @@ -570,7 +569,7 @@ impl Vm { pub fn create_irq_chip(&self) -> Result<()> { // SAFETY: // Safe because we know that our file is a VM fd and we verify the return result. - let ret = unsafe { ioctl(self, KVM_CREATE_IRQCHIP()) }; + let ret = unsafe { ioctl(self, KVM_CREATE_IRQCHIP) }; if ret == 0 { Ok(()) } else { @@ -590,7 +589,7 @@ impl Vm { // SAFETY: // Safe because we know our file is a VM fd, we know the kernel will only write // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_IRQCHIP(), &mut irqchip_state) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_IRQCHIP, &mut irqchip_state) }; if ret == 0 { Ok( // SAFETY: @@ -616,7 +615,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_IRQCHIP(), &irqchip_state) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_IRQCHIP, &irqchip_state) }; if ret == 0 { Ok(()) } else { @@ -638,7 +637,7 @@ impl Vm { // Safe because we know our file is a VM fd, we know the kernel will only write // correct amount of memory to our pointer, and we verify the return result. unsafe { - ioctl_with_mut_ref(self, KVM_GET_IRQCHIP(), &mut irqchip_state) + ioctl_with_mut_ref(self, KVM_GET_IRQCHIP, &mut irqchip_state) }; if ret == 0 { Ok( @@ -665,7 +664,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_IRQCHIP(), &irqchip_state) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_IRQCHIP, &irqchip_state) }; if ret == 0 { Ok(()) } else { @@ -683,7 +682,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_IRQ_LINE(), &irq_level) }; + let ret = unsafe { ioctl_with_ref(self, KVM_IRQ_LINE, &irq_level) }; if ret == 0 { Ok(()) } else { @@ -700,7 +699,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_CREATE_PIT2(), &pit_config) }; + let ret = unsafe { ioctl_with_ref(self, KVM_CREATE_PIT2, &pit_config) }; if ret == 0 { Ok(()) } else { @@ -718,7 +717,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only write // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_PIT2(), &mut pit_state) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_PIT2, &mut pit_state) }; if ret == 0 { Ok(pit_state) } else { @@ -734,7 +733,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_PIT2(), pit_state) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_PIT2, pit_state) }; if ret == 0 { Ok(()) } else { @@ -822,7 +821,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_IOEVENTFD(), &ioeventfd) }; + let ret = unsafe { ioctl_with_ref(self, KVM_IOEVENTFD, &ioeventfd) }; if ret == 0 { Ok(()) } else { @@ -849,7 +848,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_IRQFD(), &irqfd) }; + let ret = unsafe { ioctl_with_ref(self, KVM_IRQFD, &irqfd) }; if ret == 0 { Ok(()) } else { @@ -873,7 +872,7 @@ impl Vm { // SAFETY: // Safe because we know that our file is a VM fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_IRQFD(), &irqfd) }; + let ret = unsafe { ioctl_with_ref(self, KVM_IRQFD, &irqfd) }; if ret == 0 { Ok(()) } else { @@ -914,7 +913,7 @@ impl Vm { // TODO(b/315998194): Add safety comment #[allow(clippy::undocumented_unsafe_blocks)] - let ret = unsafe { ioctl_with_ref(self, KVM_SET_GSI_ROUTING(), &irq_routing[0]) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_GSI_ROUTING, &irq_routing[0]) }; if ret == 0 { Ok(()) } else { @@ -930,7 +929,7 @@ impl Vm { pub unsafe fn kvm_enable_cap(&self, cap: &kvm_enable_cap) -> Result<()> { // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = ioctl_with_ref(self, KVM_ENABLE_CAP(), cap); + let ret = ioctl_with_ref(self, KVM_ENABLE_CAP, cap); if ret < 0 { errno_result() } else { @@ -1044,7 +1043,7 @@ impl Vcpu { // SAFETY: // Safe because we know that vm a VM fd and we verify the return result. - let vcpu_fd = unsafe { ioctl_with_val(vm, KVM_CREATE_VCPU(), id) }; + let vcpu_fd = unsafe { ioctl_with_val(vm, KVM_CREATE_VCPU, id) }; if vcpu_fd < 0 { return errno_result(); } @@ -1201,7 +1200,7 @@ impl Vcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_REGS(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_REGS, &mut regs) }; if ret != 0 { return errno_result(); } @@ -1214,7 +1213,7 @@ impl Vcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_REGS(), regs) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_REGS, regs) }; if ret != 0 { return errno_result(); } @@ -1229,7 +1228,7 @@ impl Vcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_SREGS, &mut regs) }; if ret != 0 { return errno_result(); } @@ -1242,7 +1241,7 @@ impl Vcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only read the // correct amount of memory from our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_ref(self, KVM_SET_SREGS(), sregs) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_SREGS, sregs) }; if ret != 0 { return errno_result(); } @@ -1257,7 +1256,7 @@ impl Vcpu { let mut regs = unsafe { std::mem::zeroed() }; // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_FPU(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_FPU, &mut regs) }; if ret != 0 { return errno_result(); } @@ -1272,7 +1271,7 @@ impl Vcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_fpu struct. - unsafe { ioctl_with_ref(self, KVM_SET_FPU(), fpu) } + unsafe { ioctl_with_ref(self, KVM_SET_FPU, fpu) } }; if ret < 0 { return errno_result(); @@ -1288,7 +1287,7 @@ impl Vcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_DEBUGREGS(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_DEBUGREGS, &mut regs) }; if ret != 0 { return errno_result(); } @@ -1301,7 +1300,7 @@ impl Vcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_fpu struct. - unsafe { ioctl_with_ref(self, KVM_SET_DEBUGREGS(), dregs) } + unsafe { ioctl_with_ref(self, KVM_SET_DEBUGREGS, dregs) } }; if ret < 0 { return errno_result(); @@ -1317,7 +1316,7 @@ impl Vcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only write the // correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_XCRS(), &mut regs) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_XCRS, &mut regs) }; if ret != 0 { return errno_result(); } @@ -1330,7 +1329,7 @@ impl Vcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_xcrs struct. - unsafe { ioctl_with_ref(self, KVM_SET_XCRS(), xcrs) } + unsafe { ioctl_with_ref(self, KVM_SET_XCRS, xcrs) } }; if ret < 0 { return errno_result(); @@ -1357,7 +1356,7 @@ impl Vcpu { let ret = { // SAFETY: // Here we trust the kernel not to read or write past the end of the kvm_msrs struct. - unsafe { ioctl_with_ref(self, KVM_GET_MSRS(), &msrs[0]) } + unsafe { ioctl_with_ref(self, KVM_GET_MSRS, &msrs[0]) } }; if ret < 0 { // KVM_SET_MSRS actually returns the number of msr entries written. @@ -1383,7 +1382,7 @@ impl Vcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_msrs struct. - unsafe { ioctl_with_ref(self, KVM_SET_MSRS(), msrs) } + unsafe { ioctl_with_ref(self, KVM_SET_MSRS, msrs) } }; if ret < 0 { // KVM_SET_MSRS actually returns the number of msr entries written. @@ -1400,7 +1399,7 @@ impl Vcpu { let ret = { // SAFETY: // Here we trust the kernel not to read past the end of the kvm_msrs struct. - unsafe { ioctl_with_ptr(self, KVM_SET_CPUID2(), cpuid.as_ptr()) } + unsafe { ioctl_with_ptr(self, KVM_SET_CPUID2, cpuid.as_ptr()) } }; if ret < 0 { return errno_result(); @@ -1419,7 +1418,7 @@ impl Vcpu { // ioctl is unsafe. The kernel is trusted not to write beyond the bounds of the memory // allocated for the struct. The limit is read from nent, which is set to the allocated // size(MAX_KVM_CPUID_ENTRIES) above. - unsafe { ioctl_with_mut_ptr(self, KVM_GET_SUPPORTED_HV_CPUID(), cpuid.as_mut_ptr()) } + unsafe { ioctl_with_mut_ptr(self, KVM_GET_SUPPORTED_HV_CPUID, cpuid.as_mut_ptr()) } }; if ret < 0 { return errno_result(); @@ -1439,7 +1438,7 @@ impl Vcpu { // SAFETY: // The ioctl is unsafe unless you trust the kernel not to write past the end of the // local_apic struct. - unsafe { ioctl_with_mut_ref(self, KVM_GET_LAPIC(), &mut klapic) } + unsafe { ioctl_with_mut_ref(self, KVM_GET_LAPIC, &mut klapic) } }; if ret < 0 { return errno_result(); @@ -1456,7 +1455,7 @@ impl Vcpu { let ret = { // SAFETY: // The ioctl is safe because the kernel will only read from the klapic struct. - unsafe { ioctl_with_ref(self, KVM_SET_LAPIC(), klapic) } + unsafe { ioctl_with_ref(self, KVM_SET_LAPIC, klapic) } }; if ret < 0 { return errno_result(); @@ -1478,7 +1477,7 @@ impl Vcpu { // SAFETY: // Safe because we know that our file is a VCPU fd, we know the kernel will only // write correct amount of memory to our pointer, and we verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_MP_STATE(), &mut state) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_MP_STATE, &mut state) }; if ret < 0 { return errno_result(); } @@ -1497,7 +1496,7 @@ impl Vcpu { let ret = { // SAFETY: // The ioctl is safe because the kernel will only read from the kvm_mp_state struct. - unsafe { ioctl_with_ref(self, KVM_SET_MP_STATE(), state) } + unsafe { ioctl_with_ref(self, KVM_SET_MP_STATE, state) } }; if ret < 0 { return errno_result(); @@ -1516,7 +1515,7 @@ impl Vcpu { // Safe because we know that our file is a VCPU fd, we know the kernel // will only write correct amount of memory to our pointer, and we // verify the return result. - let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_VCPU_EVENTS(), &mut events) }; + let ret = unsafe { ioctl_with_mut_ref(self, KVM_GET_VCPU_EVENTS, &mut events) }; if ret < 0 { return errno_result(); } @@ -1532,7 +1531,7 @@ impl Vcpu { // SAFETY: // The ioctl is safe because the kernel will only read from the // kvm_vcpu_events. - unsafe { ioctl_with_ref(self, KVM_SET_VCPU_EVENTS(), events) } + unsafe { ioctl_with_ref(self, KVM_SET_VCPU_EVENTS, events) } }; if ret < 0 { return errno_result(); @@ -1549,7 +1548,7 @@ impl Vcpu { // SAFETY: // Safe because we allocated the struct and we know the kernel will read exactly the size of // the struct. - let ret = ioctl_with_ref(self, KVM_ENABLE_CAP(), cap); + let ret = ioctl_with_ref(self, KVM_ENABLE_CAP, cap); if ret < 0 { return errno_result(); } @@ -1585,7 +1584,7 @@ impl Vcpu { // SAFETY: // The ioctl is safe because the kernel will only read from the // kvm_signal_mask structure. - unsafe { ioctl_with_ref(self, KVM_SET_SIGNAL_MASK(), &kvm_sigmask[0]) } + unsafe { ioctl_with_ref(self, KVM_SET_SIGNAL_MASK, &kvm_sigmask[0]) } }; if ret < 0 { return errno_result(); @@ -1605,7 +1604,7 @@ impl Vcpu { // SAFETY: // safe because we allocated the struct and we know the kernel will read // exactly the size of the struct - let ret = unsafe { ioctl_with_ref(self, KVM_SET_ONE_REG(), &onereg) }; + let ret = unsafe { ioctl_with_ref(self, KVM_SET_ONE_REG, &onereg) }; if ret < 0 { return errno_result(); } @@ -1640,7 +1639,7 @@ impl RunnableVcpu { pub fn run(&self) -> Result { // SAFETY: // Safe because we know that our file is a VCPU fd and we verify the return result. - let ret = unsafe { ioctl(self, KVM_RUN()) }; + let ret = unsafe { ioctl(self, KVM_RUN) }; if ret == 0 { // SAFETY: // Safe because we know we mapped enough memory to hold the kvm_run struct because the diff --git a/kvm_sys/tests/basic.rs b/kvm_sys/tests/basic.rs index 1c2ac910f6..69af953577 100644 --- a/kvm_sys/tests/basic.rs +++ b/kvm_sys/tests/basic.rs @@ -19,7 +19,7 @@ fn get_version() { assert!(sys_fd >= 0); // SAFETY: sys_fd is expected to be valid and return value is checked. - let ret = unsafe { ioctl(sys_fd, KVM_GET_API_VERSION(), 0) }; + let ret = unsafe { ioctl(sys_fd, KVM_GET_API_VERSION, 0) }; assert_eq!(ret as u32, KVM_API_VERSION); } @@ -30,7 +30,7 @@ fn create_vm_fd() { assert!(sys_fd >= 0); // SAFETY: sys_fd is expected to be valid and return value is checked. - let vm_fd = unsafe { ioctl(sys_fd, KVM_CREATE_VM(), 0) }; + let vm_fd = unsafe { ioctl(sys_fd, KVM_CREATE_VM, 0) }; assert!(vm_fd >= 0); } @@ -41,6 +41,6 @@ fn check_vm_extension() { assert!(sys_fd >= 0); // SAFETY: sys_fd is expected to be valid and return value is checked. - let has_user_memory = unsafe { ioctl(sys_fd, KVM_CHECK_EXTENSION(), KVM_CAP_USER_MEMORY) }; + let has_user_memory = unsafe { ioctl(sys_fd, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY) }; assert_eq!(has_user_memory, 1); } diff --git a/net_util/src/sys/linux/tap.rs b/net_util/src/sys/linux/tap.rs index a5b8046043..cf707c1be6 100644 --- a/net_util/src/sys/linux/tap.rs +++ b/net_util/src/sys/linux/tap.rs @@ -62,7 +62,7 @@ impl Tap { // Get the interface name since we will need it for some ioctls. let mut ifreq: net_sys::ifreq = Default::default(); - let ret = ioctl_with_mut_ref(&tap_file, net_sys::TUNGETIFF(), &mut ifreq); + let ret = ioctl_with_mut_ref(&tap_file, net_sys::TUNGETIFF, &mut ifreq); if ret < 0 { return Err(Error::IoctlError(SysError::last())); @@ -95,7 +95,7 @@ impl Tap { // SAFETY: // ioctl is safe since we call it with a valid tap fd and check the return // value. - let ret = unsafe { ioctl_with_mut_ref(&tuntap, net_sys::TUNSETIFF(), ifreq) }; + let ret = unsafe { ioctl_with_mut_ref(&tuntap, net_sys::TUNSETIFF, ifreq) }; if ret < 0 { return Err(Error::CreateTap(SysError::last())); @@ -389,7 +389,7 @@ impl TapTCommon for Tap { let ret = // SAFETY: // ioctl is safe. Called with a valid tap descriptor, and we check the return. - unsafe { ioctl_with_val(&self.tap_file, net_sys::TUNSETOFFLOAD(), flags as c_ulong) }; + unsafe { ioctl_with_val(&self.tap_file, net_sys::TUNSETOFFLOAD, flags as c_ulong) }; if ret < 0 { return Err(Error::IoctlError(SysError::last())); } @@ -431,7 +431,7 @@ impl TapTLinux for Tap { let size = size as c_int; // SAFETY: // ioctl is safe. Called with a valid tap descriptor, and we check the return. - let ret = unsafe { ioctl_with_ref(&self.tap_file, net_sys::TUNSETVNETHDRSZ(), &size) }; + let ret = unsafe { ioctl_with_ref(&self.tap_file, net_sys::TUNSETVNETHDRSZ, &size) }; if ret < 0 { return Err(Error::IoctlError(SysError::last())); } diff --git a/swap/src/userfaultfd.rs b/swap/src/userfaultfd.rs index 10b9df6e16..439d6eb9f9 100644 --- a/swap/src/userfaultfd.rs +++ b/swap/src/userfaultfd.rs @@ -195,7 +195,7 @@ impl Factory { let res = unsafe { ioctl_with_val( dev_file, - USERFAULTFD_IOC_NEW(), + USERFAULTFD_IOC_NEW, (libc::O_CLOEXEC | libc::O_NONBLOCK) as libc::c_ulong, ) }; @@ -213,7 +213,7 @@ impl Factory { }; // SAFETY: // Safe because ioctl(2) UFFDIO_API with does not change Rust memory safety. - let res = unsafe { ioctl_with_mut_ref(&uffd, UFFDIO_API(), &mut api) }; + let res = unsafe { ioctl_with_mut_ref(&uffd, UFFDIO_API, &mut api) }; if res < 0 { errno_result().context("UFFDIO_API") } else { diff --git a/usb_util/src/device.rs b/usb_util/src/device.rs index bc338d88af..9bb3918319 100644 --- a/usb_util/src/device.rs +++ b/usb_util/src/device.rs @@ -276,7 +276,7 @@ impl Device { // Safe because we control the lifetime of the URB via Arc::into_raw() and // Arc::from_raw() in poll_transfers(). unsafe { - self.ioctl_with_mut_ptr(usb_sys::USBDEVFS_SUBMITURB(), urb_ptr)?; + self.ioctl_with_mut_ptr(usb_sys::USBDEVFS_SUBMITURB, urb_ptr)?; } let weak_transfer = Arc::downgrade(&rc_transfer); @@ -296,7 +296,7 @@ impl Device { let result = // SAFETY: // Safe because we provide a valid urb_ptr to be filled by the kernel. - unsafe { self.ioctl_with_mut_ref(usb_sys::USBDEVFS_REAPURBNDELAY(), &mut urb_ptr) }; + unsafe { self.ioctl_with_mut_ref(usb_sys::USBDEVFS_REAPURBNDELAY, &mut urb_ptr) }; match result { // EAGAIN indicates no more completed transfers right now. Err(Error::IoctlFailed(_nr, e)) if e.errno() == EAGAIN => break, @@ -350,7 +350,7 @@ impl Device { // SAFETY: // Safe because self.fd is a valid usbdevfs file descriptor. - let result = unsafe { self.ioctl(usb_sys::USBDEVFS_RESET()) }; + let result = unsafe { self.ioctl(usb_sys::USBDEVFS_RESET) }; if let Err(Error::IoctlFailed(_nr, errno_err)) = result { // The device may disappear after a reset if e.g. its firmware changed. @@ -375,7 +375,7 @@ impl Device { // Safe because self.fd is a valid usbdevfs file descriptor and we pass a valid // pointer to a usbdevs_disconnect_claim structure. unsafe { - self.ioctl_with_ref(usb_sys::USBDEVFS_DISCONNECT_CLAIM(), &disconnect_claim)?; + self.ioctl_with_ref(usb_sys::USBDEVFS_DISCONNECT_CLAIM, &disconnect_claim)?; } Ok(()) @@ -388,7 +388,7 @@ impl Device { // Safe because self.fd is a valid usbdevfs file descriptor and we pass a valid // pointer to unsigned int. unsafe { - self.ioctl_with_ref(usb_sys::USBDEVFS_RELEASEINTERFACE(), &ifnum)?; + self.ioctl_with_ref(usb_sys::USBDEVFS_RELEASEINTERFACE, &ifnum)?; } Ok(()) @@ -408,7 +408,7 @@ impl Device { // Safe because self.fd is a valid usbdevfs file descriptor and we pass a valid // pointer to a usbdevfs_setinterface structure. unsafe { - self.ioctl_with_ref(usb_sys::USBDEVFS_SETINTERFACE(), &setinterface)?; + self.ioctl_with_ref(usb_sys::USBDEVFS_SETINTERFACE, &setinterface)?; } Ok(()) } @@ -420,7 +420,7 @@ impl Device { // Safe because self.fd is a valid usbdevfs file descriptor and we pass a valid // pointer to int. unsafe { - self.ioctl_with_ref(usb_sys::USBDEVFS_SETCONFIGURATION(), &config)?; + self.ioctl_with_ref(usb_sys::USBDEVFS_SETCONFIGURATION, &config)?; } Ok(()) @@ -487,7 +487,7 @@ impl Device { // Safe because self.fd is a valid usbdevfs file descriptor and we pass a valid // pointer to a usbdevfs_ctrltransfer structure. unsafe { - self.ioctl_with_ref(usb_sys::USBDEVFS_CONTROL(), &ctrl_transfer)?; + self.ioctl_with_ref(usb_sys::USBDEVFS_CONTROL, &ctrl_transfer)?; } Ok(active_config) } @@ -504,7 +504,7 @@ impl Device { // Safe because self.fd is a valid usbdevfs file descriptor and we pass a valid // pointer to unsigned int. unsafe { - self.ioctl_with_ref(usb_sys::USBDEVFS_CLEAR_HALT(), &endpoint)?; + self.ioctl_with_ref(usb_sys::USBDEVFS_CLEAR_HALT, &endpoint)?; } Ok(()) @@ -513,7 +513,7 @@ impl Device { /// Get speed of this device. pub fn get_speed(&self) -> Result> { // SAFETY: args are valid and the return value is checked - let speed = unsafe { self.ioctl(usb_sys::USBDEVFS_GET_SPEED()) }?; + let speed = unsafe { self.ioctl(usb_sys::USBDEVFS_GET_SPEED) }?; match speed { 1 => Ok(Some(DeviceSpeed::Low)), // Low Speed 2 => Ok(Some(DeviceSpeed::Full)), // Full Speed @@ -541,7 +541,7 @@ impl Device { // Safe because self.fd is a valid usbdevfs file descriptor and we pass a valid // pointer to a usbdevfs_streams structure. unsafe { - self.ioctl_with_ref(usb_sys::USBDEVFS_ALLOC_STREAMS(), &streams[0])?; + self.ioctl_with_ref(usb_sys::USBDEVFS_ALLOC_STREAMS, &streams[0])?; } Ok(()) } @@ -558,7 +558,7 @@ impl Device { // Safe because self.fd is a valid usbdevfs file descriptor and we pass a valid // pointer to a usbdevfs_streams structure. unsafe { - self.ioctl_with_ref(usb_sys::USBDEVFS_FREE_STREAMS(), &streams[0])?; + self.ioctl_with_ref(usb_sys::USBDEVFS_FREE_STREAMS, &streams[0])?; } Ok(()) } @@ -699,13 +699,13 @@ impl TransferHandle { if unsafe { handle_eintr_errno!(base::ioctl_with_mut_ptr( &*fd, - usb_sys::USBDEVFS_DISCARDURB(), + usb_sys::USBDEVFS_DISCARDURB, urb_ptr )) } < 0 { return Err(Error::IoctlFailed( - usb_sys::USBDEVFS_DISCARDURB(), + usb_sys::USBDEVFS_DISCARDURB, base::Error::last(), )); } diff --git a/vhost/src/lib.rs b/vhost/src/lib.rs index 99f32e5db1..b474bf2f7c 100644 --- a/vhost/src/lib.rs +++ b/vhost/src/lib.rs @@ -82,7 +82,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost_net descriptor and has its // return value checked. - let ret = unsafe { ioctl(self, virtio_sys::VHOST_SET_OWNER()) }; + let ret = unsafe { ioctl(self, virtio_sys::VHOST_SET_OWNER) }; if ret < 0 { return ioctl_result(); } @@ -95,7 +95,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost fd and has its // return value checked. - let ret = unsafe { ioctl(self, virtio_sys::VHOST_RESET_OWNER()) }; + let ret = unsafe { ioctl(self, virtio_sys::VHOST_RESET_OWNER) }; if ret < 0 { return ioctl_result(); } @@ -109,7 +109,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // This ioctl is called on a valid vhost_net descriptor and has its // return value checked. let ret = unsafe { - ioctl_with_mut_ref(self, virtio_sys::VHOST_GET_FEATURES(), &mut avail_features) + ioctl_with_mut_ref(self, virtio_sys::VHOST_GET_FEATURES, &mut avail_features) }; if ret < 0 { return ioctl_result(); @@ -126,7 +126,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost_net descriptor and has its // return value checked. - let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_FEATURES(), &features) }; + let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_FEATURES, &features) }; if ret < 0 { return ioctl_result(); } @@ -171,7 +171,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // This ioctl is called with a pointer that is valid for the lifetime // of this function. The kernel will make its own copy of the memory // tables. As always, check the return value. - let ret = unsafe { ioctl_with_ptr(self, virtio_sys::VHOST_SET_MEM_TABLE(), vhost_memory) }; + let ret = unsafe { ioctl_with_ptr(self, virtio_sys::VHOST_SET_MEM_TABLE, vhost_memory) }; if ret < 0 { return ioctl_result(); } @@ -195,7 +195,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost_net descriptor and has its // return value checked. - let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_NUM(), &vring_state) }; + let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_NUM, &vring_state) }; if ret < 0 { return ioctl_result(); } @@ -300,7 +300,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost_net descriptor and has its // return value checked. - let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_ADDR(), &vring_addr) }; + let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_ADDR, &vring_addr) }; if ret < 0 { return ioctl_result(); } @@ -321,7 +321,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost_net descriptor and has its // return value checked. - let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_BASE(), &vring_state) }; + let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_BASE, &vring_state) }; if ret < 0 { return ioctl_result(); } @@ -340,9 +340,8 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // Safe because this will only modify `vring_state` and we check the return value. - let ret = unsafe { - ioctl_with_mut_ref(self, virtio_sys::VHOST_GET_VRING_BASE(), &mut vring_state) - }; + let ret = + unsafe { ioctl_with_mut_ref(self, virtio_sys::VHOST_GET_VRING_BASE, &mut vring_state) }; if ret < 0 { return ioctl_result(); } @@ -364,7 +363,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost_net descriptor and has its // return value checked. - let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_CALL(), &vring_file) }; + let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_CALL, &vring_file) }; if ret < 0 { return ioctl_result(); } @@ -385,7 +384,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost_net fd and has its // return value checked. - let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_ERR(), &vring_file) }; + let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_ERR, &vring_file) }; if ret < 0 { return ioctl_result(); } @@ -407,7 +406,7 @@ pub trait Vhost: AsRawDescriptor + std::marker::Sized { // SAFETY: // This ioctl is called on a valid vhost_net descriptor and has its // return value checked. - let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_KICK(), &vring_file) }; + let ret = unsafe { ioctl_with_ref(self, virtio_sys::VHOST_SET_VRING_KICK, &vring_file) }; if ret < 0 { return ioctl_result(); } diff --git a/vhost/src/net.rs b/vhost/src/net.rs index d3236a2ccd..d846b755d2 100644 --- a/vhost/src/net.rs +++ b/vhost/src/net.rs @@ -74,7 +74,7 @@ where let ret = unsafe { ioctl_with_ref( &self.descriptor, - virtio_sys::VHOST_NET_SET_BACKEND(), + virtio_sys::VHOST_NET_SET_BACKEND, &vring_file, ) }; diff --git a/vhost/src/vsock.rs b/vhost/src/vsock.rs index d61064ac84..fdf924eb0c 100644 --- a/vhost/src/vsock.rs +++ b/vhost/src/vsock.rs @@ -35,7 +35,7 @@ impl Vsock { /// * `cid` - CID to assign to the guest pub fn set_cid(&self, cid: u64) -> Result<()> { // SAFETY: Safe because descriptor is valid and the return value is checked. - let ret = unsafe { ioctl_with_ref(&self.descriptor, VHOST_VSOCK_SET_GUEST_CID(), &cid) }; + let ret = unsafe { ioctl_with_ref(&self.descriptor, VHOST_VSOCK_SET_GUEST_CID, &cid) }; if ret < 0 { return ioctl_result(); } @@ -55,7 +55,7 @@ impl Vsock { fn set_running(&self, running: bool) -> Result<()> { let on = ::std::os::raw::c_int::from(running); // SAFETY: Safe because descriptor is valid and the return value is checked. - let ret = unsafe { ioctl_with_ref(&self.descriptor, VHOST_VSOCK_SET_RUNNING(), &on) }; + let ret = unsafe { ioctl_with_ref(&self.descriptor, VHOST_VSOCK_SET_RUNNING, &on) }; if ret < 0 { return ioctl_result(); diff --git a/vm_memory/src/udmabuf/sys/linux.rs b/vm_memory/src/udmabuf/sys/linux.rs index 2268cc6094..9c26480b28 100644 --- a/vm_memory/src/udmabuf/sys/linux.rs +++ b/vm_memory/src/udmabuf/sys/linux.rs @@ -118,7 +118,7 @@ impl UdmabufDriverTrait for UnixUdmabufDriver { let fd = unsafe { let create_list = list.as_mut_ptr(); (*create_list).flags = UDMABUF_FLAGS_CLOEXEC; - ioctl_with_ptr(&self.driver_fd, UDMABUF_CREATE_LIST(), create_list) + ioctl_with_ptr(&self.driver_fd, UDMABUF_CREATE_LIST, create_list) }; if fd < 0 {