devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

linux 内核协议栈 NAPI机制与处理流程分析（图解）_linux napi

作者：Cpp五条 | 2024-03-17 00:20:33

赞

踩

linux napi

目录

1 NAPI 机制

1.1 NAPI 缺陷

1.2 使用 NAPI 先决条件

1.3 非NAPI帧的接收

1.3.1 netif_rx - 将网卡中收到的数据包放到系统中的接收队列中

1.3.2 enqueue_to_backlog

1.3.3 ____napi_schedule

1.4 NAPI方式

1.4.1 NAPI帧的接收

1.5 NAPI接口

1.5.1 struct napi_struct结构(内核处理软中断的入口)

1.5.2 netif_napi_add (驱动初始时向内核注册软软中断处理回调poll函数)

1.5.3 __napi_schedule函数(网卡硬件中断用来触发软中断)

1.5.4 napi_schedule_prep(对napi_struct进行检查)

1.5.5 napi_poll(用于调用收包poll函数)

1.5.6 napi_gro_receive(poll函数用来将网卡上的数据包发给协议栈处理)

2 E1000网卡驱动程序对NAPI的支持

2.1 e1000_probe(E1000网卡的初始化函数)

2.2 e1000_open(E1000网卡驱动程序的open方法)

2.3 e1000_setup_rx_resources(为其环形缓冲区分配资源)

2.4 request_irq(向系统申请irq中断号，中断处理函数 e1000_intr)

2.5 net_rx_action函数(软中断处理函数)

2.5.1 激活软中断(ixgbe 网卡调用栈)

2.5.2 执行软中断(ixgbe 网卡调用栈)

2.6 poll 函数

2.6.1 process_backlog(非NAPI)

2.6.2 e1000_clean(e1000网卡 NAPI) 

2.6.3 e1000_clean_rx_irq(处理e1000网卡中断收到的数据包，核心)

随着网络带宽的发展，网速越来越快，之前的中断收包模式已经无法适应目前千兆，万兆的带宽了。如果每个数据包大小等于MTU大小1460字节。当驱动以千兆网速收包时，CPU将每秒被中断91829次。在以MTU收包的情况下都会出现每秒被中断10万次的情况。过多的中断会引起一个问题，CPU一直陷入硬中断而没有时间来处理别的事情了。为了解决这个问题，内核在2.6中引入了NAPI机制。

NAPI就是混合中断和轮询的方式来收包，当有中断来了，驱动关闭中断，通知内核收包，内核软中断轮询当前网卡，在规定时间尽可能多的收包。时间用尽或者没有数据可收，内核再次开启中断，准备下一次收包。

本文将介绍Linux内核中的NAPI：Linux网络设备驱动程序中的一种支持新一代网络适配器的架构。

1 NAPI 机制

New API（NAPI）用于支持高速网卡处理网络数据包的一种机制 - 例如在Linux 2.6内核版本中引入的千兆以太网卡，后来又被移植到了2.4.x版本中。

NAPI 是 Linux 上采用的一种提高网络处理效率的技术，它的核心概念就是不采用中断的方式读取数据，而代之以首先采用中断唤醒数据接收的服务程序，然后 POLL 的方法来轮询数据。随着网络的接收速度的增加，NIC 触发的中断能做到不断减少，目前 NAPI 技术已经在网卡驱动层和网络层得到了广泛的应用，驱动层次上已经有 E1000 系列网卡，RTL8139 系列网卡，3c50X 系列等主流的网络适配器都采用了这个技术，而在网络层次上，NAPI 技术已经完全被应用到了著名的netif_rx 函数中间，并且提供了专门的 POLL 方法--process_backlog 来处理轮询的方法；根据实验数据表明采用NAPI技术可以大大改善短长度数据包接收的效率，减少中断触发的时间。

NAPI 对数据包到达的事件的处理采用轮询方法，在数据包达到的时候，NAPI 就会强制执行dev->poll方法。而和不像以前的驱动那样为了减少包到达时间的处理延迟，通常采用中断的方法来进行。

以前的网络设备驱动程序架构已经不能适用于每秒产生数千个中断的高速网络设备，并且它可能导致整个系统处于饥饿状态（译者注：饥饿状态的意思是系统忙于处理中断程序，没有时间执行其他程序）。有些网络设备具有中断合并，或者将多个数据包组合在一起来减少中断请求这种高级功能。

在内核没有使用NAPI来支持这些高级特性之前，这些功能只能全部在设备驱动程序中结合抢占机制（例如基于定时器中断），甚至中断程序范围之外的轮询程序（例如：内核线程，tasklet等）中实现。

正如我们看到的，网络子系统中加入的这个新特性是用于更好的支持中断缓解和数据包限制等功能，更重要的是它允许内核通过 round-robin 策略（轮询即Round Robin，一种负载均衡策略）将负载分发到不同网络设备上。

NAPI特性的添加不会影响内核的向后兼容性。

1.1 NAPI 缺陷

NAPI 存在一些比较严重的缺陷：

  1. 对于上层的应用程序而言，系统不能在每个数据包接收到的时候都可以及时地去处理它，而且随着传输速度增加，累计的数据包将会耗费大量的内存，经过实验表明在 Linux 平台上这个问题会比在 FreeBSD 上要严重一些；
  2. 另外一个问题是对于大的数据包处理比较困难，原因是大的数据包传送到网络层上的时候耗费的时间比短数据包长很多（即使是采用 DMA 方式），所以正如前面所说的那样，NAPI 技术适用于对高速率的短长度数据包的处理。

1.2 使用 NAPI 先决条件

驱动可以继续使用老的 2.4 内核的网络驱动程序接口，NAPI 的加入并不会导致向前兼容性的丧失，但是 NAPI 的使用至少要得到下面的保证：

  1. 设备需要有足够的缓冲区，保存多个数据分组。要使用 DMA 的环形输入队列（也就是 ring_dma，这个在 2.4 驱动中关于 Ethernet 的部分有详细的介绍），或者是有足够的内存空间缓存驱动获得的包。
  2. 可以禁用当前设备中断，然而不影响其他的操作。在发送/接收数据包产生中断的时候有能力关断 NIC 中断的事件处理，并且在关断 NIC 以后，并不影响数据包接收到网络设备的环形缓冲区（以下简称 rx-ring）处理队列中。

当前大部分的设备都支持NAPI，但是为了对之前的保持兼容，内核还是对之前中断方式提供了兼容。我们先看下NAPI具体的处理方式。

我们都知道中断分为中断上半部和下半部，上半部完成的任务很是简单，仅仅负责把数据保存下来；而下半部负责具体的处理。为了处理下半部，每个CPU有维护一个softnet_data结构（定义在netdevice.h文件中，下文将进行讲解）。我们不对此结构做详细介绍，仅仅描述和NAPI相关的部分。结构中有一个poll_list字段，连接所有的轮询设备。还 维护了两个队列input_pkt_queue和process_queue。这两个用户传统不支持NAPI方式的处理。前者由中断上半部的处理函数把数据包入队，在具体的处理时，使用后者做中转，相当于前者负责接收，后者负责处理。最后是一个napi_struct的backlog，代表一个虚拟设备供轮询使用。在支持NAPI的设备下，每个设备具备一个缓冲队列，存放到来数据。每个设备对应一个napi_struct结构，该结构代表该设备存放在poll_list中被轮询。而设备还需要提供一个poll函数，在设备被轮询到后，会调用poll函数对数据进行处理。基本逻辑就是这样，下文将给出具体流程。

  1. /*
  2.  * Incoming packets are placed on per-CPU queues
  3.  */
  4. struct softnet_data {
  5. 	struct list_head	poll_list;
  6. 	struct sk_buff_head	process_queue;
  7.  
  8. 	/* stats */
  9. 	unsigned int		processed;
  10. 	unsigned int		time_squeeze;
  11. 	unsigned int		received_rps;
  12. #ifdef CONFIG_RPS
  13. 	struct softnet_data	*rps_ipi_list;
  14. #endif
  15. #ifdef CONFIG_NET_FLOW_LIMIT
  16. 	struct sd_flow_limit __rcu *flow_limit;
  17. #endif
  18. 	struct Qdisc		*output_queue;
  19. 	struct Qdisc		**output_queue_tailp;
  20. 	struct sk_buff		*completion_queue;
  21. #ifdef CONFIG_XFRM_OFFLOAD
  22. 	struct sk_buff_head	xfrm_backlog;
  23. #endif
  24. 	/* written and read only by owning cpu: */
  25. 	struct {
  26. 		u16 recursion;
  27. 		u8  more;
  28. 	} xmit;
  29. #ifdef CONFIG_RPS
  30. 	/* input_queue_head should be written by cpu owning this struct,
  31. 	 * and only read by other cpus. Worth using a cache line.
  32. 	 */
  33. 	unsigned int		input_queue_head ____cacheline_aligned_in_smp;
  34.  
  35. 	/* Elements below can be accessed between CPUs for RPS/RFS */
  36. 	call_single_data_t	csd ____cacheline_aligned_in_smp;
  37. 	struct softnet_data	*rps_ipi_next;
  38. 	unsigned int		cpu;
  39. 	unsigned int		input_queue_tail;
  40. #endif
  41. 	unsigned int		dropped;
  42. 	struct sk_buff_head	input_pkt_queue;
  43. 	struct napi_struct	backlog;
  44.  
  45. };

