1 #![allow(dead_code)] 2 use core::cell::UnsafeCell; 3 use core::ops::{Deref, DerefMut}; 4 use core::ptr::read_volatile; 5 6 use core::sync::atomic::{AtomicBool, Ordering}; 7 8 use crate::arch::asm::irqflags::{local_irq_restore, local_irq_save}; 9 use crate::arch::interrupt::{cli, sti}; 10 use crate::include::bindings::bindings::{spin_lock, spin_unlock, spinlock_t}; 11 use crate::process::preempt::{preempt_disable, preempt_enable}; 12 13 /// @brief 保存中断状态到flags中，关闭中断，并对自旋锁加锁 14 #[inline] 15 pub fn spin_lock_irqsave(lock: *mut spinlock_t, flags: &mut u64) { 16 local_irq_save(flags); 17 unsafe { 18 spin_lock(lock); 19 } 20 } 21 22 /// @brief 恢复rflags以及中断状态并解锁自旋锁 23 #[inline] 24 pub fn spin_unlock_irqrestore(lock: *mut spinlock_t, flags: &u64) { 25 unsafe { 26 spin_unlock(lock); 27 } 28 // kdebug!("123"); 29 local_irq_restore(flags); 30 } 31 32 /// 判断一个自旋锁是否已经被加锁 33 #[inline] 34 pub fn spin_is_locked(lock: &spinlock_t) -> bool { 35 let val = unsafe { read_volatile(&lock.lock as *const i8) }; 36 37 return if val == 0 { true } else { false }; 38 } 39 40 impl Default for spinlock_t { 41 fn default() -> Self { 42 Self { lock: 1 } 43 } 44 } 45 46 /// @brief 关闭中断并加锁 47 pub fn spin_lock_irq(lock: *mut spinlock_t) { 48 cli(); 49 unsafe { 50 spin_lock(lock); 51 } 52 } 53 54 /// @brief 解锁并开中断 55 pub fn spin_unlock_irq(lock: *mut spinlock_t) { 56 unsafe { 57 spin_unlock(lock); 58 } 59 sti(); 60 } 61 62 /// 原始的Spinlock（自旋锁） 63 /// 请注意，这个自旋锁和C的不兼容。 64 /// 65 /// @param self.0 这个AtomicBool的值为false时，表示没有被加锁。当它为true时，表示自旋锁已经被上锁。 66 #[derive(Debug)] 67 pub struct RawSpinlock(AtomicBool); 68 69 impl RawSpinlock { 70 /// @brief 初始化自旋锁 71 pub const INIT: RawSpinlock = RawSpinlock(AtomicBool::new(false)); 72 73 /// @brief 加锁 74 pub fn lock(&self) { 75 while !self.try_lock() {} 76 } 77 78 /// @brief 关中断并加锁 79 pub fn lock_irq(&self) { 80 cli(); 81 self.lock(); 82 } 83 84 /// @brief 尝试加锁 85 /// @return 加锁成功->true 86 /// 加锁失败->false 87 pub fn try_lock(&self) -> bool { 88 // 先增加自旋锁持有计数 89 preempt_disable(); 90 91 let res = self 92 .0 93 .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) 94 .is_ok(); 95 96 // 如果加锁失败恢复自旋锁持有计数 97 if res == false { 98 preempt_enable(); 99 } 100 return res; 101 } 102 103 /// @brief 解锁 104 pub fn unlock(&self) { 105 // 减少自旋锁持有计数 106 preempt_enable(); 107 self.0.store(false, Ordering::Release); 108 } 109 110 /// @brief 放锁并开中断 111 pub fn unlock_irq(&self) { 112 self.unlock(); 113 sti(); 114 } 115 116 /// @brief 判断自旋锁是否被上锁 117 /// 118 /// @return true 自旋锁被上锁 119 /// @return false 自旋锁处于解锁状态 120 pub fn is_locked(&self) -> bool { 121 return self.0.load(Ordering::Relaxed).into(); 122 } 123 124 /// @brief 强制设置自旋锁的状态 125 /// 请注意，这样操作可能会带来未知的风险。因此它是unsafe的。（尽管从Rust语言本身来说，它是safe的） 126 pub unsafe fn set_value(&mut self, value: bool) { 127 self.0.store(value, Ordering::SeqCst); 128 } 129 130 // todo: spin_lock_irqsave 131 // todo: spin_unlock_irqrestore 132 } 133 134 /// 实现了守卫的SpinLock, 能够支持内部可变性 135 /// 136 #[derive(Debug)] 137 pub struct SpinLock<T> { 138 lock: RawSpinlock, 139 /// 自旋锁保护的数据 140 data: UnsafeCell<T>, 141 } 142 143 /// SpinLock的守卫 144 /// 该守卫没有构造器，并且其信息均为私有的。我们只能通过SpinLock的lock()方法获得一个守卫。 145 /// 因此我们可以认为，只要能够获得一个守卫，那么数据就在自旋锁的保护之下。 146 #[derive(Debug)] 147 pub struct SpinLockGuard<'a, T: 'a> { 148 lock: &'a SpinLock<T>, 149 } 150 151 /// 向编译器保证，SpinLock在线程之间是安全的. 152 /// 其中要求类型T实现了Send这个Trait 153 unsafe impl<T> Sync for SpinLock<T> where T: Send {} 154 155 impl<T> SpinLock<T> { 156 pub const fn new(value: T) -> Self { 157 return Self { 158 lock: RawSpinlock::INIT, 159 data: UnsafeCell::new(value), 160 }; 161 } 162 163 #[inline(always)] 164 pub fn lock(&self) -> SpinLockGuard<T> { 165 self.lock.lock(); 166 // 加锁成功，返回一个守卫 167 return SpinLockGuard { lock: self }; 168 } 169 } 170 171 /// 实现Deref trait，支持通过获取SpinLockGuard来获取临界区数据的不可变引用 172 impl<T> Deref for SpinLockGuard<'_, T> { 173 type Target = T; 174 175 fn deref(&self) -> &Self::Target { 176 return unsafe { &*self.lock.data.get() }; 177 } 178 } 179 180 /// 实现DerefMut trait，支持通过获取SpinLockGuard来获取临界区数据的可变引用 181 impl<T> DerefMut for SpinLockGuard<'_, T> { 182 fn deref_mut(&mut self) -> &mut Self::Target { 183 return unsafe { &mut *self.lock.data.get() }; 184 } 185 } 186 187 /// @brief 为SpinLockGuard实现Drop方法，那么，一旦守卫的生命周期结束，就会自动释放自旋锁，避免了忘记放锁的情况 188 impl<T> Drop for SpinLockGuard<'_, T> { 189 fn drop(&mut self) { 190 self.lock.lock.unlock(); 191 } 192 } 193