rcore 笔记 第一个裸机程序

rcore介绍 QEMU 是一个开源的虚拟化软件,可以模拟多种架构的硬件,使用户能够在不同的平台上运行操作系统和应用程序。一个块512个字节,可以存放一定数量的索引,被称为索引块,也可以存放数据,被称为数据块。在开源操作系统青训营的第二阶段,对rcore的学习中,写出一个os是循序渐进的。也就是将原本的进程中一个个线程单独拎出来,放到列表中执行。优先级值越小,步长越大,进程越靠前,越先执行。提供中断和异常的处理,定时器,内存管理等。第一级页表包含了第二级页表的地址,第二级页表包含了第三级页表的地址, 阅读详情

环境

操作系统: 乌班图22.04
rust: rustc 1.75.0-nightly
QEMU emulator version 7.0.0

应用程序与基本执行环境

应用程序执行环境与基本操作平台

执行应用程序

我们先在Linux上开发并运行一个简单的 “Hello, world” 应用程序,看看一个简单应用程序从开发到执行的全过程。

cargo new os --bin

我们加上了 --bin 选项来告诉 Cargo 我们创建一个可执行程序项目而不是函数库项目。此时,项目的文件结构如下:

tree os
os
├── Cargo.toml
└── src
    └── main.rs
1 directory, 2 files

其中 Cargo.toml 中保存着项目的配置,包括作者的信息、联系方式以及库依赖等等。显而易见源代码保存在 src 目录下,目前为止只有 main.rs 一个文件,让我们看一下里面的内容:

最简单的 Rust 应用

fn main() {
    println!("Hello, world!");
}

进入 os 项目根目录下,利用 Cargo 工具即可一条命令实现构建并运行项目:

cargo run
   Compiling os v0.1.0 (/home/shinbokuow/workspace/v3/rCore-Tutorial-v3/os)
    Finished dev [unoptimized + debuginfo] target(s) in 1.15s
     Running `target/debug/os`
Hello, world!

如我们预想的一样,我们在屏幕上看到了一行 Hello, world! 。

应用程序执行环境

如下图所示,现在通用操作系统(如 Linux 等)上的应用程序运行需要下面多层次的执行环境栈的支持,图中的白色块自上而下(越往下则越靠近底层,下层作为上层的执行环境支持上层代码的运行)表示各级执行环境,黑色块则表示相邻两层执行环境之间的接口。
请添加图片描述

我们的应用位于最上层,它可以通过调用编程语言提供的标准库或者其他三方库对外提供的函数接口,使得仅需少量的源代码就能完成复杂的功能。但是这些库的功能不仅限于此,事实上它们属于应用程序执行环境(Execution Environment) 的一部分。在我们通常不会注意到的地方,这些软件库还会在执行应用之前完成一些初始化工作,并在应用程序执行的时候对它进行监控。我们在打印Hello, world!时使用的println!
宏正是由Rust标准库std提供的。

从操作系统内核的角度看来,它上面的一切都属于用户态软件,而它自身属于内核态软件。无论用户态应用如何编写,是手写汇编代码,还是基于某种高级编程语言调用其标准库或三方库,某些功能总要直接或间接的通过操作系统内核提供的系统调用(SystemCall)来实现。因此系统调用充当了用户和内核之间的边界。内核作为用户态软件的执行环境,它不仅要提供系统调用接口,还需要对用户态软件的执行进行监控和管理。

目标平台与目标三元组

对于一份用某种编程语言实现的应用程序源代码而言,编译器在将其通过编译、链接得到可执行文件的时候需要知道程序要在哪个平台(Platform)上运行。这里平台主要是指CPU类型、操作系统类型和标准运行时库的组合。从上面给出的应用程序执行环境栈可以看出:
• 如果用户态基于的内核不同,会导致系统调用接口不同或者语义不一致;
• 如果底层硬件不同,对于硬件资源的访问方式会有差异。特别是如果ISA不同,则向软件提供的指令集和寄存器都不同。

它们都会导致最终生成的可执行文件有很大不同。需要指出的是,某些编译器支持同一份源代码无需修改就可编译到多个不同的目标平台并在上面运行。这种情况下,源代码是跨平台的。而另一些编译器则已经预设好了一个固定的目标平台。

移除标准库依赖

移除 println! 宏

println! 宏所在的Rust标准库std需要通过系统调用获得操作系统的服务,而如果要构建运行在裸机上的操作系统,就不能再依赖标准库了。所以我们第一步要尝试移除println!宏及其所在的标准库。

由于后续实验需要rustc编译器缺省生成RISC-V64的目标代码,所以我们首先要给rustc添加一个target: riscv64gc-unknown-none-elf 。这可通过如下命令来完成:

rustup target add riscv64gc-unknown-none-elf

然后在os目录下新建.cargo目录,并在这个目录下创建config文件,并在里面输入如下内容:

# os/.cargo/config
 [build]
 target = "riscv64gc-unknown-none-elf"

这会对于Cargo工具在os目录下的行为进行调整:现在默认会使用riscv64gc作为目标平台而不是原先的默认x86_64-unknown-linux-gnu。

提供 panic_handler 功能应对致命错误

我们重新编译简单的os程序,之前的println宏缺失的错误消失了,但又出现了如下新的编译错误:

 $ cargo build
 Compiling os v0.1.0 (/home/shinbokuow/workspace/v3/rCore-Tutorial-v3/os)
 error: `#[panic_handler]` function required, but not found

