Struct memfile::MemFile

pub struct MemFile { /* fields omitted */ }

A memory backed file that can have seals applied to it.

The struct implements AsRawFd, IntoRawFd and FromRawFd. When using FromRawFd::from_raw_fd, you must ensure that the file descriptor is a valid memfd.

Implementations

impl MemFile

pub fn create(name: &str, options: CreateOptions) -> Result<Self>

Create a new MemFile with the given options.

The name argument is purely for debugging purposes. On Linux it shows up in /proc, but it serves no other purpose. In particular, multiple files can be created with the same name.

The close-on-exec flag is set on the created file descriptor. If you want to pass it to a child process, you should use libc::dup2 or something similar after forking. Disabling the close-on-exec flag before forking causes a race condition with other threads.

pub fn create_cstr(name: &CStr, options: CreateOptions) -> Result<Self>

Create a new MemFile with the given options.

This is identical to Self::create, except that it takes the name as CStr to avoid allocations. See that function for more information.

pub fn create_default(name: &str) -> Result<Self>

Create a new MemFile with default options.

Sealing is not enabled for the created file.

See Self::create for more information.

pub fn create_sealable(name: &str) -> Result<Self>

Create a new MemFile with file sealing enabled.

Sealing is enabled for the created file. All other options are the same as the defaults.

See Self::create for more information.

pub fn try_clone(&self) -> Result<Self>

Create a new MemFile that shares the same underlying file handle.

The clones MemFile has a new file descriptor, but reads, writes, and seeks will affect both MemFile instances simultaneously.

pub fn from_file<T: AsRawFd + IntoRawFd>(
    file: T
) -> Result<Self, FromFdError<T>>

Wrap an already-open file as MemFile.

This function returns an error if the file was not created by memfd_create.

If the function succeeds, the passed in file object is consumed and the returned MemFile takes ownership of the file descriptor. If the function fails, the original file object is included in the returned error.

pub fn into_file(self) -> File

Convert this MemFile into an std::fs::File.

This may be useful for interoperability with other crates.

pub fn metadata(&self) -> Result<Metadata>

Query metadata about the underlying file.

Note that not all information in the metadata is not very meaningfull for a memfd. The file type is particularly useless since it is always the same. Some information, like the file size, may be useful.

pub fn set_len(&self, size: u64) -> Result<()>

Truncate or extend the underlying file, updating the size of this file to become size.

If the size is less than the current file’s size, then the file will be shrunk. If it is greater than the current file’s size, then the file will be extended to size and have all of the intermediate data filled in with 0s. The file’s cursor isn’t changed. In particular, if the cursor was at the end and the file is shrunk using this operation, the cursor will now be past the end.

pub fn get_seals(&self) -> Result<Seals>

Get the active seals of the file.

pub fn add_seal(&self, seal: Seal) -> Result<()>

Add a single seal to the file.

If you want to add multiple seals, you should prefer Self::add_seals to reduce the number of syscalls.

This function will fail if the file was not created with sealing support, if the file has already been sealed with Seal::Seal, or if you try to add Seal::Write while a shared, writable memory mapping exists for the file.

Adding a seal that is already active is a no-op.

pub fn add_seals(&self, seals: Seals) -> Result<()>

Add multiple seals to the file.

This function will fail if the file was not created with sealing support, if the file has already been sealed with Seal::Seal, or if you try to add Seal::Write while a shared, writable memory mapping exists for the file.

Adding seals that are already active is a no-op.

Trait Implementations

impl AsRawFd for MemFile

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for MemFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FileExt for MemFile

fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<usize>

Reads a number of bytes starting from a given offset.

fn write_at(&self, buf: &[u8], offset: u64) -> Result<usize>

Writes a number of bytes starting from a given offset.

fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> Result<(), Error>

Reads the exact number of byte required to fill buf from the given offset.

fn write_all_at(&self, buf: &[u8], offset: u64) -> Result<(), Error>

Attempts to write an entire buffer starting from a given offset.

impl From<MemFile> for Stdio

fn from(other: MemFile) -> Self

Performs the conversion.

impl FromRawFd for MemFile

unsafe fn from_raw_fd(fd: RawFd) -> Self

Constructs a new instance of Self from the given raw file descriptor.

impl IntoRawFd for MemFile

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.

impl Read for MemFile

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adapter which will read at most limit bytes from it.

impl Seek for MemFile

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬 This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

impl Write for MemFile

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adapter for this instance of Write.