[PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[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.

Link: https://lore.kernel.org/rust-for-linux/20240309235927.168915-2-mcanal@igalia.com/ [0]
---
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/sync/arc.rs         |  21 ++--
 rust/kernel/types.rs            |  46 ++++---
 rust/kernel/xarray.rs           | 259 ++++++++++++++++++++++++++++++++++++++++
 9 files changed, 363 insertions(+), 42 deletions(-)
---
base-commit: b2603f8ac8217bc59f5c7f248ac248423b9b99cb
change-id: 20241020-rust-xarray-bindings-bef514142968
prerequisite-change-id: 20241030-borrow-mut-75f181feef4c:v5
prerequisite-patch-id: f801fb31bb4f202b3327f5fdb50d3018e25347d1
prerequisite-patch-id: b57aa4f44b238d4cb80f00276a188d9ba0c743cc
prerequisite-patch-id: 2387ec5af1cc03614d3dff5a95cefcd243befd65
prerequisite-patch-id: 8de2f688833d4d16eece062c5b6937a95a6a0e8b
prerequisite-patch-id: 7f845443f373f975a888f01c3761fe8aa04b8a3c
prerequisite-patch-id: 5a9856c7363b33f0adfe8658e076b35abf960d23

Best regards,
-- 
Tamir Duberstein <tamird@gmail.com>

[PATCH v9 1/2] rust: types: add `ForeignOwnable::PointedTo`

[Tamir Duberstein]

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.

Signed-off-by: Tamir Duberstein <tamird@gmail.com>
---
 rust/kernel/alloc/kbox.rs | 38 ++++++++++++++++++++------------------
 rust/kernel/sync/arc.rs   | 21 ++++++++++++---------
 rust/kernel/types.rs      | 46 +++++++++++++++++++++++++++++++---------------
 3 files changed, 63 insertions(+), 42 deletions(-)

diff --git a/rust/kernel/alloc/kbox.rs b/rust/kernel/alloc/kbox.rs
index 4ffc4e1b22b2b7c2ea8e8ed5b7f7a8534625249f..4e7a0ce9cc9c24f2e828f41e9105acc4048333d5 100644
--- a/rust/kernel/alloc/kbox.rs
+++ b/rust/kernel/alloc/kbox.rs
@@ -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> = &'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 core::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 core::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
diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
index eb5cd8b360a3507a527978aaf96dbc3a80d4ae2c..8e29c332db86ae869d81f75de9c21fa73174de9a 100644
--- a/rust/kernel/sync/arc.rs
+++ b/rust/kernel/sync/arc.rs
@@ -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) }
diff --git a/rust/kernel/types.rs b/rust/kernel/types.rs
index c150cf509d52fd5006834cf1c6745e4ea3504a55..02b7fa873f0f29fd24982e1b93bfccdb20fad1b3 100644
--- a/rust/kernel/types.rs
+++ b/rust/kernel/types.rs
@@ -18,7 +18,19 @@
 ///
 /// This trait is meant to be used in cases when Rust objects are stored in C objects and
 /// eventually "freed" back to Rust.
