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}