xref: /linux/drivers/android/binder/node/wrapper.rs (revision 7d1f84f1b94e79cb95d974ab3ec54cb3a4d64f5b)
1 // SPDX-License-Identifier: GPL-2.0
2 
3 // Copyright (C) 2025 Google LLC.
4 
5 use kernel::{list::ListArc, prelude::*, seq_file::SeqFile, seq_print, sync::UniqueArc};
6 
7 use crate::{node::Node, thread::Thread, BinderReturnWriter, DArc, DLArc, DTRWrap, DeliverToRead};
8 
9 use core::mem::MaybeUninit;
10 
11 pub(crate) struct CritIncrWrapper {
12     inner: UniqueArc<MaybeUninit<DTRWrap<NodeWrapper>>>,
13 }
14 
15 impl CritIncrWrapper {
16     pub(crate) fn new() -> Result<Self> {
17         Ok(CritIncrWrapper {
18             inner: UniqueArc::new_uninit(GFP_KERNEL)?,
19         })
20     }
21 
22     pub(super) fn init(self, node: DArc<Node>) -> DLArc<dyn DeliverToRead> {
23         let Ok(initialized) = self.inner.pin_init_with(DTRWrap::new(NodeWrapper { node }));
24         ListArc::from(initialized) as DLArc<dyn DeliverToRead>
25     }
26 }
27 
28 struct NodeWrapper {
29     node: DArc<Node>,
30 }
31 
32 kernel::list::impl_list_arc_safe! {
33     impl ListArcSafe<0> for NodeWrapper {
34         untracked;
35     }
36 }
37 
38 impl DeliverToRead for NodeWrapper {
39     fn do_work(
40         self: DArc<Self>,
41         _thread: &Thread,
42         writer: &mut BinderReturnWriter<'_>,
43     ) -> Result<bool> {
44         let node = &self.node;
45         let mut owner_inner = node.owner.inner.lock();
46         let inner = node.inner.access_mut(&mut owner_inner);
47 
48         let ds = &mut inner.delivery_state;
49 
50         assert!(ds.has_pushed_wrapper);
51         assert!(ds.has_strong_zero2one);
52         ds.has_pushed_wrapper = false;
53         ds.has_strong_zero2one = false;
54 
55         node.do_work_locked(writer, owner_inner)
56     }
57 
58     fn cancel(self: DArc<Self>) {
59         let _drop_outside_lock;
60         let node = &self.node;
61         let mut owner_inner = node.owner.inner.lock();
62 
63         // We only do something on BINDER_THREAD_EXIT, not process exit.
64         if owner_inner.is_dead {
65             return;
66         }
67 
68         // We transfer the responsibility of the node refcount update to the scheduled Node because
69         // NodeWrapper has no way to re-create the ListArc.
70         let inner = node.inner.access_mut(&mut owner_inner);
71 
72         let ds = &mut inner.delivery_state;
73         assert!(ds.has_pushed_wrapper);
74         assert!(ds.has_strong_zero2one);
75         ds.has_pushed_wrapper = false;
76 
77         // We are changing the state to one where the Node is the strong zero2one update instead of
78         // the wrapper.
79         ds.has_weak_zero2one = false;
80 
81         if !ds.has_pushed_node {
82             if let Some(node2) = ListArc::try_from_arc_borrow(node.as_arc_borrow()) {
83                 ds.has_pushed_node = true;
84                 _drop_outside_lock = owner_inner.push_work(&node.owner, node2);
85             } else {
86                 // This can't actually happen.
87                 ds.has_strong_zero2one = false;
88             }
89         }
90     }
91 
92     fn should_sync_wakeup(&self) -> bool {
93         false
94     }
95 
96     #[inline(never)]
97     fn debug_print(&self, m: &SeqFile, prefix: &str, _tprefix: &str) -> Result {
98         seq_print!(
99             m,
100             "{}node work {}: u{:016x} c{:016x}\n",
101             prefix,
102             self.node.debug_id,
103             self.node.ptr,
104             self.node.cookie,
105         );
106         Ok(())
107     }
108 }
109