net: sched: implement qstat helper routines
authorJohn Fastabend <john.fastabend@gmail.com>
Sun, 28 Sep 2014 18:53:29 +0000 (11:53 -0700)
committerDavid S. Miller <davem@davemloft.net>
Tue, 30 Sep 2014 05:02:26 +0000 (01:02 -0400)
This adds helpers to manipulate qstats logic and replaces locations
that touch the counters directly. This simplifies future patches
to push qstats onto per cpu counters.

Signed-off-by: John Fastabend <john.r.fastabend@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
25 files changed:
include/net/sch_generic.h
net/sched/sch_api.c
net/sched/sch_atm.c
net/sched/sch_cbq.c
net/sched/sch_choke.c
net/sched/sch_codel.c
net/sched/sch_drr.c
net/sched/sch_dsmark.c
net/sched/sch_fifo.c
net/sched/sch_fq.c
net/sched/sch_fq_codel.c
net/sched/sch_gred.c
net/sched/sch_hfsc.c
net/sched/sch_hhf.c
net/sched/sch_htb.c
net/sched/sch_ingress.c
net/sched/sch_multiq.c
net/sched/sch_netem.c
net/sched/sch_pie.c
net/sched/sch_prio.c
net/sched/sch_qfq.c
net/sched/sch_red.c
net/sched/sch_sfb.c
net/sched/sch_sfq.c
net/sched/sch_tbf.c

index 4b9351120fd8870ee84c35a0e832dd074bd9c0d6..23a0f0fc83d884572562c7a08914195c568775cf 100644 (file)
@@ -521,11 +521,38 @@ static inline void qdisc_bstats_update(struct Qdisc *sch,
        bstats_update(&sch->bstats, skb);
 }
 
+static inline void qdisc_qstats_backlog_dec(struct Qdisc *sch,
+                                           const struct sk_buff *skb)
+{
+       sch->qstats.backlog -= qdisc_pkt_len(skb);
+}
+
+static inline void qdisc_qstats_backlog_inc(struct Qdisc *sch,
+                                           const struct sk_buff *skb)
+{
+       sch->qstats.backlog += qdisc_pkt_len(skb);
+}
+
+static inline void __qdisc_qstats_drop(struct Qdisc *sch, int count)
+{
+       sch->qstats.drops += count;
+}
+
+static inline void qdisc_qstats_drop(struct Qdisc *sch)
+{
+       sch->qstats.drops++;
+}
+
+static inline void qdisc_qstats_overlimit(struct Qdisc *sch)
+{
+       sch->qstats.overlimits++;
+}
+
 static inline int __qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch,
                                       struct sk_buff_head *list)
 {
        __skb_queue_tail(list, skb);
-       sch->qstats.backlog += qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_inc(sch, skb);
 
        return NET_XMIT_SUCCESS;
 }
@@ -541,7 +568,7 @@ static inline struct sk_buff *__qdisc_dequeue_head(struct Qdisc *sch,
        struct sk_buff *skb = __skb_dequeue(list);
 
        if (likely(skb != NULL)) {
-               sch->qstats.backlog -= qdisc_pkt_len(skb);
+               qdisc_qstats_backlog_dec(sch, skb);
                qdisc_bstats_update(sch, skb);
        }
 
@@ -560,7 +587,7 @@ static inline unsigned int __qdisc_queue_drop_head(struct Qdisc *sch,
 
        if (likely(skb != NULL)) {
                unsigned int len = qdisc_pkt_len(skb);
-               sch->qstats.backlog -= len;
+               qdisc_qstats_backlog_dec(sch, skb);
                kfree_skb(skb);
                return len;
        }
@@ -579,7 +606,7 @@ static inline struct sk_buff *__qdisc_dequeue_tail(struct Qdisc *sch,
        struct sk_buff *skb = __skb_dequeue_tail(list);
 
        if (likely(skb != NULL))
-               sch->qstats.backlog -= qdisc_pkt_len(skb);
+               qdisc_qstats_backlog_dec(sch, skb);
 
        return skb;
 }
@@ -661,14 +688,14 @@ static inline unsigned int qdisc_queue_drop(struct Qdisc *sch)
 static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch)
 {
        kfree_skb(skb);
-       sch->qstats.drops++;
+       qdisc_qstats_drop(sch);
 
        return NET_XMIT_DROP;
 }
 
 static inline int qdisc_reshape_fail(struct sk_buff *skb, struct Qdisc *sch)
 {
-       sch->qstats.drops++;
+       qdisc_qstats_drop(sch);
 
 #ifdef CONFIG_NET_CLS_ACT
        if (sch->reshape_fail == NULL || sch->reshape_fail(skb, sch))
index a95e3b48fa51b06df46113ee9d289525c212e639..2862bc61a358b4e0e6313c132e05fdf25732f453 100644 (file)
@@ -763,7 +763,7 @@ void qdisc_tree_decrease_qlen(struct Qdisc *sch, unsigned int n)
                        cops->put(sch, cl);
                }
                sch->q.qlen -= n;
-               sch->qstats.drops += drops;
+               __qdisc_qstats_drop(sch, drops);
        }
 }
 EXPORT_SYMBOL(qdisc_tree_decrease_qlen);
