Operating System Concepts

Citation

Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). Operating System Concepts (10th ed.). Wiley.

Chapter Summary

The tenth edition (April 2018; Wiley lists 1,040 pages) has 21 chapters in nine parts, plus four appendices (influential operating systems, Windows 7, BSD UNIX and the Mach system) that are paginated separately and, according to the preface, offered on the book's website. The preface describes it as a text for an introductory operating systems course at the junior or senior undergraduate or first-year graduate level, presenting concepts through intuitive descriptions, figures and examples rather than formal proofs. Examples come from Linux, Windows, macOS, Solaris, Android and iOS. Each chapter ends with practice exercises (with solutions on the website), further exercises and further reading. This edition was shaped by four trends the authors name: mobile operating systems, multicore systems, virtualization and nonvolatile-memory storage.

Part One, Chapters 1–2: Introduction; Operating-System Structures

What operating systems are and do, the hardware background (with an overview of kernel data structures), and how systems are designed and built: services, system calls, linkers and loaders, operating-system structures and booting with GRUB. The preface notes these two chapters avoid internal algorithms and suit readers who want an overview.

Part Two, Chapters 3–5: Processes; Threads & Concurrency; CPU Scheduling

The process as the unit of work, its memory layout and interprocess communication (including Mach message passing and Android RPC); threads and implicit threading, including fork-join parallelism, Java Futures, Grand Central Dispatch and Intel Threading Building Blocks; and CPU scheduling, from basic algorithms to multicore and NUMA-aware scheduling, the Linux CFS scheduler and Windows 10.

Part Three, Chapters 6–8: Synchronization Tools; Synchronization Examples; Deadlocks

The former single synchronization chapter is now two: Chapter 6 covers race conditions and general tools, from memory models and barriers to compare-and-swap and lock-free algorithms, without tying them to a specific API; Chapter 7 applies them to classical synchronization problems with POSIX semaphores, condition variables and Java. Chapter 8 covers deadlock and livelock, with tools such as Linux lockdep.

Part Four, Chapters 9–10: Main Memory; Virtual Memory

Memory management on modern hardware, including paging, swapping of pages and the ARMv8 64-bit architecture (segmentation has been removed), followed by virtual memory: page faults, frame allocation, NUMA allocation, compressed memory, and memory management in Linux and Windows 10.

Part Five, Chapters 11–12: Mass-Storage Structure; I/O Systems

Hard disks and nonvolatile memory devices treated as equals, drive scheduling, RAID, cloud and object storage; then I/O hardware, interfaces and kernel I/O structures, blocking and nonblocking I/O and performance.

Part Six, Chapters 13–15: File-System Interface; File-System Implementation; File-System Internals

Files, directories, protection and memory-mapped files from the user's point of view; then how file systems are implemented, including allocation methods, performance, journaling, TRIM and the Apple File System; and a new chapter on file-system internals gathering material from the previous edition.

Part Seven, Chapters 16–17: Security; Protection

Security now precedes protection: current threats such as ransomware, code-injection attacks with code samples, encryption, authentication and defenses such as address-space layout randomization. The protection chapter covers rings, access control, mandatory access control, Linux capabilities, sandboxing, code signing and Java stack inspection.

Part Eight, Chapters 18–19: Virtual Machines; Networks and Distributed Systems

Virtualization techniques and hardware support, containers, Docker and Kubernetes, and current research such as unikernels; then networks with a focus on TCP/IP, combined with distributed systems and file systems such as the Google file system and Hadoop.

Part Nine, Chapters 20–21: The Linux System; Windows 10

Two case studies that apply the book's concepts to complete systems. The Linux chapter covers history, design principles, kernel modules, process management, scheduling, memory management, file systems, I/O, interprocess communication, networking and security.

Key Concepts

Parts One–Two: Structure and processes

• System calls and kernel structure: how programs request services and the ways an operating system can be structured and built.
• Process and thread: the unit of work and the unit of execution within it, with interprocess communication between processes.
• CPU scheduling: policies for choosing the next thread to run, including multicore and NUMA effects.

Part Three: Synchronization

