Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Linux Kernel Development

Linux Kernel Development

Move from reading kernel code to making changes that survive testing, review, and real hardware.
by Robert Love 2010 480 pages
4.34
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Learn the kernel by changing it, not treating it as forbidden machinery.

A practical invitation. Linux grew from Linus Torvalds’s effort to build a free Unix-like system, then expanded through contributions from developers around the world. Its kernel is monolithic in execution, but supports modules that can be loaded or removed while the system runs. That combination reflects the book’s central stance: kernel development is demanding, not mystical. The book describes Linux as of version 2.6.34, so its examples are a historical snapshot of a changing codebase.

Source code is the classroom. Reading alone rarely reveals how design and implementation meet. The book urges aspiring developers to build the kernel, inspect the relevant subsystem, make a small change, and test it. Fixing a bug or adding modest functionality forces close attention to interfaces, concurrency, and the consequences of a change.

Analysis

The strongest teaching choice is to replace the aura of kernel work with a concrete learning loop: inspect, modify, test, and revise. That approach makes a vast system legible through local problems. The important qualification is that source familiarity is version-bound. Readers can retain the architectural reasoning while checking current source and documentation before applying an older interface or implementation detail.

Treat threads as tasks that share resources, not a separate kernel species.

One kernel abstraction. Linux represents each process with a `task struct`, which records its state, address space, open files, and other resources. The kernel schedules tasks, not abstract programs. A program becomes a process when it is running with resources and one or more threads of execution.

Sharing defines threads. Linux does not give threads a fundamentally separate kernel object. Instead, each thread is a task configured to share selected resources, such as an address space or file descriptors, with related tasks. Process creation uses `fork()`, which initially shares memory through copy-on-write: a private copy is made only when one process writes. `exec()` replaces a process’s program image. A terminated child can remain a zombie until its parent collects its exit status.

Analysis

This model makes resource relationships more important than labels. The same task abstraction can support a conventional process or a thread-like task, depending on what it shares. That is a useful way to reason about operating systems generally: ask which state is private and which is shared. The cost is conceptual discipline, since familiar user-level terms do not map one-to-one onto separate kernel structures.

Let fair CPU sharing depend on virtual runtime, not fixed time slices.

Fairness by accumulated use. The Completely Fair Scheduler, or CFS, aims to approximate an ideal processor that shares time evenly among runnable tasks. It tracks each task’s virtual runtime, a measure of its actual running time adjusted by its scheduling weight. When choosing the next task, CFS favors the runnable task with the smallest virtual runtime.

Priority shapes the share. A task’s nice value changes its weight and therefore its proportion of CPU time, rather than assigning it a fixed absolute slice. A waiting text editor can respond quickly when input arrives because it has used less than its fair share; a CPU-heavy video encoder can use the remaining time. CFS balances responsiveness and throughput, with a minimum scheduling granularity limiting excessive context switches.

Analysis

The useful shift is from asking how long each task gets to asking whether its cumulative share is fair. That perspective connects scheduling policy to accounting: priorities alter the distribution, while runtime records what has actually been consumed. Fairness remains an approximation, not a promise of equal response times. The minimum granularity and switching costs show that any real scheduler must trade mathematical neatness for practical performance.

Keep system calls few, validated, and durable.

A controlled boundary. A system call lets a user-space program request a kernel service through a defined entry point. Libraries such as the C library provide familiar APIs, but those APIs do not always correspond one-to-one with kernel calls. The kernel checks the request, performs the work, and returns a result or error. This boundary lets the kernel mediate access to hardware and shared system resources.

Design for long life. A new call should have one clear purpose, portable arguments, careful validation, and safe handling of user pointers. Once applications depend on its behavior, changing the interface can break them. The book therefore recommends considering alternatives, such as a device interface or a sysfs attribute, when a new system call is unnecessary. In kernel design, an interface should provide a mechanism without hard-coding a policy.

Analysis

A system call is not merely a function added to a list. It is a durable contract between independently evolving user programs and the kernel. That makes interface restraint a form of risk management: fewer permanent commitments leave more room to change internals. The trade-off is that alternatives also become user-visible interfaces and need careful design. Choosing the narrowest suitable boundary matters more than choosing the most familiar one.

Choose kernel data structures by access pattern, not familiarity.

Use the operation as your guide. Linux supplies reusable structures so kernel code need not reinvent common machinery. A linked list suits simple traversal and frequent insertion or removal. A FIFO queue fits producer-consumer work where items should leave in arrival order. The kernel’s `idr` maps integer identifiers to pointers and can allocate identifiers as well as look them up.

Pay for the complexity you need. Red-black trees keep data ordered while supporting efficient searches, making them useful when lookup matters more than simplicity. The scheduler uses one to organize runnable tasks by virtual runtime. Big-O notation describes how an algorithm’s work grows with input size, but it does not erase constant costs or typical workload size. Prefer existing infrastructure, then optimize only when the actual use case warrants it.

