rust: reduce pointer casts, enable related lints
Subsystems (16)
v4 cover rust: reduce pointer casts, enable related lints
This started with a patch that enabled clippy::ptr_as_ptr. Benno Lossin suggested I also look into clippy::ptr_cast_constness and I discovered clippy::as_ptr_cast_mut. This series now enables all 3 lints. It also enables clippy::as_underscore which ensures other pointer casts weren't missed. The first commit reduces the need for pointer casts and is shared with another series[1].
The final patch also enables pointer provenance lints and fixes violations. See that commit message for details. The build system portion of that commit is pretty messy but I couldn't find a better way to convincingly ensure that these lints were applied globally. Suggestions would be very welcome.
---
Changes in v4:
- Add missing SoB. (Benno Lossin)
- Use without_provenance_mut in alloc. (Boqun Feng)
- Limit strict provenance lints to the kernel crate to avoid complex logic in the build system. This can be revisited on MSRV >= 1.84.0.
- Rebase on rust-next.
- Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- Fixed clippy warning in rust/kernel/firmware.rs. (kernel test robot)
- s/as u64/as bindings::phys_addr_t/g. (Benno Lossin)
- Use strict provenance APIs and enable lints. (Benno Lossin)
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- Fixed typo in first commit message.
- Added additional patches, converted to series.
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Tamir Duberstein (6):
rust: retain pointer mut-ness in container_of!
rust: enable clippy::ptr_as_ptr lint
rust: enable clippy::ptr_cast_constness lint
rust: enable clippy::as_ptr_cast_mut lint
rust: enable clippy::as_underscore lint
rust: use strict provenance APIs
Makefile | 4 +++ init/Kconfig | 3 ++ rust/bindings/lib.rs | 1 + rust/kernel/alloc.rs | 2 +- rust/kernel/alloc/allocator_test.rs | 2 +- rust/kernel/alloc/kvec.rs | 4 +-- rust/kernel/block/mq/operations.rs | 2 +- rust/kernel/block/mq/request.rs | 7 +++-- rust/kernel/device.rs | 5 +-- rust/kernel/device_id.rs | 2 +- rust/kernel/devres.rs | 19 ++++++------ rust/kernel/error.rs | 2 +- rust/kernel/firmware.rs | 3 +- rust/kernel/fs/file.rs | 2 +- rust/kernel/io.rs | 16 +++++----- rust/kernel/kunit.rs | 15 +++++---- rust/kernel/lib.rs | 57 ++++++++++++++++++++++++++++++++-- rust/kernel/list/impl_list_item_mod.rs | 2 +- rust/kernel/miscdevice.rs | 2 +- rust/kernel/of.rs | 6 ++-- rust/kernel/pci.rs | 15 +++++---- rust/kernel/platform.rs | 6 ++-- rust/kernel/print.rs | 11 +++---- rust/kernel/rbtree.rs | 23 ++++++-------- rust/kernel/seq_file.rs | 3 +- rust/kernel/str.rs | 18 +++++------ rust/kernel/sync/poll.rs | 2 +- rust/kernel/uaccess.rs | 12 ++++--- rust/kernel/workqueue.rs | 12 +++---- rust/uapi/lib.rs | 1 + 30 files changed, 162 insertions(+), 97 deletions(-)
---
base-commit: 2aadc0fc1f85d7a9ed2822ba7ee9f06775eb6d84
change-id: 20250307-ptr-as-ptr-21b1867fc4d4
Best regards,
Signature · 1 line
Tamir Duberstein <[email protected]>
PATCH v4 1/6 rust: retain pointer mut-ness in `container_of!`
Avoid casting the input pointer to *const _, allowing the output pointer to be *mut if the input is *mut. This allows a number of *const to *mut conversions to be removed at the cost of slightly worse ergonomics when the macro is used with a reference rather than a pointer; the only example of this was in the macro's own doctest.
--- rust/kernel/lib.rs | 5 ++--- rust/kernel/pci.rs | 2 +- rust/kernel/platform.rs | 2 +- rust/kernel/rbtree.rs | 23 ++++++++++------------- 4 files changed, 14 insertions(+), 18 deletions(-)
rust/kernel/lib.rs +2 -3
@@ -187,7 +187,7 @@ fn panic(info: &core::panic::PanicInfo<'_>) -> ! {/// } /// /// let test = Test { a: 10, b: 20 }; -/// let b_ptr = &test.b; +/// let b_ptr: *const _ = &test.b; /// // SAFETY: The pointer points at the `b` field of a `Test`, so the resulting pointer will be /// // in-bounds of the same allocation as `b_ptr`. /// let test_alias = unsafe { container_of!(b_ptr, Test, b) };
@@ -196,9 +196,8 @@ fn panic(info: &core::panic::PanicInfo<'_>) -> ! {#[macro_export] macro_rules! container_of { ($ptr:expr, $type:ty, $($f:tt)*) => {{ -let ptr = $ptras *const _ as *const u8 ;let offset:usize = ::core::mem::offset_of!($type , $($f)*); - ptr.sub (offset)as *const $type + $ptr.byte_sub (offset).cast ::<$type>() }} }
rust/kernel/pci.rs +1 -1
@@ -364,7 +364,7 @@ pub unsafe fn from_dev(dev: ARef<device::Device>) -> Self {fn as_raw (&self) -> *mut bindings::pci_dev {// SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device` // embedded in `struct pci_dev`. -unsafe {container_of! (self.0 .as_raw (), bindings::pci_dev, dev)as _ } +unsafe {container_of! (self.0 .as_raw (), bindings::pci_dev, dev) } }/// Returns the PCI vendor ID.
rust/kernel/platform.rs +1 -1
@@ -189,7 +189,7 @@ unsafe fn from_dev(dev: ARef<device::Device>) -> Self {fn as_raw (&self) -> *mut bindings::platform_device {// SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device` // embedded in `struct platform_device`. -unsafe {container_of! (self.0 .as_raw (), bindings::platform_device, dev) }.cast_mut () +unsafe {container_of! (self.0 .as_raw (), bindings::platform_device, dev) } } }
rust/kernel/rbtree.rs +10 -13
@@ -424,7 +424,7 @@ pub fn cursor_lower_bound(&mut self, key: &K) -> Option<Cursor<'_, K, V>>while !node.is_null () {// SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node<K, V>` objects. -let this =unsafe {container_of! (node,Node <K ,V >, links) }.cast_mut (); +let this =unsafe {container_of! (node,Node <K ,V >, links) };// SAFETY: `this` is a non-null node so it is valid by the type invariants. let this_key =unsafe { &(*this).key };// SAFETY: `node` is a non-null node so it is valid by the type invariants.
@@ -496,7 +496,7 @@ fn drop(&mut self) {// but it is not observable. The loop invariant is still maintained. // SAFETY: `this` is valid per the loop invariant. -unsafe {drop (KBox ::from_raw (this.cast_mut ())) }; +unsafe {drop (KBox ::from_raw (this)) }; } } }
@@ -761,7 +761,7 @@ pub fn remove_current(self) -> (Option<Self>, RBTreeNode<K, V>) {let next = self.get_neighbor_raw (Direction ::Next );// SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node<K, V>` objects. -let this =unsafe {container_of! (self.current.as_ptr (),Node <K ,V >, links) }.cast_mut (); +let this =unsafe {container_of! (self.current.as_ptr (),Node <K ,V >, links) };// SAFETY: `this` is valid by the type invariants as described above. let node =unsafe {KBox ::from_raw (this) };let node =RBTreeNode { node };
@@ -806,7 +806,7 @@ fn remove_neighbor(&mut self, direction: Direction) -> Option<RBTreeNode<K, V>>unsafe { bindings::rb_erase (neighbor,addr_of_mut! (self.tree.root)) };// SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node<K, V>` objects. -let this =unsafe {container_of! (neighbor,Node <K ,V >, links) }.cast_mut (); +let this =unsafe {container_of! (neighbor,Node <K ,V >, links) };// SAFETY: `this` is valid by the type invariants as described above. let node =unsafe {KBox ::from_raw (this) };return Some (RBTreeNode { node });
@@ -912,7 +912,7 @@ unsafe fn to_key_value_mut<'b>(node: NonNull<bindings::rb_node>) -> (&'b K, &'bunsafe fn to_key_value_raw <'b>(node:NonNull <bindings::rb_node >) -> (&'bK , *mut V ) {// SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node<K, V>` objects. -let this =unsafe {container_of! (node.as_ptr (),Node <K ,V >, links) }.cast_mut (); +let this =unsafe {container_of! (node.as_ptr (),Node <K ,V >, links) };// SAFETY: The passed `node` is the current node or a non-null neighbor, // thus `this` is valid by the type invariants. let k =unsafe { &(*this).key };
@@ -1021,7 +1021,7 @@ fn next(&mut self) -> Option<Self::Item> {// SAFETY: By the type invariant of `IterRaw`, `self.next` is a valid node in an `RBTree`, // and by the type invariant of `RBTree`, all nodes point to the links field of `Node<K, V>` objects. -let cur =unsafe {container_of! (self.next,Node <K ,V >, links) }.cast_mut (); +let cur =unsafe {container_of! (self.next,Node <K ,V >, links) };// SAFETY: `self.next` is a valid tree node by the type invariants. self.next =unsafe { bindings::rb_next (self.next) };
@@ -1216,7 +1216,7 @@ pub fn get_mut(&mut self) -> &mut V {// SAFETY: // - `self.node_links` is a valid pointer to a node in the tree. // - We have exclusive access to the underlying tree, and can thus give out a mutable reference. -unsafe { &mut (*(container_of! (self.node_links,Node <K ,V >, links).cast_mut ())).value } +unsafe { &mut (*(container_of! (self.node_links,Node <K ,V >, links))).value } }/// Converts the entry into a mutable reference to its value.
@@ -1226,7 +1226,7 @@ pub fn into_mut(self) -> &'a mut V {// SAFETY: // - `self.node_links` is a valid pointer to a node in the tree. // - This consumes the `&'a mut RBTree<K, V>`, therefore it can give out a mutable reference that lives for `'a`. -unsafe { &mut (*(container_of! (self.node_links,Node <K ,V >, links).cast_mut ())).value } +unsafe { &mut (*(container_of! (self.node_links,Node <K ,V >, links))).value } }/// Remove this entry from the [`RBTree`].
@@ -1239,9 +1239,7 @@ pub fn remove_node(self) -> RBTreeNode<K, V> {RBTreeNode {// SAFETY: The node was a node in the tree, but we removed it, so we can convert it // back into a box. - node:unsafe { -KBox ::from_raw (container_of! (self.node_links,Node <K ,V >, links).cast_mut ()) - }, + node:unsafe {KBox ::from_raw (container_of! (self.node_links,Node <K ,V >, links)) }, } }
@@ -1272,8 +1270,7 @@ fn replace(self, node: RBTreeNode<K, V>) -> RBTreeNode<K, V> {// SAFETY: // - `self.node_ptr` produces a valid pointer to a node in the tree. // - Now that we removed this entry from the tree, we can convert the node to a box. -let old_node = -unsafe {KBox ::from_raw (container_of! (self.node_links,Node <K ,V >, links).cast_mut ()) }; +let old_node =unsafe {KBox ::from_raw (container_of! (self.node_links,Node <K ,V >, links)) };RBTreeNode { node: old_node } }
Signature · 1 line
2.48.1
PATCH v4 2/6 rust: enable `clippy::ptr_as_ptr` lint
In reply to Tamir DubersteinIn Rust 1.51.0, Clippy introduced the ptr_as_ptr lint [1]:
Quoted 3 lines
Though
ascasts between raw pointers are not terrible,pointer::castis safer because it cannot accidentally change the pointer's mutability, nor cast the pointer to other types likeusize.
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().
- *mut *mut T as _ is replaced with let *mut *const T = (*mut *mut T).cast();` since pointer to pointer can be confusing.
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/firmware.rs | 3 ++- rust/kernel/fs/file.rs | 2 +- rust/kernel/kunit.rs | 15 +++++++-------- 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(+), 34 deletions(-)
Makefile +1 -0
@@ -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
@@ -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
@@ -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
@@ -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 (ptras _ , len, len) } +unsafe {Vec ::from_raw_parts (ptr.cast (), len, len) } } }
rust/kernel/device.rs +3 -2
@@ -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 ( - klevelas *const _ as *const crate ::ffi::c_char , + klevel.as_ptr ().cast ::<crate ::ffi::c_char >(), self.as_raw (),c_str! ("%pA" ).as_char_ptr (), - &msgas *const _ as *const crate ::ffi::c_void , + msg.cast ::<crate ::ffi::c_void >(), ) }; }
rust/kernel/devres.rs +1 -1
@@ -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 = ptras *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
@@ -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/firmware.rs +2 -1
@@ -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 (pfwas _ , 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)); }
rust/kernel/fs/file.rs +1 -1
@@ -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 (selfas *const File as *const bindings::file ) } +unsafe {LocalFile ::from_raw_file ((selfas *const Self ).cast ()) } } }
rust/kernel/kunit.rs +7 -8
@@ -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 _ , - &argsas *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 _ , - &argsas *const _ as *const c_void , - ); + bindings::_printk (c_str! ("\x016%pA" ).as_char_ptr (), args.cast ::<c_void >()); } }
rust/kernel/list/impl_list_item_mod.rs +1 -1
@@ -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 { (ptras *mut u8 ).add (Self ::OFFSET )as *mut ListLinks <ID > } +unsafe { ptr.cast ::<u8 >().add (Self ::OFFSET ).cast () } } }
rust/kernel/pci.rs +1 -1
@@ -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
@@ -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
@@ -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 { *(ptras *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 (), - &argsas *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 (), - &argsas *const _ as *const c_void , - ); + bindings::_printk (format_strings::CONT .as_ptr (), args.cast ::<c_void >()); } }
rust/kernel/seq_file.rs +2 -1
@@ -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 (), - &argsas *const _ as *const crate ::ffi::c_void , + args.cast ::<crate ::ffi::c_void >(), ); } }
rust/kernel/str.rs +1 -1
@@ -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 (ptras _ , 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
@@ -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
@@ -170,7 +170,7 @@ impl Queue {pub unsafe fn from_raw <'a>(ptr: *const bindings::workqueue_struct ) -> &'aQueue {// SAFETY: The `Queue` type is `#[repr(transparent)]`, so the pointer cast is valid. The // caller promises that the pointer is not dangling. -unsafe { &*(ptras *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 { (ptras *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 { (ptras *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 = ptras *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 = ptras *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
@@ -15,6 +15,7 @@ #![allow( clippy::all, clippy::undocumented_unsafe_blocks, + clippy::ptr_as_ptr, dead_code, missing_docs, non_camel_case_types,
Signature · 1 line
2.48.1
PATCH v4 3/6 rust: enable `clippy::ptr_cast_constness` lint
In reply to Tamir DubersteinIn Rust 1.72.0, Clippy introduced the ptr_cast_constness lint [1]:
Quoted 3 lines
Though
ascasts between raw pointers are not terrible,pointer::cast_mutandpointer::cast_constare safer because they cannot accidentally cast the pointer to another type.
There are only 2 affected sites:
- *mut T as *const U as *mut U becomes (*mut T).cast()
- &self as *const Self as *mut Self becomes a reference-to-pointer coercion + (*const Self).cast().
Apply these changes and enable the lint -- no functional change intended.
--- Makefile | 1 + rust/kernel/block/mq/request.rs | 5 +++-- 2 files changed, 4 insertions(+), 2 deletions(-)
Makefile +1 -0
@@ -484,6 +484,7 @@ export rust_common_flags := --edition=2021 \ -Aclippy::needless_lifetimes \ -Wclippy::no_mangle_with_rust_abi \ -Wclippy::ptr_as_ptr \ + -Wclippy::ptr_cast_constness \ -Wclippy::undocumented_unsafe_blocks \ -Wclippy::unnecessary_safety_comment \ -Wclippy::unnecessary_safety_doc \
rust/kernel/block/mq/request.rs +3 -2
@@ -69,7 +69,7 @@ pub(crate) unsafe fn aref_from_raw(ptr: *mut bindings::request) -> ARef<Self> {// INVARIANT: By the safety requirements of this function, invariants are upheld. // SAFETY: By the safety requirement of this function, we own a // reference count that we can pass to `ARef`. -unsafe {ARef ::from_raw (NonNull ::new_unchecked (ptras *const Self as *mut Self )) } +unsafe {ARef ::from_raw (NonNull ::new_unchecked (ptr.cast ())) } }/// Notify the block layer that a request is going to be processed now.
@@ -151,11 +151,12 @@ pub(crate) unsafe fn wrapper_ptr(this: *mut Self) -> NonNull<RequestDataWrapper>/// Return a reference to the [`RequestDataWrapper`] stored in the private /// area of the request structure. pub (crate )fn wrapper_ref (&self) -> &RequestDataWrapper { +let this: *const _ = self;// SAFETY: By type invariant, `self.0` is a valid allocation. Further, // the private data associated with this request is initialized and // valid. The existence of `&self` guarantees that the private data is // valid as a shared reference. -unsafe {Self ::wrapper_ptr (selfas *const Self as *mut Self ).as_ref () } +unsafe {Self ::wrapper_ptr (this.cast_mut ()).as_ref () } } }
Signature · 1 line
2.48.1
PATCH v4 4/6 rust: enable `clippy::as_ptr_cast_mut` lint
In reply to Tamir DubersteinIn Rust 1.66.0, Clippy introduced the as_ptr_cast_mut lint [1]:
Quoted 3 lines
Since
as_ptrtakes a&self, the pointer won’t have write permissions unless interior mutability is used, making it unlikely that having it as a mutable pointer is correct.
There is only one affected callsite, and the change amounts to replacing as _ with .cast_mut().cast(). This doesn't change the semantics, but is more descriptive of what's going on.
Apply this change and enable the lint -- no functional change intended.
--- Makefile | 1 + rust/kernel/devres.rs | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-)
Makefile +1 -0
@@ -477,6 +477,7 @@ export rust_common_flags := --edition=2021 \ -Wrust_2018_idioms \ -Wunreachable_pub \ -Wclippy::all \ + -Wclippy::as_ptr_cast_mut \ -Wclippy::ignored_unit_patterns \ -Wclippy::mut_mut \ -Wclippy::needless_bitwise_bool \
rust/kernel/devres.rs +1 -1
@@ -143,7 +143,7 @@ fn remove_action(this: &Arc<Self>) { bindings::devm_remove_action_nowarn ( this.dev.as_raw (),Some (this.callback), - this.as_ptr ()as _ , + this.as_ptr ().cast_mut ().cast (), ) };
Signature · 1 line
2.48.1
PATCH v4 5/6 rust: enable `clippy::as_underscore` lint
In reply to Tamir DubersteinIn Rust 1.63.0, Clippy introduced the as_underscore lint [1]:
Quoted 5 lines
The conversion might include lossy conversion or a dangerous cast that might go undetected due to the type being inferred.
The lint is allowed by default as using
_is less wordy than always specifying the type.
Always specifying the type is especially helpful in function call contexts where the inferred type may change at a distance. Specifying the type also allows Clippy to spot more cases of useless_conversion.
The primary downside is the need to specify the type in trivial getters. There are 4 such functions: 3 have become slightly less ergonomic, 1 was revealed to be a useless_conversion.
While this doesn't eliminate unchecked as conversions, it makes such conversions easier to scrutinize. It also has the slight benefit of removing a degree of freedom on which to bikeshed. Thus apply the changes and enable the lint -- no functional change intended.
--- Makefile | 1 + rust/kernel/block/mq/operations.rs | 2 +- rust/kernel/block/mq/request.rs | 2 +- rust/kernel/device_id.rs | 2 +- rust/kernel/devres.rs | 15 ++++++++------- rust/kernel/error.rs | 2 +- rust/kernel/io.rs | 18 +++++++++--------- rust/kernel/miscdevice.rs | 2 +- rust/kernel/of.rs | 6 +++--- rust/kernel/pci.rs | 9 ++++++--- rust/kernel/str.rs | 8 ++++---- rust/kernel/workqueue.rs | 2 +- 12 files changed, 37 insertions(+), 32 deletions(-)
Makefile +1 -0
@@ -478,6 +478,7 @@ export rust_common_flags := --edition=2021 \ -Wunreachable_pub \ -Wclippy::all \ -Wclippy::as_ptr_cast_mut \ + -Wclippy::as_underscore \ -Wclippy::ignored_unit_patterns \ -Wclippy::mut_mut \ -Wclippy::needless_bitwise_bool \
rust/kernel/block/mq/operations.rs +1 -1
@@ -101,7 +101,7 @@ impl<T: Operations> OperationsVTable<T> {if let Err (e) = ret { e.to_blk_status () }else { - bindings::BLK_STS_OK as _ + bindings::BLK_STS_OK as u8 } }
rust/kernel/block/mq/request.rs +1 -1
@@ -125,7 +125,7 @@ pub fn end_ok(this: ARef<Self>) -> Result<(), ARef<Self>> {// success of the call to `try_set_end` guarantees that there are no // `ARef`s pointing to this request. Therefore it is safe to hand it // back to the block layer. -unsafe { bindings::blk_mq_end_request (request_ptr, bindings::BLK_STS_OK as _ ) }; +unsafe { bindings::blk_mq_end_request (request_ptr, bindings::BLK_STS_OK as u8 ) };Ok (()) }
rust/kernel/device_id.rs +1 -1
@@ -82,7 +82,7 @@ impl<T: RawDeviceId, U, const N: usize> IdArray<T, U, N> {unsafe { raw_ids[i] .as_mut_ptr () - .byte_offset (T ::DRIVER_DATA_OFFSET as _ ) + .byte_add (T ::DRIVER_DATA_OFFSET ) .cast ::<usize >() .write (i); }
rust/kernel/devres.rs +8 -7
@@ -45,7 +45,7 @@ struct DevresInner<T> {/// # Example /// /// ```no_run -/// # use kernel::{bindings, c_str, device::Device, devres::Devres, io::{Io, IoRaw}}; +/// # use kernel::{bindings, c_str, device::Device, devres::Devres, ffi::c_void, io::{Io, IoRaw}}; /// # use core::ops::Deref; /// /// // See also [`pci::Bar`] for a real example.
@@ -59,19 +59,19 @@ struct DevresInner<T> {/// unsafe fn new(paddr: usize) -> Result<Self>{ /// // SAFETY: By the safety requirements of this function [`paddr`, `paddr` + `SIZE`) is /// // valid for `ioremap`. -/// let addr = unsafe { bindings::ioremap(paddr as _, SIZE as _) }; +/// let addr = unsafe { bindings::ioremap(paddr as bindings::phys_addr_t, SIZE) }; /// if addr.is_null() { /// return Err(ENOMEM); /// } /// -/// Ok(IoMem(IoRaw::new(addr as _, SIZE)?)) +/// Ok(IoMem(IoRaw::new(addr as usize, SIZE)?)) /// } /// } /// /// impl<const SIZE: usize> Drop for IoMem<SIZE> { /// fn drop(&mut self) { /// // SAFETY: `self.0.addr()` is guaranteed to be properly mapped by `Self::new`. -/// unsafe { bindings::iounmap(self.0.addr() as _); }; +/// unsafe { bindings::iounmap(self.0.addr() as *mut c_void); }; /// } /// } ///
@@ -115,8 +115,9 @@ fn new(dev: &Device, data: T, flags: Flags) -> Result<Arc<DevresInner<T>>> {// SAFETY: `devm_add_action` guarantees to call `Self::devres_callback` once `dev` is // detached. -let ret = -unsafe { bindings::devm_add_action (dev.as_raw (),Some (inner.callback), dataas _ ) }; +let ret =unsafe { + bindings::devm_add_action (dev.as_raw (),Some (inner.callback), data.cast_mut ().cast ()) + };if ret !=0 {// SAFETY: We just created another reference to `inner` in order to pass it to
@@ -130,7 +131,7 @@ fn new(dev: &Device, data: T, flags: Flags) -> Result<Arc<DevresInner<T>>> { }fn as_ptr (&self) -> *const Self { - selfas _ + self }fn remove_action (this: &Arc <Self >) {
rust/kernel/error.rs +1 -1
@@ -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 _ ).cast () } +unsafe { bindings::ERR_PTR (self.0 .get ()as isize ).cast () } }/// Returns a string representing the error, if one exists.
rust/kernel/io.rs +9 -9
@@ -5,7 +5,7 @@//! C header: [`include/asm-generic/io.h`](srctree/include/asm-generic/io.h) use crate ::error::{code::EINVAL ,Result }; -use crate ::{bindings, build_assert}; +use crate ::{bindings, build_assert, ffi::c_void};/// Raw representation of an MMIO region. ///
@@ -56,7 +56,7 @@ pub fn maxsize(&self) -> usize {/// # Examples /// /// ```no_run -/// # use kernel::{bindings, io::{Io, IoRaw}}; +/// # use kernel::{bindings, ffi::c_void, io::{Io, IoRaw}}; /// # use core::ops::Deref; /// /// // See also [`pci::Bar`] for a real example.
@@ -70,19 +70,19 @@ pub fn maxsize(&self) -> usize {/// unsafe fn new(paddr: usize) -> Result<Self>{ /// // SAFETY: By the safety requirements of this function [`paddr`, `paddr` + `SIZE`) is /// // valid for `ioremap`. -/// let addr = unsafe { bindings::ioremap(paddr as _, SIZE as _) }; +/// let addr = unsafe { bindings::ioremap(paddr as bindings::phys_addr_t, SIZE) }; /// if addr.is_null() { /// return Err(ENOMEM); /// } /// -/// Ok(IoMem(IoRaw::new(addr as _, SIZE)?)) +/// Ok(IoMem(IoRaw::new(addr as usize, SIZE)?)) /// } /// } /// /// impl<const SIZE: usize> Drop for IoMem<SIZE> { /// fn drop(&mut self) { /// // SAFETY: `self.0.addr()` is guaranteed to be properly mapped by `Self::new`. -/// unsafe { bindings::iounmap(self.0.addr() as _); }; +/// unsafe { bindings::iounmap(self.0.addr() as *mut c_void); }; /// } /// } ///
@@ -119,7 +119,7 @@ pub fn $name(&self, offset: usize) -> $type_name {let addr = self.io_addr_assert ::<$type_name>(offset);// SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(addr as _) } + unsafe { bindings::$name(addr as *const c_void) } }/// Read IO data from a given offset.
@@ -131,7 +131,7 @@ pub fn $try_name(&self, offset: usize) -> Result<$type_name> {let addr = self.io_addr ::<$type_name>(offset)?;// SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - Ok(unsafe { bindings::$name(addr as _) }) + Ok(unsafe { bindings::$name(addr as *const c_void) }) } }; }
@@ -148,7 +148,7 @@ pub fn $name(&self, value: $type_name, offset: usize) {let addr = self.io_addr_assert ::<$type_name>(offset);// SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(value, addr as _, ) } + unsafe { bindings::$name(value, addr as *mut c_void) } }/// Write IO data from a given offset.
@@ -160,7 +160,7 @@ pub fn $try_name(&self, value: $type_name, offset: usize) -> Result {let addr = self.io_addr ::<$type_name>(offset)?;// SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(value, addr as _) } + unsafe { bindings::$name(value, addr as *mut c_void) }Ok (()) } };
rust/kernel/miscdevice.rs +1 -1
@@ -33,7 +33,7 @@ impl MiscDeviceOptions {pub const fn into_raw <T :MiscDevice >(self) -> bindings::miscdevice {// SAFETY: All zeros is valid for this C type. let mut result: bindings::miscdevice =unsafe {MaybeUninit ::zeroed ().assume_init () }; - result.minor = bindings::MISC_DYNAMIC_MINOR as _ ; + result.minor = bindings::MISC_DYNAMIC_MINOR as i32 ; result.name = self.name.as_char_ptr (); result.fops =create_vtable ::<T >(); result
rust/kernel/of.rs +3 -3
@@ -22,7 +22,7 @@ unsafe impl RawDeviceId for DeviceId {const DRIVER_DATA_OFFSET :usize = core::mem::offset_of!(bindings::of_device_id, data);fn index (&self) ->usize { - self.0 .dataas _ + self.0 .dataas usize } }
@@ -34,10 +34,10 @@ pub const fn new(compatible: &'static CStr) -> Self {// SAFETY: FFI type is valid to be zero-initialized. let mut of: bindings::of_device_id =unsafe { core::mem::zeroed () }; -// TODO: Use `clone_from_slice` once the corresponding types do match. +// TODO: Use `copy_from_slice` once stabilized for `const`. let mut i =0 ;while i < src.len () { - of.compatible[i] = src[i]as _ ; + of.compatible[i] = src[i]; i +=1 ; }
rust/kernel/pci.rs +6 -3
@@ -166,7 +166,7 @@ unsafe impl RawDeviceId for DeviceId {const DRIVER_DATA_OFFSET :usize = core::mem::offset_of!(bindings::pci_device_id, driver_data);fn index (&self) ->usize { - self.0 .driver_dataas _ + self.0 .driver_data } }
@@ -201,7 +201,10 @@ macro_rules! pci_device_table {/// MODULE_PCI_TABLE, /// <MyDriver as pci::Driver>::IdInfo, /// [ -/// (pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_REDHAT, bindings::PCI_ANY_ID as _), ()) +/// ( +/// pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_REDHAT, bindings::PCI_ANY_ID as u32), +/// (), +/// ) /// ] /// ); ///
@@ -317,7 +320,7 @@ unsafe fn do_release(pdev: &Device, ioptr: usize, num: i32) {// `ioptr` is valid by the safety requirements. // `num` is valid by the safety requirements. unsafe { - bindings::pci_iounmap (pdev.as_raw (), ioptras _ ); + bindings::pci_iounmap (pdev.as_raw (), ioptras *mut kernel::ffi::c_void ); bindings::pci_release_region (pdev.as_raw (), num); } }
rust/kernel/str.rs +4 -4
@@ -692,9 +692,9 @@ fn new() -> Self {pub (crate )unsafe fn from_ptrs (pos: *mut u8 , end: *mut u8 ) ->Self {// INVARIANT: The safety requirements guarantee the type invariants. Self { - beg: posas _ , - pos: posas _ , - end: endas _ , + beg: posas usize , + pos: posas usize , + end: endas usize , } }
@@ -719,7 +719,7 @@ pub(crate) unsafe fn from_buffer(buf: *mut u8, len: usize) -> Self {/// /// N.B. It may point to invalid memory. pub (crate )fn pos (&self) -> *mut u8 { - self.posas _ + self.posas *mut u8 }/// Returns the number of bytes written to the formatter.
rust/kernel/workqueue.rs +1 -1
@@ -198,7 +198,7 @@ pub fn enqueue<W, const ID: u64>(&self, w: W) -> W::EnqueueOutputunsafe { w.__enqueue (move |work_ptr| { bindings::queue_work_on ( - bindings::wq_misc_consts_WORK_CPU_UNBOUNDas _ , + bindings::wq_misc_consts_WORK_CPU_UNBOUNDas i32 , queue_ptr, work_ptr, )
Signature · 1 line
2.48.1
PATCH v4 6/6 rust: use strict provenance APIs
In reply to Tamir DubersteinThroughout the tree, use the strict provenance APIs stabilized in Rust 1.84.0[1]. Retain backwards-compatibility by introducing forwarding functions at the kernel crate root along with polyfills for rustc < 1.84.0.
Use #[allow(clippy::incompatible_msrv)] to avoid warnings on rustc < 1.84.0 as our MSRV is 1.78.0.
In the kernel crate, enable the strict provenance lints on rustc >= 1.84.0; do this in lib.rs rather than Makefile to avoid introducing compiler flags that are dependent on the rustc version in use.
--- init/Kconfig | 3 +++ rust/kernel/alloc.rs | 2 +- rust/kernel/devres.rs | 4 ++-- rust/kernel/io.rs | 14 +++++++------- rust/kernel/lib.rs | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++ rust/kernel/of.rs | 2 +- rust/kernel/pci.rs | 4 ++-- rust/kernel/str.rs | 16 ++++++---------- rust/kernel/uaccess.rs | 12 ++++++++---- 9 files changed, 82 insertions(+), 27 deletions(-)
init/Kconfig +3 -0
@@ -132,6 +132,9 @@ config CC_HAS_COUNTED_BY config RUSTC_HAS_COERCE_POINTEE def_bool RUSTC_VERSION >= 108400 +config RUSTC_HAS_STABLE_STRICT_PROVENANCE + def_bool RUSTC_VERSION >= 108400 + config PAHOLE_VERSION int default $(shell,$(srctree)/scripts/pahole-version.sh $(PAHOLE))
rust/kernel/alloc.rs +1 -1
@@ -217,7 +217,7 @@ unsafe fn free(ptr: NonNull<u8>, layout: Layout) {/// Returns a properly aligned dangling pointer from the given `layout`. pub (crate )fn dangling_from_layout (layout:Layout ) ->NonNull <u8 > { -let ptr = layout.align ()as *mut u8 ; +let ptr =crate ::without_provenance_mut (layout.align ());// SAFETY: `layout.align()` (and hence `ptr`) is guaranteed to be non-zero. unsafe {NonNull ::new_unchecked (ptr) }
rust/kernel/devres.rs +2 -2
@@ -64,14 +64,14 @@ struct DevresInner<T> {/// return Err(ENOMEM); /// } /// -/// Ok(IoMem(IoRaw::new(addr as usize, SIZE)?)) +/// Ok(IoMem(IoRaw::new(kernel::expose_provenance(addr), SIZE)?)) /// } /// } /// /// impl<const SIZE: usize> Drop for IoMem<SIZE> { /// fn drop(&mut self) { /// // SAFETY: `self.0.addr()` is guaranteed to be properly mapped by `Self::new`. -/// unsafe { bindings::iounmap(self.0.addr() as *mut c_void); }; +/// unsafe { bindings::iounmap(kernel::with_exposed_provenance_mut(self.0.addr())); }; /// } /// } ///
rust/kernel/io.rs +7 -7
@@ -5,7 +5,7 @@//! C header: [`include/asm-generic/io.h`](srctree/include/asm-generic/io.h) use crate ::error::{code::EINVAL ,Result }; -use crate ::{bindings, build_assert, ffi::c_void}; +use crate ::{bindings, build_assert};/// Raw representation of an MMIO region. ///
@@ -75,14 +75,14 @@ pub fn maxsize(&self) -> usize {/// return Err(ENOMEM); /// } /// -/// Ok(IoMem(IoRaw::new(addr as usize, SIZE)?)) +/// Ok(IoMem(IoRaw::new(kernel::expose_provenance(addr), SIZE)?)) /// } /// } /// /// impl<const SIZE: usize> Drop for IoMem<SIZE> { /// fn drop(&mut self) { /// // SAFETY: `self.0.addr()` is guaranteed to be properly mapped by `Self::new`. -/// unsafe { bindings::iounmap(self.0.addr() as *mut c_void); }; +/// unsafe { bindings::iounmap(kernel::with_exposed_provenance_mut(self.0.addr())); }; /// } /// } ///
@@ -119,7 +119,7 @@ pub fn $name(&self, offset: usize) -> $type_name {let addr = self.io_addr_assert ::<$type_name>(offset);// SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(addr as *const c_void) } + unsafe { bindings::$name(crate::with_exposed_provenance(addr)) } }/// Read IO data from a given offset.
@@ -131,7 +131,7 @@ pub fn $try_name(&self, offset: usize) -> Result<$type_name> {let addr = self.io_addr ::<$type_name>(offset)?;// SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - Ok(unsafe { bindings::$name(addr as *const c_void) }) + Ok(unsafe { bindings::$name(crate::with_exposed_provenance(addr)) }) } }; }
@@ -148,7 +148,7 @@ pub fn $name(&self, value: $type_name, offset: usize) {let addr = self.io_addr_assert ::<$type_name>(offset);// SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(value, addr as *mut c_void) } + unsafe { bindings::$name(value, crate::with_exposed_provenance_mut(addr)) } }/// Write IO data from a given offset.
@@ -160,7 +160,7 @@ pub fn $try_name(&self, value: $type_name, offset: usize) -> Result {let addr = self.io_addr ::<$type_name>(offset)?;// SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(value, addr as *mut c_void) } + unsafe { bindings::$name(value, crate::with_exposed_provenance_mut(addr)) }Ok (()) } };
rust/kernel/lib.rs +52 -0
64 lines not on this page · raw message
rust/kernel/of.rs +1 -1
@@ -22,7 +22,7 @@ unsafe impl RawDeviceId for DeviceId {const DRIVER_DATA_OFFSET :usize = core::mem::offset_of!(bindings::of_device_id, data);fn index (&self) ->usize { - self.0 .dataas usize +crate ::expose_provenance (self.0 .data) } }
rust/kernel/pci.rs +2 -2
@@ -287,7 +287,7 @@ fn new(pdev: Device, num: u32, name: &CStr) -> Result<Self> {// `pdev` is valid by the invariants of `Device`. // `num` is checked for validity by a previous call to `Device::resource_len`. // `name` is always valid. -let ioptr:usize =unsafe { bindings::pci_iomap (pdev.as_raw (), num,0 ) }as usize ; +let ioptr =crate ::expose_provenance (unsafe { bindings::pci_iomap (pdev.as_raw (), num,0 ) });if ioptr ==0 {// SAFETY: // `pdev` valid by the invariants of `Device`.
@@ -320,7 +320,7 @@ unsafe fn do_release(pdev: &Device, ioptr: usize, num: i32) {// `ioptr` is valid by the safety requirements. // `num` is valid by the safety requirements. unsafe { - bindings::pci_iounmap (pdev.as_raw (), ioptras *mut kernel::ffi::c_void ); + bindings::pci_iounmap (pdev.as_raw (),crate ::with_exposed_provenance_mut (ioptr)); bindings::pci_release_region (pdev.as_raw (), num); } }
rust/kernel/str.rs +6 -10
@@ -692,9 +692,9 @@ fn new() -> Self {pub (crate )unsafe fn from_ptrs (pos: *mut u8 , end: *mut u8 ) ->Self {// INVARIANT: The safety requirements guarantee the type invariants. Self { - beg: posas usize , - pos: posas usize , - end: endas usize , + beg:crate ::expose_provenance (pos), + pos:crate ::expose_provenance (pos), + end:crate ::expose_provenance (end), } }
@@ -705,7 +705,7 @@ pub(crate) unsafe fn from_ptrs(pos: *mut u8, end: *mut u8) -> Self {/// The memory region starting at `buf` and extending for `len` bytes must be valid for writes /// for the lifetime of the returned [`RawFormatter`]. pub (crate )unsafe fn from_buffer (buf: *mut u8 , len:usize ) ->Self { -let pos = bufas usize ; +let pos =crate ::expose_provenance (buf);// INVARIANT: We ensure that `end` is never less then `buf`, and the safety requirements // guarantees that the memory region is valid for writes. Self {
@@ -719,7 +719,7 @@ pub(crate) unsafe fn from_buffer(buf: *mut u8, len: usize) -> Self {/// /// N.B. It may point to invalid memory. pub (crate )fn pos (&self) -> *mut u8 { - self.posas *mut u8 +crate ::with_exposed_provenance_mut (self.pos) }/// Returns the number of bytes written to the formatter.
@@ -741,11 +741,7 @@ fn write_str(&mut self, s: &str) -> fmt::Result {// SAFETY: If `len_to_copy` is non-zero, then we know `pos` has not gone past `end` // yet, so it is valid for write per the type invariants. unsafe { - core::ptr::copy_nonoverlapping ( - s.as_bytes ().as_ptr (), - self.posas *mut u8 , - len_to_copy, - ) + core::ptr::copy_nonoverlapping (s.as_bytes ().as_ptr (), self.pos (), len_to_copy) }; }
rust/kernel/uaccess.rs +8 -4
@@ -226,7 +226,9 @@ pub fn read_raw(&mut self, out: &mut [MaybeUninit<u8>]) -> Result { }// SAFETY: `out_ptr` points into a mutable slice of length `len`, so we may write // that many bytes to it. -let res =unsafe { bindings::copy_from_user (out_ptr, self.ptras *const c_void , len) }; +let res =unsafe { + bindings::copy_from_user (out_ptr,crate ::with_exposed_provenance (self.ptr), len) + };if res !=0 {return Err (EFAULT ); }
@@ -264,7 +266,7 @@ pub fn read<T: FromBytes>(&mut self) -> Result<T> {let res =unsafe { bindings::_copy_from_user ( out.as_mut_ptr ().cast ::<c_void >(), - self.ptras *const c_void , +crate ::with_exposed_provenance (self.ptr), len, ) };
@@ -330,7 +332,9 @@ pub fn write_slice(&mut self, data: &[u8]) -> Result { }// SAFETY: `data_ptr` points into an immutable slice of length `len`, so we may read // that many bytes from it. -let res =unsafe { bindings::copy_to_user (self.ptras *mut c_void , data_ptr, len) }; +let res =unsafe { + bindings::copy_to_user (crate ::with_exposed_provenance_mut (self.ptr), data_ptr, len) + };if res !=0 {return Err (EFAULT ); }
@@ -357,7 +361,7 @@ pub fn write<T: AsBytes>(&mut self, value: &T) -> Result {// is a compile-time constant. let res =unsafe { bindings::_copy_to_user ( - self.ptras *mut c_void , +crate ::with_exposed_provenance_mut (self.ptr), (valueas *const T ).cast ::<c_void >(), len, )
Signature · 1 line
2.48.1
Re: [PATCH v4 6/6] rust: use strict provenance APIs
On Sat, Mar 15, 2025 at 08:17:30AM -0400, Tamir Duberstein wrote:
[...]
rust/kernel/of.rs unsafe impl RawDeviceId for DeviceId { · line 25
Quoted 10 lines
rust/kernel/of.rs +1
-1@@ -22,7 +22,7 @@ unsafe impl RawDeviceId for DeviceId {const DRIVER_DATA_OFFSET :usize = core::mem::offset_of!(bindings::of_device_id, data);fn index (&self) ->usize { - self.0 .dataas usize +crate ::expose_provenance (self.0 .data)
Even though of_device_id::data was defined as void *, but in Rust we use it to store index, see kernel::device_id::{IdTable::info(), IdArray::new()}. Hence we should use self.0.data.addr() here.
Regards,
Boqun
Quoted 3 lines
rust/kernel/of.rs +0
-0} }
[...]
Re: [PATCH v4 6/6] rust: use strict provenance APIs
Quoted 10 lines · Boqun Feng
On Sat, Mar 15, 2025 at 08:17:30AM -0400, Tamir Duberstein wrote:
[...]Quoted 7 lines
rust/kernel/of.rs +0
-0@@ -22,7 +22,7 @@ unsafe impl RawDeviceId for DeviceId {const DRIVER_DATA_OFFSET :usize = core::mem::offset_of!(bindings::of_device_id, data);
Quoted 7 lines
rust/kernel/of.rs unsafe impl RawDeviceId for DeviceId { · line 25
Quoted 3 lines
rust/kernel/of.rs +1
-1fn index (&self) ->usize { - self.0 .dataas usize +crate ::expose_provenance (self.0 .data)Even though
of_device_id::datawas defined asvoid *, but in Rust we use it to store index, see kernel::device_id::{IdTable::info(),IdArray::new()}. Hence we should use self.0.data.addr() here.
Good point, thanks.
Re: [PATCH v4 6/6] rust: use strict provenance APIs
In reply to Tamir DubersteinQuoted 7 lines · Tamir Duberstein
Throughout the tree, use the strict provenance APIs stabilized in Rust 1.84.0[1]. Retain backwards-compatibility by introducing forwarding functions at the
kernelcrate root along with polyfills for rustc < 1.84.0.Use
#[allow(clippy::incompatible_msrv)]to avoid warnings on rustc < 1.84.0 as our MSRV is 1.78.0.
This isn't necessary, right?
Quoted 3 lines
In the
kernelcrate, enable the strict provenance lints on rustc >= 1.84.0; do this inlib.rsrather thanMakefileto avoid introducing compiler flags that are dependent on the rustc version in use.
So it won't be enabled in the doctests, right?
Quoted 32 lines
Suggested-by Benno Lossin <[email protected]>Signed-off-by Tamir Duberstein <[email protected]>--- init/Kconfig | 3 +++ rust/kernel/alloc.rs | 2 +- rust/kernel/devres.rs | 4 ++-- rust/kernel/io.rs | 14 +++++++------- rust/kernel/lib.rs | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++ rust/kernel/of.rs | 2 +- rust/kernel/pci.rs | 4 ++-- rust/kernel/str.rs | 16 ++++++---------- rust/kernel/uaccess.rs | 12 ++++++++---- 9 files changed, 82 insertions(+), 27 deletions(-)rust/kernel/lib.rs +3
-0@@ -17,6 +17,9 @@#![cfg_attr(not( CONFIG_RUSTC_HAS_COERCE_POINTEE ), feature(coerce_unsized))] #![cfg_attr(not( CONFIG_RUSTC_HAS_COERCE_POINTEE ), feature(dispatch_from_dyn))] #![cfg_attr(not( CONFIG_RUSTC_HAS_COERCE_POINTEE ), feature(unsize))] +#![cfg_attr( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE , feature(strict_provenance_lints))] +#![cfg_attr( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE , deny(fuzzy_provenance_casts))] +#![cfg_attr( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE , deny(lossy_provenance_casts))] #![feature(inline_const)] #![feature(lint_reasons)] // Stable in Rust 1.83
rust/kernel/lib.rs line 32
Quoted 5 lines
rust/kernel/lib.rs +2
-0@@ -25,6 +28,55 @@#![feature(const_ptr_write)] #![feature(const_refs_to_cell)] +#[cfg( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE )] +#[allow(clippy::incompatible_msrv)]
Do we still need this allow?
rust/kernel/lib.rs line 34
Quoted 2 lines
rust/kernel/lib.rs +2
-0+mod strict_provenance { +#[doc(hidden)]
Why make them hidden in docs?
rust/kernel/lib.rs line 36
Quoted 2 lines
rust/kernel/lib.rs +2
-0+pub fn expose_provenance <T >(addr: *const T ) ->usize { + addr.expose_provenance ()
Instead of having these stubs here, you can probably just do
pub use core::ptr::expose_provenance;
Quoted 11 lines
rust/kernel/lib.rs +11
-0+ } + +#[doc(hidden)] +pub fn without_provenance_mut <T >(addr:usize ) -> *mut T { + core::ptr::without_provenance_mut (addr) + } + +#[doc(hidden)] +pub fn with_exposed_provenance <T >(addr:usize ) -> *const T { + core::ptr::with_exposed_provenance (addr) + }
rust/kernel/lib.rs line 57
Quoted 10 lines
rust/kernel/lib.rs +10
-0+ +#[doc(hidden)] +pub fn with_exposed_provenance_mut <T >(addr:usize ) -> *mut T { + core::ptr::with_exposed_provenance_mut (addr) + } +} + +#[cfg(not( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE ))] +mod strict_provenance { +#[doc(hidden)]
I think we should document these.
---
Cheers,
Benno
Quoted 21 lines
rust/kernel/lib.rs +21
-0+pub fn expose_provenance <T >(addr: *const T ) ->usize { + addr.cast ::<()>()as usize + } + +#[doc(hidden)] +pub fn without_provenance_mut <T >(addr:usize ) -> *mut T { + addras *mut T + } + +#[doc(hidden)] +pub fn with_exposed_provenance <T >(addr:usize ) -> *const T { + addras *const T + } + +#[doc(hidden)] +pub fn with_exposed_provenance_mut <T >(addr:usize ) -> *mut T { + addras *mut T + } +} + +pub use strict_provenance::*;
Re: [PATCH v4 6/6] rust: use strict provenance APIs
Quoted 11 lines · Benno Lossin
Quoted 7 lines · Tamir Duberstein
Throughout the tree, use the strict provenance APIs stabilized in Rust 1.84.0[1]. Retain backwards-compatibility by introducing forwarding functions at the
kernelcrate root along with polyfills for rustc < 1.84.0.Use
#[allow(clippy::incompatible_msrv)]to avoid warnings on rustc < 1.84.0 as our MSRV is 1.78.0.This isn't necessary, right?
It is necessary. MSRV is encoded in .clippy.toml, it doesn't matter what the *current* rustc version is.
Quoted 5 lines
Quoted 3 lines
In the
kernelcrate, enable the strict provenance lints on rustc >= 1.84.0; do this inlib.rsrather thanMakefileto avoid introducing compiler flags that are dependent on the rustc version in use.So it won't be enabled in the doctests, right?
Yes, that is correct.
Quoted 35 lines
Quoted 35 lines
Suggested-by Benno Lossin <[email protected]>Signed-off-by Tamir Duberstein <[email protected]>--- init/Kconfig | 3 +++ rust/kernel/alloc.rs | 2 +- rust/kernel/devres.rs | 4 ++-- rust/kernel/io.rs | 14 +++++++------- rust/kernel/lib.rs | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++ rust/kernel/of.rs | 2 +- rust/kernel/pci.rs | 4 ++-- rust/kernel/str.rs | 16 ++++++---------- rust/kernel/uaccess.rs | 12 ++++++++---- 9 files changed, 82 insertions(+), 27 deletions(-)rust/kernel/lib.rs +3
-0@@ -17,6 +17,9 @@#![cfg_attr(not( CONFIG_RUSTC_HAS_COERCE_POINTEE ), feature(coerce_unsized))] #![cfg_attr(not( CONFIG_RUSTC_HAS_COERCE_POINTEE ), feature(dispatch_from_dyn))] #![cfg_attr(not( CONFIG_RUSTC_HAS_COERCE_POINTEE ), feature(unsize))] +#![cfg_attr( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE , feature(strict_provenance_lints))] +#![cfg_attr( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE , deny(fuzzy_provenance_casts))] +#![cfg_attr( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE , deny(lossy_provenance_casts))] #![feature(inline_const)] #![feature(lint_reasons)] // Stable in Rust 1.83 @@ -25,6 +28,55 @@#![feature(const_ptr_write)] #![feature(const_refs_to_cell)]
Quoted 4 lines
rust/kernel/lib.rs line 32
Quoted 2 lines
rust/kernel/lib.rs +2
-0+#[cfg( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE )] +#[allow(clippy::incompatible_msrv)] Do we still need this allow?
Yes, explained above.
Quoted 4 lines
rust/kernel/lib.rs line 34
Quoted 2 lines
rust/kernel/lib.rs +2
-0+mod strict_provenance { +#[doc(hidden)] Why make them hidden in docs?
I've added documentation that defers to the standard library.
Quoted 7 lines
rust/kernel/lib.rs line 36
Quoted 3 lines
rust/kernel/lib.rs +2
-0+pub fn expose_provenance <T >(addr: *const T ) ->usize { + addr.expose_provenance ()Instead of having these stubs here, you can probably just do
pub use core::ptr::expose_provenance;
This doesn't work for the methods on primitives, but it works for the free functions. Done.
Quoted 15 lines
Quoted 15 lines
rust/kernel/lib.rs +15
-0+ } + +#[doc(hidden)] +pub fn without_provenance_mut <T >(addr:usize ) -> *mut T { + core::ptr::without_provenance_mut (addr) + } + +#[doc(hidden)] +pub fn with_exposed_provenance <T >(addr:usize ) -> *const T { + core::ptr::with_exposed_provenance (addr) + } + +#[doc(hidden)] +pub fn with_exposed_provenance_mut <T >(addr:usize ) -> *mut T { + core::ptr::with_exposed_provenance_mut (addr)
Quoted 8 lines
rust/kernel/lib.rs line 57
Quoted 6 lines
rust/kernel/lib.rs +6
-0+ } +} + +#[cfg(not( CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE ))] +mod strict_provenance { +#[doc(hidden)] I think we should document these.
Done.
Quoted 27 lines
---
Cheers,
BennoQuoted 21 lines
rust/kernel/lib.rs +21
-0+pub fn expose_provenance <T >(addr: *const T ) ->usize { + addr.cast ::<()>()as usize + } + +#[doc(hidden)] +pub fn without_provenance_mut <T >(addr:usize ) -> *mut T { + addras *mut T + } + +#[doc(hidden)] +pub fn with_exposed_provenance <T >(addr:usize ) -> *const T { + addras *const T + } + +#[doc(hidden)] +pub fn with_exposed_provenance_mut <T >(addr:usize ) -> *mut T { + addras *mut T + } +} + +pub use strict_provenance::*;
Re: [PATCH v4 6/6] rust: use strict provenance APIs
Quoted 6 lines · Tamir Duberstein
Quoted 4 lines · Benno Lossin
Quoted 3 lines
rust/kernel/lib.rs +2
-0+pub fn expose_provenance <T >(addr: *const T ) ->usize { + addr.expose_provenance ()
Quoted 6 lines
Quoted 3 lines
Instead of having these stubs here, you can probably just do
pub use core::ptr::expose_provenance;This doesn't work for the methods on primitives, but it works for the free functions. Done.
Have to revert this, writing pub use ... directly causes the MSRV clippy lint to fire at the caller.
Re: [PATCH v4 6/6] rust: use strict provenance APIs
Quoted 9 lines · Tamir Duberstein
Quoted 8 lines · Tamir Duberstein
Quoted 6 lines · Benno Lossin
rust/kernel/lib.rs line 36
Quoted 3 lines
rust/kernel/lib.rs +2
-0+pub fn expose_provenance <T >(addr: *const T ) ->usize { + addr.expose_provenance ()Instead of having these stubs here, you can probably just do
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
pub use core::ptr::expose_provenance;This doesn't work for the methods on primitives, but it works for the free functions. Done.
Have to revert this, writing
pub use ...directly causes the MSRV clippy lint to fire at the caller.
Ah that is unfortunate.
---
Cheers,
Benno
Re: [PATCH v4 6/6] rust: use strict provenance APIs
In reply to Tamir DubersteinQuoted 8 lines · Tamir Duberstein
Quoted 7 lines · Benno Lossin
Quoted 5 lines · Tamir Duberstein
Throughout the tree, use the strict provenance APIs stabilized in Rust 1.84.0[1]. Retain backwards-compatibility by introducing forwarding functions at the
kernelcrate root along with polyfills for rustc < 1.84.0.
Quoted 7 lines
Quoted 4 lines
Quoted 2 lines
Use
#[allow(clippy::incompatible_msrv)]to avoid warnings on rustc < 1.84.0 as our MSRV is 1.78.0.This isn't necessary, right?
It is necessary. MSRV is encoded in .clippy.toml, it doesn't matter what the *current* rustc version is.
Oh of course.
Quoted 7 lines
Quoted 5 lines
Quoted 3 lines
In the
kernelcrate, enable the strict provenance lints on rustc >= 1.84.0; do this inlib.rsrather thanMakefileto avoid introducing compiler flags that are dependent on the rustc version in use.So it won't be enabled in the doctests, right?
Yes, that is correct.
I would mention this in the commit message. Thanks!
---
Cheers,
Benno