Books & Videos

Table of Contents

  1. Chapter 1 Introduction

    1. Linux Versus Other Unix-Like Kernels

    2. Hardware Dependency

    3. Linux Versions

    4. Basic Operating System Concepts

    5. An Overview of the Unix Filesystem

    6. An Overview of Unix Kernels

  2. Chapter 2 Memory Addressing

    1. Memory Addresses

    2. Segmentation in Hardware

    3. Segmentation in Linux

    4. Paging in Hardware

    5. Paging in Linux

  3. Chapter 3 Processes

    1. Processes, Lightweight Processes, and Threads

    2. Process Descriptor

    3. Process Switch

    4. Creating Processes

    5. Destroying Processes

  4. Chapter 4 Interrupts and Exceptions

    1. The Role of Interrupt Signals

    2. Interrupts and Exceptions

    3. Nested Execution of Exception and Interrupt Handlers

    4. Initializing the Interrupt Descriptor Table

    5. Exception Handling

    6. Interrupt Handling

    7. Softirqs and Tasklets

    8. Work Queues

    9. Returning from Interrupts and Exceptions

  5. Chapter 5 Kernel Synchronization

    1. How the Kernel Services Requests

    2. Synchronization Primitives

    3. Synchronizing Accesses to Kernel Data Structures

    4. Examples of Race Condition Prevention

  6. Chapter 6 Timing Measurements

    1. Clock and Timer Circuits

    2. The Linux Timekeeping Architecture

    3. Updating the Time and Date

    4. Updating System Statistics

    5. Software Timers and Delay Functions

    6. System Calls Related to Timing Measurements

  7. Chapter 7 Process Scheduling

    1. Scheduling Policy

    2. The Scheduling Algorithm

    3. Data Structures Used by the Scheduler

    4. Functions Used by the Scheduler

    5. Runqueue Balancing in Multiprocessor Systems

    6. System Calls Related to Scheduling

  8. Chapter 8 Memory Management

    1. Page Frame Management

    2. Memory Area Management

    3. Noncontiguous Memory Area Management

  9. Chapter 9 Process Address Space

    1. The Process's Address Space

    2. The Memory Descriptor

    3. Memory Regions

    4. Page Fault Exception Handler

    5. Creating and Deleting a Process Address Space

    6. Managing the Heap

  10. Chapter 10 System Calls

    1. POSIX APIs and System Calls

    2. System Call Handler and Service Routines

    3. Entering and Exiting a System Call

    4. Parameter Passing

    5. Kernel Wrapper Routines

  11. Chapter 11 Signals

    1. The Role of Signals

    2. Generating a Signal

    3. Delivering a Signal

    4. System Calls Related to Signal Handling

  12. Chapter 12 The Virtual Filesystem

    1. The Role of the Virtual Filesystem (VFS)

    2. VFS Data Structures

    3. Filesystem Types

    4. Filesystem Handling

    5. Pathname Lookup

    6. Implementations of VFS System Calls

    7. File Locking

  13. Chapter 13 I/O Architecture and Device Drivers

    1. I/O Architecture

    2. The Device Driver Model

    3. Device Files

    4. Device Drivers

    5. Character Device Drivers

  14. Chapter 14 Block Device Drivers

    1. Block Devices Handling

    2. The Generic Block Layer

    3. The I/O Scheduler

    4. Block Device Drivers

    5. Opening a Block Device File

  15. Chapter 15 The Page Cache

    1. The Page Cache

    2. Storing Blocks in the Page Cache

    3. Writing Dirty Pages to Disk

    4. The sync( ), fsync( ), and fdatasync( ) System Calls

  16. Chapter 16 Accessing Files

    1. Reading and Writing a File

    2. Memory Mapping

    3. Direct I/O Transfers

    4. Asynchronous I/O

  17. Chapter 17 Page Frame Reclaiming

    1. The Page Frame Reclaiming Algorithm

    2. Reverse Mapping

    3. Implementing the PFRA

    4. Swapping

  18. Chapter 18 The Ext2 and Ext3 Filesystems

    1. General Characteristics of Ext2

    2. Ext2 Disk Data Structures

    3. Ext2 Memory Data Structures

    4. Creating the Ext2 Filesystem

    5. Ext2 Methods

    6. Managing Ext2 Disk Space

    7. The Ext3 Filesystem

  19. Chapter 19 Process Communication

    1. Pipes

    2. FIFOs

    3. System V IPC

    4. POSIX Message Queues

  20. Chapter 20 Program ExZecution

    1. Executable Files

    2. Executable Formats

    3. Execution Domains

    4. The exec Functions

  1. Appendix A System Startup

    1. Prehistoric Age: the BIOS

    2. Ancient Age: the Boot Loader

    3. Middle Ages: the setup( ) Function

    4. Renaissance: the startup_32( ) Functions

    5. Modern Age: the start_kernel( ) Function

  2. Appendix B Modules

    1. To Be (a Module) or Not to Be?

    2. Module Implementation

    3. Linking and Unlinking Modules

    4. Linking Modules on Demand

  3. Appendix Bibliography

    1. Books on Unix Kernels

    2. Books on the Linux Kernel

    3. Books on PC Architecture and Technical Manuals on Intel Microprocessors

    4. Other Online Documentation Sources

    5. Research Papers Related to Linux Development

  4. Colophon