一、从一个问题开始:进程是如何访问文件的?
在 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 | 为不同文件系统提供统一的抽象接口 |
最后记住三个容易混淆的结论:
- 文件描述符属于进程,不是文件的全局编号。
struct file描述一次打开操作,不等于磁盘上的文件。- 同一个文件可以被多次打开,每次独立打开通常拥有独立的文件偏移量。
下一篇预告
Linux 文件篇(二):open、read、write 与文件偏移量
下一篇将继续沿着本篇的知识往下走:
open()的参数与标志位;O_CREAT、O_TRUNC、O_APPEND;- 文件创建权限与
umask; read()和write()的工作过程;- 文件偏移量如何变化;
lseek()如何改变文件读写位置。
从这一篇开始,我们将真正进入 Linux 文件读写的系统调用层面。