When you call mmap() with the MAP_PRIVATE flag and pass a file descriptor, the kernel sets up a mapping between a region of your process’s virtual address space and a region of the file. The mapped region is initialized with the file’s content.

The key behavior of MAP_PRIVATE is Copy-on-Write (COW). As long as the process only reads the memory, it shares the same physical page with the file’s page cache. The moment the process tries to write to that page, the kernel silently creates a private copy of that page for the process. After that, the process is writing to its own private copy — the original file and any other process mapping the same file are unaffected.

#include <sys/mman.h>

void *mmap(void *addr,      /* Hint for start address (usually NULL) */
           size_t length,   /* Number of bytes to map                */
           int prot,        /* Memory protection flags               */
           int flags,       /* MAP_PRIVATE | MAP_SHARED | etc.       */
           int fd,          /* File descriptor (open()ed file)       */
           off_t offset);   /* Offset into file (must be page-aligned)*/

/* Returns: start address of mapped region on success, MAP_FAILED on error */

For a private file mapping, the important parameters are:

The two most important and common uses of private file mappings happen automatically — you never call mmap() yourself. The program loader and dynamic linker do it for you whenever you run any executable.

You can directly see these private file mappings by reading /proc/PID/maps. The kernel creates this file automatically for every running process.

/* How to view your own process's memory mappings */
#include <stdio.h>
#include <unistd.h>

int main(void)
{
    char cmd[64];
    /* Print PID so user knows which /proc entry to check */
    printf("My PID: %d\n", getpid());
    printf("--- /proc/%d/maps ---\n", getpid());

    /* Build the command to cat this process's maps file */
    snprintf(cmd, sizeof(cmd), "cat /proc/%d/maps", getpid());
    system(cmd);  /* for illustration only */
    return 0;
}

Sample output from /proc/PID/maps for a typical process:

/* Format: start-end   perms  offset  dev  inode   pathname
   perms: r=read, w=write, x=execute, p=private, s=shared  */

55a3b2000000-55a3b2001000 r--p 00000000 08:01 123456  /usr/bin/cat
55a3b2001000-55a3b2002000 r-xp 00001000 08:01 123456  /usr/bin/cat  <-- text (MAP_PRIVATE)
55a3b2002000-55a3b2003000 r--p 00002000 08:01 123456  /usr/bin/cat  <-- rodata
55a3b2003000-55a3b2004000 r--p 00002000 08:01 123456  /usr/bin/cat  <-- data (MAP_PRIVATE)
7f8a12000000-7f8a12200000 r--p 00000000 08:01 999001  /lib/x86_64/libc.so.6
7f8a12200000-7f8a12380000 r-xp 00200000 08:01 999001  /lib/x86_64/libc.so.6
...
7ffd45678000-7ffd45699000 rw-p 00000000 00:00 0       [stack]

/* Notice 'p' in the perms column — that means MAP_PRIVATE */

A less common but valid use of MAP_PRIVATE is simplifying file input. You map a file privately, read from it like memory, and optionally modify the in-memory content without touching the file.

/* private_mmap_read.c — Read a file using MAP_PRIVATE mmap() */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>

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

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

    /* Step 1: Open the file read-only */
    fd = open(argv[1], O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    /* Step 2: Get file size using fstat() */
    if (fstat(fd, &sb) == -1) {
        perror("fstat");
        exit(EXIT_FAILURE);
    }

    printf("File size: %ld bytes\n", (long)sb.st_size);

    /* Step 3: Create a PRIVATE mapping — changes won't touch the file */
    addr = mmap(NULL,           /* kernel chooses address */
                sb.st_size,     /* map the entire file */
                PROT_READ,      /* read-only access */
                MAP_PRIVATE,    /* private: changes not written back */
                fd,
                0);             /* offset 0 = start from beginning */

    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    /* Step 4: File descriptor can be closed immediately after mmap() */
    /* The mapping keeps a reference to the underlying file internally */
    close(fd);

    /* Step 5: Access the file content like a normal memory buffer */
    printf("First 80 characters of file:\n%.80s\n", addr);

    /* Count newlines — just access memory, no read() calls needed */
    long newlines = 0;
    for (size_t i = 0; i < (size_t)sb.st_size; i++) {
        if (addr[i] == '\n')
            newlines++;
    }
    printf("Number of lines: %ld\n", newlines);

    /* Step 6: Unmap when done */
    if (munmap(addr, sb.st_size) == -1) {
        perror("munmap");
        exit(EXIT_FAILURE);
    }

    return 0;
}

