0%

宏内核

到宏内核的特点就是:

  1. syscall
  2. app和kernel分离
    1. 特权级分离
    2. 独立空间
    3. 可以加载应用

用户空间降级方式:伪造返回现场到新任务, sret
过程:

  1. 初始化用户栈
  2. 创建新任务
  3. 让出CPU

几个重要的点

1. 任务扩展属性

将调度属性和资源属性分离,从而复用调度组件


2. 系统调用

用的是linkme这个库
linkme 是一个 Rust 的库,主要用于在编译期将数据链接到程序的特定部分(如全局变量),从而实现类似插件或模块化的功能。它可以动态扩展程序的功能,而无需显式修改原始代码。以下是对 linkme 的详细介绍,包括其用法和原理。

核心功能

linkme 提供了一种机制,使多个 Rust 模块中的静态变量可以被聚合到一个全局列表中。常见的使用场景包括:

  1. 插件系统:收集并注册动态功能。
  2. 初始化系统:在程序启动时执行一系列初始化函数。
  3. 静态配置集合:在不同的模块中定义配置项,并将它们汇总到一个位置。
    使用方法
    1. 添加依赖
    Cargo.toml 中添加:
    1
    `[dependencies] linkme = "0.3"`
    2. 定义集合

使用 #[linkme::distributed_slice] 定义一个全局的切片,用于收集静态变量。例如:

