4.19.316-rc1 review
Subsystems (4)
Greg Kroah-Hartman
maintainerPATCH 160/213 netfilter: nftables: rename set element data activation/deactivation functions
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit f8bb7889af58d8e74d2d61c76b1418230f1610fa upstream.
Rename:
- nft_set_elem_activate() to nft_set_elem_data_activate().
- nft_set_elem_deactivate() to nft_set_elem_data_deactivate().
To prepare for updates in the set element infrastructure to add support for the special catch-all element.
--- net/netfilter/nf_tables_api.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-)
net/netfilter/nf_tables_api.c +11 -11
@@ -4501,8 +4501,8 @@ void nft_set_elem_destroy(const struct n }EXPORT_SYMBOL_GPL (nft_set_elem_destroy); -/* Only called from commit path, nft_set_elem_deactivate() already deals with -* the refcounting from the preparation phase. +/* Only called from commit path, nft_setelem_data_deactivate() already deals +* with the refcounting from the preparation phase. */ static void nf_tables_set_elem_destroy (const struct nft_ctx *ctx,const struct nft_set *set,void *elem)
@@ -4806,9 +4806,9 @@ void nft_data_hold(const struct nft_data } } -static void nft_set_elem_activate (const struct net *net, -const struct nft_set *set, -struct nft_set_elem *elem) +static void nft_setelem_data_activate (const struct net *net, +const struct nft_set *set, +struct nft_set_elem *elem) {const struct nft_set_ext *ext =nft_set_elem_ext (set, elem->priv);
@@ -4818,9 +4818,9 @@ static void nft_set_elem_activate(constnft_use_inc_restore (&(*nft_set_ext_obj (ext))->use); } -static void nft_set_elem_deactivate (const struct net *net, -const struct nft_set *set, -struct nft_set_elem *elem) +static void nft_setelem_data_deactivate (const struct net *net, +const struct nft_set *set, +struct nft_set_elem *elem) {const struct nft_set_ext *ext =nft_set_elem_ext (set, elem->priv);
@@ -4887,7 +4887,7 @@ static int nft_del_setelem(struct nft_ctkfree (elem.priv); elem.priv = priv; -nft_set_elem_deactivate (ctx->net, set, &elem); +nft_setelem_data_deactivate (ctx->net, set, &elem);nft_trans_elem (trans) = elem;nft_trans_commit_list_add_tail (ctx->net, trans);
@@ -4921,7 +4921,7 @@ static int nft_flush_set(const struct nf } set->ndeact++; -nft_set_elem_deactivate (ctx->net, set, elem); +nft_setelem_data_deactivate (ctx->net, set, elem);nft_trans_elem_set (trans) = set;nft_trans_elem (trans) = *elem;nft_trans_commit_list_add_tail (ctx->net, trans);
@@ -6954,7 +6954,7 @@ static int __nf_tables_abort(struct netcase NFT_MSG_DELSETELEM : te = (struct nft_trans_elem *)trans->data; -nft_set_elem_activate (net, te->set, &te->elem); +nft_setelem_data_activate (net, te->set, &te->elem); te->set->ops->activate (net, te->set, &te->elem); te->set->ndeact--;
Greg Kroah-Hartman
maintainerPATCH 161/213 netfilter: nf_tables: drop map element references from preparation phase
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
[ Upstream commit 628bd3e49cba1c066228e23d71a852c23e26da73 ]
set .destroy callback releases the references to other objects in maps. This is very late and it results in spurious EBUSY errors. Drop refcount from the preparation phase instead, update set backend not to drop reference counter from set .destroy path.
Exceptions: NFT_TRANS_PREPARE_ERROR does not require to drop the reference counter because the transaction abort path releases the map references for each element since the set is unbound. The abort path also deals with releasing reference counter for new elements added to unbound sets.
--- include/net/netfilter/nf_tables.h | 5 +- net/netfilter/nf_tables_api.c | 89 ++++++++++++++++++++++++++++++++++---- net/netfilter/nft_set_bitmap.c | 5 +- net/netfilter/nft_set_hash.c | 23 +++++++-- net/netfilter/nft_set_rbtree.c | 5 +- 5 files changed, 108 insertions(+), 19 deletions(-)
include/net/netfilter/nf_tables.h +4 -1
@@ -349,7 +349,8 @@ struct nft_set_ops {int (*init)(const struct nft_set *set,const struct nft_set_desc *desc,const struct nlattr *const nla[]); -void (*destroy)(const struct nft_set *set); +void (*destroy)(const struct nft_ctx *ctx, +const struct nft_set *set);void (*gc_init)(const struct nft_set *set);unsigned int elemsize;
@@ -645,6 +646,8 @@ void *nft_set_elem_init(const struct nft u64 timeout, gfp_t gfp);void nft_set_elem_destroy (const struct nft_set *set,void *elem,bool destroy_expr); +void nf_tables_set_elem_destroy (const struct nft_ctx *ctx, +const struct nft_set *set,void *elem);/** * struct nft_set_gc_batch_head - nf_tables set garbage collection batch
net/netfilter/nf_tables_api.c +80 -9
164 lines not on this page · raw message
net/netfilter/nft_set_bitmap.c +3 -2
@@ -273,13 +273,14 @@ static int nft_bitmap_init(const structreturn 0 ; } -static void nft_bitmap_destroy (const struct nft_set *set) +static void nft_bitmap_destroy (const struct nft_ctx *ctx, +const struct nft_set *set) {struct nft_bitmap *priv =nft_set_priv (set);struct nft_bitmap_elem *be, *n;list_for_each_entry_safe (be, n, &priv->list, head) -nft_set_elem_destroy (set, be, true); +nf_tables_set_elem_destroy (ctx, set, be); } static bool nft_bitmap_estimate(const struct nft_set_desc *desc, u32 features,
net/netfilter/nft_set_hash.c +18 -5
@@ -379,19 +379,31 @@ static int nft_rhash_init(const struct nreturn 0 ; } +struct nft_rhash_ctx { +const struct nft_ctx ctx; +const struct nft_set *set; +}; +static void nft_rhash_elem_destroy (void *ptr,void *arg) { -nft_set_elem_destroy (arg, ptr, true); +struct nft_rhash_ctx *rhash_ctx = arg; + +nf_tables_set_elem_destroy (&rhash_ctx->ctx, rhash_ctx->set, ptr); } -static void nft_rhash_destroy (const struct nft_set *set) +static void nft_rhash_destroy (const struct nft_ctx *ctx, +const struct nft_set *set) {struct nft_rhash *priv =nft_set_priv (set); +struct nft_rhash_ctx rhash_ctx = { + .ctx = *ctx, + .set = set, + };cancel_delayed_work_sync (&priv->gc_work);rcu_barrier ();rhashtable_free_and_destroy (&priv->ht, nft_rhash_elem_destroy, - (void *)set); + (void *)&rhash_ctx); }/* Number of buckets is stored in u32, so cap our result to 1U<<31 */
@@ -629,7 +641,8 @@ static int nft_hash_init(const struct nfreturn 0 ; } -static void nft_hash_destroy (const struct nft_set *set) +static void nft_hash_destroy (const struct nft_ctx *ctx, +const struct nft_set *set) {struct nft_hash *priv =nft_set_priv (set);struct nft_hash_elem *he;
@@ -639,7 +652,7 @@ static void nft_hash_destroy(const strucfor (i =0 ; i < priv->buckets; i++) {hlist_for_each_entry_safe (he, next, &priv->table[i], node) {hlist_del_rcu (&he->node); -nft_set_elem_destroy (set, he, true); +nf_tables_set_elem_destroy (ctx, set, he); } } }
net/netfilter/nft_set_rbtree.c +3 -2
@@ -466,7 +466,8 @@ static int nft_rbtree_init(const structreturn 0 ; } -static void nft_rbtree_destroy (const struct nft_set *set) +static void nft_rbtree_destroy (const struct nft_ctx *ctx, +const struct nft_set *set) {struct nft_rbtree *priv =nft_set_priv (set);struct nft_rbtree_elem *rbe;
@@ -477,7 +478,7 @@ static void nft_rbtree_destroy(const strwhile ((node = priv->root.rb_node) !=NULL ) {rb_erase (node, &priv->root); rbe = rb_entry(node, struct nft_rbtree_elem, node); -nft_set_elem_destroy (set, rbe, true); +nf_tables_set_elem_destroy (ctx, set, rbe); } }
Greg Kroah-Hartman
maintainerPATCH 162/213 netfilter: nft_set_rbtree: allow loose matching of closing element in interval
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 3b18d5eba491b2328b31efa4235724a2354af010 upstream.
Allow to find closest matching for the right side of an interval (end flag set on) so we allow lookups in inner ranges, eg. 10-20 in 5-25.
--- net/netfilter/nft_set_rbtree.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
net/netfilter/nft_set_rbtree.c +8 -2
@@ -145,9 +145,12 @@ static bool __nft_rbtree_get(const struc d =memcmp (this, key, set->klen);if (d <0 ) { parent =rcu_dereference_raw (parent->rb_left); - interval = rbe; +if (!(flags &NFT_SET_ELEM_INTERVAL_END )) + interval = rbe; }else if (d >0 ) { parent =rcu_dereference_raw (parent->rb_right); +if (flags &NFT_SET_ELEM_INTERVAL_END ) + interval = rbe; }else {if (!nft_set_elem_active (&rbe->ext, genmask)) { parent =rcu_dereference_raw (parent->rb_left);
@@ -170,7 +173,10 @@ static bool __nft_rbtree_get(const strucif (set->flags &NFT_SET_INTERVAL && interval !=NULL &&nft_set_elem_active (&interval->ext, genmask) && - !nft_rbtree_interval_end (interval)) { + ((!nft_rbtree_interval_end (interval) && + !(flags &NFT_SET_ELEM_INTERVAL_END )) || + (nft_rbtree_interval_end (interval) && + (flags &NFT_SET_ELEM_INTERVAL_END )))) { *elem = interval;return true; }
Greg Kroah-Hartman
maintainerPATCH 163/213 netfilter: nft_set_rbtree: Add missing expired checks
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Phil Sutter <[email protected]>
commit 340eaff651160234bdbce07ef34b92a8e45cd540 upstream.
Expired intervals would still match and be dumped to user space until garbage collection wiped them out. Make sure they stop matching and disappear (from users' perspective) as soon as they expire.
--- net/netfilter/nft_set_rbtree.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
net/netfilter/nft_set_rbtree.c +11 -0
@@ -82,6 +82,10 @@ static bool __nft_rbtree_lookup(const st parent =rcu_dereference_raw (parent->rb_left);continue ; } + +if (nft_set_elem_expired (&rbe->ext)) +return false; +if (nft_rbtree_interval_end (rbe)) {if (nft_set_is_anonymous (set))return false;
@@ -97,6 +101,7 @@ static bool __nft_rbtree_lookup(const stif (set->flags &NFT_SET_INTERVAL && interval !=NULL &&nft_set_elem_active (&interval->ext, genmask) && + !nft_set_elem_expired (&interval->ext) &&nft_rbtree_interval_start (interval)) { *ext = &interval->ext;return true;
@@ -157,6 +162,9 @@ static bool __nft_rbtree_get(const struccontinue ; } +if (nft_set_elem_expired (&rbe->ext)) +return false; +if (!nft_set_ext_exists (&rbe->ext,NFT_SET_EXT_FLAGS ) || (*nft_set_ext_flags (&rbe->ext) &NFT_SET_ELEM_INTERVAL_END ) == (flags &NFT_SET_ELEM_INTERVAL_END )) {
@@ -173,6 +181,7 @@ static bool __nft_rbtree_get(const struc if (set->flags & NFT_SET_INTERVAL && interval != NULL && nft_set_elem_active(&interval->ext, genmask) && + !nft_set_elem_expired(&interval->ext) && ((!nft_rbtree_interval_end(interval) && !(flags & NFT_SET_ELEM_INTERVAL_END)) || (nft_rbtree_interval_end(interval) &&
@@ -360,6 +369,8 @@ static void nft_rbtree_walk(const structif (iter->count < iter->skip) goto cont; +if (nft_set_elem_expired (&rbe->ext)) + goto cont;if (!nft_set_elem_active (&rbe->ext, iter->genmask)) goto cont;
Greg Kroah-Hartman
maintainerPATCH 164/213 netfilter: nft_set_rbtree: Switch to node list walk for overlap detection
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit c9e6978e2725a7d4b6cd23b2facd3f11422c0643 upstream.
...instead of a tree descent, which became overly complicated in an attempt to cover cases where expired or inactive elements would affect comparisons with the new element being inserted.
Further, it turned out that it's probably impossible to cover all those cases, as inactive nodes might entirely hide subtrees consisting of a complete interval plus a node that makes the current insertion not overlap.
To speed up the overlap check, descent the tree to find a greater element that is closer to the key value to insert. Then walk down the node list for overlap detection. Starting the overlap check from rb_first() unconditionally is slow, it takes 10 times longer due to the full linear traversal of the list.
Moreover, perform garbage collection of expired elements when walking down the node list to avoid bogus overlap reports.
For the insertion operation itself, this essentially reverts back to the implementation before commit 7c84d41416d8 ("netfilter: nft_set_rbtree:
Detect partial overlaps on insertion"), except that cases of complete overlap are already handled in the overlap detection phase itself, which slightly simplifies the loop to find the insertion point.
Based on initial patch from Stefano Brivio, including text from the original patch description too.
--- net/netfilter/nft_set_rbtree.c | 223 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 198 insertions(+), 25 deletions(-)
net/netfilter/nft_set_rbtree.c +198 -25
@@ -41,10 +41,12 @@ static bool nft_rbtree_interval_start(coreturn !nft_rbtree_interval_end (rbe); } -static bool nft_rbtree_equal (const struct nft_set *set,const void *this, -const struct nft_rbtree_elem *interval) +static int nft_rbtree_cmp (const struct nft_set *set, +const struct nft_rbtree_elem *e1, +const struct nft_rbtree_elem *e2) { -return memcmp (this,nft_set_ext_key (&interval->ext), set->klen) ==0 ; +return memcmp (nft_set_ext_key (&e1->ext),nft_set_ext_key (&e2->ext), + set->klen); } static bool __nft_rbtree_lookup(const struct net *net, const struct nft_set *set,
@@ -55,7 +57,6 @@ static bool __nft_rbtree_lookup(const stconst struct nft_rbtree_elem *rbe, *interval =NULL ;u8 genmask =nft_genmask_cur (net);const struct rb_node *parent; -const void *this;int d; parent =rcu_dereference_raw (priv->root.rb_node);
@@ -65,12 +66,11 @@ static bool __nft_rbtree_lookup(const st rbe = rb_entry(parent, struct nft_rbtree_elem, node); - this =nft_set_ext_key (&rbe->ext); - d =memcmp (this, key, set->klen); + d =memcmp (nft_set_ext_key (&rbe->ext), key, set->klen);if (d <0 ) { parent =rcu_dereference_raw (parent->rb_left);if (interval && -nft_rbtree_equal (set, this, interval) && + !nft_rbtree_cmp (set, rbe, interval) &&nft_rbtree_interval_end (rbe) &&nft_rbtree_interval_start (interval))continue ;
@@ -217,43 +217,216 @@ static void *nft_rbtree_get(const structreturn rbe; } +static int nft_rbtree_gc_elem (const struct nft_set *__set, +struct nft_rbtree *priv, +struct nft_rbtree_elem *rbe) +{ +struct nft_set *set = (struct nft_set *)__set; +struct rb_node *prev =rb_prev (&rbe->node); +struct nft_rbtree_elem *rbe_prev; +struct nft_set_gc_batch *gcb; + + gcb =nft_set_gc_batch_check (set,NULL ,GFP_ATOMIC ); +if (!gcb) +return -ENOMEM ; + +/* search for expired end interval coming before this element. */ +do { + rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node); +if (nft_rbtree_interval_end (rbe_prev)) +break ; + + prev =rb_prev (prev); + }while (prev !=NULL ); + +rb_erase (&rbe_prev->node, &priv->root); +rb_erase (&rbe->node, &priv->root); +atomic_sub (2 , &set->nelems); + +nft_set_gc_batch_add (gcb, rbe); +nft_set_gc_batch_complete (gcb); + +return 0 ; +} + +static bool nft_rbtree_update_first (const struct nft_set *set, +struct nft_rbtree_elem *rbe, +struct rb_node *first) +{ +struct nft_rbtree_elem *first_elem; + + first_elem = rb_entry(first, struct nft_rbtree_elem, node); +/* this element is closest to where the new element is to be inserted: +* update the first element for the node list path. +*/ +if (nft_rbtree_cmp (set, rbe, first_elem) <0 ) +return true; + +return false; +} +static int __nft_rbtree_insert (const struct net *net,const struct nft_set *set,struct nft_rbtree_elem *new,struct nft_set_ext **ext) { +struct nft_rbtree_elem *rbe, *rbe_le =NULL , *rbe_ge =NULL ; +struct rb_node *node, *parent, **p, *first =NULL ;struct nft_rbtree *priv =nft_set_priv (set);u8 genmask =nft_genmask_next (net); -struct nft_rbtree_elem *rbe; -struct rb_node *parent, **p; -int d; +int d, err; +/* Descend the tree to search for an existing element greater than the +* key value to insert that is greater than the new element. This is the +* first element to walk the ordered elements to find possible overlap. +*/ parent =NULL ; p = &priv->root.rb_node;while (*p !=NULL ) { parent = *p; rbe = rb_entry(parent, struct nft_rbtree_elem, node); - d =memcmp (nft_set_ext_key (&rbe->ext), -nft_set_ext_key (&new->ext), - set->klen); -if (d <0 ) + d =nft_rbtree_cmp (set, rbe, new); + +if (d <0 ) { p = &parent->rb_left; -else if (d >0 ) + }else if (d >0 ) { +if (!first || +nft_rbtree_update_first (set, rbe, first)) + first = &rbe->node; + p = &parent->rb_right; -else { -if (nft_rbtree_interval_end (rbe) && -nft_rbtree_interval_start (new)) { + }else { +if (nft_rbtree_interval_end (rbe)) p = &parent->rb_left; - }else if (nft_rbtree_interval_start (rbe) && -nft_rbtree_interval_end (new)) { +else p = &parent->rb_right; - }else if (nft_set_elem_active (&rbe->ext, genmask)) { - *ext = &rbe->ext; -return -EEXIST ; - }else { - p = &parent->rb_left; + } + } + +if (!first) + first =rb_first (&priv->root); + +/* Detect overlap by going through the list of valid tree nodes. +* Values stored in the tree are in reversed order, starting from +* highest to lowest value. +*/ +for (node = first; node !=NULL ; node =rb_next (node)) { + rbe = rb_entry(node, struct nft_rbtree_elem, node); + +if (!nft_set_elem_active (&rbe->ext, genmask)) +continue ; + +/* perform garbage collection to avoid bogus overlap reports. */ +if (nft_set_elem_expired (&rbe->ext)) { + err =nft_rbtree_gc_elem (set, priv, rbe); +if (err <0 ) +return err; + +continue ; + } + + d =nft_rbtree_cmp (set, rbe, new); +if (d ==0 ) { +/* Matching end element: no need to look for an +* overlapping greater or equal element. +*/ +if (nft_rbtree_interval_end (rbe)) { + rbe_le = rbe; +break ; + } + +/* first element that is greater or equal to key value. */ +if (!rbe_ge) { + rbe_ge = rbe; +continue ; + } + +/* this is a closer more or equal element, update it. */ +if (nft_rbtree_cmp (set, rbe_ge, new) !=0 ) { + rbe_ge = rbe; +continue ; } + +/* element is equal to key value, make sure flags are +* the same, an existing more or equal start element +* must not be replaced by more or equal end element. +*/ +if ((nft_rbtree_interval_start (new) && +nft_rbtree_interval_start (rbe_ge)) || + (nft_rbtree_interval_end (new) && +nft_rbtree_interval_end (rbe_ge))) { + rbe_ge = rbe; +continue ; + } + }else if (d >0 ) { +/* annotate element greater than the new element. */ + rbe_ge = rbe; +continue ; + }else if (d <0 ) { +/* annotate element less than the new element. */ + rbe_le = rbe; +break ; } } + +/* - new start element matching existing start element: full overlap +* reported as -EEXIST, cleared by caller if NLM_F_EXCL is not given. +*/ +if (rbe_ge && !nft_rbtree_cmp (set, new, rbe_ge) && +nft_rbtree_interval_start (rbe_ge) ==nft_rbtree_interval_start (new)) { + *ext = &rbe_ge->ext; +return -EEXIST ; + } + +/* - new end element matching existing end element: full overlap +* reported as -EEXIST, cleared by caller if NLM_F_EXCL is not given. +*/ +if (rbe_le && !nft_rbtree_cmp (set, new, rbe_le) && +nft_rbtree_interval_end (rbe_le) ==nft_rbtree_interval_end (new)) { + *ext = &rbe_le->ext; +return -EEXIST ; + } + +/* - new start element with existing closest, less or equal key value +* being a start element: partial overlap, reported as -ENOTEMPTY. +* Anonymous sets allow for two consecutive start element since they +* are constant, skip them to avoid bogus overlap reports. +*/ +if (!nft_set_is_anonymous (set) && rbe_le && +nft_rbtree_interval_start (rbe_le) &&nft_rbtree_interval_start (new)) +return -ENOTEMPTY ; + +/* - new end element with existing closest, less or equal key value +* being a end element: partial overlap, reported as -ENOTEMPTY. +*/ +if (rbe_le && +nft_rbtree_interval_end (rbe_le) &&nft_rbtree_interval_end (new)) +return -ENOTEMPTY ; + +/* - new end element with existing closest, greater or equal key value +* being an end element: partial overlap, reported as -ENOTEMPTY +*/ +if (rbe_ge && +nft_rbtree_interval_end (rbe_ge) &&nft_rbtree_interval_end (new)) +return -ENOTEMPTY ; + +/* Accepted element: pick insertion point depending on key value */ + parent =NULL ; + p = &priv->root.rb_node; +while (*p !=NULL ) { + parent = *p; + rbe = rb_entry(parent, struct nft_rbtree_elem, node); + d =nft_rbtree_cmp (set, rbe, new); + +if (d <0 ) + p = &parent->rb_left; +else if (d >0 ) + p = &parent->rb_right; +else if (nft_rbtree_interval_end (rbe)) + p = &parent->rb_left; +else + p = &parent->rb_right; + } +rb_link_node_rcu (&new->node, parent, p);rb_insert_color (&new->node, &priv->root);return 0 ;
Re: [PATCH 4.19 164/213] netfilter: nft_set_rbtree: Switch to node list walk for overlap detection
Quoted 7 lines · Greg Kroah-Hartman
4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit
c9e6978e2725a7d4b6cd23b2facd3f11422c0643upstream.
[...]
This turns out to cause a regression for nftables user-space versions older than v0.9.3, specifically before:
commit a4ec053812610400b7a9e6c060d8b7589dedd5b1
Author: Pablo Neira Ayuso <[email protected]> Date: Wed Oct 9 11:54:32 2019 +0200
segtree: always close interval in non-anonymous sets
Should nft_set_rbtree detect and fix-up the bad set messages that nftables user-space used to send?
Ben.
Signature · 3 lines
Ben Hutchings
A free society is one where it is safe to be unpopular.
- Adlai StevensonPablo Neira Ayuso
maintainerRe: [PATCH 4.19 164/213] netfilter: nft_set_rbtree: Switch to node list walk for overlap detection
Quoted 10 lines · Ben Hutchings
Quoted 7 lines · Greg Kroah-Hartman
4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit
c9e6978e2725a7d4b6cd23b2facd3f11422c0643upstream.[...]
Quoted 8 lines
This turns out to cause a regression for nftables user-space versions older than v0.9.3, specifically before:
commit
a4ec053812610400b7a9e6c060d8b7589dedd5b1Author: Pablo Neira Ayuso <[email protected]> Date: Wed Oct 9 11:54:32 2019 +0200segtree: always close interval in non-anonymous sets
This is really fixing up userspace as the commit describes, otherwise incremental updates are not possible on a set/map.
Quoted 2 lines
Should
nft_set_rbtreedetect and fix-up the bad set messages that nftables user-space used to send?
Problem is that a non-anonymous set really needs close intervals, otherwise incremental updates on it are not possible.
It should be possible to backport a fix for such nftables version.
I can see Debian 10 (Buster, oldoldstable) is using 0.9.0 but it was discontinued in june 2022? But who is using such an old userspace version?
Pablo Neira Ayuso
maintainerRe: [PATCH 4.19 164/213] netfilter: nft_set_rbtree: Switch to node list walk for overlap detection
Quoted 26 lines · Pablo Neira Ayuso
Quoted 10 lines · Ben Hutchings
Quoted 7 lines · Greg Kroah-Hartman
4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit
c9e6978e2725a7d4b6cd23b2facd3f11422c0643upstream.[...]
Quoted 8 lines
This turns out to cause a regression for nftables user-space versions older than v0.9.3, specifically before:
commit
a4ec053812610400b7a9e6c060d8b7589dedd5b1Author: Pablo Neira Ayuso <[email protected]> Date: Wed Oct 9 11:54:32 2019 +0200segtree: always close interval in non-anonymous sets
This is really fixing up userspace as the commit describes, otherwise incremental updates are not possible on a set/map.
Quoted 2 lines
Should
nft_set_rbtreedetect and fix-up the bad set messages that nftables user-space used to send?
Quoted 7 lines
Problem is that a non-anonymous set really needs close intervals, otherwise incremental updates on it are not possible.
It should be possible to backport a fix for such nftables version.
I can see Debian 10 (Buster, oldoldstable) is using 0.9.0 but it was discontinued in june 2022? But who is using such an old userspace version?
Oh, I misread, it is still supported in oldoldstable in Debian.
Then, userspace really needs this fix, because incremental updates on a set are not really possible.
I can take a look and send a backport of this for nftables 0.9.0.
Re: [PATCH 4.19 164/213] netfilter: nft_set_rbtree: Switch to node list walk for overlap detection
Quoted 30 lines · Pablo Neira Ayuso
Quoted 29 lines · Pablo Neira Ayuso
Quoted 10 lines · Ben Hutchings
Quoted 7 lines · Greg Kroah-Hartman
4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit
c9e6978e2725a7d4b6cd23b2facd3f11422c0643upstream.[...]
Quoted 8 lines
This turns out to cause a regression for nftables user-space versions older than v0.9.3, specifically before:
commit
a4ec053812610400b7a9e6c060d8b7589dedd5b1Author: Pablo Neira Ayuso <[email protected]> Date: Wed Oct 9 11:54:32 2019 +0200segtree: always close interval in non-anonymous sets
This is really fixing up userspace as the commit describes, otherwise incremental updates are not possible on a set/map.
Quoted 2 lines
Should
nft_set_rbtreedetect and fix-up the bad set messages that nftables user-space used to send?Problem is that a non-anonymous set really needs close intervals, otherwise incremental updates on it are not possible.
Quoted 6 lines
Quoted 4 lines
It should be possible to backport a fix for such nftables version.
I can see Debian 10 (Buster, oldoldstable) is using 0.9.0 but it was discontinued in june 2022? But who is using such an old userspace version?
Oh, I misread, it is still supported in oldoldstable in Debian.
It is out of support in Debian from today. But Freexian will maintain a derivative of it (with selective updates, including a newer kernel branch) for some time to come.
Quoted 4 lines
Then, userspace really needs this fix, because incremental updates on a set are not really possible.
I can take a look and send a backport of this for nftables 0.9.0.
Thank you! I already tried cherry-picking just that commit, and that seemed to fix the issue, but I didn't test anything else and I'm not at all familiar with the code.
Ben.
Signature · 3 lines
Ben Hutchings
A free society is one where it is safe to be unpopular.
- Adlai StevensonGreg Kroah-Hartman
maintainerPATCH 165/213 netfilter: nft_set_rbtree: fix null deref on element insertion
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 61ae320a29b0540c16931816299eb86bf2b66c08 upstream.
There is no guarantee that rb_prev() will not return NULL in nft_rbtree_gc_elem():
general protection fault, probably for non-canonical address 0xdffffc0000000003: 0000 [#1] PREEMPT SMP KASAN KASAN: null-ptr-deref in range [0x0000000000000018-0x000000000000001f] nft_add_set_elem+0x14b0/0x2990 nf_tables_newsetelem+0x528/0xb30
Furthermore, there is a possible use-after-free while iterating, 'node' can be free'd so we need to cache the next value to use.
--- net/netfilter/nft_set_rbtree.c | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-)
net/netfilter/nft_set_rbtree.c +13 -7
@@ -223,7 +223,7 @@ static int nft_rbtree_gc_elem(const stru {struct nft_set *set = (struct nft_set *)__set;struct rb_node *prev =rb_prev (&rbe->node); -struct nft_rbtree_elem *rbe_prev; +struct nft_rbtree_elem *rbe_prev =NULL ;struct nft_set_gc_batch *gcb; gcb =nft_set_gc_batch_check (set,NULL ,GFP_ATOMIC );
@@ -231,17 +231,21 @@ static int nft_rbtree_gc_elem(const strureturn -ENOMEM ;/* search for expired end interval coming before this element. */ -do { +while (prev) { rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node);if (nft_rbtree_interval_end (rbe_prev))break ; prev =rb_prev (prev); - }while (prev !=NULL ); + } + +if (rbe_prev) { +rb_erase (&rbe_prev->node, &priv->root); +atomic_dec (&set->nelems); + } -rb_erase (&rbe_prev->node, &priv->root);rb_erase (&rbe->node, &priv->root); -atomic_sub (2 , &set->nelems); +atomic_dec (&set->nelems);nft_set_gc_batch_add (gcb, rbe);nft_set_gc_batch_complete (gcb);
@@ -270,7 +274,7 @@ static int __nft_rbtree_insert(const str struct nft_set_ext **ext) {struct nft_rbtree_elem *rbe, *rbe_le =NULL , *rbe_ge =NULL ; -struct rb_node *node, *parent, **p, *first =NULL ; +struct rb_node *node, *next, *parent, **p, *first =NULL ;struct nft_rbtree *priv =nft_set_priv (set);u8 genmask =nft_genmask_next (net);int d, err;
@@ -309,7 +313,9 @@ static int __nft_rbtree_insert(const str* Values stored in the tree are in reversed order, starting from * highest to lowest value. */ -for (node = first; node !=NULL ; node =rb_next (node)) { +for (node = first; node !=NULL ; node = next) { + next =rb_next (node); + rbe = rb_entry(node, struct nft_rbtree_elem, node);if (!nft_set_elem_active (&rbe->ext, genmask))
Greg Kroah-Hartman
maintainerPATCH 166/213 netfilter: nft_set_rbtree: fix overlap expiration walk
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit f718863aca469a109895cb855e6b81fff4827d71 upstream.
The lazy gc on insert that should remove timed-out entries fails to release the other half of the interval, if any.
Can be reproduced with tests/shell/testcases/sets/0044interval_overlap_0 in nftables.git and kmemleak enabled kernel.
Second bug is the use of rbe_prev vs. prev pointer.
If rbe_prev() returns NULL after at least one iteration, rbe_prev points to element that is not an end interval, hence it should not be removed.
Lastly, check the genmask of the end interval if this is active in the current generation.
--- net/netfilter/nft_set_rbtree.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-)
net/netfilter/nft_set_rbtree.c +14 -6
@@ -219,29 +219,37 @@ static void *nft_rbtree_get(const structstatic int nft_rbtree_gc_elem (const struct nft_set *__set,struct nft_rbtree *priv, -struct nft_rbtree_elem *rbe) +struct nft_rbtree_elem *rbe, +u8 genmask) {struct nft_set *set = (struct nft_set *)__set;struct rb_node *prev =rb_prev (&rbe->node); -struct nft_rbtree_elem *rbe_prev =NULL ; +struct nft_rbtree_elem *rbe_prev;struct nft_set_gc_batch *gcb; gcb =nft_set_gc_batch_check (set,NULL ,GFP_ATOMIC );if (!gcb)return -ENOMEM ; -/* search for expired end interval coming before this element. */ +/* search for end interval coming before this element. +* end intervals don't carry a timeout extension, they +* are coupled with the interval start element. +*/ while (prev) { rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node); -if (nft_rbtree_interval_end (rbe_prev)) +if (nft_rbtree_interval_end (rbe_prev) && +nft_set_elem_active (&rbe_prev->ext, genmask))break ; prev =rb_prev (prev); } -if (rbe_prev) { +if (prev) { + rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node); +rb_erase (&rbe_prev->node, &priv->root);atomic_dec (&set->nelems); +nft_set_gc_batch_add (gcb, rbe_prev); }rb_erase (&rbe->node, &priv->root);
@@ -323,7 +331,7 @@ static int __nft_rbtree_insert(const str/* perform garbage collection to avoid bogus overlap reports. */ if (nft_set_elem_expired (&rbe->ext)) { - err =nft_rbtree_gc_elem (set, priv, rbe); + err =nft_rbtree_gc_elem (set, priv, rbe, genmask);if (err <0 )return err;
Greg Kroah-Hartman
maintainerPATCH 167/213 netfilter: nf_tables: dont skip expired elements during walk
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 24138933b97b055d486e8064b4a1721702442a9b upstream.
There is an asymmetry between commit/abort and preparation phase if the following conditions are met:
1. set is a verdict map ("1.2.3.4 : jump foo")
2. timeouts are enabled
In this case, following sequence is problematic:
1. element E in set S refers to chain C
2. userspace requests removal of set S
3. kernel does a set walk to decrement chain->use count for all elements from preparation phase
4. kernel does another set walk to remove elements from the commit phase (or another walk to do a chain->use increment for all elements from abort phase)
If E has already expired in 1), it will be ignored during list walk, so its use count won't have been changed.
Then, when set is culled, ->destroy callback will zap the element via nf_tables_set_elem_destroy(), but this function is only safe for elements that have been deactivated earlier from the preparation phase:
lack of earlier deactivate removes the element but leaks the chain use count, which results in a WARN splat when the chain gets removed later, plus a leak of the nft_chain structure.
Update pipapo_get() not to skip expired elements, otherwise flush command reports bogus ENOENT errors.
--- net/netfilter/nf_tables_api.c | 4 ++++ net/netfilter/nft_set_hash.c | 2 -- net/netfilter/nft_set_rbtree.c | 2 -- 3 files changed, 4 insertions(+), 4 deletions(-)
net/netfilter/nf_tables_api.c +4 -0
@@ -4159,8 +4159,12 @@ static int nf_tables_dump_setelem(constconst struct nft_set_iter *iter, struct nft_set_elem *elem) { + const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);struct nft_set_dump_args *args; +if (nft_set_elem_expired (ext)) +return 0 ; + args = container_of(iter, struct nft_set_dump_args, iter);return nf_tables_fill_setelem (args->skb, set, elem); }
net/netfilter/nft_set_hash.c +0 -2
@@ -268,8 +268,6 @@ static void nft_rhash_walk(const structif (iter->count < iter->skip) goto cont; -if (nft_set_elem_expired (&he->ext)) - goto cont;if (!nft_set_elem_active (&he->ext, iter->genmask)) goto cont;
net/netfilter/nft_set_rbtree.c +0 -2
@@ -556,8 +556,6 @@ static void nft_rbtree_walk(const structif (iter->count < iter->skip) goto cont; -if (nft_set_elem_expired (&rbe->ext)) - goto cont;if (!nft_set_elem_active (&rbe->ext, iter->genmask)) goto cont;
Greg Kroah-Hartman
maintainerPATCH 168/213 netfilter: nf_tables: GC transaction API to avoid race with control plane
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 5f68718b34a531a556f2f50300ead2862278da26 upstream.
[ this includes
8357bc946a2a ("netfilter: nf_tables: use correct lock to protect gc_list") ]
The set types rhashtable and rbtree use a GC worker to reclaim memory.
Quoted 1 line
From system work queue, in periodic intervals, a scan of the table is
done.
The major caveat here is that the nft transaction mutex is not held. This causes a race between control plane and GC when they attempt to delete the same element.
We cannot grab the netlink mutex from the work queue, because the control plane has to wait for the GC work queue in case the set is to be removed, so we get following deadlock:
cpu 1 cpu2
GC work transaction comes in , lock nft mutex
`acquire nft mutex // BLOCKS
transaction asks to remove the set set destruction calls cancel_work_sync()
cancel_work_sync will now block forever, because it is waiting for the mutex the caller already owns.
This patch adds a new API that deals with garbage collection in two steps:
1) Lockless GC of expired elements sets on the NFT_SET_ELEM_DEAD_BIT so they are not visible via lookup. Annotate current GC sequence in the GC transaction. Enqueue GC transaction work as soon as it is full. If ruleset is updated, then GC transaction is aborted and retried later.
2) GC work grabs the mutex. If GC sequence has changed then this GC transaction lost race with control plane, abort it as it contains stale references to objects and let GC try again later. If the ruleset is intact, then this GC transaction deactivates and removes the elements and it uses call_rcu() to destroy elements.
Note that no elements are removed from GC lockless path, the _DEAD bit is set and pointers are collected. GC catchall does not remove the elements anymore too. There is a new set->dead flag that is set on to abort the GC transaction to deal with set->ops->destroy() path which removes the remaining elements in the set from commit_release, where no mutex is held.
To deal with GC when mutex is held, which allows safe deactivate and removal, add sync GC API which releases the set element object via call_rcu(). This is used by rbtree and pipapo backends which also perform garbage collection from control plane path.
Since element removal from sets can happen from control plane and element garbage collection/timeout, it is necessary to keep the set structure alive until all elements have been deactivated and destroyed.
We cannot do a cancel_work_sync or flush_work in nft_set_destroy because its called with the transaction mutex held, but the aforementioned async work queue might be blocked on the very mutex that nft_set_destroy() callchain is sitting on.
This gives us the choice of ABBA deadlock or UaF.
To avoid both, add set->refs refcount_t member. The GC API can then increment the set refcount and release it once the elements have been free'd.
Set backends are adapted to use the GC transaction API in a follow up patch entitled:
("netfilter: nf_tables: use gc transaction API in set backends")
This is joint work with Florian Westphal.
--- include/net/netfilter/nf_tables.h | 61 ++++++++++ net/netfilter/nf_tables_api.c | 225 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 276 insertions(+), 10 deletions(-)
include/net/netfilter/nf_tables.h +60 -1
@@ -380,6 +380,7 @@ void nft_unregister_set(struct nft_set_t* * @list: table set list node * @bindings: list of set bindings +* @refs: internal refcounting for async set destruction * @table: table this set belongs to * @net: netnamespace this set belongs to * @name: name of the set
@@ -406,6 +407,7 @@ void nft_unregister_set(struct nft_set_tstruct nft_set {struct list_head list;struct list_head bindings; +refcount_t refs;struct nft_table *table;possible_net_t net;char *name;
@@ -424,7 +426,8 @@ struct nft_set {unsigned char *udata;/* runtime data below here */ const struct nft_set_ops *ops____cacheline_aligned ; - u16 flags:14, + u16 flags:13, + dead:1, genmask:2;u8 klen;u8 dlen;
@@ -1346,6 +1349,32 @@ static inline void nft_set_elem_clear_buclear_bit (NFT_SET_ELEM_BUSY_BIT , word); } +#define NFT_SET_ELEM_DEAD_MASK (1 << 3) + +#if defined(__LITTLE_ENDIAN_BITFIELD) +#define NFT_SET_ELEM_DEAD_BIT 3 +#elif defined(__BIG_ENDIAN_BITFIELD) +#define NFT_SET_ELEM_DEAD_BIT (BITS_PER_LONG - BITS_PER_BYTE + 3) +#else +#error +#endif + +static inline void nft_set_elem_dead (struct nft_set_ext *ext) +{ +unsigned long *word = (unsigned long *)ext; + +BUILD_BUG_ON (offsetof(struct nft_set_ext , genmask) !=0 ); +set_bit (NFT_SET_ELEM_DEAD_BIT , word); +} + +static inline int nft_set_elem_is_dead (const struct nft_set_ext *ext) +{ +unsigned long *word = (unsigned long *)ext; + +BUILD_BUG_ON (offsetof(struct nft_set_ext , genmask) !=0 ); +return test_bit (NFT_SET_ELEM_DEAD_BIT , word); +} +/** * struct nft_trans - nf_tables object update in transaction *
@@ -1439,6 +1468,35 @@ struct nft_trans_flowtable {#define nft_trans_flowtable (trans) \ (((struct nft_trans_flowtable *)trans->data)->flowtable) +#define NFT_TRANS_GC_BATCHCOUNT 256 + +struct nft_trans_gc { +struct list_head list; +struct net *net; +struct nft_set *set; +u32 seq; +u8 count; +void *priv[NFT_TRANS_GC_BATCHCOUNT ]; +struct rcu_head rcu; +}; + +struct nft_trans_gc *nft_trans_gc_alloc (struct nft_set *set, +unsigned int gc_seq,gfp_t gfp); +void nft_trans_gc_destroy (struct nft_trans_gc *trans); + +struct nft_trans_gc *nft_trans_gc_queue_async (struct nft_trans_gc *gc, +unsigned int gc_seq,gfp_t gfp); +void nft_trans_gc_queue_async_done (struct nft_trans_gc *gc); + +struct nft_trans_gc *nft_trans_gc_queue_sync (struct nft_trans_gc *gc,gfp_t gfp); +void nft_trans_gc_queue_sync_done (struct nft_trans_gc *trans); + +void nft_trans_gc_elem_add (struct nft_trans_gc *gc,void *priv); + +void nft_setelem_data_deactivate (const struct net *net, +const struct nft_set *set, +struct nft_set_elem *elem); +int __init nft_chain_filter_init (void );void nft_chain_filter_fini (void );
@@ -1451,6 +1509,7 @@ struct nftables_pernet {struct mutex commit_mutex;unsigned int base_seq;u8 validate_state; + unsigned int gc_seq; };#endif /* _NET_NF_TABLES_H */
net/netfilter/nf_tables_api.c +216 -9
328 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 169/213 netfilter: nf_tables: adapt set backend to use GC transaction API
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit f6c383b8c31a93752a52697f8430a71dcbc46adf upstream.
Use the GC transaction API to replace the old and buggy gc API and the busy mark approach.
No set elements are removed from async garbage collection anymore, instead the _DEAD bit is set on so the set element is not visible from lookup path anymore. Async GC enqueues transaction work that might be aborted and retried later.
rbtree and pipapo set backends does not set on the _DEAD bit from the sync GC path since this runs in control plane path where mutex is held. In this case, set elements are deactivated, removed and then released via RCU callback, sync GC never fails.
--- net/netfilter/nft_set_hash.c | 82 +++++++++++++++-------- net/netfilter/nft_set_rbtree.c | 142 +++++++++++++++++++++++++---------------- 2 files changed, 143 insertions(+), 81 deletions(-)
net/netfilter/nft_set_hash.c +53 -29
@@ -20,6 +20,9 @@#include <linux/netfilter.h> #include <linux/netfilter/nf_tables.h> #include <net/netfilter/nf_tables.h> +#include <net/netns/generic.h> + +extern unsigned int nf_tables_net_id;/* We target a hash table size of 4, element hint is 75% of final size */ #define NFT_RHASH_ELEMENT_HINT 3
@@ -62,6 +65,8 @@ static inline int nft_rhash_cmp(struct rif (memcmp (nft_set_ext_key (&he->ext), x->key, x->set->klen))return 1 ; +if (nft_set_elem_is_dead (&he->ext)) +return 1 ;if (nft_set_elem_expired (&he->ext))return 1 ;if (!nft_set_elem_active (&he->ext, x->genmask))
@@ -190,7 +195,6 @@ static void nft_rhash_activate(const strstruct nft_rhash_elem *he = elem->priv;nft_set_elem_change_active (net, set, &he->ext); -nft_set_elem_clear_busy (&he->ext); } static bool nft_rhash_flush(const struct net *net,
@@ -198,12 +202,9 @@ static bool nft_rhash_flush(const struct {struct nft_rhash_elem *he = priv; -if (!nft_set_elem_mark_busy (&he->ext) || - !nft_is_active (net, &he->ext)) { -nft_set_elem_change_active (net, set, &he->ext); -return true; - } -return false; +nft_set_elem_change_active (net, set, &he->ext); + +return true; } static void *nft_rhash_deactivate(const struct net *net,
@@ -220,9 +221,8 @@ static void *nft_rhash_deactivate(constrcu_read_lock (); he =rhashtable_lookup_fast (&priv->ht, &arg, nft_rhash_params); -if (he !=NULL && - !nft_rhash_flush (net, set, he)) - he =NULL ; +if (he) +nft_set_elem_change_active (net, set, &he->ext);rcu_read_unlock ();
@@ -288,55 +288,80 @@ out:static void nft_rhash_gc (struct work_struct *work) { +struct nftables_pernet *nft_net;struct nft_set *set;struct nft_rhash_elem *he;struct nft_rhash *priv; -struct nft_set_gc_batch *gcb =NULL ;struct rhashtable_iter hti; +struct nft_trans_gc *gc; +struct net *net; +u32 gc_seq;int err; priv = container_of(work, struct nft_rhash, gc_work.work); set =nft_set_container_of (priv); + net =read_pnet (&set->net); + nft_net =net_generic (net, nf_tables_net_id); + gc_seq =READ_ONCE (nft_net->gc_seq); + + gc =nft_trans_gc_alloc (set, gc_seq,GFP_KERNEL ); +if (!gc) + goto done; err =rhashtable_walk_init (&priv->ht, &hti,GFP_KERNEL ); -if (err) - goto schedule; +if (err) { +nft_trans_gc_destroy (gc); + goto done; + }rhashtable_walk_start (&hti);while ((he =rhashtable_walk_next (&hti))) {if (IS_ERR (he)) { -if (PTR_ERR (he) != -EAGAIN ) - goto out; +if (PTR_ERR (he) != -EAGAIN ) { +nft_trans_gc_destroy (gc); + gc =NULL ; + goto try_later; + }continue ; } +/* Ruleset has been updated, try later. */ +if (READ_ONCE (nft_net->gc_seq) != gc_seq) { +nft_trans_gc_destroy (gc); + gc =NULL ; + goto try_later; + } + +if (nft_set_elem_is_dead (&he->ext)) + goto dead_elem; +if (nft_set_ext_exists (&he->ext,NFT_SET_EXT_EXPR )) {struct nft_expr *expr =nft_set_ext_expr (&he->ext);if (expr->ops->gc && expr->ops->gc (read_pnet (&set->net), expr)) - goto gc; + goto needs_gc_run; }if (!nft_set_elem_expired (&he->ext))continue ; -gc: -if (nft_set_elem_mark_busy (&he->ext)) -continue ; +needs_gc_run: +nft_set_elem_dead (&he->ext); +dead_elem: + gc =nft_trans_gc_queue_async (gc, gc_seq,GFP_ATOMIC ); +if (!gc) + goto try_later; - gcb =nft_set_gc_batch_check (set, gcb,GFP_ATOMIC ); -if (gcb ==NULL ) - goto out; -rhashtable_remove_fast (&priv->ht, &he->node, nft_rhash_params); -atomic_dec (&set->nelems); -nft_set_gc_batch_add (gcb, he); +nft_trans_gc_elem_add (gc, he); } -out: +try_later:rhashtable_walk_stop (&hti);rhashtable_walk_exit (&hti); -nft_set_gc_batch_complete (gcb); -schedule: +if (gc) +nft_trans_gc_queue_async_done (gc); + +done:queue_delayed_work (system_power_efficient_wq, &priv->gc_work,nft_set_gc_interval (set)); }
@@ -399,7 +424,6 @@ static void nft_rhash_destroy(const stru };cancel_delayed_work_sync (&priv->gc_work); -rcu_barrier ();rhashtable_free_and_destroy (&priv->ht, nft_rhash_elem_destroy, (void *)&rhash_ctx); }
net/netfilter/nft_set_rbtree.c +90 -52
238 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 170/213 netfilter: nf_tables: remove busy mark and gc batch API
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit a2dd0233cbc4d8a0abb5f64487487ffc9265beb5 upstream.
Ditch it, it has been replace it by the GC transaction API and it has no clients anymore.
--- include/net/netfilter/nf_tables.h | 97 +------------------------------------- net/netfilter/nf_tables_api.c | 28 ---------- 2 files changed, 5 insertions(+), 120 deletions(-)
include/net/netfilter/nf_tables.h +3 -94
@@ -652,62 +652,6 @@ void nft_set_elem_destroy(const struct nvoid nf_tables_set_elem_destroy (const struct nft_ctx *ctx,const struct nft_set *set,void *elem); -/** -* struct nft_set_gc_batch_head - nf_tables set garbage collection batch -* -* @rcu: rcu head -* @set: set the elements belong to -* @cnt: count of elements -*/ -struct nft_set_gc_batch_head { -struct rcu_head rcu; -const struct nft_set *set; -unsigned int cnt; -}; - -#define NFT_SET_GC_BATCH_SIZE ((PAGE_SIZE - \ - sizeof(struct nft_set_gc_batch_head)) / \ - sizeof(void *)) - -/** -* struct nft_set_gc_batch - nf_tables set garbage collection batch -* -* @head: GC batch head -* @elems: garbage collection elements -*/ -struct nft_set_gc_batch { -struct nft_set_gc_batch_head head; -void *elems[NFT_SET_GC_BATCH_SIZE ]; -}; - -struct nft_set_gc_batch *nft_set_gc_batch_alloc (const struct nft_set *set, -gfp_t gfp); -void nft_set_gc_batch_release (struct rcu_head *rcu); - -static inline void nft_set_gc_batch_complete (struct nft_set_gc_batch *gcb) -{ -if (gcb !=NULL ) -call_rcu (&gcb->head.rcu, nft_set_gc_batch_release); -} - -static inline struct nft_set_gc_batch * -nft_set_gc_batch_check (const struct nft_set *set,struct nft_set_gc_batch *gcb, -gfp_t gfp) -{ -if (gcb !=NULL ) { -if (gcb->head.cnt +1 <ARRAY_SIZE (gcb->elems)) -return gcb; -nft_set_gc_batch_complete (gcb); - } -return nft_set_gc_batch_alloc (set, gfp); -} - -static inline void nft_set_gc_batch_add (struct nft_set_gc_batch *gcb, -void *elem) -{ - gcb->elems[gcb->head.cnt++] = elem; -} -struct nft_expr_ops ;/** * struct nft_expr_type - nf_tables expression type
@@ -1314,47 +1258,12 @@ static inline void nft_set_elem_change_a ext->genmask ^=nft_genmask_next (net); } -/* -* We use a free bit in the genmask field to indicate the element -* is busy, meaning it is currently being processed either by -* the netlink API or GC. -* -* Even though the genmask is only a single byte wide, this works -* because the extension structure if fully constant once initialized, -* so there are no non-atomic write accesses unless it is already -* marked busy. -*/ -#define NFT_SET_ELEM_BUSY_MASK (1 << 2) - -#if defined(__LITTLE_ENDIAN_BITFIELD) -#define NFT_SET_ELEM_BUSY_BIT 2 -#elif defined(__BIG_ENDIAN_BITFIELD) -#define NFT_SET_ELEM_BUSY_BIT (BITS_PER_LONG - BITS_PER_BYTE + 2) -#else -#error -#endif - -static inline int nft_set_elem_mark_busy (struct nft_set_ext *ext) -{ -unsigned long *word = (unsigned long *)ext; - -BUILD_BUG_ON (offsetof(struct nft_set_ext , genmask) !=0 ); -return test_and_set_bit (NFT_SET_ELEM_BUSY_BIT , word); -} - -static inline void nft_set_elem_clear_busy (struct nft_set_ext *ext) -{ -unsigned long *word = (unsigned long *)ext; - -clear_bit (NFT_SET_ELEM_BUSY_BIT , word); -} - -#define NFT_SET_ELEM_DEAD_MASK (1 << 3) +#define NFT_SET_ELEM_DEAD_MASK (1 << 2)#if defined(__LITTLE_ENDIAN_BITFIELD) -#define NFT_SET_ELEM_DEAD_BIT 3 +#define NFT_SET_ELEM_DEAD_BIT 2#elif defined(__BIG_ENDIAN_BITFIELD) -#define NFT_SET_ELEM_DEAD_BIT (BITS_PER_LONG - BITS_PER_BYTE + 3) +#define NFT_SET_ELEM_DEAD_BIT (BITS_PER_LONG - BITS_PER_BYTE + 2)#else #error #endif
net/netfilter/nf_tables_api.c +2 -26
@@ -4766,7 +4766,8 @@ static int nft_add_set_elem(struct nft_cif (trans ==NULL ) goto err4; - ext->genmask =nft_genmask_cur (ctx->net) |NFT_SET_ELEM_BUSY_MASK ; + ext->genmask =nft_genmask_cur (ctx->net); + err = set->ops->insert (ctx->net, set, &elem, &ext2);if (err) {if (err == -EEXIST ) {
@@ -5059,31 +5060,6 @@ static int nf_tables_delsetelem(struct nreturn err; } -void nft_set_gc_batch_release (struct rcu_head *rcu) -{ -struct nft_set_gc_batch *gcb; -unsigned int i; - - gcb = container_of(rcu, struct nft_set_gc_batch, head.rcu); -for (i =0 ; i < gcb->head.cnt; i++) -nft_set_elem_destroy (gcb->head.set, gcb->elems[i], true); -kfree (gcb); -} -EXPORT_SYMBOL_GPL (nft_set_gc_batch_release); - -struct nft_set_gc_batch *nft_set_gc_batch_alloc (const struct nft_set *set, -gfp_t gfp) -{ -struct nft_set_gc_batch *gcb; - - gcb =kzalloc (sizeof (*gcb), gfp); -if (gcb ==NULL ) -return gcb; - gcb->head.set = set; -return gcb; -} -EXPORT_SYMBOL_GPL (nft_set_gc_batch_alloc); -/* * Stateful objects */
Greg Kroah-Hartman
maintainerPATCH 171/213 netfilter: nf_tables: fix GC transaction races with netns and netlink event exit path
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 6a33d8b73dfac0a41f3877894b38082bd0c9a5bc upstream.
Netlink event path is missing a synchronization point with GC transactions. Add GC sequence number update to netns release path and netlink event path, any GC transaction losing race will be discarded.
--- net/netfilter/nf_tables_api.c | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-)
net/netfilter/nf_tables_api.c +26 -4
@@ -6899,6 +6899,22 @@ void nft_trans_gc_queue_sync_done(struct }EXPORT_SYMBOL_GPL (nft_trans_gc_queue_sync_done); +static unsigned int nft_gc_seq_begin (struct nftables_pernet *nft_net) +{ +unsigned int gc_seq; + +/* Bump gc counter, it becomes odd, this is the busy mark. */ + gc_seq =READ_ONCE (nft_net->gc_seq); +WRITE_ONCE (nft_net->gc_seq, ++gc_seq); + +return gc_seq; +} + +static void nft_gc_seq_end (struct nftables_pernet *nft_net,unsigned int gc_seq) +{ +WRITE_ONCE (nft_net->gc_seq, ++gc_seq); +} +static int nf_tables_commit (struct net *net,struct sk_buff *skb) {struct nftables_pernet *nft_net =net_generic (net, nf_tables_net_id);
@@ -6953,9 +6969,7 @@ static int nf_tables_commit(struct net *while (++nft_net->base_seq ==0 ) ; -/* Bump gc counter, it becomes odd, this is the busy mark. */ - gc_seq =READ_ONCE (nft_net->gc_seq); -WRITE_ONCE (nft_net->gc_seq, ++gc_seq); + gc_seq =nft_gc_seq_begin (nft_net);/* step 3. Start new generation, rules_gen_X now in use. */ net->nft.gencursor =nft_gencursor_next (net);
@@ -7083,7 +7097,7 @@ static int nf_tables_commit(struct net *nf_tables_commit_release (net);nf_tables_gen_notify (net, skb,NFT_MSG_NEWGEN ); -WRITE_ONCE (nft_net->gc_seq, ++gc_seq); +nft_gc_seq_end (nft_net, gc_seq);mutex_unlock (&nft_net->commit_mutex);return 0 ;
@@ -7898,11 +7912,19 @@ static int __net_init nf_tables_init_net static void __net_exit nf_tables_exit_net(struct net *net) {struct nftables_pernet *nft_net =net_generic (net, nf_tables_net_id); +unsigned int gc_seq;mutex_lock (&nft_net->commit_mutex); + + gc_seq =nft_gc_seq_begin (nft_net); +if (!list_empty (&nft_net->commit_list))__nf_tables_abort (net); +__nft_release_tables (net); + +nft_gc_seq_end (nft_net, gc_seq); +mutex_unlock (&nft_net->commit_mutex);WARN_ON_ONCE (!list_empty (&nft_net->tables)); }
Greg Kroah-Hartman
maintainerPATCH 172/213 netfilter: nf_tables: GC transaction race with netns dismantle
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 02c6c24402bf1c1e986899c14ba22a10b510916b upstream.
Use maybe_get_net() since GC workqueue might race with netns exit path.
--- net/netfilter/nf_tables_api.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
net/netfilter/nf_tables_api.c +6 -1
@@ -6820,9 +6820,14 @@ struct nft_trans_gc *nft_trans_gc_alloc(if (!trans)return NULL ; + trans->net =maybe_get_net (net); +if (!trans->net) { +kfree (trans); +return NULL ; + } +refcount_inc (&set->refs); trans->set = set; - trans->net =get_net (net); trans->seq = gc_seq;return trans;
Greg Kroah-Hartman
maintainerPATCH 173/213 netfilter: nf_tables: GC transaction race with abort path
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 720344340fb9be2765bbaab7b292ece0a4570eae upstream.
Abort path is missing a synchronization point with GC transactions. Add GC sequence number hence any GC transaction losing race will be discarded.
--- net/netfilter/nf_tables_api.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
net/netfilter/nf_tables_api.c +6 -1
@@ -7263,7 +7263,12 @@ static int __nf_tables_abort(struct netstatic int nf_tables_abort (struct net *net,struct sk_buff *skb) {struct nftables_pernet *nft_net =net_generic (net, nf_tables_net_id); -int ret =__nf_tables_abort (net); +unsigned int gc_seq; +int ret; + + gc_seq =nft_gc_seq_begin (nft_net); + ret =__nf_tables_abort (net); +nft_gc_seq_end (nft_net, gc_seq);mutex_unlock (&nft_net->commit_mutex);
Greg Kroah-Hartman
maintainerPATCH 174/213 netfilter: nf_tables: defer gc run if previous batch is still pending
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Florian Westphal <[email protected]>
commit 8e51830e29e12670b4c10df070a4ea4c9593e961 upstream.
Don't queue more gc work, else we may queue the same elements multiple times.
If an element is flagged as dead, this can mean that either the previous gc request was invalidated/discarded by a transaction or that the previous request is still pending in the system work queue.
The latter will happen if the gc interval is set to a very low value, e.g. 1ms, and system work queue is backlogged.
The sets refcount is 1 if no previous gc requeusts are queued, so add a helper for this and skip gc run if old requests are pending.
Add a helper for this and skip the gc run in this case.
--- include/net/netfilter/nf_tables.h | 5 +++++ net/netfilter/nft_set_hash.c | 3 +++ net/netfilter/nft_set_rbtree.c | 3 +++ 3 files changed, 11 insertions(+)
include/net/netfilter/nf_tables.h +5 -0
@@ -445,6 +445,11 @@ static inline void *nft_set_priv(const sreturn (void *)set->data; } +static inline bool nft_set_gc_is_pending (const struct nft_set *s) +{ +return refcount_read (&s->refs) !=1 ; +} +static inline struct nft_set *nft_set_container_of (const void *priv) {return (void *)priv - offsetof(struct nft_set , data);
net/netfilter/nft_set_hash.c +3 -0
@@ -304,6 +304,9 @@ static void nft_rhash_gc(struct work_str nft_net =net_generic (net, nf_tables_net_id); gc_seq =READ_ONCE (nft_net->gc_seq); +if (nft_set_gc_is_pending (set)) + goto done; + gc =nft_trans_gc_alloc (set, gc_seq,GFP_KERNEL );if (!gc) goto done;
net/netfilter/nft_set_rbtree.c +3 -0
@@ -618,6 +618,9 @@ static void nft_rbtree_gc(struct work_st nft_net =net_generic (net, nf_tables_net_id); gc_seq =READ_ONCE (nft_net->gc_seq); +if (nft_set_gc_is_pending (set)) + goto done; + gc =nft_trans_gc_alloc (set, gc_seq,GFP_KERNEL );if (!gc) goto done;
Greg Kroah-Hartman
maintainerPATCH 175/213 netfilter: nft_set_rbtree: skip sync GC for new elements in this transaction
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 2ee52ae94baabf7ee09cf2a8d854b990dac5d0e4 upstream.
New elements in this transaction might expired before such transaction ends. Skip sync GC for such elements otherwise commit path might walk over an already released object. Once transaction is finished, async GC will collect such expired element.
--- net/netfilter/nft_set_rbtree.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
net/netfilter/nft_set_rbtree.c +6 -2
@@ -317,6 +317,7 @@ static int __nft_rbtree_insert(const strstruct nft_rbtree_elem *rbe, *rbe_le =NULL , *rbe_ge =NULL ;struct rb_node *node, *next, *parent, **p, *first =NULL ;struct nft_rbtree *priv =nft_set_priv (set); +u8 cur_genmask =nft_genmask_cur (net);u8 genmask =nft_genmask_next (net);int d, err;
@@ -362,8 +363,11 @@ static int __nft_rbtree_insert(const strif (!nft_set_elem_active (&rbe->ext, genmask))continue ; -/* perform garbage collection to avoid bogus overlap reports. */ -if (nft_set_elem_expired (&rbe->ext)) { +/* perform garbage collection to avoid bogus overlap reports +* but skip new elements in this transaction. +*/ +if (nft_set_elem_expired (&rbe->ext) && +nft_set_elem_active (&rbe->ext, cur_genmask)) { err =nft_rbtree_gc_elem (set, priv, rbe, genmask);if (err <0 )return err;
Greg Kroah-Hartman
maintainerPATCH 176/213 netfilter: nft_set_rbtree: use read spinlock to avoid datapath contention
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 96b33300fba880ec0eafcf3d82486f3463b4b6da upstream.
rbtree GC does not modify the datastructure, instead it collects expired elements and it enqueues a GC transaction. Use a read spinlock instead to avoid data contention while GC worker is running.
--- net/netfilter/nft_set_rbtree.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
net/netfilter/nft_set_rbtree.c +2 -4
@@ -629,8 +629,7 @@ static void nft_rbtree_gc(struct work_stif (!gc) goto done; -write_lock_bh (&priv->lock); -write_seqcount_begin (&priv->count); +read_lock_bh (&priv->lock);for (node =rb_first (&priv->root); node !=NULL ; node =rb_next (node)) {/* Ruleset has been updated, try later. */
@@ -679,8 +678,7 @@ dead_elem: } try_later: -write_seqcount_end (&priv->count); -write_unlock_bh (&priv->lock); +read_unlock_bh (&priv->lock);if (gc)nft_trans_gc_queue_async_done (gc);
Greg Kroah-Hartman
maintainerPATCH 177/213 netfilter: nft_set_hash: try later when GC hits EAGAIN on iteration
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit b079155faae94e9b3ab9337e82100a914ebb4e8d upstream.
Skip GC run if iterator rewinds to the beginning with EAGAIN, otherwise GC might collect the same element more than once.
--- net/netfilter/nft_set_hash.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
net/netfilter/nft_set_hash.c +3 -6
@@ -321,12 +321,9 @@ static void nft_rhash_gc(struct work_strwhile ((he =rhashtable_walk_next (&hti))) {if (IS_ERR (he)) { -if (PTR_ERR (he) != -EAGAIN ) { -nft_trans_gc_destroy (gc); - gc =NULL ; - goto try_later; - } -continue ; +nft_trans_gc_destroy (gc); + gc =NULL ; + goto try_later; }/* Ruleset has been updated, try later. */
Greg Kroah-Hartman
maintainerPATCH 178/213 netfilter: nf_tables: fix memleak when more than 255 elements expired
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit cf5000a7787cbc10341091d37245a42c119d26c5 upstream.
When more than 255 elements expired we're supposed to switch to a new gc container structure.
This never happens: u8 type will wrap before reaching the boundary and nft_trans_gc_space() always returns true.
This means we recycle the initial gc container structure and lose track of the elements that came before.
While at it, don't deref 'gc' after we've passed it to call_rcu.
--- include/net/netfilter/nf_tables.h | 2 +- net/netfilter/nf_tables_api.c | 10 ++++++++-- 2 files changed, 9 insertions(+), 3 deletions(-)
include/net/netfilter/nf_tables.h +1 -1
@@ -1389,7 +1389,7 @@ struct nft_trans_gc {struct net *net;struct nft_set *set;u32 seq; -u8 count; +u16 count;void *priv[NFT_TRANS_GC_BATCHCOUNT ];struct rcu_head rcu; };
net/netfilter/nf_tables_api.c +8 -2
@@ -6857,12 +6857,15 @@ static int nft_trans_gc_space(struct nftstruct nft_trans_gc *nft_trans_gc_queue_async (struct nft_trans_gc *gc,unsigned int gc_seq,gfp_t gfp) { +struct nft_set *set; +if (nft_trans_gc_space (gc))return gc; + set = gc->set;nft_trans_gc_queue_work (gc); -return nft_trans_gc_alloc (gc->set, gc_seq, gfp); +return nft_trans_gc_alloc (set, gc_seq, gfp); }EXPORT_SYMBOL_GPL (nft_trans_gc_queue_async);
@@ -6879,15 +6882,18 @@ EXPORT_SYMBOL_GPL(nft_trans_gc_queue_asystruct nft_trans_gc *nft_trans_gc_queue_sync (struct nft_trans_gc *gc,gfp_t gfp) { +struct nft_set *set; +if (WARN_ON_ONCE (!lockdep_commit_lock_is_held (gc->net)))return NULL ;if (nft_trans_gc_space (gc))return gc; + set = gc->set;call_rcu (&gc->rcu, nft_trans_gc_trans_free); -return nft_trans_gc_alloc (gc->set,0 , gfp); +return nft_trans_gc_alloc (set,0 , gfp); }EXPORT_SYMBOL_GPL (nft_trans_gc_queue_sync);
Greg Kroah-Hartman
maintainerPATCH 179/213 netfilter: nf_tables: unregister flowtable hooks on netns exit
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 6069da443bf65f513bb507bb21e2f87cfb1ad0b6 upstream.
Unregister flowtable hooks before they are releases via nf_tables_flowtable_destroy() otherwise hook core reports UAF.
BUG: KASAN: use-after-free in nf_hook_entries_grow+0x5a7/0x700 net/netfilter/core.c:142 net/netfilter/core.c:142 Read of size 4 at addr ffff8880736f7438 by task syz-executor579/3666 CPU: 0 PID: 3666 Comm: syz-executor579 Not tainted 5.16.0-rc5-syzkaller #0 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011 Call Trace: <TASK> __dump_stack lib/dump_stack.c:88 [inline] __dump_stack lib/dump_stack.c:88 [inline] lib/dump_stack.c:106 dump_stack_lvl+0x1dc/0x2d8 lib/dump_stack.c:106 lib/dump_stack.c:106 print_address_description+0x65/0x380 mm/kasan/report.c:247 mm/kasan/report.c:247 __kasan_report mm/kasan/report.c:433 [inline] __kasan_report mm/kasan/report.c:433 [inline] mm/kasan/report.c:450 kasan_report+0x19a/0x1f0 mm/kasan/report.c:450 mm/kasan/report.c:450 nf_hook_entries_grow+0x5a7/0x700 net/netfilter/core.c:142 net/netfilter/core.c:142 __nf_register_net_hook+0x27e/0x8d0 net/netfilter/core.c:429 net/netfilter/core.c:429 nf_register_net_hook+0xaa/0x180 net/netfilter/core.c:571 net/netfilter/core.c:571 nft_register_flowtable_net_hooks+0x3c5/0x730 net/netfilter/nf_tables_api.c:7232 net/netfilter/nf_tables_api.c:7232 nf_tables_newflowtable+0x2022/0x2cf0 net/netfilter/nf_tables_api.c:7430 net/netfilter/nf_tables_api.c:7430 nfnetlink_rcv_batch net/netfilter/nfnetlink.c:513 [inline] nfnetlink_rcv_skb_batch net/netfilter/nfnetlink.c:634 [inline] nfnetlink_rcv_batch net/netfilter/nfnetlink.c:513 [inline] net/netfilter/nfnetlink.c:652 nfnetlink_rcv_skb_batch net/netfilter/nfnetlink.c:634 [inline] net/netfilter/nfnetlink.c:652 nfnetlink_rcv+0x10e6/0x2550 net/netfilter/nfnetlink.c:652 net/netfilter/nfnetlink.c:652
__nft_release_hook() calls nft_unregister_flowtable_net_hooks() which only unregisters the hooks, then after RCU grace period, it is guaranteed that no packets add new entries to the flowtable (no flow offload rules and flowtable hooks are reachable from packet path), so it is safe to call nf_flow_table_free() which cleans up the remaining entries from the flowtable (both software and hardware) and it unbinds the flow_block.
--- net/netfilter/nf_tables_api.c | 2 ++ 1 file changed, 2 insertions(+)
net/netfilter/nf_tables_api.c +2 -0
@@ -7863,6 +7863,8 @@ static void __nft_release_table(struct nlist_for_each_entry (chain, &table->chains, list)nf_tables_unregister_hook (net, table, chain); +list_for_each_entry (flowtable, &table->flowtables, list) +nft_unregister_flowtable_net_hooks (net, flowtable);/* No packets are walking on these chains anymore. */ ctx.table = table;list_for_each_entry (chain, &table->chains, list) {
Greg Kroah-Hartman
maintainerPATCH 180/213 netfilter: nf_tables: double hook unregistration in netns path
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit f9a43007d3f7ba76d5e7f9421094f00f2ef202f8 upstream.
__nft_release_hooks() is called from pre_netns exit path which unregisters the hooks, then the NETDEV_UNREGISTER event is triggered which unregisters the hooks again.
[ 565.221461] WARNING: CPU: 18 PID: 193 at net/netfilter/core.c:495 __nf_unregister_net_hook+0x247/0x270 [...] [ 565.246890] CPU: 18 PID: 193 Comm: kworker/u64:1 Tainted: G E 5.18.0-rc7+ #27 [ 565.253682] Workqueue: netns cleanup_net [ 565.257059] RIP: 0010:__nf_unregister_net_hook+0x247/0x270 [...] [ 565.297120] Call Trace: [ 565.300900] <TASK> [ 565.304683] nf_tables_flowtable_event+0x16a/0x220 [nf_tables] [ 565.308518] raw_notifier_call_chain+0x63/0x80 [ 565.312386] unregister_netdevice_many+0x54f/0xb50
Unregister and destroy netdev hook from netns pre_exit via kfree_rcu so the NETDEV_UNREGISTER path see unregistered hooks.
--- net/netfilter/nf_tables_api.c | 34 +++++++++++++++++++++++++++------- net/netfilter/nft_chain_filter.c | 3 +++ 2 files changed, 30 insertions(+), 7 deletions(-)
net/netfilter/nf_tables_api.c +27 -7
@@ -204,9 +204,10 @@ static int nf_tables_register_hook(strucreturn nf_register_net_hook (net, ops); } -static void nf_tables_unregister_hook (struct net *net, -const struct nft_table *table, -struct nft_chain *chain) +static void __nf_tables_unregister_hook (struct net *net, +const struct nft_table *table, +struct nft_chain *chain, +bool release_netdev) {const struct nft_base_chain *basechain;const struct nf_hook_ops *ops;
@@ -221,6 +222,16 @@ static void nf_tables_unregister_hook(streturn basechain->type->ops_unregister (net, ops);nf_unregister_net_hook (net, ops); +if (release_netdev && + table->family ==NFPROTO_NETDEV ) +nft_base_chain (chain)->ops.dev =NULL ; +} + +static void nf_tables_unregister_hook (struct net *net, +const struct nft_table *table, +struct nft_chain *chain) +{ +__nf_tables_unregister_hook (net, table, chain, false); }static int nft_trans_table_add (struct nft_ctx *ctx,int msg_type)
@@ -5821,8 +5832,9 @@ nft_flowtable_type_get(struct net *net,return ERR_PTR (-ENOENT ); } -static void nft_unregister_flowtable_net_hooks (struct net *net, -struct nft_flowtable *flowtable) +static void __nft_unregister_flowtable_net_hooks (struct net *net, +struct nft_flowtable *flowtable, +bool release_netdev) {int i;
@@ -5831,9 +5843,17 @@ static void nft_unregister_flowtable_netcontinue ;nf_unregister_net_hook (net, &flowtable->ops[i]); +if (release_netdev) + flowtable->ops[i].dev =NULL ; } } +static void nft_unregister_flowtable_net_hooks (struct net *net, +struct nft_flowtable *flowtable) +{ +__nft_unregister_flowtable_net_hooks (net, flowtable, false); +} + static int nf_tables_newflowtable(struct net *net, struct sock *nlsk, struct sk_buff *skb, const struct nlmsghdr *nlh,
@@ -7862,9 +7882,9 @@ static void __nft_release_table(struct n ctx.family = table->family;list_for_each_entry (chain, &table->chains, list) -nf_tables_unregister_hook (net, table, chain); +__nf_tables_unregister_hook (net, table, chain, true);list_for_each_entry (flowtable, &table->flowtables, list) -nft_unregister_flowtable_net_hooks (net, flowtable); +__nft_unregister_flowtable_net_hooks (net, flowtable, true);/* No packets are walking on these chains anymore. */ ctx.table = table;list_for_each_entry (chain, &table->chains, list) {
net/netfilter/nft_chain_filter.c +3 -0
@@ -296,6 +296,9 @@ static void nft_netdev_event(unsigned loif (strcmp (basechain->dev_name, dev->name) !=0 )return ; +if (!basechain->ops.dev) +return ; +/* UNREGISTER events are also happpening on netns exit. * * Altough nf_tables core releases all tables/chains, only
Greg Kroah-Hartman
maintainerPATCH 181/213 netfilter: nftables: update table flags from the commit phase
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 0ce7cf4127f14078ca598ba9700d813178a59409 upstream.
Do not update table flags from the preparation phase. Store the flags update into the transaction, then update the flags from the commit phase.
--- include/net/netfilter/nf_tables.h | 9 ++++++--- net/netfilter/nf_tables_api.c | 31 ++++++++++++++++--------------- 2 files changed, 22 insertions(+), 18 deletions(-)
include/net/netfilter/nf_tables.h +6 -3
@@ -1347,13 +1347,16 @@ struct nft_trans_chain {struct nft_trans_table {bool update; -bool enable; +u8 state; +u32 flags; };#define nft_trans_table_update (trans) \ (((struct nft_trans_table *)trans->data)->update) -#define nft_trans_table_enable (trans) \ - (((struct nft_trans_table *)trans->data)->enable) +#define nft_trans_table_state (trans) \ + (((struct nft_trans_table *)trans->data)->state) +#define nft_trans_table_flags (trans) \ + (((struct nft_trans_table *)trans->data)->flags)struct nft_trans_elem {struct nft_set *set;
net/netfilter/nf_tables_api.c +16 -15
@@ -868,6 +868,12 @@ static void nf_tables_table_disable(strunft_table_disable (net, table,0 ); } +enum { +NFT_TABLE_STATE_UNCHANGED =0 , +NFT_TABLE_STATE_DORMANT , +NFT_TABLE_STATE_WAKEUP +}; +static int nf_tables_updtable (struct nft_ctx *ctx) {struct nft_trans *trans;
@@ -891,19 +897,17 @@ static int nf_tables_updtable(struct nftif ((flags &NFT_TABLE_F_DORMANT ) && !(ctx->table->flags &NFT_TABLE_F_DORMANT )) { -nft_trans_table_enable (trans) = false; +nft_trans_table_state (trans) =NFT_TABLE_STATE_DORMANT ; }else if (!(flags &NFT_TABLE_F_DORMANT ) && ctx->table->flags &NFT_TABLE_F_DORMANT ) { - ctx->table->flags &= ~NFT_TABLE_F_DORMANT ; ret =nf_tables_table_enable (ctx->net, ctx->table);if (ret >=0 ) -nft_trans_table_enable (trans) = true; -else - ctx->table->flags |=NFT_TABLE_F_DORMANT ; +nft_trans_table_state (trans) =NFT_TABLE_STATE_WAKEUP ; }if (ret <0 ) goto err; +nft_trans_table_flags (trans) = flags;nft_trans_table_update (trans) = true;nft_trans_commit_list_add_tail (ctx->net, trans);return 0 ;
@@ -7009,11 +7013,10 @@ static int nf_tables_commit(struct net *switch (trans->msg_type) {case NFT_MSG_NEWTABLE :if (nft_trans_table_update (trans)) { -if (!nft_trans_table_enable (trans)) { -nf_tables_table_disable (net, - trans->ctx.table); - trans->ctx.table->flags |=NFT_TABLE_F_DORMANT ; - } +if (nft_trans_table_state (trans) ==NFT_TABLE_STATE_DORMANT ) +nf_tables_table_disable (net, trans->ctx.table); + + trans->ctx.table->flags =nft_trans_table_flags (trans); }else {nft_clear (net, trans->ctx.table); }
@@ -7174,11 +7177,9 @@ static int __nf_tables_abort(struct netswitch (trans->msg_type) {case NFT_MSG_NEWTABLE :if (nft_trans_table_update (trans)) { -if (nft_trans_table_enable (trans)) { -nf_tables_table_disable (net, - trans->ctx.table); - trans->ctx.table->flags |=NFT_TABLE_F_DORMANT ; - } +if (nft_trans_table_state (trans) ==NFT_TABLE_STATE_WAKEUP ) +nf_tables_table_disable (net, trans->ctx.table); +nft_trans_destroy (trans); }else {list_del_rcu (&trans->ctx.table->list);
Greg Kroah-Hartman
maintainerPATCH 182/213 netfilter: nf_tables: fix table flag updates
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 179d9ba5559a756f4322583388b3213fe4e391b0 upstream.
The dormant flag need to be updated from the preparation phase, otherwise, two consecutive requests to dorm a table in the same batch might try to remove the same hooks twice, resulting in the following warning:
hook not found, pf 3 num 0
WARNING: CPU: 0 PID: 334 at net/netfilter/core.c:480 __nf_unregister_net_hook+0x1eb/0x610 net/netfilter/core.c:480 Modules linked in: CPU: 0 PID: 334 Comm: kworker/u4:5 Not tainted 5.12.0-syzkaller #0 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011 Workqueue: netns cleanup_net RIP: 0010:__nf_unregister_net_hook+0x1eb/0x610 net/netfilter/core.c:480
This patch is a partial revert of 0ce7cf4127f1 ("netfilter: nftables:
update table flags from the commit phase") to restore the previous behaviour.
However, there is still another problem: A batch containing a series of dorm-wakeup-dorm table and vice-versa also trigger the warning above since hook unregistration happens from the preparation phase, while hook registration occurs from the commit phase.
To fix this problem, this patch adds two internal flags to annotate the original dormant flag status which are __NFT_TABLE_F_WAS_DORMANT and __NFT_TABLE_F_WAS_AWAKEN, to restore it from the abort path.
The __NFT_TABLE_F_UPDATE bitmask allows to handle the dormant flag update with one single transaction.
--- include/net/netfilter/nf_tables.h | 6 --- include/uapi/linux/netfilter/nf_tables.h | 1 net/netfilter/nf_tables_api.c | 59 +++++++++++++++++++++---------- 3 files changed, 41 insertions(+), 25 deletions(-)
include/net/netfilter/nf_tables.h +0 -6
@@ -1347,16 +1347,10 @@ struct nft_trans_chain {struct nft_trans_table {bool update; -u8 state; -u32 flags; };#define nft_trans_table_update (trans) \ (((struct nft_trans_table *)trans->data)->update) -#define nft_trans_table_state (trans) \ - (((struct nft_trans_table *)trans->data)->state) -#define nft_trans_table_flags (trans) \ - (((struct nft_trans_table *)trans->data)->flags)struct nft_trans_elem {struct nft_set *set;
include/uapi/linux/netfilter/nf_tables.h +1 -0
@@ -162,6 +162,7 @@ enum nft_hook_attributes {enum nft_table_flags {NFT_TABLE_F_DORMANT =0x1 , }; +#define NFT_TABLE_F_MASK (NFT_TABLE_F_DORMANT)/** * enum nft_table_attributes - nf_tables table netlink attributes
net/netfilter/nf_tables_api.c +40 -19
107 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 183/213 netfilter: nf_tables: disable toggling dormant table state more than once
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit c9bd26513b3a11b3adb3c2ed8a31a01a87173ff1 upstream.
nft -f -<<EOF
add table ip t
add table ip t { flags dormant; }
add chain ip t c { type filter hook input priority 0; } add table ip t
EOF
Triggers a splat from nf core on next table delete because we lose track of right hook register state:
WARNING: CPU: 2 PID: 1597 at net/netfilter/core.c:501 __nf_unregister_net_hook RIP: 0010:__nf_unregister_net_hook+0x41b/0x570 nf_unregister_net_hook+0xb4/0xf0 __nf_tables_unregister_hook+0x160/0x1d0
[..]
The above should have table in *active* state, but in fact no hooks were registered.
Reject on/off/on games rather than attempting to fix this.
--- net/netfilter/nf_tables_api.c | 4 ++++ 1 file changed, 4 insertions(+)
net/netfilter/nf_tables_api.c +4 -0
@@ -893,6 +893,10 @@ static int nf_tables_updtable(struct nftif (flags == ctx->table->flags)return 0 ; +/* No dormant off/on/off/on games in single transaction */ +if (ctx->table->flags & __NFT_TABLE_F_UPDATE) +return -EINVAL ; + trans =nft_trans_alloc (ctx,NFT_MSG_NEWTABLE ,sizeof (struct nft_trans_table ));if (trans ==NULL )
Greg Kroah-Hartman
maintainerPATCH 184/213 netfilter: nf_tables: bogus EBUSY when deleting flowtable after flush (for 4.19)
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
3f0465a9ef02 ("netfilter: nf_tables: dynamically allocate hooks per net_device in flowtables") reworks flowtable support to allow for dynamic allocation of hooks, which implicitly fixes the following bogus EBUSY in transaction:
delete flowtable
add flowtable # same flowtable with same devices, it hits EBUSY
This patch does not exist in any tree, but it fixes this issue for -stable Linux kernel 4.19
--- net/netfilter/nf_tables_api.c | 3 +++ 1 file changed, 3 insertions(+)
net/netfilter/nf_tables_api.c +3 -0
@@ -5956,6 +5956,9 @@ static int nf_tables_newflowtable(structcontinue ;list_for_each_entry (ft, &table->flowtables, list) { +if (!nft_is_active_next (net, ft)) +continue ; +for (k =0 ; k < ft->ops_len; k++) {if (!ft->ops[k].dev)continue ;
Greg Kroah-Hartman
maintainerPATCH 185/213 netfilter: nft_dynset: fix timeouts later than 23 days
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 917d80d376ffbaa9725fde9e3c0282f63643f278 upstream.
Use nf_msecs_to_jiffies64 and nf_jiffies64_to_msecs as provided by 8e1102d5a159 ("netfilter: nf_tables: support timeouts larger than 23 days"), otherwise ruleset listing breaks.
--- include/net/netfilter/nf_tables.h | 3 +++ net/netfilter/nf_tables_api.c | 4 ++-- net/netfilter/nft_dynset.c | 8 +++++--- 3 files changed, 10 insertions(+), 5 deletions(-)
include/net/netfilter/nf_tables.h +3 -0
@@ -1423,4 +1423,7 @@ struct nftables_pernet { unsigned int gc_seq; }; +int nf_msecs_to_jiffies64 (const struct nlattr *nla,u64 *result); +__be64 nf_jiffies64_to_msecs (u64 input); +#endif /* _NET_NF_TABLES_H */
net/netfilter/nf_tables_api.c +2 -2
@@ -3294,7 +3294,7 @@ cont:return 0 ; } -static int nf_msecs_to_jiffies64 (const struct nlattr *nla,u64 *result) +int nf_msecs_to_jiffies64 (const struct nlattr *nla,u64 *result) {u64 ms =be64_to_cpu (nla_get_be64 (nla));u64 max = (u64)(~((u64 )0 ));
@@ -3308,7 +3308,7 @@ static int nf_msecs_to_jiffies64(const sreturn 0 ; } -static __be64 nf_jiffies64_to_msecs (u64 input) +__be64 nf_jiffies64_to_msecs (u64 input) {u64 ms =jiffies64_to_nsecs (input);
net/netfilter/nft_dynset.c +5 -3
@@ -169,8 +169,10 @@ static int nft_dynset_init(const structif (tb[NFTA_DYNSET_TIMEOUT ] !=NULL ) {if (!(set->flags &NFT_SET_TIMEOUT ))return -EINVAL ; - timeout =msecs_to_jiffies (be64_to_cpu (nla_get_be64 ( - tb[NFTA_DYNSET_TIMEOUT ]))); + + err =nf_msecs_to_jiffies64 (tb[NFTA_DYNSET_TIMEOUT ], &timeout); +if (err) +return err; } err = nft_parse_register_load(tb[NFTA_DYNSET_SREG_KEY], &priv->sreg_key,
@@ -284,7 +286,7 @@ static int nft_dynset_dump(struct sk_bufif (nla_put_string (skb,NFTA_DYNSET_SET_NAME , priv->set->name)) goto nla_put_failure;if (nla_put_be64 (skb,NFTA_DYNSET_TIMEOUT , -cpu_to_be64 (jiffies_to_msecs (priv->timeout)), +nf_jiffies64_to_msecs (priv->timeout),NFTA_DYNSET_PAD )) goto nla_put_failure;if (priv->expr &&nft_expr_dump (skb,NFTA_DYNSET_EXPR , priv->expr))
Greg Kroah-Hartman
maintainerPATCH 186/213 netfilter: nftables: exthdr: fix 4-byte stack OOB write
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Florian Westphal <[email protected]>
commit fd94d9dadee58e09b49075240fe83423eb1dcd36 upstream.
If priv->len is a multiple of 4, then dst[len / 4] can write past the destination array which leads to stack corruption.
This construct is necessary to clean the remainder of the register in case ->len is NOT a multiple of the register size, so make it conditional just like nft_payload.c does.
The bug was added in 4.1 cycle and then copied/inherited when tcp/sctp and ip option support was added.
Bug reported by Zero Day Initiative project (ZDI-CAN-21950, ZDI-CAN-21951, ZDI-CAN-21961).
--- net/netfilter/nft_exthdr.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-)
net/netfilter/nft_exthdr.c +11 -3
@@ -36,6 +36,14 @@ static unsigned int optlen(const u8 *optreturn opt[offset +1 ]; } +static int nft_skb_copy_to_reg (const struct sk_buff *skb,int offset,u32 *dest,unsigned int len) +{ +if (len %NFT_REG32_SIZE ) + dest[len /NFT_REG32_SIZE ] =0 ; + +return skb_copy_bits (skb, offset, dest, len); +} +static void nft_exthdr_ipv6_eval (const struct nft_expr *expr,struct nft_regs *regs,const struct nft_pktinfo *pkt)
@@ -57,8 +65,7 @@ static void nft_exthdr_ipv6_eval(const s } offset += priv->offset; - dest[priv->len /NFT_REG32_SIZE ] =0 ; -if (skb_copy_bits (pkt->skb, offset, dest, priv->len) <0 ) +if (nft_skb_copy_to_reg (pkt->skb, offset, dest, priv->len) <0 ) goto err;return ; err:
@@ -114,7 +121,8 @@ static void nft_exthdr_tcp_eval(const stif (priv->flags &NFT_EXTHDR_F_PRESENT ) { *dest =1 ; }else { - dest[priv->len /NFT_REG32_SIZE ] =0 ; +if (priv->len %NFT_REG32_SIZE ) + dest[priv->len /NFT_REG32_SIZE ] =0 ;memcpy (dest, opt + offset, priv->len); }
Greg Kroah-Hartman
maintainerPATCH 187/213 netfilter: nft_dynset: report EOPNOTSUPP on missing set feature
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 95cd4bca7b1f4a25810f3ddfc5e767fb46931789 upstream.
If userspace requests a feature which is not available the original set definition, then bail out with EOPNOTSUPP. If userspace sends unsupported dynset flags (new feature not supported by this kernel), then report EOPNOTSUPP to userspace. EINVAL should be only used to report malformed netlink messages from userspace.
--- net/netfilter/nft_dynset.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
net/netfilter/nft_dynset.c +3 -3
@@ -133,7 +133,7 @@ static int nft_dynset_init(const structu32 flags =ntohl (nla_get_be32 (tb[NFTA_DYNSET_FLAGS ]));if (flags & ~NFT_DYNSET_F_INV ) -return -EINVAL ; +return -EOPNOTSUPP ;if (flags &NFT_DYNSET_F_INV ) priv->invert = true; }
@@ -168,7 +168,7 @@ static int nft_dynset_init(const struct timeout =0 ;if (tb[NFTA_DYNSET_TIMEOUT ] !=NULL ) {if (!(set->flags &NFT_SET_TIMEOUT )) -return -EINVAL ; +return -EOPNOTSUPP ; err =nf_msecs_to_jiffies64 (tb[NFTA_DYNSET_TIMEOUT ], &timeout);if (err)
@@ -182,7 +182,7 @@ static int nft_dynset_init(const structif (tb[NFTA_DYNSET_SREG_DATA ] !=NULL ) {if (!(set->flags &NFT_SET_MAP )) -return -EINVAL ; +return -EOPNOTSUPP ;if (set->dtype ==NFT_DATA_VERDICT )return -EOPNOTSUPP ;
Greg Kroah-Hartman
maintainerPATCH 188/213 netfilter: nft_dynset: relax superfluous check on set updates
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 7b1394892de8d95748d05e3ee41e85edb4abbfa1 upstream.
Relax this condition to make add and update commands idempotent for sets with no timeout. The eval function already checks if the set element timeout is available and updates it if the update command is used.
--- net/netfilter/nft_dynset.c | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-)
net/netfilter/nft_dynset.c +1 -9
@@ -154,16 +154,8 @@ static int nft_dynset_init(const structreturn -EBUSY ; priv->op =ntohl (nla_get_be32 (tb[NFTA_DYNSET_OP ])); -switch (priv->op) { -case NFT_DYNSET_OP_ADD : -break ; -case NFT_DYNSET_OP_UPDATE : -if (!(set->flags &NFT_SET_TIMEOUT )) -return -EOPNOTSUPP ; -break ; -default : +if (priv->op >NFT_DYNSET_OP_UPDATE )return -EOPNOTSUPP ; - } timeout =0 ;if (tb[NFTA_DYNSET_TIMEOUT ] !=NULL ) {
Greg Kroah-Hartman
maintainerPATCH 189/213 netfilter: nf_tables: mark newset as dead on transaction abort
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Florian Westphal <[email protected]>
[ Upstream commit 08e4c8c5919fd405a4d709b4ba43d836894a26eb ]
If a transaction is aborted, we should mark the to-be-released NEWSET dead, just like commit path does for DEL and DESTROYSET commands.
In both cases all remaining elements will be released via set->ops->destroy().
The existing abort code does NOT post the actual release to the work queue. Also the entire __nf_tables_abort() function is wrapped in gc_seq begin/end pair.
Therefore, async gc worker will never try to release the pending set elements, as gc sequence is always stale.
It might be possible to speed up transaction aborts via work queue too, this would result in a race and a possible use-after-free.
So fix this before it becomes an issue.
--- net/netfilter/nf_tables_api.c | 1 + 1 file changed, 1 insertion(+)
net/netfilter/nf_tables_api.c +1 -0
@@ -7254,6 +7254,7 @@ static int __nf_tables_abort(struct netnft_trans_destroy (trans);break ; } +nft_trans_set (trans)->dead =1 ;list_del_rcu (&nft_trans_set (trans)->list);break ;case NFT_MSG_DELSET :
Greg Kroah-Hartman
maintainerPATCH 190/213 netfilter: nf_tables: skip dead set elements in netlink dump
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
[ Upstream commit 6b1ca88e4bb63673dc9f9c7f23c899f22c3cb17a ]
Delete from packet path relies on the garbage collector to purge elements with NFT_SET_ELEM_DEAD_BIT on.
Skip these dead elements from nf_tables_dump_setelem() path, I very rarely see tests/shell/testcases/maps/typeof_maps_add_delete reports [DUMP FAILED] showing a mismatch in the expected output with an element that should not be there.
If the netlink dump happens before GC worker run, it might show dead elements in the ruleset listing.
nft_rhash_get() already skips dead elements in nft_rhash_cmp(), therefore, it already does not show the element when getting a single element via netlink control plane.
--- net/netfilter/nf_tables_api.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/netfilter/nf_tables_api.c +1 -1
@@ -4200,7 +4200,7 @@ static int nf_tables_dump_setelem(constconst struct nft_set_ext *ext =nft_set_elem_ext (set, elem->priv);struct nft_set_dump_args *args; -if (nft_set_elem_expired (ext)) +if (nft_set_elem_expired (ext) ||nft_set_elem_is_dead (ext))return 0 ; args = container_of(iter, struct nft_set_dump_args, iter);
Greg Kroah-Hartman
maintainerPATCH 191/213 netfilter: nf_tables: validate NFPROTO_* family
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
[ Upstream commit d0009effa8862c20a13af4cb7475d9771b905693 ]
Several expressions explicitly refer to NF_INET_* hook definitions from expr->ops->validate, however, family is not validated.
Bail out with EOPNOTSUPP in case they are used from unsupported families.
--- net/netfilter/nft_compat.c | 12 ++++++++++++ net/netfilter/nft_flow_offload.c | 5 +++++ net/netfilter/nft_nat.c | 5 +++++ net/netfilter/nft_rt.c | 5 +++++ net/netfilter/nft_socket.c | 5 +++++ net/netfilter/nft_tproxy.c | 5 +++++ 6 files changed, 37 insertions(+)
net/netfilter/nft_compat.c +12 -0
@@ -319,6 +319,12 @@ static int nft_target_validate(const strunsigned int hook_mask =0 ;int ret; +if (ctx->family !=NFPROTO_IPV4 && + ctx->family !=NFPROTO_IPV6 && + ctx->family !=NFPROTO_BRIDGE && + ctx->family !=NFPROTO_ARP ) +return -EOPNOTSUPP ; +if (nft_is_base_chain (ctx->chain)) {const struct nft_base_chain *basechain =nft_base_chain (ctx->chain);
@@ -560,6 +566,12 @@ static int nft_match_validate(const struunsigned int hook_mask =0 ;int ret; +if (ctx->family !=NFPROTO_IPV4 && + ctx->family !=NFPROTO_IPV6 && + ctx->family !=NFPROTO_BRIDGE && + ctx->family !=NFPROTO_ARP ) +return -EOPNOTSUPP ; +if (nft_is_base_chain (ctx->chain)) {const struct nft_base_chain *basechain =nft_base_chain (ctx->chain);
net/netfilter/nft_flow_offload.c +5 -0
@@ -145,6 +145,11 @@ static int nft_flow_offload_validate(con {unsigned int hook_mask = (1 <<NF_INET_FORWARD ); +if (ctx->family !=NFPROTO_IPV4 && + ctx->family !=NFPROTO_IPV6 && + ctx->family !=NFPROTO_INET ) +return -EOPNOTSUPP ; +return nft_chain_validate_hooks (ctx->chain, hook_mask); }
net/netfilter/nft_nat.c +5 -0
@@ -94,6 +94,11 @@ static int nft_nat_validate(const structstruct nft_nat *priv =nft_expr_priv (expr);int err; +if (ctx->family !=NFPROTO_IPV4 && + ctx->family !=NFPROTO_IPV6 && + ctx->family !=NFPROTO_INET ) +return -EOPNOTSUPP ; + err =nft_chain_validate_dependency (ctx->chain,NFT_CHAIN_T_NAT );if (err <0 )return err;
net/netfilter/nft_rt.c +5 -0
@@ -159,6 +159,11 @@ static int nft_rt_validate(const structconst struct nft_rt *priv =nft_expr_priv (expr);unsigned int hooks; +if (ctx->family !=NFPROTO_IPV4 && + ctx->family !=NFPROTO_IPV6 && + ctx->family !=NFPROTO_INET ) +return -EOPNOTSUPP ; +switch (priv->key) {case NFT_RT_NEXTHOP4 :case NFT_RT_NEXTHOP6 :
net/netfilter/nft_socket.c +5 -0
@@ -139,6 +139,11 @@ static int nft_socket_validate(const strconst struct nft_expr *expr, const struct nft_data **data) { + if (ctx->family != NFPROTO_IPV4 && + ctx->family != NFPROTO_IPV6 && + ctx->family != NFPROTO_INET) + return -EOPNOTSUPP; + return nft_chain_validate_hooks(ctx->chain, (1 << NF_INET_PRE_ROUTING) | (1 << NF_INET_LOCAL_IN) |
net/netfilter/nft_tproxy.c +5 -0
@@ -293,6 +293,11 @@ static int nft_tproxy_validate(const strconst struct nft_expr *expr, const struct nft_data **data) { + if (ctx->family != NFPROTO_IPV4 && + ctx->family != NFPROTO_IPV6 && + ctx->family != NFPROTO_INET) + return -EOPNOTSUPP; + return nft_chain_validate_hooks(ctx->chain, 1 << NF_INET_PRE_ROUTING); }
Greg Kroah-Hartman
maintainerPATCH 192/213 netfilter: nft_set_rbtree: skip end interval element from gc
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 60c0c230c6f046da536d3df8b39a20b9a9fd6af0 upstream.
rbtree lazy gc on insert might collect an end interval element that has been just added in this transactions, skip end interval elements that are not yet active.
--- net/netfilter/nft_set_rbtree.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
net/netfilter/nft_set_rbtree.c +3 -4
@@ -240,8 +240,7 @@ static void nft_rbtree_gc_remove(structstatic int nft_rbtree_gc_elem (const struct nft_set *__set,struct nft_rbtree *priv, -struct nft_rbtree_elem *rbe, -u8 genmask) +struct nft_rbtree_elem *rbe) {struct nft_set *set = (struct nft_set *)__set;struct rb_node *prev =rb_prev (&rbe->node);
@@ -260,7 +259,7 @@ static int nft_rbtree_gc_elem(const struwhile (prev) { rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node);if (nft_rbtree_interval_end (rbe_prev) && -nft_set_elem_active (&rbe_prev->ext, genmask)) +nft_set_elem_active (&rbe_prev->ext,NFT_GENMASK_ANY ))break ; prev =rb_prev (prev);
@@ -368,7 +367,7 @@ static int __nft_rbtree_insert(const str*/ if (nft_set_elem_expired (&rbe->ext) &&nft_set_elem_active (&rbe->ext, cur_genmask)) { - err =nft_rbtree_gc_elem (set, priv, rbe, genmask); + err =nft_rbtree_gc_elem (set, priv, rbe);if (err <0 )return err;
Greg Kroah-Hartman
maintainerPATCH 193/213 netfilter: nf_tables: set dormant flag on hook register failure
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Florian Westphal <[email protected]>
[ Upstream commit bccebf64701735533c8db37773eeacc6566cc8ec ]
We need to set the dormant flag again if we fail to register the hooks.
During memory pressure hook registration can fail and we end up with a table marked as active but no registered hooks.
On table/base chain deletion, nf_tables will attempt to unregister the hook again which yields a warn splat from the nftables core.
--- net/netfilter/nf_tables_api.c | 1 + 1 file changed, 1 insertion(+)
net/netfilter/nf_tables_api.c +1 -0
@@ -925,6 +925,7 @@ static int nf_tables_updtable(struct nftreturn 0 ; err_register_hooks: + ctx->table->flags |=NFT_TABLE_F_DORMANT ;nft_trans_destroy (trans);return ret; }
Greg Kroah-Hartman
maintainerPATCH 194/213 netfilter: nf_tables: allow NFPROTO_INET in nft_(match/target)_validate()
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ignat Korchagin <[email protected]>
[ Upstream commit 7e0f122c65912740327e4c54472acaa5f85868cb ]
Commit d0009effa886 ("netfilter: nf_tables: validate NFPROTO_* family") added some validation of NFPROTO_* families in the nft_compat module, but it broke the ability to use legacy iptables modules in dual-stack nftables.
While with legacy iptables one had to independently manage IPv4 and IPv6 tables, with nftables it is possible to have dual-stack tables sharing the rules. Moreover, it was possible to use rules based on legacy iptables match/target modules in dual-stack nftables.
As an example, the program from [2] creates an INET dual-stack family table using an xt_bpf based rule, which looks like the following (the actual output was generated with a patched nft tool as the current nft tool does not parse dual stack tables with legacy match rules, so consider it for illustrative purposes only):
table inet testfw {
chain input {
type filter hook prerouting priority filter; policy accept; bytecode counter packets 0 bytes 0 accept
}
}
After d0009effa886 ("netfilter: nf_tables: validate NFPROTO_* family") we get EOPNOTSUPP for the above program.
Fix this by allowing NFPROTO_INET for nft_(match/target)_validate(), but also restrict the functions to classic iptables hooks.
Changes in v3:
* clarify that upstream nft will not display such configuration properly and that the output was generated with a patched nft tool
* remove example program from commit description and link to it instead
* no code changes otherwise
Changes in v2:
* restrict nft_(match/target)_validate() to classic iptables hooks
* rewrite example program to use unmodified libnftnl
--- net/netfilter/nft_compat.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+)
net/netfilter/nft_compat.c +20 -0
@@ -321,10 +321,20 @@ static int nft_target_validate(const strif (ctx->family !=NFPROTO_IPV4 && ctx->family !=NFPROTO_IPV6 && + ctx->family !=NFPROTO_INET && ctx->family !=NFPROTO_BRIDGE && ctx->family !=NFPROTO_ARP )return -EOPNOTSUPP ; + ret =nft_chain_validate_hooks (ctx->chain, + (1 <<NF_INET_PRE_ROUTING ) | + (1 <<NF_INET_LOCAL_IN ) | + (1 <<NF_INET_FORWARD ) | + (1 <<NF_INET_LOCAL_OUT ) | + (1 <<NF_INET_POST_ROUTING )); +if (ret) +return ret; +if (nft_is_base_chain (ctx->chain)) {const struct nft_base_chain *basechain =nft_base_chain (ctx->chain);
@@ -568,10 +578,20 @@ static int nft_match_validate(const struif (ctx->family !=NFPROTO_IPV4 && ctx->family !=NFPROTO_IPV6 && + ctx->family !=NFPROTO_INET && ctx->family !=NFPROTO_BRIDGE && ctx->family !=NFPROTO_ARP )return -EOPNOTSUPP ; + ret =nft_chain_validate_hooks (ctx->chain, + (1 <<NF_INET_PRE_ROUTING ) | + (1 <<NF_INET_LOCAL_IN ) | + (1 <<NF_INET_FORWARD ) | + (1 <<NF_INET_LOCAL_OUT ) | + (1 <<NF_INET_POST_ROUTING )); +if (ret) +return ret; +if (nft_is_base_chain (ctx->chain)) {const struct nft_base_chain *basechain =nft_base_chain (ctx->chain);
Greg Kroah-Hartman
maintainerPATCH 195/213 netfilter: nf_tables: do not compare internal table flags on updates
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
[ Upstream commit 4a0e7f2decbf9bd72461226f1f5f7dcc4b08f139 ]
Restore skipping transaction if table update does not modify flags.
--- net/netfilter/nf_tables_api.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/netfilter/nf_tables_api.c +1 -1
@@ -890,7 +890,7 @@ static int nf_tables_updtable(struct nftif (flags & ~NFT_TABLE_F_DORMANT )return -EINVAL ; -if (flags == ctx->table->flags) +if (flags == (ctx->table->flags &NFT_TABLE_F_MASK ))return 0 ;/* No dormant off/on/off/on games in single transaction */
Greg Kroah-Hartman
maintainerPATCH 196/213 netfilter: nf_tables: mark set as dead when unbinding anonymous set with timeout
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 552705a3650bbf46a22b1adedc1b04181490fc36 upstream.
While the rhashtable set gc runs asynchronously, a race allows it to collect elements from anonymous sets with timeouts while it is being released from the commit path.
Mingi Cho originally reported this issue in a different path in 6.1.x with a pipapo set with low timeouts which is not possible upstream since 7395dfacfff6 ("netfilter: nf_tables: use timestamp to check for set element timeout").
Fix this by setting on the dead flag for anonymous sets to skip async gc in this case.
According to 08e4c8c5919f ("netfilter: nf_tables: mark newset as dead on transaction abort"), Florian plans to accelerate abort path by releasing objects via workqueue, therefore, this sets on the dead flag for abort path too.
--- net/netfilter/nf_tables_api.c | 1 + 1 file changed, 1 insertion(+)
net/netfilter/nf_tables_api.c +1 -0
@@ -3943,6 +3943,7 @@ void nf_tables_unbind_set(const struct nif (list_empty (&set->bindings) &&nft_set_is_anonymous (set)) {list_del_rcu (&set->list); + set->dead =1 ;if (event)nf_tables_set_notify (ctx, set,NFT_MSG_DELSET ,GFP_KERNEL );
Greg Kroah-Hartman
maintainerPATCH 197/213 netfilter: nf_tables: reject new basechain after table flag update
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 994209ddf4f430946f6247616b2e33d179243769 upstream.
When dormant flag is toggled, hooks are disabled in the commit phase by iterating over current chains in table (existing and new).
The following configuration allows for an inconsistent state:
add table x
add chain x y { type filter hook input priority 0; } add table x { flags dormant; }
add chain x w { type filter hook input priority 1; }
which triggers the following warning when trying to unregister chain w which is already unregistered.
[ 127.322252] WARNING: CPU: 7 PID: 1211 at net/netfilter/core.c:50 1 __nf_unregister_net_hook+0x21a/0x260 [...] [ 127.322519] Call Trace: [ 127.322521] <TASK> [ 127.322524] ? __warn+0x9f/0x1a0 [ 127.322531] ? __nf_unregister_net_hook+0x21a/0x260 [ 127.322537] ? report_bug+0x1b1/0x1e0 [ 127.322545] ? handle_bug+0x3c/0x70 [ 127.322552] ? exc_invalid_op+0x17/0x40 [ 127.322556] ? asm_exc_invalid_op+0x1a/0x20 [ 127.322563] ? kasan_save_free_info+0x3b/0x60 [ 127.322570] ? __nf_unregister_net_hook+0x6a/0x260 [ 127.322577] ? __nf_unregister_net_hook+0x21a/0x260 [ 127.322583] ? __nf_unregister_net_hook+0x6a/0x260 [ 127.322590] ? __nf_tables_unregister_hook+0x8a/0xe0 [nf_tables] [ 127.322655] nft_table_disable+0x75/0xf0 [nf_tables] [ 127.322717] nf_tables_commit+0x2571/0x2620 [nf_tables]
--- net/netfilter/nf_tables_api.c | 3 +++ 1 file changed, 3 insertions(+)
net/netfilter/nf_tables_api.c +3 -0
@@ -1750,6 +1750,9 @@ static int nf_tables_addchain(struct nftstruct nft_chain_hook hook;struct nf_hook_ops *ops; +if (table->flags & __NFT_TABLE_F_UPDATE) +return -EINVAL ; + err =nft_chain_parse_hook (net, nla, &hook, family, true);if (err <0 )return err;
Greg Kroah-Hartman
maintainerPATCH 198/213 netfilter: nf_tables: discard table flag update with pending basechain deletion
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
commit 1bc83a019bbe268be3526406245ec28c2458a518 upstream.
Hook unregistration is deferred to the commit phase, same occurs with hook updates triggered by the table dormant flag. When both commands are combined, this results in deleting a basechain while leaving its hook still registered in the core.
--- net/netfilter/nf_tables_api.c | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-)
net/netfilter/nf_tables_api.c +19 -1
@@ -877,6 +877,24 @@ static void nf_tables_table_disable(stru#define __NFT_TABLE_F_UPDATE (__NFT_TABLE_F_WAS_DORMANT | \ __NFT_TABLE_F_WAS_AWAKEN) +static bool nft_table_pending_update (const struct nft_ctx *ctx) +{ +struct nftables_pernet *nft_net =net_generic (ctx->net, nf_tables_net_id); +struct nft_trans *trans; + +if (ctx->table->flags & __NFT_TABLE_F_UPDATE) +return true; + +list_for_each_entry (trans, &nft_net->commit_list, list) { +if (trans->ctx.table == ctx->table && + trans->msg_type ==NFT_MSG_DELCHAIN && +nft_is_base_chain (trans->ctx.chain)) +return true; + } + +return false; +} +static int nf_tables_updtable (struct nft_ctx *ctx) {struct nft_trans *trans;
@@ -894,7 +912,7 @@ static int nf_tables_updtable(struct nftreturn 0 ;/* No dormant off/on/off/on games in single transaction */ -if (ctx->table->flags & __NFT_TABLE_F_UPDATE) +if (nft_table_pending_update (ctx))return -EINVAL ; trans = nft_trans_alloc(ctx, NFT_MSG_NEWTABLE,
Greg Kroah-Hartman
maintainerPATCH 199/213 KVM: arm64: Allow AArch32 PSTATE.M to be restored as System mode
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Marc Zyngier <[email protected]>
commit dfe6d190f38fc5df5ff2614b463a5195a399c885 upstream.
It appears that we don't allow a vcpu to be restored in AArch32 System mode, as we *never* included it in the list of valid modes.
Just add it to the list of allowed modes.
--- arch/arm64/kvm/guest.c | 1 + 1 file changed, 1 insertion(+)
arch/arm64/kvm/guest.c +1 -0
@@ -175,6 +175,7 @@ static int set_core_reg(struct kvm_vcpucase PSR_AA32_MODE_SVC :case PSR_AA32_MODE_ABT :case PSR_AA32_MODE_UND : +case PSR_AA32_MODE_SYS :if (!vcpu_el1_is_32bit (vcpu))return -EINVAL ;break ;
Greg Kroah-Hartman
maintainerPATCH 200/213 crypto: qat - Fix ADF_DEV_RESET_SYNC memory leak
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Herbert Xu <[email protected]>
commit d3b17c6d9dddc2db3670bc9be628b122416a3d26 upstream.
Using completion_done to determine whether the caller has gone away only works after a complete call. Furthermore it's still possible that the caller has not yet called wait_for_completion, resulting in another potential UAF.
Fix this by making the caller use cancel_work_sync and then freeing the memory safely.
--- drivers/crypto/qat/qat_common/adf_aer.c | 19 +++++-------------- 1 file changed, 5 insertions(+), 14 deletions(-)
drivers/crypto/qat/qat_common/adf_aer.c +5 -14
@@ -139,8 +139,7 @@ static void adf_device_reset_worker(struif (adf_dev_init (accel_dev) ||adf_dev_start (accel_dev)) {/* The device hanged and we can't restart it so stop here */ dev_err (&GET_DEV (accel_dev),"Restart device failed\n" ); -if (reset_data->mode ==ADF_DEV_RESET_ASYNC || -completion_done (&reset_data->compl)) +if (reset_data->mode ==ADF_DEV_RESET_ASYNC )kfree (reset_data);WARN (1 ,"QAT: device restart failed. Device is unusable\n" );return ;
@@ -148,16 +147,8 @@ static void adf_device_reset_worker(struadf_dev_restarted_notify (accel_dev);clear_bit (ADF_STATUS_RESTARTING , &accel_dev->status); -/* -* The dev is back alive. Notify the caller if in sync mode -* -* If device restart will take a more time than expected, -* the schedule_reset() function can timeout and exit. This can be -* detected by calling the completion_done() function. In this case -* the reset_data structure needs to be freed here. -*/ -if (reset_data->mode ==ADF_DEV_RESET_ASYNC || -completion_done (&reset_data->compl)) +/* The dev is back alive. Notify the caller if in sync mode */ +if (reset_data->mode ==ADF_DEV_RESET_ASYNC )kfree (reset_data);else complete (&reset_data->compl);
@@ -192,10 +183,10 @@ static int adf_dev_aer_schedule_reset(stif (!timeout) {dev_err (&GET_DEV (accel_dev),"Reset device timeout expired\n" ); +cancel_work_sync (&reset_data->reset_work); ret = -EFAULT ; - }else { -kfree (reset_data); } +kfree (reset_data);return ret; }return 0 ;
Greg Kroah-Hartman
maintainerPATCH 201/213 net/9p: fix uninit-value in p9_client_rpc()
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Nikita Zhandarovich <[email protected]>
commit 25460d6f39024cc3b8241b14c7ccf0d6f11a736a upstream.
Syzbot with the help of KMSAN reported the following error:
BUG: KMSAN: uninit-value in trace_9p_client_res include/trace/events/9p.h:146 [inline] BUG: KMSAN: uninit-value in p9_client_rpc+0x1314/0x1340 net/9p/client.c:754 trace_9p_client_res include/trace/events/9p.h:146 [inline] p9_client_rpc+0x1314/0x1340 net/9p/client.c:754 p9_client_create+0x1551/0x1ff0 net/9p/client.c:1031 v9fs_session_init+0x1b9/0x28e0 fs/9p/v9fs.c:410 v9fs_mount+0xe2/0x12b0 fs/9p/vfs_super.c:122 legacy_get_tree+0x114/0x290 fs/fs_context.c:662 vfs_get_tree+0xa7/0x570 fs/super.c:1797 do_new_mount+0x71f/0x15e0 fs/namespace.c:3352 path_mount+0x742/0x1f20 fs/namespace.c:3679 do_mount fs/namespace.c:3692 [inline] __do_sys_mount fs/namespace.c:3898 [inline] __se_sys_mount+0x725/0x810 fs/namespace.c:3875 __x64_sys_mount+0xe4/0x150 fs/namespace.c:3875 do_syscall_64+0xd5/0x1f0 entry_SYSCALL_64_after_hwframe+0x6d/0x75
Uninit was created at:
__alloc_pages+0x9d6/0xe70 mm/page_alloc.c:4598 __alloc_pages_node include/linux/gfp.h:238 [inline] alloc_pages_node include/linux/gfp.h:261 [inline] alloc_slab_page mm/slub.c:2175 [inline] allocate_slab mm/slub.c:2338 [inline] new_slab+0x2de/0x1400 mm/slub.c:2391 ___slab_alloc+0x1184/0x33d0 mm/slub.c:3525 __slab_alloc mm/slub.c:3610 [inline] __slab_alloc_node mm/slub.c:3663 [inline] slab_alloc_node mm/slub.c:3835 [inline] kmem_cache_alloc+0x6d3/0xbe0 mm/slub.c:3852 p9_tag_alloc net/9p/client.c:278 [inline] p9_client_prepare_req+0x20a/0x1770 net/9p/client.c:641 p9_client_rpc+0x27e/0x1340 net/9p/client.c:688 p9_client_create+0x1551/0x1ff0 net/9p/client.c:1031 v9fs_session_init+0x1b9/0x28e0 fs/9p/v9fs.c:410 v9fs_mount+0xe2/0x12b0 fs/9p/vfs_super.c:122 legacy_get_tree+0x114/0x290 fs/fs_context.c:662 vfs_get_tree+0xa7/0x570 fs/super.c:1797 do_new_mount+0x71f/0x15e0 fs/namespace.c:3352 path_mount+0x742/0x1f20 fs/namespace.c:3679 do_mount fs/namespace.c:3692 [inline] __do_sys_mount fs/namespace.c:3898 [inline] __se_sys_mount+0x725/0x810 fs/namespace.c:3875 __x64_sys_mount+0xe4/0x150 fs/namespace.c:3875 do_syscall_64+0xd5/0x1f0 entry_SYSCALL_64_after_hwframe+0x6d/0x75
If p9_check_errors() fails early in p9_client_rpc(), req->rc.tag will not be properly initialized. However, trace_9p_client_res() ends up trying to print it out anyway before p9_client_rpc() finishes.
Fix this issue by assigning default values to p9_fcall fields such as 'tag' and (just in case KMSAN unearths something new) 'id' during the tag allocation stage.
Message-ID: <[email protected]>
--- net/9p/client.c | 2 ++ 1 file changed, 2 insertions(+)
net/9p/client.c +2 -0
@@ -250,6 +250,8 @@ static int p9_fcall_init(struct p9_clienif (!fc->sdata)return -ENOMEM ; fc->capacity = alloc_msize; + fc->id =0 ; + fc->tag =P9_NOTAG ;return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 202/213 intel_th: pci: Add Meteor Lake-S CPU support
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Alexander Shishkin <[email protected]>
commit a4f813c3ec9d1c32bc402becd1f011b3904dd699 upstream.
Add support for the Trace Hub in Meteor Lake-S CPU.
--- drivers/hwtracing/intel_th/pci.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/hwtracing/intel_th/pci.c +5 -0
@@ -251,6 +251,11 @@ static const struct pci_device_id intel_ .driver_data = (kernel_ulong_t)&intel_th_2x, }, { +/* Meteor Lake-S CPU */ + PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xae24), + .driver_data = (kernel_ulong_t)&intel_th_2x, + }, + {/* Raptor Lake-S */ PCI_DEVICE (PCI_VENDOR_ID_INTEL ,0x7a26 ), .driver_data = (kernel_ulong_t)&intel_th_2x,
Greg Kroah-Hartman
maintainerPATCH 203/213 sparc64: Fix number of online CPUs
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sam Ravnborg <[email protected]>
commit 98937707fea8375e8acea0aaa0b68a956dd52719 upstream.
Nick Bowler reported:
When using newer kernels on my Ultra 60 with dual 450MHz UltraSPARC-II CPUs, I noticed that only CPU 0 comes up, while older kernels (including 4.7) are working fine with both CPUs.
I bisected the failure to this commit:
9b2f753ec23710aa32c0d837d2499db92fe9115b is the first bad commit commit 9b2f753ec23710aa32c0d837d2499db92fe9115b
Author: Atish Patra <[email protected]>
Date: Thu Sep 15 14:54:40 2016 -0600
sparc64: Fix cpu_possible_mask if nr_cpus is set
This is a small change that reverts very easily on top of 5.18: there is just one trivial conflict. Once reverted, both CPUs work again.
Maybe this is related to the fact that the CPUs on this system are numbered CPU0 and CPU2 (there is no CPU1)?
The current code that adjust cpu_possible based on nr_cpu_ids do not take into account that CPU's may not come one after each other. Move the chech to the function that setup the cpu_possible mask so there is no need to adjust it later.
--- arch/sparc/include/asm/smp_64.h | 2 -- arch/sparc/kernel/prom_64.c | 4 +++- arch/sparc/kernel/setup_64.c | 1 - arch/sparc/kernel/smp_64.c | 14 -------------- 4 files changed, 3 insertions(+), 18 deletions(-)
arch/sparc/include/asm/smp_64.h +0 -2
@@ -47,7 +47,6 @@ void arch_send_call_function_ipi_mask(coint hard_smp_processor_id (void );#define raw_smp_processor_id () (current_thread_info()->cpu) -void smp_fill_in_cpu_possible_map (void );void smp_fill_in_sib_core_maps (void );void cpu_play_dead (void );
@@ -77,7 +76,6 @@ void __cpu_die(unsigned int cpu);#define smp_fill_in_sib_core_maps () do { } while (0)#define smp_fetch_global_regs () do { } while (0)#define smp_fetch_global_pmu () do { } while (0) -#define smp_fill_in_cpu_possible_map () do { } while (0)#define smp_init_cpu_poke () do { } while (0)#define scheduler_poke () do { } while (0)
arch/sparc/kernel/prom_64.c +3 -1
@@ -479,7 +479,9 @@ static void *record_one_cpu(struct devic ncpus_probed++;#ifdef CONFIG_SMP set_cpu_present (cpuid, true); -set_cpu_possible (cpuid, true); + +if (num_possible_cpus () < nr_cpu_ids) +set_cpu_possible (cpuid, true);#endif return NULL ; }
arch/sparc/kernel/setup_64.c +0 -1
@@ -690,7 +690,6 @@ void __init setup_arch(char **cmdline_p)paging_init ();init_sparc64_elf_hwcap (); -smp_fill_in_cpu_possible_map ();/* * Once the OF device tree and MDESC have been setup and nr_cpus has * been parsed, we know the list of possible cpus. Therefore we can
arch/sparc/kernel/smp_64.c +0 -14
@@ -1213,20 +1213,6 @@ void __init smp_setup_processor_id(void) xcall_deliver_impl = hypervisor_xcall_deliver; } -void __init smp_fill_in_cpu_possible_map (void ) -{ -int possible_cpus =num_possible_cpus (); -int i; - -if (possible_cpus > nr_cpu_ids) - possible_cpus = nr_cpu_ids; - -for (i =0 ; i < possible_cpus; i++) -set_cpu_possible (i, true); -for (; i <NR_CPUS ; i++) -set_cpu_possible (i, false); -} -void smp_fill_in_sib_core_maps (void ) {unsigned int i;
Greg Kroah-Hartman
maintainerPATCH 204/213 kdb: Fix buffer overflow during tab-complete
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daniel Thompson <[email protected]>
commit e9730744bf3af04cda23799029342aa3cddbc454 upstream.
Currently, when the user attempts symbol completion with the Tab key, kdb will use strncpy() to insert the completed symbol into the command buffer. Unfortunately it passes the size of the source buffer rather than the destination to strncpy() with predictably horrible results. Most obviously if the command buffer is already full but cp, the cursor position, is in the middle of the buffer, then we will write past the end of the supplied buffer.
Fix this by replacing the dubious strncpy() calls with memmove()/memcpy() calls plus explicit boundary checks to make sure we have enough space before we start moving characters around.
--- kernel/debug/kdb/kdb_io.c | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-)
kernel/debug/kdb/kdb_io.c +13 -8
@@ -364,14 +364,19 @@ poll_again:kdb_printf (kdb_prompt_str);kdb_printf ("%s" , buffer); }else if (tab !=2 && count >0 ) { - len_tmp =strlen (p_tmp); -strncpy (p_tmp+len_tmp, cp, lastchar-cp+1 ); - len_tmp =strlen (p_tmp); -strncpy (cp, p_tmp+len, len_tmp-len +1 ); - len = len_tmp - len; -kdb_printf ("%s" , cp); - cp += len; - lastchar += len; +/* How many new characters do we want from tmpbuffer? */ + len_tmp =strlen (p_tmp) - len; +if (lastchar + len_tmp >= bufend) + len_tmp = bufend - lastchar; + +if (len_tmp) { +/* + 1 ensures the '\0' is memmove'd */ +memmove (cp+len_tmp, cp, (lastchar-cp) +1 ); +memcpy (cp, p_tmp+len, len_tmp); +kdb_printf ("%s" , cp); + cp += len_tmp; + lastchar += len_tmp; + } } kdb_nextline =1 ;/* reset output line number */ break ;
Greg Kroah-Hartman
maintainerPATCH 205/213 kdb: Use format-strings rather than \0 injection in kdb_read()
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daniel Thompson <[email protected]>
commit 09b35989421dfd5573f0b4683c7700a7483c71f9 upstream.
Currently when kdb_read() needs to reposition the cursor it uses copy and paste code that works by injecting an '\0' at the cursor position before delivering a carriage-return and reprinting the line (which stops at the '\0').
Tidy up the code by hoisting the copy and paste code into an appropriately named function. Additionally let's replace the '\0' injection with a proper field width parameter so that the string will be abridged during formatting instead.
--- kernel/debug/kdb/kdb_io.c | 55 ++++++++++++++++++++++++++++------------------ 1 file changed, 34 insertions(+), 21 deletions(-)
kernel/debug/kdb/kdb_io.c +34 -21
@@ -170,6 +170,33 @@ static int kdb_read_get_key(char *bufferreturn key; } +/** +* kdb_position_cursor() - Place cursor in the correct horizontal position +* @prompt: Nil-terminated string containing the prompt string +* @buffer: Nil-terminated string containing the entire command line +* @cp: Cursor position, pointer the character in buffer where the cursor +* should be positioned. +* +* The cursor is positioned by sending a carriage-return and then printing +* the content of the line until we reach the correct cursor position. +* +* There is some additional fine detail here. +* +* Firstly, even though kdb_printf() will correctly format zero-width fields +* we want the second call to kdb_printf() to be conditional. That keeps things +* a little cleaner when LOGGING=1. +* +* Secondly, we can't combine everything into one call to kdb_printf() since +* that renders into a fixed length buffer and the combined print could result +* in unwanted truncation. +*/ +static void kdb_position_cursor (char *prompt,char *buffer,char *cp) +{ +kdb_printf ("\r%s" , kdb_prompt_str); +if (cp > buffer) +kdb_printf ("%.*s" , (int )(cp - buffer), buffer); +} +/* * kdb_read *
@@ -208,7 +235,6 @@ static char *kdb_read(char *buffer, size* and null byte */ char *lastchar;char *p_tmp; -char tmp;static char tmpbuffer[CMD_BUFLEN ];int len =strlen (buffer);int len_tmp;
@@ -247,12 +273,8 @@ poll_again: } *(--lastchar) ='\0' ; --cp; -kdb_printf ("\b%s \r" , cp); - tmp = *cp; - *cp ='\0' ; -kdb_printf (kdb_prompt_str); -kdb_printf ("%s" , buffer); - *cp = tmp; +kdb_printf ("\b%s " , cp); +kdb_position_cursor (kdb_prompt_str, buffer, cp); }break ;case 13 :/* enter */
@@ -269,19 +291,14 @@ poll_again:memcpy (tmpbuffer, cp+1 , lastchar - cp -1 );memcpy (cp, tmpbuffer, lastchar - cp -1 ); *(--lastchar) ='\0' ; -kdb_printf ("%s \r" , cp); - tmp = *cp; - *cp ='\0' ; -kdb_printf (kdb_prompt_str); -kdb_printf ("%s" , buffer); - *cp = tmp; +kdb_printf ("%s " , cp); +kdb_position_cursor (kdb_prompt_str, buffer, cp); }break ;case 1 :/* Home */ if (cp > buffer) { -kdb_printf ("\r" ); -kdb_printf (kdb_prompt_str); cp = buffer; +kdb_position_cursor (kdb_prompt_str, buffer, cp); }break ;case 5 :/* End */
@@ -387,13 +404,9 @@ poll_again:memcpy (cp+1 , tmpbuffer, lastchar - cp); *++lastchar ='\0' ; *cp = key; -kdb_printf ("%s\r" , cp); +kdb_printf ("%s" , cp); ++cp; - tmp = *cp; - *cp ='\0' ; -kdb_printf (kdb_prompt_str); -kdb_printf ("%s" , buffer); - *cp = tmp; +kdb_position_cursor (kdb_prompt_str, buffer, cp); }else { *++lastchar ='\0' ; *cp++ = key;
Greg Kroah-Hartman
maintainerPATCH 206/213 kdb: Fix console handling when editing and tab-completing commands
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daniel Thompson <[email protected]>
commit db2f9c7dc29114f531df4a425d0867d01e1f1e28 upstream.
Currently, if the cursor position is not at the end of the command buffer and the user uses the Tab-complete functions, then the console does not leave the cursor in the correct position.
For example consider the following buffer with the cursor positioned at the ^:
md kdb_pro 10
^
Pressing tab should result in:
md kdb_prompt_str 10
^
However this does not happen. Instead the cursor is placed at the end (after then 10) and further cursor movement redraws incorrectly. The same problem exists when we double-Tab but in a different part of the code.
Fix this by sending a carriage return and then redisplaying the text to the left of the cursor.
--- kernel/debug/kdb/kdb_io.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/debug/kdb/kdb_io.c +5 -0
@@ -380,6 +380,8 @@ poll_again:kdb_printf ("\n" );kdb_printf (kdb_prompt_str);kdb_printf ("%s" , buffer); +if (cp != lastchar) +kdb_position_cursor (kdb_prompt_str, buffer, cp); }else if (tab !=2 && count >0 ) {/* How many new characters do we want from tmpbuffer? */ len_tmp =strlen (p_tmp) - len;
@@ -393,6 +395,9 @@ poll_again:kdb_printf ("%s" , cp); cp += len_tmp; lastchar += len_tmp; +if (cp != lastchar) +kdb_position_cursor (kdb_prompt_str, + buffer, cp); } } kdb_nextline =1 ;/* reset output line number */
Greg Kroah-Hartman
maintainerPATCH 207/213 kdb: Merge identical case statements in kdb_read()
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daniel Thompson <[email protected]>
commit 6244917f377bf64719551b58592a02a0336a7439 upstream.
The code that handles case 14 (down) and case 16 (up) has been copy and pasted despite being byte-for-byte identical. Combine them.
--- kernel/debug/kdb/kdb_io.c | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-)
kernel/debug/kdb/kdb_io.c +1 -9
@@ -314,6 +314,7 @@ poll_again: }break ;case 14 :/* Down */ +case 16 :/* Up */ memset (tmpbuffer,' ' ,strlen (kdb_prompt_str) + (lastchar-buffer)); *(tmpbuffer+strlen(kdb_prompt_str) +
@@ -328,15 +329,6 @@ poll_again: ++cp; }break ; -case 16 :/* Up */ -memset (tmpbuffer,' ' , -strlen (kdb_prompt_str) + (lastchar-buffer)); - *(tmpbuffer+strlen (kdb_prompt_str) + - (lastchar-buffer)) ='\0' ; -kdb_printf ("\r%s\r" , tmpbuffer); - *lastchar = (char )key; - *(lastchar+1 ) ='\0' ; -return lastchar;case 9 :/* Tab */ if (tab <2 ) ++tab;
Greg Kroah-Hartman
maintainerPATCH 208/213 kdb: Use format-specifiers rather than memset() for padding in kdb_read()
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daniel Thompson <[email protected]>
commit c9b51ddb66b1d96e4d364c088da0f1dfb004c574 upstream.
Currently when the current line should be removed from the display kdb_read() uses memset() to fill a temporary buffer with spaces. The problem is not that this could be trivially implemented using a format string rather than open coding it. The real problem is that it is possible, on systems with a long kdb_prompt_str, to write past the end of the tmpbuffer.
Happily, as mentioned above, this can be trivially implemented using a format string. Make it so!
--- kernel/debug/kdb/kdb_io.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
kernel/debug/kdb/kdb_io.c +3 -5
@@ -315,11 +315,9 @@ poll_again:break ;case 14 :/* Down */ case 16 :/* Up */ -memset (tmpbuffer,' ' , -strlen (kdb_prompt_str) + (lastchar-buffer)); - *(tmpbuffer+strlen (kdb_prompt_str) + - (lastchar-buffer)) ='\0' ; -kdb_printf ("\r%s\r" , tmpbuffer); +kdb_printf ("\r%*c\r" , + (int )(strlen (kdb_prompt_str) + (lastchar - buffer)), +' ' ); *lastchar = (char )key; *(lastchar+1 ) ='\0' ;return lastchar;
Greg Kroah-Hartman
maintainerPATCH 209/213 net: fix __dst_negative_advice() race
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Eric Dumazet <[email protected]>
commit 92f1655aa2b2294d0b49925f3b875a634bd3b59e upstream.
__dst_negative_advice() does not enforce proper RCU rules when sk->dst_cache must be cleared, leading to possible UAF.
RCU rules are that we must first clear sk->sk_dst_cache, then call dst_release(old_dst).
Note that sk_dst_reset(sk) is implementing this protocol correctly, while __dst_negative_advice() uses the wrong order.
Given that ip6_negative_advice() has special logic against RTF_CACHE, this means each of the three ->negative_advice() existing methods must perform the sk_dst_reset() themselves.
Note the check against NULL dst is centralized in __dst_negative_advice(), there is no need to duplicate it in various callbacks.
Many thanks to Clement Lecigne for tracking this issue.
This old bug became visible after the blamed commit, using UDP sockets.
--- include/net/dst_ops.h | 2 +- include/net/sock.h | 13 +++---------- net/ipv4/route.c | 22 ++++++++-------------- net/ipv6/route.c | 29 +++++++++++++++-------------- net/xfrm/xfrm_policy.c | 11 +++-------- 5 files changed, 30 insertions(+), 47 deletions(-)
include/net/dst_ops.h +1 -1
@@ -24,7 +24,7 @@ struct dst_ops {void (*destroy)(struct dst_entry *);void (*ifdown)(struct dst_entry *,struct net_device *dev,int how); -struct dst_entry * (*negative_advice)(struct dst_entry *); +void (*negative_advice)(struct sock *sk,struct dst_entry *);void (*link_failure)(struct sk_buff *); void (*update_pmtu)(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb, u32 mtu,
include/net/sock.h +3 -10
@@ -1915,19 +1915,12 @@ sk_dst_get(struct sock *sk)static inline void dst_negative_advice (struct sock *sk) { -struct dst_entry *ndst, *dst =__sk_dst_get (sk); +struct dst_entry *dst =__sk_dst_get (sk);sk_rethink_txhash (sk); -if (dst && dst->ops->negative_advice) { - ndst = dst->ops->negative_advice (dst); - -if (ndst != dst) { -rcu_assign_pointer (sk->sk_dst_cache, ndst); -sk_tx_queue_clear (sk); -WRITE_ONCE (sk->sk_dst_pending_confirm,0 ); - } - } +if (dst && dst->ops->negative_advice) + dst->ops->negative_advice (sk, dst); } static inline void
net/ipv4/route.c +8 -14
@@ -140,7 +140,8 @@ static int ip_rt_gc_timeout __read_mostlstatic struct dst_entry *ipv4_dst_check (struct dst_entry *dst,u32 cookie);static unsigned int ipv4_default_advmss (const struct dst_entry *dst);static unsigned int ipv4_mtu (const struct dst_entry *dst); -static struct dst_entry *ipv4_negative_advice (struct dst_entry *dst); +static void ipv4_negative_advice (struct sock *sk, +struct dst_entry *dst);static void ipv4_link_failure (struct sk_buff *skb); static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb, u32 mtu,
@@ -848,22 +849,15 @@ static void ip_do_redirect(struct dst_en__ip_do_redirect (rt, skb, &fl4, true); } -static struct dst_entry *ipv4_negative_advice (struct dst_entry *dst) +static void ipv4_negative_advice (struct sock *sk, +struct dst_entry *dst) {struct rtable *rt = (struct rtable *)dst; -struct dst_entry *ret = dst; -if (rt) { -if (dst->obsolete >0 ) { -ip_rt_put (rt); - ret =NULL ; - }else if ((rt->rt_flags &RTCF_REDIRECTED ) || - rt->dst.expires) { -ip_rt_put (rt); - ret =NULL ; - } - } -return ret; +if ((dst->obsolete >0 ) || + (rt->rt_flags &RTCF_REDIRECTED ) || + rt->dst.expires) +sk_dst_reset (sk); }/*
net/ipv6/route.c +15 -14
@@ -88,7 +88,8 @@ enum rt6_nud_state {static struct dst_entry *ip6_dst_check (struct dst_entry *dst,u32 cookie);static unsigned int ip6_default_advmss (const struct dst_entry *dst);static unsigned int ip6_mtu (const struct dst_entry *dst); -static struct dst_entry *ip6_negative_advice (struct dst_entry *); +static void ip6_negative_advice (struct sock *sk, +struct dst_entry *dst);static void ip6_dst_destroy (struct dst_entry *);static void ip6_dst_ifdown (struct dst_entry *,struct net_device *dev,int how);
@@ -2281,24 +2282,24 @@ static struct dst_entry *ip6_dst_check(sreturn dst_ret; } -static struct dst_entry *ip6_negative_advice (struct dst_entry *dst) +static void ip6_negative_advice (struct sock *sk, +struct dst_entry *dst) {struct rt6_info *rt = (struct rt6_info *) dst; -if (rt) { -if (rt->rt6i_flags &RTF_CACHE ) { -rcu_read_lock (); -if (rt6_check_expired (rt)) { -rt6_remove_exception_rt (rt); - dst =NULL ; - } -rcu_read_unlock (); - }else { -dst_release (dst); - dst =NULL ; +if (rt->rt6i_flags &RTF_CACHE ) { +rcu_read_lock (); +if (rt6_check_expired (rt)) { +/* counteract the dst_release() in sk_dst_reset() */ +dst_hold (dst); +sk_dst_reset (sk); + +rt6_remove_exception_rt (rt); } +rcu_read_unlock (); +return ; } -return dst; +sk_dst_reset (sk); }static void ip6_link_failure (struct sk_buff *skb)
net/xfrm/xfrm_policy.c +3 -8
@@ -2556,15 +2556,10 @@ static void xfrm_link_failure(struct sk_/* Impossible. Such dst must be popped before reaches point of failure. */ } -static struct dst_entry *xfrm_negative_advice (struct dst_entry *dst) +static void xfrm_negative_advice (struct sock *sk,struct dst_entry *dst) { -if (dst) { -if (dst->obsolete) { -dst_release (dst); - dst =NULL ; - } - } -return dst; +if (dst->obsolete) +sk_dst_reset (sk); }static void xfrm_init_pmtu (struct xfrm_dst **bundle,int nr)
Greg Kroah-Hartman
maintainerPATCH 210/213 sparc: move struct termio to asm/termios.h
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Mike Gilbert <[email protected]>
commit c32d18e7942d7589b62e301eb426b32623366565 upstream.
Every other arch declares struct termio in asm/termios.h, so make sparc match them.
Resolves a build failure in the PPP software package, which includes both bits/ioctl-types.h via sys/ioctl.h (glibc) and asm/termbits.h.
--- arch/sparc/include/uapi/asm/termbits.h | 10 ---------- arch/sparc/include/uapi/asm/termios.h | 9 +++++++++ 2 files changed, 9 insertions(+), 10 deletions(-)
arch/sparc/include/uapi/asm/termbits.h +0 -10
@@ -13,16 +13,6 @@ typedef unsigned int tcflag_t;typedef unsigned long tcflag_t ;#endif -#define NCC 8 -struct termio { -unsigned short c_iflag;/* input mode flags */ -unsigned short c_oflag;/* output mode flags */ -unsigned short c_cflag;/* control mode flags */ -unsigned short c_lflag;/* local mode flags */ -unsigned char c_line;/* line discipline */ -unsigned char c_cc[NCC ];/* control characters */ -}; -#define NCCS 17struct termios {tcflag_t c_iflag;/* input mode flags */
arch/sparc/include/uapi/asm/termios.h +9 -0
@@ -40,5 +40,14 @@ struct winsize { unsigned short ws_ypixel; }; +#define NCC 8 +struct termio { +unsigned short c_iflag;/* input mode flags */ +unsigned short c_oflag;/* output mode flags */ +unsigned short c_cflag;/* control mode flags */ +unsigned short c_lflag;/* local mode flags */ +unsigned char c_line;/* line discipline */ +unsigned char c_cc[NCC ];/* control characters */ +};#endif /* _UAPI_SPARC_TERMIOS_H */
Greg Kroah-Hartman
maintainerPATCH 211/213 ext4: fix mb_cache_entrys e_refcnt leak in ext4_xattr_block_cache_find()
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Baokun Li <[email protected]>
commit 0c0b4a49d3e7f49690a6827a41faeffad5df7e21 upstream.
Syzbot reports a warning as follows:
============================================
WARNING: CPU: 0 PID: 5075 at fs/mbcache.c:419 mb_cache_destroy+0x224/0x290 Modules linked in: CPU: 0 PID: 5075 Comm: syz-executor199 Not tainted 6.9.0-rc6-gb947cc5bf6d7 RIP: 0010:mb_cache_destroy+0x224/0x290 fs/mbcache.c:419 Call Trace: <TASK> ext4_put_super+0x6d4/0xcd0 fs/ext4/super.c:1375 generic_shutdown_super+0x136/0x2d0 fs/super.c:641 kill_block_super+0x44/0x90 fs/super.c:1675 ext4_kill_sb+0x68/0xa0 fs/ext4/super.c:7327
[...]
============================================
This is because when finding an entry in ext4_xattr_block_cache_find(), if ext4_sb_bread() returns -ENOMEM, the ce's e_refcnt, which has already grown in the __entry_find(), won't be put away, and eventually trigger the above issue in mb_cache_destroy() due to reference count leakage.
So call mb_cache_entry_put() on the -ENOMEM error branch as a quick fix.
--- fs/ext4/xattr.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
fs/ext4/xattr.c +3 -1
@@ -3104,8 +3104,10 @@ ext4_xattr_block_cache_find(struct inode bh =ext4_sb_bread (inode->i_sb, ce->e_value,REQ_PRIO );if (IS_ERR (bh)) { -if (PTR_ERR (bh) == -ENOMEM ) +if (PTR_ERR (bh) == -ENOMEM ) { +mb_cache_entry_put (ea_block_cache, ce);return NULL ; + } bh =NULL ;EXT4_ERROR_INODE (inode,"block %lu read error" , (unsigned long )ce->e_value);
Greg Kroah-Hartman
maintainerPATCH 212/213 s390/ap: Fix crash in AP internal function modify_bitmap()
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Harald Freudenberger <[email protected]>
commit d4f9d5a99a3fd1b1c691b7a1a6f8f3f25f4116c9 upstream.
A system crash like this
Failing address: 200000cb7df6f000 TEID: 200000cb7df6f403
Fault in home space mode while using kernel ASCE. AS:00000002d71bc007 R3:00000003fe5b8007 S:000000011a446000 P:000000015660c13d
Oops: 0038 ilc:3 [#1] PREEMPT SMP Modules linked in: mlx5_ib ... CPU: 8 PID: 7556 Comm: bash Not tainted 6.9.0-rc7 #8 Hardware name: IBM 3931 A01 704 (LPAR) Krnl PSW : 0704e00180000000 0000014b75e7b606 (ap_parse_bitmap_str+0x10e/0x1f8) R:0 T:1 IO:1 EX:1 Key:0 M:1 W:0 P:0 AS:3 CC:2 PM:0 RI:0 EA:3 Krnl GPRS: 0000000000000001 ffffffffffffffc0 0000000000000001 00000048f96b75d3 000000cb00000100 ffffffffffffffff ffffffffffffffff 000000cb7df6fce0 000000cb7df6fce0 00000000ffffffff 000000000000002b 00000048ffffffff 000003ff9b2dbc80 200000cb7df6fcd8 0000014bffffffc0 000000cb7df6fbc8 Krnl Code: 0000014b75e7b5fc: a7840047 brc 8,0000014b75e7b68a 0000014b75e7b600: 18b2 lr %r11,%r2 #0000014b75e7b602: a7f4000a brc 15,0000014b75e7b616 >0000014b75e7b606: eb22d00000e6 laog %r2,%r2,0(%r13) 0000014b75e7b60c: a7680001 lhi %r6,1 0000014b75e7b610: 187b lr %r7,%r11 0000014b75e7b612: 84960021 brxh %r9,%r6,0000014b75e7b654 0000014b75e7b616: 18e9 lr %r14,%r9 Call Trace: [<0000014b75e7b606>] ap_parse_bitmap_str+0x10e/0x1f8 ([<0000014b75e7b5dc>] ap_parse_bitmap_str+0xe4/0x1f8) [<0000014b75e7b758>] apmask_store+0x68/0x140 [<0000014b75679196>] kernfs_fop_write_iter+0x14e/0x1e8 [<0000014b75598524>] vfs_write+0x1b4/0x448 [<0000014b7559894c>] ksys_write+0x74/0x100 [<0000014b7618a440>] __do_syscall+0x268/0x328 [<0000014b761a3558>] system_call+0x70/0x98 INFO: lockdep is turned off. Last Breaking-Event-Address: [<0000014b75e7b636>] ap_parse_bitmap_str+0x13e/0x1f8 Kernel panic - not syncing: Fatal exception: panic_on_oops
occured when /sys/bus/ap/a[pq]mask was updated with a relative mask value (like +0x10-0x12,+60,-90) with one of the numeric values exceeding INT_MAX.
The fix is simple: use unsigned long values for the internal variables. The correct checks are already in place in the function but a simple int for the internal variables was used with the possibility to overflow.
--- drivers/s390/crypto/ap_bus.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/s390/crypto/ap_bus.c +1 -1
@@ -916,7 +916,7 @@ static int hex2bitmap(const char *str, u*/ static int modify_bitmap (const char *str,unsigned long *bitmap,int bits) { -int a, i, z; +unsigned long a, i, z;char *np, sign;/* bits needs to be a multiple of 8 */
Greg Kroah-Hartman
maintainerPATCH 213/213 nfs: fix undefined behavior in nfs_block_bits()
In reply to Greg Kroah-Hartman4.19-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sergey Shtylyov <[email protected]>
commit 3c0a2e0b0ae661457c8505fecc7be5501aa7a715 upstream.
Shifting *signed int* typed constant 1 left by 31 bits causes undefined behavior. Specify the correct *unsigned long* type by using 1UL instead.
Found by Linux Verification Center (linuxtesting.org) with the Svace static analysis tool.
--- fs/nfs/internal.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/nfs/internal.h +2 -2
@@ -615,9 +615,9 @@ unsigned long nfs_block_bits(unsigned loif ((bsize & (bsize -1 )) || nrbitsp) {unsigned char nrbits; -for (nrbits =31 ; nrbits && !(bsize & (1 << nrbits)); nrbits--) +for (nrbits =31 ; nrbits && !(bsize & (1UL << nrbits)); nrbits--) ; - bsize =1 << nrbits; + bsize =1UL << nrbits;if (nrbitsp) *nrbitsp = nrbits; }
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.19.316 release. There are 213 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 15 Jun 2024 11:31:50 +0000. Anything received after that time might be too late.
$ git grep remove_new drivers/hsi/controllers/omap_ssi_core.c: .remove_new = ssi_remove, drivers/hsi/controllers/omap_ssi_port.c: .remove_new = ssi_port_remove,
There is no remove_new callback in v4.19.y, so this results in
drivers/hsi/controllers/omap_ssi_core.c:653:3: error:
field designator 'remove_new' does not refer to any field in type 'struct platform_driver'
653 | .remove_new = ssi_remove,
Guenter
Greg Kroah-Hartman
maintainerQuoted 14 lines · Guenter Roeck
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.19.316 release. There are 213 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 15 Jun 2024 11:31:50 +0000. Anything received after that time might be too late.
$ git grep remove_new drivers/hsi/controllers/omap_ssi_core.c: .remove_new = ssi_remove, drivers/hsi/controllers/omap_ssi_port.c: .remove_new = ssi_port_remove,
Quoted 6 lines
There is no
remove_newcallback in v4.19.y, so this results in
drivers/hsi/controllers/omap_ssi_core.c:653:3: error:
field designator 'remove_new' does not refer to any field in type 'structplatform_driver'
653 | .remove_new =ssi_remove,
Now dropped, thanks!
greg k-h
Hi!
Quoted 4 lines
This is the start of the stable review cycle for the 4.19.316 release. There are 213 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
CIP testing did not find any problems here:
https://gitlab.com/cip-project/cip-testing/linux-stable-rc-ci/-/tree/linux-4.19.y
Best regards,
Pavel
Signature · 2 lines
DENX Software Engineering GmbH, Managing Director: Erika Unter HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.19.316 release. There are 213 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 15 Jun 2024 11:31:50 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.19.316-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-4.19.y
and the diffstat can be found below.thanks,
greg k-h
All tests passing for Tegra ...
Test results for stable-v4.19:
10 builds: 10 pass, 0 fail
20 boots: 20 pass, 0 fail
37 tests: 37 pass, 0 failLinux version: 4.19.316-rc1-gafbf71016269
Boards tested: tegra124-jetson-tk1, tegra186-p2771-0000,
tegra194-p2972-0000, tegra20-ventana,
tegra210-p2371-2180, tegra30-cardhu-a04Jon
Quoted 5 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.19.316 release. There are 213 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Hi Greg,
No problems seen on x86_64 and aarch64 with our testing.
Thanks,
Harshit
Quoted 13 lines
Responses should be made by Sat, 15 Jun 2024 11:31:50 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.19.316-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-4.19.y
and the diffstat can be found below.thanks,
greg k-h
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.19.316 release. There are 213 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 15 Jun 2024 11:31:50 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 9 lines
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.19.316-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-4.19.y
and the diffstat can be found below.thanks,
greg k-h
Compiled and booted on my test system. No dmesg regressions.
thanks,
-- Shuah
Quoted 10 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.19.316 release. There are 213 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 15 Jun 2024 11:31:50 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.19.316-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-4.19.y
and the diffstat can be found below.thanks,
greg k-h
As other reported,
The arm omap2plus_defconfig builds failed on stable-rc 4.19 due to following warnings and errors.
* arm, build
- clang-18-omap2plus_defconfig
- gcc-12-omap2plus_defconfig
- gcc-8-omap2plus_defconfig
Build log:
---------drivers/hsi/controllers/omap_ssi_core.c:653:10: error: 'struct platform_driver' has no member named 'remove_new'; did you mean 'remove'?
653 | .remove_new = ssi_remove,
| ^~~~~~~~~~
| removedrivers/hsi/controllers/omap_ssi_core.c:653:23: error: initialization of 'int (*)(struct platform_device *)' from incompatible pointer type 'void (*)(struct platform_device *)' [-Werror=incompatible-pointer-types]
653 | .remove_new = ssi_remove,
| ^~~~~~~~~~
Liks:
--
- https://qa-reports.linaro.org/lkft/linux-stable-rc-linux-4.19.y/build/v4.19.315-214-gafbf71016269/testrun/24321970/suite/build/test/gcc-12-omap2plus_defconfig/log
- https://qa-reports.linaro.org/lkft/linux-stable-rc-linux-4.19.y/build/v4.19.315-214-gafbf71016269/testrun/24321970/suite/build/test/gcc-12-omap2plus_defconfig/details/
- https://storage.tuxsuite.com/public/linaro/lkft/builds/2hp7W1xcas5CN3psaeGX1n8sAj8/
--
Linaro LKFT
https://lkft.linaro.org
Greg Kroah-Hartman
maintainerQuoted 54 lines · Naresh Kamboju
Quoted 10 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.19.316 release. There are 213 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 15 Jun 2024 11:31:50 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.19.316-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-4.19.y
and the diffstat can be found below.thanks,
greg k-h
As other reported,
The arm
omap2plus_defconfigbuilds failed on stable-rc 4.19 due to following warnings and errors.* arm, build
- clang-18-omap2plus_defconfig
- gcc-12-omap2plus_defconfig
- gcc-8-omap2plus_defconfigBuild log:
---------drivers/hsi/controllers/omap_ssi_core.c:653:10: error: 'structplatform_driver' has no member named 'remove_new'; did you mean 'remove'?653 | .remove_new = ssi_remove, | ^~~~~~~~~~ | remove
drivers/hsi/controllers/omap_ssi_core.c:653:23: error: initialization of 'int (*)(structplatform_device*)' from incompatible pointer type 'void (*)(structplatform_device*)' [-Werror=incompatible-pointer-types]
653 | .remove_new =ssi_remove,| ^~~~~~~~~~Liks:
--
- https://qa-reports.linaro.org/lkft/linux-stable-rc-linux-4.19.y/build/v4.19.315-214-gafbf71016269/testrun/24321970/suite/build/test/gcc-12-omap2plus_defconfig/log
- https://qa-reports.linaro.org/lkft/linux-stable-rc-linux-4.19.y/build/v4.19.315-214-gafbf71016269/testrun/24321970/suite/build/test/gcc-12-omap2plus_defconfig/details/
- https://storage.tuxsuite.com/public/linaro/lkft/builds/2hp7W1xcas5CN3psaeGX1n8sAj8/
Quoted 4 lines
--
Linaro LKFT
https://lkft.linaro.org
Now fixed up, thanks.
greg k-h