在使用Rust编写应用程序的时候,我们常常在遇到了一些无法恢复的致命错误(panic),导致程序无法继续向下运行。这时手动或自动调用panic!宏来打印出错的位置,让软件能够意识到它的存在,并进行一些后续处理。
在标准库std中提供了关于panic!宏的具体实现,其大致功能是打印出错位置和原因并杀死当前应用。但本章要实现的操作系统不能使用还需依赖操作系统的标准库std,而更底层的核心库core中只有一个panic!宏的空壳,并没有提供panic!宏的精简实现。因此我们需要自己先实现一个简陋的panic处理函数.
注解: #[panic_handler]
#[panic_handler] 是一种编译指导属性,用于标记核心库core中的panic!宏要对接的函数(该函数实现对致命错误的具体处理)。该编译指导属性所标记的函数需要具有fn(&PanicInfo)-> !函数签名,函数可通过PanicInfo数据结构获取致命错误的相关信息。这样Rust编译器就可以把核心库core中的panic!宏定义与#[panic_handler]指向的panic函数实现合并在一起,使得no_std程序具有类似std库的应对致命错误的功能。

我们创建一个新的子模块lang_items.rs实现panic函数,并通过#[panic_handler]属性通知编译器
用panic 函数来对接panic!宏。为了将该子模块添加到项目中,我们还需要在main.rs的#![no_std]的下方加上mod lang_items;,相关知识可参考Rust模块编程:

 // os/src/lang_items.rs
 use core::panic::PanicInfo;
 #[panic_handler]
 fn panic(_info: &PanicInfo)-> ! {
 loop {}
 }

在把panic_handler配置在单独的文件os/src/lang_items.rs后,需要在os/src/main.rs文件中添加以下内容才能正常编译整个软件:

// os/src/main.rs
 #![no_std]
 mod lang_items;
 // ... other code

移除 main 函数

我们再次重新编译简单的os程序,之前的#[panic_handler]函数缺失的错误消失了,但又出现了如下新的编译错误:… error:

 .. code-block::
 $ cargo build
 Compiling os v0.1.0 (/home/shinbokuow/workspace/v3/rCore-Tutorial-v3/os)
 error: requires `start` lang_item

编译器提醒我们缺少一个名为start的语义项。我们回忆一下,之前提到语言标准库和三方库作为应用程序的执行环境,需要负责在执行应用程序之前进行一些初始化工作,然后才跳转到应用程序的入口点开始执行。事实上start语义项代表了标准库std在执行应用程序之前需要进行的一些初始化工作。由于我们禁用了标准库,编译器也就找不到这项功能的实现了。

最简单的解决方案就是压根不让编译器使用这项功能。我们在main.rs的开头加入设置#![no_main]告诉编译器我们没有一般意义上的main函数,并将原来的main函数删除。在失去了main函数的情况下,编译器也就不需要完成所谓的初始化工作了。

编译运行

# 编译
cargo build --release
# 运行
qemu-system-riscv64     -machine virt     -nographic     -bios ../bootloader/rustsbi-qemu.bin     -device loader,file=target/riscv64gc-unknown-none-elf/release/os,addr=0x80200000

内核指令

程序内存布局与编译流程

在我们将源代码编译为可执行文件之后,它就会变成一个看似充满了杂乱无章的字节的一个文件。但我们知道这些字节至少可以分成代码和数据两部分,在程序运行起来的时候它们的功能并不相同:代码部分由一条条可以被 CPU 解码并执行的指令组成,而数据部分只是被 CPU 视作可读写的内存空间。事实上我们还可以根据其功能进一步把两个部分划分为更小的单位: 段 (Section) 。不同的段会被编译器放置在内存不同的位置上,这构成了程序的 内存布局 (Memory Layout)。一种典型的程序相对内存布局如下所示:
请添加图片描述

  • 已初始化数据段保存程序中那些已初始化的全局数据,分为 .rodata 和 .data 两部分。前者存放只读的全局数据,通常是一些常数或者是 常量字符串等;而后者存放可修改的全局数据。

  • 未初始化数据段 .bss 保存程序中那些未初始化的全局数据,通常由程序的加载者代为进行零初始化,即将这块区域逐字节清零;

  • 堆 (heap)区域用来存放程序运行时动态分配的数据,如 C/C++ 中的 malloc/new 分配到的数据本体就放在堆区域,它向高地址增长;

  • 栈 (stack)区域不仅用作函数调用上下文的保存与恢复,每个函数作用域内的局部变量也被编译器放在它的栈帧内,它向低地址增长。

编译流程
从源代码得到可执行文件的编译流程可被细化为多个阶段(虽然输入一条命令便可将它们全部完成):

  1. 编译器(Compiler) 将每个源文件从某门高级编程语言转化为汇编语言,注意此时源文件仍然是一个ASCII 或其他编码的文本文件;
  2. 汇编器(Assembler) 将上一步的每个源文件中的文本格式的指令转化为机器码,得到一个二进制的目标文件(Object File);
  3. 链接器(Linker) 将上一步得到的所有目标文件以及一些可能的外部目标文件链接在一起形成一个完整的可执行文件。

