01 - 操作系统概述¶

              ┌─────────────┐
              │   用户程序    │
              │ App1 App2 .. │
              └──────┬───────┘
                     │ 资源请求
              ┌──────▼───────┐
              │  操作系统     │  ← 资源管理者
              │  (OS Kernel) │
              └──────┬───────┘
                     │ 管理和分配
        ┌────────┬───┴───┬────────┐
        ▼        ▼       ▼        ▼
      CPU      内存    磁盘    I/O设备

没有操作系统时：
  程序员需要直接控制磁盘控制器的寄存器
  → 设置磁头位置、柱面号、扇区号
  → 发送读写命令、等待中断
  → 处理错误和重试
  → 极其复杂！

有操作系统后：
  程序员只需要：
  fd = open("data.txt", O_RDONLY);
  read(fd, buffer, size);
  close(fd);
  → 简单、安全、高效！

┌─────────────────────────────────┐
│         用户（User）             │  ← 最上层
├─────────────────────────────────┤
│       应用程序（Applications）   │
│    浏览器、Office、游戏...       │
├─────────────────────────────────┤
│     系统工具（System Utilities） │
│    编译器、Shell、包管理器...    │
├─────────────────────────────────┤
│     ★ 操作系统（OS Kernel）★    │  ← 核心位置
├─────────────────────────────────┤
│         硬件（Hardware）         │  ← 最底层
│    CPU、内存、磁盘、网卡...      │
└─────────────────────────────────┘

典型工作流程：
1. 程序员预约机器时间（可能是凌晨 3 点）
2. 携带纸带到机房
3. 装载纸带、开机、运行
4. 观察结果、收集输出
5. 关机、离开

→ CPU 可能 90% 的时间在空闲等待！

┌──────────┐    ┌──────────┐    ┌──────────┐
│  作业 1   │───►│  作业 2   │───►│  作业 3   │
│ (计算)    │    │ (计算)    │    │ (计算)    │
└──────────┘    └──────────┘    └──────────┘
                 顺序执行，无重叠

时间轴：
        ┌──计算──┐  ┌──计算──┐     ┌──计算──┐
作业A:  │████████│  │████████│     │████████│
        └────────┘  └────────┘     └────────┘

        ┌─I/O─┐  ┌──计算──┐  ┌─I/O─┐  ┌──计算──┐
作业B:  │▓▓▓▓▓│  │████████│  │▓▓▓▓▓│  │████████│
        └─────┘  └────────┘  └─────┘  └────────┘

CPU:    │A│  B计算  │  A计算  │  B计算  │  A计算  │
        CPU几乎不空闲！

用户A 用户B 用户C 用户D
  │     │     │     │
  ▼     ▼     ▼     ▼
┌─────────────────────┐
│     分时操作系统       │
│                     │
│  时间片轮转：         │
│  [A][B][C][D][A][B]..│
│  每个时间片约20ms    │
└──────────┬──────────┘
           ▼
         CPU

实时操作系统（RTOS）
├── 硬实时（Hard Real-Time）
│   └── 必须在截止时间前完成，否则可能造成灾难
│       例：飞行控制系统、心脏起搏器、ABS刹车系统
│
└── 软实时（Soft Real-Time）
    └── 偶尔超过截止时间可以接受，但会降低性能
        例：视频播放、音频处理、游戏

宏内核架构：
┌───────────────────────────────┐
│         用户态（User Mode）     │
│    App1    App2    App3       │
├───────────────────────────────┤
│         内核态（Kernel Mode）   │
│  进程管理 │ 内存管理 │ 文件系统  │
│  设备驱动 │ 网络     │ 安全     │
│  ...（所有功能都在内核态）       │
└───────────────────────────────┘

微内核架构：
┌────────────────────────────────────────────┐
│              用户态（User Mode）              │
│  App1  App2  │ 文件服务  网络服务  驱动程序   │
│              │（以用户态服务器进程运行）       │
├────────────────────────────────────────────┤
│              内核态（Kernel Mode）            │
│           IPC │ 调度 │ 内存保护              │
│          （最小化的微内核）                   │
└────────────────────────────────────────────┘

现代操作系统发展时间线：

1940s   1950s   1960s   1970s   1980s   1990s   2000s   2010s   2020s
  │       │       │       │       │       │       │       │       │
  │  无OS  │ 批处理  │ 分时   │ RTOS  │ 微内核 │ 混合   │  移动   │ 云+IoT │
  │       │       │  UNIX  │       │ Mach  │ NT    │ Android│ 鸿蒙   │
  │       │       │ Multics│       │ L4    │ Linux │ iOS    │ Fuchsia│
  ▼───────▼───────▼───────▼───────▼───────▼───────▼───────▼───────▼

