AI 助理
文档备案控制台
开发者社区 大数据 文章 正文

帧的发送

2014-05-15 1037
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：       上一节我们说了帧的接收，自然有收就有发，并且也很少说关于发送的东西，这里我们就分析下帧的发送.      参考内核2.6.32.60   net/core/dev.c        我们先看看设备无关层的经典发送函数接口 dev_queue_xmit,当然这里要说一下...
      上一节我们说了帧的接收，自然有收就有发，并且也很少说关于发送的东西，这里我们就分析下帧的发送.
     参考内核2.6.32.60   net/core/dev.c  
     我们先看看设备无关层的经典发送函数接口 dev_queue_xmit,当然这里要说一下，上层是如何调用到这里的，当然数据发送到ip层的时候，会调用到邻居子系统模块会把这个接口给联系起来，因为要给数据包封装帧头.查询arp表,找到ip和mac的对应关系当然还有接口的.

点击(此处)折叠或打开

  1. /* This function can be used in contexts, where only old dev_queue_xmit
  2.    worked, f.e. if you want to override normal output path (eql, shaper),
  3.    but resolution is not made yet.
  4.  */

  6. int neigh_compat_output(struct sk_buff *skb)
  7. {
  8.     struct net_device *dev = skb->dev;

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

  12.     if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
  13.              skb->len) 0 &&
  14.      dev->header_ops->rebuild(skb))
  15.         return 0;

  17.     return dev_queue_xmit(skb);
  18. }
这里不多说上层的流程.

