Linux 基础 IO：文件描述符、系统调用与缓冲的本质

// hello.c —— 打开文件并卡住，观察进程状态
#include <stdio.h>
 
int main()
{
    // fopen("myfile", "w")：以"写"模式打开（若不存在则创建）名为 myfile 的文件
    // 参数1 文件名是相对路径；参数2 是打开方式
    FILE *fp = fopen("myfile", "w");
    if (fp == NULL)           // fopen 失败返回 NULL
    {
        printf("fopen error!\n");
        return 1;
    }
    // 打开成功后用一个死循环卡住进程，方便我们去 /proc 里观察它
    while (1);
    fclose(fp);               // 正常情况用 fclose 关闭（这里永远执行不到）
    return 0;
}

# 先查到 hello 这个进程的 PID
$ ps ajx | grep hello | grep -v grep
  506729  533463  533463  506729 pts/2  533463 R+    1002   7:45 ./hello
 
# 用 PID 去 /proc 里查看这个进程的档案
$ ls /proc/533463 -l
total 0
...
lrwxrwxrwx 1 hyb hyb 0 Aug 26 16:53 cwd -> /home/hyb/io   # 当前工作目录
lrwxrwxrwx 1 hyb hyb 0 Aug 26 16:53 exe -> /home/hyb/io/hello  # 可执行文件
dr-x------ 2 hyb hyb 0 Aug 26 16:54 fd                      # 文件描述符表
...

// write_demo.c —— 用 fwrite 向文件写入内容
#include <stdio.h>
#include <string.h>
 
int main()
{
    // "w" 模式：不存在则创建，存在则清空
    FILE *fp = fopen("myfile", "w");
    if (fp == NULL)
    {
        printf("fopen error!\n");
        return 1;
    }
 
    const char *msg = "hello bit!\n";   // 要写的内容
    int count = 5;
    while (count--)                     // 循环 5 次
    {
        // fwrite(数据, 单个元素大小, 元素个数, 流)
        // fwrite(msg, strlen(msg), 1, fp)：写 1 个"长度为 strlen(msg)"的元素
        fwrite(msg, strlen(msg), 1, fp);
    }
 
    fclose(fp);                         // 关闭并刷新缓冲区
    return 0;
}

// read_demo.c —— 用 fread 读文件内容
#include <stdio.h>
#include <string.h>
 
int main()
{
    // "r" 模式：只读，文件必须存在
    FILE *fp = fopen("myfile", "r");
    if (fp == NULL)
    {
        printf("fopen error!\n");
        return 1;
    }
 
    char buf[1024];                     // 存放读到的内容
    // key：这里用 fread(buf, 1, strlen("hello bit!\n"), fp)
    // 即每次都尝试读 strlen(...) 个"1 字节的元素"——这时返回值就等于字节数
    size_t n = strlen("hello bit!\n");
    while (1)
    {
        ssize_t s = fread(buf, 1, n, fp);   // 返回实际读到的字节数
        if (s > 0)
        {
            buf[s] = 0;                     // 手动补上字符串结束符
            printf("%s", buf);
        }
        if (feof(fp))                       // 判断是否读到文件末尾
        {
            break;
        }
    }
 
    fclose(fp);
    return 0;
}

// mycati.c —— 一个简易 cat：./mycati 文件名，把内容打印出来
#include <stdio.h>
#include <string.h>
 
int main(int argc, char *argv[])
{
    if (argc != 2)                 // 只接受一个命令行参数
    {
        printf("argv error!\n");
        return 1;
    }
 
    FILE *fp = fopen(argv[1], "r");  // 打开命令行里指定的文件
    if (fp == NULL)
    {
        printf("fopen error!\n");
        return 2;
    }
 
    char buf[1024];
    while (1)
    {
        // 一次尽量多读：读满 buf（1024 字节），size=1 保证返回的是字节数
        int s = fread(buf, 1, sizeof(buf), fp);
        if (s > 0)
        {
            buf[s] = 0;            // 补结束符
            printf("%s", buf);     // 打印
        }
        if (feof(fp))              // EOF 则结束
        {
            break;
        }
    }
 
    fclose(fp);
    return 0;
}

// print_all.c —— 往 stdout 输出的几种方式
#include <stdio.h>
#include <string.h>
 
