第12章 网络 （4）
目录
12.7 网络设备层
12.7.2 接收分组
12.7.3 发送分组
本专栏文章将有70篇左右，欢迎+关注，查看后续文章。
12.7 网络设备层
12.7.2 接收分组
接收时，使用中断通知分组到达。几乎所有网卡都支持DMA。
一个 skb如何找到对应网络设备？
skb->dev
一个socket 如何关联对应 sk_buff ？
socket fd
-> struct socket
-> struct sock
-> struct sock.sk_receive_queue //socket的接收缓存队列。
-> struct sk_buff
收到一个sk_buff，如何知道查找哪个 struct sock？
tcp为例：
int tcp_v4_rcv(struct sk_buff *skb)
{
const struct tcphdr *th;
th = tcp_hdr(skb);
sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
//通过源目端口和IP的hash值，找到struct sock。
}
网卡接收环形缓冲区：
网卡内的一块内存，存储收到的数据帧。
缓冲区大小及其数量由网卡硬件决定。
传统收包：
每收到一个数据包产生一个中断。
缺点：
数据包过多时，中断上下文切换频繁，性能降低。
因此引进 NAPI，即 New API。结合了IRQ + 轮询。
先介绍一个重要结构体：
struct softnet_data { //代表一个CPU收包队列。
struct list_head poll_list：
//NAPI 轮询的设备列表。
//list_add_tail(&napi->poll_list, &sd->poll_list);
struct sk_buff_head process_queue;
struct sk_buff_head input_pkt_queue; // 收包队列
struct napi_struct backlog;
// 为兼容NAPI模式，传统方法收包也用一个napi，用于处理积压队列中报文。
// sd->backlog.poll = process_backlog;
}
下面介绍传统和 NAPI 两种方法的接收分组。
传统网卡使用传统方式。
高吞吐、高性能网卡使用NAPI方式。
在Linux-3.10中，为兼容NAPI方式，将传统方式当做一种特殊NAPI。
即 struct napi_struct backlog。
所以先讲解 NAPI 方式。
1. NAPI
NAPI原理：
1. 收到第一个分组导致网卡发出中断，然后关闭中断。将设备放到轮询表中。
2. 只要设备接收缓存区有分组需处理，就一直对设备轮询。
3. 设备缓存中分组处理完毕后，开启RX中断。
网卡驱动中probe函数中执行netif_napi_add，就是使用 NAPI 模式。
void netif_napi_add(struct net_device *dev, struct napi_struct *napi, int (*poll) (*, ), int weight）
poll 函数：驱动自定义。用于 IRQ 禁用后被 NAPI 调度执行。以接收分组。
weight：一次轮询中处理多少分组。（不超过RX缓冲区容量）。
int (*poll) (struct napi_struct *, int budget)
budget：预算/权重，一次轮询最多允许处理的分组数。
网卡速率越高，weight可设更高。
struct napi_struct { //一个网卡的轮询结构体。
struct list_head poll_list;
unsigned long state;
int weight; //一次轮询可处理的包数量。
unsigned int gro_count;
int (*poll)(struct napi_struct *, int);
...
};
成员介绍：
struct list_head poll_list;
用于将 NAPI 实例链接到 CPU 的软中断列表中。
使用举例：
struct softnet_data *sd;
list_add_tail(&napi->poll_list, &sd->poll_list);
state：
跟踪 NAPI 实例的状态。值有：
1. NAPI_STATE_SCHED：
该 NAPI 实例已加入 softnet_data->poll_list 轮询队列中。
等待CPU调度执行该 NAPI 的poll函数。
2. NAPI_STATE_DISABLE：
禁用该 NAPI 实例。
该 NAPI 实例不会被加入softnet_data->poll_list轮询队列中。
实现 poll 函数
网卡驱动自定义底层收包。
intel e100网卡为例：
int e100_poll(struct napi_struct *napi, int budget)
{
struct nic *nic = container_of(napi, struct nic, napi);
unsigned int work_done = 0;
e100_rx_clean(nic, &work_done, budget);
if (work_done < budget) {
//没有接收足够数量的报文，表示接收完毕，可退出poll模式，并开启中断。
napi_complete(napi);
e100_enable_irq(nic);
}
return work_done;
}
实现 IRQ 处理程序
e100网卡为例：
request_irq(irq, e100_intr, IRQF_SHARED, netdev_name, nic->netdev);
irqreturn_t e100_intr(int irq, void *dev_id)
{
struct net_device *netdev = dev_id;
struct nic *nic = netdev_priv(netdev);
if (napi_schedule_prep( &nic->napi )) {
e100_disable_irq(nic);
__napi_schedule(&nic->napi);
}
return IRQ_HANDLED;
}
napi_schedule_prep：
设置NAPI state为NAPI_STATE_SCHED。（即将将设备放到轮询表中）
e100_disable_irq：
禁止中断，因为即将调用poll函数，轮询收包。
__napi_schedule：
进行NAPI调度。
void ____napi_schedule(struct softnet_data *sd, struct napi_struct *napi)
{
list_add_tail(&napi->poll_list, &sd->poll_list); // 加入本CPU的轮询表中。
__raise_softirq_irqoff( NET_RX_SOFTIRQ );
//触发软中断。
}
处理RX软中断
void net_rx_action(struct softirq_action *h)
{
struct softnet_data *sd = &__get_cpu_var(softnet_data);
unsigned long time_limit = jiffies + 2;
int budget = netdev_budget; // 对应 proc/net/sys/net/core/netdev_budget
struct softnet_data *sd = &__get_cpu_var(softnet_data);
while ( &sd->poll_list )) { // 遍历该CPU上所有napi
if (unlikely(budget <= 0 || time_after_eq(jiffies, time_limit)))
goto softnet_break; // 预算用尽，或执行执行太久。
n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
if (test_bit(NAPI_STATE_SCHED, &n->state)) {
work = n->poll(n, weight);
// 遍历执行，不同驱动定义的poll函数。
//包括传统方法的struct napi_struct backlog
}
if (work == weight) {
napi_complete( n ); // 接收到足够报文，将该napi从CPU中移除。
}
}
}
总结：
1. 第一个分组导致网卡发出IRQ，触发中断处理函数。
2. 中断处理函数中，将网卡的napi 放在CPU的轮询表上，最后触发NET_RX_SOFTIRQ软中断。
3. 软中断中执行各个napi的轮询函数。
/proc/sys/net/core/netdev_budget：
该CPU中所有 napi 预算总和，每个NAPI设备轮询后，从总数中减去。
budget为0后或超时，退出软中断处理函数。
2. 传统方法
request_irq(dev->irq, net_interrupt, irqflags, dev->name, dev);
net_interrupt ：
网卡驱动中自定义。
通常进一步调用 netif_rx。
net/core/dev.c
netif_rx：是传统方式的收包，而不是NAPI方式的收包。
int netif_rx( struct sk_buff *skb)
{
enqueue_to_backlog(skb, get_cpu(), &qtail);
}
int enqueue_to_backlog(struct sk_buff *skb, int cpu, unsigned int *qtail)
{
struct softnet_data *sd;
sd = &per_cpu(softnet_data, cpu);
if (skb_queue_len( &sd->input_pkt_queue) <= netdev_max_backlog) {
if (skb_queue_len(&sd->input_pkt_queue)) {
enqueue:
__skb_queue_tail(&sd->input_pkt_queue, skb);
//将收到的skb 放到 CPU 的等待队列 input_pkt_queue中。
return NET_RX_SUCCESS;
}
if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
____napi_schedule(sd, &sd->backlog);
}
goto enqueue;
}
return NET_RX_DROP;
}
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); // 触发NET_RX_SOFTIRQ 软中断。
}
3. 执行软中断处理函数 net_rx_action
NAPI也在软中断中调用 net_rx_action。
net_rx_action 执行所有napi中poll函数，接收报文。
包括：
1. 传统方式：sd->backlog.poll = process_backlog;
2. NAPI方式：网卡驱动自定义 poll 函数。
process_backlog：
拓展
GRO技术：
原理：
将多个数据合并成一个大包，减少中断次数和内存拷贝，提高性能。
使用场景：
高吞吐量场景，如大文件、高并发。
高速网络环境，如10GbE网络。
长连接场景，如TCP长连接，GRO合并多个TCP包。
大量小数据包场景。
不适合场景：
HTTP短连接、直播、在线游戏等（GRO会增加延迟）。
数据包长度频繁变化，如VoIP流（容易合并错误）
加密或压缩包。
12.7.3 发送分组
发包的注意事项：
1. 特定协议的首部校验和。
2. 确定路由。
3. 确定目的MAC。
net/core/dev.c 中 dev_queue_xmit：
作用：把分组放置到发送队列中。
然后调用 网卡驱动自定义 net_device -> hard_start_xmit 函数指针：
作用：完成发送动作。