Addison-Wesley
Operating Systems, 2e
By Gary NuttVisit aw.comFind Your Rep
Contact Us Publish With Us Customer Service
What's New in 3rd Edition Companion Website About The Book About The Author Table of Contents Excerpts Instructor Supplements Request an Exam Copy Ordering Information

Table of Contents

PREFACE
To the Student
Topic Order
To the Instructor
About the Laboratory Environment
Acknowledgements
Changes in the Second Edition
Changes in the Third Edition
1. INTRODUCTION
1.1 Computers and Software
General System Software; Resource Abstraction; Example: An Abstraction of a Disk Drive; Resource Sharing
1.2 Operating System Strategies
Batch Systems; Example: Batch Files; Timesharing Systems; Example: The UNIX Timesharing System; Personal Computers and Workstations; Example: The Microsoft Windows OS Family; Embedded Systems; Example: VxWorks; Small, Communicating Computers; Example: Windows CE (Pocket PC); Networks; The Genesis of Modern Operating Systems
1.3 Summary
1.4 Exercises

2. USING THE OPERATING SYSTEM
2.1 The Programmer's Abstract Machine
Sequential Computation; Multithreaded Computation
2.2 Resources
Using Files; Example: POSIX Files; Example: Windows Files; Using Other Resources
2.3 Processes and Threads
Creating Processes and Threads; Example: Using FORK(), JOIN(), and QUIT()
2.4 Writing Concurrent Programs
Multiple Single-Threaded Processes: The UNIX Model; Example: Executing Commands in UNIX; Multiple Processes and Multiple Threads Per Process: The Windows Model; Example: Launching Windows Processes
2.5 Objects
2.6 Summary
2.7 Exercises
Lab Exercise: A Simple Shell
Background
Attaching the Problem
Lab Exercise: A Multithreaded Application
Background
Attacking the Problem

3. OPERATING SYSTEM ORGANIZATION
3.1 Basic Functions
Device Management; Process, Thread and Resource Management; Memory Management; File Management
3.2 General Implementation Considerations
Performance; Exclusive Use of Resources; Processor Modes; Kernels; Requesting Services from the Operating System; Software Modularization
3.3 Contemporary OS Kernels
UNIX Kernels; Example: Linux; The Windows NT Executive and Kernel
3.4 Summary
3.5 Exercises
Lab Exercise: Observing OS Behavior
Background
Attacking the Problem

4. COMPUTER ORGANIZATION
4.1 The von Neumann Architecture
Evolving to the von Neumann Architecture; The Basic Idea
4.2 The Central Processing Unit
The Arithmetical-Logical Unit; The Control Unit; Implementing the Processor
4.3 The Primary (Executable) Memory
4.4 I/O Devices
Device Controllers; Direct Memory Access; Memory-mapped I/O
4.5 Interrupts
The Trap Instruction Revisited
4.6 Conventional Contemporary Computers
Bootstrapping the Machine
4.7 Mobile Computers
System-on-a-Chip Technology; Power Management; Example: The Itsy Mobile Computer
4.8 Multiprocessors and Parallel Computers
Parallel Instruction Execution; Array Processors; Shared Memory Multiprocessors; Distributed Memory Multiprocessors; Network of Workstations
4.9 Summary
4.10 Exercises

5. DEVICE MANAGEMENT
5.1 The I/O System
Device Manager Abstraction; I/O-Processor Overlap within an Application; I/O-Processor Overlap Across Threads
5.2 I/O Strategies
Direct I/O with Polling; Interrupt-driven I/O; Polling Versus Interrupt-Driven I/O Performance
5.3 Device Manager Design
Device Independent Driver Framework; Servicing Interrupts; Example: Linux Device I/O
5.4 Buffering
5.5 Device Class Characteristics
Communication Devices; Example: Asynchronous Serial Devices; Sequentially Accessed Storage Devices; Example: Traditional Magnetic Tape; Randomly Accessed Storage Devices; Example: Magnetic Disk; Performance: Optimizing Access on Magnetic Disks; Example: CD-ROM and DVD
5.6 Summary
5.7 Exercises
Lab Exercise: A Floppy Disk Driver
Part A
Part B
Part C
Background
Attacking the Problem

