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