[PKT_SCHED]: Kill pkt_act.h inlining.

This was simply making templates of functions and mostly causing a lot
of code duplication in the classifier action modules.

We solve this more cleanly by having a common "struct tcf_common" that
hash worker functions contained once in act_api.c can work with.

Callers work with real action objects that have the common struct
plus their module specific struct members.  You go from a common
object to the higher level one using a "to_foo()" macro which makes
use of container_of() to do the dirty work.

This also kills off act_generic.h which was only used by act_simple.c
and keeping it around was more work than the it's value.

Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 79 insertions, 96 deletions

diff --git a/net/sched/act_ipt.c b/net/sched/act_ipt.c
index d799e01248c4..224c078a398e 100644
--- a/net/sched/act_ipt.c
+++ b/net/sched/act_ipt.c
@@ -38,25 +38,19 @@
 
 #include <linux/netfilter_ipv4/ip_tables.h>
 
-/* use generic hash table */
-#define MY_TAB_SIZE     16
-#define MY_TAB_MASK     15
 
-static u32 idx_gen;
-static struct tcf_ipt *tcf_ipt_ht[MY_TAB_SIZE];
-/* ipt hash table lock */
+#define IPT_TAB_MASK     15
+static struct tcf_common *tcf_ipt_ht[IPT_TAB_MASK + 1];
+static u32 ipt_idx_gen;
 static DEFINE_RWLOCK(ipt_lock);
 
-/* ovewrride the defaults */
-#define tcf_st          tcf_ipt
-#define tcf_t_lock      ipt_lock
-#define tcf_ht          tcf_ipt_ht
-
-#define CONFIG_NET_ACT_INIT
-#include <net/pkt_act.h>
+static struct tcf_hashinfo ipt_hash_info = {
+        .htab   =       tcf_ipt_ht,
+        .hmask  =       IPT_TAB_MASK,
+        .lock   =       &ipt_lock,
+};
 
-static int
-ipt_init_target(struct ipt_entry_target *t, char *table, unsigned int hook)
+static int ipt_init_target(struct ipt_entry_target *t, char *table, unsigned int hook)
 {
         struct ipt_target *target;
         int ret = 0;
@@ -65,7 +59,6 @@ ipt_init_target(struct ipt_entry_target *t, char *table, unsigned int hook)
         if (!target)
                 return -ENOENT;
 
-        DPRINTK("ipt_init_target: found %s\n", target->name);
         t->u.kernel.target = target;
 
         ret = xt_check_target(target, AF_INET, t->u.target_size - sizeof(*t),
@@ -78,8 +71,6 @@ ipt_init_target(struct ipt_entry_target *t, char *table, unsigned int hook)
                                                t->u.kernel.target, t->data,
                                                t->u.target_size - sizeof(*t),
                                                hook)) {
-                DPRINTK("ipt_init_target: check failed for `%s'.\n",
-                        t->u.kernel.target->name);
                 module_put(t->u.kernel.target->me);
                 ret = -EINVAL;
         }
@@ -87,8 +78,7 @@ ipt_init_target(struct ipt_entry_target *t, char *table, unsigned int hook)
         return ret;
 }
 
