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), 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 - An overview of how userland memory is structured - mm_struct, Process VMAs, Copy-on-Write and more.
  5. Memory mapping - A description of how memory mapping is performed within the kernel - mmap, brk (used by malloc()) and how mappings (via VMAs) are split/merged.
  6. Page faults - A detailed examination of how page faults are handled and propagated within the kernel.
  7. The reverse mapping - A detailed look at how the kernel maps raw physical pages of userland memory back to the abstract VMA representation, in addition to how this is used to free memory.
  8. Manipulating userland memory - A detailed examination of both how the kernel accesses userland memory and functions which userland can use to manipulate it like madvise(), mprotect(), mlock(), mremap() and so on.
  9. 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.
  10. 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.
  11. 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.
  12. Compaction and migration - How direct and indirect page compaction works, kcompactd and how folios are migrated from one area of memory to another.
  13. Swap memory - A detailed description of how the swap operations in the kernel and how pages are paged out and paged back in again.
  14. Huge pages - A deep dive into hugetlb, Transparent Huge Pages (THPs), the why what, how and when.
  15. The Out Of Memory (OOM) killer - A deep dive into how it works, how to tune it, the what, why and how.
  16. Practical memory management - A brief overview of practical memory management techniques - procfs interfaces, tuneables, decoding out of memory reports and more. Generally a practical 'how to' for sysadmins/developers.
Email me when it's released!