解析`WebGPU`、`Virtio1.2`规范，以及`WGPU`、`Vortex`源码，探索异步操作系统与内核态GPU资源管理的结合方案。

第一阶段 rust基础

rustlings比较顺利，已关注rust好几年了，也一直跟进rust的发展和变化，用了大概几天的时间突击完成

第二阶段 rcore

这是我第一次接触操作系统，印象还都停留在原来的书本上，概念上，都是理论，没有真正接触操作系统是什么样的，所以，这个机会能让我了解探究操作系统内部真正的原理和运行逻辑，解开我心中的多年的疑惑，很是开心到起飞。

总体印象最深的就是操作系统内核是以什么形态存在的，上下文如何切换，进程空间如何形成，页表是如何实现的，跳板页又是怎么回事

第三阶段 ArceOS

这个和我预期不一样，没有沿着rcore继续走，这是一个全新的设计，一时间，有点慌乱，不能和rcore相关的思路很自然的顺承下来，显然这个更具有前瞻性，为此我也花了好多时间来梳理这个逻辑和rcore都关联起来。这个模块化设计的理念很突出，相互之间的关联及细节，需要仔细的研读和体会。

第三阶段的具体case

color

对println!() 把颜色表示直接加入后，可以显示颜色，
如在当前文件写了一个宏print_with_color!，让后让println!去去调用此宏，就得不到正确结果，提示找不到这个宏，查了资料，和 $crate有关，宏的暴露方式有关，引用路径，由于时间关系，后面调研

HashMap

开始的时候，从rust官方移植，这个太痛苦了，依赖太多了，最后放弃。
自己写个简单的，只是利用了官方的
use core::hash::Hasher;
use core::hash::Hash;
这两个hash算法，主体采用了最简单的线性插入算法

bumpallocator

需要仔细理解题意和上下文，思路选用：
申请一直从可用空间起始向前申请，
释放如果全部的空间都释放了，就把下一个可用空间调整到开始

rename

采用递归的方式，一层一层的先找到所在当前目录
增加当前目录的，更改命名的方法，查找相应的文件，删除后，再插入一个，因为当前存储使用的是BtreeMap，不能更改index

hv

这个耗费了我好多时间，主要是因为运行例程会卡住，后来发现可能是qemu的版本问题，升级到9.2后，还是一样卡住，当时环境为windows11，wsl2，卡在这里，不同的情况卡的还不一样：

1

Write file 'payload/skernel2/skernel2' into disk.img

最后没有办法，找一台空闲机器，实在不行，我就安装裸机linux系统，所以先尝试装了另一种虚拟机，virtualbox7.18，也花了些时间，配置好环境后，默认的qemu为6.x时，还是会出错，不过不是卡主的问题，是会触发异常访问，升级到9.2.x后，按照预期执行了，难道说，wsl2在某些情况就是不行，我真是难过。

之后遇到提交github，出错，musl.cc被block，

下载不下来：
wget https://musl.cc/riscv64-linux-musl-cross.tgz

下载不下来，终于等来了替代方案

wget https://musl.cc.timfish.dev/riscv64-linux-musl-cross.tgz
最后，终于得以解决

sys_mmap

参数和返回值我理解出现偏差，

1
2
3
4
5
6
7
8

fn sys_mmap(
    addr: *mut usize,
    length: usize,
    prot: i32,
    flags: i32,
    fd: i32,
    _offset: isize,
) -> isize

参数addr为0时要特别注意，需要寻找一空间，还有地址和size的对齐。返回值，当开始时认为0是成功，为负时，返回失败原因，后来再三确认失败返回0，成功返回地址，isize作为地址返回，有点不符合直觉？

Next

期待第四阶段

前三阶段总结

• 前两阶段总结
• 第三阶段总结

主要收获

在第四阶段中，更多的时间留给了自由探索．虽然起初缺少具体的目标有些令人摸不着头脑，不过跟随老师的引导，也一步步确立了整个阶段的目标：基于 uring^1 机制实现异步系统调用．尽管最后只实现了基于 uring 的异步 IPC 机制，一路上走来也有许多收获．

Rust 的异步机制

虽然有一些 Rust 异步编程经验，但尚未从更底层的角度了解过 Rust 的异步模型．在第一周中，通过动手实现一个简易的异步运行时 local-executor，认识到 Rust 的异步原语 Future 是如何与运行时交互的．以及深入到内存安全层面上，了解了 Rust 中如何通过 pin 语义来巧妙的保证自引用结构体的安全性．尽管这并不是一个完美的模型——几乎所有涉及到 pin 语义的数据结构和函数都需要 unsafe 代码，而这些 unsafe 代码所需的诸多安全性保证又着实有些令人头大．因为，Rust 提供了静态安全性，而编译器会基于这些安全保证进行比较“激进”的优化．所以，Rust 中的 unsafe 要比其他生来便“不安全”的语言更加不安全，对开发者的要求也更高．

在第三周的探索中，又了解到一个之前从未考虑过的问题——Future 的终止安全性^2．而这对于实现基于共享内存的异步通信机制来说尤其关键，稍有不慎就会引发难以察觉的漏洞．在后来着手实现异步通信机制的时候，又对这个问题进行了更深入的思考，并在现有方案的基础上提出了另外几个可行的思路．

原子类型和内存排序

尽管曾了解过原子类型和内存排序相关的知识，但从未真正彻底搞懂过，直到在第二周的探索中发现了一本优秀的电子书 Rust Atomics and Locks^3．这本书从抽象的并发模型深入到具体的硬件细节，比较全面的介绍了几种原子操作和内存排序的设计初衷以及对应的汇编层面实现．结合这本书和自己的思考，又经过悉心整理最终形成了一篇比较详实的学习笔记．尽管在实践时还不能完全掌握各种内存排序的选择，通过翻看笔记以及参考相似场景下现有项目的做法，也都能找到一个安全正确的选项．

基于 uring 的异步通信

经过两周的调查和学习，最终在第三周完成了基于 uring 的异步通信框架 evering，同时利用 GitHub Pages 部署了它详细的设计文档．

evering 最重要的两个数据结构是用来管理消息队列的 Uring 和用来管理操作生命周期的 Driver．Uring 的实现借鉴了 io_uring 的做法^4，但结合 Rust 的特性做了一些简化．比如，io_uring 支持 IOSQE_IO_LINK 来要求响应侧顺序处理请求．而在 Rust 中，每个异步请求都被封装为 Future，故可以利用 .await 来在请求侧实现顺序请求．Driver 的实现则借鉴了 tokio-uring 和 ringbahn．但相比后两者，evering 提供了更灵活、通用的异步操作管理机制．

不过，目前 evering 相对简陋，仅支持 SPSC，因此请求侧或响应侧只能在单线程上使用．也许未来可以实现 MPSC 的队列，以便于更好的与现有的异步生态（比如 tokio）兼容．

基于 evering 的异步 IPC

经过三周的铺垫，第四周正式开始实践跨进程的异步通信．在第三周中，基于 evering 实现了简易的跨线程异步通信 evering-threaded，而对跨进程来说，主要的难点就是内存的共享．好在 Linux 提供了易于使用的共享内存接口，基于 shm_open(3)，memfd_create(2) 和 mmap(2) 可以轻松在不同进程之间建立共享内存区．而 ftruncate(3p) 配合缺页延迟加载机制，使得程序启动后仅需一次初始化就能配置好可用的共享内存区间．不过，目前 evering 只能做到基础的“对拍式”的通信方式．而近期字节跳动开源的 shmipc 则是一个相对成熟、全面的异步通信框架，这对未来 evering 的改进提供了方向．

基于 evering 的异步系统调用

由于时间相对仓促，加之备研要占用大量的时间，遗憾的是，在第四阶段并没有完成最初的目标——实现基于 uring 的异步系统调用．与 用户线程 <-> 用户线程 的通信相比，用户线程 <-> 内核线程 的通信要额外处理内核任务的调度和用户进程的生命周期管理．即如何处理多个不同用户进程的请求，以及用户进程意外退出后对应内核任务的清理．而就共享内存而言，由于用户对内核单向透明，这看起来似乎比 IPC 的共享内存更容易解决．

用户态线程与协程的调度

去年的夏令营中，embassy-preempt 实现了内核中线程和协程的混合调度．那么用户态的协程能否被内核混合调度呢？在实现异步系统调用的前提下，当用户态线程由于内核尚未完成调用处理而让权（通过 sched_yield(2) 等系统调用）时，实际上，内核可以获知该线程应何时被唤醒．这就与 Rust 协程中的 Waker 机制非常相似，而用户态的让权又与 .await 很类似．基于这些，那么可以将一个实现异步系统调用的用户线程转换为一个用户协程．此后，内核就充当了这个协程的运行时和调度器的角色．

而相比用户态的线程，使用协程的一个显著优点是，对用户任务的唤醒实际上相当于执行一次 Future::poll．这意味着，当用户主动让权时，它不需要保存任何上下文——用户任务的唤醒本质上变成了函数调用，而主动让权表示该函数的返回．如此便能够进一步减少用户和内核切换的开销，以及系统中所需执行栈的数量．当然，当用户协程被抢占时，它便回退成了类似线程的有独立执行栈和上下文的存在．

总结

经过近两个月的学习，对操作系统和异步编程的许多方面都有了一些相对清晰的认知．非常感谢夏令营中各位老师的付出和历届同学的努力，学习的过程中让我切身的感受到操作系统发展到现在那段波澜壮阔的历史，以及在不断推陈出新的技术潮流中一点微不足道的参与感．尽管最后没能完成目标有些遗憾，不过，这也为将来再次参加夏令营留下了充足的理由 :P

序言

非常高兴能参加到开源操作系统训练营第四阶段的学习，跟大家一起进步。经历完这四个阶段，自己有非常大的收获，让我理解了操作系统内部的运行机制，通过组件化的管理来实现更现代化的操作系统，最终在操作系统中支持异步机制提高操作系统的性能。

在每周的学习过程中，非常感谢向勇老师给与了很多的指导和鼓励，成为了我前进的支柱。同时也要感谢周积萍学长给与了很多帮助和支持以及建设性的意见，让我遇到困难时不迷茫。在第四阶段的过程中，也从其他同学那学到了很多，能便捷的获取到学习资料和代码，当有疑惑了也有人能够理解你，跟你一起深入到技术中进行讨论，那种感觉真是舒服。

每周工作

对于一个程序员来说，时间总是不够的，在四周时间里，我主要做了以下几个方面的工作：

第一周 - 回顾

当我第一周(2025-06-01)加入训练营的时候，发现去年的学长大佬们已经早早的开始了自己的课题。我就从基础慢慢开始，这周主要是把文档中的例会视频都看了一遍，基本了解了协程异步的作用以及目前是如何把异步应用到操作系统内核当中去的。

第二周 - 定目标

在看例会视频的时候，我发现有学长讨论 rust 异步的函数着色问题，碰巧我之前在写 rust 的时候也遇到了这个问题，很多时候一套逻辑代码，要分别实现一个同步版本一个异步版本，从一些学长的代码中看确实是分开写的，比如赵方亮学长的仓库，在 2025-06-07 例会讨论中，有同学在参加 “大学生操作系统大赛” 的时候也遇到了此问题，最近在学习 zig 这门语言，说是能解决这个问题，我便想借着这个机会深入研究下。也是对于函数着色问题的一些自己的尝试，于是便确立了如下目标：

• 长期目标：实现低侵入式的异步协程框架，服务于操作系统内核
• 本期目标：实现简单的异步协程运行时 (zig)

后续在调研的过程中，发现 rust 的异步机制，是基于 Future 来实现的，这是一种无栈协程，跟我之前理解的 Go 语言的那种有栈协程还不一样。

第三周 - 学习和实验

