tmp: call mmap outselves

vm-memory has faulty validation logic that prevents us from mmap-ing
guest_memfds, so just bypass that by calling mmap ourselves for the time
being.

See also rust-vmm/vm-memory#320

Signed-off-by: Patrick Roy <roypat@amazon.co.uk>

Author: roypat

src/vmm/src/builder.rs

@@ -256,10 +256,7 @@ pub fn build_microvm_for_boot(
 
             Some(InitrdConfig::from_reader(
                 vmm.vm.guest_memory(),
-                MaybeBounce::new(
-                    initrd_file.as_fd(),
-                    vm_resources.machine_config.secret_free,
-                ),
+                MaybeBounce::new(initrd_file.as_fd(), vm_resources.machine_config.secret_free),
                 u64_to_usize(size),
             )?)
         }

src/vmm/src/vstate/memory.rs

@@ -7,6 +7,8 @@
 
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom, Write};
+use std::os::fd::AsRawFd;
+use std::ptr::null_mut;
 use std::sync::Arc;
 
 use serde::{Deserialize, Serialize};
@@ -51,6 +53,8 @@ pub enum MemoryError {
     MemfdSetLen(std::io::Error),
     /// Total sum of memory regions exceeds largest possible file offset
     OffsetTooLarge,
+    /// Error calling mmap: {0}
+    Mmap(std::io::Error),
 }
 
 /// Newtype that implements [`ReadVolatile`] and [`WriteVolatile`] if `T` implements `Read` or
@@ -204,16 +208,40 @@ pub fn create(
             let mut builder = MmapRegionBuilder::new_with_bitmap(
                 size,
                 track_dirty_pages.then(|| AtomicBitmap::with_len(size)),
-            )
-            .with_mmap_prot(libc::PROT_READ | libc::PROT_WRITE)
-            .with_mmap_flags(libc::MAP_NORESERVE | mmap_flags);
+            );
 
-            if let Some(ref file) = file {
+            // when computing offset below we ensure it fits into i64
+            #[allow(clippy::cast_possible_wrap)]
+            let (fd, fd_off) = if let Some(ref file) = file {
                 let file_offset = FileOffset::from_arc(Arc::clone(file), offset);
 
                 builder = builder.with_file_offset(file_offset);
+
+                (file.as_raw_fd(), offset as libc::off_t)
+            } else {
+                (-1, 0)
+            };
+
+            // SAFETY: the arguments to mmap cannot cause any memory unsafety in the rust sense
+            let ptr = unsafe {
+                libc::mmap(
+                    null_mut(),
+                    size,
+                    libc::PROT_READ | libc::PROT_WRITE,
+                    libc::MAP_NORESERVE | mmap_flags,
+                    fd,
+                    fd_off,
+                )
+            };
+
+            if ptr == libc::MAP_FAILED {
+                return Err(MemoryError::Mmap(std::io::Error::last_os_error()));
             }
 
+            // SAFETY: we check above that mmap succeeded, and the size we passed to builder is the
+            // same as the size of the mmap area.
+            let builder = unsafe { builder.with_raw_mmap_pointer(ptr.cast()) };
+
             offset = match offset.checked_add(size as u64) {
                 None => return Err(MemoryError::OffsetTooLarge),
                 Some(new_off) if new_off >= i64::MAX as u64 => {

src/vmm/src/vstate/vm.rs

@@ -12,7 +12,10 @@ use std::os::fd::FromRawFd;
 use std::path::Path;
 use std::sync::Arc;
 
-use kvm_bindings::{kvm_create_guest_memfd, kvm_userspace_memory_region, kvm_userspace_memory_region2, KVM_MEM_LOG_DIRTY_PAGES};
+use kvm_bindings::{
+    KVM_MEM_LOG_DIRTY_PAGES, kvm_create_guest_memfd, kvm_userspace_memory_region,
+    kvm_userspace_memory_region2,
+};
 use kvm_ioctls::{Cap, VmFd};
 use vmm_sys_util::eventfd::EventFd;
 

tests/integration_tests/functional/test_api.py

@@ -375,9 +375,7 @@ def test_api_machine_config(uvm_plain):
     bad_size = (1 << 64) - 1
     test_microvm.api.machine_config.patch(mem_size_mib=bad_size)
 
-    fail_msg = re.escape(
-        "Invalid Memory Configuration: Cannot create mmap region: Out of memory (os error 12)"
-    )
+    fail_msg = re.escape("Out of memory (os error 12)")
     with pytest.raises(RuntimeError, match=fail_msg):
         test_microvm.start()