Struct ModUnloader

pub struct ModUnloader { /* private fields */ }

Module unloader.

Asynchronous methods can be enabled via the optional async feature.

Implementations

impl ModUnloader

pub fn new() -> Self

Create a new default ModLoader.

Examples found in repository

examples/async-unload.rs (line 23)

fn main() {
    // Get from cmdline the name of the module to unload.
    let modname = std::env::args().nth(1).expect("missing module name");

    // Assemble a future to unload the module; if busy,
    // retry every 500ms and time out after 5 seconds.
    let pause_ms = num::NonZeroU64::new(500).unwrap();
    let modunload = likemod::ModUnloader::new().unload_async(&modname, pause_ms);
    let tout = time::Duration::from_secs(15);
    let fut = timeout::Timeout::new(modunload, tout);

    // Run the future until completion.
    if let Err(err) = current_thread::block_on_all(fut) {
        eprintln!("FAILED: {:?}", err);
        process::exit(1)
    }

    // Success!
    println!("module '{}' unloaded.", modname);
}

pub fn forced(self, force_unload: bool) -> Self

Set whether a forced unload should be performed.

A force unload will taint the kernel and can leave the host in an unstable state, or cause data loss.

pub fn unload_sync<S: AsRef<str>>( &self, modname: S, blocking: bool, ) -> Result<()>

Unload module by name, synchronously.

If blocking is enabled, this can block at syscall level (putting the process in D state) while waiting for module reference count to be 0 for clean unloading (unless forced).

It is usually recommended not to set blocking, as the process cannot be killed while blocked on syscall. Consider using unload_async instead.

pub fn unload_async<S: AsRef<str>>( &self, modname: S, pause_millis: NonZeroU64, ) -> Box<dyn Future<Item = (), Error = Error>>

Unload module by name, asynchronously.

If the module is currently in use, this will continuously retry unloading at fixed intervals after pausing for the specified amount of milliseconds. This requires enabling the async optional feature.

Examples found in repository

examples/async-unload.rs (line 23)

fn main() {
    // Get from cmdline the name of the module to unload.
    let modname = std::env::args().nth(1).expect("missing module name");

    // Assemble a future to unload the module; if busy,
    // retry every 500ms and time out after 5 seconds.
    let pause_ms = num::NonZeroU64::new(500).unwrap();
    let modunload = likemod::ModUnloader::new().unload_async(&modname, pause_ms);
    let tout = time::Duration::from_secs(15);
    let fut = timeout::Timeout::new(modunload, tout);

    // Run the future until completion.
    if let Err(err) = current_thread::block_on_all(fut) {
        eprintln!("FAILED: {:?}", err);
        process::exit(1)
    }

    // Success!
    println!("module '{}' unloaded.", modname);
}

Trait Implementations

impl Clone for ModUnloader

fn clone(&self) -> ModUnloader

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ModUnloader

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

Formats the value using the given formatter.

impl Default for ModUnloader

fn default() -> Self

Returns the “default value” for a type.