后续的两个周，主要是学习文档中的异步协程资料，编写实验代码，验证自己的想法。

• 学习内容

  • C：实现一个迷你无栈协程框架——Minico - 理解什么是无栈协程
  • stack-less rust coroutine 100-loc - 理解 rust 无栈协程
  • Rust 圣经 - 手写 Future Runtime - 理解 Waker 机制
  • 200 行代码绿色线程 - 如何从零实现协程(绿色线程)

• 实验部分

  基于上面的学习的内容，进行了如下实验来验证想法：

  • 实现在 zig 中调用 rust 封装的绿色线程任务
  • 实现基于 Future 的异步运行时 (用 zig 语言)
  • 用 asm + zig 实现有栈协程切换机制

第四周 - 代码结合

• 异步协程运行时 xasync 框架代码编写
  • 基本完成跑通简单测例
  • 同时初步解决了函数着色问题

完成上述四周的工作后，基本实现我在开源操作系统训练营本阶段的目标，符合预期。

xasync 异步协程运行时

使用者角度

我在设计 xasync 异步协程的时候，借鉴了 zig 协程 的设计思路，感觉 zig 协程更容易让使用者理解和减轻负担，那么从使用者的角度出发，什么样的协程用起来才是最舒服的，我认为尽量保持一套代码，只通过一些简单的标记就可以实现同步和异步的切换，是更加友好的协程框架实现方式。下面是我理解的伪代码。

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

var is_async = true // 如果关闭后，底层会走阻塞逻辑

fn read(file) {
    if (is_async) {
        scheudle(future:run(sys_read(file))) // 生成 future，交给 executor 和 eventloop 调度处理
        suspend()
    } else {
        sys_read(file)
    }
}

fn long_time_action() {
    read("large file")
    sleep(100)
}

fn other_action() {
    
}

fn main() {
    let frame = xasync(long_time_action) // 使用者也可以用 xasync 来标记上层代码是异步的
    // xawait(frame) // 需要等待的时候才等待
    
    other_action()
}

通过上面的注释，可以仔细看下调用流程，这是我个人期望的协程框架使用方式的理解。

架构设计

上面是架构设计图，分为前后两部分把 有栈协程 和 无栈协程 结合起来，其中红线理解为前进 蓝线理解为返回，比方说协程切换的前进返回、Future poll 前进和状态返回、协程调度的前进和唤醒的返回等。

目前图中描述的是有三个协程(绿色线程)在需要的场景下不断让出执行权，在异步任务结束后能随时切换到具体的任务上继续执行。这种机制在需要等待返回结果的情况下尤为重要。后续会优化成协程池方便使用。

下面从测例的角度简单剖析下实现代码和原理。

Future

测例代码

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

const Counter = struct {
    const Self = @This();
    num: u32,
    max: u32,

    fn init(num: u32, max: u32) Self {
        return .{
            .num = num,
            .max = max,
        };
    }

    fn doCount(ctx: *Context) Result {
        const counter = @as(*Counter, @ptrCast(@alignCast(ctx.payload)));
        if (counter.num < counter.max) {
            std.debug.print("counter num = {}\n", .{counter.num});
            counter.num += 1;
            return .wait;
        } else {
            return .{ .done = &counter.num };
        }
    }

    fn doNextCount(result: ?*anyopaque, ctx: *Context) *Future {
        var counter = @as(*Counter, @ptrCast(@alignCast(ctx.payload)));

        const num = @as(*u32, @ptrCast(@alignCast(result)));
        const value = num.*;

        counter.num = 0;
        counter.max = value + 5;

        return run(Counter.doCount, counter);
    }
};

test "counter-chain-done" {
    const allocator = std.testing.allocator;

    var executor = Executor.init(allocator);
    defer executor.deinit();

    var counter = Counter.init(0, 5);
    const fut = runWithAllocator(allocator, Counter.doCount, &counter).chain(Counter.printNum); // 这里支持链式调用

    executor.schedule(fut);

    executor.run();
}

上面的代码是把一个 Counter 计数器，改成了异步机制，当 num > max 的时候才会终止运行。在实现的时候利用 zig uinon(enum) 的特性，尽量做到了零成本抽象。

支持组合

还支持了 Then 组合操作，因为在封装 Future 代码的时候可能要把原有的阻塞代码拆成多个 Future 逐步执行。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

test "counter-chain-counter" {
    const allocator = std.testing.allocator;

    var executor = Executor.init(allocator);
    defer executor.deinit();

    var counter = Counter.init(0, 5);
    const fut = runWithAllocator(allocator, Counter.doCount, &counter).chain(Counter.doNextCount); // 这里支持链式调用

    executor.schedule(fut);

    executor.run();
}

后续还会在 Future 上进行扩展支持 Join 等更多组合操作。

Executor

Executor 中有两个队列：

• ready_queue: std.ArrayList(*Future) - 调度队列，供调用者放入 Future 任务
• futs: std.ArrayList(*Future) - 执行队列，实际调度器处理的 Future 任务

Future 先是进入到调度队列，如果调度开始执行后，会从调度队列取出任务放入执行队列，这时候执行队列中可能还有其他未完成的任务，当 Future 结束后会从执行队列中移除，如果执行队列中的所有任务都是等待状态，则 Executor 处于 idle 状态，等待 event_loop 唤醒，具体使用方式在上面的测例代码中已体现。

目前调度策略比较简单，而且没有经过任何优化，后续会不断完善。

Coroutine(绿色线程)

目前已经支持协程间的切换，下面的代码是非对称协程的实现方式：

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

var base_coro: Coroutine = undefined;
var count_coro: Coroutine = undefined;
var count: i32 = 1;

fn addCount() void {
    count += 1;
    base_coro.resumeFrom(&count_coro);
    count += 1;
    base_coro.resumeFrom(&count_coro);
    count += 1;
    base_coro.resumeFrom(&count_coro);
}

test "simple counter suspend and resume coroutine" {
    const allocator = std.testing.allocator;

    base_coro = try Coroutine.init(allocator, null);
    defer base_coro.deinit();
    count_coro = try Coroutine.init(allocator, addCount);
    defer count_coro.deinit();

    try std.testing.expect(1 == count);

    count_coro.resumeFrom(&base_coro);
    try std.testing.expect(2 == count);

    count_coro.resumeFrom(&base_coro);
    try std.testing.expect(3 == count);

    count_coro.resumeFrom(&base_coro);
    try std.testing.expect(4 == count);

    std.debug.print("all finished\n", .{});
}

这个测试就是用协程的方式去执行 addCount 所在的 count_coro 协程，在 addCount 中也可以随时切换调用者协程 base_coro，执行原有逻辑。

还支持了函数参数的传递，在上下文切换的时候，不是两个函数的切换，是通过一个中间函数 call，它会根据汇编传过来的参数指针地址，转换成具体的 *Coroutine，再从其中拿出 func_ptr 和 args_ptr，就相当于中间层转发了一下。从下面的代码看目前参数类型都是定死的，有点牵强，目前够用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

fn call(coro_ptr_int: u64) void {
    const coro: *Coroutine = @ptrFromInt(coro_ptr_int);

    std.debug.print("current coro address: 0x{x}\n", .{@intFromPtr(coro)});

    if (coro.frame.func_ptr != null) {
        if (coro.frame.args_ptr != null) {
            const func_ptr = @as(*const fn (*const anyopaque) void, @ptrCast(coro.frame.func_ptr.?));
            const args_ptr = coro.frame.args_ptr.?;
            func_ptr(args_ptr);
        } else {
            const func_ptr = @as(*const fn () void, @ptrCast(coro.frame.func_ptr.?));
            func_ptr();
        }
    } else {
        std.debug.print("the func pointer is null\n", .{});
    }
}

Eventloop

事件响应机制也就是 eventloop (reactor 模型)，其实是所有异步协程实现的底层支持，我甚至认为就算不用异步，只用事件机制和回调的方式也能做到高性能。这一部分在本期训练营并没有深入的去学习，目前只是实现了一个大概。如果这层封装好了，做成一层统一的抽象去处理 epoll、io_uring、iocp、kqueue 以及中断信号量等，也将会有很大的收获，给自己挖个坑，明年把这部分填上。

eventloop 的核心代码就是用一个循环，不停的调用系统需要等待的函数，等待系统给出响应，这里用的是 epoll_wait，这些系统提供的函数其实在操作系统里面都有自己的实现，一般性能都比较高，而且可以阻塞也可以非阻塞。当系统给出响应后，再触发回调去唤醒 Executor。

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

pub fn poll(self: *Self, timeout_ms: i32) !usize {
    try self.events.resize(16); // 预分配事件数组，先这么写

    const n = std.posix.epoll_wait(self.epfd, self.events.items, timeout_ms);

    for (self.events.items[0..n]) |event| {
        const fd = event.data.fd;

        if (self.callbacks.get(fd)) |callback| {
            if (event.events & std.posix.system.EPOLL.IN != 0) {
                var buf: [8]u8 = undefined;
                _ = std.posix.read(fd, &buf) catch {}; // 这里目前只处理了 timer 的情况

                if (callback.callback_fn) |func| {
                    func(callback.user_data);
                }
            }
        }
    }

    return n;
}

pub fn run(self: *Self) !void {
        self.running = true;

        while (self.running) {
            _ = try self.poll(100); // 100ms 超时
        }
    }
}

整体组合 xasync

把上面各部分组合起来，看看能不能达到预期效果。

Timer

这部分注册一个 TimerHandle 到 event loop 当中。

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

const Timer = struct {
    const Self = @This();

    handle: TimerHandle,
    completed: bool = false,
    waker: ?*const Waker = null,

    fn init(nanoseconds: u64) !Self {
        const handle = try TimerHandle.init(&global_event_loop, nanoseconds); // 注册给 event_loop
        return .{
            .handle = handle,
        };
    }

    fn deinit(self: *Self) void {
        self.handle.deinit();
    }

    fn timerCompletedCallback(data: ?*anyopaque) void { // event_loop 回调
        if (data) |ptr| {
            const timer: *Timer = @ptrCast(@alignCast(ptr));
            timer.completed = true;
            std.debug.print("timer callback completed!\n", .{});
            if (timer.waker) |waker| {
                waker.wake(); // 唤醒
            }
        }
    }

    // future poll
    fn poll(ctx: *Context) Result {
        const timer: *Timer = @ptrCast(@alignCast(ctx.payload));
        if (timer.completed) {
            std.debug.print("poll timer is completed\n", .{});
            return .{ .done = null };
        } else {
            timer.waker = ctx.waker;
            return .wait;
        }
    }
};

Sleep

这部分把 Timer 包装成 Future

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

fn sleep(nanoseconds: u64) void {
    std.debug.print("sleep comes in\n", .{});
    if (!sys_is_block) {
        const timer_ptr = global_runtime.allocator.create(Timer) catch unreachable;
        timer_ptr.* = Timer.init(nanoseconds) catch unreachable;

        const callback = EventCallback{
            .callback_fn = Timer.timerCompletedCallback,
            .user_data = timer_ptr,
        };
        timer_ptr.handle.setCallback(callback) catch unreachable;

        const timer_fut = future.runWithAllocator(global_runtime.allocator, Timer.poll, timer_ptr).chain(struct {
            fn thenFn(_: ?*anyopaque, ctx: *Context) *Future {
                const timer = @as(*Timer, @ptrCast(@alignCast(ctx.payload)));
                ctx.allocator.destroy(timer);
                return future.done(null);
            }
        }.thenFn);

        global_runtime.executor.schedule(timer_fut);

        global_runtime.switchTaskToBase(); // 类似 suspend - 这个地方实现还有点歧义
        // global_runtime.switchToExecutor(); // 如果需要等待返回结果则需要切换到 executor 等待其 resume 回来
    } else {
        std.Thread.sleep(nanoseconds);
    }
}