点击(此处)折叠或打开

  1. /**
  2.  *    dev_queue_xmit - transmit a buffer
  3.  *    @skb: buffer to transmit
  4.  *
  5.  *    Queue a buffer for transmission to a network device. The caller must
  6.  *    have set the device and priority and built the buffer before calling
  7.  *    this function. The function can be called from an interrupt.
  8.  *
  9.  *    A negative errno code is returned on a failure. A success does not
  10.  *    guarantee the frame will be transmitted as it may be dropped due
  11.  *    to congestion or traffic shaping.
  12.  *
  13.  * -----------------------------------------------------------------------------------
  14.  * I notice this method can also return errors from the queue disciplines,
  15.  * including NET_XMIT_DROP, which is a positive value. So, errors can also
  16.  * be positive.
  17.  *
  18.  * Regardless of the return value, the skb is consumed, so it is currently
  19.  * difficult to retry a send to this method. (You can bump the ref count
  20.  * before sending to hold a reference for retry if you are careful.)
  21.  *
  22.  * When calling this method, interrupts MUST be enabled. This is because
  23.  * the BH enable code must have IRQs enabled so that it will not deadlock.
  24.  * --BLG
  25.  */
  26. int dev_queue_xmit(struct sk_buff *skb)
  27. {
  28.     struct net_device *dev = skb->dev;
  29.     struct netdev_queue *txq;
  30.     struct Qdisc *q;
  31.     int rc = -ENOMEM;

  33.     /* GSO will handle the following emulations directly. */
  34.     if (netif_needs_gso(dev, skb))     //帧的聚合/分散  用来提高网络性能 可以参考tso，如果有了支持TSO的网卡，CPU可以直接将要发送的大数据发送到网卡上                                       //，由网卡硬件去负责分片和计算校验和;同时也需要支持硬件校验和 
  35.         goto gso;

  37.     if (skb_has_frags(skb) &&              //这里判断帧是否有分片，如果有把分片的部分，组合到一起发送.
  38.      !(dev->features & NETIF_F_FRAGLIST) &&
  39.      __skb_linearize(skb))
  40.         goto out_kfree_skb;

  42.     /* Fragmented skb is linearized if device does not support SG,
  43.      * or if at least one of fragments is in highmem and device
  44.      * does not support DMA from it.
  45.      */
  46.     if (skb_shinfo(skb)->nr_frags &&
  47.      (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
  48.      __skb_linearize(skb))
  49.         goto out_kfree_skb;

  51.     /* If packet is not checksummed and device does not support
  52.      * checksumming for this protocol, complete checksumming here.
  53.      */
  54.     if (skb->ip_summed == CHECKSUM_PARTIAL) {                 // 软件 校验L4 校验和，然后准备发送帧.
  55.         skb_set_transport_header(skb, skb->csum_start -
  56.                      skb_headroom(skb));
  57.         if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
  58.             goto out_kfree_skb;
  59.     }

  61. gso:
  62.     /* Disable soft irqs for various locks below. Also
  63.      * stops preemption for RCU.
  64.      */
  65.     rcu_read_lock_bh();

  67.     txq = dev_pick_tx(dev, skb);
  68.     q = rcu_dereference(txq->qdisc);

  70. #ifdef CONFIG_NET_CLS_ACT                // 这里默认开启了这个选项，即qos，流量控制 
  71.     skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
  72. #endif
  73.     if (q->enqueue) {
  74.         rc = __dev_xmit_skb(skb, q, dev, txq);
  75.         goto out;
  76.     }

  78.     /* The device has no queue. Common case for software devices:
  79.      loopback, all the sorts of tunnels...

  81.      Really, it is unlikely that netif_tx_lock protection is necessary
  82.      here. (f.e. loopback and IP tunnels are clean ignoring statistics
  83.      counters.)
  84.      However, it is possible, that they rely on protection
  85.      made by us here.

  87.      Check this and shot the lock. It is not prone from deadlocks.
  88.      Either shot noqueue qdisc, it is even simpler 8)
  89.      */
  90.     if (dev->flags & IFF_UP) {
  91.         int cpu = smp_processor_id(); /* ok because BHs are off */

  93.         if (txq->xmit_lock_owner != cpu) {

  95.             HARD_TX_LOCK(dev, txq, cpu);

  97.             if (!netif_tx_queue_stopped(txq)) {
  98.                 rc = NET_XMIT_SUCCESS;
  99.                 if (!dev_hard_start_xmit(skb, dev, txq)) {
  100.                     HARD_TX_UNLOCK(dev, txq);
  101.                     goto out;
  102.                 }
  103.             }
  104.             HARD_TX_UNLOCK(dev, txq);
  105.             if (net_ratelimit())
  106.                 printk(KERN_CRIT "Virtual device %s asks to "
  107.                  "queue packet!\n", dev->name);
  108.         } else {
  109.             /* Recursion is It is possible,
  110.              * unfortunately */
  111.             if (net_ratelimit())
  112.                 printk(KERN_CRIT "Dead loop on virtual device "
  113.                  "%s, fix it urgently!\n", dev->name);
  114.         }
  115.     }

  117.     rc = -ENETDOWN;
  118.     rcu_read_unlock_bh();

  120. out_kfree_skb:
  121.     kfree_skb(skb);
  122.     return rc;
  123. out:
  124.     rcu_read_unlock_bh();
  125.     return rc;
  126. }
我们这里说一下q - >enqueue ,它到底为真还是空呢？

点击(此处)折叠或打开

  1. txq = dev_pick_tx(dev, skb);
  2.     q = rcu_dereference(txq->qdisc);

点击(此处)折叠或打开

  1. static struct netdev_queue *dev_pick_tx(struct net_device *dev,
  2.                     struct sk_buff *skb)
  3. {
  4.     const struct net_device_ops *ops = dev->netdev_ops;
  5.     u16 queue_index = 0;

  7.     if (ops->ndo_select_queue)
  8.         queue_index = ops->ndo_select_queue(dev, skb);
  9.     else if (dev->real_num_tx_queues > 1)
  10.         queue_index = skb_tx_hash(dev, skb);

  12.     skb_set_queue_mapping(skb, queue_index);
  13.     return netdev_get_tx_queue(dev, queue_index);
  14. }
这里很明显是获取tx qdisc. 而ops我们如果看过网卡驱动，就知道默认很少有人去初始化.ndo_select_queue,
而dev - >real_num_tx_queues在前面文章中我们知道默认初始化为1. 所以这个函数的返回值是：
&dev->_tx[index]; // 而index明显是0 . 也是说是_tx数组的第一个元素.
我们回想到设备注册函数中的dev_init_scheduler就明白了.默认初始化qdisc是noop_qdisc
在sch_generic.c中

点击(此处)折叠或打开

  1. struct Qdisc noop_qdisc = {
  2.     .enqueue    =    noop_enqueue,
  3.     .dequeue    =    noop_dequeue,
  4.     .flags        =    TCQ_F_BUILTIN,
  5.     .ops        =    &noop_qdisc_ops,
  6.     .list        =    LIST_HEAD_INIT(noop_qdisc.list),
  7.     .q.lock        =    __SPIN_LOCK_UNLOCKED(noop_qdisc.q.lock),
  8.     .dev_queue    =    &noop_netdev_queue,
  9. }
当然后来，在dev_open的时候，里面有

点击(此处)折叠或打开

  1. /*
  2.          *    Wakeup transmit queue engine
  3.          */
  4.         dev_activate(dev);
又重新初始化了.

点击(此处)折叠或打开

  1. void dev_activate(struct net_device *dev)
  2. {
  3.     int need_watchdog;

  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.      */

  11.     if (dev->qdisc == &noop_qdisc)
  12.         attach_default_qdiscs(dev);

  14.     if (!netif_carrier_ok(dev))
  15.         /* Delay activation until next carrier-on event */
  16.         return;

  18.     need_watchdog = 0;
  19.     netdev_for_each_tx_queue(dev, transition_one_qdisc, &need_watchdog);
  20.     transition_one_qdisc(dev, &dev->rx_queue, NULL);

  22.     if (need_watchdog) {
  23.         dev->trans_start = jiffies;
  24.         dev_watchdog_up(dev);
  25.     }
  26. }
我们看看 attach_default_qdiscs (dev ) ;

点击(此处)折叠或打开

  1. static void attach_default_qdiscs(struct net_device *dev)
  2. {
  3.     struct netdev_queue *txq;
  4.     struct Qdisc *qdisc;

  6.     txq = netdev_get_tx_queue(dev, 0);

  8.     if (!netif_is_multiqueue(dev) || dev->tx_queue_len == 0) {
  9.         netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
  10.         dev->qdisc = txq->qdisc_sleeping;
  11.         atomic_inc(&dev->qdisc->refcnt);
  12.     } else {
  13.         qdisc = qdisc_create_dflt(dev, txq, &mq_qdisc_ops, TC_H_ROOT);
  14.         if (qdisc) {
  15.             qdisc->ops->attach(qdisc);
  16.             dev->qdisc = qdisc;
  17.         }
  18.     }
  19. }
这里有初始化为了mq_qdisc_ops.而它的enqueue函数是：
pfifo_enqueue：//sch_fifo.c 

点击(此处)折叠或打开

  1. static int pfifo_enqueue(struct sk_buff *skb, struct Qdisc* sch)
  2. {
  3.     struct fifo_sched_data *q = qdisc_priv(sch);

  5.     if (likely(skb_queue_len(&sch->q) q->limit))
  6.         return qdisc_enqueue_tail(skb, sch);

  8.     return qdisc_reshape_fail(skb, sch);
  9. }
所以会进入：

点击(此处)折叠或打开

  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.     int rc;

  8.     spin_lock(root_lock);
  9.     if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {  // qdisc 没有激活，当然不可能了，前面dev_open的时候~。~
  10.         kfree_skb(skb);
  11.         rc = NET_XMIT_DROP;
  12.     } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&     //  预留的一些操作，暂时我也没看懂，但是从qdis_qlen可以知道qlen为空才会进入....
  13.          !test_and_set_bit(__QDISC_STATE_RUNNING, &q->state)) {
  14.         /*
  15.          * This is a work-conserving queue; there are no old skbs
  16.          * waiting to be sent out; and the qdisc is not running -
  17.          * xmit the skb directly.
  18.          */
  19.         __qdisc_update_bstats(q, skb->len);
  20.         if (sch_direct_xmit(skb, q, dev, txq, root_lock))
  21.             __qdisc_run(q);
  22.         else
  23.             clear_bit(__QDISC_STATE_RUNNING, &q->state);

  25.         rc = NET_XMIT_SUCCESS;
  26.     } else { //正常进入这里.
  27.         rc = qdisc_enqueue_root(skb, q);
  28.         qdisc_run(q);
  29.     }
  30.     spin_unlock(root_lock);

  32.     return rc;
  33. }
