sync系统调用及示例

#include <unistd.h>  // 包含 sync 的声明

void sync(void);     // 注意：sync 没有返回值，也不会报告错误

#include <sys/syscall.h> // 对于 syncfs，有时需要 syscall.h
// #include <linux/fs.h> // 或者这个头文件
// 在某些较新的 glibc 版本中，可能直接在 unistd.h 中声明
long syscall(SYS_syncfs, int fd); // 底层调用方式

// 或者，如果 glibc 支持
// int syncfs(int fd); // 更简单的用户空间接口 (较新 glibc)

#define _GNU_SOURCE // 启用 GNU 扩展，可能需要用于 syncfs
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>    // 包含 open, O_* flags
#include <sys/stat.h> // 包含 open modes
#include <string.h>
#include <errno.h>
#include <time.h>     // 包含 clock_gettime
#include <sys/syscall.h> // 包含 SYS_syncfs
#include <linux/fs.h>    // 包含 SYNCFS 等定义 (如果需要)

// 计算时间差（毫秒）
double time_diff_ms(struct timespec start, struct timespec end) {
    return ((end.tv_sec - start.tv_sec) * 1000.0) + ((end.tv_nsec - start.tv_nsec) / 1000000.0);
}

// 封装 syncfs 调用，处理不同 glibc 版本的兼容性
int my_syncfs(int fd) {
    // 尝试直接调用 syncfs (如果 glibc 支持)
    // 如果编译报错，注释掉 #ifdef 部分，只保留 syscall 部分
#ifdef SYS_syncfs // 检查是否定义了系统调用号
    return syscall(SYS_syncfs, fd);
#else
    // 如果你的 glibc 版本较新，可能直接支持 syncfs 函数
    // return syncfs(fd);
    fprintf(stderr, "syncfs system call not available on this system.\n");
    return -1;
#endif
}

int main() {
    const char *file1_name = "/tmp/sync_test_file1.txt"; // /tmp 通常在根文件系统或 tmpfs
    const char *file2_name = "/home/user/sync_test_file2.txt"; // 假设 /home 是另一个分区
    int fd1, fd2;
    struct timespec start, end;
    double elapsed_time;

    printf("--- Demonstrating sync and syncfs ---\n");
    printf("PID: %d\n", getpid());

    // 1. 创建并写入两个测试文件
    printf("\n1. Creating and writing test files...\n");

    // --- 文件 1 ---
    fd1 = open(file1_name, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd1 == -1) {
        perror("open file1");
        // 如果 /home/user 不可写，跳过 file2
        printf("Skipping file2 due to open error.\n");
        fd2 = -1;
    } else {
        printf("Opened %s\n", file1_name);
        if (write(fd1, "Data for file 1 on root/tmp filesystem.\n", 40) != 40) {
            perror("write file1");
        }
        // 注意：不要 close，保持 fd1 打开用于 syncfs
    }

    // --- 文件 2 (可能在不同文件系统) ---
    fd2 = open(file2_name, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd2 == -1) {
        perror("open file2");
        printf("Skipping operations on file2.\n");
    } else {
        printf("Opened %s\n", file2_name);
        if (write(fd2, "Data for file 2 on home filesystem.\n", 37) != 37) {
            perror("write file2");
        }
        // 注意：不要 close，保持 fd2 打开用于 syncfs
    }

    printf("\nData written to files. It's likely in the page cache now.\n");

    // 2. 演示 syncfs: 同步特定文件系统
    printf("\n2. --- Demonstrating syncfs ---\n");
    if (fd1 != -1) {
        printf("Calling syncfs() on the filesystem containing %s...\n", file1_name);
        clock_gettime(CLOCK_MONOTONIC, &start);
        if (my_syncfs(fd1) == -1) {
            perror("syncfs fd1");
            printf("This might be because syncfs is not supported or fd is invalid.\n");
        } else {
            clock_gettime(CLOCK_MONOTONIC, &end);
            elapsed_time = time_diff_ms(start, end);
            printf("syncfs(fd1) completed in %.2f ms.\n", elapsed_time);
            printf("This synced only the filesystem containing %s.\n", file1_name);
        }
    }

    if (fd2 != -1) {
        printf("Calling syncfs() on the filesystem containing %s...\n", file2_name);
        clock_gettime(CLOCK_MONOTONIC, &start);
        if (my_syncfs(fd2) == -1) {
            perror("syncfs fd2");
        } else {
            clock_gettime(CLOCK_MONOTONIC, &end);
            elapsed_time = time_diff_ms(start, end);
            printf("syncfs(fd2) completed in %.2f ms.\n", elapsed_time);
            printf("This synced only the filesystem containing %s.\n", file2_name);
        }
    }

    // 3. 演示 sync: 同步所有文件系统
    printf("\n3. --- Demonstrating sync ---\n");
    printf("Calling sync() to flush ALL filesystems...\n");
    clock_gettime(CLOCK_MONOTONIC, &start);
    sync(); // sync() 没有返回值
    clock_gettime(CLOCK_MONOTONIC, &end);
    elapsed_time = time_diff_ms(start, end);
    printf("sync() completed in %.2f ms.\n", elapsed_time);
    printf("This synced data for ALL mounted filesystems on the system.\n");

    // 4. 关闭文件描述符
    if (fd1 != -1) close(fd1);
    if (fd2 != -1) close(fd2);

    // 5. 清理测试文件 (可选)
    printf("\n4. --- Cleaning up ---\n");
    if (fd1 != -1) {
        if (unlink(file1_name) == 0) {
            printf("Deleted %s\n", file1_name);
        } else {
            perror("unlink file1");
        }
    }
    if (fd2 != -1) {
        if (unlink(file2_name) == 0) {
            printf("Deleted %s\n", file2_name);
        } else {
            perror("unlink file2");
        }
    }

    printf("\n--- Summary ---\n");
    printf("1. sync(): Flushes dirty data for ALL mounted filesystems. No return value.\n");
    printf("2. syncfs(fd): Flushes dirty data for ONLY the filesystem containing the file referred to by 'fd'. Returns 0 on success.\n");
    printf("3. syncfs is more targeted and usually faster than sync.\n");
    printf("4. Use sync() before system shutdown. Use syncfs() or fsync() for specific data safety in applications.\n");

    return 0;
}

# 假设代码保存在 sync_example.c 中
# _GNU_SOURCE 通常由 #define 定义，显式添加也无妨
gcc -D_GNU_SOURCE -o sync_example sync_example.c

# 运行程序 (可能需要权限来写入 /home/user)
# 如果 /home/user 不可写，请修改代码中的 file2_name
./sync_example