feat(virtio-pmem): add device to the Vmm

Add methods to attach virtio-pmem devices to Vmm.
Add methods to create KVM memory slot for virtio-pmem devices.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

src/vmm/src/builder.rs

@@ -33,6 +33,7 @@ use crate::devices::acpi::vmgenid::VmGenIdError;
 use crate::devices::virtio::balloon::Balloon;
 use crate::devices::virtio::block::device::Block;
 use crate::devices::virtio::net::Net;
+use crate::devices::virtio::pmem::device::Pmem;
 use crate::devices::virtio::rng::Entropy;
 use crate::devices::virtio::vsock::{Vsock, VsockUnixBackend};
 #[cfg(feature = "gdb")]
@@ -68,6 +69,8 @@ pub enum StartMicrovmError {
     CreateGuestConfig(#[from] GuestConfigError),
     /// Cannot create network device: {0}
     CreateNetDevice(crate::devices::virtio::net::NetError),
+    /// Cannot create pmem device: {0}
+    CreatePmemDevice(#[from] crate::devices::virtio::pmem::device::PmemError),
     /// Cannot create RateLimiter: {0}
     CreateRateLimiter(io::Error),
     /// Error creating legacy device: {0}
@@ -219,6 +222,13 @@ pub fn build_microvm_for_boot(
         vm_resources.net_builder.iter(),
         event_manager,
     )?;
+    attach_pmem_devices(
+        &mut device_manager,
+        &vm,
+        &mut boot_cmdline,
+        vm_resources.pmem.devices.iter(),
+        event_manager,
+    )?;
 
     if let Some(unix_vsock) = vm_resources.vsock.get() {
         attach_unixsock_vsock_device(
@@ -609,6 +619,34 @@ fn attach_net_devices<'a, I: Iterator<Item = &'a Arc<Mutex<Net>>> + Debug>(
     Ok(())
 }
 
+fn attach_pmem_devices<'a, I: Iterator<Item = &'a Arc<Mutex<Pmem>>> + Debug>(
+    device_manager: &mut DeviceManager,
+    vm: &Arc<Vm>,
+    cmdline: &mut LoaderKernelCmdline,
+    pmem_devices: I,
+    event_manager: &mut EventManager,
+) -> Result<(), StartMicrovmError> {
+    for (i, device) in pmem_devices.enumerate() {
+        let id = {
+            let mut locked_dev = device.lock().expect("Poisoned lock");
+            if locked_dev.config.root_device {
+                cmdline.insert_str(format!("root=/dev/pmem{i}"))?;
+                match locked_dev.config.read_only {
+                    true => cmdline.insert_str("ro")?,
+                    false => cmdline.insert_str("rw")?,
+                }
+            }
+            locked_dev.alloc_region(vm.as_ref());
+            locked_dev.set_mem_region(vm.as_ref())?;
+            locked_dev.config.id.to_string()
+        };
+
+        event_manager.add_subscriber(device.clone());
+        device_manager.attach_virtio_device(vm, id, device.clone(), cmdline, false)?;
+    }
+    Ok(())
+}
+
 fn attach_unixsock_vsock_device(
     device_manager: &mut DeviceManager,
     vm: &Arc<Vm>,
@@ -655,6 +693,7 @@ pub(crate) mod tests {
     use crate::vmm_config::drive::{BlockBuilder, BlockDeviceConfig};
     use crate::vmm_config::entropy::{EntropyDeviceBuilder, EntropyDeviceConfig};
     use crate::vmm_config::net::{NetBuilder, NetworkInterfaceConfig};
+    use crate::vmm_config::pmem::{PmemBuilder, PmemConfig};
     use crate::vmm_config::vsock::tests::default_config;
     use crate::vmm_config::vsock::{VsockBuilder, VsockDeviceConfig};
     use crate::vstate::vm::tests::setup_vm_with_memory;
@@ -875,6 +914,34 @@ pub(crate) mod tests {
         );
     }
 
+    pub(crate) fn insert_pmem_devices(
+        vmm: &mut Vmm,
+        cmdline: &mut Cmdline,
+        event_manager: &mut EventManager,
+        configs: Vec<PmemConfig>,
+    ) -> Vec<TempFile> {
+        let mut builder = PmemBuilder::default();
+        let mut files = Vec::new();
+        for mut config in configs {
+            let tmp_file = TempFile::new().unwrap();
+            tmp_file.as_file().set_len(0x20_0000).unwrap();
+            let tmp_file_path = tmp_file.as_path().to_str().unwrap().to_string();
+            files.push(tmp_file);
+            config.path_on_host = tmp_file_path;
+            builder.build(config, false).unwrap();
+        }
+
+        attach_pmem_devices(
+            &mut vmm.device_manager,
+            &vmm.vm,
+            cmdline,
+            builder.devices.iter(),
+            event_manager,
+        )
+        .unwrap();
+        files
+    }
+
     #[cfg(target_arch = "x86_64")]
     pub(crate) fn insert_vmgenid_device(vmm: &mut Vmm) {
         vmm.device_manager
@@ -1122,6 +1189,28 @@ pub(crate) mod tests {
         }
     }
 
+    #[test]
+    fn test_attach_pmem_devices() {
+        let mut event_manager = EventManager::new().expect("Unable to create EventManager");
+
+        let id = String::from("root");
+        let configs = vec![PmemConfig {
+            id: id.clone(),
+            path_on_host: "".into(),
+            root_device: true,
+            read_only: true,
+        }];
+        let mut vmm = default_vmm();
+        let mut cmdline = default_kernel_cmdline();
+        _ = insert_pmem_devices(&mut vmm, &mut cmdline, &mut event_manager, configs);
+        assert!(cmdline_contains(&cmdline, "root=/dev/pmem0 ro"));
+        assert!(
+            vmm.device_manager
+                .get_virtio_device(virtio_ids::VIRTIO_ID_PMEM, id.as_str())
+                .is_some()
+        );
+    }
+
     #[test]
     fn test_attach_boot_timer_device() {
         let mut vmm = default_vmm();

src/vmm/src/devices/virtio/pmem/device.rs

@@ -2,11 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use std::fs::{File, OpenOptions};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 use std::os::fd::AsRawFd;
 use std::sync::{Arc, Mutex};
 
+use kvm_bindings::{KVM_MEM_READONLY, kvm_userspace_memory_region};
 use kvm_ioctls::VmFd;
+use serde::{Deserialize, Serialize};
+use vm_allocator::AllocPolicy;
 use vm_memory::mmap::{MmapRegionBuilder, MmapRegionError};
 use vm_memory::{GuestAddress, GuestMemoryError};
 use vmm_sys_util::eventfd::EventFd;
@@ -15,19 +18,22 @@ use crate::devices::virtio::ActivateError;
 use crate::devices::virtio::device::{ActiveState, DeviceState, VirtioDevice};
 use crate::devices::virtio::generated::virtio_config::VIRTIO_F_VERSION_1;
 use crate::devices::virtio::generated::virtio_ids::VIRTIO_ID_PMEM;
+use crate::devices::virtio::pmem::PMEM_QUEUE_SIZE;
 use crate::devices::virtio::pmem::metrics::{PmemMetrics, PmemMetricsPerDevice};
 use crate::devices::virtio::queue::{DescriptorChain, InvalidAvailIdx, Queue, QueueError};
 use crate::devices::virtio::transport::{VirtioInterrupt, VirtioInterruptType};
-use crate::impl_device_type;
 use crate::logger::{IncMetric, error};
 use crate::utils::{align_up, u64_to_usize};
 use crate::vmm_config::pmem::PmemConfig;
 use crate::vstate::memory::{ByteValued, Bytes, GuestMemoryMmap, GuestMmapRegion};
-
-pub const PMEM_QUEUE_SIZE: u16 = 256;
+use crate::{Vm, impl_device_type};
 
 #[derive(Debug, thiserror::Error, displaydoc::Display)]
 pub enum PmemError {
+    /// Cannot set the memory regions: {0}
+    SetUserMemoryRegion(kvm_ioctls::Error),
+    /// Unablet to allocate a KVM slot for the device
+    NoKvmSlotAvailable,
     /// Error accessing backing file: {0}
     BackingFile(std::io::Error),
     /// Error backing file size is 0
@@ -192,6 +198,44 @@ impl Pmem {
         Ok((file, file_len, mmap_ptr as u64, mmap_len))
     }
 
+    /// Allocater memory in past_mmio64 memory region
+    pub fn alloc_region(&mut self, vm: &Vm) {
+        let mut resource_allocator_lock = vm.resource_allocator();
+        let resource_allocator = resource_allocator_lock.deref_mut();
+        let addr = resource_allocator
+            .past_mmio64_memory
+            .allocate(
+                self.config_space.size,
+                Pmem::ALIGNMENT,
+                AllocPolicy::FirstMatch,
+            )
+            .unwrap();
+        self.config_space.start = addr.start();
+    }
+
+    /// Set user memory region in KVM
+    pub fn set_mem_region(&mut self, vm: &Vm) -> Result<(), PmemError> {
+        let next_slot = vm.next_kvm_slot().ok_or(PmemError::NoKvmSlotAvailable)?;
+        let memory_region = kvm_userspace_memory_region {
+            slot: next_slot,
+            guest_phys_addr: self.config_space.start,
+            memory_size: self.config_space.size,
+            userspace_addr: self.mmap_ptr,
+            flags: if self.config.read_only {
+                KVM_MEM_READONLY
+            } else {
+                0
+            },
+        };
+        // SAFETY: All aruments are correct
+        unsafe {
+            vm.fd()
+                .set_user_memory_region(memory_region)
+                .map_err(PmemError::SetUserMemoryRegion)?;
+        }
+        Ok(())
+    }
+
     fn handle_queue(&mut self) -> Result<(), PmemError> {
         // This is safe since we checked in the event handler that the device is activated.
         let active_state = self.device_state.active_state().unwrap();