【Linux】文件篇(六):Shell 实战——从系统调用到命令行重定向

一、从一条命令开始: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;
}

这个函数做了三件事:

  1. 打开目标文件。
  2. 使用 dup2 修改目标文件描述符的指向。
  3. 关闭不再需要的临时文件描述符。

这里专门判断了:

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. 观察结果

这个实验验证了:

  1. open() 成功打开目标文件。
  2. dup2() 将标准输出 fd 1 改为指向目标文件。
  3. printf() 仍然使用标准输出。
  4. 输出最终进入文件,而不是终端。

我们没有修改 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 系列六篇完结。

相关推荐
Star(up up up)1 小时前
MySQL 事务隔离级别是如何实现的?从 MVCC 到锁机制原理详解
笔记·vscode·sql·学习·程序人生·mysql·学习方法
dingdingfish1 小时前
TLPI 第57章 读书笔记:Sockets: UNIX Domain
linux·socket·domain·sendto·recvfrom·tlpi·socketpair
戊本菌10 小时前
进程(三)runqueue 与 Linux 的 O(1) 调度
linux·运维·服务器
光电笑映12 小时前
TCP 为什么可靠?从三次握手、滑动窗口到拥塞控制全面拆解(下)
linux·网络·网络协议·tcp
yz_aiks13 小时前
Termux 使用教程:把安卓手机变成随身 Linux(装 Python、SSH 远程、跑自动化脚本)
android·linux·python·智能手机·ssh·termux
琳少_14 小时前
java程序开发笔记
java·开发语言·数据库·笔记
无忧.芙桃15 小时前
C++语言原理与实践(二十三):哈希表的实现
c++·链表·哈希算法·散列表·哈希表
叼烟扛炮16 小时前
[LangChain] 学习笔记(15):为什么你的重试没用——429、抖动、fallback 与熔断
java·服务器·前端
hi_ro_a17 小时前
Ext系列⽂件系统详解
linux·服务器·操作系统