What Does the mmap() System Call Do?
Learn what mmap() does — lazy page-fault loading, MAP_SHARED vs MAP_PRIVATE, and real use cases in operating systems.
Expected Interview Answer
mmap() maps a file (or anonymous memory) directly into a process’s virtual address space, so the program can read and write the file’s contents using ordinary pointer/array access instead of explicit read() and write() system calls, with the kernel handling the actual data transfer lazily through page faults.
When a process calls mmap() on a file descriptor, the kernel does not immediately load the file’s data into memory; instead it reserves a range of virtual addresses and sets up page table entries marked as not-present. The first time the program touches a byte in that mapped range, a page fault occurs, and the kernel’s fault handler loads the corresponding page from the file (via the page cache) into physical memory and fixes up the page table entry, after which further accesses to that page are ordinary memory operations with no system call overhead. Mappings can be shared (MAP_SHARED), where writes go back to the underlying file and are visible to other processes mapping the same file, or private (MAP_PRIVATE), where writes trigger copy-on-write and are never written back, which is exactly how the OS loader maps executable code and shared libraries into every process without duplicating read-only pages in RAM. mmap() is commonly used for zero-copy file I/O on large files, inter-process shared memory (via MAP_SHARED with MAP_ANONYMOUS or a shared file), and loading dynamic libraries; the trade-off versus read()/write() is that it avoids extra copies through userspace buffers but exposes the caller to SIGBUS/SIGSEGV if the file shrinks or the mapping is accessed incorrectly.
- Enables zero-copy file access via ordinary pointer dereferences
- Explains lazy loading through page faults instead of eager reads
- Distinguishes MAP_SHARED (writeback, shared) from MAP_PRIVATE (copy-on-write)
- Foundation for understanding how executables and shared libraries are loaded
AI Mentor Explanation
mmap() is like a stadium giving every spectator a numbered seat that maps directly to a specific section of the archived match footage, without physically loading the footage onto every seat’s screen up front. Only when a spectator actually presses play on their seat does the projection system fetch that specific section from the archive (a page fault). A private replay seat lets a spectator scribble annotations that nobody else sees and never get saved back to the archive, while a shared seat’s edits go straight back into the master archive for everyone.
Step-by-Step Explanation
Step 1
mmap() call reserves virtual addresses
The kernel picks a virtual address range and creates page table entries marked not-present; no file data is read yet.
Step 2
First access triggers a page fault
Touching a byte in the mapped range faults; the handler loads the needed page from the file (via the page cache) into a physical frame.
Step 3
Page table entry fixed up
The faulting page table entry is updated to point at the now-resident physical frame, and execution resumes transparently.
Step 4
Writes handled per mapping type
MAP_SHARED writes go back to the file and are visible to other mappers; MAP_PRIVATE writes trigger copy-on-write and are never written back.
What Interviewer Expects
- Understanding that mmap() maps a file lazily, loading pages on demand via page faults
- Clear distinction between MAP_SHARED and MAP_PRIVATE semantics
- Awareness of common use cases: zero-copy I/O, shared memory, loading executables/libraries
- Knowledge of failure modes: SIGBUS on truncated files, SIGSEGV on invalid access
Common Mistakes
- Thinking mmap() immediately reads the entire file into RAM synchronously
- Confusing MAP_SHARED and MAP_PRIVATE write-back behavior
- Forgetting that a mapped file shrinking underneath the mapping can cause SIGBUS
- Not knowing mmap() is how executables and shared libraries get loaded
Best Answer (HR Friendly)
“mmap() lets a program treat a file almost like a regular block of memory — you can read and write it with normal variable access instead of calling read and write functions every time. Behind the scenes, the operating system only actually loads pieces of the file as they are touched, which makes it efficient for very large files, and it is also the mechanism the OS uses to load programs and shared libraries into memory in the first place.”
Code Example
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
int main(void) {
int fd = open("data.bin", O_RDWR);
struct stat st;
fstat(fd, &st);
char *map = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
if (map == MAP_FAILED) { perror("mmap"); return 1; }
printf("First byte: %d\n", map[0]); /* triggers a page fault on first touch */
map[0] = 42; /* MAP_SHARED: written back to the file */
munmap(map, st.st_size);
close(fd);
return 0;
}Follow-up Questions
- What is the difference between MAP_SHARED and MAP_PRIVATE?
- What happens if you access a memory-mapped region after the underlying file is truncated?
- How does mmap() relate to how the OS loads executables and shared libraries?
- Why is mmap() often faster than read()/write() for large files?
MCQ Practice
1. When does mmap() actually load a file's data into physical memory?
mmap() sets up virtual address mappings eagerly but defers loading actual data until a page fault occurs on first access.
2. With MAP_PRIVATE, what happens when the process writes to the mapped memory?
MAP_PRIVATE mappings use copy-on-write: modifications are visible only to the writing process and are never flushed to the file.
3. What signal can occur if a memory-mapped file is truncated while still mapped and accessed past the new end?
Accessing a mapped region beyond a file that has since been truncated typically raises SIGBUS.
Flash Cards
What does mmap() do? — Maps a file (or anonymous memory) into a process's virtual address space for direct pointer access.
When is file data actually loaded with mmap()? — Lazily, on first access to a page, via a page fault.
MAP_SHARED vs MAP_PRIVATE? — MAP_SHARED writes go back to the file and are visible to others; MAP_PRIVATE uses copy-on-write and never writes back.
Name a real-world use of mmap(). — Loading executables and shared libraries into a process's address space.