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. It also has four appendices on influential operating systems, Windows 7, BSD UNIX and the Mach system. These 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. It presents 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.

The authors name four trends that shaped this edition: mobile operating systems, multicore systems, virtualization and nonvolatile-memory storage.

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

These chapters cover what operating systems are and do and the hardware background, with an overview of kernel data structures. They then explain 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

• Processes: the process as the unit of work, its memory layout, and interprocess communication (including Mach message passing and Android RPC).
• Threads: threads and implicit threading, including fork-join parallelism, Java Futures, Grand Central Dispatch and Intel Threading Building Blocks.
• 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 these tools 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

Chapter 9 covers memory management on modern hardware, including paging, swapping of pages and the ARMv8 64-bit architecture; segmentation has been removed. Chapter 10 covers 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

Chapter 11 treats hard disks and nonvolatile memory devices as equals and covers drive scheduling, RAID, and cloud and object storage. Chapter 12 covers 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

• Chapter 13: files, directories, protection and memory-mapped files from the user's point of view.
• Chapter 14: how file systems are implemented, including allocation methods, performance, journaling, TRIM and the Apple File System.
• Chapter 15: a new chapter on file-system internals that gathers material from the previous edition.

Part Seven, Chapters 16–17: Security; Protection

Security now precedes protection. The security chapter covers 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

Chapter 18 covers virtualization techniques and hardware support, containers, Docker and Kubernetes, and current research such as unikernels. Chapter 19 covers networks with a focus on TCP/IP, combined with distributed systems and distributed file systems such as the Google file system and Hadoop.

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

Two case studies 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 aims to present 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. These include more multicore, mobile and ARM coverage; solid-state storage; a split and expanded treatment of synchronization, including memory models and lock-free algorithms; and 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. The book's website offers practice exercises with online solutions, further exercises, review questions, a student study guide, slides and sample syllabi.
• In current use. Several Fall 2024 courses assign the tenth edition; see the course assignments under How to Use This Book.

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 a 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.
• A survey, not a lab manual. This is a classic survey text, and courses often pair it with systems-programming work or projects that are not in the book. Expect the course's own assignments to carry much of the hands-on load.
• Edition drift. Both the ninth and tenth editions still appear on 2024 syllabi, and their chapter numbering and content differ. For example, the tenth edition splits synchronization into two chapters and drops segmentation. Check which edition your course names before following chapter numbers.
• 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. Readers who want a complete printed book should check which version they are buying.

Where It Fits in the Course

This is a main textbook for an introductory operating systems course. Recent syllabi, including the Fall 2024 courses at Oklahoma, Colorado State and UT Dallas described below, place it in the standard introductory slot, though not all of them use the tenth edition.

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. It 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. Processes, threads, synchronization and memory management become clear mainly by programming them. Keep the study guide for review.

Common course assignments

University of Oklahoma, CS 3113 Intro to Operating Systems (Fall 2024, 10th ed., ISBN-13 978-1-119-32091-3). This is the same ISBN as the edition described in this guide. The tentative weekly schedule closely follows the core plan above:

• Week 1: Chapter 1, OS overview
• Week 3: Chapter 2, OS structures; processes
• Week 4: Chapter 3, interprocess communication
• Week 5: Chapter 4, threads
• Week 6: Chapter 5, CPU scheduling
• Week 7: Chapter 6, synchronization, semaphores, critical sections
• Week 8: Chapter 7, monitors and atomic transactions
• Weeks 9–10: Chapter 8, deadlocks
• Weeks 11–12: Chapter 9, memory management, paging, segmentation
• Week 13: Chapter 10, virtual memory
• Week 14: file management

The tentative schedule ends with memory and file management and does not list the later parts. Some of its topic labels, such as segmentation under Chapter 9, read like earlier-edition headings. As noted above, the tenth edition has removed segmentation from that chapter, so use the course's lecture notes for that topic.

Colorado State University, CS370 Operating Systems (Fall 2024). CSU assigns the 10th edition through the Wiley e-text package (ISBN-13 978-1119127482). Its syllabus page focuses on grading and prerequisites rather than a week-by-week chapter list, so it gives no reading order.

UT Dallas, CS/SE 4348 HON (Fall 2024). UTD lists the ninth edition (ISBN 978-1-118-06333-0). Its listed topics are process management, memory, virtual memory, I/O, file systems, critical sections and deadlocks. Ninth-edition chapter numbers do not line up with the tenth edition's, so if you are in a course like this one, map assigned topics to the tenth-edition chapters by subject rather than by number.

Focused reading and edition boundary

The exercise below uses the companion problem. Read its assumptions and data before answering.

Reading route: Tenth edition, 2018: the process/thread and synchronization chapters, plus memory-management sections as your course requires.

Try before continuing: Compare mutual exclusion, ordering and progress as three different requirements for the worksheet.

Checkpoint: A mutex can exclude overlapping updates without specifying which update happens first or guaranteeing a scheduling policy.

Edition and access: The edition listed here (ISBN 9781119320913) is Wiley's e-text, the same ISBN the Oklahoma course above assigns. Other tenth-edition bundles and print companions have different ISBNs; the Colorado State course's e-text package, for example, uses 978-1119127482. Some 2024 courses still assign the ninth edition (978-1-118-06333-0). Get the version your course assigns.

Publisher page (Wiley)