• Race conditions and critical sections: why concurrent access to shared data needs coordination.
• Synchronization tools: locks, semaphores, monitors and condition variables, and lock-free compare-and-swap.
• Deadlock and liveness: conditions under which processes wait forever, and how to prevent, avoid or detect them.

Parts Four–Six: Memory, storage and files

• Paging and virtual memory: mapping virtual to physical memory, demand paging and page replacement.
• Mass storage and I/O: disk and nonvolatile memory devices, scheduling, RAID and the kernel I/O subsystem.
• File-system implementation: allocation, directories, journaling and performance.

Parts Seven–Nine: Security, advanced topics and case studies

• Security versus protection: defending against attacks versus controlling access to resources.
• Virtual machines and containers: running isolated environments over shared hardware.
• Case studies: Linux and Windows 10 as full examples of the concepts.

Critical Analysis

Strengths

• Concepts first, systems as examples. The preface states the aim of presenting concepts in a general setting not tied to one operating system, illustrated with many examples from current desktop, server and mobile systems. This makes the book usable whichever system a course uses for practical work.
• Up-to-date edition. The preface lists major revisions in every chapter: more multicore, mobile and ARM coverage, solid-state storage, a split and expanded treatment of synchronization including memory models and lock-free algorithms, containers and Kubernetes.
• Programming in three environments. Examples use POSIX and Pthreads in C, Java and the Windows API, sometimes all three for the same task (such as creating threads). A downloadable Ubuntu virtual machine supports the programming assignments, some of which involve writing Linux kernel modules.
• Plenty of support. Practice exercises with online solutions, further exercises, review questions, a student study guide, slides and sample syllabi are available from the book's website.

Limitations

• Intuition rather than proof. The authors deliberately omit most formal proofs, using figures and examples instead and pointing to research papers; students who want rigorous treatment of, for example, synchronization correctness need other sources.
• Size. At over 1,000 pages the book is a reference as much as a course text; the preface recommends working through the chapters in order but offers sample syllabi for selecting chapters.
• Prerequisites. The preface assumes basic data structures, computer organization and comfort with C; readers new to C will find the programming examples hard going.
• Format. The authors' website describes the tenth edition as sold as an e-text, alone or bundled with an abridged print companion (Wiley later added a loose-leaf printing), so readers who want a complete printed book should check which version they are buying.

Where It Fits in the Course

This is one of the course's main textbooks for an operating systems course. Tanenbaum and Bos's Modern Operating Systems is a comparable standard text that grounds the principles in extended case studies of Linux, Android and Windows; either can serve as the main book and the other as a second explanation. Arpaci-Dusseau and Arpaci-Dusseau's free Operating Systems: Three Easy Pieces organizes the subject around virtualization, concurrency and persistence and is a good companion for students who want a different angle, especially on concurrency.

Ward's How Linux Works is the practical companion: it shows on a running Linux machine where the concepts of Chapters 2, 3, 9–14 and 20 appear and how to inspect them. Saltzer and Kaashoek's Principles of Computer System Design suits a later course on the design principles of computer systems more broadly.

How to Use This Book

The book suits computer science undergraduates in their third or fourth year (the level the preface names), first-year graduate students, and practitioners who want a systematic account of operating systems. Come prepared with data structures, computer organization and C.

A practical plan for a one-semester course:

• Core: Chapters 1–7 (overview, processes, threads, scheduling, synchronization), 8 (deadlocks), 9–10 (memory) and 13–14 (file systems). These carry the main concepts and the bulk of the programming assignments.
• Storage and I/O: Chapters 11–12, especially for students interested in systems performance.
• Optional or second course: Chapters 15–19 on file-system internals, security, protection, virtualization and distributed systems.
• Case studies: Chapter 20 on Linux alongside the core chapters if the course uses Linux for programming; Chapter 21 if it uses Windows. The online appendices on historical systems are for interest.

Do the practice exercises at the end of each chapter and check them against the solutions on the website. Install the Linux virtual machine early and work through the programming projects, since processes, threads, synchronization and memory management become clear mainly by programming them. Keep the study guide for review.