Merge pull request #38 from zhanghx0905/ch4

[Ch4] update user module to 2021autumn version

.gitignore

@@ -1,10 +1,7 @@
-.idea/*
-os/target/*
-os/.idea/*
+.idea
+Cargo.lock
+target
 os/src/link_app.S
 os/last-*
-os/Cargo.lock
-user/target/*
-user/.idea/*
-user/Cargo.lock
-tools/
+user/build
+tools

os/Makefile

@@ -29,6 +29,8 @@ OBJCOPY := rust-objcopy --binary-architecture=riscv64
 # Disassembly
 DISASM ?= -x
 
+TEST ?= 0
+
 build: env switch-check $(KERNEL_BIN)
 
 switch-check:
@@ -48,7 +50,7 @@ $(KERNEL_BIN): kernel
 	@$(OBJCOPY) $(KERNEL_ELF) --strip-all -O binary $@
 
 kernel:
-	@cd ../user && make build
+	@cd ../user && make build TEST=$(TEST)
 	@echo Platform: $(BOARD)
 	@cp src/linker-$(BOARD).ld src/linker.ld
 	@cargo build --release --features "board_$(BOARD)"

os/build.rs

@@ -1,5 +1,5 @@
+use std::fs::{read_dir, File};
 use std::io::{Result, Write};
-use std::fs::{File, read_dir};
 
 fn main() {
     println!("cargo:rerun-if-changed=../user/src/");
@@ -7,11 +7,11 @@ fn main() {
     insert_app_data().unwrap();
 }
 
-static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/release/";
+static TARGET_PATH: &str = "../user/build/elf/";
 
 fn insert_app_data() -> Result<()> {
     let mut f = File::create("src/link_app.S").unwrap();
-    let mut apps: Vec<_> = read_dir("../user/src/bin")
+    let mut apps: Vec<_> = read_dir("../user/build/elf/")
         .unwrap()
         .into_iter()
         .map(|dir_entry| {
@@ -22,12 +22,16 @@ fn insert_app_data() -> Result<()> {
         .collect();
     apps.sort();
 
-    writeln!(f, r#"
+    writeln!(
+        f,
+        r#"
     .align 3
     .section .data
     .global _num_app
 _num_app:
-    .quad {}"#, apps.len())?;
+    .quad {}"#,
+        apps.len()
+    )?;
 
     for i in 0..apps.len() {
         writeln!(f, r#"    .quad app_{}_start"#, i)?;
@@ -36,14 +40,16 @@ _num_app:
 
     for (idx, app) in apps.iter().enumerate() {
         println!("app_{}: {}", idx, app);
-        writeln!(f, r#"
+        writeln!(
+            f,
+            r#"
     .section .data
     .global app_{0}_start
     .global app_{0}_end
     .align 3
 app_{0}_start:
-    .incbin "{2}{1}"
+    .incbin "{2}{1}.elf"
 app_{0}_end:"#, idx, app, TARGET_PATH)?;
     }
     Ok(())
-}
+}

os/src/syscall/mod.rs

@@ -14,7 +14,7 @@ pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
         SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
         SYSCALL_EXIT => sys_exit(args[0] as i32),
         SYSCALL_YIELD => sys_yield(),
-        SYSCALL_GET_TIME => sys_get_time(),
+        SYSCALL_GET_TIME => sys_get_time(args[0] as *mut TimeVal, args[1]),
         _ => panic!("Unsupported syscall_id: {}", syscall_id),
     }
 }

os/src/syscall/process.rs

@@ -2,7 +2,14 @@ use crate::task::{
     suspend_current_and_run_next,
     exit_current_and_run_next,
 };
-use crate::timer::get_time_ms;
+use crate::timer::get_time_us;
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct TimeVal {
+    pub sec: usize,
+    pub usec: usize,
+}
 
 pub fn sys_exit(exit_code: i32) -> ! {
     println!("[kernel] Application exited with code {}", exit_code);
@@ -15,6 +22,13 @@ pub fn sys_yield() -> isize {
     0
 }
 
-pub fn sys_get_time() -> isize {
-    get_time_ms() as isize
+pub fn sys_get_time(_ts: *mut TimeVal, _tz: usize) -> isize {
+    let _us = get_time_us();
+    // unsafe {
+    //     *ts = TimeVal {
+    //         sec: us / 1_000_000,
+    //         usec: us % 1_000_000,
+    //     };
+    // }
+    0
 }

os/src/timer.rs

@@ -1,16 +1,16 @@
-use riscv::register::time;
-use crate::sbi::set_timer;
 use crate::config::CLOCK_FREQ;
+use crate::sbi::set_timer;
+use riscv::register::time;
 
 const TICKS_PER_SEC: usize = 100;
-const MSEC_PER_SEC: usize = 1000;
+const MICRO_PER_SEC: usize = 1_000_000;
 
 pub fn get_time() -> usize {
     time::read()
 }
 
-pub fn get_time_ms() -> usize {
-    time::read() / (CLOCK_FREQ / MSEC_PER_SEC)
+pub fn get_time_us() -> usize {
+    time::read() / (CLOCK_FREQ / MICRO_PER_SEC)
 }
 
 pub fn set_next_trigger() {

user/Cargo.toml

@@ -7,3 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+buddy_system_allocator = "0.6"
+bitflags = "1.2.1"
+spin = "0.9"
+lazy_static = { version = "1.4.0", features = ["spin_no_std"] }

user/Makefile

@@ -2,22 +2,39 @@ TARGET := riscv64gc-unknown-none-elf
 MODE := release
 APP_DIR := src/bin
 TARGET_DIR := target/$(TARGET)/$(MODE)
-APPS := $(wildcard $(APP_DIR)/*.rs)
-ELFS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%, $(APPS))
-BINS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%.bin, $(APPS))
-
+BUILD_DIR := build
 OBJDUMP := rust-objdump --arch-name=riscv64
 OBJCOPY := rust-objcopy --binary-architecture=riscv64
+PY := python3
+
+TEST ?= 0
+ifeq ($(TEST), 0)
+	APPS :=  $(filter-out $(wildcard $(APP_DIR)/test*.rs), $(wildcard $(APP_DIR)/*.rs))
+else
+	APPS :=  $(wildcard $(APP_DIR)/test$(TEST)*.rs)
+endif
+ELFS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%, $(APPS))
 
 elf: $(APPS)
 	@cargo build --release
 
 binary: elf
-	$(foreach elf, $(ELFS), $(OBJCOPY) $(elf) --strip-all -O binary $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.bin, $(elf));)
+	@$(foreach elf, $(ELFS), \
+		$(OBJCOPY) $(elf) --strip-all -O binary $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.bin, $(elf)); \
+		cp $(elf) $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.elf, $(elf));)
 
-build: binary
+pre:
+	@mkdir -p $(BUILD_DIR)/bin/
+	@mkdir -p $(BUILD_DIR)/elf/
+	@mkdir -p $(BUILD_DIR)/app/
+	@$(foreach t, $(APPS), cp $(t) $(BUILD_DIR)/app/;)
+	
+build: clean pre binary 
+	@$(foreach t, $(ELFS), cp $(t).bin $(BUILD_DIR)/bin/;)
+	@$(foreach t, $(ELFS), cp $(t).elf $(BUILD_DIR)/elf/;)
 
 clean:
 	@cargo clean
+	@rm -rf $(BUILD_DIR)
 
 .PHONY: elf binary build clean

user/src/bin/00power_3.rs

@@ -26,4 +26,4 @@ unsafe fn main() -> i32 {
     println!("{}^{} = {}(MOD {})", p, iter, S[cur], m);
     println!("Test power_3 OK!");
     0
-}
+}

user/src/bin/03sleep.rs

@@ -1,18 +0,0 @@
-#![no_std]
-#![no_main]
-
-#[macro_use]
-extern crate user_lib;
-
-use user_lib::{get_time, yield_};
-
-#[no_mangle]
-fn main() -> i32 {
-    let current_timer = get_time();
-    let wait_for = current_timer + 3000;
-    while get_time() < wait_for {
-        yield_();
-    }
-    println!("Test sleep OK!");
-    0
-}

user/src/bin/test1_sleep.rs

@@ -0,0 +1,24 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::{get_time, yield_};
+
+/// 正确输出：（无报错信息）
+/// get_time OK! {...}
+/// Test sleep OK!
+
+#[no_mangle]
+fn main() -> i32 {
+    let current_time = get_time();
+    assert!(current_time > 0);
+    println!("get_time OK! {}", current_time);
+    let wait_for = current_time + 3000;
+    while get_time() < wait_for {
+        yield_();
+    }
+    println!("Test sleep OK!");
+    0
+}

user/src/bin/test1_sleep1.rs

@@ -0,0 +1,22 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::{get_time, sleep};
+
+#[no_mangle]
+pub fn main() -> i32 {
+    let start = get_time();
+    println!("current time_msec = {}", start);
+    sleep(100);
+    let end = get_time();
+    println!(
+        "time_msec = {} after sleeping 100 ticks, delta = {}ms!",
+        end,
+        end - start
+    );
+    println!("Test sleep1 passed!");
+    0
+}

user/src/bin/test2_mmap0.rs

@@ -0,0 +1,33 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::mmap;
+
+/*
+理想结果：输出 Test 04_1 OK!
+*/
+
+#[no_mangle]
+fn main() -> i32 {
+    let start: usize = 0x10000000;
+    let len: usize = 4096;
+    let prot: usize = 3;
+    assert_eq!(0, mmap(start, len, prot));
+    for i in start..(start + len) {
+        let addr: *mut u8 = i as *mut u8;
+        unsafe {
+            *addr = i as u8;
+        }
+    }
+    for i in start..(start + len) {
+        let addr: *mut u8 = i as *mut u8;
+        unsafe {
+            assert_eq!(*addr, i as u8);
+        }
+    }
+    println!("Test 04_1 OK!");
+    0
+}