Back To TOP
6. IMPLEMENTING PROCESSES, THREADS, AND RESOURCES
6.1 The Task at Hand
The Abstract Machine for Classic Processes; Supporting Modern Processes and Threads; Resources; The Process Address Space; OS Families; Process Manager Responsibilities
6.2 The Hardware Process
6.3 The Abstract Machine Interface
6.4 The Process Abstraction
Example: Linux Process Descriptor; Example: Windows NT/2000/XP Process Descriptors
6.5 The Thread Abstraction
Example: Linux Thread Descriptor; Example: Windows NT/2000/XP Thread Descriptors
6.6 State Diagrams
Example: UNIX State Diagram
6.7 Resource Managers
6.8 Generalizing Process Management Policies
Refining the Process Manager; Specializing Resource Allocation Strategies
6.9 Summary
6.10 Exercises
LAB EXERCISE 1: Kernel Timers
Background
Attacking the Problem
Lab Exercise 2: Manipulating Kernel Objects
Background
Attacking the Problem

7. SCHEDULING
7.1 Overview
7.2 Scheduling Mechanisms
The Process Scheduler Organization; Saving the Context; Voluntary CPU Sharing; Involuntary CPU Sharing; Performance
7.3 Strategy Selection
Scheduler Characteristics; A Model to Study Scheduling; Analysis: Partitioning a Process into Small Processes
7.4 Nonpreemptive Strategies
Analysis: Approximating System Load; First-Come-First-Served; Analysis: Predicting Wait Times for FCFS; Shortest Job Next; Priority Scheduling; Deadline Scheduling
7.5 Preemptive Strategies
Round Robin; Multiple-level Queues
7.6 Implementing the Scheduler
Example: The Linux Scheduling Mechanism; Example: BSD UNIX Scheduling Policy; Example: Windows NT/2000/XP Thread Scheduling
7.7 Summary
7.8 Exercises
Lab Exercise: Analyzing the Round Robin Scheduling
Background
Attacking the Problem

8. BASIC SYNCHRONIZATION PRINCIPLES
8.1 Cooperating Processes
Critical Sections; Deadlock; Resource Sharing
8.2 Evolving from the Classic Solution
8.3 Semaphores: The Basis of Modern Solutions
Principles of Operation; Example: Using Semaphores; Practical Considerations
8.4 Synchronization in Shared Memory Multiprocessors
8.5 Summary
8.6 Exercises
Lab Exercise: Bounded Buffer Problem
Background
Attacking the Problem

9. HIGH-LEVEL SYNCHRONIZATION AND INTERPROCESS COMMUNICATION
9.1 Alternative Synchronization Primitives
AND Synchronization; Example: Using AND Synchronization to Solve the Dining Philosphers Problem; Events; Example: Using Generic Events; Example: Windows NT/2000/XP Dispatcher Objects
9.2 Monitors
Principles of Operation; Condition Variables; Example: Using Monitors; Some Practical Aspects of Using Monitors
9.3 Interprocess Communication
The Pipe Model; Message Passing Mechanisms; Mailboxes; Message Protocols; Using the send() and receive() Operations; Example: Synchronized IPC; Deferred Message Copying
9.4 Summary
9.5 Exercises
Lab Exercise: Using Pipes
Background
Attacking the Problem
Lab Exercise: Refining the Shell
Background
Attacking the Problem

10. DEADLOCK
10.1 Background
Prevention; Avoidance; Detection and Recovery; Manual Deadlock Management
10.2 A System Deadlock Model
Example: Single Resource Type
10.3 Prevention
Hold and Wait; Circular Wait; Allowing Preemption
10.4 Avoidance
The Banker's Algorithm; Example: Using the Banker's Algorithm
10.5 Detection and Recovery
Serially Reusable Resources; Example: Serially Reusable Resource Graphs; Consumable Resources; General Resource Systems; Recovery
10.6 Summary
10.7 Exercises

