【Linux操作系统】 文件篇(一):文件描述符与 Linux 文件管理机制

一、从一个问题开始:进程是如何访问文件的?

在 Linux 中,我们经常使用文件。

例如:

  • 使用 cat 查看文件内容;
  • 使用 echo 向文件写入数据;
  • 使用 C 语言的 fopen() 打开文件;
  • 使用 open() 获取文件描述符,再通过 read() 和 write() 读写文件。

这些操作看起来很简单,但我们可以进一步思考一个问题:

当一个进程想要访问磁盘上的文件时,它是如何找到这个文件的?

进程能不能直接通过磁盘上的文件位置进行读写?为什么调用 open() 之后,操作系统会返回一个整数?

要理解这些问题,就需要先了解 Linux 的文件管理机制。

1. 文件不仅仅包含数据

我们平时理解的文件,通常是文件中的内容。

例如,一个 test.txt 文件:

text 复制代码
hello linux

但对于操作系统来说,文件不仅包含数据,还包含与文件相关的属性。

可以从两个方面理解:

  • 文件内容:文件中实际存储的数据。
  • 文件属性:文件的类型、权限、大小、所有者、时间信息等。

因此,可以先把文件理解为:

文件 = 内容 + 属性

当进程访问文件时,操作系统不仅要找到文件的数据,还需要管理文件的相关属性。

例如:

  • 当前进程是否有权限读取文件?
  • 文件是否存在?
  • 文件当前有多大?
  • 文件应该从什么位置开始读取?

这些工作都需要操作系统参与。

2. 为什么访问文件需要先打开?

在 Linux 中,进程不能直接操作磁盘上的文件。

进程需要通过操作系统提供的接口请求内核完成文件访问。

例如:

c 复制代码
int fd = open("test.txt", O_RDONLY);

调用 open() 后,内核会完成文件查找、权限检查以及打开文件相关的数据结构建立等工作。

如果打开成功,open() 会返回一个整数,这个整数就是文件描述符(File Descriptor,简称 fd)。

后续进程可以使用这个文件描述符操作已经打开的文件:

c 复制代码
read(fd, buffer, sizeof(buffer));

这里的 fd 并不是文件本身,也不是文件在磁盘上的地址。

它只是进程访问内核文件管理对象的一个索引。

那么,内核为什么要设计这样一层索引?

原因在于:操作系统需要统一管理大量进程对文件的访问,而文件描述符可以让进程通过一个简单的整数找到对应的打开文件。

二、文件描述符:进程访问文件的入口

1. 文件描述符究竟是什么?

文件描述符本质上是一个非负整数。

当进程调用 open() 成功打开文件时,内核会为这个进程分配一个可用的文件描述符,并将它返回给进程。

例如:

c 复制代码
int fd1 = open("a.txt", O_RDONLY);
int fd2 = open("b.txt", O_RDONLY);
int fd3 = open("c.txt", O_RDONLY);

假设这是一个刚启动、没有关闭标准文件描述符的进程,那么可能得到:

text 复制代码
fd1 = 3
fd2 = 4
fd3 = 5

为什么不是从 0 开始?

因为 Linux 进程通常在启动时就拥有三个标准文件描述符:

文件描述符 名称 默认用途
0 stdin 标准输入
1 stdout 标准输出
2 stderr 标准错误

因此,在这三个描述符都处于打开状态时,第一次调用 open() 通常得到 3。

这里有一个重要结论:

文件描述符是进程级别的资源索引,不是文件的全局编号。

不同进程可以拥有数值相同的文件描述符,但它们对应的文件不一定相同。

例如:

进程 A 的 fd=3 可能对应 a.txt,而进程 B 的 fd=3 可能对应 b.txt。

为什么?

因为每个进程都有自己的文件描述符表。

2. 文件描述符表

我们可以把文件描述符理解为数组下标。

每个进程都有自己的文件描述符表,表中的每一个有效表项都关联着内核维护的打开文件信息。