1
2
3
use linkme::distributed_slice;  
#[distributed_slice]
pub static MY_SLICE: [fn()] = [..];`

这里,MY_SLICE 是一个切片,它的类型是 fn(),表示可以存放多个函数指针。

3. 添加元素

在其他模块中,使用 #[distributed_slice] 将元素插入到切片中:

1
2
3
4
5
6
7
use linkme::distributed_slice;

#[distributed_slice(MY_SLICE)]
static FIRST_FUNCTION: fn() = || println!("First function");

#[distributed_slice(MY_SLICE)]
static SECOND_FUNCTION: fn() = || println!("Second function");
4. 使用切片

在程序中,你可以遍历切片的所有元素,并执行对应逻辑:

1
2
3
4
5
fn main() {
for func in MY_SLICE {
func();
}
}

得到

1
2
First function
Second function
原理解析

linkme 的实现基于 Rust 的链接器特性和目标平台的支持。以下是其工作原理:

  1. 分布式切片的定义
    • #[distributed_slice] 宏定义了一个全局符号,分配了一段内存区域,专门用于存储相关的元素。
  2. 分段存储
    • 每次使用 #[distributed_slice] 添加元素时,linkme 会将这些元素放置到编译产物的特定段(section)中。
  3. 链接器聚合
    • 链接器在链接阶段会将所有模块中定义的元素合并到一个段中,使得这些元素在运行时可以统一访问。

课后题

  1. 注册 PAGE_FAULT
  2. 完善注册函数
    1. 获得当前的task
    2. 得到aspace
    3. 调用其handle_page_fault方法填充

第二节

内存管理方式:

其他的和rcore很像,最后会在backend中处理映射

  • alloc(支持lazy)
  • linear (连续映射)

lazy映射:先map出虚拟地址但是没有关联物理地址,在page fault后在处理函数中多次嵌套调用handle,最后在aspace中完成关联

课后题

mmap的实现和page fault的处理很像,

  1. 找到一个free的va(最开始这里卡了很久)
  2. 读取文件内容,填充到buffer
  3. map alloc出一个页
  4. 用buffer填充这个页

hypervisor

第一节

hypervisor和虚拟机的区别是:支撑其物理运行的体系结构和其虚拟运行的环境是否一样(同构). 所以hypervisor比虚拟机更加高效.

我的理解,hypervisor也是一种类似于OS软件,如果是U的指令可以直接执行,如果需要特权级就在hypervisor中捕获处理.
hypervisor的扩展指令也是为了加速这个过程

资源管理:

  1. vcpu(直接绑定到一个CPU)
  2. vmem(提供自己的页表转换)
  3. vdevice(virtual io/ 直接映射 / 模拟)
  4. vutilities(中断/总线..)

练习题

panic将系统shut,所以需要去掉panic改成(ax_println!),然后将sepc+4跳转到下一个指令,再设置一下a0,a1的值就可以了

第二节

主要学习了两段映射

  1. Guest缺页,guset os向hypervisor查找
  2. hypervisor也缺页,向实际物理机申请

第二的部分有两个模式

  1. 透传
  2. 模拟

透传:直接把宿主物理机(即qemu)的pflash透传给虚拟机。(快 捆绑设备)
模拟:模拟一个pflash,当读取的时候传递(慢 不依赖硬件)

切换

具体的汇编:

练习题

将pflash.img写入img的/sbin/下后,在 h_2_0/src/main.rc 中将其read出来,然后将第一页的内容填充到buf中,aspace.write进去就可

第三节课

实验课正在做

虚拟时钟

总的思路是:通过关键的寄存器hvip中的VSTIP(时钟中断)来向hypervisor响应虚拟机的设置时钟中断,然后当时钟中断来的时候退出vm,并重新设置时钟中断hvip,回到vm处理.

宏内核的支持

主要是flash这种设备的处理,这个在前一个的实验中已经解决了.

虚拟设备管理:通过mmio,注册device的地址,当发生page fault的时候判断一下,如果是在mem中则正常处理,如果是在device则去对应的设备处理.

unikernel

特点:

  • 内核组件化
  • 内核和应用处于同一内核级,共享同一个地址空间,既是应用又是内核

课后练习:

如果希望只有通过println宏打印出来的文字有颜色,就应该选择在println定义的地方进行修改,即在axstd中修改
在/arceos/ulib/axstd/src/macros.rs中找到println宏的定义,进行颜色的添加
以下是修改前的输出

以下是修改后的输出

如果希望包括启动信息在内的内容都以某个颜色打印,就需要修改更底层的位置,即修改axhal
找到了axhal中调用输入输出的地方,进行颜色的添加
修改后的输出

课后练习<支持HashMap类型>

hashbrown 是一个高性能的哈希集合和哈希映射库,提供了 Rust 标准库中 HashMapHashSet 的实现。实际上,Rust 标准库的哈希集合和哈希映射类型(如 std::collections::HashMapstd::collections::HashSet)在底层就依赖于 hashbrown

将hashbrown::HashMap引进就可以了
建立以下路径的文件
/arceos/ulib/axstd/src/collections/mod.rs
添加引用

1
pub use hashbrown::HashMap;

然后得到结果

课后练习<为shell增加文件操作命令>

底层已经提供了rename有关的接口,直接调用就实现了rename
关于mv,可以分两种情况,mv的是文件还是文件夹:
如果是文件,其实mv的本质就是rename,将文件夹的路径修改到文件名的前面
如果是文件夹,我认为可以递归文件夹下的所有文件和文件夹,进行rename

课后练习<bump内存分配算法>

根据给的图示完善结构体,

1
2
3
4
5
6
pub struct EarlyAllocator <const PAGE_SIZE: usize>{
    start: usize,
    end: usize,
    b_pos: usize,
    p_pos: usize,
}

alloc时,先对现有的b_pos向上取整对齐,再加上新分配的长度
对于页分配,就多考虑一个页面大小

一、前言

这个月因为一些工作的原因并没有很好的完成课程的学习挑战这些内容,对于课程只看完了宏内核部分。但是我认为我学到了我感兴趣的部分。对于这部分我学习的感受就是是对于之前的os开发的进一步学习,对于unikernel的组件就是之前rustos实现的部分的更加具体的模块化。(虽然我还是在涉及内存以及地址的部分有些不明白)

二、 unikernel

对比裸机和RTOS

对比裸机 这样的组件化操作系统可以更快的添加功能 适配硬件
对比RTOS 可以更加灵活的做删减 比如替换使用的调度算法
更像是一种进化的裸机 所有操作系统都是为了应用而存在的
为应用的功能拆解出各种需要的模块 再拼装成一个只为了这个应用而存在的系统

系统有关与系统无关模块

所有的使用的模块都算作是系统无关的
只有你使用这些系统无关的模块所构成的就是一个系统有关的系统
说到底就是可替换和不可替换的
对于一些模块的功能是不可替换的 就可以说是系统相关的
而对于一部分模块来说就是 可有可无根据需要的特性去选择的就是系统无关的

我的理解

感觉就像是发展又发展了回去 一开始都是专业的产品 后面开始做通用性的产品当达到一定程度后又开始专业化

进一步思考

那就说明这个是一个高度定制化的系统
目的应该就是在性能更低的平台 来实现更为定制的功能
所以我理解就是 一个定制产品 而不是一个需要很多额外性能 来在一个通用计算机上实现的产品
那么我认为 这个系统应该要和芯片相绑定的 甚至这个应该更为适合fpga平台
来实现真正意义上的软硬一体
一个从一开始就是为了通用计算设计制造的芯片
我觉得会成为这样定制性系统的瓶颈 如果发展下去

宏内核

相对于unikernl 宏内核增加了一个用户特权级
这样不同的特权级 让应用更加安全因为不能直接访问到内核内的

多伪造了一个所谓的应用态 调用了一次sret来让系统从特权态进入到用户态
我认为这样扩展出来的宏内核系统 就像是在嵌入式设备中常见的中枢网关

我的理解

这样扩展ArcOS的内核类型我觉得就像是课里面老师说的对于设备端使用unikernel 对于管理端使用宏内核
我感觉这是在构建一个分布式的场景

unikernel的异构思想 就是将共同的组件作为基础
而将不同内核最大的特性作为独立的组件 这样就类似存在多种内核的系统
通过多种异构的内核 但是其中又使用了共同的模块又能有一定的统一性
或者说后期的维护 可以由一个团队共同维护一个场景
可以避免互相不清楚对方的模块导致无法定位问题所在的地方

组件化内核

组件化内核具有灵活,增量构造等优点。
组件化内核最启发我的是组件化可以用来快速构造应对不同场景的各种模式内核。
不同的功能组件,不同的内核特权级,不同的隔离要求…
组件化内核完全可以快速满足这些要求。

Unikernel

特点

单一特权级,简单高效。

实验

实验一

实验要点在于了解在不同层级下修改对应输出语句产生的变化,了解输出都来自于哪些层级。

实验二

该实验完成对std::hashmap的支持,通过查阅rust的std源码发现rust基于hashbrown。因此引入hashbrown作为hashmap。

实验三

本次实验完成Bump分配算法,此算法较为简单。重点在于实现对应trait。

练习四

该实验重点在于了解文件系统对应函数,调用对应函数即可。

Monolithic

实验

m_1

注册handle_page_fualt(), 通过aspace中的handle_page_fualt()来处理异常。

mmap

该实验是通过仿照linux来完成mmap:
1,阅读linux中的mmap,确定各参数意义:
2,分配内存buf,注意点为分配的空间需要4K对齐;
3,读取文件内容至buf

Hypervisor

特点

侧重于虚拟而非模拟,同时保持高效和安全

实验

h_1_0

按实验要求设置对应寄存器值,同时增加spec使guest运行下一条指令。
但不知为何,程序运行会经常卡死,代码未改动情况下运行结果不确定。

h_2_0

将pflash内容写入disk作为文件,与加载guest文件内容类似处理即可。

lab1

用户程序特征

该lab中的用户程序基本特征为申请n次倍增的内存,之后释放偶数次申请的内存,以此循环。

内存分配

1,由于物理内存大小为128m,初始即分配全部内存给内存分配器。
2,由于奇偶关系,将内存切分为两个区域。
3,由于倍增关系,将两个区域大小配置为2:1。

rCore2024第三阶段总结

非常遗憾也非常懊悔,我这个大三狗由于近两周实在是俗务缠身且不可脱身,因此并未太多参与到rCore的学习中,也仅仅是在第三阶段结束前几天勉强抽空看了一下前几个(前3个)ppt。本人作为一名大三学生,学习这几个 PPT 中的组件化内核设计与实践,感受颇深且困难重重。从基础概念到复杂的技术细节,如内存管理的分页机制、多任务调度算法,再到设备管理框架等,知识量剧增且难度攀升。但我相信如果能跟下去一定是收获满满,从中不仅能拓展操作系统内核知识视野,更能极大提升代码能力,后面也是报名了操作系统内核设计的华东区预赛,希望能抽出更多时间补上第三第四阶段的内容,并在比赛中取得好成绩吧。

课后练习:bump内存分配算法

主要代码在alt_axalloc里,与axalloc里不同,它在初始化时内部只有一个分配器,并把所有物理内存都分配给它。这个分配器同时实现字节分配器和页分配器的trait,但分配内存时只使用字节分配器里的alloc,页分配器里的alloc_pages没用。

1
2
3
// modules\alt_axalloc\src\lib.rs
#[cfg_attr(all(target_os = "none", not(test)), global_allocator)]
static GLOBAL_ALLOCATOR: GlobalAllocator = GlobalAllocator::new();

要想正常实现动态内存分配,首先要用#[global_allocator]属实告诉编译器使用哪个分配器实例作为全局分配器。

1
2
3
4
// modules\alt_axalloc\src\lib.rs
unsafe impl GlobalAlloc for GlobalAllocator {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {...}
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {...}

然后需要为自定义的分配器实现GlobalAlloc trait里的alloc和dealloc方法。查找调用关系:GlonalAlloc::alloc -> GlobalAllocator::alloc -> EarlyAllocator:alloc -> ByteAllocator::alloc,dealloc同理。因此主要修改的代码为modules/bump_allocator里的EarlyAllocator里的ByteAllocator trait的alloca和dealloc方法。

bump的实现参考Writing an OS in Rust : Allocator Designs 分配器设计与实现-CSDN博客

lab1:针对应用场景,优化内存分配器组件

分配器内存的初始化和申请

总共可用于分配的堆内存大小是多少?
根据axalloc::global_init(start_vaddr, size) -> GLOBAL_ALLOCATOR.init(start_vaddr, size) 可得size参数的大小即为分配的堆内存大小。查找global_init的使用得axruntime::init_allocator

1
2
3
4
5
6
7
8
9
10
11
12
13
// axruntime::init_allocator
...
for r in memory_regions() {
if r.flags.contains(MemRegionFlags::FREE) && r.paddr == max_region_paddr {
axalloc::global_init(phys_to_virt(r.paddr).as_usize(), r.size);
break;
}
}
for r in memory_regions() {
if r.flags.contains(MemRegionFlags::FREE) && r.paddr != max_region_paddr { axalloc::global_add_memory(phys_to_virt(r.paddr).as_usize(), r.size)
.expect("add heap memory region failed");
}
}

由上述代码可得标记为free的内存区域都分配给内存分配器使用。

memory_regions -> platform_regions,当前平台为riscv64

1
2
3
4
5
//riscv64_qemu_virt_/mem.rs
/// Returns platform-specific memory regions.
pub(crate) fn platform_regions() -> impl Iterator<Item = MemRegion> {
crate::mem::default_free_regions().chain(crate::mem::default_mmio_regions())
}

default_free_regions里标记为free,块起始地址为_ekernel,结束地址为PHYS_MEMORY_END。

1
pub const PHYS_MEMORY_END: usize = PHYS_MEMORY_BASE + PHYS_MEMORY_SIZE;

定义在config.rs里,查找可得物理内存大小为128m,根据128m查找可得由来为qemu启动时设置的物理内存参数128m。运行时添加LOG=debug参加也可以在输出信息里直观看到分配给分配器的内存,initialize global allocator at: [0xf
fffffc080270000, 0xffffffc088000000), size:131661824。

1
2
3
4
5
6
7
8
9
// GlobalAllocator::alloc
let old_size = balloc.total_bytes();
let expand_size = old_size
.max(layout.size())
.next_power_of_two()
.max(PAGE_SIZE);
let heap_ptr = match self.alloc_pages(expand_size / PAGE_SIZE, PAGE_SIZE) {
Ok(ptr) => ptr,
Err(e) => panic!("Bumb: {:?}.", e),}

初始分给字节分配器32KB,当alloc内存不够时,由页分配器再分配页倍数大小的内存。注意分配时要求的内存大小和字节分配器的total_bytes函数返回的值有关,若total_bytes实现不当返回值过大,则一次要求的内存会远远超过实际需要的内存,造成字节分配器分配内存失败,提前终止迭代(我实现的total_bytes返回的是可分配的内存大小,这样每次申请的内存就和需要的内存接近了)。

应用程序内存的申请和释放

通过在alloc和dealloc函数里log,分析堆上内存的分配和释放时机,主要和三个变量有关:pool、items和a。a类型是Vec<u8>,可以简单看作是一个内部地址连续的内存块。items和pool类型是Vec<Vec<u8>>,可以看成是存储Vec胖指针的集合。

在主循环里的每一轮先调用alloc_pass申请大量内存,连续申请$a_n\quad (n = 0, 1, 2, \ldots, 14)+\delta$大小的内存块,其中$\delta$表示轮数,$a_n$是首项为32,最大项为524288的以2为公比等比数列,用等比数列的求和公式可得一轮申请的内存块之和大约为1MB。每申请一个内存块便push进items里,items扩容是翻倍,初始申请$4\times32$B大小的内存,扩容的时候先申请$8\times32$B大小的内存,再释放之前申请的。因为一轮循环里总共申请15块内存,items最大容量为$16\times32=384$B。

alloc_pass结束后通过free_pass函数连续释放掉偶数项的内存块。然后将items append进pool里,每一轮循环结束pool就增加$7\times24=168$B大小,pool每次扩容时同样会释放掉之前占用的内存。pool的作用域是整个循环,pool本身及对应奇数项占用的内存在循环结束后才释放,随着循环次数的增加,占用内存越来越大,直到耗光128MB总内存。

我们可以粗略进行分析,如果忽视掉pool和items变量本身的大小(使用bumb算法,items变量最多占用$96+192+384=672$B,pool最多占用$168\times\sum_{n=1}^\delta k$ B)和每次循环递增的$\delta$,每一轮循环释放掉偶数项的总和约为$\frac{2}{3}$ MB,那么理论上最大循环次数约为$128\times3=384$。注意这是在保留奇数项内容正确性,不对奇数项所占内存进行覆写的情况下。

自定义内存分配器的设计

根据上面的分析可知,items能占用的最大空间是有限的,且在每轮循环结束后会全部释放,适合在固定大小的内存区域里使用bumb算法管理。偶数项所占用的内存空间随着$\delta$变化非常缓慢,且同样也会在每轮循环结束前全部释放,同样适合在固定固定大小的内存区域里使用bumb算法管理。同时,items和偶数项都会在全部释放完后再重新分配,所以items和偶数项可以在一块内存里用bumb算法管理。pool和奇数项占用空间是持续增加的,pool会释放,奇数项不会,但为了简单处理一样用bumb算法管理(pool占用内存在轮数较大时存在较大的优化空间)。

分配器初始可用内存为32KB,当分配不够时再向页分配器申请扩容。为了方便划分区域进行管理,在申请第0轮第0项大小的内存时,我们在alloc函数里返回nomemory错误,并在total_bytes函数返回items和偶数项之和的大小来申请足够的内存。在不覆写奇数项情况下,理论最大轮数大约为384,偶数项之和每一项增加15,所以items和偶数项之和为$672+699040+384\times15=704932$B大小,这样分配器初始就能申请向上取整2的n次方和4096的倍数1048576B大小的内存使用。

由初始地址开始,大小为704932B大小的内存区域用来进行items和偶数项的分配和释放。剩下的区域用来进行pool和奇数项的分配和释放,随着奇数项的增加再向页分配器申请新的扩容,直至最终内存耗尽,所有区域内部均使用bumb算法进行管理。注意,每一轮循环里items和偶数项都会在申请完毕后全部释放,奇数项在整个循环期间不释放,所以用bumb管理是合适的。但pool在循环内是会释放的,且随着轮数的增加,空闲内存大小不容忽视,未来可以用更高效的算法来管理pool的内存,还能进一步增加轮数。

课后练习: 实现最简单的Hypervisor,响应VM_EXIT常见情况

先从simple_hv/src/main.rs里的main函数开始运行,此时处于host域。用new_user_aspace创建地址空间,load_vm_image加载要在guest域里运行的内核文件。prepare_guest_context伪造guest上下文件,设置初始特权级为S,sepc值为VM_ENTRY(内核文件的入口地址)。

1
2
3
4
5
6
7
8
9
10
// Kick off vm and wait for it to exit.
while !run_guest(&mut ctx) {}

fn run_guest(ctx: &mut VmCpuRegisters) -> bool {
unsafe {
_run_guest(ctx);
}

vmexit_handler(ctx)
}

while循环里将会启动guest并等待它退出。_run_guest在guest.S里,主要功能是保存host上下文和恢复guest上下文,具体细节下次课会讲,最后sret跳转到sepc里的地址,切换到了guest里的内核执行。触发中断后会跳转到_guest_exit里执行,执行完后会进入vmexit_handler函数里执行(执行完_guest_exit后会接着执行_restore_csrs,里面恢复了ra寄存器的值,并在最后使用ret返回到调用_run_guest的下一行)。

1
2
3
4
5
6
7
8
9
10
//payload/skernel/src/main.rs
unsafe extern "C" fn _start() -> ! {
core::arch::asm!(
"csrr a1, mhartid",
"ld a0, 64(zero)",
"li a7, 8",
"ecall",
options(noreturn)
)
}

内核程序如上所示,当执行csrr a1, mhartid时,VS态写入了M态的寄存器,触发非法指令异常。ld 10, 64(zero),写入了非法内存地址,触发页错误异常。ecall指令超出VS态执行权限,触发异常。

先触发非法指令异常,在异常函数处理中,我们先需要将sepc+=4(一条指令长度为4字节),以便下次_run_guest里的sret能正确跳转到下条指令执行。然后返回false,以便while循环不退出,继续执行run_guest函数。

总结

这个阶段学得不是很扎实,很多内容都只看了视频,没有完成课后练习,等后面还要进一步回锅。

2024三阶段总结

由于考试和双十一的影响,导致我实际学习三阶段的时间不到一周,到目前为止,勉强把实验做完了(除了最后一个套娃arceos的实验还没有看)。考试自不必多说,至于双十一嘛,是由于外存不够了,要升级一下,然后迁移系统、配置环境什么的。

由于时间较少,而且刚考完一场试,变懒了,所以对ArceOS还没有仔细研究,下面的内容可能较空泛、可能有错误。

Unikernel

在我看来,Unikernel是一个与业务无关的裸机应用,分层、模块化且可扩展,根据业务的需要可以选取需要模块或对模块进行扩展,可以像正常开发linux c应用或std rust应用一样迅速开发裸机应用。

在这一阶段,被迫看了一些关于feature、attribute、条件编译的一些知识,头一次知道原来rust里面还有workspace。

  • print_with_color

就加一些特殊的字符

  • support_hashmap

看群内大佬讨论,就引了一个库

  • alt_alloc

对于这个,一开始还想最初的页是怎么分配来的,后来才想明白这些页已经固定下来了,只要考虑怎么管理就行了。

  • shell

对于mv操作,我一开始想的是仅移动指向inode的指针,不拷贝文件,但发现实现有些难,就没有这样做。最终rename和mv都用了rename实现,感觉有些奇怪,但起码测例能过,不愧是arceOS,就是通用。

宏内核

如果按照上面的理解的话,宏内核是Unikernel上的应用,但是又有些不太对,相比于实现业务目的,它更倾向于是扩展Unikernel,看起来有些像“内核之上不只有应用,还有内核的微内核”。

  • page_fault

相比于实现page_fault,我更关注的是linkme这种骚操作。

  • sys_map

就find_free_area然后read进去,虽然感觉用find_free_area找到的地方有些不符合man mmap的说明。

Hypervisor

在三阶段的实现中,看起来Hypervisor最没用,在裸机之上实现裸机,大部分实现都是透传的,相比于直接运行在裸机上,不仅功能减少了、性能变差了,就连能源的使用也不只是烧电,还烧头发,悲。

还有,感觉可不可以在ArceOS上同时运行宏内核或其他应用和Hypervisor,ASA(ArceOS Subsystem for ArceOS)1.0就在眼前

  • simple_hv

改一下guest的sepc,设置一下a0、a1的值

  • pflash设备模拟方式

一开始没有搞清gpa映射到hpa时,没有经过host的satp,导致在host中拿着pa当va来用,出现了问题。另外,在完成后,修改了一下pflash的内容,想要读u128转string输出,但是没想到,在对* u128解引用时,它居然会先读u128的高64位,导致映射时页面没对齐。

主要看了下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模式的寄存器并在相应事件发生时设置回调函

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

Read more »

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的,准确来说,只是修改了某个内存块的大小限制,所以优化也没有那么明显。

祝接下来项目阶段好运!