AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

帧的接收

2014-05-09 671
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：     关于帧的接收，其实在前面Napi机制中，我们已经能够明白大致流程，或者网卡驱动的流程. 但是这里仍要在说一下，注意一些细节，和系统的勾画一下画面.    其实这个流程挺乏味的，单线程，剧情单一你懂的~.
    关于帧的接收，其实在前面Napi机制中，我们已经能够明白大致流程，或者网卡驱动的流程. 但是这里仍要在说一下，注意一些细节，和系统的勾画一下画面.
   其实这个流程挺乏味的，单线程，剧情单一你懂的~.~  .
   我们就从中断说起，网卡由硬件MAC 和PHY构成，记得以前看x86中断机制的时候，记得里面讲过8259A中断控制器芯片，用来连接外设，以供cpu处理中断.关于中断的初始化，在系统启动的时候，甚至是汇编层面代码，初始化中断向量表等.当然在后来的init/main.c ，start_kernel依然有对中断的处理函数.
     参考内核 2.6.32.61 

点击(此处)折叠或打开

  1. /*
  2.  * do_IRQ handles all normal device IRQ's (the special
  3.  * SMP cross-CPU interrupts have their own specific
  4.  * handlers).
  5.  */
  6. void __irq_entry do_IRQ(unsigned int irq)
  7. {
  8.     irq_enter();
  9.     __DO_IRQ_SMTC_HOOK(irq);
  10.     generic_handle_irq(irq);
  11.     irq_exit();
  12. }
这是来自arch/mips/kernel/irq.c中的代码，（硬件架构是mips）
我们看到 generic_handle_irq ( irq ) ;它会根据irq查询中断向量表找到当初我们网卡驱动初始化时注册的中断历程

点击(此处)折叠或打开

  1. request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
  2.      const char *name, void *dev)
  3. {
  4.     return request_threaded_irq(irq, handler, NULL, flags, name, dev);
  5. }
include/linux/interrupt.h 中断注册函数api.
我们来看irq_exit:

点击(此处)折叠或打开

  1. /*
  2.  * Exit an interrupt context. Process softirqs if needed and possible:
  3.  */
  4. void irq_exit(void)
  5. {
  6.     account_system_vtime(current);
  7.     trace_hardirq_exit();
  8.     sub_preempt_count(IRQ_EXIT_OFFSET);
  9.     if (!in_interrupt() && local_softirq_pending())  // 判断是否已经退出中断，并且有挂起的软中断需要处理
  10.         invoke_softirq();

  12.     rcu_irq_exit();
  13. #ifdef CONFIG_NO_HZ
  14.     /* Make sure that timer wheel updates are propagated */
  15.     if (idle_cpu(smp_processor_id()) && !in_interrupt() && !need_resched())
  16.         tick_nohz_stop_sched_tick(0);
  17. #endif
  18.     preempt_enable_no_resched();
  19. }

点击(此处)折叠或打开

  1. #ifdef __ARCH_IRQ_EXIT_IRQS_DISABLED
  2. # define invoke_softirq()    __do_softirq()
  3. #else
  4. # define invoke_softirq()    do_softirq()
  5. #endif

