2019-05-19 20:08:55 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
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>
|
2017-11-29 04:45:44 +08:00
|
|
|
#include <net/xfrm.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
|
|
|
|
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
|
|
|
};
|
2018-04-18 08:33:16 +08:00
|
|
|
EXPORT_SYMBOL(dst_default_metrics);
|
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:13:38 +08:00
|
|
|
dst->dev = dev;
|
2021-12-05 12:22:03 +08:00
|
|
|
dev_hold_track(dev, &dst->dev_tracker, GFP_ATOMIC);
|
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;
|
|
|
|
|
#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-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;
|
|
|
|
|
|
2020-05-08 09:58:10 +08:00
|
|
|
if (ops->gc &&
|
|
|
|
|
!(flags & DST_NOCOUNT) &&
|
|
|
|
|
dst_entries_get_fast(ops) > ops->gc_thresh) {
|
2019-01-17 00:50:28 +08:00
|
|
|
if (ops->gc(ops)) {
|
2020-05-08 09:58:10 +08:00
|
|
|
pr_notice_ratelimited("Route cache is full: consider increasing sysctl net.ipv6.route.max_size.\n");
|
2015-07-21 16:43:56 +08:00
|
|
|
return NULL;
|
2019-01-17 00:50:28 +08:00
|
|
|
}
|
2015-07-21 16:43:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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
|
2017-11-29 04:45:44 +08:00
|
|
|
if (dst->xfrm) {
|
|
|
|
|
struct xfrm_dst *xdst = (struct xfrm_dst *) dst;
|
|
|
|
|
|
|
|
|
|
child = xdst->child;
|
|
|
|
|
}
|
2017-11-29 04:40:22 +08:00
|
|
|
#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);
|
2021-12-05 12:22:03 +08:00
|
|
|
dev_put_track(dst->dev, &dst->dev_tracker);
|
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:
|
2020-09-10 16:41:53 +08:00
|
|
|
* 1. put the dst under blackhole interface and discard all tx/rx packets
|
2017-06-18 01:42:28 +08:00
|
|
|
* 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;
|
2019-07-02 05:38:57 +08:00
|
|
|
dst->dev = blackhole_netdev;
|
2021-12-05 12:22:03 +08:00
|
|
|
dev_replace_track(dev, blackhole_netdev, &dst->dev_tracker,
|
|
|
|
|
GFP_ATOMIC);
|
2017-06-18 01:42:28 +08:00
|
|
|
}
|
|
|
|
|
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);
|
2019-09-24 17:09:37 +08:00
|
|
|
if (WARN_ONCE(newrefcnt < 0, "dst_release underflow"))
|
2015-07-17 19:01:11 +08:00
|
|
|
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);
|
2019-09-24 17:09:37 +08:00
|
|
|
if (WARN_ONCE(newrefcnt < 0, "dst_release_immediate underflow"))
|
2017-06-18 01:42:27 +08:00
|
|
|
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);
|
|
|
|
|
|
2021-03-10 08:38:09 +08:00
|
|
|
struct dst_entry *dst_blackhole_check(struct dst_entry *dst, u32 cookie)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
u32 *dst_blackhole_cow_metrics(struct dst_entry *dst, unsigned long old)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct neighbour *dst_blackhole_neigh_lookup(const struct dst_entry *dst,
|
|
|
|
|
struct sk_buff *skb,
|
|
|
|
|
const void *daddr)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void dst_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
|
|
|
|
|
struct sk_buff *skb, u32 mtu,
|
|
|
|
|
bool confirm_neigh)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(dst_blackhole_update_pmtu);
|
|
|
|
|
|
|
|
|
|
void dst_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
|
|
|
|
|
struct sk_buff *skb)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(dst_blackhole_redirect);
|
|
|
|
|
|
|
|
|
|
unsigned int dst_blackhole_mtu(const struct dst_entry *dst)
|
|
|
|
|
{
|
|
|
|
|
unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
|
|
|
|
|
|
|
|
|
|
return mtu ? : dst->dev->mtu;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(dst_blackhole_mtu);
|
|
|
|
|
|
2021-03-10 08:38:10 +08:00
|
|
|
static struct dst_ops dst_blackhole_ops = {
|
|
|
|
|
.family = AF_UNSPEC,
|
|
|
|
|
.neigh_lookup = dst_blackhole_neigh_lookup,
|
|
|
|
|
.check = dst_blackhole_check,
|
|
|
|
|
.cow_metrics = dst_blackhole_cow_metrics,
|
|
|
|
|
.update_pmtu = dst_blackhole_update_pmtu,
|
|
|
|
|
.redirect = dst_blackhole_redirect,
|
|
|
|
|
.mtu = dst_blackhole_mtu,
|
2015-07-21 16:43:56 +08:00
|
|
|
};
|
|
|
|
|
|
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;
|
2021-03-10 08:38:10 +08:00
|
|
|
dst_init(dst, &dst_blackhole_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
|
|
|
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);
|
|
|
|
|
}
|
2018-08-03 02:51:39 +08:00
|
|
|
EXPORT_SYMBOL_GPL(metadata_dst_free);
|
2016-02-12 22:43:57 +08:00
|
|
|
|
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);
|