Merge branch 'main' into small-error-cleanup

Author: roypat

docs/kernel-policy.md

@@ -37,6 +37,19 @@ The guest kernel configs used in our validation pipelines can be found
 [here](../resources/guest_configs/) while a breakdown of the relevant guest
 kernel modules can be found in the next section.
 
+We use these configurations to build microVM-specific kernels vended by Amazon
+Linux. microVM kernel source code is published in the Amazon Linux
+[linux repo](https://github.com/amazonlinux/linux) under tags in the form of
+`microvm-kernel-*`, e.g. 6.1.128-3.201.amazn2023 kernel can be found
+[here](https://github.com/amazonlinux/linux/tree/microvm-kernel-6.1.128-3.201.amzn2023).
+These kernels may have diverged from the equivalent mainline versions, as we
+often backport patches that we require for supporting Firecracker features not
+present in the kernel versions we officially support. As a result, kernel
+configurations found in this repo should be used to build exclusively the
+aforementioned Amazon Linux kernels. We do not guarantee that using these
+configurations to build upstream kernels, will work or produce usable kernel
+images.
+
 ## Guest kernel configuration items
 
 The configuration items that may be relevant for Firecracker are:

src/firecracker/examples/uffd/uffd_utils.rs

@@ -10,6 +10,7 @@ use std::fs::File;
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd};
 use std::os::unix::net::UnixStream;
 use std::ptr;
+use std::time::Duration;
 
 use serde::{Deserialize, Serialize};
 use userfaultfd::{Error, Event, Uffd};
@@ -52,38 +53,41 @@ pub struct UffdHandler {
 }
 
 impl UffdHandler {
+    fn try_get_mappings_and_file(
+        stream: &UnixStream,
+    ) -> Result<(String, Option<File>), std::io::Error> {
+        let mut message_buf = vec![0u8; 1024];
+        let (bytes_read, file) = stream.recv_with_fd(&mut message_buf[..])?;
+        message_buf.resize(bytes_read, 0);
+
+        // We do not expect to receive non-UTF-8 data from Firecracker, so this is probably
+        // an error we can't recover from. Just immediately abort
+        let body = String::from_utf8(message_buf.clone()).unwrap_or_else(|_| {
+            panic!(
+                "Received body is not a utf-8 valid string. Raw bytes received: {message_buf:#?}"
+            )
+        });
+        Ok((body, file))
+    }
+
     fn get_mappings_and_file(stream: &UnixStream) -> (String, File) {
         // Sometimes, reading from the stream succeeds but we don't receive any
         // UFFD descriptor. We don't really have a good understanding why this is
         // happening, but let's try to be a bit more robust and retry a few times
         // before we declare defeat.
         for _ in 1..=5 {
-            let mut message_buf = vec![0u8; 1024];
-            let (bytes_read, file) = match stream.recv_with_fd(&mut message_buf[..]) {
-                Ok(res) => res,
-                Err(err) => {
-                    println!("Could not receive message from stream: {err}");
-                    continue;
+            match Self::try_get_mappings_and_file(stream) {
+                Ok((body, Some(file))) => {
+                    return (body, file);
                 }
-            };
-            message_buf.resize(bytes_read, 0);
-
-            // We do not expect to receive non-UTF-8 data from Firecracker, so this is probably
-            // an error we can't recover from. Just immediately abort
-            let body = String::from_utf8(message_buf.clone()).unwrap_or_else(|_| {
-                panic!(
-                    "Received body is not a utf-8 valid string. Raw bytes received: \
-                     {message_buf:#?}"
-                )
-            });
-            let file = match file {
-                Some(file) => file,
-                None => {
-                    println!("Did not receive Uffd from UDS. Received body: {body}");
-                    continue;
+                Ok((body, None)) => {
+                    println!("Didn't receive UFFD over socket. We received: '{body}'. Retrying...");
                 }
-            };
-            return (body, file);
+                Err(err) => {
+                    println!("Could not get UFFD and mapping from Firecracker: {err}. Retrying...");
+                }
+            }
+            std::thread::sleep(Duration::from_millis(100));
         }
 
         panic!("Could not get UFFD and mappings after 5 retries");

tests/integration_tests/performance/test_snapshot_ab.py

@@ -142,7 +142,12 @@ def test_restore_latency(
 @pytest.mark.parametrize("uffd_handler", [None, "on_demand", "fault_all"])
 @pytest.mark.parametrize("huge_pages", HugePagesConfig)
 def test_post_restore_latency(
-    microvm_factory, rootfs, guest_kernel_linux_5_10, metrics, uffd_handler, huge_pages
+    microvm_factory,
+    rootfs,
+    guest_kernel_linux_5_10,
+    metrics,
+    uffd_handler,
+    huge_pages,
 ):
     """Collects latency metric of post-restore memory accesses done inside the guest"""
     if huge_pages != HugePagesConfig.NONE and uffd_handler is None:
@@ -190,11 +195,20 @@ def test_post_restore_latency(
 
 @pytest.mark.nonci
 @pytest.mark.parametrize("huge_pages", HugePagesConfig)
+@pytest.mark.parametrize(
+    ("vcpus", "mem"), [(1, 128), (1, 1024), (2, 2048), (3, 4096), (4, 6144)]
+)
 def test_population_latency(
-    microvm_factory, rootfs, guest_kernel_linux_5_10, metrics, huge_pages
+    microvm_factory,
+    rootfs,
+    guest_kernel_linux_5_10,
+    metrics,
+    huge_pages,
+    vcpus,
+    mem,
 ):
     """Collects population latency metrics (e.g. how long it takes UFFD handler to fault in all memory)"""
-    test_setup = SnapshotRestoreTest(mem=128, vcpus=1, huge_pages=huge_pages)
+    test_setup = SnapshotRestoreTest(mem=mem, vcpus=vcpus, huge_pages=huge_pages)
     vm = test_setup.boot_vm(microvm_factory, guest_kernel_linux_5_10, rootfs)
 
     metrics.set_dimensions(