int main()
{
    const char *msg = "hello fwrite\n";
 
    // 1) fwrite 显式指定 streams=stdout：写出 strlen(msg) 个字节
    fwrite(msg, strlen(msg), 1, stdout);
 
    // 2) printf 默认就往 stdout 输出，还支持格式化
    printf("hello printf\n");
 
    // 3) fprintf 显式指定流，等价于带格式化的 fwrite
    fprintf(stdout, "hello fprintf\n");
 
    return 0;
}

#include <stdio.h>
 
// 这三个是 C 库声明的全局"文件流"，类型都是 FILE*
extern FILE *stdin;   // 标准输入：默认连着键盘
extern FILE *stdout;  // 标准输出：默认连着显示器
extern FILE *stderr;  // 标准错误：默认连着显示器（用于报错信息）

// flags_demo.c —— 用"位"来传递多个标志
#include <stdio.h>
 
// 三个标志，各自占用一个二进制位，互不重叠
// 0001(即十进制 1)、0010(2)、0100(4)
#define ONE   0001   // 二进制 0001
#define TWO   0002   // 二进制 0010
#define THREE 0004   // 二进制 0100
// 注意：C 里以 0 开头的是八进制，0001=1、0002=2、0004=4
 
// func 根据 flags 里"置位"了哪些位来决定行为
void func(int flags)
{
    if (flags & ONE)   printf("flags has ONE! ");   // 按位与：看 ONE 那一位是否为 1
    if (flags & TWO)   printf("flags has TWO! ");
    if (flags & THREE) printf("flags has THREE! ");
    printf("\n");
}
 
int main()
{
    func(ONE);            // 只带 ONE       -> flags has ONE!
    func(THREE);          // 只带 THREE     -> flags has THREE!
    func(ONE | TWO);      // 同时带 ONE 和 TWO
    func(ONE | THREE | TWO); // 三者都带上
    return 0;
}

// sys_write.c —— 用系统调用 open + write 写文件
#include <stdio.h>
#include <string.h>
#include <unistd.h>      // 声明系统调用 write / close / read
#include <sys/types.h>
#include <sys/stat.h>    // 声明 open 所需的一些类型
#include <fcntl.h>       // 声明 open 以及 O_* 一系列标志
 
int main()
{
    umask(0);            // 不屏蔽任何权限位，让 open 的 mode 原样生效（稍后解释）
 
    // open(文件名, 标志, 权限)
    // O_WRONLY：只写打开；O_CREAT：文件不存在则创建
    // 0644：创建新文件时的权限 = rw-r--r--（8 进制）
    int fd = open("myfile", O_WRONLY | O_CREAT, 0644);
    if (fd < 0)          // 系统调用失败返回 -1
    {
        perror("open");  // perror 根据 errno 打印出错原因
        return 1;
    }
 
    int count = 5;
    const char *msg = "hello bit!\n";
    int len = strlen(msg);
    while (count--)
    {
        // write(fd, 缓冲区地址, 想写的字节数)
        // 返回值：实际成功写入的字节数
        write(fd, msg, len);
    }
 
    close(fd);           // 关闭文件描述符
    return 0;
}

// sys_read.c —— 用系统调用 open + read 读文件
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
int main()
{
    // 只读打开，O_RDONLY 就是"只读"
    int fd = open("myfile", O_RDONLY);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
 
    char buf[1024];
    while (1)
    {
        // read(fd, 缓冲区, 想读的字节数)
        // 返回值：实际读到的字节数；0 表示读到文件末尾(EOF)；-1 表示出错
        ssize_t s = read(fd, buf, sizeof(buf) - 1);
        if (s > 0)
        {
            buf[s] = 0;      // 补结束符
            printf("%s", buf);
        }
        else if (s == 0)     // EOF
        {
            break;
        }
        else                 // 出错
        {
            perror("read");
            break;
        }
    }
 
    close(fd);
    return 0;
}

// 头文件
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
 
// 打开：成功返回一个文件描述符，失败返回 -1
//   两个参数版本：open(pathname, flags)
//   三个参数版本：open(pathname, flags, mode)  —— 当用到 O_CREAT 时必须用这个
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
 
// 关闭：成功返回 0，失败返回 -1
int close(int fd);
 
// 读：返回实际读到的字节数；0=EOF；-1=出错
ssize_t read(int fd, void *buf, size_t count);
 
// 写：返回实际写出的字节数；可能小于 count（部分写）
ssize_t write(int fd, const void *buf, size_t count);
 
