The Linux Memory Manager


  1. Allocators - Describes in detail how dynamic memory allocation works, the trade-offs, the algorithms - essentially the what, why and how of memory allocation.
  2. Physical memory - The buddy allocator, struct page*, struct folio*, the kernel functions that provide memory (e.g. alloc_pages()), nodes, zones (in brief, more detailed in NUMA chapter), watermarks, migrate types, page blocks, GFP flags, migrate types, detailed analysis of physical page allocation and freeing.
  3. Virtual memory - The why, what and how, page tables, page table flags, page table sizes, virtual memory layout, direct mapping, kernel/userland split and a detailed description of vmalloc().
  4. Process memory - mm_struct, Process VMAs, page faults, demand paging, dynamic stack allocation, how memory is copied between userland/kernel, how malloc() actually feeds into the kernel (e.g. sbrk(), mmap()). Copy-on-write, forking, basics of huge pages (covered in more detail in huge pages chapter), rmaps, pagevecs, lru & lruvecs. GUP.
  5. The page cache - A detailed look into the page cache, how it interacts with the Linux virtual file system, read-ahead, read-behind, writeback, what happens under memory pressure and generally a very focused discussion of how the memory subsystem interacts with VFS. Potential overlap with the process memory chapter.
  6. Reclaim and memory pressure - A detailed explanation of how reclaim operations, what direct and indirect reclaim are, how it interacts with demand paging, higher order page starvation, etc.
  7. Slab memory - A discussion of the slab memory allocator with a focus on SLUB, kmalloc(), kfree(), slab caches, shrinkers and how they interact with the rest of the memory management subsystem.
  8. Compaction and migration - How direct and indirect page compaction works, kcompactd and how folios are migrated from one area of memory to another.
  9. Swap memory - A detailed description of how the swap operations in the kernel and how pages are paged out and paged back in again.
  10. NUMA - A detailed dive into Non-Uniform Memory Access (NUMA) sytems, discussing NUMA balancing, how different NUMA architectures are modelled in the kernel and how everything interacts.
  11. cgroups - A dive into memory control groups, how the are implemented and how they interact and can be configured, a chapter that will be of particular interest for those interested in containerisation.
  12. Huge pages - A deep dive into hugetlb, Transparent Huge Pages (THPs), the why what, how and when.
  13. The Out Of Memory (OOM) killer - A deep dive into how it works, how to tune it, the what, why and how.
  14. Practical memory management - How to decode the memory manager - procfs, tuneables, dmesg, tracepoints, eBPF and more. A description of procfs/sysfs/sysrq-m interfaces and how to use and decode them, generally a practical 'how to' for sysadmins/developers. Additionally covering DAMON and eBPF.
  15. Device memory - A deep dive into managing memory for device drivers covering topics such as ioremap() and friends.
  16. Debugging the memory manager - A practical discuss around how to effectively debug the memory management subsystem of the kernel, e.g. the use of CONFIG_DEBUG_PAGEALLOC and friends.
  17. Appendix: Folio flags - A list of all folio flags with detailed descriptions.
Email me when it's released!