rust: use new init API for initializing everything

Signed-off-by: Benno Lossin <[email protected]>

Author: y86-dev

drivers/android/context.rs

@@ -2,6 +2,8 @@
 
 use kernel::{
     bindings,
+    macros::pin_data,
+    mutex, pin_init,
     prelude::*,
     security,
     sync::{Arc, Mutex, UniqueArc},
@@ -17,7 +19,9 @@ struct Manager {
     uid: Option<bindings::kuid_t>,
 }
 
+#[pin_data]
 pub(crate) struct Context {
+    #[pin]
     manager: Mutex<Manager>,
 }
 
@@ -27,20 +31,15 @@ unsafe impl Sync for Context {}
 
 impl Context {
     pub(crate) fn new() -> Result<Arc<Self>> {
-        let mut ctx = Pin::from(UniqueArc::try_new(Self {
-            // SAFETY: Init is called below.
-            manager: unsafe {
-                Mutex::new(Manager {
+        let ctx = UniqueArc::pin_init::<core::convert::Infallible>(pin_init!(Self {
+            manager: mutex!(
+                Manager {
                     node: None,
                     uid: None,
-                })
-            },
-        })?);
-
-        // 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");
-
+                },
+                "Contex::manager"
+            ),
+        }))?;
         Ok(ctx.into())
     }
 

drivers/android/node.rs

@@ -2,9 +2,13 @@
 
 use core::sync::atomic::{AtomicU64, Ordering};
 use kernel::{
+    init::PinInit,
     io_buffer::IoBufferWriter,
     linked_list::{GetLinks, Links, List},
+    macros::pin_data,
+    pin_init,
     prelude::*,
+    spinlock,
     sync::{Arc, Guard, LockedBy, Mutex, SpinLock},
     user_ptr::UserSlicePtrWriter,
 };
@@ -54,6 +58,7 @@ struct NodeDeathInner {
     aborted: bool,
 }
 
+#[pin_data]
 pub(crate) struct NodeDeath {
     node: Arc<Node>,
     process: Arc<Process>,
@@ -63,37 +68,30 @@ pub(crate) struct NodeDeath {
     // TODO: Add the moment we're using this for two lists, which isn't safe because we want to
     // remove from the list without knowing the list it's in. We need to separate this out.
     death_links: Links<NodeDeath>,
+    #[pin]
     inner: SpinLock<NodeDeathInner>,
 }
 
 impl NodeDeath {
     /// Constructs a new node death notification object.
-    ///
-    /// # Safety
-    ///
-    /// The caller must call `NodeDeath::init` before using the notification object.
-    pub(crate) unsafe fn new(node: Arc<Node>, process: Arc<Process>, cookie: usize) -> Self {
-        Self {
+    #[allow(clippy::new_ret_no_self)]
+    pub(crate) fn new(node: Arc<Node>, process: Arc<Process>, cookie: usize) -> impl PinInit<Self> {
+        pin_init!(Self {
             node,
             process,
             cookie,
             work_links: Links::new(),
             death_links: Links::new(),
-            inner: unsafe {
-                SpinLock::new(NodeDeathInner {
+            inner: spinlock!(
+                NodeDeathInner {
                     dead: false,
                     cleared: false,
                     notification_done: false,
                     aborted: false,
-                })
-            },
-        }
-    }
-
-    pub(crate) fn init(self: Pin<&mut Self>) {
-        // SAFETY: `inner` is pinned when `self` is.
-        let inner = unsafe { self.map_unchecked_mut(|n| &mut n.inner) };
-        kernel::spinlock_init!(inner, "NodeDeath::inner");
+                },
+                "NodeDeath::inner"
+            ),
+        })
     }
 
     /// Sets the cleared flag to `true`.

drivers/android/process.rs

@@ -7,8 +7,10 @@ use kernel::{
     file::{self, File, IoctlCommand, IoctlHandler, PollTable},
     io_buffer::{IoBufferReader, IoBufferWriter},
     linked_list::List,
-    mm,
+    macros::pin_data,
+    mm, mutex,
     pages::Pages,
+    pin_init,
     prelude::*,
     rbtree::RBTree,
     sync::{Arc, ArcBorrow, Guard, Mutex, UniqueArc},
@@ -241,6 +243,7 @@ impl ProcessNodeRefs {
     }
 }
 
+#[pin_data]
 pub(crate) struct Process {
     ctx: Arc<Context>,
 
@@ -254,10 +257,12 @@ pub(crate) struct Process {
     // lock. We may want to split up the process state at some point to use a spin lock for the
     // other fields.
     // TODO: Make this private again.
+    #[pin]
     pub(crate) inner: Mutex<ProcessInner>,
 
     // References are in a different mutex to avoid recursive acquisition when
     // incrementing/decrementing a node in another process.
+    #[pin]
     node_refs: Mutex<ProcessNodeRefs>,
 }
 
@@ -267,24 +272,13 @@ unsafe impl Sync for Process {}
 
 impl Process {
     fn new(ctx: Arc<Context>, cred: ARef<Credential>) -> Result<Arc<Self>> {
-        let mut process = Pin::from(UniqueArc::try_new(Self {
+        let process = UniqueArc::pin_init::<core::convert::Infallible>(pin_init!(Self {
             ctx,
             cred,
-            task: Task::current().group_leader().into(),
-            // SAFETY: `inner` is initialised in the call to `mutex_init` below.
-            inner: unsafe { Mutex::new(ProcessInner::new()) },
-            // SAFETY: `node_refs` is initialised in the call to `mutex_init` below.
-            node_refs: unsafe { Mutex::new(ProcessNodeRefs::new()) },
-        })?);
-
-        // SAFETY: `inner` is pinned when `Process` is.
-        let pinned = unsafe { process.as_mut().map_unchecked_mut(|p| &mut p.inner) };
-        kernel::mutex_init!(pinned, "Process::inner");
-
-        // SAFETY: `node_refs` is pinned when `Process` is.
-        let pinned = unsafe { process.as_mut().map_unchecked_mut(|p| &mut p.node_refs) };
-        kernel::mutex_init!(pinned, "Process::node_refs");
-
+            task: ARef::from(Task::current().group_leader()),
+            inner: mutex!(ProcessInner::new(), "Process::inner"),
+            node_refs: mutex!(ProcessNodeRefs::new(), "Process::node_refs"),
+        }))?;
         Ok(process.into())
     }
 
@@ -712,14 +706,15 @@ impl Process {
             return Ok(());
         }
 
-        let death = {
-            let mut pinned = Pin::from(death.write(
-                // SAFETY: `init` is called below.
-                unsafe { NodeDeath::new(info.node_ref.node.clone(), self.clone(), cookie) },
-            ));
-            pinned.as_mut().init();
-            Arc::<NodeDeath>::from(pinned)
-        };
+        let death = Arc::<NodeDeath>::from(
+            death
+                .pin_init_now::<core::convert::Infallible>(NodeDeath::new(
+                    info.node_ref.node.clone(),
+                    self.clone(),
+                    cookie,
+                ))
+                .map_err(|(i, _)| i)?,
+        );
 
         info.death = Some(death.clone());
 

drivers/android/thread.rs

@@ -6,12 +6,14 @@ use core::{
     sync::atomic::{AtomicU32, Ordering},
 };
 use kernel::{
-    bindings,
+    bindings, condvar,
     file::{File, PollTable},
     io_buffer::{IoBufferReader, IoBufferWriter},
     linked_list::{GetLinks, Links, List},
+    macros::pin_data,
+    pin_init,
     prelude::*,
-    security,
+    security, spinlock,
     sync::{Arc, CondVar, SpinLock, UniqueArc},
     user_ptr::{UserSlicePtr, UserSlicePtrWriter},
     Either,
@@ -229,10 +231,13 @@ impl InnerThread {
     }
 }
 
+#[pin_data]
 pub(crate) struct Thread {
     pub(crate) id: i32,
     pub(crate) process: Arc<Process>,
+    #[pin]
     inner: SpinLock<InnerThread>,
+    #[pin]
     work_condvar: CondVar,
     links: Links<Thread>,
 }
@@ -241,23 +246,13 @@ impl Thread {
     pub(crate) fn new(id: i32, process: Arc<Process>) -> Result<Arc<Self>> {
         let return_work = Arc::try_new(ThreadError::new(InnerThread::set_return_work))?;
         let reply_work = Arc::try_new(ThreadError::new(InnerThread::set_reply_work))?;
-        let mut thread = Pin::from(UniqueArc::try_new(Self {
+        let thread = UniqueArc::pin_init::<core::convert::Infallible>(pin_init!(Self {
             id,
             process,
-            // SAFETY: `inner` is initialised in the call to `spinlock_init` below.
-            inner: unsafe { SpinLock::new(InnerThread::new()) },
-            // SAFETY: `work_condvar` is initialised in the call to `condvar_init` below.
-            work_condvar: unsafe { CondVar::new() },
+            inner: spinlock!(InnerThread::new(), "Thread::inner"),
+            work_condvar: condvar!("Thread::work_condvar"),
             links: Links::new(),
-        })?);
-
-        // SAFETY: `inner` is pinned when `thread` is.
-        let inner = unsafe { thread.as_mut().map_unchecked_mut(|t| &mut t.inner) };
-        kernel::spinlock_init!(inner, "Thread::inner");
-
-        // SAFETY: `work_condvar` is pinned when `thread` is.
-        let condvar = unsafe { thread.as_mut().map_unchecked_mut(|t| &mut t.work_condvar) };
-        kernel::condvar_init!(condvar, "Thread::work_condvar");
+        }))?;
 
         {
             let mut inner = thread.inner.lock();

drivers/android/transaction.rs

@@ -7,7 +7,10 @@ use kernel::{
     io_buffer::IoBufferWriter,
     linked_list::List,
     linked_list::{GetLinks, Links},
+    macros::pin_data,
+    pin_init,
     prelude::*,
+    spinlock,
     sync::{Arc, SpinLock, UniqueArc},
     user_ptr::UserSlicePtrWriter,
     Either, ScopeGuard,
@@ -26,7 +29,9 @@ struct TransactionInner {
     file_list: List<Box<FileInfo>>,
 }
 
+#[pin_data]
 pub(crate) struct Transaction {
+    #[pin]
     inner: SpinLock<TransactionInner>,
     // TODO: Node should be released when the buffer is released.
     node_ref: Option<NodeRef>,
@@ -55,26 +60,20 @@ impl Transaction {
         let data_address = alloc.ptr;
         let file_list = alloc.take_file_list();
         alloc.keep_alive();
-        let mut tr = Pin::from(UniqueArc::try_new(Self {
-            // SAFETY: `spinlock_init` is called below.
-            inner: unsafe { SpinLock::new(TransactionInner { file_list }) },
+        let tr = UniqueArc::pin_init::<core::convert::Infallible>(pin_init!(Self {
+            inner: spinlock!(TransactionInner { file_list }, "Transaction::inner"),
             node_ref: Some(node_ref),
             stack_next,
             from: from.clone(),
             to,
             code: tr.code,
             flags: tr.flags,
-            data_size: tr.data_size as _,
+            data_size: tr.data_size as usize,
             data_address,
-            offsets_size: tr.offsets_size as _,
+            offsets_size: tr.offsets_size as usize,
             links: Links::new(),
             free_allocation: AtomicBool::new(true),
-        })?);
-
-        // SAFETY: `inner` is pinned when `tr` is.
-        let pinned = unsafe { tr.as_mut().map_unchecked_mut(|t| &mut t.inner) };
-        kernel::spinlock_init!(pinned, "Transaction::inner");
-
+        }))?;
         Ok(tr.into())
     }
 
@@ -88,26 +87,20 @@ impl Transaction {
         let data_address = alloc.ptr;
         let file_list = alloc.take_file_list();
         alloc.keep_alive();
-        let mut tr = Pin::from(UniqueArc::try_new(Self {
-            // SAFETY: `spinlock_init` is called below.
-            inner: unsafe { SpinLock::new(TransactionInner { file_list }) },
+        let tr = UniqueArc::pin_init::<core::convert::Infallible>(pin_init!(Self {
+            inner: spinlock!(TransactionInner { file_list }, "Transaction::inner"),
             node_ref: None,
             stack_next: None,
             from: from.clone(),
             to,
             code: tr.code,
             flags: tr.flags,
-            data_size: tr.data_size as _,
+            data_size: tr.data_size as usize,
             data_address,
-            offsets_size: tr.offsets_size as _,
+            offsets_size: tr.offsets_size as usize,
             links: Links::new(),
             free_allocation: AtomicBool::new(true),
-        })?);
-
-        // SAFETY: `inner` is pinned when `tr` is.
-        let pinned = unsafe { tr.as_mut().map_unchecked_mut(|t| &mut t.inner) };
-        kernel::spinlock_init!(pinned, "Transaction::inner");
-
+        }))?;
         Ok(tr.into())
     }
 

rust/kernel/device.rs

@@ -9,9 +9,12 @@ use crate::{clk::Clk, error::from_kernel_err_ptr};
 
 use crate::{
     bindings,
+    macros::pin_data,
+    pin_init,
+    prelude::*,
     revocable::{Revocable, RevocableGuard},
     str::CStr,
-    sync::{LockClassKey, NeedsLockClass, RevocableMutex, RevocableMutexGuard, UniqueArc},
+    sync::{LockClassKey, RevocableMutex, RevocableMutexGuard, UniqueArc},
     Result,
 };
 use core::{
@@ -230,7 +233,9 @@ impl Drop for Device {
 ///
 /// This struct implements the `DeviceRemoval` trait so that it can clean resources up even if not
 /// explicitly called by the device drivers.
+#[pin_data]
 pub struct Data<T, U, V> {
+    #[pin]
     registrations: RevocableMutex<T>,
     resources: Revocable<U>,
     general: V,
@@ -262,19 +267,12 @@ impl<T, U, V> Data<T, U, V> {
         general: V,
         name: &'static CStr,
         key1: &'static LockClassKey,
-        key2: &'static LockClassKey,
     ) -> Result<Pin<UniqueArc<Self>>> {
-        let mut ret = Pin::from(UniqueArc::try_new(Self {
-            // SAFETY: We call `RevocableMutex::init` below.
-            registrations: unsafe { RevocableMutex::new(registrations) },
+        UniqueArc::pin_init::<core::convert::Infallible>(pin_init!(Self {
+            registrations: RevocableMutex::new(registrations, name, key1),
             resources: Revocable::new(resources),
             general,
-        })?);
-
-        // SAFETY: `Data::registrations` is pinned when `Data` is.
-        let pinned = unsafe { ret.as_mut().map_unchecked_mut(|d| &mut d.registrations) };
-        pinned.init(name, key1, key2);
-        Ok(ret)
+        }))
     }
 
     /// Returns the resources if they're still available.