汇编器输出的每个目标文件都有一个独立的程序内存布局,它描述了目标文件内各段所在的位置。而链接器所做的事情是将所有输入的目标文件整合成一个整体的内存布局。在此期间链接器主要完成两件事情:
• 第一件事情是将来自不同目标文件的段在目标内存布局中重新排布。如下图所示,在链接过程中,分别来自于目标文件1.o和2.o段被按照段的功能进行分类,相同功能的段被排在一起放在拼装后的目标文件output.o中。注意到,目标文件1.o和2.o的内存布局是存在冲突的,同一个地址在不同的内存布局中存放不同的内容。而在合并后的内存布局中,这些冲突被消除。
• 第二件事情是将符号替换为具体地址。这里的符号指什么呢?我们知道,在我们进行模块化编程的时候,每个模块都会提供一些向其他模块公开的全局变量、函数等供其他模块访问,也会访问其他模块向它公开的内容。要访问一个变量或者调用一个函数,在源代码级别我们只需知道它们的名字即可,
这些名字被我们称为符号。取决于符号来自于模块内部还是其他模块,我们还可以进一步将符号分成内部符号和外部符号。然而,在机器码级别(也即在目标文件或可执行文件中)我们并不是通过符号来找到索引我们想要访问的变量或函数,而是直接通过变量或函数的地址。例如,如果想调用一个函数,那么在指令的机器码中我们可以找到函数入口的绝对地址或者相对于当前PC的相对地址。

请添加图片描述

内核第一条指令

编写内核第一条指令

首先,我们需要编写进入内核后的第一条指令,这样更方便我们验证我们的内核镜像是否正确对接到Qemu
上。

 # os/src/entry.asm
 .section .text.entry
 .globl _start
_start:
 li x1, 100

实际的指令位于第5行,也即li x1, 100。li是LoadImmediate的缩写,也即将一个立即数加载到某个寄存器,因此这条指令可以看做将寄存器x1赋值为100。第4行我们声明了一个符号_start,该符号指向紧跟在符号后面的内容——也就是位于第5行的指令,因此符号_start的地址即为第5行的指令所在的
地址。第3行我们告知编译器_start是一个全局符号,因此可以被其他目标文件使用。第2行表明我们希望将第2行后面的内容全部放到一个名为.text.entry的段中。一般情况下,所有的代码都被放到一个名为.text的代码段中,这里我们将其命名为.text.entry从而区别于其他.text的目的在于我们想要确保该段被放置在相比任何其他代码段更低的地址上。这样,作为内核的入口点,这段指令才能被最先执行。
接着,我们在main.rs中嵌入这段汇编代码,这样Rust编译器才能够注意到它,不然编译器会认为它是一个与项目无关的文件:

//os/src/main.rs
#![no_std]
#![no_main]

mod lang_item;

usecore::arch::global_asm;
global_asm!(include_str!("entry.asm"));

第8行,我们通过include_str!宏将同目录下的汇编代码entry.asm转化为字符串并通过global_asm!宏嵌入到代码中。

调整内核的内存布局

由于链接器默认的内存布局并不能符合我们的要求,为了实现与Qemu正确对接,我们可以通过链接脚本(LinkerScript)调整链接器的行为,使得最终生成的可执行文件的内存布局符合Qemu的预期,即内核第一条指令的地址应该位于0x80200000。我们修改Cargo的配置文件来使用我们自己的链接脚本os/src/linker.ld而非使用默认的内存布局:

//os/.cargo/config
[build]
target ="riscv64gc-unknown-none-elf"

[target.riscv64gc-unknown-none-elf]
rustflags= [
"-Clink-arg=-Tsrc/linker.ld", "-Cforce-frame-pointers=yes"
]

链接脚本os/src/linker.ld如下:

OUTPUT_ARCH(riscv)
ENTRY(_start)
BASE_ADDRESS =0x80200000;

SECTIONS
{
 . = BASE_ADDRESS;
 skernel = .;

 stext= .;
 .text:{
 *(.text.entry)
 *(.text.text.*)
 }
 
 . = ALIGN(4K);
 etext= .;
 srodata = .;
 .rodata:{
 *(.rodata .rodata.*)
 *(.srodata .srodata.*)
 }
 
 . = ALIGN(4K);
 erodata = .;
 sdata= .;
 .data:{
 *(.data.data.*)
 *(.sdata.sdata.*)
 }
 
 . = ALIGN(4K);
 edata= .;
 .bss:{
 *(.bss.stack)
 sbss=.;
 *(.bss.bss.*)
 *(.sbss.sbss.*)
 }
 
 . = ALIGN(4K);
 ebss= .;
 ekernel = .;
 
 /DISCARD/ :{
 *(.eh_frame)
 }
}

第1行我们设置了目标平台为riscv;第2行我们设置了整个程序的入口点为之前定义的全局符号_start;第3行定义了一个常量BASE_ADDRESS为0x80200000,也就是我们之前提到内核的初始化代码被放置的地址;
从第5行开始体现了链接过程中对输入的目标文件的段的合并。其中.表示当前地址,也就是链接器会从它指向的位置开始往下放置从输入的目标文件中收集来的段。我们可以对.进行赋值来调整接下来的段放在哪里,也可以创建一些全局符号赋值为.从而记录这一时刻的位置。我们还能够看到这样的格式:

.rodata: {
 *(.rodata)
 }

冒号前面表示最终生成的可执行文件的一个段的名字,花括号内按照放置顺序描述将所有输入目标文件的哪些段放在这个段中,每一行格式为(SectionName),表示目标文件ObjectFile的名为SectionName的段需要被放进去。我们也可以使用通配符来书写和分别表示可能的输入目标文件和段名。因此,最终的合并结果是,在最终可执行文件中各个常见的段.text,.rodata.data,.bss从低地址到高地址按顺序放置,每个段里面都包括了所有输入目标文件的同名段,且每个段都有两个全局符号给出了它的开始和结束地址。
第12行我们将包含内核第一条指令的.text.entry段放在最终的.text段的最开头,同时注意到在最终内存布局中代码段.text又是先于任何其他段的。因为所有的段都从BASE_ADDRESS也即0x80200000开始放置,这就能够保证内核的第一条指令正好放在0x80200000从而能够正确对接到Qemu上。

