mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2026-08-28 19:14:35 -04:00
e9217e9776
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`.
Several inferred conversions from `binder_uintptr_t` to the driver's
internal `u64` node identifiers are identity conversions. Although the
UAPI header retains `BINDER_IPC_32BIT` for userspace building against
older kernels, commit 1190b4e38f ("ANDROID: binder: remove 32-bit
binder interface.") removed kernel support for selecting that protocol.
Rust Binder therefore uses the 64-bit Binder protocol on every supported
architecture.
While this does not 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 in the Binder Rust driver -- no functional
change intended.
Link: https://rust-lang.github.io/rust-clippy/master/index.html#as_underscore [1]
Assisted-by: Codex:gpt-5
Signed-off-by: Tamir Duberstein <tamird@kernel.org>
Reviewed-by: Alice Ryhl <aliceryhl@google.com>
Link: https://patch.msgid.link/20260526-binder-strict-provenance-v2-4-a41d89c29bc5@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
79 lines
2.0 KiB
Rust
79 lines
2.0 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
// Copyright (C) 2025 Google LLC.
|
|
|
|
use kernel::{list::ListArc, prelude::*, seq_file::SeqFile, seq_print, sync::UniqueArc};
|
|
|
|
use crate::{node::Node, thread::Thread, BinderReturnWriter, DArc, DLArc, DTRWrap, DeliverToRead};
|
|
|
|
use core::mem::MaybeUninit;
|
|
|
|
pub(crate) struct CritIncrWrapper {
|
|
inner: UniqueArc<MaybeUninit<DTRWrap<NodeWrapper>>>,
|
|
}
|
|
|
|
impl CritIncrWrapper {
|
|
pub(crate) fn new() -> Result<Self> {
|
|
Ok(CritIncrWrapper {
|
|
inner: UniqueArc::new_uninit(GFP_KERNEL)?,
|
|
})
|
|
}
|
|
|
|
pub(super) fn init(self, node: DArc<Node>) -> DLArc<dyn DeliverToRead> {
|
|
match self.inner.pin_init_with(DTRWrap::new(NodeWrapper { node })) {
|
|
Ok(initialized) => ListArc::from(initialized) as DLArc<dyn DeliverToRead>,
|
|
Err(err) => match err {},
|
|
}
|
|
}
|
|
}
|
|
|
|
struct NodeWrapper {
|
|
node: DArc<Node>,
|
|
}
|
|
|
|
kernel::list::impl_list_arc_safe! {
|
|
impl ListArcSafe<0> for NodeWrapper {
|
|
untracked;
|
|
}
|
|
}
|
|
|
|
impl DeliverToRead for NodeWrapper {
|
|
fn do_work(
|
|
self: DArc<Self>,
|
|
_thread: &Thread,
|
|
writer: &mut BinderReturnWriter<'_>,
|
|
) -> Result<bool> {
|
|
let node = &self.node;
|
|
let mut owner_inner = node.owner.inner.lock();
|
|
let inner = node.inner.access_mut(&mut owner_inner);
|
|
|
|
let ds = &mut inner.delivery_state;
|
|
|
|
assert!(ds.has_pushed_wrapper);
|
|
assert!(ds.has_strong_zero2one);
|
|
ds.has_pushed_wrapper = false;
|
|
ds.has_strong_zero2one = false;
|
|
|
|
node.do_work_locked(writer, owner_inner)
|
|
}
|
|
|
|
fn cancel(self: DArc<Self>) {}
|
|
|
|
fn should_sync_wakeup(&self) -> bool {
|
|
false
|
|
}
|
|
|
|
#[inline(never)]
|
|
fn debug_print(&self, m: &SeqFile, prefix: &str, _tprefix: &str) -> Result<()> {
|
|
seq_print!(
|
|
m,
|
|
"{}node work {}: u{:016x} c{:016x}\n",
|
|
prefix,
|
|
self.node.debug_id,
|
|
self.node.ptr,
|
|
self.node.cookie,
|
|
);
|
|
Ok(())
|
|
}
|
|
}
|