Operating System Concepts / Edition 9

by Abraham Silberschatz, Peter B. Galvin, Greg Gagne

Overview

The ninth edition of Operating System Concepts continues to evolve to provide a solid theoretical foundation for understanding operating systems. This edition has been updated with more extensive coverage of the most current topics and applications, improved conceptual coverage and additional content to bridge the gap between concepts and actual implementations. A new design allows for easier navigation and enhances reader motivation. Additional end-of-chapter, exercises, review questions, and programming exercises help to further reinforce important concepts. WileyPLUS, including a test bank, self-check exercises, and a student solutions manual, is also part of the comprehensive support package.

Product Details

ISBN-13:	9781118063330
Publisher:	Wiley
Publication date:	12/17/2012
Edition description:	New Edition
Pages:	976
Product dimensions:	7.00(w) x 10.10(h) x 1.40(d)

About the Author

Abraham Silberschatz is the Sidney J. Weinberg Professor of Computer Science at Yale University. Prior to joining Yale, he was the Vice President of the Information Sciences Research Center at Bell Laboratories. Prior to that, he held a chaired professorship in the Department of Computer Sciences at the University of Texas at Austin. His research interests include database systems, operating systems, storage systems, and network management.
Professor Silberschatz is a Fellow of the Association of Computing Machinery (ACM), a Fellow of Institute of Electrical and Electronic Engineers (IEEE), a Fellow of the American Association for the Advancement of Science (AAAS), and a member of the Connecticut Academy of Science and Engineering. He received the 2002 IEEE Taylor L. Booth Education Award, the 1998 ACM Karl V. Karlstrom Outstanding Educator Award, and the 1997 ACM SIGMOD Contribution Award. In recognition of his outstanding level of innovation and technical excellence, he was awarded the Bell Laboratories President's Award for three different Projects –– the QTM Project (1998), the DataBlitz Project (1999), and the NetInventory Project (2004).
Professor Silberschatz' writings have appeared in numerous ACM and IEEE publications and other professional conferences and journals. He is a coauthor of the textbook Database System Concepts. He has also written Op-Ed articles for the New York Times, the Boston Globe, and the Hartford Courant, among others.

Peter Baer Galvin is the chief solutions architect for Pluribus Networks (www.pluribusnetworks.com). Previously he was the CTO for the systems integrator Corporate Technologies, and a lecturer at Boston University. He has also been a columnist for ;login:, SunWorld, and SysAdmin magazines, and has written articles for Byte and other magazines. Mr. Galvin blogs for anewdomain.net and byte.com. As a consultant and trainer, he has given talks and tutorials on security and system administration worldwide.

Greg Gagne is chair of the Computer Science department at Westminster College in Salt Lake City where he has been teaching since 1990. In addition to teaching operating systems, he also teaches computer networks, parallel programming, and software engineering. He has made presentations at educational conferences and also provides workshops to industry professionals. Professor Gagne was the recipient of the Shaw Faculty Publication Prize in 2007.

Read an Excerpt

Chapter 3: Operating-System Structures

3.6.1 Implementation

Although the virtual machine concept is useful, it is difficult to implement. Much effort is required to provide an exact duplicate of the underlying machine. Remember that the underlying machine has two modes: user mode and monitor mode. The virtual-machine software can run in monitor mode, since it is the operating system. The virtual machine itself can execute in only user mode. Just as the physical machine has two modes, however, so must the virtual machine. Consequently, we must have a virtual user mode and a virtual monitor mode, both of which run in a physical user mode. Those actions that cause a transfer from user mode to monitor mode on a real machine (such as a system call or an attempt to execute a privileged instruction) must also cause a transfer from virtual user mode to virtual monitor mode on a virtual machine.

This transfer can generally be done fairly easily. When a system call, for example, is made by a program running on a virtual machine, in virtual user mode, it will cause a transfer to the virtual-machine monitor in the real machine. When the virtual-machine monitor gains control, it can change the register contents and program counter for the virtual machine to simulate the effect of the system call. It can then restart the virtual machine, noting that it is now in virtual monitor mode. If the virtual machine then tries, for example, to read from its virtual card reader, it will execute a privileged I/O instruction. Because the virtual machine is running in physical user mode, this instruction will trap to the virtual-machine monitor. The virtual-machine monitor must then simulate the effect of the I/O instruction. First, it finds the spooled file that implements the virtual card reader. Then, it translates the read of the virtual card reader into a read on the spooled disk file, and transfers the next virtual "card image" into the virtual memory of the virtual machine. Finally, it can restart the virtual machine. The state of the virtual machine has been modified exactly as though the I/O instruction had been executed with a real card reader for a real machine executing in a real monitor mode.

The major difference is, of course, time. Whereas the real I/O might have taken 100 milliseconds, the virtual I/O might take less time (because it is spooled) or more (because it is interpreted). In addition, the CPU is being multiprogrammed among many virtual machines, further slowing down the virtual machines in unpredictable ways. In the extreme case, it may be necessary to simulate all instructions to provide a true virtual machine. VM works for IBM machines because normal instructions for the virtual machines can execute directly on the hardware. Only the privileged instructions (needed mainly for I/O) must be simulated and hence execute more slowly.