/* Compile and run:
   gcc -o private_mmap_read private_mmap_read.c
   echo "Hello World" > test.txt
   ./private_mmap_read test.txt

   Expected output:
   File size: 12 bytes
   First 80 characters of file:
   Hello World
   Number of lines: 1
*/

This example proves that writing to a MAP_PRIVATE mapping does not change the original file.

/* cow_demo.c — Proves MAP_PRIVATE doesn't modify the underlying file */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>

int main(void)
{
    const char *filename = "/tmp/cow_test.txt";
    const char *original = "Hello, World!\n";
    char       *addr;
    int         fd;
    struct stat sb;

    /* Create a test file */
    fd = open(filename, O_CREAT | O_RDWR | O_TRUNC, 0644);
    if (fd == -1) { perror("open"); exit(1); }
    write(fd, original, strlen(original));
    close(fd);

    /* Open for mapping */
    fd = open(filename, O_RDWR);
    if (fd == -1) { perror("open"); exit(1); }
    fstat(fd, &sb);

    /* MAP_PRIVATE + PROT_WRITE — we can write, but changes stay private */
    addr = mmap(NULL, sb.st_size,
                PROT_READ | PROT_WRITE,
                MAP_PRIVATE,   /* <-- KEY: private, not shared */
                fd, 0);
    if (addr == MAP_FAILED) { perror("mmap"); exit(1); }
    close(fd);

    /* Print before modification */
    printf("Before write: in-memory = [%.*s]\n",
           (int)sb.st_size, addr);

    /* Modify the in-memory mapping */
    memcpy(addr, "MODIFIED!!!!!\n", 14);

    /* Print after — in-memory changed */
    printf("After  write: in-memory = [%.*s]\n",
           (int)sb.st_size, addr);

    munmap(addr, sb.st_size);

    /* Now read the actual file to verify it was NOT changed */
    fd = open(filename, O_RDONLY);
    char buf[64] = {0};
    read(fd, buf, sizeof(buf) - 1);
    close(fd);
    printf("File on disk: [%s]\n", buf);
    /* Output will still show "Hello, World!" — file unchanged! */

    return 0;
}

/* Expected output:
   Before write: in-memory = [Hello, World!]
   After  write: in-memory = [MODIFIED!!!!!]
   File on disk: [Hello, World!]      <-- file unchanged: COW worked!
*/

#include <sys/mman.h>

/* Remove a mapping — addr must be page-aligned */
int munmap(void *addr, size_t length);

/* Change protection on a mapped region */
int mprotect(void *addr, size_t length, int prot);
/* prot can be: PROT_NONE, PROT_READ, PROT_WRITE, PROT_EXEC */

/* Example: Make a read-only MAP_PRIVATE mapping temporarily writable */
/* (This is exactly what a debugger does to set breakpoints)         */
mprotect(addr, page_size, PROT_READ | PROT_WRITE | PROT_EXEC);
/* ... modify the code / set breakpoint ... */
mprotect(addr, page_size, PROT_READ | PROT_EXEC); /* restore */

Key points about munmap():

• You must pass the same addr and length that was used in mmap() (or any sub-region).
• After munmap(), accessing the region causes a segmentation fault.
• Mappings are automatically unmapped when a process exits.
• For MAP_PRIVATE, unmapping simply discards any COW copies.