Linux Kernel Internals
Inside the world's most important codebase.
The Kernel Source Tree Layout
The Linux kernel source tree is a 30-million-line city — this module is your map, compass, and street-level tour guide.
Kernel Coding Style & Conventions
Master the unwritten rules that are actually written down: how the Linux kernel community formats, names, and structures code so patches get merged instead of rejected.
Kernel Data Structures
Master the kernel's intrusive, allocation-free data structure toolkit — from the elegant container_of macro to per-CPU variables — and unlock the ability to read and write any kernel subsystem's object management code.
Kernel Memory: Buddy, Slab, kmalloc/vmalloc
The kernel's memory allocators are a masterpiece of layered engineering — from raw pages to object caches — and understanding them is the foundation of all kernel programming.
Process Management: task_struct, fork, exec
Dissect the task_struct — the kernel's complete dossier on every running thing — and trace how fork, exec, and exit create, transform, and destroy processes at the source-code level.
The Linux Scheduler: CFS, EEVDF & Scheduling Classes
The Linux scheduler is a beautiful piece of engineering that decides, thousands of times per second, which of the thousands of tasks on your machine gets to run — and for exactly how long.
System Call Implementation in the Kernel
Trace a system call from the userspace `syscall` instruction all the way through entry assembly, the dispatch table, SYSCALL_DEFINE macros, argument validation, and back — then add your own.
Interrupt Handling: Top/Bottom Halves, softirqs, workqueues
Master the kernel's interrupt handling split — from hardware signal to deferred bottom half — and write fast, correct, context-aware driver code.
Kernel Synchronization: Spinlocks, RCU, Atomics, Barriers
Kernel synchronization is the art of keeping shared data sane when dozens of CPUs and interrupt handlers all reach for it at once — get it wrong and the kernel silently corrupts itself.
The Virtual File System (VFS) Layer
VFS is Linux's C-based object system for file I/O: four core objects, four vtable structs, and one elegant dispatch layer that lets ext4, NFS, and /proc all answer the same open() call.
The Block Layer & I/O Scheduling
Trace a read() syscall from VFS all the way to hardware, mastering bio structures, blk-mq request queues, and the schedulers that decide what hits the disk next.
The Page Cache & Memory Reclaim
The page cache is Linux's beating heart: it makes your disk feel like RAM, and understanding how it fills, ages, and yields memory under pressure is the key to mastering kernel I/O and memory management.
Networking Stack Internals
Every packet you send travels a precisely engineered path through kernel memory, interrupt handlers, and protocol state machines — understanding this path is understanding how the internet actually works.
Time, Timers & the Kernel
The kernel's relationship with time — from coarse jiffy ticks to nanosecond-precision hrtimers — is what makes scheduling, networking, audio, and real-time systems possible.
Kernel Modules (LKM) Lifecycle
Kernel modules are plug-in extensions for the Linux kernel — this module teaches you their complete lifecycle, from writing and loading to symbol sharing and signed verification.
Kernel Debugging: Oops, Panic & Crash Analysis
Master the full forensic loop: from a raw kernel oops scrolling past on a console to the exact line of C that caused it, using addr2line, kdump, crash, and the kernel's own debugging infrastructure.