linux-imx

/*

 * net/sched/sch_generic.c  Generic packet scheduler routines.

 *

 *      This program is free software; you can redistribute it and/or

 *      modify it under the terms of the GNU General Public License

 *      as published by the Free Software Foundation; either version

 *      2 of the License, or (at your option) any later version.

 *

 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

 *              Jamal Hadi Salim, <hadi@cyberus.ca> 990601

 *              - Ingress support

 */

​

#include <linux/bitops.h>

#include <linux/module.h>

#include <linux/types.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/string.h>

#include <linux/errno.h>

#include <linux/netdevice.h>

#include <linux/skbuff.h>

#include <linux/rtnetlink.h>

#include <linux/init.h>

#include <linux/rcupdate.h>

#include <linux/list.h>

#include <linux/slab.h>

#include <linux/if_vlan.h>

#include <linux/skb_array.h>

#include <linux/if_macvlan.h>

#include <net/sch_generic.h>

#include <net/pkt_sched.h>

#include <net/dst.h>

#include <trace/events/qdisc.h>

#include <net/xfrm.h>

​

/* Qdisc to use by default */

const struct Qdisc_ops *default_qdisc_ops = &pfifo_fast_ops;

EXPORT_SYMBOL(default_qdisc_ops);

​

/* Main transmission queue. */

​

/* Modifications to data participating in scheduling must be protected with

 * qdisc_lock(qdisc) spinlock.

 *

 * The idea is the following:

 * - enqueue, dequeue are serialized via qdisc root lock

 * - ingress filtering is also serialized via qdisc root lock

 * - updates to tree and tree walking are only done under the rtnl mutex.

 */

​

static inline struct sk_buff *__skb_dequeue_bad_txq(struct Qdisc *q)

{

    const struct netdev_queue *txq = q->dev_queue;

    spinlock_t *lock = NULL;

    struct sk_buff *skb;

​

    if (q->flags & TCQ_F_NOLOCK) {

        lock = qdisc_lock(q);

        spin_lock(lock);

    }

​

    skb = skb_peek(&q->skb_bad_txq);

    if (skb) {

        /* check the reason of requeuing without tx lock first */

        txq = skb_get_tx_queue(txq->dev, skb);

        if (!netif_xmit_frozen_or_stopped(txq)) {

            skb = __skb_dequeue(&q->skb_bad_txq);

            if (qdisc_is_percpu_stats(q)) {

                qdisc_qstats_cpu_backlog_dec(q, skb);

                qdisc_qstats_atomic_qlen_dec(q);

            } else {

                qdisc_qstats_backlog_dec(q, skb);

                q->q.qlen--;

            }

        } else {

            skb = NULL;

        }

    }

​

    if (lock)

        spin_unlock(lock);

​

    return skb;

}

​

static inline struct sk_buff *qdisc_dequeue_skb_bad_txq(struct Qdisc *q)

{

    struct sk_buff *skb = skb_peek(&q->skb_bad_txq);

​

    if (unlikely(skb))

        skb = __skb_dequeue_bad_txq(q);