Skip to main content


Operating Systems In Depth: Design and Programming

Thomas W. Doeppner

ISBN: 978-0-470-57131-6 December 2010 444 Pages


This book is designed for a one-semester operating-systems course for advanced undergraduates and beginning graduate students. Prerequisites for the course generally include an introductory course on computer architecture and an advanced programming course.

The goal of this book is to bring together and explain current practice in operating systems. This includes much of what is traditionally covered in operating-system textbooks: concurrency, scheduling, linking and loading, storage management (both real and virtual), file systems, and security. However, the book also covers issues that come up every day in operating-systems design and implementation but are not often taught in undergraduate courses. For example, the text includes:

  • Deferred work, which includes deferred and asynchronous procedure calls in Windows, tasklets in Linux, and interrupt threads in Solaris.
  • The intricacies of thread switching, on both uniprocessor and multiprocessor systems.
  • Modern file systems, such as ZFS and WAFL.
  • Distributed file systems, including CIFS and NFS version 4.

The book and its accompanying significant programming projects make students come to grips with current operating systems and their major operating-system components and to attain an intimate understanding of how they work.

Related Resources

1 Introduction.

1.1 Operating Systems.

1.2 A Brief History of Operating Systems.

1.3 A Simple OS.

1.4 Beyond a Simple OS.

1.5 Conclusions.

1.6 Exercises.

1.7 References.

2 Multithreaded Programming.

2.1 Why Threads?

2.2 Programming with Threads.

2.3 Conclusions.

2.4 Exercises.

2.5 References.

3 Basic Concepts.

3.1 Context Switching.

3.2 Input/Output Architectures.

3.3 Dynamic Storage Allocation.

3.4 Linking and Loading.

3.5 Booting.

3.6 Conclusions.

3.7 Exercises.

3.8 References.

4 Operating-System Design.

4.1 A Simple System.

4.2 Rethinking Operating-System Structure.

4.3 Conclusions.

4.4 Exercises.

4.5 References.

5 Processor Management.

5.1 Threads Implementations.

5.2 Interrupts.

5.3 Scheduling.

5.4 Conclusions.

5.5 Exercises.

5.6 References.

6 File Systems.

6.1 The Basics of File Systems.

6.2 Crash Resiliency.

6.3 Directories and Naming.

6.4 Multiple Disks.

6.5 Flash Memory.

6.6 Case Studies.

6.7 Conclusions.

6.8 Exercises.

6.9 References.

7 Memory Management.

7.1 Memory Management in the Early Days.

7.2 Hardware Support for Virtual Memory.

7.3 Operating-System Issues.

7.4 Conclusions.

7.5 Exercises.

7.6 References.

8 Security.

8.1 Security Goals.

8.2 Security Architectures.

8.3 Conclusions.

8.4 Exercises.

8.5 References.

9 Introduction to Networking.

9.1 Network Basics.

9.2 Remote Procedure Call Protocols.

9.3 Conclusions.

9.4 Exercises.

9.5 References.

10 Distributed File Systems.

10.1 The Basics.

10.2 NFS Version 2.

10.3 Common Internet File System (CIFS).

10.4 DFS.

10.5 NFS Version 4.

10.6 Conclusions.

10.7 Exercises.

10.8 References.

Appendix URL Index.



  • Rigorous but concise coverage of Operating Systems designed for a course for CS majors who will work in the computer-systems area (as opposed to a course on the basics of operating systems that every CS major should know.)
  • A variety of accompanying projects help students attain an intimate understanding of how the major operating-systems components work. These include a relatively straightforward project that involves writing a user-level threads library, a file-system cache manager, and a simple file system. The second, for the truly interested, gung-ho students, is to implement a good portion of a simple but fully functional operating system. (Those portions that are not pedagogically useful for students to write are provided to them.) Source code and written handouts are available at the book’s website
  • Organization of Table of Contents helps make a comprehensive programming project possible. For example, Chapter 2 provides a full tutorial on how to write multithreaded programs, both using POSIX threads and Windows threads. Though the material covers such programming from an application-program perspective, both the concepts and the practice apply to programming within an operating system.
  • Three types of end-of-chapter exercises provide plenty of practice. These include unstarred, starred, and two-starred problems that range from quick and easy review to challenging, exam type problems.