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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 * 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 * 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 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 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 722 static void vxlan_mdb_remote_rdst_fini(struct vxlan_rdst *rd) 723 { 724 call_rcu(&rd->rcu, vxlan_mdb_rdst_free); 725 } 726 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 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 * 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 * 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 * 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 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 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 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 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 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 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 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 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 /* The removal of an entry cannot trigger the removal of another entry 1432 * since entries are always added to the head of the list. 1433 */ 1434 hlist_for_each_entry_safe(mdb_entry, tmp, &vxlan->mdb_list, mdb_node) { 1435 if (desc->src_vni && desc->src_vni != mdb_entry->key.vni) 1436 continue; 1437 1438 vxlan_mdb_remotes_flush(vxlan, mdb_entry, desc); 1439 /* Entry will only be removed if its remotes list is empty. */ 1440 vxlan_mdb_entry_put(vxlan, mdb_entry); 1441 } 1442 } 1443 1444 int vxlan_mdb_del_bulk(struct net_device *dev, struct nlattr *tb[], 1445 struct netlink_ext_ack *extack) 1446 { 1447 struct vxlan_dev *vxlan = netdev_priv(dev); 1448 struct vxlan_mdb_flush_desc desc = {}; 1449 int err; 1450 1451 ASSERT_RTNL(); 1452 1453 err = vxlan_mdb_flush_desc_init(vxlan, &desc, tb, extack); 1454 if (err) 1455 return err; 1456 1457 vxlan_mdb_flush(vxlan, &desc); 1458 1459 return 0; 1460 } 1461 1462 static const struct nla_policy vxlan_mdbe_attrs_get_pol[MDBE_ATTR_MAX + 1] = { 1463 [MDBE_ATTR_SOURCE] = NLA_POLICY_RANGE(NLA_BINARY, 1464 sizeof(struct in_addr), 1465 sizeof(struct in6_addr)), 1466 [MDBE_ATTR_SRC_VNI] = NLA_POLICY_FULL_RANGE(NLA_U32, &vni_range), 1467 }; 1468 1469 static int vxlan_mdb_get_parse(struct net_device *dev, struct nlattr *tb[], 1470 struct vxlan_mdb_entry_key *group, 1471 struct netlink_ext_ack *extack) 1472 { 1473 struct br_mdb_entry *entry = nla_data(tb[MDBA_GET_ENTRY]); 1474 struct nlattr *mdbe_attrs[MDBE_ATTR_MAX + 1]; 1475 struct vxlan_dev *vxlan = netdev_priv(dev); 1476 int err; 1477 1478 memset(group, 0, sizeof(*group)); 1479 group->vni = vxlan->default_dst.remote_vni; 1480 1481 if (!tb[MDBA_GET_ENTRY_ATTRS]) { 1482 vxlan_mdb_group_set(group, entry, NULL); 1483 return 0; 1484 } 1485 1486 err = nla_parse_nested(mdbe_attrs, MDBE_ATTR_MAX, 1487 tb[MDBA_GET_ENTRY_ATTRS], 1488 vxlan_mdbe_attrs_get_pol, extack); 1489 if (err) 1490 return err; 1491 1492 if (mdbe_attrs[MDBE_ATTR_SOURCE] && 1493 !vxlan_mdb_is_valid_source(mdbe_attrs[MDBE_ATTR_SOURCE], 1494 entry->addr.proto, extack)) 1495 return -EINVAL; 1496 1497 vxlan_mdb_group_set(group, entry, mdbe_attrs[MDBE_ATTR_SOURCE]); 1498 1499 if (mdbe_attrs[MDBE_ATTR_SRC_VNI]) 1500 group->vni = 1501 cpu_to_be32(nla_get_u32(mdbe_attrs[MDBE_ATTR_SRC_VNI])); 1502 1503 return 0; 1504 } 1505 1506 static struct sk_buff * 1507 vxlan_mdb_get_reply_alloc(const struct vxlan_dev *vxlan, 1508 const struct vxlan_mdb_entry *mdb_entry) 1509 { 1510 struct vxlan_mdb_remote *remote; 1511 size_t nlmsg_size; 1512 1513 nlmsg_size = NLMSG_ALIGN(sizeof(struct br_port_msg)) + 1514 /* MDBA_MDB */ 1515 nla_total_size(0) + 1516 /* MDBA_MDB_ENTRY */ 1517 nla_total_size(0); 1518 1519 list_for_each_entry(remote, &mdb_entry->remotes, list) 1520 nlmsg_size += vxlan_mdb_nlmsg_remote_size(vxlan, mdb_entry, 1521 remote); 1522 1523 return nlmsg_new(nlmsg_size, GFP_KERNEL); 1524 } 1525 1526 static int 1527 vxlan_mdb_get_reply_fill(const struct vxlan_dev *vxlan, 1528 struct sk_buff *skb, 1529 const struct vxlan_mdb_entry *mdb_entry, 1530 u32 portid, u32 seq) 1531 { 1532 struct nlattr *mdb_nest, *mdb_entry_nest; 1533 struct vxlan_mdb_remote *remote; 1534 struct br_port_msg *bpm; 1535 struct nlmsghdr *nlh; 1536 int err; 1537 1538 nlh = nlmsg_put(skb, portid, seq, RTM_NEWMDB, sizeof(*bpm), 0); 1539 if (!nlh) 1540 return -EMSGSIZE; 1541 1542 bpm = nlmsg_data(nlh); 1543 memset(bpm, 0, sizeof(*bpm)); 1544 bpm->family = AF_BRIDGE; 1545 bpm->ifindex = vxlan->dev->ifindex; 1546 mdb_nest = nla_nest_start_noflag(skb, MDBA_MDB); 1547 if (!mdb_nest) { 1548 err = -EMSGSIZE; 1549 goto cancel; 1550 } 1551 mdb_entry_nest = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY); 1552 if (!mdb_entry_nest) { 1553 err = -EMSGSIZE; 1554 goto cancel; 1555 } 1556 1557 list_for_each_entry(remote, &mdb_entry->remotes, list) { 1558 err = vxlan_mdb_entry_info_fill(vxlan, skb, mdb_entry, remote); 1559 if (err) 1560 goto cancel; 1561 } 1562 1563 nla_nest_end(skb, mdb_entry_nest); 1564 nla_nest_end(skb, mdb_nest); 1565 nlmsg_end(skb, nlh); 1566 1567 return 0; 1568 1569 cancel: 1570 nlmsg_cancel(skb, nlh); 1571 return err; 1572 } 1573 1574 int vxlan_mdb_get(struct net_device *dev, struct nlattr *tb[], u32 portid, 1575 u32 seq, struct netlink_ext_ack *extack) 1576 { 1577 struct vxlan_dev *vxlan = netdev_priv(dev); 1578 struct vxlan_mdb_entry *mdb_entry; 1579 struct vxlan_mdb_entry_key group; 1580 struct sk_buff *skb; 1581 int err; 1582 1583 ASSERT_RTNL(); 1584 1585 err = vxlan_mdb_get_parse(dev, tb, &group, extack); 1586 if (err) 1587 return err; 1588 1589 mdb_entry = vxlan_mdb_entry_lookup(vxlan, &group); 1590 if (!mdb_entry) { 1591 NL_SET_ERR_MSG_MOD(extack, "MDB entry not found"); 1592 return -ENOENT; 1593 } 1594 1595 skb = vxlan_mdb_get_reply_alloc(vxlan, mdb_entry); 1596 if (!skb) 1597 return -ENOMEM; 1598 1599 err = vxlan_mdb_get_reply_fill(vxlan, skb, mdb_entry, portid, seq); 1600 if (err) { 1601 NL_SET_ERR_MSG_MOD(extack, "Failed to fill MDB get reply"); 1602 goto free; 1603 } 1604 1605 return rtnl_unicast(skb, dev_net(dev), portid); 1606 1607 free: 1608 kfree_skb(skb); 1609 return err; 1610 } 1611 1612 struct vxlan_mdb_entry *vxlan_mdb_entry_skb_get(struct vxlan_dev *vxlan, 1613 struct sk_buff *skb, 1614 __be32 src_vni) 1615 { 1616 struct vxlan_mdb_entry *mdb_entry; 1617 struct vxlan_mdb_entry_key group; 1618 1619 if (!is_multicast_ether_addr(eth_hdr(skb)->h_dest) || 1620 is_broadcast_ether_addr(eth_hdr(skb)->h_dest)) 1621 return NULL; 1622 1623 /* When not in collect metadata mode, 'src_vni' is zero, but MDB 1624 * entries are stored with the VNI of the VXLAN device. 1625 */ 1626 if (!(vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA)) 1627 src_vni = vxlan->default_dst.remote_vni; 1628 1629 memset(&group, 0, sizeof(group)); 1630 group.vni = src_vni; 1631 1632 switch (skb->protocol) { 1633 case htons(ETH_P_IP): 1634 if (!pskb_network_may_pull(skb, sizeof(struct iphdr))) 1635 return NULL; 1636 group.dst.sa.sa_family = AF_INET; 1637 group.dst.sin.sin_addr.s_addr = ip_hdr(skb)->daddr; 1638 group.src.sa.sa_family = AF_INET; 1639 group.src.sin.sin_addr.s_addr = ip_hdr(skb)->saddr; 1640 break; 1641 #if IS_ENABLED(CONFIG_IPV6) 1642 case htons(ETH_P_IPV6): 1643 if (!pskb_network_may_pull(skb, sizeof(struct ipv6hdr))) 1644 return NULL; 1645 group.dst.sa.sa_family = AF_INET6; 1646 group.dst.sin6.sin6_addr = ipv6_hdr(skb)->daddr; 1647 group.src.sa.sa_family = AF_INET6; 1648 group.src.sin6.sin6_addr = ipv6_hdr(skb)->saddr; 1649 break; 1650 #endif 1651 default: 1652 return NULL; 1653 } 1654 1655 mdb_entry = vxlan_mdb_entry_lookup(vxlan, &group); 1656 if (mdb_entry) 1657 return mdb_entry; 1658 1659 memset(&group.src, 0, sizeof(group.src)); 1660 mdb_entry = vxlan_mdb_entry_lookup(vxlan, &group); 1661 if (mdb_entry) 1662 return mdb_entry; 1663 1664 /* No (S, G) or (*, G) found. Look up the all-zeros entry, but only if 1665 * the destination IP address is not link-local multicast since we want 1666 * to transmit such traffic together with broadcast and unknown unicast 1667 * traffic. 1668 */ 1669 switch (skb->protocol) { 1670 case htons(ETH_P_IP): 1671 if (ipv4_is_local_multicast(group.dst.sin.sin_addr.s_addr)) 1672 return NULL; 1673 group.dst.sin.sin_addr.s_addr = 0; 1674 break; 1675 #if IS_ENABLED(CONFIG_IPV6) 1676 case htons(ETH_P_IPV6): 1677 if (ipv6_addr_type(&group.dst.sin6.sin6_addr) & 1678 IPV6_ADDR_LINKLOCAL) 1679 return NULL; 1680 memset(&group.dst.sin6.sin6_addr, 0, 1681 sizeof(group.dst.sin6.sin6_addr)); 1682 break; 1683 #endif 1684 default: 1685 return NULL; 1686 } 1687 1688 return vxlan_mdb_entry_lookup(vxlan, &group); 1689 } 1690 1691 netdev_tx_t vxlan_mdb_xmit(struct vxlan_dev *vxlan, 1692 const struct vxlan_mdb_entry *mdb_entry, 1693 struct sk_buff *skb) 1694 { 1695 struct vxlan_mdb_remote *remote, *fremote = NULL; 1696 __be32 src_vni = mdb_entry->key.vni; 1697 1698 list_for_each_entry_rcu(remote, &mdb_entry->remotes, list) { 1699 struct sk_buff *skb1; 1700 1701 if ((vxlan_mdb_is_star_g(&mdb_entry->key) && 1702 READ_ONCE(remote->filter_mode) == MCAST_INCLUDE) || 1703 (READ_ONCE(remote->flags) & VXLAN_MDB_REMOTE_F_BLOCKED)) 1704 continue; 1705 1706 if (!fremote) { 1707 fremote = remote; 1708 continue; 1709 } 1710 1711 skb1 = skb_clone(skb, GFP_ATOMIC); 1712 if (skb1) 1713 vxlan_xmit_one(skb1, vxlan->dev, src_vni, 1714 rcu_dereference(remote->rd), false); 1715 } 1716 1717 if (fremote) 1718 vxlan_xmit_one(skb, vxlan->dev, src_vni, 1719 rcu_dereference(fremote->rd), false); 1720 else 1721 kfree_skb_reason(skb, SKB_DROP_REASON_NO_TX_TARGET); 1722 1723 return NETDEV_TX_OK; 1724 } 1725 1726 static void vxlan_mdb_check_empty(void *ptr, void *arg) 1727 { 1728 WARN_ON_ONCE(1); 1729 } 1730 1731 int vxlan_mdb_init(struct vxlan_dev *vxlan) 1732 { 1733 int err; 1734 1735 err = rhashtable_init(&vxlan->mdb_tbl, &vxlan_mdb_rht_params); 1736 if (err) 1737 return err; 1738 1739 INIT_HLIST_HEAD(&vxlan->mdb_list); 1740 1741 return 0; 1742 } 1743 1744 void vxlan_mdb_fini(struct vxlan_dev *vxlan) 1745 { 1746 struct vxlan_mdb_flush_desc desc = {}; 1747 1748 vxlan_mdb_flush(vxlan, &desc); 1749 WARN_ON_ONCE(vxlan->cfg.flags & VXLAN_F_MDB); 1750 rhashtable_free_and_destroy(&vxlan->mdb_tbl, vxlan_mdb_check_empty, 1751 NULL); 1752 } 1753