From 2a5b451d67ba3038122265642f3d0d60747f3802 Mon Sep 17 00:00:00 2001 From: zhanghx0905 <731931282@qq.com> Date: Fri, 19 Nov 2021 18:50:59 +0800 Subject: [PATCH 1/3] update user module to 2021autumn version --- .gitignore | 13 +- os/Makefile | 4 +- os/build.rs | 22 ++-- user/Cargo.toml | 4 + user/Makefile | 29 ++++- user/src/bin/00power_3.rs | 2 +- user/src/bin/03sleep.rs | 18 --- user/src/bin/test1_sleep.rs | 24 ++++ user/src/bin/test1_sleep1.rs | 22 ++++ user/src/bin/test2_mmap0.rs | 33 ++++++ user/src/bin/test2_mmap1.rs | 25 ++++ user/src/bin/test2_mmap2.rs | 26 ++++ user/src/bin/test2_mmap3.rs | 25 ++++ user/src/bin/test2_unmap.rs | 36 ++++++ user/src/bin/test2_unmap2.rs | 23 ++++ user/src/console.rs | 58 +++++++-- user/src/lang_items.rs | 13 +- user/src/lib.rs | 223 +++++++++++++++++++++++++++++++++-- user/src/syscall.rs | 165 ++++++++++++++++++++++++-- 19 files changed, 696 insertions(+), 69 deletions(-) delete mode 100644 user/src/bin/03sleep.rs create mode 100644 user/src/bin/test1_sleep.rs create mode 100644 user/src/bin/test1_sleep1.rs create mode 100644 user/src/bin/test2_mmap0.rs create mode 100644 user/src/bin/test2_mmap1.rs create mode 100644 user/src/bin/test2_mmap2.rs create mode 100644 user/src/bin/test2_mmap3.rs create mode 100644 user/src/bin/test2_unmap.rs create mode 100644 user/src/bin/test2_unmap2.rs diff --git a/.gitignore b/.gitignore index c44aa4fa..36e4d9eb 100644 --- a/.gitignore +++ b/.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 \ No newline at end of file diff --git a/os/Makefile b/os/Makefile index 35049e01..a9ed0b73 100644 --- a/os/Makefile +++ b/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)" diff --git a/os/build.rs b/os/build.rs index 07a25c99..0f247e3f 100644 --- a/os/build.rs +++ b/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(()) -} \ No newline at end of file +} diff --git a/user/Cargo.toml b/user/Cargo.toml index 817ca525..01b75c29 100644 --- a/user/Cargo.toml +++ b/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"] } diff --git a/user/Makefile b/user/Makefile index 5e0f87c3..58fab88c 100644 --- a/user/Makefile +++ b/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 \ No newline at end of file diff --git a/user/src/bin/00power_3.rs b/user/src/bin/00power_3.rs index e14f1e2b..125e6701 100644 --- a/user/src/bin/00power_3.rs +++ b/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 -} \ No newline at end of file +} diff --git a/user/src/bin/03sleep.rs b/user/src/bin/03sleep.rs deleted file mode 100644 index 83411233..00000000 --- a/user/src/bin/03sleep.rs +++ /dev/null @@ -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 -} \ No newline at end of file diff --git a/user/src/bin/test1_sleep.rs b/user/src/bin/test1_sleep.rs new file mode 100644 index 00000000..1312f6c3 --- /dev/null +++ b/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 +} diff --git a/user/src/bin/test1_sleep1.rs b/user/src/bin/test1_sleep1.rs new file mode 100644 index 00000000..da0cae32 --- /dev/null +++ b/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 +} diff --git a/user/src/bin/test2_mmap0.rs b/user/src/bin/test2_mmap0.rs new file mode 100644 index 00000000..5247eec2 --- /dev/null +++ b/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 +} diff --git a/user/src/bin/test2_mmap1.rs b/user/src/bin/test2_mmap1.rs new file mode 100644 index 00000000..63d6411d --- /dev/null +++ b/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 +} diff --git a/user/src/bin/test2_mmap2.rs b/user/src/bin/test2_mmap2.rs new file mode 100644 index 00000000..2489fa64 --- /dev/null +++ b/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 +} diff --git a/user/src/bin/test2_mmap3.rs b/user/src/bin/test2_mmap3.rs new file mode 100644 index 00000000..d9d04b61 --- /dev/null +++ b/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 +} diff --git a/user/src/bin/test2_unmap.rs b/user/src/bin/test2_unmap.rs new file mode 100644 index 00000000..b64f862f --- /dev/null +++ b/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 +} diff --git a/user/src/bin/test2_unmap2.rs b/user/src/bin/test2_unmap2.rs new file mode 100644 index 00000000..85ddb750 --- /dev/null +++ b/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 +} diff --git a/user/src/console.rs b/user/src/console.rs index ac801174..6d6d1f3a 100644 --- a/user/src/console.rs +++ b/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); + +lazy_static! { + static ref CONSOLE_BUFFER: Arc> = { + let buffer = VecDeque::::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)+)?)); } -} \ No newline at end of file +} + +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(); +} diff --git a/user/src/lang_items.rs b/user/src/lang_items.rs index c90d297f..2d81a1df 100644 --- a/user/src/lang_items.rs +++ b/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 {} -} \ No newline at end of file + exit(-1); +} diff --git a/user/src/lib.rs b/user/src/lib.rs index 1fae0fd2..d97fbf33 100644 --- a/user/src/lib.rs +++ b/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() } \ No newline at end of file +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) +} diff --git a/user/src/syscall.rs b/user/src/syscall.rs index ed3d16aa..7aaa584e 100644 --- a/user/src/syscall.rs +++ b/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]) -} \ No newline at end of file +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]) +} From bf8882a767c67169b0ca1162bc94ac0d7cc7cbeb Mon Sep 17 00:00:00 2001 From: zhanghx0905 <731931282@qq.com> Date: Fri, 19 Nov 2021 19:09:34 +0800 Subject: [PATCH 2/3] os gettime syscall consistent with user mod --- os/src/syscall/mod.rs | 2 +- os/src/syscall/process.rs | 24 +++++++++++++++++++++--- os/src/timer.rs | 10 +++++----- 3 files changed, 27 insertions(+), 9 deletions(-) diff --git a/os/src/syscall/mod.rs b/os/src/syscall/mod.rs index da411680..8ca22fe3 100644 --- a/os/src/syscall/mod.rs +++ b/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), } } diff --git a/os/src/syscall/process.rs b/os/src/syscall/process.rs index 23eab1ff..d0168494 100644 --- a/os/src/syscall/process.rs +++ b/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,17 @@ pub fn sys_yield() -> isize { 0 } -pub fn sys_get_time() -> isize { - get_time_ms() as isize +// 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 } \ No newline at end of file diff --git a/os/src/timer.rs b/os/src/timer.rs index 92d50e3a..7f78d6e4 100644 --- a/os/src/timer.rs +++ b/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() { From 4bf473af48f3261ced38c571383efd23972bb826 Mon Sep 17 00:00:00 2001 From: zhanghx0905 <731931282@qq.com> Date: Fri, 19 Nov 2021 21:07:33 +0800 Subject: [PATCH 3/3] remove wrong impl of gettime --- os/src/syscall/process.rs | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/os/src/syscall/process.rs b/os/src/syscall/process.rs index d0168494..17fc7051 100644 --- a/os/src/syscall/process.rs +++ b/os/src/syscall/process.rs @@ -22,17 +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, - }; - } +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 } \ No newline at end of file