【Linux】一切皆文件：深入理解文件与文件IO

FILE *fopen(const char *path, const char *mode);

// 写文件
int fputc(int character,FILE* stream)；
int fputs(const char *s, FILE *stream);
int fprintf(FILE *stream, const char *format, ...);
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

// 读文件
int fgetc(FILE* stream);
char *fgets ( char *str, int num, FILE * stream );
int fscanf(FILE* stream, const char* format, ...);
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

int fclose(FILE *stream);

2.2、实现cat 指令

当我们执行 cat log.txt 指令，其实就是读 log.txt 文件。

复制代码

#include<stdio.h>
#include<string.h>
// argv[0]：./cat 
// argv[1]：文件名
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        printf("cat error\n");
        return 1;
    }
    FILE* fp = fopen(argv[1], "r"); // 打开文件
    if(fp == NULL)
    {
        perror("fopen");
        return 2;
    }
    char buff[1024];
    while(1)
    {
        int ch = fread(buff, 1, sizeof(buff), fp); // 将文件内容写入数组
        if(ch > 0)
        {
            buff[1024] = 0;
            printf("%s", buff);
        }
        if(feof(fp)) break;
    }
    fclose(fp);
    return 0;
}

2.3、stdin & stdout & stderr

C语言程序在启动的时候，默认打开了3个流：

• **stdin-标准输⼊流：**在大多数的环境中从键盘输入，scanf函数就是从标准输入流中读取数据。

•**stdout-标准输出流：**大多数的环境中输出至显示器界面，printf函数就是将信息输出到标准输出流中。

• **stderr-标准错误流：**大多数环境中输出到显示器界面。

三、系统文件IO

系统文件IO 就是通过系统调用的方式实现文件的读和写，C语言文件读写的接口就是通过底层封装Linux系统调用接口实现的。C语言读写文件通过w，r，a等选项确定，而系统调用则是通过传递标志位的方式实现的。

3.1、传递标志位的方法

定义几个宏，每个宏代表一个标志位，而标志位就是只有一个二进制位为1的数，当我们将参数flags与标志位进行按位与&操作时，只有当flags的对应二进制与标志位同时为1时，才执行相应的操作。

将文件读写的各种方式都设置一个对应的标志位，通过这种方式我们就可以控制对文件的读和写。

cpp 复制代码

// 标志位
#define FIRST_FLAGS  (1<<0)
#define SECOND_FLAGS (1<<1)
#define THIRD_FLAGS  (1<<2)
#define FORTH_FLAGS  (1<<3)

void Print(int flags)                                                                                                                                                                                                          
{
    if(flags & FIRST_FLAGS)
        printf("FIRST_FLAGS : %d\n", FIRST_FLAGS);
    if(flags & SECOND_FLAGS) 
        printf("SECOND_FLAGS : %d\n", SECOND_FLAGS);
    if(flags & THIRD_FLAGS)
        printf("THIRD_FLAGS : %d\n", THIRD_FLAGS);
    if(flags & FORTH_FLAGS)
        printf("FORTH_FLAGS : %d\n", FORTH_FLAGS);
}
int main()
{
    Print(FIRST_FLAGS);
    Print(FIRST_FLAGS | SECOND_FLAGS);
    Print(FIRST_FLAGS | SECOND_FLAGS | THIRD_FLAGS);
    Print(FIRST_FLAGS | SECOND_FLAGS | THIRD_FLAGS | FORTH_FLAGS);
    return 0;
}

常用的标志位：

创建：O_CREAT，如对应c文件在以 "w" 方式打开，当文件不存在就会新建。

写：O_WRONLY，对应 "w"。

读：O_RDONLY，对应 "r"。

追加：O_APPEND，对应 "a"。

清空：O_TRUNC，当以"w" 方式写文件时，就会将文件的内容先清空。

3.2、系统调用接口

1、open------打开文件

参数：

（1）**pathname：**文件名（路径可带也可不带）；

（2）flags：标志位；

**•**当我们读文件即为：O_RDONLY；

