Introduce MmapResult (#1451)

This PR fixes #1450.

Author: qinsoon

src/policy/space.rs

@@ -207,7 +207,7 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
                     self.get_name(),
                 ))
             {
-                OS::handle_mmap_error::<VM>(mmap_error, tls, res.start, bytes);
+                OS::handle_mmap_error::<VM>(mmap_error, tls);
             }
         };
         let grow_space = || {

src/util/address.rs

@@ -203,6 +203,11 @@ impl Address {
         Address(self.0 + size)
     }
 
+    /// Wrapping (modular) addition. Computes self + rhs, wrapping around at the boundary of the type.
+    pub const fn wrapping_add(self, size: usize) -> Address {
+        Address(self.0.wrapping_add(size))
+    }
+
     // We implemented the Sub trait but we still keep this sub function.
     // The sub() function is const fn, and we can use it to declare Address constants.
     // The Sub trait function cannot be const.

src/util/heap/layout/mmapper/csm/byte_map_storage.rs

@@ -9,8 +9,8 @@ use std::fmt;
 use std::sync::atomic::Ordering;
 use std::sync::Mutex;
 
+use crate::util::os::MmapResult;
 use atomic::Atomic;
-use std::io::Result;
 
 /// Logarithm of the address space size that [`ByteMapStateStorage`] is able to handle.
 /// This is enough for 32-bit architectures.
@@ -60,9 +60,9 @@ impl MapStateStorage for ByteMapStateStorage {
         }
     }
 
-    fn bulk_transition_state<F>(&self, range: ChunkRange, mut update_fn: F) -> Result<()>
+    fn bulk_transition_state<F>(&self, range: ChunkRange, mut update_fn: F) -> MmapResult<()>
     where
