修改os的内存大小

.gitignore

@@ -15,3 +15,4 @@ Cargo.lock
 *.pdb
 
 /.idea/*
+*link_app.S

ch5/os/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "os"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+# 设置release模式下保存调试信息
+[profile.release]
+debug=true
+
+[dependencies]
+riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
+lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
+sbi-rt = { version = "0.0.2", features = ["legacy"] }
+buddy_system_allocator = "0.6"
+bitflags = "1.2.1"
+xmas-elf = "0.7.0"

ch5/os/Makefile

@@ -0,0 +1,50 @@
+TARGET := riscv64gc-unknown-none-elf
+KERNEL_ENTRY := 0x80200000
+MODE := release
+KERNEL_ELF := target/$(TARGET)/$(MODE)/os
+KERNEL_BIN := $(KERNEL_ELF).bin
+SYMBOL_MAP := target/system.map
+QEMU_CMD_PATH := ../../tools/qemu-system-riscv64
+OBJDUMP := rust-objdump --arch-name=riscv64
+OBJCOPY := rust-objcopy --binary-architecture=riscv64
+
+RUST_FLAGS := -Clink-arg=-Tsrc/linker.ld  # 使用我们自己的链接脚本
+RUST_FLAGS += -Cforce-frame-pointers=yes  # 强制编译器生成帧指针
+RUST_FLAGS:=$(strip ${RUST_FLAGS})
+
+# 编译elf文件
+build_elf: clean
+	CARGO_BUILD_RUSTFLAGS="$(RUST_FLAGS)" \
+ 	cargo build --$(MODE) --target=$(TARGET)
+
+# 导出一个符号表, 供我们查看
+$(SYMBOL_MAP):build_elf
+	nm $(KERNEL_ELF) | sort > $(SYMBOL_MAP)
+
+# 丢弃内核可执行elf文件中的元数据得到内核镜像
+$(KERNEL_BIN): build_elf
+	@$(OBJCOPY) $(KERNEL_ELF) --strip-all -O binary $@
+
+
+debug:build_elf $(KERNEL_BIN) $(SYMBOL_MAP) kill
+	$(QEMU_CMD_PATH) \
+		-machine virt \
+		-display none \
+		-daemonize \
+		-bios ../../bootloader/rustsbi-qemu.bin \
+		-device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY) \
+		-s -S
+
+run:build_elf $(KERNEL_BIN) $(SYMBOL_MAP) kill
+	$(QEMU_CMD_PATH) \
+		-machine virt \
+		-nographic \
+		-bios ../../bootloader/rustsbi-qemu.bin \
+		-device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY)
+
+clean:
+#	rm -rf ./target* && rm -rf ./src/link_app.S
+
+kill:
+	-pkill -9 qemu
+

ch5/os/build.rs

@@ -0,0 +1,83 @@
+use std::fs::{read_dir, File};
+use std::io::{Result, Write};
+
+fn main() {
+    // 主要功能是把用户的应用程序加载到内核中
+    println!("cargo:rerun-if-changed=../user/src/");
+    println!("cargo:rerun-if-changed={}", TARGET_PATH);
+    insert_app_data().unwrap();
+}
+
+static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/release/";
+
+fn insert_app_data() -> Result<()> {
+    let mut f = File::create("src/link_app.S").unwrap();
+    let mut apps: Vec<_> = read_dir("../user/src/bin")
+        .unwrap()
+        .into_iter()
+        .map(|dir_entry| {
+            let mut name_with_ext = dir_entry.unwrap().file_name().into_string().unwrap();
+            name_with_ext.drain(name_with_ext.find('.').unwrap()..name_with_ext.len());
+            name_with_ext
+        })
+        .collect();
+    apps.sort();
+
+
+    ///
+    ///     .align 3   表示接下来的数据或代码 使用2^3 8字节对齐
+    ///     .section .data  下面属于data段
+    ///     .global _num_app  定义一个全局符号 _num_app
+    /// _num_app:  _num_app的位置的数据
+    ///     .quad 5  用来当做matedata  8字节的整数 表示有5个元素
+    ///     .quad app_0_start  依次存储每个app的开始的位置
+    ///     .quad app_1_start
+    ///     .quad app_2_start
+    ///     .quad app_3_start
+    ///     .quad app_4_start
+    ///     .quad app_4_end
+    writeln!(
+        f,
+        r#"
+    .align 3
+    .section .data
+    .global _num_app
+_num_app:
+    .quad {}"#,
+        apps.len()
+    )?;
+
+    for i in 0..apps.len() {
+        writeln!(f, r#"    .quad app_{}_start"#, i)?;
+    }
+    writeln!(f, r#"    .quad app_{}_end"#, apps.len() - 1)?;
+
+    // app的名字列表
+    writeln!(
+        f,
+        r#"
+    .global _app_names
+_app_names:"#
+    )?;
+    for app in apps.iter() {
+        writeln!(f, r#"    .string "{}""#, app)?;
+    }
+
+
+    for (idx, app) in apps.iter().enumerate() {
+        println!("app_{}: {}", idx, app);
+        writeln!(
+            f,
+            r#"
+    .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
+        )?;
+    }
+    Ok(())
+}

ch5/os/src/boards/qemu.rs

@@ -0,0 +1,3 @@
+//! Constants used in rCore for qemu
+
+pub const CLOCK_FREQ: usize = 12500000;

ch5/os/src/config.rs

@@ -0,0 +1,13 @@
+pub const MAX_APP_NUM: usize = 10;  // 支持最大的用户应用数量
+pub const KERNEL_HEAP_SIZE: usize = 0x30_0000;  // 内核的堆大小 3M
+pub const PAGE_SIZE_BITS: usize = 0xc;  // 页内偏移的位宽(也就是每页的大小)
+pub const PAGE_SIZE: usize = 0x1000;  // 每个页 的字节大小为 4kb
+pub const MEMORY_END: usize = 0x81000000;  // 设置我们当前操作系统最大只能用到 0x80800000-0x80000000大小的内存也就是8M
+
+pub const USER_STACK_SIZE: usize = 4096 * 2;  // 每个应用用户态的栈大小为8kb
+pub const KERNEL_STACK_SIZE: usize = 4096 * 2; // 每个应用的内核栈
+
+pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;  // __alltraps对齐到了这里, (内核空间和用户空间这里虚拟地址都用这个)虚拟地址最高页 存放跳板, 跳板那一页, 被映射到 strampoline段(trap) 实际的物理地址, 即陷入时 cpu需要跳转的地址
+pub const TRAP_CONTEXT: usize = TRAMPOLINE - PAGE_SIZE;  // 用户 trap context开始的位置 在 每个用户程序 它本身地址空间 的次高页
+
+pub use crate::board::*;

ch5/os/src/entry.asm

@@ -0,0 +1,15 @@
+.section .text.entry
+.globl _start  // 声明_start是全局符号
+_start:
+    la sp, boot_stack_top_bound
+    call rust_main
+
+
+
+// 声明栈空间 后续 .bss.stack 会被link脚本链接到 .bss段
+    .section .bss.stack
+    .globl boot_stack_lower_bound  // 栈低地址公开为全局符号
+    .globl boot_stack_top_bound  // 栈高地址公开为全局符号
+boot_stack_lower_bound:
+    .space 4096 * 16
+boot_stack_top_bound:

ch5/os/src/lang_items.rs

@@ -0,0 +1,2 @@
+pub mod panic;
+pub mod console;

ch5/os/src/lang_items/console.rs

@@ -0,0 +1,33 @@
+
+use crate::sbi::console_put_char;
+use core::fmt::{self, Write};
+
+struct Stdout;
+
+impl Write for Stdout{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for c in s.chars() {
+            console_put_char(c as usize);
+        }
+        Ok(())
+    }
+}
+
+// 用函数包装一下, 表示传进来的参数满足Arguments trait, 然后供宏调用
+pub fn print(args: fmt::Arguments) {
+    Stdout.write_fmt(args).unwrap();
+}
+
+#[macro_export]  // 导入这个文件即可使用这些宏
+macro_rules! print {
+    ($fmt: literal $(, $($arg: tt)+)?) => {
+        $crate::console::print(format_args!($fmt $(, $($arg)+)?));
+    }
+}
+
+#[macro_export]
+macro_rules! println {
+    ($fmt: literal $(, $($arg: tt)+)?) => {
+        $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
+    }
+}

ch5/os/src/lang_items/panic.rs

@@ -0,0 +1,18 @@
+use core::panic::PanicInfo;
+use crate::println;
+use crate::sbi::shutdown;
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    if let Some(location) = info.location() {
+        println!(
+            "Panicked at {}:{} {}",
+            location.file(),
+            location.line(),
+            info.message().unwrap()
+        );
+    } else {
+        println!("Panicked: {}", info.message().unwrap());
+    }
+    shutdown();
+}

ch5/os/src/linker.ld

@@ -0,0 +1,53 @@
+OUTPUT_ARCH(riscv)  /* 目标平台 */
+ENTRY(_start)  /* 设置程序入口点为entry.asm中定义的全局符号 */
+BASE_ADDRESS = 0x80200000;  /* 一个常量, 我们的kernel将来加载到这个物理地址 */
+
+SECTIONS
+{
+    . = BASE_ADDRESS;  /* 我们对 . 进行赋值, 调整接下来的段的开始位置放在我们定义的常量出 */
+/*    skernel = .;*/
+
+    stext = .;  /* .text段的开始位置 */
+    .text : {  /* 表示生成一个为 .text的段, 花括号内按照防止顺序表示将输入文件中的哪些段放在 当前.text段中 */
+        *(.text.entry)  /* entry.asm中, 我们自己定义的.text.entry段, 被放在顶部*/
+        . = ALIGN(4K);  /*4k对齐*/
+        strampoline = .;
+        /* strampoline 段, 将来会被 memory set 导入, 当做跳板最高页vpn的实际物理帧 ppn*/
+        *(.text.trampoline);
+        *(.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 和 ebss 分别指向 .bss 段除 .bss.stack 以外的起始和终止地址(.bss.stack是我们在entry.asm中定义的栈) */
+        sbss = .;
+        *(.bss .bss.*)
+        *(.sbss .sbss.*)
+    }
+
+    . = ALIGN(4K);
+    ebss = .;
+    ekernel = .;
+
+    /DISCARD/ : {
+        *(.eh_frame)
+    }
+}

ch5/os/src/loader.rs

@@ -0,0 +1,85 @@
+use alloc::vec::Vec;
+use core::arch::asm;
+use lazy_static::lazy_static;
+
+use crate::config::*;
+use crate::*;
+use crate::trap::TrapContext;
+
+static KERNEL_STACK: [[u8; KERNEL_STACK_SIZE]; MAX_APP_NUM] = [[0; KERNEL_STACK_SIZE]; MAX_APP_NUM];  // 这一章, 每个用户应用对应一个内核栈 [每个应用自己的内核栈; 总应用数]
+static USER_STACK: [[u8; USER_STACK_SIZE]; MAX_APP_NUM] = [[0; USER_STACK_SIZE]; MAX_APP_NUM];  // 这一行每个用户应用对应一个应用栈
+
+extern "C" {
+    fn _num_app();
+    fn _app_names();
+}
+
+// 得到用户app的数量
+pub fn get_num_app() -> usize{
+    unsafe{
+        (_num_app as usize as *const usize).read_volatile()
+    }
+}
+
+pub fn get_app_data(app_id: usize) -> &'static [u8] {
+    extern "C" {
+        fn _num_app();
+    }
+    let num_app_ptr = _num_app as usize as *const usize;
+    let num_app = get_num_app();
+    let app_start = unsafe { core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1) };
+    assert!(app_id < num_app);
+    unsafe {
+        core::slice::from_raw_parts(
+            app_start[app_id] as *const u8,
+            app_start[app_id + 1] - app_start[app_id],
+        )
+    }
+}
+
+lazy_static!{
+    static ref APP_NAMES:Vec<&'static str> = {
+        // app总数
+        let num_app = get_num_app();
+
+        // 名字开始的位置
+        let mut start = _app_names as usize as *const u8;
+
+        // 找到每个用户名
+        let mut app_names = Vec::new();
+        unsafe {
+            for _ in 0..num_app {
+                let mut end = start;
+                while end.read_volatile() != b'\0'{
+                    end = end.add(1)
+                }
+
+                // 从start 到 end长度的切片
+                let slice = core::slice::from_raw_parts(start, end as usize - start as usize);
+
+                let str = core::str::from_utf8(slice).unwrap();
+                app_names.push(str);
+                start = end.add(1)
+            };
+        }
+        app_names
+    };
+}
+
+
+/// 根据app的名字 找到app的下标, 然后找到app的二进制elf数据
+pub fn get_app_data_by_name(name: &str) -> Option<&'static [u8]> {
+    let num_app = get_num_app();
+    (0..num_app)
+        .find(|&i| APP_NAMES[i] == name)
+        .map(get_app_data)
+}
+
+/// 输出所有的app的名字
+pub fn list_apps() {
+    println!("/**** APPS ****");
+    for app in APP_NAMES.iter() {
+        println!("{}", app);
+    }
+    println!("**************/");
+}

ch5/os/src/main.rs

@@ -0,0 +1,88 @@
+#![feature(panic_info_message)]
+#![feature(alloc_error_handler)]
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+use core::arch::global_asm;
+use sbi::{console_put_char, shutdown};
+use lang_items::console;
+
+pub mod lang_items;
+pub mod sbi;
+pub mod sync;
+pub mod trap;
+pub mod syscall;
+pub mod loader;
+pub mod config;
+pub mod task;
+pub mod timer;
+pub mod mm;
+
+#[path = "boards/qemu.rs"]
+mod board;
+
+static OS_LOGO:&'static str = r#"
+
+      ___                         ___           ___
+     /  /\          __           /  /\         /  /\
+    /  /::|        |  |\        /  /::\       /  /::\
+   /  /:|:|        |  |:|      /  /:/\:\     /__/:/\:\
+  /  /:/|:|__      |  |:|     /  /:/  \:\   _\_ \:\ \:\
+ /__/:/_|::::\     |__|:|__  /__/:/ \__\:\ /__/\ \:\ \:\
+ \__\/  /~~/:/     /  /::::\ \  \:\ /  /:/ \  \:\ \:\_\/
+       /  /:/     /  /:/~~~~  \  \:\  /:/   \  \:\_\:\
+      /  /:/     /__/:/        \  \:\/:/     \  \:\/:/
+     /__/:/      \__\/          \  \::/       \  \::/
+     \__\/                       \__\/         \__\/
+
+"#;
+
+
+
+// 汇编脚本引入, 调整内核的内存布局之后, 会跳入到 rust_main中执行
+global_asm!(include_str!("entry.asm"));
+
+// 引入用户的二进制文件
+global_asm!(include_str!("link_app.S"));
+
+extern "C" {
+    fn stext();
+    fn etext();
+    fn sbss();
+    fn ebss();
+    fn boot_stack_top_bound();
+    fn boot_stack_lower_bound();
+}
+
+#[no_mangle]
+pub fn rust_main(){
+    init_bss();
+
+    println!("stext: {:#x}, etext: {:#x}", stext as usize, etext as usize);
+    println!("sbss: {:#x}, ebss: {:#x}", sbss as usize, ebss as usize);
+    println!("boot_stack_top_bound: {:#x}, boot_stack_lower_bound: {:#x}", boot_stack_top_bound as usize, boot_stack_lower_bound as usize);
+
+    // 初始化动态内存分配器, 使我们能在内核中使用动态大小数据类型
+    mm::init();
+
+
+    trap::init();
+    trap::enable_timer_interrupt();  // 允许定时器中断
+    timer::set_next_trigger();  // 在进入用户态之前, 设置一个时钟中断, 防止第一个用户任务死循环
+    task::add_initproc();
+
+    println!("{}", OS_LOGO);
+    loader::list_apps();
+    task::run_tasks();
+    panic!("Disable run here")
+}
+
+/// ## 初始化bss段
+///
+fn init_bss() {
+    unsafe {
+        (sbss as usize..ebss as usize).for_each(|p| (p as *mut u8).write_unaligned(0))
+    }
+}

ch5/os/src/mm/address.rs

