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

帧的发送

2014-05-15 857
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：       上一节我们说了帧的接收，自然有收就有发，并且也很少说关于发送的东西，这里我们就分析下帧的发送.      参考内核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详细分析. 到这里已经和帧的接收圆了起来.




     
文章标签：
网络协议
网络性能优化
大数据
云之大者
目录
相关文章
微帧科技Visionular
|
29天前
|
编解码 缓存 算法
视频帧里的I帧、P帧、B帧是什么？
I帧、P帧、B帧是视频编码中的基本概念。I帧是帧内编码帧，无需参考其他帧即可解码；P帧是前向预测编码帧，基于前一帧解码；B帧是双向预测编码帧，基于前后帧解码。IDR帧是一种特殊的I帧，用于即时解码刷新，防止错误传播。GOP（Group of Pictures）是一组连续的画面，第一个帧为I帧，gop_size设置越大，画质越好，但解码延迟增加。OpenGOP允许GOP间的帧依赖，而ClosedGOP则不允许。DTS（解码时间戳）和PTS（显示时间戳）分别用于解码和显示时间控制。
微帧科技Visionular
62 1
爱叨叨的小嘟
|
7月前
|
网络协议
计算机网络四种帧介绍，广播帧、未知帧、同网帧、异网帧
计算机网络四种帧介绍，广播帧、未知帧、同网帧、异网帧
爱叨叨的小嘟
165 1
不脱发的程序猿
|
IDE 自动驾驶 安全
CAN FD网络中每秒最多可以发送多少帧报文？
随着总线技术在汽车电子领域越来越广泛和深入的应用，特别是自动驾驶技术的迅速发展，汽车电子对总线宽度和数据传输速率的要求也越来也高，传统CAN（1MBit/s，8Bytes Payload）已难以满足日益增加的需求。
不脱发的程序猿
408 0
游客scyturumm2baa
|
算法
为什么发出去的2833 RTP流不能收号
为什么发出去的2833 RTP流不能收号
游客scyturumm2baa
189 0
为什么发出去的2833 RTP流不能收号
OpenMMLab
|
机器学习/深度学习 并行计算 算法
MMFlow ：帧与帧之间的追光者
光流（Optical Flow），字面理解为“光的流动”，更准确的说法为：时变图像上的二维运动场，是视频数据的重要视觉线索，在动作识别、视频理解、视频分割、目标跟踪以及全景拼接等领域，都有广泛应用。
OpenMMLab
628 0
MMFlow ：帧与帧之间的追光者
韩曙亮
|
机器学习/深度学习 缓存
【计算机网络】数据链路层 : 选择重传协议 SR ( 帧分类 | “发送方“ 确认帧、超时事件 | “接受方“ 接收帧机制 | 滑动窗口长度 | 计算示例 )★
【计算机网络】数据链路层 : 选择重传协议 SR ( 帧分类 | “发送方“ 确认帧、超时事件 | “接受方“ 接收帧机制 | 滑动窗口长度 | 计算示例 )★
韩曙亮
603 0
韩曙亮
|
机器学习/深度学习
【计算机网络】数据链路层 : 后退 N 帧协议 GBN ( 滑动窗口 | 发送窗口长度 | “发送方“ 累计确认、超时机制 | “接收方“ 按序接收、确认帧发送机制 | 计算示例 )★（二）
【计算机网络】数据链路层 : 后退 N 帧协议 GBN ( 滑动窗口 | 发送窗口长度 | “发送方“ 累计确认、超时机制 | “接收方“ 按序接收、确认帧发送机制 | 计算示例 )★（二）
韩曙亮
745 0
韩曙亮
|
机器学习/深度学习 缓存
【计算机网络】数据链路层 : 后退 N 帧协议 GBN ( 滑动窗口 | 发送窗口长度 | “发送方“ 累计确认、超时机制 | “接收方“ 按序接收、确认帧发送机制 | 计算示例 )★（一）
【计算机网络】数据链路层 : 后退 N 帧协议 GBN ( 滑动窗口 | 发送窗口长度 | “发送方“ 累计确认、超时机制 | “接收方“ 按序接收、确认帧发送机制 | 计算示例 )★（一）
韩曙亮
679 0
韩曙亮
【计算机网络】数据链路层 : 停止-等待协议 ( 无差错情况 | 有差错情况 | 帧丢失 | 帧出错 | ACK 确认帧丢失 | ACK 确认帧延迟 | 信道利用率公式 | 信道利用率计算 )★（一）
【计算机网络】数据链路层 : 停止-等待协议 ( 无差错情况 | 有差错情况 | 帧丢失 | 帧出错 | ACK 确认帧丢失 | ACK 确认帧延迟 | 信道利用率公式 | 信道利用率计算 )★（一）
韩曙亮
331 0
韩曙亮
|
SQL
【计算机网络】数据链路层 : 停止-等待协议 ( 无差错情况 | 有差错情况 | 帧丢失 | 帧出错 | ACK 确认帧丢失 | ACK 确认帧延迟 | 信道利用率公式 | 信道利用率计算 )★（二）
【计算机网络】数据链路层 : 停止-等待协议 ( 无差错情况 | 有差错情况 | 帧丢失 | 帧出错 | ACK 确认帧丢失 | ACK 确认帧延迟 | 信道利用率公式 | 信道利用率计算 )★（二）
韩曙亮
437 0

热门文章

最新文章

  • 1
    手把手教你用Python实践深度学习
  • 2
    新手阿里云服务器操作指南（图文教程）
  • 3
    Maven之多模块打包成一个jar包及assembly
  • 4
    使用let's encrypt申请免费的SSL证书
  • 5
    3种在Linux命令行查看图像的方法
  • 6
    Node.js 中流操作实践
  • 7
    [Spark][Python]Spark Python 索引页
  • 8
    How-to: 利用Visual Studio升级Windows Phone 7工程
  • 9
    vagrant初始登录失败的一般性解决方案
  • 10
    NFS Volume Provider（Part I） - 每天5分钟玩转 OpenStack（62）
  • 1
    技术实践 | 使用 PAI+LLaMA Factory 微调 Qwen2-VL 模型快速搭建专业领域知识问答机器人
    37
  • 2
    使用PaliGemma2构建多模态目标检测系统：从架构设计到性能优化的技术实践指南
    97
  • 3
    pyenv 管理多个 Python 版本(1)
    109
  • 4
    百度 SEO：不是玄学，是科学与艺术的 “恋爱”
    49
  • 5
    《C++与 MXNet：分布式训练与移动端部署的卓越融合》
    51
  • 6
    《C++：智能家居系统智能化跃升的强力助推器》
    37
  • 7
    《C++：自动驾驶车辆环境感知与决策控制的核心引擎》
    34
  • 8
    《docker高级篇（大厂进阶）：5.Docker-compose容器编排》包括是什么能干嘛去哪下、Compose核心概念、Compose使用三个步骤、Compose常用命令、Compose编排微服务
    42
  • 9
    SEO：网站的“流量秘籍”大公开
    29
  • 10
    《C++赋能自然语言处理：词向量模型的构建与应用》
    27

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • 使用WaitCondition与WaitConditionHandle进行信号通知
    • 下一篇
    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解