// 移动读写位置：成功返回新偏移，失败返回 -1
off_t lseek(int fd, off_t offset, int whence);  // whence: SEEK_SET/SEEK_CUR/SEEK_END

// std_fd.c —— 直接用 fd 0/1/2 完成"从键盘读、往屏幕写"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
 
int main()
{
    char buf[1024];
    // fd 0 是标准输入（键盘）。read(0, ...) 读键盘输入
    ssize_t s = read(0, buf, sizeof(buf));
    if (s > 0)
    {
        buf[s] = 0;                   // 补结束符
        // fd 1 是标准输出（显示器）
        write(1, buf, strlen(buf));
        // fd 2 是标准错误（也是显示器）
        write(2, buf, strlen(buf));
    }
    return 0;
}

// fd_rules.c —— 观察 fd 分配规则
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
 
int main()
{
    // 此时 0/1/2 都已被占，所以第一个 open 拿到最小空闲下标 3
    int fd = open("myfile", O_RDONLY);
    printf("fd: %d\n", fd);   // 输出 fd: 3
    close(fd);
    return 0;
}

// fd_rules2.c —— 关闭 0 或 2 后再 open，观察 fd 会变成 0 或 2
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
 
int main()
{
    close(0);                    // 先把 0 号让出来
    // close(2);                 // 换成关 2 也一样，测试时两个二选一
    int fd = open("myfile", O_RDONLY);
    printf("fd: %d\n", fd);      // 由于 0 被关闭，open 捡到最小的空位 0 -> 输出 0
    close(fd);
    return 0;
}

// redirect_first.c —— 关掉 stdout，观察输出"变形"
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
 
int main()
{
    close(1);                                   // 关上标准输出 fd 1
 
    // 因为 1 空了，open 最小可用下标规则生效：fd 一定拿到 1！
    int fd = open("myfile", O_WRONLY | O_CREAT, 0644);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    printf("fd: %d\n", fd);   // 注意：这条 printf 会打进 myfile！
    fflush(stdout);           // 强制刷新，确保内容真的落到文件
    close(fd);
    exit(0);
}

#include <unistd.h>
 
// 把 oldfd 这个描述符"复制"到 newfd 这个描述符上
// 效果：newfd 从此和 oldfd 指向同一个"打开文件对象"
int dup2(int oldfd, int newfd);

// dup2_demo.c —— 用 dup2 把 stdin 重定向到 stdin.txt，把 stdout 重定向到 log
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
 
int main()
{
    // 打开输入文件；此时 fd 至少是 3（0/1/2 已占用）
    int in = open("stdin.txt", O_RDONLY);
    int out = open("log", O_CREAT | O_RDWR | O_TRUNC, 0666);
    if (in < 0 || out < 0)
    {
        perror("open");
        return 1;
    }
 
    dup2(in, 0);     // 让 fd 0 指向 in —— 从此"从标准输入读"= 从 stdin.txt 读
    close(in);       // 释放临时 fd 3
    dup2(out, 1);    // 让 fd 1 指向 out —— 从此"printf"= 写进 log
    close(out);
 
    // 循环读文件，printf 往 stdout 打，但 stdout 已经是 log 了
    char buf[1024];
    for (;;)
    {
        ssize_t n = read(0, buf, sizeof(buf) - 1);   // 读的是 stdin.txt
        if (n <= 0) break;
        buf[n] = 0;
        printf("%s", buf);   // 写的是 log
        fflush(stdout);      // 刷掉 printf 的用户缓冲
    }
    return 0;
}

// myshell.c —— 带输入/输出/追加重定向的迷你 shell
// gcc -o myshell myshell.c && ./myshell
#include <ctype.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
 
// 四种重定向状态：无、输入(<)、输出(>)、追加(>>)
enum { NONE, INPUT, OUTPUT, APPEND };
 
