Skip to contentSkip to conversation

rust: enable `clippy::ptr_as_ptr` lint

PATCH Superseded Tamir Duberstein 5 participants 13 messages Mar 7, 2025 – Mar 14, 2025

Subsystems (11)
VFS Kbuild Kselftest PCI +7 more subsystems

v1 of 12 Superseded Latest is v12 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 rust: enable `clippy::ptr_as_ptr` lint

In Rust 1.51.0, Clippy introduced the ignored_unit_patterns lint [1]:

Quoted 3 lines

Though as casts between raw pointers are not terrible, pointer::cast is safer because it cannot accidentally change the pointer's mutability, nor cast the pointer to other types like usize.

There are a few classes of changes required:
- Modules generated by bindgen are marked #[allow(clippy::ptr_as_ptr)].
- Inferred casts ( as _) are replaced with .cast().
- Ascribed casts ( as *... T) are replaced with .cast::<T>().
- Multistep casts from references ( as *const _ as *const T) are replaced with let x: *const _ = &x; and .cast() or .cast::<T>() according to the previous rules. The intermediate let binding is required because (x as *const _).cast::<T>() results in inference failure.
- Native literal C strings are replaced with c_str!().as_char_ptr().

Apply these changes and enable the lint -- no functional change intended.

---
 Makefile                               |  1 +
 rust/bindings/lib.rs                   |  1 +
 rust/kernel/alloc/allocator_test.rs    |  2 +-
 rust/kernel/alloc/kvec.rs              |  4 ++--
 rust/kernel/device.rs                  |  5 +++--
 rust/kernel/devres.rs                  |  2 +-
 rust/kernel/error.rs                   |  2 +-
 rust/kernel/fs/file.rs                 |  2 +-
 rust/kernel/kunit.rs                   | 15 +++++++--------
 rust/kernel/lib.rs                     |  4 ++--
 rust/kernel/list/impl_list_item_mod.rs |  2 +-
 rust/kernel/pci.rs                     |  2 +-
 rust/kernel/platform.rs                |  4 +++-
 rust/kernel/print.rs                   | 11 +++++------
 rust/kernel/seq_file.rs                |  3 ++-
 rust/kernel/str.rs                     |  2 +-
 rust/kernel/sync/poll.rs               |  2 +-
 rust/kernel/workqueue.rs               | 10 +++++-----
 rust/uapi/lib.rs                       |  1 +
 19 files changed, 40 insertions(+), 35 deletions(-)
Makefile +1 -0
index 70bdbf2218fc..ec8efc8e23ba 100644
@@ -483,6 +483,7 @@ export rust_common_flags := --edition=2021 \
 			    -Wclippy::needless_continue \
 			    -Aclippy::needless_lifetimes \
 			    -Wclippy::no_mangle_with_rust_abi \
+			    -Wclippy::ptr_as_ptr \
 			    -Wclippy::undocumented_unsafe_blocks \
 			    -Wclippy::unnecessary_safety_comment \
 			    -Wclippy::unnecessary_safety_doc \
rust/bindings/lib.rs +1 -0
index 014af0d1fc70..0486a32ed314 100644
@@ -25,6 +25,7 @@
 )]
 
 #[allow(dead_code)]
