深入理解Linux网络随笔（一）：内核是如何接收网络包的（上篇）

深入理解Linux网络随笔（一）：内核是如何接收网络包的（上篇） 1、TCP/IP模型概述

从Linux视角看，TCP/IP网络分层模型包括用户空间和内核空间。用户空间（应用层）负责HTTP、FTP等协议的网络服务。内核空间则实现了各个协议层：

传输层：TCP确保可靠传输，UDP提供无连接快速传输。网络层：IP负责数据包路由，ICMP用于网络诊断。链路层：通过网络设备驱动处理数据帧和硬件交互。物理层：网卡实现物理信号收发。

各层通过封装与解封装协作完成数据传输，内核通过socket接口支持用户进程与网络交互。

​

2、内核收包过程

内核收包路径如下图所示，其核心步骤小结如下：

1、网卡NIC接收到网络数据包

由于网卡位于物理层，此时接收的数据以电信号形式存在，网卡将电信号转换为数字信号，并进行数据帧的封装和预处理。

2、以DMA方式将数据帧写放入内存

采用直接内存访问（DMA)技术，将数据帧直接写入内核中预定的缓冲区，减少CPU负担并提高数据传输效率。

3、网卡触发硬中断通知CPU

4、软中断处理

CPU收到中断请求，调用网络设备驱动注册的中断处理函数，将中断请求转为软中断，提交给软中断处理机制。硬中断的目的是尽快响应硬件，而软中断则允许系统进行更复杂的处理。

5、ksoftirqd内核线程处理，poll轮询收包

软中断请求由ksoftirqd内核线程处理，通过poll轮询的方式处理所有网络相关的软中断任务。批量处理多个网络数据包，减少中断上下文切换的开销。网卡的接收缓冲区（Ring Buffer）中取出数据，将其封装为Socket缓冲区（skb）对象。skb是Linux内核中用于描述网络数据包的数据结构。

6、协议栈处理网络帧

协议栈开始处理网路帧，处理完成的data存于socket的接收队列（每个进程通过socket与内核网络栈通信，接收到的数据会被放入该进程对应的接收队列）。socket充当用户进程和内核通信桥梁

7、内核唤醒用户进程

调用如recv()或read()等系统调用读取数据，数据会从接收队列中取出并交给用户空间。

2.1Linux启动 2.1.1 创建ksoftirqd内核线程

ksoftirqd 是一种 per-CPU 内核线程，意味着每个 CPU 核心都会有一个独立的 ksoftirqd 线程来处理该核心的软中断。在 Linux 内核中，ksoftirqd 的优先级相对较低。当系统中有更高优先级的任务（如硬中断、实时任务或其他重要进程）需要处理时，ksoftirqd 线程会被调度器推迟执行，等待 CPU 资源空闲。只有当 CPU 处于空闲状态，或者软中断的处理已经无法继续推迟时，ksoftirqd 线程才会被调度执行。这种延迟处理机制，使得ksoftirqd 只会在 CPU 空闲或者软中断处理不能再推迟时才会被调度执行，最大化 CPU 的利用率，避免不必要的资源浪费。 ps命令查看**ksoftirq内核线程， **ps -eLf | grep ksoftirqd 命令查看到了 [ksoftirqd/0]、[ksoftirqd/1]、[ksoftirqd/2]、[ksoftirqd/3] 这 4 个 ksoftirq 内核线程，使用 nproc 命令查看到当前机器的 CPU 核心数为 4 。ksoftirqd线程数量等于机器的CPU核心数。

Linux内核启动过程中，系统初始化的时候在kernel/smpboot.c中调用了smpboot_register_percpu_thread为每个CPU核心启动一个内核线程，该函数会进一步执行到spawn_ksoftirqd（位于kernel/ksoftirqd.c）来创建softirqd线程。

//kernel/softirq.c static __init int spawn_ksoftirqd(void) { cpuhp_setup_state_nocalls(CPUHP_SOFTIRQ_DEAD, "softirq:dead", NULL, takeover_tasklets);//注册CPU的热插拔状态，确保在CPU下线时能够正确处理软中断 BUG_ON(smpboot_register_percpu_thread(&softirq_threads));//负责在每一个CPU上注册并启动软中断线程softirqd return 0; } early_initcall(spawn_ksoftirqd);

