I wrote this book to give systems programmers a precise, working model of memory and processes inside a real kernel built in C on x86-64. Instead of glossing over details, I treat page tables, allocators, VMAs, faults, and user crossings as rigorously as any other data structure or algorithm. My approach is simple: define the invariants, present clean APIs, and show how each piece composes under load, across cores, and in the presence of failures.
I start with the layout of the address space and the physical page inventory, then build up a buddy allocator and slab style object caches that deliver predictable latency and low fragmentation. I treat page tables as a carefully edited tree with well defined map, unmap, and protect operations, including large page promotion and demotion. From there I construct the page fault path that powers demand paging and copy on write, and I show how ELF programs are mapped, how PIE and ASLR fit, and how dynamic linking and thread local storage are set up cleanly.
Because performance and safety live in the details, I work through TLB behavior, PCIDs, and shootdowns, then show how to keep the kernel fast during frequent address space edits. I connect memory to I/O with mmap and a coherent page cache, and I explain reclamation under pressure with eviction policies and swap. Finally, I walk the user boundary with copy to user and copy from user, SMEP and SMAP, W^X, and pinned buffers, then lay out efficient syscall entry and exit, context switching with XSAVE, and the full process lifecycle with fork, exec, exit, and signal delivery.
What you will learn with clarity and depth:
- How to design a robust virtual address space for user and kernel, including higher half mappings and per CPU regions
- How to track and allocate physical memory with zones, NUMA awareness, and a buddy allocator that cooperates with large pages
- How to implement a fast kernel heap with object caches, constructors, and per CPU magazines
- How to edit page tables safely, including caching flags, NX, user and supervisor bits, and transparent large pages
- How to handle page faults for demand zero and copy on write, and how to build a reliable ELF loader with PIE and ASLR
- How to unify file I/O and memory through mmap and a page cache, and how to reclaim under pressure with swap
- How to minimize stalls with PCIDs and batched TLB shootdowns
- How to cross the user boundary safely, implement syscall trampolines, and switch contexts without surprises
I wrote it for readers who want engineering grade explanations that connect design choices to measurable behavior. If you enjoy reasoning from invariants, care about correctness under concurrency, and want code that survives real workloads, this book is for you.
