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(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(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 } 64 65 static void __mdb_entry_to_br_ip(struct br_mdb_entry *entry, struct br_ip *ip) 66 { 67 memset(ip, 0, sizeof(struct br_ip)); 68 ip->vid = entry->vid; 69 ip->proto = entry->addr.proto; 70 if (ip->proto == htons(ETH_P_IP)) 71 ip->u.ip4 = entry->addr.u.ip4; 72 #if IS_ENABLED(CONFIG_IPV6) 73 else 74 ip->u.ip6 = entry->addr.u.ip6; 75 #endif 76 } 77 78 static int br_mdb_fill_info(struct sk_buff *skb, struct netlink_callback *cb, 79 struct net_device *dev) 80 { 81 struct net_bridge *br = netdev_priv(dev); 82 struct net_bridge_mdb_htable *mdb; 83 struct nlattr *nest, *nest2; 84 int i, err = 0; 85 int idx = 0, s_idx = cb->args[1]; 86 87 if (br->multicast_disabled) 88 return 0; 89 90 mdb = rcu_dereference(br->mdb); 91 if (!mdb) 92 return 0; 93 94 nest = nla_nest_start(skb, MDBA_MDB); 95 if (nest == NULL) 96 return -EMSGSIZE; 97 98 for (i = 0; i < mdb->max; i++) { 99 struct net_bridge_mdb_entry *mp; 100 struct net_bridge_port_group *p; 101 struct net_bridge_port_group __rcu **pp; 102 struct net_bridge_port *port; 103 104 hlist_for_each_entry_rcu(mp, &mdb->mhash[i], hlist[mdb->ver]) { 105 if (idx < s_idx) 106 goto skip; 107 108 nest2 = nla_nest_start(skb, MDBA_MDB_ENTRY); 109 if (nest2 == NULL) { 110 err = -EMSGSIZE; 111 goto out; 112 } 113 114 for (pp = &mp->ports; 115 (p = rcu_dereference(*pp)) != NULL; 116 pp = &p->next) { 117 struct nlattr *nest_ent; 118 struct br_mdb_entry e; 119 120 port = p->port; 121 if (!port) 122 continue; 123 124 memset(&e, 0, sizeof(e)); 125 e.ifindex = port->dev->ifindex; 126 e.vid = p->addr.vid; 127 __mdb_entry_fill_flags(&e, p->flags); 128 if (p->addr.proto == htons(ETH_P_IP)) 129 e.addr.u.ip4 = p->addr.u.ip4; 130 #if IS_ENABLED(CONFIG_IPV6) 131 if (p->addr.proto == htons(ETH_P_IPV6)) 132 e.addr.u.ip6 = p->addr.u.ip6; 133 #endif 134 e.addr.proto = p->addr.proto; 135 nest_ent = nla_nest_start(skb, 136 MDBA_MDB_ENTRY_INFO); 137 if (!nest_ent) { 138 nla_nest_cancel(skb, nest2); 139 err = -EMSGSIZE; 140 goto out; 141 } 142 if (nla_put_nohdr(skb, sizeof(e), &e) || 143 nla_put_u32(skb, 144 MDBA_MDB_EATTR_TIMER, 145 br_timer_value(&p->timer))) { 146 nla_nest_cancel(skb, nest_ent); 147 nla_nest_cancel(skb, nest2); 148 err = -EMSGSIZE; 149 goto out; 150 } 151 nla_nest_end(skb, nest_ent); 152 } 153 nla_nest_end(skb, nest2); 154 skip: 155 idx++; 156 } 157 } 158 159 out: 160 cb->args[1] = idx; 161 nla_nest_end(skb, nest); 162 return err; 163 } 164 165 static int br_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb) 166 { 167 struct net_device *dev; 168 struct net *net = sock_net(skb->sk); 169 struct nlmsghdr *nlh = NULL; 170 int idx = 0, s_idx; 171 172 s_idx = cb->args[0]; 173 174 rcu_read_lock(); 175 176 /* In theory this could be wrapped to 0... */ 177 cb->seq = net->dev_base_seq + br_mdb_rehash_seq; 178 179 for_each_netdev_rcu(net, dev) { 180 if (dev->priv_flags & IFF_EBRIDGE) { 181 struct br_port_msg *bpm; 182 183 if (idx < s_idx) 184 goto skip; 185 186 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, 187 cb->nlh->nlmsg_seq, RTM_GETMDB, 188 sizeof(*bpm), NLM_F_MULTI); 189 if (nlh == NULL) 190 break; 191 192 bpm = nlmsg_data(nlh); 193 memset(bpm, 0, sizeof(*bpm)); 194 bpm->ifindex = dev->ifindex; 195 if (br_mdb_fill_info(skb, cb, dev) < 0) 196 goto out; 197 if (br_rports_fill_info(skb, cb, dev) < 0) 198 goto out; 199 200 cb->args[1] = 0; 201 nlmsg_end(skb, nlh); 202 skip: 203 idx++; 204 } 205 } 206 207 out: 208 if (nlh) 209 nlmsg_end(skb, nlh); 210 rcu_read_unlock(); 211 cb->args[0] = idx; 212 return skb->len; 213 } 214 215 static int nlmsg_populate_mdb_fill(struct sk_buff *skb, 216 struct net_device *dev, 217 struct br_mdb_entry *entry, u32 pid, 218 u32 seq, int type, unsigned int flags) 219 { 220 struct nlmsghdr *nlh; 221 struct br_port_msg *bpm; 222 struct nlattr *nest, *nest2; 223 224 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), 0); 225 if (!nlh) 226 return -EMSGSIZE; 227 228 bpm = nlmsg_data(nlh); 229 memset(bpm, 0, sizeof(*bpm)); 230 bpm->family = AF_BRIDGE; 231 bpm->ifindex = dev->ifindex; 232 nest = nla_nest_start(skb, MDBA_MDB); 233 if (nest == NULL) 234 goto cancel; 235 nest2 = nla_nest_start(skb, MDBA_MDB_ENTRY); 236 if (nest2 == NULL) 237 goto end; 238 239 if (nla_put(skb, MDBA_MDB_ENTRY_INFO, sizeof(*entry), entry)) 240 goto end; 241 242 nla_nest_end(skb, nest2); 243 nla_nest_end(skb, nest); 244 nlmsg_end(skb, nlh); 245 return 0; 246 247 end: 248 nla_nest_end(skb, nest); 249 cancel: 250 nlmsg_cancel(skb, nlh); 251 return -EMSGSIZE; 252 } 253 254 static inline size_t rtnl_mdb_nlmsg_size(void) 255 { 256 return NLMSG_ALIGN(sizeof(struct br_port_msg)) 257 + nla_total_size(sizeof(struct br_mdb_entry)); 258 } 259 260 struct br_mdb_complete_info { 261 struct net_bridge_port *port; 262 struct br_ip ip; 263 }; 264 265 static void br_mdb_complete(struct net_device *dev, int err, void *priv) 266 { 267 struct br_mdb_complete_info *data = priv; 268 struct net_bridge_port_group __rcu **pp; 269 struct net_bridge_port_group *p; 270 struct net_bridge_mdb_htable *mdb; 271 struct net_bridge_mdb_entry *mp; 272 struct net_bridge_port *port = data->port; 273 struct net_bridge *br = port->br; 274 275 if (err) 276 goto err; 277 278 spin_lock_bh(&br->multicast_lock); 279 mdb = mlock_dereference(br->mdb, br); 280 mp = br_mdb_ip_get(mdb, &data->ip); 281 if (!mp) 282 goto out; 283 for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL; 284 pp = &p->next) { 285 if (p->port != port) 286 continue; 287 p->flags |= MDB_PG_FLAGS_OFFLOAD; 288 } 289 out: 290 spin_unlock_bh(&br->multicast_lock); 291 err: 292 kfree(priv); 293 } 294 295 static void __br_mdb_notify(struct net_device *dev, struct net_bridge_port *p, 296 struct br_mdb_entry *entry, int type) 297 { 298 struct br_mdb_complete_info *complete_info; 299 struct switchdev_obj_port_mdb mdb = { 300 .obj = { 301 .id = SWITCHDEV_OBJ_ID_PORT_MDB, 302 .flags = SWITCHDEV_F_DEFER, 303 }, 304 .vid = entry->vid, 305 }; 306 struct net_device *port_dev; 307 struct net *net = dev_net(dev); 308 struct sk_buff *skb; 309 int err = -ENOBUFS; 310 311 port_dev = __dev_get_by_index(net, entry->ifindex); 312 if (entry->addr.proto == htons(ETH_P_IP)) 313 ip_eth_mc_map(entry->addr.u.ip4, mdb.addr); 314 #if IS_ENABLED(CONFIG_IPV6) 315 else 316 ipv6_eth_mc_map(&entry->addr.u.ip6, mdb.addr); 317 #endif 318 319 mdb.obj.orig_dev = port_dev; 320 if (port_dev && type == RTM_NEWMDB) { 321 complete_info = kmalloc(sizeof(*complete_info), GFP_ATOMIC); 322 if (complete_info) { 323 complete_info->port = p; 324 __mdb_entry_to_br_ip(entry, &complete_info->ip); 325 mdb.obj.complete_priv = complete_info; 326 mdb.obj.complete = br_mdb_complete; 327 if (switchdev_port_obj_add(port_dev, &mdb.obj)) 328 kfree(complete_info); 329 } 330 } else if (port_dev && type == RTM_DELMDB) { 331 switchdev_port_obj_del(port_dev, &mdb.obj); 332 } 333 334 skb = nlmsg_new(rtnl_mdb_nlmsg_size(), GFP_ATOMIC); 335 if (!skb) 336 goto errout; 337 338 err = nlmsg_populate_mdb_fill(skb, dev, entry, 0, 0, type, NTF_SELF); 339 if (err < 0) { 340 kfree_skb(skb); 341 goto errout; 342 } 343 344 rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC); 345 return; 346 errout: 347 rtnl_set_sk_err(net, RTNLGRP_MDB, err); 348 } 349 350 void br_mdb_notify(struct net_device *dev, struct net_bridge_port *port, 351 struct br_ip *group, int type, u8 flags) 352 { 353 struct br_mdb_entry entry; 354 355 memset(&entry, 0, sizeof(entry)); 356 entry.ifindex = port->dev->ifindex; 357 entry.addr.proto = group->proto; 358 entry.addr.u.ip4 = group->u.ip4; 359 #if IS_ENABLED(CONFIG_IPV6) 360 entry.addr.u.ip6 = group->u.ip6; 361 #endif 362 entry.vid = group->vid; 363 __mdb_entry_fill_flags(&entry, flags); 364 __br_mdb_notify(dev, port, &entry, type); 365 } 366 367 static int nlmsg_populate_rtr_fill(struct sk_buff *skb, 368 struct net_device *dev, 369 int ifindex, u32 pid, 370 u32 seq, int type, unsigned int flags) 371 { 372 struct br_port_msg *bpm; 373 struct nlmsghdr *nlh; 374 struct nlattr *nest; 375 376 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), NLM_F_MULTI); 377 if (!nlh) 378 return -EMSGSIZE; 379 380 bpm = nlmsg_data(nlh); 381 memset(bpm, 0, sizeof(*bpm)); 382 bpm->family = AF_BRIDGE; 383 bpm->ifindex = dev->ifindex; 384 nest = nla_nest_start(skb, MDBA_ROUTER); 385 if (!nest) 386 goto cancel; 387 388 if (nla_put_u32(skb, MDBA_ROUTER_PORT, ifindex)) 389 goto end; 390 391 nla_nest_end(skb, nest); 392 nlmsg_end(skb, nlh); 393 return 0; 394 395 end: 396 nla_nest_end(skb, nest); 397 cancel: 398 nlmsg_cancel(skb, nlh); 399 return -EMSGSIZE; 400 } 401 402 static inline size_t rtnl_rtr_nlmsg_size(void) 403 { 404 return NLMSG_ALIGN(sizeof(struct br_port_msg)) 405 + nla_total_size(sizeof(__u32)); 406 } 407 408 void br_rtr_notify(struct net_device *dev, struct net_bridge_port *port, 409 int type) 410 { 411 struct net *net = dev_net(dev); 412 struct sk_buff *skb; 413 int err = -ENOBUFS; 414 int ifindex; 415 416 ifindex = port ? port->dev->ifindex : 0; 417 skb = nlmsg_new(rtnl_rtr_nlmsg_size(), GFP_ATOMIC); 418 if (!skb) 419 goto errout; 420 421 err = nlmsg_populate_rtr_fill(skb, dev, ifindex, 0, 0, type, NTF_SELF); 422 if (err < 0) { 423 kfree_skb(skb); 424 goto errout; 425 } 426 427 rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC); 428 return; 429 430 errout: 431 rtnl_set_sk_err(net, RTNLGRP_MDB, err); 432 } 433 434 static bool is_valid_mdb_entry(struct br_mdb_entry *entry) 435 { 436 if (entry->ifindex == 0) 437 return false; 438 439 if (entry->addr.proto == htons(ETH_P_IP)) { 440 if (!ipv4_is_multicast(entry->addr.u.ip4)) 441 return false; 442 if (ipv4_is_local_multicast(entry->addr.u.ip4)) 443 return false; 444 #if IS_ENABLED(CONFIG_IPV6) 445 } else if (entry->addr.proto == htons(ETH_P_IPV6)) { 446 if (ipv6_addr_is_ll_all_nodes(&entry->addr.u.ip6)) 447 return false; 448 #endif 449 } else 450 return false; 451 if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY) 452 return false; 453 if (entry->vid >= VLAN_VID_MASK) 454 return false; 455 456 return true; 457 } 458 459 static int br_mdb_parse(struct sk_buff *skb, struct nlmsghdr *nlh, 460 struct net_device **pdev, struct br_mdb_entry **pentry) 461 { 462 struct net *net = sock_net(skb->sk); 463 struct br_mdb_entry *entry; 464 struct br_port_msg *bpm; 465 struct nlattr *tb[MDBA_SET_ENTRY_MAX+1]; 466 struct net_device *dev; 467 int err; 468 469 err = nlmsg_parse(nlh, sizeof(*bpm), tb, MDBA_SET_ENTRY_MAX, NULL, 470 NULL); 471 if (err < 0) 472 return err; 473 474 bpm = nlmsg_data(nlh); 475 if (bpm->ifindex == 0) { 476 pr_info("PF_BRIDGE: br_mdb_parse() with invalid ifindex\n"); 477 return -EINVAL; 478 } 479 480 dev = __dev_get_by_index(net, bpm->ifindex); 481 if (dev == NULL) { 482 pr_info("PF_BRIDGE: br_mdb_parse() with unknown ifindex\n"); 483 return -ENODEV; 484 } 485 486 if (!(dev->priv_flags & IFF_EBRIDGE)) { 487 pr_info("PF_BRIDGE: br_mdb_parse() with non-bridge\n"); 488 return -EOPNOTSUPP; 489 } 490 491 *pdev = dev; 492 493 if (!tb[MDBA_SET_ENTRY] || 494 nla_len(tb[MDBA_SET_ENTRY]) != sizeof(struct br_mdb_entry)) { 495 pr_info("PF_BRIDGE: br_mdb_parse() with invalid attr\n"); 496 return -EINVAL; 497 } 498 499 entry = nla_data(tb[MDBA_SET_ENTRY]); 500 if (!is_valid_mdb_entry(entry)) { 501 pr_info("PF_BRIDGE: br_mdb_parse() with invalid entry\n"); 502 return -EINVAL; 503 } 504 505 *pentry = entry; 506 return 0; 507 } 508 509 static int br_mdb_add_group(struct net_bridge *br, struct net_bridge_port *port, 510 struct br_ip *group, unsigned char state) 511 { 512 struct net_bridge_mdb_entry *mp; 513 struct net_bridge_port_group *p; 514 struct net_bridge_port_group __rcu **pp; 515 struct net_bridge_mdb_htable *mdb; 516 unsigned long now = jiffies; 517 int err; 518 519 mdb = mlock_dereference(br->mdb, br); 520 mp = br_mdb_ip_get(mdb, group); 521 if (!mp) { 522 mp = br_multicast_new_group(br, port, group); 523 err = PTR_ERR_OR_ZERO(mp); 524 if (err) 525 return err; 526 } 527 528 for (pp = &mp->ports; 529 (p = mlock_dereference(*pp, br)) != NULL; 530 pp = &p->next) { 531 if (p->port == port) 532 return -EEXIST; 533 if ((unsigned long)p->port < (unsigned long)port) 534 break; 535 } 536 537 p = br_multicast_new_port_group(port, group, *pp, state, NULL); 538 if (unlikely(!p)) 539 return -ENOMEM; 540 rcu_assign_pointer(*pp, p); 541 if (state == MDB_TEMPORARY) 542 mod_timer(&p->timer, now + br->multicast_membership_interval); 543 544 return 0; 545 } 546 547 static int __br_mdb_add(struct net *net, struct net_bridge *br, 548 struct br_mdb_entry *entry) 549 { 550 struct br_ip ip; 551 struct net_device *dev; 552 struct net_bridge_port *p; 553 int ret; 554 555 if (!netif_running(br->dev) || br->multicast_disabled) 556 return -EINVAL; 557 558 dev = __dev_get_by_index(net, entry->ifindex); 559 if (!dev) 560 return -ENODEV; 561 562 p = br_port_get_rtnl(dev); 563 if (!p || p->br != br || p->state == BR_STATE_DISABLED) 564 return -EINVAL; 565 566 __mdb_entry_to_br_ip(entry, &ip); 567 568 spin_lock_bh(&br->multicast_lock); 569 ret = br_mdb_add_group(br, p, &ip, entry->state); 570 spin_unlock_bh(&br->multicast_lock); 571 return ret; 572 } 573 574 static int br_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, 575 struct netlink_ext_ack *extack) 576 { 577 struct net *net = sock_net(skb->sk); 578 struct net_bridge_vlan_group *vg; 579 struct net_device *dev, *pdev; 580 struct br_mdb_entry *entry; 581 struct net_bridge_port *p; 582 struct net_bridge_vlan *v; 583 struct net_bridge *br; 584 int err; 585 586 err = br_mdb_parse(skb, nlh, &dev, &entry); 587 if (err < 0) 588 return err; 589 590 br = netdev_priv(dev); 591 592 /* If vlan filtering is enabled and VLAN is not specified 593 * install mdb entry on all vlans configured on the port. 594 */ 595 pdev = __dev_get_by_index(net, entry->ifindex); 596 if (!pdev) 597 return -ENODEV; 598 599 p = br_port_get_rtnl(pdev); 600 if (!p || p->br != br || p->state == BR_STATE_DISABLED) 601 return -EINVAL; 602 603 vg = nbp_vlan_group(p); 604 if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) { 605 list_for_each_entry(v, &vg->vlan_list, vlist) { 606 entry->vid = v->vid; 607 err = __br_mdb_add(net, br, entry); 608 if (err) 609 break; 610 __br_mdb_notify(dev, p, entry, RTM_NEWMDB); 611 } 612 } else { 613 err = __br_mdb_add(net, br, entry); 614 if (!err) 615 __br_mdb_notify(dev, p, entry, RTM_NEWMDB); 616 } 617 618 return err; 619 } 620 621 static int __br_mdb_del(struct net_bridge *br, struct br_mdb_entry *entry) 622 { 623 struct net_bridge_mdb_htable *mdb; 624 struct net_bridge_mdb_entry *mp; 625 struct net_bridge_port_group *p; 626 struct net_bridge_port_group __rcu **pp; 627 struct br_ip ip; 628 int err = -EINVAL; 629 630 if (!netif_running(br->dev) || br->multicast_disabled) 631 return -EINVAL; 632 633 __mdb_entry_to_br_ip(entry, &ip); 634 635 spin_lock_bh(&br->multicast_lock); 636 mdb = mlock_dereference(br->mdb, br); 637 638 mp = br_mdb_ip_get(mdb, &ip); 639 if (!mp) 640 goto unlock; 641 642 for (pp = &mp->ports; 643 (p = mlock_dereference(*pp, br)) != NULL; 644 pp = &p->next) { 645 if (!p->port || p->port->dev->ifindex != entry->ifindex) 646 continue; 647 648 if (p->port->state == BR_STATE_DISABLED) 649 goto unlock; 650 651 __mdb_entry_fill_flags(entry, p->flags); 652 rcu_assign_pointer(*pp, p->next); 653 hlist_del_init(&p->mglist); 654 del_timer(&p->timer); 655 call_rcu_bh(&p->rcu, br_multicast_free_pg); 656 err = 0; 657 658 if (!mp->ports && !mp->mglist && 659 netif_running(br->dev)) 660 mod_timer(&mp->timer, jiffies); 661 break; 662 } 663 664 unlock: 665 spin_unlock_bh(&br->multicast_lock); 666 return err; 667 } 668 669 static int br_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, 670 struct netlink_ext_ack *extack) 671 { 672 struct net *net = sock_net(skb->sk); 673 struct net_bridge_vlan_group *vg; 674 struct net_device *dev, *pdev; 675 struct br_mdb_entry *entry; 676 struct net_bridge_port *p; 677 struct net_bridge_vlan *v; 678 struct net_bridge *br; 679 int err; 680 681 err = br_mdb_parse(skb, nlh, &dev, &entry); 682 if (err < 0) 683 return err; 684 685 br = netdev_priv(dev); 686 687 /* If vlan filtering is enabled and VLAN is not specified 688 * delete mdb entry on all vlans configured on the port. 689 */ 690 pdev = __dev_get_by_index(net, entry->ifindex); 691 if (!pdev) 692 return -ENODEV; 693 694 p = br_port_get_rtnl(pdev); 695 if (!p || p->br != br || p->state == BR_STATE_DISABLED) 696 return -EINVAL; 697 698 vg = nbp_vlan_group(p); 699 if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) { 700 list_for_each_entry(v, &vg->vlan_list, vlist) { 701 entry->vid = v->vid; 702 err = __br_mdb_del(br, entry); 703 if (!err) 704 __br_mdb_notify(dev, p, entry, RTM_DELMDB); 705 } 706 } else { 707 err = __br_mdb_del(br, entry); 708 if (!err) 709 __br_mdb_notify(dev, p, entry, RTM_DELMDB); 710 } 711 712 return err; 713 } 714 715 void br_mdb_init(void) 716 { 717 rtnl_register(PF_BRIDGE, RTM_GETMDB, NULL, br_mdb_dump, 0); 718 rtnl_register(PF_BRIDGE, RTM_NEWMDB, br_mdb_add, NULL, 0); 719 rtnl_register(PF_BRIDGE, RTM_DELMDB, br_mdb_del, NULL, 0); 720 } 721 722 void br_mdb_uninit(void) 723 { 724 rtnl_unregister(PF_BRIDGE, RTM_GETMDB); 725 rtnl_unregister(PF_BRIDGE, RTM_NEWMDB); 726 rtnl_unregister(PF_BRIDGE, RTM_DELMDB); 727 } 728