@@ -0,0 +1,207 @@
+use crate::config::{PAGE_SIZE, PAGE_SIZE_BITS};
+use crate::mm::page_table::PageTableEntry;
+
+const PA_WIDTH_SV39: usize = 56;  // 真实物理地址 的字节宽度  44(物理页宽) + 12(4kb的宽度)
+const VA_WIDTH_SV39: usize = 39;  // 虚拟地址的宽度 9 + 9 + 9 + 12
+const PPN_WIDTH_SV39: usize = PA_WIDTH_SV39 - PAGE_SIZE_BITS;  // 物理页 的宽度, 也就是 物理地址宽度-每页宽度=物理页宽度
+const VPN_WIDTH_SV39: usize = VA_WIDTH_SV39 - PAGE_SIZE_BITS;  // 虚拟页的宽度 27
+
+
+// 物理地址 56bit 44 12
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct PhysAddr(pub usize);
+
+// 虚拟地址 39bit  9 9 9 12
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct VirtAddr(pub usize);
+
+// 物理页 44bit
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct PhysPageNum(pub usize);
+
+// 虚拟页 29bit 布局为 9 9 9
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct VirtPageNum(pub usize);
+
+
+// 把usize 转为真实地址(只保留 PA_WIDTH_SV39 位字节)
+impl From<usize> for PhysAddr {
+    fn from(v: usize) -> Self {
+        Self(v & ( (1 << PA_WIDTH_SV39) - 1 ))
+    }
+}
+
+// 把usize类型的物理页号 转为物理页结构体 (只保留物理页的宽度)
+impl From<usize> for PhysPageNum {
+    fn from(v: usize) -> Self {
+        Self(v & ( (1 << PPN_WIDTH_SV39) - 1 ))
+    }
+}
+
+// 把物理地址转为 usize, 直接返回即可
+impl From<PhysAddr> for usize {
+    fn from(v: PhysAddr) -> Self {
+        v.0
+    }
+}
+
+// 把物理页结构体转为 usize类型的物理页 直接返回即可
+impl From<PhysPageNum> for usize {
+    fn from(v: PhysPageNum) -> Self {
+        v.0
+    }
+}
+
+// 把PhysAddr 转为 PhysPageNum
+impl From<PhysAddr> for PhysPageNum {
+    fn from(v: PhysAddr) -> Self {
+        assert_eq!(v.page_offset(), 0);
+        v.floor()
+    }
+}
+
+// 把物理页转为物理地址(左移页宽即可)
+impl From<PhysPageNum> for PhysAddr {
+    fn from(v: PhysPageNum) -> Self { Self(v.0 << PAGE_SIZE_BITS) }
+}
+
+impl PhysAddr {
+    // 从当前物理地址得到页内偏移(只保留12个bit即可)
+    pub fn page_offset(&self) -> usize {
+        self.0 & (PAGE_SIZE - 1)
+    }
+
+    // 舍去小数位, 把物理地址, 转为 物理页号 向下取整
+    pub fn floor(&self) -> PhysPageNum {
+        PhysPageNum(self.0 / PAGE_SIZE)
+    }
+
+    // 有小数统一 +1, 物理地址转为物理页号  向上取整
+    pub fn ceil(&self) -> PhysPageNum {
+        PhysPageNum((self.0 + PAGE_SIZE - 1) / PAGE_SIZE)
+    }
+
+    // 把当前虚拟地址映射为指定类型T
+    pub fn get_mut<T>(&self) -> &'static mut T {
+        unsafe { (self.0 as *mut T).as_mut().unwrap() }
+    }
+}
+
+
+impl PhysPageNum {
+    // // 从当前物理页保存的数据中得到所有的 PTE
+    pub fn get_pte_array(&self) -> &'static mut [PageTableEntry] {
+        // 物理页号 转为物理地址
+        let pa: PhysAddr = (*self).into();
+        // 从物理页地址读出一页 512个8字节(4k)的数据
+        unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut PageTableEntry, 512) }
+    }
+
+    // 从当前物理页得到 引用类型的 byte array
+    pub fn get_bytes_array(&self) -> &'static mut [u8] {
+        let pa: PhysAddr = (*self).into();
+        unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut u8, 4096) }
+    }
+
+    // 把物理页转为物理地址之后, 再转为T, 强转
+    pub fn get_mut<T>(&self) -> &'static mut T {
+        let pa: PhysAddr = (*self).into();
+        unsafe { (pa.0 as *mut T).as_mut().unwrap() }
+    }
+}
+
+impl VirtAddr{
+    // 舍去小数位, 把虚拟地址转为物理页号 向下取整
+    pub fn floor(&self) -> VirtPageNum {
+        VirtPageNum(self.0 / PAGE_SIZE)
+    }
+
+    // 有小数统一+1 虚拟地址转为虚拟页号 向上取整
+    pub fn ceil(&self) -> VirtPageNum {
+        VirtPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE)
+    }
+
+    // 虚拟地址得到业内偏移 只保留12个bit即可
+    pub fn page_offset(&self) -> usize {
+        self.0 & (PAGE_SIZE - 1)
+    }
+}
+
+
+// 把usize 转为 虚拟地址, 只保留39位
+impl From<usize> for VirtAddr {
+    fn from(value: usize) -> Self {
+        Self(value & ((1 << VA_WIDTH_SV39) - 1))
+    }
+}
+
+// 把虚拟地址, 转为usize
+impl From<VirtAddr> for usize {
+    fn from(v: VirtAddr) -> Self {
+        if v.0 >= (1 << (VA_WIDTH_SV39 - 1)) {
+            // 将高位全部设置为1, 虚拟地址就是这样的, 64~39 位, 随着38位变化
+            v.0 | (!((1 << VA_WIDTH_SV39) - 1))
+        } else {
+            v.0
+        }
+    }
+}
+
+// 把usize类型的页号 转为 虚拟页号结构体, 只保留27位即可
+impl From<usize> for VirtPageNum {
+    fn from(v: usize) -> Self {
+        Self(v & ((1 << VPN_WIDTH_SV39) - 1))
+    }
+}
+
+// 虚拟地址 转为虚拟页号 向下取整
+impl From<VirtAddr> for VirtPageNum {
+    fn from(v: VirtAddr) -> Self {
+        assert_eq!(v.page_offset(), 0);
+        v.floor()
+    }
+}
+
+// 虚拟页号 转为虚拟地址 左移即可
+impl From<VirtPageNum> for VirtAddr {
+    fn from(v: VirtPageNum) -> Self {
+        // 左移12位
+        Self(v.0 << PAGE_SIZE_BITS)
+    }
+}
+
+
+impl VirtPageNum{
+    // 从虚拟页号中 抽离 9 9 9 的布局
+    pub fn indexes(&self) -> [usize; 3] {
+        let mut vpn = self.0;
+        let mut idx = [0usize; 3];
+        for i in (0..3).rev() {
+            idx[i] = vpn & 511;
+            vpn >>= 9;
+        }
+        idx
+    }
+}
+
+
+// 代表一个range类型, 表示一段 虚拟地址 的区间
+#[derive(Copy, Clone)]
+pub struct VPNRange {
+    pub l: VirtPageNum,
+    pub r: VirtPageNum
+}
+
+impl Iterator for VPNRange {
+    type Item = VirtPageNum;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.l == self.r {
+            None
+        } else {
+            let current_vpn = self.l;
+            self.l = (self.l.0 + 1).into();
+            Some(current_vpn)
+        }
+    }
+}

ch5/os/src/mm/frame_allocator.rs

@@ -0,0 +1,120 @@
+use alloc::vec::Vec;
+use lazy_static::lazy_static;
+use crate::mm::address::{PhysPageNum, PhysAddr};
+use crate::config::MEMORY_END;
+use crate::println;
+use crate::sync::UPSafeCell;
+
+extern "C" {
+    fn ekernel();
+}
+
+// 物理页帧的结构体, 他和物理页号不同, 它是管理整个物理页内的数据, 而物理页号被页表管理
+// 这个结构体只是利用rust drop管理变量的方式
+// 我们使用这个结构体, 来利用rust变量生命周期, 自动管理该页, 数据清零或者还回物理页帧管理器
+// 这个结构可以省去(因为他很多时候使用PhysPageNum 也可以完成), 但是为了防止后续课程还有其他地方使用, 就不省了,
+pub struct FrameTracker {
+    pub ppn: PhysPageNum,
+}
+
+impl FrameTracker {
+    pub fn new(ppn: PhysPageNum) -> Self {
+        // 页数据初始化
+        let bytes_array = ppn.get_bytes_array();
+        for i in bytes_array {
+            *i = 0;
+        }
+        Self { ppn }
+    }
+}
+
+impl Drop for FrameTracker {
+    // 生命周期结束, 自动把页还给 物理页帧管理器
+    fn drop(&mut self) {
+        frame_dealloc(self.ppn);
+    }
+}
+
+
+// 物理页帧管理器, 它管理了 ekernel(操作系统使用的内存结束位置) 到 MEMORY_END(最大的可用的物理内存地址)所有的内存, 这部分内存是给用户用的
+// current, end 这个区间表示此前从未被分配过的页
+// recycled 表示之前被分配过, 但是已经被回收可以再利用的页
+pub struct StackFrameAllocator {
+    current: PhysPageNum,
+    end: PhysPageNum,
+    recycled: Vec<PhysPageNum>,
+}
+
+impl StackFrameAllocator {
+    fn from(l: PhysPageNum, r: PhysPageNum) -> Self {
+        Self {
+            current: l,
+            end: r,
+            recycled: Vec::new(),
+        }
+    }
+}
+
+impl StackFrameAllocator {
+    // 从分配器中, 找到一个空闲页(它可能之前从未分配过, 或者之前被分配但是已经被回收的完好页)
+    fn alloc(&mut self) -> Option<PhysPageNum> {
+        if let Some(ppn) = self.recycled.pop() {
+            Some(ppn)
+        } else if self.current == self.end {
+            None
+        } else {
+            let current_ppn = self.current;
+            let next_ppn = (self.current.0 + 1).into();
+            self.current = next_ppn;
+            Some(current_ppn)
+        }
+    }
+
+    // 回收一个页, 为了防止二次回收, 我们这里直接panic
+    fn dealloc(&mut self, ppn: PhysPageNum) {
+        // 防止被二次回收
+        if ppn >= self.current || self.recycled.iter().any(|&v| v == ppn) {
+            panic!("Frame ppn={:#x} has not been allocated!", ppn.0);
+        }
+        // 校验完毕, 把这个页, 还给管理器
+        self.recycled.push(ppn);
+    }
+}
+
+lazy_static! {
+    static ref FRAME_ALLOCATOR: UPSafeCell<StackFrameAllocator> = unsafe {
+        // 这里我们只要完整的页, 舍去开头和结尾一些碎片
+        UPSafeCell::new(StackFrameAllocator::from(PhysAddr::from(ekernel as usize).ceil(), PhysAddr::from(MEMORY_END).floor()))
+    };
+}
+
+/// 分配一个页
+pub fn frame_alloc() -> Option<FrameTracker> {
+    FRAME_ALLOCATOR
+        .exclusive_access()
+        .alloc()
+        .map(FrameTracker::new)
+}
+
+/// 回收指定的页
+fn frame_dealloc(ppn: PhysPageNum) {
+    FRAME_ALLOCATOR.exclusive_access().dealloc(ppn);
+}
+
+
+pub fn frame_allocator_test() {
+    let mut v: Vec<FrameTracker> = Vec::new();
+    for i in 0..5 {
+        let frame = frame_alloc().unwrap();
+        println!("frame_allocator_test {:?}", frame.ppn.0);
+        v.push(frame);
+    }
+    v.clear();
+    for i in 0..5 {
+        let frame = frame_alloc().unwrap();
+        println!("frame_allocator_test {:?}", frame.ppn.0);
+        v.push(frame);
+    }
+    drop(v);
+    println!("frame_allocator_test passed!");
+}

ch5/os/src/mm/heap_allocator.rs

@@ -0,0 +1,67 @@
+
+use alloc::boxed::Box;
+use alloc::vec;
+use buddy_system_allocator::LockedHeap;
+use crate::config::KERNEL_HEAP_SIZE;
+use crate::println;
+
+
+// 动态内存分配器
+#[global_allocator]
+static HEAP_ALLOCATOR: LockedHeap = LockedHeap::empty();
+
+// 内存分配失败时, 会调用此错误处理函数
+
+// 堆的空间
+static mut HEAP_SPACE: [u8; KERNEL_HEAP_SIZE] = [0; KERNEL_HEAP_SIZE];
+
+
+// 为内存分配器, 绑定一个空间用来实现动态内存分配
+pub fn init_heap() {
+    unsafe {
+        HEAP_ALLOCATOR
+            .lock()
+            .init(HEAP_SPACE.as_ptr() as usize, KERNEL_HEAP_SIZE);
+    }
+    // heap_test()
+}
+
+pub fn heap_test() {
+    use alloc::boxed::Box;
+    use alloc::vec::Vec;
+    extern "C" {
+        fn sbss();
+        fn ebss();
+    }
+    let bss_range = sbss as usize..ebss as usize;
+    println!("bss_range {:?}", bss_range);
+
+    let a = Box::new(5);
+    println!("a: {:?}  ptr: {:p}", a, a.as_ref());
+    let b = Box::new(6);
+    println!("b: {:?}  ptr: {:p}", b, b.as_ref());
+
+
+    unsafe {
+        println!("HEAP_SPACE: {:?}", HEAP_SPACE.as_ptr())
+    }
+
+    let mut v = vec![];
+    for i in 0..500{
+        v.push(i);
+    }
+
+    for i in 0..500{
+        v.pop();
+    }
+
+    println!("{:?}", v);
+
+    // 通过输出打印, 发现 a 和b 均被分配在了 HEAP_SPACE 中, 且 HEAP_SPACE 被分配在了 bss段中, 这个段由我们 linker.ld 进行手动布局
+    // 目前整个bss段的大小都是3M, 说明当前bss段中只有这一个 数据
+}
+
+#[alloc_error_handler]
+pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! {
+    panic!("Heap allocation error, layout = {:?}", layout);
+}

ch5/os/src/mm/memory_set.rs

