Struct kernel::task::Task

#[repr(transparent)]
pub struct Task(/* private fields */);

Wraps the kernel’s struct task_struct.

Invariants

All instances are valid tasks created by the C portion of the kernel.

Instances of this type are always ref-counted, that is, a call to get_task_struct ensures that the allocation remains valid at least until the matching call to put_task_struct.

Examples

The following is an example of getting the PID of the current thread with zero additional cost when compared to the C version:

let pid = current!().pid();

Getting the PID of the current process, also zero additional cost:

let pid = current!().group_leader().pid();

Getting the current task and storing it in some struct. The reference count is automatically incremented when creating State and decremented when it is dropped:

use kernel::{task::Task, types::ARef};

struct State {
    creator: ARef<Task>,
    index: u32,
}

impl State {
    fn new() -> Self {
        Self {
            creator: current!().into(),
            index: 0,
        }
    }
}

Implementations

impl Task

pub unsafe fn current() -> impl Deref<Target = Task>

Returns a task reference for the currently executing task/thread.

The recommended way to get the current task/thread is to use the current macro because it is safe.

Safety

Callers must ensure that the returned object doesn’t outlive the current task/thread.

pub fn group_leader(&self) -> &Task

Returns the group leader of the given task.

pub fn pid(&self) -> pid_t

Returns the PID of the given task.

pub fn signal_pending(&self) -> bool

Determines whether the given task has pending signals.

pub fn wake_up(&self)

Wakes up the task.

Trait Implementations

impl AlwaysRefCounted for Task

fn inc_ref(&self)

Increments the reference count on the object.

unsafe fn dec_ref(obj: NonNull<Self>)

Decrements the reference count on the object.

impl Send for Task

impl Sync for Task