Struct userfaultfd::Uffd[−][src]

pub struct Uffd { /* fields omitted */ }

Expand description

The userfaultfd object.

The userspace representation of the object is a file descriptor, so this type implements AsRawFd, FromRawFd, and IntoRawFd. These methods should be used with caution, but can be essential for using functions like poll on a worker thread.

Implementations

[src]

impl Uffd

[src]

pub fn register(&self, start: *mut c_void, len: usize) -> Result<IoctlFlags>

Register a memory address range with the userfaultfd object, and returns the IoctlFlags that are available for the selected range.

This method only registers the given range for missing page faults.

[src]

pub fn register_with_mode(
 &self,
 start: *mut c_void,
 len: usize,
 mode: RegisterMode
) -> Result<IoctlFlags>

Register a memory address range with the userfaultfd object for the given mode and returns the IoctlFlags that are available for the selected range.

[src]

pub fn unregister(&self, start: *mut c_void, len: usize) -> Result<()>

Unregister a memory address range from the userfaultfd object.

[src]

pub unsafe fn copy(
 &self,
 src: const c_void,
 dst: mut c_void,
 len: usize,
 wake: bool
) -> Result<usize>

Atomically copy a continuous memory chunk into the userfaultfd-registered range, and return the number of bytes that were successfully copied.

If wake is true, wake up the thread waiting for page fault resolution on the memory range.

[src]

pub unsafe fn zeropage(
 &self,
 start: *mut c_void,
 len: usize,
 wake: bool
) -> Result<usize>

Zero out a memory address range registered with userfaultfd, and return the number of bytes that were successfully zeroed.

If wake is true, wake up the thread waiting for page fault resolution on the memory address range.

[src]

pub fn wake(&self, start: *mut c_void, len: usize) -> Result<()>

Wake up the thread waiting for page fault resolution on the specified memory address range.

[src]

pub fn read_event(&self) -> Result<Option<Event>>

Read an Event from the userfaultfd object.

If the Uffd object was created with non_blocking set to false, this will block until an event is successfully read (returning Some(event), or an error is returned.

If non_blocking was true, this will immediately return None if no event is ready to read.

Note that while this method doesn’t require a mutable reference to the Uffd object, it does consume bytes (thread-safely) from the underlying file descriptor.

Examples

fn read_event(uffd: &Uffd) -> Result<()> {
    // Read a single event
    match uffd.read_event()? {
        Some(e) => {
            // Do something with the event
        },
        None => {
            // This was a non-blocking read and the descriptor was not ready for read
        },
    }
    Ok(())
}

[src]

pub fn read_events<'a>(
&self,
buf: &'a mut EventBuffer
) -> Result<impl Iterator<Item = Result<Event>> + 'a>

Read multiple events from the userfaultfd object using the given event buffer.

If the Uffd object was created with non_blocking set to false, this will block until an event is successfully read or an error is returned.

If non_blocking was true, this will immediately return an empty iterator if the file descriptor is not ready for reading.

Examples

fn read_events(uffd: &Uffd) -> userfaultfd::Result<()> {
    // Read up to 100 events at a time
    let mut buf = EventBuffer::new(100);
    for event in uffd.read_events(&mut buf)? {
        let event = event?;
        // Do something with the event...
    }
    Ok(())
}