Commit 0a41f5af authored by Panagiotis Foliadis's avatar Panagiotis Foliadis Committed by Boqun Feng
Browse files

rust: task: Mark Task methods inline 

When building the kernel using the llvm-18.1.3-rust-1.85.0-x86_64
toolchain provided by kernel.org, the following symbols are generated:

$ nm vmlinux | grep ' _R'.*Task | rustfilt
... T <kernel::task::Task>::get_pid_ns
... T <kernel::task::Task>::tgid_nr_ns
... T <kernel::task::Task>::current_pid_ns
... T <kernel::task::Task>::signal_pending
... T <kernel::task::Task>::uid
... T <kernel::task::Task>::euid
... T <kernel::task::Task>::current
... T <kernel::task::Task>::wake_up
... T <kernel::task::Task as kernel::types::AlwaysRefCounted>::dec_ref
... T <kernel::task::Task as kernel::types::AlwaysRefCounted>::inc_ref

These Rust symbols are trivial wrappers around the C functions. It
doesn't make sense to go through a trivial wrapper for these functions,
so mark them inline.

[boqun: Capitalize the title, reword a bit to avoid listing all the C
functions as the code already shows them and remove the addresses of the
symbols in the commit log as they are different from build to build.]

Link: https://github.com/Rust-for-Linux/linux/issues/1145


Reviewed-by: default avatarBenno Lossin <benno.lossin@proton.me>
Reviewed-by: default avatarChristian Schrefl <chrisi.schrefl@gmail.com>
Reviewed-by: default avatarCharalampos Mitrodimas <charmitro@posteo.net>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Signed-off-by: default avatarPanagiotis Foliadis <pfoliadis@posteo.net>
Signed-off-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Link: https://lore.kernel.org/r/20250315-inline-c-wrappers-v3-1-048e43fcef7d@posteo.net
parent 11867144

rust/kernel/task.rs

+9 −0
Original line number Diff line number Diff line
@@ -173,6 +173,7 @@ pub fn current_raw() -> *mut bindings::task_struct { 
    /// Callers must ensure that the returned object is only used to access a [`CurrentTask`]

    /// within the task context that was active when this function was called. For more details,

    /// see the invariants section for [`CurrentTask`].

    #[inline]

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

        struct TaskRef {

            task: *const CurrentTask,
@@ -222,24 +223,28 @@ pub fn pid(&self) -> Pid { 
    }



    /// Returns the UID of the given task.

    #[inline]

    pub fn uid(&self) -> Kuid {

        // SAFETY: It's always safe to call `task_uid` on a valid task.

        Kuid::from_raw(unsafe { bindings::task_uid(self.as_ptr()) })

    }



    /// Returns the effective UID of the given task.

    #[inline]

    pub fn euid(&self) -> Kuid {

        // SAFETY: It's always safe to call `task_euid` on a valid task.

        Kuid::from_raw(unsafe { bindings::task_euid(self.as_ptr()) })

    }



    /// Determines whether the given task has pending signals.

    #[inline]

    pub fn signal_pending(&self) -> bool {

        // SAFETY: It's always safe to call `signal_pending` on a valid task.

        unsafe { bindings::signal_pending(self.as_ptr()) != 0 }

    }



    /// Returns task's pid namespace with elevated reference count

    #[inline]

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

        // SAFETY: By the type invariant, we know that `self.0` is valid.

        let ptr = unsafe { bindings::task_get_pid_ns(self.as_ptr()) };
@@ -255,6 +260,7 @@ pub fn get_pid_ns(&self) -> Option<ARef<PidNamespace>> { 


    /// Returns the given task's pid in the provided pid namespace.

    #[doc(alias = "task_tgid_nr_ns")]

    #[inline]

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

        let pidns = match pidns {

            Some(pidns) => pidns.as_ptr(),
@@ -268,6 +274,7 @@ pub fn tgid_nr_ns(&self, pidns: Option<&PidNamespace>) -> Pid { 
    }



    /// Wakes up the task.

    #[inline]

    pub fn wake_up(&self) {

        // SAFETY: It's always safe to call `wake_up_process` on a valid task, even if the task

        // running.
@@ -341,11 +348,13 @@ pub fn active_pid_ns(&self) -> Option<&PidNamespace> { 


// SAFETY: The type invariants guarantee that `Task` is always refcounted.

unsafe impl crate::types::AlwaysRefCounted for Task {

    #[inline]

    fn inc_ref(&self) {

        // SAFETY: The existence of a shared reference means that the refcount is nonzero.

        unsafe { bindings::get_task_struct(self.as_ptr()) };

    }



    #[inline]

    unsafe fn dec_ref(obj: ptr::NonNull<Self>) {

        // SAFETY: The safety requirements guarantee that the refcount is nonzero.

        unsafe { bindings::put_task_struct(obj.cast().as_ptr()) }