qdisc_enqueue_root 会调用enqueue加入队列,然后调用qdisc_run .它设置队列状态为running然后调用：

点击(此处)折叠或打开

  1. void __qdisc_run(struct Qdisc *q)
  2. {
  3.     unsigned long start_time = jiffies;

  5.     while (qdisc_restart(q)) {
  6.         /*
  7.          * Postpone processing if
  8.          * 1. another process needs the CPU;
  9.          * 2. we've been doing it for too long.
  10.          */
  11.         if (need_resched() || jiffies != start_time) {
  12.             __netif_schedule(q);
  13.             break;
  14.         }
  15.     }

  17.     clear_bit(__QDISC_STATE_RUNNING, &q->state);
  18. }
这里先说下while内的代码. 看注释我们明白,需要延迟处理呗. 然后调用__netif_schedule。

点击(此处)折叠或打开

  1. void __netif_schedule(struct Qdisc *q)
  2. {
  3.     if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
  4.         __netif_reschedule(q);
  5. }

点击(此处)折叠或打开

  1. static inline void __netif_reschedule(struct Qdisc *q)
  2. {
  3.     struct softnet_data *sd;
  4.     unsigned long flags;

  6.     local_irq_save(flags);
  7.     sd = &__get_cpu_var(softnet_data);
  8.     q->next_sched = sd->output_queue;
  9.     sd->output_queue = q;
  10.     raise_softirq_irqoff(NET_TX_SOFTIRQ);
  11.     local_irq_restore(flags);
  12. }