1.3 非NAPI帧的接收

我们将讨论内核在接收一个数据帧后的大致处理流程，不会详细叙述所有细节。我们认为有必要先了解一下传统的数据包处理流程以便更好的理解NAPI和传统收包方式的区别。

在传统的收包方式中（如下图）数据帧向网络协议栈中传递发生在中断上下文（在接收数据帧时）中调用 netif_rx 的函数中。 这个函数还有一个变体 netif_rx_ni，他被用于中断上下文之外。

netif_rx 函数将网卡中收到的数据包（包装在一个socket buffer中）放到系统中的接收队列中（input_pkt_queue），前提是这个接收队列的长度没有大于netdev_max_backlog。这个参数和另外一些参数可以在/proc文件系统中看到（/proc/sys/net/core文件中，可以手动调整这个数值）。

1.3.1 netif_rx - 将网卡中收到的数据包放到系统中的接收队列中

  1. int netif_rx(struct sk_buff *skb)
  2. {
  3. 	int ret;
  4. ...
  5. 	ret = netif_rx_internal(skb);
  6. ...
  7. 	return ret;
  8. }
  9. static int netif_rx_internal(struct sk_buff *skb)
  10. {
  11. 	int ret;
  12.  
  13. 	net_timestamp_check(netdev_tstamp_prequeue, skb);
  14. 	trace_netif_rx(skb);
  15.  
  16. #ifdef CONFIG_RPS
  17. ...
  18. #endif
  19. 	{
  20. 		unsigned int qtail;
  21.  
  22. 		ret = enqueue_to_backlog(skb, get_cpu_light(), &qtail);
  23. 		put_cpu_light();
  24. 	}
  25. 	return ret;
  26. }

1.3.2 enqueue_to_backlog

                    

 中间 RPS 暂时不关心，这里直接调用 enqueue_to_backlog 放入 CPU 的全局队列 input_pkt_queue

  1. static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
  2. 			      unsigned int *qtail)
  3. {
  4. 	struct softnet_data *sd;
  5. 	unsigned long flags;
  6. 	unsigned int qlen;
  7.    /*获取cpu相关的softnet_data变量*/
  8. 	sd = &per_cpu(softnet_data, cpu);
  9.    /*关中断*/
  10. 	local_irq_save(flags);
  11.  
  12. 	rps_lock(sd);
  13. 	if (!netif_running(skb->dev))
  14. 		goto drop;
  15. 	qlen = skb_queue_len(&sd->input_pkt_queue);
  16. 	/*如果input_pkt_queue的长度小于最大限制，则符合条件*/
  17. 	if (qlen <= netdev_max_backlog && !skb_flow_limit(skb, qlen)) {
  18. 		/*如果input_pkt_queue不为空，说明虚拟设备已经得到调度，此时仅仅把数据加入
  19.           input_pkt_queue队列即可 */
  20. 		if (qlen) {
  21. enqueue:
  22. 			__skb_queue_tail(&sd->input_pkt_queue, skb);
  23. 			input_queue_tail_incr_save(sd, qtail);
  24. 			rps_unlock(sd);
  25. 			local_irq_restore(flags);
  26. 			return NET_RX_SUCCESS;
  27. 		}
  28.  
  29. 		/* Schedule NAPI for backlog device
  30. 		 * We can use non atomic operation since we own the queue lock
  31. 		 */
  32. 		/*队列为空时，即skb是第一个入队元素，则将state设置为 NAPI_STATE_SCHED(软中断处理函数
  33.           rx_net_action会检查此标志)，表示软中断可以处理此 backlog */
  34. 		if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
  35. 		/* if返回0的情况下，需要将sd->backlog挂到sd->poll_list上，并激活软中断。
  36. 			rps_ipi_queued看下面的分析 */
  37. 			if (!rps_ipi_queued(sd))
  38. 				____napi_schedule(sd, &sd->backlog);
  39. 		}
  40. 		goto enqueue;
  41. 	}
  42.  
  43. drop:
  44. 	sd->dropped++;
  45. 	rps_unlock(sd);
  46.  
  47. 	local_irq_restore(flags);
  48. 	preempt_check_resched_rt();
  49.  
  50. 	atomic_long_inc(&skb->dev->rx_dropped);
  51. 	kfree_skb(skb);
  52. 	return NET_RX_DROP;
  53. }
  54.  
  55. /*
  56.  * Check if this softnet_data structure is another cpu one
  57.  * If yes, queue it to our IPI list and return 1
  58.  * If no, return 0
  59.  */ 
  60. /*上面注释说的很清楚，在配置RPS情况下，检查sd是当前cpu的还是其他cpu的，
  61. 如果是其他cpu的，将sd放在当前cpu的mysd->rps_ipi_list上，并激活当前cpu的软中断，返回1. 
  62. 在软中断处理函数net_rx_action中，通过ipi中断通知其他cpu来处理放在其他
  63. cpu队列上的skb如果是当前cpu，或者没有配置RPS，则返回0，
  64. 在外层函数激活软中断，并将当前cpu的backlog放入sd->poll_list上*/
  65. static int rps_ipi_queued(struct softnet_data *sd)
  66. {
  67. #ifdef CONFIG_RPS
  68.     struct softnet_data *mysd = this_cpu_ptr(&softnet_data);
  69.  
  70.     if (sd != mysd) {
  71.         sd->rps_ipi_next = mysd->rps_ipi_list;
  72.         mysd->rps_ipi_list = sd;
  73.  
  74.         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  75.         return 1;
  76.     }
  77. #endif /* CONFIG_RPS */
  78.     return 0;
  79. }

1.3.3 ____napi_schedule

该函数逻辑也比较简单，主要注意的是设备必须先添加调度然后才能接收数据，添加调度调用了____napi_schedule 函数，该函数把设备对应的 napi_struct 结构插入到 softnet_data 的 poll_list 链表尾部，然后唤醒软中断，这样在下次软中断得到处理时，中断下半部就会得到处理。

  1. /* Called with irq disabled */
  2. static inline void ____napi_schedule(struct softnet_data *sd,
  3. 				     struct napi_struct *napi)
  4. {
  5. 	list_add_tail(&napi->poll_list, &sd->poll_list);
  6. 	__raise_softirq_irqoff(NET_RX_SOFTIRQ);
  7. }

input_pkt_queue 是 softnet_data 结构体中的一个成员，定义在 netdevice.h 文件中。

如果接收到的数据包没有因为 input_pkt_queue 队列已满而被丢弃，它会被netif_rx_schedule函数调度给软中断NET_RX_SOFTIRQ处理，netif_rx_schedule 函数在 netif_rx 函数内部被调用。

软中断NET_RX_SOFTIRQ的处理逻辑在net_rx_action函数中实现。

此时，我们可以说此函数将数据包从input_pkt_queue队列中传递给了网络协议栈，现在数据包可以被处理了。

1.4 NAPI方式

NAPI的方式相对于非NAPI要简单许多，看下e100网卡的中断处理函数 e100_intr，核心部分

  1. static irqreturn_t e100_intr(int irq, void *dev_id)
  2. {
  3. 	struct net_device *netdev = dev_id;
  4. 	struct nic *nic = netdev_priv(netdev);
  5.     ...
  6. 	if (likely(napi_schedule_prep(&nic->napi))) {
  7. 		e100_disable_irq(nic);//屏蔽当前中断
  8. 		__napi_schedule(&nic->napi);//把设备加入到轮训队列
  9. 	}
  10.  
  11. 	return IRQ_HANDLED;
  12. }

if 条件检查当前设备是否 可被调度，主要检查两个方面：

  • 是否已经在调度
  • 是否禁止了napi pending

如果符合条件，就关闭当前设备的中断，调用__napi_schedule函数把设备假如到轮训列表，从而开启轮询模式。

分析：结合上面两种方式，还是可以发现两种方式的异同。其中 softnet_data 作为主导结构，在NAPI的处理方式下，主要维护轮询链表。NAPI设备均对应一个napi_struct结构，添加到链表中；非 NAPI 没有对应的 napi_struct 结构，为了使用 NAPI 的处理流程，使用了 softnet_data 结构中的back_log 作为一个虚拟设备添加到轮询链表。同时由于非NAPI设备没有各自的接收队列，所以利用了softnet_data结构的input_pkt_queue作为全局的接收队列。这样就处理而言，可以和NAPI的设备进行兼容。但是还有一个重要区别，在NAPI的方式下，首次数据包的接收使用中断的方式，而后续的数据包就会使用轮询处理了；而非NAPI每次都是通过中断通知。

1.4.1 NAPI帧的接收