int main()
{
    char line[1024];
    for (;;)
    {
        printf("[my-shell]# ");   // 命令提示符
        fflush(stdout);           // 提示符要立刻显示，手动刷新（重点！后面讲缓冲）
 
        // 从标准输入读一行命令，读到 EOF（Ctrl+D）则退出
        if (fgets(line, sizeof(line), stdin) == NULL)
            break;
        line[strcspn(line, "\n")] = 0;   // 去掉行尾换行符
        if (line[0] == 0)
            continue;                   // 空行跳过
 
        // ---------- 第一步：解析重定向符号 ----------
        int redir = NONE;               // 默认无重定向
        char *filename = NULL;          // 重定向目标文件名
        char *p = line + strlen(line) - 1;   // 从行尾往前找重定向符
        while (p >= line)
        {
            if (*p == '<')             // 输入重定向
            {
                redir = INPUT;
                *p = 0;                // 断开命令行与文件名的连接
                filename = p + 1;
                break;
            }
            else if (*p == '>')
            {
                if (p > line && *(p - 1) == '>')   // 连续的 >> 是追加
                {
                    redir = APPEND;
                    *(p - 1) = 0;      // 把两个 '>' 都断开
                    *p = 0;
                }
                else
                {
                    redir = OUTPUT;
                    *p = 0;
                }
                filename = p + 1;
                break;
            }
            p--;
        }
        if (filename)
            while (isspace((unsigned char)*filename)) filename++;  // 去掉文件名前空格
 
        // ---------- 第二步：解析命令与参数 ----------
        char *argv[64];
        int argc = 0;
        char *tok = strtok(line, " ");   // 逐空格切分命令和参数
        while (tok)
        {
            argv[argc++] = tok;
            tok = strtok(NULL, " ");
        }
        argv[argc] = NULL;               // argv 必须以 NULL 结尾
        if (argc == 0)
            continue;
 
        // ---------- 内建命令：必须由 shell 自己执行（因为要影响 shell 自身）----------
        if (strcmp(argv[0], "cd") == 0)
        {
            if (argc == 2 && chdir(argv[1]) == -1) perror("cd");
            continue;
        }
 
        // ---------- 第三步：fork 子进程执行外部命令 ----------
        pid_t pid = fork();
        if (pid == 0)   // 子进程
        {
            // 子进程里做重定向：只会影响子进程，不污染父 shell（重定向要在子进程做！）
            int fd;
            if (redir == INPUT)
            {
                fd = open(filename, O_RDONLY);
                if (fd < 0) { perror("open"); exit(2); }
                dup2(fd, 0);   // 把该文件搬到标准输入
                close(fd);
            }
            else if (redir == OUTPUT)
            {
                fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
                if (fd < 0) { perror("open"); exit(3); }
                dup2(fd, 1);   // 搬到标准输出：之后的 printf 全进文件
                close(fd);
            }
            else if (redir == APPEND)
            {
                fd = open(filename, O_CREAT | O_WRONLY | O_APPEND, 0666);
                if (fd < 0) { perror("open"); exit(4); }
                dup2(fd, 1);
                close(fd);
            }
            // 换掉当前进程镜像，执行真正的命令
            execvp(argv[0], argv);
            perror("execvp");   // 只有 exec 失败才走到这
            exit(1);
        }
 
        // 父进程 shell 等待子进程运行结束
        waitpid(pid, NULL, 0);
    }
    return 0;
}

$ gcc -o myshell myshell.c && ./myshell
[my-shell]# ls -l                    # 普通命令，正常执行
[my-shell]# echo hello > out.txt     # 输出重定向：当前没有内建 echo，交给系统 /usr/bin/echo
[my-shell]# cat out.txt              # 读回来：hello
[my-shell]# ls >> out.txt            # 追加重定向
[my-shell]# wc < out.txt             # 输入重定向
[my-shell]# cd /tmp && pwd           # 内建 cd（注意 cd 必须 shell 自己执行）
[my-shell]# exit   (Ctrl+D)

// cloexec.c —— 设置/清除"close-on-exec"标志
#include <fcntl.h>
#include <unistd.h>
 
int main(void)
{
    // 方式一（推荐，原子）：在 open 时顺手带上 O_CLOEXEC
    // Linux 2.6.23 起支持。exec 后这个 fd 自动关闭
    int fd = open("log", O_CREAT | O_RDWR | O_CLOEXEC, 0644);
 
    // 方式二：打开后用 fcntl 单独设置 FD_CLOEXEC
    // F_GETFD 取当前"文件描述符标志"，F_SETFD 设置它
    int flags = fcntl(fd, F_GETFD);   // 读当前的 fd 标志
    flags |= FD_CLOEXEC;              // 加上 close-on-exec 这一位
    fcntl(fd, F_SETFD, flags);        // 写回去
 
    // 清除同理：flags &= ~FD_CLOEXEC; 再 fcntl(F_SETFD, flags) 即可
 
    close(fd);
    return 0;
}

