#include <stdio.h>
 
int main(void)
{
    FILE *fp = fopen("myfile", "w");
    if (fp == NULL) {
        perror("fopen");
        return 1;
    }
    fwrite("hello\n", 1, 6, fp);
    fclose(fp);
    return 0;
}

fopen 返回一个 FILE *,fwrite 往这个流里写,fclose 关闭。看起来是 C 库在管文件,实际每一步最终都要落到 open、write、close 三个系统调用上。理解 IO 的关键是把这两层分开:用户态的 FILE 和内核里的文件对象。

文件是属性加内容,读写都要经过内核

文件在磁盘上,磁盘是永久存储介质,也是外设。文件由两部分组成:内容(数据块)和属性(元数据,包括名字、大小、权限、时间戳、inode 编号)。0 字节的空文件不占数据块,但仍要占 inode 和目录项,所以“空文件不占磁盘”是错的。对文件的操作只有两类:改内容,或改属性。

Linux 把设备也抽象成文件:键盘、显示器、网卡、磁盘、管道、套接字都能用 read、write、open、close 访问。内核为每个打开的文件建立一个 struct file,里面的 f_op 指向一组函数指针,不同设备挂不同的 read/write 实现,VFS 按 f_op 分发。开发者只拿一个 fd,就能用同一套接口操作绝大部分资源。

每个设备都有自己的 read/write 实现,struct file 里的 f_op 指向对应的 file_operations;上层只管拿 fd 调 read/write

文件的管理者是操作系统。应用不能直接操作磁盘,读写请求要经过系统调用进入内核,由内核的文件系统和驱动完成。C 库函数只是把系统调用包了一层,方便使用。

用户态经 shell、lib、系统调用接口进入内核,再经驱动落到网卡、硬盘;库函数在系统调用之上,系统调用在内核入口

C 标准库:FILE * 和六种打开方式

stdin、stdout、stderr 是三个全局 FILE *,进程启动时自动打开,分别对应标准输入、标准输出、标准错误。fopen 的第二个参数决定打开方式:

模式行为
r只读,文件必须存在,位置在开头
r+读写,文件必须存在,位置在开头
w只写,文件不存在就创建,存在就截断为 0,位置在开头
w+读写,不存在就创建,存在就截断
a追加写,不存在就创建,写入位置在末尾
a+读和追加写,读从开头,写始终追加到末尾

fwrite(ptr, size, nmemb, stream) 按“每个元素 size 字节、共 nmemb 个”写入,返回成功写入的元素个数;fread 同理。读文件时不要用 while (!feof(fp)) 作循环条件,因为 feof 只有在一次读操作失败后才置位,循环体可能多跑一次。按返回值判断更稳:

#include <stdio.h>
 
int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "usage: %s file\n", argv[0]);
        return 1;
    }
 
    FILE *fp = fopen(argv[1], "r");
    if (fp == NULL) {
        perror("fopen");
        return 2;
    }
 
    char buf[1024];
    size_t n;
    while ((n = fread(buf, 1, sizeof(buf), fp)) > 0)
        fwrite(buf, 1, n, stdout);
 
    if (ferror(fp)) {
        fprintf(stderr, "fread error\n");
        fclose(fp);
        return 3;
    }
 
    fclose(fp);
    return 0;
}

fread 返回 0 时可能是读到了文件末尾,也可能是出错;用 feof(fp) 和 ferror(fp) 区分。fwrite、printf、fprintf(stdout, ...) 都是往标准输出写,fprintf(stderr, ...) 往标准错误写。

系统调用:open 的 flags 是位或出来的

系统调用接口更底层,参数用整数和指针,不隐藏任何细节。open 的 flags 是多个常量按位或组合出来的,每个常量占一个二进制位,这种传参方式在系统接口里很常见:

#include <stdio.h>
 
#define ONE   0001
#define TWO   0002
#define THREE 0004
 
void show(int flags)
{
    if (flags & ONE)   printf("ONE ");
    if (flags & TWO)   printf("TWO ");
    if (flags & THREE) printf("THREE ");
    printf("\n");
}
 
int main(void)
{
    show(ONE);
    show(ONE | TWO);
    show(ONE | TWO | THREE);
    return 0;
}

