dev_queue_xmi函数详解

http://blog.chinaunix.net/uid-20788636-id-3181312.html

前面在分析IPv6的数据流程时，当所有的信息都准备好了之后，例如，出口设备，下一跳的地址，以及链路层地址。就会调用dev.c文件中的dev_queue_xmin函数，该函数是设备驱动程序执行传输的接口。也就是所有的数据包在填充完成后，最终发送数据时，都会调用该函数。

     Dev_queue_xmit函数只接收一个skb_buff结构作为输入的值。此数据结构包含了此函数所需要的一切信息。Skb->dev是出口设备，skb->data为有效的载荷的开头，其长度为skb->len.下面是2.6.37版本内核中的dev_queue_xmit函数，该版本的内核与之前的版本有了不少的区别。

点击(此处)折叠或打开

1. int dev_queue_xmit(struct sk_buff *skb)
   
2. {
   
3.     struct net_device *dev = skb->dev;
   
4.     struct netdev_queue *txq;
   
5.     struct Qdisc *q;
   
6.     int rc = -ENOMEM;
   
7. 
   
8.     /* Disable soft irqs for various locks below. Also
   
9.      * stops preemption for RCU.
   
10.      */
    
11. //关闭软中断 - __rcu_read_lock_bh()--->local_bh_disable();
    
12.     rcu_read_lock_bh();
    
13. // 选择一个发送队列，如果设备提供了select_queue回调函数就使用它，否则由内核选择一个队列,这里只是Linux内核多队列的实现，但是要真正的使用都队列，需要网卡支持多队列才可以，一般的网卡都只有一个队列。在调用alloc_etherdev分配net_device是，设置队列的个数
    
14.     txq = dev_pick_tx(dev, skb);
    
15.  //从netdev_queue结构上获取设备的qdisc 
    
16.     q = rcu_dereference_bh(txq->qdisc);
    
17. 
    
18. #ifdef CONFIG_NET_CLS_ACT
    
19.     skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
    
20. #endif
    
21. //如果硬件设备有队列可以使用，该函数由dev_queue_xmit函数直接调用或由dev_queue_xmit通过qdisc_run函数调用
    
22. trace_net_dev_queue(skb);
    
23.     if (q->enqueue) {
    
24.         rc = __dev_xmit_skb(skb, q, dev, txq); //使用流控对象发送数据包(包含入队和出队)
    
25. //更详细的内容参考说明3
    
26.         goto out;
    
27.     }
    
28. 
    
29. //下面的处理是在没有发送队列的情况下
    
30.     /* The device has no queue. Common case for software devices:
    
31.      loopback, all the sorts of tunnels...
    
32. 
    
33.      Really, it is unlikely that netif_tx_lock protection is necessary
    
34.      here. (f.e. loopback and IP tunnels are clean ignoring statistics
    
35.      counters.)
    
36.      However, it is possible, that they rely on protection
    
37.      made by us here.
    
38. 
    
39.      Check this and shot the lock. It is not prone from deadlocks.
    
40.      Either shot noqueue qdisc, it is even simpler 8)
    
41.      */
    
42. //首先，确定设备是开启的，并且还要确定队列是运行的，启动和停止队列有驱动程序决定
    
43. //设备没有输出队列典型的是回环设备。这里需要做的就是直接调用dev_start_queue_xmit、、函数，经过驱动发送出去，如果发送失败，就直接丢弃，没有队列可以保存。
    
44.     if (dev->flags & IFF_UP) {
    
45.         int cpu = smp_processor_id(); /* ok because BHs are off */
    
46. 
    
47.         if (txq->xmit_lock_owner != cpu) {
    
48. 
    
49.             if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT)
    
50.                 goto recursion_alert;
    
51. 
    
52.             HARD_TX_LOCK(dev, txq, cpu);
    
53. 
    
54.             if (!netif_tx_queue_stopped(txq)) {
    
55.                 __this_cpu_inc(xmit_recursion);
    
56.                 rc = dev_hard_start_xmit(skb, dev, txq);//见说明4
    
57.                 __this_cpu_dec(xmit_recursion);
    
58.                 if (dev_xmit_complete(rc)) {
    
59.                     HARD_TX_UNLOCK(dev, txq);
    
60.                     goto out;
    
61.                 }
    
62.             }
    
63.             HARD_TX_UNLOCK(dev, txq);
    
64.             if (net_ratelimit())
    
65.                 printk(KERN_CRIT "Virtual device %s asks to "
    
66.                  "queue packet!\n", dev->name);
    
67.         } else {
    
68.             /* Recursion is It is possible,
    
69.              * unfortunately
    
70.              */
    
71. recursion_alert:
    
72.             if (net_ratelimit())
    
73.                 printk(KERN_CRIT "Dead loop on virtual device "
    
74.                  "%s, fix it urgently!\n", dev->name);
    
75.         }
    
76.     }
    
