Skip to content

Commit

Permalink
netfilter: x_tables: never register tables by default
Browse files Browse the repository at this point in the history 
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: Florian Westphal <[email protected]>
Signed-off-by: Pablo Neira Ayuso <[email protected]>
  • Loading branch information
@ummakynes
Florian Westphal authored and ummakynes committed Aug 9, 2021
1 parent 9344988 commit fdacd57
Show file tree
Hide file tree
Showing 13 changed files with 204 additions and 135 deletions.
6 changes: 3 additions & 3 deletions include/linux/netfilter/x_tables.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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];
};
Expand Down Expand Up @@ -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>

Expand Down
23 changes: 11 additions & 12 deletions net/ipv4/netfilter/arptable_filter.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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 */
Expand All @@ -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;
Expand Down Expand Up @@ -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);
}

Expand Down
24 changes: 16 additions & 8 deletions net/ipv4/netfilter/iptable_filter.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,15 +19,13 @@ 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",
.valid_hooks = FILTER_VALID_HOOKS,
.me = THIS_MODULE,
.af = NFPROTO_IPV4,
.priority = NF_IP_PRI_FILTER,
.table_init = iptable_filter_table_init,
};

static unsigned int
Expand All @@ -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;
Expand All @@ -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;
Expand All @@ -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 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);
}

Expand Down
17 changes: 6 additions & 11 deletions net/ipv4/netfilter/iptable_mangle.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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);
}

Expand Down
20 changes: 11 additions & 9 deletions net/ipv4/netfilter/iptable_nat.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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 = {
Expand All @@ -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,
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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 < 0)
return ret;

if (ret)
ret = register_pernet_subsys(&iptable_nat_net_ops);
if (ret < 0) {
xt_unregister_template(&nf_nat_ipv4_table);
return ret;
}

ret = iptable_nat_table_init(&init_net);
if (ret)
unregister_pernet_subsys(&iptable_nat_net_ops);
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);
Expand Down
21 changes: 10 additions & 11 deletions net/ipv4/netfilter/iptable_raw.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,8 +12,6 @@

#define RAW_VALID_HOOKS ((1 << NF_INET_PRE_ROUTING) | (1 << NF_INET_LOCAL_OUT))

static int __net_init iptable_raw_table_init(struct net *net);

static bool raw_before_defrag __read_mostly;
MODULE_PARM_DESC(raw_before_defrag, "Enable raw table before defrag");
module_param(raw_before_defrag, bool, 0000);
Expand All @@ -24,7 +22,6 @@ static const struct xt_table packet_raw = {
.me = THIS_MODULE,
.af = NFPROTO_IPV4,
.priority = NF_IP_PRI_RAW,
.table_init = iptable_raw_table_init,
};

static const struct xt_table packet_raw_before_defrag = {
Expand All @@ -33,7 +30,6 @@ static const struct xt_table packet_raw_before_defrag = {
.me = THIS_MODULE,
.af = NFPROTO_IPV4,
.priority = NF_IP_PRI_RAW_BEFORE_DEFRAG,
.table_init = iptable_raw_table_init,
};

/* The work comes in here from netfilter.c. */
Expand Down Expand Up @@ -89,29 +85,32 @@ static int __init iptable_raw_init(void)
pr_info("Enabling raw table before defrag\n");
}

ret = xt_register_template(table,
iptable_raw_table_init);
if (ret < 0)
return ret;

rawtable_ops = xt_hook_ops_alloc(table, iptable_raw_hook);
if (IS_ERR(rawtable_ops))
if (IS_ERR(rawtable_ops)) {
xt_unregister_template(table);
return PTR_ERR(rawtable_ops);
}

ret = register_pernet_subsys(&iptable_raw_net_ops);
if (ret < 0) {
xt_unregister_template(table);
kfree(rawtable_ops);
return ret;
}

ret = iptable_raw_table_init(&init_net);
if (ret) {
unregister_pernet_subsys(&iptable_raw_net_ops);
kfree(rawtable_ops);
}

return ret;
}

static void __exit iptable_raw_fini(void)
{
unregister_pernet_subsys(&iptable_raw_net_ops);
kfree(rawtable_ops);
xt_unregister_template(&packet_raw);
}

module_init(iptable_raw_init);
Expand Down
Loading

0 comments on commit fdacd57

Please sign in to comment.