IP报文发送

原文出处：

 http://lvzg2005.blog.51cto.com/2015450/1240867

IP报文的发送的入口函数是ip_output，这个函数一般是挂载到dst->output上。 在发送IP报文时，都需要进行路由查找，得到dst，然后通过dst->output来发送数据包。对于IPv4来说，一般情况下，dst->output都是指向ip_output。

1. intip_output(struct sk_buff*skb)
   

2. {
   

3. /* 得到出口的dev */

4. struct net_device*dev=skb_dst(skb)->dev;
   

/* 增加统计信息 */

1. IP_UPD_PO_STATS(dev_net(dev),IPSTATS_MIB_OUT,skb->len);
   

1. skb->dev=dev;
   

2. skb->protocol=htons(ETH_P_IP);
   

/* 进入netfilter的POSTROUTING链 */

1. return NF_HOOK_COND(NFPROTO_IPV4,NF_INET_POST_ROUTING,skb,NULL,dev,
   

2. ip_finish_output,
   

3. !(IPCB(skb)->flags&IPSKB_REROUTED));
   

4. }

进入ip_finish_output

1. staticintip_finish_output(struct sk_buff*skb)
   

2. {
   

3. #ifdefined(CONFIG_NETFILTER)&&defined(CONFIG_XFRM)
   

4. /*Policy lookup after SNAT yielded a new policy*/
   

5. if(skb_dst(skb)->xfrm!=NULL){
   

6. IPCB(skb)->flags|=IPSKB_REROUTED;
   

7. return dst_output(skb);
   

8. }
   

9. #endif

10. /* 处理需要IP分片的情况 */

11. if(skb->len>ip_skb_dst_mtu(skb)&&!skb_is_gso(skb))
    

12. return ip_fragment(skb,ip_finish_output2);
    

13. /* 不需要IP分片， 我们就看这种一般情况 */

14. else
    

15. return ip_finish_output2(skb);
    

16. }

进入ip_finish_output2

1. static inlineintip_finish_output2(struct sk_buff*skb)
   

2. {
   

3. struct dst_entry*dst=skb_dst(skb);
   

4. struct rtable*rt=(struct rtable*)dst;
   

5. struct net_device*dev=dst->dev;
   

6. unsignedinthh_len=LL_RESERVED_SPACE(dev);
   

/* 根据路由的类型，增加统计信息 */

1. if(rt->rt_type==RTN_MULTICAST){
   

2. IP_UPD_PO_STATS(dev_net(dev),IPSTATS_MIB_OUTMCAST,skb->len);
   

3. }elseif(rt->rt_type==RTN_BROADCAST)
   

4. IP_UPD_PO_STATS(dev_net(dev),IPSTATS_MIB_OUTBCAST,skb->len);
   

5. 
   

6. /*Be paranoid,rather than too clever.*/
   

7. if(unlikely(skb_headroom(skb)<hh_len&&dev->header_ops)){
   

8. /* 

9. skb的首部空间不足，无法保存l2层的硬件地址。

10. 这时，需要重新分配一个更大bufer。

11. */

12. struct sk_buff*skb2;
    

13. 
    

14. skb2=skb_realloc_headroom(skb,LL_RESERVED_SPACE(dev));
    

15. if(skb2==NULL){
    

16. kfree_skb(skb);
    

17. return-ENOMEM;
    

18. }
    

19. if(skb->sk)
    

20. skb_set_owner_w(skb2,skb->sk);
    

21. kfree_skb(skb);
    

22. skb=skb2;
    

23. }
    

/* dst有L2层硬件地址的cache*/

1. if(dst->hh)
   

2. return neigh_hh_output(dst->hh,skb);
   

3. /* 

4. dst没有L2层地址的cache，需要调用neighbour子系统的output进行发送。

5. */

6. elseif(dst->neighbour)
   

7. return dst->neighbour->output(skb);
   

/* 

正常情况下，不会到达此处

*/

1. if(net_ratelimit())
   

2. printk(KERN_DEBUG"ip_finish_output2: No header cache and no neighbour!\n");
   

3. kfree_skb(skb);
   

4. return-EINVAL;
   

5. }

在IPv4中，neighbour subsystem使用的是arp，所以一般情况下，dst->neighbour->outpu指向的是arp_generic_ops->neigh_resolve_output（这是需要解析L2硬件地址的情况，其他情况本文暂不考虑）。

通常，neighbour subsystem使用的operation都是arp_generic_ops（在arp.c中定义，且还有其他的同类型变量，用于不同情况）。

