@ -83,7 +83,7 @@
< nav id = "sidebar" class = "sidebar" aria-label = "Table of contents" >
< div class = "sidebar-scrollbox" >
< ol class = "chapter" > < li class = "chapter-item expanded affix " > < a href = "index.html" > 简明 zCore 教程< / a > < / li > < li class = "chapter-item expanded affix " > < a href = "zcore-intro.html" > 🚧 zCore 整体结构和设计模式< / a > < / li > < li class = "chapter-item expanded affix " > < a href = "fuchsia.html" > 🚧 Fuchsia OS 和 Zircon 微内核< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch01-00-object.html" > < strong aria-hidden = "true" > 1.< / strong > 内核对象< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch01-01-kernel-object.html" > < strong aria-hidden = "true" > 1.1.< / strong > ✅ 初识内核对象< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch01-02-process-object.html" > < strong aria-hidden = "true" > 1.2.< / strong > 🚧 对象管理器： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch01-03-channel-object.html" > < strong aria-hidden = "true" > 1.3.< / strong > 🚧 对象传送器： < / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch02-00-task.html" > < strong aria-hidden = "true" > 2.< / strong > 任务管理< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch02-01-zircon-task.html" > < strong aria-hidden = "true" > 2.1.< / strong > 🚧 Zircon 任务管理体系< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch02-02-process-job-object.html" > < strong aria-hidden = "true" > 2.2.< / strong > 🚧 进程管理： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch02-03-thread-object.html" > < strong aria-hidden = "true" > 2.3.< / strong > 🚧 线程管理： < / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch03-00-memory.html" > < strong aria-hidden = "true" > 3.< / strong > 内存管理< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch03-01-zircon-memory.html" > < strong aria-hidden = "true" > 3.1.< / strong > 🚧 Zircon 内存管理模型< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch03-02-vmo.html" > < strong aria-hidden = "true" > 3.2.< / strong > 🚧 物理内存： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch03-03-vmo-paged.html" > < strong aria-hidden = "true" > 3.3.< / strong > 🚧 物理内存：按页分配的 VMO< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch03-04-vmar.html" > < strong aria-hidden = "true" > 3.4.< / strong > 🚧 虚拟内存： < / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch04-00-userspace.html" > < strong aria-hidden = "true" > 4.< / strong > 用户程序< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch04-01-user-program.html" > < strong aria-hidden = "true" > 4.1.< / strong > 🚧 Zircon 用户程序< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch04-02-context-switch.html" > < strong aria-hidden = "true" > 4.2.< / strong > 🚧 上下文切换< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch04-03-syscall.html" > < strong aria-hidden = "true" > 4.3.< / strong > 🚧 系统调用< / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch05-00-signal-and-waiting.html" > < strong aria-hidden = "true" > 5.< / strong > 信号和等待< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch05-01-wait-signal.html" > < strong aria-hidden = "true" > 5.1.< / strong > 🚧 等待内核对象的信号< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch05-02-port-object.html" > < strong aria-hidden = "true" > 5.2.< / strong > 🚧 同时等待多个信号： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch05-03-more-signal-objects.html" > < strong aria-hidden = "true" > 5.3.< / strong > 🚧 实现更多： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch05-04-futex-object.html" > < strong aria-hidden = "true" > 5.4.< / strong > 🚧 用户态同步互斥： < / a > < / li > < / ol > < / li > < / ol > < / div >
< ol class = "chapter" > < li class = "chapter-item expanded affix " > < a href = "index.html" > 简明 zCore 教程< / a > < / li > < li class = "chapter-item expanded affix " > < a href = "zcore-intro.html" > 🚧 zCore 整体结构和设计模式< / a > < / li > < li class = "chapter-item expanded affix " > < a href = "fuchsia.html" > 🚧 Fuchsia OS 和 Zircon 微内核< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch01-00-object.html" > < strong aria-hidden = "true" > 1.< / strong > 内核对象< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch01-01-kernel-object.html" > < strong aria-hidden = "true" > 1.1.< / strong > ✅ 初识内核对象< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch01-02-process-object.html" > < strong aria-hidden = "true" > 1.2.< / strong > 🚧 对象管理器： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch01-03-channel-object.html" > < strong aria-hidden = "true" > 1.3.< / strong > 🚧 对象传送器： < / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch02-00-task.html" > < strong aria-hidden = "true" > 2.< / strong > 任务管理< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch02-01-zircon-task.html" > < strong aria-hidden = "true" > 2.1.< / strong > 🚧 Zircon 任务管理体系< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch02-02-process-job-object.html" > < strong aria-hidden = "true" > 2.2.< / strong > 🚧 进程管理： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch02-03-thread-object.html" > < strong aria-hidden = "true" > 2.3.< / strong > 🚧 线程管理： < / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch03-00-memory.html" > < strong aria-hidden = "true" > 3.< / strong > 内存管理< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch03-01-zircon-memory.html" > < strong aria-hidden = "true" > 3.1.< / strong > 🚧 Zircon 内存管理模型< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch03-02-vmo.html" > < strong aria-hidden = "true" > 3.2.< / strong > 🚧 物理内存： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch03-03-vmo-paged.html" > < strong aria-hidden = "true" > 3.3.< / strong > 🚧 物理内存：按页分配的 VMO< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch03-04-vmar.html" > < strong aria-hidden = "true" > 3.4.< / strong > 🚧 虚拟内存： < / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch04-00-userspace.html" > < strong aria-hidden = "true" > 4.< / strong > 用户程序< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch04-01-user-program.html" > < strong aria-hidden = "true" > 4.1.< / strong > 🚧 Zircon 用户程序< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch04-02-context-switch.html" > < strong aria-hidden = "true" > 4.2.< / strong > 🚧 上下文切换< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch04-03-syscall.html" > < strong aria-hidden = "true" > 4.3.< / strong > 🚧 系统调用< / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch05-00-signal-and-waiting.html" > < strong aria-hidden = "true" > 5.< / strong > 信号和等待< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch05-01-wait-signal.html" > < strong aria-hidden = "true" > 5.1.< / strong > 🚧 等待内核对象的信号< / a > < / li > < li class = "chapter-item expanded " > < a href = "ch05-02-port-object.html" > < strong aria-hidden = "true" > 5.2.< / strong > 🚧 同时等待多个信号： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch05-03-more-signal-objects.html" > < strong aria-hidden = "true" > 5.3.< / strong > 🚧 实现更多： < / a > < / li > < li class = "chapter-item expanded " > < a href = "ch05-04-futex-object.html" > < strong aria-hidden = "true" > 5.4.< / strong > 🚧 用户态同步互斥： < / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "ch06-00-hal.html" > < strong aria-hidden = "true" > 6.< / strong > 硬件抽象层< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "ch06-01-zcore-hal-unix.html" > < strong aria-hidden = "true" > 6.1.< / strong > ✅ UNIX硬件抽象层< / a > < / li > < / ol > < / li > < / ol > < / div >
< div id = "sidebar-resize-handle" class = "sidebar-resize-handle" > < / div >
< / nav >
@ -194,7 +194,13 @@
< p > 让我们先来阅读一下 Fuchsia 官方文档：< a href = "https://github.com/zhangpf/fuchsia-docs-zh-CN/blob/master/zircon/docs/objects.md" > 内核对象< / a > 。这个链接是社区翻译的中文版，已经有些年头了。如果读者能够科学上网，推荐直接阅读< a href = "https://fuchsia.dev/fuchsia-src/reference/kernel_objects/objects" > 官方英文版< / a > 。< / p >
< p > 通过阅读文档，我们了解到与内核对象相关的三个重要概念：< strong > 对象（ ） ， （ ） ， （ ） < / strong > 。它们在 Zircon 内核中的角色和关系如下图所示：< / p >
< p > < img src = "img/ch01-01-kernel-object.png" alt = "" / > < / p >
< p > 简单来说：< / p >
< p > 这三个重要概念的定义如下：< / p >
< ul >
< li > < strong > 对象（ ） < / strong > ： < strong > 整数< / strong > 到复杂的< strong > 操作系统进程< / strong > 等都可看做对象，它不仅仅表示具体的事物，还能表示抽象的规则、计划或事件。< / li >
< li > < strong > 句柄（ ） < / strong > ： ， （ ） < / li >
< li > < strong > 权限（ ） < / strong > ：是指对象的访问者被允许在对象上执行的操作，即对象的访问权限。当对象访问者打开对象的句柄，该句柄具有对其对象的访问权限的某种组合。< / li >
< / ul >
< p > 对于Zircon与对象、句柄、权限的关系， ： < / p >
< ul >
< li > Zircon是一个基于对象的内核， < strong > 对象< / strong > 中。< / li >
< li > 用户程序通过 < strong > 句柄< / strong > 与内核交互。句柄是对某一对象的引用，并且附加了特定的 < strong > 权限< / strong > 。< / li >
@ -253,7 +259,7 @@ test tests::it_works ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
< / code > < / pre >
< h2 id = "实现-kernelobject-接口" > < a class = "header" href = "#实现-kernelobject-接口" > 实现 KernelObject 接口< / a > < / h2 >
< p > 所有的内核对象有一系列共同的属性和方法，我们称这些 方法为对象的公共< strong > 接口（ ） < / strong > 。
< p > 所有的内核对象有一系列共同的属性和方法，我们称对象的 方法为对象的公共< strong > 接口（ ） < / strong > 。
同一种方法在不同类型的对象中可能会有不同的行为，在面向对象语言中我们称其为< strong > 多态（ ） < / strong > 。< / p >
< p > Rust 是一门部分面向对象的语言，我们通常用它的 trait 实现接口和多态。< / p >
< p > 首先创建一个 < code > KernelObject< / code > trait 作为内核对象的公共接口：< / p >
@ -295,8 +301,8 @@ struct DummyObjectInner {
name: String,
}
< / code > < / pre >
< p > 这里我们采用 一种< a href = "https://kaisery.github.io/trpl-zh-cn/ch15-05-interior-mutability.html" > < strong > 内部可变性< / strong > < / a > 的设计模式：将对象的所有可变的部分封装到一个内部对象 < code > DummyObjectInner< / code > 中，并在原对象中用自旋锁 < a href = "https://docs.rs/spin/0.5.2/spin/struct.Mutex.html" > < code > Mutex< / code > < / a > 把它包起来，剩下的其它字段都是不可变的。
< code > Mutex< / code > 会用最简单的方式帮我们处理好并发访问问题：如果有其他人正在访问，我就在这里死 等。
< p > 为了有效地支持操作系统中的并行和并发处理，我们这里采用了 一种< a href = "https://kaisery.github.io/trpl-zh-cn/ch15-05-interior-mutability.html" > < strong > 内部可变性< / strong > < / a > 的设计模式：将对象的所有可变的部分封装到一个内部对象 < code > DummyObjectInner< / code > 中，并在原对象中用可保证互斥访问的 自旋锁 < a href = "https://docs.rs/spin/0.5.2/spin/struct.Mutex.html" > < code > Mutex< / code > < / a > 把它包起来，剩下的其它字段都是不可变的。
< code > Mutex< / code > 会用最简单的方式帮我们处理好并发访问问题：如果有其他人正在访问，我就在这里忙 等。
数据被 < code > Mutex< / code > 包起来之后需要首先使用 < a href = "https://docs.rs/spin/0.5.2/spin/struct.Mutex.html#method.lock" > < code > lock()< / code > < / a > 拿到锁之后才能访问。此时并发访问已经安全，因此被包起来的结构自动具有了 < code > Send + Sync< / code > 特性。< / p >
< p > 使用自旋锁引入了新的依赖库 < a href = "https://docs.rs/spin/0.5.2/spin/index.html" > < code > spin< / code > < / a > ，需要在 < code > Cargo.toml< / code > 中加入以下声明：< / p >
< pre > < code class = "language-toml" > [dependencies]
@ -323,10 +329,10 @@ impl DummyObject {
}
}
< / code > < / pre >
< p > 根据文档描述，每个内核对象都有唯一的 ID。为此我们需要实现一个全局的 ID 分配方法。这里采用的方法是用一个静态变量存放下一个待分配 ID 值，每次分配就原子地 +1 。
< p > 根据文档描述，每个内核对象都有唯一的 ID。为此我们需要实现一个全局的 ID 分配方法。这里采用的方法是用一个静态变量存放下一个待分配 ID 值，每次分配就原子地 加< code > 1< / code > 。
ID 类型使用 < code > u64< / code > ，保证了数值空间足够大，在有生之年都不用担心溢出问题。在 Zircon 中 ID 从 1024 开始分配， < / p >
< p > 另外注意这里 < code > new< / code > 函数返回类型不是 < code > Self< / code > 而是 < code > Arc< Self> < / code > ，这是为了以后方便而做的统一约定。< / p >
< p > 最后我们为它实现 < code > KernelObject< / code > 接口：< / p >
< p > 另外注意这里 < code > new< / code > 函数返回类型不是 < code > Self< / code > 而是 < code > Arc< Self> < / code > ，这是的< a href = "https://doc.rust-lang.org/std/sync/struct.Arc.html" > < code > Arc< / code > < / a > 为了以后方便并行处理 而做的统一约定。< / p >
< p > 最后我们为它实现 < code > KernelObject< / code > 的基本 接口：< / p >
< pre > < code class = "language-rust noplaypen" > // src/object/object.rs
impl KernelObject for DummyObject {
fn id(& self) -> KoID {
@ -405,7 +411,7 @@ fn downcast_v2<T: KernelObject>(object: Arc<dyn KernelObject>) ->
downcast-rs = { version = " 1.2.0" , default-features = false }
< / code > < / pre >
< p > （题外话：这个库原来是不支持 < code > no_std< / code > 的， < / p >
< p > 按照它 文档的描述，我们要为自己的接口实现向下转换，只需以下修改：< / p >
< p > 按照< a href = "https://docs.rs/downcast-rs/1.2.0/downcast_rs/index.html" > < code > downcast-rs< / code > < / a > < / p >
< pre > < code class = "language-rust noplaypen" > // src/object/mod.rs
use core::fmt::Debug;
use downcast_rs::{impl_downcast, DowncastSync};
@ -580,11 +586,17 @@ pub struct DummyObject;
< p > 由于 Rust 独特的< a href = "https://kaisery.github.io/trpl-zh-cn/ch17-00-oop.html" > 面向对象编程特性< / a > ，我们在实现内核对象的过程中遇到了一定的挑战。
不过万事开头难，解决这些问题为整个项目打下了坚实基础，后面实现新的内核对象就会变得简单很多。< / p >
< p > 在下一节中，我们将介绍内核对象相关的另外两个概念：句柄和权限，并实现内核对象的存储和访问。< / p >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "对象管理器process-对象" > < a class = "header" href = "#对象管理器process-对象" > 对象管理器： < / a > < / h1 >
< h2 id = "句柄和权限" > < a class = "header" href = "#句柄和权限" > 句柄和权限< / a > < / h2 >
< blockquote >
< p > 介绍并实现 Handle， < / p >
< / blockquote >
< div style = "break-before: page; page-break-before: always;" > < / div > < h4 id = "对象管理器process-对象" > < a class = "header" href = "#对象管理器process-对象" > 对象管理器： < / a > < / h4 >
< h2 id = "权限" > < a class = "header" href = "#权限" > 权限< / a > < / h2 >
< p > 内核对象的“< a href = "https://fuchsia.dev/docs/concepts/kernel/rights" > 权限< / a > ”指定允许对内核对象进行哪些操作。权限与句柄相关联，并传达对关联句柄或与句柄关联的对象执行操作的特权。单个进程可能对具有不同权限的同一个内核对象有两个不同的句柄。< / p >
< h2 id = "句柄" > < a class = "header" href = "#句柄" > 句柄< / a > < / h2 >
< p > 句柄是允许用户程序引用内核对象引用的一种内核结构，它可以被认为是与特定内核对象的会话或连接。< / p >
< p > 通常情况下，多个进程通过不同的句柄同时访问同一个对象。对象可能有多个句柄（在一个或多个进程中）引用它们。但单个句柄只能绑定到单个进程或绑定到内核。< / p >
< p > 当句柄绑定到内核时，我们说它是“在传输中”（'in-transit'）。< / p >
< p > 在用户模式下，句柄只是某个系统调用返回的特定数字。只有“不在传输中”的句柄对用户模式可见。< / p >
< p > 代表句柄的整数只对其所属的那个进程有意义。另一个进程中的相同数字可能不会映射到任何句柄，或者它可能映射到指向完全不同的内核对象的句柄。< / p >
< p > 句柄的整数值是任何 32 位数字，但对应于< strong > ZX_HANDLE_INVALID< / strong > 的值将始终为 0。除此之外， < strong > ZX_HANDLE_FIXED_BITS_MASK< / strong > 访问代表这些位的掩码。< / p >
< p > 句柄可以从一个进程移动到另一个进程，方法是将它们写入通道（使用< a href = "https://fuchsia.dev/docs/reference/syscalls/channel_write" > < code > channel_write()< / code > < / a > ），或者使用 < a href = "https://fuchsia.dev/docs/reference/syscalls/process_start" > < code > process_start()< / code > < / a > 传递一个句柄作为新进程中第一个线程的参数。对于几乎所有的对象，当最后一个打开的引用对象的句柄关闭时，对象要么被销毁，要么被置于可能无法撤消的最终状态。< / p >
< p > 在 < code > Cargo.toml< / code > 中加入 < code > bitflags< / code > 库：< / p >
< pre > < code class = "language-rust noplaypen" > [dependencies]
bitflags = " 1.2"
@ -630,12 +642,16 @@ bitflags! {
const IO = Self::READ.bits | Self::WRITE.bits;
const DEFAULT_CHANNEL = Self::BASIC.bits & !Self::DUPLICATE.bits | Self::IO.bits | Self::SIGNAL.bits | Self::SIGNAL_PEER.bits;
/// GET_PROPERTY ｜
const PROPERTY = Self::GET_PROPERTY.bits | Self::SET_PROPERTY.bits;
/// BASIC | IO | PROPERTY | ENUMERATE | DESTROY | SIGNAL | MANAGE_PROCESS | MANAGE_THREAD
const DEFAULT_PROCESS = Self::BASIC.bits | Self::IO.bits | Self::PROPERTY.bits | Self::ENUMERATE.bits | Self::DESTROY.bits | Self::SIGNAL.bits | Self::MANAGE_PROCESS.bits | Self::MANAGE_THREAD.bits;
}
}
< / code > < / pre >
< p > 定义句柄：< / p >
< pre > < code class = "language-rust noplaypen" > // src/object/handle.rs
use super::{KernelObject, Rights};
use super::{DummyObject, KernelObject, Rights};
use alloc::sync::Arc;
/// 内核对象句柄
@ -770,12 +786,26 @@ impl Process {
}
< / code > < / pre >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "对象传送器channel-对象" > < a class = "header" href = "#对象传送器channel-对象" > 对象传送器： < / a > < / h1 >
< h2 id = "概要" > < a class = "header" href = "#概要" > 概要< / a > < / h2 >
< p > 通道（ ） < / p >
< h2 id = "描述" > < a class = "header" href = "#描述" > 描述< / a > < / h2 >
< p > 通道有两个端点（ ） ， ， ， （ ， ， ， ， ） < / p >
< p > 关闭通道的最后一个句柄对先前写入该通道的消息的生命周期没有影响。这为通道提供了“即发即忘”的语义。< / p >
< p > 一条消息由一定数量的数据和一定数量的句柄组成。调用< a href = "https://fuchsia.dev/docs/reference/syscalls/channel_write" > < code > channel_write()< / code > < / a > 使一条消息入队，调用< a href = "https://fuchsia.dev/docs/reference/syscalls/channel_read" > < code > channel_read()< / code > < / a > 使一条消息出列（如果有队列）。线程可以阻塞，直到消息通过< a href = "https://fuchsia.dev/docs/reference/syscalls/object_wait_one" > < code > object_wait_one()< / code > < / a > 或其他等待机制挂起。< / p >
< p > 或者，调用< a href = "https://fuchsia.dev/docs/reference/syscalls/channel_call" > < code > channel_call()< / code > < / a > 在通道的一个方向上将消息入队， ， （ ） ， （ ） < a href = "https://fuchsia.dev/docs/reference/syscalls/channel_call" > < code > channel_call()< / code > < / a > ，为消息提供唯一的事务 ID.< / p >
< p > 通过通道发送消息的过程有两个步骤。第一步是原子地将数据写入通道并将消息中所有句柄的所有权移到此通道中。此操作始终消耗句柄： ， ， ， （ ） ， ： ， ， ， < / p >
< p > 与许多其他内核对象类型不同， ， ， （ ） < / p >
< p > 当通道端点的所有权从一个进程转移到另一个进程时，即使消息正在进行写入，消息也不会被重新排序或截断。转移事件之前的消息属于以前的所有者，转移之后的消息属于新的所有者。如果在传输端点时，正在进行消息读取，则之前描述的所有权转移方式同样适用。< / p >
< p > 即使最后剩余的句柄被剥夺了< strong > DUPLICATE< / strong > 权限，也不为其他内核对象提供上述顺序保证。< / p >
< h2 id = "创建一对内核对象" > < a class = "header" href = "#创建一对内核对象" > 创建一对内核对象< / a > < / h2 >
< h2 id = "创建通道" > < a class = "header" href = "#创建通道" > 创建通道< / a > < / h2 >
< p > 创建 Channel 将返回两个句柄，一个指向对象的每个端点。< / p >
< blockquote >
< p > 实现 Channel::create< / p >
< p > 讲一下互相持有对方 Weak 指针的目的，这里有不可避免的 unsafe< / p >
< / blockquote >
< h2 id = "实现数据传输" > < a class = "header" href = "#实现数据传输" > 实现数据传输< / a > < / h2 >
< p > 当句柄被写入通道时，它们会从发送进程中删除。当从通道读取带有句柄的消息时，句柄被添加到接收进程中。在这两个事件之间，句柄继续存在（确保它们所指的对象继续存在），除非它们写入的通道的末端关闭——此时发送到该端点的消息被丢弃并且它们包含的任何句柄都已关闭。< / p >
< blockquote >
< p > 实现 read, write 函数， < / p >
< / blockquote >
@ -788,22 +818,126 @@ impl Process {
这个 HAL 的接口未来会根据需要进行扩充。< / p >
< p > 本章中我们只会实现运行一个程序所必需的最小功能子集，剩下的部分则留到跑起用户程序之后再按需实现。< / p >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "zircon-任务管理体系" > < a class = "header" href = "#zircon-任务管理体系" > Zircon 任务管理体系< / a > < / h1 >
< p > 线程（ ） （ ） （ ， ） （ ） ， （ ） ， （ ） ， < a href = "https://fuchsia.dev/docs/concepts/booting/userboot" > < code > userboot< / code > （第一个开始执行的用户进程）< / a > 。< / p >
< p > 如果没有作业句柄（ ） ， < / p >
< p > < a href = "https://fuchsia.dev/docs/concepts/booting/program_loading" > 程序加载< / a > 由内核层以上的用户空间工具和协议提供。< / p >
< p > 一些相关的系统调用：< / p >
< p > < a href = "https://fuchsia.dev/docs/reference/syscalls/process_create" > < code > zx_process_create()< / code > < / a > , < a href = "https://fuchsia.dev/docs/reference/syscalls/process_start" > < code > zx_process_start()< / code > < / a > , < a href = "https://fuchsia.dev/docs/reference/syscalls/thread_create" > < code > zx_thread_create()< / code > < / a > , < a href = "https://fuchsia.dev/docs/reference/syscalls/thread_start" > < code > zx_thread_start()< / code > < / a > < / p >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "进程管理process-与-job-对象" > < a class = "header" href = "#进程管理process-与-job-对象" > 进程管理： < / a > < / h1 >
< h2 id = "process-与-job" > < a class = "header" href = "#process-与-job" > Process 与 Job< / a > < / h2 >
< blockquote >
< p > 介绍 Process 与 Job 的整体设计< / p >
< p > 实现 Process 和 Job 对象的基本框架，支持树状结构< / p >
< / blockquote >
< h2 id = "job-policy-策略" > < a class = "header" href = "#job-policy-策略" > Job Policy 策略< / a > < / h2 >
< blockquote >
< p > 实现 JobPolicy< / p >
< / blockquote >
< h2 id = "作业job" > < a class = "header" href = "#作业job" > 作业Job< / a > < / h2 >
< h3 id = "概要-1" > < a class = "header" href = "#概要-1" > 概要< / a > < / h3 >
< p > 作业是一组进程， （ ） （ ） ， （ ， ） ， （ ） < / p >
< h3 id = "描述-1" > < a class = "header" href = "#描述-1" > 描述< / a > < / h3 >
< p > 作业是包含以下内容的对象：< / p >
< ul >
< li > 对父作业的引用< / li >
< li > 一组子作业（每个子作业的父作业既是这个作业）< / li >
< li > 一组成员进程< / li >
< li > 一套策略（ ） < / li >
< / ul >
< p > 由多个进程组成的“应用程序”可作为单个实体，被作业基于一套策略进行控制。< / p >
< h3 id = "作业策略job-policy" > < a class = "header" href = "#作业策略job-policy" > 作业策略Job Policy< / a > < / h3 >
< p > < a href = "https://fuchsia.dev/fuchsia-src/concepts/settings/policy/policy_concepts?hl=en" > 策略policy< / a > 可在Kernel运行时动态修改系统的各种配置（ ） （ ） < / p >
< h4 id = "策略的行为policyaction" > < a class = "header" href = "#策略的行为policyaction" > 策略的行为PolicyAction< / a > < / h4 >
< p > 策略的行为包括：< / p >
< ul >
< li > Allow 允许条件< / li >
< li > Deny 拒绝条件< / li >
< li > AllowException 通过 debugt port 生成异常，异常处理完毕后可恢复执行且运行条件< / li >
< li > DenyException 通过 debugt port 生成异常，异常处理完毕后可恢复执行< / li >
< li > Kill 杀死进程< / li >
< / ul >
< h4 id = "应用策略时的条件-policycondition" > < a class = "header" href = "#应用策略时的条件-policycondition" > 应用策略时的条件 PolicyCondition< / a > < / h4 >
< p > 应用策略时的条件包括：< / p >
< ul >
< li > BadHandle： ， < code > PolicyAction::Allow< / code > 并且< code > PolicyAction::Deny< / code > 是等效的： ， < / li >
< li > WrongObject： < / li >
< li > VmarWx： < / li >
< li > NewAny： ， ， ， ， ， ， ， < / li >
< li > NewVMO： < / li >
< li > NewChannel： < / li >
< li > NewEvent： < / li >
< li > NewEventPair： < / li >
< li > NewPort： < / li >
< li > NewSocket： < / li >
< li > NewFIFO： < / li >
< li > NewTimer： < / li >
< li > NewProcess： < / li >
< li > NewProfile： < / li >
< li > AmbientMarkVMOExec： （ ） ， < / li >
< / ul >
< h2 id = "进程process" > < a class = "header" href = "#进程process" > 进程Process< / a > < / h2 >
< p > 进程是传统意义上程序的一个运行实例，包含一组指令和数据，这些指令将由一个或多个线程执行，并拥有一组资源。在具体实现上，进程包括如下内容：< / p >
< ul >
< li > Handles ：大部分是进程用到的资源对象的句柄< / li >
< li > Virtual Memory Address Regions： < / li >
< li > Threads： < / li >
< / ul >
< p > 进程包含在作业（ ） ， （ ） < / p >
< h3 id = "生命周期lifetime" > < a class = "header" href = "#生命周期lifetime" > 生命周期(lifetime)< / a > < / h3 >
< p > 进程有自己的生命周期，从开始创建到直到被强制终止或程序退出为止。可通过调用< code > Process::create()< / code > 创建一个进程，并调用< code > Process::start()< / code > 开始执行 。该进程在以下情况下停止执行：< / p >
< ul >
< li > 最后一个线程终止或退出< / li >
< li > 进程调用 < code > Process::exit()< / code > < / li >
< li > 父作业（ ） < / li >
< li > 父作业（ ） （ ） < / li >
< / ul >
< p > 注：< code > Process::start()< / code > 不能被调用两次。新线程不能被添加到已启动的进程。< / p >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "线程管理thread-对象" > < a class = "header" href = "#线程管理thread-对象" > 线程管理： < / a > < / h1 >
< h2 id = "线程状态" > < a class = "header" href = "#线程状态" > 线程状态< / a > < / h2 >
< p > 线程对象是代表分时CPU的执行上下文的一种结构。线程对象与特定的进程对象相关联， < / p >
< h2 id = "生命期" > < a class = "header" href = "#生命期" > 生命期< / a > < / h2 >
< p > 线程是通过调用Thread::create()创建的， < / p >
< p > 传递给Process::start()的线程应该是在一个进程上开始执行的第一个线程。< / p >
< p > 下列情况都可导致一个线程终止执行：< / p >
< ul >
< li > 通过调用 < code > CurrentThread::exit()< / code > < / li >
< li > 当父进程终止时< / li >
< li > 通过调用 < code > Task::kill()< / code > < / li >
< li > 在生成没有处理程序或处理程序决定终止线程的异常之后。< / li >
< / ul >
< p > 从入口例程返回并不终止执行。入口点的最后一个动作应该是调用CurrentThread::exit()。< / p >
< p > 关闭一个线程的最后一个句柄并不终止执行。为了强行杀死一个没有可用句柄的线程， < / p >
< p > 本地线程总是分离的（< em > detached< / em > ） ， （ ） ， （ ） < / p >
< h2 id = "信号" > < a class = "header" href = "#信号" > 信号< / a > < / h2 >
< p > 线程提供以下信号：< / p >
< ul >
< li > THREAD_TERMINATED< / li >
< li > THREAD_SUSPENDED< / li >
< li > THREAD_RUNNING< / li >
< / ul >
< p > 当一个线程启动执行时， ， ， ， ， ， ， < / p >
< p > 注意， < / p >
< h2 id = "线程状态threadstate" > < a class = "header" href = "#线程状态threadstate" > 线程状态(ThreadState)< / a > < / h2 >
< blockquote >
< p > 状态转移：创建 -> 运行 -> 暂停 -> 退出，最好有个状态机的图< / p >
< p > 实现 ThreadState， < / p >
< / blockquote >
< pre > < pre class = "playground" > < code class = "language-rust edition2018" >
< span class = "boring" > #![allow(unused)]
< / span > < span class = "boring" > fn main() {
< / span > pub enum ThreadState {
New, \\该线程已经创建，但还没有开始运行
Running, \\该线程正在正常运行用户代码
Suspended, \\由于zx_task_suspend()而暂停
Blocked, \\在一个系统调用中或处理一个异常而阻塞
Dying, \\线程正在被终止的过程中，但还没有停止运行
Dead, \\该线程已停止运行
BlockedException, \\该线程在一个异常中被阻塞
BlockedSleeping, \\该线程在zx_nanosleep()中被阻塞
BlockedFutex, \\该线程在zx_futex_wait()中被阻塞
BlockedPort, \\该线程在zx_port_wait()中被被阻塞
BlockedChannel, \\该线程在zx_channel_call()中被阻塞
BlockedWaitOne, \\该线程在zx_object_wait_one()中被阻塞
BlockedWaitMany, \\该线程在zx_object_wait_many()中被阻塞
BlockedInterrupt, \\该线程在zx_interrupt_wait()中被阻塞
BlockedPager, \\被Pager阻塞 （目前没用到???）
}
< span class = "boring" > }
< / span > < / code > < / pre > < / pre >
< h2 id = "线程寄存器上下文" > < a class = "header" href = "#线程寄存器上下文" > 线程寄存器上下文< / a > < / h2 >
< blockquote >
< p > 定义 ThreadState， ， < / p >
@ -825,6 +959,9 @@ impl Process {
< blockquote >
< p > 根据文档梳理 VMO 的主要特性< / p >
< / blockquote >
< p > 虚拟拟内存对象（ ， ） ， < / p >
< p > 它们可以通过 < a href = "https://fuchsia.dev/docs/reference/syscalls/vmar_map" > < code > zx_vmar_map()< / code > < / a > 被映射到一个进程（ ） ， < a href = "https://fuchsia.dev/docs/reference/syscalls/vmar_unmap" > < code > zx_vmar_unmap()< / code > < / a > 来解除映射。可以使用< a href = "https://fuchsia.dev/docs/reference/syscalls/vmar_protect" > < code > zx_vmar_protect()< / code > < / a > 来调整映射页面的权限。< / p >
< p > 也可以直接使用< a href = "https://fuchsia.dev/docs/reference/syscalls/vmo_read" > < code > zx_vmo_read()< / code > < / a > 来读取VMO和通过使用 < a href = "https://fuchsia.dev/docs/reference/syscalls/vmo_write" > < code > zx_vmo_write()< / code > < / a > 来写入 VMO。因此， ， ， （ < / p >
< h2 id = "实现-vmo-对象框架" > < a class = "header" href = "#实现-vmo-对象框架" > 实现 VMO 对象框架< / a > < / h2 >
< blockquote >
< p > 实现 VmObject 结构，其中定义 VmObjectTrait 接口，并提供三个具体实现 Paged, Physical, Slice< / p >
@ -868,6 +1005,7 @@ impl Process {
< / blockquote >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "虚拟内存vmar-对象" > < a class = "header" href = "#虚拟内存vmar-对象" > 虚拟内存： < / a > < / h1 >
< h2 id = "vmar-简介" > < a class = "header" href = "#vmar-简介" > VMAR 简介< / a > < / h2 >
< p > 虚拟内存地址区域（ ， ） ， < a href = "https://fuchsia.dev/docs/reference/syscalls/vmar_map" > < code > zx_vmar_map()< / code > < / a > 和 < a href = "https://fuchsia.dev/docs/reference/syscalls/vmar_allocate" > < code > zx_vmar_allocate()< / code > < / a > 接口来划分 。 < a href = "https://fuchsia.dev/docs/reference/syscalls/vmar_allocate" > < code > zx_vmar_allocate()< / code > < / a > 可用于生成新的 VMAR（ ） ， < / p >
< h2 id = "实现-vmar-对象框架" > < a class = "header" href = "#实现-vmar-对象框架" > 实现 VMAR 对象框架< / a > < / h2 >
< blockquote >
< p > 定义 VmAddressRange， < / p >
@ -949,6 +1087,17 @@ impl Process {
< p > 实现 sys_channel_read 和 sys_debuglog_write< / p >
< / blockquote >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "信号和等待" > < a class = "header" href = "#信号和等待" > 信号和等待< / a > < / h1 >
< h2 id = "信号-1" > < a class = "header" href = "#信号-1" > 信号< / a > < / h2 >
< p > 对象可能有多达 32 个信号（由 zx_signals < em > t 类型和 ZX< / em > < strong > SIGNAL< / strong > 定义表示），它们表示有关其当前状态的一条信息。例如，通道和套接字可能是 READABLE 或 WRITABLE 的。进程或线程可能会被终止。等等。< / p >
< p > 线程可以等待信号在一个或多个对象上变为活动状态。< / p >
< h2 id = "等待" > < a class = "header" href = "#等待" > 等待< / a > < / h2 >
< p > 线程可用于< a href = "https://fuchsia.dev/docs/reference/syscalls/object_wait_one" > < code > zx_object_wait_one()< / code > < / a > 等待单个句柄上的信号处于活动状态或 < a href = "https://fuchsia.dev/docs/reference/syscalls/object_wait_many" > < code > zx_object_wait_many()< / code > < / a > 等待多个句柄上的信号。两个调用都允许超时，即使没有信号挂起，它们也会返回。< / p >
< p > 超时可能会偏离指定的截止时间，具体取决于计时器的余量。< / p >
< p > 如果线程要等待大量句柄， （ ） ， ， ， ， < / p >
< h2 id = "事件与事件对" > < a class = "header" href = "#事件与事件对" > 事件与事件对< / a > < / h2 >
< p > 事件（ ） ， < / p >
< p > 事件对（ ） ， （ ） ， < / p >
< p > 见：< a href = "https://fuchsia.dev/docs/reference/syscalls/event_create" > < code > zx_event_create()< / code > < / a > , 和< a href = "https://fuchsia.dev/docs/reference/syscalls/eventpair_create" > < code > zx_eventpair_create()< / code > < / a > 。< / p >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "等待内核对象的信号" > < a class = "header" href = "#等待内核对象的信号" > 等待内核对象的信号< / a > < / h1 >
< h2 id = "信号与等待机制简介" > < a class = "header" href = "#信号与等待机制简介" > 信号与等待机制简介< / a > < / h2 >
< h2 id = "在内核对象中加入信号" > < a class = "header" href = "#在内核对象中加入信号" > 在内核对象中加入信号< / a > < / h2 >
@ -991,6 +1140,7 @@ impl Process {
< p > Futex 是现代 OS 中用户态同步互斥的唯一底层设施< / p >
< p > 为什么快：利用共享内存中的原子变量，避免进入内核< / p >
< / blockquote >
< p > Futexes 是内核原语， （ ， ） ， （ ） < / p >
< h2 id = "实现基础元语wait-和-wake" > < a class = "header" href = "#实现基础元语wait-和-wake" > 实现基础元语： < / a > < / h2 >
< blockquote >
< p > 实现 wait 和 wake 函数，并做单元测试< / p >
@ -999,6 +1149,168 @@ impl Process {
< blockquote >
< p > 实现 Zircon 中定义的复杂 API< / p >
< / blockquote >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "硬件抽象层" > < a class = "header" href = "#硬件抽象层" > 硬件抽象层< / a > < / h1 >
< div style = "break-before: page; page-break-before: always;" > < / div > < h1 id = "zcore-的用户态运行支持" > < a class = "header" href = "#zcore-的用户态运行支持" > zCore 的用户态运行支持< / a > < / h1 >
< p > libos 版 zCore（ ） （ ） < / p >
< h2 id = "hal-层接口设计" > < a class = "header" href = "#hal-层接口设计" > HAL 层接口设计< / a > < / h2 >
< p > HAL 层的设计是在bzCore 和 uzCore 的开发过程中逐渐演进形成的，在开发过程中将硬件实现相关的接口,比如页表、物理内存分配等进行封装,暴露给上层的内核对象层使用。在 kernel < / p >
< p > 对内核对象层而言,所依赖的硬件环境不再是真实硬件环境中能够看到的物理内存、CPU、MMU 等,而是 HAL 暴露给上层的一整套接口。这一点从设计上来说,是 zCore 与 Zircon 存在差异的一点。Zircon 将 x86_64 、ARM64 的硬件架构进行底层封装,但是没有给出一套统一的硬件 API 供上层的内核对象直接使用,在部分内核对象的实现中,仍然需要通过宏等手段对代码进行条件编译,从而支持同时面向两套硬件架构进行开发。而在 zCore 的内核对象层实现中,可以完全不考虑底层硬件接口的实现,使一套内核对象的模块代码可以同时在 bzCore和 uzCore 上运行,之后如果 zCore 进一步支持 RISC-V 64 架构（已初步实现）,只需要新增一套 HAL的实现,无需修改上层代码。下面将列出目前的uzCore的HAL层， < / p >
< h3 id = "hal接口名称----功能描述" > < a class = "header" href = "#hal接口名称----功能描述" > < strong > HAL接口名称 功能描述< / strong > < / a > < / h3 >
< ul >
< li > 线程相关
< ul >
< li > hal_thread_spawn Thread::spawn创建一个新线程并加入调度< / li >
< li > hal_thread_set_tid Thread::set_tid 设定当前线程的 id< / li >
< li > hal_thread_get_tid Thread::get_tid 获取当前线程的 id< / li >
< / ul >
< / li >
< li > future
< ul >
< li > yield_now暂时让出 CPU， < / li >
< li > sleep_until 休眠直到定时到达< / li >
< li > YieldFuture 放弃执行的future< / li >
< li > SleepFuture 睡眠且等待被唤醒的future< / li >
< li > SerialFuture 通过serial_read获得字符的future< / li >
< / ul >
< / li >
< li > 上下文切换相关
< ul >
< li > VectorRegs < / li >
< li > hal_context_run context_run 进入“用户态”运行< / li >
< / ul >
< / li >
< li > 用户指针相关
< ul >
< li > UserPtr < / li >
< li > IoVec 非连续buffer集合（ ） ： < / li >
< / ul >
< / li >
< li > 页表相关
< ul >
< li > hal_pt_currentPageTable::current 获取当前页表< / li >
< li > hal_pt_newPageTable::new 新建一个页表< / li >
< li > hal_pt_map PageTable::map 将一个物理页帧映射到一个虚拟地址中< / li >
< li > hal_pt_unmap PageTable::unmap 解映射某个虚拟地址< / li >
< li > hal_pt_protect PageTable::protect 修改vaddr对应的页表项的flags< / li >
< li > hal_pt_query PageTable::query 查询某个虚拟地址对应的页表项状态< / li >
< li > hal_pt_table_phys PageTable::table_phys 获取对应页表的根目录表物理地址< / li >
< li > hal_pt_activate PageTable::activate 激活当前页表< / li >
< li > PageTable::map_many 同时映射多个物理页帧到连续虚拟内存空间< / li >
< li > PageTable::map_cont 同时映射连续的多个物理页帧到虚拟内存空间< / li >
< li > hal_pt_unmap_cont PageTable::unmap_cont 解映射某个虚拟地址开始的一片范围< / li >
< li > MMUFlags < / li >
< / ul >
< / li >
< li > 物理页帧相关
< ul >
< li > hal_frame_alloc PhysFrame::alloc 分配一个物理页帧< / li >
< li > hal_frame_alloc_contiguous PhysFrame::alloc_contiguous_base 分配一块连续的物理内存< / li >
< li > PhysFrame::addr 返回物理页帧对应的物理地址< / li >
< li > PhysFrame::alloc_contiguous 分配一块连续的物理内存< / li >
< li > PhysFrame::zero_frame_addr （ ， ） < / li >
< li > PhysFrame::drop < / li >
< li > hal_pmem_read pmem_read 读取某特定物理页帧的内容到缓冲区< / li >
< li > hal_pmem_write pmem_write 将缓冲区中的内容写入某特定物理页帧< / li >
< li > hal_frame_copy frame_copy 复制物理页帧的内容< / li >
< li > hal_frame_zero frame_zero_in_range 物理页帧清零< / li >
< li > hal_frame_flush frame_flush将物理页帧的数据从 Cache 刷回内存< / li >
< / ul >
< / li >
< li > 基本I/O外设
< ul >
< li > hal_serial_read serial_read 字符串输入< / li >
< li > hal_serial_write serial_write 字符串输出< / li >
< li > hal_timer_now timer_now 获取当前时间< / li >
< li > hal_timer_set timer_set 设置一个时钟， ， < / li >
< li > hal_timer_set_next timer_set_next 设置下一个时钟< / li >
< li > hal_timer_tick timer_tick当时钟中断产生时会调用的时钟函数， < / li >
< / ul >
< / li >
< li > 中断处理
< ul >
< li > hal_irq_handle handle 中断处理例程< / li >
< li > hal_ioapic_set_handle set_ioapic_handle x86相关， < / li >
< li > hal_irq_add_handle add_handle 对某中断添加中断处理例程< / li >
< li > hal_ioapic_reset_handle reset_ioapic_handle 重置级中断控制器并设置处理例程< / li >
< li > hal_irq_remove_handle remove_handle 移除某中断的中断处理例程< / li >
< li > hal_irq_allocate_block allocate_block 给某中断分配连续区域< / li >
< li > hal_irq_free_block free_block 给某中断释放连续区域< / li >
< li > hal_irq_overwrite_handler overwrite_handler 覆盖某中断的中断处理例程< / li >
< li > hal_irq_enable enable 使能某中断< / li >
< li > hal_irq_disable disable 屏蔽某中断< / li >
< li > hal_irq_maxinstr maxinstr x86相关， < / li >
< li > hal_irq_configure configure 对某中断进行配置???< / li >
< li > hal_irq_isvalid is_valid 查询某中断是否有效< / li >
< / ul >
< / li >
< li > 硬件平台相关
< ul >
< li > hal_vdso_constants vdso_constants 得到平台相关常量参数
< ul >
< li > struct VdsoConstants ： < / li >
< / ul >
< / li >
< / ul >
< / li >
< / ul >
< p > max_num_cpus < / p >
< pre > < code > * fetch_fault_vaddr fetch_fault_vaddr 取得出错的地址 ???好像缺了hal_*
* fetch_trap_num fetch_trap_num 取得中断号
* hal_pc_firmware_tables pc_firmware_tables x86相关，
* hal_acpi_table get_acpi_table 得到acpi table
* hal_outpd outpd x86相关，
* hal_inpd inpd x86相关，
* hal_apic_local_id apic_local_id 得到本地(local) APIC ID
* fill_random 产生随机数，
< / code > < / pre >
< p > 在上述“线程相关”的列表中，列出了 HAL 层的部分接口设计,覆盖线程调度方面。在线程调度方面,Thread 结构体相关的接口主要用于将一个线程加入调度等基本操作。在 zCore 的相关实现中,线程调度的各接口使用 naive < / p >
< p > 在内存管理方面,HAL 层将内存管理分为页表操作与物理页帧管理两方面,并以此设计接口。在 zCore 实现中,物理页帧的分配与回收由于需要设计物理页帧分配器,且可分配范围大小与内核刚启动时的内存探测密切相关,我们将其直接在总控模块 zCore 中进行实现。而在 uzCore 中,页表对应操作依赖 mmap 进行模拟,物理页帧的相关操作则直接使用用户态物理内存分配器进行模拟。< / p >
< p > 在 Zircon 的设计中,内存的初始状态应该设置为全 0,为了在内核对象层满足该要求,我们为 HAL 层设计了零页接口,要求 HAL 层保留一个内容为全 0 的物理页帧,供上层使用。上层负责保证该零页内容不被修改。< / p >
< h2 id = "修改-vdso" > < a class = "header" href = "#修改-vdso" > 修改 VDSO< / a > < / h2 >
< p > VDSO 是由内核提供、并只读映射到用户态的动态链接库，以函数接口形式提供系统调用接口。原始的 VDSO 中将会最终使用 syscall 指令从用户态进入内核态。但在 uzCore 环境下,内核和用户程序都运行在用户态,因此需要将 syscall 指令修改为函数调用,也就是将 sysall 指令修改为 call 指令。为此我们修改了 VDSO 汇编代码，将其中的 syscall 替换为 call， < / p >
< h2 id = "调整地址空间范围" > < a class = "header" href = "#调整地址空间范围" > 调整地址空间范围< / a > < / h2 >
< p > 在 uzCore 中,使用 mmap 来模拟页表,所有进程共用一个 64 位地址空间。因此,从地址空间范围这一角度来说,运行在 uzCore 上的用户程序所在的用户进程地址空间无法像 Zircon 要求的一样大。对于这一点,我们在为每一个用户进程设置地址空间时,手动进行分配,规定每一个用户进程地址空间的大小为 0x100_0000_0000,从 0x2_0000_0000 开始依次排布。0x0 开始至 0x2_0000_0000 规定为 uzCore 内核所在地址空间,不用于 mmap。图 3.3给出了 uzCore 在运行时若干个用户进程的地址空间分布。< / p >
< p > 与 uzCore 兼容,zCore 对于用户进程的地址空间划分也遵循同样的设计,但在裸机环境下,一定程度上摆脱了限制,能够将不同用户地址空间分隔在不同的页表中。如图 3.4所示,zCore 中将三个用户进程的地址空间在不同的页表中映射,但是为了兼容 uzCore 的运行,每一个用户进程地址空间中用户程序能够真正访问到的部分都仅有 0x100_0000_0000 大小。< / p >
< h2 id = "libos源代码分析记录" > < a class = "header" href = "#libos源代码分析记录" > LibOS源代码分析记录< / a > < / h2 >
< h3 id = "zcore-on-riscv64的libos支持" > < a class = "header" href = "#zcore-on-riscv64的libos支持" > zCore on riscv64的LibOS支持< / a > < / h3 >
< ul >
< li > LibOS unix模式的入口在linux-loader main.rs:main()< / li >
< / ul >
< p > 初始化包括kernel_hal_unix， ， ； < / p >
< p > 重点工作应该在kernel_hal_unix中的< strong > 内核态与用户态互相切换< / strong > 的处理。< / p >
< p > kernel_hal_unix初始化主要包括了， ， ； < / p >
< ul >
< li > 为什么要注册这个信号处理函数呢？< / li >
< / ul >
< p > 根据wrj的说明： ， ， ， < / p >
< p > kernel_hal_unix还构造了< strong > 进入用户态< / strong > 所需的run_fncall() -> syscall_fn_return()； < / p >
< p > 而用户程序需要调用syscall_fn_entry()来< strong > 返回内核态< / strong > ； < / p >
< p > Linux-x86_64平台运行时， < / p >
< ul >
< li > Linux 和 macOS 下如何分别通过系统调用设置 fsbase / gsbase 。< / li >
< / ul >
< p > 这个转换过程调用到了trapframe库， ， ； < / p >
< ul >
< li > 关于fs寄存器< / li >
< / ul >
< p > 查找了下， ， ； < / p >
< p > fs寄存器被glibc定义为存放tls信息， ； < / p >
< p > 进入用户态前，将内核栈指针保存在内核 glibc 的 TLS 区域中。< / p >
< p > 可参考一个运行时程序的代码转换工具：< a href = "https://github.com/DynamoRIO/dynamorio/issues/1568#issuecomment-239819506?fileGuid=VMAPV7ERl7HbpNqg" > https://github.com/DynamoRIO/dynamorio/issues/1568#issuecomment-239819506< / a > < / p >
< ul >
< li > < strong > LibOS内核态与用户态的切换< / strong > < / li >
< / ul >
< p > Linux x86_64中， ， ； < / p >
< p > 例如clone系统调用， ； ， ， < / p >
< p > 计算tls结构体偏移： < / p >
< p > 经过试验， ， ： ， ： ， ： ； < / p >
< p > riscv64平台， ： ， ： ， ： ； < / p >
< p > 计算tls偏移量时， ， ， ， < / p >
< ul >
< li > 关于Linux user mode (UML)< / li >
< / ul >
< p > " No, UML works only on x86 and x86_64." < / p >
< p > < a href = "https://sourceforge.net/p/user-mode-linux/mailman/message/32782012/?fileGuid=VMAPV7ERl7HbpNqg" > https://sourceforge.net/p/user-mode-linux/mailman/message/32782012/< / a > < / p >
< / main >
chyyuu
5 years ago