探索Linux内核：原理与环境适应

下载需积分: 9 | PDF格式 | 3.81MB | 更新于2024-07-31 | 163 浏览量 | 举报

《理解Linux内核》是一本由Daniel P. Bovet和Marco Cesati合著的专业书籍，首次出版于2000年10月，由O'Reilly出版社发行。这本书对于想要深入了解Linux系统运作原理和技术开发者来说具有很高的价值。它详细地探讨了Linux内核如何优化性能，并在不同环境中发挥作用。书中强调了每个主题的重要性，作者通过深入浅出的方式，向Unix程序员和用户展示了内核操作与我们熟悉的系统工具和服务之间的关联。书中涵盖了广泛的Linux发行版，如Ubuntu、Fedora、SUSE和Red Hat，这些发行版的特性和最佳实践是学习者了解Linux生态系统的关键点。 Linux公社（LinuxIDC.com）作为一个知名的Linux专业网站，提供了丰富的资源，包括这些发行版的技术文档、教程、最新IT资讯等，使其成为Linux爱好者的知识宝库。网站设有专门的专题栏目，如Ubuntu专题、Fedora专题、Red Hat专题、SUSE专题以及红旗Linux专题，针对每个发行版的特定技术和应用场景进行了深入研究。此外，LinuxIDC.com还关注Android专题，展示了Linux在移动领域的应用。值得注意的是，尽管该网站提供的内容可能不代表作者的观点，而是为了提供客观的信息和资源，但它确实为读者提供了广泛的学习平台。版权信息表明，LinuxIDC.com自2006年至2011年保留所有权利，并且站内的带宽由[6688.CC]友情支持。如果你希望进一步提升对Linux内核的理解，阅读《Understanding the Linux Kernel》将是个不错的选择，它不仅会揭示内核的底层工作原理，还会帮助你掌握如何在实际项目中有效地利用这些知识。同时，LinuxIDC.com则是一个持续更新和提供实用资源的在线社区，无论是初学者还是高级开发者，都能在此找到所需的支持和信息。

Understanding the Linux Kernel

Linux is fully customizable in all its components.

Thanks to the General Public License (GPL), you are allowed to freely read and

modify the source code of the kernel and of all system programs.

[3]

Several commercial companies have started to support their products under Linux, most of which aren't distributed under a GNU Public License.

Therefore, you may not be allowed to read or modify their source code.

Linux runs on low-end, cheap hardware platforms.

You can even build a network server using an old Intel 80386 system with 4 MB of

RAM.

Linux is powerful.

Linux systems are very fast, since they fully exploit the features of the hardware

components. The main Linux target is efficiency, and indeed many design choices of

commercial variants, like the STREAMS I/O subsystem, have been rejected by Linus

because of their implied performance penalty.

Linux has a high standard for source code quality.

Linux systems are usually very stable; they have a very low failure rate and system

maintenance time.

The Linux kernel can be very small and compact.

Indeed, it is possible to fit both a kernel image and full root filesystem, including all

fundamental system programs, on just one 1.4 MB floppy disk! As far as we know,

none of the commercial Unix variants is able to boot from a single floppy disk.

Linux is highly compatible with many common operating systems.

It lets you directly mount filesystems for all versions of MS-DOS and MS Windows,

SVR4, OS/2, Mac OS, Solaris, SunOS, NeXTSTEP, many BSD variants, and so on.

Linux is also able to operate with many network layers like Ethernet, Fiber Distributed

Data Interface (FDDI), High Performance Parallel Interface (HIPPI), IBM's Token

Ring, AT&T WaveLAN, DEC RoamAbout DS, and so forth. By using suitable

libraries, Linux systems are even able to directly run programs written for other

operating systems. For example, Linux is able to execute applications written for MS-

DOS, MS Windows, SVR3 and R4, 4.4BSD, SCO Unix, XENIX, and others on the

Intel 80x86 platform.

Linux is well supported.

Believe it or not, it may be a lot easier to get patches and updates for Linux than for

any proprietary operating system! The answer to a problem often comes back within

a few hours after sending a message to some newsgroup or mailing list. Moreover,

drivers for Linux are usually available a few weeks after new hardware products have

been introduced on the market. By contrast, hardware manufacturers release device

drivers for only a few commercial operating systems, usually the Microsoft ones.

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

Understanding the Linux Kernel

s390

IBM System/390 mainframes

1.3 Linux Versions

Linux distinguishes stable kernels from development kernels through a simple numbering

scheme. Each version is characterized by three numbers, separated by periods. The first two

numbers are used to identify the version; the third number identifies the release.

As shown in Figure 1-1, if the second number is even, it denotes a stable kernel; otherwise, it

denotes a development kernel. At the time of this writing, the current stable version of the

Linux kernel is 2.2.14, and the current development version is 2.3.51. The 2.2 kernel, which is

the basis for this book, was first released in January 1999, and it differs considerably from the

2.0 kernel, particularly with respect to memory management. Work on the 2.3 development

version started in May 1999.

Figure 1-1. Numbering Linux versions

New releases of a stable version come out mostly to fix bugs reported by users. The main

algorithms and data structures used to implement the kernel are left unchanged.

Development versions, on the other hand, may differ quite significantly from one another;

kernel developers are free to experiment with different solutions that occasionally lead to

drastic kernel changes. Users who rely on development versions for running applications may

experience unpleasant surprises when upgrading their kernel to a newer release. This book

concentrates on the most recent stable kernel that we had available because, among all

the new features being tried in experimental kernels, there's no way of telling which will

ultimately be accepted and what they'll look like in their final form.

At the time of this writing, Linux 2.4 has not officially come out. We tried to anticipate the