手动加载内核可执行文件

上面得到的内核可执行文件完全符合我们对于内存布局的要求,但是我们不能将其直接提交给Qemu,因为它除了实际会被用到的代码和数据段之外还有一些多余的元数据,这些元数据无法被Qemu在加载文件时利用,且会使代码和数据段被加载到错误的位置。如下图所示:
请添加图片描述

图中,红色的区域表示内核可执行文件中的元数据,深蓝色的区域表示各个段(包括代码段和数据段),而浅蓝色区域则表示内核被执行的第一条指令,它位于深蓝色区域的开头。图示的上半部分中,我们直接将内核可执行文件os提交给Qemu,而Qemu会将整个可执行文件不加处理的加载到Qemu内存的0x80200000处,由于内核可执行文件的开头是一段元数据,这会导致Qemu内存0x80200000处无法找到内核第一条指令,也就意味着RustSBI无法正常将计算机控制权转交给内核。相反,图示的下半部分中,将元数据丢弃得到的内核镜像os.bin被加载到Qemu之后,则可以在0x80200000处正确找到内核第一条指令。
使用如下命令可以丢弃内核可执行文件中的元数据得到内核镜像:

rust-objcopy--strip-all target/riscv64gc-unknown-none-elf/release/os-O binary

为内核支持函数调用

函数调用与栈

请添加图片描述

指令集必须给用于函数调用的跳转指令一些额外的能力,而不只是单纯的跳转。在RISC-V架构上,有两条指令即符合这样的特征:

指令指令功能
jal rd, imm[20 : 1]rd ←pc+4 pc ←pc+imm
jalr rd, (imm[11 : 0])rsrd ←pc+4 pc ←rs+imm

从中可以看出,这两条指令在设置pc寄存器完成跳转功能之前,还将当前跳转指令的下一条指令地址保存在rd寄存器中,即rd←pc+4这条指令的含义。在RISC-V架构中,
通常使用ra寄存器(即x1寄存器)作为其中的rd对应的具体寄存器,因此在函数返回的时候,只需跳转回ra所保存的地址即可。事实上在函数返回的时候我们常常使用一条汇编伪指令(PseudoInstruction)跳转回调用之前的位置:ret。它会被汇编器翻译为jalr x0, 0(x1),含义为跳转到寄存器ra保存的物理地址,由于x0是一个恒为0的寄存器,在rd中保存这一步被省略。

由于每个CPU只有一套寄存器,我们若想在子函数调用前后保持函数调用上下文不变,就需要物理内存的帮助。确切的说,在调用子函数之前,我们需要在物理内存中的一个区域保存(Save)函数调用上下文中的寄存器;而在函数执行完毕后,我们会从内存中同样的区域读取并恢复(Restore)函数调用上下文中的寄存器。
实际上,这一工作是由子函数的调用者和被调用者(也就是子函数自身)合作完成。函数调用上下文中的寄存器被分为如下两类:
• 被调用者保存(Callee-Saved)寄存器:被调用的函数可能会覆盖这些寄存器,需要被调用的函数来保存的寄存器,即由被调用的函数来保证在调用前后,这些寄存器保持不变;
• 调用者保存(Caller-Saved)寄存器:被调用的函数可能会覆盖这些寄存器,需要发起调用的函数来保存的寄存器,即由发起调用的函数来保证在调用前后,这些寄存器保持不变。

调用规范

调用规范(Calling Convention) 约定在某个指令集架构上,某种编程语言的函数调用如何实现。它包括了以下
内容:

  1. 函数的输入参数和返回值如何传递;
  2. 函数调用上下文中调用者/被调用者保存寄存器的划分;
  3. 其他的在函数调用流程中对于寄存器的使用方法。
    调用规范是对于一种确定的编程语言来说的,因为一般意义上的函数调用只会在编程语言的内部进行。当一种语言想要调用用另一门编程语言编写的函数接口时,编译器就需要同时清楚两门语言的调用规范,并对寄存器的使用做出调整。
    |寄存器组|保存者|功能|
    |---------|------------|--------------|
    |a0a7(x10x17 )|调用者保存|用来传递输入参数。其中的a0和a1还用来保存返回值。|
    |t0~t6( x5x7,x28x31 )|调用者保存作为临时寄存器使用,在被调函数中可以随意使用无需保存。|
    |s0~s11( x18~x27 ,x8~x9,)|被调用者保存作为临时寄存器使用,被调函数保存后才能在被调函数中使用。|

剩下的5个通用寄存器情况如下:
• zero( x0 ) 之前提到过,它恒为零,函数调用不会对它产生影响;
• ra( x1 ) 是被调用者保存的。被调用者函数可能也会调用函数,在调用之前就需要修改ra使得这次调用能正确返回。因此,每个函数都需要在开头保存ra到自己的栈中,并在结尾使用ret返回之前将其恢复。栈帧是当前执行函数用于存储局部变量和函数返回信息的内存结构。
• sp( x2 ) 是被调用者保存的。这个是之后就会提到的栈指针(StackPointer)寄存器,它指向下一个将要
被存储的栈顶位置。
• fp( s0 ),它既可作为s0临时寄存器,也可作为栈帧指针(FramePointer)寄存器,表示当前栈帧的起
始位置,是一个被调用者保存寄存器。fp指向的栈帧起始位置和sp指向的栈帧的当前栈顶位置形成了
所对应函数栈帧的空间范围。
• gp( x3 ) 和tp( x4 ) 在一个程序运行期间都不会变化,因此不必放在函数调用上下文中。

