Netfilter fixes for net
Subsystems (3)
Pablo Neira Ayuso
maintainercover Netfilter fixes for net
Hi David,
The following patchset contains Netfilter fixes for you net tree, they are:
1) Restore __GFP_NORETRY in xt_table allocations to mitigate effects of large memory allocation requests, from Michal Hocko.
2) Release IPv6 fragment queue in case of error in fragmentation header, this is a follow up to amend patch 83f1999caeb1, from Subash Abhinov Kasiviswanathan.
3) Flowtable infrastructure depends on NETFILTER_INGRESS as it registers a hook for each flowtable, reported by John Crispin.
4) Missing initialization of info->priv in xt_cgroup version 1, from Cong Wang.
5) Give a chance to garbage collector to run after scheduling flowtable cleanup.
6) Releasing flowtable content on nft_flow_offload module removal is not required at all, there is not dependencies between this module and flowtables, remove it.
7) Fix missing xt_rateest_mutex grabbing for hash insertions, also from Cong Wang.
8) Move nf_flow_table_cleanup() routine to flowtable core, this patch is a dependency for the next patch in this list.
9) Flowtable resources are not properly released on removal from the control plane. Fix this resource leak by scheduling removal of all entries and explicit call to the garbage collector.
10) nf_ct_nat_offset() declaration is dead code, this function prototype is not used anywhere, remove it. From Taehee Yoo.
11) Fix another flowtable resource leak on entry insertion failures, this patch also fixes a possible use-after-free. Patch from Felix Fietkau.
You can pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git
Thanks!
P.S: Again more fixes cooking on [email protected], so
another round is likely coming up soon.
----------------------------------------------------------------
The following changes since commit 743ffffefac1c670c6618742c923f6275d819604:
net: pxa168_eth: add netconsole support (2018-02-01 14:58:37 -0500)
are available in the git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git HEAD
for you to fetch changes up to 0ff90b6c20340e57616a51ae1a1bf18156d6638a:
netfilter: nf_flow_offload: fix use-after-free and a resource leak (2018-02-07 11:55:52 +0100)
----------------------------------------------------------------
Cong Wang (2):
netfilter: xt_cgroup: initialize info->priv in cgroup_mt_check_v1()
netfilter: xt_RATEEST: acquire xt_rateest_mutex for hash insert
Felix Fietkau (1):
netfilter: nf_flow_offload: fix use-after-free and a resource leak
Michal Hocko (1):
netfilter: x_tables: make allocation less aggressive
Pablo Neira Ayuso (5):
netfilter: flowtable infrastructure depends on NETFILTER_INGRESS
netfilter: nft_flow_offload: wait for garbage collector to run after cleanup
netfilter: nft_flow_offload: no need to flush entries on module removal
netfilter: nft_flow_offload: move flowtable cleanup routines to nf_flow_table
netfilter: nf_tables: fix flowtable free
Subash Abhinov Kasiviswanathan (1):
netfilter: ipv6: nf_defrag: Kill frag queue on RFC2460 failure
Taehee Yoo (1):
netfilter: remove useless prototype
include/net/netfilter/nf_conntrack.h | 5 --- include/net/netfilter/nf_flow_table.h | 6 ++- net/ipv4/netfilter/Kconfig | 3 +- net/ipv4/netfilter/nf_flow_table_ipv4.c | 1 + net/ipv6/netfilter/Kconfig | 3 +- net/ipv6/netfilter/nf_conntrack_reasm.c | 1 + net/ipv6/netfilter/nf_flow_table_ipv6.c | 1 + net/netfilter/Kconfig | 8 ++-- net/netfilter/nf_flow_table.c | 76 ++++++++++++++++++++++----------- net/netfilter/nf_flow_table_inet.c | 1 + net/netfilter/nf_tables_api.c | 17 +++----- net/netfilter/nft_flow_offload.c | 24 +---------- net/netfilter/x_tables.c | 7 ++- net/netfilter/xt_RATEEST.c | 22 +++++++--- net/netfilter/xt_cgroup.c | 1 + 15 files changed, 97 insertions(+), 79 deletions(-)
Pablo Neira Ayuso
maintainerPATCH 1/11 netfilter: x_tables: make allocation less aggressive
From: Michal Hocko <[email protected]>
syzbot has noticed that xt_alloc_table_info can allocate a lot of memory. This is an admin only interface but an admin in a namespace is sufficient as well. eacd86ca3b03 ("net/netfilter/x_tables.c: use kvmalloc() in xt_alloc_table_info()") has changed the opencoded kmalloc->vmalloc fallback into kvmalloc. It has dropped __GFP_NORETRY on the way because vmalloc has simply never fully supported __GFP_NORETRY semantic. This is still the case because e.g. page tables backing the vmalloc area are hardcoded GFP_KERNEL.
Revert back to __GFP_NORETRY as a poors man defence against excessively large allocation request here. We will not rule out the OOM killer completely but __GFP_NORETRY should at least stop the large request in most cases.
--- net/netfilter/x_tables.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
net/netfilter/x_tables.c +6 -1
@@ -1008,7 +1008,12 @@ struct xt_table_info *xt_alloc_table_info(unsigned int size)if ((size >>PAGE_SHIFT ) +2 > totalram_pages)return NULL ; - info =kvmalloc (sz,GFP_KERNEL ); +/* __GFP_NORETRY is not fully supported by kvmalloc but it should +* work reasonably well if sz is too large and bail out rather +* than shoot all processes down before realizing there is nothing +* more to reclaim. +*/ + info =kvmalloc (sz,GFP_KERNEL | __GFP_NORETRY);if (!info)return NULL ;
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 2/11 netfilter: ipv6: nf_defrag: Kill frag queue on RFC2460 failure
In reply to Pablo Neira AyusoFrom: Subash Abhinov Kasiviswanathan <[email protected]>
Failures were seen in ICMPv6 fragmentation timeout tests if they were run after the RFC2460 failure tests. Kernel was not sending out the ICMPv6 fragment reassembly time exceeded packet after the fragmentation reassembly timeout of 1 minute had elapsed.
This happened because the frag queue was not released if an error in IPv6 fragmentation header was detected by RFC2460.
--- net/ipv6/netfilter/nf_conntrack_reasm.c | 1 + 1 file changed, 1 insertion(+)
net/ipv6/netfilter/nf_conntrack_reasm.c +1 -0
@@ -264,6 +264,7 @@ static int nf_ct_frag6_queue(struct frag_queue *fq, struct sk_buff *skb,* this case. -DaveM */ pr_debug ("end of fragment not rounded to 8 bytes.\n" ); +inet_frag_kill (&fq->q, &nf_frags);return -EPROTO ; }if (end > fq->q.len) {
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 3/11 netfilter: flowtable infrastructure depends on NETFILTER_INGRESS
In reply to Pablo Neira Ayusoconfig NF_FLOW_TABLE depends on NETFILTER_INGRESS. If users forget to enable this toggle, flowtable registration fails with EOPNOTSUPP.
Moreover, turn 'select NF_FLOW_TABLE' in every flowtable family flavour into dependency instead, otherwise this new dependency on NETFILTER_INGRESS causes a warning. This also allows us to remove the explicit dependency between family flowtables <-> NF_TABLES and NF_CONNTRACK, given they depend on the NF_FLOW_TABLE core that already expresses the general dependencies for this new infrastructure.
Moreover, NF_FLOW_TABLE_INET depends on NF_FLOW_TABLE_IPV4 and NF_FLOWTABLE_IPV6, which already depends on NF_FLOW_TABLE. So we can get rid of direct dependency with NF_FLOW_TABLE.
In general, let's avoid 'select', it just makes things more complicated.
--- net/ipv4/netfilter/Kconfig | 3 +-- net/ipv6/netfilter/Kconfig | 3 +-- net/netfilter/Kconfig | 8 +++++--- 3 files changed, 7 insertions(+), 7 deletions(-)
net/ipv4/netfilter/Kconfig +1 -2
@@ -80,8 +80,7 @@ endif # NF_TABLES config NF_FLOW_TABLE_IPV4 tristate "Netfilter flow table IPv4 module" - depends on NF_CONNTRACK && NF_TABLES - select NF_FLOW_TABLE + depends on NF_FLOW_TABLE help This option adds the flow table IPv4 support.
net/ipv6/netfilter/Kconfig +1 -2
@@ -73,8 +73,7 @@ endif # NF_TABLES config NF_FLOW_TABLE_IPV6 tristate "Netfilter flow table IPv6 module" - depends on NF_CONNTRACK && NF_TABLES - select NF_FLOW_TABLE + depends on NF_FLOW_TABLE help This option adds the flow table IPv6 support.
net/netfilter/Kconfig +5 -3
@@ -666,8 +666,8 @@ endif # NF_TABLES config NF_FLOW_TABLE_INET tristate "Netfilter flow table mixed IPv4/IPv6 module" - depends on NF_FLOW_TABLE_IPV4 && NF_FLOW_TABLE_IPV6 - select NF_FLOW_TABLE + depends on NF_FLOW_TABLE_IPV4 + depends on NF_FLOW_TABLE_IPV6 help This option adds the flow table mixed IPv4/IPv6 support.
@@ -675,7 +675,9 @@ config NF_FLOW_TABLE_INET config NF_FLOW_TABLE tristate "Netfilter flow table module" - depends on NF_CONNTRACK && NF_TABLES + depends on NETFILTER_INGRESS + depends on NF_CONNTRACK + depends on NF_TABLES help This option adds the flow table core infrastructure.
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 4/11 netfilter: xt_cgroup: initialize info->priv in cgroup_mt_check_v1()
In reply to Pablo Neira AyusoFrom: Cong Wang <[email protected]>
xt_cgroup_info_v1->priv is an internal pointer only used for kernel, we should not trust what user-space provides.
--- net/netfilter/xt_cgroup.c | 1 + 1 file changed, 1 insertion(+)
net/netfilter/xt_cgroup.c +1 -0
@@ -52,6 +52,7 @@ static int cgroup_mt_check_v1(const struct xt_mtchk_param *par)return -EINVAL ; } + info->priv =NULL ;if (info->has_path) { cgrp =cgroup_get_from_path (info->path);if (IS_ERR (cgrp)) {
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 5/11 netfilter: nft_flow_offload: wait for garbage collector to run after cleanup
In reply to Pablo Neira AyusoIf netdevice goes down, then flowtable entries are scheduled to be removed. Wait for garbage collector to have a chance to run so it can delete them from the hashtable.
The flush call might sleep, so hold the nfnl mutex from nft_flow_table_iterate() instead of rcu read side lock. The use of the nfnl mutex is also implicitly fixing races between updates via nfnetlink and netdevice event.
--- net/netfilter/nf_tables_api.c | 8 ++++---- net/netfilter/nft_flow_offload.c | 1 + 2 files changed, 5 insertions(+), 4 deletions(-)
net/netfilter/nf_tables_api.c +4 -4
@@ -5006,13 +5006,13 @@ void nft_flow_table_iterate(struct net *net,struct nft_flowtable *flowtable;const struct nft_table *table; -rcu_read_lock (); -list_for_each_entry_rcu (table, &net->nft.tables, list) { -list_for_each_entry_rcu (flowtable, &table->flowtables, list) { +nfnl_lock (NFNL_SUBSYS_NFTABLES ); +list_for_each_entry (table, &net->nft.tables, list) { +list_for_each_entry (flowtable, &table->flowtables, list) {iter (&flowtable->data, data); } } -rcu_read_unlock (); +nfnl_unlock (NFNL_SUBSYS_NFTABLES ); }EXPORT_SYMBOL_GPL (nft_flow_table_iterate);
net/netfilter/nft_flow_offload.c +1 -0
@@ -208,6 +208,7 @@ static void nft_flow_offload_iterate_cleanup(struct nf_flowtable *flowtable, void *data) {nf_flow_table_iterate (flowtable, flow_offload_iterate_cleanup, data); +flush_delayed_work (&flowtable->gc_work); } static int flow_offload_netdev_event(struct notifier_block *this,
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 6/11 netfilter: nft_flow_offload: no need to flush entries on module removal
In reply to Pablo Neira Ayusonft_flow_offload module removal does not require to flush existing flowtables, it is valid to remove this module while keeping flowtables around.
--- net/netfilter/nft_flow_offload.c | 6 ------ 1 file changed, 6 deletions(-)
net/netfilter/nft_flow_offload.c +0 -6
@@ -247,14 +247,8 @@ static int __init nft_flow_offload_module_init(void) static void __exit nft_flow_offload_module_exit(void) { -struct net *net; -nft_unregister_expr (&nft_flow_offload_type);unregister_netdevice_notifier (&flow_offload_netdev_notifier); -rtnl_lock (); -for_each_net (net) -nft_flow_table_iterate (net, nft_flow_offload_iterate_cleanup,NULL ); -rtnl_unlock (); }module_init (nft_flow_offload_module_init);
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 7/11 netfilter: xt_RATEEST: acquire xt_rateest_mutex for hash insert
In reply to Pablo Neira AyusoFrom: Cong Wang <[email protected]>
rateest_hash is supposed to be protected by xt_rateest_mutex, and, as suggested by Eric, lookup and insert should be atomic, so we should acquire the xt_rateest_mutex once for both.
So introduce a non-locking helper for internal use and keep the locking one for external.
--- net/netfilter/xt_RATEEST.c | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-)
net/netfilter/xt_RATEEST.c +17 -5
@@ -39,23 +39,31 @@ static void xt_rateest_hash_insert(struct xt_rateest *est)hlist_add_head (&est->list, &rateest_hash[h]); } -struct xt_rateest *xt_rateest_lookup (const char *name) +static struct xt_rateest *__xt_rateest_lookup (const char *name) {struct xt_rateest *est;unsigned int h; h =xt_rateest_hash (name); -mutex_lock (&xt_rateest_mutex);hlist_for_each_entry (est, &rateest_hash[h], list) {if (strcmp (est->name, name) ==0 ) { est->refcnt++; -mutex_unlock (&xt_rateest_mutex);return est; } } -mutex_unlock (&xt_rateest_mutex); +return NULL ; } + +struct xt_rateest *xt_rateest_lookup (const char *name) +{ +struct xt_rateest *est; + +mutex_lock (&xt_rateest_mutex); + est =__xt_rateest_lookup (name); +mutex_unlock (&xt_rateest_mutex); +return est; +}EXPORT_SYMBOL_GPL (xt_rateest_lookup);void xt_rateest_put (struct xt_rateest *est)
@@ -100,8 +108,10 @@ static int xt_rateest_tg_checkentry(const struct xt_tgchk_param *par)net_get_random_once (&jhash_rnd,sizeof (jhash_rnd)); - est =xt_rateest_lookup (info->name); +mutex_lock (&xt_rateest_mutex); + est =__xt_rateest_lookup (info->name);if (est) { +mutex_unlock (&xt_rateest_mutex);/* * If estimator parameters are specified, they must match the * existing estimator.
@@ -139,11 +149,13 @@ static int xt_rateest_tg_checkentry(const struct xt_tgchk_param *par) info->est = est;xt_rateest_hash_insert (est); +mutex_unlock (&xt_rateest_mutex);return 0 ; err2:kfree (est); err1: +mutex_unlock (&xt_rateest_mutex);return ret; }
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 8/11 netfilter: nft_flow_offload: move flowtable cleanup routines to nf_flow_table
In reply to Pablo Neira AyusoMove the flowtable cleanup routines to nf_flow_table and expose the nf_flow_table_cleanup() helper function.
--- include/net/netfilter/nf_flow_table.h | 3 +++ net/netfilter/nf_flow_table.c | 24 ++++++++++++++++++++++++ net/netfilter/nft_flow_offload.c | 19 +------------------ 3 files changed, 28 insertions(+), 18 deletions(-)
include/net/netfilter/nf_flow_table.h +3 -0
@@ -95,6 +95,9 @@ struct flow_offload_tuple_rhash *flow_offload_lookup(struct nf_flowtable *flow_tint nf_flow_table_iterate (struct nf_flowtable *flow_table,void (*iter)(struct flow_offload *flow,void *data),void *data); + +void nf_flow_table_cleanup (struct net *net,struct net_device *dev); +void nf_flow_offload_work_gc (struct work_struct *work);extern const struct rhashtable_params nf_flow_offload_rhash_params;
net/netfilter/nf_flow_table.c +24 -0
@@ -4,6 +4,7 @@#include <linux/netfilter.h> #include <linux/rhashtable.h> #include <linux/netdevice.h> +#include <net/netfilter/nf_tables.h> #include <net/netfilter/nf_flow_table.h> #include <net/netfilter/nf_conntrack.h> #include <net/netfilter/nf_conntrack_core.h>
@@ -425,5 +426,28 @@ int nf_flow_dnat_port(const struct flow_offload *flow, }EXPORT_SYMBOL_GPL (nf_flow_dnat_port); +static void nf_flow_table_do_cleanup (struct flow_offload *flow,void *data) +{ +struct net_device *dev = data; + +if (dev && flow->tuplehash[0 ].tuple.iifidx != dev->ifindex) +return ; + +flow_offload_dead (flow); +} + +static void nf_flow_table_iterate_cleanup (struct nf_flowtable *flowtable, +void *data) +{ +nf_flow_table_iterate (flowtable, nf_flow_table_do_cleanup, data); +flush_delayed_work (&flowtable->gc_work); +} + +void nf_flow_table_cleanup (struct net *net,struct net_device *dev) +{ +nft_flow_table_iterate (net, nf_flow_table_iterate_cleanup, dev); +} +EXPORT_SYMBOL_GPL (nf_flow_table_cleanup); +MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Pablo Neira Ayuso <[email protected]>" );
net/netfilter/nft_flow_offload.c +1 -18
@@ -194,23 +194,6 @@ static struct nft_expr_type nft_flow_offload_type __read_mostly = { .owner = THIS_MODULE, }; -static void flow_offload_iterate_cleanup (struct flow_offload *flow,void *data) -{ -struct net_device *dev = data; - -if (dev && flow->tuplehash[0 ].tuple.iifidx != dev->ifindex) -return ; - -flow_offload_dead (flow); -} - -static void nft_flow_offload_iterate_cleanup (struct nf_flowtable *flowtable, -void *data) -{ -nf_flow_table_iterate (flowtable, flow_offload_iterate_cleanup, data); -flush_delayed_work (&flowtable->gc_work); -} -static int flow_offload_netdev_event (struct notifier_block *this,unsigned long event,void *ptr) {
@@ -219,7 +202,7 @@ static int flow_offload_netdev_event(struct notifier_block *this,if (event !=NETDEV_DOWN )return NOTIFY_DONE ; -nft_flow_table_iterate (dev_net (dev), nft_flow_offload_iterate_cleanup, dev); +nf_flow_table_cleanup (dev_net (dev), dev);return NOTIFY_DONE ; }
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 9/11 netfilter: nf_tables: fix flowtable free
In reply to Pablo Neira AyusoEvery flow_offload entry is added into the table twice. Because of this, rhashtable_free_and_destroy can't be used, since it would call kfree for each flow_offload object twice.
This patch cleans up the flowtable via nf_flow_table_iterate() to schedule removal of entries by setting on the dying bit, then there is an explicitly invocation of the garbage collector to release resources.
Based on patch from Felix Fietkau.
--- include/net/netfilter/nf_flow_table.h | 2 ++ net/ipv4/netfilter/nf_flow_table_ipv4.c | 1 + net/ipv6/netfilter/nf_flow_table_ipv6.c | 1 + net/netfilter/nf_flow_table.c | 25 +++++++++++++++++++------ net/netfilter/nf_flow_table_inet.c | 1 + net/netfilter/nf_tables_api.c | 9 ++------- 6 files changed, 26 insertions(+), 13 deletions(-)
include/net/netfilter/nf_flow_table.h +2 -0
@@ -14,6 +14,7 @@ struct nf_flowtable_type {struct list_head list;int family;void (*gc)(struct work_struct *work); +void (*free)(struct nf_flowtable *ft);const struct rhashtable_params *params;nf_hookfn *hook;struct module *owner;
@@ -98,6 +99,7 @@ int nf_flow_table_iterate(struct nf_flowtable *flow_table,void nf_flow_table_cleanup (struct net *net,struct net_device *dev); +void nf_flow_table_free (struct nf_flowtable *flow_table);void nf_flow_offload_work_gc (struct work_struct *work);extern const struct rhashtable_params nf_flow_offload_rhash_params;
net/ipv4/netfilter/nf_flow_table_ipv4.c +1 -0
@@ -260,6 +260,7 @@ static struct nf_flowtable_type flowtable_ipv4 = { .family = NFPROTO_IPV4, .params = &nf_flow_offload_rhash_params, .gc = nf_flow_offload_work_gc, + .free = nf_flow_table_free, .hook = nf_flow_offload_ip_hook, .owner = THIS_MODULE, };
net/ipv6/netfilter/nf_flow_table_ipv6.c +1 -0
@@ -253,6 +253,7 @@ static struct nf_flowtable_type flowtable_ipv6 = { .family = NFPROTO_IPV6, .params = &nf_flow_offload_rhash_params, .gc = nf_flow_offload_work_gc, + .free = nf_flow_table_free, .hook = nf_flow_offload_ipv6_hook, .owner = THIS_MODULE, };
net/netfilter/nf_flow_table.c +19 -6
@@ -232,19 +232,16 @@ static inline bool nf_flow_is_dying(const struct flow_offload *flow)return flow->flags &FLOW_OFFLOAD_DYING ; } -void nf_flow_offload_work_gc (struct work_struct *work) +static int nf_flow_offload_gc_step (struct nf_flowtable *flow_table) {struct flow_offload_tuple_rhash *tuplehash; -struct nf_flowtable *flow_table;struct rhashtable_iter hti;struct flow_offload *flow;int err; - flow_table = container_of(work, struct nf_flowtable, gc_work.work); - err =rhashtable_walk_init (&flow_table->rhashtable, &hti,GFP_KERNEL );if (err) - goto schedule; +return 0 ;rhashtable_walk_start (&hti);
@@ -270,7 +267,16 @@ void nf_flow_offload_work_gc(struct work_struct *work) out:rhashtable_walk_stop (&hti);rhashtable_walk_exit (&hti); -schedule: + +return 1 ; +} + +void nf_flow_offload_work_gc (struct work_struct *work) +{ +struct nf_flowtable *flow_table; + + flow_table = container_of(work, struct nf_flowtable, gc_work.work); +nf_flow_offload_gc_step (flow_table);queue_delayed_work (system_power_efficient_wq, &flow_table->gc_work,HZ ); }EXPORT_SYMBOL_GPL (nf_flow_offload_work_gc);
@@ -449,5 +455,12 @@ void nf_flow_table_cleanup(struct net *net, struct net_device *dev) }EXPORT_SYMBOL_GPL (nf_flow_table_cleanup); +void nf_flow_table_free (struct nf_flowtable *flow_table) +{ +nf_flow_table_iterate (flow_table, nf_flow_table_do_cleanup,NULL ); +WARN_ON (!nf_flow_offload_gc_step (flow_table)); +} +EXPORT_SYMBOL_GPL (nf_flow_table_free); +MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Pablo Neira Ayuso <[email protected]>" );
net/netfilter/nf_flow_table_inet.c +1 -0
@@ -24,6 +24,7 @@ static struct nf_flowtable_type flowtable_inet = { .family = NFPROTO_INET, .params = &nf_flow_offload_rhash_params, .gc = nf_flow_offload_work_gc, + .free = nf_flow_table_free, .hook = nf_flow_offload_inet_hook, .owner = THIS_MODULE, };
net/netfilter/nf_tables_api.c +2 -7
@@ -5399,17 +5399,12 @@ static void nf_tables_flowtable_notify(struct nft_ctx *ctx,nfnetlink_set_err (ctx->net, ctx->portid,NFNLGRP_NFTABLES , -ENOBUFS ); } -static void nft_flowtable_destroy (void *ptr,void *arg) -{ -kfree (ptr); -} -static void nf_tables_flowtable_destroy (struct nft_flowtable *flowtable) {cancel_delayed_work_sync (&flowtable->data.gc_work);kfree (flowtable->name); -rhashtable_free_and_destroy (&flowtable->data.rhashtable, - nft_flowtable_destroy,NULL ); + flowtable->data.type->free (&flowtable->data); +rhashtable_destroy (&flowtable->data.rhashtable);module_put (flowtable->data.type->owner); }
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 10/11 netfilter: remove useless prototype
In reply to Pablo Neira AyusoFrom: Taehee Yoo <[email protected]>
prototype nf_ct_nat_offset is not used anymore.
--- include/net/netfilter/nf_conntrack.h | 5 ----- 1 file changed, 5 deletions(-)
include/net/netfilter/nf_conntrack.h +0 -5
@@ -213,11 +213,6 @@ static inline bool nf_ct_kill(struct nf_conn *ct)return nf_ct_delete (ct,0 ,0 ); } -/* These are for NAT. Icky. */ -extern s32 (*nf_ct_nat_offset)(const struct nf_conn *ct, -enum ip_conntrack_dir dir, -u32 seq); -/* Set all unconfirmed conntrack as dying */ void nf_ct_unconfirmed_destroy (struct net *);
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 11/11 netfilter: nf_flow_offload: fix use-after-free and a resource leak
In reply to Pablo Neira AyusoFrom: Felix Fietkau <[email protected]>
flow_offload_del frees the flow, so all associated resource must be freed before.
Since the ct entry in struct flow_offload_entry was allocated by flow_offload_alloc, it should be freed by flow_offload_free to take care of the error handling path when flow_offload_add fails.
While at it, make flow_offload_del static, since it should never be called directly, only from the gc step
--- include/net/netfilter/nf_flow_table.h | 1 - net/netfilter/nf_flow_table.c | 27 +++++++-------------------- 2 files changed, 7 insertions(+), 21 deletions(-)
include/net/netfilter/nf_flow_table.h +0 -1
@@ -90,7 +90,6 @@ struct flow_offload *flow_offload_alloc(struct nf_conn *ct,void flow_offload_free (struct flow_offload *flow);int flow_offload_add (struct nf_flowtable *flow_table,struct flow_offload *flow); -void flow_offload_del (struct nf_flowtable *flow_table,struct flow_offload *flow);struct flow_offload_tuple_rhash *flow_offload_lookup (struct nf_flowtable *flow_table,struct flow_offload_tuple *tuple); int nf_flow_table_iterate(struct nf_flowtable *flow_table,
net/netfilter/nf_flow_table.c +7 -20
@@ -125,7 +125,9 @@ void flow_offload_free(struct flow_offload *flow)dst_release (flow->tuplehash[FLOW_OFFLOAD_DIR_ORIGINAL ].tuple.dst_cache);dst_release (flow->tuplehash[FLOW_OFFLOAD_DIR_REPLY ].tuple.dst_cache); e = container_of(flow, struct flow_offload_entry, flow); -kfree (e); +nf_ct_delete (e->ct,0 ,0 ); +nf_ct_put (e->ct); +kfree_rcu (e, rcu_head); }EXPORT_SYMBOL_GPL (flow_offload_free);
@@ -149,11 +151,9 @@ int flow_offload_add(struct nf_flowtable *flow_table, struct flow_offload *flow) }EXPORT_SYMBOL_GPL (flow_offload_add); -void flow_offload_del (struct nf_flowtable *flow_table, -struct flow_offload *flow) +static void flow_offload_del (struct nf_flowtable *flow_table, +struct flow_offload *flow) { -struct flow_offload_entry *e; -rhashtable_remove_fast (&flow_table->rhashtable, &flow->tuplehash[FLOW_OFFLOAD_DIR_ORIGINAL ].node, *flow_table->type->params);
@@ -161,10 +161,8 @@ void flow_offload_del(struct nf_flowtable *flow_table, &flow->tuplehash[FLOW_OFFLOAD_DIR_REPLY ].node, *flow_table->type->params); - e = container_of(flow, struct flow_offload_entry, flow); -kfree_rcu (e, rcu_head); +flow_offload_free (flow); } -EXPORT_SYMBOL_GPL (flow_offload_del);struct flow_offload_tuple_rhash * flow_offload_lookup(struct nf_flowtable *flow_table,
@@ -175,15 +173,6 @@ flow_offload_lookup(struct nf_flowtable *flow_table, }EXPORT_SYMBOL_GPL (flow_offload_lookup); -static void nf_flow_release_ct (const struct flow_offload *flow) -{ -struct flow_offload_entry *e; - - e = container_of(flow, struct flow_offload_entry, flow); -nf_ct_delete (e->ct,0 ,0 ); -nf_ct_put (e->ct); -} -int nf_flow_table_iterate (struct nf_flowtable *flow_table,void (*iter)(struct flow_offload *flow,void *data),void *data)
@@ -259,10 +248,8 @@ static int nf_flow_offload_gc_step(struct nf_flowtable *flow_table) flow = container_of(tuplehash, struct flow_offload, tuplehash[0]);if (nf_flow_has_expired (flow) || -nf_flow_is_dying (flow)) { +nf_flow_is_dying (flow))flow_offload_del (flow_table, flow); -nf_flow_release_ct (flow); - } } out:rhashtable_walk_stop (&hti);
Signature · 1 line
2.11.0
David Miller
maintainerFrom: Pablo Neira Ayuso <[email protected]>
Date: Wed, 7 Feb 2018 18:42:18 +0100
Quoted 2 lines
The following patchset contains Netfilter fixes for you net tree, they are:
...
Quoted 3 lines
You can pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git
Pulled, thanks Pablo.
Quoted 2 lines
P.S: Again more fixes cooking on [email protected], so
another round is likely coming up soon.
Ok, no problem.