From ed36a35dbae6943b2acb4136c6d9d04f23af2af3 Mon Sep 17 00:00:00 2001
From: Joshua Liebow-Feeser <hello@joshlf.com>
Date: Mon, 26 Feb 2018 14:38:43 -0800
Subject: [PATCH] elfmalloc: Bubble up OOM errors, remove unnecessary internal
 code

- Make many internal methods return Option<T> rather than T and
  return None on OOM
- Remove CoarseAllocator::backing_memory and replace it with
  page_size (which was all the former method was ever being used
  for)
---
 elfmalloc/CHANGELOG.md      |   6 +-
 elfmalloc/Cargo.toml        |   4 +-
 elfmalloc/src/alloc_impl.rs |  16 ++--
 elfmalloc/src/bin/bench.rs  |   7 +-
 elfmalloc/src/frontends.rs  | 159 ++++++++++++++++++-----------------
 elfmalloc/src/general.rs    | 163 ++++++++++++++++++------------------
 elfmalloc/src/rust_alloc.rs |  52 ++++++------
 elfmalloc/src/slag.rs       | 103 ++++++++++-------------
 elfmalloc/src/sources.rs    |  39 +++++----
 elfmalloc/src/utils.rs      |  32 ++++---
 elfmalloc/travis.sh         |   4 +-
 11 files changed, 286 insertions(+), 299 deletions(-)

diff --git a/elfmalloc/CHANGELOG.md b/elfmalloc/CHANGELOG.md
index 0238fa4..605d5fe 100644
--- a/elfmalloc/CHANGELOG.md
+++ b/elfmalloc/CHANGELOG.md
@@ -1,4 +1,4 @@
-<!-- Copyright 2017 the authors. See the 'Copyright and license' section of the
+<!-- Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 README.md file at the top-level directory of this repository.
 
 Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -25,6 +25,10 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/).
   `MagazineCache`
 - Added `c-api` feature to optimize for the C malloc API
 
+### Changed
+- Changed error reporting so that more OOM errors are bubbled up and result
+  in top-level errors rather than panics
+
 ### Fixed
 - Fixed a bug preventing non-nightly builds from compiling
 - Fixed an integer multiplication overflow bug
diff --git a/elfmalloc/Cargo.toml b/elfmalloc/Cargo.toml
index 3d33cca..48b7d3a 100644
--- a/elfmalloc/Cargo.toml
+++ b/elfmalloc/Cargo.toml
@@ -1,4 +1,4 @@
-# Copyright 2017 the authors. See the 'Copyright and license' section of the
+# Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 # README.md file at the top-level directory of this repository.
 #
 # Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -49,7 +49,7 @@ alloc-fmt = { path = "../alloc-fmt" }
 alloc-tls = { path = "../alloc-tls" }
 bagpipe = { path = "../bagpipe" }
 bsalloc = "0.1.0"
-lazy_static = "1.0.0"
+lazy_static = { version = "1.0.0", features = ["spin_no_std"] }
 libc = "0.2"
 log = "0.3.8"
 malloc-bind = { path = "../malloc-bind" }
diff --git a/elfmalloc/src/alloc_impl.rs b/elfmalloc/src/alloc_impl.rs
index 53be8df..7092fcc 100644
--- a/elfmalloc/src/alloc_impl.rs
+++ b/elfmalloc/src/alloc_impl.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -25,6 +25,8 @@ use super::general::global;
 use std::mem;
 #[cfg(feature = "c-api")]
 use std::intrinsics::unlikely;
+#[cfg(feature = "c-api")]
+use std::ptr;
 
 #[cfg(feature = "c-api")]
 use self::libc::{size_t, c_void};
