netfilter: nf_tables: simplify the basic expressions' init routine

Some basic expressions are built into nf_tables.ko, such as nft_cmp,
nft_lookup, nft_range and so on. But these basic expressions' init
routine is a little ugly, too many goto errX labels, and we forget
to call nft_range_module_exit in the exit routine, although it is
harmless.

Acctually, the init and exit routines of these basic expressions
are same, i.e. do nft_register_expr in the init routine and do
nft_unregister_expr in the exit routine.

So it's better to arrange them into an array and deal with them
together.

Signed-off-by: Liping Zhang <zlpnobody@gmail.com>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

diff --git a/include/net/netfilter/nf_tables_core.h b/include/net/netfilter/nf_tables_core.h
index 00f4f6b1b1ba0758735ebabdff902c43b22630ee..862373d4ea9d1e5118b10e0064a85901932721cc 100644 (file)
--- a/include/net/netfilter/nf_tables_core.h
+++ b/include/net/netfilter/nf_tables_core.h
@@ -1,12 +1,18 @@
 #ifndef _NET_NF_TABLES_CORE_H
 #define _NET_NF_TABLES_CORE_H
 
+extern struct nft_expr_type nft_imm_type;
+extern struct nft_expr_type nft_cmp_type;
+extern struct nft_expr_type nft_lookup_type;
+extern struct nft_expr_type nft_bitwise_type;
+extern struct nft_expr_type nft_byteorder_type;
+extern struct nft_expr_type nft_payload_type;
+extern struct nft_expr_type nft_dynset_type;
+extern struct nft_expr_type nft_range_type;
+
 int nf_tables_core_module_init(void);
 void nf_tables_core_module_exit(void);
 
