Struct Task

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 refcounted, 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 fn current_raw() -> *mut task_struct

Returns a raw pointer to the current task.

It is up to the user to use the pointer correctly.

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 unsafe fn current_pid_ns() -> impl Deref<Target = PidNamespace>

Returns a PidNamespace reference for the currently executing task’s/thread’s pid namespace.

This function can be used to create an unbounded lifetime by e.g., storing the returned PidNamespace in a global variable which would be a bug. So the recommended way to get the current task’s/thread’s pid namespace is to use the current_pid_ns macro because it is safe.

Safety

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

pub fn as_ptr(&self) -> *mut task_struct

Returns a raw pointer to the task.

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 uid(&self) -> Kuid

Returns the UID of the given task.

pub fn euid(&self) -> Kuid

Returns the effective UID of the given task.

pub fn signal_pending(&self) -> bool

Determines whether the given task has pending signals.

pub fn get_pid_ns(&self) -> Option<ARef<PidNamespace>>

Returns task’s pid namespace with elevated reference count

pub fn tgid_nr_ns(&self, pidns: Option<&PidNamespace>) -> pid_t

Returns the given task’s pid in the provided pid namespace.

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