ch2

#![feature(linkage)]    // 启用弱链接特性

#[linkage = "weak"]
#[no_mangle]
fn main() -> i32 {
    panic!("Cannot find main!");
}

    .align 3          # 8字节对齐（2^3=8）
    .section .data
    .global _num_app   # 导出全局符号
_num_app: #应用程序描述符数组
    .quad 3       # 应用程序数量 = 3
    .quad app_0_start  # 应用程序0起始地址
    .quad app_1_start  # 应用程序1起始地址
    .quad app_2_start
    .quad app_3_start
    .quad app_4_start
    .quad app_5_start
    .quad app_6_start
    .quad app_6_end    # 最后一个应用程序的结束地址

    .section .data
    .global app_0_start
    .global app_0_end
app_0_start:
    .incbin "../user/build/bin/ch2b_bad_address.bin"
app_0_end:

    .section .data #三个数据段分别插入三个应用程序的二进制镜像
    .global app_1_start
    .global app_1_end
app_1_start:
    .incbin "../user/build/bin/ch2b_bad_instructions.bin"
app_1_end:

    .section .data #各自有一对全局符号 app_*_start, app_*_end 指示它们的开始和结束位置
    .global app_2_start
    .global app_2_end
app_2_start:
    .incbin "../user/build/bin/ch2b_bad_register.bin"
app_2_end:

    .section .data
    .global app_3_start
    .global app_3_end
app_3_start:
    .incbin "../user/build/bin/ch2b_hello_world.bin"
app_3_end:

    .section .data
    .global app_4_start
    .global app_4_end
app_4_start:
    .incbin "../user/build/bin/ch2b_power_3.bin"
app_4_end:

    .section .data
    .global app_5_start
    .global app_5_end
app_5_start:
    .incbin "../user/build/bin/ch2b_power_5.bin"
app_5_end:

    .section .data
    .global app_6_start
    .global app_6_end
app_6_start:
    .incbin "../user/build/bin/ch2b_power_7.bin"
app_6_end:

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

lazy_static! {
    static ref APP_MANAGER: UPSafeCell<AppManager> = unsafe {
        UPSafeCell::new({
            extern "C" {
                fn _num_app();
            }
            let num_app_ptr = _num_app as usize as *const usize;
            let num_app = num_app_ptr.read_volatile();
            let mut app_start: [usize; MAX_APP_NUM + 1] = [0; MAX_APP_NUM + 1];
            let app_start_raw: &[usize] =
                core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1);
            app_start[..=num_app].copy_from_slice(app_start_raw);
            AppManager {
                num_app,
                current_app: 0,
                app_start,
            }
        })
    };
}

use std::cell::RefCell;

fn main() {
    let value = RefCell::new(42);

    // 通过value.borrow_mut()来借用可变引用。
    let mut value_borrow_mut = value.borrow_mut();
    *value_borrow_mut += 1;

    // 这时，value已经被可变地借用，所以尝试再次借用会导致panic！
    // 下面的行如果取消注释，将会在运行时产生panic。
    // let value_borrow_mut2 = value.borrow_mut();

    println!("value: {}", value_borrow_mut);

    // 第一个可变引用离开作用域，所以可以再次借用。
    drop(value_borrow_mut);

    // 现在可以再次借用，因为之前的可变引用已经结束。
    let value_borrow = value.borrow();
    println!("value: {}", value_borrow);
}

    unsafe fn load_app(&self, app_id: usize) {
        if app_id >= self.num_app {
            println!("All applications completed!");
            use crate::board::QEMUExit;
            crate::board::QEMU_EXIT_HANDLE.exit_success();
        }
        println!("[kernel] Loading app_{}", app_id);
        // clear app area
        core::slice::from_raw_parts_mut(APP_BASE_ADDRESS as *mut u8, APP_SIZE_LIMIT).fill(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);
        // Memory fence about fetching the instruction memory
        // It is guaranteed that a subsequent instruction fetch must
        // observes all previous writes to the instruction memory.
        // Therefore, fence.i must be executed after we have loaded
        // the code of the next app into the instruction memory.
        // See also: riscv non-priv spec chapter 3, 'Zifencei' extension.
        asm!("fence.i");
    }

// 硬件自动设置
sstatus.SPP = current_privilege;  // U=0, S=1, M=3
sepc = pc + 4;                    // 返回地址
scause = trap_cause;              // 陷阱原因
stval = additional_info;          // 附加信息
pc = stvec;                       // 跳转到处理程序
privilege = S;                    // 切换到监督者模式

// 硬件自动恢复
privilege = sstatus.SPP;  // 恢复之前的特权级
pc = sepc;                // 跳回到用户程序
sstatus.SPP = 0;          // 清除SPP字段

// 从内核栈恢复用户态上下文
for i in 0..32 {
    x[i] = trap_context.x[i];
}
sstatus = trap_context.sstatus;
sepc = trap_context.sepc;

// os/src/batch.rs

#[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],
};

.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

csrrw sp, sscratch, sp #交换 sp 和 sscratch

addi sp, sp, -34*8  # 在内核栈上分配 34*8 字节的 TrapContext

sd x1, 1*8(sp)     # 保存 ra
sd x3, 3*8(sp)     # 保存 gp
# 跳过 x2(sp), x4(tp)
.set n, 5
.rept 27           # 循环保存 x5-x31
    SAVE_GP %n
    .set n, n+1
.endr

csrr t0, sstatus
csrr t1, sepc #将 CSR sstatus 和 sepc 的值分别读到寄存器 t0 和 t1 中然后保存到内核栈对应的位置上
sd t0, 32*8(sp)
sd t1, 33*8(sp) 

mv a0, sp          # 参数：TrapContext 指针
call trap_handler  # 调用 Rust 陷阱处理程序

mv sp, a0  # a0 包含要恢复的 TrapContext 指针

ld t0, 32*8(sp)    # 加载 sstatus
ld t1, 33*8(sp)    # 加载 sepc  
ld t2, 2*8(sp)     # 加载用户栈指针
csrw sstatus, t0
csrw sepc, t1
csrw sscratch, t2  # 恢复用户栈到 sscratch

ld x1, 1*8(sp)     # 恢复 ra
ld x3, 3*8(sp)     # 恢复 gp
.set n, 5
.rept 27           # 循环恢复 x5-x31
    LOAD_GP %n
    .set n, n+1
.endr

addi sp, sp, 34*8  # 释放 TrapContext 空间
csrrw sp, sscratch, sp  # 切换回用户栈
sret               # 返回用户态

// os/src/trap/mod.rs

#[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) => {
            cx.sepc += 4;
            cx.x[10] = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]) as usize;
        }
        Trap::Exception(Exception::StoreFault) |
        Trap::Exception(Exception::StorePageFault) => {
            println!("[kernel] PageFault in application, core dumped.");
            run_next_app();
        }
        Trap::Exception(Exception::IllegalInstruction) => {
            println!("[kernel] IllegalInstruction in application, core dumped.");
            run_next_app();
        }
        _ => {
            panic!("Unsupported trap {:?}, stval = {:#x}!", scause.cause(), stval);
        }
    }
    cx
}