2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* net/core/dst.c Protocol independent destination cache.
|
|
|
|
|
*
|
|
|
|
|
* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/kernel.h>
|
2007-09-12 20:29:01 +08:00
|
|
|
#include <linux/workqueue.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/mm.h>
|
|
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/netdevice.h>
|
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/types.h>
|
2007-09-12 19:02:17 +08:00
|
|
|
#include <net/net_namespace.h>
|
2010-02-09 07:00:39 +08:00
|
|
|
#include <linux/sched.h>
|
2011-05-21 03:50:29 +08:00
|
|
|
#include <linux/prefetch.h>
|
2015-08-20 19:56:25 +08:00
|
|
|
#include <net/lwtunnel.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#include <net/dst.h>
|
2015-07-21 16:43:56 +08:00
|
|
|
#include <net/dst_metadata.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-09-12 20:29:01 +08:00
|
|
|
/*
|
|
|
|
|
* Theory of operations:
|
|
|
|
|
* 1) We use a list, protected by a spinlock, to add
|
|
|
|
|
* new entries from both BH and non-BH context.
|
|
|
|
|
* 2) In order to keep spinlock held for a small delay,
|
|
|
|
|
* we use a second list where are stored long lived
|
|
|
|
|
* entries, that are handled by the garbage collect thread
|
|
|
|
|
* fired by a workqueue.
|
|
|
|
|
* 3) This list is guarded by a mutex,
|
|
|
|
|
* so that the gc_task and dst_dev_event() can be synchronized.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
|
2007-09-12 20:29:01 +08:00
|
|
|
/*
|
|
|
|
|
* We want to keep lock & list close together
|
|
|
|
|
* to dirty as few cache lines as possible in __dst_free().
|
|
|
|
|
* As this is not a very strong hint, we dont force an alignment on SMP.
|
|
|
|
|
*/
|
2015-10-08 05:48:47 +08:00
|
|
|
int dst_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2015-10-08 05:48:47 +08:00
|
|
|
EXPORT_SYMBOL(dst_discard_out);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-26 05:27:35 +08:00
|
|
|
const struct dst_metrics dst_default_metrics = {
|
2012-08-07 18:55:45 +08:00
|
|
|
/* This initializer is needed to force linker to place this variable
|
|
|
|
|
* into const section. Otherwise it might end into bss section.
|
|
|
|
|
* We really want to avoid false sharing on this variable, and catch
|
|
|
|
|
* any writes on it.
|
|
|
|
|
*/
|
2017-08-19 03:08:07 +08:00
|
|
|
.refcnt = REFCOUNT_INIT(1),
|
2012-08-07 18:55:45 +08:00
|
|
|
};
|
|
|
|
|
|
2015-07-21 16:43:56 +08:00
|
|
|
void dst_init(struct dst_entry *dst, struct dst_ops *ops,
|
|
|
|
|
struct net_device *dev, int initial_ref, int initial_obsolete,
|
|
|
|
|
unsigned short flags)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2011-04-29 05:31:47 +08:00
|
|
|
dst->child = NULL;
|
2011-04-29 05:13:38 +08:00
|
|
|
dst->dev = dev;
|
|
|
|
|
if (dev)
|
|
|
|
|
dev_hold(dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
dst->ops = ops;
|
2017-05-26 05:27:35 +08:00
|
|
|
dst_init_metrics(dst, dst_default_metrics.metrics, true);
|
2011-04-29 05:31:47 +08:00
|
|
|
dst->expires = 0UL;
|
2011-04-29 05:13:38 +08:00
|
|
|
dst->path = dst;
|
ipv6: fix race condition regarding dst->expires and dst->from.
Eric Dumazet wrote:
| Some strange crashes happen in rt6_check_expired(), with access
| to random addresses.
|
| At first glance, it looks like the RTF_EXPIRES and
| stuff added in commit 1716a96101c49186b
| (ipv6: fix problem with expired dst cache)
| are racy : same dst could be manipulated at the same time
| on different cpus.
|
| At some point, our stack believes rt->dst.from contains a dst pointer,
| while its really a jiffie value (as rt->dst.expires shares the same area
| of memory)
|
| rt6_update_expires() should be fixed, or am I missing something ?
|
| CC Neil because of https://bugzilla.redhat.com/show_bug.cgi?id=892060
Because we do not have any locks for dst_entry, we cannot change
essential structure in the entry; e.g., we cannot change reference
to other entity.
To fix this issue, split 'from' and 'expires' field in dst_entry
out of union. Once it is 'from' is assigned in the constructor,
keep the reference until the very last stage of the life time of
the object.
Of course, it is unsafe to change 'from', so make rt6_set_from simple
just for fresh entries.
Reported-by: Eric Dumazet <eric.dumazet@gmail.com>
Reported-by: Neil Horman <nhorman@tuxdriver.com>
CC: Gao Feng <gaofeng@cn.fujitsu.com>
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Reported-by: Steinar H. Gunderson <sesse@google.com>
Reviewed-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-02-20 08:29:08 +08:00
|
|
|
dst->from = NULL;
|
2011-04-29 05:31:47 +08:00
|
|
|
#ifdef CONFIG_XFRM
|
|
|
|
|
dst->xfrm = NULL;
|
|
|
|
|
#endif
|
2011-04-29 05:13:38 +08:00
|
|
|
dst->input = dst_discard;
|
2015-10-08 05:48:47 +08:00
|
|
|
dst->output = dst_discard_out;
|
2011-04-29 05:31:47 +08:00
|
|
|
dst->error = 0;
|
2011-04-29 05:13:38 +08:00
|
|
|
dst->obsolete = initial_obsolete;
|
2011-04-29 05:31:47 +08:00
|
|
|
dst->header_len = 0;
|
|
|
|
|
dst->trailer_len = 0;
|
|
|
|
|
#ifdef CONFIG_IP_ROUTE_CLASSID
|
|
|
|
|
dst->tclassid = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2015-08-20 19:56:25 +08:00
|
|
|
dst->lwtstate = NULL;
|
2011-04-29 05:13:38 +08:00
|
|
|
atomic_set(&dst->__refcnt, initial_ref);
|
2011-04-29 05:31:47 +08:00
|
|
|
dst->__use = 0;
|
2011-04-29 05:13:38 +08:00
|
|
|
dst->lastuse = jiffies;
|
|
|
|
|
dst->flags = flags;
|
2011-04-29 05:31:47 +08:00
|
|
|
dst->next = NULL;
|
2011-06-25 06:25:00 +08:00
|
|
|
if (!(flags & DST_NOCOUNT))
|
|
|
|
|
dst_entries_add(ops, 1);
|
2015-07-21 16:43:56 +08:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(dst_init);
|
|
|
|
|
|
|
|
|
|
void *dst_alloc(struct dst_ops *ops, struct net_device *dev,
|
|
|
|
|
int initial_ref, int initial_obsolete, unsigned short flags)
|
|
|
|
|
{
|
|
|
|
|
struct dst_entry *dst;
|
|
|
|
|
|
|
|
|
|
if (ops->gc && dst_entries_get_fast(ops) > ops->gc_thresh) {
|
|
|
|
|
if (ops->gc(ops))
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dst = kmem_cache_alloc(ops->kmem_cachep, GFP_ATOMIC);
|
|
|
|
|
if (!dst)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
dst_init(dst, ops, dev, initial_ref, initial_obsolete, flags);
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return dst;
|
|
|
|
|
}
|
2010-03-29 18:41:36 +08:00
|
|
|
EXPORT_SYMBOL(dst_alloc);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
struct dst_entry *dst_destroy(struct dst_entry * dst)
|
|
|
|
|
{
|
2017-11-29 04:40:22 +08:00
|
|
|
struct dst_entry *child = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
smp_rmb();
|
|
|
|
|
|
2017-11-29 04:40:22 +08:00
|
|
|
#ifdef CONFIG_XFRM
|
|
|
|
|
if (dst->xfrm)
|
|
|
|
|
child = dst->child;
|
|
|
|
|
#endif
|
2011-06-25 06:25:00 +08:00
|
|
|
if (!(dst->flags & DST_NOCOUNT))
|
|
|
|
|
dst_entries_add(dst->ops, -1);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (dst->ops->destroy)
|
|
|
|
|
dst->ops->destroy(dst);
|
|
|
|
|
if (dst->dev)
|
|
|
|
|
dev_put(dst->dev);
|
2015-07-21 16:43:56 +08:00
|
|
|
|
2015-08-26 01:38:53 +08:00
|
|
|
lwtstate_put(dst->lwtstate);
|
|
|
|
|
|
2015-07-21 16:43:56 +08:00
|
|
|
if (dst->flags & DST_METADATA)
|
2016-02-12 22:43:57 +08:00
|
|
|
metadata_dst_free((struct metadata_dst *)dst);
|
2015-07-21 16:43:56 +08:00
|
|
|
else
|
|
|
|
|
kmem_cache_free(dst->ops->kmem_cachep, dst);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
dst = child;
|
2017-06-18 01:42:38 +08:00
|
|
|
if (dst)
|
|
|
|
|
dst_release_immediate(dst);
|
2005-04-17 06:20:36 +08:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2010-03-29 18:41:36 +08:00
|
|
|
EXPORT_SYMBOL(dst_destroy);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-06-25 01:05:11 +08:00
|
|
|
static void dst_destroy_rcu(struct rcu_head *head)
|
|
|
|
|
{
|
|
|
|
|
struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head);
|
|
|
|
|
|
|
|
|
|
dst = dst_destroy(dst);
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-18 01:42:28 +08:00
|
|
|
/* Operations to mark dst as DEAD and clean up the net device referenced
|
|
|
|
|
* by dst:
|
|
|
|
|
* 1. put the dst under loopback interface and discard all tx/rx packets
|
|
|
|
|
* on this route.
|
|
|
|
|
* 2. release the net_device
|
|
|
|
|
* This function should be called when removing routes from the fib tree
|
|
|
|
|
* in preparation for a NETDEV_DOWN/NETDEV_UNREGISTER event and also to
|
|
|
|
|
* make the next dst_ops->check() fail.
|
|
|
|
|
*/
|
|
|
|
|
void dst_dev_put(struct dst_entry *dst)
|
|
|
|
|
{
|
|
|
|
|
struct net_device *dev = dst->dev;
|
|
|
|
|
|
|
|
|
|
dst->obsolete = DST_OBSOLETE_DEAD;
|
|
|
|
|
if (dst->ops->ifdown)
|
|
|
|
|
dst->ops->ifdown(dst, dev, true);
|
|
|
|
|
dst->input = dst_discard;
|
|
|
|
|
dst->output = dst_discard_out;
|
|
|
|
|
dst->dev = dev_net(dst->dev)->loopback_dev;
|
|
|
|
|
dev_hold(dst->dev);
|
|
|
|
|
dev_put(dev);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(dst_dev_put);
|
|
|
|
|
|
2008-03-28 08:53:31 +08:00
|
|
|
void dst_release(struct dst_entry *dst)
|
|
|
|
|
{
|
|
|
|
|
if (dst) {
|
2010-03-29 18:41:36 +08:00
|
|
|
int newrefcnt;
|
2008-11-14 16:53:54 +08:00
|
|
|
|
2010-03-29 18:41:36 +08:00
|
|
|
newrefcnt = atomic_dec_return(&dst->__refcnt);
|
2015-07-17 19:01:11 +08:00
|
|
|
if (unlikely(newrefcnt < 0))
|
|
|
|
|
net_warn_ratelimited("%s: dst:%p refcnt:%d\n",
|
|
|
|
|
__func__, dst, newrefcnt);
|
2017-06-18 01:42:41 +08:00
|
|
|
if (!newrefcnt)
|
2014-06-25 01:05:11 +08:00
|
|
|
call_rcu(&dst->rcu_head, dst_destroy_rcu);
|
2008-03-28 08:53:31 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(dst_release);
|
|
|
|
|
|
2017-06-18 01:42:27 +08:00
|
|
|
void dst_release_immediate(struct dst_entry *dst)
|
|
|
|
|
{
|
|
|
|
|
if (dst) {
|
|
|
|
|
int newrefcnt;
|
|
|
|
|
|
|
|
|
|
newrefcnt = atomic_dec_return(&dst->__refcnt);
|
|
|
|
|
if (unlikely(newrefcnt < 0))
|
|
|
|
|
net_warn_ratelimited("%s: dst:%p refcnt:%d\n",
|
|
|
|
|
__func__, dst, newrefcnt);
|
|
|
|
|
if (!newrefcnt)
|
|
|
|
|
dst_destroy(dst);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(dst_release_immediate);
|
|
|
|
|
|
net: Implement read-only protection and COW'ing of metrics.
Routing metrics are now copy-on-write.
Initially a route entry points it's metrics at a read-only location.
If a routing table entry exists, it will point there. Else it will
point at the all zero metric place-holder called 'dst_default_metrics'.
The writeability state of the metrics is stored in the low bits of the
metrics pointer, we have two bits left to spare if we want to store
more states.
For the initial implementation, COW is implemented simply via kmalloc.
However future enhancements will change this to place the writable
metrics somewhere else, in order to increase sharing. Very likely
this "somewhere else" will be the inetpeer cache.
Note also that this means that metrics updates may transiently fail
if we cannot COW the metrics successfully.
But even by itself, this patch should decrease memory usage and
increase cache locality especially for routing workloads. In those
cases the read-only metric copies stay in place and never get written
to.
TCP workloads where metrics get updated, and those rare cases where
PMTU triggers occur, will take a very slight performance hit. But
that hit will be alleviated when the long-term writable metrics
move to a more sharable location.
Since the metrics storage went from a u32 array of RTAX_MAX entries to
what is essentially a pointer, some retooling of the dst_entry layout
was necessary.
Most importantly, we need to preserve the alignment of the reference
count so that it doesn't share cache lines with the read-mostly state,
as per Eric Dumazet's alignment assertion checks.
The only non-trivial bit here is the move of the 'flags' member into
the writeable cacheline. This is OK since we are always accessing the
flags around the same moment when we made a modification to the
reference count.
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-01-27 12:51:05 +08:00
|
|
|
u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old)
|
|
|
|
|
{
|
2017-05-26 05:27:35 +08:00
|
|
|
struct dst_metrics *p = kmalloc(sizeof(*p), GFP_ATOMIC);
|
net: Implement read-only protection and COW'ing of metrics.
Routing metrics are now copy-on-write.
Initially a route entry points it's metrics at a read-only location.
If a routing table entry exists, it will point there. Else it will
point at the all zero metric place-holder called 'dst_default_metrics'.
The writeability state of the metrics is stored in the low bits of the
metrics pointer, we have two bits left to spare if we want to store
more states.
For the initial implementation, COW is implemented simply via kmalloc.
However future enhancements will change this to place the writable
metrics somewhere else, in order to increase sharing. Very likely
this "somewhere else" will be the inetpeer cache.
Note also that this means that metrics updates may transiently fail
if we cannot COW the metrics successfully.
But even by itself, this patch should decrease memory usage and
increase cache locality especially for routing workloads. In those
cases the read-only metric copies stay in place and never get written
to.
TCP workloads where metrics get updated, and those rare cases where
PMTU triggers occur, will take a very slight performance hit. But
that hit will be alleviated when the long-term writable metrics
move to a more sharable location.
Since the metrics storage went from a u32 array of RTAX_MAX entries to
what is essentially a pointer, some retooling of the dst_entry layout
was necessary.
Most importantly, we need to preserve the alignment of the reference
count so that it doesn't share cache lines with the read-mostly state,
as per Eric Dumazet's alignment assertion checks.
The only non-trivial bit here is the move of the 'flags' member into
the writeable cacheline. This is OK since we are always accessing the
flags around the same moment when we made a modification to the
reference count.
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-01-27 12:51:05 +08:00
|
|
|
|
|
|
|
|
if (p) {
|
2017-05-26 05:27:35 +08:00
|
|
|
struct dst_metrics *old_p = (struct dst_metrics *)__DST_METRICS_PTR(old);
|
net: Implement read-only protection and COW'ing of metrics.
Routing metrics are now copy-on-write.
Initially a route entry points it's metrics at a read-only location.
If a routing table entry exists, it will point there. Else it will
point at the all zero metric place-holder called 'dst_default_metrics'.
The writeability state of the metrics is stored in the low bits of the
metrics pointer, we have two bits left to spare if we want to store
more states.
For the initial implementation, COW is implemented simply via kmalloc.
However future enhancements will change this to place the writable
metrics somewhere else, in order to increase sharing. Very likely
this "somewhere else" will be the inetpeer cache.
Note also that this means that metrics updates may transiently fail
if we cannot COW the metrics successfully.
But even by itself, this patch should decrease memory usage and
increase cache locality especially for routing workloads. In those
cases the read-only metric copies stay in place and never get written
to.
TCP workloads where metrics get updated, and those rare cases where
PMTU triggers occur, will take a very slight performance hit. But
that hit will be alleviated when the long-term writable metrics
move to a more sharable location.
Since the metrics storage went from a u32 array of RTAX_MAX entries to
what is essentially a pointer, some retooling of the dst_entry layout
was necessary.
Most importantly, we need to preserve the alignment of the reference
count so that it doesn't share cache lines with the read-mostly state,
as per Eric Dumazet's alignment assertion checks.
The only non-trivial bit here is the move of the 'flags' member into
the writeable cacheline. This is OK since we are always accessing the
flags around the same moment when we made a modification to the
reference count.
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-01-27 12:51:05 +08:00
|
|
|
unsigned long prev, new;
|
|
|
|
|
|
2017-08-19 03:08:07 +08:00
|
|
|
refcount_set(&p->refcnt, 1);
|
2017-05-26 05:27:35 +08:00
|
|
|
memcpy(p->metrics, old_p->metrics, sizeof(p->metrics));
|
net: Implement read-only protection and COW'ing of metrics.
Routing metrics are now copy-on-write.
Initially a route entry points it's metrics at a read-only location.
If a routing table entry exists, it will point there. Else it will
point at the all zero metric place-holder called 'dst_default_metrics'.
The writeability state of the metrics is stored in the low bits of the
metrics pointer, we have two bits left to spare if we want to store
more states.
For the initial implementation, COW is implemented simply via kmalloc.
However future enhancements will change this to place the writable
metrics somewhere else, in order to increase sharing. Very likely
this "somewhere else" will be the inetpeer cache.
Note also that this means that metrics updates may transiently fail
if we cannot COW the metrics successfully.
But even by itself, this patch should decrease memory usage and
increase cache locality especially for routing workloads. In those
cases the read-only metric copies stay in place and never get written
to.
TCP workloads where metrics get updated, and those rare cases where
PMTU triggers occur, will take a very slight performance hit. But
that hit will be alleviated when the long-term writable metrics
move to a more sharable location.
Since the metrics storage went from a u32 array of RTAX_MAX entries to
what is essentially a pointer, some retooling of the dst_entry layout
was necessary.
Most importantly, we need to preserve the alignment of the reference
count so that it doesn't share cache lines with the read-mostly state,
as per Eric Dumazet's alignment assertion checks.
The only non-trivial bit here is the move of the 'flags' member into
the writeable cacheline. This is OK since we are always accessing the
flags around the same moment when we made a modification to the
reference count.
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-01-27 12:51:05 +08:00
|
|
|
|
|
|
|
|
new = (unsigned long) p;
|
|
|
|
|
prev = cmpxchg(&dst->_metrics, old, new);
|
|
|
|
|
|
|
|
|
|
if (prev != old) {
|
|
|
|
|
kfree(p);
|
2017-05-26 05:27:35 +08:00
|
|
|
p = (struct dst_metrics *)__DST_METRICS_PTR(prev);
|
net: Implement read-only protection and COW'ing of metrics.
Routing metrics are now copy-on-write.
Initially a route entry points it's metrics at a read-only location.
If a routing table entry exists, it will point there. Else it will
point at the all zero metric place-holder called 'dst_default_metrics'.
The writeability state of the metrics is stored in the low bits of the
metrics pointer, we have two bits left to spare if we want to store
more states.
For the initial implementation, COW is implemented simply via kmalloc.
However future enhancements will change this to place the writable
metrics somewhere else, in order to increase sharing. Very likely
this "somewhere else" will be the inetpeer cache.
Note also that this means that metrics updates may transiently fail
if we cannot COW the metrics successfully.
But even by itself, this patch should decrease memory usage and
increase cache locality especially for routing workloads. In those
cases the read-only metric copies stay in place and never get written
to.
TCP workloads where metrics get updated, and those rare cases where
PMTU triggers occur, will take a very slight performance hit. But
that hit will be alleviated when the long-term writable metrics
move to a more sharable location.
Since the metrics storage went from a u32 array of RTAX_MAX entries to
what is essentially a pointer, some retooling of the dst_entry layout
was necessary.
Most importantly, we need to preserve the alignment of the reference
count so that it doesn't share cache lines with the read-mostly state,
as per Eric Dumazet's alignment assertion checks.
The only non-trivial bit here is the move of the 'flags' member into
the writeable cacheline. This is OK since we are always accessing the
flags around the same moment when we made a modification to the
reference count.
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-01-27 12:51:05 +08:00
|
|
|
if (prev & DST_METRICS_READ_ONLY)
|
|
|
|
|
p = NULL;
|
2017-05-26 05:27:35 +08:00
|
|
|
} else if (prev & DST_METRICS_REFCOUNTED) {
|
2017-08-19 03:08:07 +08:00
|
|
|
if (refcount_dec_and_test(&old_p->refcnt))
|
2017-05-26 05:27:35 +08:00
|
|
|
kfree(old_p);
|
net: Implement read-only protection and COW'ing of metrics.
Routing metrics are now copy-on-write.
Initially a route entry points it's metrics at a read-only location.
If a routing table entry exists, it will point there. Else it will
point at the all zero metric place-holder called 'dst_default_metrics'.
The writeability state of the metrics is stored in the low bits of the
metrics pointer, we have two bits left to spare if we want to store
more states.
For the initial implementation, COW is implemented simply via kmalloc.
However future enhancements will change this to place the writable
metrics somewhere else, in order to increase sharing. Very likely
this "somewhere else" will be the inetpeer cache.
Note also that this means that metrics updates may transiently fail
if we cannot COW the metrics successfully.
But even by itself, this patch should decrease memory usage and
increase cache locality especially for routing workloads. In those
cases the read-only metric copies stay in place and never get written
to.
TCP workloads where metrics get updated, and those rare cases where
PMTU triggers occur, will take a very slight performance hit. But
that hit will be alleviated when the long-term writable metrics
move to a more sharable location.
Since the metrics storage went from a u32 array of RTAX_MAX entries to
what is essentially a pointer, some retooling of the dst_entry layout
was necessary.
Most importantly, we need to preserve the alignment of the reference
count so that it doesn't share cache lines with the read-mostly state,
as per Eric Dumazet's alignment assertion checks.
The only non-trivial bit here is the move of the 'flags' member into
the writeable cacheline. This is OK since we are always accessing the
flags around the same moment when we made a modification to the
reference count.
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-01-27 12:51:05 +08:00
|
|
|
}
|
|
|
|
|
}
|
2017-05-26 05:27:35 +08:00
|
|
|
BUILD_BUG_ON(offsetof(struct dst_metrics, metrics) != 0);
|
|
|
|
|
return (u32 *)p;
|
net: Implement read-only protection and COW'ing of metrics.
Routing metrics are now copy-on-write.
Initially a route entry points it's metrics at a read-only location.
If a routing table entry exists, it will point there. Else it will
point at the all zero metric place-holder called 'dst_default_metrics'.
The writeability state of the metrics is stored in the low bits of the
metrics pointer, we have two bits left to spare if we want to store
more states.
For the initial implementation, COW is implemented simply via kmalloc.
However future enhancements will change this to place the writable
metrics somewhere else, in order to increase sharing. Very likely
this "somewhere else" will be the inetpeer cache.
Note also that this means that metrics updates may transiently fail
if we cannot COW the metrics successfully.
But even by itself, this patch should decrease memory usage and
increase cache locality especially for routing workloads. In those
cases the read-only metric copies stay in place and never get written
to.
TCP workloads where metrics get updated, and those rare cases where
PMTU triggers occur, will take a very slight performance hit. But
that hit will be alleviated when the long-term writable metrics
move to a more sharable location.
Since the metrics storage went from a u32 array of RTAX_MAX entries to
what is essentially a pointer, some retooling of the dst_entry layout
was necessary.
Most importantly, we need to preserve the alignment of the reference
count so that it doesn't share cache lines with the read-mostly state,
as per Eric Dumazet's alignment assertion checks.
The only non-trivial bit here is the move of the 'flags' member into
the writeable cacheline. This is OK since we are always accessing the
flags around the same moment when we made a modification to the
reference count.
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-01-27 12:51:05 +08:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(dst_cow_metrics_generic);
|
|
|
|
|
|
|
|
|
|
/* Caller asserts that dst_metrics_read_only(dst) is false. */
|
|
|
|
|
void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old)
|
|
|
|
|
{
|
|
|
|
|
unsigned long prev, new;
|
|
|
|
|
|
2017-05-26 05:27:35 +08:00
|
|
|
new = ((unsigned long) &dst_default_metrics) | DST_METRICS_READ_ONLY;
|
net: Implement read-only protection and COW'ing of metrics.
Routing metrics are now copy-on-write.
Initially a route entry points it's metrics at a read-only location.
If a routing table entry exists, it will point there. Else it will
point at the all zero metric place-holder called 'dst_default_metrics'.
The writeability state of the metrics is stored in the low bits of the
metrics pointer, we have two bits left to spare if we want to store
more states.
For the initial implementation, COW is implemented simply via kmalloc.
However future enhancements will change this to place the writable
metrics somewhere else, in order to increase sharing. Very likely
this "somewhere else" will be the inetpeer cache.
Note also that this means that metrics updates may transiently fail
if we cannot COW the metrics successfully.
But even by itself, this patch should decrease memory usage and
increase cache locality especially for routing workloads. In those
cases the read-only metric copies stay in place and never get written
to.
TCP workloads where metrics get updated, and those rare cases where
PMTU triggers occur, will take a very slight performance hit. But
that hit will be alleviated when the long-term writable metrics
move to a more sharable location.
Since the metrics storage went from a u32 array of RTAX_MAX entries to
what is essentially a pointer, some retooling of the dst_entry layout
was necessary.
Most importantly, we need to preserve the alignment of the reference
count so that it doesn't share cache lines with the read-mostly state,
as per Eric Dumazet's alignment assertion checks.
The only non-trivial bit here is the move of the 'flags' member into
the writeable cacheline. This is OK since we are always accessing the
flags around the same moment when we made a modification to the
reference count.
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-01-27 12:51:05 +08:00
|
|
|
prev = cmpxchg(&dst->_metrics, old, new);
|
|
|
|
|
if (prev == old)
|
|
|
|
|
kfree(__DST_METRICS_PTR(old));
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(__dst_destroy_metrics_generic);
|
|
|
|
|
|
2015-07-21 16:43:56 +08:00
|
|
|
static struct dst_ops md_dst_ops = {
|
|
|
|
|
.family = AF_UNSPEC,
|
|
|
|
|
};
|
|
|
|
|
|
2015-10-08 05:48:47 +08:00
|
|
|
static int dst_md_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
|
2015-07-21 16:43:56 +08:00
|
|
|
{
|
|
|
|
|
WARN_ONCE(1, "Attempting to call output on metadata dst\n");
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int dst_md_discard(struct sk_buff *skb)
|
|
|
|
|
{
|
|
|
|
|
WARN_ONCE(1, "Attempting to call input on metadata dst\n");
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-24 04:11:58 +08:00
|
|
|
static void __metadata_dst_init(struct metadata_dst *md_dst,
|
|
|
|
|
enum metadata_type type, u8 optslen)
|
|
|
|
|
|
2015-07-21 16:43:56 +08:00
|
|
|
{
|
|
|
|
|
struct dst_entry *dst;
|
|
|
|
|
|
|
|
|
|
dst = &md_dst->dst;
|
|
|
|
|
dst_init(dst, &md_dst_ops, NULL, 1, DST_OBSOLETE_NONE,
|
2017-06-18 01:42:42 +08:00
|
|
|
DST_METADATA | DST_NOCOUNT);
|
2015-07-21 16:43:56 +08:00
|
|
|
|
|
|
|
|
dst->input = dst_md_discard;
|
2015-10-08 05:48:47 +08:00
|
|
|
dst->output = dst_md_discard_out;
|
2015-07-21 16:43:56 +08:00
|
|
|
|
|
|
|
|
memset(dst + 1, 0, sizeof(*md_dst) + optslen - sizeof(*dst));
|
2017-06-24 04:11:58 +08:00
|
|
|
md_dst->type = type;
|
bpf: add helpers to access tunnel metadata
Introduce helpers to let eBPF programs attached to TC manipulate tunnel metadata:
bpf_skb_[gs]et_tunnel_key(skb, key, size, flags)
skb: pointer to skb
key: pointer to 'struct bpf_tunnel_key'
size: size of 'struct bpf_tunnel_key'
flags: room for future extensions
First eBPF program that uses these helpers will allocate per_cpu
metadata_dst structures that will be used on TX.
On RX metadata_dst is allocated by tunnel driver.
Typical usage for TX:
struct bpf_tunnel_key tkey;
... populate tkey ...
bpf_skb_set_tunnel_key(skb, &tkey, sizeof(tkey), 0);
bpf_clone_redirect(skb, vxlan_dev_ifindex, 0);
RX:
struct bpf_tunnel_key tkey = {};
bpf_skb_get_tunnel_key(skb, &tkey, sizeof(tkey), 0);
... lookup or redirect based on tkey ...
'struct bpf_tunnel_key' will be extended in the future by adding
elements to the end and the 'size' argument will indicate which fields
are populated, thereby keeping backwards compatibility.
The 'flags' argument may be used as well when the 'size' is not enough or
to indicate completely different layout of bpf_tunnel_key.
Signed-off-by: Alexei Starovoitov <ast@plumgrid.com>
Acked-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-07-31 06:36:57 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-24 04:11:58 +08:00
|
|
|
struct metadata_dst *metadata_dst_alloc(u8 optslen, enum metadata_type type,
|
|
|
|
|
gfp_t flags)
|
bpf: add helpers to access tunnel metadata
Introduce helpers to let eBPF programs attached to TC manipulate tunnel metadata:
bpf_skb_[gs]et_tunnel_key(skb, key, size, flags)
skb: pointer to skb
key: pointer to 'struct bpf_tunnel_key'
size: size of 'struct bpf_tunnel_key'
flags: room for future extensions
First eBPF program that uses these helpers will allocate per_cpu
metadata_dst structures that will be used on TX.
On RX metadata_dst is allocated by tunnel driver.
Typical usage for TX:
struct bpf_tunnel_key tkey;
... populate tkey ...
bpf_skb_set_tunnel_key(skb, &tkey, sizeof(tkey), 0);
bpf_clone_redirect(skb, vxlan_dev_ifindex, 0);
RX:
struct bpf_tunnel_key tkey = {};
bpf_skb_get_tunnel_key(skb, &tkey, sizeof(tkey), 0);
... lookup or redirect based on tkey ...
'struct bpf_tunnel_key' will be extended in the future by adding
elements to the end and the 'size' argument will indicate which fields
are populated, thereby keeping backwards compatibility.
The 'flags' argument may be used as well when the 'size' is not enough or
to indicate completely different layout of bpf_tunnel_key.
Signed-off-by: Alexei Starovoitov <ast@plumgrid.com>
Acked-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-07-31 06:36:57 +08:00
|
|
|
{
|
|
|
|
|
struct metadata_dst *md_dst;
|
|
|
|
|
|
|
|
|
|
md_dst = kmalloc(sizeof(*md_dst) + optslen, flags);
|
|
|
|
|
if (!md_dst)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2017-06-24 04:11:58 +08:00
|
|
|
__metadata_dst_init(md_dst, type, optslen);
|
2015-07-21 16:43:56 +08:00
|
|
|
|
|
|
|
|
return md_dst;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(metadata_dst_alloc);
|
|
|
|
|
|
2016-02-12 22:43:57 +08:00
|
|
|
void metadata_dst_free(struct metadata_dst *md_dst)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_DST_CACHE
|
2017-08-18 20:31:35 +08:00
|
|
|
if (md_dst->type == METADATA_IP_TUNNEL)
|
|
|
|
|
dst_cache_destroy(&md_dst->u.tun_info.dst_cache);
|
2016-02-12 22:43:57 +08:00
|
|
|
#endif
|
|
|
|
|
kfree(md_dst);
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-24 04:11:58 +08:00
|
|
|
struct metadata_dst __percpu *
|
|
|
|
|
metadata_dst_alloc_percpu(u8 optslen, enum metadata_type type, gfp_t flags)
|
bpf: add helpers to access tunnel metadata
Introduce helpers to let eBPF programs attached to TC manipulate tunnel metadata:
bpf_skb_[gs]et_tunnel_key(skb, key, size, flags)
skb: pointer to skb
key: pointer to 'struct bpf_tunnel_key'
size: size of 'struct bpf_tunnel_key'
flags: room for future extensions
First eBPF program that uses these helpers will allocate per_cpu
metadata_dst structures that will be used on TX.
On RX metadata_dst is allocated by tunnel driver.
Typical usage for TX:
struct bpf_tunnel_key tkey;
... populate tkey ...
bpf_skb_set_tunnel_key(skb, &tkey, sizeof(tkey), 0);
bpf_clone_redirect(skb, vxlan_dev_ifindex, 0);
RX:
struct bpf_tunnel_key tkey = {};
bpf_skb_get_tunnel_key(skb, &tkey, sizeof(tkey), 0);
... lookup or redirect based on tkey ...
'struct bpf_tunnel_key' will be extended in the future by adding
elements to the end and the 'size' argument will indicate which fields
are populated, thereby keeping backwards compatibility.
The 'flags' argument may be used as well when the 'size' is not enough or
to indicate completely different layout of bpf_tunnel_key.
Signed-off-by: Alexei Starovoitov <ast@plumgrid.com>
Acked-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-07-31 06:36:57 +08:00
|
|
|
{
|
|
|
|
|
int cpu;
|
|
|
|
|
struct metadata_dst __percpu *md_dst;
|
|
|
|
|
|
|
|
|
|
md_dst = __alloc_percpu_gfp(sizeof(struct metadata_dst) + optslen,
|
|
|
|
|
__alignof__(struct metadata_dst), flags);
|
|
|
|
|
if (!md_dst)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu)
|
2017-06-24 04:11:58 +08:00
|
|
|
__metadata_dst_init(per_cpu_ptr(md_dst, cpu), type, optslen);
|
bpf: add helpers to access tunnel metadata
Introduce helpers to let eBPF programs attached to TC manipulate tunnel metadata:
bpf_skb_[gs]et_tunnel_key(skb, key, size, flags)
skb: pointer to skb
key: pointer to 'struct bpf_tunnel_key'
size: size of 'struct bpf_tunnel_key'
flags: room for future extensions
First eBPF program that uses these helpers will allocate per_cpu
metadata_dst structures that will be used on TX.
On RX metadata_dst is allocated by tunnel driver.
Typical usage for TX:
struct bpf_tunnel_key tkey;
... populate tkey ...
bpf_skb_set_tunnel_key(skb, &tkey, sizeof(tkey), 0);
bpf_clone_redirect(skb, vxlan_dev_ifindex, 0);
RX:
struct bpf_tunnel_key tkey = {};
bpf_skb_get_tunnel_key(skb, &tkey, sizeof(tkey), 0);
... lookup or redirect based on tkey ...
'struct bpf_tunnel_key' will be extended in the future by adding
elements to the end and the 'size' argument will indicate which fields
are populated, thereby keeping backwards compatibility.
The 'flags' argument may be used as well when the 'size' is not enough or
to indicate completely different layout of bpf_tunnel_key.
Signed-off-by: Alexei Starovoitov <ast@plumgrid.com>
Acked-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-07-31 06:36:57 +08:00
|
|
|
|
|
|
|
|
return md_dst;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(metadata_dst_alloc_percpu);
|
2017-10-10 01:30:14 +08:00
|
|
|
|
|
|
|
|
void metadata_dst_free_percpu(struct metadata_dst __percpu *md_dst)
|
|
|
|
|
{
|
2017-10-11 06:05:39 +08:00
|
|
|
#ifdef CONFIG_DST_CACHE
|
2017-10-10 01:30:14 +08:00
|
|
|
int cpu;
|
|
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
|
struct metadata_dst *one_md_dst = per_cpu_ptr(md_dst, cpu);
|
|
|
|
|
|
|
|
|
|
if (one_md_dst->type == METADATA_IP_TUNNEL)
|
|
|
|
|
dst_cache_destroy(&one_md_dst->u.tun_info.dst_cache);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
free_percpu(md_dst);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(metadata_dst_free_percpu);
|