net/bridge/br_multicast.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Bridge multicast support.
   4  *
   5  * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
   6  */
   7
   8 #include <linux/err.h>
   9 #include <linux/export.h>
  10 #include <linux/if_ether.h>
  11 #include <linux/igmp.h>
  12 #include <linux/in.h>
  13 #include <linux/jhash.h>
  14 #include <linux/kernel.h>
  15 #include <linux/log2.h>
  16 #include <linux/netdevice.h>
  17 #include <linux/netfilter_bridge.h>
  18 #include <linux/random.h>
  19 #include <linux/rculist.h>
  20 #include <linux/skbuff.h>
  21 #include <linux/slab.h>
  22 #include <linux/timer.h>
  23 #include <linux/inetdevice.h>
  24 #include <linux/mroute.h>
  25 #include <net/ip.h>
  26 #include <net/switchdev.h>
  27 #if IS_ENABLED(CONFIG_IPV6)
  28 #include <linux/icmpv6.h>
  29 #include <net/ipv6.h>
  30 #include <net/mld.h>
  31 #include <net/ip6_checksum.h>
  32 #include <net/addrconf.h>
  33 #endif
  34
  35 #include "br_private.h"
  36
  37 static const struct rhashtable_params br_mdb_rht_params = {
  38         .head_offset = offsetof(struct net_bridge_mdb_entry, rhnode),
  39         .key_offset = offsetof(struct net_bridge_mdb_entry, addr),
  40         .key_len = sizeof(struct br_ip),
  41         .automatic_shrinking = true,
  42 };
  43
  44 static void br_multicast_start_querier(struct net_bridge *br,
  45                                        struct bridge_mcast_own_query *query);
  46 static void br_multicast_add_router(struct net_bridge *br,
  47                                     struct net_bridge_port *port);
  48 static void br_ip4_multicast_leave_group(struct net_bridge *br,
  49                                          struct net_bridge_port *port,
  50                                          __be32 group,
  51                                          __u16 vid,
  52                                          const unsigned char *src);
  53
  54 static void __del_port_router(struct net_bridge_port *p);
  55 #if IS_ENABLED(CONFIG_IPV6)
  56 static void br_ip6_multicast_leave_group(struct net_bridge *br,
  57                                          struct net_bridge_port *port,
  58                                          const struct in6_addr *group,
  59                                          __u16 vid, const unsigned char *src);
  60 #endif
  61
  62 static struct net_bridge_mdb_entry *br_mdb_ip_get_rcu(struct net_bridge *br,
  63                                                       struct br_ip *dst)
  64 {
  65         return rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
  66 }
  67
  68 struct net_bridge_mdb_entry *br_mdb_ip_get(struct net_bridge *br,
  69                                            struct br_ip *dst)
  70 {
  71         struct net_bridge_mdb_entry *ent;
  72
  73         lockdep_assert_held_once(&br->multicast_lock);
  74
  75         rcu_read_lock();
  76         ent = rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
  77         rcu_read_unlock();
  78
  79         return ent;
  80 }
  81
  82 static struct net_bridge_mdb_entry *br_mdb_ip4_get(struct net_bridge *br,
  83                                                    __be32 dst, __u16 vid)
  84 {
  85         struct br_ip br_dst;
  86
  87         memset(&br_dst, 0, sizeof(br_dst));
  88         br_dst.u.ip4 = dst;
  89         br_dst.proto = htons(ETH_P_IP);
  90         br_dst.vid = vid;
  91
  92         return br_mdb_ip_get(br, &br_dst);
  93 }
  94
  95 #if IS_ENABLED(CONFIG_IPV6)
  96 static struct net_bridge_mdb_entry *br_mdb_ip6_get(struct net_bridge *br,
  97                                                    const struct in6_addr *dst,
  98                                                    __u16 vid)
  99 {
 100         struct br_ip br_dst;
 101
 102         memset(&br_dst, 0, sizeof(br_dst));
 103         br_dst.u.ip6 = *dst;
 104         br_dst.proto = htons(ETH_P_IPV6);
 105         br_dst.vid = vid;
 106
 107         return br_mdb_ip_get(br, &br_dst);
 108 }
 109 #endif
 110
 111 struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
 112                                         struct sk_buff *skb, u16 vid)
 113 {
 114         struct br_ip ip;
 115
 116         if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
 117                 return NULL;
 118
 119         if (BR_INPUT_SKB_CB(skb)->igmp)
 120                 return NULL;
 121
 122         memset(&ip, 0, sizeof(ip));
 123         ip.proto = skb->protocol;
 124         ip.vid = vid;
 125
 126         switch (skb->protocol) {
 127         case htons(ETH_P_IP):
 128                 ip.u.ip4 = ip_hdr(skb)->daddr;
 129                 break;
 130 #if IS_ENABLED(CONFIG_IPV6)
 131         case htons(ETH_P_IPV6):
 132                 ip.u.ip6 = ipv6_hdr(skb)->daddr;
 133                 break;
 134 #endif
 135         default:
 136                 return NULL;
 137         }
 138
 139         return br_mdb_ip_get_rcu(br, &ip);
 140 }
 141
 142 static void br_multicast_group_expired(struct timer_list *t)
 143 {
 144         struct net_bridge_mdb_entry *mp = from_timer(mp, t, timer);
 145         struct net_bridge *br = mp->br;
 146
 147         spin_lock(&br->multicast_lock);
 148         if (!netif_running(br->dev) || timer_pending(&mp->timer))
 149                 goto out;
 150
 151         br_multicast_host_leave(mp, true);
 152
 153         if (mp->ports)
 154                 goto out;
 155
 156         rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode,
 157                                br_mdb_rht_params);
 158         hlist_del_rcu(&mp->mdb_node);
 159
 160         kfree_rcu(mp, rcu);
 161
 162 out:
 163         spin_unlock(&br->multicast_lock);
 164 }
 165
 166 static void br_multicast_del_group_src(struct net_bridge_group_src *src)
 167 {
 168         struct net_bridge *br = src->pg->port->br;
 169
 170         hlist_del_init_rcu(&src->node);
 171         src->pg->src_ents--;
 172         hlist_add_head(&src->del_node, &br->src_gc_list);
 173         queue_work(system_long_wq, &br->src_gc_work);
 174 }
 175
 176 void br_multicast_del_pg(struct net_bridge_mdb_entry *mp,
 177                          struct net_bridge_port_group *pg,
 178                          struct net_bridge_port_group __rcu **pp)
 179 {
 180         struct net_bridge *br = pg->port->br;
 181         struct net_bridge_group_src *ent;
 182         struct hlist_node *tmp;
 183
 184         rcu_assign_pointer(*pp, pg->next);
 185         hlist_del_init(&pg->mglist);
 186         del_timer(&pg->timer);
 187         hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
 188                 br_multicast_del_group_src(ent);
 189         br_mdb_notify(br->dev, pg->port, &pg->addr, RTM_DELMDB, pg->flags);
 190         kfree_rcu(pg, rcu);
 191
 192         if (!mp->ports && !mp->host_joined && netif_running(br->dev))
 193                 mod_timer(&mp->timer, jiffies);
 194 }
 195
 196 static void br_multicast_find_del_pg(struct net_bridge *br,
 197                                      struct net_bridge_port_group *pg)
 198 {
 199         struct net_bridge_port_group __rcu **pp;
 200         struct net_bridge_mdb_entry *mp;
 201         struct net_bridge_port_group *p;
 202
 203         mp = br_mdb_ip_get(br, &pg->addr);
 204         if (WARN_ON(!mp))
 205                 return;
 206
 207         for (pp = &mp->ports;
 208              (p = mlock_dereference(*pp, br)) != NULL;
 209              pp = &p->next) {
 210                 if (p != pg)
 211                         continue;
 212
 213                 br_multicast_del_pg(mp, pg, pp);
 214                 return;
 215         }
 216
 217         WARN_ON(1);
 218 }
 219
 220 static void br_multicast_port_group_expired(struct timer_list *t)
 221 {
 222         struct net_bridge_port_group *pg = from_timer(pg, t, timer);
 223         struct net_bridge *br = pg->port->br;
 224
 225         spin_lock(&br->multicast_lock);
 226         if (!netif_running(br->dev) || timer_pending(&pg->timer) ||
 227             hlist_unhashed(&pg->mglist) || pg->flags & MDB_PG_FLAGS_PERMANENT)
 228                 goto out;
 229
 230         br_multicast_find_del_pg(br, pg);
 231
 232 out:
 233         spin_unlock(&br->multicast_lock);
 234 }
 235
 236 static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br,
 237                                                     __be32 group,
 238                                                     u8 *igmp_type)
 239 {
 240         struct igmpv3_query *ihv3;
 241         size_t igmp_hdr_size;
 242         struct sk_buff *skb;
 243         struct igmphdr *ih;
 244         struct ethhdr *eth;
 245         struct iphdr *iph;
 246
 247         igmp_hdr_size = sizeof(*ih);
 248         if (br->multicast_igmp_version == 3)
 249                 igmp_hdr_size = sizeof(*ihv3);
 250         skb = netdev_alloc_skb_ip_align(br->dev, sizeof(*eth) + sizeof(*iph) +
 251                                                  igmp_hdr_size + 4);
 252         if (!skb)
 253                 goto out;
 254
 255         skb->protocol = htons(ETH_P_IP);
 256
 257         skb_reset_mac_header(skb);
 258         eth = eth_hdr(skb);
 259
 260         ether_addr_copy(eth->h_source, br->dev->dev_addr);
 261         eth->h_dest[0] = 1;
 262         eth->h_dest[1] = 0;
 263         eth->h_dest[2] = 0x5e;
 264         eth->h_dest[3] = 0;
 265         eth->h_dest[4] = 0;
 266         eth->h_dest[5] = 1;
 267         eth->h_proto = htons(ETH_P_IP);
 268         skb_put(skb, sizeof(*eth));
 269
 270         skb_set_network_header(skb, skb->len);
 271         iph = ip_hdr(skb);
 272
 273         iph->version = 4;
 274         iph->ihl = 6;
 275         iph->tos = 0xc0;
 276         iph->tot_len = htons(sizeof(*iph) + igmp_hdr_size + 4);
 277         iph->id = 0;
 278         iph->frag_off = htons(IP_DF);
 279         iph->ttl = 1;
 280         iph->protocol = IPPROTO_IGMP;
 281         iph->saddr = br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR) ?
 282                      inet_select_addr(br->dev, 0, RT_SCOPE_LINK) : 0;
 283         iph->daddr = htonl(INADDR_ALLHOSTS_GROUP);
 284         ((u8 *)&iph[1])[0] = IPOPT_RA;
 285         ((u8 *)&iph[1])[1] = 4;
 286         ((u8 *)&iph[1])[2] = 0;
 287         ((u8 *)&iph[1])[3] = 0;
 288         ip_send_check(iph);
 289         skb_put(skb, 24);
 290
 291         skb_set_transport_header(skb, skb->len);
 292         *igmp_type = IGMP_HOST_MEMBERSHIP_QUERY;
 293
 294         switch (br->multicast_igmp_version) {
 295         case 2:
 296                 ih = igmp_hdr(skb);
 297                 ih->type = IGMP_HOST_MEMBERSHIP_QUERY;
 298                 ih->code = (group ? br->multicast_last_member_interval :
 299                                     br->multicast_query_response_interval) /
 300                            (HZ / IGMP_TIMER_SCALE);
 301                 ih->group = group;
 302                 ih->csum = 0;
 303                 ih->csum = ip_compute_csum((void *)ih, sizeof(*ih));
 304                 break;
 305         case 3:
 306                 ihv3 = igmpv3_query_hdr(skb);
 307                 ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY;
 308                 ihv3->code = (group ? br->multicast_last_member_interval :
 309                                       br->multicast_query_response_interval) /
 310                              (HZ / IGMP_TIMER_SCALE);
 311                 ihv3->group = group;
 312                 ihv3->qqic = br->multicast_query_interval / HZ;
 313                 ihv3->nsrcs = 0;
 314                 ihv3->resv = 0;
 315                 ihv3->suppress = 0;
 316                 ihv3->qrv = 2;
 317                 ihv3->csum = 0;
 318                 ihv3->csum = ip_compute_csum((void *)ihv3, sizeof(*ihv3));
 319                 break;
 320         }
 321
 322         skb_put(skb, igmp_hdr_size);
 323         __skb_pull(skb, sizeof(*eth));
 324
 325 out:
 326         return skb;
 327 }
 328
 329 #if IS_ENABLED(CONFIG_IPV6)
 330 static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br,
 331                                                     const struct in6_addr *grp,
 332                                                     u8 *igmp_type)
 333 {
 334         struct mld2_query *mld2q;
 335         unsigned long interval;
 336         struct ipv6hdr *ip6h;
 337         struct mld_msg *mldq;
 338         size_t mld_hdr_size;
 339         struct sk_buff *skb;
 340         struct ethhdr *eth;
 341         u8 *hopopt;
 342
 343         mld_hdr_size = sizeof(*mldq);
 344         if (br->multicast_mld_version == 2)
 345                 mld_hdr_size = sizeof(*mld2q);
 346         skb = netdev_alloc_skb_ip_align(br->dev, sizeof(*eth) + sizeof(*ip6h) +
 347                                                  8 + mld_hdr_size);
 348         if (!skb)
 349                 goto out;
 350
 351         skb->protocol = htons(ETH_P_IPV6);
 352
 353         /* Ethernet header */
 354         skb_reset_mac_header(skb);
 355         eth = eth_hdr(skb);
 356
 357         ether_addr_copy(eth->h_source, br->dev->dev_addr);
 358         eth->h_proto = htons(ETH_P_IPV6);
 359         skb_put(skb, sizeof(*eth));
 360
 361         /* IPv6 header + HbH option */
 362         skb_set_network_header(skb, skb->len);
 363         ip6h = ipv6_hdr(skb);
 364
 365         *(__force __be32 *)ip6h = htonl(0x60000000);
 366         ip6h->payload_len = htons(8 + mld_hdr_size);
 367         ip6h->nexthdr = IPPROTO_HOPOPTS;
 368         ip6h->hop_limit = 1;
 369         ipv6_addr_set(&ip6h->daddr, htonl(0xff020000), 0, 0, htonl(1));
 370         if (ipv6_dev_get_saddr(dev_net(br->dev), br->dev, &ip6h->daddr, 0,
 371                                &ip6h->saddr)) {
 372                 kfree_skb(skb);
 373                 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, false);
 374                 return NULL;
 375         }
 376
 377         br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
 378         ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
 379
 380         hopopt = (u8 *)(ip6h + 1);
 381         hopopt[0] = IPPROTO_ICMPV6;             /* next hdr */
 382         hopopt[1] = 0;                          /* length of HbH */
 383         hopopt[2] = IPV6_TLV_ROUTERALERT;       /* Router Alert */
 384         hopopt[3] = 2;                          /* Length of RA Option */
 385         hopopt[4] = 0;                          /* Type = 0x0000 (MLD) */
 386         hopopt[5] = 0;
 387         hopopt[6] = IPV6_TLV_PAD1;              /* Pad1 */
 388         hopopt[7] = IPV6_TLV_PAD1;              /* Pad1 */
 389
 390         skb_put(skb, sizeof(*ip6h) + 8);
 391
 392         /* ICMPv6 */
 393         skb_set_transport_header(skb, skb->len);
 394         interval = ipv6_addr_any(grp) ?
 395                         br->multicast_query_response_interval :
 396                         br->multicast_last_member_interval;
 397         *igmp_type = ICMPV6_MGM_QUERY;
 398         switch (br->multicast_mld_version) {
 399         case 1:
 400                 mldq = (struct mld_msg *)icmp6_hdr(skb);
 401                 mldq->mld_type = ICMPV6_MGM_QUERY;
 402                 mldq->mld_code = 0;
 403                 mldq->mld_cksum = 0;
 404                 mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval));
 405                 mldq->mld_reserved = 0;
 406                 mldq->mld_mca = *grp;
 407                 mldq->mld_cksum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
 408                                                   sizeof(*mldq), IPPROTO_ICMPV6,
 409                                                   csum_partial(mldq,
 410                                                                sizeof(*mldq),
 411                                                                0));
 412                 break;
 413         case 2:
 414                 mld2q = (struct mld2_query *)icmp6_hdr(skb);
 415                 mld2q->mld2q_mrc = htons((u16)jiffies_to_msecs(interval));
 416                 mld2q->mld2q_type = ICMPV6_MGM_QUERY;
 417                 mld2q->mld2q_code = 0;
 418                 mld2q->mld2q_cksum = 0;
 419                 mld2q->mld2q_resv1 = 0;
 420                 mld2q->mld2q_resv2 = 0;
 421                 mld2q->mld2q_suppress = 0;
 422                 mld2q->mld2q_qrv = 2;
 423                 mld2q->mld2q_nsrcs = 0;
 424                 mld2q->mld2q_qqic = br->multicast_query_interval / HZ;
 425                 mld2q->mld2q_mca = *grp;
 426                 mld2q->mld2q_cksum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
 427                                                      sizeof(*mld2q),
 428                                                      IPPROTO_ICMPV6,
 429                                                      csum_partial(mld2q,
 430                                                                   sizeof(*mld2q),
 431                                                                   0));
 432                 break;
 433         }
 434         skb_put(skb, mld_hdr_size);
 435
 436         __skb_pull(skb, sizeof(*eth));
 437
 438 out:
 439         return skb;
 440 }
 441 #endif
 442
 443 static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
 444                                                 struct br_ip *addr,
 445                                                 u8 *igmp_type)
 446 {
 447         switch (addr->proto) {
 448         case htons(ETH_P_IP):
 449                 return br_ip4_multicast_alloc_query(br, addr->u.ip4, igmp_type);
 450 #if IS_ENABLED(CONFIG_IPV6)
 451         case htons(ETH_P_IPV6):
 452                 return br_ip6_multicast_alloc_query(br, &addr->u.ip6,
 453                                                     igmp_type);
 454 #endif
 455         }
 456         return NULL;
 457 }
 458
 459 struct net_bridge_mdb_entry *br_multicast_new_group(struct net_bridge *br,
 460                                                     struct br_ip *group)
 461 {
 462         struct net_bridge_mdb_entry *mp;
 463         int err;
 464
 465         mp = br_mdb_ip_get(br, group);
 466         if (mp)
 467                 return mp;
 468
 469         if (atomic_read(&br->mdb_hash_tbl.nelems) >= br->hash_max) {
 470                 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, false);
 471                 return ERR_PTR(-E2BIG);
 472         }
 473
 474         mp = kzalloc(sizeof(*mp), GFP_ATOMIC);
 475         if (unlikely(!mp))
 476                 return ERR_PTR(-ENOMEM);
 477
 478         mp->br = br;
 479         mp->addr = *group;
 480         timer_setup(&mp->timer, br_multicast_group_expired, 0);
 481         err = rhashtable_lookup_insert_fast(&br->mdb_hash_tbl, &mp->rhnode,
 482                                             br_mdb_rht_params);
 483         if (err) {
 484                 kfree(mp);
 485                 mp = ERR_PTR(err);
 486         } else {
 487                 hlist_add_head_rcu(&mp->mdb_node, &br->mdb_list);
 488         }
 489
 490         return mp;
 491 }
 492
 493 static void br_multicast_group_src_expired(struct timer_list *t)
 494 {
 495         struct net_bridge_group_src *src = from_timer(src, t, timer);
 496         struct net_bridge_port_group *pg;
 497         struct net_bridge *br = src->br;
 498
 499         spin_lock(&br->multicast_lock);
 500         if (hlist_unhashed(&src->node) || !netif_running(br->dev) ||
 501             timer_pending(&src->timer))
 502                 goto out;
 503
 504         pg = src->pg;
 505         if (pg->filter_mode == MCAST_INCLUDE) {
 506                 br_multicast_del_group_src(src);
 507                 if (!hlist_empty(&pg->src_list))
 508                         goto out;
 509                 br_multicast_find_del_pg(br, pg);
 510         }
 511 out:
 512         spin_unlock(&br->multicast_lock);
 513 }
 514
 515 static struct net_bridge_group_src *
 516 br_multicast_find_group_src(struct net_bridge_port_group *pg, struct br_ip *ip)
 517 {
 518         struct net_bridge_group_src *ent;
 519
 520         switch (ip->proto) {
 521         case htons(ETH_P_IP):
 522                 hlist_for_each_entry(ent, &pg->src_list, node)
 523                         if (ip->u.ip4 == ent->addr.u.ip4)
 524                                 return ent;
 525                 break;
 526 #if IS_ENABLED(CONFIG_IPV6)
 527         case htons(ETH_P_IPV6):
 528                 hlist_for_each_entry(ent, &pg->src_list, node)
 529                         if (!ipv6_addr_cmp(&ent->addr.u.ip6, &ip->u.ip6))
 530                                 return ent;
 531                 break;
 532 #endif
 533         }
 534
 535         return NULL;
 536 }
 537
 538 static struct net_bridge_group_src *
 539 br_multicast_new_group_src(struct net_bridge_port_group *pg, struct br_ip *src_ip)
 540 {
 541         struct net_bridge_group_src *grp_src;
 542
 543         if (unlikely(pg->src_ents >= PG_SRC_ENT_LIMIT))
 544                 return NULL;
 545
 546         switch (src_ip->proto) {
 547         case htons(ETH_P_IP):
 548                 if (ipv4_is_zeronet(src_ip->u.ip4) ||
 549                     ipv4_is_multicast(src_ip->u.ip4))
 550                         return NULL;
 551                 break;
 552 #if IS_ENABLED(CONFIG_IPV6)
 553         case htons(ETH_P_IPV6):
 554                 if (ipv6_addr_any(&src_ip->u.ip6) ||
 555                     ipv6_addr_is_multicast(&src_ip->u.ip6))
 556                         return NULL;
 557                 break;
 558 #endif
 559         }
 560
 561         grp_src = kzalloc(sizeof(*grp_src), GFP_ATOMIC);
 562         if (unlikely(!grp_src))
 563                 return NULL;
 564
 565         grp_src->pg = pg;
 566         grp_src->br = pg->port->br;
 567         grp_src->addr = *src_ip;
 568         timer_setup(&grp_src->timer, br_multicast_group_src_expired, 0);
 569
 570         hlist_add_head_rcu(&grp_src->node, &pg->src_list);
 571         pg->src_ents++;
 572
 573         return grp_src;
 574 }
 575
 576 struct net_bridge_port_group *br_multicast_new_port_group(
 577                         struct net_bridge_port *port,
 578                         struct br_ip *group,
 579                         struct net_bridge_port_group __rcu *next,
 580                         unsigned char flags,
 581                         const unsigned char *src,
 582                         u8 filter_mode)
 583 {
 584         struct net_bridge_port_group *p;
 585
 586         p = kzalloc(sizeof(*p), GFP_ATOMIC);
 587         if (unlikely(!p))
 588                 return NULL;
 589
 590         p->addr = *group;
 591         p->port = port;
 592         p->flags = flags;
 593         p->filter_mode = filter_mode;
 594         INIT_HLIST_HEAD(&p->src_list);
 595         rcu_assign_pointer(p->next, next);
 596         hlist_add_head(&p->mglist, &port->mglist);
 597         timer_setup(&p->timer, br_multicast_port_group_expired, 0);
 598
 599         if (src)
 600                 memcpy(p->eth_addr, src, ETH_ALEN);
 601         else
 602                 eth_broadcast_addr(p->eth_addr);
 603
 604         return p;
 605 }
 606
 607 static bool br_port_group_equal(struct net_bridge_port_group *p,
 608                                 struct net_bridge_port *port,
 609                                 const unsigned char *src)
 610 {
 611         if (p->port != port)
 612                 return false;
 613
 614         if (!(port->flags & BR_MULTICAST_TO_UNICAST))
 615                 return true;
 616
 617         return ether_addr_equal(src, p->eth_addr);
 618 }
 619
 620 void br_multicast_host_join(struct net_bridge_mdb_entry *mp, bool notify)
 621 {
 622         if (!mp->host_joined) {
 623                 mp->host_joined = true;
 624                 if (notify)
 625                         br_mdb_notify(mp->br->dev, NULL, &mp->addr,
 626                                       RTM_NEWMDB, 0);
 627         }
 628         mod_timer(&mp->timer, jiffies + mp->br->multicast_membership_interval);
 629 }
 630
 631 void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify)
 632 {
 633         if (!mp->host_joined)
 634                 return;
 635
 636         mp->host_joined = false;
 637         if (notify)
 638                 br_mdb_notify(mp->br->dev, NULL, &mp->addr, RTM_DELMDB, 0);
 639 }
 640
 641 static int br_multicast_add_group(struct net_bridge *br,
 642                                   struct net_bridge_port *port,
 643                                   struct br_ip *group,
 644                                   const unsigned char *src,
 645                                   u8 filter_mode)
 646 {
 647         struct net_bridge_port_group __rcu **pp;
 648         struct net_bridge_port_group *p;
 649         struct net_bridge_mdb_entry *mp;
 650         unsigned long now = jiffies;
 651         int err;
 652
 653         spin_lock(&br->multicast_lock);
 654         if (!netif_running(br->dev) ||
 655             (port && port->state == BR_STATE_DISABLED))
 656                 goto out;
 657
 658         mp = br_multicast_new_group(br, group);
 659         err = PTR_ERR(mp);
 660         if (IS_ERR(mp))
 661                 goto err;
 662
 663         if (!port) {
 664                 br_multicast_host_join(mp, true);
 665                 goto out;
 666         }
 667
 668         for (pp = &mp->ports;
 669              (p = mlock_dereference(*pp, br)) != NULL;
 670              pp = &p->next) {
 671                 if (br_port_group_equal(p, port, src))
 672                         goto found;
 673                 if ((unsigned long)p->port < (unsigned long)port)
 674                         break;
 675         }
 676
 677         p = br_multicast_new_port_group(port, group, *pp, 0, src, filter_mode);
 678         if (unlikely(!p))
 679                 goto err;
 680         rcu_assign_pointer(*pp, p);
 681         br_mdb_notify(br->dev, port, group, RTM_NEWMDB, 0);
 682
 683 found:
 684         mod_timer(&p->timer, now + br->multicast_membership_interval);
 685 out:
 686         err = 0;
 687
 688 err:
 689         spin_unlock(&br->multicast_lock);
 690         return err;
 691 }
 692
 693 static int br_ip4_multicast_add_group(struct net_bridge *br,
 694                                       struct net_bridge_port *port,
 695                                       __be32 group,
 696                                       __u16 vid,
 697                                       const unsigned char *src,
 698                                       bool igmpv2)
 699 {
 700         struct br_ip br_group;
 701         u8 filter_mode;
 702
 703         if (ipv4_is_local_multicast(group))
 704                 return 0;
 705
 706         memset(&br_group, 0, sizeof(br_group));
 707         br_group.u.ip4 = group;
 708         br_group.proto = htons(ETH_P_IP);
 709         br_group.vid = vid;
 710         filter_mode = igmpv2 ? MCAST_EXCLUDE : MCAST_INCLUDE;
 711
 712         return br_multicast_add_group(br, port, &br_group, src, filter_mode);
 713 }
 714
 715 #if IS_ENABLED(CONFIG_IPV6)
 716 static int br_ip6_multicast_add_group(struct net_bridge *br,
 717                                       struct net_bridge_port *port,
 718                                       const struct in6_addr *group,
 719                                       __u16 vid,
 720                                       const unsigned char *src,
 721                                       bool mldv1)
 722 {
 723         struct br_ip br_group;
 724         u8 filter_mode;
 725
 726         if (ipv6_addr_is_ll_all_nodes(group))
 727                 return 0;
 728
 729         memset(&br_group, 0, sizeof(br_group));
 730         br_group.u.ip6 = *group;
 731         br_group.proto = htons(ETH_P_IPV6);
 732         br_group.vid = vid;
 733         filter_mode = mldv1 ? MCAST_EXCLUDE : MCAST_INCLUDE;
 734
 735         return br_multicast_add_group(br, port, &br_group, src, filter_mode);
 736 }
 737 #endif
 738
 739 static void br_multicast_router_expired(struct timer_list *t)
 740 {
 741         struct net_bridge_port *port =
 742                         from_timer(port, t, multicast_router_timer);
 743         struct net_bridge *br = port->br;
 744
 745         spin_lock(&br->multicast_lock);
 746         if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
 747             port->multicast_router == MDB_RTR_TYPE_PERM ||
 748             timer_pending(&port->multicast_router_timer))
 749                 goto out;
 750
 751         __del_port_router(port);
 752 out:
 753         spin_unlock(&br->multicast_lock);
 754 }
 755
 756 static void br_mc_router_state_change(struct net_bridge *p,
 757                                       bool is_mc_router)
 758 {
 759         struct switchdev_attr attr = {
 760                 .orig_dev = p->dev,
 761                 .id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER,
 762                 .flags = SWITCHDEV_F_DEFER,
 763                 .u.mrouter = is_mc_router,
 764         };
 765
 766         switchdev_port_attr_set(p->dev, &attr);
 767 }
 768
 769 static void br_multicast_local_router_expired(struct timer_list *t)
 770 {
 771         struct net_bridge *br = from_timer(br, t, multicast_router_timer);
 772
 773         spin_lock(&br->multicast_lock);
 774         if (br->multicast_router == MDB_RTR_TYPE_DISABLED ||
 775             br->multicast_router == MDB_RTR_TYPE_PERM ||
 776             timer_pending(&br->multicast_router_timer))
 777                 goto out;
 778
 779         br_mc_router_state_change(br, false);
 780 out:
 781         spin_unlock(&br->multicast_lock);
 782 }
 783
 784 static void br_multicast_querier_expired(struct net_bridge *br,
 785                                          struct bridge_mcast_own_query *query)
 786 {
 787         spin_lock(&br->multicast_lock);
 788         if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
 789                 goto out;
 790
 791         br_multicast_start_querier(br, query);
 792
 793 out:
 794         spin_unlock(&br->multicast_lock);
 795 }
 796
 797 static void br_ip4_multicast_querier_expired(struct timer_list *t)
 798 {
 799         struct net_bridge *br = from_timer(br, t, ip4_other_query.timer);
 800
 801         br_multicast_querier_expired(br, &br->ip4_own_query);
 802 }
 803
 804 #if IS_ENABLED(CONFIG_IPV6)
 805 static void br_ip6_multicast_querier_expired(struct timer_list *t)
 806 {
 807         struct net_bridge *br = from_timer(br, t, ip6_other_query.timer);
 808
 809         br_multicast_querier_expired(br, &br->ip6_own_query);
 810 }
 811 #endif
 812
 813 static void br_multicast_select_own_querier(struct net_bridge *br,
 814                                             struct br_ip *ip,
 815                                             struct sk_buff *skb)
 816 {
 817         if (ip->proto == htons(ETH_P_IP))
 818                 br->ip4_querier.addr.u.ip4 = ip_hdr(skb)->saddr;
 819 #if IS_ENABLED(CONFIG_IPV6)
 820         else
 821                 br->ip6_querier.addr.u.ip6 = ipv6_hdr(skb)->saddr;
 822 #endif
 823 }
 824
 825 static void __br_multicast_send_query(struct net_bridge *br,
 826                                       struct net_bridge_port *port,
 827                                       struct br_ip *ip)
 828 {
 829         struct sk_buff *skb;
 830         u8 igmp_type;
 831
 832         skb = br_multicast_alloc_query(br, ip, &igmp_type);
 833         if (!skb)
 834                 return;
 835
 836         if (port) {
 837                 skb->dev = port->dev;
 838                 br_multicast_count(br, port, skb, igmp_type,
 839                                    BR_MCAST_DIR_TX);
 840                 NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT,
 841                         dev_net(port->dev), NULL, skb, NULL, skb->dev,
 842                         br_dev_queue_push_xmit);
 843         } else {
 844                 br_multicast_select_own_querier(br, ip, skb);
 845                 br_multicast_count(br, port, skb, igmp_type,
 846                                    BR_MCAST_DIR_RX);
 847                 netif_rx(skb);
 848         }
 849 }
 850
 851 static void br_multicast_send_query(struct net_bridge *br,
 852                                     struct net_bridge_port *port,
 853                                     struct bridge_mcast_own_query *own_query)
 854 {
 855         struct bridge_mcast_other_query *other_query = NULL;
 856         struct br_ip br_group;
 857         unsigned long time;
 858
 859         if (!netif_running(br->dev) ||
 860             !br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
 861             !br_opt_get(br, BROPT_MULTICAST_QUERIER))
 862                 return;
 863
 864         memset(&br_group.u, 0, sizeof(br_group.u));
 865
 866         if (port ? (own_query == &port->ip4_own_query) :
 867                    (own_query == &br->ip4_own_query)) {
 868                 other_query = &br->ip4_other_query;
 869                 br_group.proto = htons(ETH_P_IP);
 870 #if IS_ENABLED(CONFIG_IPV6)
 871         } else {
 872                 other_query = &br->ip6_other_query;
 873                 br_group.proto = htons(ETH_P_IPV6);
 874 #endif
 875         }
 876
 877         if (!other_query || timer_pending(&other_query->timer))
 878                 return;
 879
 880         __br_multicast_send_query(br, port, &br_group);
 881
 882         time = jiffies;
 883         time += own_query->startup_sent < br->multicast_startup_query_count ?
 884                 br->multicast_startup_query_interval :
 885                 br->multicast_query_interval;
 886         mod_timer(&own_query->timer, time);
 887 }
 888
 889 static void
 890 br_multicast_port_query_expired(struct net_bridge_port *port,
 891                                 struct bridge_mcast_own_query *query)
 892 {
 893         struct net_bridge *br = port->br;
 894
 895         spin_lock(&br->multicast_lock);
 896         if (port->state == BR_STATE_DISABLED ||
 897             port->state == BR_STATE_BLOCKING)
 898                 goto out;
 899
 900         if (query->startup_sent < br->multicast_startup_query_count)
 901                 query->startup_sent++;
 902
 903         br_multicast_send_query(port->br, port, query);
 904
 905 out:
 906         spin_unlock(&br->multicast_lock);
 907 }
 908
 909 static void br_ip4_multicast_port_query_expired(struct timer_list *t)
 910 {
 911         struct net_bridge_port *port = from_timer(port, t, ip4_own_query.timer);
 912
 913         br_multicast_port_query_expired(port, &port->ip4_own_query);
 914 }
 915
 916 #if IS_ENABLED(CONFIG_IPV6)
 917 static void br_ip6_multicast_port_query_expired(struct timer_list *t)
 918 {
 919         struct net_bridge_port *port = from_timer(port, t, ip6_own_query.timer);
 920
 921         br_multicast_port_query_expired(port, &port->ip6_own_query);
 922 }
 923 #endif
 924
 925 static void br_mc_disabled_update(struct net_device *dev, bool value)
 926 {
 927         struct switchdev_attr attr = {
 928                 .orig_dev = dev,
 929                 .id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED,
 930                 .flags = SWITCHDEV_F_DEFER,
 931                 .u.mc_disabled = !value,
 932         };
 933
 934         switchdev_port_attr_set(dev, &attr);
 935 }
 936
 937 int br_multicast_add_port(struct net_bridge_port *port)
 938 {
 939         port->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
 940
 941         timer_setup(&port->multicast_router_timer,
 942                     br_multicast_router_expired, 0);
 943         timer_setup(&port->ip4_own_query.timer,
 944                     br_ip4_multicast_port_query_expired, 0);
 945 #if IS_ENABLED(CONFIG_IPV6)
 946         timer_setup(&port->ip6_own_query.timer,
 947                     br_ip6_multicast_port_query_expired, 0);
 948 #endif
 949         br_mc_disabled_update(port->dev,
 950                               br_opt_get(port->br, BROPT_MULTICAST_ENABLED));
 951
 952         port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
 953         if (!port->mcast_stats)
 954                 return -ENOMEM;
 955
 956         return 0;
 957 }
 958
 959 void br_multicast_del_port(struct net_bridge_port *port)
 960 {
 961         struct net_bridge *br = port->br;
 962         struct net_bridge_port_group *pg;
 963         struct hlist_node *n;
 964
 965         /* Take care of the remaining groups, only perm ones should be left */
 966         spin_lock_bh(&br->multicast_lock);
 967         hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
 968                 br_multicast_find_del_pg(br, pg);
 969         spin_unlock_bh(&br->multicast_lock);
 970         del_timer_sync(&port->multicast_router_timer);
 971         free_percpu(port->mcast_stats);
 972 }
 973
 974 static void br_multicast_enable(struct bridge_mcast_own_query *query)
 975 {
 976         query->startup_sent = 0;
 977
 978         if (try_to_del_timer_sync(&query->timer) >= 0 ||
 979             del_timer(&query->timer))
 980                 mod_timer(&query->timer, jiffies);
 981 }
 982
 983 static void __br_multicast_enable_port(struct net_bridge_port *port)
 984 {
 985         struct net_bridge *br = port->br;
 986
 987         if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || !netif_running(br->dev))
 988                 return;
 989
 990         br_multicast_enable(&port->ip4_own_query);
 991 #if IS_ENABLED(CONFIG_IPV6)
 992         br_multicast_enable(&port->ip6_own_query);
 993 #endif
 994         if (port->multicast_router == MDB_RTR_TYPE_PERM &&
 995             hlist_unhashed(&port->rlist))
 996                 br_multicast_add_router(br, port);
 997 }
 998
 999 void br_multicast_enable_port(struct net_bridge_port *port)
