feat(virtio-mem): wire PATCH support

Wire up PATCH requests with the virtio-mem device.
All the validation is performed in the device, but the actual operation
is not yet implemented.

Signed-off-by: Riccardo Mancini <[email protected]>

Author: Manciukic

src/firecracker/src/api_server/parsed_request.rs

@@ -28,7 +28,7 @@ use super::request::snapshot::{parse_patch_vm_state, parse_put_snapshot};
 use super::request::version::parse_get_version;
 use super::request::vsock::parse_put_vsock;
 use crate::api_server::request::hotplug::memory::{
-    parse_get_memory_hotplug, parse_put_memory_hotplug,
+    parse_get_memory_hotplug, parse_patch_memory_hotplug, parse_put_memory_hotplug,
 };
 use crate::api_server::request::serial::parse_put_serial;
 
@@ -119,6 +119,9 @@ impl TryFrom<&Request> for ParsedRequest {
                 parse_patch_net(body, path_tokens.next())
             }
             (Method::Patch, "vm", Some(body)) => parse_patch_vm_state(body),
+            (Method::Patch, "hotplug", Some(body)) if path_tokens.next() == Some("memory") => {
+                parse_patch_memory_hotplug(body)
+            }
             (Method::Patch, _, None) => method_to_error(Method::Patch),
             (method, unknown_uri, _) => Err(RequestError::InvalidPathMethod(
                 unknown_uri.to_string(),

src/firecracker/src/api_server/request/hotplug/memory.rs

@@ -4,7 +4,7 @@
 use micro_http::Body;
 use vmm::logger::{IncMetric, METRICS};
 use vmm::rpc_interface::VmmAction;
-use vmm::vmm_config::memory_hotplug::MemoryHotplugConfig;
+use vmm::vmm_config::memory_hotplug::{MemoryHotplugConfig, MemoryHotplugSizeUpdate};
 
 use crate::api_server::parsed_request::{ParsedRequest, RequestError};
 
@@ -23,11 +23,23 @@ pub(crate) fn parse_get_memory_hotplug() -> Result<ParsedRequest, RequestError>
     Ok(ParsedRequest::new_sync(VmmAction::GetMemoryHotplugStatus))
 }
 
+pub(crate) fn parse_patch_memory_hotplug(body: &Body) -> Result<ParsedRequest, RequestError> {
+    METRICS.patch_api_requests.hotplug_memory_count.inc();
+    let config =
+        serde_json::from_slice::<MemoryHotplugSizeUpdate>(body.raw()).inspect_err(|_| {
+            METRICS.patch_api_requests.hotplug_memory_fails.inc();
+        })?;
+    Ok(ParsedRequest::new_sync(VmmAction::UpdateMemoryHotplugSize(
+        config,
+    )))
+}
+
 #[cfg(test)]
 mod tests {
     use vmm::devices::virtio::mem::{
         VIRTIO_MEM_DEFAULT_BLOCK_SIZE_MIB, VIRTIO_MEM_DEFAULT_SLOT_SIZE_MIB,
     };
+    use vmm::vmm_config::memory_hotplug::MemoryHotplugSizeUpdate;
 
     use super::*;
     use crate::api_server::parsed_request::tests::vmm_action_from_request;
@@ -80,4 +92,27 @@ mod tests {
             VmmAction::GetMemoryHotplugStatus
         );
     }
+
+    #[test]
+    fn test_parse_patch_memory_hotplug_request() {
+        parse_patch_memory_hotplug(&Body::new("invalid_payload")).unwrap_err();
+
+        // PATCH with invalid fields.
+        let body = r#"{
+            "requested_size_mib": "bar"
+        }"#;
+        parse_patch_memory_hotplug(&Body::new(body)).unwrap_err();
+
+        // PATCH with valid input fields.
+        let body = r#"{
+            "requested_size_mib": 2048
+        }"#;
+        let expected_config = MemoryHotplugSizeUpdate {
+            requested_size_mib: 2048,
+        };
+        assert_eq!(
+            vmm_action_from_request(parse_patch_memory_hotplug(&Body::new(body)).unwrap()),
+            VmmAction::UpdateMemoryHotplugSize(expected_config)
+        );
+    }
 }

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

