rust: specify when `ARef` is thread safe
Alice Ryhl
reviewerPATCH 1/2 rust: specify when `ARef` is thread safe
An ARef behaves just like the Arc when it comes to thread safety, so we can reuse the thread safety comments from Arc here.
This is necessary because without this change, the Rust compiler will assume that things are not thread safe even though they are.
--- rust/kernel/types.rs | 11 +++++++++++ 1 file changed, 11 insertions(+)
rust/kernel/types.rs +11 -0
@@ -321,6 +321,17 @@ pub struct ARef<T: AlwaysRefCounted> { _p: PhantomData<T>, } +// SAFETY: It is safe to send `ARef<T>` to another thread when the underlying `T` is `Sync` because +// it effectively means sharing `&T` (which is safe because `T` is `Sync`); additionally, it needs +// `T` to be `Send` because any thread that has an `ARef<T>` may ultimately access `T` directly, for +// example, when the reference count reaches zero and `T` is dropped. +unsafe impl <T :AlwaysRefCounted +Sync +Send >Send for ARef <T > {} + +// SAFETY: It is safe to send `&ARef<T>` to another thread when the underlying `T` is `Sync` for the +// same reason as above. `T` needs to be `Send` as well because a thread can clone an `&ARef<T>` +// into an `ARef<T>`, which may lead to `T` being accessed by the same reasoning as above. +unsafe impl <T :AlwaysRefCounted +Sync +Send >Sync for ARef <T > {} +impl <T :AlwaysRefCounted >ARef <T > {/// Creates a new instance of [`ARef`]. ///
base-commit: ac9a78681b921877518763ba0e89202254349d1b
Signature · 1 line
2.40.1.606.ga4b1b128d6-goog
Alice Ryhl
reviewerPATCH 2/2 rust: task: add `Send` marker to `Task`
When a type also implements Sync, the meaning of Send is just "this type may be accessed mutably from threads other than the one it is created on". That's ok for this type.
--- rust/kernel/task.rs | 5 +++++ 1 file changed, 5 insertions(+)
rust/kernel/task.rs +5 -0
@@ -64,6 +64,11 @@ macro_rules! current {#[repr(transparent)] pub struct Task (pub (crate )Opaque <bindings::task_struct >); +// SAFETY: The only situation in which this can be accessed mutably is when the refcount drops to +// zero and the destructor runs. It is safe for that to happen on any thread, so it is ok for this +// type to be `Send`. +unsafe impl Send for Task {} +// SAFETY: It's OK to access `Task` through references from other threads because we're either // accessing properties that don't change (e.g., `pid`, `group_leader`) or that are properly // synchronised by C code (e.g., `signal_pending`).
Signature · 1 line
2.40.1.606.ga4b1b128d6-goog
Re: [PATCH v1 2/2] rust: task: add `Send` marker to `Task`
Quoted 14 lines · Alice Ryhl
When a type also implements
Sync, the meaning ofSendis just "this type may be accessed mutably from threads other than the one it is created on". That's ok for this type.Signed-off-by Alice Ryhl <[email protected]>--- rust/kernel/task.rs | 5 +++++ 1 file changed, 5 insertions(+)rust/kernel/task.rs +0
-0
rust/kernel/task.rs macro_rules! current { · line 70
Quoted 7 lines
rust/kernel/task.rs +4
-0@@ -64,6 +64,11 @@ macro_rules! current {#[repr(transparent)] pub struct Task (pub (crate )Opaque <bindings::task_struct >); +// SAFETY: The only situation in which this can be accessed mutably is when the refcount drops to +// zero and the destructor runs. It is safe for that to happen on any thread, so it is ok for this +// type to be `Send`. +unsafe impl Send for Task {}
To enhance clarity, could you elaborate _why_ Task can never be accessed mutably by Rust? Perhaps "By design, Task can only be accessed thorough &Task and Task can never be owned by the Rust side. Therefore the only situation ...".
Quoted 4 lines
rust/kernel/task.rs +1
-0+// SAFETY: It's OK to access `Task` through references from other threads because we're either // accessing properties that don't change (e.g., `pid`, `group_leader`) or that are properly // synchronised by C code (e.g., `signal_pending`).
Quoted 16 lines · Alice Ryhl
An
ARefbehaves just like theArcwhen it comes to thread safety, so we can reuse the thread safety comments fromArchere.This is necessary because without this change, the Rust compiler will assume that things are not thread safe even though they are.
Signed-off-by Alice Ryhl <[email protected]>--- rust/kernel/types.rs | 11 +++++++++++ 1 file changed, 11 insertions(+)rust/kernel/types.rs +0
-0
rust/kernel/types.rs pub struct ARef<T: AlwaysRefCounted> { · line 326
Quoted 6 lines
rust/kernel/types.rs +3
-0@@ -321,6 +321,17 @@ pub struct ARef<T: AlwaysRefCounted> { _p: PhantomData<T>, } +// SAFETY: It is safe to send `ARef<T>` to another thread when the underlying `T` is `Sync` because +// it effectively means sharing `&T` (which is safe because `T` is `Sync`); additionally, it needs +// `T` to be `Send` because any thread that has an `ARef<T>` may ultimately access `T` directly, for
Does the "ultimately access T directly" here imply mutably or exclusively? If so, it makes sense to me to call it out. I'm trying to make sure we can agree on some "common terminologies" ;-)
Regards,
Boqun
Quoted 16 lines
rust/kernel/types.rs +8
-0+// example, when the reference count reaches zero and `T` is dropped. +unsafe impl <T :AlwaysRefCounted +Sync +Send >Send for ARef <T > {} + +// SAFETY: It is safe to send `&ARef<T>` to another thread when the underlying `T` is `Sync` for the +// same reason as above. `T` needs to be `Send` as well because a thread can clone an `&ARef<T>` +// into an `ARef<T>`, which may lead to `T` being accessed by the same reasoning as above. +unsafe impl <T :AlwaysRefCounted +Sync +Send >Sync for ARef <T > {} +impl <T :AlwaysRefCounted >ARef <T > {/// Creates a new instance of [`ARef`]. /// base-commit:
ac9a78681b921877518763ba0e89202254349d1bSignature · 1 line
2.40.1.606.ga4b1b128d6-goog
Alice Ryhl
reviewerQuoted 8 lines · Boqun Feng
rust/kernel/types.rs pub struct ARef<T: AlwaysRefCounted> { · line 326
Quoted 3 lines · Alice Ryhl
rust/kernel/types.rs +3
-0+// SAFETY: It is safe to send `ARef<T>` to another thread when the underlying `T` is `Sync` because +// it effectively means sharing `&T` (which is safe because `T` is `Sync`); additionally, it needs +// `T` to be `Send` because any thread that has an `ARef<T>` may ultimately access `T` directly, for Does the "ultimately access
Tdirectly" here imply mutably or exclusively? If so, it makes sense to me to call it out. I'm trying to make sure we can agree on some "common terminologies" ;)
It means "access using a mutable reference". I agree that "directly" is a bit unclear - I copied it from the safety comment on Arc.
Alice
Quoted 19 lines · Alice Ryhl
An
ARefbehaves just like theArcwhen it comes to thread safety, so we can reuse the thread safety comments fromArchere.This is necessary because without this change, the Rust compiler will assume that things are not thread safe even though they are.
Signed-off-by Alice Ryhl <[email protected]>--- rust/kernel/types.rs | 11 +++++++++++ 1 file changed, 11 insertions(+)rust/kernel/types.rs +0
-0@@ -321,6 +321,17 @@ pub struct ARef<T: AlwaysRefCounted> { _p: PhantomData<T>, }
rust/kernel/types.rs pub struct ARef<T: AlwaysRefCounted> { · line 333
Quoted 10 lines
rust/kernel/types.rs +10
-0+// SAFETY: It is safe to send `ARef<T>` to another thread when the underlying `T` is `Sync` because +// it effectively means sharing `&T` (which is safe because `T` is `Sync`); additionally, it needs +// `T` to be `Send` because any thread that has an `ARef<T>` may ultimately access `T` directly, for +// example, when the reference count reaches zero and `T` is dropped. +unsafe impl <T :AlwaysRefCounted +Sync +Send >Send for ARef <T > {} + +// SAFETY: It is safe to send `&ARef<T>` to another thread when the underlying `T` is `Sync` for the +// same reason as above. `T` needs to be `Send` as well because a thread can clone an `&ARef<T>` +// into an `ARef<T>`, which may lead to `T` being accessed by the same reasoning as above. +unsafe impl <T :AlwaysRefCounted +Sync +Send >Sync for ARef <T > {}
Nit: I would prefer repeating the safety comment details, in case the two drift apart in the future.
BR Andreas
Quoted 6 lines
rust/kernel/types.rs +1
-0+impl <T :AlwaysRefCounted >ARef <T > {/// Creates a new instance of [`ARef`]. /// base-commit:
ac9a78681b921877518763ba0e89202254349d1b