use std::{
io,
ops::Deref,
os::fd::{AsFd, BorrowedFd, OwnedFd},
ptr, slice, thread,
time::{Duration, Instant},
};
use rustix::{
buffer::spare_capacity,
fs::{MemfdFlags, SealFlags, fcntl_add_seals, fcntl_get_seals, fstat, ftruncate, memfd_create},
io::{Errno, pread, retry_on_intr},
mm::{Advice, MapFlags, ProtFlags, madvise, mmap, munmap},
};
pub(crate) fn filled<F, E>(name: &str, len: usize, fill: F) -> Result<OwnedFd, E>
where
F: FnOnce(&mut [u8]) -> Result<(), E>,
E: From<io::Error>,
{
let fd = new(name)?;
ftruncate(&fd, len as u64).map_err(io::Error::from)?;
let seals = SealFlags::SHRINK | SealFlags::GROW;
fcntl_add_seals(&fd, seals).map_err(io::Error::from)?;
{
let mut mapping = Mapping::shared(fd.as_fd(), len)?;
mapping.populate()?;
fill(mapping.bytes_mut())?;
}
seal_writes(fd.as_fd())?;
Ok(fd)
}
#[cfg(test)]
pub(crate) fn sealed(name: &str, bytes: &[u8]) -> io::Result<OwnedFd> {
filled(name, bytes.len(), |memfd| {
memfd.copy_from_slice(bytes);
Ok(())
})
}
pub(crate) fn view(fd: BorrowedFd<'_>) -> io::Result<View> {
let kind = match Mapping::sealed(fd)? {
Some(mapping) => Kind::Mapped(mapping),
None => Kind::Read(read(fd)?),
};
Ok(View(kind))
}
pub(crate) fn read(fd: BorrowedFd<'_>) -> io::Result<Vec<u8>> {
let mut bytes = Vec::new();
loop {
bytes.reserve(READ_CHUNK);
let offset = bytes.len() as u64;
if retry_on_intr(|| pread(fd, spare_capacity(&mut bytes), offset))? == 0 {
return Ok(bytes);
}
}
}
#[derive(Debug)]
pub(crate) struct View(Kind);
impl Deref for View {
type Target = [u8];
fn deref(&self) -> &[u8] {
match &self.0 {
Kind::Mapped(mapping) => mapping.bytes(),
Kind::Read(bytes) => bytes,
}
}
}
#[derive(Debug)]
enum Kind {
Mapped(Mapping),
Read(Vec<u8>),
}
#[derive(Debug)]
struct Mapping {
start: *mut u8,
len: SliceLen,
writable: bool,
}
unsafe impl Send for Mapping {}
unsafe impl Sync for Mapping {}
impl Mapping {
fn shared(fd: BorrowedFd<'_>, len: usize) -> io::Result<Self> {
let mapping = Self::new(fd, len, true)?;
let len = mapping.len.get();
if len > 0 {
unsafe { madvise(mapping.start.cast(), len, Advice::LinuxDontFork) }?;
}
Ok(mapping)
}
fn sealed(fd: BorrowedFd<'_>) -> io::Result<Option<Self>> {
let seals = SealFlags::SHRINK | SealFlags::WRITE;
if !fcntl_get_seals(fd).is_ok_and(|sealed| sealed.contains(seals)) {
return Ok(None);
}
Self::new(fd, fstat(fd)?.st_size, false).map(Some)
}
fn new<L>(fd: BorrowedFd<'_>, len: L, writable: bool) -> io::Result<Self>
where
L: TryInto<SliceLen, Error = Errno>,
{
let len = len.try_into()?;
if len.get() == 0 {
return Ok(Self {
start: ptr::NonNull::dangling().as_ptr(),
len,
writable,
});
}
let (prot, flags) = match writable {
true => (ProtFlags::READ | ProtFlags::WRITE, MapFlags::SHARED),
false => (ProtFlags::READ, MapFlags::PRIVATE),
};
let start = unsafe { mmap(ptr::null_mut(), len.get(), prot, flags, fd, 0) }?;
Ok(Self {
start: start.cast(),
len,
writable,
})
}
fn populate(&self) -> io::Result<()> {
let len = self.len.get();
if len == 0 {
return Ok(());
}
match unsafe { madvise(self.start.cast(), len, Advice::LinuxPopulateWrite) } {
Ok(()) | Err(Errno::INVAL) => Ok(()),
Err(e) => Err(e.into()),
}
}
fn bytes(&self) -> &[u8] {
unsafe { slice::from_raw_parts(self.start, self.len.get()) }
}
fn bytes_mut(&mut self) -> &mut [u8] {
assert!(self.writable, "a read-only mapping to write to");
unsafe { slice::from_raw_parts_mut(self.start, self.len.get()) }
}
}
impl Drop for Mapping {
fn drop(&mut self) {
let len = self.len.get();
if len == 0 {
return;
}
let unmapped = unsafe { munmap(self.start.cast(), len) };
debug_assert!(unmapped.is_ok(), "failed to unmap a memfd: {unmapped:?}");
}
}
#[derive(Debug, Clone, Copy)]
struct SliceLen(usize);
impl SliceLen {
fn get(self) -> usize {
self.0
}
}
impl TryFrom<usize> for SliceLen {
type Error = Errno;
fn try_from(len: usize) -> Result<Self, Errno> {
if isize::try_from(len).is_err() {
return Err(Errno::OVERFLOW);
}
Ok(Self(len))
}
}
impl TryFrom<i64> for SliceLen {
type Error = Errno;
fn try_from(size: i64) -> Result<Self, Errno> {
let len = usize::try_from(size).map_err(|_| Errno::OVERFLOW)?;
Self::try_from(len)
}
}
fn new(name: &str) -> io::Result<OwnedFd> {
let flags = MemfdFlags::CLOEXEC | MemfdFlags::ALLOW_SEALING;
match memfd_create(name, flags | MemfdFlags::NOEXEC_SEAL) {
Err(Errno::INVAL) => Ok(memfd_create(name, flags)?),
fd => Ok(fd?),
}
}
fn seal_writes(fd: BorrowedFd<'_>) -> io::Result<()> {
let seals = SealFlags::WRITE | SealFlags::SEAL;
let deadline = Instant::now() + SEAL_TIMEOUT;
loop {
match fcntl_add_seals(fd, seals) {
Err(Errno::BUSY) if Instant::now() < deadline => thread::sleep(SEAL_RETRY),
sealed => return Ok(sealed?),
}
}
}
const READ_CHUNK: usize = 8192;
const SEAL_TIMEOUT: Duration = Duration::from_secs(1);
const SEAL_RETRY: Duration = Duration::from_millis(1);
#[cfg(test)]
mod tests {
use std::{fs::File, io::ErrorKind, os::fd::AsRawFd};
use rustix::{
io::{FdFlags, fcntl_getfd, pwrite, write},
process::{Pid, WaitOptions, waitpid},
};
use super::*;
use crate::test_utils::{in_own_process, pipe, read_byte};
#[test]
fn round_trip() {
for len in [0, 5, 3 * READ_CHUNK + 1] {
let bytes: Vec<_> = (0..=u8::MAX).cycle().take(len).collect();
let filling = |memfd: &mut [u8]| {
assert!(memfd.iter().all(|&byte| byte == 0), "the memfd isn't empty");
memfd.copy_from_slice(&bytes);
Ok::<_, io::Error>(())
};
let fd = filled("zoter-test", len, filling).unwrap();
assert_eq!(read(fd.as_fd()).unwrap(), bytes);
assert!(fcntl_getfd(&fd).unwrap().contains(FdFlags::CLOEXEC));
let seals = SealFlags::SHRINK | SealFlags::GROW | SealFlags::WRITE | SealFlags::SEAL;
assert!(fcntl_get_seals(&fd).unwrap().contains(seals));
}
}
#[test]
fn sealed_against_changes() {
let fd = sealed("zoter-test", b"state").unwrap();
assert_eq!(write(&fd, b"x").unwrap_err(), Errno::PERM);
assert_eq!(pwrite(&fd, b"x", 0).unwrap_err(), Errno::PERM);
assert_eq!(ftruncate(&fd, 0).unwrap_err(), Errno::PERM);
assert_eq!(ftruncate(&fd, 1 << 20).unwrap_err(), Errno::PERM);
assert_eq!(
fcntl_add_seals(&fd, SealFlags::FUTURE_WRITE).unwrap_err(),
Errno::PERM
);
assert_eq!(read(fd.as_fd()).unwrap(), b"state");
}
#[test]
fn filled_fails_as_it_is_filled() {
let failing = |_: &mut [u8]| Err(io::Error::from(ErrorKind::InvalidData));
let error = filled("zoter-test", 8, failing).unwrap_err();
assert_eq!(error.kind(), ErrorKind::InvalidData);
}
#[test]
fn view_maps_sealed_memfds() {
for bytes in [&b""[..], b"state"] {
let fd = sealed("zoter-test", bytes).unwrap();
let view = view(fd.as_fd()).unwrap();
assert!(matches!(view.0, Kind::Mapped(_)), "{view:?}");
assert_eq!(&*view, bytes);
}
}
#[test]
fn mapping_longer_than_a_slice_is_refused() {
let fd = sealed("zoter-test", b"state").unwrap();
for writable in [false, true] {
let e = Mapping::new(fd.as_fd(), isize::MAX.unsigned_abs() + 1, writable).unwrap_err();
assert_eq!(e.raw_os_error(), Some(Errno::OVERFLOW.raw_os_error()));
}
let e = Mapping::new(fd.as_fd(), -1_i64, false).unwrap_err();
assert_eq!(e.raw_os_error(), Some(Errno::OVERFLOW.raw_os_error()));
}
#[test]
fn view_reads_other_files() {
let fd = memfd_create("zoter-test", MemfdFlags::CLOEXEC).unwrap();
assert_eq!(pwrite(&fd, b"state", 0).unwrap(), 5);
let view = view(fd.as_fd()).unwrap();
assert!(matches!(view.0, Kind::Read(_)), "{view:?}");
assert_eq!(&*view, b"state");
let path = concat!(env!("CARGO_MANIFEST_DIR"), "/src/memfd.rs");
let file = File::open(path).unwrap();
let view = super::view(file.as_fd()).unwrap();
assert!(matches!(view.0, Kind::Read(_)), "{view:?}");
assert_eq!(&*view, std::fs::read(path).unwrap());
}
#[test]
fn name_too_long() {
assert!(sealed(&"a".repeat(249), b"").is_ok());
assert_eq!(
sealed(&"a".repeat(250), b"").unwrap_err().raw_os_error(),
Some(Errno::INVAL.raw_os_error())
);
}
#[test]
fn read_from_the_start() {
let fd = sealed("zoter-test", b"state").unwrap();
read_byte(&fd);
assert_eq!(read(fd.as_fd()).unwrap(), b"state");
assert_eq!(read_byte(&fd), b't');
}
#[test]
fn read_any_file() {
let path = concat!(env!("CARGO_MANIFEST_DIR"), "/src/memfd.rs");
let file = File::open(path).unwrap();
let bytes = read(file.as_fd()).unwrap();
assert!(bytes.len() > READ_CHUNK);
assert_eq!(bytes, std::fs::read(path).unwrap());
}
#[test]
fn sealed_with_a_child_forked_as_it_was_filled() {
let test = "memfd::tests::sealed_with_a_child_forked_as_it_was_filled";
if !in_own_process(test, "ZOTER_TEST_FORK=1") {
return;
}
let (wait, release) = pipe();
let mut child = None;
let filled = filled("zoter-test", 8, |memfd: &mut [u8]| {
memfd.fill(1);
child = Some(fork_waiting(&wait, &release));
Ok::<_, io::Error>(())
});
drop(release);
reap(child.unwrap());
let fd = filled.unwrap();
assert!(fcntl_get_seals(&fd).unwrap().contains(SealFlags::WRITE));
assert_eq!(read(fd.as_fd()).unwrap(), [1; 8]);
}
#[test]
fn sealing_waits_for_a_child_with_a_copy() {
let test = "memfd::tests::sealing_waits_for_a_child_with_a_copy";
if !in_own_process(test, "ZOTER_TEST_FORK=1") {
return;
}
let fd = new("zoter-test").unwrap();
ftruncate(&fd, 8).unwrap();
let (wait, release) = pipe();
let mapping = Mapping::new(fd.as_fd(), 8_usize, true).unwrap();
let child = fork_waiting(&wait, &release);
drop(mapping);
let releasing = thread::spawn(move || {
thread::sleep(Duration::from_millis(100));
drop(release);
});
let sealed = seal_writes(fd.as_fd());
releasing.join().unwrap();
reap(child);
sealed.unwrap();
assert!(fcntl_get_seals(&fd).unwrap().contains(SealFlags::WRITE));
}
fn fork_waiting(wait: &OwnedFd, release: &OwnedFd) -> Pid {
let (wait, release) = (wait.as_raw_fd(), release.as_raw_fd());
let pid = unsafe { libc::fork() };
if pid == 0 {
let mut byte = 0_u8;
unsafe {
libc::close(release);
libc::read(wait, (&raw mut byte).cast(), 1);
libc::_exit(0);
}
}
assert!(pid > 0, "{}", io::Error::last_os_error());
Pid::from_raw(pid).unwrap()
}
fn reap(pid: Pid) {
let (_, status) = waitpid(Some(pid), WaitOptions::empty()).unwrap().unwrap();
assert_eq!(status.exit_status(), Some(0), "{status:?}");
}
}