例如,一个进程打开两个文件:

c 复制代码
int fd1 = open("a.txt", O_RDONLY);
int fd2 = open("b.txt", O_RDONLY);

可以把它抽象成下面的关系:

text 复制代码
             进程 A
        ┌────────────────┐
        │       PCB      │
        │                │
        │  文件描述符表    │
        │                │
        │  0 ────────────┼──── 标准输入
        │  1 ────────────┼──── 标准输出
        │  2 ────────────┼──── 标准错误
        │  3 ────────────┼──── a.txt 对应的打开文件信息
        │  4 ────────────┼──── b.txt 对应的打开文件信息
        └────────────────┘

注意,这张图是概念模型,实际内核实现中,文件描述符表项还包含描述符级别的标志等信息。

当进程调用:

c 复制代码
read(3, buffer, sizeof(buffer));

内核就可以通过当前进程的文件描述符表找到 fd=3 对应的打开文件信息,再完成读取操作。

所以,文件描述符表实际上起到了一个中间索引的作用。

3. 为什么每个进程都需要自己的文件描述符表?

假设两个进程同时打开文件:

text 复制代码
进程 A                  进程 B

fd = 3                  fd = 3
  │                       │ 
  ▼                       ▼
自己的文件描述符表       自己的文件描述符表

虽然两个进程的文件描述符都是 3,但它们的文件描述符表是相互独立的。

因此,文件描述符 3 在不同进程中可以代表完全不同的文件。

这也解释了一个问题:

为什么文件描述符不能直接作为磁盘文件的唯一标识?

因为它只在对应进程的文件描述符表中具有意义。

三、struct file:内核如何管理打开的文件?

前面我们知道:

文件描述符只是一个整数,通过它可以找到文件描述符表中的对应表项。

但是,表项最终关联的是什么?

内核需要一个数据结构来维护每一次打开文件所需要的信息。

在 Linux 内核中,这个重要的数据结构就是:

struct file

1. struct file 保存了什么?

可以先把 struct file 理解为:

内核为了管理一次打开文件操作而维护的对象。

它保存了与本次打开操作有关的信息,例如:

  • 当前文件的访问路径相关信息;
  • 文件的打开状态和访问方式;
  • 当前读写位置,也就是文件偏移量;
  • 文件操作相关的方法;
  • 对相关内核对象的引用关系。

这里特别需要注意:

struct file 不是磁盘上的文件本身,而是内核中的一个打开文件描述对象。

一个磁盘文件可以被多个进程打开,也可以被同一个进程多次打开。

每一次独立的 open(),通常都会创建一个新的打开文件描述对象。

例如:

c 复制代码
int fd1 = open("test.txt", O_RDONLY);
int fd2 = open("test.txt", O_RDONLY);

虽然打开的是同一个路径,但这两次 open() 是独立的打开操作。

在通常情况下:

text 复制代码
fd1 ──────┐
          ▼
       struct file A
          │
          ▼
       同一个文件

fd2 ──────┐
          ▼
       struct file B
          │
          ▼
       同一个文件

这里的 struct file A 和 struct file B 是两个不同的打开文件描述对象。

因此,它们通常拥有各自独立的文件偏移量。

例如:

  • fd1 从文件开头读取一个字符;
  • fd2 再从文件开头读取一个字符。

两次读取互不影响。

这个现象后面还会通过代码验证。

2. struct file 与磁盘文件之间是什么关系?

既然 struct file 不是文件本身,那么它究竟关联着什么?

这里就需要引入 Linux 的 VFS(Virtual File System,虚拟文件系统)。

VFS 是 Linux 内核提供的一层统一文件系统抽象。

Linux 支持多种文件系统,例如 ext4、XFS 等。

不同文件系统内部的实现方式可能不同,但进程不需要针对每一种文件系统编写一套完全不同的文件操作接口。

VFS 通过统一的数据结构和操作接口,将不同文件系统的实现组织起来。

在这个过程中,有几个重要的数据结构:

(1)struct file

