Merge branch 'firecracker-microvm:main' into main

Author: xxgj

.gitignore

@@ -18,3 +18,4 @@ tags
 /resources/x86_64
 /resources/aarch64
 redundant_seccomp_rules_build
+test_instrumented_firecracker_build

MAINTAINERS.md

@@ -9,5 +9,6 @@ Firecracker is maintained by a dedicated team within Amazon:
 - Jay Chung <jaehoc@amazon.com>
 - Marco Marangoni <mamarang@amazon.com>
 - Michael Zoumboulakis <zoumboul@amazon.com>
+- Pierre Bertholom <pbertho@amazon.com>
 - Riccardo Mancini <mancio@amazon.com>
 - Takahiro Itazuri <itazur@amazon.com>

src/vmm/src/devices/acpi/vmclock.rs

@@ -19,7 +19,7 @@ use crate::devices::acpi::generated::vmclock_abi::{
 use crate::devices::legacy::EventFdTrigger;
 use crate::logger::debug;
 use crate::snapshot::Persist;
-use crate::vstate::memory::GuestMemoryMmap;
+use crate::vstate::memory::{GuestMemoryExtension, GuestMemoryMmap};
 use crate::vstate::resources::ResourceAllocator;
 
 // SAFETY: `vmclock_abi` is a POD
@@ -114,6 +114,7 @@ impl VmClock {
 
     /// Activate [`VmClock`] device
     pub fn activate(&self, mem: &GuestMemoryMmap) -> Result<(), VmClockError> {
+        mem.check_range_plugged(self.guest_address, self.inner.as_slice().len())?;
         mem.write_slice(self.inner.as_slice(), self.guest_address)?;
         Ok(())
     }

src/vmm/src/devices/acpi/vmgenid.rs

@@ -14,7 +14,7 @@ use vmm_sys_util::eventfd::EventFd;
 use super::super::legacy::EventFdTrigger;
 use crate::logger::debug;
 use crate::snapshot::Persist;
-use crate::vstate::memory::{Bytes, GuestMemoryMmap};
+use crate::vstate::memory::{Bytes, GuestMemoryExtension, GuestMemoryMmap};
 use crate::vstate::resources::ResourceAllocator;
 
 /// Bytes of memory we allocate for VMGenID device
@@ -117,6 +117,7 @@ impl VmGenId {
             "vmgenid: writing new generation ID to guest: {:#034x}",
             self.gen_id
         );
+        mem.check_range_plugged(self.guest_address, self.gen_id.to_le_bytes().len())?;
         mem.write_slice(&self.gen_id.to_le_bytes(), self.guest_address)
             .map_err(VmGenIdError::WriteGuestMemory)?;
 

src/vmm/src/devices/virtio/mem/device.rs

@@ -510,7 +510,7 @@ impl VirtioMem {
                 updated_range.addr,
                 self.nb_blocks_to_len(updated_range.nb_blocks),
             )
-            .try_for_each(|slot| {
+            .try_for_each(|(slot, _)| {
                 let slot_range = RequestedRange {
                     addr: slot.guest_addr,
                     nb_blocks: slot.slice.len() / u64_to_usize(self.config.block_size),

src/vmm/src/vstate/memory.rs

@@ -296,6 +296,27 @@ impl GuestRegionMmapExt {
         })
     }
 
+    /// Check whether the given guest address range falls within plugged slots.
+    pub(crate) fn check_range_plugged(
+        &self,
+        caddr: MemoryRegionAddress,
+        len: usize,
+    ) -> Result<(), GuestMemoryError> {
+        // caddr is guaranteed to be within the region by the caller
+        // (try_for_each_region_in_range validates this).
+        let from = self
+            .start_addr()
+            .checked_add(caddr.raw_value())
+            .expect("caddr should be within the region");
+        if self
+            .slots_intersecting_range(from, len)
+            .any(|(_, plugged)| !plugged)
+        {
+            return Err(GuestMemoryError::HostAddressNotAvailable);
+        }
+        Ok(())
+    }
+
     pub(crate) fn slot_cnt(&self) -> u32 {
         u32::try_from(u64_to_usize(self.len()) / self.slot_size).unwrap()
     }
@@ -347,8 +368,8 @@ impl GuestRegionMmapExt {
         &self,
         from: GuestAddress,
         len: usize,
-    ) -> impl Iterator<Item = GuestMemorySlot<'_>> {
-        self.slots().map(|(slot, _)| slot).filter(move |slot| {
+    ) -> impl Iterator<Item = (GuestMemorySlot<'_>, bool)> {
+        self.slots().filter(move |(slot, _)| {
             // Two intervals [a, b) and [c, d) intersect iff a < d && c < b.
             // This correctly handles the containment case where the slot fully
             // contains the range (or vice versa).
@@ -640,6 +661,10 @@ where
 
     /// Discards a memory range, freeing up memory pages
     fn discard_range(&self, addr: GuestAddress, range_len: usize) -> Result<(), GuestMemoryError>;
+
+    /// Check whether the given guest address range falls entirely within plugged memory.
+    /// Returns Err if the address is not in any region or is in an unplugged slot.
+    fn check_range_plugged(&self, addr: GuestAddress, len: usize) -> Result<(), GuestMemoryError>;
 }
 
 /// State of a guest memory region saved to file/buffer.
@@ -822,6 +847,12 @@ impl GuestMemoryExtension for GuestMemoryMmap {
             region.discard_range(start, len)
         })
     }
+
+    fn check_range_plugged(&self, addr: GuestAddress, len: usize) -> Result<(), GuestMemoryError> {
+        self.try_for_each_region_in_range(addr, len, |region, offset, chunk_len| {
+            region.check_range_plugged(offset, chunk_len)
+        })
+    }
 }
 
 fn create_memfd(
@@ -1520,7 +1551,7 @@ mod tests {
             let from = base.unchecked_add((offset_pages * page_size) as u64);
             let len = len_pages * page_size;
             let found: Vec<_> = region.slots_intersecting_range(from, len).collect();
-            let addrs: Vec<_> = found.iter().map(|s| s.guest_addr).collect();
+            let addrs: Vec<_> = found.iter().map(|(s, _)| s.guest_addr).collect();
             assert_eq!(
                 addrs, expected,
                 "offset={offset_pages} pages, len={len_pages} pages"
@@ -1812,4 +1843,51 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_check_range_plugged() {
+        let region_size = 0x4000usize; // 4 slots of 0x1000
+        let regions = anonymous(
+            vec![(GuestAddress(0x10_0000), region_size)].into_iter(),
+            false,
+            HugePageConfig::None,
+        )
+        .unwrap();
+        let region = regions.into_iter().next().unwrap();
+
+        let state = GuestMemoryRegionState {
+            base_address: 0x10_0000,
+            size: region_size,
+            region_type: GuestRegionType::Hotpluggable,
+            plugged: vec![true, true, false, true],
+        };
+
+        let ext = GuestRegionMmapExt::from_state(region, &state, 0).unwrap();
+
+        // Slot 0 (offset 0..0x1000): plugged
+        ext.check_range_plugged(MemoryRegionAddress(0), 0x100)
+            .unwrap();
+        // Slot 1 (offset 0x1000..0x2000): plugged
+        ext.check_range_plugged(MemoryRegionAddress(0x1000), 0x100)
+            .unwrap();
+        // Slot 2 (offset 0x2000..0x3000): unplugged
+        assert!(
+            ext.check_range_plugged(MemoryRegionAddress(0x2000), 0x100)
+                .is_err()
+        );
+        // Spanning slots 1-2: fails because slot 2 is unplugged
+        assert!(
+            ext.check_range_plugged(MemoryRegionAddress(0x1800), 0x1000)
+                .is_err()
+        );
+        // Spanning slots 0-1: both plugged
+        ext.check_range_plugged(MemoryRegionAddress(0x800), 0x1000)
+            .unwrap();
+        // Slot 3 (offset 0x3000..0x4000): plugged
+        ext.check_range_plugged(MemoryRegionAddress(0x3000), 0x100)
+            .unwrap();
+        // Zero length: always ok
+        ext.check_range_plugged(MemoryRegionAddress(0x2000), 0)
+            .unwrap();
+    }
 }

tests/README.md

@@ -17,10 +17,20 @@ excluding tests marked with `pytest.mark.nonci`):
 tools/devtool -y test
 ```
 
+Note: some performance tests require host performance tuning (e.g. dedicating
+some memory for `hugetlbfs`). For those tests, the `--performance` flag is also
+required:
+
+```sh
+tools/devtool -y test --performance
+```
+
 To run only tests from specific directories and/or files:
 
 ```sh
 tools/devtool -y test -- integration_tests/performance/test_boottime.py
+# Or
+tools/devtool -y test --performance -- integration_tests/performance/test_huge_pages.py
 ```
 
 To run a single specific test from a file:
@@ -72,6 +82,9 @@ dev container automatically, so setting them on the host before invoking
   at the uVM chroot root. The cheap artifacts (`host-dmesg.log` and the guest
   serial console) are always collected. Default off. The nightly performance
   pipeline sets this.
+- `FC_TEST_DEVELOPMENT_ENVIRONMENT=1` — skip tests that depend on specific host
+  configurations that don't add any value when running on a development
+  environment.
 
 ### Output
 

tests/framework/microvm.py

@@ -252,7 +252,7 @@ def __init__(
 
         self._screen_pid = None
 
-        self.time_api_requests = global_props.host_linux_version != "6.1"
+        self.time_api_requests = True
         # disable the HTTP API timings as they cause a lot of false positives
         if int(os.environ.get("PYTEST_XDIST_WORKER_COUNT", 1)) > 1:
             self.time_api_requests = False

tests/framework/properties.py

@@ -80,6 +80,8 @@ def __init__(self):
         self.buildkite_build_number = os.environ.get("BUILDKITE_BUILD_NUMBER")
         self.buildkite_pr = os.environ.get("BUILDKITE_PULL_REQUEST", "false") != "false"
         self.buildkite_revision_a = os.environ.get("BUILDKITE_PULL_REQUEST_BASE_BRANCH")
+        # Development environment detection
+        self.is_dev_env = os.environ.get("FC_TEST_DEVELOPMENT_ENVIRONMENT") == "1"
 
         if self._in_git_repo():
             self.git_commit_id = run_cmd("git rev-parse HEAD")

tests/framework/utils_cpuid.py

@@ -38,6 +38,7 @@ class CpuModel(str, Enum):
 CPU_DICT = {
     CpuVendor.INTEL: {
         "Intel(R) Xeon(R) Platinum 8259CL CPU": "INTEL_CASCADELAKE",
+        "Intel(R) Xeon(R) Platinum 8275CL CPU": "INTEL_CASCADELAKE",
         "Intel(R) Xeon(R) Platinum 8375C CPU": "INTEL_ICELAKE",
         "Intel(R) Xeon(R) Platinum 8488C": "INTEL_SAPPHIRE_RAPIDS",
         "Intel(R) Xeon(R) 6975P-C": "INTEL_GRANITE_RAPIDS",