ChoChoX/obsidian
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
obsidian/操作系统/01_系统运行机制/01_系统运行机制.md

697 lines
26 KiB
Markdown
Raw Permalink Normal View History

vault backup: 2026-06-13 23:46:22
2026-06-13 23:46:22 +08:00
# 第1.5章 系统运行机制
> [!abstract] 学习目标
> 1. 理解多进程并发运行的场景及其对硬件支持的需求
> 2. 掌握中断机制的工作原理，理解时钟中断对操作系统的核心作用
> 3. 理解 MMU（存储管理部件）如何实现进程隔离与地址转换
> 4. 掌握 CPU 双模式工作原理（内核模式 vs 用户模式）及特权指令的划分
> 5. 理解系统调用的完整流程（从用户程序到内核服务）
> 6. 理解广义中断的分类（外部中断、异常）
> 7. 能够综合运用上述机制，解释操作系统如何实现多任务并发执行
> [!info] 前置知识
> - 计算机组成原理：CPU、内存、寄存器的基本概念
> - 二进制与地址的基本概念
> - 进程的基本概念（参见 [[06_进程控制]]）
---
## 一、为什么需要系统运行机制？
### 1.1 多进程并发运行场景
在现代操作系统中，多个进程需要**并发**（交替）执行。考虑两个进程 A 和 B：
```
进程 A 的代码： 进程 B 的代码：
A:1 B:1
A:2 B:2
A:3 B:3
A:4 B:4
A:5 B:5
```
实际在 CPU 上的执行顺序可能是：
```
时间线 → A:1 B:1 A:2 B:2 A:3 B:3 B:4 A:4 A:5 B:5
```
> [!question] 核心问题
> 这种交替执行不会自然发生！CPU 只是一个顺序执行指令的"傻瓜机器"，它不会自动在 A 和 B 之间切换。要实现多进程并发运行，**必须有硬件和操作系统的支持**。
实现多进程并发运行需要以下关键机制：
| 机制 | 作用 |
|------|------|
| [[#二、中断机制]] | 让 CPU 能够响应外部事件，实现进程切换的"触发器" |
| [[#三、MMU 存储管理部件]] | 实现进程间的地址隔离，防止互相干扰 |
| [[#四、CPU 工作模式]] | 区分特权操作，保护操作系统内核不被用户程序破坏 |
| [[#五、系统调用机制]] | 为用户程序提供受控的内核服务访问途径 |
---
## 二、中断机制
### 2.1 什么是中断？
**中断**（Interrupt）是指 CPU 在执行程序的过程中，收到来自外部设备或内部异常的信号，暂停当前程序的执行，转而去处理该事件，处理完毕后再返回原程序继续执行的过程。
> [!tip] 生活类比
> 中断就像你在看书时手机响了（外部中断），你先记住看到哪一页（保存断点），然后去接电话（处理中断），接完电话后回到那一页继续看（恢复执行）。
### 2.2 中断处理流程
CPU 处理一次中断的完整流程如下：
```mermaid
flowchart TD
A["CPU 正在执行用户程序"] --> B{"收到中断请求？"}
B -- "否" --> A
B -- "是" --> C["关中断（防止嵌套中断）"]
C --> D["保存断点<br>（PC、PSW 压入内核栈）"]
D --> E["保存通用寄存器<br>（保存进程现场）"]
E --> F["识别中断源<br>（查询中断向量表）"]
F --> G["跳转到中断服务程序<br>（PC ← 中断向量地址）"]
G --> H["执行中断服务程序<br>（处理具体的中断事件）"]
H --> I["恢复通用寄存器<br>（恢复进程现场）"]
I --> J["恢复断点<br>（PC、PSW 出栈）"]
J --> K["开中断"]
K --> L["继续执行用户程序"]
style A fill:#e1f5fe
style C fill:#ffcdd2
style D fill:#ffcdd2
style G fill:#fff3e0
style H fill:#fff3e0
style J fill:#e1f5fe
```
**关键步骤详解**：
1. **关中断**：CPU 响应中断后立即关闭中断信号接收，防止在处理一个中断时又被另一个中断打断（中断嵌套）
2. **保存断点**：将程序计数器（PC）和程序状态字（PSW）压入内核栈，记录"回来后从哪里继续执行"
3. **保存现场**：将通用寄存器的内容保存到进程的 PCB（进程控制块）中
4. **识别中断源**：通过中断向量表（Interrupt Vector Table）确定是哪个设备发出的中断
5. **执行中断服务程序**：跳转到对应的中断处理函数，完成实际的处理工作
6. **恢复现场和断点**：从 PCB 恢复寄存器，从栈中弹出 PC 和 PSW
7. **开中断**：重新允许 CPU 接收中断信号
### 2.3 时钟中断 — 操作系统的"心跳"
> [!important] 时钟中断的核心地位
> **时钟中断**（Timer Interrupt）是由实时时钟（RTC，Real-Time Clock）硬件周期性产生的中断，是操作系统实现进程管理的最关键机制。
时钟中断的工作原理：
```mermaid
sequenceDiagram
participant RTC as 实时时钟 (RTC)
participant CPU
participant OS as 操作系统
participant PA as 进程 A
participant PB as 进程 B
PA->>CPU: 正在执行进程 A
RTC->>CPU: 时钟中断（每 10ms）
CPU->>OS: 保存 A 的现场，进入内核
OS->>OS: 检查：A 的时间片用完了吗？
OS->>CPU: 切换到进程 B
CPU->>PB: 恢复 B 的现场，执行进程 B
RTC->>CPU: 时钟中断（每 10ms）
CPU->>OS: 保存 B 的现场，进入内核
OS->>CPU: 切换到进程 A
CPU->>PA: 恢复 A 的现场，执行进程 A
```
**时钟中断频率**：通常为 **10ms 一次**（即每秒 100 次），也称为 **时钟滴答**（Clock Tick）。
> [!warning] 没有时钟中断会怎样？
> 如果没有时钟中断，CPU 一旦开始执行某个进程，就永远不会主动让出 CPU。操作系统将无法实现"分时"，也就无法让多个进程看起来在"同时"运行。时钟中断是操作系统实现**抢占式调度**的基础。
### 2.4 中断对操作系统的意义
中断机制对操作系统具有根本性的意义：
1. **实现进程并发执行**：时钟中断迫使 CPU 周期性地将控制权交还给操作系统，操作系统可以决定切换到哪个进程
2. **实现 I/O 管理**：设备完成 I/O 操作后通过中断通知 CPU，CPU 可以将等待该 I/O 的进程唤醒
3. **实现系统调用**：用户程序通过软中断指令（如 `int $0x80`）请求内核服务
4. **异常处理**：CPU 内部发生的异常（如除零、缺页）通过中断机制通知操作系统处理
---
## 三、MMU（存储管理部件）
### 3.1 为什么需要 MMU？
> [!question] 核心问题
> 如果没有地址隔离，进程 A 可以直接读写进程 B 的内存空间，甚至可以修改操作系统内核的代码！这是绝对不允许的。
**没有 MMU 时**：程序中使用的地址 = 物理地址
```
进程 A: MOV [0x1000], 1 → 直接写物理地址 0x1000
进程 B: MOV [0x1000], 2 → 也写物理地址 0x1000 ！冲突！
```
**有 MMU 时**：程序中使用的地址是**逻辑地址**（虚拟地址），经过 MMU 转换后才是**物理地址**
```
进程 A: MOV [0x1000], 1 → MMU 转换 → 物理地址 0x5000
进程 B: MOV [0x1000], 2 → MMU 转换 → 物理地址 0x8000 ✓ 不冲突
```
### 3.2 MMU 地址转换原理
MMU 通过**地址变换函数**将不同进程的逻辑地址映射到不同的物理地址区域：
```mermaid
flowchart LR
subgraph 进程A["进程 A"]
LA["逻辑地址空间<br>0x0000 ~ 0xFFFF"]
end
subgraph MMU_Block["MMU（存储管理部件）"]
TR1["地址变换函数 tr1()"]
end
subgraph PA_Phys["物理内存"]
PA_M["区域 1<br>物理地址 0x5000 ~ 0x14FFF"]
end
LA -->|"逻辑地址 0x1000"| TR1
TR1 -->|"物理地址 0x6000"| PA_M
style LA fill:#e1f5fe
style TR1 fill:#fff3e0
style PA_M fill:#e8f5e9
```
```mermaid
flowchart LR
subgraph 进程B["进程 B"]
LB["逻辑地址空间<br>0x0000 ~ 0xFFFF"]
end
subgraph MMU_Block2["MMU（存储管理部件）"]
TR2["地址变换函数 tr2()"]
end
subgraph PB_Phys["物理内存"]
PB_M["区域 2<br>物理地址 0x8000 ~ 0x17FFF"]
end
LB -->|"逻辑地址 0x1000"| TR2
TR2 -->|"物理地址 0x9000"| PB_M
style LB fill:#e1f5fe
style TR2 fill:#fff3e0
style PB_M fill:#e8f5e9
```
**关键概念**：
| 术语 | 含义 |
|------|------|
| **逻辑地址**（虚拟地址） | 程序中使用的地址，每个进程从 0 开始编址 |
| **物理地址** | 实际内存硬件上的地址，全局唯一 |
| **地址变换函数** | MMU 中的映射规则，每个进程有独立的变换函数 |
> [!tip] 进程隔离的本质
> 每个进程都有自己独立的**逻辑地址空间**，通过 MMU 映射到物理内存中互不重叠的区域。进程 A 无法访问进程 B 的物理内存区域，从而实现了**进程隔离**。
### 3.3 页表与 MMU 保护机制
在现代操作系统中，MMU 通常通过**页表**（Page Table）实现地址转换。页表中除了地址映射信息外，还包含保护位：
**页表项中的 U/S 位**：
| U/S 位值 | 含义 | 访问权限 |
|----------|------|----------|
| 0 | Supervisor（内核页） | 仅内核模式可访问 |
| 1 | User（用户页） | 内核模式和用户模式均可访问 |
**CPU 标志寄存器中的 IOPL 位**：
- `IOPL = 0` 或 `1`：用户模式（受限）
- `IOPL = 3`：内核模式（拥有全部 I/O 权限）
**保护机制的工作方式**：
```mermaid
flowchart TD
A["CPU 执行指令，访问逻辑地址"] --> B["MMU 查页表"]
B --> C{"当前 CPU 模式？"}
C -- "用户模式" --> D{"页表 U/S 位？"}
D -- "U/S = 1（用户页）" --> E["允许访问 ✓"]
D -- "U/S = 0（内核页）" --> F["触发保护异常 ✗<br>终止进程"]
C -- "内核模式" --> G["允许访问所有页面 ✓"]
style E fill:#c8e6c9
style F fill:#ffcdd2
style G fill:#c8e6c9
```
### 3.4 Linux 地址空间划分
操作系统将每个进程的逻辑地址空间划分为**用户空间**和**内核空间**：
| 操作系统 | 用户空间 | 内核空间 |
|----------|----------|----------|
| **32 位 Linux** | 低 3GB（0x00000000 ~ 0xBFFFFFFF） | 高 1GB（0xC0000000 ~ 0xFFFFFFFF） |
| **32 位 Windows** | 低 2GB（0x00000000 ~ 0x7FFFFFFF） | 高 2GB（0x80000000 ~ 0xFFFFFFFF） |
> [!info] 为什么内核空间在高地址？
> 将内核空间放在高地址是一种约定。在 Linux 中，所有进程共享同一个内核空间映射（内核只有一份），但每个进程的用户空间是独立的。当 CPU 处于用户模式时，访问内核空间会触发保护异常。
> [!tip] 相关链接
> 关于存储管理的更多内容，参见 [[13_存储管理基础]] 和 [[14_分页存储管理]]。
---
## 四、CPU 工作模式
### 4.1 双模式设计
现代 CPU 设计了两种工作模式，用于区分"谁可以执行什么指令"：
| 模式 | 别名 | 权限 | 使用者 |
|------|------|------|--------|
| **内核模式** | 系统态、核心态、管态 | 可执行所有指令，访问所有内存 | 操作系统内核 |
| **用户模式** | 用户态、目态 | 只能执行非特权指令，不能访问内核空间 | 用户程序 |
> [!warning] 为什么需要两种模式？
> 如果所有程序都运行在内核模式，任何一个用户程序都可以：修改操作系统代码、直接操作硬件、访问其他进程的内存。这将导致系统完全不安全。双模式设计是操作系统**自我保护**的基础。
### 4.2 特权指令 vs 非特权指令
| 分类 | 特点 | 示例 |
|------|------|------|
| **特权指令** | 只能在内核模式下执行 | I/O 指令、停机指令（HLT）、特殊寄存器访问（如修改页表基址寄存器） |
| **非特权指令** | 在任何模式下均可执行 | 算术逻辑运算（ADD、SUB）、寄存器操作（MOV）、内存访问（普通读写） |
> [!warning] 用户模式执行特权指令会怎样？
> 如果 CPU 处于用户模式时执行了特权指令，CPU 会立即触发一个**保护异常**（Protection Exception），操作系统会终止该进程（通常表现为 "Segmentation Fault"）。
### 4.3 不同架构的模式标识
CPU 通过标志寄存器中的特定位来标识当前工作模式：
**x86 架构**：使用 FLAGS 寄存器中的 **IOPL**（I/O Privilege Level）字段
```
FLAGS 寄存器:
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│ ... │ IOPL│ IOPL│ ... │ IF │ ... │ ZF │ CF │
│ │ (13)│ (12)│ │ (9) │ │ (6) │ (0) │
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
├───IOPL───┤
00 = Ring 0（内核模式）
11 = Ring 3（用户模式）
```
**ARM 架构**：使用 CPSR（Current Program Status Register）中的 **M[4:0]** 位
```
CPSR 寄存器:
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│ ... │ M4 │ M3 │ M2 │ M1 │ M0 │ ... │ │
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
├─── M[4:0] ───┤
10000 = User（用户模式）
10011 = Supervisor（内核模式）
10111 = Abort
11011 = Undefined
10010 = IRQ
10001 = FIQ
```
### 4.4 CPU 模式切换
CPU 模式切换发生在以下场景：
```mermaid
flowchart TD
subgraph 用户模式区["用户模式（User Mode）"]
A["执行用户程序"]
B["执行非特权指令"]
end
subgraph 内核模式区["内核模式（Kernel Mode）"]
C["处理中断/异常"]
D["执行系统调用"]
E["执行特权指令"]
end
A -->|"中断/异常发生<br>（时钟中断、I/O中断、缺页等）"| C
A -->|"系统调用<br>（int $0x80 / SWI）"| D
C -->|"中断返回<br>（IRET）"| A
D -->|"系统调用返回<br>（IRET）"| A
E -->|"设置 IOPL/M[4:0]"| A
style A fill:#e1f5fe
style B fill:#e1f5fe
style C fill:#fff3e0
style D fill:#fff3e0
style E fill:#fff3e0
```
**用户模式 → 内核模式**（两种途径）：
1. **中断/异常**：硬件自动切换
- 时钟中断、I/O 中断
- 缺页异常、除零异常
- 系统调用（软中断）
2. **系统调用**：用户程序主动发起
- x86：执行 `int $0x80` 指令
- ARM：执行 `SWI` 指令
**内核模式 → 用户模式**：
- 执行中断返回指令（x86: `IRET`），恢复用户模式的状态
---
## 五、系统调用机制
### 5.1 什么是系统调用？
**系统调用**（System Call）是操作系统提供给用户程序的**唯一合法途径**，用于请求内核提供的服务。
> [!tip] 生活类比
> 系统调用就像银行柜台：你（用户程序）不能自己进入金库（内核空间）取钱，但你可以通过柜台窗口（系统调用接口）告诉工作人员（内核）你要做什么，工作人员帮你完成后再把结果交给你。
### 5.2 系统调用的必要性
用户程序**不能直接调用**内核函数，原因：
1. **地址隔离**：内核函数位于内核空间，用户模式无法访问
2. **权限保护**：内核函数可能执行特权操作（如 I/O），用户模式无权执行
3. **安全控制**：内核需要验证参数的合法性，防止恶意调用
### 5.3 系统调用的完整流程
以 `printf("Hello")` 为例，完整调用链如下：
```mermaid
flowchart TD
A["用户程序<br>printf(#quot;Hello#quot;)"] --> B["C 库函数<br>write(1, #quot;Hello#quot;, 5)"]
B --> C["系统调用包装函数<br>将参数写入寄存器<br>EAX=4 (sys_write 号)<br>EBX=1 (文件描述符)<br>ECX=缓冲区地址<br>EDX=5 (长度)"]
C --> D["软中断指令<br>int $0x80"]
D --> E["CPU 模式切换<br>用户模式 → 内核模式<br>保存断点和现场"]
E --> F["查询系统调用表<br>根据 EAX=4 找到<br>sys_write 函数地址"]
F --> G["执行内核函数<br>sys_write()<br>实际完成屏幕输出"]
G --> H["系统调用返回<br>恢复现场<br>内核模式 → 用户模式"]
H --> I["返回用户程序<br>继续执行"]
style A fill:#e1f5fe
style B fill:#e1f5fe
style C fill:#e1f5fe
style D fill:#ffcdd2
style E fill:#fff3e0
style F fill:#fff3e0
style G fill:#fff3e0
style H fill:#ffcdd2
style I fill:#e1f5fe
```
### 5.4 系统调用的参数传递方式
用户程序通过**寄存器**将参数传递给内核：
**x86 架构的系统调用参数寄存器**：
| 寄存器 | 用途 |
|--------|------|
| **EAX** | 系统调用号（标识调用哪个内核函数） |
| **EBX** | 第 1 个参数 |
| **ECX** | 第 2 个参数 |
| **EDX** | 第 3 个参数 |
| **ESI** | 第 4 个参数 |
| **EDI** | 第 5 个参数 |
| **EBP** | 第 6 个参数 |
> [!info] `int $0x80` 指令的作用
> `int $0x80` 是 x86 的**软中断指令**（Software Interrupt）。执行该指令时，CPU 会：
> 1. 自动将 FLAGS、CS、IP 压入内核栈（保存断点）
> 2. 将 CPU 模式切换为内核模式
> 3. 从中断向量表的第 0x80 号表项取出中断服务程序入口地址
> 4. 跳转到该地址开始执行（即系统调用处理函数 `system_call`）
### 5.5 系统调用的底层实现
```asm
; x86 Linux 系统调用的底层实现示意
; 用户程序部分（C 库包装）
mov eax, 4 ; 系统调用号 = 4 (sys_write)
mov ebx, 1 ; 文件描述符 = 1 (stdout)
mov ecx, msg ; 缓冲区地址
mov edx, 5 ; 字节数
int 0x80 ; 触发软中断，进入内核
; 内核部分（system_call）
system_call:
; 1. 保存所有寄存器到内核栈
push eax
push ebx
push ecx
push edx
; ...
; 2. 根据 EAX 的值查系统调用表
call [sys_call_table + eax*4]
; 3. 返回值放在 EAX 中
mov [esp + 恢复位置], eax
; 4. 恢复寄存器，返回用户模式
pop edx
pop ecx
pop ebx
pop eax
iret
```
### 5.6 常见的系统调用
| 系统调用号 | 函数名 | 功能 |
|-----------|--------|------|
| 1 | `sys_exit` | 终止进程 |
| 2 | `sys_fork` | 创建子进程 |
| 3 | `sys_read` | 读文件 |
| 4 | `sys_write` | 写文件 |
| 5 | `sys_open` | 打开文件 |
| 6 | `sys_close` | 关闭文件 |
---
## 六、异常（广义中断）
### 6.1 广义中断的分类
在操作系统中，**广义的中断**包括两大类：
```mermaid
flowchart TD
A["广义中断"] --> B["外部中断<br>（硬件中断）"]
A --> C["异常<br>（内部中断）"]
B --> B1["I/O 中断<br>键盘、鼠标、网卡等设备发出"]
B --> B2["时钟中断<br>RTC 周期性发出"]
C --> C1["系统调用<br>用户执行 int $0x80 / SWI"]
C --> C2["缺页异常<br>访问的页面不在内存中"]
C --> C3["断点指令<br>调试器设置的断点"]
C --> C4["算术溢出<br>除零错误等"]
style A fill:#fff3e0
style B fill:#e1f5fe
style C fill:#ffcdd2
```
### 6.2 外部中断 vs 异常
| 特征 | 外部中断 | 异常 |
|------|----------|------|
| **来源** | CPU 外部设备 | CPU 内部执行指令时产生 |
| **发生时机** | 与当前指令无关，随机发生 | 与当前指令直接相关 |
| **是否可屏蔽** | 可屏蔽中断（INTR）可被 IF 位屏蔽 | 不可屏蔽 |
| **典型例子** | I/O 中断、时钟中断 | 缺页、除零、系统调用 |
### 6.3 常见异常类型
| 异常类型 | 触发条件 | 处理方式 |
|----------|----------|----------|
| **系统调用** | 执行 `int $0x80` 或 `SWI` | 查系统调用表，执行对应内核函数 |
| **缺页异常** | 访问的虚拟页面不在物理内存中 | 从磁盘调入页面（参见 [[14_分页存储管理]]） |
| **断点指令** | 调试器在代码中设置断点 | 暂停程序，将控制权交给调试器 |
| **算术溢出** | 除零、溢出等运算错误 | 终止进程或通知进程处理 |
| **保护异常** | 用户模式执行特权指令或访问内核空间 | 终止进程（Segmentation Fault） |
---
## 七、多任务并发执行的综合场景
### 7.1 操作系统如何实现多任务并发
操作系统通过**中断驱动**的方式实现多任务并发执行。以下是几种典型的触发场景：
```mermaid
flowchart TD
A["CPU 正在执行进程 P1"] --> B{"发生了什么？"}
B -->|"时钟中断（每 10ms）"| C["进入内核<br>调度器决定是否切换进程"]
B -->|"系统调用"| D["进入内核<br>执行内核函数"]
B -->|"I/O 请求"| E["进程 P1 等待 I/O<br>CPU 分配给其他进程"]
B -->|"进程结束"| F["进程 P1 终止<br>CPU 分配给其他进程"]
C --> G{"调度器决策"}
G -->|"继续执行 P1"| A
G -->|"切换到 P2"| H["保存 P1 现场<br>恢复 P2 现场<br>执行进程 P2"]
D --> I{"系统调用是否阻塞？"}
I -->|"不阻塞"| A
I -->|"需要等待"| E
E --> J["P1 进入等待队列<br>CPU 执行进程 P2"]
F --> K["回收 P1 资源<br>CPU 执行就绪队列中的进程"]
style A fill:#e1f5fe
style C fill:#fff3e0
style D fill:#fff3e0
style E fill:#ffcdd2
style F fill:#ffcdd2
```
### 7.2 四种典型场景详解
**场景一：时钟中断触发进程切换**
```
时间线：
P1 执行 → [时钟中断] → OS 调度 → P2 执行 → [时钟中断] → OS 调度 → P1 执行
↑ 10ms ↑ 10ms
```
**场景二：系统调用触发内核执行**
```
P1 执行 printf → [int $0x80] → 内核执行 sys_write → [iret] → P1 继续执行
```
**场景三：I/O 等待导致 CPU 重分配**
```
P1 请求读磁盘 → P1 进入等待队列 → CPU 执行 P2 → 磁盘中断 → P1 就绪 → P1 继续执行
```
**场景四：进程结束释放 CPU**
```
P1 执行 exit() → P1 终止 → OS 回收资源 → CPU 执行就绪队列中的 P2
```
> [!important] 中断是操作系统的"发动机"
> 可以说，**没有中断就没有操作系统**。中断机制是操作系统实现进程管理、I/O 管理、内存管理等所有核心功能的基础。时钟中断让 OS 能够"定期检查"系统状态，I/O 中断让 OS 能够响应设备事件，系统调用让 OS 能够为用户程序提供服务。
---
## 八、机制之间的关系
理解了各个机制后，需要看到它们之间的协同关系：
```mermaid
flowchart TD
subgraph 硬件支持
CLK["时钟中断<br>（RTC 硬件）"]
MMU_HW["MMU 硬件<br>（地址转换）"]
CPU_MODE["CPU 双模式<br>（IOPL/M[4:0]）"]
INT_HW["中断控制器<br>（PIC/APIC）"]
end
subgraph OS核心功能
PROC["进程管理<br>（调度、切换）"]
MEM["内存管理<br>（地址隔离）"]
PROT["系统保护<br>（内核安全）"]
IO["I/O 管理<br>（设备驱动）"]
end
CLK -->|"触发进程切换"| PROC
MMU_HW -->|"地址转换 + 保护"| MEM
CPU_MODE -->|"特权级隔离"| PROT
INT_HW -->|"设备事件通知"| IO
PROC -->|"选择下一个进程"| MEM
MEM -->|"提供地址空间"| PROC
PROT -->|"限制用户操作"| PROC
style CLK fill:#ffcdd2
style MMU_HW fill:#ffcdd2
style CPU_MODE fill:#ffcdd2
style INT_HW fill:#ffcdd2
style PROC fill:#e1f5fe
style MEM fill:#e1f5fe
style PROT fill:#e1f5fe
style IO fill:#e1f5fe
```
> [!tip] 核心要点
> 操作系统的四大运行机制（中断、MMU、CPU 模式、系统调用）不是孤立的，而是相互配合：
> - **中断**提供了"进入内核"的途径
> - **CPU 模式**确保了"谁能做什么"
> - **MMU** 保证了"谁的内存谁用"
> - **系统调用**提供了"受控的内核访问"
---
## 思考与练习
以下是 PPT 中给出的复习思考题：
1. **什么是逻辑地址、物理地址？什么是内核空间、用户空间？**
- 提示：逻辑地址是程序中使用的地址，物理地址是内存硬件的实际地址；内核空间是操作系统运行的区域，用户空间是应用程序运行的区域
2. **MMU 的功能是什么，如何实现进程隔离？**
- 提示：MMU 负责逻辑地址到物理地址的转换；每个进程有独立的地址变换函数，映射到不同的物理区域
3. **特权指令与非特权指令的特点？**
- 提示：特权指令只能在内核模式执行（如 I/O 指令、停机指令），非特权指令在任何模式都可执行（如算术运算）
4. **两种 CPU 工作模式的特点？**
- 提示：内核模式可执行所有指令、访问所有内存；用户模式只能执行非特权指令、不能访问内核空间
5. **如何利用 MMU 与工作模式防止用户程序破坏 OS？**
- 提示：MMU 通过页表 U/S 位将内核页标记为仅内核模式可访问；CPU 在用户模式执行特权指令会触发保护异常
6. **CPU 模式切换方法？**
- 提示：用户→内核：中断/异常/系统调用（硬件自动切换）；内核→用户：执行 IRET 指令
7. **系统调用的作用、原理和实现过程？**
- 提示：作用是让安全地访问内核服务；原理是通过软中断指令触发模式切换；实现过程是参数通过寄存器传递，查系统调用表找到对应函数执行
8. **时钟中断对操作系统的作用？**
- 提示：时钟中断是操作系统实现进程并发执行的基础，它迫使 CPU 周期性地将控制权交还给 OS，使 OS 能够进行进程调度
9. **中断对操作系统的意义？**
- 提示：中断是操作系统的"发动机"，是实现进程管理、I/O 管理、系统调用等所有核心功能的基础
---
## 相关笔记
- [[02_Linux基础]] — Linux 系统的基本使用
- [[06_进程控制]] — 进程的创建、终止与管理
- [[11_处理机调度]] — 进程调度算法（时钟中断的实际应用）
- [[13_存储管理基础]] — 存储管理的基本概念
- [[14_分页存储管理]] — 分页存储与 MMU 的详细实现
---
## 参考资料
- 《操作系统概念》（Operating System Concepts）第1章、第2章
- 《深入理解计算机系统》（CSAPP）第1章、第9章
- 《现代操作系统》（Modern Operating Systems）第2章
Reference in New Issue Copy Permalink