conntrack: restrict runtime hashsize modifications
Subsystems (3)
PATCH 1/1 conntrack: restrict runtime hashsize modifications
Jon Masters correctly points out that conntrack hash sizes (nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via /sys/module/nf_conntrack/hashsize .
Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()
At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for init_net (and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.
To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "expect_hashsize" readonly.
This is temporarily until we figure out what to do.
---
net/netfilter/nf_conntrack_core.c | 15 +++++++++++++++ net/netfilter/nf_conntrack_expect.c | 2 +- 2 files changed, 16 insertions(+), 1 deletion(-)
net/netfilter/nf_conntrack_core.c +15 -0
@@ -21,6 +21,7 @@#include <linux/stddef.h> #include <linux/slab.h> #include <linux/random.h> +#include <linux/rtnetlink.h> #include <linux/jhash.h> #include <linux/err.h> #include <linux/percpu.h>
@@ -1198,6 +1199,20 @@ int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp)if (!nf_conntrack_htable_size)return param_set_uint (val, kp); + { +struct net *net; +unsigned int nr; + + nr =0 ; +rtnl_lock (); +for_each_net (net) + nr++; +rtnl_unlock (); +/* init_net always exists */ +if (nr !=1 ) +return -EINVAL ; + } + hashsize =simple_strtoul (val,NULL ,0 );if (!hashsize)return -EINVAL ;
net/netfilter/nf_conntrack_expect.c +1 -1
@@ -569,7 +569,7 @@ static void exp_proc_remove(struct net *net)#endif /* CONFIG_PROC_FS */ } -module_param_named (expect_hashsize, nf_ct_expect_hsize, uint,0600 ); +module_param_named (expect_hashsize, nf_ct_expect_hsize, uint,0400 );int nf_conntrack_expect_init (struct net *net) {
Quoted 3 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.
Thanks.
Jon.
Quoted 15 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.
Quoted 7 lines
To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.This is temporarily until we figure out what to do.
How about alternatively moving nf_conntrack_hsize into the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change the init_net hashsize. Also seems less hackish :)
Quoted 22 lines · Patrick McHardy
Quoted 21 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.
Quoted 6 lines
Quoted 1 line
This is temporarily until we figure out what to do.
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)
Just to avoid duplicate work, I'm currently trying that.
Quoted 23 lines · Patrick McHardy
Quoted 22 lines · Patrick McHardy
Quoted 21 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.
Quoted 8 lines
Quoted 6 lines
Quoted 1 line
This is temporarily until we figure out what to do.
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)Just to avoid duplicate work, I'm currently trying that.
Bah. I already worked a set of patches to do that as I mentioned, but you've probably done it by now - can clean up and post if not :)
Jon.
Quoted 25 lines · Jon Masters
Quoted 24 lines · Patrick McHardy
Quoted 23 lines · Patrick McHardy
Quoted 22 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.This is temporarily until we figure out what to do.
Quoted 8 lines
Quoted 5 lines
Quoted 4 lines
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)Just to avoid duplicate work, I'm currently trying that.
Bah. I already worked a set of patches to do that as I mentioned, but you've probably done it by now - can clean up and post if not :)
Sorry, I missed that in your mail. I'm pretty much done, will finish testing shortly.
Quoted 30 lines · Patrick McHardy
Quoted 29 lines · Jon Masters
Quoted 28 lines · Patrick McHardy
Quoted 27 lines · Patrick McHardy
Quoted 15 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.Quoted 7 lines
To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.This is temporarily until we figure out what to do.
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
Just to avoid duplicate work, I'm currently trying that.
Bah. I already worked a set of patches to do that as I mentioned, but you've probably done it by now - can clean up and post if not :)
Sorry, I missed that in your mail. I'm pretty much done, will finish testing shortly.
Oh, it's cool. I hacked it together on my test box but I'm happy to go with whatever you post later, I will just try to be forthcoming next time with my bits first to save you hassle. Please do keep CCing me on these things and I'll try to test over the weekend as time permits.
Jon.
Quoted 11 lines · Jon Masters
Quoted 5 lines · Patrick McHardy
Quoted 3 lines
Quoted 1 line
Just to avoid duplicate work, I'm currently trying that.
Bah. I already worked a set of patches to do that as I mentioned, but you've probably done it by now - can clean up and post if not :)
Sorry, I missed that in your mail. I'm pretty much done, will finish testing shortly.
Oh, it's cool. I hacked it together on my test box but I'm happy to go with whatever you post later, I will just try to be forthcoming next time with my bits first to save you hassle. Please do keep CCing me on these things and I'll try to test over the weekend as time permits.
Will do, thanks for all your help Jon.
Quoted 22 lines · Patrick McHardy
Quoted 21 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.
Quoted 6 lines
Quoted 1 line
This is temporarily until we figure out what to do.
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)
How about this (so far untested) patch? The htable_size is moved into the per-namespace struct and initialized from the current (global) value of nf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.
Additionally I removed reinitializing the hash random value when changing the hash size since that also requires to rehash in all namespaces.
include/net/netns/conntrack.h +1 -0
@@ -11,6 +11,7 @@ struct nf_conntrack_ecache;struct netns_ct {atomic_t count;unsigned int expect_count; +unsigned int htable_size;struct kmem_cache *nf_conntrack_cachep;struct hlist_nulls_head *hash;struct hlist_head *expect_hash;
include/net/netns/ipv4.h +1 -0
@@ -40,6 +40,7 @@ struct netns_ipv4 {struct xt_table *iptable_security;struct xt_table *nat_table;struct hlist_head *nat_bysource; +unsigned int nat_htable_size;int nat_vmalloced;#endif
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c +1 -1
@@ -210,7 +210,7 @@ static ctl_table ip_ct_sysctl_table[] = { }, { .procname = "ip_conntrack_buckets", - .data = &nf_conntrack_htable_size, + .data = &init_net.ct.htable_size, .maxlen = sizeof(unsigned int), .mode = 0444, .proc_handler = proc_dointvec,
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c +2 -2
@@ -32,7 +32,7 @@ static struct hlist_nulls_node *ct_get_first(struct seq_file *seq)struct hlist_nulls_node *n;for (st->bucket =0 ; - st->bucket < nf_conntrack_htable_size; + st->bucket < net->ct.htable_size; st->bucket++) { n =rcu_dereference (net->ct.hash[st->bucket].first);if (!is_a_nulls (n))
@@ -50,7 +50,7 @@ static struct hlist_nulls_node *ct_get_next(struct seq_file *seq, head =rcu_dereference (head->next);while (is_a_nulls (head)) {if (likely (get_nulls_value (head) == st->bucket)) { -if (++st->bucket >= nf_conntrack_htable_size) +if (++st->bucket >= net->ct.htable_size)return NULL ; } head =rcu_dereference (net->ct.hash[st->bucket].first);
net/ipv4/netfilter/nf_nat_core.c +10 -13
@@ -35,9 +35,6 @@ static DEFINE_SPINLOCK(nf_nat_lock);static struct nf_conntrack_l3proto *l3proto__read_mostly ; -/* Calculated at init based on memory size */ -static unsigned int nf_nat_htable_size__read_mostly ; -#define MAX_IP_NAT_PROTO 256static const struct nf_nat_protocol *nf_nat_protos[MAX_IP_NAT_PROTO ]__read_mostly ;
@@ -72,7 +69,7 @@ EXPORT_SYMBOL_GPL(nf_nat_proto_put);/* We keep an extra hash for each conntrack, for fast searching. */ static inline unsigned int -hash_by_src (const struct nf_conntrack_tuple *tuple) +hash_by_src (const struct net *net,const struct nf_conntrack_tuple *tuple) {unsigned int hash;
@@ -80,7 +77,7 @@ hash_by_src(const struct nf_conntrack_tuple *tuple) hash =jhash_3words ((__force u32 )tuple->src.u3.ip, (__force u32 )tuple->src.u.all, tuple->dst.protonum,0 ); -return ((u64 )hash * nf_nat_htable_size) >>32 ; +return ((u64 )hash * net->ipv4.nat_htable_size) >>32 ; }/* Is this tuple already taken? (not by us) */
@@ -147,7 +144,7 @@ find_appropriate_src(struct net *net,struct nf_conntrack_tuple *result, const struct nf_nat_range *range) { - unsigned int h = hash_by_src(tuple); + unsigned int h = hash_by_src(net, tuple);const struct nf_conn_nat *nat;const struct nf_conn *ct;const struct hlist_node *n;
@@ -330,7 +327,7 @@ nf_nat_setup_info(struct nf_conn *ct,if (have_to_hash) {unsigned int srchash; - srchash =hash_by_src (&ct->tuplehash[IP_CT_DIR_ORIGINAL ].tuple); + srchash =hash_by_src (net, &ct->tuplehash[IP_CT_DIR_ORIGINAL ].tuple);spin_lock_bh (&nf_nat_lock);/* nf_conntrack_alter_reply might re-allocate exntension aera */ nat =nfct_nat (ct);
@@ -679,8 +676,11 @@ nfnetlink_parse_nat_setup(struct nf_conn *ct,static int __net_init nf_nat_net_init (struct net *net) { - net->ipv4.nat_bysource =nf_ct_alloc_hashtable (&nf_nat_htable_size, - &net->ipv4.nat_vmalloced,0 ); +/* Leave them the same for the moment. */ + net->ipv4.nat_htable_size = net->ct.htable_size; + + net->ipv4.nat_bysource =nf_ct_alloc_hashtable (&net->ipv4.nat_htable_size, + &net->ipv4.nat_vmalloced,0 );if (!net->ipv4.nat_bysource)return -ENOMEM ;return 0 ;
@@ -703,7 +703,7 @@ static void __net_exit nf_nat_net_exit(struct net *net)nf_ct_iterate_cleanup (net, &clean_nat,NULL );synchronize_rcu ();nf_ct_free_hashtable (net->ipv4.nat_bysource, net->ipv4.nat_vmalloced, - nf_nat_htable_size); + net->ipv4.nat_htable_size); }static struct pernet_operations nf_nat_net_ops = {
@@ -724,9 +724,6 @@ static int __init nf_nat_init(void)return ret; } -/* Leave them the same for the moment. */ - nf_nat_htable_size = nf_conntrack_htable_size; - ret =register_pernet_subsys (&nf_nat_net_ops);if (ret <0 ) goto cleanup_extend;
net/netfilter/nf_conntrack_core.c +24 -25
154 lines not on this page · raw message
net/netfilter/nf_conntrack_expect.c +1 -1
@@ -577,7 +577,7 @@ int nf_conntrack_expect_init(struct net *net)if (net_eq (net, &init_net)) {if (!nf_ct_expect_hsize) { - nf_ct_expect_hsize = nf_conntrack_htable_size /256 ; + nf_ct_expect_hsize = net->ct.htable_size /256 ;if (!nf_ct_expect_hsize) nf_ct_expect_hsize =1 ; }
net/netfilter/nf_conntrack_helper.c +1 -1
@@ -192,7 +192,7 @@ static void __nf_conntrack_helper_unregister(struct nf_conntrack_helper *me,/* Get rid of expecteds, set helpers to NULL. */ hlist_nulls_for_each_entry (h, nn, &net->ct.unconfirmed, hnnode)unhelp (h, me); -for (i =0 ; i < nf_conntrack_htable_size; i++) { +for (i =0 ; i < net->ct.htable_size; i++) {hlist_nulls_for_each_entry (h, nn, &net->ct.hash[i], hnnode)unhelp (h, me); }
net/netfilter/nf_conntrack_netlink.c +1 -1
@@ -594,7 +594,7 @@ ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb)rcu_read_lock (); last = (struct nf_conn *)cb->args[1 ]; -for (; cb->args[0 ] < nf_conntrack_htable_size; cb->args[0 ]++) { +for (; cb->args[0 ] < init_net.ct.htable_size; cb->args[0 ]++) { restart:hlist_nulls_for_each_entry_rcu (h, n, &init_net.ct.hash[cb->args[0 ]], hnnode) {
net/netfilter/nf_conntrack_standalone.c +4 -3
@@ -51,7 +51,7 @@ static struct hlist_nulls_node *ct_get_first(struct seq_file *seq)struct hlist_nulls_node *n;for (st->bucket =0 ; - st->bucket < nf_conntrack_htable_size; + st->bucket < net->ct.htable_size; st->bucket++) { n =rcu_dereference (net->ct.hash[st->bucket].first);if (!is_a_nulls (n))
@@ -69,7 +69,7 @@ static struct hlist_nulls_node *ct_get_next(struct seq_file *seq, head =rcu_dereference (head->next);while (is_a_nulls (head)) {if (likely (get_nulls_value (head) == st->bucket)) { -if (++st->bucket >= nf_conntrack_htable_size) +if (++st->bucket >= net->ct.htable_size)return NULL ; } head =rcu_dereference (net->ct.hash[st->bucket].first);
@@ -355,7 +355,7 @@ static ctl_table nf_ct_sysctl_table[] = { }, { .procname = "nf_conntrack_buckets", - .data = &nf_conntrack_htable_size, + .data = &init_net.ct.htable_size, .maxlen = sizeof(unsigned int), .mode = 0444, .proc_handler = proc_dointvec,
@@ -421,6 +421,7 @@ static int nf_conntrack_standalone_init_sysctl(struct net *net) goto out_kmemdup; table[1 ].data = &net->ct.count; + table[2 ].data = &net->ct.htable_size; table[3 ].data = &net->ct.sysctl_checksum; table[4 ].data = &net->ct.sysctl_log_invalid;
Quoted 30 lines · Patrick McHardy
Quoted 22 lines · Patrick McHardy
Quoted 21 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.Quoted 6 lines
Quoted 1 line
This is temporarily until we figure out what to do.
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)
Quoted 4 lines
How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.
No matter what we do, it's a hack!
Quoted 3 lines
Additionally I removed reinitializing the hash random value when changing the hash size since that also requires to rehash in all namespaces.
I'm not fond of this, because we're not even closely going to allow changing hashtable size per-netns. As such having actual per-netns hashtable size just slows down everything.
Quoted 11 lines · Alexey Dobriyan
Quoted 6 lines · Patrick McHardy
Quoted 1 line · Patrick McHardy
Alexey Dobriyan wrote:
Additionally I removed reinitializing the hash random value when changing the hash size since that also requires to rehash in all namespaces.
I'm not fond of this, because we're not even closely going to allow changing hashtable size per-netns. As such having actual per-netns hashtable size just slows down everything.
Are you sure, as compared with a shared global size that this is really going to slow things down all that much? We already need to poke in that struct to pull out various things just hash. I haven't profiled to see.
Jon.
Quoted 36 lines · Alexey Dobriyan
Quoted 24 lines · Patrick McHardy
Quoted 23 lines · Patrick McHardy
Quoted 22 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.This is temporarily until we figure out what to do.
Quoted 8 lines
Quoted 4 lines
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.No matter what we do, it's a hack!
Quoted 7 lines
Quoted 3 lines
Additionally I removed reinitializing the hash random value when changing the hash size since that also requires to rehash in all namespaces.
I'm not fond of this, because we're not even closely going to allow changing hashtable size per-netns. As such having actual per-netns hashtable size just slows down everything.
Actually it doesn't seem like much more work to allow changing table size, the main problem is that sysfs module parameters don't seem to fit into the network namespace model at all.
Please be more specific about your suspected slowdowns. What's "everything"? What's different about the hashsize compared to the many members we already moved to per-netns structs?
Quoted 41 lines · Patrick McHardy
Quoted 40 lines · Alexey Dobriyan
Quoted 24 lines · Patrick McHardy
Quoted 23 lines · Patrick McHardy
Quoted 22 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.This is temporarily until we figure out what to do.
Quoted 8 lines
Quoted 4 lines
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.No matter what we do, it's a hack!
Quoted 3 lines
Additionally I removed reinitializing the hash random value when changing the hash size since that also requires to rehash in all namespaces.
Quoted 7 lines
Quoted 3 lines
I'm not fond of this, because we're not even closely going to allow changing hashtable size per-netns. As such having actual per-netns hashtable size just slows down everything.
Actually it doesn't seem like much more work to allow changing table size, the main problem is that sysfs module parameters don't seem to fit into the network namespace model at all.
That was the reason I initially suggested we need a better way to expose netns topology through sysfs, which I still think is a good idea. How about this...it's dangerous as it is right now to leave things global. I suggest leaving the existing sysfs module parameter that only actually touches the init_net ct and get the rest fixed up, then adding support for exposing the topology better in sysfs and tweaking per-ns bits.
But maybe you want to fix it all at the same time.
Jon.
Quoted 17 lines · Jon Masters
Quoted 9 lines · Patrick McHardy
Quoted 9 lines
Quoted 4 lines
How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.No matter what we do, it's a hack!
Quoted 3 lines
Additionally I removed reinitializing the hash random value when changing the hash size since that also requires to rehash in all namespaces.
Quoted 6 lines
Quoted 3 lines
I'm not fond of this, because we're not even closely going to allow changing hashtable size per-netns. As such having actual per-netns hashtable size just slows down everything.
Actually it doesn't seem like much more work to allow changing table size, the main problem is that sysfs module parameters don't seem to fit into the network namespace model at all.
Quoted 8 lines
That was the reason I initially suggested we need a better way to expose netns topology through sysfs, which I still think is a good idea. How about this...it's dangerous as it is right now to leave things global. I suggest leaving the existing sysfs module parameter that only actually touches the
init_netct and get the rest fixed up, then adding support for exposing the topology better in sysfs and tweaking per-ns bits.But maybe you want to fix it all at the same time.
No, right now I only want to fix the remaining bugs. I'll leave everything else to the netns people.
Quoted 14 lines · Patrick McHardy
Quoted 4 lines · Alexey Dobriyan
Quoted 4 lines
How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.Quoted 8 lines
No matter what we do, it's a hack!
Quoted 3 lines
Additionally I removed reinitializing the hash random value when changing the hash size since that also requires to rehash in all namespaces.
I'm not fond of this, because we're not even closely going to allow changing hashtable size per-netns. As such having actual per-netns hashtable size just slows down everything.
Quoted 8 lines
Actually it doesn't seem like much more work to allow changing table size, the main problem is that sysfs module parameters don't seem to fit into the network namespace model at all.
Please be more specific about your suspected slowdowns. What's "everything"? What's different about the hashsize compared to the many members we already moved to per-netns structs?
OK testing looks fine, although I'm quite surprised that its actually possible to change module parameters from within non-init namespaces. How is this supposed to work at all? I don't see how sysfs could possibly provide a network namespace context ...
Quoted 4 lines · Patrick McHardy
OK testing looks fine, although I'm quite surprised that its actually possible to change module parameters from within non-init namespaces. How is this supposed to work at all? I don't see how sysfs could possibly provide a network namespace context ...
You can do in write hook
if (!net_eq(current->nsproxy->net_ns, &init_net))
return -EINVAL;Quoted 11 lines · Alexey Dobriyan
Quoted 4 lines · Patrick McHardy
OK testing looks fine, although I'm quite surprised that its actually possible to change module parameters from within non-init namespaces. How is this supposed to work at all? I don't see how sysfs could possibly provide a network namespace context ...
You can do in write hook
if (!net_eq(current->nsproxy->net_ns, &init_net)) return -EINVAL;
Right, I see. So we could actually make resizing work for all namespaces quite easily. Is there any reason not to do this?
Quoted 7 lines · Patrick McHardy
Quoted 6 lines · Alexey Dobriyan
Quoted 4 lines · Patrick McHardy
OK testing looks fine, although I'm quite surprised that its actually possible to change module parameters from within non-init namespaces. How is this supposed to work at all? I don't see how sysfs could possibly provide a network namespace context ...
Quoted 8 lines
Quoted 4 lines
You can do in write hook
if (!net_eq(current->nsproxy->net_ns, &init_net)) return -EINVAL;Right, I see. So we could actually make resizing work for all namespaces quite easily. Is there any reason not to do this?
Something like this (untested) patch on top of the previous one.
net/netfilter/nf_conntrack_core.c +11 -9
@@ -31,6 +31,7 @@#include <linux/socket.h> #include <linux/mm.h> #include <linux/rculist_nulls.h> +#include <linux/nsproxy.h> #include <net/netfilter/nf_conntrack.h> #include <net/netfilter/nf_conntrack_l3proto.h>
@@ -1194,6 +1195,7 @@ int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp)unsigned int hashsize, old_size;struct hlist_nulls_head *hash, *old_hash;struct nf_conntrack_tuple_hash *h; +struct net *net = current->nsproxy->net_ns;/* On boot, we can set this without any fancy locking. */ if (!nf_conntrack_htable_size)
@@ -1213,9 +1215,9 @@ int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp)* though since that required taking the lock. */ spin_lock_bh (&nf_conntrack_lock); -for (i =0 ; i < init_net.ct.htable_size; i++) { -while (!hlist_nulls_empty (&init_net.ct.hash[i])) { - h =hlist_nulls_entry (init_net.ct.hash[i].first, +for (i =0 ; i < net->ct.htable_size; i++) { +while (!hlist_nulls_empty (&net->ct.hash[i])) { + h =hlist_nulls_entry (net->ct.hash[i].first, struct nf_conntrack_tuple_hash, hnnode);hlist_nulls_del_rcu (&h->hnnode); bucket = __hash_conntrack(&h->tuple, hashsize,
@@ -1223,13 +1225,13 @@ int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp)hlist_nulls_add_head_rcu (&h->hnnode, &hash[bucket]); } } - old_size = init_net.ct.htable_size; - old_vmalloced = init_net.ct.hash_vmalloc; - old_hash = init_net.ct.hash; + old_size = net->ct.htable_size; + old_vmalloced = net->ct.hash_vmalloc; + old_hash = net->ct.hash; - init_net.ct.htable_size = nf_conntrack_htable_size = hashsize; - init_net.ct.hash_vmalloc = vmalloced; - init_net.ct.hash = hash; + net->ct.htable_size = nf_conntrack_htable_size = hashsize; + net->ct.hash_vmalloc = vmalloced; + net->ct.hash = hash;spin_unlock_bh (&nf_conntrack_lock);nf_ct_free_hashtable (old_hash, old_vmalloced, old_size);
Quoted 8 lines · Patrick McHardy
Quoted 7 lines · Alexey Dobriyan
Quoted 4 lines · Patrick McHardy
OK testing looks fine, although I'm quite surprised that its actually possible to change module parameters from within non-init namespaces. How is this supposed to work at all? I don't see how sysfs could possibly provide a network namespace context ...
Quoted 7 lines
Quoted 4 lines
You can do in write hook
if (!net_eq(current->nsproxy->net_ns, &init_net)) return -EINVAL;Right, I see. So we could actually make resizing work for all namespaces quite easily. Is there any reason not to do this?
Yes, but I think (2.6.34) there also needs to be a better way to expose netns topology and visualize all the hashtables on a system - if you're the admin you really want to be able to see all of them, not just for a particular namespace you might be in, in addition to the perns views.
We already discussed 2.6.34, I'm only mentioning this "for the record".
Jon.
Quoted 11 lines · Alexey Dobriyan
Quoted 4 lines · Patrick McHardy
OK testing looks fine, although I'm quite surprised that its actually possible to change module parameters from within non-init namespaces. How is this supposed to work at all? I don't see how sysfs could possibly provide a network namespace context ...
You can do in write hook
if (!net_eq(current->nsproxy->net_ns,
&init_net)) return-EINVAL;
-EPERM of course.
--
To unsubscribe from this list: send the line "unsubscribe netfilter-devel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 3 lines · Patrick McHardy
Actually it doesn't seem like much more work to allow changing table size, the main problem is that sysfs module parameters don't seem to fit into the network namespace model at all.
Well, they "fit" as they're global because modules are global. So we can make every netns hashtable size equals to module param, or make it bounded by module param
or make initial hashtable size and not bounded
or million other things.
Quoted 1 line
Please be more specific about your suspected slowdowns.
I meant net->ct.htable_size in hash functions _if_ you're not allowing changing it from inside netns.
Quoted 3 lines
What's "everything"? What's different about the hashsize compared to the many members we already moved to per-netns structs?
But whatever. I think per-netns hashtable size shouldn't be done that late.
Quoted 10 lines · Alexey Dobriyan
Quoted 3 lines · Patrick McHardy
Actually it doesn't seem like much more work to allow changing table size, the main problem is that sysfs module parameters don't seem to fit into the network namespace model at all.
Well, they "fit" as they're global because modules are global. So we can make every netns hashtable size equals to module param, or make it bounded by module param
or make initial hashtable size and not bounded
or million other things.
Feel free to suggest your preferred method.
Quoted 11 lines
Quoted 1 line
Please be more specific about your suspected slowdowns.
I meant
net->ct.htable_sizein hash functions _if_ you're not allowing changing it from inside netns.Quoted 3 lines
What's "everything"? What's different about the hashsize compared to the many members we already moved to per-netns structs?
But whatever. I think per-netns hashtable size shouldn't be done that late.
This is a regression. You can not simply disable resizing and call it a bugfix.
Quoted 17 lines · Patrick McHardy
Quoted 9 lines · Alexey Dobriyan
Quoted 3 lines · Patrick McHardy
Actually it doesn't seem like much more work to allow changing table size, the main problem is that sysfs module parameters don't seem to fit into the network namespace model at all.
Well, they "fit" as they're global because modules are global. So we can make every netns hashtable size equals to module param, or make it bounded by module param
or make initial hashtable size and not bounded
or million other things.Feel free to suggest your preferred method.
Quoted 4 lines
Quoted 1 line
Please be more specific about your suspected slowdowns.
I meant
net->ct.htable_sizein hash functions _if_ you're not allowing changing it from inside netns.
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
What's "everything"? What's different about the hashsize compared to the many members we already moved to per-netns structs?
But whatever. I think per-netns hashtable size shouldn't be done that late.
This is a regression. You can not simply disable resizing and call it a bugfix.
This is what I'm going to commit unless someone spots any problems. Resizing of non-init-namespaces is not supported, so its not necessary to decide the questions you raised above at this time.
commit 6521ddb0811ffb4fbfdf48d2c85024bd8f51aadf
Author: Patrick McHardy <[email protected]> Date: Mon Feb 8 15:32:18 2010 +0100
netfilter: nf_conntrack: fix hash resizing with namespaces
As noticed by Jon Masters <[email protected]>, the conntrack hash size is global and not per namespace, but modifiable at runtime through /sys/module/nf_conntrack/hashsize. Changing the hash size will only resize the hash in the current namespace however, so other namespaces will use an invalid hash size. This can cause crashes when enlarging the hashsize, or false negative lookups when shrinking it.
Move the hash size into the per-namespace data and only use the global hash size to initialize the per-namespace value when instanciating a new namespace. Additionally restrict hash resizing to init_net for now as other namespaces are not handled currently.
include/net/netns/conntrack.h +1 -0
@@ -11,6 +11,7 @@ struct nf_conntrack_ecache;struct netns_ct {atomic_t count;unsigned int expect_count; +unsigned int htable_size;struct kmem_cache *nf_conntrack_cachep;struct hlist_nulls_head *hash;struct hlist_head *expect_hash;
include/net/netns/ipv4.h +1 -0
@@ -40,6 +40,7 @@ struct netns_ipv4 {struct xt_table *iptable_security;struct xt_table *nat_table;struct hlist_head *nat_bysource; +unsigned int nat_htable_size;int nat_vmalloced;#endif
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c +1 -1
@@ -210,7 +210,7 @@ static ctl_table ip_ct_sysctl_table[] = { }, { .procname = "ip_conntrack_buckets", - .data = &nf_conntrack_htable_size, + .data = &init_net.ct.htable_size, .maxlen = sizeof(unsigned int), .mode = 0444, .proc_handler = proc_dointvec,
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c +2 -2
@@ -32,7 +32,7 @@ static struct hlist_nulls_node *ct_get_first(struct seq_file *seq)struct hlist_nulls_node *n;for (st->bucket =0 ; - st->bucket < nf_conntrack_htable_size; + st->bucket < net->ct.htable_size; st->bucket++) { n =rcu_dereference (net->ct.hash[st->bucket].first);if (!is_a_nulls (n))
@@ -50,7 +50,7 @@ static struct hlist_nulls_node *ct_get_next(struct seq_file *seq, head =rcu_dereference (head->next);while (is_a_nulls (head)) {if (likely (get_nulls_value (head) == st->bucket)) { -if (++st->bucket >= nf_conntrack_htable_size) +if (++st->bucket >= net->ct.htable_size)return NULL ; } head =rcu_dereference (net->ct.hash[st->bucket].first);
net/ipv4/netfilter/nf_nat_core.c +9 -13
@@ -35,9 +35,6 @@ static DEFINE_SPINLOCK(nf_nat_lock);static struct nf_conntrack_l3proto *l3proto__read_mostly ; -/* Calculated at init based on memory size */ -static unsigned int nf_nat_htable_size__read_mostly ; -#define MAX_IP_NAT_PROTO 256static const struct nf_nat_protocol *nf_nat_protos[MAX_IP_NAT_PROTO ]__read_mostly ;
@@ -72,7 +69,7 @@ EXPORT_SYMBOL_GPL(nf_nat_proto_put);/* We keep an extra hash for each conntrack, for fast searching. */ static inline unsigned int -hash_by_src (const struct nf_conntrack_tuple *tuple) +hash_by_src (const struct net *net,const struct nf_conntrack_tuple *tuple) {unsigned int hash;
@@ -80,7 +77,7 @@ hash_by_src(const struct nf_conntrack_tuple *tuple) hash =jhash_3words ((__force u32 )tuple->src.u3.ip, (__force u32 )tuple->src.u.all, tuple->dst.protonum,0 ); -return ((u64 )hash * nf_nat_htable_size) >>32 ; +return ((u64 )hash * net->ipv4.nat_htable_size) >>32 ; }/* Is this tuple already taken? (not by us) */
@@ -147,7 +144,7 @@ find_appropriate_src(struct net *net,struct nf_conntrack_tuple *result, const struct nf_nat_range *range) { - unsigned int h = hash_by_src(tuple); + unsigned int h = hash_by_src(net, tuple);const struct nf_conn_nat *nat;const struct nf_conn *ct;const struct hlist_node *n;
@@ -330,7 +327,7 @@ nf_nat_setup_info(struct nf_conn *ct,if (have_to_hash) {unsigned int srchash; - srchash =hash_by_src (&ct->tuplehash[IP_CT_DIR_ORIGINAL ].tuple); + srchash =hash_by_src (net, &ct->tuplehash[IP_CT_DIR_ORIGINAL ].tuple);spin_lock_bh (&nf_nat_lock);/* nf_conntrack_alter_reply might re-allocate exntension aera */ nat =nfct_nat (ct);
@@ -679,8 +676,10 @@ nfnetlink_parse_nat_setup(struct nf_conn *ct,static int __net_init nf_nat_net_init (struct net *net) { - net->ipv4.nat_bysource =nf_ct_alloc_hashtable (&nf_nat_htable_size, - &net->ipv4.nat_vmalloced,0 ); +/* Leave them the same for the moment. */ + net->ipv4.nat_htable_size = net->ct.htable_size; + net->ipv4.nat_bysource =nf_ct_alloc_hashtable (&net->ipv4.nat_htable_size, + &net->ipv4.nat_vmalloced,0 );if (!net->ipv4.nat_bysource)return -ENOMEM ;return 0 ;
@@ -703,7 +702,7 @@ static void __net_exit nf_nat_net_exit(struct net *net)nf_ct_iterate_cleanup (net, &clean_nat,NULL );synchronize_rcu ();nf_ct_free_hashtable (net->ipv4.nat_bysource, net->ipv4.nat_vmalloced, - nf_nat_htable_size); + net->ipv4.nat_htable_size); }static struct pernet_operations nf_nat_net_ops = {
@@ -724,9 +723,6 @@ static int __init nf_nat_init(void)return ret; } -/* Leave them the same for the moment. */ - nf_nat_htable_size = nf_conntrack_htable_size; - ret =register_pernet_subsys (&nf_nat_net_ops);if (ret <0 ) goto cleanup_extend;
net/netfilter/nf_conntrack_core.c +28 -25
167 lines not on this page · raw message
net/netfilter/nf_conntrack_expect.c +1 -1
@@ -577,7 +577,7 @@ int nf_conntrack_expect_init(struct net *net)if (net_eq (net, &init_net)) {if (!nf_ct_expect_hsize) { - nf_ct_expect_hsize = nf_conntrack_htable_size /256 ; + nf_ct_expect_hsize = net->ct.htable_size /256 ;if (!nf_ct_expect_hsize) nf_ct_expect_hsize =1 ; }
net/netfilter/nf_conntrack_helper.c +1 -1
@@ -192,7 +192,7 @@ static void __nf_conntrack_helper_unregister(struct nf_conntrack_helper *me,/* Get rid of expecteds, set helpers to NULL. */ hlist_nulls_for_each_entry (h, nn, &net->ct.unconfirmed, hnnode)unhelp (h, me); -for (i =0 ; i < nf_conntrack_htable_size; i++) { +for (i =0 ; i < net->ct.htable_size; i++) {hlist_nulls_for_each_entry (h, nn, &net->ct.hash[i], hnnode)unhelp (h, me); }
net/netfilter/nf_conntrack_netlink.c +1 -1
@@ -594,7 +594,7 @@ ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb)rcu_read_lock (); last = (struct nf_conn *)cb->args[1 ]; -for (; cb->args[0 ] < nf_conntrack_htable_size; cb->args[0 ]++) { +for (; cb->args[0 ] < init_net.ct.htable_size; cb->args[0 ]++) { restart:hlist_nulls_for_each_entry_rcu (h, n, &init_net.ct.hash[cb->args[0 ]], hnnode) {
net/netfilter/nf_conntrack_standalone.c +4 -3
@@ -51,7 +51,7 @@ static struct hlist_nulls_node *ct_get_first(struct seq_file *seq)struct hlist_nulls_node *n;for (st->bucket =0 ; - st->bucket < nf_conntrack_htable_size; + st->bucket < net->ct.htable_size; st->bucket++) { n =rcu_dereference (net->ct.hash[st->bucket].first);if (!is_a_nulls (n))
@@ -69,7 +69,7 @@ static struct hlist_nulls_node *ct_get_next(struct seq_file *seq, head =rcu_dereference (head->next);while (is_a_nulls (head)) {if (likely (get_nulls_value (head) == st->bucket)) { -if (++st->bucket >= nf_conntrack_htable_size) +if (++st->bucket >= net->ct.htable_size)return NULL ; } head =rcu_dereference (net->ct.hash[st->bucket].first);
@@ -355,7 +355,7 @@ static ctl_table nf_ct_sysctl_table[] = { }, { .procname = "nf_conntrack_buckets", - .data = &nf_conntrack_htable_size, + .data = &init_net.ct.htable_size, .maxlen = sizeof(unsigned int), .mode = 0444, .proc_handler = proc_dointvec,
@@ -421,6 +421,7 @@ static int nf_conntrack_standalone_init_sysctl(struct net *net) goto out_kmemdup; table[1 ].data = &net->ct.count; + table[2 ].data = &net->ct.htable_size; table[3 ].data = &net->ct.sysctl_checksum; table[4 ].data = &net->ct.sysctl_log_invalid;
Quoted 30 lines · Patrick McHardy
Quoted 22 lines · Patrick McHardy
Quoted 21 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.Quoted 6 lines
Quoted 1 line
This is temporarily until we figure out what to do.
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)
Quoted 4 lines
How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.
I moved the random seed into the per-ns context aswell. I think that's better than having a global one, and you don't need to rehash all.
Jon.
Quoted 5 lines · Jon Masters
Quoted 4 lines · Patrick McHardy
Quoted 4 lines
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)
Quoted 7 lines
Quoted 4 lines
How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.I moved the random seed into the per-ns context aswell. I think that's better than having a global one, and you don't need to rehash all.
That's another possibility. But we don't loose anything by not reseeding during resize. It also shouldn't be possible to determine the seed from userspace in a namespace, so there's no real need to use seperate values.
Quoted 11 lines · Patrick McHardy
Quoted 10 lines · Jon Masters
Quoted 8 lines · Patrick McHardy
Quoted 4 lines
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.
Quoted 7 lines
Quoted 2 lines
I moved the random seed into the per-ns context aswell. I think that's better than having a global one, and you don't need to rehash all.
That's another possibility. But we don't loose anything by not reseeding during resize. It also shouldn't be possible to determine the seed from userspace in a namespace, so there's no real need to use seperate values.
Right, the risk there is hypothetical at best. But there's little lost in putting it in per-ns and then you can rehash and truly make them independent, which I think is really what netns is all about.
Jon.
Quoted 13 lines · Jon Masters
Quoted 12 lines · Patrick McHardy
Quoted 11 lines · Jon Masters
Quoted 8 lines · Patrick McHardy
Quoted 4 lines
How about alternatively moving
nf_conntrack_hsizeinto the per-namespace struct? It doesn't look more complicated or intrusive and would allow to still change theinit_nethashsize. Also seems less hackish :)How about this (so far untested) patch? The
htable_sizeis moved into the per-namespace struct and initialized from the current (global) value ofnf_conntrack_htable_size. Changes through sysfs are still permitted, but only affect the init namespace and newly created ones.I moved the random seed into the per-ns context aswell. I think that's better than having a global one, and you don't need to rehash all.
Quoted 8 lines
Quoted 4 lines
That's another possibility. But we don't loose anything by not reseeding during resize. It also shouldn't be possible to determine the seed from userspace in a namespace, so there's no real need to use seperate values.
Right, the risk there is hypothetical at best. But there's little lost in putting it in per-ns and then you can rehash and truly make them independent, which I think is really what netns is all about.
I don't disagree, but currently I'm trying to go for a minimal version thats suitable for 2.6.33.
Patrick McHardy
AppliedQuoted 15 lines · Alexey Dobriyan
Jon Masters correctly points out that conntrack hash sizes (
nf_conntrack_htable_size) are global (not per-netns) and modifiable at runtime via/sys/module/nf_conntrack/hashsize.Steps to reproduce:
clone(CLONE_NEWNET) [grow /sys/module/nf_conntrack/hashsize] exit()At netns exit we are going to scan random memory for conntracks to be killed.
Apparently there is a code which deals with hashtable resize for
init_net(and it was there befode netns conntrack code), so prohibit hashsize modification if there is more than one netns exists.
Quoted 5 lines
To change hashtable sizes, you need to reload module.
Expectation hashtable size was simply glued to a variable with no code to rehash expectations, so it was a bug to allow writing to it. Make "
expect_hashsize" readonly.
I've applied the expectation part, thanks Alexey.
Quoted 12 lines
net/netfilter/nf_conntrack_expect.c +1
-1@@ -569,7 +569,7 @@ static void exp_proc_remove(struct net *net)#endif /* CONFIG_PROC_FS */ } -module_param_named (expect_hashsize, nf_ct_expect_hsize, uint,0600 ); +module_param_named (expect_hashsize, nf_ct_expect_hsize, uint,0400 );int nf_conntrack_expect_init (struct net *net) {