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 #include <trace/events/bridge.h> 35 36 #include "br_private.h" 37 #include "br_private_mcast_eht.h" 38 39 static const struct rhashtable_params br_mdb_rht_params = { 40 .head_offset = offsetof(struct net_bridge_mdb_entry, rhnode), 41 .key_offset = offsetof(struct net_bridge_mdb_entry, addr), 42 .key_len = sizeof(struct br_ip), 43 .automatic_shrinking = true, 44 }; 45 46 static const struct rhashtable_params br_sg_port_rht_params = { 47 .head_offset = offsetof(struct net_bridge_port_group, rhnode), 48 .key_offset = offsetof(struct net_bridge_port_group, key), 49 .key_len = sizeof(struct net_bridge_port_group_sg_key), 50 .automatic_shrinking = true, 51 }; 52 53 static void br_multicast_start_querier(struct net_bridge_mcast *brmctx, 54 struct bridge_mcast_own_query *query); 55 static void br_ip4_multicast_add_router(struct net_bridge_mcast *brmctx, 56 struct net_bridge_mcast_port *pmctx); 57 static void br_ip4_multicast_leave_group(struct net_bridge_mcast *brmctx, 58 struct net_bridge_mcast_port *pmctx, 59 __be32 group, 60 __u16 vid, 61 const unsigned char *src); 62 static void br_multicast_port_group_rexmit(struct timer_list *t); 63 64 static void 65 br_multicast_rport_del_notify(struct net_bridge_mcast_port *pmctx, bool deleted); 66 static void br_ip6_multicast_add_router(struct net_bridge_mcast *brmctx, 67 struct net_bridge_mcast_port *pmctx); 68 #if IS_ENABLED(CONFIG_IPV6) 69 static void br_ip6_multicast_leave_group(struct net_bridge_mcast *brmctx, 70 struct net_bridge_mcast_port *pmctx, 71 const struct in6_addr *group, 72 __u16 vid, const unsigned char *src); 73 #endif 74 static struct net_bridge_port_group * 75 __br_multicast_add_group(struct net_bridge_mcast *brmctx, 76 struct net_bridge_mcast_port *pmctx, 77 struct br_ip *group, 78 const unsigned char *src, 79 u8 filter_mode, 80 bool igmpv2_mldv1, 81 bool blocked); 82 static void br_multicast_find_del_pg(struct net_bridge *br, 83 struct net_bridge_port_group *pg); 84 static void __br_multicast_del_pg(struct net_bridge_mdb_entry *mp, 85 struct net_bridge_port_group *pg, 86 struct net_bridge_port_group __rcu **pp, 87 bool sg_del_exclude_ports); 88 static void __br_multicast_stop(struct net_bridge_mcast *brmctx); 89 90 static int br_mc_disabled_update(struct net_device *dev, bool value, 91 struct netlink_ext_ack *extack); 92 93 static struct net_bridge_port_group * 94 br_sg_port_find(struct net_bridge *br, 95 struct net_bridge_port_group_sg_key *sg_p) 96 { 97 lockdep_assert_held_once(&br->multicast_lock); 98 99 return rhashtable_lookup_fast(&br->sg_port_tbl, sg_p, 100 br_sg_port_rht_params); 101 } 102 103 static struct net_bridge_mdb_entry *br_mdb_ip_get_rcu(struct net_bridge *br, 104 struct br_ip *dst) 105 { 106 return rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params); 107 } 108 109 struct net_bridge_mdb_entry *br_mdb_ip_get(struct net_bridge *br, 110 struct br_ip *dst) 111 { 112 struct net_bridge_mdb_entry *ent; 113 114 lockdep_assert_held_once(&br->multicast_lock); 115 116 rcu_read_lock(); 117 ent = rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params); 118 rcu_read_unlock(); 119 120 return ent; 121 } 122 123 static struct net_bridge_mdb_entry *br_mdb_ip4_get(struct net_bridge *br, 124 __be32 dst, __u16 vid) 125 { 126 struct br_ip br_dst; 127 128 memset(&br_dst, 0, sizeof(br_dst)); 129 br_dst.dst.ip4 = dst; 130 br_dst.proto = htons(ETH_P_IP); 131 br_dst.vid = vid; 132 133 return br_mdb_ip_get(br, &br_dst); 134 } 135 136 #if IS_ENABLED(CONFIG_IPV6) 137 static struct net_bridge_mdb_entry *br_mdb_ip6_get(struct net_bridge *br, 138 const struct in6_addr *dst, 139 __u16 vid) 140 { 141 struct br_ip br_dst; 142 143 memset(&br_dst, 0, sizeof(br_dst)); 144 br_dst.dst.ip6 = *dst; 145 br_dst.proto = htons(ETH_P_IPV6); 146 br_dst.vid = vid; 147 148 return br_mdb_ip_get(br, &br_dst); 149 } 150 #endif 151 152 struct net_bridge_mdb_entry * 153 br_mdb_entry_skb_get(struct net_bridge_mcast *brmctx, struct sk_buff *skb, 154 u16 vid) 155 { 156 struct net_bridge *br = brmctx->br; 157 struct br_ip ip; 158 159 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || 160 br_multicast_ctx_vlan_global_disabled(brmctx)) 161 return NULL; 162 163 if (BR_INPUT_SKB_CB(skb)->igmp) 164 return NULL; 165 166 memset(&ip, 0, sizeof(ip)); 167 ip.proto = skb->protocol; 168 ip.vid = vid; 169 170 switch (skb->protocol) { 171 case htons(ETH_P_IP): 172 ip.dst.ip4 = ip_hdr(skb)->daddr; 173 if (brmctx->multicast_igmp_version == 3) { 174 struct net_bridge_mdb_entry *mdb; 175 176 ip.src.ip4 = ip_hdr(skb)->saddr; 177 mdb = br_mdb_ip_get_rcu(br, &ip); 178 if (mdb) 179 return mdb; 180 ip.src.ip4 = 0; 181 } 182 break; 183 #if IS_ENABLED(CONFIG_IPV6) 184 case htons(ETH_P_IPV6): 185 ip.dst.ip6 = ipv6_hdr(skb)->daddr; 186 if (brmctx->multicast_mld_version == 2) { 187 struct net_bridge_mdb_entry *mdb; 188 189 ip.src.ip6 = ipv6_hdr(skb)->saddr; 190 mdb = br_mdb_ip_get_rcu(br, &ip); 191 if (mdb) 192 return mdb; 193 memset(&ip.src.ip6, 0, sizeof(ip.src.ip6)); 194 } 195 break; 196 #endif 197 default: 198 ip.proto = 0; 199 ether_addr_copy(ip.dst.mac_addr, eth_hdr(skb)->h_dest); 200 } 201 202 return br_mdb_ip_get_rcu(br, &ip); 203 } 204 205 /* IMPORTANT: this function must be used only when the contexts cannot be 206 * passed down (e.g. timer) and must be used for read-only purposes because 207 * the vlan snooping option can change, so it can return any context 208 * (non-vlan or vlan). Its initial intended purpose is to read timer values 209 * from the *current* context based on the option. At worst that could lead 210 * to inconsistent timers when the contexts are changed, i.e. src timer 211 * which needs to re-arm with a specific delay taken from the old context 212 */ 213 static struct net_bridge_mcast_port * 214 br_multicast_pg_to_port_ctx(const struct net_bridge_port_group *pg) 215 { 216 struct net_bridge_mcast_port *pmctx = &pg->key.port->multicast_ctx; 217 struct net_bridge_vlan *vlan; 218 219 lockdep_assert_held_once(&pg->key.port->br->multicast_lock); 220 221 /* if vlan snooping is disabled use the port's multicast context */ 222 if (!pg->key.addr.vid || 223 !br_opt_get(pg->key.port->br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) 224 goto out; 225 226 /* locking is tricky here, due to different rules for multicast and 227 * vlans we need to take rcu to find the vlan and make sure it has 228 * the BR_VLFLAG_MCAST_ENABLED flag set, it can only change under 229 * multicast_lock which must be already held here, so the vlan's pmctx 230 * can safely be used on return 231 */ 232 rcu_read_lock(); 233 vlan = br_vlan_find(nbp_vlan_group_rcu(pg->key.port), pg->key.addr.vid); 234 if (vlan && !br_multicast_port_ctx_vlan_disabled(&vlan->port_mcast_ctx)) 235 pmctx = &vlan->port_mcast_ctx; 236 else 237 pmctx = NULL; 238 rcu_read_unlock(); 239 out: 240 return pmctx; 241 } 242 243 static struct net_bridge_mcast_port * 244 br_multicast_port_vid_to_port_ctx(struct net_bridge_port *port, u16 vid) 245 { 246 struct net_bridge_mcast_port *pmctx = NULL; 247 struct net_bridge_vlan *vlan; 248 249 lockdep_assert_held_once(&port->br->multicast_lock); 250 251 /* Take RCU to access the vlan. */ 252 rcu_read_lock(); 253 254 vlan = br_vlan_find(nbp_vlan_group_rcu(port), vid); 255 if (vlan) 256 pmctx = &vlan->port_mcast_ctx; 257 258 rcu_read_unlock(); 259 260 return pmctx; 261 } 262 263 /* when snooping we need to check if the contexts should be used 264 * in the following order: 265 * - if pmctx is non-NULL (port), check if it should be used 266 * - if pmctx is NULL (bridge), check if brmctx should be used 267 */ 268 static bool 269 br_multicast_ctx_should_use(const struct net_bridge_mcast *brmctx, 270 const struct net_bridge_mcast_port *pmctx) 271 { 272 if (!netif_running(brmctx->br->dev)) 273 return false; 274 275 if (pmctx) 276 return !br_multicast_port_ctx_state_disabled(pmctx); 277 else 278 return !br_multicast_ctx_vlan_disabled(brmctx); 279 } 280 281 static bool br_port_group_equal(struct net_bridge_port_group *p, 282 struct net_bridge_port *port, 283 const unsigned char *src) 284 { 285 if (p->key.port != port) 286 return false; 287 288 if (!test_bit(BR_MULTICAST_TO_UNICAST_BIT, &port->flags)) 289 return true; 290 291 return ether_addr_equal(src, p->eth_addr); 292 } 293 294 static void __fwd_add_star_excl(struct net_bridge_mcast_port *pmctx, 295 struct net_bridge_port_group *pg, 296 struct br_ip *sg_ip) 297 { 298 struct net_bridge_port_group_sg_key sg_key; 299 struct net_bridge_port_group *src_pg; 300 struct net_bridge_mcast *brmctx; 301 302 memset(&sg_key, 0, sizeof(sg_key)); 303 brmctx = br_multicast_port_ctx_get_global(pmctx); 304 sg_key.port = pg->key.port; 305 sg_key.addr = *sg_ip; 306 if (br_sg_port_find(brmctx->br, &sg_key)) 307 return; 308 309 src_pg = __br_multicast_add_group(brmctx, pmctx, 310 sg_ip, pg->eth_addr, 311 MCAST_INCLUDE, false, false); 312 if (IS_ERR_OR_NULL(src_pg) || 313 src_pg->rt_protocol != RTPROT_KERNEL) 314 return; 315 316 src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL; 317 } 318 319 static void __fwd_del_star_excl(struct net_bridge_port_group *pg, 320 struct br_ip *sg_ip) 321 { 322 struct net_bridge_port_group_sg_key sg_key; 323 struct net_bridge *br = pg->key.port->br; 324 struct net_bridge_port_group *src_pg; 325 326 memset(&sg_key, 0, sizeof(sg_key)); 327 sg_key.port = pg->key.port; 328 sg_key.addr = *sg_ip; 329 src_pg = br_sg_port_find(br, &sg_key); 330 if (!src_pg || !(src_pg->flags & MDB_PG_FLAGS_STAR_EXCL) || 331 src_pg->rt_protocol != RTPROT_KERNEL) 332 return; 333 334 br_multicast_find_del_pg(br, src_pg); 335 } 336 337 /* When a port group transitions to (or is added as) EXCLUDE we need to add it 338 * to all other ports' S,G entries which are not blocked by the current group 339 * for proper replication, the assumption is that any S,G blocked entries 340 * are already added so the S,G,port lookup should skip them. 341 * When a port group transitions from EXCLUDE -> INCLUDE mode or is being 342 * deleted we need to remove it from all ports' S,G entries where it was 343 * automatically installed before (i.e. where it's MDB_PG_FLAGS_STAR_EXCL). 344 */ 345 void br_multicast_star_g_handle_mode(struct net_bridge_port_group *pg, 346 u8 filter_mode) 347 { 348 struct net_bridge *br = pg->key.port->br; 349 struct net_bridge_port_group *pg_lst; 350 struct net_bridge_mcast_port *pmctx; 351 struct net_bridge_mdb_entry *mp; 352 struct br_ip sg_ip; 353 354 if (WARN_ON(!br_multicast_is_star_g(&pg->key.addr))) 355 return; 356 357 mp = br_mdb_ip_get(br, &pg->key.addr); 358 if (!mp) 359 return; 360 pmctx = br_multicast_pg_to_port_ctx(pg); 361 if (!pmctx) 362 return; 363 364 memset(&sg_ip, 0, sizeof(sg_ip)); 365 sg_ip = pg->key.addr; 366 367 for (pg_lst = mlock_dereference(mp->ports, br); 368 pg_lst; 369 pg_lst = mlock_dereference(pg_lst->next, br)) { 370 struct net_bridge_group_src *src_ent; 371 372 if (pg_lst == pg) 373 continue; 374 hlist_for_each_entry(src_ent, &pg_lst->src_list, node) { 375 if (!(src_ent->flags & BR_SGRP_F_INSTALLED)) 376 continue; 377 sg_ip.src = src_ent->addr.src; 378 switch (filter_mode) { 379 case MCAST_INCLUDE: 380 __fwd_del_star_excl(pg, &sg_ip); 381 break; 382 case MCAST_EXCLUDE: 383 __fwd_add_star_excl(pmctx, pg, &sg_ip); 384 break; 385 } 386 } 387 } 388 } 389 390 /* called when adding a new S,G with host_joined == false by default */ 391 static void br_multicast_sg_host_state(struct net_bridge_mdb_entry *star_mp, 392 struct net_bridge_port_group *sg) 393 { 394 struct net_bridge_mdb_entry *sg_mp; 395 396 if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr))) 397 return; 398 if (!star_mp->host_joined) 399 return; 400 401 sg_mp = br_mdb_ip_get(star_mp->br, &sg->key.addr); 402 if (!sg_mp) 403 return; 404 sg_mp->host_joined = true; 405 } 406 407 /* set the host_joined state of all of *,G's S,G entries */ 408 static void br_multicast_star_g_host_state(struct net_bridge_mdb_entry *star_mp) 409 { 410 struct net_bridge *br = star_mp->br; 411 struct net_bridge_mdb_entry *sg_mp; 412 struct net_bridge_port_group *pg; 413 struct br_ip sg_ip; 414 415 if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr))) 416 return; 417 418 memset(&sg_ip, 0, sizeof(sg_ip)); 419 sg_ip = star_mp->addr; 420 for (pg = mlock_dereference(star_mp->ports, br); 421 pg; 422 pg = mlock_dereference(pg->next, br)) { 423 struct net_bridge_group_src *src_ent; 424 425 hlist_for_each_entry(src_ent, &pg->src_list, node) { 426 if (!(src_ent->flags & BR_SGRP_F_INSTALLED)) 427 continue; 428 sg_ip.src = src_ent->addr.src; 429 sg_mp = br_mdb_ip_get(br, &sg_ip); 430 if (!sg_mp) 431 continue; 432 sg_mp->host_joined = star_mp->host_joined; 433 } 434 } 435 } 436 437 static void br_multicast_sg_del_exclude_ports(struct net_bridge_mdb_entry *sgmp) 438 { 439 struct net_bridge_port_group __rcu **pp; 440 struct net_bridge_port_group *p; 441 442 /* *,G exclude ports are only added to S,G entries */ 443 if (WARN_ON(br_multicast_is_star_g(&sgmp->addr))) 444 return; 445 446 /* we need the STAR_EXCLUDE ports if there are non-STAR_EXCLUDE ports 447 * we should ignore perm entries since they're managed by user-space 448 */ 449 for (pp = &sgmp->ports; 450 (p = mlock_dereference(*pp, sgmp->br)) != NULL; 451 pp = &p->next) 452 if (!(p->flags & (MDB_PG_FLAGS_STAR_EXCL | 453 MDB_PG_FLAGS_PERMANENT))) 454 return; 455 456 /* currently the host can only have joined the *,G which means 457 * we treat it as EXCLUDE {}, so for an S,G it's considered a 458 * STAR_EXCLUDE entry and we can safely leave it 459 */ 460 sgmp->host_joined = false; 461 462 for (pp = &sgmp->ports; 463 (p = mlock_dereference(*pp, sgmp->br)) != NULL;) { 464 if (!(p->flags & MDB_PG_FLAGS_PERMANENT)) 465 __br_multicast_del_pg(sgmp, p, pp, false); 466 else 467 pp = &p->next; 468 } 469 } 470 471 void br_multicast_sg_add_exclude_ports(struct net_bridge_mdb_entry *star_mp, 472 struct net_bridge_port_group *sg) 473 { 474 struct net_bridge_port_group_sg_key sg_key; 475 struct net_bridge *br = star_mp->br; 476 struct net_bridge_mcast_port *pmctx; 477 struct net_bridge_port_group *pg; 478 struct net_bridge_mcast *brmctx; 479 480 if (WARN_ON(br_multicast_is_star_g(&sg->key.addr))) 481 return; 482 if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr))) 483 return; 484 485 br_multicast_sg_host_state(star_mp, sg); 486 memset(&sg_key, 0, sizeof(sg_key)); 487 sg_key.addr = sg->key.addr; 488 /* we need to add all exclude ports to the S,G */ 489 for (pg = mlock_dereference(star_mp->ports, br); 490 pg; 491 pg = mlock_dereference(pg->next, br)) { 492 struct net_bridge_port_group *src_pg; 493 494 if (pg == sg || pg->filter_mode == MCAST_INCLUDE) 495 continue; 496 497 sg_key.port = pg->key.port; 498 if (br_sg_port_find(br, &sg_key)) 499 continue; 500 501 pmctx = br_multicast_pg_to_port_ctx(pg); 502 if (!pmctx) 503 continue; 504 brmctx = br_multicast_port_ctx_get_global(pmctx); 505 506 src_pg = __br_multicast_add_group(brmctx, pmctx, 507 &sg->key.addr, 508 sg->eth_addr, 509 MCAST_INCLUDE, false, false); 510 if (IS_ERR_OR_NULL(src_pg) || 511 src_pg->rt_protocol != RTPROT_KERNEL) 512 continue; 513 src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL; 514 } 515 } 516 517 static void br_multicast_fwd_src_add(struct net_bridge_group_src *src) 518 { 519 struct net_bridge_mdb_entry *star_mp; 520 struct net_bridge_mcast_port *pmctx; 521 struct net_bridge_port_group *sg; 522 struct net_bridge_mcast *brmctx; 523 struct br_ip sg_ip; 524 525 if (src->flags & BR_SGRP_F_INSTALLED) 526 return; 527 528 memset(&sg_ip, 0, sizeof(sg_ip)); 529 pmctx = br_multicast_pg_to_port_ctx(src->pg); 530 if (!pmctx) 531 return; 532 brmctx = br_multicast_port_ctx_get_global(pmctx); 533 sg_ip = src->pg->key.addr; 534 sg_ip.src = src->addr.src; 535 536 sg = __br_multicast_add_group(brmctx, pmctx, &sg_ip, 537 src->pg->eth_addr, MCAST_INCLUDE, false, 538 !timer_pending(&src->timer)); 539 if (IS_ERR_OR_NULL(sg)) 540 return; 541 src->flags |= BR_SGRP_F_INSTALLED; 542 sg->flags &= ~MDB_PG_FLAGS_STAR_EXCL; 543 544 /* if it was added by user-space as perm we can skip next steps */ 545 if (sg->rt_protocol != RTPROT_KERNEL && 546 (sg->flags & MDB_PG_FLAGS_PERMANENT)) 547 return; 548 549 /* the kernel is now responsible for removing this S,G */ 550 timer_delete(&sg->timer); 551 star_mp = br_mdb_ip_get(src->br, &src->pg->key.addr); 552 if (!star_mp) 553 return; 554 555 br_multicast_sg_add_exclude_ports(star_mp, sg); 556 } 557 558 static void br_multicast_fwd_src_remove(struct net_bridge_group_src *src, 559 bool fastleave) 560 { 561 struct net_bridge_port_group *p, *pg = src->pg; 562 struct net_bridge_port_group __rcu **pp; 563 struct net_bridge_mdb_entry *mp; 564 struct br_ip sg_ip; 565 566 memset(&sg_ip, 0, sizeof(sg_ip)); 567 sg_ip = pg->key.addr; 568 sg_ip.src = src->addr.src; 569 570 mp = br_mdb_ip_get(src->br, &sg_ip); 571 if (!mp) 572 return; 573 574 for (pp = &mp->ports; 575 (p = mlock_dereference(*pp, src->br)) != NULL; 576 pp = &p->next) { 577 if (!br_port_group_equal(p, pg->key.port, pg->eth_addr)) 578 continue; 579 580 if (p->rt_protocol != RTPROT_KERNEL && 581 (p->flags & MDB_PG_FLAGS_PERMANENT) && 582 !(src->flags & BR_SGRP_F_USER_ADDED)) 583 break; 584 585 if (fastleave) 586 p->flags |= MDB_PG_FLAGS_FAST_LEAVE; 587 br_multicast_del_pg(mp, p, pp); 588 break; 589 } 590 src->flags &= ~BR_SGRP_F_INSTALLED; 591 } 592 593 /* install S,G and based on src's timer enable or disable forwarding */ 594 static void br_multicast_fwd_src_handle(struct net_bridge_group_src *src) 595 { 596 struct net_bridge_port_group_sg_key sg_key; 597 struct net_bridge_port_group *sg; 598 u8 old_flags; 599 600 br_multicast_fwd_src_add(src); 601 602 memset(&sg_key, 0, sizeof(sg_key)); 603 sg_key.addr = src->pg->key.addr; 604 sg_key.addr.src = src->addr.src; 605 sg_key.port = src->pg->key.port; 606 607 sg = br_sg_port_find(src->br, &sg_key); 608 if (!sg || (sg->flags & MDB_PG_FLAGS_PERMANENT)) 609 return; 610 611 old_flags = sg->flags; 612 if (timer_pending(&src->timer)) 613 sg->flags &= ~MDB_PG_FLAGS_BLOCKED; 614 else 615 sg->flags |= MDB_PG_FLAGS_BLOCKED; 616 617 if (old_flags != sg->flags) { 618 struct net_bridge_mdb_entry *sg_mp; 619 620 sg_mp = br_mdb_ip_get(src->br, &sg_key.addr); 621 if (!sg_mp) 622 return; 623 br_mdb_notify(src->br->dev, sg_mp, sg, RTM_NEWMDB); 624 } 625 } 626 627 static void br_multicast_destroy_mdb_entry(struct net_bridge_mcast_gc *gc) 628 { 629 struct net_bridge_mdb_entry *mp; 630 631 mp = container_of(gc, struct net_bridge_mdb_entry, mcast_gc); 632 WARN_ON(!hlist_unhashed(&mp->mdb_node)); 633 WARN_ON(mp->ports); 634 635 timer_shutdown_sync(&mp->timer); 636 kfree_rcu(mp, rcu); 637 } 638 639 static void br_multicast_del_mdb_entry(struct net_bridge_mdb_entry *mp) 640 { 641 struct net_bridge *br = mp->br; 642 643 rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode, 644 br_mdb_rht_params); 645 hlist_del_init_rcu(&mp->mdb_node); 646 hlist_add_head(&mp->mcast_gc.gc_node, &br->mcast_gc_list); 647 queue_work(system_long_wq, &br->mcast_gc_work); 648 } 649 650 static void br_multicast_group_expired(struct timer_list *t) 651 { 652 struct net_bridge_mdb_entry *mp = timer_container_of(mp, t, timer); 653 struct net_bridge *br = mp->br; 654 655 spin_lock(&br->multicast_lock); 656 if (hlist_unhashed(&mp->mdb_node) || !netif_running(br->dev) || 657 timer_pending(&mp->timer)) 658 goto out; 659 660 br_multicast_host_leave(mp, true); 661 662 if (mp->ports) 663 goto out; 664 br_multicast_del_mdb_entry(mp); 665 out: 666 spin_unlock(&br->multicast_lock); 667 } 668 669 static void br_multicast_destroy_group_src(struct net_bridge_mcast_gc *gc) 670 { 671 struct net_bridge_group_src *src; 672 673 src = container_of(gc, struct net_bridge_group_src, mcast_gc); 674 WARN_ON(!hlist_unhashed(&src->node)); 675 676 timer_shutdown_sync(&src->timer); 677 kfree_rcu(src, rcu); 678 } 679 680 void __br_multicast_del_group_src(struct net_bridge_group_src *src) 681 { 682 struct net_bridge *br = src->pg->key.port->br; 683 684 hlist_del_init_rcu(&src->node); 685 src->pg->src_ents--; 686 hlist_add_head(&src->mcast_gc.gc_node, &br->mcast_gc_list); 687 queue_work(system_long_wq, &br->mcast_gc_work); 688 } 689 690 void br_multicast_del_group_src(struct net_bridge_group_src *src, 691 bool fastleave) 692 { 693 br_multicast_fwd_src_remove(src, fastleave); 694 __br_multicast_del_group_src(src); 695 } 696 697 static int 698 br_multicast_port_ngroups_inc_one(struct net_bridge_mcast_port *pmctx, 699 struct netlink_ext_ack *extack, 700 const char *what) 701 { 702 u32 max = READ_ONCE(pmctx->mdb_max_entries); 703 u32 n = READ_ONCE(pmctx->mdb_n_entries); 704 705 /* enforce the max limit when it's a port pmctx or a port-vlan pmctx 706 * with snooping enabled 707 */ 708 if (!br_multicast_port_ctx_vlan_disabled(pmctx) && max && n >= max) { 709 NL_SET_ERR_MSG_FMT_MOD(extack, "%s is already in %u groups, and mcast_max_groups=%u", 710 what, n, max); 711 return -E2BIG; 712 } 713 714 WRITE_ONCE(pmctx->mdb_n_entries, n + 1); 715 return 0; 716 } 717 718 static void br_multicast_port_ngroups_dec_one(struct net_bridge_mcast_port *pmctx) 719 { 720 u32 n = READ_ONCE(pmctx->mdb_n_entries); 721 722 WARN_ON_ONCE(n == 0); 723 WRITE_ONCE(pmctx->mdb_n_entries, n - 1); 724 } 725 726 static int br_multicast_port_ngroups_inc(struct net_bridge_port *port, 727 const struct br_ip *group, 728 struct netlink_ext_ack *extack) 729 { 730 struct net_bridge_mcast_port *pmctx; 731 int err; 732 733 lockdep_assert_held_once(&port->br->multicast_lock); 734 735 /* Always count on the port context. */ 736 err = br_multicast_port_ngroups_inc_one(&port->multicast_ctx, extack, 737 "Port"); 738 if (err) { 739 trace_br_mdb_full(port->dev, group); 740 return err; 741 } 742 743 /* Only count on the VLAN context if VID is given */ 744 if (!group->vid) 745 return 0; 746 747 pmctx = br_multicast_port_vid_to_port_ctx(port, group->vid); 748 if (!pmctx) 749 return 0; 750 751 err = br_multicast_port_ngroups_inc_one(pmctx, extack, "Port-VLAN"); 752 if (err) { 753 trace_br_mdb_full(port->dev, group); 754 goto dec_one_out; 755 } 756 757 return 0; 758 759 dec_one_out: 760 br_multicast_port_ngroups_dec_one(&port->multicast_ctx); 761 return err; 762 } 763 764 static void br_multicast_port_ngroups_dec(struct net_bridge_port *port, u16 vid) 765 { 766 struct net_bridge_mcast_port *pmctx; 767 768 lockdep_assert_held_once(&port->br->multicast_lock); 769 770 if (vid) { 771 pmctx = br_multicast_port_vid_to_port_ctx(port, vid); 772 if (pmctx) 773 br_multicast_port_ngroups_dec_one(pmctx); 774 } 775 br_multicast_port_ngroups_dec_one(&port->multicast_ctx); 776 } 777 778 u32 br_multicast_ngroups_get(const struct net_bridge_mcast_port *pmctx) 779 { 780 return READ_ONCE(pmctx->mdb_n_entries); 781 } 782 783 void br_multicast_ngroups_set_max(struct net_bridge_mcast_port *pmctx, u32 max) 784 { 785 WRITE_ONCE(pmctx->mdb_max_entries, max); 786 } 787 788 u32 br_multicast_ngroups_get_max(const struct net_bridge_mcast_port *pmctx) 789 { 790 return READ_ONCE(pmctx->mdb_max_entries); 791 } 792 793 static void br_multicast_destroy_port_group(struct net_bridge_mcast_gc *gc) 794 { 795 struct net_bridge_port_group *pg; 796 797 pg = container_of(gc, struct net_bridge_port_group, mcast_gc); 798 WARN_ON(!hlist_unhashed(&pg->mglist)); 799 WARN_ON(!hlist_empty(&pg->src_list)); 800 801 timer_shutdown_sync(&pg->rexmit_timer); 802 timer_shutdown_sync(&pg->timer); 803 kfree_rcu(pg, rcu); 804 } 805 806 static void __br_multicast_del_pg(struct net_bridge_mdb_entry *mp, 807 struct net_bridge_port_group *pg, 808 struct net_bridge_port_group __rcu **pp, 809 bool sg_del_exclude_ports) 810 { 811 struct net_bridge *br = pg->key.port->br; 812 struct net_bridge_group_src *ent; 813 struct hlist_node *tmp; 814 815 rcu_assign_pointer(*pp, pg->next); 816 /* Keep ->next (held under multicast_lock, freed later by the GC work): 817 * a port->mglist teardown walk may have latched this node as its next, 818 * and deleting other groups of the same port must not truncate it. 819 */ 820 hlist_del_init_rcu(&pg->mglist); 821 br_multicast_eht_clean_sets(pg); 822 hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node) 823 br_multicast_del_group_src(ent, false); 824 br_mdb_notify(br->dev, mp, pg, RTM_DELMDB); 825 if (!br_multicast_is_star_g(&mp->addr)) { 826 rhashtable_remove_fast(&br->sg_port_tbl, &pg->rhnode, 827 br_sg_port_rht_params); 828 if (sg_del_exclude_ports) 829 br_multicast_sg_del_exclude_ports(mp); 830 } else { 831 br_multicast_star_g_handle_mode(pg, MCAST_INCLUDE); 832 } 833 br_multicast_port_ngroups_dec(pg->key.port, pg->key.addr.vid); 834 hlist_add_head(&pg->mcast_gc.gc_node, &br->mcast_gc_list); 835 queue_work(system_long_wq, &br->mcast_gc_work); 836 837 if (!mp->ports && !mp->host_joined && netif_running(br->dev)) 838 mod_timer(&mp->timer, jiffies); 839 } 840 841 void br_multicast_del_pg(struct net_bridge_mdb_entry *mp, 842 struct net_bridge_port_group *pg, 843 struct net_bridge_port_group __rcu **pp) 844 { 845 __br_multicast_del_pg(mp, pg, pp, true); 846 } 847 848 static void br_multicast_find_del_pg(struct net_bridge *br, 849 struct net_bridge_port_group *pg) 850 { 851 struct net_bridge_port_group __rcu **pp; 852 struct net_bridge_mdb_entry *mp; 853 struct net_bridge_port_group *p; 854 855 /* A teardown walk over port->mglist can reach a group that an earlier 856 * iteration already deleted as a side effect. It is off mp->ports by 857 * now, so skip it instead of falling through to the WARN_ON() below. 858 */ 859 if (hlist_unhashed(&pg->mglist)) 860 return; 861 862 mp = br_mdb_ip_get(br, &pg->key.addr); 863 if (WARN_ON(!mp)) 864 return; 865 866 for (pp = &mp->ports; 867 (p = mlock_dereference(*pp, br)) != NULL; 868 pp = &p->next) { 869 if (p != pg) 870 continue; 871 872 br_multicast_del_pg(mp, pg, pp); 873 return; 874 } 875 876 WARN_ON(1); 877 } 878 879 static void br_multicast_port_group_expired(struct timer_list *t) 880 { 881 struct net_bridge_port_group *pg = timer_container_of(pg, t, timer); 882 struct net_bridge_group_src *src_ent; 883 struct net_bridge *br = pg->key.port->br; 884 struct hlist_node *tmp; 885 bool changed; 886 887 spin_lock(&br->multicast_lock); 888 if (!netif_running(br->dev) || timer_pending(&pg->timer) || 889 hlist_unhashed(&pg->mglist) || pg->flags & MDB_PG_FLAGS_PERMANENT) 890 goto out; 891 892 changed = !!(pg->filter_mode == MCAST_EXCLUDE); 893 pg->filter_mode = MCAST_INCLUDE; 894 hlist_for_each_entry_safe(src_ent, tmp, &pg->src_list, node) { 895 if (!timer_pending(&src_ent->timer)) { 896 br_multicast_del_group_src(src_ent, false); 897 changed = true; 898 } 899 } 900 901 if (hlist_empty(&pg->src_list)) { 902 br_multicast_find_del_pg(br, pg); 903 } else if (changed) { 904 struct net_bridge_mdb_entry *mp = br_mdb_ip_get(br, &pg->key.addr); 905 906 if (changed && br_multicast_is_star_g(&pg->key.addr)) 907 br_multicast_star_g_handle_mode(pg, MCAST_INCLUDE); 908 909 if (WARN_ON(!mp)) 910 goto out; 911 br_mdb_notify(br->dev, mp, pg, RTM_NEWMDB); 912 } 913 out: 914 spin_unlock(&br->multicast_lock); 915 } 916 917 static void br_multicast_gc(struct hlist_head *head) 918 { 919 struct net_bridge_mcast_gc *gcent; 920 struct hlist_node *tmp; 921 922 hlist_for_each_entry_safe(gcent, tmp, head, gc_node) { 923 hlist_del_init(&gcent->gc_node); 924 gcent->destroy(gcent); 925 } 926 } 927 928 static void __br_multicast_query_handle_vlan(struct net_bridge_mcast *brmctx, 929 struct net_bridge_mcast_port *pmctx, 930 struct sk_buff *skb) 931 { 932 struct net_bridge_vlan *vlan = NULL; 933 934 if (pmctx && br_multicast_port_ctx_is_vlan(pmctx)) 935 vlan = pmctx->vlan; 936 else if (br_multicast_ctx_is_vlan(brmctx)) 937 vlan = brmctx->vlan; 938 939 if (vlan && !(vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED)) { 940 u16 vlan_proto; 941 942 if (br_vlan_get_proto(brmctx->br->dev, &vlan_proto) != 0) 943 return; 944 __vlan_hwaccel_put_tag(skb, htons(vlan_proto), vlan->vid); 945 } 946 } 947 948 static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge_mcast *brmctx, 949 struct net_bridge_mcast_port *pmctx, 950 struct net_bridge_port_group *pg, 951 __be32 ip_dst, __be32 group, 952 bool with_srcs, bool over_lmqt, 953 u8 sflag, 954 bool *need_rexmit) 955 { 956 struct net_bridge_port *p = pg ? pg->key.port : NULL; 957 struct net_bridge_group_src *ent; 958 size_t pkt_size, igmp_hdr_size; 959 unsigned long now = jiffies; 960 struct igmpv3_query *ihv3; 961 unsigned long lmqt, mrt; 962 void *csum_start = NULL; 963 __sum16 *csum = NULL; 964 struct sk_buff *skb; 965 struct igmphdr *ih; 966 struct ethhdr *eth; 967 struct iphdr *iph; 968 u16 lmqt_srcs = 0; 969 970 igmp_hdr_size = sizeof(*ih); 971 if (brmctx->multicast_igmp_version == 3) { 972 igmp_hdr_size = sizeof(*ihv3); 973 if (pg && with_srcs) { 974 lmqt = now + (brmctx->multicast_last_member_interval * 975 brmctx->multicast_last_member_count); 976 hlist_for_each_entry(ent, &pg->src_list, node) { 977 if (over_lmqt == time_after(ent->timer.expires, 978 lmqt) && 979 ent->src_query_rexmit_cnt > 0) 980 lmqt_srcs++; 981 } 982 983 if (!lmqt_srcs) 984 return NULL; 985 igmp_hdr_size += lmqt_srcs * sizeof(__be32); 986 } 987 } 988 989 pkt_size = sizeof(*eth) + sizeof(*iph) + 4 + igmp_hdr_size; 990 if ((p && pkt_size > p->dev->mtu) || 991 pkt_size > brmctx->br->dev->mtu) 992 return NULL; 993 994 skb = netdev_alloc_skb_ip_align(brmctx->br->dev, pkt_size); 995 if (!skb) 996 goto out; 997 998 __br_multicast_query_handle_vlan(brmctx, pmctx, skb); 999 skb->protocol = htons(ETH_P_IP); 1000 1001 skb_reset_mac_header(skb); 1002 eth = eth_hdr(skb); 1003 1004 ether_addr_copy(eth->h_source, brmctx->br->dev->dev_addr); 1005 ip_eth_mc_map(ip_dst, eth->h_dest); 1006 eth->h_proto = htons(ETH_P_IP); 1007 skb_put(skb, sizeof(*eth)); 1008 1009 skb_set_network_header(skb, skb->len); 1010 iph = ip_hdr(skb); 1011 iph->tot_len = htons(pkt_size - sizeof(*eth)); 1012 1013 iph->version = 4; 1014 iph->ihl = 6; 1015 iph->tos = 0xc0; 1016 iph->id = 0; 1017 iph->frag_off = htons(IP_DF); 1018 iph->ttl = 1; 1019 iph->protocol = IPPROTO_IGMP; 1020 iph->saddr = br_opt_get(brmctx->br, BROPT_MULTICAST_QUERY_USE_IFADDR) ? 1021 inet_select_addr(brmctx->br->dev, 0, RT_SCOPE_LINK) : 0; 1022 iph->daddr = ip_dst; 1023 ((u8 *)&iph[1])[0] = IPOPT_RA; 1024 ((u8 *)&iph[1])[1] = 4; 1025 ((u8 *)&iph[1])[2] = 0; 1026 ((u8 *)&iph[1])[3] = 0; 1027 ip_send_check(iph); 1028 skb_put(skb, 24); 1029 1030 skb_set_transport_header(skb, skb->len); 1031 mrt = group ? brmctx->multicast_last_member_interval : 1032 brmctx->multicast_query_response_interval; 1033 1034 switch (brmctx->multicast_igmp_version) { 1035 case 2: 1036 ih = igmp_hdr(skb); 1037 ih->type = IGMP_HOST_MEMBERSHIP_QUERY; 1038 ih->code = mrt / (HZ / IGMP_TIMER_SCALE); 1039 ih->group = group; 1040 ih->csum = 0; 1041 csum = &ih->csum; 1042 csum_start = (void *)ih; 1043 break; 1044 case 3: 1045 ihv3 = igmpv3_query_hdr(skb); 1046 ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY; 1047 ihv3->code = igmpv3_mrc(mrt / (HZ / IGMP_TIMER_SCALE)); 1048 ihv3->group = group; 1049 ihv3->qqic = igmpv3_qqic(brmctx->multicast_query_interval / HZ); 1050 ihv3->nsrcs = htons(lmqt_srcs); 1051 ihv3->resv = 0; 1052 ihv3->suppress = sflag; 1053 ihv3->qrv = 2; 1054 ihv3->csum = 0; 1055 csum = &ihv3->csum; 1056 csum_start = (void *)ihv3; 1057 if (!pg || !with_srcs) 1058 break; 1059 1060 lmqt_srcs = 0; 1061 hlist_for_each_entry(ent, &pg->src_list, node) { 1062 if (over_lmqt == time_after(ent->timer.expires, 1063 lmqt) && 1064 ent->src_query_rexmit_cnt > 0) { 1065 ihv3->srcs[lmqt_srcs++] = ent->addr.src.ip4; 1066 ent->src_query_rexmit_cnt--; 1067 if (need_rexmit && ent->src_query_rexmit_cnt) 1068 *need_rexmit = true; 1069 } 1070 } 1071 if (WARN_ON(lmqt_srcs != ntohs(ihv3->nsrcs))) { 1072 kfree_skb(skb); 1073 return NULL; 1074 } 1075 break; 1076 } 1077 1078 if (WARN_ON(!csum || !csum_start)) { 1079 kfree_skb(skb); 1080 return NULL; 1081 } 1082 1083 *csum = ip_compute_csum(csum_start, igmp_hdr_size); 1084 skb_put(skb, igmp_hdr_size); 1085 __skb_pull(skb, sizeof(*eth)); 1086 1087 out: 1088 return skb; 1089 } 1090 1091 #if IS_ENABLED(CONFIG_IPV6) 1092 static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge_mcast *brmctx, 1093 struct net_bridge_mcast_port *pmctx, 1094 struct net_bridge_port_group *pg, 1095 const struct in6_addr *ip6_dst, 1096 const struct in6_addr *group, 1097 bool with_srcs, bool over_llqt, 1098 u8 sflag, 1099 bool *need_rexmit) 1100 { 1101 struct net_bridge_port *p = pg ? pg->key.port : NULL; 1102 struct net_bridge_group_src *ent; 1103 size_t pkt_size, mld_hdr_size; 1104 unsigned long now = jiffies; 1105 struct mld2_query *mld2q; 1106 void *csum_start = NULL; 1107 unsigned long interval; 1108 __sum16 *csum = NULL; 1109 struct ipv6hdr *ip6h; 1110 struct mld_msg *mldq; 1111 struct sk_buff *skb; 1112 unsigned long llqt; 1113 struct ethhdr *eth; 1114 u16 llqt_srcs = 0; 1115 u8 *hopopt; 1116 1117 mld_hdr_size = sizeof(*mldq); 1118 if (brmctx->multicast_mld_version == 2) { 1119 mld_hdr_size = sizeof(*mld2q); 1120 if (pg && with_srcs) { 1121 llqt = now + (brmctx->multicast_last_member_interval * 1122 brmctx->multicast_last_member_count); 1123 hlist_for_each_entry(ent, &pg->src_list, node) { 1124 if (over_llqt == time_after(ent->timer.expires, 1125 llqt) && 1126 ent->src_query_rexmit_cnt > 0) 1127 llqt_srcs++; 1128 } 1129 1130 if (!llqt_srcs) 1131 return NULL; 1132 mld_hdr_size += llqt_srcs * sizeof(struct in6_addr); 1133 } 1134 } 1135 1136 pkt_size = sizeof(*eth) + sizeof(*ip6h) + 8 + mld_hdr_size; 1137 if ((p && pkt_size > p->dev->mtu) || 1138 pkt_size > brmctx->br->dev->mtu) 1139 return NULL; 1140 1141 skb = netdev_alloc_skb_ip_align(brmctx->br->dev, pkt_size); 1142 if (!skb) 1143 goto out; 1144 1145 __br_multicast_query_handle_vlan(brmctx, pmctx, skb); 1146 skb->protocol = htons(ETH_P_IPV6); 1147 1148 /* Ethernet header */ 1149 skb_reset_mac_header(skb); 1150 eth = eth_hdr(skb); 1151 1152 ether_addr_copy(eth->h_source, brmctx->br->dev->dev_addr); 1153 eth->h_proto = htons(ETH_P_IPV6); 1154 skb_put(skb, sizeof(*eth)); 1155 1156 /* IPv6 header + HbH option */ 1157 skb_set_network_header(skb, skb->len); 1158 ip6h = ipv6_hdr(skb); 1159 1160 *(__force __be32 *)ip6h = htonl(0x60000000); 1161 ip6h->payload_len = htons(8 + mld_hdr_size); 1162 ip6h->nexthdr = IPPROTO_HOPOPTS; 1163 ip6h->hop_limit = 1; 1164 ip6h->daddr = *ip6_dst; 1165 if (ipv6_dev_get_saddr(dev_net(brmctx->br->dev), brmctx->br->dev, 1166 &ip6h->daddr, 0, &ip6h->saddr)) { 1167 kfree_skb(skb); 1168 br_opt_toggle(brmctx->br, BROPT_HAS_IPV6_ADDR, false); 1169 return NULL; 1170 } 1171 1172 br_opt_toggle(brmctx->br, BROPT_HAS_IPV6_ADDR, true); 1173 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest); 1174 1175 hopopt = (u8 *)(ip6h + 1); 1176 hopopt[0] = IPPROTO_ICMPV6; /* next hdr */ 1177 hopopt[1] = 0; /* length of HbH */ 1178 hopopt[2] = IPV6_TLV_ROUTERALERT; /* Router Alert */ 1179 hopopt[3] = 2; /* Length of RA Option */ 1180 hopopt[4] = 0; /* Type = 0x0000 (MLD) */ 1181 hopopt[5] = 0; 1182 hopopt[6] = IPV6_TLV_PAD1; /* Pad1 */ 1183 hopopt[7] = IPV6_TLV_PAD1; /* Pad1 */ 1184 1185 skb_put(skb, sizeof(*ip6h) + 8); 1186 1187 /* ICMPv6 */ 1188 skb_set_transport_header(skb, skb->len); 1189 interval = ipv6_addr_any(group) ? 1190 brmctx->multicast_query_response_interval : 1191 brmctx->multicast_last_member_interval; 1192 switch (brmctx->multicast_mld_version) { 1193 case 1: 1194 mldq = (struct mld_msg *)icmp6_hdr(skb); 1195 mldq->mld_type = ICMPV6_MGM_QUERY; 1196 mldq->mld_code = 0; 1197 mldq->mld_cksum = 0; 1198 mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval)); 1199 mldq->mld_reserved = 0; 1200 mldq->mld_mca = *group; 1201 csum = &mldq->mld_cksum; 1202 csum_start = (void *)mldq; 1203 break; 1204 case 2: 1205 mld2q = (struct mld2_query *)icmp6_hdr(skb); 1206 mld2q->mld2q_mrc = htons(mldv2_mrc(jiffies_to_msecs(interval))); 1207 mld2q->mld2q_type = ICMPV6_MGM_QUERY; 1208 mld2q->mld2q_code = 0; 1209 mld2q->mld2q_cksum = 0; 1210 mld2q->mld2q_resv1 = 0; 1211 mld2q->mld2q_resv2 = 0; 1212 mld2q->mld2q_suppress = sflag; 1213 mld2q->mld2q_qrv = 2; 1214 mld2q->mld2q_nsrcs = htons(llqt_srcs); 1215 mld2q->mld2q_qqic = mldv2_qqic(brmctx->multicast_query_interval / HZ); 1216 mld2q->mld2q_mca = *group; 1217 csum = &mld2q->mld2q_cksum; 1218 csum_start = (void *)mld2q; 1219 if (!pg || !with_srcs) 1220 break; 1221 1222 llqt_srcs = 0; 1223 hlist_for_each_entry(ent, &pg->src_list, node) { 1224 if (over_llqt == time_after(ent->timer.expires, 1225 llqt) && 1226 ent->src_query_rexmit_cnt > 0) { 1227 mld2q->mld2q_srcs[llqt_srcs++] = ent->addr.src.ip6; 1228 ent->src_query_rexmit_cnt--; 1229 if (need_rexmit && ent->src_query_rexmit_cnt) 1230 *need_rexmit = true; 1231 } 1232 } 1233 if (WARN_ON(llqt_srcs != ntohs(mld2q->mld2q_nsrcs))) { 1234 kfree_skb(skb); 1235 return NULL; 1236 } 1237 break; 1238 } 1239 1240 if (WARN_ON(!csum || !csum_start)) { 1241 kfree_skb(skb); 1242 return NULL; 1243 } 1244 1245 *csum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr, mld_hdr_size, 1246 IPPROTO_ICMPV6, 1247 csum_partial(csum_start, mld_hdr_size, 0)); 1248 skb_put(skb, mld_hdr_size); 1249 __skb_pull(skb, sizeof(*eth)); 1250 1251 out: 1252 return skb; 1253 } 1254 #endif 1255 1256 static struct sk_buff *br_multicast_alloc_query(struct net_bridge_mcast *brmctx, 1257 struct net_bridge_mcast_port *pmctx, 1258 struct net_bridge_port_group *pg, 1259 struct br_ip *ip_dst, 1260 struct br_ip *group, 1261 bool with_srcs, bool over_lmqt, 1262 u8 sflag, bool *need_rexmit) 1263 { 1264 __be32 ip4_dst; 1265 1266 switch (group->proto) { 1267 case htons(ETH_P_IP): 1268 ip4_dst = ip_dst ? ip_dst->dst.ip4 : htonl(INADDR_ALLHOSTS_GROUP); 1269 return br_ip4_multicast_alloc_query(brmctx, pmctx, pg, 1270 ip4_dst, group->dst.ip4, 1271 with_srcs, over_lmqt, 1272 sflag, need_rexmit); 1273 #if IS_ENABLED(CONFIG_IPV6) 1274 case htons(ETH_P_IPV6): { 1275 struct in6_addr ip6_dst; 1276 1277 if (ip_dst) 1278 ip6_dst = ip_dst->dst.ip6; 1279 else 1280 ipv6_addr_set(&ip6_dst, htonl(0xff020000), 0, 0, 1281 htonl(1)); 1282 1283 return br_ip6_multicast_alloc_query(brmctx, pmctx, pg, 1284 &ip6_dst, &group->dst.ip6, 1285 with_srcs, over_lmqt, 1286 sflag, need_rexmit); 1287 } 1288 #endif 1289 } 1290 return NULL; 1291 } 1292 1293 struct net_bridge_mdb_entry *br_multicast_new_group(struct net_bridge *br, 1294 struct br_ip *group) 1295 { 1296 struct net_bridge_mdb_entry *mp; 1297 int err; 1298 1299 mp = br_mdb_ip_get(br, group); 1300 if (mp) 1301 return mp; 1302 1303 if (atomic_read(&br->mdb_hash_tbl.nelems) >= br->hash_max) { 1304 trace_br_mdb_full(br->dev, group); 1305 br_mc_disabled_update(br->dev, false, NULL); 1306 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, false); 1307 return ERR_PTR(-E2BIG); 1308 } 1309 1310 mp = kzalloc_obj(*mp, GFP_ATOMIC); 1311 if (unlikely(!mp)) 1312 return ERR_PTR(-ENOMEM); 1313 1314 mp->br = br; 1315 mp->addr = *group; 1316 mp->mcast_gc.destroy = br_multicast_destroy_mdb_entry; 1317 timer_setup(&mp->timer, br_multicast_group_expired, 0); 1318 err = rhashtable_lookup_insert_fast(&br->mdb_hash_tbl, &mp->rhnode, 1319 br_mdb_rht_params); 1320 if (err) { 1321 kfree(mp); 1322 mp = ERR_PTR(err); 1323 } else { 1324 hlist_add_head_rcu(&mp->mdb_node, &br->mdb_list); 1325 } 1326 1327 return mp; 1328 } 1329 1330 static void br_multicast_group_src_expired(struct timer_list *t) 1331 { 1332 struct net_bridge_group_src *src = timer_container_of(src, t, timer); 1333 struct net_bridge_port_group *pg; 1334 struct net_bridge *br = src->br; 1335 1336 spin_lock(&br->multicast_lock); 1337 if (hlist_unhashed(&src->node) || !netif_running(br->dev) || 1338 timer_pending(&src->timer)) 1339 goto out; 1340 1341 pg = src->pg; 1342 if (pg->filter_mode == MCAST_INCLUDE) { 1343 br_multicast_del_group_src(src, false); 1344 if (!hlist_empty(&pg->src_list)) 1345 goto out; 1346 br_multicast_find_del_pg(br, pg); 1347 } else { 1348 br_multicast_fwd_src_handle(src); 1349 } 1350 1351 out: 1352 spin_unlock(&br->multicast_lock); 1353 } 1354 1355 struct net_bridge_group_src * 1356 br_multicast_find_group_src(struct net_bridge_port_group *pg, struct br_ip *ip) 1357 { 1358 struct net_bridge_group_src *ent; 1359 1360 switch (ip->proto) { 1361 case htons(ETH_P_IP): 1362 hlist_for_each_entry(ent, &pg->src_list, node) 1363 if (ip->src.ip4 == ent->addr.src.ip4) 1364 return ent; 1365 break; 1366 #if IS_ENABLED(CONFIG_IPV6) 1367 case htons(ETH_P_IPV6): 1368 hlist_for_each_entry(ent, &pg->src_list, node) 1369 if (!ipv6_addr_cmp(&ent->addr.src.ip6, &ip->src.ip6)) 1370 return ent; 1371 break; 1372 #endif 1373 } 1374 1375 return NULL; 1376 } 1377 1378 struct net_bridge_group_src * 1379 br_multicast_new_group_src(struct net_bridge_port_group *pg, struct br_ip *src_ip) 1380 { 1381 struct net_bridge_group_src *grp_src; 1382 1383 if (unlikely(pg->src_ents >= PG_SRC_ENT_LIMIT)) 1384 return NULL; 1385 1386 switch (src_ip->proto) { 1387 case htons(ETH_P_IP): 1388 if (ipv4_is_zeronet(src_ip->src.ip4) || 1389 ipv4_is_multicast(src_ip->src.ip4)) 1390 return NULL; 1391 break; 1392 #if IS_ENABLED(CONFIG_IPV6) 1393 case htons(ETH_P_IPV6): 1394 if (ipv6_addr_any(&src_ip->src.ip6) || 1395 ipv6_addr_is_multicast(&src_ip->src.ip6)) 1396 return NULL; 1397 break; 1398 #endif 1399 } 1400 1401 grp_src = kzalloc_obj(*grp_src, GFP_ATOMIC); 1402 if (unlikely(!grp_src)) 1403 return NULL; 1404 1405 grp_src->pg = pg; 1406 grp_src->br = pg->key.port->br; 1407 grp_src->addr = *src_ip; 1408 grp_src->mcast_gc.destroy = br_multicast_destroy_group_src; 1409 timer_setup(&grp_src->timer, br_multicast_group_src_expired, 0); 1410 1411 hlist_add_head_rcu(&grp_src->node, &pg->src_list); 1412 pg->src_ents++; 1413 1414 return grp_src; 1415 } 1416 1417 struct net_bridge_port_group *br_multicast_new_port_group( 1418 struct net_bridge_port *port, 1419 const struct br_ip *group, 1420 struct net_bridge_port_group __rcu *next, 1421 unsigned char flags, 1422 const unsigned char *src, 1423 u8 filter_mode, 1424 u8 rt_protocol, 1425 struct netlink_ext_ack *extack) 1426 { 1427 struct net_bridge_port_group *p; 1428 int err; 1429 1430 err = br_multicast_port_ngroups_inc(port, group, extack); 1431 if (err) 1432 return NULL; 1433 1434 p = kzalloc_obj(*p, GFP_ATOMIC); 1435 if (unlikely(!p)) { 1436 NL_SET_ERR_MSG_MOD(extack, "Couldn't allocate new port group"); 1437 goto dec_out; 1438 } 1439 1440 p->key.addr = *group; 1441 p->key.port = port; 1442 p->flags = flags; 1443 p->filter_mode = filter_mode; 1444 p->rt_protocol = rt_protocol; 1445 p->eht_host_tree = RB_ROOT; 1446 p->eht_set_tree = RB_ROOT; 1447 p->mcast_gc.destroy = br_multicast_destroy_port_group; 1448 INIT_HLIST_HEAD(&p->src_list); 1449 1450 if (!br_multicast_is_star_g(group) && 1451 rhashtable_lookup_insert_fast(&port->br->sg_port_tbl, &p->rhnode, 1452 br_sg_port_rht_params)) { 1453 NL_SET_ERR_MSG_MOD(extack, "Couldn't insert new port group"); 1454 goto free_out; 1455 } 1456 1457 timer_setup(&p->timer, br_multicast_port_group_expired, 0); 1458 timer_setup(&p->rexmit_timer, br_multicast_port_group_rexmit, 0); 1459 1460 if (src) 1461 memcpy(p->eth_addr, src, ETH_ALEN); 1462 else 1463 eth_broadcast_addr(p->eth_addr); 1464 1465 RCU_INIT_POINTER(p->next, next); 1466 hlist_add_head_rcu(&p->mglist, &port->mglist); 1467 1468 return p; 1469 1470 free_out: 1471 kfree(p); 1472 dec_out: 1473 br_multicast_port_ngroups_dec(port, group->vid); 1474 return NULL; 1475 } 1476 1477 void br_multicast_del_port_group(struct net_bridge_port_group *p) 1478 { 1479 struct net_bridge_port *port = p->key.port; 1480 __u16 vid = p->key.addr.vid; 1481 1482 hlist_del_init_rcu(&p->mglist); 1483 if (!br_multicast_is_star_g(&p->key.addr)) 1484 rhashtable_remove_fast(&port->br->sg_port_tbl, &p->rhnode, 1485 br_sg_port_rht_params); 1486 kfree_rcu(p, rcu); 1487 br_multicast_port_ngroups_dec(port, vid); 1488 } 1489 1490 void br_multicast_host_join(const struct net_bridge_mcast *brmctx, 1491 struct net_bridge_mdb_entry *mp, bool notify) 1492 { 1493 if (!mp->host_joined) { 1494 mp->host_joined = true; 1495 if (br_multicast_is_star_g(&mp->addr)) 1496 br_multicast_star_g_host_state(mp); 1497 if (notify) 1498 br_mdb_notify(mp->br->dev, mp, NULL, RTM_NEWMDB); 1499 } 1500 1501 if (br_group_is_l2(&mp->addr)) 1502 return; 1503 1504 mod_timer(&mp->timer, jiffies + brmctx->multicast_membership_interval); 1505 } 1506 1507 void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify) 1508 { 1509 if (!mp->host_joined) 1510 return; 1511 1512 mp->host_joined = false; 1513 if (br_multicast_is_star_g(&mp->addr)) 1514 br_multicast_star_g_host_state(mp); 1515 if (notify) 1516 br_mdb_notify(mp->br->dev, mp, NULL, RTM_DELMDB); 1517 } 1518 1519 static struct net_bridge_port_group * 1520 __br_multicast_add_group(struct net_bridge_mcast *brmctx, 1521 struct net_bridge_mcast_port *pmctx, 1522 struct br_ip *group, 1523 const unsigned char *src, 1524 u8 filter_mode, 1525 bool igmpv2_mldv1, 1526 bool blocked) 1527 { 1528 struct net_bridge_port_group __rcu **pp; 1529 struct net_bridge_port_group *p = NULL; 1530 struct net_bridge_mdb_entry *mp; 1531 unsigned long now = jiffies; 1532 1533 if (!br_multicast_ctx_should_use(brmctx, pmctx)) 1534 goto out; 1535 1536 mp = br_multicast_new_group(brmctx->br, group); 1537 if (IS_ERR(mp)) 1538 return ERR_CAST(mp); 1539 1540 if (!pmctx) { 1541 br_multicast_host_join(brmctx, mp, true); 1542 goto out; 1543 } 1544 1545 for (pp = &mp->ports; 1546 (p = mlock_dereference(*pp, brmctx->br)) != NULL; 1547 pp = &p->next) { 1548 if (br_port_group_equal(p, pmctx->port, src)) 1549 goto found; 1550 if ((unsigned long)p->key.port < (unsigned long)pmctx->port) 1551 break; 1552 } 1553 1554 p = br_multicast_new_port_group(pmctx->port, group, *pp, 0, src, 1555 filter_mode, RTPROT_KERNEL, NULL); 1556 if (unlikely(!p)) { 1557 p = ERR_PTR(-ENOMEM); 1558 goto out; 1559 } 1560 rcu_assign_pointer(*pp, p); 1561 if (blocked) 1562 p->flags |= MDB_PG_FLAGS_BLOCKED; 1563 br_mdb_notify(brmctx->br->dev, mp, p, RTM_NEWMDB); 1564 1565 found: 1566 if (igmpv2_mldv1) 1567 mod_timer(&p->timer, 1568 now + brmctx->multicast_membership_interval); 1569 1570 out: 1571 return p; 1572 } 1573 1574 static int br_multicast_add_group(struct net_bridge_mcast *brmctx, 1575 struct net_bridge_mcast_port *pmctx, 1576 struct br_ip *group, 1577 const unsigned char *src, 1578 u8 filter_mode, 1579 bool igmpv2_mldv1) 1580 { 1581 struct net_bridge_port_group *pg; 1582 int err; 1583 1584 spin_lock(&brmctx->br->multicast_lock); 1585 pg = __br_multicast_add_group(brmctx, pmctx, group, src, filter_mode, 1586 igmpv2_mldv1, false); 1587 /* NULL is considered valid for host joined groups */ 1588 err = PTR_ERR_OR_ZERO(pg); 1589 spin_unlock(&brmctx->br->multicast_lock); 1590 1591 return err; 1592 } 1593 1594 static int br_ip4_multicast_add_group(struct net_bridge_mcast *brmctx, 1595 struct net_bridge_mcast_port *pmctx, 1596 __be32 group, 1597 __u16 vid, 1598 const unsigned char *src, 1599 bool igmpv2) 1600 { 1601 struct br_ip br_group; 1602 u8 filter_mode; 1603 1604 if (ipv4_is_local_multicast(group)) 1605 return 0; 1606 1607 memset(&br_group, 0, sizeof(br_group)); 1608 br_group.dst.ip4 = group; 1609 br_group.proto = htons(ETH_P_IP); 1610 br_group.vid = vid; 1611 filter_mode = igmpv2 ? MCAST_EXCLUDE : MCAST_INCLUDE; 1612 1613 return br_multicast_add_group(brmctx, pmctx, &br_group, src, 1614 filter_mode, igmpv2); 1615 } 1616 1617 #if IS_ENABLED(CONFIG_IPV6) 1618 static int br_ip6_multicast_add_group(struct net_bridge_mcast *brmctx, 1619 struct net_bridge_mcast_port *pmctx, 1620 const struct in6_addr *group, 1621 __u16 vid, 1622 const unsigned char *src, 1623 bool mldv1) 1624 { 1625 struct br_ip br_group; 1626 u8 filter_mode; 1627 1628 if (ipv6_addr_is_ll_all_nodes(group)) 1629 return 0; 1630 1631 memset(&br_group, 0, sizeof(br_group)); 1632 br_group.dst.ip6 = *group; 1633 br_group.proto = htons(ETH_P_IPV6); 1634 br_group.vid = vid; 1635 filter_mode = mldv1 ? MCAST_EXCLUDE : MCAST_INCLUDE; 1636 1637 return br_multicast_add_group(brmctx, pmctx, &br_group, src, 1638 filter_mode, mldv1); 1639 } 1640 #endif 1641 1642 static bool br_multicast_rport_del(struct hlist_node *rlist) 1643 { 1644 if (hlist_unhashed(rlist)) 1645 return false; 1646 1647 hlist_del_init_rcu(rlist); 1648 return true; 1649 } 1650 1651 static bool br_ip4_multicast_rport_del(struct net_bridge_mcast_port *pmctx) 1652 { 1653 return br_multicast_rport_del(&pmctx->ip4_rlist); 1654 } 1655 1656 static bool br_ip6_multicast_rport_del(struct net_bridge_mcast_port *pmctx) 1657 { 1658 #if IS_ENABLED(CONFIG_IPV6) 1659 return br_multicast_rport_del(&pmctx->ip6_rlist); 1660 #else 1661 return false; 1662 #endif 1663 } 1664 1665 static void br_multicast_router_expired(struct net_bridge_mcast_port *pmctx, 1666 struct timer_list *t, 1667 struct hlist_node *rlist) 1668 { 1669 struct net_bridge *br = pmctx->port->br; 1670 bool del; 1671 1672 spin_lock(&br->multicast_lock); 1673 if (pmctx->multicast_router == MDB_RTR_TYPE_DISABLED || 1674 pmctx->multicast_router == MDB_RTR_TYPE_PERM || 1675 timer_pending(t)) 1676 goto out; 1677 1678 del = br_multicast_rport_del(rlist); 1679 br_multicast_rport_del_notify(pmctx, del); 1680 out: 1681 spin_unlock(&br->multicast_lock); 1682 } 1683 1684 static void br_ip4_multicast_router_expired(struct timer_list *t) 1685 { 1686 struct net_bridge_mcast_port *pmctx = timer_container_of(pmctx, t, 1687 ip4_mc_router_timer); 1688 1689 br_multicast_router_expired(pmctx, t, &pmctx->ip4_rlist); 1690 } 1691 1692 #if IS_ENABLED(CONFIG_IPV6) 1693 static void br_ip6_multicast_router_expired(struct timer_list *t) 1694 { 1695 struct net_bridge_mcast_port *pmctx = timer_container_of(pmctx, t, 1696 ip6_mc_router_timer); 1697 1698 br_multicast_router_expired(pmctx, t, &pmctx->ip6_rlist); 1699 } 1700 #endif 1701 1702 static void br_mc_router_state_change(struct net_bridge *p, 1703 bool is_mc_router) 1704 { 1705 struct switchdev_attr attr = { 1706 .orig_dev = p->dev, 1707 .id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER, 1708 .flags = SWITCHDEV_F_DEFER, 1709 .u.mrouter = is_mc_router, 1710 }; 1711 1712 switchdev_port_attr_set(p->dev, &attr, NULL); 1713 } 1714 1715 static void br_multicast_local_router_expired(struct net_bridge_mcast *brmctx, 1716 struct timer_list *timer) 1717 { 1718 spin_lock(&brmctx->br->multicast_lock); 1719 if (brmctx->multicast_router == MDB_RTR_TYPE_DISABLED || 1720 brmctx->multicast_router == MDB_RTR_TYPE_PERM || 1721 br_ip4_multicast_is_router(brmctx) || 1722 br_ip6_multicast_is_router(brmctx)) 1723 goto out; 1724 1725 br_mc_router_state_change(brmctx->br, false); 1726 out: 1727 spin_unlock(&brmctx->br->multicast_lock); 1728 } 1729 1730 static void br_ip4_multicast_local_router_expired(struct timer_list *t) 1731 { 1732 struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 1733 ip4_mc_router_timer); 1734 1735 br_multicast_local_router_expired(brmctx, t); 1736 } 1737 1738 #if IS_ENABLED(CONFIG_IPV6) 1739 static void br_ip6_multicast_local_router_expired(struct timer_list *t) 1740 { 1741 struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 1742 ip6_mc_router_timer); 1743 1744 br_multicast_local_router_expired(brmctx, t); 1745 } 1746 #endif 1747 1748 static void br_multicast_querier_expired(struct net_bridge_mcast *brmctx, 1749 struct bridge_mcast_own_query *query) 1750 { 1751 spin_lock(&brmctx->br->multicast_lock); 1752 if (!netif_running(brmctx->br->dev) || 1753 br_multicast_ctx_vlan_global_disabled(brmctx) || 1754 !br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED)) 1755 goto out; 1756 1757 br_multicast_start_querier(brmctx, query); 1758 1759 out: 1760 spin_unlock(&brmctx->br->multicast_lock); 1761 } 1762 1763 static void br_ip4_multicast_querier_expired(struct timer_list *t) 1764 { 1765 struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 1766 ip4_other_query.timer); 1767 1768 br_multicast_querier_expired(brmctx, &brmctx->ip4_own_query); 1769 } 1770 1771 #if IS_ENABLED(CONFIG_IPV6) 1772 static void br_ip6_multicast_querier_expired(struct timer_list *t) 1773 { 1774 struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 1775 ip6_other_query.timer); 1776 1777 br_multicast_querier_expired(brmctx, &brmctx->ip6_own_query); 1778 } 1779 #endif 1780 1781 static void br_multicast_query_delay_expired(struct timer_list *t) 1782 { 1783 } 1784 1785 static void br_multicast_select_own_querier(struct net_bridge_mcast *brmctx, 1786 struct br_ip *ip, 1787 struct sk_buff *skb) 1788 { 1789 if (ip->proto == htons(ETH_P_IP)) 1790 brmctx->ip4_querier.addr.src.ip4 = ip_hdr(skb)->saddr; 1791 #if IS_ENABLED(CONFIG_IPV6) 1792 else 1793 brmctx->ip6_querier.addr.src.ip6 = ipv6_hdr(skb)->saddr; 1794 #endif 1795 } 1796 1797 static u8 br_multicast_query_type(const struct sk_buff *skb) 1798 { 1799 return skb->protocol == htons(ETH_P_IP) ? IGMP_HOST_MEMBERSHIP_QUERY : 1800 ICMPV6_MGM_QUERY; 1801 } 1802 1803 static void br_multicast_port_query_queue_work(struct work_struct *work) 1804 { 1805 struct net_bridge_mcast_port *pmctx; 1806 struct sk_buff_head list; 1807 struct sk_buff *skb; 1808 1809 pmctx = container_of(work, struct net_bridge_mcast_port, 1810 query_queue_work); 1811 1812 __skb_queue_head_init(&list); 1813 spin_lock_bh(&pmctx->query_queue.lock); 1814 skb_queue_splice_tail_init(&pmctx->query_queue, &list); 1815 spin_unlock_bh(&pmctx->query_queue.lock); 1816 1817 while ((skb = __skb_dequeue(&list))) { 1818 u8 query_type = br_multicast_query_type(skb); 1819 1820 local_bh_disable(); 1821 br_multicast_count(pmctx->port->br, pmctx->port, skb, 1822 query_type, BR_MCAST_DIR_TX); 1823 NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, dev_net(skb->dev), 1824 NULL, skb, NULL, skb->dev, br_dev_queue_push_xmit); 1825 local_bh_enable(); 1826 } 1827 } 1828 1829 static void br_multicast_query_queue_work(struct work_struct *work) 1830 { 1831 struct net_bridge_mcast *brmctx; 1832 struct sk_buff_head list; 1833 struct sk_buff *skb; 1834 1835 brmctx = container_of(work, struct net_bridge_mcast, query_queue_work); 1836 1837 __skb_queue_head_init(&list); 1838 spin_lock_bh(&brmctx->query_queue.lock); 1839 skb_queue_splice_tail_init(&brmctx->query_queue, &list); 1840 spin_unlock_bh(&brmctx->query_queue.lock); 1841 1842 while ((skb = __skb_dequeue(&list))) { 1843 u8 query_type = br_multicast_query_type(skb); 1844 1845 local_bh_disable(); 1846 br_multicast_count(brmctx->br, NULL, skb, query_type, 1847 BR_MCAST_DIR_RX); 1848 netif_rx(skb); 1849 local_bh_enable(); 1850 } 1851 } 1852 1853 #define BR_MULTICAST_QUERY_QUEUE_LEN_MAX 1000 1854 1855 static void __br_multicast_send_query(struct net_bridge_mcast *brmctx, 1856 struct net_bridge_mcast_port *pmctx, 1857 struct net_bridge_port_group *pg, 1858 struct br_ip *ip_dst, 1859 struct br_ip *group, 1860 bool with_srcs, 1861 u8 sflag, 1862 bool *need_rexmit) 1863 { 1864 struct sk_buff_head *queue; 1865 bool over_lmqt = !!sflag; 1866 struct sk_buff *skb; 1867 1868 if (!br_multicast_ctx_should_use(brmctx, pmctx) || 1869 !br_multicast_ctx_matches_vlan_snooping(brmctx)) 1870 return; 1871 1872 queue = pmctx ? &pmctx->query_queue : &brmctx->query_queue; 1873 1874 again_under_lmqt: 1875 if (skb_queue_len_lockless(queue) >= BR_MULTICAST_QUERY_QUEUE_LEN_MAX) 1876 return; 1877 1878 skb = br_multicast_alloc_query(brmctx, pmctx, pg, ip_dst, group, 1879 with_srcs, over_lmqt, sflag, 1880 need_rexmit); 1881 if (!skb) 1882 return; 1883 1884 if (pmctx) { 1885 skb->dev = pmctx->port->dev; 1886 skb_queue_tail(queue, skb); 1887 queue_work(system_highpri_wq, &pmctx->query_queue_work); 1888 1889 if (over_lmqt && with_srcs && sflag) { 1890 over_lmqt = false; 1891 goto again_under_lmqt; 1892 } 1893 } else { 1894 br_multicast_select_own_querier(brmctx, group, skb); 1895 skb_queue_tail(queue, skb); 1896 queue_work(system_highpri_wq, &brmctx->query_queue_work); 1897 } 1898 } 1899 1900 static void br_multicast_read_querier(const struct bridge_mcast_querier *querier, 1901 struct bridge_mcast_querier *dest) 1902 { 1903 unsigned int seq; 1904 1905 memset(dest, 0, sizeof(*dest)); 1906 do { 1907 seq = read_seqcount_begin(&querier->seq); 1908 dest->port_ifidx = querier->port_ifidx; 1909 memcpy(&dest->addr, &querier->addr, sizeof(struct br_ip)); 1910 } while (read_seqcount_retry(&querier->seq, seq)); 1911 } 1912 1913 static void br_multicast_update_querier(struct net_bridge_mcast *brmctx, 1914 struct bridge_mcast_querier *querier, 1915 int ifindex, 1916 struct br_ip *saddr) 1917 { 1918 write_seqcount_begin(&querier->seq); 1919 querier->port_ifidx = ifindex; 1920 memcpy(&querier->addr, saddr, sizeof(*saddr)); 1921 write_seqcount_end(&querier->seq); 1922 } 1923 1924 static void br_multicast_send_query(struct net_bridge_mcast *brmctx, 1925 struct net_bridge_mcast_port *pmctx, 1926 struct bridge_mcast_own_query *own_query) 1927 { 1928 struct bridge_mcast_other_query *other_query = NULL; 1929 struct bridge_mcast_querier *querier; 1930 struct br_ip br_group; 1931 unsigned long time; 1932 1933 if (!br_multicast_ctx_should_use(brmctx, pmctx) || 1934 !br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED) || 1935 !brmctx->multicast_querier) 1936 return; 1937 1938 memset(&br_group.dst, 0, sizeof(br_group.dst)); 1939 1940 if (pmctx ? (own_query == &pmctx->ip4_own_query) : 1941 (own_query == &brmctx->ip4_own_query)) { 1942 querier = &brmctx->ip4_querier; 1943 other_query = &brmctx->ip4_other_query; 1944 br_group.proto = htons(ETH_P_IP); 1945 #if IS_ENABLED(CONFIG_IPV6) 1946 } else { 1947 querier = &brmctx->ip6_querier; 1948 other_query = &brmctx->ip6_other_query; 1949 br_group.proto = htons(ETH_P_IPV6); 1950 #endif 1951 } 1952 1953 if (!other_query || timer_pending(&other_query->timer)) 1954 return; 1955 1956 /* we're about to select ourselves as querier */ 1957 if (!pmctx && querier->port_ifidx) { 1958 struct br_ip zeroip = {}; 1959 1960 br_multicast_update_querier(brmctx, querier, 0, &zeroip); 1961 } 1962 1963 __br_multicast_send_query(brmctx, pmctx, NULL, NULL, &br_group, false, 1964 0, NULL); 1965 1966 time = jiffies; 1967 time += own_query->startup_sent < brmctx->multicast_startup_query_count ? 1968 brmctx->multicast_startup_query_interval : 1969 brmctx->multicast_query_interval; 1970 mod_timer(&own_query->timer, time); 1971 } 1972 1973 static void 1974 br_multicast_port_query_expired(struct net_bridge_mcast_port *pmctx, 1975 struct bridge_mcast_own_query *query) 1976 { 1977 struct net_bridge *br = pmctx->port->br; 1978 struct net_bridge_mcast *brmctx; 1979 1980 spin_lock(&br->multicast_lock); 1981 if (br_multicast_port_ctx_state_stopped(pmctx)) 1982 goto out; 1983 1984 brmctx = br_multicast_port_ctx_get_global(pmctx); 1985 if (query->startup_sent < brmctx->multicast_startup_query_count) 1986 query->startup_sent++; 1987 1988 br_multicast_send_query(brmctx, pmctx, query); 1989 1990 out: 1991 spin_unlock(&br->multicast_lock); 1992 } 1993 1994 static void br_ip4_multicast_port_query_expired(struct timer_list *t) 1995 { 1996 struct net_bridge_mcast_port *pmctx = timer_container_of(pmctx, t, 1997 ip4_own_query.timer); 1998 1999 br_multicast_port_query_expired(pmctx, &pmctx->ip4_own_query); 2000 } 2001 2002 #if IS_ENABLED(CONFIG_IPV6) 2003 static void br_ip6_multicast_port_query_expired(struct timer_list *t) 2004 { 2005 struct net_bridge_mcast_port *pmctx = timer_container_of(pmctx, t, 2006 ip6_own_query.timer); 2007 2008 br_multicast_port_query_expired(pmctx, &pmctx->ip6_own_query); 2009 } 2010 #endif 2011 2012 static void br_multicast_port_group_rexmit(struct timer_list *t) 2013 { 2014 struct net_bridge_port_group *pg = timer_container_of(pg, t, 2015 rexmit_timer); 2016 struct bridge_mcast_other_query *other_query = NULL; 2017 struct net_bridge *br = pg->key.port->br; 2018 struct net_bridge_mcast_port *pmctx; 2019 struct net_bridge_mcast *brmctx; 2020 bool need_rexmit = false; 2021 2022 spin_lock(&br->multicast_lock); 2023 if (!netif_running(br->dev) || hlist_unhashed(&pg->mglist) || 2024 !br_opt_get(br, BROPT_MULTICAST_ENABLED)) 2025 goto out; 2026 2027 pmctx = br_multicast_pg_to_port_ctx(pg); 2028 if (!pmctx) 2029 goto out; 2030 brmctx = br_multicast_port_ctx_get_global(pmctx); 2031 if (!brmctx->multicast_querier) 2032 goto out; 2033 2034 if (pg->key.addr.proto == htons(ETH_P_IP)) 2035 other_query = &brmctx->ip4_other_query; 2036 #if IS_ENABLED(CONFIG_IPV6) 2037 else 2038 other_query = &brmctx->ip6_other_query; 2039 #endif 2040 2041 if (!other_query || timer_pending(&other_query->timer)) 2042 goto out; 2043 2044 if (pg->grp_query_rexmit_cnt) { 2045 pg->grp_query_rexmit_cnt--; 2046 __br_multicast_send_query(brmctx, pmctx, pg, &pg->key.addr, 2047 &pg->key.addr, false, 1, NULL); 2048 } 2049 __br_multicast_send_query(brmctx, pmctx, pg, &pg->key.addr, 2050 &pg->key.addr, true, 0, &need_rexmit); 2051 2052 if (pg->grp_query_rexmit_cnt || need_rexmit) 2053 mod_timer(&pg->rexmit_timer, jiffies + 2054 brmctx->multicast_last_member_interval); 2055 out: 2056 spin_unlock(&br->multicast_lock); 2057 } 2058 2059 static int br_mc_disabled_update(struct net_device *dev, bool value, 2060 struct netlink_ext_ack *extack) 2061 { 2062 struct switchdev_attr attr = { 2063 .orig_dev = dev, 2064 .id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED, 2065 .flags = SWITCHDEV_F_DEFER, 2066 .u.mc_disabled = !value, 2067 }; 2068 2069 return switchdev_port_attr_set(dev, &attr, extack); 2070 } 2071 2072 void br_multicast_port_ctx_init(struct net_bridge_port *port, 2073 struct net_bridge_vlan *vlan, 2074 struct net_bridge_mcast_port *pmctx) 2075 { 2076 pmctx->port = port; 2077 pmctx->vlan = vlan; 2078 pmctx->multicast_router = MDB_RTR_TYPE_TEMP_QUERY; 2079 2080 skb_queue_head_init(&pmctx->query_queue); 2081 INIT_WORK(&pmctx->query_queue_work, br_multicast_port_query_queue_work); 2082 2083 timer_setup(&pmctx->ip4_mc_router_timer, 2084 br_ip4_multicast_router_expired, 0); 2085 timer_setup(&pmctx->ip4_own_query.timer, 2086 br_ip4_multicast_port_query_expired, 0); 2087 #if IS_ENABLED(CONFIG_IPV6) 2088 timer_setup(&pmctx->ip6_mc_router_timer, 2089 br_ip6_multicast_router_expired, 0); 2090 timer_setup(&pmctx->ip6_own_query.timer, 2091 br_ip6_multicast_port_query_expired, 0); 2092 #endif 2093 /* initialize mdb_n_entries if a new port vlan is being created */ 2094 if (vlan) { 2095 struct net_bridge_port_group *pg; 2096 u32 n = 0; 2097 2098 spin_lock_bh(&port->br->multicast_lock); 2099 hlist_for_each_entry(pg, &port->mglist, mglist) 2100 if (pg->key.addr.vid == vlan->vid) 2101 n++; 2102 WRITE_ONCE(pmctx->mdb_n_entries, n); 2103 spin_unlock_bh(&port->br->multicast_lock); 2104 } 2105 } 2106 2107 void br_multicast_port_ctx_deinit(struct net_bridge_mcast_port *pmctx) 2108 { 2109 struct net_bridge *br = pmctx->port->br; 2110 bool del = false; 2111 2112 #if IS_ENABLED(CONFIG_IPV6) 2113 timer_shutdown_sync(&pmctx->ip6_own_query.timer); 2114 timer_shutdown_sync(&pmctx->ip6_mc_router_timer); 2115 #endif 2116 timer_shutdown_sync(&pmctx->ip4_own_query.timer); 2117 timer_shutdown_sync(&pmctx->ip4_mc_router_timer); 2118 2119 spin_lock_bh(&br->multicast_lock); 2120 del |= br_ip6_multicast_rport_del(pmctx); 2121 del |= br_ip4_multicast_rport_del(pmctx); 2122 br_multicast_rport_del_notify(pmctx, del); 2123 spin_unlock_bh(&br->multicast_lock); 2124 cancel_work_sync(&pmctx->query_queue_work); 2125 __skb_queue_purge(&pmctx->query_queue); 2126 } 2127 2128 int br_multicast_add_port(struct net_bridge_port *port) 2129 { 2130 int err; 2131 2132 port->multicast_eht_hosts_limit = BR_MCAST_DEFAULT_EHT_HOSTS_LIMIT; 2133 br_multicast_port_ctx_init(port, NULL, &port->multicast_ctx); 2134 2135 err = br_mc_disabled_update(port->dev, 2136 br_opt_get(port->br, 2137 BROPT_MULTICAST_ENABLED), 2138 NULL); 2139 if (err && err != -EOPNOTSUPP) 2140 return err; 2141 2142 port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats); 2143 if (!port->mcast_stats) 2144 return -ENOMEM; 2145 2146 return 0; 2147 } 2148 2149 void br_multicast_del_port(struct net_bridge_port *port) 2150 { 2151 struct net_bridge *br = port->br; 2152 struct net_bridge_port_group *pg; 2153 struct hlist_node *n; 2154 2155 /* Take care of the remaining groups, only perm ones should be left */ 2156 spin_lock_bh(&br->multicast_lock); 2157 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist) 2158 br_multicast_find_del_pg(br, pg); 2159 spin_unlock_bh(&br->multicast_lock); 2160 flush_work(&br->mcast_gc_work); 2161 br_multicast_port_ctx_deinit(&port->multicast_ctx); 2162 free_percpu(port->mcast_stats); 2163 } 2164 2165 static void br_multicast_enable(struct bridge_mcast_own_query *query) 2166 { 2167 query->startup_sent = 0; 2168 2169 if (timer_delete_sync_try(&query->timer) >= 0 || 2170 timer_delete(&query->timer)) 2171 mod_timer(&query->timer, jiffies); 2172 } 2173 2174 static void __br_multicast_enable_port_ctx(struct net_bridge_mcast_port *pmctx) 2175 { 2176 struct net_bridge *br = pmctx->port->br; 2177 struct net_bridge_mcast *brmctx; 2178 2179 brmctx = br_multicast_port_ctx_get_global(pmctx); 2180 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || 2181 !netif_running(br->dev)) 2182 return; 2183 2184 br_multicast_enable(&pmctx->ip4_own_query); 2185 #if IS_ENABLED(CONFIG_IPV6) 2186 br_multicast_enable(&pmctx->ip6_own_query); 2187 #endif 2188 if (pmctx->multicast_router == MDB_RTR_TYPE_PERM) { 2189 br_ip4_multicast_add_router(brmctx, pmctx); 2190 br_ip6_multicast_add_router(brmctx, pmctx); 2191 } 2192 } 2193 2194 static void br_multicast_enable_port_ctx(struct net_bridge_mcast_port *pmctx) 2195 { 2196 struct net_bridge *br = pmctx->port->br; 2197 2198 spin_lock_bh(&br->multicast_lock); 2199 if (br_multicast_port_ctx_is_vlan(pmctx) && 2200 !(pmctx->vlan->priv_flags & BR_VLFLAG_MCAST_ENABLED)) { 2201 spin_unlock_bh(&br->multicast_lock); 2202 return; 2203 } 2204 __br_multicast_enable_port_ctx(pmctx); 2205 spin_unlock_bh(&br->multicast_lock); 2206 } 2207 2208 static void __br_multicast_disable_port_ctx(struct net_bridge_mcast_port *pmctx) 2209 { 2210 struct net_bridge_port_group *pg; 2211 struct hlist_node *n; 2212 bool del = false; 2213 2214 hlist_for_each_entry_safe(pg, n, &pmctx->port->mglist, mglist) 2215 if (!(pg->flags & MDB_PG_FLAGS_PERMANENT) && 2216 (!br_multicast_port_ctx_is_vlan(pmctx) || 2217 pg->key.addr.vid == pmctx->vlan->vid)) 2218 br_multicast_find_del_pg(pmctx->port->br, pg); 2219 2220 del |= br_ip4_multicast_rport_del(pmctx); 2221 timer_delete(&pmctx->ip4_mc_router_timer); 2222 timer_delete(&pmctx->ip4_own_query.timer); 2223 del |= br_ip6_multicast_rport_del(pmctx); 2224 #if IS_ENABLED(CONFIG_IPV6) 2225 timer_delete(&pmctx->ip6_mc_router_timer); 2226 timer_delete(&pmctx->ip6_own_query.timer); 2227 #endif 2228 br_multicast_rport_del_notify(pmctx, del); 2229 } 2230 2231 static void br_multicast_disable_port_ctx(struct net_bridge_mcast_port *pmctx) 2232 { 2233 struct net_bridge *br = pmctx->port->br; 2234 2235 spin_lock_bh(&br->multicast_lock); 2236 if (br_multicast_port_ctx_is_vlan(pmctx) && 2237 !(pmctx->vlan->priv_flags & BR_VLFLAG_MCAST_ENABLED)) { 2238 spin_unlock_bh(&br->multicast_lock); 2239 return; 2240 } 2241 2242 __br_multicast_disable_port_ctx(pmctx); 2243 spin_unlock_bh(&br->multicast_lock); 2244 } 2245 2246 static void br_multicast_toggle_port(struct net_bridge_port *port, bool on) 2247 { 2248 #if IS_ENABLED(CONFIG_BRIDGE_VLAN_FILTERING) 2249 if (br_opt_get(port->br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) { 2250 struct net_bridge_vlan_group *vg; 2251 struct net_bridge_vlan *vlan; 2252 2253 rcu_read_lock(); 2254 vg = nbp_vlan_group_rcu(port); 2255 if (!vg) { 2256 rcu_read_unlock(); 2257 return; 2258 } 2259 2260 /* iterate each vlan, toggle vlan multicast context */ 2261 list_for_each_entry_rcu(vlan, &vg->vlan_list, vlist) { 2262 struct net_bridge_mcast_port *pmctx = 2263 &vlan->port_mcast_ctx; 2264 u8 state = br_vlan_get_state(vlan); 2265 /* enable vlan multicast context when state is 2266 * LEARNING or FORWARDING 2267 */ 2268 if (on && br_vlan_state_allowed(state, true)) 2269 br_multicast_enable_port_ctx(pmctx); 2270 else 2271 br_multicast_disable_port_ctx(pmctx); 2272 } 2273 rcu_read_unlock(); 2274 return; 2275 } 2276 #endif 2277 /* toggle port multicast context when vlan snooping is disabled */ 2278 if (on) 2279 br_multicast_enable_port_ctx(&port->multicast_ctx); 2280 else 2281 br_multicast_disable_port_ctx(&port->multicast_ctx); 2282 } 2283 2284 void br_multicast_enable_port(struct net_bridge_port *port) 2285 { 2286 br_multicast_toggle_port(port, true); 2287 } 2288 2289 void br_multicast_disable_port(struct net_bridge_port *port) 2290 { 2291 br_multicast_toggle_port(port, false); 2292 } 2293 2294 static int __grp_src_delete_marked(struct net_bridge_port_group *pg) 2295 { 2296 struct net_bridge_group_src *ent; 2297 struct hlist_node *tmp; 2298 int deleted = 0; 2299 2300 hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node) 2301 if (ent->flags & BR_SGRP_F_DELETE) { 2302 br_multicast_del_group_src(ent, false); 2303 deleted++; 2304 } 2305 2306 return deleted; 2307 } 2308 2309 static void __grp_src_mod_timer(struct net_bridge_group_src *src, 2310 unsigned long expires) 2311 { 2312 mod_timer(&src->timer, expires); 2313 br_multicast_fwd_src_handle(src); 2314 } 2315 2316 static void __grp_src_query_marked_and_rexmit(struct net_bridge_mcast *brmctx, 2317 struct net_bridge_mcast_port *pmctx, 2318 struct net_bridge_port_group *pg) 2319 { 2320 struct bridge_mcast_other_query *other_query = NULL; 2321 u32 lmqc = brmctx->multicast_last_member_count; 2322 unsigned long lmqt, lmi, now = jiffies; 2323 struct net_bridge_group_src *ent; 2324 2325 if (!netif_running(brmctx->br->dev) || 2326 !br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED)) 2327 return; 2328 2329 if (pg->key.addr.proto == htons(ETH_P_IP)) 2330 other_query = &brmctx->ip4_other_query; 2331 #if IS_ENABLED(CONFIG_IPV6) 2332 else 2333 other_query = &brmctx->ip6_other_query; 2334 #endif 2335 2336 lmqt = now + br_multicast_lmqt(brmctx); 2337 hlist_for_each_entry(ent, &pg->src_list, node) { 2338 if (ent->flags & BR_SGRP_F_SEND) { 2339 ent->flags &= ~BR_SGRP_F_SEND; 2340 if (ent->timer.expires > lmqt) { 2341 if (brmctx->multicast_querier && 2342 other_query && 2343 !timer_pending(&other_query->timer)) 2344 ent->src_query_rexmit_cnt = lmqc; 2345 __grp_src_mod_timer(ent, lmqt); 2346 } 2347 } 2348 } 2349 2350 if (!brmctx->multicast_querier || 2351 !other_query || timer_pending(&other_query->timer)) 2352 return; 2353 2354 __br_multicast_send_query(brmctx, pmctx, pg, &pg->key.addr, 2355 &pg->key.addr, true, 1, NULL); 2356 2357 lmi = now + brmctx->multicast_last_member_interval; 2358 if (!timer_pending(&pg->rexmit_timer) || 2359 time_after(pg->rexmit_timer.expires, lmi)) 2360 mod_timer(&pg->rexmit_timer, lmi); 2361 } 2362 2363 static void __grp_send_query_and_rexmit(struct net_bridge_mcast *brmctx, 2364 struct net_bridge_mcast_port *pmctx, 2365 struct net_bridge_port_group *pg) 2366 { 2367 struct bridge_mcast_other_query *other_query = NULL; 2368 unsigned long now = jiffies, lmi; 2369 2370 if (!netif_running(brmctx->br->dev) || 2371 !br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED)) 2372 return; 2373 2374 if (pg->key.addr.proto == htons(ETH_P_IP)) 2375 other_query = &brmctx->ip4_other_query; 2376 #if IS_ENABLED(CONFIG_IPV6) 2377 else 2378 other_query = &brmctx->ip6_other_query; 2379 #endif 2380 2381 if (brmctx->multicast_querier && 2382 other_query && !timer_pending(&other_query->timer)) { 2383 lmi = now + brmctx->multicast_last_member_interval; 2384 pg->grp_query_rexmit_cnt = brmctx->multicast_last_member_count - 1; 2385 __br_multicast_send_query(brmctx, pmctx, pg, &pg->key.addr, 2386 &pg->key.addr, false, 0, NULL); 2387 if (!timer_pending(&pg->rexmit_timer) || 2388 time_after(pg->rexmit_timer.expires, lmi)) 2389 mod_timer(&pg->rexmit_timer, lmi); 2390 } 2391 2392 if (pg->filter_mode == MCAST_EXCLUDE && 2393 (!timer_pending(&pg->timer) || 2394 time_after(pg->timer.expires, now + br_multicast_lmqt(brmctx)))) 2395 mod_timer(&pg->timer, now + br_multicast_lmqt(brmctx)); 2396 } 2397 2398 /* State Msg type New state Actions 2399 * INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI 2400 * INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI 2401 * EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI 2402 */ 2403 static bool br_multicast_isinc_allow(const struct net_bridge_mcast *brmctx, 2404 struct net_bridge_port_group *pg, void *h_addr, 2405 void *srcs, u32 nsrcs, size_t addr_size, 2406 int grec_type) 2407 { 2408 struct net_bridge_group_src *ent; 2409 unsigned long now = jiffies; 2410 bool changed = false; 2411 struct br_ip src_ip; 2412 u32 src_idx; 2413 2414 memset(&src_ip, 0, sizeof(src_ip)); 2415 src_ip.proto = pg->key.addr.proto; 2416 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2417 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2418 ent = br_multicast_find_group_src(pg, &src_ip); 2419 if (!ent) { 2420 ent = br_multicast_new_group_src(pg, &src_ip); 2421 if (ent) 2422 changed = true; 2423 } 2424 2425 if (ent) 2426 __grp_src_mod_timer(ent, now + br_multicast_gmi(brmctx)); 2427 } 2428 2429 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2430 grec_type)) 2431 changed = true; 2432 2433 return changed; 2434 } 2435 2436 /* State Msg type New state Actions 2437 * INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0 2438 * Delete (A-B) 2439 * Group Timer=GMI 2440 */ 2441 static void __grp_src_isexc_incl(const struct net_bridge_mcast *brmctx, 2442 struct net_bridge_port_group *pg, void *h_addr, 2443 void *srcs, u32 nsrcs, size_t addr_size, 2444 int grec_type) 2445 { 2446 struct net_bridge_group_src *ent; 2447 struct br_ip src_ip; 2448 u32 src_idx; 2449 2450 hlist_for_each_entry(ent, &pg->src_list, node) 2451 ent->flags |= BR_SGRP_F_DELETE; 2452 2453 memset(&src_ip, 0, sizeof(src_ip)); 2454 src_ip.proto = pg->key.addr.proto; 2455 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2456 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2457 ent = br_multicast_find_group_src(pg, &src_ip); 2458 if (ent) 2459 ent->flags &= ~BR_SGRP_F_DELETE; 2460 else 2461 ent = br_multicast_new_group_src(pg, &src_ip); 2462 if (ent) 2463 br_multicast_fwd_src_handle(ent); 2464 } 2465 2466 br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2467 grec_type); 2468 2469 __grp_src_delete_marked(pg); 2470 } 2471 2472 /* State Msg type New state Actions 2473 * EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI 2474 * Delete (X-A) 2475 * Delete (Y-A) 2476 * Group Timer=GMI 2477 */ 2478 static bool __grp_src_isexc_excl(const struct net_bridge_mcast *brmctx, 2479 struct net_bridge_port_group *pg, void *h_addr, 2480 void *srcs, u32 nsrcs, size_t addr_size, 2481 int grec_type) 2482 { 2483 struct net_bridge_group_src *ent; 2484 unsigned long now = jiffies; 2485 bool changed = false; 2486 struct br_ip src_ip; 2487 u32 src_idx; 2488 2489 hlist_for_each_entry(ent, &pg->src_list, node) 2490 ent->flags |= BR_SGRP_F_DELETE; 2491 2492 memset(&src_ip, 0, sizeof(src_ip)); 2493 src_ip.proto = pg->key.addr.proto; 2494 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2495 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2496 ent = br_multicast_find_group_src(pg, &src_ip); 2497 if (ent) { 2498 ent->flags &= ~BR_SGRP_F_DELETE; 2499 } else { 2500 ent = br_multicast_new_group_src(pg, &src_ip); 2501 if (ent) { 2502 __grp_src_mod_timer(ent, 2503 now + br_multicast_gmi(brmctx)); 2504 changed = true; 2505 } 2506 } 2507 } 2508 2509 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2510 grec_type)) 2511 changed = true; 2512 2513 if (__grp_src_delete_marked(pg)) 2514 changed = true; 2515 2516 return changed; 2517 } 2518 2519 static bool br_multicast_isexc(const struct net_bridge_mcast *brmctx, 2520 struct net_bridge_port_group *pg, void *h_addr, 2521 void *srcs, u32 nsrcs, size_t addr_size, 2522 int grec_type) 2523 { 2524 bool changed = false; 2525 2526 switch (pg->filter_mode) { 2527 case MCAST_INCLUDE: 2528 __grp_src_isexc_incl(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2529 grec_type); 2530 br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE); 2531 changed = true; 2532 break; 2533 case MCAST_EXCLUDE: 2534 changed = __grp_src_isexc_excl(brmctx, pg, h_addr, srcs, nsrcs, 2535 addr_size, grec_type); 2536 break; 2537 } 2538 2539 pg->filter_mode = MCAST_EXCLUDE; 2540 mod_timer(&pg->timer, jiffies + br_multicast_gmi(brmctx)); 2541 2542 return changed; 2543 } 2544 2545 /* State Msg type New state Actions 2546 * INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI 2547 * Send Q(G,A-B) 2548 */ 2549 static bool __grp_src_toin_incl(struct net_bridge_mcast *brmctx, 2550 struct net_bridge_mcast_port *pmctx, 2551 struct net_bridge_port_group *pg, void *h_addr, 2552 void *srcs, u32 nsrcs, size_t addr_size, 2553 int grec_type) 2554 { 2555 u32 src_idx, to_send = pg->src_ents; 2556 struct net_bridge_group_src *ent; 2557 unsigned long now = jiffies; 2558 bool changed = false; 2559 struct br_ip src_ip; 2560 2561 hlist_for_each_entry(ent, &pg->src_list, node) 2562 ent->flags |= BR_SGRP_F_SEND; 2563 2564 memset(&src_ip, 0, sizeof(src_ip)); 2565 src_ip.proto = pg->key.addr.proto; 2566 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2567 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2568 ent = br_multicast_find_group_src(pg, &src_ip); 2569 if (ent) { 2570 ent->flags &= ~BR_SGRP_F_SEND; 2571 to_send--; 2572 } else { 2573 ent = br_multicast_new_group_src(pg, &src_ip); 2574 if (ent) 2575 changed = true; 2576 } 2577 if (ent) 2578 __grp_src_mod_timer(ent, now + br_multicast_gmi(brmctx)); 2579 } 2580 2581 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2582 grec_type)) 2583 changed = true; 2584 2585 if (to_send) 2586 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg); 2587 2588 return changed; 2589 } 2590 2591 /* State Msg type New state Actions 2592 * EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI 2593 * Send Q(G,X-A) 2594 * Send Q(G) 2595 */ 2596 static bool __grp_src_toin_excl(struct net_bridge_mcast *brmctx, 2597 struct net_bridge_mcast_port *pmctx, 2598 struct net_bridge_port_group *pg, void *h_addr, 2599 void *srcs, u32 nsrcs, size_t addr_size, 2600 int grec_type) 2601 { 2602 u32 src_idx, to_send = pg->src_ents; 2603 struct net_bridge_group_src *ent; 2604 unsigned long now = jiffies; 2605 bool changed = false; 2606 struct br_ip src_ip; 2607 2608 hlist_for_each_entry(ent, &pg->src_list, node) 2609 if (timer_pending(&ent->timer)) 2610 ent->flags |= BR_SGRP_F_SEND; 2611 2612 memset(&src_ip, 0, sizeof(src_ip)); 2613 src_ip.proto = pg->key.addr.proto; 2614 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2615 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2616 ent = br_multicast_find_group_src(pg, &src_ip); 2617 if (ent) { 2618 if (timer_pending(&ent->timer)) { 2619 ent->flags &= ~BR_SGRP_F_SEND; 2620 to_send--; 2621 } 2622 } else { 2623 ent = br_multicast_new_group_src(pg, &src_ip); 2624 if (ent) 2625 changed = true; 2626 } 2627 if (ent) 2628 __grp_src_mod_timer(ent, now + br_multicast_gmi(brmctx)); 2629 } 2630 2631 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2632 grec_type)) 2633 changed = true; 2634 2635 if (to_send) 2636 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg); 2637 2638 __grp_send_query_and_rexmit(brmctx, pmctx, pg); 2639 2640 return changed; 2641 } 2642 2643 static bool br_multicast_toin(struct net_bridge_mcast *brmctx, 2644 struct net_bridge_mcast_port *pmctx, 2645 struct net_bridge_port_group *pg, void *h_addr, 2646 void *srcs, u32 nsrcs, size_t addr_size, 2647 int grec_type) 2648 { 2649 bool changed = false; 2650 2651 switch (pg->filter_mode) { 2652 case MCAST_INCLUDE: 2653 changed = __grp_src_toin_incl(brmctx, pmctx, pg, h_addr, srcs, 2654 nsrcs, addr_size, grec_type); 2655 break; 2656 case MCAST_EXCLUDE: 2657 changed = __grp_src_toin_excl(brmctx, pmctx, pg, h_addr, srcs, 2658 nsrcs, addr_size, grec_type); 2659 break; 2660 } 2661 2662 if (br_multicast_eht_should_del_pg(pg)) { 2663 pg->flags |= MDB_PG_FLAGS_FAST_LEAVE; 2664 br_multicast_find_del_pg(pg->key.port->br, pg); 2665 /* a notification has already been sent and we shouldn't 2666 * access pg after the delete so we have to return false 2667 */ 2668 changed = false; 2669 } 2670 2671 return changed; 2672 } 2673 2674 /* State Msg type New state Actions 2675 * INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0 2676 * Delete (A-B) 2677 * Send Q(G,A*B) 2678 * Group Timer=GMI 2679 */ 2680 static void __grp_src_toex_incl(struct net_bridge_mcast *brmctx, 2681 struct net_bridge_mcast_port *pmctx, 2682 struct net_bridge_port_group *pg, void *h_addr, 2683 void *srcs, u32 nsrcs, size_t addr_size, 2684 int grec_type) 2685 { 2686 struct net_bridge_group_src *ent; 2687 u32 src_idx, to_send = 0; 2688 struct br_ip src_ip; 2689 2690 hlist_for_each_entry(ent, &pg->src_list, node) 2691 ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE; 2692 2693 memset(&src_ip, 0, sizeof(src_ip)); 2694 src_ip.proto = pg->key.addr.proto; 2695 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2696 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2697 ent = br_multicast_find_group_src(pg, &src_ip); 2698 if (ent) { 2699 ent->flags = (ent->flags & ~BR_SGRP_F_DELETE) | 2700 BR_SGRP_F_SEND; 2701 to_send++; 2702 } else { 2703 ent = br_multicast_new_group_src(pg, &src_ip); 2704 } 2705 if (ent) 2706 br_multicast_fwd_src_handle(ent); 2707 } 2708 2709 br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2710 grec_type); 2711 2712 __grp_src_delete_marked(pg); 2713 if (to_send) 2714 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg); 2715 } 2716 2717 /* State Msg type New state Actions 2718 * EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer 2719 * Delete (X-A) 2720 * Delete (Y-A) 2721 * Send Q(G,A-Y) 2722 * Group Timer=GMI 2723 */ 2724 static bool __grp_src_toex_excl(struct net_bridge_mcast *brmctx, 2725 struct net_bridge_mcast_port *pmctx, 2726 struct net_bridge_port_group *pg, void *h_addr, 2727 void *srcs, u32 nsrcs, size_t addr_size, 2728 int grec_type) 2729 { 2730 struct net_bridge_group_src *ent; 2731 u32 src_idx, to_send = 0; 2732 bool changed = false; 2733 struct br_ip src_ip; 2734 2735 hlist_for_each_entry(ent, &pg->src_list, node) 2736 ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE; 2737 2738 memset(&src_ip, 0, sizeof(src_ip)); 2739 src_ip.proto = pg->key.addr.proto; 2740 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2741 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2742 ent = br_multicast_find_group_src(pg, &src_ip); 2743 if (ent) { 2744 ent->flags &= ~BR_SGRP_F_DELETE; 2745 } else { 2746 ent = br_multicast_new_group_src(pg, &src_ip); 2747 if (ent) { 2748 __grp_src_mod_timer(ent, pg->timer.expires); 2749 changed = true; 2750 } 2751 } 2752 if (ent && timer_pending(&ent->timer)) { 2753 ent->flags |= BR_SGRP_F_SEND; 2754 to_send++; 2755 } 2756 } 2757 2758 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2759 grec_type)) 2760 changed = true; 2761 2762 if (__grp_src_delete_marked(pg)) 2763 changed = true; 2764 if (to_send) 2765 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg); 2766 2767 return changed; 2768 } 2769 2770 static bool br_multicast_toex(struct net_bridge_mcast *brmctx, 2771 struct net_bridge_mcast_port *pmctx, 2772 struct net_bridge_port_group *pg, void *h_addr, 2773 void *srcs, u32 nsrcs, size_t addr_size, 2774 int grec_type) 2775 { 2776 bool changed = false; 2777 2778 switch (pg->filter_mode) { 2779 case MCAST_INCLUDE: 2780 __grp_src_toex_incl(brmctx, pmctx, pg, h_addr, srcs, nsrcs, 2781 addr_size, grec_type); 2782 br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE); 2783 changed = true; 2784 break; 2785 case MCAST_EXCLUDE: 2786 changed = __grp_src_toex_excl(brmctx, pmctx, pg, h_addr, srcs, 2787 nsrcs, addr_size, grec_type); 2788 break; 2789 } 2790 2791 pg->filter_mode = MCAST_EXCLUDE; 2792 mod_timer(&pg->timer, jiffies + br_multicast_gmi(brmctx)); 2793 2794 return changed; 2795 } 2796 2797 /* State Msg type New state Actions 2798 * INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B) 2799 */ 2800 static bool __grp_src_block_incl(struct net_bridge_mcast *brmctx, 2801 struct net_bridge_mcast_port *pmctx, 2802 struct net_bridge_port_group *pg, void *h_addr, 2803 void *srcs, u32 nsrcs, size_t addr_size, int grec_type) 2804 { 2805 struct net_bridge_group_src *ent; 2806 u32 src_idx, to_send = 0; 2807 bool changed = false; 2808 struct br_ip src_ip; 2809 2810 hlist_for_each_entry(ent, &pg->src_list, node) 2811 ent->flags &= ~BR_SGRP_F_SEND; 2812 2813 memset(&src_ip, 0, sizeof(src_ip)); 2814 src_ip.proto = pg->key.addr.proto; 2815 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2816 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2817 ent = br_multicast_find_group_src(pg, &src_ip); 2818 if (ent) { 2819 ent->flags |= BR_SGRP_F_SEND; 2820 to_send++; 2821 } 2822 } 2823 2824 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2825 grec_type)) 2826 changed = true; 2827 2828 if (to_send) 2829 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg); 2830 2831 return changed; 2832 } 2833 2834 /* State Msg type New state Actions 2835 * EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer 2836 * Send Q(G,A-Y) 2837 */ 2838 static bool __grp_src_block_excl(struct net_bridge_mcast *brmctx, 2839 struct net_bridge_mcast_port *pmctx, 2840 struct net_bridge_port_group *pg, void *h_addr, 2841 void *srcs, u32 nsrcs, size_t addr_size, int grec_type) 2842 { 2843 struct net_bridge_group_src *ent; 2844 u32 src_idx, to_send = 0; 2845 bool changed = false; 2846 struct br_ip src_ip; 2847 2848 hlist_for_each_entry(ent, &pg->src_list, node) 2849 ent->flags &= ~BR_SGRP_F_SEND; 2850 2851 memset(&src_ip, 0, sizeof(src_ip)); 2852 src_ip.proto = pg->key.addr.proto; 2853 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 2854 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size); 2855 ent = br_multicast_find_group_src(pg, &src_ip); 2856 if (!ent) { 2857 ent = br_multicast_new_group_src(pg, &src_ip); 2858 if (ent) { 2859 __grp_src_mod_timer(ent, pg->timer.expires); 2860 changed = true; 2861 } 2862 } 2863 if (ent && timer_pending(&ent->timer)) { 2864 ent->flags |= BR_SGRP_F_SEND; 2865 to_send++; 2866 } 2867 } 2868 2869 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 2870 grec_type)) 2871 changed = true; 2872 2873 if (to_send) 2874 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg); 2875 2876 return changed; 2877 } 2878 2879 static bool br_multicast_block(struct net_bridge_mcast *brmctx, 2880 struct net_bridge_mcast_port *pmctx, 2881 struct net_bridge_port_group *pg, void *h_addr, 2882 void *srcs, u32 nsrcs, size_t addr_size, int grec_type) 2883 { 2884 bool changed = false; 2885 2886 switch (pg->filter_mode) { 2887 case MCAST_INCLUDE: 2888 changed = __grp_src_block_incl(brmctx, pmctx, pg, h_addr, srcs, 2889 nsrcs, addr_size, grec_type); 2890 break; 2891 case MCAST_EXCLUDE: 2892 changed = __grp_src_block_excl(brmctx, pmctx, pg, h_addr, srcs, 2893 nsrcs, addr_size, grec_type); 2894 break; 2895 } 2896 2897 if ((pg->filter_mode == MCAST_INCLUDE && hlist_empty(&pg->src_list)) || 2898 br_multicast_eht_should_del_pg(pg)) { 2899 if (br_multicast_eht_should_del_pg(pg)) 2900 pg->flags |= MDB_PG_FLAGS_FAST_LEAVE; 2901 br_multicast_find_del_pg(pg->key.port->br, pg); 2902 /* a notification has already been sent and we shouldn't 2903 * access pg after the delete so we have to return false 2904 */ 2905 changed = false; 2906 } 2907 2908 return changed; 2909 } 2910 2911 static struct net_bridge_port_group * 2912 br_multicast_find_port(struct net_bridge_mdb_entry *mp, 2913 struct net_bridge_port *p, 2914 const unsigned char *src) 2915 { 2916 struct net_bridge *br __maybe_unused = mp->br; 2917 struct net_bridge_port_group *pg; 2918 2919 for (pg = mlock_dereference(mp->ports, br); 2920 pg; 2921 pg = mlock_dereference(pg->next, br)) 2922 if (br_port_group_equal(pg, p, src)) 2923 return pg; 2924 2925 return NULL; 2926 } 2927 2928 static int br_ip4_multicast_igmp3_report(struct net_bridge_mcast *brmctx, 2929 struct net_bridge_mcast_port *pmctx, 2930 struct sk_buff *skb, 2931 u16 vid) 2932 { 2933 bool igmpv2 = brmctx->multicast_igmp_version == 2; 2934 struct net_bridge_mdb_entry *mdst; 2935 struct net_bridge_port_group *pg; 2936 const unsigned char *src; 2937 struct igmpv3_report *ih; 2938 struct igmpv3_grec *grec; 2939 int i, len, num, type; 2940 __be32 group, *h_addr; 2941 bool changed = false; 2942 int err = 0; 2943 u16 nsrcs; 2944 2945 ih = igmpv3_report_hdr(skb); 2946 num = ntohs(ih->ngrec); 2947 len = skb_transport_offset(skb) + sizeof(*ih); 2948 2949 for (i = 0; i < num; i++) { 2950 len += sizeof(*grec); 2951 if (!ip_mc_may_pull(skb, len)) 2952 return -EINVAL; 2953 2954 grec = (void *)(skb->data + len - sizeof(*grec)); 2955 group = grec->grec_mca; 2956 type = grec->grec_type; 2957 nsrcs = ntohs(grec->grec_nsrcs); 2958 2959 len += nsrcs * 4; 2960 if (!ip_mc_may_pull(skb, len)) 2961 return -EINVAL; 2962 2963 switch (type) { 2964 case IGMPV3_MODE_IS_INCLUDE: 2965 case IGMPV3_MODE_IS_EXCLUDE: 2966 case IGMPV3_CHANGE_TO_INCLUDE: 2967 case IGMPV3_CHANGE_TO_EXCLUDE: 2968 case IGMPV3_ALLOW_NEW_SOURCES: 2969 case IGMPV3_BLOCK_OLD_SOURCES: 2970 break; 2971 2972 default: 2973 continue; 2974 } 2975 2976 src = eth_hdr(skb)->h_source; 2977 if (nsrcs == 0 && 2978 (type == IGMPV3_CHANGE_TO_INCLUDE || 2979 type == IGMPV3_MODE_IS_INCLUDE)) { 2980 if (!pmctx || igmpv2) { 2981 br_ip4_multicast_leave_group(brmctx, pmctx, 2982 group, vid, src); 2983 continue; 2984 } 2985 } else { 2986 err = br_ip4_multicast_add_group(brmctx, pmctx, group, 2987 vid, src, igmpv2); 2988 if (err) 2989 break; 2990 } 2991 2992 if (!pmctx || igmpv2) 2993 continue; 2994 2995 spin_lock(&brmctx->br->multicast_lock); 2996 if (!br_multicast_ctx_should_use(brmctx, pmctx)) 2997 goto unlock_continue; 2998 2999 mdst = br_mdb_ip4_get(brmctx->br, group, vid); 3000 if (!mdst) 3001 goto unlock_continue; 3002 pg = br_multicast_find_port(mdst, pmctx->port, src); 3003 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT)) 3004 goto unlock_continue; 3005 /* reload grec and host addr */ 3006 grec = (void *)(skb->data + len - sizeof(*grec) - (nsrcs * 4)); 3007 h_addr = &ip_hdr(skb)->saddr; 3008 switch (type) { 3009 case IGMPV3_ALLOW_NEW_SOURCES: 3010 changed = br_multicast_isinc_allow(brmctx, pg, h_addr, 3011 grec->grec_src, 3012 nsrcs, sizeof(__be32), type); 3013 break; 3014 case IGMPV3_MODE_IS_INCLUDE: 3015 changed = br_multicast_isinc_allow(brmctx, pg, h_addr, 3016 grec->grec_src, 3017 nsrcs, sizeof(__be32), type); 3018 break; 3019 case IGMPV3_MODE_IS_EXCLUDE: 3020 changed = br_multicast_isexc(brmctx, pg, h_addr, 3021 grec->grec_src, 3022 nsrcs, sizeof(__be32), type); 3023 break; 3024 case IGMPV3_CHANGE_TO_INCLUDE: 3025 changed = br_multicast_toin(brmctx, pmctx, pg, h_addr, 3026 grec->grec_src, 3027 nsrcs, sizeof(__be32), type); 3028 break; 3029 case IGMPV3_CHANGE_TO_EXCLUDE: 3030 changed = br_multicast_toex(brmctx, pmctx, pg, h_addr, 3031 grec->grec_src, 3032 nsrcs, sizeof(__be32), type); 3033 break; 3034 case IGMPV3_BLOCK_OLD_SOURCES: 3035 changed = br_multicast_block(brmctx, pmctx, pg, h_addr, 3036 grec->grec_src, 3037 nsrcs, sizeof(__be32), type); 3038 break; 3039 } 3040 if (changed) 3041 br_mdb_notify(brmctx->br->dev, mdst, pg, RTM_NEWMDB); 3042 unlock_continue: 3043 spin_unlock(&brmctx->br->multicast_lock); 3044 } 3045 3046 return err; 3047 } 3048 3049 #if IS_ENABLED(CONFIG_IPV6) 3050 static int br_ip6_multicast_mld2_report(struct net_bridge_mcast *brmctx, 3051 struct net_bridge_mcast_port *pmctx, 3052 struct sk_buff *skb, 3053 u16 vid) 3054 { 3055 bool mldv1 = brmctx->multicast_mld_version == 1; 3056 struct net_bridge_mdb_entry *mdst; 3057 struct net_bridge_port_group *pg; 3058 unsigned int nsrcs_offset; 3059 struct mld2_report *mld2r; 3060 const unsigned char *src; 3061 struct in6_addr *h_addr; 3062 struct mld2_grec *grec; 3063 unsigned int grec_len; 3064 bool changed = false; 3065 int i, len, num; 3066 int err = 0; 3067 3068 if (!ipv6_mc_may_pull(skb, sizeof(*mld2r))) 3069 return -EINVAL; 3070 3071 mld2r = (struct mld2_report *)icmp6_hdr(skb); 3072 num = ntohs(mld2r->mld2r_ngrec); 3073 len = skb_transport_offset(skb) + sizeof(*mld2r); 3074 3075 for (i = 0; i < num; i++) { 3076 __be16 *_nsrcs, __nsrcs; 3077 u16 nsrcs; 3078 3079 nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs); 3080 3081 if (skb_transport_offset(skb) + ipv6_transport_len(skb) < 3082 nsrcs_offset + sizeof(__nsrcs)) 3083 return -EINVAL; 3084 3085 _nsrcs = skb_header_pointer(skb, nsrcs_offset, 3086 sizeof(__nsrcs), &__nsrcs); 3087 if (!_nsrcs) 3088 return -EINVAL; 3089 3090 nsrcs = ntohs(*_nsrcs); 3091 grec_len = struct_size(grec, grec_src, nsrcs); 3092 3093 if (!ipv6_mc_may_pull(skb, len + grec_len)) 3094 return -EINVAL; 3095 3096 grec = (struct mld2_grec *)(skb->data + len); 3097 len += grec_len; 3098 3099 switch (grec->grec_type) { 3100 case MLD2_MODE_IS_INCLUDE: 3101 case MLD2_MODE_IS_EXCLUDE: 3102 case MLD2_CHANGE_TO_INCLUDE: 3103 case MLD2_CHANGE_TO_EXCLUDE: 3104 case MLD2_ALLOW_NEW_SOURCES: 3105 case MLD2_BLOCK_OLD_SOURCES: 3106 break; 3107 3108 default: 3109 continue; 3110 } 3111 3112 src = eth_hdr(skb)->h_source; 3113 if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE || 3114 grec->grec_type == MLD2_MODE_IS_INCLUDE) && 3115 nsrcs == 0) { 3116 if (!pmctx || mldv1) { 3117 br_ip6_multicast_leave_group(brmctx, pmctx, 3118 &grec->grec_mca, 3119 vid, src); 3120 continue; 3121 } 3122 } else { 3123 err = br_ip6_multicast_add_group(brmctx, pmctx, 3124 &grec->grec_mca, vid, 3125 src, mldv1); 3126 if (err) 3127 break; 3128 } 3129 3130 if (!pmctx || mldv1) 3131 continue; 3132 3133 spin_lock(&brmctx->br->multicast_lock); 3134 if (!br_multicast_ctx_should_use(brmctx, pmctx)) 3135 goto unlock_continue; 3136 3137 mdst = br_mdb_ip6_get(brmctx->br, &grec->grec_mca, vid); 3138 if (!mdst) 3139 goto unlock_continue; 3140 pg = br_multicast_find_port(mdst, pmctx->port, src); 3141 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT)) 3142 goto unlock_continue; 3143 h_addr = &ipv6_hdr(skb)->saddr; 3144 switch (grec->grec_type) { 3145 case MLD2_ALLOW_NEW_SOURCES: 3146 changed = br_multicast_isinc_allow(brmctx, pg, h_addr, 3147 grec->grec_src, nsrcs, 3148 sizeof(struct in6_addr), 3149 grec->grec_type); 3150 break; 3151 case MLD2_MODE_IS_INCLUDE: 3152 changed = br_multicast_isinc_allow(brmctx, pg, h_addr, 3153 grec->grec_src, nsrcs, 3154 sizeof(struct in6_addr), 3155 grec->grec_type); 3156 break; 3157 case MLD2_MODE_IS_EXCLUDE: 3158 changed = br_multicast_isexc(brmctx, pg, h_addr, 3159 grec->grec_src, nsrcs, 3160 sizeof(struct in6_addr), 3161 grec->grec_type); 3162 break; 3163 case MLD2_CHANGE_TO_INCLUDE: 3164 changed = br_multicast_toin(brmctx, pmctx, pg, h_addr, 3165 grec->grec_src, nsrcs, 3166 sizeof(struct in6_addr), 3167 grec->grec_type); 3168 break; 3169 case MLD2_CHANGE_TO_EXCLUDE: 3170 changed = br_multicast_toex(brmctx, pmctx, pg, h_addr, 3171 grec->grec_src, nsrcs, 3172 sizeof(struct in6_addr), 3173 grec->grec_type); 3174 break; 3175 case MLD2_BLOCK_OLD_SOURCES: 3176 changed = br_multicast_block(brmctx, pmctx, pg, h_addr, 3177 grec->grec_src, nsrcs, 3178 sizeof(struct in6_addr), 3179 grec->grec_type); 3180 break; 3181 } 3182 if (changed) 3183 br_mdb_notify(brmctx->br->dev, mdst, pg, RTM_NEWMDB); 3184 unlock_continue: 3185 spin_unlock(&brmctx->br->multicast_lock); 3186 } 3187 3188 return err; 3189 } 3190 #endif 3191 3192 static bool br_multicast_select_querier(struct net_bridge_mcast *brmctx, 3193 struct net_bridge_mcast_port *pmctx, 3194 struct br_ip *saddr) 3195 { 3196 int port_ifidx = pmctx ? pmctx->port->dev->ifindex : 0; 3197 struct timer_list *own_timer, *other_timer; 3198 struct bridge_mcast_querier *querier; 3199 3200 switch (saddr->proto) { 3201 case htons(ETH_P_IP): 3202 querier = &brmctx->ip4_querier; 3203 own_timer = &brmctx->ip4_own_query.timer; 3204 other_timer = &brmctx->ip4_other_query.timer; 3205 if (!querier->addr.src.ip4 || 3206 ntohl(saddr->src.ip4) <= ntohl(querier->addr.src.ip4)) 3207 goto update; 3208 break; 3209 #if IS_ENABLED(CONFIG_IPV6) 3210 case htons(ETH_P_IPV6): 3211 querier = &brmctx->ip6_querier; 3212 own_timer = &brmctx->ip6_own_query.timer; 3213 other_timer = &brmctx->ip6_other_query.timer; 3214 if (ipv6_addr_cmp(&saddr->src.ip6, &querier->addr.src.ip6) <= 0) 3215 goto update; 3216 break; 3217 #endif 3218 default: 3219 return false; 3220 } 3221 3222 if (!timer_pending(own_timer) && !timer_pending(other_timer)) 3223 goto update; 3224 3225 return false; 3226 3227 update: 3228 br_multicast_update_querier(brmctx, querier, port_ifidx, saddr); 3229 3230 return true; 3231 } 3232 3233 static struct net_bridge_port * 3234 __br_multicast_get_querier_port(struct net_bridge *br, 3235 const struct bridge_mcast_querier *querier) 3236 { 3237 int port_ifidx = READ_ONCE(querier->port_ifidx); 3238 struct net_bridge_port *p; 3239 struct net_device *dev; 3240 3241 if (port_ifidx == 0) 3242 return NULL; 3243 3244 dev = dev_get_by_index_rcu(dev_net(br->dev), port_ifidx); 3245 if (!dev) 3246 return NULL; 3247 p = br_port_get_rtnl_rcu(dev); 3248 if (!p || p->br != br) 3249 return NULL; 3250 3251 return p; 3252 } 3253 3254 size_t br_multicast_querier_state_size(void) 3255 { 3256 return nla_total_size(0) + /* nest attribute */ 3257 nla_total_size(sizeof(__be32)) + /* BRIDGE_QUERIER_IP_ADDRESS */ 3258 nla_total_size(sizeof(int)) + /* BRIDGE_QUERIER_IP_PORT */ 3259 nla_total_size_64bit(sizeof(u64)) + /* BRIDGE_QUERIER_IP_OTHER_TIMER */ 3260 #if IS_ENABLED(CONFIG_IPV6) 3261 nla_total_size(sizeof(struct in6_addr)) + /* BRIDGE_QUERIER_IPV6_ADDRESS */ 3262 nla_total_size(sizeof(int)) + /* BRIDGE_QUERIER_IPV6_PORT */ 3263 nla_total_size_64bit(sizeof(u64)) + /* BRIDGE_QUERIER_IPV6_OTHER_TIMER */ 3264 #endif 3265 0; 3266 } 3267 3268 /* protected by rtnl or rcu */ 3269 int br_multicast_dump_querier_state(struct sk_buff *skb, 3270 const struct net_bridge_mcast *brmctx, 3271 int nest_attr) 3272 { 3273 struct bridge_mcast_querier querier = {}; 3274 struct net_bridge_port *p; 3275 struct nlattr *nest; 3276 3277 if (!br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED) || 3278 br_multicast_ctx_vlan_global_disabled(brmctx)) 3279 return 0; 3280 3281 nest = nla_nest_start(skb, nest_attr); 3282 if (!nest) 3283 return -EMSGSIZE; 3284 3285 rcu_read_lock(); 3286 if (!brmctx->multicast_querier && 3287 !timer_pending(&brmctx->ip4_other_query.timer)) 3288 goto out_v6; 3289 3290 br_multicast_read_querier(&brmctx->ip4_querier, &querier); 3291 if (nla_put_in_addr(skb, BRIDGE_QUERIER_IP_ADDRESS, 3292 querier.addr.src.ip4)) { 3293 rcu_read_unlock(); 3294 goto out_err; 3295 } 3296 3297 p = __br_multicast_get_querier_port(brmctx->br, &querier); 3298 if (timer_pending(&brmctx->ip4_other_query.timer) && 3299 (nla_put_u64_64bit(skb, BRIDGE_QUERIER_IP_OTHER_TIMER, 3300 br_timer_value(&brmctx->ip4_other_query.timer), 3301 BRIDGE_QUERIER_PAD) || 3302 (p && nla_put_u32(skb, BRIDGE_QUERIER_IP_PORT, p->dev->ifindex)))) { 3303 rcu_read_unlock(); 3304 goto out_err; 3305 } 3306 3307 out_v6: 3308 #if IS_ENABLED(CONFIG_IPV6) 3309 if (!brmctx->multicast_querier && 3310 !timer_pending(&brmctx->ip6_other_query.timer)) 3311 goto out; 3312 3313 br_multicast_read_querier(&brmctx->ip6_querier, &querier); 3314 if (nla_put_in6_addr(skb, BRIDGE_QUERIER_IPV6_ADDRESS, 3315 &querier.addr.src.ip6)) { 3316 rcu_read_unlock(); 3317 goto out_err; 3318 } 3319 3320 p = __br_multicast_get_querier_port(brmctx->br, &querier); 3321 if (timer_pending(&brmctx->ip6_other_query.timer) && 3322 (nla_put_u64_64bit(skb, BRIDGE_QUERIER_IPV6_OTHER_TIMER, 3323 br_timer_value(&brmctx->ip6_other_query.timer), 3324 BRIDGE_QUERIER_PAD) || 3325 (p && nla_put_u32(skb, BRIDGE_QUERIER_IPV6_PORT, 3326 p->dev->ifindex)))) { 3327 rcu_read_unlock(); 3328 goto out_err; 3329 } 3330 out: 3331 #endif 3332 rcu_read_unlock(); 3333 nla_nest_end(skb, nest); 3334 if (!nla_len(nest)) 3335 nla_nest_cancel(skb, nest); 3336 3337 return 0; 3338 3339 out_err: 3340 nla_nest_cancel(skb, nest); 3341 return -EMSGSIZE; 3342 } 3343 3344 static void 3345 br_multicast_update_query_timer(struct net_bridge_mcast *brmctx, 3346 struct bridge_mcast_other_query *query, 3347 unsigned long max_delay) 3348 { 3349 if (!timer_pending(&query->timer)) 3350 mod_timer(&query->delay_timer, jiffies + max_delay); 3351 3352 mod_timer(&query->timer, jiffies + brmctx->multicast_querier_interval); 3353 } 3354 3355 static void br_port_mc_router_state_change(struct net_bridge_port *p, 3356 bool is_mc_router) 3357 { 3358 struct switchdev_attr attr = { 3359 .orig_dev = p->dev, 3360 .id = SWITCHDEV_ATTR_ID_PORT_MROUTER, 3361 .flags = SWITCHDEV_F_DEFER, 3362 .u.mrouter = is_mc_router, 3363 }; 3364 3365 switchdev_port_attr_set(p->dev, &attr, NULL); 3366 } 3367 3368 static struct net_bridge_port * 3369 br_multicast_rport_from_node(struct net_bridge_mcast *brmctx, 3370 struct hlist_head *mc_router_list, 3371 struct hlist_node *rlist) 3372 { 3373 struct net_bridge_mcast_port *pmctx; 3374 3375 #if IS_ENABLED(CONFIG_IPV6) 3376 if (mc_router_list == &brmctx->ip6_mc_router_list) 3377 pmctx = hlist_entry(rlist, struct net_bridge_mcast_port, 3378 ip6_rlist); 3379 else 3380 #endif 3381 pmctx = hlist_entry(rlist, struct net_bridge_mcast_port, 3382 ip4_rlist); 3383 3384 return pmctx->port; 3385 } 3386 3387 static struct hlist_node * 3388 br_multicast_get_rport_slot(struct net_bridge_mcast *brmctx, 3389 struct net_bridge_port *port, 3390 struct hlist_head *mc_router_list) 3391 3392 { 3393 struct hlist_node *slot = NULL; 3394 struct net_bridge_port *p; 3395 struct hlist_node *rlist; 3396 3397 hlist_for_each(rlist, mc_router_list) { 3398 p = br_multicast_rport_from_node(brmctx, mc_router_list, rlist); 3399 3400 if ((unsigned long)port >= (unsigned long)p) 3401 break; 3402 3403 slot = rlist; 3404 } 3405 3406 return slot; 3407 } 3408 3409 static bool br_multicast_no_router_otherpf(struct net_bridge_mcast_port *pmctx, 3410 struct hlist_node *rnode) 3411 { 3412 #if IS_ENABLED(CONFIG_IPV6) 3413 if (rnode != &pmctx->ip6_rlist) 3414 return hlist_unhashed(&pmctx->ip6_rlist); 3415 else 3416 return hlist_unhashed(&pmctx->ip4_rlist); 3417 #else 3418 return true; 3419 #endif 3420 } 3421 3422 /* Add port to router_list 3423 * list is maintained ordered by pointer value 3424 * and locked by br->multicast_lock and RCU 3425 */ 3426 static void br_multicast_add_router(struct net_bridge_mcast *brmctx, 3427 struct net_bridge_mcast_port *pmctx, 3428 struct hlist_node *rlist, 3429 struct hlist_head *mc_router_list) 3430 { 3431 struct hlist_node *slot; 3432 3433 if (!hlist_unhashed(rlist)) 3434 return; 3435 3436 slot = br_multicast_get_rport_slot(brmctx, pmctx->port, mc_router_list); 3437 3438 if (slot) 3439 hlist_add_behind_rcu(rlist, slot); 3440 else 3441 hlist_add_head_rcu(rlist, mc_router_list); 3442 3443 /* For backwards compatibility for now, only notify if we 3444 * switched from no IPv4/IPv6 multicast router to a new 3445 * IPv4 or IPv6 multicast router. 3446 */ 3447 if (br_multicast_no_router_otherpf(pmctx, rlist)) { 3448 br_rtr_notify(pmctx->port->br->dev, pmctx, RTM_NEWMDB); 3449 br_port_mc_router_state_change(pmctx->port, true); 3450 } 3451 } 3452 3453 /* Add port to router_list 3454 * list is maintained ordered by pointer value 3455 * and locked by br->multicast_lock and RCU 3456 */ 3457 static void br_ip4_multicast_add_router(struct net_bridge_mcast *brmctx, 3458 struct net_bridge_mcast_port *pmctx) 3459 { 3460 br_multicast_add_router(brmctx, pmctx, &pmctx->ip4_rlist, 3461 &brmctx->ip4_mc_router_list); 3462 } 3463 3464 /* Add port to router_list 3465 * list is maintained ordered by pointer value 3466 * and locked by br->multicast_lock and RCU 3467 */ 3468 static void br_ip6_multicast_add_router(struct net_bridge_mcast *brmctx, 3469 struct net_bridge_mcast_port *pmctx) 3470 { 3471 #if IS_ENABLED(CONFIG_IPV6) 3472 br_multicast_add_router(brmctx, pmctx, &pmctx->ip6_rlist, 3473 &brmctx->ip6_mc_router_list); 3474 #endif 3475 } 3476 3477 static void br_multicast_mark_router(struct net_bridge_mcast *brmctx, 3478 struct net_bridge_mcast_port *pmctx, 3479 struct timer_list *timer, 3480 struct hlist_node *rlist, 3481 struct hlist_head *mc_router_list) 3482 { 3483 unsigned long now = jiffies; 3484 3485 if (!br_multicast_ctx_should_use(brmctx, pmctx)) 3486 return; 3487 3488 if (!pmctx) { 3489 if (brmctx->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) { 3490 if (!br_ip4_multicast_is_router(brmctx) && 3491 !br_ip6_multicast_is_router(brmctx)) 3492 br_mc_router_state_change(brmctx->br, true); 3493 mod_timer(timer, now + brmctx->multicast_querier_interval); 3494 } 3495 return; 3496 } 3497 3498 if (pmctx->multicast_router == MDB_RTR_TYPE_DISABLED || 3499 pmctx->multicast_router == MDB_RTR_TYPE_PERM) 3500 return; 3501 3502 br_multicast_add_router(brmctx, pmctx, rlist, mc_router_list); 3503 mod_timer(timer, now + brmctx->multicast_querier_interval); 3504 } 3505 3506 static void br_ip4_multicast_mark_router(struct net_bridge_mcast *brmctx, 3507 struct net_bridge_mcast_port *pmctx) 3508 { 3509 struct timer_list *timer = &brmctx->ip4_mc_router_timer; 3510 struct hlist_node *rlist = NULL; 3511 3512 if (pmctx) { 3513 timer = &pmctx->ip4_mc_router_timer; 3514 rlist = &pmctx->ip4_rlist; 3515 } 3516 3517 br_multicast_mark_router(brmctx, pmctx, timer, rlist, 3518 &brmctx->ip4_mc_router_list); 3519 } 3520 3521 static void br_ip6_multicast_mark_router(struct net_bridge_mcast *brmctx, 3522 struct net_bridge_mcast_port *pmctx) 3523 { 3524 #if IS_ENABLED(CONFIG_IPV6) 3525 struct timer_list *timer = &brmctx->ip6_mc_router_timer; 3526 struct hlist_node *rlist = NULL; 3527 3528 if (pmctx) { 3529 timer = &pmctx->ip6_mc_router_timer; 3530 rlist = &pmctx->ip6_rlist; 3531 } 3532 3533 br_multicast_mark_router(brmctx, pmctx, timer, rlist, 3534 &brmctx->ip6_mc_router_list); 3535 #endif 3536 } 3537 3538 static void 3539 br_ip4_multicast_query_received(struct net_bridge_mcast *brmctx, 3540 struct net_bridge_mcast_port *pmctx, 3541 struct bridge_mcast_other_query *query, 3542 struct br_ip *saddr, 3543 unsigned long max_delay) 3544 { 3545 if (!br_multicast_select_querier(brmctx, pmctx, saddr)) 3546 return; 3547 3548 br_multicast_update_query_timer(brmctx, query, max_delay); 3549 br_ip4_multicast_mark_router(brmctx, pmctx); 3550 } 3551 3552 #if IS_ENABLED(CONFIG_IPV6) 3553 static void 3554 br_ip6_multicast_query_received(struct net_bridge_mcast *brmctx, 3555 struct net_bridge_mcast_port *pmctx, 3556 struct bridge_mcast_other_query *query, 3557 struct br_ip *saddr, 3558 unsigned long max_delay) 3559 { 3560 if (!br_multicast_select_querier(brmctx, pmctx, saddr)) 3561 return; 3562 3563 br_multicast_update_query_timer(brmctx, query, max_delay); 3564 br_ip6_multicast_mark_router(brmctx, pmctx); 3565 } 3566 #endif 3567 3568 static void br_ip4_multicast_query(struct net_bridge_mcast *brmctx, 3569 struct net_bridge_mcast_port *pmctx, 3570 struct sk_buff *skb, 3571 u16 vid) 3572 { 3573 unsigned int transport_len = ip_transport_len(skb); 3574 const struct iphdr *iph = ip_hdr(skb); 3575 struct igmphdr *ih = igmp_hdr(skb); 3576 struct net_bridge_mdb_entry *mp; 3577 struct igmpv3_query *ih3; 3578 struct net_bridge_port_group *p; 3579 struct net_bridge_port_group __rcu **pp; 3580 struct br_ip saddr = {}; 3581 unsigned long max_delay; 3582 unsigned long now = jiffies; 3583 __be32 group; 3584 3585 spin_lock(&brmctx->br->multicast_lock); 3586 if (!br_multicast_ctx_should_use(brmctx, pmctx)) 3587 goto out; 3588 3589 group = ih->group; 3590 3591 if (transport_len == sizeof(*ih)) { 3592 max_delay = ih->code * (HZ / IGMP_TIMER_SCALE); 3593 3594 if (!max_delay) { 3595 max_delay = 10 * HZ; 3596 group = 0; 3597 } 3598 } else if (transport_len >= sizeof(*ih3)) { 3599 ih3 = igmpv3_query_hdr(skb); 3600 if (ih3->nsrcs || 3601 (brmctx->multicast_igmp_version == 3 && group && 3602 ih3->suppress)) 3603 goto out; 3604 3605 max_delay = ih3->code ? 3606 igmpv3_mrt(ih3) * (HZ / IGMP_TIMER_SCALE) : 1; 3607 } else { 3608 goto out; 3609 } 3610 3611 if (!group) { 3612 saddr.proto = htons(ETH_P_IP); 3613 saddr.src.ip4 = iph->saddr; 3614 3615 br_ip4_multicast_query_received(brmctx, pmctx, 3616 &brmctx->ip4_other_query, 3617 &saddr, max_delay); 3618 goto out; 3619 } 3620 3621 mp = br_mdb_ip4_get(brmctx->br, group, vid); 3622 if (!mp) 3623 goto out; 3624 3625 max_delay *= brmctx->multicast_last_member_count; 3626 3627 if (mp->host_joined && 3628 (timer_pending(&mp->timer) ? 3629 time_after(mp->timer.expires, now + max_delay) : 3630 timer_delete_sync_try(&mp->timer) >= 0)) 3631 mod_timer(&mp->timer, now + max_delay); 3632 3633 for (pp = &mp->ports; 3634 (p = mlock_dereference(*pp, brmctx->br)) != NULL; 3635 pp = &p->next) { 3636 if (timer_pending(&p->timer) ? 3637 time_after(p->timer.expires, now + max_delay) : 3638 timer_delete_sync_try(&p->timer) >= 0 && 3639 (brmctx->multicast_igmp_version == 2 || 3640 p->filter_mode == MCAST_EXCLUDE)) 3641 mod_timer(&p->timer, now + max_delay); 3642 } 3643 3644 out: 3645 spin_unlock(&brmctx->br->multicast_lock); 3646 } 3647 3648 #if IS_ENABLED(CONFIG_IPV6) 3649 static int br_ip6_multicast_query(struct net_bridge_mcast *brmctx, 3650 struct net_bridge_mcast_port *pmctx, 3651 struct sk_buff *skb, 3652 u16 vid) 3653 { 3654 unsigned int transport_len = ipv6_transport_len(skb); 3655 struct mld_msg *mld; 3656 struct net_bridge_mdb_entry *mp; 3657 struct mld2_query *mld2q; 3658 struct net_bridge_port_group *p; 3659 struct net_bridge_port_group __rcu **pp; 3660 struct br_ip saddr = {}; 3661 unsigned long max_delay; 3662 unsigned long now = jiffies; 3663 unsigned int offset = skb_transport_offset(skb); 3664 const struct in6_addr *group = NULL; 3665 bool is_general_query; 3666 int err = 0; 3667 3668 spin_lock(&brmctx->br->multicast_lock); 3669 if (!br_multicast_ctx_should_use(brmctx, pmctx)) 3670 goto out; 3671 3672 if (transport_len == sizeof(*mld)) { 3673 if (!pskb_may_pull(skb, offset + sizeof(*mld))) { 3674 err = -EINVAL; 3675 goto out; 3676 } 3677 mld = (struct mld_msg *) icmp6_hdr(skb); 3678 max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay)); 3679 if (max_delay) 3680 group = &mld->mld_mca; 3681 } else { 3682 if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) { 3683 err = -EINVAL; 3684 goto out; 3685 } 3686 mld2q = (struct mld2_query *)icmp6_hdr(skb); 3687 if (!mld2q->mld2q_nsrcs) 3688 group = &mld2q->mld2q_mca; 3689 if (brmctx->multicast_mld_version == 2 && 3690 !ipv6_addr_any(&mld2q->mld2q_mca) && 3691 mld2q->mld2q_suppress) 3692 goto out; 3693 3694 max_delay = max(msecs_to_jiffies(mldv2_mrd(mld2q)), 1UL); 3695 } 3696 3697 is_general_query = group && ipv6_addr_any(group); 3698 3699 if (is_general_query) { 3700 saddr.proto = htons(ETH_P_IPV6); 3701 saddr.src.ip6 = ipv6_hdr(skb)->saddr; 3702 3703 br_ip6_multicast_query_received(brmctx, pmctx, 3704 &brmctx->ip6_other_query, 3705 &saddr, max_delay); 3706 goto out; 3707 } else if (!group) { 3708 goto out; 3709 } 3710 3711 mp = br_mdb_ip6_get(brmctx->br, group, vid); 3712 if (!mp) 3713 goto out; 3714 3715 max_delay *= brmctx->multicast_last_member_count; 3716 if (mp->host_joined && 3717 (timer_pending(&mp->timer) ? 3718 time_after(mp->timer.expires, now + max_delay) : 3719 timer_delete_sync_try(&mp->timer) >= 0)) 3720 mod_timer(&mp->timer, now + max_delay); 3721 3722 for (pp = &mp->ports; 3723 (p = mlock_dereference(*pp, brmctx->br)) != NULL; 3724 pp = &p->next) { 3725 if (timer_pending(&p->timer) ? 3726 time_after(p->timer.expires, now + max_delay) : 3727 timer_delete_sync_try(&p->timer) >= 0 && 3728 (brmctx->multicast_mld_version == 1 || 3729 p->filter_mode == MCAST_EXCLUDE)) 3730 mod_timer(&p->timer, now + max_delay); 3731 } 3732 3733 out: 3734 spin_unlock(&brmctx->br->multicast_lock); 3735 return err; 3736 } 3737 #endif 3738 3739 static void 3740 br_multicast_leave_group(struct net_bridge_mcast *brmctx, 3741 struct net_bridge_mcast_port *pmctx, 3742 struct br_ip *group, 3743 struct bridge_mcast_other_query *other_query, 3744 struct bridge_mcast_own_query *own_query, 3745 const unsigned char *src) 3746 { 3747 struct net_bridge_mdb_entry *mp; 3748 struct net_bridge_port_group *p; 3749 unsigned long now; 3750 unsigned long time; 3751 3752 spin_lock(&brmctx->br->multicast_lock); 3753 if (!br_multicast_ctx_should_use(brmctx, pmctx)) 3754 goto out; 3755 3756 mp = br_mdb_ip_get(brmctx->br, group); 3757 if (!mp) 3758 goto out; 3759 3760 if (pmctx && 3761 test_bit(BR_MULTICAST_FAST_LEAVE_BIT, &pmctx->port->flags)) { 3762 struct net_bridge_port_group __rcu **pp; 3763 3764 for (pp = &mp->ports; 3765 (p = mlock_dereference(*pp, brmctx->br)) != NULL; 3766 pp = &p->next) { 3767 if (!br_port_group_equal(p, pmctx->port, src)) 3768 continue; 3769 3770 if (p->flags & MDB_PG_FLAGS_PERMANENT) 3771 break; 3772 3773 p->flags |= MDB_PG_FLAGS_FAST_LEAVE; 3774 br_multicast_del_pg(mp, p, pp); 3775 break; 3776 } 3777 goto out; 3778 } 3779 3780 if (timer_pending(&other_query->timer)) 3781 goto out; 3782 3783 if (brmctx->multicast_querier) { 3784 __br_multicast_send_query(brmctx, pmctx, NULL, NULL, &mp->addr, 3785 false, 0, NULL); 3786 3787 time = jiffies + brmctx->multicast_last_member_count * 3788 brmctx->multicast_last_member_interval; 3789 3790 mod_timer(&own_query->timer, time); 3791 3792 for (p = mlock_dereference(mp->ports, brmctx->br); 3793 p != NULL && pmctx != NULL; 3794 p = mlock_dereference(p->next, brmctx->br)) { 3795 if (!br_port_group_equal(p, pmctx->port, src)) 3796 continue; 3797 3798 if (!hlist_unhashed(&p->mglist) && 3799 (timer_pending(&p->timer) ? 3800 time_after(p->timer.expires, time) : 3801 timer_delete_sync_try(&p->timer) >= 0)) { 3802 mod_timer(&p->timer, time); 3803 } 3804 3805 break; 3806 } 3807 } 3808 3809 now = jiffies; 3810 time = now + brmctx->multicast_last_member_count * 3811 brmctx->multicast_last_member_interval; 3812 3813 if (!pmctx) { 3814 if (mp->host_joined && 3815 (timer_pending(&mp->timer) ? 3816 time_after(mp->timer.expires, time) : 3817 timer_delete_sync_try(&mp->timer) >= 0)) { 3818 mod_timer(&mp->timer, time); 3819 } 3820 3821 goto out; 3822 } 3823 3824 for (p = mlock_dereference(mp->ports, brmctx->br); 3825 p != NULL; 3826 p = mlock_dereference(p->next, brmctx->br)) { 3827 if (p->key.port != pmctx->port) 3828 continue; 3829 3830 if (!hlist_unhashed(&p->mglist) && 3831 (timer_pending(&p->timer) ? 3832 time_after(p->timer.expires, time) : 3833 timer_delete_sync_try(&p->timer) >= 0)) { 3834 mod_timer(&p->timer, time); 3835 } 3836 3837 break; 3838 } 3839 out: 3840 spin_unlock(&brmctx->br->multicast_lock); 3841 } 3842 3843 static void br_ip4_multicast_leave_group(struct net_bridge_mcast *brmctx, 3844 struct net_bridge_mcast_port *pmctx, 3845 __be32 group, 3846 __u16 vid, 3847 const unsigned char *src) 3848 { 3849 struct br_ip br_group; 3850 struct bridge_mcast_own_query *own_query; 3851 3852 if (ipv4_is_local_multicast(group)) 3853 return; 3854 3855 own_query = pmctx ? &pmctx->ip4_own_query : &brmctx->ip4_own_query; 3856 3857 memset(&br_group, 0, sizeof(br_group)); 3858 br_group.dst.ip4 = group; 3859 br_group.proto = htons(ETH_P_IP); 3860 br_group.vid = vid; 3861 3862 br_multicast_leave_group(brmctx, pmctx, &br_group, 3863 &brmctx->ip4_other_query, 3864 own_query, src); 3865 } 3866 3867 #if IS_ENABLED(CONFIG_IPV6) 3868 static void br_ip6_multicast_leave_group(struct net_bridge_mcast *brmctx, 3869 struct net_bridge_mcast_port *pmctx, 3870 const struct in6_addr *group, 3871 __u16 vid, 3872 const unsigned char *src) 3873 { 3874 struct br_ip br_group; 3875 struct bridge_mcast_own_query *own_query; 3876 3877 if (ipv6_addr_is_ll_all_nodes(group)) 3878 return; 3879 3880 own_query = pmctx ? &pmctx->ip6_own_query : &brmctx->ip6_own_query; 3881 3882 memset(&br_group, 0, sizeof(br_group)); 3883 br_group.dst.ip6 = *group; 3884 br_group.proto = htons(ETH_P_IPV6); 3885 br_group.vid = vid; 3886 3887 br_multicast_leave_group(brmctx, pmctx, &br_group, 3888 &brmctx->ip6_other_query, 3889 own_query, src); 3890 } 3891 #endif 3892 3893 static void br_multicast_err_count(const struct net_bridge *br, 3894 const struct net_bridge_port *p, 3895 __be16 proto) 3896 { 3897 struct bridge_mcast_stats __percpu *stats; 3898 struct bridge_mcast_stats *pstats; 3899 3900 if (!br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED)) 3901 return; 3902 3903 if (p) 3904 stats = p->mcast_stats; 3905 else 3906 stats = br->mcast_stats; 3907 if (WARN_ON(!stats)) 3908 return; 3909 3910 pstats = this_cpu_ptr(stats); 3911 3912 u64_stats_update_begin(&pstats->syncp); 3913 switch (proto) { 3914 case htons(ETH_P_IP): 3915 pstats->mstats.igmp_parse_errors++; 3916 break; 3917 #if IS_ENABLED(CONFIG_IPV6) 3918 case htons(ETH_P_IPV6): 3919 pstats->mstats.mld_parse_errors++; 3920 break; 3921 #endif 3922 } 3923 u64_stats_update_end(&pstats->syncp); 3924 } 3925 3926 static void br_multicast_pim(struct net_bridge_mcast *brmctx, 3927 struct net_bridge_mcast_port *pmctx, 3928 const struct sk_buff *skb) 3929 { 3930 unsigned int offset = skb_transport_offset(skb); 3931 struct pimhdr *pimhdr, _pimhdr; 3932 3933 pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr); 3934 if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION || 3935 pim_hdr_type(pimhdr) != PIM_TYPE_HELLO) 3936 return; 3937 3938 spin_lock(&brmctx->br->multicast_lock); 3939 br_ip4_multicast_mark_router(brmctx, pmctx); 3940 spin_unlock(&brmctx->br->multicast_lock); 3941 } 3942 3943 static int br_ip4_multicast_mrd_rcv(struct net_bridge_mcast *brmctx, 3944 struct net_bridge_mcast_port *pmctx, 3945 struct sk_buff *skb) 3946 { 3947 if (ip_hdr(skb)->protocol != IPPROTO_IGMP || 3948 igmp_hdr(skb)->type != IGMP_MRDISC_ADV) 3949 return -ENOMSG; 3950 3951 spin_lock(&brmctx->br->multicast_lock); 3952 br_ip4_multicast_mark_router(brmctx, pmctx); 3953 spin_unlock(&brmctx->br->multicast_lock); 3954 3955 return 0; 3956 } 3957 3958 static int br_multicast_ipv4_rcv(struct net_bridge_mcast *brmctx, 3959 struct net_bridge_mcast_port *pmctx, 3960 struct sk_buff *skb, 3961 u16 vid) 3962 { 3963 struct net_bridge_port *p = pmctx ? pmctx->port : NULL; 3964 const unsigned char *src; 3965 struct igmphdr *ih; 3966 int err; 3967 3968 err = ip_mc_check_igmp(skb); 3969 3970 if (err == -ENOMSG) { 3971 if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) { 3972 BR_INPUT_SKB_CB(skb)->mrouters_only = 1; 3973 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) { 3974 if (ip_hdr(skb)->protocol == IPPROTO_PIM) 3975 br_multicast_pim(brmctx, pmctx, skb); 3976 } else if (ipv4_is_all_snoopers(ip_hdr(skb)->daddr)) { 3977 br_ip4_multicast_mrd_rcv(brmctx, pmctx, skb); 3978 } 3979 3980 return 0; 3981 } else if (err < 0) { 3982 br_multicast_err_count(brmctx->br, p, skb->protocol); 3983 return err; 3984 } 3985 3986 ih = igmp_hdr(skb); 3987 src = eth_hdr(skb)->h_source; 3988 BR_INPUT_SKB_CB(skb)->igmp = ih->type; 3989 3990 switch (ih->type) { 3991 case IGMP_HOST_MEMBERSHIP_REPORT: 3992 case IGMPV2_HOST_MEMBERSHIP_REPORT: 3993 BR_INPUT_SKB_CB(skb)->mrouters_only = 1; 3994 err = br_ip4_multicast_add_group(brmctx, pmctx, ih->group, vid, 3995 src, true); 3996 break; 3997 case IGMPV3_HOST_MEMBERSHIP_REPORT: 3998 err = br_ip4_multicast_igmp3_report(brmctx, pmctx, skb, vid); 3999 break; 4000 case IGMP_HOST_MEMBERSHIP_QUERY: 4001 br_ip4_multicast_query(brmctx, pmctx, skb, vid); 4002 break; 4003 case IGMP_HOST_LEAVE_MESSAGE: 4004 br_ip4_multicast_leave_group(brmctx, pmctx, ih->group, vid, src); 4005 break; 4006 } 4007 4008 br_multicast_count(brmctx->br, p, skb, BR_INPUT_SKB_CB(skb)->igmp, 4009 BR_MCAST_DIR_RX); 4010 4011 return err; 4012 } 4013 4014 #if IS_ENABLED(CONFIG_IPV6) 4015 static void br_ip6_multicast_mrd_rcv(struct net_bridge_mcast *brmctx, 4016 struct net_bridge_mcast_port *pmctx, 4017 struct sk_buff *skb) 4018 { 4019 if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV) 4020 return; 4021 4022 spin_lock(&brmctx->br->multicast_lock); 4023 br_ip6_multicast_mark_router(brmctx, pmctx); 4024 spin_unlock(&brmctx->br->multicast_lock); 4025 } 4026 4027 static int br_multicast_ipv6_rcv(struct net_bridge_mcast *brmctx, 4028 struct net_bridge_mcast_port *pmctx, 4029 struct sk_buff *skb, 4030 u16 vid) 4031 { 4032 struct net_bridge_port *p = pmctx ? pmctx->port : NULL; 4033 const unsigned char *src; 4034 struct mld_msg *mld; 4035 int err; 4036 4037 err = ipv6_mc_check_mld(skb); 4038 4039 if (err == -ENOMSG || err == -ENODATA) { 4040 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr)) 4041 BR_INPUT_SKB_CB(skb)->mrouters_only = 1; 4042 if (err == -ENODATA && 4043 ipv6_addr_is_all_snoopers(&ipv6_hdr(skb)->daddr)) 4044 br_ip6_multicast_mrd_rcv(brmctx, pmctx, skb); 4045 4046 return 0; 4047 } else if (err < 0) { 4048 br_multicast_err_count(brmctx->br, p, skb->protocol); 4049 return err; 4050 } 4051 4052 mld = (struct mld_msg *)skb_transport_header(skb); 4053 BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type; 4054 4055 switch (mld->mld_type) { 4056 case ICMPV6_MGM_REPORT: 4057 src = eth_hdr(skb)->h_source; 4058 BR_INPUT_SKB_CB(skb)->mrouters_only = 1; 4059 err = br_ip6_multicast_add_group(brmctx, pmctx, &mld->mld_mca, 4060 vid, src, true); 4061 break; 4062 case ICMPV6_MLD2_REPORT: 4063 err = br_ip6_multicast_mld2_report(brmctx, pmctx, skb, vid); 4064 break; 4065 case ICMPV6_MGM_QUERY: 4066 err = br_ip6_multicast_query(brmctx, pmctx, skb, vid); 4067 break; 4068 case ICMPV6_MGM_REDUCTION: 4069 src = eth_hdr(skb)->h_source; 4070 br_ip6_multicast_leave_group(brmctx, pmctx, &mld->mld_mca, vid, 4071 src); 4072 break; 4073 } 4074 4075 br_multicast_count(brmctx->br, p, skb, BR_INPUT_SKB_CB(skb)->igmp, 4076 BR_MCAST_DIR_RX); 4077 4078 return err; 4079 } 4080 #endif 4081 4082 int br_multicast_rcv(struct net_bridge_mcast **brmctx, 4083 struct net_bridge_mcast_port **pmctx, 4084 struct net_bridge_vlan *vlan, 4085 struct sk_buff *skb, u16 vid) 4086 { 4087 int ret = 0; 4088 4089 BR_INPUT_SKB_CB(skb)->igmp = 0; 4090 BR_INPUT_SKB_CB(skb)->mrouters_only = 0; 4091 4092 if (!br_opt_get((*brmctx)->br, BROPT_MULTICAST_ENABLED)) 4093 return 0; 4094 4095 if (br_opt_get((*brmctx)->br, BROPT_MCAST_VLAN_SNOOPING_ENABLED) && vlan) { 4096 const struct net_bridge_vlan *masterv; 4097 4098 /* the vlan has the master flag set only when transmitting 4099 * through the bridge device 4100 */ 4101 if (br_vlan_is_master(vlan)) { 4102 masterv = vlan; 4103 *brmctx = &vlan->br_mcast_ctx; 4104 *pmctx = NULL; 4105 } else { 4106 masterv = vlan->brvlan; 4107 *brmctx = &vlan->brvlan->br_mcast_ctx; 4108 *pmctx = &vlan->port_mcast_ctx; 4109 } 4110 4111 if (!(masterv->priv_flags & BR_VLFLAG_GLOBAL_MCAST_ENABLED)) 4112 return 0; 4113 } 4114 4115 switch (skb->protocol) { 4116 case htons(ETH_P_IP): 4117 ret = br_multicast_ipv4_rcv(*brmctx, *pmctx, skb, vid); 4118 break; 4119 #if IS_ENABLED(CONFIG_IPV6) 4120 case htons(ETH_P_IPV6): 4121 ret = br_multicast_ipv6_rcv(*brmctx, *pmctx, skb, vid); 4122 break; 4123 #endif 4124 } 4125 4126 return ret; 4127 } 4128 4129 static void br_multicast_query_expired(struct net_bridge_mcast *brmctx, 4130 struct bridge_mcast_own_query *query) 4131 { 4132 spin_lock(&brmctx->br->multicast_lock); 4133 if (br_multicast_ctx_vlan_disabled(brmctx)) 4134 goto out; 4135 4136 if (query->startup_sent < brmctx->multicast_startup_query_count) 4137 query->startup_sent++; 4138 4139 br_multicast_send_query(brmctx, NULL, query); 4140 out: 4141 spin_unlock(&brmctx->br->multicast_lock); 4142 } 4143 4144 static void br_ip4_multicast_query_expired(struct timer_list *t) 4145 { 4146 struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 4147 ip4_own_query.timer); 4148 4149 br_multicast_query_expired(brmctx, &brmctx->ip4_own_query); 4150 } 4151 4152 #if IS_ENABLED(CONFIG_IPV6) 4153 static void br_ip6_multicast_query_expired(struct timer_list *t) 4154 { 4155 struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 4156 ip6_own_query.timer); 4157 4158 br_multicast_query_expired(brmctx, &brmctx->ip6_own_query); 4159 } 4160 #endif 4161 4162 static void br_multicast_gc_work(struct work_struct *work) 4163 { 4164 struct net_bridge *br = container_of(work, struct net_bridge, 4165 mcast_gc_work); 4166 HLIST_HEAD(deleted_head); 4167 4168 spin_lock_bh(&br->multicast_lock); 4169 hlist_move_list(&br->mcast_gc_list, &deleted_head); 4170 spin_unlock_bh(&br->multicast_lock); 4171 4172 br_multicast_gc(&deleted_head); 4173 } 4174 4175 void br_multicast_ctx_init(struct net_bridge *br, 4176 struct net_bridge_vlan *vlan, 4177 struct net_bridge_mcast *brmctx) 4178 { 4179 brmctx->br = br; 4180 brmctx->vlan = vlan; 4181 brmctx->multicast_router = MDB_RTR_TYPE_TEMP_QUERY; 4182 brmctx->multicast_last_member_count = 2; 4183 brmctx->multicast_startup_query_count = 2; 4184 4185 brmctx->multicast_last_member_interval = HZ; 4186 brmctx->multicast_query_response_interval = 10 * HZ; 4187 brmctx->multicast_startup_query_interval = 125 * HZ / 4; 4188 brmctx->multicast_query_interval = 125 * HZ; 4189 brmctx->multicast_querier_interval = 255 * HZ; 4190 brmctx->multicast_membership_interval = 260 * HZ; 4191 4192 brmctx->ip4_querier.port_ifidx = 0; 4193 seqcount_spinlock_init(&brmctx->ip4_querier.seq, &br->multicast_lock); 4194 brmctx->multicast_igmp_version = 2; 4195 #if IS_ENABLED(CONFIG_IPV6) 4196 brmctx->multicast_mld_version = 1; 4197 brmctx->ip6_querier.port_ifidx = 0; 4198 seqcount_spinlock_init(&brmctx->ip6_querier.seq, &br->multicast_lock); 4199 #endif 4200 4201 skb_queue_head_init(&brmctx->query_queue); 4202 INIT_WORK(&brmctx->query_queue_work, br_multicast_query_queue_work); 4203 4204 timer_setup(&brmctx->ip4_mc_router_timer, 4205 br_ip4_multicast_local_router_expired, 0); 4206 timer_setup(&brmctx->ip4_other_query.timer, 4207 br_ip4_multicast_querier_expired, 0); 4208 timer_setup(&brmctx->ip4_other_query.delay_timer, 4209 br_multicast_query_delay_expired, 0); 4210 timer_setup(&brmctx->ip4_own_query.timer, 4211 br_ip4_multicast_query_expired, 0); 4212 #if IS_ENABLED(CONFIG_IPV6) 4213 timer_setup(&brmctx->ip6_mc_router_timer, 4214 br_ip6_multicast_local_router_expired, 0); 4215 timer_setup(&brmctx->ip6_other_query.timer, 4216 br_ip6_multicast_querier_expired, 0); 4217 timer_setup(&brmctx->ip6_other_query.delay_timer, 4218 br_multicast_query_delay_expired, 0); 4219 timer_setup(&brmctx->ip6_own_query.timer, 4220 br_ip6_multicast_query_expired, 0); 4221 #endif 4222 } 4223 4224 void br_multicast_ctx_deinit(struct net_bridge_mcast *brmctx) 4225 { 4226 __br_multicast_stop(brmctx); 4227 cancel_work_sync(&brmctx->query_queue_work); 4228 __skb_queue_purge(&brmctx->query_queue); 4229 } 4230 4231 void br_multicast_init(struct net_bridge *br) 4232 { 4233 br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX; 4234 4235 br_multicast_ctx_init(br, NULL, &br->multicast_ctx); 4236 4237 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true); 4238 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true); 4239 4240 spin_lock_init(&br->multicast_lock); 4241 INIT_HLIST_HEAD(&br->mdb_list); 4242 INIT_HLIST_HEAD(&br->mcast_gc_list); 4243 INIT_WORK(&br->mcast_gc_work, br_multicast_gc_work); 4244 } 4245 4246 static void br_ip4_multicast_join_snoopers(struct net_bridge *br) 4247 { 4248 struct in_device *in_dev = in_dev_get(br->dev); 4249 4250 if (!in_dev) 4251 return; 4252 4253 __ip_mc_inc_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC); 4254 in_dev_put(in_dev); 4255 } 4256 4257 #if IS_ENABLED(CONFIG_IPV6) 4258 static void br_ip6_multicast_join_snoopers(struct net_bridge *br) 4259 { 4260 struct in6_addr addr; 4261 4262 ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a)); 4263 ipv6_dev_mc_inc(br->dev, &addr); 4264 } 4265 #else 4266 static inline void br_ip6_multicast_join_snoopers(struct net_bridge *br) 4267 { 4268 } 4269 #endif 4270 4271 void br_multicast_join_snoopers(struct net_bridge *br) 4272 { 4273 br_ip4_multicast_join_snoopers(br); 4274 br_ip6_multicast_join_snoopers(br); 4275 } 4276 4277 static void br_ip4_multicast_leave_snoopers(struct net_bridge *br) 4278 { 4279 struct in_device *in_dev = in_dev_get(br->dev); 4280 4281 if (WARN_ON(!in_dev)) 4282 return; 4283 4284 __ip_mc_dec_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC); 4285 in_dev_put(in_dev); 4286 } 4287 4288 #if IS_ENABLED(CONFIG_IPV6) 4289 static void br_ip6_multicast_leave_snoopers(struct net_bridge *br) 4290 { 4291 struct in6_addr addr; 4292 4293 ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a)); 4294 ipv6_dev_mc_dec(br->dev, &addr); 4295 } 4296 #else 4297 static inline void br_ip6_multicast_leave_snoopers(struct net_bridge *br) 4298 { 4299 } 4300 #endif 4301 4302 void br_multicast_leave_snoopers(struct net_bridge *br) 4303 { 4304 br_ip4_multicast_leave_snoopers(br); 4305 br_ip6_multicast_leave_snoopers(br); 4306 } 4307 4308 static void __br_multicast_open_query(struct net_bridge *br, 4309 struct bridge_mcast_own_query *query) 4310 { 4311 query->startup_sent = 0; 4312 4313 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) 4314 return; 4315 4316 mod_timer(&query->timer, jiffies); 4317 } 4318 4319 static void __br_multicast_open(struct net_bridge_mcast *brmctx) 4320 { 4321 __br_multicast_open_query(brmctx->br, &brmctx->ip4_own_query); 4322 #if IS_ENABLED(CONFIG_IPV6) 4323 __br_multicast_open_query(brmctx->br, &brmctx->ip6_own_query); 4324 #endif 4325 } 4326 4327 void br_multicast_open(struct net_bridge *br) 4328 { 4329 ASSERT_RTNL(); 4330 4331 if (br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) { 4332 struct net_bridge_vlan_group *vg; 4333 struct net_bridge_vlan *vlan; 4334 4335 vg = br_vlan_group(br); 4336 if (vg) { 4337 list_for_each_entry(vlan, &vg->vlan_list, vlist) { 4338 struct net_bridge_mcast *brmctx; 4339 4340 brmctx = &vlan->br_mcast_ctx; 4341 if (br_vlan_is_brentry(vlan) && 4342 !br_multicast_ctx_vlan_disabled(brmctx)) 4343 __br_multicast_open(&vlan->br_mcast_ctx); 4344 } 4345 } 4346 } else { 4347 __br_multicast_open(&br->multicast_ctx); 4348 } 4349 } 4350 4351 static void __br_multicast_stop(struct net_bridge_mcast *brmctx) 4352 { 4353 timer_delete_sync(&brmctx->ip4_mc_router_timer); 4354 timer_delete_sync(&brmctx->ip4_other_query.timer); 4355 timer_delete_sync(&brmctx->ip4_other_query.delay_timer); 4356 timer_delete_sync(&brmctx->ip4_own_query.timer); 4357 #if IS_ENABLED(CONFIG_IPV6) 4358 timer_delete_sync(&brmctx->ip6_mc_router_timer); 4359 timer_delete_sync(&brmctx->ip6_other_query.timer); 4360 timer_delete_sync(&brmctx->ip6_other_query.delay_timer); 4361 timer_delete_sync(&brmctx->ip6_own_query.timer); 4362 #endif 4363 } 4364 4365 void br_multicast_update_vlan_mcast_ctx(struct net_bridge_vlan *v, u8 state) 4366 { 4367 #if IS_ENABLED(CONFIG_BRIDGE_VLAN_FILTERING) 4368 struct net_bridge *br; 4369 4370 if (!br_vlan_should_use(v)) 4371 return; 4372 4373 if (br_vlan_is_master(v)) 4374 return; 4375 4376 br = v->port->br; 4377 4378 if (!br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) 4379 return; 4380 4381 if (br_vlan_state_allowed(state, true)) 4382 br_multicast_enable_port_ctx(&v->port_mcast_ctx); 4383 4384 /* Multicast is not disabled for the vlan when it goes in 4385 * blocking state because the timers will expire and stop by 4386 * themselves without sending more queries. 4387 */ 4388 #endif 4389 } 4390 4391 void br_multicast_toggle_one_vlan(struct net_bridge_vlan *vlan, bool on) 4392 { 4393 struct net_bridge *br; 4394 4395 /* it's okay to check for the flag without the multicast lock because it 4396 * can only change under RTNL -> multicast_lock, we need the latter to 4397 * sync with timers and packets 4398 */ 4399 if (on == !!(vlan->priv_flags & BR_VLFLAG_MCAST_ENABLED)) 4400 return; 4401 4402 if (br_vlan_is_master(vlan)) { 4403 br = vlan->br; 4404 4405 if (on && 4406 (!br_vlan_is_brentry(vlan) || 4407 br_multicast_ctx_vlan_global_disabled(&vlan->br_mcast_ctx))) 4408 return; 4409 4410 spin_lock_bh(&br->multicast_lock); 4411 vlan->priv_flags ^= BR_VLFLAG_MCAST_ENABLED; 4412 spin_unlock_bh(&br->multicast_lock); 4413 4414 if (on) 4415 __br_multicast_open(&vlan->br_mcast_ctx); 4416 else 4417 __br_multicast_stop(&vlan->br_mcast_ctx); 4418 } else { 4419 struct net_bridge_mcast *brmctx; 4420 4421 brmctx = br_multicast_port_ctx_get_global(&vlan->port_mcast_ctx); 4422 if (on && br_multicast_ctx_vlan_global_disabled(brmctx)) 4423 return; 4424 4425 br = vlan->port->br; 4426 spin_lock_bh(&br->multicast_lock); 4427 vlan->priv_flags ^= BR_VLFLAG_MCAST_ENABLED; 4428 if (on) 4429 __br_multicast_enable_port_ctx(&vlan->port_mcast_ctx); 4430 else 4431 __br_multicast_disable_port_ctx(&vlan->port_mcast_ctx); 4432 spin_unlock_bh(&br->multicast_lock); 4433 } 4434 } 4435 4436 static void br_multicast_toggle_vlan(struct net_bridge_vlan *vlan, bool on) 4437 { 4438 struct net_bridge_port *p; 4439 4440 if (WARN_ON_ONCE(!br_vlan_is_master(vlan))) 4441 return; 4442 4443 list_for_each_entry(p, &vlan->br->port_list, list) { 4444 struct net_bridge_vlan *vport; 4445 4446 vport = br_vlan_find(nbp_vlan_group(p), vlan->vid); 4447 if (!vport) 4448 continue; 4449 br_multicast_toggle_one_vlan(vport, on); 4450 } 4451 4452 if (br_vlan_is_brentry(vlan)) 4453 br_multicast_toggle_one_vlan(vlan, on); 4454 } 4455 4456 int br_multicast_toggle_vlan_snooping(struct net_bridge *br, bool on, 4457 struct netlink_ext_ack *extack) 4458 { 4459 struct net_bridge_vlan_group *vg; 4460 struct net_bridge_vlan *vlan; 4461 struct net_bridge_port *p; 4462 4463 if (br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED) == on) 4464 return 0; 4465 4466 if (on && !br_opt_get(br, BROPT_VLAN_ENABLED)) { 4467 NL_SET_ERR_MSG_MOD(extack, "Cannot enable multicast vlan snooping with vlan filtering disabled"); 4468 return -EINVAL; 4469 } 4470 4471 vg = br_vlan_group(br); 4472 if (!vg) 4473 return 0; 4474 4475 br_opt_toggle(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED, on); 4476 4477 /* disable/enable non-vlan mcast contexts based on vlan snooping */ 4478 if (on) 4479 __br_multicast_stop(&br->multicast_ctx); 4480 else 4481 __br_multicast_open(&br->multicast_ctx); 4482 list_for_each_entry(p, &br->port_list, list) { 4483 if (on) 4484 br_multicast_disable_port_ctx(&p->multicast_ctx); 4485 else 4486 br_multicast_enable_port_ctx(&p->multicast_ctx); 4487 } 4488 4489 list_for_each_entry(vlan, &vg->vlan_list, vlist) 4490 br_multicast_toggle_vlan(vlan, on); 4491 4492 return 0; 4493 } 4494 4495 bool br_multicast_toggle_global_vlan(struct net_bridge_vlan *vlan, bool on) 4496 { 4497 ASSERT_RTNL(); 4498 4499 /* BR_VLFLAG_GLOBAL_MCAST_ENABLED relies on eventual consistency and 4500 * requires only RTNL to change 4501 */ 4502 if (on == !!(vlan->priv_flags & BR_VLFLAG_GLOBAL_MCAST_ENABLED)) 4503 return false; 4504 4505 vlan->priv_flags ^= BR_VLFLAG_GLOBAL_MCAST_ENABLED; 4506 br_multicast_toggle_vlan(vlan, on); 4507 4508 return true; 4509 } 4510 4511 void br_multicast_stop(struct net_bridge *br) 4512 { 4513 ASSERT_RTNL(); 4514 4515 if (br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) { 4516 struct net_bridge_vlan_group *vg; 4517 struct net_bridge_vlan *vlan; 4518 4519 vg = br_vlan_group(br); 4520 if (vg) { 4521 list_for_each_entry(vlan, &vg->vlan_list, vlist) { 4522 struct net_bridge_mcast *brmctx; 4523 4524 brmctx = &vlan->br_mcast_ctx; 4525 if (br_vlan_is_brentry(vlan) && 4526 !br_multicast_ctx_vlan_disabled(brmctx)) 4527 __br_multicast_stop(&vlan->br_mcast_ctx); 4528 } 4529 } 4530 } else { 4531 __br_multicast_stop(&br->multicast_ctx); 4532 } 4533 } 4534 4535 void br_multicast_dev_del(struct net_bridge *br) 4536 { 4537 struct net_bridge_mdb_entry *mp; 4538 HLIST_HEAD(deleted_head); 4539 struct hlist_node *tmp; 4540 4541 spin_lock_bh(&br->multicast_lock); 4542 hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node) 4543 br_multicast_del_mdb_entry(mp); 4544 hlist_move_list(&br->mcast_gc_list, &deleted_head); 4545 spin_unlock_bh(&br->multicast_lock); 4546 4547 br_multicast_ctx_deinit(&br->multicast_ctx); 4548 br_multicast_gc(&deleted_head); 4549 cancel_work_sync(&br->mcast_gc_work); 4550 } 4551 4552 int br_multicast_set_router(struct net_bridge_mcast *brmctx, unsigned long val) 4553 { 4554 int err = -EINVAL; 4555 4556 spin_lock_bh(&brmctx->br->multicast_lock); 4557 4558 switch (val) { 4559 case MDB_RTR_TYPE_DISABLED: 4560 case MDB_RTR_TYPE_PERM: 4561 br_mc_router_state_change(brmctx->br, val == MDB_RTR_TYPE_PERM); 4562 timer_delete(&brmctx->ip4_mc_router_timer); 4563 #if IS_ENABLED(CONFIG_IPV6) 4564 timer_delete(&brmctx->ip6_mc_router_timer); 4565 #endif 4566 brmctx->multicast_router = val; 4567 err = 0; 4568 break; 4569 case MDB_RTR_TYPE_TEMP_QUERY: 4570 if (brmctx->multicast_router != MDB_RTR_TYPE_TEMP_QUERY) 4571 br_mc_router_state_change(brmctx->br, false); 4572 brmctx->multicast_router = val; 4573 err = 0; 4574 break; 4575 } 4576 4577 spin_unlock_bh(&brmctx->br->multicast_lock); 4578 4579 return err; 4580 } 4581 4582 static void 4583 br_multicast_rport_del_notify(struct net_bridge_mcast_port *pmctx, bool deleted) 4584 { 4585 if (!deleted) 4586 return; 4587 4588 /* For backwards compatibility for now, only notify if there is 4589 * no multicast router anymore for both IPv4 and IPv6. 4590 */ 4591 if (!hlist_unhashed(&pmctx->ip4_rlist)) 4592 return; 4593 #if IS_ENABLED(CONFIG_IPV6) 4594 if (!hlist_unhashed(&pmctx->ip6_rlist)) 4595 return; 4596 #endif 4597 4598 br_rtr_notify(pmctx->port->br->dev, pmctx, RTM_DELMDB); 4599 br_port_mc_router_state_change(pmctx->port, false); 4600 4601 /* don't allow timer refresh */ 4602 if (pmctx->multicast_router == MDB_RTR_TYPE_TEMP) 4603 pmctx->multicast_router = MDB_RTR_TYPE_TEMP_QUERY; 4604 } 4605 4606 int br_multicast_set_port_router(struct net_bridge_mcast_port *pmctx, 4607 unsigned long val) 4608 { 4609 struct net_bridge_mcast *brmctx; 4610 unsigned long now = jiffies; 4611 int err = -EINVAL; 4612 bool del = false; 4613 4614 brmctx = br_multicast_port_ctx_get_global(pmctx); 4615 spin_lock_bh(&brmctx->br->multicast_lock); 4616 if (pmctx->multicast_router == val) { 4617 /* Refresh the temp router port timer */ 4618 if (pmctx->multicast_router == MDB_RTR_TYPE_TEMP) { 4619 mod_timer(&pmctx->ip4_mc_router_timer, 4620 now + brmctx->multicast_querier_interval); 4621 #if IS_ENABLED(CONFIG_IPV6) 4622 mod_timer(&pmctx->ip6_mc_router_timer, 4623 now + brmctx->multicast_querier_interval); 4624 #endif 4625 } 4626 err = 0; 4627 goto unlock; 4628 } 4629 switch (val) { 4630 case MDB_RTR_TYPE_DISABLED: 4631 pmctx->multicast_router = MDB_RTR_TYPE_DISABLED; 4632 del |= br_ip4_multicast_rport_del(pmctx); 4633 timer_delete(&pmctx->ip4_mc_router_timer); 4634 del |= br_ip6_multicast_rport_del(pmctx); 4635 #if IS_ENABLED(CONFIG_IPV6) 4636 timer_delete(&pmctx->ip6_mc_router_timer); 4637 #endif 4638 br_multicast_rport_del_notify(pmctx, del); 4639 break; 4640 case MDB_RTR_TYPE_TEMP_QUERY: 4641 pmctx->multicast_router = MDB_RTR_TYPE_TEMP_QUERY; 4642 del |= br_ip4_multicast_rport_del(pmctx); 4643 del |= br_ip6_multicast_rport_del(pmctx); 4644 br_multicast_rport_del_notify(pmctx, del); 4645 break; 4646 case MDB_RTR_TYPE_PERM: 4647 pmctx->multicast_router = MDB_RTR_TYPE_PERM; 4648 timer_delete(&pmctx->ip4_mc_router_timer); 4649 br_ip4_multicast_add_router(brmctx, pmctx); 4650 #if IS_ENABLED(CONFIG_IPV6) 4651 timer_delete(&pmctx->ip6_mc_router_timer); 4652 #endif 4653 br_ip6_multicast_add_router(brmctx, pmctx); 4654 break; 4655 case MDB_RTR_TYPE_TEMP: 4656 pmctx->multicast_router = MDB_RTR_TYPE_TEMP; 4657 br_ip4_multicast_mark_router(brmctx, pmctx); 4658 br_ip6_multicast_mark_router(brmctx, pmctx); 4659 break; 4660 default: 4661 goto unlock; 4662 } 4663 err = 0; 4664 unlock: 4665 spin_unlock_bh(&brmctx->br->multicast_lock); 4666 4667 return err; 4668 } 4669 4670 int br_multicast_set_vlan_router(struct net_bridge_vlan *v, u8 mcast_router) 4671 { 4672 int err; 4673 4674 if (br_vlan_is_master(v)) 4675 err = br_multicast_set_router(&v->br_mcast_ctx, mcast_router); 4676 else 4677 err = br_multicast_set_port_router(&v->port_mcast_ctx, 4678 mcast_router); 4679 4680 return err; 4681 } 4682 4683 static void br_multicast_start_querier(struct net_bridge_mcast *brmctx, 4684 struct bridge_mcast_own_query *query) 4685 { 4686 struct net_bridge_port *port; 4687 4688 if (!br_multicast_ctx_matches_vlan_snooping(brmctx)) 4689 return; 4690 4691 __br_multicast_open_query(brmctx->br, query); 4692 4693 rcu_read_lock(); 4694 list_for_each_entry_rcu(port, &brmctx->br->port_list, list) { 4695 struct bridge_mcast_own_query *ip4_own_query; 4696 #if IS_ENABLED(CONFIG_IPV6) 4697 struct bridge_mcast_own_query *ip6_own_query; 4698 #endif 4699 4700 if (br_multicast_port_ctx_state_stopped(&port->multicast_ctx)) 4701 continue; 4702 4703 if (br_multicast_ctx_is_vlan(brmctx)) { 4704 struct net_bridge_vlan *vlan; 4705 4706 vlan = br_vlan_find(nbp_vlan_group_rcu(port), 4707 brmctx->vlan->vid); 4708 if (!vlan || 4709 br_multicast_port_ctx_state_stopped(&vlan->port_mcast_ctx)) 4710 continue; 4711 4712 ip4_own_query = &vlan->port_mcast_ctx.ip4_own_query; 4713 #if IS_ENABLED(CONFIG_IPV6) 4714 ip6_own_query = &vlan->port_mcast_ctx.ip6_own_query; 4715 #endif 4716 } else { 4717 ip4_own_query = &port->multicast_ctx.ip4_own_query; 4718 #if IS_ENABLED(CONFIG_IPV6) 4719 ip6_own_query = &port->multicast_ctx.ip6_own_query; 4720 #endif 4721 } 4722 4723 if (query == &brmctx->ip4_own_query) 4724 br_multicast_enable(ip4_own_query); 4725 #if IS_ENABLED(CONFIG_IPV6) 4726 else 4727 br_multicast_enable(ip6_own_query); 4728 #endif 4729 } 4730 rcu_read_unlock(); 4731 } 4732 4733 static void br_multicast_enable_all_ports(struct net_bridge *br) 4734 { 4735 struct net_bridge_port *port; 4736 4737 if (br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) 4738 return; 4739 4740 list_for_each_entry(port, &br->port_list, list) 4741 __br_multicast_enable_port_ctx(&port->multicast_ctx); 4742 } 4743 4744 static void br_multicast_disable_all_ports(struct net_bridge *br) 4745 { 4746 struct net_bridge_port *port; 4747 4748 if (br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) 4749 return; 4750 4751 list_for_each_entry(port, &br->port_list, list) 4752 __br_multicast_disable_port_ctx(&port->multicast_ctx); 4753 } 4754 4755 int br_multicast_toggle(struct net_bridge *br, unsigned long val, 4756 struct netlink_ext_ack *extack) 4757 { 4758 bool change_snoopers = false; 4759 int err = 0; 4760 4761 spin_lock_bh(&br->multicast_lock); 4762 if (!!br_opt_get(br, BROPT_MULTICAST_ENABLED) == !!val) 4763 goto unlock; 4764 4765 err = br_mc_disabled_update(br->dev, val, extack); 4766 if (err == -EOPNOTSUPP) 4767 err = 0; 4768 if (err) 4769 goto unlock; 4770 4771 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, !!val); 4772 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) { 4773 change_snoopers = true; 4774 br_multicast_disable_all_ports(br); 4775 goto unlock; 4776 } 4777 4778 if (!netif_running(br->dev)) 4779 goto unlock; 4780 4781 br_multicast_open(br); 4782 br_multicast_enable_all_ports(br); 4783 4784 change_snoopers = true; 4785 4786 unlock: 4787 spin_unlock_bh(&br->multicast_lock); 4788 4789 /* br_multicast_join_snoopers has the potential to cause 4790 * an MLD Report/Leave to be delivered to br_multicast_rcv, 4791 * which would in turn call br_multicast_add_group, which would 4792 * attempt to acquire multicast_lock. This function should be 4793 * called after the lock has been released to avoid deadlocks on 4794 * multicast_lock. 4795 * 4796 * br_multicast_leave_snoopers does not have the problem since 4797 * br_multicast_rcv first checks BROPT_MULTICAST_ENABLED, and 4798 * returns without calling br_multicast_ipv4/6_rcv if it's not 4799 * enabled. Moved both functions out just for symmetry. 4800 */ 4801 if (change_snoopers) { 4802 if (br_opt_get(br, BROPT_MULTICAST_ENABLED)) 4803 br_multicast_join_snoopers(br); 4804 else 4805 br_multicast_leave_snoopers(br); 4806 } 4807 4808 return err; 4809 } 4810 4811 bool br_multicast_enabled(const struct net_device *dev) 4812 { 4813 struct net_bridge *br = netdev_priv(dev); 4814 4815 return !!br_opt_get(br, BROPT_MULTICAST_ENABLED); 4816 } 4817 EXPORT_SYMBOL_GPL(br_multicast_enabled); 4818 4819 bool br_multicast_router(const struct net_device *dev) 4820 { 4821 struct net_bridge *br = netdev_priv(dev); 4822 bool is_router; 4823 4824 spin_lock_bh(&br->multicast_lock); 4825 is_router = br_multicast_is_router(&br->multicast_ctx, NULL); 4826 spin_unlock_bh(&br->multicast_lock); 4827 return is_router; 4828 } 4829 EXPORT_SYMBOL_GPL(br_multicast_router); 4830 4831 int br_multicast_set_querier(struct net_bridge_mcast *brmctx, unsigned long val) 4832 { 4833 unsigned long max_delay; 4834 4835 val = !!val; 4836 4837 spin_lock_bh(&brmctx->br->multicast_lock); 4838 if (brmctx->multicast_querier == val) 4839 goto unlock; 4840 4841 WRITE_ONCE(brmctx->multicast_querier, val); 4842 if (!val) 4843 goto unlock; 4844 4845 max_delay = brmctx->multicast_query_response_interval; 4846 4847 if (!timer_pending(&brmctx->ip4_other_query.timer)) 4848 mod_timer(&brmctx->ip4_other_query.delay_timer, 4849 jiffies + max_delay); 4850 4851 br_multicast_start_querier(brmctx, &brmctx->ip4_own_query); 4852 4853 #if IS_ENABLED(CONFIG_IPV6) 4854 if (!timer_pending(&brmctx->ip6_other_query.timer)) 4855 mod_timer(&brmctx->ip6_other_query.delay_timer, 4856 jiffies + max_delay); 4857 4858 br_multicast_start_querier(brmctx, &brmctx->ip6_own_query); 4859 #endif 4860 4861 unlock: 4862 spin_unlock_bh(&brmctx->br->multicast_lock); 4863 4864 return 0; 4865 } 4866 4867 int br_multicast_set_igmp_version(struct net_bridge_mcast *brmctx, 4868 unsigned long val) 4869 { 4870 /* Currently we support only version 2 and 3 */ 4871 switch (val) { 4872 case 2: 4873 case 3: 4874 break; 4875 default: 4876 return -EINVAL; 4877 } 4878 4879 spin_lock_bh(&brmctx->br->multicast_lock); 4880 brmctx->multicast_igmp_version = val; 4881 spin_unlock_bh(&brmctx->br->multicast_lock); 4882 4883 return 0; 4884 } 4885 4886 #if IS_ENABLED(CONFIG_IPV6) 4887 int br_multicast_set_mld_version(struct net_bridge_mcast *brmctx, 4888 unsigned long val) 4889 { 4890 /* Currently we support version 1 and 2 */ 4891 switch (val) { 4892 case 1: 4893 case 2: 4894 break; 4895 default: 4896 return -EINVAL; 4897 } 4898 4899 spin_lock_bh(&brmctx->br->multicast_lock); 4900 brmctx->multicast_mld_version = val; 4901 spin_unlock_bh(&brmctx->br->multicast_lock); 4902 4903 return 0; 4904 } 4905 #endif 4906 4907 void br_multicast_set_query_intvl(struct net_bridge_mcast *brmctx, 4908 unsigned long val) 4909 { 4910 unsigned long intvl_jiffies = clock_t_to_jiffies(val); 4911 4912 if (intvl_jiffies < BR_MULTICAST_QUERY_INTVL_MIN) { 4913 br_info(brmctx->br, 4914 "trying to set multicast query interval below minimum, setting to %lu (%ums)\n", 4915 jiffies_to_clock_t(BR_MULTICAST_QUERY_INTVL_MIN), 4916 jiffies_to_msecs(BR_MULTICAST_QUERY_INTVL_MIN)); 4917 intvl_jiffies = BR_MULTICAST_QUERY_INTVL_MIN; 4918 } 4919 4920 if (intvl_jiffies > BR_MULTICAST_QUERY_INTVL_MAX) { 4921 br_info(brmctx->br, 4922 "trying to set multicast query interval above maximum, setting to %lu (%ums)\n", 4923 jiffies_to_clock_t(BR_MULTICAST_QUERY_INTVL_MAX), 4924 jiffies_to_msecs(BR_MULTICAST_QUERY_INTVL_MAX)); 4925 intvl_jiffies = BR_MULTICAST_QUERY_INTVL_MAX; 4926 } 4927 4928 brmctx->multicast_query_interval = intvl_jiffies; 4929 } 4930 4931 void br_multicast_set_startup_query_intvl(struct net_bridge_mcast *brmctx, 4932 unsigned long val) 4933 { 4934 unsigned long intvl_jiffies = clock_t_to_jiffies(val); 4935 4936 if (intvl_jiffies < BR_MULTICAST_STARTUP_QUERY_INTVL_MIN) { 4937 br_info(brmctx->br, 4938 "trying to set multicast startup query interval below minimum, setting to %lu (%ums)\n", 4939 jiffies_to_clock_t(BR_MULTICAST_STARTUP_QUERY_INTVL_MIN), 4940 jiffies_to_msecs(BR_MULTICAST_STARTUP_QUERY_INTVL_MIN)); 4941 intvl_jiffies = BR_MULTICAST_STARTUP_QUERY_INTVL_MIN; 4942 } 4943 4944 if (intvl_jiffies > BR_MULTICAST_STARTUP_QUERY_INTVL_MAX) { 4945 br_info(brmctx->br, 4946 "trying to set multicast startup query interval above maximum, setting to %lu (%ums)\n", 4947 jiffies_to_clock_t(BR_MULTICAST_STARTUP_QUERY_INTVL_MAX), 4948 jiffies_to_msecs(BR_MULTICAST_STARTUP_QUERY_INTVL_MAX)); 4949 intvl_jiffies = BR_MULTICAST_STARTUP_QUERY_INTVL_MAX; 4950 } 4951 4952 brmctx->multicast_startup_query_interval = intvl_jiffies; 4953 } 4954 4955 /** 4956 * br_multicast_list_adjacent - Returns snooped multicast addresses 4957 * @dev: The bridge port adjacent to which to retrieve addresses 4958 * @br_ip_list: The list to store found, snooped multicast IP addresses in 4959 * 4960 * Creates a list of IP addresses (struct br_ip_list) sensed by the multicast 4961 * snooping feature on all bridge ports of dev's bridge device, excluding 4962 * the addresses from dev itself. 4963 * 4964 * Returns the number of items added to br_ip_list. 4965 * 4966 * Notes: 4967 * - br_ip_list needs to be initialized by caller 4968 * - br_ip_list might contain duplicates in the end 4969 * (needs to be taken care of by caller) 4970 * - br_ip_list needs to be freed by caller 4971 */ 4972 int br_multicast_list_adjacent(struct net_device *dev, 4973 struct list_head *br_ip_list) 4974 { 4975 struct net_bridge *br; 4976 struct net_bridge_port *port; 4977 struct net_bridge_port_group *group; 4978 struct br_ip_list *entry; 4979 int count = 0; 4980 4981 rcu_read_lock(); 4982 if (!br_ip_list || !netif_is_bridge_port(dev)) 4983 goto unlock; 4984 4985 port = br_port_get_rcu(dev); 4986 if (!port || !port->br) 4987 goto unlock; 4988 4989 br = port->br; 4990 4991 list_for_each_entry_rcu(port, &br->port_list, list) { 4992 if (!port->dev || port->dev == dev) 4993 continue; 4994 4995 hlist_for_each_entry_rcu(group, &port->mglist, mglist) { 4996 entry = kmalloc_obj(*entry, GFP_ATOMIC); 4997 if (!entry) 4998 goto unlock; 4999 5000 entry->addr = group->key.addr; 5001 list_add(&entry->list, br_ip_list); 5002 count++; 5003 } 5004 } 5005 5006 unlock: 5007 rcu_read_unlock(); 5008 return count; 5009 } 5010 EXPORT_SYMBOL_GPL(br_multicast_list_adjacent); 5011 5012 /** 5013 * br_multicast_has_querier_anywhere - Checks for a querier on a bridge 5014 * @dev: The bridge port providing the bridge on which to check for a querier 5015 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6 5016 * 5017 * Checks whether the given interface has a bridge on top and if so returns 5018 * true if a valid querier exists anywhere on the bridged link layer. 5019 * Otherwise returns false. 5020 */ 5021 bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto) 5022 { 5023 struct net_bridge *br; 5024 struct net_bridge_port *port; 5025 struct ethhdr eth; 5026 bool ret = false; 5027 5028 rcu_read_lock(); 5029 if (!netif_is_bridge_port(dev)) 5030 goto unlock; 5031 5032 port = br_port_get_rcu(dev); 5033 if (!port || !port->br) 5034 goto unlock; 5035 5036 br = port->br; 5037 5038 memset(ð, 0, sizeof(eth)); 5039 eth.h_proto = htons(proto); 5040 5041 ret = br_multicast_querier_exists(&br->multicast_ctx, ð, NULL); 5042 5043 unlock: 5044 rcu_read_unlock(); 5045 return ret; 5046 } 5047 EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere); 5048 5049 /** 5050 * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port 5051 * @dev: The bridge port adjacent to which to check for a querier 5052 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6 5053 * 5054 * Checks whether the given interface has a bridge on top and if so returns 5055 * true if a selected querier is behind one of the other ports of this 5056 * bridge. Otherwise returns false. 5057 */ 5058 bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto) 5059 { 5060 struct net_bridge_mcast *brmctx; 5061 struct net_bridge *br; 5062 struct net_bridge_port *port; 5063 bool ret = false; 5064 int port_ifidx; 5065 5066 rcu_read_lock(); 5067 if (!netif_is_bridge_port(dev)) 5068 goto unlock; 5069 5070 port = br_port_get_rcu(dev); 5071 if (!port || !port->br) 5072 goto unlock; 5073 5074 br = port->br; 5075 brmctx = &br->multicast_ctx; 5076 5077 switch (proto) { 5078 case ETH_P_IP: 5079 port_ifidx = brmctx->ip4_querier.port_ifidx; 5080 if (!timer_pending(&brmctx->ip4_other_query.timer) || 5081 port_ifidx == port->dev->ifindex) 5082 goto unlock; 5083 break; 5084 #if IS_ENABLED(CONFIG_IPV6) 5085 case ETH_P_IPV6: 5086 port_ifidx = brmctx->ip6_querier.port_ifidx; 5087 if (!timer_pending(&brmctx->ip6_other_query.timer) || 5088 port_ifidx == port->dev->ifindex) 5089 goto unlock; 5090 break; 5091 #endif 5092 default: 5093 goto unlock; 5094 } 5095 5096 ret = true; 5097 unlock: 5098 rcu_read_unlock(); 5099 return ret; 5100 } 5101 EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent); 5102 5103 /** 5104 * br_multicast_has_router_adjacent - Checks for a router behind a bridge port 5105 * @dev: The bridge port adjacent to which to check for a multicast router 5106 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6 5107 * 5108 * Checks whether the given interface has a bridge on top and if so returns 5109 * true if a multicast router is behind one of the other ports of this 5110 * bridge. Otherwise returns false. 5111 */ 5112 bool br_multicast_has_router_adjacent(struct net_device *dev, int proto) 5113 { 5114 struct net_bridge_mcast_port *pmctx; 5115 struct net_bridge_mcast *brmctx; 5116 struct net_bridge_port *port; 5117 bool ret = false; 5118 5119 rcu_read_lock(); 5120 port = br_port_get_check_rcu(dev); 5121 if (!port) 5122 goto unlock; 5123 5124 brmctx = &port->br->multicast_ctx; 5125 switch (proto) { 5126 case ETH_P_IP: 5127 hlist_for_each_entry_rcu(pmctx, &brmctx->ip4_mc_router_list, 5128 ip4_rlist) { 5129 if (pmctx->port == port) 5130 continue; 5131 5132 ret = true; 5133 goto unlock; 5134 } 5135 break; 5136 #if IS_ENABLED(CONFIG_IPV6) 5137 case ETH_P_IPV6: 5138 hlist_for_each_entry_rcu(pmctx, &brmctx->ip6_mc_router_list, 5139 ip6_rlist) { 5140 if (pmctx->port == port) 5141 continue; 5142 5143 ret = true; 5144 goto unlock; 5145 } 5146 break; 5147 #endif 5148 default: 5149 /* when compiled without IPv6 support, be conservative and 5150 * always assume presence of an IPv6 multicast router 5151 */ 5152 ret = true; 5153 } 5154 5155 unlock: 5156 rcu_read_unlock(); 5157 return ret; 5158 } 5159 EXPORT_SYMBOL_GPL(br_multicast_has_router_adjacent); 5160 5161 static void br_mcast_stats_add(struct bridge_mcast_stats __percpu *stats, 5162 const struct sk_buff *skb, u8 type, u8 dir) 5163 { 5164 struct bridge_mcast_stats *pstats = this_cpu_ptr(stats); 5165 __be16 proto = skb->protocol; 5166 unsigned int t_len; 5167 5168 u64_stats_update_begin(&pstats->syncp); 5169 switch (proto) { 5170 case htons(ETH_P_IP): 5171 t_len = ntohs(ip_hdr(skb)->tot_len) - ip_hdrlen(skb); 5172 switch (type) { 5173 case IGMP_HOST_MEMBERSHIP_REPORT: 5174 pstats->mstats.igmp_v1reports[dir]++; 5175 break; 5176 case IGMPV2_HOST_MEMBERSHIP_REPORT: 5177 pstats->mstats.igmp_v2reports[dir]++; 5178 break; 5179 case IGMPV3_HOST_MEMBERSHIP_REPORT: 5180 pstats->mstats.igmp_v3reports[dir]++; 5181 break; 5182 case IGMP_HOST_MEMBERSHIP_QUERY: 5183 if (t_len != sizeof(struct igmphdr)) { 5184 pstats->mstats.igmp_v3queries[dir]++; 5185 } else { 5186 unsigned int offset = skb_transport_offset(skb); 5187 struct igmphdr *ih, _ihdr; 5188 5189 ih = skb_header_pointer(skb, offset, 5190 sizeof(_ihdr), &_ihdr); 5191 if (!ih) 5192 break; 5193 if (!ih->code) 5194 pstats->mstats.igmp_v1queries[dir]++; 5195 else 5196 pstats->mstats.igmp_v2queries[dir]++; 5197 } 5198 break; 5199 case IGMP_HOST_LEAVE_MESSAGE: 5200 pstats->mstats.igmp_leaves[dir]++; 5201 break; 5202 } 5203 break; 5204 #if IS_ENABLED(CONFIG_IPV6) 5205 case htons(ETH_P_IPV6): 5206 t_len = ntohs(ipv6_hdr(skb)->payload_len) + 5207 sizeof(struct ipv6hdr); 5208 t_len -= skb_network_header_len(skb); 5209 switch (type) { 5210 case ICMPV6_MGM_REPORT: 5211 pstats->mstats.mld_v1reports[dir]++; 5212 break; 5213 case ICMPV6_MLD2_REPORT: 5214 pstats->mstats.mld_v2reports[dir]++; 5215 break; 5216 case ICMPV6_MGM_QUERY: 5217 if (t_len != sizeof(struct mld_msg)) 5218 pstats->mstats.mld_v2queries[dir]++; 5219 else 5220 pstats->mstats.mld_v1queries[dir]++; 5221 break; 5222 case ICMPV6_MGM_REDUCTION: 5223 pstats->mstats.mld_leaves[dir]++; 5224 break; 5225 } 5226 break; 5227 #endif /* CONFIG_IPV6 */ 5228 } 5229 u64_stats_update_end(&pstats->syncp); 5230 } 5231 5232 void br_multicast_count(struct net_bridge *br, 5233 const struct net_bridge_port *p, 5234 const struct sk_buff *skb, u8 type, u8 dir) 5235 { 5236 struct bridge_mcast_stats __percpu *stats; 5237 5238 /* if multicast_disabled is true then igmp type can't be set */ 5239 if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED)) 5240 return; 5241 5242 if (p) 5243 stats = p->mcast_stats; 5244 else 5245 stats = br->mcast_stats; 5246 if (WARN_ON(!stats)) 5247 return; 5248 5249 br_mcast_stats_add(stats, skb, type, dir); 5250 } 5251 5252 int br_multicast_init_stats(struct net_bridge *br) 5253 { 5254 br->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats); 5255 if (!br->mcast_stats) 5256 return -ENOMEM; 5257 5258 return 0; 5259 } 5260 5261 void br_multicast_uninit_stats(struct net_bridge *br) 5262 { 5263 free_percpu(br->mcast_stats); 5264 } 5265 5266 /* noinline for https://llvm.org/pr45802#c9 */ 5267 static noinline_for_stack void mcast_stats_add_dir(u64 *dst, u64 *src) 5268 { 5269 dst[BR_MCAST_DIR_RX] += src[BR_MCAST_DIR_RX]; 5270 dst[BR_MCAST_DIR_TX] += src[BR_MCAST_DIR_TX]; 5271 } 5272 5273 void br_multicast_get_stats(const struct net_bridge *br, 5274 const struct net_bridge_port *p, 5275 struct br_mcast_stats *dest) 5276 { 5277 struct bridge_mcast_stats __percpu *stats; 5278 struct br_mcast_stats tdst; 5279 int i; 5280 5281 memset(dest, 0, sizeof(*dest)); 5282 if (p) 5283 stats = p->mcast_stats; 5284 else 5285 stats = br->mcast_stats; 5286 if (WARN_ON(!stats)) 5287 return; 5288 5289 memset(&tdst, 0, sizeof(tdst)); 5290 for_each_possible_cpu(i) { 5291 struct bridge_mcast_stats *cpu_stats = per_cpu_ptr(stats, i); 5292 struct br_mcast_stats temp; 5293 unsigned int start; 5294 5295 do { 5296 start = u64_stats_fetch_begin(&cpu_stats->syncp); 5297 u64_stats_copy(&temp, &cpu_stats->mstats, sizeof(temp)); 5298 } while (u64_stats_fetch_retry(&cpu_stats->syncp, start)); 5299 5300 mcast_stats_add_dir(tdst.igmp_v1queries, temp.igmp_v1queries); 5301 mcast_stats_add_dir(tdst.igmp_v2queries, temp.igmp_v2queries); 5302 mcast_stats_add_dir(tdst.igmp_v3queries, temp.igmp_v3queries); 5303 mcast_stats_add_dir(tdst.igmp_leaves, temp.igmp_leaves); 5304 mcast_stats_add_dir(tdst.igmp_v1reports, temp.igmp_v1reports); 5305 mcast_stats_add_dir(tdst.igmp_v2reports, temp.igmp_v2reports); 5306 mcast_stats_add_dir(tdst.igmp_v3reports, temp.igmp_v3reports); 5307 tdst.igmp_parse_errors += temp.igmp_parse_errors; 5308 5309 mcast_stats_add_dir(tdst.mld_v1queries, temp.mld_v1queries); 5310 mcast_stats_add_dir(tdst.mld_v2queries, temp.mld_v2queries); 5311 mcast_stats_add_dir(tdst.mld_leaves, temp.mld_leaves); 5312 mcast_stats_add_dir(tdst.mld_v1reports, temp.mld_v1reports); 5313 mcast_stats_add_dir(tdst.mld_v2reports, temp.mld_v2reports); 5314 tdst.mld_parse_errors += temp.mld_parse_errors; 5315 } 5316 memcpy(dest, &tdst, sizeof(*dest)); 5317 } 5318 5319 int br_mdb_hash_init(struct net_bridge *br) 5320 { 5321 int err; 5322 5323 err = rhashtable_init(&br->sg_port_tbl, &br_sg_port_rht_params); 5324 if (err) 5325 return err; 5326 5327 err = rhashtable_init(&br->mdb_hash_tbl, &br_mdb_rht_params); 5328 if (err) { 5329 rhashtable_destroy(&br->sg_port_tbl); 5330 return err; 5331 } 5332 5333 return 0; 5334 } 5335 5336 void br_mdb_hash_fini(struct net_bridge *br) 5337 { 5338 rhashtable_destroy(&br->sg_port_tbl); 5339 rhashtable_destroy(&br->mdb_hash_tbl); 5340 } 5341