Struct ThreadedRegistration 

pub struct ThreadedRegistration<'a, T: ThreadedHandler> { /* private fields */ }

A registration of a threaded IRQ handler for a given IRQ line.

Two callbacks are required: one to handle the IRQ, and one to handle any other work in a separate thread.

The thread handler is only called if the IRQ handler returns ThreadedIrqReturn::WakeThread.

Examples

The following is an example of using ThreadedRegistration. It uses a Mutex to provide interior mutability.

use core::pin::Pin;
use kernel::{
    irq::{
        self,
        Flags,
        IrqRequest,
        IrqReturn,
        ThreadedHandler,
        ThreadedIrqReturn,
        ThreadedRegistration,
    },
    prelude::*,
    sync::Mutex,
};

// Declare a struct that will be passed in when the interrupt fires. The u32
// merely serves as an example of some internal data.
//
// [`irq::ThreadedHandler::handle`] takes `&self`. This example
// illustrates how interior mutability can be used when sharing the data
// between process context and IRQ context.
#[pin_data]
struct Data {
    #[pin]
    value: Mutex<u32>,
}

impl ThreadedHandler for Data {
    // This will run (in a separate kthread) if and only if
    // [`ThreadedHandler::handle`] returns [`WakeThread`], which it does by
    // default.
    fn handle_threaded(&self) -> IrqReturn {
        let mut data = self.value.lock();
        *data += 1;
        IrqReturn::Handled
    }
}

// Registers a threaded IRQ handler for the given [`IrqRequest`].
//
// This is executing in process context and assumes that `request` was
// previously acquired from a device.
fn register_threaded_irq(
    request: IrqRequest<'_>,
) -> Result<Pin<KBox<ThreadedRegistration<'_, Data>>>> {
    // SAFETY: The returned Registration is not leaked.
    let registration = unsafe {
        ThreadedRegistration::new(
            request,
            Flags::SHARED,
            c"my_device",
            try_pin_init!(Data {
                value <- kernel::new_mutex!(0),
            }? Error),
        )
    };

    let registration = KBox::pin_init(registration, GFP_KERNEL)?;

    {
        // The data can be accessed from process context too.
        let mut data = registration.handler().value.lock();
        *data += 1;
    }

    Ok(registration)
}

Invariants

• We own an irq handler registered via request_threaded_irq whose cookie is a pointer to Self.

Implementations

impl<'a, T: ThreadedHandler> ThreadedRegistration<'a, T>

pub fn project<'__pin>( self: Pin<&'__pin mut Self>, ) -> ThreadedRegistrationProjection<'__pin, 'a, T>

Pin-projects all fields of Self.

These fields are structurally pinned:

• handler
• _pin

These fields are not structurally pinned:

• request

impl<'a, T: ThreadedHandler> ThreadedRegistration<'a, T>

pub unsafe fn new( request: IrqRequest<'a>, flags: Flags, name: &'static CStr, handler: impl PinInit<T, Error> + 'a, ) -> impl PinInit<Self, Error> + 'a

where T: 'a,

Registers the IRQ handler with the system for the given IRQ number.

Safety

Callers must not mem::forget() the returned ThreadedRegistration or otherwise prevent its Drop implementation from running.

pub fn handler(&self) -> &T

Returns a reference to the handler that was registered with the system.

pub fn synchronize(&self)

Wait for pending IRQ handlers on other CPUs.

Trait Implementations

impl<'a, T: ThreadedHandler> Drop for ThreadedRegistration<'a, T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<'a, T: ThreadedHandler> HasPinData for ThreadedRegistration<'a, T>

type PinData = __ThePinData<'a, T>

unsafe fn __pin_data() -> Self::PinData

impl<T: ThreadedHandler> PinnedDrop for ThreadedRegistration<'_, T>

fn drop(self: Pin<&mut Self>, _: OnlyCallFromDrop)

Executes the pinned destructor of this type.