掌握Linux内核与系统运作：全面解析与实践指南

需积分: 12 148 浏览量更新于2024-07-20 收藏 3.99MB PDF 举报

《如何工作：Linux内幕详解》（How Linux Works: What Every Superuser Should Know）是Brian Ward所著的经典之作，由No Starch Press出版。这本书旨在帮助那些对Linux操作系统内部工作原理感兴趣的读者，特别是对想要深入掌握Linux系统、成为超级用户的人员。不同于其他试图隐藏细节的操作系统，Linux提供给用户全面的控制，但要完全掌握它，理解启动过程、内核管理、网络功能、开发工具以及shell脚本编写等核心概念至关重要。该书在第二版中进行了全面修订，内容涵盖了Linux启动机制，包括引导加载器（如GRUB、systemd、Upstart和System V init）的运作，以及内核如何管理设备、驱动程序和进程。读者将学习到网络接口、防火墙、服务器工作原理，以及如何利用共享库和开发工具解决问题。此外，书中还探讨了内核在用户空间中的关键任务，如系统调用、输入输出处理和文件系统管理。作者通过丰富的背景知识、理论阐述、实际案例分析和耐心的解释，使读者能够掌握解决棘手问题和操控系统的技能。书中的内容不仅适合初学者，也适合有一定Linux经验但希望深入了解其内在机制的读者。无论是对于Linux新手还是资深用户来说，《如何工作：Linux内幕详解》都是一本不可多得的参考书籍，能够帮助读者从底层理解Linux，从而更好地利用和定制这个强大的操作系统。

2.2 Using the Shell

When you install Linux, you should create at least one regular user in addition to the root user; this will be

your personal account. For this chapter, you should log in as the regular user.

2.2.1 The Shell Window

After logging in, open a shell window (often referred to as a terminal). The easiest way to do so from a GUI

like Gnome or Ubuntu’s Unity is to open a terminal application, which starts a shell inside a new window.

Once you’ve opened a shell, it should display a prompt at the top that usually ends with a dollar sign ($). On

Ubuntu, that prompt should look like name@host:path$, and on Fedora, it’s [name@host path]$. If

you’re familiar with Windows, the shell window will look something like a DOS command prompt; the

Terminal application in OS X is essentially the same as a Linux shell window.

This book contains many commands that you will type at a shell prompt. They all begin with a single $ to

denote the shell prompt. For example, type this command (just the part in bold, not the $) and press ENTER:

$ echo Hello there.

NOTE

Many shell commands in this book start with #. You should run these as the superuser (root).

These commands usually require extra caution.

Now enter this command:

$ cat /etc/passwd

This command displays the contents of the /etc/passwd system information file and then returns your shell

prompt. Don’t worry about what this file does right now; you’ll learn all about it later, in Chapter 7.

2.2.2 cat

The cat command is one of the easiest Unix commands to understand; it simply outputs the contents of one

or more files. The general syntax of the cat command is as follows:

$ cat file1 file2 ...

When you run this command, cat prints the contents of file1, file2, and any other files that you specify

(denoted by ...), and then exits. The command is called cat because it performs concatenation when it

prints the contents of more than one file.

2.2.3 Standard Input and Standard Output

We’ll use cat to briefly explore Unix input and output (I/O). Unix processes use I/O streams to read and write

data. Processes read data from input streams and write data to output streams. Streams are very flexible. For

example, the source of an input stream can be a file, a device, a terminal, or even the output stream from

another process.

To see an input stream at work, enter cat (with no filenames) and press ENTER. This time, you won’t get your

shell prompt back because cat is still running. Now type anything and press ENTER at the end of each line.

The cat command repeats any line that you type. Once you’re sufficiently bored, press CTRL-D on an empty

line to terminate cat and return to the shell prompt.

The reason cat adopted an interactive behavior has to do with streams. Because you did not specify an input

filename, cat read from the standard input stream provided by the Linux kernel rather than a stream

connected to a file. In this case, the standard input was connected to the terminal in which you ran cat.

