Virtual Memory, Page Tables, and Process Address Space Architecture

01Virtual Memory Architecture and the Hardware MMU

In modern operating systems (Linux, macOS, Windows), user-space applications never interact with physical RAM addresses directly. Instead, every process executes within an isolated, continuous Virtual Address Space managed cooperatively by the operating system kernel and the CPU's hardware Memory Management Unit (MMU).

On 64-bit x86_64 architectures, processes typically utilize a 48-bit canonical virtual address space (providing 256 Terabytes of addressable memory), split evenly between user space (lower half) and kernel space (upper half). Physical memory is divided into fixed-size chunks called Page Frames (typically 4KB in size, though Huge Pages can be 2MB or 1GB).

The MMU uses a multi-level page table structure (PML4, PDPT, PD, PT) to map virtual page numbers (VPN) to physical frame numbers (PFN). To prevent memory lookup latency from doubling on every memory access, the CPU caches recent page translations in the Translation Lookaside Buffer (TLB).

+-----------------------------------------+ 0x7FFFFFFFFFFF (Top of User Space)| Environment Variables & CLI Arguments   |+-----------------------------------------+| User Stack (Grows DOWNWARD)             || [Stack frames, local variables]         ||                   |                     ||                   v                     ||                                         ||                   ^                     ||                   |                     || Memory Mapping Segment (mmap)           || [Shared libraries (.so), dynamic files] |+-----------------------------------------+| Heap (Grows UPWARD via brk/sbrk)        || [Dynamic allocations via malloc/new]    |+-----------------------------------------+| .bss (Uninitialized global/static data) | (Zero-filled by OS)+-----------------------------------------+| .data (Initialized global/static data)  | (Read/Write)+-----------------------------------------+| .rodata (Read-only constants & strings) | (Read-Only)+-----------------------------------------+| .text (Executable machine instructions) | (Read & Execute, NO Write)+-----------------------------------------+ 0x0000000000400000 (Base address)

02Dissecting the Standard Process Memory Segments

Every compiled binary loaded into memory is structured into specialized segments, each configured with specific hardware page permissions (Read, Write, Execute):

.text Segment: Contains compiled CPU machine instructions. Marked Read + Execute (RX). Any attempt to write to this memory immediately triggers a CPU exception (SIGSEGV).

.rodata Segment: Stores read-only data, such as string literals ("Hello World") and const global variables. Marked Read-Only (R).

.data Segment: Stores global and static variables that have non-zero initial values (e.g., int g_counter = 42;). Marked Read + Write (RW).

.bss Segment: Stores global and static variables that are uninitialized or initialized to zero (e.g., int g_buffer[1024];). It consumes zero disk space in the executable binary; the OS allocates zeroed pages on demand upon process launch.

03Page Faults and Demand Paging

When a program requests a dynamic allocation of 1GB via malloc() or operator new, the operating system kernel does not immediately allocate 1GB of physical RAM. Instead, it reserves virtual address space and marks the corresponding page table entries as not present (Demand Paging).

When the CPU executes an instruction that reads or writes to an unbacked virtual page, the MMU fails to translate the address and raises a hardware interrupt: a Page Fault. The OS kernel's page fault handler intercepts the interrupt, allocates a physical 4KB RAM frame, updates the page table entry, and resumes CPU execution transparently.

A Minor Page Fault occurs when the required page is already in memory (e.g., shared library cache). A Major Page Fault occurs when the data must be read from slow physical disk storage (e.g., memory-mapped files or swapping).

04Segmentation Faults: The Hardware Boundary Violation

A Segmentation Fault (SIGSEGV) is not an arbitrary C++ runtime crash; it is an operating system signal delivered to the process when an instruction attempts an illegal memory access detected by the hardware MMU.

Common causes include: 1. Dereferencing a NULL pointer (accessing address 0x0, which is intentionally unmapped to trap invalid pointers). 2. Writing to read-only memory (e.g., attempting to overwrite a string literal in .rodata). 3. Stack overflow: exhausting the stack segment and colliding with the memory guard page. 4. Accessing unallocated virtual addresses beyond the process heap limit.