Linux内核收包精髓

忘是亡心i 2022-08-10 01:00 97阅读 0赞

网卡和磁盘是现代服务器里面性能要求最为苛刻的2个外设，我们来看一下Linux内核是如何处理高性能的网卡的。

int netif_rx(struct sk_buff *skb)
    {
      int this_cpu = smp_processor_id();
      struct softnet_data *queue;
      unsigned long flags;
      if (skb->stamp.tv_sec == 0)
        do_gettimeofday(&skb->stamp);
      /* The code is rearranged so that the path is the most
        short when CPU is congested, but is still operating.
       */
      queue = &softnet_data[this_cpu];
      local_irq_save(flags);
      netdev_rx_stat[this_cpu].total++;
      if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
        if (queue->input_pkt_queue.qlen) {
          if (queue->throttle)
            goto drop;
    enqueue:
          dev_hold(skb->dev);
          __skb_queue_tail(&queue->input_pkt_queue,skb);
          /* Runs from irqs or BH's, no need to wake BH */
          cpu_raise_softirq(this_cpu, NET_RX_SOFTIRQ);
          local_irq_restore(flags);
    #ifndef OFFLINE_SAMPLE
          get_sample_stats(this_cpu);
    #endif
          return softnet_data[this_cpu].cng_level;
        }
        if (queue->throttle) {
          queue->throttle = 0;
    #ifdef CONFIG_NET_HW_FLOWCONTROL
          if (atomic_dec_and_test(&netdev_dropping))
            netdev_wakeup();
    #endif
        }
        goto enqueue;
      }
      if (queue->throttle == 0) {
        queue->throttle = 1;
        netdev_rx_stat[this_cpu].throttled++;
    #ifdef CONFIG_NET_HW_FLOWCONTROL
        atomic_inc(&netdev_dropping);
    #endif
      }
    drop:
      netdev_rx_stat[this_cpu].dropped++;
      local_irq_restore(flags);
      kfree_skb(skb);
      return NET_RX_DROP;
    }
    /* Deliver skb to an old protocol, which is not threaded well
      or which do not understand shared skbs.
     */
    static int deliver_to_old_ones(struct packet_type *pt, struct sk_buff *skb, int last)
    {
      static spinlock_t net_bh_lock = SPIN_LOCK_UNLOCKED;
      int ret = NET_RX_DROP;
      if (!last) {
        skb = skb_clone(skb, GFP_ATOMIC);
        if (skb == NULL)
          return ret;
      }
      if (skb_is_nonlinear(skb) && skb_linearize(skb, GFP_ATOMIC) != 0) {
        kfree_skb(skb);
        return ret;
      }
      /* The assumption (correct one) is that old protocols
        did not depened on BHs different of NET_BH and TIMER_BH.
       */
      /* Emulate NET_BH with special spinlock */
      spin_lock(&net_bh_lock);
      /* Disable timers and wait for all timers completion */
      tasklet_disable(bh_task_vec+TIMER_BH);
      ret = pt->func(skb, skb->dev, pt);
      tasklet_hi_enable(bh_task_vec+TIMER_BH);
      spin_unlock(&net_bh_lock);
      return ret;
    }

static void net_rx_action(struct softirq_action *h)
    {
      int this_cpu = smp_processor_id();
      struct softnet_data *queue = &softnet_data[this_cpu];
      unsigned long start_time = jiffies;
      int bugdet = netdev_max_backlog;
    
      br_read_lock(BR_NETPROTO_LOCK);
    
      for (;;) {
        struct sk_buff *skb;
        struct net_device *rx_dev;
    
        local_irq_disable();
        skb = __skb_dequeue(&queue->input_pkt_queue);
        local_irq_enable();
    
        if (skb == NULL)
          break;
    
        skb_bond(skb);
    
        rx_dev = skb->dev;
    
    #ifdef CONFIG_NET_FASTROUTE
        if (skb->pkt_type == PACKET_FASTROUTE) {
          netdev_rx_stat[this_cpu].fastroute_deferred_out++;
          dev_queue_xmit(skb);
          dev_put(rx_dev);
          continue;
        }
    #endif
        skb->h.raw = skb->nh.raw = skb->data;
        {
          struct packet_type *ptype, *pt_prev;
          unsigned short type = skb->protocol;
    
          pt_prev = NULL;
          for (ptype = ptype_all; ptype; ptype = ptype->next) {
            if (!ptype->dev || ptype->dev == skb->dev) {
              if (pt_prev) {
                if (!pt_prev->data) {
                  deliver_to_old_ones(pt_prev, skb, 0);
                } else {
                  atomic_inc(&skb->users);
                  pt_prev->func(skb,
                          skb->dev,
                          pt_prev);
                }
              }
              pt_prev = ptype;
            }
          }
    
    #ifdef CONFIG_NET_DIVERT
          if (skb->dev->divert && skb->dev->divert->divert)
            handle_diverter(skb);
    #endif /* CONFIG_NET_DIVERT */
    
          
    #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
          if (skb->dev->br_port != NULL &&
              br_handle_frame_hook != NULL) {
            handle_bridge(skb, pt_prev);
            dev_put(rx_dev);
            continue;
          }
    #endif
    
          for (ptype=ptype_base[ntohs(type)&15];ptype;ptype=ptype->next) {
            if (ptype->type == type &&
                (!ptype->dev || ptype->dev == skb->dev)) {
              if (pt_prev) {
                if (!pt_prev->data)
                  deliver_to_old_ones(pt_prev, skb, 0);
                else {
                  atomic_inc(&skb->users);
                  pt_prev->func(skb,
                          skb->dev,
                          pt_prev);
                }
              }
              pt_prev = ptype;
            }
          }
    
          if (pt_prev) {
            if (!pt_prev->data)
              deliver_to_old_ones(pt_prev, skb, 1);
            else
              pt_prev->func(skb, skb->dev, pt_prev);
          } else
            kfree_skb(skb);
        }
    
        dev_put(rx_dev);
    
        if (bugdet-- < 0 || jiffies - start_time > 1)
          goto softnet_break;
    
    #ifdef CONFIG_NET_HW_FLOWCONTROL
      if (queue->throttle && queue->input_pkt_queue.qlen < no_cong_thresh ) {
        if (atomic_dec_and_test(&netdev_dropping)) {
          queue->throttle = 0;
          netdev_wakeup();
          goto softnet_break;
        }
      }
    #endif
    
      }
      br_read_unlock(BR_NETPROTO_LOCK);
    
      local_irq_disable();
      if (queue->throttle) {
        queue->throttle = 0;
    #ifdef CONFIG_NET_HW_FLOWCONTROL
        if (atomic_dec_and_test(&netdev_dropping))
          netdev_wakeup();
    #endif
      }
      local_irq_enable();
    
      NET_PROFILE_LEAVE(softnet_process);
      return;
    
    softnet_break:
      br_read_unlock(BR_NETPROTO_LOCK);
    
      local_irq_disable();
      netdev_rx_stat[this_cpu].time_squeeze++;
      /* This already runs in BH context, no need to wake up BH's */
      cpu_raise_softirq(this_cpu, NET_RX_SOFTIRQ);
      local_irq_enable();
    
      NET_PROFILE_LEAVE(softnet_process);
      return;
    }

看懂了吧？

麻痹的，Linux内核在网卡异步处理机制上比传统的BSD激进多了，性能优越得多，不过稳定性也随之下降！