表示一次打开文件的状态,保存文件偏移量、打开标志以及相关操作信息等。

(2)struct dentry

目录项对象,用于管理路径名与对应文件对象之间的关联,参与路径查找。

(3)struct inode

索引节点对象,描述文件的元数据信息,例如文件类型、权限、所有者和大小等。

可以把它们之间的关系抽象成:

text 复制代码
进程
  │
  ▼
文件描述符
  │
  ▼
文件描述符表
  │
  ▼
struct file
  │
  ▼
struct path
  │
  ├── vfsmount
  │
  └── dentry
         │
         ▼
       inode
         │
         ▼
   文件系统中的文件

这是一张帮助理解的简化关系图,并不是所有内核版本中实际指针布局的完整展开。

其中:

  • struct file:管理一次打开操作。
  • dentry:帮助内核进行目录项和路径管理。
  • inode:描述文件本身的元数据信息。

注意,磁盘上的数据块和内存中的 inode 对象也不是同一个东西。内核会通过文件系统及其缓存机制管理它们之间的关系。

3. 为什么不能把 struct file 和 inode 混为一谈?

这是理解 Linux 文件管理时非常容易混淆的地方。

假设我们打开同一个文件两次:

c 复制代码
int fd1 = open("test.txt", O_RDONLY);
int fd2 = open("test.txt", O_RDONLY);

可以理解为:

  • 两次打开产生两个独立的 struct file 对象;
  • 两个对象可以关联到同一个文件对应的 inode;
  • 两个打开文件对象可以拥有不同的文件偏移量。

也就是说:

struct file 更关注一次打开操作的状态,inode 更关注文件本身的属性。

两者解决的是不同层面的问题。

四、open():从打开文件到获得文件描述符

前面分别认识了文件描述符表、struct file 和 inode。

现在把它们串联起来:

当进程调用 open() 时,内核究竟做了什么?

例如:

c 复制代码
int fd = open("test.txt", O_RDONLY);

可以将这个过程理解为以下几个阶段。

1. 路径查找

内核根据传入的路径名查找文件。

在查找过程中,会利用 VFS 的路径解析机制,找到对应的目录项和文件对象。

如果文件不存在,或者当前进程没有相应权限,打开操作可能失败。

2. 创建打开文件描述对象

如果文件能够成功打开,内核会建立对应的打开文件描述对象,也就是 struct file。

其中会记录本次打开操作所需要的信息。

例如:

  • 打开方式;
  • 文件偏移量;
  • 文件操作相关信息。

对于新的独立打开操作,文件偏移量通常从文件开头开始。

3. 分配文件描述符

内核为当前进程找到一个可用的文件描述符表项。

通常会优先使用最小的可用非负文件描述符。

例如:

text 复制代码
0  stdin
1  stdout
2  stderr
3  空闲
4  空闲
5  空闲

如果当前进程成功打开文件,内核可能分配 fd=3。

然后将文件描述符表中的对应表项关联到刚刚创建的打开文件描述对象。

4. 返回文件描述符

最后,open() 将这个文件描述符返回给进程。

c 复制代码
int fd = open("test.txt", O_RDONLY);

if (fd == -1)
{
    perror("open");
    return 1;
}

printf("fd = %d\n", fd);

从此以后,进程就可以使用这个 fd 访问对应的打开文件。

整个过程可以总结为:

text 复制代码
           进程调用 open()
                  │
                  ▼
             内核接收请求
                  │
                  ▼
             查找目标文件
                  │
                  ▼
          检查文件及访问权限
                  │
                  ▼
         建立 struct file 对象
                  │
                  ▼
         分配文件描述符表表项
                  │
                  ▼
       将表项关联到 struct file
                  │
                  ▼
             返回 fd 给进程

这就是从文件路径到文件描述符的基本过程。

五、代码验证:观察文件描述符与打开文件

前面介绍了文件描述符的分配机制和内核管理结构。

下面通过几个小实验验证这些结论。