77. 
    
78.     rc = -ENETDOWN;
    
79.     rcu_read_unlock_bh();
    
80. 
    
81.     kfree_skb(skb);
    
82.     return rc;
    
83. out:
    
84.     rcu_read_unlock_bh();
    
85.     return rc;
    
86. }

1.       下面是dev_pick_tx函数。

点击(此处)折叠或打开

1. static struct netdev_queue *dev_pick_tx(struct net_device *dev,
   
2.                     struct sk_buff *skb)
   
3. {
   
4.     int queue_index;
   
5.     const struct net_device_ops *ops = dev->netdev_ops;
   
6. 
   
7.     if (ops->ndo_select_queue) {
   
8. //选择一个索引，这个策略可以设置，比如优先选择视频和音频队列，而哪个队列邦定哪个策略也是设定的。
   
9.         queue_index = ops->ndo_select_queue(dev, skb);
   
10.         queue_index = dev_cap_txqueue(dev, queue_index);
    
11.     } else {
    
12.         struct sock *sk = skb->sk;
    
13.         queue_index = sk_tx_queue_get(sk);
    
14.         if (queue_index < 0 || queue_index >= dev->real_num_tx_queues) {
    
15. 
    
16.             queue_index = 0;
    
17.             if (dev->real_num_tx_queues > 1)
    
18.                 queue_index = skb_tx_hash(dev, skb);
    
19. 
    
20.             if (sk) {
    
21.                 struct dst_entry *dst = rcu_dereference_check(sk->sk_dst_cache, 1);
    
22. 
    
23.                 if (dst && skb_dst(skb) == dst)
    
24.                     sk_tx_queue_set(sk, queue_index);
    
25.             }
    
26.         }
    
27.     }
    
28. 
    
29.     skb_set_queue_mapping(skb, queue_index);
    
30.     return netdev_get_tx_queue(dev, queue_index);
    
31. }

2.     下面是其中的一种网卡类型调用函数alloc_etherdev时，

dev = alloc_etherdev(sizeof(struct ether1_priv));

其实该函数是一个宏定义：其中第二参数表示的就是队列的数量，这里在Linux2.6.37内核中找到的一种硬件网卡的实现，可用的队列是1个。

#define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)

下面是alloc_etherdev_mq函数的定义实现。

点击(此处)折叠或打开

1. struct net_device *alloc_etherdev_mq(int sizeof_priv, unsigned int queue_count)
   
2. {
   
3.     return alloc_netdev_mq(sizeof_priv, "eth%d", ether_setup, queue_count);
   
4. }

3.  几乎所有的设备都会使用队列调度出口的流量，而内核可以使用对了规则的算法安排那个帧进行发送，使其以最优效率的次序进行传输。这里检查这个队列中是否有enqueue函数，如果有则说明设备会使用这个队列，否则需另外处理。关于enqueue函数的设置，我找到dev_open->dev_activate中调用了qdisc_create_dflt来设置，需要注意的是，这里并不是将传进来的skb直接发送，而是先入队，然后调度队列，具体发送哪个数据包由enqueue和dequeue函数决定，这体现了设备的排队规则    

Enqueue

 把一个元素添加的队列

Dequeue

