原文出处：http://blog.chinaunix.net/uid-23629988-id-305200.html

 

在Linux kernel中，由网卡驱动完成L1物理层和L2数据链路层的工作。
首先看函数net_dev_init

  1. static int __init net_dev_init(void)

  2. {

  3. int i, rc =-ENOMEM;


  5. BUG_ON(!dev_boot_phase);

/* 
创建对应的/proc文件，如/proc/net/dev, /proc/net/softnet_stat等
*/

  1. if(dev_proc_init())

  2. goto out;

/* 初始化netdev对应的kobject*/

  1. if(netdev_kobject_init())

  2. goto out;

/* 
初始化数据链路层的handle上层数据类型表。
回忆前文《TCP/IP学习(28)——数据包完整接受流程》中，在inet_init中注册了IP包类型到这个表中。
*/

  1. INIT_LIST_HEAD(&ptype_all);

  2. for(i = 0; i < PTYPE_HASH_SIZE; i++)

  3. INIT_LIST_HEAD(&ptype_base[i]);

/*
注册neddev_net_ops subsystem
*/

  1. if(register_pernet_subsys(&netdev_net_ops))

  2. goto out;


  4. /*

  5. * Initialise the packet receive queues.

  6. */

  7. /*

  8. 为每个CPU初始化PERCPU的全局变量softnet_data，作为该CPU的接收缓存 

  9. */

  10. for_each_possible_cpu(i){

  11. struct softnet_data *sd =&per_cpu(softnet_data, i);


  13. ...... ......

  14. }


  16. dev_boot_phase = 0;


  18. /* The loopback device is special if any other network devices

  19. *is present in a network namespace the loopback device must

  20. * be present. Since we now dynamically allocate and free the

  21. * loopback device ensure this invariant is maintained by

  22. * keeping the loopback device as the first device on the

  23. * list of network devices. Ensuring the loopback devices

  24. *is the first device that appears and the last network device

  25. * that disappears.

  26. */

  27. if(register_pernet_device(&loopback_net_ops))

  28. goto out;


  30. if(register_pernet_device(&default_device_ops))

  31. goto out;

/*
enable软中断
*/

  1. open_softirq(NET_TX_SOFTIRQ, net_tx_action);

  2. open_softirq(NET_RX_SOFTIRQ, net_rx_action);


  4. hotcpu_notifier(dev_cpu_callback, 0);

  5. dst_init();

  6. dev_mcast_init();

  7. rc = 0;

  8. out:

  9. return rc;

  10. }

net_dev_init在系统启动时，在注册网卡之前调用，主要就是初始化net device所需要的一些环境。

下面仍然以Intel PRO/1000的网卡驱动为例，e1000_init_module为该驱动的入口。通过e1000_init_module->pci_register_driver->e1000_probe进入初始化函数。
在e1000_probe中，通过下面这条语句绑定了操作函数。
netdev->netdev_ops = &e1000_netdev_ops;

  1. static const struct net_device_ops e1000_netdev_ops ={

  2. .ndo_open = e1000_open,

  3. ...... ......

  4. };

对于今天的主题来说，只需关心e1000_open即可。因为该函数是在激活该网卡时被调用，完成资源的申请，中断的注册，即e1000_intr。

  1. static irqreturn_t e1000_intr(int irq, void *data)

  2. {

  3. ...... ...... 

  4. /*

  5. 检测是否可以调度NAPI：

  6. 当没有disable NAPI且没有该网卡对应的NAPI在运行时（保证对应一个网卡的NAPI只有一个实例在运行），即可调度一个新的NAPI。

  7. NAPI是一种新的网卡数据检查处理方式。基本上是interrupt+poll。详细信息问google

  8. */

  9. if(likely(napi_schedule_prep(&adapter->napi))){

  10. /* 

  11. 清楚单次的统计信息。

  12. 刚看到这里时，我也奇怪，为什么total的统计信息要被清零。

  13. 实际上这些统计信息只是一次NAPI运行的统计信息，并不是网卡总的统计信息。

  14. 网卡的统计信息为netdev->stats。NAPI运行完会将下面的值加到网卡的统计信息上的。

  15. */

  16. adapter->total_tx_bytes = 0;

  17. adapter->total_tx_packets = 0;

  18. adapter->total_rx_bytes = 0;

  19. adapter->total_rx_packets = 0;

  20. /* 要求调度对应的NAPI实例 */

  21. __napi_schedule(&adapter->napi);

  22. }else{

  23. /* this really should notif it does it is basically a

  24. * bug, but not a hard error, so enable ints and continue */

  25. if(!test_bit(__E1000_DOWN,&adapter->flags))

  26. e1000_irq_enable(adapter);

  27. }


  29. return IRQ_HANDLED;

  30. }

