Skip to contentSkip to conversation

rust: move ARef and AlwaysRefCounted to sync::aref

PATCH Superseded Shankari Anand 3 participants 6 messages Jun 25, 2025 – Jul 2, 2025

Subsystems (17)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/2 rust: move ARef and AlwaysRefCounted to sync::aref

Move the definitions of ARef and AlwaysRefCounted from types.rs to a new file sync/aref.rs.
Define the corresponding aref module under rust/kernel/sync.rs. These types are better grouped in sync.

To avoid breaking existing imports, they are re-exported from types.rs. Drop unused imports mem::ManuallyDrop, ptr::NonNull from types.rs, they are now only used in sync/aref.rs, where they are already imported.

---
v1 -> v2 : Added git base commit id
Rebased the repository to the recent HEAD in the rust-next. Solved the conflict (a commit adding a module to sync.rs). Changed the in-file reference of {ARef, AlwaysRefCounted}. Rest remains unchanged.

---
 rust/kernel/sync.rs      |   1 +
 rust/kernel/sync/aref.rs | 170 +++++++++++++++++++++++++++++++++++++++
 rust/kernel/types.rs     | 154 +----------------------------------
 3 files changed, 174 insertions(+), 151 deletions(-)
 create mode 100644 rust/kernel/sync/aref.rs
rust/kernel/sync.rs +1 -0
index 63c99e015ad6..8fd126788e02 100644
@@ -10,6 +10,7 @@
 use pin_init;
 
 mod arc;
+pub mod aref;
 pub mod completion;
 mod condvar;
 pub mod lock;
rust/kernel/sync/aref.rs new file +170 -0

170 lines not on this page · raw message

rust/kernel/types.rs +3 -151

170 lines not on this page · raw message

base-commit: 0303584766b7bdb6564c7e8f13e0b59b6ef44984

Signature · 1 line
2.34.1
#1 lore raw

PATCH v2 2/2 rust: update ARef and AlwaysRefCounted call sites to import from sync::aref

Update call sites to import ARef and AlwaysRefCounted from sync::aref instead of indirectly via types.
Remove the re-export of their definitions in types.rs.

---
 drivers/block/rnull.rs               |  3 +--
 drivers/gpu/drm/nova/driver.rs       |  2 +-
 drivers/gpu/drm/nova/gem.rs          |  2 +-
 rust/kernel/auxiliary.rs             |  2 +-
 rust/kernel/block/mq.rs              |  6 +++---
 rust/kernel/block/mq/operations.rs   |  2 +-
 rust/kernel/block/mq/request.rs      |  3 ++-
 rust/kernel/cred.rs                  |  3 ++-
 rust/kernel/device.rs                |  7 ++++---
 rust/kernel/devres.rs                |  3 +--
 rust/kernel/dma.rs                   |  2 +-
 rust/kernel/drm/device.rs            |  3 ++-
 rust/kernel/drm/driver.rs            |  2 +-
 rust/kernel/drm/gem/mod.rs           |  3 ++-
 rust/kernel/fs/file.rs               |  3 ++-
 rust/kernel/mm.rs                    |  3 ++-
 rust/kernel/mm/mmput_async.rs        |  2 +-
 rust/kernel/opp.rs                   | 13 +++++++------
 rust/kernel/pci.rs                   |  5 +++--
 rust/kernel/pid_namespace.rs         |  3 ++-
 rust/kernel/platform.rs              |  2 +-
 rust/kernel/task.rs                  |  7 ++++---
 rust/kernel/types.rs                 |  2 --
 samples/rust/rust_dma.rs             |  2 +-
 samples/rust/rust_driver_pci.rs      |  2 +-
 samples/rust/rust_driver_platform.rs |  2 +-
 samples/rust/rust_misc_device.rs     |  3 +--
 27 files changed, 49 insertions(+), 43 deletions(-)
drivers/block/rnull.rs +1 -2
index d07e76ae2c13..80a0f7aa949e 100644
@@ -20,8 +20,7 @@
     error::Result,
     new_mutex, pr_info,
     prelude::*,