Analysis

This is a practical antidote to choosing a structure because it is fashionable or familiar. It starts with the dominant operation, then asks what cost that choice imposes on memory, implementation, and concurrency. Big-O is valuable as a map of growth, not a substitute for measurement. A theoretically faster structure can still be the wrong choice when the collection is small or the added complexity creates more bugs than it prevents.

Handle interrupts quickly, then defer work to the right context.

Respond before doing everything. A hardware interrupt requires prompt attention, but its handler can interrupt other work and cannot sleep. The handler, often called the top half, should acknowledge the device and handle time-critical tasks, such as copying incoming data into memory. Less urgent processing can be deferred to a bottom half, where all interrupts are enabled.

Choose the deferral tool carefully. Softirqs support highly concurrent, performance-sensitive work, but require careful protection of shared data. Tasklets are easier to use and prevent two instances of the same tasklet from running at once. Work queues run in process context, so their handlers can sleep, but they carry more scheduling overhead. The practical choice depends on whether the work needs to block and how much concurrency it must support.

Analysis

The split is fundamentally about preserving system responsiveness while still completing substantial work. The top half protects the device’s immediate needs; deferred work gives the rest of the system room to proceed. The choice of bottom half is therefore not a naming preference but a decision about execution context, blocking, and concurrency. Putting too much work in the urgent path can make unrelated activity feel unreliable.

Lock shared data for every way execution can overlap.

Find the shared state first. Race conditions arise when execution paths access the same data without adequate protection. In the kernel, overlap can come from another processor, a preempting task, an interrupt, or deferred work. The key design task is identifying shared data and its critical regions. Locks protect data, not merely the lines of code surrounding it.

Match the lock to the context. Spin locks suit short critical sections and contexts that cannot sleep, including interrupt handlers. Mutexes allow a waiting task to sleep and belong in process context. If interrupts share data with code holding a spin lock, local interrupts may also need disabling. Nested locks need a consistent acquisition order to prevent deadlock. Memory barriers solve a different problem: they constrain the ordering of reads and writes, but do not replace mutual exclusion.

Analysis

The emphasis on identifying data ownership is more powerful than memorizing lock names. A lock is useful only if every relevant execution path observes the same protection rule. This makes synchronization an architectural property, not a patch added after a race appears. The challenge is that correctness and scalability can pull in opposite directions: broad locks are easier to reason about, while excessive lock granularity creates overhead and complexity.

Choose memory allocation by context, contiguity, and lifetime.

Allocation depends on where code runs. Kernel memory is managed in pages and zones, and allocations can fail. `GFP KERNEL` permits an allocation to sleep, so it suits process context where blocking is safe. `GFP ATOMIC` cannot sleep and is used in contexts such as interrupt handling, but it has fewer ways to find memory. Callers must check failures and release what they allocate.

Use the right shape of memory. `kmalloc()` provides physically contiguous memory for general small allocations; `vmalloc()` gives virtually contiguous memory and is more appropriate for larger regions when physical contiguity is not required. The slab allocator caches frequently used object types, reducing repeated allocation work. Per-CPU data can reduce locking and cache interference, but code must prevent preemption from moving it to another processor while accessing it.

Analysis

Kernel allocation is a constrained resource decision, not a simple request for a number of bytes. The execution context determines whether waiting is legal, while the consumer determines whether physical contiguity matters. This distinction explains why a convenient allocation can be incorrect even when it succeeds. Reuse through slab caches and per-CPU storage can improve performance, but each adds assumptions that should be justified by the object’s use and lifetime.

Use the VFS to make different filesystems speak one interface.

One interface, many implementations. The Virtual Filesystem, or VFS, lets common calls such as `open()`, `read()`, and `write()` operate across different filesystems and storage media. Filesystem-specific code supplies the implementation behind shared kernel structures. The main objects are the superblock for a mounted filesystem, the inode for file information, the dentry for a path component, and the file object for a process’s open file.

Names become reusable work. Resolving a path can require walking each component, so the dentry cache stores results for later lookups, including negative results for paths that do not exist. This helps avoid repeating expensive filesystem work. The VFS’s common model is biased toward Unix concepts, so filesystems with different internal designs must adapt their details to the shared interface.

Analysis

The VFS demonstrates the value of an abstraction that is strict enough to make implementations interchangeable, yet broad enough to accommodate very different storage formats. Its objects separate concerns: a path component is not the same thing as an on-disk inode, and an open file is a process-specific view. The abstraction does impose a conceptual shape on filesystems, so compatibility is achieved through adaptation rather than perfect neutrality.

Cache disk data, then schedule remaining I/O for latency and throughput.