// 这是 3.10 内核 include/linux/fs.h 中 struct file 的一部分（字段示意）
struct file {
    ...
    struct inode       *f_inode;   // 指向 inode（文件的"元数据档案"，含大小、权限等）
    const struct file_operations *f_op;  // 关键！指向这个类型文件的操作函数表
    ...
    atomic_long_t       f_count;   // 引用计数：有几个 fd 在引用这个打开对象
    unsigned int        f_flags;   // 打开时用的标志（O_RDONLY/O_APPEND...）
    fmode_t             f_mode;    // 访问模式（只读/只写/读写），定义在 <fcntl.h>
    loff_t              f_pos;     // 当前读写位置（偏移）
    ...
};

struct file_operations {
    struct module *owner;                            // 所属内核模块
    loff_t (*llseek) (struct file*, loff_t, int);    // 移动读写位置
    ssize_t (*read)  (struct file*, char __user*, size_t, loff_t*);  // 读
    ssize_t (*write) (struct file*, const char __user*, size_t, loff_t*); // 写
    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);  // 读目录（仅文件系统用）
    ...
    int (*open)  (struct inode*, struct file*);      // 打开
    int (*release)(struct inode*, struct file*);     // 关闭时的回收
    int (*fsync) (struct file*, struct dentry*, int); // 强制刷盘
    ...
};

// buff_unflush.c —— 演示重定向到文件后，printf 的内容"消失"了
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
 
int main()
{
    close(1);                        // 腾出 fd 1
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    printf("hello world: %d\n", fd); // 想让它写进 log.txt
    close(fd);
    return 0;
}

$ gcc buff_unflush.c -o myfile && ./myfile
$ cat log.txt
$   # 空的！内容不见了！

// buff_flush.c —— fflush 强制把缓冲写出去
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
 
int main()
{
    close(1);
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    printf("hello world: %d\n", fd);
    fflush(stdout);       // 强制把 stdout 缓冲里的内容刷进 log.txt
    close(fd);
    return 0;
}

// buff_nobuf.c —— stderr 无缓冲，perror 立即写出
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
 
int main()
{
    close(2);                        // 腾出 fd 2
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    perror("hello world");           // perror 写 stderr -> 现在 stderr 指向 log.txt
    close(fd);
    return 0;
}

$ ./nobuf
$ cat log.txt
hello world: Success

// 这是 glibc 中 struct _IO_FILE 的关键字段（示意，做了精简）
struct _IO_FILE {
    int _flags;                 // 流的状态与标志（含缓冲模式）
    // 下面是这块"积攒数据"的缓冲区状态
    char *_IO_read_ptr;         // 输入缓冲的当前读指针
    char *_IO_read_end;         // 输入缓冲的读区末尾
    char *_IO_read_base;        // 输入缓冲的起始
    char *_IO_write_base;       // 输出缓冲起始
    char *_IO_write_ptr;        // 输出缓冲当前写指针
    char *_IO_write_end;        // 输出缓冲末尾
    char *_IO_buf_base;         // 整体缓冲起始
    char *_IO_buf_end;          // 整体缓冲末尾
    ...
    int   _fileno;              // ★ 封装的底层文件描述符！
};
typedef struct _IO_FILE FILE;   // 对外就叫 FILE

// fork_buf.c —— printf/fwrite（有缓冲）+ write（无缓冲）+ fork
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
 
int main()
{
    const char *msg0 = "hello printf\n";
    const char *msg1 = "hello fwrite\n";
    const char *msg2 = "hello write\n";
 
    printf("%s", msg0);                    // C 库，有用户缓冲
    fwrite(msg1, strlen(msg1), 1, stdout); // C 库，有用户缓冲
    write(1, msg2, strlen(msg2));          // 系统调用，无缓冲，立刻进内核
 
    fork();                                // 关键：fork 一个子进程
    return 0;                              // 父、子各自正常退出
}

$ gcc fork_buf.c -o hello && ./hello
hello printf
hello fwrite
hello write

$ ./hello > file
$ cat file
hello write
hello printf
hello fwrite
hello printf
hello fwrite

// my_stdio.h —— 自定义一个迷你"文件流"
#pragma once
#include <stddef.h>
 
#define SIZE 1024
 
// 刷新方式：不刷/行刷/全刷
#define FLUSH_NONE 0
#define FLUSH_LINE 1
#define FLUSH_FULL 2
 
