refactor code, clean up and handle edge cases better

Author: nia-e

src/alloc_bytes.rs

@@ -5,8 +5,8 @@ use std::{alloc, slice};
 use rustc_abi::{Align, Size};
 use rustc_middle::mir::interpret::AllocBytes;
 
-use crate::helpers::ToU64 as _;
 use crate::discrete_alloc::MachineAlloc;
+use crate::helpers::ToU64 as _;
 
 /// Allocation bytes that explicitly handle the layout of the data they're storing.
 /// This is necessary to interface with native code that accesses the program store in Miri.

src/discrete_alloc.rs

@@ -36,16 +36,14 @@ impl MachineAlloc {
     }
 
     /// 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;
         // 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 _
+                ret.try_into().unwrap()
             } else {
                 4096 // fallback
             }
@@ -107,7 +105,6 @@ impl MachineAlloc {
     }
 
     /// SAFETY: See alloc::alloc()
-    #[allow(clippy::cast_possible_wrap)]
     unsafe fn alloc_inner(&mut self, layout: Layout) -> *mut u8 {
         let (size, align) = MachineAlloc::normalized_layout(layout);
 
@@ -122,11 +119,11 @@ impl MachineAlloc {
                     if pinfo[idx / 8..idx / 8 + size / 8].iter().all(|v| *v == 0) {
                         pinfo[idx / 8..idx / 8 + size / 8].fill(255);
                         unsafe {
-                            let ret = page.offset(idx as isize);
+                            let ret = page.offset(idx.try_into().unwrap());
                             if ret.addr() >= page.addr() + self.page_size {
                                 panic!("Returing {} from page {}", ret.addr(), page.addr());
                             }
-                            return page.offset(idx as isize);
+                            return page.offset(idx.try_into().unwrap());
                         }
                     }
                 }
@@ -225,45 +222,47 @@ impl MachineAlloc {
     ///
     /// SAFETY: Accessing memory after this point will result in a segfault
     /// unless it is first unprotected.
-    pub unsafe fn prepare_ffi() -> Option<()> {
+    pub unsafe fn prepare_ffi() -> Result<(), nix::errno::Errno> {
         let mut alloc = ALLOCATOR.lock().unwrap();
         unsafe {
-            alloc.mprotect(ProtFlags::PROT_NONE).unwrap();
+            alloc.mprotect(ProtFlags::PROT_NONE)?;
         }
         alloc.ffi_mode = true;
-        Some(())
+        Ok(())
     }
 
-    /// Deprotects all owned memory by setting it to RW.
-    pub fn unprep_ffi() -> Option<()> {
+    /// Deprotects all owned memory by setting it to RW. Erroring here is very
+    /// likely unrecoverable, so it may panic if applying those permissions
+    /// fails.
+    pub fn unprep_ffi() {
         let mut alloc = ALLOCATOR.lock().unwrap();
         let default_flags = ProtFlags::PROT_READ | ProtFlags::PROT_WRITE;
         unsafe {
-            alloc.mprotect(default_flags)?;
+            alloc.mprotect(default_flags).unwrap();
         }
         alloc.ffi_mode = false;
-        Some(())
     }
 
     /// Applies `prot` to every page managed by the allocator.
     ///
     /// SAFETY: Accessing memory in violation of the protection flags will
     /// trigger a segfault.
-    unsafe fn mprotect(&mut self, prot: ProtFlags) -> Option<()> {
+    unsafe fn mprotect(&mut self, prot: ProtFlags) -> Result<(), nix::errno::Errno> {
         for &pg in &self.pages {
             unsafe {
+                // We already know only non-null ptrs are pushed to self.pages
                 let addr: std::ptr::NonNull<std::ffi::c_void> =
-                    std::ptr::NonNull::new_unchecked(pg as *mut _);
-                nix::sys::mman::mprotect(addr, self.page_size, prot).ok()?;
+                    std::ptr::NonNull::new_unchecked(pg.cast());
+                nix::sys::mman::mprotect(addr, self.page_size, prot)?;
             }
         }
         for &(hpg, size) in &self.huge_allocs {
             unsafe {
-                let addr = std::ptr::NonNull::new_unchecked(hpg as *mut _);
-                nix::sys::mman::mprotect(addr, size, prot).ok()?;
+                let addr = std::ptr::NonNull::new_unchecked(hpg.cast());
+                nix::sys::mman::mprotect(addr, size, prot)?;
             }
         }
-        Some(())
+        Ok(())
     }
 }
 

src/shims/native_lib.rs

@@ -203,7 +203,7 @@ unsafe fn do_native_call<T: libffi::high::CType>(ptr: CodePtr, args: &[ffi::Arg<
     let ret = unsafe {
         Supervisor::start_ffi().unwrap();
         let ret = ffi::call(ptr, args);
-        Supervisor::end_ffi().unwrap();
+        Supervisor::end_ffi();
         ret
     };
     let accesses = Supervisor::get_events().unwrap();