A Complete Roadmap to Master Linux Kernel Development from Scratch

Step 1: Knowledge Prerequisites

Before diving into the Linux kernel, a solid foundation in the following areas is essential:

Programming fundamentals : Proficiency in C and familiarity with kernel data structures such as doubly‑linked lists, bitmaps, hash tables, and red‑black trees.

Assembly language and privileged mode : Ability to write assembly for at least one ISA (x86, MIPS, ARM, or RISC‑V) and understand the distinction between user and kernel modes, especially the protected‑mode mechanisms on x86.

Computer organization : Basic digital logic and computer architecture; optional deeper study of texts like Computer Architecture: A Quantitative Approach .

Operating‑system principles : Core OS theory. Two widely‑recommended textbooks are Operating Systems: Design and Implementation (Tanenbaum) and Operating System Principles and Implementation (the “银杏书”).

Additional reading : Compilation, Linking, and Libraries (often cited as “程序员的自我修养”) after covering CS:APP.

Step 2: Teaching‑OS Projects (small, complete OS demos)

Working with a compact teaching operating system helps you see the whole system before tackling a full‑scale kernel. Popular choices are:

minix : The miniature Unix used in Tanenbaum’s textbook appendix; source code is available on the official Minix website and GitHub.

ucore : A series of labs that gradually build a complete OS. Materials and source are hosted at https://github.com/ucore-os/ucore and the MIT 6.828 course page https://pdos.csail.mit.edu/6.828/2018/schedule.html.

xv6 : An educational reimplementation of Unix V6. Source and lab instructions are at https://github.com/mit-pdos/xv6-public.

Linux 0.11 : Approximately 20 k lines of code that implement the essential kernel features of early Linux. Two entry strategies are common:

Spatial: study each subsystem module by module (e.g., using Zhao Jiong’s Linux Kernel Complete Annotation ).

Temporal: follow the boot sequence—bootloader → process 0 → process 1—to understand the overall flow.

Step 3: Real Kernel – Source‑Code Reading Strategies

3.1 Subsystem‑oriented roadmap

The Linux kernel can be divided into four major subsystems. Adopt a focused reading path for each:

Memory management

File/storage stack (VFS, page cache, block I/O)

Process and thread management (fork, exec, scheduler)

Network stack (optional, not covered here)

3.1.1 Memory‑management reading strategy

Use the page‑fault handling flow as a unifying thread:

Identify the faulting process via its mm_struct.

Locate the corresponding virtual memory area (VMA) in the process’s address‑space tree.

Determine the mapping type (anonymous vs. file‑backed).

If anonymous, allocate a free physical page through the page allocator; if file‑backed, fetch the page from the page cache or read it from disk.

Update the page tables to map the new physical page into the process’s address space.

Record the mapping in reverse‑mapping structures and add the page to the LRU list for reclamation.

This sequence links the following kernel components: do_page_fault, handle_mm_fault, alloc_pages, insert_page, update_page_table, and the LRU subsystem.

3.1.2 File‑stack (VFS) reading strategy

The file/storage stack bridges memory management and I/O. Two critical execution paths are worth mastering:

Cache‑miss path : When a page request is not present in the page cache, the kernel constructs an I/O request, sends it down to the block‑device driver, receives the data, inserts the page into the page cache (radix tree or xarray), and finally maps it into the process’s address space.

Open syscall path : The namei routine resolves a pathname, allocates an inode, creates a dentry, and links them into the VFS caches. The resulting file structure records the opened file’s state.

The pagecache structure is the key bridge between memory management and the file stack.

3.1.3 Process‑thread management reading strategy

Focus on two foundational mechanisms:

fork implementation : Study do_fork, which creates a new task_struct, duplicates the parent’s mm_struct, copies page tables (or uses copy‑on‑write), and places the child on the run‑queue.

Scheduler : Understand the entry point schedule(), how it selects the next task_struct (TCB) based on the scheduling class, and the distinction between mechanism (the generic CFS/RT framework) and policy (CFS, EEVDF, real‑time, etc.). Treat the policy as a black box initially; later, explore pick_next_task and the underlying load‑balancing heuristics.

3.1.4 Network‑stack reading strategy

The author’s current work does not cover networking; readers can add this subsystem later.

3.2 Recommended source‑code books (Linux 2.6 series)

Linux Kernel Development (3rd ed., Novell Press, 2011) – 332 pages; high‑level overview of kernel architecture and core concepts.

Understanding the Linux Kernel (3rd ed., O'Reilly, 2005) – 896 pages; detailed walkthrough of kernel data structures and code.

Professional Linux Kernel Architecture (2008) – 1038 pages; comprehensive treatment of design decisions and implementation details.

Read the first book to grasp the overall structure, then use the latter two for in‑depth analysis of specific subsystems.

Reference link: https://www.cnblogs.com/changwan/p/18246095