net_sched: Add qdisc_enqueue wrapper

Signed-off-by: Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 8a44386b35cfce1836d6937c53ab467b99697604..f396dff335a3fe3c9098778452fc2ce243f1f3dc 100644 (file)
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -306,6 +306,16 @@ static inline bool qdisc_tx_is_noop(const struct net_device *dev)
        return true;
 }
 
+static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
+{
+       return sch->enqueue(skb, sch);
+}
+
+static inline int qdisc_enqueue_root(struct sk_buff *skb, struct Qdisc *sch)
+{
+       return qdisc_enqueue(skb, sch);
+}
+
 static inline int __qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch,
                                       struct sk_buff_head *list)
 {

diff --git a/net/core/dev.c b/net/core/dev.c
index 065b9817e2091cf753c9a9dda21bf00ca525e094..2eed17bcb2ddb5c88d3dd4625c89f86c13a5c8f4 100644 (file)
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1781,7 +1781,7 @@ int dev_queue_xmit(struct sk_buff *skb)
 
                spin_lock(root_lock);
 
-               rc = q->enqueue(skb, q);
+               rc = qdisc_enqueue_root(skb, q);
                qdisc_run(q);
 
                spin_unlock(root_lock);
@@ -2083,7 +2083,7 @@ static int ing_filter(struct sk_buff *skb)
        q = rxq->qdisc;
        if (q) {
                spin_lock(qdisc_lock(q));
-               result = q->enqueue(skb, q);
+               result = qdisc_enqueue_root(skb, q);
                spin_unlock(qdisc_lock(q));
        }
 

diff --git a/net/mac80211/wme.c b/net/mac80211/wme.c
index 6e8099e77043162e3db1e3dd2ced1a0ff05fbaa7..07edda0b8a5c1c78fef73e9bdca5cf1dbf23abd5 100644 (file)
--- a/net/mac80211/wme.c
+++ b/net/mac80211/wme.c
@@ -289,7 +289,7 @@ void ieee80211_requeue(struct ieee80211_local *local, int queue)
                root_lock = qdisc_root_lock(qdisc);
 
                spin_lock(root_lock);
-               qdisc->enqueue(skb, qdisc);
+               qdisc_enqueue_root(skb, qdisc);
                spin_unlock(root_lock);
        }
 

diff --git a/net/sched/sch_atm.c b/net/sched/sch_atm.c
index 0de757e3be4ab1baab785dd294b284a6bb242b3c..68ed35e2a763fc82a26c9cff0fe7bcf21976ba35 100644 (file)
--- a/net/sched/sch_atm.c
+++ b/net/sched/sch_atm.c
@@ -429,7 +429,7 @@ static int atm_tc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 #endif
        }
 
-       ret = flow->q->enqueue(skb, flow->q);
+       ret = qdisc_enqueue(skb, flow->q);
        if (ret != 0) {
 drop: __maybe_unused
                sch->qstats.drops++;

diff --git a/net/sched/sch_cbq.c b/net/sched/sch_cbq.c
index a3953bbe2d79844c612f72a9a16df594d30c267e..1afe3eece627f576e7f71551ce5732111e5c103e 100644 (file)
--- a/net/sched/sch_cbq.c
+++ b/net/sched/sch_cbq.c
@@ -387,7 +387,8 @@ cbq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 #ifdef CONFIG_NET_CLS_ACT
        cl->q->__parent = sch;
 #endif
-       if ((ret = cl->q->enqueue(skb, cl->q)) == NET_XMIT_SUCCESS) {
+       ret = qdisc_enqueue(skb, cl->q);
+       if (ret == NET_XMIT_SUCCESS) {
                sch->q.qlen++;
                sch->bstats.packets++;
                sch->bstats.bytes+=len;
@@ -671,7 +672,7 @@ static int cbq_reshape_fail(struct sk_buff *skb, struct Qdisc *child)
                q->rx_class = cl;
                cl->q->__parent = sch;
 
-               if (cl->q->enqueue(skb, cl->q) == 0) {
+               if (qdisc_enqueue(skb, cl->q) == 0) {
                        sch->q.qlen++;
                        sch->bstats.packets++;
                        sch->bstats.bytes+=len;

diff --git a/net/sched/sch_dsmark.c b/net/sched/sch_dsmark.c
index 3aafbd17393abb8c86372cef999b893a9bb72b7e..44d347e831cf487d7431dc880e9a3e4f503228ed 100644 (file)
--- a/net/sched/sch_dsmark.c
+++ b/net/sched/sch_dsmark.c
@@ -252,7 +252,7 @@ static int dsmark_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                }
        }
 
-       err = p->q->enqueue(skb, p->q);
+       err = qdisc_enqueue(skb, p->q);
        if (err != NET_XMIT_SUCCESS) {
                sch->qstats.drops++;
                return err;

diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index 5090708ba3847d66583f305700797b25e92c05c9..fd61ed6ee1e76492b6045875c85a000d44665a93 100644 (file)
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -1586,7 +1586,7 @@ hfsc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        }
 
        len = skb->len;
-       err = cl->qdisc->enqueue(skb, cl->qdisc);
+       err = qdisc_enqueue(skb, cl->qdisc);
        if (unlikely(err != NET_XMIT_SUCCESS)) {
                cl->qstats.drops++;
                sch->qstats.drops++;

diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index ee48457eaa4a9a391bc3997bf9375d3f55e12df9..72b5a946178fd11672491926f9e693a56da03d19 100644 (file)
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -572,8 +572,7 @@ static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                kfree_skb(skb);
                return ret;
 #endif
-       } else if (cl->un.leaf.q->enqueue(skb, cl->un.leaf.q) !=
-                  NET_XMIT_SUCCESS) {
+       } else if (qdisc_enqueue(skb, cl->un.leaf.q) != NET_XMIT_SUCCESS) {
                sch->qstats.drops++;
                cl->qstats.drops++;
                return NET_XMIT_DROP;

diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index c5ea40c9eb21645ec5cef67c64f24b78e81de52d..13c4821e42b8f04f0a730b7e079e9d392648963d 100644 (file)
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -82,6 +82,12 @@ struct netem_skb_cb {
        psched_time_t   time_to_send;
 };
 
+static inline struct netem_skb_cb *netem_skb_cb(struct sk_buff *skb)
+{
+       BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct netem_skb_cb));
+       return (struct netem_skb_cb *)skb->cb;
+}
+
 /* init_crandom - initialize correlated random number generator
  * Use entropy source for initial seed.
  */
@@ -184,7 +190,7 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
                q->duplicate = 0;
 
-               rootq->enqueue(skb2, rootq);
+               qdisc_enqueue_root(skb2, rootq);
                q->duplicate = dupsave;
        }
 
@@ -205,7 +211,7 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8);
        }
 
