Team LiB
Previous Section Next Section
Book Cover
• Table of Contents
• Index
Linux Kernel Development Second Edition
By Robert Love
Publisher: Sams Publishing
Pub Date: January 12, 2005
ISBN: 0-672-32720-1
Pages: 432

      So Here We Are
      Kernel Version
      Book Website
      Second Edition Acknowledgments
   About the Author
      We Want to Hear from You!
      Reader Services
        Chapter 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
        Chapter 2.  Getting Started with the Kernel
      Obtaining the Kernel Source
      The Kernel Source Tree
      Building the Kernel
      A Beast of a Different Nature
      So Here We Are
        Chapter 3.  Process Management
      Process Descriptor and the Task Structure
      Process Creation
      The Linux Implementation of Threads
      Process Termination
      Process Wrap Up
        Chapter 4.  Process Scheduling
      The Linux Scheduling Algorithm
      Preemption and Context Switching
      Scheduler-Related System Calls
      Scheduler Finale
        Chapter 5.  System Calls
      APIs, POSIX, and the C Library
      System Call Handler
      System Call Implementation
      System Call Context
      System Calls in Conclusion
        Chapter 6.  Interrupts and Interrupt Handlers
      Interrupt Handlers
      Registering an Interrupt Handler
      Writing an Interrupt Handler
      Interrupt Context
      Implementation of Interrupt Handling
      Interrupt Control
      Don't Interrupt Me; We're Almost Done!
        Chapter 7.  Bottom Halves and Deferring Work
      Bottom Halves
      Work Queues
      Which Bottom Half Should I Use?
      Locking Between the Bottom Halves
      The Bottom of Bottom-Half Processing
        Chapter 8.  Kernel Synchronization Introduction
      Critical Regions and Race Conditions
      Contention and Scalability
      Locking and Your Code
        Chapter 9.  Kernel Synchronization Methods
      Atomic Operations
      Spin Locks
      Reader-Writer Spin Locks
      Reader-Writer Semaphores
      Spin Locks Versus Semaphores
      Completion Variables
      BKL: The Big Kernel Lock
      Preemption Disabling
      Ordering and Barriers
      Synchronization Summarization
        Chapter 10.  Timers and Time Management
      Kernel Notion of Time
      The Tick Rate: HZ
      Hardware Clocks and Timers
      The Timer Interrupt Handler
      The Time of Day
      Delaying Execution
      Out of Time
        Chapter 11.  Memory Management
      Getting Pages
      Slab Layer
      Slab Allocator Interface
      Statically Allocating on the Stack
      High Memory Mappings
      Per-CPU Allocations
      The New percpu Interface
      Reasons for Using Per-CPU Data
      Which Allocation Method Should I Use?
        Chapter 12.  The Virtual Filesystem
      Common Filesystem Interface
      Filesystem Abstraction Layer
      Unix Filesystems
      VFS Objects and Their Data Structures
      The Superblock Object
      The Inode Object
      The Dentry Object
      The File Object
      Data Structures Associated with Filesystems
      Data Structures Associated with a Process
      Filesystems in Linux
        Chapter 13.  The Block I/O Layer
      Anatomy of a Block Device
      Buffers and Buffer Heads
      The bio structure
      Request Queues
      I/O Schedulers
        Chapter 14.  The Process Address Space
      The Memory Descriptor
      Memory Areas
      Manipulating Memory Areas
      mmap() and do_mmap(): Creating an Address Interval
      munmap() and do_munmap(): Removing an Address Interval
      Page Tables
        Chapter 15.  The Page Cache and Page Writeback
      Page Cache
      Radix Tree
      The Buffer Cache
      The pdflush Daemon
      To Make a Long Story Short
        Chapter 16.  Modules
      Hello, World!
      Building Modules
      Installing Modules
      Generating Module Dependencies
      Loading Modules
      Managing Configuration Options
      Module Parameters
      Exported Symbols
      Wrapping Up Modules
        Chapter 17.  kobjects and sysfs
      Structure Confusion
      Managing and Manipulating kobjects
      Reference Counts
      The Kernel Events Layer
      kobjects and sysfs in a Nutshell
        Chapter 18.  Debugging
      What You Need to Start
      Bugs in the Kernel
      Kernel Debugging Options
      Asserting Bugs and Dumping Information
      Magic SysRq Key
      The Saga of a Kernel Debugger
      Poking and Probing the System
      Binary Searching to Find the Culprit Change
      When All Else Fails: The Community
        Chapter 19.  Portability
      History of Portability in Linux
      Word Size and Data Types
      Data Alignment
      Byte Order
      Page Size
      Processor Ordering
      SMP, Kernel Preemption, and High Memory
        Chapter 20.  Patches, Hacking, and the Community
      The Community
      Linux Coding Style
      Chain of Command
      Submitting Bug Reports
      Generating Patches
      Submitting Patches
        Appendix A.  Linked Lists
      Circular Linked Lists
      The Linux Kernel's Implementation
      Manipulating Linked Lists
      Traversing Linked Lists
        Appendix B.  Kernel Random Number Generator
      Design and Implementation
      Interfaces to Input Entropy
      Interfaces to Output Entropy
        Appendix C.  Algorithmic Complexity
      Big-O Notation
      Big Theta Notation
      Putting It All Together
      Perils of Time Complexity
       Bibliography and Reading List
      Books on Operating System Design
      Books on Unix Kernels
      Books on Linux Kernels
      Books on Other Kernels
      Books on the Unix API
      Books on the C Programming Language
      Other Works

Team LiB
Previous Section Next Section