-pub trait ForeignOwnable: Sized {
+///
+/// # Safety
+///
+/// Implementers must ensure that [`into_foreign`] returns a pointer which meets the alignment
+/// requirements of [`PointedTo`].
+///
+/// [`into_foreign`]: Self::into_foreign
+/// [`PointedTo`]: Self::PointedTo
+pub unsafe trait ForeignOwnable: Sized {
+    /// Type used when the value is foreign-owned. In practical terms only defines the alignment of
+    /// the pointer.
+    type PointedTo;
+
     /// Type used to immutably borrow a value that is currently foreign-owned.
     type Borrowed<'a>;
 
@@ -27,16 +39,18 @@ pub trait ForeignOwnable: Sized {
 
     /// Converts a Rust-owned object to a foreign-owned one.
     ///
-    /// The foreign representation is a pointer to void. There are no guarantees for this pointer.
-    /// For example, it might be invalid, dangling or pointing to uninitialized memory. Using it in
-    /// any way except for [`from_foreign`], [`try_from_foreign`], [`borrow`], or [`borrow_mut`] can
-    /// result in undefined behavior.
+    /// # Guarantees
+    ///
+    /// The return value is guaranteed to be well-aligned, but there are no other guarantees for
+    /// this pointer. For example, it might be null, dangling, or point to uninitialized memory.
+    /// Using it in any way except for [`ForeignOwnable::from_foreign`], [`ForeignOwnable::borrow`],
+    /// [`ForeignOwnable::try_from_foreign`] can result in undefined behavior.
     ///
     /// [`from_foreign`]: Self::from_foreign
     /// [`try_from_foreign`]: Self::try_from_foreign
     /// [`borrow`]: Self::borrow
     /// [`borrow_mut`]: Self::borrow_mut
-    fn into_foreign(self) -> *mut crate::ffi::c_void;
+    fn into_foreign(self) -> *mut Self::PointedTo;
 
     /// Converts a foreign-owned object back to a Rust-owned one.
     ///
@@ -46,7 +60,7 @@ pub trait ForeignOwnable: Sized {
     /// must not be passed to `from_foreign` more than once.
     ///
     /// [`into_foreign`]: Self::into_foreign
-    unsafe fn from_foreign(ptr: *mut crate::ffi::c_void) -> Self;
+    unsafe fn from_foreign(ptr: *mut Self::PointedTo) -> Self;
 
     /// Tries to convert a foreign-owned object back to a Rust-owned one.
     ///
@@ -58,7 +72,7 @@ pub trait ForeignOwnable: Sized {
     /// `ptr` must either be null or satisfy the safety requirements for [`from_foreign`].
     ///
     /// [`from_foreign`]: Self::from_foreign
-    unsafe fn try_from_foreign(ptr: *mut crate::ffi::c_void) -> Option<Self> {
+    unsafe fn try_from_foreign(ptr: *mut Self::PointedTo) -> Option<Self> {
         if ptr.is_null() {
             None
         } else {
@@ -81,7 +95,7 @@ unsafe fn try_from_foreign(ptr: *mut crate::ffi::c_void) -> Option<Self> {
     ///
     /// [`into_foreign`]: Self::into_foreign
     /// [`from_foreign`]: Self::from_foreign
-    unsafe fn borrow<'a>(ptr: *mut crate::ffi::c_void) -> Self::Borrowed<'a>;
+    unsafe fn borrow<'a>(ptr: *mut Self::PointedTo) -> Self::Borrowed<'a>;
 
     /// Borrows a foreign-owned object mutably.
     ///
@@ -109,21 +123,23 @@ unsafe fn try_from_foreign(ptr: *mut crate::ffi::c_void) -> Option<Self> {
     /// [`from_foreign`]: Self::from_foreign
     /// [`borrow`]: Self::borrow
     /// [`Arc`]: crate::sync::Arc
-    unsafe fn borrow_mut<'a>(ptr: *mut crate::ffi::c_void) -> Self::BorrowedMut<'a>;
+    unsafe fn borrow_mut<'a>(ptr: *mut Self::PointedTo) -> Self::BorrowedMut<'a>;
 }
 
-impl ForeignOwnable for () {
+// SAFETY: The `into_foreign` function returns a pointer that is dangling, but well-aligned.
+unsafe impl ForeignOwnable for () {
+    type PointedTo = ();
     type Borrowed<'a> = ();
     type BorrowedMut<'a> = ();
 
-    fn into_foreign(self) -> *mut crate::ffi::c_void {
+    fn into_foreign(self) -> *mut Self::PointedTo {
         core::ptr::NonNull::dangling().as_ptr()
     }
 
-    unsafe fn from_foreign(_: *mut crate::ffi::c_void) -> Self {}
+    unsafe fn from_foreign(_: *mut Self::PointedTo) -> Self {}
 
-    unsafe fn borrow<'a>(_: *mut crate::ffi::c_void) -> Self::Borrowed<'a> {}
-    unsafe fn borrow_mut<'a>(_: *mut crate::ffi::c_void) -> Self::BorrowedMut<'a> {}
+    unsafe fn borrow<'a>(_: *mut Self::PointedTo) -> Self::Borrowed<'a> {}
+    unsafe fn borrow_mut<'a>(_: *mut Self::PointedTo) -> Self::BorrowedMut<'a> {}
 }
 
 /// Runs a cleanup function/closure when dropped.

-- 
2.47.0

[PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[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.

Signed-off-by: Tamir Duberstein <tamird@gmail.com>
---
 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           | 259 ++++++++++++++++++++++++++++++++++++++++
 6 files changed, 300 insertions(+)

diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index a80783fcbe042a28124620ce4710ed5bdc2d0790..131ed24629c7411419c99ebd01727fd17ee4f802 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -21,6 +21,7 @@
 #include <linux/slab.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
+#include <linux/xarray.h>
 
 /* `bindgen` gets confused at certain things. */
 const size_t RUST_CONST_HELPER_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;
@@ -33,3 +34,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;
diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c
index 20a0c69d5cc7b8775f505f94d06d06379a4583b0..22c3c9fb6298b0a3b59b1290976e927ef0bc9b8e 100644
--- a/rust/helpers/helpers.c
+++ b/rust/helpers/helpers.c
@@ -25,3 +25,4 @@
 #include "vmalloc.c"
 #include "wait.c"
 #include "workqueue.c"
+#include "xarray.c"
diff --git a/rust/helpers/xarray.c b/rust/helpers/xarray.c
new file mode 100644
index 0000000000000000000000000000000000000000..60b299f11451d2c4a75e50e25dec4dac13f143f4
--- /dev/null
+++ b/rust/helpers/xarray.c
@@ -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);
+}
diff --git a/rust/kernel/alloc.rs b/rust/kernel/alloc.rs
index f2f7f3a53d298cf899e062346202ba3285ce3676..be9f164ece2e0fe71143e0201247d2b70c193c51 100644
--- a/rust/kernel/alloc.rs
+++ b/rust/kernel/alloc.rs
@@ -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
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index bf8d7f841f9425d19a24f3910929839cfe705c7f..6f301ad7f6fbc57b09dcd6a6e90bd87f29df948f 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -60,6 +60,7 @@
 pub mod types;
 pub mod uaccess;
 pub mod workqueue;
+pub mod xarray;
 
 #[doc(hidden)]
 pub use bindings;
diff --git a/rust/kernel/xarray.rs b/rust/kernel/xarray.rs
new file mode 100644
index 0000000000000000000000000000000000000000..57dbdb0a82623e3de779e26525e7dd27ce4db712
--- /dev/null
+++ b/rust/kernel/xarray.rs
@@ -0,0 +1,259 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! XArray abstraction.
+//!
+//! C header: [`include/linux/xarray.h`](srctree/include/linux/xarray.h)
+
+use core::pin::Pin;
+
+use crate::{
+    alloc, bindings, build_assert, build_error,
+    error::{Error, Result},
+    init::PinInit,
+    pin_init,
+    types::{ForeignOwnable, Opaque},
+};
+use core::{iter, marker::PhantomData, mem};
+use macros::{pin_data, pinned_drop};
+
+/// An array which efficiently maps sparse integer indices to owned objects.
+///
+/// This is similar to a [`crate::alloc::kvec::Vec<Option<T>>`], but more efficient when there are
+/// holes in the index space, and can be efficiently grown.
+///
+/// # Invariants
+///
+/// `self.xa` is always an initialized and valid [`bindings::xarray`] whose entries are either
+/// `XA_ZERO_ENTRY` or came from `T::into_foreign`.
+///
+/// # Examples
+///
+/// ```rust
+/// use kernel::alloc::KBox;
+/// use kernel::xarray::{AllocKind, XArray};
+///
+/// let xa = KBox::pin_init(XArray::new(AllocKind::Alloc1), GFP_KERNEL)?;
+///
+/// let dead = KBox::new(0xdead, GFP_KERNEL)?;
+/// let beef = KBox::new(0xbeef, GFP_KERNEL)?;
+///
+/// let mut guard = xa.lock();
+///
+/// assert_eq!(guard.get(0), None);
+///
+/// assert_eq!(guard.store(0, dead, GFP_KERNEL).unwrap().as_deref(), None);
+/// assert_eq!(guard.get(0).copied(), Some(0xdead));
+///
+/// *guard.get_mut(0).unwrap() = 0xffff;
+/// assert_eq!(guard.get(0).copied(), Some(0xffff));
+///
+/// assert_eq!(guard.store(0, beef, GFP_KERNEL).unwrap().as_deref().copied(), Some(0xffff));
+/// assert_eq!(guard.get(0).copied(), Some(0xbeef));
+///
+/// guard.remove(0);
+/// assert_eq!(guard.get(0), None);
+///
+/// # Ok::<(), Error>(())
+/// ```
+#[pin_data(PinnedDrop)]
+pub struct XArray<T: ForeignOwnable> {
+    #[pin]
+    xa: Opaque<bindings::xarray>,
+    _p: PhantomData<T>,
+}
+
+#[pinned_drop]
+impl<T: ForeignOwnable> PinnedDrop for XArray<T> {
+    fn drop(self: Pin<&mut Self>) {
+        self.iter().for_each(|ptr| {
+            let ptr = ptr.as_ptr();
+            // SAFETY: `ptr` came from `T::into_foreign`.
+            //
+            // INVARIANT: we own the only reference to the array which is being dropped so the
+            // broken invariant is not observable on function exit.
+            drop(unsafe { T::from_foreign(ptr) })
+        });
+
+        // SAFETY: `self.xa` is always valid by the type invariant.
+        unsafe { bindings::xa_destroy(self.xa.get()) };
+    }
+}
+
+/// Flags passed to [`XArray::new`] to configure the array's allocation tracking behavior.
+pub enum AllocKind {
+    /// Consider the first element to be at index 0.
+    Alloc,
+    /// Consider the first element to be at index 1.
+    Alloc1,
+}
+
+impl<T: ForeignOwnable> XArray<T> {
+    /// Creates a new [`XArray`].
+    pub fn new(kind: AllocKind) -> impl PinInit<Self> {
+        let flags = match kind {
+            AllocKind::Alloc => bindings::XA_FLAGS_ALLOC,
+            AllocKind::Alloc1 => bindings::XA_FLAGS_ALLOC1,
+        };
+        pin_init!(Self {
+            // SAFETY: `xa` is valid while the closure is called.
+            xa <- Opaque::ffi_init(|xa| unsafe {
+                bindings::xa_init_flags(xa, flags)
+            }),
+            _p: PhantomData,
+        })
+    }
+
+    fn iter(&self) -> impl Iterator<Item = core::ptr::NonNull<T::PointedTo>> + '_ {
+        // TODO: Remove when https://lore.kernel.org/all/20240913213041.395655-5-gary@garyguo.net/ is applied.
+        const MIN: core::ffi::c_ulong = core::ffi::c_ulong::MIN;
+        const MAX: core::ffi::c_ulong = core::ffi::c_ulong::MAX;
+
+        let mut index = MIN;
+
+        // SAFETY: `self.xa` is always valid by the type invariant.
+        iter::once(unsafe {
+            bindings::xa_find(self.xa.get(), &mut index, MAX, bindings::XA_PRESENT)
+        })
+        .chain(iter::from_fn(move || {
+            // SAFETY: `self.xa` is always valid by the type invariant.
+            Some(unsafe {
+                bindings::xa_find_after(self.xa.get(), &mut index, MAX, bindings::XA_PRESENT)
+            })
+        }))
+        .map_while(|ptr| core::ptr::NonNull::new(ptr.cast()))
+    }
+
+    /// Attempts to lock the [`XArray`] for exclusive access.
+    pub fn try_lock(&self) -> Option<Guard<'_, T>> {
+        // SAFETY: `self.xa` is always valid by the type invariant.
+        (unsafe { bindings::xa_trylock(self.xa.get()) } != 0).then(|| Guard { xa: self })
+    }
+
+    /// Locks the [`XArray`] for exclusive access.
+    pub fn lock(&self) -> Guard<'_, T> {
+        // SAFETY: `self.xa` is always valid by the type invariant.
+        unsafe { bindings::xa_lock(self.xa.get()) };
+
+        Guard { xa: self }
+    }
+}
+
+/// A lock guard.
+///
+/// The lock is unlocked when the guard goes out of scope.
+#[must_use = "the lock unlocks immediately when the guard is unused"]
+pub struct Guard<'a, T: ForeignOwnable> {
+    xa: &'a XArray<T>,
+}
+
+impl<T: ForeignOwnable> Drop for Guard<'_, T> {
+    fn drop(&mut self) {
+        // SAFETY: `self.xa.xa` is always valid by the type invariant.
+        //
+        // SAFETY: The caller holds the lock, so it is safe to unlock it.
+        unsafe { bindings::xa_unlock(self.xa.xa.get()) };
+    }
+}
+
+// TODO: Remove when https://lore.kernel.org/all/20240913213041.395655-5-gary@garyguo.net/ is applied.
+fn to_index(i: usize) -> core::ffi::c_ulong {
+    i.try_into()
+        .unwrap_or_else(|_| build_error!("cannot convert usize to c_ulong"))
+}
+
+impl<'a, T: ForeignOwnable> Guard<'a, T> {
+    fn load<F, U>(&mut self, index: usize, f: F) -> Option<U>
+    where
+        F: FnOnce(core::ptr::NonNull<T::PointedTo>) -> U,
+    {
+        // SAFETY: `self.xa.xa` is always valid by the type invariant.
+        let ptr = unsafe { bindings::xa_load(self.xa.xa.get(), to_index(index)) };
+        let ptr = core::ptr::NonNull::new(ptr.cast())?;
+        Some(f(ptr))
+    }
+
+    /// Loads an entry from the array.
+    ///
+    /// Returns the entry at the given index.
+    pub fn get(&mut self, index: usize) -> Option<T::Borrowed<'_>> {
+        self.load(index, |ptr| {
+            // SAFETY: `ptr` came from `T::into_foreign`.
+            unsafe { T::borrow(ptr.as_ptr()) }
+        })
+    }
+
+    /// Loads an entry from the array.
+    ///
+    /// Returns the entry at the given index.
+    pub fn get_mut(&mut self, index: usize) -> Option<T::BorrowedMut<'_>> {
+        self.load(index, |ptr| {
+            // SAFETY: `ptr` came from `T::into_foreign`.
+            unsafe { T::borrow_mut(ptr.as_ptr()) }
+        })
+    }
+
+    /// Erases an entry from the array.
+    ///
+    /// Returns the entry which was previously at the given index.
+    pub fn remove(&mut self, index: usize) -> Option<T> {
+        // SAFETY: `self.xa.xa` is always valid by the type invariant.
+        //
+        // SAFETY: The caller holds the lock.
+        let ptr = unsafe { bindings::__xa_erase(self.xa.xa.get(), to_index(index)) }.cast();
+        // SAFETY: `ptr` is either NULL or came from `T::into_foreign`.
+        unsafe { T::try_from_foreign(ptr) }
+    }
+
+    /// Stores an entry in the array.
+    ///
+    /// On success, returns the entry which was previously at the given index.
+    ///
+    /// On failure, returns the entry which was attempted to be stored.
+    pub fn store(
+        &mut self,
+        index: usize,
+        value: T,
+        gfp: alloc::Flags,
+    ) -> Result<Option<T>, (T, Error)> {
+        build_assert!(
+            mem::align_of::<T::PointedTo>() >= 4,
+            "pointers stored in XArray must be 4-byte aligned"
+        );
+        let new = value.into_foreign();
+
+        let old = {
+            let new = new.cast();
+            // SAFETY: `self.xa.xa` is always valid by the type invariant.
+            //
+            // SAFETY: The caller holds the lock.
+            //
+            // INVARIANT: `new` came from `T::into_foreign`.
+            unsafe { bindings::__xa_store(self.xa.xa.get(), to_index(index), new, gfp.as_raw()) }
+        };
+
+        // SAFETY: `__xa_store` returns the old entry at this index on success or `xa_err` if an
+        // error happened.
+        match unsafe { bindings::xa_err(old) } {
+            0 => {
+                let old = old.cast();
+                // SAFETY: `ptr` is either NULL or came from `T::into_foreign`.
+                Ok(unsafe { T::try_from_foreign(old) })
+            }
+            errno => {
+                // SAFETY: `new` came from `T::into_foreign` and `__xa_store` does not take
+                // ownership of the value on error.
+                let value = unsafe { T::from_foreign(new) };
+                Err((value, Error::from_errno(errno)))
+            }
+        }
+    }
+}
+
+// SAFETY: It is safe to send `XArray<T>` to another thread when the underlying `T` is `Send`
+// because XArray is thread-safe and all mutation operations are synchronized.
+unsafe impl<T: ForeignOwnable + Send> Send for XArray<T> {}
+
+// SAFETY: It is safe to send `&XArray<T>` to another thread when the underlying `T` is `Sync`
+// because it effectively means sharing `&T` (which is safe because `T` is `Sync`). Additionally,
+// `T` is `Send` because XArray is thread-safe and all mutation operations are internally locked.
+unsafe impl<T: ForeignOwnable + Send + Sync> Sync for XArray<T> {}

-- 
2.47.0

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Boqun Feng]

On Mon, Nov 18, 2024 at 11:33:36AM -0500, Tamir Duberstein wrote:
[...]
> +
> +/// A lock guard.
> +///
> +/// The lock is unlocked when the guard goes out of scope.
> +#[must_use = "the lock unlocks immediately when the guard is unused"]
> +pub struct Guard<'a, T: ForeignOwnable> {
> +    xa: &'a XArray<T>,
> +}

`Guard` would be `Send` if `XArray<T>` is `Sync`, however, it's
incorrect since `Guard` represents an xa_lock() held, and that's a
spin_lock, so cannot be dropped on another thread/context. `Guard`
should probably be marked as `!Send`. Or am I missing something subtle
here?

Regards,
Boqun

> +
> +impl<T: ForeignOwnable> Drop for Guard<'_, T> {
> +    fn drop(&mut self) {
> +        // SAFETY: `self.xa.xa` is always valid by the type invariant.
> +        //
> +        // SAFETY: The caller holds the lock, so it is safe to unlock it.
> +        unsafe { bindings::xa_unlock(self.xa.xa.get()) };
> +    }
> +}
> +
[...]
> +// SAFETY: It is safe to send `XArray<T>` to another thread when the underlying `T` is `Send`
> +// because XArray is thread-safe and all mutation operations are synchronized.
> +unsafe impl<T: ForeignOwnable + Send> Send for XArray<T> {}
> +
> +// SAFETY: It is safe to send `&XArray<T>` to another thread when the underlying `T` is `Sync`
> +// because it effectively means sharing `&T` (which is safe because `T` is `Sync`). Additionally,
> +// `T` is `Send` because XArray is thread-safe and all mutation operations are internally locked.
> +unsafe impl<T: ForeignOwnable + Send + Sync> Sync for XArray<T> {}
> 
> -- 
> 2.47.0
> 
> 

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Tamir Duberstein]