index 01017663e5d80d5b74652e903da68a4887a227e2..040212cab9886ff277ce872edd2f47f4afb7c1b3 100644 (file)
@@ -417,7 +417,7 @@ done:
        if (ret != NET_XMIT_SUCCESS) {
 drop: __maybe_unused
                if (net_xmit_drop_count(ret)) {
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                        if (flow)
                                flow->qstats.drops++;
                }
index 22a3a029a91147e20004b7e514303c12729e1726..60432c3d3cd4f09df2d9d5691fedf50f43562e02 100644 (file)
@@ -377,7 +377,7 @@ cbq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 #endif
        if (cl == NULL) {
                if (ret & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return ret;
        }
@@ -395,7 +395,7 @@ cbq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        }
 
        if (net_xmit_drop_count(ret)) {
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
                cbq_mark_toplevel(q, cl);
                cl->qstats.drops++;
        }
@@ -650,11 +650,11 @@ static int cbq_reshape_fail(struct sk_buff *skb, struct Qdisc *child)
                        return 0;
                }
                if (net_xmit_drop_count(ret))
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                return 0;
        }
 
-       sch->qstats.drops++;
+       qdisc_qstats_drop(sch);
        return -1;
 }
 #endif
@@ -995,7 +995,7 @@ cbq_dequeue(struct Qdisc *sch)
         */
 
        if (sch->q.qlen) {
-               sch->qstats.overlimits++;
+               qdisc_qstats_overlimit(sch);
                if (q->wd_expires)
                        qdisc_watchdog_schedule(&q->watchdog,
                                                now + q->wd_expires);
index 8abc2625c3a104a7c79a9bb62b1df599060eb10e..c009eb9045cef48adbe974e9d7d505e242213974 100644 (file)
@@ -127,7 +127,7 @@ static void choke_drop_by_idx(struct Qdisc *sch, unsigned int idx)
        if (idx == q->tail)
                choke_zap_tail_holes(q);
 
-       sch->qstats.backlog -= qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_dec(sch, skb);
        qdisc_drop(skb, sch);
        qdisc_tree_decrease_qlen(sch, 1);
        --sch->q.qlen;
@@ -302,7 +302,7 @@ static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                if (q->vars.qavg > p->qth_max) {
                        q->vars.qcount = -1;
 
-                       sch->qstats.overlimits++;
+                       qdisc_qstats_overlimit(sch);
                        if (use_harddrop(q) || !use_ecn(q) ||
                            !INET_ECN_set_ce(skb)) {
                                q->stats.forced_drop++;
@@ -315,7 +315,7 @@ static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                                q->vars.qcount = 0;
                                q->vars.qR = red_random(p);
 
-                               sch->qstats.overlimits++;
+                               qdisc_qstats_overlimit(sch);
                                if (!use_ecn(q) || !INET_ECN_set_ce(skb)) {
                                        q->stats.prob_drop++;
                                        goto congestion_drop;
@@ -332,7 +332,7 @@ static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                q->tab[q->tail] = skb;
                q->tail = (q->tail + 1) & q->tab_mask;
                ++sch->q.qlen;
-               sch->qstats.backlog += qdisc_pkt_len(skb);
+               qdisc_qstats_backlog_inc(sch, skb);
                return NET_XMIT_SUCCESS;
        }
 
@@ -345,7 +345,7 @@ congestion_drop:
 
 other_drop:
        if (ret & __NET_XMIT_BYPASS)
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
        kfree_skb(skb);
        return ret;
 }
@@ -365,7 +365,7 @@ static struct sk_buff *choke_dequeue(struct Qdisc *sch)
        q->tab[q->head] = NULL;
        choke_zap_head_holes(q);
        --sch->q.qlen;
-       sch->qstats.backlog -= qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_dec(sch, skb);
        qdisc_bstats_update(sch, skb);
 
        return skb;
@@ -460,7 +460,7 @@ static int choke_change(struct Qdisc *sch, struct nlattr *opt)
                                        ntab[tail++] = skb;
                                        continue;
                                }
-                               sch->qstats.backlog -= qdisc_pkt_len(skb);
+                               qdisc_qstats_backlog_dec(sch, skb);
                                --sch->q.qlen;
                                qdisc_drop(skb, sch);
                        }
