Skip to contentSkip to conversation

rust: xarray: Add a minimal abstraction for XArray

PATCH Applied Tamir Duberstein 5 participants 12 messages Apr 23, 2025 – May 1, 2025

Subsystems (9)
lore
Share & tools
lore
#0 lore raw

v19 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 v19:
- Rebase on v6.15-rc2.
- Link to v18: https://lore.kernel.org/r/[email protected]

Changes in v18:
- Add INVARIANT comment in XArray::new. (Danilo Krummrich)
- Replace destructuring with field access in
impl<T> From<StoreError<T>> for Error. (Danilo Krummrich)
- Use enumerations in SAFETY comments (3x). (Danilo Krummrich)
- Link to v17: https://lore.kernel.org/r/[email protected]

Changes in v17:
- Drop patch "rust: remove redundant as _ casts". (Danilo Krummrich)
- Drop trailers for shared commit from configfs series[0]. (Danilo
Krummrich)
- Avoid shadowing expressions with .cast() calls. (Danilo Krummrich)
- Link to v16: https://lore.kernel.org/r/[email protected]

Changes in v16:
- Extract prequel patch for as _ casts. (Danilo Krummrich)
- Improve doc and safety comments. (Boqun Feng)
- Pull trailers for shared commit from configfs series[0]. (Andreas Hindborg, Alice Ryhl, Fiona Behrens)
- Link to configfs series: https://lore.kernel.org/rust-for-linux/[email protected]/
- Link to v15: https://lore.kernel.org/r/[email protected]

Changes in v15:
- Rebase on v6.14-rc1.
- Add MAINTAINERS entry.
- Link to v14: https://lore.kernel.org/r/[email protected]

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 (3):
rust: types: add ForeignOwnable::PointedTo
rust: xarray: Add an abstraction for XArray
MAINTAINERS: add entry for Rust XArray API

 MAINTAINERS                     |  11 ++
 rust/bindings/bindings_helper.h |   6 +
 rust/helpers/helpers.c          |   1 +
 rust/helpers/xarray.c           |  28 ++++
 rust/kernel/alloc/kbox.rs       |  38 +++---
 rust/kernel/lib.rs              |   1 +
 rust/kernel/miscdevice.rs       |  10 +-
 rust/kernel/pci.rs              |   2 +-
 rust/kernel/platform.rs         |   2 +-
 rust/kernel/sync/arc.rs         |  21 +--
 rust/kernel/types.rs            |  46 ++++---
 rust/kernel/xarray.rs           | 275 ++++++++++++++++++++++++++++++++++++++++
 12 files changed, 392 insertions(+), 49 deletions(-)

---
base-commit: 9d7a0577c9db35c4cc52db90bc415ea248446472
change-id: 20241020-rust-xarray-bindings-bef514142968

Best regards,

Signature · 1 line
Tamir Duberstein <[email protected]>
#1 lore raw

PATCH v19 1/3 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 | 10 +++++-----
 rust/kernel/pci.rs        |  2 +-
 rust/kernel/platform.rs   |  2 +-
 rust/kernel/sync/arc.rs   | 21 ++++++++++++---------
 rust/kernel/types.rs      | 46 +++++++++++++++++++++++++++++++---------------
 6 files changed, 70 insertions(+), 49 deletions(-)
rust/kernel/alloc/kbox.rs +20 -18
index b77d32f3a58b..6aa88b01e84d 100644
@@ -360,68 +360,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> = &'a T;
     type BorrowedMut<'a> = &'a mut 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) -> &'a T {
