stop hardcoding pagesize

Author: nia-e

src/discrete_alloc.rs

@@ -5,8 +5,6 @@ use nix::sys::mman::ProtFlags;
 
 static ALLOCATOR: sync::Mutex<MachineAlloc> = sync::Mutex::new(MachineAlloc::empty());
 
-// FIXME: Assume 4k pages for now, needs adjusting
-
 /// A distinct allocator for the `MiriMachine`, allowing us to manage its
 /// memory separately from that of Miri itself.
 #[derive(Debug)]
@@ -25,31 +23,33 @@ unsafe impl Send for MachineAlloc {}
 impl MachineAlloc {
     // Allocation-related methods
 
-    /// Initializes the allocator with 4k pages.
+    /// Initializes the allocator with placeholder 4k pages.
     const fn empty() -> Self {
         Self {
             pages: Vec::new(),
             huge_allocs: Vec::new(),
             allocated: Vec::new(),
             page_size: 4096,
-            //taken_sigaction: None,
             enabled: false,
             ffi_mode: false,
         }
     }
 
     /// SAFETY: There must be no existing `MiriAllocBytes`
+    #[allow(clippy::cast_sign_loss)]
+    #[allow(clippy::cast_possible_truncation)]
     pub unsafe fn enable() {
         let mut alloc = ALLOCATOR.lock().unwrap();
         alloc.enabled = true;
-    }
-
-    /// SAFETY: `MachineAlloc` must be empty.
-    #[allow(clippy::cast_possible_truncation)]
-    pub unsafe fn set_pagesize(page_size: u64) {
-        let mut alloc = ALLOCATOR.lock().unwrap();
-        assert!(page_size == 4096 || page_size == 4096 * 4);
-        alloc.page_size = page_size as usize;
+        // This needs to specifically be the system pagesize!
+        alloc.page_size = unsafe { 
+            let ret = libc::sysconf(libc::_SC_PAGE_SIZE);
+            if ret > 0 {
+                ret as _
+            } else {
+                4096 // fallback
+            }
+        }
     }
 
     /// Returns a vector of page addresses managed by the allocator.
@@ -79,7 +79,7 @@ impl MachineAlloc {
     #[inline]
     fn huge_normalized_layout(&self, layout: Layout) -> (usize, usize) {
         let size = layout.size().next_multiple_of(self.page_size);
-        let align = std::cmp::max(layout.align(), 4096);
+        let align = std::cmp::max(layout.align(), self.page_size);
         (size, align)
     }
 

src/machine.rs

@@ -744,7 +744,6 @@ impl<'tcx> MiriMachine<'tcx> {
                 (
                     unsafe {
                         discrete_alloc::MachineAlloc::enable();
-                        discrete_alloc::MachineAlloc::set_pagesize(page_size);
                         libloading::Library::new(lib_file_path)
                             .expect("failed to read specified extern shared object file")
                     },

src/shims/trace.rs

@@ -4,9 +4,10 @@ use nix::unistd;
 
 use crate::discrete_alloc;
 
-// Note: we do NOT ever want to block the child from accessing this!!
+// We do NOT ever want to block the child from accessing this!!
 static SUPERVISOR: std::sync::Mutex<Option<Supervisor>> = std::sync::Mutex::new(None);
 static mut PAGE_ADDR: *mut libc::c_void = std::ptr::null_mut();
+static mut PAGE_SIZE: usize = 4096;
 static mut CLICK_HERE_4_FREE_STACK: [u8; 1024] = [0; 1024];
 
 #[cfg(target_pointer_width = "64")]
@@ -67,6 +68,15 @@ impl Supervisor {
         drop(sv);
 
         if is_none {
+            #[allow(clippy::cast_possible_truncation)]
+            #[allow(clippy::cast_sign_loss)]
+            unsafe {
+                let ret = libc::sysconf(libc::_SC_PAGESIZE);
+                if ret > 0 {
+                    PAGE_SIZE = ret as _;
+                }
+            }
+
             let (t_message, r_message) = ipc::channel().unwrap();
             let (t_event, r_event) = ipc::channel().unwrap();
             unsafe {
@@ -407,7 +417,7 @@ fn handle_segfault(
 ) {
     let siginfo = ptrace::getsiginfo(pid).unwrap();
     let addr = unsafe { siginfo.si_addr().addr() };
-    let page_addr = addr - addr % 4096;
+    let page_addr = addr - addr % unsafe { PAGE_SIZE };
 
     if ch_pages.contains(&page_addr) {
         // Overall structure:
@@ -578,14 +588,14 @@ fn intercept_retptr(
 // manually, so we *must not ever* unwind from it
 pub unsafe extern "C" fn mempr_off() {
     unsafe {
-        let _ = libc::mprotect(PAGE_ADDR, 4096, libc::PROT_READ | libc::PROT_WRITE);
+        let _ = libc::mprotect(PAGE_ADDR, PAGE_SIZE, libc::PROT_READ | libc::PROT_WRITE);
     }
     let _ = signal::raise(signal::SIGSTOP);
 }
 
 pub unsafe extern "C" fn mempr_on() {
     unsafe {
-        let _ = libc::mprotect(PAGE_ADDR, 4096, libc::PROT_NONE);
+        let _ = libc::mprotect(PAGE_ADDR, PAGE_SIZE, libc::PROT_NONE);
     }
     let _ = signal::raise(signal::SIGSTOP);
 }