@@ -0,0 +1,503 @@
+use alloc::collections::BTreeMap;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use core::arch::asm;
+use bitflags::bitflags;
+use lazy_static::lazy_static;
+use riscv::register::satp;
+use xmas_elf;
+use crate::sync::UPSafeCell;
+use crate::config::{MEMORY_END, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT, USER_STACK_SIZE};
+use crate::mm::address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum, VPNRange};
+use crate::mm::frame_allocator::{frame_alloc, FrameTracker};
+use crate::mm::page_table::{PageTable, PTEFlags};
+use crate::println;
+
+// 引入外部符号进来, 下面映射地址空间的逻辑段会用到
+extern "C" {
+    fn stext();
+    fn etext();
+    fn srodata();
+    fn erodata();
+    fn sdata();
+    fn edata();
+    fn sbss_with_stack();
+    fn ebss();
+    fn ekernel();
+    fn strampoline();  // 这个符号 在linker.ld 中定义
+}
+lazy_static! {
+    /// a memory set instance through lazy_static! managing kernel space
+    pub static ref KERNEL_SPACE: Arc<UPSafeCell<MemorySet>> =
+        Arc::new(unsafe { UPSafeCell::new(MemorySet::new_kernel()) });
+}
+
+// 某逻辑段的映射方式
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum MapType {
+    Identical,  // 恒等映射
+    Framed,  // 逻辑映射
+}
+
+
+// 这个段的权限, 它是页表项标志位 PTEFlags 的一个子集, 仅仅保留4个标志位就足够了
+bitflags! {
+    /// map permission corresponding to that in pte: `R W X U`
+    pub struct MapPermission: u8 {
+        const R = 1 << 1;
+        const W = 1 << 2;
+        const X = 1 << 3;
+        const U = 1 << 4;
+    }
+}
+
+
+// 代表一个逻辑段
+pub struct MapArea {
+    vpn_range: VPNRange,  // 逻辑段的虚拟页起始位置 和 结束位置
+    data_frames: BTreeMap<VirtPageNum, FrameTracker>,  // 这个逻辑段   虚拟页 对应的具体的物理帧, 这里使用rust 进行管理其物理帧的释放, 自动drop进行还给物理页帧管理器
+    map_type: MapType,
+    map_perm: MapPermission,
+}
+
+impl MapArea {
+    // 从虚拟地址起始和结束, 创建一个逻辑段结构体
+    pub fn from(start_va: VirtAddr, end_va: VirtAddr, map_type: MapType, map_perm: MapPermission,) -> Self {
+        // 截取抛弃内存碎片
+        let start_vpn: VirtPageNum = start_va.floor();
+        let end_vpn: VirtPageNum = end_va.ceil();
+
+        Self {
+            vpn_range: VPNRange {l:start_vpn, r: end_vpn},
+            data_frames: BTreeMap::new(),
+            map_type,
+            map_perm,
+        }
+    }
+    // 根据当前逻辑段的信息, 创建另一个一样的逻辑段
+    pub fn from_another(another: &Self) -> Self {
+        Self {
+            vpn_range: VPNRange{l:another.vpn_range.l, r:another.vpn_range.r},
+            data_frames: BTreeMap::new(),
+            map_type: another.map_type,
+            map_perm: another.map_perm,
+        }
+    }
+}
+
+impl MapArea {
+    // 把一个虚拟页号 创建一个对应的物理页帧 映射到page_table中, 并把创建的物理页帧生命周期 绑定到 self上
+    pub fn map_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
+        let ppn: PhysPageNum;
+        match self.map_type {
+            // 恒等映射
+            MapType::Identical => {
+                ppn = PhysPageNum(vpn.0);
+            }
+            MapType::Framed => {
+                // 随便创建一个 物理页帧
+                let frame = frame_alloc().unwrap();
+                ppn = frame.ppn;
+                // 把随便创建的物理页帧, 绑定到data_frames 中被 self管理生命周期
+                self.data_frames.insert(vpn, frame);
+            }
+        }
+
+        // 根据上面创建的物理页帧映射pte 到三级页表中
+        let pte_flags = PTEFlags::from_bits(self.map_perm.bits).unwrap();
+        page_table.map(vpn, ppn, pte_flags);
+    }
+
+    // 取消映射一个vpn, 并把 self管理的 物理页帧的生命周期结束
+    pub fn unmap_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
+        if self.map_type == MapType::Framed {
+            // 删除映射关系, 自动调用 drop 把vpn对应的ppn还给全局内存管理器
+            self.data_frames.remove(&vpn);
+        }
+        // 物理帧不存在了 把vpn 对应的pte设置为空
+        page_table.unmap(vpn);
+    }
+
+    // 映射 当前逻辑段中的每一个虚拟页, 到页表中
+    pub fn map(&mut self, page_table: &mut PageTable) {
+
+        for vpn in self.vpn_range {
+            self.map_one(page_table, vpn);
+        }
+    }
+
+    // 在页表中取消映射每一个虚拟页
+    pub fn unmap(&mut self, page_table: &mut PageTable) {
+        for vpn in self.vpn_range {
+            self.unmap_one(page_table, vpn);
+        }
+    }
+
+    // 拷贝外部的数据二进制 到当前的逻辑段中 按照页 为单位
+    pub fn copy_data(&mut self, page_table: &mut PageTable, data: &[u8]) {
+        assert_eq!(self.map_type, MapType::Framed);
+
+        let mut start: usize = 0;
+
+        // 当前逻辑段的起始页位置
+        let mut current_vpn = self.vpn_range.l;
+        // 需要拷贝的字节总大小
+        let len = data.len();
+        loop {
+            // 拷贝 每次最大拷贝1个页
+            let src = &data[start..len.min(start + PAGE_SIZE)];
+
+            // 得到逻辑段每个页的起始位置
+            let dst = &mut page_table
+                .get_pte(current_vpn)  // 在页表中, 根据逻辑段中的vpn 得到 54bit的pte (44+10)
+                .unwrap()
+                .ppn()  // 根据54bit的pte, 得到44bit 的物理页帧的位置
+                .get_bytes_array()[..src.len()];  // 得到物理页帧那一页的起始的地址 44bit<<12
+            dst.copy_from_slice(src);
+            start += PAGE_SIZE;
+            if start >= len {
+                break;
+            }
+            current_vpn = (current_vpn.0 + 1).into();
+        }
+    }
+    // 当前段, 缩小到新的结束位置, 即把new_end后面的页, 都还给物理页帧管理器, 并取消映射(通过unmap_one方法即可)
+    pub fn shrink_to(&mut self, page_table: &mut PageTable, new_end: VirtPageNum) {
+        let tmp_vpn_range = VPNRange{
+            l: new_end,
+            r: self.vpn_range.r,
+        };
+        for vpn in tmp_vpn_range {
+            self.unmap_one(page_table, vpn)
+        }
+
+        // 注意 当前段的区间 也要调整哦new(self.vpn_range.get_start(), new_end);
+        self.vpn_range.r = new_end;
+    }
+
+
+    // 当前段, 把当前结束的位置, 扩展到新的结束的位置
+    pub fn append_to(&mut self, page_table: &mut PageTable, new_end: VirtPageNum) {
+        let tmp_vpn_range = VPNRange{
+            l: self.vpn_range.r,
+            r: new_end,
+        };
+
+        for vpn in tmp_vpn_range {
+            self.map_one(page_table, vpn)
+        }
+
+        self.vpn_range.r = new_end;
+    }
+}
+
+
+// 表示一个地址空间, 它是一个页表和 包含所有段信息的页表组成
+pub struct MemorySet {
+    pub page_table: PageTable,
+    pub areas: Vec<MapArea>,
+}
+
+impl MemorySet {
+    pub fn new() -> Self {
+        Self {
+            page_table: PageTable::new(),
+            areas: Vec::new(),
+        }
+    }
+
+    pub fn from_elf(elf_data: &[u8]) -> (Self, usize, usize) {
+        let mut memory_set = Self::new();
+        // map trampoline
+        // 创建一个地址空间
+        memory_set.map_trampoline();
+        // map program headers of elf, with U flag
+        // 分析外部传进来的 elf文件数据
+        let elf = xmas_elf::ElfFile::new(elf_data).unwrap();
+        let elf_header = elf.header;
+        let magic = elf_header.pt1.magic;
+        assert_eq!(magic, [0x7f, 0x45, 0x4c, 0x46], "invalid elf!");
+        let ph_count = elf_header.pt2.ph_count();
+        // 得到所有的段数量
+        let mut max_end_vpn = VirtPageNum(0);
+        // 循环所有的段
+        for i in 0..ph_count {
+            // 得到当前段
+            let ph = elf.program_header(i).unwrap();
+            // 确定有加载的必要
+            if ph.get_type().unwrap() == xmas_elf::program::Type::Load {
+                // 当前段开始位置
+                let start_va: VirtAddr = (ph.virtual_addr() as usize).into();
+                // 当前段结束位置 (开始位置+大小)
+                let end_va: VirtAddr = ((ph.virtual_addr() + ph.mem_size()) as usize).into();
+
+                // 当前段权限
+                let mut map_perm = MapPermission::U;
+                let ph_flags = ph.flags();
+                if ph_flags.is_read() {
+                    map_perm |= MapPermission::R;
+                }
+                if ph_flags.is_write() {
+                    map_perm |= MapPermission::W;
+                }
+                if ph_flags.is_execute() {
+                    map_perm |= MapPermission::X;
+                }
+                // 创建一个 逻辑段
+                let map_area = MapArea::from(start_va, end_va, MapType::Framed, map_perm);
+                // 每次都更新最后的逻辑段的最后结束最大的逻辑地址
+                max_end_vpn = map_area.vpn_range.r;
+
+                // 当前逻辑段, 添加到地址空间, 并copy数据进去
+                memory_set.push(
+                    map_area,
+                    Some(&elf.input[ph.offset() as usize..(ph.offset() + ph.file_size()) as usize]),
+                );
+
+            }
+        }
+
+        // map user stack with U flags
+        // 将最后一个最大的逻辑段的结束的页, 转为逻辑地址  左移12位 得到39位的VirtAddr
+        let max_end_va: VirtAddr = max_end_vpn.into();
+        // 根据riscv 的规则, 转成一个 合法的地址
+        let mut user_stack_bottom: usize = max_end_va.into();
+
+        // guard page  放置 一页 保护页隔离用户栈
+        user_stack_bottom += PAGE_SIZE;
+
+        // 保护页之后 再增加 用户栈大小,得到栈底和当前的栈顶
+        // 此时 user_stack_top 距离 max_end_vpn 三个页
+        let user_stack_top = user_stack_bottom + USER_STACK_SIZE;
+
+        // 添加 用户逻辑栈段并映射物理地址页, 到当前的地址空间
+        memory_set.push(
+            MapArea::from(
+                user_stack_bottom.into(),
+                user_stack_top.into(),
+                MapType::Framed,
+                MapPermission::R | MapPermission::W | MapPermission::U,
+            ),
+            None,
+        );
+
+        // 用户的堆空间段 只有一个起始位置即可, 因为 user_stack_top上面全是堆的空间(除了最后两页)
+        memory_set.push(
+            MapArea::from(
+                user_stack_top.into(),
+                user_stack_top.into(),
+                MapType::Framed,
+                MapPermission::R | MapPermission::W | MapPermission::U,
+            ),
+            None,
+        );
+
+        // 设置 TrapContext为统一的虚拟地址
+        // 将 虚拟地址的 次高页添加到用户空间, 后面会被内核强行找到物理地址并修改为 trap context
+        memory_set.push(
+            MapArea::from(
+                TRAP_CONTEXT.into(),
+                TRAMPOLINE.into(),
+                MapType::Framed,
+                MapPermission::R | MapPermission::W,
+            ),
+            None,
+        );
+
+        (
+            memory_set,  // 地址空间
+            user_stack_top,  // 用户栈底和当前的栈顶, 他在地址空间各个逻辑段的上面, 同时
+            elf.header.pt2.entry_point() as usize,  // elf文件的入口地址
+        )
+    }
+}
+
+impl MemorySet {
+    // 得到当前地址空间的 页表token
+    pub fn token(&self) -> usize {
+        self.page_table.token()
+    }
+
+    // 从当前地址空间中,根据start 虚拟页 找到逻辑段,  取消映射 一个逻辑段, 并把这个逻辑段 从 areas中删除
+    pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum) {
+        if let Some((idx, area)) = self.areas.iter_mut().enumerate().find(|(_, area)| {
+            area.vpn_range.l == start_vpn
+        }) {
+            area.unmap(&mut self.page_table);
+            self.areas.remove(idx);
+        }
+    }
+
+    // 释放当前地址空间的 逻辑页帧areas, 把对应的物理页帧通过RAII 归还给全局物理页帧管理器
+    pub fn recycle_data_pages(&mut self) {
+        //*self = Self::new_bare();
+        self.areas.clear();
+    }
+
+    // 激活当前地址空间
+    pub fn activate(&self) {
+        // let satp = self.page_table.token();
+        // 得到当前地址空间的 页表 的规定格式
+        let satp = self.token();;
+        unsafe {
+            // 设置satp CSR寄存器为我们
+            satp::write(satp);
+
+            // 刷新快表缓存TLB, 这个指令最简单的作用就是清空旧的快表
+            // 更深层次其实是一个内存屏障
+            asm!("sfence.vma");
+        }
+    }
+
+    // 根据 start va 和end va 创建一个 逻辑段类型为逻辑映射, 插入到 当前地址空间
+    pub fn insert_framed_area(&mut self, start_va: VirtAddr, end_va: VirtAddr, permission: MapPermission) {
+        self.push(MapArea::from(start_va, end_va, MapType::Framed, permission), None);
+    }
+
+    // 把一个 逻辑段, 映射到当前页表中
+    fn push(&mut self, mut map_area: MapArea, data: Option<&[u8]>) {
+        map_area.map(&mut self.page_table);
+        if let Some(data) = data {
+            map_area.copy_data(&mut self.page_table, data);
+        }
+        self.areas.push(map_area);
+    }
+
+    /// 创建跳板, 跳板就是 trap.S中的代码段中.text.trampoline, 由 linker.ld手动布局在代码段
+    /// 内核空间和用户空间,他们都会运行这个函数, 插入同样的代码, 把虚拟地址映射为同样的物理地址, 这里内核空间和用户空间执行这段代码的时候, 每个  虚拟地址对应的物理地址是相同的
+    /// 所以 (内核空间的 TRAMPOLINE+指令offset) == (用户空间的 TRAMPOLINE+offset)  == (strampoline + offset)
+    /// (内核的 TRAMPOLINE) 和 (用户的 TRAMPOLINE) 和 strampoline 他们都是相等的
+    /// 在 trap.S 切换用户空间之后, 取值执行, 切换空间之前和切换空间之后, 他们对应的虚拟地址空间是相同的, 且都映射到了同一个物理页帧
+    fn map_trampoline(&mut self) {
+        // 直接插入到 把 linker.ld 中的符号strampoline, 映射到最高的虚拟页, 他的物理页帧是 链接脚本中我们手动内存布局的符号
+        // 如果是用户应用, 这个符号的最下面就是 次高页 即 trap context
+        self.page_table.map(
+            VirtAddr::from(TRAMPOLINE).into(),
+            PhysAddr::from(strampoline as usize).into(),
+            PTEFlags::R | PTEFlags::X,
+        );
+    }
+
+    // 创建一个内核用的地址空间
+    pub fn new_kernel() -> Self {
+        let mut memory_set = Self::new();
+        // 跳板创建
+        memory_set.map_trampoline();
+        // map kernel sections
+        println!(".text [{:#x}, {:#x})", stext as usize, etext as usize);
+        println!(".rodata [{:#x}, {:#x})", srodata as usize, erodata as usize);
+        println!(".data [{:#x}, {:#x})", sdata as usize, edata as usize);
+        println!(
+            ".bss [{:#x}, {:#x})",
+            sbss_with_stack as usize, ebss as usize
+        );
+        println!("mapping .text section");
+        memory_set.push(
+            MapArea::from(
+                (stext as usize).into(),
+                (etext as usize).into(),
+                MapType::Identical,
+                MapPermission::R | MapPermission::X,
+            ),
+            None,
+        );
+        println!("mapping .rodata section");
+        memory_set.push(
+            MapArea::from(
+                (srodata as usize).into(),
+                (erodata as usize).into(),
+                MapType::Identical,
+                MapPermission::R,
+            ),
+            None,
+        );
+        println!("mapping .data section");
+        memory_set.push(
+            MapArea::from(
+                (sdata as usize).into(),
+                (edata as usize).into(),
+                MapType::Identical,
+                MapPermission::R | MapPermission::W,
+            ),
+            None,
+        );
+        println!("mapping .bss section");
+        memory_set.push(
+            MapArea::from(
+                (sbss_with_stack as usize).into(),
+                (ebss as usize).into(),
+                MapType::Identical,
+                MapPermission::R | MapPermission::W,
+            ),
+            None,
+        );
+        println!("mapping physical memory");
+        memory_set.push(
+            MapArea::from(
+                (ekernel as usize).into(),
+                MEMORY_END.into(),
+                MapType::Identical,
+                MapPermission::R | MapPermission::W,
+            ),
+            None,
+        );
+        memory_set
+    }
+
+
+    // 当前地址空间, 缩小 虚拟地址start位置到虚拟地址 new end的位置
+    pub fn shrink_to(&mut self, start: VirtAddr, new_end: VirtAddr) -> bool {
+        // 起始虚拟地址所在的页
+        let start_vpn = start.floor();
+
+        // 找到起始地址所在的段, 传入页表, 把当前段缩小到指定结束位置new_end
+        if let Some(area) = self.areas.iter_mut().find(|area| area.vpn_range.l == start_vpn) {
+            area.shrink_to(&mut self.page_table, new_end.ceil());
+            true
+        } else {
+            false
+        }
+    }
+
+    // 增加当前的地址空间 扩展为 start到 新的结束的位置
+    pub fn append_to(&mut self, start: VirtAddr, new_end: VirtAddr) -> bool {
+        // 同上, 找到逻辑段之后, 只不过这里是 扩展
+        if let Some(area) = self.areas.iter_mut().find(|area| area.vpn_range.l == start.floor()) {
+            area.append_to(&mut self.page_table, new_end.ceil());
+            true
+        } else {
+            false
+        }
+    }
+
+    // clone 当前的 地址空间 并返回一个新的, 注意虽然地址空间是相同的, 但是 他们的物理地址并不相同
+    pub fn from_existed_user(user_space: &Self) -> Self {
+        // 一个空的地址空间
+        let mut memory_set = Self::new();
+        // 映射跳板
+        memory_set.map_trampoline();
+
+        // copy data sections/trap_context/user_stack
+        // 拷贝数据
+        for area in user_space.areas.iter() {
+            // 根据 当前逻辑段的信息, 创建一个新的数据段
+            let new_area = MapArea::from_another(area);
+
+            // 把逻辑段信息 添加到当前地址空间(顺便也映射ppn)
+            memory_set.push(new_area, None);
+
+            // copy data from another space
+            // 把 当前逻辑段从开始到结束, ppn的数据, copy 到 新的 ppn
+            for vpn in area.vpn_range {
+                let src_ppn = user_space.page_table.get_pte(vpn).unwrap().ppn();
+                let dst_ppn = memory_set.page_table.get_pte(vpn).unwrap().ppn();
+                dst_ppn
+                    .get_bytes_array()
+                    .copy_from_slice(src_ppn.get_bytes_array());
+            }
+        }
+        memory_set
+    }
+
+
+}

ch5/os/src/mm/mod.rs

@@ -0,0 +1,59 @@
+use crate::mm::address::VirtAddr;
+use crate::mm::memory_set::KERNEL_SPACE;
+use crate::{etext, println, stext};
+
+pub mod heap_allocator;
+pub mod address;
+pub mod frame_allocator;
+pub mod page_table;
+pub mod memory_set;
+
+
+
+pub fn init(){
+    // 开启 内核的内存分配器
+    heap_allocator::init_heap();
+    // 初始化并测试 物理页帧管理器
+    frame_allocator::frame_allocator_test();
+    // 激活内核的地址空间
+    KERNEL_SPACE.exclusive_access().activate();
+
+    remap_test();
+}
+
+
+pub fn remap_test() {
+    extern "C" {
+        fn stext();
+        fn etext();
+        fn srodata();
+        fn erodata();
+        fn sdata();
+        fn edata();
+        fn sbss_with_stack();
+        fn ebss();
+        fn ekernel();
+        fn strampoline();  // 这个符号 在linker.ld 中定义
+    }
+
+    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();
+    assert!(!kernel_space
+        .page_table
+        .get_pte(mid_text.floor())
+        .unwrap()
+        .writable(),);
+    assert!(!kernel_space
+        .page_table
+        .get_pte(mid_rodata.floor())
+        .unwrap()
+        .writable(),);
+    assert!(!kernel_space
+        .page_table
+        .get_pte(mid_data.floor())
+        .unwrap()
+        .executable(),);
+    println!("remap_test passed!");
+}

ch5/os/src/mm/page_table.rs