Back To TOP
11. MEMORY MANAGEMENT
11.1 The Basics
11.2 The Address Space Abstraction
Managing the Address Space; Example: Static Address Binding; Dynamic Memory for Data Structures; Modern Memory Binding
11.3 Memory Allocation
Fixed-partition Memory Strategies; Variable-partition Memory Strategies; Analysis: The Cost of Moving Programs; Contemporary Allocation Strategies
11.4 Dynamic Address Space Binding; Runtime Bound Checking: The Isolation Mechanism
11.5 Modern Memory Manager Strategies
Swapping 328; Virtual Memory; Example: Using Cache Memory; Shared-memory Multiprocessors
11.6 Summary
11.7 Exercises
Lab Exercise: Using Shared Memory
Background
Attacking the Problem

12. VIRTUAL MEMORY
12.1 The Task at Hand
12.2 Address Translation
Address Space Mapping; Segmentation and Paging
12.3 Paging
Paging Virtual Address Translation; Example: Contemporary Page Table Implementations
12.4 Static Paging Algorithms
The Fetch Policy; Demand Paging Algorithms; Stack Algorithms; Implementing LRU; Paging Performance
12.5 Dynamic Paging Algorithms
The Working Set Algorithm; Example: Working Set Algorithm; Implementing the Working Set Algorithm; Performance Consideration: Taking Advantage of Paging with IPC; Example: Windows NT/2000 Virtual Memory; Example: Linux Virtual Memory
12.6 Segmentation
Address Translation; Implementation; Example: The Multics Segmentation System
12.7 Memory-mapped Files
12.8 Summary
12.9 Exercises
Lab Exercise: Memory-mapped Files
Background
Attacking the Problem

13. FILE MANAGEMENT
13.1 The Task at Hand
13.2 Files
Low-level Files; Structured Files; Database Management Systems; Multimedia Storage
13.3 Low-level File Implementations
The open() and close() Operations; Example: UNIX open and close; Block Management; Example: UNIX File Structure; Example: The DOS FAT File System; Reading and Writing the Byte Stream
13.4 Supporting High-level File Abstractions
Structured Sequential Files; Indexed Sequential Files; Database Management Systems; Multimedia Documents
13.5 Directories
Directory Structures; Example: Some Directory Approaches
13.6 Implementing Directories
Directory Entries; Opening a File
13.7 File Systems
Example: The ISO 9660 File System; Mounting File Systems; Heterogeneous File Systems
13.8 Summary
13.9 Exercises
Lab Exercise: A Simple File Manager
Background
Attacking the Problem

14. PROTECTION AND SECURITY
14.1 The Problem
The Goal; Policy and Mechanism; Context for Protection and Security; The Cost of Protection Mechanisms
14.2 Authentication
External User Authentication; Example: Windows NT/2000/XP User Authentication; Internal Thread/Process Authentication; Authentication in the Network; Software Authentication
14.3 Authorization
Ad Hoc Authorization Mechanisms; A General Model for Authorization; Implementing Security Policies; Implementing General Authorization Mechanisms; Protection Domains; Implementing the Access Matrix
14.4 Cryptography
The Big Picture; Private Key Encryption; Public Key Encryption; Example: PGP Encryption; Internet Content Delivery
14.5 Summary
14.6 Exercises

15. NETWORKS
15.1 From Computer Communications to Networks
Switched Networks; Network Hardware Requirements; Network Software Requirements
15.2 The ISO OSI Network Architecture Model
The Evolution of Network Protocols; The ISO OSI Model
15.3 Media Access Control (MAC) Protocols
The Physical Layer; SIDEBAR: Fast Physical Layers; The Data Link Layer; Contemporary Networks
15.4 The Network Layer
Internet Addresses; Routing; Using the Network Layer; Sidebar box: Latency in the Internet
15.5 The Transport Layer
Communication Ports; Data Types; Reliable Communication; Performance Considerations: Datagrams and Virtual Circuits
15.6 Using the Transport Layer
Naming and Addresses; Example: The Domain Name Service; The Client-server Model
15.7 Network Security
Transport Layer Security: Firewalls; Network Layer Security: IPsec
15.8 Summary
15.9 Exercises
Lab Exercise: Using TCP/IP
Background
Attacking the Problem

