rCore-OS: 批处理系统

 1$ tree user
 2user
 3├── Cargo.lock
 4├── Cargo.toml
 5├── Makefile
 6└── src
 7    ├── bin
 8    │   ├── 00hello_world.rs
 9    │   ├── 01store_fault.rs
10    │   ├── 02power.rs
11    │   ├── 03priv_inst.rs
12    │   └── 04priv_csr.rs
13    ├── console.rs
14    ├── lang_items.rs
15    ├── lib.rs
16    ├── linker.ld
17    └── syscall.rs
18
193 directories, 13 files

 1#![no_std]
 2#![no_main]
 3
 4#[macro_use]
 5extern crate user_lib;
 6
 7#[no_mangle]
 8fn main() -> i32 {
 9    println!("Hello, world!");
10    0
11}

1[package]
2name = "user_lib"
3...

1#[macro_use]
2pub mod console;
3mod lang_items;
4mod syscall;

 1#[no_mangle]
 2#[link_section = ".text.entry"]
 3pub extern "C" fn _start() -> ! {
 4    clear_bss();
 5    exit(main());
 6    panic!("unreachable after sys_exit!");
 7}
 8
 9#[linkage = "weak"]
10#[no_mangle]
11fn main() -> i32 {
12    panic!("Cannot find main!");
13}

1use syscall::*;
2
3pub fn write(fd: usize, buf: &[u8]) -> isize {
4    sys_write(fd, buf)
5}
6pub fn exit(exit_code: i32) -> isize {
7    sys_exit(exit_code)
8}

 1fn syscall(id: usize, args: [usize; 3]) -> isize {
 2    let mut ret: isize;
 3    unsafe {
 4        asm!(
 5            "ecall",
 6            inlateout("x10") args[0] => ret,
 7            in("x11") args[1],
 8            in("x12") args[2],
 9            in("x17") id
10        );
11    }
12    ret
13}

 1const SYSCALL_WRITE: usize = 64;
 2const SYSCALL_EXIT: usize = 93;
 3
 4pub fn sys_write(fd: usize, buffer: &[u8]) -> isize {
 5    syscall(SYSCALL_WRITE, [fd, buffer.as_ptr() as usize, buffer.len()])
 6}
 7
 8pub fn sys_exit(xstate: i32) -> isize {
 9    syscall(SYSCALL_EXIT, [xstate as usize, 0, 0])
10}

1const STDOUT: usize = 1;
2
3impl Write for Stdout {
4    fn write_str(&mut self, s: &str) -> fmt::Result {
5        write(STDOUT, s.as_bytes());
6        Ok(())
7    }
8}

 1$ tree os
 2os
 3├── build.rs
 4├── Cargo.lock
 5├── Cargo.toml
 6├── Makefile
 7└── src
 8    ├── batch.rs
 9    ├── console.rs
10    ├── entry.asm
11    ├── lang_items.rs
12    ├── link_app.S
13    ├── linker-qemu.ld
14    ├── logging.rs
15    ├── main.rs
16    ├── sbi.rs
17    ├── sync
18    │   ├── mod.rs
19    │   └── up.rs
20    ├── syscall
21    │   ├── fs.rs
22    │   ├── mod.rs
23    │   └── process.rs
24    └── trap
25        ├── context.rs
26        ├── mod.rs
27        └── trap.S
28
295 directories, 21 files

 1use std::fs::{read_dir, File};
 2use std::io::{Result, Write};
 3
 4fn main() {
 5    println!("cargo:rerun-if-changed=../user/src/");
 6    println!("cargo:rerun-if-changed={}", TARGET_PATH);
 7    insert_app_data().unwrap();
 8}
 9
10static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/release/";

 1    .align 3
 2    .section .data
 3    .global _num_app
 4_num_app:
 5    .quad 5
 6    .quad app_0_start
 7    .quad app_1_start
 8    .quad app_2_start
 9    .quad app_3_start
