Chinaunix首页 | 论坛 | 博客

随风去的ChinaUnix博客

首页　| 　博文目录　| 　关于我

随风去

  • 博客访问： 86361
  • 博文数量： 15
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 210
  • 用 户 组： 普通用户
  • 注册时间： 2014-01-05 15:27
文章分类

全部博文（15）

文章存档

2014年（15）

我的朋友
最近访客
推荐博文
相关博文
网卡驱动的收发包流程

分类： LINUX

2014-03-16 12:24:43

分析网络协议栈的代码，如果不看驱动代码的话，总是感觉没有完全落到实处。
由于手头上只有rtl8169的网卡设备，为了方便调试和分析，因此选择该款设备对应的驱动进行分析：r8169.ko，内核代码还是基于3.1.3
对于协议栈而言：
1）发包的最后步骤为调用驱动注册的ndo_start_xmit钩子函数，具体如何实现由驱动完成
2）收包由中断触发，驱动负责skb的生成以及其他操作如校验等，然后传给协议栈
但是这些都只是模糊的概念，具体如何操作，如卸载功能、NAPI如何在驱动层次实现没有完全清晰的了解。
因此希望通过分析r8169的驱动代码，对更底层的逻辑有更好的掌握。
要分析驱动的代码，数据手册必不可少，特别是寄存器以及描述符的说明。

发包流程：

对于驱动而言，发包流程简单的可以总结为：根据skb赋值好发送描述符，然后告诉硬件进行发包
具体代码如下：

  1. static const struct net_device_ops rtl8169_netdev_ops = {
  2.     .ndo_open        = rtl8169_open,
  3.     .ndo_stop        = rtl8169_close,
  4.     .ndo_get_stats        = rtl8169_get_stats,
  5.     .ndo_start_xmit        = rtl8169_start_xmit,  //r8169对应的发包函数
  6.     .ndo_tx_timeout        = rtl8169_tx_timeout,
  7.     .ndo_validate_addr    = eth_validate_addr,
  8.     .ndo_change_mtu        = rtl8169_change_mtu,
  9.     .ndo_fix_features    = rtl8169_fix_features,
  10.     .ndo_set_features    = rtl8169_set_features,
  11.     .ndo_set_mac_address    = rtl_set_mac_address,
  12.     .ndo_do_ioctl        = rtl8169_ioctl,
  13.     .ndo_set_multicast_list    = rtl_set_rx_mode,
  14. #ifdef CONFIG_NET_POLL_CONTROLLER
  15.     .ndo_poll_controller    = rtl8169_netpoll,
  16. #endif

  18. }
要看懂发包函数的代码，需要先查看r8169的数据手册，对发送描述符以及一些寄存器有一定的了解：
由于r8169支持TSO卸载功能，因此其发送描述符分成两种格式：




ps：网上没有找到完全对应的数据手册，因此名字以及具体的格式可能有一定的差别，但是基本上影响不大

