第40讲：文件编程与打开模式

用户程序
    |
┌───────────────┐
│  标准IO (C库)  │ <-- fopen/fread/fwrite
│  (glibc)       │
└───────┬───────┘
        |
┌───────────────┐
│  系统IO        │ <-- open/read/write
│  (系统调用)     │
└───────┬───────┘
        |
      VFS
        |
   具体文件系统

// 系统IO版本：每次 write() 都是系统调用
write(fd, "H", 1);    // 系统调用 #1
write(fd, "e", 1);    // 系统调用 #2
write(fd, "l", 1);    // 系统调用 #3
write(fd, "l", 1);    // 系统调用 #4
write(fd, "o", 1);    // 系统调用 #5
// 总共 5 次系统调用，每次都有用户态/内核态切换开销

// 标准IO版本：数据先攒在用户态缓冲区
fputc('H', fp);       // 写入用户态缓冲区
fputc('e', fp);       // 写入用户态缓冲区
fputc('l', fp);       // 写入用户态缓冲区
fputc('l', fp);       // 写入用户态缓冲区
fputc('o', fp);       // 写入用户态缓冲区
fflush(fp);           // 一次性触发系统调用，把缓冲区内所有内容写入内核
// 总共 1 次系统调用（fflush 触发）

#include <stdio.h>

char mybuf[1024];
// 将 fp 设置为全缓冲，缓冲区大小为 1024 字节
setvbuf(fp, mybuf, _IOFBF, sizeof(mybuf));

你需要写入的数据是否需要"立即"到达磁盘/设备？
    |
    ├── 是 → 用系统 IO（或标准IO + fflush + fsync）
    |
    └── 否 → 是否需要跨平台兼容？
              |
              ├── 是 → 用标准 IO（ANSI C 可移植）
              |
              └── 否 → 操作的是普通文件还是特殊文件？
                        |
                        ├── 普通文件 → 标准 IO（更高效）
                        |
                        └── 设备/管道/套接字 → 系统 IO（更直接）

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

int fd = open("test.txt", O_RDONLY);
if (fd == -1) {
    // errno 是全局变量，记录最后一次系统调用的错误码
    // strerror() 把错误码转换为可读字符串
    fprintf(stderr, "open() failed: %s\n", strerror(errno));
    return 1;
}

#include <unistd.h>

off_t lseek(int fd, off_t offset, int whence);

// 获取当前文件位置
off_t cur_pos = lseek(fd, 0, SEEK_CUR);

// 获取文件大小（移到末尾，返回值就是大小）
off_t file_size = lseek(fd, 0, SEEK_END);

// 回到文件开头
lseek(fd, 0, SEEK_SET);

#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);

// 健壮的写入：确保所有数据都写入
ssize_t write_all(int fd, const void *buf, size_t count) {
    const char *p = (const char *)buf;
    size_t remaining = count;

    while (remaining > 0) {
        ssize_t n = write(fd, p, remaining);
        if (n == -1) {
            if (errno == EINTR) {
                // 被信号中断，重试
                continue;
            }
            return -1;  // 真正的错误
        }
        p += n;
        remaining -= n;
    }
    return count;
}

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

#include <unistd.h>

int close(int fd);

// 即使 close() 失败也应该记录日志（可能是 NFS 延迟写入失败等原因）
if (close(fd) == -1) {
    perror("close failed");
}

#include <fcntl.h>
#include <unistd.h>

int main() {
    // 1. 打开文件
    int fd = open("test.txt", O_RDWR | O_CREAT, 0644);

    // 2. 定位到文件开头
    lseek(fd, 0, SEEK_SET);

    // 3. 写入数据
    write(fd, "Hello World", 11);

    // 4. 读取文件
    char buf[128];
    lseek(fd, 0, SEEK_SET);  // 回到开头再读
    read(fd, buf, 128);

    // 5. 关闭文件
    close(fd);
    return 0;
}

