OS 简单教程四
特权级
目标是这次也打印 Hello OS 不同的是，这是在用户态运行的应用。 为什么需要系统调用？特权？trap？CPU 虚拟化？直接都给权限，都在一个态不香么？试想一个应用就能破坏操作系统，操作系统多脆弱啊。应用有意无意的错误不要影响到操作系统和其他应用，这就需要硬件和操作系统配合来提供特权。应用只能运行在用户态，这样应用就可以放心使用 CPU ，这是 CPU 第一种虚拟化。 应用在用户态，操作系统在内核态。应用不能自己执行危险操作，想要执行必须通过系统调用委托给操作系统，而我们信赖操作系统。今天我们尝试在 k210 上实现特权级。
应用
像之前的内核一样，不同的是 lib.rs 内容是
#![no_std]
#![feature(asm)]
#![feature(linkage)]
use scall_os::{sys_exit, sys_write};
#[macro_use]
pub mod console;
mod lang;
mod scall_os;
#[no_mangle]
#[link_section = ".text.entry2"]
pub extern "C" fn _start() -> ! {
clear_bss();
exit(main());
panic!("unreachable after sys_exit!");
}
#[linkage = "weak"]
#[no_mangle]
fn main() -> i32 {
panic!("Cannot find main!");
}
fn clear_bss() {
extern "C" {
fn start_bss();
fn end_bss();
}
(start_bss as usize..end_bss as usize).for_each(|addr| {
unsafe { (addr as *mut u8).write_volatile(0); }
});
}
pub fn write(fd: usize, buf: &[u8]) -> isize { sys_write(fd, buf) }
pub fn exit(exit_code: i32) -> isize { sys_exit(exit_code) }可以看见入口是 _start ，先给全局未初始化的变量都赋值 0 ，然后调用 main 函数，最后系统调用 OS 退出应用。注意 main 函数是 weak 的，链接的时候如果有 strong 就用 strong ，而他在 user/bin/hello.rs
#![no_std]
#![no_main]
#![feature(llvm_asm)]
#[macro_use]
extern crate user;
#[no_mangle]
fn main() -> i32 {
println!("Hello OS");
0
}根据 rust 的规范，bin 下的文件会独立构建成可执行文件
trap
trap 是不是很耳熟，应用要打印就会用 ecall 触发 trap ，我们先来实现 trap 。 先来看 trap 的初始化，trap/mod.rs 的内容
pub fn init() {
extern "C" {
fn __alltraps();
}
unsafe {
stvec::write(__alltraps as usize, TrapMode::Direct);
}
}这个 init 函数在 main.rs 调用。 那 __alltraps 是什么呢？trap/trap.asm 的内容
.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__alltraps 都干了什么呢？应用运行要使用寄存器，于是系统调用前就保存寄存器、之后再恢复。sepc 寄存器比较特殊，trap 之后由它来决定后面执行什么。我们也可以利用它来执行第一个应用，一会就看见了。alltraps 最后 call trap_handler ，trap_handler 最后根据 system call id 来决定到底该调用哪个系统调用，这里用的 linux 的系统调用规范，当然也可以用别的，约定好就行。 我们再看看 trap/mod.rs 的最后的内容，包含 trap_handler
use riscv::register::{
scause::{self, Exception, Trap},
stval, stvec,
utvec::TrapMode,
};
pub use trap_ctx::TrapContext;
use crate::scall_sbi::syscall;
mod trap_ctx;
global_asm!(include_str!("trap.asm"));
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) => {
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.");
panic!("StoreFault!");
}
Trap::Exception(Exception::IllegalInstruction) => {
println!("[kernel] IllegalInstruction in application, core dumped.");
panic!("IllegalInstruction!");
}
_ => {
panic!(
"Unsupported trap {:?}, stval = {:#x}!",
scause.cause(),
stval
);
}
}
cx
}task
那应用第一怎么执行的呢？
- 把应用放到内核数据段
- 用符号确定应用的位置
- 把应用复制到 0x80400000
- 应用的内存布局也是 0x80400000 开头，因为内存地址有用到绝对地址
- 最后从 0x80400000 开始执行
- 1、2 是由 build.rs 根据应用生成的，build.rs 在 cargo build 时候自动调用，生成 link_app.S ，我们看看它
.align 3
.section .data
.global _num_app
_num_app:
.quad 1
.quad app_0_start
.quad app_0_end
.section .data
.global app_0_start
.global app_0_end
app_0_start:
.incbin "../user/target/riscv64gc-unknown-none-elf/release/hello.bin"
app_0_end:可以看到应用在内核的数据段，start 和 end 符号指定了应用的开始和结束地址
- 3 是由 task/mod.rs 的 load_app 函数负责把应用复制到 0x80400000
unsafe fn load_app(&self) {
// 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[0] as *const u8,
self.app_start[1] - self.app_start[0],
);
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);
}- 4 是由 user/src/link.ld 指定应用的内存布局，应用的内存布局也是 0x80400000 开头，因为内存地址有用到绝对地址
OUTPUT_ARCH(riscv)
ENTRY(_start)
BASE_ADDRESS = 0x80400000;
SECTIONS
{
. = BASE_ADDRESS;
.text : {
*(.text.entry2)
*(.text .text.*)
}
.rodata : {
*(.rodata .rodata.*)
*(.srodata .srodata.*)
}
.data : {
*(.data .data.*)
*(.sdata .sdata.*)
}
.bss : {
start_bss = .;
*(.bss .bss.*)
*(.sbss .sbss.*)
end_bss = .;
}
/DISCARD/ : {
*(.eh_frame)
*(.debug*)
}
}- 最后我们看看应用是怎么执行的 ，task/mod.rs/run 函数
pub fn run() -> ! {
unsafe {
APP_MANAGER.inner.borrow().load_app();
}
extern "C" {
fn __restore(cx_addr: usize);
}
unsafe {
__restore(KERNEL_STACK.push_context(TrapContext::app_init_context(
APP_BASE_ADDRESS,
USER_STACK.get_sp(),
)) as *const _ as usize);
}
panic!("Unreachable in task::run!");
}__restore 汇编函数会设置 sepc 寄存器的值，sepc 刚好被设置成 0x80400000 ，下一条指令就是 0x80400000 啦。 One more thing. 看看结果
[rustsbi] RustSBI version 0.2.0-alpha.3
.______ __ __ _______.___________. _______..______ __
| _ \ | | | | / | | / || _ \ | |
| |_) | | | | | | (----`---| |----`| (----`| |_) || |
| / | | | | \ \ | | \ \ | _ < | |
| |\ \----.| `--' |.----) | | | .----) | | |_) || |
| _| `._____| \______/ |_______/ |__| |_______/ |______/ |__|
[rustsbi] Platform: K210 (Version 0.2.0)
[rustsbi] misa: RV64ACDFIMSU
[rustsbi] mideleg: 0x22
[rustsbi] medeleg: 0x1ab
[rustsbi] Kernel entry: 0x80020000
[kernel] app_0 [0x8002b018, 0x8002b938)
Hello OS from app
[kernel] Application exited with code 0具体完整代码可参考 https://github.com/buhe/bugu/tree/0.2.0