spawn_ksoftirqd会在内核启动时创建并初始化每个CPU上的软中断线程，并为每个CPU设置适当的热插拔状态。通过这种方式，系统可以在多核环境下并行处理软中断。

static struct smp_hotplug_thread softirq_threads = { .store = &ksoftirqd, .thread_should_run = ksoftirqd_should_run, .thread_fn = run_ksoftirqd, .thread_comm = "ksoftirqd/%u", };

smp_hotplug_thread结构体描述热插拔线程（hotplug thread），即在系统中随着 CPU 的启停而创建或销毁的线程。softirq_threads 专门用来描述软中断线程，设置回调函数ksoftirqd_should_run，决定线程是否需要继续执行；设置回调函数run_ksoftirqd处理软中断任务。（软中断核心流程不做解释）

// include/linux/interrupt.h enum { HI_SOFTIRQ = 0, // 高优先级软中断，通常用于处理紧急任务 TIMER_SOFTIRQ, // 定时器软中断，处理内核定时器相关的任务 NET_TX_SOFTIRQ, // 网络传输发送软中断，用于处理网络发送操作 NET_RX_SOFTIRQ, // 网络传输接收软中断，用于处理网络接收操作 BLOCK_SOFTIRQ, // 块设备软中断，处理与块设备（如硬盘）相关的任务 BLOCK_IOPOLL_SOFTIRQ, // 块 I/O 轮询软中断，负责检查 I/O 操作是否完成 TASKLET_SOFTIRQ, // tasklet 软中断，处理延迟任务 SCHED_SOFTIRQ, // 调度软中断，处理任务调度相关的任务 HRTIMER_SOFTIRQ, // 高分辨率定时器软中断，处理高精度定时器任务 RCPU_SOFTIRQ, // RCPU 同步软中断，涉及到 RCPU 的更新和回调处理 NR_SOFTIRQS // 软中断的总数，表示系统中所有软中断类型的数量 };

软中断类型中，网络传输发送软中断NET_TX_SOFTIRQ，网络传输接收软中断NET_RX_SOFTIRQ。

2.1.2网络子系统初始化

Linux内核通过调用subsys_initcall来初始化各个子系统，使用subsys_initcall(net_dev_init)初始化网络设备。