从队列中提取一个元素

Requeue

把一个原先已经提取的元素放回到队列，可以由于传输失败。

if (q->enqueue)为真的话，表明这个设备有队列，可以进行相关的流控。调用__dev_xmit_skb函数进行处理。

点击(此处)折叠或打开

1. static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
   
2.                  struct net_device *dev,
   
3.                  struct netdev_queue *txq)
   
4. {
   
5.     spinlock_t *root_lock = qdisc_lock(q);
   
6.     bool contended = qdisc_is_running(q);
   
7.     int rc;
   
8. 
   
9.     /*
   
10.      * Heuristic to force contended enqueues to serialize on a
    
11.      * separate lock before trying to get qdisc main lock.
    
12.      * This permits __QDISC_STATE_RUNNING owner to get the lock more often
    
13.      * and dequeue packets faster.
    
14.      */
    
15.     if (unlikely(contended))
    
16.         spin_lock(&q->busylock);
    
17. 
    
18.     spin_lock(root_lock);
    
19.     if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
    
20.         kfree_skb(skb);
    
21.         rc = NET_XMIT_DROP;
    
22.     } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
    
23.          qdisc_run_begin(q)) {
    
24.         /*
    
25.          * This is a work-conserving queue; there are no old skbs
    
26.          * waiting to be sent out; and the qdisc is not running -
    
27.          * xmit the skb directly.
    
28.          */
    
29.         if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
    
30.             skb_dst_force(skb);
    
31.         __qdisc_update_bstats(q, skb->len);
    
32.         if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
    
33.             if (unlikely(contended)) {
    
34.                 spin_unlock(&q->busylock);
    
35.                 contended = false;
    
36.             }
    
37.             __qdisc_run(q);
    
38.         } else
    
39.             qdisc_run_end(q);
    
40. 
    
41.         rc = NET_XMIT_SUCCESS;
    
42.     } else {
    
43.         skb_dst_force(skb);
    
44.         rc = qdisc_enqueue_root(skb, q);
    
45.         if (qdisc_run_begin(q)) {
    
46.             if (unlikely(contended)) {
    
47.                 spin_unlock(&q->busylock);
    
48.                 contended = false;
    
49.             }
    
50.             __qdisc_run(q);
    
51.         }
    
52.     }
    
53.     spin_unlock(root_lock);
    
54.     if (unlikely(contended))
    
55.         spin_unlock(&q->busylock);
    
56.     return rc;
    
57. }

_dev_xmit_skb函数主要做两件事情：

（1）      如果流控对象为空的，试图直接发送数据包。

（2）如果流控对象不空，将数据包加入流控对象，并运行流控对象。

当设备进入调度队列准备传输时，qdisc_run函数就会选出下一个要传输的帧，而该函数会间接的调用相关联的队列规则dequeue函数，从对了中取出数据进行传输。

有两个时机将会调用qdisc_run()：

1．__dev_xmit_skb()

2. 软中断服务线程NET_TX_SOFTIRQ

其实，真正的工作有qdisc_restart函数实现。

点击(此处)折叠或打开

1. void __qdisc_run(struct Qdisc *q)
   
2. {
   
3.     unsigned long start_time = jiffies;
   
4. 
   
5.     while (qdisc_restart(q)) { //返回值大于0，说明流控对象非空。
   
6.         /*
   
7.          * Postpone processing if
   
8.          * 1. another process needs the CPU;
   
9.          * 2. we've been doing it for too long.
   
10.          */
    
11.         if (need_resched() || jiffies != start_time) { //已经不允许继续运行本流控对象。
    
12.             __netif_schedule(q); //将本队列加入软中断的output_queue链表中。
    
13.             break;
    
14.         }
    
15.     }
    
16. 
    
17.     qdisc_run_end(q);
    
18. }

如果发现本队列运行的时间太长了，将会停止队列的运行，并将队列加入output_queue链表头。

点击(此处)折叠或打开

1. static inline int qdisc_restart(struct Qdisc *q)
   
