use std::io;
use std::ptr::NonNull;
#[cfg(unix)]
pub(super) use std::os::fd::OwnedFd as Handle;
#[cfg(windows)]
pub(super) use std::os::windows::io::OwnedHandle as Handle;
pub(super) struct Memory {
pointer: NonNull<u8>,
len: usize,
handle: Handle,
}
unsafe impl Send for Memory {}
unsafe impl Sync for Memory {}
impl Memory {
pub fn new(len: usize) -> io::Result<Memory> {
let handle = platform::create(len)?;
unsafe { Memory::open(handle, len) }
}
pub unsafe fn open(handle: Handle, len: usize) -> io::Result<Memory> {
let pointer = unsafe { platform::map(&handle, len) }?;
Ok(Memory {
pointer,
len,
handle,
})
}
pub fn as_ptr(&self) -> *mut u8 {
self.pointer.as_ptr()
}
pub fn handle(&self) -> &Handle {
&self.handle
}
}
impl Drop for Memory {
fn drop(&mut self) {
unsafe { platform::unmap(self.pointer, self.len) };
}
}
#[cfg(unix)]
mod platform {
use std::io;
use std::os::fd::OwnedFd;
use std::ptr::NonNull;
use std::sync::atomic::{AtomicU32, Ordering};
use rustix::fs::Mode;
use rustix::mm::{self, MapFlags, ProtFlags};
use rustix::shm;
use super::super::errors::{MEMORY, invalid};
pub fn create(len: usize) -> io::Result<OwnedFd> {
static NEXT: AtomicU32 = AtomicU32::new(0);
loop {
let name = format!(
"/plughost-{:x}-{:x}",
std::process::id(),
NEXT.fetch_add(1, Ordering::Relaxed)
);
let flags = shm::OFlags::CREATE | shm::OFlags::EXCL | shm::OFlags::RDWR;
match shm::open(name.as_str(), flags, Mode::RUSR | Mode::WUSR) {
Ok(fd) => {
shm::unlink(name.as_str())?;
rustix::fs::ftruncate(&fd, len as u64)?;
return Ok(fd);
}
Err(rustix::io::Errno::EXIST) => {}
Err(error) => return Err(error.into()),
}
}
}
pub unsafe fn map(fd: &OwnedFd, len: usize) -> io::Result<NonNull<u8>> {
if (rustix::fs::fstat(fd)?.st_size as u64) < len as u64 {
return Err(invalid(MEMORY));
}
let pointer = unsafe {
mm::mmap(
std::ptr::null_mut(),
len,
ProtFlags::READ | ProtFlags::WRITE,
MapFlags::SHARED,
fd,
0,
)
}?;
NonNull::new(pointer.cast()).ok_or_else(|| invalid(MEMORY))
}
pub unsafe fn unmap(pointer: NonNull<u8>, len: usize) {
let _ = unsafe { mm::munmap(pointer.as_ptr().cast(), len) };
}
}
#[cfg(windows)]
mod platform {
use std::io;
use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
use std::ptr::NonNull;
use windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE;
use windows_sys::Win32::System::Memory::{
CreateFileMappingW, FILE_MAP_READ, FILE_MAP_WRITE, MEMORY_MAPPED_VIEW_ADDRESS,
MapViewOfFile, PAGE_READWRITE, UnmapViewOfFile,
};
pub fn create(len: usize) -> io::Result<OwnedHandle> {
let size = len as u64;
let handle = unsafe {
CreateFileMappingW(
INVALID_HANDLE_VALUE,
std::ptr::null(),
PAGE_READWRITE,
(size >> 32) as u32,
size as u32,
std::ptr::null(),
)
};
if handle.is_null() {
return Err(io::Error::last_os_error());
}
Ok(unsafe { OwnedHandle::from_raw_handle(handle) })
}
pub unsafe fn map(handle: &OwnedHandle, len: usize) -> io::Result<NonNull<u8>> {
let view = unsafe {
MapViewOfFile(
handle.as_raw_handle(),
FILE_MAP_READ | FILE_MAP_WRITE,
0,
0,
len,
)
};
NonNull::new(view.Value.cast()).ok_or_else(io::Error::last_os_error)
}
pub unsafe fn unmap(pointer: NonNull<u8>, _len: usize) {
unsafe {
UnmapViewOfFile(MEMORY_MAPPED_VIEW_ADDRESS {
Value: pointer.as_ptr().cast(),
})
};
}
}