linux下ixgb网卡驱动(2)

11190阅读　0评论2013-11-26　liubangbo
分类：LINUX

II)接收数据包部分

1. 采用non_napi方式
在中断函数ixgb_intr()中，调用了ixgb_clean_rx_irq()函数来进行中断处理。在这里non_napi方式和napi方式采用了同名的函数，napi多了2个参数如下：
static boolean_t
#ifdef CONFIG_IXGB_NAPI
ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do)
#else
ixgb_clean_rx_irq(struct ixgb_adapter *adapter)
#endif



点击(此处)折叠或打开

  1. static boolean_t
  2. #ifdef CONFIG_IXGB_NAPI
  3. ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do)
  4. #else
  5. ixgb_clean_rx_irq(struct ixgb_adapter *adapter)
  6. #endif
  7. {
  8.     struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
  9.     struct net_device *netdev = adapter->netdev;
  10.     struct pci_dev *pdev = adapter->pdev;
  11.     struct ixgb_rx_desc *rx_desc, *next_rxd;
  12.     struct ixgb_buffer *buffer_info, *next_buffer, *next2_buffer;
  13.     uint32_t length;
  14.     unsigned int i, j;
  15.     boolean_t cleaned = FALSE;

  17.     i = rx_ring->next_to_clean;
  18.     rx_desc = IXGB_RX_DESC(*rx_ring, i);
  19.     buffer_info = &rx_ring->buffer_info[i];

  21.     while(rx_desc->status & IXGB_RX_DESC_STATUS_DD) {    //如前面分析rx_desc是描述符，进行了一致性DMA映射，所以直接读取其值判断这个中断是否是数据包到来产生的中断
  22.         struct sk_buff *skb, *next_skb;                  //因为对skb进行了DMA映射，一次中断最多可以接收rxd->count个数据包，所以这里对rxd->count个描述符轮询
  23.         u8 status;

  25. #ifdef CONFIG_IXGB_NAPI
  26.         if(*work_done >= work_to_do)
  27.             break;

  29.         (*work_done)++;
  30. #endif
  31.         status = rx_desc->status;
  32.         skb = buffer_info->skb;
  33.         buffer_info->skb = NULL;

  35.         prefetch(skb->data);

  37.         if(++i == rx_ring->count) i = 0;
  38.         next_rxd = IXGB_RX_DESC(*rx_ring, i);   //得到下一个描述符
  39.         prefetch(next_rxd);

  41.         if((j = i + 1) == rx_ring->count) j = 0;
  42.         next2_buffer = &rx_ring->buffer_info[j];  //预先取得第二个buffer
  43.         prefetch(next2_buffer);

  45.         next_buffer = &rx_ring->buffer_info[i];   //得到下一个buffer
  46.         next_skb = next_buffer->skb;
  47.         prefetch(next_skb);

  49.         cleaned = TRUE;

  51.         pci_unmap_single(pdev,
  52.                  buffer_info->dma,
  53.                  buffer_info->length,
  54.                  PCI_DMA_FROMDEVICE);     //把控制权还给CPU

  56.         length = le16_to_cpu(rx_desc->length);

  58.         if(unlikely(!(status & IXGB_RX_DESC_STATUS_EOP))) {

  60.             /* All receives must fit into a single buffer */

  62.             IXGB_DBG("Receive packet consumed multiple buffers "
  63.                      "length<%x>\n", length);

  65.             dev_kfree_skb_irq(skb);
  66.             goto rxdesc_done;
  67.         }

  69.         if (unlikely(rx_desc->errors
  70.              & (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE
  71.                 | IXGB_RX_DESC_ERRORS_P |
  72.                 IXGB_RX_DESC_ERRORS_RXE))) {

  74.             dev_kfree_skb_irq(skb);
  75.             goto rxdesc_done;
  76.         }

  78.         /* code added for copybreak, this should improve
  79.          * performance for small packets with large amounts
  80.          * of reassembly being done in the stack */
  81. #define IXGB_CB_LENGTH 256
  82.         if (length < IXGB_CB_LENGTH) {
  83.             struct sk_buff *new_skb =
  84.              netdev_alloc_skb(netdev, length + NET_IP_ALIGN);
  85.             if (new_skb) {
  86.                 skb_reserve(new_skb, NET_IP_ALIGN);
  87.                 memcpy(new_skb->data - NET_IP_ALIGN,
  88.                  skb->data - NET_IP_ALIGN,
  89.                  length + NET_IP_ALIGN);
  90.                 /* save the skb in buffer_info as good */
  91.                 buffer_info->skb = skb;
  92.                 skb = new_skb;
  93.             }
  94.         }
  95.         /* end copybreak code */

  97.         /* Good Receive */
  98.         skb_put(skb, length);

  100.         /* Receive Checksum Offload */
  101.         ixgb_rx_checksum(adapter, rx_desc, skb);

  103.         skb->protocol = eth_type_trans(skb, netdev);
  104. #ifdef CONFIG_IXGB_NAPI
  105.         if(adapter->vlgrp && (status & IXGB_RX_DESC_STATUS_VP)) {
  106.             vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
  107.                 le16_to_cpu(rx_desc->special) &
  108.                     IXGB_RX_DESC_SPECIAL_VLAN_MASK);
  109.         } else {
  110.             netif_receive_skb(skb);
  111.         }
  112. #else /* CONFIG_IXGB_NAPI */
  113.         if(adapter->vlgrp && (status & IXGB_RX_DESC_STATUS_VP)) {
  114.             vlan_hwaccel_rx(skb, adapter->vlgrp,
  115.                 le16_to_cpu(rx_desc->special) &
  116.                     IXGB_RX_DESC_SPECIAL_VLAN_MASK);
  117.         } else {
  118.             netif_rx(skb);    //non_napi 调用的接收函数
  119.         }
  120. #endif /* CONFIG_IXGB_NAPI */
  121.         netdev->last_rx = jiffies;

  123. rxdesc_done:
  124.         /* clean up descriptor, might be written over by hw */
  125.         rx_desc->status = 0;

  127.         /* use prefetched values */
  128.         rx_desc = next_rxd;            //指向下一个描述符
  129.         buffer_info = next_buffer;     //指向下一个buffer
  130.     }

  132.     rx_ring->next_to_clean = i;    //移动位置

  134.     ixgb_alloc_rx_buffers(adapter);     //再分配前面吃掉的skb，用多少再分配多少

  136.     return cleaned;
  137. }
 还是先把代码贴上吧。 基本上看注释就行了， 接下来看netif_rx(skb); 还是先贴代码，给代码加注释