static int __init net_dev_init(void) { ...... /* * Initialise the packet receive queues. */ // *初始化每个 CPU 上的网络接收队列和软中断相关的数据结构。 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);//处理队列 ...... init_gro_hash(&sd->backlog);//哈希表 sd->backlog.poll = process_backlog;//回调 sd->backlog.weight = weight_p;//Gro权值 } //初始化阶段结束 dev_boot_phase = 0; /* The loopback device is special if any other network devices * is present in a network namespace the loopback device must * be present. Since we now dynamically allocate and free the * loopback device ensure this invariant is maintained by * keeping the loopback device as the first device on the * list of network devices. Ensuring the loopback devices * is the first device that appears and the last network device * that disappears. */ //注册回环设备 if (register_pernet_device(&loopback_net_ops)) goto out; //注册默认网路设备 if (register_pernet_device(&default_device_ops)) goto out; //启动网络传输发送软中断 open_softirq(NET_TX_SOFTIRQ, net_tx_action); //启动网络传输接收软中断 open_softirq(NET_RX_SOFTIRQ, net_rx_action); // 设置 CPU 热插拔状态，注册 CPU 下线时的清理函数 rc = cpuhp_setup_state_nocalls(CPUHP_NET_DEV_DEAD, "net/dev:dead", NULL, dev_cpu_dead); WARN_ON(rc < 0); rc = 0; out: return rc; }

网络子系统初始化过程，为每个CPU初始化softnet_data结构体，进行软中断处理和管理网络数据包队列，为软中断注册处理函数使用方法open_softirq，网络传输发送软中断NET_TX_SOFTIRQ处理注册回调处理函数net_tx_action，网络传输接收软中断NET_RX_SOFTIRQ处理注册回调处理函数net_rx_action。

struct softnet_data { struct list_head poll_list; struct sk_buff_head process_queue; /* stats */ unsigned int processed; unsigned int time_squeeze; #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 received_rps; 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; };

在每个 softnet_data 结构体中，poll_list 用来链接需要轮询的网络设备接口。每个 CPU 上的 softnet_data 结构体都有一个 poll_list，记录了当前需要处理的网络设备。这样可以通过轮询这些设备的接口来处理网络数据包。

在 Linux 网络栈的工作流程中，NAPI 会定期轮询设备（而不是每次包都中断），有效地减少中断处理的负载。每个网络设备的 NAPI 结构体都会被放入这个链表中，表示这个设备正在进行轮询，等待数据包的处理。

void open_softirq(int nr, void (*action)(struct softirq_action *)) { softirq_vec[nr].action = action; }

软中断处理函数绑定软中断号通过softirq_vec数组实现，每一个元素对应一种软中断类型。

2.1.3协议栈注册

Linux内核实现了网络层的IP协议，同样也实现了TCP、UDP协议，协议栈初始化入口函数为fs_initcall(inet_init)，调用inet_init进行网络协议栈注册。

static int __init inet_init(void) { ...... 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__); ...... dev_add_pack(&ip_packet_type); }

使用inet_add_protocol向协议栈注册协议，协议定义结构体如下：

static struct packet_type ip_packet_type __read_mostly = { .type = cpu_to_be16(ETH_P_IP), .func = ip_rcv, .list_func = ip_list_rcv, }; static const struct net_protocol icmp_protocol = { .handler = icmp_rcv, .err_handler = icmp_err, .no_policy = 1, }; static const struct net_protocol udp_protocol = { .handler = udp_rcv, .err_handler = udp_err, .no_policy = 1, }; static const struct net_protocol tcp_protocol = { .handler = tcp_v4_rcv,//回调处理函数 .err_handler = tcp_v4_err, .no_policy = 1, .icmp_strict_tag_validation = 1, };

dev_add_pack负责将新的packet_type结构体添加于协议类型链表。

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);// 将新的 packet_type 结构体添加到链表中 spin_unlock(&ptype_lock); }

ptype_head 是一个内联函数，根据传入的 packet_type 结构体 (pt) 获取对应协议类型的链表头。这个链表存储了与该协议类型相关的处理程序。它根据协议类型和设备信息决定返回哪个链表的头部。

static inline struct list_head *ptype_head(const struct packet_type *pt) { if (pt->type == htons(ETH_P_ALL)) // 如果协议类型是 ETH_P_ALL return pt->dev ? &pt->dev->ptype_all : &ptype_all; // 返回设备特定的链表或全局链表 else // 如果协议类型不是 ETH_P_ALL return pt->dev ? &pt->dev->ptype_specific : &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK]; // 返回设备特定的链表或根据协议类型哈希的链表 }

协议类型通过 ntohs(pt->type) & PTYPE_HASH_MASK 进行哈希计算，决定将其对应的 packet_type 结构体插入到 ptype_base 数组中的哪个位置，在这里IP协议会注册到ptype_base 哈希表，存储ip_rcv函数处理地址。

int inet_add_protocol(const struct net_protocol *prot, unsigned char protocol) { return !cmpxchg((const struct net_protocol **)&inet_protos[protocol], NULL, prot) ? 0 : -1; } EXPORT_SYMBOL(inet_add_protocol);

TCP、UDP、ICMP协议注册方式与IP协议不同，通过inet_add_protocol函数调用完成协议注册，将协议类型protocol对应的处理程序添加于inet_protos数组。

2.1.4网卡驱动初始化

每一个驱动程序（不仅仅包括网卡驱动程序）会使用module_init向内核注册一个初始化函数，当驱动程序被加载时，内核会调用这个函数，以igb网卡驱动程序为例，其初始化函数如下。

static int __init igb_init_module(void) { ...... ret = pci_register_driver(&igb_driver); return ret; } module_init(igb_init_module); //驱动相关信息 static struct pci_driver igb_driver = { .name = igb_driver_name, .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 };

注册PCI驱动程序在pci_register_driver函数完成，函数调用关系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; // 绑定到 PCI 总线类型 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); // 初始化锁，用于动态分配的设备 ID INIT_LIST_HEAD(&drv->dynids.list); // 初始化动态设备列表 /* register with core */ return driver_register(&drv->driver); // 注册驱动到内核的核心驱动模型中 } EXPORT_SYMBOL(__pci_register_driver);

__pci_register_driver调用完成后，Linux内核就会知道驱动相关信息（如igb网卡驱动名称、igb_probe地址等），当网卡设备被识别以后，Linux内核会调用.probe方法（igb_probe方法)。

static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { ...... //获取MAC地址 if (eth_platform_get_mac_address(&pdev->dev, hw->mac.addr)) { /* copy the MAC address out of the NVM */ if (hw->mac.ops.read_mac_addr(hw)) dev_err(&pdev->dev, "NVM Read Error\n"); } //DMA初始化 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); //注册ethtool函数 igb_set_ethtool_ops(netdev); //注册net_device_ops、netdev等 netdev = alloc_etherdev_mq(sizeof(struct igb_adapter), IGB_MAX_TX_QUEUES); if (!netdev) goto err_alloc_etherdev; SET_NETDEV_DEV(netdev, &pdev->dev); pci_set_drvdata(pdev, netdev); adapter = netdev_priv(netdev); adapter->netdev = netdev; adapter->pdev = pdev; hw = &adapter->hw; hw->back = adapter; ...... netdev->netdev_ops = &igb_netdev_ops; // 注册NAPI相关的资源分配 err = igb_alloc_q_vector(adapter); if (err) goto err_alloc_q_vector; ...... }

igb_probe初始化过程中，调用igb_alloc_q_vector–>netif_napi_add，初始化NAPI机制，对于igb网卡来说，NAPI机制的poll函数是igb_poll。

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) { .... /* initialize NAPI */ netif_napi_add(adapter->netdev, &q_vector->napi, igb_poll); .... } 2.1.5启动网卡 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, };