在NAPI架构中（如下图），当接收到数据包产生中断时，驱动程序会通知网络子系统有新的数据包到来（而不是立即处理数据包），这样就可以在ISR（Interrupt Service Routines - 中断服务程序）上下文之外使用轮询的方式来一次性接收多个数据包（VPP了解一下）。

                                图 - NAPI frame reception

因此网卡支持NAPI必须满足几个条件：

  • 驱动程序不再使用数据包接收队列
  • 网卡本身需要维护一个缓冲区来保存接收到数据包，并且可以禁止中断。

这种方法减少了中断的产生并且在突发情况下减少了丢包的可能性，避免了接收队列的饱和。

从NAPI实现的角度来看，与传统收包方式的不同地方在中断程序和轮询函数上（在net_device结构体中定义），定义如下：

int (*poll)(struct net_device *dev, int *budget);

除此之外，net_device结构体中还有另外两个属性quota（配额）和 weight（权重），他们用于在一个轮询周期中实现抢占机制（译者注：意思是通过这两个参数来控制一个轮询周期的运行时间，恩，是的）我们将在后面详细讨论。

NAPI模型中的中断函数将数据帧传送到协议栈的任务交给poll函数执行。 换句话说中断函数的工作被简化为禁用网络设备中断（再此期间设备可以继续接收数据帧），和确认中断然后调度（通过netif_rx_schedule函数调度）软中断NET_RX_SOFTIRQ关联的 net_rx_action 函数。

等待被轮询的设备通过 netif_rx_schedule 函数将 net_device 结构体实例的指针加入到 poll_list链表中。 在调用 net_rx_action 函数执行软中断 NET_RX_SOFTIRQ 时会遍历 poll_list 链表，然后调用每个设备的poll()函数将数据帧存放在socket buffers中并通知上层协议栈。

net_rx_action 函数的执行步骤如下：

1. 回收当前处理器的poll_list链表的引用。

2. 将jiffies的值保存在start_time变量中。

3. 设置轮询的budget（预算，可处理的数据包数量）为netdev_budget变量的初始值（这个值可以通过 /proc/sys/net/core/netdev_budget 来配置）

3. 轮询poll_list链表中的每个设备，直到你的budget用完，当你的运行时间还没有超过一个jiffies时:

  • 如果quantum（配额）为正值则调用设备的poll()函数，否则将weight的值加到quantum中，将设备放回poll_list链表；
  • 如果poll() 函数返回一个非零值，将weight的值设置到quantum中然后将设备放回poll_list链表；
  • 如果poll() 函数返回零值，说明设备已经被移除poll_list链表（不再处于轮询状态）。

budget 的值和 net_device 结构体的指针会传递到 poll() 函数中。poll() 函数应该根据数据帧的处理数量来减小 budget 的值。数据帧从网络设备的缓冲区中复制出来包装在 socket buffers 中，然后通过 netif_receive_skb 函数传递到协议栈中去。

抢占策略是依赖budget变量的配额机制实现的：poll()函数必须根据分配给设备的最大配额来决定可以传递多少个数据包给内核。 当配额使用完就不允许在传递数据包给内核了，应该轮询poll_list链表中的下一个设备了。因此poll()必须和减小budget的值一样根据数据帧的处理数量来减小quota的值。

如果驱动在用完了所有的quota之后还没有传递完队列中所有的数据包，poll()函数必须停止运行并返回一个非NULL值。如果所有数据包都传递到了协议栈，驱动程序必须再次使能设备的中断并停止轮询，然后调用netif_rx_complete函数（它会将设备从poll_list链表去除），最后停止运行并返回零值给调用者（net_rx_action函数）。

net_device结构体中的另一个重要成员weight，它用于每次调用poll()函数时重置quota的值。 很明显weight的值必须被初始化为一个固定的正值。通常对于高速网卡这个值一般在16和32之间，对于千兆网卡来说这个值会大一点（通常时64）。
从net_rx_action函数的实现中我们可以看到当weight的值设置太大时，驱动使用的budget会超过quantum，此时会导致一个轮询周期的时间变长。

下面 我们给出了设备驱动程序接收中断并执行轮询函数的伪代码：

  1. static irqreturn_t sample_netdev_intr(int irq, void *dev)
  2. {
  3.     struct net_device *netdev = dev;
  4.     struct nic *nic = netdev_priv(netdev);
  5.  
  6.     if (! nic->irq_pending())
  7.         return IRQ_NONE;
  8.  
  9.     /* Ack interrupt(s) */
  10.     nic->ack_irq();
  11.  
  12.     nic->disable_irq();  
  13.  
  14.     netif_rx_schedule(netdev);
  15.  
  16.     return IRQ_HANDLED;
  17. }
  18.  
  19.  
  20. static int sample_netdev_poll(struct net_device *netdev, int *budget)
  21. {
  22.     struct nic *nic = netdev_priv(netdev);
  23.  
  24.     unsigned int work_to_do = min(netdev->quota, *budget);
  25.     unsigned int work_done = 0;
  26.  
  27.     nic->announce(&work_done, work_to_do);
  28.  
  29.     /* If no Rx announce was done, exit polling state. */
  30.  
  31.     if(work_done == 0) || !netif_running(netdev)) {
  32.  
  33.     netif_rx_complete(netdev);
  34.     nic->enable_irq();  
  35.  
  36.     return 0;
  37.     }
  38.  
  39.     *budget -= work_done;
  40.     netdev->quota -= work_done;
  41.  
  42.     return 1;
  43. }


下图分别展示了非NAPI和NAPI模型中数据包接收处理过程的时序图：

                  

                                         图 - 非NAPI模型的时序图

                           

                                     图 - NAPI模型的时序图

1.5 NAPI接口

1.5.1 struct napi_struct结构(内核处理软中断的入口)

struct napi_struct 是内核处理软中断的入口，每个 net_device 都对应一个 napi_struct，驱动在硬中断中将自己的 napi_struct 挂载到 CPU 的收包队列 softnet_data。内核在软中断中轮询该队列，并执行 napi_sturct 中的回调函数 int(*poll)(struct napi_struct *, int);

在 poll 函数中，驱动将网卡数据转换成 skb_buff 形式，最终发往协议栈。也就是说，协议栈对数据包的处理，使用的是软中断的时间片。如果协议栈处理耗费了过多的 CPU 时间的化，会直接影响到设备的网络性能。

  1. /*
  2.  * Structure for NAPI scheduling similar to tasklet but with weighting
  3.  */
  4. struct napi_struct {
  5. 	/* The poll_list must only be managed by the entity which
  6. 	 * changes the state of the NAPI_STATE_SCHED bit.  This means
  7. 	 * whoever atomically sets that bit can add this napi_struct
  8. 	 * to the per-CPU poll_list, and whoever clears that bit
  9. 	 * can remove from the list right before clearing the bit.
  10. 	 */
  11. 	struct list_head	poll_list;
  12.  
  13. 	unsigned long		state;//设备状态
  14. 	int			weight;//每次轮询最大处理数据包数量
  15. 	int			defer_hard_irqs_count;
  16. 	unsigned long		gro_bitmask;
  17. 	int			(*poll)(struct napi_struct *, int);//轮询设备的回调函数
  18. #ifdef CONFIG_NETPOLL
  19. 	int			poll_owner;
  20. #endif
  21. 	struct net_device	*dev;
  22. 	struct gro_list		gro_hash[GRO_HASH_BUCKETS];
  23. 	struct sk_buff		*skb;
  24. 	struct list_head	rx_list; /* Pending GRO_NORMAL skbs */
  25. 	int			rx_count; /* length of rx_list */
  26. 	struct hrtimer		timer;
  27. 	struct list_head	dev_list;
  28. 	struct hlist_node	napi_hash_node;
  29. 	unsigned int		napi_id;
  30. };

有了保存数据的结构体，让我们在看看为它配套提供的接口函数吧。

1.5.2 netif_napi_add (驱动初始时向内核注册软软中断处理回调poll函数)

驱动在初始化 net_device 时通过这函数将通过这个函数绑定一个 napi_struct 结构。驱动需要在这里注册软中断中用于轮询的网卡的 poll 函数。

  1. void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
  2. 		    int (*poll)(struct napi_struct *, int), int weight)
  3. {
  4. 	if (WARN_ON(test_and_set_bit(NAPI_STATE_LISTED, &napi->state)))
  5. 		return;
  6.  
  7. 	INIT_LIST_HEAD(&napi->poll_list);
  8. 	INIT_HLIST_NODE(&napi->napi_hash_node);
  9.     ...
  10. 	napi->poll = poll;
  11. 	if (weight > NAPI_POLL_WEIGHT)
  12. 		netdev_err_once(dev, "%s() called with weight %d\n", __func__,
  13. 				weight);
  14. 	napi->weight = weight;
  15. 	napi->dev = dev;
  16. #ifdef CONFIG_NETPOLL
  17. 	napi->poll_owner = -1;
  18. #endif
  19. 	set_bit(NAPI_STATE_SCHED, &napi->state);
  20. 	set_bit(NAPI_STATE_NPSVC, &napi->state);
  21. 	list_add_rcu(&napi->dev_list, &dev->napi_list);
  22. 	napi_hash_add(napi);
  23. }
  24. EXPORT_SYMBOL(netif_napi_add);