-    sync::{Arc, Mutex},
-    types::ARef,
+    sync::{aref::ARef, Arc, Mutex},
 };
 
 module! {
drivers/gpu/drm/nova/driver.rs +1 -1
index b28b2e05cc15..af2cbee80ec1 100644
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 
-use kernel::{auxiliary, c_str, device::Core, drm, drm::gem, drm::ioctl, prelude::*, types::ARef};
+use kernel::{auxiliary, c_str, device::Core, drm, drm::gem, drm::ioctl, prelude::*, sync::aref::ARef};
 
 use crate::file::File;
 use crate::gem::NovaObject;
drivers/gpu/drm/nova/gem.rs +1 -1
index 33b62d21400c..cd82773dab92 100644
@@ -4,7 +4,7 @@
     drm,
     drm::{gem, gem::BaseObject},
     prelude::*,
-    types::ARef,
+    sync::aref::ARef,
 };
 
 use crate::{
rust/kernel/auxiliary.rs +1 -1
index d2cfe1eeefb6..776c63387832 100644
@@ -250,7 +250,7 @@ extern "C" fn release(dev: *mut bindings::device) {
 kernel::impl_device_context_into_aref!(Device);
 
 // SAFETY: Instances of `Device` are always reference-counted.
-unsafe impl crate::types::AlwaysRefCounted for Device {
+unsafe impl crate::sync::aref::AlwaysRefCounted for Device {
     fn inc_ref(&self) {
         // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
         unsafe { bindings::get_device(self.as_ref().as_raw()) };
rust/kernel/block/mq.rs +3 -3
index 831445d37181..3e7e0de92604 100644
@@ -20,7 +20,7 @@
 //! The kernel will interface with the block device driver by calling the method
 //! implementations of the `Operations` trait.
 //!
-//! IO requests are passed to the driver as [`kernel::types::ARef<Request>`]
+//! IO requests are passed to the driver as [`kernel::sync::aref::ARef<Request>`]
 //! instances. The `Request` type is a wrapper around the C `struct request`.
 //! The driver must mark end of processing by calling one of the
 //! `Request::end`, methods. Failure to do so can lead to deadlock or timeout
@@ -57,12 +57,12 @@
 //!
 //! ```rust
 //! use kernel::{
 //!     alloc::flags,
 //!     block::mq::*,
 //!     new_mutex,
 //!     prelude::*,
-//!     sync::{Arc, Mutex},
-//!     types::{ARef, ForeignOwnable},
+//!     sync::{aref::ARef, Arc, Mutex},
+//!     types::ForeignOwnable,
 //! };
 //!
 //! struct MyBlkDevice;
rust/kernel/block/mq/operations.rs +1 -1
index c2b98f507bcb..18d858763e08 100644
@@ -10,7 +10,7 @@
     block::mq::Request,
     error::{from_result, Result},
     prelude::*,
-    types::ARef,
+    sync::aref::ARef,
 };
 use core::{marker::PhantomData, sync::atomic::AtomicU64, sync::atomic::Ordering};
 
rust/kernel/block/mq/request.rs +2 -1
index fefd394f064a..9cca7852b309 100644
@@ -8,7 +8,8 @@
     bindings,
     block::mq::Operations,
     error::Result,
-    types::{ARef, AlwaysRefCounted, Opaque},
+    sync::aref::{ARef, AlwaysRefCounted},
+    types::Opaque,
 };
 use core::{
     marker::PhantomData,
rust/kernel/cred.rs +2 -1
index 2599f01e8b28..2b6ac62f595f 100644
@@ -11,7 +11,8 @@
 use crate::{
     bindings,
     task::Kuid,
-    types::{AlwaysRefCounted, Opaque},
+    sync::aref::AlwaysRefCounted,
+    types::Opaque,
 };
 
 /// Wraps the kernel's `struct cred`.
rust/kernel/device.rs +4 -3
index 5c946af3a4d5..3631fa67b330 100644
@@ -7,7 +7,8 @@
 use crate::{
     bindings,
     str::CStr,
-    types::{ARef, Opaque},
+    sync::aref::ARef,
+    types::Opaque,
 };
 use core::{fmt, marker::PhantomData, ptr};
 
@@ -216,7 +217,7 @@ pub fn property_present(&self, name: &CStr) -> bool {
 kernel::impl_device_context_into_aref!(Device);
 
 // SAFETY: Instances of `Device` are always reference-counted.
-unsafe impl crate::types::AlwaysRefCounted for Device {
+unsafe impl crate::sync::aref::AlwaysRefCounted for Device {
     fn inc_ref(&self) {
         // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
         unsafe { bindings::get_device(self.as_raw()) };
@@ -322,7 +323,7 @@ macro_rules! impl_device_context_deref {
 #[macro_export]
 macro_rules! __impl_device_context_into_aref {
     ($src:ty, $device:tt) => {
-        impl ::core::convert::From<&$device<$src>> for $crate::types::ARef<$device> {
+        impl ::core::convert::From<&$device<$src>> for $crate::sync::aref::ARef<$device> {
             fn from(dev: &$device<$src>) -> Self {
                 (&**dev).into()
             }
rust/kernel/devres.rs +1 -2
index d0e6c6e162c2..7a1e2f2721b8 100644
@@ -13,8 +13,7 @@
     ffi::c_void,
     prelude::*,
     revocable::{Revocable, RevocableGuard},
-    sync::{rcu, Arc, Completion},
-    types::ARef,
+    sync::{aref::ARef, rcu, Arc, Completion},
 };
 
 #[pin_data]
rust/kernel/dma.rs +1 -1
index 8e317005decd..7e6407655969 100644
@@ -9,8 +9,8 @@
     device::{Bound, Device},
     error::code::*,
     error::Result,
+    sync::aref::ARef,
     transmute::{AsBytes, FromBytes},
-    types::ARef,
 };
 
 /// Possible attributes associated with a DMA mapping.
rust/kernel/drm/device.rs +2 -1
index b7ee3c464a12..d8f0be5fdce7 100644
@@ -10,7 +10,8 @@
     error::from_err_ptr,
     error::Result,
     prelude::*,
-    types::{ARef, AlwaysRefCounted, Opaque},
+    sync::aref::{ARef, AlwaysRefCounted},
+    types::Opaque,
 };
 use core::{mem, ops::Deref, ptr, ptr::NonNull};
 
rust/kernel/drm/driver.rs +1 -1
index acb638086131..9f3450f77ca0 100644
@@ -11,7 +11,7 @@
     error::{to_result, Result},
     prelude::*,
     str::CStr,
-    types::ARef,
+    sync::aref::ARef,
 };
 use macros::vtable;
 
rust/kernel/drm/gem/mod.rs +2 -1
index 4cd69fa84318..d2c28397f810 100644
@@ -10,7 +10,8 @@
     drm::driver::{AllocImpl, AllocOps},
     error::{to_result, Result},
     prelude::*,
-    types::{ARef, AlwaysRefCounted, Opaque},
+    sync::aref::{ARef, AlwaysRefCounted},
+    types::Opaque,
 };
 use core::{mem, ops::Deref, ptr::NonNull};
 
rust/kernel/fs/file.rs +2 -1
index 35fd5db35c46..18cf579d3312 100644
@@ -11,7 +11,8 @@
     bindings,
     cred::Credential,
     error::{code::*, Error, Result},
-    types::{ARef, AlwaysRefCounted, NotThreadSafe, Opaque},
+    sync::aref::{ARef, AlwaysRefCounted},
+    types::{NotThreadSafe, Opaque},
 };
 use core::ptr;
 
rust/kernel/mm.rs +2 -1
index 43f525c0d16c..4764d7b68f2a 100644
@@ -13,7 +13,8 @@
 
 use crate::{
     bindings,
-    types::{ARef, AlwaysRefCounted, NotThreadSafe, Opaque},
+    sync::aref::{ARef, AlwaysRefCounted},
+    types::{NotThreadSafe, Opaque},
 };
 use core::{ops::Deref, ptr::NonNull};
 
rust/kernel/mm/mmput_async.rs +1 -1
index 9289e05f7a67..b8d2f051225c 100644
@@ -10,7 +10,7 @@
 use crate::{
     bindings,
     mm::MmWithUser,
-    types::{ARef, AlwaysRefCounted},
+    sync::aref::{ARef, AlwaysRefCounted},
 };
 use core::{ops::Deref, ptr::NonNull};
 
rust/kernel/opp.rs +7 -6
index 0e94cb2703ec..16ec8dd7d1a3 100644
@@ -16,7 +16,8 @@
     ffi::c_ulong,
     prelude::*,
     str::CString,
-    types::{ARef, AlwaysRefCounted, Opaque},
+    sync::aref::{ARef, AlwaysRefCounted},
+    types::Opaque,
 };
 
 #[cfg(CONFIG_CPU_FREQ)]
@@ -162,7 +163,7 @@ fn from(power: MicroWatt) -> Self {
 /// use kernel::device::Device;
 /// use kernel::error::Result;
 /// use kernel::opp::{Data, MicroVolt, Token};
-/// use kernel::types::ARef;
+/// use kernel::sync::aref::ARef;
 ///
 /// fn create_opp(dev: &ARef<Device>, freq: Hertz, volt: MicroVolt, level: u32) -> Result<Token> {
 ///     let data = Data::new(freq, volt, level, false);
@@ -211,7 +212,7 @@ fn drop(&mut self) {
 /// use kernel::device::Device;
 /// use kernel::error::Result;
 /// use kernel::opp::{Data, MicroVolt, Token};
-/// use kernel::types::ARef;
+/// use kernel::sync::aref::ARef;
 ///
 /// fn create_opp(dev: &ARef<Device>, freq: Hertz, volt: MicroVolt, level: u32) -> Result<Token> {
 ///     let data = Data::new(freq, volt, level, false);
@@ -262,7 +263,7 @@ fn freq(&self) -> Hertz {
 /// use kernel::clk::Hertz;
 /// use kernel::error::Result;
 /// use kernel::opp::{OPP, SearchType, Table};
-/// use kernel::types::ARef;
+/// use kernel::sync::aref::ARef;
 ///
 /// fn find_opp(table: &Table, freq: Hertz) -> Result<ARef<OPP>> {
 ///     let opp = table.opp_from_freq(freq, Some(true), None, SearchType::Exact)?;
@@ -335,7 +336,7 @@ fn drop(&mut self) {
 /// use kernel::error::Result;
 /// use kernel::opp::{Config, ConfigOps, ConfigToken};
 /// use kernel::str::CString;
-/// use kernel::types::ARef;
+/// use kernel::sync::aref::ARef;
 /// use kernel::macros::vtable;
 ///
 /// #[derive(Default)]
@@ -581,7 +582,7 @@ extern "C" fn config_regulators(
 /// use kernel::device::Device;
 /// use kernel::error::Result;
 /// use kernel::opp::Table;
-/// use kernel::types::ARef;
+/// use kernel::sync::aref::ARef;
 ///
 /// fn get_table(dev: &ARef<Device>, mask: &mut Cpumask, freq: Hertz) -> Result<Table> {
 ///     let mut opp_table = Table::from_of_cpumask(dev, mask)?;
rust/kernel/pci.rs +3 -2
index 6b94fd7a3ce9..c7d95459e745 100644
@@ -14,7 +14,8 @@
     io::Io,
     io::IoRaw,
     str::CStr,
-    types::{ARef, ForeignOwnable, Opaque},
+    sync::aref::ARef,
+    types::{ForeignOwnable, Opaque},
     ThisModule,
 };
 use core::{
@@ -438,7 +439,7 @@ pub fn set_master(&self) {
 kernel::impl_device_context_into_aref!(Device);
 
 // SAFETY: Instances of `Device` are always reference-counted.
-unsafe impl crate::types::AlwaysRefCounted for Device {
+unsafe impl crate::sync::aref::AlwaysRefCounted for Device {
     fn inc_ref(&self) {
         // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
         unsafe { bindings::pci_dev_get(self.as_raw()) };
rust/kernel/pid_namespace.rs +2 -1
index 0e93808e4639..4fbbf4430f90 100644
@@ -9,7 +9,8 @@
 
 use crate::{
     bindings,
-    types::{AlwaysRefCounted, Opaque},
+    sync::aref::AlwaysRefCounted,
+    types::Opaque,
 };
 use core::ptr;
 
rust/kernel/platform.rs +1 -1
index 0a6a6be732b2..9c9807b7da54 100644
@@ -198,7 +198,7 @@ fn as_raw(&self) -> *mut bindings::platform_device {
 kernel::impl_device_context_into_aref!(Device);
 
 // SAFETY: Instances of `Device` are always reference-counted.
-unsafe impl crate::types::AlwaysRefCounted for Device {
+unsafe impl crate::sync::aref::AlwaysRefCounted for Device {
     fn inc_ref(&self) {
         // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
         unsafe { bindings::get_device(self.as_ref().as_raw()) };
rust/kernel/task.rs +4 -3
index 927413d85484..b46488f6d1a8 100644
@@ -9,7 +9,8 @@
     ffi::{c_int, c_long, c_uint},
     mm::MmWithUser,
     pid_namespace::PidNamespace,
-    types::{ARef, NotThreadSafe, Opaque},
+    sync::aref::ARef,
+    types::{NotThreadSafe, Opaque},
 };
 use core::{
     cmp::{Eq, PartialEq},
@@ -76,7 +77,7 @@ macro_rules! current {
 /// incremented when creating `State` and decremented when it is dropped:
 ///
 /// ```
-/// use kernel::{task::Task, types::ARef};
+/// use kernel::{task::Task, sync::aref::ARef};
 ///
 /// struct State {
 ///     creator: ARef<Task>,
@@ -340,7 +341,7 @@ pub fn active_pid_ns(&self) -> Option<&PidNamespace> {
 }
 
 // SAFETY: The type invariants guarantee that `Task` is always refcounted.
-unsafe impl crate::types::AlwaysRefCounted for Task {
+unsafe impl crate::sync::aref::AlwaysRefCounted for Task {
     fn inc_ref(&self) {
         // SAFETY: The existence of a shared reference means that the refcount is nonzero.
         unsafe { bindings::get_task_struct(self.as_ptr()) };
rust/kernel/types.rs +0 -2
index 60cb48285630..fccb3ee71345 100644
@@ -10,8 +10,6 @@
 };
 use pin_init::{PinInit, Zeroable};
 
-pub use crate::sync::aref::{ARef, AlwaysRefCounted};
-
 /// Used to transfer ownership to and from foreign (non-Rust) languages.
 ///
 /// Ownership is transferred from Rust to a foreign language by calling [`Self::into_foreign`] and
samples/rust/rust_dma.rs +1 -1
index 874c2c964afa..4aa3ecb7e999 100644
@@ -4,7 +4,7 @@
 //!
 //! To make this driver probe, QEMU must be run with `-device pci-testdev`.
 
-use kernel::{bindings, device::Core, dma::CoherentAllocation, pci, prelude::*, types::ARef};
+use kernel::{bindings, device::Core, dma::CoherentAllocation, pci, prelude::*, sync::aref::ARef};
 
 struct DmaSampleDriver {
     pdev: ARef<pci::Device>,
samples/rust/rust_driver_pci.rs +1 -1
index 15147e4401b2..adcdfbb57c6b 100644
@@ -4,7 +4,7 @@
 //!
 //! To make this driver probe, QEMU must be run with `-device pci-testdev`.
 
-use kernel::{bindings, c_str, device::Core, devres::Devres, pci, prelude::*, types::ARef};
+use kernel::{bindings, c_str, device::Core, devres::Devres, pci, prelude::*, sync::aref::ARef};
 
 struct Regs;
 
samples/rust/rust_driver_platform.rs +1 -1
index 8b42b3cfb363..da7d0f3ae90d 100644
@@ -2,7 +2,7 @@
 
 //! Rust Platform driver sample.
 
-use kernel::{c_str, device::Core, of, platform, prelude::*, types::ARef};
+use kernel::{c_str, device::Core, of, platform, prelude::*, sync::aref::ARef};
 
 struct SampleDriver {
     pdev: ARef<platform::Device>,
samples/rust/rust_misc_device.rs +1 -2
index c881fd6dbd08..3f4954e3eb9c 100644
@@ -105,8 +105,7 @@
     miscdevice::{MiscDevice, MiscDeviceOptions, MiscDeviceRegistration},
     new_mutex,
     prelude::*,
-    sync::Mutex,
-    types::ARef,
+    sync::{aref::ARef, Mutex},
     uaccess::{UserSlice, UserSliceReader, UserSliceWriter},
 };
 
Signature · 1 line
2.34.1
#2 lore raw

Re: [PATCH v2 2/2] rust: update ARef and AlwaysRefCounted call sites to import from sync::aref

kernel test robot noticed the following build errors:

Hi Shankari,

kernel test robot noticed the following build errors:

[auto build test ERROR on 0303584766b7bdb6564c7e8f13e0b59b6ef44984]

url:    https://github.com/intel-lab-lkp/linux/commits/Shankari-Anand/rust-update-ARef-and-AlwaysRefCounted-call-sites-to-import-from-sync-aref/20250625-191416
base:   0303584766b7bdb6564c7e8f13e0b59b6ef44984
patch link:    https://lore.kernel.org/r/20250625111133.698481-2-shankari.ak0208%40gmail.com
patch subject: [PATCH v2 2/2] rust: update ARef and AlwaysRefCounted call sites to import from sync::aref
config: x86_64-rhel-9.4-rust (https://download.01.org/0day-ci/archive/20250702/[email protected]/config)
compiler: clang version 18.1.8 (https://github.com/llvm/llvm-project 3b5b5c1ec4a3095ab096dd780e84d7ab81f3d7ff)
rustc: rustc 1.78.0 (9b00956e5 2024-04-29)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250702/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

PATH=/opt/cross/clang-18/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
INFO PATH=/opt/cross/rustc-1.78.0-bindgen-0.65.1/cargo/bin:/opt/cross/clang-18/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
/usr/bin/timeout -k 100 12h /usr/bin/make KCFLAGS= -fno-crash-diagnostics -Wno-error=return-type -Wreturn-type -funsigned-char -Wundef W=1 --keep-going LLVM=1 -j32 -C source O=/kbuild/obj/consumer/x86_64-rhel-9.4-rust ARCH=x86_64 SHELL=/bin/bash rustfmtcheck
make: Entering directory '/kbuild/src/consumer'
make[1]: Entering directory '/kbuild/obj/consumer/x86_64-rhel-9.4-rust'

>> Diff in drivers/gpu/drm/nova/driver.rs at line 1:
    // SPDX-License-Identifier: GPL-2.0

-use kernel::{auxiliary, c_str, device::Core, drm, drm::gem, drm::ioctl, prelude::*, sync::aref::ARef}; +use kernel::{
+ auxiliary, c_str, device::Core, drm, drm::gem, drm::ioctl, prelude::*, sync::aref::ARef,

   +};
    
    use crate::file::File;
    use crate::gem::NovaObject;
>> Diff in drivers/gpu/drm/nova/driver.rs at line 1:
    // SPDX-License-Identifier: GPL-2.0

-use kernel::{auxiliary, c_str, device::Core, drm, drm::gem, drm::ioctl, prelude::*, sync::aref::ARef}; +use kernel::{
+ auxiliary, c_str, device::Core, drm, drm::gem, drm::ioctl, prelude::*, sync::aref::ARef,

   +};
    
    use crate::file::File;
    use crate::gem::NovaObject;
   Diff in rust/kernel/sync/aref.rs at line 10:
    //!
    //! For Rust-managed objects, prefer using [`Arc`](crate::sync::Arc) instead.

-use core::{

   -    marker::PhantomData,
   -    mem::ManuallyDrop,
   -    ops::Deref,
   -    ptr::NonNull,
   -};
   +use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref, ptr::NonNull};
    
    /// Trait for types that are _always_ reference-counted.
    ///
>> Diff in rust/kernel/cred.rs at line 8:
    //!
    //! Reference: <https://www.kernel.org/doc/html/latest/security/credentials.html>

-use crate::{

   -    bindings,
   -    task::Kuid,
   -    sync::aref::AlwaysRefCounted,
   -    types::Opaque,
   -};
   +use crate::{bindings, sync::aref::AlwaysRefCounted, task::Kuid, types::Opaque};
    
    /// Wraps the kernel's `struct cred`.
    ///
>> Diff in rust/kernel/device.rs at line 4:
    //!
    //! C header: [`include/linux/device.h`](srctree/include/linux/device.h)

-use crate::{

   -    bindings,
   -    str::CStr,
   -    sync::aref::ARef,
   -    types::Opaque,
   -};
   +use crate::{bindings, str::CStr, sync::aref::ARef, types::Opaque};
    use core::{fmt, marker::PhantomData, ptr};
    
    #[cfg(CONFIG_PRINTK)]
   Diff in rust/kernel/pid_namespace.rs at line 7:
    //! C header: [`include/linux/pid_namespace.h`](srctree/include/linux/pid_namespace.h) and
    //! [`include/linux/pid.h`](srctree/include/linux/pid.h)

-use crate::{

   -    bindings,
   -    sync::aref::AlwaysRefCounted,
   -    types::Opaque,
   -};
   +use crate::{bindings, sync::aref::AlwaysRefCounted, types::Opaque};
    use core::ptr;
    
    /// Wraps the kernel's `struct pid_namespace`. Thread safe.
   Diff in rust/kernel/sync/aref.rs at line 10:
    //!
    //! For Rust-managed objects, prefer using [`Arc`](crate::sync::Arc) instead.

-use core::{

   -    marker::PhantomData,
   -    mem::ManuallyDrop,
   -    ops::Deref,
   -    ptr::NonNull,
   -};
   +use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref, ptr::NonNull};
    
    /// Trait for types that are _always_ reference-counted.
    ///
   Diff in rust/kernel/pid_namespace.rs at line 7:
    //! C header: [`include/linux/pid_namespace.h`](srctree/include/linux/pid_namespace.h) and
    //! [`include/linux/pid.h`](srctree/include/linux/pid.h)

-use crate::{

   -    bindings,
   -    sync::aref::AlwaysRefCounted,
   -    types::Opaque,
   -};
   +use crate::{bindings, sync::aref::AlwaysRefCounted, types::Opaque};
    use core::ptr;
    
    /// Wraps the kernel's `struct pid_namespace`. Thread safe.
   Diff in rust/kernel/sync/aref.rs at line 10:
    //!
    //! For Rust-managed objects, prefer using [`Arc`](crate::sync::Arc) instead.

-use core::{

   -    marker::PhantomData,
   -    mem::ManuallyDrop,
   -    ops::Deref,
   -    ptr::NonNull,
   -};
   +use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref, ptr::NonNull};
    
    /// Trait for types that are _always_ reference-counted.
    ///
>> Diff in rust/kernel/cred.rs at line 8:
    //!
    //! Reference: <https://www.kernel.org/doc/html/latest/security/credentials.html>

-use crate::{

   -    bindings,
   -    task::Kuid,
   -    sync::aref::AlwaysRefCounted,
   -    types::Opaque,
   -};
   +use crate::{bindings, sync::aref::AlwaysRefCounted, task::Kuid, types::Opaque};
    
    /// Wraps the kernel's `struct cred`.
    ///
>> Diff in rust/kernel/device.rs at line 4:
    //!
    //! C header: [`include/linux/device.h`](srctree/include/linux/device.h)

-use crate::{

   -    bindings,
   -    str::CStr,
   -    sync::aref::ARef,
   -    types::Opaque,
   -};
   +use crate::{bindings, str::CStr, sync::aref::ARef, types::Opaque};
    use core::{fmt, marker::PhantomData, ptr};
    
    #[cfg(CONFIG_PRINTK)]

make[2]: *** [Makefile:1831: rustfmt] Error 123
make[2]: Target 'rustfmtcheck' not remade because of errors. make[1]: Leaving directory '/kbuild/obj/consumer/x86_64-rhel-9.4-rust' make[1]: *** [Makefile:248: __sub-make] Error 2
make[1]: Target 'rustfmtcheck' not remade because of errors.
make: *** [Makefile:248: __sub-make] Error 2
make: Target 'rustfmtcheck' not remade because of errors.
make: Leaving directory '/kbuild/src/consumer'

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
reviewer
#3 lore raw
In reply to Shankari Anand

rust/kernel/sync/aref.rs line 3

Quoted 9 lines · Shankari Anand
rust/kernel/sync/aref.rs new file +3 -0
new file mode 100644
index 000000000000..93a23b493e21
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Atomic reference-counted pointer abstraction.

I'd say this module is about supporting objects with builtin reference counting.

rust/kernel/sync/aref.rs line 6

Quoted 3 lines
rust/kernel/sync/aref.rs new file +3 -0
+//!
+//! This module provides [`ARef<T>`], an owned reference to a value that implements
+//! [`AlwaysRefCounted`] — an unsafe trait for types that manage their own reference count.

I would lead with comparing ARef<T> to Arc<T> and only later mention AlwaysRefCounted.

Quoted 23 lines
rust/kernel/sync/aref.rs new file +23 -0
+//!
+//! It is based on the Linux kernel's manual reference counting model and is typically used
+//! with C types that implement reference counting (e.g., via `refcount_t` or `kref`).
+//!
+//! For Rust-managed objects, prefer using [`Arc`](crate::sync::Arc) instead.
+
+use core::{
+    marker::PhantomData,
+    mem::ManuallyDrop,
+    ops::Deref,
+    ptr::NonNull,
+};
+
+/// Trait for types that are _always_ reference-counted.
+///
+/// This trait allows types to define custom reference increment and decrement logic.
+/// It enables safe conversion from a shared reference `&T` to an owned [`ARef<T>`].
+///
+/// This is usually implemented by wrappers around C types with manual refcounting.
+///
+/// For purely Rust-managed memory, consider using [`Arc`](crate::sync::Arc) instead.
+///
+/// # Safety

rust/kernel/sync/aref.rs line 39

Quoted 10 lines
rust/kernel/sync/aref.rs new file +10 -0
+///
+/// Implementers must ensure that:
+///
+/// - Calling [`AlwaysRefCounted::inc_ref`] keeps the object alive in memory until a matching [`AlwaysRefCounted::dec_ref`] is called.
+/// - The object is always managed by a reference count; it must never be stack-allocated or
+///   otherwise untracked.
+/// - When the count reaches zero in [`AlwaysRefCounted::dec_ref`], the object is properly freed and no further
+///   access occurs.
+///
+/// Failure to follow these rules may lead to use-after-free or memory corruption.

You also rephrased these docs, can you do that in a separate patch?

rust/kernel/sync/aref.rs line 40

Quoted 1 line
rust/kernel/sync/aref.rs new file +1 -0
+

Newline?

---
Cheers,
Benno

Quoted 17 lines
rust/kernel/sync/aref.rs new file +17 -0
+pub unsafe trait AlwaysRefCounted {
+    /// Increments the reference count on the object.
+    fn inc_ref(&self);
+
+    /// Decrements the reference count on the object.
+    ///
+    /// Frees the object when the count reaches zero.
+    ///
+    /// # Safety
+    ///
+    /// Callers must ensure that there was a previous matching increment to the reference count,
+    /// and that the object is no longer used after its reference count is decremented (as it may
+    /// result in the object being freed), unless the caller owns another increment on the refcount
+    /// (e.g., it calls [`AlwaysRefCounted::inc_ref`] twice, then calls
+    /// [`AlwaysRefCounted::dec_ref`] once).
+    unsafe fn dec_ref(obj: NonNull<Self>);
+}
#4 lore raw

Hello,
Thanks for your feedback!

Quoted 2 lines

I'd say this module is about supporting objects with builtin reference counting.

I described the module as an "Atomic reference-counted pointer abstraction" to highlight its similarity to Arc<T>, but for manually refcounted types. Your version about “supporting objects with built-in reference counting” is definitely clearer, happy to adopt that phrasing if preferred.

Quoted 2 lines

I would lead with comparing ARef<T> to Arc<T> and only later mention AlwaysRefCounted.

I mentioned AlwaysRefCounted early on just to give readers a quick idea of what the module is really about, but I understand your point about introducing it a bit later and can rearrange that.

Quoted 2 lines

You also rephrased these docs, can you do that in a separate patch?

I rephrased a few lines in the intro since we’re starting a new module and I thought it might help with readability. But if keeping the original is better, I can revert those changes, no problem at all.

Quoted 1 line

Newline?

About the extra newline - I didn’t add it manually, but it might’ve come from creating the new file. I’ll check the patch, and if it was actually added, I’ll remove it.

Quoted 3 lines

---
Cheers,
Benno

---
Thanks and regards,
Shankari

Quoted 83 lines · Benno Lossin

rust/kernel/sync/aref.rs line 3

Quoted 9 lines · Shankari Anand
rust/kernel/sync/aref.rs new file +3 -0
new file mode 100644
index 000000000000..93a23b493e21
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Atomic reference-counted pointer abstraction.

I'd say this module is about supporting objects with builtin reference counting.

rust/kernel/sync/aref.rs line 6

Quoted 3 lines
rust/kernel/sync/aref.rs new file +3 -0
+//!
+//! This module provides [`ARef<T>`], an owned reference to a value that implements
+//! [`AlwaysRefCounted`] — an unsafe trait for types that manage their own reference count.

I would lead with comparing ARef<T> to Arc<T> and only later mention AlwaysRefCounted.

Quoted 23 lines
rust/kernel/sync/aref.rs new file +23 -0
+//!
+//! It is based on the Linux kernel's manual reference counting model and is typically used
+//! with C types that implement reference counting (e.g., via `refcount_t` or `kref`).
+//!
+//! For Rust-managed objects, prefer using [`Arc`](crate::sync::Arc) instead.
+
+use core::{
+    marker::PhantomData,
+    mem::ManuallyDrop,
+    ops::Deref,
+    ptr::NonNull,
+};
+
+/// Trait for types that are _always_ reference-counted.
+///
+/// This trait allows types to define custom reference increment and decrement logic.
+/// It enables safe conversion from a shared reference `&T` to an owned [`ARef<T>`].
+///
+/// This is usually implemented by wrappers around C types with manual refcounting.
+///
+/// For purely Rust-managed memory, consider using [`Arc`](crate::sync::Arc) instead.
+///
+/// # Safety

rust/kernel/sync/aref.rs line 39

Quoted 10 lines
rust/kernel/sync/aref.rs new file +10 -0
+///
+/// Implementers must ensure that:
+///
+/// - Calling [`AlwaysRefCounted::inc_ref`] keeps the object alive in memory until a matching [`AlwaysRefCounted::dec_ref`] is called.
+/// - The object is always managed by a reference count; it must never be stack-allocated or
+///   otherwise untracked.
+/// - When the count reaches zero in [`AlwaysRefCounted::dec_ref`], the object is properly freed and no further
+///   access occurs.
+///
+/// Failure to follow these rules may lead to use-after-free or memory corruption.

You also rephrased these docs, can you do that in a separate patch?

rust/kernel/sync/aref.rs line 40

Quoted 1 line
rust/kernel/sync/aref.rs new file +1 -0
+

Newline?

---
Cheers,
Benno

Quoted 17 lines
rust/kernel/sync/aref.rs new file +17 -0
+pub unsafe trait AlwaysRefCounted {
+    /// Increments the reference count on the object.
+    fn inc_ref(&self);
+
+    /// Decrements the reference count on the object.
+    ///
+    /// Frees the object when the count reaches zero.
+    ///
+    /// # Safety
+    ///
+    /// Callers must ensure that there was a previous matching increment to the reference count,
+    /// and that the object is no longer used after its reference count is decremented (as it may
+    /// result in the object being freed), unless the caller owns another increment on the refcount
+    /// (e.g., it calls [`AlwaysRefCounted::inc_ref`] twice, then calls
+    /// [`AlwaysRefCounted::dec_ref`] once).
+    unsafe fn dec_ref(obj: NonNull<Self>);
+}
#5 lore raw
In reply to Shankari Anand
kernel test robot noticed the following build errors:

Hi Shankari,

kernel test robot noticed the following build errors:

[auto build test ERROR on 0303584766b7bdb6564c7e8f13e0b59b6ef44984]

url:    https://github.com/intel-lab-lkp/linux/commits/Shankari-Anand/rust-update-ARef-and-AlwaysRefCounted-call-sites-to-import-from-sync-aref/20250625-191416
base:   0303584766b7bdb6564c7e8f13e0b59b6ef44984
patch link:    https://lore.kernel.org/r/20250625111133.698481-1-shankari.ak0208%40gmail.com
patch subject: [PATCH v2 1/2] rust: move ARef and AlwaysRefCounted to sync::aref
config: x86_64-rhel-9.4-rust (https://download.01.org/0day-ci/archive/20250702/[email protected]/config)
compiler: clang version 18.1.8 (https://github.com/llvm/llvm-project 3b5b5c1ec4a3095ab096dd780e84d7ab81f3d7ff)
rustc: rustc 1.78.0 (9b00956e5 2024-04-29)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250702/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

PATH=/opt/cross/clang-18/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
INFO PATH=/opt/cross/rustc-1.78.0-bindgen-0.65.1/cargo/bin:/opt/cross/clang-18/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
/usr/bin/timeout -k 100 12h /usr/bin/make KCFLAGS= -fno-crash-diagnostics -Wno-error=return-type -Wreturn-type -funsigned-char -Wundef W=1 --keep-going LLVM=1 -j32 -C source O=/kbuild/obj/consumer/x86_64-rhel-9.4-rust ARCH=x86_64 SHELL=/bin/bash rustfmtcheck
make: Entering directory '/kbuild/src/consumer'
make[1]: Entering directory '/kbuild/obj/consumer/x86_64-rhel-9.4-rust'

>> Diff in rust/kernel/sync/aref.rs at line 10:
    //!
    //! For Rust-managed objects, prefer using [`Arc`](crate::sync::Arc) instead.

-use core::{

   -    marker::PhantomData,
   -    mem::ManuallyDrop,
   -    ops::Deref,
   -    ptr::NonNull,
   -};
   +use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref, ptr::NonNull};
    
    /// Trait for types that are _always_ reference-counted.
    ///
>> Diff in rust/kernel/sync/aref.rs at line 10:
    //!
    //! For Rust-managed objects, prefer using [`Arc`](crate::sync::Arc) instead.

-use core::{

   -    marker::PhantomData,
   -    mem::ManuallyDrop,
   -    ops::Deref,
   -    ptr::NonNull,
   -};
   +use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref, ptr::NonNull};
    
    /// Trait for types that are _always_ reference-counted.
    ///
>> Diff in rust/kernel/sync/aref.rs at line 10:
    //!
    //! For Rust-managed objects, prefer using [`Arc`](crate::sync::Arc) instead.

-use core::{

   -    marker::PhantomData,
   -    mem::ManuallyDrop,
   -    ops::Deref,
   -    ptr::NonNull,
   -};
   +use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref, ptr::NonNull};
    
    /// Trait for types that are _always_ reference-counted.
    ///

make[1]: Leaving directory '/kbuild/obj/consumer/x86_64-rhel-9.4-rust'
make: *** [Makefile:248: __sub-make] Error 2
make: Target 'rustfmtcheck' not remade because of errors.
make: Leaving directory '/kbuild/src/consumer'
make[1]: *** [Makefile:248: __sub-make] Error 2
make[1]: Target 'rustfmtcheck' not remade because of errors. make[2]: *** [Makefile:1831: rustfmt] Error 123
make[2]: Target 'rustfmtcheck' not remade because of errors.

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki