Struct Completion

pub struct Completion { /* private fields */ }

Synchronization primitive to signal when a certain task has been completed.

The Completion synchronization primitive signals when a certain task has been completed by waking up other tasks that have been queued up to wait for the Completion to be completed.

Examples

use kernel::sync::{Arc, Completion};
use kernel::workqueue::{self, impl_has_work, new_work, Work, WorkItem};

#[pin_data]
struct MyTask {
    #[pin]
    work: Work<MyTask>,
    #[pin]
    done: Completion,
}

impl_has_work! {
    impl HasWork<Self> for MyTask { self.work }
}

impl MyTask {
    fn new() -> Result<Arc<Self>> {
        let this = Arc::pin_init(pin_init!(MyTask {
            work <- new_work!("MyTask::work"),
            done <- Completion::new(),
        }), GFP_KERNEL)?;

        let _ = workqueue::system().enqueue(this.clone());

        Ok(this)
    }

    fn wait_for_completion(&self) {
        self.done.wait_for_completion();

        pr_info!("Completion: task complete\n");
    }
}

impl WorkItem for MyTask {
    type Pointer = Arc<MyTask>;

    fn run(this: Arc<MyTask>) {
        // process this task
        this.done.complete_all();
    }
}

let task = MyTask::new()?;
task.wait_for_completion();

Implementations

impl Completion

pub fn new() -> impl PinInit<Self>

Create an initializer for a new Completion.

pub fn complete_all(&self)

Signal all tasks waiting on this completion.

This method wakes up all tasks waiting on this completion; after this operation the completion is permanently done, i.e. signals all current and future waiters.

pub fn wait_for_completion(&self)

Wait for completion of a task.

This method waits for the completion of a task; it is not interruptible and there is no timeout.

See also Completion::complete_all.

Trait Implementations

impl HasPinData for Completion

type PinData = __ThePinData

unsafe fn __pin_data() -> Self::PinData

impl Send for Completion

impl Sync for Completion