fn delay() void {
    std.debug.print("delay comes in\n", .{});
    sleep(5 * std.time.ns_per_s);
}

main

整合完毕后对于使用者来说，代码如下：

1
2
3

xasync(delay);
// xawait(); // 需要等待的时候开启
std.debug.print("hello xasync\n", .{});

运行效果

不等待完成

1
2
3
4
5
6
7

delay comes in
sleep comes in
hello xasync                - 注意这里，没有等待 timer 异步执行结束，而是直接返回
timer callback completed!
poll timer is completed     - 注意这里，timer 结束了
main will quit
event loop quit

等待完成

1
2
3
4
5
6
7

delay comes in
sleep comes in
timer callback completed!
poll timer is completed
hello xasync                - 注意这里，虽然底层是异步协程执行，但是这里等待 timer 执行完毕才打印
main will quit
event loop quit

总结

从目前执行效果和 API 的调用方式看符合预期，基本达成了本期的目标：实现简单的异步协程运行时 (zig)，按照这种方式解决函数着色问题是有希望的。

虽然本期目标基本达成，但是中间学习的过程中还是有很多技术细节没有完全搞懂，有些学习资料没有完全看完，后续还要继续努力。

后续规划

• 参数和返回值的类型支持且能自动推导
• 支持线程池 thread pool
• eventloop 完善
• 是否后台调度支持用户配置 - 现在需要改代码来实现
• 支持 rust 调用
• 封装 asyncio
• 集成到 arceos/rcore 中
• 性能对比测试

答疑和思考

为什么要用 zig 写

• 没有任何原因，个人偏好，peace & love.

实现代码在哪里

• xasync1

中断驱动的协程异步网络 - 在ArceOS中实现

一、背景

时间过的飞快，转眼间，训练营四阶段已经迎来尾声。
我由于去年已经参加过一届训练营，所以本次我提前一个月晋级到了四阶段，与向勇老师确定了我的课题方向：“中断驱动的协程异步网络”。
在后续周会的沟通中，向老师也给了我更具挑战性的目标：“在VisionFive2开发板上验证我的工作”。

二、历程

在四阶段，我主要完成了以下几个里程碑：

Rust异步运行时

因为我之前曾经在工作中编写过面向 WASM 平台的 Rust 异步运行时，所以第一个里程碑并没有花掉我太多时间。
为了给自己增加一些挑战，我还额外实现了常见的异步运行时辅助数据结构与函数，如：mutex，spawn, block_on, join 等。

异步版本的网络操作

在完成 Rust 异步运行时后，我便开始着手实现异步版本的网络API。
我为所有网络操作中包含block_on的函数都编写了异步版本，并实现了网络操作的异步化。其中包括:

• socket.recv_async()
• socket.send_async()
• socket.accept_async()
• socket.connect_async()

PLIC中断驱动的Future唤醒

实现以上异步网络操作后，网络异步仍然是以Poll驱动的，而不是以真实的物理世界事件驱动的。
为了实现真正的异步网络，我需要实现一个中断驱动的Future唤醒机制。
在 RISC-V 架构中，PLIC 是中断控制器，可以用于实现中断驱动的Future唤醒机制。
我为 ArceOS 移植了 PLIC 驱动，并实现了 VirtIO-Net 设备的 PLIC 中断驱动的 Future 唤醒机制。

将ArceOS移植到VisionFive2开发板

在完成以上工作后，距离训练营结束仍然有一个半月的时间。这次组会中，向老师给了我一个更具挑战性的目标：将 ArceOS 移植到 VisionFive2 开发板，并在 VisionFive2 开发板上验证我的工作。我也就正式开始了移植工作。
开发板板载了 u-boot 和 OpenSBI v1.2，我可以直接从 u-boot 启动 ArceOS。
幸好我手中还有 jTag 调试器，向老师也给我提供了其他前辈同学的移植经验。
感谢萧络元同学的代码仓库，我很快便完成了 ArceOS 的移植。
VF2 开发版与常见 RISC-V 开发版有些许不同，例如：
* S 态可用内存起点为 0x4000_0000 而不是 0x8000_0000
* OpenSBI v1.2 支持 SBI v1.0 规范，但未实现 Console Extension。所以日志打印时需要使用 Legacy Console API。
以及 u-boot 启动与 Qemu 启动也有些差异，现代镜像打包时更多采用 itb 格式，同时将 dtb 打包进 itb 中。
总的来说，移植工作并不算太难，但是当系统无法加载又没有任何日志输出的时候，还是需要些裸机的调试手段，例如直接通过汇编调用串口打印，或者 sbi call 字符打印来确定程序执行到了哪里，是否进入内核代码。

为VisionFile2启用中断驱动的异步网络

在完成 ArceOS 的移植后，我便开始着手为 VisionFive2 开发板编写网卡驱动，启用中断功能，复现我在 Qemu 中完成的功能。这是本次训练营中我遇到的最大挑战。
首先，启动真实的网卡设备异常复杂，需要按顺序依次启动不下10个时钟信号与复位信号。
然后，VF2 平台使用的网络设备为 dwmac-5.2，参考 Linux 内核中驱动实现时，其历史悠久，代码量庞大，支持功能多且复杂，兼容设备多，还需要兼容多个平台和历史版本，硬啃 Linux 内核驱动代码基本上不太现实。
在必要时候还需要配合 PHY 芯片的同步配置，与设备寄存器交互通过 MMIO 映射，而与 PHY 芯片交互则需要通过 MDIO 总线，Clause 22/45 协议。

同时还需要学习众多的 MMIO 寄存器偏移量，与每个 bit 对应的功能含义，了解 GMAC/DMA/MTL/PHY 相关寄存器。
也学习了 ring buffer 的实现，以及如何使用 ring buffer 实现网络数据收发。

最终我还是没能在 VF2 平台开启中断功能，根据与厂家工程师的交流，PHY 芯片中断引脚并未接入 PLIC 中断控制器，所以无法使用 PLIC 中断驱动网络功能。

遗憾未能亲眼见到自己的工作在真实硬件上运行，但是通过本阶段的学习，我还是学到了海量的知识。

三、总结

通过本次训练营，我弥补了我知识体系中的许多空白，包括：

• PLIC 中断控制器
• 网卡驱动
• U-Boot 运作原理
• 真实硬件是如何运作的

四、致谢

感谢向勇、陈渝老师，以及所有帮助过我的老师和同学。

2025 春夏季开源操作系统训练营 学习总结

1
2
3
4
5

// 实验环境
Mac mini Apple M4
MacOS 15.4.1
// 备注（在国外的同学可以忽略）
在配置实验环境时，一定要更换Homebrew、rustup和Cargo的镜像源。

第一阶段：Rust编程

由于参与过 http://opencamp.cn/ 的其他 Rust 训练营，本阶段相当于是复习阶段。然而笔者对很多 Rust 语法还是理解的不够，需要通过更多实际项目来加深学习。

第二阶段：OS设计实现

本阶段主要参考指导书完成实验 https://learningos.cn/rCore-Tutorial-Guide-2025S/

1. Apple Silicon 相关问题

在第零章，指导书如是说：
经初步测试，使用 M1 芯片的 macOS 也可以运行本实验的框架，即我们的实验对平台的要求不是很高。但我们仍建议同学配置 Ubuntu 环境，以避免未知的环境问题。

笔者在实验中确实遇到了一些问题，但都并非无法解决，具体情况如下：

1.1 安装 qemu (可能需要 sudo)

1
2

brew install qemu
qemu-img --version

如果显示qemu-img version 9.2.3则说明安装成功。

1.2 载入rustsbi-qemu.bin时卡死

@lurenjia1213 修复了该问题，需要 Clone 下面的项目，重新编译，然后拷贝生成的rustsbi-qemu.bin 并覆盖实验项目中的文件。
https://github.com/lurenjia1213/rustsbi-qemu/tree/main

1.3 qemu 模拟器无法正确退出

在ch3中，qemu模拟器无法正确退出，需要拷贝ch2中的./src/boards/qemu.rs到ch3。通过对比ch2和ch3的区别来修复问题，从而可以学习正确退出模拟器的方法。

ch4 通过同样的方法在 BASE=1 的测试中还是无法正确退出，需要以后解决。

1.4 MacOS 没有 timeout 指令导致测例无法通过

安装 coreutils, 用 gtimeout 来替代。

1
2
3

brew install coreutils
// 需要将下面这条指令写到保存环境变量的那个文件中
alias timeout=gtimeout

2. 学习心得

由于没有系统学习过操作系统的理论知识，学的比较慢，需要参考指导书和学习资源中的视频才慢慢掌握。虽然操作系统相关的内容学的不够扎实，但是对于 rust 的语法慢慢熟悉了起来。抱着学习 rust 的心态还学习到了操作系统的底层运行，很有收获。

第三阶段：项目基础阶段 - 组件化操作系统

• 尽管是第一次接触操作系统，在完成第二阶段以后，第三阶段给笔者的感觉不是很陌生（至少知道大概都在干什么）
• 课程视频和课件也很详细的给出了任务和学习目标，但是第三阶段的项目相比第二阶段要大很多
• 有时候不知道要去哪里干什么，只能通过给出的题目反向查找相关的内容。

1.遇到的问题和解决思路

• 在UniKernel部分， 笔者在 MacOS 下面完成了任务，到了宏内核的部分涉及到了交叉编译的部分，似乎 MacOS 变得复杂了起来。折腾了一段时间之后，还是在一台 Linux 服务器上用 docker 完成了后续的任务。
• 这是笔者第一次使用 docker，遇到不懂的就让 Chatgpt 来生成指令，但是还是遇到了很多问题：
  1. hub.docker.com 被墙，根本创建不了 Linux 容器， 后来找到 nvcr.io/nvidia/pytorch:25.05-py3 解决了问题： https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch
  2. 以为 root 之后就万事大吉，但是在运行容器的时候要加上 --privieged， 不然 mount 指令无法正确的找到目录的位置
  3. 运行容器的时候千万不要加 -rm， 不然停止容器的时候就永远地消失了

     2. 学习心得

     由于上述笔者遇到的问题，反反复复搭环境搭了 3 次， 对各种 Linux 指令，以及各种组件的作用有了更深的理解。相比第二阶段，第三阶段的练习难度反而有所下降，但是 ArceOS 本身的内容是相当多的，需要更加系统的学习。 希望能在第四阶段有所收获。

rust基础的总结

一.基本数据类型与所有权

所有权系统核心规则

1. 移动语义(Move)：

   1 2 3

   let s1 = String::from("hello"); // 堆分配 let s2 = s1; // 所有权转移 // println!("{}", s1); // 错误！s1 已失效

2. 借用规则：
   • 任意时刻：一个可变引用 或 多个不可变引用
   • 引用必须始终有效（悬垂指针禁止）
3. 生命周期标注：

   1 2 3

   fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }

Slice 类型

• 无所有权引用：

  1 2 3 4

  let s = String::from("hello world"); let hello: &str = &s[0..5]; // 字符串切片 let a = [1, 2, 3, 4]; let slice: &[i32] = &a[1..3]; // 数组切片

二.Crate 与模块系统

Crate 类型

模块可见性规则

1
2
3
4
5
6
7
8

mod front_of_house {
    pub mod hosting {          // pub 使模块公有
        pub fn add_to_waitlist() {}
    }
}

// 使用绝对路径访问
crate::front_of_house::hosting::add_to_waitlist();

使用外部 Crate

1
2
3

# Cargo.toml
[dependencies]
rand = "0.8.5"  # 语义化版本

1
2
3
4
5
6

// main.rs
use rand::Rng;

fn main() {
    let num = rand::thread_rng().gen_range(1..101);
}

三. Option 与错误处理

Option 枚举

1
2
3
4
5
6
7
8
9
10
11

enum Option<T> {
    Some(T),
    None,
}

