Linux内核--网络栈实现分析（十）--网络层之IP协议（下）

2023-01-07 15:35:51

本文分析基于Linux Kernel 1.2.13

原创作品，转载请标明http://blog.csdn.net/yming0221/article/details/7552455

更多请查看专栏，地址http://blog.csdn.net/column/details/linux-kernel-net.html

作者：闫明

注：标题中的”（上）“，”（下）“表示分析过程基于数据包的传递方向：”（上）“表示分析是从底层向上分析、”（下）“表示分析是从上向下分析。

上篇博文分析传输层最终会调用函数ip_queue_xmit()函数，将发送数据的任务交给网络层，下面就分析了下该函数：

该函数的主要函数调用关系图如下：

Linux内核--网络栈实现分析（十）--网络层之IP协议（下）

  1. /*
  2. * Queues a packet to be sent, and starts the transmitter
  3. * if necessary.  if free = 1 then we free the block after
  4. * transmit, otherwise we don't. If free==2 we not only
  5. * free the block but also don't assign a new ip seq number.
  6. * This routine also needs to put in the total length,
  7. * and compute the checksum
  8. */
  9. void ip_queue_xmit(struct sock *sk, //发送数据的队列所对应的sock结构
  10. struct device *dev,//发送该数据包的网卡设备
  11. struct sk_buff *skb,//封装好的sk_buff结构，要发送的数据在该结构中
  12. int free)//主要配合TCP协议使用，用于数据包的重发，UDP等协议调用是free=1
  13. {
  14. struct iphdr *iph;//IP数据报首部指针
  15. unsigned char *ptr;
  16. /* Sanity check */
  17. if (dev == NULL)
  18. {
  19. printk("IP: ip_queue_xmit dev = NULL\n");
  20. return;
  21. }
  22. IS_SKB(skb);
  23. /*
  24. *  Do some book-keeping in the packet for later
  25. */
  26. skb->dev = dev;//进一步完整sk_buff的相应字段
  27. skb->when = jiffies;//用于TCP协议的超时重传
  28. /*
  29. *  Find the IP header and set the length. This is bad
  30. *  but once we get the skb data handling code in the
  31. *  hardware will push its header sensibly and we will
  32. *  set skb->ip_hdr to avoid this mess and the fixed
  33. *  header length problem
  34. */
  35. ptr = skb->data;//指针指向sk_buff中的数据部分
  36. ptr += dev->hard_header_len;//hard_header_len为硬件首部长度，在net_init.c的函数eth_setup()函数中设置的，dev->hard_header_len = ETH_HLEN; 以太网首部长度为14
  37. iph = (struct iphdr *)ptr;//prt已经指向IP数据包的首部
  38. skb->ip_hdr = iph;
  39. iph->tot_len = ntohs(skb->len-dev->hard_header_len);//计算IP数据报的总长度
  40. #ifdef CONFIG_IP_FIREWALL
  41. if(ip_fw_chk(iph, dev, ip_fw_blk_chain, ip_fw_blk_policy, 0) != 1)
  42. /* just don't send this packet */
  43. return;
  44. #endif
  45. /*
  46. *  No reassigning numbers to fragments...
  47. */
  48. if(free!=2)
  49. iph->id      = htons(ip_id_count++);
  50. else
  51. free=1;
  52. /* All buffers without an owner socket get freed */
  53. if (sk == NULL)
  54. free = 1;
  55. skb->free = free;//设置skb的free值，free=1，发送后立即释放；free=2，不但释放缓存，而且不分配新的序列号
  56. /*
  57. *  Do we need to fragment. Again this is inefficient.
  58. *  We need to somehow lock the original buffer and use
  59. *  bits of it.
  60. */
  61. //数据帧中的数据部分必须小于等于MTU
  62. if(skb->len > dev->mtu + dev->hard_header_len)//发送的数据长度大于数据帧的数据部分和帧首部之和，则需要分片
  63. {
  64. ip_fragment(sk,skb,dev,0);//对数据报分片后继续调用ip _queue_xmit()函数发送数据
  65. IS_SKB(skb);
  66. kfree_skb(skb,FREE_WRITE);
  67. return;
  68. }
  69. /*
  70. *  Add an IP checksum
  71. */
  72. ip_send_check(iph);//IP数据报首部检查
  73. /*
  74. *  Print the frame when debugging
  75. */
  76. /*
  77. *  More debugging. You cannot queue a packet already on a list
  78. *  Spot this and moan loudly.
  79. */
  80. if (skb->next != NULL)//说明该数据包仍然存在于某个缓存队列
  81. {
  82. printk("ip_queue_xmit: next != NULL\n");
  83. skb_unlink(skb);//将其从缓存链表中删除，否则可能导致内核错误
  84. }
  85. /*
  86. *  If a sender wishes the packet to remain unfreed
  87. *  we add it to his send queue. This arguably belongs
  88. *  in the TCP level since nobody else uses it. BUT
  89. *  remember IPng might change all the rules.
  90. */
  91. if (!free)//free=0
  92. {
  93. unsigned long flags;
  94. /* The socket now has more outstanding blocks */
  95. sk->packets_out++;
  96. /* Protect the list for a moment */
  97. save_flags(flags);
  98. cli();
  99. if (skb->link3 != NULL)//link3指向数据报道呃重发队列
  100. {
  101. printk("ip.c: link3 != NULL\n");
  102. skb->link3 = NULL;
  103. }
  104. //sk中send_tail和send_head是用户缓存的单向链表表尾和表头
  105. if (sk->send_head == NULL)
  106. {
  107. sk->send_tail = skb;
  108. sk->send_head = skb;
  109. }
  110. else
  111. {
  112. sk->send_tail->link3 = skb;//link3指针用于数据包的连接
  113. sk->send_tail = skb;
  114. }
  115. /* skb->link3 is NULL */
  116. /* Interrupt restore */
  117. restore_flags(flags);
  118. }
  119. else
  120. /* Remember who owns the buffer */
  121. skb->sk = sk;
  122. /*
  123. *  If the indicated interface is up and running, send the packet.
  124. */
  125. ip_statistics.IpOutRequests++;
  126. #ifdef CONFIG_IP_ACCT
  127. ip_acct_cnt(iph,dev, ip_acct_chain);
  128. #endif
  129. #ifdef CONFIG_IP_MULTICAST  //这部分是IP数据报的多播处理
  130. /*
  131. *  Multicasts are looped back for other local users
  132. */
  133. .......................................
  134. #endif
  135. if((dev->flags&IFF_BROADCAST) && iph->daddr==dev->pa_brdaddr && !(dev->flags&IFF_LOOPBACK))//广播数据包的处理
  136. ip_loopback(dev,skb);
  137. if (dev->flags & IFF_UP)//设备状态正常
  138. {
  139. /*
  140. *  If we have an owner use its priority setting,
  141. *  otherwise use NORMAL
  142. */
  143. //调用设备接口层函数发送数据: dev_queue_xmit()函数
  144. if (sk != NULL)
  145. {
  146. dev_queue_xmit(skb, dev, sk->priority);
  147. }
  148. else
  149. {
  150. dev_queue_xmit(skb, dev, SOPRI_NORMAL);
  151. }
  152. }
  153. else//设备状态不正常
  154. {
  155. ip_statistics.IpOutDiscards++;
  156. if (free)
  157. kfree_skb(skb, FREE_WRITE);
  158. }
  159. }