分配并使用启动栈

我们在entry.asm中分配启动栈空间,并在控制权被转交给Rust入口之前将栈指针sp设置为栈顶的位置。

 # os/src/entry.asm
 .section .text.entry
 .globl _start
_start:
 la sp, boot_stack_top
 call rust_main
 .section .bss.stack
 .globl boot_stack_lower_bound
boot_stack_lower_bound:
 .space 4096 * 16
 .globl boot_stack_top
boot_stack_top:


我们在第11行在内核的内存布局中预留了一块大小为4096*16字节也就是64KiB的空间用作接下来要运行的程序的栈空间。在RISC-V架构上,栈是从高地址向低地址增长。因此,最开始的时候栈为空,栈顶和栈底位于相同的位置,我们用更高地址的符号boot_stack_top来标识栈顶的位置。同时,我们用更低地址的符号boot_stack_lower_bound来标识栈能够增长到的下限位置,它们都被设置为全局符号供其他目标文件使用。如下图所示:
请添加图片描述

回到entry.asm,可以发现在控制权转交给Rust入口之前会执行两条指令,它们分别位于entry.asm的第5、6行。第5行我们将栈指针sp设置为先前分配的启动栈栈顶地址,这样Rust代码在进行函数调用和返回的时候就可以正常在启动栈上分配和回收栈帧了。在我们设计好的内存布局中,这块启动栈所用的内存并不会和内核的其他代码、数据段产生冲突。第6行我们通过伪指令call调用Rust编写的内核入口点rust_main将控制
权转交给Rust代码,该入口点在main.rs中实现:

// os/src/main.rs
 #[no_mangle]
 pub fn rust_main()-> ! {
 loop {}
 }

这里需要注意的是需要通过宏将rust_main标记为#[no_mangle]以避免编译器对它的名字进行混淆,不然在链接的时候,entry.asm将找不到main.rs提供的外部符rust_main从而导致链接失败。在
rust_main 函数的开场白中,我们将第一次在栈上分配栈帧并保存函数调用上下文,它也是内核运行全程中最底层的栈帧。
在内核初始化中,需要先完成对.bss段的清零。这是内核很重要的一部分初始化工作,在使用任何被分配到.bss段的全局变量之前我们需要确保.bss段已被清零。我们就在rust_main的开头完成这一工作,由于控制权已经被转交给Rust,我们终于不用手写汇编代码而是可以用Rust来实现这一功能了:

//os/src/main.rs
#[no_mangle]
pubfn rust_main()->! {
clear_bss();
loop{}
}

fnbclear_bss(){
extern "C"{
fn sbss();
fn ebss();
}
(sbssas usize..ebss asusize).for_each(|a| {
unsafe{ (aas *mutu8).write_volatile(0)}
});
}

在函数clear_bss中,我们会尝试从其他地方找到全局符号sbss和ebss,它们由链接脚本linker.ld给出,并分别指出需要被清零的.bss段的起始和终止地址。接下来我们只需遍历该地址区间并逐字节进行清零即可。

基于SBI服务完成输出和关机

使用 RustSBI 提供的服务

我们对 RustSBI 的了解仅限于它会在计算机启动时进行它所负责的环境初始化工作,并将计算机控制权移交给内核。但实际上作为内核的执行环境,它还有另一项职责:即在内核运行时响应内核的请求为内核提供服务。当内核发出请求时,计算机会转由 RustSBI 控制来响应内核的请求,待请求处理完毕后,计算机控制权会被交还给内核。从内存布局的角度来思考,每一层执行环境都对应到内存中的一段代码和数据,这里的控制权转移指的是 CPU 从执行一层软件的代码到执行另一层软件的代码的过程。这个过程和函数调用比较像,但是内核无法通过函数调用来请求 RustSBI 提供的服务,这是因为内核并没有和 RustSBI 链接到一起,我们仅仅使用 RustSBI 构建后的可执行文件,因此内核对于 RustSBI 的符号一无所知。事实上,内核需要通过另一种复杂的方式来“调用” 。

// os/src/main.rs
 mod sbi;
 // os/src/sbi.rs
 use core::arch::asm;
 #[inline(always)]
 fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize)->     usize {
    let mut ret;
    unsafe {
    asm!(
        "ecall",
        inlateout("x10") arg0 => ret,
        in("x11") arg1,
        in("x12") arg2,
        in("x17") which,
    );
 }
 ret
}

我们将内核与RustSBI通信的相关功能实现在子模块sbi中,因此我们需要在main.rs中加入mod sbi将该子模块加入我们的项目。在os/src/sbi.rs中,我们首先关注sbi_call的函数签名,which表示请求RustSBI 的服务的类型(RustSBI可以提供多种不同类型的服务),arg0~arg2表示传递给RustSBI的3 个参数,而RustSBI在将请求处理完毕后,会给内核一个返回值,这个返回值也会被sbi_call函数返回。
在sbi.rs中我们定义RustSBI支持的服务类型常量,它们并未被完全用到:

