Add is_hugetlbfs() to GuestMemoryRegion

Virtio-balloon can release the unused host memory to decrease the memory
usage of the VMM.
Release normal pages and hugetlbfs pages require different operations.
(madvise MADV_DONTNEED and fallocate64 FALLOC_FL_PUNCH_HOLE)

This commit add Add is_hugetlbfs() to GuestMemoryRegion to help
VMM decide if this is a hugetlbfs address or not.

Signed-off-by: Hui Zhu <teawater@antfin.com>

Author: Hui Zhu

src/guest_memory.rs

@@ -288,6 +288,11 @@ pub trait GuestMemoryRegion: Bytes<MemoryRegionAddress, E = Error> {
     fn as_volatile_slice(&self) -> Result<volatile_memory::VolatileSlice> {
         self.get_slice(MemoryRegionAddress(0), self.len() as usize)
     }
+
+    /// Returns true if the region is hugetlbfs
+    fn is_hugetlbfs(&self) -> bool {
+        false
+    }
 }
 
 /// `GuestAddressSpace` provides a way to retrieve a `GuestMemory` object.
@@ -1106,4 +1111,13 @@ mod tests {
 
         crate::bytes::tests::check_atomic_accesses(mem, addr, bad_addr);
     }
+
+    #[cfg(feature = "backend-mmap")]
+    #[test]
+    fn test_guest_memory_mmap_is_hugetlbfs() {
+        let addr = GuestAddress(0x1000);
+        let mem = GuestMemoryMmap::from_ranges(&[(addr, 0x1000)]).unwrap();
+        let r = mem.find_region(addr).unwrap();
+        assert_eq!(r.is_hugetlbfs(), false);
+    }
 }

src/mmap.rs

@@ -403,6 +403,10 @@ impl GuestMemoryRegion for GuestRegionMmap {
         let slice = self.mapping.get_slice(offset.raw_value() as usize, count)?;
         Ok(slice)
     }
+
+    fn is_hugetlbfs(&self) -> bool {
+        self.mapping.is_hugetlbfs()
+    }
 }
 
 /// [`GuestMemory`](trait.GuestMemory.html) implementation that mmaps the guest's memory

src/mmap_unix.rs

@@ -272,6 +272,11 @@ impl MmapRegion {
         }
         false
     }
+
+    /// Returns `true` if the region is hugetlbfs
+    pub fn is_hugetlbfs(&self) -> bool {
+        (self.flags & libc::MAP_HUGETLB) != 0
+    }
 }
 
 impl AsSlice for MmapRegion {
@@ -327,6 +332,9 @@ mod tests {
     use std::sync::Arc;
     use vmm_sys_util::tempfile::TempFile;
 
+    use std::ffi;
+    use std::{fs::File, os::unix::io::FromRawFd};
+
     // Adding a helper method to extract the errno within an Error::Mmap(e), or return a
     // distinctive value when the error is represented by another variant.
     impl Error {
@@ -354,6 +362,34 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_mmap_region_is_hugetlbfs() {
+        let r = MmapRegion::new(4096).unwrap();
+        assert_eq!(r.is_hugetlbfs(), false);
+
+        let res = unsafe {
+            libc::syscall(
+                libc::SYS_memfd_create,
+                &ffi::CString::new("ch_ram").unwrap(),
+                libc::MFD_HUGETLB | libc::MAP_HUGE_2MB as u32,
+            )
+        };
+        if res < 0 {
+            /* Linux kernel version older than 4.16 doesn't support MFD_HUGETLB */
+            return;
+        }
+        let f = unsafe { File::from_raw_fd(res as i32) };
+        f.set_len(2 * 1024 * 1024).unwrap();
+        let r = MmapRegion::build(
+            Some(FileOffset::new(f, 0)),
+            2 * 1024 * 1024,
+            libc::PROT_READ | libc::PROT_WRITE,
+            libc::MAP_NORESERVE | libc::MAP_PRIVATE | libc::MAP_HUGETLB,
+        )
+        .unwrap();
+        assert_eq!(r.is_hugetlbfs(), true);
+    }
+
     #[test]
     fn test_mmap_region_from_file() {
         let mut f = TempFile::new().unwrap().into_file();

src/mmap_windows.rs

@@ -175,6 +175,11 @@ impl MmapRegion {
     pub fn file_offset(&self) -> Option<&FileOffset> {
         self.file_offset.as_ref()
     }
+
+    /// Windows doesn't have hugetlbfs.
+    pub fn is_hugetlbfs(&self) -> bool {
+        false
+    }
 }
 
 impl AsSlice for MmapRegion {