操作系统：原理与实践概览

5星 · 超过95%的资源需积分: 34 149 浏览量更新于2024-07-22 8 收藏 22.42MB PDF 举报

"Operating Systems: Principles and Practice" 是一本由Thomas Anderson和Michael Dahlin编著的教科书，被美国的伯克利、卡内基梅隆等知名高校广泛使用，深入介绍了操作系统的基本原理和实践应用。正文：本书旨在探讨操作系统的核心概念与实践，为读者提供操作系统设计和实现的全面理解。书中内容丰富，涵盖了操作系统的历史、基本结构、内核、编程接口、并发处理等多个方面。在第一章"Introduction"中，作者引入了操作系统的定义，阐述了操作系统作为计算机系统管理者的角色，以及如何通过操作系统实现硬件资源的管理和软件服务的提供。同时，这一章还讨论了评估操作系统性能的各种标准，并回顾了操作系统的发展历程。第二章"The Kernel Abstraction"主要关注操作系统的内核，它是系统的核心部分，负责管理进程、内存、设备等。内核的概念、双模式操作（用户模式和内核模式）以及安全控制转移等关键概念被详细讲解。此外，本章通过实例分析了操作系统内核的启动过程和虚拟机的实现。第三章"The Programming Interface"探讨了操作系统提供的编程接口，包括进程管理、输入/输出控制等。作者展示了如何实现一个简单的Shell，以及如何进行进程间通信，同时还讨论了操作系统结构的不同层次和未来可能的发展方向。第四章"Concurrency and Threads"深入到并发处理和线程的主题，解释了线程作为并发执行单元的概念及其接口。章节中不仅给出了简单的API示例，还解析了线程的内部工作原理及其实现方式，为读者提供了对并发编程更深层次的理解。整本书内容详尽，理论与实践相结合，对于想要深入了解操作系统设计原理和技术的学生或专业人士来说是一份宝贵的参考资料。每个章节结尾处的"Conclusion and future directions"部分，不仅总结了章节内容，还对未来的研究方向给出了展望，引导读者进一步探索操作系统领域的前沿问题。

5 CHAPTER 1. INTRODUCTION

Operating System

Hardware

Figure 1.2: A general-purpose operating system

hijacking control of your car’s computers? Although this might seem far fetched,

researchers recently demonstrated that they could remotely turn oﬀ a car’s

braking system through a computer virus introduced into the car’s computers

through a hacked car radio. A goal of this book is to explain how to build more

reliable and secure computer systems in a variety of contexts.

For general-purpose systems, users interact with applications, applications

execute in an environment provided by the operating system, and the operating

system mediates access to the underlying hardware (Figure 1.2, and expanded

in Figure 1.3). What do we need from an operating system to be able to run a

group of programs? Operating systems have three roles:

• Operating systems play referee — they manage shared resources between

diﬀerent applications running on the same physical machine. For example,

an operating system can stop one program and start another. Operating

systems isolate diﬀerent applications from each other, so that if there is

a bug in one application, it does not corrupt other applications running

on the same machine. The operating system must protect itself and other

applications from malicious computer viruses. And since the applications

1.1. What is an operating system? 6

An Expanded View of an Operating System

Figure 1.3 shows the structure of a general-purpose operating system, as an expan-

sion on the simple view presented in Figure 1.2. At the lowest level, the hardware pro-

vides processor, memory, and a set of devices for providing the user interface, storing

data and communicating with the outside world. The hardware also provides primi-

tives that the operating system can use to provide fault isolation and synchronization.

The operating system runs as the lowest layer of software on the computer, with a

device-speciﬁc layer interfaces to the myriad hardware devices, and a set of device-

independent services provided to applications. Since the operating system needs to be

able to isolate malicious and buggy applications from affecting other applications or the

operating system itself, much of the operating system runs in a separate execution en-

vironment protected from application code. A portion of the operating system can also

run as a library linked into each application. In turn, applications run in an execution

context provided by the operating system. The application context is much more than

a simple abstraction on top of hardware devices: applications execute in a virtual envi-

ronment that is both more constrained (to prevent harm), more powerful (to mask hard-

ware limitations), and more useful (via common services), than the underlying hardware.

are sharing physical resources, the operating system needs to decide which

applications get which resources.

• Operating systems play illusionist — they provide an abstraction phys-

ical hardware to simplify application design. To write a “hello world”

program, you do not need (or want!) to think about how much physical

memory the system has, or how many other programs might be sharing

the computer’s resources. Instead, operating systems provide the illusion

of a nearly inﬁnite memory, as an abstraction on top of a limited amount

of physical memory. Likewise, operating systems provide the illusion that

each program has the computer’s processors entirely to itself. Obviously,

the reality is quite diﬀerent! These illusions enable applications to be

written independently of the amount of physical memory on the system

or the physical number of processors. Because applications are written to

a higher level of abstraction, the operating system is free to change the

amount of resources assigned to each application as applications start and

stop.

• Operating systems provide glue — a set of common services between appli-