@@ -0,0 +1,273 @@
+use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
+use bitflags::*;
+use crate::config::TRAMPOLINE;
+use crate::mm::address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
+use crate::mm::frame_allocator::{frame_alloc, FrameTracker};
+use crate::println;
+
+
+bitflags! {
+    pub struct PTEFlags: u8 {
+        const V = 1 << 0;  // 仅当位 V 为 1 时，页表项才是合法的
+        const R = 1 << 1;  // 可读标志
+        const W = 1 << 2;  // 可写标志
+        const X = 1 << 3;  // 可执行标志
+        const U = 1 << 4;  // 是否允许U级访问
+        const G = 1 << 5;  //
+        const A = 1 << 6;  // 从上次清零之后, 该页是否被访问过
+        const D = 1 << 7;  // 从上次清零之后, 该页是否被修改过
+    }
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+/// pte结构体
+///
+/// 对应的64个字节的布局为
+///
+/// 10bit(保留) | 44bit(物理页号) | 10bit(标志位)
+pub struct PageTableEntry {
+    pub bits: usize,
+}
+
+
+impl PageTableEntry {
+    // 从一个物理页号和一个flag 创建出来一个 PTE
+    // 物理也好 左移10位 加上 flag 即可
+    pub fn from(ppn: PhysPageNum, flags: PTEFlags) -> Self {
+        PageTableEntry {
+            bits: ppn.0 << 10 | flags.bits as usize,
+        }
+    }
+
+    // 生成一个全0的PTE, V也是0, 它是不合法的
+    pub fn new() -> Self {
+        PageTableEntry { bits: 0 }
+    }
+
+    // 从PTE中的到 物理页的地址, 右移bit flag的宽度 再只保留44位即可得到 usize类型的物理页号, 随后调用into进行转换
+    pub fn ppn(&self) -> PhysPageNum {
+        (self.bits >> 10 & ((1usize << 44) - 1)).into()
+    }
+    // 从PTE中得到bit flag
+    pub fn flags(&self) -> PTEFlags {
+        PTEFlags::from_bits(self.bits as u8).unwrap()
+    }
+
+    // 判断是否合法, 只保留 V标志的位置, 再判断是否为0
+    pub fn is_valid(&self) -> bool {
+        (self.flags() & PTEFlags::V) != PTEFlags::empty()
+    }
+    // 判断是否可读
+    pub fn readable(&self) -> bool {
+        (self.flags() & PTEFlags::R) != PTEFlags::empty()
+    }
+    // 判断是否可写
+    pub fn writable(&self) -> bool {
+        (self.flags() & PTEFlags::W) != PTEFlags::empty()
+    }
+    // 判断是否可执行
+    pub fn executable(&self) -> bool {
+        (self.flags() & PTEFlags::X) != PTEFlags::empty()
+    }
+}
+
+// 页表
+pub struct PageTable {
+    root_ppn: PhysPageNum,
+    // 这里保存, 保存了 被映射出来的每级页表的物理帧, 页表被删除时, 页表所占用的物理帧 也被rust释放执行drop还给物理页帧管理器, FrameTracker 实现了 Drop trait
+    frames: Vec<FrameTracker>,
+}
+
+impl PageTable {
+    // 创建根节点页表
+    pub fn new() -> Self {
+        let frame = frame_alloc().unwrap();
+        PageTable {
+            root_ppn: frame.ppn,
+            frames: vec![frame],
+        }
+    }
+
+    // 从stap寄存器保存的特定格式的token, 转为根节点页表
+    pub fn from_token(satp: usize) -> Self {
+        Self {
+            // 只保留44位 bit, 这44位bit, 就是 页表所在的物理页帧
+            root_ppn: PhysPageNum::from(satp & ((1usize << 44) - 1)),
+            frames: Vec::new(),
+        }
+    }
+
+}
+
+impl PageTable {
+    // 得到该页表被设置到 stap 需要的格式
+    // 注意, 这个只能是根节点才会用得到
+    pub fn token(&self) -> usize {
+        // 8 表示MODE, SV39分页机制开启
+        // 4bit 16bit 44bit 构成页表的 stap CSR的格式要求
+        8usize << 60 | self.root_ppn.0
+    }
+
+    // 寻找 指定页号, 如果不存在中间节点, 则创建出来, 知道找到三级页表的 指定下标 的 pte的指针
+    fn find_pte_create(&mut self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
+        let idxs = vpn.indexes();
+        let mut ppn = self.root_ppn;
+        let mut result: Option<&mut PageTableEntry> = None;
+        for (i, idx) in idxs.iter().enumerate() {
+            // 得到一级页表的pte
+            let pte = &mut ppn.get_pte_array()[*idx];
+            // 到达最后一级, 不管有无数据直接 跳出, 返回 三级页表保存的信息  0或者指向  物理页44bit+权限10bit 的数据
+            if i == 2 {
+                result = Some(pte);
+                break;
+            }
+            // 如果没有中间节点
+            if pte.is_valid() == false {
+                let frame = frame_alloc().unwrap();
+                *pte = PageTableEntry::from(frame.ppn, PTEFlags::V);
+                self.frames.push(frame);
+            }
+            ppn = pte.ppn();
+        }
+        result
+    }
+
+    // 和 find_pte_create 差不多, 只不过这个不创建中间节点, 缺中间节点立马就返回
+    fn find_pte(&self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
+        let idxs = vpn.indexes();
+        let mut ppn = self.root_ppn;
+        let mut result: Option<&mut PageTableEntry> = None;
+        for (i, idx) in idxs.iter().enumerate() {
+            let pte = &mut ppn.get_pte_array()[*idx];
+            if i == 2 {
+                result = Some(pte);
+                break;
+            }
+            if pte.is_valid() == false {
+                return None;
+            }
+            ppn = pte.ppn();
+        }
+        result
+    }
+
+    // 把虚拟页 映射到页表中, 并创建一个 物理页, 然后把物理页ppn组成pte的格式, copy到 虚拟页对应的页表项内
+    pub fn map(&mut self, vpn: VirtPageNum, ppn: PhysPageNum, flags: PTEFlags) {
+        // 查找vpn 没有中间节点就创建出来
+        let pte = self.find_pte_create(vpn).unwrap();
+        assert!(!pte.is_valid(), "vpn {:?} is mapped before mapping", vpn.0);
+        *pte = PageTableEntry::from(ppn, flags | PTEFlags::V);
+    }
+
+    // 把虚拟页 取消映射(注意, 取消之后, 外部一定要 把该虚拟页对应的物理页帧 还给全局的物理页帧管理器)
+    pub fn unmap(&mut self, vpn: VirtPageNum) {
+        let pte = self.find_pte(vpn).unwrap();
+        assert!(pte.is_valid(), "vpn {:?} is invalid before unmapping", vpn.0);
+        *pte = PageTableEntry::new();
+    }
+
+    // 根据虚拟页号, 找到页表中对应的pte
+    pub fn get_pte(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
+        self.find_pte(vpn).map(|pte| *pte)
+    }
+
+    // 根据虚拟地址, 找到页表中对应的地址
+    pub fn get_pa(&self, va:VirtAddr) -> Option<PhysAddr>{
+        // vp对应的vpn
+        let vpn = va.floor();
+
+        // 找到对应vpn对应的pte
+        if let Some(pte) = self.get_pte(vpn) {
+            // 从pte找到 真实的物理页帧
+            let ppn = pte.ppn();
+
+            // 得到ppn的地址
+            let pa: PhysAddr = ppn.into();
+            let pa_usize: usize = pa.into();
+
+            // 虚拟地址对应的页内偏移
+            let va_offset = va.page_offset();
+            Some((pa_usize+va_offset).into())
+        } else {
+            None
+        }
+    }
+}
+
+// 根据token得到用户应用的页表, 并根据ptr 和len 在页表中找到指定的数据
+pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&'static mut [u8]> {
+    // 根据寄存器token, 得到用户页表
+    let page_table = PageTable::from_token(token);
+
+    // 用户空间指定数据 的 逻辑起始位置
+    let mut start = ptr as usize;
+    // 用户空间指定数据的 逻辑结束位置
+    let end = start + len;
+
+    // 循环 逻辑的起始和结束位置, 根据页表,在物理页中寻找数据
+    // 可能 start 和end 跨了很多页, 需要找到每一页并偏移
+    let mut v = Vec::new();
+    while start < end {
+        // 逻辑起始位置对应实际的物理页帧
+        let start_va = VirtAddr::from(start);
+        let mut vpn = start_va.floor();
+        let ppn = page_table.get_pte(vpn).unwrap().ppn();
+
+        // 当前start页 的结束页 就是下一个逻辑页 start+1 的位置
+        vpn = (vpn.0+1).into();
+        let mut end_va: VirtAddr = vpn.into();
+
+        // 找到 比较小的结束位置
+        end_va = end_va.min(VirtAddr::from(end));
+
+        // 如果 不是最后一页, 就找到当前物理页的所有4096字节 进行拷贝
+        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
+}
+
+// 根据token, 转换指定 虚拟地址空间中的指针ptr 为 指定 物理页帧内真实地址的 引用 &T
+pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T {
+    let page_table = PageTable::from_token(token);
+    let va = ptr as usize;
+
+    page_table
+        .get_pa(VirtAddr::from(va))
+        .unwrap()
+        .get_mut()
+}
+
+// 从token中映射虚拟地址页表, 并根据 虚拟地址ptr 逐个累加地址, 在物理页帧真实地址获得ptr后面的每个字符, 遇到 0 截止
+pub fn translated_str(token: usize, ptr: *const u8) -> String {
+    let page_table = PageTable::from_token(token);
+    let mut string = String::new();
+    let mut va = ptr as usize;
+    loop {
+        let ch: u8 = *(page_table
+            .get_pa(VirtAddr::from(va))
+            .unwrap()
+            .get_mut()
+        );
+        if ch == 0 {
+            break;
+        } else {
+            string.push(ch as char);
+            va += 1;
+        }
+    }
+    string
+}
+
+
+

ch5/os/src/sbi.rs

@@ -0,0 +1,45 @@
+use core::arch::asm;
+
+// legacy extensions: ignore fid
+const SBI_SET_TIMER: usize = 0;
+const SBI_CONSOLE_PUTCHAR: usize = 1;
+const SBI_CONSOLE_GETCHAR: usize = 2;
+const SBI_CLEAR_IPI: usize = 3;
+const SBI_SEND_IPI: usize = 4;
+const SBI_REMOTE_FENCE_I: usize = 5;
+const SBI_REMOTE_SFENCE_VMA: usize = 6;
+const SBI_REMOTE_SFENCE_VMA_ASID: usize = 7;
+
+// system reset extension
+const SRST_EXTENSION: usize = 0x53525354;
+const SBI_SHUTDOWN: usize = 0;
+
+#[inline(always)]
+fn sbi_call(eid: usize, fid: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
+    let mut ret;
+    unsafe {
+        asm!(
+        "ecall",
+        inlateout("x10") arg0 => ret,
+        in("x11") arg1,
+        in("x12") arg2,
+        in("x16") fid,
+        in("x17") eid,
+        );
+    }
+    ret
+}
+
+pub fn console_put_char(c: usize) {
+    sbi_call(SBI_CONSOLE_PUTCHAR, 0, c, 0, 0);
+}
+
+pub fn shutdown() -> ! {
+    sbi_call(SRST_EXTENSION, SBI_SHUTDOWN, 0, 0, 0);
+    panic!("It should shutdown!")
+}
+
+// 设置 mtimecmp 的值
+pub fn set_timer(timer: usize) {
+    sbi_rt::set_timer(timer as _);
+}

ch5/os/src/sync/mod.rs

@@ -0,0 +1,4 @@
+//! Synchronization and interior mutability primitives
+
+mod up;
+pub use up::UPSafeCell;

ch5/os/src/sync/up.rs

@@ -0,0 +1,31 @@
+//! Uniprocessor interior mutability primitives
+
+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),
+        }
+    }
+    /// Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.
+    pub fn exclusive_access(&self) -> RefMut<'_, T> {
+        self.inner.borrow_mut()
+    }
+}

ch5/os/src/syscall/fs.rs

@@ -0,0 +1,61 @@
+//! File and filesystem-related syscalls
+
+use sbi_rt::legacy::console_getchar;
+use crate::mm::page_table::translated_byte_buffer;
+use crate::print;
+use crate::task::manager::TASK_MANAGER;
+use crate::task::processor::current_user_token;
+use crate::task::suspend_current_and_run_next;
+
+const FD_STDOUT: usize = 1;
+
+// 从标准输入读取 指定长度的字符到 虚拟地址buffer中, 目前只支持长度为1
+pub fn sys_read(fd: usize, buf: *const u8, len: usize) -> isize {
+    match fd {
+        FD_STDIN => {
+            assert_eq!(len, 1, "Only support len = 1 in sys_read!");
+            let mut c: usize;
+            loop {
+                // 利用sbi 从键盘获取输入的
+                c = console_getchar();
+                // 如果是0 说明还没有输入
+                if c == 0 {
+                    // 切换进程
+                    suspend_current_and_run_next();
+                    continue;
+                } else {
+                    break;
+                }
+            }
+            // 把读取的字符 写入到应用的地址空间
+            let ch = c as u8;
+            // 由于目前长度只能为1, 这里直接获取第0个slice 写入
+            let mut buffers = translated_byte_buffer(current_user_token(), buf, len);
+            unsafe {
+                buffers[0].as_mut_ptr().write_volatile(ch);
+            }
+            1
+        }
+        _ => {
+            panic!("Unsupported fd in sys_read!");
+        }
+    }
+}
+
+/// write buf of length `len`  to a file with `fd`
+pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize {
+    match fd {
+        FD_STDOUT => {
+            // 根据当前页表 找到物理内存基地址
+            // 这里需要从应用的地址空间里面寻找数据
+            let buffers = translated_byte_buffer(current_user_token(), buf, len);
+            for buffer in buffers {
+                print!("{}", core::str::from_utf8(buffer).unwrap());
+            }
+            len as isize
+        }
+        _ => {
+            panic!("Unsupported fd in sys_write!");
+        }
+    }
+}

ch5/os/src/syscall/mod.rs

@@ -0,0 +1,35 @@
+const SYSCALL_READ: usize = 63;
+const SYSCALL_WRITE: usize = 64;
+const SYSCALL_EXIT: usize = 93;
+const SYSCALL_YIELD: usize = 124;
+const SYSCALL_GET_TIME: usize = 169;
+const SYSCALL_GETPID: usize = 172;
+const SYSCALL_SBRK: usize = 214;
+const SYSCALL_FORK: usize = 220;
+const SYSCALL_EXEC: usize = 221;
+const SYSCALL_WAITPID: usize = 260;
+
+mod fs;
+mod process;
+
+use fs::*;
+use process::*;
+use crate::println;
+
+/// 根据syscall_id 进行分发
+pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
+
+    match syscall_id {
+        SYSCALL_READ => sys_read(args[0], args[1] as *const u8, args[2]),
+        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_SBRK => sys_sbrk(args[0] as i32),
+        SYSCALL_GETPID => sys_getpid(),
+        SYSCALL_FORK => sys_fork(),
+        SYSCALL_EXEC => sys_exec(args[0] as *const u8),
+        SYSCALL_WAITPID => sys_waitpid(args[0] as isize, args[1] as *mut i32),
+        _ => panic!("Unsupported syscall_id: {}", syscall_id),
+    }
+}

ch5/os/src/syscall/process.rs

@@ -0,0 +1,142 @@
+//! App management syscalls
+use alloc::sync::Arc;
+use crate::loader::get_app_data_by_name;
+use crate::mm::page_table::{translated_refmut, translated_str};
+// use crate::batch::run_next_app;
+use crate::println;
+use crate::task::{exit_current_and_run_next, suspend_current_and_run_next};
+use crate::task::manager::add_task;
+use crate::task::processor::{change_program_brk, current_task, current_user_token};
+use crate::task::task::TaskStatus;
+// use crate::task::{change_program_brk, exit_current_and_run_next, suspend_current_and_run_next};
+use crate::timer::get_time_ms;
+
+/// 任务退出, 并立即切换任务
+pub fn sys_exit(exit_code: i32) -> ! {
+    println!("[kernel] Application exited with code {}", exit_code);
+    exit_current_and_run_next(exit_code);
+    panic!("Unreachable in sys_exit!");
+}
+
+pub fn sys_yield() -> isize {
+    suspend_current_and_run_next();
+    0
+}
+
+pub fn sys_get_time() -> isize {
+    get_time_ms() as isize
+}
+
+// 根据传入的 size 对当前堆进行扩容和缩小, 返回值为 失败 或者 申请的空间的起始位置
+pub fn sys_sbrk(size: i32) -> isize {
+    if let Some(old_brk) = change_program_brk(size) {
+        old_brk as isize
+    } else {
+        -1
+    }
+}
+
+pub fn sys_getpid() -> isize {
+    current_task().unwrap().pid.0 as isize
+}
+
+pub fn sys_fork() -> isize {
+    // 创建一个会 跳到trap_return的子进程
+    let current_task = current_task().unwrap();
+    let new_task = current_task.fork();
+    let new_pid = new_task.pid.0;
+
+    // 修改子进程 trap_context 中的返回值, 因为父进程在调用sys_call中之后会立即返回
+    let trap_cx = new_task.inner_exclusive_access().get_trap_cx();
+    // 我们之前 进入这个函数的时候, 已经对子进程的 结束陷入的进行返回的地址 +4了
+    // 所以现在只需要改变子进程 陷入之后的返回值即可, 将来子进程会直接从 trap_return运行
+    trap_cx.x[10] = 0;
+    // 添加子任务到全局的 任务管理器
+    add_task(new_task);
+
+    // 返回 子进程的pid 给父进程
+    new_pid as isize
+}
+
+// 根据 文件名, 创建替换当前执行的任务
+pub fn sys_exec(path: *const u8) -> isize {
+    // 当前token
+    let token = current_user_token();
+    // 得到 文件名
+    let path = translated_str(token, path);
+    // 根据文件名对应的二进制数据, 调用exec 替换
+    if let Some(data) = get_app_data_by_name(path.as_str()) {
+        let task = current_task().unwrap();
+        task.exec(data);
+        0
+    } else {
+        // 不存在 返回-1
+        -1
+    }
+}
+
+/// pid分为如下几种情况:
+///
+/// - -1 表示等待任意进程结束
+///
+/// - 1235 表示只等待pid为1234的进程
+///
+/// 返回值会返回如下:
+///
+/// - -1 表示要等待的进程不是-1(任意进程)是指定进程, 但是指定进程并没有在children中
+///
+/// - -2 表示目前还没有僵尸进程
+///
+/// - pid 返回被回收的pid
+///
+
+pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
+    // 当前进程 这里是父进程
+    let task = current_task().unwrap();
+    // find a child process
+
+    // 如果当前进程内没有对应pid的子进程 则返回-1, 如果传进来的pid是-1, 则表示任何一个子进程都是符合要求的
+    let mut inner = task.inner_exclusive_access();
+    if !inner
+        .children
+        .iter()
+        .any(|p| pid == -1 || pid as usize == p.get_pid())
+    {
+        return -1;
+        // ---- release current PCB
+    }
+
+    // 找到 指定进程且进程为 僵尸进程或者是任意进程
+    let pair = inner.children.iter().enumerate().find(|(_, p)| {
+        // ++++ temporarily access child PCB lock exclusively
+        p.inner_exclusive_access().task_status == TaskStatus::Zombie && (pid == -1 || pid as usize == p.get_pid())
+        // ++++ release child PCB
+    });
+
+    // 如果找到
+    if let Some((idx, _)) = pair {
+        // 从子列表中删除并取出
+        let child = inner.children.remove(idx);
+        // confirm that child will be deallocated after removing from children list
+        // 保证chlid当前是唯一存在的引用, 而不会出现在某个进程的子进程向量中, 更不会出现在处理器监控器或者任务管理器中, child在当前作用于结束后引用计数为0, 彻底删除,
+        // 作用域结束后, 内部的pid 和kernel stack 执行他们自己的drop方法(返还pid给pid管理器, 返还kernel stack的资源还给 KERNEL_SPACE, ), 还有 inner->memory_set->page_table->frames 三级页表本身所占的物理帧
+
+        assert_eq!(Arc::strong_count(&child), 1);
+        let found_pid = child.get_pid();
+        // ++++ temporarily access child TCB exclusively
+        // 找到子进程的退出码
+        let exit_code = child.inner_exclusive_access().exit_code;
+        // ++++ release child PCB
+
+        // 将退出码, 写入到当前进程的地址空间
+        let exit_code_ref = translated_refmut(inner.memory_set.token(), exit_code_ptr);
+        *exit_code_ref = exit_code;
+
+        // 返回回收的子进程的pid
+        found_pid as isize
+    } else {
+        // 如果制定进程不是僵尸进程 返回-2, 上层用户应用调用的 wait pid 会继续等待
+        -2
+    }
+    // ---- release current PCB lock automatically
+}

ch5/os/src/task/context.rs