实验一:观察 open() 返回的文件描述符

创建 test_fd.c:

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

int main()
{
    int fd1 = open("a.txt", O_CREAT | O_RDWR, 0666);
    int fd2 = open("b.txt", O_CREAT | O_RDWR, 0666);
    int fd3 = open("c.txt", O_CREAT | O_RDWR, 0666);

    if (fd1 == -1 || fd2 == -1 || fd3 == -1)
    {
        perror("open");
        return 1;
    }

    printf("fd1 = %d\n", fd1);
    printf("fd2 = %d\n", fd2);
    printf("fd3 = %d\n", fd3);

    close(fd1);
    close(fd2);
    close(fd3);

    return 0;
}

编译:

bash 复制代码
gcc test_fd.c -o test_fd

运行:

bash 复制代码
./test_fd

预期输出:

text 复制代码
fd1 = 3
fd2 = 4
fd3 = 5

为什么第一个文件描述符是 3?

因为当前进程通常已经拥有 0、1、2 三个标准文件描述符。

内核分配文件描述符时,会寻找可用的最小编号,因此这里从 3 开始。

注意:这是在三个标准文件描述符都正常打开、没有其他额外描述符占用的前提下得到的结果。

实验二:验证文件描述符是进程级别的

创建 process_fd.c:

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

int main()
{
    int fd = open("test.txt", O_CREAT | O_RDWR, 0666);

    if (fd == -1)
    {
        perror("open");
        return 1;
    }

    printf("process pid = %d\n", getpid());
    printf("file descriptor = %d\n", fd);

    close(fd);

    return 0;
}

编译:

bash 复制代码
gcc process_fd.c -o process_fd

运行:

bash 复制代码
./process_fd

可以看到:

text 复制代码
process pid = 12345
file descriptor = 3

这里的 PID 只是示例,实际运行时会不同。

可以再运行一次程序。

你会发现,新进程仍然可能得到 fd=3。

这是因为每个进程都有自己的文件描述符表。

两个进程都可以使用编号为 3 的文件描述符,但它们并不是同一个文件描述符表项。

实验三:验证两次独立 open() 的文件偏移量相互独立

这个实验非常重要。

它可以帮助我们理解为什么 struct file 不能和 inode 混为一谈。

首先准备文件:

bash 复制代码
echo -n "ABCDE" > test.txt

创建 offset.c:

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

int main()
{
    char ch1;
    char ch2;

    int fd1 = open("test.txt", O_RDONLY);
    int fd2 = open("test.txt", O_RDONLY);

    if (fd1 == -1 || fd2 == -1)
    {
        perror("open");
        return 1;
    }

    read(fd1, &ch1, 1);
    read(fd2, &ch2, 1);

    printf("fd1 read: %c\n", ch1);
    printf("fd2 read: %c\n", ch2);

    close(fd1);
    close(fd2);

    return 0;
}

编译:

bash 复制代码
gcc offset.c -o offset

运行:

bash 复制代码
./offset

预期输出:

text 复制代码
fd1 read: A
fd2 read: A

为什么两次读取都是 A?

因为两次 open() 是独立的打开操作。

它们分别创建了自己的打开文件描述对象。

因此:

text 复制代码
fd1 ── struct file A ── offset = 0
                         │
                         ▼
                      test.txt

fd2 ── struct file B ── offset = 0
                         │
                         ▼
                      test.txt

第一次读取:

c 复制代码
read(fd1, &ch1, 1);

只会让 fd1 对应的文件偏移量向后移动一个字节。

fd2 对应的文件偏移量不会因此改变。

所以第二次读取仍然可以从文件开头读到 A。

这个实验验证了:

两次独立的 open(),即使打开同一个文件,也通常拥有各自独立的文件偏移量。

后面学习 dup()、dup2() 和进程间文件描述符共享时,我们会进一步看到另一种情况:多个文件描述符可以指向同一个打开文件描述对象,从而共享文件偏移量。

六、close():关闭文件描述符意味着什么?

