2006-11-28 18:35:01 -07:00
|
|
|
/*
|
|
|
|
* connection tracking event cache.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _NF_CONNTRACK_ECACHE_H
|
|
|
|
#define _NF_CONNTRACK_ECACHE_H
|
|
|
|
#include <net/netfilter/nf_conntrack.h>
|
|
|
|
|
2008-10-08 03:35:07 -06:00
|
|
|
#include <net/net_namespace.h>
|
2006-11-28 18:35:01 -07:00
|
|
|
#include <net/netfilter/nf_conntrack_expect.h>
|
2009-06-13 04:26:29 -06:00
|
|
|
#include <linux/netfilter/nf_conntrack_common.h>
|
|
|
|
#include <linux/netfilter/nf_conntrack_tuple_common.h>
|
|
|
|
#include <net/netfilter/nf_conntrack_extend.h>
|
2006-11-28 18:35:01 -07:00
|
|
|
|
2009-06-13 04:26:29 -06:00
|
|
|
struct nf_conntrack_ecache {
|
2010-02-03 05:51:51 -07:00
|
|
|
unsigned long cache; /* bitops want long */
|
|
|
|
unsigned long missed; /* missed events */
|
|
|
|
u16 ctmask; /* bitmask of ct events to be delivered */
|
|
|
|
u16 expmask; /* bitmask of expect events to be delivered */
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid; /* netlink portid of destroyer */
|
2009-06-13 04:26:29 -06:00
|
|
|
};
|
2009-06-02 12:08:44 -06:00
|
|
|
|
2009-06-13 04:26:29 -06:00
|
|
|
static inline struct nf_conntrack_ecache *
|
|
|
|
nf_ct_ecache_find(const struct nf_conn *ct)
|
|
|
|
{
|
2010-11-15 04:23:24 -07:00
|
|
|
#ifdef CONFIG_NF_CONNTRACK_EVENTS
|
2009-06-13 04:26:29 -06:00
|
|
|
return nf_ct_ext_find(ct, NF_CT_EXT_ECACHE);
|
2010-11-15 04:23:24 -07:00
|
|
|
#else
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-06-13 04:26:29 -06:00
|
|
|
}
|
2009-06-02 12:08:44 -06:00
|
|
|
|
2009-06-13 04:26:29 -06:00
|
|
|
static inline struct nf_conntrack_ecache *
|
2010-02-03 05:51:51 -07:00
|
|
|
nf_ct_ecache_ext_add(struct nf_conn *ct, u16 ctmask, u16 expmask, gfp_t gfp)
|
2009-06-13 04:26:29 -06:00
|
|
|
{
|
2010-11-15 04:23:24 -07:00
|
|
|
#ifdef CONFIG_NF_CONNTRACK_EVENTS
|
2009-06-13 04:26:29 -06:00
|
|
|
struct net *net = nf_ct_net(ct);
|
2010-02-03 05:51:51 -07:00
|
|
|
struct nf_conntrack_ecache *e;
|
2009-06-02 12:08:44 -06:00
|
|
|
|
2010-02-03 05:51:51 -07:00
|
|
|
if (!ctmask && !expmask && net->ct.sysctl_events) {
|
|
|
|
ctmask = ~0;
|
|
|
|
expmask = ~0;
|
|
|
|
}
|
|
|
|
if (!ctmask && !expmask)
|
2009-06-13 04:26:29 -06:00
|
|
|
return NULL;
|
2009-06-02 12:08:44 -06:00
|
|
|
|
2010-02-03 05:51:51 -07:00
|
|
|
e = nf_ct_ext_add(ct, NF_CT_EXT_ECACHE, gfp);
|
|
|
|
if (e) {
|
|
|
|
e->ctmask = ctmask;
|
|
|
|
e->expmask = expmask;
|
|
|
|
}
|
|
|
|
return e;
|
2010-11-15 04:23:24 -07:00
|
|
|
#else
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-06-02 12:08:44 -06:00
|
|
|
};
|
|
|
|
|
2006-11-28 18:35:01 -07:00
|
|
|
#ifdef CONFIG_NF_CONNTRACK_EVENTS
|
2008-11-18 03:56:20 -07:00
|
|
|
/* This structure is passed to event handler */
|
|
|
|
struct nf_ct_event {
|
|
|
|
struct nf_conn *ct;
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid;
|
2008-11-18 03:56:20 -07:00
|
|
|
int report;
|
|
|
|
};
|
|
|
|
|
2009-06-03 02:32:06 -06:00
|
|
|
struct nf_ct_event_notifier {
|
|
|
|
int (*fcn)(unsigned int events, struct nf_ct_event *item);
|
|
|
|
};
|
|
|
|
|
2013-09-23 12:37:48 -06:00
|
|
|
int nf_conntrack_register_notifier(struct net *net,
|
|
|
|
struct nf_ct_event_notifier *nb);
|
|
|
|
void nf_conntrack_unregister_notifier(struct net *net,
|
|
|
|
struct nf_ct_event_notifier *nb);
|
2006-11-28 18:35:01 -07:00
|
|
|
|
2013-09-23 12:37:48 -06:00
|
|
|
void nf_ct_deliver_cached_events(struct nf_conn *ct);
|
2006-11-28 18:35:01 -07:00
|
|
|
|
|
|
|
static inline void
|
2008-10-08 03:35:07 -06:00
|
|
|
nf_conntrack_event_cache(enum ip_conntrack_events event, struct nf_conn *ct)
|
2006-11-28 18:35:01 -07:00
|
|
|
{
|
2011-11-21 16:16:51 -07:00
|
|
|
struct net *net = nf_ct_net(ct);
|
2009-06-13 04:26:29 -06:00
|
|
|
struct nf_conntrack_ecache *e;
|
|
|
|
|
2012-07-05 07:42:10 -06:00
|
|
|
if (!rcu_access_pointer(net->ct.nf_conntrack_event_cb))
|
2009-06-13 04:26:29 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
e = nf_ct_ecache_find(ct);
|
|
|
|
if (e == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
set_bit(event, &e->cache);
|
2006-11-28 18:35:01 -07:00
|
|
|
}
|
|
|
|
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
static inline int
|
2009-06-13 04:26:29 -06:00
|
|
|
nf_conntrack_eventmask_report(unsigned int eventmask,
|
|
|
|
struct nf_conn *ct,
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid,
|
2009-06-13 04:26:29 -06:00
|
|
|
int report)
|
2006-11-28 18:35:01 -07:00
|
|
|
{
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
int ret = 0;
|
2011-11-21 16:16:51 -07:00
|
|
|
struct net *net = nf_ct_net(ct);
|
2009-06-03 02:32:06 -06:00
|
|
|
struct nf_ct_event_notifier *notify;
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
struct nf_conntrack_ecache *e;
|
2009-06-03 02:32:06 -06:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2011-11-21 16:16:51 -07:00
|
|
|
notify = rcu_dereference(net->ct.nf_conntrack_event_cb);
|
2009-06-03 02:32:06 -06:00
|
|
|
if (notify == NULL)
|
|
|
|
goto out_unlock;
|
|
|
|
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
e = nf_ct_ecache_find(ct);
|
|
|
|
if (e == NULL)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2009-06-03 02:32:06 -06:00
|
|
|
if (nf_ct_is_confirmed(ct) && !nf_ct_is_dying(ct)) {
|
|
|
|
struct nf_ct_event item = {
|
|
|
|
.ct = ct,
|
2012-09-07 14:12:54 -06:00
|
|
|
.portid = e->portid ? e->portid : portid,
|
2009-06-03 02:32:06 -06:00
|
|
|
.report = report
|
|
|
|
};
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
/* This is a resent of a destroy event? If so, skip missed */
|
2012-09-07 14:12:54 -06:00
|
|
|
unsigned long missed = e->portid ? 0 : e->missed;
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
|
2010-02-03 05:51:51 -07:00
|
|
|
if (!((eventmask | missed) & e->ctmask))
|
|
|
|
goto out_unlock;
|
|
|
|
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
ret = notify->fcn(eventmask | missed, &item);
|
|
|
|
if (unlikely(ret < 0 || missed)) {
|
|
|
|
spin_lock_bh(&ct->lock);
|
|
|
|
if (ret < 0) {
|
|
|
|
/* This is a destroy event that has been
|
2012-09-07 14:12:54 -06:00
|
|
|
* triggered by a process, we store the PORTID
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
* to include it in the retransmission. */
|
|
|
|
if (eventmask & (1 << IPCT_DESTROY) &&
|
2012-09-07 14:12:54 -06:00
|
|
|
e->portid == 0 && portid != 0)
|
|
|
|
e->portid = portid;
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
else
|
|
|
|
e->missed |= eventmask;
|
|
|
|
} else
|
|
|
|
e->missed &= ~missed;
|
|
|
|
spin_unlock_bh(&ct->lock);
|
|
|
|
}
|
2009-06-03 02:32:06 -06:00
|
|
|
}
|
|
|
|
out_unlock:
|
|
|
|
rcu_read_unlock();
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
return ret;
|
2006-11-28 18:35:01 -07:00
|
|
|
}
|
|
|
|
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
static inline int
|
2009-06-13 04:26:29 -06:00
|
|
|
nf_conntrack_event_report(enum ip_conntrack_events event, struct nf_conn *ct,
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid, int report)
|
2009-06-13 04:26:29 -06:00
|
|
|
{
|
2012-09-07 14:12:54 -06:00
|
|
|
return nf_conntrack_eventmask_report(1 << event, ct, portid, report);
|
2009-06-13 04:26:29 -06:00
|
|
|
}
|
|
|
|
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
static inline int
|
2008-11-18 03:56:20 -07:00
|
|
|
nf_conntrack_event(enum ip_conntrack_events event, struct nf_conn *ct)
|
|
|
|
{
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
return nf_conntrack_eventmask_report(1 << event, ct, 0, 0);
|
2008-11-18 03:56:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
struct nf_exp_event {
|
|
|
|
struct nf_conntrack_expect *exp;
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid;
|
2008-11-18 03:56:20 -07:00
|
|
|
int report;
|
|
|
|
};
|
|
|
|
|
2009-06-03 02:32:06 -06:00
|
|
|
struct nf_exp_event_notifier {
|
|
|
|
int (*fcn)(unsigned int events, struct nf_exp_event *item);
|
|
|
|
};
|
|
|
|
|
2013-09-23 12:37:48 -06:00
|
|
|
int nf_ct_expect_register_notifier(struct net *net,
|
|
|
|
struct nf_exp_event_notifier *nb);
|
|
|
|
void nf_ct_expect_unregister_notifier(struct net *net,
|
|
|
|
struct nf_exp_event_notifier *nb);
|
2007-03-14 17:40:10 -06:00
|
|
|
|
2008-11-18 03:56:20 -07:00
|
|
|
static inline void
|
|
|
|
nf_ct_expect_event_report(enum ip_conntrack_expect_events event,
|
|
|
|
struct nf_conntrack_expect *exp,
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid,
|
2008-11-18 03:56:20 -07:00
|
|
|
int report)
|
|
|
|
{
|
2011-11-21 16:16:51 -07:00
|
|
|
struct net *net = nf_ct_exp_net(exp);
|
2009-06-03 02:32:06 -06:00
|
|
|
struct nf_exp_event_notifier *notify;
|
2010-02-03 05:51:51 -07:00
|
|
|
struct nf_conntrack_ecache *e;
|
2009-06-03 02:32:06 -06:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2011-11-21 16:16:51 -07:00
|
|
|
notify = rcu_dereference(net->ct.nf_expect_event_cb);
|
2009-06-03 02:32:06 -06:00
|
|
|
if (notify == NULL)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2010-02-03 05:51:51 -07:00
|
|
|
e = nf_ct_ecache_find(exp->master);
|
|
|
|
if (e == NULL)
|
2009-06-13 04:26:29 -06:00
|
|
|
goto out_unlock;
|
|
|
|
|
2010-02-03 05:51:51 -07:00
|
|
|
if (e->expmask & (1 << event)) {
|
2009-06-03 02:32:06 -06:00
|
|
|
struct nf_exp_event item = {
|
|
|
|
.exp = exp,
|
2012-09-07 14:12:54 -06:00
|
|
|
.portid = portid,
|
2009-06-03 02:32:06 -06:00
|
|
|
.report = report
|
|
|
|
};
|
2009-06-13 04:26:29 -06:00
|
|
|
notify->fcn(1 << event, &item);
|
2009-06-03 02:32:06 -06:00
|
|
|
}
|
|
|
|
out_unlock:
|
|
|
|
rcu_read_unlock();
|
2008-11-18 03:56:20 -07:00
|
|
|
}
|
|
|
|
|
2006-11-28 18:35:01 -07:00
|
|
|
static inline void
|
2007-07-07 23:30:49 -06:00
|
|
|
nf_ct_expect_event(enum ip_conntrack_expect_events event,
|
|
|
|
struct nf_conntrack_expect *exp)
|
2006-11-28 18:35:01 -07:00
|
|
|
{
|
2008-11-18 03:56:20 -07:00
|
|
|
nf_ct_expect_event_report(event, exp, 0, 0);
|
2006-11-28 18:35:01 -07:00
|
|
|
}
|
|
|
|
|
2013-09-23 12:37:48 -06:00
|
|
|
int nf_conntrack_ecache_pernet_init(struct net *net);
|
|
|
|
void nf_conntrack_ecache_pernet_fini(struct net *net);
|
2008-10-08 03:35:07 -06:00
|
|
|
|
2013-09-23 12:37:48 -06:00
|
|
|
int nf_conntrack_ecache_init(void);
|
|
|
|
void nf_conntrack_ecache_fini(void);
|
2006-11-28 18:35:01 -07:00
|
|
|
|
2014-06-10 15:12:56 -06:00
|
|
|
static inline void nf_conntrack_ecache_delayed_work(struct net *net)
|
|
|
|
{
|
|
|
|
if (!delayed_work_pending(&net->ct.ecache_dwork)) {
|
|
|
|
schedule_delayed_work(&net->ct.ecache_dwork, HZ);
|
|
|
|
net->ct.ecache_dwork_pending = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void nf_conntrack_ecache_work(struct net *net)
|
|
|
|
{
|
|
|
|
if (net->ct.ecache_dwork_pending) {
|
|
|
|
net->ct.ecache_dwork_pending = false;
|
|
|
|
mod_delayed_work(system_wq, &net->ct.ecache_dwork, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else /* CONFIG_NF_CONNTRACK_EVENTS */
|
2006-11-28 18:35:01 -07:00
|
|
|
static inline void nf_conntrack_event_cache(enum ip_conntrack_events event,
|
2008-10-11 10:46:24 -06:00
|
|
|
struct nf_conn *ct) {}
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
static inline int nf_conntrack_eventmask_report(unsigned int eventmask,
|
|
|
|
struct nf_conn *ct,
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid,
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
int report) { return 0; }
|
|
|
|
static inline int nf_conntrack_event(enum ip_conntrack_events event,
|
|
|
|
struct nf_conn *ct) { return 0; }
|
|
|
|
static inline int nf_conntrack_event_report(enum ip_conntrack_events event,
|
|
|
|
struct nf_conn *ct,
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid,
|
netfilter: conntrack: optional reliable conntrack event delivery
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.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Patrick McHardy <kaber@trash.net>
2009-06-13 04:30:52 -06:00
|
|
|
int report) { return 0; }
|
2006-11-28 18:35:01 -07:00
|
|
|
static inline void nf_ct_deliver_cached_events(const struct nf_conn *ct) {}
|
2007-07-07 23:30:49 -06:00
|
|
|
static inline void nf_ct_expect_event(enum ip_conntrack_expect_events event,
|
|
|
|
struct nf_conntrack_expect *exp) {}
|
2008-11-18 03:56:20 -07:00
|
|
|
static inline void nf_ct_expect_event_report(enum ip_conntrack_expect_events e,
|
|
|
|
struct nf_conntrack_expect *exp,
|
2012-09-07 14:12:54 -06:00
|
|
|
u32 portid,
|
2008-11-18 03:56:20 -07:00
|
|
|
int report) {}
|
2008-10-08 03:35:07 -06:00
|
|
|
|
2013-01-21 15:10:28 -07:00
|
|
|
static inline int nf_conntrack_ecache_pernet_init(struct net *net)
|
2008-10-08 03:35:07 -06:00
|
|
|
{
|
|
|
|
return 0;
|
2008-10-09 22:10:36 -06:00
|
|
|
}
|
2008-10-08 03:35:07 -06:00
|
|
|
|
2013-01-21 15:10:28 -07:00
|
|
|
static inline void nf_conntrack_ecache_pernet_fini(struct net *net)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int nf_conntrack_ecache_init(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void nf_conntrack_ecache_fini(void)
|
2008-10-08 03:35:07 -06:00
|
|
|
{
|
|
|
|
}
|
2014-06-10 15:12:56 -06:00
|
|
|
|
|
|
|
static inline void nf_conntrack_ecache_delayed_work(struct net *net)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void nf_conntrack_ecache_work(struct net *net)
|
|
|
|
{
|
|
|
|
}
|
2006-11-28 18:35:01 -07:00
|
|
|
#endif /* CONFIG_NF_CONNTRACK_EVENTS */
|
|
|
|
|
|
|
|
#endif /*_NF_CONNTRACK_ECACHE_H*/
|
|
|
|
|