+#[allow(clippy::ptr_as_ptr)]
 #[allow(clippy::undocumented_unsafe_blocks)]
 mod bindings_raw {
     // Manual definition for blocklisted types.
rust/kernel/alloc/allocator_test.rs +1 -1
index c37d4c0c64e9..8017aa9d5213 100644
@@ -82,7 +82,7 @@ unsafe fn realloc(
 
         // SAFETY: Returns either NULL or a pointer to a memory allocation that satisfies or
         // exceeds the given size and alignment requirements.
-        let dst = unsafe { libc_aligned_alloc(layout.align(), layout.size()) } as *mut u8;
+        let dst = unsafe { libc_aligned_alloc(layout.align(), layout.size()) }.cast::<u8>();
         let dst = NonNull::new(dst).ok_or(AllocError)?;
 
         if flags.contains(__GFP_ZERO) {
rust/kernel/alloc/kvec.rs +2 -2
index ae9d072741ce..c12844764671 100644
@@ -262,7 +262,7 @@ pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>] {
         // - `self.len` is smaller than `self.capacity` and hence, the resulting pointer is
         //   guaranteed to be part of the same allocated object.
         // - `self.len` can not overflow `isize`.
-        let ptr = unsafe { self.as_mut_ptr().add(self.len) } as *mut MaybeUninit<T>;
+        let ptr = unsafe { self.as_mut_ptr().add(self.len) }.cast::<MaybeUninit<T>>();
 
         // SAFETY: The memory between `self.len` and `self.capacity` is guaranteed to be allocated
         // and valid, but uninitialized.
@@ -554,7 +554,7 @@ fn drop(&mut self) {
         // - `ptr` points to memory with at least a size of `size_of::<T>() * len`,
         // - all elements within `b` are initialized values of `T`,
         // - `len` does not exceed `isize::MAX`.
-        unsafe { Vec::from_raw_parts(ptr as _, len, len) }
+        unsafe { Vec::from_raw_parts(ptr.cast(), len, len) }
     }
 }
 
rust/kernel/device.rs +3 -2
index db2d9658ba47..9e500498835d 100644
@@ -168,16 +168,17 @@ pub fn pr_dbg(&self, args: fmt::Arguments<'_>) {
     /// `KERN_*`constants, for example, `KERN_CRIT`, `KERN_ALERT`, etc.
     #[cfg_attr(not(CONFIG_PRINTK), allow(unused_variables))]
     unsafe fn printk(&self, klevel: &[u8], msg: fmt::Arguments<'_>) {
+        let msg: *const _ = &msg;
         // SAFETY: `klevel` is null-terminated and one of the kernel constants. `self.as_raw`
         // is valid because `self` is valid. The "%pA" format string expects a pointer to
         // `fmt::Arguments`, which is what we're passing as the last argument.
         #[cfg(CONFIG_PRINTK)]
         unsafe {
             bindings::_dev_printk(
-                klevel as *const _ as *const crate::ffi::c_char,
+                klevel.as_ptr().cast::<crate::ffi::c_char>(),
                 self.as_raw(),
                 c_str!("%pA").as_char_ptr(),
-                &msg as *const _ as *const crate::ffi::c_void,
+                msg.cast::<crate::ffi::c_void>(),
             )
         };
     }
rust/kernel/devres.rs +1 -1
index 942376f6f3af..3a9d998ec371 100644
@@ -157,7 +157,7 @@ fn remove_action(this: &Arc<Self>) {
 
     #[allow(clippy::missing_safety_doc)]
     unsafe extern "C" fn devres_callback(ptr: *mut kernel::ffi::c_void) {
-        let ptr = ptr as *mut DevresInner<T>;
+        let ptr = ptr.cast::<DevresInner<T>>();
         // Devres owned this memory; now that we received the callback, drop the `Arc` and hence the
         // reference.
         // SAFETY: Safe, since we leaked an `Arc` reference to devm_add_action() in
rust/kernel/error.rs +1 -1
index f6ecf09cb65f..8654d52b0bb9 100644
@@ -152,7 +152,7 @@ pub(crate) fn to_blk_status(self) -> bindings::blk_status_t {
     /// Returns the error encoded as a pointer.
     pub fn to_ptr<T>(self) -> *mut T {
         // SAFETY: `self.0` is a valid error due to its invariant.
-        unsafe { bindings::ERR_PTR(self.0.get() as _) as *mut _ }
+        unsafe { bindings::ERR_PTR(self.0.get() as _).cast() }
     }
 
     /// Returns a string representing the error, if one exists.
rust/kernel/fs/file.rs +1 -1
index e03dbe14d62a..8936afc234a4 100644
@@ -364,7 +364,7 @@ fn deref(&self) -> &LocalFile {
         //
         // By the type invariants, there are no `fdget_pos` calls that did not take the
         // `f_pos_lock` mutex.
-        unsafe { LocalFile::from_raw_file(self as *const File as *const bindings::file) }
+        unsafe { LocalFile::from_raw_file((self as *const Self).cast()) }
     }
 }
 
rust/kernel/kunit.rs +7 -8
index 824da0e9738a..7ed2063c1af0 100644
@@ -8,19 +8,20 @@
 
 use core::{ffi::c_void, fmt};
 
+#[cfg(CONFIG_PRINTK)]
+use crate::c_str;
+
 /// Prints a KUnit error-level message.
 ///
 /// Public but hidden since it should only be used from KUnit generated code.
 #[doc(hidden)]
 pub fn err(args: fmt::Arguments<'_>) {
+    let args: *const _ = &args;
     // SAFETY: The format string is null-terminated and the `%pA` specifier matches the argument we
     // are passing.
     #[cfg(CONFIG_PRINTK)]
     unsafe {
-        bindings::_printk(
-            c"\x013%pA".as_ptr() as _,
-            &args as *const _ as *const c_void,
-        );
+        bindings::_printk(c_str!("\x013%pA").as_char_ptr(), args.cast::<c_void>());
     }
 }
 
@@ -29,14 +30,12 @@ pub fn err(args: fmt::Arguments<'_>) {
 /// Public but hidden since it should only be used from KUnit generated code.
 #[doc(hidden)]
 pub fn info(args: fmt::Arguments<'_>) {
+    let args: *const _ = &args;
     // SAFETY: The format string is null-terminated and the `%pA` specifier matches the argument we
     // are passing.
     #[cfg(CONFIG_PRINTK)]
     unsafe {
-        bindings::_printk(
-            c"\x016%pA".as_ptr() as _,
-            &args as *const _ as *const c_void,
-        );
+        bindings::_printk(c_str!("\x016%pA").as_char_ptr(), args.cast::<c_void>());
     }
 }
 
rust/kernel/lib.rs +2 -2
index 7697c60b2d1a..01264e459c92 100644
@@ -196,9 +196,9 @@ fn panic(info: &core::panic::PanicInfo<'_>) -> ! {
 #[macro_export]
 macro_rules! container_of {
     ($ptr:expr, $type:ty, $($f:tt)*) => {{
-        let ptr = $ptr as *const _ as *const u8;
+        let ptr: *const _ = $ptr;
         let offset: usize = ::core::mem::offset_of!($type, $($f)*);
-        ptr.sub(offset) as *const $type
+        ptr.cast::<u8>().sub(offset).cast::<$type>()
     }}
 }
 
rust/kernel/list/impl_list_item_mod.rs +1 -1
index a0438537cee1..1f9498c1458f 100644
@@ -34,7 +34,7 @@ pub unsafe trait HasListLinks<const ID: u64 = 0> {
     unsafe fn raw_get_list_links(ptr: *mut Self) -> *mut ListLinks<ID> {
         // SAFETY: The caller promises that the pointer is valid. The implementer promises that the
         // `OFFSET` constant is correct.
-        unsafe { (ptr as *mut u8).add(Self::OFFSET) as *mut ListLinks<ID> }
+        unsafe { ptr.cast::<u8>().add(Self::OFFSET).cast() }
     }
 }
 
rust/kernel/pci.rs +1 -1
index 4c98b5b9aa1e..206f71d33ab2 100644
@@ -75,7 +75,7 @@ extern "C" fn probe_callback(
                 // Let the `struct pci_dev` own a reference of the driver's private data.
                 // SAFETY: By the type invariant `pdev.as_raw` returns a valid pointer to a
                 // `struct pci_dev`.
-                unsafe { bindings::pci_set_drvdata(pdev.as_raw(), data.into_foreign() as _) };
+                unsafe { bindings::pci_set_drvdata(pdev.as_raw(), data.into_foreign().cast()) };
             }
             Err(err) => return Error::to_errno(err),
         }
rust/kernel/platform.rs +3 -1
index 50e6b0421813..8f9e6b125faf 100644
@@ -66,7 +66,9 @@ extern "C" fn probe_callback(pdev: *mut bindings::platform_device) -> kernel::ff
                 // Let the `struct platform_device` own a reference of the driver's private data.
                 // SAFETY: By the type invariant `pdev.as_raw` returns a valid pointer to a
                 // `struct platform_device`.
-                unsafe { bindings::platform_set_drvdata(pdev.as_raw(), data.into_foreign() as _) };
+                unsafe {
+                    bindings::platform_set_drvdata(pdev.as_raw(), data.into_foreign().cast())
+                };
             }
             Err(err) => return Error::to_errno(err),
         }
rust/kernel/print.rs +5 -6
index b19ee490be58..0245c145ea32 100644
@@ -25,7 +25,7 @@
     // SAFETY: The C contract guarantees that `buf` is valid if it's less than `end`.
     let mut w = unsafe { RawFormatter::from_ptrs(buf.cast(), end.cast()) };
     // SAFETY: TODO.
-    let _ = w.write_fmt(unsafe { *(ptr as *const fmt::Arguments<'_>) });
+    let _ = w.write_fmt(unsafe { *ptr.cast::<fmt::Arguments<'_>>() });
     w.pos().cast()
 }
 
@@ -102,6 +102,7 @@ pub unsafe fn call_printk(
     module_name: &[u8],
     args: fmt::Arguments<'_>,
 ) {
+    let args: *const _ = &args;
     // `_printk` does not seem to fail in any path.
     #[cfg(CONFIG_PRINTK)]
     // SAFETY: TODO.
@@ -109,7 +110,7 @@ pub unsafe fn call_printk(
         bindings::_printk(
             format_string.as_ptr(),
             module_name.as_ptr(),
-            &args as *const _ as *const c_void,
+            args.cast::<c_void>(),
         );
     }
 }
@@ -122,15 +123,13 @@ pub unsafe fn call_printk(
 #[doc(hidden)]
 #[cfg_attr(not(CONFIG_PRINTK), allow(unused_variables))]
 pub fn call_printk_cont(args: fmt::Arguments<'_>) {
+    let args: *const _ = &args;
     // `_printk` does not seem to fail in any path.
     //
     // SAFETY: The format string is fixed.
     #[cfg(CONFIG_PRINTK)]
     unsafe {
-        bindings::_printk(
-            format_strings::CONT.as_ptr(),
-            &args as *const _ as *const c_void,
-        );
+        bindings::_printk(format_strings::CONT.as_ptr(), args.cast::<c_void>());
     }
 }
 
rust/kernel/seq_file.rs +2 -1
index 04947c672979..90545d28e6b7 100644
@@ -31,12 +31,13 @@ pub unsafe fn from_raw<'a>(ptr: *mut bindings::seq_file) -> &'a SeqFile {
 
     /// Used by the [`seq_print`] macro.
     pub fn call_printf(&self, args: core::fmt::Arguments<'_>) {
+        let args: *const _ = &args;
         // SAFETY: Passing a void pointer to `Arguments` is valid for `%pA`.
         unsafe {
             bindings::seq_printf(
                 self.inner.get(),
                 c_str!("%pA").as_char_ptr(),
-                &args as *const _ as *const crate::ffi::c_void,
+                args.cast::<crate::ffi::c_void>(),
             );
         }
     }
rust/kernel/str.rs +1 -1
index 28e2201604d6..6a1a982b946d 100644
@@ -191,7 +191,7 @@ pub unsafe fn from_char_ptr<'a>(ptr: *const crate::ffi::c_char) -> &'a Self {
         // to a `NUL`-terminated C string.
         let len = unsafe { bindings::strlen(ptr) } + 1;
         // SAFETY: Lifetime guaranteed by the safety precondition.
-        let bytes = unsafe { core::slice::from_raw_parts(ptr as _, len) };
+        let bytes = unsafe { core::slice::from_raw_parts(ptr.cast(), len) };
         // SAFETY: As `len` is returned by `strlen`, `bytes` does not contain interior `NUL`.
         // As we have added 1 to `len`, the last byte is known to be `NUL`.
         unsafe { Self::from_bytes_with_nul_unchecked(bytes) }
rust/kernel/sync/poll.rs +1 -1
index d5f17153b424..a151f54cde91 100644
@@ -73,7 +73,7 @@ pub fn register_wait(&mut self, file: &File, cv: &PollCondVar) {
             // be destroyed, the destructor must run. That destructor first removes all waiters,
             // and then waits for an rcu grace period. Therefore, `cv.wait_queue_head` is valid for
             // long enough.
-            unsafe { qproc(file.as_ptr() as _, cv.wait_queue_head.get(), self.0.get()) };
+            unsafe { qproc(file.as_ptr().cast(), cv.wait_queue_head.get(), self.0.get()) };
         }
     }
 }
rust/kernel/workqueue.rs +5 -5
index 0cd100d2aefb..8ff54105be3f 100644
@@ -170,7 +170,7 @@ impl Queue {
     pub unsafe fn from_raw<'a>(ptr: *const bindings::workqueue_struct) -> &'a Queue {
         // SAFETY: The `Queue` type is `#[repr(transparent)]`, so the pointer cast is valid. The
         // caller promises that the pointer is not dangling.
-        unsafe { &*(ptr as *const Queue) }
+        unsafe { &*ptr.cast::<Queue>() }
     }
 
     /// Enqueues a work item.
@@ -457,7 +457,7 @@ fn get_work_offset(&self) -> usize {
     #[inline]
     unsafe fn raw_get_work(ptr: *mut Self) -> *mut Work<T, ID> {
         // SAFETY: The caller promises that the pointer is valid.
-        unsafe { (ptr as *mut u8).add(Self::OFFSET) as *mut Work<T, ID> }
+        unsafe { ptr.cast::<u8>().add(Self::OFFSET).cast::<Work<T, ID>>() }
     }
 
     /// Returns a pointer to the struct containing the [`Work<T, ID>`] field.
@@ -472,7 +472,7 @@ unsafe fn work_container_of(ptr: *mut Work<T, ID>) -> *mut Self
     {
         // SAFETY: The caller promises that the pointer points at a field of the right type in the
         // right kind of struct.
-        unsafe { (ptr as *mut u8).sub(Self::OFFSET) as *mut Self }
+        unsafe { ptr.cast::<u8>().sub(Self::OFFSET).cast::<Self>() }
     }
 }
 
@@ -538,7 +538,7 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for Arc<T>
 {
     unsafe extern "C" fn run(ptr: *mut bindings::work_struct) {
         // The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`.
-        let ptr = ptr as *mut Work<T, ID>;
+        let ptr = ptr.cast::<Work<T, ID>>();
         // SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`.
         let ptr = unsafe { T::work_container_of(ptr) };
         // SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership.
@@ -591,7 +591,7 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for Pin<KBox<T>>
 {
     unsafe extern "C" fn run(ptr: *mut bindings::work_struct) {
         // The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`.
-        let ptr = ptr as *mut Work<T, ID>;
+        let ptr = ptr.cast::<Work<T, ID>>();
         // SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`.
         let ptr = unsafe { T::work_container_of(ptr) };
         // SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership.
rust/uapi/lib.rs +1 -0
index 13495910271f..fe9bf7b5a306 100644
@@ -15,6 +15,7 @@
 #![allow(
     clippy::all,
     clippy::undocumented_unsafe_blocks,
+    clippy::ptr_as_ptr,
     dead_code,
     missing_docs,
     non_camel_case_types,

---
base-commit: ff64846bee0e7e3e7bc9363ebad3bab42dd27e24
change-id: 20250307-ptr-as-ptr-21b1867fc4d4

Best regards,

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

In Rust 1.51.0, Clippy introduced the ignored_unit_patterns lint [1]:

You link to the ptr_as_ptr lint though, is this a typo?

Quoted 4 lines
Quoted 3 lines

Though as casts between raw pointers are not terrible, pointer::cast is safer because it cannot accidentally change the pointer's mutability, nor cast the pointer to other types like usize.

Quoted 11 lines

There are a few classes of changes required:
- Modules generated by bindgen are marked #[allow(clippy::ptr_as_ptr)].
- Inferred casts ( as _) are replaced with .cast().
- Ascribed casts ( as *... T) are replaced with .cast::<T>().
- Multistep casts from references ( as *const _ as *const T) are replaced with let x: *const _ = &x; and .cast() or .cast::<T>() according to the previous rules. The intermediate let binding is required because (x as *const _).cast::<T>() results in inference failure.
- Native literal C strings are replaced with c_str!().as_char_ptr().

These all seem very nice, thanks! I think it would also be a good idea to enable ptr_cast_constness [1], since those are the other kind of as usage that we should be doing via cast_mut/cast_const.

There are still some legitimate uses of as casts, when unsizing values. I don't know if these two lints can trigger on those, it would be nice if they don't. So those should continue to use as, but other than that, there shouldn't be any as in our code :)

[1]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_cast_constness

(I will take a look at the patch itself a bit later)

---
Cheers,
Benno

Quoted 26 lines

Apply these changes and enable the lint -- no functional change intended.

---
 Makefile                               |  1 +
 rust/bindings/lib.rs                   |  1 +
 rust/kernel/alloc/allocator_test.rs    |  2 +-
 rust/kernel/alloc/kvec.rs              |  4 ++--
 rust/kernel/device.rs                  |  5 +++--
 rust/kernel/devres.rs                  |  2 +-
 rust/kernel/error.rs                   |  2 +-
 rust/kernel/fs/file.rs                 |  2 +-
 rust/kernel/kunit.rs                   | 15 +++++++--------
 rust/kernel/lib.rs                     |  4 ++--
 rust/kernel/list/impl_list_item_mod.rs |  2 +-
 rust/kernel/pci.rs                     |  2 +-
 rust/kernel/platform.rs                |  4 +++-
 rust/kernel/print.rs                   | 11 +++++------
 rust/kernel/seq_file.rs                |  3 ++-
 rust/kernel/str.rs                     |  2 +-
 rust/kernel/sync/poll.rs               |  2 +-
 rust/kernel/workqueue.rs               | 10 +++++-----
 rust/uapi/lib.rs                       |  1 +
 19 files changed, 40 insertions(+), 35 deletions(-)
#2 lore raw
Quoted 21 lines · Benno Lossin
Quoted 1 line · Tamir Duberstein

In Rust 1.51.0, Clippy introduced the ignored_unit_patterns lint [1]:

You link to the ptr_as_ptr lint though, is this a typo?

Quoted 4 lines
Quoted 3 lines

Though as casts between raw pointers are not terrible, pointer::cast is safer because it cannot accidentally change the pointer's mutability, nor cast the pointer to other types like usize.

Quoted 11 lines

There are a few classes of changes required:
- Modules generated by bindgen are marked #[allow(clippy::ptr_as_ptr)].
- Inferred casts ( as _) are replaced with .cast().
- Ascribed casts ( as *... T) are replaced with .cast::<T>().
- Multistep casts from references ( as *const _ as *const T) are replaced with let x: *const _ = &x; and .cast() or .cast::<T>() according to the previous rules. The intermediate let binding is required because (x as *const _).cast::<T>() results in inference failure.
- Native literal C strings are replaced with c_str!().as_char_ptr().

Quoted 3 lines

These all seem very nice, thanks! I think it would also be a good idea to enable ptr_cast_constness [1], since those are the other kind of as usage that we should be doing via cast_mut/cast_const.

I didn't mean to make this sound like you *have* to do the work. If you find the time and want to do it, then great, otherwise we can turn this into a good-first-issue :)

---
Cheers,
Benno

Quoted 39 lines

There are still some legitimate uses of as casts, when unsizing values. I don't know if these two lints can trigger on those, it would be nice if they don't. So those should continue to use as, but other than that, there shouldn't be any as in our code :)

[1]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_cast_constness

(I will take a look at the patch itself a bit later)

---
Cheers,
Benno

Quoted 26 lines

Apply these changes and enable the lint -- no functional change intended.

---
 Makefile                               |  1 +
 rust/bindings/lib.rs                   |  1 +
 rust/kernel/alloc/allocator_test.rs    |  2 +-
 rust/kernel/alloc/kvec.rs              |  4 ++--
 rust/kernel/device.rs                  |  5 +++--
 rust/kernel/devres.rs                  |  2 +-
 rust/kernel/error.rs                   |  2 +-
 rust/kernel/fs/file.rs                 |  2 +-
 rust/kernel/kunit.rs                   | 15 +++++++--------
 rust/kernel/lib.rs                     |  4 ++--
 rust/kernel/list/impl_list_item_mod.rs |  2 +-
 rust/kernel/pci.rs                     |  2 +-
 rust/kernel/platform.rs                |  4 +++-
 rust/kernel/print.rs                   | 11 +++++------
 rust/kernel/seq_file.rs                |  3 ++-
 rust/kernel/str.rs                     |  2 +-
 rust/kernel/sync/poll.rs               |  2 +-
 rust/kernel/workqueue.rs               | 10 +++++-----
 rust/uapi/lib.rs                       |  1 +
 19 files changed, 40 insertions(+), 35 deletions(-)
#3 lore raw
Quoted 23 lines · Benno Lossin
Quoted 21 lines · Benno Lossin
Quoted 1 line · Tamir Duberstein

In Rust 1.51.0, Clippy introduced the ignored_unit_patterns lint [1]:

You link to the ptr_as_ptr lint though, is this a typo?

Quoted 15 lines
Quoted 3 lines

Though as casts between raw pointers are not terrible, pointer::cast is safer because it cannot accidentally change the pointer's mutability, nor cast the pointer to other types like usize.

There are a few classes of changes required:
- Modules generated by bindgen are marked #[allow(clippy::ptr_as_ptr)].
- Inferred casts ( as _) are replaced with .cast().
- Ascribed casts ( as *... T) are replaced with .cast::<T>().
- Multistep casts from references ( as *const _ as *const T) are replaced with let x: *const _ = &x; and .cast() or .cast::<T>() according to the previous rules. The intermediate let binding is required because (x as *const _).cast::<T>() results in inference failure.
- Native literal C strings are replaced with c_str!().as_char_ptr().

Quoted 7 lines
Quoted 3 lines

These all seem very nice, thanks! I think it would also be a good idea to enable ptr_cast_constness [1], since those are the other kind of as usage that we should be doing via cast_mut/cast_const.

I didn't mean to make this sound like you *have* to do the work. If you find the time and want to do it, then great, otherwise we can turn this into a good-first-issue :)

No worries, I will give it a go.

#4 lore raw
In reply to Benno Lossin
Quoted 5 lines · Benno Lossin
Quoted 1 line · Tamir Duberstein

In Rust 1.51.0, Clippy introduced the ignored_unit_patterns lint [1]:

You link to the ptr_as_ptr lint though, is this a typo?

Oops, yep, a typo.

Quoted 16 lines
Quoted 4 lines
Quoted 3 lines

Though as casts between raw pointers are not terrible, pointer::cast is safer because it cannot accidentally change the pointer's mutability, nor cast the pointer to other types like usize.

Quoted 11 lines

There are a few classes of changes required:
- Modules generated by bindgen are marked #[allow(clippy::ptr_as_ptr)].
- Inferred casts ( as _) are replaced with .cast().
- Ascribed casts ( as *... T) are replaced with .cast::<T>().
- Multistep casts from references ( as *const _ as *const T) are replaced with let x: *const _ = &x; and .cast() or .cast::<T>() according to the previous rules. The intermediate let binding is required because (x as *const _).cast::<T>() results in inference failure.
- Native literal C strings are replaced with c_str!().as_char_ptr().

Quoted 3 lines

These all seem very nice, thanks! I think it would also be a good idea to enable ptr_cast_constness [1], since those are the other kind of as usage that we should be doing via cast_mut/cast_const.

There's also as_ptr_cast_mut which could be good to enable.

Quoted 8 lines

There are still some legitimate uses of as casts, when unsizing values. I don't know if these two lints can trigger on those, it would be nice if they don't. So those should continue to use as, but other than that, there shouldn't be any as in our code :)

[1]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_cast_constness

(I will take a look at the patch itself a bit later)

Thanks!

#5 lore raw
In reply to Benno Lossin
Quoted 2 lines · Benno Lossin

You link to the ptr_as_ptr lint though, is this a typo?

I think Tamir was following the pattern of commit 3fcc23397628 ("rust:
enable clippy::ignored_unit_patterns lint"), which I appreciate! :)

Cheers,
Miguel

#6 lore raw
Quoted 7 lines · Miguel Ojeda
Quoted 2 lines · Benno Lossin

You link to the ptr_as_ptr lint though, is this a typo?

I think Tamir was following the pattern of commit 3fcc23397628 ("rust:
enable clippy::ignored_unit_patterns lint"), which I appreciate! :)

🎯

Imitation is the sincerest form of flattery :)

#7 lore raw
In reply to Benno Lossin
Quoted 26 lines · Benno Lossin
Quoted 1 line · Tamir Duberstein

In Rust 1.51.0, Clippy introduced the ignored_unit_patterns lint [1]:

You link to the ptr_as_ptr lint though, is this a typo?

Quoted 4 lines
Quoted 3 lines

Though as casts between raw pointers are not terrible, pointer::cast is safer because it cannot accidentally change the pointer's mutability, nor cast the pointer to other types like usize.

Quoted 11 lines

There are a few classes of changes required:
- Modules generated by bindgen are marked #[allow(clippy::ptr_as_ptr)].
- Inferred casts ( as _) are replaced with .cast().
- Ascribed casts ( as *... T) are replaced with .cast::<T>().
- Multistep casts from references ( as *const _ as *const T) are replaced with let x: *const _ = &x; and .cast() or .cast::<T>() according to the previous rules. The intermediate let binding is required because (x as *const _).cast::<T>() results in inference failure.
- Native literal C strings are replaced with c_str!().as_char_ptr().

These all seem very nice, thanks! I think it would also be a good idea to enable ptr_cast_constness [1], since those are the other kind of as usage that we should be doing via cast_mut/cast_const.

Quoted 8 lines

There are still some legitimate uses of as casts, when unsizing values. I don't know if these two lints can trigger on those, it would be nice if they don't. So those should continue to use as, but other than that, there shouldn't be any as in our code :)

[1]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_cast_constness

(I will take a look at the patch itself a bit later)

I'll go ahead and send v2 soon where this has become a 5 patch series.

#8 lore raw
In reply to Tamir Duberstein
kernel test robot noticed the following build warnings:

Hi Tamir,

kernel test robot noticed the following build warnings:

[auto build test WARNING on ff64846bee0e7e3e7bc9363ebad3bab42dd27e24]

url:    https://github.com/intel-lab-lkp/linux/commits/Tamir-Duberstein/rust-enable-clippy-ptr_as_ptr-lint/20250308-004557
base:   ff64846bee0e7e3e7bc9363ebad3bab42dd27e24
patch link:    https://lore.kernel.org/r/20250307-ptr-as-ptr-v1-1-582d06514c98%40gmail.com
patch subject: [PATCH] rust: enable `clippy::ptr_as_ptr` lint
config: x86_64-rhel-9.4-rust (https://download.01.org/0day-ci/archive/20250312/[email protected]/config)
compiler: clang version 18.1.8 (https://github.com/llvm/llvm-project 3b5b5c1ec4a3095ab096dd780e84d7ab81f3d7ff)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250312/[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 warnings (new ones prefixed by >>):

>> warning: `as` casting between raw pointers without changing its mutability

--> rust/kernel/firmware.rs:64:35
|
64 | let ret = unsafe { func.0(pfw as _, name.as_char_ptr(), dev.as_raw()) };
| ^^^^^^^^ help: try pointer::cast, a safer alternative: pfw.cast()
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr
= note: requested on the command line with -W clippy::ptr-as-ptr

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
#9 lore raw
Quoted 31 lines · kernel test robot

Hi Tamir,

kernel test robot noticed the following build warnings:

[auto build test WARNING on ff64846bee0e7e3e7bc9363ebad3bab42dd27e24]

url:    https://github.com/intel-lab-lkp/linux/commits/Tamir-Duberstein/rust-enable-clippy-ptr_as_ptr-lint/20250308-004557
base:   ff64846bee0e7e3e7bc9363ebad3bab42dd27e24
patch link:    https://lore.kernel.org/r/20250307-ptr-as-ptr-v1-1-582d06514c98%40gmail.com
patch subject: [PATCH] rust: enable `clippy::ptr_as_ptr` lint
config: x86_64-rhel-9.4-rust (https://download.01.org/0day-ci/archive/20250312/[email protected]/config)
compiler: clang version 18.1.8 (https://github.com/llvm/llvm-project 3b5b5c1ec4a3095ab096dd780e84d7ab81f3d7ff)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250312/[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 warnings (new ones prefixed by >>):

Quoted 1 line
Quoted 1 line

warning: as casting between raw pointers without changing its mutability

--> rust/kernel/firmware.rs:64:35
|
64 | let ret = unsafe { func.0(pfw as _, name.as_char_ptr(), dev.as_raw()) };
| ^^^^^^^^ help: try pointer::cast, a safer alternative: pfw.cast()
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr
= note: requested on the command line with -W clippy::ptr-as-ptr

Quoted 3 lines

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

Indeed missed this one because I wasn't building with CONFIG_RUST_FW_LOADER_ABSTRACTIONS. Fixed in v3 by:

rust/kernel/firmware.rs +0 -0
index c5162fdc95ff..74df815d2f4e 100644
@@ -58,10 +58,11 @@ impl Firmware {
     fn request_internal(name: &CStr, dev: &Device, func: FwFunc) ->
Result<Self> {
         let mut fw: *mut bindings::firmware = core::ptr::null_mut();
         let pfw: *mut *mut bindings::firmware = &mut fw;

+ let pfw: *mut *const bindings::firmware = pfw.cast();

         // SAFETY: `pfw` is a valid pointer to a NULL initialized
`bindings::firmware` pointer.
         // `name` and `dev` are valid as by their type invariants.
-        let ret = unsafe { func.0(pfw as _, name.as_char_ptr(),
dev.as_raw()) };
+        let ret = unsafe { func.0(pfw, name.as_char_ptr(), dev.as_raw()) };
         if ret != 0 {
             return Err(Error::from_errno(ret));
         }

By the way, it would be great if the email also included the rustc version used.

#10 lore raw
Quoted 2 lines · Tamir Duberstein

By the way, it would be great if the email also included the rustc version used.

Yeah, I think I may have mentioned it at some point... For the moment, one can look for it manually in the linked config (i.e. CONFIG_RUSTC_VERSION_TEXT).

Cheers,
Miguel

#11 lore raw
Quoted 5 lines · Miguel Ojeda
Quoted 2 lines · Tamir Duberstein

By the way, it would be great if the email also included the rustc version used.

Yeah, I think I may have mentioned it at some point... For the moment,

Sorry about this, I will implement this to make it clear asap.

Quoted 6 lines

one can look for it manually in the linked config (i.e. CONFIG_RUSTC_VERSION_TEXT).

Cheers,
Miguel

#12 lore raw
Quoted 2 lines · Philip Li

Sorry about this, I will implement this to make it clear asap.

The bot is great -- thanks for all the resources you have put so far into it :)

Cheers,
Miguel