打开文件之后,使用完毕就应该关闭。

例如:

c 复制代码
int fd = open("test.txt", O_RDONLY);

if (fd == -1)
{
    perror("open");
    return 1;
}

close(fd);

close() 的作用是关闭当前进程中的这个文件描述符。

从文件描述符表的角度来看:

text 复制代码
关闭前:

fd = 3 ──────> struct file

关闭后:

fd = 3       空闲

需要注意:

关闭文件描述符,不一定意味着磁盘文件被删除,也不一定意味着内核立即销毁对应的 struct file。

如果还有其他文件描述符或者进程引用着同一个打开文件描述对象,内核仍然需要保留它。

当相关引用全部释放后,内核才可以回收对应的对象。

因此:

  • close(fd) 关闭的是文件描述符;
  • 文件本身仍然存在;
  • 内核根据引用关系决定什么时候释放相关资源。

这也是为什么文件描述符需要合理管理,不能打开大量文件却一直不关闭。

七、本篇总结

现在回到最开始的问题:

进程是如何访问磁盘文件的?

我们可以把整个过程总结成:

text 复制代码
进程
 │
 │ open("test.txt")
 ▼
Linux 内核
 │
 ├── VFS 路径查找
 │
 ├── 找到对应的文件对象
 │
 ├── 建立 struct file
 │
 └── 分配文件描述符
          │
          ▼
     文件描述符表
          │
          ▼
      struct file
          │
          ▼
      struct path
          │
          ▼
       dentry
          │
          ▼
        inode
          │
          ▼
       文件系统
          │
          ▼
       文件数据

本篇需要记住的核心关系:

名称 作用
文件描述符 fd 进程访问打开文件的整数索引
文件描述符表 进程维护的文件描述符映射表
struct file 内核维护的一次打开文件描述对象
dentry 管理目录项与路径查找关系
inode 描述文件的元数据信息
VFS 为不同文件系统提供统一的抽象接口

最后记住三个容易混淆的结论:

  1. 文件描述符属于进程,不是文件的全局编号。
  2. struct file 描述一次打开操作,不等于磁盘上的文件。
  3. 同一个文件可以被多次打开,每次独立打开通常拥有独立的文件偏移量。

下一篇预告

Linux 文件篇(二):open、read、write 与文件偏移量

下一篇将继续沿着本篇的知识往下走:

  • open() 的参数与标志位;
  • O_CREAT、O_TRUNC、O_APPEND;
  • 文件创建权限与 umask;
  • read() 和 write() 的工作过程;
  • 文件偏移量如何变化;
  • lseek() 如何改变文件读写位置。

从这一篇开始,我们将真正进入 Linux 文件读写的系统调用层面。

相关推荐
发疯的技术鼠1 小时前
03-优先级与调度
linux
manduic2 小时前
汽车座舱Buck选型实战:AWK6613 对比 SCT2432,参数逐项对齐(附选型清单)
网络·汽车
Flying Bear2 小时前
Keithley 2450 SourceMeter源表上位机开发笔记
笔记·单片机·嵌入式硬件
旖旎夜光3 小时前
【C++ 基础入门】智能指针:RAII、unique_ptr 与 shared_ptr 循环引用
c++·笔记·学习·智能指针
无足鸟ICT3 小时前
【RHCA+】sosreport(收集诊断文档)
linux·运维·服务器
GeW3 小时前
世界目光聚焦中国:底层技术、Linux、数据库的破局逻辑
linux·数据库
饮水桶_T4 小时前
Python 面向对象(十七)|继承、封装、多态 笔记
数据结构·笔记·算法
ShineWinsu4 小时前
对于Qt:QSpacerItem常见属性以及方法的解析
开发语言·c++·qt·面试·系统架构·客户端·qspaceritem
星恒随风5 小时前
MySQL 从零入门(十):MVCC、Undo Log 与 Read View 详解——InnoDB 如何实现事务隔离?
linux·数据库·笔记·sql·mysql