api: implement API for getting guest memory mappings

Implement API /memory/mappings which returns the memory mappings of
guest physical to host virtual memory.

Signed-off-by: Babis Chalios <babis.chalios@e2b.dev>

Author: bchalios

src/firecracker/src/api_server/parsed_request.rs

@@ -31,6 +31,7 @@ use super::request::vsock::parse_put_vsock;
 use crate::api_server::request::hotplug::memory::{
     parse_get_memory_hotplug, parse_patch_memory_hotplug, parse_put_memory_hotplug,
 };
+use crate::api_server::request::memory_info::parse_get_guest_memory_mappings;
 use crate::api_server::request::serial::parse_put_serial;
 
 #[derive(Debug)]
@@ -91,6 +92,9 @@ impl TryFrom<&Request> for ParsedRequest {
             (Method::Get, "hotplug", None) if path_tokens.next() == Some("memory") => {
                 parse_get_memory_hotplug()
             }
+            (Method::Get, "memory", None) if path_tokens.next() == Some("mappings") => {
+                parse_get_guest_memory_mappings()
+            }
             (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),
@@ -196,6 +200,7 @@ impl ParsedRequest {
                     &serde_json::json!({ "firecracker_version": version.as_str() }),
                 ),
                 VmmData::FullVmConfig(config) => Self::success_response_with_data(config),
+                VmmData::MemoryMappings(mappings) => Self::success_response_with_data(mappings),
             },
             Err(vmm_action_error) => {
                 let mut response = match vmm_action_error {
@@ -610,6 +615,9 @@ pub mod tests {
                     &serde_json::json!({ "firecracker_version": version.as_str() }).to_string(),
                     200,
                 ),
+                VmmData::MemoryMappings(mappings) => {
+                    http_response(&serde_json::to_string(mappings).unwrap(), 200)
+                }
             };
             let response = ParsedRequest::convert_to_response(&data);
             response.write_all(&mut buf).unwrap();

src/firecracker/src/api_server/request/memory_info.rs

@@ -0,0 +1,9 @@
+use vmm::rpc_interface::VmmAction;
+
+use crate::api_server::parsed_request::{ParsedRequest, RequestError};
+
+pub(crate) fn parse_get_guest_memory_mappings() -> Result<ParsedRequest, RequestError> {
+    // TODO: Define the metric and then use it here
+    // METRICS.get_api_requests.guest_memory_mappings_count.inc();
+    Ok(ParsedRequest::new_sync(VmmAction::GetMemoryMappings))
+}

src/firecracker/src/api_server/request/mod.rs

@@ -11,6 +11,7 @@ pub mod hotplug;
 pub mod instance_info;
 pub mod logger;
 pub mod machine_configuration;
+pub mod memory_info;
 pub mod metrics;
 pub mod mmds;
 pub mod net;

src/vmm/src/lib.rs

@@ -144,8 +144,9 @@ use crate::devices::virtio::block::device::Block;
 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};
+use crate::persist::{GuestRegionUffdMapping, MicrovmState, MicrovmStateError, VmInfo};
 use crate::rate_limiter::BucketUpdate;
+use crate::utils::usize_to_u64;
 use crate::vmm_config::instance_info::{InstanceInfo, VmState};
 use crate::vstate::memory::{GuestMemory, GuestMemoryMmap, GuestMemoryRegion};
 use crate::vstate::vcpu::VcpuState;
@@ -690,6 +691,27 @@ impl Vmm {
     pub fn vm(&self) -> &Vm {
         &self.vm
     }
+
+    /// Get the list of mappings for guest memory
+    pub fn guest_memory_mappings(&self, page_size: usize) -> Vec<GuestRegionUffdMapping> {
+        let mut mappings = vec![];
+        let mut offset = 0;
+
+        for region in self.vm.guest_memory().iter() {
+            #[allow(deprecated)]
+            mappings.push(GuestRegionUffdMapping {
+                base_host_virt_addr: region.as_ptr() as u64,
+                size: region.size(),
+                offset,
+                page_size,
+                page_size_kib: page_size,
+            });
+
+            offset += usize_to_u64(region.size());
+        }
+
+        mappings
+    }
 }
 
 /// Process the content of the MPIDR_EL1 register in order to be able to pass it to KVM

