Share vm and vcpu fds

These descriptors are required for handling the KVM_FAULT_MEMORY vmexit.
Although this vmexit is only present when the tee feature is enabled,
changing for a reference does not seem the right thing to do by using
feratures. Use reference and protect it to be able to share these
descriptors. These changes prepare the code for handling
KVM_EXIT_FAULT_MEMORY

Signed-off-by: Matias Ezequiel Vara Larsen <[email protected]>

Author: MatiasVara

src/vmm/src/builder.rs

@@ -1019,13 +1019,13 @@ fn attach_legacy_devices(
 ) -> std::result::Result<(), StartMicrovmError> {
     if let Some(serial) = serial {
         mmio_device_manager
-            .register_mmio_serial(vm.fd(), kernel_cmdline, serial)
+            .register_mmio_serial(&vm.fd.lock().unwrap(), kernel_cmdline, serial)
             .map_err(Error::RegisterMMIODevice)
             .map_err(StartMicrovmError::Internal)?;
     }
 
     mmio_device_manager
-        .register_mmio_rtc(vm.fd())
+        .register_mmio_rtc(&vm.fd.lock().unwrap())
         .map_err(Error::RegisterMMIODevice)
         .map_err(StartMicrovmError::Internal)?;
 
@@ -1110,12 +1110,12 @@ fn create_vcpus_aarch64(
     for cpu_index in 0..vcpu_config.vcpu_count {
         let mut vcpu = Vcpu::new_aarch64(
             cpu_index,
-            vm.fd(),
+            &vm.fd.lock().unwrap(),
             exit_evt.try_clone().map_err(Error::EventFd)?,
         )
         .map_err(Error::Vcpu)?;
 
-        vcpu.configure_aarch64(vm.fd(), guest_mem, entry_addr)
+        vcpu.configure_aarch64(&vm.fd.lock().unwrap(), guest_mem, entry_addr)
             .map_err(Error::Vcpu)?;
 
         vcpus.push(vcpu);
@@ -1177,9 +1177,12 @@ fn attach_mmio_device(
     let _cmdline = &mut vmm.kernel_cmdline;
 
     #[cfg(target_os = "linux")]
-    let (_mmio_base, _irq) =
-        vmm.mmio_device_manager
-            .register_mmio_device(vmm.vm.fd(), device, type_id, id)?;
+    let (_mmio_base, _irq) = vmm.mmio_device_manager.register_mmio_device(
+        &vmm.vm.fd.lock().unwrap(),
+        device,
+        type_id,
+        id,
+    )?;
     #[cfg(target_os = "macos")]
     let (_mmio_base, _irq) = vmm
         .mmio_device_manager

src/vmm/src/linux/vstate.rs

@@ -14,6 +14,9 @@ use std::io;
 #[cfg(feature = "tee")]
 use std::os::unix::io::RawFd;
 
+use std::sync::Arc;
+use std::sync::Mutex;
+
 use std::result;
 use std::sync::atomic::{fence, Ordering};
 #[cfg(not(test))]
@@ -470,7 +473,7 @@ impl KvmContext {
 
 /// A wrapper around creating and using a VM.
 pub struct Vm {
-    fd: VmFd,
+    pub fd: Arc<Mutex<VmFd>>,
     next_mem_slot: u32,
 
     // X86 specific fields.
@@ -510,7 +513,7 @@ impl Vm {
             arch::x86_64::msr::supported_guest_msrs(kvm).map_err(Error::GuestMSRs)?;
 
         Ok(Vm {
-            fd: vm_fd,
+            fd: Arc::new(Mutex::new(vm_fd)),
             next_mem_slot: 0,
             #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
             supported_cpuid,
@@ -590,6 +593,8 @@ impl Vm {
 
                 let id: RawFd = self
                     .fd
+                    .lock()
+                    .unwrap()
                     .create_guest_memfd(gmem)
                     .map_err(Error::CreateGuestMemfd)?;
 
@@ -611,6 +616,8 @@ impl Vm {
                 // are not overlapping.
                 unsafe {
                     self.fd
+                        .lock()
+                        .unwrap()
                         .set_user_memory_region2(memory_region)
                         .map_err(Error::SetUserMemoryRegion2)?;
                 };
@@ -623,7 +630,7 @@ impl Vm {
                     attributes: KVM_MEMORY_ATTRIBUTE_PRIVATE as u64,
                     flags: 0,
                 };
-                self.fd.set_memory_attributes(attr).unwrap();
+                self.fd.lock().unwrap().set_memory_attributes(attr).unwrap();
             }
             #[cfg(not(feature = "tee"))]
             {
@@ -638,6 +645,8 @@ impl Vm {
                 // are not overlapping.
                 unsafe {
                     self.fd
+                        .lock()
+                        .unwrap()
                         .set_user_memory_region(memory_region)
                         .map_err(Error::SetUserMemoryRegion)?;
                 };
@@ -727,7 +736,8 @@ impl Vm {
     #[cfg(target_arch = "aarch64")]
     pub fn setup_irqchip(&mut self, vcpu_count: u8) -> Result<()> {
         self.irqchip_handle = Some(
-            arch::aarch64::gic::create_gic(&self.fd, vcpu_count.into()).map_err(Error::SetupGIC)?,
+            arch::aarch64::gic::create_gic(&self.fd.lock().unwrap(), vcpu_count.into())
+                .map_err(Error::SetupGIC)?,
         );
         Ok(())
     }
@@ -739,11 +749,6 @@ impl Vm {
         self.irqchip_handle.as_ref().unwrap()
     }
 
-    /// Gets a reference to the kvm file descriptor owned by this VM.
-    pub fn fd(&self) -> &VmFd {
-        &self.fd
-    }
-
     #[allow(unused)]
     #[cfg(target_arch = "x86_64")]
     /// Saves and returns the Kvm Vm state.
@@ -835,7 +840,7 @@ type VcpuCell = Cell<Option<*mut Vcpu>>;
 
 /// A wrapper around creating and using a kvm-based VCPU.
 pub struct Vcpu {
-    fd: VcpuFd,
+    pub fd: VcpuFd,
     id: u8,
     mmio_bus: Option<devices::Bus>,
     #[allow(dead_code)]