The Design of the UNIX Operating System (Maurice J. Bach)（Z-Library）

# The Design of the UNIX Operating System ## 【One-Line Pitch】 A classic deep-dive into the internal architecture of UNIX System V, explaining the kernel's algorithms and data structures—essential reading for systems programmers, OS students, and anyone who wants to truly understand how operating systems work under the hood. ## 【Book Arc】 - **Opening (~0%–9%)**: Traces UNIX's evolution from Bell Labs through System III and System V, contrasting with BSD variants, then introduces the kernel's two major subsystems—file and process—and the user perspective via the shell and fundamental system calls like fork, exec, and wait. - **Early (~9%–25%)**: Establishes kernel architecture fundamentals: the non-preemptive execution model, the buffer cache mechanism with its allocation algorithms (getblk), and how the kernel maintains data consistency through interrupt blocking and sleep states. - **Early–Middle (~25%–38%)**: Explores the internal representation of files—inodes, the super block, direct/indirect block addressing, and algorithms like iget, iput, bmap, and namei that convert path names to inodes and manage disk block allocation. - **Middle (~38%–47%)**: Details the system call interface to the file system: open, read, write, close, chroot, chown, chmod, stat, and dup—showing how file descriptors, file table entries, and inodes interconnect. - **Late (~47%–100%)**: Covers process control (fork, signals, exec, exit), scheduling and time, memory management (swapping and paging), device drivers, streams, inter-process communication (messages, shared memory, semaphores), and advanced topics in multiprocessor and distributed UNIX systems. ## 【Key Takeaways】 - **The kernel is non-preemptive** (Early): A process running in kernel mode executes until it sleeps or returns to user mode—this simple policy, plus interrupt blocking, maintains data structure consistency without complex locking. - **The buffer cache is the performance backbone** (Early): The getblk algorithm manages buffer allocation with hash queues and free lists, using delayed writes to reduce disk I/O—critical for understanding file system performance. - **Inodes are the heart of the file system** (Early): Every file has a unique inode containing ownership, permissions, size, and data block locations; the kernel converts path names to inodes via the namei algorithm. - **The super block caches free resources** (Early): Free inode numbers and free disk block numbers are cached in the super block, with a linked list of block numbers for overflow—a clever design that avoids expensive disk scans. - **File descriptors are indices into a layered table structure** (Middle): The user file descriptor table points to global file table entries, which point to inodes—this indirection enables features like dup and shared file offsets. - **Delayed write is especially effective for pipes** (Middle): By caching writes and deferring disk I/O, the kernel avoids redundant operations—particularly beneficial when data is written and quickly read or removed. - **The shell is just a user program** (Opening): UNIX keeps the kernel small by pushing compilers, editors, and the command interpreter to user space; the shell supports executable files, shell scripts, and internal commands as a programming language. - **The superuser is not a separate process class** (Early): Administrative processes use the same system calls as everyone else, distinguished only by special privileges—a design choice that simplifies the kernel. ## 【Reading Tips】 - **Skim the historical introduction** (~0%–6%): The UNIX lineage and popularity discussion is interesting context but not essential—move quickly to the kernel architecture overview. - **Deep-read the buffer cache and inode chapters** (~16%–34%): These are the conceptual foundations; the algorithms (getblk, iget, ialloc, bmap) appear repeatedly in later chapters, so mastering them pays off. - **Study the figures carefully**: Diagrams like the user/kernel stack layout and the inode direct/indirect block structure convey more than the prose—trace through the data structure relationships. - **Expect dense pseudocode**: The algorithm listings are simplified but still require careful reading; try tracing through scenarios (like buffer allocation with sleep/wakeup) to internalize the logic. - **Use later chapters as reference**: Process control, scheduling, and memory management build on earlier concepts—if you're primarily interested in processes, you can jump ahead after Chapter 5. ## 【Coverage Limits】 This guide covers the book's opening through the file system system calls (~47% of the book). The excerpts do not cover the later chapters on process control, scheduling, memory management, device drivers, streams, IPC, or multiprocessor/distributed systems in detail. ##