tg_sync/
up.rs

1use core::cell::{RefCell, RefMut, UnsafeCell};
2use core::ops::{Deref, DerefMut};
3use riscv::register::sstatus;
4use spin::Lazy;
5
6/*
7/// Wrap a static data structure inside it so that we are
8/// able to access it without any `unsafe`.
9///
10/// We should only use it in uniprocessor.
11///
12/// In order to get mutable reference of inner data, call
13/// `exclusive_access`.
14pub struct UPSafeCell<T> {
15    /// inner data
16    inner: RefCell<T>,
17}
18
19unsafe impl<T> Sync for UPSafeCell<T> {}
20
21impl<T> UPSafeCell<T> {
22    /// User is responsible to guarantee that inner struct is only used in
23    /// uniprocessor.
24    pub unsafe fn new(value: T) -> Self {
25        Self {
26            inner: RefCell::new(value),
27        }
28    }
29    /// Panic if the data has been borrowed.
30    pub fn exclusive_access(&self) -> RefMut<'_, T> {
31        self.inner.borrow_mut()
32    }
33}
34*/
35
36/// 单处理器环境下的内部可变性容器（原始版本）。
37///
38/// 这个类型绕过了 Rust 的借用检查，仅适用于单处理器环境。
39pub struct UPSafeCellRaw<T> {
40    inner: UnsafeCell<T>,
41}
42
43// SAFETY: 此类型仅用于单处理器环境，不会发生数据竞争。
44// 使用者需要确保不会在单处理器上产生重入问题。
45unsafe impl<T> Sync for UPSafeCellRaw<T> {}
46
47impl<T> UPSafeCellRaw<T> {
48    /// 创建一个新的 `UPSafeCellRaw`。
49    ///
50    /// # Safety
51    ///
52    /// 调用者必须确保此类型仅在单处理器环境下使用，
53    /// 且不会在持有可变引用时发生重入。
54    pub unsafe fn new(value: T) -> Self {
55        Self {
56            inner: UnsafeCell::new(value),
57        }
58    }
59
60    /// 获取内部值的可变引用。
61    ///
62    /// 注意：此函数不进行借用检查，调用者需要确保不会产生多个可变引用。
63    pub fn get_mut(&self) -> &mut T {
64        // SAFETY: 单处理器环境下，只要调用者确保不重入，就不会产生数据竞争。
65        // 此函数的安全性由 UPSafeCellRaw::new 的 unsafe 约定保证。
66        unsafe { &mut (*self.inner.get()) }
67    }
68}
69
70/// 中断屏蔽信息
71pub struct IntrMaskingInfo {
72    nested_level: usize,
73    sie_before_masking: bool,
74}
75
76/// 全局中断屏蔽信息。
77///
78/// SAFETY: 此静态变量仅在单处理器内核中使用，通过中断屏蔽保证访问安全。
79pub static INTR_MASKING_INFO: Lazy<UPSafeCellRaw<IntrMaskingInfo>> = Lazy::new(|| {
80    // SAFETY: 内核运行在单处理器环境下
81    unsafe { UPSafeCellRaw::new(IntrMaskingInfo::new()) }
82});
83
84impl IntrMaskingInfo {
85    pub fn new() -> Self {
86        Self {
87            nested_level: 0,
88            sie_before_masking: false,
89        }
90    }
91
92    /// 进入中断屏蔽区域。
93    pub fn enter(&mut self) {
94        let sie = sstatus::read().sie();
95        // SAFETY: 清除 sstatus.SIE 位以禁用中断，这是单处理器同步的标准做法
96        unsafe {
97            sstatus::clear_sie();
98        }
99        if self.nested_level == 0 {
100            self.sie_before_masking = sie;
101        }
102        self.nested_level += 1;
103    }
104
105    /// 退出中断屏蔽区域。
106    pub fn exit(&mut self) {
107        self.nested_level -= 1;
108        if self.nested_level == 0 && self.sie_before_masking {
109            // SAFETY: 恢复 sstatus.SIE 位以重新启用中断
110            unsafe {
111                sstatus::set_sie();
112            }
113        }
114    }
115}
116
117/// 带中断屏蔽的内部可变性容器。
118///
119/// 在访问内部数据时自动禁用中断，保证单处理器环境下的数据安全。
120pub struct UPIntrFreeCell<T> {
121    /// inner data
122    inner: RefCell<T>,
123}
124
125// SAFETY: 此类型通过中断屏蔽保证单处理器环境下不会发生数据竞争。
126// RefCell 的动态借用检查会在运行时捕获重入错误。
127unsafe impl<T> Sync for UPIntrFreeCell<T> {}
128
129/// A wrapper type for a mutably borrowed value from a RefCell<T>
130pub struct UPIntrRefMut<'a, T>(Option<RefMut<'a, T>>);
131
132impl<T> UPIntrFreeCell<T> {
133    /// 创建一个新的 `UPIntrFreeCell`。
134    ///
135    /// # Safety
136    ///
137    /// 调用者必须确保此类型仅在单处理器环境下使用。
138    pub unsafe fn new(value: T) -> Self {
139        Self {
140            inner: RefCell::new(value),
141        }
142    }
143
144    /// Panic if the data has been borrowed.
145    pub fn exclusive_access(&self) -> UPIntrRefMut<'_, T> {
146        INTR_MASKING_INFO.get_mut().enter();
147        UPIntrRefMut(Some(self.inner.borrow_mut()))
148    }
149    /// exclusive_session
150    pub fn exclusive_session<F, V>(&self, f: F) -> V
151    where
152        F: FnOnce(&mut T) -> V,
153    {
154        let mut inner = self.exclusive_access();
155        f(inner.deref_mut())
156    }
157}
158
159impl<'a, T> Drop for UPIntrRefMut<'a, T> {
160    fn drop(&mut self) {
161        self.0 = None;
162        INTR_MASKING_INFO.get_mut().exit();
163    }
164}
165
166impl<'a, T> Deref for UPIntrRefMut<'a, T> {
167    type Target = T;
168    fn deref(&self) -> &Self::Target {
169        self.0.as_ref().unwrap().deref()
170    }
171}
172impl<'a, T> DerefMut for UPIntrRefMut<'a, T> {
173    fn deref_mut(&mut self) -> &mut Self::Target {
174        self.0.as_mut().unwrap().deref_mut()
175    }
176}
tg_sync/up.rs

tg_sync/
up.rs
