Struct memfd::Memfd

pub struct Memfd { /* private fields */ }

Available on Android or Linux only.

An anonymous volatile file, with sealing capabilities.

Implementations

impl Memfd

pub fn try_from_fd<F>(fd: F) -> Result<Self, F>where F: AsRawFd + IntoRawFd,

Try to convert an object that owns a file descriptor into a Memfd.

This function consumes the ownership of the specified object. If the underlying file-descriptor is compatible with memfd/sealing, a Memfd object is returned. Otherwise the supplied object is returned as error.

pub fn try_from_file(file: File) -> Result<Self, File>

Try to convert a File object into a Memfd.

This function consumes the ownership of the specified File. If the underlying file-descriptor is compatible with memfd/sealing, a Memfd object is returned. Otherwise the supplied File is returned for further usage.

pub const fn as_file(&self) -> &File

Return a reference to the backing File.

Examples found in repository

examples/sized.rs (line 18)

fn main() {
    // Create a sealable memfd.
    let opts = memfd::MemfdOptions::default().allow_sealing(true);
    let mfd = opts.create("sized-1K").unwrap();

    // Resize to 1024B.
    mfd.as_file().set_len(1024).unwrap();

    // Add seals to prevent further resizing.
    mfd.add_seals(&[
        memfd::FileSeal::SealShrink,
        memfd::FileSeal::SealGrow
    ]).unwrap();

    // Prevent further sealing changes.
    mfd.add_seal(memfd::FileSeal::SealSeal).unwrap();

    // Write 1K of data, allowed by size seals.
    let data_1k = vec![0x00; 1024];
    let r = mfd.as_file().write_all(&data_1k);
    assert!(r.is_ok());
    mfd.as_file().seek(SeekFrom::Start(0)).unwrap();

    // Write 2K of data, now allowed by size seals.
    let data_2k = vec![0x11; 2048];
    let r = mfd.as_file().write_all(&data_2k);
    assert!(r.is_err());
    mfd.as_file().seek(SeekFrom::Start(0)).unwrap();

    // Try to resize to 2048B, not allowed by size seals.
    let r = mfd.as_file().set_len(2048);
    assert!(r.is_err());

    // Overwrite 1K of data, allowed by size seals.
    let data_1k = vec![0x22; 1024];
    let r = mfd.as_file().write_all(&data_1k);
    assert!(r.is_ok());
}

pub fn into_file(self) -> File

Convert Memfd to the backing File.

pub fn seals(&self) -> Result<SealsHashSet, Error>

Obtain the current set of seals for the Memfd.

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

Add a seal to the existing set of seals.

Examples found in repository

examples/sized.rs (line 27)

fn main() {
    // Create a sealable memfd.
    let opts = memfd::MemfdOptions::default().allow_sealing(true);
    let mfd = opts.create("sized-1K").unwrap();

    // Resize to 1024B.
    mfd.as_file().set_len(1024).unwrap();

    // Add seals to prevent further resizing.
    mfd.add_seals(&[
        memfd::FileSeal::SealShrink,
        memfd::FileSeal::SealGrow
    ]).unwrap();

    // Prevent further sealing changes.
    mfd.add_seal(memfd::FileSeal::SealSeal).unwrap();

    // Write 1K of data, allowed by size seals.
    let data_1k = vec![0x00; 1024];
    let r = mfd.as_file().write_all(&data_1k);
    assert!(r.is_ok());
    mfd.as_file().seek(SeekFrom::Start(0)).unwrap();

    // Write 2K of data, now allowed by size seals.
    let data_2k = vec![0x11; 2048];
    let r = mfd.as_file().write_all(&data_2k);
    assert!(r.is_err());
    mfd.as_file().seek(SeekFrom::Start(0)).unwrap();

    // Try to resize to 2048B, not allowed by size seals.
    let r = mfd.as_file().set_len(2048);
    assert!(r.is_err());

    // Overwrite 1K of data, allowed by size seals.
    let data_1k = vec![0x22; 1024];
    let r = mfd.as_file().write_all(&data_1k);
    assert!(r.is_ok());
}

pub fn add_seals<'a>( &self, seals: impl IntoIterator<Item = &'a FileSeal> ) -> Result<(), Error>

Add some seals to the existing set of seals.

Examples found in repository

examples/sized.rs (lines 21-24)

fn main() {
    // Create a sealable memfd.
    let opts = memfd::MemfdOptions::default().allow_sealing(true);
    let mfd = opts.create("sized-1K").unwrap();

    // Resize to 1024B.
    mfd.as_file().set_len(1024).unwrap();

    // Add seals to prevent further resizing.
    mfd.add_seals(&[
        memfd::FileSeal::SealShrink,
        memfd::FileSeal::SealGrow
    ]).unwrap();

    // Prevent further sealing changes.
    mfd.add_seal(memfd::FileSeal::SealSeal).unwrap();

    // Write 1K of data, allowed by size seals.
    let data_1k = vec![0x00; 1024];
    let r = mfd.as_file().write_all(&data_1k);
    assert!(r.is_ok());
    mfd.as_file().seek(SeekFrom::Start(0)).unwrap();

    // Write 2K of data, now allowed by size seals.
    let data_2k = vec![0x11; 2048];
    let r = mfd.as_file().write_all(&data_2k);
    assert!(r.is_err());
    mfd.as_file().seek(SeekFrom::Start(0)).unwrap();

    // Try to resize to 2048B, not allowed by size seals.
    let r = mfd.as_file().set_len(2048);
    assert!(r.is_err());

    // Overwrite 1K of data, allowed by size seals.
    let data_1k = vec![0x22; 1024];
    let r = mfd.as_file().write_all(&data_1k);
    assert!(r.is_ok());
}

Trait Implementations

impl AsRawFd for Memfd

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for Memfd

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

Formats the value using the given formatter.

impl FromRawFd for Memfd

unsafe fn from_raw_fd(fd: RawFd) -> Self

Convert a raw file-descriptor to a Memfd.

This function consumes ownership of the specified file descriptor. Memfd will take responsibility for closing it when the object goes out of scope.

Safety

fd must be a valid file descriptor representing a memfd file.

impl IntoRawFd for Memfd

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.