Remove memmap dependency (#311)

Try to slim down the dependencies of `gimli-symbolize`

Author: alexcrichton

Cargo.toml

@@ -36,7 +36,6 @@ cpp_demangle = { default-features = false, version = "0.2.3", optional = true }
 # Optional dependencies enabled through the `gimli-symbolize` feature
 addr2line = { version = "0.11.0", optional = true, default-features = false, features = ['std'] }
 findshlibs = { version = "0.5.0", optional = true }
-memmap = { version = "0.7.0", optional = true }
 goblin = { version = "0.2", optional = true, default-features = false, features = ['elf32', 'elf64', 'mach32', 'mach64', 'pe32', 'pe64', 'std'] }
 
 [target.'cfg(windows)'.dependencies]
@@ -97,7 +96,7 @@ kernel32 = []
 libbacktrace = ["backtrace-sys/backtrace-sys"]
 dladdr = []
 coresymbolication = []
-gimli-symbolize = ["addr2line", "findshlibs", "memmap", "goblin"]
+gimli-symbolize = ["addr2line", "findshlibs", "goblin"]
 
 #=======================================
 # Methods of serialization
@@ -112,6 +111,7 @@ verify-winapi = [
   'winapi/dbghelp',
   'winapi/handleapi',
   'winapi/libloaderapi',
+  'winapi/memoryapi',
   'winapi/minwindef',
   'winapi/processthreadsapi',
   'winapi/synchapi',

src/symbolize/gimli.rs

@@ -6,6 +6,7 @@
 
 use self::gimli::read::EndianSlice;
 use self::gimli::LittleEndian as Endian;
+use self::mmap::Mmap;
 use crate::symbolize::dladdr;
 use crate::symbolize::ResolveWhat;
 use crate::types::BytesOrWideString;
@@ -15,13 +16,20 @@ use core::mem;
 use core::u32;
 use findshlibs::{self, Segment, SharedLibrary};
 use libc::c_void;
-use memmap::Mmap;
+use std::convert::TryInto;
 use std::env;
 use std::ffi::OsString;
 use std::fs::File;
 use std::path::Path;
 use std::prelude::v1::*;
 
+#[cfg(windows)]
+#[path = "gimli/mmap_windows.rs"]
+mod mmap;
+#[cfg(unix)]
+#[path = "gimli/mmap_unix.rs"]
+mod mmap;
+
 const MAPPINGS_CACHE_SIZE: usize = 4;
 
 struct Context<'a> {
@@ -76,8 +84,8 @@ macro_rules! mk {
 
 fn mmap(path: &Path) -> Option<Mmap> {
     let file = File::open(path).ok()?;
-    // TODO: not completely safe, see https://github.com/danburkert/memmap-rs/issues/25
-    unsafe { Mmap::map(&file).ok() }
+    let len = file.metadata().ok()?.len().try_into().ok()?;
+    unsafe { Mmap::map(&file, len) }
 }
 
 cfg_if::cfg_if! {

src/symbolize/gimli/mmap_unix.rs

@@ -0,0 +1,44 @@
+use std::fs::File;
+use std::ops::Deref;
+use std::os::unix::prelude::*;
+use std::ptr;
+use std::slice;
+
+pub struct Mmap {
+    ptr: *mut libc::c_void,
+    len: usize,
+}
+
+impl Mmap {
+    pub unsafe fn map(file: &File, len: usize) -> Option<Mmap> {
+        let ptr = libc::mmap(
+            ptr::null_mut(),
+            len,
+            libc::PROT_READ,
+            libc::MAP_PRIVATE,
+            file.as_raw_fd(),
+            0,
+        );
+        if ptr == libc::MAP_FAILED {
+            return None;
+        }
+        Some(Mmap { ptr, len })
+    }
+}
+
+impl Deref for Mmap {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] {
+        unsafe { slice::from_raw_parts(self.ptr as *const u8, self.len) }
+    }
+}
+
+impl Drop for Mmap {
+    fn drop(&mut self) {
+        unsafe {
+            let r = libc::munmap(self.ptr, self.len);
+            debug_assert_eq!(r, 0);
+        }
+    }
+}

src/symbolize/gimli/mmap_windows.rs

@@ -0,0 +1,57 @@
+use crate::windows::*;
+use std::fs::File;
+use std::ops::Deref;
+use std::os::windows::prelude::*;
+use std::ptr;
+use std::slice;
+
+pub struct Mmap {
+    // keep the file alive to prevent it from ebeing deleted which would cause
+    // us to read bad data.
+    _file: File,
+    ptr: *mut c_void,
+    len: usize,
+}
+
+impl Mmap {
+    pub unsafe fn map(file: &File, len: usize) -> Option<Mmap> {
+        let file = file.try_clone().ok()?;
+        let mapping = CreateFileMappingA(
+            file.as_raw_handle() as *mut _,
+            ptr::null_mut(),
+            PAGE_READONLY,
+            0,
+            0,
+            ptr::null(),
+        );
+        if mapping.is_null() {
+            return None;
+        }
+        let ptr = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, len);
+        CloseHandle(mapping);
+        if ptr.is_null() {
+            return None;
+        }
+        Some(Mmap {
+            _file: file,
+            ptr,
+            len,
+        })
+    }
+}
+impl Deref for Mmap {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] {
+        unsafe { slice::from_raw_parts(self.ptr as *const u8, self.len) }
+    }
+}
+
+impl Drop for Mmap {
+    fn drop(&mut self) {
+        unsafe {
+            let r = UnmapViewOfFile(self.ptr);
+            debug_assert!(r != 0);
+        }
+    }
+}

src/windows.rs

@@ -25,14 +25,15 @@ cfg_if::cfg_if! {
             pub use winapi::shared::basetsd::*;
             pub use winapi::shared::minwindef::*;
             pub use winapi::um::dbghelp::*;
+            pub use winapi::um::fileapi::*;
             pub use winapi::um::handleapi::*;
             pub use winapi::um::libloaderapi::*;
+            pub use winapi::um::memoryapi::*;
+            pub use winapi::um::minwinbase::*;
             pub use winapi::um::processthreadsapi::*;
+            pub use winapi::um::synchapi::*;
             pub use winapi::um::winbase::*;
             pub use winapi::um::winnt::*;
-            pub use winapi::um::fileapi::*;
-            pub use winapi::um::minwinbase::*;
-            pub use winapi::um::synchapi::*;
         }
     } else {
         pub use core::ffi::c_void;
@@ -324,6 +325,8 @@ ffi! {
     pub const OPEN_EXISTING: DWORD = 0x3;
     pub const GENERIC_READ: DWORD = 0x80000000;
     pub const INFINITE: DWORD = !0;
+    pub const PAGE_READONLY: DWORD = 2;
+    pub const FILE_MAP_READ: DWORD = 4;
 
     pub type DWORD = u32;
     pub type PDWORD = *mut u32;
@@ -344,6 +347,9 @@ ffi! {
     pub type LPDWORD = *mut DWORD;
     pub type DWORDLONG = u64;
     pub type HMODULE = HINSTANCE;
+    pub type SIZE_T = usize;
+    pub type LPVOID = *mut c_void;
+    pub type LPCVOID = *const c_void;
 
     extern "system" {
         pub fn GetCurrentProcess() -> HANDLE;
@@ -379,6 +385,22 @@ ffi! {
             dwMilliseconds: DWORD,
             bAlertable: BOOL,
         ) -> DWORD;
+        pub fn CreateFileMappingA(
+            hFile: HANDLE,
+            lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
+            flProtect: DWORD,
+            dwMaximumSizeHigh: DWORD,
+            dwMaximumSizeLow: DWORD,
+            lpName: LPCSTR,
+        ) -> HANDLE;
+        pub fn MapViewOfFile(
+            hFileMappingObject: HANDLE,
+            dwDesiredAccess: DWORD,
+            dwFileOffsetHigh: DWORD,
+            dwFileOffsetLow: DWORD,
+            dwNumberOfBytesToMap: SIZE_T,
+        ) -> LPVOID;
+        pub fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL;
     }
 }