open 的常用标志:

标志含义
O_RDONLY只读,值为 0
O_WRONLY只写
O_RDWR读写
O_CREAT文件不存在就创建,必须提供 mode
O_TRUNC打开时把文件长度截断为 0
O_APPEND每次写入都追加到文件末尾
O_EXCL与 O_CREAT 连用,文件已存在就失败

前三个访问模式必须指定且只能指定一个。O_CREAT 需要第三个参数 mode,表示新建文件的权限,最终还会被 umask 修正;不创建文件时用两参数版本即可。

#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
int main(void)
{
    umask(0);
    int fd = open("myfile", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return 1;
    }
 
    const char *msg = "hello bit\n";
    for (int i = 0; i < 5; i++) {
        if (write(fd, msg, strlen(msg)) < 0) {
            perror("write");
            close(fd);
            return 1;
        }
    }
 
    close(fd);
    return 0;
}

write(fd, buf, count) 把 buf 开头的 count 字节写进去,返回实际写入的字节数,可能小于 count;read(fd, buf, count) 返回实际读到的字节数,返回 0 表示读到末尾,返回 -1 表示出错。close(fd) 释放这个描述符。lseek(fd, offset, whence) 改读写位置,whence 可以是 SEEK_SET、SEEK_CUR、SEEK_END,返回新位置。

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
 
int main(void)
{
    int fd = open("myfile", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }
 
    char buf[1024];
    ssize_t n;
    while ((n = read(fd, buf, sizeof(buf))) > 0) {
        if (write(1, buf, n) < 0) {
            perror("write");
            close(fd);
            return 1;
        }
    }
    if (n < 0)
        perror("read");
 
    close(fd);
    return 0;
}

fd 是 fd_array 的下标,重定向就是换指针

每个进程的 task_struct 里有一个 files 指针,指向 files_struct。这张表的核心是一个指针数组 fd_array,每个元素指向一个已打开文件的 struct file。文件描述符就是这个数组的下标,拿到 fd 就拿到了对应的文件对象。

task_struct 的 files 指向 files_struct,fd_array 的 0、1、2 分别指向标准输入、标准输出、标准错误,3 指向新打开的文件

课件的说法是“0、1、2 对应的物理设备一般是键盘、显示器、显示器”。更准确的说法是:0、1、2 默认从父进程继承,交互式 shell 下通常都指向同一个控制终端;0 走读方向,1 和 2 走写方向。标准输入可以被重定向成普通文件或管道,标准输出也可以指向文件,它们并不绑定在键盘和显示器上。

分配规则很简单:在 fd_array 里找当前没被用的最小下标。进程启动时 0、1、2 已占用,第一次 open 得到 3;先 close(0) 再 open,新文件就拿到 0。

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
 
int main(void)
{
    close(0);
    int fd = open("myfile", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }
    printf("fd = %d\n", fd);
    close(fd);
    return 0;
}

这段程序打印 0,因为 0 号槽位被腾出来了。把 close(0) 换成 close(2),会打印 2。规则不依赖文件名、内容或打开方式,只看下标有没有被占。

dup2(oldfd, newfd) 让 newfd 也指向 oldfd 对应的文件对象:如果 newfd 已经打开,先关掉它;操作成功后两个描述符共享同一个打开文件描述(包括读写偏移)。重定向的本质就是把 1 号槽位的指针换成另一个文件的指针。

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
 
int main(void)
{
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return 1;
    }
 
    if (dup2(fd, 1) < 0) {
        perror("dup2");
        close(fd);
        return 1;
    }
 
    printf("this line goes to log.txt\n");
    fflush(stdout);
    close(fd);
    return 0;
}

printf 仍然往 stdout 写,stdout 底层用的是 fd 1;fd 1 现在指向 log.txt,内容就进了文件。

close(1) 后 1 号槽位空出来,再 open 新文件会占 1 号,所有原本写往标准输出的内容都改写到这个文件