1.5.3 __napi_schedule函数(网卡硬件中断用来触发软中断)

__napi_schedule函数，为驱动硬件中断提供的接口，驱动在硬件中断中，将自己的napi_struct挂载到当前CPU的softnet_data上。

  1. /**
  2.  * __napi_schedule - schedule for receive
  3.  * @n: entry to schedule
  4.  *
  5.  * The entry's receive function will be scheduled to run.
  6.  * Consider using __napi_schedule_irqoff() if hard irqs are masked.
  7.  */
  8. void __napi_schedule(struct napi_struct *n)
  9. {
  10.     unsigned long flags;
  11.  
  12.     local_irq_save(flags);
  13.     ____napi_schedule(this_cpu_ptr(&softnet_data), n);
  14.     local_irq_restore(flags);
  15. }
  16.  
  17. /* Called with irq disabled */
  18. static inline void ____napi_schedule(struct softnet_data *sd,
  19.                      struct napi_struct *napi)
  20. {
  21.     list_add_tail(&napi->poll_list, &sd->poll_list);
  22.     __raise_softirq_irqoff(NET_RX_SOFTIRQ); //设置了软中断接收标志位
  23. }

1.5.4 napi_schedule_prep(对napi_struct进行检查)

napi_schedule_prep 函数是上面 __napi_schedule 的配套函数，用于 __napi_schedule 调用前对napi_struct 进行检查。前面博文e1000网卡的中断函数就是这样调用的。

  1. /**
  2.  * e1000_intr - Interrupt Handler
  3.  * @irq: interrupt number
  4.  * @data: pointer to a network interface device structure
  5.  **/
  6. static irqreturn_t e1000_intr(int irq, void *data)
  7. {
  8. 	struct net_device *netdev = data;
  9. 	struct e1000_adapter *adapter = netdev_priv(netdev);
  10. 	struct e1000_hw *hw = &adapter->hw;
  11. 	u32 icr = er32(ICR);
  12.     ...
  13. 	if (likely(napi_schedule_prep(&adapter->napi))) {
  14. 		adapter->total_tx_bytes = 0;
  15. 		adapter->total_tx_packets = 0;
  16. 		adapter->total_rx_bytes = 0;
  17. 		adapter->total_rx_packets = 0;
  18. 		__napi_schedule(&adapter->napi);
  19. 	} else {
  20. 		/* this really should not happen! if it does it is basically a
  21. 		 * bug, but not a hard error, so enable ints and continue
  22. 		 */
  23. 		if (!test_bit(__E1000_DOWN, &adapter->flags))
  24. 			e1000_irq_enable(adapter);
  25. 	}
  26.  
  27. 	return IRQ_HANDLED;
  28. }

判断NAPI是否可以调度。如果NAPI没有被禁止，且不存在已被调度的NAPI，则允许调度NAPI，因为同一时刻只允许有一个NAPI poll instance。测试napi.state字段，只有当其不是NAPI_STATE_SCHED时，返回真，并设置为NAPI_STATE_SCHED.

  1. /**
  2.  *	napi_schedule_prep - check if napi can be scheduled
  3.  *	@n: napi context
  4.  *
  5.  * Test if NAPI routine is already running, and if not mark
  6.  * it as running.  This is used as a condition variable to
  7.  * insure only one NAPI poll instance runs.  We also make
  8.  * sure there is no pending NAPI disable.
  9.  */
  10. bool napi_schedule_prep(struct napi_struct *n)
  11. {
  12. 	unsigned long val, new;
  13.  
  14. 	do {
  15. 		val = READ_ONCE(n->state);
  16. 		if (unlikely(val & NAPIF_STATE_DISABLE))
  17. 			return false;
  18. 		new = val | NAPIF_STATE_SCHED;
  19.  
  20. 		/* Sets STATE_MISSED bit if STATE_SCHED was already set
  21. 		 * This was suggested by Alexander Duyck, as compiler
  22. 		 * emits better code than :
  23. 		 * if (val & NAPIF_STATE_SCHED)
  24. 		 *     new |= NAPIF_STATE_MISSED;
  25. 		 */
  26. 		new |= (val & NAPIF_STATE_SCHED) / NAPIF_STATE_SCHED *
  27. 						   NAPIF_STATE_MISSED;
  28. 	} while (cmpxchg(&n->state, val, new) != val);
  29.  
  30. 	return !(val & NAPIF_STATE_SCHED);
  31. }
  32. EXPORT_SYMBOL(napi_schedule_prep);

上面的三个函数 netif_napi_add, __napi_schedule, napi_schedule_prep 是驱动使用NAPI收包机制的接口，下面再看看内核软中断使用NAPI的接口函数吧。

1.5.5 napi_poll(用于调用收包poll函数)

这函数是被软中断处理函数 net_rx_action 调用的。这个函数将在 napi_struct.weight 规定的时间内，被 net_rx_action 循环调用，直到时间片用尽或者网卡当前DMA中所有缓存的数据包被处理完。如果是由于时间片用尽而退出的的话，napi_struct 会重新挂载到 softnet_data 上，而如果是所有数据包处理完退出的，napi_struct 会从 softnet_data 上移除并重新打开网卡硬件中断。

  1. static int napi_poll(struct napi_struct *n, struct list_head *repoll)
  2. {
  3. 	void *have;
  4. 	int work, weight;
  5.  
  6. 	list_del_init(&n->poll_list);
  7.  
  8. 	have = netpoll_poll_lock(n);
  9.  
  10. 	weight = n->weight;
  11.  
  12. 	/* This NAPI_STATE_SCHED test is for avoiding a race
  13. 	 * with netpoll's poll_napi().  Only the entity which
  14. 	 * obtains the lock and sees NAPI_STATE_SCHED set will
  15. 	 * actually make the ->poll() call.  Therefore we avoid
  16. 	 * accidentally calling ->poll() when NAPI is not scheduled.
  17. 	 */
  18. 	work = 0;
  19. 	if (test_bit(NAPI_STATE_SCHED, &n->state)) {
  20. 		work = n->poll(n, weight);
  21. 		trace_napi_poll(n, work, weight);
  22. 	}
  23.  
  24. 	if (unlikely(work > weight))
  25. 		pr_err_once("NAPI poll function %pS returned %d, exceeding its budget of %d.\n",
  26. 			    n->poll, work, weight);
  27.  
  28. 	if (likely(work < weight))
  29. 		goto out_unlock;
  30.  
  31. 	/* Drivers must not modify the NAPI state if they
  32. 	 * consume the entire weight.  In such cases this code
  33. 	 * still "owns" the NAPI instance and therefore can
  34. 	 * move the instance around on the list at-will.
  35. 	 */
  36. 	if (unlikely(napi_disable_pending(n))) {
  37. 		napi_complete(n);
  38. 		goto out_unlock;
  39. 	}
  40.  
  41. 	if (n->gro_bitmask) {
  42. 		/* flush too old packets
  43. 		 * If HZ < 1000, flush all packets.
  44. 		 */
  45. 		napi_gro_flush(n, HZ >= 1000);
  46. 	}
  47.  
  48. 	gro_normal_list(n);
  49.  
  50. 	/* Some drivers may have called napi_schedule
  51. 	 * prior to exhausting their budget.
  52. 	 */
  53. 	if (unlikely(!list_empty(&n->poll_list))) {
  54. 		pr_warn_once("%s: Budget exhausted after napi rescheduled\n",
  55. 			     n->dev ? n->dev->name : "backlog");
  56. 		goto out_unlock;
  57. 	}
  58.  
  59. 	list_add_tail(&n->poll_list, repoll);
  60.  
  61. out_unlock:
  62. 	netpoll_poll_unlock(have);
  63.  
  64. 	return work;
  65. }

1.5.6 napi_gro_receive(poll函数用来将网卡上的数据包发给协议栈处理)

准确来说 napi_gro_receive 函数是驱动通过 poll 注册，内核调用的函数。通过这函数的的调用，skb 将会传给协议栈的入口函数 __netif_receive_skb 。dev_gro_receive 函数用于对数据包的合并，他将合并 napi_struct.gro_list 链表上的skb。GRO是一个网络子系统的另一套机制，以后再看。

  1. gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
  2. {
  3. 	gro_result_t ret;
  4.  
  5. 	skb_mark_napi_id(skb, napi);
  6. 	trace_napi_gro_receive_entry(skb);
  7.  
  8. 	skb_gro_reset_offset(skb, 0);
  9.  
  10. 	ret = napi_skb_finish(napi, skb, dev_gro_receive(napi, skb));
  11. 	trace_napi_gro_receive_exit(ret);
  12.  
  13. 	return ret;
  14. }
  15. EXPORT_SYMBOL(napi_gro_receive);

