rcore-os Blog
0%

Posted on Edited on

主要看了下hypervisor部分

tour/h_1_0部分的vmexit_handler只处理了Shutdown vm
exercise/simplehv处理了IllegalInstruction, LoadGuestPageFault,VirtualSupervisorEnvCall

IllegalInstruction处理部分

1
2
3
4
5
6
7
8
9
Trap::Exception(Exception::IllegalInstruction) => {
            ax_println!("Bad instruction: {:#x} sepc: {:#x}",
                stval::read(),
                ctx.guest_regs.sepc
            );
            ctx.guest_regs.sepc += 4;
            ctx.guest_regs.gprs.set_reg(A0, 0x6688);
            ctx.guest_regs.gprs.set_reg(A1, 0x1234);
        },

guest_regs.sepc代表返回guest模式后的pc值
guest_regs.gprs.set_reg设置guest模式的reg值设置guest模式的reg值
hyper模式可以接管guest模式的寄存器并在相应事件发生时设置回调函

Posted on Edited on In

由于 11 月事情较为繁忙（比赛和研一课程等），因此三阶段实际花的时间并不是很多，加之 ArceOS 项目的复杂性较高，导致这一阶段个人的学习效果不算太理想，对项目的代码框架还不算很熟悉。后续准备深入啃一啃各模块的源代码，并在四阶段深入学习 Hypervisor 虚拟化方向。以下是我在三阶段过程中的学习日志。

Read more »

Posted on Edited on

ArceOS入门

依本人的拙见，三阶段其实是为了让大家在正式开始项目实习前，先弄明白我们接下来要开发或者要完善的这个OS到底是一个什么样的OS。换句话说，它到底是基于一个什么样的思想去构建的？它跟市面上已有的那些微内核或者宏内核有哪些区别？或者更近一点，它跟我们之前做的rcore又有哪些异同？这应该都是我们在ArceOS入门阶段需要了解的一些事情，弄明白了这些概念是为了给接下来的开发和项目实习打下一个良好的基础。

组件化内核的概念

研究和实践基于组件构造内核的方法，尝试构造应对不同场景的各种模式内核。

前两天才考完操作系统，在书本上，对操作系统的（其中一种）定义是这样的：

操作系统是一组能有效地组织和管理计算机硬件和软件资源，合理地对各类作业进行调度，以及方便用户使用的程序的集合。

感觉有一种异曲同工之妙。即，我们也许不用将操作系统看作一个完整的整体，而是一块块组件，我们通过“胶水”进行粘合，将这些组件组合成一个程序的集合，来实现诸如计算机软硬件资源管理等功能。

在组件化内核领域：所有内核实例都可以基于组合组件的方式，从简单到复杂逐级迭代的进行构建。所有内核模式都可以看作以Unikernel模式为基础，朝向特定方向的组件化扩展。

那么什么是unikernel？

Unikernel

Unikernel模式下应用与内核处于同一特权级（均为内核态），共享地址空间。Unikernel既是内核又是应用，二者合为一体。

转换到实际场景中，我们可以理解成就是一个运行在开发板上的程序，只是这个程序直接操控了这个开发板的所有硬件资源，且它只做一个任务，比如U1.0，负责向屏幕上输出信息，随后终止，退出。

而从上面的例子中，我们又可以将一个简单的输出字符串的程序，分成几个部分。比如输出部分，架构相关的部分，给分隔开，并且各自作为组件再完善，成为了组件化内核的前身。

优势：二者之间无隔离无切换，简单高效。

劣势：二者之间无隔离无切换，安全性低。

小结：通过U_1_0：helloworld，建立最基本的框架：核心组件axhal、axruntime、api、ulib以及上层应用组件。

后续版本在该基本框架的基础上，通过扩展功能组件，扩展OS能力特性。

这里扩展的部分，就是axalloc, axtask, axsync等

从Unikernel到宏内核

相对于Unikernel，宏内核的特点：

(1) 增加一个权限较低的用户特权级来运行应用。

(2) 为应用创建独立的用户地址空间，与内核隔离。

(3) 内核运行时可以随时加载应用Image投入运行。

(4) 应用与内核界限分明。

为了将我们的工作进一步推进到宏内核，我们还需要实现几个组件，其中就是axmm，用来构造用户地址空间和axfs，加载应用程序代码到地址空间。

Hypervisor

这部分暂时没有做更多的了解，因为本人想参与宏内核的开发，更多的去学习宏内核的相关知识了。此外，软件所的任务也一直在做，于是还没来得及看。

课后练习

主要是在于bump_allocator以及对挑战题目第1题的理解。因为之前也一直在做内存分配这里的工作。

bump_allocator主要还是根据bump分配器本身的一些思想去填充对应的功能即可。

而挑战题目通过优化内存块的分配来提升内存空间的使用效率，使得Indicator这个指标有显性的提升。我的实现是基于slab的，准确来说，只是修改了某个内存块的大小限制，所以优化也没有那么明显。

祝接下来项目阶段好运！

Posted on Edited on

操作系统秋季训练营第三阶段学习总结博客

大家好，我是参加这次操作系统秋季训练营的一名学员。最近我们刚刚结束了第三阶段的学习，这个阶段主要围绕组件化内核设计与实践展开，包括了从Unikernel到宏内核的过渡，以及Hypervisor扩展等内容。
虽然由于时间关系我没能亲自动手完成所有的实验，但通过PPT和一些额外的挑战任务，我还是学到了不少东西。下面我就来分享一下这段时间的学习体会。

一、课程概述

组件化内核的概念与意义

“If you don’t need it, you don’t pay for it”

组件化内核是这次训练营的核心思想，它强调的是将内核的功能分解成一系列独立的组件，这些组件可以灵活地组合起来形成不同规模和功能的内核。这种构建方式不仅提高了开发效率，还降低了维护难度，使得团队成员能够更有效地协作。
相比传统的内核设计，组件化方法允许开发者根据具体需求定制内核，从而更好地满足应用场景的需求。

主流内核模式对比

在训练营中，我们讨论了几种主流的内核模式，比如Unikernel和宏内核等。Unikernel是一种非常轻量级的内核形式，它将应用程序和内核紧密结合在一起，
共享同一地址空间，并且运行在同一个特权级别上。这使得Unikernel非常适合于需要高性能和低资源消耗的应用场景。而宏内核则提供了更加丰富的功能，支持多用户态进程，
每个进程都有自己的地址空间，这增强了系统的安全性和稳定性。但是，宏内核也因此变得更加复杂，对资源的需求也更高。

二、学习内容回顾

Unikernel模式

第一周我们从最基础的Unikernel模式开始，逐步了解了如何通过增加或替换组件来构建出一个简单的内核。
在Unikernel模式的学习过程中，我们深入探讨了如何从最基础的层面构建一个极简的操作系统环境，该环境仅包含应用程序运行所必需的核心组件。
与传统Unix内核相比，Unikernel以其高度定制化和轻量化的特点脱颖而出，通过将操作系统功能直接编译进应用代码中，实现了更小的内存占用、
更快的启动时间和更高的安全性。

宏内核扩展

第二周的内容转向了宏内核的设计，这是从Unikernel到更加复杂的操作系统的桥梁。
在M.1 UserPrivilege实验中，我们探索了如何让应用程序在较低的用户特权级别下运行，同时保持内核的安全性。这一转变意味着我们需要管理更多的地址空间，
并处理由此带来的复杂性问题。通过这样的练习，我对Unix操作系统中的用户空间与内核空间分离有了更深的理解——这种方式虽然增加了系统设计的难度，
但却极大地提高了系统的灵活性和安全性。

Hypervisor扩展

最后一周专注于Hypervisor技术，这也是当前云计算领域的一个热点话题。
通过对H.1 VirtualMode等实验的学习，我了解到Hypervisor是如何模拟出多个虚拟机环境，让它们各自拥有独立的操作系统和硬件资源。
与KVM相比，本课程中的Hypervisor实现以简化模型为tradeoff，通过直接绑定vCPU、忽略多任务并发以及省略复杂的设备模拟等方式，降低了实现复杂度，
但牺牲了一定的灵活性和性能效率。

三、字节分配器设计挑战