src/vmm/src/rpc_interface.rs

@@ -30,6 +30,7 @@ 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::meminfo::MemoryMapingsResponse;
 use crate::vmm_config::memory_hotplug::{
     MemoryHotplugConfig, MemoryHotplugConfigError, MemoryHotplugSizeUpdate,
 };
@@ -146,6 +147,8 @@ pub enum VmmAction {
     /// Update the microVM configuration (memory & vcpu) using `VmUpdateConfig` as input. This
     /// action can only be called before the microVM has booted.
     UpdateMachineConfiguration(MachineConfigUpdate),
+    /// Get the guest memory mappings to host memory
+    GetMemoryMappings,
 }
 
 /// Wrapper for all errors associated with VMM actions.
@@ -228,6 +231,8 @@ pub enum VmmData {
     VirtioMemStatus(VirtioMemStatus),
     /// The status of the virtio-balloon hinting run
     HintingStatus(HintingStatus),
+    /// The guest memory mapping information.
+    MemoryMappings(MemoryMapingsResponse),
 }
 
 /// Trait used for deduplicating the MMDS request handling across the two ApiControllers.
@@ -495,7 +500,8 @@ impl<'a> PrebootApiController<'a> {
             | UpdateNetworkInterface(_)
             | StartFreePageHinting(_)
             | GetFreePageHintingStatus
-            | StopFreePageHinting => Err(VmmActionError::OperationNotSupportedPreBoot),
+            | StopFreePageHinting
+            | GetMemoryMappings => Err(VmmActionError::OperationNotSupportedPreBoot),
             #[cfg(target_arch = "x86_64")]
             SendCtrlAltDel => Err(VmmActionError::OperationNotSupportedPreBoot),
         }
@@ -771,6 +777,7 @@ impl RuntimeApiController {
                 .update_memory_hotplug_size(cfg.requested_size_mib)
                 .map(|_| VmmData::Empty)
                 .map_err(VmmActionError::MemoryHotplugUpdate),
+            GetMemoryMappings => self.get_guest_memory_mappings(),
             // Operations not allowed post-boot.
             ConfigureBootSource(_)
             | ConfigureLogger(_)
@@ -937,6 +944,14 @@ impl RuntimeApiController {
             .map_err(NetworkInterfaceError::DeviceUpdate)
             .map_err(VmmActionError::NetworkConfig)
     }
+
+    /// Get guest memory mappings
+    fn get_guest_memory_mappings(&self) -> Result<VmmData, VmmActionError> {
+        let vmm = self.vmm.lock().expect("Poisoned lock");
+        let page_size = self.vm_resources.machine_config.huge_pages.page_size();
+        let mappings = vmm.guest_memory_mappings(page_size);
+        Ok(VmmData::MemoryMappings(MemoryMapingsResponse { mappings }))
+    }
 }
 
 #[cfg(test)]

src/vmm/src/vmm_config/meminfo.rs

@@ -0,0 +1,11 @@
+use serde::Serialize;
+
+use crate::persist::GuestRegionUffdMapping;
+
+/// Serializeable struct that contains information about guest's memory mappings
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
+pub struct MemoryMapingsResponse {
+    /// Vector with mappings from guest physical to host virtual memoryv
+    pub mappings: Vec<GuestRegionUffdMapping>,
+}
+

src/vmm/src/vmm_config/mod.rs

@@ -20,6 +20,8 @@ pub mod entropy;
 pub mod instance_info;
 /// Wrapper for configuring the memory and CPU of the microVM.
 pub mod machine_config;
+/// Wrapper for getting memory-related information.
+pub mod meminfo;
 /// Wrapper for configuring memory hotplug.
 pub mod memory_hotplug;
 /// Wrapper for configuring the metrics.