NOTE

Pressing CTRL-D on an empty line stops the current standard input entry from the terminal (and

often terminates a program). Don’t confuse this with CTRL-C, which terminates a program

regardless of its input or output.

Standard output is similar. The kernel gives each process a standard output stream where it can write its output.

The cat command always writes its output to the standard output. When you ran cat in the terminal, the

standard output was connected to that terminal, so that’s where you saw the output.

Standard input and output are often abbreviated as stdin and stdout. Many commands operate as cat does; if

you don’t specify an input file, the command reads from stdin. Output is a little different. Some commands

(like cat) send output only to stdout, but others have the option to send output directly to files.

There is a third standard I/O stream called standard error. You’ll see it in 2.14.1 Standard Error.

One of the best features of standard streams is that you can easily manipulate them to read and write to places

other than the terminal, as you’ll learn in 2.14 Shell Input and Output. In particular, you’ll learn how to connect

streams to files and other processes.

2.3 Basic Commands

Now let’s look at some more Unix commands. Most of the following programs take multiple arguments, and

some have so many options and formats that an unabridged listing would be pointless. This is a simplified list

of the basic commands; you don’t need all of the details just yet.

2.3.1 ls

The ls command lists the contents of a directory. The default is the current directory. Use ls -l for a

detailed (long) listing and ls -F to display file type information. (For more on the file types and permissions

displayed in the left column below, see 2.17 File Modes and Permissions.) Here is a sample long listing; it

includes the owner of the file (column 3), the group (column 4), the file size (column 5), and the modification

date/time (between column 5 and the filename):

$ ls -l

total 3616

-rw-r--r-- 1 juser users 3804 Apr 30 2011 abusive.c

-rw-r--r-- 1 juser users 4165 May 26 2010 battery.zip

-rw-r--r-- 1 juser users 131219 Oct 26 2012 beav_1.40-13.tar.gz

-rw-r--r-- 1 juser users 6255 May 30 2010 country.c

drwxr-xr-x 2 juser users 4096 Jul 17 20:00 cs335

-rwxr-xr-x 1 juser users 7108 Feb 2 2011 dhry

-rw-r--r-- 1 juser users 11309 Oct 20 2010 dhry.c

-rw-r--r-- 1 juser users 56 Oct 6 2012 doit

drwxr-xr-x 6 juser users 4096 Feb 20 13:51 dw

drwxr-xr-x 3 juser users 4096 May 2 2011 hough-stuff

You’ll learn more about the d in column 1 of this output in 2.17 File Modes and Permissions.

When you refer to a file or directory, you specify a path or pathname. When a path starts with / (such as

/usr/lib), it’s a full or absolute path.

A path component identified by two dots (..) specifies the parent of a directory. For example, if you’re working

in /usr/lib, the path .. would refer to /usr. Similarly, ../bin would refer to /usr/bin.

One dot (.) refers to the current directory; for example, if you’re in /usr/lib, the path . is still /usr/lib, and ./X11

is /usr/lib/X11. You won’t have to use . very often because most commands default to the current directory if

a path doesn’t start with / (you could just use X11 instead of ./X11 in the preceding example).

A path not beginning with / is called a relative path. Most of the time, you’ll work with relative pathnames,

because you’ll already be in the directory you need to be in or somewhere close by.

Now that you have a sense of the basic directory mechanics, here are some essential directory commands.

2.4.1 cd

The current working directory is the directory that a process (such as the shell) is currently in. The cd

command changes the shell’s current working directory:

$ cd dir

If you omit dir, the shell returns to your home directory, the directory you started in when you first logged

in.

2.4.2 mkdir

The mkdir command creates a new directory dir:

$ mkdir dir

2.4.3 rmdir

The rmdir command removes the directory dir:

$ rmdir dir

If dir isn’t empty, this command fails. However, if you’re impatient, you probably don’t want to laboriously

delete all the files and subdirectories inside dir first. You can use rm -rf dir to delete a directory and its

