sel4_async_unsync/
mutex.rs

1//
2// Copyright 2023, Colias Group, LLC
3//
4// SPDX-License-Identifier: BSD-2-Clause
5//
6
7use core::cell::{RefCell, RefMut};
8use core::ops::{Deref, DerefMut};
9
10use async_unsync::semaphore::{Permit, Semaphore};
11
12pub struct Mutex<T> {
13    data: RefCell<T>, // remove need for unsafe
14    semaphore: Semaphore,
15}
16
17impl<T> Mutex<T> {
18    pub const fn new(data: T) -> Self {
19        Self {
20            data: RefCell::new(data),
21            semaphore: Semaphore::new(1),
22        }
23    }
24
25    pub async fn lock(&self) -> Guard<'_, T> {
26        let permit = self.semaphore.acquire().await.unwrap();
27        let ref_mut = self.data.borrow_mut();
28        Guard {
29            ref_mut,
30            _permit: permit,
31        }
32    }
33}
34
35unsafe impl<T: Send> Send for Mutex<T> {}
36unsafe impl<T: Send> Sync for Mutex<T> {}
37
38pub struct Guard<'a, T> {
39    // order matters, for drop order
40    ref_mut: RefMut<'a, T>,
41    _permit: Permit<'a>,
42}
43
44impl<T> Deref for Guard<'_, T> {
45    type Target = T;
46
47    fn deref(&self) -> &Self::Target {
48        &self.ref_mut
49    }
50}
51
52impl<T> DerefMut for Guard<'_, T> {
53    fn deref_mut(&mut self) -> &mut Self::Target {
54        &mut self.ref_mut
55    }
56}