blob: ef45c3c925be19c008f10cc8ba97abb7a36b2baf [file] [log] [blame]
stephen hemmingerd3428942012-10-01 12:32:35 +00001/*
Rami Roseneb5ce432012-11-13 13:29:15 +00002 * VXLAN: Virtual eXtensible Local Area Network
stephen hemmingerd3428942012-10-01 12:32:35 +00003 *
stephen hemminger3b8df3c2013-04-27 11:31:52 +00004 * Copyright (c) 2012-2013 Vyatta Inc.
stephen hemmingerd3428942012-10-01 12:32:35 +00005 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
stephen hemmingerd3428942012-10-01 12:32:35 +00009 */
10
11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
13#include <linux/kernel.h>
stephen hemmingerd3428942012-10-01 12:32:35 +000014#include <linux/module.h>
15#include <linux/errno.h>
16#include <linux/slab.h>
stephen hemmingerd3428942012-10-01 12:32:35 +000017#include <linux/udp.h>
18#include <linux/igmp.h>
stephen hemmingerd3428942012-10-01 12:32:35 +000019#include <linux/if_ether.h>
Yan Burman1b13c972013-01-29 23:43:07 +000020#include <linux/ethtool.h>
David Stevense4f67ad2012-11-20 02:50:14 +000021#include <net/arp.h>
22#include <net/ndisc.h>
stephen hemmingerd3428942012-10-01 12:32:35 +000023#include <net/ip.h>
24#include <net/icmp.h>
stephen hemmingerd3428942012-10-01 12:32:35 +000025#include <net/rtnetlink.h>
stephen hemmingerd3428942012-10-01 12:32:35 +000026#include <net/inet_ecn.h>
27#include <net/net_namespace.h>
28#include <net/netns/generic.h>
Jiri Bencfa20e0e2017-08-28 21:43:22 +020029#include <net/tun_proto.h>
Pravin B Shelar012a5722013-08-19 11:23:07 -070030#include <net/vxlan.h>
stephen hemminger40d29af2016-02-09 22:07:29 -080031
Cong Wange4c7ed42013-08-31 13:44:33 +080032#if IS_ENABLED(CONFIG_IPV6)
Cong Wange4c7ed42013-08-31 13:44:33 +080033#include <net/ip6_tunnel.h>
Cong Wang660d98c2013-09-02 10:06:52 +080034#include <net/ip6_checksum.h>
Cong Wange4c7ed42013-08-31 13:44:33 +080035#endif
stephen hemmingerd3428942012-10-01 12:32:35 +000036
37#define VXLAN_VERSION "0.1"
38
stephen hemminger553675f2013-05-16 11:35:20 +000039#define PORT_HASH_BITS 8
40#define PORT_HASH_SIZE (1<<PORT_HASH_BITS)
stephen hemmingerd3428942012-10-01 12:32:35 +000041#define FDB_AGE_DEFAULT 300 /* 5 min */
42#define FDB_AGE_INTERVAL (10 * HZ) /* rescan interval */
43
stephen hemminger23c578b2013-04-27 11:31:53 +000044/* UDP port for VXLAN traffic.
45 * The IANA assigned port is 4789, but the Linux default is 8472
Stephen Hemminger234f5b72013-06-17 14:16:41 -070046 * for compatibility with early adopters.
stephen hemminger23c578b2013-04-27 11:31:53 +000047 */
Stephen Hemminger9daaa392013-06-17 14:16:12 -070048static unsigned short vxlan_port __read_mostly = 8472;
49module_param_named(udp_port, vxlan_port, ushort, 0444);
stephen hemmingerd3428942012-10-01 12:32:35 +000050MODULE_PARM_DESC(udp_port, "Destination UDP port");
51
52static bool log_ecn_error = true;
53module_param(log_ecn_error, bool, 0644);
54MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
55
Alexey Dobriyanc7d03a02016-11-17 04:58:21 +030056static unsigned int vxlan_net_id;
Thomas Graf0dfbdf42015-07-21 10:44:02 +020057static struct rtnl_link_ops vxlan_link_ops;
stephen hemminger553675f2013-05-16 11:35:20 +000058
Li RongQing7256eac2016-01-29 09:43:47 +080059static const u8 all_zeros_mac[ETH_ALEN + 2];
Mike Rapoportafbd8ba2013-06-25 16:01:51 +030060
Jiri Benc205f3562015-09-24 13:50:01 +020061static int vxlan_sock_add(struct vxlan_dev *vxlan);
Thomas Graf614732e2015-07-21 10:44:06 +020062
Mark Blocha53cb292017-06-02 03:24:08 +030063static void vxlan_vs_del_dev(struct vxlan_dev *vxlan);
64
stephen hemminger553675f2013-05-16 11:35:20 +000065/* per-network namespace private data for this module */
66struct vxlan_net {
67 struct list_head vxlan_list;
68 struct hlist_head sock_list[PORT_HASH_SIZE];
Stephen Hemminger1c51a912013-06-17 14:16:11 -070069 spinlock_t sock_lock;
stephen hemminger553675f2013-05-16 11:35:20 +000070};
71
stephen hemmingerd3428942012-10-01 12:32:35 +000072/* Forwarding table entry */
73struct vxlan_fdb {
74 struct hlist_node hlist; /* linked list of entries */
75 struct rcu_head rcu;
76 unsigned long updated; /* jiffies */
77 unsigned long used;
Stephen Hemminger3e61aa82013-06-17 14:16:12 -070078 struct list_head remotes;
Sowmini Varadhan7177a3b2015-07-20 09:54:50 +020079 u8 eth_addr[ETH_ALEN];
stephen hemmingerd3428942012-10-01 12:32:35 +000080 u16 state; /* see ndm_state */
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -080081 __be32 vni;
Petr Machata45598c12018-11-21 08:02:36 +000082 u16 flags; /* see ndm_flags and below */
stephen hemmingerd3428942012-10-01 12:32:35 +000083};
84
Petr Machata45598c12018-11-21 08:02:36 +000085#define NTF_VXLAN_ADDED_BY_USER 0x100
86
stephen hemmingerd3428942012-10-01 12:32:35 +000087/* salt for hash table */
88static u32 vxlan_salt __read_mostly;
89
Thomas Grafee122c72015-07-21 10:43:58 +020090static inline bool vxlan_collect_metadata(struct vxlan_sock *vs)
91{
Thomas Grafe7030872015-07-21 10:44:01 +020092 return vs->flags & VXLAN_F_COLLECT_METADATA ||
93 ip_tunnel_collect_metadata();
Thomas Grafee122c72015-07-21 10:43:58 +020094}
95
Cong Wange4c7ed42013-08-31 13:44:33 +080096#if IS_ENABLED(CONFIG_IPV6)
97static inline
98bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
99{
Jiri Bencf0ef3122015-03-29 16:17:37 +0200100 if (a->sa.sa_family != b->sa.sa_family)
101 return false;
102 if (a->sa.sa_family == AF_INET6)
103 return ipv6_addr_equal(&a->sin6.sin6_addr, &b->sin6.sin6_addr);
104 else
105 return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
Cong Wange4c7ed42013-08-31 13:44:33 +0800106}
107
Cong Wange4c7ed42013-08-31 13:44:33 +0800108static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
109{
Jiri Bencf0ef3122015-03-29 16:17:37 +0200110 if (nla_len(nla) >= sizeof(struct in6_addr)) {
Jiri Benc67b61f62015-03-29 16:59:26 +0200111 ip->sin6.sin6_addr = nla_get_in6_addr(nla);
Jiri Bencf0ef3122015-03-29 16:17:37 +0200112 ip->sa.sa_family = AF_INET6;
113 return 0;
114 } else if (nla_len(nla) >= sizeof(__be32)) {
Jiri Benc67b61f62015-03-29 16:59:26 +0200115 ip->sin.sin_addr.s_addr = nla_get_in_addr(nla);
Jiri Bencf0ef3122015-03-29 16:17:37 +0200116 ip->sa.sa_family = AF_INET;
117 return 0;
118 } else {
119 return -EAFNOSUPPORT;
120 }
Cong Wange4c7ed42013-08-31 13:44:33 +0800121}
122
123static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
Jiri Bencf0ef3122015-03-29 16:17:37 +0200124 const union vxlan_addr *ip)
Cong Wange4c7ed42013-08-31 13:44:33 +0800125{
Jiri Bencf0ef3122015-03-29 16:17:37 +0200126 if (ip->sa.sa_family == AF_INET6)
Jiri Benc930345e2015-03-29 16:59:25 +0200127 return nla_put_in6_addr(skb, attr, &ip->sin6.sin6_addr);
Jiri Bencf0ef3122015-03-29 16:17:37 +0200128 else
Jiri Benc930345e2015-03-29 16:59:25 +0200129 return nla_put_in_addr(skb, attr, ip->sin.sin_addr.s_addr);
Cong Wange4c7ed42013-08-31 13:44:33 +0800130}
131
132#else /* !CONFIG_IPV6 */
133
134static inline
135bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
136{
Jiri Bencf0ef3122015-03-29 16:17:37 +0200137 return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
Cong Wange4c7ed42013-08-31 13:44:33 +0800138}
139
Cong Wange4c7ed42013-08-31 13:44:33 +0800140static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
141{
Jiri Bencf0ef3122015-03-29 16:17:37 +0200142 if (nla_len(nla) >= sizeof(struct in6_addr)) {
143 return -EAFNOSUPPORT;
144 } else if (nla_len(nla) >= sizeof(__be32)) {
Jiri Benc67b61f62015-03-29 16:59:26 +0200145 ip->sin.sin_addr.s_addr = nla_get_in_addr(nla);
Jiri Bencf0ef3122015-03-29 16:17:37 +0200146 ip->sa.sa_family = AF_INET;
147 return 0;
148 } else {
149 return -EAFNOSUPPORT;
150 }
Cong Wange4c7ed42013-08-31 13:44:33 +0800151}
152
153static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
Jiri Bencf0ef3122015-03-29 16:17:37 +0200154 const union vxlan_addr *ip)
Cong Wange4c7ed42013-08-31 13:44:33 +0800155{
Jiri Benc930345e2015-03-29 16:59:25 +0200156 return nla_put_in_addr(skb, attr, ip->sin.sin_addr.s_addr);
Cong Wange4c7ed42013-08-31 13:44:33 +0800157}
158#endif
159
stephen hemminger553675f2013-05-16 11:35:20 +0000160/* Virtual Network hash table head */
Jiri Benc54bfd872016-02-16 21:58:58 +0100161static inline struct hlist_head *vni_head(struct vxlan_sock *vs, __be32 vni)
stephen hemminger553675f2013-05-16 11:35:20 +0000162{
Jiri Benc54bfd872016-02-16 21:58:58 +0100163 return &vs->vni_list[hash_32((__force u32)vni, VNI_HASH_BITS)];
stephen hemminger553675f2013-05-16 11:35:20 +0000164}
165
166/* Socket hash table head */
167static inline struct hlist_head *vs_head(struct net *net, __be16 port)
stephen hemmingerd3428942012-10-01 12:32:35 +0000168{
169 struct vxlan_net *vn = net_generic(net, vxlan_net_id);
170
stephen hemminger553675f2013-05-16 11:35:20 +0000171 return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
172}
173
Stephen Hemminger3e61aa82013-06-17 14:16:12 -0700174/* First remote destination for a forwarding entry.
175 * Guaranteed to be non-NULL because remotes are never deleted.
176 */
stephen hemminger5ca54612013-08-04 17:17:39 -0700177static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)
Stephen Hemminger3e61aa82013-06-17 14:16:12 -0700178{
stephen hemminger5ca54612013-08-04 17:17:39 -0700179 return list_entry_rcu(fdb->remotes.next, struct vxlan_rdst, list);
180}
181
182static inline struct vxlan_rdst *first_remote_rtnl(struct vxlan_fdb *fdb)
183{
184 return list_first_entry(&fdb->remotes, struct vxlan_rdst, list);
Stephen Hemminger3e61aa82013-06-17 14:16:12 -0700185}
186
Thomas Grafac5132d2015-01-15 03:53:56 +0100187/* Find VXLAN socket based on network namespace, address family and UDP port
188 * and enabled unshareable flags.
189 */
190static struct vxlan_sock *vxlan_find_sock(struct net *net, sa_family_t family,
Alexis Bauvinaab8cc32018-12-03 10:54:40 +0100191 __be16 port, u32 flags, int ifindex)
stephen hemminger553675f2013-05-16 11:35:20 +0000192{
193 struct vxlan_sock *vs;
Tom Herbertaf33c1a2015-01-20 11:23:05 -0800194
195 flags &= VXLAN_F_RCV_FLAGS;
stephen hemminger553675f2013-05-16 11:35:20 +0000196
197 hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
Marcelo Leitner19ca9fc2014-11-13 14:43:08 -0200198 if (inet_sk(vs->sock->sk)->inet_sport == port &&
Jiri Benc705cc622015-08-20 13:56:28 +0200199 vxlan_get_sk_family(vs) == family &&
Alexis Bauvinaab8cc32018-12-03 10:54:40 +0100200 vs->flags == flags &&
201 vs->sock->sk->sk_bound_dev_if == ifindex)
stephen hemminger553675f2013-05-16 11:35:20 +0000202 return vs;
203 }
204 return NULL;
stephen hemmingerd3428942012-10-01 12:32:35 +0000205}
206
Matthias Schiffer49f810f2017-06-19 10:04:00 +0200207static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, int ifindex,
208 __be32 vni)
stephen hemmingerd3428942012-10-01 12:32:35 +0000209{
Jiri Benc69e76662017-07-02 19:00:57 +0200210 struct vxlan_dev_node *node;
stephen hemmingerd3428942012-10-01 12:32:35 +0000211
Jiri Bencb9167b22016-02-16 21:59:03 +0100212 /* For flow based devices, map all packets to VNI 0 */
213 if (vs->flags & VXLAN_F_COLLECT_METADATA)
214 vni = 0;
215
Jiri Benc69e76662017-07-02 19:00:57 +0200216 hlist_for_each_entry_rcu(node, vni_head(vs, vni), hlist) {
217 if (node->vxlan->default_dst.remote_vni != vni)
Matthias Schiffer49f810f2017-06-19 10:04:00 +0200218 continue;
219
220 if (IS_ENABLED(CONFIG_IPV6)) {
Jiri Benc69e76662017-07-02 19:00:57 +0200221 const struct vxlan_config *cfg = &node->vxlan->cfg;
Matthias Schiffer49f810f2017-06-19 10:04:00 +0200222
223 if ((cfg->flags & VXLAN_F_IPV6_LINKLOCAL) &&
224 cfg->remote_ifindex != ifindex)
225 continue;
226 }
227
Jiri Benc69e76662017-07-02 19:00:57 +0200228 return node->vxlan;
stephen hemmingerd3428942012-10-01 12:32:35 +0000229 }
230
231 return NULL;
232}
233
Pravin B Shelar5cfccc52013-08-19 11:23:02 -0700234/* Look up VNI in a per net namespace table */
Matthias Schiffer49f810f2017-06-19 10:04:00 +0200235static struct vxlan_dev *vxlan_find_vni(struct net *net, int ifindex,
236 __be32 vni, sa_family_t family,
237 __be16 port, u32 flags)
Pravin B Shelar5cfccc52013-08-19 11:23:02 -0700238{
239 struct vxlan_sock *vs;
240
Alexis Bauvinaab8cc32018-12-03 10:54:40 +0100241 vs = vxlan_find_sock(net, family, port, flags, ifindex);
Pravin B Shelar5cfccc52013-08-19 11:23:02 -0700242 if (!vs)
243 return NULL;
244
Matthias Schiffer49f810f2017-06-19 10:04:00 +0200245 return vxlan_vs_find_vni(vs, ifindex, vni);
Pravin B Shelar5cfccc52013-08-19 11:23:02 -0700246}
247
stephen hemmingerd3428942012-10-01 12:32:35 +0000248/* Fill in neighbour message in skbuff. */
249static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
Stephen Hemminger234f5b72013-06-17 14:16:41 -0700250 const struct vxlan_fdb *fdb,
251 u32 portid, u32 seq, int type, unsigned int flags,
252 const struct vxlan_rdst *rdst)
stephen hemmingerd3428942012-10-01 12:32:35 +0000253{
254 unsigned long now = jiffies;
255 struct nda_cacheinfo ci;
256 struct nlmsghdr *nlh;
257 struct ndmsg *ndm;
David Stevense4f67ad2012-11-20 02:50:14 +0000258 bool send_ip, send_eth;
stephen hemmingerd3428942012-10-01 12:32:35 +0000259
260 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
261 if (nlh == NULL)
262 return -EMSGSIZE;
263
264 ndm = nlmsg_data(nlh);
265 memset(ndm, 0, sizeof(*ndm));
David Stevense4f67ad2012-11-20 02:50:14 +0000266
267 send_eth = send_ip = true;
268
269 if (type == RTM_GETNEIGH) {
Cong Wange4c7ed42013-08-31 13:44:33 +0800270 send_ip = !vxlan_addr_any(&rdst->remote_ip);
David Stevense4f67ad2012-11-20 02:50:14 +0000271 send_eth = !is_zero_ether_addr(fdb->eth_addr);
Vincent Bernat8f48ba72017-03-10 16:30:24 +0100272 ndm->ndm_family = send_ip ? rdst->remote_ip.sa.sa_family : AF_INET;
David Stevense4f67ad2012-11-20 02:50:14 +0000273 } else
274 ndm->ndm_family = AF_BRIDGE;
stephen hemmingerd3428942012-10-01 12:32:35 +0000275 ndm->ndm_state = fdb->state;
276 ndm->ndm_ifindex = vxlan->dev->ifindex;
David Stevensae884082013-04-19 00:36:26 +0000277 ndm->ndm_flags = fdb->flags;
Petr Machata0efe1172018-10-17 08:53:26 +0000278 if (rdst->offloaded)
279 ndm->ndm_flags |= NTF_OFFLOADED;
Jun Zhao545469f2014-07-26 00:38:59 +0800280 ndm->ndm_type = RTN_UNICAST;
stephen hemmingerd3428942012-10-01 12:32:35 +0000281
Nicolas Dichtel193523b2015-01-20 15:15:47 +0100282 if (!net_eq(dev_net(vxlan->dev), vxlan->net) &&
Nicolas Dichtel49670822015-01-26 14:10:53 +0100283 nla_put_s32(skb, NDA_LINK_NETNSID,
WANG Cong38f507f2016-09-01 21:53:44 -0700284 peernet2id(dev_net(vxlan->dev), vxlan->net)))
Nicolas Dichtel193523b2015-01-20 15:15:47 +0100285 goto nla_put_failure;
286
David Stevense4f67ad2012-11-20 02:50:14 +0000287 if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))
stephen hemmingerd3428942012-10-01 12:32:35 +0000288 goto nla_put_failure;
289
Cong Wange4c7ed42013-08-31 13:44:33 +0800290 if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))
David Stevens66817122013-03-15 04:35:51 +0000291 goto nla_put_failure;
292
Thomas Graf0dfbdf42015-07-21 10:44:02 +0200293 if (rdst->remote_port && rdst->remote_port != vxlan->cfg.dst_port &&
David Stevens66817122013-03-15 04:35:51 +0000294 nla_put_be16(skb, NDA_PORT, rdst->remote_port))
295 goto nla_put_failure;
Atzm Watanabec7995c42013-04-16 02:50:52 +0000296 if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
Jiri Benc54bfd872016-02-16 21:58:58 +0100297 nla_put_u32(skb, NDA_VNI, be32_to_cpu(rdst->remote_vni)))
David Stevens66817122013-03-15 04:35:51 +0000298 goto nla_put_failure;
Matthias Schifferdc5321d2017-06-19 10:03:56 +0200299 if ((vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) && fdb->vni &&
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800300 nla_put_u32(skb, NDA_SRC_VNI,
301 be32_to_cpu(fdb->vni)))
302 goto nla_put_failure;
David Stevens66817122013-03-15 04:35:51 +0000303 if (rdst->remote_ifindex &&
304 nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
stephen hemmingerd3428942012-10-01 12:32:35 +0000305 goto nla_put_failure;
306
307 ci.ndm_used = jiffies_to_clock_t(now - fdb->used);
308 ci.ndm_confirmed = 0;
309 ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated);
310 ci.ndm_refcnt = 0;
311
312 if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
313 goto nla_put_failure;
314
Johannes Berg053c0952015-01-16 22:09:00 +0100315 nlmsg_end(skb, nlh);
316 return 0;
stephen hemmingerd3428942012-10-01 12:32:35 +0000317
318nla_put_failure:
319 nlmsg_cancel(skb, nlh);
320 return -EMSGSIZE;
321}
322
323static inline size_t vxlan_nlmsg_size(void)
324{
325 return NLMSG_ALIGN(sizeof(struct ndmsg))
326 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
Cong Wange4c7ed42013-08-31 13:44:33 +0800327 + nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */
stephen hemminger73cf3312013-04-27 11:31:54 +0000328 + nla_total_size(sizeof(__be16)) /* NDA_PORT */
David Stevens66817122013-03-15 04:35:51 +0000329 + nla_total_size(sizeof(__be32)) /* NDA_VNI */
330 + nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
Nicolas Dichtel49670822015-01-26 14:10:53 +0100331 + nla_total_size(sizeof(__s32)) /* NDA_LINK_NETNSID */
stephen hemmingerd3428942012-10-01 12:32:35 +0000332 + nla_total_size(sizeof(struct nda_cacheinfo));
333}
334
Petr Machata9a997352018-10-17 08:53:22 +0000335static void __vxlan_fdb_notify(struct vxlan_dev *vxlan, struct vxlan_fdb *fdb,
336 struct vxlan_rdst *rd, int type)
stephen hemmingerd3428942012-10-01 12:32:35 +0000337{
338 struct net *net = dev_net(vxlan->dev);
339 struct sk_buff *skb;
340 int err = -ENOBUFS;
341
342 skb = nlmsg_new(vxlan_nlmsg_size(), GFP_ATOMIC);
343 if (skb == NULL)
344 goto errout;
345
Nicolas Dichtel9e4b93f2014-04-22 15:01:30 +0200346 err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0, rd);
stephen hemmingerd3428942012-10-01 12:32:35 +0000347 if (err < 0) {
348 /* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */
349 WARN_ON(err == -EMSGSIZE);
350 kfree_skb(skb);
351 goto errout;
352 }
353
354 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
355 return;
356errout:
357 if (err < 0)
358 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
359}
360
Petr Machataff23b912018-12-07 19:55:03 +0000361static void vxlan_fdb_switchdev_notifier_info(const struct vxlan_dev *vxlan,
362 const struct vxlan_fdb *fdb,
363 const struct vxlan_rdst *rd,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000364 struct netlink_ext_ack *extack,
Petr Machataff23b912018-12-07 19:55:03 +0000365 struct switchdev_notifier_vxlan_fdb_info *fdb_info)
366{
367 fdb_info->info.dev = vxlan->dev;
Petr Machata4c59b7d2019-01-16 23:06:54 +0000368 fdb_info->info.extack = extack;
Petr Machataff23b912018-12-07 19:55:03 +0000369 fdb_info->remote_ip = rd->remote_ip;
370 fdb_info->remote_port = rd->remote_port;
371 fdb_info->remote_vni = rd->remote_vni;
372 fdb_info->remote_ifindex = rd->remote_ifindex;
373 memcpy(fdb_info->eth_addr, fdb->eth_addr, ETH_ALEN);
374 fdb_info->vni = fdb->vni;
375 fdb_info->offloaded = rd->offloaded;
376 fdb_info->added_by_user = fdb->flags & NTF_VXLAN_ADDED_BY_USER;
377}
378
Petr Machata61f46fe2019-01-16 23:06:38 +0000379static int vxlan_fdb_switchdev_call_notifiers(struct vxlan_dev *vxlan,
380 struct vxlan_fdb *fdb,
381 struct vxlan_rdst *rd,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000382 bool adding,
383 struct netlink_ext_ack *extack)
Petr Machata9a997352018-10-17 08:53:22 +0000384{
385 struct switchdev_notifier_vxlan_fdb_info info;
386 enum switchdev_notifier_type notifier_type;
Petr Machata61f46fe2019-01-16 23:06:38 +0000387 int ret;
Petr Machata9a997352018-10-17 08:53:22 +0000388
389 if (WARN_ON(!rd))
Petr Machata61f46fe2019-01-16 23:06:38 +0000390 return 0;
Petr Machata9a997352018-10-17 08:53:22 +0000391
392 notifier_type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE
393 : SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE;
Petr Machata4c59b7d2019-01-16 23:06:54 +0000394 vxlan_fdb_switchdev_notifier_info(vxlan, fdb, rd, NULL, &info);
Petr Machata61f46fe2019-01-16 23:06:38 +0000395 ret = call_switchdev_notifiers(notifier_type, vxlan->dev,
Petr Machata66859872019-01-16 23:06:56 +0000396 &info.info, extack);
Petr Machata61f46fe2019-01-16 23:06:38 +0000397 return notifier_to_errno(ret);
Petr Machata9a997352018-10-17 08:53:22 +0000398}
399
Petr Machata61f46fe2019-01-16 23:06:38 +0000400static int vxlan_fdb_notify(struct vxlan_dev *vxlan, struct vxlan_fdb *fdb,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000401 struct vxlan_rdst *rd, int type, bool swdev_notify,
402 struct netlink_ext_ack *extack)
Petr Machata9a997352018-10-17 08:53:22 +0000403{
Petr Machata61f46fe2019-01-16 23:06:38 +0000404 int err;
405
Petr Machata0e6160f2018-11-21 08:02:35 +0000406 if (swdev_notify) {
407 switch (type) {
408 case RTM_NEWNEIGH:
Petr Machata61f46fe2019-01-16 23:06:38 +0000409 err = vxlan_fdb_switchdev_call_notifiers(vxlan, fdb, rd,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000410 true, extack);
Petr Machata61f46fe2019-01-16 23:06:38 +0000411 if (err)
412 return err;
Petr Machata0e6160f2018-11-21 08:02:35 +0000413 break;
414 case RTM_DELNEIGH:
415 vxlan_fdb_switchdev_call_notifiers(vxlan, fdb, rd,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000416 false, extack);
Petr Machata0e6160f2018-11-21 08:02:35 +0000417 break;
418 }
Petr Machata9a997352018-10-17 08:53:22 +0000419 }
420
421 __vxlan_fdb_notify(vxlan, fdb, rd, type);
Petr Machata61f46fe2019-01-16 23:06:38 +0000422 return 0;
Petr Machata9a997352018-10-17 08:53:22 +0000423}
424
Cong Wange4c7ed42013-08-31 13:44:33 +0800425static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)
David Stevense4f67ad2012-11-20 02:50:14 +0000426{
427 struct vxlan_dev *vxlan = netdev_priv(dev);
Stephen Hemmingerbb3fd682013-06-17 14:16:40 -0700428 struct vxlan_fdb f = {
429 .state = NUD_STALE,
430 };
431 struct vxlan_rdst remote = {
Cong Wange4c7ed42013-08-31 13:44:33 +0800432 .remote_ip = *ipa, /* goes to NDA_DST */
Jiri Benc54bfd872016-02-16 21:58:58 +0100433 .remote_vni = cpu_to_be32(VXLAN_N_VID),
Stephen Hemmingerbb3fd682013-06-17 14:16:40 -0700434 };
Stephen Hemminger3e61aa82013-06-17 14:16:12 -0700435
Petr Machata4c59b7d2019-01-16 23:06:54 +0000436 vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH, true, NULL);
David Stevense4f67ad2012-11-20 02:50:14 +0000437}
438
439static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
440{
Stephen Hemmingerbb3fd682013-06-17 14:16:40 -0700441 struct vxlan_fdb f = {
442 .state = NUD_STALE,
443 };
Nicolas Dichtel9e4b93f2014-04-22 15:01:30 +0200444 struct vxlan_rdst remote = { };
David Stevense4f67ad2012-11-20 02:50:14 +0000445
David Stevense4f67ad2012-11-20 02:50:14 +0000446 memcpy(f.eth_addr, eth_addr, ETH_ALEN);
447
Petr Machata4c59b7d2019-01-16 23:06:54 +0000448 vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH, true, NULL);
David Stevense4f67ad2012-11-20 02:50:14 +0000449}
450
stephen hemmingerd3428942012-10-01 12:32:35 +0000451/* Hash Ethernet address */
452static u32 eth_hash(const unsigned char *addr)
453{
454 u64 value = get_unaligned((u64 *)addr);
455
456 /* only want 6 bytes */
457#ifdef __BIG_ENDIAN
stephen hemmingerd3428942012-10-01 12:32:35 +0000458 value >>= 16;
stephen hemminger321fb992012-10-09 20:35:47 +0000459#else
460 value <<= 16;
stephen hemmingerd3428942012-10-01 12:32:35 +0000461#endif
462 return hash_64(value, FDB_HASH_BITS);
463}
464
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800465static u32 eth_vni_hash(const unsigned char *addr, __be32 vni)
466{
467 /* use 1 byte of OUI and 3 bytes of NIC */
468 u32 key = get_unaligned((u32 *)(addr + 2));
469
470 return jhash_2words(key, vni, vxlan_salt) & (FDB_HASH_SIZE - 1);
471}
472
stephen hemmingerd3428942012-10-01 12:32:35 +0000473/* Hash chain to use given mac address */
474static inline struct hlist_head *vxlan_fdb_head(struct vxlan_dev *vxlan,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800475 const u8 *mac, __be32 vni)
stephen hemmingerd3428942012-10-01 12:32:35 +0000476{
Matthias Schifferdc5321d2017-06-19 10:03:56 +0200477 if (vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA)
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800478 return &vxlan->fdb_head[eth_vni_hash(mac, vni)];
479 else
480 return &vxlan->fdb_head[eth_hash(mac)];
stephen hemmingerd3428942012-10-01 12:32:35 +0000481}
482
483/* Look up Ethernet address in forwarding table */
Sridhar Samudrala014be2c2013-05-17 06:39:07 +0000484static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800485 const u8 *mac, __be32 vni)
stephen hemmingerd3428942012-10-01 12:32:35 +0000486{
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800487 struct hlist_head *head = vxlan_fdb_head(vxlan, mac, vni);
stephen hemmingerd3428942012-10-01 12:32:35 +0000488 struct vxlan_fdb *f;
stephen hemmingerd3428942012-10-01 12:32:35 +0000489
Sasha Levinb67bfe02013-02-27 17:06:00 -0800490 hlist_for_each_entry_rcu(f, head, hlist) {
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800491 if (ether_addr_equal(mac, f->eth_addr)) {
Matthias Schifferdc5321d2017-06-19 10:03:56 +0200492 if (vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) {
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800493 if (vni == f->vni)
494 return f;
495 } else {
496 return f;
497 }
498 }
stephen hemmingerd3428942012-10-01 12:32:35 +0000499 }
500
501 return NULL;
502}
503
Sridhar Samudrala014be2c2013-05-17 06:39:07 +0000504static struct vxlan_fdb *vxlan_find_mac(struct vxlan_dev *vxlan,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800505 const u8 *mac, __be32 vni)
Sridhar Samudrala014be2c2013-05-17 06:39:07 +0000506{
507 struct vxlan_fdb *f;
508
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800509 f = __vxlan_find_mac(vxlan, mac, vni);
Li RongQing016f3d12018-08-29 11:52:10 +0800510 if (f && f->used != jiffies)
Sridhar Samudrala014be2c2013-05-17 06:39:07 +0000511 f->used = jiffies;
512
513 return f;
514}
515
Mike Rapoporta5e7c102013-06-25 16:01:52 +0300516/* caller should hold vxlan->hash_lock */
517static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,
Cong Wange4c7ed42013-08-31 13:44:33 +0800518 union vxlan_addr *ip, __be16 port,
Jiri Benc54bfd872016-02-16 21:58:58 +0100519 __be32 vni, __u32 ifindex)
Mike Rapoporta5e7c102013-06-25 16:01:52 +0300520{
521 struct vxlan_rdst *rd;
522
523 list_for_each_entry(rd, &f->remotes, list) {
Cong Wange4c7ed42013-08-31 13:44:33 +0800524 if (vxlan_addr_equal(&rd->remote_ip, ip) &&
Mike Rapoporta5e7c102013-06-25 16:01:52 +0300525 rd->remote_port == port &&
526 rd->remote_vni == vni &&
527 rd->remote_ifindex == ifindex)
528 return rd;
529 }
530
531 return NULL;
532}
533
Petr Machata1941f1d2018-10-17 08:53:24 +0000534int vxlan_fdb_find_uc(struct net_device *dev, const u8 *mac, __be32 vni,
535 struct switchdev_notifier_vxlan_fdb_info *fdb_info)
536{
537 struct vxlan_dev *vxlan = netdev_priv(dev);
538 u8 eth_addr[ETH_ALEN + 2] = { 0 };
539 struct vxlan_rdst *rdst;
540 struct vxlan_fdb *f;
541 int rc = 0;
542
543 if (is_multicast_ether_addr(mac) ||
544 is_zero_ether_addr(mac))
545 return -EINVAL;
546
547 ether_addr_copy(eth_addr, mac);
548
549 rcu_read_lock();
550
551 f = __vxlan_find_mac(vxlan, eth_addr, vni);
552 if (!f) {
553 rc = -ENOENT;
554 goto out;
555 }
556
557 rdst = first_remote_rcu(f);
Petr Machata4c59b7d2019-01-16 23:06:54 +0000558 vxlan_fdb_switchdev_notifier_info(vxlan, f, rdst, NULL, fdb_info);
Petr Machata1941f1d2018-10-17 08:53:24 +0000559
560out:
561 rcu_read_unlock();
562 return rc;
563}
564EXPORT_SYMBOL_GPL(vxlan_fdb_find_uc);
565
Petr Machata4f89f5b2018-12-07 19:55:04 +0000566static int vxlan_fdb_notify_one(struct notifier_block *nb,
567 const struct vxlan_dev *vxlan,
568 const struct vxlan_fdb *f,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000569 const struct vxlan_rdst *rdst,
570 struct netlink_ext_ack *extack)
Petr Machata4f89f5b2018-12-07 19:55:04 +0000571{
572 struct switchdev_notifier_vxlan_fdb_info fdb_info;
573 int rc;
574
Petr Machata4c59b7d2019-01-16 23:06:54 +0000575 vxlan_fdb_switchdev_notifier_info(vxlan, f, rdst, extack, &fdb_info);
Petr Machata4f89f5b2018-12-07 19:55:04 +0000576 rc = nb->notifier_call(nb, SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE,
577 &fdb_info);
578 return notifier_to_errno(rc);
579}
580
581int vxlan_fdb_replay(const struct net_device *dev, __be32 vni,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000582 struct notifier_block *nb,
583 struct netlink_ext_ack *extack)
Petr Machata4f89f5b2018-12-07 19:55:04 +0000584{
585 struct vxlan_dev *vxlan;
586 struct vxlan_rdst *rdst;
587 struct vxlan_fdb *f;
588 unsigned int h;
589 int rc = 0;
590
591 if (!netif_is_vxlan(dev))
592 return -EINVAL;
593 vxlan = netdev_priv(dev);
594
595 spin_lock_bh(&vxlan->hash_lock);
596 for (h = 0; h < FDB_HASH_SIZE; ++h) {
597 hlist_for_each_entry(f, &vxlan->fdb_head[h], hlist) {
598 if (f->vni == vni) {
599 list_for_each_entry(rdst, &f->remotes, list) {
600 rc = vxlan_fdb_notify_one(nb, vxlan,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000601 f, rdst,
602 extack);
Petr Machata4f89f5b2018-12-07 19:55:04 +0000603 if (rc)
604 goto out;
605 }
606 }
607 }
608 }
609
610out:
611 spin_unlock_bh(&vxlan->hash_lock);
612 return rc;
613}
614EXPORT_SYMBOL_GPL(vxlan_fdb_replay);
615
Petr Machatae5ff4b12018-12-07 19:55:06 +0000616void vxlan_fdb_clear_offload(const struct net_device *dev, __be32 vni)
617{
618 struct vxlan_dev *vxlan;
619 struct vxlan_rdst *rdst;
620 struct vxlan_fdb *f;
621 unsigned int h;
622
623 if (!netif_is_vxlan(dev))
624 return;
625 vxlan = netdev_priv(dev);
626
627 spin_lock_bh(&vxlan->hash_lock);
628 for (h = 0; h < FDB_HASH_SIZE; ++h) {
629 hlist_for_each_entry(f, &vxlan->fdb_head[h], hlist)
630 if (f->vni == vni)
631 list_for_each_entry(rdst, &f->remotes, list)
632 rdst->offloaded = false;
633 }
634 spin_unlock_bh(&vxlan->hash_lock);
635}
636EXPORT_SYMBOL_GPL(vxlan_fdb_clear_offload);
637
Thomas Richter906dc182013-07-19 17:20:07 +0200638/* Replace destination of unicast mac */
639static int vxlan_fdb_replace(struct vxlan_fdb *f,
Jiri Benc54bfd872016-02-16 21:58:58 +0100640 union vxlan_addr *ip, __be16 port, __be32 vni,
Petr Machataccdfd4f2019-01-16 23:06:34 +0000641 __u32 ifindex, struct vxlan_rdst *oldrd)
Thomas Richter906dc182013-07-19 17:20:07 +0200642{
643 struct vxlan_rdst *rd;
644
645 rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
646 if (rd)
647 return 0;
648
649 rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);
650 if (!rd)
651 return 0;
Paolo Abeni0c1d70a2016-02-12 15:43:56 +0100652
Petr Machataccdfd4f2019-01-16 23:06:34 +0000653 *oldrd = *rd;
Paolo Abeni0c1d70a2016-02-12 15:43:56 +0100654 dst_cache_reset(&rd->dst_cache);
Cong Wange4c7ed42013-08-31 13:44:33 +0800655 rd->remote_ip = *ip;
Thomas Richter906dc182013-07-19 17:20:07 +0200656 rd->remote_port = port;
657 rd->remote_vni = vni;
658 rd->remote_ifindex = ifindex;
Petr Machata6ad0b5a2018-12-18 13:15:59 +0000659 rd->offloaded = false;
Thomas Richter906dc182013-07-19 17:20:07 +0200660 return 1;
661}
662
David Stevens66817122013-03-15 04:35:51 +0000663/* Add/update destinations for multicast */
664static int vxlan_fdb_append(struct vxlan_fdb *f,
Jiri Benc54bfd872016-02-16 21:58:58 +0100665 union vxlan_addr *ip, __be16 port, __be32 vni,
Nicolas Dichtel9e4b93f2014-04-22 15:01:30 +0200666 __u32 ifindex, struct vxlan_rdst **rdp)
David Stevens66817122013-03-15 04:35:51 +0000667{
Stephen Hemminger3e61aa82013-06-17 14:16:12 -0700668 struct vxlan_rdst *rd;
David Stevens66817122013-03-15 04:35:51 +0000669
Mike Rapoporta5e7c102013-06-25 16:01:52 +0300670 rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
671 if (rd)
672 return 0;
Stephen Hemminger3e61aa82013-06-17 14:16:12 -0700673
David Stevens66817122013-03-15 04:35:51 +0000674 rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
675 if (rd == NULL)
676 return -ENOBUFS;
Paolo Abeni0c1d70a2016-02-12 15:43:56 +0100677
678 if (dst_cache_init(&rd->dst_cache, GFP_ATOMIC)) {
679 kfree(rd);
680 return -ENOBUFS;
681 }
682
Cong Wange4c7ed42013-08-31 13:44:33 +0800683 rd->remote_ip = *ip;
David Stevens66817122013-03-15 04:35:51 +0000684 rd->remote_port = port;
Petr Machata0efe1172018-10-17 08:53:26 +0000685 rd->offloaded = false;
David Stevens66817122013-03-15 04:35:51 +0000686 rd->remote_vni = vni;
687 rd->remote_ifindex = ifindex;
Stephen Hemminger3e61aa82013-06-17 14:16:12 -0700688
689 list_add_tail_rcu(&rd->list, &f->remotes);
690
Nicolas Dichtel9e4b93f2014-04-22 15:01:30 +0200691 *rdp = rd;
David Stevens66817122013-03-15 04:35:51 +0000692 return 1;
693}
694
Tom Herbertdfd86452015-01-12 17:00:38 -0800695static struct vxlanhdr *vxlan_gro_remcsum(struct sk_buff *skb,
696 unsigned int off,
697 struct vxlanhdr *vh, size_t hdrlen,
Jiri Benc54bfd872016-02-16 21:58:58 +0100698 __be32 vni_field,
699 struct gro_remcsum *grc,
Tom Herbert0ace2ca2015-02-10 16:30:32 -0800700 bool nopartial)
Tom Herbertdfd86452015-01-12 17:00:38 -0800701{
Tom Herbertb7fe10e2015-08-19 17:07:32 -0700702 size_t start, offset;
Tom Herbertdfd86452015-01-12 17:00:38 -0800703
704 if (skb->remcsum_offload)
Tom Herbertb7fe10e2015-08-19 17:07:32 -0700705 return vh;
Tom Herbertdfd86452015-01-12 17:00:38 -0800706
707 if (!NAPI_GRO_CB(skb)->csum_valid)
708 return NULL;
709
Jiri Benc54bfd872016-02-16 21:58:58 +0100710 start = vxlan_rco_start(vni_field);
711 offset = start + vxlan_rco_offset(vni_field);
Tom Herbertdfd86452015-01-12 17:00:38 -0800712
Tom Herbertb7fe10e2015-08-19 17:07:32 -0700713 vh = skb_gro_remcsum_process(skb, (void *)vh, off, hdrlen,
714 start, offset, grc, nopartial);
Tom Herbertdfd86452015-01-12 17:00:38 -0800715
716 skb->remcsum_offload = 1;
717
718 return vh;
719}
720
David Millerd4546c22018-06-24 14:13:49 +0900721static struct sk_buff *vxlan_gro_receive(struct sock *sk,
722 struct list_head *head,
723 struct sk_buff *skb)
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200724{
David Millerd4546c22018-06-24 14:13:49 +0900725 struct sk_buff *pp = NULL;
726 struct sk_buff *p;
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200727 struct vxlanhdr *vh, *vh2;
Jesse Gross9b174d82014-12-30 19:10:15 -0800728 unsigned int hlen, off_vx;
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200729 int flush = 1;
Tom Herbert5602c482016-04-05 08:22:53 -0700730 struct vxlan_sock *vs = rcu_dereference_sk_user_data(sk);
Jiri Benc54bfd872016-02-16 21:58:58 +0100731 __be32 flags;
Tom Herbert26c4f7d2015-02-10 16:30:27 -0800732 struct gro_remcsum grc;
733
734 skb_gro_remcsum_init(&grc);
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200735
736 off_vx = skb_gro_offset(skb);
737 hlen = off_vx + sizeof(*vh);
738 vh = skb_gro_header_fast(skb, off_vx);
739 if (skb_gro_header_hard(skb, hlen)) {
740 vh = skb_gro_header_slow(skb, hlen, off_vx);
741 if (unlikely(!vh))
742 goto out;
743 }
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200744
Tom Herbertdfd86452015-01-12 17:00:38 -0800745 skb_gro_postpull_rcsum(skb, vh, sizeof(struct vxlanhdr));
746
Jiri Benc54bfd872016-02-16 21:58:58 +0100747 flags = vh->vx_flags;
Tom Herbertdfd86452015-01-12 17:00:38 -0800748
749 if ((flags & VXLAN_HF_RCO) && (vs->flags & VXLAN_F_REMCSUM_RX)) {
750 vh = vxlan_gro_remcsum(skb, off_vx, vh, sizeof(struct vxlanhdr),
Jiri Benc54bfd872016-02-16 21:58:58 +0100751 vh->vx_vni, &grc,
Tom Herbert0ace2ca2015-02-10 16:30:32 -0800752 !!(vs->flags &
753 VXLAN_F_REMCSUM_NOPARTIAL));
Tom Herbertdfd86452015-01-12 17:00:38 -0800754
755 if (!vh)
756 goto out;
757 }
758
Tom Herbertb7fe10e2015-08-19 17:07:32 -0700759 skb_gro_pull(skb, sizeof(struct vxlanhdr)); /* pull vxlan header */
760
David Millerd4546c22018-06-24 14:13:49 +0900761 list_for_each_entry(p, head, list) {
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200762 if (!NAPI_GRO_CB(p)->same_flow)
763 continue;
764
765 vh2 = (struct vxlanhdr *)(p->data + off_vx);
Thomas Graf35114942015-01-15 03:53:55 +0100766 if (vh->vx_flags != vh2->vx_flags ||
767 vh->vx_vni != vh2->vx_vni) {
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200768 NAPI_GRO_CB(p)->same_flow = 0;
769 continue;
770 }
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200771 }
772
Sabrina Dubrocafcd91dd2016-10-20 15:58:02 +0200773 pp = call_gro_receive(eth_gro_receive, head, skb);
Alexander Duyckc194cf92016-03-09 09:24:23 -0800774 flush = 0;
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200775
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200776out:
Sabrina Dubroca603d4cf2018-06-30 17:38:55 +0200777 skb_gro_flush_final_remcsum(skb, pp, flush, &grc);
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200778
779 return pp;
780}
781
Tom Herbert5602c482016-04-05 08:22:53 -0700782static int vxlan_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff)
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200783{
Jarno Rajahalme229740c2016-05-03 16:10:21 -0700784 /* Sets 'skb->inner_mac_header' since we are always called with
785 * 'skb->encapsulation' set.
786 */
Jesse Gross9b174d82014-12-30 19:10:15 -0800787 return eth_gro_complete(skb, nhoff + sizeof(struct vxlanhdr));
Or Gerlitzdc01e7d2014-01-20 13:59:21 +0200788}
789
Roopa Prabhu25e20e72018-07-04 16:46:30 -0700790static struct vxlan_fdb *vxlan_fdb_alloc(struct vxlan_dev *vxlan,
791 const u8 *mac, __u16 state,
Petr Machata45598c12018-11-21 08:02:36 +0000792 __be32 src_vni, __u16 ndm_flags)
Roopa Prabhu25e20e72018-07-04 16:46:30 -0700793{
794 struct vxlan_fdb *f;
795
796 f = kmalloc(sizeof(*f), GFP_ATOMIC);
797 if (!f)
798 return NULL;
799 f->state = state;
800 f->flags = ndm_flags;
801 f->updated = f->used = jiffies;
802 f->vni = src_vni;
803 INIT_LIST_HEAD(&f->remotes);
804 memcpy(f->eth_addr, mac, ETH_ALEN);
805
806 return f;
807}
808
stephen hemmingerd3428942012-10-01 12:32:35 +0000809static int vxlan_fdb_create(struct vxlan_dev *vxlan,
Cong Wange4c7ed42013-08-31 13:44:33 +0800810 const u8 *mac, union vxlan_addr *ip,
Roopa Prabhu25e20e72018-07-04 16:46:30 -0700811 __u16 state, __be16 port, __be32 src_vni,
Petr Machata45598c12018-11-21 08:02:36 +0000812 __be32 vni, __u32 ifindex, __u16 ndm_flags,
Roopa Prabhu25e20e72018-07-04 16:46:30 -0700813 struct vxlan_fdb **fdb)
814{
815 struct vxlan_rdst *rd = NULL;
816 struct vxlan_fdb *f;
817 int rc;
818
819 if (vxlan->cfg.addrmax &&
820 vxlan->addrcnt >= vxlan->cfg.addrmax)
821 return -ENOSPC;
822
823 netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);
824 f = vxlan_fdb_alloc(vxlan, mac, state, src_vni, ndm_flags);
825 if (!f)
826 return -ENOMEM;
827
828 rc = vxlan_fdb_append(f, ip, port, vni, ifindex, &rd);
829 if (rc < 0) {
830 kfree(f);
831 return rc;
832 }
833
834 ++vxlan->addrcnt;
835 hlist_add_head_rcu(&f->hlist,
836 vxlan_fdb_head(vxlan, mac, src_vni));
837
838 *fdb = f;
839
840 return 0;
841}
842
Petr Machatac2b200e2019-01-16 23:06:30 +0000843static void vxlan_fdb_free(struct rcu_head *head)
844{
845 struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);
846 struct vxlan_rdst *rd, *nd;
847
848 list_for_each_entry_safe(rd, nd, &f->remotes, list) {
849 dst_cache_destroy(&rd->dst_cache);
850 kfree(rd);
851 }
852 kfree(f);
853}
854
855static void vxlan_fdb_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f,
856 bool do_notify, bool swdev_notify)
857{
858 struct vxlan_rdst *rd;
859
860 netdev_dbg(vxlan->dev, "delete %pM\n", f->eth_addr);
861
862 --vxlan->addrcnt;
863 if (do_notify)
864 list_for_each_entry(rd, &f->remotes, list)
865 vxlan_fdb_notify(vxlan, f, rd, RTM_DELNEIGH,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000866 swdev_notify, NULL);
Petr Machatac2b200e2019-01-16 23:06:30 +0000867
868 hlist_del_rcu(&f->hlist);
869 call_rcu(&f->rcu, vxlan_fdb_free);
870}
871
Petr Machataa76d1ca2019-01-16 23:06:32 +0000872static int vxlan_fdb_update_existing(struct vxlan_dev *vxlan,
873 union vxlan_addr *ip,
874 __u16 state, __u16 flags,
875 __be16 port, __be32 vni,
876 __u32 ifindex, __u16 ndm_flags,
877 struct vxlan_fdb *f,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000878 bool swdev_notify,
879 struct netlink_ext_ack *extack)
Petr Machataa76d1ca2019-01-16 23:06:32 +0000880{
881 __u16 fdb_flags = (ndm_flags & ~NTF_USE);
882 struct vxlan_rdst *rd = NULL;
Petr Machataccdfd4f2019-01-16 23:06:34 +0000883 struct vxlan_rdst oldrd;
Petr Machataa76d1ca2019-01-16 23:06:32 +0000884 int notify = 0;
Petr Machata61f46fe2019-01-16 23:06:38 +0000885 int rc = 0;
886 int err;
Petr Machataa76d1ca2019-01-16 23:06:32 +0000887
888 /* Do not allow an externally learned entry to take over an entry added
889 * by the user.
890 */
891 if (!(fdb_flags & NTF_EXT_LEARNED) ||
892 !(f->flags & NTF_VXLAN_ADDED_BY_USER)) {
893 if (f->state != state) {
894 f->state = state;
895 f->updated = jiffies;
896 notify = 1;
897 }
898 if (f->flags != fdb_flags) {
899 f->flags = fdb_flags;
900 f->updated = jiffies;
901 notify = 1;
902 }
903 }
904
905 if ((flags & NLM_F_REPLACE)) {
906 /* Only change unicasts */
907 if (!(is_multicast_ether_addr(f->eth_addr) ||
908 is_zero_ether_addr(f->eth_addr))) {
909 rc = vxlan_fdb_replace(f, ip, port, vni,
Petr Machataccdfd4f2019-01-16 23:06:34 +0000910 ifindex, &oldrd);
Petr Machataa76d1ca2019-01-16 23:06:32 +0000911 notify |= rc;
912 } else {
913 return -EOPNOTSUPP;
914 }
915 }
916 if ((flags & NLM_F_APPEND) &&
917 (is_multicast_ether_addr(f->eth_addr) ||
918 is_zero_ether_addr(f->eth_addr))) {
919 rc = vxlan_fdb_append(f, ip, port, vni, ifindex, &rd);
920
921 if (rc < 0)
922 return rc;
923 notify |= rc;
924 }
925
926 if (ndm_flags & NTF_USE)
927 f->used = jiffies;
928
929 if (notify) {
930 if (rd == NULL)
931 rd = first_remote_rtnl(f);
932
Petr Machata61f46fe2019-01-16 23:06:38 +0000933 err = vxlan_fdb_notify(vxlan, f, rd, RTM_NEWNEIGH,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000934 swdev_notify, extack);
Petr Machata61f46fe2019-01-16 23:06:38 +0000935 if (err)
936 goto err_notify;
Petr Machataa76d1ca2019-01-16 23:06:32 +0000937 }
938
939 return 0;
Petr Machata61f46fe2019-01-16 23:06:38 +0000940
941err_notify:
942 if ((flags & NLM_F_REPLACE) && rc)
943 *rd = oldrd;
944 else if ((flags & NLM_F_APPEND) && rc)
945 list_del_rcu(&rd->list);
946 return err;
Petr Machataa76d1ca2019-01-16 23:06:32 +0000947}
948
949static int vxlan_fdb_update_create(struct vxlan_dev *vxlan,
950 const u8 *mac, union vxlan_addr *ip,
951 __u16 state, __u16 flags,
952 __be16 port, __be32 src_vni, __be32 vni,
953 __u32 ifindex, __u16 ndm_flags,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000954 bool swdev_notify,
955 struct netlink_ext_ack *extack)
Petr Machataa76d1ca2019-01-16 23:06:32 +0000956{
957 __u16 fdb_flags = (ndm_flags & ~NTF_USE);
958 struct vxlan_fdb *f;
959 int rc;
960
961 /* Disallow replace to add a multicast entry */
962 if ((flags & NLM_F_REPLACE) &&
963 (is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))
964 return -EOPNOTSUPP;
965
966 netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);
967 rc = vxlan_fdb_create(vxlan, mac, ip, state, port, src_vni,
968 vni, ifindex, fdb_flags, &f);
969 if (rc < 0)
970 return rc;
971
Petr Machata61f46fe2019-01-16 23:06:38 +0000972 rc = vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f), RTM_NEWNEIGH,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000973 swdev_notify, extack);
Petr Machata61f46fe2019-01-16 23:06:38 +0000974 if (rc)
975 goto err_notify;
976
Petr Machataa76d1ca2019-01-16 23:06:32 +0000977 return 0;
Petr Machata61f46fe2019-01-16 23:06:38 +0000978
979err_notify:
980 vxlan_fdb_destroy(vxlan, f, false, false);
981 return rc;
Petr Machataa76d1ca2019-01-16 23:06:32 +0000982}
983
Roopa Prabhu25e20e72018-07-04 16:46:30 -0700984/* Add new entry to forwarding table -- assumes lock held */
985static int vxlan_fdb_update(struct vxlan_dev *vxlan,
986 const u8 *mac, union vxlan_addr *ip,
David Stevens66817122013-03-15 04:35:51 +0000987 __u16 state, __u16 flags,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800988 __be16 port, __be32 src_vni, __be32 vni,
Petr Machata45598c12018-11-21 08:02:36 +0000989 __u32 ifindex, __u16 ndm_flags,
Petr Machata4c59b7d2019-01-16 23:06:54 +0000990 bool swdev_notify,
991 struct netlink_ext_ack *extack)
stephen hemmingerd3428942012-10-01 12:32:35 +0000992{
993 struct vxlan_fdb *f;
stephen hemmingerd3428942012-10-01 12:32:35 +0000994
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -0800995 f = __vxlan_find_mac(vxlan, mac, src_vni);
stephen hemmingerd3428942012-10-01 12:32:35 +0000996 if (f) {
997 if (flags & NLM_F_EXCL) {
998 netdev_dbg(vxlan->dev,
999 "lost race to create %pM\n", mac);
1000 return -EEXIST;
1001 }
Petr Machata0ec566a2018-11-21 08:02:37 +00001002
Petr Machataa76d1ca2019-01-16 23:06:32 +00001003 return vxlan_fdb_update_existing(vxlan, ip, state, flags, port,
1004 vni, ifindex, ndm_flags, f,
Petr Machata4c59b7d2019-01-16 23:06:54 +00001005 swdev_notify, extack);
stephen hemmingerd3428942012-10-01 12:32:35 +00001006 } else {
1007 if (!(flags & NLM_F_CREATE))
1008 return -ENOENT;
1009
Petr Machataa76d1ca2019-01-16 23:06:32 +00001010 return vxlan_fdb_update_create(vxlan, mac, ip, state, flags,
1011 port, src_vni, vni, ifindex,
Petr Machata4c59b7d2019-01-16 23:06:54 +00001012 ndm_flags, swdev_notify, extack);
stephen hemmingerd3428942012-10-01 12:32:35 +00001013 }
stephen hemmingerd3428942012-10-01 12:32:35 +00001014}
1015
Lance Richardson35cf2842017-05-29 13:25:57 -04001016static void vxlan_dst_free(struct rcu_head *head)
1017{
1018 struct vxlan_rdst *rd = container_of(head, struct vxlan_rdst, rcu);
1019
1020 dst_cache_destroy(&rd->dst_cache);
1021 kfree(rd);
1022}
1023
1024static void vxlan_fdb_dst_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f,
Petr Machata0e6160f2018-11-21 08:02:35 +00001025 struct vxlan_rdst *rd, bool swdev_notify)
Lance Richardson35cf2842017-05-29 13:25:57 -04001026{
1027 list_del_rcu(&rd->list);
Petr Machata4c59b7d2019-01-16 23:06:54 +00001028 vxlan_fdb_notify(vxlan, f, rd, RTM_DELNEIGH, swdev_notify, NULL);
Lance Richardson35cf2842017-05-29 13:25:57 -04001029 call_rcu(&rd->rcu, vxlan_dst_free);
1030}
1031
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001032static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001033 union vxlan_addr *ip, __be16 *port, __be32 *src_vni,
1034 __be32 *vni, u32 *ifindex)
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001035{
1036 struct net *net = dev_net(vxlan->dev);
Cong Wange4c7ed42013-08-31 13:44:33 +08001037 int err;
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001038
1039 if (tb[NDA_DST]) {
Cong Wange4c7ed42013-08-31 13:44:33 +08001040 err = vxlan_nla_get_addr(ip, tb[NDA_DST]);
1041 if (err)
1042 return err;
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001043 } else {
Cong Wange4c7ed42013-08-31 13:44:33 +08001044 union vxlan_addr *remote = &vxlan->default_dst.remote_ip;
1045 if (remote->sa.sa_family == AF_INET) {
1046 ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);
1047 ip->sa.sa_family = AF_INET;
1048#if IS_ENABLED(CONFIG_IPV6)
1049 } else {
1050 ip->sin6.sin6_addr = in6addr_any;
1051 ip->sa.sa_family = AF_INET6;
1052#endif
1053 }
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001054 }
1055
1056 if (tb[NDA_PORT]) {
1057 if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
1058 return -EINVAL;
1059 *port = nla_get_be16(tb[NDA_PORT]);
1060 } else {
Thomas Graf0dfbdf42015-07-21 10:44:02 +02001061 *port = vxlan->cfg.dst_port;
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001062 }
1063
1064 if (tb[NDA_VNI]) {
1065 if (nla_len(tb[NDA_VNI]) != sizeof(u32))
1066 return -EINVAL;
Jiri Benc54bfd872016-02-16 21:58:58 +01001067 *vni = cpu_to_be32(nla_get_u32(tb[NDA_VNI]));
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001068 } else {
1069 *vni = vxlan->default_dst.remote_vni;
1070 }
1071
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001072 if (tb[NDA_SRC_VNI]) {
1073 if (nla_len(tb[NDA_SRC_VNI]) != sizeof(u32))
1074 return -EINVAL;
1075 *src_vni = cpu_to_be32(nla_get_u32(tb[NDA_SRC_VNI]));
1076 } else {
1077 *src_vni = vxlan->default_dst.remote_vni;
1078 }
1079
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001080 if (tb[NDA_IFINDEX]) {
1081 struct net_device *tdev;
1082
1083 if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
1084 return -EINVAL;
1085 *ifindex = nla_get_u32(tb[NDA_IFINDEX]);
Ying Xue73763942014-01-15 10:23:41 +08001086 tdev = __dev_get_by_index(net, *ifindex);
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001087 if (!tdev)
1088 return -EADDRNOTAVAIL;
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001089 } else {
1090 *ifindex = 0;
1091 }
1092
1093 return 0;
1094}
1095
stephen hemmingerd3428942012-10-01 12:32:35 +00001096/* Add static entry (via netlink) */
1097static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1098 struct net_device *dev,
Petr Machata87b09842019-01-16 23:06:50 +00001099 const unsigned char *addr, u16 vid, u16 flags,
1100 struct netlink_ext_ack *extack)
stephen hemmingerd3428942012-10-01 12:32:35 +00001101{
1102 struct vxlan_dev *vxlan = netdev_priv(dev);
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001103 /* struct net *net = dev_net(vxlan->dev); */
Cong Wange4c7ed42013-08-31 13:44:33 +08001104 union vxlan_addr ip;
stephen hemminger73cf3312013-04-27 11:31:54 +00001105 __be16 port;
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001106 __be32 src_vni, vni;
Jiri Benc54bfd872016-02-16 21:58:58 +01001107 u32 ifindex;
stephen hemmingerd3428942012-10-01 12:32:35 +00001108 int err;
1109
1110 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_REACHABLE))) {
1111 pr_info("RTM_NEWNEIGH with invalid state %#x\n",
1112 ndm->ndm_state);
1113 return -EINVAL;
1114 }
1115
1116 if (tb[NDA_DST] == NULL)
1117 return -EINVAL;
1118
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001119 err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &src_vni, &vni, &ifindex);
Mike Rapoportf0b074b2013-06-25 16:01:53 +03001120 if (err)
1121 return err;
David Stevens66817122013-03-15 04:35:51 +00001122
Mike Rapoport5933a7b2014-04-01 09:23:01 +03001123 if (vxlan->default_dst.remote_ip.sa.sa_family != ip.sa.sa_family)
1124 return -EAFNOSUPPORT;
1125
stephen hemmingerd3428942012-10-01 12:32:35 +00001126 spin_lock_bh(&vxlan->hash_lock);
Roopa Prabhu25e20e72018-07-04 16:46:30 -07001127 err = vxlan_fdb_update(vxlan, addr, &ip, ndm->ndm_state, flags,
Petr Machata45598c12018-11-21 08:02:36 +00001128 port, src_vni, vni, ifindex,
1129 ndm->ndm_flags | NTF_VXLAN_ADDED_BY_USER,
Petr Machata4c59b7d2019-01-16 23:06:54 +00001130 true, extack);
stephen hemmingerd3428942012-10-01 12:32:35 +00001131 spin_unlock_bh(&vxlan->hash_lock);
1132
1133 return err;
1134}
1135
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001136static int __vxlan_fdb_delete(struct vxlan_dev *vxlan,
1137 const unsigned char *addr, union vxlan_addr ip,
Xin Longfc39c382017-11-26 21:19:05 +08001138 __be16 port, __be32 src_vni, __be32 vni,
Petr Machata0e6160f2018-11-21 08:02:35 +00001139 u32 ifindex, bool swdev_notify)
stephen hemmingerd3428942012-10-01 12:32:35 +00001140{
stephen hemmingerd3428942012-10-01 12:32:35 +00001141 struct vxlan_fdb *f;
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001142 struct vxlan_rdst *rd = NULL;
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001143 int err = -ENOENT;
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001144
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001145 f = vxlan_find_mac(vxlan, addr, src_vni);
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001146 if (!f)
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001147 return err;
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001148
Cong Wange4c7ed42013-08-31 13:44:33 +08001149 if (!vxlan_addr_any(&ip)) {
1150 rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001151 if (!rd)
1152 goto out;
stephen hemmingerd3428942012-10-01 12:32:35 +00001153 }
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001154
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001155 /* remove a destination if it's not the only one on the list,
1156 * otherwise destroy the fdb entry
1157 */
1158 if (rd && !list_is_singular(&f->remotes)) {
Petr Machata0e6160f2018-11-21 08:02:35 +00001159 vxlan_fdb_dst_destroy(vxlan, f, rd, swdev_notify);
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001160 goto out;
1161 }
1162
Petr Machata0e6160f2018-11-21 08:02:35 +00001163 vxlan_fdb_destroy(vxlan, f, true, swdev_notify);
Mike Rapoportbc7892b2013-06-25 16:01:54 +03001164
1165out:
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001166 return 0;
1167}
1168
1169/* Delete entry (via netlink) */
1170static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
1171 struct net_device *dev,
1172 const unsigned char *addr, u16 vid)
1173{
1174 struct vxlan_dev *vxlan = netdev_priv(dev);
1175 union vxlan_addr ip;
1176 __be32 src_vni, vni;
1177 __be16 port;
1178 u32 ifindex;
1179 int err;
1180
1181 err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &src_vni, &vni, &ifindex);
1182 if (err)
1183 return err;
1184
1185 spin_lock_bh(&vxlan->hash_lock);
Petr Machata0e6160f2018-11-21 08:02:35 +00001186 err = __vxlan_fdb_delete(vxlan, addr, ip, port, src_vni, vni, ifindex,
1187 true);
stephen hemmingerd3428942012-10-01 12:32:35 +00001188 spin_unlock_bh(&vxlan->hash_lock);
1189
1190 return err;
1191}
1192
1193/* Dump forwarding table */
1194static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
Jamal Hadi Salim5d5eacb2014-07-10 07:01:58 -04001195 struct net_device *dev,
Roopa Prabhud2976532016-08-30 21:56:45 -07001196 struct net_device *filter_dev, int *idx)
stephen hemmingerd3428942012-10-01 12:32:35 +00001197{
1198 struct vxlan_dev *vxlan = netdev_priv(dev);
1199 unsigned int h;
Roopa Prabhud2976532016-08-30 21:56:45 -07001200 int err = 0;
stephen hemmingerd3428942012-10-01 12:32:35 +00001201
1202 for (h = 0; h < FDB_HASH_SIZE; ++h) {
1203 struct vxlan_fdb *f;
stephen hemmingerd3428942012-10-01 12:32:35 +00001204
Sasha Levinb67bfe02013-02-27 17:06:00 -08001205 hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
David Stevens66817122013-03-15 04:35:51 +00001206 struct vxlan_rdst *rd;
stephen hemmingerd3428942012-10-01 12:32:35 +00001207
Stephen Hemminger3e61aa82013-06-17 14:16:12 -07001208 list_for_each_entry_rcu(rd, &f->remotes, list) {
Roopa Prabhud2976532016-08-30 21:56:45 -07001209 if (*idx < cb->args[2])
Atzm Watanabe07a51cd2015-08-10 23:39:09 +09001210 goto skip;
1211
David Stevens66817122013-03-15 04:35:51 +00001212 err = vxlan_fdb_info(skb, vxlan, f,
1213 NETLINK_CB(cb->skb).portid,
1214 cb->nlh->nlmsg_seq,
1215 RTM_NEWNEIGH,
1216 NLM_F_MULTI, rd);
Roopa Prabhud2976532016-08-30 21:56:45 -07001217 if (err < 0)
Stephen Hemminger3e61aa82013-06-17 14:16:12 -07001218 goto out;
Stephen Hemminger3e61aa82013-06-17 14:16:12 -07001219skip:
Roopa Prabhud2976532016-08-30 21:56:45 -07001220 *idx += 1;
Atzm Watanabe07a51cd2015-08-10 23:39:09 +09001221 }
stephen hemmingerd3428942012-10-01 12:32:35 +00001222 }
1223 }
Stephen Hemminger3e61aa82013-06-17 14:16:12 -07001224out:
Roopa Prabhud2976532016-08-30 21:56:45 -07001225 return err;
stephen hemmingerd3428942012-10-01 12:32:35 +00001226}
1227
Roopa Prabhu474c3c82018-12-15 22:35:10 -08001228static int vxlan_fdb_get(struct sk_buff *skb,
1229 struct nlattr *tb[],
1230 struct net_device *dev,
1231 const unsigned char *addr,
1232 u16 vid, u32 portid, u32 seq,
1233 struct netlink_ext_ack *extack)
1234{
1235 struct vxlan_dev *vxlan = netdev_priv(dev);
1236 struct vxlan_fdb *f;
1237 __be32 vni;
1238 int err;
1239
1240 if (tb[NDA_VNI])
1241 vni = cpu_to_be32(nla_get_u32(tb[NDA_VNI]));
1242 else
1243 vni = vxlan->default_dst.remote_vni;
1244
1245 rcu_read_lock();
1246
1247 f = __vxlan_find_mac(vxlan, addr, vni);
1248 if (!f) {
1249 NL_SET_ERR_MSG(extack, "Fdb entry not found");
1250 err = -ENOENT;
1251 goto errout;
1252 }
1253
1254 err = vxlan_fdb_info(skb, vxlan, f, portid, seq,
1255 RTM_NEWNEIGH, 0, first_remote_rcu(f));
1256errout:
1257 rcu_read_unlock();
1258 return err;
1259}
1260
stephen hemmingerd3428942012-10-01 12:32:35 +00001261/* Watch incoming packets to learn mapping between Ethernet address
1262 * and Tunnel endpoint.
Simon Hormanc4b49512015-04-02 11:17:58 +09001263 * Return true if packet is bogus and should be dropped.
stephen hemmingerd3428942012-10-01 12:32:35 +00001264 */
stephen hemminger26a41ae62013-06-17 12:09:58 -07001265static bool vxlan_snoop(struct net_device *dev,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001266 union vxlan_addr *src_ip, const u8 *src_mac,
Matthias Schiffer87613de2017-06-19 10:03:59 +02001267 u32 src_ifindex, __be32 vni)
stephen hemmingerd3428942012-10-01 12:32:35 +00001268{
1269 struct vxlan_dev *vxlan = netdev_priv(dev);
1270 struct vxlan_fdb *f;
Matthias Schiffer87613de2017-06-19 10:03:59 +02001271 u32 ifindex = 0;
1272
1273#if IS_ENABLED(CONFIG_IPV6)
1274 if (src_ip->sa.sa_family == AF_INET6 &&
1275 (ipv6_addr_type(&src_ip->sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL))
1276 ifindex = src_ifindex;
1277#endif
stephen hemmingerd3428942012-10-01 12:32:35 +00001278
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001279 f = vxlan_find_mac(vxlan, src_mac, vni);
stephen hemmingerd3428942012-10-01 12:32:35 +00001280 if (likely(f)) {
stephen hemminger5ca54612013-08-04 17:17:39 -07001281 struct vxlan_rdst *rdst = first_remote_rcu(f);
Stephen Hemminger3e61aa82013-06-17 14:16:12 -07001282
Matthias Schiffer87613de2017-06-19 10:03:59 +02001283 if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip) &&
1284 rdst->remote_ifindex == ifindex))
stephen hemminger26a41ae62013-06-17 12:09:58 -07001285 return false;
1286
1287 /* Don't migrate static entries, drop packets */
Roopa Prabhue0090a92017-06-11 16:32:50 -07001288 if (f->state & (NUD_PERMANENT | NUD_NOARP))
stephen hemminger26a41ae62013-06-17 12:09:58 -07001289 return true;
stephen hemmingerd3428942012-10-01 12:32:35 +00001290
1291 if (net_ratelimit())
1292 netdev_info(dev,
Cong Wange4c7ed42013-08-31 13:44:33 +08001293 "%pM migrated from %pIS to %pIS\n",
Rasmus Villemoesa4870f72015-02-07 03:17:31 +01001294 src_mac, &rdst->remote_ip.sa, &src_ip->sa);
stephen hemmingerd3428942012-10-01 12:32:35 +00001295
Cong Wange4c7ed42013-08-31 13:44:33 +08001296 rdst->remote_ip = *src_ip;
stephen hemmingerd3428942012-10-01 12:32:35 +00001297 f->updated = jiffies;
Petr Machata4c59b7d2019-01-16 23:06:54 +00001298 vxlan_fdb_notify(vxlan, f, rdst, RTM_NEWNEIGH, true, NULL);
stephen hemmingerd3428942012-10-01 12:32:35 +00001299 } else {
1300 /* learned new entry */
1301 spin_lock(&vxlan->hash_lock);
stephen hemminger3bf74b12013-06-17 12:09:57 -07001302
1303 /* close off race between vxlan_flush and incoming packets */
1304 if (netif_running(dev))
Roopa Prabhu25e20e72018-07-04 16:46:30 -07001305 vxlan_fdb_update(vxlan, src_mac, src_ip,
stephen hemminger3bf74b12013-06-17 12:09:57 -07001306 NUD_REACHABLE,
1307 NLM_F_EXCL|NLM_F_CREATE,
Thomas Graf0dfbdf42015-07-21 10:44:02 +02001308 vxlan->cfg.dst_port,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001309 vni,
stephen hemminger3bf74b12013-06-17 12:09:57 -07001310 vxlan->default_dst.remote_vni,
Petr Machata4c59b7d2019-01-16 23:06:54 +00001311 ifindex, NTF_SELF, true, NULL);
stephen hemmingerd3428942012-10-01 12:32:35 +00001312 spin_unlock(&vxlan->hash_lock);
1313 }
stephen hemminger26a41ae62013-06-17 12:09:58 -07001314
1315 return false;
stephen hemmingerd3428942012-10-01 12:32:35 +00001316}
1317
stephen hemmingerd3428942012-10-01 12:32:35 +00001318/* See if multicast group is already in use by other ID */
Gao feng95ab0992013-12-10 16:37:33 +08001319static bool vxlan_group_used(struct vxlan_net *vn, struct vxlan_dev *dev)
stephen hemmingerd3428942012-10-01 12:32:35 +00001320{
stephen hemminger553675f2013-05-16 11:35:20 +00001321 struct vxlan_dev *vxlan;
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001322 struct vxlan_sock *sock4;
Arnd Bergmann4053ab12016-11-07 22:09:07 +01001323#if IS_ENABLED(CONFIG_IPV6)
1324 struct vxlan_sock *sock6;
1325#endif
Jiri Bencb1be00a2015-09-24 13:50:02 +02001326 unsigned short family = dev->default_dst.remote_ip.sa.sa_family;
stephen hemmingerd3428942012-10-01 12:32:35 +00001327
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001328 sock4 = rtnl_dereference(dev->vn4_sock);
1329
Gao feng95ab0992013-12-10 16:37:33 +08001330 /* The vxlan_sock is only used by dev, leaving group has
1331 * no effect on other vxlan devices.
1332 */
Reshetova, Elena66af8462017-07-04 15:52:59 +03001333 if (family == AF_INET && sock4 && refcount_read(&sock4->refcnt) == 1)
Gao feng95ab0992013-12-10 16:37:33 +08001334 return false;
Jiri Bencb1be00a2015-09-24 13:50:02 +02001335#if IS_ENABLED(CONFIG_IPV6)
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001336 sock6 = rtnl_dereference(dev->vn6_sock);
Reshetova, Elena66af8462017-07-04 15:52:59 +03001337 if (family == AF_INET6 && sock6 && refcount_read(&sock6->refcnt) == 1)
Jiri Bencb1be00a2015-09-24 13:50:02 +02001338 return false;
1339#endif
Gao feng95ab0992013-12-10 16:37:33 +08001340
stephen hemminger553675f2013-05-16 11:35:20 +00001341 list_for_each_entry(vxlan, &vn->vxlan_list, next) {
Gao feng95ab0992013-12-10 16:37:33 +08001342 if (!netif_running(vxlan->dev) || vxlan == dev)
stephen hemminger553675f2013-05-16 11:35:20 +00001343 continue;
stephen hemmingerd3428942012-10-01 12:32:35 +00001344
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001345 if (family == AF_INET &&
1346 rtnl_dereference(vxlan->vn4_sock) != sock4)
Gao feng95ab0992013-12-10 16:37:33 +08001347 continue;
Jiri Bencb1be00a2015-09-24 13:50:02 +02001348#if IS_ENABLED(CONFIG_IPV6)
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001349 if (family == AF_INET6 &&
1350 rtnl_dereference(vxlan->vn6_sock) != sock6)
Jiri Bencb1be00a2015-09-24 13:50:02 +02001351 continue;
1352#endif
Gao feng95ab0992013-12-10 16:37:33 +08001353
1354 if (!vxlan_addr_equal(&vxlan->default_dst.remote_ip,
1355 &dev->default_dst.remote_ip))
1356 continue;
1357
1358 if (vxlan->default_dst.remote_ifindex !=
1359 dev->default_dst.remote_ifindex)
1360 continue;
1361
1362 return true;
stephen hemminger553675f2013-05-16 11:35:20 +00001363 }
stephen hemmingerd3428942012-10-01 12:32:35 +00001364
1365 return false;
1366}
1367
Hannes Frederic Sowa544a7732016-04-09 12:46:23 +02001368static bool __vxlan_sock_release_prep(struct vxlan_sock *vs)
stephen hemmingerd3428942012-10-01 12:32:35 +00001369{
Jiri Bencb1be00a2015-09-24 13:50:02 +02001370 struct vxlan_net *vn;
Pravin B Shelar012a5722013-08-19 11:23:07 -07001371
Jiri Bencb1be00a2015-09-24 13:50:02 +02001372 if (!vs)
Hannes Frederic Sowa544a7732016-04-09 12:46:23 +02001373 return false;
Reshetova, Elena66af8462017-07-04 15:52:59 +03001374 if (!refcount_dec_and_test(&vs->refcnt))
Hannes Frederic Sowa544a7732016-04-09 12:46:23 +02001375 return false;
Stephen Hemminger7c47ced2013-06-17 14:16:10 -07001376
Jiri Bencb1be00a2015-09-24 13:50:02 +02001377 vn = net_generic(sock_net(vs->sock->sk), vxlan_net_id);
Stephen Hemminger1c51a912013-06-17 14:16:11 -07001378 spin_lock(&vn->sock_lock);
Stephen Hemminger7c47ced2013-06-17 14:16:10 -07001379 hlist_del_rcu(&vs->hlist);
Alexander Duycke7b3db52016-06-16 12:20:52 -07001380 udp_tunnel_notify_del_rx_port(vs->sock,
Alexander Duyckb9adcd692016-06-16 12:23:19 -07001381 (vs->flags & VXLAN_F_GPE) ?
1382 UDP_TUNNEL_TYPE_VXLAN_GPE :
Alexander Duycke7b3db52016-06-16 12:20:52 -07001383 UDP_TUNNEL_TYPE_VXLAN);
Stephen Hemminger1c51a912013-06-17 14:16:11 -07001384 spin_unlock(&vn->sock_lock);
1385
Hannes Frederic Sowa544a7732016-04-09 12:46:23 +02001386 return true;
Stephen Hemminger7c47ced2013-06-17 14:16:10 -07001387}
1388
Jiri Bencb1be00a2015-09-24 13:50:02 +02001389static void vxlan_sock_release(struct vxlan_dev *vxlan)
1390{
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001391 struct vxlan_sock *sock4 = rtnl_dereference(vxlan->vn4_sock);
Jiri Bencb1be00a2015-09-24 13:50:02 +02001392#if IS_ENABLED(CONFIG_IPV6)
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001393 struct vxlan_sock *sock6 = rtnl_dereference(vxlan->vn6_sock);
1394
Mark Bloch57d88182017-06-07 14:36:58 +03001395 RCU_INIT_POINTER(vxlan->vn6_sock, NULL);
Hannes Frederic Sowa544a7732016-04-09 12:46:23 +02001396#endif
1397
Mark Bloch57d88182017-06-07 14:36:58 +03001398 RCU_INIT_POINTER(vxlan->vn4_sock, NULL);
Hannes Frederic Sowa544a7732016-04-09 12:46:23 +02001399 synchronize_net();
1400
Mark Blocha53cb292017-06-02 03:24:08 +03001401 vxlan_vs_del_dev(vxlan);
1402
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001403 if (__vxlan_sock_release_prep(sock4)) {
1404 udp_tunnel_sock_release(sock4->sock);
1405 kfree(sock4);
Hannes Frederic Sowa544a7732016-04-09 12:46:23 +02001406 }
1407
1408#if IS_ENABLED(CONFIG_IPV6)
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001409 if (__vxlan_sock_release_prep(sock6)) {
1410 udp_tunnel_sock_release(sock6->sock);
1411 kfree(sock6);
Hannes Frederic Sowa544a7732016-04-09 12:46:23 +02001412 }
Jiri Bencb1be00a2015-09-24 13:50:02 +02001413#endif
1414}
1415
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001416/* Update multicast group membership when first VNI on
Simon Hormanc4b49512015-04-02 11:17:58 +09001417 * multicast address is brought up
Stephen Hemminger7c47ced2013-06-17 14:16:10 -07001418 */
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001419static int vxlan_igmp_join(struct vxlan_dev *vxlan)
Stephen Hemminger7c47ced2013-06-17 14:16:10 -07001420{
Jiri Bencb1be00a2015-09-24 13:50:02 +02001421 struct sock *sk;
Cong Wange4c7ed42013-08-31 13:44:33 +08001422 union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
1423 int ifindex = vxlan->default_dst.remote_ifindex;
Marcelo Ricardo Leitner149d7542015-03-20 10:26:21 -03001424 int ret = -EINVAL;
stephen hemmingerd3428942012-10-01 12:32:35 +00001425
Cong Wange4c7ed42013-08-31 13:44:33 +08001426 if (ip->sa.sa_family == AF_INET) {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001427 struct vxlan_sock *sock4 = rtnl_dereference(vxlan->vn4_sock);
Cong Wange4c7ed42013-08-31 13:44:33 +08001428 struct ip_mreqn mreq = {
1429 .imr_multiaddr.s_addr = ip->sin.sin_addr.s_addr,
1430 .imr_ifindex = ifindex,
1431 };
1432
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001433 sk = sock4->sock->sk;
Jiri Bencb1be00a2015-09-24 13:50:02 +02001434 lock_sock(sk);
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001435 ret = ip_mc_join_group(sk, &mreq);
Jiri Bencb1be00a2015-09-24 13:50:02 +02001436 release_sock(sk);
Cong Wange4c7ed42013-08-31 13:44:33 +08001437#if IS_ENABLED(CONFIG_IPV6)
1438 } else {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001439 struct vxlan_sock *sock6 = rtnl_dereference(vxlan->vn6_sock);
1440
1441 sk = sock6->sock->sk;
Jiri Bencb1be00a2015-09-24 13:50:02 +02001442 lock_sock(sk);
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001443 ret = ipv6_stub->ipv6_sock_mc_join(sk, ifindex,
1444 &ip->sin6.sin6_addr);
Jiri Bencb1be00a2015-09-24 13:50:02 +02001445 release_sock(sk);
Cong Wange4c7ed42013-08-31 13:44:33 +08001446#endif
1447 }
stephen hemminger3fc2de22013-07-18 08:40:15 -07001448
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001449 return ret;
stephen hemminger3fc2de22013-07-18 08:40:15 -07001450}
1451
1452/* Inverse of vxlan_igmp_join when last VNI is brought down */
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001453static int vxlan_igmp_leave(struct vxlan_dev *vxlan)
stephen hemminger3fc2de22013-07-18 08:40:15 -07001454{
Jiri Bencb1be00a2015-09-24 13:50:02 +02001455 struct sock *sk;
Cong Wange4c7ed42013-08-31 13:44:33 +08001456 union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
1457 int ifindex = vxlan->default_dst.remote_ifindex;
Marcelo Ricardo Leitner149d7542015-03-20 10:26:21 -03001458 int ret = -EINVAL;
stephen hemminger3fc2de22013-07-18 08:40:15 -07001459
Cong Wange4c7ed42013-08-31 13:44:33 +08001460 if (ip->sa.sa_family == AF_INET) {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001461 struct vxlan_sock *sock4 = rtnl_dereference(vxlan->vn4_sock);
Cong Wange4c7ed42013-08-31 13:44:33 +08001462 struct ip_mreqn mreq = {
1463 .imr_multiaddr.s_addr = ip->sin.sin_addr.s_addr,
1464 .imr_ifindex = ifindex,
1465 };
1466
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001467 sk = sock4->sock->sk;
Jiri Bencb1be00a2015-09-24 13:50:02 +02001468 lock_sock(sk);
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001469 ret = ip_mc_leave_group(sk, &mreq);
Jiri Bencb1be00a2015-09-24 13:50:02 +02001470 release_sock(sk);
Cong Wange4c7ed42013-08-31 13:44:33 +08001471#if IS_ENABLED(CONFIG_IPV6)
1472 } else {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07001473 struct vxlan_sock *sock6 = rtnl_dereference(vxlan->vn6_sock);
1474
1475 sk = sock6->sock->sk;
Jiri Bencb1be00a2015-09-24 13:50:02 +02001476 lock_sock(sk);
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001477 ret = ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,
1478 &ip->sin6.sin6_addr);
Jiri Bencb1be00a2015-09-24 13:50:02 +02001479 release_sock(sk);
Cong Wange4c7ed42013-08-31 13:44:33 +08001480#endif
1481 }
stephen hemmingerd3428942012-10-01 12:32:35 +00001482
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03001483 return ret;
stephen hemmingerd3428942012-10-01 12:32:35 +00001484}
1485
Jiri Bencf14eceb2016-02-16 21:59:01 +01001486static bool vxlan_remcsum(struct vxlanhdr *unparsed,
1487 struct sk_buff *skb, u32 vxflags)
Tom Herbertdfd86452015-01-12 17:00:38 -08001488{
Jiri Benc7d34fa72016-03-21 17:50:05 +01001489 size_t start, offset;
Tom Herbertdfd86452015-01-12 17:00:38 -08001490
Jiri Bencf14eceb2016-02-16 21:59:01 +01001491 if (!(unparsed->vx_flags & VXLAN_HF_RCO) || skb->remcsum_offload)
1492 goto out;
Tom Herbertb7fe10e2015-08-19 17:07:32 -07001493
Jiri Bencf14eceb2016-02-16 21:59:01 +01001494 start = vxlan_rco_start(unparsed->vx_vni);
1495 offset = start + vxlan_rco_offset(unparsed->vx_vni);
Tom Herbertdfd86452015-01-12 17:00:38 -08001496
Jiri Benc7d34fa72016-03-21 17:50:05 +01001497 if (!pskb_may_pull(skb, offset + sizeof(u16)))
Jiri Bencbe5cfea2016-02-16 21:58:59 +01001498 return false;
Tom Herbertdfd86452015-01-12 17:00:38 -08001499
Jiri Bencbe5cfea2016-02-16 21:58:59 +01001500 skb_remcsum_process(skb, (void *)(vxlan_hdr(skb) + 1), start, offset,
1501 !!(vxflags & VXLAN_F_REMCSUM_NOPARTIAL));
Jiri Bencf14eceb2016-02-16 21:59:01 +01001502out:
1503 unparsed->vx_flags &= ~VXLAN_HF_RCO;
1504 unparsed->vx_vni &= VXLAN_VNI_MASK;
Jiri Bencbe5cfea2016-02-16 21:58:59 +01001505 return true;
Tom Herbertdfd86452015-01-12 17:00:38 -08001506}
1507
Jiri Bencf14eceb2016-02-16 21:59:01 +01001508static void vxlan_parse_gbp_hdr(struct vxlanhdr *unparsed,
Jiri Benc64f87d32016-02-23 18:02:55 +01001509 struct sk_buff *skb, u32 vxflags,
Jiri Benc10a5af22016-02-23 18:02:59 +01001510 struct vxlan_metadata *md)
Jiri Benc3288af02016-02-16 21:59:00 +01001511{
Jiri Bencf14eceb2016-02-16 21:59:01 +01001512 struct vxlanhdr_gbp *gbp = (struct vxlanhdr_gbp *)unparsed;
Jiri Benc10a5af22016-02-23 18:02:59 +01001513 struct metadata_dst *tun_dst;
Jiri Benc3288af02016-02-16 21:59:00 +01001514
Jiri Bencf14eceb2016-02-16 21:59:01 +01001515 if (!(unparsed->vx_flags & VXLAN_HF_GBP))
1516 goto out;
1517
Jiri Benc3288af02016-02-16 21:59:00 +01001518 md->gbp = ntohs(gbp->policy_id);
1519
Jiri Benc10a5af22016-02-23 18:02:59 +01001520 tun_dst = (struct metadata_dst *)skb_dst(skb);
David S. Miller810813c2016-03-08 12:34:12 -05001521 if (tun_dst) {
Jiri Benc3288af02016-02-16 21:59:00 +01001522 tun_dst->u.tun_info.key.tun_flags |= TUNNEL_VXLAN_OPT;
David S. Miller810813c2016-03-08 12:34:12 -05001523 tun_dst->u.tun_info.options_len = sizeof(*md);
1524 }
Jiri Benc3288af02016-02-16 21:59:00 +01001525 if (gbp->dont_learn)
1526 md->gbp |= VXLAN_GBP_DONT_LEARN;
1527
1528 if (gbp->policy_applied)
1529 md->gbp |= VXLAN_GBP_POLICY_APPLIED;
Jiri Bencf14eceb2016-02-16 21:59:01 +01001530
Jiri Benc64f87d32016-02-23 18:02:55 +01001531 /* In flow-based mode, GBP is carried in dst_metadata */
1532 if (!(vxflags & VXLAN_F_COLLECT_METADATA))
1533 skb->mark = md->gbp;
Jiri Bencf14eceb2016-02-16 21:59:01 +01001534out:
1535 unparsed->vx_flags &= ~VXLAN_GBP_USED_BITS;
Jiri Benc3288af02016-02-16 21:59:00 +01001536}
1537
Jiri Bence1e53142016-04-05 14:47:13 +02001538static bool vxlan_parse_gpe_hdr(struct vxlanhdr *unparsed,
Jiri Benc61618ee2016-04-11 17:06:08 +02001539 __be16 *protocol,
Jiri Bence1e53142016-04-05 14:47:13 +02001540 struct sk_buff *skb, u32 vxflags)
1541{
1542 struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)unparsed;
1543
1544 /* Need to have Next Protocol set for interfaces in GPE mode. */
1545 if (!gpe->np_applied)
1546 return false;
1547 /* "The initial version is 0. If a receiver does not support the
1548 * version indicated it MUST drop the packet.
1549 */
1550 if (gpe->version != 0)
1551 return false;
1552 /* "When the O bit is set to 1, the packet is an OAM packet and OAM
1553 * processing MUST occur." However, we don't implement OAM
1554 * processing, thus drop the packet.
1555 */
1556 if (gpe->oam_flag)
1557 return false;
1558
Jiri Bencfa20e0e2017-08-28 21:43:22 +02001559 *protocol = tun_p_to_eth_p(gpe->next_protocol);
1560 if (!*protocol)
Jiri Bence1e53142016-04-05 14:47:13 +02001561 return false;
Jiri Bence1e53142016-04-05 14:47:13 +02001562
1563 unparsed->vx_flags &= ~VXLAN_GPE_USED_BITS;
1564 return true;
1565}
1566
Jiri Benc1ab016e2016-02-23 18:02:56 +01001567static bool vxlan_set_mac(struct vxlan_dev *vxlan,
1568 struct vxlan_sock *vs,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001569 struct sk_buff *skb, __be32 vni)
Thomas Graf614732e2015-07-21 10:44:06 +02001570{
Thomas Graf614732e2015-07-21 10:44:06 +02001571 union vxlan_addr saddr;
Matthias Schiffer87613de2017-06-19 10:03:59 +02001572 u32 ifindex = skb->dev->ifindex;
Thomas Graf614732e2015-07-21 10:44:06 +02001573
Thomas Graf614732e2015-07-21 10:44:06 +02001574 skb_reset_mac_header(skb);
Thomas Graf614732e2015-07-21 10:44:06 +02001575 skb->protocol = eth_type_trans(skb, vxlan->dev);
1576 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
1577
1578 /* Ignore packet loops (and multicast echo) */
1579 if (ether_addr_equal(eth_hdr(skb)->h_source, vxlan->dev->dev_addr))
Jiri Benc1ab016e2016-02-23 18:02:56 +01001580 return false;
Thomas Graf614732e2015-07-21 10:44:06 +02001581
Jiri Benc760c6802016-02-23 18:02:57 +01001582 /* Get address from the outer IP header */
Jiri Bencce212d02015-12-07 16:29:08 +01001583 if (vxlan_get_sk_family(vs) == AF_INET) {
Jiri Benc1ab016e2016-02-23 18:02:56 +01001584 saddr.sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
Thomas Graf614732e2015-07-21 10:44:06 +02001585 saddr.sa.sa_family = AF_INET;
1586#if IS_ENABLED(CONFIG_IPV6)
1587 } else {
Jiri Benc1ab016e2016-02-23 18:02:56 +01001588 saddr.sin6.sin6_addr = ipv6_hdr(skb)->saddr;
Thomas Graf614732e2015-07-21 10:44:06 +02001589 saddr.sa.sa_family = AF_INET6;
1590#endif
1591 }
1592
Matthias Schifferdc5321d2017-06-19 10:03:56 +02001593 if ((vxlan->cfg.flags & VXLAN_F_LEARN) &&
Matthias Schiffer87613de2017-06-19 10:03:59 +02001594 vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source, ifindex, vni))
Jiri Benc1ab016e2016-02-23 18:02:56 +01001595 return false;
1596
1597 return true;
1598}
1599
Jiri Benc760c6802016-02-23 18:02:57 +01001600static bool vxlan_ecn_decapsulate(struct vxlan_sock *vs, void *oiph,
1601 struct sk_buff *skb)
1602{
1603 int err = 0;
1604
1605 if (vxlan_get_sk_family(vs) == AF_INET)
1606 err = IP_ECN_decapsulate(oiph, skb);
1607#if IS_ENABLED(CONFIG_IPV6)
1608 else
1609 err = IP6_ECN_decapsulate(oiph, skb);
1610#endif
1611
1612 if (unlikely(err) && log_ecn_error) {
1613 if (vxlan_get_sk_family(vs) == AF_INET)
1614 net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
1615 &((struct iphdr *)oiph)->saddr,
1616 ((struct iphdr *)oiph)->tos);
1617 else
1618 net_info_ratelimited("non-ECT from %pI6\n",
1619 &((struct ipv6hdr *)oiph)->saddr);
1620 }
1621 return err <= 1;
1622}
1623
stephen hemmingerd3428942012-10-01 12:32:35 +00001624/* Callback from net/ipv4/udp.c to receive packets */
Jiri Bencf2d1968ec2016-02-23 18:02:58 +01001625static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)
stephen hemmingerd3428942012-10-01 12:32:35 +00001626{
Jiri Bencf2d1968ec2016-02-23 18:02:58 +01001627 struct pcpu_sw_netstats *stats;
Jiri Bencc9e78ef2016-02-18 11:22:51 +01001628 struct vxlan_dev *vxlan;
Pravin B Shelar5cfccc52013-08-19 11:23:02 -07001629 struct vxlan_sock *vs;
Jiri Bencf14eceb2016-02-16 21:59:01 +01001630 struct vxlanhdr unparsed;
Thomas Grafee122c72015-07-21 10:43:58 +02001631 struct vxlan_metadata _md;
1632 struct vxlan_metadata *md = &_md;
Jiri Benc61618ee2016-04-11 17:06:08 +02001633 __be16 protocol = htons(ETH_P_TEB);
Jiri Bence1e53142016-04-05 14:47:13 +02001634 bool raw_proto = false;
Jiri Bencf2d1968ec2016-02-23 18:02:58 +01001635 void *oiph;
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001636 __be32 vni = 0;
stephen hemmingerd3428942012-10-01 12:32:35 +00001637
Jiri Bence1e53142016-04-05 14:47:13 +02001638 /* Need UDP and VXLAN header to be present */
Pravin B Shelar7ce04752013-08-19 11:22:54 -07001639 if (!pskb_may_pull(skb, VXLAN_HLEN))
Hannes Frederic Sowae5aed002016-05-19 15:58:33 +02001640 goto drop;
stephen hemmingerd3428942012-10-01 12:32:35 +00001641
Jiri Bencf14eceb2016-02-16 21:59:01 +01001642 unparsed = *vxlan_hdr(skb);
Jiri Benc288b01c2016-02-16 21:59:02 +01001643 /* VNI flag always required to be set */
1644 if (!(unparsed.vx_flags & VXLAN_HF_VNI)) {
1645 netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",
1646 ntohl(vxlan_hdr(skb)->vx_flags),
1647 ntohl(vxlan_hdr(skb)->vx_vni));
1648 /* Return non vxlan pkt */
Hannes Frederic Sowae5aed002016-05-19 15:58:33 +02001649 goto drop;
stephen hemmingerd3428942012-10-01 12:32:35 +00001650 }
Jiri Benc288b01c2016-02-16 21:59:02 +01001651 unparsed.vx_flags &= ~VXLAN_HF_VNI;
1652 unparsed.vx_vni &= ~VXLAN_VNI_MASK;
stephen hemmingerd3428942012-10-01 12:32:35 +00001653
Pravin B Shelar559835ea2013-09-24 10:25:40 -07001654 vs = rcu_dereference_sk_user_data(sk);
Pravin B Shelar5cfccc52013-08-19 11:23:02 -07001655 if (!vs)
stephen hemmingerd3428942012-10-01 12:32:35 +00001656 goto drop;
Pravin B Shelar5cfccc52013-08-19 11:23:02 -07001657
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001658 vni = vxlan_vni(vxlan_hdr(skb)->vx_vni);
1659
Matthias Schiffer49f810f2017-06-19 10:04:00 +02001660 vxlan = vxlan_vs_find_vni(vs, skb->dev->ifindex, vni);
Jiri Bencc9e78ef2016-02-18 11:22:51 +01001661 if (!vxlan)
1662 goto drop;
1663
Jiri Bence1e53142016-04-05 14:47:13 +02001664 /* For backwards compatibility, only allow reserved fields to be
1665 * used by VXLAN extensions if explicitly requested.
1666 */
1667 if (vs->flags & VXLAN_F_GPE) {
1668 if (!vxlan_parse_gpe_hdr(&unparsed, &protocol, skb, vs->flags))
1669 goto drop;
1670 raw_proto = true;
1671 }
1672
1673 if (__iptunnel_pull_header(skb, VXLAN_HLEN, protocol, raw_proto,
1674 !net_eq(vxlan->net, dev_net(vxlan->dev))))
1675 goto drop;
Jiri Bencc9e78ef2016-02-18 11:22:51 +01001676
Thomas Grafee122c72015-07-21 10:43:58 +02001677 if (vxlan_collect_metadata(vs)) {
Jiri Benc10a5af22016-02-23 18:02:59 +01001678 struct metadata_dst *tun_dst;
Jiri Benc07dabf22016-02-18 19:19:29 +01001679
Pravin B Shelarc29a70d2015-08-26 23:46:50 -07001680 tun_dst = udp_tun_rx_dst(skb, vxlan_get_sk_family(vs), TUNNEL_KEY,
Amir Vadaid817f432016-09-08 16:23:45 +03001681 key32_to_tunnel_id(vni), sizeof(*md));
Pravin B Shelarc29a70d2015-08-26 23:46:50 -07001682
Thomas Grafee122c72015-07-21 10:43:58 +02001683 if (!tun_dst)
1684 goto drop;
1685
Geert Uytterhoeven0f1b7352015-09-04 12:49:32 +02001686 md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
Jiri Benc10a5af22016-02-23 18:02:59 +01001687
1688 skb_dst_set(skb, (struct dst_entry *)tun_dst);
Thomas Grafee122c72015-07-21 10:43:58 +02001689 } else {
1690 memset(md, 0, sizeof(*md));
1691 }
1692
Jiri Bencf14eceb2016-02-16 21:59:01 +01001693 if (vs->flags & VXLAN_F_REMCSUM_RX)
1694 if (!vxlan_remcsum(&unparsed, skb, vs->flags))
1695 goto drop;
1696 if (vs->flags & VXLAN_F_GBP)
Jiri Benc10a5af22016-02-23 18:02:59 +01001697 vxlan_parse_gbp_hdr(&unparsed, skb, vs->flags, md);
Jiri Bence1e53142016-04-05 14:47:13 +02001698 /* Note that GBP and GPE can never be active together. This is
1699 * ensured in vxlan_dev_configure.
1700 */
Thomas Graf35114942015-01-15 03:53:55 +01001701
Jiri Bencf14eceb2016-02-16 21:59:01 +01001702 if (unparsed.vx_flags || unparsed.vx_vni) {
Tom Herbert3bf39472015-01-08 12:31:18 -08001703 /* If there are any unprocessed flags remaining treat
1704 * this as a malformed packet. This behavior diverges from
1705 * VXLAN RFC (RFC7348) which stipulates that bits in reserved
1706 * in reserved fields are to be ignored. The approach here
Simon Hormanc4b49512015-04-02 11:17:58 +09001707 * maintains compatibility with previous stack code, and also
Tom Herbert3bf39472015-01-08 12:31:18 -08001708 * is more robust and provides a little more security in
1709 * adding extensions to VXLAN.
1710 */
Jiri Benc288b01c2016-02-16 21:59:02 +01001711 goto drop;
Tom Herbert3bf39472015-01-08 12:31:18 -08001712 }
1713
Jiri Bence1e53142016-04-05 14:47:13 +02001714 if (!raw_proto) {
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001715 if (!vxlan_set_mac(vxlan, vs, skb, vni))
Jiri Bence1e53142016-04-05 14:47:13 +02001716 goto drop;
1717 } else {
Jiri Benc8be0cfa2016-05-13 10:48:42 +02001718 skb_reset_mac_header(skb);
Jiri Bence1e53142016-04-05 14:47:13 +02001719 skb->dev = vxlan->dev;
1720 skb->pkt_type = PACKET_HOST;
1721 }
Jiri Bencf2d1968ec2016-02-23 18:02:58 +01001722
Jiri Bencf2d1968ec2016-02-23 18:02:58 +01001723 oiph = skb_network_header(skb);
1724 skb_reset_network_header(skb);
1725
1726 if (!vxlan_ecn_decapsulate(vs, oiph, skb)) {
1727 ++vxlan->dev->stats.rx_frame_errors;
1728 ++vxlan->dev->stats.rx_errors;
1729 goto drop;
1730 }
1731
1732 stats = this_cpu_ptr(vxlan->dev->tstats);
1733 u64_stats_update_begin(&stats->syncp);
1734 stats->rx_packets++;
1735 stats->rx_bytes += skb->len;
1736 u64_stats_update_end(&stats->syncp);
1737
1738 gro_cells_receive(&vxlan->gro_cells, skb);
Pravin B Shelar5cfccc52013-08-19 11:23:02 -07001739 return 0;
1740
1741drop:
Jiri Benc288b01c2016-02-16 21:59:02 +01001742 /* Consume bad packet */
1743 kfree_skb(skb);
1744 return 0;
Pravin B Shelar5cfccc52013-08-19 11:23:02 -07001745}
1746
Stefano Brivioc3a43b92018-11-08 12:19:15 +01001747/* Callback from net/ipv{4,6}/udp.c to check that we have a VNI for errors */
1748static int vxlan_err_lookup(struct sock *sk, struct sk_buff *skb)
1749{
1750 struct vxlan_dev *vxlan;
1751 struct vxlan_sock *vs;
1752 struct vxlanhdr *hdr;
1753 __be32 vni;
1754
1755 if (skb->len < VXLAN_HLEN)
1756 return -EINVAL;
1757
1758 hdr = vxlan_hdr(skb);
1759
1760 if (!(hdr->vx_flags & VXLAN_HF_VNI))
1761 return -EINVAL;
1762
1763 vs = rcu_dereference_sk_user_data(sk);
1764 if (!vs)
1765 return -ENOENT;
1766
1767 vni = vxlan_vni(hdr->vx_vni);
1768 vxlan = vxlan_vs_find_vni(vs, skb->dev->ifindex, vni);
1769 if (!vxlan)
1770 return -ENOENT;
1771
1772 return 0;
1773}
1774
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001775static int arp_reduce(struct net_device *dev, struct sk_buff *skb, __be32 vni)
David Stevense4f67ad2012-11-20 02:50:14 +00001776{
1777 struct vxlan_dev *vxlan = netdev_priv(dev);
1778 struct arphdr *parp;
1779 u8 *arpptr, *sha;
1780 __be32 sip, tip;
1781 struct neighbour *n;
1782
1783 if (dev->flags & IFF_NOARP)
1784 goto out;
1785
1786 if (!pskb_may_pull(skb, arp_hdr_len(dev))) {
1787 dev->stats.tx_dropped++;
1788 goto out;
1789 }
1790 parp = arp_hdr(skb);
1791
1792 if ((parp->ar_hrd != htons(ARPHRD_ETHER) &&
1793 parp->ar_hrd != htons(ARPHRD_IEEE802)) ||
1794 parp->ar_pro != htons(ETH_P_IP) ||
1795 parp->ar_op != htons(ARPOP_REQUEST) ||
1796 parp->ar_hln != dev->addr_len ||
1797 parp->ar_pln != 4)
1798 goto out;
1799 arpptr = (u8 *)parp + sizeof(struct arphdr);
1800 sha = arpptr;
1801 arpptr += dev->addr_len; /* sha */
1802 memcpy(&sip, arpptr, sizeof(sip));
1803 arpptr += sizeof(sip);
1804 arpptr += dev->addr_len; /* tha */
1805 memcpy(&tip, arpptr, sizeof(tip));
1806
1807 if (ipv4_is_loopback(tip) ||
1808 ipv4_is_multicast(tip))
1809 goto out;
1810
1811 n = neigh_lookup(&arp_tbl, &tip, dev);
1812
1813 if (n) {
David Stevense4f67ad2012-11-20 02:50:14 +00001814 struct vxlan_fdb *f;
1815 struct sk_buff *reply;
1816
1817 if (!(n->nud_state & NUD_CONNECTED)) {
1818 neigh_release(n);
1819 goto out;
1820 }
1821
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001822 f = vxlan_find_mac(vxlan, n->ha, vni);
Cong Wange4c7ed42013-08-31 13:44:33 +08001823 if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
David Stevense4f67ad2012-11-20 02:50:14 +00001824 /* bridge-local neighbor */
1825 neigh_release(n);
1826 goto out;
1827 }
1828
1829 reply = arp_create(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
1830 n->ha, sha);
1831
1832 neigh_release(n);
1833
David Stevens73461352014-03-18 12:32:29 -04001834 if (reply == NULL)
1835 goto out;
1836
David Stevense4f67ad2012-11-20 02:50:14 +00001837 skb_reset_mac_header(reply);
1838 __skb_pull(reply, skb_network_offset(reply));
1839 reply->ip_summed = CHECKSUM_UNNECESSARY;
1840 reply->pkt_type = PACKET_HOST;
1841
1842 if (netif_rx_ni(reply) == NET_RX_DROP)
1843 dev->stats.rx_dropped++;
Matthias Schifferdc5321d2017-06-19 10:03:56 +02001844 } else if (vxlan->cfg.flags & VXLAN_F_L3MISS) {
Cong Wange4c7ed42013-08-31 13:44:33 +08001845 union vxlan_addr ipa = {
1846 .sin.sin_addr.s_addr = tip,
Gerhard Stenzela45e92a2014-08-22 21:34:16 +02001847 .sin.sin_family = AF_INET,
Cong Wange4c7ed42013-08-31 13:44:33 +08001848 };
1849
1850 vxlan_ip_miss(dev, &ipa);
1851 }
David Stevense4f67ad2012-11-20 02:50:14 +00001852out:
1853 consume_skb(skb);
1854 return NETDEV_TX_OK;
1855}
1856
Cong Wangf564f452013-08-31 13:44:36 +08001857#if IS_ENABLED(CONFIG_IPV6)
David Stevens4b29dba2014-03-24 10:39:58 -04001858static struct sk_buff *vxlan_na_create(struct sk_buff *request,
1859 struct neighbour *n, bool isrouter)
1860{
1861 struct net_device *dev = request->dev;
1862 struct sk_buff *reply;
1863 struct nd_msg *ns, *na;
1864 struct ipv6hdr *pip6;
1865 u8 *daddr;
1866 int na_olen = 8; /* opt hdr + ETH_ALEN for target */
1867 int ns_olen;
1868 int i, len;
1869
Vincent Bernatf1fb08f2017-04-02 11:00:06 +02001870 if (dev == NULL || !pskb_may_pull(request, request->len))
David Stevens4b29dba2014-03-24 10:39:58 -04001871 return NULL;
1872
1873 len = LL_RESERVED_SPACE(dev) + sizeof(struct ipv6hdr) +
1874 sizeof(*na) + na_olen + dev->needed_tailroom;
1875 reply = alloc_skb(len, GFP_ATOMIC);
1876 if (reply == NULL)
1877 return NULL;
1878
1879 reply->protocol = htons(ETH_P_IPV6);
1880 reply->dev = dev;
1881 skb_reserve(reply, LL_RESERVED_SPACE(request->dev));
1882 skb_push(reply, sizeof(struct ethhdr));
Zhang Shengju6297b912016-03-03 01:16:54 +00001883 skb_reset_mac_header(reply);
David Stevens4b29dba2014-03-24 10:39:58 -04001884
Vincent Bernatf1fb08f2017-04-02 11:00:06 +02001885 ns = (struct nd_msg *)(ipv6_hdr(request) + 1);
David Stevens4b29dba2014-03-24 10:39:58 -04001886
1887 daddr = eth_hdr(request)->h_source;
Vincent Bernatf1fb08f2017-04-02 11:00:06 +02001888 ns_olen = request->len - skb_network_offset(request) -
1889 sizeof(struct ipv6hdr) - sizeof(*ns);
David Stevens4b29dba2014-03-24 10:39:58 -04001890 for (i = 0; i < ns_olen-1; i += (ns->opt[i+1]<<3)) {
1891 if (ns->opt[i] == ND_OPT_SOURCE_LL_ADDR) {
1892 daddr = ns->opt + i + sizeof(struct nd_opt_hdr);
1893 break;
1894 }
1895 }
1896
1897 /* Ethernet header */
1898 ether_addr_copy(eth_hdr(reply)->h_dest, daddr);
1899 ether_addr_copy(eth_hdr(reply)->h_source, n->ha);
1900 eth_hdr(reply)->h_proto = htons(ETH_P_IPV6);
1901 reply->protocol = htons(ETH_P_IPV6);
1902
1903 skb_pull(reply, sizeof(struct ethhdr));
Zhang Shengju6297b912016-03-03 01:16:54 +00001904 skb_reset_network_header(reply);
David Stevens4b29dba2014-03-24 10:39:58 -04001905 skb_put(reply, sizeof(struct ipv6hdr));
1906
1907 /* IPv6 header */
1908
1909 pip6 = ipv6_hdr(reply);
1910 memset(pip6, 0, sizeof(struct ipv6hdr));
1911 pip6->version = 6;
1912 pip6->priority = ipv6_hdr(request)->priority;
1913 pip6->nexthdr = IPPROTO_ICMPV6;
1914 pip6->hop_limit = 255;
1915 pip6->daddr = ipv6_hdr(request)->saddr;
1916 pip6->saddr = *(struct in6_addr *)n->primary_key;
1917
1918 skb_pull(reply, sizeof(struct ipv6hdr));
Zhang Shengju6297b912016-03-03 01:16:54 +00001919 skb_reset_transport_header(reply);
David Stevens4b29dba2014-03-24 10:39:58 -04001920
David Stevens4b29dba2014-03-24 10:39:58 -04001921 /* Neighbor Advertisement */
Johannes Bergb080db52017-06-16 14:29:19 +02001922 na = skb_put_zero(reply, sizeof(*na) + na_olen);
David Stevens4b29dba2014-03-24 10:39:58 -04001923 na->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;
1924 na->icmph.icmp6_router = isrouter;
1925 na->icmph.icmp6_override = 1;
1926 na->icmph.icmp6_solicited = 1;
1927 na->target = ns->target;
1928 ether_addr_copy(&na->opt[2], n->ha);
1929 na->opt[0] = ND_OPT_TARGET_LL_ADDR;
1930 na->opt[1] = na_olen >> 3;
1931
1932 na->icmph.icmp6_cksum = csum_ipv6_magic(&pip6->saddr,
1933 &pip6->daddr, sizeof(*na)+na_olen, IPPROTO_ICMPV6,
1934 csum_partial(na, sizeof(*na)+na_olen, 0));
1935
1936 pip6->payload_len = htons(sizeof(*na)+na_olen);
1937
1938 skb_push(reply, sizeof(struct ipv6hdr));
1939
1940 reply->ip_summed = CHECKSUM_UNNECESSARY;
1941
1942 return reply;
1943}
1944
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001945static int neigh_reduce(struct net_device *dev, struct sk_buff *skb, __be32 vni)
Cong Wangf564f452013-08-31 13:44:36 +08001946{
1947 struct vxlan_dev *vxlan = netdev_priv(dev);
Roopa Prabhu8dcd81a2017-02-20 08:41:16 -08001948 const struct in6_addr *daddr;
Xin Long8bff36852017-11-11 19:58:50 +08001949 const struct ipv6hdr *iphdr;
David Stevens4b29dba2014-03-24 10:39:58 -04001950 struct inet6_dev *in6_dev;
Xin Long8bff36852017-11-11 19:58:50 +08001951 struct neighbour *n;
1952 struct nd_msg *msg;
Cong Wangf564f452013-08-31 13:44:36 +08001953
1954 in6_dev = __in6_dev_get(dev);
1955 if (!in6_dev)
1956 goto out;
1957
Cong Wangf564f452013-08-31 13:44:36 +08001958 iphdr = ipv6_hdr(skb);
Cong Wangf564f452013-08-31 13:44:36 +08001959 daddr = &iphdr->daddr;
Vincent Bernatf1fb08f2017-04-02 11:00:06 +02001960 msg = (struct nd_msg *)(iphdr + 1);
Cong Wangf564f452013-08-31 13:44:36 +08001961
David Stevens4b29dba2014-03-24 10:39:58 -04001962 if (ipv6_addr_loopback(daddr) ||
1963 ipv6_addr_is_multicast(&msg->target))
1964 goto out;
1965
1966 n = neigh_lookup(ipv6_stub->nd_tbl, &msg->target, dev);
Cong Wangf564f452013-08-31 13:44:36 +08001967
1968 if (n) {
1969 struct vxlan_fdb *f;
David Stevens4b29dba2014-03-24 10:39:58 -04001970 struct sk_buff *reply;
Cong Wangf564f452013-08-31 13:44:36 +08001971
1972 if (!(n->nud_state & NUD_CONNECTED)) {
1973 neigh_release(n);
1974 goto out;
1975 }
1976
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08001977 f = vxlan_find_mac(vxlan, n->ha, vni);
Cong Wangf564f452013-08-31 13:44:36 +08001978 if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
1979 /* bridge-local neighbor */
1980 neigh_release(n);
1981 goto out;
1982 }
1983
David Stevens4b29dba2014-03-24 10:39:58 -04001984 reply = vxlan_na_create(skb, n,
1985 !!(f ? f->flags & NTF_ROUTER : 0));
1986
Cong Wangf564f452013-08-31 13:44:36 +08001987 neigh_release(n);
David Stevens4b29dba2014-03-24 10:39:58 -04001988
1989 if (reply == NULL)
1990 goto out;
1991
1992 if (netif_rx_ni(reply) == NET_RX_DROP)
1993 dev->stats.rx_dropped++;
1994
Matthias Schifferdc5321d2017-06-19 10:03:56 +02001995 } else if (vxlan->cfg.flags & VXLAN_F_L3MISS) {
David Stevens4b29dba2014-03-24 10:39:58 -04001996 union vxlan_addr ipa = {
1997 .sin6.sin6_addr = msg->target,
Gerhard Stenzela45e92a2014-08-22 21:34:16 +02001998 .sin6.sin6_family = AF_INET6,
David Stevens4b29dba2014-03-24 10:39:58 -04001999 };
2000
Cong Wangf564f452013-08-31 13:44:36 +08002001 vxlan_ip_miss(dev, &ipa);
2002 }
2003
2004out:
2005 consume_skb(skb);
2006 return NETDEV_TX_OK;
2007}
2008#endif
2009
David Stevense4f67ad2012-11-20 02:50:14 +00002010static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)
2011{
2012 struct vxlan_dev *vxlan = netdev_priv(dev);
2013 struct neighbour *n;
David Stevense4f67ad2012-11-20 02:50:14 +00002014
2015 if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))
2016 return false;
2017
2018 n = NULL;
2019 switch (ntohs(eth_hdr(skb)->h_proto)) {
2020 case ETH_P_IP:
Cong Wange15a00a2013-08-31 13:44:34 +08002021 {
2022 struct iphdr *pip;
2023
David Stevense4f67ad2012-11-20 02:50:14 +00002024 if (!pskb_may_pull(skb, sizeof(struct iphdr)))
2025 return false;
2026 pip = ip_hdr(skb);
2027 n = neigh_lookup(&arp_tbl, &pip->daddr, dev);
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002028 if (!n && (vxlan->cfg.flags & VXLAN_F_L3MISS)) {
Cong Wange4c7ed42013-08-31 13:44:33 +08002029 union vxlan_addr ipa = {
2030 .sin.sin_addr.s_addr = pip->daddr,
Gerhard Stenzela45e92a2014-08-22 21:34:16 +02002031 .sin.sin_family = AF_INET,
Cong Wange4c7ed42013-08-31 13:44:33 +08002032 };
2033
2034 vxlan_ip_miss(dev, &ipa);
2035 return false;
2036 }
2037
David Stevense4f67ad2012-11-20 02:50:14 +00002038 break;
Cong Wange15a00a2013-08-31 13:44:34 +08002039 }
2040#if IS_ENABLED(CONFIG_IPV6)
2041 case ETH_P_IPV6:
2042 {
2043 struct ipv6hdr *pip6;
2044
2045 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
2046 return false;
2047 pip6 = ipv6_hdr(skb);
2048 n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002049 if (!n && (vxlan->cfg.flags & VXLAN_F_L3MISS)) {
Cong Wange15a00a2013-08-31 13:44:34 +08002050 union vxlan_addr ipa = {
2051 .sin6.sin6_addr = pip6->daddr,
Gerhard Stenzela45e92a2014-08-22 21:34:16 +02002052 .sin6.sin6_family = AF_INET6,
Cong Wange15a00a2013-08-31 13:44:34 +08002053 };
2054
2055 vxlan_ip_miss(dev, &ipa);
2056 return false;
2057 }
2058
2059 break;
2060 }
2061#endif
David Stevense4f67ad2012-11-20 02:50:14 +00002062 default:
2063 return false;
2064 }
2065
2066 if (n) {
2067 bool diff;
2068
Joe Perches7367d0b2013-09-01 11:51:23 -07002069 diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);
David Stevense4f67ad2012-11-20 02:50:14 +00002070 if (diff) {
2071 memcpy(eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,
2072 dev->addr_len);
2073 memcpy(eth_hdr(skb)->h_dest, n->ha, dev->addr_len);
2074 }
2075 neigh_release(n);
2076 return diff;
Cong Wange4c7ed42013-08-31 13:44:33 +08002077 }
2078
David Stevense4f67ad2012-11-20 02:50:14 +00002079 return false;
2080}
2081
Tom Herbertaf33c1a2015-01-20 11:23:05 -08002082static void vxlan_build_gbp_hdr(struct vxlanhdr *vxh, u32 vxflags,
Thomas Graf35114942015-01-15 03:53:55 +01002083 struct vxlan_metadata *md)
2084{
2085 struct vxlanhdr_gbp *gbp;
2086
Thomas Grafdb79a622015-02-04 17:00:04 +01002087 if (!md->gbp)
2088 return;
2089
Thomas Graf35114942015-01-15 03:53:55 +01002090 gbp = (struct vxlanhdr_gbp *)vxh;
Jiri Benc54bfd872016-02-16 21:58:58 +01002091 vxh->vx_flags |= VXLAN_HF_GBP;
Thomas Graf35114942015-01-15 03:53:55 +01002092
2093 if (md->gbp & VXLAN_GBP_DONT_LEARN)
2094 gbp->dont_learn = 1;
2095
2096 if (md->gbp & VXLAN_GBP_POLICY_APPLIED)
2097 gbp->policy_applied = 1;
2098
2099 gbp->policy_id = htons(md->gbp & VXLAN_GBP_ID_MASK);
2100}
2101
Jiri Bence1e53142016-04-05 14:47:13 +02002102static int vxlan_build_gpe_hdr(struct vxlanhdr *vxh, u32 vxflags,
2103 __be16 protocol)
2104{
2105 struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)vxh;
2106
2107 gpe->np_applied = 1;
Jiri Bencfa20e0e2017-08-28 21:43:22 +02002108 gpe->next_protocol = tun_p_from_eth_p(protocol);
2109 if (!gpe->next_protocol)
2110 return -EPFNOSUPPORT;
2111 return 0;
Jiri Bence1e53142016-04-05 14:47:13 +02002112}
2113
Jiri Bencf491e562016-02-02 18:09:16 +01002114static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,
2115 int iphdr_len, __be32 vni,
2116 struct vxlan_metadata *md, u32 vxflags,
Jiri Bencb4ed5ca2016-02-02 18:09:15 +01002117 bool udp_sum)
Cong Wange4c7ed42013-08-31 13:44:33 +08002118{
Cong Wange4c7ed42013-08-31 13:44:33 +08002119 struct vxlanhdr *vxh;
Cong Wange4c7ed42013-08-31 13:44:33 +08002120 int min_headroom;
2121 int err;
Tom Herbertdfd86452015-01-12 17:00:38 -08002122 int type = udp_sum ? SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
Jiri Bence1e53142016-04-05 14:47:13 +02002123 __be16 inner_protocol = htons(ETH_P_TEB);
Cong Wange4c7ed42013-08-31 13:44:33 +08002124
Tom Herbertaf33c1a2015-01-20 11:23:05 -08002125 if ((vxflags & VXLAN_F_REMCSUM_TX) &&
Tom Herbertdfd86452015-01-12 17:00:38 -08002126 skb->ip_summed == CHECKSUM_PARTIAL) {
2127 int csum_start = skb_checksum_start_offset(skb);
2128
2129 if (csum_start <= VXLAN_MAX_REMCSUM_START &&
2130 !(csum_start & VXLAN_RCO_SHIFT_MASK) &&
2131 (skb->csum_offset == offsetof(struct udphdr, check) ||
Edward Creeb5708502016-02-11 20:57:17 +00002132 skb->csum_offset == offsetof(struct tcphdr, check)))
Tom Herbertdfd86452015-01-12 17:00:38 -08002133 type |= SKB_GSO_TUNNEL_REMCSUM;
Tom Herbertdfd86452015-01-12 17:00:38 -08002134 }
2135
Cong Wange4c7ed42013-08-31 13:44:33 +08002136 min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
pravin shelar4a4f86c2016-11-13 20:43:52 -08002137 + VXLAN_HLEN + iphdr_len;
Pravin B Shelar649c5b82013-08-19 11:23:22 -07002138
2139 /* Need space for new headers (invalidates iph ptr) */
2140 err = skb_cow_head(skb, min_headroom);
Jiri Bence1e53142016-04-05 14:47:13 +02002141 if (unlikely(err))
pravin shelarc46b7892016-11-13 20:43:54 -08002142 return err;
Pravin B Shelar649c5b82013-08-19 11:23:22 -07002143
Alexander Duyckaed069d2016-04-14 15:33:37 -04002144 err = iptunnel_handle_offloads(skb, type);
2145 if (err)
pravin shelarc46b7892016-11-13 20:43:54 -08002146 return err;
Jesse Grossb736a622015-04-09 11:19:14 -07002147
Johannes Bergd58ff352017-06-16 14:29:23 +02002148 vxh = __skb_push(skb, sizeof(*vxh));
Jiri Benc54bfd872016-02-16 21:58:58 +01002149 vxh->vx_flags = VXLAN_HF_VNI;
2150 vxh->vx_vni = vxlan_vni_field(vni);
Pravin B Shelar49560532013-08-19 11:23:17 -07002151
Tom Herbertdfd86452015-01-12 17:00:38 -08002152 if (type & SKB_GSO_TUNNEL_REMCSUM) {
Jiri Benc54bfd872016-02-16 21:58:58 +01002153 unsigned int start;
Tom Herbertdfd86452015-01-12 17:00:38 -08002154
Jiri Benc54bfd872016-02-16 21:58:58 +01002155 start = skb_checksum_start_offset(skb) - sizeof(struct vxlanhdr);
2156 vxh->vx_vni |= vxlan_compute_rco(start, skb->csum_offset);
2157 vxh->vx_flags |= VXLAN_HF_RCO;
Tom Herbertdfd86452015-01-12 17:00:38 -08002158
2159 if (!skb_is_gso(skb)) {
2160 skb->ip_summed = CHECKSUM_NONE;
2161 skb->encapsulation = 0;
2162 }
2163 }
2164
Tom Herbertaf33c1a2015-01-20 11:23:05 -08002165 if (vxflags & VXLAN_F_GBP)
2166 vxlan_build_gbp_hdr(vxh, vxflags, md);
Jiri Bence1e53142016-04-05 14:47:13 +02002167 if (vxflags & VXLAN_F_GPE) {
2168 err = vxlan_build_gpe_hdr(vxh, vxflags, skb->protocol);
2169 if (err < 0)
pravin shelarc46b7892016-11-13 20:43:54 -08002170 return err;
Jiri Bence1e53142016-04-05 14:47:13 +02002171 inner_protocol = skb->protocol;
2172 }
Thomas Graf35114942015-01-15 03:53:55 +01002173
Jiri Bence1e53142016-04-05 14:47:13 +02002174 skb_set_inner_protocol(skb, inner_protocol);
Pravin B Shelar039f5062015-12-24 14:34:54 -08002175 return 0;
Pravin B Shelar49560532013-08-19 11:23:17 -07002176}
Pravin B Shelar49560532013-08-19 11:23:17 -07002177
pravin shelar655c3de2016-11-13 20:43:55 -08002178static struct rtable *vxlan_get_route(struct vxlan_dev *vxlan, struct net_device *dev,
2179 struct vxlan_sock *sock4,
Jiri Benc1a8496b2016-02-02 18:09:14 +01002180 struct sk_buff *skb, int oif, u8 tos,
Martynas Pumputis4ecb1d82017-01-11 15:18:53 +00002181 __be32 daddr, __be32 *saddr, __be16 dport, __be16 sport,
Paolo Abeni0c1d70a2016-02-12 15:43:56 +01002182 struct dst_cache *dst_cache,
Daniel Borkmanndb3c6132016-03-04 15:15:07 +01002183 const struct ip_tunnel_info *info)
Jiri Benc1a8496b2016-02-02 18:09:14 +01002184{
Daniel Borkmanndb3c6132016-03-04 15:15:07 +01002185 bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
Jiri Benc1a8496b2016-02-02 18:09:14 +01002186 struct rtable *rt = NULL;
2187 struct flowi4 fl4;
2188
pravin shelar655c3de2016-11-13 20:43:55 -08002189 if (!sock4)
2190 return ERR_PTR(-EIO);
2191
Daniel Borkmanndb3c6132016-03-04 15:15:07 +01002192 if (tos && !info)
2193 use_cache = false;
2194 if (use_cache) {
Paolo Abeni0c1d70a2016-02-12 15:43:56 +01002195 rt = dst_cache_get_ip4(dst_cache, saddr);
2196 if (rt)
2197 return rt;
2198 }
2199
Jiri Benc1a8496b2016-02-02 18:09:14 +01002200 memset(&fl4, 0, sizeof(fl4));
2201 fl4.flowi4_oif = oif;
2202 fl4.flowi4_tos = RT_TOS(tos);
2203 fl4.flowi4_mark = skb->mark;
2204 fl4.flowi4_proto = IPPROTO_UDP;
2205 fl4.daddr = daddr;
pravin shelar272d96a2016-08-05 17:45:36 -07002206 fl4.saddr = *saddr;
Martynas Pumputis4ecb1d82017-01-11 15:18:53 +00002207 fl4.fl4_dport = dport;
2208 fl4.fl4_sport = sport;
Jiri Benc1a8496b2016-02-02 18:09:14 +01002209
2210 rt = ip_route_output_key(vxlan->net, &fl4);
pravin shelar655c3de2016-11-13 20:43:55 -08002211 if (likely(!IS_ERR(rt))) {
2212 if (rt->dst.dev == dev) {
2213 netdev_dbg(dev, "circular route to %pI4\n", &daddr);
2214 ip_rt_put(rt);
2215 return ERR_PTR(-ELOOP);
2216 }
2217
Jiri Benc1a8496b2016-02-02 18:09:14 +01002218 *saddr = fl4.saddr;
Paolo Abeni0c1d70a2016-02-12 15:43:56 +01002219 if (use_cache)
2220 dst_cache_set_ip4(dst_cache, &rt->dst, fl4.saddr);
pravin shelar655c3de2016-11-13 20:43:55 -08002221 } else {
2222 netdev_dbg(dev, "no route to %pI4\n", &daddr);
2223 return ERR_PTR(-ENETUNREACH);
Paolo Abeni0c1d70a2016-02-12 15:43:56 +01002224 }
Jiri Benc1a8496b2016-02-02 18:09:14 +01002225 return rt;
2226}
2227
Jiri Bence5d4b292015-12-07 13:04:30 +01002228#if IS_ENABLED(CONFIG_IPV6)
2229static struct dst_entry *vxlan6_get_route(struct vxlan_dev *vxlan,
pravin shelar655c3de2016-11-13 20:43:55 -08002230 struct net_device *dev,
pravin shelar03dc52a2016-11-13 20:43:53 -08002231 struct vxlan_sock *sock6,
Daniel Borkmann14006152016-03-04 15:15:08 +01002232 struct sk_buff *skb, int oif, u8 tos,
Daniel Borkmanne7f70af2016-03-09 03:00:03 +01002233 __be32 label,
Jiri Bence5d4b292015-12-07 13:04:30 +01002234 const struct in6_addr *daddr,
Paolo Abeni0c1d70a2016-02-12 15:43:56 +01002235 struct in6_addr *saddr,
Martynas Pumputis4ecb1d82017-01-11 15:18:53 +00002236 __be16 dport, __be16 sport,
Daniel Borkmanndb3c6132016-03-04 15:15:07 +01002237 struct dst_cache *dst_cache,
2238 const struct ip_tunnel_info *info)
Jiri Bence5d4b292015-12-07 13:04:30 +01002239{
Daniel Borkmanndb3c6132016-03-04 15:15:07 +01002240 bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
Jiri Bence5d4b292015-12-07 13:04:30 +01002241 struct dst_entry *ndst;
2242 struct flowi6 fl6;
2243 int err;
2244
pravin shelarc6fcc4f2016-10-28 09:59:15 -07002245 if (!sock6)
2246 return ERR_PTR(-EIO);
2247
Daniel Borkmann14006152016-03-04 15:15:08 +01002248 if (tos && !info)
2249 use_cache = false;
Daniel Borkmanndb3c6132016-03-04 15:15:07 +01002250 if (use_cache) {
Paolo Abeni0c1d70a2016-02-12 15:43:56 +01002251 ndst = dst_cache_get_ip6(dst_cache, saddr);
2252 if (ndst)
2253 return ndst;
2254 }
2255
Jiri Bence5d4b292015-12-07 13:04:30 +01002256 memset(&fl6, 0, sizeof(fl6));
2257 fl6.flowi6_oif = oif;
2258 fl6.daddr = *daddr;
pravin shelar272d96a2016-08-05 17:45:36 -07002259 fl6.saddr = *saddr;
Daniel Borkmanneaa93bf2016-03-18 18:37:57 +01002260 fl6.flowlabel = ip6_make_flowinfo(RT_TOS(tos), label);
Jiri Bence5d4b292015-12-07 13:04:30 +01002261 fl6.flowi6_mark = skb->mark;
2262 fl6.flowi6_proto = IPPROTO_UDP;
Martynas Pumputis4ecb1d82017-01-11 15:18:53 +00002263 fl6.fl6_dport = dport;
2264 fl6.fl6_sport = sport;
Jiri Bence5d4b292015-12-07 13:04:30 +01002265
2266 err = ipv6_stub->ipv6_dst_lookup(vxlan->net,
pravin shelarc6fcc4f2016-10-28 09:59:15 -07002267 sock6->sock->sk,
Jiri Bence5d4b292015-12-07 13:04:30 +01002268 &ndst, &fl6);
pravin shelar655c3de2016-11-13 20:43:55 -08002269 if (unlikely(err < 0)) {
2270 netdev_dbg(dev, "no route to %pI6\n", daddr);
2271 return ERR_PTR(-ENETUNREACH);
2272 }
2273
2274 if (unlikely(ndst->dev == dev)) {
2275 netdev_dbg(dev, "circular route to %pI6\n", daddr);
2276 dst_release(ndst);
2277 return ERR_PTR(-ELOOP);
2278 }
Jiri Bence5d4b292015-12-07 13:04:30 +01002279
2280 *saddr = fl6.saddr;
Daniel Borkmanndb3c6132016-03-04 15:15:07 +01002281 if (use_cache)
Paolo Abeni0c1d70a2016-02-12 15:43:56 +01002282 dst_cache_set_ip6(dst_cache, ndst, saddr);
Jiri Bence5d4b292015-12-07 13:04:30 +01002283 return ndst;
2284}
2285#endif
2286
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002287/* Bypass encapsulation if the destination is local */
2288static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002289 struct vxlan_dev *dst_vxlan, __be32 vni)
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002290{
Li RongQing8f849852014-01-04 13:57:59 +08002291 struct pcpu_sw_netstats *tx_stats, *rx_stats;
Cong Wange4c7ed42013-08-31 13:44:33 +08002292 union vxlan_addr loopback;
2293 union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;
Li RongQingce6502a2014-10-16 08:49:41 +08002294 struct net_device *dev = skb->dev;
2295 int len = skb->len;
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002296
Li RongQing8f849852014-01-04 13:57:59 +08002297 tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);
2298 rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002299 skb->pkt_type = PACKET_HOST;
2300 skb->encapsulation = 0;
2301 skb->dev = dst_vxlan->dev;
2302 __skb_pull(skb, skb_network_offset(skb));
2303
Cong Wange4c7ed42013-08-31 13:44:33 +08002304 if (remote_ip->sa.sa_family == AF_INET) {
2305 loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
2306 loopback.sa.sa_family = AF_INET;
2307#if IS_ENABLED(CONFIG_IPV6)
2308 } else {
2309 loopback.sin6.sin6_addr = in6addr_loopback;
2310 loopback.sa.sa_family = AF_INET6;
2311#endif
2312 }
2313
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002314 if (dst_vxlan->cfg.flags & VXLAN_F_LEARN)
Matthias Schiffer87613de2017-06-19 10:03:59 +02002315 vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source, 0,
2316 vni);
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002317
2318 u64_stats_update_begin(&tx_stats->syncp);
2319 tx_stats->tx_packets++;
Li RongQingce6502a2014-10-16 08:49:41 +08002320 tx_stats->tx_bytes += len;
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002321 u64_stats_update_end(&tx_stats->syncp);
2322
2323 if (netif_rx(skb) == NET_RX_SUCCESS) {
2324 u64_stats_update_begin(&rx_stats->syncp);
2325 rx_stats->rx_packets++;
Li RongQingce6502a2014-10-16 08:49:41 +08002326 rx_stats->rx_bytes += len;
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002327 u64_stats_update_end(&rx_stats->syncp);
2328 } else {
Li RongQingce6502a2014-10-16 08:49:41 +08002329 dev->stats.rx_dropped++;
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002330 }
2331}
2332
pravin shelarfee1fad2016-11-13 20:43:56 -08002333static int encap_bypass_if_local(struct sk_buff *skb, struct net_device *dev,
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002334 struct vxlan_dev *vxlan,
2335 union vxlan_addr *daddr,
2336 __be16 dst_port, int dst_ifindex, __be32 vni,
2337 struct dst_entry *dst,
pravin shelarfee1fad2016-11-13 20:43:56 -08002338 u32 rt_flags)
2339{
2340#if IS_ENABLED(CONFIG_IPV6)
2341 /* IPv6 rt-flags are checked against RTF_LOCAL, but the value of
2342 * RTF_LOCAL is equal to RTCF_LOCAL. So to keep code simple
2343 * we can use RTCF_LOCAL which works for ipv4 and ipv6 route entry.
2344 */
2345 BUILD_BUG_ON(RTCF_LOCAL != RTF_LOCAL);
2346#endif
2347 /* Bypass encapsulation if the destination is local */
2348 if (rt_flags & RTCF_LOCAL &&
2349 !(rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
2350 struct vxlan_dev *dst_vxlan;
2351
2352 dst_release(dst);
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002353 dst_vxlan = vxlan_find_vni(vxlan->net, dst_ifindex, vni,
pravin shelarfee1fad2016-11-13 20:43:56 -08002354 daddr->sa.sa_family, dst_port,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002355 vxlan->cfg.flags);
pravin shelarfee1fad2016-11-13 20:43:56 -08002356 if (!dst_vxlan) {
2357 dev->stats.tx_errors++;
2358 kfree_skb(skb);
2359
2360 return -ENOENT;
2361 }
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002362 vxlan_encap_bypass(skb, vxlan, dst_vxlan, vni);
pravin shelarfee1fad2016-11-13 20:43:56 -08002363 return 1;
2364 }
2365
2366 return 0;
2367}
2368
Stephen Hemminger4ad16932013-06-17 14:16:11 -07002369static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002370 __be32 default_vni, struct vxlan_rdst *rdst,
2371 bool did_rsc)
stephen hemmingerd3428942012-10-01 12:32:35 +00002372{
Paolo Abenid71785f2016-02-12 15:43:57 +01002373 struct dst_cache *dst_cache;
Thomas Graf3093fbe2015-07-21 10:44:00 +02002374 struct ip_tunnel_info *info;
stephen hemmingerd3428942012-10-01 12:32:35 +00002375 struct vxlan_dev *vxlan = netdev_priv(dev);
pravin shelar0770b532016-11-13 20:43:57 -08002376 const struct iphdr *old_iph = ip_hdr(skb);
Cong Wange4c7ed42013-08-31 13:44:33 +08002377 union vxlan_addr *dst;
pravin shelar272d96a2016-08-05 17:45:36 -07002378 union vxlan_addr remote_ip, local_ip;
Thomas Grafee122c72015-07-21 10:43:58 +02002379 struct vxlan_metadata _md;
2380 struct vxlan_metadata *md = &_md;
Cong Wange4c7ed42013-08-31 13:44:33 +08002381 __be16 src_port = 0, dst_port;
pravin shelar655c3de2016-11-13 20:43:55 -08002382 struct dst_entry *ndst = NULL;
Daniel Borkmanne7f70af2016-03-09 03:00:03 +01002383 __be32 vni, label;
stephen hemmingerd3428942012-10-01 12:32:35 +00002384 __u8 tos, ttl;
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002385 int ifindex;
Pravin B Shelar0e6fbc52013-06-17 17:49:56 -07002386 int err;
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002387 u32 flags = vxlan->cfg.flags;
Jiri Bencb4ed5ca2016-02-02 18:09:15 +01002388 bool udp_sum = false;
Jiri Bencf491e562016-02-02 18:09:16 +01002389 bool xnet = !net_eq(vxlan->net, dev_net(vxlan->dev));
stephen hemmingerd3428942012-10-01 12:32:35 +00002390
Jiri Benc61adedf2015-08-20 13:56:25 +02002391 info = skb_tunnel_info(skb);
Thomas Graf3093fbe2015-07-21 10:44:00 +02002392
Thomas Grafee122c72015-07-21 10:43:58 +02002393 if (rdst) {
pravin shelar0770b532016-11-13 20:43:57 -08002394 dst = &rdst->remote_ip;
2395 if (vxlan_addr_any(dst)) {
2396 if (did_rsc) {
2397 /* short-circuited back to local bridge */
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002398 vxlan_encap_bypass(skb, vxlan, vxlan, default_vni);
pravin shelar0770b532016-11-13 20:43:57 -08002399 return;
2400 }
2401 goto drop;
2402 }
2403
Thomas Graf0dfbdf42015-07-21 10:44:02 +02002404 dst_port = rdst->remote_port ? rdst->remote_port : vxlan->cfg.dst_port;
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002405 vni = (rdst->remote_vni) ? : default_vni;
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002406 ifindex = rdst->remote_ifindex;
Brian Russell11586322017-02-24 17:47:11 +00002407 local_ip = vxlan->cfg.saddr;
Paolo Abenid71785f2016-02-12 15:43:57 +01002408 dst_cache = &rdst->dst_cache;
pravin shelar0770b532016-11-13 20:43:57 -08002409 md->gbp = skb->mark;
Hangbin Liu72f6d712018-04-17 14:11:28 +08002410 if (flags & VXLAN_F_TTL_INHERIT) {
2411 ttl = ip_tunnel_get_ttl(old_iph, skb);
2412 } else {
2413 ttl = vxlan->cfg.ttl;
2414 if (!ttl && vxlan_addr_multicast(dst))
2415 ttl = 1;
2416 }
pravin shelar0770b532016-11-13 20:43:57 -08002417
2418 tos = vxlan->cfg.tos;
2419 if (tos == 1)
2420 tos = ip_tunnel_get_dsfield(old_iph, skb);
2421
2422 if (dst->sa.sa_family == AF_INET)
2423 udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM_TX);
2424 else
2425 udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM6_TX);
2426 label = vxlan->cfg.label;
Thomas Grafee122c72015-07-21 10:43:58 +02002427 } else {
2428 if (!info) {
2429 WARN_ONCE(1, "%s: Missing encapsulation instructions\n",
2430 dev->name);
2431 goto drop;
2432 }
Jiri Bencb1be00a2015-09-24 13:50:02 +02002433 remote_ip.sa.sa_family = ip_tunnel_info_af(info);
pravin shelar272d96a2016-08-05 17:45:36 -07002434 if (remote_ip.sa.sa_family == AF_INET) {
Jiri Benca725e512015-08-20 13:56:30 +02002435 remote_ip.sin.sin_addr.s_addr = info->key.u.ipv4.dst;
pravin shelar272d96a2016-08-05 17:45:36 -07002436 local_ip.sin.sin_addr.s_addr = info->key.u.ipv4.src;
2437 } else {
Jiri Benca725e512015-08-20 13:56:30 +02002438 remote_ip.sin6.sin6_addr = info->key.u.ipv6.dst;
pravin shelar272d96a2016-08-05 17:45:36 -07002439 local_ip.sin6.sin6_addr = info->key.u.ipv6.src;
2440 }
Thomas Grafee122c72015-07-21 10:43:58 +02002441 dst = &remote_ip;
pravin shelar0770b532016-11-13 20:43:57 -08002442 dst_port = info->key.tp_dst ? : vxlan->cfg.dst_port;
2443 vni = tunnel_id_to_key32(info->key.tun_id);
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002444 ifindex = 0;
Paolo Abenid71785f2016-02-12 15:43:57 +01002445 dst_cache = &info->dst_cache;
Pieter Jansen van Vuuren256c87c2018-06-26 21:39:36 -07002446 if (info->options_len &&
2447 info->key.tun_flags & TUNNEL_VXLAN_OPT)
pravin shelar0770b532016-11-13 20:43:57 -08002448 md = ip_tunnel_info_opts(info);
Jiri Benca725e512015-08-20 13:56:30 +02002449 ttl = info->key.ttl;
2450 tos = info->key.tos;
Daniel Borkmanne7f70af2016-03-09 03:00:03 +01002451 label = info->key.label;
Jiri Bencb4ed5ca2016-02-02 18:09:15 +01002452 udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
Jiri Benca725e512015-08-20 13:56:30 +02002453 }
pravin shelar0770b532016-11-13 20:43:57 -08002454 src_port = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,
2455 vxlan->cfg.port_max, true);
Jiri Benca725e512015-08-20 13:56:30 +02002456
Jakub Kicinski56de8592017-02-24 11:43:36 -08002457 rcu_read_lock();
Cong Wange4c7ed42013-08-31 13:44:33 +08002458 if (dst->sa.sa_family == AF_INET) {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07002459 struct vxlan_sock *sock4 = rcu_dereference(vxlan->vn4_sock);
pravin shelarc46b7892016-11-13 20:43:54 -08002460 struct rtable *rt;
pravin shelar0770b532016-11-13 20:43:57 -08002461 __be16 df = 0;
pravin shelarc6fcc4f2016-10-28 09:59:15 -07002462
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01002463 if (!ifindex)
2464 ifindex = sock4->sock->sk->sk_bound_dev_if;
2465
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002466 rt = vxlan_get_route(vxlan, dev, sock4, skb, ifindex, tos,
pravin shelar272d96a2016-08-05 17:45:36 -07002467 dst->sin.sin_addr.s_addr,
Brian Russell11586322017-02-24 17:47:11 +00002468 &local_ip.sin.sin_addr.s_addr,
Martynas Pumputis4ecb1d82017-01-11 15:18:53 +00002469 dst_port, src_port,
Paolo Abenid71785f2016-02-12 15:43:57 +01002470 dst_cache, info);
David S. Miller8ebd1152016-11-15 16:32:11 -05002471 if (IS_ERR(rt)) {
2472 err = PTR_ERR(rt);
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002473 goto tx_error;
David S. Miller8ebd1152016-11-15 16:32:11 -05002474 }
pravin shelarfee1fad2016-11-13 20:43:56 -08002475
pravin shelarfee1fad2016-11-13 20:43:56 -08002476 if (!info) {
Stefano Briviob4d306972018-11-08 12:19:16 +01002477 /* Bypass encapsulation if the destination is local */
pravin shelarfee1fad2016-11-13 20:43:56 -08002478 err = encap_bypass_if_local(skb, dev, vxlan, dst,
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002479 dst_port, ifindex, vni,
2480 &rt->dst, rt->rt_flags);
pravin shelarfee1fad2016-11-13 20:43:56 -08002481 if (err)
Jakub Kicinski56de8592017-02-24 11:43:36 -08002482 goto out_unlock;
Stefano Briviob4d306972018-11-08 12:19:16 +01002483
2484 if (vxlan->cfg.df == VXLAN_DF_SET) {
2485 df = htons(IP_DF);
2486 } else if (vxlan->cfg.df == VXLAN_DF_INHERIT) {
2487 struct ethhdr *eth = eth_hdr(skb);
2488
2489 if (ntohs(eth->h_proto) == ETH_P_IPV6 ||
2490 (ntohs(eth->h_proto) == ETH_P_IP &&
2491 old_iph->frag_off & htons(IP_DF)))
2492 df = htons(IP_DF);
2493 }
pravin shelarfee1fad2016-11-13 20:43:56 -08002494 } else if (info->key.tun_flags & TUNNEL_DONT_FRAGMENT) {
Alexander Duyck6ceb31c2016-02-19 11:26:31 -08002495 df = htons(IP_DF);
pravin shelarfee1fad2016-11-13 20:43:56 -08002496 }
Alexander Duyck6ceb31c2016-02-19 11:26:31 -08002497
pravin shelarc46b7892016-11-13 20:43:54 -08002498 ndst = &rt->dst;
Stefano Brivio6b4f92a2018-10-12 23:53:59 +02002499 skb_tunnel_check_pmtu(skb, ndst, VXLAN_HEADROOM);
Xin Longa93bf0f2017-12-18 14:20:56 +08002500
Cong Wange4c7ed42013-08-31 13:44:33 +08002501 tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
2502 ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
pravin shelarc46b7892016-11-13 20:43:54 -08002503 err = vxlan_build_skb(skb, ndst, sizeof(struct iphdr),
Jiri Benc54bfd872016-02-16 21:58:58 +01002504 vni, md, flags, udp_sum);
Jiri Bencf491e562016-02-02 18:09:16 +01002505 if (err < 0)
pravin shelarc46b7892016-11-13 20:43:54 -08002506 goto tx_error;
Jiri Bencf491e562016-02-02 18:09:16 +01002507
Brian Russell11586322017-02-24 17:47:11 +00002508 udp_tunnel_xmit_skb(rt, sock4->sock->sk, skb, local_ip.sin.sin_addr.s_addr,
Jiri Bencf491e562016-02-02 18:09:16 +01002509 dst->sin.sin_addr.s_addr, tos, ttl, df,
2510 src_port, dst_port, xnet, !udp_sum);
Cong Wange4c7ed42013-08-31 13:44:33 +08002511#if IS_ENABLED(CONFIG_IPV6)
2512 } else {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07002513 struct vxlan_sock *sock6 = rcu_dereference(vxlan->vn6_sock);
Cong Wange4c7ed42013-08-31 13:44:33 +08002514
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01002515 if (!ifindex)
2516 ifindex = sock6->sock->sk->sk_bound_dev_if;
2517
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002518 ndst = vxlan6_get_route(vxlan, dev, sock6, skb, ifindex, tos,
pravin shelar272d96a2016-08-05 17:45:36 -07002519 label, &dst->sin6.sin6_addr,
Brian Russell11586322017-02-24 17:47:11 +00002520 &local_ip.sin6.sin6_addr,
Martynas Pumputis4ecb1d82017-01-11 15:18:53 +00002521 dst_port, src_port,
Daniel Borkmanndb3c6132016-03-04 15:15:07 +01002522 dst_cache, info);
Jiri Bence5d4b292015-12-07 13:04:30 +01002523 if (IS_ERR(ndst)) {
David S. Miller8ebd1152016-11-15 16:32:11 -05002524 err = PTR_ERR(ndst);
pravin shelarc46b7892016-11-13 20:43:54 -08002525 ndst = NULL;
Cong Wange4c7ed42013-08-31 13:44:33 +08002526 goto tx_error;
2527 }
pravin shelar655c3de2016-11-13 20:43:55 -08002528
pravin shelarfee1fad2016-11-13 20:43:56 -08002529 if (!info) {
2530 u32 rt6i_flags = ((struct rt6_info *)ndst)->rt6i_flags;
Cong Wange4c7ed42013-08-31 13:44:33 +08002531
pravin shelarfee1fad2016-11-13 20:43:56 -08002532 err = encap_bypass_if_local(skb, dev, vxlan, dst,
Matthias Schiffer49f810f2017-06-19 10:04:00 +02002533 dst_port, ifindex, vni,
2534 ndst, rt6i_flags);
pravin shelarfee1fad2016-11-13 20:43:56 -08002535 if (err)
Jakub Kicinski56de8592017-02-24 11:43:36 -08002536 goto out_unlock;
pravin shelarfee1fad2016-11-13 20:43:56 -08002537 }
Jesse Gross35e2d112016-01-20 16:22:47 -08002538
Stefano Brivio6b4f92a2018-10-12 23:53:59 +02002539 skb_tunnel_check_pmtu(skb, ndst, VXLAN6_HEADROOM);
Xin Longa93bf0f2017-12-18 14:20:56 +08002540
Daniel Borkmann14006152016-03-04 15:15:08 +01002541 tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
Cong Wange4c7ed42013-08-31 13:44:33 +08002542 ttl = ttl ? : ip6_dst_hoplimit(ndst);
Jiri Bencf491e562016-02-02 18:09:16 +01002543 skb_scrub_packet(skb, xnet);
2544 err = vxlan_build_skb(skb, ndst, sizeof(struct ipv6hdr),
Jiri Benc54bfd872016-02-16 21:58:58 +01002545 vni, md, flags, udp_sum);
pravin shelarc46b7892016-11-13 20:43:54 -08002546 if (err < 0)
2547 goto tx_error;
2548
pravin shelar0770b532016-11-13 20:43:57 -08002549 udp_tunnel6_xmit_skb(ndst, sock6->sock->sk, skb, dev,
Brian Russell11586322017-02-24 17:47:11 +00002550 &local_ip.sin6.sin6_addr,
pravin shelar272d96a2016-08-05 17:45:36 -07002551 &dst->sin6.sin6_addr, tos, ttl,
Daniel Borkmanne7f70af2016-03-09 03:00:03 +01002552 label, src_port, dst_port, !udp_sum);
Cong Wange4c7ed42013-08-31 13:44:33 +08002553#endif
Sridhar Samudrala9dcc71e2013-04-02 12:31:52 +00002554 }
Jakub Kicinski56de8592017-02-24 11:43:36 -08002555out_unlock:
2556 rcu_read_unlock();
Stephen Hemminger4ad16932013-06-17 14:16:11 -07002557 return;
stephen hemmingerd3428942012-10-01 12:32:35 +00002558
2559drop:
2560 dev->stats.tx_dropped++;
stephen hemmingerd3428942012-10-01 12:32:35 +00002561 dev_kfree_skb(skb);
pravin shelarc46b7892016-11-13 20:43:54 -08002562 return;
2563
2564tx_error:
Jakub Kicinski56de8592017-02-24 11:43:36 -08002565 rcu_read_unlock();
pravin shelar655c3de2016-11-13 20:43:55 -08002566 if (err == -ELOOP)
2567 dev->stats.collisions++;
2568 else if (err == -ENETUNREACH)
2569 dev->stats.tx_carrier_errors++;
pravin shelarc46b7892016-11-13 20:43:54 -08002570 dst_release(ndst);
2571 dev->stats.tx_errors++;
2572 kfree_skb(skb);
stephen hemmingerd3428942012-10-01 12:32:35 +00002573}
2574
David Stevens66817122013-03-15 04:35:51 +00002575/* Transmit local packets over Vxlan
2576 *
2577 * Outer IP header inherits ECN and DF from inner header.
2578 * Outer UDP destination is the VXLAN assigned port.
2579 * source port is based on hash of flow
2580 */
2581static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)
2582{
2583 struct vxlan_dev *vxlan = netdev_priv(dev);
Eric Dumazet8f646c92014-01-06 09:54:31 -08002584 struct vxlan_rdst *rdst, *fdst = NULL;
Xin Long8bff36852017-11-11 19:58:50 +08002585 const struct ip_tunnel_info *info;
2586 bool did_rsc = false;
David Stevens66817122013-03-15 04:35:51 +00002587 struct vxlan_fdb *f;
Xin Long8bff36852017-11-11 19:58:50 +08002588 struct ethhdr *eth;
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002589 __be32 vni = 0;
David Stevens66817122013-03-15 04:35:51 +00002590
Jiri Benc61adedf2015-08-20 13:56:25 +02002591 info = skb_tunnel_info(skb);
Thomas Graf3093fbe2015-07-21 10:44:00 +02002592
David Stevens66817122013-03-15 04:35:51 +00002593 skb_reset_mac_header(skb);
David Stevens66817122013-03-15 04:35:51 +00002594
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002595 if (vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) {
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002596 if (info && info->mode & IP_TUNNEL_INFO_BRIDGE &&
2597 info->mode & IP_TUNNEL_INFO_TX) {
2598 vni = tunnel_id_to_key32(info->key.tun_id);
2599 } else {
2600 if (info && info->mode & IP_TUNNEL_INFO_TX)
2601 vxlan_xmit_one(skb, dev, vni, NULL, false);
2602 else
2603 kfree_skb(skb);
2604 return NETDEV_TX_OK;
2605 }
Jiri Benc47e5d1b2016-04-05 14:47:11 +02002606 }
2607
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002608 if (vxlan->cfg.flags & VXLAN_F_PROXY) {
Jiri Benc47e5d1b2016-04-05 14:47:11 +02002609 eth = eth_hdr(skb);
Cong Wangf564f452013-08-31 13:44:36 +08002610 if (ntohs(eth->h_proto) == ETH_P_ARP)
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002611 return arp_reduce(dev, skb, vni);
Cong Wangf564f452013-08-31 13:44:36 +08002612#if IS_ENABLED(CONFIG_IPV6)
Xin Long8bff36852017-11-11 19:58:50 +08002613 else if (ntohs(eth->h_proto) == ETH_P_IPV6 &&
2614 pskb_may_pull(skb, sizeof(struct ipv6hdr) +
2615 sizeof(struct nd_msg)) &&
2616 ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
2617 struct nd_msg *m = (struct nd_msg *)(ipv6_hdr(skb) + 1);
2618
2619 if (m->icmph.icmp6_code == 0 &&
2620 m->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)
Vincent Bernatf1fb08f2017-04-02 11:00:06 +02002621 return neigh_reduce(dev, skb, vni);
Cong Wangf564f452013-08-31 13:44:36 +08002622 }
2623#endif
2624 }
David Stevens66817122013-03-15 04:35:51 +00002625
Jiri Benc47e5d1b2016-04-05 14:47:11 +02002626 eth = eth_hdr(skb);
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002627 f = vxlan_find_mac(vxlan, eth->h_dest, vni);
David Stevensae884082013-04-19 00:36:26 +00002628 did_rsc = false;
2629
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002630 if (f && (f->flags & NTF_ROUTER) && (vxlan->cfg.flags & VXLAN_F_RSC) &&
Cong Wange15a00a2013-08-31 13:44:34 +08002631 (ntohs(eth->h_proto) == ETH_P_IP ||
2632 ntohs(eth->h_proto) == ETH_P_IPV6)) {
David Stevensae884082013-04-19 00:36:26 +00002633 did_rsc = route_shortcircuit(dev, skb);
2634 if (did_rsc)
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002635 f = vxlan_find_mac(vxlan, eth->h_dest, vni);
David Stevensae884082013-04-19 00:36:26 +00002636 }
2637
David Stevens66817122013-03-15 04:35:51 +00002638 if (f == NULL) {
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002639 f = vxlan_find_mac(vxlan, all_zeros_mac, vni);
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002640 if (f == NULL) {
Matthias Schifferdc5321d2017-06-19 10:03:56 +02002641 if ((vxlan->cfg.flags & VXLAN_F_L2MISS) &&
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002642 !is_multicast_ether_addr(eth->h_dest))
2643 vxlan_fdb_miss(vxlan, eth->h_dest);
David Stevens66817122013-03-15 04:35:51 +00002644
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002645 dev->stats.tx_dropped++;
Eric Dumazet8f646c92014-01-06 09:54:31 -08002646 kfree_skb(skb);
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002647 return NETDEV_TX_OK;
Stephen Hemminger3e61aa82013-06-17 14:16:12 -07002648 }
David Stevens66817122013-03-15 04:35:51 +00002649 }
2650
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002651 list_for_each_entry_rcu(rdst, &f->remotes, list) {
2652 struct sk_buff *skb1;
2653
Eric Dumazet8f646c92014-01-06 09:54:31 -08002654 if (!fdst) {
2655 fdst = rdst;
2656 continue;
2657 }
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002658 skb1 = skb_clone(skb, GFP_ATOMIC);
2659 if (skb1)
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002660 vxlan_xmit_one(skb1, dev, vni, rdst, did_rsc);
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002661 }
2662
Eric Dumazet8f646c92014-01-06 09:54:31 -08002663 if (fdst)
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002664 vxlan_xmit_one(skb, dev, vni, fdst, did_rsc);
Eric Dumazet8f646c92014-01-06 09:54:31 -08002665 else
2666 kfree_skb(skb);
Stephen Hemminger4ad16932013-06-17 14:16:11 -07002667 return NETDEV_TX_OK;
David Stevens66817122013-03-15 04:35:51 +00002668}
2669
stephen hemmingerd3428942012-10-01 12:32:35 +00002670/* Walk the forwarding table and purge stale entries */
Kees Cookdf7e8282017-10-04 16:26:59 -07002671static void vxlan_cleanup(struct timer_list *t)
stephen hemmingerd3428942012-10-01 12:32:35 +00002672{
Kees Cookdf7e8282017-10-04 16:26:59 -07002673 struct vxlan_dev *vxlan = from_timer(vxlan, t, age_timer);
stephen hemmingerd3428942012-10-01 12:32:35 +00002674 unsigned long next_timer = jiffies + FDB_AGE_INTERVAL;
2675 unsigned int h;
2676
2677 if (!netif_running(vxlan->dev))
2678 return;
2679
stephen hemmingerd3428942012-10-01 12:32:35 +00002680 for (h = 0; h < FDB_HASH_SIZE; ++h) {
2681 struct hlist_node *p, *n;
Sorin Dumitru14e1d0f2015-05-26 10:42:04 +03002682
2683 spin_lock_bh(&vxlan->hash_lock);
stephen hemmingerd3428942012-10-01 12:32:35 +00002684 hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
2685 struct vxlan_fdb *f
2686 = container_of(p, struct vxlan_fdb, hlist);
2687 unsigned long timeout;
2688
Balakrishnan Ramanefb5f682017-01-23 20:44:33 -08002689 if (f->state & (NUD_PERMANENT | NUD_NOARP))
stephen hemmingerd3428942012-10-01 12:32:35 +00002690 continue;
2691
Roopa Prabhudef499c2017-03-27 15:46:41 -07002692 if (f->flags & NTF_EXT_LEARNED)
2693 continue;
2694
Thomas Graf0dfbdf42015-07-21 10:44:02 +02002695 timeout = f->used + vxlan->cfg.age_interval * HZ;
stephen hemmingerd3428942012-10-01 12:32:35 +00002696 if (time_before_eq(timeout, jiffies)) {
2697 netdev_dbg(vxlan->dev,
2698 "garbage collect %pM\n",
2699 f->eth_addr);
2700 f->state = NUD_STALE;
Petr Machata0e6160f2018-11-21 08:02:35 +00002701 vxlan_fdb_destroy(vxlan, f, true, true);
stephen hemmingerd3428942012-10-01 12:32:35 +00002702 } else if (time_before(timeout, next_timer))
2703 next_timer = timeout;
2704 }
Sorin Dumitru14e1d0f2015-05-26 10:42:04 +03002705 spin_unlock_bh(&vxlan->hash_lock);
stephen hemmingerd3428942012-10-01 12:32:35 +00002706 }
stephen hemmingerd3428942012-10-01 12:32:35 +00002707
2708 mod_timer(&vxlan->age_timer, next_timer);
2709}
2710
Mark Blocha53cb292017-06-02 03:24:08 +03002711static void vxlan_vs_del_dev(struct vxlan_dev *vxlan)
2712{
2713 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2714
2715 spin_lock(&vn->sock_lock);
Jiri Benc69e76662017-07-02 19:00:57 +02002716 hlist_del_init_rcu(&vxlan->hlist4.hlist);
2717#if IS_ENABLED(CONFIG_IPV6)
2718 hlist_del_init_rcu(&vxlan->hlist6.hlist);
2719#endif
Mark Blocha53cb292017-06-02 03:24:08 +03002720 spin_unlock(&vn->sock_lock);
2721}
2722
Jiri Benc69e76662017-07-02 19:00:57 +02002723static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan,
2724 struct vxlan_dev_node *node)
Pravin B Shelar9c2e24e2013-08-19 11:22:48 -07002725{
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002726 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
Jiri Benc54bfd872016-02-16 21:58:58 +01002727 __be32 vni = vxlan->default_dst.remote_vni;
Pravin B Shelar9c2e24e2013-08-19 11:22:48 -07002728
Jiri Benc69e76662017-07-02 19:00:57 +02002729 node->vxlan = vxlan;
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002730 spin_lock(&vn->sock_lock);
Jiri Benc69e76662017-07-02 19:00:57 +02002731 hlist_add_head_rcu(&node->hlist, vni_head(vs, vni));
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002732 spin_unlock(&vn->sock_lock);
Pravin B Shelar9c2e24e2013-08-19 11:22:48 -07002733}
2734
stephen hemmingerd3428942012-10-01 12:32:35 +00002735/* Setup stats when device is created */
2736static int vxlan_init(struct net_device *dev)
2737{
WANG Cong1c213bd2014-02-13 11:46:28 -08002738 dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
Pravin B Shelare8171042013-03-25 14:49:46 +00002739 if (!dev->tstats)
stephen hemmingerd3428942012-10-01 12:32:35 +00002740 return -ENOMEM;
2741
2742 return 0;
2743}
2744
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002745static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan, __be32 vni)
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002746{
2747 struct vxlan_fdb *f;
2748
2749 spin_lock_bh(&vxlan->hash_lock);
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002750 f = __vxlan_find_mac(vxlan, all_zeros_mac, vni);
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002751 if (f)
Petr Machata0e6160f2018-11-21 08:02:35 +00002752 vxlan_fdb_destroy(vxlan, f, true, true);
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002753 spin_unlock_bh(&vxlan->hash_lock);
2754}
2755
Stephen Hemmingerebf40632013-06-17 14:16:11 -07002756static void vxlan_uninit(struct net_device *dev)
2757{
2758 struct vxlan_dev *vxlan = netdev_priv(dev);
Stephen Hemmingerebf40632013-06-17 14:16:11 -07002759
Roopa Prabhu3ad7a4b2017-01-31 22:59:52 -08002760 vxlan_fdb_delete_default(vxlan, vxlan->cfg.vni);
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002761
Stephen Hemmingerebf40632013-06-17 14:16:11 -07002762 free_percpu(dev->tstats);
2763}
2764
stephen hemmingerd3428942012-10-01 12:32:35 +00002765/* Start ageing timer and join group when device is brought up */
2766static int vxlan_open(struct net_device *dev)
2767{
2768 struct vxlan_dev *vxlan = netdev_priv(dev);
Jiri Benc205f3562015-09-24 13:50:01 +02002769 int ret;
Stephen Hemminger1c51a912013-06-17 14:16:11 -07002770
Jiri Benc205f3562015-09-24 13:50:01 +02002771 ret = vxlan_sock_add(vxlan);
2772 if (ret < 0)
2773 return ret;
stephen hemmingerd3428942012-10-01 12:32:35 +00002774
Gao feng79d4a942013-12-10 16:37:32 +08002775 if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip)) {
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002776 ret = vxlan_igmp_join(vxlan);
Marcelo Ricardo Leitnerbef00572015-08-25 20:22:35 -03002777 if (ret == -EADDRINUSE)
2778 ret = 0;
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002779 if (ret) {
Jiri Benc205f3562015-09-24 13:50:01 +02002780 vxlan_sock_release(vxlan);
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002781 return ret;
2782 }
stephen hemmingerd3428942012-10-01 12:32:35 +00002783 }
2784
Thomas Graf0dfbdf42015-07-21 10:44:02 +02002785 if (vxlan->cfg.age_interval)
stephen hemmingerd3428942012-10-01 12:32:35 +00002786 mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);
2787
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002788 return ret;
stephen hemmingerd3428942012-10-01 12:32:35 +00002789}
2790
2791/* Purge the forwarding table */
Roopa Prabhu8b3f9332017-01-23 20:44:32 -08002792static void vxlan_flush(struct vxlan_dev *vxlan, bool do_all)
stephen hemmingerd3428942012-10-01 12:32:35 +00002793{
Cong Wang31fec5a2013-05-27 22:35:52 +00002794 unsigned int h;
stephen hemmingerd3428942012-10-01 12:32:35 +00002795
2796 spin_lock_bh(&vxlan->hash_lock);
2797 for (h = 0; h < FDB_HASH_SIZE; ++h) {
2798 struct hlist_node *p, *n;
2799 hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
2800 struct vxlan_fdb *f
2801 = container_of(p, struct vxlan_fdb, hlist);
Roopa Prabhu8b3f9332017-01-23 20:44:32 -08002802 if (!do_all && (f->state & (NUD_PERMANENT | NUD_NOARP)))
2803 continue;
Mike Rapoportafbd8ba2013-06-25 16:01:51 +03002804 /* the all_zeros_mac entry is deleted at vxlan_uninit */
2805 if (!is_zero_ether_addr(f->eth_addr))
Petr Machata0e6160f2018-11-21 08:02:35 +00002806 vxlan_fdb_destroy(vxlan, f, true, true);
stephen hemmingerd3428942012-10-01 12:32:35 +00002807 }
2808 }
2809 spin_unlock_bh(&vxlan->hash_lock);
2810}
2811
2812/* Cleanup timer and forwarding table on shutdown */
2813static int vxlan_stop(struct net_device *dev)
2814{
2815 struct vxlan_dev *vxlan = netdev_priv(dev);
Nicolas Dichtelf01ec1c2014-04-24 10:02:49 +02002816 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002817 int ret = 0;
stephen hemmingerd3428942012-10-01 12:32:35 +00002818
Marcelo Ricardo Leitner24c0e682015-03-23 16:23:12 -03002819 if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
WANG Congf13b1682015-04-08 14:48:30 -07002820 !vxlan_group_used(vn, vxlan))
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002821 ret = vxlan_igmp_leave(vxlan);
stephen hemmingerd3428942012-10-01 12:32:35 +00002822
2823 del_timer_sync(&vxlan->age_timer);
2824
Roopa Prabhu8b3f9332017-01-23 20:44:32 -08002825 vxlan_flush(vxlan, false);
Jiri Benc205f3562015-09-24 13:50:01 +02002826 vxlan_sock_release(vxlan);
stephen hemmingerd3428942012-10-01 12:32:35 +00002827
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03002828 return ret;
stephen hemmingerd3428942012-10-01 12:32:35 +00002829}
2830
stephen hemmingerd3428942012-10-01 12:32:35 +00002831/* Stub, nothing needs to be done. */
2832static void vxlan_set_multicast_list(struct net_device *dev)
2833{
2834}
2835
Daniel Borkmann345010b2013-12-18 00:21:08 +01002836static int vxlan_change_mtu(struct net_device *dev, int new_mtu)
2837{
2838 struct vxlan_dev *vxlan = netdev_priv(dev);
2839 struct vxlan_rdst *dst = &vxlan->default_dst;
David Wragg72564b52016-02-10 00:05:55 +00002840 struct net_device *lowerdev = __dev_get_by_index(vxlan->net,
2841 dst->remote_ifindex);
Matthias Schifferce44a4a2017-06-19 10:03:57 +02002842 bool use_ipv6 = !!(vxlan->cfg.flags & VXLAN_F_IPV6);
Jarod Wilson91572082016-10-20 13:55:20 -04002843
2844 /* This check is different than dev->max_mtu, because it looks at
2845 * the lowerdev->mtu, rather than the static dev->max_mtu
2846 */
2847 if (lowerdev) {
2848 int max_mtu = lowerdev->mtu -
2849 (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
2850 if (new_mtu > max_mtu)
2851 return -EINVAL;
2852 }
2853
2854 dev->mtu = new_mtu;
2855 return 0;
Daniel Borkmann345010b2013-12-18 00:21:08 +01002856}
2857
Pravin B Shelarfc4099f2015-10-22 18:17:16 -07002858static int vxlan_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
2859{
2860 struct vxlan_dev *vxlan = netdev_priv(dev);
2861 struct ip_tunnel_info *info = skb_tunnel_info(skb);
2862 __be16 sport, dport;
2863
2864 sport = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,
2865 vxlan->cfg.port_max, true);
2866 dport = info->key.tp_dst ? : vxlan->cfg.dst_port;
2867
Jiri Benc239e9442015-12-07 13:04:31 +01002868 if (ip_tunnel_info_af(info) == AF_INET) {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07002869 struct vxlan_sock *sock4 = rcu_dereference(vxlan->vn4_sock);
Jiri Benc1a8496b2016-02-02 18:09:14 +01002870 struct rtable *rt;
2871
pravin shelar655c3de2016-11-13 20:43:55 -08002872 rt = vxlan_get_route(vxlan, dev, sock4, skb, 0, info->key.tos,
Jiri Benc1a8496b2016-02-02 18:09:14 +01002873 info->key.u.ipv4.dst,
Paolo Abeni22f07082017-02-17 19:14:27 +01002874 &info->key.u.ipv4.src, dport, sport,
2875 &info->dst_cache, info);
Jiri Benc1a8496b2016-02-02 18:09:14 +01002876 if (IS_ERR(rt))
2877 return PTR_ERR(rt);
2878 ip_rt_put(rt);
Jiri Benc239e9442015-12-07 13:04:31 +01002879 } else {
2880#if IS_ENABLED(CONFIG_IPV6)
pravin shelar03dc52a2016-11-13 20:43:53 -08002881 struct vxlan_sock *sock6 = rcu_dereference(vxlan->vn6_sock);
Jiri Benc239e9442015-12-07 13:04:31 +01002882 struct dst_entry *ndst;
2883
pravin shelar655c3de2016-11-13 20:43:55 -08002884 ndst = vxlan6_get_route(vxlan, dev, sock6, skb, 0, info->key.tos,
Daniel Borkmanne7f70af2016-03-09 03:00:03 +01002885 info->key.label, &info->key.u.ipv6.dst,
Paolo Abeni22f07082017-02-17 19:14:27 +01002886 &info->key.u.ipv6.src, dport, sport,
2887 &info->dst_cache, info);
Jiri Benc239e9442015-12-07 13:04:31 +01002888 if (IS_ERR(ndst))
2889 return PTR_ERR(ndst);
2890 dst_release(ndst);
Jiri Benc239e9442015-12-07 13:04:31 +01002891#else /* !CONFIG_IPV6 */
2892 return -EPFNOSUPPORT;
2893#endif
2894 }
Jiri Benc1a8496b2016-02-02 18:09:14 +01002895 info->key.tp_src = sport;
2896 info->key.tp_dst = dport;
Jiri Benc239e9442015-12-07 13:04:31 +01002897 return 0;
Pravin B Shelarfc4099f2015-10-22 18:17:16 -07002898}
2899
Jiri Benc0c867c92016-04-05 14:47:10 +02002900static const struct net_device_ops vxlan_netdev_ether_ops = {
stephen hemmingerd3428942012-10-01 12:32:35 +00002901 .ndo_init = vxlan_init,
Stephen Hemmingerebf40632013-06-17 14:16:11 -07002902 .ndo_uninit = vxlan_uninit,
stephen hemmingerd3428942012-10-01 12:32:35 +00002903 .ndo_open = vxlan_open,
2904 .ndo_stop = vxlan_stop,
2905 .ndo_start_xmit = vxlan_xmit,
Pravin B Shelare8171042013-03-25 14:49:46 +00002906 .ndo_get_stats64 = ip_tunnel_get_stats64,
stephen hemmingerd3428942012-10-01 12:32:35 +00002907 .ndo_set_rx_mode = vxlan_set_multicast_list,
Daniel Borkmann345010b2013-12-18 00:21:08 +01002908 .ndo_change_mtu = vxlan_change_mtu,
stephen hemmingerd3428942012-10-01 12:32:35 +00002909 .ndo_validate_addr = eth_validate_addr,
2910 .ndo_set_mac_address = eth_mac_addr,
2911 .ndo_fdb_add = vxlan_fdb_add,
2912 .ndo_fdb_del = vxlan_fdb_delete,
2913 .ndo_fdb_dump = vxlan_fdb_dump,
Roopa Prabhu474c3c82018-12-15 22:35:10 -08002914 .ndo_fdb_get = vxlan_fdb_get,
Pravin B Shelarfc4099f2015-10-22 18:17:16 -07002915 .ndo_fill_metadata_dst = vxlan_fill_metadata_dst,
stephen hemmingerd3428942012-10-01 12:32:35 +00002916};
2917
Jiri Bence1e53142016-04-05 14:47:13 +02002918static const struct net_device_ops vxlan_netdev_raw_ops = {
2919 .ndo_init = vxlan_init,
2920 .ndo_uninit = vxlan_uninit,
2921 .ndo_open = vxlan_open,
2922 .ndo_stop = vxlan_stop,
2923 .ndo_start_xmit = vxlan_xmit,
2924 .ndo_get_stats64 = ip_tunnel_get_stats64,
2925 .ndo_change_mtu = vxlan_change_mtu,
2926 .ndo_fill_metadata_dst = vxlan_fill_metadata_dst,
2927};
2928
stephen hemmingerd3428942012-10-01 12:32:35 +00002929/* Info for udev, that this is a virtual tunnel endpoint */
2930static struct device_type vxlan_type = {
2931 .name = "vxlan",
2932};
2933
Sabrina Dubrocae5de25d2016-07-11 13:12:28 +02002934/* Calls the ndo_udp_tunnel_add of the caller in order to
Joseph Gasparakis35e42372013-09-13 07:34:13 -07002935 * supply the listening VXLAN udp ports. Callers are expected
Sabrina Dubrocae5de25d2016-07-11 13:12:28 +02002936 * to implement the ndo_udp_tunnel_add.
Joseph Gasparakis53cf52752013-09-04 02:13:38 -07002937 */
Sabrina Dubroca2d2b13f2017-07-21 12:49:32 +02002938static void vxlan_offload_rx_ports(struct net_device *dev, bool push)
Joseph Gasparakis53cf52752013-09-04 02:13:38 -07002939{
2940 struct vxlan_sock *vs;
2941 struct net *net = dev_net(dev);
2942 struct vxlan_net *vn = net_generic(net, vxlan_net_id);
Joseph Gasparakis35e42372013-09-13 07:34:13 -07002943 unsigned int i;
Joseph Gasparakis53cf52752013-09-04 02:13:38 -07002944
2945 spin_lock(&vn->sock_lock);
2946 for (i = 0; i < PORT_HASH_SIZE; ++i) {
Sabrina Dubroca2d2b13f2017-07-21 12:49:32 +02002947 hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist) {
2948 unsigned short type;
2949
2950 if (vs->flags & VXLAN_F_GPE)
2951 type = UDP_TUNNEL_TYPE_VXLAN_GPE;
2952 else
2953 type = UDP_TUNNEL_TYPE_VXLAN;
2954
2955 if (push)
2956 udp_tunnel_push_rx_port(dev, vs->sock, type);
2957 else
2958 udp_tunnel_drop_rx_port(dev, vs->sock, type);
2959 }
Joseph Gasparakis53cf52752013-09-04 02:13:38 -07002960 }
2961 spin_unlock(&vn->sock_lock);
2962}
Joseph Gasparakis53cf52752013-09-04 02:13:38 -07002963
stephen hemmingerd3428942012-10-01 12:32:35 +00002964/* Initialize the device structure. */
2965static void vxlan_setup(struct net_device *dev)
2966{
2967 struct vxlan_dev *vxlan = netdev_priv(dev);
Cong Wang31fec5a2013-05-27 22:35:52 +00002968 unsigned int h;
stephen hemmingerd3428942012-10-01 12:32:35 +00002969
Jiri Benc65226ef2016-04-28 16:36:30 +02002970 eth_hw_addr_random(dev);
2971 ether_setup(dev);
2972
David S. Millercf124db2017-05-08 12:52:56 -04002973 dev->needs_free_netdev = true;
stephen hemmingerd3428942012-10-01 12:32:35 +00002974 SET_NETDEV_DEVTYPE(dev, &vxlan_type);
2975
stephen hemmingerd3428942012-10-01 12:32:35 +00002976 dev->features |= NETIF_F_LLTX;
Joseph Gasparakisd6727fe2012-12-07 14:14:16 +00002977 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
Joseph Gasparakis0afb1662012-12-07 14:14:18 +00002978 dev->features |= NETIF_F_RXCSUM;
Pravin B Shelar05c0db02013-03-07 13:22:36 +00002979 dev->features |= NETIF_F_GSO_SOFTWARE;
Joseph Gasparakis0afb1662012-12-07 14:14:18 +00002980
Pravin B Shelar1eaa8172013-08-19 11:23:29 -07002981 dev->vlan_features = dev->features;
Joseph Gasparakis0afb1662012-12-07 14:14:18 +00002982 dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
Pravin B Shelar05c0db02013-03-07 13:22:36 +00002983 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
Eric Dumazet02875872014-10-05 18:38:35 -07002984 netif_keep_dst(dev);
Jiri Benc0c867c92016-04-05 14:47:10 +02002985 dev->priv_flags |= IFF_NO_QUEUE;
stephen hemmingerd3428942012-10-01 12:32:35 +00002986
Matthias Schiffera9853432017-06-19 10:03:55 +02002987 /* MTU range: 68 - 65535 */
2988 dev->min_mtu = ETH_MIN_MTU;
2989 dev->max_mtu = ETH_MAX_MTU;
2990
stephen hemminger553675f2013-05-16 11:35:20 +00002991 INIT_LIST_HEAD(&vxlan->next);
stephen hemmingerd3428942012-10-01 12:32:35 +00002992 spin_lock_init(&vxlan->hash_lock);
2993
Kees Cookdf7e8282017-10-04 16:26:59 -07002994 timer_setup(&vxlan->age_timer, vxlan_cleanup, TIMER_DEFERRABLE);
stephen hemmingerd3428942012-10-01 12:32:35 +00002995
2996 vxlan->dev = dev;
2997
Tom Herbert58ce31c2015-08-19 17:07:33 -07002998 gro_cells_init(&vxlan->gro_cells, dev);
2999
stephen hemmingerd3428942012-10-01 12:32:35 +00003000 for (h = 0; h < FDB_HASH_SIZE; ++h)
3001 INIT_HLIST_HEAD(&vxlan->fdb_head[h]);
3002}
3003
Jiri Benc0c867c92016-04-05 14:47:10 +02003004static void vxlan_ether_setup(struct net_device *dev)
3005{
Jiri Benc0c867c92016-04-05 14:47:10 +02003006 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
3007 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
3008 dev->netdev_ops = &vxlan_netdev_ether_ops;
3009}
3010
Jiri Bence1e53142016-04-05 14:47:13 +02003011static void vxlan_raw_setup(struct net_device *dev)
3012{
Jiri Benc65226ef2016-04-28 16:36:30 +02003013 dev->header_ops = NULL;
Jiri Bence1e53142016-04-05 14:47:13 +02003014 dev->type = ARPHRD_NONE;
3015 dev->hard_header_len = 0;
3016 dev->addr_len = 0;
Jiri Bence1e53142016-04-05 14:47:13 +02003017 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
3018 dev->netdev_ops = &vxlan_netdev_raw_ops;
3019}
3020
stephen hemmingerd3428942012-10-01 12:32:35 +00003021static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
3022 [IFLA_VXLAN_ID] = { .type = NLA_U32 },
stephen hemminger5d174dd2013-04-27 11:31:55 +00003023 [IFLA_VXLAN_GROUP] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
Cong Wange4c7ed42013-08-31 13:44:33 +08003024 [IFLA_VXLAN_GROUP6] = { .len = sizeof(struct in6_addr) },
stephen hemmingerd3428942012-10-01 12:32:35 +00003025 [IFLA_VXLAN_LINK] = { .type = NLA_U32 },
3026 [IFLA_VXLAN_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
Cong Wange4c7ed42013-08-31 13:44:33 +08003027 [IFLA_VXLAN_LOCAL6] = { .len = sizeof(struct in6_addr) },
stephen hemmingerd3428942012-10-01 12:32:35 +00003028 [IFLA_VXLAN_TOS] = { .type = NLA_U8 },
3029 [IFLA_VXLAN_TTL] = { .type = NLA_U8 },
Daniel Borkmanne7f70af2016-03-09 03:00:03 +01003030 [IFLA_VXLAN_LABEL] = { .type = NLA_U32 },
stephen hemmingerd3428942012-10-01 12:32:35 +00003031 [IFLA_VXLAN_LEARNING] = { .type = NLA_U8 },
3032 [IFLA_VXLAN_AGEING] = { .type = NLA_U32 },
3033 [IFLA_VXLAN_LIMIT] = { .type = NLA_U32 },
stephen hemminger05f47d62012-10-09 20:35:50 +00003034 [IFLA_VXLAN_PORT_RANGE] = { .len = sizeof(struct ifla_vxlan_port_range) },
David Stevense4f67ad2012-11-20 02:50:14 +00003035 [IFLA_VXLAN_PROXY] = { .type = NLA_U8 },
3036 [IFLA_VXLAN_RSC] = { .type = NLA_U8 },
3037 [IFLA_VXLAN_L2MISS] = { .type = NLA_U8 },
3038 [IFLA_VXLAN_L3MISS] = { .type = NLA_U8 },
Alexei Starovoitovf8a9b1b2015-07-30 20:10:22 -07003039 [IFLA_VXLAN_COLLECT_METADATA] = { .type = NLA_U8 },
stephen hemminger823aa872013-04-27 11:31:57 +00003040 [IFLA_VXLAN_PORT] = { .type = NLA_U16 },
Tom Herbert5c91ae02014-11-06 18:06:01 -08003041 [IFLA_VXLAN_UDP_CSUM] = { .type = NLA_U8 },
3042 [IFLA_VXLAN_UDP_ZERO_CSUM6_TX] = { .type = NLA_U8 },
3043 [IFLA_VXLAN_UDP_ZERO_CSUM6_RX] = { .type = NLA_U8 },
Tom Herbertdfd86452015-01-12 17:00:38 -08003044 [IFLA_VXLAN_REMCSUM_TX] = { .type = NLA_U8 },
3045 [IFLA_VXLAN_REMCSUM_RX] = { .type = NLA_U8 },
Thomas Graf35114942015-01-15 03:53:55 +01003046 [IFLA_VXLAN_GBP] = { .type = NLA_FLAG, },
Jiri Bence1e53142016-04-05 14:47:13 +02003047 [IFLA_VXLAN_GPE] = { .type = NLA_FLAG, },
Tom Herbert0ace2ca2015-02-10 16:30:32 -08003048 [IFLA_VXLAN_REMCSUM_NOPARTIAL] = { .type = NLA_FLAG },
Hangbin Liu72f6d712018-04-17 14:11:28 +08003049 [IFLA_VXLAN_TTL_INHERIT] = { .type = NLA_FLAG },
Stefano Briviob4d306972018-11-08 12:19:16 +01003050 [IFLA_VXLAN_DF] = { .type = NLA_U8 },
stephen hemmingerd3428942012-10-01 12:32:35 +00003051};
3052
Matthias Schiffera8b8a8892017-06-25 23:56:01 +02003053static int vxlan_validate(struct nlattr *tb[], struct nlattr *data[],
3054 struct netlink_ext_ack *extack)
stephen hemmingerd3428942012-10-01 12:32:35 +00003055{
3056 if (tb[IFLA_ADDRESS]) {
3057 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003058 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_ADDRESS],
3059 "Provided link layer address is not Ethernet");
stephen hemmingerd3428942012-10-01 12:32:35 +00003060 return -EINVAL;
3061 }
3062
3063 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003064 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_ADDRESS],
3065 "Provided Ethernet address is not unicast");
stephen hemmingerd3428942012-10-01 12:32:35 +00003066 return -EADDRNOTAVAIL;
3067 }
3068 }
3069
Matthias Schiffera9853432017-06-19 10:03:55 +02003070 if (tb[IFLA_MTU]) {
Matthias Schiffer019b13a2017-06-27 14:42:43 +02003071 u32 mtu = nla_get_u32(tb[IFLA_MTU]);
Matthias Schiffera9853432017-06-19 10:03:55 +02003072
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003073 if (mtu < ETH_MIN_MTU || mtu > ETH_MAX_MTU) {
3074 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_MTU],
3075 "MTU must be between 68 and 65535");
Matthias Schiffera9853432017-06-19 10:03:55 +02003076 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003077 }
Matthias Schiffera9853432017-06-19 10:03:55 +02003078 }
3079
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003080 if (!data) {
3081 NL_SET_ERR_MSG(extack,
3082 "Required attributes not provided to perform the operation");
stephen hemmingerd3428942012-10-01 12:32:35 +00003083 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003084 }
stephen hemmingerd3428942012-10-01 12:32:35 +00003085
3086 if (data[IFLA_VXLAN_ID]) {
Matthias Schiffera9853432017-06-19 10:03:55 +02003087 u32 id = nla_get_u32(data[IFLA_VXLAN_ID]);
3088
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003089 if (id >= VXLAN_N_VID) {
3090 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_ID],
3091 "VXLAN ID must be lower than 16777216");
stephen hemmingerd3428942012-10-01 12:32:35 +00003092 return -ERANGE;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003093 }
stephen hemmingerd3428942012-10-01 12:32:35 +00003094 }
3095
stephen hemminger05f47d62012-10-09 20:35:50 +00003096 if (data[IFLA_VXLAN_PORT_RANGE]) {
3097 const struct ifla_vxlan_port_range *p
3098 = nla_data(data[IFLA_VXLAN_PORT_RANGE]);
3099
3100 if (ntohs(p->high) < ntohs(p->low)) {
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003101 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_PORT_RANGE],
3102 "Invalid source port range");
stephen hemminger05f47d62012-10-09 20:35:50 +00003103 return -EINVAL;
3104 }
3105 }
3106
Stefano Briviob4d306972018-11-08 12:19:16 +01003107 if (data[IFLA_VXLAN_DF]) {
3108 enum ifla_vxlan_df df = nla_get_u8(data[IFLA_VXLAN_DF]);
3109
3110 if (df < 0 || df > VXLAN_DF_MAX) {
3111 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_DF],
3112 "Invalid DF attribute");
3113 return -EINVAL;
3114 }
3115 }
3116
stephen hemmingerd3428942012-10-01 12:32:35 +00003117 return 0;
3118}
3119
Yan Burman1b13c972013-01-29 23:43:07 +00003120static void vxlan_get_drvinfo(struct net_device *netdev,
3121 struct ethtool_drvinfo *drvinfo)
3122{
3123 strlcpy(drvinfo->version, VXLAN_VERSION, sizeof(drvinfo->version));
3124 strlcpy(drvinfo->driver, "vxlan", sizeof(drvinfo->driver));
3125}
3126
3127static const struct ethtool_ops vxlan_ethtool_ops = {
3128 .get_drvinfo = vxlan_get_drvinfo,
3129 .get_link = ethtool_op_get_link,
3130};
3131
Tom Herbert3ee64f32014-07-13 19:49:42 -07003132static struct socket *vxlan_create_sock(struct net *net, bool ipv6,
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01003133 __be16 port, u32 flags, int ifindex)
stephen hemminger553675f2013-05-16 11:35:20 +00003134{
Cong Wange4c7ed42013-08-31 13:44:33 +08003135 struct socket *sock;
Tom Herbert3ee64f32014-07-13 19:49:42 -07003136 struct udp_port_cfg udp_conf;
3137 int err;
Cong Wange4c7ed42013-08-31 13:44:33 +08003138
Tom Herbert3ee64f32014-07-13 19:49:42 -07003139 memset(&udp_conf, 0, sizeof(udp_conf));
3140
3141 if (ipv6) {
3142 udp_conf.family = AF_INET6;
Tom Herbert3ee64f32014-07-13 19:49:42 -07003143 udp_conf.use_udp6_rx_checksums =
Alexander Duyck3dc2b6a2014-11-24 20:08:38 -08003144 !(flags & VXLAN_F_UDP_ZERO_CSUM6_RX);
Jiri Benca43a9ef2015-08-28 20:48:22 +02003145 udp_conf.ipv6_v6only = 1;
Tom Herbert3ee64f32014-07-13 19:49:42 -07003146 } else {
3147 udp_conf.family = AF_INET;
Cong Wange4c7ed42013-08-31 13:44:33 +08003148 }
3149
Tom Herbert3ee64f32014-07-13 19:49:42 -07003150 udp_conf.local_udp_port = port;
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01003151 udp_conf.bind_ifindex = ifindex;
Cong Wange4c7ed42013-08-31 13:44:33 +08003152
Tom Herbert3ee64f32014-07-13 19:49:42 -07003153 /* Open UDP socket */
3154 err = udp_sock_create(net, &udp_conf, &sock);
3155 if (err < 0)
3156 return ERR_PTR(err);
Cong Wange4c7ed42013-08-31 13:44:33 +08003157
Zhi Yong Wu39deb2c2013-10-28 14:01:48 +08003158 return sock;
Cong Wange4c7ed42013-08-31 13:44:33 +08003159}
3160
3161/* Create new listen socket if needed */
Jiri Bencb1be00a2015-09-24 13:50:02 +02003162static struct vxlan_sock *vxlan_socket_create(struct net *net, bool ipv6,
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01003163 __be16 port, u32 flags,
3164 int ifindex)
Cong Wange4c7ed42013-08-31 13:44:33 +08003165{
3166 struct vxlan_net *vn = net_generic(net, vxlan_net_id);
3167 struct vxlan_sock *vs;
3168 struct socket *sock;
Cong Wang31fec5a2013-05-27 22:35:52 +00003169 unsigned int h;
Andy Zhouacbf74a2014-09-16 17:31:18 -07003170 struct udp_tunnel_sock_cfg tunnel_cfg;
stephen hemminger553675f2013-05-16 11:35:20 +00003171
Or Gerlitzdc01e7d2014-01-20 13:59:21 +02003172 vs = kzalloc(sizeof(*vs), GFP_KERNEL);
Cong Wange4c7ed42013-08-31 13:44:33 +08003173 if (!vs)
stephen hemminger553675f2013-05-16 11:35:20 +00003174 return ERR_PTR(-ENOMEM);
3175
3176 for (h = 0; h < VNI_HASH_SIZE; ++h)
3177 INIT_HLIST_HEAD(&vs->vni_list[h]);
3178
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01003179 sock = vxlan_create_sock(net, ipv6, port, flags, ifindex);
Zhi Yong Wu39deb2c2013-10-28 14:01:48 +08003180 if (IS_ERR(sock)) {
stephen hemminger553675f2013-05-16 11:35:20 +00003181 kfree(vs);
Duan Jionge50fddc2013-11-01 13:09:43 +08003182 return ERR_CAST(sock);
stephen hemminger553675f2013-05-16 11:35:20 +00003183 }
3184
Cong Wange4c7ed42013-08-31 13:44:33 +08003185 vs->sock = sock;
Reshetova, Elena66af8462017-07-04 15:52:59 +03003186 refcount_set(&vs->refcnt, 1);
Tom Herbertaf33c1a2015-01-20 11:23:05 -08003187 vs->flags = (flags & VXLAN_F_RCV_FLAGS);
stephen hemminger553675f2013-05-16 11:35:20 +00003188
Pravin B Shelar9c2e24e2013-08-19 11:22:48 -07003189 spin_lock(&vn->sock_lock);
3190 hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
Alexander Duycke7b3db52016-06-16 12:20:52 -07003191 udp_tunnel_notify_add_rx_port(sock,
Alexander Duyckb9adcd692016-06-16 12:23:19 -07003192 (vs->flags & VXLAN_F_GPE) ?
3193 UDP_TUNNEL_TYPE_VXLAN_GPE :
Alexander Duycke7b3db52016-06-16 12:20:52 -07003194 UDP_TUNNEL_TYPE_VXLAN);
Pravin B Shelar9c2e24e2013-08-19 11:22:48 -07003195 spin_unlock(&vn->sock_lock);
stephen hemminger553675f2013-05-16 11:35:20 +00003196
3197 /* Mark socket as an encapsulation socket. */
Tom Herbert5602c482016-04-05 08:22:53 -07003198 memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
Andy Zhouacbf74a2014-09-16 17:31:18 -07003199 tunnel_cfg.sk_user_data = vs;
3200 tunnel_cfg.encap_type = 1;
Jiri Bencf2d1968ec2016-02-23 18:02:58 +01003201 tunnel_cfg.encap_rcv = vxlan_rcv;
Stefano Brivioc3a43b92018-11-08 12:19:15 +01003202 tunnel_cfg.encap_err_lookup = vxlan_err_lookup;
Andy Zhouacbf74a2014-09-16 17:31:18 -07003203 tunnel_cfg.encap_destroy = NULL;
Tom Herbert5602c482016-04-05 08:22:53 -07003204 tunnel_cfg.gro_receive = vxlan_gro_receive;
3205 tunnel_cfg.gro_complete = vxlan_gro_complete;
Andy Zhouacbf74a2014-09-16 17:31:18 -07003206
3207 setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
Cong Wange4c7ed42013-08-31 13:44:33 +08003208
Pravin B Shelar9c2e24e2013-08-19 11:22:48 -07003209 return vs;
3210}
stephen hemminger553675f2013-05-16 11:35:20 +00003211
Jiri Bencb1be00a2015-09-24 13:50:02 +02003212static int __vxlan_sock_add(struct vxlan_dev *vxlan, bool ipv6)
Pravin B Shelar9c2e24e2013-08-19 11:22:48 -07003213{
Jiri Benc205f3562015-09-24 13:50:01 +02003214 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
3215 struct vxlan_sock *vs = NULL;
Jiri Benc69e76662017-07-02 19:00:57 +02003216 struct vxlan_dev_node *node;
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01003217 int l3mdev_index = 0;
3218
3219 if (vxlan->cfg.remote_ifindex)
3220 l3mdev_index = l3mdev_master_upper_ifindex_by_index(
3221 vxlan->net, vxlan->cfg.remote_ifindex);
Pravin B Shelar9c2e24e2013-08-19 11:22:48 -07003222
Jiri Benc205f3562015-09-24 13:50:01 +02003223 if (!vxlan->cfg.no_share) {
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03003224 spin_lock(&vn->sock_lock);
Jiri Benc205f3562015-09-24 13:50:01 +02003225 vs = vxlan_find_sock(vxlan->net, ipv6 ? AF_INET6 : AF_INET,
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01003226 vxlan->cfg.dst_port, vxlan->cfg.flags,
3227 l3mdev_index);
Reshetova, Elena66af8462017-07-04 15:52:59 +03003228 if (vs && !refcount_inc_not_zero(&vs->refcnt)) {
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03003229 spin_unlock(&vn->sock_lock);
Jiri Benc205f3562015-09-24 13:50:01 +02003230 return -EBUSY;
Marcelo Ricardo Leitner56ef9c92015-03-18 14:50:44 -03003231 }
3232 spin_unlock(&vn->sock_lock);
3233 }
Jiri Benc205f3562015-09-24 13:50:01 +02003234 if (!vs)
Jiri Bencb1be00a2015-09-24 13:50:02 +02003235 vs = vxlan_socket_create(vxlan->net, ipv6,
Alexis Bauvinaab8cc32018-12-03 10:54:40 +01003236 vxlan->cfg.dst_port, vxlan->cfg.flags,
3237 l3mdev_index);
Jiri Benc205f3562015-09-24 13:50:01 +02003238 if (IS_ERR(vs))
3239 return PTR_ERR(vs);
Jiri Bencb1be00a2015-09-24 13:50:02 +02003240#if IS_ENABLED(CONFIG_IPV6)
Jiri Benc69e76662017-07-02 19:00:57 +02003241 if (ipv6) {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07003242 rcu_assign_pointer(vxlan->vn6_sock, vs);
Jiri Benc69e76662017-07-02 19:00:57 +02003243 node = &vxlan->hlist6;
3244 } else
Jiri Bencb1be00a2015-09-24 13:50:02 +02003245#endif
Jiri Benc69e76662017-07-02 19:00:57 +02003246 {
pravin shelarc6fcc4f2016-10-28 09:59:15 -07003247 rcu_assign_pointer(vxlan->vn4_sock, vs);
Jiri Benc69e76662017-07-02 19:00:57 +02003248 node = &vxlan->hlist4;
3249 }
3250 vxlan_vs_add_dev(vs, vxlan, node);
Jiri Benc205f3562015-09-24 13:50:01 +02003251 return 0;
stephen hemminger553675f2013-05-16 11:35:20 +00003252}
3253
Jiri Bencb1be00a2015-09-24 13:50:02 +02003254static int vxlan_sock_add(struct vxlan_dev *vxlan)
3255{
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003256 bool metadata = vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA;
3257 bool ipv6 = vxlan->cfg.flags & VXLAN_F_IPV6 || metadata;
Jiri Bencd074bf92017-04-27 21:24:35 +02003258 bool ipv4 = !ipv6 || metadata;
Jiri Bencb1be00a2015-09-24 13:50:02 +02003259 int ret = 0;
3260
pravin shelarc6fcc4f2016-10-28 09:59:15 -07003261 RCU_INIT_POINTER(vxlan->vn4_sock, NULL);
Jiri Bencb1be00a2015-09-24 13:50:02 +02003262#if IS_ENABLED(CONFIG_IPV6)
pravin shelarc6fcc4f2016-10-28 09:59:15 -07003263 RCU_INIT_POINTER(vxlan->vn6_sock, NULL);
Jiri Bencd074bf92017-04-27 21:24:35 +02003264 if (ipv6) {
Jiri Bencb1be00a2015-09-24 13:50:02 +02003265 ret = __vxlan_sock_add(vxlan, true);
Jiri Bencd074bf92017-04-27 21:24:35 +02003266 if (ret < 0 && ret != -EAFNOSUPPORT)
3267 ipv4 = false;
3268 }
Jiri Bencb1be00a2015-09-24 13:50:02 +02003269#endif
Jiri Bencd074bf92017-04-27 21:24:35 +02003270 if (ipv4)
Jiri Bencb1be00a2015-09-24 13:50:02 +02003271 ret = __vxlan_sock_add(vxlan, false);
3272 if (ret < 0)
3273 vxlan_sock_release(vxlan);
3274 return ret;
3275}
3276
Matthias Schiffera9853432017-06-19 10:03:55 +02003277static int vxlan_config_validate(struct net *src_net, struct vxlan_config *conf,
3278 struct net_device **lower,
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003279 struct vxlan_dev *old,
3280 struct netlink_ext_ack *extack)
stephen hemmingerd3428942012-10-01 12:32:35 +00003281{
Nicolas Dichtel33564bb2015-01-26 22:28:14 +01003282 struct vxlan_net *vn = net_generic(src_net, vxlan_net_id);
Matthias Schiffera9853432017-06-19 10:03:55 +02003283 struct vxlan_dev *tmp;
3284 bool use_ipv6 = false;
3285
3286 if (conf->flags & VXLAN_F_GPE) {
3287 /* For now, allow GPE only together with
3288 * COLLECT_METADATA. This can be relaxed later; in such
3289 * case, the other side of the PtP link will have to be
3290 * provided.
3291 */
3292 if ((conf->flags & ~VXLAN_F_ALLOWED_GPE) ||
3293 !(conf->flags & VXLAN_F_COLLECT_METADATA)) {
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003294 NL_SET_ERR_MSG(extack,
3295 "VXLAN GPE does not support this combination of attributes");
Matthias Schiffera9853432017-06-19 10:03:55 +02003296 return -EINVAL;
3297 }
3298 }
3299
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003300 if (!conf->remote_ip.sa.sa_family && !conf->saddr.sa.sa_family) {
3301 /* Unless IPv6 is explicitly requested, assume IPv4 */
Matthias Schiffera9853432017-06-19 10:03:55 +02003302 conf->remote_ip.sa.sa_family = AF_INET;
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003303 conf->saddr.sa.sa_family = AF_INET;
3304 } else if (!conf->remote_ip.sa.sa_family) {
3305 conf->remote_ip.sa.sa_family = conf->saddr.sa.sa_family;
3306 } else if (!conf->saddr.sa.sa_family) {
3307 conf->saddr.sa.sa_family = conf->remote_ip.sa.sa_family;
3308 }
Matthias Schiffera9853432017-06-19 10:03:55 +02003309
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003310 if (conf->saddr.sa.sa_family != conf->remote_ip.sa.sa_family) {
3311 NL_SET_ERR_MSG(extack,
3312 "Local and remote address must be from the same family");
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003313 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003314 }
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003315
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003316 if (vxlan_addr_multicast(&conf->saddr)) {
3317 NL_SET_ERR_MSG(extack, "Local address cannot be multicast");
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003318 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003319 }
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003320
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003321 if (conf->saddr.sa.sa_family == AF_INET6) {
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003322 if (!IS_ENABLED(CONFIG_IPV6)) {
3323 NL_SET_ERR_MSG(extack,
3324 "IPv6 support not enabled in the kernel");
Matthias Schiffera9853432017-06-19 10:03:55 +02003325 return -EPFNOSUPPORT;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003326 }
Matthias Schiffera9853432017-06-19 10:03:55 +02003327 use_ipv6 = true;
3328 conf->flags |= VXLAN_F_IPV6;
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003329
3330 if (!(conf->flags & VXLAN_F_COLLECT_METADATA)) {
3331 int local_type =
3332 ipv6_addr_type(&conf->saddr.sin6.sin6_addr);
3333 int remote_type =
3334 ipv6_addr_type(&conf->remote_ip.sin6.sin6_addr);
3335
3336 if (local_type & IPV6_ADDR_LINKLOCAL) {
3337 if (!(remote_type & IPV6_ADDR_LINKLOCAL) &&
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003338 (remote_type != IPV6_ADDR_ANY)) {
3339 NL_SET_ERR_MSG(extack,
3340 "Invalid combination of local and remote address scopes");
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003341 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003342 }
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003343
3344 conf->flags |= VXLAN_F_IPV6_LINKLOCAL;
3345 } else {
3346 if (remote_type ==
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003347 (IPV6_ADDR_UNICAST | IPV6_ADDR_LINKLOCAL)) {
3348 NL_SET_ERR_MSG(extack,
3349 "Invalid combination of local and remote address scopes");
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003350 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003351 }
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003352
3353 conf->flags &= ~VXLAN_F_IPV6_LINKLOCAL;
3354 }
3355 }
Matthias Schiffera9853432017-06-19 10:03:55 +02003356 }
3357
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003358 if (conf->label && !use_ipv6) {
3359 NL_SET_ERR_MSG(extack,
3360 "Label attribute only applies to IPv6 VXLAN devices");
Matthias Schiffera9853432017-06-19 10:03:55 +02003361 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003362 }
Matthias Schiffera9853432017-06-19 10:03:55 +02003363
3364 if (conf->remote_ifindex) {
3365 struct net_device *lowerdev;
3366
3367 lowerdev = __dev_get_by_index(src_net, conf->remote_ifindex);
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003368 if (!lowerdev) {
3369 NL_SET_ERR_MSG(extack,
3370 "Invalid local interface, device not found");
Matthias Schiffera9853432017-06-19 10:03:55 +02003371 return -ENODEV;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003372 }
Matthias Schiffera9853432017-06-19 10:03:55 +02003373
3374#if IS_ENABLED(CONFIG_IPV6)
3375 if (use_ipv6) {
3376 struct inet6_dev *idev = __in6_dev_get(lowerdev);
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003377 if (idev && idev->cnf.disable_ipv6) {
3378 NL_SET_ERR_MSG(extack,
3379 "IPv6 support disabled by administrator");
Matthias Schiffera9853432017-06-19 10:03:55 +02003380 return -EPERM;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003381 }
Matthias Schiffera9853432017-06-19 10:03:55 +02003382 }
3383#endif
3384
3385 *lower = lowerdev;
3386 } else {
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003387 if (vxlan_addr_multicast(&conf->remote_ip)) {
3388 NL_SET_ERR_MSG(extack,
3389 "Local interface required for multicast remote destination");
3390
Matthias Schiffera9853432017-06-19 10:03:55 +02003391 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003392 }
Matthias Schiffera9853432017-06-19 10:03:55 +02003393
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003394#if IS_ENABLED(CONFIG_IPV6)
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003395 if (conf->flags & VXLAN_F_IPV6_LINKLOCAL) {
3396 NL_SET_ERR_MSG(extack,
3397 "Local interface required for link-local local/remote addresses");
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003398 return -EINVAL;
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003399 }
Matthias Schiffer0f22a3c2017-06-19 10:03:58 +02003400#endif
3401
Matthias Schiffera9853432017-06-19 10:03:55 +02003402 *lower = NULL;
3403 }
3404
3405 if (!conf->dst_port) {
3406 if (conf->flags & VXLAN_F_GPE)
3407 conf->dst_port = htons(4790); /* IANA VXLAN-GPE port */
3408 else
3409 conf->dst_port = htons(vxlan_port);
3410 }
3411
3412 if (!conf->age_interval)
3413 conf->age_interval = FDB_AGE_DEFAULT;
3414
3415 list_for_each_entry(tmp, &vn->vxlan_list, next) {
3416 if (tmp == old)
3417 continue;
3418
Matthias Schiffer49f810f2017-06-19 10:04:00 +02003419 if (tmp->cfg.vni != conf->vni)
3420 continue;
3421 if (tmp->cfg.dst_port != conf->dst_port)
3422 continue;
3423 if ((tmp->cfg.flags & (VXLAN_F_RCV_FLAGS | VXLAN_F_IPV6)) !=
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003424 (conf->flags & (VXLAN_F_RCV_FLAGS | VXLAN_F_IPV6)))
Matthias Schiffer49f810f2017-06-19 10:04:00 +02003425 continue;
3426
3427 if ((conf->flags & VXLAN_F_IPV6_LINKLOCAL) &&
3428 tmp->cfg.remote_ifindex != conf->remote_ifindex)
3429 continue;
3430
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003431 NL_SET_ERR_MSG(extack,
3432 "A VXLAN device with the specified VNI already exists");
Matthias Schiffer49f810f2017-06-19 10:04:00 +02003433 return -EEXIST;
Matthias Schiffera9853432017-06-19 10:03:55 +02003434 }
3435
3436 return 0;
3437}
3438
3439static void vxlan_config_apply(struct net_device *dev,
3440 struct vxlan_config *conf,
Sabrina Dubroca889ce932017-06-30 15:50:00 +02003441 struct net_device *lowerdev,
3442 struct net *src_net,
3443 bool changelink)
Matthias Schiffera9853432017-06-19 10:03:55 +02003444{
3445 struct vxlan_dev *vxlan = netdev_priv(dev);
Atzm Watanabec7995c42013-04-16 02:50:52 +00003446 struct vxlan_rdst *dst = &vxlan->default_dst;
Jiri Bencb1be00a2015-09-24 13:50:02 +02003447 unsigned short needed_headroom = ETH_HLEN;
Matthias Schiffera9853432017-06-19 10:03:55 +02003448 bool use_ipv6 = !!(conf->flags & VXLAN_F_IPV6);
3449 int max_mtu = ETH_MAX_MTU;
stephen hemmingerd3428942012-10-01 12:32:35 +00003450
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003451 if (!changelink) {
Matthias Schiffera9853432017-06-19 10:03:55 +02003452 if (conf->flags & VXLAN_F_GPE)
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003453 vxlan_raw_setup(dev);
Matthias Schiffera9853432017-06-19 10:03:55 +02003454 else
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003455 vxlan_ether_setup(dev);
Jiri Bence1e53142016-04-05 14:47:13 +02003456
Matthias Schiffera9853432017-06-19 10:03:55 +02003457 if (conf->mtu)
3458 dev->mtu = conf->mtu;
Sabrina Dubroca889ce932017-06-30 15:50:00 +02003459
3460 vxlan->net = src_net;
Jiri Bence1e53142016-04-05 14:47:13 +02003461 }
Jiri Benc0c867c92016-04-05 14:47:10 +02003462
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003463 dst->remote_vni = conf->vni;
3464
3465 memcpy(&dst->remote_ip, &conf->remote_ip, sizeof(conf->remote_ip));
stephen hemmingerd3428942012-10-01 12:32:35 +00003466
Matthias Schiffera9853432017-06-19 10:03:55 +02003467 if (lowerdev) {
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003468 dst->remote_ifindex = conf->remote_ifindex;
stephen hemmingerd3428942012-10-01 12:32:35 +00003469
Felix Manlunasd6acfeb2017-03-29 17:56:43 -07003470 dev->gso_max_size = lowerdev->gso_max_size;
3471 dev->gso_max_segs = lowerdev->gso_max_segs;
Matthias Schiffera9853432017-06-19 10:03:55 +02003472
3473 needed_headroom = lowerdev->hard_header_len;
3474
3475 max_mtu = lowerdev->mtu - (use_ipv6 ? VXLAN6_HEADROOM :
3476 VXLAN_HEADROOM);
Alexey Kodanevf870c1f2017-12-14 20:20:00 +03003477 if (max_mtu < ETH_MIN_MTU)
3478 max_mtu = ETH_MIN_MTU;
3479
3480 if (!changelink && !conf->mtu)
3481 dev->mtu = max_mtu;
Felix Manlunasd6acfeb2017-03-29 17:56:43 -07003482 }
3483
Matthias Schiffera9853432017-06-19 10:03:55 +02003484 if (dev->mtu > max_mtu)
3485 dev->mtu = max_mtu;
David Wragg7e059152016-02-10 00:05:58 +00003486
Jiri Bencb1be00a2015-09-24 13:50:02 +02003487 if (use_ipv6 || conf->flags & VXLAN_F_COLLECT_METADATA)
3488 needed_headroom += VXLAN6_HEADROOM;
3489 else
3490 needed_headroom += VXLAN_HEADROOM;
3491 dev->needed_headroom = needed_headroom;
3492
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003493 memcpy(&vxlan->cfg, conf, sizeof(*conf));
Matthias Schiffera9853432017-06-19 10:03:55 +02003494}
stephen hemmingerd3428942012-10-01 12:32:35 +00003495
Matthias Schiffera9853432017-06-19 10:03:55 +02003496static int vxlan_dev_configure(struct net *src_net, struct net_device *dev,
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003497 struct vxlan_config *conf, bool changelink,
3498 struct netlink_ext_ack *extack)
Matthias Schiffera9853432017-06-19 10:03:55 +02003499{
3500 struct vxlan_dev *vxlan = netdev_priv(dev);
3501 struct net_device *lowerdev;
3502 int ret;
Vincent Bernatafb97182012-10-30 10:27:16 +00003503
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003504 ret = vxlan_config_validate(src_net, conf, &lowerdev, vxlan, extack);
Matthias Schiffera9853432017-06-19 10:03:55 +02003505 if (ret)
3506 return ret;
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003507
Sabrina Dubroca889ce932017-06-30 15:50:00 +02003508 vxlan_config_apply(dev, conf, lowerdev, src_net, changelink);
stephen hemminger553675f2013-05-16 11:35:20 +00003509
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003510 return 0;
3511}
3512
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003513static int __vxlan_dev_create(struct net *net, struct net_device *dev,
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003514 struct vxlan_config *conf,
3515 struct netlink_ext_ack *extack)
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003516{
3517 struct vxlan_net *vn = net_generic(net, vxlan_net_id);
3518 struct vxlan_dev *vxlan = netdev_priv(dev);
Roopa Prabhu0241b832018-07-04 16:46:32 -07003519 struct vxlan_fdb *f = NULL;
Petr Machata6db92462018-12-18 13:16:00 +00003520 bool unregister = false;
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003521 int err;
3522
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003523 err = vxlan_dev_configure(net, dev, conf, false, extack);
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003524 if (err)
3525 return err;
3526
3527 dev->ethtool_ops = &vxlan_ethtool_ops;
3528
3529 /* create an fdb entry for a valid default destination */
3530 if (!vxlan_addr_any(&vxlan->default_dst.remote_ip)) {
Roopa Prabhu0241b832018-07-04 16:46:32 -07003531 err = vxlan_fdb_create(vxlan, all_zeros_mac,
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003532 &vxlan->default_dst.remote_ip,
3533 NUD_REACHABLE | NUD_PERMANENT,
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003534 vxlan->cfg.dst_port,
3535 vxlan->default_dst.remote_vni,
3536 vxlan->default_dst.remote_vni,
3537 vxlan->default_dst.remote_ifindex,
Roopa Prabhu0241b832018-07-04 16:46:32 -07003538 NTF_SELF, &f);
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003539 if (err)
3540 return err;
3541 }
3542
3543 err = register_netdevice(dev);
Roopa Prabhu0241b832018-07-04 16:46:32 -07003544 if (err)
3545 goto errout;
Petr Machata6db92462018-12-18 13:16:00 +00003546 unregister = true;
Roopa Prabhu0241b832018-07-04 16:46:32 -07003547
3548 err = rtnl_configure_link(dev, NULL);
Petr Machata6db92462018-12-18 13:16:00 +00003549 if (err)
Roopa Prabhu0241b832018-07-04 16:46:32 -07003550 goto errout;
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003551
Roopa Prabhu0241b832018-07-04 16:46:32 -07003552 /* notify default fdb entry */
Petr Machata61f46fe2019-01-16 23:06:38 +00003553 if (f) {
3554 err = vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f),
Petr Machata4c59b7d2019-01-16 23:06:54 +00003555 RTM_NEWNEIGH, true, extack);
Petr Machata61f46fe2019-01-16 23:06:38 +00003556 if (err)
3557 goto errout;
3558 }
Roopa Prabhu0241b832018-07-04 16:46:32 -07003559
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003560 list_add(&vxlan->next, &vn->vxlan_list);
3561 return 0;
Petr Machata6db92462018-12-18 13:16:00 +00003562
Roopa Prabhu0241b832018-07-04 16:46:32 -07003563errout:
Petr Machata6db92462018-12-18 13:16:00 +00003564 /* unregister_netdevice() destroys the default FDB entry with deletion
3565 * notification. But the addition notification was not sent yet, so
3566 * destroy the entry by hand here.
3567 */
Roopa Prabhu0241b832018-07-04 16:46:32 -07003568 if (f)
Petr Machata0e6160f2018-11-21 08:02:35 +00003569 vxlan_fdb_destroy(vxlan, f, false, false);
Petr Machata6db92462018-12-18 13:16:00 +00003570 if (unregister)
3571 unregister_netdevice(dev);
Roopa Prabhu0241b832018-07-04 16:46:32 -07003572 return err;
Nicolas Dichtelc80498e2017-03-13 16:24:03 +01003573}
3574
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003575static int vxlan_nl2conf(struct nlattr *tb[], struct nlattr *data[],
3576 struct net_device *dev, struct vxlan_config *conf,
3577 bool changelink)
3578{
3579 struct vxlan_dev *vxlan = netdev_priv(dev);
3580
3581 memset(conf, 0, sizeof(*conf));
3582
3583 /* if changelink operation, start with old existing cfg */
3584 if (changelink)
3585 memcpy(conf, &vxlan->cfg, sizeof(*conf));
3586
3587 if (data[IFLA_VXLAN_ID]) {
3588 __be32 vni = cpu_to_be32(nla_get_u32(data[IFLA_VXLAN_ID]));
3589
3590 if (changelink && (vni != conf->vni))
3591 return -EOPNOTSUPP;
3592 conf->vni = cpu_to_be32(nla_get_u32(data[IFLA_VXLAN_ID]));
3593 }
3594
3595 if (data[IFLA_VXLAN_GROUP]) {
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003596 if (changelink && (conf->remote_ip.sa.sa_family != AF_INET))
3597 return -EOPNOTSUPP;
3598
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003599 conf->remote_ip.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_GROUP]);
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003600 conf->remote_ip.sa.sa_family = AF_INET;
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003601 } else if (data[IFLA_VXLAN_GROUP6]) {
3602 if (!IS_ENABLED(CONFIG_IPV6))
3603 return -EPFNOSUPPORT;
3604
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003605 if (changelink && (conf->remote_ip.sa.sa_family != AF_INET6))
3606 return -EOPNOTSUPP;
3607
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003608 conf->remote_ip.sin6.sin6_addr = nla_get_in6_addr(data[IFLA_VXLAN_GROUP6]);
3609 conf->remote_ip.sa.sa_family = AF_INET6;
3610 }
3611
3612 if (data[IFLA_VXLAN_LOCAL]) {
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003613 if (changelink && (conf->saddr.sa.sa_family != AF_INET))
3614 return -EOPNOTSUPP;
3615
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003616 conf->saddr.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_LOCAL]);
3617 conf->saddr.sa.sa_family = AF_INET;
3618 } else if (data[IFLA_VXLAN_LOCAL6]) {
3619 if (!IS_ENABLED(CONFIG_IPV6))
3620 return -EPFNOSUPPORT;
3621
Matthias Schifferce44a4a2017-06-19 10:03:57 +02003622 if (changelink && (conf->saddr.sa.sa_family != AF_INET6))
3623 return -EOPNOTSUPP;
3624
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003625 /* TODO: respect scope id */
3626 conf->saddr.sin6.sin6_addr = nla_get_in6_addr(data[IFLA_VXLAN_LOCAL6]);
3627 conf->saddr.sa.sa_family = AF_INET6;
3628 }
3629
3630 if (data[IFLA_VXLAN_LINK])
3631 conf->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]);
3632
3633 if (data[IFLA_VXLAN_TOS])
3634 conf->tos = nla_get_u8(data[IFLA_VXLAN_TOS]);
3635
3636 if (data[IFLA_VXLAN_TTL])
3637 conf->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);
3638
Hangbin Liu72f6d712018-04-17 14:11:28 +08003639 if (data[IFLA_VXLAN_TTL_INHERIT]) {
3640 if (changelink)
3641 return -EOPNOTSUPP;
3642 conf->flags |= VXLAN_F_TTL_INHERIT;
3643 }
3644
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003645 if (data[IFLA_VXLAN_LABEL])
3646 conf->label = nla_get_be32(data[IFLA_VXLAN_LABEL]) &
3647 IPV6_FLOWLABEL_MASK;
3648
3649 if (data[IFLA_VXLAN_LEARNING]) {
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003650 if (nla_get_u8(data[IFLA_VXLAN_LEARNING]))
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003651 conf->flags |= VXLAN_F_LEARN;
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003652 else
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003653 conf->flags &= ~VXLAN_F_LEARN;
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003654 } else if (!changelink) {
3655 /* default to learn on a new device */
3656 conf->flags |= VXLAN_F_LEARN;
3657 }
3658
Ido Schimmel40051c42018-11-21 08:02:40 +00003659 if (data[IFLA_VXLAN_AGEING])
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003660 conf->age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003661
3662 if (data[IFLA_VXLAN_PROXY]) {
3663 if (changelink)
3664 return -EOPNOTSUPP;
3665 if (nla_get_u8(data[IFLA_VXLAN_PROXY]))
3666 conf->flags |= VXLAN_F_PROXY;
3667 }
3668
3669 if (data[IFLA_VXLAN_RSC]) {
3670 if (changelink)
3671 return -EOPNOTSUPP;
3672 if (nla_get_u8(data[IFLA_VXLAN_RSC]))
3673 conf->flags |= VXLAN_F_RSC;
3674 }
3675
3676 if (data[IFLA_VXLAN_L2MISS]) {
3677 if (changelink)
3678 return -EOPNOTSUPP;
3679 if (nla_get_u8(data[IFLA_VXLAN_L2MISS]))
3680 conf->flags |= VXLAN_F_L2MISS;
3681 }
3682
3683 if (data[IFLA_VXLAN_L3MISS]) {
3684 if (changelink)
3685 return -EOPNOTSUPP;
3686 if (nla_get_u8(data[IFLA_VXLAN_L3MISS]))
3687 conf->flags |= VXLAN_F_L3MISS;
3688 }
3689
3690 if (data[IFLA_VXLAN_LIMIT]) {
3691 if (changelink)
3692 return -EOPNOTSUPP;
3693 conf->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);
3694 }
3695
3696 if (data[IFLA_VXLAN_COLLECT_METADATA]) {
3697 if (changelink)
3698 return -EOPNOTSUPP;
3699 if (nla_get_u8(data[IFLA_VXLAN_COLLECT_METADATA]))
3700 conf->flags |= VXLAN_F_COLLECT_METADATA;
3701 }
3702
3703 if (data[IFLA_VXLAN_PORT_RANGE]) {
3704 if (!changelink) {
3705 const struct ifla_vxlan_port_range *p
3706 = nla_data(data[IFLA_VXLAN_PORT_RANGE]);
3707 conf->port_min = ntohs(p->low);
3708 conf->port_max = ntohs(p->high);
3709 } else {
3710 return -EOPNOTSUPP;
3711 }
3712 }
3713
3714 if (data[IFLA_VXLAN_PORT]) {
3715 if (changelink)
3716 return -EOPNOTSUPP;
3717 conf->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);
3718 }
3719
3720 if (data[IFLA_VXLAN_UDP_CSUM]) {
3721 if (changelink)
3722 return -EOPNOTSUPP;
3723 if (!nla_get_u8(data[IFLA_VXLAN_UDP_CSUM]))
3724 conf->flags |= VXLAN_F_UDP_ZERO_CSUM_TX;
3725 }
3726
3727 if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]) {
3728 if (changelink)
3729 return -EOPNOTSUPP;
3730 if (nla_get_u8(data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]))
3731 conf->flags |= VXLAN_F_UDP_ZERO_CSUM6_TX;
3732 }
3733
3734 if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]) {
3735 if (changelink)
3736 return -EOPNOTSUPP;
3737 if (nla_get_u8(data[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]))
3738 conf->flags |= VXLAN_F_UDP_ZERO_CSUM6_RX;
3739 }
3740
3741 if (data[IFLA_VXLAN_REMCSUM_TX]) {
3742 if (changelink)
3743 return -EOPNOTSUPP;
3744 if (nla_get_u8(data[IFLA_VXLAN_REMCSUM_TX]))
3745 conf->flags |= VXLAN_F_REMCSUM_TX;
3746 }
3747
3748 if (data[IFLA_VXLAN_REMCSUM_RX]) {
3749 if (changelink)
3750 return -EOPNOTSUPP;
3751 if (nla_get_u8(data[IFLA_VXLAN_REMCSUM_RX]))
3752 conf->flags |= VXLAN_F_REMCSUM_RX;
3753 }
3754
3755 if (data[IFLA_VXLAN_GBP]) {
3756 if (changelink)
3757 return -EOPNOTSUPP;
3758 conf->flags |= VXLAN_F_GBP;
3759 }
3760
3761 if (data[IFLA_VXLAN_GPE]) {
3762 if (changelink)
3763 return -EOPNOTSUPP;
3764 conf->flags |= VXLAN_F_GPE;
3765 }
3766
3767 if (data[IFLA_VXLAN_REMCSUM_NOPARTIAL]) {
3768 if (changelink)
3769 return -EOPNOTSUPP;
3770 conf->flags |= VXLAN_F_REMCSUM_NOPARTIAL;
3771 }
3772
3773 if (tb[IFLA_MTU]) {
3774 if (changelink)
3775 return -EOPNOTSUPP;
3776 conf->mtu = nla_get_u32(tb[IFLA_MTU]);
3777 }
3778
Stefano Briviob4d306972018-11-08 12:19:16 +01003779 if (data[IFLA_VXLAN_DF])
3780 conf->df = nla_get_u8(data[IFLA_VXLAN_DF]);
3781
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003782 return 0;
3783}
3784
3785static int vxlan_newlink(struct net *src_net, struct net_device *dev,
Matthias Schiffer7a3f4a12017-06-25 23:55:59 +02003786 struct nlattr *tb[], struct nlattr *data[],
3787 struct netlink_ext_ack *extack)
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003788{
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003789 struct vxlan_config conf;
3790 int err;
3791
3792 err = vxlan_nl2conf(tb, data, dev, &conf, false);
3793 if (err)
3794 return err;
3795
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07003796 return __vxlan_dev_create(src_net, dev, &conf, extack);
stephen hemmingerd3428942012-10-01 12:32:35 +00003797}
3798
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003799static int vxlan_changelink(struct net_device *dev, struct nlattr *tb[],
Matthias Schifferad744b22017-06-25 23:56:00 +02003800 struct nlattr *data[],
3801 struct netlink_ext_ack *extack)
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003802{
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003803 struct vxlan_dev *vxlan = netdev_priv(dev);
3804 struct vxlan_rdst *dst = &vxlan->default_dst;
Petr Machata8db9427d52019-01-16 23:06:39 +00003805 struct net_device *lowerdev;
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003806 struct vxlan_config conf;
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003807 int err;
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003808
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003809 err = vxlan_nl2conf(tb, data,
3810 dev, &conf, true);
3811 if (err)
3812 return err;
Jesse Grosse277de52015-10-16 16:36:00 -07003813
Petr Machata8db9427d52019-01-16 23:06:39 +00003814 err = vxlan_config_validate(vxlan->net, &conf, &lowerdev,
3815 vxlan, extack);
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003816 if (err)
3817 return err;
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003818
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003819 /* handle default dst entry */
Petr Machata038a5a92019-01-16 23:06:41 +00003820 if (!vxlan_addr_equal(&conf.remote_ip, &dst->remote_ip)) {
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003821 spin_lock_bh(&vxlan->hash_lock);
Petr Machata038a5a92019-01-16 23:06:41 +00003822 if (!vxlan_addr_any(&conf.remote_ip)) {
Petr Machatace5e098f2018-12-18 13:16:02 +00003823 err = vxlan_fdb_update(vxlan, all_zeros_mac,
Petr Machata038a5a92019-01-16 23:06:41 +00003824 &conf.remote_ip,
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003825 NUD_REACHABLE | NUD_PERMANENT,
Petr Machatace5e098f2018-12-18 13:16:02 +00003826 NLM_F_APPEND | NLM_F_CREATE,
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003827 vxlan->cfg.dst_port,
Petr Machata038a5a92019-01-16 23:06:41 +00003828 conf.vni, conf.vni,
3829 conf.remote_ifindex,
Petr Machata4c59b7d2019-01-16 23:06:54 +00003830 NTF_SELF, true, extack);
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003831 if (err) {
3832 spin_unlock_bh(&vxlan->hash_lock);
3833 return err;
3834 }
3835 }
Petr Machata1cdc98c2019-01-16 23:06:43 +00003836 if (!vxlan_addr_any(&dst->remote_ip))
3837 __vxlan_fdb_delete(vxlan, all_zeros_mac,
3838 dst->remote_ip,
3839 vxlan->cfg.dst_port,
3840 dst->remote_vni,
3841 dst->remote_vni,
3842 dst->remote_ifindex,
3843 true);
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003844 spin_unlock_bh(&vxlan->hash_lock);
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003845 }
3846
Petr Machata038a5a92019-01-16 23:06:41 +00003847 if (conf.age_interval != vxlan->cfg.age_interval)
3848 mod_timer(&vxlan->age_timer, jiffies);
3849
3850 vxlan_config_apply(dev, &conf, lowerdev, vxlan->net, true);
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08003851 return 0;
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003852}
3853
stephen hemmingerd3428942012-10-01 12:32:35 +00003854static void vxlan_dellink(struct net_device *dev, struct list_head *head)
3855{
3856 struct vxlan_dev *vxlan = netdev_priv(dev);
3857
Roopa Prabhu8b3f9332017-01-23 20:44:32 -08003858 vxlan_flush(vxlan, true);
3859
Tom Herbert58ce31c2015-08-19 17:07:33 -07003860 gro_cells_destroy(&vxlan->gro_cells);
stephen hemminger553675f2013-05-16 11:35:20 +00003861 list_del(&vxlan->next);
stephen hemmingerd3428942012-10-01 12:32:35 +00003862 unregister_netdevice_queue(dev, head);
3863}
3864
3865static size_t vxlan_get_size(const struct net_device *dev)
3866{
3867
3868 return nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_ID */
Cong Wange4c7ed42013-08-31 13:44:33 +08003869 nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */
stephen hemmingerd3428942012-10-01 12:32:35 +00003870 nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_LINK */
Cong Wange4c7ed42013-08-31 13:44:33 +08003871 nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */
stephen hemmingerd3428942012-10-01 12:32:35 +00003872 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_TTL */
Hangbin Liu8fd78062018-09-26 10:35:42 +08003873 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_TTL_INHERIT */
stephen hemmingerd3428942012-10-01 12:32:35 +00003874 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_TOS */
Stefano Briviob4d306972018-11-08 12:19:16 +01003875 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_DF */
Daniel Borkmanne7f70af2016-03-09 03:00:03 +01003876 nla_total_size(sizeof(__be32)) + /* IFLA_VXLAN_LABEL */
stephen hemmingerd3428942012-10-01 12:32:35 +00003877 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_LEARNING */
David Stevense4f67ad2012-11-20 02:50:14 +00003878 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_PROXY */
3879 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_RSC */
3880 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_L2MISS */
3881 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_L3MISS */
Alexei Starovoitovda8b43c2015-08-04 22:51:07 -07003882 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_COLLECT_METADATA */
stephen hemmingerd3428942012-10-01 12:32:35 +00003883 nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_AGEING */
3884 nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_LIMIT */
stephen hemminger05f47d62012-10-09 20:35:50 +00003885 nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
Tom Herbert359a0ea2014-06-04 17:20:29 -07003886 nla_total_size(sizeof(__be16)) + /* IFLA_VXLAN_PORT */
3887 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_CSUM */
3888 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_ZERO_CSUM6_TX */
3889 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_ZERO_CSUM6_RX */
Tom Herbertdfd86452015-01-12 17:00:38 -08003890 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_TX */
3891 nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_RX */
stephen hemmingerd3428942012-10-01 12:32:35 +00003892 0;
3893}
3894
3895static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
3896{
3897 const struct vxlan_dev *vxlan = netdev_priv(dev);
Atzm Watanabec7995c42013-04-16 02:50:52 +00003898 const struct vxlan_rdst *dst = &vxlan->default_dst;
stephen hemminger05f47d62012-10-09 20:35:50 +00003899 struct ifla_vxlan_port_range ports = {
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003900 .low = htons(vxlan->cfg.port_min),
3901 .high = htons(vxlan->cfg.port_max),
stephen hemminger05f47d62012-10-09 20:35:50 +00003902 };
stephen hemmingerd3428942012-10-01 12:32:35 +00003903
Jiri Benc54bfd872016-02-16 21:58:58 +01003904 if (nla_put_u32(skb, IFLA_VXLAN_ID, be32_to_cpu(dst->remote_vni)))
stephen hemmingerd3428942012-10-01 12:32:35 +00003905 goto nla_put_failure;
3906
Cong Wange4c7ed42013-08-31 13:44:33 +08003907 if (!vxlan_addr_any(&dst->remote_ip)) {
3908 if (dst->remote_ip.sa.sa_family == AF_INET) {
Jiri Benc930345e2015-03-29 16:59:25 +02003909 if (nla_put_in_addr(skb, IFLA_VXLAN_GROUP,
3910 dst->remote_ip.sin.sin_addr.s_addr))
Cong Wange4c7ed42013-08-31 13:44:33 +08003911 goto nla_put_failure;
3912#if IS_ENABLED(CONFIG_IPV6)
3913 } else {
Jiri Benc930345e2015-03-29 16:59:25 +02003914 if (nla_put_in6_addr(skb, IFLA_VXLAN_GROUP6,
3915 &dst->remote_ip.sin6.sin6_addr))
Cong Wange4c7ed42013-08-31 13:44:33 +08003916 goto nla_put_failure;
3917#endif
3918 }
3919 }
stephen hemmingerd3428942012-10-01 12:32:35 +00003920
Atzm Watanabec7995c42013-04-16 02:50:52 +00003921 if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
stephen hemmingerd3428942012-10-01 12:32:35 +00003922 goto nla_put_failure;
3923
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003924 if (!vxlan_addr_any(&vxlan->cfg.saddr)) {
3925 if (vxlan->cfg.saddr.sa.sa_family == AF_INET) {
Jiri Benc930345e2015-03-29 16:59:25 +02003926 if (nla_put_in_addr(skb, IFLA_VXLAN_LOCAL,
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003927 vxlan->cfg.saddr.sin.sin_addr.s_addr))
Cong Wange4c7ed42013-08-31 13:44:33 +08003928 goto nla_put_failure;
3929#if IS_ENABLED(CONFIG_IPV6)
3930 } else {
Jiri Benc930345e2015-03-29 16:59:25 +02003931 if (nla_put_in6_addr(skb, IFLA_VXLAN_LOCAL6,
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003932 &vxlan->cfg.saddr.sin6.sin6_addr))
Cong Wange4c7ed42013-08-31 13:44:33 +08003933 goto nla_put_failure;
3934#endif
3935 }
3936 }
stephen hemmingerd3428942012-10-01 12:32:35 +00003937
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003938 if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->cfg.ttl) ||
Hangbin Liu8fd78062018-09-26 10:35:42 +08003939 nla_put_u8(skb, IFLA_VXLAN_TTL_INHERIT,
3940 !!(vxlan->cfg.flags & VXLAN_F_TTL_INHERIT)) ||
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003941 nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->cfg.tos) ||
Stefano Briviob4d306972018-11-08 12:19:16 +01003942 nla_put_u8(skb, IFLA_VXLAN_DF, vxlan->cfg.df) ||
Daniel Borkmanne7f70af2016-03-09 03:00:03 +01003943 nla_put_be32(skb, IFLA_VXLAN_LABEL, vxlan->cfg.label) ||
David Stevense4f67ad2012-11-20 02:50:14 +00003944 nla_put_u8(skb, IFLA_VXLAN_LEARNING,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003945 !!(vxlan->cfg.flags & VXLAN_F_LEARN)) ||
David Stevense4f67ad2012-11-20 02:50:14 +00003946 nla_put_u8(skb, IFLA_VXLAN_PROXY,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003947 !!(vxlan->cfg.flags & VXLAN_F_PROXY)) ||
3948 nla_put_u8(skb, IFLA_VXLAN_RSC,
3949 !!(vxlan->cfg.flags & VXLAN_F_RSC)) ||
David Stevense4f67ad2012-11-20 02:50:14 +00003950 nla_put_u8(skb, IFLA_VXLAN_L2MISS,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003951 !!(vxlan->cfg.flags & VXLAN_F_L2MISS)) ||
David Stevense4f67ad2012-11-20 02:50:14 +00003952 nla_put_u8(skb, IFLA_VXLAN_L3MISS,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003953 !!(vxlan->cfg.flags & VXLAN_F_L3MISS)) ||
Alexei Starovoitovda8b43c2015-08-04 22:51:07 -07003954 nla_put_u8(skb, IFLA_VXLAN_COLLECT_METADATA,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003955 !!(vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA)) ||
Thomas Graf0dfbdf42015-07-21 10:44:02 +02003956 nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->cfg.age_interval) ||
3957 nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->cfg.addrmax) ||
3958 nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->cfg.dst_port) ||
Tom Herbert359a0ea2014-06-04 17:20:29 -07003959 nla_put_u8(skb, IFLA_VXLAN_UDP_CSUM,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003960 !(vxlan->cfg.flags & VXLAN_F_UDP_ZERO_CSUM_TX)) ||
Tom Herbert359a0ea2014-06-04 17:20:29 -07003961 nla_put_u8(skb, IFLA_VXLAN_UDP_ZERO_CSUM6_TX,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003962 !!(vxlan->cfg.flags & VXLAN_F_UDP_ZERO_CSUM6_TX)) ||
Tom Herbert359a0ea2014-06-04 17:20:29 -07003963 nla_put_u8(skb, IFLA_VXLAN_UDP_ZERO_CSUM6_RX,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003964 !!(vxlan->cfg.flags & VXLAN_F_UDP_ZERO_CSUM6_RX)) ||
Tom Herbertdfd86452015-01-12 17:00:38 -08003965 nla_put_u8(skb, IFLA_VXLAN_REMCSUM_TX,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003966 !!(vxlan->cfg.flags & VXLAN_F_REMCSUM_TX)) ||
Tom Herbertdfd86452015-01-12 17:00:38 -08003967 nla_put_u8(skb, IFLA_VXLAN_REMCSUM_RX,
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003968 !!(vxlan->cfg.flags & VXLAN_F_REMCSUM_RX)))
stephen hemmingerd3428942012-10-01 12:32:35 +00003969 goto nla_put_failure;
3970
stephen hemminger05f47d62012-10-09 20:35:50 +00003971 if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
3972 goto nla_put_failure;
3973
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003974 if (vxlan->cfg.flags & VXLAN_F_GBP &&
Thomas Graf35114942015-01-15 03:53:55 +01003975 nla_put_flag(skb, IFLA_VXLAN_GBP))
3976 goto nla_put_failure;
3977
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003978 if (vxlan->cfg.flags & VXLAN_F_GPE &&
Jiri Bence1e53142016-04-05 14:47:13 +02003979 nla_put_flag(skb, IFLA_VXLAN_GPE))
3980 goto nla_put_failure;
3981
Matthias Schifferdc5321d2017-06-19 10:03:56 +02003982 if (vxlan->cfg.flags & VXLAN_F_REMCSUM_NOPARTIAL &&
Tom Herbert0ace2ca2015-02-10 16:30:32 -08003983 nla_put_flag(skb, IFLA_VXLAN_REMCSUM_NOPARTIAL))
3984 goto nla_put_failure;
3985
stephen hemmingerd3428942012-10-01 12:32:35 +00003986 return 0;
3987
3988nla_put_failure:
3989 return -EMSGSIZE;
3990}
3991
Nicolas Dichtel1728d4f2015-01-15 15:11:17 +01003992static struct net *vxlan_get_link_net(const struct net_device *dev)
3993{
3994 struct vxlan_dev *vxlan = netdev_priv(dev);
3995
3996 return vxlan->net;
3997}
3998
stephen hemmingerd3428942012-10-01 12:32:35 +00003999static struct rtnl_link_ops vxlan_link_ops __read_mostly = {
4000 .kind = "vxlan",
4001 .maxtype = IFLA_VXLAN_MAX,
4002 .policy = vxlan_policy,
4003 .priv_size = sizeof(struct vxlan_dev),
4004 .setup = vxlan_setup,
4005 .validate = vxlan_validate,
4006 .newlink = vxlan_newlink,
Roopa Prabhu8bcdc4f2017-02-20 08:29:19 -08004007 .changelink = vxlan_changelink,
stephen hemmingerd3428942012-10-01 12:32:35 +00004008 .dellink = vxlan_dellink,
4009 .get_size = vxlan_get_size,
4010 .fill_info = vxlan_fill_info,
Nicolas Dichtel1728d4f2015-01-15 15:11:17 +01004011 .get_link_net = vxlan_get_link_net,
stephen hemmingerd3428942012-10-01 12:32:35 +00004012};
4013
Nicolas Dichtelcf5da332016-06-13 10:31:05 +02004014struct net_device *vxlan_dev_create(struct net *net, const char *name,
4015 u8 name_assign_type,
4016 struct vxlan_config *conf)
4017{
4018 struct nlattr *tb[IFLA_MAX + 1];
4019 struct net_device *dev;
4020 int err;
4021
4022 memset(&tb, 0, sizeof(tb));
4023
4024 dev = rtnl_create_link(net, name, name_assign_type,
David Ahernd0522f12018-11-06 12:51:14 -08004025 &vxlan_link_ops, tb, NULL);
Nicolas Dichtelcf5da332016-06-13 10:31:05 +02004026 if (IS_ERR(dev))
4027 return dev;
4028
Girish Moodalbail653ef6a32017-08-11 15:20:59 -07004029 err = __vxlan_dev_create(net, dev, conf, NULL);
Nicolas Dichtelcf5da332016-06-13 10:31:05 +02004030 if (err < 0) {
4031 free_netdev(dev);
4032 return ERR_PTR(err);
4033 }
4034
4035 err = rtnl_configure_link(dev, NULL);
4036 if (err < 0) {
4037 LIST_HEAD(list_kill);
4038
4039 vxlan_dellink(dev, &list_kill);
4040 unregister_netdevice_many(&list_kill);
4041 return ERR_PTR(err);
4042 }
4043
4044 return dev;
4045}
4046EXPORT_SYMBOL_GPL(vxlan_dev_create);
4047
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004048static void vxlan_handle_lowerdev_unregister(struct vxlan_net *vn,
4049 struct net_device *dev)
4050{
4051 struct vxlan_dev *vxlan, *next;
4052 LIST_HEAD(list_kill);
4053
4054 list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {
4055 struct vxlan_rdst *dst = &vxlan->default_dst;
4056
4057 /* In case we created vxlan device with carrier
4058 * and we loose the carrier due to module unload
4059 * we also need to remove vxlan device. In other
4060 * cases, it's not necessary and remote_ifindex
4061 * is 0 here, so no matches.
4062 */
4063 if (dst->remote_ifindex == dev->ifindex)
4064 vxlan_dellink(vxlan->dev, &list_kill);
4065 }
4066
4067 unregister_netdevice_many(&list_kill);
4068}
4069
Hannes Frederic Sowab7aade12016-04-18 21:19:47 +02004070static int vxlan_netdevice_event(struct notifier_block *unused,
4071 unsigned long event, void *ptr)
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004072{
4073 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Daniel Borkmann783c1462014-01-22 21:07:53 +01004074 struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004075
Sabrina Dubroca04584952017-07-21 12:49:33 +02004076 if (event == NETDEV_UNREGISTER) {
4077 vxlan_offload_rx_ports(dev, false);
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004078 vxlan_handle_lowerdev_unregister(vn, dev);
Sabrina Dubroca04584952017-07-21 12:49:33 +02004079 } else if (event == NETDEV_REGISTER) {
4080 vxlan_offload_rx_ports(dev, true);
4081 } else if (event == NETDEV_UDP_TUNNEL_PUSH_INFO ||
4082 event == NETDEV_UDP_TUNNEL_DROP_INFO) {
Sabrina Dubroca2d2b13f2017-07-21 12:49:32 +02004083 vxlan_offload_rx_ports(dev, event == NETDEV_UDP_TUNNEL_PUSH_INFO);
Sabrina Dubroca04584952017-07-21 12:49:33 +02004084 }
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004085
4086 return NOTIFY_DONE;
4087}
4088
4089static struct notifier_block vxlan_notifier_block __read_mostly = {
Hannes Frederic Sowab7aade12016-04-18 21:19:47 +02004090 .notifier_call = vxlan_netdevice_event,
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004091};
4092
Petr Machata0efe1172018-10-17 08:53:26 +00004093static void
4094vxlan_fdb_offloaded_set(struct net_device *dev,
4095 struct switchdev_notifier_vxlan_fdb_info *fdb_info)
4096{
4097 struct vxlan_dev *vxlan = netdev_priv(dev);
4098 struct vxlan_rdst *rdst;
4099 struct vxlan_fdb *f;
4100
4101 spin_lock_bh(&vxlan->hash_lock);
4102
4103 f = vxlan_find_mac(vxlan, fdb_info->eth_addr, fdb_info->vni);
4104 if (!f)
4105 goto out;
4106
4107 rdst = vxlan_fdb_find_rdst(f, &fdb_info->remote_ip,
4108 fdb_info->remote_port,
4109 fdb_info->remote_vni,
4110 fdb_info->remote_ifindex);
4111 if (!rdst)
4112 goto out;
4113
4114 rdst->offloaded = fdb_info->offloaded;
4115
4116out:
4117 spin_unlock_bh(&vxlan->hash_lock);
4118}
4119
Petr Machata5728ae02018-11-21 08:02:39 +00004120static int
4121vxlan_fdb_external_learn_add(struct net_device *dev,
4122 struct switchdev_notifier_vxlan_fdb_info *fdb_info)
4123{
4124 struct vxlan_dev *vxlan = netdev_priv(dev);
Petr Machata4c59b7d2019-01-16 23:06:54 +00004125 struct netlink_ext_ack *extack;
Petr Machata5728ae02018-11-21 08:02:39 +00004126 int err;
4127
Petr Machata4c59b7d2019-01-16 23:06:54 +00004128 extack = switchdev_notifier_info_to_extack(&fdb_info->info);
4129
Petr Machata5728ae02018-11-21 08:02:39 +00004130 spin_lock_bh(&vxlan->hash_lock);
4131 err = vxlan_fdb_update(vxlan, fdb_info->eth_addr, &fdb_info->remote_ip,
4132 NUD_REACHABLE,
4133 NLM_F_CREATE | NLM_F_REPLACE,
4134 fdb_info->remote_port,
4135 fdb_info->vni,
4136 fdb_info->remote_vni,
4137 fdb_info->remote_ifindex,
4138 NTF_USE | NTF_SELF | NTF_EXT_LEARNED,
Petr Machata4c59b7d2019-01-16 23:06:54 +00004139 false, extack);
Petr Machata5728ae02018-11-21 08:02:39 +00004140 spin_unlock_bh(&vxlan->hash_lock);
4141
4142 return err;
4143}
4144
4145static int
4146vxlan_fdb_external_learn_del(struct net_device *dev,
4147 struct switchdev_notifier_vxlan_fdb_info *fdb_info)
4148{
4149 struct vxlan_dev *vxlan = netdev_priv(dev);
4150 struct vxlan_fdb *f;
4151 int err = 0;
4152
4153 spin_lock_bh(&vxlan->hash_lock);
4154
4155 f = vxlan_find_mac(vxlan, fdb_info->eth_addr, fdb_info->vni);
4156 if (!f)
4157 err = -ENOENT;
4158 else if (f->flags & NTF_EXT_LEARNED)
4159 err = __vxlan_fdb_delete(vxlan, fdb_info->eth_addr,
4160 fdb_info->remote_ip,
4161 fdb_info->remote_port,
4162 fdb_info->vni,
4163 fdb_info->remote_vni,
4164 fdb_info->remote_ifindex,
4165 false);
4166
4167 spin_unlock_bh(&vxlan->hash_lock);
4168
4169 return err;
4170}
4171
Petr Machata0efe1172018-10-17 08:53:26 +00004172static int vxlan_switchdev_event(struct notifier_block *unused,
4173 unsigned long event, void *ptr)
4174{
4175 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
Petr Machata5728ae02018-11-21 08:02:39 +00004176 struct switchdev_notifier_vxlan_fdb_info *fdb_info;
4177 int err = 0;
Petr Machata0efe1172018-10-17 08:53:26 +00004178
4179 switch (event) {
4180 case SWITCHDEV_VXLAN_FDB_OFFLOADED:
4181 vxlan_fdb_offloaded_set(dev, ptr);
4182 break;
Petr Machata5728ae02018-11-21 08:02:39 +00004183 case SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE:
4184 fdb_info = ptr;
4185 err = vxlan_fdb_external_learn_add(dev, fdb_info);
4186 if (err) {
4187 err = notifier_from_errno(err);
4188 break;
4189 }
4190 fdb_info->offloaded = true;
4191 vxlan_fdb_offloaded_set(dev, fdb_info);
4192 break;
4193 case SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE:
4194 fdb_info = ptr;
4195 err = vxlan_fdb_external_learn_del(dev, fdb_info);
4196 if (err) {
4197 err = notifier_from_errno(err);
4198 break;
4199 }
4200 fdb_info->offloaded = false;
4201 vxlan_fdb_offloaded_set(dev, fdb_info);
4202 break;
Petr Machata0efe1172018-10-17 08:53:26 +00004203 }
4204
Petr Machata5728ae02018-11-21 08:02:39 +00004205 return err;
Petr Machata0efe1172018-10-17 08:53:26 +00004206}
4207
4208static struct notifier_block vxlan_switchdev_notifier_block __read_mostly = {
4209 .notifier_call = vxlan_switchdev_event,
4210};
4211
stephen hemmingerd3428942012-10-01 12:32:35 +00004212static __net_init int vxlan_init_net(struct net *net)
4213{
4214 struct vxlan_net *vn = net_generic(net, vxlan_net_id);
Cong Wang31fec5a2013-05-27 22:35:52 +00004215 unsigned int h;
stephen hemmingerd3428942012-10-01 12:32:35 +00004216
stephen hemminger553675f2013-05-16 11:35:20 +00004217 INIT_LIST_HEAD(&vn->vxlan_list);
Stephen Hemminger1c51a912013-06-17 14:16:11 -07004218 spin_lock_init(&vn->sock_lock);
stephen hemmingerd3428942012-10-01 12:32:35 +00004219
stephen hemminger553675f2013-05-16 11:35:20 +00004220 for (h = 0; h < PORT_HASH_SIZE; ++h)
4221 INIT_HLIST_HEAD(&vn->sock_list[h]);
stephen hemmingerd3428942012-10-01 12:32:35 +00004222
4223 return 0;
4224}
4225
Haishuang Yan57b61122017-12-16 17:54:49 +08004226static void vxlan_destroy_tunnels(struct net *net, struct list_head *head)
Nicolas Dichtelf01ec1c2014-04-24 10:02:49 +02004227{
4228 struct vxlan_net *vn = net_generic(net, vxlan_net_id);
4229 struct vxlan_dev *vxlan, *next;
4230 struct net_device *dev, *aux;
Vasily Averin0e4ec5a2017-11-12 22:28:10 +03004231 unsigned int h;
Nicolas Dichtelf01ec1c2014-04-24 10:02:49 +02004232
Nicolas Dichtelf01ec1c2014-04-24 10:02:49 +02004233 for_each_netdev_safe(net, dev, aux)
4234 if (dev->rtnl_link_ops == &vxlan_link_ops)
Haishuang Yan57b61122017-12-16 17:54:49 +08004235 unregister_netdevice_queue(dev, head);
Nicolas Dichtelf01ec1c2014-04-24 10:02:49 +02004236
4237 list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {
4238 /* If vxlan->dev is in the same netns, it has already been added
4239 * to the list by the previous loop.
4240 */
Tom Herbert58ce31c2015-08-19 17:07:33 -07004241 if (!net_eq(dev_net(vxlan->dev), net)) {
4242 gro_cells_destroy(&vxlan->gro_cells);
Haishuang Yan57b61122017-12-16 17:54:49 +08004243 unregister_netdevice_queue(vxlan->dev, head);
Tom Herbert58ce31c2015-08-19 17:07:33 -07004244 }
Nicolas Dichtelf01ec1c2014-04-24 10:02:49 +02004245 }
4246
Vasily Averin0e4ec5a2017-11-12 22:28:10 +03004247 for (h = 0; h < PORT_HASH_SIZE; ++h)
4248 WARN_ON_ONCE(!hlist_empty(&vn->sock_list[h]));
Nicolas Dichtelf01ec1c2014-04-24 10:02:49 +02004249}
4250
Haishuang Yan57b61122017-12-16 17:54:49 +08004251static void __net_exit vxlan_exit_batch_net(struct list_head *net_list)
4252{
4253 struct net *net;
4254 LIST_HEAD(list);
4255
4256 rtnl_lock();
4257 list_for_each_entry(net, net_list, exit_list)
4258 vxlan_destroy_tunnels(net, &list);
4259
4260 unregister_netdevice_many(&list);
4261 rtnl_unlock();
4262}
4263
stephen hemmingerd3428942012-10-01 12:32:35 +00004264static struct pernet_operations vxlan_net_ops = {
4265 .init = vxlan_init_net,
Haishuang Yan57b61122017-12-16 17:54:49 +08004266 .exit_batch = vxlan_exit_batch_net,
stephen hemmingerd3428942012-10-01 12:32:35 +00004267 .id = &vxlan_net_id,
4268 .size = sizeof(struct vxlan_net),
4269};
4270
4271static int __init vxlan_init_module(void)
4272{
4273 int rc;
4274
4275 get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));
4276
Daniel Borkmann783c1462014-01-22 21:07:53 +01004277 rc = register_pernet_subsys(&vxlan_net_ops);
stephen hemmingerd3428942012-10-01 12:32:35 +00004278 if (rc)
4279 goto out1;
4280
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004281 rc = register_netdevice_notifier(&vxlan_notifier_block);
stephen hemmingerd3428942012-10-01 12:32:35 +00004282 if (rc)
4283 goto out2;
4284
Petr Machata0efe1172018-10-17 08:53:26 +00004285 rc = register_switchdev_notifier(&vxlan_switchdev_notifier_block);
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004286 if (rc)
4287 goto out3;
stephen hemmingerd3428942012-10-01 12:32:35 +00004288
Petr Machata0efe1172018-10-17 08:53:26 +00004289 rc = rtnl_link_register(&vxlan_link_ops);
4290 if (rc)
4291 goto out4;
4292
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004293 return 0;
Petr Machata0efe1172018-10-17 08:53:26 +00004294out4:
4295 unregister_switchdev_notifier(&vxlan_switchdev_notifier_block);
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004296out3:
4297 unregister_netdevice_notifier(&vxlan_notifier_block);
stephen hemmingerd3428942012-10-01 12:32:35 +00004298out2:
Daniel Borkmann783c1462014-01-22 21:07:53 +01004299 unregister_pernet_subsys(&vxlan_net_ops);
stephen hemmingerd3428942012-10-01 12:32:35 +00004300out1:
4301 return rc;
4302}
Cong Wang7332a132013-05-27 22:35:53 +00004303late_initcall(vxlan_init_module);
stephen hemmingerd3428942012-10-01 12:32:35 +00004304
4305static void __exit vxlan_cleanup_module(void)
4306{
Stephen Hemmingerb7153982013-06-17 14:16:09 -07004307 rtnl_link_unregister(&vxlan_link_ops);
Petr Machata0efe1172018-10-17 08:53:26 +00004308 unregister_switchdev_notifier(&vxlan_switchdev_notifier_block);
Daniel Borkmannacaf4e7092014-01-13 18:41:19 +01004309 unregister_netdevice_notifier(&vxlan_notifier_block);
Daniel Borkmann783c1462014-01-22 21:07:53 +01004310 unregister_pernet_subsys(&vxlan_net_ops);
4311 /* rcu_barrier() is called by netns */
stephen hemmingerd3428942012-10-01 12:32:35 +00004312}
4313module_exit(vxlan_cleanup_module);
4314
4315MODULE_LICENSE("GPL");
4316MODULE_VERSION(VXLAN_VERSION);
stephen hemminger3b8df3c2013-04-27 11:31:52 +00004317MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");
Jesse Brandeburgead51392014-01-17 11:00:33 -08004318MODULE_DESCRIPTION("Driver for VXLAN encapsulated traffic");
stephen hemmingerd3428942012-10-01 12:32:35 +00004319MODULE_ALIAS_RTNL_LINK("vxlan");