上面为中断的关键流程，其中要求调度对应的NAPI实例时，实际上是引发一个软中断。
__raise_softirq_irqoff(NET_RX_SOFTIRQ)。这个中断函数的主要功能就是要求调度一个NAPI——这里跟以前理解的中断函数不太一样。按照教科书式的概念，网卡的中断函数，应该将数据包从网卡的缓冲中取出放到一个系统缓冲中，然后在引发软中断去做剩下的工作。

下面看 NET_RX_SOFTIRQ软中断对应的处理函数net_rx_action。

  1. static void net_rx_action(struct softirq_action *h)

  2. {

  3. struct softnet_data *sd =&__get_cpu_var(softnet_data);

  4. unsigned long time_limit = jiffies + 2;

  5. int budget = netdev_budget;

  6. void *have;


  8. local_irq_disable();

/* 开始顺序poll所有需要poll的网卡 */

  1. while(!list_empty(&sd->poll_list)){

  2. struct napi_struct *n;

  3. int work, weight;


  5. /*If softirq windowis exhuasted then punt.

  6. * Allow this to run for 2 jiffies since which will allow

  7. * an average latency of 1.5/HZ.

  8. */

  9. if(unlikely(budget <= 0 || time_after(jiffies, time_limit)))

  10. goto softnet_break;


  12. local_irq_enable();


  14. /* Even though interrupts have been re-enabled, this

  15. * access is safe because interrupts can only add new

  16. * entries to the tail of this list,and only ->poll()

  17. * calls can remove this head entry from the list.

  18. */

  19. /* 取得一个网卡的NAPI实例 */

  20. n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);

/* 给这个实例上锁 */

  1. have = netpoll_poll_lock(n);


  3. weight = n->weight;


  5. /* This NAPI_STATE_SCHED test isfor avoiding a race

  6. * with netpoll's poll_napi(). Only the entity which

  7. * obtains the lock and sees NAPI_STATE_SCHED set will

  8. * actually make the ->poll()call. Therefore we avoid

  9. * accidently calling ->poll() when NAPI isnot scheduled.

  10. */

  11. work = 0;

  12. if(test_bit(NAPI_STATE_SCHED,&n->state)){

  13. /* poll这个网卡 */

  14. work = n->poll(n, weight);

  15. trace_napi_poll(n);

  16. }


  18. WARN_ON_ONCE(work > weight);


  20. budget -= work;


  22. local_irq_disable();


  24. /* Drivers must not modify the NAPI state if they

  25. * consume the entire weight.In such cases this code

  26. * still "owns" the NAPI instance and therefore can

  27. * move the instance around on the list at-will.

  28. */

  29. if(unlikely(work == weight)){

  30. /* 该NAPI的weight消耗完毕，需要处理下一个 */

  31. if(unlikely(napi_disable_pending(n))){

  32. local_irq_enable();

  33. napi_complete(n);

  34. local_irq_disable();

  35. }else

  36. list_move_tail(&n->poll_list,&sd->poll_list);

  37. }


  39. netpoll_poll_unlock(have);

  40. }

  41. out:

  42. net_rps_action_and_irq_enable(sd);


  44. #ifdef CONFIG_NET_DMA

  45. /*

  46. * There may not be any more sk_buffs coming rightnow, so push

  47. * any pending DMA copies to hardware

  48. */

  49. dma_issue_pending_all();

  50. #endif


  52. return;


  54. softnet_break:

  55. sd->time_squeeze++;

  56. __raise_softirq_irqoff(NET_RX_SOFTIRQ);

  57. goto out;

  58. }

通过上面这个软中断处理函数，对应每个网卡来说，又需要跳回驱动，去学习对应的poll函数。对于本文的这个驱动来说，poll函数就是e1000_clean->e1000_clean_rx_irq。这个函数是真正用于处理网卡接收数据包的工作。

  1. static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

  2. struct e1000_rx_ring *rx_ring,

  3. int*work_done,int work_to_do)

  4. {

  5. ...... ......

/* 得到当前需要处理buffer*/

  1. i = rx_ring->next_to_clean;

  2. rx_desc = E1000_RX_DESC(*rx_ring, i);

  3. buffer_info =&rx_ring->buffer_info[i];


  5. while(rx_desc->status & E1000_RXD_STAT_DD){

  6. struct sk_buff *skb;

  7. u8 status;


  9. if(*work_done >= work_to_do) //如果已经poll到足够的包，可以跳出返回

  10. break;

  11. (*work_done)++;

  12. rmb();/* read descriptor and rx_buffer_info after status DD */

/* 得到数据包buffer对应的skb buffer结构地址 */

  1. status = rx_desc->status;

  2. skb = buffer_info->skb;

  3. buffer_info->skb =NULL;

/* 
然后做一些网卡硬件相关，及一些sanity check
*/
...... ......

  1. /* 

  2. 设置skb->pkt_type：PACKET_BROADCAST等；

  3. 即数据链路层协议类型

  4. */

  5. skb->protocol = eth_type_trans(skb, netdev);

/* 将数据包传递给上层，并做一些通用数据链路层的处理 */

  1. e1000_receive_skb(adapter, status, rx_desc->special, skb);


  3. next_desc:

  4. /* 处理下一个数据包 */

  5. ...... ......

  6. }
/* 更新统计信息等*/

  1. ...... ...... 


  3. return cleaned;

  4. }