课件的 dup2 示例里写的是 open("./log", O_CREAT | O_RDWR),少了第三个 mode 参数。open(2) 明确规定:使用 O_CREAT 时必须提供 mode,否则新建文件的权限取自不确定的值。正确写法是 open("./log", O_CREAT | O_RDWR, 0644)。示例里先 close(1) 再 dup2(fd, 1) 也多余,dup2 本身会关掉已打开的 newfd。

dup2 的兄弟是 dup(oldfd):它不指定新下标,直接返回当前最小的可用 fd,语义和 dup2(oldfd, 最小可用) 一样。两个函数复制的是“打开文件描述”,不是文件本身;复制出来的 fd 和原 fd 共享同一个读写偏移,往一个 fd 写,另一个 fd 的 lseek 位置也跟着走。fork 之后父子进程的 fd 表也是这种关系:子进程继承的是指向同一批 struct file 的指针,所以父子往同一个文件追加时,偏移是共享的。

shell 的 >、>>、<、2>&1 都落在这套操作上:> 用 O_WRONLY|O_CREAT|O_TRUNC 打开目标文件再 dup2 到 1;>> 把 O_TRUNC 换成 O_APPEND;< 打开文件后 dup2 到 0;2>&1 把 1 号槽位的指针复制到 2 号。重定向要在子进程 exec 之前做,exec 会保留 fd 表,新程序继承的就是已经改过的 0、1、2。

缓冲区:stdio 一层,内核页缓存一层

每次 read、write 都是一次系统调用,要从用户态切到内核态,开销不小。stdio 在用户空间准备一块缓冲,把多次小写入攒成一次系统调用;内核又在页缓存里缓存磁盘块,减少真正的磁盘访问。

标准 I/O 有三种缓冲方式:

类型刷新时机典型对象
全缓冲缓冲区满、fflush、fclose、exit普通磁盘文件
行缓冲遇到 \n、缓冲区满、fflush、fclose、exit终端上的 stdin、stdout
无缓冲每次调用直接进内核stderr,以及 setvbuf 设置成 _IONBF 的流

课件写“默认行缓冲区大小为 1024”。这个大小由实现决定,glibc 用的是 BUFSIZ,在 glibc 里是 8192 字节,不是固定 1024;换一个 libc 实现可能又是别的值,所以不要拿 1024 当地址或边界来推算。

#include <stdio.h>
#include <string.h>
#include <unistd.h>
 
int main(void)
{
    printf("hello printf\n");
    fwrite("hello fwrite\n", 1, strlen("hello fwrite\n"), stdout);
    write(1, "hello write\n", strlen("hello write\n"));
 
    fork();
    return 0;
}

在终端上跑,三行各出现一次。加 > out.txt 重定向到文件后,out.txt 里有五行:write 一行,printf 和 fwrite 各两行。

原因分两层。终端上的 stdout 是行缓冲,三条输出都带 \n,在 fork 之前就已刷进内核,父子各有一份已经清空的用户缓冲。重定向到普通文件后,stdout 变成全缓冲,printf 和 fwrite 的内容还留在 FILE 的用户缓冲区里;fork 复制地址空间时,这块缓冲区也按写时拷贝复制了一份。父子进程各自在退出时刷新,各自写一次,于是两行变四行。write 不经过 stdio 的用户缓冲,直接进内核,所以只有一行。

课件里还有一个“重定向后内容丢失”的例子:先 close(1),再 open 得到 fd 1,printf 写内容,随后 close(fd)。课件把这个现象归因于“缓冲区没填满”。全缓冲确实会让内容留在用户态,但进程正常退出时 stdio 会刷新所有流,内容本可以写出去;真正让它丢掉的是那句 close(fd)——fd 1 已经被关闭,退出时刷新往 1 号描述符写会得到 EBADF。把 close(fd) 之前加一句 fflush(stdout),或者改用 fclose(stdout),内容就能落盘。

内核页缓存是另一层。write 返回成功,只表示数据已经交给内核并放进页缓存,不表示已经落到磁盘;fsync(fd) 才会要求把脏页写回设备。read 命中页缓存时不用访问磁盘。断电丢数据、write 成功但文件里没有,这类问题都出在这一层,和 stdio 的用户缓冲不是一回事。

FILE 里封装着 fd,自己写一个 mini stdio