@@ -0,0 +1,44 @@
+use crate::trap::trap_return;
+
+// TCB的字段 用来保存cpu 在内核切换人物的时候 寄存器还有栈顶的信息, 这个结构体将来会传到 switch.S 中的汇编中
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct TaskContext{
+    ra: usize,  // 保存了进行切换完毕之后需要 跳转继续执行的地址
+    sp: usize,  // 当前任务的在内核中的内核栈的栈顶, 这个会被switch 保存与恢复
+    s: [usize; 12]  // 当前任务内核 有必要 保存的寄存器
+}
+
+
+impl TaskContext{
+    // 初始的内容
+    pub fn new() -> Self {
+        Self {
+            ra: 0,
+            sp: 0,
+            s: [0; 12],
+        }
+    }
+
+    // 从kernel_stack_ptr 创建一个 任务上下文
+    // 并把任务上下文的返回地址设置为 trap.S的返回符号的地方
+    pub fn from(kernel_stack_ptr: usize) -> Self{
+        extern "C" {
+            fn __restore();
+        }
+        Self {
+            ra: __restore as usize,  // 新创建的任务, 在switch ret 之后 直接进入 trap返回函数
+            sp: kernel_stack_ptr,  // 这里设置 应用内核栈的栈顶了, 后面会被switch 恢复, 所以我们在trap.S中 注释mv sp, a0
+            s: [0; 12],
+        }
+    }
+
+    /// 根据用户当前内核栈做的栈顶 构造一个 任务上下文, 并把 trap_return 设置为 switch切换 ret的返回地址
+    pub fn goto_trap_return(kstack_ptr: usize) -> Self {
+        Self {
+            ra: trap_return as usize,  // 这里是 在内核空间的 函数地址 (当然 task context 只有在内核态才是可见的)
+            sp: kstack_ptr,
+            s: [0; 12],
+        }
+    }
+}

ch5/os/src/task/manager.rs

@@ -0,0 +1,46 @@
+use alloc::collections::VecDeque;
+use alloc::sync::Arc;
+use lazy_static::lazy_static;
+use crate::println;
+use crate::task::task::TaskControlBlock;
+use crate::task::UPSafeCell;
+
+/// 任务管理器 仅负责管理所有任务, 由ch4 TaskManager 拆分的,
+/// 先入先出的双端队列
+pub struct TaskManager {
+    ready_queue: VecDeque<Arc<TaskControlBlock>>,
+}
+
+impl TaskManager {
+    pub fn new() -> Self {
+        Self {
+            ready_queue: VecDeque::new(),
+        }
+    }
+}
+
+impl TaskManager {
+    // 添加一个任务到 队列中
+    pub fn add(&mut self, task: Arc<TaskControlBlock>) {
+        self.ready_queue.push_back(task);
+    }
+    // 如果有任务, 弹出第一个任务
+    pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>> {
+        self.ready_queue.pop_front()
+    }
+}
+
+
+
+lazy_static! {
+    // 全局的任务管理器
+    pub static ref TASK_MANAGER: UPSafeCell<TaskManager> = unsafe { UPSafeCell::new(TaskManager::new()) };
+}
+/// 给全局任务管理器添加任务
+pub fn add_task(task: Arc<TaskControlBlock>) {
+    TASK_MANAGER.exclusive_access().add(task);
+}
+// 全局任务管理器 弹出任务
+pub fn pop_task() -> Option<Arc<TaskControlBlock>> {
+    TASK_MANAGER.exclusive_access().fetch()
+}

ch5/os/src/task/mod.rs

@@ -0,0 +1,130 @@
+use lazy_static::lazy_static;
+use alloc::vec::Vec;
+use crate::config::MAX_APP_NUM;
+use crate::sync::UPSafeCell;
+use crate::task::task::{TaskControlBlock, TaskStatus};
+use crate::loader::{get_num_app, get_app_data};
+use crate::println;
+use crate::sbi::shutdown;
+use crate::task::context::TaskContext;
+use crate::task::manager::{add_task, TASK_MANAGER};
+use crate::task::processor::{kernel_time_start, refresh_stop_clock, schedule, take_current_task};
+use crate::task::switch::__switch;
+use crate::timer::{get_time_ms, get_time_us};
+use crate::trap::TrapContext;
+use alloc::sync::Arc;
+use crate::loader::get_app_data_by_name;
+
+mod context;
+mod switch;
+pub mod task;
+mod pid;
+pub mod manager;
+pub mod processor;
+
+pub use processor::{run_tasks};
+
+pub const IDLE_PID: usize = 0;
+
+lazy_static! {
+    /// 初始化用户shell的全局进程, 他的pid是0
+    pub static ref INITPROC: Arc<TaskControlBlock> = Arc::new(TaskControlBlock::from(get_app_data_by_name("initproc").unwrap()));
+}
+
+/// 添加初始化 Process 到 全局任务管理器
+pub fn add_initproc() {
+    add_task(INITPROC.clone());
+}
+
+// 挂起当前运行下一个, 需要把当前任务 从Process中 take 取出来, 然后再 push回 全局的任务管理器
+pub fn suspend_current_and_run_next() {
+
+    // 必须有一个程序在运行,
+    let task = take_current_task().unwrap();
+
+    // ---- access current TCB exclusively
+    // 当前正在执行的Process
+    let mut task_inner = task.inner_exclusive_access();
+    let task_cx_ptr = &mut task_inner.task_cx as *mut TaskContext;
+    // Change status to Ready
+    task_inner.task_status = TaskStatus::Ready;
+
+    // 统计内核时间
+    let kernel_time = refresh_stop_clock();
+    task_inner.kernel_time += kernel_time;
+
+    drop(task_inner);
+    // ---- release current PCB
+
+    // 把当前任务 push回全局的任务管理器
+    add_task(task);
+
+    // jump to scheduling cycle
+    schedule(task_cx_ptr);
+}
+
+pub fn exit_current_and_run_next(exit_code: i32) {
+    // 从 Process 管理器中 转移所有权的取出当前cpu执行的任务
+    let task = take_current_task().unwrap();
+
+    // 当前pid
+    let pid = task.get_pid();
+
+    // 如果是idle进程
+    if pid == IDLE_PID {
+        println!(
+            "[kernel] Idle process exit with exit_code {} ...",
+            exit_code
+        );
+        if exit_code != 0 {
+            //crate::sbi::shutdown(255); //255 == -1 for err hint
+            shutdown()
+        } else {
+            //crate::sbi::shutdown(0); //0 for success hint
+            shutdown()
+        }
+    }
+
+    // 改变pcb 的状态, 从当前task获取inner, 也就是当前当前pcb需要变化的值
+    let mut inner = task.inner_exclusive_access();
+    // 将状态更改为 僵尸进程, 供后续父进程查找回收资源
+    inner.task_status = TaskStatus::Zombie;
+    // 写入退出码
+    inner.exit_code = exit_code;
+    // 不需要修改父进程, 因为所有进程的父进程这里都为 initproc
+
+    // 把当前进程, 所有的子进程, 都挂载到 initproc进程
+    {
+        let mut initproc_inner = INITPROC.inner_exclusive_access();
+        for child in inner.children.iter() {
+            child.inner_exclusive_access().parent = Some(Arc::downgrade(&INITPROC));  // 父进程 一个弱引用
+            initproc_inner.children.push(child.clone());  // 挂载到initproc进程的childre中, 引用计数 +1, 现在是2
+        }
+    }
+
+    inner.children.clear();  // 子进程引用计数-1 现在又变成1了
+
+    // 统计内核时间
+    let kernel_time = refresh_stop_clock();
+    inner.kernel_time += kernel_time;
+    println!("[kernel] user_time: {}ms, kernel_time: {}ms", inner.user_time /1000, inner.kernel_time / 1000);
+
+
+    // 释放当前地址空间中, 逻辑段清空, areas->MapArea->data_frames->FrameTracker 执行析构, 过程是把areas中的物理页帧 根据 RAII还给操作系统
+    // 注意 页表本身占用的 三级页表的物理帧(page_table->frames), 还没有被释放, 因为我们还需要使用, 这需要父进程管理进行释放
+    inner.memory_set.recycle_data_pages();
+    drop(inner);
+
+
+    // 手动删除tcb, 后面这里永远不会执行了, 我们智能指针需要手动释放(这里需要给引用计数-1)
+    drop(task);
+
+    // 当前task 函数 为什么在 recycle_data_pages 之后还能执行? 函数栈帧为什么还能使用? 是因为我们虽然把 应用程序锁使用的逻辑页帧都取消映射了, 但是关于 task中的 pid 和kernel stack 还没有被释放
+    // task 他在被fork的时候 parent_inner.children.push(task_control_block.clone()); 也clone了自己一份到父进程中, 所以这里删除drop只是删除了当前 Process中管理的引用计数(后续我们不会执行到这里了, 需要手动删除)
+
+    // 这个进程不会被执行了, 我们当前栈帧随便创建一个上下文就好了
+    let mut _unused = TaskContext::new();
+
+    // 输出一下
+    schedule(&mut _unused as *mut _);
+}

ch5/os/src/task/pid.rs

@@ -0,0 +1,149 @@
+use alloc::vec::Vec;
+use lazy_static::lazy_static;
+use crate::config::{KERNEL_STACK_SIZE, PAGE_SIZE, TRAMPOLINE};
+use crate::mm::address::VirtAddr;
+use crate::mm::memory_set::{KERNEL_SPACE, MapPermission};
+use crate::sync::UPSafeCell;
+
+// pid分配器
+pub struct PidAllocator {
+    current: usize,  // 当前分配到多少号了
+    recycled: Vec<usize>,  // 被回收的pid, 后续可以再次利用
+}
+
+// 全局的pid分配器
+lazy_static! {
+    pub static ref PID_ALLOCATOR: UPSafeCell<PidAllocator> =
+        unsafe { UPSafeCell::new(PidAllocator::new()) };
+}
+
+pub fn pid_alloc() -> PidHandle {
+    PID_ALLOCATOR.exclusive_access().alloc()
+}
+
+
+impl PidAllocator {
+    pub fn new() -> Self {
+        Self {
+            current: 0,
+            recycled: Vec::new(),
+        }
+    }
+}
+
+impl PidAllocator {
+    // 分配一个pid
+    pub fn alloc(&mut self) -> PidHandle {
+        if let Some(pid) = self.recycled.pop() {
+            PidHandle(pid)
+        } else {
+            let current = self.current;
+            self.current += 1;
+            PidHandle(current)
+        }
+    }
+
+    // 取消分配一个pid
+    pub fn dealloc(&mut self, pid: usize) {
+        assert!(pid < self.current);
+        // 防止二次释放
+        assert!(
+            !self.recycled.iter().any(|tmp_pid| *tmp_pid == pid),
+            "pid {} has been deallocated!",
+            pid
+        );
+
+        self.recycled.push(pid);
+    }
+}
+
+
+// 用来表示进程的唯一标识符, RAII思想来进行释放管理
+pub struct PidHandle(pub usize);
+
+// pid_handle 被drop时, 同时把pid 还给全局管理器
+impl Drop for PidHandle {
+    fn drop(&mut self) {
+        PID_ALLOCATOR.exclusive_access().dealloc(self.0);
+    }
+}
+
+
+/// 得到 "用户程序的内核栈" 的在 内核本身地址空间 中的虚拟位置(当然由于恒等映射其实也是实际的物理地址)
+/// 这个在 跳板的下面的某个位置
+/// 每个用户除了分配 KERNEL_STACK_SIZE 大小外, 还额外 增加 一个PAGE_SIZE 放在比栈底要高的地址 用来隔离每个用户内核栈
+/// 根据 pid 在相应的位置, 得到app 内核栈的它处于的位置, 位置, 注意代码实现, 这个是有保护页面的(1 pagesize),
+/// 在逻辑地址空间存在保护页面(保护页面不会被映射), 但是在物理地址空间,这个保护页会被随时被物理页帧管理器分配走
+/// 返回的 top是内存的高地址, bottom是内存的低地址
+pub fn kernel_stack_position(pid: usize) -> (usize, usize) {
+    let top = TRAMPOLINE - pid * (KERNEL_STACK_SIZE + PAGE_SIZE);
+    // 栈底只需要 KERNEL_STACK_SIZE 即可,
+    let bottom = top - KERNEL_STACK_SIZE;
+    (bottom, top)
+}
+
+// 新的结构体, 内核栈, 之前我们是根据 app_id 找到的, 现在我们需要改成 统一分配的pid, 根据pid摆放应用内核栈的位置
+pub struct KernelStack {
+    pid: usize,
+}
+
+impl KernelStack {
+    // push 一个 泛型, 到 内核栈中, 直接减去T的大小, 再写入即可
+    pub fn push_on_top<T: Sized>(&self, value: T) -> *mut T {
+        let kernel_stack_top = self.get_top();
+        let kernel_stack_top = self.get_top();
+        let ptr_mut = (kernel_stack_top - core::mem::size_of::<T>()) as *mut T;
+        unsafe {
+            *ptr_mut = value;
+        }
+        ptr_mut
+    }
+
+    // 得到当前内核栈的 栈底(高地址)
+    pub fn get_top(&self) -> usize {
+        let (_, kernel_stack_top) = kernel_stack_position(self.pid);
+        kernel_stack_top
+    }
+}
+
+impl KernelStack {
+    // 根据 pid handle 在内核空间(最高页的下面) 某个位置, 创建一个 逻辑段 作为应用的内核栈
+    pub fn from(pid_handle: &PidHandle) -> Self {
+        let pid = pid_handle.0;
+
+        // 根据 pid 创建受保护的用户的任务内核栈, 并得到栈的起始地址和结束地址, 这个在次高页的下面的 某个位置
+        // kernel_stack_bottom = kernel_stack_top - PAGESIZE * 2
+        // kernel_stack_top 是当前栈的栈顶, 同时也是现在没有push操作也是栈底
+        // 这里都是虚拟地址
+        let (kernel_stack_bottom, kernel_stack_top) = kernel_stack_position(pid);
+
+        // 把用户的内核栈逻辑段, 映射并创建出来实际的物理页帧, 到内核地址空间, 供内核态可以进行寻址找到用户应用的内核栈,
+        // 这里使用虚拟映射  而不是恒等映射, 是因为需要动态调整?
+        // 这个只有在内核会用到
+        KERNEL_SPACE
+            .exclusive_access()
+            .insert_framed_area(
+                kernel_stack_bottom.into(),
+                kernel_stack_top.into(),
+                MapPermission::R | MapPermission::W,
+            );
+        KernelStack { pid: pid_handle.0 }
+    }
+}
+
+
+// 当kernel stack 生命周期结束, 对应 new 出来的一个 应用内核栈 逻辑段也随之删除
+// 注意! 一般这个是在 wait_pid 内用的, 用于父进程回收子进程资源时, 子进程内的字段根据RAII执行
+impl Drop for KernelStack {
+    fn drop(&mut self) {
+        let (kernel_stack_bottom, _) = kernel_stack_position(self.pid);
+        let kernel_stack_bottom_va: VirtAddr = kernel_stack_bottom.into();
+        KERNEL_SPACE
+            .exclusive_access()
+            .remove_area_with_start_vpn(kernel_stack_bottom_va.into());
+    }
+}
+
+
+
+

ch5/os/src/task/processor.rs