// os/src/sbi.rs
#![allow(unused)] // 此行请放在该文件最开头
const SBI_SET_TIMER: usize = 0;
const SBI_CONSOLE_PUTCHAR: usize = 1;
const SBI_CONSOLE_GETCHAR:usize= 2;
const SBI_CLEAR_IPI:usize= 3;
const SBI_SEND_IPI:usize= 4;
const SBI_REMOTE_FENCE_I:usize= 5;
const SBI_REMOTE_SFENCE_VMA:usize= 6;
const SBI_REMOTE_SFENCE_VMA_ASID:usize= 7;
const SBI_SHUTDOWN:usize= 8;

如字面意思,服务SBI_CONSOLE_PUTCHAR可以用来在屏幕上输出一个字符。我们将这个功能封装成console_putchar函数:

//os/src/sbi.rs
pub fn console_putchar(c:usize){
    sbi_call(SBI_CONSOLE_PUTCHAR,c,0, 0);
}

类似上述方式,我们还可以将关机服务SBI_SHUTDOWN封装成shutdown函数:

//os/src/sbi.rs
pub fn shutdown()->! {
sbi_call(SBI_SHUTDOWN,0, 0,0);
    panic!("Itshouldshutdown!");
}

实现格式化输出

onsole_putchar的功能过于受限,如果想打印一行Helloworld!的话需要进行多次调用。能否像本章第一节那样使用println!宏一行就完成输出呢?因此我们尝试自己编写基于console_putchar的println!宏。

// os/src/main.rs
#[macro_use]
mod console;

// os/src/console.rs
use crate::sbi::console_putchar;
use core::fmt::{self, Write};

struct Stdout;

impl Write for Stdout {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        for c in s.chars() {
            console_putchar(c as usize);
        }
        Ok(())
    }
}

pub fn print(args: fmt::Arguments) {
    Stdout.write_fmt(args).unwrap();
}

#[macro_export]
macro_rules! print {
    ($fmt: literal $(, $($arg: tt)+)?) => {
        $crate::console::print(format_args!($fmt $(, $($arg)+)?));
    }
}

#[macro_export]
macro_rules! println {
    ($fmt: literal $(, $($arg: tt)+)?) => {
        $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
    }
}

处理致命错误

错误处理是编程的重要一环,它能够保证程序的可靠性和可用性,使得程序能够从容应对更多突发状况而不至于过早崩溃。

// os/src/lang_items.rs
use core::panic::PanicInfo;

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}

可以看到,在目前的实现中,当遇到不可恢复错误的时候,被标记为语义项 #[panic_handler] 的 panic 函数将会被调用,然而其中只是一个死循环,会使得计算机卡在这里。借助前面实现的 println! 宏和 shutdown 函数,我们可以在 panic 函数中打印错误信息并关机:

// os/src/main.rs
#![feature(panic_info_message)]

// os/src/lang_item.rs
use crate::sbi::shutdown;
use core::panic::PanicInfo;

#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
    if let Some(location) = info.location() {
        println!(
            "Panicked at {}:{} {}",
            location.file(),
            location.line(),
            info.message().unwrap()
        );
    } else {
        println!("Panicked: {}", info.message().unwrap());
    }
    shutdown()
}

我们尝试打印更加详细的信息,包括 panic 所在的源文件和代码行数。我们尝试从传入的 PanicInfo 中解析这些信息,如果解析成功的话,就和 panic 的报错信息一起打印出来。我们需要在 main.rs 开头加上 #![feature(panic_info_message)] 才能通过 PanicInfo::message 获取报错信息。当打印完毕之后,我们直接调用 shutdown 函数关机。

为了测试我们的实现是否正确,我们将 rust_main 改为:

// os/src/main.rs
#[no_mangle]
pub fn rust_main() -> ! {
    clear_bss();
    println!("Hello, world!");
    panic!("Shutdown machine!");
}
THU-OS rCore学习总结 基于Rust + RISC-V 2021课程主页 源码 指导书 Rust编程之道 视频 阅读详情

相关推荐

iOS安全攻防:从DarkSword漏洞利用链剖析到纵深防御实践

在移动安全领域,内存破坏漏洞(如堆溢出、释放后使用)是攻击者突破系统防线、实现远程代码执行和权限提升的核心技术原理。这些漏洞利用技术通过精心构造的攻击链,能够绕过沙箱、地址空间布局随机化等安全机制,最终威胁设备内核安全,其技术价值在于揭示了系统安全架构的潜在薄弱环节。在iOS应用开发与系统防护中,理解此类攻击链对于构建有效的纵深防御体系至关重要。应用场景涵盖从安全编码、网络通信加固到运行时应用程序自保护等多个层面。本文以DarkSword工具包为例,深入拆解其利用链,并分享如何通过内存安全实践、代码签名强化

weixin_30357231的博客 481

清华大学操作系统rCore实验-第一章-应用程序与基本执行环境

rCore实验一-应用程序与基本执行环境

qq_38678845的博客 3469

瑞芯微RK3576开发板实战:6TOPS NPU如何加速你的AIoT项目(附性能测试)

本文以瑞芯微RK3576开发板为核心,深入探讨其6TOPS NPU在AIoT项目中的实战应用。通过详细的性能测试对比,展示了NPU如何将AI模型推理速度提升15倍以上,并大幅降低CPU负载。文章涵盖从环境搭建、模型转换优化到多屏异显与系统级调优的全流程,为开发者提供了将硬件算力转化为实际项目加速效果的完整指南。

oauth7security的博客 822

