1 // SPDX-License-Identifier: GPL-2.0-or-later 2 // Copyright (c) 2020, Nikolay Aleksandrov <nikolay@nvidia.com> 3 #include <linux/err.h> 4 #include <linux/export.h> 5 #include <linux/if_ether.h> 6 #include <linux/igmp.h> 7 #include <linux/in.h> 8 #include <linux/jhash.h> 9 #include <linux/kernel.h> 10 #include <linux/log2.h> 11 #include <linux/netdevice.h> 12 #include <linux/netfilter_bridge.h> 13 #include <linux/random.h> 14 #include <linux/rculist.h> 15 #include <linux/skbuff.h> 16 #include <linux/slab.h> 17 #include <linux/timer.h> 18 #include <linux/inetdevice.h> 19 #include <linux/mroute.h> 20 #include <net/ip.h> 21 #include <net/switchdev.h> 22 #if IS_ENABLED(CONFIG_IPV6) 23 #include <linux/icmpv6.h> 24 #include <net/ipv6.h> 25 #include <net/mld.h> 26 #include <net/ip6_checksum.h> 27 #include <net/addrconf.h> 28 #endif 29 30 #include "br_private.h" 31 #include "br_private_mcast_eht.h" 32 33 static bool br_multicast_del_eht_set_entry(struct net_bridge_port_group *pg, 34 union net_bridge_eht_addr *src_addr, 35 union net_bridge_eht_addr *h_addr); 36 static void br_multicast_create_eht_set_entry(const struct net_bridge_mcast *brmctx, 37 struct net_bridge_port_group *pg, 38 union net_bridge_eht_addr *src_addr, 39 union net_bridge_eht_addr *h_addr, 40 int filter_mode, 41 bool allow_zero_src); 42 43 static struct net_bridge_group_eht_host * 44 br_multicast_eht_host_lookup(struct net_bridge_port_group *pg, 45 union net_bridge_eht_addr *h_addr) 46 { 47 struct rb_node *node = pg->eht_host_tree.rb_node; 48 49 while (node) { 50 struct net_bridge_group_eht_host *this; 51 int result; 52 53 this = rb_entry(node, struct net_bridge_group_eht_host, 54 rb_node); 55 result = memcmp(h_addr, &this->h_addr, sizeof(*h_addr)); 56 if (result < 0) 57 node = node->rb_left; 58 else if (result > 0) 59 node = node->rb_right; 60 else 61 return this; 62 } 63 64 return NULL; 65 } 66 67 static int br_multicast_eht_host_filter_mode(struct net_bridge_port_group *pg, 68 union net_bridge_eht_addr *h_addr) 69 { 70 struct net_bridge_group_eht_host *eht_host; 71 72 eht_host = br_multicast_eht_host_lookup(pg, h_addr); 73 if (!eht_host) 74 return MCAST_INCLUDE; 75 76 return eht_host->filter_mode; 77 } 78 79 static struct net_bridge_group_eht_set_entry * 80 br_multicast_eht_set_entry_lookup(struct net_bridge_group_eht_set *eht_set, 81 union net_bridge_eht_addr *h_addr) 82 { 83 struct rb_node *node = eht_set->entry_tree.rb_node; 84 85 while (node) { 86 struct net_bridge_group_eht_set_entry *this; 87 int result; 88 89 this = rb_entry(node, struct net_bridge_group_eht_set_entry, 90 rb_node); 91 result = memcmp(h_addr, &this->h_addr, sizeof(*h_addr)); 92 if (result < 0) 93 node = node->rb_left; 94 else if (result > 0) 95 node = node->rb_right; 96 else 97 return this; 98 } 99 100 return NULL; 101 } 102 103 static struct net_bridge_group_eht_set * 104 br_multicast_eht_set_lookup(struct net_bridge_port_group *pg, 105 union net_bridge_eht_addr *src_addr) 106 { 107 struct rb_node *node = pg->eht_set_tree.rb_node; 108 109 while (node) { 110 struct net_bridge_group_eht_set *this; 111 int result; 112 113 this = rb_entry(node, struct net_bridge_group_eht_set, 114 rb_node); 115 result = memcmp(src_addr, &this->src_addr, sizeof(*src_addr)); 116 if (result < 0) 117 node = node->rb_left; 118 else if (result > 0) 119 node = node->rb_right; 120 else 121 return this; 122 } 123 124 return NULL; 125 } 126 127 static void __eht_destroy_host(struct net_bridge_group_eht_host *eht_host) 128 { 129 WARN_ON(!hlist_empty(&eht_host->set_entries)); 130 131 br_multicast_eht_hosts_dec(eht_host->pg); 132 133 rb_erase(&eht_host->rb_node, &eht_host->pg->eht_host_tree); 134 RB_CLEAR_NODE(&eht_host->rb_node); 135 kfree(eht_host); 136 } 137 138 static void br_multicast_destroy_eht_set_entry(struct net_bridge_mcast_gc *gc) 139 { 140 struct net_bridge_group_eht_set_entry *set_h; 141 142 set_h = container_of(gc, struct net_bridge_group_eht_set_entry, mcast_gc); 143 WARN_ON(!RB_EMPTY_NODE(&set_h->rb_node)); 144 145 timer_shutdown_sync(&set_h->timer); 146 kfree(set_h); 147 } 148 149 static void br_multicast_destroy_eht_set(struct net_bridge_mcast_gc *gc) 150 { 151 struct net_bridge_group_eht_set *eht_set; 152 153 eht_set = container_of(gc, struct net_bridge_group_eht_set, mcast_gc); 154 WARN_ON(!RB_EMPTY_NODE(&eht_set->rb_node)); 155 WARN_ON(!RB_EMPTY_ROOT(&eht_set->entry_tree)); 156 157 timer_shutdown_sync(&eht_set->timer); 158 kfree(eht_set); 159 } 160 161 static void __eht_del_set_entry(struct net_bridge_group_eht_set_entry *set_h) 162 { 163 struct net_bridge_group_eht_host *eht_host = set_h->h_parent; 164 union net_bridge_eht_addr zero_addr; 165 166 rb_erase(&set_h->rb_node, &set_h->eht_set->entry_tree); 167 RB_CLEAR_NODE(&set_h->rb_node); 168 hlist_del_init(&set_h->host_list); 169 memset(&zero_addr, 0, sizeof(zero_addr)); 170 if (memcmp(&set_h->h_addr, &zero_addr, sizeof(zero_addr))) 171 eht_host->num_entries--; 172 hlist_add_head(&set_h->mcast_gc.gc_node, &set_h->br->mcast_gc_list); 173 queue_work(system_long_wq, &set_h->br->mcast_gc_work); 174 175 if (hlist_empty(&eht_host->set_entries)) 176 __eht_destroy_host(eht_host); 177 } 178 179 static void br_multicast_del_eht_set(struct net_bridge_group_eht_set *eht_set) 180 { 181 struct net_bridge_group_eht_set_entry *set_h; 182 struct rb_node *node; 183 184 while ((node = rb_first(&eht_set->entry_tree))) { 185 set_h = rb_entry(node, struct net_bridge_group_eht_set_entry, 186 rb_node); 187 __eht_del_set_entry(set_h); 188 } 189 190 rb_erase(&eht_set->rb_node, &eht_set->pg->eht_set_tree); 191 RB_CLEAR_NODE(&eht_set->rb_node); 192 hlist_add_head(&eht_set->mcast_gc.gc_node, &eht_set->br->mcast_gc_list); 193 queue_work(system_long_wq, &eht_set->br->mcast_gc_work); 194 } 195 196 void br_multicast_eht_clean_sets(struct net_bridge_port_group *pg) 197 { 198 struct net_bridge_group_eht_set *eht_set; 199 struct rb_node *node; 200 201 while ((node = rb_first(&pg->eht_set_tree))) { 202 eht_set = rb_entry(node, struct net_bridge_group_eht_set, 203 rb_node); 204 br_multicast_del_eht_set(eht_set); 205 } 206 } 207 208 static void br_multicast_eht_set_entry_expired(struct timer_list *t) 209 { 210 struct net_bridge_group_eht_set_entry *set_h = from_timer(set_h, t, timer); 211 struct net_bridge *br = set_h->br; 212 213 spin_lock(&br->multicast_lock); 214 if (RB_EMPTY_NODE(&set_h->rb_node) || timer_pending(&set_h->timer)) 215 goto out; 216 217 br_multicast_del_eht_set_entry(set_h->eht_set->pg, 218 &set_h->eht_set->src_addr, 219 &set_h->h_addr); 220 out: 221 spin_unlock(&br->multicast_lock); 222 } 223 224 static void br_multicast_eht_set_expired(struct timer_list *t) 225 { 226 struct net_bridge_group_eht_set *eht_set = from_timer(eht_set, t, 227 timer); 228 struct net_bridge *br = eht_set->br; 229 230 spin_lock(&br->multicast_lock); 231 if (RB_EMPTY_NODE(&eht_set->rb_node) || timer_pending(&eht_set->timer)) 232 goto out; 233 234 br_multicast_del_eht_set(eht_set); 235 out: 236 spin_unlock(&br->multicast_lock); 237 } 238 239 static struct net_bridge_group_eht_host * 240 __eht_lookup_create_host(struct net_bridge_port_group *pg, 241 union net_bridge_eht_addr *h_addr, 242 unsigned char filter_mode) 243 { 244 struct rb_node **link = &pg->eht_host_tree.rb_node, *parent = NULL; 245 struct net_bridge_group_eht_host *eht_host; 246 247 while (*link) { 248 struct net_bridge_group_eht_host *this; 249 int result; 250 251 this = rb_entry(*link, struct net_bridge_group_eht_host, 252 rb_node); 253 result = memcmp(h_addr, &this->h_addr, sizeof(*h_addr)); 254 parent = *link; 255 if (result < 0) 256 link = &((*link)->rb_left); 257 else if (result > 0) 258 link = &((*link)->rb_right); 259 else 260 return this; 261 } 262 263 if (br_multicast_eht_hosts_over_limit(pg)) 264 return NULL; 265 266 eht_host = kzalloc(sizeof(*eht_host), GFP_ATOMIC); 267 if (!eht_host) 268 return NULL; 269 270 memcpy(&eht_host->h_addr, h_addr, sizeof(*h_addr)); 271 INIT_HLIST_HEAD(&eht_host->set_entries); 272 eht_host->pg = pg; 273 eht_host->filter_mode = filter_mode; 274 275 rb_link_node(&eht_host->rb_node, parent, link); 276 rb_insert_color(&eht_host->rb_node, &pg->eht_host_tree); 277 278 br_multicast_eht_hosts_inc(pg); 279 280 return eht_host; 281 } 282 283 static struct net_bridge_group_eht_set_entry * 284 __eht_lookup_create_set_entry(struct net_bridge *br, 285 struct net_bridge_group_eht_set *eht_set, 286 struct net_bridge_group_eht_host *eht_host, 287 bool allow_zero_src) 288 { 289 struct rb_node **link = &eht_set->entry_tree.rb_node, *parent = NULL; 290 struct net_bridge_group_eht_set_entry *set_h; 291 292 while (*link) { 293 struct net_bridge_group_eht_set_entry *this; 294 int result; 295 296 this = rb_entry(*link, struct net_bridge_group_eht_set_entry, 297 rb_node); 298 result = memcmp(&eht_host->h_addr, &this->h_addr, 299 sizeof(union net_bridge_eht_addr)); 300 parent = *link; 301 if (result < 0) 302 link = &((*link)->rb_left); 303 else if (result > 0) 304 link = &((*link)->rb_right); 305 else 306 return this; 307 } 308 309 /* always allow auto-created zero entry */ 310 if (!allow_zero_src && eht_host->num_entries >= PG_SRC_ENT_LIMIT) 311 return NULL; 312 313 set_h = kzalloc(sizeof(*set_h), GFP_ATOMIC); 314 if (!set_h) 315 return NULL; 316 317 memcpy(&set_h->h_addr, &eht_host->h_addr, 318 sizeof(union net_bridge_eht_addr)); 319 set_h->mcast_gc.destroy = br_multicast_destroy_eht_set_entry; 320 set_h->eht_set = eht_set; 321 set_h->h_parent = eht_host; 322 set_h->br = br; 323 timer_setup(&set_h->timer, br_multicast_eht_set_entry_expired, 0); 324 325 hlist_add_head(&set_h->host_list, &eht_host->set_entries); 326 rb_link_node(&set_h->rb_node, parent, link); 327 rb_insert_color(&set_h->rb_node, &eht_set->entry_tree); 328 /* we must not count the auto-created zero entry otherwise we won't be 329 * able to track the full list of PG_SRC_ENT_LIMIT entries 330 */ 331 if (!allow_zero_src) 332 eht_host->num_entries++; 333 334 return set_h; 335 } 336 337 static struct net_bridge_group_eht_set * 338 __eht_lookup_create_set(struct net_bridge_port_group *pg, 339 union net_bridge_eht_addr *src_addr) 340 { 341 struct rb_node **link = &pg->eht_set_tree.rb_node, *parent = NULL; 342 struct net_bridge_group_eht_set *eht_set; 343 344 while (*link) { 345 struct net_bridge_group_eht_set *this; 346 int result; 347 348 this = rb_entry(*link, struct net_bridge_group_eht_set, 349 rb_node); 350 result = memcmp(src_addr, &this->src_addr, sizeof(*src_addr)); 351 parent = *link; 352 if (result < 0) 353 link = &((*link)->rb_left); 354 else if (result > 0) 355 link = &((*link)->rb_right); 356 else 357 return this; 358 } 359 360 eht_set = kzalloc(sizeof(*eht_set), GFP_ATOMIC); 361 if (!eht_set) 362 return NULL; 363 364 memcpy(&eht_set->src_addr, src_addr, sizeof(*src_addr)); 365 eht_set->mcast_gc.destroy = br_multicast_destroy_eht_set; 366 eht_set->pg = pg; 367 eht_set->br = pg->key.port->br; 368 eht_set->entry_tree = RB_ROOT; 369 timer_setup(&eht_set->timer, br_multicast_eht_set_expired, 0); 370 371 rb_link_node(&eht_set->rb_node, parent, link); 372 rb_insert_color(&eht_set->rb_node, &pg->eht_set_tree); 373 374 return eht_set; 375 } 376 377 static void br_multicast_ip_src_to_eht_addr(const struct br_ip *src, 378 union net_bridge_eht_addr *dest) 379 { 380 switch (src->proto) { 381 case htons(ETH_P_IP): 382 dest->ip4 = src->src.ip4; 383 break; 384 #if IS_ENABLED(CONFIG_IPV6) 385 case htons(ETH_P_IPV6): 386 memcpy(&dest->ip6, &src->src.ip6, sizeof(struct in6_addr)); 387 break; 388 #endif 389 } 390 } 391 392 static void br_eht_convert_host_filter_mode(const struct net_bridge_mcast *brmctx, 393 struct net_bridge_port_group *pg, 394 union net_bridge_eht_addr *h_addr, 395 int filter_mode) 396 { 397 struct net_bridge_group_eht_host *eht_host; 398 union net_bridge_eht_addr zero_addr; 399 400 eht_host = br_multicast_eht_host_lookup(pg, h_addr); 401 if (eht_host) 402 eht_host->filter_mode = filter_mode; 403 404 memset(&zero_addr, 0, sizeof(zero_addr)); 405 switch (filter_mode) { 406 case MCAST_INCLUDE: 407 br_multicast_del_eht_set_entry(pg, &zero_addr, h_addr); 408 break; 409 case MCAST_EXCLUDE: 410 br_multicast_create_eht_set_entry(brmctx, pg, &zero_addr, 411 h_addr, MCAST_EXCLUDE, 412 true); 413 break; 414 } 415 } 416 417 static void br_multicast_create_eht_set_entry(const struct net_bridge_mcast *brmctx, 418 struct net_bridge_port_group *pg, 419 union net_bridge_eht_addr *src_addr, 420 union net_bridge_eht_addr *h_addr, 421 int filter_mode, 422 bool allow_zero_src) 423 { 424 struct net_bridge_group_eht_set_entry *set_h; 425 struct net_bridge_group_eht_host *eht_host; 426 struct net_bridge *br = pg->key.port->br; 427 struct net_bridge_group_eht_set *eht_set; 428 union net_bridge_eht_addr zero_addr; 429 430 memset(&zero_addr, 0, sizeof(zero_addr)); 431 if (!allow_zero_src && !memcmp(src_addr, &zero_addr, sizeof(zero_addr))) 432 return; 433 434 eht_set = __eht_lookup_create_set(pg, src_addr); 435 if (!eht_set) 436 return; 437 438 eht_host = __eht_lookup_create_host(pg, h_addr, filter_mode); 439 if (!eht_host) 440 goto fail_host; 441 442 set_h = __eht_lookup_create_set_entry(br, eht_set, eht_host, 443 allow_zero_src); 444 if (!set_h) 445 goto fail_set_entry; 446 447 mod_timer(&set_h->timer, jiffies + br_multicast_gmi(brmctx)); 448 mod_timer(&eht_set->timer, jiffies + br_multicast_gmi(brmctx)); 449 450 return; 451 452 fail_set_entry: 453 if (hlist_empty(&eht_host->set_entries)) 454 __eht_destroy_host(eht_host); 455 fail_host: 456 if (RB_EMPTY_ROOT(&eht_set->entry_tree)) 457 br_multicast_del_eht_set(eht_set); 458 } 459 460 static bool br_multicast_del_eht_set_entry(struct net_bridge_port_group *pg, 461 union net_bridge_eht_addr *src_addr, 462 union net_bridge_eht_addr *h_addr) 463 { 464 struct net_bridge_group_eht_set_entry *set_h; 465 struct net_bridge_group_eht_set *eht_set; 466 bool set_deleted = false; 467 468 eht_set = br_multicast_eht_set_lookup(pg, src_addr); 469 if (!eht_set) 470 goto out; 471 472 set_h = br_multicast_eht_set_entry_lookup(eht_set, h_addr); 473 if (!set_h) 474 goto out; 475 476 __eht_del_set_entry(set_h); 477 478 if (RB_EMPTY_ROOT(&eht_set->entry_tree)) { 479 br_multicast_del_eht_set(eht_set); 480 set_deleted = true; 481 } 482 483 out: 484 return set_deleted; 485 } 486 487 static void br_multicast_del_eht_host(struct net_bridge_port_group *pg, 488 union net_bridge_eht_addr *h_addr) 489 { 490 struct net_bridge_group_eht_set_entry *set_h; 491 struct net_bridge_group_eht_host *eht_host; 492 struct hlist_node *tmp; 493 494 eht_host = br_multicast_eht_host_lookup(pg, h_addr); 495 if (!eht_host) 496 return; 497 498 hlist_for_each_entry_safe(set_h, tmp, &eht_host->set_entries, host_list) 499 br_multicast_del_eht_set_entry(set_h->eht_set->pg, 500 &set_h->eht_set->src_addr, 501 &set_h->h_addr); 502 } 503 504 /* create new set entries from reports */ 505 static void __eht_create_set_entries(const struct net_bridge_mcast *brmctx, 506 struct net_bridge_port_group *pg, 507 union net_bridge_eht_addr *h_addr, 508 void *srcs, 509 u32 nsrcs, 510 size_t addr_size, 511 int filter_mode) 512 { 513 union net_bridge_eht_addr eht_src_addr; 514 u32 src_idx; 515 516 memset(&eht_src_addr, 0, sizeof(eht_src_addr)); 517 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 518 memcpy(&eht_src_addr, srcs + (src_idx * addr_size), addr_size); 519 br_multicast_create_eht_set_entry(brmctx, pg, &eht_src_addr, 520 h_addr, filter_mode, 521 false); 522 } 523 } 524 525 /* delete existing set entries and their (S,G) entries if they were the last */ 526 static bool __eht_del_set_entries(struct net_bridge_port_group *pg, 527 union net_bridge_eht_addr *h_addr, 528 void *srcs, 529 u32 nsrcs, 530 size_t addr_size) 531 { 532 union net_bridge_eht_addr eht_src_addr; 533 struct net_bridge_group_src *src_ent; 534 bool changed = false; 535 struct br_ip src_ip; 536 u32 src_idx; 537 538 memset(&eht_src_addr, 0, sizeof(eht_src_addr)); 539 memset(&src_ip, 0, sizeof(src_ip)); 540 src_ip.proto = pg->key.addr.proto; 541 for (src_idx = 0; src_idx < nsrcs; src_idx++) { 542 memcpy(&eht_src_addr, srcs + (src_idx * addr_size), addr_size); 543 if (!br_multicast_del_eht_set_entry(pg, &eht_src_addr, h_addr)) 544 continue; 545 memcpy(&src_ip, srcs + (src_idx * addr_size), addr_size); 546 src_ent = br_multicast_find_group_src(pg, &src_ip); 547 if (!src_ent) 548 continue; 549 br_multicast_del_group_src(src_ent, true); 550 changed = true; 551 } 552 553 return changed; 554 } 555 556 static bool br_multicast_eht_allow(const struct net_bridge_mcast *brmctx, 557 struct net_bridge_port_group *pg, 558 union net_bridge_eht_addr *h_addr, 559 void *srcs, 560 u32 nsrcs, 561 size_t addr_size) 562 { 563 bool changed = false; 564 565 switch (br_multicast_eht_host_filter_mode(pg, h_addr)) { 566 case MCAST_INCLUDE: 567 __eht_create_set_entries(brmctx, pg, h_addr, srcs, nsrcs, 568 addr_size, MCAST_INCLUDE); 569 break; 570 case MCAST_EXCLUDE: 571 changed = __eht_del_set_entries(pg, h_addr, srcs, nsrcs, 572 addr_size); 573 break; 574 } 575 576 return changed; 577 } 578 579 static bool br_multicast_eht_block(const struct net_bridge_mcast *brmctx, 580 struct net_bridge_port_group *pg, 581 union net_bridge_eht_addr *h_addr, 582 void *srcs, 583 u32 nsrcs, 584 size_t addr_size) 585 { 586 bool changed = false; 587 588 switch (br_multicast_eht_host_filter_mode(pg, h_addr)) { 589 case MCAST_INCLUDE: 590 changed = __eht_del_set_entries(pg, h_addr, srcs, nsrcs, 591 addr_size); 592 break; 593 case MCAST_EXCLUDE: 594 __eht_create_set_entries(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 595 MCAST_EXCLUDE); 596 break; 597 } 598 599 return changed; 600 } 601 602 /* flush_entries is true when changing mode */ 603 static bool __eht_inc_exc(const struct net_bridge_mcast *brmctx, 604 struct net_bridge_port_group *pg, 605 union net_bridge_eht_addr *h_addr, 606 void *srcs, 607 u32 nsrcs, 608 size_t addr_size, 609 unsigned char filter_mode, 610 bool to_report) 611 { 612 bool changed = false, flush_entries = to_report; 613 union net_bridge_eht_addr eht_src_addr; 614 615 if (br_multicast_eht_host_filter_mode(pg, h_addr) != filter_mode) 616 flush_entries = true; 617 618 memset(&eht_src_addr, 0, sizeof(eht_src_addr)); 619 /* if we're changing mode del host and its entries */ 620 if (flush_entries) 621 br_multicast_del_eht_host(pg, h_addr); 622 __eht_create_set_entries(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 623 filter_mode); 624 /* we can be missing sets only if we've deleted some entries */ 625 if (flush_entries) { 626 struct net_bridge_group_eht_set *eht_set; 627 struct net_bridge_group_src *src_ent; 628 struct hlist_node *tmp; 629 630 hlist_for_each_entry_safe(src_ent, tmp, &pg->src_list, node) { 631 br_multicast_ip_src_to_eht_addr(&src_ent->addr, 632 &eht_src_addr); 633 if (!br_multicast_eht_set_lookup(pg, &eht_src_addr)) { 634 br_multicast_del_group_src(src_ent, true); 635 changed = true; 636 continue; 637 } 638 /* this is an optimization for TO_INCLUDE where we lower 639 * the set's timeout to LMQT to catch timeout hosts: 640 * - host A (timing out): set entries X, Y 641 * - host B: set entry Z (new from current TO_INCLUDE) 642 * sends BLOCK Z after LMQT but host A's EHT 643 * entries still exist (unless lowered to LMQT 644 * so they can timeout with the S,Gs) 645 * => we wait another LMQT, when we can just delete the 646 * group immediately 647 */ 648 if (!(src_ent->flags & BR_SGRP_F_SEND) || 649 filter_mode != MCAST_INCLUDE || 650 !to_report) 651 continue; 652 eht_set = br_multicast_eht_set_lookup(pg, 653 &eht_src_addr); 654 if (!eht_set) 655 continue; 656 mod_timer(&eht_set->timer, jiffies + br_multicast_lmqt(brmctx)); 657 } 658 } 659 660 return changed; 661 } 662 663 static bool br_multicast_eht_inc(const struct net_bridge_mcast *brmctx, 664 struct net_bridge_port_group *pg, 665 union net_bridge_eht_addr *h_addr, 666 void *srcs, 667 u32 nsrcs, 668 size_t addr_size, 669 bool to_report) 670 { 671 bool changed; 672 673 changed = __eht_inc_exc(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 674 MCAST_INCLUDE, to_report); 675 br_eht_convert_host_filter_mode(brmctx, pg, h_addr, MCAST_INCLUDE); 676 677 return changed; 678 } 679 680 static bool br_multicast_eht_exc(const struct net_bridge_mcast *brmctx, 681 struct net_bridge_port_group *pg, 682 union net_bridge_eht_addr *h_addr, 683 void *srcs, 684 u32 nsrcs, 685 size_t addr_size, 686 bool to_report) 687 { 688 bool changed; 689 690 changed = __eht_inc_exc(brmctx, pg, h_addr, srcs, nsrcs, addr_size, 691 MCAST_EXCLUDE, to_report); 692 br_eht_convert_host_filter_mode(brmctx, pg, h_addr, MCAST_EXCLUDE); 693 694 return changed; 695 } 696 697 static bool __eht_ip4_handle(const struct net_bridge_mcast *brmctx, 698 struct net_bridge_port_group *pg, 699 union net_bridge_eht_addr *h_addr, 700 void *srcs, 701 u32 nsrcs, 702 int grec_type) 703 { 704 bool changed = false, to_report = false; 705 706 switch (grec_type) { 707 case IGMPV3_ALLOW_NEW_SOURCES: 708 br_multicast_eht_allow(brmctx, pg, h_addr, srcs, nsrcs, 709 sizeof(__be32)); 710 break; 711 case IGMPV3_BLOCK_OLD_SOURCES: 712 changed = br_multicast_eht_block(brmctx, pg, h_addr, srcs, nsrcs, 713 sizeof(__be32)); 714 break; 715 case IGMPV3_CHANGE_TO_INCLUDE: 716 to_report = true; 717 fallthrough; 718 case IGMPV3_MODE_IS_INCLUDE: 719 changed = br_multicast_eht_inc(brmctx, pg, h_addr, srcs, nsrcs, 720 sizeof(__be32), to_report); 721 break; 722 case IGMPV3_CHANGE_TO_EXCLUDE: 723 to_report = true; 724 fallthrough; 725 case IGMPV3_MODE_IS_EXCLUDE: 726 changed = br_multicast_eht_exc(brmctx, pg, h_addr, srcs, nsrcs, 727 sizeof(__be32), to_report); 728 break; 729 } 730 731 return changed; 732 } 733 734 #if IS_ENABLED(CONFIG_IPV6) 735 static bool __eht_ip6_handle(const struct net_bridge_mcast *brmctx, 736 struct net_bridge_port_group *pg, 737 union net_bridge_eht_addr *h_addr, 738 void *srcs, 739 u32 nsrcs, 740 int grec_type) 741 { 742 bool changed = false, to_report = false; 743 744 switch (grec_type) { 745 case MLD2_ALLOW_NEW_SOURCES: 746 br_multicast_eht_allow(brmctx, pg, h_addr, srcs, nsrcs, 747 sizeof(struct in6_addr)); 748 break; 749 case MLD2_BLOCK_OLD_SOURCES: 750 changed = br_multicast_eht_block(brmctx, pg, h_addr, srcs, nsrcs, 751 sizeof(struct in6_addr)); 752 break; 753 case MLD2_CHANGE_TO_INCLUDE: 754 to_report = true; 755 fallthrough; 756 case MLD2_MODE_IS_INCLUDE: 757 changed = br_multicast_eht_inc(brmctx, pg, h_addr, srcs, nsrcs, 758 sizeof(struct in6_addr), 759 to_report); 760 break; 761 case MLD2_CHANGE_TO_EXCLUDE: 762 to_report = true; 763 fallthrough; 764 case MLD2_MODE_IS_EXCLUDE: 765 changed = br_multicast_eht_exc(brmctx, pg, h_addr, srcs, nsrcs, 766 sizeof(struct in6_addr), 767 to_report); 768 break; 769 } 770 771 return changed; 772 } 773 #endif 774 775 /* true means an entry was deleted */ 776 bool br_multicast_eht_handle(const struct net_bridge_mcast *brmctx, 777 struct net_bridge_port_group *pg, 778 void *h_addr, 779 void *srcs, 780 u32 nsrcs, 781 size_t addr_size, 782 int grec_type) 783 { 784 bool eht_enabled = !!(pg->key.port->flags & BR_MULTICAST_FAST_LEAVE); 785 union net_bridge_eht_addr eht_host_addr; 786 bool changed = false; 787 788 if (!eht_enabled) 789 goto out; 790 791 memset(&eht_host_addr, 0, sizeof(eht_host_addr)); 792 memcpy(&eht_host_addr, h_addr, addr_size); 793 if (addr_size == sizeof(__be32)) 794 changed = __eht_ip4_handle(brmctx, pg, &eht_host_addr, srcs, 795 nsrcs, grec_type); 796 #if IS_ENABLED(CONFIG_IPV6) 797 else 798 changed = __eht_ip6_handle(brmctx, pg, &eht_host_addr, srcs, 799 nsrcs, grec_type); 800 #endif 801 802 out: 803 return changed; 804 } 805 806 int br_multicast_eht_set_hosts_limit(struct net_bridge_port *p, 807 u32 eht_hosts_limit) 808 { 809 struct net_bridge *br = p->br; 810 811 if (!eht_hosts_limit) 812 return -EINVAL; 813 814 spin_lock_bh(&br->multicast_lock); 815 p->multicast_eht_hosts_limit = eht_hosts_limit; 816 spin_unlock_bh(&br->multicast_lock); 817 818 return 0; 819 } 820