fix: 直接存储地址范围和释放函数以避免悬垂指针

Signed-off-by: YdrMaster <ydrml@hotmail.com>

Author: YdrMaster

README.md

@@ -8,9 +8,6 @@
 
 > **感谢：2022 系统能力赛，哈工大（深圳），[FTL-OS](https://gitlab.eduxiji.net/DarkAngelEX/oskernel2022-ftlos) 提供灵感**
 
-| 注意 | 这个项目有重大 bug，设计上也需要调整，正在重构中，参见[重构设计](#重构设计)。
-|-|-
-
 ## 目录
 
 - [概念](#概念)
@@ -22,10 +19,10 @@
   - [切换现场](#切换现场)
   - [任务兼容性](#任务兼容性)
   - [陷入服务程序的一致抽象](#陷入服务程序的一致抽象)
+- [设计解释](#设计解释)
 - [使用说明](#使用说明)
   - [功能测试](#功能测试)
   - [性能测试](#性能测试)
-- [重构设计](#重构设计)
 
 ## 概念
 
@@ -313,6 +310,10 @@ trap Lv.2                                                     (trap3)-->{o}  (tr
 
 服务阶段指的是初始化阶段以后的整个生命周期。这个阶段完全是陷入驱动的，每次发生陷入就进入准备好的陷入栈执行处理流程，平时则完全静默。
 
+## 设计解释
+
+- [为什么陷入必须换栈](https://github.com/YdrMaster/notebook/blob/main/%E9%9A%8F%E7%AC%94/20230130-trap-to-a-new-stack.md)
+
 ## 使用说明
 
 ### 功能测试
@@ -341,17 +342,9 @@ trap Lv.2                                                     (trap3)-->{o}  (tr
 [ WARN] LOG TEST >> Hello, world!
 [ERROR] LOG TEST >> Hello, world!
 
-[TRACE] new TrapStack(0x80205000..0x80206000)
-[TRACE] delete TrapStack(0x80205000..0x80206000)
-[ INFO] Stack Dropped!
-[TRACE] new TrapStack(0x80205000..0x80206000)
-[TRACE] load TrapStack(0x80205000..0x80206000)
-[TRACE] unload TrapStack(0x80205000..0x80206000)
-[TRACE] delete TrapStack(0x80205000..0x80206000)
-[ INFO] Stack Dropped!
-[TRACE] new TrapStack(0x80205000..0x80206000)
-[TRACE] load TrapStack(0x80205000..0x80206000)
-[DEBUG] sscratch: 0x80205fd8
+[DEBUG] fast trap: Exception(Unknown)(25)
+[ WARN] call fast-trap inline!
+[DEBUG] mscratch: 0x80008fd0
 [DEBUG] fast trap: Exception(Unknown)(24)
 [DEBUG] fast trap: Exception(IllegalInstruction)(2)
 [ INFO] Test pass
@@ -450,41 +443,3 @@ cargo qemu --kernel bench --smp 1
 | main     | 107700360    | 107756601 | 123088023 |  48.5%
 | vectored | 212014619    | 212212320 | 273411079 | 100.0%
 | slow     | 210191584    | 210286668 | 456087262 | 125.6%
-
-## 重构设计
-
-将陷入分为 2 类：
-
-- 陷入到新栈：陷入之后将栈指针指向一个新的栈，意味着启动了新的线程；
-- 陷入到当前栈：发生陷入时栈指针不动，直接继续使用，因此陷入时栈指针必须有效；
-
-必须将陷入处理和“线程”的概念耦合。在这个库的框架下，产生新线程的唯一方式就是陷入到新栈。
-
-陷入到新栈时一定会创建一个新线程，但是这个线程的生命周期可能很短。任务的切换只能发生在陷入线程的末尾，这类似于 CORTEX 架构的 PendSV 可挂起中断的设计。
-
-一般来说，跨权限等级的陷入必须陷入到新栈，因为低权限代码可能没有正确使用栈指针，甚至就是因为栈溢出才发生陷入。但同权限的陷入，尤其是在同一个软件内部发生的陷入（比如内核开中断），通常来说栈指针是保证有效的，此时就可以使用同栈陷入的方式。
-
-陷入之后，上下文可以直接压在栈上。下表显示了一个典型的线程栈结构：
-
-| 栈底（高地址）
-| -
-| 低权限上下文
-| `0` 级陷入栈
-| `1` 级嵌套上下文
-| `1` 级陷入栈
-| ……
-| `n` 级嵌套上下文
-
-这个线程栈由一次低优先级发生的陷入创建，在栈上压入控制流上下文后开始处理，此时使用的栈空间称为 `0` 级陷入栈。若处理过程中再次发生陷入，栈指针不动，当前上下文直接压到栈上后开始处理，此时使用的栈空间称为 `1` 级陷入栈。以此类推，若发生 `n` 次嵌套陷入后，无法处理，需要挂起等待，则 `n` 级嵌套处理必须退出，栈顶存放用于恢复 `n-1` 级陷入处理的 `n` 级上下文，然后一步恢复另一个线程的最后一个上下文。此时，刚刚创建的那个线程上，共有 `n` 个内核陷入和一个低权限陷入不能处理，处于挂起状态。只有原来的 `n` 级陷入处理完成才能依次恢复。
-
-这种逐级压到同一个栈的方式可以节省栈空间的开销，也会减少同权限陷入不得不换栈导致的缓存失效问题。但也会压住之前到来的陷入无法处理，必须跟着挂起。尤其是新到来的同权限陷入通常和被压住的陷入没什么关系，很可能带来死锁。所以，如果第 `n` 级上下文无法立即处理，可以选择创建一个挂起状态的新线程，然后恢复处理 `n-1` 级陷入。只需分配一个新的栈空间，拷贝 `n` 级陷入栈的数据到新栈上，然后构造一个可恢复这个陷入栈的上下文即可。
-
-这种从挂起创建的线程栈具有这样的结构：
-
-| 栈底（高地址）
-| -
-| 无效上下文
-| `n` 级陷入栈
-| `n+1` 级嵌套上下文
-
-从这个线程恢复时，恢复 `n+1` 级嵌套上下文将继续执行 `n` 级陷入栈的处理流程，完成后识别到下一个要恢复的是一个无效的上下文，可以执行一个调度流程，这个栈空间则可回收。

fast-trap/Cargo.toml

@@ -9,6 +9,3 @@ authors = ["YdrMaster <ydrml@hotmail.com>"]
 [features]
 riscv-s = []
 riscv-m = []
-
-[dependencies]
-log = "0.4.17"

fast-trap/src/lib.rs

@@ -17,11 +17,9 @@ use core::{
     marker::PhantomPinned,
     mem::{align_of, forget, MaybeUninit},
     ops::Range,
-    ptr::{drop_in_place, NonNull},
+    ptr::NonNull,
 };
 
-const TARGET: &str = "fast-trap";
-
 /// 游离的陷入栈。
 pub struct FreeTrapStack(NonNull<TrapHandler>);
 
@@ -35,22 +33,22 @@ pub struct IllegalStack;
 impl FreeTrapStack {
     /// 在内存块上构造游离的陷入栈。
     pub fn new(
-        block: impl TrapStackBlock,
+        range: Range<usize>,
+        drop: fn(Range<usize>),
+
         context_ptr: NonNull<FlowContext>,
         fast_handler: FastHandler,
     ) -> Result<Self, IllegalStack> {
         const LAYOUT: Layout = Layout::new::<TrapHandler>();
-        let range = block.as_ref().as_ptr_range();
-        let bottom = range.start as usize;
-        let top = range.end as usize;
+        let bottom = range.start;
+        let top = range.end;
         let ptr = (top - LAYOUT.size()) & !(LAYOUT.align() - 1);
         if ptr >= bottom {
             let handler = unsafe { &mut *(ptr as *mut TrapHandler) };
+            handler.range = range;
+            handler.drop = drop;
             handler.context = context_ptr;
             handler.fast_handler = fast_handler;
-            handler.block = NonNull::from(&block);
-            forget(block);
-            log::trace!(target: TARGET, "new TrapStack({:?})", range);
             Ok(Self(unsafe { NonNull::new_unchecked(handler) }))
         } else {
             Err(IllegalStack)
@@ -60,7 +58,6 @@ impl FreeTrapStack {
     /// 将这个陷入栈加载为预备陷入栈。
     #[inline]
     pub fn load(self) -> LoadedTrapStack {
-        log::trace!("load TrapStack({:#x?})", unsafe { self.0.as_ref().range() });
         let scratch = exchange_scratch(self.0.as_ptr() as _);
         forget(self);
         LoadedTrapStack(scratch)
@@ -70,10 +67,10 @@ impl FreeTrapStack {
 impl Drop for FreeTrapStack {
     #[inline]
     fn drop(&mut self) {
-        log::trace!("delete TrapStack({:#x?})", unsafe {
-            self.0.as_ref().range()
-        });
-        unsafe { drop_in_place(self.0.as_ref().block.as_ptr()) }
+        unsafe {
+            let handler = self.0.as_ref();
+            (handler.drop)(handler.range.clone());
+        }
     }
 }
 
@@ -101,9 +98,6 @@ impl LoadedTrapStack {
     unsafe fn unload_unchecked(&self) -> FreeTrapStack {
         let ptr = exchange_scratch(self.0) as *mut TrapHandler;
         let handler = unsafe { NonNull::new_unchecked(ptr) };
-        log::trace!("unload TrapStack({:#x?})", unsafe {
-            handler.as_ref().range()
-        });
         FreeTrapStack(handler)
     }
 }
@@ -115,13 +109,6 @@ impl Drop for LoadedTrapStack {
     }
 }
 
-/// 陷入栈内存块。
-///
-/// # TODO
-///
-/// 需要给 `Vec`、`Box<[u8]>` 之类的东西实现。
-pub trait TrapStackBlock: 'static + AsRef<[u8]> + AsMut<[u8]> {}
-
 /// 陷入处理器上下文。
 #[repr(C)]
 struct TrapHandler {
@@ -145,30 +132,23 @@ struct TrapHandler {
     /// - 在快速路径开始时暂存 a0。
     /// - 在快速路径结束时保存完整路径函数。
     scratch: usize,
-    /// 上下文所在的内存块。
-    ///
-    /// 保存它以提供内存块的范围，同时用于控制内存块的生命周期。
-    block: NonNull<dyn TrapStackBlock>,
+
+    range: Range<usize>,
+    drop: fn(Range<usize>),
+
     /// 禁止移动标记。
     ///
     /// `TrapHandler` 是放在其内部定义的 `block` 块里的，这是一种自引用结构，不能移动。
     pinned: PhantomPinned,
 }
 
 impl TrapHandler {
-    /// 内存块地址范围。
-    #[inline]
-    fn range(&self) -> Range<usize> {
-        let block = unsafe { self.block.as_ref().as_ref().as_ptr_range() };
-        block.start as _..block.end as _
-    }
-
     /// 如果从快速路径向完整路径转移，可以把一个对象放在栈底。
     /// 用这个方法找到栈底的一个对齐的位置。
     #[inline]
     fn locate_fast_mail<T>(&mut self) -> *mut MaybeUninit<T> {
-        let bottom = unsafe { self.block.as_mut() }.as_mut().as_mut_ptr();
-        let offset = bottom.align_offset(align_of::<T>());
-        unsafe { &mut *bottom.add(offset).cast() }
+        let top = self.range.end as *mut u8;
+        let offset = top.align_offset(align_of::<T>());
+        unsafe { &mut *top.add(offset).cast() }
     }
 }

test-app/src/main.rs

@@ -12,7 +12,7 @@ use core::{
 use dtb_walker::{Dtb, DtbObj, HeaderError, Str, WalkOperation};
 use fast_trap::{
     load_direct_trap_entry, reuse_stack_for_trap, soft_trap, trap_entry, FastContext, FastResult,
-    FlowContext, FreeTrapStack, TrapStackBlock,
+    FlowContext, FreeTrapStack,
 };
 use rcore_console::log;
 use riscv::register::*;
@@ -102,7 +102,8 @@ extern "C" fn rust_main(_hartid: usize, dtb: *const u8) {
 
     // 测试构造和释放
     let _ = FreeTrapStack::new(
-        StackRef(unsafe { &mut ROOT_STACK }),
+        unsafe { ROOT_STACK.range() },
+        |_| {},
         context_ptr,
         fast_handler,
     )
@@ -114,7 +115,8 @@ extern "C" fn rust_main(_hartid: usize, dtb: *const u8) {
 
     // 测试加载和卸载
     let _ = FreeTrapStack::new(
-        StackRef(unsafe { &mut ROOT_STACK }),
+        unsafe { ROOT_STACK.range() },
+        |_| {},
         context_ptr,
         fast_handler,
     )
@@ -127,7 +129,8 @@ extern "C" fn rust_main(_hartid: usize, dtb: *const u8) {
 
     // 加载一个新的陷入栈
     let loaded = FreeTrapStack::new(
-        StackRef(unsafe { &mut ROOT_STACK }),
+        unsafe { ROOT_STACK.range() },
+        |_| {},
         context_ptr,
         fast_handler,
     )
@@ -137,7 +140,8 @@ extern "C" fn rust_main(_hartid: usize, dtb: *const u8) {
     {
         // 叠加一个陷入栈用于临时保护
         let _loaded = FreeTrapStack::new(
-            StackRef(unsafe { &mut FREE_STACK }),
+            unsafe { FREE_STACK.range() },
+            |_| {},
             context_ptr,
             fast_handler,
         )
@@ -239,27 +243,10 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
 #[repr(C, align(4096))]
 struct Stack([u8; 4096]);
 
-struct StackRef(&'static mut Stack);
-
-impl AsRef<[u8]> for StackRef {
-    #[inline]
-    fn as_ref(&self) -> &[u8] {
-        &self.0 .0
-    }
-}
-
-impl AsMut<[u8]> for StackRef {
-    #[inline]
-    fn as_mut(&mut self) -> &mut [u8] {
-        &mut self.0 .0
-    }
-}
-
-impl TrapStackBlock for StackRef {}
-
-impl Drop for StackRef {
-    fn drop(&mut self) {
-        log::info!("Stack Dropped!")
+impl Stack {
+    fn range(&self) -> core::ops::Range<usize> {
+        let ans = self.0.as_ptr_range();
+        ans.start as usize..ans.end as usize
     }
 }