Commit fdacd57c authored by Florian Westphal's avatar Florian Westphal Committed by Pablo Neira Ayuso
Browse files

netfilter: x_tables: never register tables by default 



For historical reasons x_tables still register tables by default in the
initial namespace.
Only newly created net namespaces add the hook on demand.

This means that the init_net always pays hook cost, even if no filtering
rules are added (e.g. only used inside a single netns).

Note that the hooks are added even when 'iptables -L' is called.
This is because there is no way to tell 'iptables -A' and 'iptables -L'
apart at kernel level.

The only solution would be to register the table, but delay hook
registration until the first rule gets added (or policy gets changed).

That however means that counters are not hooked either, so 'iptables -L'
would always show 0-counters even when traffic is flowing which might be
unexpected.

This keeps table and hook registration consistent with what is already done
in non-init netns: first iptables(-save) invocation registers both table
and hooks.

This applies the same solution adopted for ebtables.
All tables register a template that contains the l3 family, the name
and a constructor function that is called when the initial table has to
be added.

Signed-off-by: default avatarFlorian Westphal <fw@strlen.de>
Signed-off-by: default avatarPablo Neira Ayuso <pablo@netfilter.org>
parent 9344988d

include/linux/netfilter/x_tables.h

+3 −3
Original line number Diff line number Diff line
@@ -238,9 +238,6 @@ struct xt_table { 
	u_int8_t af;		/* address/protocol family */

	int priority;		/* hook order */



	/* called when table is needed in the given netns */

	int (*table_init)(struct net *net);



	/* A unique name... */

	const char name[XT_TABLE_MAXNAMELEN];

};
@@ -452,6 +449,9 @@ xt_get_per_cpu_counter(struct xt_counters *cnt, unsigned int cpu) 


struct nf_hook_ops *xt_hook_ops_alloc(const struct xt_table *, nf_hookfn *);



int xt_register_template(const struct xt_table *t, int(*table_init)(struct net *net));

void xt_unregister_template(const struct xt_table *t);



#ifdef CONFIG_NETFILTER_XTABLES_COMPAT

#include <net/compat.h>

net/ipv4/netfilter/arptable_filter.c

+11 −12
Original line number Diff line number Diff line
@@ -18,15 +18,12 @@ MODULE_DESCRIPTION("arptables filter table"); 
#define FILTER_VALID_HOOKS ((1 << NF_ARP_IN) | (1 << NF_ARP_OUT) | \

			   (1 << NF_ARP_FORWARD))



static int __net_init arptable_filter_table_init(struct net *net);



static const struct xt_table packet_filter = {

	.name		= "filter",

	.valid_hooks	= FILTER_VALID_HOOKS,

	.me		= THIS_MODULE,

	.af		= NFPROTO_ARP,

	.priority	= NF_IP_PRI_FILTER,

	.table_init	= arptable_filter_table_init,

};