// 安全解包
let x: Option<i32> = Some(5);
match x {
    Some(i) => println!("Value: {}", i),
    None => println!("Missing value"),
}

Result<T, E> 错误处理

1
2
3
4
5
6
7
8
9
10
11

fn read_file(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)
}

// 错误传播简写
fn read_config() -> Result<String, io::Error> {
    let mut file = File::open("config.toml")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

错误处理最佳实践

1. 优先使用 Result 而非 panic
2. 使用 ? 操作符传播错误
3. 自定义错误类型实现 std::error::Error

四. Trait 与泛型

Trait 定义与实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14

trait Summary {
    fn summarize(&self) -> String;
}

struct NewsArticle {
    headline: String,
    location: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{} ({})", self.headline, self.location)
    }
}

泛型函数

1
2
3
4
5
6
7
8
9

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

Trait Bound 语法糖

1
2
3

// 以下两种写法等价
fn notify<T: Display + Clone>(item: &T) {...}
fn notify(item: &(impl Display + Clone)) {...}

生命周期进阶

生命周期标注必要性：

1. 结构体持有引用时必须显式标注生命周期，确保引用的有效性
2. 方法实现中：
   • &self 参数隐含 &'a self 生命周期
   • 返回值关联结构体生命周期（通过生命周期消除规则第三项）
3. 遵循Rust生命周期消除三规则：
   • 每个输入引用自动获得独立生命周期
   • 单个输入引用时所有输出引用与其生命周期对齐
   • 方法签名中 &self 使输出引用与结构体生命周期对齐

错误：

1
2
3
4

fn dangling_reference() -> &str {
    let s = String::from("temporary");
    &s[..]  // 错误！返回局部变量引用
} // s离开作用域被丢弃

1
2
3
4
5
6
7
8
9
10

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part
    }
}

五. 智能指针

常用智能指针对比

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Box 用于递归类型
enum List {
    Cons(i32, Box<List>),
    Nil,
}

// Rc 共享所有权
use std::rc::Rc;
let a = Rc::new(5);
let b = Rc::clone(&a);

// RefCell 运行时借用检查
use std::cell::RefCell;
let c = RefCell::new(42);
*c.borrow_mut() += 10;

六.迭代器与闭包

闭包类型推断

1
2

let add_one = |x| x + 1;         // 类型自动推导
let print = || println!("hello"); // 无参闭包

闭包捕获模式

迭代器适配器

1
2
3
4
5
6
7

let v = vec![1, 2, 3, 4];

// 链式调用
let sum: i32 = v.iter()
    .map(|x| x * 2)        // 加倍
    .filter(|x| x % 4 == 0) // 过滤4的倍数
    .sum();                 // 求和

自定义迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

struct Counter {
    count: u32,
}

impl Iterator for Counter {
    type Item = u32;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

七.并发与异步编程

线程创建

1
2
3
4
5
6
7

use std::thread;

let handle = thread::spawn(|| {
    println!("From spawned thread");
});

handle.join().unwrap();

通道通信 (mpsc)

1
2
3
4
5
6
7
8
9

use std::sync::mpsc;

let (tx, rx) = mpsc::channel();

thread::spawn(move || {
    tx.send("Message").unwrap();
});

println!("Received: {}", rx.recv().unwrap());

共享状态 (Mutex)

1
2
3
4
5
6
7
8
9
10
11

use std::sync::{Arc, Mutex};

let counter = Arc::new(Mutex::new(0));

let handles: Vec<_> = (0..10).map(|_| {
    let c = Arc::clone(&counter);
    thread::spawn(move || {
        let mut num = c.lock().unwrap();
        *num += 1;
    })
}).collect();

异步编程 (async/await)

1
2
3
4
5
6
7
8
9
10
11
12

async fn fetch_data() -> Result<String, reqwest::Error> {
    reqwest::get("https://api.example.com/data")
        .await?
        .text()
        .await
}

#[tokio::main]
async fn main() {
    let data = fetch_data().await.unwrap();
    println!("Data: {}", data);
}

八.常用集合类型

Vec 动态数组

1
2
3
4
5
6
7
8
9
10
11

let mut v = Vec::with_capacity(10);
v.extend([1, 2, 3]);

// 安全访问
if let Some(val) = v.get(1) {
    println!("Second element: {}", val);
}

// 所有权注意事项
let first = &v[0];
// v.push(4); // 编译错误！存在不可变引用时禁止修改

HashMap<K, V> 哈希表

1
2
3
4
5
6
7
8

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert("Blue", 10);

// Entry API 安全更新
scores.entry("Yellow").or_insert(50);
scores.entry("Blue").and_modify(|e| *e += 1);

阶段二,os基础

lab1

与上下文, 特权级有关的寄存器

• sstatus：包含了处理器的状态信息，包括特权级别和中断使能状态。恢复 sstatus 的值确保在返回用户态时，处理器的特权级别和中断状态与陷阱发生前一致。
• sepc：保存了中断或异常发生时的程序计数器值。恢复 sepc 的值确保在返回用户态时，处理器能够从中断或异常发生的地方继续执行。
• sscratch：保存了用户栈指针。在切换到用户态之前，将用户栈指针保存到 sscratch 寄存器中，以便在用户态下使用。
• sret根据sstatus中的SPP位指示切换为用户态。（寄存器中的一个位，0,u_mode;1_,s_mode,s_mode）
• scause: Trap原因/种类
• stvec: trap_handle地址

lab2

SV39

• virtual page 39位, 38-12为虚拟页号
• 页表项PTE: Reserver: 10, PPN2: 26, PPN1: 9, PPN0: 9, RSW: 2, DAGUXWRV

分页

• MMU地址转换
• kernel address space最高位为 “跳板”, app ks, guard page
• app address space, 最高位为跳板, TrapContext, UserStack, GP, Framed

  跳板意义:

  satp, 切换后,地址映射不同, 例如:上下文切换的restore, 在更改satp指令后, 保证下一条指令在不同的地址映射下能被正确寻址,保证指令的连续执行

TrapContext新增字段

在进行特权级转换时, 需要相应的sp以及satp的token

• pub kernel_satp: usize, 内核地址空间的 token
• pub kernel_sp: usize, 当前应用在内核地址空间中的内核栈栈顶的虚拟地址
• pub trap_handler: usize, 内核中 trap handler 入口点的虚拟地址

lab3

fork

• 获得父进程的地址空间
• sepc + 4
• a0返回参数更改,父子进程不相同
• 维护父子进程关系
• fd, 死锁检测等

功能实现

• stride算法:

  • 为TCB加上schedule块(struct), 同时预留了pass设置的接口
  • 为sys_set_priority加入了对priority的设置
  • 将TaskManager块改为了用binaryheap存储, 并为TCB分配了Ord特性,每次选取都会取stride最小的调度

• 向前兼容

  • 重写mmap和munmap(用到了remove_area_with_start_vpn)
  • 重写了sys_get_time,用到了translate_va

lab4

文件系统

文件系统本质上是一堆块上的抽象, 在内存中有缓存块对其进行映射.

进程维护一个文件描述符表,可映射到对应的缓存块

1
2
3
4
5
6
7
8

pub struct BlockCache {
    cache: [u8; BLOCK_SZ],
    block_id: usize,
    block_device: Arc<dyn BlockDevice>,
    modified: bool,
}

//提供对应的接口调用

easy-fs磁盘布局

• 超级块 (Super Block)，用于定位其他连续区域的位置，检查文件系统合法性。

• 索引节点位图，长度为若干个块。它记录了索引节点区域中有哪些索引节点已经被分配出去使用了。

• 索引节点区域，长度为若干个块。其中的每个块都存储了若干个索引节点。

  1 2 3 4 5 6 7 8

  #[repr(C)] pub struct DiskInode { pub size: u32, pub direct: [u32; INODE_DIRECT_COUNT], pub indirect1: u32, pub indirect2: u32, type_: DiskInodeType, }

• 数据块位图，长度为若干个块。它记录了后面的数据块区域中有哪些已经被分配出去使用了。

• 数据块区域，其中的每个被分配出去的块保存了文件或目录的具体内容。

lab5

在引入线程后, 调度机制本质上是在线程块上进行切换. 会区分主线程和子线程

• 创建线程不需要要建立新的地址空间
• 能够访问到进程所拥有的代码段， 堆和其他数据段
• 专有的用户态栈

实现功能

• 在ProcessControlBlockInner加入了对mutex和sem的死锁检查块(all[], ava[], need[])
• 检测前对相应资源的need[] + 1
• 实现is_safe检测函数, 对finish==false和need <= work的块, 回收allocation和finish=true,对标记flag=true, 当finish没有任何改变, 即本次循环flag==false时退出loop, 利用闭包all,检测finish所有线程是否全是true
• 若为unsafe, 则回退need, 返回-0xdead
• 若为safe, 则在down和lock之前drop(process_inner),防止线程堵塞无法释放资源, 在down和lock之后同时更新检查块中的矩阵
• 为up和unlock加上检查块的更新

Mutex实现问题

• Mutex1的lock里,会一直尝试获取锁, 具体逻辑为当无法获得锁时,直接阻塞,让出cpu,直到被唤醒, 再重新尝试获得锁, unlock中释放锁,并且唤醒一个线程去竞争这个锁.
• Mutex的lock,在无法获得锁时,直接堵塞,在unlock时,只有等待队列为空才释放锁.