user/src/bin/test2_mmap1.rs

@@ -0,0 +1,25 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::mmap;
+
+/*
+理想结果：程序触发访存异常，被杀死。不输出 error 就算过。
+*/
+
+#[no_mangle]
+fn main() -> i32 {
+    let start: usize = 0x10000000;
+    let len: usize = 4096;
+    let prot: usize = 1;
+    assert_eq!(0, mmap(start, len, prot));
+    let addr: *mut u8 = start as *mut u8;
+    unsafe {
+        *addr = start as u8;
+    }
+    println!("Should cause error, Test 04_2 fail!");
+    0
+}

user/src/bin/test2_mmap2.rs

@@ -0,0 +1,26 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::mmap;
+
+/*
+理想结果：程序触发访存异常，被杀死。不输出 error 就算过。
+*/
+
+#[no_mangle]
+fn main() -> i32 {
+    let start: usize = 0x10000000;
+    let len: usize = 4096;
+    let prot: usize = 2;
+    assert_eq!(0, mmap(start, len, prot));
+    let addr: *mut u8 = start as *mut u8;
+    unsafe {
+        // *addr = start as u8; // can't write, R == 0 && W == 1 is illegal in riscv
+        assert!(*addr != 0);
+    }
+    println!("Should cause error, Test 04_2 fail!");
+    0
+}