看到上面的代码我们是否明白点什么，对，就是软中断发送中断的调用处. 当然关于rx软中断前面napi机制里已经说的很清楚了.

点击(此处)折叠或打开

  1. static void net_tx_action(struct softirq_action *h)
  2. {
  3.     struct softnet_data *sd = &__get_cpu_var(softnet_data);

  5.     if (sd->completion_queue) {   //已经发送完的报文，但是buff还没释放
  6.         struct sk_buff *clist;

  8.         local_irq_disable();
  9.         clist = sd->completion_queue;
  10.         sd->completion_queue = NULL;
  11.         local_irq_enable();

  13.         while (clist) {
  14.             struct sk_buff *skb = clist;
  15.             clist = clist->next;

  17.             WARN_ON(atomic_read(&skb->users));
  18.             __kfree_skb(skb);
  19.         }
  20.     }

  22.     if (sd->output_queue) {
  23.         struct Qdisc *head;

  25.         local_irq_disable();
  26.         head = sd->output_queue;
  27.         sd->output_queue = NULL;
  28.         local_irq_enable();

  30.         while (head) {
  31.             struct Qdisc *q = head;
  32.             spinlock_t *root_lock;

  34.             head = head->next_sched;

  36.             root_lock = qdisc_lock(q);
  37.             if (spin_trylock(root_lock)) {
  38.                 smp_mb__before_clear_bit();
  39.                 clear_bit(__QDISC_STATE_SCHED,
  40.                      &q->state);
  41.                 qdisc_run(q);
  42.                 spin_unlock(root_lock);
  43.             } else {
  44.                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
  45.                      &q->state)) {
  46.                     __netif_reschedule(q);
  47.                 } else {
  48.                     smp_mb__before_clear_bit();
  49.                     clear_bit(__QDISC_STATE_SCHED,
  50.                          &q->state);
  51.                 }
  52.             }
  53.         }
  54.     }
  55. }
在处理延迟的output_queue时，最后又调用到qdisc_run. 本质都会调用 qdisc_restart. 直到数据发送完.

