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