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