Linux文件描述符重定向机制与实现原理

1. Linux文件描述符重定向机制解析

在Linux系统中，文件描述符（File Descriptor）是理解I/O操作的核心概念。每个进程启动时都会默认打开三个文件描述符：0（标准输入stdin）、1（标准输出stdout）和2（标准错误stderr）。这些描述符本质上都是数组索引，指向内核维护的文件对象。

1.1 文件描述符分配规则

Linux内核采用"最小可用原则"分配文件描述符。当进程打开新文件时，系统会扫描文件描述符表，选择当前未被使用的最小数字作为新文件的描述符。这个机制可以通过简单的C程序验证：

c复制#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 正常情况下新文件会分配描述符3
    int fd1 = open("file1.txt", O_CREAT|O_WRONLY, 0644);
    printf("fd1: %d\n", fd1);
    
    // 关闭标准输入后，新文件会复用描述符0
    close(0);
    int fd2 = open("file2.txt", O_CREAT|O_WRONLY, 0644);
    printf("fd2: %d\n", fd2);
    
    close(fd1);
    close(fd2);
    return 0;
}

运行这个程序可以看到，第一个open()调用通常会返回3（假设0-2已被占用），而关闭0后再打开文件，系统会优先分配0这个最小可用描述符。

关键点：文件描述符的分配完全遵循最小可用原则，这个特性正是实现I/O重定向的基础。当某个标准描述符（0/1/2）被关闭后，新打开的文件会优先占用这个位置，从而改变标准I/O的默认行为。

1.2 输出重定向的实现原理

输出重定向是最常见的I/O重定向操作。在Shell中我们常用>操作符实现，其底层原理可以通过以下代码模拟：

c复制#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 关闭标准输出描述符
    close(1);
    
    // 打开目标文件，此时会分配到描述符1
    int fd = open("output.txt", O_CREAT|O_WRONLY|O_TRUNC, 0644);
    
    // 这些输出将写入文件而非终端
    printf("This goes to file\n");
    fprintf(stdout, "This too\n");
    
    close(fd);
    return 0;
}

这个程序的关键点在于：

1. 先关闭描述符1（标准输出）
2. 然后打开文件，由于描述符1现在是可用的最小值，文件会绑定到这个位置
3. 之后所有向stdout的输出（包括printf、fprintf等）都会自动重定向到文件

注意事项：O_TRUNC标志非常重要，它确保每次打开文件时会清空原有内容。如果不希望清空而是追加内容，应该使用O_APPEND标志。

1.3 输入重定向的实现原理

输入重定向的原理与输出类似，只是操作的是描述符0（标准输入）：

c复制#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    char buffer[1024];
    
    // 关闭标准输入描述符
    close(0);
    
    // 打开输入文件，会分配到描述符0
    int fd = open("input.txt", O_RDONLY);
    
    // 从stdin读取实际上是从文件读取
    fgets(buffer, sizeof(buffer), stdin);
    printf("Read: %s", buffer);
    
    close(fd);
    return 0;
}

在这个例子中，fgets()本应从键盘读取输入，但由于描述符0已被重定向到文件，实际会从文件中读取内容。

2. dup2系统调用的高级用法

虽然close+open的方式可以实现重定向，但在实际编程中更推荐使用dup2系统调用，它提供了更简洁、安全的实现方式。

2.1 dup2的基本工作原理

dup2(int oldfd, int newfd)的功能是将oldfd复制到newfd。如果newfd已经打开，dup2会先关闭它。这个操作完成后，两个文件描述符将指向同一个文件表项。

c复制#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    // 打开目标文件
    int file_fd = open("output.txt", O_CREAT|O_WRONLY|O_TRUNC, 0644);
    
    // 将文件描述符复制到标准输出
    dup2(file_fd, 1);
    
    // 可以安全关闭原文件描述符
    close(file_fd);
    
    // 输出将重定向到文件
    printf("This is redirected output\n");
    
    return 0;
}

dup2的主要优势包括：