点击(此处)折叠或打开

  1. /*
  2.  * NOTE: Called under qdisc_lock(q) with locally disabled BH.
  3.  *
  4.  * __QDISC_STATE_RUNNING guarantees only one CPU can process
  5.  * this qdisc at a time. qdisc_lock(q) serializes queue accesses for
  6.  * this queue.
  7.  *
  8.  * netif_tx_lock serializes accesses to device driver.
  9.  *
  10.  * qdisc_lock(q) and netif_tx_lock are mutually exclusive,
  11.  * if one is grabbed, another must be free.
  12.  *
  13.  * Note, that this procedure can be called by a watchdog timer
  14.  *
  15.  * Returns to the caller:
  16.  *                0 - queue is empty or throttled.
  17.  *                >0 - queue is not empty.
  18.  *
  19.  */
  20. static inline int qdisc_restart(struct Qdisc *q)
  21. {
  22.     struct netdev_queue *txq;
  23.     struct net_device *dev;
  24.     spinlock_t *root_lock;
  25.     struct sk_buff *skb;

  27.     /* Dequeue packet */
  28.     skb = dequeue_skb(q);
  29.     if (unlikely(!skb))
  30.         return 0;

  32.     root_lock = qdisc_lock(q);
  33.     dev = qdisc_dev(q);
  34.     txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));

  36.     return sch_direct_xmit(skb, q, dev, txq, root_lock);
  37. }
这里我们看到了dequeue函数的调用，它就是qdisc生效的地方，具体不多说.然后是直接 sch_direct_xmit发送

点击(此处)折叠或打开

  1. /*
  2.  * Transmit one skb, and handle the return status as required. Holding the
  3.  * __QDISC_STATE_RUNNING bit guarantees that only one CPU can execute this
  4.  * function.
  5.  *
  6.  * Returns to the caller:
  7.  *                0 - queue is empty or throttled.
  8.  *                >0 - queue is not empty.
  9.  */
  10. int sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
  11.          struct net_device *dev, struct netdev_queue *txq,
  12.          spinlock_t *root_lock)
  13. {
  14.     int ret = NETDEV_TX_BUSY;

  16.     /* And release qdisc */
  17.     spin_unlock(root_lock);

  19.     HARD_TX_LOCK(dev, txq, smp_processor_id());
  20.     if (!netif_tx_queue_stopped(txq) &&
  21.      !netif_tx_queue_frozen(txq))
  22.         ret = dev_hard_start_xmit(skb, dev, txq);
  23.     HARD_TX_UNLOCK(dev, txq);

  25.     spin_lock(root_lock);

  27.     switch (ret) {
  28.     case NETDEV_TX_OK:
  29.         /* Driver sent out skb successfully */
  30.         ret = qdisc_qlen(q);
  31.         break;

  33.     case NETDEV_TX_LOCKED:
  34.         /* Driver try lock failed */
  35.         ret = handle_dev_cpu_collision(skb, txq, q);
  36.         break;

  38.     default:
  39.         /* Driver returned NETDEV_TX_BUSY - requeue skb */
  40.         if (unlikely (ret != NETDEV_TX_BUSY && net_ratelimit()))
  41.             printk(KERN_WARNING "BUG %s code %d qlen %d\n",
  42.              dev->name, ret, q->q.qlen);

  44.         ret = dev_requeue_skb(skb, q);
  45.         break;
  46.     }

  48.     if (ret && (netif_tx_queue_stopped(txq) ||
  49.          netif_tx_queue_frozen(txq)))
  50.         ret = 0;

  52.     return ret;
  53. }
这个函数有几个工作：
1.dev_hard_start_xmit  直接调用网卡驱动发送出去
2.根据第一步的返回值，继续处理，如果发送失败，又分处理
3.如果是locked ，那么就调用冲突处理
4.其他重新入队列继续发送.
基本又重新循环了，直到数据报文发送成功或者丢弃.

