六十天Linux从0到项目搭建（第十五天）（程序替换、exec流程示意图、核心特性）

1 为什么要有程序替换？

程序替换（Process Replacement）是操作系统中一个关键机制，它的核心目的是：让一个正在运行的进程（通常是子进程）停止执行当前代码，转而加载并执行一个全新的程序。

核心需求：

1. 子进程需要执行不同的任务

   • 父进程创建子进程后，子进程默认会执行父进程的代码（fork() 后的代码）。

   • 但如果子进程需要执行 完全不同的程序（如 ls、gcc 等），就需要程序替换。

2. 避免重复创建进程的开销

   • 如果每次运行新程序都先 fork() 再 exec()，可以复用已有的进程结构（如 PID、文件描述符等），比直接创建新进程更高效。

3. 实现灵活的进程管理

   • 比如 Shell 执行命令时：

     $ ls -l  # Shell fork() + exec("ls") 来运行 `ls`，而不是自己实现 `ls` 的功能

---

2. 创建子进程的目的是什么？

（1）让子进程执行父进程的一部分代码

• 默认情况下，fork() 创建的子进程会 继承父进程的代码和数据，继续执行 fork() 之后的逻辑。

• 适用场景：

  • 多进程并行计算（如分治算法）。

  • 父进程和子进程协作完成同一任务（如网络服务器处理请求）。

（2）让子进程执行一个全新的程序

• 通过 程序替换（exec 系列函数），子进程可以加载另一个程序的代码和数据，完全替换自己。

• 适用场景：

  • Shell 运行外部命令（如 ls、grep）。

  • 动态加载插件或子模块（如游戏引擎加载新关卡逻辑）。

---

3. 程序替换的本质

程序替换通过 exec 系列函数 实现，它的核心行为是：

1. 替换当前进程的代码和数据

   • 销毁当前进程的 代码段、数据段、堆栈，重新加载目标程序的代码和数据。

   • 注意：PID、文件描述符、信号处理等 进程属性不变。

2. 不创建新进程

   • exec 只是 替换当前进程的内容，不会像 fork() 那样新建进程。

3. 成功后永不返回

   • 如果 exec 成功，原程序的代码已被覆盖，exec 之后的代码不会执行。

   • 只有失败时（如目标程序不存在），exec 才会返回 -1。

---

4. 程序替换的典型用法

（1）Shell 运行命令

pid_t pid = fork();
if (pid == 0) {// 子进程替换为 `ls -l`execlp("ls", "ls", "-l", NULL);  // 如果成功，不会执行后面的代码perror("exec failed");           // 只有 exec 失败时才会执行exit(1);
} else {wait(NULL);  // 父进程等待子进程结束
}

（2）动态加载程序

// 子进程替换为自定义程序
char *argv[] = {"./my_program", "arg1", "arg2", NULL};
execv(argv[0], argv);

---

5. 程序替换 vs. 普通进程创建

场景	fork()	fork() + exec()
子进程执行的内容	父进程的代码	全新的程序代码
进程 PID	新创建的子进程	复用子进程的 PID
典型用途	多进程并行计算	Shell 执行命令、动态加载插件

---

6. 为什么不用 fork() 直接创建新程序？

• 效率问题：
  fork() 只复制进程结构，而 exec 可以复用这个结构，避免完全新建进程的开销。

• 灵活性：
  父进程可以在 fork() 后通过 exec 让子进程执行任意程序，而无需预先绑定。

---

7. 总结

• 程序替换（exec） 的目的是让进程 动态切换执行不同的程序，而不是局限于父进程的代码。

• fork() + exec() 是 Linux 运行新程序的标准方式（如 Shell 执行命令）。

• 关键特点：

  • 替换代码和数据，但保留 PID、文件描述符等。

  • 成功时不返回，失败时返回 -1。

示例类比：

• fork() 像 克隆一个自己，默认做同样的事。

• exec 像 灵魂转移，保留身体（进程资源），但彻底换了一个大脑（程序代码）

2 程序替换（Process Replacement）的原理

程序替换是操作系统提供的一种机制，允许一个进程 动态加载并执行另一个全新的程序，而无需创建新的进程。它的核心原理可以分为以下几个部分：

---

1. 程序替换的核心函数

在 Linux 中，程序替换通过 exec 系列函数 实现，主要包括：

• execl, execlp, execle（参数列表形式）

• execv, execvp, execvpe（参数数组形式）

示例：

