Every time you open an app, save a file, stream a video, or load a web page, an operating system is at work beneath you - scheduling the processor among dozens of programs, parcelling out memory, shuttling data to and from disks and networks, and keeping every program walled off from every other so that one misbehaving process cannot bring down the rest. It is the most consequential piece of software on any computer, and also the most invisible: it succeeds precisely by going unnoticed. This book is an invitation to look beneath that surface and understand, concretely and in depth, how the machinery actually works.
The subtitle - Principles, Internals & Practice - states the book's intent. Many treatments of operating systems stop at principles: the enduring ideas of processes, scheduling, virtual memory, concurrency, and protection. Those ideas are essential, and they anchor every chapter here. But ideas alone leave a gap between understanding what an operating system does and understanding how it is built. So this book also pursues the internals - the data structures, algorithms, and hardware mechanisms that turn principles into running systems - and the practice of seeing those mechanisms at work in real software. The goal throughout is not merely to describe an operating system, but to explain it well enough that you could reason about, or even begin to build, one yourself.
A conviction runs through these pages: that operating systems are best learned through concrete, worked detail. It is one thing to be told that the shortest-job-first algorithm minimizes average waiting time, and quite another to schedule a specific set of processes by hand and compute that the average wait falls from 10.25 to 7.00 milliseconds. So the book works such examples in full - tracing the Banker's algorithm to a safe sequence, replaying a reference string to expose Belady's anomaly, computing total head movement for every disk-scheduling discipline, and demonstrating exactly why a task set that defeats rate-monotonic scheduling is still feasible under earliest-deadline-first. Every numerical claim is something you can reproduce, and the end-of-chapter problems ask you to do precisely that.
How This Book Is OrganizedThe twenty chapters proceed in six parts, each building on the last.
Part I lays the foundations - what an operating system is and how it is structured.
Part II is the heart of the subject: processes and threads, CPU scheduling, synchronization, and deadlocks.
Part III develops memory management, from contiguous allocation through paging to virtual memory.
Part IV turns to storage and I/O - disks and disk scheduling, file systems and their implementation, and the I/O subsystem.
Part V covers protection and security. And
Part VI explores advanced and contemporary topics - virtualization and containers, distributed systems, real-time and embedded systems, and multiprocessor and multicore architectures - before a closing chapter of
case studies that traces every principle in the book through the real architectures of Linux, Windows, UNIX, and Android. Appendices on C systems programming, a reference of the key algorithms and formulas, a bank of exam and interview questions, and a glossary round out the volume.