index 2f9ab17db85a59524556055bc5e53c5f2cab1a67..de28f8e968e8176ac7630a1e6fcccb45ad295f5d 100644 (file)
@@ -149,7 +149,7 @@ static int codel_change(struct Qdisc *sch, struct nlattr *opt)
        while (sch->q.qlen > sch->limit) {
                struct sk_buff *skb = __skb_dequeue(&sch->q);
 
-               sch->qstats.backlog -= qdisc_pkt_len(skb);
+               qdisc_qstats_backlog_dec(sch, skb);
                qdisc_drop(skb, sch);
        }
        qdisc_tree_decrease_qlen(sch, qlen - sch->q.qlen);
index 7a6243c5d27098064306a2dde93e288c4f1b3984..907b12fd6825184d0e6b9c13fa7bf1e65042c415 100644 (file)
@@ -360,7 +360,7 @@ static int drr_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        cl = drr_classify(skb, sch, &err);
        if (cl == NULL) {
                if (err & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return err;
        }
@@ -369,7 +369,7 @@ static int drr_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        if (unlikely(err != NET_XMIT_SUCCESS)) {
                if (net_xmit_drop_count(err)) {
                        cl->qstats.drops++;
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                }
                return err;
        }
index 485e456c8139218eaad2fb4f9ce56ba2afebc54d..227114f27f9408b6010c9c537236ce9f7cb484d9 100644 (file)
@@ -258,7 +258,7 @@ static int dsmark_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        err = qdisc_enqueue(skb, p->q);
        if (err != NET_XMIT_SUCCESS) {
                if (net_xmit_drop_count(err))
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                return err;
        }
 
index e15a9eb29087794ccc71408f467e9ae37f9c086b..2e2398cfc694aaf7ed12c2afda377e8ded340cb2 100644 (file)
@@ -42,7 +42,7 @@ static int pfifo_tail_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 
        /* queue full, remove one skb to fulfill the limit */
        __qdisc_queue_drop_head(sch, &sch->q);
-       sch->qstats.drops++;
+       qdisc_qstats_drop(sch);
        qdisc_enqueue_tail(skb, sch);
 
        return NET_XMIT_CN;
index e12f997e1b4ca9862f408f6751713c793d747606..c9b9fcb53206ba046fca38d081795755afcdf5a1 100644 (file)
@@ -290,7 +290,7 @@ static struct sk_buff *fq_dequeue_head(struct Qdisc *sch, struct fq_flow *flow)
                flow->head = skb->next;
                skb->next = NULL;
                flow->qlen--;
-               sch->qstats.backlog -= qdisc_pkt_len(skb);
+               qdisc_qstats_backlog_dec(sch, skb);
                sch->q.qlen--;
        }
        return skb;
@@ -371,7 +371,7 @@ static int fq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        f->qlen++;
        if (skb_is_retransmit(skb))
                q->stat_tcp_retrans++;