/*
 * file_demo.c -- 演示系统 IO 五个核心函数的完整用法（含错误处理）
 * 编译：gcc -Wall -o file_demo file_demo.c
 * 运行：./file_demo
 */

#include <stdio.h>      // perror
#include <stdlib.h>     // exit
#include <string.h>     // strlen
#include <errno.h>      // errno
#include <fcntl.h>      // open, O_* 常量
#include <unistd.h>     // read, write, lseek, close

int main(void)
{
    int fd;
    ssize_t n;
    off_t file_size;
    char buf[256];

    /* 步骤1：打开（或创建）文件，读写模式 */
    fd = open("demo.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open failed");
        exit(EXIT_FAILURE);
    }
    printf("[INFO] fd = %d\n", fd);

    /* 步骤2：写入数据 */
    const char *msg = "Hello, Linux System IO!\n";
    n = write(fd, msg, strlen(msg));
    if (n == -1) {
        perror("write failed");
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("[INFO] wrote %zd bytes\n", n);

    /* 步骤3：查看当前文件位置 */
    file_size = lseek(fd, 0, SEEK_CUR);
    if (file_size == -1) {
        perror("lseek (SEEK_CUR) failed");
    } else {
        printf("[INFO] current position: %ld\n", (long)file_size);
    }

    /* 步骤4：回到文件开头，读取刚写入的内容 */
    if (lseek(fd, 0, SEEK_SET) == -1) {
        perror("lseek (SEEK_SET) failed");
        close(fd);
        exit(EXIT_FAILURE);
    }

    n = read(fd, buf, sizeof(buf) - 1);
    if (n == -1) {
        perror("read failed");
        close(fd);
        exit(EXIT_FAILURE);
    }
    buf[n] = '\0';  // 手动补上字符串结束符
    printf("[INFO] read %zd bytes: %s", n, buf);

    /* 步骤5：关闭文件 */
    if (close(fd) == -1) {
        perror("close failed");
        exit(EXIT_FAILURE);
    }
    printf("[INFO] file closed\n");

    return 0;
}

gcc -Wall -o file_demo file_demo.c
./file_demo
# 输出示例：
# [INFO] fd = 3
# [INFO] wrote 24 bytes
# [INFO] current position: 24
# [INFO] read 24 bytes: Hello, Linux System IO!
# [INFO] file closed

/*
 * mycp.c -- 用系统 IO 实现文件复制
 * 编译：gcc -Wall -o mycp mycp.c
 * 用法：./mycp <源文件> <目标文件>
 */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

#define BUFSIZE 4096   // 一次读写 4KB，兼顾效率和内存

