Try batch but kernel panicked.

os/src/batch.rs

@@ -0,0 +1,117 @@
+use core::cell::RefCell;
+use lazy_static::*;
+use crate::trap::TrapContext;
+
+const USER_STACK_SIZE: usize = 4096 * 2;
+const KERNEL_STACK_SIZE: usize = 4096 * 2;
+const MAX_APP_NUM: usize = 16;
+const APP_BASE_ADDRESS: usize = 0x80040000;
+const APP_SIZE_LIMIT: usize = 0x20000;
+
+#[repr(align(4096))]
+struct KernelStack {
+    data: [u8; KERNEL_STACK_SIZE],
+}
+
+#[repr(align(4096))]
+struct UserStack {
+    data: [u8; USER_STACK_SIZE],
+}
+
+static KERNEL_STACK: KernelStack = KernelStack { data: [0; KERNEL_STACK_SIZE] };
+static USER_STACK: UserStack = UserStack { data: [0; USER_STACK_SIZE] };
+
+impl KernelStack {
+    fn get_sp(&self) -> usize {
+        self.data.as_ptr() as usize + KERNEL_STACK_SIZE
+    }
+    pub fn push_context(&self, cx: TrapContext) -> &'static mut TrapContext {
+        let cx_ptr = (self.get_sp() - core::mem::size_of::<TrapContext>()) as *mut TrapContext;
+        unsafe { *cx_ptr = cx; }
+        unsafe { cx_ptr.as_mut().unwrap() }
+    }
+}
+
+impl UserStack {
+    fn get_sp(&self) -> usize {
+        self.data.as_ptr() as usize + USER_STACK_SIZE
+    }
+}
+
+struct AppManager {
+    inner: RefCell<AppManagerInner>,
+}
+struct AppManagerInner {
+    num_app: usize,
+    next_app: usize,
+    app_start: [usize; MAX_APP_NUM + 1],
+}
+unsafe impl Sync for AppManager {}
+
+impl AppManagerInner {
+    pub fn print_app_info(&self) {
+        println!("num_app = {}", self.num_app);
+        for i in 0..self.num_app {
+            println!("app_{} [{:#x}, {:#x})", i, self.app_start[i], self.app_start[i + 1]);
+        }
+    }
+
+    unsafe fn load_app(&self, app_id: usize) {
+        // clear app area
+        (APP_BASE_ADDRESS..APP_BASE_ADDRESS + APP_SIZE_LIMIT).for_each(|addr| {
+            (addr as *mut u8).write_volatile(0);
+        });
+        let app_src = core::slice::from_raw_parts(
+            self.app_start[app_id] as *const u8,
+            self.app_start[app_id + 1] - self.app_start[app_id]
+        );
+        let app_dst = core::slice::from_raw_parts_mut(
+            APP_BASE_ADDRESS as *mut u8,
+            app_src.len()
+        );
+        app_dst.copy_from_slice(app_src);
+    }
+
+    pub fn run_next_app(&mut self) {
+        unsafe { self.load_app(self.next_app); }
+        self.next_app += 1;
+        extern "C" { fn __restore(cx: &mut TrapContext); }
+        unsafe {
+            __restore(KERNEL_STACK.push_context(
+                TrapContext::app_init_context(APP_BASE_ADDRESS, USER_STACK.get_sp())
+            ));
+        }
+    }
+}
+
+lazy_static! {
+    static ref APP_MANAGER: AppManager = AppManager {
+        inner: RefCell::new({
+            extern "C" { fn _num_app(); }
+            let num_app_ptr = _num_app as usize as *const usize;
+            let num_app = unsafe { num_app_ptr.read_volatile() };
+            let mut app_start: [usize; MAX_APP_NUM + 1] = [0; MAX_APP_NUM + 1];
+            let app_start_raw: &[usize] = unsafe {
+                core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1)
+            };
+            &app_start[..=num_app].copy_from_slice(app_start_raw);
+            AppManagerInner {
+                num_app,
+                next_app: 0,
+                app_start,
+            }
+        }),
+    };
+}
+
+pub fn init() {
+    print_app_info();
+}
+
+pub fn print_app_info() {
+    APP_MANAGER.inner.borrow().print_app_info();
+}
+
+pub fn run_next_app() {
+    APP_MANAGER.inner.borrow_mut().run_next_app();
+}

os/src/main.rs

@@ -10,6 +10,7 @@ mod lang_items;
 mod sbi;
 mod syscall;
 mod trap;
+mod batch;
 
 global_asm!(include_str!("entry.asm"));
 global_asm!(include_str!("link_app.S"));
