1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/err.h> 3 #include <linux/igmp.h> 4 #include <linux/kernel.h> 5 #include <linux/netdevice.h> 6 #include <linux/rculist.h> 7 #include <linux/skbuff.h> 8 #include <linux/if_ether.h> 9 #include <net/ip.h> 10 #include <net/netlink.h> 11 #include <net/switchdev.h> 12 #if IS_ENABLED(CONFIG_IPV6) 13 #include <net/ipv6.h> 14 #include <net/addrconf.h> 15 #endif 16 17 #include "br_private.h" 18 19 static int br_rports_fill_info(struct sk_buff *skb, struct netlink_callback *cb, 20 struct net_device *dev) 21 { 22 struct net_bridge *br = netdev_priv(dev); 23 struct net_bridge_port *p; 24 struct nlattr *nest, *port_nest; 25 26 if (!br->multicast_router || hlist_empty(&br->router_list)) 27 return 0; 28 29 nest = nla_nest_start_noflag(skb, MDBA_ROUTER); 30 if (nest == NULL) 31 return -EMSGSIZE; 32 33 hlist_for_each_entry_rcu(p, &br->router_list, rlist) { 34 if (!p) 35 continue; 36 port_nest = nla_nest_start_noflag(skb, MDBA_ROUTER_PORT); 37 if (!port_nest) 38 goto fail; 39 if (nla_put_nohdr(skb, sizeof(u32), &p->dev->ifindex) || 40 nla_put_u32(skb, MDBA_ROUTER_PATTR_TIMER, 41 br_timer_value(&p->multicast_router_timer)) || 42 nla_put_u8(skb, MDBA_ROUTER_PATTR_TYPE, 43 p->multicast_router)) { 44 nla_nest_cancel(skb, port_nest); 45 goto fail; 46 } 47 nla_nest_end(skb, port_nest); 48 } 49 50 nla_nest_end(skb, nest); 51 return 0; 52 fail: 53 nla_nest_cancel(skb, nest); 54 return -EMSGSIZE; 55 } 56 57 static void __mdb_entry_fill_flags(struct br_mdb_entry *e, unsigned char flags) 58 { 59 e->state = flags & MDB_PG_FLAGS_PERMANENT; 60 e->flags = 0; 61 if (flags & MDB_PG_FLAGS_OFFLOAD) 62 e->flags |= MDB_FLAGS_OFFLOAD; 63 if (flags & MDB_PG_FLAGS_FAST_LEAVE) 64 e->flags |= MDB_FLAGS_FAST_LEAVE; 65 } 66 67 static void __mdb_entry_to_br_ip(struct br_mdb_entry *entry, struct br_ip *ip) 68 { 69 memset(ip, 0, sizeof(struct br_ip)); 70 ip->vid = entry->vid; 71 ip->proto = entry->addr.proto; 72 if (ip->proto == htons(ETH_P_IP)) 73 ip->u.ip4 = entry->addr.u.ip4; 74 #if IS_ENABLED(CONFIG_IPV6) 75 else 76 ip->u.ip6 = entry->addr.u.ip6; 77 #endif 78 } 79 80 static int __mdb_fill_srcs(struct sk_buff *skb, 81 struct net_bridge_port_group *p) 82 { 83 struct net_bridge_group_src *ent; 84 struct nlattr *nest, *nest_ent; 85 86 if (hlist_empty(&p->src_list)) 87 return 0; 88 89 nest = nla_nest_start(skb, MDBA_MDB_EATTR_SRC_LIST); 90 if (!nest) 91 return -EMSGSIZE; 92 93 hlist_for_each_entry_rcu(ent, &p->src_list, node, 94 lockdep_is_held(&p->port->br->multicast_lock)) { 95 nest_ent = nla_nest_start(skb, MDBA_MDB_SRCLIST_ENTRY); 96 if (!nest_ent) 97 goto out_cancel_err; 98 switch (ent->addr.proto) { 99 case htons(ETH_P_IP): 100 if (nla_put_in_addr(skb, MDBA_MDB_SRCATTR_ADDRESS, 101 ent->addr.u.ip4)) { 102 nla_nest_cancel(skb, nest_ent); 103 goto out_cancel_err; 104 } 105 break; 106 #if IS_ENABLED(CONFIG_IPV6) 107 case htons(ETH_P_IPV6): 108 if (nla_put_in6_addr(skb, MDBA_MDB_SRCATTR_ADDRESS, 109 &ent->addr.u.ip6)) { 110 nla_nest_cancel(skb, nest_ent); 111 goto out_cancel_err; 112 } 113 break; 114 #endif 115 default: 116 nla_nest_cancel(skb, nest_ent); 117 continue; 118 } 119 if (nla_put_u32(skb, MDBA_MDB_SRCATTR_TIMER, 120 br_timer_value(&ent->timer))) { 121 nla_nest_cancel(skb, nest_ent); 122 goto out_cancel_err; 123 } 124 nla_nest_end(skb, nest_ent); 125 } 126 127 nla_nest_end(skb, nest); 128 129 return 0; 130 131 out_cancel_err: 132 nla_nest_cancel(skb, nest); 133 return -EMSGSIZE; 134 } 135 136 static int __mdb_fill_info(struct sk_buff *skb, 137 struct net_bridge_mdb_entry *mp, 138 struct net_bridge_port_group *p) 139 { 140 bool dump_srcs_mode = false; 141 struct timer_list *mtimer; 142 struct nlattr *nest_ent; 143 struct br_mdb_entry e; 144 u8 flags = 0; 145 int ifindex; 146 147 memset(&e, 0, sizeof(e)); 148 if (p) { 149 ifindex = p->port->dev->ifindex; 150 mtimer = &p->timer; 151 flags = p->flags; 152 } else { 153 ifindex = mp->br->dev->ifindex; 154 mtimer = &mp->timer; 155 } 156 157 __mdb_entry_fill_flags(&e, flags); 158 e.ifindex = ifindex; 159 e.vid = mp->addr.vid; 160 if (mp->addr.proto == htons(ETH_P_IP)) 161 e.addr.u.ip4 = mp->addr.u.ip4; 162 #if IS_ENABLED(CONFIG_IPV6) 163 if (mp->addr.proto == htons(ETH_P_IPV6)) 164 e.addr.u.ip6 = mp->addr.u.ip6; 165 #endif 166 e.addr.proto = mp->addr.proto; 167 nest_ent = nla_nest_start_noflag(skb, 168 MDBA_MDB_ENTRY_INFO); 169 if (!nest_ent) 170 return -EMSGSIZE; 171 172 if (nla_put_nohdr(skb, sizeof(e), &e) || 173 nla_put_u32(skb, 174 MDBA_MDB_EATTR_TIMER, 175 br_timer_value(mtimer))) { 176 nla_nest_cancel(skb, nest_ent); 177 return -EMSGSIZE; 178 } 179 switch (mp->addr.proto) { 180 case htons(ETH_P_IP): 181 dump_srcs_mode = !!(p && mp->br->multicast_igmp_version == 3); 182 break; 183 #if IS_ENABLED(CONFIG_IPV6) 184 case htons(ETH_P_IPV6): 185 dump_srcs_mode = !!(p && mp->br->multicast_mld_version == 2); 186 break; 187 #endif 188 } 189 if (dump_srcs_mode && 190 (__mdb_fill_srcs(skb, p) || 191 nla_put_u8(skb, MDBA_MDB_EATTR_GROUP_MODE, p->filter_mode))) { 192 nla_nest_cancel(skb, nest_ent); 193 return -EMSGSIZE; 194 } 195 196 nla_nest_end(skb, nest_ent); 197 198 return 0; 199 } 200 201 static int br_mdb_fill_info(struct sk_buff *skb, struct netlink_callback *cb, 202 struct net_device *dev) 203 { 204 int idx = 0, s_idx = cb->args[1], err = 0, pidx = 0, s_pidx = cb->args[2]; 205 struct net_bridge *br = netdev_priv(dev); 206 struct net_bridge_mdb_entry *mp; 207 struct nlattr *nest, *nest2; 208 209 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) 210 return 0; 211 212 nest = nla_nest_start_noflag(skb, MDBA_MDB); 213 if (nest == NULL) 214 return -EMSGSIZE; 215 216 hlist_for_each_entry_rcu(mp, &br->mdb_list, mdb_node) { 217 struct net_bridge_port_group *p; 218 struct net_bridge_port_group __rcu **pp; 219 220 if (idx < s_idx) 221 goto skip; 222 223 nest2 = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY); 224 if (!nest2) { 225 err = -EMSGSIZE; 226 break; 227 } 228 229 if (!s_pidx && mp->host_joined) { 230 err = __mdb_fill_info(skb, mp, NULL); 231 if (err) { 232 nla_nest_cancel(skb, nest2); 233 break; 234 } 235 } 236 237 for (pp = &mp->ports; (p = rcu_dereference(*pp)) != NULL; 238 pp = &p->next) { 239 if (!p->port) 240 continue; 241 if (pidx < s_pidx) 242 goto skip_pg; 243 244 err = __mdb_fill_info(skb, mp, p); 245 if (err) { 246 nla_nest_cancel(skb, nest2); 247 goto out; 248 } 249 skip_pg: 250 pidx++; 251 } 252 pidx = 0; 253 s_pidx = 0; 254 nla_nest_end(skb, nest2); 255 skip: 256 idx++; 257 } 258 259 out: 260 cb->args[1] = idx; 261 cb->args[2] = pidx; 262 nla_nest_end(skb, nest); 263 return err; 264 } 265 266 static int br_mdb_valid_dump_req(const struct nlmsghdr *nlh, 267 struct netlink_ext_ack *extack) 268 { 269 struct br_port_msg *bpm; 270 271 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*bpm))) { 272 NL_SET_ERR_MSG_MOD(extack, "Invalid header for mdb dump request"); 273 return -EINVAL; 274 } 275 276 bpm = nlmsg_data(nlh); 277 if (bpm->ifindex) { 278 NL_SET_ERR_MSG_MOD(extack, "Filtering by device index is not supported for mdb dump request"); 279 return -EINVAL; 280 } 281 if (nlmsg_attrlen(nlh, sizeof(*bpm))) { 282 NL_SET_ERR_MSG(extack, "Invalid data after header in mdb dump request"); 283 return -EINVAL; 284 } 285 286 return 0; 287 } 288 289 static int br_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb) 290 { 291 struct net_device *dev; 292 struct net *net = sock_net(skb->sk); 293 struct nlmsghdr *nlh = NULL; 294 int idx = 0, s_idx; 295 296 if (cb->strict_check) { 297 int err = br_mdb_valid_dump_req(cb->nlh, cb->extack); 298 299 if (err < 0) 300 return err; 301 } 302 303 s_idx = cb->args[0]; 304 305 rcu_read_lock(); 306 307 cb->seq = net->dev_base_seq; 308 309 for_each_netdev_rcu(net, dev) { 310 if (dev->priv_flags & IFF_EBRIDGE) { 311 struct br_port_msg *bpm; 312 313 if (idx < s_idx) 314 goto skip; 315 316 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, 317 cb->nlh->nlmsg_seq, RTM_GETMDB, 318 sizeof(*bpm), NLM_F_MULTI); 319 if (nlh == NULL) 320 break; 321 322 bpm = nlmsg_data(nlh); 323 memset(bpm, 0, sizeof(*bpm)); 324 bpm->ifindex = dev->ifindex; 325 if (br_mdb_fill_info(skb, cb, dev) < 0) 326 goto out; 327 if (br_rports_fill_info(skb, cb, dev) < 0) 328 goto out; 329 330 cb->args[1] = 0; 331 nlmsg_end(skb, nlh); 332 skip: 333 idx++; 334 } 335 } 336 337 out: 338 if (nlh) 339 nlmsg_end(skb, nlh); 340 rcu_read_unlock(); 341 cb->args[0] = idx; 342 return skb->len; 343 } 344 345 static int nlmsg_populate_mdb_fill(struct sk_buff *skb, 346 struct net_device *dev, 347 struct net_bridge_mdb_entry *mp, 348 struct net_bridge_port_group *pg, 349 int type) 350 { 351 struct nlmsghdr *nlh; 352 struct br_port_msg *bpm; 353 struct nlattr *nest, *nest2; 354 355 nlh = nlmsg_put(skb, 0, 0, type, sizeof(*bpm), 0); 356 if (!nlh) 357 return -EMSGSIZE; 358 359 bpm = nlmsg_data(nlh); 360 memset(bpm, 0, sizeof(*bpm)); 361 bpm->family = AF_BRIDGE; 362 bpm->ifindex = dev->ifindex; 363 nest = nla_nest_start_noflag(skb, MDBA_MDB); 364 if (nest == NULL) 365 goto cancel; 366 nest2 = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY); 367 if (nest2 == NULL) 368 goto end; 369 370 if (__mdb_fill_info(skb, mp, pg)) 371 goto end; 372 373 nla_nest_end(skb, nest2); 374 nla_nest_end(skb, nest); 375 nlmsg_end(skb, nlh); 376 return 0; 377 378 end: 379 nla_nest_end(skb, nest); 380 cancel: 381 nlmsg_cancel(skb, nlh); 382 return -EMSGSIZE; 383 } 384 385 static size_t rtnl_mdb_nlmsg_size(struct net_bridge_port_group *pg) 386 { 387 size_t nlmsg_size = NLMSG_ALIGN(sizeof(struct br_port_msg)) + 388 nla_total_size(sizeof(struct br_mdb_entry)) + 389 nla_total_size(sizeof(u32)); 390 struct net_bridge_group_src *ent; 391 size_t addr_size = 0; 392 393 if (!pg) 394 goto out; 395 396 switch (pg->addr.proto) { 397 case htons(ETH_P_IP): 398 if (pg->port->br->multicast_igmp_version == 2) 399 goto out; 400 addr_size = sizeof(__be32); 401 break; 402 #if IS_ENABLED(CONFIG_IPV6) 403 case htons(ETH_P_IPV6): 404 if (pg->port->br->multicast_mld_version == 1) 405 goto out; 406 addr_size = sizeof(struct in6_addr); 407 break; 408 #endif 409 } 410 411 /* MDBA_MDB_EATTR_GROUP_MODE */ 412 nlmsg_size += nla_total_size(sizeof(u8)); 413 414 /* MDBA_MDB_EATTR_SRC_LIST nested attr */ 415 if (!hlist_empty(&pg->src_list)) 416 nlmsg_size += nla_total_size(0); 417 418 hlist_for_each_entry(ent, &pg->src_list, node) { 419 /* MDBA_MDB_SRCLIST_ENTRY nested attr + 420 * MDBA_MDB_SRCATTR_ADDRESS + MDBA_MDB_SRCATTR_TIMER 421 */ 422 nlmsg_size += nla_total_size(0) + 423 nla_total_size(addr_size) + 424 nla_total_size(sizeof(u32)); 425 } 426 out: 427 return nlmsg_size; 428 } 429 430 struct br_mdb_complete_info { 431 struct net_bridge_port *port; 432 struct br_ip ip; 433 }; 434 435 static void br_mdb_complete(struct net_device *dev, int err, void *priv) 436 { 437 struct br_mdb_complete_info *data = priv; 438 struct net_bridge_port_group __rcu **pp; 439 struct net_bridge_port_group *p; 440 struct net_bridge_mdb_entry *mp; 441 struct net_bridge_port *port = data->port; 442 struct net_bridge *br = port->br; 443 444 if (err) 445 goto err; 446 447 spin_lock_bh(&br->multicast_lock); 448 mp = br_mdb_ip_get(br, &data->ip); 449 if (!mp) 450 goto out; 451 for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL; 452 pp = &p->next) { 453 if (p->port != port) 454 continue; 455 p->flags |= MDB_PG_FLAGS_OFFLOAD; 456 } 457 out: 458 spin_unlock_bh(&br->multicast_lock); 459 err: 460 kfree(priv); 461 } 462 463 static void br_mdb_switchdev_host_port(struct net_device *dev, 464 struct net_device *lower_dev, 465 struct net_bridge_mdb_entry *mp, 466 int type) 467 { 468 struct switchdev_obj_port_mdb mdb = { 469 .obj = { 470 .id = SWITCHDEV_OBJ_ID_HOST_MDB, 471 .flags = SWITCHDEV_F_DEFER, 472 }, 473 .vid = mp->addr.vid, 474 }; 475 476 if (mp->addr.proto == htons(ETH_P_IP)) 477 ip_eth_mc_map(mp->addr.u.ip4, mdb.addr); 478 #if IS_ENABLED(CONFIG_IPV6) 479 else 480 ipv6_eth_mc_map(&mp->addr.u.ip6, mdb.addr); 481 #endif 482 483 mdb.obj.orig_dev = dev; 484 switch (type) { 485 case RTM_NEWMDB: 486 switchdev_port_obj_add(lower_dev, &mdb.obj, NULL); 487 break; 488 case RTM_DELMDB: 489 switchdev_port_obj_del(lower_dev, &mdb.obj); 490 break; 491 } 492 } 493 494 static void br_mdb_switchdev_host(struct net_device *dev, 495 struct net_bridge_mdb_entry *mp, int type) 496 { 497 struct net_device *lower_dev; 498 struct list_head *iter; 499 500 netdev_for_each_lower_dev(dev, lower_dev, iter) 501 br_mdb_switchdev_host_port(dev, lower_dev, mp, type); 502 } 503 504 void br_mdb_notify(struct net_device *dev, 505 struct net_bridge_mdb_entry *mp, 506 struct net_bridge_port_group *pg, 507 int type) 508 { 509 struct br_mdb_complete_info *complete_info; 510 struct switchdev_obj_port_mdb mdb = { 511 .obj = { 512 .id = SWITCHDEV_OBJ_ID_PORT_MDB, 513 .flags = SWITCHDEV_F_DEFER, 514 }, 515 .vid = mp->addr.vid, 516 }; 517 struct net *net = dev_net(dev); 518 struct sk_buff *skb; 519 int err = -ENOBUFS; 520 521 if (pg) { 522 if (mp->addr.proto == htons(ETH_P_IP)) 523 ip_eth_mc_map(mp->addr.u.ip4, mdb.addr); 524 #if IS_ENABLED(CONFIG_IPV6) 525 else 526 ipv6_eth_mc_map(&mp->addr.u.ip6, mdb.addr); 527 #endif 528 mdb.obj.orig_dev = pg->port->dev; 529 switch (type) { 530 case RTM_NEWMDB: 531 complete_info = kmalloc(sizeof(*complete_info), GFP_ATOMIC); 532 if (!complete_info) 533 break; 534 complete_info->port = pg->port; 535 complete_info->ip = mp->addr; 536 mdb.obj.complete_priv = complete_info; 537 mdb.obj.complete = br_mdb_complete; 538 if (switchdev_port_obj_add(pg->port->dev, &mdb.obj, NULL)) 539 kfree(complete_info); 540 break; 541 case RTM_DELMDB: 542 switchdev_port_obj_del(pg->port->dev, &mdb.obj); 543 break; 544 } 545 } else { 546 br_mdb_switchdev_host(dev, mp, type); 547 } 548 549 skb = nlmsg_new(rtnl_mdb_nlmsg_size(pg), GFP_ATOMIC); 550 if (!skb) 551 goto errout; 552 553 err = nlmsg_populate_mdb_fill(skb, dev, mp, pg, type); 554 if (err < 0) { 555 kfree_skb(skb); 556 goto errout; 557 } 558 559 rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC); 560 return; 561 errout: 562 rtnl_set_sk_err(net, RTNLGRP_MDB, err); 563 } 564 565 static int nlmsg_populate_rtr_fill(struct sk_buff *skb, 566 struct net_device *dev, 567 int ifindex, u32 pid, 568 u32 seq, int type, unsigned int flags) 569 { 570 struct br_port_msg *bpm; 571 struct nlmsghdr *nlh; 572 struct nlattr *nest; 573 574 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), 0); 575 if (!nlh) 576 return -EMSGSIZE; 577 578 bpm = nlmsg_data(nlh); 579 memset(bpm, 0, sizeof(*bpm)); 580 bpm->family = AF_BRIDGE; 581 bpm->ifindex = dev->ifindex; 582 nest = nla_nest_start_noflag(skb, MDBA_ROUTER); 583 if (!nest) 584 goto cancel; 585 586 if (nla_put_u32(skb, MDBA_ROUTER_PORT, ifindex)) 587 goto end; 588 589 nla_nest_end(skb, nest); 590 nlmsg_end(skb, nlh); 591 return 0; 592 593 end: 594 nla_nest_end(skb, nest); 595 cancel: 596 nlmsg_cancel(skb, nlh); 597 return -EMSGSIZE; 598 } 599 600 static inline size_t rtnl_rtr_nlmsg_size(void) 601 { 602 return NLMSG_ALIGN(sizeof(struct br_port_msg)) 603 + nla_total_size(sizeof(__u32)); 604 } 605 606 void br_rtr_notify(struct net_device *dev, struct net_bridge_port *port, 607 int type) 608 { 609 struct net *net = dev_net(dev); 610 struct sk_buff *skb; 611 int err = -ENOBUFS; 612 int ifindex; 613 614 ifindex = port ? port->dev->ifindex : 0; 615 skb = nlmsg_new(rtnl_rtr_nlmsg_size(), GFP_ATOMIC); 616 if (!skb) 617 goto errout; 618 619 err = nlmsg_populate_rtr_fill(skb, dev, ifindex, 0, 0, type, NTF_SELF); 620 if (err < 0) { 621 kfree_skb(skb); 622 goto errout; 623 } 624 625 rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC); 626 return; 627 628 errout: 629 rtnl_set_sk_err(net, RTNLGRP_MDB, err); 630 } 631 632 static bool is_valid_mdb_entry(struct br_mdb_entry *entry) 633 { 634 if (entry->ifindex == 0) 635 return false; 636 637 if (entry->addr.proto == htons(ETH_P_IP)) { 638 if (!ipv4_is_multicast(entry->addr.u.ip4)) 639 return false; 640 if (ipv4_is_local_multicast(entry->addr.u.ip4)) 641 return false; 642 #if IS_ENABLED(CONFIG_IPV6) 643 } else if (entry->addr.proto == htons(ETH_P_IPV6)) { 644 if (ipv6_addr_is_ll_all_nodes(&entry->addr.u.ip6)) 645 return false; 646 #endif 647 } else 648 return false; 649 if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY) 650 return false; 651 if (entry->vid >= VLAN_VID_MASK) 652 return false; 653 654 return true; 655 } 656 657 static int br_mdb_parse(struct sk_buff *skb, struct nlmsghdr *nlh, 658 struct net_device **pdev, struct br_mdb_entry **pentry) 659 { 660 struct net *net = sock_net(skb->sk); 661 struct br_mdb_entry *entry; 662 struct br_port_msg *bpm; 663 struct nlattr *tb[MDBA_SET_ENTRY_MAX+1]; 664 struct net_device *dev; 665 int err; 666 667 err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb, 668 MDBA_SET_ENTRY_MAX, NULL, NULL); 669 if (err < 0) 670 return err; 671 672 bpm = nlmsg_data(nlh); 673 if (bpm->ifindex == 0) { 674 pr_info("PF_BRIDGE: br_mdb_parse() with invalid ifindex\n"); 675 return -EINVAL; 676 } 677 678 dev = __dev_get_by_index(net, bpm->ifindex); 679 if (dev == NULL) { 680 pr_info("PF_BRIDGE: br_mdb_parse() with unknown ifindex\n"); 681 return -ENODEV; 682 } 683 684 if (!(dev->priv_flags & IFF_EBRIDGE)) { 685 pr_info("PF_BRIDGE: br_mdb_parse() with non-bridge\n"); 686 return -EOPNOTSUPP; 687 } 688 689 *pdev = dev; 690 691 if (!tb[MDBA_SET_ENTRY] || 692 nla_len(tb[MDBA_SET_ENTRY]) != sizeof(struct br_mdb_entry)) { 693 pr_info("PF_BRIDGE: br_mdb_parse() with invalid attr\n"); 694 return -EINVAL; 695 } 696 697 entry = nla_data(tb[MDBA_SET_ENTRY]); 698 if (!is_valid_mdb_entry(entry)) { 699 pr_info("PF_BRIDGE: br_mdb_parse() with invalid entry\n"); 700 return -EINVAL; 701 } 702 703 *pentry = entry; 704 return 0; 705 } 706 707 static int br_mdb_add_group(struct net_bridge *br, struct net_bridge_port *port, 708 struct br_ip *group, struct br_mdb_entry *entry) 709 { 710 struct net_bridge_mdb_entry *mp; 711 struct net_bridge_port_group *p; 712 struct net_bridge_port_group __rcu **pp; 713 unsigned long now = jiffies; 714 int err; 715 716 mp = br_mdb_ip_get(br, group); 717 if (!mp) { 718 mp = br_multicast_new_group(br, group); 719 err = PTR_ERR_OR_ZERO(mp); 720 if (err) 721 return err; 722 } 723 724 /* host join */ 725 if (!port) { 726 /* don't allow any flags for host-joined groups */ 727 if (entry->state) 728 return -EINVAL; 729 if (mp->host_joined) 730 return -EEXIST; 731 732 br_multicast_host_join(mp, false); 733 br_mdb_notify(br->dev, mp, NULL, RTM_NEWMDB); 734 735 return 0; 736 } 737 738 for (pp = &mp->ports; 739 (p = mlock_dereference(*pp, br)) != NULL; 740 pp = &p->next) { 741 if (p->port == port) 742 return -EEXIST; 743 if ((unsigned long)p->port < (unsigned long)port) 744 break; 745 } 746 747 p = br_multicast_new_port_group(port, group, *pp, entry->state, NULL, 748 MCAST_EXCLUDE); 749 if (unlikely(!p)) 750 return -ENOMEM; 751 rcu_assign_pointer(*pp, p); 752 if (entry->state == MDB_TEMPORARY) 753 mod_timer(&p->timer, now + br->multicast_membership_interval); 754 br_mdb_notify(br->dev, mp, p, RTM_NEWMDB); 755 756 return 0; 757 } 758 759 static int __br_mdb_add(struct net *net, struct net_bridge *br, 760 struct br_mdb_entry *entry) 761 { 762 struct br_ip ip; 763 struct net_device *dev; 764 struct net_bridge_port *p = NULL; 765 int ret; 766 767 if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED)) 768 return -EINVAL; 769 770 if (entry->ifindex != br->dev->ifindex) { 771 dev = __dev_get_by_index(net, entry->ifindex); 772 if (!dev) 773 return -ENODEV; 774 775 p = br_port_get_rtnl(dev); 776 if (!p || p->br != br || p->state == BR_STATE_DISABLED) 777 return -EINVAL; 778 } 779 780 __mdb_entry_to_br_ip(entry, &ip); 781 782 spin_lock_bh(&br->multicast_lock); 783 ret = br_mdb_add_group(br, p, &ip, entry); 784 spin_unlock_bh(&br->multicast_lock); 785 return ret; 786 } 787 788 static int br_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, 789 struct netlink_ext_ack *extack) 790 { 791 struct net *net = sock_net(skb->sk); 792 struct net_bridge_vlan_group *vg; 793 struct net_bridge_port *p = NULL; 794 struct net_device *dev, *pdev; 795 struct br_mdb_entry *entry; 796 struct net_bridge_vlan *v; 797 struct net_bridge *br; 798 int err; 799 800 err = br_mdb_parse(skb, nlh, &dev, &entry); 801 if (err < 0) 802 return err; 803 804 br = netdev_priv(dev); 805 806 if (entry->ifindex != br->dev->ifindex) { 807 pdev = __dev_get_by_index(net, entry->ifindex); 808 if (!pdev) 809 return -ENODEV; 810 811 p = br_port_get_rtnl(pdev); 812 if (!p || p->br != br || p->state == BR_STATE_DISABLED) 813 return -EINVAL; 814 vg = nbp_vlan_group(p); 815 } else { 816 vg = br_vlan_group(br); 817 } 818 819 /* If vlan filtering is enabled and VLAN is not specified 820 * install mdb entry on all vlans configured on the port. 821 */ 822 if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) { 823 list_for_each_entry(v, &vg->vlan_list, vlist) { 824 entry->vid = v->vid; 825 err = __br_mdb_add(net, br, entry); 826 if (err) 827 break; 828 } 829 } else { 830 err = __br_mdb_add(net, br, entry); 831 } 832 833 return err; 834 } 835 836 static int __br_mdb_del(struct net_bridge *br, struct br_mdb_entry *entry) 837 { 838 struct net_bridge_mdb_entry *mp; 839 struct net_bridge_port_group *p; 840 struct net_bridge_port_group __rcu **pp; 841 struct br_ip ip; 842 int err = -EINVAL; 843 844 if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED)) 845 return -EINVAL; 846 847 __mdb_entry_to_br_ip(entry, &ip); 848 849 spin_lock_bh(&br->multicast_lock); 850 mp = br_mdb_ip_get(br, &ip); 851 if (!mp) 852 goto unlock; 853 854 /* host leave */ 855 if (entry->ifindex == mp->br->dev->ifindex && mp->host_joined) { 856 br_multicast_host_leave(mp, false); 857 err = 0; 858 br_mdb_notify(br->dev, mp, NULL, RTM_DELMDB); 859 if (!mp->ports && netif_running(br->dev)) 860 mod_timer(&mp->timer, jiffies); 861 goto unlock; 862 } 863 864 for (pp = &mp->ports; 865 (p = mlock_dereference(*pp, br)) != NULL; 866 pp = &p->next) { 867 if (!p->port || p->port->dev->ifindex != entry->ifindex) 868 continue; 869 870 if (p->port->state == BR_STATE_DISABLED) 871 goto unlock; 872 873 br_multicast_del_pg(mp, p, pp); 874 err = 0; 875 break; 876 } 877 878 unlock: 879 spin_unlock_bh(&br->multicast_lock); 880 return err; 881 } 882 883 static int br_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, 884 struct netlink_ext_ack *extack) 885 { 886 struct net *net = sock_net(skb->sk); 887 struct net_bridge_vlan_group *vg; 888 struct net_bridge_port *p = NULL; 889 struct net_device *dev, *pdev; 890 struct br_mdb_entry *entry; 891 struct net_bridge_vlan *v; 892 struct net_bridge *br; 893 int err; 894 895 err = br_mdb_parse(skb, nlh, &dev, &entry); 896 if (err < 0) 897 return err; 898 899 br = netdev_priv(dev); 900 901 if (entry->ifindex != br->dev->ifindex) { 902 pdev = __dev_get_by_index(net, entry->ifindex); 903 if (!pdev) 904 return -ENODEV; 905 906 p = br_port_get_rtnl(pdev); 907 if (!p || p->br != br || p->state == BR_STATE_DISABLED) 908 return -EINVAL; 909 vg = nbp_vlan_group(p); 910 } else { 911 vg = br_vlan_group(br); 912 } 913 914 /* If vlan filtering is enabled and VLAN is not specified 915 * delete mdb entry on all vlans configured on the port. 916 */ 917 if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) { 918 list_for_each_entry(v, &vg->vlan_list, vlist) { 919 entry->vid = v->vid; 920 err = __br_mdb_del(br, entry); 921 } 922 } else { 923 err = __br_mdb_del(br, entry); 924 } 925 926 return err; 927 } 928 929 void br_mdb_init(void) 930 { 931 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_GETMDB, NULL, br_mdb_dump, 0); 932 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_NEWMDB, br_mdb_add, NULL, 0); 933 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_DELMDB, br_mdb_del, NULL, 0); 934 } 935 936 void br_mdb_uninit(void) 937 { 938 rtnl_unregister(PF_BRIDGE, RTM_GETMDB); 939 rtnl_unregister(PF_BRIDGE, RTM_NEWMDB); 940 rtnl_unregister(PF_BRIDGE, RTM_DELMDB); 941 } 942