3、接收网络数据
3.1.1硬中断处理
数据帧从网线到达网卡时候，首先到达网卡的接收队列，网卡会在初始化时分配给自己的RingBuffer中寻找可用内存位置，寻找成功后将数据帧DMA到网卡关联的内存里，DMA操作完成后，网卡会向CPU发起一个硬中断，通知CPU有数据到达。
启动网卡到硬中断注册处理函数调用流程ign_open-->igb_request_irq-->igb_request_msix-->igb_msix_ring。
static irqreturn_t igb_msix_ring(int irq, void *data)
{
struct igb_q_vector *q_vector = data;
/* Write the ITR value calculated from the previous interrupt. */
//记录硬件中断频率
igb_write_itr(q_vector);
//调度NAPI机制
napi_schedule(&q_vector->napi);
return IRQ_HANDLED;
}
napi_schedule将q_vector关联的NAPI结构添加于调度队列，函数调用关系napi_schedule-->__napi_schedule-->____napi_schedule。
static inline void ____napi_schedule(struct softnet_data *sd,
struct napi_struct *napi)
{
......
list_add_tail(&napi->poll_list, &sd->poll_list);
__raise_softirq_irqoff(NET_RX_SOFTIRQ);
}
基于软中断的NAPI处理调用list_add_tail修改Per-CPU变量的softnet_data的poll_list，将驱动napi_struct传入的poll_list添加于软中断的poll_list，触发NET_RX_SOFTIRQ类型软中断。
void __raise_softirq_irqoff(unsigned int nr)
{
//禁中断
lockdep_assert_irqs_disabled();
//追踪软中断
trace_softirq_raise(nr);
//触发
or_softirq_pending(1UL << nr);
}
#define or_softirq_pending(x) (S390_lowcore.softirq_pending |= (x))
通过or操作符将软中断nr对应的位设置为1，调用or_softirq_pending将该标志位添加于软中断挂起队列，触发软中断。
3.1.2软中断处理
前文分析软中断处理通过ksfortirq内核线程处理，会调用两个函数ksoftirqd_should_run和run_ksoftirqd，均调用local_softirq_pending进行处理。
#define local_softirq_pending() (S390_lowcore.softirq_pending)
static int ksoftirqd_should_run(unsigned int cpu)
{
return local_softirq_pending();
}
static void run_ksoftirqd(unsigned int cpu)
{
ksoftirqd_run_begin();
if (local_softirq_pending()) {
/*
* We can safely run softirq on inline stack, as we are not deep
* in the task stack here.
*/
__do_softirq();
ksoftirqd_run_end();
cond_resched();
return;
}
ksoftirqd_run_end();
}
硬中断处理是由硬件中断服务例程（ISR）触发的，调用local_softirq_pending标记软中断挂起状态，真正的中断处理由ksfortirq内核线程处理，函数调用逻辑run_ksoftirqd-->__do_softirq。
asmlinkage __visible void __softirq_entry __do_softirq(void)
{
.....
// 获取当前 CPU 上待处理的软中断类型的掩码
pending = local_softirq_pending();
// 遍历所有待处理的软中断
while ((softirq_bit = ffs(pending))) {
unsigned int vec_nr;
int prev_count;
// 将指针 'h' 移动到当前待处理软中断类型的处理函数
h += softirq_bit - 1;
// 计算当前软中断处理函数在软中断处理数组中的索引
vec_nr = h - softirq_vec;
// 获取当前任务的预占用计数
prev_count = preempt_count();
// 统计当前软中断类型的处理次数
kstat_incr_softirqs_this_cpu(vec_nr);
// 调用 trace 函数跟踪软中断的进入
trace_softirq_entry(vec_nr);
// 执行软中断的处理函数
h->action(h);
// 调用 trace 函数跟踪软中断的退出
trace_softirq_exit(vec_nr);
......
// 处理下一个软中断类型
h++;
// 右移 pending 位图，检查下一个待处理的软中断
pending >>= softirq_bit;
}
}
__do_softirq根据传入的软中断类型处理所有挂起的软中断，通过h->action(h)执行具体的软中断处理函数。硬中断中的设置软中断标记，和ksoftirqd中的判断是否有软中断到达，都是基于smp_processor_id()的。只要硬中断在哪个CPU上被响应，那么软中断也是在这个CPU上处理的，针对Linux软中断消耗集中一个核现象，方法：调整硬中断CPU亲和性，硬中断打散于不同核上。
设备初始化时调用open_softirq(NET_RX_SOFTIRQ, net_rx_action)，将网络接收软中断 NET_RX_SOFTIRQ 绑定到 net_rx_action 处理函数，收到软中断类型NET_RX_SOFTIRQ会调用net_rx_action接收软中断，处理网络数据包。
static __latent_entropy void net_rx_action(struct softirq_action *h)
{
struct softnet_data *sd = this_cpu_ptr(&softnet_data); // 获取当前 CPU 的软中断数据
unsigned long time_limit = jiffies +
usecs_to_jiffies(READ_ONCE(netdev_budget_usecs)); // 计算软中断的超时时间
int budget = READ_ONCE(netdev_budget); // 获取软中断的处理预算（每次允许处理的最大数据包数量）
LIST_HEAD(list); // 创建链表 list，用于存储要处理的 napi 结构体
LIST_HEAD(repoll); // 创建链表 repoll，用于存储需要重新投递的 napi 结构体
local_irq_disable(); // 关闭CPU硬中断
list_splice_init(&sd->poll_list, &list); // 将当前 CPU 上的 poll_list 中的元素移动到 list 中
local_irq_enable(); // 重新启用本地中断
for (;;) {
struct napi_struct *n;
skb_defer_free_flush(sd); // 清理延迟释放的数据包
if (list_empty(&list)) { // 如果没有要处理的 napi 结构体
if (!sd_has_rps_ipi_waiting(sd) && list_empty(&repoll)) // 如果没有需要处理的 RPS IPI 和 repoll 列表为空
goto end; // 结束处理
break; // 如果有需要的工作，继续处理
}
n = list_first_entry(&list, struct napi_struct, poll_list); // 获取待处理的第一个 napi 结构体
budget -= napi_poll(n, &repoll); // 调用 napi_poll 处理数据包，更新剩余预算
/* 如果软中断窗口已耗尽，则退出处理
* 允许最多运行 2 个 jiffies，这会允许平均延迟为 1.5/HZ
*/
if (unlikely(budget <= 0 ||
time_after_eq(jiffies, time_limit))) {
sd->time_squeeze++; // 记录时间压缩（即软中断处理超时）
break; // 退出循环
}
}
local_irq_disable(); // 禁用本地中断
// 将 repoll 和 list 的元素合并到 sd->poll_list 中
list_splice_tail_init(&sd->poll_list, &list);
list_splice_tail(&repoll, &list);
list_splice(&list, &sd->poll_list);
// 如果 poll_list 中仍有元素，重新唤起软中断
if (!list_empty(&sd->poll_list))
__raise_softirq_irqoff(NET_RX_SOFTIRQ);
net_rps_action_and_irq_enable(sd); // 处理 RPS（Receive Packet Steering）和启用中断
end:;
}
遍历所有待处理的网络接收软中断，核心获取当前CPU软中断数据softnet_data，list_first_entry遍历poll_list，调用 napi_poll 处理数据包，上文中分析了NAPI机制的poll函数是igb_poll。
static int igb_poll(struct napi_struct *napi, int budget)
{
.....
//TX发送队列
if (q_vector->tx.ring)
clean_complete = igb_clean_tx_irq(q_vector, budget);
//RX接收队列
if (q_vector->rx.ring) {
int cleaned = igb_clean_rx_irq(q_vector, budget);
// 累计本次轮询处理的数据包数量
work_done += cleaned;
if (cleaned >= budget)
clean_complete = false;
}
......
return work_done;
}
igb_poll是 igb 网卡驱动中 NAPI 轮询的核心函数，负责清理发送和接收队列的中断。核心处理逻辑igb_clean_rx_irq和igb_clean_tx_irq。
static int igb_clean_rx_irq(struct igb_q_vector *q_vector, const int budget)
{
......
rx_desc = IGB_RX_DESC(rx_ring, rx_ring->next_to_clean); // 获取当前的接收描述符
size = le16_to_cpu(rx_desc->wb.upper.length); // 获取数据包的大小
rx_buffer = igb_get_rx_buffer(rx_ring, size, &rx_buf_pgcnt); // 获取接收缓冲区
pktbuf = page_address(rx_buffer->page) + rx_buffer->page_offset; // 获取数据包的缓冲区地址
if (!skb) {
unsigned char *hard_start = pktbuf - igb_rx_offset(rx_ring); // 获取数据包的起始地址
unsigned int offset = pkt_offset + igb_rx_offset(rx_ring); // 计算数据包的偏移
xdp_prepare_buff(&xdp, hard_start, offset, size, true); // 为 XDP 准备数据包
xdp_buff_clear_frags_flag(&xdp); // 清除 XDP 的分段标志
skb = igb_run_xdp(adapter, rx_ring, &xdp); // 运行 XDP 处理，构建 skb
}
if (IS_ERR(skb)) {
unsigned int xdp_res = -PTR_ERR(skb);
if (xdp_res & (IGB_XDP_TX | IGB_XDP_REDIR)) { // 如果是 XDP 传输或重定向
xdp_xmit |= xdp_res;
igb_rx_buffer_flip(rx_ring, rx_buffer, size); // 切换缓冲区
} else {
rx_buffer->pagecnt_bias++; // 增加页面计数偏移
}
total_packets++; // 增加数据包计数
total_bytes += size; // 增加字节数
}else if (skb) {
igb_add_rx_frag(rx_ring, rx_buffer, skb, size); // 将接收到的数据包添加到 skb 中
}
napi_gro_receive(&q_vector->napi, skb); // 将 skb 传递给 NAPI 进行进一步处理
igb_put_rx_buffer(rx_ring, rx_buffer, rx_buf_pgcnt); // 释放接收缓冲区
if (cleaned_count)
igb_alloc_rx_buffers(rx_ring, cleaned_count);
......
}
igb_clean_tx_irq核心将数据帧从RingBuffer中摘下，igb_alloc_rx_buffers重新申请新的skb再重新挂起，NAPI机制下一步处理调用napi_gro_receive。
gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
{
......
ret = napi_skb_finish(napi, skb, dev_gro_receive(napi, skb));
......
return ret;
}
EXPORT_SYMBOL(napi_gro_receive);
napi_gro_receive用于网卡GRO特性，合并多个小的数据包（通常是同一流的 TCP 数据包）为一个较大的数据包，从而减少协议栈的处理开销。调用napi_skb_finish完成GRO处理。
static gro_result_t napi_skb_finish(struct napi_struct *napi,
struct sk_buff *skb,
gro_result_t ret)
{
switch (ret) {
case GRO_NORMAL:
gro_normal_one(napi, skb, 1);
break;
case GRO_MERGED_FREE:
if (NAPI_GRO_CB(skb)->free == NAPI_GRO_FREE_STOLEN_HEAD)
napi_skb_free_stolen_head(skb);
else if (skb->fclone != SKB_FCLONE_UNAVAILABLE)
__kfree_skb(skb);
else
__kfree_skb_defer(skb);
break;
case GRO_HELD:
case GRO_MERGED:
case GRO_CONSUMED:
break;
}
return ret;
}
正常数据包处理GRO_NORMAL，需要合并的数据包处理GRO_MERGED_FREE，根据不同的方式选择不同的释放方式，函数调用逻辑gro_normal_one-->gro_normal_list-->netif_receive_skb_list_internal-->__netif_receive_skb_list-->__netif_receive_skb_core，数据包发送于协议栈。
3.1.3网络协议栈处理
static int __netif_receive_skb_core(struct sk_buff **pskb, bool pfmemalloc,
struct packet_type **ppt_prev)
{
......
// 遍历全局的协议类型链表并传递 skb,tcpdump入口
list_for_each_entry_rcu(ptype, &ptype_all, list) {
if (pt_prev)
ret = deliver_skb(skb, pt_prev, orig_dev);
pt_prev = ptype;
}
type = skb->protocol;
// 如果没有精确匹配，处理协议类型
if (likely(!deliver_exact)) {
deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
&ptype_base[ntohs(type) & PTYPE_HASH_MASK]);
}
// 传递到设备特定协议链表
deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
&orig_dev->ptype_specific);
// 如果 skb 的设备不是原始设备，进行协议处理
if (unlikely(skb->dev != orig_dev)) {
deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
&skb->dev->ptype_specific);
}
}
ptype_all 是一个全局链表，包含了所有已注册的协议类型及其处理回调，在 __netif_receive_skb_core 函数中，首先会遍历这个链表，依次处理每个协议类型，并调用与协议相关的处理函数，ptype_base 是一个基于协议类型的哈希表，它包含了协议类型（如 IPv4、IPv6、TCP 等）对应的特定处理函数，当数据包的协议类型与哈希表中的某个条目匹配时，数据包会被传递到该处理函数。例如，ip_rcv 的地址通常是保存在 ptype_base 哈希表中的。
static inline int deliver_skb(struct sk_buff *skb,
struct packet_type *pt_prev,
struct net_device *orig_dev)
{
......
//调用协议处理函数 (pt_prev->func) 并将 skb 传递给它
return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
}
static struct packet_type ip_packet_type __read_mostly = {
.type = cpu_to_be16(ETH_P_IP),
.func = ip_rcv,
};
deliver_skb 将接收到的 skb传递给协议处理函数。从 packet_type 结构体中获取 func 字段，并将 skb 数据包传递给该函数进行处理。这里的 pt_prev->func 是一个协议回调函数，指向处理该协议类型数据包的函数（例如，对于 IPv4 数据包，func 指向 ip_rcv 函数）。
3.1.4IP层处理
数据包经过协议栈处理后会被传递到IP层进行处理，收包方向IP层入口函数ip_rcv。
int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt,
struct net_device *orig_dev)
{
struct net *net = dev_net(dev);
skb = ip_rcv_core(skb, net);
if (skb == NULL)
return NET_RX_DROP;
return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
net, NULL, skb, dev, NULL,
ip_rcv_finish);
}
接收到的数据包会经过ip_rcv_core进行基本处理，例如对数据包进行有效性检查、协议解析等，处理成功会触发IPV4数据包Netfilter钩子链，在 NF_INET_PRE_ROUTING 钩子处插入数据包处理，NF_INET_PRE_ROUTING 是所有接收数据包到达的第一个 hook 触发点，在路由判断之前执行，对应的回调函数ip_rcv_finish。
static int ip_rcv_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
{
struct net_device *dev = skb->dev;
int ret;
/* if ingress device is enslaved to an L3 master device pass the
* skb to its handler for processing
*/
skb = l3mdev_ip_rcv(skb);
if (!skb)
return NET_RX_SUCCESS;
ret = ip_rcv_finish_core(net, sk, skb, dev, NULL);
if (ret != NET_RX_DROP)
ret = dst_input(skb);
return ret;
}
ip_rcv_finish负责接收和处理通过 IPv4 协议栈传输的网络数据包，核心的IP数据包处理函数调用dst_input传递数据包。
static inline int dst_input(struct sk_buff *skb)
{
return INDIRECT_CALL_INET(skb_dst(skb)->input,
ip6_input, ip_local_deliver, skb);
}
基于路由类型skb_dst(skb)选择对应的处理函数，通过INDIRECT_CALL_INET宏选择IPV4/IPV6协议数据包处理函数，IPV4选择调用ip_local_deliver。
int ip_local_deliver(struct sk_buff *skb)
{
/*
* Reassemble IP fragments.
*/
struct net *net = dev_net(skb->dev);
if (ip_is_fragment(ip_hdr(skb))) {
if (ip_defrag(net, skb, IP_DEFRAG_LOCAL_DELIVER))
return 0;
}
return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN,
net, NULL, skb, skb->dev, NULL,
ip_local_deliver_finish);
}
EXPORT_SYMBOL(ip_local_deliver);
ip_local_deliver处理本地IPV4数据包，接收一个网络数据包skb，调用ip_is_fragment检查是否需要进行IP分片重组，对不分片/已重组的数据包调用NF_HOOK，NF_INET_LOCAL_IN处理本地接收到的数据包(并不是经过路由转发的数据包)，对应的处理函数ip_local_deliver_finish。
参考资料：《深入理解Linux网络》