@@ -28,17 +29,7 @@ fn clear_bss() {
 pub fn rust_main() -> ! {
     clear_bss();
     println!("Hello, world!");
-    extern "C" {
-        fn _num_app();
-    }
-    let num_app_ptr = _num_app as usize as *const usize;
-    let num_app = unsafe { num_app_ptr.read_volatile() };
-    println!("num_app = {}", num_app);
-    let app_start: &[usize] = unsafe {
-        core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1)
-    };
-    for i in 0..num_app {
-        println!("app_{} [{:#x}, {:#x})", i, app_start[i], app_start[i + 1]);
-    }
+    batch::init();
+    batch::run_next_app();
     panic!("Shutdown machine!");
 }

os/src/trap/context.rs

@@ -0,0 +1,23 @@
+use riscv::register::sstatus::{Sstatus, self, SPP};
+
+#[repr(C)]
+pub struct TrapContext {
+    x: [usize; 32],
+    sstatus: Sstatus,
+    sepc: usize,
+}
+
+impl TrapContext {
+    pub fn set_sp(&mut self, sp: usize) { self.x[2] = sp; }
+    pub fn app_init_context(entry: usize, sp: usize) -> Self {
+        let mut sstatus = sstatus::read();
+        sstatus.set_spp(SPP::User);
+        let mut cx = Self {
+            x: [0; 32],
+            sstatus,
+            sepc: entry,
+        };
+        cx.set_sp(sp);
+        cx
+    }
+}

os/src/trap/mod.rs

@@ -0,0 +1,38 @@
+mod context;
+
+use riscv::register::{
+    mtvec::TrapMode,
+    stvec,
+    scause::{
+        self,
+        Trap,
+        Exception,
+    },
+    stval,
+};
+
+global_asm!(include_str!("trap.S"));
+
+pub fn init() {
+    extern "C" { fn __alltraps(); }
+    unsafe {
+        stvec::write(__alltraps as usize, TrapMode::Direct);
+    }
+}
+
+#[no_mangle]
+pub fn trap_handler(cx: &mut TrapContext) -> &mut TrapContext {
+    let scause = scause::read();
+    let stval = stval::read();
+    match scause.cause() {
+        Trap::Exception(Exception::UserEnvCall) => {
+            panic!("Triggered UserEnvCall!");
+        }
+        _ => {
+            panic!("Unsupported trap!");
+        }
+    }
+    cx
+}
+
+pub use context::TrapContext;

os/src/trap/trap.S

@@ -0,0 +1,64 @@
+.altmacro
+.macro SAVE_GP n
+    sd x\n, \n*8(sp)
+.endm
+.macro LOAD_GP n
+    ld x\n, \n*8(sp)
+.endm
+    .section .text
+    .globl __alltraps
+    .globl __restore
+    .align 2
+__alltraps:
+    csrrw sp, sscratch, sp
+    # now sp->kernel stack, sscratch->user stack
+    # allocate a TrapContext on kernel stack
+    addi sp, sp, -34*8
+    # save general-purpose registers
+    sd x1, 1*8(sp)
+    # skip sp(x2), we will save it later
+    sd x3, 3*8(sp)
+    # skip tp(x4), application does not use it
+    # save x5~x31
+    .set n, 5
+    .rept 27
+        SAVE_GP %n
+        .set n, n+1
+    .endr
+    # we can use t0/t1/t2 freely, because they were saved on kernel stack
+    csrr t0, sstatus
+    csrr t1, sepc
+    sd t0, 32*8(sp)
+    sd t1, 33*8(sp)
+    # read user stack from sscratch and save it on the kernel stack
+    csrr t2, sscratch
+    sd t2, 2*8(sp)
+    # set input argument of trap_handler(cx: &mut TrapContext)
+    mv a0, sp
+    call trap_handler
+
+__restore:
+    # case1: start running app by __restore
+    # case2: back to U after handling trap
+    mv sp, a0
+    # now sp->kernel stack(after allocated), sscratch->user stack
+    # restore sstatus/sepc
+    ld t0, 32*8(sp)
+    ld t1, 33*8(sp)
+    ld t2, 2*8(sp)
+    csrw sstatus, t0
+    csrw sepc, t1
+    csrw sscratch, t2
+    # restore general-purpuse registers except sp/tp
+    ld x1, 1*8(sp)
+    ld x3, 3*8(sp)
+    .set n, 5
+    .rept 27
+        LOAD_GP %n
+        .set n, n+1
+    .endr
+    # release TrapContext on kernel stack
+    addi sp, sp, 34*8
+    # now sp->kernel stack, sscratch->user stack
+    csrrw sp, sscratch, sp
+    sret