On Mon, Nov 18, 2024 at 5:18 PM Boqun Feng <boqun.feng@gmail.com> wrote:
>
> On Mon, Nov 18, 2024 at 11:33:36AM -0500, Tamir Duberstein wrote:
> [...]
> > +
> > +/// A lock guard.
> > +///
> > +/// The lock is unlocked when the guard goes out of scope.
> > +#[must_use = "the lock unlocks immediately when the guard is unused"]
> > +pub struct Guard<'a, T: ForeignOwnable> {
> > +    xa: &'a XArray<T>,
> > +}
>
> `Guard` would be `Send` if `XArray<T>` is `Sync`, however, it's
> incorrect since `Guard` represents an xa_lock() held, and that's a
> spin_lock, so cannot be dropped on another thread/context. `Guard`
> should probably be marked as `!Send`. Or am I missing something subtle
> here?

I didn't know about this requirement, thanks for calling it out. I
have added `_not_send: PhantomData<*mut ()>` in v10.

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Alice Ryhl]

On Tue, Nov 19, 2024 at 5:24 PM Tamir Duberstein <tamird@gmail.com> wrote:
>
> On Mon, Nov 18, 2024 at 5:18 PM Boqun Feng <boqun.feng@gmail.com> wrote:
> >
> > On Mon, Nov 18, 2024 at 11:33:36AM -0500, Tamir Duberstein wrote:
> > [...]
> > > +
> > > +/// A lock guard.
> > > +///
> > > +/// The lock is unlocked when the guard goes out of scope.
> > > +#[must_use = "the lock unlocks immediately when the guard is unused"]
> > > +pub struct Guard<'a, T: ForeignOwnable> {
> > > +    xa: &'a XArray<T>,
> > > +}
> >
> > `Guard` would be `Send` if `XArray<T>` is `Sync`, however, it's
> > incorrect since `Guard` represents an xa_lock() held, and that's a
> > spin_lock, so cannot be dropped on another thread/context. `Guard`
> > should probably be marked as `!Send`. Or am I missing something subtle
> > here?
>
> I didn't know about this requirement, thanks for calling it out. I
> have added `_not_send: PhantomData<*mut ()>` in v10.