小结

  • netif_napi_add：驱动初始时向内核注册软软中断处理回调poll函数。
  • napi_schedule_prep 函数是上面__napi_schedule的配套函数，用于__napi_schedule调用前对napi_struct进行检查。
  • __napi_schedule：网卡硬件中断用来触发软中断。
  • napi_poll：软中断处理函数net_rx_action用来回调上面驱动初始化是通过netif_napi_add注册的回调收包poll函数。
  • napi_gro_receive：poll函数用来将网卡上的数据包发给协议栈处理。

到这，NAPI机制下的收包处理流程就很清晰了。

IRQ->__napi_schedule->进入软中断->net_rx_action->napi_poll->驱动注册的poll->napi_gro_receive。

  1. IRQ
  2.     ->__napi_schedule
  3.         ->进入软中断
  4.             ->net_rx_action
  5.                 ->napi_poll
  6.                     ->驱动注册的poll
  7.                         ->napi_gro_receive。

2 E1000网卡驱动程序对NAPI的支持

上面已经介绍过了，使用NAPI需要在编译内核的时候选择打开相应网卡设备的NAPI支持选项，对于E1000网卡来说就是CONFIG_E1000_NAPI宏。

2.1 e1000_probe(E1000网卡的初始化函数)

E1000网卡的初始化函数，也就是通常所说的probe方法，定义为e1000_probe()：

  1. /**
  2.  * e1000_probe - Device Initialization Routine
  3.  * @pdev: PCI device information struct
  4.  * @ent: entry in e1000_pci_tbl
  5.  *
  6.  * Returns 0 on success, negative on failure
  7.  *
  8.  * e1000_probe initializes an adapter identified by a pci_dev structure.
  9.  * The OS initialization, configuring of the adapter private structure,
  10.  * and a hardware reset occur.
  11.  **/
  12. static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
  13. {
  14. 	struct net_device *netdev;
  15. 	struct e1000_adapter *adapter = NULL;
  16. 	struct e1000_hw *hw;
  17.  
  18. 	static int cards_found;
  19. 	static int global_quad_port_a; /* global ksp3 port a indication */
  20. 	int i, err, pci_using_dac;
  21. 	u16 eeprom_data = 0;
  22. 	u16 tmp = 0;
  23. 	u16 eeprom_apme_mask = E1000_EEPROM_APME;
  24. 	int bars, need_ioport;
  25. 	bool disable_dev = false;
  26.  
  27. 	/* do not allocate ioport bars when not needed */
  28. 	need_ioport = e1000_is_need_ioport(pdev);
  29. 	if (need_ioport) {
  30. 		bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
  31. 		err = pci_enable_device(pdev);
  32. 	} else {
  33. 		bars = pci_select_bars(pdev, IORESOURCE_MEM);
  34. 		err = pci_enable_device_mem(pdev);
  35. 	}
  36. 	if (err)
  37. 		return err;
  38.  
  39. 	err = pci_request_selected_regions(pdev, bars, e1000_driver_name);
  40. 	if (err)
  41. 		goto err_pci_reg;
  42.  
  43. 	pci_set_master(pdev);
  44. 	err = pci_save_state(pdev);
  45. 	if (err)
  46. 		goto err_alloc_etherdev;
  47.  
  48. 	err = -ENOMEM;
  49. 	//为e1000网卡对应的net_device结构分配内存。
  50. 	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
  51. 	if (!netdev)
  52. 		goto err_alloc_etherdev;
  53.  
  54. 	SET_NETDEV_DEV(netdev, &pdev->dev);
  55.  
  56. 	pci_set_drvdata(pdev, netdev);
  57. 	adapter = netdev_priv(netdev);
  58. 	adapter->netdev = netdev;
  59. 	adapter->pdev = pdev;
  60. 	adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
  61. 	adapter->bars = bars;
  62. 	adapter->need_ioport = need_ioport;
  63.  
  64. 	hw = &adapter->hw;
  65. 	hw->back = adapter;
  66.  
  67. 	err = -EIO;
  68. 	hw->hw_addr = pci_ioremap_bar(pdev, BAR_0);
  69. 	if (!hw->hw_addr)
  70. 		goto err_ioremap;
  71. 	
  72. 	...
  73. 	
  74. 	/* make ready for any if (hw->...) below */
  75. 	err = e1000_init_hw_struct(adapter, hw);
  76. 	if (err)
  77. 		goto err_sw_init;
  78.  
  79. 	/* there is a workaround being applied below that limits
  80. 	 * 64-bit DMA addresses to 64-bit hardware.  There are some
  81. 	 * 32-bit adapters that Tx hang when given 64-bit DMA addresses
  82. 	 */
  83. 	pci_using_dac = 0;
  84. 	if ((hw->bus_type == e1000_bus_type_pcix) &&
  85. 	    !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) {
  86. 		pci_using_dac = 1;
  87. 	} else {
  88. 		err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
  89. 		if (err) {
  90. 			pr_err("No usable DMA config, aborting\n");
  91. 			goto err_dma;
  92. 		}
  93. 	}
  94. 	/*将e1000网卡驱动程序的相应函数注册到net_device结构的成员函数上。这里值得注意的
  95.     是如果定义了设备的CONFIG_E1000_NAPI宏，则设备对应的poll方法被注册为e1000_clean。
  96.     在网络设备初始化时（net_dev_init()函数）将所有的设备的poll方法注册为系统默认
  97.     函数process_backlog（），该函数的处理方法就是从CPU相关队列softnet_data的输入
  98.     数据包队列中读取skb，然后调用netif_receive_skb（）函数提交给上层协议继续处
  99.     理。设备的poll方法是在软中断处理函数中调用的。*/
  100. 	netdev->netdev_ops = &e1000_netdev_ops;
  101. 	e1000_set_ethtool_ops(netdev);
  102. 	netdev->watchdog_timeo = 5 * HZ;
  103. 	netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);
  104.  
  105. 	strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
  106.  
  107. 	adapter->bd_number = cards_found;
  108.  
  109. 	/* setup the private structure */
  110.  
  111. 	err = e1000_sw_init(adapter);
  112. 	if (err)
  113. 		goto err_sw_init;
  114. 	...
  115. 	/* reset the hardware with the new settings */
  116. 	e1000_reset(adapter);
  117.  
  118. 	strcpy(netdev->name, "eth%d");
  119. 	err = register_netdev(netdev);
  120. 	if (err)
  121. 		goto err_register;
  122.  
  123. 	e1000_vlan_filter_on_off(adapter, false);
  124. 	...
  125. 	return err;
  126. }
  127.  
  128. static const struct net_device_ops e1000_netdev_ops = {
  129. 	.ndo_open		= e1000_open,
  130. 	.ndo_stop		= e1000_close,
  131. 	.ndo_start_xmit		= e1000_xmit_frame,
  132. 	.ndo_set_rx_mode	= e1000_set_rx_mode,
  133. 	.ndo_set_mac_address	= e1000_set_mac,
  134. 	.ndo_tx_timeout		= e1000_tx_timeout,
  135. 	.ndo_change_mtu		= e1000_change_mtu,
  136. 	.ndo_do_ioctl		= e1000_ioctl,
  137. 	.ndo_validate_addr	= eth_validate_addr,
  138. 	.ndo_vlan_rx_add_vid	= e1000_vlan_rx_add_vid,
  139. 	.ndo_vlan_rx_kill_vid	= e1000_vlan_rx_kill_vid,
  140. #ifdef CONFIG_NET_POLL_CONTROLLER
  141. 	.ndo_poll_controller	= e1000_netpoll,
  142. #endif
  143. 	.ndo_fix_features	= e1000_fix_features,
  144. 	.ndo_set_features	= e1000_set_features,
  145. };

2.2 e1000_open(E1000网卡驱动程序的open方法)