-        F: FnMut(ChunkRange, MapState) -> Result<Option<MapState>>,
+        F: FnMut(ChunkRange, MapState) -> MmapResult<Option<MapState>>,
     {
         if range.is_empty() {
             return Ok(());

src/util/heap/layout/mmapper/csm/mod.rs

@@ -5,7 +5,7 @@ use crate::util::heap::layout::Mmapper;
 use crate::util::os::*;
 use crate::util::Address;
 use bytemuck::NoUninit;
-use std::{io::Result, sync::Mutex};
+use std::sync::Mutex;
 
 mod byte_map_storage;
 #[cfg(target_pointer_width = "64")]
@@ -94,9 +94,9 @@ trait MapStateStorage {
     /// -   `Ok(Some(new_state))`: Set the state of all chunks within `group_range` to `new_state`.
     ///
     /// Return `Ok(())` if finished visiting all chunks normally.
-    fn bulk_transition_state<F>(&self, range: ChunkRange, update_fn: F) -> Result<()>
+    fn bulk_transition_state<F>(&self, range: ChunkRange, update_fn: F) -> MmapResult<()>
     where
-        F: FnMut(ChunkRange, MapState) -> Result<Option<MapState>>;
+        F: FnMut(ChunkRange, MapState) -> MmapResult<Option<MapState>>;
 }
 
 /// A [`Mmapper`] implementation based on a logical array of chunk states.
@@ -148,7 +148,7 @@ impl Mmapper for ChunkStateMmapper {
         pages: usize,
         huge_page_option: HugePageSupport,
         anno: &MmapAnnotation,
-    ) -> Result<()> {
+    ) -> MmapResult<()> {
         let _guard = self.transition_lock.lock().unwrap();
 
         let bytes = pages << LOG_BYTES_IN_PAGE;
@@ -189,7 +189,7 @@ impl Mmapper for ChunkStateMmapper {
         huge_page_option: HugePageSupport,
         prot: MmapProtection,
         anno: &MmapAnnotation,
-    ) -> Result<()> {
+    ) -> MmapResult<()> {
         let _guard = self.transition_lock.lock().unwrap();
 
         let bytes = pages << LOG_BYTES_IN_PAGE;

src/util/heap/layout/mmapper/csm/two_level_storage.rs

@@ -6,13 +6,13 @@
 use super::MapState;
 use crate::util::heap::layout::mmapper::csm::{ChunkRange, MapStateStorage};
 use crate::util::heap::layout::vm_layout::*;
+use crate::util::os::MmapResult;
 use crate::util::rust_util::atomic_box::OnceOptionBox;
 use crate::util::rust_util::rev_group::RevisitableGroupByForIterator;
 use crate::util::rust_util::zeroed_alloc::new_zeroed_vec;
 use crate::util::Address;
 use atomic::{Atomic, Ordering};
 use std::fmt;
-use std::io::Result;
 
 /// Logarithm of the address space size that [`TwoLevelStateStorage`] is able to handle.
 /// This is enough for ARM64, x86_64 and some other architectures.
@@ -103,9 +103,9 @@ impl MapStateStorage for TwoLevelStateStorage {
         });
     }
 
-    fn bulk_transition_state<F>(&self, range: ChunkRange, mut update_fn: F) -> Result<()>
+    fn bulk_transition_state<F>(&self, range: ChunkRange, mut update_fn: F) -> MmapResult<()>
     where
-        F: FnMut(ChunkRange, MapState) -> Result<Option<MapState>>,
+        F: FnMut(ChunkRange, MapState) -> MmapResult<Option<MapState>>,
     {
         if range.is_empty() {
             return Ok(());

src/util/heap/layout/mmapper/mod.rs

@@ -1,5 +1,4 @@
 use crate::util::{os::*, Address};
-use std::io::Result;
 
 #[allow(unused)] // Used in doc comment.
 use crate::util::constants::LOG_BYTES_IN_PAGE;
@@ -76,7 +75,7 @@ pub trait Mmapper: Sync {
         pages: usize,
         huge_page_option: HugePageSupport,
         anno: &MmapAnnotation,
-    ) -> Result<()>;
+    ) -> MmapResult<()>;
 
     /// Ensure that a range of pages is mmapped (or equivalent).  If the
     /// pages are not yet mapped, demand-zero map them. Note that mapping
@@ -97,7 +96,7 @@ pub trait Mmapper: Sync {
         huge_page_option: HugePageSupport,
         prot: MmapProtection,
         anno: &MmapAnnotation,
-    ) -> Result<()>;
+    ) -> MmapResult<()>;
 
     /// Is the page pointed to by this address mapped? Returns true if
     /// the page at the given address is mapped.

src/util/metadata/side_metadata/global.rs

@@ -10,7 +10,6 @@ use crate::util::Address;
 use num_traits::FromPrimitive;
 use ranges::BitByteRange;
 use std::fmt;
-use std::io::Result;
 use std::sync::atomic::{AtomicU8, Ordering};
 
 /// This struct stores the specification of a side metadata bit-set.
@@ -1391,7 +1390,7 @@ impl SideMetadataContext {
         start: Address,
         size: usize,
         space_name: &str,
-    ) -> Result<()> {
+    ) -> MmapResult<()> {
         debug!(
             "try_map_metadata_space({}, 0x{:x}, {}, {})",
             start,
@@ -1414,7 +1413,7 @@ impl SideMetadataContext {
         start: Address,
         size: usize,
         name: &str,
-    ) -> Result<()> {
+    ) -> MmapResult<()> {
         debug!(
             "try_map_metadata_address_range({}, 0x{:x}, {}, {})",
             start,
@@ -1441,16 +1440,13 @@ impl SideMetadataContext {
         size: usize,
         no_reserve: bool,
         space_name: &str,
-    ) -> Result<()> {
+    ) -> MmapResult<()> {
         for spec in self.global.iter() {
             let anno = MmapAnnotation::SideMeta {
                 space: space_name,
                 meta: spec.name,
             };
-            match try_mmap_contiguous_metadata_space(start, size, spec, no_reserve, &anno) {
-                Ok(_) => {}
-                Err(e) => return Result::Err(e),
-            }
+            try_mmap_contiguous_metadata_space(start, size, spec, no_reserve, &anno)?;
         }
 
         #[cfg(target_pointer_width = "32")]
@@ -1474,10 +1470,7 @@ impl SideMetadataContext {
                     space: space_name,
                     meta: spec.name,
                 };
-                match try_mmap_contiguous_metadata_space(start, size, spec, no_reserve, &anno) {
-                    Ok(_) => {}
-                    Err(e) => return Result::Err(e),
-                }
+                try_mmap_contiguous_metadata_space(start, size, spec, no_reserve, &anno)?;
             }
             #[cfg(target_pointer_width = "32")]
             {
@@ -1500,10 +1493,7 @@ impl SideMetadataContext {
                 space: space_name,
                 meta: "all",
             };
-            match try_map_per_chunk_metadata_space(start, size, lsize, no_reserve, &anno) {
-                Ok(_) => {}
-                Err(e) => return Result::Err(e),
-            }
+            try_map_per_chunk_metadata_space(start, size, lsize, no_reserve, &anno)?;
         }
 
         Ok(())

src/util/metadata/side_metadata/helpers.rs

@@ -9,7 +9,6 @@ use crate::util::metadata::side_metadata::address_to_chunked_meta_address;
 use crate::util::os::*;
 use crate::util::Address;
 use crate::MMAPPER;
-use std::io::Result;
 
 /// Performs address translation in contiguous metadata spaces (e.g. global and policy-specific in 64-bits, and global in 32-bits)
 pub(super) fn address_to_contiguous_meta_address(
@@ -127,7 +126,7 @@ pub(super) fn try_mmap_contiguous_metadata_space(
     spec: &SideMetadataSpec,
     no_reserve: bool,
     anno: &MmapAnnotation,
-) -> Result<usize> {
+) -> MmapResult<usize> {
     debug_assert!(start.is_aligned_to(BYTES_IN_PAGE));
     debug_assert!(size % BYTES_IN_PAGE == 0);
 

src/util/metadata/side_metadata/helpers_32.rs

@@ -5,7 +5,6 @@ use crate::util::{
     os::*,
     Address,
 };
-use std::io::Result;
 
 use super::constants::{
     LOCAL_SIDE_METADATA_BASE_ADDRESS, LOCAL_SIDE_METADATA_PER_CHUNK,
@@ -113,7 +112,7 @@ pub(super) fn try_map_per_chunk_metadata_space(
     local_per_chunk: usize,
     no_reserve: bool,
     anno: &MmapAnnotation,
-) -> Result<usize> {
+) -> MmapResult<usize> {
     let mut aligned_start = start.align_down(BYTES_IN_CHUNK);
     let aligned_end = (start + size).align_up(BYTES_IN_CHUNK);
 
@@ -152,11 +151,12 @@ pub(super) fn try_map_per_chunk_metadata_space(
                 local_per_chunk,
                 res
             );
-            return Result::Err(res.err().unwrap());
+            return Err(res.err().unwrap());
         }
         if munmap_first_chunk.is_none() {
             // if first chunk is newly mapped, it needs munmap on failure
-            let map_exists = res.is_err_and(|e| e.kind() == std::io::ErrorKind::AlreadyExists);
+            let map_exists =
+                res.is_err_and(|e| e.error.kind() == std::io::ErrorKind::AlreadyExists);
             munmap_first_chunk = Some(map_exists);
         }
         aligned_start += BYTES_IN_CHUNK;
@@ -178,7 +178,7 @@ pub(super) fn try_mmap_metadata_chunk(
     local_per_chunk: usize,
     no_reserve: bool,
     anno: &MmapAnnotation,
-) -> Result<()> {
+) -> MmapResult<()> {
     debug_assert!(start.is_aligned_to(BYTES_IN_CHUNK));
 
     let policy_meta_start = address_to_meta_chunk_addr(start);

src/util/os/imp/unix_like/linux_like/android.rs

@@ -14,7 +14,7 @@ impl OSMemory for Android {
         size: usize,
         strategy: MmapStrategy,
         annotation: &MmapAnnotation<'_>,
-    ) -> Result<Address> {
+    ) -> MmapResult<Address> {
         linux_common::dzmmap(start, size, strategy, annotation)
     }