2005-04-17 02:20:36 +04:00
|
|
|
/*
|
2007-02-09 17:24:47 +03:00
|
|
|
* Linux NET3: GRE over IP protocol decoder.
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
|
* Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
2012-03-12 11:03:32 +04:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
2006-01-11 23:17:47 +03:00
|
|
|
#include <linux/capability.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/kernel.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 11:04:11 +03:00
|
|
|
#include <linux/slab.h>
|
2016-12-24 22:46:01 +03:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
|
#include <linux/in.h>
|
|
|
|
|
#include <linux/tcp.h>
|
|
|
|
|
#include <linux/udp.h>
|
|
|
|
|
#include <linux/if_arp.h>
|
2015-08-08 09:51:42 +03:00
|
|
|
#include <linux/if_vlan.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/in6.h>
|
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
|
#include <linux/igmp.h>
|
|
|
|
|
#include <linux/netfilter_ipv4.h>
|
2008-10-09 23:00:17 +04:00
|
|
|
#include <linux/etherdevice.h>
|
2006-01-06 03:35:42 +03:00
|
|
|
#include <linux/if_ether.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
#include <net/sock.h>
|
|
|
|
|
#include <net/ip.h>
|
|
|
|
|
#include <net/icmp.h>
|
|
|
|
|
#include <net/protocol.h>
|
2013-03-25 18:49:35 +04:00
|
|
|
#include <net/ip_tunnels.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <net/arp.h>
|
|
|
|
|
#include <net/checksum.h>
|
|
|
|
|
#include <net/dsfield.h>
|
|
|
|
|
#include <net/inet_ecn.h>
|
|
|
|
|
#include <net/xfrm.h>
|
2008-04-16 12:08:53 +04:00
|
|
|
#include <net/net_namespace.h>
|
|
|
|
|
#include <net/netns/generic.h>
|
2008-10-09 22:59:55 +04:00
|
|
|
#include <net/rtnetlink.h>
|
2010-08-22 10:05:39 +04:00
|
|
|
#include <net/gre.h>
|
2015-08-08 09:51:42 +03:00
|
|
|
#include <net/dst_metadata.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Problems & solutions
|
|
|
|
|
--------------------
|
|
|
|
|
|
|
|
|
|
1. The most important issue is detecting local dead loops.
|
|
|
|
|
They would cause complete host lockup in transmit, which
|
|
|
|
|
would be "resolved" by stack overflow or, if queueing is enabled,
|
|
|
|
|
with infinite looping in net_bh.
|
|
|
|
|
|
|
|
|
|
We cannot track such dead loops during route installation,
|
|
|
|
|
it is infeasible task. The most general solutions would be
|
|
|
|
|
to keep skb->encapsulation counter (sort of local ttl),
|
2010-09-30 10:35:10 +04:00
|
|
|
and silently drop packet when it expires. It is a good
|
2012-02-24 12:08:20 +04:00
|
|
|
solution, but it supposes maintaining new variable in ALL
|
2005-04-17 02:20:36 +04:00
|
|
|
skb, even if no tunneling is used.
|
|
|
|
|
|
2010-09-30 10:35:10 +04:00
|
|
|
Current solution: xmit_recursion breaks dead loops. This is a percpu
|
|
|
|
|
counter, since when we enter the first ndo_xmit(), cpu migration is
|
|
|
|
|
forbidden. We force an exit if this counter reaches RECURSION_LIMIT
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
2. Networking dead loops would not kill routers, but would really
|
|
|
|
|
kill network. IP hop limit plays role of "t->recursion" in this case,
|
|
|
|
|
if we copy it from packet being encapsulated to upper header.
|
|
|
|
|
It is very good solution, but it introduces two problems:
|
|
|
|
|
|
|
|
|
|
- Routing protocols, using packets with ttl=1 (OSPF, RIP2),
|
|
|
|
|
do not work over tunnels.
|
|
|
|
|
- traceroute does not work. I planned to relay ICMP from tunnel,
|
|
|
|
|
so that this problem would be solved and traceroute output
|
|
|
|
|
would even more informative. This idea appeared to be wrong:
|
|
|
|
|
only Linux complies to rfc1812 now (yes, guys, Linux is the only
|
|
|
|
|
true router now :-)), all routers (at least, in neighbourhood of mine)
|
|
|
|
|
return only 8 bytes of payload. It is the end.
|
|
|
|
|
|
|
|
|
|
Hence, if we want that OSPF worked or traceroute said something reasonable,
|
|
|
|
|
we should search for another solution.
|
|
|
|
|
|
|
|
|
|
One of them is to parse packet trying to detect inner encapsulation
|
|
|
|
|
made by our node. It is difficult or even impossible, especially,
|
2012-02-24 12:08:20 +04:00
|
|
|
taking into account fragmentation. TO be short, ttl is not solution at all.
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
Current solution: The solution was UNEXPECTEDLY SIMPLE.
|
|
|
|
|
We force DF flag on tunnels with preconfigured hop limit,
|
|
|
|
|
that is ALL. :-) Well, it does not remove the problem completely,
|
|
|
|
|
but exponential growth of network traffic is changed to linear
|
|
|
|
|
(branches, that exceed pmtu are pruned) and tunnel mtu
|
2012-02-24 12:08:20 +04:00
|
|
|
rapidly degrades to value <68, where looping stops.
|
2005-04-17 02:20:36 +04:00
|
|
|
Yes, it is not good if there exists a router in the loop,
|
|
|
|
|
which does not force DF, even when encapsulating packets have DF set.
|
|
|
|
|
But it is not our problem! Nobody could accuse us, we made
|
|
|
|
|
all that we could make. Even if it is your gated who injected
|
|
|
|
|
fatal route to network, even if it were you who configured
|
|
|
|
|
fatal static route: you are innocent. :-)
|
|
|
|
|
|
|
|
|
|
Alexey Kuznetsov.
|
|
|
|
|
*/
|
|
|
|
|
|
2012-09-25 15:02:48 +04:00
|
|
|
static bool log_ecn_error = true;
|
|
|
|
|
module_param(log_ecn_error, bool, 0644);
|
|
|
|
|
MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
|
|
|
|
|
|
2008-10-09 22:59:55 +04:00
|
|
|
static struct rtnl_link_ops ipgre_link_ops __read_mostly;
|
2005-04-17 02:20:36 +04:00
|
|
|
static int ipgre_tunnel_init(struct net_device *dev);
|
2008-04-16 12:10:26 +04:00
|
|
|
|
netns: make struct pernet_operations::id unsigned int
Make struct pernet_operations::id unsigned.
There are 2 reasons to do so:
1)
This field is really an index into an zero based array and
thus is unsigned entity. Using negative value is out-of-bound
access by definition.
2)
On x86_64 unsigned 32-bit data which are mixed with pointers
via array indexing or offsets added or subtracted to pointers
are preffered to signed 32-bit data.
"int" being used as an array index needs to be sign-extended
to 64-bit before being used.
void f(long *p, int i)
{
g(p[i]);
}
roughly translates to
movsx rsi, esi
mov rdi, [rsi+...]
call g
MOVSX is 3 byte instruction which isn't necessary if the variable is
unsigned because x86_64 is zero extending by default.
Now, there is net_generic() function which, you guessed it right, uses
"int" as an array index:
static inline void *net_generic(const struct net *net, int id)
{
...
ptr = ng->ptr[id - 1];
...
}
And this function is used a lot, so those sign extensions add up.
Patch snipes ~1730 bytes on allyesconfig kernel (without all junk
messing with code generation):
add/remove: 0/0 grow/shrink: 70/598 up/down: 396/-2126 (-1730)
Unfortunately some functions actually grow bigger.
This is a semmingly random artefact of code generation with register
allocator being used differently. gcc decides that some variable
needs to live in new r8+ registers and every access now requires REX
prefix. Or it is shifted into r12, so [r12+0] addressing mode has to be
used which is longer than [r8]
However, overall balance is in negative direction:
add/remove: 0/0 grow/shrink: 70/598 up/down: 396/-2126 (-1730)
function old new delta
nfsd4_lock 3886 3959 +73
tipc_link_build_proto_msg 1096 1140 +44
mac80211_hwsim_new_radio 2776 2808 +32
tipc_mon_rcv 1032 1058 +26
svcauth_gss_legacy_init 1413 1429 +16
tipc_bcbase_select_primary 379 392 +13
nfsd4_exchange_id 1247 1260 +13
nfsd4_setclientid_confirm 782 793 +11
...
put_client_renew_locked 494 480 -14
ip_set_sockfn_get 730 716 -14
geneve_sock_add 829 813 -16
nfsd4_sequence_done 721 703 -18
nlmclnt_lookup_host 708 686 -22
nfsd4_lockt 1085 1063 -22
nfs_get_client 1077 1050 -27
tcf_bpf_init 1106 1076 -30
nfsd4_encode_fattr 5997 5930 -67
Total: Before=154856051, After=154854321, chg -0.00%
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-11-17 04:58:21 +03:00
|
|
|
static unsigned int ipgre_net_id __read_mostly;
|
|
|
|
|
static unsigned int gre_tap_net_id __read_mostly;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-08-08 09:51:52 +03:00
|
|
|
static void ipgre_err(struct sk_buff *skb, u32 info,
|
|
|
|
|
const struct tnl_ptk_info *tpi)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
/* All the routers (except for Linux) return only
|
|
|
|
|
8 bytes of packet payload. It means, that precise relaying of
|
|
|
|
|
ICMP in the real Internet is absolutely infeasible.
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
Moreover, Cisco "wise men" put GRE key to the third word
|
|
|
|
|
in GRE header. It makes impossible maintaining even soft
|
|
|
|
|
state for keyed GRE tunnels with enabled checksum. Tell
|
|
|
|
|
them "thank you".
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
Well, I wonder, rfc1812 was written by Cisco employee,
|
|
|
|
|
what the hell these idiots break standards established
|
|
|
|
|
by themselves???
|
|
|
|
|
*/
|
|
|
|
|
struct net *net = dev_net(skb->dev);
|
|
|
|
|
struct ip_tunnel_net *itn;
|
2013-05-18 12:36:03 +04:00
|
|
|
const struct iphdr *iph;
|
2007-03-13 20:43:18 +03:00
|
|
|
const int type = icmp_hdr(skb)->type;
|
|
|
|
|
const int code = icmp_hdr(skb)->code;
|
2016-06-19 07:52:06 +03:00
|
|
|
unsigned int data_len = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct ip_tunnel *t;
|
|
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
default:
|
|
|
|
|
case ICMP_PARAMETERPROB:
|
2015-08-08 09:51:52 +03:00
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
case ICMP_DEST_UNREACH:
|
|
|
|
|
switch (code) {
|
|
|
|
|
case ICMP_SR_FAILED:
|
|
|
|
|
case ICMP_PORT_UNREACH:
|
|
|
|
|
/* Impossible event. */
|
2015-08-08 09:51:52 +03:00
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
default:
|
|
|
|
|
/* All others are translated to HOST_UNREACH.
|
|
|
|
|
rfc2003 contains "deep thoughts" about NET_UNREACH,
|
|
|
|
|
I believe they are just ether pollution. --ANK
|
|
|
|
|
*/
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2015-08-08 09:51:52 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
case ICMP_TIME_EXCEEDED:
|
|
|
|
|
if (code != ICMP_EXC_TTL)
|
2015-08-08 09:51:52 +03:00
|
|
|
return;
|
2016-06-19 07:52:06 +03:00
|
|
|
data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
2012-07-12 08:27:49 +04:00
|
|
|
|
|
|
|
|
case ICMP_REDIRECT:
|
|
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2013-06-18 04:49:38 +04:00
|
|
|
if (tpi->proto == htons(ETH_P_TEB))
|
2013-03-25 18:49:35 +04:00
|
|
|
itn = net_generic(net, gre_tap_net_id);
|
|
|
|
|
else
|
|
|
|
|
itn = net_generic(net, ipgre_net_id);
|
|
|
|
|
|
2014-01-28 07:49:43 +04:00
|
|
|
iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
|
2013-06-18 04:49:38 +04:00
|
|
|
t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
|
|
|
|
|
iph->daddr, iph->saddr, tpi->key);
|
2012-09-24 22:12:23 +04:00
|
|
|
|
2015-04-03 11:17:26 +03:00
|
|
|
if (!t)
|
2015-08-08 09:51:52 +03:00
|
|
|
return;
|
2012-06-15 09:21:46 +04:00
|
|
|
|
2016-06-19 07:52:05 +03:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
|
if (tpi->proto == htons(ETH_P_IPV6) &&
|
2016-06-19 07:52:06 +03:00
|
|
|
!ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len,
|
|
|
|
|
type, data_len))
|
2016-06-19 07:52:05 +03:00
|
|
|
return;
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-06-15 09:21:46 +04:00
|
|
|
if (t->parms.iph.daddr == 0 ||
|
2007-12-17 00:45:43 +03:00
|
|
|
ipv4_is_multicast(t->parms.iph.daddr))
|
2015-08-08 09:51:52 +03:00
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
|
2015-08-08 09:51:52 +03:00
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2009-02-25 10:34:48 +03:00
|
|
|
if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
|
2005-04-17 02:20:36 +04:00
|
|
|
t->err_count++;
|
|
|
|
|
else
|
|
|
|
|
t->err_count = 1;
|
|
|
|
|
t->err_time = jiffies;
|
2015-08-08 09:51:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void gre_err(struct sk_buff *skb, u32 info)
|
|
|
|
|
{
|
|
|
|
|
/* All the routers (except for Linux) return only
|
|
|
|
|
* 8 bytes of packet payload. It means, that precise relaying of
|
|
|
|
|
* ICMP in the real Internet is absolutely infeasible.
|
|
|
|
|
*
|
|
|
|
|
* Moreover, Cisco "wise men" put GRE key to the third word
|
|
|
|
|
* in GRE header. It makes impossible maintaining even soft
|
|
|
|
|
* state for keyed
|
|
|
|
|
* GRE tunnels with enabled checksum. Tell them "thank you".
|
|
|
|
|
*
|
|
|
|
|
* Well, I wonder, rfc1812 was written by Cisco employee,
|
|
|
|
|
* what the hell these idiots break standards established
|
|
|
|
|
* by themselves???
|
|
|
|
|
*/
|
|
|
|
|
|
2016-06-15 16:24:00 +03:00
|
|
|
const struct iphdr *iph = (struct iphdr *)skb->data;
|
2015-08-08 09:51:52 +03:00
|
|
|
const int type = icmp_hdr(skb)->type;
|
|
|
|
|
const int code = icmp_hdr(skb)->code;
|
|
|
|
|
struct tnl_ptk_info tpi;
|
|
|
|
|
bool csum_err = false;
|
|
|
|
|
|
2016-06-15 16:24:00 +03:00
|
|
|
if (gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP),
|
|
|
|
|
iph->ihl * 4) < 0) {
|
2015-08-08 09:51:52 +03:00
|
|
|
if (!csum_err) /* ignore csum errors. */
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
|
|
|
|
|
ipv4_update_pmtu(skb, dev_net(skb->dev), info,
|
|
|
|
|
skb->dev->ifindex, 0, IPPROTO_GRE, 0);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (type == ICMP_REDIRECT) {
|
|
|
|
|
ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0,
|
|
|
|
|
IPPROTO_GRE, 0);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ipgre_err(skb, info, &tpi);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2016-05-03 18:10:08 +03:00
|
|
|
static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
|
|
|
|
|
struct ip_tunnel_net *itn, int hdr_len, bool raw_proto)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2015-08-08 09:51:42 +03:00
|
|
|
struct metadata_dst *tun_dst = NULL;
|
2011-04-22 08:53:02 +04:00
|
|
|
const struct iphdr *iph;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct ip_tunnel *tunnel;
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
iph = ip_hdr(skb);
|
2013-06-18 04:49:38 +04:00
|
|
|
tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
|
|
|
|
|
iph->saddr, iph->daddr, tpi->key);
|
2008-10-09 23:00:17 +04:00
|
|
|
|
2012-09-24 22:12:23 +04:00
|
|
|
if (tunnel) {
|
2016-05-03 18:10:08 +03:00
|
|
|
if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
|
|
|
|
|
raw_proto, false) < 0)
|
2016-05-03 18:10:07 +03:00
|
|
|
goto drop;
|
|
|
|
|
|
2016-05-11 16:53:57 +03:00
|
|
|
if (tunnel->dev->type != ARPHRD_NONE)
|
|
|
|
|
skb_pop_mac_header(skb);
|
|
|
|
|
else
|
|
|
|
|
skb_reset_mac_header(skb);
|
2015-08-08 09:51:42 +03:00
|
|
|
if (tunnel->collect_md) {
|
2015-08-27 09:46:50 +03:00
|
|
|
__be16 flags;
|
|
|
|
|
__be64 tun_id;
|
2015-08-08 09:51:42 +03:00
|
|
|
|
2015-08-27 09:46:50 +03:00
|
|
|
flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
|
2016-09-08 16:23:45 +03:00
|
|
|
tun_id = key32_to_tunnel_id(tpi->key);
|
2015-08-27 09:46:50 +03:00
|
|
|
tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
|
2015-08-08 09:51:42 +03:00
|
|
|
if (!tun_dst)
|
|
|
|
|
return PACKET_REJECT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
|
2013-06-18 04:49:38 +04:00
|
|
|
return PACKET_RCVD;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2016-05-03 18:10:08 +03:00
|
|
|
return PACKET_NEXT;
|
2016-05-03 18:10:07 +03:00
|
|
|
|
|
|
|
|
drop:
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return PACKET_RCVD;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2016-05-03 18:10:08 +03:00
|
|
|
static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
|
|
|
|
|
int hdr_len)
|
|
|
|
|
{
|
|
|
|
|
struct net *net = dev_net(skb->dev);
|
|
|
|
|
struct ip_tunnel_net *itn;
|
|
|
|
|
int res;
|
|
|
|
|
|
|
|
|
|
if (tpi->proto == htons(ETH_P_TEB))
|
|
|
|
|
itn = net_generic(net, gre_tap_net_id);
|
|
|
|
|
else
|
|
|
|
|
itn = net_generic(net, ipgre_net_id);
|
|
|
|
|
|
|
|
|
|
res = __ipgre_rcv(skb, tpi, itn, hdr_len, false);
|
|
|
|
|
if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) {
|
|
|
|
|
/* ipgre tunnels in collect metadata mode should receive
|
|
|
|
|
* also ETH_P_TEB traffic.
|
|
|
|
|
*/
|
|
|
|
|
itn = net_generic(net, ipgre_net_id);
|
|
|
|
|
res = __ipgre_rcv(skb, tpi, itn, hdr_len, true);
|
|
|
|
|
}
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-08 09:51:52 +03:00
|
|
|
static int gre_rcv(struct sk_buff *skb)
|
|
|
|
|
{
|
|
|
|
|
struct tnl_ptk_info tpi;
|
|
|
|
|
bool csum_err = false;
|
2016-04-30 03:12:16 +03:00
|
|
|
int hdr_len;
|
2015-08-08 09:51:52 +03:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_IPGRE_BROADCAST
|
|
|
|
|
if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
|
|
|
|
|
/* Looped back packet, drop it! */
|
|
|
|
|
if (rt_is_output_route(skb_rtable(skb)))
|
|
|
|
|
goto drop;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2016-06-15 16:24:00 +03:00
|
|
|
hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0);
|
2016-05-03 16:00:21 +03:00
|
|
|
if (hdr_len < 0)
|
2016-04-30 03:12:16 +03:00
|
|
|
goto drop;
|
|
|
|
|
|
2016-05-03 18:10:07 +03:00
|
|
|
if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
|
2015-08-08 09:51:52 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
|
|
|
|
|
drop:
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
|
|
|
|
|
const struct iphdr *tnl_params,
|
|
|
|
|
__be16 proto)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
if (tunnel->parms.o_flags & TUNNEL_SEQ)
|
|
|
|
|
tunnel->o_seqno++;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
/* Push GRE header. */
|
2016-04-30 03:12:19 +03:00
|
|
|
gre_build_header(skb, tunnel->tun_hlen,
|
|
|
|
|
tunnel->parms.o_flags, proto, tunnel->parms.o_key,
|
|
|
|
|
htonl(tunnel->o_seqno));
|
2014-09-30 07:22:32 +04:00
|
|
|
|
2013-05-28 03:48:15 +04:00
|
|
|
ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
|
2013-03-25 18:49:35 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-04-14 22:33:37 +03:00
|
|
|
static int gre_handle_offloads(struct sk_buff *skb, bool csum)
|
2015-08-08 09:51:47 +03:00
|
|
|
{
|
2016-02-12 00:02:31 +03:00
|
|
|
return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
|
2015-08-08 09:51:47 +03:00
|
|
|
}
|
|
|
|
|
|
2015-10-23 04:17:16 +03:00
|
|
|
static struct rtable *gre_get_rt(struct sk_buff *skb,
|
|
|
|
|
struct net_device *dev,
|
|
|
|
|
struct flowi4 *fl,
|
|
|
|
|
const struct ip_tunnel_key *key)
|
|
|
|
|
{
|
|
|
|
|
struct net *net = dev_net(dev);
|
|
|
|
|
|
|
|
|
|
memset(fl, 0, sizeof(*fl));
|
|
|
|
|
fl->daddr = key->u.ipv4.dst;
|
|
|
|
|
fl->saddr = key->u.ipv4.src;
|
|
|
|
|
fl->flowi4_tos = RT_TOS(key->tos);
|
|
|
|
|
fl->flowi4_mark = skb->mark;
|
|
|
|
|
fl->flowi4_proto = IPPROTO_GRE;
|
|
|
|
|
|
|
|
|
|
return ip_route_output_key(net, fl);
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-27 12:29:07 +03:00
|
|
|
static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
|
|
|
|
|
__be16 proto)
|
2015-08-08 09:51:42 +03:00
|
|
|
{
|
|
|
|
|
struct ip_tunnel_info *tun_info;
|
|
|
|
|
const struct ip_tunnel_key *key;
|
bpf, vxlan, geneve, gre: fix usage of dst_cache on xmit
The assumptions from commit 0c1d70af924b ("net: use dst_cache for vxlan
device"), 468dfffcd762 ("geneve: add dst caching support") and 3c1cb4d2604c
("net/ipv4: add dst cache support for gre lwtunnels") on dst_cache usage
when ip_tunnel_info is used is unfortunately not always valid as assumed.
While it seems correct for ip_tunnel_info front-ends such as OVS, eBPF
however can fill in ip_tunnel_info for consumers like vxlan, geneve or gre
with different remote dsts, tos, etc, therefore they cannot be assumed as
packet independent.
Right now vxlan, geneve, gre would cache the dst for eBPF and every packet
would reuse the same entry that was first created on the initial route
lookup. eBPF doesn't store/cache the ip_tunnel_info, so each skb may have
a different one.
Fix it by adding a flag that checks the ip_tunnel_info. Also the !tos test
in vxlan needs to be handeled differently in this context as it is currently
inferred from ip_tunnel_info as well if present. ip_tunnel_dst_cache_usable()
helper is added for the three tunnel cases, which checks if we can use dst
cache.
Fixes: 0c1d70af924b ("net: use dst_cache for vxlan device")
Fixes: 468dfffcd762 ("geneve: add dst caching support")
Fixes: 3c1cb4d2604c ("net/ipv4: add dst cache support for gre lwtunnels")
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Paolo Abeni <pabeni@redhat.com>
Acked-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-03-04 17:15:07 +03:00
|
|
|
struct rtable *rt = NULL;
|
2015-08-08 09:51:42 +03:00
|
|
|
struct flowi4 fl;
|
|
|
|
|
int min_headroom;
|
|
|
|
|
int tunnel_hlen;
|
|
|
|
|
__be16 df, flags;
|
bpf, vxlan, geneve, gre: fix usage of dst_cache on xmit
The assumptions from commit 0c1d70af924b ("net: use dst_cache for vxlan
device"), 468dfffcd762 ("geneve: add dst caching support") and 3c1cb4d2604c
("net/ipv4: add dst cache support for gre lwtunnels") on dst_cache usage
when ip_tunnel_info is used is unfortunately not always valid as assumed.
While it seems correct for ip_tunnel_info front-ends such as OVS, eBPF
however can fill in ip_tunnel_info for consumers like vxlan, geneve or gre
with different remote dsts, tos, etc, therefore they cannot be assumed as
packet independent.
Right now vxlan, geneve, gre would cache the dst for eBPF and every packet
would reuse the same entry that was first created on the initial route
lookup. eBPF doesn't store/cache the ip_tunnel_info, so each skb may have
a different one.
Fix it by adding a flag that checks the ip_tunnel_info. Also the !tos test
in vxlan needs to be handeled differently in this context as it is currently
inferred from ip_tunnel_info as well if present. ip_tunnel_dst_cache_usable()
helper is added for the three tunnel cases, which checks if we can use dst
cache.
Fixes: 0c1d70af924b ("net: use dst_cache for vxlan device")
Fixes: 468dfffcd762 ("geneve: add dst caching support")
Fixes: 3c1cb4d2604c ("net/ipv4: add dst cache support for gre lwtunnels")
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Paolo Abeni <pabeni@redhat.com>
Acked-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-03-04 17:15:07 +03:00
|
|
|
bool use_cache;
|
2015-08-08 09:51:42 +03:00
|
|
|
int err;
|
|
|
|
|
|
2015-08-20 14:56:25 +03:00
|
|
|
tun_info = skb_tunnel_info(skb);
|
2015-08-28 21:48:20 +03:00
|
|
|
if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
|
|
|
|
|
ip_tunnel_info_af(tun_info) != AF_INET))
|
2015-08-08 09:51:42 +03:00
|
|
|
goto err_free_skb;
|
|
|
|
|
|
|
|
|
|
key = &tun_info->key;
|
bpf, vxlan, geneve, gre: fix usage of dst_cache on xmit
The assumptions from commit 0c1d70af924b ("net: use dst_cache for vxlan
device"), 468dfffcd762 ("geneve: add dst caching support") and 3c1cb4d2604c
("net/ipv4: add dst cache support for gre lwtunnels") on dst_cache usage
when ip_tunnel_info is used is unfortunately not always valid as assumed.
While it seems correct for ip_tunnel_info front-ends such as OVS, eBPF
however can fill in ip_tunnel_info for consumers like vxlan, geneve or gre
with different remote dsts, tos, etc, therefore they cannot be assumed as
packet independent.
Right now vxlan, geneve, gre would cache the dst for eBPF and every packet
would reuse the same entry that was first created on the initial route
lookup. eBPF doesn't store/cache the ip_tunnel_info, so each skb may have
a different one.
Fix it by adding a flag that checks the ip_tunnel_info. Also the !tos test
in vxlan needs to be handeled differently in this context as it is currently
inferred from ip_tunnel_info as well if present. ip_tunnel_dst_cache_usable()
helper is added for the three tunnel cases, which checks if we can use dst
cache.
Fixes: 0c1d70af924b ("net: use dst_cache for vxlan device")
Fixes: 468dfffcd762 ("geneve: add dst caching support")
Fixes: 3c1cb4d2604c ("net/ipv4: add dst cache support for gre lwtunnels")
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Paolo Abeni <pabeni@redhat.com>
Acked-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-03-04 17:15:07 +03:00
|
|
|
use_cache = ip_tunnel_dst_cache_usable(skb, tun_info);
|
|
|
|
|
if (use_cache)
|
|
|
|
|
rt = dst_cache_get_ip4(&tun_info->dst_cache, &fl.saddr);
|
2016-02-12 17:43:59 +03:00
|
|
|
if (!rt) {
|
|
|
|
|
rt = gre_get_rt(skb, dev, &fl, key);
|
|
|
|
|
if (IS_ERR(rt))
|
|
|
|
|
goto err_free_skb;
|
bpf, vxlan, geneve, gre: fix usage of dst_cache on xmit
The assumptions from commit 0c1d70af924b ("net: use dst_cache for vxlan
device"), 468dfffcd762 ("geneve: add dst caching support") and 3c1cb4d2604c
("net/ipv4: add dst cache support for gre lwtunnels") on dst_cache usage
when ip_tunnel_info is used is unfortunately not always valid as assumed.
While it seems correct for ip_tunnel_info front-ends such as OVS, eBPF
however can fill in ip_tunnel_info for consumers like vxlan, geneve or gre
with different remote dsts, tos, etc, therefore they cannot be assumed as
packet independent.
Right now vxlan, geneve, gre would cache the dst for eBPF and every packet
would reuse the same entry that was first created on the initial route
lookup. eBPF doesn't store/cache the ip_tunnel_info, so each skb may have
a different one.
Fix it by adding a flag that checks the ip_tunnel_info. Also the !tos test
in vxlan needs to be handeled differently in this context as it is currently
inferred from ip_tunnel_info as well if present. ip_tunnel_dst_cache_usable()
helper is added for the three tunnel cases, which checks if we can use dst
cache.
Fixes: 0c1d70af924b ("net: use dst_cache for vxlan device")
Fixes: 468dfffcd762 ("geneve: add dst caching support")
Fixes: 3c1cb4d2604c ("net/ipv4: add dst cache support for gre lwtunnels")
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Paolo Abeni <pabeni@redhat.com>
Acked-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-03-04 17:15:07 +03:00
|
|
|
if (use_cache)
|
2016-02-12 17:43:59 +03:00
|
|
|
dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst,
|
|
|
|
|
fl.saddr);
|
|
|
|
|
}
|
2015-08-08 09:51:42 +03:00
|
|
|
|
2016-04-30 03:12:16 +03:00
|
|
|
tunnel_hlen = gre_calc_hlen(key->tun_flags);
|
2015-08-08 09:51:42 +03:00
|
|
|
|
|
|
|
|
min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
|
|
|
|
|
+ tunnel_hlen + sizeof(struct iphdr);
|
|
|
|
|
if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) {
|
|
|
|
|
int head_delta = SKB_DATA_ALIGN(min_headroom -
|
|
|
|
|
skb_headroom(skb) +
|
|
|
|
|
16);
|
|
|
|
|
err = pskb_expand_head(skb, max_t(int, head_delta, 0),
|
|
|
|
|
0, GFP_ATOMIC);
|
|
|
|
|
if (unlikely(err))
|
|
|
|
|
goto err_free_rt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Push Tunnel header. */
|
2016-04-14 22:33:37 +03:00
|
|
|
if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
|
2015-08-08 09:51:42 +03:00
|
|
|
goto err_free_rt;
|
|
|
|
|
|
|
|
|
|
flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY);
|
2016-05-04 07:52:29 +03:00
|
|
|
gre_build_header(skb, tunnel_hlen, flags, proto,
|
2016-09-08 16:23:45 +03:00
|
|
|
tunnel_id_to_key32(tun_info->key.tun_id), 0);
|
2015-08-08 09:51:42 +03:00
|
|
|
|
|
|
|
|
df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
|
2015-12-25 01:34:54 +03:00
|
|
|
|
|
|
|
|
iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE,
|
|
|
|
|
key->tos, key->ttl, df, false);
|
2015-08-08 09:51:42 +03:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
err_free_rt:
|
|
|
|
|
ip_rt_put(rt);
|
|
|
|
|
err_free_skb:
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
dev->stats.tx_dropped++;
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-23 04:17:16 +03:00
|
|
|
static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel_info *info = skb_tunnel_info(skb);
|
|
|
|
|
struct rtable *rt;
|
|
|
|
|
struct flowi4 fl4;
|
|
|
|
|
|
|
|
|
|
if (ip_tunnel_info_af(info) != AF_INET)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
rt = gre_get_rt(skb, dev, &fl4, &info->key);
|
|
|
|
|
if (IS_ERR(rt))
|
|
|
|
|
return PTR_ERR(rt);
|
|
|
|
|
|
|
|
|
|
ip_rt_put(rt);
|
|
|
|
|
info->key.u.ipv4.src = fl4.saddr;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
|
|
|
|
|
struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
const struct iphdr *tnl_params;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-08-08 09:51:42 +03:00
|
|
|
if (tunnel->collect_md) {
|
2016-04-27 12:29:07 +03:00
|
|
|
gre_fb_xmit(skb, dev, skb->protocol);
|
2015-08-08 09:51:42 +03:00
|
|
|
return NETDEV_TX_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
if (dev->header_ops) {
|
|
|
|
|
/* Need space for new headers */
|
|
|
|
|
if (skb_cow_head(skb, dev->needed_headroom -
|
2013-04-23 00:45:42 +04:00
|
|
|
(tunnel->hlen + sizeof(struct iphdr))))
|
2013-03-25 18:49:35 +04:00
|
|
|
goto free_skb;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
tnl_params = (const struct iphdr *)skb->data;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
/* Pull skb since ip_tunnel_xmit() needs skb->data pointing
|
|
|
|
|
* to gre header.
|
|
|
|
|
*/
|
|
|
|
|
skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
|
2014-12-15 10:24:13 +03:00
|
|
|
skb_reset_mac_header(skb);
|
2013-03-25 18:49:35 +04:00
|
|
|
} else {
|
|
|
|
|
if (skb_cow_head(skb, dev->needed_headroom))
|
|
|
|
|
goto free_skb;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
tnl_params = &tunnel->parms.iph;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2016-04-14 22:33:37 +03:00
|
|
|
if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
|
|
|
|
|
goto free_skb;
|
2014-12-15 10:24:13 +03:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
__gre_xmit(skb, dev, tnl_params, skb->protocol);
|
2009-06-23 10:03:08 +04:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
free_skb:
|
2014-01-19 06:27:49 +04:00
|
|
|
kfree_skb(skb);
|
2013-03-25 18:49:35 +04:00
|
|
|
dev->stats.tx_dropped++;
|
2009-06-23 10:03:08 +04:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
|
|
|
|
|
struct net_device *dev)
|
2007-12-13 20:46:32 +03:00
|
|
|
{
|
2013-03-25 18:49:35 +04:00
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
2007-12-13 20:46:32 +03:00
|
|
|
|
2015-08-08 09:51:42 +03:00
|
|
|
if (tunnel->collect_md) {
|
2016-04-27 12:29:07 +03:00
|
|
|
gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
|
2015-08-08 09:51:42 +03:00
|
|
|
return NETDEV_TX_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-14 22:33:37 +03:00
|
|
|
if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
|
|
|
|
|
goto free_skb;
|
2007-12-13 20:46:32 +03:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
if (skb_cow_head(skb, dev->needed_headroom))
|
|
|
|
|
goto free_skb;
|
2008-10-09 22:59:32 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
__gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
|
|
|
|
|
return NETDEV_TX_OK;
|
2007-12-13 20:46:32 +03:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
free_skb:
|
2014-01-19 06:27:49 +04:00
|
|
|
kfree_skb(skb);
|
2013-03-25 18:49:35 +04:00
|
|
|
dev->stats.tx_dropped++;
|
|
|
|
|
return NETDEV_TX_OK;
|
2007-12-13 20:46:32 +03:00
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static int ipgre_tunnel_ioctl(struct net_device *dev,
|
|
|
|
|
struct ifreq *ifr, int cmd)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-09-17 23:26:01 +04:00
|
|
|
int err;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct ip_tunnel_parm p;
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
|
|
|
|
|
return -EFAULT;
|
2013-06-29 08:02:59 +04:00
|
|
|
if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
|
|
|
|
|
if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
|
|
|
|
|
p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
|
|
|
|
|
((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
|
|
|
|
|
return -EINVAL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2013-03-25 18:49:35 +04:00
|
|
|
p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
|
|
|
|
|
p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
err = ip_tunnel_ioctl(dev, &p, cmd);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-04-30 03:12:16 +03:00
|
|
|
p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags);
|
|
|
|
|
p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags);
|
2013-03-25 18:49:35 +04:00
|
|
|
|
|
|
|
|
if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
|
|
|
|
|
return -EFAULT;
|
2005-04-17 02:20:36 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Nice toy. Unfortunately, useless in real life :-)
|
|
|
|
|
It allows to construct virtual multiprotocol broadcast "LAN"
|
|
|
|
|
over the Internet, provided multicast routing is tuned.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
I have no idea was this bicycle invented before me,
|
|
|
|
|
so that I had to set ARPHRD_IPGRE to a random value.
|
|
|
|
|
I have an impression, that Cisco could make something similar,
|
|
|
|
|
but this feature is apparently missing in IOS<=11.2(8).
|
2007-02-09 17:24:47 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
|
|
|
|
|
with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
|
|
|
|
|
|
|
|
|
|
ping -t 255 224.66.66.66
|
|
|
|
|
|
|
|
|
|
If nobody answers, mbone does not work.
|
|
|
|
|
|
|
|
|
|
ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
|
|
|
|
|
ip addr add 10.66.66.<somewhat>/24 dev Universe
|
|
|
|
|
ifconfig Universe up
|
|
|
|
|
ifconfig Universe add fe80::<Your_real_addr>/10
|
|
|
|
|
ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
|
|
|
|
|
ftp 10.66.66.66
|
|
|
|
|
...
|
|
|
|
|
ftp fec0:6666:6666::193.233.7.65
|
|
|
|
|
...
|
|
|
|
|
*/
|
2007-10-09 12:40:57 +04:00
|
|
|
static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
|
|
|
|
|
unsigned short type,
|
2010-09-15 15:07:53 +04:00
|
|
|
const void *daddr, const void *saddr, unsigned int len)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2006-01-09 09:05:26 +03:00
|
|
|
struct ip_tunnel *t = netdev_priv(dev);
|
2013-03-25 18:49:35 +04:00
|
|
|
struct iphdr *iph;
|
|
|
|
|
struct gre_base_hdr *greh;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
networking: make skb_push & __skb_push return void pointers
It seems like a historic accident that these return unsigned char *,
and in many places that means casts are required, more often than not.
Make these functions return void * and remove all the casts across
the tree, adding a (u8 *) cast only where the unsigned char pointer
was used directly, all done with the following spatch:
@@
expression SKB, LEN;
typedef u8;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
@@
- *(fn(SKB, LEN))
+ *(u8 *)fn(SKB, LEN)
@@
expression E, SKB, LEN;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
type T;
@@
- E = ((T *)(fn(SKB, LEN)))
+ E = fn(SKB, LEN)
@@
expression SKB, LEN;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
@@
- fn(SKB, LEN)[0]
+ *(u8 *)fn(SKB, LEN)
Note that the last part there converts from push(...)[0] to the
more idiomatic *(u8 *)push(...).
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 15:29:23 +03:00
|
|
|
iph = skb_push(skb, t->hlen + sizeof(*iph));
|
2013-03-25 18:49:35 +04:00
|
|
|
greh = (struct gre_base_hdr *)(iph+1);
|
2016-04-30 03:12:16 +03:00
|
|
|
greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
|
2013-03-25 18:49:35 +04:00
|
|
|
greh->protocol = htons(type);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
|
2007-02-09 17:24:47 +03:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
/* Set the source hardware address. */
|
2005-04-17 02:20:36 +04:00
|
|
|
if (saddr)
|
|
|
|
|
memcpy(&iph->saddr, saddr, 4);
|
2010-03-03 07:01:13 +03:00
|
|
|
if (daddr)
|
2005-04-17 02:20:36 +04:00
|
|
|
memcpy(&iph->daddr, daddr, 4);
|
2010-03-03 07:01:13 +03:00
|
|
|
if (iph->daddr)
|
2013-08-06 14:45:43 +04:00
|
|
|
return t->hlen + sizeof(*iph);
|
2007-02-09 17:24:47 +03:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
return -(t->hlen + sizeof(*iph));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2007-10-24 07:31:53 +04:00
|
|
|
static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
|
|
|
|
|
{
|
2011-04-22 08:53:02 +04:00
|
|
|
const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
|
2007-10-24 07:31:53 +04:00
|
|
|
memcpy(haddr, &iph->saddr, 4);
|
|
|
|
|
return 4;
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-09 12:40:57 +04:00
|
|
|
static const struct header_ops ipgre_header_ops = {
|
|
|
|
|
.create = ipgre_header,
|
2007-10-24 07:31:53 +04:00
|
|
|
.parse = ipgre_header_parse,
|
2007-10-09 12:40:57 +04:00
|
|
|
};
|
|
|
|
|
|
2007-10-24 07:31:53 +04:00
|
|
|
#ifdef CONFIG_NET_IPGRE_BROADCAST
|
2005-04-17 02:20:36 +04:00
|
|
|
static int ipgre_open(struct net_device *dev)
|
|
|
|
|
{
|
2006-01-09 09:05:26 +03:00
|
|
|
struct ip_tunnel *t = netdev_priv(dev);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-12-17 00:45:43 +03:00
|
|
|
if (ipv4_is_multicast(t->parms.iph.daddr)) {
|
2011-05-04 23:33:34 +04:00
|
|
|
struct flowi4 fl4;
|
|
|
|
|
struct rtable *rt;
|
|
|
|
|
|
2014-04-22 12:15:23 +04:00
|
|
|
rt = ip_route_output_gre(t->net, &fl4,
|
2011-05-04 23:33:34 +04:00
|
|
|
t->parms.iph.daddr,
|
|
|
|
|
t->parms.iph.saddr,
|
|
|
|
|
t->parms.o_key,
|
|
|
|
|
RT_TOS(t->parms.iph.tos),
|
|
|
|
|
t->parms.link);
|
2011-03-03 01:31:35 +03:00
|
|
|
if (IS_ERR(rt))
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EADDRNOTAVAIL;
|
2010-06-11 10:31:35 +04:00
|
|
|
dev = rt->dst.dev;
|
2005-04-17 02:20:36 +04:00
|
|
|
ip_rt_put(rt);
|
2015-04-03 11:17:26 +03:00
|
|
|
if (!__in_dev_get_rtnl(dev))
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
t->mlink = dev->ifindex;
|
2005-10-04 01:35:55 +04:00
|
|
|
ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ipgre_close(struct net_device *dev)
|
|
|
|
|
{
|
2006-01-09 09:05:26 +03:00
|
|
|
struct ip_tunnel *t = netdev_priv(dev);
|
2008-11-21 07:34:29 +03:00
|
|
|
|
2007-12-17 00:45:43 +03:00
|
|
|
if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
|
2008-01-22 04:32:38 +03:00
|
|
|
struct in_device *in_dev;
|
2014-04-22 12:15:23 +04:00
|
|
|
in_dev = inetdev_by_index(t->net, t->mlink);
|
2010-10-19 04:39:26 +04:00
|
|
|
if (in_dev)
|
2005-04-17 02:20:36 +04:00
|
|
|
ip_mc_dec_group(in_dev, t->parms.iph.daddr);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-11-21 07:34:29 +03:00
|
|
|
static const struct net_device_ops ipgre_netdev_ops = {
|
|
|
|
|
.ndo_init = ipgre_tunnel_init,
|
2013-03-25 18:49:35 +04:00
|
|
|
.ndo_uninit = ip_tunnel_uninit,
|
2008-11-21 07:34:29 +03:00
|
|
|
#ifdef CONFIG_NET_IPGRE_BROADCAST
|
|
|
|
|
.ndo_open = ipgre_open,
|
|
|
|
|
.ndo_stop = ipgre_close,
|
|
|
|
|
#endif
|
2013-03-25 18:49:35 +04:00
|
|
|
.ndo_start_xmit = ipgre_xmit,
|
2008-11-21 07:34:29 +03:00
|
|
|
.ndo_do_ioctl = ipgre_tunnel_ioctl,
|
2013-03-25 18:49:35 +04:00
|
|
|
.ndo_change_mtu = ip_tunnel_change_mtu,
|
|
|
|
|
.ndo_get_stats64 = ip_tunnel_get_stats64,
|
2015-04-02 18:07:02 +03:00
|
|
|
.ndo_get_iflink = ip_tunnel_get_iflink,
|
2008-11-21 07:34:29 +03:00
|
|
|
};
|
|
|
|
|
|
2012-09-14 01:25:33 +04:00
|
|
|
#define GRE_FEATURES (NETIF_F_SG | \
|
|
|
|
|
NETIF_F_FRAGLIST | \
|
|
|
|
|
NETIF_F_HIGHDMA | \
|
|
|
|
|
NETIF_F_HW_CSUM)
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static void ipgre_tunnel_setup(struct net_device *dev)
|
|
|
|
|
{
|
2008-11-21 07:34:29 +03:00
|
|
|
dev->netdev_ops = &ipgre_netdev_ops;
|
2014-04-11 17:51:18 +04:00
|
|
|
dev->type = ARPHRD_IPGRE;
|
2013-03-25 18:49:35 +04:00
|
|
|
ip_tunnel_setup(dev, ipgre_net_id);
|
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static void __gre_tunnel_init(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel;
|
2014-09-17 23:26:01 +04:00
|
|
|
int t_hlen;
|
2013-03-25 18:49:35 +04:00
|
|
|
|
|
|
|
|
tunnel = netdev_priv(dev);
|
2016-04-30 03:12:16 +03:00
|
|
|
tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
|
2013-03-25 18:49:35 +04:00
|
|
|
tunnel->parms.iph.protocol = IPPROTO_GRE;
|
|
|
|
|
|
2014-09-17 23:26:01 +04:00
|
|
|
tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
|
|
|
|
|
|
|
|
|
|
t_hlen = tunnel->hlen + sizeof(struct iphdr);
|
|
|
|
|
|
|
|
|
|
dev->needed_headroom = LL_MAX_HEADER + t_hlen + 4;
|
|
|
|
|
dev->mtu = ETH_DATA_LEN - t_hlen - 4;
|
2012-09-14 01:25:33 +04:00
|
|
|
|
2014-04-22 12:15:23 +04:00
|
|
|
dev->features |= GRE_FEATURES;
|
2012-09-14 01:25:33 +04:00
|
|
|
dev->hw_features |= GRE_FEATURES;
|
2013-03-25 18:49:35 +04:00
|
|
|
|
|
|
|
|
if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
|
2016-04-05 19:13:39 +03:00
|
|
|
/* TCP offload with GRE SEQ is not supported, nor
|
|
|
|
|
* can we support 2 levels of outer headers requiring
|
|
|
|
|
* an update.
|
|
|
|
|
*/
|
|
|
|
|
if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
|
|
|
|
|
(tunnel->encap.type == TUNNEL_ENCAP_NONE)) {
|
|
|
|
|
dev->features |= NETIF_F_GSO_SOFTWARE;
|
|
|
|
|
dev->hw_features |= NETIF_F_GSO_SOFTWARE;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
/* Can use a lockless transmit, unless we generate
|
|
|
|
|
* output sequences
|
|
|
|
|
*/
|
|
|
|
|
dev->features |= NETIF_F_LLTX;
|
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ipgre_tunnel_init(struct net_device *dev)
|
|
|
|
|
{
|
2013-03-25 18:49:35 +04:00
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
struct iphdr *iph = &tunnel->parms.iph;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
__gre_tunnel_init(dev);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
memcpy(dev->dev_addr, &iph->saddr, 4);
|
|
|
|
|
memcpy(dev->broadcast, &iph->daddr, 4);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
dev->flags = IFF_NOARP;
|
2014-10-06 05:38:35 +04:00
|
|
|
netif_keep_dst(dev);
|
2013-03-25 18:49:35 +04:00
|
|
|
dev->addr_len = 4;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-04-27 12:29:06 +03:00
|
|
|
if (iph->daddr && !tunnel->collect_md) {
|
2005-04-17 02:20:36 +04:00
|
|
|
#ifdef CONFIG_NET_IPGRE_BROADCAST
|
2007-12-17 00:45:43 +03:00
|
|
|
if (ipv4_is_multicast(iph->daddr)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!iph->saddr)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
dev->flags = IFF_BROADCAST;
|
2007-10-09 12:40:57 +04:00
|
|
|
dev->header_ops = &ipgre_header_ops;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
#endif
|
2016-04-27 12:29:06 +03:00
|
|
|
} else if (!tunnel->collect_md) {
|
2007-10-24 07:31:53 +04:00
|
|
|
dev->header_ops = &ipgre_header_ops;
|
2016-04-27 12:29:06 +03:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
return ip_tunnel_init(dev);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2015-08-08 09:51:52 +03:00
|
|
|
static const struct gre_protocol ipgre_protocol = {
|
|
|
|
|
.handler = gre_rcv,
|
|
|
|
|
.err_handler = gre_err,
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
|
2010-01-17 06:35:32 +03:00
|
|
|
static int __net_init ipgre_init_net(struct net *net)
|
2008-04-16 12:08:53 +04:00
|
|
|
{
|
2013-03-25 18:49:35 +04:00
|
|
|
return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
|
2008-04-16 12:08:53 +04:00
|
|
|
}
|
|
|
|
|
|
2010-01-17 06:35:32 +03:00
|
|
|
static void __net_exit ipgre_exit_net(struct net *net)
|
2008-04-16 12:08:53 +04:00
|
|
|
{
|
2013-03-25 18:49:35 +04:00
|
|
|
struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
|
2013-08-13 19:51:11 +04:00
|
|
|
ip_tunnel_delete_net(itn, &ipgre_link_ops);
|
2008-04-16 12:08:53 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct pernet_operations ipgre_net_ops = {
|
|
|
|
|
.init = ipgre_init_net,
|
|
|
|
|
.exit = ipgre_exit_net,
|
2009-11-29 18:46:13 +03:00
|
|
|
.id = &ipgre_net_id,
|
2013-03-25 18:49:35 +04:00
|
|
|
.size = sizeof(struct ip_tunnel_net),
|
2008-04-16 12:08:53 +04:00
|
|
|
};
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2017-06-26 00:56:01 +03:00
|
|
|
static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
|
struct netlink_ext_ack *extack)
|
2008-10-09 22:59:55 +04:00
|
|
|
{
|
|
|
|
|
__be16 flags;
|
|
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
flags = 0;
|
|
|
|
|
if (data[IFLA_GRE_IFLAGS])
|
|
|
|
|
flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
|
|
|
|
|
if (data[IFLA_GRE_OFLAGS])
|
|
|
|
|
flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
|
|
|
|
|
if (flags & (GRE_VERSION|GRE_ROUTING))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2016-04-27 15:08:01 +03:00
|
|
|
if (data[IFLA_GRE_COLLECT_METADATA] &&
|
|
|
|
|
data[IFLA_GRE_ENCAP_TYPE] &&
|
|
|
|
|
nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2008-10-09 22:59:55 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-26 00:56:01 +03:00
|
|
|
static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
|
struct netlink_ext_ack *extack)
|
2008-10-09 23:00:17 +04:00
|
|
|
{
|
|
|
|
|
__be32 daddr;
|
|
|
|
|
|
|
|
|
|
if (tb[IFLA_ADDRESS]) {
|
|
|
|
|
if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
|
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_REMOTE]) {
|
|
|
|
|
memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
|
|
|
|
|
if (!daddr)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
2017-06-26 00:56:01 +03:00
|
|
|
return ipgre_tunnel_validate(tb, data, extack);
|
2008-10-09 23:00:17 +04:00
|
|
|
}
|
|
|
|
|
|
2016-06-15 00:53:02 +03:00
|
|
|
static int ipgre_netlink_parms(struct net_device *dev,
|
2015-08-08 09:51:42 +03:00
|
|
|
struct nlattr *data[],
|
|
|
|
|
struct nlattr *tb[],
|
2017-04-19 19:30:54 +03:00
|
|
|
struct ip_tunnel_parm *parms,
|
|
|
|
|
__u32 *fwmark)
|
2008-10-09 22:59:55 +04:00
|
|
|
{
|
2016-06-15 00:53:02 +03:00
|
|
|
struct ip_tunnel *t = netdev_priv(dev);
|
|
|
|
|
|
2008-10-11 23:20:15 +04:00
|
|
|
memset(parms, 0, sizeof(*parms));
|
2008-10-09 22:59:55 +04:00
|
|
|
|
|
|
|
|
parms->iph.protocol = IPPROTO_GRE;
|
|
|
|
|
|
|
|
|
|
if (!data)
|
2016-06-15 00:53:02 +03:00
|
|
|
return 0;
|
2008-10-09 22:59:55 +04:00
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_LINK])
|
|
|
|
|
parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_IFLAGS])
|
2013-03-25 18:49:35 +04:00
|
|
|
parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
|
2008-10-09 22:59:55 +04:00
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_OFLAGS])
|
2013-03-25 18:49:35 +04:00
|
|
|
parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
|
2008-10-09 22:59:55 +04:00
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_IKEY])
|
|
|
|
|
parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_OKEY])
|
|
|
|
|
parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_LOCAL])
|
2015-03-29 17:59:26 +03:00
|
|
|
parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
|
2008-10-09 22:59:55 +04:00
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_REMOTE])
|
2015-03-29 17:59:26 +03:00
|
|
|
parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
|
2008-10-09 22:59:55 +04:00
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_TTL])
|
|
|
|
|
parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_TOS])
|
|
|
|
|
parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
|
|
|
|
|
|
2016-06-15 00:53:02 +03:00
|
|
|
if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
|
|
|
|
|
if (t->ignore_df)
|
|
|
|
|
return -EINVAL;
|
2008-10-09 22:59:55 +04:00
|
|
|
parms->iph.frag_off = htons(IP_DF);
|
2016-06-15 00:53:02 +03:00
|
|
|
}
|
2015-08-08 09:51:42 +03:00
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_COLLECT_METADATA]) {
|
|
|
|
|
t->collect_md = true;
|
2016-05-11 16:53:57 +03:00
|
|
|
if (dev->type == ARPHRD_IPGRE)
|
|
|
|
|
dev->type = ARPHRD_NONE;
|
2015-08-08 09:51:42 +03:00
|
|
|
}
|
2016-06-15 00:53:02 +03:00
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_IGNORE_DF]) {
|
|
|
|
|
if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
|
|
|
|
|
&& (parms->iph.frag_off & htons(IP_DF)))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-19 19:30:54 +03:00
|
|
|
if (data[IFLA_GRE_FWMARK])
|
|
|
|
|
*fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
|
|
|
|
|
|
2016-06-15 00:53:02 +03:00
|
|
|
return 0;
|
2008-10-09 22:59:55 +04:00
|
|
|
}
|
|
|
|
|
|
2014-09-17 23:26:01 +04:00
|
|
|
/* This function returns true when ENCAP attributes are present in the nl msg */
|
|
|
|
|
static bool ipgre_netlink_encap_parms(struct nlattr *data[],
|
|
|
|
|
struct ip_tunnel_encap *ipencap)
|
|
|
|
|
{
|
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
|
|
memset(ipencap, 0, sizeof(*ipencap));
|
|
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_TYPE]) {
|
|
|
|
|
ret = true;
|
|
|
|
|
ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_FLAGS]) {
|
|
|
|
|
ret = true;
|
|
|
|
|
ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_SPORT]) {
|
|
|
|
|
ret = true;
|
2015-02-06 19:22:22 +03:00
|
|
|
ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
|
2014-09-17 23:26:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_DPORT]) {
|
|
|
|
|
ret = true;
|
2015-02-06 19:22:22 +03:00
|
|
|
ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
|
2014-09-17 23:26:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static int gre_tap_init(struct net_device *dev)
|
2008-10-09 23:00:17 +04:00
|
|
|
{
|
2013-03-25 18:49:35 +04:00
|
|
|
__gre_tunnel_init(dev);
|
2014-12-27 21:01:42 +03:00
|
|
|
dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
|
2008-10-09 23:00:17 +04:00
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
return ip_tunnel_init(dev);
|
2008-10-09 23:00:17 +04:00
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static const struct net_device_ops gre_tap_netdev_ops = {
|
|
|
|
|
.ndo_init = gre_tap_init,
|
|
|
|
|
.ndo_uninit = ip_tunnel_uninit,
|
|
|
|
|
.ndo_start_xmit = gre_tap_xmit,
|
2008-11-21 07:34:29 +03:00
|
|
|
.ndo_set_mac_address = eth_mac_addr,
|
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
2013-03-25 18:49:35 +04:00
|
|
|
.ndo_change_mtu = ip_tunnel_change_mtu,
|
|
|
|
|
.ndo_get_stats64 = ip_tunnel_get_stats64,
|
2015-04-02 18:07:02 +03:00
|
|
|
.ndo_get_iflink = ip_tunnel_get_iflink,
|
2015-10-23 04:17:16 +03:00
|
|
|
.ndo_fill_metadata_dst = gre_fill_metadata_dst,
|
2008-11-21 07:34:29 +03:00
|
|
|
};
|
|
|
|
|
|
2008-10-09 23:00:17 +04:00
|
|
|
static void ipgre_tap_setup(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
ether_setup(dev);
|
2016-02-17 17:32:53 +03:00
|
|
|
dev->netdev_ops = &gre_tap_netdev_ops;
|
|
|
|
|
dev->priv_flags &= ~IFF_TX_SKB_SHARING;
|
|
|
|
|
dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
|
2013-03-25 18:49:35 +04:00
|
|
|
ip_tunnel_setup(dev, gre_tap_net_id);
|
2008-10-09 23:00:17 +04:00
|
|
|
}
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static int ipgre_newlink(struct net *src_net, struct net_device *dev,
|
2017-06-26 00:55:59 +03:00
|
|
|
struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
|
struct netlink_ext_ack *extack)
|
2008-10-09 22:59:55 +04:00
|
|
|
{
|
2013-03-25 18:49:35 +04:00
|
|
|
struct ip_tunnel_parm p;
|
2014-09-17 23:26:01 +04:00
|
|
|
struct ip_tunnel_encap ipencap;
|
2017-04-19 19:30:54 +03:00
|
|
|
__u32 fwmark = 0;
|
2016-06-15 00:53:02 +03:00
|
|
|
int err;
|
2014-09-17 23:26:01 +04:00
|
|
|
|
|
|
|
|
if (ipgre_netlink_encap_parms(data, &ipencap)) {
|
|
|
|
|
struct ip_tunnel *t = netdev_priv(dev);
|
2016-06-15 00:53:02 +03:00
|
|
|
err = ip_tunnel_encap_setup(t, &ipencap);
|
2014-09-17 23:26:01 +04:00
|
|
|
|
|
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2008-10-09 22:59:55 +04:00
|
|
|
|
2017-04-19 19:30:54 +03:00
|
|
|
err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
|
2016-06-15 00:53:02 +03:00
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
2017-04-19 19:30:54 +03:00
|
|
|
return ip_tunnel_newlink(dev, tb, &p, fwmark);
|
2008-10-09 22:59:55 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
|
2017-06-26 00:56:00 +03:00
|
|
|
struct nlattr *data[],
|
|
|
|
|
struct netlink_ext_ack *extack)
|
2008-10-09 22:59:55 +04:00
|
|
|
{
|
2017-04-19 19:30:54 +03:00
|
|
|
struct ip_tunnel *t = netdev_priv(dev);
|
2008-10-09 22:59:55 +04:00
|
|
|
struct ip_tunnel_parm p;
|
2014-09-17 23:26:01 +04:00
|
|
|
struct ip_tunnel_encap ipencap;
|
2017-04-19 19:30:54 +03:00
|
|
|
__u32 fwmark = t->fwmark;
|
2016-06-15 00:53:02 +03:00
|
|
|
int err;
|
2014-09-17 23:26:01 +04:00
|
|
|
|
|
|
|
|
if (ipgre_netlink_encap_parms(data, &ipencap)) {
|
2016-06-15 00:53:02 +03:00
|
|
|
err = ip_tunnel_encap_setup(t, &ipencap);
|
2014-09-17 23:26:01 +04:00
|
|
|
|
|
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2008-10-09 22:59:55 +04:00
|
|
|
|
2017-04-19 19:30:54 +03:00
|
|
|
err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
|
2016-06-15 00:53:02 +03:00
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
2017-04-19 19:30:54 +03:00
|
|
|
return ip_tunnel_changelink(dev, tb, &p, fwmark);
|
2008-10-09 22:59:55 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static size_t ipgre_get_size(const struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
return
|
|
|
|
|
/* IFLA_GRE_LINK */
|
|
|
|
|
nla_total_size(4) +
|
|
|
|
|
/* IFLA_GRE_IFLAGS */
|
|
|
|
|
nla_total_size(2) +
|
|
|
|
|
/* IFLA_GRE_OFLAGS */
|
|
|
|
|
nla_total_size(2) +
|
|
|
|
|
/* IFLA_GRE_IKEY */
|
|
|
|
|
nla_total_size(4) +
|
|
|
|
|
/* IFLA_GRE_OKEY */
|
|
|
|
|
nla_total_size(4) +
|
|
|
|
|
/* IFLA_GRE_LOCAL */
|
|
|
|
|
nla_total_size(4) +
|
|
|
|
|
/* IFLA_GRE_REMOTE */
|
|
|
|
|
nla_total_size(4) +
|
|
|
|
|
/* IFLA_GRE_TTL */
|
|
|
|
|
nla_total_size(1) +
|
|
|
|
|
/* IFLA_GRE_TOS */
|
|
|
|
|
nla_total_size(1) +
|
|
|
|
|
/* IFLA_GRE_PMTUDISC */
|
|
|
|
|
nla_total_size(1) +
|
2014-09-17 23:26:01 +04:00
|
|
|
/* IFLA_GRE_ENCAP_TYPE */
|
|
|
|
|
nla_total_size(2) +
|
|
|
|
|
/* IFLA_GRE_ENCAP_FLAGS */
|
|
|
|
|
nla_total_size(2) +
|
|
|
|
|
/* IFLA_GRE_ENCAP_SPORT */
|
|
|
|
|
nla_total_size(2) +
|
|
|
|
|
/* IFLA_GRE_ENCAP_DPORT */
|
|
|
|
|
nla_total_size(2) +
|
2015-08-08 09:51:42 +03:00
|
|
|
/* IFLA_GRE_COLLECT_METADATA */
|
|
|
|
|
nla_total_size(0) +
|
2016-06-15 00:53:02 +03:00
|
|
|
/* IFLA_GRE_IGNORE_DF */
|
|
|
|
|
nla_total_size(1) +
|
2017-04-19 19:30:54 +03:00
|
|
|
/* IFLA_GRE_FWMARK */
|
|
|
|
|
nla_total_size(4) +
|
2008-10-09 22:59:55 +04:00
|
|
|
0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *t = netdev_priv(dev);
|
|
|
|
|
struct ip_tunnel_parm *p = &t->parms;
|
|
|
|
|
|
2012-04-02 04:39:02 +04:00
|
|
|
if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
|
2016-04-30 03:12:16 +03:00
|
|
|
nla_put_be16(skb, IFLA_GRE_IFLAGS,
|
|
|
|
|
gre_tnl_flags_to_gre_flags(p->i_flags)) ||
|
|
|
|
|
nla_put_be16(skb, IFLA_GRE_OFLAGS,
|
|
|
|
|
gre_tnl_flags_to_gre_flags(p->o_flags)) ||
|
2012-04-02 04:39:02 +04:00
|
|
|
nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
|
|
|
|
|
nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
|
2015-03-29 17:59:25 +03:00
|
|
|
nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
|
|
|
|
|
nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
|
2012-04-02 04:39:02 +04:00
|
|
|
nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
|
|
|
|
|
nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
|
|
|
|
|
nla_put_u8(skb, IFLA_GRE_PMTUDISC,
|
2017-04-19 19:30:54 +03:00
|
|
|
!!(p->iph.frag_off & htons(IP_DF))) ||
|
|
|
|
|
nla_put_u32(skb, IFLA_GRE_FWMARK, t->fwmark))
|
2012-04-02 04:39:02 +04:00
|
|
|
goto nla_put_failure;
|
2014-09-17 23:26:01 +04:00
|
|
|
|
|
|
|
|
if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
|
|
|
|
|
t->encap.type) ||
|
2015-02-06 19:22:22 +03:00
|
|
|
nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
|
|
|
|
|
t->encap.sport) ||
|
|
|
|
|
nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
|
|
|
|
|
t->encap.dport) ||
|
2014-09-17 23:26:01 +04:00
|
|
|
nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
|
2014-11-06 03:49:38 +03:00
|
|
|
t->encap.flags))
|
2014-09-17 23:26:01 +04:00
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
2016-06-15 00:53:02 +03:00
|
|
|
if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
|
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
2015-08-08 09:51:42 +03:00
|
|
|
if (t->collect_md) {
|
|
|
|
|
if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
|
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-09 22:59:55 +04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
nla_put_failure:
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
|
|
|
|
|
[IFLA_GRE_LINK] = { .type = NLA_U32 },
|
|
|
|
|
[IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
|
|
|
|
|
[IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
|
|
|
|
|
[IFLA_GRE_IKEY] = { .type = NLA_U32 },
|
|
|
|
|
[IFLA_GRE_OKEY] = { .type = NLA_U32 },
|
2008-10-10 23:11:06 +04:00
|
|
|
[IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
|
|
|
|
|
[IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
|
2008-10-09 22:59:55 +04:00
|
|
|
[IFLA_GRE_TTL] = { .type = NLA_U8 },
|
|
|
|
|
[IFLA_GRE_TOS] = { .type = NLA_U8 },
|
|
|
|
|
[IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
|
2014-09-17 23:26:01 +04:00
|
|
|
[IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 },
|
|
|
|
|
[IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 },
|
|
|
|
|
[IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 },
|
|
|
|
|
[IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 },
|
2015-08-08 09:51:42 +03:00
|
|
|
[IFLA_GRE_COLLECT_METADATA] = { .type = NLA_FLAG },
|
2016-06-15 00:53:02 +03:00
|
|
|
[IFLA_GRE_IGNORE_DF] = { .type = NLA_U8 },
|
2017-04-19 19:30:54 +03:00
|
|
|
[IFLA_GRE_FWMARK] = { .type = NLA_U32 },
|
2008-10-09 22:59:55 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
|
|
|
|
|
.kind = "gre",
|
|
|
|
|
.maxtype = IFLA_GRE_MAX,
|
|
|
|
|
.policy = ipgre_policy,
|
|
|
|
|
.priv_size = sizeof(struct ip_tunnel),
|
|
|
|
|
.setup = ipgre_tunnel_setup,
|
|
|
|
|
.validate = ipgre_tunnel_validate,
|
|
|
|
|
.newlink = ipgre_newlink,
|
|
|
|
|
.changelink = ipgre_changelink,
|
2013-03-25 18:49:35 +04:00
|
|
|
.dellink = ip_tunnel_dellink,
|
2008-10-09 22:59:55 +04:00
|
|
|
.get_size = ipgre_get_size,
|
|
|
|
|
.fill_info = ipgre_fill_info,
|
2015-01-15 17:11:17 +03:00
|
|
|
.get_link_net = ip_tunnel_get_link_net,
|
2008-10-09 22:59:55 +04:00
|
|
|
};
|
|
|
|
|
|
2008-10-09 23:00:17 +04:00
|
|
|
static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
|
|
|
|
|
.kind = "gretap",
|
|
|
|
|
.maxtype = IFLA_GRE_MAX,
|
|
|
|
|
.policy = ipgre_policy,
|
|
|
|
|
.priv_size = sizeof(struct ip_tunnel),
|
|
|
|
|
.setup = ipgre_tap_setup,
|
|
|
|
|
.validate = ipgre_tap_validate,
|
|
|
|
|
.newlink = ipgre_newlink,
|
|
|
|
|
.changelink = ipgre_changelink,
|
2013-03-25 18:49:35 +04:00
|
|
|
.dellink = ip_tunnel_dellink,
|
2008-10-09 23:00:17 +04:00
|
|
|
.get_size = ipgre_get_size,
|
|
|
|
|
.fill_info = ipgre_fill_info,
|
2015-01-15 17:11:17 +03:00
|
|
|
.get_link_net = ip_tunnel_get_link_net,
|
2008-10-09 23:00:17 +04:00
|
|
|
};
|
|
|
|
|
|
2015-08-08 09:51:47 +03:00
|
|
|
struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
|
|
|
|
|
u8 name_assign_type)
|
|
|
|
|
{
|
|
|
|
|
struct nlattr *tb[IFLA_MAX + 1];
|
|
|
|
|
struct net_device *dev;
|
2016-06-13 11:31:04 +03:00
|
|
|
LIST_HEAD(list_kill);
|
2015-08-08 09:51:47 +03:00
|
|
|
struct ip_tunnel *t;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
memset(&tb, 0, sizeof(tb));
|
|
|
|
|
|
|
|
|
|
dev = rtnl_create_link(net, name, name_assign_type,
|
|
|
|
|
&ipgre_tap_ops, tb);
|
|
|
|
|
if (IS_ERR(dev))
|
|
|
|
|
return dev;
|
|
|
|
|
|
|
|
|
|
/* Configure flow based GRE device. */
|
|
|
|
|
t = netdev_priv(dev);
|
|
|
|
|
t->collect_md = true;
|
|
|
|
|
|
2017-06-26 00:55:59 +03:00
|
|
|
err = ipgre_newlink(net, dev, tb, NULL, NULL);
|
2016-06-13 11:31:04 +03:00
|
|
|
if (err < 0) {
|
|
|
|
|
free_netdev(dev);
|
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
}
|
vxlan, gre, geneve: Set a large MTU on ovs-created tunnel devices
Prior to 4.3, openvswitch tunnel vports (vxlan, gre and geneve) could
transmit vxlan packets of any size, constrained only by the ability to
send out the resulting packets. 4.3 introduced netdevs corresponding
to tunnel vports. These netdevs have an MTU, which limits the size of
a packet that can be successfully encapsulated. The default MTU
values are low (1500 or less), which is awkwardly small in the context
of physical networks supporting jumbo frames, and leads to a
conspicuous change in behaviour for userspace.
Instead, set the MTU on openvswitch-created netdevs to be the relevant
maximum (i.e. the maximum IP packet size minus any relevant overhead),
effectively restoring the behaviour prior to 4.3.
Signed-off-by: David Wragg <david@weave.works>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-10 03:05:58 +03:00
|
|
|
|
|
|
|
|
/* openvswitch users expect packet sizes to be unrestricted,
|
|
|
|
|
* so set the largest MTU we can.
|
|
|
|
|
*/
|
|
|
|
|
err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2016-06-13 11:31:06 +03:00
|
|
|
err = rtnl_configure_link(dev, NULL);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2015-08-08 09:51:47 +03:00
|
|
|
return dev;
|
|
|
|
|
out:
|
2016-06-13 11:31:04 +03:00
|
|
|
ip_tunnel_dellink(dev, &list_kill);
|
|
|
|
|
unregister_netdevice_many(&list_kill);
|
2015-08-08 09:51:47 +03:00
|
|
|
return ERR_PTR(err);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
static int __net_init ipgre_tap_init_net(struct net *net)
|
|
|
|
|
{
|
2015-08-08 09:51:42 +03:00
|
|
|
return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
|
2013-03-25 18:49:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __net_exit ipgre_tap_exit_net(struct net *net)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
|
2013-08-13 19:51:11 +04:00
|
|
|
ip_tunnel_delete_net(itn, &ipgre_tap_ops);
|
2013-03-25 18:49:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct pernet_operations ipgre_tap_net_ops = {
|
|
|
|
|
.init = ipgre_tap_init_net,
|
|
|
|
|
.exit = ipgre_tap_exit_net,
|
|
|
|
|
.id = &gre_tap_net_id,
|
|
|
|
|
.size = sizeof(struct ip_tunnel_net),
|
|
|
|
|
};
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
static int __init ipgre_init(void)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
2012-03-11 22:36:11 +04:00
|
|
|
pr_info("GRE over IPv4 tunneling driver\n");
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2009-11-29 18:46:13 +03:00
|
|
|
err = register_pernet_device(&ipgre_net_ops);
|
2008-04-16 12:08:53 +04:00
|
|
|
if (err < 0)
|
2010-02-16 10:57:44 +03:00
|
|
|
return err;
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
err = register_pernet_device(&ipgre_tap_net_ops);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto pnet_tap_faied;
|
|
|
|
|
|
2015-08-08 09:51:52 +03:00
|
|
|
err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
|
2010-02-16 10:57:44 +03:00
|
|
|
if (err < 0) {
|
2012-03-11 22:36:11 +04:00
|
|
|
pr_info("%s: can't add protocol\n", __func__);
|
2010-02-16 10:57:44 +03:00
|
|
|
goto add_proto_failed;
|
|
|
|
|
}
|
2008-04-16 12:10:05 +04:00
|
|
|
|
2008-10-09 22:59:55 +04:00
|
|
|
err = rtnl_link_register(&ipgre_link_ops);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto rtnl_link_failed;
|
|
|
|
|
|
2008-10-09 23:00:17 +04:00
|
|
|
err = rtnl_link_register(&ipgre_tap_ops);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto tap_ops_failed;
|
|
|
|
|
|
2013-03-25 18:49:35 +04:00
|
|
|
return 0;
|
2008-10-09 22:59:55 +04:00
|
|
|
|
2008-10-09 23:00:17 +04:00
|
|
|
tap_ops_failed:
|
|
|
|
|
rtnl_link_unregister(&ipgre_link_ops);
|
2008-10-09 22:59:55 +04:00
|
|
|
rtnl_link_failed:
|
2015-08-08 09:51:52 +03:00
|
|
|
gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
|
2010-02-16 10:57:44 +03:00
|
|
|
add_proto_failed:
|
2013-03-25 18:49:35 +04:00
|
|
|
unregister_pernet_device(&ipgre_tap_net_ops);
|
|
|
|
|
pnet_tap_faied:
|
2010-02-16 10:57:44 +03:00
|
|
|
unregister_pernet_device(&ipgre_net_ops);
|
2013-03-25 18:49:35 +04:00
|
|
|
return err;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2005-07-31 04:46:44 +04:00
|
|
|
static void __exit ipgre_fini(void)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2008-10-09 23:00:17 +04:00
|
|
|
rtnl_link_unregister(&ipgre_tap_ops);
|
2008-10-09 22:59:55 +04:00
|
|
|
rtnl_link_unregister(&ipgre_link_ops);
|
2015-08-08 09:51:52 +03:00
|
|
|
gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
|
2013-03-25 18:49:35 +04:00
|
|
|
unregister_pernet_device(&ipgre_tap_net_ops);
|
2010-02-16 10:57:44 +03:00
|
|
|
unregister_pernet_device(&ipgre_net_ops);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(ipgre_init);
|
|
|
|
|
module_exit(ipgre_fini);
|
|
|
|
|
MODULE_LICENSE("GPL");
|
2008-10-10 23:11:06 +04:00
|
|
|
MODULE_ALIAS_RTNL_LINK("gre");
|
|
|
|
|
MODULE_ALIAS_RTNL_LINK("gretap");
|
2011-03-02 00:33:13 +03:00
|
|
|
MODULE_ALIAS_NETDEV("gre0");
|
2013-03-25 18:49:35 +04:00
|
|
|
MODULE_ALIAS_NETDEV("gretap0");
|
