fix(memory): punch holes for shared discard ranges

Use fallocate(PUNCH_HOLE|KEEP_SIZE) for MAP_SHARED file-backed guest memory so memfd-backed balloon hinting/reporting clears the shared backing instead of only dropping PTEs.

Author: ValentaTomas

src/vmm/src/vstate/memory.rs

@@ -8,6 +8,7 @@
 use std::fs::File;
 use std::io::SeekFrom;
 use std::ops::Deref;
+use std::os::fd::AsRawFd;
 use std::sync::{Arc, Mutex};
 
 use bitvec::vec::BitVec;
@@ -420,12 +421,32 @@ impl GuestRegionMmapExt {
                     Ok(())
                 }
             }
-            // Match either the case of an anonymous mapping, or the case
-            // of a shared file mapping.
-            // TODO: madvise(MADV_DONTNEED) doesn't actually work with memfd
-            // (or in general MAP_SHARED of a fd). In those cases we should use
-            // fallocate64(FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE).
-            // We keep falling to the madvise branch to keep the previous behaviour.
+            (Some(file_offset), flags) if flags & libc::MAP_SHARED != 0 => {
+                let Some(offset) = file_offset.start().checked_add(caddr.raw_value()) else {
+                    return Err(GuestMemoryError::InvalidGuestAddress(GuestAddress(
+                        caddr.raw_value(),
+                    )));
+                };
+
+                // SAFETY: fd, offset and length are validated by the kernel. The
+                // file is kept alive by the FileOffset held by this mmap region.
+                let ret = unsafe {
+                    libc::fallocate(
+                        file_offset.file().as_raw_fd(),
+                        libc::FALLOC_FL_PUNCH_HOLE | libc::FALLOC_FL_KEEP_SIZE,
+                        i64::try_from(offset).expect("shared discard offset fits in i64"),
+                        i64::try_from(len).expect("shared discard length fits in i64"),
+                    )
+                };
+                if ret < 0 {
+                    let os_error = std::io::Error::last_os_error();
+                    error!("discard_range: fallocate failed: {:?}", os_error);
+                    Err(GuestMemoryError::IOError(os_error))
+                } else {
+                    Ok(())
+                }
+            }
+            // Anonymous mapping.
             _ => {
                 // Madvise the region in order to mark it as not used.
                 // SAFETY: The address and length are known to be valid.
@@ -1462,6 +1483,32 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_discard_range_on_shared_memfd() {
+        let page_size: usize = 0x1000;
+        let (mem, _file) = memfd_backed(
+            &[(GuestAddress(0), 2 * page_size)],
+            false,
+            HugePageConfig::None,
+        )
+        .unwrap();
+        let mem = into_region_ext(mem);
+
+        let ones = vec![1u8; 2 * page_size];
+        mem.write(&ones, GuestAddress(0)).unwrap();
+
+        mem.discard_range(GuestAddress(0), page_size).unwrap();
+
+        let mut actual_page = vec![0u8; page_size];
+        mem.read(actual_page.as_mut_slice(), GuestAddress(0))
+            .unwrap();
+        assert_eq!(vec![0u8; page_size], actual_page);
+
+        mem.read(actual_page.as_mut_slice(), GuestAddress(page_size as u64))
+            .unwrap();
+        assert_eq!(vec![1u8; page_size], actual_page);
+    }
+
     /// Verifies that `slots_intersecting_range` returns the correct slots for
     /// ranges at slot boundaries, interior to a slot, and spanning two slots.
     #[test]