-       cb = (struct netem_skb_cb *)skb->cb;
+       cb = netem_skb_cb(skb);
        if (q->gap == 0                 /* not doing reordering */
            || q->counter < q->gap      /* inside last reordering gap */
            || q->reorder < get_crandom(&q->reorder_cor)) {
@@ -218,7 +224,7 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                now = psched_get_time();
                cb->time_to_send = now + delay;
                ++q->counter;
-               ret = q->qdisc->enqueue(skb, q->qdisc);
+               ret = qdisc_enqueue(skb, q->qdisc);
        } else {
                /*
                 * Do re-ordering by putting one out of N packets at the front
@@ -277,8 +283,7 @@ static struct sk_buff *netem_dequeue(struct Qdisc *sch)
 
        skb = q->qdisc->dequeue(q->qdisc);
        if (skb) {
-               const struct netem_skb_cb *cb
-                       = (const struct netem_skb_cb *)skb->cb;
+               const struct netem_skb_cb *cb = netem_skb_cb(skb);
                psched_time_t now = psched_get_time();
 
                /* if more time remaining? */
@@ -457,7 +462,7 @@ static int tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch)
 {
        struct fifo_sched_data *q = qdisc_priv(sch);
        struct sk_buff_head *list = &sch->q;
-       psched_time_t tnext = ((struct netem_skb_cb *)nskb->cb)->time_to_send;
+       psched_time_t tnext = netem_skb_cb(nskb)->time_to_send;
        struct sk_buff *skb;
 
        if (likely(skb_queue_len(list) < q->limit)) {
@@ -468,8 +473,7 @@ static int tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch)
                }
 
                skb_queue_reverse_walk(list, skb) {
-                       const struct netem_skb_cb *cb
-                               = (const struct netem_skb_cb *)skb->cb;
+                       const struct netem_skb_cb *cb = netem_skb_cb(skb);
 
                        if (tnext >= cb->time_to_send)
                                break;

diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c
index 536ca474dc69bc86d00f6da516e41b1a925fa97d..d29c2f87fc0bdf0278b9179afce2217778757b23 100644 (file)
--- a/net/sched/sch_prio.c
+++ b/net/sched/sch_prio.c
@@ -81,7 +81,8 @@ prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        }
 #endif
 
-       if ((ret = qdisc->enqueue(skb, qdisc)) == NET_XMIT_SUCCESS) {
+       ret = qdisc_enqueue(skb, qdisc);
+       if (ret == NET_XMIT_SUCCESS) {
                sch->bstats.bytes += skb->len;
                sch->bstats.packets++;
                sch->q.qlen++;

diff --git a/net/sched/sch_red.c b/net/sched/sch_red.c
index 77098acf0adc79fa506989e65d824cba24f93195..b48a391bc1292062199d504cbffa39b7721e8016 100644 (file)
--- a/net/sched/sch_red.c
+++ b/net/sched/sch_red.c
@@ -92,7 +92,7 @@ static int red_enqueue(struct sk_buff *skb, struct Qdisc* sch)
                        break;
        }
 
-       ret = child->enqueue(skb, child);
+       ret = qdisc_enqueue(skb, child);
        if (likely(ret == NET_XMIT_SUCCESS)) {
                sch->bstats.bytes += skb->len;
                sch->bstats.packets++;

diff --git a/net/sched/sch_tbf.c b/net/sched/sch_tbf.c
index 444c227fcb6b089e911765fa83595681564282d1..7d705b86dae5287396ce695cf8f4a2f0aa1b295d 100644 (file)
--- a/net/sched/sch_tbf.c
+++ b/net/sched/sch_tbf.c
@@ -133,7 +133,8 @@ static int tbf_enqueue(struct sk_buff *skb, struct Qdisc* sch)
                return NET_XMIT_DROP;
        }
 
-       if ((ret = q->qdisc->enqueue(skb, q->qdisc)) != 0) {
+       ret = qdisc_enqueue(skb, q->qdisc);
+       if (ret != 0) {
                sch->qstats.drops++;
                return ret;
        }