尽管大部分时间都在理论学习上度过，我还是尝试着完成了11.15发布的字节分配器设计挑战。虽然最终并没有完全按照题目要求找到一种理想的字节分配算法实现，
却意外发现了测试用例中存在的一个小漏洞。这对我来说也是一个不小的收获，至少证明了自己具备一定的调试能力和批判性思维Xb。
此外，这个过程也加深了我对内存管理机制的理解，尤其是对于像TLSF这样复杂的分配策略有了初步的认识。
img.png

四、个人感悟

整个训练营期间，我深刻体会到组件化设计给操作系统开发带来的巨大便利。
它可以让我们专注于特定领域的功能实现，而不必担心与其他部分的耦合度太高。然而，这也要求开发者具备较强的整体规划能力，否则很容易导致系统结构混乱。
相比之下，传统Unix风格的操作系统就在某些方面可能显得不够灵活，唉唉，历史包袱。

总之，这次训练营给了我一次宝贵的机会去深入了解现代操作系统的设计理念和技术细节。
虽然还有很多知识需要进一步消化吸收，但我相信这段经历将对我未来的职业发展产生积极影响。
希望以后还能有机会参与更多类似的活动，继续充实自己的技术栈！

五、最后

十分感谢所有的讲师和同学的付出，让我有机会接触到如此优秀的技术，也给我带来了非常丰富的学习资源。

Posted on Edited on

week 1

思路：直接修改 axstd 里面的 println!宏，在输出的内容之前加上ansi的控制字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
commit 29c8b52df3644c27ea1f2cb26191e7a45c2c40a4 (HEAD -> exercise)
Author: PandaJiang <3160104094@zju.edu.cn>
Date:   Wed Nov 13 22:15:34 2024 +0800

    with color
    
    Signed-off-by: PandaJiang <3160104094@zju.edu.cn>

