netfilter: nf_tables: reduce set element
Subsystems (2)
Florian Westphal
maintainercover netfilter: nf_tables: reduce set element
When doing a flush on a set or mass adding/removing elements from a set, each element needs to allocate 96 bytes to hold the transactional state.
In such cases, virtually all the information in struct nft_trans_elem is the same.
Change nft_trans_elem to a flex-array, i.e. a single nft_trans_elem can hold multiple set element pointers.
The number of elements that can be stored in one nft_trans_elem is limited by the slab allocator, this series limits the compaction to at most 62 elements as it caps the reallocation to 2048 bytes of memory.
Florian Westphal (5):
netfilter: nf_tables: prefer nft_trans_elem_alloc helper
netfilter: nf_tables: add nft_trans_commit_list_add_elem helper
netfilter: nf_tables: prepare for multiple elements in nft_trans_elem
structure
netfilter: nf_tables: switch trans_elem to real flex array
netfilter: nf_tables: allocate element update information dynamically
include/net/netfilter/nf_tables.h | 25 +-- net/netfilter/nf_tables_api.c | 348 +++++++++++++++++++++++------- 2 files changed, 283 insertions(+), 90 deletions(-)
Signature · 1 line
2.44.2
Florian Westphal
maintainerPATCH 1/5 netfilter: nf_tables: prefer nft_trans_elem_alloc helper
Reduce references to sizeof(struct nft_trans_elem). Preparation patch to move this to a flexiable array to store elem references.
--- net/netfilter/nf_tables_api.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
net/netfilter/nf_tables_api.c +2 -4
@@ -6409,7 +6409,7 @@ static void nf_tables_setelem_notify(const struct nft_ctx *ctx,nfnetlink_set_err (net, portid,NFNLGRP_NFTABLES , -ENOBUFS ); } -static struct nft_trans *nft_trans_elem_alloc (struct nft_ctx *ctx, +static struct nft_trans *nft_trans_elem_alloc (const struct nft_ctx *ctx,int msg_type,struct nft_set *set) {
@@ -7471,13 +7471,11 @@ static int __nft_set_catchall_flush(const struct nft_ctx *ctx, {struct nft_trans *trans; - trans =nft_trans_alloc_gfp (ctx,NFT_MSG_DELSETELEM , -sizeof (struct nft_trans_elem ),GFP_KERNEL ); + trans =nft_trans_elem_alloc (ctx,NFT_MSG_DELSETELEM , set);if (!trans)return -ENOMEM ;nft_setelem_data_deactivate (ctx->net, set, elem_priv); -nft_trans_elem_set (trans) = set;nft_trans_elem_priv (trans) = elem_priv;nft_trans_commit_list_add_tail (ctx->net, trans);
Signature · 1 line
2.44.2
Florian Westphal
maintainerPATCH 2/5 netfilter: nf_tables: add nft_trans_commit_list_add_elem helper
In reply to Florian WestphalAdd and use a wrapper to append trans_elem structures to the transaction log.
Unlike the existing helper, pass a gfp_t to indicate if sleeping is allowed.
This will be used by a followup patch to realloc nft_trans_elem structures after they gain a flexible array member to reduce number of such container structures on the transaction list.
--- net/netfilter/nf_tables_api.c | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-)
net/netfilter/nf_tables_api.c +16 -5
@@ -421,6 +421,17 @@ static void nft_trans_commit_list_add_tail(struct net *net, struct nft_trans *tr } } +static void nft_trans_commit_list_add_elem (struct net *net,struct nft_trans *trans, +gfp_t gfp) +{ +WARN_ON_ONCE (trans->msg_type !=NFT_MSG_NEWSETELEM && + trans->msg_type !=NFT_MSG_DELSETELEM ); + +might_alloc (gfp); + +nft_trans_commit_list_add_tail (net, trans); +} +static int nft_trans_table_add (struct nft_ctx *ctx,int msg_type) {struct nft_trans *trans;
@@ -7183,7 +7194,7 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set,if (update_flags) {nft_trans_elem_priv (trans) = elem_priv;nft_trans_elem_update_flags (trans) = update_flags; -nft_trans_commit_list_add_tail (ctx->net, trans); +nft_trans_commit_list_add_elem (ctx->net, trans,GFP_KERNEL ); goto err_elem_free; } }
@@ -7207,7 +7218,7 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, }nft_trans_elem_priv (trans) = elem.priv; -nft_trans_commit_list_add_tail (ctx->net, trans); +nft_trans_commit_list_add_elem (ctx->net, trans,GFP_KERNEL );return 0 ; err_set_full:
@@ -7424,7 +7435,7 @@ static int nft_del_setelem(struct nft_ctx *ctx, struct nft_set *set,nft_setelem_data_deactivate (ctx->net, set, elem.priv);nft_trans_elem_priv (trans) = elem.priv; -nft_trans_commit_list_add_tail (ctx->net, trans); +nft_trans_commit_list_add_elem (ctx->net, trans,GFP_KERNEL );return 0 ; fail_ops:
@@ -7460,7 +7471,7 @@ static int nft_setelem_flush(const struct nft_ctx *ctx,nft_setelem_data_deactivate (ctx->net, set, elem_priv);nft_trans_elem_set (trans) = set;nft_trans_elem_priv (trans) = elem_priv; -nft_trans_commit_list_add_tail (ctx->net, trans); +nft_trans_commit_list_add_elem (ctx->net, trans,GFP_ATOMIC );return 0 ; }
@@ -7477,7 +7488,7 @@ static int __nft_set_catchall_flush(const struct nft_ctx *ctx,nft_setelem_data_deactivate (ctx->net, set, elem_priv);nft_trans_elem_priv (trans) = elem_priv; -nft_trans_commit_list_add_tail (ctx->net, trans); +nft_trans_commit_list_add_elem (ctx->net, trans,GFP_KERNEL );return 0 ; }
Signature · 1 line
2.44.2
Florian Westphal
maintainerPATCH 3/5 netfilter: nf_tables: prepare for multiple elements in nft_trans_elem structure
In reply to Florian WestphalAdd helpers to release the individual elements contained in the trans_elem container structure.
No functional change intended.
Followup patch will add 'nelems' member and will turn 'priv' into a flexible array.
These helpers can then loop over all elements.
--- include/net/netfilter/nf_tables.h | 21 ++- net/netfilter/nf_tables_api.c | 217 +++++++++++++++++++++--------- 2 files changed, 164 insertions(+), 74 deletions(-)
include/net/netfilter/nf_tables.h +9 -12
@@ -1754,28 +1754,25 @@ enum nft_trans_elem_flags { NFT_TRANS_UPD_EXPIRATION = (1 << 1), }; -struct nft_trans_elem { -struct nft_trans nft_trans; -struct nft_set *set; -struct nft_elem_priv *elem_priv; +struct nft_trans_one_elem { +struct nft_elem_priv *priv;u64 timeout;u64 expiration;u8 update_flags; +}; + +struct nft_trans_elem { +struct nft_trans nft_trans; +struct nft_set *set;bool bound; +unsigned int nelems; + struct nft_trans_one_elem elems[] __counted_by(nelems); };#define nft_trans_container_elem (t) \ container_of(t, struct nft_trans_elem, nft_trans)#define nft_trans_elem_set (trans) \ nft_trans_container_elem(trans)->set -#define nft_trans_elem_priv (trans) \ - nft_trans_container_elem(trans)->elem_priv -#define nft_trans_elem_update_flags (trans) \ - nft_trans_container_elem(trans)->update_flags -#define nft_trans_elem_timeout (trans) \ - nft_trans_container_elem(trans)->timeout -#define nft_trans_elem_expiration (trans) \ - nft_trans_container_elem(trans)->expiration#define nft_trans_elem_set_bound (trans) \ nft_trans_container_elem(trans)->bound
net/netfilter/nf_tables_api.c +155 -62
350 lines not on this page · raw message
Signature · 1 line
2.44.2
Florian Westphal
maintainerPATCH 4/5 netfilter: nf_tables: switch trans_elem to real flex array
In reply to Florian WestphalWhen queueing a set element add or removal operation to the transaction log, check if the previous operation already asks for a the identical operation on the same set.
If so, store the element reference in the preceeding operation. This significantlty reduces memory consumption when many set add/delete operations appear in a single transaction.
Example: 10k elements require 937kb of memory (10k allocations from kmalloc-96 slab).
Assuming we can compact 4 elements in the same set, 468 kbytes are needed (64 bytes for base struct, nft_trans_elemn, 32 bytes for nft_trans_one_elem structure, so 2500 allocations from kmalloc-192 slab).
For large batch updates we can compact up to 62 elements
into one single nft_trans_elem structure (~65% mem reduction):
(64 bytes for base struct, nft_trans_elem, 32 byte for nft_trans_one_elem
struct).
We can halve size of nft_trans_one_elem struct by moving timeout/expire/update_flags into a dynamically allocated structure, this allows to store 124 elements in a 2k slab nft_trans_elem struct. This is done in a followup patch.
--- net/netfilter/nf_tables_api.c | 79 ++++++++++++++++++++++++++++++++++- 1 file changed, 77 insertions(+), 2 deletions(-)
net/netfilter/nf_tables_api.c +77 -2
@@ -25,6 +25,7 @@#define NFT_MODULE_AUTOLOAD_LIMIT (MODULE_NAME_LEN - sizeof("nft-expr-255-"))#define NFT_SET_MAX_ANONLEN 16 +#define NFT_MAX_SET_NELEMS ((2048 - sizeof(struct nft_trans_elem)) / sizeof(struct nft_trans_one_elem))unsigned int nf_tables_net_id__read_mostly ;
@@ -391,6 +392,69 @@ static void nf_tables_unregister_hook(struct net *net,return __nf_tables_unregister_hook (net, table, chain, false); } +static bool nft_trans_collapse_set_elem_allowed (const struct nft_trans_elem *a,const struct nft_trans_elem *b) +{ +return a->set == b->set && a->bound == b->bound && a->nelems <NFT_MAX_SET_NELEMS ; +} + +static bool nft_trans_collapse_set_elem (struct nftables_pernet *nft_net, +struct nft_trans_elem *tail, +struct nft_trans_elem *trans, +gfp_t gfp) +{ +unsigned int nelems, old_nelems = tail->nelems; +struct nft_trans_elem *new_trans; + +if (!nft_trans_collapse_set_elem_allowed (tail, trans)) +return false; + +if (WARN_ON_ONCE (trans->nelems !=1 )) +return false; + +if (check_add_overflow (old_nelems, trans->nelems, &nelems)) +return false; + +/* krealloc might free tail which invalidates list pointers */ +list_del_init (&tail->nft_trans.list); + + new_trans =krealloc (tail,struct_size (tail, elems, nelems), gfp); +if (!new_trans) { +list_add_tail (&tail->nft_trans.list, &nft_net->commit_list); +return false; + } + +INIT_LIST_HEAD (&new_trans->nft_trans.list); + new_trans->nelems = nelems; + new_trans->elems[old_nelems] = trans->elems[0 ]; +list_add_tail (&new_trans->nft_trans.list, &nft_net->commit_list); + +return true; +} + +static bool nft_trans_try_collapse (struct nftables_pernet *nft_net, +struct nft_trans *trans,gfp_t gfp) +{ +struct nft_trans *tail; + +if (list_empty (&nft_net->commit_list)) +return false; + + tail = list_last_entry(&nft_net->commit_list, struct nft_trans, list); + +if (tail->msg_type != trans->msg_type) +return false; + +switch (trans->msg_type) { +case NFT_MSG_NEWSETELEM : +case NFT_MSG_DELSETELEM : +return nft_trans_collapse_set_elem (nft_net, +nft_trans_container_elem (tail), +nft_trans_container_elem (trans), gfp); + } + +return false; +} +static void nft_trans_commit_list_add_tail (struct net *net,struct nft_trans *trans) {struct nftables_pernet *nft_net =nft_pernet (net);
@@ -424,11 +488,18 @@ static void nft_trans_commit_list_add_tail(struct net *net, struct nft_trans *trstatic void nft_trans_commit_list_add_elem (struct net *net,struct nft_trans *trans,gfp_t gfp) { +struct nftables_pernet *nft_net =nft_pernet (net); +WARN_ON_ONCE (trans->msg_type !=NFT_MSG_NEWSETELEM && trans->msg_type !=NFT_MSG_DELSETELEM );might_alloc (gfp); +if (nft_trans_try_collapse (nft_net, trans, gfp)) { +kfree (trans); +return ; + } +nft_trans_commit_list_add_tail (net, trans); }
@@ -6424,13 +6495,17 @@ static struct nft_trans *nft_trans_elem_alloc(const struct nft_ctx *ctx,int msg_type, struct nft_set *set) { + struct nft_trans_elem *te;struct nft_trans *trans; - trans =nft_trans_alloc (ctx, msg_type,sizeof (struct nft_trans_elem )); + trans =nft_trans_alloc (ctx, msg_type,struct_size (te, elems,1 ));if (trans ==NULL )return NULL ; -nft_trans_elem_set (trans) = set; + te =nft_trans_container_elem (trans); + te->nelems =1 ; + te->set = set; +return trans; }
Signature · 1 line
2.44.2
Florian Westphal
maintainerPATCH 5/5 netfilter: nf_tables: allocate element update information dynamically
In reply to Florian WestphalMove the timeout/expire/flag members from nft_trans_one_elem struct into a dybamically allocated structure, only needed when timeout update was requested.
This halves size of nft_trans_one_elem struct and allows to compact up to 124 elements in one transaction container rather than 62.
This halves memory requirements for a large flush or insert transaction, where ->update remains NULL.
Care has to be taken to release the extra data in all spots, including abort path.
--- include/net/netfilter/nf_tables.h | 10 ++++-- net/netfilter/nf_tables_api.c | 57 +++++++++++++++++++------------ 2 files changed, 43 insertions(+), 24 deletions(-)
include/net/netfilter/nf_tables.h +7 -3
@@ -1754,11 +1754,15 @@ enum nft_trans_elem_flags { NFT_TRANS_UPD_EXPIRATION = (1 << 1), }; -struct nft_trans_one_elem { -struct nft_elem_priv *priv; +struct nft_elem_update {u64 timeout;u64 expiration; -u8 update_flags; +u8 flags; +}; + +struct nft_trans_one_elem { +struct nft_elem_priv *priv; +struct nft_elem_update *update; };struct nft_trans_elem {
net/netfilter/nf_tables_api.c +36 -21
113 lines not on this page · raw message
Signature · 1 line
2.44.2