一、系统简介
本操作系统是一个使用rust语言实现，基于32位的x86CPU的分时操作系统。
项目地址（求star）：GitHub - CaoGaorong/os-in-rust: 使用rust实现一个操作系统内核
详细文档：自制操作系统 · 语雀
1. 项目特性
在本项目的实现上，我以为该项目有一下特性：
特性
| 阐明
| rust语言实现
| 市面上许多操作系统项目使用的C语言实现，我这里使用的rust实现，可以包管这个项目的代码由我手写实现。也表现了该项目的独特和新颖。
| 基于x86 CPU
| x86是市面上最常见的CPU，基于这种通用大众化的CPU，也能阐明本项目用到的知识的通用。
| 拥有OS的基本功能
| 本项目在实现操作系统的功能上，算得上是“麻雀虽小，五脏俱全”。基本操作系统的焦点功能都实现了：
- BIOS启动、Mbr引导、Loader加载内核
- 使用BIOS启动，Mbr引导操作系统，手写Loader 进入掩护模式、加载段描述符、开启分页
- 停止管理
- 实现各种停止：CPU异常停止、键盘停止、硬盘停止等等通例停止
- 内存管理
- 使用页表管理内存，实现进程的虚拟内存，进程独享4GB内存空间
- *线程和进程管理
- 实现内核线程和用户进程，此中包罗PCB的属性的计划，线程和进程的启动、执行，使命的管理、调理。
- 系统调用（基于停止）
- 在实现用户进程后，用户进程处于3特权级下，想调用内核高级功能就得通过系统调用。本系统实现了系统调用，让用户进程跟内核交互。
- *文件系统
- 本系统实现了一个最小化并且全面的文件系统，实现了文件、目次的层级结构，支持在文件系统对文件以及目次的 增、删、改、查。对于文件和目次的通例操作都有支持。并且支持从硬盘加载程序并且执行。
- Shell交互
- 本系统提供了Shell作为人跟系统交互的桥梁，在Shell读取命令然后执行。Shell实现了管道，支持多个进程间通信。
这里只是对系统的基本先容，详细的先容可以看下面更加详细的先容。
| mbr启动、Loader引导
| 本系统使用比较古老的BIOS启动，手写Mbr启动，并且手动实现Loader对系统进行引导。（mbr和loader均为rust实现）
| 没使用任何第三方crate
| 在市面上许多rust的系统引用了许多第三方的crate，好比blog_os和rCore os。本系统不使用任何第三方crate，全部功能都使用rust的core手动实现。
|
2. 项目结构先容
如下图是该项目的文件结构：
下面我挑几个重点的模块先容：
模块名称
| 模块范例
| 模块先容
| build
| makefile生成
| make之后生成的文件
| cat
| 用户程序（独立进程）
（写入到文件系统，然后shell可以加载成为一个进程运行）
| 自制的cat程序，把文件系统中的文本文件内容输出到控制台
| echo
| 自制echo程序，把echo命令跟着的字符串输出到控制台
| grep
| 自制grep程序，根据输入内容，进行过滤，然后输出到控制台
| common
| 操作系统内核 源码
| common包，loader、loader2、kernel都会用到的常用工具
| mbr
| mbr启动（16位），该模块就两个功能：
- 实现mbr规范，引导BIOS
- 加载loader（读取硬盘）
| loader
| loader启动（16位）：
- 加载选择子、打开GDT，进入掩护模式
- 加载loader2（读取硬盘）
| loader2
| loader2启动（32位）：
- 由于loader生成的指令是16位的，因此在进入掩护模式后，需要再进入到loader2执行
- 加载kernel（读取硬盘）
| kernel
| 进入内核的最终实现，包罗停止、内存管理、线程进程管理、文件系统等等操作系统焦点，都在这个模块
| rrt
| Rust RunTime library
| 我自制简单的用户程序运行时库，模拟了crt。为用户程序封装了_start入口和exit的调用。
| target
| cargo生成
| rust使用cargo生成的二进制文件。忽略
| tests
| 单元测试
| 在这个项目实现中，我写的简单的单元测试
|
3. 项目情况先容
这里我先容一下项目的开辟情况和运行情况。
开辟情况（最终是生成一个32位的基于x86的操作系统二进制文件）：
名称
| 值
| 版本信息
| 操作系统
| MacOS
| Ventura 13.0.1
| CPU
| Apple M1
|
| 编译器
| rustc
| - rustc 1.82.0-nightly (5aea14073 2024-08-20)
- binary: rustc
- commit-hash: 5aea14073eee9e403c3bb857490cd6aa4a395531
- commit-date: 2024-08-20
- host: aarch64-apple-darwin
- release: 1.82.0-nightly
- LLVM version: 19.1.0
| 包管理工具
| cargo
| - cargo 1.82.0-nightly (ba8b39413 2024-08-16)
- release: 1.82.0-nightly
- commit-hash: ba8b39413c74d08494f94a7542fe79aa636e1661
- commit-date: 2024-08-16
- host: aarch64-apple-darwin
- libgit2: 1.8.1 (sys:0.19.0 vendored)
- libcurl: 7.84.0 (sys:0.4.74+curl-8.9.0 system ssl:(SecureTransport) LibreSSL/3.3.6)
- ssl: OpenSSL 1.1.1w 11 Sep 2023
- os: Mac OS 13.0.1 [64-bit]
| 自动化工具
| make
| GNU Make 3.81
| elf文件二进制提取工具
| x86_64-linux-gnu-objcopy
| GNU objcopy (GNU Binutils) 2.41
| elf文件dump工具
| x86_64-linux-gnu-objdump
| GNU objdump (GNU Binutils) 2.41
|
运行情况（把这个x86的32位的操作系统镜像运行在虚拟机中）：
名称
| 值
| 情况版本信息
| 虚拟机
| qemu-system-x86_64
| QEMU emulator version 8.2.1
| 虚拟机2
| bochs
| Bochs x86 Emulator 2.8
|
这里不得不说rust的跨平台开辟能力太好了，我在Mac M1上开辟，生成一个 x86 的 ELF文件。然后在启动一个qemu虚拟机运行。
4. 项目运行效果
这里给各人展示一下我的操作系统的基本功能。
下面我从这几个方面来展示：
- 内置命令
- 文件系统操作
- 从文件系统加载进程
- Shell多进程通信（管道）
4.1. 内置命令
先看内置命令，如今我的系统内置了如下命令（排除文件系统操作和加载可执行文件）：
命令名称
| 命令用途
| 命令展示
| pwd
| 展示当前工作目次
|
| ps
| 查询当前的全部使命
|
| clear
| 清屏
| | ctrl + l快捷键
| 清屏
| | ctrl + u快捷键
| 删除当前行的输入
| |
这是一些底子并且跟功能无关的命令。下面请看我们使用操作系统中，最常用的文件系统相关的命令。
4.2. 文件系统命令
我们使用一个操作系统，最常用的一定是文件系统相关的命令，好比「文件的增、删、改、查」、「目次的增、删、改、查」。我在本系统中基本都实现了，如下表所示：
命令名称
| 命令用途
| 命令展示
| ls
| 展示当前目次下的全部文件。
|
这里的cat、grep是可执行文件
| ls -l
| 展示当前目次下的文件细节
|
file_type中，"-"表示普通文件，"d"表示文件夹
| cd
| 切换当前工作目次
|
| mkdir
| 在当前工作目次下，创建一个目次
|
| rmdir
| 删除某个目次名称
|
| touch
| 创建一个普通文件
|
创建了一个名为"file"的普通文件
|
看到这里可能会问，怎么没有读写文件的命令？我们一般使用cat命令读取文件，并且我们会使用echo hello > hello.txt来写入文件。
这个cat和echo命令是我写的用户程序，这种程序是属于从硬盘加载后作为进程执行的。因此这个放到下一节。
4.3. 从文件系统加载进程
上面讲的都是内置的命令，都比较简单而且固定。下面就是要从文件系统加载可执行程序执行了。
在上面讲项目结构中，我提到我实现了3个用户程序，作为小工具：
这三个小工具分别是：
- cat：把一个文件的内容输出到控制台
- echo：把命令后面跟着的字符串输出到屏幕
- grep：使用正泽匹配过滤输入，然后把过滤后的效果输出
本小结，我就展示cat和echo实现读、写一个文件。
命令名称
| 展示效果
| echo
|
我这里先创建「hello.txt」文件，然后把"hello"字符串写入到 hello.txt文件中
| cat
|
我这里使用cat命令，把hello.txt的文件内容输出
| ">"和">>"输出到文件
|
这里使用echo 和 ">>" 追加 数据到 hello.txt文件中
|
这里我简单展示了echo和cat的执行效果。
这里得留意，echo和cat是两个在文件系统的文件，这里表现出来的是 把 可执行文件 从文件系统加载到内存，然后成为一个独立的用户进程执行的过程。
4.4. Shell多进程通信（管道）
别的我们在Shell常用的一个功能就是“管道”，这个也是进程间通信的一种方式之一。
本系统计划好管道，可以用于多个进程间通信。好比下面的命令：
- > cat main.rs | grep main
在本系统中，运行效果是这样的：
还可以多级管道，如下图所示：
这里管道的实现紧张有一下焦点点：
- 阻塞队列（进程间通信协调）
- 重定向文件描述符（齐备都是文件）
关于更多的细节实现，可以看下面的焦点功能先容。
二、*项目焦点功能先容
下面我来带各人过一下整个项目的团体功能，不会太详细（具体详细的内容可以见我写的文档）。
本篇文章就作为一个目次，带着过一下本系统的焦点计划，当然不敷全面，但是可以大概知道本系统实现了哪些功能。
如果想看最全面的讲解可以看我写的 合集文档：
此处为语雀内容卡片，点击链接查察：自制操作系统 · 语雀
1. 物理结构
1.1. 硬盘结构
首先，我们有两块硬盘：
hd60M.img是一个60MB巨细的硬盘。它的作用是存放操作系统的，这个硬盘没有分区，是一个裸硬盘。
hd80M.img是一个80MB巨细的硬盘。它的作用是给我们系统存放文件系统的，这个硬盘经过了分区。
先看hd60M.img硬盘的结构，如下图2-1所示：
hd60M.img存放了操作系统的焦点指令二进制文件：mbr、loader、loader2、kernel。他们占用的扇区巨细在图中也标记出来了。
下面我们再看看hd80M.img的结构，我们的hd80M.img是一个有分区结构的硬盘，如下图2-2所示：
我们的文件系统，只用此中的一个分区。
1.2. 模块的结构
再说到本系统的模块结构，按照他们在硬盘的结构和位置，我把本系统分为了如下几个焦点模块：
- mbr
- loader
- loader2
- kernel
- 硬盘中的用户进程（好比我自己写的cat、grep等小工具）
这几个模块，在硬盘的结构上，是这样的一种结构，如下图2-3所示：
可以看到我们按照物理结构来分别，把他们所在硬盘的位置，以及如何加载到内存做了描述。
下面我们就从这个系统的计划和逻辑结构上来讲解这个系统。
2. 系统团体架构
先看这个系统的团体架构，从全局的视角看一下这个项目的全景，如下图2-1所示：
要想一幅图画清晰全部的细节和交互是不可能的，我这里只能挑选出最常用而且容易表现出来的部门，只管画在一张图里。
本系统把kernel模块的代码从硬盘加载到内存中，放在低端1MB中（实模式可以访问的1MB），如下图2-5所示：
为什么放在低端1MB呢？因为低端1MB是开启分页后仍然可以访问的空间（内核页表映射到了）。这里的空间我们可以直接指定内存地址直接访问。
1MB以上的大部门空间，我们都作为操作系统的堆空间（实现内存管理后，动态申请和释放），是不能恣意指定地址直接访问的。
下面我分具体的模块来把最焦点的功能先容一下。
3. 系统引导：Mbr、Loader、Loader2
我们的焦点在操作系统内核的计划，因此对于加载内核前面的引导部门，我们尽快过一下。
还是看这个硬盘的结构图：
我们可以看到mbr、loader、loader2所在硬盘的位置，最终目的就是把kernel从硬盘中加载到内存。
下面我简单说一说这几个引导程序的作用：
模块
| 作用
| mbr
| 在我看来有两个作用：
- 标识当前硬盘或者分区有操作系统。（固定在首个扇区，并且以0x55AA末端）
- 加载loader。把loader从硬盘中加载出来
| loader
| 在我的系统计划中，有两个作用：
- 进入掩护模式，开启32位。
- 加载loader2（我特意计划的，因为当前的loader是16位的，在加载中存在一些问题）
| loader2
| 这里已经是给加载内核做准备了，焦点作用就是「打开分页」以及「加载内核」，具体作用如下：
- 构建内核的页目次表（在本系统的计划中，内核的页目次表固定放在0x100000，也就是1MB以上）
- 加载页目次表（加载到GDTR寄存器）
- 打开分页
- 加载kernel
|
引导部门我们不说太详细，在我看来，引导程序最焦点的就是要：
- 进入掩护模式、构建页目次表打开分页
- 加载kernel
此中，分页开启后，最终是构建了一个内核页目次表，如下图3-2所示：
下面就开始先容我们系统的焦点计划。
4. 停止管理
我们进入内核后，先要做的就是实现停止处理程序，接收停止。当CPU抛出一些异常（好比General Protection Exception、Page Fault）的时候，我们就可以通过停止处理程序的触发，立马知道有停止发生。
关于停止的计划我不再细说，可以看我本仓库写的文章：
此处为语雀内容卡片，点击链接查察：一、停止先容 · 语雀
此处为语雀内容卡片，点击链接查察：二、停止描述符 · 语雀
此处为语雀内容卡片，点击链接查察：三、停止发生时的栈操作 · 语雀
这里我们简单讲一下停止发生到执行停止处理程序的原理，如下图4-1所示：
下面我简单先容一下我的这个系统实现了的停止处理程序：
停止处理程序
| 停止范例
| 执行的操作
| general protection
| CPU异常
关于异常可以看这里：Exceptions - OSDev Wiki
| 通用掩护异常。通常是低特权级下访问高级资源
| double fault
| 一般是在停止处理程序里发生异常。以是异常“double”了
| page fault
| 一般是访问一个页表没有映射的内存，以是找不到页
| invalid code
| 指令非法。遇到过，一般是编译有点问题。
| 时钟停止
| 硬件停止
| 定时触发，停止的频率可以设置
| 键盘停止
| 键盘按下，生成扫描码
| 主ATA通道停止
| 硬盘信号停止
| 次ATA通道停止
| 硬盘信号停止
| 系统调用停止0x80
| 软件停止
| 代码指令中使用int指令发起停止
|
在实现停止处理程序中，停止发生到跳转执行停止处理程序，这个过程是根据停止描述符表来的，我们不消过多关心。
我们的停止处理程序关键的就是在于要清晰如何保存上下文，此中停止发生有的上下文是CPU给保存了的，但是有的需要自行保存。这个停止上下文的保存，如果使用rust实现，就简单了许多，因为rust专门有这样的声明：
- extern "x86-interrupt" fn handler(frame: InterruptStackFrame, error_code: u32) {
-
- }
但是对于系统调用，必须要清晰栈中的晚上的上下文数据，因此就不能使用这个extern "x86-interrupt"来保存了，而是只能手动保存上下文。这个等候后面系统调用再说。
但是这里我们要清除，当停止发生时，CPU自动保存了哪些上下文，可以看这篇文章：
此处为语雀内容卡片，点击链接查察：三、停止发生时的栈操作 · 语雀
别的停止的频率也是可以调解的，我们可以通过操作「可编程停止控制器」来调解停止的频率。这里就不细说了。
5. 内存管理
在写应用层程序的时候，经常要用到堆内存。好比C语言中的malloc来动态申请堆内存空间。我们本系统实现的「内存管理」模块，就是要提供一个口子，可以「动态申请」、「动态释放」内存空间。把内存操作的口子收拢，同一管理，这就是内存管理。
此处为语雀内容卡片，点击链接查察：一、内存结构回顾 · 语雀
此处为语雀内容卡片，点击链接查察：二、数据结构-位图 · 语雀
此处为语雀内容卡片，点击链接查察：三、位图的计划 · 语雀
此处为语雀内容卡片，点击链接查察：四、*管理内存 · 语雀
此处为语雀内容卡片，点击链接查察：五、细粒度管理内存 · 语雀
5.1. 内存空间的分别
而在我们在实现这个系统的过程中，更要完全把控好内存的使用。首先我们在实现操作系统的时候，操作内存分为两种内存操作：
操作内存范例
| 阐明
| 非管控的内存
| 首先内核代码本身加载到内存了，需要一个内存空间存放，这一块空间包罗了：
- 「内存管理模块」的元数据。好比内存管理的位图
- 内核的代码指令
- 内核页目次表、内核页表所在的空间
这部门空间不参与内存管理的动态分配（毕竟这是内存管理的元数据，没法参与管理）
| 内存管理的内存
| 剩下的就是被内存管理模块管控的内存，提供口子同一在这里申请和释放内存
|
先看我们如今的内存结构，如下图5-1所示：
我们可以看到如今宏观上的内存结构，可以分为这几个部门：
- 固定内存地址访问，毕竟分页功能是要经过这个页表的映射的
我们先看下低端1MB的结构，如下图5-1所示：
可以看到，我们把kernel的指令部门，都加载到低端1MB中，在这低端1MB是不被内存管理管控的，指定内存地址就可以访问（得益于这一块空间的页表映射，因此物理地址跟虚拟地址是一样的）。
我们把内存确定好后，空间的分别就成了这个样子，如下图5-3所示：
5.2. 内存管理的计划与实现
在上面图中，我们说了哪些内存空间是可以被操作系统用来实现内存管理的，如今我们就要对这部门空间进行同一管理，要求做到 同一动态申请、同一动态释放。
其实这个实现原理也很简单，就是使用位图。用位图来构建一个内存池，位图的某一位，就代表该池子中某一块内存使用与否。如下图5-4所示：
而我们现实上可以把要管理的内存，也分为了好几种：
- 内核物理内存池。内核线程申请内存空间，同一从这个池子里申请。
- 用户物理内存池。用户进程申请内存空间，从这个池子里申请。
- 每个进程有自己的页表，有自己的虚拟地址范围，因此每个进程需要一个虚拟地址池
在本系统中，这些池子的细节，我们可以看下表：
内存池名称
| 范例
| 代表的地址范围
| 位图地址
| 内核物理内存池
| 物理内存池
| [0x200000, 0x11000000)
总15MB 物理内存
| [0x9A000, 0x9A1E0)
总480 bytes
| 用户物理内存池
| [0x11000000, 0x2000000]
总15MB 物理内存
| [0x9A1E0, 0x9A3C0)
总480 bytes
| 内核虚拟地址池
| 虚拟地址池
| [0xC000 0000, 0xC0F0 0000)
总15MB，逻辑上虚拟的
| [0x9A3C0, 0x9A5A0)
总480 bytes
| 用户虚拟地址池
(每个用户进程都有1个)
| [0x8048000, 0xC000 0000)
约总2.88GB，逻辑上虚拟的
| 动态申请的地址
总92KB（23页）
|
最终构建的内存池的效果如下图5-5所示：
关于更多内存池的细节，可以看我写的这篇文章：
此处为语雀内容卡片，点击链接查察：四、*管理内存 · 语雀
5.3. 细粒度的内存管理实现（依靠进程/线程的实现）
上面我们讲了内存管理的底层数据结构就是用的「位图」，我们位图的1个位，就表示了4KB空间的使用与否。
这样粒度明显太大了，在上层使用的的时候，并不会这么大的粒度分配，而更多的是按照字节分配。
因此把申请到的1页空间，封装成一个Arena的结构，然后“切碎”成许多小的MemBlock，然后把没用完的MemBlock串起来，放到申请内存的这个使命中。如下图5-6所示：
然后把这些小块MemBlock组成链表，串起来，如下图5-7所示：
最后把这些剩下的MemBlock按照规格的分别，放到“申请内存的这个使命”的PCB里，下次申请就直接从这个MemBlock队列内里取，如下图5-8所示：
这样下次该使命再申请内存空间的时候，会先从自身使命拥有的MemBlock列表中去匹配合适规格的MemBlock，直接从这里申请。而不再从内存管理中的位图申请。
6. 内核线程
我们把希望盘算机做的一件事情，抽象成“使命”，那么每个“使命”都有自己的元信息，这个就是TaskStruct。
我们还希望多个使命可以切换，那么我们只需要把TaskStruct跟对应的上下文资源绑定，并且在切换使命的时候，保存和恢复上下文资源，就可以做到让一个执行中的程序“暂停”和“继承”的效果。
在本节中，我们讲一讲内核线程的实现，用户进程我们放到下一讲。细节的可以看我写的这些内容：
此处为语雀内容卡片，点击链接查察：一、如何明确进程/线程 · 语雀
此处为语雀内容卡片，点击链接查察：二、使命切换的原理 · 语雀
此处为语雀内容卡片，点击链接查察：三、使命队列 · 语雀
此处为语雀内容卡片，点击链接查察：四、创建内核线程 · 语雀
此处为语雀内容卡片，点击链接查察：五、线程切换 · 语雀
当我们明确了程序的执行原理，以及用到的资源（栈空间、寄存器资源），那么我们也能明确，只要把这些资源保存起来，然后切换使命，就可以做到“暂停”这个使命，然后还可以恢复执行。
而我们线程切换，就是保存上下文资源和恢复上下文资源的过程，如今一个程序，我们用到的就是寄存器资源（栈地址也是寄存器中），因此，只要我们把寄存器资源保存到一块内存空间就好了，我们把它保存到栈中。
好比我们要从使命A切换到使命B，那么我们先保存使命A的寄存器资源，如下图6-1所示：
保存完毕后，我们把当前使用的栈（ESP寄存器）切换到使命B的栈地址（记录在使命B的TaskStruct中），如下图6-2所示：
然后再恢复使命B栈内的寄存器资源，如下图6-3所示：
这样以往，我们就实现了保存和恢复某个使命的上下文资源。
但是在一个线程首次执行的时候，则需要自己构建这个线程的上下文资源，然后让esp指向这个构建好数据栈空间，然后走「恢复上下文」的逻辑，从而做到切换的效果。
这个就轻微复杂一点，可以看我写的这篇文章：
此处为语雀内容卡片，点击链接查察：四、创建内核线程 · 语雀
其实原理也简单，就是使用恢复上下文切换线程的这个原理和流程，我们创建好TaskStruct后，自己填充这个使命的栈数据，然后恢复上下文，从而实现切换使命。
7. 用户进程
我们上面实现了内核线程后，下面就要实现用户进程。用户进程的实现比内核线程要复杂一些。
关于用户进程跟内核进程的关系如下图7-1所示：
关于实现用户进程和内核线程，底层逻辑焦点的区别有以下几点：
| | 内核线程
| 用户进程
| 运行时所处的特权级
| 0级
| 3级（停止处理程序时是0级）
| 使命PCB
| 申请1页（内核空间）
| 申请1页（内核空间）
| 虚拟地址池
| 全部内核线程共用一个虚拟地址池
总可用虚拟地址的范围是：
[0xC001 0000, 0xFFFF FFFF]
| 每个进程有各自的虚拟地址池
每个地址池的地址范围是：[0x804 8000, 0xC000 0000)
| 页表
| 全部内核线程共用一个页目次表
| 每个用户进程有各自的页目次表
| 栈空间分布
| 只有0级栈(跟PCB共用1页)
|
- 0级栈(PCB共用1页)
- 3级栈(单独申请1页用户空间作为3级栈)
| 栈空间的使用
| 停止和非停止都使用1个栈，被执行时需要把0级栈地址放到TSS
| 非停止执行时使用3级栈
停止发生时使用0级栈
|
以上对比了内核线程和用户进程在实现上的异同，对比项可以分为两大类：
资源上的差异还好说，申请资源就是了，关键在于CPU特权级，我们如何让用户进程运行在3特权级下。
关于用户进程，我也不细讲了，详细的细节可以看我写的这几篇文章：
此处为语雀内容卡片，点击链接查察：一、用户进程 · 语雀
此处为语雀内容卡片，点击链接查察：二、*使命切换的栈操作 · 语雀
此处为语雀内容卡片，点击链接查察：三、实现用户进程的常见问题 · 语雀
此处为语雀内容卡片，点击链接查察：四、进程拥有的资源 · 语雀
要明确用户进程的难点，我以为要捉住用户进程的要点，这个要点就是「特权级」。
我们计划出用户进程，就是限制这个使命在操作上的安全性，因此特权级就是实现用户进程最大的要点。
7.1. 停止和特权级
我们系统启动，特权级处于0级下，处于最高级。
我们前面在讲停止的时候，就说到停止发生的时候，CPU会保存上下文，提升特权级，然后停止退出，就会恢复上下文，降低特权级。我们要实现用户进程在低特权级下运行，就要使用停止的退出。
因此，要想使用好停止退出，我们必须明确停止发生和结束时，栈内数据的完备变革，这个可以看我签名讲过的文章：
此处为语雀内容卡片，点击链接查察：三、停止发生时的栈操作 · 语雀
当CPU发生停止，会保存寄存器上下文，那么栈中的数据就是这样的，如下图7-2所示：
当停止恢复的时候，CPU也会自动从栈中的这个数据来恢复寄存器的值。此中就包罗了eip的值，也就是当上下文恢复eip的值，就会实现跳转。
以是我们要使用好栈内上下文数据，恢复时的跳转属性，来到达跳转执行用户程序的目的。
我们创建好一个用户进程的TaskStruct，通过填充栈信息，如下图7-3所示：
此中我们把栈的数据逻辑分别为了两个栈：
- CPU发生停止时自动压栈和出栈。我们通过填充这个栈的数据，然后停止退出，从而到达跳转的目的。
- 这是为了兼容停止处理程序发生后，手动压栈的数据。
- 内核线程切换和启动的时候，就是使用的这个栈的数据，因此我们用户进程也要兼容。
7.2. 用户进程的启动和切换
当我们构建好用户进程TaskStruct的栈数据（停止栈和线程栈）之后，我们就可以来通过“恢复上下文”的方式来跳转，并且使用iret停止退出的指令，来实现特权级降低和指令跳转功能。
这个过程如下图7-4所示：
随着栈内上下文数据的弹出：
- 先弹出「线程栈」，恢复了一些通用寄存器的上下文，这些是停止处理程序会保存和恢复的上下文数据。
- 然后使用iret指令，CPU自动弹出「停止栈」，恢复EIP寄存器的值后跳转，以及降低特权级到3级
当我们可以或许在低特权级下执行某个使命，那么也就是实现了用户进程了。
8. 系统调用
此处为语雀内容卡片，点击链接查察：一、什么是系统调用 · 语雀
此处为语雀内容卡片，点击链接查察：二、如何实现系统调用 · 语雀
此处为语雀内容卡片，点击链接查察：三、*系统调用的全链路分析 · 语雀
我们在低特权级下想要访问高特权级的资源（好比执行某些特权指令），那么就必须使用系统调用（提升了特权级）。如下图8-1所示：
关于系统调用的实现，我这里使用了停止来实现。具体系统调用的细节就不细说了（发现本篇文章我写的内容太多了）。
建议看我写的这篇精华文章，很细节：
此处为语雀内容卡片，点击链接查察：三、*系统调用的全链路分析 · 语雀
9. 文件系统
一个操作系统最直观的入口，其实就是文件系统，好比我们登录Linux一定要操作文件，好比使用ls、cd等命令都是文件系统的命令。
但是其实文件系统是跟操作系统耦合性最小的，在我看来，操作系统更方向底层， 而文件系统其实方向计划：
- 好比上面讲的操作系统许多概念好比全局描述符表、页表、停止等等，都跟硬件强相关。
- 而文件系统硬件相关的只有读写硬盘，并且这个完全可以封装成一个驱动层。剩下的就全是“文件”的计划，好比“文件如何存储”、“文件和目次的关系”、“文件如何CRUD”等等。更加方向应用层的计划
此处为语雀内容卡片，点击链接查察：一、硬盘和分区结构 · 语雀
此处为语雀内容卡片，点击链接查察：二、硬盘的操作(PIO模式) · 语雀
此处为语雀内容卡片，点击链接查察：三、什么是文件系统 · 语雀
此处为语雀内容卡片，点击链接查察：四、*文件系统的概要计划(精华) · 语雀
此处为语雀内容卡片，点击链接查察：五、文件系统的需求 · 语雀
此处为语雀内容卡片，点击链接查察：六、inode的详细计划 · 语雀
此处为语雀内容卡片，点击链接查察：七、目次项的计划 · 语雀
此处为语雀内容卡片，点击链接查察：八、文件的打开结构(文件描述符) · 语雀
9.1. 分区结构
在明确文件系统之前，我们要先可以或许操作硬盘。那么我们就得明确分区。
分区就像给硬盘格式化，让硬盘有一个基本的格式信息。“分区”这种结构是市面上各人都服从一种结构。这里分区的结构也不细说了，可以见如下图9-1所示：
更多的可以看这里：
此处为语雀内容卡片，点击链接查察：一、硬盘和分区结构 · 语雀
9.2. 硬盘操作：PIO模式
在大学中我们学盘算机组成原理，都学过主机I/O的数据交换方式有三种：
我们的系统要读取硬盘，那么也就是这三种方式。在前面的MBR、Loader中，读取硬盘使用的是程序查询，也就是读取硬盘的寄存器，如果数据没有准备好就轮询等候。
而如今我们的文件系统实现中，我们有了停止的功能，我们使用 程序停止的方式。这个其实就是 硬盘的PIO模式。
关于PIO模式的使用方法，可以看这篇文档：
https://wiki.osdev.org/ATA_PIO_Mode
这里就不细说了。
9.3. 文件系统的焦点计划
文件系统有点像内存管理 + 文件管理。在我看来文件系统有两个东西要管理：
- 管理硬盘的块（或者说扇区，使用LBA地址访问）
- 管理“文件”（这是一种抽象的概念）
对于“块”或者“扇区”的管理，我们可以跟内存管理一样使用「块位图」。
而对于“文件”的管理，我们就要引入新的数据结构和计划了。
别的我们的文件系统是要持久化保存的，以是跟其他的结构计划还不一样（只在内存里存在就行），我们文件系统计划的数据结构得保存到硬盘里。
这里我不多说了，直接放出文件系统计划后的结构，如下图9-2所示：
更加详细的讲解可以看这里：
此处为语雀内容卡片，点击链接查察：四、*文件系统的概要计划(精华) · 语雀
9.4. 文件系统的目的
文件系统是一个复杂的系统，在实现这个过程中，我们一定要明确我们要实现哪些功能，这样有目的地去做，才能高效地实现。
因此我找了一些作为一个 通例文件系统有的功能，然后列出要实现的需求：
此处为语雀内容卡片，点击链接查察：五、文件系统的需求 · 语雀
这样我们更加有目的性地去思考和计划。在我看来，我们的目的最焦点的无非一下几点：
- 文件操作：实现文件的增、删、改、查
- 目次操作：实现目次的增、删、改、查
- 目次和文件的层级关系
此中，最需要考虑和计划的就是「目次和文件的层级关系」。要想实现得优雅、扩展性高，是我们文件系统的亮点。
9.5. inode的计划
在明确文件系统的计划中，只要在我看来，需要明确三个焦点模块：
一个文件一定要包含数据，不然这个文件毫无意义。
此中inode描述的是一个文件的数据的元信息，好比某个文件包含的数据，分布在哪些地方。
因此，inode结构中最焦点功能就是 表明这个文件的数据内容 在哪些扇区，也就是如下图9-3所示：
这里inode的数据扇区i_sectors是一个数组，长度是有限的，要是文件的长度凌驾这个怎么办呢？因此我们有了二级索引，如下图9-4所示：
我们通过设置i_secotors的最后一项的值指向的是间接块的LBA地址，然后该块的全部数据又指向新的LBA块。
这样间接块的计划，那么一个inode就可以包含多个数据块了（如果不敷甚至可以再增长一级间接块）。关于inode的计划，详细的可以看我写的这篇文章：
此处为语雀内容卡片，点击链接查察：六、inode的详细计划 · 语雀
9.6. 文件、目次和目次项的计划
在实现文件系统中，目次和文件是存在层级关系的，但是目次和文件这两种范例，我们都抽象明确为“文件”。
在计划上，我们不区分「目次」跟「普通文件」，他们都有自己的inode指向对应的数据区。那么怎么区分一个文件到底是「目次」还是「普通文件」呢？我们使用「目次项」的结构。
目次项记录一个“文件”的名称、范例、inode号。而根据inode号就可以找到inode，就可以找到当前“文件”包含的数据区。
- 这里的“文件”可以是普通文件，也可以是目次
- inode的数据区，如果是普通文件，那么数据区内里是这个文件的二进制数据。如果是目次文件，那么这个inode的数据区是许多的目次项。
因此有了目次项、inode、目次、普通文件的计划，他们如今的关系如下图9-5所示：
关于更多他们关系的讲解，可以看我写的这篇文章：
此处为语雀内容卡片，点击链接查察：七、目次项的计划 · 语雀
此处为语雀内容卡片，点击链接查察：为什么inode和目次项要分开存储？ · 语雀
9.7. 文件描述符
每个进程都可以打开一个文件，并且可以重复打开文件。并且打开之后，同一个文件的两个打开结构，互不干扰。好比vscode浏览器到这个文件的第100字节，而edge浏览到这个文件的第300字节。两者互相独立。
那么关于打开一个文件，我们可以得出以下结论：
- 同一个文件可以被打开多次
- 同一文件打开多次后，可以处于不同的偏移量
- 打开后，可以进行的操作，好比读、写权限
因此，我们打开一个文件后，应该需要一个结构来描述这个文件的“打开结构”，相对于inode和目次项的结构，这是一种动态结构（同一个文件，但是偏移量不同）。
因此，我们可以把这些 「打开的文件结构」同一放到一起，组成一个「文件结构表」，如下图9-6所示：
我们可以看到：
- OpenedInode是描述的一个文件的静态属性，好比文件所在的地方、文件数据的内容
- File（文件结构）描述的是文件的动态属性，此中file_off描述了这个文件操作的偏移量
- 如果多次打开一个文件，那么OpenedInode是同一个，但是会有不同的File文件结构。（因为不同的打开偏移量不同）
上面的「文件结构表」是整个系统全局的，而我们每个进程应该拥有自己独立的操作的文件，因此我们抽象出「文件描述符」的结构：
- 每个使命的TaskStruct有个「文件描述符数组」，这个数组的值就是「文件结构表」的下标。
- 每个进程的「文件描述符」就是「文件描述符数组」的下标。
也就是「文件描述符」定位到「文件描述符数组」的元素，再定位到「文件结构表」中的文件结构，然后再定位到「具体的文件（包罗偏移、inode）」，这个过程如下图9-7所示：
当我们完成文件的计划，特殊是目次项、目次、文件的层级关系的计划，以及inode的理念，我们就基本上已经完成了我们最终的文件系统了。
剩下的操作好比「对文件增、删、改、查」和「对目次的增、删、改、查」都只要按照这个计划来，填凑数据和查询数据就好了。
10. 系统交互
最后一步就是实现系统交互的，我们的系统基本上实现得大差不差了，我们Shell的作用只是锦上添花。关于系统交互上，详细计划可以看下面我写的文章：
此处为语雀内容卡片，点击链接查察：一、fork系统调用的实现 · 语雀
此处为语雀内容卡片，点击链接查察：二、Shell的底子实现 · 语雀
此处为语雀内容卡片，点击链接查察：三、实现从文件系统加载并且运行程序 · 语雀
此处为语雀内容卡片，点击链接查察：四、运行用户程序支持参数 · 语雀
此处为语雀内容卡片，点击链接查察：五、*Shell支持管道 · 语雀
此处为语雀内容卡片，点击链接查察：五、系统调用exit和wait · 语雀
我们在这一步实现中，基本上把前面所学的都使用起来了，在我看来，本系统的系统交互，有一下几个焦点点：
- 真正实现用户进程。把用户进程的二进制指令，从硬盘中加载到内存，然后跳转执行。乍一看很复杂，其实明确了程序的原理后，就很简单了。
10.1. fork进程
实现进程的fork功能，几乎是后面实现多进程以及管道的前提。也是明确我们在应用层编码中多线程的紧张一环。
我在这里简单说一说fork的实现，具体的可以看我写的这篇文章：
此处为语雀内容卡片，点击链接查察：一、fork系统调用的实现 · 语雀
所谓fork，其实就是把当进步程拥有的资源全部拷贝一遍（深拷贝），那么一个进程拥有哪些资源呢？我们可以看如下图10-1所示：
剩下的就是要拷贝进程拥有的资源了，好比「TaskStruct」、「停止栈」、「文件描述符表」这些都好说，关键复杂的在于「拷贝一个进程的堆内存空间」。
因为拷贝进程的堆内存空间，也就意味着要完备拷贝的页表映射关系。
好比进程A fork出了进程B，进程A的资源X复制了一份得到资源X'。那么fork后，进程A通过地址0x1234到资源X，那么进程B也要通过地址0x1234访问到资源X'。
也就是效果是如下图10-2所示的：
根据上图10-2，我们把进程的堆内存指向的某个物理空间进行了数据拷贝，但是使用虚拟地址访问的时候，虚拟地址要相同。
要实现这个效果，我们就处理起来比较麻烦了，这个拷贝流程如下图10-3所示：
关于fork这个过程其实并不简单，建议还是看看我写的文章：
此处为语雀内容卡片，点击链接查察：一、fork系统调用的实现 · 语雀
10.2. 从文件系统加载程序运行
在上面进程管理中，我们可以实现把一个内核函数，封装成一个用户进程。
如今我们希望把一个程序从硬盘加载到内存，然后再作为用户进程执行。其实这个原理是一样的，不管程序是来自哪里，都是跳转到入口开始执行。
因此关键点在于，我们把一个程序的指令加载到内存，然后根据程序的入口地址封装成一个用户进程即可。
在通例操作系统的实现中，由于这个用户程序是其他操作系统生成的（好比在Linux），因此我们需要剖析ELF文件，然后提取出 二进制指令部门，然后加载到内存的某个地址。
这里我使用了一个比较取巧的方式，直接使用x86下32位的Linux的objcopy工具，直接把一个32位的elf文件中的指令二进制给提取出来了，然后再写入到我们自己操作系统的文件系统里，这个过程如下图10-4所示：
当我们的操作系统可以或许把用户程序的二进制加载到内存，并且知道这个程序在内存的入口地址之后，就可以根据这个封装成一个用户进程了，这个过程如下图10-5所示：
这个加载用户进程并且执行的过程，其实本质上跟前面进程管理，把一个函数封装成用户进程 没有区别，因为我们只需要知道一个程序的在内存的入口地址，就可以实现跳转执行指令了。
关于这个过程的更多细节，可以看我写的这篇文章：
此处为语雀内容卡片，点击链接查察：三、实现从文件系统加载并且运行程序 · 语雀
10.3. Shell支持管道
在使用操作系统时，我们经常使用到管道，并且管道是一个很好的进程间通信的方式。
因此本系统中也要支持管道，并且要优雅的地支持管道功能。
在本系统中，管道使用一个「阻塞队列」来实现，阻塞队列如下图10-6所示：
本系统中支持管道的实现，并且管道也使用文件描述符来访问，也就是如今文件描述符和管道的关系是这样的，如下图10-7所示：
也就是文件描述符有了范例，既可以访问文件，也可以访问管道，还可以访问标准输入和标准输出。
后面就知道这种计划的好处了。齐备皆是文件。
然后当我们的父进程创建管道，然后再fork出子进程，子进程就自动复制了父进程的文件描述符，那么子进程就也可以访问到管道了。这个结构如下图10-8所示：
那么只要两个进程可以访问到同一个管道，那么这两个进程就可以通过管道来信息交互的，一个进程往管道里写数据，一个进程往管道里斲丧数据，并且这个管道是一个阻塞队列，可以包管生产者和斲丧者协调进行。
别的再搭配上 文件描述符的重定向，就可以实现我们很常用的的命令：
- cat xxx.log | grep 2024 | grep main >> main.txt
而在现实的原理中，我们做的其实是两件事情：
- 这样看来一个管道就是一个生产者斲丧者模型，从而实现数据交换的目的
- 在不改动子进程指令本身的情况下，修改进程的文件描述符
- 把进程的标准输入、标准输出文件描述符，修改为管道或者文件的文件描述，那么这个进程本来的标准输入和输出，就变成了对管道或者文件的操作
当我们把这两件事做好后，实现的效果就是如下图10-10所示：
其实关于管道的实现和思考还有许多细节，具体的可以看我这篇文章：
此处为语雀内容卡片，点击链接查察：五、*Shell支持管道 · 语雀
10.4. 系统调用wait和exit
一个进程调用exit会退出，这个进程的资源会被销毁。
父进程调用wait会等候子进程，送子进程的“最后一程”。
这个过程有点像是fork的逆操作，把fork中用到梳理的资源，都给释放掉（包罗内存资源、文件资源、管道等等）。这里就不细讲了，可以看我写的这篇文章：
此处为语雀内容卡片，点击链接查察：五、系统调用exit和wait · 语雀
11. 其他
其实还有许多东西没有讲，我以为不是特殊焦点的计划，就算了。
- 如何实如今屏幕上打印字符，我们在文本模式下，往显存的区域按照规则写入ascii码即可。还有根据显卡控制器的规则，控制光标。
- 这个涉及到键盘的扫描码，读取键盘停止中的扫描码，然后再根据键的组合（通码、断码、shift键），来生成对应的ascii码。本系统中把ascii码存到了一个全局的阻塞队列中。
- 然后标准输入的话会从阻塞队列中读取数据，如果没有数据就会阻塞。
还有许多其实我觉得特殊有意思，但是不是本系统的焦点计划，并且限于篇幅没有写的。
12. 参考资源
《操作系统真象还原》
Writing an OS in Rust
Preface - The Embedonomicon
四、预测
1. 我为什么要实现这个操作系统
这个项目从我第一次提交到最后的结束，几乎耗时我5个月，满打满算的5个月。这5个月来，我几乎把全部的空余时间都花在了这个上面。每天除了上班，就是在写这个项目。
首先本系统是我三年前写的一个操作系统的延续：
GitHub - CaoGaorong/MyOS: To make an operating system from scratch
三年前我还在大学的时候，就开始想着写一个操作系统了，当时我是跟着书《操作系统真象还原》写的（使用的C语言），当时是大三，我也是几乎把全部空余时间都花在了这个上面。
但是由于时间不敷充裕，只有一个学期的时间，之后就要找工作了。以是只是跟着书上写，并且并没有完全写完（项目能跑，但是文件系统没有实现）。
在我上面三年前的仓库的readme中，最后一段我曾经说要继承写操作系统，并且补上文件系统，而且当时我就曾想过要用rust来实现。没想到时隔三年的今天，我都实现了，完善了文件系统 + rust实现。
今年我使用rust把这个操作系统重写、重新计划，我是有三个期望：
- 重新捡起我学过的操作系统（毕竟三年了，有点忘了）
- 更加深入完备学习操作系统（之前只是跟着书上看，并没有太多的调试履历，并且没有实现文件系统）
- 学习Rust语言，找个项目上手（虽然学得不多，但是确实对Rust更加了解了）
如今过了5个月，我把这个项目实现后，再回头看，还是很有成绩感了。
2. 在这个过程中，我遇到哪些问题
在五个月前，我刚开始有用rust重写这个系统的想法的时候，我是很夷由的，我最担心的就是这个项目流产，因为当时的我对操作系统是半吊子，rust更是只懂底子语法，许多的偏门用法（好比各种配置）都不会。
以是当时我是很怕这个项目做不完，特殊怕这个项目做一半，然后卡住了，后面一直解决不了从而放弃。
一开始我害怕中途卡住而流产，但是随着后面我遇到问题，解决问题，我渐渐地变得很有自信，我开始越来越刚强地相信我可以完成。也许是我不停遇到难题并且不停解决的这个过程让我变得信心十足。
除了解决了信心不刚强的问题，更多遇到的就是实打实操作系统和Rust相关的问题。非常多稀奇古怪的问题，特殊是操作系统这种底层软件（没有应用层开辟时的操作系统兜底），也很容易出现一些少见、并且难以解决的问题。
并且这些问题在市面上很难找到答案，好比操作系统相关的信息在网上就很少有资源，再配合上Rust又是一个比较新的语言，因此这两者在市面上都很少有相关的资料。
不过这些问题我最终还是都解决了，我基本从以下三个方面解决了我的问题：
- 不管是操作系统，还是Rust，外网的资料还是比较多的，有许多的资料可以借鉴
- 自制操作系统的项目有许多，可以参考计划。不过用Rust实现而且功能全的很少。
- 这两年出了ChatGPT确实让我的编程变得方便了许多，不管是遇到Rust还是操作系统的问题，我都可以问ChatGPT，虽然答案不一定可靠，但是还是给了我许多资助。
此中我遇到的更细节的问题，更是有不少，有一些我记录了下来：
此处为语雀内容卡片，点击链接查察：记录一次实现fork栈溢出导致的问题 · 语雀
此处为语雀内容卡片，点击链接查察：最古怪的问题 · 语雀
此处为语雀内容卡片，点击链接查察：QEMU重复启动 · 语雀
此处为语雀内容卡片，点击链接查察：mbr无法打印问题 · 语雀
此处为语雀内容卡片，点击链接查察：release profile编译优化配置 · 语雀
此处为语雀内容卡片，点击链接查察：loader的opt-level设置问题 · 语雀
此处为语雀内容卡片，点击链接查察：loader的lto设置问题 · 语雀
此处为语雀内容卡片，点击链接查察：加载GDT问题 · 语雀
此处为语雀内容卡片，点击链接查察：构建页表途中卡住问题 · 语雀
此处为语雀内容卡片，点击链接查察：突然不能打印了 · 语雀
此处为语雀内容卡片，点击链接查察：构建IDT死循环问题 · 语雀
此处为语雀内容卡片，点击链接查察：静态变量初始化为0值不对的问题 · 语雀
此处为语雀内容卡片，点击链接查察：函数调用却自动内联 · 语雀
还有更多我遇到的问题没有记录下来，在这个系统开辟的早期，经常遇到问题，有的是关于Rust语言一些特性的问题，随着我后面临Rust越来越熟练和了解，在本系统的后续开辟问题也变得越来越少。
3. 我后续会做哪些事情
这个项目确实一个大项目，耗费我的时间比较长。但是如果说商用价值，确实不大，假如说我去学习一下Java的应用技术、各种中央件、大数据可能更好找工作工作，能有更大的价值。
但是我做这个项目，确实能给我更大的满足感，就像锻炼完虽然很累但是又很爽的感觉。
昨晚这个项目，我的劳绩确实非常大，我花费五个月觉得非常值得，最紧张的是两点：
- 学习了Rust。并且学习的是底层原理（好比操作汇编、内存）
- 学习了操作系统。之前只是看，但是这次我自己实现，对操作系统、盘算机底层的感悟更加深刻了
以是其实还有许多我可以做的，包罗我所在公司的部门就有IM的业务，我想我如果我想深入学习IM，我可以在我的这个系统上实现一套IP/TCP协议栈，让我的操作系统实现网络的功能，这样应该会对IM的明确更加深入。
别的还有许多可以做的，好比对硬盘的操作，我一直想学习使用一下DMA（总是看到这个词，但是没有底层实现过，终归感觉不是完全了解）。还有好比操作系统的图形界面GUI，这个也比较炫酷。
总的来说，可以做的还有许多，我希望还能有机会，像这次一样，花费半年的时间来陶醉式地去做一件事情。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。 |
