Merge git://www.linux-watchdog.org/linux-watchdog

[mv-sheeva.git] / net / sched / sch_choke.c

diff --git a/net/sched/sch_choke.c b/net/sched/sch_choke.c
index bef00acb8bd2e9f392f433c9d7579a5b02d80ffb..e465064d39a369aad077f8ed55a54fd1f1cac31d 100644 (file)
--- a/net/sched/sch_choke.c
+++ b/net/sched/sch_choke.c
@@ -57,6 +57,7 @@ struct choke_sched_data {
        struct red_parms parms;
 
 /* Variables */
+       struct red_vars  vars;
        struct tcf_proto *filter_list;
        struct {
                u32     prob_drop;      /* Early probability drops */
@@ -265,7 +266,7 @@ static bool choke_match_random(const struct choke_sched_data *q,
 static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 {
        struct choke_sched_data *q = qdisc_priv(sch);
-       struct red_parms *p = &q->parms;
+       const struct red_parms *p = &q->parms;
        int ret = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 
        if (q->filter_list) {
@@ -276,13 +277,13 @@ static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 
        choke_skb_cb(skb)->keys_valid = 0;
        /* Compute average queue usage (see RED) */
-       p->qavg = red_calc_qavg(p, sch->q.qlen);
-       if (red_is_idling(p))
-               red_end_of_idle_period(p);
+       q->vars.qavg = red_calc_qavg(p, &q->vars, sch->q.qlen);
+       if (red_is_idling(&q->vars))
+               red_end_of_idle_period(&q->vars);
 
        /* Is queue small? */
-       if (p->qavg <= p->qth_min)
-               p->qcount = -1;
+       if (q->vars.qavg <= p->qth_min)
+               q->vars.qcount = -1;
        else {
                unsigned int idx;
 
@@ -294,8 +295,8 @@ static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                }
 
                /* Queue is large, always mark/drop */
-               if (p->qavg > p->qth_max) {
-                       p->qcount = -1;
+               if (q->vars.qavg > p->qth_max) {
+                       q->vars.qcount = -1;
 
                        sch->qstats.overlimits++;
                        if (use_harddrop(q) || !use_ecn(q) ||
@@ -305,10 +306,10 @@ static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                        }
 
                        q->stats.forced_mark++;
-               } else if (++p->qcount) {
-                       if (red_mark_probability(p, p->qavg)) {
-                               p->qcount = 0;
-                               p->qR = red_random(p);
+               } else if (++q->vars.qcount) {
+                       if (red_mark_probability(p, &q->vars, q->vars.qavg)) {
+                               q->vars.qcount = 0;
+                               q->vars.qR = red_random(p);
 
                                sch->qstats.overlimits++;
                                if (!use_ecn(q) || !INET_ECN_set_ce(skb)) {
@@ -319,7 +320,7 @@ static int choke_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                                q->stats.prob_mark++;
                        }
                } else
-                       p->qR = red_random(p);
+                       q->vars.qR = red_random(p);
        }
 
        /* Admit new packet */
@@ -353,8 +354,8 @@ static struct sk_buff *choke_dequeue(struct Qdisc *sch)
        struct sk_buff *skb;
 
        if (q->head == q->tail) {
-               if (!red_is_idling(&q->parms))
-                       red_start_of_idle_period(&q->parms);
+               if (!red_is_idling(&q->vars))
+                       red_start_of_idle_period(&q->vars);
                return NULL;
        }
 
@@ -377,8 +378,8 @@ static unsigned int choke_drop(struct Qdisc *sch)
        if (len > 0)
                q->stats.other++;
        else {
-               if (!red_is_idling(&q->parms))
-                       red_start_of_idle_period(&q->parms);
+               if (!red_is_idling(&q->vars))
+                       red_start_of_idle_period(&q->vars);
        }
 
        return len;
@@ -388,7 +389,7 @@ static void choke_reset(struct Qdisc *sch)
 {
        struct choke_sched_data *q = qdisc_priv(sch);
 
-       red_restart(&q->parms);
+       red_restart(&q->vars);
 }
 
 static const struct nla_policy choke_policy[TCA_CHOKE_MAX + 1] = {
@@ -482,9 +483,10 @@ static int choke_change(struct Qdisc *sch, struct nlattr *opt)
                      ctl->Plog, ctl->Scell_log,
                      nla_data(tb[TCA_CHOKE_STAB]),
                      max_P);
+       red_set_vars(&q->vars);
 
        if (q->head == q->tail)
-               red_end_of_idle_period(&q->parms);
+               red_end_of_idle_period(&q->vars);
 
        sch_tree_unlock(sch);
        choke_free(old);