int main(int argc, char *argv[])
{
    int fd_src, fd_dst;
    ssize_t nread, nwrite;
    char buf[BUFSIZE];
    off_t total = 0;

    if (argc != 3) {
        fprintf(stderr, "Usage: %s <src> <dst>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    /* 打开源文件（只读） */
    fd_src = open(argv[1], O_RDONLY);
    if (fd_src == -1) {
        fprintf(stderr, "Cannot open %s: %s\n", argv[1], strerror(errno));
        exit(EXIT_FAILURE);
    }

    /* 打开/创建目标文件（只写，截断或创建） */
    fd_dst = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd_dst == -1) {
        fprintf(stderr, "Cannot create %s: %s\n", argv[2], strerror(errno));
        close(fd_src);
        exit(EXIT_FAILURE);
    }

    /* 循环读写，直到源文件读完 */
    while ((nread = read(fd_src, buf, BUFSIZE)) > 0) {
        nwrite = write(fd_dst, buf, nread);
        if (nwrite != nread) {
            fprintf(stderr, "Write error: %s\n", strerror(errno));
            close(fd_src);
            close(fd_dst);
            exit(EXIT_FAILURE);
        }
        total += nwrite;
    }

    if (nread == -1) {
        perror("read error");
    }

    printf("Copied %ld bytes from %s to %s\n", (long)total, argv[1], argv[2]);

    close(fd_src);
    close(fd_dst);
    return 0;
}

┌─────────────────────────────────┐
│       进程 (task_struct)         │
│  ┌───────────────────────────┐  │
│  │ files (指向files_struct)   │  │
│  └──────────┬────────────────┘  │
└─────────────┼───────────────────┘
              |
┌─────────────────────────────────┐
│       files_struct              │
│  ┌───────────────────────────┐  │
│  │ fd_array[]                │  │
│  │                           │  │
│  │ [0] ---> stdin            │  │
│  │ [1] ---> stdout           │  │
│  │ [2] ---> stderr           │  │
│  │ [3] ---> file对象 (你打开的文件)│  │
│  │ [4] ---> ...              │  │
│  └───────────────────────────┘  │
└─────────────────────────────────┘

open("test.txt", O_RDWR)
    |
VFS 找到文件 -> 获取 file_operations 操作接口
    |
进程 files_struct 的 fd_array[]
找到空闲位置（比如下标3）
    |
创建 file 对象，填充到 fd_array[3]
包含：file_operations、权限、模式、读写位置、路径...
    |
返回 3（文件描述符）

# 查看软限制（当前有效值）
ulimit -n
# 通常输出: 1024

# 查看硬限制（最大值，需要 root 才能调）
ulimit -Hn
# 通常输出: 4096 或 1048576

# 临时修改软限制（当前 shell 进程生效）
ulimit -n 2048

# 查看系统范围内所有进程打开的文件总数上限
cat /proc/sys/fs/file-max
# 通常输出: 100000 或更大

# 查看当前系统已打开的文件总数
cat /proc/sys/fs/file-nr
# 输出三个数字：已分配 / 已使用 / 上限

// 简化版 file_operations（内核源码中的真实结构体字段更多）
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 *);
    int     (*open)    (struct inode *, struct file *);
    int     (*release) (struct inode *, struct file *);
    // ... 还有 mmap, ioctl, poll, fsync 等
};

用户空间: read(fd, buf, 100)
    |   系统调用
    v
内核空间: 通过 fd 找到 file 对象
    |
    v
取出 file->f_op->read 函数指针
    |
    v
调用对应的具体实现
    ├── 普通文件 -> ext4_read() 或 xfs_read()
    ├── 设备文件 -> device_read()
    └── socket   -> sock_read()

// 第三个参数 0644 表示：所有者可读写，组用户只读，其他用户只读
int fd = open("newfile.txt", O_WRONLY | O_CREAT, 0644);

# 查看当前 umask
umask
# 通常输出: 0022

# 在 C 程序中获取 umask

#include <sys/stat.h>
mode_t old_umask = umask(0);   // 获取当前 umask 并临时设为 0
// ... 创建文件 ...
umask(old_umask);              // 恢复

// 错误：flags 中有 O_CREAT 但没有提供 mode 参数
int fd = open("file.txt", O_WRONLY | O_CREAT);
// 编译器可能不报错（因为 open 是变参函数），
// 但新文件的权限是栈上的随机值，行为不可预测

int fd = open("file.txt", O_WRONLY | O_CREAT, 0644);

// 追加模式：每次写都在末尾，不会覆盖已有内容
int fd = open("log.txt", O_WRONLY | O_CREAT | O_APPEND, 0644);
write(fd, "line 1\n", 7);
write(fd, "line 2\n", 7);
// log.txt 内容：
// line 1
// line 2

// 方法A：手动 lseek 到末尾再写（非原子，多进程下不安全）
lseek(fd, 0, SEEK_END);   // 步骤1
write(fd, data, len);      // 步骤2
// 风险：步骤1和步骤2之间，另一个进程可能也写了数据，导致覆盖

// 方法B：O_APPEND（原子操作，多进程安全）
// 打开时设置 O_APPEND
// 每次 write() 前，内核自动把 f_pos 设为文件末尾，
// 然后原子地完成"定位+写入"