1. 原子性操作：避免了close和open之间的竞争条件
2. 代码更简洁：不需要手动处理描述符关闭和重新分配
3. 更安全：不会意外占用错误的描述符

2.2 使用dup2实现复杂重定向

dup2特别适合实现复杂的重定向场景，比如同时重定向标准输出和标准错误：

c复制#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    // 打开输出文件
    int output_fd = open("output.txt", O_CREAT|O_WRONLY|O_TRUNC, 0644);
    // 打开错误文件
    int error_fd = open("error.txt", O_CREAT|O_WRONLY|O_TRUNC, 0644);
    
    // 重定向标准输出和标准错误
    dup2(output_fd, 1);
    dup2(error_fd, 2);
    
    // 关闭原始文件描述符
    close(output_fd);
    close(error_fd);
    
    // 测试输出
    printf("This is normal output\n");
    fprintf(stderr, "This is error message\n");
    
    return 0;
}

2.3 重定向的恢复技巧

在实际应用中，我们有时需要临时重定向I/O，之后恢复原始状态。这可以通过保存原始文件描述符来实现：

c复制#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    // 保存原始标准输出
    int saved_stdout = dup(1);
    
    // 重定向到文件
    int file_fd = open("output.txt", O_CREAT|O_WRONLY|O_TRUNC, 0644);
    dup2(file_fd, 1);
    close(file_fd);
    
    printf("This goes to file\n");
    
    // 恢复原始标准输出
    dup2(saved_stdout, 1);
    close(saved_stdout);
    
    printf("This goes to terminal\n");
    
    return 0;
}

实用技巧：使用dup()复制文件描述符是保存当前I/O状态的有效方法。记住在恢复后要关闭保存的描述符，避免文件描述符泄漏。

3. Shell重定向的底层实现

Shell中的重定向操作符（>, >>, <等）底层都是通过dup2系统调用实现的。理解这些操作符与文件描述符的关系对系统编程非常重要。

3.1 输出重定向的两种形式

1. 覆盖重定向（>）：对应O_TRUNC标志

bash复制# 等效C代码：open(filename, O_CREAT|O_WRONLY|O_TRUNC, 0644)
./program > output.txt

2. 追加重定向（>>）：对应O_APPEND标志

bash复制# 等效C代码：open(filename, O_CREAT|O_WRONLY|O_APPEND, 0644)
./program >> output.txt

3.2 输入重定向的实现

输入重定向使用<操作符，对应描述符0的重定向：

bash复制# 等效C代码：close(0); open(filename, O_RDONLY)
./program < input.txt

3.3 标准错误的重定向

标准错误（描述符2）也可以重定向，有多种语法形式：

1. 将标准错误重定向到文件：

bash复制./program 2> error.log

2. 将标准输出和标准错误都重定向到文件：

bash复制./program > output.log 2>&1

3. 将标准错误重定向到标准输出：

bash复制./program 2>&1 | grep "error"

关键点：2>&1表示将描述符2重定向到描述符1当前指向的位置。这个顺序很重要，必须先重定向标准输出，再重定向标准错误。

4. 文件描述符与进程的关系

每个进程都有自己独立的文件描述符表，理解这个结构对掌握Linux I/O至关重要。

4.1 进程的文件描述符表

Linux内核为每个进程维护一个文件描述符表，这个表包含：

1. 指向文件表的指针
2. 文件状态标志（如O_RDONLY、O_NONBLOCK等）
3. 当前文件偏移量

当调用fork()创建子进程时，子进程会继承父进程的文件描述符表，但两者指向相同的文件表项。这意味着在父进程和子进程中操作同一个文件描述符会影响相同的文件位置。

4.2 文件描述符的生命周期

文件描述符在以下情况下会被关闭：

1. 显式调用close()
2. 进程终止（所有打开的文件描述符自动关闭）
3. 执行exec系列函数时，标记为FD_CLOEXEC的描述符会被关闭

注意事项：文件描述符是有限的资源，每个进程默认有上限（通常1024）。编程时应注意及时关闭不再需要的描述符，避免泄漏。

4.3 文件描述符的共享机制

