rust: add improved version of `ForeignOwnable::borrow_mut`
Subsystems (3)
v4 cover rust: add improved version of `ForeignOwnable::borrow_mut`
This is a re-submission of Alice's patch[0]. The leading commits are intended to improve the consistency and ergonomics of ForeignOwnable, and to split out the code movement originally included in the patch.
ForeignOwnable::borrow_mut is a dependency of the memory backing feature of rnull, the Rust null block driver.
---
Changes in v4:
- Remove (another) superfluous cast_const(). (Alice Ryhl)
- Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- Remove superfluous cast_const(). (Alice Ryhl)
- Correct SoB placement. (Alice Ryhl)
- Mention as cast removal. (Miguel Ojeda)
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- Call out ordering inconsistency in commit message.
- Restore pointer type ascriptionin Arc. (Andreas Hindborg)
- Remove most reduction of unsafe blocks. (Andreas Hindborg)
- Lift splitting of unsafe block into separate patch.
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Alice Ryhl (1):
rust: add improved version of ForeignOwnable::borrow_mut
Tamir Duberstein (5):
rust: arc: use NonNull::new_unchecked
rust: types: avoid as casts
rust: arc: split unsafe block, add missing comment
rust: change ForeignOwnable pointer to mut
rust: reorder ForeignOwnable items
rust/kernel/alloc/kbox.rs | 41 ++++++++++++++++----- rust/kernel/sync/arc.rs | 42 ++++++++++++++------- rust/kernel/types.rs | 93 +++++++++++++++++++++++++++++++++++------------ 3 files changed, 129 insertions(+), 47 deletions(-)
---
base-commit: ae7851c29747fa3765ecb722fe722117a346f988
change-id: 20241030-borrow-mut-75f181feef4c
Best regards,
Signature · 1 line
Tamir Duberstein <[email protected]>
PATCH v4 1/6 rust: arc: use `NonNull::new_unchecked`
There is no need to check (and panic on violations of) the safety requirements on ForeignOwnable functions. Avoiding the check is consistent with the implementation of ForeignOwnable for Box.
--- rust/kernel/sync/arc.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
rust/kernel/sync/arc.rs +8 -4
@@ -337,9 +337,9 @@ fn into_foreign(self) -> *const core::ffi::c_void { }unsafe fn borrow <'a>(ptr: *const core::ffi::c_void ) ->ArcBorrow <'a,T > { -// By the safety requirement of this function, we know that `ptr` came from -// a previous call to `Arc::into_foreign`. -let inner =NonNull ::new (ptras *mut ArcInner <T >).unwrap (); +// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous +// call to `Self::into_foreign`. +let inner =unsafe {NonNull ::new_unchecked (ptras *mut ArcInner <T >) };// SAFETY: The safety requirements of `from_foreign` ensure that the object remains alive // for the lifetime of the returned value.
@@ -347,10 +347,14 @@ unsafe fn borrow<'a>(ptr: *const core::ffi::c_void) -> ArcBorrow<'a, T> { }unsafe fn from_foreign (ptr: *const core::ffi::c_void ) ->Self { +// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous +// call to `Self::into_foreign`. +let inner =unsafe {NonNull ::new_unchecked (ptras *mut ArcInner <T >) }; +// SAFETY: By the safety requirement of this function, we know that `ptr` came from // a previous call to `Arc::into_foreign`, which guarantees that `ptr` is valid and // holds a reference count increment that is transferrable to us. -unsafe {Self ::from_inner (NonNull ::new (ptras _ ).unwrap ()) } +unsafe {Self ::from_inner (inner) } } }
Signature · 1 line
2.47.0
Re: [PATCH v4 1/6] rust: arc: use `NonNull::new_unchecked`
Quoted 7 lines · Tamir Duberstein
There is no need to check (and panic on violations of) the safety requirements on
ForeignOwnablefunctions. Avoiding the check is consistent with the implementation ofForeignOwnableforBox.Reviewed-by Alice Ryhl <[email protected]>Signed-off-by Tamir Duberstein <[email protected]>---
Best regards,
Andreas Hindborg
PATCH v4 2/6 rust: types: avoid `as` casts
In reply to Tamir DubersteinReplace as casts with cast{,_mut} calls which are a bit safer.
In one instance, remove an unnecessary as cast without replacement.
--- rust/kernel/alloc/kbox.rs | 8 ++++---- rust/kernel/sync/arc.rs | 9 +++++---- rust/kernel/types.rs | 2 +- 3 files changed, 10 insertions(+), 9 deletions(-)
rust/kernel/alloc/kbox.rs +4 -4
@@ -356,13 +356,13 @@ impl<T: 'static, A> ForeignOwnable for Box<T, A>type Borrowed <'a> = &'aT ;fn into_foreign (self) -> *const core::ffi::c_void { -Box ::into_raw (self)as _ +Box ::into_raw (self).cast () }unsafe fn from_foreign (ptr: *const core::ffi::c_void ) ->Self {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. -unsafe {Box ::from_raw (ptras _ ) } +unsafe {Box ::from_raw (ptr.cast_mut ().cast ()) } }unsafe fn borrow <'a>(ptr: *const core::ffi::c_void ) -> &'aT {
@@ -380,13 +380,13 @@ impl<T: 'static, A> ForeignOwnable for Pin<Box<T, A>>fn into_foreign (self) -> *const core::ffi::c_void {// SAFETY: We are still treating the box as pinned. -Box ::into_raw (unsafe {Pin ::into_inner_unchecked (self) })as _ +Box ::into_raw (unsafe {Pin ::into_inner_unchecked (self) }).cast () }unsafe fn from_foreign (ptr: *const core::ffi::c_void ) ->Self {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. -unsafe {Pin ::new_unchecked (Box ::from_raw (ptras _ )) } +unsafe {Pin ::new_unchecked (Box ::from_raw (ptr.cast_mut ().cast ())) } }unsafe fn borrow <'a>(ptr: *const core::ffi::c_void ) ->Pin <&'aT > {
rust/kernel/sync/arc.rs +5 -4
@@ -201,10 +201,11 @@ pub fn new(contents: T, flags: Flags) -> Result<Self, AllocError> { };let inner =KBox ::new (value, flags)?; +let inner =KBox ::leak (inner).into ();// SAFETY: We just created `inner` with a reference count of 1, which is owned by the new // `Arc` object. -Ok (unsafe {Self ::from_inner (KBox ::leak (inner).into ()) }) +Ok (unsafe {Self ::from_inner (inner) }) } }
@@ -333,13 +334,13 @@ impl<T: 'static> ForeignOwnable for Arc<T> {type Borrowed <'a> =ArcBorrow <'a,T >;fn into_foreign (self) -> *const core::ffi::c_void { -ManuallyDrop ::new (self).ptr.as_ptr ()as _ +ManuallyDrop ::new (self).ptr.as_ptr ().cast () }unsafe fn borrow <'a>(ptr: *const core::ffi::c_void ) ->ArcBorrow <'a,T > {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. -let inner =unsafe {NonNull ::new_unchecked (ptras *mut ArcInner <T >) }; +let inner =unsafe {NonNull ::new_unchecked (ptr.cast_mut ().cast ::<ArcInner <T >>()) };// SAFETY: The safety requirements of `from_foreign` ensure that the object remains alive // for the lifetime of the returned value.
@@ -349,7 +350,7 @@ unsafe fn borrow<'a>(ptr: *const core::ffi::c_void) -> ArcBorrow<'a, T> {unsafe fn from_foreign (ptr: *const core::ffi::c_void ) ->Self {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. -let inner =unsafe {NonNull ::new_unchecked (ptras *mut ArcInner <T >) }; +let inner =unsafe {NonNull ::new_unchecked (ptr.cast_mut ().cast ::<ArcInner <T >>()) };// SAFETY: By the safety requirement of this function, we know that `ptr` came from // a previous call to `Arc::into_foreign`, which guarantees that `ptr` is valid and
rust/kernel/types.rs +1 -1
@@ -418,7 +418,7 @@ pub unsafe fn from_raw(ptr: NonNull<T>) -> Self {/// } /// /// let mut data = Empty {}; -/// let ptr = NonNull::<Empty>::new(&mut data as *mut _).unwrap(); +/// let ptr = NonNull::<Empty>::new(&mut data).unwrap(); /// # // SAFETY: TODO. /// let data_ref: ARef<Empty> = unsafe { ARef::from_raw(ptr) }; /// let raw_ptr: NonNull<Empty> = ARef::into_raw(data_ref);
Signature · 1 line
2.47.0
Re: [PATCH v4 2/6] rust: types: avoid `as` casts
Quoted 6 lines · Tamir Duberstein
Replace
ascasts withcast{,_mut}calls which are a bit safer.In one instance, remove an unnecessary
ascast without replacement.Reviewed-by Alice Ryhl <[email protected]>Signed-off-by Tamir Duberstein <[email protected]>
Best regards,
Andreas Hindborg
PATCH v4 3/6 rust: arc: split unsafe block, add missing comment
In reply to Tamir DubersteinThe new SAFETY comment style is taken from existing comments in deref and `drop.
--- rust/kernel/sync/arc.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
rust/kernel/sync/arc.rs +5 -1
@@ -377,10 +377,14 @@ fn as_ref(&self) -> &T {impl <T : ?Sized >Clone for Arc <T > {fn clone (&self) ->Self { +// SAFETY: By the type invariant, there is necessarily a reference to the object, so it is +// safe to dereference it. +let refcount =unsafe { self.ptr.as_ref () }.refcount.get (); +// INVARIANT: C `refcount_inc` saturates the refcount, so it cannot overflow to zero. // SAFETY: By the type invariant, there is necessarily a reference to the object, so it is // safe to increment the refcount. -unsafe { bindings::refcount_inc (self.ptr.as_ref ().refcount.get ()) }; +unsafe { bindings::refcount_inc (refcount) };// SAFETY: We just incremented the refcount. This increment is now owned by the new `Arc`. unsafe {Self ::from_inner (self.ptr) }
Signature · 1 line
2.47.0
Re: [PATCH v4 3/6] rust: arc: split unsafe block, add missing comment
Quoted 5 lines · Tamir Duberstein
The new SAFETY comment style is taken from existing comments in
derefand `drop.Reviewed-by Alice Ryhl <[email protected]>Signed-off-by Tamir Duberstein <[email protected]>
Best regards,
Andreas Hindborg
PATCH v4 4/6 rust: change `ForeignOwnable` pointer to mut
In reply to Tamir DubersteinIt is slightly more convenient to operate on mut pointers, and this also properly conveys the desired ownership semantics of the trait.
--- rust/kernel/alloc/kbox.rs | 16 ++++++++-------- rust/kernel/sync/arc.rs | 10 +++++----- rust/kernel/types.rs | 14 +++++++------- 3 files changed, 20 insertions(+), 20 deletions(-)
rust/kernel/alloc/kbox.rs +8 -8
@@ -355,17 +355,17 @@ impl<T: 'static, A> ForeignOwnable for Box<T, A> {type Borrowed <'a> = &'aT ; -fn into_foreign (self) -> *const core::ffi::c_void { +fn into_foreign (self) -> *mut core::ffi::c_void {Box ::into_raw (self).cast () } -unsafe fn from_foreign (ptr: *const core::ffi::c_void ) ->Self { +unsafe fn from_foreign (ptr: *mut core::ffi::c_void ) ->Self {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. -unsafe {Box ::from_raw (ptr.cast_mut ().cast ()) } +unsafe {Box ::from_raw (ptr.cast ()) } } -unsafe fn borrow <'a>(ptr: *const core::ffi::c_void ) -> &'aT { +unsafe fn borrow <'a>(ptr: *mut core::ffi::c_void ) -> &'aT {// SAFETY: The safety requirements of this method ensure that the object remains alive and // immutable for the duration of 'a. unsafe { &*ptr.cast () }
@@ -378,18 +378,18 @@ impl<T: 'static, A> ForeignOwnable for Pin<Box<T, A>> {type Borrowed <'a> =Pin <&'aT >; -fn into_foreign (self) -> *const core::ffi::c_void { +fn into_foreign (self) -> *mut core::ffi::c_void {// SAFETY: We are still treating the box as pinned. Box ::into_raw (unsafe {Pin ::into_inner_unchecked (self) }).cast () } -unsafe fn from_foreign (ptr: *const core::ffi::c_void ) ->Self { +unsafe fn from_foreign (ptr: *mut core::ffi::c_void ) ->Self {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. -unsafe {Pin ::new_unchecked (Box ::from_raw (ptr.cast_mut ().cast ())) } +unsafe {Pin ::new_unchecked (Box ::from_raw (ptr.cast ())) } } -unsafe fn borrow <'a>(ptr: *const core::ffi::c_void ) ->Pin <&'aT > { +unsafe fn borrow <'a>(ptr: *mut core::ffi::c_void ) ->Pin <&'aT > {// SAFETY: The safety requirements for this function ensure that the object is still alive, // so it is safe to dereference the raw pointer. // The safety requirements of `from_foreign` also ensure that the object remains alive for
rust/kernel/sync/arc.rs +5 -5
@@ -333,24 +333,24 @@ pub fn into_unique_or_drop(self) -> Option<Pin<UniqueArc<T>>> {impl <T : 'static>ForeignOwnable for Arc <T > {type Borrowed <'a> =ArcBorrow <'a,T >; -fn into_foreign (self) -> *const core::ffi::c_void { +fn into_foreign (self) -> *mut core::ffi::c_void {ManuallyDrop ::new (self).ptr.as_ptr ().cast () } -unsafe fn borrow <'a>(ptr: *const core::ffi::c_void ) ->ArcBorrow <'a,T > { +unsafe fn borrow <'a>(ptr: *mut core::ffi::c_void ) ->ArcBorrow <'a,T > {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. -let inner =unsafe {NonNull ::new_unchecked (ptr.cast_mut ().cast ::<ArcInner <T >>()) }; +let inner =unsafe {NonNull ::new_unchecked (ptr.cast ::<ArcInner <T >>()) };// SAFETY: The safety requirements of `from_foreign` ensure that the object remains alive // for the lifetime of the returned value. unsafe {ArcBorrow ::new (inner) } } -unsafe fn from_foreign (ptr: *const core::ffi::c_void ) ->Self { +unsafe fn from_foreign (ptr: *mut core::ffi::c_void ) ->Self {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. -let inner =unsafe {NonNull ::new_unchecked (ptr.cast_mut ().cast ::<ArcInner <T >>()) }; +let inner =unsafe {NonNull ::new_unchecked (ptr.cast ::<ArcInner <T >>()) };// SAFETY: By the safety requirement of this function, we know that `ptr` came from // a previous call to `Arc::into_foreign`, which guarantees that `ptr` is valid and
rust/kernel/types.rs +7 -7
@@ -29,7 +29,7 @@ pub trait ForeignOwnable: Sized {/// For example, it might be invalid, dangling or pointing to uninitialized memory. Using it in /// any way except for [`ForeignOwnable::from_foreign`], [`ForeignOwnable::borrow`], /// [`ForeignOwnable::try_from_foreign`] can result in undefined behavior. -fn into_foreign (self) -> *const core::ffi::c_void ; +fn into_foreign (self) -> *mut core::ffi::c_void ;/// Borrows a foreign-owned object. ///
@@ -37,7 +37,7 @@ pub trait ForeignOwnable: Sized {/// /// `ptr` must have been returned by a previous call to [`ForeignOwnable::into_foreign`] for /// which a previous matching [`ForeignOwnable::from_foreign`] hasn't been called yet. -unsafe fn borrow <'a>(ptr: *const core::ffi::c_void ) ->Self ::Borrowed <'a>; +unsafe fn borrow <'a>(ptr: *mut core::ffi::c_void ) ->Self ::Borrowed <'a>;/// Converts a foreign-owned object back to a Rust-owned one. ///
@@ -47,7 +47,7 @@ pub trait ForeignOwnable: Sized {/// which a previous matching [`ForeignOwnable::from_foreign`] hasn't been called yet. /// Additionally, all instances (if any) of values returned by [`ForeignOwnable::borrow`] for /// this object must have been dropped. -unsafe fn from_foreign (ptr: *const core::ffi::c_void ) ->Self ; +unsafe fn from_foreign (ptr: *mut core::ffi::c_void ) ->Self ;/// Tries to convert a foreign-owned object back to a Rust-owned one. ///
@@ -58,7 +58,7 @@ pub trait ForeignOwnable: Sized {/// /// `ptr` must either be null or satisfy the safety requirements for /// [`ForeignOwnable::from_foreign`]. -unsafe fn try_from_foreign (ptr: *const core::ffi::c_void ) ->Option <Self > { +unsafe fn try_from_foreign (ptr: *mut core::ffi::c_void ) ->Option <Self > {if ptr.is_null () {None }else {
@@ -72,13 +72,13 @@ unsafe fn try_from_foreign(ptr: *const core::ffi::c_void) -> Option<Self> {impl ForeignOwnable for () {type Borrowed <'a> = (); -fn into_foreign (self) -> *const core::ffi::c_void { +fn into_foreign (self) -> *mut core::ffi::c_void { core::ptr::NonNull ::dangling ().as_ptr () } -unsafe fn borrow <'a>(_: *const core::ffi::c_void ) ->Self ::Borrowed <'a> {} +unsafe fn borrow <'a>(_: *mut core::ffi::c_void ) ->Self ::Borrowed <'a> {} -unsafe fn from_foreign (_: *const core::ffi::c_void ) ->Self {} +unsafe fn from_foreign (_: *mut core::ffi::c_void ) ->Self {} }/// Runs a cleanup function/closure when dropped.
Signature · 1 line
2.47.0
PATCH v4 5/6 rust: reorder `ForeignOwnable` items
In reply to Tamir Duberstein{into,from}_foreign before borrow is slightly more logical.
This removes an inconsistency with kbox.rs which already uses this ordering.
--- rust/kernel/sync/arc.rs | 18 +++++++++--------- rust/kernel/types.rs | 20 ++++++++++---------- 2 files changed, 19 insertions(+), 19 deletions(-)
rust/kernel/sync/arc.rs +9 -9
@@ -337,25 +337,25 @@ fn into_foreign(self) -> *mut core::ffi::c_void {ManuallyDrop ::new (self).ptr.as_ptr ().cast () } -unsafe fn borrow <'a>(ptr: *mut core::ffi::c_void ) ->ArcBorrow <'a,T > { +unsafe fn from_foreign (ptr: *mut core::ffi::c_void ) ->Self {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. let inner =unsafe {NonNull ::new_unchecked (ptr.cast ::<ArcInner <T >>()) }; -// SAFETY: The safety requirements of `from_foreign` ensure that the object remains alive -// for the lifetime of the returned value. -unsafe {ArcBorrow ::new (inner) } +// SAFETY: By the safety requirement of this function, we know that `ptr` came from +// a previous call to `Arc::into_foreign`, which guarantees that `ptr` is valid and +// holds a reference count increment that is transferrable to us. +unsafe {Self ::from_inner (inner) } } -unsafe fn from_foreign (ptr: *mut core::ffi::c_void ) ->Self { +unsafe fn borrow <'a>(ptr: *mut core::ffi::c_void ) ->ArcBorrow <'a,T > {// SAFETY: The safety requirements of this function ensure that `ptr` comes from a previous // call to `Self::into_foreign`. let inner =unsafe {NonNull ::new_unchecked (ptr.cast ::<ArcInner <T >>()) }; -// SAFETY: By the safety requirement of this function, we know that `ptr` came from -// a previous call to `Arc::into_foreign`, which guarantees that `ptr` is valid and -// holds a reference count increment that is transferrable to us. -unsafe {Self ::from_inner (inner) } +// SAFETY: The safety requirements of `from_foreign` ensure that the object remains alive +// for the lifetime of the returned value. +unsafe {ArcBorrow ::new (inner) } } }
rust/kernel/types.rs +10 -10
@@ -31,14 +31,6 @@ pub trait ForeignOwnable: Sized {/// [`ForeignOwnable::try_from_foreign`] can result in undefined behavior. fn into_foreign (self) -> *mut core::ffi::c_void ; -/// Borrows a foreign-owned object. -/// -/// # Safety -/// -/// `ptr` must have been returned by a previous call to [`ForeignOwnable::into_foreign`] for -/// which a previous matching [`ForeignOwnable::from_foreign`] hasn't been called yet. -unsafe fn borrow <'a>(ptr: *mut core::ffi::c_void ) ->Self ::Borrowed <'a>; -/// Converts a foreign-owned object back to a Rust-owned one. /// /// # Safety
@@ -67,6 +59,14 @@ unsafe fn try_from_foreign(ptr: *mut core::ffi::c_void) -> Option<Self> {unsafe {Some (Self ::from_foreign (ptr)) } } } + +/// Borrows a foreign-owned object. +/// +/// # Safety +/// +/// `ptr` must have been returned by a previous call to [`ForeignOwnable::into_foreign`] for +/// which a previous matching [`ForeignOwnable::from_foreign`] hasn't been called yet. +unsafe fn borrow <'a>(ptr: *mut core::ffi::c_void ) ->Self ::Borrowed <'a>; }impl ForeignOwnable for () {
@@ -76,9 +76,9 @@ fn into_foreign(self) -> *mut core::ffi::c_void { core::ptr::NonNull ::dangling ().as_ptr () } -unsafe fn borrow <'a>(_: *mut core::ffi::c_void ) ->Self ::Borrowed <'a> {} -unsafe fn from_foreign (_: *mut core::ffi::c_void ) ->Self {} + +unsafe fn borrow <'a>(_: *mut core::ffi::c_void ) ->Self ::Borrowed <'a> {} }/// Runs a cleanup function/closure when dropped.
Signature · 1 line
2.47.0
Re: [PATCH v4 5/6] rust: reorder `ForeignOwnable` items
Quoted 7 lines · Tamir Duberstein
{into,from}_foreignbeforeborrowis slightly more logical.This removes an inconsistency with
kbox.rswhich already uses this ordering.Reviewed-by Alice Ryhl <[email protected]>Signed-off-by Tamir Duberstein <[email protected]>
Best regards,
Andreas Hindborg
PATCH v4 6/6 rust: add improved version of `ForeignOwnable::borrow_mut`
In reply to Tamir DubersteinFrom: Alice Ryhl <[email protected]>
Previously, the ForeignOwnable trait had a method called borrow_mut that was intended to provide mutable access to the inner value. However, the method accidentally made it possible to change the address of the object being modified, which usually isn't what we want. (And when we want that, it can be done by calling from_foreign and into_foreign, like how the old borrow_mut was implemented.)
In this patch, we introduce an alternate definition of borrow_mut that solves the previous problem. Conceptually, given a pointer type P that implements ForeignOwnable, the borrow_mut method gives you the same kind of access as an &mut P would, except that it does not let you change the pointer P itself.
This is analogous to how the existing borrow method provides the same kind of access to the inner value as an &P.
Note that for types like Arc, having an &mut Arc<T> only gives you immutable access to the inner T. This is because mutable references assume exclusive access, but there might be other handles to the same reference counted value, so the access isn't exclusive. The Arc type implements this by making borrow_mut return the same type as borrow.
--- rust/kernel/alloc/kbox.rs | 21 ++++++++++++++ rust/kernel/sync/arc.rs | 7 +++++ rust/kernel/types.rs | 71 ++++++++++++++++++++++++++++++++++++++--------- 3 files changed, 86 insertions(+), 13 deletions(-)
rust/kernel/alloc/kbox.rs +21 -0
@@ -354,6 +354,7 @@ impl<T: 'static, A> ForeignOwnable for Box<T, A> A: Allocator, { type Borrowed<'a> = &'a T; +type BorrowedMut <'a> = &'amut T ;fn into_foreign (self) -> *mut core::ffi::c_void {Box ::into_raw (self).cast ()
@@ -370,6 +371,13 @@ unsafe fn borrow<'a>(ptr: *mut core::ffi::c_void) -> &'a T {// immutable for the duration of 'a. unsafe { &*ptr.cast () } } + +unsafe fn borrow_mut <'a>(ptr: *mut core::ffi::c_void ) -> &'amut T { +let ptr = ptr.cast (); +// SAFETY: The safety requirements of this method ensure that the pointer is valid and that +// nothing else will access the value for the duration of 'a. +unsafe { &mut *ptr } + } }impl <T : 'static,A >ForeignOwnable for Pin <Box <T ,A >>
@@ -377,6 +385,7 @@ impl<T: 'static, A> ForeignOwnable for Pin<Box<T, A>> A: Allocator, { type Borrowed<'a> = Pin<&'a T>; +type BorrowedMut <'a> =Pin <&'amut T >;fn into_foreign (self) -> *mut core::ffi::c_void {// SAFETY: We are still treating the box as pinned.
@@ -399,6 +408,18 @@ unsafe fn borrow<'a>(ptr: *mut core::ffi::c_void) -> Pin<&'a T> {// SAFETY: This pointer originates from a `Pin<Box<T>>`. unsafe {Pin ::new_unchecked (r) } } + +unsafe fn borrow_mut <'a>(ptr: *mut core::ffi::c_void ) ->Pin <&'amut T > { +let ptr = ptr.cast (); +// SAFETY: The safety requirements for this function ensure that the object is still alive, +// so it is safe to dereference the raw pointer. +// The safety requirements of `from_foreign` also ensure that the object remains alive for +// the lifetime of the returned value. +let r =unsafe { &mut *ptr }; + +// SAFETY: This pointer originates from a `Pin<Box<T>>`. +unsafe {Pin ::new_unchecked (r) } + } }impl <T ,A >Deref for Box <T ,A >
rust/kernel/sync/arc.rs +7 -0
@@ -332,6 +332,7 @@ pub fn into_unique_or_drop(self) -> Option<Pin<UniqueArc<T>>> {impl <T : 'static>ForeignOwnable for Arc <T > {type Borrowed <'a> =ArcBorrow <'a,T >; +type BorrowedMut <'a> =Self ::Borrowed <'a>;fn into_foreign (self) -> *mut core::ffi::c_void {ManuallyDrop ::new (self).ptr.as_ptr ().cast ()
@@ -357,6 +358,12 @@ unsafe fn borrow<'a>(ptr: *mut core::ffi::c_void) -> ArcBorrow<'a, T> {// for the lifetime of the returned value. unsafe {ArcBorrow ::new (inner) } } + +unsafe fn borrow_mut <'a>(ptr: *mut core::ffi::c_void ) ->ArcBorrow <'a,T > { +// SAFETY: The safety requirements for `borrow_mut` are a superset of the safety +// requirements for `borrow`. +unsafe {Self ::borrow (ptr) } + } }impl <T : ?Sized >Deref for Arc <T > {
rust/kernel/types.rs +58 -13
115 lines not on this page · raw message
Signature · 1 line
2.47.0
This series conflicts with Gary's FFI types series:
https://lore.kernel.org/all/[email protected]/
I've rebased it locally. Shall I send a v5?
Alice Ryhl
maintainerQuoted 6 lines · Tamir Duberstein
This series conflicts with Gary's FFI types series:
https://lore.kernel.org/all/[email protected]/
I've rebased it locally. Shall I send a v5?
You should probably wait for Miguel to decide what to do about
https://lore.kernel.org/all/[email protected]/
Alice
Quoted 4 lines
You should probably wait for Miguel to decide what to do about
https://lore.kernel.org/all/[email protected]/Alice
Thanks for the pointer!
My reading of that discussion is that the new crate::ffi module isn't going anywhere, it's just the later patches that diverge the types that might be dropped for now and taken later.
In my case though I have a hard conflict as the patch introducing crate::ffi and this series touch the same lines so I think a rebase is unavoidable.
Tamir
Quoted 4 lines · Tamir Duberstein
My reading of that discussion is that the new
crate::ffimodule isn't going anywhere, it's just the later patches that diverge the types that might be dropped for now and taken later.
Yeah, that was my plan, and I ended up with that.
However, we still need to see how it actually goes -- we will see tomorrow.
Quoted 3 lines
In my case though I have a hard conflict as the patch introducing
crate::ffiand this series touch the same lines so I think a rebase is unavoidable.
If there are conflicts, then a new version is usually welcome, unless the conflict is small or trivial (i.e. sometimes maintainers may do the rebase for you and other adjustments -- a new version may not be worth it, and it depends on the maintainer).
In this case, please wait a few days to see if you get more feedback, and meanwhile the linux-next issue will be resolved one way or another, so you can use whatever is in rust-next by then.
Thanks!
Cheers,
Miguel
Quoted 11 lines · Miguel Ojeda
Quoted 4 lines · Tamir Duberstein
My reading of that discussion is that the new
crate::ffimodule isn't going anywhere, it's just the later patches that diverge the types that might be dropped for now and taken later.Yeah, that was my plan, and I ended up with that.
However, we still need to see how it actually goes -- we will see tomorrow.
Quoted 8 lines
Quoted 3 lines
In my case though I have a hard conflict as the patch introducing
crate::ffiand this series touch the same lines so I think a rebase is unavoidable.If there are conflicts, then a new version is usually welcome, unless the conflict is small or trivial (i.e. sometimes maintainers may do the rebase for you and other adjustments -- a new version may not be worth it, and it depends on the maintainer).
The conflict is trivial here, but I've already done the rebase 🤷🏼♂️.
Quoted 3 lines
In this case, please wait a few days to see if you get more feedback, and meanwhile the linux-next issue will be resolved one way or another, so you can use whatever is in rust-next by then.
Will do! Thanks Miguel.