You can use _nts: NotThreadSafe. The type in question has landed in
6.13 and is available in Linus's tree since yesterday.

Alice

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Tamir Duberstein]

On Tue, Nov 19, 2024 at 11:28 AM Alice Ryhl <aliceryhl@google.com> wrote:
>
> On Tue, Nov 19, 2024 at 5:24 PM Tamir Duberstein <tamird@gmail.com> wrote:
> >
> > On Mon, Nov 18, 2024 at 5:18 PM Boqun Feng <boqun.feng@gmail.com> wrote:
> > >
> > > On Mon, Nov 18, 2024 at 11:33:36AM -0500, Tamir Duberstein wrote:
> > > [...]
> > > > +
> > > > +/// A lock guard.
> > > > +///
> > > > +/// The lock is unlocked when the guard goes out of scope.
> > > > +#[must_use = "the lock unlocks immediately when the guard is unused"]
> > > > +pub struct Guard<'a, T: ForeignOwnable> {
> > > > +    xa: &'a XArray<T>,
> > > > +}
> > >
> > > `Guard` would be `Send` if `XArray<T>` is `Sync`, however, it's
> > > incorrect since `Guard` represents an xa_lock() held, and that's a
> > > spin_lock, so cannot be dropped on another thread/context. `Guard`
> > > should probably be marked as `!Send`. Or am I missing something subtle
> > > here?
> >
> > I didn't know about this requirement, thanks for calling it out. I
> > have added `_not_send: PhantomData<*mut ()>` in v10.
>
> You can use _nts: NotThreadSafe. The type in question has landed in
> 6.13 and is available in Linus's tree since yesterday.