多个文件描述符（即使在不同的进程中）可以指向同一个文件表项，这种情况发生在：

1. 调用dup/dup2
2. fork()创建子进程
3. 通过Unix域套接字传递文件描述符

这种共享机制使得进程间可以高效地共享文件访问，但也需要注意同步问题。

5. "一切皆文件"的设计哲学

Linux系统最著名的设计理念之一就是"一切皆文件"，这个抽象极大地简化了系统接口的设计。

5.1 文件抽象的实现机制

在Linux内核中，所有I/O设备都通过文件接口访问，这得益于虚拟文件系统（VFS）层。VFS定义了统一的文件操作接口：

c复制struct file_operations {
    ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
    int (*open)(struct inode *, struct file *);
    int (*release)(struct inode *, struct file *);
    // 其他操作...
};

每种设备类型（磁盘、终端、套接字等）都提供自己的file_operations实现，这样上层应用可以用统一的接口访问各种设备。

5.2 文件描述符与设备访问

当进程打开一个设备文件时，内核会：

1. 根据文件路径找到对应的设备驱动程序
2. 创建file结构体，关联设备的file_operations
3. 分配文件描述符，将其与file结构体关联

之后，进程通过文件描述符进行的read/write等操作都会被路由到设备驱动程序的对应方法。

5.3 特殊文件类型示例

Linux中有几种特殊的文件类型体现了"一切皆文件"的理念：

1. 设备文件（/dev下的文件）：

   • 字符设备（如终端）：/dev/tty
   • 块设备（如磁盘）：/dev/sda

2. 命名管道（FIFO）：

   bash复制mkfifo mypipe
   

3. 套接字文件：

   c复制int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
   

4. proc文件系统（/proc下的文件）：

   bash复制cat /proc/cpuinfo
   

这些特殊文件虽然不存储实际数据，但都通过文件接口提供了访问相应功能的统一方式。

6. 高级重定向技巧与实战

掌握了基本重定向原理后，我们来看一些高级应用场景和实用技巧。

6.1 临时重定向与恢复

在复杂程序中，可能需要临时重定向I/O，完成后恢复原始状态：

c复制#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

void redirect_stdout(const char *filename) {
    static int saved_stdout = -1;
    
    // 第一次调用时保存原始stdout
    if (saved_stdout == -1) {
        saved_stdout = dup(1);
    }
    
    // 重定向到文件
    int fd = open(filename, O_CREAT|O_WRONLY|O_APPEND, 0644);
    dup2(fd, 1);
    close(fd);
}

void restore_stdout() {
    static int saved_stdout = -1;
    
    if (saved_stdout != -1) {
        dup2(saved_stdout, 1);
        close(saved_stdout);
        saved_stdout = -1;
    }
}

int main() {
    printf("This goes to terminal\n");
    
    redirect_stdout("log.txt");
    printf("This goes to file\n");
    
    restore_stdout();
    printf("Back to terminal\n");
    
    return 0;
}

6.2 创建匿名管道实现进程通信

管道是Unix系统进程间通信的重要机制，其实质也是一种文件描述符重定向：

c复制#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    int pipefd[2];
    pid_t pid;
    char buf[256];
    
    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0) { // 子进程
        close(pipefd[1]); // 关闭写端
        
        // 从管道读取数据
        ssize_t n = read(pipefd[0], buf, sizeof(buf));
        printf("Child received: %.*s\n", (int)n, buf);
        
        close(pipefd[0]);
    } else { // 父进程
        close(pipefd[0]); // 关闭读端
        
        // 向管道写入数据
        write(pipefd[1], "Hello from parent", 17);
        
        close(pipefd[1]);
    }
    
    return 0;
}

6.3 重定向与shell命令执行

理解文件描述符重定向对于实现自己的shell非常有帮助。下面是一个简单的命令执行函数，支持重定向：

c复制#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>