这个函数中对长度过长的数据包进行了分片，ip_fragment()函数，该函数没有详细分析。

  1. void ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
  2. {
  3. struct iphdr *iph;
  4. unsigned char *raw;
  5. unsigned char *ptr;
  6. struct sk_buff *skb2;
  7. int left, mtu, hlen, len;
  8. int offset;
  9. unsigned long flags;
  10. /*
  11. *  Point into the IP datagram header.
  12. */
  13. raw = skb->data;
  14. iph = (struct iphdr *) (raw + dev->hard_header_len);
  15. skb->ip_hdr = iph;
  16. /*
  17. *  Setup starting values.
  18. */
  19. hlen = (iph->ihl * sizeof(unsigned long));
  20. left = ntohs(iph->tot_len) - hlen;   /* Space per frame */
  21. hlen += dev->hard_header_len;        /* Total header size */
  22. mtu = (dev->mtu - hlen);     /* Size of data space */
  23. ptr = (raw + hlen);         /* Where to start from */
  24. /*
  25. *  Check for any "DF" flag. [DF means do not fragment]
  26. */
  27. if (ntohs(iph->frag_off) & IP_DF)
  28. {
  29. /*
  30. *  Reply giving the MTU of the failed hop.
  31. */
  32. ip_statistics.IpFragFails++;
  33. icmp_send(skb,ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, dev->mtu, dev);
  34. return;
  35. }
  36. /*
  37. *  The protocol doesn't seem to say what to do in the case that the
  38. *  frame + options doesn't fit the mtu. As it used to fall down dead
  39. *  in this case we were fortunate it didn't happen
  40. */
  41. if(mtu<8)
  42. {
  43. /* It's wrong but it's better than nothing */
  44. icmp_send(skb,ICMP_DEST_UNREACH,ICMP_FRAG_NEEDED,dev->mtu, dev);
  45. ip_statistics.IpFragFails++;
  46. return;
  47. }
  48. /*
  49. *  Fragment the datagram.
  50. */
  51. /*
  52. *  The initial offset is 0 for a complete frame. When
  53. *  fragmenting fragments it's wherever this one starts.
  54. */
  55. if (is_frag & 2)
  56. offset = (ntohs(iph->frag_off) & 0x1fff) << 3;
  57. else
  58. offset = 0;
  59. /*
  60. *  Keep copying data until we run out.
  61. */
  62. while(left > 0)
  63. {
  64. len = left;
  65. /* IF: it doesn't fit, use 'mtu' - the data space left */
  66. if (len > mtu)
  67. len = mtu;
  68. /* IF: we are not sending upto and including the packet end
  69. then align the next start on an eight byte boundary */
  70. if (len < left)
  71. {
  72. len/=8;
  73. len*=8;
  74. }
  75. /*
  76. *  Allocate buffer.
  77. */
  78. if ((skb2 = alloc_skb(len + hlen,GFP_ATOMIC)) == NULL)
  79. {
  80. printk("IP: frag: no memory for new fragment!\n");
  81. ip_statistics.IpFragFails++;
  82. return;
  83. }
  84. /*
  85. *  Set up data on packet
  86. */
  87. skb2->arp = skb->arp;
  88. if(skb->free==0)
  89. printk("IP fragmenter: BUG free!=1 in fragmenter\n");
  90. skb2->free = 1;
  91. skb2->len = len + hlen;
  92. skb2->h.raw=(char *) skb2->data;
  93. /*
  94. *  Charge the memory for the fragment to any owner
  95. *  it might possess
  96. */
  97. save_flags(flags);
  98. if (sk)
  99. {
  100. cli();
  101. sk->wmem_alloc += skb2->mem_len;
  102. skb2->sk=sk;
  103. }
  104. restore_flags(flags);
  105. skb2->raddr = skb->raddr; /* For rebuild_header - must be here */
  106. /*
  107. *  Copy the packet header into the new buffer.
  108. */
  109. memcpy(skb2->h.raw, raw, hlen);
  110. /*
  111. *  Copy a block of the IP datagram.
  112. */
  113. memcpy(skb2->h.raw + hlen, ptr, len);
  114. left -= len;
  115. skb2->h.raw+=dev->hard_header_len;
  116. /*
  117. *  Fill in the new header fields.
  118. */
  119. iph = (struct iphdr *)(skb2->h.raw/*+dev->hard_header_len*/);
  120. iph->frag_off = htons((offset >> 3));
  121. /*
  122. *  Added AC : If we are fragmenting a fragment thats not the
  123. *         last fragment then keep MF on each bit
  124. */
  125. if (left > 0 || (is_frag & 1))
  126. iph->frag_off |= htons(IP_MF);
  127. ptr += len;
  128. offset += len;
  129. /*
  130. *  Put this fragment into the sending queue.
  131. */
  132. ip_statistics.IpFragCreates++;
  133. ip_queue_xmit(sk, dev, skb2, 2);//还是调用ip_queue_xmit()函数来发送分片后的数据
  134. }
  135. ip_statistics.IpFragOKs++;
  136. }

