Linux Kernel Engineering & Systems Programming

Most kernel bugs do not crash the machine. They wait.

Consider a single line of ordinary-looking code: kmalloc(129, GFP_KERNEL). The allocator does not give you 129 bytes. It serves the request from the next power-of-two cache, so you receive 256 - nearly twice what you asked for. Allocate a thousand such objects and you have silently consumed 256 KB where your arithmetic promised 129 KB. Nothing fails. Nothing warns. The system simply has less memory than the design assumed, and the shortfall surfaces months later as an allocation failure in an unrelated subsystem.

That is the character of kernel engineering. The rules are precise, the consequences are delayed, and the source code does not tell you which one you have broken.

If that kind of detail is what you have been missing, this book was written for you.

Linux Kernel Engineering & Systems Programming is a working text for engineers who can already write C and use Linux, and who now want to understand the machine beneath the API. It does not survey commands. It does not paraphrase documentation. It walks you through the kernel's actual interfaces and asks you to write code against them. It assumes fluency in C and comfort with the command line, and it assumes nothing about kernel internals.

Inside, you will build real loadable modules and trace them with ftrace and kprobes. You will write character and block drivers, register interrupt handlers, and learn why a spinlock acquired without disabling interrupts will deadlock the CPU against itself. You will work through page tables, the buddy and slab allocators, DMA mapping and cache coherency, and the reference counting rules that keep kernel objects alive. You will meet KASAN, lockdep, kmemleak, and kdump, and learn when each is the right instrument. You will finish with the patch, the mailing list, and the review process that turns working code into an accepted contribution.

The payoff is concrete. You will read kernel source without translation, diagnose a crash from a stack trace and a memory dump, and defend your design decisions in review. Every example compiles against current mainline and runs in a disposable virtual machine.

This is not a book you read once. Every subchapter closes with targeted exercises, and the failure modes that catch most engineers are flagged explicitly as common pitfalls - so you can recognize them before your own kernel does, and before a reviewer has to tell you.

Stop guessing what the kernel is doing. Start reading it.