Memory Mapped Files

Chapter 1: open() — Getting the File Descriptor

Before you can map a file to memory, you need a file descriptor. That means calling open() the usual way:

c
#include <fcntl.h>

int fd;
fd = open("mapdemofile", O_RDWR);

The mode you pass to open() matters — it must match what you'll tell mmap() later. If you open the file read-only (O_RDONLY), you can only map it with PROT_READ. If you want to write through the mapping, open with O_RDWR.

Chapter 2: mmap() — The Star of the Show

Here it is — the system call that turns a file into a pointer:

c
#include <sys/mman.h>

void *mmap(void *addr, size_t len, int prot,
           int flags, int fildes, off_t off);

Six parameters. Don't panic. Let's walk through each one in plain English.

c
int fd, pagesize;
char *data;

fd = open("foo", O_RDONLY);
pagesize = getpagesize();
data = mmap(NULL, pagesize, PROT_READ, MAP_SHARED, fd, pagesize);

This maps one page of the file foo, starting at the second page. The returned pointer data now points directly at that section of the file. data[0] is the first byte of the second page.

Chapter 3: Key Parameters in Detail

Let's zoom in on the three parameters that trip people up: prot, flags, and off.

prot — Protection

This controls what you can do with the mapped memory. Bitwise-OR the values you need:

If you set PROT_READ and then try to write (data[0] = 'B'), you'll get a segmentation fault. The hardware MMU enforces this.

flags — Shared vs Private

off — Page Alignment

The offset must be a multiple of the system's virtual memory page size. You can get this value with getpagesize(). Typical values:

If len is not a multiple of the page size, the OS rounds up. The extra bytes beyond the file's actual content are zero-filled, and any changes to them are not written back to the file.

Chapter 4: munmap() — Unmapping the File

When you're done with the mapping, call munmap() to release it:

c
int munmap(void *addr, size_t len);

c
/* Map the file */
data = mmap(NULL, file_size, PROT_READ, MAP_SHARED, fd, 0);

/* ... use data[0], data[1], etc. ... */

/* Unmap when done */
munmap(data, file_size);

A few important details:

• munmap() returns -1 on error and sets errno
• If your program exits, the mapping is automatically unmapped
• Closing the file descriptor does not unmap the region — the mapping persists until munmap() or process exit
• For MAP_SHARED, changes are flushed to disk. You can force a flush with msync()

Chapter 5: Concurrency, Again?!

Just like shared memory segments, memory-mapped files have no built-in synchronization. If two processes map the same file with MAP_SHARED and both write to overlapping regions simultaneously, you get a data race.

The good news: since mmap is backed by a real file, you can use fcntl() file locking directly — which is arguably more natural than System V semaphores:

c
struct flock fl;
fl.l_type = F_WRLCK;    /* write lock */
fl.l_whence = SEEK_SET;
fl.l_start = 0;
fl.l_len = 0;          /* lock entire file */

fcntl(fd, F_SETLKW, &fl);  /* acquire lock (blocking) */

/* write to mapped memory safely */
data[0] = 'X';

fl.l_type = F_UNLCK;
fcntl(fd, F_SETLK, &fl);   /* release lock */

Chapter 6: mmapdemo.c — The Full Program

Beej's demo program maps its own source file to memory, then prints the byte at whatever offset you specify on the command line. It uses stat() to get the file size so it knows how much to map.

c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <errno.h>

int main(int argc, char *argv[]) {
    int fd, offset;
    char *data;
    struct stat sbuf;

    if (argc != 2) {
        fprintf(stderr, "usage: mmapdemo offset\n");
        exit(1);
    }

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

    if (stat("mmapdemo.c", &sbuf) == -1) {
        perror("stat");
        exit(1);
    }

    offset = atoi(argv[1]);
    if (offset < 0 || offset > sbuf.st_size - 1) {
        fprintf(stderr, "offset must be 0-%ld\n",
                sbuf.st_size - 1);
        exit(1);
    }

    data = mmap(NULL, sbuf.st_size, PROT_READ,
               MAP_SHARED, fd, 0);
    if (data == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }

    printf("byte at offset %d is '%c'\n",
           offset, data[offset]);

    munmap(data, sbuf.st_size);
    close(fd);
    return 0;
}

Chapter 7: Memory Mapping Simulator

Watch a file being mapped into a process's virtual address space. Click offsets to read bytes, or write to see changes appear in both the file and the mapping.

Chapter 8: Beyond Memory Mapped Files

Memory-mapped files sit at the intersection of shared memory and file I/O. They give you pointer-based access (like shared memory) with file-backed persistence (like regular I/O). On systems that don't support System V shared memory, mmap is often the only zero-copy option.

"Memory mapped files can be very useful, especially on systems that don't support shared memory segments. In fact, the two are very similar in most respects." — Beej