rcore 笔记 批处理系统 邓氏鱼

批处理系统 (Batch System) ,它可用来管理无需或仅需少量用户交互即可运行的程序,在资源允许的情况下它可以自动安排程序的执行,这被称为“批处理作业”。

个人博客,记录了本人学习的各种有趣的技术。 1146

DeepSeek Harness 三步安装:命令行低成本接入 GPT-5.6 Sol

命令行AI工具正成为开发者调用大模型API的高效入口。这类工具通过API Key对接多家模型服务商,无需本地GPU,按token量计费,既能完成编码对话,也适合脚本化批量任务。对于经常在终端工作的开发者,掌握这类CLI工具的安装与配置,能显著降低调用模型的门槛。DeepSeek Harness 正是面向这一场景的轻量方案:三步完成安装,以0.3元/刀的量级接入GPT-5.6 Sol等旗舰模型,并支持skill扩展。本文从环境准备到批量测试,帮你快速搭建起属于自己的命令行智能编码环境。

weixin_28235513的博客 305

深入解析Linux Suspend/Resume机制——从用户态到内核态的完整流程

本文深入解析Linux Suspend/Resume机制,从用户态触发到内核态执行的完整流程。详细介绍了三种挂起模式(Freeze、Standby、Suspend to RAM)的实现原理,包括系统调用入口、状态验证、设备挂起流程及平台相关操作。同时提供实战调试技巧,帮助开发者解决电源管理中的常见问题。

weixin_29313239的博客 444

Rust嵌入式编程---panic处理和异常处理

异常意味着抢占,并涉及异常处理程序,即响应触发事件的信号而执行的子例程,这就是和。是硬件上的,而panic理解成软件上的,比如访问文件不存在啊、访问越界啊、除0操作等等,而且panic一般没有那么多处理方式,没有抢占和触发panic处理程序等等。在标准库(Std)中,panic有一个定义的行为:它展开 panic 线程的堆栈,除非用户选择在 panic 时中止程序,否则会进行错误位置的一个堆栈定位。该值是发生异常时程序计数器的值,它指向触发异常的指令,所以可以看一下pc的值指向的指令就是错误的地方。

phthon1997的博客 2026

使用 PLS 回归进行近红外光谱的异常值检测

在光谱数据中,并非每个数据点都是有效的,因此,在构建模型时找到与大部分数据不符合的数据点是一种必要的操作。这些数据我们称之为。在这篇文章中,我们将使用PLS回归进行红外光谱数据的异常值检测。

qq_44204759的博客 1424

rcore第一章:裸机执行应用程序

栈的来源:内核自己在.bss.stack段分配的 64KB 空间(链接器定死地址);栈的初始化:通过将sp绑定到栈顶,完成初始化;栈的用途:支撑函数调用、存储局部变量、保存寄存器值,是内核从汇编到 Rust 执行的必要条件;栈的特性:RISC-V 架构向下生长,sp递减为压栈,递增为弹栈,64KB 空间足够满足内核初始化需求。源码准备:编写entry.asm(汇编入口)、(Rust 入口)、linker.ld(内存布局)等文件;编译汇编:将源码转为独立.o目标文件,段分散,无固定地址;

a2401576898的博客 1194

告别 SAP GUI 事务码时代:手把手教你配置 SAP Fiori Launchpad

SAP S/4HANA私有云系统安装后,Fiori Launchpad空页面问题常因多层配置未完成所致。SAP仅提供基础技术配置,实际应用启用、业务目录创建、角色授权等需实施团队完成。Fiori配置分为跨客户端层(技术目录)、客户端定制层(业务目录、空间页面)和用户个性化层三层架构。标准授权流程需依次创建业务目录、业务角色、空间页面并正确分配。SAP建议使用最新的配置工具如FLPAM和FLPCM,并采用Spaces/Pages替代已弃用的Groups概念。完整授权需六步:分配基础角色、创建业务目录、维护业务

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 541

Silvaco TCAD 半导体器件仿真全攻略:从入门到精通

本文介绍了Silvaco TCAD半导体器件仿真平台的核心功能与应用方法。主要内容包括: Silvaco TCAD的核心模块组成(ATHENA工艺仿真和ATLAS器件仿真)及其在半导体研发中的重要作用,能够通过数值仿真预测器件电学特性,显著降低研发成本。 环境配置要点,包括内存分配、文件目录管理和许可证验证,为仿真工作提供基础保障。 仿真核心概念:详细讲解了网格划分策略和物理模型选择原则,强调基于物理直觉的自适应加密网格方法。 以PN结二极管为例,提供了完整的仿真代码示例,涵盖从网格定义、掺杂设置到结果分析

huanghm88的专栏 209

rust 实现 rCore lab0

实验报告 lab0 lab0实验指导书 一,创建项目: 第 1 步:建立Project文件夹,所有文件均保存在其中。 第 2 步:在Project文件夹下建立名为rust-toolchain的文件,指定工具链版本。 //rust-toolchain nightly-2020-06-27 第 3 步:运行cargo new os创建os文件夹,具体的os项目在此文件夹中开发。 此时目录结构如下: Project 项目目录 ├── rust-toolchain Ru

凡尘维一心的博客 1354

opencv案例实战——银行卡模式匹配识别

在之前的几篇文章中我们已经介绍了opencv的一些基础知识,本篇文章我们将结合一个案例运用之前的知识并且学习opencv中模式匹配的应用,用到的知识点如果有不清楚的可以查看上面列出来的系列文章。具体代码会放在最后。

