What is Atomicity?

An atomic operation is one that either completes fully or does not happen at all — there is no in-between state visible to any other process or thread. The Linux kernel guarantees that every system call is atomic: no other process can sneak in and run between the individual steps of your system call.

Think of it like a bank transfer: money is either moved from A to B completely, or the transfer never happened. A partial transfer (money leaves A but never reaches B) would be a disaster — and that is exactly what a race condition causes in files.

Race Conditions – A Concrete Problem

A race condition happens when two processes share a resource and the final result depends on whichever one gets CPU time first. It is unpredictable and dangerous.

🩹 Fix: O_CREAT | O_EXCL – Atomic File Creation

Using O_CREAT | O_EXCL together in open() makes the check-and-create a single unbreakable step. If the file exists, open() returns an error (EEXIST) immediately — no gap for another process to sneak in.

/*
 * safe_create.c
 * Demonstrates atomic file creation using O_CREAT | O_EXCL.
 * Only one process/run will succeed in creating "lock.txt".
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

int main(void)
{
    int fd;

    /* O_EXCL guarantees: check + create happen as ONE atomic step */
    fd = open("lock.txt", O_WRONLY | O_CREAT | O_EXCL, 0644);

    if (fd == -1) {
        if (errno == EEXIST)
            printf("File already exists — someone else got here first.\n");
        else
            perror("open");
        exit(EXIT_FAILURE);
    }

    printf("PID %ld: I am the exclusive creator!\n", (long)getpid());
    write(fd, "locked\n", 7);
    close(fd);
    return 0;
}

🩹 Fix: O_APPEND – Atomic Appends to a Shared File

Multiple processes writing to a shared log file face the same race condition. Without O_APPEND, a process must seek to the end and then write — two separate steps that can interleave badly.

O_APPEND makes seek-to-end + write into a single atomic operation. The kernel moves to end-of-file and writes before any other process can interfere.

/*
 * shared_logger.c
 * Multiple processes safely appending to the same log file.
 * Compile: gcc shared_logger.c -o shared_logger
 * Run two instances simultaneously to see safe interleaving.
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(void)
{
    int fd;
    char msg[64];

    /* O_APPEND: every write() atomically goes to end of file */
    fd = open("shared.log", O_WRONLY | O_CREAT | O_APPEND, 0644);
    if (fd == -1) { perror("open"); exit(1); }

    for (int i = 0; i < 5; i++) {
        snprintf(msg, sizeof(msg), "PID %ld: entry %d\n", (long)getpid(), i);
        write(fd, msg, strlen(msg));
        usleep(10000); /* small delay to simulate work */
    }

    close(fd);
    return 0;
}

fcntl() (file control) is a multipurpose system call that performs various control operations on an already open file descriptor. Think of it as a remote control for your open file.

When you call open(), you pass flags like O_RDONLY, O_APPEND, O_NONBLOCK. These are stored by the kernel. You can read them back later using fcntl(F_GETFL) and even modify some of them using fcntl(F_SETFL) — without closing and reopening the file.

Flags You Can Modify After open()

Practical Example: Enable Non-Blocking on a Pipe

A common real-world use: you receive a file descriptor from another source (e.g., a pipe or socket) and need to enable O_NONBLOCK on it. You cannot re-open it — you use fcntl().

/*
 * toggle_flags.c
 * Shows how to read and modify file status flags using fcntl().
 * Use case: enabling O_APPEND on an fd obtained from elsewhere.
 * Compile: gcc toggle_flags.c -o toggle_flags
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

void print_flags(int fd)
{
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1) { perror("fcntl F_GETFL"); return; }

    printf("  O_APPEND   : %s\n", (flags & O_APPEND)   ? "ON" : "OFF");
    printf("  O_NONBLOCK : %s\n", (flags & O_NONBLOCK) ? "ON" : "OFF");

    /* Access mode needs a mask because it occupies 2 bits */
    int mode = flags & O_ACCMODE;
    if (mode == O_RDONLY) printf("  Access mode: READ-ONLY\n");
    else if (mode == O_WRONLY) printf("  Access mode: WRITE-ONLY\n");
    else printf("  Access mode: READ-WRITE\n");
}

int main(void)
{
    int fd = open("demo.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) { perror("open"); exit(1); }

    printf("=== Flags BEFORE modification ===\n");
    print_flags(fd);

    /* Step 1: read current flags */
    int flags = fcntl(fd, F_GETFL);
    /* Step 2: turn ON O_APPEND */
    flags |= O_APPEND;
    /* Step 3: write flags back */
    if (fcntl(fd, F_SETFL, flags) == -1) { perror("fcntl F_SETFL"); exit(1); }

    printf("\n=== Flags AFTER enabling O_APPEND ===\n");
    print_flags(fd);

    close(fd);
    return 0;
}

This is one of the most important concepts for Linux interviews. Most developers think “file descriptor = file”. That is only part of the story. The kernel uses three separate layers between your program and the actual file data.

The Three Layers Explained Simply

Visual: How It All Connects

Key Rules That Follow From This Architecture

Practical Demo: Shared File Offset Between Duplicated fds

/*
 * shared_offset.c
 * When two file descriptors point to the same OFD,
 * reading via one fd advances the offset for the other too.
 * Compile: gcc shared_offset.c -o shared_offset
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main(void)
{
    /* Create a small test file */
    int wfd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    write(wfd, "ABCDEFGHIJ", 10);
    close(wfd);

    /* Open the file — one OFD is created */
    int fd1 = open("test.txt", O_RDONLY);

    /* dup() creates fd2 pointing to the SAME OFD */
    int fd2 = dup(fd1);

    char buf[4] = {0};

    /* Read 3 bytes via fd1 — file offset in OFD moves to 3 */
    read(fd1, buf, 3);
    printf("fd1 read: %s\n", buf);  /* prints: ABC */

    /* Now read via fd2 — it picks up at offset 3 (not 0!) */
    read(fd2, buf, 3);
    printf("fd2 read: %s\n", buf);  /* prints: DEF */

    /* Compare: open file AGAIN — this creates a NEW OFD */
    int fd3 = open("test.txt", O_RDONLY);
    read(fd3, buf, 3);
    printf("fd3 read: %s\n", buf);  /* prints: ABC — independent offset */

    close(fd1); close(fd2); close(fd3);
    return 0;
}