深入理解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上注册并启动软中断线程softirqdreturn 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_RPSstruct softnet_data	*rps_ipi_list;
#endif
#ifdef CONFIG_NET_FLOW_LIMITstruct sd_flow_limit __rcu *flow_limit;
#endifstruct Qdisc		*output_queue;struct Qdisc		**output_queue_tailp;struct sk_buff		*completion_queue;
#ifdef CONFIG_XFRM_OFFLOADstruct sk_buff_head	xfrm_backlog;
#endif/* written and read only by owning cpu: */struct {u16 recursion;u8  more;
#ifdef CONFIG_NET_EGRESSu8  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;
#endifunsigned 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_ALLreturn pt->dev ? &pt->dev->ptype_all : &ptype_all;  // 返回设备特定的链表或全局链表else  // 如果协议类型不是 ETH_P_ALLreturn 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);        // 初始化锁，用于动态分配的设备 IDINIT_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;
}