rust: xarray: Add a minimal abstraction for XArray
Subsystems (6)
v14 cover rust: xarray: Add a minimal abstraction for XArray
This is a reimagining relative to earlier versions[0] by Asahi Lina and Maíra Canal.
It is needed to support rust-binder, though this version only provides enough machinery to support rnull.
---
Changes in v14:
- Remove TODO made stale by Gary Guo's FFI type series.
- Link: https://lore.kernel.org/all/[email protected]/
- Link to v13: https://lore.kernel.org/r/[email protected]
Changes in v13:
- Replace bool::then with if. (Miguel Ojeda)
- Replace match with let + if. (Miguel Ojeda)
- Link to v12: https://lore.kernel.org/r/[email protected]
Changes in v12:
- Import core::ptr::NonNull. (Alice Ryhl)
- Introduce StoreError to allow ? to be used with Guard::store.
(Alice Ryhl)
- Replace {crate,core}::ffi::c_ulong and clarify TODO with respect to
usize. (Alice Ryhl)
- Drop T: Sync bound on impl Sync for XArray<T>. (Alice Ryhl)
- Reword Send and Sync safety comments to match the style used in
lock.rs. (Alice Ryhl and Andreas
Hindborg)
- Link to v11: https://lore.kernel.org/r/[email protected]
Changes in v11:
- Consolidate imports. (Alice Ryhl)
- Use literal 0 rather than MIN. (Alice Ryhl)
- Use bulleted list in SAFETY comment. (Alice Ryhl)
- Document (un)locking behavior of Guard::store. (Alice Ryhl)
- Document Normal API behavior WRT XA_ZERO_ENTRY. (Alice Ryhl)
- Rewrite unsafe impl Sync SAFETY comment. (Andreas Hindborg)
- Link to v10: https://lore.kernel.org/r/[email protected]
Changes in v10:
- Guard::get takes &self instead of &mut self. (Andreas Hindborg)
- Guard is !Send. (Boqun Feng)
- Add Inspired-by tags. (Maíra Canal and Asahi Lina)
- Rebase on linux-next, use NotThreadSafe. (Alice Ryhl)
- Link to v9: https://lore.kernel.org/r/[email protected]
---
Tamir Duberstein (2):
rust: types: add ForeignOwnable::PointedTo
rust: xarray: Add an abstraction for XArray
rust/bindings/bindings_helper.h | 6 + rust/helpers/helpers.c | 1 + rust/helpers/xarray.c | 28 ++++ rust/kernel/alloc.rs | 5 + rust/kernel/alloc/kbox.rs | 38 +++--- rust/kernel/lib.rs | 1 + rust/kernel/miscdevice.rs | 6 +- rust/kernel/sync/arc.rs | 21 +-- rust/kernel/types.rs | 46 ++++--- rust/kernel/xarray.rs | 279 ++++++++++++++++++++++++++++++++++++++++ 10 files changed, 386 insertions(+), 45 deletions(-)
---
base-commit: fac04efc5c793dccbd07e2d59af9f90b7fc0dca4
change-id: 20241020-rust-xarray-bindings-bef514142968
prerequisite-change-id: 20241030-borrow-mut-75f181feef4c:v6
prerequisite-patch-id: f801fb31bb4f202b3327f5fdb50d3018e25347d1
prerequisite-patch-id: b57aa4f44b238d4cb80f00276a188d9ba0c743cc
prerequisite-patch-id: 2387ec5af1cc03614d3dff5a95cefcd243befd65
prerequisite-patch-id: 75e26dd500888d9a27f8eac3d8304eab8d75c366
prerequisite-patch-id: 7f845443f373f975a888f01c3761fe8aa04b8a3c
prerequisite-patch-id: 5a9856c7363b33f0adfe8658e076b35abf960d23
Best regards,
Signature · 1 line
Tamir Duberstein <[email protected]>
PATCH v14 1/2 rust: types: add `ForeignOwnable::PointedTo`
Allow implementors to specify the foreign pointer type; this exposes information about the pointed-to type such as its alignment.
This requires the trait to be unsafe since it is now possible for implementors to break soundness by returning a misaligned pointer.
Encoding the pointer type in the trait (and avoiding pointer casts) allows the compiler to check that implementors return the correct pointer type. This is preferable to directly encoding the alignment in the trait using a constant as the compiler would be unable to check it.
--- rust/kernel/alloc/kbox.rs | 38 ++++++++++++++++++++------------------ rust/kernel/miscdevice.rs | 6 +++--- rust/kernel/sync/arc.rs | 21 ++++++++++++--------- rust/kernel/types.rs | 46 +++++++++++++++++++++++++++++++--------------- 4 files changed, 66 insertions(+), 45 deletions(-)
rust/kernel/alloc/kbox.rs +20 -18
@@ -349,68 +349,70 @@ fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E> } } -impl <T : 'static,A >ForeignOwnable for Box <T ,A > +// SAFETY: The `into_foreign` function returns a pointer that is well-aligned. +unsafe impl <T : 'static,A >ForeignOwnable for Box <T ,A >where A :Allocator , { +type PointedTo =T ;type Borrowed <'a> = &'aT ;type BorrowedMut <'a> = &'amut T ; -fn into_foreign (self) -> *mut crate ::ffi::c_void { -Box ::into_raw (self).cast () +fn into_foreign (self) -> *mut Self ::PointedTo { +Box ::into_raw (self) } -unsafe fn from_foreign (ptr: *mut crate ::ffi::c_void ) ->Self { +unsafe fn from_foreign (ptr: *mut Self ::PointedTo ) ->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 ()) } +unsafe {Box ::from_raw (ptr) } } -unsafe fn borrow <'a>(ptr: *mut crate ::ffi::c_void ) -> &'aT { +unsafe fn borrow <'a>(ptr: *mut Self ::PointedTo ) -> &'aT {// SAFETY: The safety requirements of this method ensure that the object remains alive and // immutable for the duration of 'a. -unsafe { &*ptr.cast () } +unsafe { &*ptr } } -unsafe fn borrow_mut <'a>(ptr: *mut core::ffi::c_void ) -> &'amut T { -let ptr = ptr.cast (); +unsafe fn borrow_mut <'a>(ptr: *mut Self ::PointedTo ) -> &'amut T {// 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 >> +// SAFETY: The `into_foreign` function returns a pointer that is well-aligned. +unsafe impl <T : 'static,A >ForeignOwnable for Pin <Box <T ,A >>where A :Allocator , { +type PointedTo =T ;type Borrowed <'a> =Pin <&'aT >;type BorrowedMut <'a> =Pin <&'amut T >; -fn into_foreign (self) -> *mut crate ::ffi::c_void { +fn into_foreign (self) -> *mut Self ::PointedTo {// SAFETY: We are still treating the box as pinned. -Box ::into_raw (unsafe {Pin ::into_inner_unchecked (self) }).cast () +Box ::into_raw (unsafe {Pin ::into_inner_unchecked (self) }) } -unsafe fn from_foreign (ptr: *mut crate ::ffi::c_void ) ->Self { +unsafe fn from_foreign (ptr: *mut Self ::PointedTo ) ->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 ())) } +unsafe {Pin ::new_unchecked (Box ::from_raw (ptr)) } } -unsafe fn borrow <'a>(ptr: *mut crate ::ffi::c_void ) ->Pin <&'aT > { +unsafe fn borrow <'a>(ptr: *mut Self ::PointedTo ) ->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 // the lifetime of the returned value. -let r =unsafe { &*ptr.cast () }; +let r =unsafe { &*ptr };// 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 (); +unsafe fn borrow_mut <'a>(ptr: *mut Self ::PointedTo ) ->Pin <&'amut T > {// 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/miscdevice.rs +3 -3
@@ -189,7 +189,7 @@ impl<T: MiscDevice> VtableHelper<T> { };// SAFETY: The open call of a file owns the private data. -unsafe { (*file).private_data = ptr.into_foreign () }; +unsafe { (*file).private_data = ptr.into_foreign ().cast () };0 }
@@ -205,7 +205,7 @@ impl<T: MiscDevice> VtableHelper<T> {// SAFETY: The release call of a file owns the private data. let private =unsafe { (*file).private_data };// SAFETY: The release call of a file owns the private data. -let ptr =unsafe { <T ::Ptr as ForeignOwnable >::from_foreign (private) }; +let ptr =unsafe { <T ::Ptr as ForeignOwnable >::from_foreign (private.cast ()) };T ::release (ptr);
@@ -223,7 +223,7 @@ impl<T: MiscDevice> VtableHelper<T> {// SAFETY: The ioctl call of a file can access the private data. let private =unsafe { (*file).private_data };// SAFETY: Ioctl calls can borrow the private data of the file. -let device =unsafe { <T ::Ptr as ForeignOwnable >::borrow (private) }; +let device =unsafe { <T ::Ptr as ForeignOwnable >::borrow (private.cast ()) };match T ::ioctl (device, cmd, arg) {Ok (ret) => retas c_long ,
rust/kernel/sync/arc.rs +12 -9
@@ -130,9 +130,10 @@ pub struct Arc<T: ?Sized> { _p: PhantomData<ArcInner<T>>, } +#[doc(hidden)] #[pin_data] #[repr( C )] -struct ArcInner <T : ?Sized > { +pub struct ArcInner <T : ?Sized > { refcount:Opaque <bindings::refcount_t >, data:T , }
@@ -330,18 +331,20 @@ pub fn into_unique_or_drop(self) -> Option<Pin<UniqueArc<T>>> { } } -impl <T : 'static>ForeignOwnable for Arc <T > { +// SAFETY: The `into_foreign` function returns a pointer that is well-aligned. +unsafe impl <T : 'static>ForeignOwnable for Arc <T > { +type PointedTo =ArcInner <T >;type Borrowed <'a> =ArcBorrow <'a,T >;type BorrowedMut <'a> =Self ::Borrowed <'a>; -fn into_foreign (self) -> *mut crate ::ffi::c_void { -ManuallyDrop ::new (self).ptr.as_ptr ().cast () +fn into_foreign (self) -> *mut Self ::PointedTo { +ManuallyDrop ::new (self).ptr.as_ptr () } -unsafe fn from_foreign (ptr: *mut crate ::ffi::c_void ) ->Self { +unsafe fn from_foreign (ptr: *mut Self ::PointedTo ) ->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 >>()) }; +let inner =unsafe {NonNull ::new_unchecked (ptr) };// 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
@@ -349,17 +352,17 @@ unsafe fn from_foreign(ptr: *mut crate::ffi::c_void) -> Self {unsafe {Self ::from_inner (inner) } } -unsafe fn borrow <'a>(ptr: *mut crate ::ffi::c_void ) ->ArcBorrow <'a,T > { +unsafe fn borrow <'a>(ptr: *mut Self ::PointedTo ) ->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 >>()) }; +let inner =unsafe {NonNull ::new_unchecked (ptr) };// 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 borrow_mut <'a>(ptr: *mut core::ffi::c_void ) ->ArcBorrow <'a,T > { +unsafe fn borrow_mut <'a>(ptr: *mut Self ::PointedTo ) ->ArcBorrow <'a,T > {// SAFETY: The safety requirements for `borrow_mut` are a superset of the safety // requirements for `borrow`. unsafe {Self ::borrow (ptr) }
rust/kernel/types.rs +31 -15
96 lines not on this page · raw message
Signature · 1 line
2.47.1
PATCH v14 2/2 rust: xarray: Add an abstraction for XArray
In reply to Tamir DubersteinXArray is an efficient sparse array of pointers. Add a Rust abstraction for this type.
This implementation bounds the element type on ForeignOwnable and requires explicit locking for all operations. Future work may leverage RCU to enable lockless operation.
--- rust/bindings/bindings_helper.h | 6 + rust/helpers/helpers.c | 1 + rust/helpers/xarray.c | 28 ++++ rust/kernel/alloc.rs | 5 + rust/kernel/lib.rs | 1 + rust/kernel/xarray.rs | 279 ++++++++++++++++++++++++++++++++++++++++ 6 files changed, 320 insertions(+)
rust/bindings/bindings_helper.h +6 -0
@@ -30,6 +30,7 @@#include <linux/tracepoint.h> #include <linux/wait.h> #include <linux/workqueue.h> +#include <linux/xarray.h> #include <trace/events/rust_sample.h> /* `bindgen` gets confused at certain things. */
@@ -43,3 +44,8 @@ const gfp_t RUST_CONST_HELPER___GFP_ZERO = __GFP_ZERO;const gfp_t RUST_CONST_HELPER___GFP_HIGHMEM = ___GFP_HIGHMEM;const gfp_t RUST_CONST_HELPER___GFP_NOWARN = ___GFP_NOWARN;const blk_features_t RUST_CONST_HELPER_BLK_FEAT_ROTATIONAL =BLK_FEAT_ROTATIONAL ; + +const xa_mark_t RUST_CONST_HELPER_XA_PRESENT =XA_PRESENT ; + +const gfp_t RUST_CONST_HELPER_XA_FLAGS_ALLOC =XA_FLAGS_ALLOC ; +const gfp_t RUST_CONST_HELPER_XA_FLAGS_ALLOC1 =XA_FLAGS_ALLOC1 ;
rust/helpers/helpers.c +1 -0
@@ -30,3 +30,4 @@#include "vmalloc.c" #include "wait.c" #include "workqueue.c" +#include "xarray.c"
rust/helpers/xarray.c new file +28 -0
@@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <linux/xarray.h> + +int rust_helper_xa_err (void *entry) +{ +return xa_err (entry); +} + +void rust_helper_xa_init_flags (struct xarray *xa,gfp_t flags) +{ +return xa_init_flags (xa, flags); +} + +int rust_helper_xa_trylock (struct xarray *xa) +{ +return xa_trylock (xa); +} + +void rust_helper_xa_lock (struct xarray *xa) +{ +return xa_lock (xa); +} + +void rust_helper_xa_unlock (struct xarray *xa) +{ +return xa_unlock (xa); +}
rust/kernel/alloc.rs +5 -0
@@ -39,6 +39,11 @@pub struct Flags (u32 );impl Flags { +/// Get a flags value with all bits unset. +pub fn empty () ->Self { +Self (0 ) + } +/// Get the raw representation of this flag. pub (crate )fn as_raw (self) ->u32 { self.0
rust/kernel/lib.rs +1 -0
@@ -68,6 +68,7 @@pub mod types;pub mod uaccess;pub mod workqueue; +pub mod xarray;#[doc(hidden)] pub use bindings;
rust/kernel/xarray.rs new file +279 -0
279 lines not on this page · raw message
Signature · 1 line
2.47.1