user/src/bin/test2_mmap3.rs

@@ -0,0 +1,25 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::mmap;
+
+/*
+理想结果：对于错误的 mmap 返回 -1，最终输出 Test 04_4 test OK!
+*/
+
+#[no_mangle]
+fn main() -> i32 {
+    let start: usize = 0x10000000;
+    let len: usize = 4096;
+    let prot: usize = 3;
+    assert_eq!(0, mmap(start, len, prot));
+    assert_eq!(mmap(start - len, len + 1, prot), -1);
+    assert_eq!(mmap(start + len + 1, len, prot), -1);
+    assert_eq!(mmap(start + len, len, 0), -1);
+    assert_eq!(mmap(start + len, len, prot | 8), -1);
+    println!("Test 04_4 test OK!");
+    0
+}

user/src/bin/test2_unmap.rs

@@ -0,0 +1,36 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::{mmap, munmap};
+
+/*
+理想结果：输出 Test 04_5 ummap OK!
+*/
+
+#[no_mangle]
+fn main() -> i32 {
+    let start: usize = 0x10000000;
+    let len: usize = 4096;
+    let prot: usize = 3;
+    assert_eq!(0, mmap(start, len, prot));
+    assert_eq!(mmap(start + len, len * 2, prot), 0);
+    assert_eq!(munmap(start, len), 0);
+    assert_eq!(mmap(start - len, len + 1, prot), 0);
+    for i in (start - len)..(start + len * 3) {
+        let addr: *mut u8 = i as *mut u8;
+        unsafe {
+            *addr = i as u8;
+        }
+    }
+    for i in (start - len)..(start + len * 3) {
+        let addr: *mut u8 = i as *mut u8;
+        unsafe {
+            assert_eq!(*addr, i as u8);
+        }
+    }
+    println!("Test 04_5 ummap OK!");
+    0
+}