**•**写文件：**O_CREAT |**O_WRONLY | O_TRUNC；

**•**追加写文件：**O_CREAT |**O_WRONLY | O_APPEND。

（3）mode：权限位。

如果不传该参数，且文件不存在，创建的文件默认初始权限为：-r- xr- x--

所以如果文件不存在，我们就需要设置权限位，而我们前面已经介绍过，修改文件权限可以直接用八进制数。通过0666就可以正常设置普通文件的权限。

返回值：文件描述符。

2、close------关闭文件

参数即为要关闭文件的文件描述符，open函数的返回值。

3、write------写文件

write() 函数会从指针**buf** 指向的缓冲区中，向文件描述符 fd 所引用的文件写入最多 **count**个字节的数据。而且系统其实并不关心写入数据的类型。

4、read------读文件

read() 函数尝试从文件描述符**fd** 所指向的文件中，读取最多**count** 个字节的数据，并将其存入以**buf**为起始地址的缓冲区中。

3.3、文件描述符

open函数返回值即为创建或打开文件的文件描述符，但我们注意到这个数字是3而不是其他。

这是为什么？

当启动一个 Shell（比如 Bash）时，Shell 进程本身会默认打开这三个标准流，即标准输入流，标准输出流和标准错误流。而后续在这个 Shell 中启动的子进程，也会继承这三个已打开的流。

这三个流其实也是文件，对应文件描述符为0，1和2。

标准输入（stdin, fd=0） → 默认绑定到键盘

标准输出（stdout, fd=1） → 默认绑定到显示器

标准错误（stderr, fd=2） → 默认绑定到显示器

后面再打开文件，自然就对应3，4... 了。

而我们在c语言中打开文件时，是用FILE* 指针指向我们打开的文件，但是在底层一个整数即代表打开的文件。0，1，2，3... 是不是跟数组下标又有什么关系？这就涉及到操作系统对文件的管理

当进程打开多个文件，怎么管理：先描述，再组织。

将文件的特性用一个结构体进行描述，用一个指针指向 file 结构体，然后将这个指针放在文件描述符表中，就可以进行管理了。

cpp 复制代码

// 路径：include/linux/fs.h
struct file {
    union {
        struct llist_node    fu_llist;
        struct rcu_head      fu_rcuhead;
    } f_u;
    struct path             f_path;       // 文件的路径（包含 dentry 和 vfsmount）
    const struct file_operations *f_op;  // 文件操作方法（read/write 等）
    spinlock_t              f_lock;      // 保护该结构体的自旋锁
    atomic_long_t           f_count;     // 引用计数（被多少进程打开）
    unsigned int            f_flags;     // 文件打开时的标志（O_RDONLY/O_WRONLY/O_APPEND 等）
    fmode_t                 f_mode;      // 文件的访问模式（读/写/执行权限）
    loff_t                  f_pos;       // 当前读写位置（文件指针）
    struct fown_struct      f_owner;     // 信号异步 IO 相关的所有者信息
    const struct cred       *f_cred;     // 文件的安全凭证
    struct file_ra_state    f_ra;        // 预读状态
    void                    *private_data;// 驱动/文件系统的私有数据
};

此时，我们也就懂了为什么log.txt文件的文件标识符为3了。

文件描述符分配规则：

创建文件后，操作系统遍历文件标识符表，找到的第一个空位置就用来存放指向该文件file结构体的指针。

验证：我们手动关闭标准输入流文件，然后创建log.txt文件，观察log.txt文件的文件标识符。

3.4、重定向

回顾以前的重定向操作：

**•**输入重定向 < ：将键盘读入改成从文件读入。
bash 复制代码
cat < log.txt
**•**输出重定向 ：将向显示器输出改为向文件输出，> 覆盖写入和 >> 追加写入。
bash 复制代码
echo "hello Linux" > temp.txt
echo "hello Linux" >> temp.txt

现在我们已经知道fd_array[0] 指向标准输入流文件，fd_array[1] 指向标准输出流文件，fd_array[2] 指向标准错误流文件。所以，我们只需要让原来指向对应流的指针指向我们的文件即可，因此：