在这个函数中，真正的从网卡buffer中取出数据包，然后根据硬件的特性做一些特定处理，并简单的设置了数据包的一些field，完成L1的操作，设置好L2的报头。这时，数据包已经为TCP/IP协议栈所需要的skb_buff结构。
然后调用e1000_receive_skb->netif_receive_skb->__netif_receive_skb

  1. static int __netif_receive_skb(struct sk_buff *skb)

  2. {

  3. struct packet_type *ptype,*pt_prev;

  4. rx_handler_func_t *rx_handler;

  5. struct net_device *orig_dev;

  6. struct net_device *master;

  7. struct net_device *null_or_orig;

  8. struct net_device *orig_or_bond;

  9. int ret = NET_RX_DROP;

  10. __be16 type;

/* 为skb打时间戳 */

  1. if(!netdev_tstamp_prequeue)

  2. net_timestamp_check(skb);

/* vlan下硬件加速处理 */

  1. if(vlan_tx_tag_present(skb)&& vlan_hwaccel_do_receive(skb))

  2. return NET_RX_SUCCESS;


  4. /*if we've gotten here through NAPI, check netpoll */

  5. if(netpoll_receive_skb(skb))

  6. return NET_RX_DROP;

/* 设置skb的iif为接收网卡的索引 */

  1. if(!skb->skb_iif)

  2. skb->skb_iif = skb->dev->ifindex;

  1. /*

  2. * bonding note: skbs received on inactive slaves should only

  3. * be delivered to pkt handlers that are exact matches. Also

  4. * the deliver_no_wcard flag will be set.If packet handlers

  5. * are sensitive to duplicate packets these skbs will need to

  6. * be dropped at the handler. The vlan accel path may have

  7. * already set the deliver_no_wcard flag.

  8. */

  9. /*关于网卡的bond的处理， 这个feature我只是了解，所以略过 */

  10. null_or_orig =NULL;

  11. orig_dev = skb->dev;

  12. master = ACCESS_ONCE(orig_dev->master);

  13. if(skb->deliver_no_wcard)

  14. null_or_orig = orig_dev;

  15. elseif(master){

  16. if(skb_bond_should_drop(skb, master)){

  17. skb->deliver_no_wcard = 1;

  18. null_or_orig = orig_dev;/* deliver only exact match */

  19. }else

  20. skb->dev = master;

  21. }


  23. __this_cpu_inc(softnet_data.processed);

  24. /* 初始化l3 header 和 l4 header 的地址*/

  25. skb_reset_network_header(skb);

  26. skb_reset_transport_header(skb);

  27. /* 得到mac地址长度，准确来说是2层地址的长度 */

  28. skb->mac_len = skb->network_header - skb->mac_header;


  30. pt_prev =NULL;


  32. rcu_read_lock();


  34. /*

  35. 省略一些不太相关的代码 

  36. */

  37. ...... ......

  38.  

  39. /*

  40. 通过2层协议类型作为key，得到相应链表。

  41. */

  1. type = skb->protocol;

  2. list_for_each_entry_rcu(ptype,

  3. &ptype_base[ntohs(type)& PTYPE_HASH_MASK], list){

  4. if(ptype->type == type &&(ptype->dev == null_or_orig ||

  5. ptype->dev == skb->dev || ptype->dev == orig_dev ||

  6. ptype->dev == orig_or_bond)){

  7. if(pt_prev) //找到匹配的协议类型，上传给L3层

  8. ret = deliver_skb(skb, pt_prev, orig_dev);

  9. pt_prev = ptype;

  10. }

  11. }


  13. if(pt_prev){

  14. ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);

  15. }else{

  16. kfree_skb(skb);

  17. /* Jamal,now you will not able to escape explaining

  18. * me how you were going to use this.:-)

  19. */

  20. ret = NET_RX_DROP;

  21. }


  23. out:

  24. rcu_read_unlock();

  25. return ret;

  26. }

现在基本上已经比较详细的学习了L2层的数据包处理流程。当然，还有很多很多的细节没有涉及，道路还很漫长啊。