You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
438 lines
12 KiB
438 lines
12 KiB
//! Provides physical in-memory file descriptors.
|
|
//!
|
|
//! This can be useful for temporary buffers where a file descriptor is required.
|
|
//! Huge-pages can also be used for this memory.
|
|
#![allow(deprecated)]
|
|
|
|
use super::*;
|
|
use libc::{
|
|
c_uint,
|
|
memfd_create,
|
|
MFD_CLOEXEC,
|
|
MFD_HUGETLB,
|
|
|
|
ftruncate,
|
|
|
|
lseek,
|
|
SEEK_SET,
|
|
SEEK_CUR,
|
|
SEEK_END,
|
|
};
|
|
use std::{
|
|
ffi::{CStr, CString},
|
|
borrow::{
|
|
Borrow,
|
|
BorrowMut,
|
|
Cow,
|
|
},
|
|
path::{
|
|
Path, PathBuf,
|
|
},
|
|
ops,
|
|
};
|
|
use hugetlb::{
|
|
MapHugeFlag,
|
|
HugePage,
|
|
};
|
|
|
|
static UNNAMED: &'static CStr = unsafe {
|
|
CStr::from_bytes_with_nul_unchecked(b"<unnamed memory file>\0")
|
|
};
|
|
|
|
const DEFAULT_FLAGS: c_uint = if cfg!(feature="default-cloexec") { MFD_CLOEXEC } else { 0 };
|
|
|
|
#[inline(always)]
|
|
//XXX: Is the static bound required here?
|
|
/// Create a raw, unmanaged, memory file with these flags and this name.
|
|
///
|
|
/// # Safety
|
|
/// The reference obtained by `name` must not move as long as the `Ok()` result is alive.
|
|
pub unsafe fn create_raw(name: impl AsRef<CStr>, flags: c_uint) -> io::Result<UnmanagedFD>
|
|
{
|
|
UnmanagedFD::new_raw(memfd_create(name.as_ref().as_ptr(), flags)).ok_or_else(|| io::Error::last_os_error())
|
|
}
|
|
|
|
/// A physical-memory backed file
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[repr(transparent)]
|
|
pub struct MemoryFile(ManagedFD);
|
|
|
|
/// A named, physical-memory backed file
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[deprecated(note = "Use `MemoryFile::named[_with_size]()` instead.")]
|
|
pub struct NamedMemoryFile(Box<CStr>, MemoryFile);
|
|
|
|
impl NamedMemoryFile
|
|
{
|
|
pub(crate) const PATH_PREFIX: &'static str = "/proc/self/fd/";
|
|
|
|
/// Get the name of the memfd which will be `/proc/self/fd/memfd:{}` (where `{}` is `.name()`.)
|
|
#[inline]
|
|
pub fn name(&self) -> &CStr
|
|
{
|
|
self.0.as_ref()
|
|
}
|
|
|
|
/// Get the absolute path (in `/proc/self/fd/`) of this memfd.
|
|
#[inline]
|
|
pub fn get_path(&self) -> PathBuf
|
|
{
|
|
use std::ffi::OsStr;
|
|
/// Name prefix within `PATH_PREFIX`.
|
|
const PREFIX: &[u8; 6] = b"memfd:";
|
|
|
|
// Alloc space for `PREFIX`+`self.0.len()` to create last element in path.
|
|
stackalloc::alloca_zeroed(self.0.count_bytes() + PREFIX.len(), move |name| {
|
|
// Write `memfd:` to `name[..6]`
|
|
name[..PREFIX.len()].copy_from_slice(&PREFIX[..]);
|
|
// Write name to `name+6`
|
|
name[PREFIX.len()..].copy_from_slice(self.0.to_bytes());
|
|
|
|
// for (&src, dest) in PREFIX.into_iter().chain(self.0.to_bytes().iter()).zip(&mut name[..]) {
|
|
// *dest = src;
|
|
// }
|
|
|
|
debug_assert_ne!(name.last().unwrap(), &0, "Invalid stack based path-builder string");
|
|
|
|
Path::new(Self::PATH_PREFIX).join(OsStr::from_bytes(&name[..]))
|
|
})
|
|
}
|
|
|
|
/// Consume into the internal `MemoryFile`.
|
|
#[inline]
|
|
pub fn into_inner(self) -> MemoryFile
|
|
{
|
|
self.1
|
|
}
|
|
}
|
|
|
|
impl AsRawFd for NamedMemoryFile
|
|
{
|
|
#[inline]
|
|
fn as_raw_fd(&self) -> RawFd {
|
|
self.1.as_raw_fd()
|
|
}
|
|
}
|
|
|
|
impl IntoRawFd for NamedMemoryFile
|
|
{
|
|
#[inline]
|
|
fn into_raw_fd(self) -> RawFd {
|
|
self.1.into_raw_fd()
|
|
}
|
|
}
|
|
|
|
impl Borrow<MemoryFile> for NamedMemoryFile
|
|
{
|
|
#[inline]
|
|
fn borrow(&self) -> &MemoryFile {
|
|
&self.1
|
|
}
|
|
}
|
|
impl BorrowMut<MemoryFile> for NamedMemoryFile
|
|
{
|
|
#[inline]
|
|
fn borrow_mut(&mut self) -> &mut MemoryFile {
|
|
&mut self.1
|
|
}
|
|
}
|
|
impl ops::DerefMut for NamedMemoryFile
|
|
{
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.1
|
|
}
|
|
}
|
|
impl ops::Deref for NamedMemoryFile
|
|
{
|
|
type Target = MemoryFile;
|
|
#[inline]
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.1
|
|
}
|
|
}
|
|
|
|
//impl `MemoryFile` (memfd_create() fd wrapper)
|
|
impl MemoryFile
|
|
{
|
|
/// The total size of the `memfd` memory file.
|
|
#[inline]
|
|
pub fn size(&self) -> io::Result<u64>
|
|
{
|
|
stat_file_size(&self.0)
|
|
}
|
|
|
|
/// Create a new, empty, memory file with the specified raw C-string pointer name and the default set of flags.
|
|
/// # Safety
|
|
///
|
|
/// `name` must be a:
|
|
/// - Non-null, aligned, valid pointer to:
|
|
/// - A nul-terminated, non-wide C string.
|
|
/// - Which must **not** contain a `/`.
|
|
#[inline(always)]
|
|
pub(super) unsafe fn new_raw_named(name: *const std::ffi::c_char, flags: c_uint) -> io::Result<Self>
|
|
{
|
|
let managed = unsafe {
|
|
match memfd_create(name, flags) {
|
|
-1 => return Err(last_os_error()),
|
|
fd => ManagedFD::take_unchecked(fd),
|
|
}
|
|
};
|
|
Ok(Self(managed))
|
|
}
|
|
|
|
/// Create a new, empty, memory file with no user-provided name and the default set of flags.
|
|
pub fn new() -> io::Result<Self>
|
|
{
|
|
// SAFETY: `UNNAMED` is a constant that fits the constraints required for `name`.
|
|
unsafe {
|
|
Self::new_raw_named(UNNAMED.as_ptr(), DEFAULT_FLAGS)
|
|
}
|
|
}
|
|
#[inline]
|
|
pub fn resize(&mut self, value: usize) -> io::Result<()>
|
|
{
|
|
if 0 == unsafe { ftruncate(self.as_raw_fd(), value.try_into().map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?) } {
|
|
Ok(())
|
|
} else {
|
|
Err(io::Error::last_os_error())
|
|
}
|
|
}
|
|
|
|
pub fn with_hugetlb(hugetlb: MapHugeFlag) -> io::Result<Self>
|
|
{
|
|
unsafe { create_raw(UNNAMED, DEFAULT_FLAGS | MFD_HUGETLB | (hugetlb.get_mask() as c_uint)) }
|
|
.map(ManagedFD::take)
|
|
.map(Self)
|
|
}
|
|
|
|
pub fn with_size(size: usize) -> io::Result<Self>
|
|
{
|
|
let mut this = Self(unsafe { create_raw(UNNAMED, DEFAULT_FLAGS) }.map(ManagedFD::take)?);
|
|
this.resize(size)?;
|
|
Ok(this)
|
|
}
|
|
|
|
#[inline]
|
|
pub fn with_size_hugetlb(size: usize, hugetlb: MapHugeFlag) -> io::Result<Self>
|
|
{
|
|
let mut this = Self::with_hugetlb(hugetlb)?;
|
|
this.resize(size)?;
|
|
Ok(this)
|
|
}
|
|
|
|
/// Create a new, empty, memory file with the specified raw C-string pointer name and the default set of flags.
|
|
pub fn new_named(name: impl AsRef<str>) -> io::Result<Self>
|
|
{
|
|
Self::raw_with_str_name(name.as_ref(), DEFAULT_FLAGS)
|
|
}
|
|
|
|
#[inline(always)]
|
|
pub(crate) fn raw_with_str_name(name: &str, flags: c_uint) -> io::Result<Self>
|
|
{
|
|
stackalloc::alloca_zeroed(name.len()+1, move |cname| {
|
|
cname[..name.len()].copy_from_slice(name.as_bytes());
|
|
debug_assert_eq!(cname[name.len()], 0, "Copied name not nul-terminated for `memfd_create()` call.");
|
|
|
|
// SAFETY: We have initialised `cname[..]`, and we know the final byte will be
|
|
unsafe {
|
|
Self::new_raw_named(cname.as_ptr() as *const _, flags)
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Create a new, empty, memory file with the specified raw C-string pointer name and the `MEMFD_HUGETLB` flag setup as provided as `hugetlb`.
|
|
pub fn new_named_with_hugetlb(name: impl AsRef<str>, hugetlb: MapHugeFlag) -> io::Result<Self>
|
|
{
|
|
Self::raw_with_str_name(name.as_ref(), DEFAULT_FLAGS | MFD_HUGETLB | (hugetlb.get_mask() as c_uint))
|
|
}
|
|
|
|
/// Create a new memory file with the specified raw C-string pointer name and the default set of flags.
|
|
/// Then resize it via `ftruncate()` to `size` bytes.
|
|
pub fn new_named_with_size(name: impl AsRef<str>, size: usize) -> io::Result<Self>
|
|
{
|
|
let mut this = Self::raw_with_str_name(name.as_ref(), DEFAULT_FLAGS)?;
|
|
this.resize(size)?;
|
|
Ok(this)
|
|
}
|
|
|
|
/// Create a new memory file with the specified raw C-string pointer name and the `MEMFD_HUGETLB` flag setup as provided as `hugetlb`.
|
|
/// Then resize it via `ftruncate()` to `size` bytes.
|
|
pub fn new_named_with_size_hugetlb(name: impl AsRef<str>, size: usize, hugetlb: MapHugeFlag) -> io::Result<Self>
|
|
{
|
|
let mut this = Self::raw_with_str_name(name.as_ref(), DEFAULT_FLAGS | MFD_HUGETLB | (hugetlb.get_mask() as c_uint))?;
|
|
this.resize(size)?;
|
|
Ok(this)
|
|
}
|
|
}
|
|
|
|
fn alloc_cstring(string: &str) -> std::ffi::CString
|
|
{
|
|
#[cold]
|
|
fn _contains_nul(mut bytes: Vec<u8>) -> std::ffi::CString
|
|
{
|
|
// SAFETY: We know this will only be called if byte `0` is in `bytes` (**before** the final element)
|
|
let len = unsafe {
|
|
memchr::memchr(0, &bytes[..]).unwrap_unchecked()
|
|
};
|
|
bytes.truncate(len);
|
|
// SAFETY: We have truncated the vector to end on the *first* instance of the `0` byte in `bytes`.
|
|
unsafe {
|
|
std::ffi::CString::from_vec_with_nul_unchecked(bytes)
|
|
}
|
|
}
|
|
let mut bytes = Vec::with_capacity(string.len()+1);
|
|
bytes.extend_from_slice(string.as_bytes());
|
|
bytes.push(0);
|
|
match std::ffi::CString::from_vec_with_nul(bytes) {
|
|
Ok(v) => v,
|
|
Err(cn) => {
|
|
_contains_nul(cn.into_bytes())
|
|
}
|
|
}
|
|
}
|
|
|
|
impl NamedMemoryFile
|
|
{
|
|
#[inline]
|
|
pub fn new(name: impl AsRef<str>) -> io::Result<Self>
|
|
{
|
|
let name: Box<CStr> = alloc_cstring(name.as_ref()).into();
|
|
let managed = unsafe {
|
|
match memfd_create(name.as_ptr(), DEFAULT_FLAGS) {
|
|
-1 => return Err(io::Error::last_os_error()),
|
|
fd => ManagedFD::take_unchecked(fd),
|
|
}
|
|
};
|
|
Ok(Self(name, MemoryFile(managed)))
|
|
}
|
|
|
|
pub fn with_hugetlb(name: impl AsRef<str>, hugetlb: MapHugeFlag) -> io::Result<Self>
|
|
{
|
|
let name: Box<CStr> = alloc_cstring(name.as_ref()).into();
|
|
let memfd = MemoryFile(unsafe { create_raw(&name, DEFAULT_FLAGS | MFD_HUGETLB | (hugetlb.get_mask() as c_uint)) }
|
|
.map(ManagedFD::take)?);
|
|
Ok(Self(name, memfd))
|
|
}
|
|
|
|
pub fn with_size(name: impl AsRef<str>, size: usize) -> io::Result<Self>
|
|
{
|
|
let name: Box<CStr> = alloc_cstring(name.as_ref()).into();
|
|
let mut this = MemoryFile(unsafe { create_raw(&name, DEFAULT_FLAGS) }.map(ManagedFD::take)?);
|
|
this.resize(size)?;
|
|
Ok(Self(name, this))
|
|
}
|
|
|
|
#[inline]
|
|
pub fn with_size_hugetlb(name: impl AsRef<str>, size: usize, hugetlb: MapHugeFlag) -> io::Result<Self>
|
|
{
|
|
let mut this = Self::with_hugetlb(name, hugetlb)?;
|
|
this.resize(size)?;
|
|
Ok(this)
|
|
}
|
|
}
|
|
|
|
impl AsRawFd for MemoryFile
|
|
{
|
|
#[inline]
|
|
fn as_raw_fd(&self) -> RawFd {
|
|
self.0.as_raw_fd()
|
|
}
|
|
}
|
|
|
|
impl FromRawFd for MemoryFile
|
|
{
|
|
#[inline]
|
|
unsafe fn from_raw_fd(fd: RawFd) -> Self {
|
|
Self(ManagedFD::from_raw_fd(fd))
|
|
}
|
|
}
|
|
|
|
impl IntoRawFd for MemoryFile
|
|
{
|
|
#[inline]
|
|
fn into_raw_fd(self) -> RawFd {
|
|
self.0.into_raw_fd()
|
|
}
|
|
}
|
|
|
|
impl From<MemoryFile> for ManagedFD
|
|
{
|
|
#[inline]
|
|
fn from(from: MemoryFile) -> Self
|
|
{
|
|
from.0
|
|
}
|
|
}
|
|
|
|
impl From<MemoryFile> for std::fs::File
|
|
{
|
|
#[inline]
|
|
fn from(from: MemoryFile) -> Self
|
|
{
|
|
from.0.into()
|
|
}
|
|
}
|
|
|
|
raw::impl_io_for_fd!(MemoryFile => .0.as_raw_fd());
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use std::io::{
|
|
self,
|
|
Write, Read, Seek,
|
|
};
|
|
|
|
#[test]
|
|
fn default_flag_cloexec_visible()
|
|
{
|
|
println!("Default flags: {} (default-cloexec: {})", super::DEFAULT_FLAGS, cfg!(feature="default-cloexec"));
|
|
|
|
assert_eq!(super::DEFAULT_FLAGS, cfg!(feature="default-cloexec").then(|| super::MFD_CLOEXEC).unwrap_or_default(), "Compile-time default creation flags are not in accordance with provided global crate configuration");
|
|
}
|
|
|
|
fn mem_seek()
|
|
{
|
|
// Test `SEEK_SET`.
|
|
let mut file = super::MemoryFile::new_named("test-mem-seek").expect("Failed to create new file 'memfd:test-mem-seek'");
|
|
file.write_all(b"hello world").expect("Failed to write to memfd");
|
|
file.seek(io::SeekFrom::Start(6)).expect("Failed to seek to 6..");
|
|
|
|
let mut buf = Vec::new();
|
|
let sz = file.read_to_end(&mut buf).expect("Failed to read from memfd");
|
|
|
|
assert_eq!(sz, 5, "Invalid number of bytes read");
|
|
assert_eq!(&buf, b"world", "Invalid string data read");
|
|
|
|
file.seek_relative(-(sz as i64)).expect("Failed to seek -5");
|
|
|
|
buf.clear();
|
|
assert_eq!(file.read_to_end(&mut buf).expect("Failed to read from memfd (2nd pass)"), sz, "Invalid number of bytes re-read from file");
|
|
assert_eq!(&buf, b"world", "Invalid string data read in 2nd pass");
|
|
}
|
|
|
|
#[test]
|
|
fn open_hugetlb()
|
|
{
|
|
const SIZE: usize = 1024 * 1024 * 4; // 1GB
|
|
|
|
let ht = super::HugePage::Static(crate::MapHugeFlag::HUGE_2MB); // 2MB hugetlb
|
|
|
|
let file = super::MemoryFile::new_named_with_size_hugetlb("test-mem-hugetlb", SIZE, dbg!(ht.compute_huge()).expect("Invalid `HugePage` spec."))
|
|
.expect("Failed to open hugetlb memfile");
|
|
|
|
let mut file = crate::MappedFile::new(file, 4096, crate::Perm::Writeonly, crate::Flags::Shared.with_hugetlb(ht))
|
|
.expect("Failed to map hugetlb memfile for writing");
|
|
|
|
write!(&mut &mut file[..], "Hello").expect("Failed to write to mapped file (1)");
|
|
write!(&mut &mut file[2000..], "World").expect("Failed to write to mapped file (2)");
|
|
|
|
file.flush(crate::Flush::Wait).expect("Failed to flush mapped data to memfd");
|
|
|
|
let file = crate::MappedFile::new(super::ManagedFD::alias(file.inner()).expect("dup() failed"), 4096, crate::Perm::Readonly, crate::Flags::Shared)
|
|
.expect("Failed to map hugetlb memfile for reading");
|
|
|
|
assert_eq!(&file[..5], b"Hello", "Invalid first write at 0");
|
|
assert_eq!(&file[2000..2005], b"World", "Invalid second write at 2000");
|
|
}
|
|
}
|