freertos_rust/
critical.rs

1use crate::base::*;
2use crate::prelude::v1::*;
3use crate::shim::*;
4
5pub struct CriticalRegion;
6impl CriticalRegion {
7    pub fn enter() -> Self {
8        unsafe {
9            freertos_rs_enter_critical();
10        }
11
12        CriticalRegion
13    }
14}
15
16impl Drop for CriticalRegion {
17    fn drop(&mut self) {
18        unsafe {
19            freertos_rs_exit_critical();
20        }
21    }
22}
23
24unsafe impl<T: Send> Send for ExclusiveData<T> {}
25unsafe impl<T: Send> Sync for ExclusiveData<T> {}
26
27/// Data protected with a critical region. Lightweight version of a mutex,
28/// intended for simple data structures.
29pub struct ExclusiveData<T: ?Sized> {
30    data: UnsafeCell<T>,
31}
32
33impl<T> ExclusiveData<T> {
34    pub fn new(data: T) -> Self {
35        ExclusiveData {
36            data: UnsafeCell::new(data),
37        }
38    }
39
40    pub fn lock(&self) -> Result<ExclusiveDataGuard<'_, T>, FreeRtosError> {
41        Ok(ExclusiveDataGuard {
42            __data: &self.data,
43            __lock: CriticalRegion::enter(),
44        })
45    }
46
47    pub fn lock_from_isr(
48        &self,
49        _context: &mut crate::isr::InterruptContext,
50    ) -> Result<ExclusiveDataGuardIsr<'_, T>, FreeRtosError> {
51        Ok(ExclusiveDataGuardIsr { __data: &self.data })
52    }
53}
54
55/// Holds the mutex until we are dropped
56pub struct ExclusiveDataGuard<'a, T: ?Sized + 'a> {
57    __data: &'a UnsafeCell<T>,
58    __lock: CriticalRegion,
59}
60
61impl<'mutex, T: ?Sized> Deref for ExclusiveDataGuard<'mutex, T> {
62    type Target = T;
63
64    fn deref<'a>(&'a self) -> &'a T {
65        unsafe { &*self.__data.get() }
66    }
67}
68
69impl<'mutex, T: ?Sized> DerefMut for ExclusiveDataGuard<'mutex, T> {
70    fn deref_mut<'a>(&'a mut self) -> &'a mut T {
71        unsafe { &mut *self.__data.get() }
72    }
73}
74
75pub struct ExclusiveDataGuardIsr<'a, T: ?Sized + 'a> {
76    __data: &'a UnsafeCell<T>,
77}
78
79impl<'mutex, T: ?Sized> Deref for ExclusiveDataGuardIsr<'mutex, T> {
80    type Target = T;
81
82    fn deref<'a>(&'a self) -> &'a T {
83        unsafe { &*self.__data.get() }
84    }
85}
86
87impl<'mutex, T: ?Sized> DerefMut for ExclusiveDataGuardIsr<'mutex, T> {
88    fn deref_mut<'a>(&'a mut self) -> &'a mut T {
89        unsafe { &mut *self.__data.get() }
90    }
91}
92
93unsafe impl<T: Send> Send for SuspendScheduler<T> {}
94unsafe impl<T: Send> Sync for SuspendScheduler<T> {}
95
96/// Data protected with a critical region, implemented by suspending the
97/// FreeRTOS scheduler.
98pub struct SuspendScheduler<T: ?Sized> {
99    data: UnsafeCell<T>,
100}
101
102impl<T> SuspendScheduler<T> {
103    pub const fn new(data: T) -> Self {
104        SuspendScheduler {
105            data: UnsafeCell::new(data),
106        }
107    }
108
109    pub fn lock(&self) -> SuspendSchedulerGuard<'_,T> {
110        unsafe {
111            freertos_rs_vTaskSuspendAll();
112        }
113        SuspendSchedulerGuard { data: &self.data }
114    }
115
116    pub fn get_mut(&mut self) -> &mut T {
117        self.data.get_mut()
118    }
119
120    pub fn into_inner(self) -> T {
121        self.data.into_inner()
122    }
123}
124
125pub struct SuspendSchedulerGuard<'a, T: ?Sized + 'a> {
126    data: &'a UnsafeCell<T>,
127}
128
129impl<'mutex, T: ?Sized> Deref for SuspendSchedulerGuard<'mutex, T> {
130    type Target = T;
131
132    fn deref<'a>(&'a self) -> &'a T {
133        unsafe { &*self.data.get() }
134    }
135}
136
137impl<'mutex, T: ?Sized> DerefMut for SuspendSchedulerGuard<'mutex, T> {
138    fn deref_mut<'a>(&'a mut self) -> &'a mut T {
139        unsafe { &mut *self.data.get() }
140    }
141}
142
143impl<'mutex, T: ?Sized> Drop for SuspendSchedulerGuard<'mutex, T> {
144    fn drop(&mut self) {
145        unsafe {
146            freertos_rs_xTaskResumeAll();
147        }
148    }
149}
freertos_rust/critical.rs

freertos_rust/
critical.rs