-       sch->qstats.backlog += qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_inc(sch, skb);
        if (fq_flow_is_detached(f)) {
                fq_flow_add_tail(&q->new_flows, f);
                if (time_after(jiffies, f->age + q->flow_refill_delay))
index 105cf55576307eb5b3031d09080014442bdfe604..9270e1b2f25da5282b56026b977f64bf2e60c447 100644 (file)
@@ -164,8 +164,8 @@ static unsigned int fq_codel_drop(struct Qdisc *sch)
        q->backlogs[idx] -= len;
        kfree_skb(skb);
        sch->q.qlen--;
-       sch->qstats.drops++;
-       sch->qstats.backlog -= len;
+       qdisc_qstats_drop(sch);
+       qdisc_qstats_backlog_dec(sch, skb);
        flow->dropped++;
        return idx;
 }
@@ -180,7 +180,7 @@ static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        idx = fq_codel_classify(skb, sch, &ret);
        if (idx == 0) {
                if (ret & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return ret;
        }
@@ -190,7 +190,7 @@ static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        flow = &q->flows[idx];
        flow_queue_add(flow, skb);
        q->backlogs[idx] += qdisc_pkt_len(skb);
-       sch->qstats.backlog += qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_inc(sch, skb);
 
        if (list_empty(&flow->flowchain)) {
                list_add_tail(&flow->flowchain, &q->new_flows);
index 12cbc09157fcce67c314076e3cf0ed690f6f8818..a4ca4517cdc82843e21e5245989a59e89aa53702 100644 (file)
@@ -209,7 +209,7 @@ static int gred_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                break;
 
        case RED_PROB_MARK:
-               sch->qstats.overlimits++;
+               qdisc_qstats_overlimit(sch);
                if (!gred_use_ecn(t) || !INET_ECN_set_ce(skb)) {
                        q->stats.prob_drop++;
                        goto congestion_drop;
@@ -219,7 +219,7 @@ static int gred_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                break;
 
        case RED_HARD_MARK:
-               sch->qstats.overlimits++;
+               qdisc_qstats_overlimit(sch);
                if (gred_use_harddrop(t) || !gred_use_ecn(t) ||
                    !INET_ECN_set_ce(skb)) {
                        q->stats.forced_drop++;
index 209b966b2eed79eaf1ba7c8fa63f06251cc67a76..ad278251d81168340c6c088005467a93c7fb2670 100644 (file)
@@ -1591,7 +1591,7 @@ hfsc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        cl = hfsc_classify(skb, sch, &err);
        if (cl == NULL) {
                if (err & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return err;
        }
@@ -1600,7 +1600,7 @@ hfsc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        if (unlikely(err != NET_XMIT_SUCCESS)) {
                if (net_xmit_drop_count(err)) {
                        cl->qstats.drops++;
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                }
                return err;
        }
@@ -1643,7 +1643,7 @@ hfsc_dequeue(struct Qdisc *sch)
                 */
                cl = vttree_get_minvt(&q->root, cur_time);
                if (cl == NULL) {
-                       sch->qstats.overlimits++;
+                       qdisc_qstats_overlimit(sch);
                        hfsc_schedule_watchdog(sch);
                        return NULL;
                }
@@ -1698,7 +1698,7 @@ hfsc_drop(struct Qdisc *sch)
                                list_move_tail(&cl->dlist, &q->droplist);
                        }
                        cl->qstats.drops++;
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                        sch->q.qlen--;
                        return len;
                }
index d85b6812a7d4c6bd0794decd872406e6b810e779..15d3aabfe2506c1483a2cdba0fe8425d152d2736 100644 (file)
@@ -376,8 +376,8 @@ static unsigned int hhf_drop(struct Qdisc *sch)
                struct sk_buff *skb = dequeue_head(bucket);
 
                sch->q.qlen--;
-               sch->qstats.drops++;
-               sch->qstats.backlog -= qdisc_pkt_len(skb);
+               qdisc_qstats_drop(sch);
+               qdisc_qstats_backlog_dec(sch, skb);
                kfree_skb(skb);
        }
 
@@ -395,7 +395,7 @@ static int hhf_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 
        bucket = &q->buckets[idx];
        bucket_add(bucket, skb);
-       sch->qstats.backlog += qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_inc(sch, skb);
 
        if (list_empty(&bucket->bucketchain)) {
                unsigned int weight;
@@ -457,7 +457,7 @@ begin:
        if (bucket->head) {
                skb = dequeue_head(bucket);
                sch->q.qlen--;
-               sch->qstats.backlog -= qdisc_pkt_len(skb);
+               qdisc_qstats_backlog_dec(sch, skb);
        }
 
        if (!skb) {
index 0256dee69bd6a22a726009f786eb09516a9a4589..c40ab7a98c50819f73b1edd4037c4f43147e011c 100644 (file)
@@ -586,13 +586,13 @@ static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 #ifdef CONFIG_NET_CLS_ACT
        } else if (!cl) {
                if (ret & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return ret;
 #endif
        } else if ((ret = qdisc_enqueue(skb, cl->un.leaf.q)) != NET_XMIT_SUCCESS) {
                if (net_xmit_drop_count(ret)) {
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                        cl->qstats.drops++;
                }
                return ret;
@@ -925,7 +925,7 @@ ok:
                                goto ok;
                }
        }
-       sch->qstats.overlimits++;
+       qdisc_qstats_overlimit(sch);
        if (likely(next_event > q->now)) {
                if (!test_bit(__QDISC_STATE_DEACTIVATED,
                              &qdisc_root_sleeping(q->watchdog.qdisc)->state)) {
index b351125f3849a6a7d596fe66b90659950931c7e6..eb5b8445fef989c1f331fa1485fa39c649181a82 100644 (file)
@@ -69,7 +69,7 @@ static int ingress_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        switch (result) {
        case TC_ACT_SHOT:
                result = TC_ACT_SHOT;
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
                break;
        case TC_ACT_STOLEN:
        case TC_ACT_QUEUED:
index 4adbf7fefc095e3830d9f71f3e90097e7164d742..7f4e1d8504b0e829554ac93bbfb18610d1c9476f 100644 (file)
@@ -75,7 +75,7 @@ multiq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        if (qdisc == NULL) {
 
                if (ret & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return ret;
        }
@@ -87,7 +87,7 @@ multiq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                return NET_XMIT_SUCCESS;
        }
        if (net_xmit_drop_count(ret))
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
        return ret;
 }
 
index 111d70fddaea97242ac4a85115e969efcd11dfcd..b34331967e020b6f1151b25be8f744e494a80ad6 100644 (file)
@@ -429,12 +429,12 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        /* Drop packet? */
        if (loss_event(q)) {
                if (q->ecn && INET_ECN_set_ce(skb))
-                       sch->qstats.drops++; /* mark packet */
+                       qdisc_qstats_drop(sch); /* mark packet */
                else
                        --count;
        }
        if (count == 0) {
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
        }
@@ -478,7 +478,7 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        if (unlikely(skb_queue_len(&sch->q) >= sch->limit))
                return qdisc_reshape_fail(skb, sch);
 
-       sch->qstats.backlog += qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_inc(sch, skb);
 
        cb = netem_skb_cb(skb);
        if (q->gap == 0 ||              /* not doing reordering */
@@ -549,15 +549,14 @@ static unsigned int netem_drop(struct Qdisc *sch)
                        sch->q.qlen--;
                        skb->next = NULL;
                        skb->prev = NULL;
-                       len = qdisc_pkt_len(skb);
-                       sch->qstats.backlog -= len;
+                       qdisc_qstats_backlog_dec(sch, skb);
                        kfree_skb(skb);
                }
        }
        if (!len && q->qdisc && q->qdisc->ops->drop)
            len = q->qdisc->ops->drop(q->qdisc);
        if (len)
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
 
        return len;
 }
@@ -575,7 +574,7 @@ tfifo_dequeue:
        skb = __skb_dequeue(&sch->q);
        if (skb) {
 deliver:
-               sch->qstats.backlog -= qdisc_pkt_len(skb);
+               qdisc_qstats_backlog_dec(sch, skb);
                qdisc_unthrottled(sch);
                qdisc_bstats_update(sch, skb);
                return skb;
@@ -610,7 +609,7 @@ deliver:
 
                                if (unlikely(err != NET_XMIT_SUCCESS)) {
                                        if (net_xmit_drop_count(err)) {
-                                               sch->qstats.drops++;
+                                               qdisc_qstats_drop(sch);
                                                qdisc_tree_decrease_qlen(sch, 1);
                                        }
                                }
index fefeeb73f15f18a84406ed686dc653ff3327ef45..33d7a98a7a9799b3cb5b3ce62c9013c49483184c 100644 (file)
@@ -232,7 +232,7 @@ static int pie_change(struct Qdisc *sch, struct nlattr *opt)
        while (sch->q.qlen > sch->limit) {
                struct sk_buff *skb = __skb_dequeue(&sch->q);
 
-               sch->qstats.backlog -= qdisc_pkt_len(skb);
+               qdisc_qstats_backlog_dec(sch, skb);
                qdisc_drop(skb, sch);
        }
        qdisc_tree_decrease_qlen(sch, qlen - sch->q.qlen);
index 68a8f25e30c30f14f18118f88d1ba4199dac3354..b411e78a02fc8902c972ebc661a43b0f37c0e5ab 100644 (file)
@@ -77,7 +77,7 @@ prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        if (qdisc == NULL) {
 
                if (ret & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return ret;
        }
@@ -89,7 +89,7 @@ prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                return NET_XMIT_SUCCESS;
        }
        if (net_xmit_drop_count(ret))
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
        return ret;
 }
 
index d59f8574540a14130e850301250c6ee0db9fb516..3fb26555c79bb7e735cf4563d12baba4f1aff8e7 100644 (file)
@@ -1229,7 +1229,7 @@ static int qfq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        cl = qfq_classify(skb, sch, &err);
        if (cl == NULL) {
                if (err & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return err;
        }
@@ -1249,7 +1249,7 @@ static int qfq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                pr_debug("qfq_enqueue: enqueue failed %d\n", err);
                if (net_xmit_drop_count(err)) {
                        cl->qstats.drops++;
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                }
                return err;
        }
index 633e32defdcc61291554e9457d5e13c2f6b87a1e..6c0534cc77582881fecb7b9276659f6d921e6daa 100644 (file)
@@ -74,7 +74,7 @@ static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                break;
 
        case RED_PROB_MARK:
-               sch->qstats.overlimits++;
+               qdisc_qstats_overlimit(sch);
                if (!red_use_ecn(q) || !INET_ECN_set_ce(skb)) {
                        q->stats.prob_drop++;
                        goto congestion_drop;
@@ -84,7 +84,7 @@ static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                break;
 
        case RED_HARD_MARK:
-               sch->qstats.overlimits++;
+               qdisc_qstats_overlimit(sch);
                if (red_use_harddrop(q) || !red_use_ecn(q) ||
                    !INET_ECN_set_ce(skb)) {
                        q->stats.forced_drop++;
@@ -100,7 +100,7 @@ static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                sch->q.qlen++;
        } else if (net_xmit_drop_count(ret)) {
                q->stats.pdrop++;
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
        }
        return ret;
 
@@ -142,7 +142,7 @@ static unsigned int red_drop(struct Qdisc *sch)
 
        if (child->ops->drop && (len = child->ops->drop(child)) > 0) {
                q->stats.other++;
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
                sch->q.qlen--;
                return len;
        }
index 1562fb2b3f46be69f601d07029e25fe61e549f6d..5819dd82630d2a126d2a75a3cd2f5d6a9a3534a8 100644 (file)
@@ -290,7 +290,7 @@ static int sfb_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        struct flow_keys keys;
 
        if (unlikely(sch->q.qlen >= q->limit)) {
-               sch->qstats.overlimits++;
+               qdisc_qstats_overlimit(sch);
                q->stats.queuedrop++;
                goto drop;
        }
@@ -348,7 +348,7 @@ static int sfb_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        sfb_skb_cb(skb)->hashes[slot] = 0;
 
        if (unlikely(minqlen >= q->max)) {
-               sch->qstats.overlimits++;
+               qdisc_qstats_overlimit(sch);
                q->stats.bucketdrop++;
                goto drop;
        }
@@ -376,7 +376,7 @@ static int sfb_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                        }
                }
                if (sfb_rate_limit(skb, q)) {
-                       sch->qstats.overlimits++;
+                       qdisc_qstats_overlimit(sch);
                        q->stats.penaltydrop++;
                        goto drop;
                }
@@ -411,7 +411,7 @@ enqueue:
                increment_qlen(skb, q);
        } else if (net_xmit_drop_count(ret)) {
                q->stats.childdrop++;
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
        }
        return ret;
 
@@ -420,7 +420,7 @@ drop:
        return NET_XMIT_CN;
 other_drop:
        if (ret & __NET_XMIT_BYPASS)
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
        kfree_skb(skb);
        return ret;
 }