网络层的发送函数调用了设备接口层，相当于网络模型的链路层的发送函数dev_queue_xmit()

该函数的调用关系如下：

Linux内核--网络栈实现分析（十）--网络层之IP协议（下）

  1. /*
  2. *  Send (or queue for sending) a packet.
  3. *
  4. *  IMPORTANT: When this is called to resend frames. The caller MUST
  5. *  already have locked the sk_buff. Apart from that we do the
  6. *  rest of the magic.
  7. */
  8. void dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
  9. {
  10. unsigned long flags;
  11. int nitcount;
  12. struct packet_type *ptype;
  13. int where = 0;      /* used to say if the packet should go  */
  14. /* at the front or the back of the  */
  15. /* queue - front is a retransmit try    */
  16. /* where=0 表示是刚从上层传递的新数据包；where=1 表示从硬件队列中取出的数据包*/
  17. if (dev == NULL)
  18. {
  19. printk("dev.c: dev_queue_xmit: dev = NULL\n");
  20. return;
  21. }
  22. if(pri>=0 && !skb_device_locked(skb))//锁定该skb再进行操作，避免造成内核的不一致情况
  23. skb_device_lock(skb);   /* Shove a lock on the frame */
  24. #ifdef CONFIG_SLAVE_BALANCING
  25. save_flags(flags);
  26. cli();
  27. if(dev->slave!=NULL && dev->slave->pkt_queue < dev->pkt_queue &&
  28. (dev->slave->flags & IFF_UP))
  29. dev=dev->slave;
  30. restore_flags(flags);
  31. #endif
  32. #ifdef CONFIG_SKB_CHECK
  33. IS_SKB(skb);
  34. #endif
  35. skb->dev = dev;
  36. /*
  37. *  This just eliminates some race conditions, but not all...
  38. */
  39. if (skb->next != NULL) //这种条件似乎永远不能成立，因为发送数据包前，数据包已经从缓存队列摘下
  40. {//以防内核代码有BUG
  41. /*
  42. *  Make sure we haven't missed an interrupt.
  43. */
  44. printk("dev_queue_xmit: worked around a missed interrupt\n");
  45. start_bh_atomic();
  46. dev->hard_start_xmit(NULL, dev);
  47. end_bh_atomic();
  48. return;
  49. }
  50. /*
  51. *  Negative priority is used to flag a frame that is being pulled from the
  52. *  queue front as a retransmit attempt. It therefore goes back on the queue
  53. *  start on a failure.
  54. */
  55. if (pri < 0) //优先级小于0表示是从硬件队列中取出的数据包
  56. {
  57. pri = -pri-1;
  58. where = 1;
  59. }
  60. if (pri >= DEV_NUMBUFFS)
  61. {
  62. printk("bad priority in dev_queue_xmit.\n");
  63. pri = 1;
  64. }
  65. /*
  66. *  If the address has not been resolved. Call the device header rebuilder.
  67. *  This can cover all protocols and technically not just ARP either.
  68. */
  69. if (!skb->arp && dev->rebuild_header(skb->data, dev, skb->raddr, skb)) {//用于ARP协议，并重建MAC帧首部
  70. return;
  71. }
  72. save_flags(flags);
  73. cli();
  74. if (!where) {//表示是新数据包，需要将其加入设备队列中
  75. #ifdef CONFIG_SLAVE_BALANCING
  76. skb->in_dev_queue=1;//该数据包在设备队列
  77. #endif
  78. skb_queue_tail(dev->buffs + pri,skb);//将发送数据包加入硬件队列
  79. skb_device_unlock(skb);     /* Buffer is on the device queue and can be freed safely */
  80. skb = skb_dequeue(dev->buffs + pri);//从硬件队列中取出一个数据包
  81. skb_device_lock(skb);       /* New buffer needs locking down */
  82. #ifdef CONFIG_SLAVE_BALANCING
  83. skb->in_dev_queue=0;
  84. #endif
  85. }
  86. restore_flags(flags);
  87. /* copy outgoing packets to any sniffer packet handlers */
  88. if(!where)//对于新的数据包，则遍历网络层协议队列，内核支持混杂模式
  89. {
  90. for (nitcount= dev_nit, ptype = ptype_base; nitcount > 0 && ptype != NULL; ptype = ptype->next)
  91. {
  92. /* Never send packets back to the socket
  93. * they originated from - MvS (miquels@drinkel.ow.org)
  94. */
  95. if (ptype->type == htons(ETH_P_ALL) &&
  96. (ptype->dev == dev || !ptype->dev) &&
  97. ((struct sock *)ptype->data != skb->sk))
  98. {
  99. struct sk_buff *skb2;
  100. if ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL)
  101. break;
  102. /*
  103. *  The protocol knows this has (for other paths) been taken off
  104. *  and adds it back.
  105. */
  106. skb2->len-=skb->dev->hard_header_len;
  107. ptype->func(skb2, skb->dev, ptype);//IP层函数对应func为ip_rcv()，将发送的数据回送一份给对应的网络层协议
  108. nitcount--;//用于及时退出循环
  109. }
  110. }
  111. }
  112. start_bh_atomic();//开始原子操作
  113. if (dev->hard_start_xmit(skb, dev) == 0) {//调用硬件的发送函数发送数据
  114. end_bh_atomic();//结束原子操作
  115. /*
  116. *  Packet is now solely the responsibility of the driver
  117. */
  118. return;//到这里说明数据包成功发送
  119. }
  120. //数据包没有成功发送，进行处理，将数据包从新加入硬件队列
  121. end_bh_atomic();
  122. /*
  123. *  Transmission failed, put skb back into a list. Once on the list it's safe and
  124. *  no longer device locked (it can be freed safely from the device queue)
  125. */
  126. cli();
  127. #ifdef CONFIG_SLAVE_BALANCING
  128. skb->in_dev_queue=1;
  129. dev->pkt_queue++;
  130. #endif
  131. skb_device_unlock(skb);//对SKB解锁
  132. skb_queue_head(dev->buffs + pri,skb);//这次采用头插法插入硬件发送队列
  133. restore_flags(flags);
  134. }

具体的硬件发送函数dev->hard_start_xmit的实现将做下篇博文中分析。

上一篇：git中添加多个SSH公钥，以及不同系统之间的差别


下一篇：MySQL流程函数