- Allocators - Describes in detail how dynamic memory
allocation works, the trade-offs, the algorithms - essentially the
what, why and how of memory allocation.
- 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.
- 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().
- Process memory - An overview of how userland memory is
structured - mm_struct, Process VMAs, Copy-on-Write and more.
- 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.
- Page faults - A detailed examination of how page faults are
handled and propagated within the kernel.
- 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
- 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.
- 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
- 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.
- 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.
- Compaction and migration - How direct and indirect page
compaction works, kcompactd and how folios are migrated from one area
of memory to another.
- Swap memory - A detailed description of how the swap
operations in the kernel and how pages are paged out and paged back
- Huge pages - A deep dive into hugetlb, Transparent Huge
Pages (THPs), the why what, how and when.
- The Out Of Memory (OOM) killer - A deep dive into how it
works, how to tune it, the what, why and how.
- 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.