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 requiring 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.
It returns None represents that no information is available.

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

Author: Hui Zhu

src/guest_memory.rs

@@ -288,6 +288,30 @@ 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)
     }
+
+    /// Show if the region is based on the `HugeTLBFS`.
+    /// Returns Some(true) if the region is backed by hugetlbfs.
+    /// None represents that no information is available.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[cfg(feature = "backend-mmap")]
+    /// # use vm_memory::{GuestAddress, GuestMemory, GuestMemoryMmap, GuestRegionMmap};
+    ///
+    /// # #[cfg(feature = "backend-mmap")]
+    /// # 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(), None);
+    /// # }
+    /// # #[cfg(feature = "backend-mmap")]
+    /// # test_guest_memory_mmap_is_hugetlbfs();
+    /// ```
+    fn is_hugetlbfs(&self) -> Option<bool> {
+        None
+    }
 }
 
 /// `GuestAddressSpace` provides a way to retrieve a `GuestMemory` object.
@@ -1170,4 +1194,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(), None);
+    }
 }

src/mmap.rs

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

src/mmap_unix.rs

@@ -90,6 +90,7 @@ pub struct MmapRegion {
     prot: i32,
     flags: i32,
     owned: bool,
+    hugetlbfs: Option<bool>,
 }
 
 // Send and Sync aren't automatically inherited for the raw address pointer.
@@ -172,6 +173,7 @@ impl MmapRegion {
             prot,
             flags,
             owned: true,
+            hugetlbfs: None,
         })
     }
 
@@ -213,6 +215,7 @@ impl MmapRegion {
             prot,
             flags,
             owned: false,
+            hugetlbfs: None,
         })
     }
 
@@ -272,6 +275,16 @@ impl MmapRegion {
         }
         false
     }
+
+    /// Set the hugetlbfs of the region
+    pub fn set_hugetlbfs(&mut self, hugetlbfs: bool) {
+        self.hugetlbfs = Some(hugetlbfs)
+    }
+
+    /// Returns `true` if the region is hugetlbfs
+    pub fn is_hugetlbfs(&self) -> Option<bool> {
+        self.hugetlbfs
+    }
 }
 
 impl AsSlice for MmapRegion {
@@ -354,6 +367,45 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_mmap_region_set_hugetlbfs() {
+        assert!(MmapRegion::new(0).is_err());
+
+        let size = 4096;
+
+        let r = MmapRegion::new(size).unwrap();
+        assert_eq!(r.size(), size);
+        assert!(r.file_offset().is_none());
+        assert_eq!(r.prot(), libc::PROT_READ | libc::PROT_WRITE);
+        assert_eq!(
+            r.flags(),
+            libc::MAP_ANONYMOUS | libc::MAP_NORESERVE | libc::MAP_PRIVATE
+        );
+        assert_eq!(r.is_hugetlbfs(), None);
+
+        let mut r = MmapRegion::new(size).unwrap();
+        r.set_hugetlbfs(false);
+        assert_eq!(r.size(), size);
+        assert!(r.file_offset().is_none());
+        assert_eq!(r.prot(), libc::PROT_READ | libc::PROT_WRITE);
+        assert_eq!(
+            r.flags(),
+            libc::MAP_ANONYMOUS | libc::MAP_NORESERVE | libc::MAP_PRIVATE
+        );
+        assert_eq!(r.is_hugetlbfs(), Some(false));
+
+        let mut r = MmapRegion::new(size).unwrap();
+        r.set_hugetlbfs(true);
+        assert_eq!(r.size(), size);
+        assert!(r.file_offset().is_none());
+        assert_eq!(r.prot(), libc::PROT_READ | libc::PROT_WRITE);
+        assert_eq!(
+            r.flags(),
+            libc::MAP_ANONYMOUS | libc::MAP_NORESERVE | libc::MAP_PRIVATE
+        );
+        assert_eq!(r.is_hugetlbfs(), Some(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) -> Option<bool> {
+        None
+    }
 }
 
 impl AsSlice for MmapRegion {