FILE 在 glibc 里定义为 struct _IO_FILE,里面除了标志位,主要是三组指针和底层 fd:

字段作用
_flags高位是魔数,低位是流的状态标志
_IO_read_ptr / _IO_read_end / _IO_read_base读缓冲区的当前指针、末尾和起点
_IO_write_base / _IO_write_ptr / _IO_write_end写缓冲区的起点、当前指针和末尾
_IO_buf_base / _IO_buf_end整个缓冲区的起止地址
_fileno底层文件描述符

_fileno 就是底层的文件描述符。fileno(FILE *) 返回它;fdopen(fd, mode) 反过来,把一个已有的 fd 包成 FILE *。这说明“库函数”和“系统调用”不是两套独立的文件系统,库函数只是在 fd 上面加了一层缓冲和格式化。

自己实现一个最小版本,可以把这层关系看清。头文件:

#pragma once
 
#define SIZE 1024
#define FLUSH_NONE 0
#define FLUSH_LINE 1
#define FLUSH_FULL 2
 
struct IO_FILE {
    int flags;
    int fileno;
    char outbuffer[SIZE];
    int size;
};
 
typedef struct IO_FILE mFILE;
 
mFILE *mfopen(const char *path, const char *mode);
int mfwrite(const void *ptr, int num, mFILE *stream);
void mfflush(mFILE *stream);
void mfclose(mFILE *stream);

实现:

#include "my_stdio.h"
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
mFILE *mfopen(const char *path, const char *mode)
{
    int fd = -1;
 
    if (strcmp(mode, "r") == 0)
        fd = open(path, O_RDONLY);
    else if (strcmp(mode, "w") == 0)
        fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    else if (strcmp(mode, "a") == 0)
        fd = open(path, O_WRONLY | O_CREAT | O_APPEND, 0644);
    else
        return NULL;
 
    if (fd < 0)
        return NULL;
 
    mFILE *f = (mFILE *)malloc(sizeof(*f));
    if (f == NULL) {
        close(fd);
        return NULL;
    }
 
    f->fileno = fd;
    f->size = 0;
    f->flags = (fd == 1 || fd == 2) ? FLUSH_LINE : FLUSH_FULL;
    return f;
}
 
void mfflush(mFILE *stream)
{
    if (stream->size > 0) {
        write(stream->fileno, stream->outbuffer, stream->size);
        stream->size = 0;
    }
}
 
int mfwrite(const void *ptr, int num, mFILE *stream)
{
    const char *p = (const char *)ptr;
    int left = num;
 
    while (left > 0) {
        if (stream->size == SIZE)
            mfflush(stream);
 
        int room = SIZE - stream->size;
        int n = left < room ? left : room;
        memcpy(stream->outbuffer + stream->size, p, n);
        stream->size += n;
        p += n;
        left -= n;
 
        if (stream->flags == FLUSH_LINE && stream->size > 0 &&
            stream->outbuffer[stream->size - 1] == '\n')
            mfflush(stream);
    }
    return num;
}
 
void mfclose(mFILE *stream)
{
    if (stream->size > 0)
        mfflush(stream);
    close(stream->fileno);
    free(stream);
}
#include "my_stdio.h"
 
int main(void)
{
    mFILE *f = mfopen("log.txt", "a");
    if (f == NULL)
        return 1;
 
    mfwrite("hello\n", 6, f);
    mfwrite("world\n", 6, f);
    mfclose(f);
    return 0;
}

mfopen 把 mode 映射成 open 的 flags,mfwrite 只往用户缓冲里拷贝,缓冲满或这次写入的最后一个字节是换行时才调用 write,mfclose 先刷新再 close(fd)。这套代码没有 printf 的格式化功能,也没有线程安全和写入失败后的回滚,但结构已经和 glibc 的 FILE 一致:一个 fd,一块缓冲,一套刷新规则。

从 fopen 到 open,从 FILE * 到 fd,从用户缓冲到页缓存,链路走通之后,“重定向为什么能改变 printf 的去向”“为什么 write 不受缓冲影响”“为什么 fork 后多出两行”就不再是三个孤立的怪现象,而是同一个模型在不同参数下的结果。