conntrack event subsystem updates for 2.6.31 (part 2)
Subsystems (2)
Pablo Neira Ayuso
maintainercover conntrack event subsystem updates for 2.6.31 (part 2)
Hi Patrick!
This is the second part of the updates for the conntrack event subsystem. These patches are built on top of the previous patchset. They basically consists of a re-work of the conntrack event cache to switch from per-cpu to the conntrack extension infrastructure that is required by the optional reliable event delivery.
Basically, the idea consists of accumulating undelivered events in the per-conntrack cache to allow another try once the next packet hits the conntrack entry. We may keep losing events but, at worst case, we make sure that destroy events are delivered.
Feedback welcome.
---
Pablo Neira Ayuso (2):
netfilter: conntrack: optional reliable conntrack event delivery
netfilter: conntrack: move event cache to conntrack extension infrastructure
include/net/netfilter/nf_conntrack.h | 2 include/net/netfilter/nf_conntrack_core.h | 6 + include/net/netfilter/nf_conntrack_ecache.h | 156 ++++++++++++-------- 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 | 106 ++++++++++--- net/netfilter/nf_conntrack_ecache.c | 215 ++++++++++++++++++--------- net/netfilter/nf_conntrack_helper.c | 15 ++ net/netfilter/nf_conntrack_netlink.c | 90 +++++++---- 10 files changed, 403 insertions(+), 198 deletions(-)
Pablo Neira Ayuso
maintainerPATCH 1/2 netfilter: conntrack: move event cache to conntrack extension infrastructure
This 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. This patch is required by the reliable event delivery that follows to this patch.
---
include/net/netfilter/nf_conntrack_ecache.h | 145 ++++++++++++-------- include/net/netfilter/nf_conntrack_extend.h | 2 include/net/netns/conntrack.h | 5 - net/netfilter/nf_conntrack_core.c | 17 +- net/netfilter/nf_conntrack_ecache.c | 197 +++++++++++++++++---------- net/netfilter/nf_conntrack_netlink.c | 44 +++--- 6 files changed, 246 insertions(+), 164 deletions(-)
include/net/netfilter/nf_conntrack_ecache.h +85 -60
@@ -6,59 +6,50 @@#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 */ +/* Connection tracking event types */ enum ip_conntrack_events { -/* New conntrack */ -IPCT_NEW_BIT =0 , -IPCT_NEW = (1 <<IPCT_NEW_BIT ), - -/* Expected connection */ -IPCT_RELATED_BIT =1 , -IPCT_RELATED = (1 <<IPCT_RELATED_BIT ), - -/* Destroyed conntrack */ -IPCT_DESTROY_BIT =2 , -IPCT_DESTROY = (1 <<IPCT_DESTROY_BIT ), - -/* Status has changed */ -IPCT_STATUS_BIT =3 , -IPCT_STATUS = (1 <<IPCT_STATUS_BIT ), - -/* Update of protocol info */ -IPCT_PROTOINFO_BIT =4 , -IPCT_PROTOINFO = (1 <<IPCT_PROTOINFO_BIT ), - -/* New helper for conntrack */ -IPCT_HELPER_BIT =5 , -IPCT_HELPER = (1 <<IPCT_HELPER_BIT ), - -/* Mark is set */ -IPCT_MARK_BIT =6 , -IPCT_MARK = (1 <<IPCT_MARK_BIT ), - -/* NAT sequence adjustment */ -IPCT_NATSEQADJ_BIT =7 , -IPCT_NATSEQADJ = (1 <<IPCT_NATSEQADJ_BIT ), - -/* Secmark is set */ -IPCT_SECMARK_BIT =8 , -IPCT_SECMARK = (1 <<IPCT_SECMARK_BIT ), +IPCT_NEW =0 ,/* new conntrack */ +IPCT_RELATED =1 ,/* related conntrack */ +IPCT_DESTROY =2 ,/* destroyed conntrack */ +IPCT_STATUS =3 ,/* status has changed */ +IPCT_PROTOINFO =4 ,/* protocol information has changed */ +IPCT_HELPER =5 ,/* new helper has been set */ +IPCT_MARK =6 ,/* new mark has been set */ +IPCT_NATSEQADJ =7 ,/* NAT is doing sequence adjustment */ +IPCT_SECMARK =8 ,/* new security mark has been set */ };enum ip_conntrack_expect_events { -IPEXP_NEW_BIT =0 , -IPEXP_NEW = (1 <<IPEXP_NEW_BIT ), +IPEXP_NEW =0 ,/* new expectation */ };#ifdef CONFIG_NF_CONNTRACK_EVENTS struct nf_conntrack_ecache { -struct nf_conn *ct; -unsigned int events; +unsigned long 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 */
@@ -76,22 +67,54 @@ 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_read_lock (); + notify =rcu_dereference (nf_conntrack_event_cb); +if (notify ==NULL ) { +rcu_read_unlock (); +return ; + } +rcu_read_unlock (); + + e =nf_ct_ecache_find (ct); +if (e ==NULL ) +return ; + +set_bit (event, &e->cache); +} + +static inline void +nf_conntrack_event_bitmask_report (unsigned int bitmask, +struct nf_conn *ct,u32 pid,int report) +{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 (); +struct nf_ct_event_notifier *notify; + +rcu_read_lock (); + notify =rcu_dereference (nf_conntrack_event_cb); +if (notify ==NULL ) + goto out_unlock; + +if (!net->ct.sysctl_events) + 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 (bitmask, &item); + } +out_unlock: +rcu_read_unlock (); } static inline void
@@ -100,6 +123,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 ();
@@ -107,13 +131,16 @@ nf_conntrack_event_report(enum ip_conntrack_events event,if (notify ==NULL ) goto out_unlock; +if (!net->ct.sysctl_events) + 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); + notify->fcn ((1 << event), &item); } out_unlock:rcu_read_unlock ();
@@ -145,6 +172,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 ();
@@ -152,13 +180,16 @@ nf_ct_expect_event_report(enum ip_conntrack_expect_events event,if (notify ==NULL ) goto out_unlock; +if (!net->ct.sysctl_events) + goto out_unlock; + {struct nf_exp_event item = { .exp = exp, .pid = pid, .report = report }; - notify->fcn (event, &item); + notify->fcn ((1 << event), &item); } out_unlock:rcu_read_unlock ();
@@ -191,12 +222,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
@@ -15,15 +15,14 @@ struct netns_ct {struct hlist_head *expect_hash;struct hlist_nulls_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 +10 -7
@@ -576,6 +576,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);
@@ -738,6 +739,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
@@ -1035,8 +1039,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 ) {
@@ -1049,6 +1051,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);
@@ -1224,9 +1227,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,1 );if (!net->ct.hash) {
@@ -1240,6 +1240,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 */
@@ -1252,14 +1255,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
236 lines not on this page · raw message
net/netfilter/nf_conntrack_netlink.c +21 -23
105 lines not on this page · raw message
Pablo Neira Ayuso
maintainerPATCH 2/2 netfilter: conntrack: 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. During my stress tests consisting of setting a very small buffer of 2048 bytes for conntrackd and the NETLINK_BROADCAST_ERROR socket flag, and generating lots of very small connections, we hit "table full, dropping packet" at some point.
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, we have to introduce confirm and destroy events before.
---
include/net/netfilter/nf_conntrack.h | 2 + include/net/netfilter/nf_conntrack_core.h | 6 +- include/net/netfilter/nf_conntrack_ecache.h | 19 ++++-- include/net/netfilter/nf_conntrack_helper.h | 2 + include/net/netns/conntrack.h | 2 + net/netfilter/nf_conntrack_core.c | 89 ++++++++++++++++++++++----- net/netfilter/nf_conntrack_ecache.c | 24 ++++++- net/netfilter/nf_conntrack_helper.c | 15 +++++ net/netfilter/nf_conntrack_netlink.c | 58 ++++++++++++------ 9 files changed, 170 insertions(+), 47 deletions(-)
include/net/netfilter/nf_conntrack.h +2 -0
@@ -291,6 +291,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 +12 -7
@@ -24,6 +24,7 @@ enum ip_conntrack_eventsIPCT_MARK =6 ,/* new mark has been set */ IPCT_NATSEQADJ =7 ,/* NAT is doing sequence adjustment */ IPCT_SECMARK =8 ,/* new security mark has been set */ + IPCT_DELIVERY_FAILED = 31, /* previous event delivery has failed */ }; enum ip_conntrack_expect_events {
@@ -67,7 +68,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)
@@ -90,10 +91,11 @@ nf_conntrack_event_cache(enum ip_conntrack_events event, struct nf_conn *ct)set_bit (event, &e->cache); } -static inline void +static inline int nf_conntrack_event_bitmask_report (unsigned int bitmask,struct nf_conn *ct,u32 pid,int report) { +int ret =0 ;struct net *net =nf_ct_net (ct);struct nf_ct_event_notifier *notify;
@@ -111,18 +113,20 @@ nf_conntrack_event_bitmask_report(unsigned int bitmask, .pid = pid, .report = report }; - notify->fcn (bitmask, &item); + ret = notify->fcn (bitmask, &item); } out_unlock:rcu_read_unlock (); +return ret; } -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;
@@ -140,16 +144,17 @@ nf_conntrack_event_report(enum ip_conntrack_events event, .pid = pid, .report = report }; - notify->fcn ((1 << event), &item); + ret = notify->fcn ((1 << 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 {
include/net/netfilter/nf_conntrack_helper.h +2 -0
@@ -50,6 +50,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
@@ -14,8 +14,10 @@ struct netns_ct {struct hlist_nulls_head *hash;struct hlist_head *expect_hash;struct hlist_nulls_head unconfirmed; +struct hlist_nulls_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 +73 -16
127 lines not on this page · raw message
net/netfilter/nf_conntrack_ecache.c +21 -3
@@ -33,10 +33,11 @@ EXPORT_SYMBOL_GPL(nf_expect_event_cb);/* deliver cached events and clear cache entry - must be called with locally * disabled softirqs */ -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_bh (); notify =rcu_dereference (nf_conntrack_event_cb);
@@ -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_bh (); +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 +39 -19
106 lines not on this page · raw message
Pablo Neira Ayuso
maintainerRe: [PATCH 2/2] netfilter: conntrack: optional reliable conntrack event delivery
Quoted 2 lines · Pablo Neira Ayuso
This patch improves ctnetlink event reliability if one broadcast listener has set the
NETLINK_BROADCAST_ERRORsocket option.
I have just detected an inconsistency in the handling of IPCT_DELIVERY_FAILED, I'll resend this patch alone again.
Signature · 1 line
"Los honestos son inadaptados sociales" -- Les Luthiers
Pablo Neira Ayuso
maintainerQuoted 4 lines · Pablo Neira Ayuso
Hi Patrick!
This is the second part of the updates for the conntrack event subsystem.
Please, ignore this second part. I'm reworking it again and my mail server seems to have munched patch 1/2.
Signature · 1 line
"Los honestos son inadaptados sociales" -- Les Luthiers