第43讲：lseek 与 sync 函数

#include <unistd.h>

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

// 编译时启用大文件支持
// gcc -D_FILE_OFFSET_BITS=64 -o prog prog.c

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

// 从当前位置前移 10 字节
lseek(fd, 10, SEEK_CUR);

// 定位到文件末尾前 5 字节
lseek(fd, -5, SEEK_END);

// 错误判断
if (lseek(fd, 0, SEEK_SET) > 0) {  /* 错！偏移 0 时无法进入此分支 */ }

// 正确判断
if (lseek(fd, 0, SEEK_SET) != -1) {  /* 正确 */ }
if (lseek(fd, 0, SEEK_SET) >= 0)    {  /* 正确 */ }

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

int main() {
    int fd = open("test.txt", O_RDONLY);

    // lseek(fd, 0, SEEK_END) 返回文件末尾相对于开头的偏移量
    // 即文件大小（字节数）
    off_t size = lseek(fd, 0, SEEK_END);

    if (size != -1) {
        printf("文件大小: %ld 字节\n", (long)size);
    } else {
        perror("lseek");
    }

    close(fd);
    return 0;
}

// 先保存当前位置，再定位到末尾获取大小，最后恢复位置
off_t current = lseek(fd, 0, SEEK_CUR);  // 保存当前位置
off_t size    = lseek(fd, 0, SEEK_END);  // 定位到末尾获取大小
lseek(fd, current, SEEK_SET);            // 恢复到原来位置

printf("文件大小: %ld 字节\n", (long)size);

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

int main() {
    int pipefd[2];

    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }

    // 尝试对管道写端执行 lseek
    off_t ret = lseek(pipefd[1], 0, SEEK_SET);
    if (ret == -1) {
        printf("lseek on pipe failed: %s\n", strerror(errno));
        // 输出: lseek on pipe failed: Illegal seek
        // errno == ESPIPE
    }

    close(pipefd[0]);
    close(pipefd[1]);
    return 0;
}

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

int main() {
    int fd;

    // 创建文件 test.txt（读写|创建，权限 0666）
    fd = open("test.txt", O_RDWR | O_CREAT, 0666);

    // ① 写入 "123"（3字节）
    write(fd, "123", 3);

    // ② 从当前位置偏移 100 字节
    lseek(fd, 100, SEEK_CUR);

    // ③ 再写入 "ABC"（3字节）
    write(fd, "ABC", 3);

    close(fd);
    return 0;
}

$ make
$ ./test_lseek

# 查看文件大小
$ ls -l test.txt
-rw-r--r-- 1 root root 106 Jul 22 12:00 test.txt

文件内容图示：
[1][2][3][ ][ ][ ]...[ ][A][B][C]
 0  1  2  3 ...      102 103 104 105
         ↑ 100个空字节（NUL字符 0x00）↑
         （文件空洞，hole）

# 以十六进制查看文件内容
$ od -A x -t x1z -v test.txt
000000 31 32 33 00 00 00 00 00 00 00 00 00 00 00 00 00  >123.............<
000010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  >................<
...
000060 00 00 00 00 00 00 00 00 41 42 43                 >........ABC<
00006a

逻辑视图（应用程序看到的样子）：
┌────┬─────────────────────────────┬────┐
│123 │  100 字节的空洞（全 0x00）    │ABC │
└────┴─────────────────────────────┴────┘
                  共 106 字节

物理存储（磁盘上实际存放）：
┌────┐                           ┌────┐
│123 │    [没有分配任何磁盘块]      │ABC │
└────┘                           └────┘
       3 字节物理占用                   3 字节物理占用
                   共 6 字节物理空间（可能经过块对齐后会多一些）

$ ls -l test.txt
-rw-r--r-- 1 root root 106 Jul 22 12:00 test.txt  # 逻辑大小 106

$ du -h test.txt
4.0K    test.txt                                    # 物理占用约 4K（一个文件系统块）

$ ls -ls test.txt
4 -rw-r--r-- 1 root root 106 Jul 22 12:00 test.txt  # 第一列=4个块（通常每块512字节）

# 使用 dd 命令创建稀疏文件
$ dd if=/dev/zero of=sparse.bin bs=1 count=1 seek=100M
1+0 records in
1+0 records out
1 byte copied

$ ls -lh sparse.bin
-rw-r--r-- 1 root root 101M Jul 22 12:00 sparse.bin   # 逻辑大小 ~101MB

$ du -h sparse.bin
4.0K    sparse.bin                                     # 物理占用仅 4KB

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

