Each process thinks it has a large, contiguous address space all to itself. In reality the kernel uses a page table to map the process’s virtual addresses to physical RAM frames. Only the pages a process is actively using need to be in RAM — unused pages can be swapped to disk.

Virtual memory is efficient because most programs exhibit locality of reference — they tend to use a small “working set” of pages repeatedly, rather than jumping all over memory.

On x86-32, each page is 4096 bytes. If a process accesses an address with no page table entry at all (not in RAM and not in swap), the kernel sends it a SIGSEGV signal — the dreaded segmentation fault.

You can check a process’s page size programmatically with:

long page_size = sysconf(_SC_PAGESIZE);   /* typically 4096 bytes */

#include <stdio.h>
#include <unistd.h>

int main(void)
{
    long page_sz = sysconf(_SC_PAGESIZE);
    printf("System page size : %ld bytes\n", page_sz);
    printf("                 : %ld KB\n", page_sz / 1024);

    /* Also readable from /proc/meminfo */
    return 0;
}

/* Output (typical x86-64):
   System page size : 4096 bytes
                   : 4 KB  */

When a process dereferences an address with no page table entry, the kernel sends SIGSEGV. This example catches it to explain what happened.

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>

void segfault_handler(int sig)
{
    printf("\nCaught SIGSEGV (signal %d)!\n", sig);
    printf("We accessed an address with no page table entry.\n");
    printf("Kernel refused access — this is virtual memory protection.\n");
    exit(1);
}

int main(void)
{
    /* Register handler so program doesn't just crash silently */
    signal(SIGSEGV, segfault_handler);

    int *bad_ptr = (int *)0xDEADBEEF;  /* Invalid virtual address */
    printf("About to access invalid address %p ...\n", (void*)bad_ptr);
    *bad_ptr = 42;   /* This triggers a page fault → no entry → SIGSEGV */

    return 0;   /* Never reached */
}

/* Output:
   About to access invalid address 0xdeadbeef ...
   Caught SIGSEGV (signal 11)!
   We accessed an address with no page table entry.
   Kernel refused access — this is virtual memory protection. */

/proc/self/maps shows every virtual memory region the current process has, including permissions and what backs each region.

#include <stdio.h>

int main(void)
{
    FILE *maps = fopen("/proc/self/maps", "r");
    if (!maps) { perror("fopen"); return 1; }

    char line[256];
    printf("%-30s %-6s %s\n", "Address Range", "Perms", "Mapped region");
    printf("%s\n", "---------------------------------------------------------------");

    int count = 0;
    while (fgets(line, sizeof(line), maps) && count++ < 10) {
        printf("%s", line);
    }
    fclose(maps);

    printf("...(truncated — run: cat /proc/self/maps for full output)\n");
    return 0;
}

/* Sample output (x86-64):
   55a3e8400000-55a3e8401000 r--p  /home/user/a.out   (text: read-only)
   55a3e8401000-55a3e8402000 r-xp  /home/user/a.out   (text: execute)
   55a3e8402000-55a3e8403000 r--p  /home/user/a.out   (rodata)
   55a3e8603000-55a3e8604000 rw-p  /home/user/a.out   (data/BSS)
   55a3e9a00000-55a3e9a21000 rw-p  [heap]
   7fff1a200000-7fff1a221000 rw-p  [stack]
   Permissions: r=read, w=write, x=execute, p=private */