点击(此处)折叠或打开

  1. /*
  2.  * We restart softirq processing MAX_SOFTIRQ_RESTART times,
  3.  * and we fall back to softirqd after that.
  4.  *
  5.  * This number has been established via experimentation.
  6.  * The two things to balance is latency against fairness -
  7.  * we want to handle softirqs as soon as possible, but they
  8.  * should not be able to lock up the box.
  9.  */
  10. #define MAX_SOFTIRQ_RESTART 10

  12. DEFINE_TRACE(softirq_raise);

  14. asmlinkage void __do_softirq(void)
  15. {
  16.     struct softirq_action *h;
  17.     __u32 pending;
  18.     int max_restart = MAX_SOFTIRQ_RESTART;
  19.     int cpu;

  21.     pending = local_softirq_pending();
  22.     account_system_vtime(current);

  24.     __local_bh_disable((unsigned long)__builtin_return_address(0));
  25.     lockdep_softirq_enter();

  27.     cpu = smp_processor_id();
  28. restart:
  29.     /* Reset the pending bitmask before enabling irqs */
  30.     set_softirq_pending(0);

  32.     local_irq_enable();

  34.     h = softirq_vec;

  36.     do {
  37.         if (pending & 1) {
  38.             int prev_count = preempt_count();
  39.             kstat_incr_softirqs_this_cpu(h - softirq_vec);

  41.             trace_softirq_entry(h, softirq_vec);
  42.             h->action(h);
  43.             trace_softirq_exit(h, softirq_vec);
  44.             if (unlikely(prev_count != preempt_count())) {
  45.                 printk(KERN_ERR "huh, entered softirq %td %s %p"
  46.                  "with preempt_count %08x,"
  47.                  " exited with %08x?\n", h - softirq_vec,
  48.                  softirq_to_name[h - softirq_vec],
  49.                  h->action, prev_count, preempt_count());
  50.                 preempt_count() = prev_count;
  51.             }

  53.             rcu_bh_qs(cpu);
  54.         }
  55.         h++;
  56.         pending >>= 1;
  57.     } while (pending);

  59.     local_irq_disable();

  61.     pending = local_softirq_pending();
  62.     if (pending && --max_restart)
  63.         goto restart;

  65.     if (pending)
  66.         wakeup_softirqd();

  68.     lockdep_softirq_exit();

  70.     account_system_vtime(current);
  71.     _local_bh_enable();
  72. }
 __do_softirq它最终会调用接收软中断 net_rx_action ，关于软中断初始化是在 net_dev_init里

点击(此处)折叠或打开

  1. open_softirq(NET_TX_SOFTIRQ, net_tx_action);
  2.     open_softirq(NET_RX_SOFTIRQ, net_rx_action);
这里处理了大部分的软中断，但是还有一些不能及时处理，就需要wakeup_softirqd即唤醒 ksoftirqd这个守护进程,后续处理.它同样也是调用net_rx_action
我们回过头看看驱动里注册的XXX_isr :

点击(此处)折叠或打开

  1. void rxqueue_isr(BL_CPU_RX_QUEUE_ID_DTE queue_id)
  2. {
  3.     bl_api_ctrl_cpu_rx_queue_interrupt(queue_id,
  4.     CE_BL_INTERRUPT_ACTION_DISABLE);
  5.     napi_schedule(&global_napi);
  6.     return;
  7. }
这里只是随便举个例子，重点是里面的 napi_schedule ( & global_napi ) ; 我们看到isr几乎什么都没做，就马上退出了.
struct napi_struct global_napi;

点击(此处)折叠或打开

  1. /**
  2.  *    napi_schedule - schedule NAPI poll
  3.  *    @n: napi context
  4.  *
  5.  * Schedule NAPI poll routine to be called if it is not already
  6.  * running.
  7.  */
  8. static inline void napi_schedule(struct napi_struct *n)
  9. {
  10.     if (napi_schedule_prep(n))   //判断napi是否运行 
  11.         __napi_schedule(n);
  12. }

点击(此处)折叠或打开

  1. /**
  2.  *    napi_schedule_prep - check if napi can be scheduled
  3.  *    @n: napi context
  4.  *
  5.  * Test if NAPI routine is already running, and if not mark
  6.  * it as running. This is used as a condition variable
  7.  * insure only one NAPI poll instance runs. We also make
  8.  * sure there is no pending NAPI disable.
  9.  */
  10. static inline int napi_schedule_prep(struct napi_struct *n)
  11. {
  12.     return !napi_disable_pending(n) &&
  13.         !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
  14. }
上面这个函数的注释说的很清晰.主要判断napi的状态

点击(此处)折叠或打开

  1. /**
  2.  * __napi_schedule - schedule for receive
  3.  * @n: entry to schedule
  4.  *
  5.  * The entry's receive function will be scheduled to run
  6.  */
  7. void __napi_schedule(struct napi_struct *n)
  8. {
  9.     unsigned long flags;

  11.     trace_net_napi_schedule(n);

  13.     local_irq_save(flags);
  14.     list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
  15.     __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  16.     local_irq_restore(flags);
  17. }