点击(此处)折叠或打开

  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;

  7.     if (likely(!skb->next)) {
  8.         if (!list_empty(&ptype_all))
  9.             dev_queue_xmit_nit(skb, dev);    //  嗅探器

  11.         if (netif_needs_gso(dev, skb)) {
  12.             if (unlikely(dev_gso_segment(skb)))
  13.                 goto out_kfree_skb;
  14.             if (skb->next)
  15.                 goto gso;
  16.         }

  18.         /*
  19.          * If device doesnt need skb->dst, release it right now while
  20.          * its hot in this cpu cache
  21.          */
  22.         if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
  23.             skb_dst_drop(skb);

  25.         rc = ops->ndo_start_xmit(skb, dev);      //调用网卡驱动发送
  26.         if (rc == NETDEV_TX_OK)
  27.             txq_trans_update(txq);
  28.         /*
  29.          * TODO: if skb_orphan() was called by
  30.          * dev->hard_start_xmit() (for example, the unmodified
  31.          * igb driver does that; bnx2 doesn't), then
  32.          * skb_tx_software_timestamp() will be unable to send
  33.          * back the time stamp.
  34.          *
  35.          * How can this be prevented? Always create another
  36.          * reference to the socket before calling
  37.          * dev->hard_start_xmit()? Prevent that skb_orphan()
  38.          * does anything in dev->hard_start_xmit() by clearing
  39.          * the skb destructor before the call and restoring it
  40.          * afterwards, then doing the skb_orphan() ourselves?
  41.          */
  42.         return rc;
  43.     }

  45. gso:
  46.     do {
  47.         struct sk_buff *nskb = skb->next;

  49.         skb->next = nskb->next;
  50.         nskb->next = NULL;

  52.         /*
  53.          * If device doesnt need nskb->dst, release it right now while
  54.          * its hot in this cpu cache
  55.          */
  56.         if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
  57.             skb_dst_drop(nskb);

  59.         rc = ops->ndo_start_xmit(nskb, dev);     //调用网卡驱动发送
  60.         if (unlikely(rc != NETDEV_TX_OK)) {
  61.             nskb->next = skb->next;
  62.             skb->next = nskb;
  63.             return rc;
  64.         }
  65.         txq_trans_update(txq);
  66.         if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
  67.             return NETDEV_TX_BUSY;
  68.     } while (skb->next);

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

  72. out_kfree_skb:
  73.     kfree_skb(skb);
  74.     return NETDEV_TX_OK;
  75. }
这个函数主要功能是如果设置了嗅探器，则 dev_queue_xmit_nit复制一份，这个在前面接收的时候也说到过，它这里查询ptype_all链表，注册的类型是eth_all

点击(此处)折叠或打开

  1. /*
  2.  *    Support routine. Sends outgoing frames to any network
  3.  *    taps currently in use.
  4.  */

  6. static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
  7. {
  8.     struct packet_type *ptype;

  10. #ifdef CONFIG_NET_CLS_ACT
  11.     if (!(skb->tstamp.tv64 && (G_TC_FROM(skb->tc_verd) & AT_INGRESS)))
  12.         net_timestamp(skb);
  13. #else
  14.     net_timestamp(skb);
  15. #endif

  17.     rcu_read_lock();
  18.     list_for_each_entry_rcu(ptype, &ptype_all, list) {
  19.         /* Never send packets back to the socket
  20.          * they originated from - MvS (miquels@drinkel.ow.org)
  21.          */
  22.         if ((ptype->dev == dev || !ptype->dev) &&
  23.          (ptype->af_packet_priv == NULL ||
  24.          (struct sock *)ptype->af_packet_priv != skb->sk)) {
  25.             struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
  26.             if (!skb2)
  27.                 break;

  29.             /* skb->nh should be correctly
  30.              set by sender, so that the second statement is
  31.              just protection against buggy protocols.
  32.              */
  33.             skb_reset_mac_header(skb2);

  35.             if (skb_network_header(skb2) skb2->data ||
  36.              skb2->network_header > skb2->tail) {
  37.                 if (net_ratelimit())
  38.                     printk(KERN_CRIT "protocol %04x is "
  39.                      "buggy, dev %s\n",
  40.                      skb2->protocol, dev->name);
  41.                 skb_reset_network_header(skb2);
  42.             }

  44.             skb2->transport_header = skb2->network_header;
  45.             skb2->pkt_type = PACKET_OUTGOING;
  46.             ptype->func(skb2, skb->dev, ptype, skb->dev);
  47.         }
  48.     }
  49.     rcu_read_unlock();
  50. }
