binder: replace Arc<Context> with Ref<Context>.

drivers/android/context.rs

@@ -2,9 +2,12 @@
 
 extern crate alloc;
 
-use alloc::sync::Arc;
-use core::pin::Pin;
-use kernel::{bindings, prelude::*, sync::Mutex, Error};
+use kernel::{
+    bindings,
+    prelude::*,
+    sync::{Mutex, Ref},
+    Error,
+};
 
 use crate::{
     node::NodeRef,
@@ -24,24 +27,23 @@ unsafe impl Send for Context {}
 unsafe impl Sync for Context {}
 
 impl Context {
-    pub(crate) fn new() -> Result<Pin<Arc<Self>>> {
-        let mut ctx_ref = Arc::try_new(Self {
-            // SAFETY: Init is called below.
-            manager: unsafe {
-                Mutex::new(Manager {
-                    node: None,
-                    uid: None,
-                })
+    pub(crate) fn new() -> Result<Ref<Self>> {
+        Ref::try_new_and_init(
+            Self {
+                // SAFETY: Init is called below.
+                manager: unsafe {
+                    Mutex::new(Manager {
+                        node: None,
+                        uid: None,
+                    })
+                },
             },
-        })?;
-        let ctx = Arc::get_mut(&mut ctx_ref).unwrap();
-
-        // SAFETY: `manager` is also pinned when `ctx` is.
-        let manager = unsafe { Pin::new_unchecked(&mut ctx.manager) };
-        kernel::mutex_init!(manager, "Context::manager");
-
-        // SAFETY: `ctx_ref` is pinned behind the `Arc` reference.
-        Ok(unsafe { Pin::new_unchecked(ctx_ref) })
+            |mut ctx| {
+                // SAFETY: `manager` is also pinned when `ctx` is.
+                let manager = unsafe { ctx.as_mut().map_unchecked_mut(|c| &mut c.manager) };
+                kernel::mutex_init!(manager, "Context::manager");
+            },
+        )
     }
 
     pub(crate) fn set_manager_node(&self, node_ref: NodeRef) -> Result {

drivers/android/process.rs

@@ -274,7 +274,7 @@ impl ProcessNodeRefs {
 }
 
 pub(crate) struct Process {
-    ctx: Arc<Context>,
+    ctx: Ref<Context>,
 
     // TODO: For now this a mutex because we have allocations in BTreeMap and RangeAllocator while
     // holding the lock. We may want to split up the process state at some point to use a spin lock
@@ -291,8 +291,8 @@ unsafe impl Send for Process {}
 unsafe impl Sync for Process {}
 
 impl Process {
-    fn new(ctx: Arc<Context>) -> Result<Ref<Self>> {
-        Ref::try_new_and_init(
+    fn new(ctx: Ref<Context>) -> Result<Pin<Ref<Self>>> {
+        Ok(Ref::pinned(Ref::try_new_and_init(
             Self {
                 ctx,
                 // SAFETY: `inner` is initialised in the call to `mutex_init` below.
@@ -308,7 +308,7 @@ impl Process {
                 let pinned = unsafe { process.as_mut().map_unchecked_mut(|p| &mut p.node_refs) };
                 kernel::mutex_init!(pinned, "Process::node_refs");
             },
-        )
+        )?))
     }
 
     /// Attemps to fetch a work item from the process queue.
@@ -808,11 +808,9 @@ impl IoctlHandler for Process {
     }
 }
 
-impl FileOpener<Arc<Context>> for Process {
-    fn open(ctx: &Arc<Context>) -> Result<Self::Wrapper> {
-        let process = Self::new(ctx.clone())?;
-        // SAFETY: Pointer is pinned behind `Ref`.
-        Ok(unsafe { Pin::new_unchecked(process) })
+impl FileOpener<Ref<Context>> for Process {
+    fn open(ctx: &Ref<Context>) -> Result<Self::Wrapper> {
+        Self::new(ctx.clone())
     }
 }
 

drivers/android/rust_binder.rs

@@ -15,6 +15,7 @@ use kernel::{
     linked_list::{GetLinks, GetLinksWrapped, Links},
     miscdev::Registration,
     prelude::*,
+    sync::Ref,
     user_ptr::UserSlicePtrWriter,
 };
 
@@ -103,18 +104,13 @@ const fn ptr_align(value: usize) -> usize {
 unsafe impl Sync for BinderModule {}
 
 struct BinderModule {
-    _reg: Pin<Box<Registration<Arc<Context>>>>,
+    _reg: Pin<Box<Registration<Ref<Context>>>>,
 }
 
 impl KernelModule for BinderModule {
     fn init() -> Result<Self> {
-        let pinned_ctx = Context::new()?;
-        let ctx = unsafe { Pin::into_inner_unchecked(pinned_ctx) };
-        let reg = Registration::<Arc<Context>>::new_pinned::<process::Process>(
-            c_str!("rust_binder"),
-            None,
-            ctx,
-        )?;
+        let ctx = Context::new()?;
+        let reg = Registration::new_pinned::<process::Process>(c_str!("rust_binder"), None, ctx)?;
         Ok(Self { _reg: reg })
     }
 }