Multiple processes mapping the same file region initially share the same physical pages (from the page cache). When any process writes to its copy, the kernel performs copy-on-write: a new private page is allocated for that process. The underlying file is never modified.

Primary use cases:

• ELF loading: The OS maps a program’s text segment (code) and initialized data segment from the executable file using MAP_PRIVATE. The text segment uses PROT_READ|PROT_EXEC, data uses PROT_READ|PROT_WRITE. When a process writes to its data, COW kicks in.
• Shared libraries: Multiple processes share the same physical pages for a library’s code via private mappings — zero extra RAM used for code even with 100 processes using the same .so.
• Read-only configuration files: Load a large config file into memory once, parse it without modifying the file.

/*
 * private_file_map.c
 * Read a binary file using MAP_PRIVATE
 * Compile: gcc -o private_file_map private_file_map.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>

int main(int argc, char *argv[])
{
    int          fd;
    struct stat  sb;
    char        *data;
    size_t       length;

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

    /* Open read-only is sufficient for MAP_PRIVATE */
    fd = open(argv[1], O_RDONLY);
    if (fd == -1) { perror("open"); exit(EXIT_FAILURE); }

    if (fstat(fd, &sb) == -1) { perror("fstat"); exit(EXIT_FAILURE); }
    length = sb.st_size;

    /* MAP_PRIVATE: changes never reach the file */
    data = mmap(NULL, length, PROT_READ | PROT_WRITE,
                MAP_PRIVATE, fd, 0);
    if (data == MAP_FAILED) { perror("mmap"); exit(EXIT_FAILURE); }
    close(fd);  /* Safe to close fd now */

    /* We can "modify" the mapping without touching the file */
    data[0] = 'X';   /* COW: kernel creates private page for us */

    printf("First byte (in our private copy): %c\n", data[0]);
    printf("Original file is unchanged on disk.\n");

    munmap(data, length);
    return 0;
}

All processes that create a MAP_SHARED mapping of the same file region share the same physical pages in RAM. There is no copy-on-write — a write by one process is immediately visible to all others sharing the mapping, and is also reflected back to the underlying file (via the page cache).

Primary use cases:

• Memory-mapped I/O: Use pointer operations instead of read()/write() to access file data. Efficient for random access patterns.
• IPC between unrelated processes: Two processes share data through a file without System V shared memory setup overhead.

Instead of lseek()+read() for random access, use a shared mapping and access bytes directly:

/*
 * mmap_io.c — Memory-mapped I/O vs traditional I/O comparison
 * Compile: gcc -O2 -o mmap_io mmap_io.c
 *
 * Creates a 1MB file then:
 * (a) writes using mmap
 * (b) reads using mmap
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>

#define FILE_SIZE  (1024 * 1024)   /* 1 MB */
#define FILENAME   "/tmp/mmap_test.dat"

/* Create a file of a given size (filled with zeros) */
static void create_file(const char *path, size_t size)
{
    int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) { perror("open"); exit(1); }

    /* Seek to last byte and write one byte to set file size */
    if (lseek(fd, size - 1, SEEK_SET) == -1) { perror("lseek"); exit(1); }
    if (write(fd, "\0", 1) != 1) { perror("write"); exit(1); }
    close(fd);
}

int main(void)
{
    int    fd;
    char  *map;
    size_t i;

    /* Step 1: Create the backing file */
    create_file(FILENAME, FILE_SIZE);

    /* Step 2: Open and map for read+write (shared) */
    fd = open(FILENAME, O_RDWR);
    if (fd == -1) { perror("open"); exit(1); }

    map = mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE,
               MAP_SHARED, fd, 0);
    if (map == MAP_FAILED) { perror("mmap"); exit(1); }
    close(fd);

    /* Step 3: Write using pointer arithmetic — no write() calls */
    for (i = 0; i < FILE_SIZE; i++) {
        map[i] = (char)(i & 0xFF);
    }
    printf("Written %zu bytes via mmap pointer operations\n", FILE_SIZE);

    /* Step 4: Read back — again, no read() calls */
    unsigned long sum = 0;
    for (i = 0; i < FILE_SIZE; i++) {
        sum += (unsigned char)map[i];
    }
    printf("Checksum of mapped data: %lu\n", sum);

    /* Step 5: Explicitly flush dirty pages to disk */
    if (msync(map, FILE_SIZE, MS_SYNC) == -1) {
        perror("msync");
    }
    printf("Data flushed to disk via msync(MS_SYNC)\n");

    munmap(map, FILE_SIZE);

    /* Verify: read the file with traditional I/O */
    FILE *f = fopen(FILENAME, "rb");
    int first_byte = fgetc(f);
    fclose(f);
    printf("First byte in file (should be 0): %d\n", first_byte);

    return 0;
}