1000 {
1001         struct net_bridge *br = port->br;
1002
1003         spin_lock(&br->multicast_lock);
1004         __br_multicast_enable_port(port);
1005         spin_unlock(&br->multicast_lock);
1006 }
1007
1008 void br_multicast_disable_port(struct net_bridge_port *port)
1009 {
1010         struct net_bridge *br = port->br;
1011         struct net_bridge_port_group *pg;
1012         struct hlist_node *n;
1013
1014         spin_lock(&br->multicast_lock);
1015         hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
1016                 if (!(pg->flags & MDB_PG_FLAGS_PERMANENT))
1017                         br_multicast_find_del_pg(br, pg);
1018
1019         __del_port_router(port);
1020
1021         del_timer(&port->multicast_router_timer);
1022         del_timer(&port->ip4_own_query.timer);
1023 #if IS_ENABLED(CONFIG_IPV6)
1024         del_timer(&port->ip6_own_query.timer);
1025 #endif
1026         spin_unlock(&br->multicast_lock);
1027 }
1028
1029 static int br_ip4_multicast_igmp3_report(struct net_bridge *br,
1030                                          struct net_bridge_port *port,
1031                                          struct sk_buff *skb,
1032                                          u16 vid)
1033 {
1034         const unsigned char *src;
1035         struct igmpv3_report *ih;
1036         struct igmpv3_grec *grec;
1037         int i;
1038         int len;
1039         int num;
1040         int type;
1041         int err = 0;
1042         __be32 group;
1043         u16 nsrcs;
1044
1045         ih = igmpv3_report_hdr(skb);
1046         num = ntohs(ih->ngrec);
1047         len = skb_transport_offset(skb) + sizeof(*ih);
1048
1049         for (i = 0; i < num; i++) {
1050                 len += sizeof(*grec);
1051                 if (!ip_mc_may_pull(skb, len))
1052                         return -EINVAL;
1053
1054                 grec = (void *)(skb->data + len - sizeof(*grec));
1055                 group = grec->grec_mca;
1056                 type = grec->grec_type;
1057                 nsrcs = ntohs(grec->grec_nsrcs);
1058
1059                 len += nsrcs * 4;
1060                 if (!ip_mc_may_pull(skb, len))
1061                         return -EINVAL;
1062
1063                 /* We treat this as an IGMPv2 report for now. */
1064                 switch (type) {
1065                 case IGMPV3_MODE_IS_INCLUDE:
1066                 case IGMPV3_MODE_IS_EXCLUDE:
1067                 case IGMPV3_CHANGE_TO_INCLUDE:
1068                 case IGMPV3_CHANGE_TO_EXCLUDE:
1069                 case IGMPV3_ALLOW_NEW_SOURCES:
1070                 case IGMPV3_BLOCK_OLD_SOURCES:
1071                         break;
1072
1073                 default:
1074                         continue;
1075                 }
1076
1077                 src = eth_hdr(skb)->h_source;
1078                 if ((type == IGMPV3_CHANGE_TO_INCLUDE ||
1079                      type == IGMPV3_MODE_IS_INCLUDE) &&
1080                     nsrcs == 0) {
1081                         br_ip4_multicast_leave_group(br, port, group, vid, src);
1082                 } else {
1083                         err = br_ip4_multicast_add_group(br, port, group, vid,
1084                                                          src, true);
1085                         if (err)
1086                                 break;
1087                 }
1088         }
1089
1090         return err;
1091 }
1092
1093 #if IS_ENABLED(CONFIG_IPV6)
1094 static int br_ip6_multicast_mld2_report(struct net_bridge *br,
1095                                         struct net_bridge_port *port,
1096                                         struct sk_buff *skb,
1097                                         u16 vid)
1098 {
1099         unsigned int nsrcs_offset;
1100         const unsigned char *src;
1101         struct icmp6hdr *icmp6h;
1102         struct mld2_grec *grec;
1103         unsigned int grec_len;
1104         int i;
1105         int len;
1106         int num;
1107         int err = 0;
1108
1109         if (!ipv6_mc_may_pull(skb, sizeof(*icmp6h)))
1110                 return -EINVAL;
1111
1112         icmp6h = icmp6_hdr(skb);
1113         num = ntohs(icmp6h->icmp6_dataun.un_data16[1]);
1114         len = skb_transport_offset(skb) + sizeof(*icmp6h);
1115
1116         for (i = 0; i < num; i++) {
1117                 __be16 *_nsrcs, __nsrcs;
1118                 u16 nsrcs;
1119
1120                 nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs);
1121
1122                 if (skb_transport_offset(skb) + ipv6_transport_len(skb) <
1123                     nsrcs_offset + sizeof(__nsrcs))
1124                         return -EINVAL;
1125
1126                 _nsrcs = skb_header_pointer(skb, nsrcs_offset,
1127                                             sizeof(__nsrcs), &__nsrcs);
1128                 if (!_nsrcs)
1129                         return -EINVAL;
1130
1131                 nsrcs = ntohs(*_nsrcs);
1132                 grec_len = struct_size(grec, grec_src, nsrcs);
1133
1134                 if (!ipv6_mc_may_pull(skb, len + grec_len))
1135                         return -EINVAL;
1136
1137                 grec = (struct mld2_grec *)(skb->data + len);
1138                 len += grec_len;
1139
1140                 /* We treat these as MLDv1 reports for now. */
1141                 switch (grec->grec_type) {
1142                 case MLD2_MODE_IS_INCLUDE:
1143                 case MLD2_MODE_IS_EXCLUDE:
1144                 case MLD2_CHANGE_TO_INCLUDE:
1145                 case MLD2_CHANGE_TO_EXCLUDE:
1146                 case MLD2_ALLOW_NEW_SOURCES:
1147                 case MLD2_BLOCK_OLD_SOURCES:
1148                         break;
1149
1150                 default:
1151                         continue;
1152                 }
1153
1154                 src = eth_hdr(skb)->h_source;
1155                 if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
1156                      grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
1157                     nsrcs == 0) {
1158                         br_ip6_multicast_leave_group(br, port, &grec->grec_mca,
1159                                                      vid, src);
1160                 } else {
1161                         err = br_ip6_multicast_add_group(br, port,
1162                                                          &grec->grec_mca, vid,
1163                                                          src, true);
1164                         if (err)
1165                                 break;
1166                 }
1167         }
1168
1169         return err;
1170 }
1171 #endif
1172
1173 static bool br_ip4_multicast_select_querier(struct net_bridge *br,
1174                                             struct net_bridge_port *port,
1175                                             __be32 saddr)
1176 {
1177         if (!timer_pending(&br->ip4_own_query.timer) &&
1178             !timer_pending(&br->ip4_other_query.timer))
1179                 goto update;
1180
1181         if (!br->ip4_querier.addr.u.ip4)
1182                 goto update;
1183
1184         if (ntohl(saddr) <= ntohl(br->ip4_querier.addr.u.ip4))
1185                 goto update;
1186
1187         return false;
1188
1189 update:
1190         br->ip4_querier.addr.u.ip4 = saddr;
1191
1192         /* update protected by general multicast_lock by caller */
1193         rcu_assign_pointer(br->ip4_querier.port, port);
1194
1195         return true;
1196 }
1197
1198 #if IS_ENABLED(CONFIG_IPV6)
1199 static bool br_ip6_multicast_select_querier(struct net_bridge *br,
1200                                             struct net_bridge_port *port,
1201                                             struct in6_addr *saddr)
1202 {
1203         if (!timer_pending(&br->ip6_own_query.timer) &&
1204             !timer_pending(&br->ip6_other_query.timer))
1205                 goto update;
1206
1207         if (ipv6_addr_cmp(saddr, &br->ip6_querier.addr.u.ip6) <= 0)
1208                 goto update;
1209
1210         return false;
1211
1212 update:
1213         br->ip6_querier.addr.u.ip6 = *saddr;
1214
1215         /* update protected by general multicast_lock by caller */
1216         rcu_assign_pointer(br->ip6_querier.port, port);
1217
1218         return true;
1219 }
1220 #endif
1221
1222 static bool br_multicast_select_querier(struct net_bridge *br,
1223                                         struct net_bridge_port *port,
1224                                         struct br_ip *saddr)
1225 {
1226         switch (saddr->proto) {
1227         case htons(ETH_P_IP):
1228                 return br_ip4_multicast_select_querier(br, port, saddr->u.ip4);
1229 #if IS_ENABLED(CONFIG_IPV6)
1230         case htons(ETH_P_IPV6):
1231                 return br_ip6_multicast_select_querier(br, port, &saddr->u.ip6);
1232 #endif
1233         }
1234
1235         return false;
1236 }
1237
1238 static void
1239 br_multicast_update_query_timer(struct net_bridge *br,
1240                                 struct bridge_mcast_other_query *query,
1241                                 unsigned long max_delay)
1242 {
1243         if (!timer_pending(&query->timer))
1244                 query->delay_time = jiffies + max_delay;
1245
1246         mod_timer(&query->timer, jiffies + br->multicast_querier_interval);
1247 }
1248
1249 static void br_port_mc_router_state_change(struct net_bridge_port *p,
1250                                            bool is_mc_router)
1251 {
1252         struct switchdev_attr attr = {
1253                 .orig_dev = p->dev,
1254                 .id = SWITCHDEV_ATTR_ID_PORT_MROUTER,
1255                 .flags = SWITCHDEV_F_DEFER,
1256                 .u.mrouter = is_mc_router,
1257         };
1258
1259         switchdev_port_attr_set(p->dev, &attr);
1260 }
1261
1262 /*
1263  * Add port to router_list
1264  *  list is maintained ordered by pointer value
1265  *  and locked by br->multicast_lock and RCU
1266  */
1267 static void br_multicast_add_router(struct net_bridge *br,
1268                                     struct net_bridge_port *port)
1269 {
1270         struct net_bridge_port *p;
1271         struct hlist_node *slot = NULL;
1272
1273         if (!hlist_unhashed(&port->rlist))
1274                 return;
1275
1276         hlist_for_each_entry(p, &br->router_list, rlist) {
1277                 if ((unsigned long) port >= (unsigned long) p)
1278                         break;
1279                 slot = &p->rlist;
1280         }
1281
1282         if (slot)
1283                 hlist_add_behind_rcu(&port->rlist, slot);
1284         else
1285                 hlist_add_head_rcu(&port->rlist, &br->router_list);
1286         br_rtr_notify(br->dev, port, RTM_NEWMDB);
1287         br_port_mc_router_state_change(port, true);
1288 }
1289
1290 static void br_multicast_mark_router(struct net_bridge *br,
1291                                      struct net_bridge_port *port)
1292 {
1293         unsigned long now = jiffies;
1294
1295         if (!port) {
1296                 if (br->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) {
1297                         if (!timer_pending(&br->multicast_router_timer))
1298                                 br_mc_router_state_change(br, true);
1299                         mod_timer(&br->multicast_router_timer,
1300                                   now + br->multicast_querier_interval);
1301                 }
1302                 return;
1303         }
1304
1305         if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
1306             port->multicast_router == MDB_RTR_TYPE_PERM)
1307                 return;
1308
1309         br_multicast_add_router(br, port);
1310
1311         mod_timer(&port->multicast_router_timer,
1312                   now + br->multicast_querier_interval);
1313 }
1314
1315 static void br_multicast_query_received(struct net_bridge *br,
1316                                         struct net_bridge_port *port,
1317                                         struct bridge_mcast_other_query *query,
1318                                         struct br_ip *saddr,
1319                                         unsigned long max_delay)
1320 {
1321         if (!br_multicast_select_querier(br, port, saddr))
1322                 return;
1323
1324         br_multicast_update_query_timer(br, query, max_delay);
1325         br_multicast_mark_router(br, port);
1326 }
1327
1328 static void br_ip4_multicast_query(struct net_bridge *br,
1329                                    struct net_bridge_port *port,
1330                                    struct sk_buff *skb,
1331                                    u16 vid)
1332 {
1333         unsigned int transport_len = ip_transport_len(skb);
1334         const struct iphdr *iph = ip_hdr(skb);
1335         struct igmphdr *ih = igmp_hdr(skb);
1336         struct net_bridge_mdb_entry *mp;
1337         struct igmpv3_query *ih3;
1338         struct net_bridge_port_group *p;
1339         struct net_bridge_port_group __rcu **pp;
1340         struct br_ip saddr;
1341         unsigned long max_delay;
1342         unsigned long now = jiffies;
1343         __be32 group;
1344
1345         spin_lock(&br->multicast_lock);
1346         if (!netif_running(br->dev) ||
1347             (port && port->state == BR_STATE_DISABLED))
1348                 goto out;
1349
1350         group = ih->group;
1351
1352         if (transport_len == sizeof(*ih)) {
1353                 max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
1354
1355                 if (!max_delay) {
1356                         max_delay = 10 * HZ;
1357                         group = 0;
1358                 }
1359         } else if (transport_len >= sizeof(*ih3)) {
1360                 ih3 = igmpv3_query_hdr(skb);
1361                 if (ih3->nsrcs)
1362                         goto out;
1363
1364                 max_delay = ih3->code ?
1365                             IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1;
1366         } else {
1367                 goto out;
1368         }
1369
1370         if (!group) {
1371                 saddr.proto = htons(ETH_P_IP);
1372                 saddr.u.ip4 = iph->saddr;
1373
1374                 br_multicast_query_received(br, port, &br->ip4_other_query,
1375                                             &saddr, max_delay);
1376                 goto out;
1377         }
1378
1379         mp = br_mdb_ip4_get(br, group, vid);
1380         if (!mp)
1381                 goto out;
1382
1383         max_delay *= br->multicast_last_member_count;
1384
1385         if (mp->host_joined &&
1386             (timer_pending(&mp->timer) ?
1387              time_after(mp->timer.expires, now + max_delay) :
1388              try_to_del_timer_sync(&mp->timer) >= 0))
1389                 mod_timer(&mp->timer, now + max_delay);
1390
1391         for (pp = &mp->ports;
1392              (p = mlock_dereference(*pp, br)) != NULL;
1393              pp = &p->next) {
1394                 if (timer_pending(&p->timer) ?
1395                     time_after(p->timer.expires, now + max_delay) :
1396                     try_to_del_timer_sync(&p->timer) >= 0)
1397                         mod_timer(&p->timer, now + max_delay);
1398         }
1399
1400 out:
1401         spin_unlock(&br->multicast_lock);
1402 }
1403
1404 #if IS_ENABLED(CONFIG_IPV6)
1405 static int br_ip6_multicast_query(struct net_bridge *br,
1406                                   struct net_bridge_port *port,
1407                                   struct sk_buff *skb,
1408                                   u16 vid)
1409 {
1410         unsigned int transport_len = ipv6_transport_len(skb);
1411         struct mld_msg *mld;
1412         struct net_bridge_mdb_entry *mp;
1413         struct mld2_query *mld2q;
1414         struct net_bridge_port_group *p;
1415         struct net_bridge_port_group __rcu **pp;
1416         struct br_ip saddr;
1417         unsigned long max_delay;
1418         unsigned long now = jiffies;
1419         unsigned int offset = skb_transport_offset(skb);
1420         const struct in6_addr *group = NULL;
1421         bool is_general_query;
1422         int err = 0;
1423
1424         spin_lock(&br->multicast_lock);
1425         if (!netif_running(br->dev) ||
1426             (port && port->state == BR_STATE_DISABLED))
1427                 goto out;
1428
1429         if (transport_len == sizeof(*mld)) {
1430                 if (!pskb_may_pull(skb, offset + sizeof(*mld))) {
1431                         err = -EINVAL;
1432                         goto out;
1433                 }
1434                 mld = (struct mld_msg *) icmp6_hdr(skb);
1435                 max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));
1436                 if (max_delay)
1437                         group = &mld->mld_mca;
1438         } else {
1439                 if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) {
1440                         err = -EINVAL;
1441                         goto out;
1442                 }
1443                 mld2q = (struct mld2_query *)icmp6_hdr(skb);
1444                 if (!mld2q->mld2q_nsrcs)
1445                         group = &mld2q->mld2q_mca;
1446
1447                 max_delay = max(msecs_to_jiffies(mldv2_mrc(mld2q)), 1UL);
1448         }
1449
1450         is_general_query = group && ipv6_addr_any(group);
1451
1452         if (is_general_query) {
1453                 saddr.proto = htons(ETH_P_IPV6);
1454                 saddr.u.ip6 = ipv6_hdr(skb)->saddr;
1455
1456                 br_multicast_query_received(br, port, &br->ip6_other_query,
1457                                             &saddr, max_delay);
1458                 goto out;
1459         } else if (!group) {
1460                 goto out;
1461         }
1462
1463         mp = br_mdb_ip6_get(br, group, vid);
1464         if (!mp)
1465                 goto out;
1466
1467         max_delay *= br->multicast_last_member_count;
1468         if (mp->host_joined &&
1469             (timer_pending(&mp->timer) ?
1470              time_after(mp->timer.expires, now + max_delay) :
1471              try_to_del_timer_sync(&mp->timer) >= 0))
1472                 mod_timer(&mp->timer, now + max_delay);
1473
1474         for (pp = &mp->ports;
1475              (p = mlock_dereference(*pp, br)) != NULL;
1476              pp = &p->next) {
1477                 if (timer_pending(&p->timer) ?
1478                     time_after(p->timer.expires, now + max_delay) :
1479                     try_to_del_timer_sync(&p->timer) >= 0)
1480                         mod_timer(&p->timer, now + max_delay);
1481         }
1482
1483 out:
1484         spin_unlock(&br->multicast_lock);
1485         return err;
1486 }
1487 #endif
1488
1489 static void
1490 br_multicast_leave_group(struct net_bridge *br,
1491                          struct net_bridge_port *port,
1492                          struct br_ip *group,
1493                          struct bridge_mcast_other_query *other_query,
1494                          struct bridge_mcast_own_query *own_query,
1495                          const unsigned char *src)
1496 {
1497         struct net_bridge_mdb_entry *mp;
1498         struct net_bridge_port_group *p;
1499         unsigned long now;
1500         unsigned long time;
1501
1502         spin_lock(&br->multicast_lock);
1503         if (!netif_running(br->dev) ||
1504             (port && port->state == BR_STATE_DISABLED))
1505                 goto out;
1506
1507         mp = br_mdb_ip_get(br, group);
1508         if (!mp)
1509                 goto out;
1510
1511         if (port && (port->flags & BR_MULTICAST_FAST_LEAVE)) {
1512                 struct net_bridge_port_group __rcu **pp;
1513
1514                 for (pp = &mp->ports;
1515                      (p = mlock_dereference(*pp, br)) != NULL;
1516                      pp = &p->next) {
1517                         if (!br_port_group_equal(p, port, src))
1518                                 continue;
1519
1520                         if (p->flags & MDB_PG_FLAGS_PERMANENT)
1521                                 break;
1522
1523                         p->flags |= MDB_PG_FLAGS_FAST_LEAVE;
1524                         br_multicast_del_pg(mp, p, pp);
1525                 }
1526                 goto out;
1527         }
1528
1529         if (timer_pending(&other_query->timer))
1530                 goto out;
1531
1532         if (br_opt_get(br, BROPT_MULTICAST_QUERIER)) {
1533                 __br_multicast_send_query(br, port, &mp->addr);
1534
1535                 time = jiffies + br->multicast_last_member_count *
1536                                  br->multicast_last_member_interval;
1537
1538                 mod_timer(&own_query->timer, time);
1539
1540                 for (p = mlock_dereference(mp->ports, br);
1541                      p != NULL;
1542                      p = mlock_dereference(p->next, br)) {
1543                         if (!br_port_group_equal(p, port, src))
1544                                 continue;
1545
1546                         if (!hlist_unhashed(&p->mglist) &&
1547                             (timer_pending(&p->timer) ?
1548                              time_after(p->timer.expires, time) :
1549                              try_to_del_timer_sync(&p->timer) >= 0)) {
1550                                 mod_timer(&p->timer, time);
1551                         }
1552
1553                         break;
1554                 }
1555         }
1556
1557         now = jiffies;
1558         time = now + br->multicast_last_member_count *
1559                      br->multicast_last_member_interval;
1560
1561         if (!port) {
1562                 if (mp->host_joined &&
1563                     (timer_pending(&mp->timer) ?
1564                      time_after(mp->timer.expires, time) :
1565                      try_to_del_timer_sync(&mp->timer) >= 0)) {
1566                         mod_timer(&mp->timer, time);
1567                 }
1568
1569                 goto out;
1570         }
1571
1572         for (p = mlock_dereference(mp->ports, br);
1573              p != NULL;
1574              p = mlock_dereference(p->next, br)) {
1575                 if (p->port != port)
1576                         continue;
1577
1578                 if (!hlist_unhashed(&p->mglist) &&
1579                     (timer_pending(&p->timer) ?
1580                      time_after(p->timer.expires, time) :
1581                      try_to_del_timer_sync(&p->timer) >= 0)) {
1582                         mod_timer(&p->timer, time);
1583                 }
1584
1585                 break;
1586         }
1587 out:
1588         spin_unlock(&br->multicast_lock);
1589 }
1590
1591 static void br_ip4_multicast_leave_group(struct net_bridge *br,
1592                                          struct net_bridge_port *port,
1593                                          __be32 group,
1594                                          __u16 vid,
1595                                          const unsigned char *src)
1596 {
1597         struct br_ip br_group;
1598         struct bridge_mcast_own_query *own_query;
1599
1600         if (ipv4_is_local_multicast(group))
1601                 return;
1602
1603         own_query = port ? &port->ip4_own_query : &br->ip4_own_query;
1604
1605         memset(&br_group, 0, sizeof(br_group));
1606         br_group.u.ip4 = group;
1607         br_group.proto = htons(ETH_P_IP);
1608         br_group.vid = vid;
1609
1610         br_multicast_leave_group(br, port, &br_group, &br->ip4_other_query,
1611                                  own_query, src);
1612 }
1613
1614 #if IS_ENABLED(CONFIG_IPV6)
1615 static void br_ip6_multicast_leave_group(struct net_bridge *br,
1616                                          struct net_bridge_port *port,
1617                                          const struct in6_addr *group,
1618                                          __u16 vid,
1619                                          const unsigned char *src)
1620 {
1621         struct br_ip br_group;
1622         struct bridge_mcast_own_query *own_query;
1623
1624         if (ipv6_addr_is_ll_all_nodes(group))
1625                 return;
1626
1627         own_query = port ? &port->ip6_own_query : &br->ip6_own_query;
1628
1629         memset(&br_group, 0, sizeof(br_group));
1630         br_group.u.ip6 = *group;
1631         br_group.proto = htons(ETH_P_IPV6);
1632         br_group.vid = vid;
1633
1634         br_multicast_leave_group(br, port, &br_group, &br->ip6_other_query,
1635                                  own_query, src);
1636 }
1637 #endif
1638
1639 static void br_multicast_err_count(const struct net_bridge *br,
1640                                    const struct net_bridge_port *p,
1641                                    __be16 proto)
1642 {
1643         struct bridge_mcast_stats __percpu *stats;
1644         struct bridge_mcast_stats *pstats;
1645
1646         if (!br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
1647                 return;
1648
1649         if (p)
1650                 stats = p->mcast_stats;
1651         else
1652                 stats = br->mcast_stats;
1653         if (WARN_ON(!stats))
1654                 return;
1655
1656         pstats = this_cpu_ptr(stats);
1657
1658         u64_stats_update_begin(&pstats->syncp);
1659         switch (proto) {
1660         case htons(ETH_P_IP):
1661                 pstats->mstats.igmp_parse_errors++;
1662                 break;
1663 #if IS_ENABLED(CONFIG_IPV6)
1664         case htons(ETH_P_IPV6):
1665                 pstats->mstats.mld_parse_errors++;
1666                 break;
1667 #endif
1668         }
1669         u64_stats_update_end(&pstats->syncp);
1670 }
1671
1672 static void br_multicast_pim(struct net_bridge *br,
1673                              struct net_bridge_port *port,
1674                              const struct sk_buff *skb)
1675 {
1676         unsigned int offset = skb_transport_offset(skb);
1677         struct pimhdr *pimhdr, _pimhdr;
1678
1679         pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr);
1680         if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION ||
1681             pim_hdr_type(pimhdr) != PIM_TYPE_HELLO)
1682                 return;
1683
1684         br_multicast_mark_router(br, port);
1685 }
1686
1687 static int br_ip4_multicast_mrd_rcv(struct net_bridge *br,
1688                                     struct net_bridge_port *port,
1689                                     struct sk_buff *skb)
1690 {
1691         if (ip_hdr(skb)->protocol != IPPROTO_IGMP ||
1692             igmp_hdr(skb)->type != IGMP_MRDISC_ADV)
1693                 return -ENOMSG;
1694
1695         br_multicast_mark_router(br, port);
1696
1697         return 0;
1698 }
1699
1700 static int br_multicast_ipv4_rcv(struct net_bridge *br,
1701                                  struct net_bridge_port *port,
1702                                  struct sk_buff *skb,
1703                                  u16 vid)
1704 {
1705         const unsigned char *src;
1706         struct igmphdr *ih;
1707         int err;
1708
1709         err = ip_mc_check_igmp(skb);
1710
1711         if (err == -ENOMSG) {
1712                 if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) {
1713                         BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
1714                 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) {
1715                         if (ip_hdr(skb)->protocol == IPPROTO_PIM)
1716                                 br_multicast_pim(br, port, skb);
1717                 } else if (ipv4_is_all_snoopers(ip_hdr(skb)->daddr)) {
1718                         br_ip4_multicast_mrd_rcv(br, port, skb);
1719                 }
1720
1721                 return 0;
1722         } else if (err < 0) {
1723                 br_multicast_err_count(br, port, skb->protocol);
1724                 return err;
1725         }
1726
1727         ih = igmp_hdr(skb);
1728         src = eth_hdr(skb)->h_source;
1729         BR_INPUT_SKB_CB(skb)->igmp = ih->type;
1730
1731         switch (ih->type) {
1732         case IGMP_HOST_MEMBERSHIP_REPORT:
1733         case IGMPV2_HOST_MEMBERSHIP_REPORT:
1734                 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
1735                 err = br_ip4_multicast_add_group(br, port, ih->group, vid, src,
1736                                                  true);
1737                 break;
1738         case IGMPV3_HOST_MEMBERSHIP_REPORT:
1739                 err = br_ip4_multicast_igmp3_report(br, port, skb, vid);
1740                 break;
1741         case IGMP_HOST_MEMBERSHIP_QUERY:
1742                 br_ip4_multicast_query(br, port, skb, vid);
1743                 break;
1744         case IGMP_HOST_LEAVE_MESSAGE:
1745                 br_ip4_multicast_leave_group(br, port, ih->group, vid, src);
1746                 break;
1747         }
1748
1749         br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
1750                            BR_MCAST_DIR_RX);
1751
1752         return err;
1753 }
1754
1755 #if IS_ENABLED(CONFIG_IPV6)
1756 static int br_ip6_multicast_mrd_rcv(struct net_bridge *br,
1757                                     struct net_bridge_port *port,
1758                                     struct sk_buff *skb)
1759 {
1760         int ret;
1761
1762         if (ipv6_hdr(skb)->nexthdr != IPPROTO_ICMPV6)
1763                 return -ENOMSG;
1764
1765         ret = ipv6_mc_check_icmpv6(skb);
1766         if (ret < 0)
1767                 return ret;
1768
1769         if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV)
1770                 return -ENOMSG;
1771
1772         br_multicast_mark_router(br, port);
1773
1774         return 0;
1775 }
1776
1777 static int br_multicast_ipv6_rcv(struct net_bridge *br,
1778                                  struct net_bridge_port *port,
1779                                  struct sk_buff *skb,
1780                                  u16 vid)
1781 {
1782         const unsigned char *src;
1783         struct mld_msg *mld;
1784         int err;
1785
1786         err = ipv6_mc_check_mld(skb);
1787
1788         if (err == -ENOMSG) {
1789                 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr))
1790                         BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
1791
1792                 if (ipv6_addr_is_all_snoopers(&ipv6_hdr(skb)->daddr)) {
1793                         err = br_ip6_multicast_mrd_rcv(br, port, skb);
1794
1795                         if (err < 0 && err != -ENOMSG) {
1796                                 br_multicast_err_count(br, port, skb->protocol);
1797                                 return err;
1798                         }
1799                 }
1800
1801                 return 0;
1802         } else if (err < 0) {
1803                 br_multicast_err_count(br, port, skb->protocol);
1804                 return err;
1805         }
1806
1807         mld = (struct mld_msg *)skb_transport_header(skb);
1808         BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type;
1809
1810         switch (mld->mld_type) {
1811         case ICMPV6_MGM_REPORT:
1812                 src = eth_hdr(skb)->h_source;
1813                 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
1814                 err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid,
1815                                                  src, true);
1816                 break;
1817         case ICMPV6_MLD2_REPORT:
1818                 err = br_ip6_multicast_mld2_report(br, port, skb, vid);
1819                 break;
1820         case ICMPV6_MGM_QUERY:
1821                 err = br_ip6_multicast_query(br, port, skb, vid);
1822                 break;
1823         case ICMPV6_MGM_REDUCTION:
1824                 src = eth_hdr(skb)->h_source;
1825                 br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid, src);
1826                 break;
1827         }
1828
1829         br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
1830                            BR_MCAST_DIR_RX);
1831
1832         return err;
1833 }
1834 #endif
1835
1836 int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
1837                      struct sk_buff *skb, u16 vid)
1838 {
1839         int ret = 0;
1840
1841         BR_INPUT_SKB_CB(skb)->igmp = 0;
1842         BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
1843
1844         if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
1845                 return 0;
1846
1847         switch (skb->protocol) {
1848         case htons(ETH_P_IP):
1849                 ret = br_multicast_ipv4_rcv(br, port, skb, vid);
1850                 break;
1851 #if IS_ENABLED(CONFIG_IPV6)
1852         case htons(ETH_P_IPV6):
1853                 ret = br_multicast_ipv6_rcv(br, port, skb, vid);
1854                 break;
1855 #endif
1856         }
1857
1858         return ret;
1859 }
1860
1861 static void br_multicast_query_expired(struct net_bridge *br,
1862                                        struct bridge_mcast_own_query *query,
1863                                        struct bridge_mcast_querier *querier)
1864 {
1865         spin_lock(&br->multicast_lock);
1866         if (query->startup_sent < br->multicast_startup_query_count)
1867                 query->startup_sent++;
1868
1869         RCU_INIT_POINTER(querier->port, NULL);
1870         br_multicast_send_query(br, NULL, query);
1871         spin_unlock(&br->multicast_lock);
1872 }
1873
1874 static void br_ip4_multicast_query_expired(struct timer_list *t)
1875 {
1876         struct net_bridge *br = from_timer(br, t, ip4_own_query.timer);
1877
1878         br_multicast_query_expired(br, &br->ip4_own_query, &br->ip4_querier);
1879 }
1880
1881 #if IS_ENABLED(CONFIG_IPV6)
1882 static void br_ip6_multicast_query_expired(struct timer_list *t)
1883 {
1884         struct net_bridge *br = from_timer(br, t, ip6_own_query.timer);
1885
1886         br_multicast_query_expired(br, &br->ip6_own_query, &br->ip6_querier);
1887 }
1888 #endif
1889
1890 static void __grp_src_gc(struct hlist_head *head)
1891 {
1892         struct net_bridge_group_src *ent;
1893         struct hlist_node *tmp;
1894
1895         hlist_for_each_entry_safe(ent, tmp, head, del_node) {
1896                 hlist_del_init(&ent->del_node);
1897                 del_timer_sync(&ent->timer);
1898                 kfree_rcu(ent, rcu);
1899         }
1900 }
1901
1902 static void br_multicast_src_gc(struct work_struct *work)
1903 {
1904         struct net_bridge *br = container_of(work, struct net_bridge,
1905                                              src_gc_work);
1906         HLIST_HEAD(deleted_head);
1907
1908         spin_lock_bh(&br->multicast_lock);
1909         hlist_move_list(&br->src_gc_list, &deleted_head);
1910         spin_unlock_bh(&br->multicast_lock);
1911
1912         __grp_src_gc(&deleted_head);
1913 }
1914
1915 void br_multicast_init(struct net_bridge *br)
1916 {
1917         br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX;
1918
1919         br->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
1920         br->multicast_last_member_count = 2;
1921         br->multicast_startup_query_count = 2;
1922
1923         br->multicast_last_member_interval = HZ;
1924         br->multicast_query_response_interval = 10 * HZ;
1925         br->multicast_startup_query_interval = 125 * HZ / 4;
1926         br->multicast_query_interval = 125 * HZ;
1927         br->multicast_querier_interval = 255 * HZ;
1928         br->multicast_membership_interval = 260 * HZ;
1929
1930         br->ip4_other_query.delay_time = 0;
1931         br->ip4_querier.port = NULL;
1932         br->multicast_igmp_version = 2;
1933 #if IS_ENABLED(CONFIG_IPV6)
1934         br->multicast_mld_version = 1;
1935         br->ip6_other_query.delay_time = 0;
1936         br->ip6_querier.port = NULL;
1937 #endif
1938         br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true);
1939         br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
1940
1941         spin_lock_init(&br->multicast_lock);
1942         timer_setup(&br->multicast_router_timer,
1943                     br_multicast_local_router_expired, 0);
1944         timer_setup(&br->ip4_other_query.timer,
1945                     br_ip4_multicast_querier_expired, 0);
1946         timer_setup(&br->ip4_own_query.timer,
1947                     br_ip4_multicast_query_expired, 0);
1948 #if IS_ENABLED(CONFIG_IPV6)
1949         timer_setup(&br->ip6_other_query.timer,
1950                     br_ip6_multicast_querier_expired, 0);
1951         timer_setup(&br->ip6_own_query.timer,
1952                     br_ip6_multicast_query_expired, 0);
1953 #endif
1954         INIT_HLIST_HEAD(&br->mdb_list);
1955         INIT_HLIST_HEAD(&br->src_gc_list);
1956         INIT_WORK(&br->src_gc_work, br_multicast_src_gc);
1957 }
1958
1959 static void br_ip4_multicast_join_snoopers(struct net_bridge *br)
1960 {
1961         struct in_device *in_dev = in_dev_get(br->dev);
1962
1963         if (!in_dev)
1964                 return;
1965
1966         __ip_mc_inc_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC);
1967         in_dev_put(in_dev);
1968 }
1969
1970 #if IS_ENABLED(CONFIG_IPV6)
1971 static void br_ip6_multicast_join_snoopers(struct net_bridge *br)
1972 {
1973         struct in6_addr addr;
1974
1975         ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a));
1976         ipv6_dev_mc_inc(br->dev, &addr);
1977 }
1978 #else
1979 static inline void br_ip6_multicast_join_snoopers(struct net_bridge *br)
1980 {
1981 }
1982 #endif
1983
1984 static void br_multicast_join_snoopers(struct net_bridge *br)
1985 {
1986         br_ip4_multicast_join_snoopers(br);
1987         br_ip6_multicast_join_snoopers(br);
1988 }
1989
1990 static void br_ip4_multicast_leave_snoopers(struct net_bridge *br)
1991 {
1992         struct in_device *in_dev = in_dev_get(br->dev);
1993
1994         if (WARN_ON(!in_dev))
1995                 return;
1996
1997         __ip_mc_dec_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC);
1998         in_dev_put(in_dev);
1999 }
2000
2001 #if IS_ENABLED(CONFIG_IPV6)
2002 static void br_ip6_multicast_leave_snoopers(struct net_bridge *br)
2003 {
2004         struct in6_addr addr;
2005
2006         ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a));
2007         ipv6_dev_mc_dec(br->dev, &addr);
2008 }
2009 #else
2010 static inline void br_ip6_multicast_leave_snoopers(struct net_bridge *br)
2011 {
2012 }
2013 #endif
2014
2015 static void br_multicast_leave_snoopers(struct net_bridge *br)
2016 {
2017         br_ip4_multicast_leave_snoopers(br);
2018         br_ip6_multicast_leave_snoopers(br);
2019 }
2020
2021 static void __br_multicast_open(struct net_bridge *br,
2022                                 struct bridge_mcast_own_query *query)
2023 {
2024         query->startup_sent = 0;
2025
2026         if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
2027                 return;
2028
2029         mod_timer(&query->timer, jiffies);
2030 }
2031
2032 void br_multicast_open(struct net_bridge *br)
2033 {
2034         if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
2035                 br_multicast_join_snoopers(br);
2036
2037         __br_multicast_open(br, &br->ip4_own_query);
2038 #if IS_ENABLED(CONFIG_IPV6)
2039         __br_multicast_open(br, &br->ip6_own_query);
2040 #endif
2041 }
2042
2043 void br_multicast_stop(struct net_bridge *br)
2044 {
2045         del_timer_sync(&br->multicast_router_timer);
2046         del_timer_sync(&br->ip4_other_query.timer);
2047         del_timer_sync(&br->ip4_own_query.timer);
2048 #if IS_ENABLED(CONFIG_IPV6)
2049         del_timer_sync(&br->ip6_other_query.timer);
2050         del_timer_sync(&br->ip6_own_query.timer);
2051 #endif
2052
2053         if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
2054                 br_multicast_leave_snoopers(br);
2055 }
2056
2057 void br_multicast_dev_del(struct net_bridge *br)
2058 {
2059         struct net_bridge_mdb_entry *mp;
2060         HLIST_HEAD(deleted_head);
2061         struct hlist_node *tmp;
2062
2063         spin_lock_bh(&br->multicast_lock);
2064         hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node) {
2065                 del_timer(&mp->timer);
2066                 rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode,
2067                                        br_mdb_rht_params);
2068                 hlist_del_rcu(&mp->mdb_node);
2069                 kfree_rcu(mp, rcu);
2070         }
2071         hlist_move_list(&br->src_gc_list, &deleted_head);
2072         spin_unlock_bh(&br->multicast_lock);
2073
2074         __grp_src_gc(&deleted_head);
2075         cancel_work_sync(&br->src_gc_work);
2076
2077         rcu_barrier();
2078 }
2079
2080 int br_multicast_set_router(struct net_bridge *br, unsigned long val)
2081 {
2082         int err = -EINVAL;
2083
2084         spin_lock_bh(&br->multicast_lock);
2085
2086         switch (val) {
2087         case MDB_RTR_TYPE_DISABLED:
2088         case MDB_RTR_TYPE_PERM:
2089                 br_mc_router_state_change(br, val == MDB_RTR_TYPE_PERM);
2090                 del_timer(&br->multicast_router_timer);
2091                 br->multicast_router = val;
2092                 err = 0;
2093                 break;
2094         case MDB_RTR_TYPE_TEMP_QUERY:
2095                 if (br->multicast_router != MDB_RTR_TYPE_TEMP_QUERY)
2096                         br_mc_router_state_change(br, false);
2097                 br->multicast_router = val;
2098                 err = 0;
2099                 break;
2100         }
2101
2102         spin_unlock_bh(&br->multicast_lock);
2103
2104         return err;
2105 }
2106
2107 static void __del_port_router(struct net_bridge_port *p)
2108 {
2109         if (hlist_unhashed(&p->rlist))
2110                 return;
2111         hlist_del_init_rcu(&p->rlist);
2112         br_rtr_notify(p->br->dev, p, RTM_DELMDB);
2113         br_port_mc_router_state_change(p, false);
2114
2115         /* don't allow timer refresh */
2116         if (p->multicast_router == MDB_RTR_TYPE_TEMP)
2117                 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
2118 }
2119
2120 int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val)
2121 {
2122         struct net_bridge *br = p->br;
2123         unsigned long now = jiffies;
2124         int err = -EINVAL;
2125
2126         spin_lock(&br->multicast_lock);
2127         if (p->multicast_router == val) {
2128                 /* Refresh the temp router port timer */
2129                 if (p->multicast_router == MDB_RTR_TYPE_TEMP)
2130                         mod_timer(&p->multicast_router_timer,
2131                                   now + br->multicast_querier_interval);
2132                 err = 0;
2133                 goto unlock;
2134         }
2135         switch (val) {
2136         case MDB_RTR_TYPE_DISABLED:
2137                 p->multicast_router = MDB_RTR_TYPE_DISABLED;
2138                 __del_port_router(p);
2139                 del_timer(&p->multicast_router_timer);
2140                 break;
2141         case MDB_RTR_TYPE_TEMP_QUERY:
2142                 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
2143                 __del_port_router(p);
2144                 break;
2145         case MDB_RTR_TYPE_PERM:
2146                 p->multicast_router = MDB_RTR_TYPE_PERM;
2147                 del_timer(&p->multicast_router_timer);
2148                 br_multicast_add_router(br, p);
2149                 break;
2150         case MDB_RTR_TYPE_TEMP:
2151                 p->multicast_router = MDB_RTR_TYPE_TEMP;
2152                 br_multicast_mark_router(br, p);
2153                 break;
2154         default:
2155                 goto unlock;
2156         }
2157         err = 0;
2158 unlock:
2159         spin_unlock(&br->multicast_lock);
2160
2161         return err;
2162 }
2163
2164 static void br_multicast_start_querier(struct net_bridge *br,
2165                                        struct bridge_mcast_own_query *query)
2166 {
2167         struct net_bridge_port *port;
2168
2169         __br_multicast_open(br, query);
2170
2171         rcu_read_lock();
2172         list_for_each_entry_rcu(port, &br->port_list, list) {
2173                 if (port->state == BR_STATE_DISABLED ||
2174                     port->state == BR_STATE_BLOCKING)
2175                         continue;
2176
2177                 if (query == &br->ip4_own_query)
2178                         br_multicast_enable(&port->ip4_own_query);
2179 #if IS_ENABLED(CONFIG_IPV6)
2180                 else
2181                         br_multicast_enable(&port->ip6_own_query);
2182 #endif
2183         }
2184         rcu_read_unlock();
2185 }
2186
2187 int br_multicast_toggle(struct net_bridge *br, unsigned long val)
2188 {
2189         struct net_bridge_port *port;
2190
2191         spin_lock_bh(&br->multicast_lock);
2192         if (!!br_opt_get(br, BROPT_MULTICAST_ENABLED) == !!val)
2193                 goto unlock;
2194
2195         br_mc_disabled_update(br->dev, val);
2196         br_opt_toggle(br, BROPT_MULTICAST_ENABLED, !!val);
2197         if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) {
2198                 br_multicast_leave_snoopers(br);
2199                 goto unlock;
2200         }
2201
2202         if (!netif_running(br->dev))
2203                 goto unlock;
2204
2205         br_multicast_open(br);
2206         list_for_each_entry(port, &br->port_list, list)
2207                 __br_multicast_enable_port(port);
2208
2209 unlock:
2210         spin_unlock_bh(&br->multicast_lock);
2211
2212         return 0;
2213 }
2214
2215 bool br_multicast_enabled(const struct net_device *dev)
2216 {
2217         struct net_bridge *br = netdev_priv(dev);
2218
2219         return !!br_opt_get(br, BROPT_MULTICAST_ENABLED);
2220 }
2221 EXPORT_SYMBOL_GPL(br_multicast_enabled);
2222
2223 bool br_multicast_router(const struct net_device *dev)
2224 {
2225         struct net_bridge *br = netdev_priv(dev);
2226         bool is_router;
2227
2228         spin_lock_bh(&br->multicast_lock);
2229         is_router = br_multicast_is_router(br);
2230         spin_unlock_bh(&br->multicast_lock);
2231         return is_router;
2232 }
2233 EXPORT_SYMBOL_GPL(br_multicast_router);
2234
2235 int br_multicast_set_querier(struct net_bridge *br, unsigned long val)
2236 {
2237         unsigned long max_delay;
2238
2239         val = !!val;
2240
2241         spin_lock_bh(&br->multicast_lock);
2242         if (br_opt_get(br, BROPT_MULTICAST_QUERIER) == val)
2243                 goto unlock;
2244
2245         br_opt_toggle(br, BROPT_MULTICAST_QUERIER, !!val);
2246         if (!val)
2247                 goto unlock;
2248
2249         max_delay = br->multicast_query_response_interval;
2250
2251         if (!timer_pending(&br->ip4_other_query.timer))
2252                 br->ip4_other_query.delay_time = jiffies + max_delay;
2253
2254         br_multicast_start_querier(br, &br->ip4_own_query);
2255
2256 #if IS_ENABLED(CONFIG_IPV6)
2257         if (!timer_pending(&br->ip6_other_query.timer))
2258                 br->ip6_other_query.delay_time = jiffies + max_delay;
2259
2260         br_multicast_start_querier(br, &br->ip6_own_query);
2261 #endif
2262
2263 unlock:
2264         spin_unlock_bh(&br->multicast_lock);
2265
2266         return 0;
2267 }
2268
2269 int br_multicast_set_igmp_version(struct net_bridge *br, unsigned long val)
2270 {
2271         /* Currently we support only version 2 and 3 */
2272         switch (val) {
2273         case 2:
2274         case 3:
2275                 break;
2276         default:
2277                 return -EINVAL;
2278         }
2279
2280         spin_lock_bh(&br->multicast_lock);
2281         br->multicast_igmp_version = val;
2282         spin_unlock_bh(&br->multicast_lock);
2283
2284         return 0;
2285 }
2286
2287 #if IS_ENABLED(CONFIG_IPV6)
2288 int br_multicast_set_mld_version(struct net_bridge *br, unsigned long val)
2289 {
2290         /* Currently we support version 1 and 2 */
2291         switch (val) {
2292         case 1:
2293         case 2:
2294                 break;
2295         default:
2296                 return -EINVAL;
2297         }
2298
2299         spin_lock_bh(&br->multicast_lock);
2300         br->multicast_mld_version = val;
2301         spin_unlock_bh(&br->multicast_lock);
2302
2303         return 0;
2304 }
2305 #endif
2306
2307 /**
2308  * br_multicast_list_adjacent - Returns snooped multicast addresses
2309  * @dev:        The bridge port adjacent to which to retrieve addresses
2310  * @br_ip_list: The list to store found, snooped multicast IP addresses in
2311  *
2312  * Creates a list of IP addresses (struct br_ip_list) sensed by the multicast
2313  * snooping feature on all bridge ports of dev's bridge device, excluding
2314  * the addresses from dev itself.
2315  *
2316  * Returns the number of items added to br_ip_list.
2317  *
2318  * Notes:
2319  * - br_ip_list needs to be initialized by caller
2320  * - br_ip_list might contain duplicates in the end
2321  *   (needs to be taken care of by caller)
2322  * - br_ip_list needs to be freed by caller
2323  */
2324 int br_multicast_list_adjacent(struct net_device *dev,
2325                                struct list_head *br_ip_list)
2326 {
2327         struct net_bridge *br;
2328         struct net_bridge_port *port;
2329         struct net_bridge_port_group *group;
2330         struct br_ip_list *entry;
2331         int count = 0;
2332
2333         rcu_read_lock();
2334         if (!br_ip_list || !netif_is_bridge_port(dev))
2335                 goto unlock;
2336
2337         port = br_port_get_rcu(dev);
2338         if (!port || !port->br)
2339                 goto unlock;
2340
2341         br = port->br;
2342
2343         list_for_each_entry_rcu(port, &br->port_list, list) {
2344                 if (!port->dev || port->dev == dev)
2345                         continue;
2346
2347                 hlist_for_each_entry_rcu(group, &port->mglist, mglist) {
2348                         entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
2349                         if (!entry)
2350                                 goto unlock;
2351
2352                         entry->addr = group->addr;
2353                         list_add(&entry->list, br_ip_list);
2354                         count++;
2355                 }
2356         }
2357
2358 unlock:
2359         rcu_read_unlock();
2360         return count;
2361 }
2362 EXPORT_SYMBOL_GPL(br_multicast_list_adjacent);
2363
2364 /**
2365  * br_multicast_has_querier_anywhere - Checks for a querier on a bridge
2366  * @dev: The bridge port providing the bridge on which to check for a querier
2367  * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
2368  *
2369  * Checks whether the given interface has a bridge on top and if so returns
2370  * true if a valid querier exists anywhere on the bridged link layer.
2371  * Otherwise returns false.
2372  */
2373 bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto)
2374 {
2375         struct net_bridge *br;
2376         struct net_bridge_port *port;
2377         struct ethhdr eth;
2378         bool ret = false;
2379
2380         rcu_read_lock();
2381         if (!netif_is_bridge_port(dev))
2382                 goto unlock;
2383
2384         port = br_port_get_rcu(dev);
2385         if (!port || !port->br)
2386                 goto unlock;
2387
2388         br = port->br;
2389
2390         memset(&eth, 0, sizeof(eth));
2391         eth.h_proto = htons(proto);
2392
2393         ret = br_multicast_querier_exists(br, &eth);
2394
2395 unlock:
2396         rcu_read_unlock();
2397         return ret;
2398 }
2399 EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere);
2400
2401 /**
2402  * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
2403  * @dev: The bridge port adjacent to which to check for a querier
2404  * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
2405  *
2406  * Checks whether the given interface has a bridge on top and if so returns
2407  * true if a selected querier is behind one of the other ports of this
2408  * bridge. Otherwise returns false.
2409  */
2410 bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto)
2411 {
2412         struct net_bridge *br;
2413         struct net_bridge_port *port;
2414         bool ret = false;
2415
2416         rcu_read_lock();
2417         if (!netif_is_bridge_port(dev))
2418                 goto unlock;
2419
2420         port = br_port_get_rcu(dev);
2421         if (!port || !port->br)
2422                 goto unlock;
2423
2424         br = port->br;
2425
2426         switch (proto) {
2427         case ETH_P_IP:
2428                 if (!timer_pending(&br->ip4_other_query.timer) ||
2429                     rcu_dereference(br->ip4_querier.port) == port)
2430                         goto unlock;
2431                 break;
2432 #if IS_ENABLED(CONFIG_IPV6)
2433         case ETH_P_IPV6:
2434                 if (!timer_pending(&br->ip6_other_query.timer) ||
2435                     rcu_dereference(br->ip6_querier.port) == port)
2436                         goto unlock;
2437                 break;
2438 #endif
2439         default:
2440                 goto unlock;
2441         }
2442
2443         ret = true;
2444 unlock:
2445         rcu_read_unlock();
2446         return ret;
2447 }
2448 EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent);
2449
2450 static void br_mcast_stats_add(struct bridge_mcast_stats __percpu *stats,
2451                                const struct sk_buff *skb, u8 type, u8 dir)
2452 {
2453         struct bridge_mcast_stats *pstats = this_cpu_ptr(stats);
2454         __be16 proto = skb->protocol;
2455         unsigned int t_len;
2456
2457         u64_stats_update_begin(&pstats->syncp);
2458         switch (proto) {
2459         case htons(ETH_P_IP):
2460                 t_len = ntohs(ip_hdr(skb)->tot_len) - ip_hdrlen(skb);
2461                 switch (type) {
2462                 case IGMP_HOST_MEMBERSHIP_REPORT:
2463                         pstats->mstats.igmp_v1reports[dir]++;
2464                         break;
2465                 case IGMPV2_HOST_MEMBERSHIP_REPORT:
2466                         pstats->mstats.igmp_v2reports[dir]++;
2467                         break;
2468                 case IGMPV3_HOST_MEMBERSHIP_REPORT:
2469                         pstats->mstats.igmp_v3reports[dir]++;
2470                         break;
2471                 case IGMP_HOST_MEMBERSHIP_QUERY:
2472                         if (t_len != sizeof(struct igmphdr)) {
2473                                 pstats->mstats.igmp_v3queries[dir]++;
2474                         } else {
2475                                 unsigned int offset = skb_transport_offset(skb);
2476                                 struct igmphdr *ih, _ihdr;
2477
2478                                 ih = skb_header_pointer(skb, offset,
2479                                                         sizeof(_ihdr), &_ihdr);
2480                                 if (!ih)
2481                                         break;
2482                                 if (!ih->code)
2483                                         pstats->mstats.igmp_v1queries[dir]++;
2484                                 else
2485                                         pstats->mstats.igmp_v2queries[dir]++;
2486                         }
2487                         break;
2488                 case IGMP_HOST_LEAVE_MESSAGE:
2489                         pstats->mstats.igmp_leaves[dir]++;
2490                         break;
2491                 }
2492                 break;
2493 #if IS_ENABLED(CONFIG_IPV6)
2494         case htons(ETH_P_IPV6):
2495                 t_len = ntohs(ipv6_hdr(skb)->payload_len) +
2496                         sizeof(struct ipv6hdr);
2497                 t_len -= skb_network_header_len(skb);
2498                 switch (type) {
2499                 case ICMPV6_MGM_REPORT:
2500                         pstats->mstats.mld_v1reports[dir]++;
2501                         break;
2502                 case ICMPV6_MLD2_REPORT:
2503                         pstats->mstats.mld_v2reports[dir]++;
2504                         break;
2505                 case ICMPV6_MGM_QUERY:
2506                         if (t_len != sizeof(struct mld_msg))
2507                                 pstats->mstats.mld_v2queries[dir]++;
2508                         else
2509                                 pstats->mstats.mld_v1queries[dir]++;
2510                         break;
2511                 case ICMPV6_MGM_REDUCTION:
2512                         pstats->mstats.mld_leaves[dir]++;
2513                         break;
2514                 }
2515                 break;
2516 #endif /* CONFIG_IPV6 */
2517         }
2518         u64_stats_update_end(&pstats->syncp);
2519 }
2520
2521 void br_multicast_count(struct net_bridge *br, const struct net_bridge_port *p,
2522                         const struct sk_buff *skb, u8 type, u8 dir)
2523 {
2524         struct bridge_mcast_stats __percpu *stats;
2525
2526         /* if multicast_disabled is true then igmp type can't be set */
2527         if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
2528                 return;
2529
2530         if (p)
2531                 stats = p->mcast_stats;
2532         else
2533                 stats = br->mcast_stats;
2534         if (WARN_ON(!stats))
2535                 return;
2536
2537         br_mcast_stats_add(stats, skb, type, dir);
2538 }
2539
2540 int br_multicast_init_stats(struct net_bridge *br)
2541 {
2542         br->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
2543         if (!br->mcast_stats)
2544                 return -ENOMEM;
2545
2546         return 0;
2547 }
2548
2549 void br_multicast_uninit_stats(struct net_bridge *br)
2550 {
2551         free_percpu(br->mcast_stats);
2552 }
2553
2554 /* noinline for https://bugs.llvm.org/show_bug.cgi?id=45802#c9 */
2555 static noinline_for_stack void mcast_stats_add_dir(u64 *dst, u64 *src)
2556 {
2557         dst[BR_MCAST_DIR_RX] += src[BR_MCAST_DIR_RX];
2558         dst[BR_MCAST_DIR_TX] += src[BR_MCAST_DIR_TX];
2559 }
2560
2561 void br_multicast_get_stats(const struct net_bridge *br,
2562                             const struct net_bridge_port *p,
2563                             struct br_mcast_stats *dest)
2564 {
2565         struct bridge_mcast_stats __percpu *stats;
2566         struct br_mcast_stats tdst;
2567         int i;
2568
2569         memset(dest, 0, sizeof(*dest));
2570         if (p)
2571                 stats = p->mcast_stats;
2572         else
2573                 stats = br->mcast_stats;
2574         if (WARN_ON(!stats))
2575                 return;
2576
2577         memset(&tdst, 0, sizeof(tdst));
2578         for_each_possible_cpu(i) {
2579                 struct bridge_mcast_stats *cpu_stats = per_cpu_ptr(stats, i);
2580                 struct br_mcast_stats temp;
2581                 unsigned int start;
2582
2583                 do {
2584                         start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
2585                         memcpy(&temp, &cpu_stats->mstats, sizeof(temp));
2586                 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
2587
2588                 mcast_stats_add_dir(tdst.igmp_v1queries, temp.igmp_v1queries);
2589                 mcast_stats_add_dir(tdst.igmp_v2queries, temp.igmp_v2queries);
2590                 mcast_stats_add_dir(tdst.igmp_v3queries, temp.igmp_v3queries);
2591                 mcast_stats_add_dir(tdst.igmp_leaves, temp.igmp_leaves);
2592                 mcast_stats_add_dir(tdst.igmp_v1reports, temp.igmp_v1reports);
2593                 mcast_stats_add_dir(tdst.igmp_v2reports, temp.igmp_v2reports);
2594                 mcast_stats_add_dir(tdst.igmp_v3reports, temp.igmp_v3reports);
2595                 tdst.igmp_parse_errors += temp.igmp_parse_errors;
2596
2597                 mcast_stats_add_dir(tdst.mld_v1queries, temp.mld_v1queries);
2598                 mcast_stats_add_dir(tdst.mld_v2queries, temp.mld_v2queries);
2599                 mcast_stats_add_dir(tdst.mld_leaves, temp.mld_leaves);
2600                 mcast_stats_add_dir(tdst.mld_v1reports, temp.mld_v1reports);
2601                 mcast_stats_add_dir(tdst.mld_v2reports, temp.mld_v2reports);
2602                 tdst.mld_parse_errors += temp.mld_parse_errors;
2603         }
2604         memcpy(dest, &tdst, sizeof(*dest));
2605 }
2606
2607 int br_mdb_hash_init(struct net_bridge *br)
2608 {
2609         return rhashtable_init(&br->mdb_hash_tbl, &br_mdb_rht_params);
2610 }
2611
2612 void br_mdb_hash_fini(struct net_bridge *br)
2613 {
2614         rhashtable_destroy(&br->mdb_hash_tbl);
2615 }