arch64: add necessary kvm ioctls

Tested that cargo test is functional on aarch64 too.

Signed-off-by: Diana Popa <[email protected]>

Author: dianpopa

src/ioctls/device.rs

@@ -0,0 +1,97 @@
+// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use std::fs::File;
+use std::io;
+use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
+
+use kvm_bindings::kvm_device_attr;
+
+use ioctls::Result;
+use kvm_ioctls::KVM_SET_DEVICE_ATTR;
+use sys_ioctl::ioctl_with_ref;
+
+/// Wrapper over the file descriptor obtained when creating an emulated device in the kernel.
+pub struct DeviceFd {
+    fd: File,
+}
+
+impl DeviceFd {
+    /// Sets a specified piece of device configuration and/or state.
+    ///
+    /// See the documentation for `KVM_SET_DEVICE_ATTR`.
+    /// # Arguments
+    ///
+    /// * `device_attr` - The device attribute to be set.
+    ///
+    pub fn set_device_attr(&self, device_attr: &kvm_device_attr) -> Result<()> {
+        let ret = unsafe { ioctl_with_ref(self, KVM_SET_DEVICE_ATTR(), device_attr) };
+        if ret != 0 {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+}
+
+/// Helper function for creating a new device.
+pub fn new_device(dev_fd: File) -> DeviceFd {
+    DeviceFd { fd: dev_fd }
+}
+
+impl AsRawFd for DeviceFd {
+    fn as_raw_fd(&self) -> RawFd {
+        self.fd.as_raw_fd()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ioctls::system::Kvm;
+    use kvm_bindings::{
+        kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V3, kvm_device_type_KVM_DEV_TYPE_FSL_MPIC_20,
+        kvm_device_type_KVM_DEV_TYPE_VFIO, KVM_CREATE_DEVICE_TEST, KVM_DEV_VFIO_GROUP,
+        KVM_DEV_VFIO_GROUP_ADD,
+    };
+    use std::io::{Error, ErrorKind};
+
+    #[test]
+    fn test_create_device() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+
+        let mut gic_device = kvm_bindings::kvm_create_device {
+            #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+            type_: kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V3,
+            #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+            type_: kvm_device_type_KVM_DEV_TYPE_FSL_MPIC_20,
+            fd: 0,
+            flags: KVM_CREATE_DEVICE_TEST,
+        };
+        // This fails on x86_64 because there is no VGIC there.
+        // This fails on aarch64 as it does not use MPIC (MultiProcessor Interrupt Controller), it uses
+        // the VGIC.
+        assert!(vm.create_device(&mut gic_device).is_err());
+
+        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
+            gic_device.type_ = kvm_device_type_KVM_DEV_TYPE_VFIO;
+        } else if cfg!(any(target_arch = "arm", target_arch = "aarch64")) {
+            gic_device.type_ = kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V3;
+        }
+        let device_fd = vm
+            .create_device(&mut gic_device)
+            .expect("Cannot create KVM device");
+
+        let dist_attr = kvm_bindings::kvm_device_attr {
+            group: KVM_DEV_VFIO_GROUP,
+            attr: KVM_DEV_VFIO_GROUP_ADD as u64,
+            addr: 0x0,
+            flags: 0,
+        };
+        device_fd.set_device_attr(&dist_attr);
+        // We are just creating a test device. Creating a real device would make the CI dependent
+        // on host configuration (like having /dev/vfio). We expect this to fail.
+        assert!(device_fd.set_device_attr(&dist_attr).is_err());
+        assert_eq!(io::Error::last_os_error().raw_os_error().unwrap(), 25);
+    }
+}

src/ioctls/mod.rs

@@ -1,12 +1,15 @@
-use kvm_bindings::kvm_run;
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-use kvm_bindings::{kvm_cpuid2, kvm_cpuid_entry2};
 use std::io;
 use std::mem::size_of;
 use std::os::unix::io::AsRawFd;
 use std::ptr::null_mut;
 use std::result;
 
+use kvm_bindings::kvm_run;
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+use kvm_bindings::{kvm_cpuid2, kvm_cpuid_entry2};
+
+/// Wrappers over KVM device ioctls.
+pub mod device;
 /// Wrappers over KVM system ioctls.
 pub mod system;
 /// Wrappers over KVM VCPU ioctls.

src/ioctls/system.rs

@@ -350,9 +350,13 @@ mod tests {
         assert_eq!(get_raw_errno(faulty_kvm.get_vcpu_mmap_size()), badf_errno);
         assert_eq!(faulty_kvm.get_nr_vcpus(), 4);
         assert_eq!(faulty_kvm.get_nr_memslots(), 32);
-        assert_eq!(get_raw_errno(faulty_kvm.get_emulated_cpuid(4)), badf_errno);
-        assert_eq!(get_raw_errno(faulty_kvm.get_supported_cpuid(4)), badf_errno);
-        assert_eq!(get_raw_errno(faulty_kvm.get_msr_index_list()), badf_errno);
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        {
+            assert_eq!(get_raw_errno(faulty_kvm.get_emulated_cpuid(4)), badf_errno);
+            assert_eq!(get_raw_errno(faulty_kvm.get_supported_cpuid(4)), badf_errno);
+
+            assert_eq!(get_raw_errno(faulty_kvm.get_msr_index_list()), badf_errno);
+        }
         assert_eq!(get_raw_errno(faulty_kvm.create_vm()), badf_errno);
     }
 }

