1. Two Types of Synchronized I/O

2. fsync() — Flush Data + All Metadata

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

/* Safely write a critical record to disk */
int write_critical_record(const char *filename, const char *data, size_t len) {
    int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0644);
    if (fd == -1) { perror("open"); return -1; }

    /* Step 1: Write data to kernel buffer cache */
    ssize_t n = write(fd, data, len);
    if (n == -1) { perror("write"); close(fd); return -1; }
    if ((size_t)n != len) {
        fprintf(stderr, "Partial write: only %zd of %zu bytes\n", n, len);
        close(fd); return -1;
    }

    /* Step 2: Force kernel buffer → physical disk
       fsync() blocks until the disk controller acknowledges the write.
       This is the guarantee that data survives a crash. */
    if (fsync(fd) == -1) {
        perror("fsync");
        close(fd);
        return -1;
    }

    close(fd);
    printf("Record written and synced to disk\n");
    return 0;
}

int main(void) {
    const char record[] = "TXN:001 AMOUNT:5000 STATUS:COMMITTED\n";
    return write_critical_record("/var/log/transactions.log", record, strlen(record));
}

/* Compile: gcc -o write_critical write_critical.c
   Note: fsync() on a typical spinning disk may take 5-15ms per call.
   On SSD it's faster, but still much slower than a plain write(). */

3. fdatasync() — Flush Data Only (Faster)

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

/* Database-style log writer — uses fdatasync for performance */
typedef struct {
    int fd;
    long record_count;
} LogDB;

int logdb_open(LogDB *db, const char *path) {
    db->fd = open(path, O_WRONLY | O_CREAT | O_APPEND, 0644);
    db->record_count = 0;
    return db->fd;
}

int logdb_write(LogDB *db, const char *key, const char *value) {
    char entry[256];
    int len = snprintf(entry, sizeof(entry),
                       "%ld|%s|%s\n", (long)time(NULL), key, value);

    /* Write to kernel buffer */
    if (write(db->fd, entry, len) != len) {
        perror("write"); return -1;
    }
    db->record_count++;

    /* Use fdatasync() instead of fsync():
       - Does NOT sync the file's mtime (we don't care about that)
       - Does sync the file data and file size (we DO care about those)
       - Saves ~1 disk seek compared to fsync() */
    if (fdatasync(db->fd) == -1) {
        perror("fdatasync"); return -1;
    }
    return 0;
}

int main(void) {
    LogDB db;
    if (logdb_open(&db, "/tmp/mydb.log") == -1) return 1;

    logdb_write(&db, "sensor_temp",   "36.7");
    logdb_write(&db, "sensor_press",  "1013");
    logdb_write(&db, "ble_rssi",      "-72");

    close(db.fd);
    printf("Wrote %ld records\n", db.record_count);
    return 0;
}

4. sync() — Flush Everything (System-Wide)

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

int main(void) {
    /* Write something to disk first */
    int fd = open("/tmp/test.txt", O_WRONLY|O_CREAT|O_TRUNC, 0644);
    write(fd, "test data\n", 10);
    close(fd);

    /* sync() flushes ALL dirty buffers in the system to disk.
       This is a heavy operation — do not call in a tight loop. */
    printf("Calling sync()...\n");
    sync();
    printf("sync() completed — all dirty pages flushed\n");

    /* In a shell: the 'sync' command does the same thing */
    /* $ sync */
    return 0;
}

/* When to use sync() vs fsync():
   sync()      — system administrator use, shutdown scripts, unmounting
   fsync(fd)   — application use, when you care about a specific file
   fdatasync() — application use, faster alternative when metadata timing is unimportant */

5. O_SYNC Flag — Make Every Write Synchronous

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

int main(void) {
    /* Open with O_SYNC — every write() will block until disk confirms */
    int fd = open("/tmp/sync_test.txt",
                  O_WRONLY | O_CREAT | O_TRUNC | O_SYNC,
                  0644);
    if (fd == -1) { perror("open"); return 1; }

    const char *line = "Critical record\n";

    /* This write() will NOT return until data is on disk.
       This may take 5-15ms on a spinning disk.
       No need to call fsync() — O_SYNC handles it automatically. */
    write(fd, line, strlen(line));
    printf("write() returned — data is on disk\n");

    close(fd);
    return 0;
}

/* Combine O_SYNC with O_APPEND for an atomic append-only log:
   int fd = open("audit.log", O_WRONLY | O_CREAT | O_APPEND | O_SYNC, 0644);
   Each write() is atomic (won't interleave with other processes) AND synchronous */

Performance Impact: With vs Without O_SYNC

Writing 1 MB (1,000,000 bytes) to a new file on ext2 (real benchmark data from the book):

6. O_DSYNC and O_RSYNC

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

int main(void) {
    /* O_DSYNC: faster than O_SYNC because it skips non-essential metadata.
       Best for database-style writes where you don't care about timestamps. */
    int fd = open("/tmp/dsync_test.txt",
                  O_WRONLY | O_CREAT | O_TRUNC | O_DSYNC,
                  0644);
    if (fd == -1) { perror("open O_DSYNC"); return 1; }

    const char *data = "Record: fdatasync-level guarantee\n";
    write(fd, data, strlen(data));
    /* write() returns only after: data + file size are on disk
       (mtime is NOT guaranteed — that's the O_DSYNC vs O_SYNC difference) */

    close(fd);
    printf("O_DSYNC write complete\n");
    return 0;
}

/* Performance recommendation:
   Need durability?   Use O_DSYNC (faster) for most cases.
   Need full metadata? Use O_SYNC or manually call fsync().
   Better approach:   Use large buffers + occasional fsync() — more control. */

7. Best Practices for Durable Writes

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

/* PATTERN 1: Write many records, fsync() at logical boundaries (best performance) */
void pattern_batch_fsync(int fd, const char **records, int count) {
    for (int i = 0; i < count; i++) {
        write(fd, records[i], strlen(records[i]));
    }
    /* Single fsync() for all the records above — much more efficient
       than one fsync() per record */
    fsync(fd);
    printf("Batch of %d records committed to disk\n", count);
}

/* PATTERN 2: Atomic update — write new data to temp file, then rename */
/* This ensures the file is never in a corrupt state */
int atomic_file_update(const char *target, const char *data, size_t len) {
    char tmp[256];
    snprintf(tmp, sizeof(tmp), "%s.tmp.%d", target, (int)getpid());

    int fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) { perror("open tmp"); return -1; }

    /* Write new content to temp file */
    if (write(fd, data, len) != (ssize_t)len) {
        perror("write"); close(fd); unlink(tmp); return -1;
    }

    /* Sync the new data to disk */
    if (fsync(fd) == -1) {
        perror("fsync"); close(fd); unlink(tmp); return -1;
    }
    close(fd);

    /* Atomic rename: either old file exists or new file exists, never corrupt */
    if (rename(tmp, target) == -1) {
        perror("rename"); unlink(tmp); return -1;
    }

    /* Also sync the directory to make rename persistent */
    int dir_fd = open(".", O_RDONLY);
    if (dir_fd != -1) { fsync(dir_fd); close(dir_fd); }

    return 0;
}

int main(void) {
    /* Pattern 2 demo */
    const char *new_config = "[server]\nport=8080\nhost=0.0.0.0\n";
    atomic_file_update("/etc/myapp/config.ini", new_config, strlen(new_config));
    return 0;
}