1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! Non-racy linux-specific mirrored memory allocation.
use libc::{
    c_char, c_int, c_long, c_uint, c_void, close, ftruncate, mkstemp, mmap,
    munmap, off_t, size_t, syscall, sysconf, SYS_memfd_create, ENOSYS,
    MAP_FAILED, MAP_FIXED, MAP_SHARED, PROT_READ, PROT_WRITE, _SC_PAGESIZE,
};

#[cfg(target_os = "android")]
use libc::__errno;
#[cfg(not(target_os = "android"))]
use libc::__errno_location;

use super::{ptr, AllocError};

/// [`memfd_create`] - create an anonymous file
///
/// [`memfd_create`]: http://man7.org/linux/man-pages/man2/memfd_create.2.html
fn memfd_create(name: *const c_char, flags: c_uint) -> c_long {
    unsafe { syscall(SYS_memfd_create, name, flags) }
}

/// Returns the size of a memory allocation unit.
///
/// In Linux-like systems this equals the page-size.
pub fn allocation_granularity() -> usize {
    unsafe { sysconf(_SC_PAGESIZE) as usize }
}

/// Reads `errno`.
fn errno() -> c_int {
    #[cfg(not(target_os = "android"))]
    unsafe {
        *__errno_location()
    }
    #[cfg(target_os = "android")]
    unsafe {
        *__errno()
    }
}

/// Allocates an uninitialzied buffer that holds `size` bytes, where
/// the bytes in range `[0, size / 2)` are mirrored into the bytes in
/// range `[size / 2, size)`.
///
/// On Linux the algorithm is as follows:
///
/// * 1. Allocate a memory-mapped file containing `size / 2` bytes.
/// * 2. Map the file into `size` bytes of virtual memory.
/// * 3. Map the file into the last `size / 2` bytes of the virtual memory
/// region      obtained in step 2.
///
/// This algorithm doesn't have any races.
///
/// # Panics
///
/// If `size` is zero or `size / 2` is not a multiple of the
/// allocation granularity.
pub fn allocate_mirrored(size: usize) -> Result<*mut u8, AllocError> {
    unsafe {
        let half_size = size / 2;
        assert!(size != 0);
        assert!(half_size % allocation_granularity() == 0);

        // create temporary file
        let mut fname = *b"/tmp/slice_deque_fileXXXXXX\0";
        let mut fd: c_long =
            memfd_create(fname.as_mut_ptr() as *mut c_char, 0);
        if fd == -1 && errno() == ENOSYS {
            // memfd_create is not implemented, use mkstemp instead:
            fd = c_long::from(mkstemp(fname.as_mut_ptr() as *mut c_char));
        }
        if fd == -1 {
            print_error("memfd_create failed");
            return Err(AllocError::Other);
        }
        let fd = fd as c_int;
        if ftruncate(fd, half_size as off_t) == -1 {
            print_error("ftruncate failed");
            if close(fd) == -1 {
                print_error("@ftruncate: close failed");
            }
            return Err(AllocError::Oom);
        };

        // mmap memory
        let ptr = mmap(
            ptr::null_mut(),
            size,
            PROT_READ | PROT_WRITE,
            MAP_SHARED,
            fd,
            0,
        );
        if ptr == MAP_FAILED {
            print_error("@first: mmap failed");
            if close(fd) == -1 {
                print_error("@first: close failed");
            }
            return Err(AllocError::Oom);
        }

        let ptr2 = mmap(
            (ptr as *mut u8).offset(half_size as isize) as *mut c_void,
            half_size,
            PROT_READ | PROT_WRITE,
            MAP_SHARED | MAP_FIXED,
            fd,
            0,
        );
        if ptr2 == MAP_FAILED {
            print_error("@second: mmap failed");
            if munmap(ptr, size as size_t) == -1 {
                print_error("@second: munmap failed");
            }
            if close(fd) == -1 {
                print_error("@second: close failed");
            }
            return Err(AllocError::Other);
        }

        if close(fd) == -1 {
            print_error("@success: close failed");
        }
        Ok(ptr as *mut u8)
    }
}

/// Deallocates the mirrored memory region at `ptr` of `size` bytes.
///
/// # Unsafe
///
/// `ptr` must have been obtained from a call to `allocate_mirrored(size)`,
/// otherwise the behavior is undefined.
///
/// # Panics
///
/// If `size` is zero or `size / 2` is not a multiple of the
/// allocation granularity, or `ptr` is null.
pub unsafe fn deallocate_mirrored(ptr: *mut u8, size: usize) {
    assert!(!ptr.is_null());
    assert!(size != 0);
    assert!(size % allocation_granularity() == 0);
    if munmap(ptr as *mut c_void, size as size_t) == -1 {
        print_error("deallocate munmap failed");
    }
}

/// Prints last os error at `location`.
#[cfg(all(debug_assertions, feature = "use_std"))]
fn print_error(location: &str) {
    eprintln!(
        "Error at {}: {}",
        location,
        ::std::io::Error::last_os_error()
    );
}

/// Prints last os error at `location`.
#[cfg(not(all(debug_assertions, feature = "use_std")))]
fn print_error(_location: &str) {}