@@ -0,0 +1,187 @@
+use alloc::sync::Arc;
+use lazy_static::lazy_static;
+use crate::println;
+use crate::task::context::TaskContext;
+use crate::task::switch::__switch;
+use crate::task::task::{TaskControlBlock, TaskStatus};
+use crate::trap::TrapContext;
+use crate::sync::UPSafeCell;
+use crate::task::manager::{pop_task, TASK_MANAGER};
+use crate::timer::{get_time_ms, get_time_us};
+
+///维护在一个处理器上正在执行的任务, 这在ch4 中是 TaskManager做的, 现在拆分
+pub struct Processor {
+    /// 当前处理器上正在执行的任务, 他是一个被option 包裹的 智能指针, 保证 TCB 要不在这个结构体中, 要不就是在全局的任务管理器上
+    current: Option<Arc<TaskControlBlock>>,
+    /// 当前处理器上的 idle 控制流的任务上下文, 当任务切换的时候, 先切换到这个
+    /// 这样做的主要目的是使得换入/换出进程和调度执行流在内核层各自执行在不同的内核栈上,
+    /// 分别是进程自身的内核栈和内核初始化时使用的启动栈
+    /// 这样的话, 调度相关的数据不会出现在进程内核栈上,
+    /// 也使得调度机制对于换出进程的Trap执行流是不可见的
+    /// 它在决定换出的时候只需调用schedule而无需操心调度的事情
+    /// 从而各执行流的分工更加明确了, 虽然带来了更大的开销
+    /// 虽然 永远不会执行这个 task context 的任务, 他只保存 内核的启动栈
+    idle_task_cx: TaskContext,
+    pub clock_time: usize,  // 处理器时间
+}
+
+
+impl Processor {
+    ///Create an empty Processor
+    /// 一旦程序开始运行, 就开始在内核栈或者用户栈之间切换, 永远 不会运行到这个, 这个就是保存 内核的启动栈的
+    pub fn new() -> Self {
+        Self {
+            current: None,
+            idle_task_cx: TaskContext::new(),
+            clock_time: 0
+        }
+    }
+}
+
+impl Processor {
+    // 得到当前 task context 的指针
+    fn get_idle_task_cx_ptr(&mut self) -> *mut TaskContext {
+        &mut self.idle_task_cx as *mut _
+    }
+    /// 取出当前正在执行的任务
+    pub fn take_current(&mut self) -> Option<Arc<TaskControlBlock>> {
+        self.current.take()
+    }
+
+    ///当前正在执行的任务的 copy
+    pub fn current(&self) -> Option<Arc<TaskControlBlock>> {
+        self.current.as_ref().map(Arc::clone)
+    }
+
+    // 掐表函数
+    fn refresh_stop_clock(&mut self) -> usize {
+        // 上次停表的时间
+        let start_time = self.clock_time;
+        // 当前时间
+        self.clock_time = get_time_us();
+        // 返回 当前时间 - 上次停表时间 = 时间间距
+        self.clock_time - start_time
+    }
+
+    // 即将进入用户态, 把之前使用的内核时间统计
+    fn user_time_start(&mut self) {
+        let use_clock_time = self.refresh_stop_clock();
+        self.current.as_ref().unwrap().inner_exclusive_access().kernel_time += use_clock_time;
+    }
+
+    fn kernel_time_start(&mut self) {
+        let use_clock_time = self.refresh_stop_clock();
+        self.current.as_ref().unwrap().inner_exclusive_access().user_time += use_clock_time;
+    }
+}
+
+
+
+// 全局 描述cpu状态的管理器
+lazy_static! {
+    pub static ref PROCESSOR: UPSafeCell<Processor> = unsafe { UPSafeCell::new(Processor::new()) };
+}
+
+
+// 循环 全局的任务管理器'fetch_task'获取需要运行的下一个进程, 并通过'__switch' 和当前process切换进程,
+// 这和之前的 run_first_task 差不多
+pub fn run_tasks() {
+    loop {
+        // 获得当前 进程的管理对象
+        let mut processor = PROCESSOR.exclusive_access();
+
+        // 弹出一个任务
+        if let Some(task) = pop_task() {
+            // 当前运行的进程(第一次运行时,这里是空的 zero, 但是不影响, 因为永远不会执行到第一次运行的任务)
+            let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
+
+            // 获得下一个需要运行的进程 的task context的指针
+            let mut task_inner = task.inner_exclusive_access();
+            let next_task_cx_ptr = &task_inner.task_cx as *const TaskContext;
+            task_inner.task_status = TaskStatus::Running;
+
+            // 删除内部可变性的引用, 这里需要手动释放
+            drop(task_inner);
+
+            // 修改process的状态, 把下一个需要运行的进程 move到 Process中被管理, 保证引用计数为1
+            processor.current = Some(task);
+
+            // 这里需要手动释放, 同上, 因为switch跳出作用域了, 不会通过作用域自动析构 refcell
+            drop(processor);
+
+            unsafe {
+                __switch(idle_task_cx_ptr, next_task_cx_ptr);
+
+                // 调用 schedule 之后 内部又调用__switch, next task 也就是idle task会走入到这里, 开启新的循环获取新的任务
+                // 其实 idle task 并不会执行, 他只是保存 内核的启动栈 也就是当前函数 的寄存器状态
+            }
+        }
+    }
+}
+
+
+// 掐表函数
+pub fn refresh_stop_clock() -> usize {
+    PROCESSOR.exclusive_access().refresh_stop_clock()
+}
+
+// 用户应用 进入用户态开始计时
+pub fn user_time_start(){
+    PROCESSOR.exclusive_access().user_time_start();
+}
+
+// 用户应用 进入内核态开始计时
+pub fn kernel_time_start(){
+    PROCESSOR.exclusive_access().kernel_time_start();
+}
+
+// 取出当前正在执行的任务
+pub fn take_current_task() -> Option<Arc<TaskControlBlock>> {
+    PROCESSOR.exclusive_access().take_current()
+}
+
+// 返回当前正在执行的任务的 copy版本
+pub fn current_task() -> Option<Arc<TaskControlBlock>> {
+    PROCESSOR.exclusive_access().current()
+}
+
+//得到当前正在执行任务的token
+pub fn current_user_token() -> usize {
+    // 得到当前正在执行的任务
+    let task = current_task().unwrap();
+    // 得到当前正在执行任务的token
+    let token = task.inner_exclusive_access().get_user_token();
+    token
+}
+
+// 得到当前 task context 的指针
+pub fn current_trap_cx() -> &'static mut TrapContext {
+    current_task()
+        .unwrap()
+        .inner_exclusive_access()
+        .get_trap_cx()
+}
+
+// 扩张/缩减, 当前运行进程的地址空间中的堆段, 指定字节的数据
+pub fn change_program_brk(size: i32) -> Option<usize> {
+    current_task().as_ref().unwrap().inner_exclusive_access().change_program_brk(size)
+}
+
+
+// 传入当前运行的任务指针, 切换到 idle 任务
+// 用尽时间片, 或者调用 yield之后会调用这个, 调用这个之后, 会回到 run_task __switch返回的位置, 开启下一轮循环 中执行
+pub fn schedule(switched_task_cx_ptr: *mut TaskContext) {
+    // 进程管理对象
+    let mut processor = PROCESSOR.exclusive_access();
+
+    // 得到当前进程管理中 task context 指针
+    let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
+    drop(processor);
+
+    // 切换 汇编会保存当前的寄存器状态到 switched_task_cx_ptr 中, 然后根据 idle_task_cx_ptr 继续执行 __switch 的下一行, 结束当前循环, 开启新的循环
+    unsafe {
+        __switch(switched_task_cx_ptr, idle_task_cx_ptr);
+    }
+}
+
+

ch5/os/src/task/switch.S

@@ -0,0 +1,44 @@
+# os/src/task/switch.S
+
+.altmacro
+.macro SAVE_SN n
+    sd s\n, (\n+2)*8(a0)  # 将寄存器s(n)的值保存到当前任务的上下文中
+.endm
+
+.macro LOAD_SN n
+    ld s\n, (\n+2)*8(a1)  # 从下一个任务的上下文中加载寄存器s(n)的值
+.endm
+    .section .text
+    .globl __switch
+
+__switch:
+    # 阶段 [1]
+    # __switch(
+    #     current_task_cx_ptr: *mut TaskContext,
+    #     next_task_cx_ptr: *const TaskContext
+    # )
+
+    # 阶段 [2] 保存当前寄存器状态到 current_task_cx_ptr
+    # save kernel stack of current task
+    sd sp, 8(a0)  # 将当前任务的在内核栈顶 保存到当前任务current_task_cx_ptr的上下文中
+    # save ra & s0~s11 of current execution
+    sd ra, 0(a0)  # 将当前执行的ra和s0~s11寄存器的值保存到当前任务current_task_cx_ptr的上下文中
+    .set n, 0
+    .rept 12
+        SAVE_SN %n  # 保存寄存器s0~s11的值到当前任务的上下文中
+        .set n, n + 1
+    .endr
+
+    # 阶段 [3] 恢复next_task_cx_ptr 的状态
+    # restore ra & s0~s11 of next execution
+    ld ra, 0(a1)  # 从下一个任务的上下文中加载ra寄存器的值
+    .set n, 0
+    .rept 12
+        LOAD_SN %n  # 从下一个任务的上下文中加载寄存器s0~s11的值
+        .set n, n + 1
+    .endr
+    # restore kernel stack of next task
+    ld sp, 8(a1)  # 从下一个任务的上下文中加载内核栈栈顶的值
+    # 阶段 [4]
+__switch_ret:
+    ret  # 返回到下一个任务的执行点

ch5/os/src/task/switch.rs

@@ -0,0 +1,11 @@
+use core::arch::global_asm;
+global_asm!(include_str!("switch.S"));  // 读入switch.S 到当前代码
+
+use super::context::TaskContext;
+extern "C" {
+    // 引入 switch.S 中的切换函数
+    pub fn __switch(
+        current_task_cx_ptr: *mut TaskContext,
+        next_task_cx_ptr: *const TaskContext
+    );
+}

ch5/os/src/task/task.rs

@@ -0,0 +1,261 @@
+use alloc::sync::{Arc, Weak};
+use alloc::vec::Vec;
+use core::cell::RefMut;
+use crate::config::{TRAP_CONTEXT};
+use crate::mm::address::{PhysPageNum, VirtAddr};
+use crate::mm::memory_set::{KERNEL_SPACE, MapPermission, MemorySet};
+use crate::println;
+use crate::sync::UPSafeCell;
+use crate::task::context::{TaskContext};
+use crate::task::pid::{kernel_stack_position, KernelStack, pid_alloc, PidHandle};
+use crate::trap::{trap_handler, TrapContext};
+
+// TCB的字段, 用来保存任务的状态
+#[derive(Copy, Clone, PartialEq)]
+pub enum TaskStatus {
+    Ready,
+    Running,
+    Zombie,
+}
+
+// 把 ch4 的TaskManagerInner 和 TaskControlBlock 整合为 TaskControlBlock, 现在被 TaskManager 关联和管理
+// 在内核中, 它等价与一个进程
+pub struct TaskControlBlock {
+    // 初始化后不再变化的元数据
+    pub pid: PidHandle,
+    pub kernel_stack: KernelStack,
+
+    // 初始化后 需要变化的元数据
+    inner: UPSafeCell<TaskControlBlockInner>,
+}
+
+pub struct TaskControlBlockInner {
+    pub user_time: usize,  // 用户态程序用的时间
+    pub kernel_time: usize,  // 内核态程序所用的时间
+    pub trap_cx_ppn: PhysPageNum,  // tcb访问 trap context所在的真实的物理页, 它对应逻辑页的次高页
+    pub task_cx: TaskContext,
+    pub task_status: TaskStatus,
+    pub memory_set: MemorySet,  // tcb他自己的地址空间
+    pub parent: Option<Weak<TaskControlBlock>>,  // 不包含父进程引用计数的弱指针
+    pub children: Vec<Arc<TaskControlBlock>>,  // 所有的子进程 arc智能指针, 只有引用计数为0的时候, 绑定的各类资源才能回收
+    pub exit_code: i32,  // 该进程退出时的 退出码
+    pub base_size: usize,  // 应用地址空间中从0x0开始到用户栈结束一共包含多少字节, 就是用户数据有多大
+    pub heap_bottom: usize,  // 堆的起始地址 这个一开始和base_size 是一样的
+    pub program_brk: usize,  // 这个一开始和base_size 是一样的, 表示进程当前的堆边界, 即堆的顶部地址, 它指向堆中最后一个已分配内存块的末尾, 下一个内存分配将从该地址开始
+    //   base_size(低地址) --- TRAP_CONTEXT(次高页) 的虚拟空间, 可以当做堆来使用
+}
+
+impl TaskControlBlock {
+    // 得到具有内部可变性的字段
+    pub fn inner_exclusive_access(&self) -> RefMut<'_, TaskControlBlockInner> {
+        self.inner.exclusive_access()
+    }
+    pub fn get_pid(&self) -> usize {
+        self.pid.0
+    }
+}
+
+impl TaskControlBlock {
+    // 根据 elf data 新建一个 TCB, 这个只在初始化 INITPROC 时候用
+    pub fn from(elf_data: &[u8]) -> Self {
+        // memory_set with elf program headers/trampoline/trap context/user stack
+        // 返回 内存空间, 用户栈的栈底和当前栈顶, 和入口地址
+        let (memory_set, user_sp, entry_point) = MemorySet::from_elf(elf_data);
+        // 在当前的地址空间中, 找到 trap_context 逻辑页 所在的真实物理页, 他逻辑地址在次高页, 真实物理地址是我们在 from_elf 申请映射的未知地址
+        // 这个真实的物理地址, 我们后续再陷入的时候会用到, 进行强写数据
+        let trap_cx_ppn = memory_set
+            .page_table
+            .get_pte(VirtAddr::from(TRAP_CONTEXT).into())  // 虚拟地址次高页, 所在对应的物理内存的pte,
+            .unwrap()
+            .ppn();  // pte 内的ppn, 得到实际 虚拟内存次高页 所在的物理页号
+
+        // 从全局pid分配器, 得到一个pid
+        let pid_handle = pid_alloc();
+
+        // 根据pid, 得到内核栈并得到高地址(栈底)
+        let kernel_stack = KernelStack::from(&pid_handle);
+        let kernel_stack_top = kernel_stack.get_top();
+
+        // 构建 任务控制块
+        let task_control_block = Self {
+            pid: pid_handle,
+            kernel_stack: kernel_stack,
+            inner: unsafe {
+                UPSafeCell::new(TaskControlBlockInner{
+                    user_time: 0,
+                    kernel_time: 0,
+                    task_status:TaskStatus::Ready,
+                    task_cx: TaskContext::goto_trap_return(kernel_stack_top),  // 根据内核栈构造任务切换上下文, 并把 switch任务切换的 ra 设置为 trap_return的函数地址
+                    memory_set,  // 新增, 当前任务的地址空间
+                    parent: None,
+                    children: Vec::new(),
+                    trap_cx_ppn,  // 新增  逻辑次高页的trap context, 对应的这个是真实的物理页, 我们这里保存一份, 省的在memory_set 里面查找了
+                    base_size: user_sp,  // 用户栈顶以下 是代码中的各种逻辑段+栈段, 应用地址空间中从0x0开始到用户栈结束一共包含多少字节, 所以大小就是截止到user_sp
+                    heap_bottom: user_sp,  //
+                    program_brk: user_sp,  //
+                    exit_code: 0,
+                })
+            }
+        };
+
+        // prepare TrapContext in user space
+        // 根据 trap_cx_ppn 构建 陷入 trap context 的结构体
+        let trap_cx = task_control_block.inner_exclusive_access().get_trap_cx();  // 根据trap_cx_ppn得到真实的物理页的 trap context的地址
+        *trap_cx = TrapContext::from(  // 对 tcb 的 TrapContext 的物理页进行 修改,
+           entry_point,  // 在陷入完成后, 准备返回用户态执行的, 用户代码入口地址
+           user_sp,  // 用户栈, 这个栈的地址是虚拟地址
+           KERNEL_SPACE.exclusive_access().token(),  // 内核 satp 页表的寄存器信息
+           kernel_stack_top,  // 用户应用的内核栈顶  在内核空间的位置 (这个是根据appid 计算出来的, 也只能在内核的地址空间中才能根据这个地址 看到相关的栈)
+           trap_handler as usize,  // 内核中 trap handler的入口点虚拟地址(恒等映射所以 这里也能找到)
+        );
+        task_control_block
+        // 以上:
+        // 任务控制块和 trap控制块, 分别多了一些字段
+        // trap控制块(这个每次陷入都会被 sscratch 寄存器临时保存):
+        //     多的三个字段 首次写入后, 后续只会读取和恢复,不会被再次写入新值, 这是为了
+        //     kernel_satp 内核空间页表所在位置的实际物理地址, 这个值以后会在切换的时候替换到satp寄存器
+        //     kernel_sp, 这个保存这个应用 他 根据appid计算出来 所持有的任务内核栈, 在jump context之前 会恢复
+        //     trap_handler 这是在内核在陷入的时候, 我们自定义的 trap_handle 的地址, 在陷入保存完寄存器之后, 需要 jmp 到这个函数地址
+        // task 控制块 TCB, 这个是在内核进行 switch时的上下文结构:
+        //     memory_set 表示当前任务他的地址空间
+        //     trap_cx_ppn 用来保存 上方 trap控制块的 实际的物理页帧, 在用户空间中都被应设在了TRAP_CONTEXT相关的次高位置虚拟地址处, 在内核空间我们这保存一份实际的物理地址, 在内核空间读取这个通过恒等映射就得到任务的 trap context
+        //     base_size 用户栈顶距离0x0的距离, 即用户应用已知的大小
+        //
+    }
+    
+    // 从当前进程copy 一个子进程, 他和父进程有相同的地址空间, 但是它拥有自己的内核栈 用来存放 trap_context
+    // 子进程后续运行会 条入到 trap_return
+    pub fn fork(self: &Arc<Self>) -> Arc<Self> {
+        // ---- 当前进程的内容
+        let mut parent_inner = self.inner_exclusive_access();
+
+        // 根据当前地址空间, copy 当前进程地址空间的数据到 一个新的地址空间
+        let memory_set = MemorySet::from_existed_user(&parent_inner.memory_set);
+
+        // 找到新的进程地址空间中 TRAP_CONTEXT 的物理页
+        let trap_cx_ppn = memory_set
+            .page_table
+            .get_pte(VirtAddr::from(TRAP_CONTEXT).into())
+            .unwrap()
+            .ppn();
+
+        // 分配一个pid
+        let pid_handle = pid_alloc();
+        // 根据pid 分配一个 子进程自己的内核栈
+        let kernel_stack = KernelStack::from(&pid_handle);
+
+        // 创建tcb
+        let kernel_stack_top = kernel_stack.get_top();
+        let task_control_block = Arc::new(TaskControlBlock {
+            pid: pid_handle,
+            kernel_stack,
+            inner: unsafe {
+                UPSafeCell::new(TaskControlBlockInner {
+                    user_time: 0,
+                    kernel_time: 0,
+                    trap_cx_ppn,
+                    base_size: parent_inner.base_size,
+                    task_cx: TaskContext::goto_trap_return(kernel_stack_top),
+                    task_status: TaskStatus::Ready,
+                    memory_set,
+                    parent: Some(Arc::downgrade(self)),  // 将父进程的弱引用计数 放到子进程的进程控制块中
+                    children: Vec::new(),
+                    exit_code: 0,
+                    heap_bottom: 0,
+                    program_brk: 0,
+                })
+            },
+        });
+
+
+        // add child
+        // 添加子进程信息 到父进程中
+        parent_inner.children.push(task_control_block.clone());
+
+        // 得到 tcb 当中 trap context 的可变引用, 上面复制时还是复制的父进程的
+        // 现在修改其栈顶为我们新创建的 子进程自己的栈顶, 其他字段则是完全和父进程一样
+        let trap_cx = task_control_block.inner_exclusive_access().get_trap_cx();
+        trap_cx.kernel_sp = kernel_stack_top;
+
+        // return
+        task_control_block
+        // ---- release parent PCB automatically
+        // **** release children PCB automatically
+    }
+    // TCB 加载一个新的应用, 从新的elf的 代码和数据替换 原有的旧的 应用地址空间的内容, 并开始执行
+    // pid 和 kernel_stack 不变
+    // 也不需要修改任务上下文环境, 因为只有被暂停的应用才需要再内核中保留一个任务上下文, 修改trap context 即可因
+    pub fn exec(&self, elf_data: &[u8]) {
+        // memory_set with elf program headers/trampoline/trap context/user stack
+        // 根据 elf data 创建一个地址空间
+        let (memory_set, user_sp, entry_point) = MemorySet::from_elf(elf_data);
+        let trap_cx_ppn = memory_set
+            .page_table
+            .get_pte(VirtAddr::from(TRAP_CONTEXT).into())
+            .unwrap()
+            .ppn();
+
+        // **** access inner exclusively
+        let mut inner = self.inner_exclusive_access();
+        // substitute memory_set
+        // 原有地址空间生命周期结束, 全部被回收
+        inner.memory_set = memory_set;
+        // 更新trap ppn
+        inner.trap_cx_ppn = trap_cx_ppn;
+        // 更新应用大小
+        inner.base_size = user_sp;
+        // 得到trap context 真实内存的指针
+        let trap_cx = inner.get_trap_cx();
+        *trap_cx = TrapContext::from(
+            entry_point,
+            user_sp,
+            KERNEL_SPACE.exclusive_access().token(),
+            self.kernel_stack.get_top(),
+            trap_handler as usize,
+        );
+        // 作用域结束 释放inner
+        // **** release inner automatically
+    }
+}
+
+impl TaskControlBlockInner{
+    // 根据 trap context 的实际的物理地址, 强转为 TrapContext 结构体
+    pub fn get_trap_cx(&self) -> &'static mut TrapContext {
+        self.trap_cx_ppn.get_mut()
+    }
+
+    pub fn get_user_token(&self) -> usize {
+        self.memory_set.token()
+    }
+
+    // 扩张/缩减, 当前应用的地址空间中的堆段, 指定字节的数据
+    pub fn change_program_brk(&mut self, size: i32) -> Option<usize> {
+        // 堆顶
+        let old_break = self.program_brk;
+        // 申请后新的堆顶
+        let new_brk = self.program_brk as isize + size as isize;
+
+        // 如果新的堆顶 小于 堆底 直接返回(防止过度释放)
+        if new_brk < self.heap_bottom as isize {
+            return None;
+        }
+
+        // 如果是小于0 说明需要释放,缩小堆的大小
+        // 传入两个参数 堆底虚拟地址, 和 新的堆顶地址
+        let result = if size < 0 {
+            self.memory_set
+                .shrink_to(VirtAddr(self.heap_bottom), VirtAddr(new_brk as usize))
+        } else {
+            self.memory_set
+                .append_to(VirtAddr(self.heap_bottom), VirtAddr(new_brk as usize))
+        };
+        println!("size: {}, old_break: {}", size, old_break);
+        // 如果成功就把新的堆顶的地址, 复制到结构提上记录, 并把旧的堆顶返回
+        if result {
+            self.program_brk = new_brk as usize;
+            Some(old_break)
+        } else {
+            None
+        }
+    }
+}

