1. static int __init net_dev_init(void)
   
2. {
   
3.     int i, rc = -ENOMEM;
   
4. 
   
5.     BUG_ON(!dev_boot_phase);
   

1.     if (dev_proc_init())
   
2.         goto out;
   

1.     if (netdev_kobject_init())
   
2.         goto out;
   

1.     INIT_LIST_HEAD(&ptype_all);
   
2.     for (i = 0; i < PTYPE_HASH_SIZE; i++)
   
3.         INIT_LIST_HEAD(&ptype_base[i]);
   

1.     if (register_pernet_subsys(&netdev_net_ops))
   
2.         goto out;
   
3. 
   
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);
    
12. 
    
13.         ...... ......
14.     }
    
15. 
    
16.     dev_boot_phase = 0;
    
17. 
    
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;
    
29. 
    
30.     if (register_pernet_device(&default_device_ops))
    
31.         goto out;
    

1.     open_softirq(NET_TX_SOFTIRQ, net_tx_action);
   
2.     open_softirq(NET_RX_SOFTIRQ, net_rx_action);
   
3. 
   
4.     hotcpu_notifier(dev_cpu_callback, 0);
   
5.     dst_init();
   
6.     dev_mcast_init();
   
7.     rc = 0;
   
8. out:
   
9.     return rc;
   
10. }

1. static const struct net_device_ops e1000_netdev_ops = {
   
2.     .ndo_open        = e1000_open,
   
3. ...... ......
4. };

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 not if 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.     }
    
28. 
    
29.     return IRQ_HANDLED;
    
30. }

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;
   
7. 
   
8.     local_irq_disable();
   

1.     while (!list_empty(&sd->poll_list)) {
   
2.         struct napi_struct *n;
   
3.         int work, weight;
   
4. 
   
5.         /* If softirq window is 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;
    
11. 
    
12.         local_irq_enable();
    
13. 
    
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);
   
2. 
   
3.         weight = n->weight;
   
4. 
   
5.         /* This NAPI_STATE_SCHED test is for 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 is not 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.         }
    
17. 
    
18.         WARN_ON_ONCE(work > weight);
    
19. 
    
20.         budget -= work;
    
21. 
    
22.         local_irq_disable();
    
23. 
    
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.         }
    
38. 
    
39.         netpoll_poll_unlock(have);
    
40.     }
    
41. out:
    
42.     net_rps_action_and_irq_enable(sd);
    
43. 
    
44. #ifdef CONFIG_NET_DMA
    
45.     /*
    
46.      * There may not be any more sk_buffs coming right now, so push
    
47.      * any pending DMA copies to hardware
    
48.      */
    
49.     dma_issue_pending_all();
    
50. #endif
    
51. 
    
52.     return;
    
53. 
    
54. softnet_break:
    
55.     sd->time_squeeze++;
    
56.     __raise_softirq_irqoff(NET_RX_SOFTIRQ);
    
57.     goto out;
    
58. }

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.    ...... ......

1.     i = rx_ring->next_to_clean;
2.     rx_desc = E1000_RX_DESC(*rx_ring, i);
3.     buffer_info = &rx_ring->buffer_info[i];
   
4. 
   
5.     while (rx_desc->status & E1000_RXD_STAT_DD) {
   
6.         struct sk_buff *skb;
   
7.         u8 status;
   
8. 
   
9.         if (*work_done >= work_to_do) //如果已经poll到足够的包，可以跳出返回
   
10.             break;
    
11.         (*work_done)++;
    
12.         rmb(); /* read descriptor and rx_buffer_info after status DD */
    

1.         status = rx_desc->status;
   
2.         skb = buffer_info->skb;
   
3.         buffer_info->skb = NULL;
   

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);
   
2. 
   
3. next_desc:
   
4.         /* 处理下一个数据包 */
5.         ...... ......
6.     }

1.     ...... ...... 
2. 
   
3.     return cleaned;
4. }

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;
    

1.     if (!netdev_tstamp_prequeue)
   
2.         net_timestamp_check(skb);
   

1.     if (vlan_tx_tag_present(skb) && vlan_hwaccel_do_receive(skb))
   
2.         return NET_RX_SUCCESS;
   
3. 
   
4.     /* if we've gotten here through NAPI, check netpoll */
   
5.     if (netpoll_receive_skb(skb))
   
6.         return NET_RX_DROP;
   

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.     else if (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.     }
    
22. 
    
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;
    
29. 
    
30.     pt_prev = NULL;
    
31. 
    
32.     rcu_read_lock();
    
33. 
    
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.     }
    
12. 
    
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.     }
    
22. 
    
23. out:
    
24.     rcu_read_unlock();
    
25.     return ret;
    
26. }