void execute_command(char *cmd[], char *input_file, char *output_file, int append) {
    pid_t pid = fork();
    
    if (pid == 0) { // 子进程
        // 输入重定向
        if (input_file) {
            int fd = open(input_file, O_RDONLY);
            dup2(fd, 0);
            close(fd);
        }
        
        // 输出重定向
        if (output_file) {
            int flags = O_CREAT|O_WRONLY;
            flags |= append ? O_APPEND : O_TRUNC;
            
            int fd = open(output_file, flags, 0644);
            dup2(fd, 1);
            close(fd);
        }
        
        execvp(cmd[0], cmd);
        perror("execvp");
        exit(EXIT_FAILURE);
    } else if (pid > 0) { // 父进程
        waitpid(pid, NULL, 0);
    } else {
        perror("fork");
    }
}

int main() {
    char *cmd1[] = {"ls", "-l", NULL};
    execute_command(cmd1, NULL, "ls-output.txt", 0);
    
    char *cmd2[] = {"grep", "main", NULL};
    execute_command(cmd2, "demo.c", "grep-output.txt", 1);
    
    return 0;
}

7. 常见问题与调试技巧

在实际使用文件描述符重定向时，会遇到各种问题。下面总结一些常见情况及解决方法。

7.1 重定向失效的常见原因

1. 文件描述符未正确关闭：

   c复制// 错误示例：忘记关闭原始描述符
   int fd = open("file.txt", O_WRONLY);
   dup2(fd, 1);
   // 忘记 close(fd);
   

   这样会导致文件描述符泄漏，可能影响后续操作。

2. 标志位设置不当：

   • 忘记设置O_CREAT导致文件不存在时打开失败
   • 需要追加时忘记设置O_APPEND
   • 需要截断时忘记设置O_TRUNC

3. 权限问题：

   • 目标文件没有写权限
   • 目录没有执行权限
   • SELinux/AppArmor等安全模块限制

7.2 文件描述符泄漏检测

使用lsof工具可以检测进程打开的文件描述符：

bash复制# 查看指定进程打开的文件
lsof -p <pid>

# 查看某个文件被哪些进程打开
lsof /path/to/file

在程序中可以通过/proc文件系统查看：

bash复制ls -l /proc/<pid>/fd

7.3 重定向与缓冲区的交互

标准I/O库（如printf）使用缓冲区，这可能导致重定向时的输出顺序问题：

c复制#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    printf("This should appear first\n");
    
    // 重定向标准输出
    int fd = open("output.txt", O_CREAT|O_WRONLY|O_TRUNC, 0644);
    dup2(fd, 1);
    close(fd);
    
    printf("This should appear second\n");
    
    return 0;
}

有时会发现两个printf的输出顺序不符合预期，这是因为：

• 输出到终端时，stdout通常是行缓冲的（遇到换行符就刷新）
• 输出到文件时，stdout通常是全缓冲的（缓冲区满才刷新）

解决方法：

1. 在重定向前调用fflush(stdout)
2. 使用setvbuf设置缓冲区模式
3. 在关键输出后添加换行符

7.4 多线程环境下的重定向

在多线程程序中重定向文件描述符需要特别注意：

1. 文件描述符是进程级别的资源，会影响所有线程
2. 重定向操作应该是原子的，避免竞态条件
3. 考虑使用互斥锁保护重定向操作

c复制#include <pthread.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

static pthread_mutex_t io_mutex = PTHREAD_MUTEX_INITIALIZER;

void safe_redirect(int newfd, const char *filename) {
    pthread_mutex_lock(&io_mutex);
    
    int fd = open(filename, O_CREAT|O_WRONLY|O_TRUNC, 0644);
    dup2(fd, newfd);
    close(fd);
    
    pthread_mutex_unlock(&io_mutex);
}

void *thread_func(void *arg) {
    safe_redirect(1, "thread-output.txt");
    printf("Thread output\n");
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);
    
    safe_redirect(1, "main-output.txt");
    printf("Main output\n");
    
    pthread_join(tid, NULL);
    return 0;
}

8. 性能考量与最佳实践

正确使用文件描述符重定向不仅能实现功能需求，还能影响程序性能。下面探讨相关优化技巧。

8.1 文件描述符操作的开销