  - 这里的unlock本质是锁资源的转移, A不释放锁, 而是唤醒一个直接使用这个资源的B线程(它醒来后直接运行临界区后的代码)

第三阶段

一, 组件化内核基础与 Unikernel 模式

组件化内核介绍

Unikernel 模式

• 特点：
  • 应用与内核合一：编译为一个 Image，共享同一特权级（内核态）和地址空间。
  • 无用户态 / 内核态切换：简单高效，但安全性较低（应用可直接访问内核资源）。

核心组件

Unikernel 的启动链

• 硬件启动：通过 OpenSBI（Riscv 固件）加载内核 Image 到内存。
• 引导阶段（axhal）：
  • 初始化 CPU 寄存器、MMU 分页（早期恒等映射）。
  • 建立内核栈，为 Rust 运行时做准备。
• 运行时阶段（axruntime）：
  • 初始化内存分配器、日志系统。
  • 调用应用层 main 函数，执行具体功能。

实验

1. 主函数 src/main.rs

1
2
3
4
5
6
7
8

#![cfg_attr(feature = "axstd", no_main)] // 若启用 axstd，不使用标准库的 main 入口
#[cfg(feature = "axstd")] // 根据 feature 条件编译
use axstd::println; // 使用 axstd 的打印函数

#[cfg_attr(feature = "axstd", no_mangle)] // 避免符号名被修改
fn main() {
    println!("Hello, ArceOS!"); // 调用 axhal 提供的串口输出功能
}

2. 依赖管理 Cargo.toml

1
2
3

[dependencies]
axstd = { workspace = true } // 引入 axstd 组件，支持标准库功能
arceos_api = { workspace = true } // 引入内核公共接口

3. features 动态配置

• 作用：通过编译参数控制组件的启用，实现 “按需构建”。
• 示例：
  • axstd 组件通过 feature = “axstd” 控制是否包含。
  • 实验中默认启用 axstd，因此能使用 println!。

println!

通过更改ulib下axstd,macros文件中的println!

hashmap

1
2

#[cfg(feature = "alloc")]
pub mod collections;

暴露自己写的collections

1
2
3

[dependencies.hashbrown]
version = "0.14"
default-features = false

用了官方库的core版本

二, 内存管理与多任务基础

1. 分页的两个阶段

2. 算法

3.

全局分配器：通过 #[global_allocator] 声明，实现 GlobalAlloc trait。

1
2

#[cfg_attr(all(target_os = "none", not(test)), global_allocator)]
static GLOBAL_ALLOCATOR: GlobalAllocator = GlobalAllocator::new();

任务数据结构 TaskInner

1
2
3
4
5
6
7
8

struct TaskInner {
    id: TaskId,           // 唯一标识
    name: String,         // 任务名称（调试用）
    state: AtomicU8,      // 状态（Running/Ready/Blocked/Exited）
    kstack: Option<TaskStack>, // 任务栈（类似线程栈）
    ctx: UnsafeCell<TaskContext>, // 上下文（保存寄存器状态）
    // 其他字段：调度相关（如时间片、优先级）
}

协作式调度

FIFO 队列：任务按 “先到先服务” 原则执行，当前任务需主动让出 CPU（调用 yield_now()）。

组件

实现

EarlyAllocator实现要求比较低

byte

• alloc
  • 注意每次分配内存时候的对齐
  • 预分配，检查是否与p_pos重叠
  • 为count++
    • 注意每次分配内存时候的对齐
    • 预分配,检查是否与p_pos重叠
    • 为count++
• dealloc
  • 单纯的count–
  • count==0时,就可以重置b_pos了

page

• alloc
  • 检查alignment是否有效
  • 获取分配的size进行对齐，同时检查是否越界
  • 更新数据
    • 检查alignment是否有效
    • 获取分配的size进行对齐,同时检查是否越界
    • 更新数据
• dealloc
  • 不要求实现

三、调度,块设备,文件系统

时钟中断：

代码（Riscv64 中断初始化）

1
2
3
4
5
6

// axhal/src/platform/riscv64_qemu_virt/mod.rs
axhal::irq::register_handler(TIMER_IRQ_NUM, || {
    update_timer(); // 更新系统时间
    axtask::on_timer_tick(); // 触发调度器更新
});
axhal::arch::enable_irqs(); // 开中断

块设备驱动：

Trait：BlockDriverOps

1
2
3
4
5

trait BlockDriverOps {
    fn num_blocks(&self) -> u64; // 磁盘总块数
    fn block_size(&self) -> usize; // 块大小（512 字节）
    fn read_block(&mut self, block_id: u64, buf: &mut [u8]) -> DevResult; // 读块
}

文件系统：

抽象

文件系统（FileSystem）：如 FAT32、EXT4。

目录（Dir）：存储文件 / 子目录元数据。

文件（File）：存储具体数据，支持读写操作。

接口

1
2
3
4

trait VfsOps {
    fn root_dir(&self) -> &DirNode; // 获取根目录
    fn lookup(&self, path: &str) -> Option<FileNode>; // 解析路径
}

加载流程

块设备读取：通过 VirtIO Blk 驱动读取磁盘前 512 字节（引导扇区）。

解析 BPB：获取 FAT 表起始地址、簇大小等参数。

挂载文件系统：将 FAT32 的根目录挂载到 VFS 的 / 节点。

应用加载示例（U.8 实验）

1
2
3
4
5
6

// 从 FAT32 文件系统加载应用程序
fn load_app(path: &str) -> Result<Vec<u8>> {
    let root = vfs.root_dir();
    let file = root.lookup(path).ok_or("文件不存在")?;
    file.read_to_end() // 读取文件内容到内存
}

实验实现

寻找ing

在axfs_ramf中实现

1

impl VfsNodeOps for DirNode{...}

文件时通过封装的BTreeMap管理的, 替换相应键值对即可

注意

1

fn rename(&self, src_path: &str, dst_path: &str)

src和dst_path路径层级不一样
我使用了split_path_to_end来获取最终的文件名

四, 地址空间管理

缺页异常处理

1
2

// 关键修改：init_user_stack的lazy参数设为false
let ustack_top = init_user_stack(&mut uspace, false).unwrap(); // 延迟映射

缺页异常处理流程

• 异常触发：用户态访问未映射地址（如栈写入），CPU 陷入内核。
• 处理逻辑：
  1. 通过handle_page_fault函数申请物理页帧（alloc_frame）
  2. 在页表中建立虚拟地址与物理页帧的映射（pt.remap）

1
2
3
4
5

fn handle_page_fault(...) -> bool {
    let frame = alloc_frame(true); // 申请物理页
    pt.remap(vaddr, frame, orig_flags); // 建立映射
    tlb.flush(); // 刷新TLB
}

ELF 格式解析

关键段：
LOAD 段：包含代码段（R E标志）和数据段（RW标志）。
BSS 段：未初始化数据，ELF 文件不存储，内核需预留空间并清零。
加载逻辑：

1
2
3
4
5
6
7
8
9
10
11
12

for segment in elf.segments {
    if segment.type == LOAD {
        let vaddr = segment.virt_addr;
        let phys_frame = alloc_frame(segment.mem_siz);
        map_virtual_to_physical(vaddr, phys_frame, segment.flags);
        if segment.has_data {
            copy_file_data(vaddr, segment.file_offset, segment.file_siz);
        } else {
            zero_memory(vaddr, segment.mem_siz); // BSS段清零
        }
    }
}

实验实现

得到aspace->分配内存->将文件信息写入

1
2
3
4
5
6

const MAP_SHARED = 1 << 0;    // 共享映射，对映射区域的修改会反映到文件中
const MAP_PRIVATE = 1 << 1;   // 私有映射，对映射区域的修改不会反映到文件中
const MAP_FIXED = 1 << 4;     // 必须使用指定的映射地址
const MAP_ANONYMOUS = 1 << 5; // 匿名映射，不与文件关联
const MAP_NORESERVE = 1 << 14; // 不保留交换空间
const MAP_STACK = 0x20000;    // 用于栈分配

这里只处理MAP_PRIVATE,
同时addr.is_null(),可通过aspace.find_free_area寻找内存

五, Hypervisor

Hypervisor

1.1 定义

Hypervisor（虚拟机监控器）是运行在物理硬件与虚拟机之间的虚拟化层软件，允许多个虚拟机共享物理资源，每个虚拟机拥有独立的虚拟硬件环境（如vCPU、vMem、vDevice）。

1.2 核心功能

• 资源虚拟化：模拟CPU、内存、设备等硬件资源
• 隔离与调度：确保虚拟机之间资源隔离，并高效调度物理资源
• 模式切换：在Host（Hypervisor）与Guest（虚拟机）之间双向切换

1.3 与模拟器的区别

1.4 虚拟化类型

1. I型Hypervisor：直接运行在硬件上（如Xen、KVM），性能高
2. II型Hypervisor：运行在宿主OS上（如VirtualBox），依赖宿主资源管理

二. Riscv64虚拟化扩展（H扩展）

2.1 特权级扩展

新增特权级：

• HS(Hypervisor Supervisor)：Host域的管理级，负责虚拟化控制
• VS(Virtual Supervisor)：Guest域的内核级，运行Guest OS内核
• VU(Virtual User)：Guest域的用户级，运行Guest应用

特权级关系：

1
2

物理机：M（最高） > HS > U
虚拟机：VS（Guest内核） > VU（Guest用户）

2.2 关键寄存器

• hstatus：控制Host与Guest的模式切换
  • SPV位：指示进入HS前的模式（0：非虚拟化模式；1：来自Guest的VS模式）
  • SPVP位：控制HS是否有权限操作Guest的地址空间
• vs[xxx]/hs[xxx]：分别用于Guest和Host的上下文管理
• misa：标识是否支持H扩展（bit7=1表示支持）

3. 模式切换机制

3.1 从Host到Guest（run_guest函数）

1
2
3
4
5
6

// 保存Host寄存器状态
sd ra, (hyp_ra)(a0)  // 保存返回地址
// 加载Guest寄存器状态
ld sstatus, guest_sstatus(a0)
// 执行sret指令切换到VS模式
sret

可参考guest.s

• a0指向的guest_reg区域 与 当前reg的替换

  3.2 VM-Exit处理（以SBI调用为例）

  1 2 3 4 5 6 7 8 9

