Message-ID: <CAH5fLggOo-TErSktC6qmyZpMGVu-M8rFXgvfi3N0Z_u63C3EyA@mail.gmail.com>
Date: Thu, 25 Jul 2024 17:09:14 +0200
From: Alice Ryhl <aliceryhl@...gle.com>
To: Peter Zijlstra <peterz@...radead.org>
Cc: Miguel Ojeda <ojeda@...nel.org>, Alex Gaynor <alex.gaynor@...il.com>, 
	Wedson Almeida Filho <wedsonaf@...il.com>, Boqun Feng <boqun.feng@...il.com>, Gary Guo <gary@...yguo.net>, 
	Björn Roy Baron <bjorn3_gh@...tonmail.com>, 
	Benno Lossin <benno.lossin@...ton.me>, Andreas Hindborg <a.hindborg@...sung.com>, 
	Alexander Viro <viro@...iv.linux.org.uk>, Christian Brauner <brauner@...nel.org>, 
	Greg Kroah-Hartman <gregkh@...uxfoundation.org>, Arve Hjønnevåg <arve@...roid.com>, 
	Todd Kjos <tkjos@...roid.com>, Martijn Coenen <maco@...roid.com>, 
	Joel Fernandes <joel@...lfernandes.org>, Carlos Llamas <cmllamas@...gle.com>, 
	Suren Baghdasaryan <surenb@...gle.com>, Dan Williams <dan.j.williams@...el.com>, 
	Matthew Wilcox <willy@...radead.org>, Thomas Gleixner <tglx@...utronix.de>, Daniel Xu <dxu@...uu.xyz>, 
	Martin Rodriguez Reboredo <yakoyoku@...il.com>, Trevor Gross <tmgross@...ch.edu>, linux-kernel@...r.kernel.org, 
	rust-for-linux@...r.kernel.org, linux-fsdevel@...r.kernel.org, 
	Kees Cook <kees@...nel.org>
Subject: Re: [PATCH v8 1/8] rust: types: add `NotThreadSafe`

