如果网络设备发送队列没有配置发送策略，内核就会使用默认的队列策略来进行报文的发送。

内核中定义实现了两种默认的队列策略，一种是给队列长度为零的队列使用的。一种是给队列长度不为0，但没配置队列策略的队列使用的。


初始化时使用的默认队列策略 noop_qdisc:

/*入队操作直接丢弃报文*/
static int noop_enqueue(struct sk_buff *skb, struct Qdisc * qdisc)
{
    kfree_skb(skb);
    return NET_XMIT_CN;
}
/*出队操作直接返回NULL*/
static struct sk_buff *noop_dequeue(struct Qdisc * qdisc)
{
    return NULL;
}
struct Qdisc_ops noop_qdisc_ops __read_mostly = {
    .id     =   "noop",
    .priv_size  =   0,
    .enqueue    =   noop_enqueue,
    .dequeue    =   noop_dequeue,
    .peek       =   noop_dequeue,
    .owner      =   THIS_MODULE,
};
static struct netdev_queue noop_netdev_queue = {
    .qdisc      =   &noop_qdisc,
    .qdisc_sleeping =   &noop_qdisc,
};
struct Qdisc noop_qdisc = {
    .enqueue    =   noop_enqueue,
    .dequeue    =   noop_dequeue,
    .flags      =   TCQ_F_BUILTIN,
    .ops        =   &noop_qdisc_ops,
    .list       =   LIST_HEAD_INIT(noop_qdisc.list),
    .dev_queue  =   &noop_netdev_queue,
};
EXPORT_SYMBOL(noop_qdisc);



零长度队列的默认队列策略 noqueue_qdisc：

static struct Qdisc_ops noqueue_qdisc_ops __read_mostly = {
    .id     =   "noqueue",
    .priv_size  =   0,
    .enqueue    =   noop_enqueue,
    .dequeue    =   noop_dequeue,
    .peek       =   noop_dequeue,
    .owner      =   THIS_MODULE,
};
static struct netdev_queue noqueue_netdev_queue = {
    .qdisc      =   &noqueue_qdisc,
    .qdisc_sleeping =   &noqueue_qdisc,
};
static struct Qdisc noqueue_qdisc = {
    /*队列长度为零，入队函数置为空,
     *发送函数根据该字段是否为空来判断是否需要缓存报文
     */
    .enqueue    =   NULL,
    .dequeue    =   noop_dequeue,
    .flags      =   TCQ_F_BUILTIN,
    .ops        =   &noqueue_qdisc_ops,
    .list       =   LIST_HEAD_INIT(noqueue_qdisc.list),
    .q.lock     =   __SPIN_LOCK_UNLOCKED(noqueue_qdisc.q.lock),
    .dev_queue  =   &noqueue_netdev_queue,
};


单队列时使用的默认队列策略 pfifo_fast:

该默认队列策略使用三个优先级队列来管理报文的发送。根据skb->priority字段设置的优先级来决定报文的发送优先级。

/*默认报文优先级队列个数为 3 个*/
#define PFIFO_FAST_BANDS 3
/*队列策略的私有数据结构
 * q：三个不同优先级的报文队列，数组下标越小优先级越高
 * bitmap:记录三个优先级队列中哪些有报文需要发送
 */
struct pfifo_fast_priv
{
    u32 bitmap;
    struct sk_buff_head q[PFIFO_FAST_BANDS];
};
/*根据priv->bitmap的值取出有报文要发送的队列号，
 *如果有多个队列都有报文要发送，返回优先级最高的队列号
 */
static const int bitmap2band[] = {-1, 0, 1, 0, 2, 0, 1, 0};
struct sk_buff_head *band2list(struct pfifo_fast_priv *priv,
                               int band)
{
    return priv->q + band;
}
/*根据skb->priority字段往队列策略优先级队列中的映射表*/
static const u8 prio2band[TC_PRIO_MAX+1] =
{ 1, 2, 2, 2, 1, 2, 0, 0 , 1, 1, 1, 1, 1, 1, 1, 1 };

入队和出队的操作：