有了上面的说明，就可以看懂r8169的发包流程了
  1. static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
  2.                  struct net_device *dev)
  3. {
  4.     struct rtl8169_private *tp = netdev_priv(dev);
  5.     unsigned int entry = tp->cur_tx % NUM_TX_DESC;
  6.     struct TxDesc *txd = tp->TxDescArray + entry;
  7.     void __iomem *ioaddr = tp->mmio_addr;
  8.     struct device *d = &tp->pci_dev->dev;
  9.     dma_addr_t mapping;
  10.     u32 status, len;
  11.     u32 opts[2];
  12.     int frags;
  13.     //首先查看发送描述符是否足够，A skbuff with nr_frags needs nr_frags+1 entries in the tx queue
  14.     if (unlikely(TX_BUFFS_AVAIL(tp) < skb_shinfo(skb)->nr_frags)) {  //这个判断其实有点问题，应该再加1，最新的代码修复了这个问题
  15.         netif_err(tp, drv, dev, "BUG! Tx Ring full when queue awake!\n"); 
  16.         goto err_stop_0;
  17.     }
  18.     //从DescOwn的定义可以知道，如果为1表示该描述符为网卡所有，等待发送，即不是空闲的，驱动没法用
  19.     //基本操作：初始化为0，驱动填充完后为1，网卡发送完后触发中断，释放资源，又赋值为0
  20.     if (unlikely(le32_to_cpu(txd->opts1) & DescOwn)) //
  21.         goto err_stop_0;
  22.     //首先处理线形区的数据，分配一个发送描述符
  23.     len = skb_headlen(skb);
  24.     mapping = dma_map_single(d, skb->data, len, DMA_TO_DEVICE);  //进行DMA映射
  25.     if (unlikely(dma_mapping_error(d, mapping))) {
  26.         if (net_ratelimit())
  27.             netif_err(tp, drv, dev, "Failed to map TX DMA!\n");
  28.         goto err_dma_0;
  29.     }

  31.     tp->tx_skb[entry].len = len;
  32.     txd->addr = cpu_to_le64(mapping);

  34.     opts[1] = cpu_to_le32(rtl8169_tx_vlan_tag(tp, skb));
  35.     opts[0] = DescOwn;
  36.     //根据skb_shinfo(skb)->gso_size决定使用哪种发送描述符
  37.     rtl8169_tso_csum(tp, skb, opts);

  39.     frags = rtl8169_xmit_frags(tp, skb, opts); //对每一个frag分配一个发送描述符和它对应
  40.     if (frags < 0)
  41.         goto err_dma_1;
  42.     else if (frags) //skb有frag，即该skb对应>=2的发送描述符，即FirstFrag和LastFrag不是同一个
  43.         opts[0] |= FirstFrag;   
  44.     else { //skb没有frag，即该skb只对应一个发送描述符，FirstFrag和LastFrag是同一个
  45.         opts[0] |= FirstFrag | LastFrag;
  46.         tp->tx_skb[entry].skb = skb;
  47.     }

  49.     txd->opts2 = cpu_to_le32(opts[1]);

  51.     wmb();

  53.     /* Anti gcc 2.95.3 bugware (sic) */
  54.     status = opts[0] | len | (RingEnd * !((entry + 1) % NUM_TX_DESC));
  55.     txd->opts1 = cpu_to_le32(status);

  57.     tp->cur_tx += frags + 1;

  59.     wmb();

  61.     RTL_W8(TxPoll, NPQ); //置位TxPoll寄存器的NPQ位，告诉硬件可以发包了

  62.
  63.     //下面是流量控制，如果发送描述符不够的话暂时关闭该发送队列，等资源释放后再开启
  64.     if (TX_BUFFS_AVAIL(tp) < MAX_SKB_FRAGS) {
  65.         netif_stop_queue(dev);
  66.         smp_rmb();
  67.         if (TX_BUFFS_AVAIL(tp) >= MAX_SKB_FRAGS)
  68.             netif_wake_queue(dev);
  69.     }

  71.     return NETDEV_TX_OK;

  73. err_dma_1:
  74.     rtl8169_unmap_tx_skb(d, tp->tx_skb + entry, txd);
  75. err_dma_0:
  76.     dev_kfree_skb(skb);
  77.     dev->stats.tx_dropped++;
  78.     return NETDEV_TX_OK;

  80. err_stop_0:
  81.     netif_stop_queue(dev);
  82.     dev->stats.tx_dropped++;
  83.     return NETDEV_TX_BUSY;
  84. }