而这个函数就是开启软中断，并把收到帧的设备加入到cpu接收poll链表.
cpu接收队列的定义和初始化也是在net_dev_init里。这里不多说，struct  softnet_data  .我们就看看软中断的历程吧

点击(此处)折叠或打开

  1. static void net_rx_action(struct softirq_action *h)
  2. {
  3.     struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
  4.     unsigned long time_limit = jiffies + 2;
  5.     int budget = netdev_budget;
  6.     void *have;

  8.     local_irq_disable();

  10.     while (!list_empty(list)) {    //查询链表直到空
  11.         struct napi_struct *n;
  12.         int work, weight;

  14.         /* If softirq window is exhuasted then punt.
  15.          * Allow this to run for 2 jiffies since which will allow
  16.          * an average latency of 1.5/HZ.
  17.          */
  18.         if (unlikely(budget = 0 || time_after(jiffies, time_limit)))    // 定时处理
  19.             goto softnet_break;

  21.         local_irq_enable();

  23.         /* Even though interrupts have been re-enabled, this
  24.          * access is safe because interrupts can only add new
  25.          * entries to the tail of this list, and only ->poll()
  26.          * calls can remove this head entry from the list.
  27.          */
  28.         n = list_first_entry(list, struct napi_struct, poll_list);

  30.         have = netpoll_poll_lock(n);

  32.         weight = n->weight;

  34.         /* This NAPI_STATE_SCHED test is for avoiding a race
  35.          * with netpoll's poll_napi(). Only the entity which
  36.          * obtains the lock and sees NAPI_STATE_SCHED set will
  37.          * actually make the ->poll() call. Therefore we avoid
  38.          * accidently calling ->poll() when NAPI is not scheduled.
  39.          */
  40.         work = 0;
  41.         if (test_bit(NAPI_STATE_SCHED, &n->state)) {
  42.             trace_net_napi_poll(n);
  43.             work = n->poll(n, weight);
  44.             trace_napi_poll(n);
  45.         }

  47.         WARN_ON_ONCE(work > weight);

  49.         budget -= work;

  51.         local_irq_disable();

  53.         /* Drivers must not modify the NAPI state if they
  54.          * consume the entire weight. In such cases this code
  55.          * still "owns" the NAPI instance and therefore can
  56.          * move the instance around on the list at-will.
  57.          */
  58.         if (unlikely(work == weight)) {
  59.             if (unlikely(napi_disable_pending(n))) {
  60.                 local_irq_enable();
  61.                 napi_complete(n);
  62.                 local_irq_disable();
  63.             } else
  64.                 list_move_tail(&n->poll_list, list);
  65.         }

  67.         netpoll_poll_unlock(have);
  68.     }
  69. out:
  70.     local_irq_enable();

  72. #ifdef CONFIG_NET_DMA
  73.     /*
  74.      * There may not be any more sk_buffs coming right now, so push
  75.      * any pending DMA copies to hardware
  76.      */
  77.     dma_issue_pending_all();
  78. #endif

  80.     return;

  82. softnet_break:
  83.     __get_cpu_var(netdev_rx_stat).time_squeeze++;
  84.     __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  85.     goto out;
  86. }
这个函数很明显，获取cpu接收poll链表.并查询处理，直到空.当然有时候这个链表或许很长，总不能让它一直执行吧，那其他进程什么的，难道喝西北风饿死么？！
我们看到代码有这样一句：

点击(此处)折叠或打开

  1. /* If softirq window is exhuasted then punt.
  2.          * Allow this to run for 2 jiffies since which will allow
  3.          * an average latency of 1.5/HZ.
  4.          */
  5.         if (unlikely(budget = 0 || time_after(jiffies, time_limit)))
  6.             goto softnet_break;
然后就是调用poll函数 ：
work = n->poll(n, weight);
它一般就是从dma或者队列缓冲区里读取数据包 ，到内存.然后传递到上层.
poll注册：
 netif_napi_add(dummy_dev, &global_napi, rxqueue_poll, 128);  
这里也仅仅是一个接口实例.仅供参考.

