use core::ptr::NonNull;
pub struct Arena {
ptr: NonNull<u8>,
len: usize,
}
unsafe impl Send for Arena {}
unsafe impl Sync for Arena {}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Protection {
pub locked: bool,
pub excluded_from_dumps: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ArenaError {
pub code: i32,
}
impl Arena {
pub fn new(len: usize) -> Result<Self, ArenaError> {
if len == 0 {
return Err(ArenaError { code: 0 });
}
let ptr = sys::map(len)?;
Ok(Self { ptr, len })
}
#[inline]
#[must_use]
pub fn base(&self) -> NonNull<u8> {
self.ptr
}
#[inline]
#[must_use]
pub fn len(&self) -> usize {
self.len
}
#[must_use]
pub fn protect_sensitive(&self) -> Protection {
sys::protect(self.ptr, self.len)
}
#[inline]
#[must_use]
pub fn is_empty(&self) -> bool {
self.len == 0
}
}
impl Drop for Arena {
fn drop(&mut self) {
unsafe { sys::unmap(self.ptr, self.len) };
}
}
#[cfg(miri)]
mod sys {
use super::{ArenaError, NonNull};
use std::alloc::{Layout, alloc_zeroed, dealloc};
fn layout(len: usize) -> Result<Layout, ArenaError> {
Layout::from_size_align(len, 4096).map_err(|_| ArenaError { code: 0 })
}
pub(super) fn map(len: usize) -> Result<NonNull<u8>, ArenaError> {
let l = layout(len)?;
NonNull::new(unsafe { alloc_zeroed(l) }).ok_or(ArenaError { code: 12 })
}
pub(super) fn protect(_ptr: NonNull<u8>, _len: usize) -> super::Protection {
super::Protection::default()
}
pub(super) unsafe fn unmap(ptr: NonNull<u8>, len: usize) {
if let Ok(l) = layout(len) {
unsafe { dealloc(ptr.as_ptr(), l) };
}
}
}
#[cfg(all(unix, not(miri)))]
mod sys {
use super::{ArenaError, NonNull};
pub(super) fn map(len: usize) -> Result<NonNull<u8>, ArenaError> {
let p = unsafe {
libc::mmap(
core::ptr::null_mut(),
len,
libc::PROT_READ | libc::PROT_WRITE,
libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
-1,
0,
)
};
if p == libc::MAP_FAILED {
return Err(ArenaError { code: errno() });
}
dont_fork(p, len);
NonNull::new(p.cast::<u8>()).ok_or(ArenaError { code: 0 })
}
pub(super) fn protect(ptr: NonNull<u8>, len: usize) -> super::Protection {
let locked = unsafe { libc::mlock(ptr.as_ptr().cast(), len) } == 0;
let excluded_from_dumps = exclude_from_dumps(ptr, len);
super::Protection {
locked,
excluded_from_dumps,
}
}
#[cfg(target_os = "linux")]
fn exclude_from_dumps(ptr: NonNull<u8>, len: usize) -> bool {
unsafe { libc::madvise(ptr.as_ptr().cast(), len, libc::MADV_DONTDUMP) == 0 }
}
#[cfg(not(target_os = "linux"))]
fn exclude_from_dumps(_ptr: NonNull<u8>, _len: usize) -> bool {
false
}
pub(super) unsafe fn unmap(ptr: NonNull<u8>, len: usize) {
let _unmap_status = unsafe { libc::munmap(ptr.as_ptr().cast(), len) };
}
#[cfg(target_os = "linux")]
fn dont_fork(p: *mut libc::c_void, len: usize) {
let _advice_status = unsafe { libc::madvise(p, len, libc::MADV_DONTFORK) };
}
#[cfg(not(target_os = "linux"))]
fn dont_fork(_p: *mut libc::c_void, _len: usize) {}
fn errno() -> i32 {
std::io::Error::last_os_error().raw_os_error().unwrap_or(0)
}
}
#[cfg(all(windows, not(miri)))]
mod sys {
use super::{ArenaError, NonNull};
use windows_sys::Win32::System::Memory::{
MEM_COMMIT, MEM_RELEASE, MEM_RESERVE, PAGE_READWRITE, VirtualAlloc, VirtualFree,
VirtualLock,
};
pub(super) fn protect(ptr: NonNull<u8>, len: usize) -> super::Protection {
let locked = unsafe { VirtualLock(ptr.as_ptr().cast(), len) } != 0;
super::Protection {
locked,
excluded_from_dumps: false,
}
}
pub(super) fn map(len: usize) -> Result<NonNull<u8>, ArenaError> {
let p = unsafe {
VirtualAlloc(
core::ptr::null(),
len,
MEM_RESERVE | MEM_COMMIT,
PAGE_READWRITE,
)
};
NonNull::new(p.cast::<u8>()).ok_or_else(|| ArenaError {
code: std::io::Error::last_os_error().raw_os_error().unwrap_or(0),
})
}
pub(super) unsafe fn unmap(ptr: NonNull<u8>, _len: usize) {
let _free_status = unsafe { VirtualFree(ptr.as_ptr().cast(), 0, MEM_RELEASE) };
}
}