OS interface (#1439)

This PR addresses #1420.

This PR is based on top of #1418,
and includes all the changes for Windows (for testing purpose). It is
likely that Windows support will be removed from this PR, and will be
merged separately.

This PR does not try to refactor our malloc interface -- I am not sure
if malloc should be included in the OS interface or not.

This PR consolidates the current multiple mmap functions (such as
dzmmap, mmap_fixed, mmap_noreplace, mmap_noreserve, etc), and use
`MmapStrategy` to specify the expected mmap behavior.

---------

Co-authored-by: sepcnt <30561671+sepcnt@users.noreply.github.com>

Author: qinsoon

benches/mock_bench/mmapper.rs

@@ -3,8 +3,7 @@ pub use criterion::Criterion;
 use mmtk::{
     memory_manager, mmap_anno_test,
     util::{
-        constants::BYTES_IN_PAGE, memory::MmapStrategy, test_private::MMAPPER,
-        test_util::fixtures::*, Address,
+        constants::BYTES_IN_PAGE, os::*, test_private::MMAPPER, test_util::fixtures::*, Address,
     },
 };
 
@@ -76,10 +75,17 @@ pub fn bench(c: &mut Criterion) {
     c.bench_function("ensure_mapped_regular", |b| {
         let start = regular.align_down(BYTES_IN_PAGE);
         assert!(start.is_mapped());
-        let strategy = MmapStrategy::new(false, mmtk::util::memory::MmapProtection::ReadWrite);
         let anno = mmap_anno_test!();
         b.iter(|| {
-            MMAPPER.ensure_mapped(start, 1, strategy, anno).unwrap();
+            MMAPPER
+                .ensure_mapped(
+                    start,
+                    1,
+                    HugePageSupport::No,
+                    MmapProtection::ReadWrite,
+                    anno,
+                )
+                .unwrap();
         })
     });
 }

src/plan/generational/gc_work.rs

@@ -4,6 +4,7 @@ use crate::plan::PlanTraceObject;
 use crate::plan::VectorObjectQueue;
 use crate::policy::gc_work::TraceKind;
 use crate::scheduler::{gc_work::*, GCWork, GCWorker, WorkBucketStage};
+use crate::util::os::*;
 use crate::util::ObjectReference;
 use crate::vm::slot::{MemorySlice, Slot};
 use crate::vm::*;
@@ -117,7 +118,7 @@ impl<E: ProcessEdgesWork> GCWork<E::VM> for ProcessModBuf<E> {
                     !gen.is_object_in_nursery(*obj),
                     "{} was logged but is not mature. Dumping process memory maps:\n{}",
                     *obj,
-                    crate::util::memory::get_process_memory_maps(),
+                    OS::get_process_memory_maps().unwrap(),
                 );
                 <E::VM as VMBinding>::VMObjectModel::GLOBAL_LOG_BIT_SPEC.store_atomic::<E::VM, u8>(
                     *obj,

src/policy/copyspace.rs

@@ -10,10 +10,10 @@ use crate::util::heap::{MonotonePageResource, PageResource};
 use crate::util::metadata::{extract_side_metadata, MetadataSpec};
 use crate::util::object_enum::ObjectEnumerator;
 use crate::util::object_forwarding;
+use crate::util::os::*;
 use crate::util::{copy::*, object_enum};
 use crate::util::{Address, ObjectReference};
 use crate::vm::*;
-use libc::{mprotect, PROT_EXEC, PROT_NONE, PROT_READ, PROT_WRITE};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
@@ -293,8 +293,8 @@ impl<VM: VMBinding> CopySpace<VM> {
         }
         let start = self.common().start;
         let extent = self.common().extent;
-        unsafe {
-            mprotect(start.to_mut_ptr(), extent, PROT_NONE);
+        if let Err(e) = OS::set_memory_access(start, extent, MmapProtection::NoAccess) {
+            panic!("Failed to protect memory: {:?}", e);
         }
         trace!("Protect {:x} {:x}", start, start + extent);
     }
@@ -308,12 +308,8 @@ impl<VM: VMBinding> CopySpace<VM> {
         }
         let start = self.common().start;
         let extent = self.common().extent;
-        unsafe {
-            mprotect(
-                start.to_mut_ptr(),
-                extent,
-                PROT_READ | PROT_WRITE | PROT_EXEC,
-            );
+        if let Err(e) = OS::set_memory_access(start, extent, self.common().mmap_protection()) {
+            panic!("Failed to unprotect memory: {:?}", e);
         }
         trace!("Unprotect {:x} {:x}", start, start + extent);
     }

src/policy/largeobjectspace.rs

@@ -292,7 +292,7 @@ impl<VM: VMBinding> LargeObjectSpace<VM> {
             FreeListPageResource::new_contiguous(common.start, common.extent, vm_map)
         };
         pr.protect_memory_on_release = if protect_memory_on_release {
-            Some(common.mmap_strategy().prot)
+            Some(common.mmap_protection())
         } else {
             None
         };

src/policy/lockfreeimmortalspace.rs

@@ -14,12 +14,11 @@ use crate::util::heap::gc_trigger::GCTrigger;
 use crate::util::heap::layout::vm_layout::vm_layout;
 use crate::util::heap::PageResource;
 use crate::util::heap::VMRequest;
-use crate::util::memory::MmapAnnotation;
-use crate::util::memory::MmapStrategy;
 use crate::util::metadata::side_metadata::SideMetadataContext;
 use crate::util::metadata::side_metadata::SideMetadataSanity;
 use crate::util::object_enum::ObjectEnumerator;
 use crate::util::opaque_pointer::*;
+use crate::util::os::*;
 use crate::util::ObjectReference;
 use crate::vm::VMBinding;
 
@@ -255,11 +254,12 @@ impl<VM: VMBinding> LockFreeImmortalSpace<VM> {
         };
 
         // Eagerly memory map the entire heap (also zero all the memory)
-        let strategy = MmapStrategy::new(
-            *args.options.transparent_hugepages,
-            crate::util::memory::MmapProtection::ReadWrite,
-        );
-        crate::util::memory::dzmmap_noreplace(
+        let strategy = MmapStrategy::default()
+            .transparent_hugepages(*args.options.transparent_hugepages)
+            .prot(crate::util::os::MmapProtection::ReadWrite)
+            .replace(false)
+            .reserve(true);
+        crate::util::os::OS::dzmmap(
             start,
             aligned_total_bytes,
             strategy,

src/policy/space.rs

@@ -30,7 +30,7 @@ use crate::util::heap::layout::Mmapper;
 use crate::util::heap::layout::VMMap;
 use crate::util::heap::space_descriptor::SpaceDescriptor;
 use crate::util::heap::HeapMeta;
-use crate::util::memory::{self, HugePageSupport, MmapProtection, MmapStrategy};
+use crate::util::os::*;
 use crate::vm::VMBinding;
 
 use std::marker::PhantomData;
@@ -191,8 +191,13 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
                 .ensure_mapped(
                     res.start,
                     res.pages,
-                    self.common().mmap_strategy(),
-                    &memory::MmapAnnotation::Space {
+                    if *self.common().options.transparent_hugepages {
+                        HugePageSupport::TransparentHugePages
+                    } else {
+                        HugePageSupport::No
+                    },
+                    self.common().mmap_protection(),
+                    &MmapAnnotation::Space {
                         name: self.get_name(),
                     },
                 )
@@ -202,7 +207,7 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
                     self.get_name(),
                 ))
             {
-                memory::handle_mmap_error::<VM>(mmap_error, tls, res.start, bytes);
+                OS::handle_mmap_error::<VM>(mmap_error, tls, res.start, bytes);
             }
         };
         let grow_space = || {
@@ -227,7 +232,7 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
 
         // TODO: Concurrent zeroing
         if self.common().zeroed {
-            memory::zero(res.start, bytes);
+            crate::util::memory::zero(res.start, bytes);
         }
 
         // Some assertions
@@ -755,18 +760,11 @@ impl<VM: VMBinding> CommonSpace<VM> {
         self.vm_map
     }
 
-    pub fn mmap_strategy(&self) -> MmapStrategy {
-        MmapStrategy {
-            huge_page: if *self.options.transparent_hugepages {
-                HugePageSupport::TransparentHugePages
-            } else {
-                HugePageSupport::No
-            },
-            prot: if self.permission_exec || cfg!(feature = "exec_permission_on_all_spaces") {
-                MmapProtection::ReadWriteExec
-            } else {
-                MmapProtection::ReadWrite
-            },
+    pub fn mmap_protection(&self) -> MmapProtection {
+        if self.permission_exec || cfg!(feature = "exec_permission_on_all_spaces") {
+            MmapProtection::ReadWriteExec
+        } else {
+            MmapProtection::ReadWrite
         }
     }
 

src/scheduler/affinity.rs

@@ -1,30 +1,6 @@
 use super::worker::ThreadId;
 use crate::util::options::AffinityKind;
-#[cfg(target_os = "linux")]
-use libc::{cpu_set_t, sched_getaffinity, sched_setaffinity, CPU_COUNT, CPU_SET, CPU_ZERO};
-
-/// Represents the ID of a logical CPU on a system.
-pub type CoreId = u16;
-
-// XXX: Maybe in the future we can use a library such as https://github.com/Elzair/core_affinity_rs
-// to have an OS agnostic way of setting thread affinity.
-#[cfg(target_os = "linux")]
-/// Return the total number of cores allocated to the program.
-pub fn get_total_num_cpus() -> u16 {
-    use std::mem::MaybeUninit;
-    unsafe {
-        let mut cs = MaybeUninit::zeroed().assume_init();
-        CPU_ZERO(&mut cs);
-        sched_getaffinity(0, std::mem::size_of::<cpu_set_t>(), &mut cs);
-        CPU_COUNT(&cs) as u16
-    }
-}
-
-#[cfg(not(target_os = "linux"))]
-/// Return the total number of cores allocated to the program.
-pub fn get_total_num_cpus() -> u16 {
-    unimplemented!()
-}
+use crate::util::os::*;
 
 impl AffinityKind {
     /// Resolve affinity of GC thread. Has a side-effect of calling into the kernel to set the
@@ -36,51 +12,13 @@ impl AffinityKind {
             AffinityKind::AllInSet(cpuset) => {
                 // Bind the current thread to all the cores in the set
                 debug!("Set affinity for thread {} to cpuset {:?}", thread, cpuset);
-                bind_current_thread_to_cpuset(cpuset.as_slice());
+                OS::bind_current_thread_to_cpuset(cpuset.as_slice());
             }
             AffinityKind::RoundRobin(cpuset) => {
                 let cpu = cpuset[thread % cpuset.len()];
                 debug!("Set affinity for thread {} to core {}", thread, cpu);
-                bind_current_thread_to_core(cpu);
+                OS::bind_current_thread_to_core(cpu);
             }
         }
     }
 }
-
-#[cfg(target_os = "linux")]
-/// Bind the current thread to the specified core.
-fn bind_current_thread_to_core(cpu: CoreId) {
-    use std::mem::MaybeUninit;
-    unsafe {
-        let mut cs = MaybeUninit::zeroed().assume_init();
-        CPU_ZERO(&mut cs);
-        CPU_SET(cpu as usize, &mut cs);
-        sched_setaffinity(0, std::mem::size_of::<cpu_set_t>(), &cs);
-    }
-}
-
-#[cfg(not(target_os = "linux"))]
-/// Bind the current thread to the specified core.
-fn bind_current_thread_to_core(_cpu: CoreId) {
-    unimplemented!()
-}
-
-#[cfg(any(target_os = "linux", target_os = "android"))]
-/// Bind the current thread to the specified core.
-fn bind_current_thread_to_cpuset(cpuset: &[CoreId]) {
-    use std::mem::MaybeUninit;
-    unsafe {
-        let mut cs = MaybeUninit::zeroed().assume_init();
-        CPU_ZERO(&mut cs);
-        for cpu in cpuset {
-            CPU_SET(*cpu as usize, &mut cs);
-        }
-        sched_setaffinity(0, std::mem::size_of::<cpu_set_t>(), &cs);
-    }
-}
-
-#[cfg(not(any(target_os = "linux", target_os = "android")))]
-/// Bind the current thread to the specified core.
-fn bind_current_thread_to_cpuset(_cpuset: &[CoreId]) {
-    unimplemented!()
-}

src/util/alloc/free_list_allocator.rs

@@ -2,6 +2,7 @@
 
 use std::sync::Arc;
 
+use super::allocator::AllocatorContext;
 use crate::policy::marksweepspace::native_ms::*;
 use crate::util::alloc::allocator;
 use crate::util::alloc::Allocator;
@@ -10,8 +11,6 @@ use crate::util::Address;
 use crate::util::VMThread;
 use crate::vm::VMBinding;
 
-use super::allocator::AllocatorContext;
-
 /// A MiMalloc free list allocator
 #[repr(C)]
 pub struct FreeListAllocator<VM: VMBinding> {

src/util/heap/freelistpageresource.rs

@@ -14,8 +14,8 @@ use crate::util::heap::layout::vm_layout::*;
 use crate::util::heap::layout::CreateFreeListResult;
 use crate::util::heap::pageresource::CommonPageResource;
 use crate::util::heap::space_descriptor::SpaceDescriptor;
-use crate::util::memory;
 use crate::util::opaque_pointer::*;
+use crate::util::os::*;
 use crate::util::raw_memory_freelist::RawMemoryFreeList;
 use crate::vm::*;
 use std::marker::PhantomData;
@@ -27,7 +27,7 @@ pub struct FreeListPageResource<VM: VMBinding> {
     sync: Mutex<FreeListPageResourceSync>,
     _p: PhantomData<VM>,
     /// Protect memory on release, and unprotect on re-allocate.
-    pub(crate) protect_memory_on_release: Option<memory::MmapProtection>,
+    pub(crate) protect_memory_on_release: Option<MmapProtection>,
 }
 
 unsafe impl<VM: VMBinding> Send for FreeListPageResource<VM> {}
@@ -219,7 +219,11 @@ impl<VM: VMBinding> FreeListPageResource<VM> {
         // > (e.g., read versus read/write protection) exceeding the
         // > allowed maximum.
         assert!(self.protect_memory_on_release.is_some());
-        if let Err(e) = memory::mprotect(start, conversions::pages_to_bytes(pages)) {
+        if let Err(e) = OS::set_memory_access(
+            start,
+            conversions::pages_to_bytes(pages),
+            MmapProtection::NoAccess,
+        ) {
             panic!(
                 "Failed at protecting memory (starting at {}): {:?}",
                 start, e
@@ -230,7 +234,7 @@ impl<VM: VMBinding> FreeListPageResource<VM> {
     /// Unprotect the memory
     fn munprotect(&self, start: Address, pages: usize) {
         assert!(self.protect_memory_on_release.is_some());
-        if let Err(e) = memory::munprotect(
+        if let Err(e) = OS::set_memory_access(
             start,
             conversions::pages_to_bytes(pages),
             self.protect_memory_on_release.unwrap(),

src/util/heap/layout/map64.rs

@@ -6,7 +6,7 @@ use crate::util::freelist::FreeList;
 use crate::util::heap::layout::heap_parameters::*;
 use crate::util::heap::layout::vm_layout::*;
 use crate::util::heap::space_descriptor::SpaceDescriptor;
-use crate::util::memory::MmapStrategy;
+use crate::util::os::*;
 use crate::util::raw_memory_freelist::RawMemoryFreeList;
 use crate::util::Address;
 use std::cell::UnsafeCell;