点击(此处)折叠或打开

  1. int rxqueue_poll(struct napi_struct *napi, int budget)
  2. {
  3.     int rx_packet_cnt = 0;
  4.     static int empty_count = 0;
        
            bl_api_ctrl_cpu_rx_queue_interrupt(param_queue_id,    //清中断
            CE_BL_INTERRUPT_ACTION_CLEAR);
  1.     while (rx_packet_cnt budget)    // 当有高速流量的时候,队列满一次处理不完的时候，poll返回值等于weight. 
  2.     {
  3.     if (netdev_read_packet())   //获取数据包,然后到上层
  4.     {
  5.      empty_count++;
  6.      break;
  7.     }
  8.     rx_packet_cnt++;
  9.     }
  10.     if(rx_packet_cnt budget && empty_count > 1)
  11.     {
  12.     empty_count = 0;
  13.     napi_complete(napi); 
  14.     bl_api_ctrl_cpu_rx_queue_interrupt(param_queue_id,                    //恢复中断
  15.      CE_BL_INTERRUPT_ACTION_ENABLE);
  16.     }
  17.     return rx_packet_cnt;
  18. }
在队列满的时候，即poll返回值等于weight时，由于这个时候关闭了中断，所以在这里停留的时间越久，相对丢包就越多.也是网络性能的一个参考点。
这里面会把数据帧传给netif_recevice_skb

点击(此处)折叠或打开

  1. /**
  2.  *    netif_receive_skb - process receive buffer from network
  3.  *    @skb: buffer to process
  4.  *
  5.  *    netif_receive_skb() is the main receive data processing function.
  6.  *    It always succeeds. The buffer may be dropped during processing
  7.  *    for congestion control or by the protocol layers.
  8.  *
  9.  *    This function may only be called from softirq context and interrupts
  10.  *    should be enabled.
  11.  *
  12.  *    Return values (usually ignored):
  13.  *    NET_RX_SUCCESS: no congestion
  14.  *    NET_RX_DROP: packet was dropped
  15.  */
  16. int netif_receive_skb(struct sk_buff *skb)
  17. {
  18.     struct packet_type *ptype, *pt_prev;
  19.     struct net_device *orig_dev;
  20.     struct net_device *master;
  21.     struct net_device *null_or_orig;
  22.     struct net_device *null_or_bond;
  23.     int ret = NET_RX_DROP;
  24.     __be16 type;

  26.     if (!skb->tstamp.tv64)
  27.         net_timestamp(skb);

  29.     if (vlan_tx_tag_present(skb) && vlan_hwaccel_do_receive(skb))
  30.         return NET_RX_SUCCESS;

  32.     /* if we've gotten here through NAPI, check netpoll */
  33.     if (netpoll_receive_skb(skb))
  34.         return NET_RX_DROP;

  36.     trace_net_dev_receive(skb);

  38.     if (!skb->skb_iif)
  39.         skb->skb_iif = skb->dev->ifindex;

  41.     null_or_orig = NULL;
  42.     orig_dev = skb->dev;
  43.     master = ACCESS_ONCE(orig_dev->master);
  44.     if (master) {
  45.         if (skb_bond_should_drop(skb, master))
  46.             null_or_orig = orig_dev; /* deliver only exact match */
  47.         else
  48.             skb->dev = master;
  49.     }

  51.     __get_cpu_var(netdev_rx_stat).total++;

  53.     skb_reset_network_header(skb);
  54.     skb_reset_transport_header(skb);
  55.     skb->mac_len = skb->network_header - skb->mac_header;

  57.     pt_prev = NULL;

  59.     rcu_read_lock();

  61. #ifdef CONFIG_NET_CLS_ACT                                 //qdisc  入口队列处理
  62.     if (skb->tc_verd & TC_NCLS) {
  63.         skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
  64.         goto ncls;
  65.     }
  66. #endif

  68.     list_for_each_entry_rcu(ptype, &ptype_all, list) {
  69.         if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
  70.          ptype->dev == orig_dev) {
  71.             if (pt_prev)
  72.                 ret = deliver_skb(skb, pt_prev, orig_dev);
  73.             pt_prev = ptype;
  74.         }
  75.     }

  77. #ifdef CONFIG_NET_CLS_ACT                          ////qdisc  入口队列处理
  78.     skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
  79.     if (!skb)
  80.         goto out;
  81. ncls:
  82. #endif

  84.     skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);    // bridge 处理
  85.     if (!skb)
  86.         goto out;
  87.     skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);    //macvlan 
  88.     if (!skb)
  89.         goto out;

  91.     /*
  92.      * Make sure frames received on VLAN interfaces stacked on
  93.      * bonding interfaces still make their way to any base bonding
  94.      * device that may have registered for a specific ptype. The
  95.      * handler may have to adjust skb->dev and orig_dev.
  96.      */
  97.     null_or_bond = NULL;
  98.     if ((skb->dev->priv_flags & IFF_802_1Q_VLAN) &&
  99.      (vlan_dev_real_dev(skb->dev)->priv_flags & IFF_BONDING)) {
  100.         null_or_bond = vlan_dev_real_dev(skb->dev);
  101.     }

  103.     type = skb->protocol;
  104.     list_for_each_entry_rcu(ptype,
  105.             &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
  106.         if (ptype->type == type && (ptype->dev == null_or_orig ||          //根据type查找相关的协议处理模块
  107.          ptype->dev == skb->dev || ptype->dev == orig_dev ||
  108.          ptype->dev == null_or_bond)) {
  109.             if (pt_prev)
  110.                 ret = deliver_skb(skb, pt_prev, orig_dev);
  111.             pt_prev = ptype;
  112.         }
  113.     }

  115.     if (pt_prev) {
  116.         ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
  117.     } else {
  118.         kfree_skb(skb);
  119.         /* Jamal, now you will not able to escape explaining
  120.          * me how you were going to use this. :-)
  121.          */
  122.         ret = NET_RX_DROP;
  123.     }

  125. out:
  126.     rcu_read_unlock();
  127.     return ret;
  128. }

