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

@@ -173,6 +173,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() }),
@@ -557,6 +558,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

@@ -13,6 +13,10 @@ pub(crate) fn parse_put_memory_hotplug(body: &Body) -> Result<ParsedRequest, Req
     )))
 }
 
+pub(crate) fn parse_get_memory_hotplug() -> Result<ParsedRequest, RequestError> {
+    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};
@@ -61,4 +65,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/firecracker/src/api_server/request/hotplug/mod.rs

@@ -6,7 +6,9 @@ mod memory;
 use micro_http::{Body, Method};
 
 use crate::api_server::parsed_request::{ParsedRequest, RequestError};
-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,
+};
 
 pub(crate) fn parse_hotplug(
     method: Method,
@@ -16,6 +18,7 @@ pub(crate) fn parse_hotplug(
     let token =
         token.ok_or_else(|| RequestError::InvalidPathMethod("hotplug".to_string(), method))?;
     match (method, token, body) {
+        (Method::Get, "memory", None) => parse_get_memory_hotplug(),
         (Method::Put, "memory", Some(body)) => parse_put_memory_hotplug(body),
         (method, unknown_uri, _) => Err(RequestError::InvalidPathMethod(
             unknown_uri.to_string(),

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()))
@@ -389,4 +415,17 @@ 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

@@ -137,7 +137,7 @@ 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::generated::virtio_ids;
-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};
@@ -621,6 +621,17 @@ 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_ids::VIRTIO_ID_MEM,
+                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/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};
@@ -104,6 +105,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),
@@ -199,6 +202,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.
@@ -453,6 +458,7 @@ impl<'a> PrebootApiController<'a> {
             | Pause
             | Resume
             | GetBalloonStats
+            | GetMemoryHotplugStatus
             | UpdateBalloon(_)
             | UpdateBalloonStatistics(_)
             | UpdateBlockDevice(_)
@@ -658,6 +664,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/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):
     """