进程管理相关系统调用：
├── fork()      // 创建子进程
├── exec()      // 加载新程序
├── wait()      // 等待子进程结束
├── exit()      // 终止进程
├── kill()      // 发送信号
├── getpid()    // 获取进程 ID
└── pthread_create()  // 创建线程

用户接口的层次：
┌──────────────┐
│  GUI / CLI   │  ← 用户直接使用
├──────────────┤
│   库函数     │  ← printf() 封装了 write()
│  (libc etc.) │
├──────────────┤
│  系统调用    │  ← 用户态到内核态的接口
│ (syscall)    │
├──────────────┤
│  OS 内核     │
└──────────────┘

┌──────────────────────────────────────────────┐
│                  操作系统                      │
│                                              │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌────┐ │
│  │进程  │ │内存  │ │文件  │ │ I/O  │ │用户│ │
│  │管理  │ │管理  │ │管理  │ │ 管理 │ │接口│ │
│  │      │ │      │ │      │ │      │ │    │ │
│  │ CPU  │ │ RAM  │ │ Disk │ │Device│ │CLI │ │
│  │调度  │ │虚拟  │ │文件  │ │驱动  │ │GUI │ │
│  │同步  │ │分页  │ │目录  │ │缓冲  │ │API │ │
│  │通信  │ │保护  │ │权限  │ │中断  │ │    │ │
│  └──────┘ └──────┘ └──────┘ └──────┘ └────┘ │
└──────────────────────────────────────────────┘

危险场景：
1. 恶意程序直接读写其他进程的内存 → 窃取密码
2. 有 bug 的程序直接操作磁盘控制器 → 破坏文件系统
3. 普通程序禁用中断 → 导致系统死机
4. 用户程序修改页表 → 绕过所有安全限制

              Ring 0（内核态）
           ┌────────────────┐
           │   OS Kernel    │  最高特权
           │  可执行所有指令 │
        ┌──┴────────────────┴──┐
        │     Ring 1           │  驱动程序
        │   (通常未使用)        │  (某些OS用)
     ┌──┴──────────────────────┴──┐
     │        Ring 2               │
     │      (通常未使用)            │
  ┌──┴────────────────────────────┴──┐
  │           Ring 3（用户态）         │
  │        用户应用程序               │  最低特权
  │     只能执行非特权指令            │
  └──────────────────────────────────┘

系统调用完整流程：

用户态                    内核态
  │                        │
  │  1. 准备参数            │
  │     (寄存器/栈)         │
  │                        │
  │  2. 执行 syscall 指令   │
  │  ─────────────────────► │
  │        trap            │  3. 保存用户态上下文
  │                        │     (寄存器、PC、SP)
  │                        │
  │                        │  4. 查系统调用表
  │                        │     根据系统调用号
  │                        │     跳转到对应处理函数
  │                        │
  │                        │  5. 执行系统调用
  │                        │     (如 read/write)
  │                        │
  │                        │  6. 恢复用户态上下文
  │  ◄───────────────────── │
  │        返回（iret）     │  7. 切换回用户态
  │                        │
  │  8. 获取返回值          │
  │                        │

系统调用的开销包括：
1. 保存/恢复寄存器上下文        ~100 cycles
2. 切换特权级（Ring 3 → Ring 0） ~50 cycles
3. TLB 刷新（如果需要）          ~variable
4. 内核代码执行                  ~variable
5. 切换回用户态                  ~50 cycles

总计：一次系统调用约 200-1000 CPU 周期
      对于 3GHz CPU，约 0.1-0.3 微秒

→ 所以应尽量减少系统调用次数（如用缓冲I/O代替直接I/O）

没有中断 → 轮询方式：
while (true) {
    if (keyboard_ready()) {       // 不断检查键盘
        char c = read_keyboard();
        process(c);
    }
    // CPU 大部分时间在做无用的检查！
}

有中断 → 中断驱动方式：
// CPU 正常执行其他任务
// 当键盘有按键时：
//   1. 键盘控制器发送中断信号给 CPU
//   2. CPU 暂停当前任务
//   3. 跳转到键盘中断处理程序
//   4. 读取按键、处理
//   5. 返回继续执行之前的任务
// → CPU 不浪费时间轮询！