下面看neigh_resolve_output

1. int neigh_resolve_output(struct sk_buff *skb)
   

2. {
   

3. struct dst_entry *dst = skb_dst(skb);
   

4. struct neighbour *neigh;
   

5. int rc = 0;
   

6. 
   

7. if(!dst ||!(neigh = dst->neighbour))
   

8. goto discard;

1. __skb_pull(skb, skb_network_offset(skb));
   

/* 判断是否发送neigh请求，对于IPv4来说就是arp request */

1. if(!neigh_event_send(neigh, skb)){
   

2. /* 无需发送neigh请求, 可以直接从dev中获得 */

3. interr;
   

4. struct net_device *dev = neigh->dev;
   

/* 从dev中获得L2硬件地址*/

1. if(dev->header_ops->cache &&!dst->hh){
   

2. write_lock_bh(&neigh->lock);
   

3. if(!dst->hh)
   

4. neigh_hh_init(neigh, dst, dst->ops->protocol);
   

5. err= dev_hard_header(skb, dev, ntohs(skb->protocol),
   

6. neigh->ha,NULL, skb->len);
   

7. write_unlock_bh(&neigh->lock);
   

8. }else{
   

9. read_lock_bh(&neigh->lock);
   

10. err= dev_hard_header(skb, dev, ntohs(skb->protocol),
    

11. neigh->ha,NULL, skb->len);
    

12. read_unlock_bh(&neigh->lock);
    

13. }
    

14. if(err>= 0)
    

15. rc = neigh->ops->queue_xmit(skb); //发送数据包
    

16. else
    

17. goto out_kfree_skb;
    

18. }
    

19. out:
    

20. return rc;
    

21. discard:
    

22. NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
    

23. dst, dst ? dst->neighbour :NULL);
    

24. out_kfree_skb:
    

25. rc =-EINVAL;
    

26. kfree_skb(skb);
    

27. goto out;
    

28. }

在neigh_event_send中，实际上并不立刻执行发送neigh 请求，而是将这个数据包加到一个队列中__skb_queue_tail(&neigh->arp_queue, skb);，即语句中的arp_queue。

然后通过neighbour subsystem的定时处理函数neigh_timer_handler来处理这个队列。

neigh_timer_handler主要是neighbour状态的处理和变迁，本文并将其列为重点，留作以后分析学习。对于IPv4来说，当没有对应的neighbour信息时，会先调用arp_solicit发送ARP请求，当收到ARP包时，由arp_process进行处理（可参见我前面的博文 TCP/IP学习(33)——ARP数据包的处理流程分析，  http://blog.chinaunix.net/space.php?uid=23629988&do=blog&id=335262 ）。当收到ARP reply时，会调用neigh_update，当neighbour的状态为valid且neighbour的arp_queue不为空时，会调用n1->output将之前的skb数据包发送。

1. while(neigh->nud_state & NUD_VALID &&
   

2. (skb = __skb_dequeue(&neigh->arp_queue))!=NULL){
   

3. struct neighbour *n1 = neigh;
   

4. write_unlock_bh(&neigh->lock);
   

5. /*On shaper/eql skb->dst->neighbour != neigh :(*/
   

6. if(skb_dst(skb)&& skb_dst(skb)->neighbour)
   

7. n1 = skb_dst(skb)->neighbour;
   

8. n1->output(skb);
   

9. write_lock_bh(&neigh->lock);
   

10. }

当解析neighbour信息成功时，这个n1->output是指向neigh_connected_output，并最终调用dev_queue_xmit->__dev_xmit_skb将数据包添加到dev的queue中，并发送数据包。

当发送完毕时，引发NET_TX_SOFTIRQ软中断，进行下半部处理，如释放已发送的数据包skb的内存等。

本文还遗留了不少细节有待完善，如neighbour subsystem和发送软中断等。

 

上次学习IP包的发送流程时，学习到了dev_queue_xmit这个函数。

1. intdev_queue_xmit(struct sk_buff*skb)
   

2. {
   

3. struct net_device*dev=skb->dev;
   

4. struct netdev_queue*txq;
   

5. struct Qdisc*q;
   

6. intrc=-ENOMEM;
   

7. 
   

8. /*Disable soft irqsforvarious locks below.Also
   

9. *stops preemptionforRCU.
   

10. */
    

11. rcu_read_lock_bh();
    

/* 得到发送队列 */

1. txq=dev_pick_tx(dev,skb);
   

2. q=rcu_dereference_bh(txq->qdisc);
   

3. 
   

4. #ifdef CONFIG_NET_CLS_ACT
   

5. skb->tc_verd=SET_TC_AT(skb->tc_verd,AT_EGRESS);
   

6. #endif
   

7. if(q->enqueue){
   

8. /* 一般的dev都应该进入这里 */

9. rc=__dev_xmit_skb(skb,q,dev,txq);
   

10. goto out;
    

11. }
    

...... ......

1. }