2. {
   
3.     struct netdev_queue *txq;
   
4.     struct net_device *dev;
   
5.     spinlock_t *root_lock;
   
6.     struct sk_buff *skb;
   
7. 
   
8.     /* Dequeue packet */
   
9.     skb = dequeue_skb(q);//一开始就调用dequeue函数。
   
10.     if (unlikely(!skb))
    
11.         return 0;
    
12.     WARN_ON_ONCE(skb_dst_is_noref(skb));
    
13.     root_lock = qdisc_lock(q);
    
14.     dev = qdisc_dev(q);
    
15.     txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
    
16. 
    
17.     return sch_direct_xmit(skb, q, dev, txq, root_lock);//用于发送数据包
    
18. }
    
19. * Returns to the caller:
    
20.  *                0 - queue is empty or throttled.
    
21.  *                >0 - queue is not empty.
    
22.  */
    
23. int sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
    
24.          struct net_device *dev, struct netdev_queue *txq,
    
25.          spinlock_t *root_lock)
    
26. {
    
27.     int ret = NETDEV_TX_BUSY;
    
28. 
    
29.     /* And release qdisc */
    
30.     spin_unlock(root_lock);
    
31. 
    
32.     HARD_TX_LOCK(dev, txq, smp_processor_id());
    
33.     if (!netif_tx_queue_stopped(txq) && !netif_tx_queue_frozen(txq)) //设备没有被停止，且发送队列没有被冻结
    
34.         ret = dev_hard_start_xmit(skb, dev, txq); //发送数据包
    
35. 
    
36.     HARD_TX_UNLOCK(dev, txq);
    
37. 
    
38.     spin_lock(root_lock);
    
39. 
    
40.     if (dev_xmit_complete(ret)) {
    
41.         /* Driver sent out skb successfully or skb was consumed */
    
42. //发送成功，返回新的队列的长度
    
43.         ret = qdisc_qlen(q);
    
44.     } else if (ret == NETDEV_TX_LOCKED) {
    
45.         /* Driver try lock failed */
    
46.         ret = handle_dev_cpu_collision(skb, txq, q);
    
47.     } else {
    
48.         /* Driver returned NETDEV_TX_BUSY - requeue skb */
    
49.         if (unlikely (ret != NETDEV_TX_BUSY && net_ratelimit()))
    
50.             printk(KERN_WARNING "BUG %s code %d qlen %d\n",
    
51.              dev->name, ret, q->q.qlen);
    
52.          //设备繁忙，重新调度发送（利用softirq）
    
53.         ret = dev_requeue_skb(skb, q);
    
54.     }
    
55. 
    
56.     if (ret && (netif_tx_queue_stopped(txq) ||
    
57.          netif_tx_queue_frozen(txq)))
    
58.         ret = 0;
    
59. 
    
60.     return ret;
    
61. }

4.       我们看一下下面的发送函数。

 从此函数可以看出，当驱动使用发送队列的时候会循环从队列中取出包发送
   而不使用队列的时候只发送一次，如果没发送成功就直接丢弃

点击(此处)折叠或打开

1. struct netdev_queue *txq)
   
