feat(virtio-mem): add GET API

Add support for GET /hotplug/memory that returns the current status of
the virtio-mem device.

This API can only be called after boot.

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

Author: Manciukic

src/firecracker/src/api_server/parsed_request.rs

@@ -27,7 +27,9 @@ use super::request::net::{parse_patch_net, parse_put_net};
 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_put_memory_hotplug;
+use crate::api_server::request::hotplug::memory::{
+    parse_get_memory_hotplug, parse_put_memory_hotplug,
+};
 use crate::api_server::request::serial::parse_put_serial;
 
 #[derive(Debug)]
@@ -85,6 +87,9 @@ impl TryFrom<&Request> for ParsedRequest {
             }
             (Method::Get, "machine-config", None) => parse_get_machine_config(),
             (Method::Get, "mmds", None) => parse_get_mmds(),
+            (Method::Get, "hotplug", None) if path_tokens.next() == Some("memory") => {
+                parse_get_memory_hotplug()
+            }
             (Method::Get, _, Some(_)) => method_to_error(Method::Get),
             (Method::Put, "actions", Some(body)) => parse_put_actions(body),
             (Method::Put, "balloon", Some(body)) => parse_put_balloon(body),
@@ -177,6 +182,7 @@ impl ParsedRequest {
                     Self::success_response_with_data(balloon_config)
                 }
                 VmmData::BalloonStats(stats) => Self::success_response_with_data(stats),
+                VmmData::VirtioMemStatus(data) => Self::success_response_with_data(data),
                 VmmData::InstanceInformation(info) => Self::success_response_with_data(info),
                 VmmData::VmmVersion(version) => Self::success_response_with_data(
                     &serde_json::json!({ "firecracker_version": version.as_str() }),
@@ -561,6 +567,9 @@ pub mod tests {
                 VmmData::BalloonStats(stats) => {
                     http_response(&serde_json::to_string(stats).unwrap(), 200)
                 }
+                VmmData::VirtioMemStatus(data) => {
+                    http_response(&serde_json::to_string(data).unwrap(), 200)
+                }
                 VmmData::Empty => http_response("", 204),
                 VmmData::FullVmConfig(cfg) => {
                     http_response(&serde_json::to_string(cfg).unwrap(), 200)

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

@@ -18,6 +18,11 @@ pub(crate) fn parse_put_memory_hotplug(body: &Body) -> Result<ParsedRequest, Req
     )))
 }
 
+pub(crate) fn parse_get_memory_hotplug() -> Result<ParsedRequest, RequestError> {
+    METRICS.get_api_requests.hotplug_memory_count.inc();
+    Ok(ParsedRequest::new_sync(VmmAction::GetMemoryHotplugStatus))
+}
+
 #[cfg(test)]
 mod tests {
     use vmm::devices::virtio::mem::{VIRTIO_MEM_DEFAULT_BLOCK_SIZE, VIRTIO_MEM_DEFAULT_SLOT_SIZE};
@@ -66,4 +71,12 @@ mod tests {
             VmmAction::SetMemoryHotplugDevice(expected_config)
         );
     }
+
+    #[test]
+    fn test_parse_parse_get_memory_hotplug_request() {
+        assert_eq!(
+            vmm_action_from_request(parse_get_memory_hotplug().unwrap()),
+            VmmAction::GetMemoryHotplugStatus
+        );
+    }
 }

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

@@ -61,6 +61,22 @@ pub struct VirtioMem {
     vm: Arc<Vm>,
 }
 