Keep hot data in memory. The page cache stores recently accessed file data in RAM, avoiding slow disk reads when the same pages are needed again. Writes usually update the cache first, marking pages dirty; kernel threads later write those pages to storage. A two-list strategy separates recently reused pages from pages more readily available for eviction, reducing the harm caused by files read only once.

Order unavoidable disk work. The `bio` structure describes in-flight block I/O, while request queues collect work for devices. I/O schedulers merge adjacent requests and reorder others to reduce costly seeks. The Deadline scheduler gives requests expiration targets to limit starvation, especially for reads; the CFQ scheduler distributes service among processes. These policies trade individual request fairness against overall device throughput.

Analysis

The storage path is a layered optimization problem: avoid a disk operation if cached data suffices, combine operations when possible, and order the rest intelligently. That layered strategy explains why disk performance cannot be reduced to a single queue algorithm. Write-back improves efficiency by grouping changes, but delays agreement with the backing store. The system gains speed by accepting a period when memory and disk contain different versions.

Treat time as ticks carefully, and use timers for real delays.

Ticks are not universal seconds. The system timer generates interrupts at a frequency set by `HZ`; the kernel counts them in `jiffies`. A higher tick rate can improve timing resolution and scheduling responsiveness, but it also increases interrupt overhead. Code should scale durations using `HZ` rather than assume a fixed value. Because the counter can wrap around, the kernel provides comparison macros that handle wraparound safely.

Use the right kind of wait. Dynamic timers defer a function until a specified future time, but they can run later than their expiration and are not hard real-time guarantees. Busy waiting is wasteful and belongs only in very short hardware delays that require precision. For longer waits, a task can sleep with a timeout, allowing the processor to run other work.

Analysis

Timekeeping exposes the difference between a convenient unit and a reliable guarantee. A tick counter is useful for relative intervals, but its frequency and wraparound make casual arithmetic dangerous. Timers also promise a minimum delay more readily than an exact deadline. That distinction is essential in driver code, where confusing a scheduling convenience with a real-time guarantee can produce subtle hardware failures.

Make kernel changes portable, testable, and easy to review.

Assume the machine will differ. Portable kernel code avoids assumptions about word size, signed `char`, byte order, page size, alignment, and processor memory ordering. Architecture-specific work belongs in architecture-specific code. Modules let related code be loaded and removed independently, while kobjects and sysfs expose a structured view of devices and selected kernel attributes to user-space.

Make correctness inspectable. The book recommends `printk()` and kernel debugging options, reading oops traces, and using Git’s binary search to identify the change that introduced a bug. A contribution should follow kernel style, target the relevant maintainer, explain its rationale, and arrive as a tested patch. The Linux Kernel Mailing List supplies review and testing, but clear reproduction steps and a focused change make that collaboration far more effective.

Analysis

Kernel quality depends on more than whether code works on its author’s machine. Portability tests assumptions, debugging makes failures legible, and review brings in knowledge unavailable to a single contributor. These practices reinforce one another: a small, reproducible patch is easier to test across configurations and easier for maintainers to evaluate. The book’s process is rooted in the 2010 community workflow, so exact submission mechanics should be checked against current project guidance.

Analysis

Linux Kernel Development is best understood as a guided map of boundaries: user space meets the kernel through system calls, hardware meets software through interrupts and drivers, virtual memory meets physical pages through page tables, and diverse storage systems meet applications through the VFS. The technical details are extensive, but the recurring intellectual problem is consistent: how can the kernel provide a simple contract while managing concurrency, hardware constraints, and changing workloads beneath it?

The book’s strongest organizing principle is pragmatism. It presents Linux as a monolithic kernel for direct, efficient internal communication, while also emphasizing modular loading, reusable data structures, and common interfaces. That combination resists ideology. The scheduler’s fairness model, the division of interrupt work, and the page cache each solve a practical tension rather than pursue purity for its own sake. The reader learns to ask what must happen immediately, what can be deferred, what state is shared, and what promise an interface must preserve.

Its scope is both its strength and its difficulty. In a compact tour, the book moves from process creation and scheduling through synchronization, memory, filesystems, devices, debugging, portability, and community practice. The result is a systems-level mental model, not a substitute for subsystem documentation or source inspection. Its code and interface descriptions describe the 2.6.34 era, and specific APIs have changed since publication. The durable value lies less in memorizing those details than in understanding why they exist and how they interact.

The book also treats contribution as engineering, not merely coding. Bugs must be reproducible, patches must be reviewable, and portability requires distrust of convenient assumptions. That social dimension completes the technical argument: a kernel is maintained by many people, so clarity and compatibility are part of correctness. The central lesson is to move from curiosity to disciplined participation, using the source itself as the final reference.