2. {
   
3.     const struct net_device_ops *ops = dev->netdev_ops;//驱动程序的函数集
   
4.     int rc = NETDEV_TX_OK;
   
5. 
   
6.     if (likely(!skb->next)) {
   
7.         if (!list_empty(&ptype_all))
   
8.             dev_queue_xmit_nit(skb, dev);//如果dev_add_pack加入的是ETH_P_ALL，那么就会复制一份给你的回调函数。
   
9. 
   
10.         /*
    
11.          * If device doesnt need skb->dst, release it right now while
    
12.          * its hot in this cpu cache
    
13.          */
    
14.         if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
    
15.             skb_dst_drop(skb);
    
16. 
    
17.         skb_orphan_try(skb);
    
18. 
    
19.         if (vlan_tx_tag_present(skb) &&
    
20.          !(dev->features & NETIF_F_HW_VLAN_TX)) {
    
21.             skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
    
22.             if (unlikely(!skb))
    
23.                 goto out;
    
24. 
    
25.             skb->vlan_tci = 0;
    
26.         }
    
27. 
    
28.         if (netif_needs_gso(dev, skb)) {
    
29.             if (unlikely(dev_gso_segment(skb)))
    
30.                 goto out_kfree_skb;
    
31.             if (skb->next)
    
32.                 goto gso;
    
33.         } else {
    
34.             if (skb_needs_linearize(skb, dev) &&
    
35.              __skb_linearize(skb))
    
36.                 goto out_kfree_skb;
    
37. 
    
38.             /* If packet is not checksummed and device does not
    
39.              * support checksumming for this protocol, complete
    
40.              * checksumming here.
    
41.              */
    
42.             if (skb->ip_summed == CHECKSUM_PARTIAL) {
    
43.                 skb_set_transport_header(skb, skb->csum_start -
    
44.                      skb_headroom(skb));
    
45.                 if (!dev_can_checksum(dev, skb) &&
    
46.                  skb_checksum_help(skb))
    
47.                     goto out_kfree_skb;
    
48.             }
    
49.         }
    
50. 
    
51.         rc = ops->ndo_start_xmit(skb, dev);//调用网卡的驱动程序发送数据。不同的网络设备有不同的发送函数
    
52.         trace_net_dev_xmit(skb, rc);
    
53.         if (rc == NETDEV_TX_OK)
    
54.             txq_trans_update(txq);
    
55.         return rc;
    
56.     }
    
57. 
    
58. gso:
    
59.     do {
    
60.         struct sk_buff *nskb = skb->next;
    
61. 
    
62.         skb->next = nskb->next;
    
63.         nskb->next = NULL;
    
64. 
    
65.         /*
    
66.          * If device doesnt need nskb->dst, release it right now while
    
67.          * its hot in this cpu cache
    
68.          */
    
69.         if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
    
70.             skb_dst_drop(nskb);
    
71. 
    
72.         rc = ops->ndo_start_xmit(nskb, dev); //调用网卡的驱动程序发送数据。不同的网络设备有不同的发送函数
    
73.         trace_net_dev_xmit(nskb, rc);
    
74.         if (unlikely(rc != NETDEV_TX_OK)) {
    
75.             if (rc & ~NETDEV_TX_MASK)
    
76.                 goto out_kfree_gso_skb;
    
77.             nskb->next = skb->next;
    
78.             skb->next = nskb;
    
79.             return rc;
    
80.         }
    
81.         txq_trans_update(txq);
    
82.         if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
    
83.             return NETDEV_TX_BUSY;
    
84.     } while (skb->next);
    
85. 
    
86. out_kfree_gso_skb:
    
87.     if (likely(skb->next == NULL))
    
88.         skb->destructor = DEV_GSO_CB(skb)->destructor;
    
89. out_kfree_skb:
    
90.     kfree_skb(skb);
    
91. out:
    
92.     return rc;
    
93. }

5.       下面看一下dev_queue_xmit_nit函数。对于通过socket(AF_PACKET,SOCK_RAW,htons(ETH_P_ALL))创建的原始套接口，不但可以接受从外部输入的数据包，而且对于由于本地输出的数据包，如果满足条件，也可以能接受。

   该函数就是用来接收由于本地输出的数据包，在链路层的输出过程中，会调用此函数，将满足条件的数据包输入到RAW套接口，

点击(此处)折叠或打开

1. static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
   