-static void
-ipt_destroy_target(struct ipt_entry_target *t)
+static void ipt_destroy_target(struct ipt_entry_target *t)
 {
         if (t->u.kernel.target->destroy)
                 t->u.kernel.target->destroy(t->u.kernel.target, t->data,
@@ -96,31 +86,30 @@ ipt_destroy_target(struct ipt_entry_target *t)
         module_put(t->u.kernel.target->me);
 }
 
-static int
-tcf_ipt_release(struct tcf_ipt *p, int bind)
+static int tcf_ipt_release(struct tcf_ipt *ipt, int bind)
 {
         int ret = 0;
-        if (p) {
+        if (ipt) {
                 if (bind)
-                        p->bindcnt--;
-                p->refcnt--;
-                if (p->bindcnt <= 0 && p->refcnt <= 0) {
-                        ipt_destroy_target(p->t);
-                        kfree(p->tname);
-                        kfree(p->t);
-                        tcf_hash_destroy(p);
+                        ipt->tcf_bindcnt--;
+                ipt->tcf_refcnt--;
+                if (ipt->tcf_bindcnt <= 0 && ipt->tcf_refcnt <= 0) {
+                        ipt_destroy_target(ipt->tcfi_t);
+                        kfree(ipt->tcfi_tname);
+                        kfree(ipt->tcfi_t);
+                        tcf_hash_destroy(&ipt->common, &ipt_hash_info);
                         ret = ACT_P_DELETED;
                 }
         }
         return ret;
 }
 
-static int
-tcf_ipt_init(struct rtattr *rta, struct rtattr *est, struct tc_action *a,
-             int ovr, int bind)
+static int tcf_ipt_init(struct rtattr *rta, struct rtattr *est,
+                        struct tc_action *a, int ovr, int bind)
 {
         struct rtattr *tb[TCA_IPT_MAX];
-        struct tcf_ipt *p;
+        struct tcf_ipt *ipt;
+        struct tcf_common *pc;
         struct ipt_entry_target *td, *t;
         char *tname;
         int ret = 0, err;
@@ -144,49 +133,51 @@ tcf_ipt_init(struct rtattr *rta, struct rtattr *est, struct tc_action *a,
             RTA_PAYLOAD(tb[TCA_IPT_INDEX-1]) >= sizeof(u32))
                 index = *(u32 *)RTA_DATA(tb[TCA_IPT_INDEX-1]);
 
-        p = tcf_hash_check(index, a, ovr, bind);
-        if (p == NULL) {
-                p = tcf_hash_create(index, est, a, sizeof(*p), ovr, bind);
-                if (p == NULL)
+        pc = tcf_hash_check(index, a, bind, &ipt_hash_info);
+        if (!pc) {
+                pc = tcf_hash_create(index, est, a, sizeof(*ipt), bind,
+                                     &ipt_idx_gen, &ipt_hash_info);
+                if (unlikely(!pc))
                         return -ENOMEM;
                 ret = ACT_P_CREATED;
         } else {
                 if (!ovr) {
-                        tcf_ipt_release(p, bind);
+                        tcf_ipt_release(to_ipt(pc), bind);
                         return -EEXIST;
                 }
         }
+        ipt = to_ipt(pc);
 
         hook = *(u32 *)RTA_DATA(tb[TCA_IPT_HOOK-1]);
 
         err = -ENOMEM;
         tname = kmalloc(IFNAMSIZ, GFP_KERNEL);
-        if (tname == NULL)
+        if (unlikely(!tname))
                 goto err1;
         if (tb[TCA_IPT_TABLE - 1] == NULL ||
             rtattr_strlcpy(tname, tb[TCA_IPT_TABLE-1], IFNAMSIZ) >= IFNAMSIZ)
                 strcpy(tname, "mangle");
 
         t = kmalloc(td->u.target_size, GFP_KERNEL);
-        if (t == NULL)
+        if (unlikely(!t))
                 goto err2;
         memcpy(t, td, td->u.target_size);
 
         if ((err = ipt_init_target(t, tname, hook)) < 0)
                 goto err3;
 
-        spin_lock_bh(&p->lock);
+        spin_lock_bh(&ipt->tcf_lock);
         if (ret != ACT_P_CREATED) {
-                ipt_destroy_target(p->t);
-                kfree(p->tname);
-                kfree(p->t);
+                ipt_destroy_target(ipt->tcfi_t);
+                kfree(ipt->tcfi_tname);
+                kfree(ipt->tcfi_t);
         }
-        p->tname = tname;
-        p->t     = t;
-        p->hook  = hook;
-        spin_unlock_bh(&p->lock);
+        ipt->tcfi_tname = tname;
+        ipt->tcfi_t     = t;
+        ipt->tcfi_hook  = hook;
+        spin_unlock_bh(&ipt->tcf_lock);
         if (ret == ACT_P_CREATED)
-                tcf_hash_insert(p);
+                tcf_hash_insert(pc, &ipt_hash_info);
         return ret;
 
 err3:
@@ -194,33 +185,32 @@ err3:
 err2:
         kfree(tname);
 err1:
-        kfree(p);
+        kfree(pc);
         return err;
 }
 
-static int
-tcf_ipt_cleanup(struct tc_action *a, int bind)
+static int tcf_ipt_cleanup(struct tc_action *a, int bind)
 {
-        struct tcf_ipt *p = PRIV(a, ipt);
-        return tcf_ipt_release(p, bind);
+        struct tcf_ipt *ipt = a->priv;
+        return tcf_ipt_release(ipt, bind);
 }
 
-static int
-tcf_ipt(struct sk_buff *skb, struct tc_action *a, struct tcf_result *res)
+static int tcf_ipt(struct sk_buff *skb, struct tc_action *a,
+                   struct tcf_result *res)
 {
         int ret = 0, result = 0;
-        struct tcf_ipt *p = PRIV(a, ipt);
+        struct tcf_ipt *ipt = a->priv;
 
         if (skb_cloned(skb)) {
                 if (pskb_expand_head(skb, 0, 0, GFP_ATOMIC))
                         return TC_ACT_UNSPEC;
         }
 
-        spin_lock(&p->lock);
+        spin_lock(&ipt->tcf_lock);
 
-        p->tm.lastuse = jiffies;
-        p->bstats.bytes += skb->len;
-        p->bstats.packets++;
+        ipt->tcf_tm.lastuse = jiffies;
+        ipt->tcf_bstats.bytes += skb->len;
+        ipt->tcf_bstats.packets++;
 
         /* yes, we have to worry about both in and out dev
          worry later - danger - this API seems to have changed
@@ -229,16 +219,17 @@ tcf_ipt(struct sk_buff *skb, struct tc_action *a, struct tcf_result *res)
         /* iptables targets take a double skb pointer in case the skb
          * needs to be replaced. We don't own the skb, so this must not
          * happen. The pskb_expand_head above should make sure of this */
-        ret = p->t->u.kernel.target->target(&skb, skb->dev, NULL, p->hook,
-                                            p->t->u.kernel.target, p->t->data,
-                                            NULL);
+        ret = ipt->tcfi_t->u.kernel.target->target(&skb, skb->dev, NULL,
+                                                   ipt->tcfi_hook,
+                                                   ipt->tcfi_t->u.kernel.target,
+                                                   ipt->tcfi_t->data, NULL);
         switch (ret) {
         case NF_ACCEPT:
                 result = TC_ACT_OK;
                 break;
         case NF_DROP:
                 result = TC_ACT_SHOT;
-                p->qstats.drops++;
+                ipt->tcf_qstats.drops++;
                 break;
         case IPT_CONTINUE:
                 result = TC_ACT_PIPE;
@@ -249,53 +240,46 @@ tcf_ipt(struct sk_buff *skb, struct tc_action *a, struct tcf_result *res)
                 result = TC_POLICE_OK;
                 break;
         }
-        spin_unlock(&p->lock);
+        spin_unlock(&ipt->tcf_lock);
         return result;
 
 }
 
-static int
-tcf_ipt_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
+static int tcf_ipt_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
 {
+        unsigned char *b = skb->tail;
+        struct tcf_ipt *ipt = a->priv;
         struct ipt_entry_target *t;
         struct tcf_t tm;
         struct tc_cnt c;
-        unsigned char *b = skb->tail;
-        struct tcf_ipt *p = PRIV(a, ipt);
 
         /* for simple targets kernel size == user size
         ** user name = target name
         ** for foolproof you need to not assume this
         */
 
-        t = kmalloc(p->t->u.user.target_size, GFP_ATOMIC);
-        if (t == NULL)
+        t = kmalloc(ipt->tcfi_t->u.user.target_size, GFP_ATOMIC);
+        if (unlikely(!t))
                 goto rtattr_failure;
 
-        c.bindcnt = p->bindcnt - bind;
-        c.refcnt = p->refcnt - ref;
-        memcpy(t, p->t, p->t->u.user.target_size);
-        strcpy(t->u.user.name, p->t->u.kernel.target->name);
-
-        DPRINTK("\ttcf_ipt_dump tablename %s length %d\n", p->tname,
-                strlen(p->tname));
-        DPRINTK("\tdump target name %s size %d size user %d "
-                "data[0] %x data[1] %x\n", p->t->u.kernel.target->name,
-                p->t->u.target_size, p->t->u.user.target_size,
-                p->t->data[0], p->t->data[1]);
-        RTA_PUT(skb, TCA_IPT_TARG, p->t->u.user.target_size, t);
-        RTA_PUT(skb, TCA_IPT_INDEX, 4, &p->index);
-        RTA_PUT(skb, TCA_IPT_HOOK, 4, &p->hook);
+        c.bindcnt = ipt->tcf_bindcnt - bind;
+        c.refcnt = ipt->tcf_refcnt - ref;
+        memcpy(t, ipt->tcfi_t, ipt->tcfi_t->u.user.target_size);
+        strcpy(t->u.user.name, ipt->tcfi_t->u.kernel.target->name);
+
+        RTA_PUT(skb, TCA_IPT_TARG, ipt->tcfi_t->u.user.target_size, t);
+        RTA_PUT(skb, TCA_IPT_INDEX, 4, &ipt->tcf_index);
+        RTA_PUT(skb, TCA_IPT_HOOK, 4, &ipt->tcfi_hook);
         RTA_PUT(skb, TCA_IPT_CNT, sizeof(struct tc_cnt), &c);
-        RTA_PUT(skb, TCA_IPT_TABLE, IFNAMSIZ, p->tname);
-        tm.install = jiffies_to_clock_t(jiffies - p->tm.install);
-        tm.lastuse = jiffies_to_clock_t(jiffies - p->tm.lastuse);
-        tm.expires = jiffies_to_clock_t(p->tm.expires);
+        RTA_PUT(skb, TCA_IPT_TABLE, IFNAMSIZ, ipt->tcfi_tname);
+        tm.install = jiffies_to_clock_t(jiffies - ipt->tcf_tm.install);
+        tm.lastuse = jiffies_to_clock_t(jiffies - ipt->tcf_tm.lastuse);
+        tm.expires = jiffies_to_clock_t(ipt->tcf_tm.expires);
         RTA_PUT(skb, TCA_IPT_TM, sizeof (tm), &tm);
         kfree(t);
         return skb->len;
 
-      rtattr_failure:
+rtattr_failure:
         skb_trim(skb, b - skb->data);
         kfree(t);
         return -1;
@@ -303,6 +287,7 @@ tcf_ipt_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
 
 static struct tc_action_ops act_ipt_ops = {
         .kind           =       "ipt",
+        .hinfo          =       &ipt_hash_info,
         .type           =       TCA_ACT_IPT,
         .capab          =       TCA_CAP_NONE,
         .owner          =       THIS_MODULE,
@@ -318,14 +303,12 @@ MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
 MODULE_DESCRIPTION("Iptables target actions");
 MODULE_LICENSE("GPL");
 
-static int __init
-ipt_init_module(void)
+static int __init ipt_init_module(void)
 {
         return tcf_register_action(&act_ipt_ops);
 }
 
-static void __exit
-ipt_cleanup_module(void)
+static void __exit ipt_cleanup_module(void)
 {
         tcf_unregister_action(&act_ipt_ops);
 }