1 // SPDX-License-Identifier: GPL-2.0-only
2
3 #include <linux/if_bridge.h>
4 #include <linux/in.h>
5 #include <linux/list.h>
6 #include <linux/netdevice.h>
7 #include <linux/netlink.h>
8 #include <linux/rhashtable.h>
9 #include <linux/rhashtable-types.h>
10 #include <linux/rtnetlink.h>
11 #include <linux/skbuff.h>
12 #include <linux/types.h>
13 #include <net/netlink.h>
14 #include <net/vxlan.h>
15
16 #include "vxlan_private.h"
17
18 struct vxlan_mdb_entry_key {
19 union vxlan_addr src;
20 union vxlan_addr dst;
21 __be32 vni;
22 };
23
24 struct vxlan_mdb_entry {
25 struct rhash_head rhnode;
26 struct list_head remotes;
27 struct vxlan_mdb_entry_key key;
28 struct hlist_node mdb_node;
29 struct rcu_head rcu;
30 };
31
32 #define VXLAN_MDB_REMOTE_F_BLOCKED BIT(0)
33
34 struct vxlan_mdb_remote {
35 struct list_head list;
36 struct vxlan_rdst __rcu *rd;
37 u8 flags;
38 u8 filter_mode;
39 u8 rt_protocol;
40 struct hlist_head src_list;
41 struct rcu_head rcu;
42 };
43
44 #define VXLAN_SGRP_F_DELETE BIT(0)
45 #define VXLAN_SGRP_F_NEW BIT(1)
46
47 struct vxlan_mdb_src_entry {
48 struct hlist_node node;
49 union vxlan_addr addr;
50 u8 flags;
51 };
52
53 struct vxlan_mdb_dump_ctx {
54 long reserved;
55 long entry_idx;
56 long remote_idx;
57 };
58
59 struct vxlan_mdb_config_src_entry {
60 union vxlan_addr addr;
61 struct list_head node;
62 };
63
64 struct vxlan_mdb_config {
65 struct vxlan_dev *vxlan;
66 struct vxlan_mdb_entry_key group;
67 struct list_head src_list;
68 union vxlan_addr remote_ip;
69 u32 remote_ifindex;
70 __be32 remote_vni;
71 __be16 remote_port;
72 u16 nlflags;
73 u8 flags;
74 u8 filter_mode;
75 u8 rt_protocol;
76 };
77
78 struct vxlan_mdb_flush_desc {
79 union vxlan_addr remote_ip;
80 __be32 src_vni;
81 __be32 remote_vni;
82 __be16 remote_port;
83 u8 rt_protocol;
84 };
85
86 static const struct rhashtable_params vxlan_mdb_rht_params = {
87 .head_offset = offsetof(struct vxlan_mdb_entry, rhnode),
88 .key_offset = offsetof(struct vxlan_mdb_entry, key),
89 .key_len = sizeof(struct vxlan_mdb_entry_key),
90 .automatic_shrinking = true,
91 };
92
93 static int __vxlan_mdb_add(const struct vxlan_mdb_config *cfg,
94 struct netlink_ext_ack *extack);
95 static int __vxlan_mdb_del(const struct vxlan_mdb_config *cfg,
96 struct netlink_ext_ack *extack);
97
vxlan_br_mdb_entry_fill(const struct vxlan_dev * vxlan,const struct vxlan_mdb_entry * mdb_entry,const struct vxlan_mdb_remote * remote,struct br_mdb_entry * e)98 static void vxlan_br_mdb_entry_fill(const struct vxlan_dev *vxlan,
99 const struct vxlan_mdb_entry *mdb_entry,
100 const struct vxlan_mdb_remote *remote,
101 struct br_mdb_entry *e)
102 {
103 const union vxlan_addr *dst = &mdb_entry->key.dst;
104
105 memset(e, 0, sizeof(*e));
106 e->ifindex = vxlan->dev->ifindex;
107 e->state = MDB_PERMANENT;
108
109 if (remote->flags & VXLAN_MDB_REMOTE_F_BLOCKED)
110 e->flags |= MDB_FLAGS_BLOCKED;
111
112 switch (dst->sa.sa_family) {
113 case AF_INET:
114 e->addr.u.ip4 = dst->sin.sin_addr.s_addr;
115 e->addr.proto = htons(ETH_P_IP);
116 break;
117 #if IS_ENABLED(CONFIG_IPV6)
118 case AF_INET6:
119 e->addr.u.ip6 = dst->sin6.sin6_addr;
120 e->addr.proto = htons(ETH_P_IPV6);
121 break;
122 #endif
123 }
124 }
125
vxlan_mdb_entry_info_fill_srcs(struct sk_buff * skb,const struct vxlan_mdb_remote * remote)126 static int vxlan_mdb_entry_info_fill_srcs(struct sk_buff *skb,
127 const struct vxlan_mdb_remote *remote)
128 {
129 struct vxlan_mdb_src_entry *ent;
130 struct nlattr *nest;
131
132 if (hlist_empty(&remote->src_list))
133 return 0;
134
135 nest = nla_nest_start(skb, MDBA_MDB_EATTR_SRC_LIST);
136 if (!nest)
137 return -EMSGSIZE;
138
139 hlist_for_each_entry(ent, &remote->src_list, node) {
140 struct nlattr *nest_ent;
141
142 nest_ent = nla_nest_start(skb, MDBA_MDB_SRCLIST_ENTRY);
143 if (!nest_ent)
144 goto out_cancel_err;
145
146 if (vxlan_nla_put_addr(skb, MDBA_MDB_SRCATTR_ADDRESS,
147 &ent->addr) ||
148 nla_put_u32(skb, MDBA_MDB_SRCATTR_TIMER, 0))
149 goto out_cancel_err;
150
151 nla_nest_end(skb, nest_ent);
152 }
153
154 nla_nest_end(skb, nest);
155
156 return 0;
157
158 out_cancel_err:
159 nla_nest_cancel(skb, nest);
160 return -EMSGSIZE;
161 }
162
vxlan_mdb_entry_info_fill(const struct vxlan_dev * vxlan,struct sk_buff * skb,const struct vxlan_mdb_entry * mdb_entry,const struct vxlan_mdb_remote * remote)163 static int vxlan_mdb_entry_info_fill(const struct vxlan_dev *vxlan,
164 struct sk_buff *skb,
165 const struct vxlan_mdb_entry *mdb_entry,
166 const struct vxlan_mdb_remote *remote)
167 {
168 struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
169 struct br_mdb_entry e;
170 struct nlattr *nest;
171
172 nest = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY_INFO);
173 if (!nest)
174 return -EMSGSIZE;
175
176 vxlan_br_mdb_entry_fill(vxlan, mdb_entry, remote, &e);
177
178 if (nla_put_nohdr(skb, sizeof(e), &e) ||
179 nla_put_u32(skb, MDBA_MDB_EATTR_TIMER, 0))
180 goto nest_err;
181
182 if (!vxlan_addr_any(&mdb_entry->key.src) &&
183 vxlan_nla_put_addr(skb, MDBA_MDB_EATTR_SOURCE, &mdb_entry->key.src))
184 goto nest_err;
185
186 if (nla_put_u8(skb, MDBA_MDB_EATTR_RTPROT, remote->rt_protocol) ||
187 nla_put_u8(skb, MDBA_MDB_EATTR_GROUP_MODE, remote->filter_mode) ||
188 vxlan_mdb_entry_info_fill_srcs(skb, remote) ||
189 vxlan_nla_put_addr(skb, MDBA_MDB_EATTR_DST, &rd->remote_ip))
190 goto nest_err;
191
192 if (rd->remote_port && rd->remote_port != vxlan->cfg.dst_port &&
193 nla_put_u16(skb, MDBA_MDB_EATTR_DST_PORT,
194 be16_to_cpu(rd->remote_port)))
195 goto nest_err;
196
197 if (rd->remote_vni != vxlan->default_dst.remote_vni &&
198 nla_put_u32(skb, MDBA_MDB_EATTR_VNI, be32_to_cpu(rd->remote_vni)))
199 goto nest_err;
200
201 if (rd->remote_ifindex &&
202 nla_put_u32(skb, MDBA_MDB_EATTR_IFINDEX, rd->remote_ifindex))
203 goto nest_err;
204
205 if ((vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) &&
206 mdb_entry->key.vni && nla_put_u32(skb, MDBA_MDB_EATTR_SRC_VNI,
207 be32_to_cpu(mdb_entry->key.vni)))
208 goto nest_err;
209
210 nla_nest_end(skb, nest);
211
212 return 0;
213
214 nest_err:
215 nla_nest_cancel(skb, nest);
216 return -EMSGSIZE;
217 }
218
vxlan_mdb_entry_fill(const struct vxlan_dev * vxlan,struct sk_buff * skb,struct vxlan_mdb_dump_ctx * ctx,const struct vxlan_mdb_entry * mdb_entry)219 static int vxlan_mdb_entry_fill(const struct vxlan_dev *vxlan,
220 struct sk_buff *skb,
221 struct vxlan_mdb_dump_ctx *ctx,
222 const struct vxlan_mdb_entry *mdb_entry)
223 {
224 int remote_idx = 0, s_remote_idx = ctx->remote_idx;
225 struct vxlan_mdb_remote *remote;
226 struct nlattr *nest;
227 int err = 0;
228
229 nest = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
230 if (!nest)
231 return -EMSGSIZE;
232
233 list_for_each_entry(remote, &mdb_entry->remotes, list) {
234 if (remote_idx < s_remote_idx)
235 goto skip;
236
237 err = vxlan_mdb_entry_info_fill(vxlan, skb, mdb_entry, remote);
238 if (err)
239 break;
240 skip:
241 remote_idx++;
242 }
243
244 ctx->remote_idx = err ? remote_idx : 0;
245 nla_nest_end(skb, nest);
246 return err;
247 }
248
vxlan_mdb_fill(const struct vxlan_dev * vxlan,struct sk_buff * skb,struct vxlan_mdb_dump_ctx * ctx)249 static int vxlan_mdb_fill(const struct vxlan_dev *vxlan, struct sk_buff *skb,
250 struct vxlan_mdb_dump_ctx *ctx)
251 {
252 int entry_idx = 0, s_entry_idx = ctx->entry_idx;
253 struct vxlan_mdb_entry *mdb_entry;
254 struct nlattr *nest;
255 int err = 0;
256
257 nest = nla_nest_start_noflag(skb, MDBA_MDB);
258 if (!nest)
259 return -EMSGSIZE;
260
261 hlist_for_each_entry(mdb_entry, &vxlan->mdb_list, mdb_node) {
262 if (entry_idx < s_entry_idx)
263 goto skip;
264
265 err = vxlan_mdb_entry_fill(vxlan, skb, ctx, mdb_entry);
266 if (err)
267 break;
268 skip:
269 entry_idx++;
270 }
271
272 ctx->entry_idx = err ? entry_idx : 0;
273 nla_nest_end(skb, nest);
274 return err;
275 }
276
vxlan_mdb_dump(struct net_device * dev,struct sk_buff * skb,struct netlink_callback * cb)277 int vxlan_mdb_dump(struct net_device *dev, struct sk_buff *skb,
278 struct netlink_callback *cb)
279 {
280 struct vxlan_mdb_dump_ctx *ctx = (void *)cb->ctx;
281 struct vxlan_dev *vxlan = netdev_priv(dev);
282 struct br_port_msg *bpm;
283 struct nlmsghdr *nlh;
284 int err;
285
286 ASSERT_RTNL();
287
288 NL_ASSERT_CTX_FITS(struct vxlan_mdb_dump_ctx);
289
290 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
291 cb->nlh->nlmsg_seq, RTM_NEWMDB, sizeof(*bpm),
292 NLM_F_MULTI);
293 if (!nlh)
294 return -EMSGSIZE;
295
296 bpm = nlmsg_data(nlh);
297 memset(bpm, 0, sizeof(*bpm));
298 bpm->family = AF_BRIDGE;
299 bpm->ifindex = dev->ifindex;
300
301 err = vxlan_mdb_fill(vxlan, skb, ctx);
302
303 nlmsg_end(skb, nlh);
304
305 cb->seq = vxlan->mdb_seq;
306 nl_dump_check_consistent(cb, nlh);
307
308 return err;
309 }
310
311 static const struct nla_policy
312 vxlan_mdbe_src_list_entry_pol[MDBE_SRCATTR_MAX + 1] = {
313 [MDBE_SRCATTR_ADDRESS] = NLA_POLICY_RANGE(NLA_BINARY,
314 sizeof(struct in_addr),
315 sizeof(struct in6_addr)),
316 };
317
318 static const struct nla_policy
319 vxlan_mdbe_src_list_pol[MDBE_SRC_LIST_MAX + 1] = {
320 [MDBE_SRC_LIST_ENTRY] = NLA_POLICY_NESTED(vxlan_mdbe_src_list_entry_pol),
321 };
322
323 static const struct netlink_range_validation vni_range = {
324 .max = VXLAN_N_VID - 1,
325 };
326
327 static const struct nla_policy vxlan_mdbe_attrs_pol[MDBE_ATTR_MAX + 1] = {
328 [MDBE_ATTR_SOURCE] = NLA_POLICY_RANGE(NLA_BINARY,
329 sizeof(struct in_addr),
330 sizeof(struct in6_addr)),
331 [MDBE_ATTR_GROUP_MODE] = NLA_POLICY_RANGE(NLA_U8, MCAST_EXCLUDE,
332 MCAST_INCLUDE),
333 [MDBE_ATTR_SRC_LIST] = NLA_POLICY_NESTED(vxlan_mdbe_src_list_pol),
334 [MDBE_ATTR_RTPROT] = NLA_POLICY_MIN(NLA_U8, RTPROT_STATIC),
335 [MDBE_ATTR_DST] = NLA_POLICY_RANGE(NLA_BINARY,
336 sizeof(struct in_addr),
337 sizeof(struct in6_addr)),
338 [MDBE_ATTR_DST_PORT] = { .type = NLA_U16 },
339 [MDBE_ATTR_VNI] = NLA_POLICY_FULL_RANGE(NLA_U32, &vni_range),
340 [MDBE_ATTR_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1),
341 [MDBE_ATTR_SRC_VNI] = NLA_POLICY_FULL_RANGE(NLA_U32, &vni_range),
342 };
343
vxlan_mdb_is_valid_source(const struct nlattr * attr,__be16 proto,struct netlink_ext_ack * extack)344 static bool vxlan_mdb_is_valid_source(const struct nlattr *attr, __be16 proto,
345 struct netlink_ext_ack *extack)
346 {
347 switch (proto) {
348 case htons(ETH_P_IP):
349 if (nla_len(attr) != sizeof(struct in_addr)) {
350 NL_SET_ERR_MSG_MOD(extack, "IPv4 invalid source address length");
351 return false;
352 }
353 if (ipv4_is_multicast(nla_get_in_addr(attr))) {
354 NL_SET_ERR_MSG_MOD(extack, "IPv4 multicast source address is not allowed");
355 return false;
356 }
357 if (ipv4_is_zeronet(nla_get_in_addr(attr))) {
358 NL_SET_ERR_MSG_MOD(extack, "IPv4 all-zeros source address is not allowed");
359 return false;
360 }
361 break;
362 #if IS_ENABLED(CONFIG_IPV6)
363 case htons(ETH_P_IPV6): {
364 struct in6_addr src;
365
366 if (nla_len(attr) != sizeof(struct in6_addr)) {
367 NL_SET_ERR_MSG_MOD(extack, "IPv6 invalid source address length");
368 return false;
369 }
370 src = nla_get_in6_addr(attr);
371 if (ipv6_addr_is_multicast(&src)) {
372 NL_SET_ERR_MSG_MOD(extack, "IPv6 multicast source address is not allowed");
373 return false;
374 }
375 if (ipv6_addr_any(&src)) {
376 NL_SET_ERR_MSG_MOD(extack, "IPv6 all-zeros source address is not allowed");
377 return false;
378 }
379 break;
380 }
381 #endif
382 default:
383 NL_SET_ERR_MSG_MOD(extack, "Invalid protocol used with source address");
384 return false;
385 }
386
387 return true;
388 }
389
vxlan_mdb_group_set(struct vxlan_mdb_entry_key * group,const struct br_mdb_entry * entry,const struct nlattr * source_attr)390 static void vxlan_mdb_group_set(struct vxlan_mdb_entry_key *group,
391 const struct br_mdb_entry *entry,
392 const struct nlattr *source_attr)
393 {
394 switch (entry->addr.proto) {
395 case htons(ETH_P_IP):
396 group->dst.sa.sa_family = AF_INET;
397 group->dst.sin.sin_addr.s_addr = entry->addr.u.ip4;
398 break;
399 #if IS_ENABLED(CONFIG_IPV6)
400 case htons(ETH_P_IPV6):
401 group->dst.sa.sa_family = AF_INET6;
402 group->dst.sin6.sin6_addr = entry->addr.u.ip6;
403 break;
404 #endif
405 }
406
407 if (source_attr)
408 vxlan_nla_get_addr(&group->src, source_attr);
409 }
410
vxlan_mdb_is_star_g(const struct vxlan_mdb_entry_key * group)411 static bool vxlan_mdb_is_star_g(const struct vxlan_mdb_entry_key *group)
412 {
413 return !vxlan_addr_any(&group->dst) && vxlan_addr_any(&group->src);
414 }
415
vxlan_mdb_is_sg(const struct vxlan_mdb_entry_key * group)416 static bool vxlan_mdb_is_sg(const struct vxlan_mdb_entry_key *group)
417 {
418 return !vxlan_addr_any(&group->dst) && !vxlan_addr_any(&group->src);
419 }
420
vxlan_mdb_config_src_entry_init(struct vxlan_mdb_config * cfg,__be16 proto,const struct nlattr * src_entry,struct netlink_ext_ack * extack)421 static int vxlan_mdb_config_src_entry_init(struct vxlan_mdb_config *cfg,
422 __be16 proto,
423 const struct nlattr *src_entry,
424 struct netlink_ext_ack *extack)
425 {
426 struct nlattr *tb[MDBE_SRCATTR_MAX + 1];
427 struct vxlan_mdb_config_src_entry *src;
428 int err;
429
430 err = nla_parse_nested(tb, MDBE_SRCATTR_MAX, src_entry,
431 vxlan_mdbe_src_list_entry_pol, extack);
432 if (err)
433 return err;
434
435 if (NL_REQ_ATTR_CHECK(extack, src_entry, tb, MDBE_SRCATTR_ADDRESS))
436 return -EINVAL;
437
438 if (!vxlan_mdb_is_valid_source(tb[MDBE_SRCATTR_ADDRESS], proto,
439 extack))
440 return -EINVAL;
441
442 src = kzalloc_obj(*src);
443 if (!src)
444 return -ENOMEM;
445
446 err = vxlan_nla_get_addr(&src->addr, tb[MDBE_SRCATTR_ADDRESS]);
447 if (err)
448 goto err_free_src;
449
450 list_add_tail(&src->node, &cfg->src_list);
451
452 return 0;
453
454 err_free_src:
455 kfree(src);
456 return err;
457 }
458
459 static void
vxlan_mdb_config_src_entry_fini(struct vxlan_mdb_config_src_entry * src)460 vxlan_mdb_config_src_entry_fini(struct vxlan_mdb_config_src_entry *src)
461 {
462 list_del(&src->node);
463 kfree(src);
464 }
465
vxlan_mdb_config_src_list_init(struct vxlan_mdb_config * cfg,__be16 proto,const struct nlattr * src_list,struct netlink_ext_ack * extack)466 static int vxlan_mdb_config_src_list_init(struct vxlan_mdb_config *cfg,
467 __be16 proto,
468 const struct nlattr *src_list,
469 struct netlink_ext_ack *extack)
470 {
471 struct vxlan_mdb_config_src_entry *src, *tmp;
472 struct nlattr *src_entry;
473 int rem, err;
474
475 nla_for_each_nested(src_entry, src_list, rem) {
476 err = vxlan_mdb_config_src_entry_init(cfg, proto, src_entry,
477 extack);
478 if (err)
479 goto err_src_entry_init;
480 }
481
482 return 0;
483
484 err_src_entry_init:
485 list_for_each_entry_safe_reverse(src, tmp, &cfg->src_list, node)
486 vxlan_mdb_config_src_entry_fini(src);
487 return err;
488 }
489
vxlan_mdb_config_src_list_fini(struct vxlan_mdb_config * cfg)490 static void vxlan_mdb_config_src_list_fini(struct vxlan_mdb_config *cfg)
491 {
492 struct vxlan_mdb_config_src_entry *src, *tmp;
493
494 list_for_each_entry_safe_reverse(src, tmp, &cfg->src_list, node)
495 vxlan_mdb_config_src_entry_fini(src);
496 }
497
vxlan_mdb_config_attrs_init(struct vxlan_mdb_config * cfg,const struct br_mdb_entry * entry,const struct nlattr * set_attrs,struct netlink_ext_ack * extack)498 static int vxlan_mdb_config_attrs_init(struct vxlan_mdb_config *cfg,
499 const struct br_mdb_entry *entry,
500 const struct nlattr *set_attrs,
501 struct netlink_ext_ack *extack)
502 {
503 struct nlattr *mdbe_attrs[MDBE_ATTR_MAX + 1];
504 int err;
505
506 err = nla_parse_nested(mdbe_attrs, MDBE_ATTR_MAX, set_attrs,
507 vxlan_mdbe_attrs_pol, extack);
508 if (err)
509 return err;
510
511 if (NL_REQ_ATTR_CHECK(extack, set_attrs, mdbe_attrs, MDBE_ATTR_DST)) {
512 NL_SET_ERR_MSG_MOD(extack, "Missing remote destination IP address");
513 return -EINVAL;
514 }
515
516 if (mdbe_attrs[MDBE_ATTR_SOURCE] &&
517 !vxlan_mdb_is_valid_source(mdbe_attrs[MDBE_ATTR_SOURCE],
518 entry->addr.proto, extack))
519 return -EINVAL;
520
521 vxlan_mdb_group_set(&cfg->group, entry, mdbe_attrs[MDBE_ATTR_SOURCE]);
522
523 /* rtnetlink code only validates that IPv4 group address is
524 * multicast.
525 */
526 if (!vxlan_addr_is_multicast(&cfg->group.dst) &&
527 !vxlan_addr_any(&cfg->group.dst)) {
528 NL_SET_ERR_MSG_MOD(extack, "Group address is not multicast");
529 return -EINVAL;
530 }
531
532 if (vxlan_addr_any(&cfg->group.dst) &&
533 mdbe_attrs[MDBE_ATTR_SOURCE]) {
534 NL_SET_ERR_MSG_MOD(extack, "Source cannot be specified for the all-zeros entry");
535 return -EINVAL;
536 }
537
538 if (vxlan_mdb_is_sg(&cfg->group))
539 cfg->filter_mode = MCAST_INCLUDE;
540
541 if (mdbe_attrs[MDBE_ATTR_GROUP_MODE]) {
542 if (!vxlan_mdb_is_star_g(&cfg->group)) {
543 NL_SET_ERR_MSG_MOD(extack, "Filter mode can only be set for (*, G) entries");
544 return -EINVAL;
545 }
546 cfg->filter_mode = nla_get_u8(mdbe_attrs[MDBE_ATTR_GROUP_MODE]);
547 }
548
549 if (mdbe_attrs[MDBE_ATTR_SRC_LIST]) {
550 if (!vxlan_mdb_is_star_g(&cfg->group)) {
551 NL_SET_ERR_MSG_MOD(extack, "Source list can only be set for (*, G) entries");
552 return -EINVAL;
553 }
554 if (!mdbe_attrs[MDBE_ATTR_GROUP_MODE]) {
555 NL_SET_ERR_MSG_MOD(extack, "Source list cannot be set without filter mode");
556 return -EINVAL;
557 }
558 err = vxlan_mdb_config_src_list_init(cfg, entry->addr.proto,
559 mdbe_attrs[MDBE_ATTR_SRC_LIST],
560 extack);
561 if (err)
562 return err;
563 }
564
565 if (vxlan_mdb_is_star_g(&cfg->group) && list_empty(&cfg->src_list) &&
566 cfg->filter_mode == MCAST_INCLUDE) {
567 NL_SET_ERR_MSG_MOD(extack, "Cannot add (*, G) INCLUDE with an empty source list");
568 return -EINVAL;
569 }
570
571 if (mdbe_attrs[MDBE_ATTR_RTPROT])
572 cfg->rt_protocol = nla_get_u8(mdbe_attrs[MDBE_ATTR_RTPROT]);
573
574 err = vxlan_nla_get_addr(&cfg->remote_ip, mdbe_attrs[MDBE_ATTR_DST]);
575 if (err) {
576 NL_SET_ERR_MSG_MOD(extack, "Invalid remote destination address");
577 goto err_src_list_fini;
578 }
579
580 if (mdbe_attrs[MDBE_ATTR_DST_PORT])
581 cfg->remote_port =
582 cpu_to_be16(nla_get_u16(mdbe_attrs[MDBE_ATTR_DST_PORT]));
583
584 if (mdbe_attrs[MDBE_ATTR_VNI])
585 cfg->remote_vni =
586 cpu_to_be32(nla_get_u32(mdbe_attrs[MDBE_ATTR_VNI]));
587
588 if (mdbe_attrs[MDBE_ATTR_IFINDEX]) {
589 cfg->remote_ifindex =
590 nla_get_s32(mdbe_attrs[MDBE_ATTR_IFINDEX]);
591 if (!__dev_get_by_index(cfg->vxlan->net, cfg->remote_ifindex)) {
592 NL_SET_ERR_MSG_MOD(extack, "Outgoing interface not found");
593 err = -EINVAL;
594 goto err_src_list_fini;
595 }
596 }
597
598 if (mdbe_attrs[MDBE_ATTR_SRC_VNI])
599 cfg->group.vni =
600 cpu_to_be32(nla_get_u32(mdbe_attrs[MDBE_ATTR_SRC_VNI]));
601
602 return 0;
603
604 err_src_list_fini:
605 vxlan_mdb_config_src_list_fini(cfg);
606 return err;
607 }
608
vxlan_mdb_config_init(struct vxlan_mdb_config * cfg,struct net_device * dev,struct nlattr * tb[],u16 nlmsg_flags,struct netlink_ext_ack * extack)609 static int vxlan_mdb_config_init(struct vxlan_mdb_config *cfg,
610 struct net_device *dev, struct nlattr *tb[],
611 u16 nlmsg_flags,
612 struct netlink_ext_ack *extack)
613 {
614 struct br_mdb_entry *entry = nla_data(tb[MDBA_SET_ENTRY]);
615 struct vxlan_dev *vxlan = netdev_priv(dev);
616
617 memset(cfg, 0, sizeof(*cfg));
618 cfg->vxlan = vxlan;
619 cfg->group.vni = vxlan->default_dst.remote_vni;
620 INIT_LIST_HEAD(&cfg->src_list);
621 cfg->nlflags = nlmsg_flags;
622 cfg->filter_mode = MCAST_EXCLUDE;
623 cfg->rt_protocol = RTPROT_STATIC;
624 cfg->remote_vni = vxlan->default_dst.remote_vni;
625 cfg->remote_port = vxlan->cfg.dst_port;
626
627 if (entry->ifindex != dev->ifindex) {
628 NL_SET_ERR_MSG_MOD(extack, "Port net device must be the VXLAN net device");
629 return -EINVAL;
630 }
631
632 /* State is not part of the entry key and can be ignored on deletion
633 * requests.
634 */
635 if ((nlmsg_flags & (NLM_F_CREATE | NLM_F_REPLACE)) &&
636 entry->state != MDB_PERMANENT) {
637 NL_SET_ERR_MSG_MOD(extack, "MDB entry must be permanent");
638 return -EINVAL;
639 }
640
641 if (entry->flags) {
642 NL_SET_ERR_MSG_MOD(extack, "Invalid MDB entry flags");
643 return -EINVAL;
644 }
645
646 if (entry->vid) {
647 NL_SET_ERR_MSG_MOD(extack, "VID must not be specified");
648 return -EINVAL;
649 }
650
651 if (entry->addr.proto != htons(ETH_P_IP) &&
652 entry->addr.proto != htons(ETH_P_IPV6)) {
653 NL_SET_ERR_MSG_MOD(extack, "Group address must be an IPv4 / IPv6 address");
654 return -EINVAL;
655 }
656
657 if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_SET_ENTRY_ATTRS)) {
658 NL_SET_ERR_MSG_MOD(extack, "Missing MDBA_SET_ENTRY_ATTRS attribute");
659 return -EINVAL;
660 }
661
662 return vxlan_mdb_config_attrs_init(cfg, entry, tb[MDBA_SET_ENTRY_ATTRS],
663 extack);
664 }
665
vxlan_mdb_config_fini(struct vxlan_mdb_config * cfg)666 static void vxlan_mdb_config_fini(struct vxlan_mdb_config *cfg)
667 {
668 vxlan_mdb_config_src_list_fini(cfg);
669 }
670
671 static struct vxlan_mdb_entry *
vxlan_mdb_entry_lookup(struct vxlan_dev * vxlan,const struct vxlan_mdb_entry_key * group)672 vxlan_mdb_entry_lookup(struct vxlan_dev *vxlan,
673 const struct vxlan_mdb_entry_key *group)
674 {
675 return rhashtable_lookup_fast(&vxlan->mdb_tbl, group,
676 vxlan_mdb_rht_params);
677 }
678
679 static struct vxlan_mdb_remote *
vxlan_mdb_remote_lookup(const struct vxlan_mdb_entry * mdb_entry,const union vxlan_addr * addr)680 vxlan_mdb_remote_lookup(const struct vxlan_mdb_entry *mdb_entry,
681 const union vxlan_addr *addr)
682 {
683 struct vxlan_mdb_remote *remote;
684
685 list_for_each_entry(remote, &mdb_entry->remotes, list) {
686 struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
687
688 if (vxlan_addr_equal(addr, &rd->remote_ip))
689 return remote;
690 }
691
692 return NULL;
693 }
694
vxlan_mdb_rdst_free(struct rcu_head * head)695 static void vxlan_mdb_rdst_free(struct rcu_head *head)
696 {
697 struct vxlan_rdst *rd = container_of(head, struct vxlan_rdst, rcu);
698
699 dst_cache_destroy(&rd->dst_cache);
700 kfree(rd);
701 }
702
vxlan_mdb_remote_rdst_init(const struct vxlan_mdb_config * cfg,struct vxlan_mdb_remote * remote)703 static int vxlan_mdb_remote_rdst_init(const struct vxlan_mdb_config *cfg,
704 struct vxlan_mdb_remote *remote)
705 {
706 struct vxlan_rdst *rd;
707 int err;
708
709 rd = kzalloc_obj(*rd);
710 if (!rd)
711 return -ENOMEM;
712
713 err = dst_cache_init(&rd->dst_cache, GFP_KERNEL);
714 if (err)
715 goto err_free_rdst;
716
717 rd->remote_ip = cfg->remote_ip;
718 rd->remote_port = cfg->remote_port;
719 rd->remote_vni = cfg->remote_vni;
720 rd->remote_ifindex = cfg->remote_ifindex;
721 rcu_assign_pointer(remote->rd, rd);
722
723 return 0;
724
725 err_free_rdst:
726 kfree(rd);
727 return err;
728 }
729
vxlan_mdb_remote_rdst_fini(struct vxlan_rdst * rd)730 static void vxlan_mdb_remote_rdst_fini(struct vxlan_rdst *rd)
731 {
732 call_rcu(&rd->rcu, vxlan_mdb_rdst_free);
733 }
734
vxlan_mdb_remote_init(const struct vxlan_mdb_config * cfg,struct vxlan_mdb_remote * remote)735 static int vxlan_mdb_remote_init(const struct vxlan_mdb_config *cfg,
736 struct vxlan_mdb_remote *remote)
737 {
738 int err;
739
740 err = vxlan_mdb_remote_rdst_init(cfg, remote);
741 if (err)
742 return err;
743
744 remote->flags = cfg->flags;
745 remote->filter_mode = cfg->filter_mode;
746 remote->rt_protocol = cfg->rt_protocol;
747 INIT_HLIST_HEAD(&remote->src_list);
748
749 return 0;
750 }
751
vxlan_mdb_remote_fini(struct vxlan_dev * vxlan,struct vxlan_mdb_remote * remote)752 static void vxlan_mdb_remote_fini(struct vxlan_dev *vxlan,
753 struct vxlan_mdb_remote *remote)
754 {
755 WARN_ON_ONCE(!hlist_empty(&remote->src_list));
756 vxlan_mdb_remote_rdst_fini(rtnl_dereference(remote->rd));
757 }
758
759 static struct vxlan_mdb_src_entry *
vxlan_mdb_remote_src_entry_lookup(const struct vxlan_mdb_remote * remote,const union vxlan_addr * addr)760 vxlan_mdb_remote_src_entry_lookup(const struct vxlan_mdb_remote *remote,
761 const union vxlan_addr *addr)
762 {
763 struct vxlan_mdb_src_entry *ent;
764
765 hlist_for_each_entry(ent, &remote->src_list, node) {
766 if (vxlan_addr_equal(&ent->addr, addr))
767 return ent;
768 }
769
770 return NULL;
771 }
772
773 static struct vxlan_mdb_src_entry *
vxlan_mdb_remote_src_entry_add(struct vxlan_mdb_remote * remote,const union vxlan_addr * addr)774 vxlan_mdb_remote_src_entry_add(struct vxlan_mdb_remote *remote,
775 const union vxlan_addr *addr)
776 {
777 struct vxlan_mdb_src_entry *ent;
778
779 ent = kzalloc_obj(*ent);
780 if (!ent)
781 return NULL;
782
783 ent->addr = *addr;
784 hlist_add_head(&ent->node, &remote->src_list);
785
786 return ent;
787 }
788
789 static void
vxlan_mdb_remote_src_entry_del(struct vxlan_mdb_src_entry * ent)790 vxlan_mdb_remote_src_entry_del(struct vxlan_mdb_src_entry *ent)
791 {
792 hlist_del(&ent->node);
793 kfree(ent);
794 }
795
796 static int
vxlan_mdb_remote_src_fwd_add(const struct vxlan_mdb_config * cfg,const union vxlan_addr * addr,struct netlink_ext_ack * extack)797 vxlan_mdb_remote_src_fwd_add(const struct vxlan_mdb_config *cfg,
798 const union vxlan_addr *addr,
799 struct netlink_ext_ack *extack)
800 {
801 struct vxlan_mdb_config sg_cfg;
802
803 memset(&sg_cfg, 0, sizeof(sg_cfg));
804 sg_cfg.vxlan = cfg->vxlan;
805 sg_cfg.group.src = *addr;
806 sg_cfg.group.dst = cfg->group.dst;
807 sg_cfg.group.vni = cfg->group.vni;
808 INIT_LIST_HEAD(&sg_cfg.src_list);
809 sg_cfg.remote_ip = cfg->remote_ip;
810 sg_cfg.remote_ifindex = cfg->remote_ifindex;
811 sg_cfg.remote_vni = cfg->remote_vni;
812 sg_cfg.remote_port = cfg->remote_port;
813 sg_cfg.nlflags = cfg->nlflags;
814 sg_cfg.filter_mode = MCAST_INCLUDE;
815 if (cfg->filter_mode == MCAST_EXCLUDE)
816 sg_cfg.flags = VXLAN_MDB_REMOTE_F_BLOCKED;
817 sg_cfg.rt_protocol = cfg->rt_protocol;
818
819 return __vxlan_mdb_add(&sg_cfg, extack);
820 }
821
822 static void
vxlan_mdb_remote_src_fwd_del(struct vxlan_dev * vxlan,const struct vxlan_mdb_entry_key * group,const struct vxlan_mdb_remote * remote,const union vxlan_addr * addr)823 vxlan_mdb_remote_src_fwd_del(struct vxlan_dev *vxlan,
824 const struct vxlan_mdb_entry_key *group,
825 const struct vxlan_mdb_remote *remote,
826 const union vxlan_addr *addr)
827 {
828 struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
829 struct vxlan_mdb_config sg_cfg;
830
831 memset(&sg_cfg, 0, sizeof(sg_cfg));
832 sg_cfg.vxlan = vxlan;
833 sg_cfg.group.src = *addr;
834 sg_cfg.group.dst = group->dst;
835 sg_cfg.group.vni = group->vni;
836 INIT_LIST_HEAD(&sg_cfg.src_list);
837 sg_cfg.remote_ip = rd->remote_ip;
838
839 __vxlan_mdb_del(&sg_cfg, NULL);
840 }
841
842 static int
vxlan_mdb_remote_src_add(const struct vxlan_mdb_config * cfg,struct vxlan_mdb_remote * remote,const struct vxlan_mdb_config_src_entry * src,struct netlink_ext_ack * extack)843 vxlan_mdb_remote_src_add(const struct vxlan_mdb_config *cfg,
844 struct vxlan_mdb_remote *remote,
845 const struct vxlan_mdb_config_src_entry *src,
846 struct netlink_ext_ack *extack)
847 {
848 struct vxlan_mdb_src_entry *ent;
849 int err;
850
851 ent = vxlan_mdb_remote_src_entry_lookup(remote, &src->addr);
852 if (!ent) {
853 ent = vxlan_mdb_remote_src_entry_add(remote, &src->addr);
854 if (!ent)
855 return -ENOMEM;
856 ent->flags |= VXLAN_SGRP_F_NEW;
857 } else if (!(cfg->nlflags & NLM_F_REPLACE)) {
858 NL_SET_ERR_MSG_MOD(extack, "Source entry already exists");
859 return -EEXIST;
860 }
861
862 err = vxlan_mdb_remote_src_fwd_add(cfg, &ent->addr, extack);
863 if (err)
864 goto err_src_del;
865
866 /* Clear the deletion mark so the entry survives the replace sweep.
867 * The new mark is retained until the whole operation succeeds.
868 */
869 ent->flags &= ~VXLAN_SGRP_F_DELETE;
870
871 return 0;
872
873 err_src_del:
874 if (ent->flags & VXLAN_SGRP_F_NEW)
875 vxlan_mdb_remote_src_entry_del(ent);
876 return err;
877 }
878
vxlan_mdb_remote_src_del(struct vxlan_dev * vxlan,const struct vxlan_mdb_entry_key * group,const struct vxlan_mdb_remote * remote,struct vxlan_mdb_src_entry * ent)879 static void vxlan_mdb_remote_src_del(struct vxlan_dev *vxlan,
880 const struct vxlan_mdb_entry_key *group,
881 const struct vxlan_mdb_remote *remote,
882 struct vxlan_mdb_src_entry *ent)
883 {
884 vxlan_mdb_remote_src_fwd_del(vxlan, group, remote, &ent->addr);
885 vxlan_mdb_remote_src_entry_del(ent);
886 }
887
vxlan_mdb_remote_srcs_add(const struct vxlan_mdb_config * cfg,struct vxlan_mdb_remote * remote,struct netlink_ext_ack * extack)888 static int vxlan_mdb_remote_srcs_add(const struct vxlan_mdb_config *cfg,
889 struct vxlan_mdb_remote *remote,
890 struct netlink_ext_ack *extack)
891 {
892 struct vxlan_mdb_config_src_entry *src;
893 struct vxlan_mdb_src_entry *ent;
894 struct hlist_node *tmp;
895 int err;
896
897 list_for_each_entry(src, &cfg->src_list, node) {
898 err = vxlan_mdb_remote_src_add(cfg, remote, src, extack);
899 if (err)
900 goto err_src_del;
901 }
902
903 hlist_for_each_entry(ent, &remote->src_list, node)
904 ent->flags &= ~VXLAN_SGRP_F_NEW;
905
906 return 0;
907
908 err_src_del:
909 hlist_for_each_entry_safe(ent, tmp, &remote->src_list, node) {
910 if (ent->flags & VXLAN_SGRP_F_NEW)
911 vxlan_mdb_remote_src_del(cfg->vxlan, &cfg->group, remote,
912 ent);
913 else
914 ent->flags &= ~VXLAN_SGRP_F_DELETE;
915 }
916 return err;
917 }
918
vxlan_mdb_remote_srcs_del(struct vxlan_dev * vxlan,const struct vxlan_mdb_entry_key * group,struct vxlan_mdb_remote * remote)919 static void vxlan_mdb_remote_srcs_del(struct vxlan_dev *vxlan,
920 const struct vxlan_mdb_entry_key *group,
921 struct vxlan_mdb_remote *remote)
922 {
923 struct vxlan_mdb_src_entry *ent;
924 struct hlist_node *tmp;
925
926 hlist_for_each_entry_safe(ent, tmp, &remote->src_list, node)
927 vxlan_mdb_remote_src_del(vxlan, group, remote, ent);
928 }
929
930 static size_t
vxlan_mdb_nlmsg_src_list_size(const struct vxlan_mdb_entry_key * group,const struct vxlan_mdb_remote * remote)931 vxlan_mdb_nlmsg_src_list_size(const struct vxlan_mdb_entry_key *group,
932 const struct vxlan_mdb_remote *remote)
933 {
934 struct vxlan_mdb_src_entry *ent;
935 size_t nlmsg_size;
936
937 if (hlist_empty(&remote->src_list))
938 return 0;
939
940 /* MDBA_MDB_EATTR_SRC_LIST */
941 nlmsg_size = nla_total_size(0);
942
943 hlist_for_each_entry(ent, &remote->src_list, node) {
944 /* MDBA_MDB_SRCLIST_ENTRY */
945 nlmsg_size += nla_total_size(0) +
946 /* MDBA_MDB_SRCATTR_ADDRESS */
947 nla_total_size(vxlan_addr_size(&group->dst)) +
948 /* MDBA_MDB_SRCATTR_TIMER */
949 nla_total_size(sizeof(u8));
950 }
951
952 return nlmsg_size;
953 }
954
955 static size_t
vxlan_mdb_nlmsg_remote_size(const struct vxlan_dev * vxlan,const struct vxlan_mdb_entry * mdb_entry,const struct vxlan_mdb_remote * remote)956 vxlan_mdb_nlmsg_remote_size(const struct vxlan_dev *vxlan,
957 const struct vxlan_mdb_entry *mdb_entry,
958 const struct vxlan_mdb_remote *remote)
959 {
960 const struct vxlan_mdb_entry_key *group = &mdb_entry->key;
961 struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
962 size_t nlmsg_size;
963
964 /* MDBA_MDB_ENTRY_INFO */
965 nlmsg_size = nla_total_size(sizeof(struct br_mdb_entry)) +
966 /* MDBA_MDB_EATTR_TIMER */
967 nla_total_size(sizeof(u32));
968
969 /* MDBA_MDB_EATTR_SOURCE */
970 if (vxlan_mdb_is_sg(group))
971 nlmsg_size += nla_total_size(vxlan_addr_size(&group->dst));
972 /* MDBA_MDB_EATTR_RTPROT */
973 nlmsg_size += nla_total_size(sizeof(u8));
974 /* MDBA_MDB_EATTR_SRC_LIST */
975 nlmsg_size += vxlan_mdb_nlmsg_src_list_size(group, remote);
976 /* MDBA_MDB_EATTR_GROUP_MODE */
977 nlmsg_size += nla_total_size(sizeof(u8));
978 /* MDBA_MDB_EATTR_DST */
979 nlmsg_size += nla_total_size(vxlan_addr_size(&rd->remote_ip));
980 /* MDBA_MDB_EATTR_DST_PORT */
981 if (rd->remote_port && rd->remote_port != vxlan->cfg.dst_port)
982 nlmsg_size += nla_total_size(sizeof(u16));
983 /* MDBA_MDB_EATTR_VNI */
984 if (rd->remote_vni != vxlan->default_dst.remote_vni)
985 nlmsg_size += nla_total_size(sizeof(u32));
986 /* MDBA_MDB_EATTR_IFINDEX */
987 if (rd->remote_ifindex)
988 nlmsg_size += nla_total_size(sizeof(u32));
989 /* MDBA_MDB_EATTR_SRC_VNI */
990 if ((vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) && group->vni)
991 nlmsg_size += nla_total_size(sizeof(u32));
992
993 return nlmsg_size;
994 }
995
vxlan_mdb_nlmsg_size(const struct vxlan_dev * vxlan,const struct vxlan_mdb_entry * mdb_entry,const struct vxlan_mdb_remote * remote)996 static size_t vxlan_mdb_nlmsg_size(const struct vxlan_dev *vxlan,
997 const struct vxlan_mdb_entry *mdb_entry,
998 const struct vxlan_mdb_remote *remote)
999 {
1000 return NLMSG_ALIGN(sizeof(struct br_port_msg)) +
1001 /* MDBA_MDB */
1002 nla_total_size(0) +
1003 /* MDBA_MDB_ENTRY */
1004 nla_total_size(0) +
1005 /* Remote entry */
1006 vxlan_mdb_nlmsg_remote_size(vxlan, mdb_entry, remote);
1007 }
1008
vxlan_mdb_nlmsg_fill(const struct vxlan_dev * vxlan,struct sk_buff * skb,const struct vxlan_mdb_entry * mdb_entry,const struct vxlan_mdb_remote * remote,int type)1009 static int vxlan_mdb_nlmsg_fill(const struct vxlan_dev *vxlan,
1010 struct sk_buff *skb,
1011 const struct vxlan_mdb_entry *mdb_entry,
1012 const struct vxlan_mdb_remote *remote,
1013 int type)
1014 {
1015 struct nlattr *mdb_nest, *mdb_entry_nest;
1016 struct br_port_msg *bpm;
1017 struct nlmsghdr *nlh;
1018
1019 nlh = nlmsg_put(skb, 0, 0, type, sizeof(*bpm), 0);
1020 if (!nlh)
1021 return -EMSGSIZE;
1022
1023 bpm = nlmsg_data(nlh);
1024 memset(bpm, 0, sizeof(*bpm));
1025 bpm->family = AF_BRIDGE;
1026 bpm->ifindex = vxlan->dev->ifindex;
1027
1028 mdb_nest = nla_nest_start_noflag(skb, MDBA_MDB);
1029 if (!mdb_nest)
1030 goto cancel;
1031 mdb_entry_nest = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
1032 if (!mdb_entry_nest)
1033 goto cancel;
1034
1035 if (vxlan_mdb_entry_info_fill(vxlan, skb, mdb_entry, remote))
1036 goto cancel;
1037
1038 nla_nest_end(skb, mdb_entry_nest);
1039 nla_nest_end(skb, mdb_nest);
1040 nlmsg_end(skb, nlh);
1041
1042 return 0;
1043
1044 cancel:
1045 nlmsg_cancel(skb, nlh);
1046 return -EMSGSIZE;
1047 }
1048
vxlan_mdb_remote_notify(const struct vxlan_dev * vxlan,const struct vxlan_mdb_entry * mdb_entry,const struct vxlan_mdb_remote * remote,int type)1049 static void vxlan_mdb_remote_notify(const struct vxlan_dev *vxlan,
1050 const struct vxlan_mdb_entry *mdb_entry,
1051 const struct vxlan_mdb_remote *remote,
1052 int type)
1053 {
1054 struct net *net = dev_net(vxlan->dev);
1055 struct sk_buff *skb;
1056 int err = -ENOBUFS;
1057
1058 skb = nlmsg_new(vxlan_mdb_nlmsg_size(vxlan, mdb_entry, remote),
1059 GFP_KERNEL);
1060 if (!skb)
1061 goto errout;
1062
1063 err = vxlan_mdb_nlmsg_fill(vxlan, skb, mdb_entry, remote, type);
1064 if (err) {
1065 kfree_skb(skb);
1066 goto errout;
1067 }
1068
1069 rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_KERNEL);
1070 return;
1071 errout:
1072 rtnl_set_sk_err(net, RTNLGRP_MDB, err);
1073 }
1074
1075 static int
vxlan_mdb_remote_srcs_replace(const struct vxlan_mdb_config * cfg,const struct vxlan_mdb_entry * mdb_entry,struct vxlan_mdb_remote * remote,struct netlink_ext_ack * extack)1076 vxlan_mdb_remote_srcs_replace(const struct vxlan_mdb_config *cfg,
1077 const struct vxlan_mdb_entry *mdb_entry,
1078 struct vxlan_mdb_remote *remote,
1079 struct netlink_ext_ack *extack)
1080 {
1081 struct vxlan_dev *vxlan = cfg->vxlan;
1082 struct vxlan_mdb_src_entry *ent;
1083 struct hlist_node *tmp;
1084 int err;
1085
1086 hlist_for_each_entry(ent, &remote->src_list, node)
1087 ent->flags |= VXLAN_SGRP_F_DELETE;
1088
1089 err = vxlan_mdb_remote_srcs_add(cfg, remote, extack);
1090 if (err)
1091 return err;
1092
1093 hlist_for_each_entry_safe(ent, tmp, &remote->src_list, node) {
1094 if (ent->flags & VXLAN_SGRP_F_DELETE)
1095 vxlan_mdb_remote_src_del(vxlan, &mdb_entry->key, remote,
1096 ent);
1097 }
1098
1099 return 0;
1100 }
1101
vxlan_mdb_remote_replace(const struct vxlan_mdb_config * cfg,const struct vxlan_mdb_entry * mdb_entry,struct vxlan_mdb_remote * remote,struct netlink_ext_ack * extack)1102 static int vxlan_mdb_remote_replace(const struct vxlan_mdb_config *cfg,
1103 const struct vxlan_mdb_entry *mdb_entry,
1104 struct vxlan_mdb_remote *remote,
1105 struct netlink_ext_ack *extack)
1106 {
1107 struct vxlan_rdst *new_rd, *old_rd = rtnl_dereference(remote->rd);
1108 struct vxlan_dev *vxlan = cfg->vxlan;
1109 int err;
1110
1111 err = vxlan_mdb_remote_rdst_init(cfg, remote);
1112 if (err)
1113 return err;
1114 new_rd = rtnl_dereference(remote->rd);
1115
1116 err = vxlan_mdb_remote_srcs_replace(cfg, mdb_entry, remote, extack);
1117 if (err)
1118 goto err_rdst_reset;
1119
1120 WRITE_ONCE(remote->flags, cfg->flags);
1121 WRITE_ONCE(remote->filter_mode, cfg->filter_mode);
1122 remote->rt_protocol = cfg->rt_protocol;
1123 vxlan_mdb_remote_notify(vxlan, mdb_entry, remote, RTM_NEWMDB);
1124
1125 vxlan_mdb_remote_rdst_fini(old_rd);
1126
1127 return 0;
1128
1129 err_rdst_reset:
1130 rcu_assign_pointer(remote->rd, old_rd);
1131 vxlan_mdb_remote_rdst_fini(new_rd);
1132 return err;
1133 }
1134
vxlan_mdb_remote_add(const struct vxlan_mdb_config * cfg,struct vxlan_mdb_entry * mdb_entry,struct netlink_ext_ack * extack)1135 static int vxlan_mdb_remote_add(const struct vxlan_mdb_config *cfg,
1136 struct vxlan_mdb_entry *mdb_entry,
1137 struct netlink_ext_ack *extack)
1138 {
1139 struct vxlan_mdb_remote *remote;
1140 int err;
1141
1142 remote = vxlan_mdb_remote_lookup(mdb_entry, &cfg->remote_ip);
1143 if (remote) {
1144 if (!(cfg->nlflags & NLM_F_REPLACE)) {
1145 NL_SET_ERR_MSG_MOD(extack, "Replace not specified and MDB remote entry already exists");
1146 return -EEXIST;
1147 }
1148 return vxlan_mdb_remote_replace(cfg, mdb_entry, remote, extack);
1149 }
1150
1151 if (!(cfg->nlflags & NLM_F_CREATE)) {
1152 NL_SET_ERR_MSG_MOD(extack, "Create not specified and entry does not exist");
1153 return -ENOENT;
1154 }
1155
1156 remote = kzalloc_obj(*remote);
1157 if (!remote)
1158 return -ENOMEM;
1159
1160 err = vxlan_mdb_remote_init(cfg, remote);
1161 if (err) {
1162 NL_SET_ERR_MSG_MOD(extack, "Failed to initialize remote MDB entry");
1163 goto err_free_remote;
1164 }
1165
1166 err = vxlan_mdb_remote_srcs_add(cfg, remote, extack);
1167 if (err)
1168 goto err_remote_fini;
1169
1170 list_add_rcu(&remote->list, &mdb_entry->remotes);
1171 vxlan_mdb_remote_notify(cfg->vxlan, mdb_entry, remote, RTM_NEWMDB);
1172
1173 return 0;
1174
1175 err_remote_fini:
1176 vxlan_mdb_remote_fini(cfg->vxlan, remote);
1177 err_free_remote:
1178 kfree(remote);
1179 return err;
1180 }
1181
vxlan_mdb_remote_del(struct vxlan_dev * vxlan,struct vxlan_mdb_entry * mdb_entry,struct vxlan_mdb_remote * remote)1182 static void vxlan_mdb_remote_del(struct vxlan_dev *vxlan,
1183 struct vxlan_mdb_entry *mdb_entry,
1184 struct vxlan_mdb_remote *remote)
1185 {
1186 vxlan_mdb_remote_notify(vxlan, mdb_entry, remote, RTM_DELMDB);
1187 list_del_rcu(&remote->list);
1188 vxlan_mdb_remote_srcs_del(vxlan, &mdb_entry->key, remote);
1189 vxlan_mdb_remote_fini(vxlan, remote);
1190 kfree_rcu(remote, rcu);
1191 }
1192
1193 static struct vxlan_mdb_entry *
vxlan_mdb_entry_get(struct vxlan_dev * vxlan,const struct vxlan_mdb_entry_key * group)1194 vxlan_mdb_entry_get(struct vxlan_dev *vxlan,
1195 const struct vxlan_mdb_entry_key *group)
1196 {
1197 struct vxlan_mdb_entry *mdb_entry;
1198 int err;
1199
1200 mdb_entry = vxlan_mdb_entry_lookup(vxlan, group);
1201 if (mdb_entry)
1202 return mdb_entry;
1203
1204 mdb_entry = kzalloc_obj(*mdb_entry);
1205 if (!mdb_entry)
1206 return ERR_PTR(-ENOMEM);
1207
1208 INIT_LIST_HEAD(&mdb_entry->remotes);
1209 memcpy(&mdb_entry->key, group, sizeof(mdb_entry->key));
1210 hlist_add_head(&mdb_entry->mdb_node, &vxlan->mdb_list);
1211
1212 err = rhashtable_lookup_insert_fast(&vxlan->mdb_tbl,
1213 &mdb_entry->rhnode,
1214 vxlan_mdb_rht_params);
1215 if (err)
1216 goto err_free_entry;
1217
1218 if (hlist_is_singular_node(&mdb_entry->mdb_node, &vxlan->mdb_list))
1219 vxlan->cfg.flags |= VXLAN_F_MDB;
1220
1221 return mdb_entry;
1222
1223 err_free_entry:
1224 hlist_del(&mdb_entry->mdb_node);
1225 kfree(mdb_entry);
1226 return ERR_PTR(err);
1227 }
1228
vxlan_mdb_entry_put(struct vxlan_dev * vxlan,struct vxlan_mdb_entry * mdb_entry)1229 static void vxlan_mdb_entry_put(struct vxlan_dev *vxlan,
1230 struct vxlan_mdb_entry *mdb_entry)
1231 {
1232 if (!list_empty(&mdb_entry->remotes))
1233 return;
1234
1235 if (hlist_is_singular_node(&mdb_entry->mdb_node, &vxlan->mdb_list))
1236 vxlan->cfg.flags &= ~VXLAN_F_MDB;
1237
1238 rhashtable_remove_fast(&vxlan->mdb_tbl, &mdb_entry->rhnode,
1239 vxlan_mdb_rht_params);
1240 hlist_del(&mdb_entry->mdb_node);
1241 kfree_rcu(mdb_entry, rcu);
1242 }
1243
__vxlan_mdb_add(const struct vxlan_mdb_config * cfg,struct netlink_ext_ack * extack)1244 static int __vxlan_mdb_add(const struct vxlan_mdb_config *cfg,
1245 struct netlink_ext_ack *extack)
1246 {
1247 struct vxlan_dev *vxlan = cfg->vxlan;
1248 struct vxlan_mdb_entry *mdb_entry;
1249 int err;
1250
1251 mdb_entry = vxlan_mdb_entry_get(vxlan, &cfg->group);
1252 if (IS_ERR(mdb_entry))
1253 return PTR_ERR(mdb_entry);
1254
1255 err = vxlan_mdb_remote_add(cfg, mdb_entry, extack);
1256 if (err)
1257 goto err_entry_put;
1258
1259 vxlan->mdb_seq++;
1260
1261 return 0;
1262
1263 err_entry_put:
1264 vxlan_mdb_entry_put(vxlan, mdb_entry);
1265 return err;
1266 }
1267
__vxlan_mdb_del(const struct vxlan_mdb_config * cfg,struct netlink_ext_ack * extack)1268 static int __vxlan_mdb_del(const struct vxlan_mdb_config *cfg,
1269 struct netlink_ext_ack *extack)
1270 {
1271 struct vxlan_dev *vxlan = cfg->vxlan;
1272 struct vxlan_mdb_entry *mdb_entry;
1273 struct vxlan_mdb_remote *remote;
1274
1275 mdb_entry = vxlan_mdb_entry_lookup(vxlan, &cfg->group);
1276 if (!mdb_entry) {
1277 NL_SET_ERR_MSG_MOD(extack, "Did not find MDB entry");
1278 return -ENOENT;
1279 }
1280
1281 remote = vxlan_mdb_remote_lookup(mdb_entry, &cfg->remote_ip);
1282 if (!remote) {
1283 NL_SET_ERR_MSG_MOD(extack, "Did not find MDB remote entry");
1284 return -ENOENT;
1285 }
1286
1287 vxlan_mdb_remote_del(vxlan, mdb_entry, remote);
1288 vxlan_mdb_entry_put(vxlan, mdb_entry);
1289
1290 vxlan->mdb_seq++;
1291
1292 return 0;
1293 }
1294
vxlan_mdb_add(struct net_device * dev,struct nlattr * tb[],u16 nlmsg_flags,struct netlink_ext_ack * extack)1295 int vxlan_mdb_add(struct net_device *dev, struct nlattr *tb[], u16 nlmsg_flags,
1296 struct netlink_ext_ack *extack)
1297 {
1298 struct vxlan_mdb_config cfg;
1299 int err;
1300
1301 ASSERT_RTNL();
1302
1303 err = vxlan_mdb_config_init(&cfg, dev, tb, nlmsg_flags, extack);
1304 if (err)
1305 return err;
1306
1307 err = __vxlan_mdb_add(&cfg, extack);
1308
1309 vxlan_mdb_config_fini(&cfg);
1310 return err;
1311 }
1312
vxlan_mdb_del(struct net_device * dev,struct nlattr * tb[],struct netlink_ext_ack * extack)1313 int vxlan_mdb_del(struct net_device *dev, struct nlattr *tb[],
1314 struct netlink_ext_ack *extack)
1315 {
1316 struct vxlan_mdb_config cfg;
1317 int err;
1318
1319 ASSERT_RTNL();
1320
1321 err = vxlan_mdb_config_init(&cfg, dev, tb, 0, extack);
1322 if (err)
1323 return err;
1324
1325 err = __vxlan_mdb_del(&cfg, extack);
1326
1327 vxlan_mdb_config_fini(&cfg);
1328 return err;
1329 }
1330
1331 static const struct nla_policy
1332 vxlan_mdbe_attrs_del_bulk_pol[MDBE_ATTR_MAX + 1] = {
1333 [MDBE_ATTR_RTPROT] = NLA_POLICY_MIN(NLA_U8, RTPROT_STATIC),
1334 [MDBE_ATTR_DST] = NLA_POLICY_RANGE(NLA_BINARY,
1335 sizeof(struct in_addr),
1336 sizeof(struct in6_addr)),
1337 [MDBE_ATTR_DST_PORT] = { .type = NLA_U16 },
1338 [MDBE_ATTR_VNI] = NLA_POLICY_FULL_RANGE(NLA_U32, &vni_range),
1339 [MDBE_ATTR_SRC_VNI] = NLA_POLICY_FULL_RANGE(NLA_U32, &vni_range),
1340 [MDBE_ATTR_STATE_MASK] = NLA_POLICY_MASK(NLA_U8, MDB_PERMANENT),
1341 };
1342
vxlan_mdb_flush_desc_init(struct vxlan_dev * vxlan,struct vxlan_mdb_flush_desc * desc,struct nlattr * tb[],struct netlink_ext_ack * extack)1343 static int vxlan_mdb_flush_desc_init(struct vxlan_dev *vxlan,
1344 struct vxlan_mdb_flush_desc *desc,
1345 struct nlattr *tb[],
1346 struct netlink_ext_ack *extack)
1347 {
1348 struct br_mdb_entry *entry = nla_data(tb[MDBA_SET_ENTRY]);
1349 struct nlattr *mdbe_attrs[MDBE_ATTR_MAX + 1];
1350 int err;
1351
1352 if (entry->ifindex && entry->ifindex != vxlan->dev->ifindex) {
1353 NL_SET_ERR_MSG_MOD(extack, "Invalid port net device");
1354 return -EINVAL;
1355 }
1356
1357 if (entry->vid) {
1358 NL_SET_ERR_MSG_MOD(extack, "VID must not be specified");
1359 return -EINVAL;
1360 }
1361
1362 if (!tb[MDBA_SET_ENTRY_ATTRS])
1363 return 0;
1364
1365 err = nla_parse_nested(mdbe_attrs, MDBE_ATTR_MAX,
1366 tb[MDBA_SET_ENTRY_ATTRS],
1367 vxlan_mdbe_attrs_del_bulk_pol, extack);
1368 if (err)
1369 return err;
1370
1371 if (mdbe_attrs[MDBE_ATTR_STATE_MASK]) {
1372 u8 state_mask = nla_get_u8(mdbe_attrs[MDBE_ATTR_STATE_MASK]);
1373
1374 if ((state_mask & MDB_PERMANENT) && !(entry->state & MDB_PERMANENT)) {
1375 NL_SET_ERR_MSG_MOD(extack, "Only permanent MDB entries are supported");
1376 return -EINVAL;
1377 }
1378 }
1379
1380 if (mdbe_attrs[MDBE_ATTR_RTPROT])
1381 desc->rt_protocol = nla_get_u8(mdbe_attrs[MDBE_ATTR_RTPROT]);
1382
1383 if (mdbe_attrs[MDBE_ATTR_DST])
1384 vxlan_nla_get_addr(&desc->remote_ip, mdbe_attrs[MDBE_ATTR_DST]);
1385
1386 if (mdbe_attrs[MDBE_ATTR_DST_PORT])
1387 desc->remote_port =
1388 cpu_to_be16(nla_get_u16(mdbe_attrs[MDBE_ATTR_DST_PORT]));
1389
1390 if (mdbe_attrs[MDBE_ATTR_VNI])
1391 desc->remote_vni =
1392 cpu_to_be32(nla_get_u32(mdbe_attrs[MDBE_ATTR_VNI]));
1393
1394 if (mdbe_attrs[MDBE_ATTR_SRC_VNI])
1395 desc->src_vni =
1396 cpu_to_be32(nla_get_u32(mdbe_attrs[MDBE_ATTR_SRC_VNI]));
1397
1398 return 0;
1399 }
1400
vxlan_mdb_remotes_flush(struct vxlan_dev * vxlan,struct vxlan_mdb_entry * mdb_entry,const struct vxlan_mdb_flush_desc * desc)1401 static void vxlan_mdb_remotes_flush(struct vxlan_dev *vxlan,
1402 struct vxlan_mdb_entry *mdb_entry,
1403 const struct vxlan_mdb_flush_desc *desc)
1404 {
1405 struct vxlan_mdb_remote *remote, *tmp;
1406
1407 list_for_each_entry_safe(remote, tmp, &mdb_entry->remotes, list) {
1408 struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
1409 __be32 remote_vni;
1410
1411 if (desc->remote_ip.sa.sa_family &&
1412 !vxlan_addr_equal(&desc->remote_ip, &rd->remote_ip))
1413 continue;
1414
1415 /* Encapsulation is performed with source VNI if remote VNI
1416 * is not set.
1417 */
1418 remote_vni = rd->remote_vni ? : mdb_entry->key.vni;
1419 if (desc->remote_vni && desc->remote_vni != remote_vni)
1420 continue;
1421
1422 if (desc->remote_port && desc->remote_port != rd->remote_port)
1423 continue;
1424
1425 if (desc->rt_protocol &&
1426 desc->rt_protocol != remote->rt_protocol)
1427 continue;
1428
1429 vxlan_mdb_remote_del(vxlan, mdb_entry, remote);
1430 }
1431 }
1432
vxlan_mdb_flush(struct vxlan_dev * vxlan,const struct vxlan_mdb_flush_desc * desc)1433 static void vxlan_mdb_flush(struct vxlan_dev *vxlan,
1434 const struct vxlan_mdb_flush_desc *desc)
1435 {
1436 struct vxlan_mdb_entry *mdb_entry;
1437 struct hlist_node *tmp;
1438
1439 hlist_for_each_entry_safe(mdb_entry, tmp, &vxlan->mdb_list, mdb_node) {
1440 if (desc->src_vni && desc->src_vni != mdb_entry->key.vni)
1441 continue;
1442
1443 vxlan_mdb_remotes_flush(vxlan, mdb_entry, desc);
1444 /* The flush can remove the (S, G) entries created for the
1445 * source list of this entry, including the one saved by
1446 * hlist_for_each_entry_safe(), so re-read it while this entry
1447 * is still linked.
1448 */
1449 tmp = mdb_entry->mdb_node.next;
1450 /* Entry will only be removed if its remotes list is empty. */
1451 vxlan_mdb_entry_put(vxlan, mdb_entry);
1452 }
1453 }
1454
vxlan_mdb_del_bulk(struct net_device * dev,struct nlattr * tb[],struct netlink_ext_ack * extack)1455 int vxlan_mdb_del_bulk(struct net_device *dev, struct nlattr *tb[],
1456 struct netlink_ext_ack *extack)
1457 {
1458 struct vxlan_dev *vxlan = netdev_priv(dev);
1459 struct vxlan_mdb_flush_desc desc = {};
1460 int err;
1461
1462 ASSERT_RTNL();
1463
1464 err = vxlan_mdb_flush_desc_init(vxlan, &desc, tb, extack);
1465 if (err)
1466 return err;
1467
1468 vxlan_mdb_flush(vxlan, &desc);
1469
1470 return 0;
1471 }
1472
1473 static const struct nla_policy vxlan_mdbe_attrs_get_pol[MDBE_ATTR_MAX + 1] = {
1474 [MDBE_ATTR_SOURCE] = NLA_POLICY_RANGE(NLA_BINARY,
1475 sizeof(struct in_addr),
1476 sizeof(struct in6_addr)),
1477 [MDBE_ATTR_SRC_VNI] = NLA_POLICY_FULL_RANGE(NLA_U32, &vni_range),
1478 };
1479
vxlan_mdb_get_parse(struct net_device * dev,struct nlattr * tb[],struct vxlan_mdb_entry_key * group,struct netlink_ext_ack * extack)1480 static int vxlan_mdb_get_parse(struct net_device *dev, struct nlattr *tb[],
1481 struct vxlan_mdb_entry_key *group,
1482 struct netlink_ext_ack *extack)
1483 {
1484 struct br_mdb_entry *entry = nla_data(tb[MDBA_GET_ENTRY]);
1485 struct nlattr *mdbe_attrs[MDBE_ATTR_MAX + 1];
1486 struct vxlan_dev *vxlan = netdev_priv(dev);
1487 int err;
1488
1489 memset(group, 0, sizeof(*group));
1490 group->vni = vxlan->default_dst.remote_vni;
1491
1492 if (!tb[MDBA_GET_ENTRY_ATTRS]) {
1493 vxlan_mdb_group_set(group, entry, NULL);
1494 return 0;
1495 }
1496
1497 err = nla_parse_nested(mdbe_attrs, MDBE_ATTR_MAX,
1498 tb[MDBA_GET_ENTRY_ATTRS],
1499 vxlan_mdbe_attrs_get_pol, extack);
1500 if (err)
1501 return err;
1502
1503 if (mdbe_attrs[MDBE_ATTR_SOURCE] &&
1504 !vxlan_mdb_is_valid_source(mdbe_attrs[MDBE_ATTR_SOURCE],
1505 entry->addr.proto, extack))
1506 return -EINVAL;
1507
1508 vxlan_mdb_group_set(group, entry, mdbe_attrs[MDBE_ATTR_SOURCE]);
1509
1510 if (mdbe_attrs[MDBE_ATTR_SRC_VNI])
1511 group->vni =
1512 cpu_to_be32(nla_get_u32(mdbe_attrs[MDBE_ATTR_SRC_VNI]));
1513
1514 return 0;
1515 }
1516
1517 static struct sk_buff *
vxlan_mdb_get_reply_alloc(const struct vxlan_dev * vxlan,const struct vxlan_mdb_entry * mdb_entry)1518 vxlan_mdb_get_reply_alloc(const struct vxlan_dev *vxlan,
1519 const struct vxlan_mdb_entry *mdb_entry)
1520 {
1521 struct vxlan_mdb_remote *remote;
1522 size_t nlmsg_size;
1523
1524 nlmsg_size = NLMSG_ALIGN(sizeof(struct br_port_msg)) +
1525 /* MDBA_MDB */
1526 nla_total_size(0) +
1527 /* MDBA_MDB_ENTRY */
1528 nla_total_size(0);
1529
1530 list_for_each_entry(remote, &mdb_entry->remotes, list)
1531 nlmsg_size += vxlan_mdb_nlmsg_remote_size(vxlan, mdb_entry,
1532 remote);
1533
1534 return nlmsg_new(nlmsg_size, GFP_KERNEL);
1535 }
1536
1537 static int
vxlan_mdb_get_reply_fill(const struct vxlan_dev * vxlan,struct sk_buff * skb,const struct vxlan_mdb_entry * mdb_entry,u32 portid,u32 seq)1538 vxlan_mdb_get_reply_fill(const struct vxlan_dev *vxlan,
1539 struct sk_buff *skb,
1540 const struct vxlan_mdb_entry *mdb_entry,
1541 u32 portid, u32 seq)
1542 {
1543 struct nlattr *mdb_nest, *mdb_entry_nest;
1544 struct vxlan_mdb_remote *remote;
1545 struct br_port_msg *bpm;
1546 struct nlmsghdr *nlh;
1547 int err;
1548
1549 nlh = nlmsg_put(skb, portid, seq, RTM_NEWMDB, sizeof(*bpm), 0);
1550 if (!nlh)
1551 return -EMSGSIZE;
1552
1553 bpm = nlmsg_data(nlh);
1554 memset(bpm, 0, sizeof(*bpm));
1555 bpm->family = AF_BRIDGE;
1556 bpm->ifindex = vxlan->dev->ifindex;
1557 mdb_nest = nla_nest_start_noflag(skb, MDBA_MDB);
1558 if (!mdb_nest) {
1559 err = -EMSGSIZE;
1560 goto cancel;
1561 }
1562 mdb_entry_nest = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
1563 if (!mdb_entry_nest) {
1564 err = -EMSGSIZE;
1565 goto cancel;
1566 }
1567
1568 list_for_each_entry(remote, &mdb_entry->remotes, list) {
1569 err = vxlan_mdb_entry_info_fill(vxlan, skb, mdb_entry, remote);
1570 if (err)
1571 goto cancel;
1572 }
1573
1574 nla_nest_end(skb, mdb_entry_nest);
1575 nla_nest_end(skb, mdb_nest);
1576 nlmsg_end(skb, nlh);
1577
1578 return 0;
1579
1580 cancel:
1581 nlmsg_cancel(skb, nlh);
1582 return err;
1583 }
1584
vxlan_mdb_get(struct net_device * dev,struct nlattr * tb[],u32 portid,u32 seq,struct netlink_ext_ack * extack)1585 int vxlan_mdb_get(struct net_device *dev, struct nlattr *tb[], u32 portid,
1586 u32 seq, struct netlink_ext_ack *extack)
1587 {
1588 struct vxlan_dev *vxlan = netdev_priv(dev);
1589 struct vxlan_mdb_entry *mdb_entry;
1590 struct vxlan_mdb_entry_key group;
1591 struct sk_buff *skb;
1592 int err;
1593
1594 ASSERT_RTNL();
1595
1596 err = vxlan_mdb_get_parse(dev, tb, &group, extack);
1597 if (err)
1598 return err;
1599
1600 mdb_entry = vxlan_mdb_entry_lookup(vxlan, &group);
1601 if (!mdb_entry) {
1602 NL_SET_ERR_MSG_MOD(extack, "MDB entry not found");
1603 return -ENOENT;
1604 }
1605
1606 skb = vxlan_mdb_get_reply_alloc(vxlan, mdb_entry);
1607 if (!skb)
1608 return -ENOMEM;
1609
1610 err = vxlan_mdb_get_reply_fill(vxlan, skb, mdb_entry, portid, seq);
1611 if (err) {
1612 NL_SET_ERR_MSG_MOD(extack, "Failed to fill MDB get reply");
1613 goto free;
1614 }
1615
1616 return rtnl_unicast(skb, dev_net(dev), portid);
1617
1618 free:
1619 kfree_skb(skb);
1620 return err;
1621 }
1622
vxlan_mdb_entry_skb_get(struct vxlan_dev * vxlan,struct sk_buff * skb,__be32 src_vni)1623 struct vxlan_mdb_entry *vxlan_mdb_entry_skb_get(struct vxlan_dev *vxlan,
1624 struct sk_buff *skb,
1625 __be32 src_vni)
1626 {
1627 struct vxlan_mdb_entry *mdb_entry;
1628 struct vxlan_mdb_entry_key group;
1629
1630 if (!is_multicast_ether_addr(eth_hdr(skb)->h_dest) ||
1631 is_broadcast_ether_addr(eth_hdr(skb)->h_dest))
1632 return NULL;
1633
1634 /* When not in collect metadata mode, 'src_vni' is zero, but MDB
1635 * entries are stored with the VNI of the VXLAN device.
1636 */
1637 if (!(vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA))
1638 src_vni = vxlan->default_dst.remote_vni;
1639
1640 memset(&group, 0, sizeof(group));
1641 group.vni = src_vni;
1642
1643 switch (skb->protocol) {
1644 case htons(ETH_P_IP):
1645 if (!pskb_network_may_pull(skb, sizeof(struct iphdr)))
1646 return NULL;
1647 group.dst.sa.sa_family = AF_INET;
1648 group.dst.sin.sin_addr.s_addr = ip_hdr(skb)->daddr;
1649 group.src.sa.sa_family = AF_INET;
1650 group.src.sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
1651 break;
1652 #if IS_ENABLED(CONFIG_IPV6)
1653 case htons(ETH_P_IPV6):
1654 if (!pskb_network_may_pull(skb, sizeof(struct ipv6hdr)))
1655 return NULL;
1656 group.dst.sa.sa_family = AF_INET6;
1657 group.dst.sin6.sin6_addr = ipv6_hdr(skb)->daddr;
1658 group.src.sa.sa_family = AF_INET6;
1659 group.src.sin6.sin6_addr = ipv6_hdr(skb)->saddr;
1660 break;
1661 #endif
1662 default:
1663 return NULL;
1664 }
1665
1666 mdb_entry = vxlan_mdb_entry_lookup(vxlan, &group);
1667 if (mdb_entry)
1668 return mdb_entry;
1669
1670 memset(&group.src, 0, sizeof(group.src));
1671 mdb_entry = vxlan_mdb_entry_lookup(vxlan, &group);
1672 if (mdb_entry)
1673 return mdb_entry;
1674
1675 /* No (S, G) or (*, G) found. Look up the all-zeros entry, but only if
1676 * the destination IP address is not link-local multicast since we want
1677 * to transmit such traffic together with broadcast and unknown unicast
1678 * traffic.
1679 */
1680 switch (skb->protocol) {
1681 case htons(ETH_P_IP):
1682 if (ipv4_is_local_multicast(group.dst.sin.sin_addr.s_addr))
1683 return NULL;
1684 group.dst.sin.sin_addr.s_addr = 0;
1685 break;
1686 #if IS_ENABLED(CONFIG_IPV6)
1687 case htons(ETH_P_IPV6):
1688 if (ipv6_addr_type(&group.dst.sin6.sin6_addr) &
1689 IPV6_ADDR_LINKLOCAL)
1690 return NULL;
1691 memset(&group.dst.sin6.sin6_addr, 0,
1692 sizeof(group.dst.sin6.sin6_addr));
1693 break;
1694 #endif
1695 default:
1696 return NULL;
1697 }
1698
1699 return vxlan_mdb_entry_lookup(vxlan, &group);
1700 }
1701
vxlan_mdb_xmit(struct vxlan_dev * vxlan,const struct vxlan_mdb_entry * mdb_entry,struct sk_buff * skb)1702 netdev_tx_t vxlan_mdb_xmit(struct vxlan_dev *vxlan,
1703 const struct vxlan_mdb_entry *mdb_entry,
1704 struct sk_buff *skb)
1705 {
1706 struct vxlan_mdb_remote *remote, *fremote = NULL;
1707 __be32 src_vni = mdb_entry->key.vni;
1708
1709 list_for_each_entry_rcu(remote, &mdb_entry->remotes, list) {
1710 struct sk_buff *skb1;
1711
1712 if ((vxlan_mdb_is_star_g(&mdb_entry->key) &&
1713 READ_ONCE(remote->filter_mode) == MCAST_INCLUDE) ||
1714 (READ_ONCE(remote->flags) & VXLAN_MDB_REMOTE_F_BLOCKED))
1715 continue;
1716
1717 if (!fremote) {
1718 fremote = remote;
1719 continue;
1720 }
1721
1722 skb1 = skb_clone(skb, GFP_ATOMIC);
1723 if (skb1)
1724 vxlan_xmit_one(skb1, vxlan->dev, src_vni,
1725 rcu_dereference(remote->rd), false);
1726 }
1727
1728 if (fremote)
1729 vxlan_xmit_one(skb, vxlan->dev, src_vni,
1730 rcu_dereference(fremote->rd), false);
1731 else
1732 kfree_skb_reason(skb, SKB_DROP_REASON_NO_TX_TARGET);
1733
1734 return NETDEV_TX_OK;
1735 }
1736
vxlan_mdb_check_empty(void * ptr,void * arg)1737 static void vxlan_mdb_check_empty(void *ptr, void *arg)
1738 {
1739 WARN_ON_ONCE(1);
1740 }
1741
vxlan_mdb_init(struct vxlan_dev * vxlan)1742 int vxlan_mdb_init(struct vxlan_dev *vxlan)
1743 {
1744 int err;
1745
1746 err = rhashtable_init(&vxlan->mdb_tbl, &vxlan_mdb_rht_params);
1747 if (err)
1748 return err;
1749
1750 INIT_HLIST_HEAD(&vxlan->mdb_list);
1751
1752 return 0;
1753 }
1754
vxlan_mdb_fini(struct vxlan_dev * vxlan)1755 void vxlan_mdb_fini(struct vxlan_dev *vxlan)
1756 {
1757 struct vxlan_mdb_flush_desc desc = {};
1758
1759 vxlan_mdb_flush(vxlan, &desc);
1760 WARN_ON_ONCE(vxlan->cfg.flags & VXLAN_F_MDB);
1761 rhashtable_free_and_destroy(&vxlan->mdb_tbl, vxlan_mdb_check_empty,
1762 NULL);
1763 }
1764