【网络开发】网络收包讲解1
基于 Linux 内核 6.0、64 位系统和 Intel 网卡驱动 igb。由于篇幅过长切分多篇，所有参考内容在最后一篇。公众号回复「十年」免费领取精心制作的《十年码农内功》 PDF。图1 整体流程图
一、系统启yjqe动1.1 概述
[*]网卡驱动的加载
[*]网卡驱动的初始化（probe）
[*]网卡设备的启用（ndo_open）
[*]软中断进程初始化（ksoftirqd）
[*]网络子系统初始化（net）
[*]网络协议栈初始化
1.2 网卡驱动的加载网卡需要有驱动才能工作，驱动是加载到内核中的模块，负责衔接网卡和内核。当相应的网卡收到数据包时，网络模块会调用相应的驱动程序处理数据。网卡驱动程序 igb 向 Linux 内核通过 module_init 宏注册一个初始化函数 igb_init_module，当驱动加载的时候，该函数被内核调用。static struct pci_driver igb_driver = {
.name = igb_driver_name, //igb
.id_table = igb_pci_tbl,
.probe = igb_probe,
.remove = igb_remove,
#ifdef CONFIG_PM
.driver.pm = &igb_pm_ops,
#endif
.shutdown = igb_shutdown,
.sriov_configure = igb_pci_sriov_configure,
.err_handler = &igb_err_handler
};
static int __init igb_init_module(void)
{
int ret;
pr_info("%s\n", igb_driver_string);
pr_info("%s\n", igb_copyright);
#ifdef CONFIG_IGB_DCA
dca_register_notify(&dca_notifier);
#endif
ret = pci_register_driver(&igb_driver);
return ret;
}
module_init(igb_init_module);
igb_init_module 函数的大部分工作是通过 pci_register_driver 内 __pci_register_driver 函数来完成的。int __pci_register_driver(struct pci_driver *drv, struct module *owner, const char *mod_name)
{
/* initialize common driver fields */
drv->driver.name = drv->name;
drv->driver.bus = &pci_bus_type;
drv->driver.owner = owner;
drv->driver.mod_name = mod_name;
drv->driver.groups = drv->groups;
drv->driver.dev_groups = drv->dev_groups;
spin_lock_init(&drv->dynids.lock);
INIT_LIST_HEAD(&drv->dynids.list);
/* register with core */
return driver_register(&drv->driver);
}
最后 driver_register 函数把网卡的驱动（driver）加载到内核 PCI 子系统。1.3 网卡驱动的初始化（probe）一个驱动程序可以支持一个或多个设备，而一个设备只会绑定一个驱动程序。驱动程序将其支持的所有设备保存在一个列表 struct pci_device_id 中。igb 驱动程序所支持的 PCI 设备列表部分如下：static const struct pci_device_id igb_pci_tbl[] = {
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_1GBPS) },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_SGMII) },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_2_5GBPS) },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I211_COPPER), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_FIBER), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SGMII), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER_FLASHLESS), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES_FLASHLESS), board_82575 },
/* required last entry */
{0, }
};
内核通过设备 ID 与驱动支持的设备列表匹配，选择合适的驱动控制网卡，然后调用之前注册到内核 PCI 子系统的探测函数（probe）完成初始化。例如 igb 驱动程序的 igb_probe 函数，其处理流程包括：
[*]设置 DMA 寻址限制和缓存一致性；
[*]申请内核内存；
[*]struct net_device 结构体的创建、初始化和注册；
[*]注册 struct net_device_ops （里面有 igb_open ） 到 net_device；
[*]注册驱动支持的 ethtool 调用函数；
[*]注册 poll 函数到 NAPI 子系统；
igb 驱动程序中 igb_probe 函数的部分代码如下：
static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
/* 设置 DMA 寻址限制和缓存一致性 */
err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
/* 申请内存 */
err = pci_request_mem_regions(pdev, igb_driver_name);
/* 网络设备 */
netdev = alloc_etherdev_mq(sizeof(struct igb_adapter), IGB_MAX_TX_QUEUES);
/* net_device_ops 结构体，代表一个网络设备 */
netdev->netdev_ops = &igb_netdev_ops;
/* 注册驱动支持的 ethtool 调用函数 */
igb_set_ethtool_ops(netdev);
/* 函数里面注册了 poll 函数 */
err = igb_sw_init(adapter);
}
DMA（Direct Memory Access）顾名思义就是「直接内存访问」，是指一个设备和 CPU 共享内存总线。DMA 主要优点：通过和 CPU 共享内存总线，DMA 可以实现 IO 设备和内存之间快速的数据复制(不论内存到设备还是设备到内存，都能够加速数据传输)。1.3.1 注册 net_device_ops 到 net_devicenet_device_ops 结构体包含了指向打开设备、发送数据和设置 MAC 地址等操作函数的指针，代码如下：static const struct net_device_ops igb_netdev_ops = {
.ndo_open = igb_open,
.ndo_stop = igb_close,
.ndo_start_xmit = igb_xmit_frame,
.ndo_get_stats64 = igb_get_stats64,
.ndo_set_rx_mode = igb_set_rx_mode,
.ndo_set_mac_address= igb_set_mac,
.ndo_change_mtu = igb_change_mtu,
.ndo_eth_ioctl = igb_ioctl,
.ndo_tx_timeout = igb_tx_timeout,
.ndo_validate_addr= eth_validate_addr,
.ndo_vlan_rx_add_vid= igb_vlan_rx_add_vid,
.ndo_vlan_rx_kill_vid= igb_vlan_rx_kill_vid,
.ndo_set_vf_mac = igb_ndo_set_vf_mac,
.ndo_set_vf_vlan = igb_ndo_set_vf_vlan,
.ndo_set_vf_rate = igb_ndo_set_vf_bw,
.ndo_set_vf_spoofchk= igb_ndo_set_vf_spoofchk,
.ndo_set_vf_trust = igb_ndo_set_vf_trust,
.ndo_get_vf_config= igb_ndo_get_vf_config,
.ndo_fix_features = igb_fix_features,
.ndo_set_features = igb_set_features,
.ndo_fdb_add = igb_ndo_fdb_add,
.ndo_features_check = igb_features_check,
.ndo_setup_tc = igb_setup_tc,
.ndo_bpf = igb_xdp,
.ndo_xdp_xmit = igb_xdp_xmit,
};
1.3.2 注册 poll 函数到 NAPI 子系统网卡驱动程序都会实现poll函数，igb驱动程序实现的poll函数是 igb_poll 函数，通过调用netif_napi_add函数将其注册到 NAPI 子系统。调用链：igb_sw_init -> igb_init_interrupt_scheme -> igb_alloc_q_vectors -> igb_alloc_q_vector。igb_alloc_q_vector 函数部分代码如下：static int igb_alloc_q_vector(struct igb_adapter *adapter, int v_count, int v_idx, int txr_count, int txr_idx, int rxr_count, int rxr_idx)
{
/* allocate q_vector and rings */
q_vector = adapter->q_vector;
/* 初始化 NAPI */
netif_napi_add(adapter->netdev, &q_vector->napi, igb_poll, 64);
}
其中，weight代表 RX 队列的处理权重，budget表示一种惩罚措施，用于多 CPU 多队列之间的公平性调度1.4 网卡设备的启用（ndo_open）当网络设备被启用时（比如使用 ifconfig eth0 up 命令）net_device_ops 中的 ndo_open 所指向的函数将会被调用。完成以下处理：
[*]分配多 TX/RX 队列的内核内存空间；
[*]给网卡配置 RX/TX 队列，给 RX 申请 DMA 空间；
[*]注册硬中断处理函数；
[*]打开 NAPI；
[*]打开网卡硬中断；
igb 驱动程序中 ndo_open 指向的是 igb_open，部分代码如下：static int __igb_open(struct net_device *netdev, bool resuming)
{
/* 分配多 TX 队列的内存空间 */
err = igb_setup_all_tx_resources(adapter);
/* 分配多 RX 队列的内存空间 */
err = igb_setup_all_rx_resources(adapter);
/* 给网卡配置 RX/TX 队列，给 RX 申请 DMA 空间 */
igb_configure(adapter);
/* 注册中断处理函数 */
err = igb_request_irq(adapter);
/* 打开 NAPI */
for (i = 0; i < adapter->num_q_vectors; i++)
napi_enable(&(adapter->q_vector->napi));
/* 打开硬中断 */
igb_irq_enable(adapter);
/* 启动所有 TX 队列 */
netif_tx_start_all_queues(netdev);
}
int igb_open(struct net_device *netdev)
{
return __igb_open(netdev, false);
}
1.4.1 分配 TX/RX 多队列（Ring Buffer）内存空间目前大部分网络都采用基于环形缓冲区的队列来进行 DMA 的收发数据包。igb_open 代码中 igb_setup_all_rx_resources 会循环调用 igb_setup_rx_resources 函数 num_rx_queues 次，每次申请一个 Ring Buffer 内存空间，元素是 struct igb_rx_buffer，并且通过 DMA 申请连续内核空间用来存放 Ring Buffer 对应的网络数据。部分代码如下：static int igb_setup_all_rx_resources(struct igb_adapter *adapter)
{
for (i = 0; i < adapter->num_rx_queues; i++)
err = igb_setup_rx_resources(adapter->rx_ring);
}
int igb_setup_rx_resources(struct igb_ring *rx_ring)
{
/* Ring Buffer 的元素是 struct igb_rx_buffer */
size = sizeof(struct igb_rx_buffer) * rx_ring->count;
/* 申请 Ring Buffer 内存空间 */
rx_ring->rx_buffer_info = vmalloc(size);
/* Round up to nearest 4K */
rx_ring->size = rx_ring->count * sizeof(union e1000_adv_rx_desc);
rx_ring->size = ALIGN(rx_ring->size, 4096);
/* 通过 DMA 申请连续内核空间，数量与 Ring Buffer 长度一致 */
rx_ring->desc = dma_alloc_coherent(dev, rx_ring->size, &rx_ring->dma, GFP_KERNEL);
/* 复位 */
rx_ring->next_to_alloc = 0;
rx_ring->next_to_clean = 0;
rx_ring->next_to_use = 0;
}
struct igb_rx_buffer {
dma_addr_t dma; /* DMA 内核空间地址 */
struct page *page;
__u16 page_offset;
__u16 pagecnt_bias;
};
1.4.2 网卡配置 TX/RX 队列创建完 RX 和 TX 队列后，需要把他们关联到网卡硬件，关联方式是通过把 RX/TX 的首元素写入网卡寄存器等操作，最后需要申请 RX 队列内长度 - 1个 igb_rx_buffer 元素的 DMA 地址（总线地址）空间，便于网卡收到数据好有地方存。igb_configure 和 igb_alloc_rx_buffers 函数部分代码如下：static void igb_configure(struct igb_adapter *adapter)
{
struct net_device *netdev = adapter->netdev;
int i;
/* 给网卡配置 TX/RX 队列，收发数据均从一个元素开始 */
igb_configure_tx(adapter);
igb_configure_rx(adapter);
/* 清空网卡内的 RX FIFO */
igb_rx_fifo_flush_82575(&adapter->hw);
/* 给每个 RX 队列分配 DMA 空间，便于网卡硬件接收数据写入其中 */
for (i = 0; i < adapter->num_rx_queues; i++) {
struct igb_ring *ring = adapter->rx_ring;
igb_alloc_rx_buffers(ring, igb_desc_unused(ring));
}
}
void igb_alloc_rx_buffers(struct igb_ring *rx_ring, u16 cleaned_count)
{
union e1000_adv_rx_desc *rx_desc;
struct igb_rx_buffer *bi;
u16 i = rx_ring->next_to_use;
u16 bufsz;
rx_desc = IGB_RX_DESC(rx_ring, i);
bi = &rx_ring->rx_buffer_info;
i -= rx_ring->count;
bufsz = igb_rx_bufsz(rx_ring);
do {
/* 申请 DMA 地址（总线地址）空间供网卡写入接收的数据，sync the buffer for use by the device */
dma_sync_single_range_for_device(rx_ring->dev, bi->dma, bi->page_offset, bufsz, DMA_FROM_DEVICE);
/* Refresh the desc even if buffer_addrs didn't change
* because each write-back erases this info.
*/
rx_desc->read.pkt_addr = cpu_to_le64(bi->dma + bi->page_offset);
rx_desc++;
bi++;
i++;
if (unlikely(!i)) {
rx_desc = IGB_RX_DESC(rx_ring, 0);
bi = rx_ring->rx_buffer_info;
i -= rx_ring->count;
}
/* clear the length for the next_to_use descriptor */
rx_desc->wb.upper.length = 0;
cleaned_count--;
} while (cleaned_count);
}
1.4.3 注册中断函数通常设备可以采用不同的中断方式：MSI-X、MSI 和 legacy 模式的中断方式。MSI-X 中断是较好的方法，特别是对于支持多 RX 队列的网卡，每个 RX 队列都有其分配的特定硬中断号，可以绑定固定的 CPU 处理。根据设备所支持的中断方式，驱动程序采用最合适的中断方式注册处理函数。在 igb 驱动中，igb_msix_ring、igb_intr_msi 和 igb_intr 分别是 MSI-X、MSI 和 legacy 模式的中断处理函数。igb 按照 MSI-X -> MSI -> legacy 的顺序尝试注册中断处理函数。igb_request_irq 部分代码如下：static int igb_request_irq(struct igb_adapter *adapter)
{
struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev;
int err = 0;
/* MSI-X */
if (adapter->flags & IGB_FLAG_HAS_MSIX) {
err = igb_request_msix(adapter);
if (!err)
goto request_done;
/* fall back to MSI */
}
/* MSI */
if (adapter->flags & IGB_FLAG_HAS_MSI) {
err = request_irq(pdev->irq, igb_intr_msi, 0, netdev->name, adapter);
if (!err)
goto request_done;
/* fall back to legacy interrupts */
}
/* legacy interrupts */
err = request_irq(pdev->irq, igb_intr, IRQF_SHARED, netdev->name, adapter);
}
多数情况下网卡驱动会选择 MSI-X 中断方式，调用 igb_request_msix 函数，然后注册 igb_msix_ring 函数为中断处理函数，部分代码如下：static int igb_request_msix(struct igb_adapter *adapter)
{
/* 注册 igb_msix_ring 硬中断函数 */
err = request_irq(adapter->msix_entries.vector, igb_msix_ring, 0, q_vector->name, q_vector);
}
当 NIC 收到数据后发出一个硬件中断信号时，上面注册的中断函数将会执行，具体执行到收包过程再讲。1.4.4 打开 NAPINAPI 的核心概念是不采用频繁硬中断的方式读取数据，而是首先采用硬中断唤醒 NAPI 子系统，然后触发软中断，网络子系统处理软中断，然后循环调用 poll_list 中的 NAPI 实例的 poll 函数来循环接收数据包，这样可以防止高频硬中断影响系统的运行效率。当然，NAPI 也有缺陷，系统不能及时接收每一个包，而是多个包一起处理，进而增加了部分数据包的延时。前面驱动程序介绍了如何将 poll 函数注册到 NAPI 子系统，但是 NAPI 通常会等到设备被打开之后才会开始工作。打开 NAPI 比较简单。在 igb 驱动中，调用 napi_enable 实现。/* 打开 NAPI */
for (i = 0; i < adapter->num_q_vectors; i++)
napi_enable(&(adapter->q_vector->napi));
1.4.5 打开硬中断打开 NIC 硬中断，等待数据包的到来。打开中断是一个硬件操作，igb 驱动通过函数 igb_irq_enable 写寄存器实现。static void igb_irq_enable(struct igb_adapter *adapter)
{
struct e1000_hw *hw = &adapter->hw;
if (adapter->flags & IGB_FLAG_HAS_MSIX) {
u32 ims = E1000_IMS_LSC | E1000_IMS_DOUTSYNC | E1000_IMS_DRSTA;
u32 regval = rd32(E1000_EIAC);
wr32(E1000_EIAC, regval | adapter->eims_enable_mask);
regval = rd32(E1000_EIAM);
wr32(E1000_EIAM, regval | adapter->eims_enable_mask);
wr32(E1000_EIMS, adapter->eims_enable_mask);
if (adapter->vfs_allocated_count) {
wr32(E1000_MBVFIMR, 0xFF);
ims |= E1000_IMS_VMMB;
}
wr32(E1000_IMS, ims);
} else {
wr32(E1000_IMS, IMS_ENABLE_MASK | E1000_IMS_DRSTA);
wr32(E1000_IAM, IMS_ENABLE_MASK | E1000_IMS_DRSTA);
}
}
1.5 软中断 ksoftirqd 内核进程CPU 在执行硬中断处理函数时可能会短暂的关闭硬中断，中断处理函数处理时间越长，关闭时间越长，丢掉其他硬中断事件的机会就越大。因此，硬中断处理函数处理的事情越少越好，这样可以尽快完成中断处理函数并且重新打开硬中断。中断处理函数的总工作量不变的情况下，还得减少硬中断的工作量，就引入了软中断，复杂的事情交给软中断来处理。软中断在 ksoftirq 内核进程来处理，与硬中断不在一个层面，其可以被硬中断打断。每个 CPU 负责执行一个 ksoftirq 内核进程，比如 ksoftirqd/0 运行在 CPU 0上，这些内核进程执行不同软中断注册的中断处理函数。内核通过 open_softirq 函数来注册软中断处理函数。一个重要知识点：执行硬中断的处理函数的 CPU 核心，也会执行该硬中断后续的软中断处理函数，也就是同一中断事件的软/硬中断处理函数会被同一个 CPU 核心执行。ksoftirqd 内核进程通过 spawn_ksoftirqd 函数初始化，代码如下：static struct smp_hotplug_thread softirq_threads = {
.store = &ksoftirqd,
.thread_should_run = ksoftirqd_should_run,
.thread_fn = run_ksoftirqd,
.thread_comm = "ksoftirqd/%u",
};
static __init int spawn_ksoftirqd(void) {
cpuhp_setup_state_nocalls(CPUHP_SOFTIRQ_DEAD, "softirq:dead", NULL, takeover_tasklets);
BUG_ON(smpboot_register_percpu_thread(&softirq_threads));
return 0;
}
early_initcall(spawn_ksoftirqd);
1.6 网络子系统上面讲解了网络驱动和软中断的初始化流程，下面介绍下「网络子系统」的初始化。「网络子系统」通过 net_dev_init 函数进行初始化，部分代码如下：static int __init net_dev_init(void)
{
int i, rc = -ENOMEM;
/* Initialise the packet receive queues. */
for_each_possible_cpu(i) {
struct work_struct *flush = per_cpu_ptr(&flush_works, i);
struct softnet_data *sd = &per_cpu(softnet_data, i);
INIT_WORK(flush, flush_backlog);
skb_queue_head_init(&sd->input_pkt_queue);
skb_queue_head_init(&sd->process_queue);
#ifdef CONFIG_XFRM_OFFLOAD
skb_queue_head_init(&sd->xfrm_backlog);
#endif
INIT_LIST_HEAD(&sd->poll_list);
sd->output_queue_tailp = &sd->output_queue;
#ifdef CONFIG_RPS
/* 注册 IPI 信号的处理函数，然后发出 NET_RX_SOFTIRQ 软中断信号 */
INIT_CSD(&sd->csd, rps_trigger_softirq, sd);
sd->cpu = i;
#endif
INIT_CSD(&sd->defer_csd, trigger_rx_softirq, sd);
spin_lock_init(&sd->defer_lock);
init_gro_hash(&sd->backlog);
/* 软中断中通过调用 backlog（napi_struct）的 poll 处理 cpu 的 sd 的 input_pkt_queue（skb） 队列 */
sd->backlog.poll = process_backlog;
/* weight_p 可以调整，网卡的 poll 权重是 hardcode 64 */
sd->backlog.weight = weight_p;
}
open_softirq(NET_TX_SOFTIRQ, net_tx_action);
open_softirq(NET_RX_SOFTIRQ, net_rx_action);
}
/* 内核通过调用 subsys_initcall 初始化各个子系统 */
subsys_initcall(net_dev_init);
该函数会给每个 CPU 创建一个 softnet_data 结构体，该结构体包含了很多数据，其中包括：
[*]注册到该 CPU 的 NAPI 结构体列表（poll_list）；
[*]接收和发送队列；
[*]backlog（napi_struct）初始化；
[*]RPS 相关的指针；
struct softnet_data {
struct list_head poll_list;
struct sk_buff_head process_queue;
/* stats */
unsigned int processed;
unsigned int time_squeeze;
unsigned int received_rps;
#ifdef CONFIG_RPS
struct softnet_data *rps_ipi_list;
#endif
#ifdef CONFIG_NET_FLOW_LIMIT
struct sd_flow_limit __rcu *flow_limit;
#endif
struct Qdisc *output_queue;
struct Qdisc **output_queue_tailp;
struct sk_buff *completion_queue;
#ifdef CONFIG_XFRM_OFFLOAD
struct sk_buff_head xfrm_backlog;
#endif
/* written and read only by owning cpu: */
struct {
u16 recursion;
u8 more;
#ifdef CONFIG_NET_EGRESS
u8 skip_txqueue;
#endif
} xmit;
#ifdef CONFIG_RPS
/* input_queue_head should be written by cpu owning this struct,
* and only read by other cpus. Worth using a cache line.
*/
unsigned int input_queue_head ____cacheline_aligned_in_smp;
/* Elements below can be accessed between CPUs for RPS/RFS */
call_single_data_t csd ____cacheline_aligned_in_smp;
struct softnet_data *rps_ipi_next;
unsigned int cpu;
unsigned int input_queue_tail;
#endif
unsigned int dropped;
struct sk_buff_head input_pkt_queue;
struct napi_struct backlog;
/* Another possibly contended cache line */
spinlock_t defer_lock ____cacheline_aligned_in_smp;
int defer_count;
int defer_ipi_scheduled;
struct sk_buff *defer_list;
call_single_data_t defer_csd;
};
此外，net_dev_init 注册了两个软中断处理函数，分别用 net_rx_action 和 net_tc_action 中断函数处理接收和发送的数据包。open_softirq(NET_TX_SOFTIRQ, net_tc_action);
open_softirq(NET_RX_SOFTIRQ, net_rx_action);
open_softirq 函数将软中断类型和处理函数对存在 softirq_vec 里，当有软中断到来时，通过查此表来找对应的中断处理函数，代码如下：void open_softirq(int nr, void (*action)(struct softirq_action *))
{
/* softirq_vec 是静态变量 */
softirq_vec.action = action;
}
1.7 协议栈初始化内核中的fs_initcall和subsys_initcall类似，也是模块初始化的入口。fs_initcall调用 inet_init 完成网络协议栈模块初始化，主要流程有：
[*]将 TCP、UDP 和 ICMP 的接收函数注册到 inet_protos 数组中;
[*]注册 Socket 相关的信息到 inetsw 链表数组中，便于 inet_create 函数创建套接字；
[*]将 IP 的接收函数注册到 ptype_base 哈希表中。
inet_init 部分代码如下：static int __init inet_init(void) {
struct inet_protosw *q;
struct list_head *r;
int rc;
sock_skb_cb_check_size(sizeof(struct inet_skb_parm));
raw_hashinfo_init(&raw_v4_hashinfo);
/* 注册各种协议的各种处理函数 */
rc = proto_register(&tcp_prot, 1);
rc = proto_register(&udp_prot, 1);
rc = proto_register(&raw_prot, 1);
rc = proto_register(&ping_prot, 1);
/* Tell SOCKET that we are alive... */
(void)sock_register(&inet_family_ops);
#ifdef CONFIG_SYSCTL
ip_static_sysctl_init();
#endif
/* 添加所有基础网络协议，eg. 添加到 inet_protos = icmp_protocol 数组里 */
if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
pr_crit("%s: Cannot add ICMP protocol\n", __func__);
if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
pr_crit("%s: Cannot add UDP protocol\n", __func__);
if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
pr_crit("%s: Cannot add TCP protocol\n", __func__);
#ifdef CONFIG_IP_MULTICAST
if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0)
pr_crit("%s: Cannot add IGMP protocol\n", __func__);
#endif
/* Register the socket-side information for inet_create. */
for (r = &inetsw; r < &inetsw; ++r)
INIT_LIST_HEAD(r);
for (q = inetsw_array; q < &inetsw_array; ++q)
inet_register_protosw(q);
/* 加载 arp 模块 */
arp_init();
/* 加载 ip 模块 */
ip_init();
/* Initialise per-cpu ipv4 mibs */
if (init_ipv4_mibs())
panic("%s: Cannot init ipv4 mibs\n", __func__);
/* Setup TCP slab cache for open requests. */
tcp_init();
/* Setup UDP memory threshold */
udp_init();
/* Add UDP-Lite (RFC 3828) */
udplite4_register();
/* RAW 类型数据包 */
raw_init();
ping_init();
/* 加载 icmp 模块 */
if (icmp_init() < 0)
panic("Failed to create the ICMP control socket.\n");
/* Initialise the multicast router */
#if defined(CONFIG_IP_MROUTE)
if (ip_mr_init())
pr_crit("%s: Cannot init ipv4 mroute\n", __func__);
#endif
if (init_inet_pernet_ops())
pr_crit("%s: Cannot init ipv4 inet pernet ops\n", __func__);
ipv4_proc_init();
ipfrag_init();
/* 将 IP 的接收函数 ip_rcv 注册到 ptype_base 列表里 */
dev_add_pack(&ip_packet_type);
ip_tunnel_core_init();
rc = 0;
}
fs_initcall(inet_init);
1.7.1 inet_protos 数组TCP、UDP 和 ICMP 的net_protocol结构体定义如下，其中有 tcp_v4_rcv、udp_rcv 和 icmp_rcv 函数用来接收数据。static const struct net_protocol tcp_protocol = {
.handler = tcp_v4_rcv,
.err_handler = tcp_v4_err,
.no_policy = 1,
.icmp_strict_tag_validation = 1,
};
static const struct net_protocol udp_protocol = {
.handler = udp_rcv,
.err_handler = udp_err,
.no_policy = 1,
};
static const struct net_protocol icmp_protocol = {
.handler = icmp_rcv,
.err_handler = icmp_err,
.no_policy = 1,
};
inet_init 函数中调用 inet_add_protocol 函数将上面三个结构体注册到 inet_protos 数组里：struct net_protocol __rcu *inet_protos __read_mostly;
int inet_add_protocol(const struct net_protocol *prot, unsigned char protocol) {
return !cmpxchg((const struct net_protocol **)&inet_protos, NULL, prot) ? 0 : -1;
}
1.7.2 inetsw 链表数组/* The inetsw table contains everything that inet_create needs to
* build a new socket.
*/
static struct list_head inetsw;
/* Upon startup we insert all the elements in inetsw_array[] into
* the linked list inetsw.
*/
static struct inet_protosw inetsw_array[] = {
{
.type = SOCK_STREAM,
.protocol = IPPROTO_TCP,
.prot = &tcp_prot,
.ops = &inet_stream_ops,
.flags = INET_PROTOSW_PERMANENT | INET_PROTOSW_ICSK,
},
{
.type = SOCK_DGRAM,
.protocol = IPPROTO_UDP,
.prot = &udp_prot,
.ops = &inet_dgram_ops,
.flags = INET_PROTOSW_PERMANENT,
},
{
.type = SOCK_DGRAM,
.protocol = IPPROTO_ICMP,
.prot = &ping_prot,
.ops = &inet_sockraw_ops,
.flags = INET_PROTOSW_REUSE,
},
{
.type = SOCK_RAW,
.protocol = IPPROTO_IP, /* wild card */
.prot = &raw_prot,
.ops = &inet_sockraw_ops,
.flags = INET_PROTOSW_REUSE,
}
};
inet_init 函数遍历所有协议，循环调用 inet_register_protosw 函数将 inetsw_array 数组中各个协议的操作注册到 inetsw 链表数组中，便于 inet_create 函数根据具体协议类型创建套接字。/* Register the socket-side information for inet_create. */
for (q = inetsw_array; q < &inetsw_array; ++q)
inet_register_protosw(q);
inet_register_protosw 函数部分代码如下：void inet_register_protosw(struct inet_protosw *p)
{
struct list_head *lh;
struct inet_protosw *answer;
int protocol = p->protocol;
struct list_head *last_perm;
...
last_perm = &inetsw;
list_for_each(lh, &inetsw) {
answer = list_entry(lh, struct inet_protosw, list);
/* Check only the non-wild match. */
if ((INET_PROTOSW_PERMANENT & answer->flags) == 0)
break;
if (protocol == answer->protocol)
goto out_permanent;
last_perm = lh;
}
...
}
TCP 和 UDP Scoket 使用的ops结构体如下：const struct proto_ops inet_stream_ops = {
.family = PF_INET,
.owner = THIS_MODULE,
.release = inet_release,
.bind = inet_bind,
.connect = inet_stream_connect,
.socketpair = sock_no_socketpair,
.accept = inet_accept,
.getname = inet_getname,
.poll = tcp_poll,
.ioctl = inet_ioctl,
.gettstamp = sock_gettstamp,
.listen = inet_listen,
.shutdown = inet_shutdown,
.setsockopt = sock_common_setsockopt,
.getsockopt = sock_common_getsockopt,
.sendmsg = inet_sendmsg,
.recvmsg = inet_recvmsg,// 接收数据
#ifdef CONFIG_MMU
.mmap = tcp_mmap,
#endif
.sendpage = inet_sendpage,
.splice_read = tcp_splice_read,
.read_sock = tcp_read_sock,
.read_skb = tcp_read_skb,
.sendmsg_locked = tcp_sendmsg_locked,
.sendpage_locked= tcp_sendpage_locked,
.peek_len = tcp_peek_len,
#ifdef CONFIG_COMPAT
.compat_ioctl = inet_compat_ioctl,
#endif
.set_rcvlowat = tcp_set_rcvlowat,
};
const struct proto_ops inet_dgram_ops = {
.family = PF_INET,
.owner = THIS_MODULE,
.release = inet_release,
.bind = inet_bind,
.connect = inet_dgram_connect,
.socketpair = sock_no_socketpair,
.accept = sock_no_accept,
.getname = inet_getname,
.poll = udp_poll,
.ioctl = inet_ioctl,
.gettstamp = sock_gettstamp,
.listen = sock_no_listen,
.shutdown = inet_shutdown,
.setsockopt = sock_common_setsockopt,
.getsockopt = sock_common_getsockopt,
.sendmsg = inet_sendmsg,
.read_skb = udp_read_skb,
.recvmsg = inet_recvmsg,// 接收数据
.mmap = sock_no_mmap,
.sendpage = inet_sendpage,
.set_peek_off = sk_set_peek_off,
#ifdef CONFIG_COMPAT
.compat_ioctl = inet_compat_ioctl,
#endif
};
TCP 和 UDP Scoket 使用的prot结构体如下：struct proto tcp_prot = {
.name = "TCP",
.owner = THIS_MODULE,
.close = tcp_close,
.pre_connect = tcp_v4_pre_connect,
.connect = tcp_v4_connect,
.disconnect = tcp_disconnect,
.accept = inet_csk_accept,
.ioctl = tcp_ioctl,
.init = tcp_v4_init_sock,
.destroy = tcp_v4_destroy_sock,
.shutdown = tcp_shutdown,
.setsockopt = tcp_setsockopt,
.getsockopt = tcp_getsockopt,
.bpf_bypass_getsockopt = tcp_bpf_bypass_getsockopt,
.keepalive = tcp_set_keepalive,
.recvmsg = tcp_recvmsg,// 接收数据
.sendmsg = tcp_sendmsg,
.sendpage = tcp_sendpage,
.backlog_rcv = tcp_v4_do_rcv,
.release_cb = tcp_release_cb,
.hash = inet_hash,
.unhash = inet_unhash,
.get_port = inet_csk_get_port,
.put_port = inet_put_port,
#ifdef CONFIG_BPF_SYSCALL
.psock_update_sk_prot = tcp_bpf_update_proto,
#endif
.enter_memory_pressure= tcp_enter_memory_pressure,
.leave_memory_pressure= tcp_leave_memory_pressure,
.stream_memory_free = tcp_stream_memory_free,
.sockets_allocated = &tcp_sockets_allocated,
.orphan_count = &tcp_orphan_count,
.memory_allocated = &tcp_memory_allocated,
.per_cpu_fw_alloc = &tcp_memory_per_cpu_fw_alloc,
.memory_pressure = &tcp_memory_pressure,
.sysctl_mem = sysctl_tcp_mem,
.sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_tcp_wmem),
.sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_tcp_rmem),
.max_header = MAX_TCP_HEADER,
.obj_size = sizeof(struct tcp_sock),
.slab_flags = SLAB_TYPESAFE_BY_RCU,
.twsk_prot = &tcp_timewait_sock_ops,
.rsk_prot = &tcp_request_sock_ops,
.h.hashinfo = &tcp_hashinfo,
.no_autobind = true,
.diag_destroy = tcp_abort,
};
struct proto udp_prot = {
.name = "UDP",
.owner = THIS_MODULE,
.close = udp_lib_close,
.pre_connect = udp_pre_connect,
.connect = ip4_datagram_connect,
.disconnect = udp_disconnect,
.ioctl = udp_ioctl,
.init = udp_init_sock,
.destroy = udp_destroy_sock,
.setsockopt = udp_setsockopt,
.getsockopt = udp_getsockopt,
.sendmsg = udp_sendmsg,
.recvmsg = udp_recvmsg,// 接收数据
.sendpage = udp_sendpage,
.release_cb = ip4_datagram_release_cb,
.hash = udp_lib_hash,
.unhash = udp_lib_unhash,
.rehash = udp_v4_rehash,
.get_port = udp_v4_get_port,
.put_port = udp_lib_unhash,
#ifdef CONFIG_BPF_SYSCALL
.psock_update_sk_prot = udp_bpf_update_proto,
#endif
.memory_allocated = &udp_memory_allocated,
.per_cpu_fw_alloc = &udp_memory_per_cpu_fw_alloc,
.sysctl_mem = sysctl_udp_mem,
.sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_udp_wmem_min),
.sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_udp_rmem_min),
.obj_size = sizeof(struct udp_sock),
.h.udp_table = &udp_table,
.diag_destroy = udp_abort,
};
1.7.3 ptype_base 哈希表后面调用 dev_add_pack 函数将 ip_packet_type 结构体注册到 ptype_base 哈希表中，type 是 ETH_P_IP(0x0800)，func 是 ip_rcv 函数。static struct packet_type ip_packet_type __read_mostly = {
.type = cpu_to_be16(ETH_P_IP),
.func = ip_rcv,
.list_func = ip_list_rcv,
};
extern struct list_head ptype_all __read_mostly;
struct list_head ptype_base __read_mostly;
void dev_add_pack(struct packet_type *pt) {
struct list_head *head = ptype_head(pt);
spin_lock(&ptype_lock);
list_add_rcu(&pt->list, head);
spin_unlock(&ptype_lock);
}
static inline struct list_head *ptype_head(const struct packet_type *pt) {
if (pt->type == htons(ETH_P_ALL))
return pt->dev ? &pt->dev->ptype_all : &ptype_all;
else
return pt->dev ? &pt->dev->ptype_specific : &ptype_base;
}
除了 IP 还有下面协议：$ grep -R dev_add_pack net/{ipv4,packet}/*
net/ipv4/af_inet.c: dev_add_pack(&ip_packet_type); //IP
net/ipv4/arp.c: dev_add_pack(&arp_packet_type);//ARP
net/ipv4/ipconfig.c: dev_add_pack(&rarp_packet_type);
net/ipv4/ipconfig.c: dev_add_pack(&bootp_packet_type);
net/packet/af_packet.c: dev_add_pack(&po->prot_hook); //用于抓包
net/packet/af_packet.c: dev_add_pack(&f->prot_hook); //用于抓包
包的类型可以通过下面命令查看：$ cat /proc/net/ptype # packet type (skb->protocol)
Type Device Function
0800 ip_rcv
0806 arp_rcv
86dd ipv6_rcv
1.7.4 小结好了，inet_protos 存储着 TCP、UDP 和 ICMP 接收数据的 udp_rcv 和 icmp_rcv 函数地址，ptype_base 存储着接收数据的 ip_rcv 函数地址。后面会看到软中断中会通过 ptype_base 找到 ip_rcv 函数地址，进而将 IP 包正确地送到 ip_rcv 中执行。在 ip_rcv 中将会通过 inet_protos 找到 TCP 或者 UDP 的处理函数，再而把包转发给 tcp_v4_rcv 或者 udp_rcv 函数。ip_rcv、tcp_v4_rcv、udp_rcv 和 icmp_rcv 函数已经注册好了，就等待数据包的到来。最后通过 inet_create 函数根据具体协议类型和 inetsw 链表数组创建套接字来完成接收数据。二、网络收包概述前面主要介绍了系统启动时的初始化操作，接下来开始正式介绍网络的详细收包过程，从网络接口层（L1）、网络层（L2）、传输层（L3）、套接字（L3.5）再到应用层（L4）的整个过程。
图2 整体流程图
从硬中断到协议栈的调用链：
图3 完整调用链
页:
[1]