conntrack event caching changes
Subsystems (2)
Pablo Neira Ayuso
maintainercover conntrack event caching changes
Hi Patrick,
This is another round of the event caching rework. I'm not including patch from 1/5 to 3/5 that I previously sent that are required by these patches but that are not relevant for the RFC I think.
Basically, this rework contains:
a) The replacement for the use of the notify chain by a single function pointer.
b) The replacement of the per-cpu event cache by a per-conntrack event cache.
c) The addition of optional reliable conntrack event delivery containing the recent comments during one of our discussions.
Thanks!
---
Pablo Neira Ayuso (3):
ctnetlink: optional reliable conntrack event delivery
conntrack: ecache: move event cache to conntrack extension infrastructure
netfilter: ecache: replace notify chain by function pointer
include/net/netfilter/nf_conntrack.h | 2 include/net/netfilter/nf_conntrack_core.h | 6 - include/net/netfilter/nf_conntrack_ecache.h | 163 +++++++++++---- include/net/netfilter/nf_conntrack_extend.h | 2 include/net/netfilter/nf_conntrack_helper.h | 2 include/net/netns/conntrack.h | 7 - net/netfilter/nf_conntrack_core.c | 124 ++++++++---- net/netfilter/nf_conntrack_ecache.c | 288 ++++++++++++++++++++------- net/netfilter/nf_conntrack_ftp.c | 4 net/netfilter/nf_conntrack_helper.c | 15 + net/netfilter/nf_conntrack_netlink.c | 103 +++++----- net/netfilter/nf_conntrack_proto_sctp.c | 2 net/netfilter/nf_conntrack_proto_tcp.c | 7 - 13 files changed, 513 insertions(+), 212 deletions(-)
Signature · 1 line
3.3.3
Pablo Neira Ayuso
maintainerPATCH 1/3 netfilter: ecache: replace notify chain by function pointer
This patch removes the notify chain from per-cpu event cache infrastructure and replace it by a simple function pointer. The use of the notify chain adds too much overhead for something that is only used by ctnetlink.
---
include/net/netfilter/nf_conntrack_ecache.h | 70 +++++++++++++------ net/netfilter/nf_conntrack_ecache.c | 101 +++++++++++++++++++++++---- net/netfilter/nf_conntrack_netlink.c | 41 +++++------ 3 files changed, 154 insertions(+), 58 deletions(-)
include/net/netfilter/nf_conntrack_ecache.h +50 -20
@@ -6,7 +6,6 @@#define _NF_CONNTRACK_ECACHE_H#include <net/netfilter/nf_conntrack.h> -#include <linux/notifier.h> #include <linux/interrupt.h> #include <net/net_namespace.h> #include <net/netfilter/nf_conntrack_expect.h>
@@ -93,9 +92,13 @@ struct nf_ct_event {int report; }; -extern struct atomic_notifier_head nf_conntrack_chain; -extern int nf_conntrack_register_notifier (struct notifier_block *nb); -extern int nf_conntrack_unregister_notifier (struct notifier_block *nb); +struct nf_ct_event_notifier { +int (*fcn)(unsigned int events,struct nf_ct_event *item); +}; + +extern struct nf_ct_event_notifier *nf_conntrack_event_cb; +extern int nf_conntrack_register_notifier (struct nf_ct_event_notifier *nb); +extern int nf_conntrack_unregister_notifier (struct nf_ct_event_notifier *nb);extern void nf_ct_deliver_cached_events (const struct nf_conn *ct);extern void __nf_ct_event_cache_init (struct nf_conn *ct);
@@ -121,13 +124,24 @@ nf_conntrack_event_report(enum ip_conntrack_events event, u32 pid, int report) { -struct nf_ct_event item = { - .ct = ct, - .pid = pid, - .report = report - }; -if (nf_ct_is_confirmed (ct) && !nf_ct_is_dying (ct)) -atomic_notifier_call_chain (&nf_conntrack_chain, event, &item); +struct nf_ct_event_notifier *notify; + +rcu_read_lock (); + notify =rcu_dereference (nf_conntrack_event_cb); +if (notify ==NULL ) + goto out_unlock; + +if (nf_ct_is_confirmed (ct) && !nf_ct_is_dying (ct)) { +struct nf_ct_event item = { + .ct = ct, + .pid = pid, + .report = report + }; + + notify->fcn (event, &item); + } +out_unlock: +rcu_read_unlock (); } static inline void
@@ -142,9 +156,13 @@ struct nf_exp_event {int report; }; -extern struct atomic_notifier_head nf_ct_expect_chain; -extern int nf_ct_expect_register_notifier (struct notifier_block *nb); -extern int nf_ct_expect_unregister_notifier (struct notifier_block *nb); +struct nf_exp_event_notifier { +int (*fcn)(unsigned int events,struct nf_exp_event *item); +}; + +extern struct nf_exp_event_notifier *nf_expect_event_cb; +extern int nf_ct_expect_register_notifier (struct nf_exp_event_notifier *nb); +extern int nf_ct_expect_unregister_notifier (struct nf_exp_event_notifier *nb); static inline void nf_ct_expect_event_report(enum ip_conntrack_expect_events event,
@@ -152,12 +170,24 @@ nf_ct_expect_event_report(enum ip_conntrack_expect_events event, u32 pid, int report) { -struct nf_exp_event item = { - .exp = exp, - .pid = pid, - .report = report - }; -atomic_notifier_call_chain (&nf_ct_expect_chain, event, &item); +struct nf_exp_event_notifier *notify; + +rcu_read_lock (); + notify =rcu_dereference (nf_expect_event_cb); +if (notify ==NULL ) + goto out_unlock; + + { +struct nf_exp_event item = { + .exp = exp, + .pid = pid, + .report = report + }; + + notify->fcn (event, &item); + } +out_unlock: +rcu_read_unlock (); } static inline void
net/netfilter/nf_conntrack_ecache.c +85 -16
149 lines not on this page · raw message
net/netfilter/nf_conntrack_netlink.c +19 -22
127 lines not on this page · raw message
Pablo Neira Ayuso
maintainerPATCH 2/3 conntrack: ecache: move event cache to conntrack extension infrastructure
In reply to Pablo Neira AyusoThis patch reworks the event caching infrastructure to use the conntrack extension infrastructure. As a result, you can enable and disable event delivery via /proc/sys/net/netfilter/nf_conntrack_events in runtime opposed to compilation time. The main drawback is that we consume more memory per conntrack if event delivery is enabled.
---
include/net/netfilter/nf_conntrack_ecache.h | 73 +++++++--- include/net/netfilter/nf_conntrack_extend.h | 2 include/net/netns/conntrack.h | 5 - net/netfilter/nf_conntrack_core.c | 37 ++--- net/netfilter/nf_conntrack_ecache.c | 197 +++++++++++++++++---------- net/netfilter/nf_conntrack_ftp.c | 4 - net/netfilter/nf_conntrack_netlink.c | 1 net/netfilter/nf_conntrack_proto_sctp.c | 2 net/netfilter/nf_conntrack_proto_tcp.c | 7 + 9 files changed, 207 insertions(+), 121 deletions(-)
include/net/netfilter/nf_conntrack_ecache.h +52 -21
@@ -6,9 +6,11 @@#define _NF_CONNTRACK_ECACHE_H#include <net/netfilter/nf_conntrack.h> -#include <linux/interrupt.h> #include <net/net_namespace.h> #include <net/netfilter/nf_conntrack_expect.h> +#include <linux/netfilter/nf_conntrack_common.h> +#include <linux/netfilter/nf_conntrack_tuple_common.h> +#include <net/netfilter/nf_conntrack_extend.h> /* Connection tracking event bits */ enum ip_conntrack_events
@@ -81,8 +83,24 @@ enum ip_conntrack_expect_events {#ifdef CONFIG_NF_CONNTRACK_EVENTS struct nf_conntrack_ecache { -struct nf_conn *ct; -unsigned int events; +unsigned int cache; +}; + +static inline struct nf_conntrack_ecache * +nf_ct_ecache_find (const struct nf_conn *ct) +{ +return nf_ct_ext_find (ct,NF_CT_EXT_ECACHE ); +} + +static inline struct nf_conntrack_ecache * +nf_ct_ecache_ext_add (struct nf_conn *ct,gfp_t gfp) +{ +struct net *net =nf_ct_net (ct); + +if (!net->ct.sysctl_events) +return NULL ; + +return nf_ct_ext_add (ct,NF_CT_EXT_ECACHE , gfp); };/* This structure is passed to event handler */
@@ -100,22 +118,33 @@ extern struct nf_ct_event_notifier *nf_conntrack_event_cb;extern int nf_conntrack_register_notifier (struct nf_ct_event_notifier *nb);extern int nf_conntrack_unregister_notifier (struct nf_ct_event_notifier *nb); -extern void nf_ct_deliver_cached_events (const struct nf_conn *ct); -extern void __nf_ct_event_cache_init (struct nf_conn *ct); -extern void nf_ct_event_cache_flush (struct net *net); +extern void nf_ct_deliver_cached_events (struct nf_conn *ct); + +static inline void +__nf_conntrack_event_cache (enum ip_conntrack_events event,struct nf_conn *ct) +{ +struct nf_conntrack_ecache *e; +struct nf_ct_event_notifier *notify = +rcu_dereference (nf_conntrack_event_cb); + +if (notify ==NULL ) +return ; + + e =nf_ct_ecache_find (ct); +if (e ==NULL ) +return ; + + e->cache |= event; +} + +extern spinlock_t nf_conntrack_lock;static inline void nf_conntrack_event_cache (enum ip_conntrack_events event,struct nf_conn *ct) { -struct net *net =nf_ct_net (ct); -struct nf_conntrack_ecache *ecache; - -local_bh_disable (); - ecache =per_cpu_ptr (net->ct.ecache,raw_smp_processor_id ()); -if (ct != ecache->ct) -__nf_ct_event_cache_init (ct); - ecache->events |= event; -local_bh_enable (); +spin_lock_bh (&nf_conntrack_lock); +__nf_conntrack_event_cache (event, ct); +spin_unlock_bh (&nf_conntrack_lock); } static inline void
@@ -124,6 +153,7 @@ nf_conntrack_event_report(enum ip_conntrack_events event, u32 pid, int report) { +struct net *net =nf_ct_net (ct);struct nf_ct_event_notifier *notify;rcu_read_lock ();
@@ -131,6 +161,9 @@ nf_conntrack_event_report(enum ip_conntrack_events event,if (notify ==NULL ) goto out_unlock; +if (!net->ct.sysctl_events) +return ; +if (nf_ct_is_confirmed (ct) && !nf_ct_is_dying (ct)) {struct nf_ct_event item = { .ct = ct,
@@ -170,6 +203,7 @@ nf_ct_expect_event_report(enum ip_conntrack_expect_events event, u32 pid, int report) { +struct net *net =nf_ct_exp_net (exp);struct nf_exp_event_notifier *notify;rcu_read_lock ();
@@ -177,6 +211,9 @@ nf_ct_expect_event_report(enum ip_conntrack_expect_events event,if (notify ==NULL ) goto out_unlock; +if (!net->ct.sysctl_events) +return ; + {struct nf_exp_event item = { .exp = exp,
@@ -217,12 +254,6 @@ static inline void nf_ct_expect_event_report(enum ip_conntrack_expect_events e, struct nf_conntrack_expect *exp, u32 pid, int report) {} -static inline void nf_ct_event_cache_flush (struct net *net) {} - -static inline int nf_conntrack_ecache_init (struct net *net) -{ -return 0 ; -}static inline void nf_conntrack_ecache_fini (struct net *net) {
include/net/netfilter/nf_conntrack_extend.h +2 -0
@@ -8,12 +8,14 @@ enum nf_ct_ext_idNF_CT_EXT_HELPER ,NF_CT_EXT_NAT ,NF_CT_EXT_ACCT , +NF_CT_EXT_ECACHE , NF_CT_EXT_NUM, };#define NF_CT_EXT_HELPER_TYPE struct nf_conn_help#define NF_CT_EXT_NAT_TYPE struct nf_conn_nat#define NF_CT_EXT_ACCT_TYPE struct nf_conn_counter +#define NF_CT_EXT_ECACHE_TYPE struct nf_conntrack_ecache/* Extensions: optional stuff which isn't permanently in struct. */ struct nf_ct_ext {
include/net/netns/conntrack.h +2 -3
@@ -14,15 +14,14 @@ struct netns_ct {struct hlist_head *expect_hash;struct hlist_head unconfirmed;struct ip_conntrack_stat *stat; -#ifdef CONFIG_NF_CONNTRACK_EVENTS -struct nf_conntrack_ecache *ecache; -#endif +int sysctl_events;int sysctl_acct;int sysctl_checksum;unsigned int sysctl_log_invalid;/* Log invalid packets */ #ifdef CONFIG_SYSCTL struct ctl_table_header *sysctl_header;struct ctl_table_header *acct_sysctl_header; +struct ctl_table_header *event_sysctl_header;#endif int hash_vmalloc;int expect_vmalloc;
net/netfilter/nf_conntrack_core.c +17 -20
@@ -371,17 +371,17 @@ __nf_conntrack_confirm(struct sk_buff *skb)atomic_inc (&ct->ct_general.use);set_bit (IPS_CONFIRMED_BIT , &ct->status);NF_CT_STAT_INC (net, insert); -spin_unlock_bh (&nf_conntrack_lock); help =nfct_help (ct);if (help && help->helper) -nf_conntrack_event_cache (IPCT_HELPER , ct); +__nf_conntrack_event_cache (IPCT_HELPER , ct);#ifdef CONFIG_NF_NAT_NEEDED if (test_bit (IPS_SRC_NAT_DONE_BIT , &ct->status) ||test_bit (IPS_DST_NAT_DONE_BIT , &ct->status)) -nf_conntrack_event_cache (IPCT_NATINFO , ct); +__nf_conntrack_event_cache (IPCT_NATINFO , ct);#endif -nf_conntrack_event_cache (master_ct (ct) ? -IPCT_RELATED :IPCT_NEW , ct); +__nf_conntrack_event_cache (master_ct (ct) ? +IPCT_RELATED :IPCT_NEW , ct); +spin_unlock_bh (&nf_conntrack_lock);return NF_ACCEPT ; out:
@@ -564,6 +564,7 @@ init_conntrack(struct net *net, }nf_ct_acct_ext_add (ct,GFP_ATOMIC ); +nf_ct_ecache_ext_add (ct,GFP_ATOMIC );spin_lock_bh (&nf_conntrack_lock); exp =nf_ct_find_expectation (net, tuple);
@@ -726,6 +727,9 @@ nf_conntrack_in(struct net *net, u_int8_t pf, unsigned int hooknum,NF_CT_ASSERT (skb->nfct); +/* We may have pending events, deliver them and clear the cache */ +nf_ct_deliver_cached_events (ct); + ret = l4proto->packet (ct, skb, dataoff, ctinfo, pf, hooknum);if (ret <=0 ) {/* Invalid: inverse of the return code tells
@@ -791,8 +795,6 @@ void __nf_ct_refresh_acct(struct nf_conn *ct,unsigned long extra_jiffies, int do_acct) { - int event = 0; - NF_CT_ASSERT(ct->timeout.data == (unsigned long)ct);NF_CT_ASSERT (skb);
@@ -805,7 +807,7 @@ void __nf_ct_refresh_acct(struct nf_conn *ct,/* If not in hash table, timer will not be active yet */ if (!nf_ct_is_confirmed (ct)) { ct->timeout.expires = extra_jiffies; - event =IPCT_REFRESH ; +__nf_conntrack_event_cache (IPCT_REFRESH , ct); }else {unsigned long newtime = jiffies + extra_jiffies;
@@ -816,7 +818,7 @@ void __nf_ct_refresh_acct(struct nf_conn *ct, && del_timer(&ct->timeout)) { ct->timeout.expires = newtime;add_timer (&ct->timeout); - event =IPCT_REFRESH ; +__nf_conntrack_event_cache (IPCT_REFRESH , ct); } }
@@ -833,10 +835,6 @@ acct: }spin_unlock_bh (&nf_conntrack_lock); - -/* must be unlocked when calling event cache */ -if (event) -nf_conntrack_event_cache (event, ct); }EXPORT_SYMBOL_GPL (__nf_ct_refresh_acct);
@@ -1022,8 +1020,6 @@ static void nf_conntrack_cleanup_init_net(void)static void nf_conntrack_cleanup_net (struct net *net) { -nf_ct_event_cache_flush (net); -nf_conntrack_ecache_fini (net); i_see_dead_people:nf_ct_iterate_cleanup (net, kill_all,NULL );if (atomic_read (&net->ct.count) !=0 ) {
@@ -1036,6 +1032,7 @@ static void nf_conntrack_cleanup_net(struct net *net)nf_ct_free_hashtable (net->ct.hash, net->ct.hash_vmalloc, nf_conntrack_htable_size); +nf_conntrack_ecache_fini (net);nf_conntrack_acct_fini (net);nf_conntrack_expect_fini (net);free_percpu (net->ct.stat);
@@ -1209,9 +1206,6 @@ static int nf_conntrack_init_net(struct net *net) ret = -ENOMEM ; goto err_stat; } - ret =nf_conntrack_ecache_init (net); -if (ret <0 ) - goto err_ecache; net->ct.hash =nf_ct_alloc_hashtable (&nf_conntrack_htable_size, &net->ct.hash_vmalloc);if (!net->ct.hash) {
@@ -1225,6 +1219,9 @@ static int nf_conntrack_init_net(struct net *net) ret =nf_conntrack_acct_init (net);if (ret <0 ) goto err_acct; + ret =nf_conntrack_ecache_init (net); +if (ret <0 ) + goto err_ecache;/* Set up fake conntrack: - to never be deleted, not in any hashes */
@@ -1237,14 +1234,14 @@ static int nf_conntrack_init_net(struct net *net)return 0 ; +err_ecache: +nf_conntrack_acct_fini (net); err_acct:nf_conntrack_expect_fini (net); err_expect:nf_ct_free_hashtable (net->ct.hash, net->ct.hash_vmalloc, nf_conntrack_htable_size); err_hash: -nf_conntrack_ecache_fini (net); -err_ecache:free_percpu (net->ct.stat); err_stat:return ret;
net/netfilter/nf_conntrack_ecache.c +126 -71
238 lines not on this page · raw message
net/netfilter/nf_conntrack_ftp.c +2 -2
@@ -338,11 +338,11 @@ static void update_nl_seq(struct nf_conn *ct, u32 nl_seq,if (info->seq_aft_nl_num[dir] <NUM_SEQ_TO_REMEMBER ) { info->seq_aft_nl[dir][info->seq_aft_nl_num[dir]++] = nl_seq; -nf_conntrack_event_cache (IPCT_HELPINFO_VOLATILE , ct); +__nf_conntrack_event_cache (IPCT_HELPINFO_VOLATILE , ct); }else if (oldest !=NUM_SEQ_TO_REMEMBER &&after (nl_seq, info->seq_aft_nl[dir][oldest])) { info->seq_aft_nl[dir][oldest] = nl_seq; -nf_conntrack_event_cache (IPCT_HELPINFO_VOLATILE , ct); +__nf_conntrack_event_cache (IPCT_HELPINFO_VOLATILE , ct); } }
net/netfilter/nf_conntrack_netlink.c +1 -0
@@ -1224,6 +1224,7 @@ ctnetlink_create_conntrack(struct nlattr *cda[], }nf_ct_acct_ext_add (ct,GFP_ATOMIC ); +nf_ct_ecache_ext_add (ct,GFP_ATOMIC );#if defined(CONFIG_NF_CONNTRACK_MARK )if (cda[CTA_MARK ])
net/netfilter/nf_conntrack_proto_sctp.c +1 -1
@@ -369,7 +369,7 @@ static int sctp_packet(struct nf_conn *ct, ct->proto.sctp.state = new_state;if (old_state != new_state) -nf_conntrack_event_cache (IPCT_PROTOINFO , ct); +__nf_conntrack_event_cache (IPCT_PROTOINFO , ct); }write_unlock_bh (&sctp_lock);
net/netfilter/nf_conntrack_proto_tcp.c +4 -3
@@ -972,11 +972,12 @@ static int tcp_packet(struct nf_conn *ct, timeout = nf_ct_tcp_timeout_unacknowledged; else timeout = tcp_timeouts[new_state]; -write_unlock_bh (&tcp_lock); -nf_conntrack_event_cache (IPCT_PROTOINFO_VOLATILE , ct); +__nf_conntrack_event_cache (IPCT_PROTOINFO_VOLATILE , ct);if (new_state != old_state) -nf_conntrack_event_cache (IPCT_PROTOINFO , ct); +__nf_conntrack_event_cache (IPCT_PROTOINFO , ct); + +write_unlock_bh (&tcp_lock);if (!test_bit (IPS_SEEN_REPLY_BIT , &ct->status)) {/* If only reply is a RST, we can consider ourselves not to
Pablo Neira Ayuso
maintainerPATCH 3/3 ctnetlink: optional reliable conntrack event delivery
In reply to Pablo Neira AyusoThis patch improves ctnetlink event reliability if one broadcast listener has set the NETLINK_BROADCAST_ERROR socket option.
The logic is the following: if the event delivery fails, ctnetlink sets IPCT_DELIVERY_FAILED event bit and keep the undelivered events in the conntrack event cache. Thus, once the next packet arrives, we trigger another event delivery in nf_conntrack_in(). If things don't go well in this second try, we accumulate the pending events in the cache but we try to deliver the current state as soon as possible. Therefore, we may lost state transitions but the userspace process gets in sync at some point.
At worst case, if no events were delivered to userspace, we make sure that destroy events are successfully delivered. This happens because if ctnetlink fails to deliver the destroy event, we remove the conntrack entry from the hashes and insert them in the dying list, which contains inactive entries. Then, the conntrack timer is added with an extra grace timeout of 15 seconds to trigger the event again (this grace timeout is tunable via /proc).
The maximum number of conntrack entries (active or inactive) is still handled by nf_conntrack_max. Thus, we may start dropping packets at some point if we accumulate a lot of inactive conntrack entries waiting to deliver the destroy event to userspace.
For expectations, no changes are introduced in this patch. Currently, event delivery is only done for new expectations (no events from expectation removal and confirmation) and, apart from the conntrack command line tool, I don't see any client that may benefit of reliable expectation event delivery, at least until destroy and confirm events are introduced.
This patch does not include the removal of the notify chain as Patrick suggested yet, but I'll work on such change on top of this patch if this is OK.
---
include/net/netfilter/nf_conntrack.h | 2 + include/net/netfilter/nf_conntrack_core.h | 6 +- include/net/netfilter/nf_conntrack_ecache.h | 30 ++++++--- include/net/netfilter/nf_conntrack_helper.h | 2 + include/net/netns/conntrack.h | 2 + net/netfilter/nf_conntrack_core.c | 87 ++++++++++++++++++++++----- net/netfilter/nf_conntrack_ecache.c | 26 +++++++- net/netfilter/nf_conntrack_helper.c | 15 +++++ net/netfilter/nf_conntrack_netlink.c | 61 ++++++++++++------- 9 files changed, 175 insertions(+), 56 deletions(-)
include/net/netfilter/nf_conntrack.h +2 -0
@@ -289,6 +289,8 @@ extern int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp);extern unsigned int nf_conntrack_htable_size;extern unsigned int nf_conntrack_max; +extern void nf_ct_setup_event_timer (struct nf_conn *ct); +#define NF_CT_STAT_INC (net, count) \ (per_cpu_ptr((net)->ct.stat, raw_smp_processor_id())->count++)#define NF_CT_STAT_INC_ATOMIC (net, count) \
include/net/netfilter/nf_conntrack_core.h +4 -2
@@ -62,8 +62,10 @@ static inline int nf_conntrack_confirm(struct sk_buff *skb)if (ct && ct != &nf_conntrack_untracked) {if (!nf_ct_is_confirmed (ct) && !nf_ct_is_dying (ct)) ret =__nf_conntrack_confirm (skb); -if (likely (ret ==NF_ACCEPT )) -nf_ct_deliver_cached_events (ct); +if (unlikely (ret ==NF_DROP )) +return NF_DROP ; +if (unlikely (nf_ct_deliver_cached_events (ct) <0 )) +nf_conntrack_event_cache (IPCT_DELIVERY_FAILED , ct); }return ret; }
include/net/netfilter/nf_conntrack_ecache.h +19 -11
@@ -74,6 +74,10 @@ enum ip_conntrack_events/* Secmark is set */ IPCT_SECMARK_BIT =14 ,IPCT_SECMARK = (1 <<IPCT_SECMARK_BIT ), + +/* An event delivery has failed */ +IPCT_DELIVERY_FAILED_BIT =31 , + IPCT_DELIVERY_FAILED = (1 << IPCT_DELIVERY_FAILED_BIT), }; enum ip_conntrack_expect_events {
@@ -118,7 +122,7 @@ extern struct nf_ct_event_notifier *nf_conntrack_event_cb;extern int nf_conntrack_register_notifier (struct nf_ct_event_notifier *nb);extern int nf_conntrack_unregister_notifier (struct nf_ct_event_notifier *nb); -extern void nf_ct_deliver_cached_events (struct nf_conn *ct); +extern int nf_ct_deliver_cached_events (struct nf_conn *ct);static inline void __nf_conntrack_event_cache (enum ip_conntrack_events event,struct nf_conn *ct)
@@ -147,12 +151,13 @@ nf_conntrack_event_cache(enum ip_conntrack_events event, struct nf_conn *ct)spin_unlock_bh (&nf_conntrack_lock); } -static inline void +static inline int nf_conntrack_event_report (enum ip_conntrack_events event,struct nf_conn *ct,u32 pid,int report) { +int ret =0 ;struct net *net =nf_ct_net (ct);struct nf_ct_event_notifier *notify;
@@ -162,7 +167,7 @@ nf_conntrack_event_report(enum ip_conntrack_events event, goto out_unlock;if (!net->ct.sysctl_events) -return ; + goto out_unlock;if (nf_ct_is_confirmed (ct) && !nf_ct_is_dying (ct)) {struct nf_ct_event item = {
@@ -171,16 +176,17 @@ nf_conntrack_event_report(enum ip_conntrack_events event, .report = report }; - notify->fcn (event, &item); + ret = notify->fcn (event, &item); } out_unlock:rcu_read_unlock (); +return ret; } -static inline void +static inline int nf_conntrack_event (enum ip_conntrack_events event,struct nf_conn *ct) { -nf_conntrack_event_report (event, ct,0 ,0 ); +return nf_conntrack_event_report (event, ct,0 ,0 ); }struct nf_exp_event {
@@ -197,12 +203,13 @@ extern struct nf_exp_event_notifier *nf_expect_event_cb;extern int nf_ct_expect_register_notifier (struct nf_exp_event_notifier *nb);extern int nf_ct_expect_unregister_notifier (struct nf_exp_event_notifier *nb); -static inline void +static inline int nf_ct_expect_event_report (enum ip_conntrack_expect_events event,struct nf_conntrack_expect *exp,u32 pid,int report) { +int ret =0 ;struct net *net =nf_ct_exp_net (exp);struct nf_exp_event_notifier *notify;
@@ -212,7 +219,7 @@ nf_ct_expect_event_report(enum ip_conntrack_expect_events event, goto out_unlock;if (!net->ct.sysctl_events) -return ; + goto out_unlock; {struct nf_exp_event item = {
@@ -221,17 +228,18 @@ nf_ct_expect_event_report(enum ip_conntrack_expect_events event, .report = report }; - notify->fcn (event, &item); + ret = notify->fcn (event, &item); } out_unlock:rcu_read_unlock (); +return ret; } -static inline void +static inline int nf_ct_expect_event (enum ip_conntrack_expect_events event,struct nf_conntrack_expect *exp) { -nf_ct_expect_event_report (event, exp,0 ,0 ); +return nf_ct_expect_event_report (event, exp,0 ,0 ); }extern int nf_conntrack_ecache_init (struct net *net);
include/net/netfilter/nf_conntrack_helper.h +2 -0
@@ -48,6 +48,8 @@ extern struct nf_conn_help *nf_ct_helper_ext_add(struct nf_conn *ct, gfp_t gfp);extern int __nf_ct_try_assign_helper (struct nf_conn *ct,gfp_t flags); +extern void nf_ct_helper_destroy (struct nf_conn *ct); +static inline struct nf_conn_help *nfct_help (const struct nf_conn *ct) {return nf_ct_ext_find (ct,NF_CT_EXT_HELPER );
include/net/netns/conntrack.h +2 -0
@@ -13,8 +13,10 @@ struct netns_ct {struct hlist_head *hash;struct hlist_head *expect_hash;struct hlist_head unconfirmed; +struct hlist_head dying;struct ip_conntrack_stat *stat;int sysctl_events; +unsigned int sysctl_events_retry_timeout;int sysctl_acct;int sysctl_checksum;unsigned int sysctl_log_invalid;/* Log invalid packets */
net/netfilter/nf_conntrack_core.c +71 -16
125 lines not on this page · raw message
net/netfilter/nf_conntrack_ecache.c +22 -4
@@ -33,10 +33,11 @@ EXPORT_SYMBOL_GPL(nf_expect_event_cb);/* Deliver all cached events for a particular conntrack. This is called * by code prior to async packet handling for freeing the skb */ -void nf_ct_deliver_cached_events (struct nf_conn *ct) +int nf_ct_deliver_cached_events (struct nf_conn *ct) {struct nf_ct_event_notifier *notify;struct nf_conntrack_ecache *e; +int ret =0 , delivered =0 ;rcu_read_lock (); notify =rcu_dereference (nf_conntrack_event_cb);
@@ -45,7 +46,7 @@ void nf_ct_deliver_cached_events(struct nf_conn *ct) e =nf_ct_ecache_find (ct);if (e ==NULL ) -return ; + goto out_unlock;if (nf_ct_is_confirmed (ct) && !nf_ct_is_dying (ct) && e->cache) {struct nf_ct_event item = {
@@ -54,12 +55,16 @@ void nf_ct_deliver_cached_events(struct nf_conn *ct) .report = 0 }; - notify->fcn (e->cache, &item); + ret = notify->fcn (e->cache, &item); +if (ret ==0 ) + delivered =1 ; } -xchg (&e->cache,0 ); +if (delivered) +xchg (&e->cache,0 ); out_unlock:rcu_read_unlock (); +return ret; }EXPORT_SYMBOL_GPL (nf_ct_deliver_cached_events);
@@ -154,9 +159,12 @@ EXPORT_SYMBOL_GPL(nf_ct_expect_unregister_notifier);#endif static int nf_ct_events_switch__read_mostly =NF_CT_EVENTS_DEFAULT ; +static int nf_ct_events_retry_timeout__read_mostly =15 *HZ ;module_param_named (event, nf_ct_events_switch, bool,0644 );MODULE_PARM_DESC (event,"Enable connection tracking event delivery" ); +module_param_named (retry_timeout, nf_ct_events_retry_timeout, bool,0644 ); +MODULE_PARM_DESC (retry_timeout,"Event delivery retry timeout" );#ifdef CONFIG_SYSCTL static struct ctl_table event_sysctl_table[] = {
@@ -168,6 +176,14 @@ static struct ctl_table event_sysctl_table[] = { .mode = 0644, .proc_handler = proc_dointvec, }, + { + .ctl_name = CTL_UNNUMBERED, + .procname = "nf_conntrack_events_retry_timeout", + .data = &init_net.ct.sysctl_events_retry_timeout, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_dointvec_jiffies, + }, {} };#endif /* CONFIG_SYSCTL */
@@ -189,6 +205,7 @@ static int nf_conntrack_event_init_sysctl(struct net *net) goto out; table[0 ].data = &net->ct.sysctl_events; + table[1 ].data = &net->ct.sysctl_events_retry_timeout; net->ct.event_sysctl_header = register_net_sysctl_table(net,
@@ -229,6 +246,7 @@ int nf_conntrack_ecache_init(struct net *net)int ret; net->ct.sysctl_events = nf_ct_events_switch; + net->ct.sysctl_events_retry_timeout = nf_ct_events_retry_timeout;if (net_eq (net, &init_net)) { ret =nf_ct_extend_register (&event_extend);
net/netfilter/nf_conntrack_helper.c +15 -0
@@ -136,6 +136,21 @@ static inline int unhelp(struct nf_conntrack_tuple_hash *i,return 0 ; } +void nf_ct_helper_destroy (struct nf_conn *ct) +{ +struct nf_conn_help *help =nfct_help (ct); +struct nf_conntrack_helper *helper; + +if (help) { +rcu_read_lock (); + helper =rcu_dereference (help->helper); +if (helper && helper->destroy) + helper->destroy (ct); +rcu_read_unlock (); + } +} +EXPORT_SYMBOL_GPL (nf_ct_helper_destroy); +int nf_conntrack_helper_register (struct nf_conntrack_helper *me) {unsigned int h =helper_hash (&me->tuple);
net/netfilter/nf_conntrack_netlink.c +38 -23
108 lines not on this page · raw message
Pablo Neira Ayuso
maintainerRe: [PATCH 3/3] ctnetlink: optional reliable conntrack event delivery
Quoted 3 lines · Pablo Neira Ayuso
This patch does not include the removal of the notify chain as Patrick suggested yet, but I'll work on such change on top of this patch if this is OK.
^^^
BTW, this is comment is obsolte. I wrote it and then go back to add the notify chain removal as the very first patch :).
Signature · 1 line
"Los honestos son inadaptados sociales" -- Les Luthiers