一、从一条命令开始:Shell 是如何实现重定向的?
在 Linux 终端中,我们经常使用这样的命令:
bash
ls > result.txt
cat < result.txt
echo hello >> result.txt
它们分别表示:
ls > result.txt:将命令的标准输出写入文件,文件原有内容会被清空。cat < result.txt:将文件作为命令的标准输入。echo hello >> result.txt:将命令的标准输出追加到文件末尾。
从使用者的角度看,我们只是在命令后面增加了一个符号。
但从操作系统的角度看,这些符号并没有什么特殊魔法。Shell 真正做的事情,是在程序执行之前,提前修改进程的文件描述符,让程序原本要写入终端的数据转而写入文件,或者让程序从文件中读取数据。
这正是前面几篇文章学习的知识:
- 第一篇:文件描述符是什么?
- 第二篇:
open、read、write如何操作文件? - 第三篇:
dup2如何改变文件描述符的指向? - 第四篇:
FILE缓冲区与文件描述符有什么关系? - 第五篇:如何模拟实现一个简单的用户态缓冲区?
现在,我们把这些知识放进 Shell 的执行流程中。
二、先理解重定向的本质:修改文件描述符的指向
在默认情况下,一个进程启动后,通常会拥有三个标准文件描述符:
| 文件描述符 | 名称 | 默认指向 |
|---|---|---|
| 0 | stdin | 标准输入 |
| 1 | stdout | 标准输出 |
| 2 | stderr | 标准错误 |
例如执行:
bash
printf "hello\n";
程序调用标准输出接口,最终会将数据写向文件描述符 1。
默认情况下,文件描述符 1 指向终端,因此我们能够在屏幕上看到 hello。
那么,如果我们希望把输出写入文件,是否需要修改 printf 的代码?
不需要。
我们只需要在程序执行之前,把文件描述符 1 改为指向目标文件即可。
1. 重定向前
假设当前进程的文件描述符表如下:
text
文件描述符表
+----------------+
| fd 0 | -----> 终端输入
| fd 1 | -----> 终端输出
| fd 2 | -----> 终端错误输出
+----------------+
2. 执行重定向后
执行:
bash
ls > result.txt
Shell 打开 result.txt,然后使用 dup2 将文件描述符 1 改为指向这个文件。
text
文件描述符表
+----------------+
| fd 0 | -----> 终端输入
| fd 1 | -----> result.txt
| fd 2 | -----> 终端错误输出
+----------------+
此时,程序仍然向标准输出写数据。
但标准输出的指向已经发生改变,所以数据最终进入了文件。
这就是重定向最核心的原理:不修改程序的输出逻辑,只修改文件描述符的指向。
三、Shell 如何解析重定向符号?
Shell 接收到用户输入后,首先需要解析命令。
例如:
bash
ls -l > result.txt
如果只考虑普通命令参数,可以得到:
text
argv[0] = ls
argv[1] = -l
但是,重定向符号和目标文件并不是普通的命令参数。
Shell 需要识别:
text
命令:ls -l
重定向类型:输出重定向
目标文件:result.txt
也就是说,Shell 需要在执行命令之前,把重定向信息提取出来。
可以将解析结果理解成下面的结构:
cpp
struct Redirection
{
int fd; // 要重定向的文件描述符
int flags; // open 使用的打开方式
std::string file; // 目标文件
};
例如:
bash
ls -l > result.txt
对应的信息可以表示为:
text
fd = 1
flags = O_WRONLY | O_CREAT | O_TRUNC
file = result.txt
而:
bash
cat < result.txt
对应:
text
fd = 0
flags = O_RDONLY
file = result.txt
追加重定向:
bash
echo hello >> result.txt
对应:
text
fd = 1
flags = O_WRONLY | O_CREAT | O_APPEND
file = result.txt
这里需要注意:Shell 的解析器负责识别语法,而 open 和 dup2 负责真正完成文件操作。两者是不同的工作。
四、外部命令的重定向:fork + open + dup2 + exec
这是整个实战最重要的部分。
例如:
bash
ls > result.txt
ls 是一个外部命令。Shell 通常不会直接替换自己来执行 ls,而是创建子进程,让子进程执行命令。
整个过程可以分成五步。
1. 创建子进程
cpp
pid_t id = fork();
fork() 创建子进程。
子进程会继承父进程的文件描述符,因此刚创建时,子进程的标准输出通常也指向终端。
text
父进程 Shell 子进程
fd 1 -> 终端 fd 1 -> 终端
注意:父子进程有各自的文件描述符表,但对应的描述符可能引用同一个打开文件对象。
2. 子进程打开目标文件
cpp
int fd = open("result.txt",
O_WRONLY | O_CREAT | O_TRUNC,
0666);
if (fd < 0)
{
perror("open");
_exit(1);
}
这里:
O_WRONLY:以只写方式打开。O_CREAT:文件不存在时创建。O_TRUNC:文件已经存在时清空原有内容。0666:创建文件时请求的权限,最终权限还会受到umask的影响。
open() 成功后会返回一个文件描述符。
假设当前子进程中,0、1、2 已经被占用,那么通常会得到:
text
fd = 3
此时:
text
fd 1 -> 终端
fd 3 -> result.txt
3. 使用 dup2 修改标准输出
cpp
if (dup2(fd, STDOUT_FILENO) < 0)
{
perror("dup2");
close(fd);
_exit(1);
}
close(fd);
这里的:
cpp
dup2(fd, STDOUT_FILENO);
等价于让文件描述符 1 指向原来 fd 指向的打开文件对象。
执行之后:
text
fd 1 -> result.txt
为什么还要执行:
cpp
close(fd);
因为 dup2 已经让标准输出 fd 1 指向目标文件了。
原来的 fd 3 不再需要,可以关闭。
关闭 fd 3 不会影响 fd 1,因为两者已经分别引用同一个打开文件对象。
4. 执行外部程序
cpp
execvp(argv[0], argv);
这里的 execvp 会用新的程序替换当前子进程的程序映像。
例如,原本子进程执行的是 Shell 的代码,现在变成执行 ls 的代码。
但是有一个关键点:
exec 替换的是进程的程序映像,并不会默认关闭所有已经打开的文件描述符。
因此,之前修改好的:
text
fd 1 -> result.txt
仍然保留着。
于是 ls 执行时,即使它完全不知道发生过重定向,输出也会进入 result.txt。
5. 父进程等待子进程
父进程继续执行:
cpp
waitpid(id, nullptr, 0);
父进程等待子进程结束。
整个过程可以总结为:
text
用户输入:ls > result.txt
|
v
Shell 解析命令
|
v
fork()
|
+----+----+
| |
父进程 子进程
| |
| open()
| |
| dup2()
| |
| close()
| |
| execvp()
| |
| 执行 ls
| |
+--waitpid+
|
v
Shell 继续运行
这就是外部命令实现输出重定向的完整思路。
五、把重定向封装成函数
为了避免在 Shell 的执行流程中重复编写代码,可以把重定向操作封装起来。
下面给出一个简化的 C++ 实现。
cpp
#include <iostream>
#include <string>
#include <fcntl.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>
bool ApplyRedirection(int target_fd,
const std::string& filename,
int flags)
{
int fd = open(filename.c_str(), flags, 0666);
if (fd < 0)
{
std::cerr << "open failed: "
<< strerror(errno) << std::endl;
return false;
}
if (dup2(fd, target_fd) < 0)
{
std::cerr << "dup2 failed: "
<< strerror(errno) << std::endl;
close(fd);
return false;
}
// 如果 open 返回的 fd 与目标 fd 不同,
// dup2 完成后就可以关闭临时 fd。
if (fd != target_fd)
{
close(fd);
}
return true;
}
这个函数做了三件事:
- 打开目标文件。
- 使用
dup2修改目标文件描述符的指向。 - 关闭不再需要的临时文件描述符。
这里专门判断了:
cpp
if (fd != target_fd)
因为 open() 返回的文件描述符不一定永远大于 2。
如果标准输入、标准输出或标准错误已经被关闭,open() 有可能直接返回 0、1 或 2。
当 fd == target_fd 时,dup2(fd, target_fd) 不会关闭这个描述符,因此不能再把它当成临时描述符关闭。
不同重定向方式如何调用?
输出重定向:
cpp
ApplyRedirection(
STDOUT_FILENO,
"result.txt",
O_WRONLY | O_CREAT | O_TRUNC
);
追加重定向:
cpp
ApplyRedirection(
STDOUT_FILENO,
"result.txt",
O_WRONLY | O_CREAT | O_APPEND
);
输入重定向:
cpp
ApplyRedirection(
STDIN_FILENO,
"result.txt",
O_RDONLY
);
可以看到,三种重定向的底层机制完全相同。
真正变化的只是:
- 修改哪个文件描述符;
- 打开哪个文件;
- 使用什么打开标志。
六、为什么内置命令不能简单地使用子进程重定向?
前面讲的是外部命令。
但 Shell 中还有一类命令:内置命令(builtin)。
例如:
bash
cd ..
cd 通常由 Shell 自己实现。
为什么不能直接创建子进程执行 cd?
因为 cd 修改的是当前进程的工作目录。
如果在子进程中执行:
cpp
chdir("..");
改变的只是子进程的工作目录。
子进程结束之后,父进程 Shell 的工作目录并不会发生变化。
所以,像 cd 这样的内置命令,通常需要由 Shell 进程自己执行。
这就带来一个新问题:
如果内置命令也需要重定向,应该怎么办?
例如:
bash
echo hello > result.txt
假设 echo 是 Shell 自己实现的内置命令。
如果我们直接在 Shell 进程中调用:
cpp
ApplyRedirection(
STDOUT_FILENO,
"result.txt",
O_WRONLY | O_CREAT | O_TRUNC
);
那么 Shell 自己的标准输出也会被修改。
执行完内置命令后,如果不恢复,后续 Shell 提示符和其他输出也可能进入文件。
因此,内置命令的重定向需要额外做一件事:
保存原来的文件描述符,执行完命令后再恢复。
1. 保存原来的标准输出
cpp
int saved_stdout = dup(STDOUT_FILENO);
if (saved_stdout < 0)
{
perror("dup");
return;
}
dup() 会复制标准输出对应的文件描述符。
此时:
text
fd 1 -> 终端
saved_stdout -> 终端
两个描述符指向同一个打开文件对象。
2. 修改标准输出
cpp
if (!ApplyRedirection(
STDOUT_FILENO,
"result.txt",
O_WRONLY | O_CREAT | O_TRUNC))
{
close(saved_stdout);
return;
}
此时:
text
fd 1 -> result.txt
saved_stdout -> 终端
3. 执行内置命令
cpp
std::cout << "hello" << std::endl;
此时输出会进入 result.txt。
4. 恢复原来的标准输出
cpp
std::cout.flush();
if (dup2(saved_stdout, STDOUT_FILENO) < 0)
{
perror("restore stdout");
}
close(saved_stdout);
执行恢复后:
text
fd 1 -> 终端
Shell 的标准输出重新指向终端。
这里有一个容易忽略的细节:
如果使用了 printf、fprintf(stdout, ...) 或 std::cout,它们可能存在用户态缓冲。
因此,在切换文件描述符之前,应该先刷新相关输出缓冲区。
对于 C 标准 I/O:
cpp
fflush(stdout);
对于 C++ 标准输出流:
cpp
std::cout.flush();
这两种缓冲机制需要分别处理,不能认为 dup2 会自动清空它们。
注意:上面的代码展示的是保存、修改和恢复文件描述符的核心思路。实际 Shell 还应处理文件打开失败、恢复失败、多个重定向以及原本关闭的标准描述符等情况。对于
std::cout,还要确保流状态和缓冲行为符合实际执行环境。
七、为什么重定向必须发生在 exec 之前?
现在回头看外部命令的执行过程:
text
fork()
|
v
open()
|
v
dup2()
|
v
execvp()
为什么一定要先完成 dup2,再调用 execvp?
因为 execvp 会替换当前进程的程序映像。
如果先执行:
cpp
execvp(argv[0], argv);
成功之后,原来的 Shell 子进程代码就不再继续执行了。
那么后面的:
cpp
dup2(fd, STDOUT_FILENO);
自然也没有机会执行。
所以,Shell 必须在新程序开始运行之前,把它需要的输入输出环境准备好。
这也解释了为什么重定向并不是 ls 自己实现的功能。
ls 只负责把内容写入标准输出。
Shell 负责在 ls 执行之前,把标准输出安排到正确的位置。
八、文件描述符重定向与 FILE 缓冲区的关系
前面第四篇已经讲过:
cpp
printf("hello\n");
并不意味着每次调用 printf 都会立即执行一次系统调用 write()。
数据可能先进入 stdout 对应的用户态缓冲区。
这会带来一个问题:
如果 Shell 在重定向之前,已经有数据留在 stdout 的缓冲区中,那么这些数据究竟会写到哪里?
例如:
cpp
printf("before redirect");
int fd = open("result.txt",
O_WRONLY | O_CREAT | O_TRUNC,
0666);
dup2(fd, STDOUT_FILENO);
close(fd);
printf("after redirect\n");
在常见的 Linux C 库实现中,如果标准输出处于全缓冲状态,第一段输出可能还留在用户态缓冲区里。
当后续发生刷新时,它可能通过已经改变指向的文件描述符写入文件。
因此,重定向前应当先刷新标准输出:
cpp
fflush(stdout);
再执行 dup2。
这样可以避免旧缓冲区中的数据被意外写入新的目标位置。
这里要区分两个概念:
fflush(stdout):将 C 标准 I/O 的用户态输出缓冲提交到底层 I/O。dup2():修改文件描述符表中的描述符指向。
它们解决的是不同层面的问题。
九、动手验证:亲自观察重定向
我们可以写一个简单程序,验证文件描述符重定向确实改变了输出位置。
1. 编写测试程序
创建 redirect_test.cpp:
cpp
#include <iostream>
#include <cstdio>
#include <fcntl.h>
#include <unistd.h>
int main()
{
// 先刷新标准输出,避免旧缓冲数据影响实验
std::cout.flush();
fflush(stdout);
int fd = open("output.txt",
O_WRONLY | O_CREAT | O_TRUNC,
0666);
if (fd < 0)
{
perror("open");
return 1;
}
if (dup2(fd, STDOUT_FILENO) < 0)
{
perror("dup2");
close(fd);
return 1;
}
close(fd);
printf("This message goes to file.\n");
fflush(stdout);
return 0;
}
2. 编译
bash
g++ redirect_test.cpp -o redirect_test
3. 运行
bash
./redirect_test
此时终端中不会显示:
text
This message goes to file.
查看文件:
bash
cat output.txt
预期可以看到:
text
This message goes to file.
4. 观察结果
这个实验验证了:
open()成功打开目标文件。dup2()将标准输出 fd 1 改为指向目标文件。printf()仍然使用标准输出。- 输出最终进入文件,而不是终端。
我们没有修改 printf() 的输出逻辑。
改变的只有文件描述符的指向。
这就是 Linux 文件描述符重定向的核心思想。
十、回顾整个 Linux 文件 I/O 知识体系
到这里,六篇 Linux 文件篇就串起来了。
| 篇章 | 核心知识 | 解决的问题 |
|---|---|---|
| 第一篇 | fd、文件描述符表、VFS | 进程如何找到打开的文件? |
| 第二篇 | open、read、write、lseek | 如何打开、读写和定位文件? |
| 第三篇 | dup、dup2 | 如何改变文件描述符的指向? |
| 第四篇 | FILE、用户态缓冲区 | C 标准 I/O 为什么需要缓冲? |
| 第五篇 | 模拟实现 MyFILE | 如何自己管理用户态缓冲区? |
| 第六篇 | Shell 重定向 | 如何把这些机制组合起来? |
从文件描述符到 Shell 重定向,我们实际上一直在研究同一件事情:
进程如何通过文件描述符管理 I/O,以及操作系统如何将这些 I/O 操作连接到底层文件对象。
十一、本篇复习 Checklist
- 能够画出进程文件描述符表与打开文件对象之间的关系。
- 能解释
open()返回的文件描述符是什么。 - 能解释
dup2(oldfd, newfd)修改了什么。 - 能独立写出
>、>>、<对应的打开标志。 - 能讲清楚外部命令重定向的
fork → open → dup2 → exec流程。 - 能解释为什么
exec之后重定向仍然有效。 - 能解释为什么内置命令重定向需要保存和恢复原来的 fd。
- 能解释
fflush()和dup2()分别解决什么问题。 - 能独立实现一个简单的输出重定向功能。
结语
刚开始学习 Linux 文件 I/O 时,我们接触的是一个个独立的系统调用:
open()、read()、write()、close()、dup2()......
它们看起来只是几个函数。
但当我们把它们放进 Shell 的执行流程中,就能发现这些系统调用之间并不是孤立的。
Shell 负责解析用户命令,进程负责执行程序,文件描述符负责连接 I/O,系统调用负责完成底层操作。
一条简单的:
bash
ls > result.txt
背后就包含了进程创建、文件打开、描述符复制、程序替换等一系列机制。
学习底层原理的意义,就是能够从一条看似简单的命令,反推出它背后的整个执行过程。
至此,Linux 文件 I/O 系列六篇完结。