diff --git a/arceos/ulib/axstd/src/macros.rs b/arceos/ulib/axstd/src/macros.rs
index c7cd653..760739b 100644
--- a/arceos/ulib/axstd/src/macros.rs
+++ b/arceos/ulib/axstd/src/macros.rs
@@ -18,6 +18,6 @@ macro_rules! print {
 macro_rules! println {
     () => { $crate::print!("\n") };
     ($($arg:tt)*) => {
-        $crate::io::__print_impl(format_args!("{}\n", format_args!($($arg)*)));
+        $crate::io::__print_impl(format_args!("\x1b[31m{}\x1b[0m\n", format_args!($($arg)*)));
     }
 }

support hashmap

思路：axstd 中新增collections模块，将 alloc::collections 中的容器导入。此外，注意到std::collection::hashmap是在hashbrown作为base进行使用。尝试与std做一样的事情，发现可以直接将hashbrown模块引入作为hashmap使用，randomState就采用了默认的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
commit c2cab71c6640a9c9f984144f2e12f701cf347f31
Author: PandaJiang <3160104094@zju.edu.cn>
Date:   Wed Nov 13 22:21:01 2024 +0800

    support hash
    
    Signed-off-by: PandaJiang <3160104094@zju.edu.cn>

diff --git a/arceos/ulib/axstd/Cargo.toml b/arceos/ulib/axstd/Cargo.toml
index c2322c5..d3a3fe8 100644
--- a/arceos/ulib/axstd/Cargo.toml
+++ b/arceos/ulib/axstd/Cargo.toml
@@ -80,3 +80,4 @@ arceos_api = { workspace = true }
 axio = "0.1"
 axerrno = "0.1"
 kspin = "0.1"
+hashbrown = "0.15"
\ No newline at end of file
diff --git a/arceos/ulib/axstd/src/collections/mod.rs b/arceos/ulib/axstd/src/collections/mod.rs
new file mode 100644
index 0000000..6978165
--- /dev/null
+++ b/arceos/ulib/axstd/src/collections/mod.rs
@@ -0,0 +1,6 @@
+// collections
+
+extern  crate alloc;
+
+pub use alloc::collections::*;
+pub use  hashbrown::*;
\ No newline at end of file
diff --git a/arceos/ulib/axstd/src/lib.rs b/arceos/ulib/axstd/src/lib.rs
index 5ab0517..49784bb 100644
--- a/arceos/ulib/axstd/src/lib.rs
+++ b/arceos/ulib/axstd/src/lib.rs
@@ -55,7 +55,7 @@ extern crate alloc;
 
 #[cfg(feature = "alloc")]
 #[doc(no_inline)]
-pub use alloc::{boxed, collections, format, string, vec};
+pub use alloc::{boxed, format, string, vec};
 
 #[doc(no_inline)]
 pub use core::{arch, cell, cmp, hint, marker, mem, ops, ptr, slice, str};
@@ -70,6 +70,7 @@ pub mod process;
 pub mod sync;
 pub mod thread;
 pub mod time;
+pub mod collections;
 
 #[cfg(feature = "fs")]
 pub mod fs;

bump 内存分配算法

  • 分配bytes

    实现较为简单，用b_pos记录当前内存bytes分配到的地方。 唯一需要注意的是

    1. 要根据aligment返回起始地址。并将分配计数+1
    2. 要检查 b_pos + size是否到达了 p_pos，是的话说明内存已经被耗尽。

  • 分配pages
    实现也较为简单，用p_pos记录当前pages分配的地方。需要注意的是

    1. p_pos是递减的，返回的地址会越来越小
    2. 要检查p_pos - size是否到达了b_pos，是的话说明内存已经被耗尽。

  • 释放bytes

    • 引用计数减1，然后检查是否为0即可，为0的话就将b——pos重置。

mv和rename操作

  • mv

    分解为 create + del 两个动作，在新的地址上写入原文件，然后删除原文件

  • rename

    文件系统有相关api，直接调用即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
commit adabd01bad84c50a172a5a43af4d7cb77d75c4d7
Author: Panda Jiang <3160104094@zju.edu.cn>
Date:   Mon Nov 18 08:00:23 2024 +0000

    mv and rename
    
    Signed-off-by: Panda Jiang <3160104094@zju.edu.cn>

diff --git a/arceos/examples/shell/src/cmd.rs b/arceos/examples/shell/src/cmd.rs
index 23f087f..f81723c 100644
--- a/arceos/examples/shell/src/cmd.rs
+++ b/arceos/examples/shell/src/cmd.rs
@@ -1,5 +1,6 @@
 use std::fs::{self, File, FileType};
 use std::io::{self, prelude::*};
+use std::string::ToString;
 use std::{string::String, vec::Vec};
 
 #[cfg(all(not(feature = "axstd"), unix))]
@@ -27,6 +28,8 @@ const CMD_TABLE: &[(&str, CmdHandler)] = &[
     ("pwd", do_pwd),
     ("rm", do_rm),
     ("uname", do_uname),
+    ("rename", do_rename),
+    ("mv", do_mv),
 ];
 
 fn file_type_to_char(ty: FileType) -> char {
@@ -195,6 +198,84 @@ fn do_mkdir(args: &str) {
     }
 }
 
+fn do_rename(args: &str) {
+    let mut arg_v = args.split(" ");
+    let  old_name = arg_v.next();
+    let  new_name = arg_v.next();
+    if old_name.is_none() || new_name.is_none() || arg_v.next().is_some() {
+        println!("rename: invalid args");
+        println!("usage: rename $old_name $new_name");
+        return;
+    }
+    let old_name_s = old_name.unwrap();
+    let new_name_s = new_name.unwrap();
+    println!("try to rename {old_name_s} to {new_name_s}");
+    if let Err(e) =  fs::rename(old_name_s, new_name_s) {
+        print_err!("rename", format_args!("cannot rename '{old_name_s}' to '{new_name_s}'"), e);
+    }
+    return;
+}
+
+fn do_mv(args: &str) {
+    let mut arg_v = args.split(" ");
+    let  old_file_path = arg_v.next();
+    let  new_file_path = arg_v.next();
+    if old_file_path.is_none() || new_file_path.is_none() || arg_v.next().is_some() {
+        println!("mv: invalid args");
+        println!("usage: mv $old_file_path $new_path_path");
+        return;
+    }
+    fn rm_one(path: &str, rm_dir: bool) -> io::Result<()> {
+        if rm_dir && fs::metadata(path)?.is_dir() {
+            fs::remove_dir(path)
+        } else {
+            fs::remove_file(path)
+        }
+    }
+    fn write_file(fname: &str, bufs: &Vec<Vec<u8>>) -> io::Result<()> {
+        let mut file = File::create(fname)?;
+        for buf in bufs {
+            file.write_all(&buf[..])?;
+        }
+        Ok(())
+    }
+    fn read_file(fname: &str, all_data: &mut Vec<Vec<u8>>) -> io::Result<()> {
+        let mut file = File::open(fname)?;
+        loop {
+            let mut buf=vec![0u8;1024];
+            let n = file.read(&mut buf)?;
+            if n > 0 {
+                all_data.push(buf);
+            } else {
+                return Ok(());
+            }
+        }
+    }
+    let old_path = old_file_path.unwrap();
+    let last_separator_pos = old_path.rfind(|c| c == '/' || c == '\\');
+    // 提取文件名
+    let filename = match last_separator_pos {
+        Some(pos) => &old_path[pos + 1..],
+        None => old_path,
+    };
+    let mut new_path = new_file_path.unwrap().to_string();
+    new_path.push('/');
+    new_path.push_str(filename);
+    let mut data:Vec<Vec<u8>> = Vec::new();
+    if let Err(e) = read_file(old_path, &mut data) {
+        print_err!("mv", format_args!("cannot read '{old_path}'"), e);
+        return;
+    }
+    if let Err(e) = write_file(&new_path, &data) {
+        print_err!("mv", format_args!("cannot open '{new_path}'"), e);
+        return;
+    }
+    if let Err(e) = rm_one(old_path, false) {
+        print_err!("mv", format_args!("cannot rm '{old_path}'"), e);
+        return;
+    }
+}
+
 fn do_rm(args: &str) {
     if args.is_empty() {
         print_err!("rm", "missing operand");

week2

pagefault 缺页处理

populate参数为false时，uspace模块只会为将该块虚拟内存地址记录下来，实际的访问会导致 pagefault， 在该handler中处理这一错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
commit c0ed66e6fd0ad5af24f7ae6b2e683c43df03228a
Author: PandaJiang <3160104094@zju.edu.cn>
Date:   Wed Nov 20 22:19:20 2024 +0800

    add page fault func
    
    Signed-off-by: PandaJiang <3160104094@zju.edu.cn>

diff --git a/arceos/payload/fileops_c/fileops b/arceos/payload/fileops_c/fileops
new file mode 100755
index 0000000..a457c8c
Binary files /dev/null and b/arceos/payload/fileops_c/fileops differ
diff --git a/arceos/payload/hello_c/hello b/arceos/payload/hello_c/hello
new file mode 100755
index 0000000..a44f4c6
Binary files /dev/null and b/arceos/payload/hello_c/hello differ
diff --git a/arceos/payload/origin/Makefile b/arceos/payload/origin/Makefile
new file mode 100644
index 0000000..15ba26d
--- /dev/null
+++ b/arceos/payload/origin/Makefile
@@ -0,0 +1,18 @@
+TARGET := origin
+TARGET_ELF := ../../target/riscv64gc-unknown-none-elf/release/$(TARGET)
+
+all: $(TARGET) FORCE
+
+$(TARGET): $(TARGET_ELF)
+	@rust-objcopy --binary-architecture=riscv64 --strip-all -O binary $< $@
+
+$(TARGET_ELF): src/main.rs
+	@cargo build -p origin --target riscv64gc-unknown-none-elf --release
+
+clean:
+	@rm -rf ./$(TARGET)
+	@cargo clean -p origin --target riscv64gc-unknown-none-elf --release
+
+FORCE:
+
+.PHONY: FORCE
diff --git a/arceos/payload/origin/origin b/arceos/payload/origin/origin
new file mode 100755
index 0000000..da2037d
Binary files /dev/null and b/arceos/payload/origin/origin differ
diff --git a/arceos/tour/m_1_0/src/main.rs b/arceos/tour/m_1_0/src/main.rs
index 89ef91d..f8c6077 100644
--- a/arceos/tour/m_1_0/src/main.rs
+++ b/arceos/tour/m_1_0/src/main.rs
@@ -12,6 +12,8 @@ mod task;
 mod syscall;
 mod loader;
 
+use std::println;
+
 use axstd::io;
 use axhal::paging::MappingFlags;
 use axhal::arch::UspaceContext;
@@ -19,12 +21,27 @@ use axhal::mem::VirtAddr;
 use axsync::Mutex;
 use alloc::sync::Arc;
 use axmm::AddrSpace;
+use axtask::TaskExtRef;
 use loader::load_user_app;
+use axhal::trap::{register_trap_handler, PAGE_FAULT};
 
 const USER_STACK_SIZE: usize = 0x10000;
 const KERNEL_STACK_SIZE: usize = 0x40000; // 256 KiB
 const APP_ENTRY: usize = 0x1000;
 
+#[register_trap_handler(PAGE_FAULT)]
+fn page_fault(vaddr: VirtAddr, access_flags: MappingFlags, is_user: bool) -> bool {
+    if !is_user {
+        panic!("page fault from kernel!!!");
+    }
+    println!("handler user page fault");
+    axtask::current()
+    .task_ext()
+    .aspace
+    .lock()
+    .handle_page_fault(vaddr, access_flags)
+}
+
 #[cfg_attr(feature = "axstd", no_mangle)]
 fn main() {
     // A new address space for user app.
@@ -36,7 +53,7 @@ fn main() {
     }
 
     // Init user stack.
-    let ustack_top = init_user_stack(&mut uspace, true).unwrap();
+    let ustack_top = init_user_stack(&mut uspace, false).unwrap();
     ax_println!("New user address space: {:#x?}", uspace);
 
     // Let's kick off the user process.

mmap syscall

与page fault处理类似，有相应api可以调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
commit daef0f232f4ae709afe1ef19974afa29b4594c95
Author: Panda Jiang <3160104094@zju.edu.cn>
Date:   Thu Nov 21 09:22:08 2024 +0000

    mmap
    
    Signed-off-by: Panda Jiang <3160104094@zju.edu.cn>

diff --git a/arceos/exercises/sys_map/src/syscall.rs b/arceos/exercises/sys_map/src/syscall.rs
index 83b98d5..ac6624d 100644
--- a/arceos/exercises/sys_map/src/syscall.rs
+++ b/arceos/exercises/sys_map/src/syscall.rs
@@ -1,13 +1,16 @@
 #![allow(dead_code)]
 
 use core::ffi::{c_void, c_char, c_int};
+use core::usize;
 use axhal::arch::TrapFrame;
 use axhal::trap::{register_trap_handler, SYSCALL};
 use axerrno::LinuxError;
+use axmm::{USER_ASPACE_BASE, USER_ASPACE_SIZE};
 use axtask::current;
 use axtask::TaskExtRef;
 use axhal::paging::MappingFlags;
-use arceos_posix_api as api;
+use arceos_posix_api::{self as api, get_file_like};
+use memory_addr::{MemoryAddr, VirtAddr, VirtAddrRange};
 
 const SYS_IOCTL: usize = 29;
 const SYS_OPENAT: usize = 56;
@@ -140,7 +143,53 @@ fn sys_mmap(
     fd: i32,
     _offset: isize,
 ) -> isize {
-    unimplemented!("no sys_mmap!");
+    let file = get_file_like(fd);
+    if file.is_err() {
+        return 0;
+    }
+    let file = file.unwrap();
+    let ss = file.stat();
+    if ss.is_err() {
+        return  0;
+    }
+    let size = ss.unwrap().st_size as usize;
+    if length > size {
+        debug!("incoming length is too long!!");
+    }
+    let prot_f = MmapProt::from_bits(prot);
+    if prot_f.is_none() {
+        return  0;
+    }
+    let mpflag:MappingFlags = prot_f.unwrap().into();
+    let mut buf = alloc::vec![0u8; size];
+    if let Err(_) = file.read(&mut buf) {
+        return  0;
+    }
+    let c = current();
+    let mut uspace = c
+        .task_ext()
+        .aspace
+        .lock();
+    let mut vaddr = VirtAddr::from(addr as usize);
+    if let Some(va) = uspace.find_free_area(vaddr, length.align_up_4k(), VirtAddrRange::from_start_size(USER_ASPACE_BASE.into(), USER_ASPACE_SIZE.into())) {
+        debug!("old vaddr {:?}", vaddr);
+        vaddr = va;
+        debug!("new vaddr {:?}", vaddr);
+    } else {
+        ax_println!("can't find free vaddr");
+        return 0;
+    }
+
+    if let Err(e) =  uspace.map_alloc(vaddr, length.align_up_4k(), mpflag, true) {
+        ax_println!("error while mmap, {:?}", e);
+        return 0;
+    }
+    if let Ok(_) = uspace.write(vaddr, &buf) {
+        let ret:usize = vaddr.into();
+        ret as isize
+    } else {
+        0
+    }
 }
 
 fn sys_openat(dfd: c_int, fname: *const c_char, flags: c_int, mode: api::ctypes::mode_t) -> isize {
diff --git a/arceos/modules/axhal/src/trap.rs b/arceos/modules/axhal/src/trap.rs
index a38f7e5..5fa9499 100644
--- a/arceos/modules/axhal/src/trap.rs
+++ b/arceos/modules/axhal/src/trap.rs
@@ -41,5 +41,6 @@ macro_rules! handle_trap {
 /// Call the external syscall handler.
 #[cfg(feature = "uspace")]
 pub(crate) fn handle_syscall(tf: &TrapFrame, syscall_num: usize) -> isize {
+    debug!("handle syscall in axhal");
     SYSCALL[0](tf, syscall_num)
 }
diff --git a/arceos/modules/axmm/src/lib.rs b/arceos/modules/axmm/src/lib.rs
index ed23c71..e0ace44 100644
--- a/arceos/modules/axmm/src/lib.rs
+++ b/arceos/modules/axmm/src/lib.rs
@@ -19,8 +19,8 @@ use lazyinit::LazyInit;
 use memory_addr::{va, PhysAddr, VirtAddr};
 use memory_set::MappingError;
 
-const USER_ASPACE_BASE: usize = 0x0000;
-const USER_ASPACE_SIZE: usize = 0x40_0000_0000;
+pub const USER_ASPACE_BASE: usize = 0x0000;
+pub const USER_ASPACE_SIZE: usize = 0x40_0000_0000;
 
 static KERNEL_ASPACE: LazyInit<SpinNoIrq<AddrSpace>> = LazyInit::new();

week 3

simple hv

这个题是面对用例编程,分析下面的程序

1
2
3
4
5
6
7
8
9
unsafe extern "C" fn _start() -> ! {
    core::arch::asm!(
        "csrr a1, mhartid",  // 获取mhardid的值，按照最后
        "ld a0, 64(zero)", // 访问0x40处的值
        "li a7, 8",
        "ecall", // shutdown
        options(noreturn)
    )
}

结合下面的代码，知道是需要我们将GUEST的a0设置为0x6688, a1设置为0x1234。

1
2
3
4
5
6
7

fn vmexit_handler(ctx: &mut VmCpuRegisters) -> bool {
...
                        assert_eq!(a0, 0x6688);
                        assert_eq!(a1, 0x1234);
...
}

最终实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
commit 325d23818ae08961b4cf8e8d500b90f04dbd98d3
Author: PandaJiang <3160104094@zju.edu.cn>
Date:   Tue Nov 26 23:31:54 2024 +0800

    simple hv
    
    Signed-off-by: PandaJiang <3160104094@zju.edu.cn>

diff --git a/arceos/exercises/simple_hv/src/main.rs b/arceos/exercises/simple_hv/src/main.rs
index 788ad8e..5809a64 100644
--- a/arceos/exercises/simple_hv/src/main.rs
+++ b/arceos/exercises/simple_hv/src/main.rs
@@ -3,29 +3,29 @@
 #![feature(asm_const)]
 #![feature(riscv_ext_intrinsics)]
 
+extern crate alloc;
 #[cfg(feature = "axstd")]
 extern crate axstd as std;
-extern crate alloc;
 #[macro_use]
 extern crate axlog;
 
-mod task;
-mod vcpu;
-mod regs;
 mod csrs;
-mod sbi;
 mod loader;
+mod regs;
+mod sbi;
+mod task;
+mod vcpu;
 
-use vcpu::VmCpuRegisters;
-use riscv::register::{scause, sstatus, stval};
+use crate::regs::GprIndex::{A0, A1};
+use axhal::mem::PhysAddr;
 use csrs::defs::hstatus;
-use tock_registers::LocalRegisterCopy;
 use csrs::{RiscvCsrTrait, CSR};
-use vcpu::_run_guest;
-use sbi::SbiMessage;
 use loader::load_vm_image;
-use axhal::mem::PhysAddr;
-use crate::regs::GprIndex::{A0, A1};
+use riscv::register::{scause, sstatus, stval};
+use sbi::SbiMessage;
+use tock_registers::LocalRegisterCopy;
+use vcpu::VmCpuRegisters;
+use vcpu::_run_guest;
 
 const VM_ENTRY: usize = 0x8020_0000;
 
@@ -50,8 +50,7 @@ fn main() {
     prepare_vm_pgtable(ept_root);
 
     // Kick off vm and wait for it to exit.
-    while !run_guest(&mut ctx) {
-    }
+    while !run_guest(&mut ctx) {}
 
     panic!("Hypervisor ok!");
 }
@@ -68,10 +67,11 @@ fn prepare_vm_pgtable(ept_root: PhysAddr) {
 }
 
 fn run_guest(ctx: &mut VmCpuRegisters) -> bool {
+    // ax_println!("re-run guest");
     unsafe {
         _run_guest(ctx);
     }
-
+    // ax_println!("vm_exit");
     vmexit_handler(ctx)
 }
 
@@ -94,25 +94,34 @@ fn vmexit_handler(ctx: &mut VmCpuRegisters) -> bool {
                         assert_eq!(a1, 0x1234);
                         ax_println!("Shutdown vm normally!");
                         return true;
-                    },
+                    }
                     _ => todo!(),
                 }
             } else {
                 panic!("bad sbi message! ");
             }
-        },
+        }
         Trap::Exception(Exception::IllegalInstruction) => {
-            panic!("Bad instruction: {:#x} sepc: {:#x}",
-                stval::read(),
-                ctx.guest_regs.sepc
-            );
-        },
+            // ax_println!(
+            //     "Bad instruction: {:#x} sepc: {:#x}",
+            //     stval::read(),
+            //     ctx.guest_regs.sepc
+            // );
+            ctx.guest_regs.gprs.set_reg(A1, 0x1234);
+            ctx.guest_regs.sepc += 4;
+            // ax_println!("next instruction {:#x}", ctx.guest_regs.sepc);
+            return false;
+        }
         Trap::Exception(Exception::LoadGuestPageFault) => {
-            panic!("LoadGuestPageFault: stval{:#x} sepc: {:#x}",
-                stval::read(),
-                ctx.guest_regs.sepc
-            );
-        },
+            // panic!(
+            //     "LoadGuestPageFault: stval{:#x} sepc: {:#x}",
+            //     stval::read(),
+            //     ctx.guest_regs.sepc
+            // );
+            ctx.guest_regs.gprs.set_reg(A0, 0x6688);
+            ctx.guest_regs.sepc += 4;
+            return false;
+        }
         _ => {
             panic!(
                 "Unhandled trap: {:?}, sepc: {:#x}, stval: {:#x}",
@@ -127,9 +136,8 @@ fn vmexit_handler(ctx: &mut VmCpuRegisters) -> bool {
 
 fn prepare_guest_context(ctx: &mut VmCpuRegisters) {
     // Set hstatus
-    let mut hstatus = LocalRegisterCopy::<usize, hstatus::Register>::new(
-        riscv::register::hstatus::read().bits(),
-    );
+    let mut hstatus =
+        LocalRegisterCopy::<usize, hstatus::Register>::new(riscv::register::hstatus::read().bits());
     // Set Guest bit in order to return to guest mode.
     hstatus.modify(hstatus::spv::Guest);
     // Set SPVP bit in order to accessing VS-mode memory from HS-mode.

hv_pflash

思路: 用upload img脚本将pflash传到 disk.img 中，然后在处理异常地址时读取该文件，将该文件的内容映射到 pflash 所在的地址即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
commit d3959ba050e8d4fcbd764415b0bac71be5a2013b
Author: Panda Jiang <3160104094@zju.edu.cn>
Date:   Fri Nov 29 07:43:01 2024 +0000

    read pflash.img ok
    
    Signed-off-by: Panda Jiang <3160104094@zju.edu.cn>

diff --git a/arceos/tour/h_2_0/src/main.rs b/arceos/tour/h_2_0/src/main.rs
index 0ae2f0e..d7b6d6a 100644
--- a/arceos/tour/h_2_0/src/main.rs
+++ b/arceos/tour/h_2_0/src/main.rs
@@ -6,14 +6,14 @@ extern crate log;
 #[macro_use]
 extern crate alloc;
 extern crate axstd as std;
+use alloc::string::String;
 use alloc::string::ToString;
-use riscv_vcpu::AxVCpuExitReason;
 use axerrno::{ax_err_type, AxResult};
 use memory_addr::VirtAddr;
-use alloc::string::String;
-use std::fs::File;
-use riscv_vcpu::RISCVVCpu;
+use riscv_vcpu::AxVCpuExitReason;
 use riscv_vcpu::AxVCpuExitReason::NestedPageFault;
+use riscv_vcpu::RISCVVCpu;
+use std::fs::File;
 
 const VM_ASPACE_BASE: usize = 0x0;
 const VM_ASPACE_SIZE: usize = 0x7fff_ffff_f000;
@@ -21,8 +21,8 @@ const PHY_MEM_START: usize = 0x8000_0000;
 const PHY_MEM_SIZE: usize = 0x100_0000;
 const KERNEL_BASE: usize = 0x8020_0000;
 
-use axmm::AddrSpace;
 use axhal::paging::MappingFlags;
+use axmm::AddrSpace;
 
 #[no_mangle]
 fn main() {
@@ -36,40 +36,47 @@ fn main() {
 
     // Physical memory region. Full access flags.
     let mapping_flags = MappingFlags::from_bits(0xf).unwrap();
-    aspace.map_alloc(PHY_MEM_START.into(), PHY_MEM_SIZE, mapping_flags, true).unwrap();
+    aspace
+        .map_alloc(PHY_MEM_START.into(), PHY_MEM_SIZE, mapping_flags, true)
+        .unwrap();
 
     // Load corresponding images for VM.
     info!("VM created success, loading images...");
     let image_fname = "/sbin/u_3_0_riscv64-qemu-virt.bin";
-    load_vm_image(image_fname.to_string(), KERNEL_BASE.into(), &aspace).expect("Failed to load VM images");
+    load_vm_image(image_fname.to_string(), KERNEL_BASE.into(), &aspace)
+        .expect("Failed to load VM images");
 
     // Create VCpus.
     let mut arch_vcpu = RISCVVCpu::init();
 
     // Setup VCpus.
-    info!("bsp_entry: {:#x}; ept: {:#x}", KERNEL_BASE, aspace.page_table_root());
+    info!(
+        "bsp_entry: {:#x}; ept: {:#x}",
+        KERNEL_BASE,
+        aspace.page_table_root()
+    );
     arch_vcpu.set_entry(KERNEL_BASE.into()).unwrap();
     arch_vcpu.set_ept_root(aspace.page_table_root()).unwrap();
 
     loop {
         match vcpu_run(&mut arch_vcpu) {
             Ok(exit_reason) => match exit_reason {
-                AxVCpuExitReason::Nothing => {},
-                NestedPageFault{addr, access_flags} => {
+                AxVCpuExitReason::Nothing => {}
+                NestedPageFault { addr, access_flags } => {
                     debug!("addr {:#x} access {:#x}", addr, access_flags);
                     assert_eq!(addr, 0x2200_0000.into(), "Now we ONLY handle pflash#2.");
-                    let mapping_flags = MappingFlags::from_bits(0xf).unwrap();
-                    // Passthrough-Mode
-                    let _ = aspace.map_linear(addr, addr.as_usize().into(), 4096, mapping_flags);
+                    // let mapping_flags = MappingFlags::from_bits(0xf).unwrap();
+                    // // Passthrough-Mode
+                    // let _ = aspace.map_linear(addr, addr.as_usize().into(), 4096, mapping_flags);
 
                     /*
                     // Emulator-Mode
                     // Pretend to load file to fill buffer.
-                    let buf = "pfld";
+                     */
+                    // let buf = "pfld";
                     aspace.map_alloc(addr, 4096, mapping_flags, true);
-                    aspace.write(addr, buf.as_bytes());
-                    */
-                },
+                    load_file("/sbin/pflash.img", addr, &aspace).unwrap()
+                }
                 _ => {
                     panic!("Unhandled VM-Exit: {:?}", exit_reason);
                 }
@@ -81,6 +88,24 @@ fn main() {
     }
 }
 
+fn load_file(file_path: &str, image_file_load_addr: VirtAddr, aspace: &AddrSpace) -> AxResult {
+    use std::io::{BufReader, Read};
+    let (ffile, size) = open_image_file(file_path)?;
+    let mut file = BufReader::new(ffile);
+    let load_region = aspace
+        .translated_byte_buffer(image_file_load_addr, 4096)
+        .expect("failed to translate kernel image load address");
+    for buffer in load_region {
+        file.read_exact(buffer).map_err(|err| {
+            ax_err_type!(
+                Io,
+                format!("Failed in reading from file {}, err {:?}", file_path, err)
+            )
+        })?
+    }
+    Ok(())
+}
+
 fn load_vm_image(image_path: String, image_load_gpa: VirtAddr, aspace: &AddrSpace) -> AxResult {
     use std::io::{BufReader, Read};
     let (image_file, image_size) = open_image_file(image_path.as_str())?;
@@ -103,7 +128,7 @@ fn load_vm_image(image_path: String, image_load_gpa: VirtAddr, aspace: &AddrSpac
 }
 
 fn vcpu_run(arch_vcpu: &mut RISCVVCpu) -> AxResult<AxVCpuExitReason> {
-    use axhal::arch::{local_irq_save_and_disable, local_irq_restore};
+    use axhal::arch::{local_irq_restore, local_irq_save_and_disable};
     let flags = local_irq_save_and_disable();
     let ret = arch_vcpu.run();
     local_irq_restore(flags);

Posted on Edited on

很高兴能够进入第三阶段，本来想着好好跟进一下，但是很遗憾与考试科目以及组里的项目冲突里，仅仅完成了前三次课程的实验，后面大体了解了一下宏内核与Hypervisor

第一次课 HelloWorld

image-20241111222207439

什么是组件化操作系统？ 上面是课件里很形象的一张图。在裸机程序中，Bootloader阶段后，需要初始化寄存器、栈指针等。之后初始化串口驱动，并在此基础上打印HelloWorld，这是一套连贯的操作流程。在层次化中，可以分为Hal层和runtime层，Hal层对于对应一些基本的初始化，runtime层对应的是驱动的初始化，为上层的应用提供运行时环境。如果迭代为组件化结构，那么优势就很明显了，在hal层可以抽象出不同架构的初始化，runtime层分为了不同组件，在构建不同的裸机应用时，可以有选择的使用相关的组件，有利于系统的裁剪和定制化。

一个简单的helloword程序使用的组件大致如图所示

image-20241111223112760

课后练习

为了实现带颜色的输出，一个最简单的实现是在输出字符串前后加入相应的转义字符。

修改axstd组件中println的实现即可

1
2
3
4
5
6
7
#[macro_export]
macro_rules! println {
    () => { $crate::print!("\n") };
    ($($arg:tt)*) => {
        $crate::io::__print_impl(format_args!("\x1b[34m{}\x1b[0m\n", format_args!($($arg)*)));
    }
}

image-20241111223334733、

或者修改axhal中putchar的实现，在打印每一个字符时都加入相应的转义字符

1
2
3
4
5
6
7
8
9
10
11
12
13
pub fn putchar(c: u8) {
    #[allow(deprecated)]
    sbi_rt::legacy::console_putchar('\x1b' as usize);
    sbi_rt::legacy::console_putchar('[' as usize);
    sbi_rt::legacy::console_putchar('3' as usize);
    sbi_rt::legacy::console_putchar('4' as usize);
    sbi_rt::legacy::console_putchar('m' as usize);
    sbi_rt::legacy::console_putchar(c as usize);
    sbi_rt::legacy::console_putchar('\x1b' as usize);
    sbi_rt::legacy::console_putchar('[' as usize);
    sbi_rt::legacy::console_putchar('0' as usize);
    sbi_rt::legacy::console_putchar('m' as usize);
}

image-20241111224510977

第二次课 Collections

引入了新的组件axalloc，以便于实现动态的内存分配。

课后练习

支持HashMap

使用hashbrown作为HashMap实现

image-20241115210910430

第三次课

课后练习

image-20241115211654916

实现一个简单的bump内存分配算法，比较简单，维护相应的trait即可。Page不考虑回收，回收Bytes的时候记录剩余的Bytes计数，在count为0的时候将byte_pos归零。

image-20241115212923154

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
pub struct EarlyAllocator<const PAGE_SIZE: usize> {
    start: usize,
    b_pos: usize,
    p_pos: usize,
    end: usize,
    count: usize,
}

impl<const PAGE_SIZE: usize> EarlyAllocator<PAGE_SIZE> {
    pub const fn new() -> Self {
        Self {
            start: 0,
            b_pos: 0,
            p_pos: 0,
            end: 0,
            count: 0,
        }
    }
}

impl<const PAGE_SIZE: usize> BaseAllocator for EarlyAllocator<PAGE_SIZE> {
    fn init(&mut self, start: usize, size: usize) {
        self.start = start;
        self.end = start + size;
        self.b_pos = start;
        self.p_pos = self.end;
        self.count = 0;
    }
    fn add_memory(&mut self, _start: usize, _size: usize) -> AllocResult {
        Err(AllocError::NoMemory)
    }
}

impl<const PAGE_SIZE: usize> ByteAllocator for EarlyAllocator<PAGE_SIZE> {
    fn alloc(&mut self, layout: Layout) -> AllocResult<NonNull<u8>> {
        let size = layout.size();
        let align = layout.align();
        let align_mask = align - 1;
        let new_pos = (self.b_pos + align_mask) & !align_mask;
        if new_pos + size > self.p_pos {
            return Err(AllocError::NoMemory);
        }
        self.b_pos = new_pos + size;
        self.count += 1;
        Ok(NonNull::new(new_pos as *mut u8).unwrap())
    }
    fn dealloc(&mut self, _ptr: NonNull<u8>, _layout: Layout) {
        if self.count > 0 {
            self.count -= 1;
        }
        if self.count == 0 {
            self.b_pos = self.start;
        }
        // Do nothing
    }
    fn total_bytes(&self) -> usize {
        self.end - self.start
    }
    fn available_bytes(&self) -> usize {
        self.p_pos - self.b_pos
    }
    fn used_bytes(&self) -> usize {
        self.b_pos - self.start
    }
}

impl<const PAGE_SIZE: usize> PageAllocator for EarlyAllocator<PAGE_SIZE> {
    const PAGE_SIZE: usize = PAGE_SIZE;
    fn alloc_pages(&mut self, num_pages: usize, align_pow2: usize) -> AllocResult<usize> {
        if align_pow2 % Self::PAGE_SIZE != 0 {
            return Err(AllocError::InvalidParam);
        }
        let align_pow2 = align_pow2 / Self::PAGE_SIZE;
        if !align_pow2.is_power_of_two() {
            return Err(AllocError::InvalidParam);
        }
        let p_pos = self.p_pos - num_pages * Self::PAGE_SIZE;
        if p_pos < self.b_pos {
            return Err(AllocError::NoMemory);
        }

        self.p_pos -= num_pages * Self::PAGE_SIZE;
        Ok(self.p_pos)
    }
    fn dealloc_pages(&mut self, _pos: usize, _num_pages: usize) {
        // Do nothing
    }
    fn total_pages(&self) -> usize {
        (self.end - self.start) / Self::PAGE_SIZE
    }
    fn used_pages(&self) -> usize {
        (self.end - self.p_pos) / Self::PAGE_SIZE
    }
    fn available_pages(&self) -> usize {
        self.p_pos / Self::PAGE_SIZE
    }
}

感悟

第三节阶段的代码相对于第二阶段清晰了不少，很后悔没有持续跟进下去，其实本人一直想学习的是基于协程异步机制的操作系统/驱动这一部分，不知道为什么没有相应的前置课程，希望第四阶段能够坚持下去，学习一下协程、异步机制以及操作系统的一些新实践。

Posted on Edited on In

Submit Blog

rcore-blog 这个 repo 已经挺大的了，网不好的 clone 下来还挺费时间的。

实际上可以直接在 Github 上写东西提 PR 不需要本地 clone 下来，Github 网站本身就提供了这样的功能。

打开 rcore-blog 项目主页，在绿色按钮 Code 左边有个 Add file 的按钮，可以直接用 Create new file 写所需要的 Blog 或者用 Upload files 直接上传写好的 md 文件。

需要注意的点是要切到 rcore-blog/source/_posts 这个目录下，不然文件的位置不对。

虽然直接在网站上写，文件里的内容还是要注意一下加上 Blog 需要的分类/标签/作者信息等，这些东西随便打开一个 md 文件复制一下就行。

缺点是数学公式支持和插入本地图片可能麻烦点。

注意一下 Commit changes 里上面是 Commit message, 下面只是辅助描述，一般只用改上面就行。

引用了我很喜欢的一个库 ansi_rgb, 秒了。

hashmap

在 axstd 里开个 mod collections, 再引入 hashbrown, 秒了，

alt_alloc

测试里实际上没有用到 Page alloc 的接口，写完 Byte alloc 就通过了。

rename and mv in shell

有意思的来了，实际上 fs::ax_rename 没有很好的处理 ‘./‘ 和 ‘/‘ 这些前缀后缀。

我认为在 shell 的逻辑里处理文件访问文件名是一个错误的抽象，因此我写的时候决定不在 shell 代码里处理路径问题。

观察到 ls 命令可以处理前缀后缀，一路跳转后决定在 modules/axfs/src/fs/fatfs.rs 中 DirWrapper::rename() 中进行处理，刚好旁边就有 remove 方法可以参考。

lab1

觉得没意思就没写，看群里大佬们玩挺花的，我自己想能不能玩点 hack, 最后确认到 main 地址是可以获取的，main 的 text 内存是可读可写的。

也就意味着可以整花活来跳转到自定义的 main 函数当中去，但是想到这样就要做 platform 的适配，感觉工作量并不小，就没整。

set populating to false

从 AddrSpace 为入口开始找参考的辅助函数，发现直接就有 handle_page_fault 可以用，一调用就过了，看看 m2 的参考才知道 user flag 的作用。

mmap

这个练习用到的 api 挺多，需要找找 find_free_area, api::fs, LinuxError, AxError.

因为 rust 没有 goto, 所以错误处理需要包一层 fn() -> Result, 这样才能用 ? 来减少代码量。

? 只能在 Result 和 Option 上用就已经很强大了，如果 try_trait_v2 稳定了都不用包一层 fn 了，不敢想象有多爽。

simple hypervisor

这个练习不错，有一定难度。

首先处理 csrr a1, mhartid 这条指令。

尝试了下直接用 asm!("csrr {rd}, mhartid", out(reg) rd) 进行代理，不过如我所料的是 hypervisor 也没有 M 权限，所以不能这样弄。

但是可以注意到 mhartid 的语义是 cpu id, 所以可以直接用 axhal::cpu::this_cpu_id() 的值就行。

不过事实上根据语义应当返回的值是 vcpu id, 也就是 hypervisor 让 Guest 看到的 cpu_id, 但是我懒得添加相关的逻辑了。

把值写到上下文的 a1 寄存器之后需要把 spec 也加上指令长度。

然后处理缺页，注意到 src/task.rs 里有 TaskExt 的定义，并且压根没用上，可以知道大概需要用上。

但是我偷懒没去用，而是直接改了 vmexit_handler 和 run_guest 的接口，加一个 uspace 参数，这样就能在 vmexit_handler 里修改页表了。

对于一个内核来说，所有内存地址都是可以访问的，所以直接用 uspace.map_alloc() 就行了，权限可以全加上。

一个很有意思的点是 hypervisor 寻址用的是 satp, Guest 机器寻址用的是 hgatp. 所以写入用 uspace.write 来进行。

Emulator mode device

直接把注释去掉就能通，所以改起来挺简单的。把 populate flag 置为 false 会导致 Supervisor Page Fault 错误。

刚好文件里就直接给出了一个 load_vm_image 辅助函数，直接拿来用把参数改改就完成了。size 可以通过 fs::metadata 来获取。

之前提到过 aspace 目前不支持 File 类型的 Backend, 不然就可以把 populate 置为 false 了，会快上不少。

Posted on Edited on
  • 要求：
  1. 修改一个组件的实现
  2. 执行make run A=exercises/print_with_color

  • 预期：字符串输出带颜色。（具体颜色不做要求）

  • 提示：在不同层次的组件上修改，影响的输出范围不同。例如，修改axstd可能只影响println!的输出；修改axhal则可能一并影响ArceOS启动信息的颜色。

  • 本次修改主要集中在 println! 宏中，修改后的代码如下：
    1
    2
    3
    4
    5
    6
    7
    8
     macro_rules! println {
         () => { $crate::print!("\n") };
         ($($arg:tt)*) => {
    -        $crate::io::__print_impl(format_args!("{}\n", format_args!($($arg)*)));
    +        // $crate::io::__print_impl(format_args!("{}\n", format_args!($($arg)*)));
    +        $crate::io::__print_impl(format_args!("\u{1B}[{}m{}\u{1B}[m\n", 32, format_args!($($arg)*)));
         }
     }

[support_hashmap]: 支持HashMap类型。

  • 预备：执行make run A=exercises/support_hashmap

  • 要求：

    1. 在axstd等组件中，支持collections::HashMap
    2. 再次执行make run A=exercises/support_hashmap

  • 提示：

    1. 报错的std其实是axstd，测试用例main.rs中有”extern crate axstd as std;”
    2. 在axhal中给出了一个随机数产生函数random()，可以基于它为HashMap提高随机数支持。
  • 实现思路

HashMap 使用一个 Vec<Option<(K, V)>> 来存储键值对，每个桶（即 Option<(K, V)>）存储一个键值对，空桶为 None
custom_hash 函数用于生成键的哈希值，这里采用简单的字节移位和异或方式，返回一个 u64 类型的哈希值
iter 方法返回一个自定义的迭代器 HashMapIterator，该迭代器遍历哈希表中的所有已存储的键值对
通过线性探测法处理哈希冲突，即当发生冲突时，依次检查下一个桶直到找到空桶或找到匹配的键。

  • 测试结果
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
           d8888                            .d88888b.   .d8888b.
          d88888                           d88P" "Y88b d88P  Y88b
         d88P888                           888     888 Y88b.
        d88P 888 888d888  .d8888b  .d88b.  888     888  "Y888b.
       d88P  888 888P"   d88P"    d8P  Y8b 888     888     "Y88b.
      d88P   888 888     888      88888888 888     888       "888
     d8888888888 888     Y88b.    Y8b.     Y88b. .d88P Y88b  d88P
    d88P     888 888      "Y8888P  "Y8888   "Y88888P"   "Y8888P"

    arch = riscv64
    platform = riscv64-qemu-virt
    target = riscv64gc-unknown-none-elf
    smp = 1
    build_mode = release
    log_level = warn

    Running memory tests...
    test_hashmap() OK!
    Memory tests run OK!

其他实验由于忙于项目，暂时未做，后面有时间再补上其他的实验。

之前总结的一个starry的实现流程也记录这里，方便以后实验查阅：
Starry启动流程

Posted on Edited on

组件化内核的意义与概念

基于组件构造内核的方法，去构造不同场景的各种模式内核。组件之间单向依赖。

与传统设计思路的差异：

  1. 面向场景和应用需求构建内核
  2. 以统一视角看待各种模式、不同规模的内核

组件化内核相对传统构建方式的优势：

  1. 提高内核开发效率
  2. 降低内核维护难度
  3. 开展基于组件的功能复用和开发协作

内核模式：1)App和Kernel均处于S Mode.2)相互可见.3)编译形成一个Image.4)是App也是Kernel
可以通过组件增量的方式，实现扩展到宏内核与Hypervisor模式。

Unikernel

学习心得

Unikernel令我最惊讶的就是模块化的OS构建方式并通过组件增量的方式组成不同内核模式的OS.

特点

  1. 应用与内核处于同一特权级（均为内核态），共享地址空间。Unikernel既是内核又是应用，二者合为一体
  2. 优点: 应用与内核之间没有隔离和切换，简单高效
  3. 缺点: 同样因为没有隔离和切换，所以安全性较低

Unikernel框架与构成框架的核心组件是怎么来的？经历的阶段如下：

(1) 直接开发一个裸机应用来满足输出Hello的简单需求
(2) 需求增加，发现可按照通用性和Arch相关实现分层复用
(3) 引入组件化，降低耦合性、提升复用性定制性灵活性。

应用的开发

面向应用：基于features选择必要组件的最小集合。

  1. 学习了如何加载和执行外部应用程序
  2. 实现了内核与应用程序的通信机制
  3. 掌握了地址空间分离和切换的技术要点

课后练习

练习一

在打印宏的定义处，使用ANSI控制颜色即可，我使用的是：\x1B[34m和\x1B[0m

练习二

我做了两版，一版就是直接引入hashbrown，这是最简单的方法，不过对于alloc和hashbrown中的有一个方法存在的冲突，我没有做处理，默认是让alloc的方法覆盖了hashbrown的。另一个版本是CV了std的实现，然后一点一点的修理，但是我还是觉得第一个更优雅一点。

练习三

我在EarlyAllocator中添加了start, end, b_pos, p_pos, count属性。然后将每一个Trait需要实现的函数实现出来。我发现PageAllocator中的部分函数并没有被使用，有些函数是直接打了unimplement()!的，但是一样能通过测试。

练习四

参数的检查可以直接参考官方函数的实现。
rename直接调用API fs::rename就可以。mv通过判断第二个参数dst是否是一个目录，如果是的话，吧文件src读入buf,然后在对应的路径写，最后删除原来的文件。

Monolithic

学习心得

宏内核在如今的市场上还是占有大量的比率，而Linux也为我们证明了，宏内核加上一些合理的缓解措施，并不意味着会比其他模式差。所以，学习宏内核是很多有意义的。

特点

基于组件化方法构建宏内核模式。

  1. Unikernel到宏内核：
    以构建最小化的宏内核为目标，说明：
    宏内核特点、与Unikernel的差异分析、框架和组件构成、具体实现示例。
  2. 地址空间管理和支持Linux应用：
    1）用户地址空间映射、缺页加载机制；
    2）支持运行最简单的Linux的原始应用

Unikernel模式的应用和内核：
(1）处于同一特权级 - 内核特权级
(2) 共享同一地址空间 - 相互可见
(3) 编译形成一个Image，一体运行
(4) Unikernel既是应用又是内核，二者合体

课后练习

练习五

使用register_trap_handler来标记对PAGE_FAULT的处理，然后实现处理函数：handle_page_fualt()
处理的实现是通过axtask的接口去实现的，得到task的ext，将aspace上锁后，调用handle_page_fualt同名函数，最后直接打印了对应的输出，然后返回一个正确处理。如果同名函数没有正确执行，那么就直接返回false.

练习六

从当前的aspace中调用find_free_area，得到length的addr_src，然后进行4K对齐，同时，对length进行对齐得到size。

prot和flags通过调用MmapProt::from_bits_truncate(prot), MmapFlags::from_bits_truncate(flags)得到，需要的mappingFlags就from(prot)即可。

调用aspace的map_alloc方法。

之后处理一下MmapFlags::MAP_ANONYMOUS。如果有这个flags，直接返回就好

如果没有MmapFlags::MAP_ANONYMOUS。则通过get_file_like得到我们所需的文件，并将其读取进入buf，然后写入aspace。

Hypervisor

学习心得

HyperVisor，即所谓的虚拟机管理程序，从代码实现来看，和宏内核思想差不多，都是一个高特权级的“内核”为低特权级的“应用”创建独属于它的“虚拟空间”，为它准备对应的资源，然后切换特权级去执行该“应用”。当“应用”发生“中断”的时候，就trap回“内核”处理。GuestOS，就像是一个特殊的应用。

特点

HyperVisor，即所谓的虚拟机管理程序，从代码实现来看，和宏内核思想差不多，都是一个高特权级的“内核”为低特权级的“应用”创建独属于它的“虚拟空间”，为它准备对应的资源，然后切换特权级去执行该“应用”。当“应用”发生“中断”的时候，就trap回“内核”处理。GuestOS，就像是一个特殊的应用。

基于一台物理计算机建立一些OS的就是虚拟机，我们这里用的是I形虚拟机，也就是不存在宿主机，直接在硬件平台运行的。
虚拟机的特点包括：同质、高校、资源受控。为了实现虚拟化，支持了以下层次的对象VM、vCPU、vMem、vDevice、vUtilities。

课后题

练习七

这里处理Trap的时候，需要更改掉panic，然后在这道题中，要求A0、A1为0x1234和0x6688，只需要在处理这些Trap的时候，将对应的寄存器进行修改就可以

笔记：https://github.com/inchinaxiaofeng/Blog-arceos

Posted on Edited on In

进入第三阶段当然很高兴，但时间上实在太紧，我一开始的心态是按看懂源代码中的每一步来走的，但目前只是看完了所有相关的 makefile，以及看了部分 PPT 中强调部分的源代码。实验的话也是完成了第一周的内容以及 Hypervisor 的实验一。

arceos流程小结

总体执行流程：axhal的boot.rs中先引导，用于初始化内核栈，设置初始的页表，这里映射了两个 1G 的大页，分别是低地址恒等映射以及高地址的一个映射。随后要调用 axruntime 的 rust_main 来进一步完善运行时，这里会涉及到 axfeat 里面用到的 feature 条件编译并初始化一些东西，比如启用了 paging 这个 feature 就会重新映射页表这样。调用 rust_main 的时候加了一个偏移，偏移的大小其实就是高地址映射的偏移这样。随后 axruntime 做好运行时之后，调用 main 函数。随后调用结束函数，结束整个流程。

课后练习1：支持带颜色的打印输出。

具体实现：修改axhal中putchar的实现，在打印每一个字符时都加入相应的转义字符。

关于转义字符的具体解析的话：颜色定义的部分可以参考 console_codes(4) — Linux manual page 的 ECMA-48 Select Graphic Rendition 部分。在 makefile 中的 run_cmd 函数用于辅助输出同时会以颜色输出命令，参数 1 控制颜色为白色，参数 2 控制为灰色，随后执行命令。

颜色控制部分关键如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
param      result
0          reset all attributes to their defaults
1          set bold
2          set half-bright (simulated with color on a color display)
3          set italic (since Linux 2.6.22; simulated with color on a color display)
4          set underscore (simulated with color on a color display) (the colors
			used to simulate dim or underline are set using ESC ] ...)
5          set blink
7          set reverse video
10         reset selected mapping, display control flag, and toggle meta flag
			(ECMA-48 says "primary font").
11         select null mapping, set display control flag, reset toggle meta flag
			(ECMA-48 says "first alternate font").
12         select null mapping, set display control flag, set toggle meta flag
			(ECMA-48 says "second alternate font").  The toggle meta flag causes the
			high bit of a byte to be toggled before the mapping table translation is
			done.
21         set underline; before Linux 4.17, this value set normal intensity (as is
			done in many other terminals)
22         set normal intensity
23         italic off (since Linux 2.6.22)
24         underline off
25         blink off
27         reverse video off
30         set black foreground
31         set red foreground
32         set green foreground
33         set brown foreground
34         set blue foreground
35         set magenta foreground
36         set cyan foreground
37         set white foreground
38         256/24-bit foreground color follows, shoehorned into 16 basic colors
			(before Linux 3.16: set underscore on, set default foreground color)
39         set default foreground color (before Linux 3.16: set underscore off, set
			default foreground color)
40         set black background
41         set red background
42         set green background
43         set brown background
44         set blue background
45         set magenta background
46         set cyan background
47         set white background
48         256/24-bit background color follows, shoehorned into 8 basic colors
49         set default background color
90..97     set foreground to bright versions of 30..37
100..107   set background, same as 40..47 (bright not supported)

Commands 38 and 48 require further arguments:
;5;x       256 color: values 0..15 are IBGR (black,  red,  green,
			...  white),  16..231  a  6x6x6 color cube, 232..255 a
			grayscale ramp
;2;r;g;b   24-bit color, r/g/b components are in the range 0..255

ECMA-48 SGR 序列以 ESC[ parameters m 的格式控制显示的属性。parameters 用分号隔开，\033[92;1m 为例，033 为八进制，表示 ESC，92 和 1分别是 param，参考上文的 ECMA-48 Select Graphic Rendition 92 表示绿色明亮前景色。1 表示加粗，0 表示重置属性。

课后练习2：支持 HashMap

ax_api 作为下层 module 的抽象，随后 axstd 作为我们自己定义的标准库供用户程序调用。

我的想法其实也是直接看 std 的 HashMap 怎么实现，然后改一改，做到最小的满足测试案例中的那些操作。然后慢慢改一改，后面看到官方也用了 hashbrown 作为实现，然后我就改了改，把随机数用到 hashbrown 这边大概。然后就好了。

课后练习3：实现 alt_alloc

这个分配器应当是用作早期boot之后系统初始化阶段的内存分配器，所以实现上相对简单，每次分配都向后增长。dealloc的时候尝试减掉已经alloc的空间大小，如果为0，那就重新开始从头分配这样。

挑战题目：实现特定分配算法

这个算法的话，还是要感谢万能的群友，我一开始想的也是在TLSF基础上改一改这样。后面发现有取巧的地方，主要也是循环一直进行，奇数项的内容永不释放，所以就取巧了，会记录每次奇数次申请的空间，下次申请如果比上次的小，那就返回该地址。如果比上次大，那就重新申请，释放上次的内容这样。

达到的轮次是65536应该是，也是一个非常 unsigned int 的值。

思路详细描述：由于每次申请的空间大小会加1，相比上一次。例如，delta 为1，申请的空间依次是32 + 1， 32 * 2 + 1， 。delta 为 2，申请的空间依次是32 +2， 32*2 +2，。所以，第一次循环会反复替换掉分配器中的记录。

但是，从第二次开始，每次当 index 为 13 的时候，会替换上一次的内容。因为上一次的 13 比这次的 13 申请的空间小 1。但是呢，14 不是最后一次循环吗，因为 14 是偶数所以不管。奇数就很神奇，每次都是到 index 为 13 的时候重新申请一次空间。其余时候，其实大家返回的地址都是一样的。嘿嘿。而且，每次替换的时候都会把上次的给释放了，哎，就很神奇。

首先主体部分使用特定内存分配器 tlsf。包括申请，释放等操作。

其次，定制 alloc 函数。用 indicator 记录此时调用 alloc_pass 函数的 delta值。用 index 记录 alloc_pass 函数中的循环次数。

alloc 的时候需要谨慎计算，2的多少次方啊，当index = 14 的时候，重置为 0，然后indiactor需要加 1 啊，之类的。

这里要注意一点，源码里，分配器有个special变量，为bool类型。这里用它的主要原因在于有个很神奇的点：当indiactor为32， index = 1的时候，items需要申请 0x60 的空间，而恰好，下次申请向量空间也是 0x60 的大小。就，重复了。嗯。所以，作为单独判断条件，然后重置，第一次出现先不管，然后继续。然后，bug解决。

Hypervisor课后练习1

hypervisior流程分析：这里初始化阶段我们的hyper会布置好一个现场类似我们在宏内核中设置好sstatus寄存器那样，随后通过sret到GUEST中执行，GUEST中遇到无法处理的情况又会陷入Hypervisior中，通过对不同类型的陷入执行不同的代码，处理好用户的错误设置寄存器等操作，随后返回GUEST继续执行。

这里的第一个实验比较简单：只需要在处理错误函数中设置寄存器的值，然后设置sepc += 4，让GUEST去执行出错指令的下一条指令即可。

Hypervisior课后练习2

这里会涉及到虚拟化里的地址二阶段映射。主要流程：GUEST中的虚拟地址先通过 VSATP 翻译，通过 GVA 到 GPA，然后通过 HGATP 把GPA翻译到 HPA 这样。

课后练习尚未完成，嗯。

Hypervisior课后练习3

这里涉及 GUEST 的中断。主要涉及时钟中断，一种实现方式是当 GUEST 配置 RTC 的时候会陷入 Hyper，由 Hyper 来设置时钟，当时钟触发的时候，Hyper 会触发 GUEST 的时钟中断位这样。Hyper在设置完之后应该是会关中断的，待下次GUEST设置中断的时候再打开，这样保持一致。

课后练习尚未完成，嗯。

总结

这里总结的话，三阶段实在不完美，时间上太赶了，然后各种东西都想弄明白细节，这样就很来不及。原本还准备看RISCV的指令集虚拟化扩展这样，也只看了一小部分，内容上其实不算多，但要补的内容比较多，就比较费劲。