net_sched: fix a race condition in tcindex_destroy()
Subsystems (3)
PATCH 1/2 net_sched: fix a race condition in tcindex_destroy()
(cherry picked from commit 8015d93ebd27484418d4952284fd02172fa4b0b2)
tcindex_destroy() invokes tcindex_destroy_element() via a walker to delete each filter result in its perfect hash table, and tcindex_destroy_element() calls tcindex_delete() which schedules tcf RCU works to do the final deletion work. Unfortunately this races with the RCU callback __tcindex_destroy(), which could lead to use-after-free as reported by Adrian.
Fix this by migrating this RCU callback to tcf RCU work too, as that workqueue is ordered, we will not have use-after-free.
Note, we don't need to hold netns refcnt because we don't call tcf_exts_destroy() here.
--- net/sched/cls_tcindex.c | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-)
net/sched/cls_tcindex.c +11 -7
@@ -48,7 +48,7 @@ struct tcindex_data {u32 hash;/* hash table size; 0 if undefined */ u32 alloc_hash;/* allocated size */ u32 fall_through;/* 0: only classify if explicit match */ -struct rcu_head rcu; +struct rcu_work rwork; };static inline int tcindex_filter_is_set (struct tcindex_filter_result *r)
@@ -229,9 +229,11 @@ static int tcindex_destroy_element(struct tcf_proto *tp,return tcindex_delete (tp, arg, &last, false,NULL ); } -static void __tcindex_destroy (struct rcu_head *head) +static void tcindex_destroy_work (struct work_struct *work) { - struct tcindex_data *p = container_of(head, struct tcindex_data, rcu); +struct tcindex_data *p =container_of (to_rcu_work (work), + struct tcindex_data, + rwork);kfree (p->perfect);kfree (p->h);
@@ -258,9 +260,11 @@ static int tcindex_filter_result_init(struct tcindex_filter_result *r)return tcf_exts_init (&r->exts,TCA_TCINDEX_ACT ,TCA_TCINDEX_POLICE ); } -static void __tcindex_partial_destroy (struct rcu_head *head) +static void tcindex_partial_destroy_work (struct work_struct *work) { - struct tcindex_data *p = container_of(head, struct tcindex_data, rcu); +struct tcindex_data *p =container_of (to_rcu_work (work), + struct tcindex_data, + rwork);kfree (p->perfect);kfree (p);
@@ -480,7 +484,7 @@ tcindex_set_parms(struct net *net, struct tcf_proto *tp, unsigned long base, }if (oldp) -call_rcu (&oldp->rcu, __tcindex_partial_destroy); +tcf_queue_work (&oldp->rwork, tcindex_partial_destroy_work);return 0 ; errout_alloc:
@@ -572,7 +576,7 @@ static void tcindex_destroy(struct tcf_proto *tp, bool rtnl_held, walker.fn = tcindex_destroy_element;tcindex_walk (tp, &walker, true); -call_rcu (&p->rcu, __tcindex_destroy); +tcf_queue_work (&p->rwork, tcindex_destroy_work); }
Signature · 1 line
2.20.1
PATCH 2/2 net_sched: fix a memory leak in cls_tcindex
(cherry picked from commit 033b228e7f26b29ae37f8bfa1bc6b209a5365e9f)
When tcindex_destroy() destroys all the filter results in the perfect hash table, it invokes the walker to delete each of them. However, results with class==0 are skipped in either tcindex_walk() or tcindex_delete(), which causes a memory leak reported by kmemleak.
This patch fixes it by skipping the walker and directly deleting these filter results so we don't miss any filter result.
As a result of this change, we have to initialize exts->net properly in tcindex_alloc_perfect_hash(). For net-next, we need to consider whether we should initialize ->net in tcf_exts_init() instead, before that just directly test CONFIG_NET_CLS_ACT=y.
--- net/sched/cls_tcindex.c | 37 ++++++++++++++++++++++++------------- 1 file changed, 24 insertions(+), 13 deletions(-)
net/sched/cls_tcindex.c +24 -13
@@ -221,14 +221,6 @@ static int tcindex_delete(struct tcf_proto *tp, void *arg, bool *last,return 0 ; } -static int tcindex_destroy_element (struct tcf_proto *tp, -void *arg,struct tcf_walker *walker) -{ -bool last; - -return tcindex_delete (tp, arg, &last, false,NULL ); -} -static void tcindex_destroy_work (struct work_struct *work) { struct tcindex_data *p = container_of(to_rcu_work(work),
@@ -568,13 +560,32 @@ static void tcindex_destroy(struct tcf_proto *tp, bool rtnl_held, struct netlink_ext_ack *extack) {struct tcindex_data *p =rtnl_dereference (tp->root); -struct tcf_walker walker; +int i;pr_debug ("tcindex_destroy(tp %p),p %p\n" , tp, p); - walker.count =0 ; - walker.skip =0 ; - walker.fn = tcindex_destroy_element; -tcindex_walk (tp, &walker, true); + +if (p->perfect) { +for (i =0 ; i < p->hash; i++) { +struct tcindex_filter_result *r = p->perfect + i; + +tcf_unbind_filter (tp, &r->res); +if (tcf_exts_get_net (&r->exts)) +tcf_queue_work (&r->rwork, + tcindex_destroy_rexts_work); +else +__tcindex_destroy_rexts (r); + } + } + +for (i =0 ; p->h && i < p->hash; i++) { +struct tcindex_filter *f, *next; +bool last; + +for (f =rtnl_dereference (p->h[i]); f; f = next) { + next =rtnl_dereference (f->next); +tcindex_delete (tp, &f->result, &last, rtnl_held,NULL ); + } + }tcf_queue_work (&p->rwork, tcindex_destroy_work); }
Signature · 1 line
2.20.1
Re: [Patch net-next 2/2] net_sched: fix a memory leak in cls_tcindex
From: Cong Wang <[email protected]>
Date: Sat, 16 Feb 2019 10:58:27 -0800
Quoted 18 lines
(cherry picked from commit
033b228e7f26b29ae37f8bfa1bc6b209a5365e9f)When
tcindex_destroy()destroys all the filter results in the perfect hash table, it invokes the walker to delete each of them. However, results with class==0 are skipped in eithertcindex_walk()ortcindex_delete(), which causes a memory leak reported by kmemleak.This patch fixes it by skipping the walker and directly deleting these filter results so we don't miss any filter result.
As a result of this change, we have to initialize
exts->netproperly intcindex_alloc_perfect_hash(). For net-next, we need to consider whether we should initialize ->net intcf_exts_init()instead, before that just directly testCONFIG_NET_CLS_ACT=y.
Quoted 3 lines
Cc Jamal Hadi Salim <[email protected]>Cc Jiri Pirko <[email protected]>Signed-off-by Cong Wang <[email protected]>
Applied.
From: Cong Wang <[email protected]>
Date: Sat, 16 Feb 2019 10:58:26 -0800
Quoted 16 lines
(cherry picked from commit
8015d93ebd27484418d4952284fd02172fa4b0b2)
tcindex_destroy()invokestcindex_destroy_element()via a walker to delete each filter result in its perfect hash table, andtcindex_destroy_element()callstcindex_delete()which schedules tcf RCU works to do the final deletion work. Unfortunately this races with the RCU callback__tcindex_destroy(), which could lead to use-after-free as reported by Adrian.Fix this by migrating this RCU callback to tcf RCU work too, as that workqueue is ordered, we will not have use-after-free.
Note, we don't need to hold netns refcnt because we don't call
tcf_exts_destroy()here.
Quoted 6 lines
Fixes 27ce4f05e2ab ("net_sched: use tcf_queue_work() in tcindex filter")Reported-by Adrian <[email protected]>Cc Ben Hutchings <[email protected]>Cc Jamal Hadi Salim <[email protected]>Cc Jiri Pirko <[email protected]>Signed-off-by Cong Wang <[email protected]>
Applied.