进入函数__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 toget qdisc main lock.
    

12. * This permits __QDISC_STATE_RUNNING owner toget 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. /* 该quque的状态为非活动的，drop该数据包 */

21. kfree_skb(skb);
    

22. rc = NET_XMIT_DROP;
    

23. }elseif((q->flags & TCQ_F_CAN_BYPASS)&&!qdisc_qlen(q)&&
    

24. qdisc_run_begin(q)){
    

/* 

这部分代码，从注释上看，似乎选中的queue是一个保留的工作queue。

想来也是非正常路径，暂时保留不看。

*/

1. /*
   

2. * This is a work-conserving queue; there are no old skbs
   

3. * waiting to be sent out;and the qdisc isnot running -
   

4. * xmit the skb directly.
   

5. */
   

6. if(!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
   

7. skb_dst_force(skb);
   

8. __qdisc_update_bstats(q, skb->len);
   

9. if(sch_direct_xmit(skb, q, dev, txq, root_lock)){
   

10. if(unlikely(contended)){
    

11. spin_unlock(&q->busylock);
    

12. contended =false;
    

13. }
    

14. __qdisc_run(q);
    

15. }else
    

16. qdisc_run_end(q);
    

17. 
    

18. rc = NET_XMIT_SUCCESS;
    

19. }else{
    

/* 正常路径 */

/* 确保dst被引用，防止被其他模块释放 */

1. skb_dst_force(skb);
   

2. /* 将数据包加入到queue中 */

3. rc = qdisc_enqueue_root(skb, q);
   

/* 如果queue不是运行状态，将其置为运行状态 */

1. if(qdisc_run_begin(q)){
   

2. if(unlikely(contended)){
   

3. spin_unlock(&q->busylock);
   

4. contended =false;
   

5. }
   

6. __qdisc_run(q);
   

7. }
   

8. }
   

9. spin_unlock(root_lock);
   

10. if(unlikely(contended))
    

11. spin_unlock(&q->busylock);
    

12. return rc;
    

13. }

将数据包加入队列的函数是通过q->enque的回调实现的,那么这个enque的回调钩子函数是何时注册上的呢？
请看dev_activate，用于激活网卡。

1. void dev_activate(struct net_device *dev)
   

2. {
   

3. int need_watchdog;
   

4. 
   

5. /* No queueing discipline is attached to device;
   

6. create default one i.e. pfifo_fast for devices,
   

7. which need queueing and noqueue_qdisc for
   

8. virtual interfaces
   

9. */
   

/*
当没有指定queueing discipline时，就使用默认的discipline
*/

1. if(dev->qdisc ==&noop_qdisc)
   

2. attach_default_qdiscs(dev);
   

3. 
   

4. ...... ...... 
   

5. }

这里不列出attach_default_qdiscs的代码了，一般情况下，网卡只有一个queue时，这个默认的discipline为

1. struct Qdisc_ops pfifo_fast_ops __read_mostly ={
   

2. .id ="pfifo_fast",
   

3. .priv_size = sizeof(struct pfifo_fast_priv),
   

4. .enqueue = pfifo_fast_enqueue,
   

5. .dequeue = pfifo_fast_dequeue,
   

6. .peek = pfifo_fast_peek,
   

7. .init = pfifo_fast_init,
   

8. .reset = pfifo_fast_reset,
   

9. .dump = pfifo_fast_dump,
   

10. .owner = THIS_MODULE,
    

11. };

那么对于我们来说，就确定了默认的要是一般情况下的enque函数为pfifo_fast_enqueue。

1. static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc* qdisc)
   

2. {
   

3. if(skb_queue_len(&qdisc->q)< qdisc_dev(qdisc)->tx_queue_len){
   

4. int band = prio2band[skb->priority & TC_PRIO_MAX];
   

5. struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
   

6. struct sk_buff_head *list = band2list(priv, band);
   

7. 
   

8. priv->bitmap |=(1 << band);
   

9. qdisc->q.qlen++;
   

10. return __qdisc_enqueue_tail(skb, qdisc, list);
    

11. }
    

12. 
    

13. return qdisc_drop(skb, qdisc);
    

14. }