-int nft_immediate_module_init(void);
-void nft_immediate_module_exit(void);
-
 struct nft_cmp_fast_expr {
        u32                     data;
        enum nft_registers      sreg:8;
@@ -25,24 +31,6 @@ static inline u32 nft_cmp_fast_mask(unsigned int len)
 
 extern const struct nft_expr_ops nft_cmp_fast_ops;
 
-int nft_cmp_module_init(void);
-void nft_cmp_module_exit(void);
-
-int nft_range_module_init(void);
-void nft_range_module_exit(void);
-
-int nft_lookup_module_init(void);
-void nft_lookup_module_exit(void);
-
-int nft_dynset_module_init(void);
-void nft_dynset_module_exit(void);
-
-int nft_bitwise_module_init(void);
-void nft_bitwise_module_exit(void);
-
-int nft_byteorder_module_init(void);
-void nft_byteorder_module_exit(void);
-
 struct nft_payload {
        enum nft_payload_bases  base:8;
        u8                      offset;
@@ -62,7 +50,4 @@ struct nft_payload_set {
 extern const struct nft_expr_ops nft_payload_fast_ops;
 extern struct static_key_false nft_trace_enabled;
 
-int nft_payload_module_init(void);
-void nft_payload_module_exit(void);
-
 #endif /* _NET_NF_TABLES_CORE_H */

diff --git a/net/netfilter/nf_tables_core.c b/net/netfilter/nf_tables_core.c
index b63b1edb76a66278e0751892b867d9d15e271caf..65dbeadcb11888263527dfff874288ce437744d8 100644 (file)
--- a/net/netfilter/nf_tables_core.c
+++ b/net/netfilter/nf_tables_core.c
@@ -232,68 +232,40 @@ next_rule:
 }
 EXPORT_SYMBOL_GPL(nft_do_chain);
 
+static struct nft_expr_type *nft_basic_types[] = {
+       &nft_imm_type,
+       &nft_cmp_type,
+       &nft_lookup_type,
+       &nft_bitwise_type,
+       &nft_byteorder_type,
+       &nft_payload_type,
+       &nft_dynset_type,
+       &nft_range_type,
+};
+
 int __init nf_tables_core_module_init(void)
 {
-       int err;
-
-       err = nft_immediate_module_init();
-       if (err < 0)
-               goto err1;
-
-       err = nft_cmp_module_init();
-       if (err < 0)
-               goto err2;
-
-       err = nft_lookup_module_init();
-       if (err < 0)
-               goto err3;
-
-       err = nft_bitwise_module_init();
-       if (err < 0)
-               goto err4;
+       int err, i;
 
-       err = nft_byteorder_module_init();
-       if (err < 0)
-               goto err5;
-
-       err = nft_payload_module_init();
-       if (err < 0)
-               goto err6;
-
-       err = nft_dynset_module_init();
-       if (err < 0)
-               goto err7;
-
-       err = nft_range_module_init();
-       if (err < 0)
-               goto err8;
+       for (i = 0; i < ARRAY_SIZE(nft_basic_types); i++) {
+               err = nft_register_expr(nft_basic_types[i]);
+               if (err)
+                       goto err;
+       }
 
        return 0;
-err8:
-       nft_dynset_module_exit();
-err7:
-       nft_payload_module_exit();
-err6:
-       nft_byteorder_module_exit();
-err5:
-       nft_bitwise_module_exit();
-err4:
-       nft_lookup_module_exit();
-err3:
-       nft_cmp_module_exit();
-err2:
-       nft_immediate_module_exit();
-err1:
+
+err:
+       while (i-- > 0)
+               nft_unregister_expr(nft_basic_types[i]);
        return err;
 }
 
 void nf_tables_core_module_exit(void)
 {
-       nft_dynset_module_exit();
-       nft_payload_module_exit();
-       nft_byteorder_module_exit();
-       nft_bitwise_module_exit();
-       nft_lookup_module_exit();
-       nft_cmp_module_exit();
-       nft_immediate_module_exit();
+       int i;
+
+       i = ARRAY_SIZE(nft_basic_types);
+       while (i-- > 0)
+               nft_unregister_expr(nft_basic_types[i]);
 }

diff --git a/net/netfilter/nft_bitwise.c b/net/netfilter/nft_bitwise.c
index 31c15ed2e5fcb1cce63c620650d17bc0942a8ce2..877d9acd91ef5c616c43d00f265facbfe4c2d334 100644 (file)
--- a/net/netfilter/nft_bitwise.c
+++ b/net/netfilter/nft_bitwise.c
@@ -121,7 +121,6 @@ nla_put_failure:
        return -1;
 }
 
-static struct nft_expr_type nft_bitwise_type;
 static const struct nft_expr_ops nft_bitwise_ops = {
        .type           = &nft_bitwise_type,
        .size           = NFT_EXPR_SIZE(sizeof(struct nft_bitwise)),
@@ -130,20 +129,10 @@ static const struct nft_expr_ops nft_bitwise_ops = {
        .dump           = nft_bitwise_dump,
 };
 
-static struct nft_expr_type nft_bitwise_type __read_mostly = {
+struct nft_expr_type nft_bitwise_type __read_mostly = {
        .name           = "bitwise",
        .ops            = &nft_bitwise_ops,
        .policy         = nft_bitwise_policy,
        .maxattr        = NFTA_BITWISE_MAX,
        .owner          = THIS_MODULE,
 };
-
-int __init nft_bitwise_module_init(void)
-{
-       return nft_register_expr(&nft_bitwise_type);
-}
-
-void nft_bitwise_module_exit(void)
-{
-       nft_unregister_expr(&nft_bitwise_type);
-}

diff --git a/net/netfilter/nft_byteorder.c b/net/netfilter/nft_byteorder.c
index ee63d981268d9ebb8fd42329bd0e242195e09003..13d4e421a6b33ccc44ff3c70ab6bb9c38d256822 100644 (file)
--- a/net/netfilter/nft_byteorder.c
+++ b/net/netfilter/nft_byteorder.c
@@ -169,7 +169,6 @@ nla_put_failure:
        return -1;
 }
 
-static struct nft_expr_type nft_byteorder_type;
 static const struct nft_expr_ops nft_byteorder_ops = {
        .type           = &nft_byteorder_type,
        .size           = NFT_EXPR_SIZE(sizeof(struct nft_byteorder)),
@@ -178,20 +177,10 @@ static const struct nft_expr_ops nft_byteorder_ops = {
        .dump           = nft_byteorder_dump,
 };
 
-static struct nft_expr_type nft_byteorder_type __read_mostly = {
+struct nft_expr_type nft_byteorder_type __read_mostly = {
        .name           = "byteorder",
        .ops            = &nft_byteorder_ops,
        .policy         = nft_byteorder_policy,
        .maxattr        = NFTA_BYTEORDER_MAX,
        .owner          = THIS_MODULE,
 };
-
-int __init nft_byteorder_module_init(void)
-{
-       return nft_register_expr(&nft_byteorder_type);
-}
-
-void nft_byteorder_module_exit(void)
-{
-       nft_unregister_expr(&nft_byteorder_type);
-}

diff --git a/net/netfilter/nft_cmp.c b/net/netfilter/nft_cmp.c
index e25b35d70e4dc8a1f63de86f112f37760c132227..2b96effeadc1bc708a1f16e89342c8d39c4c4da7 100644 (file)
--- a/net/netfilter/nft_cmp.c
+++ b/net/netfilter/nft_cmp.c
@@ -107,7 +107,6 @@ nla_put_failure:
        return -1;
 }
 
-static struct nft_expr_type nft_cmp_type;
 static const struct nft_expr_ops nft_cmp_ops = {
        .type           = &nft_cmp_type,
        .size           = NFT_EXPR_SIZE(sizeof(struct nft_cmp_expr)),
@@ -208,20 +207,10 @@ nft_cmp_select_ops(const struct nft_ctx *ctx, const struct nlattr * const tb[])
                return &nft_cmp_ops;
 }
 
-static struct nft_expr_type nft_cmp_type __read_mostly = {
+struct nft_expr_type nft_cmp_type __read_mostly = {
        .name           = "cmp",
        .select_ops     = nft_cmp_select_ops,
        .policy         = nft_cmp_policy,
        .maxattr        = NFTA_CMP_MAX,
        .owner          = THIS_MODULE,
 };
-
-int __init nft_cmp_module_init(void)
-{
-       return nft_register_expr(&nft_cmp_type);
-}
-
-void nft_cmp_module_exit(void)
-{
-       nft_unregister_expr(&nft_cmp_type);
-}

diff --git a/net/netfilter/nft_dynset.c b/net/netfilter/nft_dynset.c
index 517f08767a3cd677dba53c1f6ec28f77288ebcbc..4339e3f1c4b11f0f2357f9592339cd4f58ffcb48 100644 (file)
--- a/net/netfilter/nft_dynset.c
+++ b/net/netfilter/nft_dynset.c
@@ -261,7 +261,6 @@ nla_put_failure:
        return -1;
 }
 
-static struct nft_expr_type nft_dynset_type;
 static const struct nft_expr_ops nft_dynset_ops = {
        .type           = &nft_dynset_type,
        .size           = NFT_EXPR_SIZE(sizeof(struct nft_dynset)),
@@ -271,20 +270,10 @@ static const struct nft_expr_ops nft_dynset_ops = {
        .dump           = nft_dynset_dump,
 };
 
-static struct nft_expr_type nft_dynset_type __read_mostly = {
+struct nft_expr_type nft_dynset_type __read_mostly = {
        .name           = "dynset",
        .ops            = &nft_dynset_ops,
        .policy         = nft_dynset_policy,
        .maxattr        = NFTA_DYNSET_MAX,
        .owner          = THIS_MODULE,
 };
-
-int __init nft_dynset_module_init(void)
-{
-       return nft_register_expr(&nft_dynset_type);
-}
-
-void nft_dynset_module_exit(void)
-{
-       nft_unregister_expr(&nft_dynset_type);
-}

diff --git a/net/netfilter/nft_immediate.c b/net/netfilter/nft_immediate.c
index 4528adea7ede873652c8ab7b5f9184e0d135ede9..728baf88295aab3d4f0e1272d551672ae5a2fb13 100644 (file)
--- a/net/netfilter/nft_immediate.c
+++ b/net/netfilter/nft_immediate.c
@@ -102,7 +102,6 @@ static int nft_immediate_validate(const struct nft_ctx *ctx,
        return 0;
 }
 
-static struct nft_expr_type nft_imm_type;
 static const struct nft_expr_ops nft_imm_ops = {
        .type           = &nft_imm_type,
        .size           = NFT_EXPR_SIZE(sizeof(struct nft_immediate_expr)),
@@ -113,20 +112,10 @@ static const struct nft_expr_ops nft_imm_ops = {
        .validate       = nft_immediate_validate,
 };
 
-static struct nft_expr_type nft_imm_type __read_mostly = {
+struct nft_expr_type nft_imm_type __read_mostly = {
        .name           = "immediate",
        .ops            = &nft_imm_ops,
        .policy         = nft_immediate_policy,
        .maxattr        = NFTA_IMMEDIATE_MAX,
        .owner          = THIS_MODULE,
 };
-
-int __init nft_immediate_module_init(void)
-{
-       return nft_register_expr(&nft_imm_type);
-}
-
-void nft_immediate_module_exit(void)
-{
-       nft_unregister_expr(&nft_imm_type);
-}

diff --git a/net/netfilter/nft_lookup.c b/net/netfilter/nft_lookup.c
index a8ce49bcda80c89f37d8483789ac14af17291a81..d4f97fa7e21d0036690e229768ab097fc5220cfc 100644 (file)
--- a/net/netfilter/nft_lookup.c
+++ b/net/netfilter/nft_lookup.c
@@ -154,7 +154,6 @@ nla_put_failure:
        return -1;
 }
 
-static struct nft_expr_type nft_lookup_type;
 static const struct nft_expr_ops nft_lookup_ops = {
        .type           = &nft_lookup_type,
        .size           = NFT_EXPR_SIZE(sizeof(struct nft_lookup)),
@@ -164,20 +163,10 @@ static const struct nft_expr_ops nft_lookup_ops = {
        .dump           = nft_lookup_dump,
 };
 
-static struct nft_expr_type nft_lookup_type __read_mostly = {
+struct nft_expr_type nft_lookup_type __read_mostly = {
        .name           = "lookup",
        .ops            = &nft_lookup_ops,
        .policy         = nft_lookup_policy,
        .maxattr        = NFTA_LOOKUP_MAX,
        .owner          = THIS_MODULE,
 };
-
-int __init nft_lookup_module_init(void)
-{
-       return nft_register_expr(&nft_lookup_type);
-}
-
-void nft_lookup_module_exit(void)
-{
-       nft_unregister_expr(&nft_lookup_type);
-}

diff --git a/net/netfilter/nft_payload.c b/net/netfilter/nft_payload.c
index b2f88617611aac450631e606174f5bfd58cd38fa..98fb5d7b8087f60f5b97109b2570169631286590 100644 (file)
--- a/net/netfilter/nft_payload.c
+++ b/net/netfilter/nft_payload.c
@@ -148,7 +148,6 @@ nla_put_failure:
        return -1;
 }
 
-static struct nft_expr_type nft_payload_type;
 static const struct nft_expr_ops nft_payload_ops = {
        .type           = &nft_payload_type,
        .size           = NFT_EXPR_SIZE(sizeof(struct nft_payload)),
@@ -320,20 +319,10 @@ nft_payload_select_ops(const struct nft_ctx *ctx,
                return &nft_payload_ops;
 }
 
-static struct nft_expr_type nft_payload_type __read_mostly = {
+struct nft_expr_type nft_payload_type __read_mostly = {
        .name           = "payload",
        .select_ops     = nft_payload_select_ops,
        .policy         = nft_payload_policy,
        .maxattr        = NFTA_PAYLOAD_MAX,
        .owner          = THIS_MODULE,
 };
-
-int __init nft_payload_module_init(void)
-{
-       return nft_register_expr(&nft_payload_type);
-}
-
-void nft_payload_module_exit(void)
-{
-       nft_unregister_expr(&nft_payload_type);
-}

diff --git a/net/netfilter/nft_range.c b/net/netfilter/nft_range.c
index fbc88009ca2ef938a5d4b0fd1c597543ff804fcc..009062606697dc76ccf90d1a1a1c98b6ded00a1c 100644 (file)
--- a/net/netfilter/nft_range.c
+++ b/net/netfilter/nft_range.c
@@ -122,7 +122,6 @@ nla_put_failure:
        return -1;
 }
 
-static struct nft_expr_type nft_range_type;
 static const struct nft_expr_ops nft_range_ops = {
        .type           = &nft_range_type,
        .size           = NFT_EXPR_SIZE(sizeof(struct nft_range_expr)),
@@ -131,20 +130,10 @@ static const struct nft_expr_ops nft_range_ops = {
        .dump           = nft_range_dump,
 };
 
-static struct nft_expr_type nft_range_type __read_mostly = {
+struct nft_expr_type nft_range_type __read_mostly = {
        .name           = "range",
        .ops            = &nft_range_ops,
        .policy         = nft_range_policy,
        .maxattr        = NFTA_RANGE_MAX,
        .owner          = THIS_MODULE,
 };
-
-int __init nft_range_module_init(void)
-{
-       return nft_register_expr(&nft_range_type);
-}
-
-void nft_range_module_exit(void)
-{
-       nft_unregister_expr(&nft_range_type);
-}