rust: remove Arc from rust samples.

Signed-off-by: Wedson Almeida Filho <[email protected]>

Author: wedsonaf

samples/rust/rust_miscdev.rs

@@ -5,7 +5,7 @@
 #![no_std]
 #![feature(allocator_api, global_asm)]
 
-use alloc::{boxed::Box, sync::Arc};
+use alloc::boxed::Box;
 use core::pin::Pin;
 use kernel::prelude::*;
 use kernel::{
@@ -14,7 +14,7 @@ use kernel::{
     file_operations::{FileOpener, FileOperations},
     io_buffer::{IoBufferReader, IoBufferWriter},
     miscdev,
-    sync::{CondVar, Mutex},
+    sync::{CondVar, Mutex, Ref},
     Error,
 };
 
@@ -38,38 +38,41 @@ struct SharedState {
 }
 
 impl SharedState {
-    fn try_new() -> Result<Pin<Arc<Self>>> {
-        let state = Arc::try_pin(Self {
-            // SAFETY: `condvar_init!` is called below.
-            state_changed: unsafe { CondVar::new() },
-            // SAFETY: `mutex_init!` is called below.
-            inner: unsafe { Mutex::new(SharedStateInner { token_count: 0 }) },
-        })?;
-        // SAFETY: `state_changed` is pinned behind `Pin<Arc>`.
-        let state_changed = unsafe { Pin::new_unchecked(&state.state_changed) };
-        kernel::condvar_init!(state_changed, "SharedState::state_changed");
-        // SAFETY: `inner` is pinned behind `Pin<Arc>`.
-        let inner = unsafe { Pin::new_unchecked(&state.inner) };
-        kernel::mutex_init!(inner, "SharedState::inner");
-        Ok(state)
+    fn try_new() -> Result<Pin<Ref<Self>>> {
+        Ok(Ref::pinned(Ref::try_new_and_init(
+            Self {
+                // SAFETY: `condvar_init!` is called below.
+                state_changed: unsafe { CondVar::new() },
+                // SAFETY: `mutex_init!` is called below.
+                inner: unsafe { Mutex::new(SharedStateInner { token_count: 0 }) },
+            },
+            |state| {
+                // SAFETY: `state_changed` is pinned when `state` is.
+                let state_changed = unsafe { Pin::new_unchecked(&state.state_changed) };
+                kernel::condvar_init!(state_changed, "SharedState::state_changed");
+                // SAFETY: `inner` is pinned when `state` is.
+                let inner = unsafe { Pin::new_unchecked(&state.inner) };
+                kernel::mutex_init!(inner, "SharedState::inner");
+            },
+        )?))
     }
 }
 
 struct Token;
 
-impl FileOpener<Pin<Arc<SharedState>>> for Token {
-    fn open(shared: &Pin<Arc<SharedState>>) -> Result<Self::Wrapper> {
+impl FileOpener<Pin<Ref<SharedState>>> for Token {
+    fn open(shared: &Pin<Ref<SharedState>>) -> Result<Self::Wrapper> {
         Ok(shared.clone())
     }
 }
 
 impl FileOperations for Token {
-    type Wrapper = Pin<Arc<SharedState>>;
+    type Wrapper = Pin<Ref<SharedState>>;
 
     kernel::declare_file_operations!(read, write);
 
     fn read<T: IoBufferWriter>(
-        shared: &SharedState,
+        shared: &Ref<SharedState>,
         _: &File,
         data: &mut T,
         offset: u64,
@@ -102,10 +105,10 @@ impl FileOperations for Token {
     }
 
     fn write<T: IoBufferReader>(
-        shared: &SharedState,
+        shared: &Ref<SharedState>,
         _: &File,
         data: &mut T,
-        _offs: u64,
+        _offset: u64,
     ) -> Result<usize> {
         {
             let mut inner = shared.inner.lock();
@@ -128,7 +131,7 @@ impl FileOperations for Token {
 }
 
 struct RustMiscdev {
-    _dev: Pin<Box<miscdev::Registration<Pin<Arc<SharedState>>>>>,
+    _dev: Pin<Box<miscdev::Registration<Pin<Ref<SharedState>>>>>,
 }
 
 impl KernelModule for RustMiscdev {

samples/rust/rust_semaphore.rs

@@ -16,7 +16,7 @@
 #![no_std]
 #![feature(allocator_api, global_asm)]
 
-use alloc::{boxed::Box, sync::Arc};
+use alloc::boxed::Box;
 use core::{
     pin::Pin,
     sync::atomic::{AtomicU64, Ordering},
@@ -29,7 +29,7 @@ use kernel::{
     miscdev::Registration,
     mutex_init,
     prelude::*,
-    sync::{CondVar, Mutex},
+    sync::{CondVar, Mutex, Ref},
     user_ptr::{UserSlicePtrReader, UserSlicePtrWriter},
     Error,
 };
@@ -54,7 +54,7 @@ struct Semaphore {
 
 struct FileState {
     read_count: AtomicU64,
-    shared: Arc<Semaphore>,
+    shared: Ref<Semaphore>,
 }
 
 impl FileState {
@@ -70,8 +70,8 @@ impl FileState {
     }
 }
 
-impl FileOpener<Arc<Semaphore>> for FileState {
-    fn open(shared: &Arc<Semaphore>) -> Result<Box<Self>> {
+impl FileOpener<Ref<Semaphore>> for FileState {
+    fn open(shared: &Ref<Semaphore>) -> Result<Box<Self>> {
         Ok(Box::try_new(Self {
             read_count: AtomicU64::new(0),
             shared: shared.clone(),
@@ -111,31 +111,34 @@ impl FileOperations for FileState {
 }
 
 struct RustSemaphore {
-    _dev: Pin<Box<Registration<Arc<Semaphore>>>>,
+    _dev: Pin<Box<Registration<Ref<Semaphore>>>>,
 }
 
 impl KernelModule for RustSemaphore {
     fn init() -> Result<Self> {
         pr_info!("Rust semaphore sample (init)\n");
 
-        let sema = Arc::try_new(Semaphore {
-            // SAFETY: `condvar_init!` is called below.
-            changed: unsafe { CondVar::new() },
-
-            // SAFETY: `mutex_init!` is called below.
-            inner: unsafe {
-                Mutex::new(SemaphoreInner {
-                    count: 0,
-                    max_seen: 0,
-                })
+        let sema = Ref::try_new_and_init(
+            Semaphore {
+                // SAFETY: `condvar_init!` is called below.
+                changed: unsafe { CondVar::new() },
+
+                // SAFETY: `mutex_init!` is called below.
+                inner: unsafe {
+                    Mutex::new(SemaphoreInner {
+                        count: 0,
+                        max_seen: 0,
+                    })
+                },
             },
-        })?;
-
-        // SAFETY: `changed` is pinned behind `Arc`.
-        condvar_init!(Pin::new_unchecked(&sema.changed), "Semaphore::changed");
+            |sema| {
+                // SAFETY: `changed` is pinned when `sema` is.
+                condvar_init!(Pin::new_unchecked(&sema.changed), "Semaphore::changed");
 
-        // SAFETY: `inner` is pinned behind `Arc`.
-        mutex_init!(Pin::new_unchecked(&sema.inner), "Semaphore::inner");
+                // SAFETY: `inner` is pinned when `sema` is.
+                mutex_init!(Pin::new_unchecked(&sema.inner), "Semaphore::inner");
+            },
+        )?;
 
         Ok(Self {
             _dev: Registration::new_pinned::<FileState>(c_str!("rust_semaphore"), None, sema)?,