Add ARef::into_raw

[y86-dev]

Add the function into_raw to ARef<T>, the function should:

• consume the ARef<T> by value, but not run the destructor, so you need to mem::forget the ARef<T>.
• return a NonNull<T> or a *mut T, figure out which one works better.
• have an example and some documentation.

Also adjust instances where ARefs are manually forgotten to use this new function.

---

This requires submitting a proper patch to the LKML and the Rust for Linux mailing list. Please recall to test your changes, to use a proper title for the commit, to sign your commit under the Developer's Certificate of Origin and so on. Please see https://docs.kernel.org/process/submitting-patches.html and https://rust-for-linux.com/contributing for details.

Please take this issue only if you are new to the kernel development process and you would like to use it as a test to submit your first patch to the kernel.

[Kartik1397]

I'll take this one.

[y86-dev]

Sure!

Note that there currently are no instances of ARefs getting manually forgotten. I created this issue, while reviewing [PATCH 4/7] rust: file: add FileDescriptorReservation. So depending on which thing makes it first into upstream you will or won't have to adjust other stuff.

[Redhawk18]

I'll take this one.

Are you currently working on it?

[Kartik1397]

Yes @Redhawk18, I've the patch ready here, which I'm planning to submit in couple of days once I complete testing of changes in rust/kernel/net/filter.rs and rust/kernel/file.rs files.

[Kartik1397]

Hi @y86-dev, I've drafted a PR for initial review. Please take a look when you can.
I'll send the patch to the mailing list after that.

[vincenzopalazzo]

The PR is sent upstream through ML https://lore.kernel.org/all/20240324231236.145086-1-vincenzopalazzodev@gmail.com/

[ojeda]

@Kartik1397 We are thinking of using NonNull as the return type -- Alice sent an alternative patch (unaware of yours), and I think ideally we would get a combined approach with the best of both, i.e. an example like yours but returning NonNull like she did. Would you be OK to be the primary author of that approach? (i.e. with NonNull)?

https://lore.kernel.org/rust-for-linux/20240801-aref-into-raw-v1-1-33401e2fbac8@google.com/
https://lore.kernel.org/rust-for-linux/20240324231236.145086-1-vincenzopalazzodev@gmail.com/

Alice is happy sending the patch (with you as the primary author), but if you want to send it yourself, that is also fine.

Thanks!

[ojeda]

Something like (from Alice):

diff --git a/rust/kernel/types.rs b/rust/kernel/types.rs
index ee7dd1f963ef..9e7ca066355c 100644
--- a/rust/kernel/types.rs
+++ b/rust/kernel/types.rs
@@ -7,7 +7,7 @@
 use core::{
     cell::UnsafeCell,
     marker::{PhantomData, PhantomPinned},
-    mem::MaybeUninit,
+    mem::{ManuallyDrop, MaybeUninit},
     ops::{Deref, DerefMut},
     pin::Pin,
     ptr::NonNull,
@@ -396,6 +396,35 @@ pub unsafe fn from_raw(ptr: NonNull<T>) -> Self {
             _p: PhantomData,
         }
     }
+
+    /// Consumes the `ARef`, returning a raw pointer.
+    ///
+    /// This function does not change the refcount. After calling this function, the caller is
+    /// responsible for the refcount previously managed by the `ARef`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use core::ptr::NonNull;
+    /// use kernel::types::{ARef, AlwaysRefCounted};
+    ///
+    /// struct Empty {}
+    ///
+    /// unsafe impl AlwaysRefCounted for Empty {
+    ///     fn inc_ref(&self) {}
+    ///     unsafe fn dec_ref(_obj: NonNull<Self>) {}
+    /// }
+    ///
+    /// let mut data = Empty {};
+    /// let ptr = NonNull::<Empty>::new(&mut data as *mut _).unwrap();
+    /// let data_ref: ARef<Empty> = unsafe { ARef::from_raw(ptr) };
+    /// let raw_ptr: NonNull<Empty> = ARef::into_raw(data_ref);
+    ///
+    /// assert_eq!(ptr, raw_ptr);
+    /// ```
+    pub fn into_raw(me: Self) -> NonNull<T> {
+        ManuallyDrop::new(me).ptr
+    }

[ojeda]

By the way, I think @vincenzopalazzo did not change the code when he sent @Kartik1397 patch to the mailing list. But if Vincenzo contributed to the patch and should have a Co-developed-by, then please let us know (https://lore.kernel.org/rust-for-linux/CANiq72==OBG+KVJuzW0S5aYowAZ4oq91pk=phRgtedUrGYeHAg@mail.gmail.com/). Thanks!

[vincenzopalazzo]

@ojeda you are right, I did not change the code I just push it to the finish line through the ML :)

[Kartik1397]

@ojeda I'm OK with using NonNull as the return type.
I'm also fine with Alice sending the patch with me as the primary author.

Thanks considering my patch!

[ojeda]

Applied to rust-next -- thanks everyone!