Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4e24877e authored by Liping Zhang's avatar Liping Zhang Committed by Pablo Neira Ayuso
Browse files

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: default avatarLiping Zhang <zlpnobody@gmail.com>
Signed-off-by: default avatarPablo Neira Ayuso <pablo@netfilter.org>
parent f86dab3a

include/net/netfilter/nf_tables_core.h

+9 −24
Original line number Diff line number Diff line 
#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 */

net/netfilter/nf_tables_core.c

+26 −54
Original line number Diff line number Diff line
@@ -232,68 +232,40 @@ nft_do_chain(struct nft_pktinfo *pkt, void *priv) 
}

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]);

}

net/netfilter/nft_bitwise.c

+1 −12
Original line number Diff line number Diff line
@@ -121,7 +121,6 @@ static int nft_bitwise_dump(struct sk_buff *skb, const struct nft_expr *expr) 
	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);

}

net/netfilter/nft_byteorder.c

+1 −12
Original line number Diff line number Diff line
@@ -169,7 +169,6 @@ static int nft_byteorder_dump(struct sk_buff *skb, const struct nft_expr *expr) 
	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);

}

net/netfilter/nft_cmp.c

+1 −12
Original line number Diff line number Diff line
@@ -107,7 +107,6 @@ static int nft_cmp_dump(struct sk_buff *skb, const struct nft_expr *expr) 
	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);

}