10    .quad app_4_start
11    .quad app_4_end
12
13    .section .data
14    .global app_0_start
15    .global app_0_end
16app_0_start:
17    .incbin "../user/target/riscv64gc-unknown-none-elf/release/00hello_world.bin"
18app_0_end:
19
20    .section .data
21    .global app_1_start
22    .global app_1_end
23app_1_start:
24    .incbin "../user/target/riscv64gc-unknown-none-elf/release/01store_fault.bin"
25app_1_end:
26
27    .section .data
28    .global app_2_start
29    .global app_2_end
30app_2_start:
31    .incbin "../user/target/riscv64gc-unknown-none-elf/release/02power.bin"
32app_2_end:
33
34    .section .data
35    .global app_3_start
36    .global app_3_end
37app_3_start:
38    .incbin "../user/target/riscv64gc-unknown-none-elf/release/03priv_inst.bin"
39app_3_end:
40
41    .section .data
42    .global app_4_start
43    .global app_4_end
44app_4_start:
45    .incbin "../user/target/riscv64gc-unknown-none-elf/release/04priv_csr.bin"
46app_4_end:

1struct AppManager {
2    num_app: usize,
3    current_app: usize,
4    app_start: [usize; MAX_APP_NUM + 1],
5}

1use std::cell::RefCell;
2static A: RefCell<i32> = RefCell::new(3);
3fn main() {
4    *A.borrow_mut() = 4;
5    println!("{}", A.borrow());
6}