user/src/bin/test2_unmap2.rs

@@ -0,0 +1,23 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::{mmap, munmap};
+
+/*
+理想结果：输出 Test 04_6 ummap2 OK!
+*/
+
+#[no_mangle]
+fn main() -> i32 {
+    let start: usize = 0x10000000;
+    let len: usize = 4096;
+    let prot: usize = 3;
+    assert_eq!(0, mmap(start, len, prot));
+    assert_eq!(munmap(start, len + 1), -1);
+    assert_eq!(munmap(start + 1, len - 1), -1);
+    println!("Test 04_6 ummap2 OK!");
+    0
+}

user/src/console.rs

@@ -1,19 +1,52 @@
+use alloc::collections::vec_deque::VecDeque;
+use alloc::sync::Arc;
 use core::fmt::{self, Write};
-use super::write;
+use spin::mutex::Mutex;
 
-struct Stdout;
+pub const STDIN: usize = 0;
+pub const STDOUT: usize = 1;
 
-const STDOUT: usize = 1;
+const CONSOLE_BUFFER_SIZE: usize = 256 * 10;
 
-impl Write for Stdout {
+use super::{read, write};
+use lazy_static::*;
+
+struct ConsoleBuffer(VecDeque<u8>);
+
+lazy_static! {
+    static ref CONSOLE_BUFFER: Arc<Mutex<ConsoleBuffer>> = {
+        let buffer = VecDeque::<u8>::with_capacity(CONSOLE_BUFFER_SIZE);
+        Arc::new(Mutex::new(ConsoleBuffer(buffer)))
+    };
+}
+
+impl ConsoleBuffer {
+    fn flush(&mut self) -> isize {
+        let s: &[u8] = self.0.make_contiguous();
+        let ret = write(STDOUT, s);
+        self.0.clear();
+        ret
+    }
+}
+
+impl Write for ConsoleBuffer {
     fn write_str(&mut self, s: &str) -> fmt::Result {
-        write(STDOUT, s.as_bytes());
+        for c in s.as_bytes().iter() {
+            self.0.push_back(*c);
+            if (*c == b'\n' || self.0.len() == CONSOLE_BUFFER_SIZE) && -1 == self.flush() {
+                return Err(fmt::Error);
+            }
+        }
         Ok(())
     }
 }
 
+#[allow(unused)]
 pub fn print(args: fmt::Arguments) {
-    Stdout.write_fmt(args).unwrap();
+    let mut buf = CONSOLE_BUFFER.lock();
+    // buf.write_fmt(args).unwrap();
+    // BUG FIX: 关闭 stdout 后，本函数不能触发 panic，否则会造成死锁
+    buf.write_fmt(args);
 }
 
 #[macro_export]
@@ -28,4 +61,15 @@ macro_rules! println {
     ($fmt: literal $(, $($arg: tt)+)?) => {
         $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
     }
-}
+}
+
+pub fn getchar() -> u8 {
+    let mut c = [0u8; 1];
+    read(STDIN, &mut c);
+    c[0]
+}
+
+pub fn flush() {
+    let mut buf = CONSOLE_BUFFER.lock();
+    buf.flush();
+}

user/src/lang_items.rs

@@ -1,10 +1,17 @@
+use crate::exit;
+
 #[panic_handler]
 fn panic_handler(panic_info: &core::panic::PanicInfo) -> ! {
     let err = panic_info.message().unwrap();
     if let Some(location) = panic_info.location() {
-        println!("Panicked at {}:{}, {}", location.file(), location.line(), err);
+        println!(
+            "Panicked at {}:{}, {}",
+            location.file(),
+            location.line(),
+            err
+        );
     } else {
         println!("Panicked: {}", err);
     }
-    loop {}
-}
+    exit(-1);
+}

user/src/lib.rs

@@ -2,17 +2,42 @@
 #![feature(asm)]
 #![feature(linkage)]
 #![feature(panic_info_message)]
+#![feature(alloc_error_handler)]
 
 #[macro_use]
 pub mod console;
-mod syscall;
 mod lang_items;