我们先看两个链表的查询 ptype_all 和ptype_base. 前者是为嗅探做准备的，比如tcpdump工具分析包.后者就是具体的协议，真正发送给上层协议的.比如ip_rcv等.
对于ptype_all我们看看dev_add_pack就明白了：

点击(此处)折叠或打开

  1. /*******************************************************************************

  3.         Protocol management and registration routines

  5. *******************************************************************************/

  7. /*
  8.  *    Add a protocol ID to the list. Now that the input handler is
  9.  *    smarter we can dispense with all the messy stuff that used to be
  10.  *    here.
  11.  *
  12.  *     Protocol handlers, mangling input packets,
  13.  *    MUST BE last in hash buckets and checking protocol handlers
  14.  *    MUST start from promiscuous ptype_all chain in net_bh.
  15.  *    It is true now, do not change it.
  16.  *    Explanation follows: if protocol handler, mangling packet, will
  17.  *    be the first on list, it is not able to sense, that packet
  18.  *    is cloned and should be copied-on-write, so that it will
  19.  *    change it and subsequent readers will get broken packet.
  20.  *                            --ANK (980803)
  21.  */

  23. /**
  24.  *    dev_add_pack - add packet handler
  25.  *    @pt: packet type declaration
  26.  *
  27.  *    Add a protocol handler to the networking stack. The passed &packet_type
  28.  *    is linked into kernel lists and may not be freed until it has been
  29.  *    removed from the kernel lists.
  30.  *
  31.  *    This call does not sleep therefore it can not
  32.  *    guarantee all CPU's that are in middle of receiving packets
  33.  *    will see the new packet type (until the next received packet).
  34.  */

  36. void dev_add_pack(struct packet_type *pt)
  37. {
  38.     int hash;

  40.     spin_lock_bh(&ptype_lock);
  41.     if (pt->type == htons(ETH_P_ALL))
  42.         list_add_rcu(&pt->list, &ptype_all);
  43.     else {
  44.         hash = ntohs(pt->type) & PTYPE_HASH_MASK;
  45.         list_add_rcu(&pt->list, &ptype_base[hash]);
  46.     }
  47.     spin_unlock_bh(&ptype_lock);
  48. }
  49. EXPORT_SYMBOL(dev_add_pack);