在分析网卡接收数据包的过程中，设备的 open 方法是值得注意的，因为在这里对网卡设备的各种数据结构进行了初始化，特别是环形缓冲区队列和中断。

  1. int e1000_open(struct net_device *netdev)
  2. {
  3. 	struct e1000_adapter *adapter = netdev_priv(netdev);
  4. 	struct e1000_hw *hw = &adapter->hw;
  5. 	int err;
  6.  
  7. 	/* disallow open during test */
  8. 	if (test_bit(__E1000_TESTING, &adapter->flags))
  9. 		return -EBUSY;
  10.  
  11. 	netif_carrier_off(netdev);
  12.  
  13. 	/* allocate transmit descriptors */
  14. 	err = e1000_setup_all_tx_resources(adapter);
  15. 	if (err)
  16. 		goto err_setup_tx;
  17.  
  18. 	/* allocate receive descriptors */
  19. 	err = e1000_setup_all_rx_resources(adapter);
  20. 	if (err)
  21. 		goto err_setup_rx;
  22.  
  23. 	e1000_power_up_phy(adapter);
  24.  
  25. 	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
  26. 	if ((hw->mng_cookie.status &
  27. 			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
  28. 		e1000_update_mng_vlan(adapter);
  29. 	}
  30.  
  31. 	/* before we allocate an interrupt, we must be ready to handle it.
  32. 	 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
  33. 	 * as soon as we call pci_request_irq, so we have to setup our
  34. 	 * clean_rx handler before we do so.
  35. 	 */
  36. 	e1000_configure(adapter);
  37.  
  38. 	err = e1000_request_irq(adapter);
  39. 	if (err)
  40. 		goto err_req_irq;
  41.  
  42. 	/* From here on the code is the same as e1000_up() */
  43. 	clear_bit(__E1000_DOWN, &adapter->flags);
  44.  
  45. 	napi_enable(&adapter->napi);
  46.  
  47. 	e1000_irq_enable(adapter);
  48.  
  49. 	netif_start_queue(netdev);
  50.  
  51. 	/* fire a link status change interrupt to start the watchdog */
  52. 	ew32(ICS, E1000_ICS_LSC);
  53.  
  54. 	return E1000_SUCCESS;
  55.  
  56. err_req_irq:
  57. 	e1000_power_down_phy(adapter);
  58. 	e1000_free_all_rx_resources(adapter);
  59. err_setup_rx:
  60. 	e1000_free_all_tx_resources(adapter);
  61. err_setup_tx:
  62. 	e1000_reset(adapter);
  63.  
  64. 	return err;
  65. }

事实上e1000_open（） 函数调用了e1000_setup_rx_resources（）函数为其环形缓冲区分配资源。

e1000设备的接收方式是一种缓冲方式，能显著的降低 CPU接收数据造成的花费，接收数据之前，软件需要预先分配一个 DMA 缓冲区，一般对于传输而言，缓冲区最大为 8Kbyte 并且把物理地址链接在描述符的 DMA 地址描述单元，另外还有两个双字的单元表示对应的 DMA 缓冲区的接收状态。

2.3 e1000_setup_rx_resources(为其环形缓冲区分配资源)

在 /driver/net/e1000/e1000/e1000.h 中对于环形缓冲队列描述符的数据单元如下表示：

  1. struct e1000_rx_ring {
  2.     void *desc; /* 指向描述符环状缓冲区的指针。*/
  3.     dma_addr_t dma; /* 描述符环状缓冲区物理地址，也就是DMA缓冲区地址*/
  4.     unsigned int size; /* 描述符环状缓冲区的长度（用字节表示）*/
  5.     unsigned int count; /* 缓冲区内描述符的数量，这个是系统初始化时规定好的，它
  6.     决定该环形缓冲区有多少描述符（或者说缓冲区）可用*/
  7.     unsigned int next_to_use; /* 下一个要使用的描述符。*/
  8.     unsigned int next_to_clean; /* 下一个待删除描述符。*/
  9.     struct e1000_buffer *buffer_info; /* 缓冲区信息结构数组。*/
  10. 	struct sk_buff *rx_skb_top;
  11.  
  12. 	/* cpu for rx queue */
  13. 	int cpu;
  14.  
  15. 	u16 rdh;
  16. 	u16 rdt;
  17. };
  18.  
  19. static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
  20. 				    struct e1000_rx_ring *rxdr)
  21. {
  22. 	struct pci_dev *pdev = adapter->pdev;
  23. 	int size, desc_len;
  24.  
  25. 	size = sizeof(struct e1000_rx_buffer) * rxdr->count;
  26. 	rxdr->buffer_info = vzalloc(size);
  27. 	if (!rxdr->buffer_info)
  28. 		return -ENOMEM;
  29.  
  30. 	desc_len = sizeof(struct e1000_rx_desc);
  31.  
  32. 	/* Round up to nearest 4K */
  33.  
  34. 	rxdr->size = rxdr->count * desc_len;
  35. 	rxdr->size = ALIGN(rxdr->size, 4096);
  36.  
  37. 	rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
  38. 					GFP_KERNEL);
  39. 	if (!rxdr->desc) {
  40. setup_rx_desc_die:
  41. 		vfree(rxdr->buffer_info);
  42. 		return -ENOMEM;
  43. 	}
  44.  
  45. 	/* Fix for errata 23, can't cross 64kB boundary */
  46. 	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
  47. 		void *olddesc = rxdr->desc;
  48. 		dma_addr_t olddma = rxdr->dma;
  49. 		e_err(rx_err, "rxdr align check failed: %u bytes at %p\n",
  50. 		      rxdr->size, rxdr->desc);
  51. 		/* Try again, without freeing the previous */
  52. 		rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size,
  53. 						&rxdr->dma, GFP_KERNEL);
  54. 		/* Failed allocation, critical failure */
  55. 		if (!rxdr->desc) {
  56. 			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
  57. 					  olddma);
  58. 			goto setup_rx_desc_die;
  59. 		}
  60. 	...
  61. 	memset(rxdr->desc, 0, rxdr->size);
  62.  
  63. 	rxdr->next_to_clean = 0;
  64. 	rxdr->next_to_use = 0;
  65. 	rxdr->rx_skb_top = NULL;
  66.  
  67. 	return 0;
  68. }

2.4 request_irq(向系统申请irq中断号，中断处理函数 e1000_intr)

在 e1000_open() 函数中，调用e1000_request_irq() 向系统申请irq中断号，然后将e1000_intr() 中断处理函数注册到系统当中，系统有一个中断向量表irq_desc[]。然后使能网卡的中断。接下来就是网卡处于响应中断的模式，e1000_intr() 作为中断处理函数。

  1. /**
  2.  * e1000_intr - Interrupt Handler
  3.  * @irq: interrupt number
  4.  * @data: pointer to a network interface device structure
  5.  **/
  6. static irqreturn_t e1000_intr(int irq, void *data)
  7. {
  8. 	struct net_device *netdev = data;
  9. 	struct e1000_adapter *adapter = netdev_priv(netdev);
  10. 	struct e1000_hw *hw = &adapter->hw;
  11. 	u32 icr = er32(ICR);
  12.  
  13. 	if (unlikely((!icr)))
  14. 		return IRQ_NONE;  /* Not our interrupt */
  15. 	...
  16. 	/* disable interrupts, without the synchronize_irq bit */
  17. 	ew32(IMC, ~0);
  18. 	E1000_WRITE_FLUSH();
  19.  
  20. 	if (likely(napi_schedule_prep(&adapter->napi))) {
  21. 		adapter->total_tx_bytes = 0;
  22. 		adapter->total_tx_packets = 0;
  23. 		adapter->total_rx_bytes = 0;
  24. 		adapter->total_rx_packets = 0;
  25. 		__napi_schedule(&adapter->napi);//唤醒软中断
  26. 	} else {
  27. 		/* this really should not happen! if it does it is basically a
  28. 		 * bug, but not a hard error, so enable ints and continue
  29. 		 */
  30. 		if (!test_bit(__E1000_DOWN, &adapter->flags))
  31. 			e1000_irq_enable(adapter);
  32. 	}
  33.  
  34. 	return IRQ_HANDLED;
  35. }

2.5 net_rx_action函数(软中断处理函数)