输入重定向：

输出重定向：

重定向函数------dup2

dup2为系统接口，用来将oldfd 重定向到newfd。

对于输入重定向：oldfd = fd，newfd = 0；即 dup2(fd，0)

bash 复制代码

int main()
{
    char buf[1024] = {0};
    // 1. 打开要作为输入的文件
    int fd = open("input.txt", O_RDONLY);
    if (fd == -1) {
        perror("open failed");
        exit(1);
    }
    // 2. 核心：把 stdin（fd=0）重定向到 input.txt
    // dup2(oldfd, newfd)：将 newfd 指向 oldfd 对应的文件
    dup2(fd, 0);

    // 3. 关闭原文件描述符（fd 已复制到 0，无需保留）
    close(fd);

    // 4. 从 stdin 读取（实际从 input.txt 读）
    fread(buf, sizeof(buf), 1, stdin);
    printf("%s", buf);                                                                                                                                                                        
    return 0;
}

输出重定向：oldfd = fd，newfd = 1；即 dup2(fd，1)

bash 复制代码

int main()             
{                      
    // 打开文件        
    int fd = open("log.txt", O_CREAT | O_WRONLY | O_TRUNC, 0666);
                       
    // 关键操作：将标准输出文件重定向到log.txt文件
    dup2(fd, 1);       
    // 向显示器输出改为向log.txt文件输出                                                                                                                                                      
    printf("xxxxxxxxx\n");          
    fprintf(stdout, "aaaaaaaaaa\n");
    close(fd);           
   return 0;            
}

💡💡根据文件描述符分配规则，如果我们先关闭标准输出流，则新创建的文件的 fd = 1，此时我们再向标准输出流打印数据，实际上也会重定向到该文件。

bash 复制代码

int main()
{
    // 关闭标准输出流
    close(1);
    int fd = open("log.txt", O_CREAT | O_WRONLY | O_TRUNC, 0666);
    printf("xxxxxxxxxx\n");
    fprintf(stdout, "sssssssssss\n");
    // close(fd);
    return 0;                                                                                                                                                                               
}

++注意：++有一个细节，我们最后不关闭fd文件，这里涉及缓冲区刷新的问题，下面会讲到。

补充：标准错误重定向

💦 直接看效果：标准输出流重定向 ./myfie > log.txt ， 其实真正的写法为：./myfile 1 > log.txt

只是把1 省略不写。

bash 复制代码

int main()
{
    printf("wwwwwwww\n");
    fprintf(stdout, "ssssssssss\n");
    const char *s = "hello Linux\n";                                                                                                                                                          
    fwrite(s, strlen(s), 1, stdout);
    return 0;
}

💦 标准错误流与标准输出流一样，都和显示器绑定。因此，重定向操作为：

./myfile 2>log.err

++注意：++2>log.err 之间没有空格。
cpp 复制代码
int main()                                     
{                                              
    std::cerr << "hello cerr\n"; // c++标准错误流
    perror("hello stderr"); // c标准错误流                                                                                                                                                    
    return 0;                                         
} 
💦 将标准输出流内容与标准错误流的内容全部重定向到一个文件：
cpp 复制代码
int main()
{
    // 标准输出流
    printf("hello printf\n");
    fprintf(stdout,"%s", "hello fprintf\n");
                                                                                                                                                                                              
    // 标准错误流
    std::cerr << "hello cerr" << std::endl;
    perror("hello pereor");
    return 0;
}
❌️ ./myfile 1>log.txt 2>log.txt：第二次重定向时即第二次打开文件，先清空之前内容再写入，无法将所有内容重定向到 log.txt 文件。

✔️ ./myfile 1>>log.txt 2>>log.txt：追加重定向。

💡还有一种写法：./myfile 1>log.txt 2>&1

3.5、理解一切皆文件

Linux中键盘，显示器，磁盘，网卡等外设，也被抽象为文件，来方便操作系统管理（先描述，再组织）。但是对于不同的外设，读写方式不同，而在 file 结构体中还有一个东西：f_op指针