  match scause.cause() { Trap::Exception(Exception::VirtualSupervisorEnvCall) => { let sbi_msg = SbiMessage::from_regs(ctx.guest_regs.gpr); if let Some(SbiMessage::Reset(Shutdown)) = sbi_msg { ax_println!("Shutdown vm normally!"); // 清理Guest资源 } } }

实现

根据结果硬编码,更改guest_reg的值

Stage 1

这个阶段主要是学习Rust语法，因为之前有报名过训练营，所以做起来比较顺手，把基础语法又复习了一遍。

Stage 2

这个阶段主要是阅读实验指导书和源码。实验指导书非常重要，如果没有看明白的话对做实验有很大影响，所以要细心耐心看。时间有限的话，看精简版指导书即可。
完成实验部分需要重点理解几个点：

1. 任务切换机制，保存切换前后程序上下文
2. 地址空间，多级页表机制
3. 文件系统，操作与管理

Stage 3

这个阶段主要是看视频和PPT，并通过做6个实验来熟悉ArceOS的设计思想。相对于上一个阶段的实验会简单一些。

总结

之前有报名过两次训练营，但都没有坚持下来。对于如何平衡学习、工作和自我提升之间的平衡，是一个我现在以及将来都需要仔细思考的问题。

Prologue

这样的总结应该从何开始？我是从Bilibili刷视频偶然了解到与训练营相关的信息的。使用Rust语言编写操作系统的实践，我太喜欢这个方向了。因为我正学过一点Rust，也经学校老师的推荐看过CSAPP并完成了大多数的实验。其中我最喜欢的便是shlab和attacklab────写一个shell！实在是有趣不过，如果再写一个操作系统呢？好吧，我应该没有与之匹配的实力，不过开源操作系统训练营就这样给了我一个类似的机会。报名人数破千！全程免费！还有什么好说的呢，杀😡。

Stage 1

110道Rustling编程题，并没有耗费我太多功夫，更多的是重新熟悉一下语法。我觉得，学习Rust不仅是学会如何使用一门编程语言，更是了解更多的编程范式。例如trait背后的组合大于继承；函数式编程对现代编程语言深刻的影响：默认不可变、闭包、HOFs、链式操作等；所有权与生命周期机制，这种RAII思想是C++首创的（但是opt-out）。Rust编译器就是你最好的老师，更别说还有满地走的各式AI（本总结经AI辅助完成），2025年的今天，学习Rust不应该再是一件难事🥳。

Stage 2

到了OS设计实现，主要是完成5道rCore操作系统大实验编程题。我是提前进入该阶段，所以全程并没有看过相关学习视频，而是跟随rCore-Tutorial-Guide文档完成的🤓。

这阶段最耗时的是lab2───地址空间和lab5───并发，这两个不管哪个太痛苦了😭。lab2是因为分页机制本身就相对复杂，层层抽象，读内核新增的代码就花了我很久时间（光论这一点文件系统其实不遑多让，不过到这里我的读代码能力已经得到显著锻炼了，所以带给我的痛苦远不及地址空间🥱）。而lab5，单纯是我因为技术路线的左右互博而无限拖缓了进度，我一直在对死锁检测资源的获取上究竟是现场构建还是跟随进程保存之间反复横跳。倒不如说，是因为我在实现这两个的时候遭遇多方掣肘，导致我不停怀疑我自己，不停的重构。使用Rust编程不就是戴着脚镣在跳舞吗？我现在水平还不够，只能写出不够优美的实现，但是我不会放弃的😡。

Stage 3

组件化操作系统，这大概是最各显神通的阶段了。我对这阶段的印象其实是一点草台味🤯，遇到各方面奇怪的问题，测试脚本死活不通过，各种不同的资料，到底要实现在哪里，我要怎么修改一个crate依赖的代码？我是个不撞南墙不愿意问别人的人，所以我全部都闭门造车自己解决了所有问题（真的吗？至少测例说我通过了）。但实际上，在讨论群里大家都很乐意回答别人的提问，每个人都有自己的“奇技淫巧”，应该让大家全都热烈讨论遇到的问题，才能让训练营变得更好😈。

Conclusion

写到这里我已经有点精疲力竭。我在参与前三个阶段的过程中收获颇多，不只是对整个组件化操作系统的认识。还有各种在学习过程中对工具的使用，helix、Zellij，这些工具，我很早就下载了，只是因为它是Rust重写的老工具。现在呢？我需要helix丰富的快捷键，我需要Zellij的分屏。我开始熟悉，正是我开始迈出一步，参加了这次，2025 春夏季开源操作系统训练营。

完成了三阶段的任务，我也疲惫了，进入了一种拖延的状态。五月二十二号，新建文件夹，想要完成这篇总结报告。一直到今天，我终于又想重新出发了。希望到了第四阶段，我可以找到新的方向。

编程的乐趣：⭐️⭐️⭐️⭐️
挑战的难度：⭐️⭐️⭐️
开源训练营：⭐️⭐️⭐️⭐️⭐️

RUST学习总结

函数：

• 函数名和变量名使用蛇形命名法(snake case)，例如 fn add_two() -> {}
• 函数的位置可以随便放，Rust 不关心我们在哪里定义了函数，只要有定义即可
• 每个函数参数都需要标注类型

所有权

基础类型：不会转移所有权，属于复制变量的值

复合类型：会转移所有权，相当于重新绑定变量

（深拷贝：复合类型变量名.clone()，不转移所有权）

引用

• 以&表示引用，以*表示解引用
• 可变引用首先要求变量可变，引用时也要写成&mut 变量名，否则是可变变量的不可变引用
• 一个变量的可变引用同时只能存在一个，可变与不可变引用不可同时存在
• “同时”指引用的作用域，为引用”从创建开始，一直持续到它最后一次使用的地方“

复合类型

字符串

切片：对string类型中某一部分的引用，即&变量名[开始……终止]，切片类型为&str

string与&str的转化：

&str化成string: String::from("字符串字面量")/"字符串字面量".to_string()

string化成&str: 取切片

操作字符串（针对于string）

• 追加：push(字符)/push_str(字符串字面量（不能是string类型）) 改变原有的字符串（不返回新值，必须mut可变）
• 插入：insert()/insert_str() 需要传入两个参数，第一个是插入位置索引，第二个是插入内容 改变原有字符串
• 替换：replace(被替换的字符串，新的字符串) 返回新的字符串（需要新变量接收）

1
2

let string_replace = String::from("I like rust. Learning rust is my favorite!");
let new_string_replace = string_replace.replace("rust", "RUST");

replacen(被替换的字符串，新的字符串，替换的个数) 返回新的字符串

replace_range(要替换的范围，新的字符串) 改变原有的字符串

• 删除：pop() 删除并返回最后一个字符 改变原有的字符串

  remove(字符起始索引) 删除并返回指定位置的字符 改变原有的字符串

  truncate(字符起始索引) 删除指定位置至结尾的所有字符 改变原有字符串

  clear() 清空字符串

• 连接：+/+= 相当于调用函数add(self, s:&str……) 第一个参数是string,其所有权会被转移，后面的参数需要&str类型 '+'返回新的字符串

  format!("{}", s) 用法与println!类似， 返回新的字符串

注：此处所有涉及索引的方法（包括切片），都是以字节为单位处理数据；对于UTF-8类型字符非常容易出错

结构体

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

1、// 定义字段
struct 结构体名称 {
    字段名称1： 类型 //结构体字段
}
gree
2、// 初始化：每个字段都要初始化，但顺序不一定一样
let 变量名 =  结构体名称 {
    字段名称1： 值 
}
let 变量名 =  结构体名称 {
    字段名称1： 值 
    ..另一个同类型变量2名的名称	//	剩余自动从另一变量中获取（该语句必须位于尾部）
    				//	同时变量2部分字段会发生所有权转移
}

3、// 访问字段
变量名.字段名	

4、// 元组结构体、单元结构体
let a : (i32, f64, u8) = (500, 6.4, 1); // (i32, f64, u8)是元组
struct Color(i32, i32, i32); // 元组结构体，适用于结构体有名称，字段没有的情况
struct AlwaysEqual; // 单元结构体，没有属性与字段

5、 // 结构体数据所有权：字段值最好不要基于引用，否则需要加上生命周期

6、 // 正常情况无法{}打印，需要在开头加上#[derive(Debug)]，使用{:?}或{:#?}来打印

枚举

枚举类型是一个类型，它会包含所有可能的枚举成员，而枚举值是该类型中的具体某个成员的实例

1
2
3
4
5
6
7
8

// 枚举变体携带数据
enum PokerCard {
    Clubs(u8),
    Spades(u8),
    Diamonds(char),
    Hearts(char),
} // 任何类型的数据都可以放入枚举成员中，包括另一个枚举或者结构体
let c1 = PokerCard::Spades(5);

数组

分为静态的array和动态数组vector，先看array

array可以正常使用下标访问，可以使用{:?}打印

1
2
3
4
5
6

let a = [1, 2, 3, 4, 5]; // 定义
let a: [i32; 5] = [1, 2, 3, 4, 5]; // 需要声明类型时
let a = [3; 5]; // 某个值重复出现
let arrays: [[u8; 3]; 4]  = [one, two, blank1, blank2]; // 二维数组

let slice: &[i32] = &a[1..3]; // 数组切片

流程控制

if: if语句块是表达式，可以有返回值

for

1
2
3
4
5
6
7
8
9
10
11
12

for 元素 in 集合/0..集合.len() { // 注意，此处集合需要使用引用，否则所有权会被转移（如需更改加上mut）
}

// 想要获取元素的索引
let a = [4, 3, 2, 1];
for (i, v) in a.iter().enumerate() {
    println!("第{}个元素是{}", i + 1, v); // .iter()方法把 `a` 数组变成一个迭代器
}

// 只在意循环次数
for _ in 0..10 {
}

continue与break依然存在

while

1

while 条件 {}

loop

无条件循环，必须搭配break

（break类似于return，可以单独使用也可以带回来一个返回值；

loop同样是表达式，可以返回一个值）

模式匹配

match和if let

match: 非常类似于switch(但匹配后只会执行当前分支，而不会往下”贯穿“)

match同样是表达式，可以有返回值

1
2
3
4
5
6
7
8
9
10

match target {
    模式1 => 表达式1, // =>代替了:
    模式2 | 模式3 => {	// X|Y
        语句1;
        语句2;
        表达式2 // 注意，语句同样可以返回()
    },
    _ => 表达式3 // _代替了default，必须穷尽所有情况否则会报错
    //或者 任意无关变量名 => 表达式3  // 此时就可以对该变量操作，不操作记得使用_开头
}

模式绑定（从匹配到的分支中取出绑定的值）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState), // 25美分硬币
}
match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state); // 可以取出绑定的具体state值
            25
        },
    }

if let: 适用于只需要判断一个模式是否匹配的情况,比if更适用于匹配

1
2
3
4

let some_value = Some(5);
if let Some(v) = some_value {
    println!("Value is: {}", v);
}

while let: while和let的总和，即如果满足条件就可循环，同样可以从模式匹配中拆出值

注：match/if let/while let都会转移被匹配值的借用值的所有权，需要使用ref抵消（ref只在左侧生效）

1
2
3

if let Some(ref x) = value
match opt {
    Some(ref s) => println!("Got a reference to string: {}", s),

Option<T>

表示一个值是否存在的枚举(Some<T>与T不是同一类型)

对于Some和None可以不加Option::前缀

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

enum Option<T> {
    Some(T),  // 表示有值
    None,     // 表示无值
}

//存储
let x: Option<i32> = Some(42);  // Some(42) 代表 x 里面存了 42
let y: Option<i32> = None;      // None 代表没有值

//解构
match x {
    Some(v) => println!("Value is: {}", v),  // 取出 v
    None => println!("No value"),
}
if let Some(v) = x {
    println!("Value is: {}", v);
}

方法

impl中存储方法与struct中声明字段分开，同时一个结构体可以有多个impl块

1
2
3
4
5
6
7
8
9
10

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
} // &self代替了self:&Self

注：

• self 表示 Rectangle 的所有权转移到该方法中，这种形式用的较少

  &self 表示该方法对 Rectangle 的不可变借用

  &mut self 表示可变借用

• 允许方法名和字段名相同

• 在调用方法时只有.没有->

• 枚举同样可以定义方法

关联函数

定义在结构体impl且没有self的函数

不能使用变量.函数()的方法调用，只能使用结构体名称::函数名(参数)来调用

比如String::from()

泛型

为了抽象不同的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fn 函数名<T>(变量名: T) -> T { // 函数泛型
struct Point<T> {
    x: T,
    y: T,
} // 结构体泛型，多个类型也可以声明如struct Point<T,U>
enum Result<T, E> {
    Ok(T),
    Err(E),
} // 枚举泛型，可以根据返回值的类型判断是否成功
struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> { 
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
} // 结构体泛型，impl处需要另外声明，impl中的方法可以拥有自己的泛型
  //对于结构体泛型，还可以为特定的泛型单独声明方法

• 在使用T前需要先声明<T>，T的名字可以随便取
• 有时在调用泛型函数时需使用函数名::<具体类型>()来显式指定T的类型

const泛型

允许常量值成为泛型变量，语法为const N: usize，表示const泛型N，它的值基于usize

1
2
3

struct Buffer<T, const N: usize> {
    data: [T; N], // N 作为数组大小
}

const fn: 在函数声明前加上const关键字

注：const泛型与const fn都需要在编译时确定，const fn就可以用于给const泛型赋值

特征

定义了一组可以被共享的行为，只要实现了特征，你就能使用这组行为（类似于接口）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

pub trait Summary {
    fn summarize(&self) -> String; // 只是一个抽象接口，而不具体实现
} // 定义特征

// 为每个需要的类单独实现特征
impl Summary for Post {
    fn summarize(&self) -> String {
        format!("文章{}, 作者是{}", self.title, self.author)
    }
}
impl Summary for Weibo {
    fn summarize(&self) -> String {
        format!("{}发表了微博{}", self.username, self.content)
    }
}

注：

• 孤儿规则：如果你想要为类型 A 实现特征 T，那么 A 或者 T 至少有一个是在当前作用域中定义的（另一个可以在其他库中引入）
• 默认实现：可以在特征中定义具有默认实现的方法，这样其它类型无需再实现该方法，或者也可以选择重载该方法（默认实现允许调用特征中其他方法，哪怕这个方法没有默认实现）

特征约束

特征作为函数参数：

1
2
3

pub fn notify(item: &impl Summary) { // 实现了Summary特征 的 item 参数
    println!("Breaking news! {}", item.summarize());
}

语法：

1
2
3
4
5
6

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}
// 对于结构体方法
impl<T: Display> ToString for T {
}

形如 T: Summary 被称为特征约束

多重约束:

1
2
3

// 要求同时实现了两个特征的参数
pub fn notify(item: &(impl Summary + Display)) {}
pub fn notify<T: Summary + Display>(item: &T) {}

where约束

1
2
3
4
5

fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {}
fn some_function<T, U>(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
{}

函数返回值：

通过 impl Trait 来说明一个函数返回了一个类型，该类型实现了某个特征

1

fn returns_summarizable() -> impl Summary { // 返回一个实现了Summary特征的类型

特征对象

允许你使用 不同类型 但 实现了相同特征 的对象，使它们可以在 同一个变量、参数或返回值 中使用

1
2
3
4
5
6

// 语法
&dyn 特征名 // 必须要使用指针，否则无法确定大小
Box<dyn 特征名> // 智能指针

// 动态数组
Vec<Box<dyn 特征名>>

集合类型

动态数组Vector

使用Vec<T>表示，只能存储相同类型的数据

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

// 创建数组
let v: Vec<i32> = Vec::new();
let mut v = Vec::new(); // 在添加元素后会自动推导
let mut v: Vec<i32> = Vec::with_capacity(5); // 预先分配空间

let v = vec![1, 2, 3]; // 宏vec!可以给予初始值
let v = vec![0; 3];   // 默认值为 0，初始长度为 3
let v_from = Vec::from([0, 0, 0]);

// 更新（需要为mut）
v.push(n); // 可变引用，不能与其他引用同时存在

// 访问元素
v[下标] //		越界不会检查
v.get(下标) // 返回Option<T>,需要match来解构出值		确保不会越界

// 遍历
for i in &(mut) v {}
    
// 常见方法
v.is_empty()
v.insert(pos, val) // 在指定索引pos处插入数值val
v.remove(pos) // 删除在pos处的数并返回该数
v.pop() // 删除尾部的数并返回(返回的是Option<T>的枚举值)
v.clear()
v.append(&mut v1) // v1所有数据全部转入v，v1被清空

// 排序
sort/sort_unstable() // 默认按照升序类型，且要元素可比较
sort_by/sort_unstable_by(闭包实现) // 可以自定义比较规则来实现多种类型的比较

注：可以通过使用枚举类型和特征对象来实现不同类型元素的存储

KV存储HashMap

需要使用use std::collections::HashMap;来引入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 创建与插入
let mut my_gems = HashMap::new();
my_gems.insert("红宝石", 1);

HashMap::with_capacity(capacity)

let teams_list = vec![
        ("中国队".to_string(), 100),
        ("美国队".to_string(), 10),
        ("日本队".to_string(), 50),
    ];
let teams_map: HashMap<_,_> = teams_list.into_iter().collect(); // 从动态数组转化为hashmap

// 在表中查询元素
let score: Option<&value类型> = 表名.get(key的引用); // 注意返回的是Option<T>类型

// 遍历
for (key, value) in &表名 {
    println!("{}: {}", key, value);
}

// 更新表中的值
let old = scores.insert("Blue", 20); // 会直接覆盖旧值，返回Some(旧值)/None
let v = scores.entry("Yellow").or_insert(5); // 查询Yellow对应的值，若不存在则插入新值；返回存储值的可变引用

注

HashMap 的所有权规则与其它 Rust 类型没有区别：

• 若类型实现 Copy 特征，该类型会被复制进 HashMap，因此无所谓所有权
• 若没实现 Copy 特征，所有权将被转移给 HashMap 中（使用引用要确保其生命周期足够长）

生命周期

变量的生命周期声明方式：

1
2

&'a i32     // 具有显式生命周期的引用
&'a mut i32 // 具有显式生命周期的可变引用

函数中的生命周期

需要标注生命周期的情况如下：

• 首先返回值必须是引用类型，可能会出现悬垂引用错误
• 存在多个参数时，如果编译器无法确定返回值需要跟随哪个参数的生命周期（哪怕这两个参数的生命周期是一样的），那么不标注就会报错
• 标注之后，编译时就会检查返回值使用会不会超出某个参数，如果发现超出就会报错（标注生命周期实际上不会更改任何返回值或者变量的真实生命周期，只是告诉编译器当返回值的生命周期不与较短的参数生命周期一致时，不予通过）

1
2
3
4
5
6
7
8
9
10

// 用'a显式表示生命周期，此处的'a表示两个参数中较短的生命周期，需要提前标注
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {

// 特殊情况：返回值永远只和一个参数有关/返回值与参数无关
fn longest<'a>(x: &'a str, y: &str) -> &'a str { // 只与一个有关就只标注一个
    x
}
fn longest(_x: &str, _y: &str) -> String { // 与新建变量有关尽量不返回引用
    String::from("really long string")
}

结构体中的生命周期

如果结构体的字段值类型为引用型，也需要标注生命周期'a（a可以任意替换）

作用是避免编译器报错、同时(提醒编译器)在编译时就检查其是否不超过原变量的生命周期

1
2
3

struct ImportantExcerpt<'a> {
    part: &'a str,
} // 只要在结构体每一个引用标注上生命周期即可，此处也需要提前声明<>

生命周期声明消除

为何在只有一个参数时可以不标注生命周期？

存在以下三个步骤可以省略生命周期声明（函数中参数的生命周期是输入生命周期，返回值为输出）：

1. 每一个引用参数都会获得独自的生命周期（所以不声明则多个参数有各自的生命周期声明）

   1	fn foo<'a, 'b>(x: &'a i32, y: &'b i32) // 所以不显式标出不知道跟随a还是b

2. 若只有一个输入生命周期（函数参数中只有一个引用类型），那么该生命周期会被赋给所有的输出生命周期，也就是所有返回值的生命周期都等于该输入生命周期

   1	fn foo<'a>(x: &'a i32) -> &'a i32 // 所以单个参数可以省略

3. 若存在多个输入生命周期，且其中一个是 &self 或 &mut self，则 &self 的生命周期被赋给所有的输出生命周期

方法中的生命周期

• 类似于泛型结构体
• 方法签名中一般不需要标注，因为有&self参数（根据以上第三条规则）

1
2
3
4
5
6
7
8
9

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

静态生命周期

拥有'static生命周期声明的引用生命周期是整个程序

1

let s: &'static str = "我没啥优点，就是活得久，嘿嘿";

属性

属性是一种元数据，用于修改编译器的行为、提供额外信息或影响代码生成方式

使用#[]语法

常见类型

#[derive()] 自动派生特征

用于让编译器自动为结构体或枚举实现特定的 trait（特征），如 Debug、Clone 等

注意只针对结构体与枚举，同时在实现某特征时（比如Copy）结构体中不能够有String这种无法自动实现Copy的字段

#[cfg(...)] 条件编译

用于根据特定 条件选择性地编译代码，例如目标平台：

1
2
3
4
5
6
7
8
9

#[cfg(target_os = "linux")]
fn platform_specific() {
    println!("Running on Linux!");
} // 只在linux上面编译

#[cfg(feature = "logging")]
fn log_message() {
    println!("Logging is enabled");
} // 启用了feature特征才能编译（feature特征是cargo.toml中定义的）

#[test] Rust 测试函数

用于标记测试函数，让 cargo test 自动运行它

错误处理

panic

• 标识不可恢复错误
• 有被动与主动触发两种情况

主动触发：使用panic!宏

1
2
3

fn main() {
    panic!("crash and burn");
} // 会打印出一个错误信息，展开报错点往前的函数调用堆栈，最后退出程序

Result

标识可恢复的错误

1
2
3
4

enum Result<T, E> {
    Ok(T),
    Err(E),
}

返回了该枚举类型之后就可以使用match来匹配解析

1
2
3
4
5
6
7
8
9
10

let f = match f {
       Ok(file) => file,
       Err(error) => match error.kind() {
           ErrorKind::NotFound => match File::create("hello.txt") {
               Ok(fc) => fc,
               Err(e) => panic!("Problem creating the file: {:?}", e),
           },
           other_error => panic!("Problem opening the file: {:?}", other_error),
       },
   }; // 一个打开文件的返回处理

如果不需要处理错误情况（即要么Ok()要么panic()，就使用unwrap()/expect）

1
2
3
4
5
6
7
8

let f = File::open("hello.txt").unwrap();
// 要么返回正确值要么直接panic

let f = File::open("hello.txt").expect("Failed to open hello.txt");
// 与unwrap()一样，只不过会报出里面的信息

// 改变错误类型：假设有f1(T)返回值T1类型，f2(F)返回值F2类型
let n: u8 = "1".parse().map(f1).map_err(f2) //原本返回T/F,现在返回T1/F1

传播错误

如果需要上级来处理这个函数中出现的错误呢？

返回Result<, >类型

• 使用match匹配，用分支来操作/返回
• 使用宏?

?功能类似于match

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// match写法
let f = File::open("hello.txt");
let mut f = match f {
    Ok(file) => file,
    Err(e) => return Err(e),
};
let mut s = String::new();
match f.read_to_string(&mut s) {
    Ok(_) => Ok(s),
    Err(e) => Err(e),
}

// ？写法：Err则该函数返回，Ok则语句返回正确值
let mut f = File::open("hello.txt")?;
let mut s = String::new();
f.read_to_string(&mut s)?;
Ok(s)
// ？同时可以进行类型提升，把所有的错误类型都提升为std::error::Error
// 此时就是返回Result<Ok值, Box<dyn std::error::Error>>

// ？可以链式调用
let mut s = String::new();
File::open("hello.txt")?.read_to_string(&mut s)?;
Ok(s)

注：

• ?操作符一定需要一个变量来承接正确的值
• 函数一定要是Result<, >返回值

Option与Result的转换

1
2
3

Option`转`Result`: 使用`.ok_or()`或`.ok_or_else()
// Option<T>	Result<T, E>
let res1: Result<T, E> = Option类型值.ok_or(E类型值);

1
2
3
4
5
6

Result`转`Option`: 丢弃错误使用`ok()`，丢弃成功值使用`.err()
// Option<T>	Result<T, E>
let opt1: Option<T> = Result类型值.ok();  

// Option<E>	Result<T, E>
let opt1: Option<E> = Result类型值.err(); // 如果Result类型值是ok()则丢弃

包与模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14

my_project/
├── Cargo.toml
└── src/
    ├── lib.rs         # library crate (名为 my_project)
    ├── main.rs        # binary crate (名为 my_project)
    └── bin/
        ├── tool1.rs   # binary crate (名为 tool1)
        └── tool2.rs   # binary crate (名为 tool2)
├── tests			   # 集成测试文件
│   └── some_integration_tests.rs
├── benches			   # 基准性能测试文件
│   └── simple_bench.rs
└── examples		   # 项目示例
    └── simple_example.rs

1

Package` => `Crate` => `mod

Package(包)

一个Package就是一个项目，包含一个或多个Crate（最多一个）

每个 Package 必须包含一个 Cargo.toml 文件来描述包的元信息和依赖

Crate(单元/箱)

• crate 是一个 Rust 项目或库的最小单元，即需要一起编译不可继续拆分
• 分为lib单元（入口文件一般为src/lib.rs；编译为库文件.rlib；不可单独执行，可以为其他项目提供依赖）和二进制单元（入口文件一般为src/main.rs或者在 src/bin/ 目录下；编译为可执行文件）
• 一个Package最多可以包含一个库单元和多个二进制单元，也可以只包含一个库单元/一个或几个二进制单元
• 对于二进制单元，src/main.rs是默认的crate，其他的crate都在src/bin/（或其他）目录下，且文件可以单独编译（一个文件就是一个crate）

考虑划分多个 crate 当：

1. 部分代码需要作为独立库被其他项目使用
2. 项目包含多个独立可执行工具
3. 某些功能需要单独编译和测试
4. 需要减少编译时间（修改一个 crate 不会导致其他 crate 重新编译）

Mod(模块)

使用模块只是为了更好地组织代码，同时控制它们的可见性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 定义语法
mod A {
	mod B {fn B1(){}} //可以嵌套
	mod C {fn C1(){}}
}

// 路径引用
fn D() {
    // 绝对路径
    crate::A::B::B1(); 
    //相对路径：只能以super/self/模块名或Crate开头
    A::B::B1(); // 在同一个Crate根部的相对路径可以直接这么写
}

// 可见性设置
pub mod hosting { // 模块写pub仅代表其可被访问，而其中的函数等还是对外界不可见
    pub fn add_to_waitlist() {} // 函数也需以pub开头
}