1error[E0277]: `RefCell<i32>` cannot be shared between threads safely
2 --> src/main.rs:2:11
3  |
42 | static A: RefCell<i32> = RefCell::new(3);
5  |           ^^^^^^^^^^^^ `RefCell<i32>` cannot be shared between threads safely
6  |
7  = help: the trait `Sync` is not implemented for `RefCell<i32>`
8  = note: if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` instead
9  = note: shared static variables must have a type that implements `Sync`

 1// os/src/sync/up.rs
 2
 3pub struct UPSafeCell<T> {
 4    inner: RefCell<T>,
 5}
 6
 7unsafe impl<T> Sync for UPSafeCell<T> {}
 8
 9impl<T> UPSafeCell<T> {
10    pub unsafe fn new(value: T) -> Self {
11        Self { inner: RefCell::new(value) }
12    }
13    /// Panic if the data has been borrowed.
14    pub fn exclusive_access(&self) -> RefMut<'_, T> {
15        self.inner.borrow_mut()
16    }
17}

 1// os/src/batch.rs
 2lazy_static! {
 3    static ref APP_MANAGER: UPSafeCell<AppManager> = unsafe { UPSafeCell::new({
 4        extern "C" { fn _num_app(); }
 5        let num_app_ptr = _num_app as usize as *const usize;
 6        let num_app = num_app_ptr.read_volatile();
 7        let mut app_start: [usize; MAX_APP_NUM + 1] = [0; MAX_APP_NUM + 1];
 8        let app_start_raw: &[usize] =  core::slice::from_raw_parts(
 9            num_app_ptr.add(1), num_app + 1
10        );
11        app_start[..=num_app].copy_from_slice(app_start_raw);
12        AppManager {
13            num_app,
14            current_app: 0,
15            app_start,
16        }
17    })};
18}

 1impl AppManager {
 2    pub fn print_app_info(&self) {
 3        println!("[kernel] num_app = {}", self.num_app);
 4        for i in 0..self.num_app {
 5            println!(
 6                "[kernel] app_{} [{:#x}, {:#x})",
 7                i,
 8                self.app_start[i],
 9                self.app_start[i + 1]
10            );
11        }
12    }
13
14    unsafe fn load_app(&self, app_id: usize) {
15        if app_id >= self.num_app {
16            println!("All applications completed!");
17            shutdown(false);
18        }
19        println!("[kernel] Loading app_{}", app_id);
20        // clear app area
21        core::slice::from_raw_parts_mut(APP_BASE_ADDRESS as *mut u8, APP_SIZE_LIMIT).fill(0);
22        let app_src = core::slice::from_raw_parts(
23            self.app_start[app_id] as *const u8,
24            self.app_start[app_id + 1] - self.app_start[app_id],
25        );
26	let app_dst = core::slice::from_raw_parts_mut(APP_BASE_ADDRESS as *mut u8, app_src.len());
27        app_dst.copy_from_slice(app_src);
28        // Memory fence about fetching the instruction memory
29        // It is guaranteed that a subsequent instruction fetch must
30        // observes all previous writes to the instruction memory.
31        // Therefore, fence.i must be executed after we have loaded
32        // the code of the next app into the instruction memory.
33        // See also: riscv non-priv spec chapter 3, 'Zifencei' extension.
34        asm!("fence.i");
35    }
36
37    pub fn get_current_app(&self) -> usize {
38        self.current_app
39    }
40
41    pub fn move_to_next_app(&mut self) {
42        self.current_app += 1;
43    }
44}

 1const USER_STACK_SIZE: usize = 4096 * 2;
 2const KERNEL_STACK_SIZE: usize = 4096 * 2;
 3
 4#[repr(align(4096))]
 5struct KernelStack {
 6    data: [u8; KERNEL_STACK_SIZE],
 7}
 8
 9#[repr(align(4096))]
10struct UserStack {
11    data: [u8; USER_STACK_SIZE],
12}
13
14static KERNEL_STACK: KernelStack = KernelStack {
15    data: [0; KERNEL_STACK_SIZE],
16};
17static USER_STACK: UserStack = UserStack {
18    data: [0; USER_STACK_SIZE],
19};
20
21impl KernelStack {
22    fn get_sp(&self) -> usize {
23        self.data.as_ptr() as usize + KERNEL_STACK_SIZE
24    }
25    pub fn push_context(&self, cx: TrapContext) -> &'static mut TrapContext {
26        let cx_ptr = (self.get_sp() - core::mem::size_of::<TrapContext>()) as *mut TrapContext;
27        unsafe {
28            *cx_ptr = cx;
29        }
30        unsafe { cx_ptr.as_mut().unwrap() }
31    }
32}
33
34impl UserStack {
35    fn get_sp(&self) -> usize {
36        self.data.as_ptr() as usize + USER_STACK_SIZE
37    }
38}

 1use riscv::register::sstatus::{self, Sstatus, SPP};
 2/// Trap Context
 3#[repr(C)]
 4pub struct TrapContext {
 5    /// general regs[0..31]
 6    pub x: [usize; 32],
 7    /// CSR sstatus      
 8    pub sstatus: Sstatus,
 9    /// CSR sepc
10    pub sepc: usize,
11}

 1global_asm!(include_str!("trap.S"));
 2
 3/// initialize CSR `stvec` as the entry of `__alltraps`
 4pub fn init() {
 5    extern "C" {
 6        fn __alltraps();
 7    }
 8    unsafe {
 9        stvec::write(__alltraps as usize, TrapMode::Direct);
10    }
11}

 1.altmacro
 2.macro SAVE_GP n
 3    sd x\n, \n*8(sp)
 4.endm
 5.macro LOAD_GP n
 6    ld x\n, \n*8(sp)
 7.endm
 8    .section .text
 9    .globl __alltraps
10    .globl __restore
11    .align 2
12__alltraps:
13    csrrw sp, sscratch, sp
14    # now sp->kernel stack, sscratch->user stack
15    # allocate a TrapContext on kernel stack
16    addi sp, sp, -34*8
17    # save general-purpose registers
18    sd x1, 1*8(sp)
19    # skip sp(x2), we will save it later
20    sd x3, 3*8(sp)
21    # skip tp(x4), application does not use it
22    # save x5~x31
23    .set n, 5
24    .rept 27
25        SAVE_GP %n
26        .set n, n+1
27    .endr
28    # we can use t0/t1/t2 freely, because they were saved on kernel stack
29    csrr t0, sstatus
30    csrr t1, sepc
31    sd t0, 32*8(sp)
32    sd t1, 33*8(sp)
33    # read user stack from sscratch and save it on the kernel stack
34    csrr t2, sscratch
35    sd t2, 2*8(sp)
36    # set input argument of trap_handler(cx: &mut TrapContext)
37    mv a0, sp
38    call trap_handler
39
40__restore:
41    # case1: start running app by __restore
42    # case2: back to U after handling trap
43    mv sp, a0
44    # now sp->kernel stack(after allocated), sscratch->user stack
45    # restore sstatus/sepc
46    ld t0, 32*8(sp)
47    ld t1, 33*8(sp)
48    ld t2, 2*8(sp)
49    csrw sstatus, t0
50    csrw sepc, t1
51    csrw sscratch, t2
52    # restore general-purpuse registers except sp/tp
53    ld x1, 1*8(sp)
54    ld x3, 3*8(sp)
55    .set n, 5
56    .rept 27
57        LOAD_GP %n
58        .set n, n+1
59    .endr
60    # release TrapContext on kernel stack
61    addi sp, sp, 34*8
62    # now sp->kernel stack, sscratch->user stack
63    csrrw sp, sscratch, sp
64    sret

 1// os/src/trap/mod.rs
 2use riscv::register::{
 3    mtvec::TrapMode,
 4    scause::{self, Exception, Trap},
 5    stval, stvec,
 6};
 7
 8#[no_mangle]
 9/// handle an interrupt, exception, or system call from user space
10pub fn trap_handler(cx: &mut TrapContext) -> &mut TrapContext {
11    let scause = scause::read(); // get trap cause
12    let stval = stval::read(); // get extra value
13    match scause.cause() {
14        Trap::Exception(Exception::UserEnvCall) => {
15            cx.sepc += 4;
16            cx.x[10] = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]) as usize;
17        }
18        Trap::Exception(Exception::StoreFault) | Trap::Exception(Exception::StorePageFault) => {
19            println!("[kernel] PageFault in application, kernel killed it.");
20            run_next_app();
21        }
22        Trap::Exception(Exception::IllegalInstruction) => {
23            println!("[kernel] IllegalInstruction in application, kernel killed it.");
24            run_next_app();
25        }
26        _ => {
27            panic!(
28                "Unsupported trap {:?}, stval = {:#x}!",
29                scause.cause(),
30                stval
31            );
32        }
33    }
34    cx
35}

1[dependencies]
2riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }

1// os/src/syscall/mod.rs
2
3pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
4    match syscall_id {
5        SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
6        SYSCALL_EXIT => sys_exit(args[0] as i32),
7        _ => panic!("Unsupported syscall_id: {}", syscall_id),
8    }
9}

 1// os/src/syscall/fs.rs
 2const FD_STDOUT: usize = 1;
 3
 4pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize {
 5    match fd {
 6        FD_STDOUT => {
 7            let slice = unsafe { core::slice::from_raw_parts(buf, len) };
 8            let str = core::str::from_utf8(slice).unwrap();
 9            print!("{}", str);
10            len as isize
11        },
12        _ => {
13            panic!("Unsupported fd in sys_write!");
14        }
15    }
16}
17
18// os/src/syscall/process.rs
19pub fn sys_exit(xstate: i32) -> ! {
20    println!("[kernel] Application exited with code {}", xstate);
21    run_next_app()
22}

 1/// init batch subsystem
 2pub fn init() {
 3    print_app_info();
 4}
 5
 6/// print apps info
 7pub fn print_app_info() {
 8    APP_MANAGER.exclusive_access().print_app_info();
 9}
10
11/// run next app
12pub fn run_next_app() -> ! {
13    let mut app_manager = APP_MANAGER.exclusive_access();
14    let current_app = app_manager.get_current_app();
15    unsafe {
16        app_manager.load_app(current_app);
17    }
18    app_manager.move_to_next_app();
19    drop(app_manager);
20    // before this we have to drop local variables related to resources manually
21    // and release the resources
22    extern "C" {
23        fn __restore(cx_addr: usize);
24    }
25    unsafe {
26        __restore(KERNEL_STACK.push_context(TrapContext::app_init_context(
27            APP_BASE_ADDRESS,
28            USER_STACK.get_sp(),
29        )) as *const _ as usize);
30    }
31    panic!("Unreachable in batch::run_current_app!");
32}

1// os/.cargo/config
2
3[target.riscv64gc-unknown-none-elf]
4rustflags = [
5    "-Clink-arg=-Tsrc/linker.ld", "-Cforce-frame-pointers=yes"
6]

 1Stack
 2                   .
 3                   .
 4      +->          .
 5      |   +-----------------+   |
 6      |   | return address  |   |
 7      |   |   previous fp ------+
 8      |   | saved registers |
 9      |   | local variables |
10      |   |       ...       | <-+
11      |   +-----------------+   |
12      |   | return address  |   |
13      +------ previous fp   |   |
14          | saved registers |   |
15          | local variables |   |
16      +-> |       ...       |   |
17      |   +-----------------+   |
18      |   | return address  |   |
19      |   |   previous fp ------+
20      |   | saved registers |
21      |   | local variables |
22      |   |       ...       | <-+
23      |   +-----------------+   |
24      |   | return address  |   |
25      +------ previous fp   |   |
26          | saved registers |   |
27          | local variables |   |
28  $fp --> |       ...       |   |
29          +-----------------+   |
30          | return address  |   |
31          |   previous fp ------+
32          | saved registers |
33  $sp --> | local variables |
34          +-----------------+

 1// os/src/backtrace.rs
 2use core::arch::asm;
 3use core::ptr;
 4
 5#[no_mangle]
 6pub fn unwind() {
 7    println!("[kernel] rqdmap: 123");
 8    let mut fp: *const usize;
 9    unsafe{
10        asm!("mv {}, fp", out(reg) fp);
11
12        println!("[Kernel] == Begin stack trace ==");
13        while fp != ptr::null() {
14            let ra = *fp.sub(1);
15            let prev_fp = *fp.sub(2) as *const usize;
16            println!("[kernel] 0x{:x}, fp = 0x{:x}", ra as usize, prev_fp as usize);
17            fp = prev_fp;
18        }
19        println!("[Kernel] == End stack trace ==");
20    }
21}

 1// os/src/main.rs
 2mod backtrace;
 3
 4fn foo1() { foo2(); }
 5fn foo2() { foo3(); }
 6fn foo3() { foo4(); }
 7fn foo4() { foo5(); }
 8fn foo5() { foo6(); }
 9
10fn foo6() {
11    backtrace::unwind();
12}
13
14#[no_mangle]
15pub fn rust_main() -> ! {
16    clear_bss();
17    println!("[kernel] Hello, world!");
18    trap::init();
19    batch::init();
20
21    foo1();
22    foo2();
23    backtrace::unwind();
24    backtrace::unwind();
25
26    panic!("Stop...");
27
28    batch::run_next_app();
29}

 1[Kernel] == Begin stack trace ==
 2[kernel] 0x80200fd2, fp = 0x80239000
 3[kernel] 0x80200010, fp = 0x0
 4[Kernel] == End stack trace ==
 5[Kernel] == Begin stack trace ==
 6[kernel] 0x80200fda, fp = 0x80239000
 7[kernel] 0x80200010, fp = 0x0
 8[Kernel] == End stack trace ==
 9[Kernel] == Begin stack trace ==
10[kernel] 0x80200fe2, fp = 0x80239000
11[kernel] 0x80200010, fp = 0x0
12[Kernel] == End stack trace ==
13[Kernel] == Begin stack trace ==
14[kernel] 0x80200fea, fp = 0x80239000
15[kernel] 0x80200010, fp = 0x0
16[Kernel] == End stack trace ==
17[kernel] Panicked at src/main.rs:56 Stop...