Skip to content

Linux Kernel Development

Spend $50 to get a free DVD!

ISBN-10: 0672325128

ISBN-13: 9780672325120

Edition: 2004

Authors: Robert Love

List price: $44.99
Blue ribbon 30 day, 100% satisfaction guarantee!
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!


This practical guide helps programmers better understand the Linux kernel, and to write and develop kernel code. It provides in-depth coverage of all the major subsystems and features of the Linux 2.6 kernel.
Customers also bought

Book details

List price: $44.99
Copyright year: 2004
Publisher: Sams
Publication date: 9/18/2003
Binding: Paperback
Pages: 360
Size: 6.97" wide x 9.06" long x 0.79" tall
Weight: 1.232
Language: English

Robert Love is an author, speaker, and open source software developer. He is best known for his contributions to the Linux kernel, with notable work including the preemptive kernel, process scheduler, kernel event layer, virtual memory subsystem, and inotify. Love is also active in the GNOME community, working on NetworkManager, GNOME Volume Manager, Project Utopia and Beagle. Love currently works for Google in Boston, where he is a member of Google's Open Source Program Office and is involved in the development of Google Android. Previously he worked at Novell as an engineer in the Linux desktop group and as Chief Architect, Linux Desktop. He has given numerous talks on the kernel and…    

Introduction to the Linux Kernel
Along Came Linus: Introduction to Linux
Overview of Operating Systems and Kernels
Linux Versus Classic Unix Kernels
Linux Kernel Versions
The Linux Kernel Development Community
Before We Begin
Getting Started with the Kernel
Obtaining the Kernel Source
Installing the Kernel Source
Using Patches
The Kernel Source Tree
Building the Kernel
Minimizing Build Noise
Spawning Multiple Build Jobs
Installing the Kernel
A Beast of a Different Nature
No libc
GNU CNo Memory Protection
No (Easy) Use of Floating Point
Small, Fixed-Size Stack
Synchronization and Concurrency
Portability Is Important
So Here We Are
Process Management
Process Descriptor and the Task Structure
Allocating the Process Descriptor
Storing the Process Descriptor
Process State
Manipulating the Current Process State
Process Context
The Process Family Tree
Process Creation
The Linux Implementation of Threads
Kernel Threads
Process Termination
Removal of the Process Descriptor
The Dilemma of the Parentless Task
Process Wrap Up
Process Scheduling
PolicyI/O-Bound Versus Processor-Bound Processes
Process Priority
Process Preemption
The Scheduling Policy in Action
The Linux Scheduling Algorithm
The Priority Arrays
Recalculating Timeslicesschedule()
Calculating Priority and Timeslice
Sleeping and Waking Up
The Load Balancer
Preemption and Context Switching
User Preemption
Kernel Preemption
Scheduler-Related System Calls
Scheduling Policy and Priority-Related System Calls
Processor Affinity System Calls
Yielding Processor Time
Scheduler Finale
System Calls
APIs, POSIX, and the C Library
System Call Numbers
System Call Performance
System Call Handler
Denoting the Correct System Call
Parameter Passing
System Call Implementation
Verifying the Parameters
System Call Context
Final Steps in Binding a System Call
Accessing the System Call from User-Space
Why Not to Implement a System Call
System Calls in Conclusion
Interrupts and Interrupt Handlers
Interrupt Handlers
Top Halves Versus Bottom Halves
Registering an Interrupt Handler
Freeing an Interrupt Handler
Writing an Interrupt Handler
Shared Handlers
A Real-Life Interrupt Handler
Interrupt Context
Implementation of Interrupt Handling/proc/interrupts
Interrupt Control
Disabling and Enabling Interrupts
Disabling a Specific Interrupt Line
Status of the Interrupt System
Don't Interrupt Me
We're Almost Done!
Bottom Halves and Deferring Work
Bottom Halves
Why Bottom Halves?
A World of Bottom Halves
Implementation of Softirqs
Using Softirqs
Implementation of Tasklets
Using Taskletsksoftirqd
The Old BH Mechanism
Work Queues
Implementation of Work Queues
Using Work Queues
The Old Task Queue Mechanism
Which Bottom Half Should I Use?
Locking Between the Bottom Halves
Disabling Bottom Halves
The Bottom of Bottom-Half Processing
Kernel Synchronization Introduction
Critical Regions and Race Condit