TIL, thanks - though it looks like the field name is still `_not_send`.

How do I set the base-commit/deps such that both
https://github.com/torvalds/linux/commit/e7572e5deaf3bc36818f19ba35ac8e0c454c8bac
and https://github.com/Rust-for-Linux/linux/commit/d072acda4862f095ec9056979b654cc06a22cc68
are present, given that the former is in 6.13 and the latter in
rust-next?

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Alice Ryhl]

On Tue, Nov 19, 2024 at 5:40 PM Tamir Duberstein <tamird@gmail.com> wrote:
>
> On Tue, Nov 19, 2024 at 11:28 AM Alice Ryhl <aliceryhl@google.com> wrote:
> >
> > On Tue, Nov 19, 2024 at 5:24 PM Tamir Duberstein <tamird@gmail.com> wrote:
> > >
> > > On Mon, Nov 18, 2024 at 5:18 PM Boqun Feng <boqun.feng@gmail.com> wrote:
> > > >
> > > > On Mon, Nov 18, 2024 at 11:33:36AM -0500, Tamir Duberstein wrote:
> > > > [...]
> > > > > +
> > > > > +/// A lock guard.
> > > > > +///
> > > > > +/// The lock is unlocked when the guard goes out of scope.
> > > > > +#[must_use = "the lock unlocks immediately when the guard is unused"]
> > > > > +pub struct Guard<'a, T: ForeignOwnable> {
> > > > > +    xa: &'a XArray<T>,
> > > > > +}
> > > >
> > > > `Guard` would be `Send` if `XArray<T>` is `Sync`, however, it's
> > > > incorrect since `Guard` represents an xa_lock() held, and that's a
> > > > spin_lock, so cannot be dropped on another thread/context. `Guard`
> > > > should probably be marked as `!Send`. Or am I missing something subtle
> > > > here?
> > >
> > > I didn't know about this requirement, thanks for calling it out. I
> > > have added `_not_send: PhantomData<*mut ()>` in v10.
> >
> > You can use _nts: NotThreadSafe. The type in question has landed in
> > 6.13 and is available in Linus's tree since yesterday.
>
> TIL, thanks - though it looks like the field name is still `_not_send`.
>
> How do I set the base-commit/deps such that both
> https://github.com/torvalds/linux/commit/e7572e5deaf3bc36818f19ba35ac8e0c454c8bac
> and https://github.com/Rust-for-Linux/linux/commit/d072acda4862f095ec9056979b654cc06a22cc68
> are present, given that the former is in 6.13 and the latter in
> rust-next?