2. {
   
3.     struct packet_type *ptype;
   
4. 
   
5. #ifdef CONFIG_NET_CLS_ACT
   
6.     if (!(skb->tstamp.tv64 && (G_TC_FROM(skb->tc_verd) & AT_INGRESS)))
   
7.         net_timestamp_set(skb);-----------------（1）
   
8. #else
   
9.     net_timestamp_set(skb);
   
10. #endif
    
11. 
    
12.     rcu_read_lock();
    
13.     list_for_each_entry_rcu(ptype, &ptype_all, list) {-----------------（2）
    
14.         /* Never send packets back to the socket
    
15.          * they originated from - MvS (miquels@drinkel.ow.org)
    
16.          */
    
17.         if ((ptype->dev == dev || !ptype->dev) &&
    
18.          (ptype->af_packet_priv == NULL ||
    
19.          (struct sock *)ptype->af_packet_priv != skb->sk)) {-----------------（3）
    
20.             struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); -----------------（4）
    
21.             if (!skb2)
    
22.                 break;
    
23. 
    
24.             /* skb->nh should be correctly
    
25.              set by sender, so that the second statement is
    
26.              just protection against buggy protocols.
    
27.              */
    
28.             skb_reset_mac_header(skb2);
    
29. 
    
30.             if (skb_network_header(skb2) < skb2->data ||
    
31.              skb2->network_header > skb2->tail) {
    
32.                 if (net_ratelimit())
    
33.                     printk(KERN_CRIT "protocol %04x is "
    
34.                      "buggy, dev %s\n",
    
35.                      ntohs(skb2->protocol),
    
36.                      dev->name);
    
37.                 skb_reset_network_header(skb2); -----------------（5）
    
38.             }
    
39. 
    
40.             skb2->transport_header = skb2->network_header;
    
41.             skb2->pkt_type = PACKET_OUTGOING;
    
42.             ptype->func(skb2, skb->dev, ptype, skb->dev); -----------------（6）
    
43.         }
    
44.     }
    
45.     rcu_read_unlock();
    
46. }

说明：

（1）       记录该数据包输入的时间戳

（2）       遍历ptype_all链表，查找所有符合输入条件的原始套接口，并循环将数据包输入到满足条件的套接口

（3）       数据包的输出设备与套接口的输入设备相符或者套接口不指定输入设备，并且该数据包不是有当前用于比较的套接口输出，此时该套接口满足条件，数据包可以输入

（4）       由于该数据包是额外输入到这个原始套接口的，因此需要克隆一个数据包

（5）       校验数据包是否有效

（6）       将数据包输入原始套接口

6.       对于lookback设备来说处理有些不同。它的hard_start_xmit函数是loopback_xmit

在net/lookback.c文件中，定义的struct net_device_ops loopback_ops结构体

点击(此处)折叠或打开

1. static const struct net_device_ops loopback_ops = {
   
2.     .ndo_init = loopback_dev_init,
   
3.     .ndo_start_xmit= loopback_xmit,
   
4.     .ndo_get_stats64 = loopback_get_stats64,
   
5. };

从这里可以看到起发送函数为loopback_xmit函数。

点击(此处)折叠或打开

1. static netdev_tx_t loopback_xmit(struct sk_buff *skb,
   
2.                  struct net_device *dev)
   
3. {
   
4.     struct pcpu_lstats *lb_stats;
   
5.     int len;
   
6. 
   
7.     skb_orphan(skb);
   
8. 
   
9.     skb->protocol = eth_type_trans(skb, dev);
   
10. 
    
11.     /* it's OK to use per_cpu_ptr() because BHs are off */
    
12.     lb_stats = this_cpu_ptr(dev->lstats);
    
13. 
    
14.     len = skb->len;
    
15.     if (likely(netif_rx(skb) == NET_RX_SUCCESS)) {//直接调用了netif_rx进行了接收处理
    
16.         u64_stats_update_begin(&lb_stats->syncp);
    
17.         lb_stats->bytes += len;
    
18.         lb_stats->packets++;
    
19.         u64_stats_update_end(&lb_stats->syncp);
    
20.     }
    
21. 
    
22.     return NETDEV_TX_OK;
    
23. }

7.    已经有了dev_queue_xmit函数，为什么还需要软中断来发送呢？

dev_queue_xmit是对skb做些最后的处理并且第一次尝试发送,软中断是将前者发送失败或者没发完的包发送出去。

主要参考文献：

Linux发送函数dev_queue_xmit分析  http://shaojiashuai123456.iteye.com/blog/842236 

TC流量控制实现分析（初步）  http://blog.csdn.net/wwwlkk/article/details/5929308

Linux内核源码剖析 TCP/IP实现