由于两种发送描述符的结构不一样，因此分别赋值，开启TSO的话，指定TD_LSO标记，让硬件进行分包和校验
不开启TSO的话，根据传输类型，指定校验标记，让硬件完成校验功能。
  1. static inline void rtl8169_tso_csum(struct rtl8169_private *tp,
  2.                  struct sk_buff *skb, u32 *opts)
  3. {
  4.     const struct rtl_tx_desc_info *info = tx_desc_info + tp->txd_version;
  5.     u32 mss = skb_shinfo(skb)->gso_size;
  6.     int offset = info->opts_offset;

  8.     if (mss) {
  9.         opts[0] |= TD_LSO;
  10.         opts[offset] |= min(mss, TD_MSS_MAX) << info->mss_shift;  //分片的大小
  11.     } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
  12.         const struct iphdr *ip = ip_hdr(skb);

  14.         if (ip->protocol == IPPROTO_TCP)
  15.             opts[offset] |= info->checksum.tcp;
  16.         else if (ip->protocol == IPPROTO_UDP)
  17.             opts[offset] |= info->checksum.udp;
  18.         else
  19.             WARN_ON_ONCE(1);
  20.     }
  21. }
从上面可以看到，驱动是如何实现卸载功能的（分片以及校验功能），和协议栈是如何交互的：
1）根据参数skb_shinfo(skb)->gso_size，决定使用的发送描述符的类型，反过来，上层协议栈肯定是感知到底层可以分片的情况下才会把大包传下来的。
2）上层没有校验的话，硬件进行校验，反过来上层协议栈肯定是感知到底层可以校验的情况下才不进行校验的

收包流程

和发包类似于同步的流程不一样，收包是异步的，中断触发，直观的感觉发包应该也有中断，即硬件发完一个包后触发一个中断，释放相应的资源，
但是目前很多驱动使用了变通的方法：在收包中断中处理相应的流程，r8169驱动就是这么做的。
目前主流网卡驱动都使用了NAPI的机制，即中断和轮询相结合的方法来提高性能。
在网卡open的时候申请中断号：

  1. retval = request_irq(dev->irq, rtl8169_interrupt,
  2.              (tp->features & RTL_FEATURE_MSI) ? 0 : IRQF_SHARED,
  3.              dev->name, dev)


