1 files changed, 68 insertions, 74 deletions

diff --git a/net/sched/act_gact.c b/net/sched/act_gact.c
index e75a147ad60f..6cff56696a81 100644
--- a/net/sched/act_gact.c
+++ b/net/sched/act_gact.c
@@ -34,48 +34,43 @@
 #include <linux/tc_act/tc_gact.h>
 #include <net/tc_act/tc_gact.h>
 
-/* use generic hash table */
-#define MY_TAB_SIZE     16
-#define MY_TAB_MASK     15
-
-static u32 idx_gen;
-static struct tcf_gact *tcf_gact_ht[MY_TAB_SIZE];
+#define GACT_TAB_MASK   15
+static struct tcf_common *tcf_gact_ht[GACT_TAB_MASK + 1];
+static u32 gact_idx_gen;
 static DEFINE_RWLOCK(gact_lock);
 
-/* ovewrride the defaults */
-#define tcf_st          tcf_gact
-#define tc_st           tc_gact
-#define tcf_t_lock      gact_lock
-#define tcf_ht          tcf_gact_ht
-
-#define CONFIG_NET_ACT_INIT 1
-#include <net/pkt_act.h>
+static struct tcf_hashinfo gact_hash_info = {
+        .htab   =       tcf_gact_ht,
+        .hmask  =       GACT_TAB_MASK,
+        .lock   =       &gact_lock,
+};
 
 #ifdef CONFIG_GACT_PROB
-static int gact_net_rand(struct tcf_gact *p)
+static int gact_net_rand(struct tcf_gact *gact)
 {
-        if (net_random()%p->pval)
-                return p->action;
-        return p->paction;
+        if (net_random() % gact->tcfg_pval)
+                return gact->tcf_action;
+        return gact->tcfg_paction;
 }
 
-static int gact_determ(struct tcf_gact *p)
+static int gact_determ(struct tcf_gact *gact)
 {
-        if (p->bstats.packets%p->pval)
-                return p->action;
-        return p->paction;
+        if (gact->tcf_bstats.packets % gact->tcfg_pval)
+                return gact->tcf_action;
+        return gact->tcfg_paction;
 }
 
-typedef int (*g_rand)(struct tcf_gact *p);
+typedef int (*g_rand)(struct tcf_gact *gact);
 static g_rand gact_rand[MAX_RAND]= { NULL, gact_net_rand, gact_determ };