上面就是 __dev_xmit_skb中调用的q->enque的代码，将数据包加入到了dev->_tx所对应的队列中。
然后我还需要回到__dev_xmit_skb中，在加数据包加入到队列中后。要保证qdisc为运行态。

1. rc = qdisc_enqueue_root(skb, q);
   

2. if(qdisc_run_begin(q)){
   

3. if(unlikely(contended)){
   

4. spin_unlock(&q->busylock);
   

5. contended =false;
   

6. }
   

7. __qdisc_run(q);
   

8. }

查看__qdisc_run的代码。

1. void __qdisc_run(struct Qdisc *q)
   

2. {
   

3. unsigned long start_time = jiffies;
   

/*
qdisc_restart中发送了数据包。
这里是循环发送，直至qdisc_restart返回0
或者其它进程请求CPU或发送已运行比较长的时间(1jiffie)则也跳出循环体。
*/

1. while(qdisc_restart(q)){
   

2. /*
   

3. * Postpone processing if
   

4. * 1. another process needs the CPU;
   

5. * 2. we've been doing it for too long.
   

6. */
   

7. if(need_resched()|| jiffies != start_time){

8. /*

9. 需要以后再执行发送动作(利用softirq)
   

10. */
    

11. __netif_schedule(q);
    

12. break;
    

13. }
    

14. }
    

15. 
    

16. qdisc_run_end(q);
    

17. }

进入qdisc_restart->sch_direct_xmit，该函数用于发送一个数据包

1. int sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
   

2. struct net_device *dev, struct netdev_queue *txq,
   

3. spinlock_t *root_lock)
   

4. {
   

5. int ret = NETDEV_TX_BUSY;
   

6. 
   

7. /*And release qdisc */
   

8. spin_unlock(root_lock);
   

9. 
   

10. HARD_TX_LOCK(dev, txq, smp_processor_id());

11. //设备没有被停止，且发送队列没有被冻结
    

12. if(!netif_tx_queue_stopped(txq)&&!netif_tx_queue_frozen(txq))
    

13. ret = dev_hard_start_xmit(skb, dev, txq); //发送数据包
    

14. 
    

15. HARD_TX_UNLOCK(dev, txq);
    

16. 
    

17. spin_lock(root_lock);
    

18. 
    

19. if(dev_xmit_complete(ret)){
    

20. /* Driver sent out skb successfully or skb was consumed */

21. //发送成功，返回qdisc新的队列产的
    

22. ret = qdisc_qlen(q);
    

23. }elseif(ret == NETDEV_TX_LOCKED){
    

24. /* Driver try lock failed */

25. //锁冲突
    

26. ret = handle_dev_cpu_collision(skb, txq, q);
    

27. }else{
    

28. /* Driver returned NETDEV_TX_BUSY - requeue skb */
    

29. if(unlikely (ret != NETDEV_TX_BUSY && net_ratelimit()))
    

30. printk(KERN_WARNING "BUG %s code %d qlen %d\n",
    

31. dev->name, ret, q->q.qlen);
    

//设备繁忙，重新调度发送（利用softirq）

1. ret = dev_requeue_skb(skb, q);
   

2. }
   

3. 
   

4. if(ret &&(netif_tx_queue_stopped(txq)||
   

5. netif_tx_queue_frozen(txq)))
   

6. ret = 0;
   

7. 
   

8. return ret;
   

9. }

到此，本文长度已经不短了，先就此结尾。IP包的发送流程比接收流程要复杂得多，估计还需一篇博文才能基本走完。

 

前文已经学习到了sch_direct_xmit函数，下面进入下一级函数。

1. int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
   

2. struct netdev_queue *txq)
   