其类型为const struct file_operations，在struct file_operations结构体中的成员除了struct module* owner 其余都是函数指针，这些函数指针可以指向不同外设的读写的函数。

file_operation 就是把系统调用和驱动程序关联起来的关键数据结构，这个结构的每一个成员都对应着一个系统调用。读取 file_operation 中相应的函数指针，接着把控制权转交给函数，从而完成了Linux设备驱动程序的工作。

cpp 复制代码

struct file
{
    // ...
    const struct file_operations *f_op;  // 文件操作方法（read/write 等）
    // ...
};

cpp 复制代码

struct file_operations 
{
    struct module *owner;
    //指向拥有该模块的指针；
    
    loff_t (*llseek) (struct file *, loff_t, int);
    //llseek 方法用作改变文件中的当前读/写位置, 并且新位置作为(正的)返回值.
    
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    //用来从设备中获取数据
    
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    //发送数据给设备. 如果 NULL, -EINVAL 返回给调用 write 系统调用的程序. 如果非负,
返回值代表成功写的字节数.
    
    ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long,
loff_t);
    //初始化一个异步读 -- 可能在函数返回前不结束的读操作.
    
    ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned
long, loff_t);
    //初始化设备上的一个异步写.
    
    int (*readdir) (struct file *, void *, filldir_t);
    //对于设备文件这个成员应当为 NULL; 它用来读取目录, 并且仅对**文件系统**有用.
    
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
    int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    int (*mmap) (struct file *, struct vm_area_struct *);
    //mmap 用来请求将设备内存映射到进程的地址空间. 如果这个方法是 NULL, mmap 系统调用
返回 -ENODEV.
    int (*open) (struct inode *, struct file *);
    //打开一个文件
    
    int (*flush) (struct file *, fl_owner_t id);
    //flush 操作在进程关闭它的设备文件描述符的拷贝时调用;
    
    int (*release) (struct inode *, struct file *);
    //在文件结构被释放时引用这个操作. 如同 open, release 可以为 NULL.
    
    int (*fsync) (struct file *, struct dentry *, int datasync);
    //用户调用来刷新任何挂着的数据.
    
    int (*aio_fsync) (struct kiocb *, int datasync);
    int (*fasync) (int, struct file *, int);
    int (*lock) (struct file *, int, struct file_lock *);
    //lock 方法用来实现文件加锁; 加锁对常规文件是必不可少的特性, 但是设备驱动几乎从不实
现它.
    ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *,
int);
    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned
long, unsigned long, unsigned long);
    int (*check_flags)(int);
    int (*flock) (struct file *, int, struct file_lock *);
    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t
*, size_t, unsigned int);
    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *,
size_t, unsigned int);
    int (*setlease)(struct file *, long, struct file_lock **);
};

甚至管道，也是文件；将来我们要学习网络编程中的socket（套接字）这样的东西, 使用的接口跟文件接口也是一致的。

四、缓冲区

4.1、什么是缓冲区？

缓冲区（Buffer） 是内存中开辟的一块临时存储区域 ，核心作用是协调两个速度不匹配的设备 / 组件之间的数据传输，通过 "批量读写" 替代 "逐字节读写" 减少高频交互的开销，提升整体效率。

缓冲区根据其对应的是输入设备还是输出设备，分为输入缓冲区和输出缓冲区

4.2、为什么要有缓冲区？

⚠️你往硬盘写数据（硬盘速度：MB/s 级），内存速度是 GB/s 级，两者速度差上万倍；如果逐字节写，内存要等硬盘每次写完，大部分时间都在闲置；

先把数据写到内存缓冲区，攒够一批再一次性写入硬盘，内存不用频繁等待，硬盘也能批量处理，整体效率大幅提升。

⚠️我们向显示器打印，如果每调用一次 fprintf 就对应调用一次系统调用write，那么系统调用的频率就会大大增加。我们知道操作系统是非常忙的，而这样就会降低操作系统的效率。

