BatchOS¶

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

// user/src/syscall.rs
use core::arch::asm;
fn syscall(id: usize, args: [usize; 3]) -> isize {
    let mut ret: isize;
    unsafe {
        asm!(
            "ecall",
            inlateout("x10") args[0] => ret,
            in("x11") args[1],
            in("x12") args[2],
            in("x17") id
        );
    }
    ret
}
const SYSCALL_WRITE: usize = 64;
const SYSCALL_EXIT: usize = 93;

pub fn sys_write(fd: usize, buffer: &[u8]) -> isize {
    syscall(SYSCALL_WRITE, [fd, buffer.as_ptr() as usize, buffer.len()])
}

pub fn sys_exit(xstate: i32) -> isize {
    syscall(SYSCALL_EXIT, [xstate as usize, 0, 0])
}

// os/src/sync/up.rs

pub struct UPSafeCell<T> {
    /// inner data
    inner: RefCell<T>,
}

// unsafe向编译器保证只在单核上进行操作
unsafe impl<T> Sync for UPSafeCell<T> {}

impl<T> UPSafeCell<T> {
    /// User is responsible to guarantee that inner struct is only used in
    /// uniprocessor.
    pub unsafe fn new(value: T) -> Self {
        Self { inner: RefCell::new(value) }
    }
    /// Panic if the data has been borrowed.
    pub fn exclusive_access(&self) -> RefMut<'_, T> {
        self.inner.borrow_mut()
    }
}

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,
        }
    })
};

unsafe fn load_app(&self, app_id: usize) {
    if app_id >= self.num_app {
        println!("All applications completed!");
        shutdown(false);
    }
    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);
    // 将指针看作切片，使用拷贝实现App切换
    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");
}

/// run next app
pub fn run_next_app() -> ! {
    let mut app_manager = APP_MANAGER.exclusive_access();
    let current_app = app_manager.get_current_app();
    unsafe {
        app_manager.load_app(current_app);
    }
    app_manager.move_to_next_app();
    drop(app_manager);
    // before this we have to drop local variables related to resources manually
    // and release the resources
    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 batch::run_current_app!");
}

// os/src/trap/context.rs

#[repr(C)]
pub struct TrapContext {
    pub x: [usize; 32],
    pub sstatus: Sstatus,
    pub sepc: usize,
}

// os/src/trap/mod.rs

global_asm!(include_str!("trap.S"));

pub fn init() {
    extern "C" { fn __alltraps(); }
    unsafe {
        stvec::write(__alltraps as usize, TrapMode::Direct);
    }
}

// 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, kernel killed it.");
            run_next_app();
        }
        Trap::Exception(Exception::IllegalInstruction) => {
            println!("[kernel] IllegalInstruction in application, kernel killed it.");
            run_next_app();
        }
        _ => {
            panic!("Unsupported trap {:?}, stval = {:#x}!", scause.cause(), stval);
        }
    }
    cx
}

// batch.rs
/**
 * syscall num
 */
pub struct SyscallNum {
    num: [usize; SYSCALL_NUM],
}

impl SyscallNum {
    /**
     * get syscall num
     */
    pub fn get_syscall_num(&self, syscall_id: usize) -> usize {
        self.num[syscall_id]
    }
    /**
     * inc syscall num
     */
    pub fn inc_syscall_num(&mut self, syscall_id: usize) {
        self.num[syscall_id] += 1;
    }
}

lazy_static!{
     // ch2 add begin
    /**
     * syscall use syscall num
     */
    pub static ref NUM: UPSafeCell<SyscallNum> = unsafe {
        UPSafeCell::new({
            SyscallNum {
                num: [0; SYSCALL_NUM],
            }
        })
    };
}

// run_next_app
if current_app == APP_MANAGER.exclusive_access().num_app - 1 || current_app == 0 {
        println!(
            "sys_write num: {}",
            NUM.exclusive_access().get_syscall_num(0)
        );
        println!(
            "sys_exit num: {}",
            NUM.exclusive_access().get_syscall_num(1)
        );
    }

// syscall/mod.rs
use crate::batch::NUM;
/// handle syscall exception with `syscall_id` and other arguments
pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
    match syscall_id {
        SYSCALL_WRITE => {
            let ret = sys_write(args[0], args[1] as *const u8, args[2]);
            NUM.exclusive_access().inc_syscall_num(0);
            ret
        }
        SYSCALL_EXIT => {
            NUM.exclusive_access().inc_syscall_num(1);
            sys_exit(args[0] as i32)
        }
        _ => panic!("Unsupported syscall_id: {}", syscall_id),
    }

// batch.rs
/**
 * AppManager
 */
struct AppManager {
    num_app: usize,
    current_app: usize,
    app_start: [usize; MAX_APP_NUM + 1],
    // ch2 add begin
    app_runtime: [u64; MAX_APP_NUM],
    // ch2 add end
}

// run_next_app
// ch2 add begin

let time: u64;
unsafe {
    asm!("rdtime {0}", out(reg) time);
}
if current_app > 0 {
    let runtime = time - APP_MANAGER.exclusive_access().app_runtime[current_app - 1];
    APP_MANAGER
        .exclusive_access()
        .set_app_runtime(current_app - 1, runtime);
    println!(
        "[kernel] app_{} runs {} cycles",
        current_app - 1,
        APP_MANAGER
            .exclusive_access()
            .get_app_runtime(current_app - 1)
    );
}

// batch.rs
/**
 * Reliable address of program
 */
pub struct ReliableAddr {
    start: usize,
    end: usize,
}

impl ReliableAddr {
    /**
     * get reliable start addr
     */
    pub fn get_reliable_start(&self) -> usize {
        self.start
    }
    /**
     * get reliable end addr
     */
    pub fn get_reliable_end(&self) -> usize {
        self.end
    }
}

lazy_static!{
    /**
     * reliable addr init
     */
    pub static ref RE_ADDR:UPSafeCell<ReliableAddr> = unsafe {
        UPSafeCell::new({
            ReliableAddr {
                start: APP_BASE_ADDRESS,
                end: APP_BASE_ADDRESS + APP_SIZE_LIMIT,
            }
        })
    };
}

// run_next_app
// 注意数据需要使用clone()
let mut reliable_addr = RE_ADDR.exclusive_access();
reliable_addr.start = app_manager.app_start[current_app].clone();
reliable_addr.end = app_manager.app_start[current_app + 1].clone();
drop(reliable_addr);

// syscall/mod.rs
use crate::batch::RE_ADDR;

/// handle syscall exception with `syscall_id` and other arguments
pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
    match syscall_id {
        SYSCALL_WRITE => {
            let start_addr = RE_ADDR.exclusive_access().get_reliable_start();
            let end_addr = RE_ADDR.exclusive_access().get_reliable_end();
            if args[1] < start_addr {
                return -1;
            }
            if args[1] >= end_addr {
                return -1;
            }
            if args[1] + args[2] >= end_addr {
                return -1;
            }
            let ret = sys_write(args[0], args[1] as *const u8, args[2]);
            NUM.exclusive_access().inc_syscall_num(0);
            ret
        }
        SYSCALL_EXIT => {
            NUM.exclusive_access().inc_syscall_num(1);
            sys_exit(args[0] as i32)
        }
        _ => panic!("Unsupported syscall_id: {}", syscall_id),
    }
}