深入理解Linux网络内核

需积分: 34 90 浏览量更新于2024-07-23 收藏 18.17MB PDF 举报

"Understanding Linux Network Internals 是一本专为Linux开发和内核开发人员设计的经典书籍。本书深入探讨了Linux网络内部的工作原理，包括用户空间到内核空间的接口、系统初始化以及关键数据结构等核心主题。" 在"Understanding Linux Network Internals"中，作者首先向读者介绍了这本书的受众群体（主要是Linux开发者和内核开发者），并提供了背景信息，强调了书中材料的组织方式和使用的一系列约定，如代码示例的使用。书中的内容旨在帮助读者更好地理解Linux网络的底层机制。第一部分"General Background"提供了一般性的背景知识。第一章"Introduction"讲解了基本术语，常见的编码模式，用户空间工具的使用，如何浏览源代码，以及当一个特性以补丁形式出现时的情况。这为后续章节奠定了基础。第二章"Critical Data Structures"深入探讨了两个关键的数据结构：Socket Buffer（sk_buff结构）和net_device结构。sk_buff结构是网络协议栈中用于存储网络数据的核心结构，而net_device结构则代表了网络设备的主要信息。书中还提到了本章涉及的其他文件，这对于理解Linux内核网络子系统的实现至关重要。第三章"User-Space-to-Kernel Interface"详细阐述了用户空间与内核交互的各种方法，包括procfs和sysctl的对比，ioctl调用，Netlink协议，以及如何序列化配置更改。这些接口是用户空间应用程序与内核通信的关键途径，对于开发网络相关的驱动程序和应用来说，这部分内容尤为关键。接下来的"Part II: System Initialization"主要关注系统初始化过程，特别是"Notification Chains"的概念。第四章讨论了为何需要通知链，以及它们的概述、定义、注册、事件通知以及针对网络子系统的特定通知链。通过/proc文件系统进行调优也是这一部分的重点，这允许开发者动态调整系统参数。本书的每一章都深入到Linux网络体系结构的不同方面，为读者提供了丰富的实践指导和理论知识，帮助他们理解并能够有效地开发和优化Linux网络功能。对于那些想要深入了解Linux网络操作和内核开发的人来说，"Understanding Linux Network Internals"是一本不可或缺的参考资料。

task. Because of that, it is common for a lookup routine to increase the reference

count on the matching element, and let the caller release it when necessary.

When the last reference to a data structure is released, it may be freed because it is not

needed anymore, but not necessarily.

The introduction of the new sysfs filesystem has helped to make a good portion of the kernel

code more aware of reference counts and consistent in its use of them.

1.2.4. Garbage Collection

Memory is a shared and limited resource and should not be wasted, particularly in the kernel

because it does not use virtual memory. Most kernel subsystems implement some sort of

garbage collection to reclaim the memory held by unused or stale data structure instances.

Depending on the needs of any given feature, you will find two main kinds of garbage

collection:

Asynchronous

This type of garbage collection is unrelated to particular events. A timer that expires

regularly invokes a routine that scans a set of data structures and frees the ones

considered eligible for deletion. The conditions that make a data structure eligible

for deletion depend on the features and logic of the subsystem, but a common

criterion is the presence of a null reference count.

Synchronous

There are cases where a shortage of memory, which cannot wait for the

asynchronous garbage collection timer to kick in, triggers immediate garbage

collection. The criteria used to select the data structures eligible for deletion are not

necessarily the same ones used by asynchronous cleanup (for instance, they could be

more aggressive). See Chapter 33 for an example.

In Chapter 7, you will see how the kernel manages to reclaim the memory used by

initialization routines and that is no longer needed after they have been executed.

1.2.5. Function Pointers and Virtual Function Tables (VFTs)

Function pointers are a convenient way to write clean C code while getting some of the

benefits of the object-oriented languages. In the definition of a data structure type (the

object), you include a set of function pointers (the methods). Some or all manipulations of

the structure are then done through the embedded functions. C-language function pointers in

data structures look like this:

struct sock {

...

void (*sk_state_change)(struct sock *sk);

6 Part I: General Background

void (*sk_data_ready)(struct sock *sk, int bytes);

...

};

A key advantage to using function pointers is that they can be initialized differently

depending on various criteria and the role played by the object. Thus, invoking

sk_state_change may actually invoke different functions for different sock sockets.

Function pointers are used extensively in the networking code. The following are only a few

examples:

When an ingress or egress packet is processed by the routing subsystem, it initializes

two routines in the buffer data structure. You will see this in Chapter 35. Refer to