ch5/os/src/timer.rs

@@ -0,0 +1,29 @@
+
+use riscv::register::time;
+use crate::config::CLOCK_FREQ;
+use crate::sbi::set_timer;
+
+const TICKS_PER_SEC: usize = 100;
+const MICRO_PER_SEC: usize = 1_000_000;
+const MSEC_PER_SEC: usize = 1_000;
+
+//
+pub fn get_time() -> usize {
+    time::read()
+}
+
+// 读取mtime的值, 然后使用 (当前每秒的频率 / TICKS_PER_SEC 100) = 得到 10ms的数值的增量, 相加得到下一个下10ms 后mtime应该属于的值
+// 并设置mtimecmp, 这样在10ms后就会发出一个S特权的时钟中断
+pub fn set_next_trigger() {
+    set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC);
+}
+
+// 以微秒为单位, 返回当前计数器经过的微秒
+// 当前 (计时器的值的总数 / 频率) = 计时器中经过了多少秒,    (计时器的值的总数 / 频率) * 1_000_000 得到微秒(1秒有1_000_000微秒)
+pub fn get_time_us() -> usize {
+    time::read() / (CLOCK_FREQ / MICRO_PER_SEC)
+}
+
+pub fn get_time_ms() -> usize {
+    time::read() / (CLOCK_FREQ / MSEC_PER_SEC)
+}

ch5/os/src/trap/context.rs

@@ -0,0 +1,50 @@
+use riscv::register::sstatus::{self, Sstatus, SPP};
+
+/// Trap Context
+#[repr(C)]
+pub struct TrapContext {
+    /// 保存了 [0..31] 号寄存器, 其中0/2/4 号寄存器我们不保存, 2有特殊用途
+    /// > 其中 [17] 号寄存器保存的是系统调用号
+    ///
+    /// > [10]/[11]/[12] 寄存器保存了系统调用时的3个参数
+    ///
+    /// > [2] 号寄存器因为我们有特殊用途所以也跳过保存, (保存了用户栈)保存了用户 USER_STACK 的 栈顶
+    ///
+    /// > [0] 被硬编码为了0, 不会有变化, 不需要做任何处理
+    ///
+    /// > [4] 除非特殊用途使用它, 一般我们也用不到, 不需要做任何处理
+    pub x: [usize; 32],
+    /// CSR sstatus  保存的是在trap发生之前, cpu处在哪一个特权级
+    pub sstatus: Sstatus,
+    /// CSR sepc  保存的是用户态ecall时 所在的那一行的代码
+    pub sepc: usize,
+    /// Addr of Page Table
+    pub kernel_satp: usize,  // 内核页的起始物理地址, 首次写入后, 后续只会读取和恢复,不会被再次写入新值
+    /// kernel stack
+    pub kernel_sp: usize,  // 当前任务的内核栈顶的虚拟地址
+    /// Addr of trap_handler function
+    pub trap_handler: usize,  // 陷入处理函数的地址虚拟地址
+}
+
+impl TrapContext {
+    /// 把用户栈的栈顶 保存到 [2]
+    pub fn set_sp(&mut self, sp: usize) {
+        self.x[2] = sp;
+    }
+
+    // 根据entry和sp构造一个 trap_context
+    pub fn from(entry: usize, sp: usize, kernel_satp: usize, kernel_sp: usize, trap_handler: usize,) -> Self {
+        let mut sstatus = sstatus::read();  // 读取CSR sstatus
+        sstatus.set_spp(SPP::User);  // 设置特权级为用户模式
+        let mut cx = Self {
+            x: [0; 32],
+            sstatus,
+            sepc: entry, // 设置代码执行的开头, 将来条入到这里执行
+            kernel_satp,
+            kernel_sp,
+            trap_handler,
+        };
+        cx.set_sp(sp); // 设置用户栈的栈顶
+        cx  // 返回, 外面会恢复完 x[0; 32] 之后最后 sret 根据entry和sstatus 返回
+    }
+}

ch5/os/src/trap/mod.rs

@@ -0,0 +1,140 @@
+mod context;
+
+use core::arch::{asm, global_asm};
+use riscv::register::{mtvec::TrapMode, scause::{self, Exception, Trap}, sie, stval, stvec};
+use riscv::register::scause::Interrupt;
+
+pub use context::TrapContext;
+use crate::config::{TRAMPOLINE, TRAP_CONTEXT};
+use crate::println;
+use crate::syscall::syscall;
+use crate::task::{exit_current_and_run_next, suspend_current_and_run_next};
+use crate::timer::set_next_trigger;
+use crate::task::manager::TASK_MANAGER;
+use crate::task::processor::{current_task, current_trap_cx, current_user_token, kernel_time_start, user_time_start};
+
+
+
+// 引入陷入保存寄存器需要的汇编代码
+global_asm!(include_str!("trap.S"));
+
+/// 初始化stvec 寄存器, 这个寄存器保存陷入时, 入口函数的地址
+pub fn init() {
+    set_kernel_trap_entry();
+}
+
+// 设置riscv 允许定时器中断
+pub fn enable_timer_interrupt() {
+    unsafe {
+        sie::set_stimer();
+    }
+}
+
+// 这个函数是 trap.S 中__alltraps 保存完所有寄存器在内核栈 之后会进入到这里
+#[no_mangle]
+pub fn trap_handler() -> ! {
+    // 已经进入内核, 如果再发生中断我们进行的设置, 目前是直接跳转到一个引发panic 的函数
+    set_kernel_trap_entry();
+
+    // 进入到了内核态, 需要把之前的用户消耗时间统计在用户时间上
+    kernel_time_start();
+
+    // 得到当前用户应用 的 trap context, 需要调用一个函数, 因为用户应用的trap context 不再内核空间, 他是在用户空间的次高地址
+    let cx = current_trap_cx();
+
+    let scause = scause::read(); // trap 发生的原因
+    let stval = stval::read(); // trap的附加信息
+    // 根据发生的原因判断是那种类别
+    match scause.cause() {
+        // 用户态发出的系统调用
+        Trap::Exception(Exception::UserEnvCall) => {
+            cx.sepc += 4;  // +4 是因为我们需要返回 ecall指令的下一个指令
+            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)
+        | Trap::Exception(Exception::LoadFault)
+        | Trap::Exception(Exception::LoadPageFault)  => {
+            println!("[kernel] PageFault in application, kernel killed it.");
+            exit_current_and_run_next(-2);
+        }
+        // 非法指令
+        Trap::Exception(Exception::IllegalInstruction) => {
+            println!("[kernel] IllegalInstruction in application, kernel killed it.");
+            exit_current_and_run_next(-3);
+        }
+        Trap::Interrupt(Interrupt::SupervisorTimer) => {
+            // 发生时钟中断之后, 继续设置下一个时钟中断的发起时间
+            set_next_trigger();
+            // 暂停当前任务, 切换新的任务
+            suspend_current_and_run_next();
+        }
+        // 未知错误
+        _ => {
+            panic!(
+                "Unsupported trap {:?}, stval = {:#x}!",
+                scause.cause(),
+                stval
+            );
+        }
+    }
+    // 即将进入用户态, 把内核使用的时间统计在内核时间上
+    user_time_start();
+    trap_return()
+}
+
+
+#[no_mangle]
+/// Unimplement: traps/interrupts/exceptions from kernel mode
+/// Todo: Chapter 9: I/O device
+pub fn trap_from_kernel() -> ! {
+    panic!("a trap from kernel!");
+}
+
+#[no_mangle]
+/// set the new addr of __restore asm function in TRAMPOLINE page,
+/// set the reg a0 = trap_cx_ptr, reg a1 = phy addr of usr page table,
+/// finally, jump to new addr of __restore asm function
+pub fn trap_return() -> ! {
+    // 设置 用户态的中断处理函数
+    set_user_trap_entry();
+
+    let trap_cx_ptr = TRAP_CONTEXT;        // 用户空间虚拟地址的次高页, 保存了trap context, 在返回用户空间的时候, 需要恢复trap context中保存的寄存器信息
+    let user_satp = current_user_token();  // 当前用户应用的 页表所在的地址  需要在trap.S中, 等下恢复完寄存器之后 修改的用户应用自己的页表
+    extern "C" {
+        fn __alltraps();
+        fn __restore();
+    }
+    // TRAMPOLINE + (__restore - __alltraps), 得到的就是用户空间中 虚拟地址跳板的位置, 增加一个 (__alltraps低地址 到 __restore高地址的偏移值), 就得到了 strampoline ->  __restore 的虚拟地址
+    let restore_va = __restore as usize - __alltraps as usize + TRAMPOLINE;
+
+
+    unsafe {
+        asm!(
+            "fence.i",  // 清空 i-cache
+            "jr {restore_va}",             // 跳转到 strampoline ->  __restore 地址
+            restore_va = in(reg) restore_va,
+            in("a0") trap_cx_ptr,      // a0 = virt addr of Trap Context
+            in("a1") user_satp,        // a1 = phy addr of usr page table
+            options(noreturn)
+        )
+    }
+}
+
+
+fn set_kernel_trap_entry() {
+    // 设置内核法中 trap 的处理
+    // 当前我们直接panic
+    unsafe {
+        stvec::write(trap_from_kernel as usize, TrapMode::Direct);
+    }
+}
+
+fn set_user_trap_entry() {
+    // 设置 用户态的中断处理函数, 为我们的跳板, 这个跳板在用户空间的虚拟地址最高页, 虚拟地址最高页被映射在了十几物理内存的trap 处理函数所在的段执行__alltraps
+    unsafe {
+        stvec::write(TRAMPOLINE as usize, TrapMode::Direct);
+    }
+}
+

ch5/os/src/trap/trap.S

@@ -0,0 +1,97 @@
+# trap进入处理函数的入口__alltraps, 以及第一次进入时的出口__restore
+
+.altmacro
+.macro SAVE_GP n
+    sd x\n, \n*8(sp)    # 将寄存器 x_n 的值保存到栈空间中
+.endm
+
+.macro LOAD_GP n
+    ld x\n, \n*8(sp)    # 从栈空间中加载寄存器 x_n 的值
+.endm
+
+.section .text.trampoline        # 进入 .text.trampoline 段
+.globl __alltraps     # 声明全局符号 __alltraps
+.globl __restore      # 声明全局符号 __restore
+.align 2               # 对齐到 2^2 = 4 字节
+
+__alltraps:           # __alltraps 符号的实现
+    # 交换 sp 和 sscratch 寄存器的值
+    # sscratch在陷入之前是用户空间 次高的页, 是trap context
+    # 这里和sp交换之后, sscratch变成了用户栈顶, sp变成了trap context的位置
+    csrrw sp, sscratch, sp
+
+    # 保存通用寄存器
+    sd x1, 1*8(sp)          # 保存寄存器 x1 的值  (这一步是为了跳过x0寄存器, 方便下面循环)
+    # 跳过 sp(x2)，后面会再次保存
+    sd x3, 3*8(sp)          # 保存寄存器 x3 的值  (这一步是为了跳过x4寄存器, 方便下面循环)
+    # 跳过 tp(x4)，应用程序不使用该寄存器
+    # 保存 x5~x31
+    .set n, 5               # 定义变量 n 的初始值为 5
+    .rept 27                # 循环 27 次
+        SAVE_GP %n          # 保存寄存器 x_n 的值到trap context中
+        .set n, n+1         # 将 n 加 1
+    .endr                   # 结束指令块
+
+    # 我们可以自由使用 t0/t1/t2，因为它们已保存在 trap context中
+    # 保存CSR寄存器
+    csrr t0, sstatus        # 读取 sstatus 寄存器的值
+    csrr t1, sepc           # 读取 sepc 寄存器的值
+    sd t0, 32*8(sp)         # 保存 sstatus 寄存器的值到trap context中
+    sd t1, 33*8(sp)         # 保存 sepc 寄存器的值到trap context中
+
+    # 从 sscratch 中读取用户栈，并将其保存到trap context中
+    csrr t2, sscratch       # 读取 sscratch 寄存器的值
+    sd t2, 2*8(sp)          # 保存用户栈的地址到 trap context中
+
+    # 以上 通过用户空间 就保存了所有的寄存器, 他们保存在 用户空间的次高虚拟页
+    # 下面开始恢复 用户空间和 内核栈 并跳转到处理函数, 这是在内核初始化该应用的时候, 设置好的
+
+    # 等下需要加载内核的地址空间, 它是 KERNEL_SPACE.exclusive_access().token(), 他保存在了trap context中
+    ld t0, 34*8(sp)
+
+    # 等下jmp 到我们自己的trap 处理函数 他是 trap_handler as usize(这里直接as usize 转为地址, 还可以跳转到这个地址, 是因为我们是在切换内存空间之后jmp的)
+    ld t1, 36*8(sp)
+
+    # 切换栈, 上面 sp 是 trap context, 现在换成 trap context内保存的 用户内核栈
+    ld sp, 35*8(sp)
+
+    # 切换页表
+    csrw satp, t0
+    sfence.vma
+
+    # 防止编译期使用相对位置call, 这时候, 已经进入内核的地址空间了, 防止编译器在链接的时候, 对call进行相对位置偏移call, 那肯定是不对的
+    jr t1
+
+__restore:                  # __restore 符号的实现
+    # 这个是有 trap_return 调用的, 调用的时候把 trap_cx_ptr(每个用户程序都统一的地址TRAP_CONTEXT), 和 user_satp传进来
+
+    # 恢复用户地址空间
+    csrw satp, a1
+    sfence.vma
+
+    # sscratch当做临时寄存器 保存是用户空间 次高的页, 也就是是trap context
+    csrw sscratch, a0
+    # 把trap context 也copy到sp中, 下面会进行恢复
+    mv sp, a0
+
+    # 恢复 sstatus/sepc
+    ld t0, 32*8(sp)         # 从trap context中读取 sstatus 寄存器的值
+    ld t1, 33*8(sp)         # 从trap context中读取 sepc 寄存器的值
+    csrw sstatus, t0        # 恢复 sstatus 寄存器的值
+    csrw sepc, t1           # 恢复 sepc 寄存器的值
+
+    # 恢复通用寄存器，除了 sp/tp 以外的寄存器
+    # 跳过x0
+    ld x1, 1*8(sp)          # 从栈空间中读取寄存器 x1 的值
+    # 跳过x2
+    ld x3, 3*8(sp)          # 从栈空间中读取寄存器 x3 的值
+    # 循环恢复
+    .set n, 5               # 定义变量 n 的初始值为 5
+    .rept 27                # 循环 27 次
+        LOAD_GP %n          # 从栈空间中加载寄存器 x_n 的值
+        .set n, n+1        # 将 n 加 1
+    .endr                   # 结束指令块
+
+    # 恢复用户栈, 他在 trap context 中
+    ld sp, 2*8(sp)
+    sret                    # 返回指令, 根据sstatus(陷入/异常之前的特权级) 和 sepc(陷入/异常 之前的pc)返回

ch5/user/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "user_lib"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
+buddy_system_allocator = "0.6"
+
+[profile.release]
+debug = true

ch5/user/Makefile

@@ -0,0 +1,28 @@
+MODE := release
+TARGET := riscv64gc-unknown-none-elf
+OBJDUMP := rust-objdump --arch-name=riscv64
+OBJCOPY := rust-objcopy --binary-architecture=riscv64
+
+RUST_FLAGS := -Clink-arg=-Tsrc/linker.ld  # 使用我们自己的链接脚本
+RUST_FLAGS += -Cforce-frame-pointers=yes  # 强制编译器生成帧指针
+RUST_FLAGS:=$(strip ${RUST_FLAGS})
+
+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))
+
+
+# 编译elf文件
+build_elf: clean
+	CARGO_BUILD_RUSTFLAGS="$(RUST_FLAGS)" \
+ 	cargo build --$(MODE) --target=$(TARGET)
+
+
+# 把每个elf文件去掉无关代码
+build: build_elf
+
+
+clean:
+	#rm -rf ./target*

ch5/user/src/bin/00power_3.rs

@@ -0,0 +1,28 @@
+#![no_std]
+#![no_main]
+
+use user_lib::*;
+
+const LEN: usize = 100;
+
+static mut S: [u64; LEN] = [0u64; LEN];
+
+#[no_mangle]
+unsafe fn main() -> i32 {
+    let p = 3u64;
+    let m = 998244353u64;
+    let iter: usize = 300000;
+    let mut cur = 0usize;
+    S[cur] = 1;
+    for i in 1..=iter {
+        let next = if cur + 1 == LEN { 0 } else { cur + 1 };
+        S[next] = S[cur] * p % m;
+        cur = next;
+        if i % 10000 == 0 {
+            println!("power_3 [{}/{}]", i, iter);
+        }
+    }
+    println!("{}^{} = {}(MOD {})", p, iter, S[cur], m);
+    println!("Test power_3 OK!");
+    0
+}

ch5/user/src/bin/01power_5.rs