cations. An important beneﬁt of common services is to facilitate sharing

between applications, so that, for example, cut and paste works uniformly

across the system and a ﬁle written by one application can be read by

another. Many operating systems provide a common set of user interface

routines to help applications provide a common “look and feel.” Perhaps

most importantly, operating systems provide a layer separating applica-

1.1. What is an operating system? 8

let me run another. Better, the operating system should allow multiple appli-

cations to run at the same time, as when I read email while I am downloading

a security patch to the system software.

Even individual applications can be designed to do multiple things at once.

For instance, a web server will be more responsive to its users if it can handle

multiple requests at the same time rather than waiting for each to complete

before the next one starts running. The same holds for the browser — it is

more responsive if it can start drawing a page while the rest of the page is

still being transferred. On multiprocessors, the computation inside a parallel

application can be split into separate units that can be run independently for

faster execution. The operating system itself is an example of software written

to be able to do multiple things at once. As we will describe later, the operating

system is a customer of its own abstractions.

Sharing raises several challenges for an operating system:

• Resource Allocation. The operating system must keep all of the simul-

taneous activities separate, allocating resources to each as appropriate. A

computer usually has only a few processors and a ﬁnite amount of memory,

network bandwidth, and disk space. When there are multiple tasks to do

at the same time, how should the operating system choose how many re-

sources to give to each? Seemingly trivial diﬀerences in how resources are

allocated can have a large impact on user-perceived performance. As we

will see later, if the operating system gives too little memory to a program,

it will not only slow down that particular program, it can dramatically

hurt the performance of the entire machine.

As another example, what should happen if an application executes an

inﬁnite loop:

while ( true ){

;

}

If programs ran directly on the raw hardware, this code fragment would

lock up the computer, making it completely non-responsive to user input.

With resource multiplexing provided by the operating system, the speciﬁc

application might lock up, but other programs can proceed unimpeded.

Additionally, the user can ask the operating system to force the looping

program to exit.

• Isolation. An error in one application should not disrupt other applica-

tions, or even the operating system itself. This is called fault isolation.Deﬁnition: fault isolation

Anyone who has taken an introductory computer science class knows the

value of an operating system that can protect itself and other applications

from programmer bugs. Debugging would be vastly harder if an error

9 CHAPTER 1. INTRODUCTION

in one program could corrupt data structures in other applications. Like-

wise, downloading and installing a screen saver or other application should

not crash other unrelated programs, nor should it be a way for a mali-

cious attacker to surreptitiously install a computer virus on the system.

Nor should one user be able to access or change another’s data without

permission.

Fault isolation requires restricting the behavior of applications to less than

the full power of the underlying hardware. Given access to the full capabil-

ity of the hardware, any application downloaded oﬀ the web, or any script

embedded in a web page, would have complete control of the machine.

Thus, it would be able to install spyware into the operating system to

log every keystroke you type, or record the password to every website you

visit. Without fault isolation provided by the operating system, any bug

in any program might cause the disk to become irretrievably corrupted.

Erroneous or malignant applications would cause all sorts of havoc.

• Communication. The ﬂip side of isolation is the need for communication

between diﬀerent applications and between diﬀerent users. For example, a

web site may be implemented by a cooperating set of applications: one to

select advertisements, another to cache recent results, yet another to fetch

and merge data from disk, and several more to cooperatively scan the web

for new content to index. For this to work, the various programs need

to be able to communicate with one another. If the operating systems

is designed to prevent bugs and malicious users and applications from

aﬀecting other users and their applications, how does the operating system

support communication to share results? In setting up boundaries, an

operating system must also allow for those boundaries to be crossed in

carefully controlled ways as the need arises.

In its role as a referee, an operating system is somewhat akin to that of a

government, or perhaps a particularly patient kindergarten teacher, balancing

needs, separating conﬂicts, and facilitating sharing. One user should not be

able to hog all of the system’s resources or to access or corrupt another user’s

ﬁles without permission; a buggy application should not be able to crash the

operating system or other unrelated applications; and yet applications also need

to be able to work together. Enforcing and balancing these concerns is the role

of the operating system.

Exercises

Take a moment to speculate. We will provide answers to these questions

throughout the rest of the book, but given what you know now, how would you

answer them? Before there were operating systems, someone needed to develop

solutions, without being able to look them up! How would you have designed

the ﬁrst operating system?

剩余468页未读，继续阅读

twentyfo

粉丝: 0
资源: 1

操作系统：原理与实践概览

Operating Systems Principles and Practice（1-4）.zip

Operating Systems Principles and Practice(2nd)

操作系统：原理与实践 第二卷

operating systems:principles and practice pdf

operating systems: principles and practice pdf

Operating Systems: Persistent Storage Principles and Practice

Operating Systems Principles and Practice V1

Operating Systems Principles and Practice V3

Operating Systems Principles and Practice 2nd Volume 3

Operating Systems Principles And Practice 1st,2nd

最新资源

操作系统：原理与实践第二卷