@@ -43,6 +43,10 @@ pub enum VirtioMemError {
     EventFd(#[from] io::Error),
     /// Received error while sending an interrupt: {0}
     InterruptError(#[from] InterruptError),
+    /// Size {0} is invalid: it must be a multiple of block size and less than the total size
+    InvalidSize(u64),
+    /// Device is not active
+    DeviceNotActive,
 }
 
 #[derive(Debug)]
@@ -200,6 +204,45 @@ impl VirtioMem {
     pub(crate) fn activate_event(&self) -> &EventFd {
         &self.activate_event
     }
+
+    /// Updates the requested size of the virtio-mem device.
+    pub fn update_requested_size(
+        &mut self,
+        requested_size_mib: usize,
+    ) -> Result<(), VirtioMemError> {
+        let requested_size = usize_to_u64(mib_to_bytes(requested_size_mib));
+        if !self.is_activated() {
+            return Err(VirtioMemError::DeviceNotActive);
+        }
+
+        if requested_size % self.config.block_size != 0 {
+            return Err(VirtioMemError::InvalidSize(requested_size));
+        }
+        if requested_size > self.config.region_size {
+            return Err(VirtioMemError::InvalidSize(requested_size));
+        }
+
+        // usable_region_size can only be increased
+        if self.config.usable_region_size < requested_size {
+            self.config.usable_region_size =
+                requested_size.next_multiple_of(usize_to_u64(self.slot_size));
+            debug!(
+                "virtio-mem: Updated usable size to {} bytes",
+                self.config.usable_region_size
+            );
+        }
+
+        self.config.requested_size = requested_size;
+        debug!(
+            "virtio-mem: Updated requested size to {} bytes",
+            requested_size
+        );
+        // TODO(virtio-mem): trigger interrupt once we add handling for the requests
+        // self.interrupt_trigger()
+        //     .trigger(VirtioInterruptType::Config)
+        //     .map_err(VirtioMemError::InterruptError)
+        Ok(())
+    }
 }
 
 impl VirtioDevice for VirtioMem {

src/vmm/src/lib.rs

@@ -609,6 +609,15 @@ impl Vmm {
             .map_err(VmmError::FindDeviceError)
     }
 
+    /// Returns the current state of the memory hotplug device.
+    pub fn update_memory_hotplug_size(&self, requested_size_mib: usize) -> Result<(), VmmError> {
+        self.device_manager
+            .try_with_virtio_device_with_id(VIRTIO_MEM_DEV_ID, |dev: &mut VirtioMem| {
+                dev.update_requested_size(requested_size_mib)
+            })
+            .map_err(VmmError::FindDeviceError)
+    }
+
     /// Signals Vmm to stop and exit.
     pub fn stop(&mut self, exit_code: FcExitCode) {
         // To avoid cycles, all teardown paths take the following route:

src/vmm/src/logger/metrics.rs

@@ -479,6 +479,10 @@ pub struct PatchRequestsMetrics {
     pub mmds_count: SharedIncMetric,
     /// Number of failures in PATCHing an mmds.
     pub mmds_fails: SharedIncMetric,
+    /// Number of PATCHes to /hotplug/memory
+    pub hotplug_memory_count: SharedIncMetric,
+    /// Number of failed PATCHes to /hotplug/memory
+    pub hotplug_memory_fails: SharedIncMetric,
 }
 impl PatchRequestsMetrics {
     /// Const default construction.
@@ -492,6 +496,8 @@ impl PatchRequestsMetrics {
             machine_cfg_fails: SharedIncMetric::new(),
             mmds_count: SharedIncMetric::new(),
             mmds_fails: SharedIncMetric::new(),
+            hotplug_memory_count: SharedIncMetric::new(),
+            hotplug_memory_fails: SharedIncMetric::new(),
         }
     }
 }

src/vmm/src/rpc_interface.rs

@@ -29,7 +29,9 @@ use crate::vmm_config::drive::{BlockDeviceConfig, BlockDeviceUpdateConfig, Drive
 use crate::vmm_config::entropy::{EntropyDeviceConfig, EntropyDeviceError};
 use crate::vmm_config::instance_info::InstanceInfo;
 use crate::vmm_config::machine_config::{MachineConfig, MachineConfigError, MachineConfigUpdate};
-use crate::vmm_config::memory_hotplug::{MemoryHotplugConfig, MemoryHotplugConfigError};
+use crate::vmm_config::memory_hotplug::{
+    MemoryHotplugConfig, MemoryHotplugConfigError, MemoryHotplugSizeUpdate,
+};
 use crate::vmm_config::metrics::{MetricsConfig, MetricsConfigError};
 use crate::vmm_config::mmds::{MmdsConfig, MmdsConfigError};
 use crate::vmm_config::net::{
@@ -113,6 +115,9 @@ pub enum VmmAction {
     /// Set the memory hotplug device using `MemoryHotplugConfig` as input. This action can only be
     /// called before the microVM has booted.
     SetMemoryHotplugDevice(MemoryHotplugConfig),
+    /// Updates the memory hotplug device using `MemoryHotplugConfigUpdate` as input. This action
+    /// can only be called after the microVM has booted.
+    UpdateMemoryHotplugSize(MemoryHotplugSizeUpdate),
     /// Launch the microVM. This action can only be called before the microVM has booted.
     StartMicroVm,
     /// Send CTRL+ALT+DEL to the microVM, using the i8042 keyboard function. If an AT-keyboard
@@ -152,6 +157,8 @@ pub enum VmmActionError {
     EntropyDevice(#[from] EntropyDeviceError),
     /// Memory hotplug config error: {0}
     MemoryHotplugConfig(#[from] MemoryHotplugConfigError),
+    /// Memory hotplug update error: {0}
+    MemoryHotplugUpdate(VmmError),
     /// Internal VMM error: {0}
     InternalVmm(#[from] VmmError),
     /// Load snapshot error: {0}
@@ -469,6 +476,7 @@ impl<'a> PrebootApiController<'a> {
             | UpdateBalloon(_)
             | UpdateBalloonStatistics(_)
             | UpdateBlockDevice(_)
+            | UpdateMemoryHotplugSize(_)
             | UpdateNetworkInterface(_) => Err(VmmActionError::OperationNotSupportedPreBoot),
             #[cfg(target_arch = "x86_64")]
             SendCtrlAltDel => Err(VmmActionError::OperationNotSupportedPreBoot),
@@ -709,7 +717,13 @@ impl RuntimeApiController {
                 .map_err(VmmActionError::BalloonUpdate),
             UpdateBlockDevice(new_cfg) => self.update_block_device(new_cfg),
             UpdateNetworkInterface(netif_update) => self.update_net_rate_limiters(netif_update),
-
+            UpdateMemoryHotplugSize(cfg) => self
+                .vmm
+                .lock()
+                .expect("Poisoned lock")
+                .update_memory_hotplug_size(cfg.requested_size_mib)
+                .map(|_| VmmData::Empty)
+                .map_err(VmmActionError::MemoryHotplugUpdate),
             // Operations not allowed post-boot.
             ConfigureBootSource(_)
             | ConfigureLogger(_)
@@ -1181,6 +1195,11 @@ mod tests {
         )));
         #[cfg(target_arch = "x86_64")]
         check_unsupported(preboot_request(VmmAction::SendCtrlAltDel));
+        check_unsupported(preboot_request(VmmAction::UpdateMemoryHotplugSize(
+            MemoryHotplugSizeUpdate {
+                requested_size_mib: 0,
+            },
+        )));
     }
 
     fn runtime_request(request: VmmAction) -> Result<VmmData, VmmActionError> {

src/vmm/src/vmm_config/memory_hotplug.rs

@@ -86,6 +86,14 @@ impl MemoryHotplugConfig {
     }
 }
 
+/// Configuration for memory hotplug device.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct MemoryHotplugSizeUpdate {
+    /// Requested size in MiB to resize the hotpluggable memory to.
+    pub requested_size_mib: usize,
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json;