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 memfd 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 try_clone(&self) -> Result<Self>

Try to create a new MemFile Createinstance that shares the same underlying file handle as the existing MemFile instance.

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 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.

pub 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.

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

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

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.

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

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

pub 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.

pub 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.

pub 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.

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

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

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

Read the exact number of bytes required to fill buf.

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

Creates a "by reference" adaptor for this instance of Read.

pub fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adaptor which will chain this stream with another.

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

Creates an adaptor 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.

pub 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).

pub 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.

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

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

pub 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.

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

Attempts to write an entire buffer into this writer.

pub 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.

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

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

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

Creates a "by reference" adaptor for this instance of Write.