在分析中断函数前，需要知道r8169对应的中断寄存器的说明：

  1.     SYSErr        = 0x8000,
  2.     PCSTimeout    = 0x4000,
  3.     SWInt        = 0x0100,
  4.     TxDescUnavail    = 0x0080,
  5.     RxFIFOOver    = 0x0040,
  6.     LinkChg        = 0x0020,
  7.     RxOverflow    = 0x0010,
  8.     TxErr        = 0x0008,
  9.     TxOK        = 0x0004,
  10.     RxErr        = 0x0002,
  11.     RxOK        = 0x0001,

  1. static irqreturn_t rtl8169_interrupt(int irq, void *dev_instance)
  2. {
  3.     struct net_device *dev = dev_instance;
  4.     struct rtl8169_private *tp = netdev_priv(dev);
  5.     void __iomem *ioaddr = tp->mmio_addr;
  6.     int handled = 0;
  7.     int status;

  9.     /* loop handling interrupts until we have no new ones or
  10.      * we hit a invalid/hotplug case.
  11.      */
  12.     status = RTL_R16(IntrStatus);
  13.     while (status && status != 0xffff) {  //status的某一位为1表示有相应的中断发生
  14.         handled = 1;

  16.         /* Handle all of the error cases first. These will reset
  17.          * the chip, so just exit the loop.
  18.          */
  19.         if (unlikely(!netif_running(dev))) {
  20.             rtl8169_hw_reset(tp);
  21.             break;
  22.         }

  24.         if (unlikely(status & SYSErr)) { //发送错误的一些处理流程
  25.             rtl8169_pcierr_interrupt(dev);
  26.             break;
  27.         }

  29.         if (status & LinkChg)
  30.             __rtl8169_check_link_status(dev, tp, ioaddr, true);

  32.         /* We need to see the lastest version of tp->intr_mask to
  33.          * avoid ignoring an MSI interrupt and having to wait for
  34.          * another event which may never come.
  35.          */
  36.         smp_rmb();
  37.         if (status & tp->intr_mask & tp->napi_event) { 
  38.             RTL_W16(IntrMask, tp->intr_event & ~tp->napi_event); //IntrMask的某一位置1表示使能该中断，处理过程中先关闭同样的中断
  39.             tp->intr_mask = ~tp->napi_event;  //处理完后再全部打开，具体看rtl8169_poll函数

  41.             if (likely(napi_schedule_prep(&tp->napi))) //和协议栈的NAPI机制交互，触发收包软中断，调用r8169的poll函数：rtl8169_poll
  42.                 __napi_schedule(&tp->napi);   
  43.             else
  44.                 netif_info(tp, intr, dev,
  45.                      "interrupt %04x in poll\n", status);
  46.         }

  48.         /* We only get a new MSI interrupt when all active irq
  49.          * sources on the chip have been acknowledged. So, ack
  50.          * everything we
收包软中断net_rx_action主要是调用各个NAPI对应的poll函数。
接下来看r8169的poll函数，该函数除了完成收包任务外，还附带完成发送相关的资源释放任务
  1. static int rtl8169_poll(struct napi_struct *napi, int budget)
  2. {
  3.     struct rtl8169_private *tp = container_of(napi, struct rtl8169_private, napi);
  4.     struct net_device *dev = tp->dev;
  5.     void __iomem *ioaddr = tp->mmio_addr;
  6.     int work_done;

  8.     work_done = rtl8169_rx_interrupt(dev, tp, ioaddr, (u32) budget);
  9.     rtl8169_tx_interrupt(dev, tp, ioaddr);

  11.     if (work_done < budget) {
  12.         napi_complete(napi);

  14.         /* We need for force the visibility of tp->intr_mask
  15.          * for other CPUs, as we can loose an MSI interrupt
  16.          * and potentially wait for a retransmit timeout if we don't.
  17.          * The posted write to IntrMask is safe, as it will
  18.          * eventually make it to the chip and we won't loose anything
  19.          * until it does.
  20.          */
  21.         tp->intr_mask = 0xffff;
  22.         wmb();
  23.         RTL_W16(IntrMask, tp->intr_event);
  24.     }

  26.     return work_done;
  27. }
要看懂收包流程同样需要结合数据手册：
收包和发包相反，其发送描述符相关的内容由硬件赋值好，驱动主要根据该描述符构造skb数据结构然后传给协议栈。
为了使硬件能够正确的使用发送描述符，驱动要先准备好相应的资源：
初始化后的描述符如下：