static int pfifo_fast_enqueue(struct sk_buff *skb,
                              struct Qdisc* qdisc)
{
    /*如果队列没满，就缓存报文*/
    if (skb_queue_len(&qdisc->q)
        < qdisc_dev(qdisc)->tx_queue_len)
    {
        /*根据skb的优先级找到队列策略对应的优先级队列*/
        int band = prio2band[skb->priority & TC_PRIO_MAX];
        struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
        struct sk_buff_head *list = band2list(priv, band);
        /*置位优先级队列对应的bitmap位*/
        priv->bitmap |= (1 << band);
        qdisc->q.qlen++;
                                                                                                                                                                                         
        /*把报文加入队列*/
        return __qdisc_enqueue_tail(skb, qdisc, list);
    }
    /*如果队列已经满了，丢弃报文*/
    return qdisc_drop(skb, qdisc);
}


static struct sk_buff *pfifo_fast_dequeue(struct Qdisc* qdisc)
{
    struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
    /*找到有报文要发送的优先级最高的队列*/
    int band = bitmap2band[priv->bitmap];
    if (likely(band >= 0))
    {
        struct sk_buff_head *list = band2list(priv, band);
        /*从队列中取一个报文*/
        struct sk_buff *skb =
             __qdisc_dequeue_head(qdisc, list);
        qdisc->q.qlen--;
        /*如果队列为空，清除bitmap位*/
        if (skb_queue_empty(list))
        {
           priv->bitmap &= ~(1 << band);
        }
                                                                                                                                                                                     
        return skb;
    }
                                                                                                                                                                                 
    /*没有队列有报文要发送，返回NULL*/
    return NULL;
}


struct Qdisc_ops pfifo_fast_ops __read_mostly = {
    .id     =   "pfifo_fast",
    .priv_size  =   sizeof(struct pfifo_fast_priv),
    .enqueue    =   pfifo_fast_enqueue,
    .dequeue    =   pfifo_fast_dequeue,
    .owner      =   THIS_MODULE,
};


队列策略的初始化：

在设备创建时会使用noop_qdisc来初始化发送队列的队列策略：

int register_netdevice(struct net_device *dev)
{
    。。。。。。
    dev_init_scheduler(dev);
    。。。。。。
}
void dev_init_scheduler(struct net_device *dev)
{
    dev->qdisc = &noop_qdisc;
    netdev_for_each_tx_queue(dev, dev_init_scheduler_queue,
                             &noop_qdisc);
}

当打开设备时，如果没创建队列策略，就会给创建一个默认的队列策略。

dev_open()
{
    。。。。。。
    dev_activate(dev)；
    。。。。。。
}
void dev_activate(struct net_device *dev)
{
    /*如果dev使用的默认的qisc  noop_qdisc，
     *创建一个新的qdisc*/
    if (dev->qdisc == &noop_qdisc)
    {
    attach_default_qdiscs(dev);
    }
}
static void attach_one_default_qdisc(struct net_device *dev,
               struct netdev_queue *dev_queue,
               void *_unused)
{
    struct Qdisc *qdisc;
    /*如果队列长度不为0，就创建一个发送队列策略pfifo_fast*/
    if (dev->tx_queue_len)
    {
        qdisc = qdisc_create_dflt(dev, dev_queue,
                         &pfifo_fast_ops, TC_H_ROOT);
        if (!qdisc)
        {
            printk(KERN_INFO "%s: activation failed\n", dev->name);
            return;
        }
        /* Can by-pass the queue discipline for default qdisc */
        qdisc->flags |= TCQ_F_CAN_BYPASS;
    }
    /*发送队列长度为0，就使用noqueue_qdisc*/
    else
    {
        qdisc =  &noqueue_qdisc;
    }
    dev_queue->qdisc_sleeping = qdisc;
}
static void attach_default_qdiscs(struct net_device *dev)
{
    struct netdev_queue *txq;
    struct Qdisc *qdisc;
    /*取得设备的第一个发送队列*/
    txq = netdev_get_tx_queue(dev, 0);
            
    /*如果设备只有一个发送队列或者发送队列长度为0，
     *调用attach_one_default_qdisc创建一个默认队列策略
     */
    if (!netif_is_multiqueue(dev)
        || dev->tx_queue_len == 0)
    {
        netdev_for_each_tx_queue(dev,
                 attach_one_default_qdisc, NULL);
        dev->qdisc = txq->qdisc_sleeping;
        atomic_inc(&dev->qdisc->refcnt);
    }
    else
    {
        qdisc = qdisc_create_dflt(dev, txq,
                        &mq_qdisc_ops, TC_H_ROOT);
        if (qdisc)
        {
            qdisc->ops->attach(qdisc);
            dev->qdisc = qdisc;
        }
    }
}