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