硬件赋值好的描述符如下，这种描述符是驱动用于构造skb的：


  1. static int rtl8169_rx_interrupt(struct net_device *dev,
  2.                 struct rtl8169_private *tp,
  3.                 void __iomem *ioaddr, u32 budget)
  4. {
  5.     unsigned int cur_rx, rx_left;
  6.     unsigned int count;

  8.     cur_rx = tp->cur_rx;
  9.     rx_left = NUM_RX_DESC + tp->dirty_rx - cur_rx; //dirty_rx始终等于cur_rx，这段代码没啥意义，新版的代码去除了这个分量
  10.     rx_left = min(rx_left, budget); //直接使用min(budget, NUM_RX_DESC)

  12.     for (; rx_left > 0; rx_left--, cur_rx++) {
  13.         unsigned int entry = cur_rx % NUM_RX_DESC;
  14.         struct RxDesc *desc = tp->RxDescArray + entry;
  15.         u32 status;

  17.         rmb();
  18.         status = le32_to_cpu(desc->opts1) & tp->opts1_mask;

  20.         if (status & DescOwn) //从数据手册可以知道，此时这个描述符还属于网卡，即还没有接到数据
  21.             break;
  22.         if (unlikely(status & RxRES)) {  //错误综合标志位
  23.             netif_info(tp, rx_err, dev, "Rx ERROR. status = %08x\n",
  24.                  status);
  25.             dev->stats.rx_errors++;
  26.             if (status & (RxRWT | RxRUNT))
  27.                 dev->stats.rx_length_errors++;
  28.             if (status & RxCRC)
  29.                 dev->stats.rx_crc_errors++;
  30.             if (status & RxFOVF) {
  31.                 rtl8169_schedule_work(dev, rtl8169_reset_task);
  32.                 dev->stats.rx_fifo_errors++;
  33.             }
  34.             rtl8169_mark_to_asic(desc, rx_buf_sz);
  35.         } else {
  36.             struct sk_buff *skb;
  37.             dma_addr_t addr = le64_to_cpu(desc->addr);
  38.             int pkt_size = (status & 0x00001FFF) - 4;

  40.             /*
  41.              * The driver does not support incoming fragmented
  42.              * frames. They are seen as a symptom of over-mtu
  43.              * sized frames.
  44.              */
  45.             if (unlikely(rtl8169_fragmented_frame(status))) {
  46.                 dev->stats.rx_dropped++;
  47.                 dev->stats.rx_length_errors++;
  48.                 rtl8169_mark_to_asic(desc, rx_buf_sz);
  49.                 continue;
  50.             }

  52.             skb = rtl8169_try_rx_copy(tp->Rx_databuff[entry],
  53.                          tp, pkt_size, addr);
  54.             rtl8169_mark_to_asic(desc, rx_buf_sz); //数据拷贝完后，该接收描述符可以释放给网卡了
  55.             if (!skb) {
  56.                 dev->stats.rx_dropped++;
  57.                 continue;
  58.             }
  59.             //如果硬件已经校验的话，赋值skb->ip_summed = CHECKSUM_UNNECESSARY;
  60.             rtl8169_rx_csum(skb, status);
  61.             skb_put(skb, pkt_size);
  62.             skb->protocol = eth_type_trans(skb, dev); //根据包L2层的数据赋值protocal

  64.             rtl8169_rx_vlan_tag(desc, skb);

  66.             napi_gro_receive(&tp->napi, skb); //通过GRO，把包传给协议栈

  68.             dev->stats.rx_bytes += pkt_size;
  69.             dev->stats.rx_packets++;
  70.         }

  72.         /* Work around for AMD plateform. */
  73.         if ((desc->opts2 & cpu_to_le32(0xfffe000)) &&
  74.          (tp->mac_version == RTL_GIGA_MAC_VER_05)) {
  75.             desc->opts2 = 0;
  76.             cur_rx++;
  77.         }
  78.     }

  80.     count = cur_rx - tp->cur_rx;
  81.     tp->cur_rx = cur_rx;

  83.     tp->dirty_rx += count;

  85.     return count;
  86. }