Summary in 30 Seconds
Linux represents processes and threads as tasks, with shared resources determining how related tasks behave. Its scheduler distributes CPU time according to accumulated use and task priority. Interrupt handlers do urgent work immediately and defer the rest; locks must account for every source of concurrency. Memory allocation depends on whether code can sleep and whether physical contiguity matters. Shared interfaces, careful testing, portable code, and focused patches help kernel changes remain reliable.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.34 out of 5
Average of 500+ ratings from Goodreads and Amazon.

Linux Kernel Development is highly regarded as an accessible introduction to Linux kernel internals, praised for its readable style and balanced coverage of fundamentals and implementation. Readers appreciate its approachability for beginners while remaining valuable for experienced developers. Common criticisms include outdated content (written for kernel 2.6), uneven chapter quality, and occasionally insufficient depth, particularly around memory management and VFS. Despite its age, many readers return to it repeatedly, recommending it as a strong primer before tackling more comprehensive kernel references.

Your rating:
4.75
26 ratings
Want to read the full book?

Glossary

Completely Fair Scheduler

Proportional CPU scheduler

The scheduler class used for ordinary Linux tasks in the 2.6.23-era design described in the book. It models fair processor sharing by tracking each task’s virtual runtime and selecting a runnable task with relatively little accumulated runtime. Nice values weight the proportion of processor time each task receives.

task_struct

Process descriptor

The kernel structure that represents a process or thread-like task. It holds the task’s state and references to resources such as its address space, open files, and signals. Linux schedules these task structures; threads are represented as separate tasks configured to share selected resources.

copy-on-write

Delay memory copying

A memory-sharing technique used when Linux creates a child process. Parent and child initially share pages marked so that writes trigger creation of a private copy. This avoids copying data that may never be modified, especially when the child quickly loads a different program with exec.

softirq

Concurrent deferred interrupt work

A statically registered mechanism for deferring work from an interrupt handler. Softirq handlers run outside the immediate hardware response path and cannot sleep. Multiple processors may execute the same softirq type concurrently, so shared data needs careful protection. The book describes them as suited to performance-sensitive subsystems.

tasklet

Serialized deferred work

A dynamically created bottom-half mechanism built on softirqs. Tasklets cannot sleep, but two instances of the same tasklet do not run simultaneously on different processors. This makes them simpler to use than softirqs for many device drivers, while still allowing different tasklets to run concurrently.

work queue

Deferred process-context work

A mechanism for scheduling deferred kernel work on worker threads. Unlike softirqs and tasklets, work queue handlers run in process context and can sleep. They are appropriate when deferred work must block, for example while waiting for a resource, though they involve thread scheduling overhead.

gfp_mask

Allocation behavior flags

A set of flags passed to kernel memory allocation routines to describe where memory may come from and what the allocator may do. GFP_KERNEL permits waiting and is suitable when sleeping is safe. GFP_ATOMIC cannot sleep and is used in contexts such as interrupt handlers, but may be less likely to succeed under memory pressure.

Virtual Filesystem

Common filesystem interface

The kernel layer that lets common file operations work across different filesystem implementations and storage media. It defines shared objects and operations for filesystems to implement. The main objects include superblocks, inodes, dentries, and open-file structures, giving applications a consistent interface.

bio

In-flight block I/O description

A kernel structure describing a block I/O operation through one or more memory segments. Its vectors identify pages, offsets, and lengths, allowing an operation to use data that is not contiguous in memory. The structure is lighter and more flexible than representing every operation with individual buffer heads.

two-list strategy

Modified page-cache eviction

A page-cache policy that maintains active and inactive lists. Pages accessed again while inactive are promoted to the active list; inactive pages are more readily evicted. This approximates least-recently-used behavior while reducing the influence of files that are accessed once and then abandoned.

jiffies

Kernel tick counter

A counter incremented by timer ticks to measure elapsed time since system boot. Its rate depends on HZ, so code should convert durations rather than assume a fixed tick frequency. The counter can wrap around, and the kernel provides comparison macros designed to handle that safely.

kobject

Kernel object foundation

A structure that supplies basic object features to kernel data, including a name, reference counting, and a parent relationship. Kobjects are commonly embedded in larger structures and can form a hierarchy. That hierarchy underlies the device model and its representation in sysfs.

About the Author

Robert Love is a seasoned technologist and author with deep roots in systems-level engineering. His career spans landmark contributions to the Linux kernel, Android, and Google Search, reflecting a rare blend of low-level and large-scale expertise. Currently serving as Senior Director of Engineering at Google Cloud, he focuses on planet-scale networking infrastructure. His tenure at Toast further demonstrates his versatility across industries. Beyond engineering, Love has established himself as a respected technical author, with his writing celebrated for making complex operating system concepts accessible to developers at all levels.

Download PDF

To save this Linux Kernel Development summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.41 MB     Pages: 19

Download EPUB

To read this Linux Kernel Development summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.46 MB     Pages: 22
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...