@@ -0,0 +1,28 @@
+#![no_std]
+#![no_main]
+
+use user_lib::*;
+
+const LEN: usize = 100;
+
+static mut S: [u64; LEN] = [0u64; LEN];
+
+#[no_mangle]
+unsafe fn main() -> i32 {
+    let p = 5u64;
+    let m = 998244353u64;
+    let iter: usize = 210000;
+    let mut cur = 0usize;
+    S[cur] = 1;
+    for i in 1..=iter {
+        let next = if cur + 1 == LEN { 0 } else { cur + 1 };
+        S[next] = S[cur] * p % m;
+        cur = next;
+        if i % 10000 == 0 {
+            println!("power_5 [{}/{}]", i, iter);
+        }
+    }
+    println!("{}^{} = {}(MOD {})", p, iter, S[cur], m);
+    println!("Test power_5 OK!");
+    0
+}

ch5/user/src/bin/02sleep.rs

@@ -0,0 +1,19 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use user_lib::*;
+use user_lib::syscall::*;
+
+#[no_mangle]
+fn main() -> i32 {
+    let current_timer = sys_get_time();
+    let wait_for = current_timer + 3000;
+    while sys_get_time() < wait_for {
+        sys_yield();
+    }
+    println!("Test sleep OK!");
+    0
+}

ch5/user/src/bin/03load_fault.rs

@@ -0,0 +1,19 @@
+#![no_std]
+#![no_main]
+
+use user_lib::*;
+
+use core::ptr::{null_mut, read_volatile};
+
+#[no_mangle]
+fn main() -> i32 {
+    println!("\nload_fault APP running...\n");
+    // 在Test load_fault中，我们将插入一个无效的加载操作
+    println!("Into Test load_fault, we will insert an invalid load operation...");
+    // 内核应该终止这个应用程序!
+    println!("Kernel should kill this application!");
+    unsafe {
+        let _i = read_volatile(null_mut::<u8>());
+    }
+    0
+}

ch5/user/src/bin/05store_fault.rs

@@ -0,0 +1,17 @@
+#![no_std]
+#![no_main]
+use core::ptr::{null_mut, read_volatile};
+use user_lib::*;
+
+#[no_mangle]
+fn main() -> i32 {
+    println!("\nstore_fault APP running...\n");
+    // 在Test store_fault中，我们将插入一个无效的存储操作…
+    println!("Into Test store_fault, we will insert an invalid store operation...");
+    
+    println!("Kernel should kill this application!");
+    unsafe {
+        null_mut::<u8>().write_volatile(1);
+    }
+    0
+}

ch5/user/src/bin/06sbrk_test.rs

@@ -0,0 +1,65 @@
+#![no_std]
+#![no_main]
+
+use core::ptr::slice_from_raw_parts_mut;
+use user_lib::*;
+use user_lib::syscall::sys_sbrk;
+
+#[no_mangle]
+fn main() -> i32 {
+    println!("Test sbrk start.");
+
+    // 设置申请颗粒度
+    const PAGE_SIZE: usize = 0x1000;
+
+    // 查看当前堆 end
+    let origin_brk = sys_sbrk(0);
+    println!("origin break point = {:x}", origin_brk);
+
+    // 申请一页
+    let brk = sys_sbrk(PAGE_SIZE as i32);
+    if brk != origin_brk {
+        return -1;
+    }
+
+    // 申请一页之后 查看堆 end
+    let brk = sys_sbrk(0);
+    println!("one page allocated,  break point = {:x}", brk);
+    println!("try write to allocated page");
+
+    // 得到 申请的堆 的字节数组, 并写入为1
+    let new_page = unsafe {
+        &mut *slice_from_raw_parts_mut(origin_brk as usize as *const u8 as *mut u8, PAGE_SIZE)
+    };
+    for pos in 0..PAGE_SIZE {
+        new_page[pos] = 1;
+    }
+    println!("write ok");
+
+    // 再申请10页内存 并得到当前 堆end
+    sys_sbrk(PAGE_SIZE as i32 * 10);
+    let brk = sys_sbrk(0);
+    println!("10 page allocated,  break point = {:x}", brk);
+
+    // 释放 11页(之前已经申请了 1 + 10页了)
+    sys_sbrk(PAGE_SIZE as i32 * -11);
+    let brk = sys_sbrk(0);
+    println!("11 page DEALLOCATED,  break point = {:x}", brk);
+    println!("try DEALLOCATED more one page, should be failed.");
+
+    // 继续释放1页, 非法释放的测试
+    let ret = sys_sbrk(PAGE_SIZE as i32 * -1);
+    if ret != -1 {
+        println!("Test sbrk failed!");
+        return -1;
+    }
+
+    println!("Test sbrk almost OK!");
+    println!("now write to deallocated page, should cause page fault.");
+    for pos in 0..PAGE_SIZE {
+        new_page[pos] = 2;
+    }
+    println!("{:?}", new_page);
+    // 不应该走到这里
+    0
+}

ch5/user/src/bin/forktest_simple.rs

@@ -0,0 +1,29 @@
+#![no_std]
+#![no_main]
+
+
+
+use user_lib::*;
+use syscall::{sys_fork, };
+use user_lib::syscall::sys_getpid;
+
+#[no_mangle]
+pub fn main() -> i32 {
+    assert_eq!(wait(&mut 0i32), -1);
+    println!("sys_wait without child process test passed!");
+    println!("parent start, pid = {}!", sys_getpid());
+    let pid = sys_fork();
+    if pid == 0 {
+        // child process
+        println!("hello child process!");
+        100
+    } else {
+        // parent process
+        let mut exit_code: i32 = 0;
+        println!("ready waiting on parent process!");
+        assert_eq!(pid, wait(&mut exit_code));
+        assert_eq!(exit_code, 100);
+        println!("child process pid = {}, exit code = {}", pid, exit_code);
+        0
+    }
+}

ch5/user/src/bin/forktree.rs

@@ -0,0 +1,36 @@
+#![no_std]
+#![no_main]
+
+use user_lib::*;
+use syscall::{sys_fork, sys_getpid, sys_yield};
+use user_lib::syscall::sys_exit;
+
+const DEPTH: usize = 4;
+
+fn fork_child(cur: &str, branch: char) {
+    let mut next = [0u8; DEPTH + 1];
+    let l = cur.len();
+    if l >= DEPTH {
+        return;
+    }
+    next[..l].copy_from_slice(cur.as_bytes());
+    next[l] = branch as u8;
+    if sys_fork() == 0 {
+        fork_tree(core::str::from_utf8(&next[..l + 1]).unwrap());
+        sys_yield();
+        sys_exit(0);
+    }
+}
+
+fn fork_tree(cur: &str) {
+    println!("pid{}: {}", sys_getpid(), cur);
+    fork_child(cur, '0');
+    fork_child(cur, '1');
+}
+
+#[no_mangle]
+pub fn main() -> i32 {
+    fork_tree("");
+    sleep(3000);
+    0
+}

ch5/user/src/bin/initproc.rs

@@ -0,0 +1,31 @@
+#![no_std]
+#![no_main]
+
+use user_lib::syscall::{sys_fork, sys_yield, sys_exec};
+use user_lib::{println, wait};
+
+#[no_mangle]
+fn main() -> i32 {
+    if sys_fork() == 0 {
+        // 注意需要手动添加\0 转为 c_str
+        // 启动我们的shell程序
+        sys_exec("user_shell\0");
+    } else {
+        // 所有的进程 最后父进程都会是 initproc进程, 所以我们这里一直等待 子进程是否结束
+        // 持续调用wait 进行等待,
+        loop {
+            let mut exit_code: i32 = 0;
+            let pid = wait(&mut exit_code);
+            //如果 没有进程被回收 则让出cpu, 开始下一轮循环
+            if pid == -1 {
+                sys_yield();
+                continue;
+            }
+            println!(
+                "[initproc] Released a zombie process, pid={}, exit_code={}",
+                pid, exit_code,
+            );
+        }
+    }
+    0
+}

ch5/user/src/bin/matrix.rs

@@ -0,0 +1,70 @@
+#![no_std]
+#![no_main]
+#![allow(clippy::needless_range_loop)]
+
+use user_lib::*;
+use syscall::{sys_fork, sys_getpid, sys_yield};
+use user_lib::syscall::{sys_exit, sys_get_time};
+
+
+static NUM: usize = 30;
+const N: usize = 10;
+static P: i32 = 10007;
+type Arr = [[i32; N]; N];
+
+fn work(times: isize) {
+    let mut a: Arr = Default::default();
+    let mut b: Arr = Default::default();
+    let mut c: Arr = Default::default();
+    for i in 0..N {
+        for j in 0..N {
+            a[i][j] = 1;
+            b[i][j] = 1;
+        }
+    }
+    sys_yield();
+    println!("pid {} is running ({} times)!.", sys_getpid(), times);
+    for _ in 0..times {
+        for i in 0..N {
+            for j in 0..N {
+                c[i][j] = 0;
+                #[allow(clippy::needless_range_loop)]
+                for k in 0..N {
+                    c[i][j] = (c[i][j] + a[i][k] * b[k][j]) % P;
+                }
+            }
+        }
+        for i in 0..N {
+            for j in 0..N {
+                a[i][j] = c[i][j];
+                b[i][j] = c[i][j];
+            }
+        }
+    }
+    println!("pid {} done!.", sys_getpid());
+    sys_exit(0);
+}
+
+#[no_mangle]
+pub fn main() -> i32 {
+    for _ in 0..NUM {
+        let pid = sys_fork();
+        if pid == 0 {
+            let current_time = sys_get_time();
+            let times = (current_time as i32 as isize) * (current_time as i32 as isize) % 1000;
+            work(times * 10);
+        }
+    }
+
+    println!("fork ok.");
+
+    let mut exit_code: i32 = 0;
+    for _ in 0..NUM {
+        if wait(&mut exit_code) < 0 {
+            panic!("wait failed.");
+        }
+    }
+    assert!(wait(&mut exit_code) < 0);
+    println!("matrix passed.");
+    0
+}

ch5/user/src/bin/user_shell.rs

@@ -0,0 +1,72 @@
+#![no_std]
+#![no_main]
+#![allow(clippy::println_empty_string)]
+
+extern crate alloc;
+
+const LF: u8 = 0x0au8;
+const CR: u8 = 0x0du8;
+const DL: u8 = 0x7fu8;
+const BS: u8 = 0x08u8;
+
+use alloc::string::String;
+use user_lib::{ print, println, waitpid};
+use user_lib::syscall::{sys_exec, sys_yield, sys_fork, sys_get_time};
+use user_lib::user_console::getchar;
+
+
+#[no_mangle]
+pub fn main() -> i32 {
+    println!("Rust user shell");
+
+    // line变量 维护着当前输入的内容, 它不断发生变化
+    let mut line: String = String::new();
+    print!(">> ");
+    loop {
+        // 循环读取标准输入
+        let c = getchar();
+
+        match c {
+            // 如果是 回车键, 开启一个新的进程, 把 line中的内容 使用exec 执行
+            LF | CR => {
+                println!("");
+                if !line.is_empty() {
+                    line.push('\0');
+                    let mut st = sys_get_time();
+
+                    let pid = sys_fork();
+                    if pid == 0 {
+                        // child process
+                        if sys_exec(line.as_str()) == -1 {
+                            // 返回 -1 说明没有存在 line中的程序
+                            println!("Error when executing!");
+                            return -4;
+                        }
+                        unreachable!();
+                    } else {
+                        // 等待上方子进程结束
+                        let mut exit_code: i32 = 0;
+                        let exit_pid = waitpid(pid as usize, &mut exit_code);
+                        assert_eq!(pid, exit_pid);
+                        println!("Shell: Process {} exited with code {}, use time: {}ms", pid, exit_code, sys_get_time()-st);
+                    }
+                    line.clear();
+                }
+                print!(">> ");
+            }
+            // 如果是退格键
+            BS | DL => {
+                if !line.is_empty() {
+                    print!("{}", BS as char);
+                    print!(" ");
+                    print!("{}", BS as char);
+                    line.pop();
+                }
+            }
+            _ => {
+                print!("{}", c as char);
+                line.push(c as char);
+            }
+        }
+    }
+}

ch5/user/src/lib.rs

@@ -0,0 +1,74 @@
+#![no_std]
+#![feature(linkage)]  // 开启弱链接特性
+#![feature(panic_info_message)]
+
+
+pub mod user_lang_items;
+pub use user_lang_items::*;
+
+pub mod syscall;
+use syscall::*;
+use buddy_system_allocator::LockedHeap;
+
+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();
+
+
+// 只要使用这个包, 那么这里就会作为bin程序的开始
+#[no_mangle]
+#[link_section = ".text.entry"]  // 链接到指定的段
+pub extern "C" fn _start() -> ! {
+    unsafe {
+        HEAP.lock()
+            .init(HEAP_SPACE.as_ptr() as usize, USER_HEAP_SIZE);
+    }
+
+    sys_exit(main());  // 这里执行的main程序是我们 bin文件夹里面的main, 而不是下面的, 下面的main程序只有在bin程序没有main函数的时候才会链接
+    // 正常是不会走到这一步的, 因为上面已经退出了程序
+    panic!("unreachable after sys_exit!");
+}
+
+#[linkage = "weak"]  // 设置我们默认的main函数, 弱链接
+#[no_mangle]
+fn main() -> i32 {
+    panic!("Cannot find main!");
+}
+
+// sys_waitpid如果传的是-1 则表示任何子进程退出都可以,
+pub fn wait(exit_code: &mut i32) -> isize {
+    loop {
+        match sys_waitpid(-1, exit_code as *mut _) {
+            // 如果返回-2, 说明还没有僵尸进程, 那就下一轮loop循环继续等待
+            -2 => {
+                sys_yield();
+            }
+            // 如果返回 -1 说明有任意进程结束
+            // -1 or a real pid
+            exit_pid => return exit_pid,
+        }
+    }
+}
+
+// 只检测指定pid的进程是否结束
+pub fn waitpid(pid: usize, exit_code: &mut i32) -> isize {
+    loop {
+        match sys_waitpid(pid as isize, exit_code as *mut _) {
+            -2 => {
+                sys_yield();
+            }
+            // -1 or a real pid
+            exit_pid => return exit_pid,
+        }
+    }
+}
+
+pub fn sleep(period_ms: usize) {
+    let start = sys_get_time();
+    while sys_get_time() < start + period_ms as isize {
+        sys_yield();
+    }
+}

ch5/user/src/linker.ld

@@ -0,0 +1,32 @@
+
+OUTPUT_ARCH(riscv)
+ENTRY(_start)
+
+BASE_ADDRESS = 0x10000;
+
+SECTIONS
+{
+    . = BASE_ADDRESS;
+    .text : {
+        *(.text.entry)
+        *(.text .text.*)
+    }
+    . = ALIGN(4K);
+    .rodata : {
+        *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
+    }
+    . = ALIGN(4K);
+    .data : {
+        *(.data .data.*)
+        *(.sdata .sdata.*)
+    }
+    .bss : {
+        *(.bss .bss.*)
+        *(.sbss .sbss.*)
+    }
+    /DISCARD/ : {
+        *(.eh_frame)
+        *(.debug*)
+    }
+}

ch5/user/src/syscall.rs

@@ -0,0 +1,72 @@
+use core::arch::asm;
+
+const SYSCALL_READ: usize = 63;
+const SYSCALL_WRITE: usize = 64;
+const SYSCALL_EXIT: usize = 93;
+const SYSCALL_YIELD: usize = 124;
+const SYSCALL_GET_TIME: usize = 169;
+const SYSCALL_SBRK: usize = 214;
+const SYSCALL_GETPID: usize = 172;
+const SYSCALL_FORK: usize = 220;
+const SYSCALL_EXEC: usize = 221;
+const SYSCALL_WAITPID: usize = 260;
+
+
+fn syscall(id: usize, args: [usize; 3]) -> isize {
+    let mut ret: isize;
+    unsafe {
+        // a0寄存器同时作为输入参数和输出参数, {in_var} => {out_var}
+        asm!(
+        "ecall",
+        inlateout("x10") args[0] => ret,
+        in("x11") args[1],
+        in("x12") args[2],
+        in("x17") id
+        );
+    }
+    ret
+}
+
+
+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_yield() {
+    syscall(SYSCALL_YIELD, [0, 0, 0]);
+}
+
+pub fn sys_get_time() -> isize {
+    syscall(SYSCALL_GET_TIME, [0, 0, 0])
+}
+
+pub fn sys_sbrk(size: i32) -> isize {
+    syscall(SYSCALL_SBRK, [size as usize, 0, 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, exit_code: *mut i32) -> isize {
+    syscall(SYSCALL_WAITPID, [pid as usize, exit_code as usize, 0])
+}
+
+pub fn sys_read(fd: usize, buffer: &mut [u8]) -> isize {
+    syscall(
+        SYSCALL_READ,
+        [fd, buffer.as_mut_ptr() as usize, buffer.len()],
+    )
+}

ch5/user/src/user_lang_items.rs

@@ -0,0 +1,2 @@
+pub mod user_panic;
+pub mod user_console;

ch5/user/src/user_lang_items/user_console.rs

@@ -0,0 +1,41 @@
+use core::fmt::{Arguments, Write, Result};
+use crate::syscall::{sys_read, sys_write};
+
+struct Stdout;
+
+const STDIN: usize = 0;  // 读取 标准输入的标志
+const STDOUT: usize = 1;
+
+impl Write for Stdout {
+    fn write_str(&mut self, s: &str) -> Result {
+        sys_write(STDOUT, s.as_bytes());
+        Ok(())
+    }
+}
+
+// 每次从标准输入读出一个字符, 这个会阻塞当前进程
+pub fn getchar() -> u8 {
+    let mut c = [0u8; 1];
+    sys_read(STDIN, &mut c);
+    c[0]
+}
+
+
+pub fn print(args: Arguments) {
+    Stdout.write_fmt(args).unwrap();
+}
+
+
+#[macro_export]
+macro_rules! print {
+    ($fmt: literal $(, $($arg: tt)+)?) => {
+        $crate::user_console::print(format_args!($fmt $(, $($arg)+)?));
+    }
+}
+
+#[macro_export]
+macro_rules! println {
+    ($fmt: literal $(, $($arg: tt)+)?) => {
+        $crate::user_console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
+    }
+}

ch5/user/src/user_lang_items/user_panic.rs

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