Either you merge them yourself or you wait for rust-next to get merged
into Linus's branch.

Alice

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Tamir Duberstein]

On Tue, Nov 19, 2024 at 11:43 AM Alice Ryhl <aliceryhl@google.com> wrote:
>
> On Tue, Nov 19, 2024 at 5:40 PM Tamir Duberstein <tamird@gmail.com> wrote:
> >
> > On Tue, Nov 19, 2024 at 11:28 AM Alice Ryhl <aliceryhl@google.com> wrote:
> > >
> > > On Tue, Nov 19, 2024 at 5:24 PM Tamir Duberstein <tamird@gmail.com> wrote:
> > > >
> > > > On Mon, Nov 18, 2024 at 5:18 PM Boqun Feng <boqun.feng@gmail.com> wrote:
> > > > >
> > > > > On Mon, Nov 18, 2024 at 11:33:36AM -0500, Tamir Duberstein wrote:
> > > > > [...]
> > > > > > +
> > > > > > +/// A lock guard.
> > > > > > +///
> > > > > > +/// The lock is unlocked when the guard goes out of scope.
> > > > > > +#[must_use = "the lock unlocks immediately when the guard is unused"]
> > > > > > +pub struct Guard<'a, T: ForeignOwnable> {
> > > > > > +    xa: &'a XArray<T>,
> > > > > > +}
> > > > >
> > > > > `Guard` would be `Send` if `XArray<T>` is `Sync`, however, it's
> > > > > incorrect since `Guard` represents an xa_lock() held, and that's a
> > > > > spin_lock, so cannot be dropped on another thread/context. `Guard`
> > > > > should probably be marked as `!Send`. Or am I missing something subtle
> > > > > here?
> > > >
> > > > I didn't know about this requirement, thanks for calling it out. I
> > > > have added `_not_send: PhantomData<*mut ()>` in v10.
> > >
> > > You can use _nts: NotThreadSafe. The type in question has landed in
> > > 6.13 and is available in Linus's tree since yesterday.
> >
> > TIL, thanks - though it looks like the field name is still `_not_send`.
> >
> > How do I set the base-commit/deps such that both
> > https://github.com/torvalds/linux/commit/e7572e5deaf3bc36818f19ba35ac8e0c454c8bac
> > and https://github.com/Rust-for-Linux/linux/commit/d072acda4862f095ec9056979b654cc06a22cc68
> > are present, given that the former is in 6.13 and the latter in
> > rust-next?
>
> Either you merge them yourself or you wait for rust-next to get merged
> into Linus's branch.