// 迷你 FILE：底层 fd + 一个输出缓冲 + 相关状态
struct IO_FILE
{
    int flag;             // 刷新方式
    int fileno;           // 文件描述符（fd）
    char outbuffer[SIZE]; // 用户级输出缓冲
    int cap;              // 缓冲区容量
    int size;             // 当前已缓存了多少字节
};
typedef struct IO_FILE mFILE;
 
// 自定义的四个"函数"，对应 fopen/fwrite/fflush/fclose
mFILE *mfopen(const char *filename, const char *mode);
int    mfwrite(const void *ptr, int num, mFILE *stream);
void   mfflush(mFILE *stream);
void   mfclose(mFILE *stream);

// my_stdio.c —— 迷你文件流的实现
#include "my_stdio.h"
 
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
// mfopen：把 fopen 的 mode 翻译成 open 的标志，再开出一块带缓冲的 mFILE
mFILE *mfopen(const char *filename, const char *mode)
{
    // 先按 mode 决定用 open 的哪种标志组合
    int fd = -1;
    if (strcmp(mode, "r") == 0)
    {
        fd = open(filename, O_RDONLY);
    }
    else if (strcmp(mode, "w") == 0)
    {
        fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
    }
    else if (strcmp(mode, "a") == 0)
    {
        fd = open(filename, O_CREAT | O_WRONLY | O_APPEND, 0666);
    }
    if (fd < 0) return NULL;    // open 失败
 
    // 分配 mFILE，把 fd 塞进去，初始化缓冲
    mFILE *mf = (mFILE *)malloc(sizeof(mFILE));
    if (mf == NULL)
    {
        close(fd);              // 申请失败就回滚刚才的 open
        return NULL;
    }
    mf->fileno = fd;            // ★ FILE 里封装了 fd！
    mf->flag   = FLUSH_LINE;    // 先以"行缓冲"演示
    mf->size   = 0;
    mf->cap    = SIZE;
    return mf;
}
 
// mfflush：把用户缓冲里的数据一次性交给内核
void mfflush(mFILE *stream)
{
    if (stream && stream->size > 0)
    {
        // 把缓存的 outbuffer 交给系统调用 write
        write(stream->fileno, stream->outbuffer, stream->size);
        // 等待内核数据真正落盘（这里示意性地加 fsync，真实 getc 一般不用）
        fsync(stream->fileno);
        stream->size = 0;       // 清空"已缓存"计数
    }
}
 
// mfwrite：先复制进缓冲，再根据刷新策略决定何时真正 write
int mfwrite(const void *ptr, int num, mFILE *stream)
{
    // 1. 把数据先拷进用户缓冲
    memcpy(stream->outbuffer + stream->size, ptr, num);
    stream->size += num;
 
    // 2. 判断是否要触发"行刷新"：行缓冲模式且末尾恰好是 \n
    if (stream->flag == FLUSH_LINE &&
        stream->size > 0 &&
        stream->outbuffer[stream->size - 1] == '\n')
    {
        mfflush(stream);
    }
    // 若缓冲满了（全缓冲模式）也可在此触发刷新，这里留给读者扩展
 
    return num;
}
 
// mfclose：先冲刷残余缓冲，再关掉底层 fd
void mfclose(mFILE *stream)
{
    if (stream->size > 0)
    {
        mfflush(stream);     // 关闭前把缓冲清干净
    }
    close(stream->fileno);
    free(stream);
}

// main.c —— 用我们的迷你 libc 往日志里写并模拟"进度条"
#include "my_stdio.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
 
int main()
{
    mFILE *fp = mfopen("./log.txt", "a");   // 追加打开
    if (fp == NULL)
    {
        return 1;
    }
 
    int cnt = 10;
    while (cnt)
    {
        char buffer[64];
        // 拼一行内容
        snprintf(buffer, sizeof(buffer), "hello message, number is : %d", cnt);
        mfwrite(buffer, strlen(buffer), fp);  // 写进"用户缓冲"
 
        printf("write %d\n", cnt);            // 普通 printf 打行号
        mfflush(fp);                          // 立刻把这条数据刷进 log.txt
 
        cnt--;
        sleep(1);                             // 模拟"进度条"：每 1 秒写一条
    }
 
    mfclose(fp);
    return 0;
}

$ gcc my_stdio.c main.c -o mydemo && ./mydemo
write 10
write 9
write 8
...（每秒一条）