ToB企服应用市场:ToB评测及商务社交产业平台

标题: 使用rust自制操作系统内核 [打印本页]

---

作者: 刘俊凯    时间: 2024-9-19 22:56
标题: 使用rust自制操作系统内核
一、系统简介

本操作系统是一个使用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常用的一个功能就是“管道”，这个也是进程间通信的一种方式之一。
本系统计划好管道，可以用于多个进程间通信。好比下面的命令：

1. > cat main.rs | grep main

复制代码

main.rs是一个文本文件，我输出到管道，然后经过grep过滤后输出到屏幕
 
在本系统中，运行效果是这样的：
 

 
还可以多级管道，如下图所示：
 

 
这里管道的实现紧张有一下焦点点：

• 阻塞队列（进程间通信协调）
  
• 重定向文件描述符（齐备都是文件）
  

 
关于更多的细节实现，可以看下面的焦点功能先容。
二、*项目焦点功能先容

下面我来带各人过一下整个项目的团体功能，不会太详细（具体详细的内容可以见我写的文档）。
 
本篇文章就作为一个目次，带着过一下本系统的焦点计划，当然不敷全面，但是可以大概知道本系统实现了哪些功能。
如果想看最全面的讲解可以看我写的 合集文档：
此处为语雀内容卡片，点击链接查察：自制操作系统 · 语雀
 
1. 物理结构

1.1. 硬盘结构

首先，我们有两块硬盘：

• hd60M.img
  
• hd80M.img
  

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专门有这样的声明：

1. extern "x86-interrupt" fn handler(frame: InterruptStackFrame, error_code: u32) {
2.    
3. }

复制代码

这里把一个函数使用了extern "x86-interrupt"修饰了，那么这个函数就会自动保存停止的上下文。
 
但是对于系统调用，必须要清晰栈中的晚上的上下文数据，因此就不能使用这个extern "x86-interrupt"来保存了，而是只能手动保存上下文。这个等候后面系统调用再说。
但是这里我们要清除，当停止发生时，CPU自动保存了哪些上下文，可以看这篇文章：
此处为语雀内容卡片，点击链接查察：三、停止发生时的栈操作 · 语雀
 
别的停止的频率也是可以调解的，我们可以通过操作「可编程停止控制器」来调解停止的频率。这里就不细说了。
5. 内存管理

在写应用层程序的时候，经常要用到堆内存。好比C语言中的malloc来动态申请堆内存空间。我们本系统实现的「内存管理」模块，就是要提供一个口子，可以「动态申请」、「动态释放」内存空间。把内存操作的口子收拢，同一管理，这就是内存管理。
此处为语雀内容卡片，点击链接查察：一、内存结构回顾 · 语雀
此处为语雀内容卡片，点击链接查察：二、数据结构-位图 · 语雀
此处为语雀内容卡片，点击链接查察：三、位图的计划 · 语雀
此处为语雀内容卡片，点击链接查察：四、*管理内存 · 语雀
此处为语雀内容卡片，点击链接查察：五、细粒度管理内存 · 语雀
 
5.1. 内存空间的分别

而在我们在实现这个系统的过程中，更要完全把控好内存的使用。首先我们在实现操作系统的时候，操作内存分为两种内存操作：

操作内存范例	阐明
非管控的内存	首先内核代码本身加载到内存了，需要一个内存空间存放，这一块空间包罗了：       「内存管理模块」的元数据。好比内存管理的位图 内核的代码指令 内核页目次表、内核页表所在的空间 这部门空间不参与内存管理的动态分配（毕竟这是内存管理的元数据，没法参与管理）
内存管理的内存	剩下的就是被内存管理模块管控的内存，提供口子同一在这里申请和释放内存

先看我们如今的内存结构，如下图5-1所示：
 

我们可以看到如今宏观上的内存结构，可以分为这几个部门：

• 低端1MB
  

• 
  
  
  
  • 实模式下低端1MB空间，直接指定地址访问空间
    
  
  

• 内核页目次表、内核页表
  

• 
  
  
  
  • 固定内存地址访问，毕竟分页功能是要经过这个页表的映射的
    
  
  

• 剩下可用内存
  

• 
  
  
  
  • 用作实现「内存管理」的空间
    
  
  

 
我们先看下低端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特权级的不同
  