CPU 接收到的事件
├── 中断（Interrupt）— 来自外部，异步
│   ├── 可屏蔽中断（Maskable Interrupt）
│   │   ├── 硬中断（Hardware Interrupt）
│   │   │   ├── 定时器中断（Timer Interrupt）
│   │   │   ├── 键盘中断
│   │   │   ├── 磁盘中断
│   │   │   └── 网卡中断
│   │   └── 软中断（Software Interrupt）
│   │       ├── Linux 的 softirq（下半部处理）
│   │       └── tasklet
│   └── 不可屏蔽中断（NMI, Non-Maskable Interrupt）
│       └── 硬件故障（如内存校验错误）
│
└── 异常（Exception）— CPU 内部，同步
    ├── Fault（故障）— 可恢复
    │   ├── 缺页异常（Page Fault）
    │   ├── 段错误的某些情况
    │   └── 一般保护异常
    ├── Trap（陷阱）— 有意触发
    │   ├── 系统调用（int 0x80 / syscall）
    │   ├── 断点（int 3，调试用）
    │   └── 溢出检测（into）
    └── Abort（终止）— 不可恢复
        ├── 硬件错误（如总线错误）
        └── 双重故障（Double Fault）

1. 设备完成操作，向中断控制器发送中断信号
2. 中断控制器判断优先级，向 CPU 的 INTR 引脚发信号
3. CPU 在当前指令执行完后检查 INTR
4. 如果 IF=1（中断未屏蔽），CPU 响应中断：
   a. 保存当前上下文（PC、PSW、寄存器）到栈
   b. 根据中断号查 IDT（中断描述符表）
   c. 获取中断处理程序的入口地址
   d. 关中断（防止嵌套）
   e. 跳转到中断处理程序执行
5. 中断处理程序执行完毕
6. 恢复上下文，开中断
7. 返回被中断的程序继续执行

问题：硬中断处理时间不能太长（会屏蔽其他中断）
解决：将中断处理分为两部分

上半部（Top Half）—— 硬中断处理
├── 快速执行
├── 屏蔽中断
├── 只做最紧急的工作（如从设备读数据到缓冲区）
└── 标记软中断，告诉下半部有工作要做

下半部（Bottom Half）—— 软中断处理
├── 延后执行
├── 不屏蔽中断
├── 处理不紧急的工作（如网络协议栈处理）
└── 通过 softirq / tasklet / workqueue 实现

网卡收到数据包
  │
  ▼ [硬中断 - 上半部]
  1. 将数据从网卡 DMA 缓冲区复制到内核缓冲区
  2. 标记 NET_RX_SOFTIRQ 软中断
  3. 硬中断返回（非常快，约几微秒）
  │
  ▼ [软中断 - 下半部]
  4. 处理网络协议栈（IP、TCP/UDP 解析）
  5. 将数据放入 Socket 接收缓冲区
  6. 唤醒等待数据的用户进程

进程访问一个页面 P
  │
  ├── P 在物理内存中 → 正常访问（无异常）
  │
  └── P 不在物理内存中 → 触发缺页 Fault
        │
        ▼
      缺页异常处理程序：
        1. 检查地址是否合法
           ├── 不合法 → 发送 SIGSEGV（段错误），终止进程
           └── 合法 → 继续
        2. 在磁盘上找到对应的页面
        3. 分配一个空闲物理页框
        4. 将页面从磁盘读入物理页框
        5. 更新页表
        6. 返回，重新执行引起缺页的那条指令
        → 这次成功访问！

系统调用使用 trap 实现：

用户程序：
  mov rax, 1        ; 系统调用号 = 1 (write)
  mov rdi, 1        ; fd = 1 (stdout)
  mov rsi, msg      ; 缓冲区地址
  mov rdx, len      ; 长度
  syscall            ; ← 触发 trap，切换到内核态
  ; ← 系统调用返回后执行这里

内核：
  1. 保存上下文
  2. 根据 rax=1 找到 sys_write
  3. 执行 sys_write
  4. 恢复上下文
  5. 返回到 syscall 的下一条指令

┌─────────────┐
│ 中断/异常发生 │
└──────┬──────┘
       ▼
┌─────────────────┐
│ 1. CPU 完成当前  │
│    指令的执行    │
└──────┬──────────┘
       ▼
┌─────────────────┐
│ 2. CPU 自动保存  │
│    PC、PSW 到栈  │
│    (硬件完成)    │
└──────┬──────────┘
       ▼
┌─────────────────┐
│ 3. 根据中断号    │
│    查 IDT 表     │
│    获取处理程序   │
│    入口地址      │
└──────┬──────────┘
       ▼
┌─────────────────┐
│ 4. 切换到内核态  │
│    (如果在用户态) │
└──────┬──────────┘
       ▼
┌─────────────────┐
│ 5. 保存更多上下文│
│    (通用寄存器)  │
│    (OS 完成)     │
└──────┬──────────┘
       ▼
┌─────────────────┐
│ 6. 执行中断      │
│    处理程序      │
└──────┬──────────┘
       ▼
┌─────────────────┐
│ 7. 恢复上下文    │
└──────┬──────────┘
       ▼
┌─────────────────┐
│ 8. 执行 iret     │
│    返回被中断的   │
│    程序继续执行   │
└─────────────────┘