execl("/bin/ls", "ls", "-l", NULL);  // 替换为 `ls -l`
execvp("gcc", (char *[]){"gcc", "main.c", "-o", "main", NULL});  // 替换为 `gcc`

---

2. 程序替换的核心原理

（1）替换进程的代码和数据

• 原进程的代码段（.text）、数据段（.data、.bss）、堆栈被销毁。

• 新程序的代码和数据从磁盘加载到内存，并映射到当前进程的地址空间。

• 新程序从 main 函数开始执行。

（2）保留进程的某些属性

虽然代码和数据被替换，但以下信息仍然保留：

• 进程 ID（PID）：仍然是原来的进程，只是内容变了。

• 文件描述符表：已打开的文件（如 stdin、stdout）仍然有效（除非显式设置 O_CLOEXEC）。

• 进程优先级、信号处理方式（除非新程序重新设置）。

• 用户 ID、组 ID（除非新程序是 setuid/setgid 程序）。

（3）不创建新进程

• exec 不会创建新进程，只是替换当前进程的代码和数据。

• 如果 exec 成功，原进程的代码不再执行，控制权交给新程序。

• 如果 exec 失败（如目标程序不存在），返回 -1，并继续执行原程序。

---

3. 程序替换的底层机制

（1）内核的处理流程

1. 解析目标程序：

   • 检查目标程序是否存在，是否有执行权限。

   • 读取目标程序的 ELF 头部信息（如代码段、数据段的布局）。

2. 释放原进程资源：

   • 销毁原进程的代码、数据、堆、栈等内存区域。

   • 关闭标记了 O_CLOEXEC 的文件描述符。

3. 加载新程序：

   • 将新程序的代码段（.text）、数据段（.data）加载到内存。

   • 设置新的堆栈（stack）和堆（heap）。

4. 更新进程的页表：

   • 建立虚拟地址到物理地址的新映射。

5. 跳转到新程序的入口点（通常是 _start，最终调用 main）。

（2）为什么 exec 成功后不会返回？

• exec 替换了当前进程的所有代码，包括调用 exec 的代码本身。

• 因此，如果 exec 成功，原程序的执行流被彻底覆盖，没有任何代码可以继续执行。

• 只有 exec 失败时，才会返回 -1，并继续执行原程序。

---

4. 程序替换的典型应用

（1）Shell 执行命令

$ ls -l  # Shell 会 fork() + exec("ls")，而不是自己实现 `ls` 的功能

Shell 的伪代码：

pid_t pid = fork();
if (pid == 0) {// 子进程替换为 `ls`execlp("ls", "ls", "-l", NULL);exit(1);  // 只有 exec 失败时才执行
} else {wait(NULL);  // 父进程等待子进程结束
}

（2）动态加载插件

// 子进程加载插件
if (fork() == 0) {execv("./plugin.so", args);exit(1);
}

---

5. 程序替换 vs. 普通进程创建

对比项	fork()	fork() + exec()
进程 PID	创建新进程（新 PID）	复用子进程的 PID
代码和数据	复制父进程的代码和数据	完全替换为新程序的代码和数据
典型用途	多进程并行计算	Shell 执行命令、动态加载插件

---

6. 总结

• 程序替换（exec）的本质：

  • 替换当前进程的代码和数据，但保留 PID、文件描述符等属性。

  • 不创建新进程，仅复用现有进程的“外壳”。

• 关键特点：

  • 成功时不返回（原代码被覆盖）。

  • 失败时返回 -1（如目标程序不存在）。

• 典型应用：

  • Shell 执行外部命令。

  • 动态加载插件或子模块。

类比：

• fork() 像 克隆自己（相同代码）。

• exec 像 换脑手术（保留身体，换新大脑）。

3 Linux 内核处理 exec 程序替换的流程示意图

用户态
↓
execve("/bin/ls", ["ls", "-l"], envp)  // 用户调用 exec 函数
↓
--------------------------------------------------------------
内核态（系统调用入口）
↓
1. 检查权限 & 目标文件是否存在？→ 失败？返回 -1 (ENOENT/EACCES)→ 成功？继续
↓
2. 解析目标文件（ELF 格式）├─ .text (代码段)├─ .data (初始化数据)└─ .bss  (未初始化数据)
↓
3. 准备新内存空间├─ 释放原进程的：│   ├─ 代码段│   ├─ 数据段│   └─ 堆栈└─ 加载新程序的：├─ 代码段（只读映射）├─ 数据段（私有映射）└─ 设置新堆栈
↓
4. 更新进程控制块（PCB）├─ 保留：PID、父进程、文件描述符表└─ 重置：信号处理器、计时器
↓
5. 跳转到新程序入口（_start → main）
↓
--------------------------------------------------------------
用户态
↓
新程序开始执行（原进程的代码已完全消失）