• 一个Crate是一棵模块树，而src/main.rs及src/lib.rs就是该树的根
• 模块A包含模块B，则A是B的父模块，B是A的子模块
• 模块中可以定义各种Rust类型，如函数、结构体、枚举、特征等
• 在同一个Crate根下的模块，相互引用的相对路径可以直接以对方模块名称开头；在同一父模块下的两个子模块，若在同文件中实现则也可以以对方模块名称开头，否则需要通过super::来使用父模块中转
• 将结构体设置为 pub，但它的所有字段依然是私有的；将枚举设置为 pub，它的所有字段也将对外可见
• 可以把模块实现放入对应等级的*.rs文件中，*要等同于模块名（文件中便不必再写），模块的定义/声明还是在父文件/模块中

use

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 基本引用方式：绝对或相对路径
use crate::front_of_house::hosting; // 引入模块
use front_of_house::hosting::add_to_waitlist; // 引入函数

// as别名
use std::fmt::Result;
use std::io::Result as IoResult;

// 引入再导出
pub use crate::front_of_house::hosting;

// 简化引入
use std::collections::{HashMap,BTreeMap,HashSet};
use std::{cmp::Ordering, io};

use std::io;
use std::io::Write;
use std::io::{self, Write};

use std::collections::*; // 引入模块下所有项

注：

• 如果引入的函数存在同名的情况时，需使用模块名::函数名的方式或者as别名的方式来区分

限制可见性

• pub 意味着可见性无任何限制
• pub(crate) 表示在当前包可见
• pub(self) 在当前模块可见
• pub(super) 在父模块可见
• pub(in <path>) 表示在某个路径代表的模块中可见，其中 path 必须是父模块或者祖先模块

函数式编程

简单来说，迭代器/高阶函数是“流水线模板”，提供规范流程（比如map\filter等等）；闭包是“可替换的工具”，即灵活调整传入的参数；而这两者都需要满足“不可变性”的安全要求

闭包

闭包是一种匿名函数，它可以赋值给变量也可以作为参数传递给其它函数，不同于函数的是，它允许捕获调用者作用域中的值

闭包语法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 定义闭包
|param1, param2,...| {
    语句1;
    语句2;
    返回表达式
} 
|param1| 返回表达式 // 只需要有一个表达式时
|| {} // 如果不需要参数时

// 结构体中的闭包
struct Cacher<T>
where T: Fn(u32) -> u32,
{
    query: T,
}  // 等价于struct Cacher<T: Fn(u32) -> u32>，query字段同样也可以使用一个符合的函数作为值

注：

• 闭包函数中是否标注类型皆可（如果未使用过则需要标注），同样可以以此省略返回值
• 闭包函数中的类型不可以是泛型，所以每次使用参数要求同类型

三种Fn特征

FnOnce: 强制需要闭包所捕获变量的所有权

FnMut: 用于闭包函数内需要改变被捕获变量的值的情况，需要闭包和捕获变量都有mut声明

Fn: 以不可变借用的方式捕获环境中的值(与FnMut不兼容，即不可改变捕获函数的值)

注：

• 在FnOnce作为传入闭包的特征约束时，传入闭包和其捕获函数的所有权都会在第一次调用时被消耗；特殊情况：同时要求FnOnce与Copy（闭包会实现Copy，而其捕获的变量也会尽量实现Copy）

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  fn main() { let x = vec![1, 2, 3]; fn_once(|z|{z == x.len()}) } fn fn_once<F>(func: F) where F: FnOnce(usize) -> bool, { println!("{}", func(3)); // 捕获的Vec的所有权，闭包与变量一起消耗 println!("{}", func(4)); } fn fn_once<F>(func: F) where F: FnOnce(usize) -> bool + Copy,// 改动在这里 { println!("{}", func(3)); // 闭包实现Copy，不消耗；尽可能捕获可Copy的值如x.len()，没有则会在编译报错 println!("{}", func(4)); }

• 由上所知，闭包的捕获行为会根据上下文约束来调整

• 闭包自动实现Copy特征的规则是，只要闭包捕获的类型都实现了Copy特征的话，这个闭包就会默认实现Copy特征

• FnOnce会消耗闭包的所有权；但无论按值还是按引用传递，Fn/FnMut通常都不会消耗闭包的所有权。即在传入一个有Fn(Mut)特征约束的函数之后，一个闭包函数的变量还可以继续使用

• 所有的闭包都自动实现了 FnOnce 特征，因此任何一个闭包都至少可以被调用一次；没有移出所捕获变量的所有权的闭包自动实现了 FnMut 特征；不需要对捕获变量进行改变的闭包自动实现了 Fn 特征

move

1

let update_string =  move || println!("{}",s); // move强制闭包获取变量所有权

闭包作为函数返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn factory() -> Fn(i32) -> i32 {
    let num = 5;
    |x| x + num
} // 报错，特征不是类型，需要其他辅助声明

fn factory(x:i32) -> impl Fn(i32) -> i32 {
    let num = 5;
    if x > 1{
        move |x| x + num
    } else {
        move |x| x - num
    }
} // 报错，返回的内容要求是同一类型，此处虽然满足同一特征，但属于不同类型

fn factory(x:i32) -> Box<dyn Fn(i32) -> i32> {
    let num = 5;
    if x > 1{
        Box::new(move |x| x + num)
    } else {
        Box::new(move |x| x - num)
    }
} // 正确，使用智能指针将其视为同一类型

迭代器Iterator

迭代器允许我们迭代一个连续的集合，例如数组、动态数组 Vec、HashMap 等，在此过程中，只需关心集合中的元素如何处理，而无需关心如何开始、如何结束、按照什么样的索引去访问

1、.next是迭代器中取下一个值的方式,返回Option<T>

1
2
3
4
5

pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
    // 省略其余有默认实现的方法
} // 迭代器实现的特征Interator

2、将数组转化为迭代器的三种方式(Vec动态数组实现的IntoIterator中的函数)：

• into_iter 会夺走所有权
• iter 是借用
• iter_mut 是可变借用（next方法返回的&mut）

3、迭代器的消费者与适配器（都是迭代器特征中的方法）

• 消费者：消费掉迭代器，返回一个值

  会拿走迭代器的所有权，即调用它之后迭代器无法再使用

• 适配器：返回一个新的迭代器，是链式调用的基础

  因此在链式调用末尾需要一个消费者来收尾用以返回一个值

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  //例1 let v1: Vec<i32> = vec![1, 2, 3]; let v2: Vec<_> = v1.iter().map(|x| x + 1).collect(); // collect():消费掉迭代器，把值收集成特定类型（需要显式注明） // .map():对迭代器的每一个值操作，换为另一个新值 assert_eq!(v2, vec![2, 3, 4]); //例2 let names = ["sunface", "sunfei"]; let ages = [18, 18]; let folks: HashMap<_, _> = names.into_iter().zip(ages.into_iter()).collect(); // .zip():将两个迭代器压缩在一起，形成Iterator<Item=(ValueFromA, ValueFromB)> 这样的新的迭代器 //例3：闭包用作适配器参数 fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> { shoes.into_iter().filter(|s| s.size == shoe_size).collect() } // filter():对迭代器每个值进行过滤，若满足则保留 // 此处闭包同样可以捕捉环境变量

深入类型

类型转换

as转换

1
2
3

let a = 3.1 as i8;
let b = 100_i8 as i32;
let c = 'a' as u8; // 将字符'a'转换为整数，97

注：

转换不具有传递性：就算 e as U1 as U2 是合法的，也不能说明 e as U2 是合法的（e 不能直接转换成 U2）

TryInto转换

1
2
3

let a: u8 = 10;
let b: u16 = 1500;
let b_: u8 = b.try_into().unwrap(); //尝试进行一次转换，并返回一个 Result

注：try_into 转换会捕获大类型向小类型转换时导致的溢出错误

From和Into特征

• From<T>：定义如何从类型 T 转换到当前类型。
• Into<T>：自动为实现了 From 的类型生成反向转换。

1
2
3
4
5
6
7
8
9
10

impl From<i32> for MyType {
    fn from(value: i32) -> Self {
        MyType(value)
  
    
    }
}

let a = MyType::from(42);  // 显式调用
let b: MyType = 42.into(); // 自动推导（需类型注解）

newtype

使用元组结构体的方式将已有的类型包裹起来：struct Meters(u32);，那么此处 Meters 就是一个 newtype

• 自定义类型可以让我们给出更有意义和可读性的类型名，例如与其使用 u32 作为距离的单位类型，我们可以使用 Meters，它的可读性要好得多
• 对于某些场景，只有 newtype 可以很好地解决
• 隐藏内部类型的细节

为外部类型实现外部特征

孤儿规则：要为类型 A 实现特征 T，那么 A 或者 T 必须至少有一个在当前的作用范围内

1
2
3
4
5
6
7
8
9
10

// 例：想为Vec实现Display特征，但这两个都在标准库中
use std::fmt;
struct Wrapper(Vec<String>);
impl fmt::Display for Wrapper {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[{}]", self.0.join(", "))
    }
}

// 注：包裹一样类型的newtype是不同的类型,newtype与其内部包裹的类型同理

类型别名

1

type Meters = u32

注：类型别名仅仅为了更好的可读性，与原类型没有任何区别

1
2
3
4
5
6
7
8

// 应用：减少代码模板的使用
let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi"));

type Thunk = Box<dyn Fn() + Send + 'static>;
let f: Thunk = Box::new(|| println!("hi"));

//常用于简化Result<T, E> 枚举中
type Result<T> = std::result::Result<T, std::io::Error>; // 此处为std::io库中Error类型的简化

不定长类型DST

定长类型：基础类型、集合 Vec、String 和 HashMap 等(其在栈上拥有固定大小的指针)

不定长类型：str、特征对象

1
2
3

fn foobar_1(thing: &dyn MyThing) {}     // OK
fn foobar_2(thing: Box<dyn MyThing>) {} // OK
fn foobar_3(thing: MyThing) {}          // ERROR!

注：只能间接使用DST，通过引用或Box来使用

Sized特征

怎么保证泛型参数是固定大小的类型？

1
2

fn generic<T(: Sized)>(t: T) { // 自动补全了Sized特征
}

枚举与整数

枚举到整数很容易，但反过来需要借助三方库来实现

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

enum MyEnum {
    A = 1,
    B,
    C,
}
fn main() {
    // 将枚举转换成整数，顺利通过
    let x = MyEnum::C as i32;
    // 将整数转换为枚举，失败
    match x {
        MyEnum::A => {}
        MyEnum::B => {}
        MyEnum::C => {}
        _ => {}
    }
}

// 使用num-traits/num-derive库
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;

match FromPrimitive::from_i32(x) {
    Some(MyEnum::A) => println!("Got A"),
    Some(MyEnum::B) => println!("Got B"),
    Some(MyEnum::C) => println!("Got C"),
    None            => println!("Couldn't convert {}", x),
}

智能指针

智能指针与普通自定义结构体区别：实现了Deref和Drop特征

智能指针用于一些较引用更复杂的场景

Box<T>堆对象分配

Box 简单的封装，用于将值存储在堆上

使用场景：

• 特意的将数据分配在堆上
• 数据较大时，又不想在转移所有权时进行数据拷贝
• 类型的大小在编译期无法确定，但是我们又需要固定大小的类型时
• 特征对象，用于说明对象实现了一个特征，而不是某个特定的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 将数据存储在堆上
let a = 3; // a在栈上
let a = Box::new(3); // 在堆上

// 避免栈上数据拷贝
let arr = [0;1000];
let arr1 = arr; // 此时两份数据，是深拷贝

let arr = Box::new([0;1000]);
let arr1 = arr; // 所有权顺利转移给 arr1，arr 不再拥有所有权

// 提供固定大小
enum List {
    Cons(i32, List), // 递归类型：无法确定大小，因为DST报错
    Nil,
}
enum List {
    Cons(i32, Box<List>),
    Nil,
}

// 特征对象
// 想实现不同类型组成的数组只有两个办法：枚举和特征对象
// 特征对象其实就是把DST类型的特征转为固定大小