Sure, I can merge them locally - but how do I properly send a patch
that relies on both to the list?

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Miguel Ojeda]

On Tue, Nov 19, 2024 at 5:51 PM Tamir Duberstein <tamird@gmail.com> wrote:
>
> Sure, I can merge them locally - but how do I properly send a patch
> that relies on both to the list?

You can mention in the cover letter your prerequisites.

Cheers,
Miguel

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Tamir Duberstein]

Looks like there are merge conflicts between v6.13 and rust-next.
What's the usual process for resolution?

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Miguel Ojeda]

On Tue, Nov 19, 2024 at 7:22 PM Tamir Duberstein <tamird@gmail.com> wrote:
>
> Looks like there are merge conflicts between v6.13 and rust-next.
> What's the usual process for resolution?

You can take a look, for instance, at how it was done in linux-next.

(Nit: mainline is not yet v6.13)

Cheers,
Miguel

Re: [PATCH v9 2/2] rust: xarray: Add an abstraction for XArray

[Tamir Duberstein]

On Tue, Nov 19, 2024 at 1:40 PM Miguel Ojeda
<miguel.ojeda.sandonis@gmail.com> wrote:
>
> On Tue, Nov 19, 2024 at 7:22 PM Tamir Duberstein <tamird@gmail.com> wrote:
> >
> > Looks like there are merge conflicts between v6.13 and rust-next.
> > What's the usual process for resolution?
>
> You can take a look, for instance, at how it was done in linux-next.
>
> (Nit: mainline is not yet v6.13)

I guess I can just set base-commit to linux-next.