+    unsafe fn borrow<'a>(ptr: *mut Self::PointedTo) -> &'a T {
         // 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 crate::ffi::c_void) -> &'a mut T {
-        let ptr = ptr.cast();
+    unsafe fn borrow_mut<'a>(ptr: *mut Self::PointedTo) -> &'a mut 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<&'a T>;
     type BorrowedMut<'a> = Pin<&'a mut 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<&'a T> {
+    unsafe fn borrow<'a>(ptr: *mut Self::PointedTo) -> Pin<&'a 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
         // 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 crate::ffi::c_void) -> Pin<&'a mut T> {
-        let ptr = ptr.cast();
+    unsafe fn borrow_mut<'a>(ptr: *mut Self::PointedTo) -> Pin<&'a mut 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 +5 -5
index fa9ecc42602a..b4c5f74de23d 100644
@@ -200,7 +200,7 @@ impl<T: MiscDevice> MiscdeviceVTable<T> {
         // type.
         //
         // SAFETY: The open call of a file can access the private data.
-        unsafe { (*raw_file).private_data = ptr.into_foreign() };
+        unsafe { (*raw_file).private_data = ptr.into_foreign().cast() };
 
         0
     }
@@ -211,7 +211,7 @@ impl<T: MiscDevice> MiscdeviceVTable<T> {
     /// must be associated with a `MiscDeviceRegistration<T>`.
     unsafe extern "C" fn release(_inode: *mut bindings::inode, file: *mut bindings::file) -> c_int {
         // SAFETY: The release call of a file owns the private data.
-        let private = unsafe { (*file).private_data };
+        let private = unsafe { (*file).private_data }.cast();
         // SAFETY: The release call of a file owns the private data.
         let ptr = unsafe { <T::Ptr as ForeignOwnable>::from_foreign(private) };
 
@@ -228,7 +228,7 @@ impl<T: MiscDevice> MiscdeviceVTable<T> {
     /// `file` must be a valid file that is associated with a `MiscDeviceRegistration<T>`.
     unsafe extern "C" fn ioctl(file: *mut bindings::file, cmd: c_uint, arg: c_ulong) -> c_long {
         // SAFETY: The ioctl call of a file can access the private data.
-        let private = unsafe { (*file).private_data };
+        let private = unsafe { (*file).private_data }.cast();
         // SAFETY: Ioctl calls can borrow the private data of the file.
         let device = unsafe { <T::Ptr as ForeignOwnable>::borrow(private) };
 
@@ -253,7 +253,7 @@ impl<T: MiscDevice> MiscdeviceVTable<T> {
         arg: c_ulong,
     ) -> c_long {
         // SAFETY: The compat ioctl call of a file can access the private data.
-        let private = unsafe { (*file).private_data };
+        let private = unsafe { (*file).private_data }.cast();
         // SAFETY: Ioctl calls can borrow the private data of the file.
         let device = unsafe { <T::Ptr as ForeignOwnable>::borrow(private) };
 
@@ -274,7 +274,7 @@ impl<T: MiscDevice> MiscdeviceVTable<T> {
     /// - `seq_file` must be a valid `struct seq_file` that we can write to.
     unsafe extern "C" fn show_fdinfo(seq_file: *mut bindings::seq_file, file: *mut bindings::file) {
         // SAFETY: The release call of a file owns the private data.
-        let private = unsafe { (*file).private_data };
+        let private = unsafe { (*file).private_data }.cast();
         // SAFETY: Ioctl calls can borrow the private data of the file.
         let device = unsafe { <T::Ptr as ForeignOwnable>::borrow(private) };
         // SAFETY:
rust/kernel/pci.rs +1 -1
index c97d6d470b28..3aeb1250c27f 100644
@@ -89,7 +89,7 @@ extern "C" fn probe_callback(
     extern "C" fn remove_callback(pdev: *mut bindings::pci_dev) {
         // SAFETY: The PCI bus only ever calls the remove callback with a valid pointer to a
         // `struct pci_dev`.
-        let ptr = unsafe { bindings::pci_get_drvdata(pdev) };
+        let ptr = unsafe { bindings::pci_get_drvdata(pdev) }.cast();
 
         // SAFETY: `remove_callback` is only ever called after a successful call to
         // `probe_callback`, hence it's guaranteed that `ptr` points to a valid and initialized
rust/kernel/platform.rs +1 -1
index 4917cb34e2fe..fd4a494f30e8 100644
@@ -80,7 +80,7 @@ extern "C" fn probe_callback(pdev: *mut bindings::platform_device) -> kernel::ff
 
     extern "C" fn remove_callback(pdev: *mut bindings::platform_device) {
         // SAFETY: `pdev` is a valid pointer to a `struct platform_device`.
-        let ptr = unsafe { bindings::platform_get_drvdata(pdev) };
+        let ptr = unsafe { bindings::platform_get_drvdata(pdev) }.cast();
 
         // SAFETY: `remove_callback` is only ever called after a successful call to
         // `probe_callback`, hence it's guaranteed that `ptr` points to a valid and initialized
rust/kernel/sync/arc.rs +12 -9
index 8484c814609a..a42c164e577a 100644
@@ -140,9 +140,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,
 }
@@ -371,18 +372,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
@@ -390,17 +393,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 crate::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.49.0
maintainer
#2 lore raw

Re: [PATCH v19 1/3] rust: types: add `ForeignOwnable::PointedTo`

Quoted 27 lines · On Wed, 23 Apr 2025 09:54:37 -0400 Tamir Duberstein <[email protected]> wrote:

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 | 10 +++++-----
 rust/kernel/pci.rs        |  2 +-
 rust/kernel/platform.rs   |  2 +-
 rust/kernel/sync/arc.rs   | 21 ++++++++++++---------
 rust/kernel/types.rs      | 46 +++++++++++++++++++++++++++++++---------------
 6 files changed, 70 insertions(+), 49 deletions(-)
rust/kernel/alloc/kbox.rs +0 -0
index b77d32f3a58b..6aa88b01e84d 100644

rust/kernel/alloc/kbox.rs fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E> · line 368

Quoted 10 lines
rust/kernel/alloc/kbox.rs +3 -1
@@ -360,68 +360,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;

I don't think this is the correct solution for this. The returned pointer is supposed to opaque, and exposing this type may encourage this is to be wrongly used.

IIUC, the only reason for this to be exposed is for XArray to be able to check alignment. However align_of::<PointedTo>() is not the minimum guaranteed alignment.

For example, if the type is allocated via kernel allocator then it can always guarantee to be at least usize-aligned. ZST can be arbitrarily aligned so ForeignOwnable` implementation could return a validly-aligned pointer for XArray. Actually, I think all current ForeignOwnable implementation can be modified to always give 4-byte aligned pointers.

Having a const associated item indicating the minimum guaranteed alignment for *that specific container* is the correct way IMO, not to reason about the pointee type!

Best,
Gary

Quoted 33 lines
rust/kernel/alloc/kbox.rs +7 -8
     type Borrowed<'a> = &'a T;
     type BorrowedMut<'a> = &'a mut 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) -> &'a T {
+    unsafe fn borrow<'a>(ptr: *mut Self::PointedTo) -> &'a T {
         // 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 crate::ffi::c_void) -> &'a mut T {
-        let ptr = ptr.cast();
+    unsafe fn borrow_mut<'a>(ptr: *mut Self::PointedTo) -> &'a mut 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 }
     }
 }
#3 lore raw

Re: [PATCH v19 1/3] rust: types: add `ForeignOwnable::PointedTo`

Quoted 34 lines · Gary Guo
Quoted 30 lines · On Wed, 23 Apr 2025 09:54:37 -0400 Tamir Duberstein <[email protected]> wrote:

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 | 10 +++++-----
 rust/kernel/pci.rs        |  2 +-
 rust/kernel/platform.rs   |  2 +-
 rust/kernel/sync/arc.rs   | 21 ++++++++++++---------
 rust/kernel/types.rs      | 46 +++++++++++++++++++++++++++++++---------------
 6 files changed, 70 insertions(+), 49 deletions(-)
rust/kernel/alloc/kbox.rs +0 -0
index b77d32f3a58b..6aa88b01e84d 100644
@@ -360,68 +360,70 @@ fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E>
     }
 }
 
Quoted 11 lines

rust/kernel/alloc/kbox.rs fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E> · line 368

Quoted 7 lines
rust/kernel/alloc/kbox.rs +3 -1
-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;

I don't think this is the correct solution for this. The returned pointer is supposed to opaque, and exposing this type may encourage this is to be wrongly used.

Can you give an example?

Quoted 10 lines

IIUC, the only reason for this to be exposed is for XArray to be able to check alignment. However align_of::<PointedTo>() is not the minimum guaranteed alignment.

For example, if the type is allocated via kernel allocator then it can always guarantee to be at least usize-aligned. ZST can be arbitrarily aligned so ForeignOwnable` implementation could return a validly-aligned pointer for XArray. Actually, I think all current ForeignOwnable implementation can be modified to always give 4-byte aligned pointers.

Is your concern that this is *too restrictive*? It might be that the minimum alignment is greater than align_of::<PointedTo>(), but not less.

Quoted 3 lines

Having a const associated item indicating the minimum guaranteed alignment for *that specific container* is the correct way IMO, not to reason about the pointee type!

How do you determine the value? You're at quite some distance from the allocator implementation.

maintainer
#4 lore raw

Re: [PATCH v19 1/3] rust: types: add `ForeignOwnable::PointedTo`

Quoted 17 lines · Tamir Duberstein
Quoted 14 lines · Gary Guo

rust/kernel/alloc/kbox.rs fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E> · line 368

Quoted 7 lines · On Wed, 23 Apr 2025 09:54:37 -0400 Tamir Duberstein <[email protected]> wrote:
rust/kernel/alloc/kbox.rs +3 -1
-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;

I don't think this is the correct solution for this. The returned pointer is supposed to opaque, and exposing this type may encourage this is to be wrongly used.

Quoted 1 line

Can you give an example?

This came up when we discussed this patch in the meeting yesterday:
https://lore.kernel.org/all/[email protected]/

This is incorrect use of the trait. The pointer is supposed to be opaque, and you can't dereference it. See my reply to that patch as well:
https://lore.kernel.org/all/CAH5fLggDwPBzMO2Z48oMjDm4qgoNM0NQs_63TxmVEGy+gtMpOA@mail.gmail.com/

Alice

maintainer
#5 lore raw

Re: [PATCH v19 1/3] rust: types: add `ForeignOwnable::PointedTo`

Quoted 20 lines · Alice Ryhl
Quoted 17 lines · Tamir Duberstein
Quoted 14 lines · Gary Guo

rust/kernel/alloc/kbox.rs fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E> · line 368

Quoted 7 lines · On Wed, 23 Apr 2025 09:54:37 -0400 Tamir Duberstein <[email protected]> wrote:
rust/kernel/alloc/kbox.rs +3 -1
-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;

I don't think this is the correct solution for this. The returned pointer is supposed to opaque, and exposing this type may encourage this is to be wrongly used.

Quoted 1 line

Can you give an example?

Quoted 7 lines

This came up when we discussed this patch in the meeting yesterday:
https://lore.kernel.org/all/[email protected]/

This is incorrect use of the trait. The pointer is supposed to be opaque, and you can't dereference it. See my reply to that patch as well:
https://lore.kernel.org/all/CAH5fLggDwPBzMO2Z48oMjDm4qgoNM0NQs_63TxmVEGy+gtMpOA@mail.gmail.com/

For reference, the outcome of the discussion yesterday:

- The use of ForeignOwnable in the configfs series is not correct. The pointer must be opaque. I will drop the use of ForeignOwnable and adapt Arc methods into_raw/from_raw instead. I had a plan to make the code generic over the pointer type with a bound on ForeignOwnable. A new trait is required for that now.

- There may be a use case for a trait that allows passing ownership of an object to C, similar to ForeignOwnable but with a non-opaque pointer. Trait methods would be into_raw, from_raw, borrow.

- The solution for alignment adopted in this (xarray) series is not ideal. However, given the timeline we will proceed merging the series as is, and then change the solution to the one outlined by Gary in the next cycle.

@Gary you mentioned an implementation of the solution you outlined is already posted to the list. I can't seem to find it, can you point to it?

Best regards,
Andreas Hindborg

#6 lore raw

PATCH v19 2/3 rust: xarray: Add an abstraction for XArray

In reply to Tamir Duberstein

XArray 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/lib.rs              |   1 +
 rust/kernel/xarray.rs           | 275 ++++++++++++++++++++++++++++++++++++++++
 5 files changed, 311 insertions(+)
rust/bindings/bindings_helper.h +6 -0
index ab37e1d35c70..e0bcd130b494 100644
@@ -37,6 +37,7 @@
 #include <linux/tracepoint.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
+#include <linux/xarray.h>
 #include <trace/events/rust_sample.h>
 
 #if defined(CONFIG_DRM_PANIC_SCREEN_QR_CODE)
@@ -55,3 +56,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
index 1e7c84df7252..80785b1e7a63 100644
@@ -38,3 +38,4 @@
 #include "vmalloc.c"
 #include "wait.c"
 #include "workqueue.c"
+#include "xarray.c"
rust/helpers/xarray.c new file +28 -0
new file mode 100644
index 000000000000..60b299f11451
@@ -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/lib.rs +1 -0
index de07aadd1ff5..715fab6b1345 100644
@@ -88,6 +88,7 @@
 pub mod types;
 pub mod uaccess;
 pub mod workqueue;
+pub mod xarray;
 
 #[doc(hidden)]
 pub use bindings;
rust/kernel/xarray.rs new file +275 -0

275 lines not on this page · raw message

Signature · 1 line
2.49.0
#7 lore raw

PATCH v19 3/3 MAINTAINERS: add entry for Rust XArray API

In reply to Tamir Duberstein

Add an entry for the Rust xarray abstractions.

---
 MAINTAINERS | 11 +++++++++++
 1 file changed, 11 insertions(+)
MAINTAINERS +11 -0
index fa1e04e87d1d..925d64be9dd6 100644
@@ -26310,6 +26310,17 @@ F:	lib/test_xarray.c
 F:	lib/xarray.c
 F:	tools/testing/radix-tree
 
+XARRAY API [RUST]
+M:	Tamir Duberstein <[email protected]>
+M:	Andreas Hindborg <[email protected]>
+L:	[email protected]
+S:	Supported
+W:	https://rust-for-linux.com
+B:	https://github.com/Rust-for-Linux/linux/issues
+C:	https://rust-for-linux.zulipchat.com
+T:	git https://github.com/Rust-for-Linux/linux.git rust-next
+F:	rust/kernel/xarray.rs
+
 XBOX DVD IR REMOTE
 M:	Benjamin Valentin <[email protected]>
 S:	Maintained
Signature · 1 line
2.49.0
maintainer Applied
#8 lore raw
In reply to Tamir Duberstein
Quoted 8 lines · Tamir Duberstein

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.

[...]

Applied, thanks!

[1/3] rust: types: add ForeignOwnable::PointedTo

      commit: a68f46e837473de56e2c101bc0df19078a0cfeaf
[2/3] rust: xarray: Add an abstraction for XArray
      commit: dea08321b98ed6b4e06680886f60160d30254a6d
[3/3] MAINTAINERS: add entry for Rust XArray API
      commit: 1061e78014e80982814083ec8375c455848abdb4

Best regards,

Signature · 1 line
Andreas Hindborg <[email protected]>
maintainer
#9 lore raw
Quoted 11 lines · Andreas Hindborg
Quoted 8 lines · Tamir Duberstein

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.

[...]

Quoted 8 lines

Applied, thanks!

[1/3] rust: types: add ForeignOwnable::PointedTo

      commit: a68f46e837473de56e2c101bc0df19078a0cfeaf
[2/3] rust: xarray: Add an abstraction for XArray
      commit: dea08321b98ed6b4e06680886f60160d30254a6d
[3/3] MAINTAINERS: add entry for Rust XArray API
      commit: 1061e78014e80982814083ec8375c455848abdb4

I assume this went into xarray-next? If so, you probably want to adjust the MAINTAINERS entry accordingly.

maintainer
#10 lore raw
Quoted 21 lines · Danilo Krummrich
Quoted 11 lines · Andreas Hindborg
Quoted 8 lines · Tamir Duberstein

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.

[...]

Quoted 8 lines

Applied, thanks!

[1/3] rust: types: add ForeignOwnable::PointedTo

      commit: a68f46e837473de56e2c101bc0df19078a0cfeaf
[2/3] rust: xarray: Add an abstraction for XArray
      commit: dea08321b98ed6b4e06680886f60160d30254a6d
[3/3] MAINTAINERS: add entry for Rust XArray API
      commit: 1061e78014e80982814083ec8375c455848abdb4
Quoted 2 lines

I assume this went into xarray-next? If so, you probably want to adjust the MAINTAINERS entry accordingly.

Yes, thanks for catching that. I'm very much in the learning phase still.

Best regards,
Andreas Hindborg

maintainer
#11 lore raw
Quoted 23 lines · Andreas Hindborg
Quoted 21 lines · Danilo Krummrich
Quoted 19 lines · Andreas Hindborg
Quoted 8 lines · Tamir Duberstein

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.

[...]

Applied, thanks!

[1/3] rust: types: add ForeignOwnable::PointedTo

      commit: a68f46e837473de56e2c101bc0df19078a0cfeaf
[2/3] rust: xarray: Add an abstraction for XArray
      commit: dea08321b98ed6b4e06680886f60160d30254a6d
[3/3] MAINTAINERS: add entry for Rust XArray API
      commit: 1061e78014e80982814083ec8375c455848abdb4
Quoted 6 lines
Quoted 2 lines

I assume this went into xarray-next? If so, you probably want to adjust the MAINTAINERS entry accordingly.

Yes, thanks for catching that. I'm very much in the learning phase still.

I changed the branch to xarray-rust on my side.

Best regards,
Andreas Hindborg