contents, but be careful! This is one of the few commands that can do serious damage, especially if you run it

as the superuser. The -r option specifies recursive delete to repeatedly delete everything inside dir, and -f

forces the delete operation. Don’t use the -rf flags with globs such as a star (*). And above all, always

double-check your command before you run it.

2.4.4 Shell Globbing (Wildcards)

The shell can match simple patterns to file and directory names, a process known as globbing. This is similar

to the concept of wildcards in other systems. The simplest of these is the glob character *, which tells the shell

to match any number of arbitrary characters. For example, the following command prints a list of files in the

current directory:

$ echo *

The shell matches arguments containing globs to filenames, substitutes the filenames for those arguments, and

then runs the revised command line. The substitution is called expansion because the shell substitutes all

matching filenames. Here are some ways to use * to expand filenames:

o at* expands to all filenames that start with at.

o *at expands to all filenames that end with at.

o *at* expands to all filenames that contain at.

If no files match a glob, the shell performs no expansion, and the command runs with literal characters such

as *. For example, try a command such as echo *dfkdsafh.

NOTE

If you’re used to MS-DOS, you might instinctively type *.* to match all files. Break this habit now.

In Linux and other versions of Unix, you must use * to match all files. In the Unix shell, *.*

matches only files and directories that contain the dot (.) character in their names. Unix filenames

do not need extensions and often do not carry them.

Another shell glob character, the question mark (?), instructs the shell to match exactly one arbitrary character.

For example, b?at matches boat and brat.

If you don’t want the shell to expand a glob in a command, enclose the glob in single quotes (''). For example,

the command echo '*' prints a star. You will find this handy for a few of the commands described in the

next section, such as grep and find. (You’ll learn more much about quoting in 11.2 Quoting and Literals.)

NOTE

It is important to remember that the shell performs expansions before running commands, and

only then. Therefore, if a * makes it to a command without expanding, the shell will do nothing

more with it; it’s up to the command to decide what it wants to do.

There is more to a modern shell’s pattern-matching capabilities, but * and ? are what you need to know now.

2.5 Intermediate Commands

The following sections describe the most essential intermediate Unix commands.

2.5.1 grep

The grep command prints the lines from a file or input stream that match an expression. For example, to

print the lines in the /etc/passwd file that contain the text root, enter this:

$ grep root /etc/passwd

The grep command is extraordinarily handy when operating on multiple files at once because it prints the

filename in addition to the matching line. For example, if you want to check every file in /etc that contains the

word root, you could use this command:

$ grep root /etc/*

Two of the most important grep options are -i (for case-insensitive matches) and -v (which inverts the

search, that is, prints all lines that don’t match). There is also a more powerful variant called egrep (which

is just a synonym for grep -E).

grep understands patterns known as regular expressions that are grounded in computer science theory and

are very common in Unix utilities. Regular expressions are more powerful than wildcard-style patterns, and

they have a different syntax. There are two important things to remember about regular expressions:

o .* matches any number of characters (like the * in wildcards).

o . matches one arbitrary character.

NOTE

The grep(1) manual page contains a detailed description of regular expressions, but it can be a

little difficult to read. To learn more, you can read Mastering Regular Expressions, 3rd edition

(O’Reilly, 2006), or see the regular expressions chapter of Programming Perl, 4th edition (O’Reilly,

剩余337页未读，继续阅读

「已注销」

粉丝: 2
资源: 6

掌握Linux内核与系统运作：全面解析与实践指南

How Linux Works 2nd Edition

How Linux Works, 2nd Edition

How Linux Works: What Every Superuser Should Know, 2nd Edition

Python中__init__和how_to_有什么区别

anything-llm/docker/HOW_TO_USE_DOCKER.md

HowTo_support_WIFI_certification_test

explain to me how does Linux bootloadwr work

增强度准则(EME)matlab代码

有一个文件名为 HowTo_enable_driver_to_support_mbo 请问他是关于什么的

图像增强度准则(EME)matlab代码

最新资源

Python中init和how_to_有什么区别