下半部的处理函数，之前提到，网络数据包的接发对应两个不同的软中断，接收软中断NET_RX_SOFTIRQ的处理函数对应 net_rx_action。

  1. static void net_rx_action(struct softirq_action *h)
  2. {
  3.     //获取percpu的sd
  4.     struct softnet_data *sd = this_cpu_ptr(&softnet_data);
  5.     unsigned long time_limit = jiffies + 2;
  6.  
  7.     //netdev_budget默认值300，可通过sysctl修改
  8.     int budget = netdev_budget;
  9.     void *have;
  10.  
  11.     local_irq_disable();
  12.     //如果sd->poll_list不为空，说明有数据需要处理
  13.     while (!list_empty(&sd->poll_list)) {
  14.         struct napi_struct *n;
  15.         int work, weight;
  16.  
  17.         /* If softirq window is exhuasted then punt.
  18.          * Allow this to run for 2 jiffies since which will allow
  19.          * an average latency of 1.5/HZ.
  20.          */
  21.         //如果budget用完了，或者经过了两个时间片，说明数据
  22.         //包压力过大，还没处理完就需要跳出循环，在
  23.         //softnet_break会再次激活软中断(因为执行软中断时已
  24.         //经把所有的pending清空了)
  25.         if (unlikely(budget <= 0 || time_after_eq(jiffies, time_limit)))
  26.             goto softnet_break;
  27.  
  28.         local_irq_enable();
  29.  
  30.         /* Even though interrupts have been re-enabled, this
  31.          * access is safe because interrupts can only add new
  32.          * entries to the tail of this list, and only ->poll()
  33.          * calls can remove this head entry from the list.
  34.          */
  35.         n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
  36.  
  37.         have = netpoll_poll_lock(n);
  38.  
  39.         weight = n->weight;
  40.  
  41.         /* This NAPI_STATE_SCHED test is for avoiding a race
  42.          * with netpoll's poll_napi().  Only the entity which
  43.          * obtains the lock and sees NAPI_STATE_SCHED set will
  44.          * actually make the ->poll() call.  Therefore we avoid
  45.          * accidentally calling ->poll() when NAPI is not scheduled.
  46.          */
  47.         work = 0;
  48.         //只有state为NAPI_STATE_SCHED才会执行poll函数。
  49.         //对于non-napi来说，poll函数为process_backlog，处理
  50.         //percpu的input queue上的数据包。
  51.         //对于napi来说，poll函数为网卡驱动提供的poll函数，比
  52.         //如ixgbe_poll，分配skb，将skb上送协议栈
  53.         //如果poll处理后的结果work小于weight说明没有更多数
  54.         //据需要处理，poll函数中会把napi从链表sd->poll_list删
  55.         //除。如果work等于weight说明还有更多数据需要处理，
  56.         //不会删除napi，只是将napi移动到链表尾部
  57.         if (test_bit(NAPI_STATE_SCHED, &n->state)) {
  58.             work = n->poll(n, weight);
  59.             trace_napi_poll(n);
  60.         }
  61.  
  62.         WARN_ON_ONCE(work > weight);
  63.         //work为poll实际处理的数据个数，budget需要减去work
  64.         budget -= work;
  65.  
  66.         local_irq_disable();
  67.  
  68.         /* Drivers must not modify the NAPI state if they
  69.          * consume the entire weight.  In such cases this code
  70.          * still "owns" the NAPI instance and therefore can
  71.          * move the instance around on the list at-will.
  72.          */
  73.         //如果work等于weight说明还有更多数据需要处理
  74.         if (unlikely(work == weight)) {
  75.             if (unlikely(napi_disable_pending(n))) {
  76.                 local_irq_enable();
  77.                 napi_complete(n);
  78.                 local_irq_disable();
  79.             } else {
  80.                 if (n->gro_list) {
  81.                     /* flush too old packets
  82.                      * If HZ < 1000, flush all packets.
  83.                      */
  84.                     local_irq_enable();
  85.                     napi_gro_flush(n, HZ >= 1000);
  86.                     local_irq_disable();
  87.                 }
  88.                 //将napi移动到链表尾部
  89.                 list_move_tail(&n->poll_list, &sd->poll_list);
  90.             }
  91.         }
  92.  
  93.         netpoll_poll_unlock(have);
  94.     }
  95. out:
  96.     net_rps_action_and_irq_enable(sd);
  97.  
  98.     return;
  99.  
  100. softnet_break:
  101.     sd->time_squeeze++;
  102.     __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  103.     goto out;
  104. }
  105.  
  106. /*
  107.  * net_rps_action_and_irq_enable sends any pending IPI's for rps.
  108.  * Note: called with local irq disabled, but exits with local irq enabled.
  109.  */
  110. //如果链表 sd->rps_ipi_list不为空，说明在rps下，将skb放在其他
  111. //cpu上的percpu队列上了，所以需要通过ipi中断通知其他cpu，通
  112. //过smp_call_function_single_async远程激活其他cpu的软中断，
  113. //使其他cpu处理数据包
  114. static void net_rps_action_and_irq_enable(struct softnet_data *sd)
  115. {
  116. #ifdef CONFIG_RPS
  117.     struct softnet_data *remsd = sd->rps_ipi_list;
  118.  
  119.     if (remsd) {
  120.         sd->rps_ipi_list = NULL;
  121.  
  122.         local_irq_enable();
  123.  
  124.         /* Send pending IPI's to kick RPS processing on remote cpus. */
  125.         while (remsd) {
  126.             struct softnet_data *next = remsd->rps_ipi_next;
  127.  
  128.             if (cpu_online(remsd->cpu))
  129.                 smp_call_function_single_async(remsd->cpu,
  130.                                &remsd->csd);
  131.             remsd = next;
  132.         }
  133.     } else
  134. #endif
  135.         local_irq_enable();
  136. }

这里有处理方式比较直观，直接遍历 poll_list 链表，处理之前设置了两个限制：budget 和time_limit。前者限制本次处理数据包的总量，后者限制本次处理总时间。只有二者均有剩余的情况下，才会继续处理。处理期间同样是开中断的，每次总是从链表表头取设备进行处理，如果设备被调度，其实就是检查 NAPI_STATE_SCHED 位，则调用 napi_struct 的 poll 函数，处理结束如果没有处理完，则把设备移动到链表尾部，否则从链表删除。NAPI 设备对应的 poll 函数会同样会调用__netif_receive_skb 函数上传协议栈。

2.5.1 激活软中断(ixgbe 网卡调用栈)

  1. //硬件中断到来时调用中断处理函数 ixgbe_msix_clean_rings
  2. ixgbe_msix_clean_rings
  3.     napi_schedule(&q_vector->napi);
  4. ____napi_schedule(this_cpu_ptr(&softnet_data), n);
  5.             //将napi添加到per cpu的softnet_data->poll_list中
  6.             list_add_tail(&napi->poll_list, &sd->poll_list);
  7.             //将接收软中断置位
  8.             __raise_softirq_irqoff(NET_RX_SOFTIRQ);

2.5.2 执行软中断(ixgbe 网卡调用栈)

  1. __do_softirq
  2.     net_rx_action
  3.         n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
  4.         work = n->poll(n, weight); //即调用 ixgbe_poll
  5.             ixgbe_clean_rx_irq(q_vector, ring)
  6.                 skb = ixgbe_fetch_rx_buffer(rx_ring, rx_desc);
  7.                 ixgbe_rx_skb(q_vector, skb);
  8.                     napi_gro_receive(&q_vector->napi, skb);
  9.                         //上送协议栈，但如果开启了RPS就走non-NAPI的路径了
  10.                         netif_receive_skb_internal
  11.             /* all work done, exit the polling mode */
  12.             //如果处理的skb小于配额，说明工作已经完成，将napi从poll_list删除
  13.             //清除标志位 NAPI_STATE_SCHED
  14.             napi_complete(napi);
  15.                 list_del(&n->poll_list);
  16.                 clear_bit(NAPI_STATE_SCHED, &n->state);

如果没有开启RPS，则直接调用 __netif_receive_skb上送协议栈了。如果开启了RPS，则调用get_rps_cpu 获取合适的 cpu(有可能是本地cpu，也有可能是其他cpu)，再调用enqueue_to_backlog 将 skb 放在 percpu 的队列中，激活相应 cpu 的软中断。

  1. static int netif_receive_skb_internal(struct sk_buff *skb)
  2. {
  3.     int ret;
  4.  
  5.     net_timestamp_check(netdev_tstamp_prequeue, skb);
  6.  
  7.     if (skb_defer_rx_timestamp(skb))
  8.         return NET_RX_SUCCESS;
  9.  
  10.     rcu_read_lock();
  11.  
  12. #ifdef CONFIG_RPS
  13.     //注意使用的是static_key_false进行判断，意思是分支预测为false概率很大
  14.     if (static_key_false(&rps_needed)) {
  15.         struct rps_dev_flow voidflow, *rflow = &voidflow;
  16.         int cpu = get_rps_cpu(skb->dev, skb, &rflow);
  17.  
  18.         if (cpu >= 0) {
  19.             ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
  20.             rcu_read_unlock();
  21.             return ret;
  22.         }
  23.     }
  24. #endif
  25.     ret = __netif_receive_skb(skb);
  26.     rcu_read_unlock();
  27.     return ret;
  28. }

2.6 poll 函数

2.6.1 process_backlog(非NAPI)

  1. static int process_backlog(struct napi_struct *napi, int quota)
  2. {
  3.     int work = 0;
  4.     struct softnet_data *sd = container_of(napi, struct softnet_data, backlog);
  5.  
  6. #ifdef CONFIG_RPS
  7.     /* Check if we have pending ipi, its better to send them now,
  8.      * not waiting net_rx_action() end.
  9.      */
  10.     //激活其他cpu上的软中断
  11.     if (sd->rps_ipi_list) {
  12.         local_irq_disable();
  13.         net_rps_action_and_irq_enable(sd);
  14.     }
  15. #endif
  16.     napi->weight = weight_p;
  17.     local_irq_disable();
  18.     while (1) {
  19.         struct sk_buff *skb;
  20.  
  21.         while ((skb = __skb_dequeue(&sd->process_queue))) {
  22.             rcu_read_lock();
  23.             local_irq_enable();
  24.             //将skb上送协议栈
  25.             __netif_receive_skb(skb);
  26.             rcu_read_unlock();
  27.             local_irq_disable();
  28.             input_queue_head_incr(sd);
  29.             //处理skb的个数达到quota了，说明还有更多数据
  30.             //包需要处理
  31.             if (++work >= quota) {
  32.                 local_irq_enable();
  33.                 return work;
  34.             }
  35.         }
  36.  
  37.         rps_lock(sd);
  38.         if (skb_queue_empty(&sd->input_pkt_queue)) {
  39.             /*
  40.              * Inline a custom version of __napi_complete().
  41.              * only current cpu owns and manipulates this napi,
  42.              * and NAPI_STATE_SCHED is the only possible flag set
  43.              * on backlog.
  44.              * We can use a plain write instead of clear_bit(),
  45.              * and we dont need an smp_mb() memory barrier.
  46.              */
  47.             //如果input_pkt_queue队列为空，将napi从链表
  48.             //poll_list删除
  49.             list_del(&napi->poll_list);
  50.             napi->state = 0;
  51.             rps_unlock(sd);
  52.  
  53.             break;
  54.         }
  55.         //将input_pkt_queue队列中的skb挂到process_queue
  56.         //上，并清空input_pkt_queue
  57.         skb_queue_splice_tail_init(&sd->input_pkt_queue,
  58.                        &sd->process_queue);
  59.         rps_unlock(sd);
  60.     }
  61.     local_irq_enable();
  62.  
  63.     return work;
  64. }