index 80c36bd54abc91c0c8f6c4313bb5092815db1998..158dfa641d18ab060c6a14d4c88e7378b208c012 100644 (file)
@@ -331,8 +331,8 @@ drop:
                sfq_dec(q, x);
                kfree_skb(skb);
                sch->q.qlen--;
-               sch->qstats.drops++;
-               sch->qstats.backlog -= len;
+               qdisc_qstats_drop(sch);
+               qdisc_qstats_backlog_dec(sch, skb);
                return len;
        }
 
@@ -379,7 +379,7 @@ sfq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        hash = sfq_classify(skb, sch, &ret);
        if (hash == 0) {
                if (ret & __NET_XMIT_BYPASS)
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                kfree_skb(skb);
                return ret;
        }
@@ -409,7 +409,7 @@ sfq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                        break;
 
                case RED_PROB_MARK:
-                       sch->qstats.overlimits++;
+                       qdisc_qstats_overlimit(sch);
                        if (sfq_prob_mark(q)) {
                                /* We know we have at least one packet in queue */
                                if (sfq_headdrop(q) &&
@@ -426,7 +426,7 @@ sfq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                        goto congestion_drop;
 
                case RED_HARD_MARK:
-                       sch->qstats.overlimits++;
+                       qdisc_qstats_overlimit(sch);
                        if (sfq_hard_mark(q)) {
                                /* We know we have at least one packet in queue */
                                if (sfq_headdrop(q) &&
@@ -461,7 +461,7 @@ congestion_drop:
        }
 
 enqueue:
-       sch->qstats.backlog += qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_inc(sch, skb);
        slot->backlog += qdisc_pkt_len(skb);
        slot_queue_add(slot, skb);
        sfq_inc(q, x);
@@ -520,7 +520,7 @@ next_slot:
        sfq_dec(q, a);
        qdisc_bstats_update(sch, skb);
        sch->q.qlen--;
-       sch->qstats.backlog -= qdisc_pkt_len(skb);
+       qdisc_qstats_backlog_dec(sch, skb);
        slot->backlog -= qdisc_pkt_len(skb);
        /* Is the slot empty? */
        if (slot->qlen == 0) {
@@ -586,7 +586,8 @@ static void sfq_rehash(struct Qdisc *sch)
                if (x == SFQ_EMPTY_SLOT) {
                        x = q->dep[0].next; /* get a free slot */
                        if (x >= SFQ_MAX_FLOWS) {
-drop:                          sch->qstats.backlog -= qdisc_pkt_len(skb);
+drop:
+                               qdisc_qstats_backlog_dec(sch, skb);
                                kfree_skb(skb);
                                dropped++;
                                continue;
index 0c39b754083b2028438289ddd8a5a292a1cbf938..77edffe329c447f82b26069785c048a3333ede0c 100644 (file)
@@ -175,7 +175,7 @@ static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch)
                ret = qdisc_enqueue(segs, q->qdisc);
                if (ret != NET_XMIT_SUCCESS) {
                        if (net_xmit_drop_count(ret))
-                               sch->qstats.drops++;
+                               qdisc_qstats_drop(sch);
                } else {
                        nb++;
                }
@@ -201,7 +201,7 @@ static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch)
        ret = qdisc_enqueue(skb, q->qdisc);
        if (ret != NET_XMIT_SUCCESS) {
                if (net_xmit_drop_count(ret))
-                       sch->qstats.drops++;
+                       qdisc_qstats_drop(sch);
                return ret;
        }
 
@@ -216,7 +216,7 @@ static unsigned int tbf_drop(struct Qdisc *sch)
 
        if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
                sch->q.qlen--;
-               sch->qstats.drops++;
+               qdisc_qstats_drop(sch);
        }
        return len;
 }
@@ -281,7 +281,7 @@ static struct sk_buff *tbf_dequeue(struct Qdisc *sch)
                   (cf. CSZ, HPFQ, HFSC)
                 */
 
-               sch->qstats.overlimits++;
+               qdisc_qstats_overlimit(sch);
        }
        return NULL;
 }