src/ioctls/vcpu.rs

@@ -293,6 +293,52 @@ impl VcpuFd {
         Ok(())
     }
 
+    /// Sets the type of CPU to be exposed to the guest and optional features.
+    ///
+    /// This initializes an ARM vCPU to the specified type with the specified features
+    /// and resets the values of all of its registers to defaults.
+    ///
+    /// # Arguments
+    ///
+    /// * `kvi` - information about preferred CPU target type and recommended features for it.
+    ///
+    #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+    pub fn vcpu_init(&self, kvi: &kvm_vcpu_init) -> Result<()> {
+        // This is 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) };
+        if ret < 0 {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+
+    /// Sets the value of one register for this vCPU.
+    ///
+    /// The id of the register is encoded as specified in the kernel documentation
+    /// for `KVM_SET_ONE_REG`.
+    ///
+    /// # Arguments
+    ///
+    /// * `reg_id` - ID of the register for which we are setting the value.
+    /// * `data` - value for the specified register.
+    ///
+    #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+    pub fn set_one_reg(&self, reg_id: u64, data: u64) -> Result<()> {
+        let data_ref = &data as *const u64;
+        let onereg = kvm_one_reg {
+            id: reg_id,
+            addr: data_ref as u64,
+        };
+        // This is 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) };
+        if ret < 0 {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+
     /// Triggers the running of the current virtual CPU returning an exit reason.
     ///
     pub fn run(&self) -> Result<VcpuExit> {
@@ -718,4 +764,41 @@ mod tests {
         );
         assert_eq!(get_raw_errno(faulty_vcpu_fd.run()), badf_errno);
     }
+
+    #[test]
+    #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+    fn test_get_preferred_target() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+        let vcpu = vm.create_vcpu(0).unwrap();
+
+        let mut kvi: kvm_bindings::kvm_vcpu_init = kvm_bindings::kvm_vcpu_init::default();
+        assert!(vcpu.vcpu_init(&kvi).is_err());
+
+        vm.get_preferred_target(&mut kvi)
+            .expect("Cannot get preferred target");
+        assert!(vcpu.vcpu_init(&kvi).is_ok());
+    }
+
+    #[test]
+    #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+    fn test_set_one_reg() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+        let vcpu = vm.create_vcpu(0).unwrap();
+
+        let mut kvi: kvm_bindings::kvm_vcpu_init = kvm_bindings::kvm_vcpu_init::default();
+        vm.get_preferred_target(&mut kvi)
+            .expect("Cannot get preferred target");
+        vcpu.vcpu_init(&kvi).expect("Cannot initialize vcpu");
+        let mut data: u64 = 0;
+        let mut reg_id: u64 = 0;
+
+        assert!(vcpu.set_one_reg(reg_id, data).is_err());
+        // Exercising KVM_SET_ONE_REG by trying to alter the data inside the PSTATE register (which is a
+        // specific aarch64 register).
+        const PSTATE_REG_ID: u64 = 0x6030_0000_0010_0042;
+        vcpu.set_one_reg(PSTATE_REG_ID, data)
+            .expect("Failed to set pstate register");
+    }
 }

src/ioctls/vm.rs

@@ -5,6 +5,8 @@ use std::io;
 use std::os::raw::{c_ulong, c_void};
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 
+use ioctls::device::new_device;
+use ioctls::device::DeviceFd;
 use ioctls::vcpu::new_vcpu;
 use ioctls::vcpu::VcpuFd;
 use ioctls::KvmRunWrapper;
@@ -246,6 +248,28 @@ impl VmFd {
         Ok(new_vcpu(vcpu, kvm_run_ptr))
     }
 
