src/dlmalloc/src/linux.rs

   1 extern crate libc;
   2
   3 use core::ptr;
   4
   5 pub unsafe fn alloc(size: usize) -> (*mut u8, usize, u32) {
   6     let addr = libc::mmap(0 as *mut _,
   7                           size,
   8                           libc::PROT_WRITE | libc::PROT_READ,
   9                           libc::MAP_ANONYMOUS | libc::MAP_PRIVATE,
  10                           -1,
  11                           0);
  12     if addr == libc::MAP_FAILED {
  13         (ptr::null_mut(), 0, 0)
  14     } else {
  15         (addr as *mut u8, size, 0)
  16     }
  17 }
  18
  19 pub unsafe fn remap(ptr: *mut u8, oldsize: usize, newsize: usize, can_move: bool)
  20     -> *mut u8
  21 {
  22     let flags = if can_move { libc::MREMAP_MAYMOVE } else { 0 };
  23     let ptr = libc::mremap(ptr as *mut _, oldsize, newsize, flags);
  24     if ptr == libc::MAP_FAILED {
  25         ptr::null_mut()
  26     } else {
  27         ptr as *mut u8
  28     }
  29 }
  30
  31 pub unsafe fn free_part(ptr: *mut u8, oldsize: usize, newsize: usize) -> bool {
  32     let rc = libc::mremap(ptr as *mut _, oldsize, newsize, 0);
  33     if rc != libc::MAP_FAILED {
  34         return true
  35     }
  36     libc::munmap(ptr.offset(newsize as isize) as *mut _, oldsize - newsize) == 0
  37 }
  38
  39 pub unsafe fn free(ptr: *mut u8, size: usize) -> bool {
  40     libc::munmap(ptr as *mut _, size) == 0
  41 }
  42
  43 pub fn can_release_part(_flags: u32) -> bool {
  44     true
  45 }
  46
  47 static mut LOCK: libc::pthread_mutex_t = libc::PTHREAD_MUTEX_INITIALIZER;
  48
  49 pub fn acquire_global_lock() {
  50     unsafe {
  51         assert_eq!(libc::pthread_mutex_lock(&mut LOCK), 0)
  52     }
  53 }
  54
  55 pub fn release_global_lock() {
  56     unsafe {
  57         assert_eq!(libc::pthread_mutex_unlock(&mut LOCK), 0)
  58     }
  59 }
  60
  61 pub fn allocates_zeros() -> bool {
  62     true
  63 }
  64
  65 pub fn page_size() -> usize {
  66     4096
  67 }