Re: [PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[Miguel Ojeda]

On Mon, Nov 18, 2024 at 5:33 PM Tamir Duberstein <tamird@gmail.com> wrote:
>
> This is a reimagining relative to earlier versions[0] by Asahi Lina and
> Maíra Canal.

Maíra's latest version has both of them listed as co-authors in the
main patch -- how close is this to that version? (I see some bits that
look fairly similar)

Thanks!

Cheers,
Miguel

Re: [PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[Tamir Duberstein]

On Mon, Nov 18, 2024 at 11:52 AM Miguel Ojeda
<miguel.ojeda.sandonis@gmail.com> wrote:
>
> On Mon, Nov 18, 2024 at 5:33 PM Tamir Duberstein <tamird@gmail.com> wrote:
> >
> > This is a reimagining relative to earlier versions[0] by Asahi Lina and
> > Maíra Canal.
>
> Maíra's latest version has both of them listed as co-authors in the
> main patch -- how close is this to that version? (I see some bits that
> look fairly similar)
>
> Thanks!
>
> Cheers,
> Miguel

It's fairly different, and I discussed with both of them - we agreed
that Co-developed-by would not be appropriate.

Thanks!
Tamir

Re: [PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[Miguel Ojeda]

On Mon, Nov 18, 2024 at 6:03 PM Tamir Duberstein <tamird@gmail.com> wrote:
>
> It's fairly different, and I discussed with both of them - we agreed
> that Co-developed-by would not be appropriate.

Thanks for clarifying!

Cheers,
Miguel

Re: [PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[Maíra Canal]

Hi Tamir & Miguel,

On 18/11/24 14:02, Tamir Duberstein wrote:
> On Mon, Nov 18, 2024 at 11:52 AM Miguel Ojeda
> <miguel.ojeda.sandonis@gmail.com> wrote:
>>
>> On Mon, Nov 18, 2024 at 5:33 PM Tamir Duberstein <tamird@gmail.com> wrote:
>>>
>>> This is a reimagining relative to earlier versions[0] by Asahi Lina and
>>> Maíra Canal.
>>
>> Maíra's latest version has both of them listed as co-authors in the
>> main patch -- how close is this to that version? (I see some bits that
>> look fairly similar)
>>
>> Thanks!
>>
>> Cheers,
>> Miguel
> 
> It's fairly different, and I discussed with both of them - we agreed
> that Co-developed-by would not be appropriate.

I still agree that a Co-developed-by isn't appropriate, but I believe
that it would be fair to mention me and Lina on the commit message.

Best Regards,
- Maíra

> 
> Thanks!
> Tamir

Re: [PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[Asahi Lina]

On 11/19/24 8:11 PM, Maíra Canal wrote:
> Hi Tamir & Miguel,
> 
> On 18/11/24 14:02, Tamir Duberstein wrote:
>> On Mon, Nov 18, 2024 at 11:52 AM Miguel Ojeda
>> <miguel.ojeda.sandonis@gmail.com> wrote:
>>>
>>> On Mon, Nov 18, 2024 at 5:33 PM Tamir Duberstein <tamird@gmail.com>
>>> wrote:
>>>>
>>>> This is a reimagining relative to earlier versions[0] by Asahi Lina and
>>>> Maíra Canal.
>>>
>>> Maíra's latest version has both of them listed as co-authors in the
>>> main patch -- how close is this to that version? (I see some bits that
>>> look fairly similar)
>>>
>>> Thanks!
>>>
>>> Cheers,
>>> Miguel
>>
>> It's fairly different, and I discussed with both of them - we agreed
>> that Co-developed-by would not be appropriate.
> 
> I still agree that a Co-developed-by isn't appropriate, but I believe
> that it would be fair to mention me and Lina on the commit message.

I think I mentioned Inspired-by: as perhaps a nice alternative?

> 
> Best Regards,
> - Maíra
> 
>>
>> Thanks!
>> Tamir
> 
> 

~~ Lina

Re: [PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[Tamir Duberstein]

On Tue, Nov 19, 2024 at 7:26 AM Asahi Lina <lina@asahilina.net> wrote:
>
>
>
> On 11/19/24 8:11 PM, Maíra Canal wrote:
> > Hi Tamir & Miguel,
> >
> > On 18/11/24 14:02, Tamir Duberstein wrote:
> >> On Mon, Nov 18, 2024 at 11:52 AM Miguel Ojeda
> >> <miguel.ojeda.sandonis@gmail.com> wrote:
> >>>
> >>> On Mon, Nov 18, 2024 at 5:33 PM Tamir Duberstein <tamird@gmail.com>
> >>> wrote:
> >>>>
> >>>> This is a reimagining relative to earlier versions[0] by Asahi Lina and
> >>>> Maíra Canal.
> >>>
> >>> Maíra's latest version has both of them listed as co-authors in the
> >>> main patch -- how close is this to that version? (I see some bits that
> >>> look fairly similar)
> >>>
> >>> Thanks!
> >>>
> >>> Cheers,
> >>> Miguel
> >>
> >> It's fairly different, and I discussed with both of them - we agreed
> >> that Co-developed-by would not be appropriate.
> >
> > I still agree that a Co-developed-by isn't appropriate, but I believe
> > that it would be fair to mention me and Lina on the commit message.
>
> I think I mentioned Inspired-by: as perhaps a nice alternative?

Ah yes - will add in v2.

Re: [PATCH v9 0/2] rust: xarray: Add a minimal abstraction for XArray

[Tamir Duberstein]

On Tue, Nov 19, 2024 at 9:21 AM Tamir Duberstein <tamird@gmail.com> wrote:
> Ah yes - will add in v2.

Err, I meant v10.