3.6.2 Benefits

The virtual-machine concept has several advantages. Notice that in this environment there is complete protection of the various system resources. Each virtual machine is completely isolated from all other virtual machines, so there are no security problems. On the other hand, there is no direct sharing of resources. To provide sharing, two approaches have been implemented. First, it is possible to share a minidisk. This scheme is modeled after a physical shared disk, but is implemented by software. With this technique, files can be shared. Second, it is possible to define a network of virtual machines, each of which can send information over the virtual communications network. Again, the network is modeled after physical communication networks, but is implemented in software.

Such a virtual-machine system is a perfect vehicle for operating-systems research and development. Normally, changing an operating system is a difficult task. Because operating systems are large and complex programs, it is difficult to be sure that a change in one point will not cause obscure bugs in some other part. This situation can be particularly dangerous because of the power of the operating system. Because the operating system executes in monitor mode, a wrong change in a pointer could cause an error that would destroy the entire file system. Thus, it is necessary to test all changes to the operating system carefully.

The operating system, however, runs on and controls the entire machine. Therefore, the current system must be stopped and taken out of use while changes are made and tested. This period is commonly called system-development time. Since it makes the system unavailable to users, system-development time is often scheduled late at night or on weekends, when system load is low.

A virtual-machine system can eliminate much of this problem. System programmers are given their own virtual machine, and system development is done on the virtual machine, instead of on a physical machine. Normal system operation seldom needs to be disrupted for system development.

Virtual machines are coming back into fashion as a means of solving system compatibility problems. For instance, there are thousands of programs available for MS-DOS on Intel CPU-based systems. Computer vendors like Sun Microsystems and Digital Equipment Corporation (DEC) use other, faster processors, but would like their customers to be able to run these MS-DOS programs. The solution is to create a virtual Intel machine on top of the native processor. An MS-DOS program is run in this environment, and its Intel instructions are translated into the native instruction set. MS-DOS is also run in this virtual machine, so the program can make its system calls as usual. The net result is a program which appears to be running on an Intel-based system but is really executing on a very different processor. If the processor is sufficiently fast, the MS-DOS program will run quickly even though every instruction is being translated into several native instructions for execution. Similarly, the PowerPC-based Apple Macintosh includes a Motorola 68000 virtual machine to allow execution of binaries that were written for the older 68000-based Macintosh.

3.6.3 Java

Another example of the continued utility of virtual machines involves the Java language. Java is a very popular language designed by Sun Microsystems. Java is implemented by a compiler that generates bytecode output. These bytecodes are the instructions that run on the Java Virtual Machine (JVM). For Java programs to run on a platform, that platform must have a JVM running on it. The JVM runs on many types of computer, including IBM-Compatible PC, Macintosh, Unix workstation and server, and IBM minicomputer and mainframe. The JVM is also implemented within web browsers such as Microsoft Internet Explorer and Netscape Communicator. These browsers, in turn, run on top of varying hardware and operating systems. The JVM is also implemented on the small JavaOS, which implements the JVM directly on hardware to avoid the overhead imposed by running Java on general-purpose operating systems. Finally, single-purpose devices such as cellular phones can be implemented via Java through the use of microprocessors that execute Java bytecodes as native instructions.

The Java Virtual Machine implements a stack-based instruction set that includes the expected arithmetic, logical, data movement, and flow control instructions. Because it is a virtual machine, it can also implement instructions that are too complex to be built in hardware, including object creation, manipulation, and method invocation instructions. Java compilers can simply emit these bytecode instructions, and the JVM must implement the necessary functionality on each platform.

The design of Java takes advantage of the complete environment that a virtual machine implements. For instance, the bytecodes are checked for instructions that could compromise the security or reliability of the underlying machine. The Java program is not allowed to run if it fails this check. Through the implementation of Java as a language that executes on a virtual machine, Sun has created an efficient, dynamic, secure, and portable object-oriented facility. Although Java programs are not as fast as programs that compile to the native hardware instruction set, they nevertheless are more efficient than interpreted programs and have several advantages over native-compilation languages such as C.

3.7.0 System Design and Implementation

In this section, we discuss the problems of designing and implementing a system. There are, of course, no complete solutions to the design problems, but there are approaches that have been successful.

3.7.1 Design Goals

The first Problem in designing a system is to define the goals and specifications of the system. At the highest level, the design of the system will be affected.....

Table of Contents

Chapter 1: Introduction

Chapter 2: Operating-System Structures

Chapter 3: Processes

Chapter 4: Threads

Chapter 5: CPU Scheduling

Chapter 6: Process Synchronization

Chapter 7: Deadlocks

Chapter 8: Main Memory

Chapter 9: Virtual Memory

Chapter 10: File-System Interface

Chapter 11: File-System Implementation

Chapter 12: Mass-Storage Structure

Chapter 13: I/O Systems

Chapter 14: Protection

Chapter 15: Security

Chapter 16: Distributed System Structures

Chapter 17: Real-Time Systems

Chapter 18: The Linux System

Chapter 19: Windows 7®

Chapter 20: Influential Operating Systems

Appendices