文件描述符操作的系统调用（open/close/dup2等）相对较昂贵，应该：

1. 避免在循环中频繁重定向
2. 考虑重用文件描述符而非重复打开关闭
3. 批量处理重定向操作

8.2 选择正确的I/O方式

根据场景选择合适的I/O方法：

1. 对于大量数据：考虑使用mmap内存映射
2. 对于高频小数据：考虑缓冲I/O（如stdio）
3. 对于低延迟需求：考虑直接I/O（O_DIRECT）

8.3 文件描述符限制管理

系统对文件描述符数量有限制，可以通过以下方式管理：

1. 查询当前限制：

   bash复制ulimit -n
   

2. 提高限制（需要权限）：

   bash复制ulimit -n 4096
   

3. 在程序中动态检查和处理EMFILE错误（Too many open files）

8.4 错误处理的最佳实践

健壮的重定向代码应该包含完善的错误处理：

c复制int redirect_output(const char *filename) {
    int fd = open(filename, O_CREAT|O_WRONLY|O_TRUNC, 0644);
    if (fd == -1) {
        perror("open failed");
        return -1;
    }
    
    if (dup2(fd, 1) == -1) {
        perror("dup2 failed");
        close(fd);
        return -1;
    }
    
    close(fd);
    return 0;
}

关键点：

1. 每次系统调用后检查返回值
2. 错误时提供有意义的诊断信息
3. 确保资源被正确释放
4. 考虑使用goto简化错误处理（争议性技巧）

9. 实际应用案例分析

通过几个实际案例展示文件描述符重定向的强大功能。

9.1 实现简单的日志系统

c复制#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <time.h>
#include <stdarg.h>

#define LOG_FILE "app.log"

void log_message(const char *format, ...) {
    static int initialized = 0;
    static int log_fd = -1;
    
    if (!initialized) {
        // 首次调用时打开日志文件
        log_fd = open(LOG_FILE, O_CREAT|O_WRONLY|O_APPEND, 0644);
        if (log_fd == -1) {
            perror("Failed to open log file");
            return;
        }
        initialized = 1;
    }
    
    // 保存原始stdout
    int saved_stdout = dup(1);
    
    // 重定向到日志文件
    dup2(log_fd, 1);
    
    // 添加时间戳
    time_t now = time(NULL);
    struct tm *tm = localtime(&now);
    printf("[%04d-%02d-%02d %02d:%02d:%02d] ", 
           tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
           tm->tm_hour, tm->tm_min, tm->tm_sec);
    
    // 打印日志内容
    va_list args;
    va_start(args, format);
    vprintf(format, args);
    va_end(args);
    
    printf("\n");
    fflush(stdout);
    
    // 恢复原始stdout
    dup2(saved_stdout, 1);
    close(saved_stdout);
}

int main() {
    printf("Normal output\n");
    log_message("Application started");
    log_message("Processing item %d", 42);
    printf("Back to normal output\n");
    return 0;
}

9.2 实现简单的CGI处理器

c复制#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void handle_cgi_request(const char *script_path, const char *query_string) {
    // 创建管道用于读取脚本输出
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe failed");
        exit(EXIT_FAILURE);
    }
    
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0) { // 子进程 - CGI脚本
        close(pipefd[0]); // 关闭读端
        
        // 重定向stdout到管道写端
        dup2(pipefd[1], 1);
        close(pipefd[1]);
        
        // 设置QUERY_STRING环境变量
        setenv("QUERY_STRING", query_string, 1);
        
        // 执行CGI脚本
        execl(script_path, script_path, NULL);
        perror("execl failed");
        exit(EXIT_FAILURE);
    } else { // 父进程 - Web服务器
        close(pipefd[1]); // 关闭写端
        
        // 从管道读取脚本输出
        char buffer[4096];
        ssize_t n;
        while ((n = read(pipefd[0], buffer, sizeof(buffer))) > 0) {
            write(1, buffer, n); // 输出到客户端
        }
        
        close(pipefd[0]);
        waitpid(pid, NULL, 0);
    }
}