3. {
   

4. const struct net_device_ops *ops = dev->netdev_ops;
   

5. int rc = NETDEV_TX_OK;
   

6. 
   

7. if(likely(!skb->next)){
   

/* skb->next为null，即只发送一个skb */

1. if(!list_empty(&ptype_all))
   

2. dev_queue_xmit_nit(skb, dev); //ptype_all上的协议处理，如tcpdump
   

3. 
   

4. /*
   

5. *If device doesnt need skb->dst, release it rightnowwhile
   

6. * its hot in this cpu cache
   

7. */
   

8. /* device 不需要dst */

9. if(dev->priv_flags & IFF_XMIT_DST_RELEASE)
   

10. skb_dst_drop(skb);
    

/* 使该skb不属于任何一个socket */

1. skb_orphan_try(skb);
   

2. 
   

3. if(netif_needs_gso(dev, skb)){
   

4. /* 需要scatter gather功能 */

/*

从注释上看，是进行perform protocol segmentation on skb。

但是实际工作，目前我不清楚

*/

1. if(unlikely(dev_gso_segment(skb)))
   

2. goto out_kfree_skb;
   

3. if(skb->next)
   

4. goto gso;
   

5. }else{
   

6. //不需要scatter gather

/*

如需要连续内存，则将skb内存线性化，即连续内存 

*/

1. if(skb_needs_linearize(skb, dev)&&
   

2. __skb_linearize(skb))
   

3. goto out_kfree_skb;
   

4. 
   

5. /*If packet isnot checksummed and device does not
   

6. * support checksumming for this protocol, complete
   

7. * checksumming here.
   

8. */
   

9. if(skb->ip_summed == CHECKSUM_PARTIAL){
   

10. /* 计算checksum */

11. skb_set_transport_header(skb, skb->csum_start -
    

12. skb_headroom(skb));
    

13. if(!dev_can_checksum(dev, skb)&&
    

14. skb_checksum_help(skb))
    

15. goto out_kfree_skb;
    

16. }
    

17. }
    

/* 发送skb数据 */

1. rc = ops->ndo_start_xmit(skb, dev);
   

2. if(rc == NETDEV_TX_OK)
   

3. txq_trans_update(txq);
   

4. return rc;
   

5. }
   

6. 
   

7. gso:
   

8. /* 循环发送数据包 */

9. do{
   

10. struct sk_buff *nskb = skb->next;
    

11. 
    

12. skb->next= nskb->next;
    

13. nskb->next=NULL;
    

14. 
    

15. /*
    

16. *If device doesnt need nskb->dst, release it rightnowwhile
    

17. * its hot in this cpu cache
    

18. */
    

19. if(dev->priv_flags & IFF_XMIT_DST_RELEASE)
    

20. skb_dst_drop(nskb);
    

21. 
    

22. rc = ops->ndo_start_xmit(nskb, dev);
    

23. if(unlikely(rc != NETDEV_TX_OK)){
    

24. if(rc &~NETDEV_TX_MASK)
    

25. goto out_kfree_gso_skb;
    

26. nskb->next= skb->next;
    

27. skb->next= nskb;
    

28. return rc;
    

29. }
    

30. txq_trans_update(txq);
    

31. if(unlikely(netif_tx_queue_stopped(txq)&& skb->next))
    

32. return NETDEV_TX_BUSY;
    

33. }while(skb->next);
    

34. 
    

35. out_kfree_gso_skb:
    

36. if(likely(skb->next==NULL))
    

37. skb->destructor = DEV_GSO_CB(skb)->destructor;
    

38. out_kfree_skb:
    

39. kfree_skb(skb);
    

40. return rc;
    

41. }

继续下一个函数，ops->ndo_start_xmit。又是一个回调函数，这个回调函数由驱动所决定。以e1000_main.c为例，

1. static const struct net_device_ops e1000_netdev_ops ={
   

2. .ndo_open = e1000_open,
   

3. .ndo_stop = e1000_close,
   

4. .ndo_start_xmit = e1000_xmit_frame,
   

5. .ndo_get_stats = e1000_get_stats,
   

6. .ndo_set_rx_mode = e1000_set_rx_mode,
   

7. .ndo_set_mac_address = e1000_set_mac,
   

8. .ndo_tx_timeout = e1000_tx_timeout,
   

9. .ndo_change_mtu = e1000_change_mtu,
   

10. .ndo_do_ioctl = e1000_ioctl,
    

11. .ndo_validate_addr = eth_validate_addr,
    

12. 
    

13. .ndo_vlan_rx_register = e1000_vlan_rx_register,
    

14. .ndo_vlan_rx_add_vid = e1000_vlan_rx_add_vid,
    

15. .ndo_vlan_rx_kill_vid = e1000_vlan_rx_kill_vid,
    

16. #ifdef CONFIG_NET_POLL_CONTROLLER
    

17. .ndo_poll_controller = e1000_netpoll,
    

18. #endif
    

19. };

从这里可以看出，对于e1000_main来说，该回调函数为e1000_xmit_frame。这个涉及到驱动层，一般都与硬件相关，在此就不继续探讨了。

那么现在，一个基本的IP包发送流程，基本上浏览完毕。小小的总结一下，当linux发送IP数据包时，数据包有可能是立刻发送出去，也有可能由下一次的软中断发送。