Remove spin::Mutex in frame_allocator and memory_set.

.dockerignore

@@ -0,0 +1 @@
+*/*

.gitignore

@@ -2,7 +2,9 @@
 os/target/*
 os/.idea/*
 os/src/link_app.S
+os/last-*
 os/Cargo.lock
 user/target/*
 user/.idea/*
 user/Cargo.lock
+tools/

Dockerfile

@@ -0,0 +1,40 @@
+FROM ubuntu:18.04
+LABEL maintainer="dinghao188" \
+      version="1.1" \
+      description="ubuntu 18.04 with tools for tsinghua's rCore-Tutorial-V3"
+
+#install some deps
+RUN set -x \
+    && apt-get update \
+    && apt-get install -y curl wget autoconf automake autotools-dev curl libmpc-dev libmpfr-dev libgmp-dev \
+              gawk build-essential bison flex texinfo gperf libtool patchutils bc xz-utils \
+              zlib1g-dev libexpat-dev pkg-config  libglib2.0-dev libpixman-1-dev git tmux python3 
+
+#install rust and qemu
+RUN set -x; \
+    RUSTUP='/root/rustup.sh' \
+    && cd $HOME \
+    #install rust
+    && curl https://sh.rustup.rs -sSf > $RUSTUP && chmod +x $RUSTUP \
+    && $RUSTUP -y --default-toolchain nightly --profile minimal \
+
+    #compile qemu
+    && wget https://ftp.osuosl.org/pub/blfs/conglomeration/qemu/qemu-5.0.0.tar.xz \
+    && tar xvJf qemu-5.0.0.tar.xz \
+    && cd qemu-5.0.0 \
+    && ./configure --target-list=riscv64-softmmu,riscv64-linux-user \
+    && make -j$(nproc) install \
+    && cd $HOME && rm -rf qemu-5.0.0 qemu-5.0.0.tar.xz
+
+#for chinese network
+RUN set -x; \
+    APT_CONF='/etc/apt/sources.list'; \
+    CARGO_CONF='/root/.cargo/config'; \
+    BASHRC='/root/.bashrc' \
+    && echo 'export RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static' >> $BASHRC \
+    && echo 'export RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup' >> $BASHRC \
+    && touch $CARGO_CONF \
+    && echo '[source.crates-io]' > $CARGO_CONF \
+    && echo "replace-with = 'ustc'" >> $CARGO_CONF \
+    && echo '[source.ustc]' >> $CARGO_CONF \
+    && echo 'registry = "git://mirrors.ustc.edu.cn/crates.io-index"' >> $CARGO_CONF

Makefile

@@ -0,0 +1,8 @@
+DOCKER_NAME ?= dinghao188/rcore-tutorial
+.PHONY: docker build_docker
+
+docker:
+	docker run --rm -it --mount type=bind,source=$(shell pwd),destination=/mnt ${DOCKER_NAME}
+
+build_docker: 
+	docker build -t ${DOCKER_NAME} .

README.md

@@ -1,2 +1,12 @@
 # rCore-Tutorial-v3
-rCore-Tutorial version 3.
+rCore-Tutorial version 3.x
+
+## Dependency
+
+### Binaries
+
+* rustc 1.56.0-nightly (b03ccace5 2021-08-24)
+
+* qemu: 5.0.0
+
+* rustsbi: qemu[7d71bfb7] k210[563144b0]

os/Cargo.toml

@@ -10,7 +10,6 @@ edition = "2018"
 riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
 lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
 buddy_system_allocator = "0.6"
-spin = "0.7.0"
 bitflags = "1.2.1"
 xmas-elf = "0.7.0"
 

os/Makefile

@@ -3,17 +3,24 @@ TARGET := riscv64gc-unknown-none-elf
 MODE := release
 KERNEL_ELF := target/$(TARGET)/$(MODE)/os
 KERNEL_BIN := $(KERNEL_ELF).bin
-KERNEL_ENTRY_PA := 0x80020000
 DISASM_TMP := target/$(TARGET)/$(MODE)/asm
 
 # BOARD
-BOARD		?= qemu
-SBI			?= rustsbi
-BOOTLOADER	:= ../bootloader/$(SBI)-$(BOARD).bin
+BOARD ?= qemu
+SBI ?= rustsbi
+BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin
+K210_BOOTLOADER_SIZE := 131072
+
+# KERNEL ENTRY
+ifeq ($(BOARD), qemu)
+	KERNEL_ENTRY_PA := 0x80200000
+else ifeq ($(BOARD), k210)
+	KERNEL_ENTRY_PA := 0x80020000
+endif
 
 # Run K210
 K210-SERIALPORT	= /dev/ttyUSB0
-K210-BURNER		= ../tools/kflash.py
+K210-BURNER = ../tools/kflash.py
 
 # Binutils
 OBJDUMP := rust-objdump --arch-name=riscv64
@@ -22,14 +29,30 @@ OBJCOPY := rust-objcopy --binary-architecture=riscv64
 # Disassembly
 DISASM ?= -x
 
-build: $(KERNEL_BIN)
+build: env switch-check $(KERNEL_BIN)
+
+switch-check:
+ifeq ($(BOARD), qemu)
+	(which last-qemu) || (rm last-k210 -f && touch last-qemu && make clean)
+else ifeq ($(BOARD), k210)
+	(which last-k210) || (rm last-qemu -f && touch last-k210 && make clean)
+endif
+
+env:
+	(rustup target list | grep "riscv64gc-unknown-none-elf (installed)") || rustup target add $(TARGET)
+	cargo install cargo-binutils --vers ~0.2
+	rustup component add rust-src
+	rustup component add llvm-tools-preview
 
 $(KERNEL_BIN): kernel
 	@$(OBJCOPY) $(KERNEL_ELF) --strip-all -O binary $@
 
 kernel:
 	@cd ../user && make build
+	@echo Platform: $(BOARD)
+	@cp src/linker-$(BOARD).ld src/linker.ld
 	@cargo build --release --features "board_$(BOARD)"
+	@rm src/linker.ld
 
 clean:
 	@cargo clean
@@ -44,6 +67,8 @@ disasm-vim: kernel
 
 run: run-inner
 
+	
+
 run-inner: build
 ifeq ($(BOARD),qemu)
 	@qemu-system-riscv64 \
@@ -52,12 +77,13 @@ ifeq ($(BOARD),qemu)
 		-bios $(BOOTLOADER) \
 		-device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA)
 else
+	(which $(K210-BURNER)) || (cd .. && git clone https://github.com/sipeed/kflash.py.git && mv kflash.py tools)
 	@cp $(BOOTLOADER) $(BOOTLOADER).copy
-	@dd if=$(KERNEL_BIN) of=$(BOOTLOADER).copy bs=128K seek=1
+	@dd if=$(KERNEL_BIN) of=$(BOOTLOADER).copy bs=$(K210_BOOTLOADER_SIZE) seek=1
 	@mv $(BOOTLOADER).copy $(KERNEL_BIN)
 	@sudo chmod 777 $(K210-SERIALPORT)
 	python3 $(K210-BURNER) -p $(K210-SERIALPORT) -b 1500000 $(KERNEL_BIN)
-	miniterm --eol LF --dtr 0 --rts 0 --filter direct $(K210-SERIALPORT) 115200
+	python3 -m serial.tools.miniterm --eol LF --dtr 0 --rts 0 --filter direct $(K210-SERIALPORT) 115200
 endif
 
 debug: build
@@ -66,4 +92,4 @@ debug: build
 		tmux split-window -h "riscv64-unknown-elf-gdb -ex 'file $(KERNEL_ELF)' -ex 'set arch riscv:rv64' -ex 'target remote localhost:1234'" && \
 		tmux -2 attach-session -d
 
-.PHONY: build kernel clean disasm disasm-vim run-inner
+.PHONY: build env kernel clean disasm disasm-vim run-inner switch-check

os/build.rs

@@ -23,7 +23,7 @@ fn insert_app_data() -> Result<()> {
     apps.sort();
 
     writeln!(f, r#"
-    .align 4
+    .align 3
     .section .data
     .global _num_app
 _num_app:
@@ -40,6 +40,7 @@ _num_app:
     .section .data
     .global app_{0}_start
     .global app_{0}_end
+    .align 3
 app_{0}_start:
     .incbin "{2}{1}"
 app_{0}_end:"#, idx, app, TARGET_PATH)?;

os/src/config.rs

@@ -15,7 +15,7 @@ pub fn kernel_stack_position(app_id: usize) -> (usize, usize) {
 }
 
 #[cfg(feature = "board_k210")]
-pub const CPU_FREQ: usize = 10000000;
+pub const CLOCK_FREQ: usize = 403000000 / 62;
 
 #[cfg(feature = "board_qemu")]
-pub const CPU_FREQ: usize = 12500000;
+pub const CLOCK_FREQ: usize = 12500000;

os/src/linker-k210.ld

@@ -22,6 +22,7 @@ SECTIONS
     srodata = .;
     .rodata : {
         *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
     }
 
     . = ALIGN(4K);
@@ -29,6 +30,7 @@ SECTIONS
     sdata = .;
     .data : {
         *(.data .data.*)
+        *(.sdata .sdata.*)
     }
 
     . = ALIGN(4K);
@@ -38,6 +40,7 @@ SECTIONS
         *(.bss.stack)
         sbss = .;
         *(.bss .bss.*)
+        *(.sbss .sbss.*)
     }
 
     . = ALIGN(4K);

os/src/linker-qemu.ld

@@ -0,0 +1,53 @@
+OUTPUT_ARCH(riscv)
+ENTRY(_start)
+BASE_ADDRESS = 0x80200000;
+
+SECTIONS
+{
+    . = BASE_ADDRESS;
+    skernel = .;
+
+    stext = .;
+    .text : {
+        *(.text.entry)
+        . = ALIGN(4K);
+        strampoline = .;
+        *(.text.trampoline);
+        . = ALIGN(4K);
+        *(.text .text.*)
+    }
+
+    . = ALIGN(4K);
+    etext = .;
+    srodata = .;
+    .rodata : {
+        *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
+    }
+
+    . = ALIGN(4K);
+    erodata = .;
+    sdata = .;
+    .data : {
+        *(.data .data.*)
+        *(.sdata .sdata.*)
+    }
+
+    . = ALIGN(4K);
+    edata = .;
+    sbss_with_stack = .;
+    .bss : {
+        *(.bss.stack)
+        sbss = .;
+        *(.bss .bss.*)
+        *(.sbss .sbss.*)
+    }
+
+    . = ALIGN(4K);
+    ebss = .;
+    ekernel = .;
+
+    /DISCARD/ : {
+        *(.eh_frame)
+    }
+}

os/src/main.rs

@@ -1,9 +1,8 @@
 #![no_std]
 #![no_main]
 #![feature(global_asm)]
-#![feature(llvm_asm)]
+#![feature(asm)]
 #![feature(panic_info_message)]
-#![feature(const_in_array_repeat_expressions)]
 #![feature(alloc_error_handler)]
 
 extern crate alloc;
@@ -21,6 +20,7 @@ mod loader;
 mod config;
 mod task;
 mod timer;
+mod sync;
 mod mm;
 
 global_asm!(include_str!("entry.asm"));
@@ -31,9 +31,12 @@ fn clear_bss() {
         fn sbss();
         fn ebss();
     }
-    (sbss as usize..ebss as usize).for_each(|a| {
-        unsafe { (a as *mut u8).write_volatile(0) }
-    });
+    unsafe {
+        core::slice::from_raw_parts_mut(
+            sbss as usize as *mut u8,
+            ebss as usize - sbss as usize,
+        ).fill(0);
+    }
 }
 
 #[no_mangle]

os/src/mm/address.rs

@@ -69,7 +69,7 @@ impl From<VirtPageNum> for usize {
 
 impl VirtAddr {
     pub fn floor(&self) -> VirtPageNum { VirtPageNum(self.0 / PAGE_SIZE) }
-    pub fn ceil(&self) -> VirtPageNum  { VirtPageNum((self.0 + PAGE_SIZE - 1) / PAGE_SIZE) }
+    pub fn ceil(&self) -> VirtPageNum  { VirtPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE) }
     pub fn page_offset(&self) -> usize { self.0 & (PAGE_SIZE - 1) }
     pub fn aligned(&self) -> bool { self.page_offset() == 0 }
 }
@@ -84,7 +84,7 @@ impl From<VirtPageNum> for VirtAddr {
 }
 impl PhysAddr {
     pub fn floor(&self) -> PhysPageNum { PhysPageNum(self.0 / PAGE_SIZE) }
-    pub fn ceil(&self) -> PhysPageNum { PhysPageNum((self.0 + PAGE_SIZE - 1) / PAGE_SIZE) }
+    pub fn ceil(&self) -> PhysPageNum { PhysPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE) }
     pub fn page_offset(&self) -> usize { self.0 & (PAGE_SIZE - 1) }
     pub fn aligned(&self) -> bool { self.page_offset() == 0 }
 }

os/src/mm/frame_allocator.rs

@@ -1,6 +1,6 @@
 use super::{PhysAddr, PhysPageNum};
 use alloc::vec::Vec;
-use spin::Mutex;
+use crate::sync::UPSafeCell;
 use crate::config::MEMORY_END;
 use lazy_static::*;
 use core::fmt::{self, Debug, Formatter};
@@ -87,8 +87,9 @@ impl FrameAllocator for StackFrameAllocator {
 type FrameAllocatorImpl = StackFrameAllocator;
 
 lazy_static! {
-    pub static ref FRAME_ALLOCATOR: Mutex<FrameAllocatorImpl> =
-        Mutex::new(FrameAllocatorImpl::new());
+    pub static ref FRAME_ALLOCATOR: UPSafeCell<FrameAllocatorImpl> = unsafe {
+        UPSafeCell::new(FrameAllocatorImpl::new())
+    };
 }
 
 pub fn init_frame_allocator() {
@@ -96,20 +97,20 @@ pub fn init_frame_allocator() {
         fn ekernel();
     }
     FRAME_ALLOCATOR
-        .lock()
+        .exclusive_access()
         .init(PhysAddr::from(ekernel as usize).ceil(), PhysAddr::from(MEMORY_END).floor());
 }
 
 pub fn frame_alloc() -> Option<FrameTracker> {
     FRAME_ALLOCATOR
-        .lock()
+        .exclusive_access()
         .alloc()
         .map(|ppn| FrameTracker::new(ppn))
 }
 
 fn frame_dealloc(ppn: PhysPageNum) {
     FRAME_ALLOCATOR
-        .lock()
+        .exclusive_access()
         .dealloc(ppn);
 }
 

os/src/mm/memory_set.rs

@@ -7,7 +7,7 @@ use alloc::vec::Vec;
 use riscv::register::satp;
 use alloc::sync::Arc;
 use lazy_static::*;
-use spin::Mutex;
+use crate::sync::UPSafeCell;
 use crate::config::{
     MEMORY_END,
     PAGE_SIZE,
@@ -30,9 +30,9 @@ extern "C" {
 }
 
 lazy_static! {
-    pub static ref KERNEL_SPACE: Arc<Mutex<MemorySet>> = Arc::new(Mutex::new(
-        MemorySet::new_kernel()
-    ));
+    pub static ref KERNEL_SPACE: Arc<UPSafeCell<MemorySet>> = Arc::new(unsafe {
+        UPSafeCell::new(MemorySet::new_kernel()
+    )});
 }
 
 pub struct MemorySet {
@@ -182,7 +182,7 @@ impl MemorySet {
         let satp = self.page_table.token();
         unsafe {
             satp::write(satp);
-            llvm_asm!("sfence.vma" :::: "volatile");
+            asm!("sfence.vma");
         }
     }
     pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
@@ -290,7 +290,7 @@ bitflags! {
 
 #[allow(unused)]
 pub fn remap_test() {
-    let mut kernel_space = KERNEL_SPACE.lock();
+    let mut kernel_space = KERNEL_SPACE.exclusive_access();
     let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
     let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into();
     let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into();

os/src/mm/mod.rs

@@ -15,5 +15,5 @@ pub use memory_set::remap_test;
 pub fn init() {
     heap_allocator::init_heap();
     frame_allocator::init_frame_allocator();
-    KERNEL_SPACE.clone().lock().activate();
+    KERNEL_SPACE.exclusive_access().activate();
 }

os/src/mm/page_table.rs

@@ -131,7 +131,7 @@ impl PageTable {
     }
 }
 
-pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&'static [u8]> {
+pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&'static mut [u8]> {
     let page_table = PageTable::from_token(token);
     let mut start = ptr as usize;
     let end = start + len;
@@ -146,7 +146,11 @@ pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&
         vpn.step();
         let mut end_va: VirtAddr = vpn.into();
         end_va = end_va.min(VirtAddr::from(end));
-        v.push(&ppn.get_bytes_array()[start_va.page_offset()..end_va.page_offset()]);
+        if end_va.page_offset() == 0 {
+            v.push(&mut ppn.get_bytes_array()[start_va.page_offset()..]);
+        } else {
+            v.push(&mut ppn.get_bytes_array()[start_va.page_offset()..end_va.page_offset()]);
+        }
         start = end_va.into();
     }
     v

os/src/sbi.rs

@@ -14,11 +14,12 @@ const SBI_SHUTDOWN: usize = 8;
 fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
     let mut ret;
     unsafe {
-        llvm_asm!("ecall"
-            : "={x10}" (ret)
-            : "{x10}" (arg0), "{x11}" (arg1), "{x12}" (arg2), "{x17}" (which)
-            : "memory"
-            : "volatile"
+        asm!(
+            "ecall",
+            inlateout("x10") arg0 => ret,
+            in("x11") arg1,
+            in("x12") arg2,
+            in("x17") which,
         );
     }
     ret

os/src/sync/mod.rs

@@ -0,0 +1,3 @@
+mod up;
+
+pub use up::UPSafeCell;

os/src/sync/up.rs

@@ -0,0 +1,27 @@
+use core::cell::{RefCell, RefMut};
+
+/// Wrap a static data structure inside it so that we are
+/// able to access it without any `unsafe`.
+///
+/// We should only use it in uniprocessor.
+///
+/// In order to get mutable reference of inner data, call
+/// `exclusive_access`.
+pub struct UPSafeCell<T> {
+    /// inner data
+    inner: RefCell<T>,
+}
+
+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()
+    }
+}

os/src/syscall/process.rs

@@ -2,10 +2,10 @@ use crate::task::{
     suspend_current_and_run_next,
     exit_current_and_run_next,
 };
-use crate::timer::get_time;
+use crate::timer::get_time_ms;
 
-pub fn sys_exit(xstate: i32) -> ! {
-    println!("[kernel] Application exited with code {}", xstate);
+pub fn sys_exit(exit_code: i32) -> ! {
+    println!("[kernel] Application exited with code {}", exit_code);
     exit_current_and_run_next();
     panic!("Unreachable in sys_exit!");
 }
@@ -16,5 +16,5 @@ pub fn sys_yield() -> isize {
 }
 
 pub fn sys_get_time() -> isize {
-    get_time() as isize
+    get_time_ms() as isize
 }

os/src/task/context.rs

@@ -3,13 +3,22 @@ use crate::trap::trap_return;
 #[repr(C)]
 pub struct TaskContext {
     ra: usize,
+    sp: usize,
     s: [usize; 12],
 }
 
 impl TaskContext {
-    pub fn goto_trap_return() -> Self {
+    pub fn zero_init() -> Self {
+        Self {
+            ra: 0,
+            sp: 0,
+            s: [0; 12],
+        }
+    }
+    pub fn goto_trap_return(kstack_ptr: usize) -> Self {
         Self {
             ra: trap_return as usize,
+            sp: kstack_ptr,
             s: [0; 12],
         }
     }

os/src/task/mod.rs

@@ -4,7 +4,7 @@ mod task;
 
 use crate::loader::{get_num_app, get_app_data};
 use crate::trap::TrapContext;
-use core::cell::RefCell;
+use crate::sync::UPSafeCell;
 use lazy_static::*;
 use switch::__switch;
 use task::{TaskControlBlock, TaskStatus};
@@ -14,7 +14,7 @@ pub use context::TaskContext;
 
 pub struct TaskManager {
     num_app: usize,
-    inner: RefCell<TaskManagerInner>,
+    inner: UPSafeCell<TaskManagerInner>,
 }
 
 struct TaskManagerInner {
@@ -22,8 +22,6 @@ struct TaskManagerInner {
     current_task: usize,
 }
 
-unsafe impl Sync for TaskManager {}
-
 lazy_static! {
     pub static ref TASK_MANAGER: TaskManager = {
         println!("init TASK_MANAGER");
@@ -38,41 +36,46 @@ lazy_static! {
         }
         TaskManager {
             num_app,
-            inner: RefCell::new(TaskManagerInner {
+            inner: unsafe { UPSafeCell::new(TaskManagerInner {
                 tasks,
                 current_task: 0,
-            }),
+            })},
         }
     };
 }
 
 impl TaskManager {
-    fn run_first_task(&self) {
-        self.inner.borrow_mut().tasks[0].task_status = TaskStatus::Running;
-        let next_task_cx = self.inner.borrow().tasks[0].get_task_cx_ptr2();
-        let _unused: usize = 0;
+    fn run_first_task(&self) -> ! {
+        let mut inner = self.inner.exclusive_access();
+        let next_task = &mut inner.tasks[0];
+        next_task.task_status = TaskStatus::Running;
+        let next_task_cx_ptr = &next_task.task_cx as *const TaskContext;
+        drop(inner);
+        let mut _unused = TaskContext::zero_init();
+        // before this, we should drop local variables that must be dropped manually
         unsafe {
             __switch(
-                &_unused as *const _,
-                next_task_cx,
+                &mut _unused as *mut _,
+                next_task_cx_ptr,
             );
         }
+        panic!("unreachable in run_first_task!");
     }
 
     fn mark_current_suspended(&self) {
-        let mut inner = self.inner.borrow_mut();
-        let current = inner.current_task;
-        inner.tasks[current].task_status = TaskStatus::Ready;
+        let mut inner = self.inner.exclusive_access();
+        let cur = inner.current_task;
+        inner.tasks[cur].task_status = TaskStatus::Ready;
     }
 
     fn mark_current_exited(&self) {
-        let mut inner = self.inner.borrow_mut();
-        let current = inner.current_task;
-        inner.tasks[current].task_status = TaskStatus::Exited;
+        let mut inner = self.inner.exclusive_access();
+        let cur = inner.current_task;
+        inner.tasks[cur].task_status = TaskStatus::Exited;
     }
 
     fn find_next_task(&self) -> Option<usize> {
-        let inner = self.inner.borrow();
+        let inner = self.inner.exclusive_access();
         let current = inner.current_task;
         (current + 1..current + self.num_app + 1)
             .map(|id| id % self.num_app)
@@ -82,32 +85,32 @@ impl TaskManager {
     }
 
     fn get_current_token(&self) -> usize {
-        let inner = self.inner.borrow();
-        let current = inner.current_task;
-        inner.tasks[current].get_user_token()
+        let inner = self.inner.exclusive_access();
+        inner.tasks[inner.current_task].get_user_token()
     }
 
     fn get_current_trap_cx(&self) -> &mut TrapContext {
-        let inner = self.inner.borrow();
-        let current = inner.current_task;
-        inner.tasks[current].get_trap_cx()
+        let inner = self.inner.exclusive_access();
+        inner.tasks[inner.current_task].get_trap_cx()
     }
 
     fn run_next_task(&self) {
         if let Some(next) = self.find_next_task() {
-            let mut inner = self.inner.borrow_mut();
+            let mut inner = self.inner.exclusive_access();
             let current = inner.current_task;
             inner.tasks[next].task_status = TaskStatus::Running;
             inner.current_task = next;
-            let current_task_cx = inner.tasks[current].get_task_cx_ptr2();
-            let next_task_cx = inner.tasks[next].get_task_cx_ptr2();
-            core::mem::drop(inner);
+            let current_task_cx_ptr = &mut inner.tasks[current].task_cx as *mut TaskContext;
+            let next_task_cx_ptr = &inner.tasks[next].task_cx as *const TaskContext;
+            drop(inner);
+            // before this, we should drop local variables that must be dropped manually
             unsafe {
                 __switch(
-                    current_task_cx,
-                    next_task_cx,
+                    current_task_cx_ptr,
+                    next_task_cx_ptr,
                 );
             }
+            // go back to user mode
         } else {
             panic!("All applications completed!");
         }

os/src/task/switch.S

@@ -1,34 +1,34 @@
 .altmacro
 .macro SAVE_SN n
-    sd s\n, (\n+1)*8(sp)
+    sd s\n, (\n+2)*8(a0)
 .endm
 .macro LOAD_SN n
-    ld s\n, (\n+1)*8(sp)
+    ld s\n, (\n+2)*8(a1)
 .endm
     .section .text
     .globl __switch
 __switch:
-    # __switch(current_task_cx: &*const TaskContext, next_task_cx: &*const TaskContext)
-    # push TaskContext to current sp and save its address to where a0 points to
-    addi sp, sp, -13*8
-    sd sp, 0(a0)
-    # fill TaskContext with ra & s0-s11
-    sd ra, 0(sp)
+    # __switch(
+    #     current_task_cx_ptr: *mut TaskContext,
+    #     next_task_cx_ptr: *const TaskContext
+    # )
+    # save kernel stack of current task
+    sd sp, 8(a0)
+    # save ra & s0~s11 of current execution
+    sd ra, 0(a0)
     .set n, 0
     .rept 12
         SAVE_SN %n
         .set n, n + 1
     .endr
-    # ready for loading TaskContext a1 points to
-    ld sp, 0(a1)
-    # load registers in the TaskContext
-    ld ra, 0(sp)
+    # restore ra & s0~s11 of next execution
+    ld ra, 0(a1)
     .set n, 0
     .rept 12
         LOAD_SN %n
         .set n, n + 1
     .endr
-    # pop TaskContext
-    addi sp, sp, 13*8
+    # restore kernel stack of next task
+    ld sp, 8(a1)
     ret
 

os/src/task/switch.rs

@@ -1,5 +1,10 @@
 global_asm!(include_str!("switch.S"));
 
+use super::TaskContext;
+
 extern "C" {
-    pub fn __switch(current_task_cx: *const usize, next_task_cx: *const usize);
+    pub fn __switch(
+        current_task_cx_ptr: *mut TaskContext,
+        next_task_cx_ptr: *const TaskContext
+    );
 }

os/src/task/task.rs

@@ -4,17 +4,14 @@ use crate::config::{TRAP_CONTEXT, kernel_stack_position};
 use super::TaskContext;
 
 pub struct TaskControlBlock {
-    pub task_cx_ptr: usize,
     pub task_status: TaskStatus,
+    pub task_cx: TaskContext,
     pub memory_set: MemorySet,
     pub trap_cx_ppn: PhysPageNum,
     pub base_size: usize,
 }
 
 impl TaskControlBlock {
-    pub fn get_task_cx_ptr2(&self) -> *const usize {
-        &self.task_cx_ptr as *const usize
-    }
     pub fn get_trap_cx(&self) -> &'static mut TrapContext {
         self.trap_cx_ppn.get_mut()
     }
@@ -32,17 +29,15 @@ impl TaskControlBlock {
         // map a kernel-stack in kernel space
         let (kernel_stack_bottom, kernel_stack_top) = kernel_stack_position(app_id);
         KERNEL_SPACE
-            .lock()
+            .exclusive_access()
             .insert_framed_area(
                 kernel_stack_bottom.into(),
                 kernel_stack_top.into(),
                 MapPermission::R | MapPermission::W,
             );
-        let task_cx_ptr = (kernel_stack_top - core::mem::size_of::<TaskContext>()) as *mut TaskContext;
-        unsafe { *task_cx_ptr = TaskContext::goto_trap_return(); }
         let task_control_block = Self {
-            task_cx_ptr: task_cx_ptr as usize,
             task_status,
+            task_cx: TaskContext::goto_trap_return(kernel_stack_top),
             memory_set,
             trap_cx_ppn,
             base_size: user_sp,
@@ -52,7 +47,7 @@ impl TaskControlBlock {
         *trap_cx = TrapContext::app_init_context(
             entry_point,
             user_sp,
-            KERNEL_SPACE.lock().token(),
+            KERNEL_SPACE.exclusive_access().token(),
             kernel_stack_top,
             trap_handler as usize,
         );

os/src/timer.rs

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

os/src/trap/context.rs

@@ -21,7 +21,6 @@ impl TrapContext {
     ) -> Self {
         let mut sstatus = sstatus::read();
         sstatus.set_spp(SPP::User);
-        sstatus.set_spie(true);
         let mut cx = Self {
             x: [0; 32],
             sstatus,

os/src/trap/mod.rs

@@ -10,7 +10,6 @@ use riscv::register::{
         Interrupt,
     },
     stval,
-    sstatus,
     sie,
 };
 use crate::syscall::syscall;
@@ -41,11 +40,6 @@ fn set_user_trap_entry() {
     }
 }
 
-#[allow(unused)]
-pub fn enable_interrupt() {
-    unsafe { sstatus::set_sie(); }
-}
-
 pub fn enable_timer_interrupt() {
     unsafe { sie::set_stimer(); }
 }
@@ -92,9 +86,15 @@ pub fn trap_return() -> ! {
     }
     let restore_va = __restore as usize - __alltraps as usize + TRAMPOLINE;
     unsafe {
-        llvm_asm!("jr $0" :: "r"(restore_va), "{a0}"(trap_cx_ptr), "{a1}"(user_satp) :: "volatile");
+        asm!(
+            "fence.i",
+            "jr {restore_va}",
+            restore_va = in(reg) restore_va,
+            in("a0") trap_cx_ptr,
+            in("a1") user_satp,
+            options(noreturn)
+        );
     }
-    panic!("Unreachable in back_to_user!");
 }
 
 #[no_mangle]

rust-toolchain

@@ -1 +1 @@
-nightly-2020-11-01
+nightly-2021-08-25

user/src/bin/00power_3.rs

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

user/src/bin/01power_5.rs

@@ -23,7 +23,7 @@ unsafe fn main() -> i32 {
             println!("power_5 [{}/{}]", i, iter);
         }
     }
-    println!("{}^{} = {}(mod {})", p, iter, S[cur], m);
+    println!("{}^{} = {}(MOD {})", p, iter, S[cur], m);
     println!("Test power_5 OK!");
     0
 }

user/src/bin/02power_7.rs

@@ -23,7 +23,7 @@ unsafe fn main() -> i32 {
             println!("power_7 [{}/{}]", i, iter);
         }
     }
-    println!("{}^{} = {}(mod {})", p, iter, S[cur], m);
+    println!("{}^{} = {}(MOD {})", p, iter, S[cur], m);
     println!("Test power_7 OK!");
     0
 }

user/src/bin/03sleep.rs

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

user/src/console.rs

@@ -1,11 +1,13 @@
 use core::fmt::{self, Write};
-use crate::syscall::{STDOUT, sys_write};
+use super::write;
 
 struct Stdout;
 
+const STDOUT: usize = 1;
+
 impl Write for Stdout {
     fn write_str(&mut self, s: &str) -> fmt::Result {
-        sys_write(STDOUT, s.as_bytes());
+        write(STDOUT, s.as_bytes());
         Ok(())
     }
 }

user/src/lib.rs

@@ -1,5 +1,5 @@
 #![no_std]
-#![feature(llvm_asm)]
+#![feature(asm)]
 #![feature(linkage)]
 #![feature(panic_info_message)]
 
@@ -11,7 +11,7 @@ mod lang_items;
 #[no_mangle]
 #[link_section = ".text.entry"]
 pub extern "C" fn _start() -> ! {
-    syscall::sys_exit(main());
+    exit(main());
     panic!("unreachable after sys_exit!");
 }
 
@@ -22,4 +22,9 @@ fn main() -> i32 {
 }
 
 
-pub use syscall::*;
+use syscall::*;
+
+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() }

user/src/linker.ld

@@ -14,13 +14,16 @@ SECTIONS
     . = ALIGN(4K);
     .rodata : {
         *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
     }
     . = ALIGN(4K);
     .data : {
         *(.data .data.*)
+        *(.sdata .sdata.*)
     }
     .bss : {
         *(.bss .bss.*)
+        *(.sbss .sbss.*)
     }
     /DISCARD/ : {
         *(.eh_frame)

user/src/syscall.rs

@@ -1,5 +1,3 @@
-pub const STDOUT: usize = 1;
-
 const SYSCALL_WRITE: usize = 64;
 const SYSCALL_EXIT: usize = 93;
 const SYSCALL_YIELD: usize = 124;
@@ -8,11 +6,12 @@ const SYSCALL_GET_TIME: usize = 169;
 fn syscall(id: usize, args: [usize; 3]) -> isize {
     let mut ret: isize;
     unsafe {
-        llvm_asm!("ecall"
-            : "={x10}" (ret)
-            : "{x10}" (args[0]), "{x11}" (args[1]), "{x12}" (args[2]), "{x17}" (id)
-            : "memory"
-            : "volatile"
+        asm!(
+            "ecall",
+            inlateout("x10") args[0] => ret,
+            in("x11") args[1],
+            in("x12") args[2],
+            in("x17") id
         );
     }
     ret
@@ -22,8 +21,8 @@ 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])
+pub fn sys_exit(exit_code: i32) -> isize {
+    syscall(SYSCALL_EXIT, [exit_code as usize, 0, 0])
 }
 
 pub fn sys_yield() -> isize {