Chapter 2 for a complete list of function pointers included in the sk_buff data

structure.

•

When a packet is ready for transmission on the networking hardware, it is handed to

the hard_start_xmit function pointer of the net_device data structure. That

routine is initialized by the device driver associated with the device.

•

When an L3 protocol wants to transmit a packet, it invokes one of a set of function

pointers. These have been initialized to a set of routines by the address resolution

protocol associated with the L3 protocol. Depending on the actual routine to which

the function pointer is initialized, a transparent L3-to-L2 address resolution may take

place (for example, IPv4 packets go through ARP). When the address resolution is

unnecessary, a different routine is used. See Part VI for a detailed discussion on this

interface.

•

We see in the preceding examples how function pointers can be employed as interfaces

between kernel components or as generic mechanisms to invoke the right function handler at

the right time based on the result of something done by a different subsystem. There are

cases where function pointers are also used as a simple way to allow protocols, device

drivers, or any other feature to personalize an action.

Let's look at an example. When a device driver registers a network device with the kernel, it

goes through a series of steps that are needed regardless of the device type. At some point, it

invokes a function pointer on the net_device data structure to let the device driver do

something extra if needed. The device driver could either initialize that function pointer to a

function of its own, or leave the pointer NULL because the default steps performed by the

kernel are sufficient.

A check on the value of a function pointer is always necessary before executing it to avoid

NULL pointer dereferences, as shown in this snapshot from register_netdevice:

if (dev->init && dev->init(dev) != 0) {

...

}

Function pointers have one main drawback: they make browsing the source code a little

harder. While going through a given code path, you may end up focusing on a function

pointer call. In such cases, before proceeding down the code path, you need to find out how

the function pointer has been initialized. It could depend on different factors:

Part I: General Background 7

When the selection of the routine to assign to a function pointer is based on a

particular piece of data, such as the protocol handling the data or the device driver a

given packet is received from, it is easier to derive the routine. For example, if a

given device is managed by the drivers/net/3c59x.c device driver, you can derive the

routine to which a given function pointer of the net_device data structure is

initialized by reading the device initialization routine provided by the device driver.

•

When the selection of the routine is based instead on more complex logic, such as

the state of the resolution of an L3-to-L2 address mapping, the routine used at any

time depends on external events that cannot be predicted.

•

A set of function pointers grouped into a data structure are often referred to as a virtual

function table (VFT). When a VFT is used as the interface between two major subsystems,

such as the L3 and L4 protocol layers, or when the VFT is simply exported as an interface to

a generic kernel component (set of objects), the number of function pointers in it may swell

to include many different pointers that accommodate a wide range of protocols or other

features. Each feature may end up using only a few of the many functions provided. You will

see an example in Part VI. Of course, if this use of a VFT is taken too far, it becomes

cumbersome and a major redesign is needed.

1.2.6. goto Statements

Few C programmers like the goto statement. Without getting into the history of the goto

(one of the longest and most famous controversies in computer programming), I'll

summarize some of the reasons the goto is usually deprecated, but why the Linux kernel

uses it anyway.

Any piece of code that uses goto can be rewritten without it. The use of goto statements

can reduce the readability of the code, and make debugging harder, because at any position

following a goto you can no longer derive unequivocally the conditions that led the

execution to that point.

Let me make this analogy: given any node in a tree, you know what the path from the root to

the node is. But if you add vines that entwine around branches randomly, you do not always

have a unique path between the root and the other nodes anymore.

However, because the C language does not provide explicit exceptions (and they are often

avoided in other languages as well because of the performance hit and coding complexity),

carefully placed goto statements can make it easier to jump to code that handles undesired

or peculiar events. In kernel programming, and particularly in networking, such events are

very common, so goto becomes a convenient tool.

I must defend the kernel's use of goto by pointing out that developers have by no means

gone wild with it. Even though there are more than 30,000 instances, they are mainly used to

handle different return codes within a function, or to jump out of more than one level of

nesting.

1.2.7. Vector Definitions

In some cases, the definition of a data structure includes an optional block at the end. This is

an example:

8 Part I: General Background

剩余1051页未读，继续阅读

sbak755

粉丝: 0
资源: 9

深入理解Linux网络内核

Understanding linux network internals

understanding linux network internals

Understanding Linux Network Internal

understanding linux network internals pdf

linux串口编程相关资料。

如何学习linux内核网络

有关liunx的英文参考文献

linux内核源码注解的书

linux内核有哪些参考书籍

Linux 4.19相关的参考书

最新资源