点击(此处)折叠或打开

  1. int netif_rx(struct sk_buff *skb)
  2. {
  3.     struct softnet_data *queue;
  4.     unsigned long flags;

  6.     /* if netpoll wants it, pretend we never saw it */
  7.     if (netpoll_rx(skb))   //稍微看了一下这个函数只处理ARP和UDP数据包，具体为什么以后再分析
  8.         return NET_RX_DROP;

  10.     if (!skb->tstamp.off_sec)
  11.         net_timestamp(skb);

  13.     /*
  14.      * The code is rearranged so that the path is the most
  15.      * short when CPU is congested, but is still operating.
  16.      */
  17.     local_irq_save(flags);
  18.     queue = &__get_cpu_var(softnet_data);  //得到当前CPU的软中断调度队列，每个CPU有自己的软中断调度队列

  20.     __get_cpu_var(netdev_rx_stat).total++;
  21.     if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {   //这个是软中断调度队列的预算，这个值默认为300，可以在/proc文件中改变
  22.         if (queue->input_pkt_queue.qlen) {
  23. enqueue:
  24.             dev_hold(skb->dev);
  25.             __skb_queue_tail(&queue->input_pkt_queue, skb);    //在这里把skb挂到input_pkt_queue接收队列中，接着就退出了，因为在中断函数不能做太多的事情。
  26.                                                                //接收软中断处理从input_pkt_queue取走skb交给上层协议栈，
  27.                                                          
  28.             local_irq_restore(flags);
  29.             return NET_RX_SUCCESS;
  30.         }

  32.         netif_rx_schedule(&queue->backlog_dev);  //这个函数把backlog_dev设备挂接到软中断队列中，分配这个网卡设备的配额，并唤醒接收软件中断，注意当
  33.                                                  //queue->input_pkt_queue.qlen == 0, 即队列为空时才调用这个函数
  34.         goto enqueue;
  35.     }

  37.     __get_cpu_var(netdev_rx_stat).dropped++;
  38.     local_irq_restore(flags);

  40.     kfree_skb(skb);   //如果上面的if条件不满足，即网卡接收数据包快，来不及处理，则直接丢包。
  41.     return NET_RX_DROP;
  42. }

