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