net_sched: red: split red_parms into parms and vars

This patch splits the red_parms structure into two components.

One holding the RED 'constant' parameters, and one containing the
variables.

This permits a size reduction of GRED qdisc, and is a preliminary step
to add an optional RED unit to SFQ.

SFQRED will have a single red_parms structure shared by all flows, and a
private red_vars per flow.

Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
CC: Dave Taht <dave.taht@gmail.com>
CC: Stephen Hemminger <shemminger@vyatta.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 21 insertions, 19 deletions

diff --git a/net/sched/sch_choke.c b/net/sched/sch_choke.c
index bef00acb8bd2..e465064d39a3 100644
--- 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);