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

Update VmResources type with virtio-pmem configuration
field to allow virtio-pmem devices be configured
through config files and later through API calls.

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

Author: ShadowCurse

src/vmm/src/device_manager/pci_mngr.rs

@@ -730,7 +730,8 @@ mod tests {
   }},
   "entropy": {{
     "rate_limiter": null
-  }}
+  }},
+  "pmem": []
 }}"#,
             _block_files.last().unwrap().as_path().to_str().unwrap(),
             tmp_sock_file.as_path().to_str().unwrap()

src/vmm/src/device_manager/persist.rs

@@ -750,7 +750,8 @@ mod tests {
   }},
   "entropy": {{
     "rate_limiter": null
-  }}
+  }},
+  "pmem": []
 }}"#,
             _block_files.last().unwrap().as_path().to_str().unwrap(),
             tmp_sock_file.as_path().to_str().unwrap()

src/vmm/src/resources.rs

@@ -28,6 +28,7 @@ use crate::vmm_config::machine_config::{
 use crate::vmm_config::metrics::{MetricsConfig, MetricsConfigError, init_metrics};
 use crate::vmm_config::mmds::{MmdsConfig, MmdsConfigError};
 use crate::vmm_config::net::*;
+use crate::vmm_config::pmem::{PmemBuilder, PmemConfig, PmemConfigError};
 use crate::vmm_config::serial::SerialConfig;
 use crate::vmm_config::vsock::*;
 use crate::vstate::memory;
@@ -62,6 +63,8 @@ pub enum ResourcesError {
     VsockDevice(#[from] VsockConfigError),
     /// Entropy device error: {0}
     EntropyDevice(#[from] EntropyDeviceError),
+    /// Pmem device error: {0}
+    PmemDevice(#[from] PmemConfigError),
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
@@ -87,6 +90,8 @@ pub struct VmmConfig {
     network_interfaces: Vec<NetworkInterfaceConfig>,
     vsock: Option<VsockDeviceConfig>,
     entropy: Option<EntropyDeviceConfig>,
+    #[serde(default, rename = "pmem")]
+    pmem_devices: Vec<PmemConfig>,
     #[serde(skip)]
     serial_config: Option<SerialConfig>,
 }
@@ -109,6 +114,8 @@ pub struct VmResources {
     pub net_builder: NetBuilder,
     /// The entropy device builder.
     pub entropy: EntropyDeviceBuilder,
+    /// The pmem devices.
+    pub pmem: PmemBuilder,
     /// The optional Mmds data store.
     // This is initialised on demand (if ever used), so that we don't allocate it unless it's
     // actually used.
@@ -198,6 +205,10 @@ impl VmResources {
             resources.build_entropy_device(entropy_device_config)?;
         }
 
+        for pmem_config in vmm_config.pmem_devices.into_iter() {
+            resources.build_pmem_device(pmem_config)?;
+        }
+
         if let Some(serial_cfg) = vmm_config.serial_config {
             resources.serial_out_path = serial_cfg.serial_out_path;
         }
@@ -389,6 +400,11 @@ impl VmResources {
         self.entropy.insert(body)
     }
 
+    /// Builds a pmem device to be attached when the VM starts.
+    pub fn build_pmem_device(&mut self, body: PmemConfig) -> Result<(), PmemConfigError> {
+        self.pmem.build(body)
+    }
+
     /// Setter for mmds config.
     pub fn set_mmds_config(
         &mut self,
@@ -515,6 +531,7 @@ impl From<&VmResources> for VmmConfig {
             network_interfaces: resources.net_builder.configs(),
             vsock: resources.vsock.config(),
             entropy: resources.entropy.config(),
+            pmem_devices: resources.pmem.configs(),
             // serial_config is marked serde(skip) so that it doesnt end up in snapshots.
             serial_config: None,
         }
@@ -627,6 +644,7 @@ mod tests {
             boot_timer: false,
             mmds_size_limit: HTTP_MAX_PAYLOAD_SIZE,
             entropy: Default::default(),
+            pmem: Default::default(),
             pci_enabled: false,
             serial_out_path: None,
         }
@@ -636,6 +654,8 @@ mod tests {
     fn test_from_json() {
         let kernel_file = TempFile::new().unwrap();
         let rootfs_file = TempFile::new().unwrap();
+        let scratch_file = TempFile::new().unwrap();
+        scratch_file.as_file().set_len(0x1000).unwrap();
         let default_instance_info = InstanceInfo::default();
 
         // We will test different scenarios with invalid resources configuration and
@@ -1010,6 +1030,14 @@ mod tests {
                             "is_read_only": false
                         }}
                     ],
+                    "pmem": [
+                        {{
+                            "id": "pmem",
+                            "path_on_host": "{}",
+                            "root_device": false,
+                            "read_only": false
+                        }}
+                    ],
                     "network-interfaces": [
                         {{
                             "iface_id": "netif",
@@ -1028,6 +1056,7 @@ mod tests {
             }}"#,
             kernel_file.as_path().to_str().unwrap(),
             rootfs_file.as_path().to_str().unwrap(),
+            scratch_file.as_path().to_str().unwrap(),
         );
         let resources = VmResources::from_json(
             json.as_str(),
@@ -1640,4 +1669,20 @@ mod tests {
         vm_resources.build_net_device(new_net_device_cfg).unwrap();
         assert_eq!(vm_resources.net_builder.len(), 2);
     }
+
+    #[test]
+    fn test_set_pmem_device() {
+        let mut vm_resources = default_vm_resources();
+
+        let tmp_file = TempFile::new().unwrap();
+        tmp_file.as_file().set_len(0x1000).unwrap();
+        let cfg = PmemConfig {
+            id: "pmem".to_string(),
+            path_on_host: tmp_file.as_path().to_str().unwrap().to_string(),
+            ..Default::default()
+        };
+        assert_eq!(vm_resources.pmem.devices.len(), 0);
+        vm_resources.build_pmem_device(cfg).unwrap();
+        assert_eq!(vm_resources.pmem.devices.len(), 1);
+    }
 }

src/vmm/src/rpc_interface.rs

@@ -33,6 +33,7 @@ use crate::vmm_config::mmds::{MmdsConfig, MmdsConfigError};
 use crate::vmm_config::net::{
     NetworkInterfaceConfig, NetworkInterfaceError, NetworkInterfaceUpdateConfig,
 };
+use crate::vmm_config::pmem::{PmemConfig, PmemConfigError};
 use crate::vmm_config::serial::SerialConfig;
 use crate::vmm_config::snapshot::{CreateSnapshotParams, LoadSnapshotParams, SnapshotType};
 use crate::vmm_config::vsock::{VsockConfigError, VsockDeviceConfig};
@@ -75,6 +76,8 @@ pub enum VmmAction {
     /// Add a new block device or update one that already exists using the `BlockDeviceConfig` as
     /// input. This action can only be called before the microVM has booted.
     InsertBlockDevice(BlockDeviceConfig),
+    /// Add a virtio-pmem device.
+    InsertPmemDevice(PmemConfig),
     /// Add a new network interface config or update one that already exists using the
     /// `NetworkInterfaceConfig` as input. This action can only be called before the microVM has
     /// booted.
@@ -143,6 +146,8 @@ pub enum VmmActionError {
     DriveConfig(#[from] DriveError),
     /// Entropy device error: {0}
     EntropyDevice(#[from] EntropyDeviceError),
+    /// Pmem device error: {0}
+    PmemDevice(#[from] PmemConfigError),
     /// Internal VMM error: {0}
     InternalVmm(#[from] VmmError),
     /// Load snapshot error: {0}
@@ -432,6 +437,7 @@ impl<'a> PrebootApiController<'a> {
             GetVmInstanceInfo => Ok(VmmData::InstanceInformation(self.instance_info.clone())),
             GetVmmVersion => Ok(VmmData::VmmVersion(self.instance_info.vmm_version.clone())),
             InsertBlockDevice(config) => self.insert_block_device(config),
+            InsertPmemDevice(config) => self.insert_pmem_device(config),
             InsertNetworkDevice(config) => self.insert_net_device(config),
             LoadSnapshot(config) => self
                 .load_snapshot(&config)
@@ -489,6 +495,14 @@ impl<'a> PrebootApiController<'a> {
             .map_err(VmmActionError::NetworkConfig)
     }
 
+    fn insert_pmem_device(&mut self, cfg: PmemConfig) -> Result<VmmData, VmmActionError> {
+        self.boot_path = true;
+        self.vm_resources
+            .build_pmem_device(cfg)
+            .map(|()| VmmData::Empty)
+            .map_err(VmmActionError::PmemDevice)
+    }
+
     fn set_balloon_device(&mut self, cfg: BalloonDeviceConfig) -> Result<VmmData, VmmActionError> {
         self.boot_path = true;
         self.vm_resources
@@ -687,6 +701,7 @@ impl RuntimeApiController {
             | ConfigureMetrics(_)
             | ConfigureSerial(_)
             | InsertBlockDevice(_)
+            | InsertPmemDevice(_)
             | InsertNetworkDevice(_)
             | LoadSnapshot(_)
             | PutCpuConfiguration(_)
@@ -1272,5 +1287,11 @@ mod tests {
         check_unsupported(runtime_request(VmmAction::SetEntropyDevice(
             EntropyDeviceConfig::default(),
         )));
+        check_unsupported(runtime_request(VmmAction::InsertPmemDevice(PmemConfig {
+            id: String::new(),
+            path_on_host: String::new(),
+            root_device: false,
+            read_only: false,
+        })));
     }
 }