Re: [PATCH v12 4/6] rust: enable `clippy::as_underscore` lint

[Tamir Duberstein <tamird@gmail.com>]

On Sun, Jun 15, 2025 at 4:55 PM Tamir Duberstein <tamird@gmail.com> wrote:
>
> In Rust 1.63.0, Clippy introduced the `as_underscore` lint [1]:
>
> > 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.
>
> Link: https://rust-lang.github.io/rust-clippy/master/index.html#as_underscore [1]
> Reviewed-by: Benno Lossin <benno.lossin@proton.me>
> Reviewed-by: Boqun Feng <boqun.feng@gmail.com>
> Signed-off-by: Tamir Duberstein <tamird@gmail.com>

@Danilo Krummrich could you please have a look for nova?

> ---
>  Makefile                           |  1 +
>  drivers/gpu/nova-core/driver.rs    |  2 +-
>  rust/kernel/block/mq/operations.rs |  2 +-
>  rust/kernel/block/mq/request.rs    |  7 ++++-
>  rust/kernel/device_id.rs           |  2 +-
>  rust/kernel/devres.rs              | 13 +++++-----
>  rust/kernel/dma.rs                 |  2 +-
>  rust/kernel/drm/device.rs          |  2 +-
>  rust/kernel/error.rs               |  2 +-
>  rust/kernel/io.rs                  | 18 ++++++-------
>  rust/kernel/miscdevice.rs          |  2 +-
>  rust/kernel/mm/virt.rs             | 52 +++++++++++++++++++-------------------
>  rust/kernel/of.rs                  |  6 ++---
>  rust/kernel/pci.rs                 |  9 ++++---
>  rust/kernel/str.rs                 |  8 +++---
>  rust/kernel/workqueue.rs           |  2 +-
>  16 files changed, 70 insertions(+), 60 deletions(-)
>
> diff --git a/Makefile b/Makefile
> index bb33023f87c3..0ba22c361de8 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -480,6 +480,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 \
> diff --git a/drivers/gpu/nova-core/driver.rs b/drivers/gpu/nova-core/driver.rs
> index 8c86101c26cb..a0e435dc4656 100644
> --- a/drivers/gpu/nova-core/driver.rs
> +++ b/drivers/gpu/nova-core/driver.rs
> @@ -19,7 +19,7 @@ pub(crate) struct NovaCore {
>      MODULE_PCI_TABLE,
>      <NovaCore as pci::Driver>::IdInfo,
>      [(
> -        pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_NVIDIA, bindings::PCI_ANY_ID as _),
> +        pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_NVIDIA, bindings::PCI_ANY_ID as u32),
>          ()
>      )]
>  );
> diff --git a/rust/kernel/block/mq/operations.rs b/rust/kernel/block/mq/operations.rs
> index 864ff379dc91..c2b98f507bcb 100644
> --- a/rust/kernel/block/mq/operations.rs
> +++ b/rust/kernel/block/mq/operations.rs
> @@ -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 bindings::blk_status_t
>          }
>      }
>
> diff --git a/rust/kernel/block/mq/request.rs b/rust/kernel/block/mq/request.rs
> index af5c9ac94f36..fefd394f064a 100644
> --- a/rust/kernel/block/mq/request.rs
> +++ b/rust/kernel/block/mq/request.rs
> @@ -125,7 +125,12 @@ 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 bindings::blk_status_t,
> +            )
> +        };
>
>          Ok(())
>      }
> diff --git a/rust/kernel/device_id.rs b/rust/kernel/device_id.rs
> index 0a4eb56d98f2..f9d55ac7b9e6 100644
> --- a/rust/kernel/device_id.rs
> +++ b/rust/kernel/device_id.rs
> @@ -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);
>              }
> diff --git a/rust/kernel/devres.rs b/rust/kernel/devres.rs
> index 237182446db3..1e44d70687a8 100644
> --- a/rust/kernel/devres.rs
> +++ b/rust/kernel/devres.rs
> @@ -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); };
>  ///     }
>  /// }
>  ///
> @@ -112,8 +112,9 @@ fn new(dev: &Device<Bound>, 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), data as _) };
> +        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
> @@ -127,7 +128,7 @@ fn new(dev: &Device<Bound>, data: T, flags: Flags) -> Result<Arc<DevresInner<T>>
>      }
>
>      fn as_ptr(&self) -> *const Self {
> -        self as _
> +        self
>      }
>
>      fn remove_action(this: &Arc<Self>) {
> diff --git a/rust/kernel/dma.rs b/rust/kernel/dma.rs
> index 666bf2d64f9a..8e317005decd 100644
> --- a/rust/kernel/dma.rs
> +++ b/rust/kernel/dma.rs
> @@ -38,7 +38,7 @@
>  impl Attrs {
>      /// Get the raw representation of this attribute.
>      pub(crate) fn as_raw(self) -> crate::ffi::c_ulong {
> -        self.0 as _
> +        self.0 as crate::ffi::c_ulong
>      }
>
>      /// Check whether `flags` is contained in `self`.
> diff --git a/rust/kernel/drm/device.rs b/rust/kernel/drm/device.rs
> index ef66deb7ce23..b7ee3c464a12 100644
> --- a/rust/kernel/drm/device.rs
> +++ b/rust/kernel/drm/device.rs
> @@ -89,7 +89,7 @@ impl<T: drm::Driver> Device<T> {
>          driver_features: drm::driver::FEAT_GEM,
>          ioctls: T::IOCTLS.as_ptr(),
>          num_ioctls: T::IOCTLS.len() as i32,
> -        fops: &Self::GEM_FOPS as _,
> +        fops: &Self::GEM_FOPS,
>      };
>
>      const GEM_FOPS: bindings::file_operations = drm::gem::create_fops();
> diff --git a/rust/kernel/error.rs b/rust/kernel/error.rs
> index afcb00cb6a75..fd7a8b759437 100644
> --- a/rust/kernel/error.rs
> +++ b/rust/kernel/error.rs
> @@ -153,7 +153,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.
> diff --git a/rust/kernel/io.rs b/rust/kernel/io.rs
> index 72d80a6f131e..c08de4121637 100644
> --- a/rust/kernel/io.rs
> +++ b/rust/kernel/io.rs
> @@ -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::$c_fn(addr as _) }
> +            unsafe { bindings::$c_fn(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::$c_fn(addr as _) })
> +            Ok(unsafe { bindings::$c_fn(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::$c_fn(value, addr as _, ) }
> +            unsafe { bindings::$c_fn(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::$c_fn(value, addr as _) }
> +            unsafe { bindings::$c_fn(value, addr as *mut c_void) }
>              Ok(())
>          }
>      };
> diff --git a/rust/kernel/miscdevice.rs b/rust/kernel/miscdevice.rs
> index 939278bc7b03..288f40e79906 100644
> --- a/rust/kernel/miscdevice.rs
> +++ b/rust/kernel/miscdevice.rs
> @@ -34,7 +34,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 ffi::c_int;
>          result.name = self.name.as_char_ptr();
>          result.fops = MiscdeviceVTable::<T>::build();
>          result
> diff --git a/rust/kernel/mm/virt.rs b/rust/kernel/mm/virt.rs
> index 31803674aecc..6086ca981b06 100644
> --- a/rust/kernel/mm/virt.rs
> +++ b/rust/kernel/mm/virt.rs
> @@ -392,80 +392,80 @@ pub mod flags {
>      use crate::bindings;
>
>      /// No flags are set.
> -    pub const NONE: vm_flags_t = bindings::VM_NONE as _;
> +    pub const NONE: vm_flags_t = bindings::VM_NONE as vm_flags_t;
>
>      /// Mapping allows reads.
> -    pub const READ: vm_flags_t = bindings::VM_READ as _;
> +    pub const READ: vm_flags_t = bindings::VM_READ as vm_flags_t;
>
>      /// Mapping allows writes.
> -    pub const WRITE: vm_flags_t = bindings::VM_WRITE as _;
> +    pub const WRITE: vm_flags_t = bindings::VM_WRITE as vm_flags_t;
>
>      /// Mapping allows execution.
> -    pub const EXEC: vm_flags_t = bindings::VM_EXEC as _;
> +    pub const EXEC: vm_flags_t = bindings::VM_EXEC as vm_flags_t;
>
>      /// Mapping is shared.
> -    pub const SHARED: vm_flags_t = bindings::VM_SHARED as _;
> +    pub const SHARED: vm_flags_t = bindings::VM_SHARED as vm_flags_t;
>
>      /// Mapping may be updated to allow reads.
> -    pub const MAYREAD: vm_flags_t = bindings::VM_MAYREAD as _;
> +    pub const MAYREAD: vm_flags_t = bindings::VM_MAYREAD as vm_flags_t;
>
>      /// Mapping may be updated to allow writes.
> -    pub const MAYWRITE: vm_flags_t = bindings::VM_MAYWRITE as _;
> +    pub const MAYWRITE: vm_flags_t = bindings::VM_MAYWRITE as vm_flags_t;
>
>      /// Mapping may be updated to allow execution.
> -    pub const MAYEXEC: vm_flags_t = bindings::VM_MAYEXEC as _;
> +    pub const MAYEXEC: vm_flags_t = bindings::VM_MAYEXEC as vm_flags_t;
>
>      /// Mapping may be updated to be shared.
> -    pub const MAYSHARE: vm_flags_t = bindings::VM_MAYSHARE as _;
> +    pub const MAYSHARE: vm_flags_t = bindings::VM_MAYSHARE as vm_flags_t;
>
>      /// Page-ranges managed without `struct page`, just pure PFN.
> -    pub const PFNMAP: vm_flags_t = bindings::VM_PFNMAP as _;
> +    pub const PFNMAP: vm_flags_t = bindings::VM_PFNMAP as vm_flags_t;
>
>      /// Memory mapped I/O or similar.
> -    pub const IO: vm_flags_t = bindings::VM_IO as _;
> +    pub const IO: vm_flags_t = bindings::VM_IO as vm_flags_t;
>
>      /// Do not copy this vma on fork.
> -    pub const DONTCOPY: vm_flags_t = bindings::VM_DONTCOPY as _;
> +    pub const DONTCOPY: vm_flags_t = bindings::VM_DONTCOPY as vm_flags_t;
>
>      /// Cannot expand with mremap().
> -    pub const DONTEXPAND: vm_flags_t = bindings::VM_DONTEXPAND as _;
> +    pub const DONTEXPAND: vm_flags_t = bindings::VM_DONTEXPAND as vm_flags_t;
>
>      /// Lock the pages covered when they are faulted in.
> -    pub const LOCKONFAULT: vm_flags_t = bindings::VM_LOCKONFAULT as _;
> +    pub const LOCKONFAULT: vm_flags_t = bindings::VM_LOCKONFAULT as vm_flags_t;
>
>      /// Is a VM accounted object.
> -    pub const ACCOUNT: vm_flags_t = bindings::VM_ACCOUNT as _;
> +    pub const ACCOUNT: vm_flags_t = bindings::VM_ACCOUNT as vm_flags_t;
>
>      /// Should the VM suppress accounting.
> -    pub const NORESERVE: vm_flags_t = bindings::VM_NORESERVE as _;
> +    pub const NORESERVE: vm_flags_t = bindings::VM_NORESERVE as vm_flags_t;
>
>      /// Huge TLB Page VM.
> -    pub const HUGETLB: vm_flags_t = bindings::VM_HUGETLB as _;
> +    pub const HUGETLB: vm_flags_t = bindings::VM_HUGETLB as vm_flags_t;
>
>      /// Synchronous page faults. (DAX-specific)
> -    pub const SYNC: vm_flags_t = bindings::VM_SYNC as _;
> +    pub const SYNC: vm_flags_t = bindings::VM_SYNC as vm_flags_t;
>
>      /// Architecture-specific flag.
> -    pub const ARCH_1: vm_flags_t = bindings::VM_ARCH_1 as _;
> +    pub const ARCH_1: vm_flags_t = bindings::VM_ARCH_1 as vm_flags_t;
>
>      /// Wipe VMA contents in child on fork.
> -    pub const WIPEONFORK: vm_flags_t = bindings::VM_WIPEONFORK as _;
> +    pub const WIPEONFORK: vm_flags_t = bindings::VM_WIPEONFORK as vm_flags_t;
>
>      /// Do not include in the core dump.
> -    pub const DONTDUMP: vm_flags_t = bindings::VM_DONTDUMP as _;
> +    pub const DONTDUMP: vm_flags_t = bindings::VM_DONTDUMP as vm_flags_t;
>
>      /// Not soft dirty clean area.
> -    pub const SOFTDIRTY: vm_flags_t = bindings::VM_SOFTDIRTY as _;
> +    pub const SOFTDIRTY: vm_flags_t = bindings::VM_SOFTDIRTY as vm_flags_t;
>
>      /// Can contain `struct page` and pure PFN pages.
> -    pub const MIXEDMAP: vm_flags_t = bindings::VM_MIXEDMAP as _;
> +    pub const MIXEDMAP: vm_flags_t = bindings::VM_MIXEDMAP as vm_flags_t;
>
>      /// MADV_HUGEPAGE marked this vma.
> -    pub const HUGEPAGE: vm_flags_t = bindings::VM_HUGEPAGE as _;
> +    pub const HUGEPAGE: vm_flags_t = bindings::VM_HUGEPAGE as vm_flags_t;
>
>      /// MADV_NOHUGEPAGE marked this vma.
> -    pub const NOHUGEPAGE: vm_flags_t = bindings::VM_NOHUGEPAGE as _;
> +    pub const NOHUGEPAGE: vm_flags_t = bindings::VM_NOHUGEPAGE as vm_flags_t;
>
>      /// KSM may merge identical pages.
> -    pub const MERGEABLE: vm_flags_t = bindings::VM_MERGEABLE as _;
> +    pub const MERGEABLE: vm_flags_t = bindings::VM_MERGEABLE as vm_flags_t;
>  }
> diff --git a/rust/kernel/of.rs b/rust/kernel/of.rs
> index 04f2d8ef29cb..40d1bd13682c 100644
> --- a/rust/kernel/of.rs
> +++ b/rust/kernel/of.rs
> @@ -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.data as _
> +        self.0.data as 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;
>          }
>
> diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
> index 33ae0bdc433d..f6b19764ad17 100644
> --- a/rust/kernel/pci.rs
> +++ b/rust/kernel/pci.rs
> @@ -171,7 +171,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_data as _
> +        self.0.driver_data
>      }
>  }
>
> @@ -206,7 +206,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),
> +///             (),
> +///         )
>  ///     ]
>  /// );
>  ///
> @@ -330,7 +333,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(), ioptr as _);
> +            bindings::pci_iounmap(pdev.as_raw(), ioptr as *mut kernel::ffi::c_void);
>              bindings::pci_release_region(pdev.as_raw(), num);
>          }
>      }
> diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs
> index 6a3cb607b332..43597eb7c5c1 100644
> --- a/rust/kernel/str.rs
> +++ b/rust/kernel/str.rs
> @@ -728,9 +728,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: pos as _,
> -            pos: pos as _,
> -            end: end as _,
> +            beg: pos as usize,
> +            pos: pos as usize,
> +            end: end as usize,
>          }
>      }
>
> @@ -755,7 +755,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.pos as _
> +        self.pos as *mut u8
>      }
>
>      /// Returns the number of bytes written to the formatter.
> diff --git a/rust/kernel/workqueue.rs b/rust/kernel/workqueue.rs
> index de61374e36bd..89e5c2560eec 100644
> --- a/rust/kernel/workqueue.rs
> +++ b/rust/kernel/workqueue.rs
> @@ -198,7 +198,7 @@ pub fn enqueue<W, const ID: u64>(&self, w: W) -> W::EnqueueOutput
>          unsafe {
>              w.__enqueue(move |work_ptr| {
>                  bindings::queue_work_on(
> -                    bindings::wq_misc_consts_WORK_CPU_UNBOUND as _,
> +                    bindings::wq_misc_consts_WORK_CPU_UNBOUND as ffi::c_int,
>                      queue_ptr,
>                      work_ptr,
>                  )
>
> --
> 2.49.0
>