int main() {
    printf("Content-type: text/html\r\n\r\n");
    printf("<html><body>\n");
    
    handle_cgi_request("./cgi-script.sh", "name=value&test=123");
    
    printf("</body></html>\n");
    return 0;
}

9.3 实现命令管道功能

c复制#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>

void execute_pipeline(char ***commands) {
    int i = 0;
    int in_fd = 0; // 初始输入来自stdin
    
    while (commands[i] != NULL) {
        int pipefd[2];
        
        // 如果不是最后一个命令，创建管道
        if (commands[i+1] != NULL) {
            if (pipe(pipefd) == -1) {
                perror("pipe failed");
                exit(EXIT_FAILURE);
            }
        }
        
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork failed");
            exit(EXIT_FAILURE);
        }
        
        if (pid == 0) { // 子进程
            // 重定向输入
            if (i > 0) {
                dup2(in_fd, 0);
                close(in_fd);
            }
            
            // 重定向输出（如果不是最后一个命令）
            if (commands[i+1] != NULL) {
                close(pipefd[0]);
                dup2(pipefd[1], 1);
                close(pipefd[1]);
            }
            
            // 执行命令
            execvp(commands[i][0], commands[i]);
            perror("execvp failed");
            exit(EXIT_FAILURE);
        } else { // 父进程
            // 关闭前一个管道的读端（如果有）
            if (i > 0) {
                close(in_fd);
            }
            
            // 如果不是最后一个命令，保存管道读端
            if (commands[i+1] != NULL) {
                close(pipefd[1]);
                in_fd = pipefd[0];
            }
            
            // 等待当前命令完成
            waitpid(pid, NULL, 0);
        }
        
        i++;
    }
}

int main() {
    char *cmd1[] = {"ls", "-l", NULL};
    char *cmd2[] = {"grep", "main", NULL};
    char *cmd3[] = {"wc", "-l", NULL};
    char **commands[] = {cmd1, cmd2, cmd3, NULL};
    
    execute_pipeline(commands);
    return 0;
}

10. 深入理解文件描述符内核实现

要真正掌握文件描述符和重定向，需要了解Linux内核的相关数据结构和工作原理。

10.1 内核关键数据结构

1. struct files_struct：

   • 每个进程都有一个，包含进程打开的所有文件信息
   • 核心成员：fd_array（文件描述符表）

2. struct file：

   • 代表一个打开的文件实例
   • 包含文件位置、访问模式、操作函数指针等

3. struct inode：

   • 代表文件系统中的一个文件
   • 包含文件元数据（大小、权限、时间戳等）

10.2 文件描述符生命周期

1. 打开文件：

   • 应用程序调用open()
   • 内核创建file结构体，初始化各种字段
   • 在files_struct的fd_array中分配空闲位置
   • 返回文件描述符（数组索引）

2. 操作文件：

   • 通过文件描述符找到对应的file结构体
   • 调用file->f_op中的相应方法（read/write等）

3. 关闭文件：

   • 应用程序调用close()
   • 内核释放file结构体
   • 清空fd_array对应项

10.3 dup2的内核实现

dup2的系统调用主要执行以下操作：

1. 检查参数有效性
2. 如果newfd == oldfd，直接返回newfd
3. 如果newfd已经打开，先关闭它
4. 将newfd指向oldfd对应的file结构体
5. 增加file结构体的引用计数

10.4 文件描述符与多进程共享

当进程调用fork()时：

1. 子进程获得父进程files_struct的副本
2. 所有文件描述符指向相同的file结构体
3. file结构体的引用计数增加

这意味着：

• 父子进程可以共享文件位置指针
• 一个进程的lseek会影响另一个进程
• 需要同步以避免竞态条件

10.5 性能优化考虑

内核在处理文件描述符时采用多种优化：

1. 文件描述符分配使用位图快速查找空闲位置
2. 常用文件描述符（0/1/2）有特殊快速路径
3. 文件结构体使用RCU机制优化并发访问

理解这些底层细节有助于编写更高效的系统程序。