Linux kernel development (2^nd Ed.)

The Linux kernel is one of the most important and far-reaching open-source projects. That is why Novell Press is excited to bring you the second edition of Linux Kernel Development, Robert Love's widely acclaimed insider's look at the Linux kernel. This authoritative, practical guide helps developers better understand the Linux kernel through updated coverage of all the major subsystems as well as new features associated with the Linux 2.6 kernel. You'll be able to take an in-depth look at Linux kernel from both a theoretical and an applied perspective as you cover a wide range of topics, including algorithms, system call interface, paging strategies and kernel synchronization. Get the top information right from the source in Linux Kernel Development.

1. 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 2. 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 C No Memory Protection No (Easy) Use of Floating Point Small, Fixed-Size Stack Synchronization and Concurrency Portability Is Important So Here We Are 3. 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 Copy-on-Write fork() vfork() The Linux Implementation of Threads Kernel Threads Process Termination Removal of the Process Descriptor The Dilemma of the Parentless Task Process Wrap Up 4. Process Scheduling. Policy I/O-Bound Versus Processor-Bound Processes Process Priority Timeslice Process Preemption The Scheduling Policy in Action The Linux Scheduling Algorithm Runqueues The Priority Arrays Recalculating Timeslices schedule() Calculating Priority and Timeslice Sleeping and Waking Up The Load Balancer Preemption and Context Switching User Preemption Kernel Preemption Real-Time Scheduler-Related System Calls Scheduling Policy and Priority-Related System Calls Processor Affinity System Calls Yielding Processor Time Scheduler Finale 5. System Calls. APIs, POSIX, and the C Library Syscalls 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 6. Interrupts and Interrupt Handlers. Interrupts 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! 7. Bottom Halves and Deferring Work. Bottom Halves Why Bottom Halves? A World of Bottom Halves Softirqs Implementation of Softirqs Using Softirqs Tasklets Implementation of Tasklets Using Tasklets ksoftirqd 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 8. Kernel Synchronization Introduction. Critical Regions and Race Conditions Why Do We Need Protection? Locking g What Causes Concurrency, Anyway? So, How Do I Know What Needs Protecting? Deadlocks Contention and Scalability Locking and Your Code 9. Kernel Synchronization Methods. Atomic Operations Atomic Integer Operations Atomic Bitwise Operations Spin Locks Other Spin Lock Methods Spin Locks and Bottom Halves Reader-Writer Spin Locks Semaphores Creating and Initializing Semaphores Using Semaphores Reader-Writer Semaphores Spin Locks Versus Semaphores Completion Variables BKL: The Big Kernel Lock Seq Locks Preemption Disabling Ordering and Barriers Synchronization Summarization 10. Timers and Time Management. Kernel Notion of Time The Tick Rate: HZ The Ideal HZ Value Jiffies Internal Representation of Jiffies Jiffies Wraparound User-Space and HZ Hardware Clocks and Timers Real-Time Clock System Timer The Timer Interrupt Handler The Time of Day Timers Using Timers Timer Race Conditions The Timer Implementation Delaying Execution Busy Looping Small Delays schedule_timeout() Out of Time 11. Memory Management. Pages Zones Getting Pages Getting Zeroed Pages Freeing pages kmalloc() gfp_mask Flags kfree() vmalloc() Slab Layer Design of the Slab Layer Slab Allocator Interface Statically Allocating on the Stack Playing Fair on the Stack High Memory Mappings Permanent Mappings Temporary Mappings Per-CPU Allocations The New percpu Interface Per-CPU Data at Compile-Time Per-CPU Data at Runtime Reasons for Using Per-CPU Data Which Allocation Method Should I Use? 12. The Virtual Filesystem. Common Filesystem Interface Filesystem Abstraction Layer Unix Filesystems VFS Objects and Their Data Structures Other VFS Objects The Superblock Object Superblock Operations The Inode Object Inode Operations The Dentry Object Dentry State The Dentry Cache Dentry Operations The File Object File Operations Data Structures Associated with Filesystems Data Structures Associated with a Process Filesystems in Linux 13. The Block I/O Layer. Anatomy of a Block Device Buffers and Buffer Heads The bio structure The Old Versus the New Request Queues Requests I/O Schedulers The Job of an I/O Scheduler The Linus Elevator The Deadline I/O Scheduler The Anticipatory I/O Scheduler The Complete Fair Queuing I/O Scheduler The Noop I/O Scheduler I/O Scheduler Selection Summary 14. The Process Address Space. The Memory Descriptor Allocating a Memory Descriptor Destroying a Memory Descriptor The mm_struct and Kernel Threads Memory Areas VMA Flags VMA Operations Lists and Trees of Memory Areas Memory Areas in Real Life Manipulating Memory Areas find_vma() find_vma_prev() find_vma_intersection() mmap() and do_mmap(): Creating an Address Interval The mmap() System Call munmap() and do_munmap(): Removing an Address Interval The munmap() System Call Page Tables Conclusion 15. The Page Cache and Page Writeback. Page Cache The address_space Object Radix Tree The Old Page Hash Table The Buffer Cache The pdflush Daemon Laptop Mode bdflush and kupdated Congestion Avoidance: Why We Have Multiple Threads To Make a Long Story Short 16. Modules. Hello, World! Building Modules At Home in the Source Tree Living Externally Installing Modules Generating Module Dependencies Loading Modules Managing Configuration Options Module Parameters Exported Symbols Wrapping Up