/* The work comes in here from netfilter.c */
@@ -39,7 +36,7 @@ arptable_filter_hook(void *priv, struct sk_buff *skb, 


static struct nf_hook_ops *arpfilter_ops __read_mostly;



static int __net_init arptable_filter_table_init(struct net *net)

static int arptable_filter_table_init(struct net *net)

{

	struct arpt_replace *repl;

	int err;
@@ -69,30 +66,32 @@ static struct pernet_operations arptable_filter_net_ops = { 


static int __init arptable_filter_init(void)

{

	int ret;

	int ret = xt_register_template(&packet_filter,

				       arptable_filter_table_init);



	if (ret < 0)

		return ret;



	arpfilter_ops = xt_hook_ops_alloc(&packet_filter, arptable_filter_hook);

	if (IS_ERR(arpfilter_ops))

	if (IS_ERR(arpfilter_ops)) {

		xt_unregister_template(&packet_filter);

		return PTR_ERR(arpfilter_ops);

	}



	ret = register_pernet_subsys(&arptable_filter_net_ops);

	if (ret < 0) {

		xt_unregister_template(&packet_filter);

		kfree(arpfilter_ops);

		return ret;

	}



	ret = arptable_filter_table_init(&init_net);

	if (ret) {

		unregister_pernet_subsys(&arptable_filter_net_ops);

		kfree(arpfilter_ops);

	}



	return ret;

}



static void __exit arptable_filter_fini(void)

{

	unregister_pernet_subsys(&arptable_filter_net_ops);

	xt_unregister_template(&packet_filter);

	kfree(arpfilter_ops);

}

net/ipv4/netfilter/iptable_filter.c

+16 −8
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ MODULE_DESCRIPTION("iptables filter table"); 
#define FILTER_VALID_HOOKS ((1 << NF_INET_LOCAL_IN) | \

			    (1 << NF_INET_FORWARD) | \

			    (1 << NF_INET_LOCAL_OUT))

static int __net_init iptable_filter_table_init(struct net *net);



static const struct xt_table packet_filter = {

	.name		= "filter",
@@ -27,7 +26,6 @@ static const struct xt_table packet_filter = { 
	.me		= THIS_MODULE,

	.af		= NFPROTO_IPV4,

	.priority	= NF_IP_PRI_FILTER,

	.table_init	= iptable_filter_table_init,

};



static unsigned int
@@ -43,7 +41,7 @@ static struct nf_hook_ops *filter_ops __read_mostly; 
static bool forward __read_mostly = true;

module_param(forward, bool, 0000);



static int __net_init iptable_filter_table_init(struct net *net)

static int iptable_filter_table_init(struct net *net)

{

	struct ipt_replace *repl;

	int err;
@@ -62,7 +60,7 @@ static int __net_init iptable_filter_table_init(struct net *net) 


static int __net_init iptable_filter_net_init(struct net *net)

{

	if (net == &init_net || !forward)

	if (!forward)

		return iptable_filter_table_init(net);



	return 0;
@@ -86,22 +84,32 @@ static struct pernet_operations iptable_filter_net_ops = { 


static int __init iptable_filter_init(void)

{

	int ret;

	int ret = xt_register_template(&packet_filter,

				       iptable_filter_table_init);



	if (ret < 0)

		return ret;



	filter_ops = xt_hook_ops_alloc(&packet_filter, iptable_filter_hook);

	if (IS_ERR(filter_ops))

	if (IS_ERR(filter_ops)) {

		xt_unregister_template(&packet_filter);

		return PTR_ERR(filter_ops);

	}



	ret = register_pernet_subsys(&iptable_filter_net_ops);

	if (ret < 0)

	if (ret < 0) {

		xt_unregister_template(&packet_filter);

		kfree(filter_ops);



		return ret;

	}



	return 0;

}



static void __exit iptable_filter_fini(void)

{

	unregister_pernet_subsys(&iptable_filter_net_ops);

	xt_unregister_template(&packet_filter);

	kfree(filter_ops);

}

net/ipv4/netfilter/iptable_mangle.c

+6 −11
Original line number Diff line number Diff line
@@ -25,15 +25,12 @@ MODULE_DESCRIPTION("iptables mangle table"); 
			    (1 << NF_INET_LOCAL_OUT) | \

			    (1 << NF_INET_POST_ROUTING))



static int __net_init iptable_mangle_table_init(struct net *net);



static const struct xt_table packet_mangler = {

	.name		= "mangle",

	.valid_hooks	= MANGLE_VALID_HOOKS,

	.me		= THIS_MODULE,

	.af		= NFPROTO_IPV4,

	.priority	= NF_IP_PRI_MANGLE,

	.table_init	= iptable_mangle_table_init,

};



static unsigned int
@@ -83,7 +80,7 @@ iptable_mangle_hook(void *priv, 
}



static struct nf_hook_ops *mangle_ops __read_mostly;

static int __net_init iptable_mangle_table_init(struct net *net)

static int iptable_mangle_table_init(struct net *net)

{

	struct ipt_replace *repl;

	int ret;
@@ -113,32 +110,30 @@ static struct pernet_operations iptable_mangle_net_ops = { 


static int __init iptable_mangle_init(void)

{

	int ret;

	int ret = xt_register_template(&packet_mangler,

				       iptable_mangle_table_init);



	mangle_ops = xt_hook_ops_alloc(&packet_mangler, iptable_mangle_hook);

	if (IS_ERR(mangle_ops)) {

		xt_unregister_template(&packet_mangler);

		ret = PTR_ERR(mangle_ops);

		return ret;

	}



	ret = register_pernet_subsys(&iptable_mangle_net_ops);

	if (ret < 0) {

		xt_unregister_template(&packet_mangler);

		kfree(mangle_ops);

		return ret;

	}



	ret = iptable_mangle_table_init(&init_net);

	if (ret) {

		unregister_pernet_subsys(&iptable_mangle_net_ops);

		kfree(mangle_ops);

	}



	return ret;

}



static void __exit iptable_mangle_fini(void)

{

	unregister_pernet_subsys(&iptable_mangle_net_ops);

	xt_unregister_template(&packet_mangler);

	kfree(mangle_ops);

}

net/ipv4/netfilter/iptable_nat.c

+11 −9
Original line number Diff line number Diff line
@@ -17,8 +17,6 @@ struct iptable_nat_pernet { 
	struct nf_hook_ops *nf_nat_ops;

};



static int __net_init iptable_nat_table_init(struct net *net);



static unsigned int iptable_nat_net_id __read_mostly;



static const struct xt_table nf_nat_ipv4_table = {
@@ -29,7 +27,6 @@ static const struct xt_table nf_nat_ipv4_table = { 
			  (1 << NF_INET_LOCAL_IN),

	.me		= THIS_MODULE,

	.af		= NFPROTO_IPV4,

	.table_init	= iptable_nat_table_init,

};



static unsigned int iptable_nat_do_chain(void *priv,
@@ -113,7 +110,7 @@ static void ipt_nat_unregister_lookups(struct net *net) 
	kfree(ops);

}



static int __net_init iptable_nat_table_init(struct net *net)

static int iptable_nat_table_init(struct net *net)

{

	struct ipt_replace *repl;

	int ret;
@@ -155,20 +152,25 @@ static struct pernet_operations iptable_nat_net_ops = { 


static int __init iptable_nat_init(void)

{

	int ret = register_pernet_subsys(&iptable_nat_net_ops);

	int ret = xt_register_template(&nf_nat_ipv4_table,

				       iptable_nat_table_init);



	if (ret)

	if (ret < 0)

		return ret;



	ret = iptable_nat_table_init(&init_net);

	if (ret)

		unregister_pernet_subsys(&iptable_nat_net_ops);

	ret = register_pernet_subsys(&iptable_nat_net_ops);

	if (ret < 0) {

		xt_unregister_template(&nf_nat_ipv4_table);

		return ret;

	}



	return ret;

}



static void __exit iptable_nat_exit(void)

{

	unregister_pernet_subsys(&iptable_nat_net_ops);

	xt_unregister_template(&nf_nat_ipv4_table);

}



module_init(iptable_nat_init);