With a shared file mapping, the kernel writes dirty pages back to the file lazily (when memory pressure increases or on munmap()). If you need data flushed to disk immediately (e.g., for durability), use msync():

#include <sys/mman.h>

int msync(void *addr, size_t length, int flags);
/* Returns 0 on success, -1 on error */

/* Flush first 4096 bytes synchronously */
if (msync(map, 4096, MS_SYNC) == -1) {
    perror("msync");
}

/* Schedule async flush of entire mapping */
if (msync(map, file_size, MS_ASYNC) == -1) {
    perror("msync async");
}

When you are done with a mapping, release it with munmap(). This removes the mapping from the process’s virtual address space and decrements the file reference count.

#include <sys/mman.h>

int munmap(void *addr, size_t length);
/* Returns 0 on success, -1 on error */

/*
 * Rules for munmap():
 * 1. addr must be the address returned by mmap() (or page-aligned within it)
 * 2. length must match what was passed to mmap() (or a subset)
 * 3. A mapping can be partially unmapped — the rest stays valid
 * 4. After munmap(), accessing the unmapped range causes SIGSEGV
 */

/* Full unmap */
munmap(map, file_size);

/* Partial unmap: unmap just the second half */
size_t half = file_size / 2;
munmap((char *)map + half, half);   /* First half still accessible */

Two unrelated processes (no fork relationship) can communicate through a shared file mapping. Process A writes, Process B reads — both through the same physical pages backed by a file.

/*
 * ipc_writer.c — Write a message via shared file mapping
 * Compile: gcc -o writer ipc_writer.c
 * Run:     ./writer; ./ipc_reader
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>

#define SHM_FILE  "/tmp/ipc_shared.dat"
#define SHM_SIZE  256

int main(void)
{
    int   fd;
    char *map;

    /* Create/truncate backing file */
    fd = open(SHM_FILE, O_RDWR | O_CREAT | O_TRUNC, 0666);
    if (fd == -1) { perror("open"); exit(1); }
    ftruncate(fd, SHM_SIZE);   /* Set file size */

    map = mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE,
               MAP_SHARED, fd, 0);
    if (map == MAP_FAILED) { perror("mmap"); exit(1); }
    close(fd);

    /* Write message into shared region */
    snprintf(map, SHM_SIZE, "Hello from PID %d!", (int)getpid());
    msync(map, SHM_SIZE, MS_SYNC);   /* Ensure it's on disk */

    printf("Writer: wrote '%s'\n", map);
    munmap(map, SHM_SIZE);
    return 0;
}

/*
 * ipc_reader.c — Read message via shared file mapping
 * Compile: gcc -o reader ipc_reader.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>

#define SHM_FILE  "/tmp/ipc_shared.dat"
#define SHM_SIZE  256

int main(void)
{
    int   fd;
    char *map;

    fd = open(SHM_FILE, O_RDONLY);
    if (fd == -1) { perror("open"); exit(1); }

    map = mmap(NULL, SHM_SIZE, PROT_READ, MAP_SHARED, fd, 0);
    if (map == MAP_FAILED) { perror("mmap"); exit(1); }
    close(fd);

    printf("Reader: received '%s'\n", map);

    munmap(map, SHM_SIZE);
    return 0;
}

Note: This example has no synchronization. In production code, use a semaphore or mutex placed inside the shared region to coordinate access.

If the mapping’s length is larger than the actual file size (e.g., you truncated the file after mapping it), accessing the pages beyond the file end causes SIGBUS, not SIGSEGV. This is different from accessing outside the mapped range (which gives SIGSEGV).

/* Example: SIGBUS scenario
 *
 * File is 4000 bytes. We map 4096 (one page).
 * Bytes 0..3999   → backed by file → OK
 * Bytes 4000..4095 → in mapped range but past file end
 *                  → SIGBUS on access
 */
#include <signal.h>
#include <stdio.h>

void sigbus_handler(int sig)
{
    printf("Caught SIGBUS (signal %d) — access beyond file end!\n", sig);
    /* In real code: use siglongjmp to recover, not return */
    _exit(1);
}

/* Install before mmap if you want graceful handling */
signal(SIGBUS, sigbus_handler);