Back To TOP
16. REMOTE FILES
16.1 Sharing Information Across the Network
Explicit File Copying Systems; A Seamless File System Interface; Distributing the Work
16.2 Remote Disk Systems
Remote Disk Operation; Performance Considerations; Reliability; The Future of Remote Disks
16.3 Remote File Systems
The General Architecture; Block Caching; Crash Recovery
16.4 File-level Caching
The Andrew File System; The LOCUS File System
16.5 Directory Systems and Their Implementations
Filenames; Opening a File
16.6 Summary
16.7 Exercises

17. DISTRIBUTED COMPUTING
17.1 Distributed OS Mechanisms
17.2 Distributed Primary Memory
Remote Memory; Example: The Linda Programming Language; Distributed Shared Memory
17.3 Remote Procedure Call
How Does RPC Work?; Implementing RPC
17.4 Remote Objects
17.5 Distributing Process Management
General Process Management; Process and Thread Creation; Scheduling; Migration and Load Balancing; Distributed Synchronization
17.6 Summary
17.7 Exercises
Lab Exercise: Using Remote Procedure Cal
Background
Attacking the Problem

18. DISTRIBUTED PROGRAMMING RUNTIME SYSTEMS
18.1 Supporting Distributed Software with Middleware
18.2 Classic Distributed Application Programs
18.3 Middleware Support for Classic Distributed Programming
PVM; The Beowulf Cluster Computing Environment; The OSF Distributed Computing Environment
18.4 Distributed Programming on the Web
18.5 Middleware Support for Mobile Code
Java and the Java Virtual Machine; The ECMA-335 Common Language Infrastructure
18.6 Summary
18.7 Exercises

19. DESIGN STRATEGIES
19.1 Design Considerations
Performance, Performance, Performance; Trusted Software; Modularization; Portability
19.2 Monolithic Kernels
Example: MS-DOS; Example: The UNIX Kernel
19.3 Modular Organization
Example: Choices: An Object-oriented OS
19.4 Extensible Nucleus, or Microkernel, Organization
Example: The Mach Operating System
19.5 Layered Organizations
19.6 Operating Systems for Distributed Systems
Network Operating Systems; Example: BSD UNIX; Distributed Operating Systems; Example: The CHORUS Operating System
19.7 Summary
19.8 Exercises

20. THE LINUX KERNEL
20.1 The Linux Kernel
20.2 Kernel Organization
Using Kernel Services; Daemons; Starting the Kernel; Control Flow in the Machine
20.3 Modules and Device Management
Module Organization; Module Installation and Removal
20.4 Process and Resource Management
Running the Process Manager; Creating a New Task; IPC and Synchronization; The Scheduler
20.5 Memory Manager
The Virtual Address Space; The Page Fault Handler
20.6 File Management
20.7 Summary

21. THE WINDOWS NT/2000XP KERNEL
21.1 Introduction
21.2 The NT Kernel
Objects; Threads; Multiprocess Synchronization; Traps, Interrupts, and Exceptions
21.3 The NT Executive
Object Manager; Process and Thread Manager; Virtual Memory Manager; I/O Manager; The Cache Manager
21.4 Kernel Local Procedure Calls and IPC
The Native API
21.5 Subsystems
21.6 Summary

GLOSSARY

BIBLIOGRAPHY

INDEX
Back To TOP

 

Download the Table of Contents (136K) from Operating Systems, Third Edition in Adobe® PDF format.

Note: This is an Adobe® Acrobat® file. Download the free PDF reader by clicking on the button below:

Get Adobe Acrobat Reader - click here!
Copyright 2004. Addison-Wesley Higher Education Group, a division of Pearson Education, a Pearson plc company. All rights reserved. Legal disclaimer. E-mail webmaster@awl.com