+mod syscall;
+
+extern crate alloc;
+extern crate core;
+#[macro_use]
+extern crate bitflags;
+
+use buddy_system_allocator::LockedHeap;
+pub use console::{flush, STDIN, STDOUT};
+pub use syscall::*;
+
+const USER_HEAP_SIZE: usize = 16384;
+
+static mut HEAP_SPACE: [u8; USER_HEAP_SIZE] = [0; USER_HEAP_SIZE];
+
+#[global_allocator]
+static HEAP: LockedHeap = LockedHeap::empty();
+
+#[alloc_error_handler]
+pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! {
+    panic!("Heap allocation error, layout = {:?}", layout);
+}
 
 #[no_mangle]
 #[link_section = ".text.entry"]
 pub extern "C" fn _start() -> ! {
+    unsafe {
+        HEAP.lock()
+            .init(HEAP_SPACE.as_ptr() as usize, USER_HEAP_SIZE);
+    }
     exit(main());
-    panic!("unreachable after sys_exit!");
 }
 
 #[linkage = "weak"]
@@ -21,10 +46,194 @@ fn main() -> i32 {
     panic!("Cannot find main!");
 }
 
+bitflags! {
+    pub struct OpenFlags: u32 {
+        const RDONLY = 0;
+        const WRONLY = 1 << 0;
+        const RDWR = 1 << 1;
+        const CREATE = 1 << 9;
+        const TRUNC = 1 << 10;
+    }
+}
 