资源上的差异还好说，申请资源就是了，关键在于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的数据交换方式有三种：

• 程序查询
  
• 程序停止
  
• DMA
  

我们的系统要读取硬盘，那么也就是这三种方式。在前面的MBR、Loader中，读取硬盘使用的是程序查询，也就是读取硬盘的寄存器，如果数据没有准备好就轮询等候。
 
而如今我们的文件系统实现中，我们有了停止的功能，我们使用 程序停止的方式。这个其实就是 硬盘的PIO模式。
关于PIO模式的使用方法，可以看这篇文档：
https://wiki.osdev.org/ATA_PIO_Mode
这里就不细说了。
9.3. 文件系统的焦点计划

文件系统有点像内存管理 + 文件管理。在我看来文件系统有两个东西要管理：

• 管理硬盘的块（或者说扇区，使用LBA地址访问）
  
• 管理“文件”（这是一种抽象的概念）
  

对于“块”或者“扇区”的管理，我们可以跟内存管理一样使用「块位图」。
而对于“文件”的管理，我们就要引入新的数据结构和计划了。
 
别的我们的文件系统是要持久化保存的，以是跟其他的结构计划还不一样（只在内存里存在就行），我们文件系统计划的数据结构得保存到硬盘里。
这里我不多说了，直接放出文件系统计划后的结构，如下图9-2所示：
 

更加详细的讲解可以看这里：
此处为语雀内容卡片，点击链接查察：四、*文件系统的概要计划(精华) · 语雀
 
9.4. 文件系统的目的

文件系统是一个复杂的系统，在实现这个过程中，我们一定要明确我们要实现哪些功能，这样有目的地去做，才能高效地实现。
因此我找了一些作为一个 通例文件系统有的功能，然后列出要实现的需求：
此处为语雀内容卡片，点击链接查察：五、文件系统的需求 · 语雀
这样我们更加有目的性地去思考和计划。在我看来，我们的目的最焦点的无非一下几点：

• 文件操作：实现文件的增、删、改、查
  
• 目次操作：实现目次的增、删、改、查
  
• 目次和文件的层级关系
  

此中，最需要考虑和计划的就是「目次和文件的层级关系」。要想实现得优雅、扩展性高，是我们文件系统的亮点。
9.5. inode的计划

在明确文件系统的计划中，只要在我看来，需要明确三个焦点模块：

• 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 · 语雀
 
我们在这一步实现中，基本上把前面所学的都使用起来了，在我看来，本系统的系统交互，有一下几个焦点点：

• 实现fork创建进程
  

• 
  
  
  
  • 这也是多进程的开始，也是系统之间交互的底子支撑
    
  
  

• 从文件中加载用户程序
  

• 
  
  
  
  • 真正实现用户进程。把用户进程的二进制指令，从硬盘中加载到内存，然后跳转执行。乍一看很复杂，其实明确了程序的原理后，就很简单了。
    
  
  

• 管道和文件描述符的重定向
  

• 
  
  
  
  • 实现我们最常见的命令，并且实现进程间通信
    
  
  

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所示：
 

 
那么只要两个进程可以访问到同一个管道，那么这两个进程就可以通过管道来信息交互的，一个进程往管道里写数据，一个进程往管道里斲丧数据，并且这个管道是一个阻塞队列，可以包管生产者和斲丧者协调进行。
 
别的再搭配上 文件描述符的重定向，就可以实现我们很常用的的命令：

1. cat xxx.log | grep 2024 | grep main >> main.txt

复制代码

这个命令的实现思路是这样的，如下图10-9所示：
 

 
而在现实的原理中，我们做的其实是两件事情：

• 父进程创建管道，多个子进程共享管道。
  

• 
  
  
  
  • 这样看来一个管道就是一个生产者斲丧者模型，从而实现数据交换的目的
    
  
  

• 重定向文件描述符。
  

• 
  
  
  
  • 在不改动子进程指令本身的情况下，修改进程的文件描述符
    
  • 把进程的标准输入、标准输出文件描述符，修改为管道或者文件的文件描述，那么这个进程本来的标准输入和输出，就变成了对管道或者文件的操作
    
  
  

当我们把这两件事做好后，实现的效果就是如下图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
  

• 
  
  
  
  • 这两年出了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企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4