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