函数还是比较简单的，需要注意的每次处理都携带一个配额，即本次只能处理quota个数据包，如果超额了，即使没处理完也要返回，这是为了保证处理器的公平使用。处理在一个while循环中完成，循环条件正是work < quota，首先会从process_queue中取出skb,调用__netif_receive_skb上传给协议栈，然后增加work。当work即将大于quota时，即++work >= quota时，就要返回。当work还有剩余额度，但是 process_queue 中数据处理完了，就需要检查input_pkt_queue，因为在具体处理期间是开中断的，那么期间就有可能有新的数据包到来，如果input_pkt_queue不为空，则调用s kb_queue_splice_tail_init 函数把数据包迁移到 process_queue。如果剩余额度足够处理完这些数据包，那么就把虚拟设备移除轮询队列。这里有些疑惑就是最后为何要增加额度，剩下的额度已经足够处理这些数据了呀？根据此流程不难发现，其实执行的是在两个队列之间移动数据包，然后再做处理。

2.6.2 e1000_clean(e1000网卡 NAPI) 

下面介绍一下 e1000 网卡的轮询 poll 处理函数 e1000_clean()，这个函数只有定义了 NAPI 宏的情况下才有效：

  1. /**
  2.  * e1000_clean - NAPI Rx polling callback
  3.  * @napi: napi struct containing references to driver info
  4.  * @budget: budget given to driver for receive packets
  5.  **/
  6. static int e1000_clean(struct napi_struct *napi, int budget)
  7. {
  8. 	struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter,
  9. 						     napi);
  10. 	int tx_clean_complete = 0, work_done = 0;
  11.  
  12. 	tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]);
  13. 	//处理网卡中断收到的数据包即 e1000_clean_rx_irq
  14. 	adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget);
  15.  
  16. 	if (!tx_clean_complete || work_done == budget)
  17. 		return budget;
  18.  
  19. 	/* Exit the polling mode, but don't re-enable interrupts if stack might
  20. 	 * poll us due to busy-polling
  21. 	 */
  22. 	if (likely(napi_complete_done(napi, work_done))) {
  23. 		if (likely(adapter->itr_setting & 3))
  24. 			e1000_set_itr(adapter);
  25. 		if (!test_bit(__E1000_DOWN, &adapter->flags))
  26. 			e1000_irq_enable(adapter);
  27. 	}
  28.  
  29. 	return work_done;
  30. }

2.6.3 e1000_clean_rx_irq(处理e1000网卡中断收到的数据包，核心)

设备轮询接收机制中最重要的函数就是下面这个函数，当然它同时也可以为中断接收机制所用，只不过处理过程有一定的差别。上面看到budget -= napi_poll(n, &repoll);他会去调用我们驱动初始化时注册的poll函数，在e1000网卡中就是 e1000_clean 函数。

  1. /**
  2.  * e1000_clean_rx_irq - Send received data up the network stack; legacy
  3.  * @adapter: board private structure
  4.  * @rx_ring: ring to clean
  5.  * @work_done: amount of napi work completed this call
  6.  * @work_to_do: max amount of work allowed for this call to do
  7.  */
  8. static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
  9. 			       struct e1000_rx_ring *rx_ring,
  10. 			       int *work_done, int work_to_do)
  11. {
  12. 	struct net_device *netdev = adapter->netdev;
  13. 	struct pci_dev *pdev = adapter->pdev;
  14. 	struct e1000_rx_desc *rx_desc, *next_rxd;
  15. 	struct e1000_rx_buffer *buffer_info, *next_buffer;
  16. 	u32 length;
  17. 	unsigned int i;
  18. 	int cleaned_count = 0;
  19. 	bool cleaned = false;
  20. 	unsigned int total_rx_bytes = 0, total_rx_packets = 0;
  21. 	
  22. 	/*把i置为下一个要清除的描述符索引，因为在环形缓冲区队列当中，我们即使已经处理
  23.      *完一个缓冲区描述符，也不是将其删除，而是标记为已经处理，这样如果有新的数据需要
  24.      *使用缓冲区，只是将已经处理的缓冲区覆盖而已。*/
  25. 	i = rx_ring->next_to_clean;
  26. 	rx_desc = E1000_RX_DESC(*rx_ring, i);
  27. 	buffer_info = &rx_ring->buffer_info[i];
  28. 	
  29.     /*如果i对应的描述符状态是已经删除，则将这个缓冲区取出来给新的数据使用*/
  30. 	while (rx_desc->status & E1000_RXD_STAT_DD) {
  31. 		struct sk_buff *skb;
  32. 		u8 *data;
  33. 		u8 status;
  34. 		
  35. 		/*在配置了NAPI的情况下，判断是否已经完成的工作？，因为是轮询机制，所以我
  36.         *们必须自己计算我们已经处理了多少数据。*/
  37. 		if (*work_done >= work_to_do)
  38. 			break;
  39. 		(*work_done)++;
  40. 		dma_rmb(); /* read descriptor and rx_buffer_info after status DD */
  41.  
  42. 		status = rx_desc->status;
  43. 		length = le16_to_cpu(rx_desc->length);
  44.  
  45. 		data = buffer_info->rxbuf.data;
  46. 		prefetch(data);
  47. 		/*调用__alloc_skb创建一个sk_buff,
  48. 		*dma_sync_single_for_cpu读取DMA数据最新，
  49. 		并将data数据拷贝进skb中*/
  50. 		skb = e1000_copybreak(adapter, buffer_info, length, data);
  51. 		if (!skb) {
  52. 			unsigned int frag_len = e1000_frag_len(adapter);
  53.  
  54. 			skb = build_skb(data - E1000_HEADROOM, frag_len);
  55. 			if (!skb) {
  56. 				adapter->alloc_rx_buff_failed++;
  57. 				break;
  58. 			}
  59.  
  60. 			skb_reserve(skb, E1000_HEADROOM);
  61. 			/*这个是DMA函数，目的是解除与DMA缓冲区的映射关系，这样我们就可以访问这个
  62. 			 *缓冲区，获取通过DMA传输过来的数据包（skb）。驱动程序在分配环形缓冲区的时
  63. 			 *候就将缓冲区与DMA进行了映射。*/
  64. 			dma_unmap_single(&pdev->dev, buffer_info->dma,
  65. 					 adapter->rx_buffer_len,
  66. 					 DMA_FROM_DEVICE);
  67. 			buffer_info->dma = 0;
  68. 			buffer_info->rxbuf.data = NULL;
  69. 		}
  70. 		...
  71. 	
  72. process_skb:
  73. 		total_rx_bytes += (length - 4); /* don't count FCS */
  74. 		total_rx_packets++;
  75.  
  76. 		if (likely(!(netdev->features & NETIF_F_RXFCS)))
  77. 			/* adjust length to remove Ethernet CRC, this must be
  78. 			 * done after the TBI_ACCEPT workaround above
  79. 			 */
  80. 			length -= 4;
  81. 		/*对接收的数据包检查一下正确性。确认是一个正确的数据包以后，将skb的数据
  82.          *指针进行偏移。*/
  83. 		if (buffer_info->rxbuf.data == NULL)
  84. 			skb_put(skb, length);
  85. 		else /* copybreak skb */
  86. 			skb_trim(skb, length);
  87.  
  88. 		/* Receive Checksum Offload */
  89. 		e1000_rx_checksum(adapter,
  90. 				  (u32)(status) |
  91. 				  ((u32)(rx_desc->errors) << 24),
  92. 				  le16_to_cpu(rx_desc->csum), skb);
  93.  
  94. 		e1000_receive_skb(adapter, status, rx_desc->special, skb);
  95.  
  96. next_desc:
  97. 		rx_desc->status = 0;
  98.  
  99. 		/* return some buffers to hardware, one at a time is too slow */
  100. 		if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
  101. 			adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);//e1000_alloc_rx_buffers
  102. 			cleaned_count = 0;
  103. 		}
  104.  
  105. 		/* use prefetched values */
  106. 		rx_desc = next_rxd;
  107. 		buffer_info = next_buffer;
  108. 	}
  109. 	rx_ring->next_to_clean = i;
  110. 	...
  111. 	return cleaned;
  112. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/252899
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号