[v1.14] Expose memory mapping & dirty pages; Make memfile dump optional

resources/seccomp/x86_64-unknown-linux-musl.json

@@ -31,6 +31,9 @@
             {
                 "syscall": "mincore"
             },
+            {
+                "syscall": "pread64"
+            },
             {
                 "syscall": "writev",
                 "comment": "Used by the VirtIO net device to write to tap"

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/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_memory;
 use crate::api_server::request::serial::parse_put_serial;
 
 #[derive(Debug)]
@@ -91,6 +92,7 @@ impl TryFrom<&Request> for ParsedRequest {
             (Method::Get, "hotplug", None) if path_tokens.next() == Some("memory") => {
                 parse_get_memory_hotplug()
             }
+            (Method::Get, "memory", None) => parse_get_memory(path_tokens),
             (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 +198,9 @@ 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),
+                VmmData::Memory(meminfo) => Self::success_response_with_data(meminfo),
+                VmmData::MemoryDirty(dirty) => Self::success_response_with_data(dirty),
             },
             Err(vmm_action_error) => {
                 let mut response = match vmm_action_error {
@@ -610,6 +615,15 @@ 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)
+                }
+                VmmData::Memory(meminfo) => {
+                    http_response(&serde_json::to_string(meminfo).unwrap(), 200)
+                }
+                VmmData::MemoryDirty(dirty) => {
+                    http_response(&serde_json::to_string(dirty).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,19 @@
+use micro_http::Method;
+use vmm::rpc_interface::VmmAction;
+
+use crate::api_server::parsed_request::{ParsedRequest, RequestError};
+
+pub(crate) fn parse_get_memory<'a, T>(mut path_tokens: T) -> Result<ParsedRequest, RequestError>
+where
+    T: Iterator<Item = &'a str>,
+{
+    match path_tokens.next() {
+        Some("mappings") => Ok(ParsedRequest::new_sync(VmmAction::GetMemoryMappings)),
+        Some("dirty") => Ok(ParsedRequest::new_sync(VmmAction::GetMemoryDirty)),
+        Some(unknown_path) => Err(RequestError::InvalidPathMethod(
+            format!("/memory/{}", unknown_path),
+            Method::Get,
+        )),
+        None => Ok(ParsedRequest::new_sync(VmmAction::GetMemory)),
+    }
+}

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/firecracker/src/api_server/request/snapshot.rs

@@ -91,13 +91,21 @@ fn parse_put_snapshot_load(body: &Body) -> Result<ParsedRequest, RequestError> {
     // If `mem_file_path` is specified instead of `mem_backend`, we construct the
     // `MemBackendConfig` object from the path specified, with `File` as backend type.
     let mem_backend = match snapshot_config.mem_backend {
-        Some(backend_cfg) => backend_cfg,
+        Some(backend_cfg) => {
+            if backend_cfg.use_memfd && backend_cfg.backend_type != MemBackendType::Uffd {
+                return Err(RequestError::SerdeJson(serde_json::Error::custom(
+                    "use_memfd is only valid when backend_type is Uffd",
+                )));
+            }
+            backend_cfg
+        }
         None => {
             MemBackendConfig {
                 // This is safe to unwrap() because we ensure above that one of the two:
                 // either `mem_file_path` or `mem_backend` field is always specified.
                 backend_path: snapshot_config.mem_file_path.unwrap(),
                 backend_type: MemBackendType::File,
+                use_memfd: false,
             }
         }
     };
@@ -145,7 +153,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()),
@@ -159,7 +167,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()),
@@ -184,6 +192,7 @@ mod tests {
             mem_backend: MemBackendConfig {
                 backend_path: PathBuf::from("bar"),
                 backend_type: MemBackendType::File,
+                use_memfd: false,
             },
             track_dirty_pages: false,
             resume_vm: false,
@@ -215,6 +224,7 @@ mod tests {
             mem_backend: MemBackendConfig {
                 backend_path: PathBuf::from("bar"),
                 backend_type: MemBackendType::File,
+                use_memfd: false,
             },
             track_dirty_pages: true,
             resume_vm: false,
@@ -246,6 +256,7 @@ mod tests {
             mem_backend: MemBackendConfig {
                 backend_path: PathBuf::from("bar"),
                 backend_type: MemBackendType::Uffd,
+                use_memfd: false,
             },
             track_dirty_pages: false,
             resume_vm: true,
@@ -283,6 +294,7 @@ mod tests {
             mem_backend: MemBackendConfig {
                 backend_path: PathBuf::from("bar"),
                 backend_type: MemBackendType::Uffd,
+                use_memfd: false,
             },
             track_dirty_pages: false,
             resume_vm: true,
@@ -314,6 +326,7 @@ mod tests {
             mem_backend: MemBackendConfig {
                 backend_path: PathBuf::from("bar"),
                 backend_type: MemBackendType::File,
+                use_memfd: false,
             },
             track_dirty_pages: false,
             resume_vm: true,
@@ -401,6 +414,45 @@ mod tests {
         );
         parse_put_snapshot(&Body::new(body), Some("invalid")).unwrap_err();
         parse_put_snapshot(&Body::new(body), None).unwrap_err();
+
+        // use_memfd=true with Uffd backend must be accepted and propagated.
+        let body = r#"{
+            "snapshot_path": "foo",
+            "mem_backend": {
+                "backend_path": "bar",
+                "backend_type": "Uffd",
+                "use_memfd": true
+            }
+        }"#;
+        let expected_config = LoadSnapshotParams {
+            snapshot_path: PathBuf::from("foo"),
+            mem_backend: MemBackendConfig {
+                backend_path: PathBuf::from("bar"),
+                backend_type: MemBackendType::Uffd,
+                use_memfd: true,
+            },
+            track_dirty_pages: false,
+            resume_vm: false,
+            network_overrides: vec![],
+            clock_realtime: false,
+        };
+        let mut parsed_request = parse_put_snapshot(&Body::new(body), Some("load")).unwrap();
+        assert!(parsed_request.parsing_info().take_deprecation_message().is_none());
+        assert_eq!(
+            vmm_action_from_request(parsed_request),
+            VmmAction::LoadSnapshot(expected_config)
+        );
+
+        // use_memfd=true with File backend must be rejected.
+        let body = r#"{
+            "snapshot_path": "foo",
+            "mem_backend": {
+                "backend_path": "bar",
+                "backend_type": "File",
+                "use_memfd": true
+            }
+        }"#;
+        parse_put_snapshot(&Body::new(body), Some("load")).unwrap_err();
     }
 
     #[test]