驱动负责解析L2的头，根据mac地址的值以及协议类型设置skb的分量：
  1. __be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)
  2. {
  3.     struct ethhdr *eth;

  5.     skb->dev = dev;
  6.     skb_reset_mac_header(skb);
  7.     skb_pull_inline(skb, ETH_HLEN); 
  8.     eth = eth_hdr(skb);

  10.     if (unlikely(is_multicast_ether_addr(eth->h_dest))) {  //根据mac地址赋值pkt_type
  11.         if (!compare_ether_addr_64bits(eth->h_dest, dev->broadcast))
  12.             skb->pkt_type = PACKET_BROADCAST;
  13.         else
  14.             skb->pkt_type = PACKET_MULTICAST;
  15.     }

  17.     /*
  18.      * This ALLMULTI check should be redundant by 1.4
  19.      * so don't forget to remove it.
  20.      *
  21.      * Seems, you forgot to remove it. All silly devices
  22.      * seems to set IFF_PROMISC.
  23.      */

  25.     else if (1 /*dev->flags&IFF_PROMISC */ ) {
  26.         if (unlikely(compare_ether_addr_64bits(eth->h_dest, dev->dev_addr)))
  27.             skb->pkt_type = PACKET_OTHERHOST;
  28.     }

  30.     /*
  31.      * Some variants of DSA tagging don't have an ethertype field
  32.      * at all, so we check here whether one of those tagging
  33.      * variants has been configured on the receiving interface,
  34.      * and if so, set skb->protocol without looking at the packet.
  35.      */
  36.     if (netdev_uses_dsa_tags(dev))
  37.         return htons(ETH_P_DSA);
  38.     if (netdev_uses_trailer_tags(dev))
  39.         return htons(ETH_P_TRAILER);

  41.     if (ntohs(eth->h_proto) >= 1536)
  42.         return eth->h_proto;   //IP为0x0800，ARP为0x0806
  43.     /*
  44.      * This is a magic hack to spot IPX packets. Older Novell breaks
  45.      * the protocol design and runs IPX over 802.3 without an 802.2 LLC
  46.      * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
  47.      * won't work for fault tolerant netware but does for the rest.
  48.      */
  49.     if (skb->len >= 2 && *(unsigned short *)(skb->data) == 0xFFFF)
  50.         return htons(ETH_P_802_3);

  52.     /*
  53.      * Real 802.2 LLC
  54.      */
  55.     return htons(ETH_P_802_2);
  56. }
看驱动收包后，在发给上层协议栈前skb的具体情况：



再看一下发包后资源释放的流程：
  1. static void rtl8169_tx_interrupt(struct net_device *dev,
  2.                  struct rtl8169_private *tp,
  3.                  void __iomem *ioaddr)
  4. {
  5.     unsigned int dirty_tx, tx_left;

  7.     dirty_tx = tp->dirty_tx;
  8.     smp_rmb();
  9.     tx_left = tp->cur_tx - dirty_tx;

  11.     while (tx_left > 0) {
  12.         unsigned int entry = dirty_tx % NUM_TX_DESC;
  13.         struct ring_info *tx_skb = tp->tx_skb + entry;
  14.         u32 status;

  16.         rmb();
  17.         status = le32_to_cpu(tp->TxDescArray[entry].opts1);
  18.         if (status & DescOwn)  //DescOwn为1表示硬件还没发送完该包，发送完后硬件会把该位置0
  19.             break;

  21.         rtl8169_unmap_tx_skb(&tp->pci_dev->dev, tx_skb,
  22.                  tp->TxDescArray + entry);
  23.         if (status & LastFrag) {  //如果一个skb对应的所有发送描述符都可以释放的话，该skb也可以释放了
  24.             dev->stats.tx_packets++;
  25.             dev->stats.tx_bytes += tx_skb->skb->len;
  26.             dev_kfree_skb(tx_skb->skb);
  27.             tx_skb->skb = NULL;
  28.         }
  29.         dirty_tx++;
  30.         tx_left--;
  31.     }

  33.     if (tp->dirty_tx != dirty_tx) {
  34.         tp->dirty_tx = dirty_tx;
  35.         smp_wmb();
  36.         if (netif_queue_stopped(dev) && //如果之前由于发送描述符不够导致队列关闭的话，重新判断
  37.          (TX_BUFFS_AVAIL(tp) >= MAX_SKB_FRAGS)) {
  38.             netif_wake_queue(dev);
  39.         }
  40.         /*
  41.          * 8168 hack: TxPoll requests are lost when the Tx packets are
  42.          * too close. Let
对于网卡驱动收包流程的话可以总结为：根据接收描述符的内容构造skb，拷贝数据，赋值相应的分量，然后调用napi_gro_receive发给上层协议栈。


阅读(3100) | 评论(0) | 转发(1) |
0

上一篇：ip分片以及网卡的卸载功能

下一篇：GRO 接收流程

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6