forthcoming features and the main kernel changes with respect to the 2.2 version by looking

at the Linux 2.3.99-pre8 prerelease. Linux 2.4 inherits a good deal from Linux 2.2: many

concepts, design choices, algorithms, and data structures remain the same. For that reason, we

conclude each chapter by sketching how Linux 2.4 differs from Linux 2.2 with respect to

the topics just discussed. As you'll notice, the new Linux is gleaming and shining; it should

appear more appealing to large corporations and, more generally, to the whole business

community.

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

Understanding the Linux Kernel

1.4 Basic Operating System Concepts

Any computer system includes a basic set of programs called the operating system. The most

important program in the set is called the kernel. It is loaded into RAM when the system boots

and contains many critical procedures that are needed for the system to operate. The other

programs are less crucial utilities; they can provide a wide variety of interactive experiences

for the user—as well as doing all the jobs the user bought the computer for—but the essential

shape and capabilities of the system are determined by the kernel. The kernel, then, is where

we fix our attention in this book. Hence, we'll often use the term "operating system" as

a synonym for "kernel."

The operating system must fulfill two main objectives:

• Interact with the hardware components servicing all low-level programmable elements

included in the hardware platform.

• Provide an execution environment to the applications that run on the computer system

(the so-called user programs).

Some operating systems allow all user programs to directly play with the hardware

components (a typical example is MS-DOS). In contrast, a Unix-like operating system hides

all low-level details concerning the physical organization of the computer from applications

run by the user. When a program wants to make use of a hardware resource, it must issue

a request to the operating system. The kernel evaluates the request and, if it chooses to grant

the resource, interacts with the relative hardware components on behalf of the user program.

In order to enforce this mechanism, modern operating systems rely on the availability of

specific hardware features that forbid user programs to directly interact with low-level

hardware components or to access arbitrary memory locations. In particular, the hardware

introduces at least two different execution modes for the CPU: a nonprivileged mode for user

programs and a privileged mode for the kernel. Unix calls these User Mode and Kernel Mode,

respectively.

In the rest of this chapter, we introduce the basic concepts that have motivated the design of

Unix over the past two decades, as well as Linux and other operating systems. While the

concepts are probably familiar to you as a Linux user, these sections try to delve into them

a bit more deeply than usual to explain the requirements they place on an operating system

kernel. These broad considerations refer to Unix-like systems, thus also to Linux. The other

chapters of this book will hopefully help you to understand the Linux kernel internals.

1.4.1 Multiuser Systems

A multiuser system is a computer that is able to concurrently and independently execute

several applications belonging to two or more users. "Concurrently" means that applications

can be active at the same time and contend for the various resources such as CPU, memory,

hard disks, and so on. "Independently" means that each application can perform its task with

no concern for what the applications of the other users are doing. Switching from one

application to another, of course, slows down each of them and affects the response time seen

by the users. Many of the complexities of modern operating system kernels, which we will

examine in this book, are present to minimize the delays enforced on each program and to

provide the user with responses that are as fast as possible.

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

Understanding the Linux Kernel

Multiuser operating systems must include several features:

• An authentication mechanism for verifying the user identity

• A protection mechanism against buggy user programs that could block other

applications running in the system

• A protection mechanism against malicious user programs that could interfere with, or

spy on, the activity of other users

• An accounting mechanism that limits the amount of resource units assigned to each

user

In order to ensure safe protection mechanisms, operating systems must make use of the

hardware protection associated with the CPU privileged mode. Otherwise, a user program

would be able to directly access the system circuitry and overcome the imposed bounds. Unix

is a multiuser system that enforces the hardware protection of system resources.

1.4.2 Users and Groups

In a multiuser system, each user has a private space on the machine: typically, he owns some

quota of the disk space to store files, receives private mail messages, and so on. The operating

system must ensure that the private portion of a user space is visible only to its owner. In

particular, it must ensure that no user can exploit a system application for the purpose of

violating the private space of another user.

All users are identified by a unique number called the User ID , or UID. Usually only a

restricted number of persons are allowed to make use of a computer system. When one of

these users starts a working session, the operating system asks for a login name and a

password. If the user does not input a valid pair, the system denies access. Since the password

is assumed to be secret, the user's privacy is ensured.

In order to selectively share material with other users, each user is a member of one or more

groups, which are identified by a unique number called a Group ID , or GID. Each file is also

associated with exactly one group. For example, access could be set so that the user owning

the file has read and write privileges, the group has read-only privileges, and other users on

the system are denied access to the file.

Any Unix-like operating system has a special user called root, superuser, or supervisor. The

system administrator must log in as root in order to handle user accounts, perform

maintenance tasks like system backups and program upgrades, and so on. The root user can

do almost everything, since the operating system does not apply the usual protection

mechanisms to her. In particular, the root user can access every file on the system and can

interfere with the activity of every running user program.

1.4.3 Processes

All operating systems make use of one fundamental abstraction: the process . A process can

be defined either as "an instance of a program in execution," or as the "execution context" of a

running program. In traditional operating systems, a process executes a single sequence of

instructions in an address space ; the address space is the set of memory addresses that the

process is allowed to reference. Modern operating systems allow processes with multiple

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

剩余542页未读，继续阅读

bonjouy

粉丝: 1

探索Linux内核：原理与环境适应

Understanding the Linux Kernel pdf

Understanding The Linux Kernel 完美组合

Understanding the Linux Kernel 3rd Edition

Understanding The Linux Kernel

understanding the linux kernel

Understanding the LINUX Kernel

understanding the linux kernel 3

Understanding the Linux Kernel 3rd

Understanding The Linux Kernel 3rd

understanding linux kernel 中文版,Understanding the Linux Kernel [PDF]

最新资源