所以在用户层，设置用户态缓冲区（C 标准库封装，针对FILE* ，C 标准库（<stdio.h> ）为每个FILE* 对象（如stdin/stdout/stderr ）维护的一块内存区域）；可以看看FILE结构体:

cpp 复制代码

// 在/usr/include/stdio.h
typedef struct _IO_FILE FILE; 

// 在/usr/include/libio.h
struct _IO_FILE 
{
    int _flags; /* High-order word is _IO_MAGIC; rest is flags.*/
    #define _IO_file_flags _flags
    //缓冲区相关
    /* The following pointers correspond to the C++ streambuf protocol. */
    /* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
    char* _IO_read_ptr; /* Current read pointer */
    char* _IO_read_end; /* End of get area. */
    char* _IO_read_base; /* Start of putback+get area. */
    char* _IO_write_base; /* Start of put area. */
    char* _IO_write_ptr; /* Current put pointer. */
    char* _IO_write_end; /* End of put area. */
    char* _IO_buf_base; /* Start of reserve area. */
    char* _IO_buf_end; /* End of reserve area. */
    /* The following fields are used to support backing up and undo. */
    char *_IO_save_base; /* Pointer to start of non-current get area. */
    char *_IO_backup_base; /* Pointer to first valid character of backup area
    */
    char *_IO_save_end; /* Pointer to end of non-current get area. */
    struct _IO_marker *_markers;
    struct _IO_FILE *_chain;
    int _fileno; //封装的文件描述符
    #if 0
    int _blksize;
    #else
    int _flags2;
    #endif
    _IO_off_t _old_offset; /* This used to be _offset but it's too small. */
    #define __HAVE_COLUMN /* temporary */
    /* 1+column number of pbase(); 0 is unknown. */
    unsigned short _cur_column;
    signed char _vtable_offset;
    char _shortbuf[1];
    /* char* _save_gptr; char* _save_egptr; */
    _IO_lock_t *_lock;
    #ifdef _IO_USE_OLD_IO_FILE
};

当调用 库函数（fopen/fwrite/printf/fputs等 ）时，先将内容存储到缓冲区，然后按照一定的规则进行批量化的刷新，将数据刷新到文件内核缓冲区，就会大大降低系统调用的次数，从而提高效率。

行缓冲 （stdout 默认）：缓冲区遇到换行符\n 、缓冲区满、调用**fflush()/fclose()** 时，才会把数据批量传给内核；

无缓冲 （stderr 默认）：数据不经过缓冲区，调用**fprintf(stderr)** 时直接传给内核，这也是错误信息能实时输出的原因；

全缓冲 （普通文件默认）：只有缓冲区满 或调用**fflush()/fclose()**时，才会批量传给内核（缓冲区大小一般为 4KB/8KB）。
计算机数据流动的本质：拷贝！！！

深入了解缓冲区

我们来看这样一段代码：

cpp 复制代码

int main()
{
    // 库函数
    printf("hello printf\n");
    fprintf(stdout,"hello fprintf\n");
    const char *s = "hello fwrite\n";
    fwrite(s, strlen(s), 1, stdout);

    //系统调用
    const char* ss = "hello write\n";
    write(1, ss, strlen(ss));

    fork();                                                                                                                                                                                                                      
     return 0;
}

我们发现 printf 和 fwrite （库函数）都输出了2次，而 write 只输出了一次（系统调用）。为什么呢？肯定和fork有关！

• 一般C库函数写入文件时是全缓冲的，而写入显示器是行缓冲。

• printf fwrite 库函数+会自带缓冲区，当发生重定向到普通文件时，数据的缓冲方式由行缓冲变成了全缓冲。

• 而我们放在缓冲区中的数据，就不会被立即刷新，甚至fork之后。

• 但是进程退出之后，会统一刷新，写入文件当中。

• 而fork的时候，父子数据会发生写时拷贝，所以当你父进程准备刷新的时候，子进程也就有了同样的一份数据，随即产生两份数据。

• write 没有变化，说明没有所谓的缓冲。
😄 创作不易，你的点赞和关注都是对我莫大的鼓励，再次感谢您的观看😘