// 打开文件并清空，然后写入新内容
int fd = open("data.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
write(fd, "fresh data", 10);
// data.txt 现在只有 "fresh data"，旧内容全部丢失

// 只读打开
int fd1 = open("file.txt", O_RDONLY);

// 读写打开，不存在则创建，权限 0644
int fd2 = open("file.txt", O_RDWR | O_CREAT, 0644);

// 读写打开，清空再写
int fd3 = open("file.txt", O_RDWR | O_TRUNC);

// 追加模式写入
int fd4 = open("file.txt", O_WRONLY | O_APPEND | O_CREAT, 0644);

// 原子地检查"文件不存在"并"创建文件"
// 如果文件已存在，open() 返回 -1
int fd = open("myapp.lock", O_WRONLY | O_CREAT | O_EXCL, 0644);
if (fd == -1) {
    if (errno == EEXIST) {
        fprintf(stderr, "Another instance is already running.\n");
        exit(1);
    }
    perror("open");
    exit(1);
}
// 成功获得锁，继续执行...
// 进程退出时，可以 unlink("myapp.lock") 释放锁

时刻 T1: 进程A 调用 stat("lock") -> 文件不存在
时刻 T2: 进程B 调用 stat("lock") -> 文件不存在
时刻 T3: 进程A 调用 open("lock", O_CREAT) -> 创建成功
时刻 T4: 进程B 调用 open("lock", O_CREAT) -> 也创建成功！
结果：两个进程都认为自己获得了锁

int fd = open("secret.txt", O_RDONLY | O_CLOEXEC);

// 不安全：fd 会被 exec 后的程序继承
int fd = open("passwords.txt", O_RDONLY);
execl("/usr/bin/some_program", "some_program", NULL);
// some_program 仍然可以读 passwords.txt！

// 安全：fd 在 exec 时自动关闭
int fd = open("passwords.txt", O_RDONLY | O_CLOEXEC);
execl("/usr/bin/some_program", "some_program", NULL);
// some_program 无法访问 passwords.txt

// 只读，文件必须存在，不存在则报错
int fd = open("/etc/myapp.conf", O_RDONLY);
if (fd == -1) {
    perror("Cannot open config file");
    exit(1);
}
// 读取配置...
close(fd);

// 只写，追加，不存在则创建；多进程安全
int log_fd = open("/var/log/myapp.log",
                   O_WRONLY | O_CREAT | O_APPEND,
                   0644);
// 每次 write 自动追加到末尾
dprintf(log_fd, "[%s] Service started\n", get_timestamp());

// 读写，清空旧内容，不存在则创建
int fd = open("data.bin", O_RDWR | O_CREAT | O_TRUNC, 0644);
// 旧数据被清空，从头写入新数据
write(fd, new_data, data_len);
close(fd);

// 利用 O_EXCL 实现进程互斥
int lock_fd = open("/var/run/myapp.pid",
                   O_WRONLY | O_CREAT | O_EXCL, 0644);
if (lock_fd == -1) {
    fprintf(stderr, "myapp is already running\n");
    exit(1);
}
// 写入 PID
dprintf(lock_fd, "%d\n", getpid());
close(lock_fd);
// ... 程序主逻辑 ...
unlink("/var/run/myapp.pid");  // 退出时释放锁

// 需要保证数据真正落盘
int fd = open("database.db", O_WRONLY | O_CREAT | O_SYNC, 0600);
// 每次 write() 都会等待数据写入磁盘后才返回
write(fd, commit_record, record_len);
// 此时数据已经安全地在磁盘上了
close(fd);

// 临时文件只需要短期存在，不需要持久化
int fd = open("/tmp/myapp_XXXXXX", O_RDWR | O_CREAT | O_EXCL, 0600);
// 临时读写...
close(fd);
unlink("/tmp/myapp_XXXXXX");  // 删除临时文件

// 危险写法：不检查返回值，后续操作可能对 fd=-1 操作
int fd = open("file.txt", O_RDONLY);
read(fd, buf, 100);      // 如果 open 失败，read(-1, ...) 会出错
close(fd);               // close(-1) 也是无效操作

// 正确写法
int fd = open("file.txt", O_RDONLY);
if (fd == -1) {
    perror("open");
    return 1;
}

// 错误
int fd = open("new.txt", O_CREAT | O_WRONLY);  // 缺少 mode！

// 正确
int fd = open("new.txt", O_CREAT | O_WRONLY, 0644);

// 泄漏示例：错误路径上没有 close()
void process_file(const char *path) {
    int fd = open(path, O_RDONLY);
    if (fd == -1) return;

    char *buf = malloc(4096);
    if (buf == NULL) return;   // fd 未关闭！泄漏！
    // ... 处理 ...
    free(buf);
    close(fd);
}

void process_file(const char *path) {
    int fd = open(path, O_RDONLY);
    if (fd == -1) return;

    char *buf = malloc(4096);
    if (buf == NULL) goto cleanup_fd;

    // ... 处理 ...

    free(buf);
cleanup_fd:
    close(fd);
}

// 不可靠写法：假设一次 read 能读到全部数据
char buf[1024];
ssize_t n = read(fd, buf, sizeof(buf));
// n 可能只有 100，但文件还有更多数据没读完

// 可靠写法：循环读取直到读完
size_t total = 0;
while (total < expected_size) {
    ssize_t n = read(fd, buf + total, expected_size - total);
    if (n == 0) break;       // EOF
    if (n == -1) {
        if (errno == EINTR) continue;
        perror("read");
        break;
    }
    total += n;
}

// 管道、socket、终端等不可 seek
int fd = STDIN_FILENO;  // 标准输入（可能是终端或管道）
off_t pos = lseek(fd, 0, SEEK_CUR);  // 失败，errno = ESPIPE

off_t pos = lseek(fd, 0, SEEK_CUR);
if (pos == -1) {
    if (errno == ESPIPE) {
        printf("This fd does not support seeking\n");
    }
}

# 追踪程序的所有系统调用
strace ./mycp source.txt dest.txt

# 只追踪文件相关系统调用（open/read/write/close/lseek）
strace -e trace=open,read,write,close,lseek ./file_demo

# 追踪正在运行的进程（通过 PID）
strace -p 12345

# 统计系统调用次数和耗时
strace -c ./file_demo

open("demo.txt", O_RDWR|O_CREAT|O_TRUNC, 0644) = 3
write(3, "Hello, Linux System IO!\n", 24) = 24
lseek(3, 0, SEEK_CUR)                   = 24
lseek(3, 0, SEEK_SET)                   = 0
read(3, "Hello, Linux System IO!\n", 255) = 24
close(3)                                = 0

/*
 * mycp_stdio.c -- 用标准 IO 实现文件复制（对比系统 IO 版本）
 * 编译：gcc -Wall -o mycp_stdio mycp_stdio.c
 */

#include <stdio.h>
#include <stdlib.h>

#define BUFSIZE 4096

int main(int argc, char *argv[])
{
    FILE *fp_src, *fp_dst;
    char buf[BUFSIZE];
    size_t nread;

    if (argc != 3) {
        fprintf(stderr, "Usage: %s <src> <dst>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    fp_src = fopen(argv[1], "rb");
    if (fp_src == NULL) {
        perror("fopen src");
        exit(EXIT_FAILURE);
    }

    fp_dst = fopen(argv[2], "wb");
    if (fp_dst == NULL) {
        perror("fopen dst");
        fclose(fp_src);
        exit(EXIT_FAILURE);
    }

    while ((nread = fread(buf, 1, BUFSIZE, fp_src)) > 0) {
        fwrite(buf, 1, nread, fp_dst);
    }

    fclose(fp_src);
    fclose(fp_dst);
    return 0;
}