igb_netdev_ops结构体定义了网络设备常见的执行操作，当网卡被启动时调用回调函数igb_open。函数调用关系igb_open–>_igb_open。

static int __igb_open(struct net_device *netdev, bool resuming) { ...... netif_carrier_off(netdev); /* allocate transmit descriptors */ err = igb_setup_all_tx_resources(adapter); if (err) goto err_setup_tx; /* allocate receive descriptors */ err = igb_setup_all_rx_resources(adapter); if (err) goto err_setup_rx; err = igb_request_irq(adapter); if (err) goto err_req_irq; ...... igb_irq_enable(adapter); for (i = 0; i < adapter->num_q_vectors; i++) napi_enable(&(adapter->q_vector[i]->napi)); ...... }

__igb_open中调用igb_setup_all_tx_resources分配TX队列内存，调用igb_setup_all_rx_resources分配RX队列内存，调用igb_request_irq注册中断处理函数，igb_irq_enable启用硬中断， napi_enable启用NAPI机制。

static int igb_setup_all_rx_resources(struct igb_adapter *adapter) { struct pci_dev *pdev = adapter->pdev; int i, err = 0; for (i = 0; i < adapter->num_rx_queues; i++) { err = igb_setup_rx_resources(adapter->rx_ring[i]); ...... } } return err; }

循环创建若干个接收队列，调用igb_setup_rx_resources为RX队分配资源，前期准备工作已完成，等待网络数据包到来~~。

int igb_setup_rx_resources(struct igb_ring *rx_ring) { ...... //申请igb_rx_buffer数组内存供内核使用 size = sizeof(struct igb_rx_buffer) * rx_ring->count; rx_ring->rx_buffer_info = vmalloc(size); if (!rx_ring->rx_buffer_info) goto err; //申请e1000_adv_rx_desc数组内存供网卡使用 /* 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); rx_ring->desc = dma_alloc_coherent(dev, rx_ring->size, &rx_ring->dma, GFP_KERNEL); if (!rx_ring->desc) goto err; //初始化 rx_ring->next_to_alloc = 0; rx_ring->next_to_clean = 0; rx_ring->next_to_use = 0; ...... return 0; }

参考资料：《深入理解linux网络》