[v3,10/13] rust: introduce `current`

  From: Wedson Almeida Filho <walmeida@microsoft.com>

This allows Rust code to get a reference to the current task without
having to increment the refcount, but still guaranteeing memory safety.

Cc: Ingo Molnar <mingo@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Signed-off-by: Wedson Almeida Filho <walmeida@microsoft.com>
---
v1 -> v2: Make `current` a macro to prevent it from escaping the caller
v2 -> v3:
- Mention `current` macro in `Task::current`
- Hide implementation of `TaskRef` inside `Task::current`

 rust/helpers.c         |  6 +++
 rust/kernel/prelude.rs |  2 +
 rust/kernel/task.rs    | 88 +++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 95 insertions(+), 1 deletion(-)
  

On 4/8/23 04:53, Wedson Almeida Filho wrote:
> From: Wedson Almeida Filho <walmeida@microsoft.com>
> 
> This allows Rust code to get a reference to the current task without
> having to increment the refcount, but still guaranteeing memory safety.
> 
> Cc: Ingo Molnar <mingo@redhat.com>
> Cc: Peter Zijlstra <peterz@infradead.org>
> Signed-off-by: Wedson Almeida Filho <walmeida@microsoft.com>
> ---
> v1 -> v2: Make `current` a macro to prevent it from escaping the caller
> v2 -> v3:
> - Mention `current` macro in `Task::current`
> - Hide implementation of `TaskRef` inside `Task::current`
> 
>  rust/helpers.c         |  6 +++
>  rust/kernel/prelude.rs |  2 +
>  rust/kernel/task.rs    | 88 +++++++++++++++++++++++++++++++++++++++++-
>  3 files changed, 95 insertions(+), 1 deletion(-)
> 
> diff --git a/rust/helpers.c b/rust/helpers.c
> index 58a194042c86..96441744030e 100644
> --- a/rust/helpers.c
> +++ b/rust/helpers.c
> @@ -100,6 +100,12 @@ bool rust_helper_refcount_dec_and_test(refcount_t *r)
>  }
>  EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test);
>  
> +struct task_struct *rust_helper_get_current(void)
> +{
> +	return current;
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_get_current);
> +
>  void rust_helper_get_task_struct(struct task_struct *t)
>  {
>  	get_task_struct(t);
> diff --git a/rust/kernel/prelude.rs b/rust/kernel/prelude.rs
> index fcdc511d2ce8..c28587d68ebc 100644
> --- a/rust/kernel/prelude.rs
> +++ b/rust/kernel/prelude.rs
> @@ -36,3 +36,5 @@ pub use super::error::{code::*, Error, Result};
>  pub use super::{str::CStr, ThisModule};
>  
>  pub use super::init::{InPlaceInit, Init, PinInit};
> +
> +pub use super::current;
> diff --git a/rust/kernel/task.rs b/rust/kernel/task.rs
> index d70cad131956..5269a562cb1b 100644
> --- a/rust/kernel/task.rs
> +++ b/rust/kernel/task.rs
> @@ -5,7 +5,17 @@
>  //! C header: [`include/linux/sched.h`](../../../../include/linux/sched.h).
>  
>  use crate::{bindings, types::Opaque};
> -use core::ptr;
> +use core::{marker::PhantomData, ops::Deref, ptr};
> +
> +/// Returns the currently running task.
> +#[macro_export]
> +macro_rules! current {
> +    () => {
> +        // SAFETY: Deref + addr-of below create a temporary `TaskRef` that cannot outlive the
> +        // caller.
> +        unsafe { &*$crate::task::Task::current() }
> +    };
> +}
>  
>  /// Wraps the kernel's `struct task_struct`.
>  ///
> @@ -15,6 +25,42 @@ use core::ptr;
>  ///
>  /// 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,
> +///         }
> +///     }
> +/// }
> +/// ```
>  #[repr(transparent)]
>  pub struct Task(pub(crate) Opaque<bindings::task_struct>);
>  
> @@ -27,6 +73,46 @@ unsafe impl Sync for Task {}
>  type Pid = bindings::pid_t;
>  
>  impl 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`](crate::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() -> impl Deref<Target = Task> {
> +        pub struct TaskRef<'a> {
> +            task: &'a Task,
> +            _not_send: PhantomData<*mut ()>,
> +        }

I'd had named this as `CurrentTaskRef`, but since this is not exposed to
users then there are no problems whatsoever.

> +
> +        impl Deref for TaskRef<'_> {
> +            type Target = Task;
> +
> +            fn deref(&self) -> &Self::Target {
> +                self.task
> +            }
> +        }
> +
> +        impl From<TaskRef<'_>> for crate::types::ARef<Task> {
> +            fn from(t: TaskRef<'_>) -> Self {
> +                t.deref().into()
> +            }
> +        }
> +
> +        // SAFETY: Just an FFI call with no additional safety requirements.
> +        let ptr = unsafe { bindings::get_current() };
> +
> +        TaskRef {
> +            // SAFETY: If the current thread is still running, the current task is valid. Given
> +            // that `TaskRef` is not `Send`, we know it cannot be transferred to another thread
> +            // (where it could potentially outlive the caller).
> +            task: unsafe { &*ptr.cast() },
> +            _not_send: PhantomData,
> +        }
> +    }
> +
>      /// Returns the group leader of the given task.
>      pub fn group_leader(&self) -> &Task {
>          // SAFETY: By the type invariant, we know that `self.0` is a valid task. Valid tasks always

Reviewed-by: Martin Rodriguez Reboredo <yakoyoku@gmail.com>
  

On 08.04.23 09:53, Wedson Almeida Filho wrote:
> From: Wedson Almeida Filho <walmeida@microsoft.com>
>
> This allows Rust code to get a reference to the current task without
> having to increment the refcount, but still guaranteeing memory safety.
>
> Cc: Ingo Molnar <mingo@redhat.com>
> Cc: Peter Zijlstra <peterz@infradead.org>
> Signed-off-by: Wedson Almeida Filho <walmeida@microsoft.com>
> ---
> v1 -> v2: Make `current` a macro to prevent it from escaping the caller
> v2 -> v3:
> - Mention `current` macro in `Task::current`
> - Hide implementation of `TaskRef` inside `Task::current`
>
>   rust/helpers.c         |  6 +++
>   rust/kernel/prelude.rs |  2 +
>   rust/kernel/task.rs    | 88 +++++++++++++++++++++++++++++++++++++++++-
>   3 files changed, 95 insertions(+), 1 deletion(-)
>
> diff --git a/rust/helpers.c b/rust/helpers.c
> index 58a194042c86..96441744030e 100644
> --- a/rust/helpers.c
> +++ b/rust/helpers.c
> @@ -100,6 +100,12 @@ bool rust_helper_refcount_dec_and_test(refcount_t *r)
>   }
>   EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test);
>
> +struct task_struct *rust_helper_get_current(void)
> +{
> +	return current;
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_get_current);
> +
>   void rust_helper_get_task_struct(struct task_struct *t)
>   {
>   	get_task_struct(t);
> diff --git a/rust/kernel/prelude.rs b/rust/kernel/prelude.rs
> index fcdc511d2ce8..c28587d68ebc 100644
> --- a/rust/kernel/prelude.rs
> +++ b/rust/kernel/prelude.rs
> @@ -36,3 +36,5 @@ pub use super::error::{code::*, Error, Result};
>   pub use super::{str::CStr, ThisModule};
>
>   pub use super::init::{InPlaceInit, Init, PinInit};
> +
> +pub use super::current;
> diff --git a/rust/kernel/task.rs b/rust/kernel/task.rs
> index d70cad131956..5269a562cb1b 100644
> --- a/rust/kernel/task.rs
> +++ b/rust/kernel/task.rs
> @@ -5,7 +5,17 @@
>   //! C header: [`include/linux/sched.h`](../../../../include/linux/sched.h).
>
>   use crate::{bindings, types::Opaque};
> -use core::ptr;
> +use core::{marker::PhantomData, ops::Deref, ptr};
> +
> +/// Returns the currently running task.
> +#[macro_export]
> +macro_rules! current {
> +    () => {
> +        // SAFETY: Deref + addr-of below create a temporary `TaskRef` that cannot outlive the
> +        // caller.
> +        unsafe { &*$crate::task::Task::current() }
> +    };
> +}
>
>   /// Wraps the kernel's `struct task_struct`.
>   ///
> @@ -15,6 +25,42 @@ use core::ptr;
>   ///
>   /// 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,
> +///         }
> +///     }
> +/// }
> +/// ```
>   #[repr(transparent)]
>   pub struct Task(pub(crate) Opaque<bindings::task_struct>);
>
> @@ -27,6 +73,46 @@ unsafe impl Sync for Task {}
>   type Pid = bindings::pid_t;
>
>   impl 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`](crate::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() -> impl Deref<Target = Task> {
> +        pub struct TaskRef<'a> {
> +            task: &'a Task,
> +            _not_send: PhantomData<*mut ()>,
> +        }
> +
> +        impl Deref for TaskRef<'_> {
> +            type Target = Task;
> +
> +            fn deref(&self) -> &Self::Target {
> +                self.task
> +            }
> +        }
> +
> +        impl From<TaskRef<'_>> for crate::types::ARef<Task> {
> +            fn from(t: TaskRef<'_>) -> Self {
> +                t.deref().into()
> +            }
> +        }

I think we can remove this `From` impl, since the type is never exposed
to the outside (there still is the `From<&T> for ARef<T>` impl, so users
can still do `current!().into()` to get an `ARef<Task>`).

--
Cheers,
Benno

> +
> +        // SAFETY: Just an FFI call with no additional safety requirements.
> +        let ptr = unsafe { bindings::get_current() };
> +
> +        TaskRef {
> +            // SAFETY: If the current thread is still running, the current task is valid. Given
> +            // that `TaskRef` is not `Send`, we know it cannot be transferred to another thread
> +            // (where it could potentially outlive the caller).
> +            task: unsafe { &*ptr.cast() },
> +            _not_send: PhantomData,
> +        }
> +    }
> +
>       /// Returns the group leader of the given task.
>       pub fn group_leader(&self) -> &Task {
>           // SAFETY: By the type invariant, we know that `self.0` is a valid task. Valid tasks always
> --
> 2.34.1
>
  

On Mon, 10 Apr 2023 at 15:05, Benno Lossin <y86-dev@protonmail.com> wrote:
>
> On 08.04.23 09:53, Wedson Almeida Filho wrote:
> > From: Wedson Almeida Filho <walmeida@microsoft.com>
> >
> > This allows Rust code to get a reference to the current task without
> > having to increment the refcount, but still guaranteeing memory safety.
> >
> > Cc: Ingo Molnar <mingo@redhat.com>
> > Cc: Peter Zijlstra <peterz@infradead.org>
> > Signed-off-by: Wedson Almeida Filho <walmeida@microsoft.com>
> > ---
> > v1 -> v2: Make `current` a macro to prevent it from escaping the caller
> > v2 -> v3:
> > - Mention `current` macro in `Task::current`
> > - Hide implementation of `TaskRef` inside `Task::current`
> >
> >   rust/helpers.c         |  6 +++
> >   rust/kernel/prelude.rs |  2 +
> >   rust/kernel/task.rs    | 88 +++++++++++++++++++++++++++++++++++++++++-
> >   3 files changed, 95 insertions(+), 1 deletion(-)
> >
> > diff --git a/rust/helpers.c b/rust/helpers.c
> > index 58a194042c86..96441744030e 100644
> > --- a/rust/helpers.c
> > +++ b/rust/helpers.c
> > @@ -100,6 +100,12 @@ bool rust_helper_refcount_dec_and_test(refcount_t *r)
> >   }
> >   EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test);
> >
> > +struct task_struct *rust_helper_get_current(void)
> > +{
> > +     return current;
> > +}
> > +EXPORT_SYMBOL_GPL(rust_helper_get_current);
> > +
> >   void rust_helper_get_task_struct(struct task_struct *t)
> >   {
> >       get_task_struct(t);
> > diff --git a/rust/kernel/prelude.rs b/rust/kernel/prelude.rs
> > index fcdc511d2ce8..c28587d68ebc 100644
> > --- a/rust/kernel/prelude.rs
> > +++ b/rust/kernel/prelude.rs
> > @@ -36,3 +36,5 @@ pub use super::error::{code::*, Error, Result};
> >   pub use super::{str::CStr, ThisModule};
> >
> >   pub use super::init::{InPlaceInit, Init, PinInit};
> > +
> > +pub use super::current;
> > diff --git a/rust/kernel/task.rs b/rust/kernel/task.rs
> > index d70cad131956..5269a562cb1b 100644
> > --- a/rust/kernel/task.rs
> > +++ b/rust/kernel/task.rs
> > @@ -5,7 +5,17 @@
> >   //! C header: [`include/linux/sched.h`](../../../../include/linux/sched.h).
> >
> >   use crate::{bindings, types::Opaque};
> > -use core::ptr;
> > +use core::{marker::PhantomData, ops::Deref, ptr};
> > +
> > +/// Returns the currently running task.
> > +#[macro_export]
> > +macro_rules! current {
> > +    () => {
> > +        // SAFETY: Deref + addr-of below create a temporary `TaskRef` that cannot outlive the
> > +        // caller.
> > +        unsafe { &*$crate::task::Task::current() }
> > +    };
> > +}
> >
> >   /// Wraps the kernel's `struct task_struct`.
> >   ///
> > @@ -15,6 +25,42 @@ use core::ptr;
> >   ///
> >   /// 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,
> > +///         }
> > +///     }
> > +/// }
> > +/// ```
> >   #[repr(transparent)]
> >   pub struct Task(pub(crate) Opaque<bindings::task_struct>);
> >
> > @@ -27,6 +73,46 @@ unsafe impl Sync for Task {}
> >   type Pid = bindings::pid_t;
> >
> >   impl 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`](crate::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() -> impl Deref<Target = Task> {
> > +        pub struct TaskRef<'a> {
> > +            task: &'a Task,
> > +            _not_send: PhantomData<*mut ()>,
> > +        }
> > +
> > +        impl Deref for TaskRef<'_> {
> > +            type Target = Task;
> > +
> > +            fn deref(&self) -> &Self::Target {
> > +                self.task
> > +            }
> > +        }
> > +
> > +        impl From<TaskRef<'_>> for crate::types::ARef<Task> {
> > +            fn from(t: TaskRef<'_>) -> Self {
> > +                t.deref().into()
> > +            }
> > +        }
>
> I think we can remove this `From` impl, since the type is never exposed
> to the outside (there still is the `From<&T> for ARef<T>` impl, so users
> can still do `current!().into()` to get an `ARef<Task>`).

Hmm, this also allows me to remove the `pub` visibility from
`TaskRef`. I will make this change for v4.

> --
> Cheers,
> Benno
>
> > +
> > +        // SAFETY: Just an FFI call with no additional safety requirements.
> > +        let ptr = unsafe { bindings::get_current() };
> > +
> > +        TaskRef {
> > +            // SAFETY: If the current thread is still running, the current task is valid. Given
> > +            // that `TaskRef` is not `Send`, we know it cannot be transferred to another thread
> > +            // (where it could potentially outlive the caller).
> > +            task: unsafe { &*ptr.cast() },
> > +            _not_send: PhantomData,
> > +        }
> > +    }
> > +
> >       /// Returns the group leader of the given task.
> >       pub fn group_leader(&self) -> &Task {
> >           // SAFETY: By the type invariant, we know that `self.0` is a valid task. Valid tasks always
> > --
> > 2.34.1
> >
>