艾醒的博客 1340

rcore阅读(二)

本文档深入分析了rCore-Tutorial操作系统内核的启动代码和panic处理器实现。启动代码采用汇编编写,负责初始化栈指针并跳转到Rust主函数,体现了最小化原则和分层设计思想。panic处理器则处理不可恢复错误,通过日志记录panic信息并安全关机,确保系统稳定终止。两者配合为操作系统提供了可靠的启动和错误处理机制,具有可维护性、可调试性和安全性等特点。

daivy520的博客 626

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

[rCore学习笔记 021]多道程序与分时任务

操作系统可进一步利用某种以固定时长为时间间隔的外设中断(比如时钟中断)来强制打断一个程序的执行,这样一个程序只能运行一段时间(可以简称为一个时间片, Time Slice)就一定会让出处理器,且操作系统可以在处理外设的 I/O 响应后,让不同应用程序分时占用处理器执行,并可通过统计程序占用处理器的总执行时间,来评估运行的程序对处理器资源的消耗。本章所介绍的多道程序和分时多任务系统都有一些共同的特点:在内存中同一时间可以驻留多个应用,而且所有的应用都是在系统启动的时候分别加载到内存的不同区域中。

weixin_55010563的博客 723

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

THU-rCore 操作系统实验踩坑日寄-1

虽然也可以使用JetBrains的RustRover,但是JetBrains系IDE的运行速度在我的低配电脑上实在很难称得上顺滑,也许还是使用编辑器好些。上,还要求使用nightly版本的工具链。不过如今rust工具链的已经迭代到v1.83(stable),想必彼时的nightly特性应该早已经稳定了(指导书使用的版本是1.62 nightly)。糟糕的是大概因为版本太新还没有进入LLM们的训练语料中,几乎所有LLM(Claude,GPT,Tongyi)都会认为这种写法是错的。即这些不安全的属性都得标上。

weixin_43332748的博客 2054

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

RCore学习记录001

在Ubuntu24.04搭建RCore的代码环境

黑暗巫妖的博客 972

rcore阅读(三)

本文分析了rcore操作系统中ch2分支的部分关键代码实现,重点解读了单处理器环境下的内部可变性原语和系统调用机制。摘要如下: 单处理器安全单元(UPSafeCell): 通过RefCell实现内部可变性,利用运行时借用检查规避unsafe代码 显式标记为Sync以支持全局静态变量访问 提供exclusive_access方法实现排他性访问 系统调用实现: 采用模块化设计,按功能分类实现系统调用 sys_write实现标准输出功能,仅支持FD_STDOUT描述符 遵循RISC-V Linux ABI系统调用

daivy520的博客 591

在裸机上输出Hello,world! [rCore-lab1]

非常简单的“Hello, world”应用程序,实际上有着多层硬件和软件工具和支撑环境隐藏在它背后,才让我们不必付出那么多努力就能够创造出功能强大的应用程序。生成应用程序二进制执行代码所依赖的是以 编译器 为主的开发环境;运行应用程序执行码所依赖的是以 操作系统 为主的执行环境。这次本文章梳理文档,要在裸机上实现输出Hello,world!./os/src├── bootloader(内核依赖的运行在 M 特权级的 SBI 实现,本项目中我们使用 RustSBI)

weixin_61631200的博客 1292

rCore1

键入如上指令,CPU:X86_64,操作系统:linux,运行时库:gnu。

2401_87872002的博客 445

操作系统实验-rCore-lab2

rCore-lab2

SHyyyyyy___的博客 2139

[rCore学习笔记 020]第二章作业

合集 - rCore(26)1.[rCore学习笔记 00]总览07-092.[rCore学习笔记 01]安装VMwareWorkStationPro08-153.[rCore学习笔记 02]Ubuntu 22虚拟机安装07-094.[rCore学习笔记 03]配置rCore开发环境07-095.[rCore学习笔记 04]安装SSH07-096.[rCore学习笔记 05]第0章作业题07-09...

weixin_40480943的博客 581

rcore lab0

今天早上终于把之前实验环境的问题解决了!搞了有一周了吧,事实证明还是要多问不能闭门造车啊。 原来之前做的是实验指导书上第一章的内容,lab在习题上,所以今天才算是做lab的第一天吧。时间要不够了… 安装 binutils 工具集 cargo install cargo-binutils rustup component add llvm-tools-preview 用 rust-objdump --version 命令看看是否安装成功。 查看它的文件类型: $ file target/riscv64imac

m0_59880088的博客 639

rcore,zcore,兼谈fuchsia:一种快速编程教学系统和rust编程语言快速学习项目

本文关键字:一种快速编程教学系统和编程语言设想,把devops和hypersior集成到os和 在前面《云APP,virtual appliance:unikernel与微运行时的绝配,统一本地/分布式语言与开发设想》和《一种设想:为linux建立一个微内核,融合OS内核与语言runtime设想》中,我们都讲到“语言机制与OS机制一一对应的运行时”的思想,这些属于平台与语言连接处的联系对于编程学习至关重要,直接影响着你在这个OS上学LANG写APPDEV的曲线,(正如“业务逻辑与APP编程”处的连接一

minlearn's techrepos 2157
上一篇: MyBatis-Plus 实战教程三 拓展插件
下一篇: rcore 笔记 批处理系统 邓氏鱼
过去日记
过去日记 新星创作者: 后端开发技术领域 新星创作者: 后端开发技术领域
博客等级 码龄3年 5343粉丝 225原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

过去日记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值