在这个函数中接收中断处理函数就算结束了，总结一下接收中断处理函数所干的工作就是来一个接收中断，就把DMA内存中所有的数据包挂在接收队列中，如果接收队列为空就唤醒接收软件中断去接收，如果包过快，来不及处理就直接在这里丢包。下面就看接收软件中断函数了：


点击(此处)折叠或打开

  1. /*
     *    Initialize the DEV module. At boot time this walks the device list and
     *    unhooks any devices that fail to initialise (normally hardware not
     *    present) and leaves us with a valid list of present and active devices.
     *
     */
  2. static int __init net_dev_init(void) 
  3. {
  4.     int i, rc = -ENOMEM;

  6.     BUG_ON(!dev_boot_phase);

  8.     if (dev_proc_init())
  9.         goto out;

  11.     if (netdev_sysfs_init())
  12.         goto out;

  14.     INIT_LIST_HEAD(&ptype_all);
  15.     for (i = 0; i < 16; i++)
  16.         INIT_LIST_HEAD(&ptype_base[i]);

  18.     for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
  19.         INIT_HLIST_HEAD(&dev_name_head[i]);

  21.     for (i = 0; i < ARRAY_SIZE(dev_index_head); i++)
  22.         INIT_HLIST_HEAD(&dev_index_head[i]);

  24.     /*
  25.      *    Initialise the packet receive queues.
  26.      */

  28.     for_each_possible_cpu(i) {
  29.         struct softnet_data *queue;

  31.         queue = &per_cpu(softnet_data, i);
  32.         skb_queue_head_init(&queue->input_pkt_queue); //non_napi
  33.         queue->completion_queue = NULL;
  34.         INIT_LIST_HEAD(&queue->poll_list); //napi
  35.         set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
  36.         queue->backlog_dev.weight = weight_p; //non_napi 默认配额为64
  37.         queue->backlog_dev.poll = process_backlog; //non_napi
  38.         atomic_set(&queue->backlog_dev.refcnt, 1);
  39.     }

  41.     netdev_dma_register();

  43.     dev_boot_phase = 0;

  45.     open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
  46.     open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);

  48.     hotcpu_notifier(dev_cpu_callback, 0);
  49.     dst_init();
  50.     dev_mcast_init();
  51.     rc = 0;
  52. out:
  53.     return rc;
  54. }
一目了然，还是看net_rx_action函数吧

