Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
Miykael_xxm
RCore Tutorial Book V3
提交
96a76265
R
RCore Tutorial Book V3
项目概览
Miykael_xxm
/
RCore Tutorial Book V3
与 Fork 源项目一致
Fork自
rcore-os / RCore Tutorial Book V3
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
RCore Tutorial Book V3
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
前往新版Gitcode,体验更适合开发者的 AI 搜索 >>
提交
96a76265
编写于
11月 03, 2020
作者:
Y
Yifan Wu
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Update chapter1 2020-11-03
上级
3a12b68d
变更
10
展开全部
隐藏空白更改
内联
并排
Showing
10 changed file
with
718 addition
and
22 deletion
+718
-22
docs/_sources/chapter1/1app-ee-platform.rst.txt
docs/_sources/chapter1/1app-ee-platform.rst.txt
+81
-7
docs/_sources/chapter1/1remove-std.rst.txt
docs/_sources/chapter1/1remove-std.rst.txt
+52
-5
docs/_sources/chapter1/index.rst.txt
docs/_sources/chapter1/index.rst.txt
+1
-1
docs/chapter1/1app-ee-platform.html
docs/chapter1/1app-ee-platform.html
+360
-0
docs/chapter1/1remove-std.html
docs/chapter1/1remove-std.html
+44
-4
docs/chapter1/index.html
docs/chapter1/index.html
+3
-3
docs/objects.inv
docs/objects.inv
+0
-0
docs/searchindex.js
docs/searchindex.js
+1
-1
source/chapter1/1app-ee-platform.rst
source/chapter1/1app-ee-platform.rst
+175
-0
source/chapter1/index.rst
source/chapter1/index.rst
+1
-1
未找到文件。
source/chapter1/1remove-std.rs
t
→
docs/_sources/chapter1/1app-ee-platform.rst.tx
t
浏览文件 @
96a76265
移除标准库依赖
应用程序运行环境与平台支持
===========================
===========================
=====================
.. toctree::
.. toctree::
:hidden:
:hidden:
...
@@ -52,7 +52,11 @@
...
@@ -52,7 +52,11 @@
如下图所示,应用程序的运行需要下面一套运行环境栈的支持:
如下图所示,应用程序的运行需要下面一套运行环境栈的支持:
.. image:: app-software-stack.png
.. _app-software-stack:
.. figure:: app-software-stack.png
应用程序运行环境栈
图中的白色块自上而下(越往下则越靠近底层,下层作为上层的执行环境支持上层代码的运行)表示各级运行环境,黑色块则表示相邻两层运行环境之间
图中的白色块自上而下(越往下则越靠近底层,下层作为上层的执行环境支持上层代码的运行)表示各级运行环境,黑色块则表示相邻两层运行环境之间
的接口。
的接口。
...
@@ -70,9 +74,23 @@
...
@@ -70,9 +74,23 @@
``Hello, world!`` 用到了哪些系统调用?
``Hello, world!`` 用到了哪些系统调用?
从之前的 ``cargo run`` 的输出可以看出之前构建的可执行文件是在 target/debug 目录下的 os 。
在 Ubuntu 系统上,可以通过 ``strace`` 工具来运行一个程序并输出程序运行过程当中向内核请求的所有的系统调用及其返回值。
我们只需输入 ``strace target/debug/os`` 即可看到一长串的系统调用。
其中,真正容易看出与 ``Hello, world!`` 相关的只有一个系统调用:
.. code-block::
write(1, "Hello, world!\n", 14) = 14
其参数的具体含义我们暂且不在这里进行解释。
其余的系统调用基本上分别用于函数库和内核两层执行环境的初始化工作和对于上层的运行期监控和管理。之后,随着应用场景的复杂化,我们
需要更强的抽象能力,也会实现这里面的一些系统调用。
从硬件的角度来看,它上面的一切都属于软件。硬件可以分为三种: 处理器 (Processor) ——它更常见的名字是中央处理单元 (CPU, Central Processing Unit),
从硬件的角度来看,它上面的一切都属于软件。硬件可以分为三种: 处理器 (Processor) ——它更常见的名字是中央处理单元 (CPU, Central Processing Unit),
内存 (Memory) 还有 I/O 设备。其中处理器无疑是其中最复杂同时也最关键的一个。它与软件约定一套 **指令集
架
构** (ISA, Instruction Set Architecture),
内存 (Memory) 还有 I/O 设备。其中处理器无疑是其中最复杂同时也最关键的一个。它与软件约定一套 **指令集
体系结
构** (ISA, Instruction Set Architecture),
使得软件可以通过 ISA 中提供的汇编指令来访问各种硬件资源。软件当然也需要知道处理器会如何执行这些指令:最简单的话就是一条一条执行位于内存
使得软件可以通过 ISA 中提供的汇编指令来访问各种硬件资源。软件当然也需要知道处理器会如何执行这些指令:最简单的话就是一条一条执行位于内存
中的指令。当然,实际的情况远比这个要复杂得多,为了适应现代应用程序的场景,处理器还需要提供很多额外的机制,而不仅仅是让数据在 CPU 寄存器、内存和 I/O 设备
中的指令。当然,实际的情况远比这个要复杂得多,为了适应现代应用程序的场景,处理器还需要提供很多额外的机制,而不仅仅是让数据在 CPU 寄存器、内存和 I/O 设备
三者之间流动。
三者之间流动。
...
@@ -94,8 +112,64 @@
...
@@ -94,8 +112,64 @@
操作系统如 Windows/Linux/macOS 等的抽象都支持同时运行很多应用程序,在嵌入式场景是过抽象的。因此,常见的解决方案是仅使用函数库构建
操作系统如 Windows/Linux/macOS 等的抽象都支持同时运行很多应用程序,在嵌入式场景是过抽象的。因此,常见的解决方案是仅使用函数库构建
单独的应用程序或是用专为应用场景特别裁减过的轻量级内核管理少数应用程序。
单独的应用程序或是用专为应用场景特别裁减过的轻量级内核管理少数应用程序。
目标三元组
平台与目标三元组
--------------------
---------------------------------------
对于一份用某种编程语言实现的源代码而言,编译器在将其通过编译、链接得到目标文件的时候需要知道程序要在哪个 **平台** (Platform) 上运行。
从上面给出的 :ref:`应用程序运行环境栈 <app-software-stack>` 可以看出:
- 如果用户态基于的内核不同,会导致系统调用接口不同或者语义不一致;
- 如果底层硬件不同,对于硬件资源的访问方式会有差异。特别是 ISA 不同的话,对上提供的指令集和寄存器都不同。
它们都会导致最终生成的目标文件有很大不同。需要指出的是,某些编译器支持同一份源代码无需修改就可编译到多个不同的目标平台并在上面运行。这种
情况下,源代码是 **跨平台** 的。而另一些编译器则已经预设好了一个固定的目标平台。
我们可以通过 **目标三元组** (Target Triple) 来描述一个目标平台。它一般包括 CPU 架构、CPU 厂商和操作系统,它们确实都会控制目标文件的生成。
比如,我们可以尝试看一下之前的 ``Hello, world!`` 的目标平台是什么。这可以通过打印编译器 rustc 的默认配置信息:
.. code-block:: console
$ rustc --version --verbose
rustc 1.48.0-nightly (73dc675b9 2020-09-06)
binary: rustc
commit-hash: 73dc675b9437c2a51a975a9f58cc66f05463c351
commit-date: 2020-09-06
host: x86_64-unknown-linux-gnu
release: 1.48.0-nightly
LLVM version: 11.0
从其中的 host 一项可以看出默认的目标平台是 ``x86_64-unknown-linux-gnu``,其中 CPU 架构是 x86_64,CPU 厂商是 unknown,操作系统是 linux-gnu。
这种无论编译器还是其目标文件都在我们当前所处的平台运行是一种最简单也最普遍的情况。但是很快我们就将遇到另外一种情况。
讲了这么多,终于该介绍我们的主线任务了。我们希望能够在另一个平台上运行 ``Hello, world!``,而与之前的默认平台不同的地方在于,我们将 CPU 架构从
x86_64 换成 RISC-V。
.. note::
为何基于 RISC-V 架构而非 x86 系列架构?
x86 架构为了在升级换代的同时保持对基于旧版架构应用程序/内核的兼容性,存在大量的历史包袱,也就是一些对于目前的应用场景没有任何意义,但又必须
花大量时间正确设置才能正常使用 CPU 的奇怪设定。为了建立并维护架构的应用生态,这确实是必不可少的,但站在教学的角度几乎完全是在浪费时间。而
新生的 RISC-V 架构十分简洁,架构文档需要阅读的核心部分不足百页,且这些功能已经足以用来构造一个具有相当抽象能力的内核了。
可以看一下目前 Rust 编译器支持哪些基于 RISC-V 的平台:
.. code-block:: console
$ rustc --print target-list | grep riscv
riscv32i-unknown-none-elf
riscv32imac-unknown-none-elf
riscv32imc-unknown-none-elf
riscv64gc-unknown-linux-gnu
riscv64gc-unknown-none-elf
riscv64imac-unknown-none-elf
这里我们选择的是 ``riscv64gc-unknown-none-elf``,目标三元组中的操作系统是 none-elf,表明没有任何系统调用支持。这里我们之所以不选择有
linux-gnu 系统调用支持的版本 ``riscv64gc-unknown-linux-gnu``,是因为我们只是想跑一个 ``Hello, world!``,没有必要使用操作系统所提供的
那么高级的抽象。而且我们很清楚后续我们要开发的是一个内核,如果仅仅基于已有操作系统提供的系统调用的话,它自身的抽象能力会受到很大限制。所以它必须
直面底层硬件来解锁更大的抽象能力上限。
.. note::
RISC-V 指令集拓展
\ No newline at end of file
docs/_sources/chapter1/1remove-std.rst.txt
浏览文件 @
96a76265
...
@@ -52,7 +52,11 @@
...
@@ -52,7 +52,11 @@
如下图所示,应用程序的运行需要下面一套运行环境栈的支持:
如下图所示,应用程序的运行需要下面一套运行环境栈的支持:
.. image:: app-software-stack.png
.. _app-software-stack:
.. figure:: app-software-stack.png
应用程序运行环境栈
图中的白色块自上而下(越往下则越靠近底层,下层作为上层的执行环境支持上层代码的运行)表示各级运行环境,黑色块则表示相邻两层运行环境之间
图中的白色块自上而下(越往下则越靠近底层,下层作为上层的执行环境支持上层代码的运行)表示各级运行环境,黑色块则表示相邻两层运行环境之间
的接口。
的接口。
...
@@ -70,9 +74,23 @@
...
@@ -70,9 +74,23 @@
``Hello, world!`` 用到了哪些系统调用?
``Hello, world!`` 用到了哪些系统调用?
从之前的 ``cargo run`` 的输出可以看出之前构建的可执行文件是在 target/debug 目录下的 os 。
在 Ubuntu 系统上,可以通过 ``strace`` 工具来运行一个程序并输出程序运行过程当中向内核请求的所有的系统调用及其返回值。
我们只需输入 ``strace target/debug/os`` 即可看到一长串的系统调用。
其中,真正容易看出与 ``Hello, world!`` 相关的只有一个系统调用:
.. code-block::
write(1, "Hello, world!\n", 14) = 14
其参数的具体含义我们暂且不在这里进行解释。
其余的系统调用基本上分别用于函数库和内核两层执行环境的初始化工作和对于上层的运行期监控和管理。之后,随着应用场景的复杂化,我们
需要更强的抽象能力,也会实现这里面的一些系统调用。
从硬件的角度来看,它上面的一切都属于软件。硬件可以分为三种: 处理器 (Processor) ——它更常见的名字是中央处理单元 (CPU, Central Processing Unit),
从硬件的角度来看,它上面的一切都属于软件。硬件可以分为三种: 处理器 (Processor) ——它更常见的名字是中央处理单元 (CPU, Central Processing Unit),
内存 (Memory) 还有 I/O 设备。其中处理器无疑是其中最复杂同时也最关键的一个。它与软件约定一套 **指令集
架
构** (ISA, Instruction Set Architecture),
内存 (Memory) 还有 I/O 设备。其中处理器无疑是其中最复杂同时也最关键的一个。它与软件约定一套 **指令集
体系结
构** (ISA, Instruction Set Architecture),
使得软件可以通过 ISA 中提供的汇编指令来访问各种硬件资源。软件当然也需要知道处理器会如何执行这些指令:最简单的话就是一条一条执行位于内存
使得软件可以通过 ISA 中提供的汇编指令来访问各种硬件资源。软件当然也需要知道处理器会如何执行这些指令:最简单的话就是一条一条执行位于内存
中的指令。当然,实际的情况远比这个要复杂得多,为了适应现代应用程序的场景,处理器还需要提供很多额外的机制,而不仅仅是让数据在 CPU 寄存器、内存和 I/O 设备
中的指令。当然,实际的情况远比这个要复杂得多,为了适应现代应用程序的场景,处理器还需要提供很多额外的机制,而不仅仅是让数据在 CPU 寄存器、内存和 I/O 设备
三者之间流动。
三者之间流动。
...
@@ -94,8 +112,37 @@
...
@@ -94,8 +112,37 @@
操作系统如 Windows/Linux/macOS 等的抽象都支持同时运行很多应用程序,在嵌入式场景是过抽象的。因此,常见的解决方案是仅使用函数库构建
操作系统如 Windows/Linux/macOS 等的抽象都支持同时运行很多应用程序,在嵌入式场景是过抽象的。因此,常见的解决方案是仅使用函数库构建
单独的应用程序或是用专为应用场景特别裁减过的轻量级内核管理少数应用程序。
单独的应用程序或是用专为应用场景特别裁减过的轻量级内核管理少数应用程序。
目标三元组
平台与目标三元组
--------------------
---------------------------------------
对于一份用某种编程语言实现的源代码而言,编译器在将其通过编译、链接得到目标文件的时候需要知道程序要在哪个 **平台** (Platform) 上运行。
从上面给出的 :ref:`应用程序运行环境栈 <app-software-stack>` 可以看出:
- 如果用户态基于的内核不同,会导致系统调用接口不同或者语义不一致;
- 如果底层硬件不同,对于硬件资源的访问方式会有差异。特别是 ISA 不同的话,对上提供的指令集和寄存器都不同。
它们都会导致最终生成的目标文件有很大不同。需要指出的是,某些编译器支持同一份源代码无需修改就可编译到多个不同的目标平台并在上面运行。这种
情况下,源代码是 **跨平台** 的。而另一些编译器则已经预设好了一个固定的目标平台。
我们可以通过 **目标三元组** (Target Triple) 来描述一个目标平台。它一般包括 CPU 架构、CPU 厂商和操作系统,它们确实都会控制目标文件的生成。
比如,我们可以尝试看一下之前的 ``Hello, world!`` 的目标平台是什么。这可以通过打印编译器 rustc 的默认配置信息:
.. code-block:: console
$ rustc --version --verbose
rustc 1.48.0-nightly (73dc675b9 2020-09-06)
binary: rustc
commit-hash: 73dc675b9437c2a51a975a9f58cc66f05463c351
commit-date: 2020-09-06
host: x86_64-unknown-linux-gnu
release: 1.48.0-nightly
LLVM version: 11.0
从其中的 host 一项可以看出默认的目标平台是 ``x86_64-unknown-linux-gnu``,其中 CPU 架构是 x86_64,CPU 厂商是 unknown,操作系统是 linux-gnu。
这种无论编译器还是目标文件都在我们当前所处的平台运行是一种最简单也最普遍的情况。但是很快我们就将遇到另外一种情况。
讲了这么多,终于该介绍我们的主线任务了。我们希望能够在另一个平台上运行 ``Hello, world!``,而与之前的默认平台不同的地方在于:
- CPU 架构从 x86_64 换成 RISC-V 架构;
- 操作系统从 linux-gnu 换成 none-elf,也就是没有任何系统调用支持。
\ No newline at end of file
docs/_sources/chapter1/index.rst.txt
浏览文件 @
96a76265
...
@@ -6,4 +6,4 @@
...
@@ -6,4 +6,4 @@
:hidden:
:hidden:
:maxdepth: 3
:maxdepth: 3
1remove-std
1app-ee-platform
\ No newline at end of file
\ No newline at end of file
docs/chapter1/1app-ee-platform.html
0 → 100644
浏览文件 @
96a76265
此差异已折叠。
点击以展开。
docs/chapter1/1remove-std.html
浏览文件 @
96a76265
...
@@ -87,7 +87,7 @@
...
@@ -87,7 +87,7 @@
<li
class=
"toctree-l1 current"
><a
class=
"reference internal"
href=
"index.html"
>
第一章:编译运行 RV64 裸机程序
</a><ul
class=
"current"
>
<li
class=
"toctree-l1 current"
><a
class=
"reference internal"
href=
"index.html"
>
第一章:编译运行 RV64 裸机程序
</a><ul
class=
"current"
>
<li
class=
"toctree-l2 current"
><a
class=
"current reference internal"
href=
"#"
>
移除标准库依赖
</a><ul>
<li
class=
"toctree-l2 current"
><a
class=
"current reference internal"
href=
"#"
>
移除标准库依赖
</a><ul>
<li
class=
"toctree-l3"
><a
class=
"reference internal"
href=
"#id2"
>
应用程序运行环境
</a></li>
<li
class=
"toctree-l3"
><a
class=
"reference internal"
href=
"#id2"
>
应用程序运行环境
</a></li>
<li
class=
"toctree-l3"
><a
class=
"reference internal"
href=
"#id3"
>
目标三元组
</a></li>
<li
class=
"toctree-l3"
><a
class=
"reference internal"
href=
"#id3"
>
平台与
目标三元组
</a></li>
</ul>
</ul>
</li>
</li>
</ul>
</ul>
...
@@ -205,7 +205,10 @@
...
@@ -205,7 +205,10 @@
<div
class=
"section"
id=
"id2"
>
<div
class=
"section"
id=
"id2"
>
<h2>
应用程序运行环境
<a
class=
"headerlink"
href=
"#id2"
title=
"Permalink to this headline"
>
¶
</a></h2>
<h2>
应用程序运行环境
<a
class=
"headerlink"
href=
"#id2"
title=
"Permalink to this headline"
>
¶
</a></h2>
<p>
如下图所示,应用程序的运行需要下面一套运行环境栈的支持:
</p>
<p>
如下图所示,应用程序的运行需要下面一套运行环境栈的支持:
</p>
<img
alt=
"../_images/app-software-stack.png"
src=
"../_images/app-software-stack.png"
/>
<div
class=
"figure align-default"
id=
"id5"
>
<span
id=
"app-software-stack"
></span><img
alt=
"../_images/app-software-stack.png"
src=
"../_images/app-software-stack.png"
/>
<p
class=
"caption"
><span
class=
"caption-text"
>
应用程序运行环境栈
</span><a
class=
"headerlink"
href=
"#id5"
title=
"Permalink to this image"
>
¶
</a></p>
</div>
<p>
图中的白色块自上而下(越往下则越靠近底层,下层作为上层的执行环境支持上层代码的运行)表示各级运行环境,黑色块则表示相邻两层运行环境之间
<p>
图中的白色块自上而下(越往下则越靠近底层,下层作为上层的执行环境支持上层代码的运行)表示各级运行环境,黑色块则表示相邻两层运行环境之间
的接口。
</p>
的接口。
</p>
<p>
我们的应用位于最上层,它可以通过调用编程语言提供的标准库或者其他三方库对外提供的功能强大的函数接口,使得仅需少量的源代码就能完成复杂的
<p>
我们的应用位于最上层,它可以通过调用编程语言提供的标准库或者其他三方库对外提供的功能强大的函数接口,使得仅需少量的源代码就能完成复杂的
...
@@ -218,9 +221,19 @@
...
@@ -218,9 +221,19 @@
<div
class=
"admonition note"
>
<div
class=
"admonition note"
>
<p
class=
"admonition-title"
>
Note
</p>
<p
class=
"admonition-title"
>
Note
</p>
<p><code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
Hello,
</span>
<span
class=
"pre"
>
world!
</span></code>
用到了哪些系统调用?
</p>
<p><code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
Hello,
</span>
<span
class=
"pre"
>
world!
</span></code>
用到了哪些系统调用?
</p>
<p>
从之前的
<code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
cargo
</span>
<span
class=
"pre"
>
run
</span></code>
的输出可以看出之前构建的可执行文件是在 target/debug 目录下的 os 。
在 Ubuntu 系统上,可以通过
<code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
strace
</span></code>
工具来运行一个程序并输出程序运行过程当中向内核请求的所有的系统调用及其返回值。
我们只需输入
<code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
strace
</span>
<span
class=
"pre"
>
target/debug/os
</span></code>
即可看到一长串的系统调用。
</p>
<p>
其中,真正容易看出与
<code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
Hello,
</span>
<span
class=
"pre"
>
world!
</span></code>
相关的只有一个系统调用:
</p>
<div
class=
"highlight-default notranslate"
><div
class=
"highlight"
><pre><span></span><span
class=
"n"
>
write
</span><span
class=
"p"
>
(
</span><span
class=
"mi"
>
1
</span><span
class=
"p"
>
,
</span>
<span
class=
"s2"
>
"
Hello, world!
</span><span
class=
"se"
>
\n
</span><span
class=
"s2"
>
"
</span><span
class=
"p"
>
,
</span>
<span
class=
"mi"
>
14
</span><span
class=
"p"
>
)
</span>
<span
class=
"o"
>
=
</span>
<span
class=
"mi"
>
14
</span>
</pre></div>
</div>
<p>
其参数的具体含义我们暂且不在这里进行解释。
</p>
<p>
其余的系统调用基本上分别用于函数库和内核两层执行环境的初始化工作和对于上层的运行期监控和管理。之后,随着应用场景的复杂化,我们
需要更强的抽象能力,也会实现这里面的一些系统调用。
</p>
</div>
</div>
<p>
从硬件的角度来看,它上面的一切都属于软件。硬件可以分为三种: 处理器 (Processor) ——它更常见的名字是中央处理单元 (CPU, Central Processing Unit),
<p>
从硬件的角度来看,它上面的一切都属于软件。硬件可以分为三种: 处理器 (Processor) ——它更常见的名字是中央处理单元 (CPU, Central Processing Unit),
内存 (Memory) 还有 I/O 设备。其中处理器无疑是其中最复杂同时也最关键的一个。它与软件约定一套
<strong>
指令集
架
构
</strong>
(ISA, Instruction Set Architecture),
内存 (Memory) 还有 I/O 设备。其中处理器无疑是其中最复杂同时也最关键的一个。它与软件约定一套
<strong>
指令集
体系结
构
</strong>
(ISA, Instruction Set Architecture),
使得软件可以通过 ISA 中提供的汇编指令来访问各种硬件资源。软件当然也需要知道处理器会如何执行这些指令:最简单的话就是一条一条执行位于内存
使得软件可以通过 ISA 中提供的汇编指令来访问各种硬件资源。软件当然也需要知道处理器会如何执行这些指令:最简单的话就是一条一条执行位于内存
中的指令。当然,实际的情况远比这个要复杂得多,为了适应现代应用程序的场景,处理器还需要提供很多额外的机制,而不仅仅是让数据在 CPU 寄存器、内存和 I/O 设备
中的指令。当然,实际的情况远比这个要复杂得多,为了适应现代应用程序的场景,处理器还需要提供很多额外的机制,而不仅仅是让数据在 CPU 寄存器、内存和 I/O 设备
三者之间流动。
</p>
三者之间流动。
</p>
...
@@ -242,7 +255,34 @@
...
@@ -242,7 +255,34 @@
</div>
</div>
</div>
</div>
<div
class=
"section"
id=
"id3"
>
<div
class=
"section"
id=
"id3"
>
<h2>
目标三元组
<a
class=
"headerlink"
href=
"#id3"
title=
"Permalink to this headline"
>
¶
</a></h2>
<h2>
平台与目标三元组
<a
class=
"headerlink"
href=
"#id3"
title=
"Permalink to this headline"
>
¶
</a></h2>
<p>
对于一份用某种编程语言实现的源代码而言,编译器在将其通过编译、链接得到目标文件的时候需要知道程序要在哪个
<strong>
平台
</strong>
(Platform) 上运行。
从上面给出的
<a
class=
"reference internal"
href=
"#app-software-stack"
><span
class=
"std std-ref"
>
应用程序运行环境栈
</span></a>
可以看出:
</p>
<ul
class=
"simple"
>
<li><p>
如果用户态基于的内核不同,会导致系统调用接口不同或者语义不一致;
</p></li>
<li><p>
如果底层硬件不同,对于硬件资源的访问方式会有差异。特别是 ISA 不同的话,对上提供的指令集和寄存器都不同。
</p></li>
</ul>
<p>
它们都会导致最终生成的目标文件有很大不同。需要指出的是,某些编译器支持同一份源代码无需修改就可编译到多个不同的目标平台并在上面运行。这种
情况下,源代码是
<strong>
跨平台
</strong>
的。而另一些编译器则已经预设好了一个固定的目标平台。
</p>
<p>
我们可以通过
<strong>
目标三元组
</strong>
(Target Triple) 来描述一个目标平台。它一般包括 CPU 架构、CPU 厂商和操作系统,它们确实都会控制目标文件的生成。
比如,我们可以尝试看一下之前的
<code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
Hello,
</span>
<span
class=
"pre"
>
world!
</span></code>
的目标平台是什么。这可以通过打印编译器 rustc 的默认配置信息:
</p>
<div
class=
"highlight-console notranslate"
><div
class=
"highlight"
><pre><span></span><span
class=
"gp"
>
$
</span>
rustc --version --verbose
<span
class=
"go"
>
rustc 1.48.0-nightly (73dc675b9 2020-09-06)
</span>
<span
class=
"go"
>
binary: rustc
</span>
<span
class=
"go"
>
commit-hash: 73dc675b9437c2a51a975a9f58cc66f05463c351
</span>
<span
class=
"go"
>
commit-date: 2020-09-06
</span>
<span
class=
"go"
>
host: x86_64-unknown-linux-gnu
</span>
<span
class=
"go"
>
release: 1.48.0-nightly
</span>
<span
class=
"go"
>
LLVM version: 11.0
</span>
</pre></div>
</div>
<p>
从其中的 host 一项可以看出默认的目标平台是
<code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
x86_64-unknown-linux-gnu
</span></code>
,其中 CPU 架构是 x86_64,CPU 厂商是 unknown,操作系统是 linux-gnu。
这种无论编译器还是目标文件都在我们当前所处的平台运行是一种最简单也最普遍的情况。但是很快我们就将遇到另外一种情况。
</p>
<p>
讲了这么多,终于该介绍我们的主线任务了。我们希望能够在另一个平台上运行
<code
class=
"docutils literal notranslate"
><span
class=
"pre"
>
Hello,
</span>
<span
class=
"pre"
>
world!
</span></code>
,而与之前的默认平台不同的地方在于:
</p>
<ul
class=
"simple"
>
<li><p>
CPU 架构从 x86_64 换成 RISC-V 架构;
</p></li>
<li><p>
操作系统从 linux-gnu 换成 none-elf,也就是没有任何系统调用支持。
</p></li>
</ul>
</div>
</div>
</div>
</div>
...
...
docs/chapter1/index.html
浏览文件 @
96a76265
...
@@ -36,7 +36,7 @@
...
@@ -36,7 +36,7 @@
<link
rel=
"stylesheet"
href=
"../_static/pygments.css"
type=
"text/css"
/>
<link
rel=
"stylesheet"
href=
"../_static/pygments.css"
type=
"text/css"
/>
<link
rel=
"index"
title=
"Index"
href=
"../genindex.html"
/>
<link
rel=
"index"
title=
"Index"
href=
"../genindex.html"
/>
<link
rel=
"search"
title=
"Search"
href=
"../search.html"
/>
<link
rel=
"search"
title=
"Search"
href=
"../search.html"
/>
<link
rel=
"next"
title=
"
移除标准库依赖"
href=
"1remove-std
.html"
/>
<link
rel=
"next"
title=
"
应用程序运行环境与平台支持"
href=
"1app-ee-platform
.html"
/>
<link
rel=
"prev"
title=
"快速上手"
href=
"../quickstart.html"
/>
<link
rel=
"prev"
title=
"快速上手"
href=
"../quickstart.html"
/>
</head>
</head>
...
@@ -85,7 +85,7 @@
...
@@ -85,7 +85,7 @@
<ul
class=
"current"
>
<ul
class=
"current"
>
<li
class=
"toctree-l1"
><a
class=
"reference internal"
href=
"../quickstart.html"
>
快速上手
</a></li>
<li
class=
"toctree-l1"
><a
class=
"reference internal"
href=
"../quickstart.html"
>
快速上手
</a></li>
<li
class=
"toctree-l1 current"
><a
class=
"current reference internal"
href=
"#"
>
第一章:编译运行 RV64 裸机程序
</a><ul>
<li
class=
"toctree-l1 current"
><a
class=
"current reference internal"
href=
"#"
>
第一章:编译运行 RV64 裸机程序
</a><ul>
<li
class=
"toctree-l2"
><a
class=
"reference internal"
href=
"1
remove-std.html"
>
移除标准库依赖
</a></li>
<li
class=
"toctree-l2"
><a
class=
"reference internal"
href=
"1
app-ee-platform.html"
>
应用程序运行环境与平台支持
</a></li>
</ul>
</ul>
</li>
</li>
</ul>
</ul>
...
@@ -170,7 +170,7 @@
...
@@ -170,7 +170,7 @@
<div
class=
"rst-footer-buttons"
role=
"navigation"
aria-label=
"footer navigation"
>
<div
class=
"rst-footer-buttons"
role=
"navigation"
aria-label=
"footer navigation"
>
<a
href=
"1
remove-std.html"
class=
"btn btn-neutral float-right"
title=
"移除标准库依赖
"
accesskey=
"n"
rel=
"next"
>
Next
<span
class=
"fa fa-arrow-circle-right"
></span></a>
<a
href=
"1
app-ee-platform.html"
class=
"btn btn-neutral float-right"
title=
"应用程序运行环境与平台支持
"
accesskey=
"n"
rel=
"next"
>
Next
<span
class=
"fa fa-arrow-circle-right"
></span></a>
<a
href=
"../quickstart.html"
class=
"btn btn-neutral float-left"
title=
"快速上手"
accesskey=
"p"
rel=
"prev"
><span
class=
"fa fa-arrow-circle-left"
></span>
Previous
</a>
<a
href=
"../quickstart.html"
class=
"btn btn-neutral float-left"
title=
"快速上手"
accesskey=
"p"
rel=
"prev"
><span
class=
"fa fa-arrow-circle-left"
></span>
Previous
</a>
...
...
docs/objects.inv
浏览文件 @
96a76265
无法预览此类型文件
docs/searchindex.js
浏览文件 @
96a76265
此差异已折叠。
点击以展开。
source/chapter1/1app-ee-platform.rst
0 → 100644
浏览文件 @
96a76265
应用程序运行环境与平台支持
================================================
.. toctree::
:hidden:
:maxdepth: 3
作为一切的开始,让我们使用 Cargo 工具来创建一个 Rust 项目。它看上去没有任何特别之处:
.. code-block:: console
$ cargo new os --bin
我们加上了 ``--bin`` 选项来告诉 Cargo 我们创建一个可执行项目而不是库项目。此时,项目的文件结构如下:
.. code-block:: console
$ tree os
os
├── Cargo.toml
└── src
└── main.rs
1 directory, 2 files
其中 ``Cargo.toml`` 中保存着项目的配置,包括作者的信息、联系方式以及库依赖等等。显而易见源代码保存在 ``src`` 目录下,目前为止只有 ``main.rs``
一个文件,让我们看一下里面的内容:
.. code-block:: rust
:linenos:
:caption: 最简单的 Rust 应用
fn main() {
println!("Hello, world!");
}
利用 Cargo 工具即可一条命令实现构建并运行项目:
.. code-block:: console
$ 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!`` 。但是,需要注意到我们所享受到的编程的方便并不是理所当然的,背后有着从硬件
到软件的多种机制的支持。
应用程序运行环境
-------------------------------
如下图所示,应用程序的运行需要下面一套运行环境栈的支持:
.. _app-software-stack:
.. figure:: app-software-stack.png
应用程序运行环境栈
图中的白色块自上而下(越往下则越靠近底层,下层作为上层的执行环境支持上层代码的运行)表示各级运行环境,黑色块则表示相邻两层运行环境之间
的接口。
我们的应用位于最上层,它可以通过调用编程语言提供的标准库或者其他三方库对外提供的功能强大的函数接口,使得仅需少量的源代码就能完成复杂的
功能。但是这些库的功能不仅限于此,事实上它们属于应用程序的 **执行环境** (Execution Environment),在我们通常不会注意到的地方,它
们还会在执行应用之前完成一些初始化工作,并在应用程序执行的时候对它进行监控。我们在打印 ``Hello, world!`` 时使用的 ``println!``
宏正是由 Rust 标准库 std 提供的。
从内核/操作系统的角度看来,它上面的一切都属于用户态,而它自身属于内核态。无论用户态应用如何编写,是手写汇编代码,还是基于某种编程语言利用
其标准库或三方库,某些功能总要直接或间接的通过内核/操作系统提供的 **系统调用** (System Call) 来实现。因此系统调用充当了用户和内核之间
的边界。内核作为用户态的运行环境,它不仅要提供系统调用接口,还需要对用户态应用的执行进行监控和管理。
.. note::
``Hello, world!`` 用到了哪些系统调用?
从之前的 ``cargo run`` 的输出可以看出之前构建的可执行文件是在 target/debug 目录下的 os 。
在 Ubuntu 系统上,可以通过 ``strace`` 工具来运行一个程序并输出程序运行过程当中向内核请求的所有的系统调用及其返回值。
我们只需输入 ``strace target/debug/os`` 即可看到一长串的系统调用。
其中,真正容易看出与 ``Hello, world!`` 相关的只有一个系统调用:
.. code-block::
write(1, "Hello, world!\n", 14) = 14
其参数的具体含义我们暂且不在这里进行解释。
其余的系统调用基本上分别用于函数库和内核两层执行环境的初始化工作和对于上层的运行期监控和管理。之后,随着应用场景的复杂化,我们
需要更强的抽象能力,也会实现这里面的一些系统调用。
从硬件的角度来看,它上面的一切都属于软件。硬件可以分为三种: 处理器 (Processor) ——它更常见的名字是中央处理单元 (CPU, Central Processing Unit),
内存 (Memory) 还有 I/O 设备。其中处理器无疑是其中最复杂同时也最关键的一个。它与软件约定一套 **指令集体系结构** (ISA, Instruction Set Architecture),
使得软件可以通过 ISA 中提供的汇编指令来访问各种硬件资源。软件当然也需要知道处理器会如何执行这些指令:最简单的话就是一条一条执行位于内存
中的指令。当然,实际的情况远比这个要复杂得多,为了适应现代应用程序的场景,处理器还需要提供很多额外的机制,而不仅仅是让数据在 CPU 寄存器、内存和 I/O 设备
三者之间流动。
.. note::
多层执行环境都是必需的吗?
除了最上层的应用程序和最下层的硬件平台必须存在之外,作为中间层的函数库和内核并不是必须存在的:它们都是对下层资源进行了 **抽象** (Abstraction),
并为上层提供了一套运行环境。抽象的优点在于它让上层以较小的代价获得所需的功能,并同时可以提供一些保护。但抽象同时也是一种限制,会丧失一些
应有的灵活性。比如,当你在考虑在项目中应该使用哪个函数库的时候,就常常需要这方面的权衡:过多的抽象和过少的抽象自然都是不合适的。
实际上,我们通过应用程序的特征来判断它需要什么程度的抽象。
- 如果函数库和内核都不存在,那么我们就是在手写汇编代码,这种方式具有最高的灵活性,抽象能力则最低,基本等同于硬件。我们通常用这种方式来
实现一些架构相关且仅通过编程语言无法描述的小模块或者代码片段。
- 如果仅存在函数库而不存在内核,意味着我们不需要内核提供的抽象。在嵌入式场景就常常会出现这种情况。嵌入式设备虽然也包含 CPU、内存和 I/O
设备,但是它上面通常只会同时运行一个或几个功能非常简单的小应用程序,其定位就是那种功能单一的场景,比如人脸识别打卡系统等。我们常用的
操作系统如 Windows/Linux/macOS 等的抽象都支持同时运行很多应用程序,在嵌入式场景是过抽象的。因此,常见的解决方案是仅使用函数库构建
单独的应用程序或是用专为应用场景特别裁减过的轻量级内核管理少数应用程序。
平台与目标三元组
---------------------------------------
对于一份用某种编程语言实现的源代码而言,编译器在将其通过编译、链接得到目标文件的时候需要知道程序要在哪个 **平台** (Platform) 上运行。
从上面给出的 :ref:`应用程序运行环境栈 <app-software-stack>` 可以看出:
- 如果用户态基于的内核不同,会导致系统调用接口不同或者语义不一致;
- 如果底层硬件不同,对于硬件资源的访问方式会有差异。特别是 ISA 不同的话,对上提供的指令集和寄存器都不同。
它们都会导致最终生成的目标文件有很大不同。需要指出的是,某些编译器支持同一份源代码无需修改就可编译到多个不同的目标平台并在上面运行。这种
情况下,源代码是 **跨平台** 的。而另一些编译器则已经预设好了一个固定的目标平台。
我们可以通过 **目标三元组** (Target Triple) 来描述一个目标平台。它一般包括 CPU 架构、CPU 厂商和操作系统,它们确实都会控制目标文件的生成。
比如,我们可以尝试看一下之前的 ``Hello, world!`` 的目标平台是什么。这可以通过打印编译器 rustc 的默认配置信息:
.. code-block:: console
$ rustc --version --verbose
rustc 1.48.0-nightly (73dc675b9 2020-09-06)
binary: rustc
commit-hash: 73dc675b9437c2a51a975a9f58cc66f05463c351
commit-date: 2020-09-06
host: x86_64-unknown-linux-gnu
release: 1.48.0-nightly
LLVM version: 11.0
从其中的 host 一项可以看出默认的目标平台是 ``x86_64-unknown-linux-gnu``,其中 CPU 架构是 x86_64,CPU 厂商是 unknown,操作系统是 linux-gnu。
这种无论编译器还是其目标文件都在我们当前所处的平台运行是一种最简单也最普遍的情况。但是很快我们就将遇到另外一种情况。
讲了这么多,终于该介绍我们的主线任务了。我们希望能够在另一个平台上运行 ``Hello, world!``,而与之前的默认平台不同的地方在于,我们将 CPU 架构从
x86_64 换成 RISC-V。
.. note::
为何基于 RISC-V 架构而非 x86 系列架构?
x86 架构为了在升级换代的同时保持对基于旧版架构应用程序/内核的兼容性,存在大量的历史包袱,也就是一些对于目前的应用场景没有任何意义,但又必须
花大量时间正确设置才能正常使用 CPU 的奇怪设定。为了建立并维护架构的应用生态,这确实是必不可少的,但站在教学的角度几乎完全是在浪费时间。而
新生的 RISC-V 架构十分简洁,架构文档需要阅读的核心部分不足百页,且这些功能已经足以用来构造一个具有相当抽象能力的内核了。
可以看一下目前 Rust 编译器支持哪些基于 RISC-V 的平台:
.. code-block:: console
$ rustc --print target-list | grep riscv
riscv32i-unknown-none-elf
riscv32imac-unknown-none-elf
riscv32imc-unknown-none-elf
riscv64gc-unknown-linux-gnu
riscv64gc-unknown-none-elf
riscv64imac-unknown-none-elf
这里我们选择的是 ``riscv64gc-unknown-none-elf``,目标三元组中的操作系统是 none-elf,表明没有任何系统调用支持。这里我们之所以不选择有
linux-gnu 系统调用支持的版本 ``riscv64gc-unknown-linux-gnu``,是因为我们只是想跑一个 ``Hello, world!``,没有必要使用操作系统所提供的
那么高级的抽象。而且我们很清楚后续我们要开发的是一个内核,如果仅仅基于已有操作系统提供的系统调用的话,它自身的抽象能力会受到很大限制。所以它必须
直面底层硬件来解锁更大的抽象能力上限。
.. note::
RISC-V 指令集拓展
source/chapter1/index.rst
浏览文件 @
96a76265
...
@@ -6,4 +6,4 @@
...
@@ -6,4 +6,4 @@
:hidden:
:hidden:
:maxdepth: 3
:maxdepth: 3
1remove-std
1app-ee-platform
\ No newline at end of file
\ No newline at end of file
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录