improve conntrack event reliability (try 3)
Subsystems (2)
Pablo Neira Ayuso
maintainercover improve conntrack event reliability (try 3)
Hi Patrick,
Here it follows the third incarnation of the reliable event delivery for the conntrack event subsystem. I think that I did not miss any of your suggestions and comments from the last time. This patchset includes the missed cache approach that you have proposed today and Eric's ack'ed patch that I sent yesterday to add some missing functions to the nulls lists.
If you like them, you can pull them from:
git://1984.lsi.us.es/nf-next-2.6 master
Thanks!
---
Pablo Neira Ayuso (4):
netfilter: conntrack: optional reliable conntrack event delivery
list_nulls: add hlist_nulls_add_head and hlist_nulls_del
netfilter: conntrack: move helper destruction to nf_ct_helper_destroy()
netfilter: conntrack: move event caching to conntrack extension infrastructure
include/linux/list_nulls.h | 18 ++ include/net/netfilter/nf_conntrack.h | 2 include/net/netfilter/nf_conntrack_ecache.h | 160 ++++++++++++--------- 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 | 103 ++++++++++--- net/netfilter/nf_conntrack_ecache.c | 210 ++++++++++++++++++--------- net/netfilter/nf_conntrack_helper.c | 14 ++ net/netfilter/nf_conntrack_netlink.c | 68 +++++---- 10 files changed, 394 insertions(+), 192 deletions(-)
Pablo Neira Ayuso
maintainerPATCH 1/4 netfilter: conntrack: move event caching to conntrack extension infrastructure
This patch reworks the per-cpu event caching to use the conntrack extension infrastructure.
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.
BTW, this patch allows you to enable/disable event delivery via /proc/sys/net/netfilter/nf_conntrack_events in runtime, although you can still disable event caching as compilation option.
---
include/net/netfilter/nf_conntrack_ecache.h | 130 ++++++++++--------- include/net/netfilter/nf_conntrack_extend.h | 2 include/net/netns/conntrack.h | 5 - net/netfilter/nf_conntrack_core.c | 15 +- net/netfilter/nf_conntrack_ecache.c | 186 +++++++++++++++++---------- net/netfilter/nf_conntrack_netlink.c | 49 ++++--- 6 files changed, 224 insertions(+), 163 deletions(-)
include/net/netfilter/nf_conntrack_ecache.h +69 -61
@@ -6,61 +6,52 @@#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 ), +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 */ +}; -/* Update of protocol info */ -IPCT_PROTOINFO_BIT =4 , -IPCT_PROTOINFO = (1 <<IPCT_PROTOINFO_BIT ), +enum ip_conntrack_expect_events { +IPEXP_NEW =0 ,/* new expectation */ +}; -/* New helper for conntrack */ -IPCT_HELPER_BIT =5 , -IPCT_HELPER = (1 <<IPCT_HELPER_BIT ), +struct nf_conntrack_ecache { +unsigned long cache;/* bitops want long */ +}; -/* Mark is set */ -IPCT_MARK_BIT =6 , -IPCT_MARK = (1 <<IPCT_MARK_BIT ), +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 ); +} -/* NAT sequence adjustment */ -IPCT_NATSEQADJ_BIT =7 , -IPCT_NATSEQADJ = (1 <<IPCT_NATSEQADJ_BIT ), +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); -/* Secmark is set */ -IPCT_SECMARK_BIT =8 , -IPCT_SECMARK = (1 <<IPCT_SECMARK_BIT ), -}; +if (!net->ct.sysctl_events) +return NULL ; -enum ip_conntrack_expect_events { -IPEXP_NEW_BIT =0 , -IPEXP_NEW = (1 <<IPEXP_NEW_BIT ), +return nf_ct_ext_add (ct,NF_CT_EXT_ECACHE , gfp); }; #ifdef CONFIG_NF_CONNTRACK_EVENTS -struct nf_conntrack_ecache { - struct nf_conn *ct; - unsigned int events; -}; - /* This structure is passed to event handler */ struct nf_ct_event { struct nf_conn *ct;
@@ -76,30 +67,30 @@ extern struct nf_ct_event_notifier *nf_conntrack_event_cb;extern int nf_conntrack_register_notifier (struct nf_ct_event_notifier *nb);extern void 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 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_conntrack_ecache *e; + +if (nf_conntrack_event_cb ==NULL ) +return ; + + e =nf_ct_ecache_find (ct); +if (e ==NULL ) +return ; + +set_bit (event, &e->cache); }static inline void -nf_conntrack_event_report (enum ip_conntrack_events event, -struct nf_conn *ct, -u32 pid, -int report) +nf_conntrack_eventmask_report (unsigned int eventmask, +struct nf_conn *ct, +u32 pid, +int report) { +struct net *net =nf_ct_net (ct);struct nf_ct_event_notifier *notify;rcu_read_lock ();
@@ -107,22 +98,32 @@ 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 (eventmask, &item); } out_unlock:rcu_read_unlock (); }static inline void +nf_conntrack_event_report (enum ip_conntrack_events event,struct nf_conn *ct, +u32 pid,int report) +{ +nf_conntrack_eventmask_report (1 << event, ct, pid, report); +} + +static inline void nf_conntrack_event (enum ip_conntrack_events event,struct nf_conn *ct) { -nf_conntrack_event_report (event, ct,0 ,0 ); +nf_conntrack_eventmask_report (1 << event, ct,0 ,0 ); }struct nf_exp_event {
@@ -145,6 +146,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 +154,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 ();
@@ -178,6 +183,10 @@ extern void nf_conntrack_ecache_fini(struct net *net);static inline void nf_conntrack_event_cache (enum ip_conntrack_events event,struct nf_conn *ct) {} +static inline void nf_conntrack_eventmask_report (unsigned int eventmask, +struct nf_conn *ct, +u32 pid, +int report) {}static inline void nf_conntrack_event (enum ip_conntrack_events event,struct nf_conn *ct) {} static inline void nf_conntrack_event_report(enum ip_conntrack_events event,
@@ -191,7 +200,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) {
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 +8 -7
@@ -39,6 +39,7 @@#include <net/netfilter/nf_conntrack_core.h> #include <net/netfilter/nf_conntrack_extend.h> #include <net/netfilter/nf_conntrack_acct.h> +#include <net/netfilter/nf_conntrack_ecache.h> #include <net/netfilter/nf_nat.h> #include <net/netfilter/nf_nat_core.h>
@@ -577,6 +578,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);
@@ -1036,8 +1038,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 ) {
@@ -1050,6 +1050,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);
@@ -1225,9 +1226,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) {
@@ -1241,6 +1239,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 */
@@ -1253,14 +1254,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 +118 -68
221 lines not on this page · raw message
net/netfilter/nf_conntrack_netlink.c +25 -24
112 lines not on this page · raw message
Pablo Neira Ayuso
maintainerPATCH 2/4 netfilter: conntrack: move helper destruction to nf_ct_helper_destroy()
In reply to Pablo Neira AyusoThis patch moves the helper destruction to a function that lives in nf_conntrack_helper.c. This new function is used in the patch to add ctnetlink reliable event delivery.
---
include/net/netfilter/nf_conntrack_helper.h | 2 ++ net/netfilter/nf_conntrack_core.c | 11 +---------- net/netfilter/nf_conntrack_helper.c | 14 ++++++++++++++ 3 files changed, 17 insertions(+), 10 deletions(-)
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 );
net/netfilter/nf_conntrack_core.c +1 -10
@@ -224,17 +224,8 @@ static void death_by_timeout(unsigned long ul_conntrack) {struct nf_conn *ct = (void *)ul_conntrack;struct net *net =nf_ct_net (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 (); - } +nf_ct_helper_destroy (ct);spin_lock_bh (&nf_conntrack_lock);/* Inside lock so preempt is disabled on module removal path. * Otherwise we can get spurious warnings. */
net/netfilter/nf_conntrack_helper.c +14 -0
@@ -136,6 +136,20 @@ 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 (); + } +} +int nf_conntrack_helper_register (struct nf_conntrack_helper *me) {unsigned int h =helper_hash (&me->tuple);
Pablo Neira Ayuso
maintainerPATCH 3/4 list_nulls: add hlist_nulls_add_head and hlist_nulls_del
In reply to Pablo Neira AyusoThis patch adds the hlist_nulls_add_head() function which is based on hlist_nulls_add_head_rcu() but without the use of rcu_assign_pointer(). It also adds hlist_nulls_del which is exactly the same like hlist_nulls_del_rcu().
---
include/linux/list_nulls.h | 18 ++++++++++++++++++ 1 files changed, 18 insertions(+), 0 deletions(-)
include/linux/list_nulls.h +18 -0
@@ -56,6 +56,18 @@ static inline int hlist_nulls_empty(const struct hlist_nulls_head *h)return is_a_nulls (h->first); } +static inline void hlist_nulls_add_head (struct hlist_nulls_node *n, +struct hlist_nulls_head *h) +{ +struct hlist_nulls_node *first = h->first; + + n->next = first; + n->pprev = &h->first; + h->first = n; +if (!is_a_nulls (first)) + first->pprev = &n->next; +} +static inline void __hlist_nulls_del (struct hlist_nulls_node *n) {struct hlist_nulls_node *next = n->next;
@@ -65,6 +77,12 @@ static inline void __hlist_nulls_del(struct hlist_nulls_node *n) next->pprev = pprev; } +static inline void hlist_nulls_del (struct hlist_nulls_node *n) +{ +__hlist_nulls_del (n); + n->pprev =LIST_POISON2 ; +} +/** * hlist_nulls_for_each_entry - iterate over list of given type * @tpos: the type * to use as a loop cursor.
Pablo Neira Ayuso
maintainerPATCH 4/4 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 an event delivery fails, we keep the undelivered events in the missed event cache. Once the next packet arrives, we add the new events (if any) to the missed events in the cache and we try a new delivery, and so on. Thus, if ctnetlink fails to deliver an event, we try to deliver them once we see a new packet. Therefore, we may lose 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. Basically, if ctnetlink fails to deliver the destroy event, we remove the conntrack entry from the hashes and we insert them in the dying list, which contains inactive entries. Then, the conntrack timer is added with an extra grace timeout of random32() % 15 seconds to trigger the event again (this grace timeout is tunable via /proc). The use of a limited random timeout value allows distributing the "destroy" resends, thus, avoiding accumulating lots "destroy" events at the same time. Event delivery may re-order but we can identify them by means of the tuple plus the conntrack ID.
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 that did not successfully report 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, I noticed very few destroy entries on the fly waiting to be resend.
A simple way to test this patch consist of creating a lot of entries, set a very small Netlink buffer in conntrackd (+ a patch which is not in the git tree to set the BROADCAST_ERROR flag) and invoke `conntrack -F'.
For expectations, no changes are introduced in this patch. Currently, event delivery is only done for new expectations (no events from expectation expiration, removal and confirmation). In that case, they need a per-expectation event cache to implement the same idea that is exposed in this patch.
This patch can be useful to provide reliable flow-accouting. We still have to add a new conntrack extension to store the creation and destroy time.
---
include/net/netfilter/nf_conntrack.h | 2 + include/net/netfilter/nf_conntrack_ecache.h | 46 +++++++++++----- include/net/netns/conntrack.h | 2 + net/netfilter/nf_conntrack_core.c | 77 +++++++++++++++++++++++++-- net/netfilter/nf_conntrack_ecache.c | 28 +++++++++- net/netfilter/nf_conntrack_netlink.c | 19 +++++-- 6 files changed, 145 insertions(+), 29 deletions(-)
include/net/netfilter/nf_conntrack.h +2 -0
@@ -204,6 +204,8 @@ extern struct nf_conntrack_tuple_hash * __nf_conntrack_find(struct net *net, const struct nf_conntrack_tuple *tuple);extern void nf_conntrack_hash_insert (struct nf_conn *ct); +extern void nf_ct_delete_from_lists (struct nf_conn *ct); +extern void nf_ct_insert_dying_list (struct nf_conn *ct);extern void nf_conntrack_flush_report (struct net *net,u32 pid,int report);
include/net/netfilter/nf_conntrack_ecache.h +30 -16
87 lines not on this page · raw message
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 +71 -6
114 lines not on this page · raw message
net/netfilter/nf_conntrack_ecache.c +26 -2
@@ -56,8 +56,21 @@ void nf_ct_deliver_cached_events(struct nf_conn *ct) .pid = 0, .report = 0 }; - - notify->fcn (events, &item); +int ret; +/* We make a copy of the missed event cache without taking +* the lock, thus we may send missed events twice. However, +* this does not harm and it happens very rarely. */ +unsigned long missed = e->missed; + + ret = notify->fcn (events | missed, &item); +if (unlikely (ret <0 || missed)) { +spin_lock_bh (&ct->lock); +if (ret <0 ) + e->missed |= events; +else + e->missed &= ~missed; +spin_unlock_bh (&ct->lock); + } } out_unlock:
@@ -133,6 +146,7 @@ EXPORT_SYMBOL_GPL(nf_ct_expect_unregister_notifier);#define NF_CT_EVENTS_DEFAULT 1static int nf_ct_events__read_mostly =NF_CT_EVENTS_DEFAULT ; +static int nf_ct_events_retry_timeout__read_mostly =15 *HZ ;#ifdef CONFIG_SYSCTL static struct ctl_table event_sysctl_table[] = {
@@ -144,6 +158,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 */
@@ -166,6 +188,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,
@@ -206,6 +229,7 @@ int nf_conntrack_ecache_init(struct net *net)int ret; net->ct.sysctl_events = nf_ct_events; + 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_netlink.c +14 -5
@@ -463,6 +463,7 @@ ctnetlink_conntrack_event(unsigned int events, struct nf_ct_event *item)struct sk_buff *skb;unsigned int type;unsigned int flags =0 , group; +int err;/* ignore our fake conntrack entry */ if (ct == &nf_conntrack_untracked)
@@ -558,7 +559,10 @@ ctnetlink_conntrack_event(unsigned int events, struct nf_ct_event *item)rcu_read_unlock ();nlmsg_end (skb, nlh); -nfnetlink_send (skb, item->pid, group, item->report,GFP_ATOMIC ); + err =nfnetlink_send (skb, item->pid, group, item->report,GFP_ATOMIC ); +if (err == -ENOBUFS || err == -EAGAIN ) +return -ENOBUFS ; +return 0 ; nla_put_failure:
@@ -798,10 +802,15 @@ ctnetlink_del_conntrack(struct sock *ctnl, struct sk_buff *skb, } } -nf_conntrack_event_report (IPCT_DESTROY , - ct, -NETLINK_CB (skb).pid, -nlmsg_report (nlh)); +if (nf_conntrack_event_report (IPCT_DESTROY , ct, +NETLINK_CB (skb).pid, +nlmsg_report (nlh)) <0 ) { +nf_ct_delete_from_lists (ct); +/* we failed to report the event, try later */ +nf_ct_insert_dying_list (ct); +nf_ct_put (ct); +return 0 ; + }/* death_by_timeout would report the event again */ set_bit (IPS_DYING_BIT , &ct->status);
Pablo Neira Ayuso
maintainerRe: [PATCH 4/4] 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.
This is missing reliable event delivery for _eventmask_report(). I'm going to resend this patch. Sorry and rebase my git tree with the new patch.
Signature · 1 line
"Los honestos son inadaptados sociales" -- Les Luthiers
Re: [PATCH 4/4] netfilter: conntrack: optional reliable conntrack event delivery
Quoted 6 lines · Pablo Neira Ayuso
Quoted 2 lines · Pablo Neira Ayuso
This patch improves ctnetlink event reliability if one broadcast listener has set the
NETLINK_BROADCAST_ERRORsocket option.This is missing reliable event delivery for
_eventmask_report(). I'm going to resend this patch. Sorry and rebase my git tree with the new patch.
OK thanks. I'll back them out again from my tree :)
Pablo Neira Ayuso
maintainerRe: [PATCH 4/4] netfilter: conntrack: optional reliable conntrack event delivery
Quoted 10 lines · Patrick McHardy
Quoted 7 lines · Pablo Neira Ayuso
Quoted 2 lines · Pablo Neira Ayuso
This patch improves ctnetlink event reliability if one broadcast listener has set the
NETLINK_BROADCAST_ERRORsocket option.This is missing reliable event delivery for
_eventmask_report(). I'm going to resend this patch. Sorry and rebase my git tree with the new patch.OK thanks. I'll back them out again from my tree :)
There's another issue that I have to fix here that I haven't noticed so far:
+ if (nf_conntrack_event_report(IPCT_DESTROY, ct,
+ NETLINK_CB(skb).pid,
+ nlmsg_report(nlh)) < 0) {
+ nf_ct_delete_from_lists(ct); + /* we failed to report the event, try later */ + nf_ct_insert_dying_list(ct); + nf_ct_put(ct); + return 0;
+ }
With this, we send the first destroy event including the netlink pid. However, in the second try, we send it using netlink pid 0. The netlink pid is important to notice who has triggered this event (the kernel, myself or a different process). So I think that I need to add some structure like:
struct nf_conn_dying {
struct list_head head;
u32 pid;
struct nf_conn *ct;
};Thus, destroy events are delivered using the original netlink pid. I can get rid of using the nulls list in that case.
I think this is necessary, or I'm completely driving nuts and seeing ghosts everywhere :D. Patrick, You still plan to send the patches for 2.6.31 along today? I think that I need one extra day, I have to leave now and I cannot work on this until tomorrow morning.
Signature · 1 line
"Los honestos son inadaptados sociales" -- Les Luthiers
Re: [PATCH 4/4] netfilter: conntrack: optional reliable conntrack event delivery
Quoted 24 lines · Pablo Neira Ayuso
There's another issue that I have to fix here that I haven't noticed so far:
net/netfilter/nf_conntrack_netlink.c +9
-0+if (nf_conntrack_event_report (IPCT_DESTROY , ct, +NETLINK_CB (skb).pid, +nlmsg_report (nlh)) <0 ) { +nf_ct_delete_from_lists (ct); +/* we failed to report the event, try later */ +nf_ct_insert_dying_list (ct); +nf_ct_put (ct); +return 0 ; + }With this, we send the first destroy event including the netlink pid. However, in the second try, we send it using netlink pid 0. The netlink pid is important to notice who has triggered this event (the kernel, myself or a different process). So I think that I need to add some structure like:
struct nf_conn_dying { struct list_head head; u32 pid; struct nf_conn *ct; };
Quoted 5 lines
Thus, destroy events are delivered using the original netlink pid. I can get rid of using the nulls list in that case.
I think this is necessary, or I'm completely driving nuts and seeing ghosts everywhere :D.
I agree, this is necessary. But I'd add the pid to the event structure instead of adding a completely new structure I think. Or perhaps we can reuse an unused-at-that-time conntrack member.
Quoted 3 lines
Patrick, You still plan to send the patches for
2.6.31 along today? I think that I need one extra day, I have to leave now and I cannot work on this until tomorrow morning.
Yes, the networking merge window closes a lot earlier than the general kernel merge window and I have to get the other patches in.
I can delay it today, but I don't want to risk waiting until tomorrow.
Pablo Neira Ayuso
maintainerRe: [PATCH 4/4] netfilter: conntrack: optional reliable conntrack event delivery
Quoted 4 lines · Patrick McHardy
Yes, the networking merge window closes a lot earlier than the general kernel merge window and I have to get the other patches in.
I can delay it today, but I don't want to risk waiting until tomorrow.
I'm going to take my laptop with me to see if I can finish it during some spare time. Let's see if I reach the merge window in time :-).
Signature · 1 line
"Los honestos son inadaptados sociales" -- Les Luthiers
Pablo Neira Ayuso
maintainerRe: [PATCH 4/4] netfilter: conntrack: optional reliable conntrack event delivery
Quoted 8 lines · Pablo Neira Ayuso
Quoted 4 lines · Patrick McHardy
Yes, the networking merge window closes a lot earlier than the general kernel merge window and I have to get the other patches in.
I can delay it today, but I don't want to risk waiting until tomorrow.
I'm going to take my laptop with me to see if I can finish it during some spare time. Let's see if I reach the merge window in time :-).
Attached the version that includes a new pid field in the cache structure to store the netlink pid of the destroyer process (in case that it needs to be retransmitted).
Please, you can pull this and the previous three from!
git://1984.lsi.us.es/nf-next-2.6 master
Signature · 1 line
"Los honestos son inadaptados sociales" -- Les Luthiers
netfilter: conntrack: optional reliable conntrack event delivery
From: Pablo Neira Ayuso <[email protected]>
This patch improves ctnetlink event reliability if one broadcast listener has set the NETLINK_BROADCAST_ERROR socket option.
The logic is the following: if an event delivery fails, we keep the undelivered events in the missed event cache. Once the next packet arrives, we add the new events (if any) to the missed events in the cache and we try a new delivery, and so on. Thus, if ctnetlink fails to deliver an event, we try to deliver them once we see a new packet. Therefore, we may lose 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. Basically, if ctnetlink fails to deliver the destroy event, we remove the conntrack entry from the hashes and we insert them in the dying list, which contains inactive entries. Then, the conntrack timer is added with an extra grace timeout of random32() % 15 seconds to trigger the event again (this grace timeout is tunable via /proc). The use of a limited random timeout value allows distributing the "destroy" resends, thus, avoiding accumulating lots "destroy" events at the same time. Event delivery may re-order but we can identify them by means of the tuple plus the conntrack ID.
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 that did not successfully report 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, I noticed very few destroy entries on the fly waiting to be resend.
A simple way to test this patch consist of creating a lot of entries, set a very small Netlink buffer in conntrackd (+ a patch which is not in the git tree to set the BROADCAST_ERROR flag) and invoke `conntrack -F'.
For expectations, no changes are introduced in this patch. Currently, event delivery is only done for new expectations (no events from expectation expiration, removal and confirmation). In that case, they need a per-expectation event cache to implement the same idea that is exposed in this patch.
This patch can be useful to provide reliable flow-accouting. We still have to add a new conntrack extension to store the creation and destroy time.
---
include/net/netfilter/nf_conntrack.h | 2 + include/net/netfilter/nf_conntrack_ecache.h | 61 +++++++++++++------ include/net/netns/conntrack.h | 2 + net/netfilter/nf_conntrack_core.c | 89 ++++++++++++++++++++++++--- net/netfilter/nf_conntrack_ecache.c | 28 ++++++++ net/netfilter/nf_conntrack_netlink.c | 19 ++++-- 6 files changed, 166 insertions(+), 35 deletions(-)
include/net/netfilter/nf_conntrack.h +2 -0
@@ -204,6 +204,8 @@ extern struct nf_conntrack_tuple_hash * __nf_conntrack_find(struct net *net, const struct nf_conntrack_tuple *tuple);extern void nf_conntrack_hash_insert (struct nf_conn *ct); +extern void nf_ct_delete_from_lists (struct nf_conn *ct); +extern void nf_ct_insert_dying_list (struct nf_conn *ct);extern void nf_conntrack_flush_report (struct net *net,u32 pid,int report);
include/net/netfilter/nf_conntrack_ecache.h +44 -17
109 lines not on this page · raw message
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 +78 -11
132 lines not on this page · raw message
net/netfilter/nf_conntrack_ecache.c +26 -2
@@ -56,8 +56,21 @@ void nf_ct_deliver_cached_events(struct nf_conn *ct) .pid = 0, .report = 0 }; - - notify->fcn (events, &item); +int ret; +/* We make a copy of the missed event cache without taking +* the lock, thus we may send missed events twice. However, +* this does not harm and it happens very rarely. */ +unsigned long missed = e->missed; + + ret = notify->fcn (events | missed, &item); +if (unlikely (ret <0 || missed)) { +spin_lock_bh (&ct->lock); +if (ret <0 ) + e->missed |= events; +else + e->missed &= ~missed; +spin_unlock_bh (&ct->lock); + } } out_unlock:
@@ -133,6 +146,7 @@ EXPORT_SYMBOL_GPL(nf_ct_expect_unregister_notifier);#define NF_CT_EVENTS_DEFAULT 1static int nf_ct_events__read_mostly =NF_CT_EVENTS_DEFAULT ; +static int nf_ct_events_retry_timeout__read_mostly =15 *HZ ;#ifdef CONFIG_SYSCTL static struct ctl_table event_sysctl_table[] = {
@@ -144,6 +158,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 */
@@ -166,6 +188,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,
@@ -206,6 +229,7 @@ int nf_conntrack_ecache_init(struct net *net)int ret; net->ct.sysctl_events = nf_ct_events; + 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_netlink.c +14 -5
@@ -463,6 +463,7 @@ ctnetlink_conntrack_event(unsigned int events, struct nf_ct_event *item)struct sk_buff *skb;unsigned int type;unsigned int flags =0 , group; +int err;/* ignore our fake conntrack entry */ if (ct == &nf_conntrack_untracked)
@@ -558,7 +559,10 @@ ctnetlink_conntrack_event(unsigned int events, struct nf_ct_event *item)rcu_read_unlock ();nlmsg_end (skb, nlh); -nfnetlink_send (skb, item->pid, group, item->report,GFP_ATOMIC ); + err =nfnetlink_send (skb, item->pid, group, item->report,GFP_ATOMIC ); +if (err == -ENOBUFS || err == -EAGAIN ) +return -ENOBUFS ; +return 0 ; nla_put_failure:
@@ -798,10 +802,15 @@ ctnetlink_del_conntrack(struct sock *ctnl, struct sk_buff *skb, } } -nf_conntrack_event_report (IPCT_DESTROY , - ct, -NETLINK_CB (skb).pid, -nlmsg_report (nlh)); +if (nf_conntrack_event_report (IPCT_DESTROY , ct, +NETLINK_CB (skb).pid, +nlmsg_report (nlh)) <0 ) { +nf_ct_delete_from_lists (ct); +/* we failed to report the event, try later */ +nf_ct_insert_dying_list (ct); +nf_ct_put (ct); +return 0 ; + }/* death_by_timeout would report the event again */ set_bit (IPS_DYING_BIT , &ct->status);