Netfilter updates for net-next
Subsystems (4)
Pablo Neira Ayuso
maintainercover Netfilter updates for net-next
Hi,
The following patchset contains Netfilter updates for net-next. This patchset contains updates for the nf_tables register tracking infrastructure, disable bogus warning when attaching ct helpers, one namespace pollution fix and few cleanups for the flowtable.
1) Revisit conntrack gc routine to reduce chances of overruning the netlink buffer from the event path. From Florian Westphal.
2) Disable warning on explicit ct helper assignment, from Phil Sutter.
3) Read-only expressions do not update registers, mark them as NFT_REDUCE_READONLY. Add helper functions to update the register tracking information. This patch re-enables the register tracking infrastructure.
4) Cancel register tracking in case an expression fully/partially clobbers existing data.
5) Add register tracking support for remaining expressions: ct, lookup, meta, numgen, osf, hash, immediate, socket, xfrm, tunnel, fib, exthdr.
6) Rename init and exit functions for the conntrack h323 helper, from Randy Dunlap.
7) Remove redundant field in struct flow_offload_work.
8) Update nf_flow_table_iterate() to pass flowtable to callback.
Please, pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next.git
Thanks.
----------------------------------------------------------------
The following changes since commit 092d992b76ed9d06389af0bc5efd5279d7b1ed9f:
Merge tag 'mlx5-updates-2022-03-18' of git://git.kernel.org/pub/scm/linux/kernel/git/saeed/linux (2022-03-19 14:50:19 +0000)
are available in the Git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next.git HEAD
for you to fetch changes up to 217cff36e885627c41a14e803fc44f9cbc945767:
netfilter: flowtable: pass flowtable to nf_flow_table_iterate() (2022-03-20 00:29:48 +0100)
----------------------------------------------------------------
Florian Westphal (5):
netfilter: conntrack: revisit gc autotuning
netfilter: nft_lookup: only cancel tracking for clobbered dregs
netfilter: nft_meta: extend reduce support to bridge family
netfilter: nft_fib: add reduce support
netfilter: nft_exthdr: add reduce support
Pablo Neira Ayuso (12):
netfilter: nf_tables: do not reduce read-only expressions
netfilter: nf_tables: cancel tracking for clobbered destination registers
netfilter: nft_ct: track register operations
netfilter: nft_numgen: cancel register tracking
netfilter: nft_osf: track register operations
netfilter: nft_hash: track register operations
netfilter: nft_immediate: cancel register tracking for data destination register
netfilter: nft_socket: track register operations
netfilter: nft_xfrm: track register operations
netfilter: nft_tunnel: track register operations
netfilter: flowtable: remove redundant field in flow_offload_work struct
netfilter: flowtable: pass flowtable to nf_flow_table_iterate()
Phil Sutter (1):
netfilter: conntrack: Add and use nf_ct_set_auto_assign_helper_warned()
Randy Dunlap (1):
netfilter: nf_nat_h323: eliminate anonymous module_init & module_exit
include/net/netfilter/nf_conntrack_helper.h | 1 + include/net/netfilter/nf_tables.h | 22 ++++++++ include/net/netfilter/nft_fib.h | 3 + include/net/netfilter/nft_meta.h | 3 + net/bridge/netfilter/nft_meta_bridge.c | 5 +- net/bridge/netfilter/nft_reject_bridge.c | 1 + net/ipv4/netfilter/nf_nat_h323.c | 8 +-- net/ipv4/netfilter/nft_dup_ipv4.c | 1 + net/ipv4/netfilter/nft_fib_ipv4.c | 2 + net/ipv4/netfilter/nft_reject_ipv4.c | 1 + net/ipv6/netfilter/nft_dup_ipv6.c | 1 + net/ipv6/netfilter/nft_fib_ipv6.c | 2 + net/ipv6/netfilter/nft_reject_ipv6.c | 1 + net/netfilter/nf_conntrack_core.c | 85 +++++++++++++++++++++++------ net/netfilter/nf_conntrack_helper.c | 6 ++ net/netfilter/nf_flow_table_core.c | 20 +++---- net/netfilter/nf_flow_table_offload.c | 11 ++-- net/netfilter/nf_tables_api.c | 63 ++++++++++++++++++++- net/netfilter/nft_bitwise.c | 24 +++++--- net/netfilter/nft_byteorder.c | 3 +- net/netfilter/nft_cmp.c | 3 + net/netfilter/nft_compat.c | 1 + net/netfilter/nft_connlimit.c | 1 + net/netfilter/nft_counter.c | 1 + net/netfilter/nft_ct.c | 51 +++++++++++++++++ net/netfilter/nft_dup_netdev.c | 1 + net/netfilter/nft_dynset.c | 1 + net/netfilter/nft_exthdr.c | 33 +++++++++++ net/netfilter/nft_fib.c | 42 ++++++++++++++ net/netfilter/nft_fib_inet.c | 1 + net/netfilter/nft_fib_netdev.c | 1 + net/netfilter/nft_flow_offload.c | 1 + net/netfilter/nft_fwd_netdev.c | 2 + net/netfilter/nft_hash.c | 36 ++++++++++++ net/netfilter/nft_immediate.c | 12 ++++ net/netfilter/nft_last.c | 1 + net/netfilter/nft_limit.c | 2 + net/netfilter/nft_log.c | 1 + net/netfilter/nft_lookup.c | 12 ++++ net/netfilter/nft_masq.c | 3 + net/netfilter/nft_meta.c | 19 +++---- net/netfilter/nft_nat.c | 2 + net/netfilter/nft_numgen.c | 22 ++++++++ net/netfilter/nft_objref.c | 2 + net/netfilter/nft_osf.c | 25 +++++++++ net/netfilter/nft_payload.c | 12 ++-- net/netfilter/nft_queue.c | 2 + net/netfilter/nft_quota.c | 1 + net/netfilter/nft_range.c | 1 + net/netfilter/nft_redir.c | 3 + net/netfilter/nft_reject_inet.c | 1 + net/netfilter/nft_reject_netdev.c | 1 + net/netfilter/nft_rt.c | 1 + net/netfilter/nft_socket.c | 28 ++++++++++ net/netfilter/nft_synproxy.c | 1 + net/netfilter/nft_tproxy.c | 1 + net/netfilter/nft_tunnel.c | 28 ++++++++++ net/netfilter/nft_xfrm.c | 28 ++++++++++ 58 files changed, 580 insertions(+), 67 deletions(-)
Pablo Neira Ayuso
maintainerPATCH 1/19 netfilter: conntrack: revisit gc autotuning
From: Florian Westphal <[email protected]>
as of commit 4608fdfc07e1
("netfilter: conntrack: collect all entries in one cycle") conntrack gc was changed to run every 2 minutes.
On systems where conntrack hash table is set to large value, most evictions happen from gc worker rather than the packet path due to hash table distribution.
This causes netlink event overflows when events are collected.
This change collects average expiry of scanned entries and reschedules to the average remaining value, within 1 to 60 second interval.
To avoid event overflows, reschedule after each bucket and add a limit for both run time and number of evictions per run.
If more entries have to be evicted, reschedule and restart 1 jiffy into the future.
--- net/netfilter/nf_conntrack_core.c | 85 ++++++++++++++++++++++++------- 1 file changed, 68 insertions(+), 17 deletions(-)
net/netfilter/nf_conntrack_core.c +68 -17
@@ -66,6 +66,8 @@ EXPORT_SYMBOL_GPL(nf_conntrack_hash);struct conntrack_gc_work {struct delayed_work dwork;u32 next_bucket; +u32 avg_timeout; +u32 start_time;bool exiting;bool early_drop; };
@@ -77,8 +79,19 @@ static __read_mostly bool nf_conntrack_locks_all;/* serialize hash resizes and nf_ct_iterate_cleanup */ static DEFINE_MUTEX (nf_conntrack_mutex); -#define GC_SCAN_INTERVAL (120u * HZ) +#define GC_SCAN_INTERVAL_MAX (60ul * HZ) +#define GC_SCAN_INTERVAL_MIN (1ul * HZ) + +/* clamp timeouts to this value (TCP unacked) */ +#define GC_SCAN_INTERVAL_CLAMP (300ul * HZ) + +/* large initial bias so that we don't scan often just because we have +* three entries with a 1s timeout. +*/ +#define GC_SCAN_INTERVAL_INIT INT_MAX +#define GC_SCAN_MAX_DURATION msecs_to_jiffies(10) +#define GC_SCAN_EXPIRED_MAX (64000u / HZ)#define MIN_CHAINLEN 8u#define MAX_CHAINLEN (32u - MIN_CHAINLEN)
@@ -1420,16 +1433,28 @@ static bool gc_worker_can_early_drop(const struct nf_conn *ct)static void gc_worker (struct work_struct *work) { -unsigned long end_time = jiffies +GC_SCAN_MAX_DURATION ;unsigned int i, hashsz, nf_conntrack_max95 =0 ; -unsigned long next_run =GC_SCAN_INTERVAL ; +u32 end_time, start_time = nfct_time_stamp;struct conntrack_gc_work *gc_work; +unsigned int expired_count =0 ; +unsigned long next_run; +s32 delta_time; + gc_work = container_of(work, struct conntrack_gc_work, dwork.work); i = gc_work->next_bucket;if (gc_work->early_drop) nf_conntrack_max95 = nf_conntrack_max /100u *95u ; +if (i ==0 ) { + gc_work->avg_timeout =GC_SCAN_INTERVAL_INIT ; + gc_work->start_time = start_time; + } + + next_run = gc_work->avg_timeout; + + end_time = start_time +GC_SCAN_MAX_DURATION ; + do { struct nf_conntrack_tuple_hash *h; struct hlist_nulls_head *ct_hash;
@@ -1446,6 +1471,7 @@ static void gc_worker(struct work_struct *work)hlist_nulls_for_each_entry_rcu (h, n, &ct_hash[i], hnnode) {struct nf_conntrack_net *cnet; +unsigned long expires;struct net *net; tmp =nf_ct_tuplehash_to_ctrack (h);
@@ -1455,11 +1481,29 @@ static void gc_worker(struct work_struct *work)continue ; } +if (expired_count >GC_SCAN_EXPIRED_MAX ) { +rcu_read_unlock (); + + gc_work->next_bucket = i; + gc_work->avg_timeout = next_run; + + delta_time = nfct_time_stamp - gc_work->start_time; + +/* re-sched immediately if total cycle time is exceeded */ + next_run = delta_time < (s32 )GC_SCAN_INTERVAL_MAX ; + goto early_exit; + } +if (nf_ct_is_expired (tmp)) {nf_ct_gc_expired (tmp); + expired_count++;continue ; } + expires =clamp (nf_ct_expires (tmp),GC_SCAN_INTERVAL_MIN ,GC_SCAN_INTERVAL_CLAMP ); + next_run += expires; + next_run /=2u ; +if (nf_conntrack_max95 ==0 ||gc_worker_skip_ct (tmp))continue ;
@@ -1477,8 +1521,10 @@ static void gc_worker(struct work_struct *work)continue ; } -if (gc_worker_can_early_drop (tmp)) +if (gc_worker_can_early_drop (tmp)) {nf_ct_kill (tmp); + expired_count++; + }nf_ct_put (tmp); }
@@ -1491,33 +1537,38 @@ static void gc_worker(struct work_struct *work)cond_resched (); i++; -if (time_after (jiffies, end_time) && i < hashsz) { + delta_time = nfct_time_stamp - end_time; +if (delta_time >0 && i < hashsz) { + gc_work->avg_timeout = next_run; gc_work->next_bucket = i; next_run =0 ; -break ; + goto early_exit; } }while (i < hashsz); + gc_work->next_bucket =0 ; + + next_run =clamp (next_run,GC_SCAN_INTERVAL_MIN ,GC_SCAN_INTERVAL_MAX ); + + delta_time =max_t (s32, nfct_time_stamp - gc_work->start_time,1 ); +if (next_run > (unsigned long )delta_time) + next_run -= delta_time; +else + next_run =1 ; + +early_exit:if (gc_work->exiting)return ; -/* -* Eviction will normally happen from the packet path, and not -* from this gc worker. -* -* This worker is only here to reap expired entries when system went -* idle after a busy period. -*/ -if (next_run) { +if (next_run) gc_work->early_drop = false; - gc_work->next_bucket =0 ; - } +queue_delayed_work (system_power_efficient_wq, &gc_work->dwork, next_run); }static void conntrack_gc_work_init (struct conntrack_gc_work *gc_work) { -INIT_DEFERRABLE_WORK (&gc_work->dwork, gc_worker); +INIT_DELAYED_WORK (&gc_work->dwork, gc_worker); gc_work->exiting = false; }
Signature · 1 line
2.30.2
Re: [PATCH net-next 01/19] netfilter: conntrack: revisit gc autotuning
This series was applied to netdev/net-next.git (master) by Pablo Neira Ayuso <[email protected]>:
Hello:
This series was applied to netdev/net-next.git (master) by Pablo Neira Ayuso <[email protected]>:
Quoted 11 lines · On Mon, 21 Mar 2022 13:30:34 +0100 you wrote:
From: Florian Westphal <[email protected]>
as of commit
4608fdfc07e1
("netfilter: conntrack: collect all entries in one cycle") conntrack gc was changed to run every 2 minutes.On systems where conntrack hash table is set to large value, most evictions happen from gc worker rather than the packet path due to hash table distribution.
[...]
Here is the summary with links:
- [net-next,01/19] netfilter: conntrack: revisit gc autotuning
https://git.kernel.org/netdev/net-next/c/2cfadb761d3d - [net-next,02/19] netfilter: conntrack: Add and use nf_ct_set_auto_assign_helper_warned() https://git.kernel.org/netdev/net-next/c/31d0bb9763ef - [net-next,03/19] netfilter: nf_tables: do not reduce read-only expressions https://git.kernel.org/netdev/net-next/c/b2d306542ff9 - [net-next,04/19] netfilter: nf_tables: cancel tracking for clobbered destination registers https://git.kernel.org/netdev/net-next/c/34cc9e52884a - [net-next,05/19] netfilter: nft_ct: track register operations https://git.kernel.org/netdev/net-next/c/03858af0135f - [net-next,06/19] netfilter: nft_lookup: only cancel tracking for clobbered dregs https://git.kernel.org/netdev/net-next/c/e50ae445fb70 - [net-next,07/19] netfilter: nft_meta: extend reduce support to bridge family https://git.kernel.org/netdev/net-next/c/aaa7b20bd4d6 - [net-next,08/19] netfilter: nft_numgen: cancel register tracking https://git.kernel.org/netdev/net-next/c/4e2b29d88168 - [net-next,09/19] netfilter: nft_osf: track register operations https://git.kernel.org/netdev/net-next/c/ffe6488e624e - [net-next,10/19] netfilter: nft_hash: track register operations https://git.kernel.org/netdev/net-next/c/5da03b566626 - [net-next,11/19] netfilter: nft_immediate: cancel register tracking for data destination register https://git.kernel.org/netdev/net-next/c/71ef842d73f6 - [net-next,12/19] netfilter: nft_socket: track register operations https://git.kernel.org/netdev/net-next/c/d77a721d212d - [net-next,13/19] netfilter: nft_xfrm: track register operations https://git.kernel.org/netdev/net-next/c/48f1910326ea - [net-next,14/19] netfilter: nft_tunnel: track register operations https://git.kernel.org/netdev/net-next/c/611580d2df1f - [net-next,15/19] netfilter: nft_fib: add reduce support https://git.kernel.org/netdev/net-next/c/3c1eb413a45b - [net-next,16/19] netfilter: nft_exthdr: add reduce support https://git.kernel.org/netdev/net-next/c/e86dbdb9d461 - [net-next,17/19] netfilter: nf_nat_h323: eliminate anonymous module_init & module_exit https://git.kernel.org/netdev/net-next/c/fd4213929053 - [net-next,18/19] netfilter: flowtable: remove redundant field in flow_offload_work struct https://git.kernel.org/netdev/net-next/c/bb321ed6bbaa - [net-next,19/19] netfilter: flowtable: pass flowtable to nf_flow_table_iterate() https://git.kernel.org/netdev/net-next/c/217cff36e885
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html
Pablo Neira Ayuso
maintainerPATCH 2/19 netfilter: conntrack: Add and use nf_ct_set_auto_assign_helper_warned()
In reply to Pablo Neira AyusoFrom: Phil Sutter <[email protected]>
The function sets the pernet boolean to avoid the spurious warning from nf_ct_lookup_helper() when assigning conntrack helpers via nftables.
--- include/net/netfilter/nf_conntrack_helper.h | 1 + net/netfilter/nf_conntrack_helper.c | 6 ++++++ net/netfilter/nft_ct.c | 3 +++ 3 files changed, 10 insertions(+)
include/net/netfilter/nf_conntrack_helper.h +1 -0
@@ -177,4 +177,5 @@ void nf_nat_helper_unregister(struct nf_conntrack_nat_helper *nat);int nf_nat_helper_try_module_get (const char *name,u16 l3num,u8 protonum);void nf_nat_helper_put (struct nf_conntrack_helper *helper); +void nf_ct_set_auto_assign_helper_warned (struct net *net);#endif /*_NF_CONNTRACK_HELPER_H*/
net/netfilter/nf_conntrack_helper.c +6 -0
@@ -550,6 +550,12 @@ void nf_nat_helper_unregister(struct nf_conntrack_nat_helper *nat) }EXPORT_SYMBOL_GPL (nf_nat_helper_unregister); +void nf_ct_set_auto_assign_helper_warned (struct net *net) +{ +nf_ct_pernet (net)->auto_assign_helper_warned = true; +} +EXPORT_SYMBOL_GPL (nf_ct_set_auto_assign_helper_warned); +void nf_conntrack_helper_pernet_init (struct net *net) {struct nf_conntrack_net *cnet =nf_ct_pernet (net);
net/netfilter/nft_ct.c +3 -0
@@ -1041,6 +1041,9 @@ static int nft_ct_helper_obj_init(const struct nft_ctx *ctx,if (err <0 ) goto err_put_helper; +/* Avoid the bogus warning, helper will be assigned after CT init */ +nf_ct_set_auto_assign_helper_warned (ctx->net); +return 0 ; err_put_helper:
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 3/19 netfilter: nf_tables: do not reduce read-only expressions
In reply to Pablo Neira AyusoSkip register tracking for expressions that perform read-only operations on the registers. Define and use a cookie pointer NFT_REDUCE_READONLY to avoid defining stubs for these expressions.
This patch re-enables register tracking which was disabled in ed5f85d42290 ("netfilter: nf_tables: disable register tracking"). Follow up patches add remaining register tracking for existing expressions.
--- include/net/netfilter/nf_tables.h | 8 ++++++++ net/bridge/netfilter/nft_reject_bridge.c | 1 + net/ipv4/netfilter/nft_dup_ipv4.c | 1 + net/ipv4/netfilter/nft_reject_ipv4.c | 1 + net/ipv6/netfilter/nft_dup_ipv6.c | 1 + net/ipv6/netfilter/nft_reject_ipv6.c | 1 + net/netfilter/nf_tables_api.c | 11 ++++++++++- net/netfilter/nft_cmp.c | 3 +++ net/netfilter/nft_compat.c | 1 + net/netfilter/nft_connlimit.c | 1 + net/netfilter/nft_counter.c | 1 + net/netfilter/nft_ct.c | 1 + net/netfilter/nft_dup_netdev.c | 1 + net/netfilter/nft_dynset.c | 1 + net/netfilter/nft_flow_offload.c | 1 + net/netfilter/nft_fwd_netdev.c | 2 ++ net/netfilter/nft_last.c | 1 + net/netfilter/nft_limit.c | 2 ++ net/netfilter/nft_log.c | 1 + net/netfilter/nft_masq.c | 3 +++ net/netfilter/nft_nat.c | 2 ++ net/netfilter/nft_objref.c | 2 ++ net/netfilter/nft_queue.c | 2 ++ net/netfilter/nft_quota.c | 1 + net/netfilter/nft_range.c | 1 + net/netfilter/nft_redir.c | 3 +++ net/netfilter/nft_reject_inet.c | 1 + net/netfilter/nft_reject_netdev.c | 1 + net/netfilter/nft_rt.c | 1 + net/netfilter/nft_synproxy.c | 1 + net/netfilter/nft_tproxy.c | 1 + 31 files changed, 58 insertions(+), 1 deletion(-)
include/net/netfilter/nf_tables.h +8 -0
@@ -1633,4 +1633,12 @@ static inline struct nftables_pernet *nft_pernet(const struct net *net) return net_generic(net, nf_tables_net_id); } +#define __NFT_REDUCE_READONLY 1UL +#define NFT_REDUCE_READONLY (void *)__NFT_REDUCE_READONLY + +static inline bool nft_reduce_is_readonly (const struct nft_expr *expr) +{ +return expr->ops->reduce ==NFT_REDUCE_READONLY ; +} +#endif /* _NET_NF_TABLES_H */
net/bridge/netfilter/nft_reject_bridge.c +1 -0
@@ -185,6 +185,7 @@ static const struct nft_expr_ops nft_reject_bridge_ops = { .init = nft_reject_init, .dump = nft_reject_dump, .validate = nft_reject_bridge_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_reject_bridge_type__read_mostly = {
net/ipv4/netfilter/nft_dup_ipv4.c +1 -0
@@ -75,6 +75,7 @@ static const struct nft_expr_ops nft_dup_ipv4_ops = { .eval = nft_dup_ipv4_eval, .init = nft_dup_ipv4_init, .dump = nft_dup_ipv4_dump, + .reduce = NFT_REDUCE_READONLY, };static const struct nla_policy nft_dup_ipv4_policy[NFTA_DUP_MAX +1 ] = {
net/ipv4/netfilter/nft_reject_ipv4.c +1 -0
@@ -45,6 +45,7 @@ static const struct nft_expr_ops nft_reject_ipv4_ops = { .init = nft_reject_init, .dump = nft_reject_dump, .validate = nft_reject_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_reject_ipv4_type__read_mostly = {
net/ipv6/netfilter/nft_dup_ipv6.c +1 -0
@@ -73,6 +73,7 @@ static const struct nft_expr_ops nft_dup_ipv6_ops = { .eval = nft_dup_ipv6_eval, .init = nft_dup_ipv6_init, .dump = nft_dup_ipv6_dump, + .reduce = NFT_REDUCE_READONLY, };static const struct nla_policy nft_dup_ipv6_policy[NFTA_DUP_MAX +1 ] = {
net/ipv6/netfilter/nft_reject_ipv6.c +1 -0
@@ -46,6 +46,7 @@ static const struct nft_expr_ops nft_reject_ipv6_ops = { .init = nft_reject_init, .dump = nft_reject_dump, .validate = nft_reject_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_reject_ipv6_type__read_mostly = {
net/netfilter/nf_tables_api.c +10 -1
@@ -8290,7 +8290,16 @@ EXPORT_SYMBOL_GPL(nf_tables_trans_destroy_flush_work);static bool nft_expr_reduce (struct nft_regs_track *track,const struct nft_expr *expr) { -return false; +if (!expr->ops->reduce) { +pr_warn_once ("missing reduce for expression %s " , + expr->ops->type->name); +return false; + } + +if (nft_reduce_is_readonly (expr)) +return false; + +return expr->ops->reduce (track, expr); }static int nf_tables_commit_chain_prepare (struct net *net,struct nft_chain *chain)
net/netfilter/nft_cmp.c +3 -0
@@ -193,6 +193,7 @@ static const struct nft_expr_ops nft_cmp_ops = { .eval = nft_cmp_eval, .init = nft_cmp_init, .dump = nft_cmp_dump, + .reduce = NFT_REDUCE_READONLY, .offload = nft_cmp_offload, };
@@ -269,6 +270,7 @@ const struct nft_expr_ops nft_cmp_fast_ops = { .eval = NULL, /* inlined */ .init = nft_cmp_fast_init, .dump = nft_cmp_fast_dump, + .reduce = NFT_REDUCE_READONLY, .offload = nft_cmp_fast_offload, };
@@ -359,6 +361,7 @@ const struct nft_expr_ops nft_cmp16_fast_ops = { .eval = NULL, /* inlined */ .init = nft_cmp16_fast_init, .dump = nft_cmp16_fast_dump, + .reduce = NFT_REDUCE_READONLY, .offload = nft_cmp16_fast_offload, };
net/netfilter/nft_compat.c +1 -0
@@ -871,6 +871,7 @@ nft_target_select_ops(const struct nft_ctx *ctx, ops->dump = nft_target_dump; ops->validate = nft_target_validate; ops->data = target; + ops->reduce =NFT_REDUCE_READONLY ;if (family ==NFPROTO_BRIDGE ) ops->eval = nft_target_eval_bridge;
net/netfilter/nft_connlimit.c +1 -0
@@ -257,6 +257,7 @@ static const struct nft_expr_ops nft_connlimit_ops = { .destroy_clone = nft_connlimit_destroy_clone, .dump = nft_connlimit_dump, .gc = nft_connlimit_gc, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_connlimit_type__read_mostly = {
net/netfilter/nft_counter.c +1 -0
@@ -293,6 +293,7 @@ static const struct nft_expr_ops nft_counter_ops = { .destroy_clone = nft_counter_destroy, .dump = nft_counter_dump, .clone = nft_counter_clone, + .reduce = NFT_REDUCE_READONLY, .offload = nft_counter_offload, .offload_stats = nft_counter_offload_stats, };
net/netfilter/nft_ct.c +1 -0
@@ -785,6 +785,7 @@ static const struct nft_expr_ops nft_notrack_ops = { .type = &nft_notrack_type, .size = NFT_EXPR_SIZE(0), .eval = nft_notrack_eval, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_notrack_type__read_mostly = {
net/netfilter/nft_dup_netdev.c +1 -0
@@ -79,6 +79,7 @@ static const struct nft_expr_ops nft_dup_netdev_ops = { .eval = nft_dup_netdev_eval, .init = nft_dup_netdev_init, .dump = nft_dup_netdev_dump, + .reduce = NFT_REDUCE_READONLY, .offload = nft_dup_netdev_offload, .offload_action = nft_dup_netdev_offload_action, };
net/netfilter/nft_dynset.c +1 -0
@@ -413,6 +413,7 @@ static const struct nft_expr_ops nft_dynset_ops = { .activate = nft_dynset_activate, .deactivate = nft_dynset_deactivate, .dump = nft_dynset_dump, + .reduce = NFT_REDUCE_READONLY, };struct nft_expr_type nft_dynset_type__read_mostly = {
net/netfilter/nft_flow_offload.c +1 -0
@@ -441,6 +441,7 @@ static const struct nft_expr_ops nft_flow_offload_ops = { .destroy = nft_flow_offload_destroy, .validate = nft_flow_offload_validate, .dump = nft_flow_offload_dump, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_flow_offload_type__read_mostly = {
net/netfilter/nft_fwd_netdev.c +2 -0
@@ -217,6 +217,7 @@ static const struct nft_expr_ops nft_fwd_neigh_netdev_ops = { .init = nft_fwd_neigh_init, .dump = nft_fwd_neigh_dump, .validate = nft_fwd_validate, + .reduce = NFT_REDUCE_READONLY, };static const struct nft_expr_ops nft_fwd_netdev_ops = {
@@ -226,6 +227,7 @@ static const struct nft_expr_ops nft_fwd_netdev_ops = { .init = nft_fwd_netdev_init, .dump = nft_fwd_netdev_dump, .validate = nft_fwd_validate, + .reduce = NFT_REDUCE_READONLY, .offload = nft_fwd_netdev_offload, .offload_action = nft_fwd_netdev_offload_action, };
net/netfilter/nft_last.c +1 -0
@@ -120,6 +120,7 @@ static const struct nft_expr_ops nft_last_ops = { .destroy = nft_last_destroy, .clone = nft_last_clone, .dump = nft_last_dump, + .reduce = NFT_REDUCE_READONLY, };struct nft_expr_type nft_last_type__read_mostly = {
net/netfilter/nft_limit.c +2 -0
@@ -225,6 +225,7 @@ static const struct nft_expr_ops nft_limit_pkts_ops = { .destroy = nft_limit_pkts_destroy, .clone = nft_limit_pkts_clone, .dump = nft_limit_pkts_dump, + .reduce = NFT_REDUCE_READONLY, }; static void nft_limit_bytes_eval(const struct nft_expr *expr,
@@ -279,6 +280,7 @@ static const struct nft_expr_ops nft_limit_bytes_ops = { .dump = nft_limit_bytes_dump, .clone = nft_limit_bytes_clone, .destroy = nft_limit_bytes_destroy, + .reduce = NFT_REDUCE_READONLY, }; static const struct nft_expr_ops *
net/netfilter/nft_log.c +1 -0
@@ -290,6 +290,7 @@ static const struct nft_expr_ops nft_log_ops = { .init = nft_log_init, .destroy = nft_log_destroy, .dump = nft_log_dump, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_log_type__read_mostly = {
net/netfilter/nft_masq.c +3 -0
@@ -129,6 +129,7 @@ static const struct nft_expr_ops nft_masq_ipv4_ops = { .destroy = nft_masq_ipv4_destroy, .dump = nft_masq_dump, .validate = nft_masq_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_masq_ipv4_type__read_mostly = {
@@ -175,6 +176,7 @@ static const struct nft_expr_ops nft_masq_ipv6_ops = { .destroy = nft_masq_ipv6_destroy, .dump = nft_masq_dump, .validate = nft_masq_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_masq_ipv6_type__read_mostly = {
@@ -230,6 +232,7 @@ static const struct nft_expr_ops nft_masq_inet_ops = { .destroy = nft_masq_inet_destroy, .dump = nft_masq_dump, .validate = nft_masq_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_masq_inet_type__read_mostly = {
net/netfilter/nft_nat.c +2 -0
@@ -317,6 +317,7 @@ static const struct nft_expr_ops nft_nat_ops = { .destroy = nft_nat_destroy, .dump = nft_nat_dump, .validate = nft_nat_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_nat_type__read_mostly = {
@@ -346,6 +347,7 @@ static const struct nft_expr_ops nft_nat_inet_ops = { .destroy = nft_nat_destroy, .dump = nft_nat_dump, .validate = nft_nat_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_inet_nat_type__read_mostly = {
net/netfilter/nft_objref.c +2 -0
@@ -91,6 +91,7 @@ static const struct nft_expr_ops nft_objref_ops = { .activate = nft_objref_activate, .deactivate = nft_objref_deactivate, .dump = nft_objref_dump, + .reduce = NFT_REDUCE_READONLY, };struct nft_objref_map {
@@ -204,6 +205,7 @@ static const struct nft_expr_ops nft_objref_map_ops = { .deactivate = nft_objref_map_deactivate, .destroy = nft_objref_map_destroy, .dump = nft_objref_map_dump, + .reduce = NFT_REDUCE_READONLY, }; static const struct nft_expr_ops *
net/netfilter/nft_queue.c +2 -0
@@ -164,6 +164,7 @@ static const struct nft_expr_ops nft_queue_ops = { .eval = nft_queue_eval, .init = nft_queue_init, .dump = nft_queue_dump, + .reduce = NFT_REDUCE_READONLY, };static const struct nft_expr_ops nft_queue_sreg_ops = {
@@ -172,6 +173,7 @@ static const struct nft_expr_ops nft_queue_sreg_ops = { .eval = nft_queue_sreg_eval, .init = nft_queue_sreg_init, .dump = nft_queue_sreg_dump, + .reduce = NFT_REDUCE_READONLY, }; static const struct nft_expr_ops *
net/netfilter/nft_quota.c +1 -0
@@ -254,6 +254,7 @@ static const struct nft_expr_ops nft_quota_ops = { .destroy = nft_quota_destroy, .clone = nft_quota_clone, .dump = nft_quota_dump, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_quota_type__read_mostly = {
net/netfilter/nft_range.c +1 -0
@@ -140,6 +140,7 @@ static const struct nft_expr_ops nft_range_ops = { .eval = nft_range_eval, .init = nft_range_init, .dump = nft_range_dump, + .reduce = NFT_REDUCE_READONLY, };struct nft_expr_type nft_range_type__read_mostly = {
net/netfilter/nft_redir.c +3 -0
@@ -134,6 +134,7 @@ static const struct nft_expr_ops nft_redir_ipv4_ops = { .destroy = nft_redir_ipv4_destroy, .dump = nft_redir_dump, .validate = nft_redir_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_redir_ipv4_type__read_mostly = {
@@ -183,6 +184,7 @@ static const struct nft_expr_ops nft_redir_ipv6_ops = { .destroy = nft_redir_ipv6_destroy, .dump = nft_redir_dump, .validate = nft_redir_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_redir_ipv6_type__read_mostly = {
@@ -225,6 +227,7 @@ static const struct nft_expr_ops nft_redir_inet_ops = { .destroy = nft_redir_inet_destroy, .dump = nft_redir_dump, .validate = nft_redir_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_redir_inet_type__read_mostly = {
net/netfilter/nft_reject_inet.c +1 -0
@@ -80,6 +80,7 @@ static const struct nft_expr_ops nft_reject_inet_ops = { .init = nft_reject_init, .dump = nft_reject_dump, .validate = nft_reject_inet_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_reject_inet_type__read_mostly = {
net/netfilter/nft_reject_netdev.c +1 -0
@@ -159,6 +159,7 @@ static const struct nft_expr_ops nft_reject_netdev_ops = { .init = nft_reject_init, .dump = nft_reject_dump, .validate = nft_reject_netdev_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_reject_netdev_type__read_mostly = {
net/netfilter/nft_rt.c +1 -0
@@ -191,6 +191,7 @@ static const struct nft_expr_ops nft_rt_get_ops = { .init = nft_rt_get_init, .dump = nft_rt_get_dump, .validate = nft_rt_validate, + .reduce = NFT_REDUCE_READONLY, };struct nft_expr_type nft_rt_type__read_mostly = {
net/netfilter/nft_synproxy.c +1 -0
@@ -288,6 +288,7 @@ static const struct nft_expr_ops nft_synproxy_ops = { .dump = nft_synproxy_dump, .type = &nft_synproxy_type, .validate = nft_synproxy_validate, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_synproxy_type__read_mostly = {
net/netfilter/nft_tproxy.c +1 -0
@@ -320,6 +320,7 @@ static const struct nft_expr_ops nft_tproxy_ops = { .init = nft_tproxy_init, .destroy = nft_tproxy_destroy, .dump = nft_tproxy_dump, + .reduce = NFT_REDUCE_READONLY, };static struct nft_expr_type nft_tproxy_type__read_mostly = {
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 4/19 netfilter: nf_tables: cancel tracking for clobbered destination registers
In reply to Pablo Neira AyusoOutput of expressions might be larger than one single register, this might clobber existing data. Reset tracking for all destination registers that required to store the expression output.
This patch adds three new helper functions:
- nft_reg_track_update: cancel previous register tracking and update it.
- nft_reg_track_cancel: cancel any previous register tracking info.
- __nft_reg_track_cancel: cancel only one single register tracking info.
Partial register clobbering detection is also supported by checking the .num_reg field which describes the number of register that are used.
This patch updates the following expressions:
- meta_bridge
- bitwise
- byteorder
- meta
- payload
to use these helper functions.
--- include/net/netfilter/nf_tables.h | 14 +++++++ include/net/netfilter/nft_meta.h | 1 + net/bridge/netfilter/nft_meta_bridge.c | 4 +- net/netfilter/nf_tables_api.c | 52 ++++++++++++++++++++++++++ net/netfilter/nft_bitwise.c | 23 ++++++++---- net/netfilter/nft_byteorder.c | 3 +- net/netfilter/nft_meta.c | 14 +++---- net/netfilter/nft_payload.c | 12 ++---- 8 files changed, 95 insertions(+), 28 deletions(-)
include/net/netfilter/nf_tables.h +14 -0
@@ -126,6 +126,7 @@ struct nft_regs_track {struct {const struct nft_expr *selector;const struct nft_expr *bitwise; +u8 num_reg; } regs[NFT_REG32_NUM ];const struct nft_expr *cur;
@@ -1641,4 +1642,17 @@ static inline bool nft_reduce_is_readonly(const struct nft_expr *expr) return expr->ops->reduce == NFT_REDUCE_READONLY; } +void nft_reg_track_update (struct nft_regs_track *track, +const struct nft_expr *expr,u8 dreg,u8 len); +void nft_reg_track_cancel (struct nft_regs_track *track,u8 dreg,u8 len); +void __nft_reg_track_cancel (struct nft_regs_track *track,u8 dreg); + +static inline bool nft_reg_track_cmp (struct nft_regs_track *track, +const struct nft_expr *expr,u8 dreg) +{ +return track->regs[dreg].selector && + track->regs[dreg].selector->ops == expr->ops && + track->regs[dreg].num_reg ==0 ; +} +#endif /* _NET_NF_TABLES_H */
include/net/netfilter/nft_meta.h +1 -0
@@ -6,6 +6,7 @@struct nft_meta {enum nft_meta_keys key:8 ; +u8 len;union {u8 dreg;u8 sreg;
net/bridge/netfilter/nft_meta_bridge.c +2 -2
@@ -87,6 +87,7 @@ static int nft_meta_bridge_get_init(const struct nft_ctx *ctx,return nft_meta_get_init (ctx, expr, tb); } + priv->len = len;return nft_parse_register_store (ctx, tb[NFTA_META_DREG ], &priv->dreg,NULL ,NFT_DATA_VALUE , len); }
@@ -112,8 +113,7 @@ static bool nft_meta_bridge_set_reduce(struct nft_regs_track *track,if (track->regs[i].selector->ops != &nft_meta_bridge_get_ops)continue ; - track->regs[i].selector =NULL ; - track->regs[i].bitwise =NULL ; +__nft_reg_track_cancel (track, i); }return false;
net/netfilter/nf_tables_api.c +52 -0
58 lines not on this page · raw message
net/netfilter/nft_bitwise.c +15 -8
@@ -283,12 +283,16 @@ static bool nft_bitwise_reduce(struct nft_regs_track *track, {const struct nft_bitwise *priv =nft_expr_priv (expr);const struct nft_bitwise *bitwise; +unsigned int regcount; +u8 dreg; +int i;if (!track->regs[priv->sreg].selector)return false; bitwise =nft_expr_priv (expr); if (track->regs[priv->sreg].selector == track->regs[priv->dreg].selector && + track->regs[priv->sreg].num_reg == 0 && track->regs[priv->dreg].bitwise && track->regs[priv->dreg].bitwise->ops == expr->ops && priv->sreg == bitwise->sreg &&
@@ -302,17 +306,21 @@ static bool nft_bitwise_reduce(struct nft_regs_track *track,return true; } -if (track->regs[priv->sreg].bitwise) { - track->regs[priv->dreg].selector =NULL ; - track->regs[priv->dreg].bitwise =NULL ; +if (track->regs[priv->sreg].bitwise || + track->regs[priv->sreg].num_reg !=0 ) { +nft_reg_track_cancel (track, priv->dreg, priv->len);return false; }if (priv->sreg != priv->dreg) { - track->regs[priv->dreg].selector = - track->regs[priv->sreg].selector; +nft_reg_track_update (track, track->regs[priv->sreg].selector, + priv->dreg, priv->len); } - track->regs[priv->dreg].bitwise = expr; + + dreg = priv->dreg; + regcount =DIV_ROUND_UP (priv->len,NFT_REG32_SIZE ); +for (i =0 ; i < regcount; i++, dreg++) + track->regs[priv->dreg].bitwise = expr;return false; }
@@ -447,8 +455,7 @@ static bool nft_bitwise_fast_reduce(struct nft_regs_track *track, }if (track->regs[priv->sreg].bitwise) { - track->regs[priv->dreg].selector =NULL ; - track->regs[priv->dreg].bitwise =NULL ; +nft_reg_track_cancel (track, priv->dreg,NFT_REG32_SIZE );return false; }
net/netfilter/nft_byteorder.c +1 -2
@@ -172,8 +172,7 @@ static bool nft_byteorder_reduce(struct nft_regs_track *track, {struct nft_byteorder *priv =nft_expr_priv (expr); - track->regs[priv->dreg].selector =NULL ; - track->regs[priv->dreg].bitwise =NULL ; +nft_reg_track_cancel (track, priv->dreg, priv->len);return false; }
net/netfilter/nft_meta.c +6 -8
@@ -539,6 +539,7 @@ int nft_meta_get_init(const struct nft_ctx *ctx,return -EOPNOTSUPP ; } + priv->len = len;return nft_parse_register_store (ctx, tb[NFTA_META_DREG ], &priv->dreg,NULL ,NFT_DATA_VALUE , len); }
@@ -664,6 +665,7 @@ int nft_meta_set_init(const struct nft_ctx *ctx,return -EOPNOTSUPP ; } + priv->len = len; err =nft_parse_register_load (tb[NFTA_META_SREG ], &priv->sreg, len);if (err <0 )return err;
@@ -756,18 +758,15 @@ static bool nft_meta_get_reduce(struct nft_regs_track *track,const struct nft_meta *priv =nft_expr_priv (expr);const struct nft_meta *meta; -if (!track->regs[priv->dreg].selector || - track->regs[priv->dreg].selector->ops != expr->ops) { - track->regs[priv->dreg].selector = expr; - track->regs[priv->dreg].bitwise =NULL ; +if (!nft_reg_track_cmp (track, expr, priv->dreg)) { +nft_reg_track_update (track, expr, priv->dreg, priv->len);return false; } meta =nft_expr_priv (track->regs[priv->dreg].selector);if (priv->key != meta->key || priv->dreg != meta->dreg) { - track->regs[priv->dreg].selector = expr; - track->regs[priv->dreg].bitwise =NULL ; +nft_reg_track_update (track, expr, priv->dreg, priv->len);return false; }
@@ -800,8 +799,7 @@ static bool nft_meta_set_reduce(struct nft_regs_track *track,if (track->regs[i].selector->ops != &nft_meta_get_ops)continue ; - track->regs[i].selector =NULL ; - track->regs[i].bitwise =NULL ; +__nft_reg_track_cancel (track, i); }return false;
net/netfilter/nft_payload.c +4 -8
@@ -216,10 +216,8 @@ static bool nft_payload_reduce(struct nft_regs_track *track,const struct nft_payload *priv =nft_expr_priv (expr);const struct nft_payload *payload; -if (!track->regs[priv->dreg].selector || - track->regs[priv->dreg].selector->ops != expr->ops) { - track->regs[priv->dreg].selector = expr; - track->regs[priv->dreg].bitwise =NULL ; +if (!nft_reg_track_cmp (track, expr, priv->dreg)) { +nft_reg_track_update (track, expr, priv->dreg, priv->len);return false; }
@@ -227,8 +225,7 @@ static bool nft_payload_reduce(struct nft_regs_track *track,if (priv->base != payload->base || priv->offset != payload->offset || priv->len != payload->len) { - track->regs[priv->dreg].selector = expr; - track->regs[priv->dreg].bitwise =NULL ; +nft_reg_track_update (track, expr, priv->dreg, priv->len);return false; }
@@ -815,8 +812,7 @@ static bool nft_payload_set_reduce(struct nft_regs_track *track, track->regs[i].selector->ops != &nft_payload_fast_ops) continue; - track->regs[i].selector =NULL ; - track->regs[i].bitwise =NULL ; +__nft_reg_track_cancel (track, i); }return false;
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 5/19 netfilter: nft_ct: track register operations
In reply to Pablo Neira AyusoCheck if the destination register already contains the data that this ct expression performs. This allows to skip this redundant operation. If the destination contains a different selector, update the register tracking information.
Export nft_expr_reduce_bitwise as a symbol since nft_ct might be compiled as a module.
--- net/netfilter/nft_bitwise.c | 1 + net/netfilter/nft_ct.c | 47 +++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+)
net/netfilter/nft_bitwise.c +1 -0
@@ -529,3 +529,4 @@ bool nft_expr_reduce_bitwise(struct nft_regs_track *track,return false; } +EXPORT_SYMBOL_GPL (nft_expr_reduce_bitwise);
net/netfilter/nft_ct.c +47 -0
91 lines not on this page · raw message
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 6/19 netfilter: nft_lookup: only cancel tracking for clobbered dregs
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
In most cases, nft_lookup will be read-only, i.e. won't clobber registers. In case of map, we need to cancel the registers that will see stores.
--- net/netfilter/nft_lookup.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
net/netfilter/nft_lookup.c +12 -0
@@ -253,6 +253,17 @@ static int nft_lookup_validate(const struct nft_ctx *ctx,return 0 ; } +static bool nft_lookup_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_lookup *priv =nft_expr_priv (expr); + +if (priv->set->flags &NFT_SET_MAP ) +nft_reg_track_cancel (track, priv->dreg, priv->set->dlen); + +return false; +} +static const struct nft_expr_ops nft_lookup_ops = { .type = &nft_lookup_type, .size =NFT_EXPR_SIZE (sizeof (struct nft_lookup )),
@@ -263,6 +274,7 @@ static const struct nft_expr_ops nft_lookup_ops = { .destroy = nft_lookup_destroy, .dump = nft_lookup_dump, .validate = nft_lookup_validate, + .reduce = nft_lookup_reduce, };struct nft_expr_type nft_lookup_type__read_mostly = {
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 7/19 netfilter: nft_meta: extend reduce support to bridge family
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
its enough to export the meta get reduce helper and then call it from nft_meta_bridge too.
--- include/net/netfilter/nft_meta.h | 2 ++ net/bridge/netfilter/nft_meta_bridge.c | 1 + net/netfilter/nft_meta.c | 5 +++-- 3 files changed, 6 insertions(+), 2 deletions(-)
include/net/netfilter/nft_meta.h +2 -0
@@ -44,4 +44,6 @@ int nft_meta_set_validate(const struct nft_ctx *ctx,const struct nft_expr *expr, const struct nft_data **data); +bool nft_meta_get_reduce (struct nft_regs_track *track, +const struct nft_expr *expr);#endif
net/bridge/netfilter/nft_meta_bridge.c +1 -0
@@ -99,6 +99,7 @@ static const struct nft_expr_ops nft_meta_bridge_get_ops = { .eval = nft_meta_bridge_get_eval, .init = nft_meta_bridge_get_init, .dump = nft_meta_get_dump, + .reduce = nft_meta_get_reduce, }; static bool nft_meta_bridge_set_reduce(struct nft_regs_track *track,
net/netfilter/nft_meta.c +3 -2
@@ -752,8 +752,8 @@ static int nft_meta_get_offload(struct nft_offload_ctx *ctx,return 0 ; } -static bool nft_meta_get_reduce (struct nft_regs_track *track, -const struct nft_expr *expr) +bool nft_meta_get_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) {const struct nft_meta *priv =nft_expr_priv (expr);const struct nft_meta *meta;
@@ -775,6 +775,7 @@ static bool nft_meta_get_reduce(struct nft_regs_track *track,return nft_expr_reduce_bitwise (track, expr); } +EXPORT_SYMBOL_GPL (nft_meta_get_reduce);static const struct nft_expr_ops nft_meta_get_ops = { .type = &nft_meta_type,
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 8/19 netfilter: nft_numgen: cancel register tracking
In reply to Pablo Neira AyusoRandom and increment are stateful, each invocation results in fresh output. Cancel register tracking for these two expressions.
--- net/netfilter/nft_numgen.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)
net/netfilter/nft_numgen.c +22 -0
@@ -85,6 +85,16 @@ static int nft_ng_inc_init(const struct nft_ctx *ctx,return err; } +static bool nft_ng_inc_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_ng_inc *priv =nft_expr_priv (expr); + +nft_reg_track_cancel (track, priv->dreg,NFT_REG32_SIZE ); + +return false; +} +static int nft_ng_dump (struct sk_buff *skb,enum nft_registers dreg,u32 modulus,enum nft_ng_types type,u32 offset) {
@@ -172,6 +182,16 @@ static int nft_ng_random_dump(struct sk_buff *skb, const struct nft_expr *expr) priv->offset); } +static bool nft_ng_random_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_ng_random *priv =nft_expr_priv (expr); + +nft_reg_track_cancel (track, priv->dreg,NFT_REG32_SIZE ); + +return false; +} +static struct nft_expr_type nft_ng_type;static const struct nft_expr_ops nft_ng_inc_ops = { .type = &nft_ng_type,
@@ -180,6 +200,7 @@ static const struct nft_expr_ops nft_ng_inc_ops = { .init = nft_ng_inc_init, .destroy = nft_ng_inc_destroy, .dump = nft_ng_inc_dump, + .reduce = nft_ng_inc_reduce, };static const struct nft_expr_ops nft_ng_random_ops = {
@@ -188,6 +209,7 @@ static const struct nft_expr_ops nft_ng_random_ops = { .eval = nft_ng_random_eval, .init = nft_ng_random_init, .dump = nft_ng_random_dump, + .reduce = nft_ng_random_reduce, }; static const struct nft_expr_ops *
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 9/19 netfilter: nft_osf: track register operations
In reply to Pablo Neira AyusoAllow to recycle the previous output of the OS fingerprint expression if flags and ttl are the same.
--- net/netfilter/nft_osf.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
net/netfilter/nft_osf.c +25 -0
@@ -120,6 +120,30 @@ static int nft_osf_validate(const struct nft_ctx *ctx, (1 << NF_INET_FORWARD)); } +static bool nft_osf_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +struct nft_osf *priv =nft_expr_priv (expr); +struct nft_osf *osf; + +if (!nft_reg_track_cmp (track, expr, priv->dreg)) { +nft_reg_track_update (track, expr, priv->dreg,NFT_OSF_MAXGENRELEN ); +return false; + } + + osf =nft_expr_priv (track->regs[priv->dreg].selector); +if (priv->flags != osf->flags || + priv->ttl != osf->ttl) { +nft_reg_track_update (track, expr, priv->dreg,NFT_OSF_MAXGENRELEN ); +return false; + } + +if (!track->regs[priv->dreg].bitwise) +return true; + +return false; +} +static struct nft_expr_type nft_osf_type;static const struct nft_expr_ops nft_osf_op = { .eval = nft_osf_eval,
@@ -128,6 +152,7 @@ static const struct nft_expr_ops nft_osf_op = { .dump = nft_osf_dump, .type = &nft_osf_type, .validate = nft_osf_validate, + .reduce = nft_osf_reduce, };static struct nft_expr_type nft_osf_type__read_mostly = {
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 10/19 netfilter: nft_hash: track register operations
In reply to Pablo Neira AyusoCheck if the destination register already contains the data that this osf expression performs. Always cancel register tracking for jhash since this requires tracking multiple source registers in case of concatenations. Perform register tracking (without bitwise) for symhash since input does not come from source register.
--- net/netfilter/nft_hash.c | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+)
net/netfilter/nft_hash.c +36 -0
@@ -165,6 +165,16 @@ static int nft_jhash_dump(struct sk_buff *skb,return -1 ; } +static bool nft_jhash_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_jhash *priv =nft_expr_priv (expr); + +nft_reg_track_cancel (track, priv->dreg,sizeof (u32)); + +return false; +} +static int nft_symhash_dump (struct sk_buff *skb,const struct nft_expr *expr) {
@@ -185,6 +195,30 @@ static int nft_symhash_dump(struct sk_buff *skb,return -1 ; } +static bool nft_symhash_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +struct nft_symhash *priv =nft_expr_priv (expr); +struct nft_symhash *symhash; + +if (!nft_reg_track_cmp (track, expr, priv->dreg)) { +nft_reg_track_update (track, expr, priv->dreg,sizeof (u32)); +return false; + } + + symhash =nft_expr_priv (track->regs[priv->dreg].selector); +if (priv->offset != symhash->offset || + priv->modulus != symhash->modulus) { +nft_reg_track_update (track, expr, priv->dreg,sizeof (u32)); +return false; + } + +if (!track->regs[priv->dreg].bitwise) +return true; + +return false; +} +static struct nft_expr_type nft_hash_type;static const struct nft_expr_ops nft_jhash_ops = { .type = &nft_hash_type,
@@ -192,6 +226,7 @@ static const struct nft_expr_ops nft_jhash_ops = { .eval = nft_jhash_eval, .init = nft_jhash_init, .dump = nft_jhash_dump, + .reduce = nft_jhash_reduce, };static const struct nft_expr_ops nft_symhash_ops = {
@@ -200,6 +235,7 @@ static const struct nft_expr_ops nft_symhash_ops = { .eval = nft_symhash_eval, .init = nft_symhash_init, .dump = nft_symhash_dump, + .reduce = nft_symhash_reduce, }; static const struct nft_expr_ops *
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 11/19 netfilter: nft_immediate: cancel register tracking for data destination register
In reply to Pablo Neira AyusoThe immediate expression might clobber existing data on the registers, cancel register tracking for the destination register.
--- net/netfilter/nft_immediate.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
net/netfilter/nft_immediate.c +12 -0
@@ -223,6 +223,17 @@ static bool nft_immediate_offload_action(const struct nft_expr *expr)return false; } +static bool nft_immediate_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_immediate_expr *priv =nft_expr_priv (expr); + +if (priv->dreg !=NFT_REG_VERDICT ) +nft_reg_track_cancel (track, priv->dreg, priv->dlen); + +return false; +} +static const struct nft_expr_ops nft_imm_ops = { .type = &nft_imm_type, .size =NFT_EXPR_SIZE (sizeof (struct nft_immediate_expr )),
@@ -233,6 +244,7 @@ static const struct nft_expr_ops nft_imm_ops = { .destroy = nft_immediate_destroy, .dump = nft_immediate_dump, .validate = nft_immediate_validate, + .reduce = nft_immediate_reduce, .offload = nft_immediate_offload, .offload_action = nft_immediate_offload_action, };
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 12/19 netfilter: nft_socket: track register operations
In reply to Pablo Neira AyusoCheck if the destination register already contains the data that this socket expression performs. This allows to skip this redundant operation. If the destination contains a different selector, update the register tracking information.
--- net/netfilter/nft_socket.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
net/netfilter/nft_socket.c +28 -0
@@ -10,6 +10,7 @@struct nft_socket {enum nft_socket_keys key:8 ;u8 level; +u8 len;union {u8 dreg; };
@@ -179,6 +180,7 @@ static int nft_socket_init(const struct nft_ctx *ctx,return -EOPNOTSUPP ; } + priv->len = len;return nft_parse_register_store (ctx, tb[NFTA_SOCKET_DREG ], &priv->dreg,NULL ,NFT_DATA_VALUE , len); }
@@ -198,6 +200,31 @@ static int nft_socket_dump(struct sk_buff *skb,return 0 ; } +static bool nft_socket_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_socket *priv =nft_expr_priv (expr); +const struct nft_socket *socket; + +if (!nft_reg_track_cmp (track, expr, priv->dreg)) { +nft_reg_track_update (track, expr, priv->dreg, priv->len); +return false; + } + + socket =nft_expr_priv (track->regs[priv->dreg].selector); +if (priv->key != socket->key || + priv->dreg != socket->dreg || + priv->level != socket->level) { +nft_reg_track_update (track, expr, priv->dreg, priv->len); +return false; + } + +if (!track->regs[priv->dreg].bitwise) +return true; + +return nft_expr_reduce_bitwise (track, expr); +} +static struct nft_expr_type nft_socket_type;static const struct nft_expr_ops nft_socket_ops = { .type = &nft_socket_type,
@@ -205,6 +232,7 @@ static const struct nft_expr_ops nft_socket_ops = { .eval = nft_socket_eval, .init = nft_socket_init, .dump = nft_socket_dump, + .reduce = nft_socket_reduce, };static struct nft_expr_type nft_socket_type__read_mostly = {
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 13/19 netfilter: nft_xfrm: track register operations
In reply to Pablo Neira AyusoCheck if the destination register already contains the data that this xfrm expression performs. This allows to skip this redundant operation. If the destination contains a different selector, update the register tracking information.
--- net/netfilter/nft_xfrm.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
net/netfilter/nft_xfrm.c +28 -0
@@ -27,6 +27,7 @@ struct nft_xfrm {u8 dreg;u8 dir;u8 spnum; +u8 len; }; static int nft_xfrm_get_init(const struct nft_ctx *ctx,
@@ -86,6 +87,7 @@ static int nft_xfrm_get_init(const struct nft_ctx *ctx, priv->spnum = spnum; + priv->len = len;return nft_parse_register_store (ctx, tb[NFTA_XFRM_DREG ], &priv->dreg,NULL ,NFT_DATA_VALUE , len); }
@@ -252,6 +254,31 @@ static int nft_xfrm_validate(const struct nft_ctx *ctx, const struct nft_expr *ereturn nft_chain_validate_hooks (ctx->chain, hooks); } +static bool nft_xfrm_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_xfrm *priv =nft_expr_priv (expr); +const struct nft_xfrm *xfrm; + +if (!nft_reg_track_cmp (track, expr, priv->dreg)) { +nft_reg_track_update (track, expr, priv->dreg, priv->len); +return false; + } + + xfrm =nft_expr_priv (track->regs[priv->dreg].selector); +if (priv->key != xfrm->key || + priv->dreg != xfrm->dreg || + priv->dir != xfrm->dir || + priv->spnum != xfrm->spnum) { +nft_reg_track_update (track, expr, priv->dreg, priv->len); +return false; + } + +if (!track->regs[priv->dreg].bitwise) +return true; + +return nft_expr_reduce_bitwise (track, expr); +}static struct nft_expr_type nft_xfrm_type;static const struct nft_expr_ops nft_xfrm_get_ops = {
@@ -261,6 +288,7 @@ static const struct nft_expr_ops nft_xfrm_get_ops = { .init = nft_xfrm_get_init, .dump = nft_xfrm_get_dump, .validate = nft_xfrm_validate, + .reduce = nft_xfrm_reduce, };static struct nft_expr_type nft_xfrm_type__read_mostly = {
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 14/19 netfilter: nft_tunnel: track register operations
In reply to Pablo Neira AyusoCheck if the destination register already contains the data that this tunnel expression performs. This allows to skip this redundant operation. If the destination contains a different selector, update the register tracking information. This patch does not perform bitwise tracking.
--- net/netfilter/nft_tunnel.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
net/netfilter/nft_tunnel.c +28 -0
@@ -17,6 +17,7 @@ struct nft_tunnel { enum nft_tunnel_keys key:8;u8 dreg; enum nft_tunnel_mode mode:8; +u8 len; }; static void nft_tunnel_get_eval(const struct nft_expr *expr,
@@ -101,6 +102,7 @@ static int nft_tunnel_get_init(const struct nft_ctx *ctx, priv->mode =NFT_TUNNEL_MODE_NONE ; } + priv->len = len;return nft_parse_register_store (ctx, tb[NFTA_TUNNEL_DREG ], &priv->dreg,NULL ,NFT_DATA_VALUE , len); }
@@ -122,6 +124,31 @@ static int nft_tunnel_get_dump(struct sk_buff *skb,return -1 ; } +static bool nft_tunnel_get_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_tunnel *priv =nft_expr_priv (expr); +const struct nft_tunnel *tunnel; + +if (!nft_reg_track_cmp (track, expr, priv->dreg)) { +nft_reg_track_update (track, expr, priv->dreg, priv->len); +return false; + } + + tunnel =nft_expr_priv (track->regs[priv->dreg].selector); +if (priv->key != tunnel->key || + priv->dreg != tunnel->dreg || + priv->mode != tunnel->mode) { +nft_reg_track_update (track, expr, priv->dreg, priv->len); +return false; + } + +if (!track->regs[priv->dreg].bitwise) +return true; + +return false; +} +static struct nft_expr_type nft_tunnel_type;static const struct nft_expr_ops nft_tunnel_get_ops = { .type = &nft_tunnel_type,
@@ -129,6 +156,7 @@ static const struct nft_expr_ops nft_tunnel_get_ops = { .eval = nft_tunnel_get_eval, .init = nft_tunnel_get_init, .dump = nft_tunnel_get_dump, + .reduce = nft_tunnel_get_reduce, };static struct nft_expr_type nft_tunnel_type__read_mostly = {
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 15/19 netfilter: nft_fib: add reduce support
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
The fib expression stores to a register, so we can't add empty stub. Check that the register that is being written is in fact redundant.
In most cases, this is expected to cancel tracking as re-use is unlikely.
--- include/net/netfilter/nft_fib.h | 3 +++ net/ipv4/netfilter/nft_fib_ipv4.c | 2 ++ net/ipv6/netfilter/nft_fib_ipv6.c | 2 ++ net/netfilter/nft_fib.c | 42 +++++++++++++++++++++++++++++++ net/netfilter/nft_fib_inet.c | 1 + net/netfilter/nft_fib_netdev.c | 1 + 6 files changed, 51 insertions(+)
include/net/netfilter/nft_fib.h +3 -0
@@ -37,4 +37,7 @@ void nft_fib6_eval(const struct nft_expr *expr, struct nft_regs *regs,void nft_fib_store_result (void *reg,const struct nft_fib *priv,const struct net_device *dev); + +bool nft_fib_reduce (struct nft_regs_track *track, +const struct nft_expr *expr);#endif
net/ipv4/netfilter/nft_fib_ipv4.c +2 -0
@@ -152,6 +152,7 @@ static const struct nft_expr_ops nft_fib4_type_ops = { .init = nft_fib_init, .dump = nft_fib_dump, .validate = nft_fib_validate, + .reduce = nft_fib_reduce, };static const struct nft_expr_ops nft_fib4_ops = {
@@ -161,6 +162,7 @@ static const struct nft_expr_ops nft_fib4_ops = { .init = nft_fib_init, .dump = nft_fib_dump, .validate = nft_fib_validate, + .reduce = nft_fib_reduce, }; static const struct nft_expr_ops *
net/ipv6/netfilter/nft_fib_ipv6.c +2 -0
@@ -211,6 +211,7 @@ static const struct nft_expr_ops nft_fib6_type_ops = { .init = nft_fib_init, .dump = nft_fib_dump, .validate = nft_fib_validate, + .reduce = nft_fib_reduce, };static const struct nft_expr_ops nft_fib6_ops = {
@@ -220,6 +221,7 @@ static const struct nft_expr_ops nft_fib6_ops = { .init = nft_fib_init, .dump = nft_fib_dump, .validate = nft_fib_validate, + .reduce = nft_fib_reduce, }; static const struct nft_expr_ops *
net/netfilter/nft_fib.c +42 -0
47 lines not on this page · raw message
net/netfilter/nft_fib_inet.c +1 -0
@@ -49,6 +49,7 @@ static const struct nft_expr_ops nft_fib_inet_ops = { .init = nft_fib_init, .dump = nft_fib_dump, .validate = nft_fib_validate, + .reduce = nft_fib_reduce, };static struct nft_expr_type nft_fib_inet_type__read_mostly = {
net/netfilter/nft_fib_netdev.c +1 -0
@@ -58,6 +58,7 @@ static const struct nft_expr_ops nft_fib_netdev_ops = { .init = nft_fib_init, .dump = nft_fib_dump, .validate = nft_fib_validate, + .reduce = nft_fib_reduce, };static struct nft_expr_type nft_fib_netdev_type__read_mostly = {
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 16/19 netfilter: nft_exthdr: add reduce support
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
Check if we can elide the load. Cancel if the new candidate isn't identical to previous store.
--- net/netfilter/nft_exthdr.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
net/netfilter/nft_exthdr.c +33 -0
@@ -603,12 +603,40 @@ static int nft_exthdr_dump_strip(struct sk_buff *skb, const struct nft_expr *expreturn nft_exthdr_dump_common (skb, priv); } +static bool nft_exthdr_reduce (struct nft_regs_track *track, +const struct nft_expr *expr) +{ +const struct nft_exthdr *priv =nft_expr_priv (expr); +const struct nft_exthdr *exthdr; + +if (!nft_reg_track_cmp (track, expr, priv->dreg)) { +nft_reg_track_update (track, expr, priv->dreg, priv->len); +return false; + } + + exthdr =nft_expr_priv (track->regs[priv->dreg].selector); +if (priv->type != exthdr->type || + priv->op != exthdr->op || + priv->flags != exthdr->flags || + priv->offset != exthdr->offset || + priv->len != exthdr->len) { +nft_reg_track_update (track, expr, priv->dreg, priv->len); +return false; + } + +if (!track->regs[priv->dreg].bitwise) +return true; + +return nft_expr_reduce_bitwise (track, expr); +} +static const struct nft_expr_ops nft_exthdr_ipv6_ops = { .type = &nft_exthdr_type, .size =NFT_EXPR_SIZE (sizeof (struct nft_exthdr )), .eval = nft_exthdr_ipv6_eval, .init = nft_exthdr_init, .dump = nft_exthdr_dump, + .reduce = nft_exthdr_reduce, };static const struct nft_expr_ops nft_exthdr_ipv4_ops = {
@@ -617,6 +645,7 @@ static const struct nft_expr_ops nft_exthdr_ipv4_ops = { .eval = nft_exthdr_ipv4_eval, .init = nft_exthdr_ipv4_init, .dump = nft_exthdr_dump, + .reduce = nft_exthdr_reduce, };static const struct nft_expr_ops nft_exthdr_tcp_ops = {
@@ -625,6 +654,7 @@ static const struct nft_expr_ops nft_exthdr_tcp_ops = { .eval = nft_exthdr_tcp_eval, .init = nft_exthdr_init, .dump = nft_exthdr_dump, + .reduce = nft_exthdr_reduce, };static const struct nft_expr_ops nft_exthdr_tcp_set_ops = {
@@ -633,6 +663,7 @@ static const struct nft_expr_ops nft_exthdr_tcp_set_ops = { .eval = nft_exthdr_tcp_set_eval, .init = nft_exthdr_tcp_set_init, .dump = nft_exthdr_dump_set, + .reduce = NFT_REDUCE_READONLY, };static const struct nft_expr_ops nft_exthdr_tcp_strip_ops = {
@@ -641,6 +672,7 @@ static const struct nft_expr_ops nft_exthdr_tcp_strip_ops = { .eval = nft_exthdr_tcp_strip_eval, .init = nft_exthdr_tcp_strip_init, .dump = nft_exthdr_dump_strip, + .reduce = NFT_REDUCE_READONLY, };static const struct nft_expr_ops nft_exthdr_sctp_ops = {
@@ -649,6 +681,7 @@ static const struct nft_expr_ops nft_exthdr_sctp_ops = { .eval = nft_exthdr_sctp_eval, .init = nft_exthdr_init, .dump = nft_exthdr_dump, + .reduce = nft_exthdr_reduce, }; static const struct nft_expr_ops *
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 17/19 netfilter: nf_nat_h323: eliminate anonymous module_init & module_exit
In reply to Pablo Neira AyusoFrom: Randy Dunlap <[email protected]>
Eliminate anonymous module_init() and module_exit(), which can lead to confusion or ambiguity when reading System.map, crashes/oops/bugs, or an initcall_debug log.
Give each of these init and exit functions unique driver-specific names to eliminate the anonymous names.
Example 1: (System.map)
ffffffff832fc78c t init
ffffffff832fc79e t init
ffffffff832fc8f8 t init
Example 2: (initcall_debug log)
calling init+0x0/0x12 @ 1
initcall init+0x0/0x12 returned 0 after 15 usecs
calling init+0x0/0x60 @ 1
initcall init+0x0/0x60 returned 0 after 2 usecs
calling init+0x0/0x9a @ 1
initcall init+0x0/0x9a returned 0 after 74 usecs
--- net/ipv4/netfilter/nf_nat_h323.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
net/ipv4/netfilter/nf_nat_h323.c +4 -4
@@ -580,7 +580,7 @@ static struct nf_ct_helper_expectfn callforwarding_nat = { };/****************************************************************************/ -static int __init init (void ) +static int __init nf_nat_h323_init (void ) {BUG_ON (set_h245_addr_hook !=NULL );BUG_ON (set_h225_addr_hook !=NULL );
@@ -607,7 +607,7 @@ static int __init init(void) }/****************************************************************************/ -static void __exit fini(void) +static void __exit nf_nat_h323_fini(void) {RCU_INIT_POINTER (set_h245_addr_hook,NULL );RCU_INIT_POINTER (set_h225_addr_hook,NULL );
@@ -624,8 +624,8 @@ static void __exit fini(void) }/****************************************************************************/ -module_init (init); -module_exit (fini); +module_init (nf_nat_h323_init); +module_exit (nf_nat_h323_fini);MODULE_AUTHOR ("Jing Min Zhao <[email protected]>" );MODULE_DESCRIPTION ("H.323 NAT helper" );
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 18/19 netfilter: flowtable: remove redundant field in flow_offload_work struct
In reply to Pablo Neira AyusoAlready available through the flowtable object, remove it.
--- net/netfilter/nf_flow_table_offload.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
net/netfilter/nf_flow_table_offload.c +6 -5
@@ -20,7 +20,6 @@ static struct workqueue_struct *nf_flow_offload_stats_wq;struct flow_offload_work {struct list_head list;enum flow_cls_command cmd; -int priority;struct nf_flowtable *flowtable;struct flow_offload *flow;struct work_struct work;
@@ -874,7 +873,8 @@ static int flow_offload_tuple_add(struct flow_offload_work *offload, enum flow_offload_tuple_dir dir) {return nf_flow_offload_tuple (offload->flowtable, offload->flow, - flow_rule, dir, offload->priority, + flow_rule, dir, + offload->flowtable->priority,FLOW_CLS_REPLACE ,NULL , &offload->flowtable->flow_block.cb_list); }
@@ -883,7 +883,8 @@ static void flow_offload_tuple_del(struct flow_offload_work *offload, enum flow_offload_tuple_dir dir) {nf_flow_offload_tuple (offload->flowtable, offload->flow,NULL , dir, - offload->priority,FLOW_CLS_DESTROY ,NULL , + offload->flowtable->priority, +FLOW_CLS_DESTROY ,NULL , &offload->flowtable->flow_block.cb_list); }
@@ -934,7 +935,8 @@ static void flow_offload_tuple_stats(struct flow_offload_work *offload, struct flow_stats *stats) {nf_flow_offload_tuple (offload->flowtable, offload->flow,NULL , dir, - offload->priority,FLOW_CLS_STATS , stats, + offload->flowtable->priority, +FLOW_CLS_STATS , stats, &offload->flowtable->flow_block.cb_list); }
@@ -1012,7 +1014,6 @@ nf_flow_offload_work_alloc(struct nf_flowtable *flowtable, offload->cmd = cmd; offload->flow = flow; - offload->priority = flowtable->priority; offload->flowtable = flowtable;INIT_WORK (&offload->work, flow_offload_work_handler);
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 19/19 netfilter: flowtable: pass flowtable to nf_flow_table_iterate()
In reply to Pablo Neira AyusoThe flowtable object is already passed as argument to nf_flow_table_iterate(), do use not data pointer to pass flowtable.
--- net/netfilter/nf_flow_table_core.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)
net/netfilter/nf_flow_table_core.c +10 -10
@@ -405,7 +405,8 @@ EXPORT_SYMBOL_GPL(flow_offload_lookup);static int nf_flow_table_iterate (struct nf_flowtable *flow_table, -void (*iter)(struct flow_offload *flow,void *data), +void (*iter)(struct nf_flowtable *flowtable, +struct flow_offload *flow,void *data),void *data) {struct flow_offload_tuple_rhash *tuplehash;
@@ -429,7 +430,7 @@ nf_flow_table_iterate(struct nf_flowtable *flow_table, flow = container_of(tuplehash, struct flow_offload, tuplehash[0]); -iter (flow, data); +iter (flow_table, flow, data); }rhashtable_walk_stop (&hti);rhashtable_walk_exit (&hti);
@@ -457,10 +458,9 @@ static bool nf_flow_has_stale_dst(struct flow_offload *flow)flow_offload_stale_dst (&flow->tuplehash[FLOW_OFFLOAD_DIR_REPLY ].tuple); } -static void nf_flow_offload_gc_step (struct flow_offload *flow,void *data) +static void nf_flow_offload_gc_step (struct nf_flowtable *flow_table, +struct flow_offload *flow,void *data) { -struct nf_flowtable *flow_table = data; -if (nf_flow_has_expired (flow) ||nf_ct_is_dying (flow->ct) ||nf_flow_has_stale_dst (flow))
@@ -485,7 +485,7 @@ static void nf_flow_offload_work_gc(struct work_struct *work)struct nf_flowtable *flow_table; flow_table = container_of(work, struct nf_flowtable, gc_work.work); -nf_flow_table_iterate (flow_table, nf_flow_offload_gc_step, flow_table); +nf_flow_table_iterate (flow_table, nf_flow_offload_gc_step,NULL );queue_delayed_work (system_power_efficient_wq, &flow_table->gc_work,HZ ); }
@@ -601,7 +601,8 @@ int nf_flow_table_init(struct nf_flowtable *flowtable) }EXPORT_SYMBOL_GPL (nf_flow_table_init); -static void nf_flow_table_do_cleanup (struct flow_offload *flow,void *data) +static void nf_flow_table_do_cleanup (struct nf_flowtable *flow_table, +struct flow_offload *flow,void *data) {struct net_device *dev = data;
@@ -643,11 +644,10 @@ void nf_flow_table_free(struct nf_flowtable *flow_table)cancel_delayed_work_sync (&flow_table->gc_work);nf_flow_table_iterate (flow_table, nf_flow_table_do_cleanup,NULL ); -nf_flow_table_iterate (flow_table, nf_flow_offload_gc_step, flow_table); +nf_flow_table_iterate (flow_table, nf_flow_offload_gc_step,NULL );nf_flow_table_offload_flush (flow_table);if (nf_flowtable_hw_offload (flow_table)) -nf_flow_table_iterate (flow_table, nf_flow_offload_gc_step, - flow_table); +nf_flow_table_iterate (flow_table, nf_flow_offload_gc_step,NULL );rhashtable_destroy (&flow_table->rhashtable); }EXPORT_SYMBOL_GPL (nf_flow_table_free);
Signature · 1 line
2.30.2