On Thu, Jul 25, 2024 at 4:37 PM Peter Zijlstra <peterz@...radead.org> wrote:
>
> On Thu, Jul 25, 2024 at 02:27:34PM +0000, Alice Ryhl wrote:
> > This introduces a new marker type for types that shouldn't be thread
> > safe. By adding a field of this type to a struct, it becomes non-Send
> > and non-Sync, which means that it cannot be accessed in any way from
> > threads other than the one it was created on.
> >
> > This is useful for APIs that require globals such as `current` to remain
> > constant while the value exists.
> >
> > We update two existing users in the Kernel to use this helper:
> >
> >  * `Task::current()` - moving the return type of this value to a
> >    different thread would not be safe as you can no longer be guaranteed
> >    that the `current` pointer remains valid.
> >  * Lock guards. Mutexes and spinlocks should be unlocked on the same
> >    thread as where they were locked, so we enforce this using the Send
> >    trait.
> >
> > There are also additional users in later patches of this patchset. See
> > [1] and [2] for the discussion that led to the introduction of this
> > patch.
> >
> > Link: https://lore.kernel.org/all/nFDPJFnzE9Q5cqY7FwSMByRH2OAn_BpI4H53NQfWIlN6I2qfmAqnkp2wRqn0XjMO65OyZY4h6P4K2nAGKJpAOSzksYXaiAK_FoH_8QbgBI4=@proton.me/ [1]
> > Link: https://lore.kernel.org/all/nFDPJFnzE9Q5cqY7FwSMByRH2OAn_BpI4H53NQfWIlN6I2qfmAqnkp2wRqn0XjMO65OyZY4h6P4K2nAGKJpAOSzksYXaiAK_FoH_8QbgBI4=@proton.me/ [2]
> > Suggested-by: Benno Lossin <benno.lossin@...ton.me>
> > Reviewed-by: Benno Lossin <benno.lossin@...ton.me>
> > Reviewed-by: Trevor Gross <tmgross@...ch.edu>
> > Reviewed-by: Martin Rodriguez Reboredo <yakoyoku@...il.com>
> > Reviewed-by: Björn Roy Baron <bjorn3_gh@...tonmail.com>
> > Signed-off-by: Alice Ryhl <aliceryhl@...gle.com>
> > ---
> >  rust/kernel/sync/lock.rs | 13 +++++++++----
> >  rust/kernel/task.rs      | 10 ++++++----
> >  rust/kernel/types.rs     | 21 +++++++++++++++++++++
> >  3 files changed, 36 insertions(+), 8 deletions(-)
> >
> > diff --git a/rust/kernel/sync/lock.rs b/rust/kernel/sync/lock.rs
> > index f6c34ca4d819..d6e9bab114b8 100644
> > --- a/rust/kernel/sync/lock.rs
> > +++ b/rust/kernel/sync/lock.rs
> > @@ -6,8 +6,13 @@
> >  //! spinlocks, raw spinlocks) to be provided with minimal effort.
> >
> >  use super::LockClassKey;
> > -use crate::{init::PinInit, pin_init, str::CStr, types::Opaque, types::ScopeGuard};
> > -use core::{cell::UnsafeCell, marker::PhantomData, marker::PhantomPinned};
> > +use crate::{
> > +    init::PinInit,
> > +    pin_init,
> > +    str::CStr,
> > +    types::{NotThreadSafe, Opaque, ScopeGuard},
> > +};
> > +use core::{cell::UnsafeCell, marker::PhantomPinned};
> >  use macros::pin_data;
> >
> >  pub mod mutex;
> > @@ -139,7 +144,7 @@ pub fn lock(&self) -> Guard<'_, T, B> {
> >  pub struct Guard<'a, T: ?Sized, B: Backend> {
> >      pub(crate) lock: &'a Lock<T, B>,
> >      pub(crate) state: B::GuardState,
> > -    _not_send: PhantomData<*mut ()>,
> > +    _not_send: NotThreadSafe,
> >  }
> >
> >  // SAFETY: `Guard` is sync when the data protected by the lock is also sync.
> > @@ -191,7 +196,7 @@ pub(crate) unsafe fn new(lock: &'a Lock<T, B>, state: B::GuardState) -> Self {
> >          Self {
> >              lock,
> >              state,
> > -            _not_send: PhantomData,
> > +            _not_send: NotThreadSafe,
> >          }
> >      }
> >  }
> > diff --git a/rust/kernel/task.rs b/rust/kernel/task.rs
> > index 55dff7e088bf..278c623de0c6 100644
> > --- a/rust/kernel/task.rs
> > +++ b/rust/kernel/task.rs
> > @@ -4,10 +4,12 @@
> >  //!
> >  //! C header: [`include/linux/sched.h`](srctree/include/linux/sched.h).
> >
> > -use crate::types::Opaque;
> > +use crate::{
> > +    bindings,
> > +    types::{NotThreadSafe, Opaque},
> > +};
> >  use core::{
> >      ffi::{c_int, c_long, c_uint},
> > -    marker::PhantomData,
> >      ops::Deref,
> >      ptr,
> >  };
> > @@ -106,7 +108,7 @@ impl Task {
> >      pub unsafe fn current() -> impl Deref<Target = Task> {
> >          struct TaskRef<'a> {
> >              task: &'a Task,
> > -            _not_send: PhantomData<*mut ()>,
> > +            _not_send: NotThreadSafe,
> >          }
> >
> >          impl Deref for TaskRef<'_> {
> > @@ -125,7 +127,7 @@ fn deref(&self) -> &Self::Target {
> >              // 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,
> > +            _not_send: NotThreadSafe,
> >          }
> >      }
>
> As per always for not being able to read rust; how does this extend to
> get_task_struct()? Once you've taken a reference on current, you should
> be free to pass it along to whomever.

Once you take a reference on current, it becomes thread-safe. This is
because taking a reference creates a value of type ARef<Task> rather
than TaskRef, and ARef<Task> is considered thread-safe.

Alice

Powered by blists - more mailing lists