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