+    /// Creates an emulated device in the kernel.
+    pub fn create_device(&self, device: &mut kvm_create_device) -> Result<DeviceFd> {
+        let ret = unsafe { ioctl_with_ref(self, KVM_CREATE_DEVICE(), device) };
+        if ret == 0 {
+            Ok((new_device(unsafe { File::from_raw_fd(device.fd as i32) })))
+        } else {
+            return Err(io::Error::last_os_error());
+        }
+    }
+
+    /// This queries the kernel for the preferred target CPU type.
+    #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+    pub fn get_preferred_target(&self, kvi: &mut kvm_vcpu_init) -> Result<()> {
+        // The ioctl is 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, KVM_ARM_PREFERRED_TARGET(), kvi) };
+        if ret != 0 {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+
     /// Get the `kvm_run` size.
     pub fn get_run_size(&self) -> usize {
         self.run_size
@@ -307,7 +331,12 @@ mod tests {
         let kvm = Kvm::new().unwrap();
         assert!(kvm.check_extension(Cap::Irqchip));
         let vm = kvm.create_vm().unwrap();
-        assert!(vm.create_irq_chip().is_ok());
+        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
+            assert!(vm.create_irq_chip().is_ok());
+        } else if cfg!(any(target_arch = "arm", target_arch = "aarch64")) {
+            // On arm, we expect this to fail as the irq chip needs to be created after the vcpus.
+            assert!(vm.create_irq_chip().is_err());
+        }
     }
 
     #[test]
@@ -358,11 +387,15 @@ mod tests {
         let evtfd1 = unsafe { eventfd(0, EFD_NONBLOCK) };
         let evtfd2 = unsafe { eventfd(0, EFD_NONBLOCK) };
         let evtfd3 = unsafe { eventfd(0, EFD_NONBLOCK) };
+        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
+            assert!(vm_fd.register_irqfd(evtfd1, 4).is_ok());
+            assert!(vm_fd.register_irqfd(evtfd2, 8).is_ok());
+            assert!(vm_fd.register_irqfd(evtfd3, 4).is_ok());
+        }
 
-        assert!(vm_fd.register_irqfd(evtfd1, 4).is_ok());
-        assert!(vm_fd.register_irqfd(evtfd2, 8).is_ok());
-        assert!(vm_fd.register_irqfd(evtfd3, 4).is_ok());
-
+        // On aarch64, this fails because setting up the interrupt controller is mandatory before
+        // registering any IRQ.
+        // On x86_64 this fails as the event fd was already matched with a GSI.
         assert!(vm_fd.register_irqfd(evtfd3, 4).is_err());
         assert!(vm_fd.register_irqfd(evtfd3, 5).is_err());
     }
@@ -413,4 +446,13 @@ mod tests {
 
         assert_eq!(get_raw_errno(faulty_vm_fd.get_dirty_log(0, 0)), badf_errno);
     }
+
+    #[test]
+    #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+    fn test_get_preferred_target() {
+        let kvm = Kvm::new().unwrap();
+        let vm = kvm.create_vm().unwrap();
+        let mut kvi: kvm_bindings::kvm_vcpu_init = kvm_bindings::kvm_vcpu_init::default();
+        assert!(vm.get_preferred_target(&mut kvi).is_ok());
+    }
 }

src/kvm_ioctls.rs

@@ -82,6 +82,14 @@ ioctl_iow_nr!(KVM_SET_FPU, KVMIO, 0x8d, kvm_fpu);
 ioctl_ior_nr!(KVM_GET_LAPIC, KVMIO, 0x8e, kvm_lapic_state);
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 ioctl_iow_nr!(KVM_SET_LAPIC, KVMIO, 0x8f, kvm_lapic_state);
+#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+ioctl_iow_nr!(KVM_SET_ONE_REG, KVMIO, 0xac, kvm_one_reg);
+#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+ioctl_iow_nr!(KVM_ARM_VCPU_INIT, KVMIO, 0xae, kvm_vcpu_init);
+#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+ioctl_ior_nr!(KVM_ARM_PREFERRED_TARGET, KVMIO, 0xaf, kvm_vcpu_init);
+ioctl_iowr_nr!(KVM_CREATE_DEVICE, KVMIO, 0xe0, kvm_create_device);
+ioctl_iow_nr!(KVM_SET_DEVICE_ATTR, KVMIO, 0xe1, kvm_device_attr);
 
 #[cfg(test)]
 mod tests {

src/lib.rs

@@ -20,6 +20,7 @@ mod cap;
 mod ioctls;
 
 pub use cap::Cap;
+pub use ioctls::device::DeviceFd;
 pub use ioctls::system::Kvm;
 pub use ioctls::vcpu::{VcpuExit, VcpuFd};
 pub use ioctls::vm::VmFd;

tests/coverage

@@ -1 +1 @@
-91.1
+91.3