int main() {
    int fd = open("sparse.dat", O_RDWR | O_CREAT | O_TRUNC, 0666);

    // 在偏移 1GB 处写入 1 字节
    lseek(fd, 1024 * 1024 * 1024, SEEK_SET);  // 跳转到 1GB 位置
    write(fd, "X", 1);                          // 写入 1 字节

    // 获取文件大小
    off_t size = lseek(fd, 0, SEEK_END);
    printf("逻辑大小: %.2f GB\n", (double)size / (1024 * 1024 * 1024));

    close(fd);
    return 0;
}

# 比较逻辑大小和物理占用
$ stat test.txt
  File: `test.txt`
  Size: 106             Blocks: 8          IO Block: 4096   regular file
# Size=逻辑大小(Bytes), Blocks=512字节块的数量
# 如果 Size > Blocks * 512，说明存在空洞

# 用 find 查找稀疏文件
$ find . -type f -size +0 -printf `%S\t%p\n` | awk `$1 < 1 {print}`
# %S 是稀疏度（物理占用/逻辑大小），值小于1表示有空洞

用户空间                          内核空间                      磁盘
┌──────────┐     write()    ┌─────────────┐    后台回写    ┌────────┐
│   Buffer  │ ───────────→  │  Page Cache  │ ───────────→  │  磁盘   │
│ (应用程序) │              │  (页缓存)     │              │ (物理)  │
└──────────┘               └─────────────┘              └────────┘
                   read()        ↑
                ←───────────────┘

页缓存中的页有两种状态：

  clean page:  缓存的数据与磁盘一致 ← 可以安全回收
  dirty page:  缓存的数据比磁盘新   ← 必须先写回磁盘才能回收

$ sysctl -a | grep dirty
vm.dirty_background_ratio = 10
vm.dirty_ratio = 20
vm.dirty_expire_centisecs = 3000
vm.dirty_writeback_centisecs = 500
vm.dirty_background_bytes = 0
vm.dirty_bytes = 0

# 或者从 /proc 查看
$ cat /proc/sys/vm/dirty_background_ratio
10

应用程序 write() ──→ 标记 page cache 页为 dirty ──→ write() 返回
                                                         │
         ┌───────────────────────────────────────────────┘
         │  (异步，由内核触发)
         ▼
┌─────────────────┐
│  flush-* 线程   │  每隔 dirty_writeback_centisecs 唤醒
│  (每块设备一个)  │  检查脏页数量和年龄
└────────┬────────┘
         │ 满足回写条件
         ▼
    将脏页写入磁盘 → 标记为 clean

$ ps aux | grep flush
root      123  0.0  0.0      0     0 ?        S    Jul22   0:00 [flush-8:0]
# flush-8:0 表示主设备号 8、次设备号 0 的块设备（通常是 /dev/sda）

#include <unistd.h>

void sync(void);

write(fd, buf, len);   // 写入数据（可能还在 cache 中）
sync();                 // 强制将 cache 写入磁盘

int main() {
    int fd = open("data.txt", O_RDWR | O_CREAT, 0666);

    write(fd, "important data", 14);

    // 确保数据立即写回磁盘
    sync();

    close(fd);
    return 0;
}

#include <unistd.h>
void sync(void);

#define _GNU_SOURCE         /* 需要定义以使用 syncfs */
#include <unistd.h>
int syncfs(int fd);

#include <unistd.h>
int fsync(int fd);

#include <unistd.h>
int fdatasync(int fd);

sync()  >  syncfs()  >  fsync()  >  fdatasync()

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

int main() {
    int fd = open("test.db", O_RDWR | O_CREAT, 0666);

    write(fd, "database record", 15);

    // 场景1：对安全性要求极高 → 使用 fsync
    fsync(fd);     // 数据和元数据都落盘

    // 场景2：只关心数据不关心时间戳 → 使用 fdatasync
    // fdatasync(fd);  // 只保证数据落盘，更快

    // 场景3：粗暴简单 → 使用 sync
    // sync();  // 所有文件都刷盘，开销大

    close(fd);
    return 0;
}

// 以同步方式打开文件
int fd = open("data.txt", O_RDWR | O_CREAT | O_SYNC, 0666);

// 每次 write() 都会等待数据写入磁盘后才返回
write(fd, buf, 1024);  // 阻塞直到数据落盘
write(fd, buf, 1024);  // 每写一次就刷一次盘

// 方式A：O_SYNC —— 每次写都同步（性能最差）
int fd_a = open("data.txt", O_WRONLY | O_CREAT | O_SYNC, 0666);
for (int i = 0; i < 1000; i++) {
    write(fd_a, &i, sizeof(i));  // 每次 write 都触发磁盘 I/O，共1000次
}
close(fd_a);

