net/bridge/br_mdb.c

   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 }