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 static void br_multicast_port_group_rexmit(struct timer_list *t); 54 55 static void __del_port_router(struct net_bridge_port *p); 56 #if IS_ENABLED(CONFIG_IPV6) 57 static void br_ip6_multicast_leave_group(struct net_bridge *br, 58 struct net_bridge_port *port, 59 const struct in6_addr *group, 60 __u16 vid, const unsigned char *src); 61 #endif 62 63 static struct net_bridge_mdb_entry *br_mdb_ip_get_rcu(struct net_bridge *br, 64 struct br_ip *dst) 65 { 66 return rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params); 67 } 68 69 struct net_bridge_mdb_entry *br_mdb_ip_get(struct net_bridge *br, 70 struct br_ip *dst) 71 { 72 struct net_bridge_mdb_entry *ent; 73 74 lockdep_assert_held_once(&br->multicast_lock); 75 76 rcu_read_lock(); 77 ent = rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params); 78 rcu_read_unlock(); 79 80 return ent; 81 } 82 83 static struct net_bridge_mdb_entry *br_mdb_ip4_get(struct net_bridge *br, 84 __be32 dst, __u16 vid) 85 { 86 struct br_ip br_dst; 87 88 memset(&br_dst, 0, sizeof(br_dst)); 89 br_dst.u.ip4 = dst; 90 br_dst.proto = htons(ETH_P_IP); 91 br_dst.vid = vid; 92 93 return br_mdb_ip_get(br, &br_dst); 94 } 95 96 #if IS_ENABLED(CONFIG_IPV6) 97 static struct net_bridge_mdb_entry *br_mdb_ip6_get(struct net_bridge *br, 98 const struct in6_addr *dst, 99 __u16 vid) 100 { 101 struct br_ip br_dst; 102 103 memset(&br_dst, 0, sizeof(br_dst)); 104 br_dst.u.ip6 = *dst; 105 br_dst.proto = htons(ETH_P_IPV6); 106 br_dst.vid = vid; 107 108 return br_mdb_ip_get(br, &br_dst); 109 } 110 #endif 111 112 struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br, 113 struct sk_buff *skb, u16 vid) 114 { 115 struct br_ip ip; 116 117 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) 118 return NULL; 119 120 if (BR_INPUT_SKB_CB(skb)->igmp) 121 return NULL; 122 123 memset(&ip, 0, sizeof(ip)); 124 ip.proto = skb->protocol; 125 ip.vid = vid; 126 127 switch (skb->protocol) { 128 case htons(ETH_P_IP): 129 ip.u.ip4 = ip_hdr(skb)->daddr; 130 break; 131 #if IS_ENABLED(CONFIG_IPV6) 132 case htons(ETH_P_IPV6): 133 ip.u.ip6 = ipv6_hdr(skb)->daddr; 134 break; 135 #endif 136 default: 137 return NULL; 138 } 139 140 return br_mdb_ip_get_rcu(br, &ip); 141 } 142 143 static void br_multicast_group_expired(struct timer_list *t) 144 { 145 struct net_bridge_mdb_entry *mp = from_timer(mp, t, timer); 146 struct net_bridge *br = mp->br; 147 148 spin_lock(&br->multicast_lock); 149 if (!netif_running(br->dev) || timer_pending(&mp->timer)) 150 goto out; 151 152 br_multicast_host_leave(mp, true); 153 154 if (mp->ports) 155 goto out; 156 157 rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode, 158 br_mdb_rht_params); 159 hlist_del_rcu(&mp->mdb_node); 160 161 kfree_rcu(mp, rcu); 162 163 out: 164 spin_unlock(&br->multicast_lock); 165 } 166 167 static void br_multicast_del_group_src(struct net_bridge_group_src *src) 168 { 169 struct net_bridge *br = src->pg->port->br; 170 171 hlist_del_init_rcu(&src->node); 172 src->pg->src_ents--; 173 hlist_add_head(&src->del_node, &br->src_gc_list); 174 queue_work(system_long_wq, &br->src_gc_work); 175 } 176 177 void br_multicast_del_pg(struct net_bridge_mdb_entry *mp, 178 struct net_bridge_port_group *pg, 179 struct net_bridge_port_group __rcu **pp) 180 { 181 struct net_bridge *br = pg->port->br; 182 struct net_bridge_group_src *ent; 183 struct hlist_node *tmp; 184 185 rcu_assign_pointer(*pp, pg->next); 186 hlist_del_init(&pg->mglist); 187 del_timer(&pg->timer); 188 del_timer(&pg->rexmit_timer); 189 hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node) 190 br_multicast_del_group_src(ent); 191 br_mdb_notify(br->dev, mp, pg, RTM_DELMDB); 192 kfree_rcu(pg, rcu); 193 194 if (!mp->ports && !mp->host_joined && netif_running(br->dev)) 195 mod_timer(&mp->timer, jiffies); 196 } 197 198 static void br_multicast_find_del_pg(struct net_bridge *br, 199 struct net_bridge_port_group *pg) 200 { 201 struct net_bridge_port_group __rcu **pp; 202 struct net_bridge_mdb_entry *mp; 203 struct net_bridge_port_group *p; 204 205 mp = br_mdb_ip_get(br, &pg->addr); 206 if (WARN_ON(!mp)) 207 return; 208 209 for (pp = &mp->ports; 210 (p = mlock_dereference(*pp, br)) != NULL; 211 pp = &p->next) { 212 if (p != pg) 213 continue; 214 215 br_multicast_del_pg(mp, pg, pp); 216 return; 217 } 218 219 WARN_ON(1); 220 } 221 222 static void br_multicast_port_group_expired(struct timer_list *t) 223 { 224 struct net_bridge_port_group *pg = from_timer(pg, t, timer); 225 struct net_bridge_group_src *src_ent; 226 struct net_bridge *br = pg->port->br; 227 struct hlist_node *tmp; 228 bool changed; 229 230 spin_lock(&br->multicast_lock); 231 if (!netif_running(br->dev) || timer_pending(&pg->timer) || 232 hlist_unhashed(&pg->mglist) || pg->flags & MDB_PG_FLAGS_PERMANENT) 233 goto out; 234 235 changed = !!(pg->filter_mode == MCAST_EXCLUDE); 236 pg->filter_mode = MCAST_INCLUDE; 237 hlist_for_each_entry_safe(src_ent, tmp, &pg->src_list, node) { 238 if (!timer_pending(&src_ent->timer)) { 239 br_multicast_del_group_src(src_ent); 240 changed = true; 241 } 242 } 243 244 if (hlist_empty(&pg->src_list)) { 245 br_multicast_find_del_pg(br, pg); 246 } else if (changed) { 247 struct net_bridge_mdb_entry *mp = br_mdb_ip_get(br, &pg->addr); 248 249 if (WARN_ON(!mp)) 250 goto out; 251 br_mdb_notify(br->dev, mp, pg, RTM_NEWMDB); 252 } 253 out: 254 spin_unlock(&br->multicast_lock); 255 } 256 257 static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br, 258 struct net_bridge_port_group *pg, 259 __be32 ip_dst, __be32 group, 260 bool with_srcs, bool over_lmqt, 261 u8 sflag, u8 *igmp_type, 262 bool *need_rexmit) 263 { 264 struct net_bridge_port *p = pg ? pg->port : NULL; 265 struct net_bridge_group_src *ent; 266 size_t pkt_size, igmp_hdr_size; 267 unsigned long now = jiffies; 268 struct igmpv3_query *ihv3; 269 void *csum_start = NULL; 270 __sum16 *csum = NULL; 271 struct sk_buff *skb; 272 struct igmphdr *ih; 273 struct ethhdr *eth; 274 unsigned long lmqt; 275 struct iphdr *iph; 276 u16 lmqt_srcs = 0; 277 278 igmp_hdr_size = sizeof(*ih); 279 if (br->multicast_igmp_version == 3) { 280 igmp_hdr_size = sizeof(*ihv3); 281 if (pg && with_srcs) { 282 lmqt = now + (br->multicast_last_member_interval * 283 br->multicast_last_member_count); 284 hlist_for_each_entry(ent, &pg->src_list, node) { 285 if (over_lmqt == time_after(ent->timer.expires, 286 lmqt) && 287 ent->src_query_rexmit_cnt > 0) 288 lmqt_srcs++; 289 } 290 291 if (!lmqt_srcs) 292 return NULL; 293 igmp_hdr_size += lmqt_srcs * sizeof(__be32); 294 } 295 } 296 297 pkt_size = sizeof(*eth) + sizeof(*iph) + 4 + igmp_hdr_size; 298 if ((p && pkt_size > p->dev->mtu) || 299 pkt_size > br->dev->mtu) 300 return NULL; 301 302 skb = netdev_alloc_skb_ip_align(br->dev, pkt_size); 303 if (!skb) 304 goto out; 305 306 skb->protocol = htons(ETH_P_IP); 307 308 skb_reset_mac_header(skb); 309 eth = eth_hdr(skb); 310 311 ether_addr_copy(eth->h_source, br->dev->dev_addr); 312 ip_eth_mc_map(ip_dst, eth->h_dest); 313 eth->h_proto = htons(ETH_P_IP); 314 skb_put(skb, sizeof(*eth)); 315 316 skb_set_network_header(skb, skb->len); 317 iph = ip_hdr(skb); 318 iph->tot_len = htons(pkt_size - sizeof(*eth)); 319 320 iph->version = 4; 321 iph->ihl = 6; 322 iph->tos = 0xc0; 323 iph->id = 0; 324 iph->frag_off = htons(IP_DF); 325 iph->ttl = 1; 326 iph->protocol = IPPROTO_IGMP; 327 iph->saddr = br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR) ? 328 inet_select_addr(br->dev, 0, RT_SCOPE_LINK) : 0; 329 iph->daddr = ip_dst; 330 ((u8 *)&iph[1])[0] = IPOPT_RA; 331 ((u8 *)&iph[1])[1] = 4; 332 ((u8 *)&iph[1])[2] = 0; 333 ((u8 *)&iph[1])[3] = 0; 334 ip_send_check(iph); 335 skb_put(skb, 24); 336 337 skb_set_transport_header(skb, skb->len); 338 *igmp_type = IGMP_HOST_MEMBERSHIP_QUERY; 339 340 switch (br->multicast_igmp_version) { 341 case 2: 342 ih = igmp_hdr(skb); 343 ih->type = IGMP_HOST_MEMBERSHIP_QUERY; 344 ih->code = (group ? br->multicast_last_member_interval : 345 br->multicast_query_response_interval) / 346 (HZ / IGMP_TIMER_SCALE); 347 ih->group = group; 348 ih->csum = 0; 349 csum = &ih->csum; 350 csum_start = (void *)ih; 351 break; 352 case 3: 353 ihv3 = igmpv3_query_hdr(skb); 354 ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY; 355 ihv3->code = (group ? br->multicast_last_member_interval : 356 br->multicast_query_response_interval) / 357 (HZ / IGMP_TIMER_SCALE); 358 ihv3->group = group; 359 ihv3->qqic = br->multicast_query_interval / HZ; 360 ihv3->nsrcs = htons(lmqt_srcs); 361 ihv3->resv = 0; 362 ihv3->suppress = sflag; 363 ihv3->qrv = 2; 364 ihv3->csum = 0; 365 csum = &ihv3->csum; 366 csum_start = (void *)ihv3; 367 if (!pg || !with_srcs) 368 break; 369 370 lmqt_srcs = 0; 371 hlist_for_each_entry(ent, &pg->src_list, node) { 372 if (over_lmqt == time_after(ent->timer.expires, 373 lmqt) && 374 ent->src_query_rexmit_cnt > 0) { 375 ihv3->srcs[lmqt_srcs++] = ent->addr.u.ip4; 376 ent->src_query_rexmit_cnt--; 377 if (need_rexmit && ent->src_query_rexmit_cnt) 378 *need_rexmit = true; 379 } 380 } 381 if (WARN_ON(lmqt_srcs != ntohs(ihv3->nsrcs))) { 382 kfree_skb(skb); 383 return NULL; 384 } 385 break; 386 } 387 388 if (WARN_ON(!csum || !csum_start)) { 389 kfree_skb(skb); 390 return NULL; 391 } 392 393 *csum = ip_compute_csum(csum_start, igmp_hdr_size); 394 skb_put(skb, igmp_hdr_size); 395 __skb_pull(skb, sizeof(*eth)); 396 397 out: 398 return skb; 399 } 400 401 #if IS_ENABLED(CONFIG_IPV6) 402 static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br, 403 struct net_bridge_port_group *pg, 404 const struct in6_addr *ip6_dst, 405 const struct in6_addr *group, 406 bool with_srcs, bool over_llqt, 407 u8 sflag, u8 *igmp_type, 408 bool *need_rexmit) 409 { 410 struct net_bridge_port *p = pg ? pg->port : NULL; 411 struct net_bridge_group_src *ent; 412 size_t pkt_size, mld_hdr_size; 413 unsigned long now = jiffies; 414 struct mld2_query *mld2q; 415 void *csum_start = NULL; 416 unsigned long interval; 417 __sum16 *csum = NULL; 418 struct ipv6hdr *ip6h; 419 struct mld_msg *mldq; 420 struct sk_buff *skb; 421 unsigned long llqt; 422 struct ethhdr *eth; 423 u16 llqt_srcs = 0; 424 u8 *hopopt; 425 426 mld_hdr_size = sizeof(*mldq); 427 if (br->multicast_mld_version == 2) { 428 mld_hdr_size = sizeof(*mld2q); 429 if (pg && with_srcs) { 430 llqt = now + (br->multicast_last_member_interval * 431 br->multicast_last_member_count); 432 hlist_for_each_entry(ent, &pg->src_list, node) { 433 if (over_llqt == time_after(ent->timer.expires, 434 llqt) && 435 ent->src_query_rexmit_cnt > 0) 436 llqt_srcs++; 437 } 438 439 if (!llqt_srcs) 440 return NULL; 441 mld_hdr_size += llqt_srcs * sizeof(struct in6_addr); 442 } 443 } 444 445 pkt_size = sizeof(*eth) + sizeof(*ip6h) + 8 + mld_hdr_size; 446 if ((p && pkt_size > p->dev->mtu) || 447 pkt_size > br->dev->mtu) 448 return NULL; 449 450 skb = netdev_alloc_skb_ip_align(br->dev, pkt_size); 451 if (!skb) 452 goto out; 453 454 skb->protocol = htons(ETH_P_IPV6); 455 456 /* Ethernet header */ 457 skb_reset_mac_header(skb); 458 eth = eth_hdr(skb); 459 460 ether_addr_copy(eth->h_source, br->dev->dev_addr); 461 eth->h_proto = htons(ETH_P_IPV6); 462 skb_put(skb, sizeof(*eth)); 463 464 /* IPv6 header + HbH option */ 465 skb_set_network_header(skb, skb->len); 466 ip6h = ipv6_hdr(skb); 467 468 *(__force __be32 *)ip6h = htonl(0x60000000); 469 ip6h->payload_len = htons(8 + mld_hdr_size); 470 ip6h->nexthdr = IPPROTO_HOPOPTS; 471 ip6h->hop_limit = 1; 472 ip6h->daddr = *ip6_dst; 473 if (ipv6_dev_get_saddr(dev_net(br->dev), br->dev, &ip6h->daddr, 0, 474 &ip6h->saddr)) { 475 kfree_skb(skb); 476 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, false); 477 return NULL; 478 } 479 480 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true); 481 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest); 482 483 hopopt = (u8 *)(ip6h + 1); 484 hopopt[0] = IPPROTO_ICMPV6; /* next hdr */ 485 hopopt[1] = 0; /* length of HbH */ 486 hopopt[2] = IPV6_TLV_ROUTERALERT; /* Router Alert */ 487 hopopt[3] = 2; /* Length of RA Option */ 488 hopopt[4] = 0; /* Type = 0x0000 (MLD) */ 489 hopopt[5] = 0; 490 hopopt[6] = IPV6_TLV_PAD1; /* Pad1 */ 491 hopopt[7] = IPV6_TLV_PAD1; /* Pad1 */ 492 493 skb_put(skb, sizeof(*ip6h) + 8); 494 495 /* ICMPv6 */ 496 skb_set_transport_header(skb, skb->len); 497 interval = ipv6_addr_any(group) ? 498 br->multicast_query_response_interval : 499 br->multicast_last_member_interval; 500 *igmp_type = ICMPV6_MGM_QUERY; 501 switch (br->multicast_mld_version) { 502 case 1: 503 mldq = (struct mld_msg *)icmp6_hdr(skb); 504 mldq->mld_type = ICMPV6_MGM_QUERY; 505 mldq->mld_code = 0; 506 mldq->mld_cksum = 0; 507 mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval)); 508 mldq->mld_reserved = 0; 509 mldq->mld_mca = *group; 510 csum = &mldq->mld_cksum; 511 csum_start = (void *)mldq; 512 break; 513 case 2: 514 mld2q = (struct mld2_query *)icmp6_hdr(skb); 515 mld2q->mld2q_mrc = htons((u16)jiffies_to_msecs(interval)); 516 mld2q->mld2q_type = ICMPV6_MGM_QUERY; 517 mld2q->mld2q_code = 0; 518 mld2q->mld2q_cksum = 0; 519 mld2q->mld2q_resv1 = 0; 520 mld2q->mld2q_resv2 = 0; 521 mld2q->mld2q_suppress = sflag; 522 mld2q->mld2q_qrv = 2; 523 mld2q->mld2q_nsrcs = htons(llqt_srcs); 524 mld2q->mld2q_qqic = br->multicast_query_interval / HZ; 525 mld2q->mld2q_mca = *group; 526 csum = &mld2q->mld2q_cksum; 527 csum_start = (void *)mld2q; 528 if (!pg || !with_srcs) 529 break; 530 531 llqt_srcs = 0; 532 hlist_for_each_entry(ent, &pg->src_list, node) { 533 if (over_llqt == time_after(ent->timer.expires, 534 llqt) && 535 ent->src_query_rexmit_cnt > 0) { 536 mld2q->mld2q_srcs[llqt_srcs++] = ent->addr.u.ip6; 537 ent->src_query_rexmit_cnt--; 538 if (need_rexmit && ent->src_query_rexmit_cnt) 539 *need_rexmit = true; 540 } 541 } 542 if (WARN_ON(llqt_srcs != ntohs(mld2q->mld2q_nsrcs))) { 543 kfree_skb(skb); 544 return NULL; 545 } 546 break; 547 } 548 549 if (WARN_ON(!csum || !csum_start)) { 550 kfree_skb(skb); 551 return NULL; 552 } 553 554 *csum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr, mld_hdr_size, 555 IPPROTO_ICMPV6, 556 csum_partial(csum_start, mld_hdr_size, 0)); 557 skb_put(skb, mld_hdr_size); 558 __skb_pull(skb, sizeof(*eth)); 559 560 out: 561 return skb; 562 } 563 #endif 564 565 static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br, 566 struct net_bridge_port_group *pg, 567 struct br_ip *ip_dst, 568 struct br_ip *group, 569 bool with_srcs, bool over_lmqt, 570 u8 sflag, u8 *igmp_type, 571 bool *need_rexmit) 572 { 573 __be32 ip4_dst; 574 575 switch (group->proto) { 576 case htons(ETH_P_IP): 577 ip4_dst = ip_dst ? ip_dst->u.ip4 : htonl(INADDR_ALLHOSTS_GROUP); 578 return br_ip4_multicast_alloc_query(br, pg, 579 ip4_dst, group->u.ip4, 580 with_srcs, over_lmqt, 581 sflag, igmp_type, 582 need_rexmit); 583 #if IS_ENABLED(CONFIG_IPV6) 584 case htons(ETH_P_IPV6): { 585 struct in6_addr ip6_dst; 586 587 if (ip_dst) 588 ip6_dst = ip_dst->u.ip6; 589 else 590 ipv6_addr_set(&ip6_dst, htonl(0xff020000), 0, 0, 591 htonl(1)); 592 593 return br_ip6_multicast_alloc_query(br, pg, 594 &ip6_dst, &group->u.ip6, 595 with_srcs, over_lmqt, 596 sflag, igmp_type, 597 need_rexmit); 598 } 599 #endif 600 } 601 return NULL; 602 } 603 604 struct net_bridge_mdb_entry *br_multicast_new_group(struct net_bridge *br, 605 struct br_ip *group) 606 { 607 struct net_bridge_mdb_entry *mp; 608 int err; 609 610 mp = br_mdb_ip_get(br, group); 611 if (mp) 612 return mp; 613 614 if (atomic_read(&br->mdb_hash_tbl.nelems) >= br->hash_max) { 615 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, false); 616 return ERR_PTR(-E2BIG); 617 } 618 619 mp = kzalloc(sizeof(*mp), GFP_ATOMIC); 620 if (unlikely(!mp)) 621 return ERR_PTR(-ENOMEM); 622 623 mp->br = br; 624 mp->addr = *group; 625 timer_setup(&mp->timer, br_multicast_group_expired, 0); 626 err = rhashtable_lookup_insert_fast(&br->mdb_hash_tbl, &mp->rhnode, 627 br_mdb_rht_params); 628 if (err) { 629 kfree(mp); 630 mp = ERR_PTR(err); 631 } else { 632 hlist_add_head_rcu(&mp->mdb_node, &br->mdb_list); 633 } 634 635 return mp; 636 } 637 638 static void br_multicast_group_src_expired(struct timer_list *t) 639 { 640 struct net_bridge_group_src *src = from_timer(src, t, timer); 641 struct net_bridge_port_group *pg; 642 struct net_bridge *br = src->br; 643 644 spin_lock(&br->multicast_lock); 645 if (hlist_unhashed(&src->node) || !netif_running(br->dev) || 646 timer_pending(&src->timer)) 647 goto out; 648 649 pg = src->pg; 650 if (pg->filter_mode == MCAST_INCLUDE) { 651 br_multicast_del_group_src(src); 652 if (!hlist_empty(&pg->src_list)) 653 goto out; 654 br_multicast_find_del_pg(br, pg); 655 } 656 out: 657 spin_unlock(&br->multicast_lock); 658 } 659 660 static struct net_bridge_group_src * 661 br_multicast_find_group_src(struct net_bridge_port_group *pg, struct br_ip *ip) 662 { 663 struct net_bridge_group_src *ent; 664 665 switch (ip->proto) { 666 case htons(ETH_P_IP): 667 hlist_for_each_entry(ent, &pg->src_list, node) 668 if (ip->u.ip4 == ent->addr.u.ip4) 669 return ent; 670 break; 671 #if IS_ENABLED(CONFIG_IPV6) 672 case htons(ETH_P_IPV6): 673 hlist_for_each_entry(ent, &pg->src_list, node) 674 if (!ipv6_addr_cmp(&ent->addr.u.ip6, &ip->u.ip6)) 675 return ent; 676 break; 677 #endif 678 } 679 680 return NULL; 681 } 682 683 static struct net_bridge_group_src * 684 br_multicast_new_group_src(struct net_bridge_port_group *pg, struct br_ip *src_ip) 685 { 686 struct net_bridge_group_src *grp_src; 687 688 if (unlikely(pg->src_ents >= PG_SRC_ENT_LIMIT)) 689 return NULL; 690 691 switch (src_ip->proto) { 692 case htons(ETH_P_IP): 693 if (ipv4_is_zeronet(src_ip->u.ip4) || 694 ipv4_is_multicast(src_ip->u.ip4)) 695 return NULL; 696 break; 697 #if IS_ENABLED(CONFIG_IPV6) 698 case htons(ETH_P_IPV6): 699 if (ipv6_addr_any(&src_ip->u.ip6) || 700 ipv6_addr_is_multicast(&src_ip->u.ip6)) 701 return NULL; 702 break; 703 #endif 704 } 705 706 grp_src = kzalloc(sizeof(*grp_src), GFP_ATOMIC); 707 if (unlikely(!grp_src)) 708 return NULL; 709 710 grp_src->pg = pg; 711 grp_src->br = pg->port->br; 712 grp_src->addr = *src_ip; 713 timer_setup(&grp_src->timer, br_multicast_group_src_expired, 0); 714 715 hlist_add_head_rcu(&grp_src->node, &pg->src_list); 716 pg->src_ents++; 717 718 return grp_src; 719 } 720 721 struct net_bridge_port_group *br_multicast_new_port_group( 722 struct net_bridge_port *port, 723 struct br_ip *group, 724 struct net_bridge_port_group __rcu *next, 725 unsigned char flags, 726 const unsigned char *src, 727 u8 filter_mode) 728 { 729 struct net_bridge_port_group *p; 730 731 p = kzalloc(sizeof(*p), GFP_ATOMIC); 732 if (unlikely(!p)) 733 return NULL; 734 735 p->addr = *group; 736 p->port = port; 737 p->flags = flags; 738 p->filter_mode = filter_mode; 739 INIT_HLIST_HEAD(&p->src_list); 740 rcu_assign_pointer(p->next, next); 741 timer_setup(&p->timer, br_multicast_port_group_expired, 0); 742 timer_setup(&p->rexmit_timer, br_multicast_port_group_rexmit, 0); 743 hlist_add_head(&p->mglist, &port->mglist); 744 745 if (src) 746 memcpy(p->eth_addr, src, ETH_ALEN); 747 else 748 eth_broadcast_addr(p->eth_addr); 749 750 return p; 751 } 752 753 static bool br_port_group_equal(struct net_bridge_port_group *p, 754 struct net_bridge_port *port, 755 const unsigned char *src) 756 { 757 if (p->port != port) 758 return false; 759 760 if (!(port->flags & BR_MULTICAST_TO_UNICAST)) 761 return true; 762 763 return ether_addr_equal(src, p->eth_addr); 764 } 765 766 void br_multicast_host_join(struct net_bridge_mdb_entry *mp, bool notify) 767 { 768 if (!mp->host_joined) { 769 mp->host_joined = true; 770 if (notify) 771 br_mdb_notify(mp->br->dev, mp, NULL, RTM_NEWMDB); 772 } 773 mod_timer(&mp->timer, jiffies + mp->br->multicast_membership_interval); 774 } 775 776 void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify) 777 { 778 if (!mp->host_joined) 779 return; 780 781 mp->host_joined = false; 782 if (notify) 783 br_mdb_notify(mp->br->dev, mp, NULL, RTM_DELMDB); 784 } 785 786 static int br_multicast_add_group(struct net_bridge *br, 787 struct net_bridge_port *port, 788 struct br_ip *group, 789 const unsigned char *src, 790 u8 filter_mode, 791 bool igmpv2_mldv1) 792 { 793 struct net_bridge_port_group __rcu **pp; 794 struct net_bridge_port_group *p; 795 struct net_bridge_mdb_entry *mp; 796 unsigned long now = jiffies; 797 int err; 798 799 spin_lock(&br->multicast_lock); 800 if (!netif_running(br->dev) || 801 (port && port->state == BR_STATE_DISABLED)) 802 goto out; 803 804 mp = br_multicast_new_group(br, group); 805 err = PTR_ERR(mp); 806 if (IS_ERR(mp)) 807 goto err; 808 809 if (!port) { 810 br_multicast_host_join(mp, true); 811 goto out; 812 } 813 814 for (pp = &mp->ports; 815 (p = mlock_dereference(*pp, br)) != NULL; 816 pp = &p->next) { 817 if (br_port_group_equal(p, port, src)) 818 goto found; 819 if ((unsigned long)p->port < (unsigned long)port) 820 break; 821 } 822 823 p = br_multicast_new_port_group(port, group, *pp, 0, src, filter_mode); 824 if (unlikely(!p)) 825 goto err; 826 rcu_assign_pointer(*pp, p); 827 br_mdb_notify(br->dev, mp, p, RTM_NEWMDB); 828 829 found: 830 if (igmpv2_mldv1) 831 mod_timer(&p->timer, now + br->multicast_membership_interval); 832 833 out: 834 err = 0; 835 836 err: 837 spin_unlock(&br->multicast_lock); 838 return err; 839 } 840 841 static int br_ip4_multicast_add_group(struct net_bridge *br, 842 struct net_bridge_port *port, 843 __be32 group, 844 __u16 vid, 845 const unsigned char *src, 846 bool igmpv2) 847 { 848 struct br_ip br_group; 849 u8 filter_mode; 850 851 if (ipv4_is_local_multicast(group)) 852 return 0; 853 854 memset(&br_group, 0, sizeof(br_group)); 855 br_group.u.ip4 = group; 856 br_group.proto = htons(ETH_P_IP); 857 br_group.vid = vid; 858 filter_mode = igmpv2 ? MCAST_EXCLUDE : MCAST_INCLUDE; 859 860 return br_multicast_add_group(br, port, &br_group, src, filter_mode, 861 igmpv2); 862 } 863 864 #if IS_ENABLED(CONFIG_IPV6) 865 static int br_ip6_multicast_add_group(struct net_bridge *br, 866 struct net_bridge_port *port, 867 const struct in6_addr *group, 868 __u16 vid, 869 const unsigned char *src, 870 bool mldv1) 871 { 872 struct br_ip br_group; 873 u8 filter_mode; 874 875 if (ipv6_addr_is_ll_all_nodes(group)) 876 return 0; 877 878 memset(&br_group, 0, sizeof(br_group)); 879 br_group.u.ip6 = *group; 880 br_group.proto = htons(ETH_P_IPV6); 881 br_group.vid = vid; 882 filter_mode = mldv1 ? MCAST_EXCLUDE : MCAST_INCLUDE; 883 884 return br_multicast_add_group(br, port, &br_group, src, filter_mode, 885 mldv1); 886 } 887 #endif 888 889 static void br_multicast_router_expired(struct timer_list *t) 890 { 891 struct net_bridge_port *port = 892 from_timer(port, t, multicast_router_timer); 893 struct net_bridge *br = port->br; 894 895 spin_lock(&br->multicast_lock); 896 if (port->multicast_router == MDB_RTR_TYPE_DISABLED || 897 port->multicast_router == MDB_RTR_TYPE_PERM || 898 timer_pending(&port->multicast_router_timer)) 899 goto out; 900 901 __del_port_router(port); 902 out: 903 spin_unlock(&br->multicast_lock); 904 } 905 906 static void br_mc_router_state_change(struct net_bridge *p, 907 bool is_mc_router) 908 { 909 struct switchdev_attr attr = { 910 .orig_dev = p->dev, 911 .id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER, 912 .flags = SWITCHDEV_F_DEFER, 913 .u.mrouter = is_mc_router, 914 }; 915 916 switchdev_port_attr_set(p->dev, &attr); 917 } 918 919 static void br_multicast_local_router_expired(struct timer_list *t) 920 { 921 struct net_bridge *br = from_timer(br, t, multicast_router_timer); 922 923 spin_lock(&br->multicast_lock); 924 if (br->multicast_router == MDB_RTR_TYPE_DISABLED || 925 br->multicast_router == MDB_RTR_TYPE_PERM || 926 timer_pending(&br->multicast_router_timer)) 927 goto out; 928 929 br_mc_router_state_change(br, false); 930 out: 931 spin_unlock(&br->multicast_lock); 932 } 933 934 static void br_multicast_querier_expired(struct net_bridge *br, 935 struct bridge_mcast_own_query *query) 936 { 937 spin_lock(&br->multicast_lock); 938 if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED)) 939 goto out; 940 941 br_multicast_start_querier(br, query); 942 943 out: 944 spin_unlock(&br->multicast_lock); 945 } 946 947 static void br_ip4_multicast_querier_expired(struct timer_list *t) 948 { 949 struct net_bridge *br = from_timer(br, t, ip4_other_query.timer); 950 951 br_multicast_querier_expired(br, &br->ip4_own_query); 952 } 953 954 #if IS_ENABLED(CONFIG_IPV6) 955 static void br_ip6_multicast_querier_expired(struct timer_list *t) 956 { 957 struct net_bridge *br = from_timer(br, t, ip6_other_query.timer); 958 959 br_multicast_querier_expired(br, &br->ip6_own_query); 960 } 961 #endif 962 963 static void br_multicast_select_own_querier(struct net_bridge *br, 964 struct br_ip *ip, 965 struct sk_buff *skb) 966 { 967 if (ip->proto == htons(ETH_P_IP)) 968 br->ip4_querier.addr.u.ip4 = ip_hdr(skb)->saddr; 969 #if IS_ENABLED(CONFIG_IPV6) 970 else 971 br->ip6_querier.addr.u.ip6 = ipv6_hdr(skb)->saddr; 972 #endif 973 } 974 975 static void __br_multicast_send_query(struct net_bridge *br, 976 struct net_bridge_port *port, 977 struct net_bridge_port_group *pg, 978 struct br_ip *ip_dst, 979 struct br_ip *group, 980 bool with_srcs, 981 u8 sflag, 982 bool *need_rexmit) 983 { 984 bool over_lmqt = !!sflag; 985 struct sk_buff *skb; 986 u8 igmp_type; 987 988 again_under_lmqt: 989 skb = br_multicast_alloc_query(br, pg, ip_dst, group, with_srcs, 990 over_lmqt, sflag, &igmp_type, 991 need_rexmit); 992 if (!skb) 993 return; 994 995 if (port) { 996 skb->dev = port->dev; 997 br_multicast_count(br, port, skb, igmp_type, 998 BR_MCAST_DIR_TX); 999 NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, 1000 dev_net(port->dev), NULL, skb, NULL, skb->dev, 1001 br_dev_queue_push_xmit); 1002 1003 if (over_lmqt && with_srcs && sflag) { 1004 over_lmqt = false; 1005 goto again_under_lmqt; 1006 } 1007 } else { 1008 br_multicast_select_own_querier(br, group, skb); 1009 br_multicast_count(br, port, skb, igmp_type, 1010 BR_MCAST_DIR_RX); 1011 netif_rx(skb); 1012 } 1013 } 1014 1015 static void br_multicast_send_query(struct net_bridge *br, 1016 struct net_bridge_port *port, 1017 struct bridge_mcast_own_query *own_query) 1018 { 1019 struct bridge_mcast_other_query *other_query = NULL; 1020 struct br_ip br_group; 1021 unsigned long time; 1022 1023 if (!netif_running(br->dev) || 1024 !br_opt_get(br, BROPT_MULTICAST_ENABLED) || 1025 !br_opt_get(br, BROPT_MULTICAST_QUERIER)) 1026 return; 1027 1028 memset(&br_group.u, 0, sizeof(br_group.u)); 1029 1030 if (port ? (own_query == &port->ip4_own_query) : 1031 (own_query == &br->ip4_own_query)) { 1032 other_query = &br->ip4_other_query; 1033 br_group.proto = htons(ETH_P_IP); 1034 #if IS_ENABLED(CONFIG_IPV6) 1035 } else { 1036 other_query = &br->ip6_other_query; 1037 br_group.proto = htons(ETH_P_IPV6); 1038 #endif 1039 } 1040 1041 if (!other_query || timer_pending(&other_query->timer)) 1042 return; 1043 1044 __br_multicast_send_query(br, port, NULL, NULL, &br_group, false, 0, 1045 NULL); 1046 1047 time = jiffies; 1048 time += own_query->startup_sent < br->multicast_startup_query_count ? 1049 br->multicast_startup_query_interval : 1050 br->multicast_query_interval; 1051 mod_timer(&own_query->timer, time); 1052 } 1053 1054 static void 1055 br_multicast_port_query_expired(struct net_bridge_port *port, 1056 struct bridge_mcast_own_query *query) 1057 { 1058 struct net_bridge *br = port->br; 1059 1060 spin_lock(&br->multicast_lock); 1061 if (port->state == BR_STATE_DISABLED || 1062 port->state == BR_STATE_BLOCKING) 1063 goto out; 1064 1065 if (query->startup_sent < br->multicast_startup_query_count) 1066 query->startup_sent++; 1067 1068 br_multicast_send_query(port->br, port, query); 1069 1070 out: 1071 spin_unlock(&br->multicast_lock); 1072 } 1073 1074 static void br_ip4_multicast_port_query_expired(struct timer_list *t) 1075 { 1076 struct net_bridge_port *port = from_timer(port, t, ip4_own_query.timer); 1077 1078 br_multicast_port_query_expired(port, &port->ip4_own_query); 1079 } 1080 1081 #if IS_ENABLED(CONFIG_IPV6) 1082 static void br_ip6_multicast_port_query_expired(struct timer_list *t) 1083 { 1084 struct net_bridge_port *port = from_timer(port, t, ip6_own_query.timer); 1085 1086 br_multicast_port_query_expired(port, &port->ip6_own_query); 1087 } 1088 #endif 1089 1090 static void br_multicast_port_group_rexmit(struct timer_list *t) 1091 { 1092 struct net_bridge_port_group *pg = from_timer(pg, t, rexmit_timer); 1093 struct bridge_mcast_other_query *other_query = NULL; 1094 struct net_bridge *br = pg->port->br; 1095 bool need_rexmit = false; 1096 1097 spin_lock(&br->multicast_lock); 1098 if (!netif_running(br->dev) || hlist_unhashed(&pg->mglist) || 1099 !br_opt_get(br, BROPT_MULTICAST_ENABLED) || 1100 !br_opt_get(br, BROPT_MULTICAST_QUERIER)) 1101 goto out; 1102 1103 if (pg->addr.proto == htons(ETH_P_IP)) 1104 other_query = &br->ip4_other_query; 1105 #if IS_ENABLED(CONFIG_IPV6) 1106 else 1107 other_query = &br->ip6_other_query; 1108 #endif 1109 1110 if (!other_query || timer_pending(&other_query->timer)) 1111 goto out; 1112 1113 if (pg->grp_query_rexmit_cnt) { 1114 pg->grp_query_rexmit_cnt--; 1115 __br_multicast_send_query(br, pg->port, pg, &pg->addr, 1116 &pg->addr, false, 1, NULL); 1117 } 1118 __br_multicast_send_query(br, pg->port, pg, &pg->addr, 1119 &pg->addr, true, 0, &need_rexmit); 1120 1121 if (pg->grp_query_rexmit_cnt || need_rexmit) 1122 mod_timer(&pg->rexmit_timer, jiffies + 1123 br->multicast_last_member_interval); 1124 out: 1125 spin_unlock(&br->multicast_lock); 1126 } 1127 1128 static void br_mc_disabled_update(struct net_device *dev, bool value) 1129 { 1130 struct switchdev_attr attr = { 1131 .orig_dev = dev, 1132 .id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED, 1133 .flags = SWITCHDEV_F_DEFER, 1134 .u.mc_disabled = !value, 1135 }; 1136 1137 switchdev_port_attr_set(dev, &attr); 1138 } 1139 1140 int br_multicast_add_port(struct net_bridge_port *port) 1141 { 1142 port->multicast_router = MDB_RTR_TYPE_TEMP_QUERY; 1143 1144 timer_setup(&port->multicast_router_timer, 1145 br_multicast_router_expired, 0); 1146 timer_setup(&port->ip4_own_query.timer, 1147 br_ip4_multicast_port_query_expired, 0); 1148 #if IS_ENABLED(CONFIG_IPV6) 1149 timer_setup(&port->ip6_own_query.timer, 1150 br_ip6_multicast_port_query_expired, 0); 1151 #endif 1152 br_mc_disabled_update(port->dev, 1153 br_opt_get(port->br, BROPT_MULTICAST_ENABLED)); 1154 1155 port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats); 1156 if (!port->mcast_stats) 1157 return -ENOMEM; 1158 1159 return 0; 1160 } 1161 1162 void br_multicast_del_port(struct net_bridge_port *port) 1163 { 1164 struct net_bridge *br = port->br; 1165 struct net_bridge_port_group *pg; 1166 struct hlist_node *n; 1167 1168 /* Take care of the remaining groups, only perm ones should be left */ 1169 spin_lock_bh(&br->multicast_lock); 1170 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist) 1171 br_multicast_find_del_pg(br, pg); 1172 spin_unlock_bh(&br->multicast_lock); 1173 del_timer_sync(&port->multicast_router_timer); 1174 free_percpu(port->mcast_stats); 1175 } 1176 1177 static void br_multicast_enable(struct bridge_mcast_own_query *query) 1178 { 1179 query->startup_sent = 0; 1180 1181 if (try_to_del_timer_sync(&query->timer) >= 0 || 1182 del_timer(&query->timer)) 1183 mod_timer(&query->timer, jiffies); 1184 } 1185 1186 static void __br_multicast_enable_port(struct net_bridge_port *port) 1187 { 1188 struct net_bridge *br = port->br; 1189 1190 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || !netif_running(br->dev)) 1191 return; 1192 1193 br_multicast_enable(&port->ip4_own_query); 1194 #if IS_ENABLED(CONFIG_IPV6) 1195 br_multicast_enable(&port->ip6_own_query); 1196 #endif 1197 if (port->multicast_router == MDB_RTR_TYPE_PERM && 1198 hlist_unhashed(&port->rlist)) 1199 br_multicast_add_router(br, port); 1200 } 1201 1202 void br_multicast_enable_port(struct net_bridge_port *port) 1203 { 1204 struct net_bridge *br = port->br; 1205 1206 spin_lock(&br->multicast_lock); 1207 __br_multicast_enable_port(port); 1208 spin_unlock(&br->multicast_lock); 1209 } 1210 1211 void br_multicast_disable_port(struct net_bridge_port *port) 1212 { 1213 struct net_bridge *br = port->br; 1214 struct net_bridge_port_group *pg; 1215 struct hlist_node *n; 1216 1217 spin_lock(&br->multicast_lock); 1218 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist) 1219 if (!(pg->flags & MDB_PG_FLAGS_PERMANENT)) 1220 br_multicast_find_del_pg(br, pg); 1221 1222 __del_port_router(port); 1223 1224 del_timer(&port->multicast_router_timer); 1225 del_timer(&port->ip4_own_query.timer); 1226 #if IS_ENABLED(CONFIG_IPV6) 1227 del_timer(&port->ip6_own_query.timer); 1228 #endif 1229 spin_unlock(&br->multicast_lock); 1230 } 1231 1232 static int __grp_src_delete_marked(struct net_bridge_port_group *pg) 1233 { 1234 struct net_bridge_group_src *ent; 1235 struct hlist_node *tmp; 1236 int deleted = 0; 1237 1238 hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node) 1239 if (ent->flags & BR_SGRP_F_DELETE) { 1240 br_multicast_del_group_src(ent); 1241 deleted++; 1242 } 1243 1244 return deleted; 1245 } 1246 1247 static void __grp_src_query_marked_and_rexmit(struct net_bridge_port_group *pg) 1248 { 1249 struct bridge_mcast_other_query *other_query = NULL; 1250 struct net_bridge *br = pg->port->br; 1251 u32 lmqc = br->multicast_last_member_count; 1252 unsigned long lmqt, lmi, now = jiffies; 1253 struct net_bridge_group_src *ent; 1254 1255 if (!netif_running(br->dev) || 1256 !br_opt_get(br, BROPT_MULTICAST_ENABLED)) 1257 return; 1258 1259 if (pg->addr.proto == htons(ETH_P_IP)) 1260 other_query = &br->ip4_other_query; 1261 #if IS_ENABLED(CONFIG_IPV6) 1262 else 1263 other_query = &br->ip6_other_query; 1264 #endif 1265 1266 lmqt = now + br_multicast_lmqt(br); 1267 hlist_for_each_entry(ent, &pg->src_list, node) { 1268 if (ent->flags & BR_SGRP_F_SEND) { 1269 ent->flags &= ~BR_SGRP_F_SEND; 1270 if (ent->timer.expires > lmqt) { 1271 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) && 1272 other_query && 1273 !timer_pending(&other_query->timer)) 1274 ent->src_query_rexmit_cnt = lmqc; 1275 mod_timer(&ent->timer, lmqt); 1276 } 1277 } 1278 } 1279 1280 if (!br_opt_get(br, BROPT_MULTICAST_QUERIER) || 1281 !other_query || timer_pending(&other_query->timer)) 1282 return; 1283 1284 __br_multicast_send_query(br, pg->port, pg, &pg->addr, 1285 &pg->addr, true, 1, NULL); 1286 1287 lmi = now + br->multicast_last_member_interval; 1288 if (!timer_pending(&pg->rexmit_timer) || 1289 time_after(pg->rexmit_timer.expires, lmi)) 1290 mod_timer(&pg->rexmit_timer, lmi); 1291 } 1292 1293 static void __grp_send_query_and_rexmit(struct net_bridge_port_group *pg) 1294 { 1295 struct bridge_mcast_other_query *other_query = NULL; 1296 struct net_bridge *br = pg->port->br; 1297 unsigned long now = jiffies, lmi; 1298 1299 if (!netif_running(br->dev) || 1300 !br_opt_get(br, BROPT_MULTICAST_ENABLED)) 1301 return; 1302 1303 if (pg->addr.proto == htons(ETH_P_IP)) 1304 other_query = &br->ip4_other_query; 1305 #if IS_ENABLED(CONFIG_IPV6) 1306 else 1307 other_query = &br->ip6_other_query; 1308 #endif 1309 1310 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) && 1311 other_query && !timer_pending(&other_query->timer)) { 1312 lmi = now + br->multicast_last_member_interval; 1313 pg->grp_query_rexmit_cnt = br->multicast_last_member_count - 1; 1314 __br_multicast_send_query(br, pg->port, pg, &pg->addr, 1315 &pg->addr, false, 0, NULL); 1316 if (!timer_pending(&pg->rexmit_timer) || 1317 time_after(pg->rexmit_timer.expires, lmi)) 1318 mod_timer(&pg->rexmit_timer, lmi); 1319 } 1320 1321 if (pg->filter_mode == MCAST_EXCLUDE && 1322 (!timer_pending(&pg->timer) || 1323 time_after(pg->timer.expires, now + br_multicast_lmqt(br)))) 1324 mod_timer(&pg->timer, now + br_multicast_lmqt(br)); 1325 } 1326 1327 /* State Msg type New state Actions 1328 * INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI 1329 * INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI 1330 * EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI 1331 */ 1332 static bool br_multicast_isinc_allow(struct net_bridge_port_group *pg, 1333 void *srcs, u32 nsrcs, size_t src_size) 1334 { 1335 struct net_bridge *br = pg->port->br; 1336 struct net_bridge_group_src *ent; 1337 unsigned long now = jiffies; 1338 bool changed = false; 1339 struct br_ip src_ip; 1340 u32 src_idx; 1341 1342 memset(&src_ip, 0, sizeof(src_ip)); 1343 src_ip.proto = pg->addr.proto; 1344 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1345 memcpy(&src_ip.u, srcs, src_size); 1346 ent = br_multicast_find_group_src(pg, &src_ip); 1347 if (!ent) { 1348 ent = br_multicast_new_group_src(pg, &src_ip); 1349 if (ent) 1350 changed = true; 1351 } 1352 1353 if (ent) 1354 mod_timer(&ent->timer, now + br_multicast_gmi(br)); 1355 srcs += src_size; 1356 } 1357 1358 return changed; 1359 } 1360 1361 /* State Msg type New state Actions 1362 * INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0 1363 * Delete (A-B) 1364 * Group Timer=GMI 1365 */ 1366 static void __grp_src_isexc_incl(struct net_bridge_port_group *pg, 1367 void *srcs, u32 nsrcs, size_t src_size) 1368 { 1369 struct net_bridge_group_src *ent; 1370 struct br_ip src_ip; 1371 u32 src_idx; 1372 1373 hlist_for_each_entry(ent, &pg->src_list, node) 1374 ent->flags |= BR_SGRP_F_DELETE; 1375 1376 memset(&src_ip, 0, sizeof(src_ip)); 1377 src_ip.proto = pg->addr.proto; 1378 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1379 memcpy(&src_ip.u, srcs, src_size); 1380 ent = br_multicast_find_group_src(pg, &src_ip); 1381 if (ent) 1382 ent->flags &= ~BR_SGRP_F_DELETE; 1383 else 1384 br_multicast_new_group_src(pg, &src_ip); 1385 srcs += src_size; 1386 } 1387 1388 __grp_src_delete_marked(pg); 1389 } 1390 1391 /* State Msg type New state Actions 1392 * EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI 1393 * Delete (X-A) 1394 * Delete (Y-A) 1395 * Group Timer=GMI 1396 */ 1397 static bool __grp_src_isexc_excl(struct net_bridge_port_group *pg, 1398 void *srcs, u32 nsrcs, size_t src_size) 1399 { 1400 struct net_bridge *br = pg->port->br; 1401 struct net_bridge_group_src *ent; 1402 unsigned long now = jiffies; 1403 bool changed = false; 1404 struct br_ip src_ip; 1405 u32 src_idx; 1406 1407 hlist_for_each_entry(ent, &pg->src_list, node) 1408 ent->flags |= BR_SGRP_F_DELETE; 1409 1410 memset(&src_ip, 0, sizeof(src_ip)); 1411 src_ip.proto = pg->addr.proto; 1412 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1413 memcpy(&src_ip.u, srcs, src_size); 1414 ent = br_multicast_find_group_src(pg, &src_ip); 1415 if (ent) { 1416 ent->flags &= ~BR_SGRP_F_DELETE; 1417 } else { 1418 ent = br_multicast_new_group_src(pg, &src_ip); 1419 if (ent) { 1420 mod_timer(&ent->timer, 1421 now + br_multicast_gmi(br)); 1422 changed = true; 1423 } 1424 } 1425 srcs += src_size; 1426 } 1427 1428 if (__grp_src_delete_marked(pg)) 1429 changed = true; 1430 1431 return changed; 1432 } 1433 1434 static bool br_multicast_isexc(struct net_bridge_port_group *pg, 1435 void *srcs, u32 nsrcs, size_t src_size) 1436 { 1437 struct net_bridge *br = pg->port->br; 1438 bool changed = false; 1439 1440 switch (pg->filter_mode) { 1441 case MCAST_INCLUDE: 1442 __grp_src_isexc_incl(pg, srcs, nsrcs, src_size); 1443 changed = true; 1444 break; 1445 case MCAST_EXCLUDE: 1446 changed = __grp_src_isexc_excl(pg, srcs, nsrcs, src_size); 1447 break; 1448 } 1449 1450 pg->filter_mode = MCAST_EXCLUDE; 1451 mod_timer(&pg->timer, jiffies + br_multicast_gmi(br)); 1452 1453 return changed; 1454 } 1455 1456 /* State Msg type New state Actions 1457 * INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI 1458 * Send Q(G,A-B) 1459 */ 1460 static bool __grp_src_toin_incl(struct net_bridge_port_group *pg, 1461 void *srcs, u32 nsrcs, size_t src_size) 1462 { 1463 struct net_bridge *br = pg->port->br; 1464 u32 src_idx, to_send = pg->src_ents; 1465 struct net_bridge_group_src *ent; 1466 unsigned long now = jiffies; 1467 bool changed = false; 1468 struct br_ip src_ip; 1469 1470 hlist_for_each_entry(ent, &pg->src_list, node) 1471 ent->flags |= BR_SGRP_F_SEND; 1472 1473 memset(&src_ip, 0, sizeof(src_ip)); 1474 src_ip.proto = pg->addr.proto; 1475 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1476 memcpy(&src_ip.u, srcs, src_size); 1477 ent = br_multicast_find_group_src(pg, &src_ip); 1478 if (ent) { 1479 ent->flags &= ~BR_SGRP_F_SEND; 1480 to_send--; 1481 } else { 1482 ent = br_multicast_new_group_src(pg, &src_ip); 1483 if (ent) 1484 changed = true; 1485 } 1486 if (ent) 1487 mod_timer(&ent->timer, now + br_multicast_gmi(br)); 1488 srcs += src_size; 1489 } 1490 1491 if (to_send) 1492 __grp_src_query_marked_and_rexmit(pg); 1493 1494 return changed; 1495 } 1496 1497 /* State Msg type New state Actions 1498 * EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI 1499 * Send Q(G,X-A) 1500 * Send Q(G) 1501 */ 1502 static bool __grp_src_toin_excl(struct net_bridge_port_group *pg, 1503 void *srcs, u32 nsrcs, size_t src_size) 1504 { 1505 struct net_bridge *br = pg->port->br; 1506 u32 src_idx, to_send = pg->src_ents; 1507 struct net_bridge_group_src *ent; 1508 unsigned long now = jiffies; 1509 bool changed = false; 1510 struct br_ip src_ip; 1511 1512 hlist_for_each_entry(ent, &pg->src_list, node) 1513 if (timer_pending(&ent->timer)) 1514 ent->flags |= BR_SGRP_F_SEND; 1515 1516 memset(&src_ip, 0, sizeof(src_ip)); 1517 src_ip.proto = pg->addr.proto; 1518 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1519 memcpy(&src_ip.u, srcs, src_size); 1520 ent = br_multicast_find_group_src(pg, &src_ip); 1521 if (ent) { 1522 if (timer_pending(&ent->timer)) { 1523 ent->flags &= ~BR_SGRP_F_SEND; 1524 to_send--; 1525 } 1526 } else { 1527 ent = br_multicast_new_group_src(pg, &src_ip); 1528 if (ent) 1529 changed = true; 1530 } 1531 if (ent) 1532 mod_timer(&ent->timer, now + br_multicast_gmi(br)); 1533 srcs += src_size; 1534 } 1535 1536 if (to_send) 1537 __grp_src_query_marked_and_rexmit(pg); 1538 1539 __grp_send_query_and_rexmit(pg); 1540 1541 return changed; 1542 } 1543 1544 static bool br_multicast_toin(struct net_bridge_port_group *pg, 1545 void *srcs, u32 nsrcs, size_t src_size) 1546 { 1547 bool changed = false; 1548 1549 switch (pg->filter_mode) { 1550 case MCAST_INCLUDE: 1551 changed = __grp_src_toin_incl(pg, srcs, nsrcs, src_size); 1552 break; 1553 case MCAST_EXCLUDE: 1554 changed = __grp_src_toin_excl(pg, srcs, nsrcs, src_size); 1555 break; 1556 } 1557 1558 return changed; 1559 } 1560 1561 /* State Msg type New state Actions 1562 * INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0 1563 * Delete (A-B) 1564 * Send Q(G,A*B) 1565 * Group Timer=GMI 1566 */ 1567 static void __grp_src_toex_incl(struct net_bridge_port_group *pg, 1568 void *srcs, u32 nsrcs, size_t src_size) 1569 { 1570 struct net_bridge_group_src *ent; 1571 u32 src_idx, to_send = 0; 1572 struct br_ip src_ip; 1573 1574 hlist_for_each_entry(ent, &pg->src_list, node) 1575 ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE; 1576 1577 memset(&src_ip, 0, sizeof(src_ip)); 1578 src_ip.proto = pg->addr.proto; 1579 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1580 memcpy(&src_ip.u, srcs, src_size); 1581 ent = br_multicast_find_group_src(pg, &src_ip); 1582 if (ent) { 1583 ent->flags = (ent->flags & ~BR_SGRP_F_DELETE) | 1584 BR_SGRP_F_SEND; 1585 to_send++; 1586 } else { 1587 br_multicast_new_group_src(pg, &src_ip); 1588 } 1589 srcs += src_size; 1590 } 1591 1592 __grp_src_delete_marked(pg); 1593 if (to_send) 1594 __grp_src_query_marked_and_rexmit(pg); 1595 } 1596 1597 /* State Msg type New state Actions 1598 * EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer 1599 * Delete (X-A) 1600 * Delete (Y-A) 1601 * Send Q(G,A-Y) 1602 * Group Timer=GMI 1603 */ 1604 static bool __grp_src_toex_excl(struct net_bridge_port_group *pg, 1605 void *srcs, u32 nsrcs, size_t src_size) 1606 { 1607 struct net_bridge_group_src *ent; 1608 u32 src_idx, to_send = 0; 1609 bool changed = false; 1610 struct br_ip src_ip; 1611 1612 hlist_for_each_entry(ent, &pg->src_list, node) 1613 ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE; 1614 1615 memset(&src_ip, 0, sizeof(src_ip)); 1616 src_ip.proto = pg->addr.proto; 1617 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1618 memcpy(&src_ip.u, srcs, src_size); 1619 ent = br_multicast_find_group_src(pg, &src_ip); 1620 if (ent) { 1621 ent->flags &= ~BR_SGRP_F_DELETE; 1622 } else { 1623 ent = br_multicast_new_group_src(pg, &src_ip); 1624 if (ent) { 1625 mod_timer(&ent->timer, pg->timer.expires); 1626 changed = true; 1627 } 1628 } 1629 if (ent && timer_pending(&ent->timer)) { 1630 ent->flags |= BR_SGRP_F_SEND; 1631 to_send++; 1632 } 1633 srcs += src_size; 1634 } 1635 1636 if (__grp_src_delete_marked(pg)) 1637 changed = true; 1638 if (to_send) 1639 __grp_src_query_marked_and_rexmit(pg); 1640 1641 return changed; 1642 } 1643 1644 static bool br_multicast_toex(struct net_bridge_port_group *pg, 1645 void *srcs, u32 nsrcs, size_t src_size) 1646 { 1647 struct net_bridge *br = pg->port->br; 1648 bool changed = false; 1649 1650 switch (pg->filter_mode) { 1651 case MCAST_INCLUDE: 1652 __grp_src_toex_incl(pg, srcs, nsrcs, src_size); 1653 changed = true; 1654 break; 1655 case MCAST_EXCLUDE: 1656 __grp_src_toex_excl(pg, srcs, nsrcs, src_size); 1657 break; 1658 } 1659 1660 pg->filter_mode = MCAST_EXCLUDE; 1661 mod_timer(&pg->timer, jiffies + br_multicast_gmi(br)); 1662 1663 return changed; 1664 } 1665 1666 /* State Msg type New state Actions 1667 * INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B) 1668 */ 1669 static void __grp_src_block_incl(struct net_bridge_port_group *pg, 1670 void *srcs, u32 nsrcs, size_t src_size) 1671 { 1672 struct net_bridge_group_src *ent; 1673 u32 src_idx, to_send = 0; 1674 struct br_ip src_ip; 1675 1676 hlist_for_each_entry(ent, &pg->src_list, node) 1677 ent->flags &= ~BR_SGRP_F_SEND; 1678 1679 memset(&src_ip, 0, sizeof(src_ip)); 1680 src_ip.proto = pg->addr.proto; 1681 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1682 memcpy(&src_ip.u, srcs, src_size); 1683 ent = br_multicast_find_group_src(pg, &src_ip); 1684 if (ent) { 1685 ent->flags |= BR_SGRP_F_SEND; 1686 to_send++; 1687 } 1688 srcs += src_size; 1689 } 1690 1691 if (to_send) 1692 __grp_src_query_marked_and_rexmit(pg); 1693 1694 if (pg->filter_mode == MCAST_INCLUDE && hlist_empty(&pg->src_list)) 1695 br_multicast_find_del_pg(pg->port->br, pg); 1696 } 1697 1698 /* State Msg type New state Actions 1699 * EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer 1700 * Send Q(G,A-Y) 1701 */ 1702 static bool __grp_src_block_excl(struct net_bridge_port_group *pg, 1703 void *srcs, u32 nsrcs, size_t src_size) 1704 { 1705 struct net_bridge_group_src *ent; 1706 u32 src_idx, to_send = 0; 1707 bool changed = false; 1708 struct br_ip src_ip; 1709 1710 hlist_for_each_entry(ent, &pg->src_list, node) 1711 ent->flags &= ~BR_SGRP_F_SEND; 1712 1713 memset(&src_ip, 0, sizeof(src_ip)); 1714 src_ip.proto = pg->addr.proto; 1715 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 1716 memcpy(&src_ip.u, srcs, src_size); 1717 ent = br_multicast_find_group_src(pg, &src_ip); 1718 if (!ent) { 1719 ent = br_multicast_new_group_src(pg, &src_ip); 1720 if (ent) { 1721 mod_timer(&ent->timer, pg->timer.expires); 1722 changed = true; 1723 } 1724 } 1725 if (ent && timer_pending(&ent->timer)) { 1726 ent->flags |= BR_SGRP_F_SEND; 1727 to_send++; 1728 } 1729 srcs += src_size; 1730 } 1731 1732 if (to_send) 1733 __grp_src_query_marked_and_rexmit(pg); 1734 1735 return changed; 1736 } 1737 1738 static bool br_multicast_block(struct net_bridge_port_group *pg, 1739 void *srcs, u32 nsrcs, size_t src_size) 1740 { 1741 bool changed = false; 1742 1743 switch (pg->filter_mode) { 1744 case MCAST_INCLUDE: 1745 __grp_src_block_incl(pg, srcs, nsrcs, src_size); 1746 break; 1747 case MCAST_EXCLUDE: 1748 changed = __grp_src_block_excl(pg, srcs, nsrcs, src_size); 1749 break; 1750 } 1751 1752 return changed; 1753 } 1754 1755 static struct net_bridge_port_group * 1756 br_multicast_find_port(struct net_bridge_mdb_entry *mp, 1757 struct net_bridge_port *p, 1758 const unsigned char *src) 1759 { 1760 struct net_bridge_port_group *pg; 1761 struct net_bridge *br = mp->br; 1762 1763 for (pg = mlock_dereference(mp->ports, br); 1764 pg; 1765 pg = mlock_dereference(pg->next, br)) 1766 if (br_port_group_equal(pg, p, src)) 1767 return pg; 1768 1769 return NULL; 1770 } 1771 1772 static int br_ip4_multicast_igmp3_report(struct net_bridge *br, 1773 struct net_bridge_port *port, 1774 struct sk_buff *skb, 1775 u16 vid) 1776 { 1777 bool igmpv2 = br->multicast_igmp_version == 2; 1778 struct net_bridge_mdb_entry *mdst; 1779 struct net_bridge_port_group *pg; 1780 const unsigned char *src; 1781 struct igmpv3_report *ih; 1782 struct igmpv3_grec *grec; 1783 int i, len, num, type; 1784 bool changed = false; 1785 __be32 group; 1786 int err = 0; 1787 u16 nsrcs; 1788 1789 ih = igmpv3_report_hdr(skb); 1790 num = ntohs(ih->ngrec); 1791 len = skb_transport_offset(skb) + sizeof(*ih); 1792 1793 for (i = 0; i < num; i++) { 1794 len += sizeof(*grec); 1795 if (!ip_mc_may_pull(skb, len)) 1796 return -EINVAL; 1797 1798 grec = (void *)(skb->data + len - sizeof(*grec)); 1799 group = grec->grec_mca; 1800 type = grec->grec_type; 1801 nsrcs = ntohs(grec->grec_nsrcs); 1802 1803 len += nsrcs * 4; 1804 if (!ip_mc_may_pull(skb, len)) 1805 return -EINVAL; 1806 1807 switch (type) { 1808 case IGMPV3_MODE_IS_INCLUDE: 1809 case IGMPV3_MODE_IS_EXCLUDE: 1810 case IGMPV3_CHANGE_TO_INCLUDE: 1811 case IGMPV3_CHANGE_TO_EXCLUDE: 1812 case IGMPV3_ALLOW_NEW_SOURCES: 1813 case IGMPV3_BLOCK_OLD_SOURCES: 1814 break; 1815 1816 default: 1817 continue; 1818 } 1819 1820 src = eth_hdr(skb)->h_source; 1821 if (nsrcs == 0 && 1822 (type == IGMPV3_CHANGE_TO_INCLUDE || 1823 type == IGMPV3_MODE_IS_INCLUDE)) { 1824 if (!port || igmpv2) { 1825 br_ip4_multicast_leave_group(br, port, group, vid, src); 1826 continue; 1827 } 1828 } else { 1829 err = br_ip4_multicast_add_group(br, port, group, vid, 1830 src, igmpv2); 1831 if (err) 1832 break; 1833 } 1834 1835 if (!port || igmpv2) 1836 continue; 1837 1838 spin_lock_bh(&br->multicast_lock); 1839 mdst = br_mdb_ip4_get(br, group, vid); 1840 if (!mdst) 1841 goto unlock_continue; 1842 pg = br_multicast_find_port(mdst, port, src); 1843 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT)) 1844 goto unlock_continue; 1845 /* reload grec */ 1846 grec = (void *)(skb->data + len - sizeof(*grec) - (nsrcs * 4)); 1847 switch (type) { 1848 case IGMPV3_ALLOW_NEW_SOURCES: 1849 changed = br_multicast_isinc_allow(pg, grec->grec_src, 1850 nsrcs, sizeof(__be32)); 1851 break; 1852 case IGMPV3_MODE_IS_INCLUDE: 1853 changed = br_multicast_isinc_allow(pg, grec->grec_src, nsrcs, 1854 sizeof(__be32)); 1855 break; 1856 case IGMPV3_MODE_IS_EXCLUDE: 1857 changed = br_multicast_isexc(pg, grec->grec_src, nsrcs, 1858 sizeof(__be32)); 1859 break; 1860 case IGMPV3_CHANGE_TO_INCLUDE: 1861 changed = br_multicast_toin(pg, grec->grec_src, nsrcs, 1862 sizeof(__be32)); 1863 break; 1864 case IGMPV3_CHANGE_TO_EXCLUDE: 1865 changed = br_multicast_toex(pg, grec->grec_src, nsrcs, 1866 sizeof(__be32)); 1867 break; 1868 case IGMPV3_BLOCK_OLD_SOURCES: 1869 changed = br_multicast_block(pg, grec->grec_src, nsrcs, 1870 sizeof(__be32)); 1871 break; 1872 } 1873 if (changed) 1874 br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB); 1875 unlock_continue: 1876 spin_unlock_bh(&br->multicast_lock); 1877 } 1878 1879 return err; 1880 } 1881 1882 #if IS_ENABLED(CONFIG_IPV6) 1883 static int br_ip6_multicast_mld2_report(struct net_bridge *br, 1884 struct net_bridge_port *port, 1885 struct sk_buff *skb, 1886 u16 vid) 1887 { 1888 bool mldv1 = br->multicast_mld_version == 1; 1889 struct net_bridge_mdb_entry *mdst; 1890 struct net_bridge_port_group *pg; 1891 unsigned int nsrcs_offset; 1892 const unsigned char *src; 1893 struct icmp6hdr *icmp6h; 1894 struct mld2_grec *grec; 1895 unsigned int grec_len; 1896 bool changed = false; 1897 int i, len, num; 1898 int err = 0; 1899 1900 if (!ipv6_mc_may_pull(skb, sizeof(*icmp6h))) 1901 return -EINVAL; 1902 1903 icmp6h = icmp6_hdr(skb); 1904 num = ntohs(icmp6h->icmp6_dataun.un_data16[1]); 1905 len = skb_transport_offset(skb) + sizeof(*icmp6h); 1906 1907 for (i = 0; i < num; i++) { 1908 __be16 *_nsrcs, __nsrcs; 1909 u16 nsrcs; 1910 1911 nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs); 1912 1913 if (skb_transport_offset(skb) + ipv6_transport_len(skb) < 1914 nsrcs_offset + sizeof(__nsrcs)) 1915 return -EINVAL; 1916 1917 _nsrcs = skb_header_pointer(skb, nsrcs_offset, 1918 sizeof(__nsrcs), &__nsrcs); 1919 if (!_nsrcs) 1920 return -EINVAL; 1921 1922 nsrcs = ntohs(*_nsrcs); 1923 grec_len = struct_size(grec, grec_src, nsrcs); 1924 1925 if (!ipv6_mc_may_pull(skb, len + grec_len)) 1926 return -EINVAL; 1927 1928 grec = (struct mld2_grec *)(skb->data + len); 1929 len += grec_len; 1930 1931 switch (grec->grec_type) { 1932 case MLD2_MODE_IS_INCLUDE: 1933 case MLD2_MODE_IS_EXCLUDE: 1934 case MLD2_CHANGE_TO_INCLUDE: 1935 case MLD2_CHANGE_TO_EXCLUDE: 1936 case MLD2_ALLOW_NEW_SOURCES: 1937 case MLD2_BLOCK_OLD_SOURCES: 1938 break; 1939 1940 default: 1941 continue; 1942 } 1943 1944 src = eth_hdr(skb)->h_source; 1945 if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE || 1946 grec->grec_type == MLD2_MODE_IS_INCLUDE) && 1947 nsrcs == 0) { 1948 if (!port || mldv1) { 1949 br_ip6_multicast_leave_group(br, port, 1950 &grec->grec_mca, 1951 vid, src); 1952 continue; 1953 } 1954 } else { 1955 err = br_ip6_multicast_add_group(br, port, 1956 &grec->grec_mca, vid, 1957 src, mldv1); 1958 if (err) 1959 break; 1960 } 1961 1962 if (!port || mldv1) 1963 continue; 1964 1965 spin_lock_bh(&br->multicast_lock); 1966 mdst = br_mdb_ip6_get(br, &grec->grec_mca, vid); 1967 if (!mdst) 1968 goto unlock_continue; 1969 pg = br_multicast_find_port(mdst, port, src); 1970 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT)) 1971 goto unlock_continue; 1972 switch (grec->grec_type) { 1973 case MLD2_ALLOW_NEW_SOURCES: 1974 changed = br_multicast_isinc_allow(pg, grec->grec_src, 1975 nsrcs, 1976 sizeof(struct in6_addr)); 1977 break; 1978 case MLD2_MODE_IS_INCLUDE: 1979 changed = br_multicast_isinc_allow(pg, grec->grec_src, nsrcs, 1980 sizeof(struct in6_addr)); 1981 break; 1982 case MLD2_MODE_IS_EXCLUDE: 1983 changed = br_multicast_isexc(pg, grec->grec_src, nsrcs, 1984 sizeof(struct in6_addr)); 1985 break; 1986 case MLD2_CHANGE_TO_INCLUDE: 1987 changed = br_multicast_toin(pg, grec->grec_src, nsrcs, 1988 sizeof(struct in6_addr)); 1989 break; 1990 case MLD2_CHANGE_TO_EXCLUDE: 1991 changed = br_multicast_toex(pg, grec->grec_src, nsrcs, 1992 sizeof(struct in6_addr)); 1993 break; 1994 case MLD2_BLOCK_OLD_SOURCES: 1995 changed = br_multicast_block(pg, grec->grec_src, nsrcs, 1996 sizeof(struct in6_addr)); 1997 break; 1998 } 1999 if (changed) 2000 br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB); 2001 unlock_continue: 2002 spin_unlock_bh(&br->multicast_lock); 2003 } 2004 2005 return err; 2006 } 2007 #endif 2008 2009 static bool br_ip4_multicast_select_querier(struct net_bridge *br, 2010 struct net_bridge_port *port, 2011 __be32 saddr) 2012 { 2013 if (!timer_pending(&br->ip4_own_query.timer) && 2014 !timer_pending(&br->ip4_other_query.timer)) 2015 goto update; 2016 2017 if (!br->ip4_querier.addr.u.ip4) 2018 goto update; 2019 2020 if (ntohl(saddr) <= ntohl(br->ip4_querier.addr.u.ip4)) 2021 goto update; 2022 2023 return false; 2024 2025 update: 2026 br->ip4_querier.addr.u.ip4 = saddr; 2027 2028 /* update protected by general multicast_lock by caller */ 2029 rcu_assign_pointer(br->ip4_querier.port, port); 2030 2031 return true; 2032 } 2033 2034 #if IS_ENABLED(CONFIG_IPV6) 2035 static bool br_ip6_multicast_select_querier(struct net_bridge *br, 2036 struct net_bridge_port *port, 2037 struct in6_addr *saddr) 2038 { 2039 if (!timer_pending(&br->ip6_own_query.timer) && 2040 !timer_pending(&br->ip6_other_query.timer)) 2041 goto update; 2042 2043 if (ipv6_addr_cmp(saddr, &br->ip6_querier.addr.u.ip6) <= 0) 2044 goto update; 2045 2046 return false; 2047 2048 update: 2049 br->ip6_querier.addr.u.ip6 = *saddr; 2050 2051 /* update protected by general multicast_lock by caller */ 2052 rcu_assign_pointer(br->ip6_querier.port, port); 2053 2054 return true; 2055 } 2056 #endif 2057 2058 static bool br_multicast_select_querier(struct net_bridge *br, 2059 struct net_bridge_port *port, 2060 struct br_ip *saddr) 2061 { 2062 switch (saddr->proto) { 2063 case htons(ETH_P_IP): 2064 return br_ip4_multicast_select_querier(br, port, saddr->u.ip4); 2065 #if IS_ENABLED(CONFIG_IPV6) 2066 case htons(ETH_P_IPV6): 2067 return br_ip6_multicast_select_querier(br, port, &saddr->u.ip6); 2068 #endif 2069 } 2070 2071 return false; 2072 } 2073 2074 static void 2075 br_multicast_update_query_timer(struct net_bridge *br, 2076 struct bridge_mcast_other_query *query, 2077 unsigned long max_delay) 2078 { 2079 if (!timer_pending(&query->timer)) 2080 query->delay_time = jiffies + max_delay; 2081 2082 mod_timer(&query->timer, jiffies + br->multicast_querier_interval); 2083 } 2084 2085 static void br_port_mc_router_state_change(struct net_bridge_port *p, 2086 bool is_mc_router) 2087 { 2088 struct switchdev_attr attr = { 2089 .orig_dev = p->dev, 2090 .id = SWITCHDEV_ATTR_ID_PORT_MROUTER, 2091 .flags = SWITCHDEV_F_DEFER, 2092 .u.mrouter = is_mc_router, 2093 }; 2094 2095 switchdev_port_attr_set(p->dev, &attr); 2096 } 2097 2098 /* 2099 * Add port to router_list 2100 * list is maintained ordered by pointer value 2101 * and locked by br->multicast_lock and RCU 2102 */ 2103 static void br_multicast_add_router(struct net_bridge *br, 2104 struct net_bridge_port *port) 2105 { 2106 struct net_bridge_port *p; 2107 struct hlist_node *slot = NULL; 2108 2109 if (!hlist_unhashed(&port->rlist)) 2110 return; 2111 2112 hlist_for_each_entry(p, &br->router_list, rlist) { 2113 if ((unsigned long) port >= (unsigned long) p) 2114 break; 2115 slot = &p->rlist; 2116 } 2117 2118 if (slot) 2119 hlist_add_behind_rcu(&port->rlist, slot); 2120 else 2121 hlist_add_head_rcu(&port->rlist, &br->router_list); 2122 br_rtr_notify(br->dev, port, RTM_NEWMDB); 2123 br_port_mc_router_state_change(port, true); 2124 } 2125 2126 static void br_multicast_mark_router(struct net_bridge *br, 2127 struct net_bridge_port *port) 2128 { 2129 unsigned long now = jiffies; 2130 2131 if (!port) { 2132 if (br->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) { 2133 if (!timer_pending(&br->multicast_router_timer)) 2134 br_mc_router_state_change(br, true); 2135 mod_timer(&br->multicast_router_timer, 2136 now + br->multicast_querier_interval); 2137 } 2138 return; 2139 } 2140 2141 if (port->multicast_router == MDB_RTR_TYPE_DISABLED || 2142 port->multicast_router == MDB_RTR_TYPE_PERM) 2143 return; 2144 2145 br_multicast_add_router(br, port); 2146 2147 mod_timer(&port->multicast_router_timer, 2148 now + br->multicast_querier_interval); 2149 } 2150 2151 static void br_multicast_query_received(struct net_bridge *br, 2152 struct net_bridge_port *port, 2153 struct bridge_mcast_other_query *query, 2154 struct br_ip *saddr, 2155 unsigned long max_delay) 2156 { 2157 if (!br_multicast_select_querier(br, port, saddr)) 2158 return; 2159 2160 br_multicast_update_query_timer(br, query, max_delay); 2161 br_multicast_mark_router(br, port); 2162 } 2163 2164 static void br_ip4_multicast_query(struct net_bridge *br, 2165 struct net_bridge_port *port, 2166 struct sk_buff *skb, 2167 u16 vid) 2168 { 2169 unsigned int transport_len = ip_transport_len(skb); 2170 const struct iphdr *iph = ip_hdr(skb); 2171 struct igmphdr *ih = igmp_hdr(skb); 2172 struct net_bridge_mdb_entry *mp; 2173 struct igmpv3_query *ih3; 2174 struct net_bridge_port_group *p; 2175 struct net_bridge_port_group __rcu **pp; 2176 struct br_ip saddr; 2177 unsigned long max_delay; 2178 unsigned long now = jiffies; 2179 __be32 group; 2180 2181 spin_lock(&br->multicast_lock); 2182 if (!netif_running(br->dev) || 2183 (port && port->state == BR_STATE_DISABLED)) 2184 goto out; 2185 2186 group = ih->group; 2187 2188 if (transport_len == sizeof(*ih)) { 2189 max_delay = ih->code * (HZ / IGMP_TIMER_SCALE); 2190 2191 if (!max_delay) { 2192 max_delay = 10 * HZ; 2193 group = 0; 2194 } 2195 } else if (transport_len >= sizeof(*ih3)) { 2196 ih3 = igmpv3_query_hdr(skb); 2197 if (ih3->nsrcs || 2198 (br->multicast_igmp_version == 3 && group && ih3->suppress)) 2199 goto out; 2200 2201 max_delay = ih3->code ? 2202 IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1; 2203 } else { 2204 goto out; 2205 } 2206 2207 if (!group) { 2208 saddr.proto = htons(ETH_P_IP); 2209 saddr.u.ip4 = iph->saddr; 2210 2211 br_multicast_query_received(br, port, &br->ip4_other_query, 2212 &saddr, max_delay); 2213 goto out; 2214 } 2215 2216 mp = br_mdb_ip4_get(br, group, vid); 2217 if (!mp) 2218 goto out; 2219 2220 max_delay *= br->multicast_last_member_count; 2221 2222 if (mp->host_joined && 2223 (timer_pending(&mp->timer) ? 2224 time_after(mp->timer.expires, now + max_delay) : 2225 try_to_del_timer_sync(&mp->timer) >= 0)) 2226 mod_timer(&mp->timer, now + max_delay); 2227 2228 for (pp = &mp->ports; 2229 (p = mlock_dereference(*pp, br)) != NULL; 2230 pp = &p->next) { 2231 if (timer_pending(&p->timer) ? 2232 time_after(p->timer.expires, now + max_delay) : 2233 try_to_del_timer_sync(&p->timer) >= 0 && 2234 (br->multicast_igmp_version == 2 || 2235 p->filter_mode == MCAST_EXCLUDE)) 2236 mod_timer(&p->timer, now + max_delay); 2237 } 2238 2239 out: 2240 spin_unlock(&br->multicast_lock); 2241 } 2242 2243 #if IS_ENABLED(CONFIG_IPV6) 2244 static int br_ip6_multicast_query(struct net_bridge *br, 2245 struct net_bridge_port *port, 2246 struct sk_buff *skb, 2247 u16 vid) 2248 { 2249 unsigned int transport_len = ipv6_transport_len(skb); 2250 struct mld_msg *mld; 2251 struct net_bridge_mdb_entry *mp; 2252 struct mld2_query *mld2q; 2253 struct net_bridge_port_group *p; 2254 struct net_bridge_port_group __rcu **pp; 2255 struct br_ip saddr; 2256 unsigned long max_delay; 2257 unsigned long now = jiffies; 2258 unsigned int offset = skb_transport_offset(skb); 2259 const struct in6_addr *group = NULL; 2260 bool is_general_query; 2261 int err = 0; 2262 2263 spin_lock(&br->multicast_lock); 2264 if (!netif_running(br->dev) || 2265 (port && port->state == BR_STATE_DISABLED)) 2266 goto out; 2267 2268 if (transport_len == sizeof(*mld)) { 2269 if (!pskb_may_pull(skb, offset + sizeof(*mld))) { 2270 err = -EINVAL; 2271 goto out; 2272 } 2273 mld = (struct mld_msg *) icmp6_hdr(skb); 2274 max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay)); 2275 if (max_delay) 2276 group = &mld->mld_mca; 2277 } else { 2278 if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) { 2279 err = -EINVAL; 2280 goto out; 2281 } 2282 mld2q = (struct mld2_query *)icmp6_hdr(skb); 2283 if (!mld2q->mld2q_nsrcs) 2284 group = &mld2q->mld2q_mca; 2285 if (br->multicast_mld_version == 2 && 2286 !ipv6_addr_any(&mld2q->mld2q_mca) && 2287 mld2q->mld2q_suppress) 2288 goto out; 2289 2290 max_delay = max(msecs_to_jiffies(mldv2_mrc(mld2q)), 1UL); 2291 } 2292 2293 is_general_query = group && ipv6_addr_any(group); 2294 2295 if (is_general_query) { 2296 saddr.proto = htons(ETH_P_IPV6); 2297 saddr.u.ip6 = ipv6_hdr(skb)->saddr; 2298 2299 br_multicast_query_received(br, port, &br->ip6_other_query, 2300 &saddr, max_delay); 2301 goto out; 2302 } else if (!group) { 2303 goto out; 2304 } 2305 2306 mp = br_mdb_ip6_get(br, group, vid); 2307 if (!mp) 2308 goto out; 2309 2310 max_delay *= br->multicast_last_member_count; 2311 if (mp->host_joined && 2312 (timer_pending(&mp->timer) ? 2313 time_after(mp->timer.expires, now + max_delay) : 2314 try_to_del_timer_sync(&mp->timer) >= 0)) 2315 mod_timer(&mp->timer, now + max_delay); 2316 2317 for (pp = &mp->ports; 2318 (p = mlock_dereference(*pp, br)) != NULL; 2319 pp = &p->next) { 2320 if (timer_pending(&p->timer) ? 2321 time_after(p->timer.expires, now + max_delay) : 2322 try_to_del_timer_sync(&p->timer) >= 0 && 2323 (br->multicast_mld_version == 1 || 2324 p->filter_mode == MCAST_EXCLUDE)) 2325 mod_timer(&p->timer, now + max_delay); 2326 } 2327 2328 out: 2329 spin_unlock(&br->multicast_lock); 2330 return err; 2331 } 2332 #endif 2333 2334 static void 2335 br_multicast_leave_group(struct net_bridge *br, 2336 struct net_bridge_port *port, 2337 struct br_ip *group, 2338 struct bridge_mcast_other_query *other_query, 2339 struct bridge_mcast_own_query *own_query, 2340 const unsigned char *src) 2341 { 2342 struct net_bridge_mdb_entry *mp; 2343 struct net_bridge_port_group *p; 2344 unsigned long now; 2345 unsigned long time; 2346 2347 spin_lock(&br->multicast_lock); 2348 if (!netif_running(br->dev) || 2349 (port && port->state == BR_STATE_DISABLED)) 2350 goto out; 2351 2352 mp = br_mdb_ip_get(br, group); 2353 if (!mp) 2354 goto out; 2355 2356 if (port && (port->flags & BR_MULTICAST_FAST_LEAVE)) { 2357 struct net_bridge_port_group __rcu **pp; 2358 2359 for (pp = &mp->ports; 2360 (p = mlock_dereference(*pp, br)) != NULL; 2361 pp = &p->next) { 2362 if (!br_port_group_equal(p, port, src)) 2363 continue; 2364 2365 if (p->flags & MDB_PG_FLAGS_PERMANENT) 2366 break; 2367 2368 p->flags |= MDB_PG_FLAGS_FAST_LEAVE; 2369 br_multicast_del_pg(mp, p, pp); 2370 } 2371 goto out; 2372 } 2373 2374 if (timer_pending(&other_query->timer)) 2375 goto out; 2376 2377 if (br_opt_get(br, BROPT_MULTICAST_QUERIER)) { 2378 __br_multicast_send_query(br, port, NULL, NULL, &mp->addr, 2379 false, 0, NULL); 2380 2381 time = jiffies + br->multicast_last_member_count * 2382 br->multicast_last_member_interval; 2383 2384 mod_timer(&own_query->timer, time); 2385 2386 for (p = mlock_dereference(mp->ports, br); 2387 p != NULL; 2388 p = mlock_dereference(p->next, br)) { 2389 if (!br_port_group_equal(p, port, src)) 2390 continue; 2391 2392 if (!hlist_unhashed(&p->mglist) && 2393 (timer_pending(&p->timer) ? 2394 time_after(p->timer.expires, time) : 2395 try_to_del_timer_sync(&p->timer) >= 0)) { 2396 mod_timer(&p->timer, time); 2397 } 2398 2399 break; 2400 } 2401 } 2402 2403 now = jiffies; 2404 time = now + br->multicast_last_member_count * 2405 br->multicast_last_member_interval; 2406 2407 if (!port) { 2408 if (mp->host_joined && 2409 (timer_pending(&mp->timer) ? 2410 time_after(mp->timer.expires, time) : 2411 try_to_del_timer_sync(&mp->timer) >= 0)) { 2412 mod_timer(&mp->timer, time); 2413 } 2414 2415 goto out; 2416 } 2417 2418 for (p = mlock_dereference(mp->ports, br); 2419 p != NULL; 2420 p = mlock_dereference(p->next, br)) { 2421 if (p->port != port) 2422 continue; 2423 2424 if (!hlist_unhashed(&p->mglist) && 2425 (timer_pending(&p->timer) ? 2426 time_after(p->timer.expires, time) : 2427 try_to_del_timer_sync(&p->timer) >= 0)) { 2428 mod_timer(&p->timer, time); 2429 } 2430 2431 break; 2432 } 2433 out: 2434 spin_unlock(&br->multicast_lock); 2435 } 2436 2437 static void br_ip4_multicast_leave_group(struct net_bridge *br, 2438 struct net_bridge_port *port, 2439 __be32 group, 2440 __u16 vid, 2441 const unsigned char *src) 2442 { 2443 struct br_ip br_group; 2444 struct bridge_mcast_own_query *own_query; 2445 2446 if (ipv4_is_local_multicast(group)) 2447 return; 2448 2449 own_query = port ? &port->ip4_own_query : &br->ip4_own_query; 2450 2451 memset(&br_group, 0, sizeof(br_group)); 2452 br_group.u.ip4 = group; 2453 br_group.proto = htons(ETH_P_IP); 2454 br_group.vid = vid; 2455 2456 br_multicast_leave_group(br, port, &br_group, &br->ip4_other_query, 2457 own_query, src); 2458 } 2459 2460 #if IS_ENABLED(CONFIG_IPV6) 2461 static void br_ip6_multicast_leave_group(struct net_bridge *br, 2462 struct net_bridge_port *port, 2463 const struct in6_addr *group, 2464 __u16 vid, 2465 const unsigned char *src) 2466 { 2467 struct br_ip br_group; 2468 struct bridge_mcast_own_query *own_query; 2469 2470 if (ipv6_addr_is_ll_all_nodes(group)) 2471 return; 2472 2473 own_query = port ? &port->ip6_own_query : &br->ip6_own_query; 2474 2475 memset(&br_group, 0, sizeof(br_group)); 2476 br_group.u.ip6 = *group; 2477 br_group.proto = htons(ETH_P_IPV6); 2478 br_group.vid = vid; 2479 2480 br_multicast_leave_group(br, port, &br_group, &br->ip6_other_query, 2481 own_query, src); 2482 } 2483 #endif 2484 2485 static void br_multicast_err_count(const struct net_bridge *br, 2486 const struct net_bridge_port *p, 2487 __be16 proto) 2488 { 2489 struct bridge_mcast_stats __percpu *stats; 2490 struct bridge_mcast_stats *pstats; 2491 2492 if (!br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED)) 2493 return; 2494 2495 if (p) 2496 stats = p->mcast_stats; 2497 else 2498 stats = br->mcast_stats; 2499 if (WARN_ON(!stats)) 2500 return; 2501 2502 pstats = this_cpu_ptr(stats); 2503 2504 u64_stats_update_begin(&pstats->syncp); 2505 switch (proto) { 2506 case htons(ETH_P_IP): 2507 pstats->mstats.igmp_parse_errors++; 2508 break; 2509 #if IS_ENABLED(CONFIG_IPV6) 2510 case htons(ETH_P_IPV6): 2511 pstats->mstats.mld_parse_errors++; 2512 break; 2513 #endif 2514 } 2515 u64_stats_update_end(&pstats->syncp); 2516 } 2517 2518 static void br_multicast_pim(struct net_bridge *br, 2519 struct net_bridge_port *port, 2520 const struct sk_buff *skb) 2521 { 2522 unsigned int offset = skb_transport_offset(skb); 2523 struct pimhdr *pimhdr, _pimhdr; 2524 2525 pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr); 2526 if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION || 2527 pim_hdr_type(pimhdr) != PIM_TYPE_HELLO) 2528 return; 2529 2530 br_multicast_mark_router(br, port); 2531 } 2532 2533 static int br_ip4_multicast_mrd_rcv(struct net_bridge *br, 2534 struct net_bridge_port *port, 2535 struct sk_buff *skb) 2536 { 2537 if (ip_hdr(skb)->protocol != IPPROTO_IGMP || 2538 igmp_hdr(skb)->type != IGMP_MRDISC_ADV) 2539 return -ENOMSG; 2540 2541 br_multicast_mark_router(br, port); 2542 2543 return 0; 2544 } 2545 2546 static int br_multicast_ipv4_rcv(struct net_bridge *br, 2547 struct net_bridge_port *port, 2548 struct sk_buff *skb, 2549 u16 vid) 2550 { 2551 const unsigned char *src; 2552 struct igmphdr *ih; 2553 int err; 2554 2555 err = ip_mc_check_igmp(skb); 2556 2557 if (err == -ENOMSG) { 2558 if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) { 2559 BR_INPUT_SKB_CB(skb)->mrouters_only = 1; 2560 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) { 2561 if (ip_hdr(skb)->protocol == IPPROTO_PIM) 2562 br_multicast_pim(br, port, skb); 2563 } else if (ipv4_is_all_snoopers(ip_hdr(skb)->daddr)) { 2564 br_ip4_multicast_mrd_rcv(br, port, skb); 2565 } 2566 2567 return 0; 2568 } else if (err < 0) { 2569 br_multicast_err_count(br, port, skb->protocol); 2570 return err; 2571 } 2572 2573 ih = igmp_hdr(skb); 2574 src = eth_hdr(skb)->h_source; 2575 BR_INPUT_SKB_CB(skb)->igmp = ih->type; 2576 2577 switch (ih->type) { 2578 case IGMP_HOST_MEMBERSHIP_REPORT: 2579 case IGMPV2_HOST_MEMBERSHIP_REPORT: 2580 BR_INPUT_SKB_CB(skb)->mrouters_only = 1; 2581 err = br_ip4_multicast_add_group(br, port, ih->group, vid, src, 2582 true); 2583 break; 2584 case IGMPV3_HOST_MEMBERSHIP_REPORT: 2585 err = br_ip4_multicast_igmp3_report(br, port, skb, vid); 2586 break; 2587 case IGMP_HOST_MEMBERSHIP_QUERY: 2588 br_ip4_multicast_query(br, port, skb, vid); 2589 break; 2590 case IGMP_HOST_LEAVE_MESSAGE: 2591 br_ip4_multicast_leave_group(br, port, ih->group, vid, src); 2592 break; 2593 } 2594 2595 br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp, 2596 BR_MCAST_DIR_RX); 2597 2598 return err; 2599 } 2600 2601 #if IS_ENABLED(CONFIG_IPV6) 2602 static int br_ip6_multicast_mrd_rcv(struct net_bridge *br, 2603 struct net_bridge_port *port, 2604 struct sk_buff *skb) 2605 { 2606 int ret; 2607 2608 if (ipv6_hdr(skb)->nexthdr != IPPROTO_ICMPV6) 2609 return -ENOMSG; 2610 2611 ret = ipv6_mc_check_icmpv6(skb); 2612 if (ret < 0) 2613 return ret; 2614 2615 if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV) 2616 return -ENOMSG; 2617 2618 br_multicast_mark_router(br, port); 2619 2620 return 0; 2621 } 2622 2623 static int br_multicast_ipv6_rcv(struct net_bridge *br, 2624 struct net_bridge_port *port, 2625 struct sk_buff *skb, 2626 u16 vid) 2627 { 2628 const unsigned char *src; 2629 struct mld_msg *mld; 2630 int err; 2631 2632 err = ipv6_mc_check_mld(skb); 2633 2634 if (err == -ENOMSG) { 2635 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr)) 2636 BR_INPUT_SKB_CB(skb)->mrouters_only = 1; 2637 2638 if (ipv6_addr_is_all_snoopers(&ipv6_hdr(skb)->daddr)) { 2639 err = br_ip6_multicast_mrd_rcv(br, port, skb); 2640 2641 if (err < 0 && err != -ENOMSG) { 2642 br_multicast_err_count(br, port, skb->protocol); 2643 return err; 2644 } 2645 } 2646 2647 return 0; 2648 } else if (err < 0) { 2649 br_multicast_err_count(br, port, skb->protocol); 2650 return err; 2651 } 2652 2653 mld = (struct mld_msg *)skb_transport_header(skb); 2654 BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type; 2655 2656 switch (mld->mld_type) { 2657 case ICMPV6_MGM_REPORT: 2658 src = eth_hdr(skb)->h_source; 2659 BR_INPUT_SKB_CB(skb)->mrouters_only = 1; 2660 err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid, 2661 src, true); 2662 break; 2663 case ICMPV6_MLD2_REPORT: 2664 err = br_ip6_multicast_mld2_report(br, port, skb, vid); 2665 break; 2666 case ICMPV6_MGM_QUERY: 2667 err = br_ip6_multicast_query(br, port, skb, vid); 2668 break; 2669 case ICMPV6_MGM_REDUCTION: 2670 src = eth_hdr(skb)->h_source; 2671 br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid, src); 2672 break; 2673 } 2674 2675 br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp, 2676 BR_MCAST_DIR_RX); 2677 2678 return err; 2679 } 2680 #endif 2681 2682 int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port, 2683 struct sk_buff *skb, u16 vid) 2684 { 2685 int ret = 0; 2686 2687 BR_INPUT_SKB_CB(skb)->igmp = 0; 2688 BR_INPUT_SKB_CB(skb)->mrouters_only = 0; 2689 2690 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) 2691 return 0; 2692 2693 switch (skb->protocol) { 2694 case htons(ETH_P_IP): 2695 ret = br_multicast_ipv4_rcv(br, port, skb, vid); 2696 break; 2697 #if IS_ENABLED(CONFIG_IPV6) 2698 case htons(ETH_P_IPV6): 2699 ret = br_multicast_ipv6_rcv(br, port, skb, vid); 2700 break; 2701 #endif 2702 } 2703 2704 return ret; 2705 } 2706 2707 static void br_multicast_query_expired(struct net_bridge *br, 2708 struct bridge_mcast_own_query *query, 2709 struct bridge_mcast_querier *querier) 2710 { 2711 spin_lock(&br->multicast_lock); 2712 if (query->startup_sent < br->multicast_startup_query_count) 2713 query->startup_sent++; 2714 2715 RCU_INIT_POINTER(querier->port, NULL); 2716 br_multicast_send_query(br, NULL, query); 2717 spin_unlock(&br->multicast_lock); 2718 } 2719 2720 static void br_ip4_multicast_query_expired(struct timer_list *t) 2721 { 2722 struct net_bridge *br = from_timer(br, t, ip4_own_query.timer); 2723 2724 br_multicast_query_expired(br, &br->ip4_own_query, &br->ip4_querier); 2725 } 2726 2727 #if IS_ENABLED(CONFIG_IPV6) 2728 static void br_ip6_multicast_query_expired(struct timer_list *t) 2729 { 2730 struct net_bridge *br = from_timer(br, t, ip6_own_query.timer); 2731 2732 br_multicast_query_expired(br, &br->ip6_own_query, &br->ip6_querier); 2733 } 2734 #endif 2735 2736 static void __grp_src_gc(struct hlist_head *head) 2737 { 2738 struct net_bridge_group_src *ent; 2739 struct hlist_node *tmp; 2740 2741 hlist_for_each_entry_safe(ent, tmp, head, del_node) { 2742 hlist_del_init(&ent->del_node); 2743 del_timer_sync(&ent->timer); 2744 kfree_rcu(ent, rcu); 2745 } 2746 } 2747 2748 static void br_multicast_src_gc(struct work_struct *work) 2749 { 2750 struct net_bridge *br = container_of(work, struct net_bridge, 2751 src_gc_work); 2752 HLIST_HEAD(deleted_head); 2753 2754 spin_lock_bh(&br->multicast_lock); 2755 hlist_move_list(&br->src_gc_list, &deleted_head); 2756 spin_unlock_bh(&br->multicast_lock); 2757 2758 __grp_src_gc(&deleted_head); 2759 } 2760 2761 void br_multicast_init(struct net_bridge *br) 2762 { 2763 br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX; 2764 2765 br->multicast_router = MDB_RTR_TYPE_TEMP_QUERY; 2766 br->multicast_last_member_count = 2; 2767 br->multicast_startup_query_count = 2; 2768 2769 br->multicast_last_member_interval = HZ; 2770 br->multicast_query_response_interval = 10 * HZ; 2771 br->multicast_startup_query_interval = 125 * HZ / 4; 2772 br->multicast_query_interval = 125 * HZ; 2773 br->multicast_querier_interval = 255 * HZ; 2774 br->multicast_membership_interval = 260 * HZ; 2775 2776 br->ip4_other_query.delay_time = 0; 2777 br->ip4_querier.port = NULL; 2778 br->multicast_igmp_version = 2; 2779 #if IS_ENABLED(CONFIG_IPV6) 2780 br->multicast_mld_version = 1; 2781 br->ip6_other_query.delay_time = 0; 2782 br->ip6_querier.port = NULL; 2783 #endif 2784 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true); 2785 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true); 2786 2787 spin_lock_init(&br->multicast_lock); 2788 timer_setup(&br->multicast_router_timer, 2789 br_multicast_local_router_expired, 0); 2790 timer_setup(&br->ip4_other_query.timer, 2791 br_ip4_multicast_querier_expired, 0); 2792 timer_setup(&br->ip4_own_query.timer, 2793 br_ip4_multicast_query_expired, 0); 2794 #if IS_ENABLED(CONFIG_IPV6) 2795 timer_setup(&br->ip6_other_query.timer, 2796 br_ip6_multicast_querier_expired, 0); 2797 timer_setup(&br->ip6_own_query.timer, 2798 br_ip6_multicast_query_expired, 0); 2799 #endif 2800 INIT_HLIST_HEAD(&br->mdb_list); 2801 INIT_HLIST_HEAD(&br->src_gc_list); 2802 INIT_WORK(&br->src_gc_work, br_multicast_src_gc); 2803 } 2804 2805 static void br_ip4_multicast_join_snoopers(struct net_bridge *br) 2806 { 2807 struct in_device *in_dev = in_dev_get(br->dev); 2808 2809 if (!in_dev) 2810 return; 2811 2812 __ip_mc_inc_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC); 2813 in_dev_put(in_dev); 2814 } 2815 2816 #if IS_ENABLED(CONFIG_IPV6) 2817 static void br_ip6_multicast_join_snoopers(struct net_bridge *br) 2818 { 2819 struct in6_addr addr; 2820 2821 ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a)); 2822 ipv6_dev_mc_inc(br->dev, &addr); 2823 } 2824 #else 2825 static inline void br_ip6_multicast_join_snoopers(struct net_bridge *br) 2826 { 2827 } 2828 #endif 2829 2830 static void br_multicast_join_snoopers(struct net_bridge *br) 2831 { 2832 br_ip4_multicast_join_snoopers(br); 2833 br_ip6_multicast_join_snoopers(br); 2834 } 2835 2836 static void br_ip4_multicast_leave_snoopers(struct net_bridge *br) 2837 { 2838 struct in_device *in_dev = in_dev_get(br->dev); 2839 2840 if (WARN_ON(!in_dev)) 2841 return; 2842 2843 __ip_mc_dec_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC); 2844 in_dev_put(in_dev); 2845 } 2846 2847 #if IS_ENABLED(CONFIG_IPV6) 2848 static void br_ip6_multicast_leave_snoopers(struct net_bridge *br) 2849 { 2850 struct in6_addr addr; 2851 2852 ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a)); 2853 ipv6_dev_mc_dec(br->dev, &addr); 2854 } 2855 #else 2856 static inline void br_ip6_multicast_leave_snoopers(struct net_bridge *br) 2857 { 2858 } 2859 #endif 2860 2861 static void br_multicast_leave_snoopers(struct net_bridge *br) 2862 { 2863 br_ip4_multicast_leave_snoopers(br); 2864 br_ip6_multicast_leave_snoopers(br); 2865 } 2866 2867 static void __br_multicast_open(struct net_bridge *br, 2868 struct bridge_mcast_own_query *query) 2869 { 2870 query->startup_sent = 0; 2871 2872 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) 2873 return; 2874 2875 mod_timer(&query->timer, jiffies); 2876 } 2877 2878 void br_multicast_open(struct net_bridge *br) 2879 { 2880 if (br_opt_get(br, BROPT_MULTICAST_ENABLED)) 2881 br_multicast_join_snoopers(br); 2882 2883 __br_multicast_open(br, &br->ip4_own_query); 2884 #if IS_ENABLED(CONFIG_IPV6) 2885 __br_multicast_open(br, &br->ip6_own_query); 2886 #endif 2887 } 2888 2889 void br_multicast_stop(struct net_bridge *br) 2890 { 2891 del_timer_sync(&br->multicast_router_timer); 2892 del_timer_sync(&br->ip4_other_query.timer); 2893 del_timer_sync(&br->ip4_own_query.timer); 2894 #if IS_ENABLED(CONFIG_IPV6) 2895 del_timer_sync(&br->ip6_other_query.timer); 2896 del_timer_sync(&br->ip6_own_query.timer); 2897 #endif 2898 2899 if (br_opt_get(br, BROPT_MULTICAST_ENABLED)) 2900 br_multicast_leave_snoopers(br); 2901 } 2902 2903 void br_multicast_dev_del(struct net_bridge *br) 2904 { 2905 struct net_bridge_mdb_entry *mp; 2906 HLIST_HEAD(deleted_head); 2907 struct hlist_node *tmp; 2908 2909 spin_lock_bh(&br->multicast_lock); 2910 hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node) { 2911 del_timer(&mp->timer); 2912 rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode, 2913 br_mdb_rht_params); 2914 hlist_del_rcu(&mp->mdb_node); 2915 kfree_rcu(mp, rcu); 2916 } 2917 hlist_move_list(&br->src_gc_list, &deleted_head); 2918 spin_unlock_bh(&br->multicast_lock); 2919 2920 __grp_src_gc(&deleted_head); 2921 cancel_work_sync(&br->src_gc_work); 2922 2923 rcu_barrier(); 2924 } 2925 2926 int br_multicast_set_router(struct net_bridge *br, unsigned long val) 2927 { 2928 int err = -EINVAL; 2929 2930 spin_lock_bh(&br->multicast_lock); 2931 2932 switch (val) { 2933 case MDB_RTR_TYPE_DISABLED: 2934 case MDB_RTR_TYPE_PERM: 2935 br_mc_router_state_change(br, val == MDB_RTR_TYPE_PERM); 2936 del_timer(&br->multicast_router_timer); 2937 br->multicast_router = val; 2938 err = 0; 2939 break; 2940 case MDB_RTR_TYPE_TEMP_QUERY: 2941 if (br->multicast_router != MDB_RTR_TYPE_TEMP_QUERY) 2942 br_mc_router_state_change(br, false); 2943 br->multicast_router = val; 2944 err = 0; 2945 break; 2946 } 2947 2948 spin_unlock_bh(&br->multicast_lock); 2949 2950 return err; 2951 } 2952 2953 static void __del_port_router(struct net_bridge_port *p) 2954 { 2955 if (hlist_unhashed(&p->rlist)) 2956 return; 2957 hlist_del_init_rcu(&p->rlist); 2958 br_rtr_notify(p->br->dev, p, RTM_DELMDB); 2959 br_port_mc_router_state_change(p, false); 2960 2961 /* don't allow timer refresh */ 2962 if (p->multicast_router == MDB_RTR_TYPE_TEMP) 2963 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY; 2964 } 2965 2966 int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val) 2967 { 2968 struct net_bridge *br = p->br; 2969 unsigned long now = jiffies; 2970 int err = -EINVAL; 2971 2972 spin_lock(&br->multicast_lock); 2973 if (p->multicast_router == val) { 2974 /* Refresh the temp router port timer */ 2975 if (p->multicast_router == MDB_RTR_TYPE_TEMP) 2976 mod_timer(&p->multicast_router_timer, 2977 now + br->multicast_querier_interval); 2978 err = 0; 2979 goto unlock; 2980 } 2981 switch (val) { 2982 case MDB_RTR_TYPE_DISABLED: 2983 p->multicast_router = MDB_RTR_TYPE_DISABLED; 2984 __del_port_router(p); 2985 del_timer(&p->multicast_router_timer); 2986 break; 2987 case MDB_RTR_TYPE_TEMP_QUERY: 2988 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY; 2989 __del_port_router(p); 2990 break; 2991 case MDB_RTR_TYPE_PERM: 2992 p->multicast_router = MDB_RTR_TYPE_PERM; 2993 del_timer(&p->multicast_router_timer); 2994 br_multicast_add_router(br, p); 2995 break; 2996 case MDB_RTR_TYPE_TEMP: 2997 p->multicast_router = MDB_RTR_TYPE_TEMP; 2998 br_multicast_mark_router(br, p); 2999 break; 3000 default: 3001 goto unlock; 3002 } 3003 err = 0; 3004 unlock: 3005 spin_unlock(&br->multicast_lock); 3006 3007 return err; 3008 } 3009 3010 static void br_multicast_start_querier(struct net_bridge *br, 3011 struct bridge_mcast_own_query *query) 3012 { 3013 struct net_bridge_port *port; 3014 3015 __br_multicast_open(br, query); 3016 3017 rcu_read_lock(); 3018 list_for_each_entry_rcu(port, &br->port_list, list) { 3019 if (port->state == BR_STATE_DISABLED || 3020 port->state == BR_STATE_BLOCKING) 3021 continue; 3022 3023 if (query == &br->ip4_own_query) 3024 br_multicast_enable(&port->ip4_own_query); 3025 #if IS_ENABLED(CONFIG_IPV6) 3026 else 3027 br_multicast_enable(&port->ip6_own_query); 3028 #endif 3029 } 3030 rcu_read_unlock(); 3031 } 3032 3033 int br_multicast_toggle(struct net_bridge *br, unsigned long val) 3034 { 3035 struct net_bridge_port *port; 3036 3037 spin_lock_bh(&br->multicast_lock); 3038 if (!!br_opt_get(br, BROPT_MULTICAST_ENABLED) == !!val) 3039 goto unlock; 3040 3041 br_mc_disabled_update(br->dev, val); 3042 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, !!val); 3043 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) { 3044 br_multicast_leave_snoopers(br); 3045 goto unlock; 3046 } 3047 3048 if (!netif_running(br->dev)) 3049 goto unlock; 3050 3051 br_multicast_open(br); 3052 list_for_each_entry(port, &br->port_list, list) 3053 __br_multicast_enable_port(port); 3054 3055 unlock: 3056 spin_unlock_bh(&br->multicast_lock); 3057 3058 return 0; 3059 } 3060 3061 bool br_multicast_enabled(const struct net_device *dev) 3062 { 3063 struct net_bridge *br = netdev_priv(dev); 3064 3065 return !!br_opt_get(br, BROPT_MULTICAST_ENABLED); 3066 } 3067 EXPORT_SYMBOL_GPL(br_multicast_enabled); 3068 3069 bool br_multicast_router(const struct net_device *dev) 3070 { 3071 struct net_bridge *br = netdev_priv(dev); 3072 bool is_router; 3073 3074 spin_lock_bh(&br->multicast_lock); 3075 is_router = br_multicast_is_router(br); 3076 spin_unlock_bh(&br->multicast_lock); 3077 return is_router; 3078 } 3079 EXPORT_SYMBOL_GPL(br_multicast_router); 3080 3081 int br_multicast_set_querier(struct net_bridge *br, unsigned long val) 3082 { 3083 unsigned long max_delay; 3084 3085 val = !!val; 3086 3087 spin_lock_bh(&br->multicast_lock); 3088 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) == val) 3089 goto unlock; 3090 3091 br_opt_toggle(br, BROPT_MULTICAST_QUERIER, !!val); 3092 if (!val) 3093 goto unlock; 3094 3095 max_delay = br->multicast_query_response_interval; 3096 3097 if (!timer_pending(&br->ip4_other_query.timer)) 3098 br->ip4_other_query.delay_time = jiffies + max_delay; 3099 3100 br_multicast_start_querier(br, &br->ip4_own_query); 3101 3102 #if IS_ENABLED(CONFIG_IPV6) 3103 if (!timer_pending(&br->ip6_other_query.timer)) 3104 br->ip6_other_query.delay_time = jiffies + max_delay; 3105 3106 br_multicast_start_querier(br, &br->ip6_own_query); 3107 #endif 3108 3109 unlock: 3110 spin_unlock_bh(&br->multicast_lock); 3111 3112 return 0; 3113 } 3114 3115 int br_multicast_set_igmp_version(struct net_bridge *br, unsigned long val) 3116 { 3117 /* Currently we support only version 2 and 3 */ 3118 switch (val) { 3119 case 2: 3120 case 3: 3121 break; 3122 default: 3123 return -EINVAL; 3124 } 3125 3126 spin_lock_bh(&br->multicast_lock); 3127 br->multicast_igmp_version = val; 3128 spin_unlock_bh(&br->multicast_lock); 3129 3130 return 0; 3131 } 3132 3133 #if IS_ENABLED(CONFIG_IPV6) 3134 int br_multicast_set_mld_version(struct net_bridge *br, unsigned long val) 3135 { 3136 /* Currently we support version 1 and 2 */ 3137 switch (val) { 3138 case 1: 3139 case 2: 3140 break; 3141 default: 3142 return -EINVAL; 3143 } 3144 3145 spin_lock_bh(&br->multicast_lock); 3146 br->multicast_mld_version = val; 3147 spin_unlock_bh(&br->multicast_lock); 3148 3149 return 0; 3150 } 3151 #endif 3152 3153 /** 3154 * br_multicast_list_adjacent - Returns snooped multicast addresses 3155 * @dev: The bridge port adjacent to which to retrieve addresses 3156 * @br_ip_list: The list to store found, snooped multicast IP addresses in 3157 * 3158 * Creates a list of IP addresses (struct br_ip_list) sensed by the multicast 3159 * snooping feature on all bridge ports of dev's bridge device, excluding 3160 * the addresses from dev itself. 3161 * 3162 * Returns the number of items added to br_ip_list. 3163 * 3164 * Notes: 3165 * - br_ip_list needs to be initialized by caller 3166 * - br_ip_list might contain duplicates in the end 3167 * (needs to be taken care of by caller) 3168 * - br_ip_list needs to be freed by caller 3169 */ 3170 int br_multicast_list_adjacent(struct net_device *dev, 3171 struct list_head *br_ip_list) 3172 { 3173 struct net_bridge *br; 3174 struct net_bridge_port *port; 3175 struct net_bridge_port_group *group; 3176 struct br_ip_list *entry; 3177 int count = 0; 3178 3179 rcu_read_lock(); 3180 if (!br_ip_list || !netif_is_bridge_port(dev)) 3181 goto unlock; 3182 3183 port = br_port_get_rcu(dev); 3184 if (!port || !port->br) 3185 goto unlock; 3186 3187 br = port->br; 3188 3189 list_for_each_entry_rcu(port, &br->port_list, list) { 3190 if (!port->dev || port->dev == dev) 3191 continue; 3192 3193 hlist_for_each_entry_rcu(group, &port->mglist, mglist) { 3194 entry = kmalloc(sizeof(*entry), GFP_ATOMIC); 3195 if (!entry) 3196 goto unlock; 3197 3198 entry->addr = group->addr; 3199 list_add(&entry->list, br_ip_list); 3200 count++; 3201 } 3202 } 3203 3204 unlock: 3205 rcu_read_unlock(); 3206 return count; 3207 } 3208 EXPORT_SYMBOL_GPL(br_multicast_list_adjacent); 3209 3210 /** 3211 * br_multicast_has_querier_anywhere - Checks for a querier on a bridge 3212 * @dev: The bridge port providing the bridge on which to check for a querier 3213 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6 3214 * 3215 * Checks whether the given interface has a bridge on top and if so returns 3216 * true if a valid querier exists anywhere on the bridged link layer. 3217 * Otherwise returns false. 3218 */ 3219 bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto) 3220 { 3221 struct net_bridge *br; 3222 struct net_bridge_port *port; 3223 struct ethhdr eth; 3224 bool ret = false; 3225 3226 rcu_read_lock(); 3227 if (!netif_is_bridge_port(dev)) 3228 goto unlock; 3229 3230 port = br_port_get_rcu(dev); 3231 if (!port || !port->br) 3232 goto unlock; 3233 3234 br = port->br; 3235 3236 memset(ð, 0, sizeof(eth)); 3237 eth.h_proto = htons(proto); 3238 3239 ret = br_multicast_querier_exists(br, ð); 3240 3241 unlock: 3242 rcu_read_unlock(); 3243 return ret; 3244 } 3245 EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere); 3246 3247 /** 3248 * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port 3249 * @dev: The bridge port adjacent to which to check for a querier 3250 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6 3251 * 3252 * Checks whether the given interface has a bridge on top and if so returns 3253 * true if a selected querier is behind one of the other ports of this 3254 * bridge. Otherwise returns false. 3255 */ 3256 bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto) 3257 { 3258 struct net_bridge *br; 3259 struct net_bridge_port *port; 3260 bool ret = false; 3261 3262 rcu_read_lock(); 3263 if (!netif_is_bridge_port(dev)) 3264 goto unlock; 3265 3266 port = br_port_get_rcu(dev); 3267 if (!port || !port->br) 3268 goto unlock; 3269 3270 br = port->br; 3271 3272 switch (proto) { 3273 case ETH_P_IP: 3274 if (!timer_pending(&br->ip4_other_query.timer) || 3275 rcu_dereference(br->ip4_querier.port) == port) 3276 goto unlock; 3277 break; 3278 #if IS_ENABLED(CONFIG_IPV6) 3279 case ETH_P_IPV6: 3280 if (!timer_pending(&br->ip6_other_query.timer) || 3281 rcu_dereference(br->ip6_querier.port) == port) 3282 goto unlock; 3283 break; 3284 #endif 3285 default: 3286 goto unlock; 3287 } 3288 3289 ret = true; 3290 unlock: 3291 rcu_read_unlock(); 3292 return ret; 3293 } 3294 EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent); 3295 3296 static void br_mcast_stats_add(struct bridge_mcast_stats __percpu *stats, 3297 const struct sk_buff *skb, u8 type, u8 dir) 3298 { 3299 struct bridge_mcast_stats *pstats = this_cpu_ptr(stats); 3300 __be16 proto = skb->protocol; 3301 unsigned int t_len; 3302 3303 u64_stats_update_begin(&pstats->syncp); 3304 switch (proto) { 3305 case htons(ETH_P_IP): 3306 t_len = ntohs(ip_hdr(skb)->tot_len) - ip_hdrlen(skb); 3307 switch (type) { 3308 case IGMP_HOST_MEMBERSHIP_REPORT: 3309 pstats->mstats.igmp_v1reports[dir]++; 3310 break; 3311 case IGMPV2_HOST_MEMBERSHIP_REPORT: 3312 pstats->mstats.igmp_v2reports[dir]++; 3313 break; 3314 case IGMPV3_HOST_MEMBERSHIP_REPORT: 3315 pstats->mstats.igmp_v3reports[dir]++; 3316 break; 3317 case IGMP_HOST_MEMBERSHIP_QUERY: 3318 if (t_len != sizeof(struct igmphdr)) { 3319 pstats->mstats.igmp_v3queries[dir]++; 3320 } else { 3321 unsigned int offset = skb_transport_offset(skb); 3322 struct igmphdr *ih, _ihdr; 3323 3324 ih = skb_header_pointer(skb, offset, 3325 sizeof(_ihdr), &_ihdr); 3326 if (!ih) 3327 break; 3328 if (!ih->code) 3329 pstats->mstats.igmp_v1queries[dir]++; 3330 else 3331 pstats->mstats.igmp_v2queries[dir]++; 3332 } 3333 break; 3334 case IGMP_HOST_LEAVE_MESSAGE: 3335 pstats->mstats.igmp_leaves[dir]++; 3336 break; 3337 } 3338 break; 3339 #if IS_ENABLED(CONFIG_IPV6) 3340 case htons(ETH_P_IPV6): 3341 t_len = ntohs(ipv6_hdr(skb)->payload_len) + 3342 sizeof(struct ipv6hdr); 3343 t_len -= skb_network_header_len(skb); 3344 switch (type) { 3345 case ICMPV6_MGM_REPORT: 3346 pstats->mstats.mld_v1reports[dir]++; 3347 break; 3348 case ICMPV6_MLD2_REPORT: 3349 pstats->mstats.mld_v2reports[dir]++; 3350 break; 3351 case ICMPV6_MGM_QUERY: 3352 if (t_len != sizeof(struct mld_msg)) 3353 pstats->mstats.mld_v2queries[dir]++; 3354 else 3355 pstats->mstats.mld_v1queries[dir]++; 3356 break; 3357 case ICMPV6_MGM_REDUCTION: 3358 pstats->mstats.mld_leaves[dir]++; 3359 break; 3360 } 3361 break; 3362 #endif /* CONFIG_IPV6 */ 3363 } 3364 u64_stats_update_end(&pstats->syncp); 3365 } 3366 3367 void br_multicast_count(struct net_bridge *br, const struct net_bridge_port *p, 3368 const struct sk_buff *skb, u8 type, u8 dir) 3369 { 3370 struct bridge_mcast_stats __percpu *stats; 3371 3372 /* if multicast_disabled is true then igmp type can't be set */ 3373 if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED)) 3374 return; 3375 3376 if (p) 3377 stats = p->mcast_stats; 3378 else 3379 stats = br->mcast_stats; 3380 if (WARN_ON(!stats)) 3381 return; 3382 3383 br_mcast_stats_add(stats, skb, type, dir); 3384 } 3385 3386 int br_multicast_init_stats(struct net_bridge *br) 3387 { 3388 br->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats); 3389 if (!br->mcast_stats) 3390 return -ENOMEM; 3391 3392 return 0; 3393 } 3394 3395 void br_multicast_uninit_stats(struct net_bridge *br) 3396 { 3397 free_percpu(br->mcast_stats); 3398 } 3399 3400 /* noinline for https://bugs.llvm.org/show_bug.cgi?id=45802#c9 */ 3401 static noinline_for_stack void mcast_stats_add_dir(u64 *dst, u64 *src) 3402 { 3403 dst[BR_MCAST_DIR_RX] += src[BR_MCAST_DIR_RX]; 3404 dst[BR_MCAST_DIR_TX] += src[BR_MCAST_DIR_TX]; 3405 } 3406 3407 void br_multicast_get_stats(const struct net_bridge *br, 3408 const struct net_bridge_port *p, 3409 struct br_mcast_stats *dest) 3410 { 3411 struct bridge_mcast_stats __percpu *stats; 3412 struct br_mcast_stats tdst; 3413 int i; 3414 3415 memset(dest, 0, sizeof(*dest)); 3416 if (p) 3417 stats = p->mcast_stats; 3418 else 3419 stats = br->mcast_stats; 3420 if (WARN_ON(!stats)) 3421 return; 3422 3423 memset(&tdst, 0, sizeof(tdst)); 3424 for_each_possible_cpu(i) { 3425 struct bridge_mcast_stats *cpu_stats = per_cpu_ptr(stats, i); 3426 struct br_mcast_stats temp; 3427 unsigned int start; 3428 3429 do { 3430 start = u64_stats_fetch_begin_irq(&cpu_stats->syncp); 3431 memcpy(&temp, &cpu_stats->mstats, sizeof(temp)); 3432 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start)); 3433 3434 mcast_stats_add_dir(tdst.igmp_v1queries, temp.igmp_v1queries); 3435 mcast_stats_add_dir(tdst.igmp_v2queries, temp.igmp_v2queries); 3436 mcast_stats_add_dir(tdst.igmp_v3queries, temp.igmp_v3queries); 3437 mcast_stats_add_dir(tdst.igmp_leaves, temp.igmp_leaves); 3438 mcast_stats_add_dir(tdst.igmp_v1reports, temp.igmp_v1reports); 3439 mcast_stats_add_dir(tdst.igmp_v2reports, temp.igmp_v2reports); 3440 mcast_stats_add_dir(tdst.igmp_v3reports, temp.igmp_v3reports); 3441 tdst.igmp_parse_errors += temp.igmp_parse_errors; 3442 3443 mcast_stats_add_dir(tdst.mld_v1queries, temp.mld_v1queries); 3444 mcast_stats_add_dir(tdst.mld_v2queries, temp.mld_v2queries); 3445 mcast_stats_add_dir(tdst.mld_leaves, temp.mld_leaves); 3446 mcast_stats_add_dir(tdst.mld_v1reports, temp.mld_v1reports); 3447 mcast_stats_add_dir(tdst.mld_v2reports, temp.mld_v2reports); 3448 tdst.mld_parse_errors += temp.mld_parse_errors; 3449 } 3450 memcpy(dest, &tdst, sizeof(*dest)); 3451 } 3452 3453 int br_mdb_hash_init(struct net_bridge *br) 3454 { 3455 return rhashtable_init(&br->mdb_hash_tbl, &br_mdb_rht_params); 3456 } 3457 3458 void br_mdb_hash_fini(struct net_bridge *br) 3459 { 3460 rhashtable_destroy(&br->mdb_hash_tbl); 3461 } 3462