我们看到只有协议类型是 ETH_P_ALL才会添加到ptype_all链表.
流量控制的核心代码在net/sched中.之前我们说过，当设备open时会调用dev_activate激活qdisc.
然后我们看#ifdef CONFIG_NET_CLS_ACT 的部分，这里是处理入口队列的部分，如果配置了入口队列规则或者其他，就会深入处理.大部分的功能发挥在了出口队列，流量控制tc--qos.

我们来看第一个判断：skb->tc_verd & TC_NCLS   默认情况下是没有人赋值skb->tc_verd 所以与的结果肯定是0 .

点击(此处)折叠或打开

  1. #ifdef CONFIG_NET_CLS_ACT
  2. /* TODO: Maybe we should just force sch_ingress to be compiled in
  3.  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
  4.  * a compare and 2 stores extra right now if we dont have it on
  5.  * but have CONFIG_NET_CLS_ACT
  6.  * NOTE: This doesnt stop any functionality; if you dont have
  7.  * the ingress scheduler, you just cant add policies on ingress.
  8.  *
  9.  */
  10. static int ing_filter(struct sk_buff *skb)
  11. {
  12.     struct net_device *dev = skb->dev;
  13.     u32 ttl = G_TC_RTTL(skb->tc_verd);
  14.     struct netdev_queue *rxq;
  15.     int result = TC_ACT_OK;
  16.     struct Qdisc *q;

  18.     if (MAX_RED_LOOP ttl++) {
  19.         printk(KERN_WARNING
  20.          "Redir loop detected Dropping packet (%d->%d)\n",
  21.          skb->iif, dev->ifindex);
  22.         return TC_ACT_SHOT;
  23.     }

  25.     skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
  26.     skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);

  28.     rxq = &dev->rx_queue;

  30.     q = rxq->qdisc;
  31.     if (q != &noop_qdisc) {
  32.         spin_lock(qdisc_lock(q));
  33.         if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
  34.             result = qdisc_enqueue_root(skb, q);
  35.         spin_unlock(qdisc_lock(q));
  36.     }

  38.     return result;
  39. }

  41. static inline struct sk_buff *handle_ing(struct sk_buff *skb,
  42.                      struct packet_type **pt_prev,
  43.                      int *ret, struct net_device *orig_dev)
  44. {
  45.     if (skb->dev->rx_queue.qdisc == &noop_qdisc)
  46.         goto out;

  48.     if (*pt_prev) {
  49.         *ret = deliver_skb(skb, *pt_prev, orig_dev);
  50.         *pt_prev = NULL;
  51.     } else {
  52.         /* Huh? Why does turning on AF_PACKET affect this? */
  53.         skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
  54.     }

  56.     switch (ing_filter(skb)) {
  57.     case TC_ACT_SHOT:
  58.     case TC_ACT_STOLEN:
  59.         kfree_skb(skb);
  60.         return NULL;
  61.     }

  63. out:
  64.     skb->tc_verd = 0;
  65.     return skb;
  66. }
  67. #endif


我们看ing_filter里q != &noop_qdisc这个判断，默认它们是相等的，我们应该记得以前讲过qdisc的初始化.默认就是noop_qdisc.所以默认的情况就是什么也不做，就返回了，当然
这里没有深入讨论，以后会深入分析入口队列流量控制的应用.

再接着就是判断是不是属于桥handle_bridge 。关于bridge也需要单独分析.至少到这里整个流程我想大家都明白了吧.