@@ -39,10 +41,10 @@ unsafe impl<'a> Alloc for &'a ElfMallocGlobal {
         // two up to 1MiB are aligned to their size. Past that size, only page-alignment is
         // guaranteed.
         if l.size().is_power_of_two() || l.align() <= mem::size_of::<usize>() {
-            Ok(global::alloc(l.size()))
+            global::alloc(l.size())
         } else {
-            Ok(global::alloc(l.size().next_power_of_two()))
-        }
+            global::alloc(l.size().next_power_of_two())
+        }.ok_or(AllocErr::Exhausted { request: l })
     }
 
     unsafe fn dealloc(&mut self, p: *mut u8, _l: Layout) {
@@ -50,14 +52,14 @@ unsafe impl<'a> Alloc for &'a ElfMallocGlobal {
     }
 
     unsafe fn realloc(&mut self, p: *mut u8, _l1: Layout, l2: Layout) -> Result<*mut u8, AllocErr> {
-        Ok(global::aligned_realloc(p, l2.size(), l2.align()))
+        global::aligned_realloc(p, l2.size(), l2.align()).ok_or(AllocErr::Exhausted { request: l2 })
     }
 }
 
 #[cfg(feature = "c-api")]
 unsafe impl Malloc for ElfMallocGlobal {
     unsafe fn c_malloc(&self, size: size_t) -> *mut c_void {
-        let p = global::alloc(size as usize) as *mut c_void;
+        let p = global::alloc(size as usize).unwrap_or(ptr::null_mut()) as *mut c_void;
         alloc_debug_assert_eq!((p as usize) % MIN_ALIGN,
                          0,
                          "object does not have the required alignment of {}: {:?}",
@@ -82,7 +84,7 @@ unsafe impl Malloc for ElfMallocGlobal {
                          "object does not have the required alignment of {}: {:?}",
                          MIN_ALIGN,
                          p);
-        global::realloc(p as *mut u8, new_size as usize) as *mut c_void
+        global::realloc(p as *mut u8, new_size as usize).unwrap_or(ptr::null_mut()) as *mut c_void
     }
 }
 
diff --git a/elfmalloc/src/bin/bench.rs b/elfmalloc/src/bin/bench.rs
index fe8a004..2ffd520 100644
--- a/elfmalloc/src/bin/bench.rs
+++ b/elfmalloc/src/bin/bench.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -101,11 +101,12 @@ unsafe impl<T> Send for ElfClone<T> {}
 impl<T: 'static> AllocLike for ElfClone<T> {
     type Item = T;
     fn create() -> Self {
-        ElfClone(DynamicAllocator::new(), marker::PhantomData)
+        ElfClone(DynamicAllocator::new().unwrap(), marker::PhantomData)
     }
 
     unsafe fn allocate(&mut self) -> *mut T {
-        self.0.alloc(mem::size_of::<T>()) as *mut T
+        // TODO: Do something other than unwrap?
+        self.0.alloc(mem::size_of::<T>()).unwrap() as *mut T
     }
 
     unsafe fn deallocate(&mut self, item: *mut T) {
diff --git a/elfmalloc/src/frontends.rs b/elfmalloc/src/frontends.rs
index 63b99b3..5b2c4e7 100644
--- a/elfmalloc/src/frontends.rs
+++ b/elfmalloc/src/frontends.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -22,7 +22,7 @@ use std::ptr;
 use std::cmp;
 
 pub trait Frontend: LazyInitializable + Clone {
-    unsafe fn alloc(&mut self) -> *mut u8;
+    unsafe fn alloc(&mut self) -> Option<*mut u8>;
     unsafe fn free(&mut self, item: *mut u8);
 }
 
@@ -57,20 +57,20 @@ impl<CA: CoarseAllocator> Drop for LocalCache<CA> {
 }
 impl<CA: CoarseAllocator> Clone for LocalCache<CA> {
     fn clone(&self) -> LocalCache<CA> {
-        LocalCache::new(self.alloc.clone())
+        LocalCache::new(self.alloc.clone()).expect("failed to allocate new LocalCache")
     }
 }
 
 impl<CA: CoarseAllocator> LocalCache<CA> {
-    fn new(mut alloc: SlagAllocator<CA>) -> Self {
+    fn new(mut alloc: SlagAllocator<CA>) -> Option<Self> {
         unsafe {
-            let stack = PtrStack::new((*alloc.m).n_objects);
-            let iter = alloc.refresh();
-            LocalCache {
+            let stack = PtrStack::new((*alloc.m).n_objects)?;
+            let iter = alloc.refresh()?;
+            Some(LocalCache {
                 alloc: alloc,
                 vals: stack,
                 iter: iter,
-            }
+            })
         }
     }
 }
@@ -84,14 +84,14 @@ impl<CA: CoarseAllocator> Frontend for LocalCache<CA> {
         }
     }
 
-    unsafe fn alloc(&mut self) -> *mut u8 {
+    unsafe fn alloc(&mut self) -> Option<*mut u8> {
         self.vals
             .pop()
             .or_else(|| self.iter.next())
-            .unwrap_or_else(|| {
-                let next_iter = self.alloc.refresh();
+            .or_else(|| {
+                let next_iter = self.alloc.refresh()?;
                 self.iter = next_iter;
-                self.iter.next().expect("New iterator should have values")
+                Some(self.iter.next().expect("New iterator should have values"))
             })
     }
 }
@@ -115,16 +115,16 @@ pub struct MagazineCache<CA: CoarseAllocator> {
 
 impl<CA: CoarseAllocator> LazyInitializable for MagazineCache<CA> {
     type Params = (*mut Metadata, usize, CA, RevocablePipe<Slag>);
-    fn init(&(meta, decommit, ref page_alloc, ref avail): &Self::Params) -> Self {
-        let salloc = SlagAllocator::partial_new(meta, decommit, page_alloc.clone(), avail.clone());
+    fn init(&(meta, decommit, ref page_alloc, ref avail): &Self::Params) -> Option<Self> {
+        let salloc = SlagAllocator::partial_new(meta, decommit, page_alloc.clone(), avail.clone())?;
         Self::new(salloc)
     }
 }
 
 impl<CA: CoarseAllocator> LazyInitializable for LocalCache<CA> {
     type Params = (*mut Metadata, usize, CA, RevocablePipe<Slag>);
-    fn init(&(meta, decommit, ref page_alloc, ref avail): &Self::Params) -> Self {
-        let salloc = SlagAllocator::partial_new(meta, decommit, page_alloc.clone(), avail.clone());
+    fn init(&(meta, decommit, ref page_alloc, ref avail): &Self::Params) -> Option<Self> {
+        let salloc = SlagAllocator::partial_new(meta, decommit, page_alloc.clone(), avail.clone())?;
         Self::new(salloc)
     }
 }
@@ -148,26 +148,26 @@ impl<CA: CoarseAllocator> Drop for MagazineCache<CA> {
 
 impl<CA: CoarseAllocator> Clone for MagazineCache<CA> {
     fn clone(&self) -> Self {
-        MagazineCache::new_sized(self.alloc.clone(), self.stack_size)
+        MagazineCache::new_sized(self.alloc.clone(), self.stack_size).expect("failed to allocate new MagazineCache")
     }
 }
 
 impl<CA: CoarseAllocator> MagazineCache<CA> {
-    pub fn new_sized(mut alloc: SlagAllocator<CA>, magazine_size: usize) -> Self {
+    pub fn new_sized(mut alloc: SlagAllocator<CA>, magazine_size: usize) -> Option<Self> {
         alloc_assert!(magazine_size > 0);
-        let s = PtrStack::new(magazine_size);
-        let iter = unsafe { alloc.refresh() };
-        let buckets = Coalescer::new(magazine_size * 2);
-        MagazineCache {
+        let s = PtrStack::new(magazine_size)?;
+        let iter = unsafe { alloc.refresh()? };
+        let buckets = Coalescer::new(magazine_size * 2)?;
+        Some(MagazineCache {
             stack_size: magazine_size,
             s: s,
             iter: iter,
             alloc: alloc,
             coalescer: buckets,
-        }
+        })
     }
 
-    pub fn new(alloc: SlagAllocator<CA>) -> Self {
+    pub fn new(alloc: SlagAllocator<CA>) -> Option<Self> {
         use std::cmp;
         let object_size = unsafe { (*alloc.m).object_size };
         const CUTOFF: usize = 32 << 10;
@@ -183,11 +183,11 @@ impl<CA: CoarseAllocator> MagazineCache<CA> {
     ///
     /// This amounts to getting memory from the current alloc iterator. If the iterator is
     /// exhausted, a new `Slag` is acquired.
-    unsafe fn slag_alloc(&mut self) -> *mut u8 {
+    unsafe fn slag_alloc(&mut self) -> Option<*mut u8> {
         for _ in 0..2 {
             match self.iter.next() {
-                Some(ptr) => return ptr,
-                None => self.iter = self.alloc.refresh(),
+                Some(ptr) => return Some(ptr),
+                None => self.iter = self.alloc.refresh()?,
             }
         }
         alloc_panic!(
@@ -225,10 +225,10 @@ impl<CA: CoarseAllocator> MagazineCache<CA> {
 }
 
 impl<CA: CoarseAllocator> Frontend for MagazineCache<CA> {
-    unsafe fn alloc(&mut self) -> *mut u8 {
+    unsafe fn alloc(&mut self) -> Option<*mut u8> {
         if let Some(ptr) = self.s.pop() {
             trace_event!(cache_alloc);
-            ptr
+            Some(ptr)
         } else {
             trace_event!(slag_alloc);
             self.slag_alloc()
@@ -275,11 +275,11 @@ impl Default for RemoteFreeCell {
 }
 
 impl Coalescer {
-    fn new(size: usize) -> Self {
-        Coalescer(
-            OwnedArray::new(size.next_power_of_two()),
-            PtrStack::new(size),
-        )
+    fn new(size: usize) -> Option<Self> {
+        Some(Coalescer(
+            OwnedArray::new(size.next_power_of_two())?,
+            PtrStack::new(size)?,
+        ))
     }
 
     fn bucket_num(&self, word: usize) -> usize {
@@ -345,11 +345,11 @@ struct PtrStack {
 }
 
 impl PtrStack {
-    fn new(max_objects: usize) -> PtrStack {
-        PtrStack {
-            data: OwnedArray::new(max_objects),
+    fn new(max_objects: usize) -> Option<PtrStack> {
+        Some(PtrStack {
+            data: OwnedArray::new(max_objects)?,
             top: 0,
-        }
+        })
     }
 
     unsafe fn push(&mut self, item: *mut u8) {
@@ -436,7 +436,7 @@ mod magazine {
     }
 
     impl Magazine {
-        unsafe fn new(size: usize) -> *mut Magazine {
+        unsafe fn new(size: usize) -> Option<*mut Magazine> {
             let page_size = mmap::page_size();
             alloc_debug_assert!(page_size.is_power_of_two());
             let bytes = mem::size_of::<Magazine>() + mem::size_of::<*mut u8>() * size;
@@ -444,7 +444,7 @@ mod magazine {
             let n_pages = (bytes >> page_size.trailing_zeros()) + cmp::min(1, rem);
             let region_size = n_pages * page_size;
             alloc_debug_assert!(bytes <= region_size);
-            let mem = mmap::map(region_size) as *mut Magazine;
+            let mem = mmap::map(region_size)? as *mut Magazine;
             ptr::write(
                 mem,
                 Magazine {
@@ -454,12 +454,11 @@ mod magazine {
                     base: mem.offset(1) as *mut u8,
                 },
             );
-            mem
+            Some(mem)
         }
 
-        unsafe fn default() -> *mut Magazine {
-            let res = Magazine::new(3068);
-            res
+        unsafe fn default() -> Option<*mut Magazine> {
+            Magazine::new(3068)
         }
 
         /// Unmap the memory associated with the `Magazine`.
@@ -582,15 +581,15 @@ mod magazine {
 
         /// Allocate a full `Magazine` from the `Depot`, constructing a new one if none are
         /// present.
-        fn alloc_empty(&mut self) -> *mut Magazine {
-            let res = self.empty.pop_mut().unwrap_or_else(|| {
+        fn alloc_empty(&mut self) -> Option<*mut Magazine> {
+            let res = self.empty.pop_mut().or_else(|| {
                 unsafe {
                     Magazine::default()
                 }
             });
-            unsafe {
-                alloc_debug_assert_eq!((*res).top, 0)
-            };
+            if let Some(res) = res {
+                unsafe { alloc_debug_assert_eq!((*res).top, 0) };
+            }
             res
         }
 
@@ -611,7 +610,7 @@ mod magazine {
         /// If the `Depot` is at capacity, `None` is returned and `m` is not freed.
         fn swap_full(&mut self, m: *mut Magazine) -> Option<*mut Magazine> {
             if self.free_full(m) {
-                Some(self.alloc_empty())
+                self.alloc_empty()
             } else {
                 None
             }
@@ -631,32 +630,32 @@ mod magazine {
 
     impl<FE: Frontend> LazyInitializable for DepotCache<FE> {
         type Params = (FE::Params, Depot);
-        fn init(&(ref backing, ref depot): &(FE::Params, Depot)) -> DepotCache<FE> {
-            Self::new(FE::init(backing.clone()), depot.clone())
+        fn init(&(ref backing, ref depot): &(FE::Params, Depot)) -> Option<DepotCache<FE>> {
+            Self::new(FE::init(backing.clone())?, depot.clone())
         }
     }
 
     impl<FE: Frontend> DepotCache<FE> {
-        fn new(backing: FE, mut depot: Depot) -> DepotCache<FE> {
-            let m1 = depot.alloc_full().unwrap_or_else(|| depot.alloc_empty());
-            let m2 = depot.alloc_empty();
-            DepotCache {
+        fn new(backing: FE, mut depot: Depot) -> Option<DepotCache<FE>> {
+            let m1 = depot.alloc_full().or_else(|| depot.alloc_empty())?;
+            let m2 = depot.alloc_empty()?;
+            Some(DepotCache {
                 backing: backing,
                 depot: depot,
                 m1: m1,
                 m2: m2,
-            }
+            })
         }
     }
 
     impl<FE: Frontend> Frontend for DepotCache<FE> {
-        unsafe fn alloc(&mut self) -> *mut u8 {
+        unsafe fn alloc(&mut self) -> Option<*mut u8> {
             if let Some(p) = (*self.m1).pop() {
-                return p;
+                return Some(p);
             }
             mem::swap(&mut self.m1, &mut self.m2);
             if let Some(p) = (*self.m1).pop() {
-                return p;
+                return Some(p);
             }
 
             if let Some(m) = self.depot.swap_empty(self.m1) {
@@ -664,11 +663,11 @@ mod magazine {
             } else {
                 let cap = (*self.m1).cap;
                 for _ in 0..cap {
-                    let _r = (*self.m1).push(self.backing.alloc());
+                    let _r = (*self.m1).push(self.backing.alloc()?);
                     alloc_debug_assert!(_r);
                 }
             }
-            (*self.m1).pop().expect("new full magazine is empty")
+            Some((*self.m1).pop().expect("new full magazine is empty"))
         }
 
         unsafe fn free(&mut self, item: *mut u8) {
@@ -700,7 +699,7 @@ mod magazine {
         #[test]
         fn magazine_stack() {
             unsafe {
-                let m = Magazine::default();
+                let m = Magazine::default().unwrap();
                 let m_ref = &mut*m;
                 let goal = m_ref.cap;
                 // start at 1 because we debug_assert that the pointer is non-null
@@ -770,7 +769,7 @@ impl<T> AllocBuilder<T> {
     }
 
     /// Build a `LocalAllocator<T>` from the current configuration.
-    pub fn build_local(&self) -> LocalAllocator<T> {
+    pub fn build_local(&self) -> Option<LocalAllocator<T>> {
         LocalAllocator::new_standalone(
             self.cutoff_factor,
             self.page_size,
@@ -781,7 +780,7 @@ impl<T> AllocBuilder<T> {
     }
 
     /// Build a `MagazineAllocator<T>` from the current configuration.
-    pub fn build_magazine(&self) -> MagazineAllocator<T> {
+    pub fn build_magazine(&self) -> Option<MagazineAllocator<T>> {
         MagazineAllocator::new_standalone(
             self.cutoff_factor,
             self.page_size,
@@ -807,15 +806,15 @@ macro_rules! typed_wrapper {
                                   target_overhead: usize,
                                   eager_decommit: usize,
                                   max_objects: usize)
-                -> Self {
-                    let pa = PageAlloc::new(page_size, target_overhead, 8, AllocType::SmallSlag);
+                -> Option<Self> {
+                    let pa = PageAlloc::new(page_size, target_overhead, 8, AllocType::SmallSlag)?;
                     let slag = SlagAllocator::new(max_objects, mem::size_of::<T>(), 0,
-                                                  cutoff_factor, eager_decommit, pa);
-                    $name($wrapped::new(slag), PhantomData)
+                                                  cutoff_factor, eager_decommit, pa)?;
+                    Some($name($wrapped::new(slag)?, PhantomData))
                 }
 
-            pub unsafe fn alloc(&mut self) -> *mut T {
-                self.0.alloc() as *mut T
+            pub unsafe fn alloc(&mut self) -> Option<*mut T> {
+                self.0.alloc().map(|ptr| ptr as *mut T)
             }
 
             pub unsafe fn free(&mut self, item: *mut T) {
@@ -842,9 +841,10 @@ mod tests {
         let _ = env_logger::init();
         let mut oa = AllocBuilder::<usize>::default()
             .page_size(4096)
-            .build_local();
+            .build_local()
+            .unwrap();
         unsafe {
-            let item = oa.alloc();
+            let item = oa.alloc().unwrap();
             write_volatile(item, 10);
             oa.free(item);
         }
@@ -868,12 +868,12 @@ mod tests {
     fn obj_alloc_many_pages_single_threaded<T: 'static>() {
         let _ = env_logger::init();
         const N_ITEMS: usize = 4096 * 20;
-        let mut oa = AllocBuilder::<T>::default().page_size(4096).build_local();
+        let mut oa = AllocBuilder::<T>::default().page_size(4096).build_local().unwrap();
         alloc_assert!(mem::size_of::<T>() >= mem::size_of::<usize>());
         // stay in a local cache
         for _ in 0..N_ITEMS {
             unsafe {
-                let item = oa.alloc();
+                let item = oa.alloc().unwrap();
                 write_volatile(item as *mut usize, 10);
                 oa.free(item);
             }
@@ -883,7 +883,7 @@ mod tests {
         let mut h = HashSet::new();
         for i in 0..N_ITEMS {
             unsafe {
-                let item = oa.alloc();
+                let item = oa.alloc().unwrap();
                 write_volatile(item as *mut usize, i + 1);
                 v.push(item);
                 let item_num = item as usize;
@@ -921,7 +921,8 @@ mod tests {
         // TODO make macros for these tests and test both MagazineAllocator and LocalAllocator
         let oa = AllocBuilder::<T>::default()
             .page_size(4096)
-            .build_magazine();
+            .build_magazine()
+            .unwrap();
         // stay in a local cache
         alloc_assert!(mem::size_of::<T>() >= mem::size_of::<usize>());
         let mut threads = Vec::new();
@@ -930,7 +931,7 @@ mod tests {
             threads.push(thread::spawn(move || {
                 for _ in 0..N_ITEMS {
                     unsafe {
-                        let item = my_alloc.alloc();
+                        let item = my_alloc.alloc().unwrap();
                         write_volatile(item as *mut usize, 10);
                         my_alloc.free(item);
                     }
@@ -940,7 +941,7 @@ mod tests {
                 let mut h = HashSet::new();
                 for i in 0..N_ITEMS {
                     unsafe {
-                        let item = my_alloc.alloc();
+                        let item = my_alloc.alloc().unwrap();
                         write_volatile(item as *mut usize, i);
                         v.push(item);
                         let item_num = item as usize;
diff --git a/elfmalloc/src/general.rs b/elfmalloc/src/general.rs
index 56cb6a2..c2f6207 100644
--- a/elfmalloc/src/general.rs
+++ b/elfmalloc/src/general.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -156,8 +156,8 @@ pub(crate) mod global {
     // methods.
     unsafe impl Sync for GlobalAllocProvider {}
     impl GlobalAllocProvider {
-        fn new() -> GlobalAllocProvider {
-            GlobalAllocProvider { inner: Some(ElfMalloc::new()) }
+        fn new() -> Option<GlobalAllocProvider> {
+            Some(GlobalAllocProvider { inner: Some(ElfMalloc::new()?) })
         }
     }
 
@@ -210,14 +210,14 @@ pub(crate) mod global {
     }
 
     pub unsafe fn get_layout(item: *mut u8) -> (usize /* size */, usize /* alignment */) {
-        let m_block = match get_type(item) {
+        let page_size = match get_type(item) {
             // TODO(ezrosent): this duplicates some work..
             AllocType::SmallSlag | AllocType::Large => {
                 with_local_or_clone(|h| {
                     (*h.get())
                         .alloc
                         .small_pages
-                        .backing_memory()
+                        .page_size()
                 })
             }
             AllocType::BigSlag => {
@@ -225,11 +225,11 @@ pub(crate) mod global {
                     (*h.get())
                         .alloc
                         .large_pages
-                        .backing_memory()
+                        .page_size()
                 })
             }
         };
-        super::elfmalloc_get_layout(m_block, item)
+        super::elfmalloc_get_layout(page_size, item)
     }
 
     fn new_handle() -> GlobalAllocator {
@@ -246,7 +246,7 @@ pub(crate) mod global {
     }
 
     lazy_static! {
-        static ref ELF_HEAP: GlobalAllocProvider = GlobalAllocProvider::new();
+        static ref ELF_HEAP: GlobalAllocProvider = GlobalAllocProvider::new().expect("could not create heap");
         static ref DESTRUCTOR_CHAN: Mutex<Sender<Husk>> = {
             // Background thread code: block on a channel waiting for memory reclamation messages
             // (Husks).
@@ -283,16 +283,16 @@ pub(crate) mod global {
         }
     }
 
-    pub unsafe fn alloc(size: usize) -> *mut u8 {
+    pub unsafe fn alloc(size: usize) -> Option<*mut u8> {
         alloc_tls_fast_with!(LOCAL_ELF_HEAP, h, { (*h.get()).alloc.alloc(size) })
             .unwrap_or_else(|| super::large_alloc::alloc(size))
     }
 
-    pub unsafe fn realloc(item: *mut u8, new_size: usize) -> *mut u8 {
+    pub unsafe fn realloc(item: *mut u8, new_size: usize) -> Option<*mut u8> {
         aligned_realloc(item, new_size, mem::size_of::<usize>())
     }
 
-    pub unsafe fn aligned_realloc(item: *mut u8, new_size: usize, new_alignment: usize) -> *mut u8 {
+    pub unsafe fn aligned_realloc(item: *mut u8, new_size: usize, new_alignment: usize) -> Option<*mut u8> {
         with_local_or_clone(|h| (*h.get()).alloc.realloc(item, new_size, new_alignment))
     }
 
@@ -319,8 +319,8 @@ where
     type Key;
 
     /// Create and initialize the map.
-    fn init<F: FnMut(Self::Key) -> T>(start: Self::Key, n_classes: usize, f: F) -> Self {
-        Self::init_conserve(start, n_classes, f).1
+    fn init<F: FnMut(Self::Key) -> T>(start: Self::Key, n_classes: usize, f: F) -> Option<Self> {
+        Some(Self::init_conserve(start, n_classes, f)?.1)
     }
 
     /// Create and initialize the map, handing back ownership of the constructor.
@@ -328,7 +328,7 @@ where
         start: Self::Key,
         n_classes: usize,
         f: F,
-    ) -> (F, Self);
+    ) -> Option<(F, Self)>;
 
     /// Get an unchecked raw pointer to the class corresponding to `k`.
     unsafe fn get_raw(&self, k: Self::Key) -> *mut T;
@@ -384,19 +384,19 @@ struct TieredSizeClasses<T> {
 
 impl<T> AllocMap<T> for TieredSizeClasses<T> {
     type Key = usize;
-    fn init_conserve<F: FnMut(usize) -> T>(start: usize, n_classes: usize, f: F) -> (F, Self) {
+    fn init_conserve<F: FnMut(usize) -> T>(start: usize, n_classes: usize, f: F) -> Option<(F, Self)> {
         let n_small_classes = cmp::min((ELFMALLOC_SMALL_CUTOFF / MULTIPLE) - (start / MULTIPLE), n_classes / 2);
         let n_medium_classes = n_classes - n_small_classes;
-        let (f2, small_classes) = Multiples::init_conserve(start, n_small_classes, f);
+        let (f2, small_classes) = Multiples::init_conserve(start, n_small_classes, f)?;
         // mutability is unnecessary when we don't execute the 'let word_objs = f3(8)' line
         #[allow(unused_mut)]
         let (mut f3, medium_classes) =
-            PowersOfTwo::init_conserve(small_classes.max_key() + 1, n_medium_classes, f2);
+            PowersOfTwo::init_conserve(small_classes.max_key() + 1, n_medium_classes, f2)?;
         #[cfg(any(not(feature = "c-api"),
                     not(any(target_os = "macos",
                                 all(windows, target_pointer_width = "64")))))]
         let word_objs = f3(8);
-        (
+        Some((
             f3,
             TieredSizeClasses {
                 // When compiling for the C API, the minimum alignment is 16 on Mac and 64-bit Windows.
@@ -407,7 +407,7 @@ impl<T> AllocMap<T> for TieredSizeClasses<T> {
                 small_objs: small_classes,
                 medium_objs: medium_classes,
             },
-        )
+        ))
     }
 
     unsafe fn get_raw(&self, n: usize) -> *mut T {
@@ -469,7 +469,7 @@ impl<T: Clone> Clone for Multiples<T> {
     fn clone(&self) -> Self {
         Multiples::init(self.starting_size, self.classes.len(), |size| unsafe {
             self.get(size).clone()
-        })
+        }).expect("could not initialize Multiples")
     }
 }
 
@@ -481,13 +481,13 @@ fn round_up(n: usize) -> usize {
 
 impl<T> AllocMap<T> for Multiples<T> {
     type Key = usize;
-    fn init_conserve<F: FnMut(usize) -> T>(start: usize, n_classes: usize, mut f: F) -> (F, Self) {
+    fn init_conserve<F: FnMut(usize) -> T>(start: usize, n_classes: usize, mut f: F) -> Option<(F, Self)> {
         alloc_debug_assert!(n_classes >= 1);
         let starting_size = round_up(start);
         let res = Multiples {
             starting_size: starting_size,
             max_size: n_classes * MULTIPLE + starting_size - MULTIPLE,
-            classes: TypedArray::new(n_classes),
+            classes: TypedArray::new(n_classes)?,
         };
         let mut cur_size = res.starting_size;
         for p in res.classes.iter() {
@@ -497,7 +497,7 @@ impl<T> AllocMap<T> for Multiples<T> {
             cur_size += MULTIPLE;
         }
         alloc_debug_assert_eq!(res.max_size, cur_size - MULTIPLE);
-        (f, res)
+        Some((f, res))
     }
 
     #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
@@ -536,7 +536,7 @@ impl<T: Clone> Clone for PowersOfTwo<T> {
     fn clone(&self) -> Self {
         PowersOfTwo::init(self.starting_size, self.classes.len(), |size| unsafe {
             self.get(size).clone()
-        })
+        }).expect("failed to initialize PowersOfTwo")
     }
 }
 
@@ -555,12 +555,12 @@ impl Drop for DynamicAllocator {
 }
 
 impl<T> PowersOfTwo<T> {
-    fn new(start_from: usize, n_classes: usize) -> PowersOfTwo<T> {
-        PowersOfTwo {
+    fn new(start_from: usize, n_classes: usize) -> Option<PowersOfTwo<T>> {
+        Some(PowersOfTwo {
             starting_size: start_from.next_power_of_two(),
             max_size: 0, // currently uninitialized
-            classes: TypedArray::new(n_classes),
-        }
+            classes: TypedArray::new(n_classes)?,
+        })
     }
 }
 
@@ -570,8 +570,8 @@ impl<T> AllocMap<T> for PowersOfTwo<T> {
         start: usize,
         n_classes: usize,
         mut f: F,
-    ) -> (F, Self) {
-        let mut res = Self::new(start, n_classes);
+    ) -> Option<(F, Self)> {
+        let mut res = Self::new(start, n_classes)?;
         let mut cur_size = res.starting_size;
         unsafe {
             for item in res.classes.iter() {
@@ -580,7 +580,7 @@ impl<T> AllocMap<T> for PowersOfTwo<T> {
             }
         }
         res.max_size = cur_size / 2;
-        (f, res)
+        Some((f, res))
     }
 
     #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
@@ -617,17 +617,17 @@ pub struct DynamicAllocator(ElfMalloc<PageAlloc<Source>, TieredSizeClasses<Objec
 unsafe impl Send for DynamicAllocator {}
 
 impl DynamicAllocator {
-    pub fn new() -> Self {
-        DynamicAllocator(ElfMalloc::new())
+    pub fn new() -> Option<Self> {
+        Some(DynamicAllocator(ElfMalloc::new()?))
     }
-    pub unsafe fn alloc(&mut self, size: usize) -> *mut u8 {
+    pub unsafe fn alloc(&mut self, size: usize) -> Option<*mut u8> {
         self.0.alloc(size)
     }
     pub unsafe fn free(&mut self, item: *mut u8) {
         self.0.free(item)
     }
 
-    pub unsafe fn realloc(&mut self, item: *mut u8, new_size: usize) -> *mut u8 {
+    pub unsafe fn realloc(&mut self, item: *mut u8, new_size: usize) -> Option<*mut u8> {
         self.0.realloc(item, new_size, mem::size_of::<usize>())
     }
 
@@ -636,7 +636,7 @@ impl DynamicAllocator {
         item: *mut u8,
         new_size: usize,
         new_alignment: usize,
-    ) -> *mut u8 {
+    ) -> Option<*mut u8> {
         self.0.realloc(item, new_size, new_alignment)
     }
 }
@@ -678,7 +678,7 @@ struct ElfMalloc<CA: CoarseAllocator, AM: AllocMap<ObjectAlloc<CA>>> {
 
 impl Default for DynamicAllocator {
     fn default() -> Self {
-        Self::new()
+        Self::new().expect("could not create new DynamicAllocator")
     }
 }
 
@@ -689,8 +689,8 @@ const ELFMALLOC_SMALL_CUTOFF: usize = ELFMALLOC_SMALL_PAGE_SIZE / 4;
 
 impl<M: MemorySource, D: DirtyFn>
     ElfMalloc<PageAlloc<M, D>, TieredSizeClasses<ObjectAlloc<PageAlloc<M, D>>>> {
-    fn new() -> Self {
-        let pa_large = PageAlloc::new(ELFMALLOC_PAGE_SIZE, 1 << 20, 8, AllocType::BigSlag);
+    fn new() -> Option<Self> {
+        let pa_large = PageAlloc::new(ELFMALLOC_PAGE_SIZE, 1 << 20, 8, AllocType::BigSlag)?;
         // The small pages are allocated in groups where the first page is aligned to
         // ELFMALLOC_PAGE_SIZE; this page will be stamped with AllocType::SmallSlag, allowing type
         // lookups to work as expected.
@@ -700,7 +700,7 @@ impl<M: MemorySource, D: DirtyFn>
             8,
             ELFMALLOC_PAGE_SIZE,
             AllocType::SmallSlag,
-        );
+        )?;
         Self::new_internal(0.6, pa_small, pa_large, 8, 25)
     }
 }
@@ -727,7 +727,7 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
     fn clone(&self) -> Self {
         let new_map = AM::init(self.start_from, self.n_classes, |size: usize| unsafe {
             self.allocs.get(size).clone()
-        });
+        }).expect("could not initialize AM");
         ElfMalloc {
             small_pages: self.small_pages.clone(),
             large_pages: self.large_pages.clone(),
@@ -739,10 +739,10 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
     }
 }
 
-unsafe fn elfmalloc_get_layout<M: MemorySource>(m_block: &M, item: *mut u8) -> (usize, usize) {
+unsafe fn elfmalloc_get_layout(page_size: usize, item: *mut u8) -> (usize, usize) {
     match get_type(item) {
         AllocType::SmallSlag | AllocType::BigSlag => {
-            let meta = (*Slag::find(item, m_block.page_size())).get_metadata();
+            let meta = (*Slag::find(item, page_size)).get_metadata();
             (
                 meta.object_size,
                 if meta.object_size.is_power_of_two() {
@@ -765,16 +765,16 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
         pa_large: PageAlloc<M, D>,
         start_from: usize,
         n_classes: usize,
-    ) -> Self {
+    ) -> Option<Self> {
         use self::mmap::map;
-        let mut meta_pointer = map(mem::size_of::<Metadata>() * n_classes) as *mut Metadata;
-        let small_page_size = pa_small.backing_memory().page_size();
+        let mut meta_pointer = map(mem::size_of::<Metadata>() * n_classes)? as *mut Metadata;
+        let small_page_size = pa_small.page_size();
         let am = AM::init(start_from, n_classes, |size: usize| {
             let (u_size, pa, ty) = if size < ELFMALLOC_SMALL_CUTOFF {
                 (small_page_size, pa_small.clone(), AllocType::SmallSlag)
             } else {
                 (
-                    pa_large.backing_memory().page_size(),
+                    pa_large.page_size(),
                     pa_large.clone(),
                     AllocType::BigSlag,
                 )
@@ -786,7 +786,7 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
                     m_ptr,
                     compute_metadata(
                         size,
-                        pa.backing_memory().page_size(),
+                        pa.page_size(),
                         0,
                         cutoff_factor,
                         u_size,
@@ -794,7 +794,7 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
                     ),
                 );
             }
-            let clean = PageCleanup::new(pa.backing_memory().page_size());
+            let clean = PageCleanup::new(pa.page_size());
             // TODO(ezrosent); new_size(8) is a good default, but a better one would take
             // num_cpus::get() into account when picking this size, as in principle this will run
             // into scaling limits at some point.
@@ -812,16 +812,15 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
             {
                 ObjectAlloc::new((params, Depot::default()))
             }
-        });
-        let max_size = am.max_key();
-        ElfMalloc {
+        })?;
+        Some(ElfMalloc {
             small_pages: pa_small.clone(),
             large_pages: pa_large.clone(),
+            max_size: am.max_key(),
             allocs: am,
-            max_size: max_size,
             start_from: start_from,
             n_classes: n_classes,
-        }
+        })
     }
 
     #[inline]
@@ -839,18 +838,18 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
         }
         match get_type(item) {
             AllocType::SmallSlag => {
-                alloc_debug_assert_eq!(self.small_pages.backing_memory().page_size(), ELFMALLOC_SMALL_PAGE_SIZE);
+                alloc_debug_assert_eq!(self.small_pages.page_size(), ELFMALLOC_SMALL_PAGE_SIZE);
                 Some(ELFMALLOC_SMALL_PAGE_SIZE)
             },
             AllocType::BigSlag => {
-                alloc_debug_assert_eq!(self.large_pages.backing_memory().page_size(), ELFMALLOC_PAGE_SIZE);
+                alloc_debug_assert_eq!(self.large_pages.page_size(), ELFMALLOC_PAGE_SIZE);
                 Some(ELFMALLOC_PAGE_SIZE)
             },
             AllocType::Large => None,
         }
     }
 
-    unsafe fn alloc(&mut self, bytes: usize) -> *mut u8 {
+    unsafe fn alloc(&mut self, bytes: usize) -> Option<*mut u8> {
         if likely(bytes <= self.max_size) {
             self.allocs.get_mut(bytes).alloc()
         } else {
@@ -863,7 +862,7 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
         item: *mut u8,
         mut new_size: usize,
         new_alignment: usize,
-    ) -> *mut u8 {
+    ) -> Option<*mut u8> {
         if item.is_null() {
             let alloc_size = if new_alignment <= mem::size_of::<usize>() {
                 new_size
@@ -874,16 +873,16 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
         }
         if new_size == 0 {
             self.free(item);
-            return ptr::null_mut();
+            return None;
         }
         let (old_size, old_alignment) = global::get_layout(item);
         if old_alignment >= new_alignment && old_size >= new_size {
-            return item;
+            return Some(item);
         }
         if new_alignment > mem::size_of::<usize>() {
             new_size = new_size.next_power_of_two();
         }
-        let new_mem = self.alloc(new_size);
+        let new_mem = self.alloc(new_size)?;
         ptr::copy_nonoverlapping(item, new_mem, ::std::cmp::min(old_size, new_size));
         self.free(item);
         #[cfg(debug_assertions)]
@@ -891,7 +890,7 @@ impl<M: MemorySource, D: DirtyFn, AM: AllocMap<ObjectAlloc<PageAlloc<M, D>>, Key
             let (size, _) = global::get_layout(new_mem);
             alloc_debug_assert!(new_size <= size, "Realloc for {} got memory with size {}", new_size, size);
         }
-        new_mem
+        Some(new_mem)
     }
 
     unsafe fn free(&mut self, item: *mut u8) {
@@ -922,6 +921,7 @@ mod large_alloc {
     use super::super::sources::{MemorySource, MmapSource};
     use super::{ELFMALLOC_PAGE_SIZE, ELFMALLOC_SMALL_CUTOFF, round_to_page};
     use super::super::alloc_type::AllocType;
+    use super::mmap;
 
     // For debugging, we keep around a thread-local map of pointers to lengths. This helps us
     // scrutinize if various header data is getting propagated correctly.
@@ -929,9 +929,6 @@ mod large_alloc {
     thread_local! {
         pub static SEEN_PTRS: RefCell<HashMap<*mut u8, usize>> = RefCell::new(HashMap::new());
     }
-    use super::mmap::unmap;
-    #[cfg(debug_assertions)]
-    use super::mmap::page_size;
 
     #[repr(C)]
     #[derive(Copy, Clone)]
@@ -941,12 +938,12 @@ mod large_alloc {
         region_size: usize,
     }
 
-    pub unsafe fn alloc(size: usize) -> *mut u8 {
+    pub unsafe fn alloc(size: usize) -> Option<*mut u8> {
         // TODO(ezrosent) round up to page size
         let region_size = size + ELFMALLOC_PAGE_SIZE;
         // We need a pointer aligned to the SMALL_CUTOFF, so we use an `MmapSource` to map the
         // memory. See the comment in get_page_size.
-        let src = MmapSource::new(ELFMALLOC_SMALL_CUTOFF);
+        let src = MmapSource::new(ELFMALLOC_SMALL_CUTOFF)?;
         let n_pages = region_size / ELFMALLOC_SMALL_CUTOFF + cmp::min(1, region_size % ELFMALLOC_SMALL_CUTOFF);
         let mem = src.carve(n_pages).expect("[lage_alloc::alloc] mmap failed");
         let res = mem.offset(ELFMALLOC_PAGE_SIZE as isize);
@@ -969,7 +966,7 @@ mod large_alloc {
         alloc_debug_assert_eq!(get_commitment(res), (size + ELFMALLOC_PAGE_SIZE, mem));
         #[cfg(test)] SEEN_PTRS.with(|hs| hs.borrow_mut().insert(mem, region_size));
         // end extra debugging information
-        res
+        Some(res)
     }
 
     pub unsafe fn free(item: *mut u8) {
@@ -985,11 +982,11 @@ mod large_alloc {
         {
             ptr::write_volatile(item, 10);
             alloc_debug_assert_eq!(
-                base_ptr as usize % page_size(),
+                base_ptr as usize % mmap::page_size(),
                 0,
                 "base_ptr ({:?}) not a multiple of the page size ({})",
                 base_ptr,
-                page_size()
+                mmap::page_size()
             );
         }
         #[cfg(test)]
@@ -1005,7 +1002,7 @@ mod large_alloc {
             });
         }
         // end extra debugging information
-        unmap(base_ptr, size);
+        mmap::unmap(base_ptr, size);
     }
 
     pub unsafe fn get_size(item: *mut u8) -> usize {
@@ -1036,7 +1033,7 @@ mod tests {
     fn layout_lookup() {
         fn test_and_free<F: Fn(usize, usize)>(inp: usize, tester: F) {
             unsafe {
-                let obj = global::alloc(inp);
+                let obj = global::alloc(inp).unwrap();
                 let (size, align) = global::get_layout(obj);
                 tester(size, align);
                 global::free(obj);
@@ -1065,7 +1062,7 @@ mod tests {
         let _ = env_logger::init();
         for size in ((1 << 13) - 8)..((1 << 13) + 1) {
             unsafe {
-                let item = global::alloc(size * 8);
+                let item = global::alloc(size * 8).unwrap();
                 write_volatile(item, 10);
                 global::free(item);
             }
@@ -1075,11 +1072,11 @@ mod tests {
     #[test]
     fn general_alloc_basic_clone_single_threaded() {
         let _ = env_logger::init();
-        let da_c = DynamicAllocator::new();
+        let da_c = DynamicAllocator::new().unwrap();
         let mut da = da_c.clone();
         for size in ((1 << 13) - 8)..((1 << 13) + 1) {
             unsafe {
-                let item = da.alloc(size * 8);
+                let item = da.alloc(size * 8).unwrap();
                 write_volatile(item, 10);
                 da.free(item);
             }
@@ -1101,7 +1098,7 @@ mod tests {
                         for size in 1..(1 << 13) {
                             // ((1 << 9) + 1)..((1 << 18) + 1) {
                             unsafe {
-                                let item = global::alloc(size * 8);
+                                let item = global::alloc(size * 8).unwrap();
                                 write_volatile(item, 10);
                                 global::free(item);
                             }
@@ -1133,7 +1130,7 @@ mod tests {
                     .spawn(move || unsafe {
                         for _ in 0..2 {
                             let ptrs: Vec<*mut u8> =
-                                (0..(1 << 20)).map(|_| global::alloc(8)).collect();
+                                (0..(1 << 20)).map(|_| global::alloc(8).unwrap()).collect();
                             for p in ptrs {
                                 global::free(p);
                             }
@@ -1153,7 +1150,7 @@ mod tests {
         let _ = env_logger::init();
         use std::thread;
         const N_THREADS: usize = 8;
-        let alloc = DynamicAllocator::new();
+        let alloc = DynamicAllocator::new().unwrap();
         let mut threads = Vec::with_capacity(N_THREADS);
         for t in 0..N_THREADS {
             let mut da = alloc.clone();
@@ -1169,7 +1166,7 @@ mod tests {
                         }
                         unsafe {
                             for _ in 0..N_ITERS {
-                                let item = da.alloc(alloc_size);
+                                let item = da.alloc(alloc_size).unwrap();
                                 write_bytes(item, 0xFF, alloc_size);
                                 v1.push(item);
                             }
@@ -1180,7 +1177,7 @@ mod tests {
                                         8
                                     } else {
                                         (alloc_size * 2).next_power_of_two()
-                                    });
+                                    }).unwrap();
                                 write_bytes(new_item.offset(alloc_size as isize), 0xFE, alloc_size);
                                 da.free(new_item);
                             }
@@ -1199,7 +1196,7 @@ mod tests {
         use std::thread;
 
         const N_THREADS: usize = 32;
-        let alloc = DynamicAllocator::new();
+        let alloc = DynamicAllocator::new().unwrap();
         let mut threads = Vec::with_capacity(N_THREADS);
         for t in 0..N_THREADS {
             let mut da = alloc.clone();
@@ -1210,7 +1207,7 @@ mod tests {
                         for size in 1..(1 << 13) {
                             // ((1 << 9) + 1)..((1 << 18) + 1) {
                             unsafe {
-                                let item = da.alloc(size * 8);
+                                let item = da.alloc(size * 8).unwrap();
                                 write_bytes(item, 0xFF, size * 8);
                                 da.free(item);
                             }
@@ -1233,7 +1230,7 @@ mod tests {
         let _ = env_logger::init();
         for size in 1..((1 << 21) + 1) {
             unsafe {
-                let item = global::alloc(size);
+                let item = global::alloc(size).unwrap();
                 write_volatile(item, 10);
                 global::free(item);
                 if size + 2 > 1 << 20 {
diff --git a/elfmalloc/src/rust_alloc.rs b/elfmalloc/src/rust_alloc.rs
index 3e3bec9..5fd4f93 100644
--- a/elfmalloc/src/rust_alloc.rs
+++ b/elfmalloc/src/rust_alloc.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -110,14 +110,14 @@ impl<M: MemorySource> PageSource<M> {
         target_size: usize,
         pipe_size: usize,
         page_size: usize,
-    ) -> PageSource<M> {
-        let m = M::new(page_size);
-        PageSource {
+    ) -> Option<PageSource<M>> {
+        let m = M::new(page_size)?;
+        Some(PageSource {
             cutoff_bytes: cutoff_bytes,
             target_size: target_size,
             pages: SlagPipe::new_size_cleanup(pipe_size, PageCleanup::new(m.page_size())),
             source: m,
-        }
+        })
     }
 
     unsafe fn free(&mut self, p: *mut u8, old_size: usize) {
@@ -167,15 +167,15 @@ impl<M: MemorySource> PageFrontend<M> {
         max_overhead: usize,
         pipe_size: usize,
         parent: PageSource<M>,
-    ) -> PageFrontend<M> {
+    ) -> Option<PageFrontend<M>> {
         alloc_debug_assert!(size <= parent.source.page_size());
         alloc_debug_assert!(size.is_power_of_two());
-        PageFrontend {
+        Some(PageFrontend {
             parent: parent,
             pages: SlagPipe::new_size_cleanup(pipe_size, PageCleanup::new(size)),
             local_size: size,
             max_overhead: max_overhead,
-        }
+        })
     }
 
     unsafe fn alloc(&mut self) -> Option<*mut u8> {
@@ -195,7 +195,7 @@ impl<M: MemorySource> PageFrontend<M> {
 
 impl<M: MemorySource + Clone> LazyInitializable for PageFrontend<M> {
     type Params = (usize, usize, usize, PageSource<M>);
-    fn init(&(size, max_overhead, pipe_size, ref parent): &Self::Params) -> Self {
+    fn init(&(size, max_overhead, pipe_size, ref parent): &Self::Params) -> Option<Self> {
         PageFrontend::new(size, max_overhead, pipe_size, parent.clone())
     }
 }
@@ -272,20 +272,18 @@ unsafe impl<M: MemorySource> Alloc for ElfMalloc<M> {
         case_analyze!(
             self,
             l,
-            small Ok(
-                self.small
+            small self.small
                     .get_mut(if l.align() > mem::size_of::<usize>() {
                         l.size().next_power_of_two()
                     } else {
                         l.size()
                     })
-                    .alloc(),
-            );
+                    .alloc().ok_or(AllocErr::Exhausted { request: l });
             medium match self.large.get_mut(l.size()).alloc() {
                 Some(p) => Ok(p),
                 None => Err(AllocErr::Exhausted { request: l }),
             };
-            large match mmap::fallible_map(l.size()) {
+            large match mmap::map(l.size()) {
                 Some(p) => Ok(p),
                 None => Err(AllocErr::Exhausted { request: l }),
             };
@@ -397,11 +395,11 @@ impl ElfMallocBuilder {
         self
     }
 
-    pub fn build<M: MemorySource>(&self) -> ElfMalloc<M> {
-        let pa = PageAlloc::<M>::new(self.page_size, self.target_pa_size, self.large_pipe_size, AllocType::SmallSlag);
+    pub fn build<M: MemorySource>(&self) -> Option<ElfMalloc<M>> {
+        let pa = PageAlloc::<M>::new(self.page_size, self.target_pa_size, self.large_pipe_size, AllocType::SmallSlag)?;
         let n_small_classes = (self.page_size / 4) / MULTIPLE;
         alloc_assert!(n_small_classes > 0);
-        let mut meta_pointers = mmap::map(mem::size_of::<Metadata>() * n_small_classes) as
+        let mut meta_pointers = mmap::map(mem::size_of::<Metadata>() * n_small_classes)? as
             *mut Metadata;
         let small_classes = Multiples::init(MULTIPLE, n_small_classes, |size: usize| {
             let meta = meta_pointers;
@@ -433,7 +431,7 @@ impl ElfMallocBuilder {
             {
                 ObjectAlloc::new((params, Depot::default()))
             }
-        });
+        })?;
         let next_size_class = (small_classes.max_key() + 1).next_power_of_two();
         let max_size = self.max_object_size.next_power_of_two();
         let n_classes = max_size.trailing_zeros() - next_size_class.trailing_zeros();
@@ -442,22 +440,22 @@ impl ElfMallocBuilder {
             self.large_obj_target_size,
             self.large_pipe_size,
             max_size,
-        );
+        )?;
         let large_classes = PowersOfTwo::init(next_size_class, n_classes as usize, |size: usize| {
             let target_size: usize = cmp::max(1, self.target_pipe_overhead / size);
             Lazy::<PageFrontend<M>>::new(
                 (size, target_size, self.small_pipe_size, p_source.clone()),
             )
-        });
+        })?;
         alloc_debug_assert!(small_classes.max_key().is_power_of_two());
-        ElfMalloc {
+        Some(ElfMalloc {
             small: small_classes,
             large: large_classes,
-        }
+        })
     }
 
-    pub fn build_owned<M: MemorySource>(&self) -> OwnedElfMalloc<M> {
-        OwnedElfMalloc(self.build())
+    pub fn build_owned<M: MemorySource>(&self) -> Option<OwnedElfMalloc<M>> {
+        Some(OwnedElfMalloc(self.build()?))
     }
 }
 
@@ -513,7 +511,7 @@ mod global {
     lazy_static! {
         static ref GLOBAL_HANDLE: ElfCloner = ElfCloner(ElfMallocBuilder::default()
                                                         .page_size(16 << 10)
-                                                        .build());
+                                                        .build().expect("failed to build global handle"));
 
         /// We still have a crossbeam dependency, which means that we may have to reclaim a
         /// thread's cached memory after it is destroyed. See the comments in `general::global` for
@@ -602,7 +600,7 @@ mod tests {
     #[test]
     fn basic_alloc_functionality() {
         let word_size = mem::size_of::<usize>();
-        let mut alloc = ElfMallocBuilder::default().build_owned::<MmapSource>();
+        let mut alloc = ElfMallocBuilder::default().build_owned::<MmapSource>().unwrap();
         let layouts: Vec<_> = (word_size..(8 << 10))
             .map(|size| {
                 Layout::from_size_align(size * 128, word_size).unwrap()
@@ -623,7 +621,7 @@ mod tests {
 
     fn multi_threaded_alloc_test(layouts: Vec<Layout>) {
         const N_THREADS: usize = 64;
-        let alloc = ElfMallocBuilder::default().build_owned::<MmapSource>();
+        let alloc = ElfMallocBuilder::default().build_owned::<MmapSource>().unwrap();
 
         let mut threads = Vec::new();
         for _ in 0..N_THREADS {
diff --git a/elfmalloc/src/slag.rs b/elfmalloc/src/slag.rs
index 012192b..9c98591 100644
--- a/elfmalloc/src/slag.rs
+++ b/elfmalloc/src/slag.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -99,26 +99,17 @@ pub trait CoarseAllocator
 where
     Self: Clone,
 {
-    /// The concrete type representing backing memory for the allocator.
-    type Block: MemorySource;
-
-    /// The start of a new block of memory of size `backing_memory().page_size()`.
-    ///
-    /// Furthermore, all memory returned by `alloc` must satisfy
-    /// `c.backing_memory().contains(c.alloc())`*.
-    ///
-    /// *That is, if that code actually compiled and didn't have a lifetime issue.
-    unsafe fn alloc(&mut self) -> *mut u8;
+    /// Allocate a new block of memory of size `page_size()`.
+    unsafe fn alloc(&mut self) -> Option<*mut u8>;
 
     /// Free a page of memory back to the allocator.
     ///
-    /// If `item` is not contained in `self.backing_memory()`, the behavior of `free` is undefined.
     /// The `uncommit` flag is a hint to the allocator to uncommit the memory. It need not be
     /// observed.
     unsafe fn free(&mut self, item: *mut u8, uncommit: bool);
 
     /// Get access to the backing memory for the allocator.
-    fn backing_memory(&self) -> &Self::Block;
+    fn page_size(&self) -> usize;
 }
 
 
@@ -907,20 +898,21 @@ where
     dirty: SlagPipe<u8>,
     aligned_source: C,
     pages_per: usize,
+    page_size: usize,
     ty: AllocType,
     _marker: PhantomData<D>,
 }
 
 impl<C: MemorySource, D: DirtyFn> LazyInitializable for PageAlloc<C, D> {
     type Params = (usize, usize, usize, usize, AllocType);
-    fn init(&(page_size, target_overhead, pipe_size, aligned_source, ty): &Self::Params) -> Self {
+    fn init(&(page_size, target_overhead, pipe_size, aligned_source, ty): &Self::Params) -> Option<Self> {
         Self::new_aligned(page_size, target_overhead, pipe_size, aligned_source, ty)
     }
 }
 
 impl<C: MemorySource, D: DirtyFn> PageAlloc<C, D> {
     /// Create a new `PageAlloc`.
-    pub fn new(page_size: usize, target_overhead: usize, pipe_size: usize, ty: AllocType) -> Self {
+    pub fn new(page_size: usize, target_overhead: usize, pipe_size: usize, ty: AllocType) -> Option<Self> {
         Self::new_aligned(page_size, target_overhead, pipe_size, page_size, ty)
     }
 
@@ -930,42 +922,42 @@ impl<C: MemorySource, D: DirtyFn> PageAlloc<C, D> {
         pipe_size: usize,
         align: usize,
         ty: AllocType,
-    ) -> Self {
+    ) -> Option<Self> {
         alloc_debug_assert!(align >= page_size);
         alloc_debug_assert!(page_size.is_power_of_two());
         alloc_debug_assert!(align.is_power_of_two());
         let pages_per = align / page_size;
         let clean = PageCleanup::new(page_size);
-        let creek = C::new(page_size);
+        let creek = C::new(page_size)?;
         let creek_2 = if pages_per > 1 {
-            C::new(align)
+            C::new(align)?
         } else {
             creek.clone()
         };
-        PageAlloc {
-            target_overhead: target_overhead,
-            creek: creek,
-            pages_per: pages_per,
+        Some(PageAlloc {
+            target_overhead,
+            creek,
+            pages_per,
+            page_size,
             aligned_source: creek_2,
             clean: SlagPipe::new_size_cleanup(2, clean),
             dirty: SlagPipe::new_size_cleanup(pipe_size, clean),
-            ty: ty,
+            ty,
             _marker: PhantomData,
-        }
+        })
     }
 
     /// Get more clean pages from the backing memory.
     ///
     /// One of these pages is returned to the caller for allocation. The rest are added to the
     /// clean `BagPipe`.
-    fn refresh_pages(&mut self) -> *mut u8 {
+    fn refresh_pages(&mut self) -> Option<*mut u8> {
         // If we are using a higher alignment, just allocate a single higher-aligned page. If not,
         // allocate two pages.
         let npages = cmp::max(self.pages_per, 2);
         let creek = &self.aligned_source;
         let pages = creek
-            .carve(if self.pages_per == 1 { 2 } else { 1 })
-            .expect("out of memory!");
+            .carve(if self.pages_per == 1 { 2 } else { 1 })?;
         let page_size = self.creek.page_size();
         // Write the required AllocType to the aligned boundary. In some settings this is
         // unnecessary, but refresh_pages is not called in the hot path and the cost of writing
@@ -976,48 +968,45 @@ impl<C: MemorySource, D: DirtyFn> PageAlloc<C, D> {
             pages.offset(page_size as isize * (i as isize))
         });
         self.clean.bulk_add(iter);
-        pages
+        Some(pages)
     }
 }
 
 impl<C: MemorySource, D: DirtyFn> CoarseAllocator for PageAlloc<C, D> {
-    type Block = C;
-
-    fn backing_memory(&self) -> &C {
-        &self.creek
+    fn page_size(&self) -> usize {
+        self.page_size
     }
 
-    unsafe fn alloc(&mut self) -> *mut u8 {
+    unsafe fn alloc(&mut self) -> Option<*mut u8> {
         if let Ok(ptr) = self.dirty.try_pop_mut() {
             trace_event!(grabbed_dirty);
-            return ptr;
-        }
-        if let Ok(ptr) = self.clean.try_pop_mut() {
+            Some(ptr)
+        } else if let Ok(ptr) = self.clean.try_pop_mut() {
             trace_event!(grabbed_clean);
             D::dirty(ptr);
-            return ptr;
+            Some(ptr)
+        } else {
+            self.refresh_pages()
         }
-        self.refresh_pages()
     }
 
     unsafe fn free(&mut self, ptr: *mut u8, decommit: bool) {
-        use self::mmap::uncommit;
         use std::cmp;
         let minor_page_size = mmap::page_size() as isize;
         if self.dirty.size_guess() >= self.target_overhead as isize {
-            uncommit(ptr, self.backing_memory().page_size());
+            mmap::uncommit(ptr, self.page_size);
             self.clean.push_mut(ptr);
             return;
         }
         if decommit {
             let uncommit_len = cmp::max(
                 0,
-                self.backing_memory().page_size() as isize - minor_page_size,
+                self.page_size as isize - minor_page_size,
             ) as usize;
             if uncommit_len == 0 {
                 self.dirty.push_mut(ptr);
             } else {
-                uncommit(ptr.offset(minor_page_size), uncommit_len);
+                mmap::uncommit(ptr.offset(minor_page_size), uncommit_len);
                 self.dirty.push_mut(ptr);
             }
         } else {
@@ -1073,18 +1062,18 @@ impl<CA: CoarseAllocator> SlagAllocator<CA> {
         decommit: usize,
         mut pa: CA,
         avail: RevocablePipe<Slag>,
-    ) -> Self {
-        let first_slag = unsafe { pa.alloc() } as *mut Slag;
+    ) -> Option<Self> {
+        let first_slag = unsafe { pa.alloc()? } as *mut Slag;
         unsafe {
             Slag::init(first_slag, meta.as_ref().expect("metadata null"));
         };
-        SlagAllocator {
+        Some(SlagAllocator {
             m: meta,
             slag: first_slag,
             pages: pa,
             available: avail,
             eager_decommit_threshold: decommit,
-        }
+        })
     }
     pub fn new(
         max_objects: usize,
@@ -1093,33 +1082,33 @@ impl<CA: CoarseAllocator> SlagAllocator<CA> {
         cutoff_factor: f64,
         eager_decommit: usize,
         mut pa: CA,
-    ) -> Self {
+    ) -> Option<Self> {
         // This is a bit wasteful as one metadata object consumes will wind up consuming a page. In
         // the dynamic allocator these are packed more tightly.
         let meta = Box::into_raw(Box::new(compute_metadata(
             object_size,
-            pa.backing_memory().page_size(),
+            pa.page_size(),
             index,
             cutoff_factor,
             max_objects,
             AllocType::SmallSlag,
         )));
-        let first_slag = unsafe { pa.alloc() } as *mut Slag;
+        let first_slag = unsafe { pa.alloc()? } as *mut Slag;
         unsafe {
             Slag::init(first_slag, meta.as_ref().expect("metadata null"));
         };
-        let cleanup = PageCleanup::new(pa.backing_memory().page_size());
-        SlagAllocator {
+        let cleanup = PageCleanup::new(pa.page_size());
+        Some(SlagAllocator {
             m: meta,
             slag: first_slag,
             pages: pa,
             available: RevocablePipe::new_size_cleanup(8, cleanup),
             eager_decommit_threshold: eager_decommit,
-        }
+        })
     }
 
     /// Re-initialize a non-empty `AllocIter`; potentially getting a new `Slag` to do so.
-    pub unsafe fn refresh(&mut self) -> AllocIter {
+    pub unsafe fn refresh(&mut self) -> Option<AllocIter> {
         let s_ref = &*self.slag;
         let meta = &*self.m;
         let (_claimed, was) = s_ref.rc.unclaim();
@@ -1156,7 +1145,7 @@ impl<CA: CoarseAllocator> SlagAllocator<CA> {
                 _claimed,
                 "claiming slag either during initialization or due to being over cutoff"
             );
-            s_ref.refresh(meta)
+            Some(s_ref.refresh(meta))
         } else {
             // we need a new slag!
             // first we try and get a slag from the available slagpipe. If it is empty, then we get
@@ -1168,7 +1157,7 @@ impl<CA: CoarseAllocator> SlagAllocator<CA> {
                     slab
                 }
                 Err(_) => {
-                    let new_raw = self.pages.alloc() as *mut Slag;
+                    let new_raw = self.pages.alloc()? as *mut Slag;
                     if (*new_raw).meta.load(Ordering::Relaxed) != self.m {
                         Slag::init(new_raw, meta);
                     }
@@ -1179,7 +1168,7 @@ impl<CA: CoarseAllocator> SlagAllocator<CA> {
             let s_ref = self.slag.as_mut().expect("s_ref_2"); // let s_ref = &*self.slag;
             let claimed = s_ref.rc.claim();
             alloc_debug_assert!(claimed, "claiming new slag after refresh");
-            s_ref.refresh(meta)
+            Some(s_ref.refresh(meta))
         }
     }
 
@@ -1262,7 +1251,7 @@ impl<CA: CoarseAllocator> SlagAllocator<CA> {
 impl<CA: CoarseAllocator> Clone for SlagAllocator<CA> {
     fn clone(&self) -> Self {
         let mut new_page_handle = self.pages.clone();
-        let first_slag = unsafe { new_page_handle.alloc() as *mut Slag };
+        let first_slag = unsafe { new_page_handle.alloc().expect("failed to allocate slag") as *mut Slag };
         unsafe {
             Slag::init(
                 first_slag,
diff --git a/elfmalloc/src/sources.rs b/elfmalloc/src/sources.rs
index 5681cd0..3584447 100644
--- a/elfmalloc/src/sources.rs
+++ b/elfmalloc/src/sources.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -16,7 +16,7 @@ pub trait MemorySource
 where
     Self: Clone,
 {
-    fn new(page_size: usize) -> Self;
+    fn new(page_size: usize) -> Option<Self>;
     /// The smallest unit of memory that can be `carve`d.
     fn page_size(&self) -> usize;
     /// Return `npages` fresh pages from the `Creek`. Each of these pages is aligned to
@@ -44,8 +44,8 @@ pub struct MmapSource {
 unsafe impl Send for MmapSource {}
 
 impl MemorySource for MmapSource {
-    fn new(page_size: usize) -> MmapSource {
-        MmapSource { page_size: page_size.next_power_of_two() }
+    fn new(page_size: usize) -> Option<MmapSource> {
+        Some(MmapSource { page_size: page_size.next_power_of_two() })
     }
     fn page_size(&self) -> usize {
         self.page_size
@@ -62,14 +62,14 @@ impl MemorySource for MmapSource {
         // system one.
         let system_page_size = mmap::page_size();
         if self.page_size <= system_page_size {
-            return mmap::fallible_map(npages * self.page_size);
+            return mmap::map(npages * self.page_size);
         }
         // We want to return pages aligned to our page size, which is larger than the
         // system page size. As a result, we want to allocate an extra page to guarantee a slice of
         // the memory that is aligned to the larger page size.
         let target_size = npages * self.page_size;
         let req_size = target_size + self.page_size;
-        mmap::fallible_map(req_size).and_then(|mem| {
+        mmap::map(req_size).and_then(|mem| {
             let mem_num = mem as usize;
 
             alloc_debug_assert_eq!(mod_size(mem_num, system_page_size), 0);
@@ -175,23 +175,22 @@ impl MemorySource for Creek {
     /// Page size and heap size should be powers of two. The allocator may want to reserve some
     /// pages for itself (or for alignment reasons), as a result it is a good idea to have
     /// heap_size be much larger than page_size.
-    fn new(page_size: usize) -> Self {
-        use self::mmap::fallible_map;
-        let get_heap = || {
+    fn new(page_size: usize) -> Option<Self> {
+        // lots of stuff breaks if this isn't true
+        alloc_assert!(page_size.is_power_of_two());
+        alloc_assert!(page_size > mem::size_of::<usize>());
+        // first, let's grab some memory;
+        let (orig_base, heap_size) = {
             let mut heap_size: usize = 2 << 40;
-            while heap_size > (1 << 30) {
-                if let Some(heap) = fallible_map(heap_size) {
-                    return (heap, heap_size);
+            loop {
+                if let Some(heap) = self::mmap::map(heap_size) {
+                    break (heap, heap_size);
+                } else if heap_size <= (1 << 30) {
+                    return None;
                 }
                 heap_size /= 2;
             }
-            alloc_panic!("unable to map heap")
         };
-        // lots of stuff breaks if this isn't true
-        alloc_assert!(page_size.is_power_of_two());
-        alloc_assert!(page_size > mem::size_of::<usize>());
-        // first, let's grab some memory;
-        let (orig_base, heap_size) = get_heap();
         info!("created heap of size {}", heap_size);
         let orig_addr = orig_base as usize;
         let (slush_addr, real_addr) = {
@@ -213,12 +212,12 @@ impl MemorySource for Creek {
             };
             (base as *mut u8, (base + page_size) as *mut u8)
         };
-        Creek {
+        Some(Creek {
             page_size: page_size,
             map_info: Arc::new(MapAddr(orig_base, heap_size)),
             base: real_addr,
             bump: AtomicPtr::new(slush_addr as *mut AtomicUsize),
-        }
+        })
     }
 }
 
diff --git a/elfmalloc/src/utils.rs b/elfmalloc/src/utils.rs
index 4b1acca..355a42d 100644
--- a/elfmalloc/src/utils.rs
+++ b/elfmalloc/src/utils.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -20,11 +20,7 @@ pub mod mmap {
         self::sysconf::page::pagesize()
     }
 
-    pub fn map(size: usize) -> *mut u8 {
-        fallible_map(size).expect("mmap should not fail")
-    }
-
-    pub fn fallible_map(size: usize) -> Option<*mut u8> {
+    pub fn map(size: usize) -> Option<*mut u8> {
         unsafe {
             if let Ok(s) = MapAllocBuilder::default()
                    .exec(true)
@@ -73,9 +69,9 @@ pub unsafe fn likely(b: bool) -> bool {
 /// A `LazyInitializable` type can be constructed from `Params`.
 ///
 /// Types that implement this trate can be wrapped in the `Lazy` construct.
-pub trait LazyInitializable {
+pub trait LazyInitializable: Sized {
     type Params;
-    fn init(p: &Self::Params) -> Self;
+    fn init(p: &Self::Params) -> Option<Self>;
 }
 
 /// A `Lazy` instance of a type `T` keeps `T::Params` strict but only initializes the value with
@@ -120,7 +116,7 @@ impl<T: LazyInitializable> Deref for Lazy<T> {
     fn deref(&self) -> &T {
         let state = unsafe { &mut *self.val.get() };
         if unsafe { unlikely(state.is_none()) } {
-            *state = Some(T::init(&self.params));
+            *state = T::init(&self.params);
         }
         state.as_ref().unwrap()
     }
@@ -132,7 +128,7 @@ impl<T: LazyInitializable> DerefMut for Lazy<T> {
     fn deref_mut(&mut self) -> &mut T {
         let state = unsafe { &mut *self.val.get() };
         if unsafe { unlikely(state.is_none()) } {
-            *state = Some(T::init(&self.params));
+            *state = T::init(&self.params);
         }
         state.as_mut().unwrap()
     }
@@ -156,19 +152,19 @@ pub struct TypedArray<T> {
 }
 
 impl<T> TypedArray<T> {
-    pub fn new(size: usize) -> TypedArray<T> {
+    pub fn new(size: usize) -> Option<TypedArray<T>> {
         use std::mem::size_of;
         let page_size = mmap::page_size();
         let bytes = size_of::<T>() * size;
         let rem = bytes % page_size;
         let n_pages = bytes / page_size + cmp::min(1, rem);
         let region_size = n_pages * page_size;
-        let mem = mmap::map(region_size);
-        TypedArray {
+        let mem = mmap::map(region_size)?;
+        Some(TypedArray {
             data: mem as *mut T,
             len: size,
             mapped: region_size,
-        }
+        })
     }
 
     pub fn iter(&self) -> TypedArrayIter<T> {
@@ -197,8 +193,8 @@ impl<T> TypedArray<T> {
 pub struct OwnedArray<T>(TypedArray<T>);
 
 impl<T> OwnedArray<T> {
-    pub fn new(size: usize) -> OwnedArray<T> {
-        OwnedArray(TypedArray::new(size))
+    pub fn new(size: usize) -> Option<OwnedArray<T>> {
+        Some(OwnedArray(TypedArray::new(size)?))
     }
 }
 
@@ -241,8 +237,8 @@ mod tests {
     struct DefaultInit<T: Default>(T);
     impl<T: Default> LazyInitializable for DefaultInit<T> {
         type Params = ();
-        fn init(_p: &()) -> Self {
-            DefaultInit(T::default())
+        fn init(_p: &()) -> Option<Self> {
+            Some(DefaultInit(T::default()))
         }
     }
 
diff --git a/elfmalloc/travis.sh b/elfmalloc/travis.sh
index 86eb005..b9f26bc 100755
--- a/elfmalloc/travis.sh
+++ b/elfmalloc/travis.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-# Copyright 2017 the authors. See the 'Copyright and license' section of the
+# Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 # README.md file at the top-level directory of this repository.
 #
 # Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -17,6 +17,6 @@ exit 0
 
 travis-cargo --only nightly build
 RUST_BACKTRACE=1 travis-cargo --only nightly test
-for feature in prime_schedules huge_segments no_lazy_region nightly; do
+for feature in prime_schedules huge_segments no_lazy_region local_cache use_default_allocator print_stats magazine_layout c-api nightly; do
   RUST_BACKTRACE=1 travis-cargo --only nightly test -- --features "$feature"
 done