说了这么多，我们看看没有队列的设备，

点击(此处)折叠或打开

  1. /* The device has no queue. Common case for software devices:
  2.      loopback, all the sorts of tunnels...

  4.      Really, it is unlikely that netif_tx_lock protection is necessary
  5.      here. (f.e. loopback and IP tunnels are clean ignoring statistics
  6.      counters.)
  7.      However, it is possible, that they rely on protection
  8.      made by us here.

  10.      Check this and shot the lock. It is not prone from deadlocks.
  11.      Either shot noqueue qdisc, it is even simpler 8)
  12.      */
  13.     if (dev->flags & IFF_UP) {
当然设备必须是开启的，up状态，典型的例子就是回环设备. 它没有队列的处理，而是直接把包发送出去，如果发送失败也不会重新发送，而是直接丢弃了.

这里我们只是大致说了下帧从ip层到驱动层的发送，没有涉及ip以上和网卡驱动的具体函数. 网卡驱动可以具体看驱动实例即可.关于流量控制这里只是简单说了一下调用流程，
具体分析还需要结合tc命令以及iptables详细分析. 到这里已经和帧的接收圆了起来.




     
文章标签：
网络协议
网络性能优化
大数据
云之大者
目录
相关文章
小鲸云
|
5月前
|
人工智能 Linux API
OpenClaw+本地模型无限Token实战：阿里云/本地部署+Ollama+百炼API配置指南
OpenClaw 配合本地小模型，可实现**完全免费、无限Token、数据不出本地、断网可用**的私人AI助手，彻底告别订阅费、额度限制与隐私泄露风险。本文完整覆盖：OpenClaw 2026阿里云/Windows11/MacOS/Linux全平台部署、Ollama快速搭建本地模型、阿里云百炼Coding Plan免费大模型配置、本地+云端双模型自动切换方案，所有命令可直接复制，全程无付费环节、无冗余表述，适合追求低成本、高隐私、高自由度的个人与轻量化团队。
小鲸云
2273 15
顾北Ccc
|
4月前
|
存储 安全 Java
Java 基础数据类型完全指南
本文详解Java 8种基本数据类型（byte/short/int/long/float/double/char/boolean）的取值范围、默认值、使用场景及注意事项，涵盖字面量规范、自动/强制类型转换、包装类与装箱拆箱机制，并强调金额计算须用BigDecimal、内存优化等最佳实践。
顾北Ccc
637 1
RossyYan
|
存储 C语言 C++
【C++数据结构——栈与队列】顺序栈的基本运算（头歌实践教学平台习题）【合集】
本关任务：编写一个程序实现顺序栈的基本运算。开始你的任务吧，祝你成功！​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 1.初始化栈 概念：初始化栈是为栈的使用做准备，包括分配内存空间（如果是动态分配）和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈，通常需要定义一个数组来存储栈元素，并设置一个变量来记录栈顶位置；对于链式栈，需要定义节点结构，包含数据域和指针域，同时初始化栈顶指针。 示例（顺序栈）： 以下是一个简单的顺序栈初始化示例，假设用C语言实现，栈中存储
RossyYan
1194 77
刘大猫.
|
XML Java 数据库连接
十一、MyBatis的逆向工程
十一、MyBatis的逆向工程
刘大猫.
498 6
十一、MyBatis的逆向工程
布客飞龙
|
网络协议 算法 关系型数据库
MySQL8 中文参考（八十四）（5）
MySQL8 中文参考（八十四）
布客飞龙
560 5
技术员阿伟
|
数据采集 自然语言处理 监控
《一文破解！自然语言处理论文实验复现秘籍》
在自然语言处理（NLP）领域，复现学术论文实验是将理论转化为实践的关键。前期需深入研读论文、收集数据与代码资源；搭建环境时要配置开发工具和预处理数据；模型训练中注重架构实现、优化器选择及训练监控；最后通过评估指标、结果对比与可视化分析确保复现成功。这一过程不仅验证研究成果，还提升技术能力，推动NLP领域的发展。
技术员阿伟
564 16
龙大吉
|
存储 缓存 监控
Docker容器性能调优的关键技巧，涵盖CPU、内存、网络及磁盘I/O的优化策略，结合实战案例，旨在帮助读者有效提升Docker容器的性能与稳定性。
本文介绍了Docker容器性能调优的关键技巧，涵盖CPU、内存、网络及磁盘I/O的优化策略，结合实战案例，旨在帮助读者有效提升Docker容器的性能与稳定性。
龙大吉
1532 8
开发工程师
|
SQL Java 数据库连接
求求你别乱脱敏了！MyBatis 插件 + 注解轻松实现数据脱敏，So easy~!
求求你别乱脱敏了！MyBatis 插件 + 注解轻松实现数据脱敏，So easy~!
开发工程师
1143 0
漏刻有时
|
数据可视化
Echarts动态数据可视化学习(2)柱状图和折线图的动态数据更新
Echarts动态数据可视化学习(2)柱状图和折线图的动态数据更新
漏刻有时
658 0
沐雨风栉
|
存储 算法 Java
趣味算法：滑动窗口算法的理解与应用
前言 在编程和数据结构中，滑动窗口算法是一种常见的解决问题的方法。它主要用于处理涉及连续或固定长度子数组、子序列或子字符串的问题。本文将深入探讨滑动窗口算法，包括其基本概念、应用场景、基本步骤以及具体的Java代码实践。
沐雨风栉
1104 0

热门文章

最新文章

  • 1
    杜蕾斯的双11：一场曼伦营销理论体系与阿里云数据中台相结合的实践
  • 2
    数据技术工程师成长之路
  • 3
    【01】完成新年倒计时页面-蛇年新年快乐倒计时领取礼物放烟花html代码优雅草科技央千澈写采用html5+div+CSS+JavaScript-优雅草卓伊凡-做一条关于新年的代码分享给你们-为了C站的分拼一下子
  • 4
    支付宝客户端体验度量与诊断
  • 5
    尝鲜阿里云容器服务Kubernetes 1.16，共享TensorFlow实验室《二》--共享GPU的弹性
  • 6
    第143天：渐进增强和优雅降级之间的不同
  • 7
    管理表空间和数据文件
  • 8
    cocos2d-2.1rc0-x-2.1.3中有一个好用的CCRemoveSelf
  • 9
    【Xamarin.Forms】数据绑定的力量你可能无法使用（还）
  • 10
    基于 WPF 平台的 ActiveReports Viewer控件
  • 1
    阿里云 ESSD AutoPL 云盘完整指南：性能分层、计费规则与控制台操作
    57
  • 2
    同城O2O系统开发趋势分析：本地生活数字化下的新机会
    46
  • 3
    【AI】Agent 全栈进阶｜系统化学习路线专题
    293
  • 4
    创业团队开发聊天应用，需要解决哪些 IM 技术难题？
    59
  • 5
    互联网医院系统开发：HIS接口、电子病历与处方数据同步设计
    53
  • 6
    RAG系统测试实战：如何验证企业知识库AI助手是否可靠？
    30
  • 7
    风控系统如何从“管交易”延伸到“管IP”？IP风险画像落地指南
    62
  • 8
    LLM测试体系设计：从Prompt测试到模型质量评估的完整实践
    31
  • 9
    【AI时代软件项目管理系列】2. 从工具到数字员工：AI 在项目团队中的角色演进
    65
  • 10
    阿里云服务器弹性临时盘是什么？哪些ECS支持弹性临时盘？
    62

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！