Expose memory mapping; Add optional memfile dump

Author: ValentaTomas

.tool-versions

@@ -0,0 +1 @@
+rust 1.85.0

src/firecracker/src/api_server/mod.rs

@@ -275,7 +275,7 @@ mod tests {
             Box::new(VmmAction::CreateSnapshot(CreateSnapshotParams {
                 snapshot_type: SnapshotType::Diff,
                 snapshot_path: PathBuf::new(),
-                mem_file_path: PathBuf::new(),
+                mem_file_path: Some(PathBuf::new()),
             })),
             start_time_us,
         );
@@ -288,7 +288,7 @@ mod tests {
             Box::new(VmmAction::CreateSnapshot(CreateSnapshotParams {
                 snapshot_type: SnapshotType::Diff,
                 snapshot_path: PathBuf::new(),
-                mem_file_path: PathBuf::new(),
+                mem_file_path: Some(PathBuf::new()),
             })),
             start_time_us,
         );

src/firecracker/src/api_server/request/snapshot.rs

@@ -140,7 +140,7 @@ mod tests {
         let expected_config = CreateSnapshotParams {
             snapshot_type: SnapshotType::Diff,
             snapshot_path: PathBuf::from("foo"),
-            mem_file_path: PathBuf::from("bar"),
+            mem_file_path: Some(PathBuf::from("bar")),
         };
         assert_eq!(
             vmm_action_from_request(parse_put_snapshot(&Body::new(body), Some("create")).unwrap()),
@@ -154,7 +154,7 @@ mod tests {
         let expected_config = CreateSnapshotParams {
             snapshot_type: SnapshotType::Full,
             snapshot_path: PathBuf::from("foo"),
-            mem_file_path: PathBuf::from("bar"),
+            mem_file_path: Some(PathBuf::from("bar")),
         };
         assert_eq!(
             vmm_action_from_request(parse_put_snapshot(&Body::new(body), Some("create")).unwrap()),

src/firecracker/swagger/firecracker.yaml

@@ -996,6 +996,32 @@ definitions:
       vmm_version:
         description: MicroVM hypervisor build version.
         type: string
+      memory_regions:
+        type: array
+        description: The regions of the guest memory.
+        items:
+          $ref: "#/definitions/GuestMemoryRegion"
+
+  GuestMemoryRegionMapping:
+    type: object
+    description: Describes the region of guest memory that can be used for creating the memfile.
+    required:
+      - base_host_virt_addr
+      - size
+      - offset
+      - page_size
+    properties:
+      base_host_virt_addr:
+        type: integer
+      size:
+        description: The size of the region in bytes.
+        type: integer
+      offset:
+        description: The offset of the region in bytes.
+        type: integer
+      page_size:
+        description: The page size of the region in pages.
+        type: integer
 
   Logger:
     type: object

src/vmm/src/persist.rs

@@ -162,8 +162,11 @@ pub fn create_snapshot(
 
     snapshot_state_to_file(&microvm_state, &params.snapshot_path)?;
 
-    vmm.vm
-        .snapshot_memory_to_file(&params.mem_file_path, params.snapshot_type)?;
+    // Dump memory to file only if mem_file_path is specified
+    if let Some(ref mem_file_path) = params.mem_file_path {
+        vmm.vm
+            .snapshot_memory_to_file(mem_file_path, params.snapshot_type)?;
+    }
 
     // We need to mark queues as dirty again for all activated devices. The reason we
     // do it here is because we don't mark pages as dirty during runtime

src/vmm/src/rpc_interface.rs

@@ -647,9 +647,17 @@ impl RuntimeApiController {
             GetVmMachineConfig => Ok(VmmData::MachineConfiguration(
                 self.vm_resources.machine_config.clone(),
             )),
-            GetVmInstanceInfo => Ok(VmmData::InstanceInformation(
-                self.vmm.lock().expect("Poisoned lock").instance_info(),
-            )),
+            GetVmInstanceInfo => {
+                let locked_vmm = self.vmm.lock().expect("Poisoned lock");
+
+                let mut instance_info = locked_vmm.instance_info();
+
+                instance_info.memory_regions = locked_vmm
+                    .vm
+                    .guest_memory_mappings(&VmInfo::from(&self.vm_resources));
+
+                Ok(VmmData::InstanceInformation(instance_info))
+            }
             GetVmmVersion => Ok(VmmData::VmmVersion(
                 self.vmm.lock().expect("Poisoned lock").version(),
             )),
@@ -1147,7 +1155,7 @@ mod tests {
             CreateSnapshotParams {
                 snapshot_type: SnapshotType::Full,
                 snapshot_path: PathBuf::new(),
-                mem_file_path: PathBuf::new(),
+                mem_file_path: Some(PathBuf::new()),
             },
         )));
         #[cfg(target_arch = "x86_64")]

src/vmm/src/vmm_config/instance_info.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 use std::fmt::{self, Display, Formatter};
 
+use crate::vstate::vm::GuestMemoryRegionMapping;
 use serde::{Serialize, ser};
 
 /// Enumerates microVM runtime states.
@@ -46,4 +47,6 @@ pub struct InstanceInfo {
     pub vmm_version: String,
     /// The name of the application that runs the microVM.
     pub app_name: String,
+    /// The regions of the guest memory.
+    pub memory_regions: Vec<GuestMemoryRegionMapping>,
 }

src/vmm/src/vmm_config/snapshot.rs

@@ -44,7 +44,9 @@ pub struct CreateSnapshotParams {
     /// Path to the file that will contain the microVM state.
     pub snapshot_path: PathBuf,
     /// Path to the file that will contain the guest memory.
-    pub mem_file_path: PathBuf,
+    /// If not specified, the memory is not dumped to a file.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mem_file_path: Option<PathBuf>,
 }
 
 /// Allows for changing the mapping between tap devices and host devices

src/vmm/src/vstate/vm.rs

@@ -13,11 +13,12 @@ use std::sync::Arc;
 
 use kvm_bindings::{KVM_MEM_LOG_DIRTY_PAGES, kvm_userspace_memory_region};
 use kvm_ioctls::VmFd;
+use serde::{Deserialize, Serialize};
 use vmm_sys_util::eventfd::EventFd;
 
 pub use crate::arch::{ArchVm as Vm, ArchVmError, VmState};
 use crate::logger::info;
-use crate::persist::CreateSnapshotError;
+use crate::persist::{CreateSnapshotError, VmInfo};
 use crate::utils::u64_to_usize;
 use crate::vmm_config::snapshot::SnapshotType;
 use crate::vstate::memory::{
@@ -36,6 +37,20 @@ pub struct VmCommon {
     pub guest_memory: GuestMemoryMmap,
 }
 
+/// Describes the region of guest memory that can be used for creating the memfile.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
+pub struct GuestMemoryRegionMapping {
+    /// Base host virtual address where the guest memory contents for this region
+    /// should be copied/populated.
+    pub base_host_virt_addr: u64,
+    /// Region size.
+    pub size: usize,
+    /// Offset in the backend file/buffer where the region contents are.
+    pub offset: u64,
+    /// The configured page size for this memory region.
+    pub page_size: usize,
+}
+
 /// Errors associated with the wrappers over KVM ioctls.
 /// Needs `rustfmt::skip` to make multiline comments work
 #[rustfmt::skip]
@@ -185,6 +200,22 @@ impl Vm {
         &self.common.guest_memory
     }
 
+    /// Gets the mappings for the guest memory.
+    pub fn guest_memory_mappings(&self, vm_info: &VmInfo) -> Vec<GuestMemoryRegionMapping> {
+        let mut offset = 0;
+        let mut mappings = Vec::new();
+        for mem_region in self.guest_memory().iter() {
+            mappings.push(GuestMemoryRegionMapping {
+                base_host_virt_addr: mem_region.as_ptr() as u64,
+                size: mem_region.size(),
+                offset,
+                page_size: vm_info.huge_pages.page_size(),
+            });
+            offset += mem_region.size() as u64;
+        }
+        mappings
+    }
+
     /// Resets the KVM dirty bitmap for each of the guest's memory regions.
     pub fn reset_dirty_bitmap(&self) {
         self.guest_memory()

src/vmm/tests/integration_tests.rs

@@ -215,7 +215,7 @@ fn verify_create_snapshot(is_diff: bool) -> (TempFile, TempFile) {
     let snapshot_params = CreateSnapshotParams {
         snapshot_type,
         snapshot_path: snapshot_file.as_path().to_path_buf(),
-        mem_file_path: memory_file.as_path().to_path_buf(),
+        mem_file_path: Some(memory_file.as_path().to_path_buf()),
     };
 
     controller