-#endif
+#endif /* CONFIG_GACT_PROB */
 
 static int tcf_gact_init(struct rtattr *rta, struct rtattr *est,
                          struct tc_action *a, int ovr, int bind)
 {
         struct rtattr *tb[TCA_GACT_MAX];
         struct tc_gact *parm;
-        struct tcf_gact *p;
+        struct tcf_gact *gact;
+        struct tcf_common *pc;
         int ret = 0;
 
         if (rta == NULL || rtattr_parse_nested(tb, TCA_GACT_MAX, rta) < 0)
@@ -94,105 +89,106 @@ static int tcf_gact_init(struct rtattr *rta, struct rtattr *est,
                 return -EOPNOTSUPP;
 #endif
 
-        p = tcf_hash_check(parm->index, a, ovr, bind);
-        if (p == NULL) {
-                p = tcf_hash_create(parm->index, est, a, sizeof(*p), ovr, bind);
-                if (p == NULL)
+        pc = tcf_hash_check(parm->index, a, bind, &gact_hash_info);
+        if (!pc) {
+                pc = tcf_hash_create(parm->index, est, a, sizeof(*gact),
+                                     bind, &gact_idx_gen, &gact_hash_info);
+                if (unlikely(!pc))
                         return -ENOMEM;
                 ret = ACT_P_CREATED;
         } else {
                 if (!ovr) {
-                        tcf_hash_release(p, bind);
+                        tcf_hash_release(pc, bind, &gact_hash_info);
                         return -EEXIST;
                 }
         }
 
-        spin_lock_bh(&p->lock);
-        p->action = parm->action;
+        gact = to_gact(pc);
+
+        spin_lock_bh(&gact->tcf_lock);
+        gact->tcf_action = parm->action;
 #ifdef CONFIG_GACT_PROB
         if (tb[TCA_GACT_PROB-1] != NULL) {
                 struct tc_gact_p *p_parm = RTA_DATA(tb[TCA_GACT_PROB-1]);
-                p->paction = p_parm->paction;
-                p->pval    = p_parm->pval;
-                p->ptype   = p_parm->ptype;
+                gact->tcfg_paction = p_parm->paction;
+                gact->tcfg_pval    = p_parm->pval;
+                gact->tcfg_ptype   = p_parm->ptype;
         }
 #endif
-        spin_unlock_bh(&p->lock);
+        spin_unlock_bh(&gact->tcf_lock);
         if (ret == ACT_P_CREATED)
-                tcf_hash_insert(p);
+                tcf_hash_insert(pc, &gact_hash_info);
         return ret;
 }
 
-static int
-tcf_gact_cleanup(struct tc_action *a, int bind)
+static int tcf_gact_cleanup(struct tc_action *a, int bind)
 {
-        struct tcf_gact *p = PRIV(a, gact);
+        struct tcf_gact *gact = a->priv;
 
-        if (p != NULL)
-                return tcf_hash_release(p, bind);
+        if (gact)
+                return tcf_hash_release(&gact->common, bind, &gact_hash_info);
         return 0;
 }
 
-static int
-tcf_gact(struct sk_buff *skb, struct tc_action *a, struct tcf_result *res)
+static int tcf_gact(struct sk_buff *skb, struct tc_action *a, struct tcf_result *res)
 {
-        struct tcf_gact *p = PRIV(a, gact);
+        struct tcf_gact *gact = a->priv;
         int action = TC_ACT_SHOT;
 
-        spin_lock(&p->lock);
+        spin_lock(&gact->tcf_lock);
 #ifdef CONFIG_GACT_PROB
-        if (p->ptype && gact_rand[p->ptype] != NULL)
-                action = gact_rand[p->ptype](p);
+        if (gact->tcfg_ptype && gact_rand[gact->tcfg_ptype] != NULL)
+                action = gact_rand[gact->tcfg_ptype](gact);
         else
-                action = p->action;
+                action = gact->tcf_action;
 #else
-        action = p->action;
+        action = gact->tcf_action;
 #endif
-        p->bstats.bytes += skb->len;
-        p->bstats.packets++;
+        gact->tcf_bstats.bytes += skb->len;
+        gact->tcf_bstats.packets++;
         if (action == TC_ACT_SHOT)
-                p->qstats.drops++;
-        p->tm.lastuse = jiffies;
-        spin_unlock(&p->lock);
+                gact->tcf_qstats.drops++;
+        gact->tcf_tm.lastuse = jiffies;
+        spin_unlock(&gact->tcf_lock);
 
         return action;
 }
 
-static int
-tcf_gact_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
+static int tcf_gact_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
 {
         unsigned char *b = skb->tail;
         struct tc_gact opt;
-        struct tcf_gact *p = PRIV(a, gact);
+        struct tcf_gact *gact = a->priv;
         struct tcf_t t;
 
-        opt.index = p->index;
-        opt.refcnt = p->refcnt - ref;
-        opt.bindcnt = p->bindcnt - bind;
-        opt.action = p->action;
+        opt.index = gact->tcf_index;
+        opt.refcnt = gact->tcf_refcnt - ref;
+        opt.bindcnt = gact->tcf_bindcnt - bind;
+        opt.action = gact->tcf_action;
         RTA_PUT(skb, TCA_GACT_PARMS, sizeof(opt), &opt);
 #ifdef CONFIG_GACT_PROB
-        if (p->ptype) {
+        if (gact->tcfg_ptype) {
                 struct tc_gact_p p_opt;
-                p_opt.paction = p->paction;
-                p_opt.pval = p->pval;
-                p_opt.ptype = p->ptype;
+                p_opt.paction = gact->tcfg_paction;
+                p_opt.pval = gact->tcfg_pval;
+                p_opt.ptype = gact->tcfg_ptype;
                 RTA_PUT(skb, TCA_GACT_PROB, sizeof(p_opt), &p_opt);
         }
 #endif
-        t.install = jiffies_to_clock_t(jiffies - p->tm.install);
-        t.lastuse = jiffies_to_clock_t(jiffies - p->tm.lastuse);
-        t.expires = jiffies_to_clock_t(p->tm.expires);
+        t.install = jiffies_to_clock_t(jiffies - gact->tcf_tm.install);
+        t.lastuse = jiffies_to_clock_t(jiffies - gact->tcf_tm.lastuse);
+        t.expires = jiffies_to_clock_t(gact->tcf_tm.expires);
         RTA_PUT(skb, TCA_GACT_TM, sizeof(t), &t);
         return skb->len;
 
-      rtattr_failure:
+rtattr_failure:
         skb_trim(skb, b - skb->data);
         return -1;
 }
 
 static struct tc_action_ops act_gact_ops = {
         .kind           =       "gact",
+        .hinfo          =       &gact_hash_info,
         .type           =       TCA_ACT_GACT,
         .capab          =       TCA_CAP_NONE,
         .owner          =       THIS_MODULE,
@@ -208,8 +204,7 @@ MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
 MODULE_DESCRIPTION("Generic Classifier actions");
 MODULE_LICENSE("GPL");
 
-static int __init
-gact_init_module(void)
+static int __init gact_init_module(void)
 {
 #ifdef CONFIG_GACT_PROB
         printk("GACT probability on\n");
@@ -219,8 +214,7 @@ gact_init_module(void)
         return tcf_register_action(&act_gact_ops);
 }
 
-static void __exit
-gact_cleanup_module(void)
+static void __exit gact_cleanup_module(void)
 {
         tcf_unregister_action(&act_gact_ops);
 }