关键点说明

1. 权限检查阶段

   • 确认目标文件存在且可执行

   • 检查 setuid/setgid 权限位

2. ELF 加载阶段

   • 通过 mmap 建立代码段（只读）和数据段（可写）的映射

   • 初始化 .bss 段为零页

3. 资源清理阶段

   • 关闭标记了 FD_CLOEXEC 的文件描述符

   • 保留标准输入/输出/错误流

4. 执行转移阶段

   • 通过修改 rip 寄存器跳转到新程序的 _start 符号

   • 完全不会回到原调用点（除非加载失败）

典型错误路径

execve("/not/exist", ...)
↓
内核发现文件不存在
↓
返回 -1 (errno=ENOENT)
↓
原进程继续执行（检查返回值）

与 fork() 的对比

fork() 流程：
用户进程 → 复制PCB → 复制页表 → 返回两次exec() 流程：
用户进程 → 销毁内存映射 → 新建映射 → 永不返回（成功时）

这个流程体现了 Linux "进程是执行流的容器" 的设计哲学：保持进程外壳（PID、文件描述符等），仅替换内部执行内容。

4 多进程环境下程序替换（exec）的核心特性

1. 程序替换是「整体替换」

（不能局部替换）

原进程内存布局:
+-------------------+
|     代码段        | ← 完全被新程序覆盖
|     数据段        | ← 完全被新程序覆盖
|       堆          | ← 被新程序重建
|       栈          | ← 被新程序重建
+-------------------+

• 所有用户空间内容被替换（包括全局变量、函数指针等）

• 内核空间信息保留（PID、文件描述符、信号处理表等）

2. 进程独立性保障

（替换仅影响当前进程）

父进程 (PID=100)
├─ 子进程A (PID=101) → exec("./new_prog") → 变成全新程序
└─ 子进程B (PID=102) → 继续运行原程序

• 写时复制（COW）机制确保：

  • 子进程在exec()前与父进程共享物理页

  • exec()后所有内存页都会触发COW，建立独立映射

3. 所有exec系列接口对比

接口函数	参数传递方式	环境变量处理	路径搜索规则
execl	可变参数列表	继承父进程环境	需绝对/相对路径
execle	可变参数列表	自定义环境变量数组	需绝对/相对路径
execlp	可变参数列表	继承父进程环境	自动搜索PATH目录
execv	字符串数组	继承父进程环境	需绝对/相对路径
execvp	字符串数组	继承父进程环境	自动搜索PATH目录
execvpe	字符串数组	自定义环境变量数组	自动搜索PATH目录

4. 典型多进程替换场景

// 父进程创建多个工作子进程
for (int i = 0; i < 5; i++) {pid_t pid = fork();if (pid == 0) {// 每个子进程替换不同程序char *env[] = {"MY_ID=i", NULL};execle("./worker", "worker", NULL, env);_exit(1); // 只有exec失败时执行}
}// 父进程继续监控子进程
while (wait(NULL) > 0);

5. 关键注意事项

1. 文件描述符处理：

   • 默认保留已打开的文件描述符

   • 建议对不需要的fd设置FD_CLOEXEC标志

   fcntl(fd, F_SETFD, FD_CLOEXEC);

2. 信号处理重置：

   • 被捕获的信号会恢复为默认处理方式

   • 忽略的信号保持忽略状态

3. 进程属性保留：

   • 维持原PID、PPID关系

   • 保持调度策略和优先级

6. 底层实现简图

用户态调用execve()
↓
sys_execve() (系统调用入口)
↓
do_execve()
├─ 1. 打开目标文件
├─ 2. 解析ELF格式
├─ 3. 检查权限
├─ 4. 准备新的内存空间
│   ├─ flush_old_exec()  // 清理原内存
│   └─ setup_new_exec()  // 初始化新内存布局
└─ 5. start_thread()    // 设置新的eip/esp

这种设计保证了：

• 原子性：要么完全替换成功，要么完全失败

• 安全性：新程序无法访问原进程的任何内存数据

• 高效性：复用现有进程结构，避免创建新进程的开销