点击(此处)折叠或打开

  1. /*
  2.   *给每个CPU的软中断调度队列分配一个预算，
  3.   * 每个网卡有自己的配额， 一次软中断处理完这个预算，
  4.   *然后再次触法软中断 。。。
  5.   *挂在这个软中断调度队列的所有的网卡以配额为单位去吃这个预算
  6.   *每个网卡以配额为单位吃掉后挂在软中断调度队列的尾部，让给
  7.   *其他网卡去吃预算
  8.   */
  9. static void net_rx_action(struct softirq_action *h)
  10. {
  11.     struct softnet_data *queue = &__get_cpu_var(softnet_data);
  12.     unsigned long start_time = jiffies;
  13.     int budget = netdev_budget; //一次软中断的预算
  14.     void *have;

  16.     local_irq_disable();

  18.     while (!list_empty(&queue->poll_list)) {
  19.         struct net_device *dev;

  21.         if (budget <= 0 || jiffies - start_time > 1) //预算不够了，或者包处理时间超过1s，直接再次触法软中断
  22.             goto softnet_break;

  24.         local_irq_enable();

  26.         dev = list_entry(queue->poll_list.next,
  27.                  struct net_device, poll_list); //遍历链表，找到接收设备
  28.         have = netpoll_poll_lock(dev);

  30.         if (dev->quota <= 0 || dev->poll(dev, &budget)) {
  31.             /*
  32.              *配额用完了或者还有很多数据包要接收
  33.              */
  34.             netpoll_poll_unlock(have);
  35.             local_irq_disable();
  36.             list_move_tail(&dev->poll_list, &queue->poll_list); //把接收链表删除，并再次添加到softnet结构中

  38.             //再次设置配额，然后继续轮询接收剩下的数据包
  39.             if (dev->quota < 0)
  40.                 dev->quota += dev->weight;
  41.             else
  42.                 dev->quota = dev->weight;
  43.         } else {
  44.          //收到的数据包小于配额，则这一次轮询接收就完事了，要打开接收中断，等待数据包的到来
  45.             netpoll_poll_unlock(have);
  46.             dev_put(dev);
  47.             local_irq_disable();
  48.         }
  49.     }
  50. out:
  51. #ifdef CONFIG_NET_DMA
  52.     /*
  53.      * There may not be any more sk_buffs coming right now, so push
  54.      * any pending DMA copies to hardware
  55.      */
  56.     if (net_dma_client) {
  57.         struct dma_chan *chan;
  58.         rcu_read_lock();
  59.         list_for_each_entry_rcu(chan, &net_dma_client->channels, client_node)
  60.             dma_async_memcpy_issue_pending(chan);
  61.         rcu_read_unlock();
  62.     }
  63. #endif
  64.     local_irq_enable();
  65.     return;

  67. softnet_break:
  68.     __get_cpu_var(netdev_rx_stat).time_squeeze++;
  69.     __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  70.     goto out;
  71. }
这个是软中断处理函数流程，napi方式也调用这个函数，处理流程是一样的，但是在non_napi方式中struct net_device *dev; 这个设备是初始化默认的backlog_dev 设备，所以dev->poll(dev, &budget)) 调用的
是backlog_dev 设备注册的queue->backlog_dev.poll = process_backlog; //non_napi   函数， napi方式中设备是自己创建的，处理函数也是自己注册的。现在看process_backlog这个函数就行了

点击(此处)折叠或打开

  1. static int process_backlog(struct net_device *backlog_dev, int *budget)
  2. {
  3.     int work = 0;
  4.     int quota = min(backlog_dev->quota, *budget);
  5.     struct softnet_data *queue = &__get_cpu_var(softnet_data);
  6.     unsigned long start_time = jiffies;

  8.     backlog_dev->weight = weight_p;
  9.     for (;;) {
  10.         struct sk_buff *skb;
  11.         struct net_device *dev;

  13.         local_irq_disable();
  14.         skb = __skb_dequeue(&queue->input_pkt_queue);
  15.         if (!skb)
  16.             goto job_done;
  17.         local_irq_enable();

  19.         dev = skb->dev;

  21.         netif_receive_skb(skb);

  23.         dev_put(dev);

  25.         work++;

  27.         if (work >= quota || jiffies - start_time > 1)
  28.             break;

  30.     }

  32.     backlog_dev->quota -= work;
  33.     *budget -= work;
  34.     return -1;

  36. job_done:
  37.     backlog_dev->quota -= work;
  38.     *budget -= work;

  40.     list_del(&backlog_dev->poll_list);
  41.     smp_mb__before_clear_bit();
  42.     netif_poll_enable(backlog_dev);

  44.     local_irq_enable();
  45.     return 0;
  46. }

在这里我们看到了从接受队列中取包skb = __skb_dequeue(&queue->input_pkt_queue);    送到上层协议栈 netif_receive_skb(skb);  减少预算和配额backlog_dev->quota -= work; *budget -= work;等操作



over ...



上一篇：linux下ixgb网卡驱动(1)
下一篇： linux下ixgb网卡驱动(3)