// 方式B：普通模式 + 最后 sync —— 累积后再同步（性能好）
int fd_b = open("data.txt", O_WRONLY | O_CREAT, 0666);
for (int i = 0; i < 1000; i++) {
    write(fd_b, &i, sizeof(i));  // 数据先写入 page cache
}
fsync(fd_b);  // 只在最后同步一次
close(fd_b);

int fd = open("data.txt", O_RDWR | O_CREAT | O_DSYNC, 0666);
// 每次 write 保证数据落盘，但不保证 atime/mtime 等元数据落盘

// 模拟数据库的 write-ahead logging（WAL）
int log_fd = open("wal.log", O_RDWR | O_CREAT, 0666);
int db_fd  = open("data.db", O_RDWR | O_CREAT, 0666);

// 1. 先写日志
write(log_fd, log_entry, log_len);
fdatasync(log_fd);  // 确保日志先落盘

// 2. 再写数据
write(db_fd, data_entry, data_len);
fdatasync(db_fd);   // 确保数据落盘

// 3. 最后标记日志已应用（截断或写 checkpoint）
write(log_fd, checkpoint, cp_len);
fsync(log_fd);

close(log_fd);
close(db_fd);

// 原子写入配置文件（通过临时文件 + rename）
int tmp_fd = open("config.tmp", O_WRONLY | O_CREAT | O_TRUNC, 0666);

write(tmp_fd, new_config, config_len);
fsync(tmp_fd);   // 先确保临时文件数据落盘
close(tmp_fd);

rename("config.tmp", "config.conf");  // 原子替换
// rename 是原子操作，不会出现部分写入的文件

// rename 后还需要同步目录，确保目录元数据落盘
int dir_fd = open(".", O_RDONLY);
fsync(dir_fd);   // 同步目录的元数据
close(dir_fd);

// 方案A：最高安全性（数据库常用）
write(fd, buf, len);
fsync(fd);          // 每次写都同步，性能最差

// 方案B：批量提交（推荐）
write(fd, buf1, len1);
write(fd, buf2, len2);
write(fd, buf3, len3);
fsync(fd);          // 多条记录写完后一次同步

// 方案C：定时同步（日志场景）
write(fd, buf, len);
// 不立即 sync，依赖内核脏页回写机制（默认 30s 内落盘）

// 方案D：纯性能（临时数据）
write(fd, buf, len);
// 不调用任何同步函数

write(fd, "data", 4);
close(fd);  // 此时数据并未保证落盘！
// 如果此时断电，数据可能丢失

FILE *fp = fopen("test.txt", "w");
fprintf(fp, "hello");
fclose(fp);  // fflush → write → close，没有 fsync！

需要保证数据不丢失？
  ├── 是 → 数据量很大？
  │        ├── 是 → 用 fdatasync()，每次提交后调用
  │        └── 否 → 用 fsync()，写入后立即调用
  └── 否 → 是否可以接受丢失最近几秒的数据？
           ├── 可以 → 依赖内核自动回写（默认 ~30s），不做额外同步
           └── 不行 → 用 fdatasync()，定时（如每 5s）调用一次

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

int main() {
    // 1. 写入数据并 close（不 fsync）
    int fd1 = open("file1.txt", O_RDWR | O_CREAT | O_TRUNC, 0666);
    write(fd1, "data without fsync", 18);
    close(fd1);  // 此时数据可能还在 page cache 中
    printf("file1 written and closed (no fsync)\n");

    // 2. 写入数据，fsync 后再 close
    int fd2 = open("file2.txt", O_RDWR | O_CREAT | O_TRUNC, 0666);
    write(fd2, "data with fsync", 15);
    fsync(fd2);   // 强制落盘
    close(fd2);
    printf("file2 written, fsynced, and closed\n");

    // 3. 用 O_SYNC 打开（每次 write 自动同步）
    int fd3 = open("file3.txt", O_RDWR | O_CREAT | O_TRUNC | O_SYNC, 0666);
    write(fd3, "data with O_SYNC", 16);
    close(fd3);
    printf("file3 written with O_SYNC\n");

    // 观察：在系统崩溃/断电前执行 sync() 验证数据是否都存在
    // sync();

    return 0;
}

# 写入数据并查看 page cache 状态
$ echo "test data" > testfile

# 查看文件在 page cache 中的状态
$ cat /proc/meminfo | grep -i dirty
Dirty:               256 kB      # 脏页大小

# 手动触发 sync
$ sync

# 再次查看
$ cat /proc/meminfo | grep -i dirty
Dirty:                 0 kB      # 脏页被清空