+/// Memory hotplug device status information.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct VirtioMemStatus {
+    /// Block size in MiB.
+    pub block_size_mib: usize,
+    /// Total memory size in MiB that can be hotplugged.
+    pub total_size_mib: usize,
+    /// Size of the KVM slots in MiB.
+    pub slot_size_mib: usize,
+    /// Currently plugged memory size in MiB.
+    pub plugged_size_mib: usize,
+    /// Requested memory size in MiB.
+    pub requested_size_mib: usize,
+}
+
 impl VirtioMem {
     pub fn new(
         vm: Arc<Vm>,
@@ -132,6 +148,16 @@ impl VirtioMem {
         bytes_to_mib(self.config.requested_size.try_into().unwrap())
     }
 
+    pub fn status(&self) -> VirtioMemStatus {
+        VirtioMemStatus {
+            block_size_mib: self.block_size_mib(),
+            total_size_mib: self.total_size_mib(),
+            slot_size_mib: self.slot_size_mib(),
+            plugged_size_mib: self.plugged_size_mib(),
+            requested_size_mib: self.requested_size_mib(),
+        }
+    }
+
     fn signal_used_queue(&self) -> Result<(), VirtioMemError> {
         self.interrupt_trigger()
             .trigger(VirtioInterruptType::Queue(MEM_QUEUE.try_into().unwrap()))
@@ -387,4 +413,20 @@ mod tests {
         mem.set_acked_features(456);
         assert_eq!(mem.acked_features(), 456);
     }
+
+    #[test]
+    fn test_status() {
+        let mut mem = default_virtio_mem();
+        let status = mem.status();
+        assert_eq!(
+            status,
+            VirtioMemStatus {
+                block_size_mib: 2,
+                total_size_mib: 1024,
+                slot_size_mib: 128,
+                plugged_size_mib: 0,
+                requested_size_mib: 0,
+            }
+        );
+    }
 }

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

@@ -6,7 +6,7 @@ mod event_handler;
 
 use vm_memory::GuestAddress;
 
-pub use self::device::{VirtioMem, VirtioMemError};
+pub use self::device::{VirtioMem, VirtioMemError, VirtioMemStatus};
 use crate::arch::FIRST_ADDR_PAST_64BITS_MMIO;
 
 pub(crate) const MEM_NUM_QUEUES: usize = 1;

src/vmm/src/lib.rs

@@ -136,7 +136,7 @@ use vstate::vcpu::{self, StartThreadedError, VcpuSendEventError};
 use crate::cpu_config::templates::CpuConfiguration;
 use crate::devices::virtio::balloon::{BALLOON_DEV_ID, Balloon, BalloonConfig, BalloonStats};
 use crate::devices::virtio::block::device::Block;
-use crate::devices::virtio::mem::VirtioMemError;
+use crate::devices::virtio::mem::{VIRTIO_MEM_DEV_ID, VirtioMem, VirtioMemError, VirtioMemStatus};
 use crate::devices::virtio::net::Net;
 use crate::logger::{METRICS, MetricsError, error, info, warn};
 use crate::persist::{MicrovmState, MicrovmStateError, VmInfo};
@@ -594,6 +594,13 @@ impl Vmm {
             .map_err(VmmError::FindDeviceError)
     }
 
+    /// Returns the current state of the memory hotplug device.
+    pub fn memory_hotplug_status(&self) -> Result<VirtioMemStatus, VmmError> {
+        self.device_manager
+            .with_virtio_device_with_id(VIRTIO_MEM_DEV_ID, |dev: &mut VirtioMem| dev.status())
+            .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

@@ -365,6 +365,8 @@ pub struct GetRequestsMetrics {
     pub mmds_count: SharedIncMetric,
     /// Number of GETs for getting the VMM version.
     pub vmm_version_count: SharedIncMetric,
+    /// Number of GETs for getting hotpluggable memory status.
+    pub hotplug_memory_count: SharedIncMetric,
 }
 impl GetRequestsMetrics {
     /// Const default construction.
@@ -374,6 +376,7 @@ impl GetRequestsMetrics {
             machine_cfg_count: SharedIncMetric::new(),
             mmds_count: SharedIncMetric::new(),
             vmm_version_count: SharedIncMetric::new(),
+            hotplug_memory_count: SharedIncMetric::new(),
         }
     }
 }

src/vmm/src/rpc_interface.rs

@@ -14,6 +14,7 @@ use super::{Vmm, VmmError};
 use crate::EventManager;
 use crate::builder::StartMicrovmError;
 use crate::cpu_config::templates::{CustomCpuTemplate, GuestConfigError};
+use crate::devices::virtio::mem::VirtioMemStatus;
 use crate::logger::{LoggerConfig, info, warn, *};
 use crate::mmds::data_store::{self, Mmds};
 use crate::persist::{CreateSnapshotError, RestoreFromSnapshotError, VmInfo};
@@ -107,6 +108,8 @@ pub enum VmmAction {
     /// Set the entropy device using `EntropyDeviceConfig` as input. This action can only be called
     /// before the microVM has booted.
     SetEntropyDevice(EntropyDeviceConfig),
+    /// Get the memory hotplug device configuration and status.
+    GetMemoryHotplugStatus,
     /// Set the memory hotplug device using `MemoryHotplugConfig` as input. This action can only be
     /// called before the microVM has booted.
     SetMemoryHotplugDevice(MemoryHotplugConfig),
@@ -202,6 +205,8 @@ pub enum VmmData {
     InstanceInformation(InstanceInfo),
     /// The microVM version.
     VmmVersion(String),
+    /// The status of the memory hotplug device.
+    VirtioMemStatus(VirtioMemStatus),
 }
 
 /// Trait used for deduplicating the MMDS request handling across the two ApiControllers.
@@ -460,6 +465,7 @@ impl<'a> PrebootApiController<'a> {
             | Pause
             | Resume
             | GetBalloonStats
+            | GetMemoryHotplugStatus
             | UpdateBalloon(_)
             | UpdateBalloonStatistics(_)
             | UpdateBlockDevice(_)
@@ -664,6 +670,13 @@ impl RuntimeApiController {
                 .map(VmmData::BalloonStats)
                 .map_err(VmmActionError::InternalVmm),
             GetFullVmConfig => Ok(VmmData::FullVmConfig((&self.vm_resources).into())),
+            GetMemoryHotplugStatus => self
+                .vmm
+                .lock()
+                .expect("Poisoned lock")
+                .memory_hotplug_status()
+                .map(VmmData::VirtioMemStatus)
+                .map_err(VmmActionError::InternalVmm),
             GetMMDS => self.get_mmds(),
             GetVmMachineConfig => Ok(VmmData::MachineConfiguration(
                 self.vm_resources.machine_config.clone(),

tests/host_tools/fcmetrics.py

@@ -153,6 +153,7 @@ def validate_fc_metrics(metrics):
             "machine_cfg_count",
             "mmds_count",
             "vmm_version_count",
+            "hotplug_memory_count",
         ],
         "i8042": [
             "error_count",

tests/integration_tests/functional/test_api.py

@@ -998,13 +998,21 @@ def test_api_memory_hotplug(uvm_plain):
     # Omitting optional values should be ok
     test_microvm.api.memory_hotplug.put(total_size_mib=1024)
 
+    # Get API should be rejected before boot
+    with pytest.raises(AssertionError):
+        test_microvm.api.memory_hotplug.get()
+
     # Start the microvm
     test_microvm.start()
 
-    # API should be rejected after boot
+    # Put API should be rejected after boot
     with pytest.raises(RuntimeError):
         test_microvm.api.memory_hotplug.put(total_size_mib=1024)
 
+    # Get API should work after boot
+    status = test_microvm.api.memory_hotplug.get().json()
+    assert status["total_size_mib"] == 1024
+
 
 def test_api_balloon(uvm_nano):
     """