文章标签：
Linux
网络虚拟化
芯片
云之大者
目录
相关文章
c的前世今生
|
7天前
|
传感器
CAN 帧有哪些类型
CAN帧主要有五种类型：数据帧，用于传输数据；远程帧，用于请求数据；错误帧，表示检测到错误；过载帧，表示接收器需要延时；帧间隔，用于分隔不同的帧。
c的前世今生
21 4
微帧科技Visionular
|
12天前
|
编解码 缓存 算法
视频帧里的I帧、P帧、B帧是什么？
I帧、P帧、B帧是视频编码中的基本概念。I帧是帧内编码帧，无需参考其他帧即可解码；P帧是前向预测编码帧，基于前一帧解码；B帧是双向预测编码帧，基于前后帧解码。IDR帧是一种特殊的I帧，用于即时解码刷新，防止错误传播。GOP（Group of Pictures）是一组连续的画面，第一个帧为I帧，gop_size设置越大，画质越好，但解码延迟增加。OpenGOP允许GOP间的帧依赖，而ClosedGOP则不允许。DTS（解码时间戳）和PTS（显示时间戳）分别用于解码和显示时间控制。
微帧科技Visionular
40 1
小王老师呀
|
2月前
|
网络协议 算法 安全
802.11帧结构与WiFi控制帧、管理帧、数据帧
【9月更文挑战第26天】该内容详细介绍了802.11帧结构，包括帧头、帧体和帧尾三部分，并分别阐述了各部分的功能和作用。此外，还介绍了WiFi控制帧、管理帧和数据帧的功能及类型，涵盖了RTS/CTS、ACK、信标帧、关联请求/响应帧、认证帧等内容，解释了它们在网络通信中的具体应用。
小王老师呀
190 3
爱叨叨的小嘟
|
6月前
|
网络协议
计算机网络四种帧介绍，广播帧、未知帧、同网帧、异网帧
计算机网络四种帧介绍，广播帧、未知帧、同网帧、异网帧
爱叨叨的小嘟
142 1
不脱发的程序猿
|
IDE 自动驾驶 安全
CAN FD网络中每秒最多可以发送多少帧报文？
随着总线技术在汽车电子领域越来越广泛和深入的应用，特别是自动驾驶技术的迅速发展，汽车电子对总线宽度和数据传输速率的要求也越来也高，传统CAN（1MBit/s，8Bytes Payload）已难以满足日益增加的需求。
不脱发的程序猿
399 0
游客scyturumm2baa
|
算法
为什么发出去的2833 RTP流不能收号
为什么发出去的2833 RTP流不能收号
游客scyturumm2baa
183 0
为什么发出去的2833 RTP流不能收号
OpenMMLab
|
机器学习/深度学习 并行计算 算法
MMFlow ：帧与帧之间的追光者
光流（Optical Flow），字面理解为“光的流动”，更准确的说法为：时变图像上的二维运动场，是视频数据的重要视觉线索，在动作识别、视频理解、视频分割、目标跟踪以及全景拼接等领域，都有广泛应用。
OpenMMLab
617 0
MMFlow ：帧与帧之间的追光者
韩曙亮
|
机器学习/深度学习 缓存
【计算机网络】数据链路层 : 选择重传协议 SR ( 帧分类 | “发送方“ 确认帧、超时事件 | “接受方“ 接收帧机制 | 滑动窗口长度 | 计算示例 )★
【计算机网络】数据链路层 : 选择重传协议 SR ( 帧分类 | “发送方“ 确认帧、超时事件 | “接受方“ 接收帧机制 | 滑动窗口长度 | 计算示例 )★
韩曙亮
593 0
韩曙亮
|
机器学习/深度学习 缓存
【计算机网络】数据链路层 : 后退 N 帧协议 GBN ( 滑动窗口 | 发送窗口长度 | “发送方“ 累计确认、超时机制 | “接收方“ 按序接收、确认帧发送机制 | 计算示例 )★（一）
【计算机网络】数据链路层 : 后退 N 帧协议 GBN ( 滑动窗口 | 发送窗口长度 | “发送方“ 累计确认、超时机制 | “接收方“ 按序接收、确认帧发送机制 | 计算示例 )★（一）
韩曙亮
650 0
韩曙亮
|
机器学习/深度学习
【计算机网络】数据链路层 : 后退 N 帧协议 GBN ( 滑动窗口 | 发送窗口长度 | “发送方“ 累计确认、超时机制 | “接收方“ 按序接收、确认帧发送机制 | 计算示例 )★（二）
【计算机网络】数据链路层 : 后退 N 帧协议 GBN ( 滑动窗口 | 发送窗口长度 | “发送方“ 累计确认、超时机制 | “接收方“ 按序接收、确认帧发送机制 | 计算示例 )★（二）
韩曙亮
730 0