-use syscall::*;
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct TimeVal {
+    pub sec: usize,
+    pub usec: usize,
+}
+
+impl TimeVal {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct Stat {
+    /// ID of device containing file
+    pub dev: u64,
+    /// inode number
+    pub ino: u64,
+    /// file type and mode
+    pub mode: StatMode,
+    /// number of hard links
+    pub nlink: u32,
+    /// unused pad
+    pad: [u64; 7],
+}
+
+impl Stat {
+    pub fn new() -> Self {
+        Stat {
+            dev: 0,
+            ino: 0,
+            mode: StatMode::NULL,
+            nlink: 0,
+            pad: [0; 7],
+        }
+    }
+}
+
+impl Default for Stat {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+bitflags! {
+    pub struct StatMode: u32 {
+        const NULL  = 0;
+        /// directory
+        const DIR   = 0o040000;
+        /// ordinary regular file
+        const FILE  = 0o100000;
+    }
+}
+
+const AT_FDCWD: isize = -100;
+
+pub fn open(path: &str, flags: OpenFlags) -> isize {
+    sys_openat(AT_FDCWD as usize, path, flags.bits, OpenFlags::RDWR.bits)
+}
+
+pub fn close(fd: usize) -> isize {
+    if fd == STDOUT {
+        console::flush();
+    }
+    sys_close(fd)
+}
+
+pub fn read(fd: usize, buf: &mut [u8]) -> isize {
+    sys_read(fd, buf)
+}
+
+pub fn write(fd: usize, buf: &[u8]) -> isize {
+    sys_write(fd, buf)
+}
+
+pub fn link(old_path: &str, new_path: &str) -> isize {
+    sys_linkat(AT_FDCWD as usize, old_path, AT_FDCWD as usize, new_path, 0)
+}
+
+pub fn unlink(path: &str) -> isize {
+    sys_unlinkat(AT_FDCWD as usize, path, 0)
+}
 
-pub fn write(fd: usize, buf: &[u8]) -> isize { sys_write(fd, buf) }
-pub fn exit(exit_code: i32) -> isize { sys_exit(exit_code) }
-pub fn yield_() -> isize { sys_yield() }
-pub fn get_time() -> isize { sys_get_time() }
+pub fn fstat(fd: usize, st: &Stat) -> isize {
+    sys_fstat(fd, st)
+}
+
+pub fn mail_read(buf: &mut [u8]) -> isize {
+    sys_mail_read(buf)
+}
+
+pub fn mail_write(pid: usize, buf: &[u8]) -> isize {
+    sys_mail_write(pid, buf)
+}
+
+pub fn exit(exit_code: i32) -> ! {
+    console::flush();
+    sys_exit(exit_code);
+}
+
+pub fn yield_() -> isize {
+    sys_yield()
+}
+
+pub fn get_time() -> isize {
+    let time = TimeVal::new();
+    match sys_get_time(&time, 0) {
+        0 => ((time.sec & 0xffff) * 1000 + time.usec / 1000) as isize,
+        _ => -1,
+    }
+}
+
+pub fn getpid() -> isize {
+    sys_getpid()
+}
+
+pub fn fork() -> isize {
+    sys_fork()
+}
+
+pub fn exec(path: &str) -> isize {
+    sys_exec(path)
+}
+
+pub fn set_priority(prio: isize) -> isize {
+    sys_set_priority(prio)
+}
+
+pub fn wait(exit_code: &mut i32) -> isize {
+    loop {
+        match sys_waitpid(-1, exit_code as *mut _) {
+            -2 => {
+                sys_yield();
+            }
+            n => {
+                return n;
+            }
+        }
+    }
+}
+
+pub fn waitpid(pid: usize, exit_code: &mut i32) -> isize {
+    loop {
+        match sys_waitpid(pid as isize, exit_code as *mut _) {
+            -2 => {
+                sys_yield();
+            }
+            n => {
+                return n;
+            }
+        }
+    }
+}
+
+pub fn sleep(period_ms: usize) {
+    let start = get_time();
+    while get_time() < start + period_ms as isize {
+        sys_yield();
+    }
+}
+
+pub fn mmap(start: usize, len: usize, prot: usize) -> isize {
+    sys_mmap(start, len, prot)
+}
+
+pub fn munmap(start: usize, len: usize) -> isize {
+    sys_munmap(start, len)
+}
+
+pub fn spawn(path: &str) -> isize {
+    sys_spawn(path)
+}
+
+pub fn dup(fd: usize) -> isize {
+    sys_dup(fd)
+}
+pub fn pipe(pipe_fd: &mut [usize]) -> isize {
+    sys_pipe(pipe_fd)
+}

user/src/syscall.rs

@@ -1,9 +1,43 @@
-const SYSCALL_WRITE: usize = 64;
-const SYSCALL_EXIT: usize = 93;
-const SYSCALL_YIELD: usize = 124;
-const SYSCALL_GET_TIME: usize = 169;
+use super::{Stat, TimeVal};
 
-fn syscall(id: usize, args: [usize; 3]) -> isize {
+pub const SYSCALL_OPENAT: usize = 56;
+pub const SYSCALL_CLOSE: usize = 57;
+pub const SYSCALL_READ: usize = 63;
+pub const SYSCALL_WRITE: usize = 64;
+pub const SYSCALL_UNLINKAT: usize = 35;
+pub const SYSCALL_LINKAT: usize = 37;
+pub const SYSCALL_FSTAT: usize = 80;
+pub const SYSCALL_EXIT: usize = 93;
+pub const SYSCALL_YIELD: usize = 124;
+pub const SYSCALL_GETTIMEOFDAY: usize = 169;
+pub const SYSCALL_GETPID: usize = 172;
+pub const SYSCALL_FORK: usize = 220;
+pub const SYSCALL_EXEC: usize = 221;
+pub const SYSCALL_WAITPID: usize = 260;
+pub const SYSCALL_SET_PRIORITY: usize = 140;
+pub const SYSCALL_MUNMAP: usize = 215;
+pub const SYSCALL_MMAP: usize = 222;
+pub const SYSCALL_SPAWN: usize = 400;
+pub const SYSCALL_MAIL_READ: usize = 401;
+pub const SYSCALL_MAIL_WRITE: usize = 402;
+pub const SYSCALL_DUP: usize = 24;
+pub const SYSCALL_PIPE: usize = 59;
+
+pub 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
+}
+
+pub fn syscall6(id: usize, args: [usize; 6]) -> isize {
     let mut ret: isize;
     unsafe {
         asm!(
@@ -11,24 +45,135 @@ fn syscall(id: usize, args: [usize; 3]) -> isize {
             inlateout("x10") args[0] => ret,
             in("x11") args[1],
             in("x12") args[2],
+            in("x13") args[3],
+            in("x14") args[4],
+            in("x15") args[5],
             in("x17") id
         );
     }
     ret
 }
 
+pub fn sys_openat(dirfd: usize, path: &str, flags: u32, mode: u32) -> isize {
+    syscall6(
+        SYSCALL_OPENAT,
+        [
+            dirfd,
+            path.as_ptr() as usize,
+            flags as usize,
+            mode as usize,
+            0,
+            0,
+        ],
+    )
+}
+
+pub fn sys_close(fd: usize) -> isize {
+    syscall(SYSCALL_CLOSE, [fd, 0, 0])
+}
+
+pub fn sys_read(fd: usize, buffer: &mut [u8]) -> isize {
+    syscall(
+        SYSCALL_READ,
+        [fd, buffer.as_mut_ptr() as usize, buffer.len()],
+    )
+}
+
 pub fn sys_write(fd: usize, buffer: &[u8]) -> isize {
     syscall(SYSCALL_WRITE, [fd, buffer.as_ptr() as usize, buffer.len()])
 }
 
-pub fn sys_exit(exit_code: i32) -> isize {
-    syscall(SYSCALL_EXIT, [exit_code as usize, 0, 0])
+pub fn sys_linkat(
+    old_dirfd: usize,
+    old_path: &str,
+    new_dirfd: usize,
+    new_path: &str,
+    flags: usize,
+) -> isize {
+    syscall6(
+        SYSCALL_LINKAT,
+        [
+            old_dirfd,
+            old_path.as_ptr() as usize,
+            new_dirfd,
+            new_path.as_ptr() as usize,
+            flags,
+            0,
+        ],
+    )
+}
+
+pub fn sys_unlinkat(dirfd: usize, path: &str, flags: usize) -> isize {
+    syscall(SYSCALL_UNLINKAT, [dirfd, path.as_ptr() as usize, flags])
+}
+
+pub fn sys_fstat(fd: usize, st: &Stat) -> isize {
+    syscall(SYSCALL_FSTAT, [fd, st as *const _ as usize, 0])
+}
+
+pub fn sys_mail_read(buffer: &mut [u8]) -> isize {
+    syscall(
+        SYSCALL_MAIL_READ,
+        [buffer.as_ptr() as usize, buffer.len(), 0],
+    )
+}
+
+pub fn sys_mail_write(pid: usize, buffer: &[u8]) -> isize {
+    syscall(
+        SYSCALL_MAIL_WRITE,
+        [pid, buffer.as_ptr() as usize, buffer.len()],
+    )
+}
+
+pub fn sys_exit(exit_code: i32) -> ! {
+    syscall(SYSCALL_EXIT, [exit_code as usize, 0, 0]);
+    panic!("sys_exit never returns!");
 }
 
 pub fn sys_yield() -> isize {
     syscall(SYSCALL_YIELD, [0, 0, 0])
 }
 
-pub fn sys_get_time() -> isize {
-    syscall(SYSCALL_GET_TIME, [0, 0, 0])
-}
+pub fn sys_get_time(time: &TimeVal, tz: usize) -> isize {
+    syscall(SYSCALL_GETTIMEOFDAY, [time as *const _ as usize, tz, 0])
+}
+
+pub fn sys_getpid() -> isize {
+    syscall(SYSCALL_GETPID, [0, 0, 0])
+}
+
+pub fn sys_fork() -> isize {
+    syscall(SYSCALL_FORK, [0, 0, 0])
+}
+
+pub fn sys_exec(path: &str) -> isize {
+    syscall(SYSCALL_EXEC, [path.as_ptr() as usize, 0, 0])
+}
+
+pub fn sys_waitpid(pid: isize, xstatus: *mut i32) -> isize {
+    syscall(SYSCALL_WAITPID, [pid as usize, xstatus as usize, 0])
+}
+
+pub fn sys_set_priority(prio: isize) -> isize {
+    syscall(SYSCALL_SET_PRIORITY, [prio as usize, 0, 0])
+}
+
+pub fn sys_mmap(start: usize, len: usize, prot: usize) -> isize {
+    syscall(SYSCALL_MMAP, [start, len, prot])
+}
+
+pub fn sys_munmap(start: usize, len: usize) -> isize {
+    syscall(SYSCALL_MUNMAP, [start, len, 0])
+}
+
+pub fn sys_spawn(path: &str) -> isize {
+    syscall(SYSCALL_SPAWN, [path.as_ptr() as usize, 0, 0])
+}
+
+pub fn sys_dup(fd: usize) -> isize {
+    syscall(SYSCALL_DUP, [fd, 0, 0])
+}
+
+pub fn sys_pipe(pipe: &mut [usize]) -> isize {
+    syscall(SYSCALL_PIPE, [pipe.as_mut_ptr() as usize, 0, 0])
+}