yarr_common/
lib.rs

1#![no_std]
2
3pub mod process;
4
5pub mod spin_lock {
6
7    use core::cell::UnsafeCell;
8    use core::ops::{Deref, DerefMut, Drop};
9    use core::sync::atomic::{AtomicBool, Ordering};
10
11    #[derive(Debug)]
12    pub struct Mutex<T> {
13        lock: AtomicBool,
14        inner: UnsafeCell<T>,
15    }
16
17    #[derive(Debug)]
18    pub struct MutexGuard<'a, T>
19    where
20        T: 'a,
21    {
22        mutex: &'a Mutex<T>,
23    }
24
25    #[derive(Debug)]
26    pub struct MutexErr<'a>(&'a str);
27
28    impl<T> Mutex<T> {
29        pub const fn new(value: T) -> Mutex<T> {
30            Mutex {
31                lock: AtomicBool::new(false),
32                inner: UnsafeCell::new(value),
33            }
34        }
35
36        pub fn try_lock(&self) -> Result<MutexGuard<T>, MutexErr> {
37            if !self.lock.swap(true, Ordering::Acquire) {
38                Ok(MutexGuard { mutex: self })
39            } else {
40                Err(MutexErr("lock error"))
41            }
42        }
43
44        pub fn lock(&self) -> MutexGuard<T> {
45            loop {
46                if let Ok(mutex_guard) = self.try_lock() {
47                    return mutex_guard;
48                }
49            }
50        }
51    }
52
53    impl<T> Drop for Mutex<T> {
54        fn drop(&mut self) {
55            unsafe {
56                self.inner.get().drop_in_place();
57            }
58        }
59    }
60
61    unsafe impl<T> Send for Mutex<T> {}
62    unsafe impl<T> Sync for Mutex<T> {}
63
64    impl<T> Drop for MutexGuard<'_, T> {
65        fn drop(&mut self) {
66            let _a = self.mutex.lock.swap(false, Ordering::Release);
67        }
68    }
69
70    impl<T> Deref for MutexGuard<'_, T> {
71        type Target = T;
72        fn deref(&self) -> &Self::Target {
73            unsafe { &*self.mutex.inner.get() }
74        }
75    }
76
77    impl<T> DerefMut for MutexGuard<'_, T> {
78        fn deref_mut(&mut self) -> &mut Self::Target {
79            unsafe { &mut *self.mutex.inner.get() }
80        }
81    }
82}