2013-03-25 14:49:35 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2013 Nicira, Inc.
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of version 2 of the GNU General Public
|
|
|
|
|
* License as published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
|
* 02110-1301, USA
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
|
|
|
|
#include <linux/capability.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
|
#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>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/in6.h>
|
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
|
#include <linux/igmp.h>
|
|
|
|
|
#include <linux/netfilter_ipv4.h>
|
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
|
#include <linux/if_ether.h>
|
|
|
|
|
#include <linux/if_vlan.h>
|
|
|
|
|
#include <linux/rculist.h>
|
2014-01-27 06:43:57 +00:00
|
|
|
#include <linux/err.h>
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
#include <net/sock.h>
|
|
|
|
|
#include <net/ip.h>
|
|
|
|
|
#include <net/icmp.h>
|
|
|
|
|
#include <net/protocol.h>
|
|
|
|
|
#include <net/ip_tunnels.h>
|
|
|
|
|
#include <net/arp.h>
|
|
|
|
|
#include <net/checksum.h>
|
|
|
|
|
#include <net/dsfield.h>
|
|
|
|
|
#include <net/inet_ecn.h>
|
|
|
|
|
#include <net/xfrm.h>
|
|
|
|
|
#include <net/net_namespace.h>
|
|
|
|
|
#include <net/netns/generic.h>
|
|
|
|
|
#include <net/rtnetlink.h>
|
2014-09-17 19:25:58 +00:00
|
|
|
#include <net/udp.h>
|
2016-09-15 20:00:29 +00:00
|
|
|
#include <net/dst_metadata.h>
|
2014-11-04 17:06:51 +00:00
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
|
#include <net/ipv6.h>
|
|
|
|
|
#include <net/ip6_fib.h>
|
|
|
|
|
#include <net/ip6_route.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-01-19 08:43:42 +00:00
|
|
|
static unsigned int ip_tunnel_hash(__be32 key, __be32 remote)
|
2013-03-25 14:49:35 +00:00
|
|
|
{
|
|
|
|
|
return hash_32((__force u32)key ^ (__force u32)remote,
|
|
|
|
|
IP_TNL_HASH_BITS);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool ip_tunnel_key_match(const struct ip_tunnel_parm *p,
|
|
|
|
|
__be16 flags, __be32 key)
|
|
|
|
|
{
|
|
|
|
|
if (p->i_flags & TUNNEL_KEY) {
|
|
|
|
|
if (flags & TUNNEL_KEY)
|
|
|
|
|
return key == p->i_key;
|
|
|
|
|
else
|
|
|
|
|
/* key expected, none present */
|
|
|
|
|
return false;
|
|
|
|
|
} else
|
|
|
|
|
return !(flags & TUNNEL_KEY);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Fallback tunnel: no source, no destination, no key, no options
|
|
|
|
|
|
|
|
|
|
Tunnel hash table:
|
|
|
|
|
We require exact key match i.e. if a key is present in packet
|
|
|
|
|
it will match only tunnel with the same key; if it is not present,
|
|
|
|
|
it will match only keyless tunnel.
|
|
|
|
|
|
|
|
|
|
All keysless packets, if not matched configured keyless tunnels
|
|
|
|
|
will match fallback tunnel.
|
|
|
|
|
Given src, dst and key, find appropriate for input tunnel.
|
|
|
|
|
*/
|
|
|
|
|
struct ip_tunnel *ip_tunnel_lookup(struct ip_tunnel_net *itn,
|
|
|
|
|
int link, __be16 flags,
|
|
|
|
|
__be32 remote, __be32 local,
|
|
|
|
|
__be32 key)
|
|
|
|
|
{
|
|
|
|
|
unsigned int hash;
|
|
|
|
|
struct ip_tunnel *t, *cand = NULL;
|
|
|
|
|
struct hlist_head *head;
|
|
|
|
|
|
2014-01-19 08:43:42 +00:00
|
|
|
hash = ip_tunnel_hash(key, remote);
|
2013-03-25 14:49:35 +00:00
|
|
|
head = &itn->tunnels[hash];
|
|
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(t, head, hash_node) {
|
|
|
|
|
if (local != t->parms.iph.saddr ||
|
|
|
|
|
remote != t->parms.iph.daddr ||
|
|
|
|
|
!(t->dev->flags & IFF_UP))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (!ip_tunnel_key_match(&t->parms, flags, key))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (t->parms.link == link)
|
|
|
|
|
return t;
|
|
|
|
|
else
|
|
|
|
|
cand = t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(t, head, hash_node) {
|
|
|
|
|
if (remote != t->parms.iph.daddr ||
|
2014-07-04 22:26:37 +00:00
|
|
|
t->parms.iph.saddr != 0 ||
|
2013-03-25 14:49:35 +00:00
|
|
|
!(t->dev->flags & IFF_UP))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (!ip_tunnel_key_match(&t->parms, flags, key))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (t->parms.link == link)
|
|
|
|
|
return t;
|
|
|
|
|
else if (!cand)
|
|
|
|
|
cand = t;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-19 08:43:42 +00:00
|
|
|
hash = ip_tunnel_hash(key, 0);
|
2013-03-25 14:49:35 +00:00
|
|
|
head = &itn->tunnels[hash];
|
|
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(t, head, hash_node) {
|
2014-07-04 22:26:37 +00:00
|
|
|
if ((local != t->parms.iph.saddr || t->parms.iph.daddr != 0) &&
|
|
|
|
|
(local != t->parms.iph.daddr || !ipv4_is_multicast(local)))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (!(t->dev->flags & IFF_UP))
|
2013-03-25 14:49:35 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (!ip_tunnel_key_match(&t->parms, flags, key))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (t->parms.link == link)
|
|
|
|
|
return t;
|
|
|
|
|
else if (!cand)
|
|
|
|
|
cand = t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (flags & TUNNEL_NO_KEY)
|
|
|
|
|
goto skip_key_lookup;
|
|
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(t, head, hash_node) {
|
|
|
|
|
if (t->parms.i_key != key ||
|
2014-07-04 22:26:37 +00:00
|
|
|
t->parms.iph.saddr != 0 ||
|
|
|
|
|
t->parms.iph.daddr != 0 ||
|
2013-03-25 14:49:35 +00:00
|
|
|
!(t->dev->flags & IFF_UP))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (t->parms.link == link)
|
|
|
|
|
return t;
|
|
|
|
|
else if (!cand)
|
|
|
|
|
cand = t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
skip_key_lookup:
|
|
|
|
|
if (cand)
|
|
|
|
|
return cand;
|
|
|
|
|
|
2015-08-08 06:51:42 +00:00
|
|
|
t = rcu_dereference(itn->collect_md_tun);
|
|
|
|
|
if (t)
|
|
|
|
|
return t;
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
if (itn->fb_tunnel_dev && itn->fb_tunnel_dev->flags & IFF_UP)
|
|
|
|
|
return netdev_priv(itn->fb_tunnel_dev);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_lookup);
|
|
|
|
|
|
|
|
|
|
static struct hlist_head *ip_bucket(struct ip_tunnel_net *itn,
|
|
|
|
|
struct ip_tunnel_parm *parms)
|
|
|
|
|
{
|
|
|
|
|
unsigned int h;
|
|
|
|
|
__be32 remote;
|
2014-02-21 07:41:09 +00:00
|
|
|
__be32 i_key = parms->i_key;
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
if (parms->iph.daddr && !ipv4_is_multicast(parms->iph.daddr))
|
|
|
|
|
remote = parms->iph.daddr;
|
|
|
|
|
else
|
|
|
|
|
remote = 0;
|
|
|
|
|
|
2014-02-21 07:41:09 +00:00
|
|
|
if (!(parms->i_flags & TUNNEL_KEY) && (parms->i_flags & VTI_ISVTI))
|
|
|
|
|
i_key = 0;
|
|
|
|
|
|
|
|
|
|
h = ip_tunnel_hash(i_key, remote);
|
2013-03-25 14:49:35 +00:00
|
|
|
return &itn->tunnels[h];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void ip_tunnel_add(struct ip_tunnel_net *itn, struct ip_tunnel *t)
|
|
|
|
|
{
|
|
|
|
|
struct hlist_head *head = ip_bucket(itn, &t->parms);
|
|
|
|
|
|
2015-08-08 06:51:42 +00:00
|
|
|
if (t->collect_md)
|
|
|
|
|
rcu_assign_pointer(itn->collect_md_tun, t);
|
2013-03-25 14:49:35 +00:00
|
|
|
hlist_add_head_rcu(&t->hash_node, head);
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-08 06:51:42 +00:00
|
|
|
static void ip_tunnel_del(struct ip_tunnel_net *itn, struct ip_tunnel *t)
|
2013-03-25 14:49:35 +00:00
|
|
|
{
|
2015-08-08 06:51:42 +00:00
|
|
|
if (t->collect_md)
|
|
|
|
|
rcu_assign_pointer(itn->collect_md_tun, NULL);
|
2013-03-25 14:49:35 +00:00
|
|
|
hlist_del_init_rcu(&t->hash_node);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct ip_tunnel *ip_tunnel_find(struct ip_tunnel_net *itn,
|
|
|
|
|
struct ip_tunnel_parm *parms,
|
|
|
|
|
int type)
|
|
|
|
|
{
|
|
|
|
|
__be32 remote = parms->iph.daddr;
|
|
|
|
|
__be32 local = parms->iph.saddr;
|
|
|
|
|
__be32 key = parms->i_key;
|
2014-06-07 23:03:08 +00:00
|
|
|
__be16 flags = parms->i_flags;
|
2013-03-25 14:49:35 +00:00
|
|
|
int link = parms->link;
|
|
|
|
|
struct ip_tunnel *t = NULL;
|
|
|
|
|
struct hlist_head *head = ip_bucket(itn, parms);
|
|
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(t, head, hash_node) {
|
|
|
|
|
if (local == t->parms.iph.saddr &&
|
|
|
|
|
remote == t->parms.iph.daddr &&
|
|
|
|
|
link == t->parms.link &&
|
2014-06-07 23:03:08 +00:00
|
|
|
type == t->dev->type &&
|
|
|
|
|
ip_tunnel_key_match(&t->parms, flags, key))
|
2013-03-25 14:49:35 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct net_device *__ip_tunnel_create(struct net *net,
|
|
|
|
|
const struct rtnl_link_ops *ops,
|
|
|
|
|
struct ip_tunnel_parm *parms)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
struct ip_tunnel *tunnel;
|
|
|
|
|
struct net_device *dev;
|
|
|
|
|
char name[IFNAMSIZ];
|
|
|
|
|
|
|
|
|
|
if (parms->name[0])
|
|
|
|
|
strlcpy(name, parms->name, IFNAMSIZ);
|
|
|
|
|
else {
|
2013-03-28 08:21:46 +00:00
|
|
|
if (strlen(ops->kind) > (IFNAMSIZ - 3)) {
|
2013-03-25 14:49:35 +00:00
|
|
|
err = -E2BIG;
|
|
|
|
|
goto failed;
|
|
|
|
|
}
|
|
|
|
|
strlcpy(name, ops->kind, IFNAMSIZ);
|
|
|
|
|
strncat(name, "%d", 2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
net: set name_assign_type in alloc_netdev()
Extend alloc_netdev{,_mq{,s}}() to take name_assign_type as argument, and convert
all users to pass NET_NAME_UNKNOWN.
Coccinelle patch:
@@
expression sizeof_priv, name, setup, txqs, rxqs, count;
@@
(
-alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs)
+alloc_netdev_mqs(sizeof_priv, name, NET_NAME_UNKNOWN, setup, txqs, rxqs)
|
-alloc_netdev_mq(sizeof_priv, name, setup, count)
+alloc_netdev_mq(sizeof_priv, name, NET_NAME_UNKNOWN, setup, count)
|
-alloc_netdev(sizeof_priv, name, setup)
+alloc_netdev(sizeof_priv, name, NET_NAME_UNKNOWN, setup)
)
v9: move comments here from the wrong commit
Signed-off-by: Tom Gundersen <teg@jklm.no>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-07-14 14:37:24 +00:00
|
|
|
dev = alloc_netdev(ops->priv_size, name, NET_NAME_UNKNOWN, ops->setup);
|
2013-03-25 14:49:35 +00:00
|
|
|
if (!dev) {
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
|
goto failed;
|
|
|
|
|
}
|
|
|
|
|
dev_net_set(dev, net);
|
|
|
|
|
|
|
|
|
|
dev->rtnl_link_ops = ops;
|
|
|
|
|
|
|
|
|
|
tunnel = netdev_priv(dev);
|
|
|
|
|
tunnel->parms = *parms;
|
2013-06-26 14:11:28 +00:00
|
|
|
tunnel->net = net;
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
err = register_netdevice(dev);
|
|
|
|
|
if (err)
|
|
|
|
|
goto failed_free;
|
|
|
|
|
|
|
|
|
|
return dev;
|
|
|
|
|
|
|
|
|
|
failed_free:
|
|
|
|
|
free_netdev(dev);
|
|
|
|
|
failed:
|
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-02 19:48:26 +00:00
|
|
|
static inline void init_tunnel_flow(struct flowi4 *fl4,
|
|
|
|
|
int proto,
|
|
|
|
|
__be32 daddr, __be32 saddr,
|
|
|
|
|
__be32 key, __u8 tos, int oif)
|
2013-03-25 14:49:35 +00:00
|
|
|
{
|
|
|
|
|
memset(fl4, 0, sizeof(*fl4));
|
|
|
|
|
fl4->flowi4_oif = oif;
|
|
|
|
|
fl4->daddr = daddr;
|
|
|
|
|
fl4->saddr = saddr;
|
|
|
|
|
fl4->flowi4_tos = tos;
|
|
|
|
|
fl4->flowi4_proto = proto;
|
|
|
|
|
fl4->fl4_gre_key = key;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ip_tunnel_bind_dev(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct net_device *tdev = NULL;
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
const struct iphdr *iph;
|
|
|
|
|
int hlen = LL_MAX_HEADER;
|
|
|
|
|
int mtu = ETH_DATA_LEN;
|
|
|
|
|
int t_hlen = tunnel->hlen + sizeof(struct iphdr);
|
|
|
|
|
|
|
|
|
|
iph = &tunnel->parms.iph;
|
|
|
|
|
|
|
|
|
|
/* Guess output device to choose reasonable mtu and needed_headroom */
|
|
|
|
|
if (iph->daddr) {
|
|
|
|
|
struct flowi4 fl4;
|
|
|
|
|
struct rtable *rt;
|
|
|
|
|
|
2014-01-02 19:48:26 +00:00
|
|
|
init_tunnel_flow(&fl4, iph->protocol, iph->daddr,
|
|
|
|
|
iph->saddr, tunnel->parms.o_key,
|
|
|
|
|
RT_TOS(iph->tos), tunnel->parms.link);
|
|
|
|
|
rt = ip_route_output_key(tunnel->net, &fl4);
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
if (!IS_ERR(rt)) {
|
|
|
|
|
tdev = rt->dst.dev;
|
|
|
|
|
ip_rt_put(rt);
|
|
|
|
|
}
|
|
|
|
|
if (dev->type != ARPHRD_ETHER)
|
|
|
|
|
dev->flags |= IFF_POINTOPOINT;
|
2016-04-28 09:04:51 +00:00
|
|
|
|
|
|
|
|
dst_cache_reset(&tunnel->dst_cache);
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!tdev && tunnel->parms.link)
|
2013-08-13 15:51:11 +00:00
|
|
|
tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
if (tdev) {
|
|
|
|
|
hlen = tdev->hard_header_len + tdev->needed_headroom;
|
|
|
|
|
mtu = tdev->mtu;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dev->needed_headroom = t_hlen + hlen;
|
|
|
|
|
mtu -= (dev->hard_header_len + t_hlen);
|
|
|
|
|
|
|
|
|
|
if (mtu < 68)
|
|
|
|
|
mtu = 68;
|
|
|
|
|
|
|
|
|
|
return mtu;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct ip_tunnel *ip_tunnel_create(struct net *net,
|
|
|
|
|
struct ip_tunnel_net *itn,
|
|
|
|
|
struct ip_tunnel_parm *parms)
|
|
|
|
|
{
|
2014-05-15 03:43:20 +00:00
|
|
|
struct ip_tunnel *nt;
|
2013-03-25 14:49:35 +00:00
|
|
|
struct net_device *dev;
|
|
|
|
|
|
|
|
|
|
BUG_ON(!itn->fb_tunnel_dev);
|
|
|
|
|
dev = __ip_tunnel_create(net, itn->fb_tunnel_dev->rtnl_link_ops, parms);
|
|
|
|
|
if (IS_ERR(dev))
|
2014-02-14 12:14:39 +00:00
|
|
|
return ERR_CAST(dev);
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
dev->mtu = ip_tunnel_bind_dev(dev);
|
|
|
|
|
|
|
|
|
|
nt = netdev_priv(dev);
|
|
|
|
|
ip_tunnel_add(itn, nt);
|
|
|
|
|
return nt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int ip_tunnel_rcv(struct ip_tunnel *tunnel, struct sk_buff *skb,
|
2015-08-08 06:51:42 +00:00
|
|
|
const struct tnl_ptk_info *tpi, struct metadata_dst *tun_dst,
|
|
|
|
|
bool log_ecn_error)
|
2013-03-25 14:49:35 +00:00
|
|
|
{
|
2014-01-04 05:57:59 +00:00
|
|
|
struct pcpu_sw_netstats *tstats;
|
2013-03-25 14:49:35 +00:00
|
|
|
const struct iphdr *iph = ip_hdr(skb);
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_IPGRE_BROADCAST
|
|
|
|
|
if (ipv4_is_multicast(iph->daddr)) {
|
|
|
|
|
tunnel->dev->stats.multicast++;
|
|
|
|
|
skb->pkt_type = PACKET_BROADCAST;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if ((!(tpi->flags&TUNNEL_CSUM) && (tunnel->parms.i_flags&TUNNEL_CSUM)) ||
|
|
|
|
|
((tpi->flags&TUNNEL_CSUM) && !(tunnel->parms.i_flags&TUNNEL_CSUM))) {
|
|
|
|
|
tunnel->dev->stats.rx_crc_errors++;
|
|
|
|
|
tunnel->dev->stats.rx_errors++;
|
|
|
|
|
goto drop;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (tunnel->parms.i_flags&TUNNEL_SEQ) {
|
|
|
|
|
if (!(tpi->flags&TUNNEL_SEQ) ||
|
|
|
|
|
(tunnel->i_seqno && (s32)(ntohl(tpi->seq) - tunnel->i_seqno) < 0)) {
|
|
|
|
|
tunnel->dev->stats.rx_fifo_errors++;
|
|
|
|
|
tunnel->dev->stats.rx_errors++;
|
|
|
|
|
goto drop;
|
|
|
|
|
}
|
|
|
|
|
tunnel->i_seqno = ntohl(tpi->seq) + 1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-04 22:20:04 +00:00
|
|
|
skb_reset_network_header(skb);
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
err = IP_ECN_decapsulate(iph, skb);
|
|
|
|
|
if (unlikely(err)) {
|
|
|
|
|
if (log_ecn_error)
|
|
|
|
|
net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
|
|
|
|
|
&iph->saddr, iph->tos);
|
|
|
|
|
if (err > 1) {
|
|
|
|
|
++tunnel->dev->stats.rx_frame_errors;
|
|
|
|
|
++tunnel->dev->stats.rx_errors;
|
|
|
|
|
goto drop;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tstats = this_cpu_ptr(tunnel->dev->tstats);
|
|
|
|
|
u64_stats_update_begin(&tstats->syncp);
|
|
|
|
|
tstats->rx_packets++;
|
|
|
|
|
tstats->rx_bytes += skb->len;
|
|
|
|
|
u64_stats_update_end(&tstats->syncp);
|
|
|
|
|
|
2013-11-12 22:39:13 +00:00
|
|
|
skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(tunnel->dev)));
|
|
|
|
|
|
2013-06-18 00:50:02 +00:00
|
|
|
if (tunnel->dev->type == ARPHRD_ETHER) {
|
|
|
|
|
skb->protocol = eth_type_trans(skb, tunnel->dev);
|
|
|
|
|
skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
|
|
|
|
|
} else {
|
|
|
|
|
skb->dev = tunnel->dev;
|
|
|
|
|
}
|
2013-08-13 15:51:09 +00:00
|
|
|
|
2015-08-08 06:51:42 +00:00
|
|
|
if (tun_dst)
|
|
|
|
|
skb_dst_set(skb, (struct dst_entry *)tun_dst);
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
gro_cells_receive(&tunnel->gro_cells, skb);
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
drop:
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_rcv);
|
|
|
|
|
|
2014-11-12 19:54:09 +00:00
|
|
|
int ip_tunnel_encap_add_ops(const struct ip_tunnel_encap_ops *ops,
|
|
|
|
|
unsigned int num)
|
|
|
|
|
{
|
2014-12-16 20:05:20 +00:00
|
|
|
if (num >= MAX_IPTUN_ENCAP_OPS)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
2014-11-12 19:54:09 +00:00
|
|
|
return !cmpxchg((const struct ip_tunnel_encap_ops **)
|
|
|
|
|
&iptun_encaps[num],
|
|
|
|
|
NULL, ops) ? 0 : -1;
|
2014-09-17 19:25:58 +00:00
|
|
|
}
|
2014-11-12 19:54:09 +00:00
|
|
|
EXPORT_SYMBOL(ip_tunnel_encap_add_ops);
|
|
|
|
|
|
|
|
|
|
int ip_tunnel_encap_del_ops(const struct ip_tunnel_encap_ops *ops,
|
|
|
|
|
unsigned int num)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
2014-12-16 20:05:20 +00:00
|
|
|
if (num >= MAX_IPTUN_ENCAP_OPS)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
2014-11-12 19:54:09 +00:00
|
|
|
ret = (cmpxchg((const struct ip_tunnel_encap_ops **)
|
|
|
|
|
&iptun_encaps[num],
|
|
|
|
|
ops, NULL) == ops) ? 0 : -1;
|
|
|
|
|
|
|
|
|
|
synchronize_net();
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(ip_tunnel_encap_del_ops);
|
2014-09-17 19:25:58 +00:00
|
|
|
|
|
|
|
|
int ip_tunnel_encap_setup(struct ip_tunnel *t,
|
|
|
|
|
struct ip_tunnel_encap *ipencap)
|
|
|
|
|
{
|
|
|
|
|
int hlen;
|
|
|
|
|
|
|
|
|
|
memset(&t->encap, 0, sizeof(t->encap));
|
|
|
|
|
|
|
|
|
|
hlen = ip_encap_hlen(ipencap);
|
|
|
|
|
if (hlen < 0)
|
|
|
|
|
return hlen;
|
|
|
|
|
|
|
|
|
|
t->encap.type = ipencap->type;
|
|
|
|
|
t->encap.sport = ipencap->sport;
|
|
|
|
|
t->encap.dport = ipencap->dport;
|
|
|
|
|
t->encap.flags = ipencap->flags;
|
|
|
|
|
|
|
|
|
|
t->encap_hlen = hlen;
|
|
|
|
|
t->hlen = t->encap_hlen + t->tun_hlen;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_encap_setup);
|
|
|
|
|
|
2013-07-02 17:57:33 +00:00
|
|
|
static int tnl_update_pmtu(struct net_device *dev, struct sk_buff *skb,
|
2015-07-07 05:34:13 +00:00
|
|
|
struct rtable *rt, __be16 df,
|
|
|
|
|
const struct iphdr *inner_iph)
|
2013-07-02 17:57:33 +00:00
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
2013-07-11 20:12:22 +00:00
|
|
|
int pkt_size = skb->len - tunnel->hlen - dev->hard_header_len;
|
2013-07-02 17:57:33 +00:00
|
|
|
int mtu;
|
|
|
|
|
|
|
|
|
|
if (df)
|
|
|
|
|
mtu = dst_mtu(&rt->dst) - dev->hard_header_len
|
|
|
|
|
- sizeof(struct iphdr) - tunnel->hlen;
|
|
|
|
|
else
|
|
|
|
|
mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
|
|
|
|
|
|
|
|
|
|
if (skb_dst(skb))
|
|
|
|
|
skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
|
|
|
|
|
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
|
|
|
|
if (!skb_is_gso(skb) &&
|
2015-07-07 05:34:13 +00:00
|
|
|
(inner_iph->frag_off & htons(IP_DF)) &&
|
|
|
|
|
mtu < pkt_size) {
|
2013-07-02 17:57:33 +00:00
|
|
|
memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
|
|
|
|
|
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
|
|
|
|
|
return -E2BIG;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
|
else if (skb->protocol == htons(ETH_P_IPV6)) {
|
|
|
|
|
struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
|
|
|
|
|
|
|
|
|
|
if (rt6 && mtu < dst_mtu(skb_dst(skb)) &&
|
|
|
|
|
mtu >= IPV6_MIN_MTU) {
|
|
|
|
|
if ((tunnel->parms.iph.daddr &&
|
|
|
|
|
!ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
|
|
|
|
|
rt6->rt6i_dst.plen == 128) {
|
|
|
|
|
rt6->rt6i_flags |= RTF_MODIFIED;
|
|
|
|
|
dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!skb_is_gso(skb) && mtu >= IPV6_MIN_MTU &&
|
|
|
|
|
mtu < pkt_size) {
|
|
|
|
|
icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
|
|
|
|
|
return -E2BIG;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-15 20:00:29 +00:00
|
|
|
void ip_md_tunnel_xmit(struct sk_buff *skb, struct net_device *dev, u8 proto)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
u32 headroom = sizeof(struct iphdr);
|
|
|
|
|
struct ip_tunnel_info *tun_info;
|
|
|
|
|
const struct ip_tunnel_key *key;
|
|
|
|
|
const struct iphdr *inner_iph;
|
|
|
|
|
struct rtable *rt;
|
|
|
|
|
struct flowi4 fl4;
|
|
|
|
|
__be16 df = 0;
|
|
|
|
|
u8 tos, ttl;
|
|
|
|
|
|
|
|
|
|
tun_info = skb_tunnel_info(skb);
|
|
|
|
|
if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
|
|
|
|
|
ip_tunnel_info_af(tun_info) != AF_INET))
|
|
|
|
|
goto tx_error;
|
|
|
|
|
key = &tun_info->key;
|
|
|
|
|
memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
|
|
|
|
|
inner_iph = (const struct iphdr *)skb_inner_network_header(skb);
|
|
|
|
|
tos = key->tos;
|
|
|
|
|
if (tos == 1) {
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP))
|
|
|
|
|
tos = inner_iph->tos;
|
|
|
|
|
else if (skb->protocol == htons(ETH_P_IPV6))
|
|
|
|
|
tos = ipv6_get_dsfield((const struct ipv6hdr *)inner_iph);
|
|
|
|
|
}
|
|
|
|
|
init_tunnel_flow(&fl4, proto, key->u.ipv4.dst, key->u.ipv4.src, 0,
|
|
|
|
|
RT_TOS(tos), tunnel->parms.link);
|
|
|
|
|
if (tunnel->encap.type != TUNNEL_ENCAP_NONE)
|
|
|
|
|
goto tx_error;
|
|
|
|
|
rt = ip_route_output_key(tunnel->net, &fl4);
|
|
|
|
|
if (IS_ERR(rt)) {
|
|
|
|
|
dev->stats.tx_carrier_errors++;
|
|
|
|
|
goto tx_error;
|
|
|
|
|
}
|
|
|
|
|
if (rt->dst.dev == dev) {
|
|
|
|
|
ip_rt_put(rt);
|
|
|
|
|
dev->stats.collisions++;
|
|
|
|
|
goto tx_error;
|
|
|
|
|
}
|
|
|
|
|
tos = ip_tunnel_ecn_encap(tos, inner_iph, skb);
|
|
|
|
|
ttl = key->ttl;
|
|
|
|
|
if (ttl == 0) {
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP))
|
|
|
|
|
ttl = inner_iph->ttl;
|
|
|
|
|
else if (skb->protocol == htons(ETH_P_IPV6))
|
|
|
|
|
ttl = ((const struct ipv6hdr *)inner_iph)->hop_limit;
|
|
|
|
|
else
|
|
|
|
|
ttl = ip4_dst_hoplimit(&rt->dst);
|
|
|
|
|
}
|
|
|
|
|
if (key->tun_flags & TUNNEL_DONT_FRAGMENT)
|
|
|
|
|
df = htons(IP_DF);
|
|
|
|
|
else if (skb->protocol == htons(ETH_P_IP))
|
|
|
|
|
df = inner_iph->frag_off & htons(IP_DF);
|
|
|
|
|
headroom += LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len;
|
|
|
|
|
if (headroom > dev->needed_headroom)
|
|
|
|
|
dev->needed_headroom = headroom;
|
|
|
|
|
|
|
|
|
|
if (skb_cow_head(skb, dev->needed_headroom)) {
|
|
|
|
|
ip_rt_put(rt);
|
|
|
|
|
goto tx_dropped;
|
|
|
|
|
}
|
|
|
|
|
iptunnel_xmit(NULL, rt, skb, fl4.saddr, fl4.daddr, proto, key->tos,
|
|
|
|
|
key->ttl, df, !net_eq(tunnel->net, dev_net(dev)));
|
|
|
|
|
return;
|
|
|
|
|
tx_error:
|
|
|
|
|
dev->stats.tx_errors++;
|
|
|
|
|
goto kfree;
|
|
|
|
|
tx_dropped:
|
|
|
|
|
dev->stats.tx_dropped++;
|
|
|
|
|
kfree:
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_md_tunnel_xmit);
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
|
2014-09-17 19:25:58 +00:00
|
|
|
const struct iphdr *tnl_params, u8 protocol)
|
2013-03-25 14:49:35 +00:00
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
const struct iphdr *inner_iph;
|
|
|
|
|
struct flowi4 fl4;
|
|
|
|
|
u8 tos, ttl;
|
|
|
|
|
__be16 df;
|
2014-02-03 20:52:14 +00:00
|
|
|
struct rtable *rt; /* Route to the other host */
|
2013-03-25 14:49:35 +00:00
|
|
|
unsigned int max_headroom; /* The extra header space needed */
|
|
|
|
|
__be32 dst;
|
2014-05-16 05:34:39 +00:00
|
|
|
bool connected;
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
inner_iph = (const struct iphdr *)skb_inner_network_header(skb);
|
2014-05-16 05:34:39 +00:00
|
|
|
connected = (tunnel->parms.iph.daddr != 0);
|
2013-03-25 14:49:35 +00:00
|
|
|
|
2016-02-21 23:58:05 +00:00
|
|
|
memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
dst = tnl_params->daddr;
|
|
|
|
|
if (dst == 0) {
|
|
|
|
|
/* NBMA tunnel */
|
|
|
|
|
|
2015-04-03 08:17:26 +00:00
|
|
|
if (!skb_dst(skb)) {
|
2013-03-25 14:49:35 +00:00
|
|
|
dev->stats.tx_fifo_errors++;
|
|
|
|
|
goto tx_error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
|
|
|
|
rt = skb_rtable(skb);
|
|
|
|
|
dst = rt_nexthop(rt, inner_iph->daddr);
|
|
|
|
|
}
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
|
else if (skb->protocol == htons(ETH_P_IPV6)) {
|
|
|
|
|
const struct in6_addr *addr6;
|
|
|
|
|
struct neighbour *neigh;
|
|
|
|
|
bool do_tx_error_icmp;
|
|
|
|
|
int addr_type;
|
|
|
|
|
|
|
|
|
|
neigh = dst_neigh_lookup(skb_dst(skb),
|
|
|
|
|
&ipv6_hdr(skb)->daddr);
|
2015-04-03 08:17:26 +00:00
|
|
|
if (!neigh)
|
2013-03-25 14:49:35 +00:00
|
|
|
goto tx_error;
|
|
|
|
|
|
|
|
|
|
addr6 = (const struct in6_addr *)&neigh->primary_key;
|
|
|
|
|
addr_type = ipv6_addr_type(addr6);
|
|
|
|
|
|
|
|
|
|
if (addr_type == IPV6_ADDR_ANY) {
|
|
|
|
|
addr6 = &ipv6_hdr(skb)->daddr;
|
|
|
|
|
addr_type = ipv6_addr_type(addr6);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
|
|
|
|
|
do_tx_error_icmp = true;
|
|
|
|
|
else {
|
|
|
|
|
do_tx_error_icmp = false;
|
|
|
|
|
dst = addr6->s6_addr32[3];
|
|
|
|
|
}
|
|
|
|
|
neigh_release(neigh);
|
|
|
|
|
if (do_tx_error_icmp)
|
|
|
|
|
goto tx_error_icmp;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
else
|
|
|
|
|
goto tx_error;
|
2014-01-02 19:48:26 +00:00
|
|
|
|
|
|
|
|
connected = false;
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tos = tnl_params->tos;
|
|
|
|
|
if (tos & 0x1) {
|
|
|
|
|
tos &= ~0x1;
|
2014-01-02 19:48:26 +00:00
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
2013-03-25 14:49:35 +00:00
|
|
|
tos = inner_iph->tos;
|
2014-01-02 19:48:26 +00:00
|
|
|
connected = false;
|
|
|
|
|
} else if (skb->protocol == htons(ETH_P_IPV6)) {
|
2013-03-25 14:49:35 +00:00
|
|
|
tos = ipv6_get_dsfield((const struct ipv6hdr *)inner_iph);
|
2014-01-02 19:48:26 +00:00
|
|
|
connected = false;
|
|
|
|
|
}
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
|
2014-01-02 19:48:26 +00:00
|
|
|
init_tunnel_flow(&fl4, protocol, dst, tnl_params->saddr,
|
|
|
|
|
tunnel->parms.o_key, RT_TOS(tos), tunnel->parms.link);
|
|
|
|
|
|
2014-09-17 19:25:58 +00:00
|
|
|
if (ip_tunnel_encap(skb, tunnel, &protocol, &fl4) < 0)
|
|
|
|
|
goto tx_error;
|
|
|
|
|
|
2016-02-12 14:43:55 +00:00
|
|
|
rt = connected ? dst_cache_get_ip4(&tunnel->dst_cache, &fl4.saddr) :
|
|
|
|
|
NULL;
|
2014-01-02 19:48:26 +00:00
|
|
|
|
|
|
|
|
if (!rt) {
|
|
|
|
|
rt = ip_route_output_key(tunnel->net, &fl4);
|
|
|
|
|
|
|
|
|
|
if (IS_ERR(rt)) {
|
|
|
|
|
dev->stats.tx_carrier_errors++;
|
|
|
|
|
goto tx_error;
|
|
|
|
|
}
|
|
|
|
|
if (connected)
|
2016-02-12 14:43:55 +00:00
|
|
|
dst_cache_set_ip4(&tunnel->dst_cache, &rt->dst,
|
|
|
|
|
fl4.saddr);
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
2014-01-02 19:48:26 +00:00
|
|
|
|
2013-06-18 00:49:56 +00:00
|
|
|
if (rt->dst.dev == dev) {
|
2013-03-25 14:49:35 +00:00
|
|
|
ip_rt_put(rt);
|
|
|
|
|
dev->stats.collisions++;
|
|
|
|
|
goto tx_error;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-07 05:34:13 +00:00
|
|
|
if (tnl_update_pmtu(dev, skb, rt, tnl_params->frag_off, inner_iph)) {
|
2013-07-02 17:57:33 +00:00
|
|
|
ip_rt_put(rt);
|
|
|
|
|
goto tx_error;
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (tunnel->err_count > 0) {
|
|
|
|
|
if (time_before(jiffies,
|
|
|
|
|
tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
|
|
|
|
|
tunnel->err_count--;
|
|
|
|
|
|
|
|
|
|
dst_link_failure(skb);
|
|
|
|
|
} else
|
|
|
|
|
tunnel->err_count = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-25 16:57:47 +00:00
|
|
|
tos = ip_tunnel_ecn_encap(tos, inner_iph, skb);
|
2013-03-25 14:49:35 +00:00
|
|
|
ttl = tnl_params->ttl;
|
|
|
|
|
if (ttl == 0) {
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP))
|
|
|
|
|
ttl = inner_iph->ttl;
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
|
else if (skb->protocol == htons(ETH_P_IPV6))
|
|
|
|
|
ttl = ((const struct ipv6hdr *)inner_iph)->hop_limit;
|
|
|
|
|
#endif
|
|
|
|
|
else
|
|
|
|
|
ttl = ip4_dst_hoplimit(&rt->dst);
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-02 17:57:33 +00:00
|
|
|
df = tnl_params->frag_off;
|
2016-06-14 21:53:02 +00:00
|
|
|
if (skb->protocol == htons(ETH_P_IP) && !tunnel->ignore_df)
|
2013-07-02 17:57:33 +00:00
|
|
|
df |= (inner_iph->frag_off&htons(IP_DF));
|
|
|
|
|
|
2013-06-18 00:49:56 +00:00
|
|
|
max_headroom = LL_RESERVED_SPACE(rt->dst.dev) + sizeof(struct iphdr)
|
2014-10-03 22:48:07 +00:00
|
|
|
+ rt->dst.header_len + ip_encap_hlen(&tunnel->encap);
|
2013-10-01 09:33:59 +00:00
|
|
|
if (max_headroom > dev->needed_headroom)
|
2013-03-25 14:49:35 +00:00
|
|
|
dev->needed_headroom = max_headroom;
|
2013-10-01 09:33:59 +00:00
|
|
|
|
|
|
|
|
if (skb_cow_head(skb, dev->needed_headroom)) {
|
2014-06-06 00:34:37 +00:00
|
|
|
ip_rt_put(rt);
|
2013-10-01 09:33:59 +00:00
|
|
|
dev->stats.tx_dropped++;
|
2014-01-19 02:27:49 +00:00
|
|
|
kfree_skb(skb);
|
2013-10-01 09:33:59 +00:00
|
|
|
return;
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
|
2015-12-24 22:34:54 +00:00
|
|
|
iptunnel_xmit(NULL, rt, skb, fl4.saddr, fl4.daddr, protocol, tos, ttl,
|
|
|
|
|
df, !net_eq(tunnel->net, dev_net(dev)));
|
2013-03-25 14:49:35 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
|
tx_error_icmp:
|
|
|
|
|
dst_link_failure(skb);
|
|
|
|
|
#endif
|
|
|
|
|
tx_error:
|
|
|
|
|
dev->stats.tx_errors++;
|
2014-01-19 02:27:49 +00:00
|
|
|
kfree_skb(skb);
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_xmit);
|
|
|
|
|
|
|
|
|
|
static void ip_tunnel_update(struct ip_tunnel_net *itn,
|
|
|
|
|
struct ip_tunnel *t,
|
|
|
|
|
struct net_device *dev,
|
|
|
|
|
struct ip_tunnel_parm *p,
|
|
|
|
|
bool set_mtu)
|
|
|
|
|
{
|
2015-08-08 06:51:42 +00:00
|
|
|
ip_tunnel_del(itn, t);
|
2013-03-25 14:49:35 +00:00
|
|
|
t->parms.iph.saddr = p->iph.saddr;
|
|
|
|
|
t->parms.iph.daddr = p->iph.daddr;
|
|
|
|
|
t->parms.i_key = p->i_key;
|
|
|
|
|
t->parms.o_key = p->o_key;
|
|
|
|
|
if (dev->type != ARPHRD_ETHER) {
|
|
|
|
|
memcpy(dev->dev_addr, &p->iph.saddr, 4);
|
|
|
|
|
memcpy(dev->broadcast, &p->iph.daddr, 4);
|
|
|
|
|
}
|
|
|
|
|
ip_tunnel_add(itn, t);
|
|
|
|
|
|
|
|
|
|
t->parms.iph.ttl = p->iph.ttl;
|
|
|
|
|
t->parms.iph.tos = p->iph.tos;
|
|
|
|
|
t->parms.iph.frag_off = p->iph.frag_off;
|
|
|
|
|
|
|
|
|
|
if (t->parms.link != p->link) {
|
|
|
|
|
int mtu;
|
|
|
|
|
|
|
|
|
|
t->parms.link = p->link;
|
|
|
|
|
mtu = ip_tunnel_bind_dev(dev);
|
|
|
|
|
if (set_mtu)
|
|
|
|
|
dev->mtu = mtu;
|
|
|
|
|
}
|
2016-02-12 14:43:55 +00:00
|
|
|
dst_cache_reset(&t->dst_cache);
|
2013-03-25 14:49:35 +00:00
|
|
|
netdev_state_change(dev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd)
|
|
|
|
|
{
|
|
|
|
|
int err = 0;
|
2014-04-16 09:19:32 +00:00
|
|
|
struct ip_tunnel *t = netdev_priv(dev);
|
|
|
|
|
struct net *net = t->net;
|
|
|
|
|
struct ip_tunnel_net *itn = net_generic(net, t->ip_tnl_net_id);
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
BUG_ON(!itn->fb_tunnel_dev);
|
|
|
|
|
switch (cmd) {
|
|
|
|
|
case SIOCGETTUNNEL:
|
2014-04-16 09:19:32 +00:00
|
|
|
if (dev == itn->fb_tunnel_dev) {
|
2013-03-25 14:49:35 +00:00
|
|
|
t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
|
2015-04-03 08:17:26 +00:00
|
|
|
if (!t)
|
2014-04-16 09:19:32 +00:00
|
|
|
t = netdev_priv(dev);
|
|
|
|
|
}
|
2013-03-25 14:49:35 +00:00
|
|
|
memcpy(p, &t->parms, sizeof(*p));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SIOCADDTUNNEL:
|
|
|
|
|
case SIOCCHGTUNNEL:
|
|
|
|
|
err = -EPERM;
|
|
|
|
|
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
|
|
|
|
|
goto done;
|
|
|
|
|
if (p->iph.ttl)
|
|
|
|
|
p->iph.frag_off |= htons(IP_DF);
|
2014-06-07 22:06:25 +00:00
|
|
|
if (!(p->i_flags & VTI_ISVTI)) {
|
|
|
|
|
if (!(p->i_flags & TUNNEL_KEY))
|
|
|
|
|
p->i_key = 0;
|
|
|
|
|
if (!(p->o_flags & TUNNEL_KEY))
|
|
|
|
|
p->o_key = 0;
|
|
|
|
|
}
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
|
|
|
|
|
|
2014-09-22 07:11:08 +00:00
|
|
|
if (cmd == SIOCADDTUNNEL) {
|
|
|
|
|
if (!t) {
|
|
|
|
|
t = ip_tunnel_create(net, itn, p);
|
|
|
|
|
err = PTR_ERR_OR_ZERO(t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = -EEXIST;
|
2014-05-15 05:07:02 +00:00
|
|
|
break;
|
2014-02-14 12:14:39 +00:00
|
|
|
}
|
2013-03-25 14:49:35 +00:00
|
|
|
if (dev != itn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
|
2015-04-03 08:17:27 +00:00
|
|
|
if (t) {
|
2013-03-25 14:49:35 +00:00
|
|
|
if (t->dev != dev) {
|
|
|
|
|
err = -EEXIST;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
unsigned int nflags = 0;
|
|
|
|
|
|
|
|
|
|
if (ipv4_is_multicast(p->iph.daddr))
|
|
|
|
|
nflags = IFF_BROADCAST;
|
|
|
|
|
else if (p->iph.daddr)
|
|
|
|
|
nflags = IFF_POINTOPOINT;
|
|
|
|
|
|
|
|
|
|
if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
|
|
|
|
|
err = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
t = netdev_priv(dev);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (t) {
|
|
|
|
|
err = 0;
|
|
|
|
|
ip_tunnel_update(itn, t, dev, p, true);
|
2014-02-14 12:14:39 +00:00
|
|
|
} else {
|
|
|
|
|
err = -ENOENT;
|
|
|
|
|
}
|
2013-03-25 14:49:35 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SIOCDELTUNNEL:
|
|
|
|
|
err = -EPERM;
|
|
|
|
|
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
|
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
|
|
if (dev == itn->fb_tunnel_dev) {
|
|
|
|
|
err = -ENOENT;
|
|
|
|
|
t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
|
2015-04-03 08:17:26 +00:00
|
|
|
if (!t)
|
2013-03-25 14:49:35 +00:00
|
|
|
goto done;
|
|
|
|
|
err = -EPERM;
|
|
|
|
|
if (t == netdev_priv(itn->fb_tunnel_dev))
|
|
|
|
|
goto done;
|
|
|
|
|
dev = t->dev;
|
|
|
|
|
}
|
|
|
|
|
unregister_netdevice(dev);
|
|
|
|
|
err = 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
err = -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_ioctl);
|
|
|
|
|
|
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 00:05:58 +00:00
|
|
|
int __ip_tunnel_change_mtu(struct net_device *dev, int new_mtu, bool strict)
|
2013-03-25 14:49:35 +00:00
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
int t_hlen = tunnel->hlen + sizeof(struct iphdr);
|
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 00:05:58 +00:00
|
|
|
int max_mtu = 0xFFF8 - dev->hard_header_len - t_hlen;
|
2013-03-25 14:49:35 +00:00
|
|
|
|
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 00:05:58 +00:00
|
|
|
if (new_mtu < 68)
|
2013-03-25 14:49:35 +00:00
|
|
|
return -EINVAL;
|
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 00:05:58 +00:00
|
|
|
|
|
|
|
|
if (new_mtu > max_mtu) {
|
|
|
|
|
if (strict)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
new_mtu = max_mtu;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
dev->mtu = new_mtu;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
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 00:05:58 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__ip_tunnel_change_mtu);
|
|
|
|
|
|
|
|
|
|
int ip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
|
{
|
|
|
|
|
return __ip_tunnel_change_mtu(dev, new_mtu, true);
|
|
|
|
|
}
|
2013-03-25 14:49:35 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_change_mtu);
|
|
|
|
|
|
|
|
|
|
static void ip_tunnel_dev_free(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
gro_cells_destroy(&tunnel->gro_cells);
|
2016-02-12 14:43:55 +00:00
|
|
|
dst_cache_destroy(&tunnel->dst_cache);
|
2013-03-25 14:49:35 +00:00
|
|
|
free_percpu(dev->tstats);
|
|
|
|
|
free_netdev(dev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ip_tunnel_dellink(struct net_device *dev, struct list_head *head)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
struct ip_tunnel_net *itn;
|
|
|
|
|
|
2013-08-13 15:51:11 +00:00
|
|
|
itn = net_generic(tunnel->net, tunnel->ip_tnl_net_id);
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
if (itn->fb_tunnel_dev != dev) {
|
2015-08-08 06:51:42 +00:00
|
|
|
ip_tunnel_del(itn, netdev_priv(dev));
|
2013-03-25 14:49:35 +00:00
|
|
|
unregister_netdevice_queue(dev, head);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_dellink);
|
|
|
|
|
|
2015-01-15 14:11:17 +00:00
|
|
|
struct net *ip_tunnel_get_link_net(const struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
return tunnel->net;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(ip_tunnel_get_link_net);
|
|
|
|
|
|
2015-04-02 15:07:02 +00:00
|
|
|
int ip_tunnel_get_iflink(const struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
return tunnel->parms.link;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(ip_tunnel_get_iflink);
|
|
|
|
|
|
2013-06-07 20:26:05 +00:00
|
|
|
int ip_tunnel_init_net(struct net *net, int ip_tnl_net_id,
|
2013-03-25 14:49:35 +00:00
|
|
|
struct rtnl_link_ops *ops, char *devname)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel_net *itn = net_generic(net, ip_tnl_net_id);
|
|
|
|
|
struct ip_tunnel_parm parms;
|
2013-08-06 05:51:37 +00:00
|
|
|
unsigned int i;
|
2013-03-25 14:49:35 +00:00
|
|
|
|
2013-08-06 05:51:37 +00:00
|
|
|
for (i = 0; i < IP_TNL_HASH_SIZE; i++)
|
|
|
|
|
INIT_HLIST_HEAD(&itn->tunnels[i]);
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
if (!ops) {
|
|
|
|
|
itn->fb_tunnel_dev = NULL;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2013-08-06 05:51:37 +00:00
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
memset(&parms, 0, sizeof(parms));
|
|
|
|
|
if (devname)
|
|
|
|
|
strlcpy(parms.name, devname, IFNAMSIZ);
|
|
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
itn->fb_tunnel_dev = __ip_tunnel_create(net, ops, &parms);
|
2013-08-19 07:05:10 +00:00
|
|
|
/* FB netdevice is special: we have one, and only one per netns.
|
|
|
|
|
* Allowing to move it to another netns is clearly unsafe.
|
|
|
|
|
*/
|
2013-10-01 09:34:48 +00:00
|
|
|
if (!IS_ERR(itn->fb_tunnel_dev)) {
|
2013-08-23 08:15:37 +00:00
|
|
|
itn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
|
2014-05-19 09:36:56 +00:00
|
|
|
itn->fb_tunnel_dev->mtu = ip_tunnel_bind_dev(itn->fb_tunnel_dev);
|
2013-10-01 09:34:48 +00:00
|
|
|
ip_tunnel_add(itn, netdev_priv(itn->fb_tunnel_dev));
|
|
|
|
|
}
|
2013-08-23 08:15:37 +00:00
|
|
|
rtnl_unlock();
|
2013-03-25 14:49:35 +00:00
|
|
|
|
2014-01-27 06:43:57 +00:00
|
|
|
return PTR_ERR_OR_ZERO(itn->fb_tunnel_dev);
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_init_net);
|
|
|
|
|
|
2013-08-13 15:51:11 +00:00
|
|
|
static void ip_tunnel_destroy(struct ip_tunnel_net *itn, struct list_head *head,
|
|
|
|
|
struct rtnl_link_ops *ops)
|
2013-03-25 14:49:35 +00:00
|
|
|
{
|
2013-08-13 15:51:11 +00:00
|
|
|
struct net *net = dev_net(itn->fb_tunnel_dev);
|
|
|
|
|
struct net_device *dev, *aux;
|
2013-03-25 14:49:35 +00:00
|
|
|
int h;
|
|
|
|
|
|
2013-08-13 15:51:11 +00:00
|
|
|
for_each_netdev_safe(net, dev, aux)
|
|
|
|
|
if (dev->rtnl_link_ops == ops)
|
|
|
|
|
unregister_netdevice_queue(dev, head);
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
for (h = 0; h < IP_TNL_HASH_SIZE; h++) {
|
|
|
|
|
struct ip_tunnel *t;
|
|
|
|
|
struct hlist_node *n;
|
|
|
|
|
struct hlist_head *thead = &itn->tunnels[h];
|
|
|
|
|
|
|
|
|
|
hlist_for_each_entry_safe(t, n, thead, hash_node)
|
2013-08-13 15:51:11 +00:00
|
|
|
/* If dev is in the same netns, it has already
|
|
|
|
|
* been added to the list by the previous loop.
|
|
|
|
|
*/
|
|
|
|
|
if (!net_eq(dev_net(t->dev), net))
|
|
|
|
|
unregister_netdevice_queue(t->dev, head);
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-13 15:51:11 +00:00
|
|
|
void ip_tunnel_delete_net(struct ip_tunnel_net *itn, struct rtnl_link_ops *ops)
|
2013-03-25 14:49:35 +00:00
|
|
|
{
|
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
|
|
rtnl_lock();
|
2013-08-13 15:51:11 +00:00
|
|
|
ip_tunnel_destroy(itn, &list, ops);
|
2013-03-25 14:49:35 +00:00
|
|
|
unregister_netdevice_many(&list);
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_delete_net);
|
|
|
|
|
|
|
|
|
|
int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[],
|
|
|
|
|
struct ip_tunnel_parm *p)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *nt;
|
|
|
|
|
struct net *net = dev_net(dev);
|
|
|
|
|
struct ip_tunnel_net *itn;
|
|
|
|
|
int mtu;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
nt = netdev_priv(dev);
|
|
|
|
|
itn = net_generic(net, nt->ip_tnl_net_id);
|
|
|
|
|
|
2015-08-08 06:51:42 +00:00
|
|
|
if (nt->collect_md) {
|
|
|
|
|
if (rtnl_dereference(itn->collect_md_tun))
|
|
|
|
|
return -EEXIST;
|
|
|
|
|
} else {
|
|
|
|
|
if (ip_tunnel_find(itn, p, dev->type))
|
|
|
|
|
return -EEXIST;
|
|
|
|
|
}
|
2013-03-25 14:49:35 +00:00
|
|
|
|
2013-06-26 14:11:28 +00:00
|
|
|
nt->net = net;
|
2013-03-25 14:49:35 +00:00
|
|
|
nt->parms = *p;
|
|
|
|
|
err = register_netdevice(dev);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
|
|
|
|
|
eth_hw_addr_random(dev);
|
|
|
|
|
|
|
|
|
|
mtu = ip_tunnel_bind_dev(dev);
|
|
|
|
|
if (!tb[IFLA_MTU])
|
|
|
|
|
dev->mtu = mtu;
|
|
|
|
|
|
|
|
|
|
ip_tunnel_add(itn, nt);
|
|
|
|
|
out:
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_newlink);
|
|
|
|
|
|
|
|
|
|
int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
|
|
|
|
|
struct ip_tunnel_parm *p)
|
|
|
|
|
{
|
2013-08-13 15:51:11 +00:00
|
|
|
struct ip_tunnel *t;
|
2013-03-25 14:49:35 +00:00
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
2013-08-13 15:51:11 +00:00
|
|
|
struct net *net = tunnel->net;
|
2013-03-25 14:49:35 +00:00
|
|
|
struct ip_tunnel_net *itn = net_generic(net, tunnel->ip_tnl_net_id);
|
|
|
|
|
|
|
|
|
|
if (dev == itn->fb_tunnel_dev)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
t = ip_tunnel_find(itn, p, dev->type);
|
|
|
|
|
|
|
|
|
|
if (t) {
|
|
|
|
|
if (t->dev != dev)
|
|
|
|
|
return -EEXIST;
|
|
|
|
|
} else {
|
2013-08-13 15:51:11 +00:00
|
|
|
t = tunnel;
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
if (dev->type != ARPHRD_ETHER) {
|
|
|
|
|
unsigned int nflags = 0;
|
|
|
|
|
|
|
|
|
|
if (ipv4_is_multicast(p->iph.daddr))
|
|
|
|
|
nflags = IFF_BROADCAST;
|
|
|
|
|
else if (p->iph.daddr)
|
|
|
|
|
nflags = IFF_POINTOPOINT;
|
|
|
|
|
|
|
|
|
|
if ((dev->flags ^ nflags) &
|
|
|
|
|
(IFF_POINTOPOINT | IFF_BROADCAST))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ip_tunnel_update(itn, t, dev, p, !tb[IFLA_MTU]);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_changelink);
|
|
|
|
|
|
|
|
|
|
int ip_tunnel_init(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
struct iphdr *iph = &tunnel->parms.iph;
|
2014-02-13 19:46:28 +00:00
|
|
|
int err;
|
2013-03-25 14:49:35 +00:00
|
|
|
|
|
|
|
|
dev->destructor = ip_tunnel_dev_free;
|
2014-02-13 19:46:28 +00:00
|
|
|
dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
|
2013-03-25 14:49:35 +00:00
|
|
|
if (!dev->tstats)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2016-02-12 14:43:55 +00:00
|
|
|
err = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL);
|
|
|
|
|
if (err) {
|
2014-01-02 19:48:33 +00:00
|
|
|
free_percpu(dev->tstats);
|
2016-02-12 14:43:55 +00:00
|
|
|
return err;
|
2014-01-02 19:48:33 +00:00
|
|
|
}
|
|
|
|
|
|
2013-03-25 14:49:35 +00:00
|
|
|
err = gro_cells_init(&tunnel->gro_cells, dev);
|
|
|
|
|
if (err) {
|
2016-02-12 14:43:55 +00:00
|
|
|
dst_cache_destroy(&tunnel->dst_cache);
|
2013-03-25 14:49:35 +00:00
|
|
|
free_percpu(dev->tstats);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tunnel->dev = dev;
|
2013-08-13 15:51:11 +00:00
|
|
|
tunnel->net = dev_net(dev);
|
2013-03-25 14:49:35 +00:00
|
|
|
strcpy(tunnel->parms.name, dev->name);
|
|
|
|
|
iph->version = 4;
|
|
|
|
|
iph->ihl = 5;
|
|
|
|
|
|
2015-08-08 06:51:42 +00:00
|
|
|
if (tunnel->collect_md) {
|
|
|
|
|
dev->features |= NETIF_F_NETNS_LOCAL;
|
|
|
|
|
netif_keep_dst(dev);
|
|
|
|
|
}
|
2013-03-25 14:49:35 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_init);
|
|
|
|
|
|
|
|
|
|
void ip_tunnel_uninit(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
2013-08-13 15:51:11 +00:00
|
|
|
struct net *net = tunnel->net;
|
2013-03-25 14:49:35 +00:00
|
|
|
struct ip_tunnel_net *itn;
|
|
|
|
|
|
|
|
|
|
itn = net_generic(net, tunnel->ip_tnl_net_id);
|
|
|
|
|
/* fb_tunnel_dev will be unregisted in net-exit call. */
|
|
|
|
|
if (itn->fb_tunnel_dev != dev)
|
2015-08-08 06:51:42 +00:00
|
|
|
ip_tunnel_del(itn, netdev_priv(dev));
|
2014-01-02 19:48:26 +00:00
|
|
|
|
2016-02-12 14:43:55 +00:00
|
|
|
dst_cache_reset(&tunnel->dst_cache);
|
2013-03-25 14:49:35 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_uninit);
|
|
|
|
|
|
|
|
|
|
/* Do least required initialization, rest of init is done in tunnel_init call */
|
|
|
|
|
void ip_tunnel_setup(struct net_device *dev, int net_id)
|
|
|
|
|
{
|
|
|
|
|
struct ip_tunnel *tunnel = netdev_priv(dev);
|
|
|
|
|
tunnel->ip_tnl_net_id = net_id;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(ip_tunnel_setup);
|
|
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
