1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Bridge multicast support.
5 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
9 #include <linux/export.h>
10 #include <linux/if_ether.h>
11 #include <linux/igmp.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>
26 #include <net/switchdev.h>
27 #if IS_ENABLED(CONFIG_IPV6)
28 #include <linux/icmpv6.h>
31 #include <net/ip6_checksum.h>
32 #include <net/addrconf.h>
35 #include "br_private.h"
36 #include "br_private_mcast_eht.h"
38 static const struct rhashtable_params br_mdb_rht_params
= {
39 .head_offset
= offsetof(struct net_bridge_mdb_entry
, rhnode
),
40 .key_offset
= offsetof(struct net_bridge_mdb_entry
, addr
),
41 .key_len
= sizeof(struct br_ip
),
42 .automatic_shrinking
= true,
45 static const struct rhashtable_params br_sg_port_rht_params
= {
46 .head_offset
= offsetof(struct net_bridge_port_group
, rhnode
),
47 .key_offset
= offsetof(struct net_bridge_port_group
, key
),
48 .key_len
= sizeof(struct net_bridge_port_group_sg_key
),
49 .automatic_shrinking
= true,
52 static void br_multicast_start_querier(struct net_bridge
*br
,
53 struct bridge_mcast_own_query
*query
);
54 static void br_ip4_multicast_add_router(struct net_bridge
*br
,
55 struct net_bridge_port
*port
);
56 static void br_ip4_multicast_leave_group(struct net_bridge
*br
,
57 struct net_bridge_port
*port
,
60 const unsigned char *src
);
61 static void br_multicast_port_group_rexmit(struct timer_list
*t
);
64 br_multicast_rport_del_notify(struct net_bridge_port
*p
, bool deleted
);
65 static void br_ip6_multicast_add_router(struct net_bridge
*br
,
66 struct net_bridge_port
*port
);
67 #if IS_ENABLED(CONFIG_IPV6)
68 static void br_ip6_multicast_leave_group(struct net_bridge
*br
,
69 struct net_bridge_port
*port
,
70 const struct in6_addr
*group
,
71 __u16 vid
, const unsigned char *src
);
73 static struct net_bridge_port_group
*
74 __br_multicast_add_group(struct net_bridge
*br
,
75 struct net_bridge_port
*port
,
77 const unsigned char *src
,
81 static void br_multicast_find_del_pg(struct net_bridge
*br
,
82 struct net_bridge_port_group
*pg
);
84 static struct net_bridge_port_group
*
85 br_sg_port_find(struct net_bridge
*br
,
86 struct net_bridge_port_group_sg_key
*sg_p
)
88 lockdep_assert_held_once(&br
->multicast_lock
);
90 return rhashtable_lookup_fast(&br
->sg_port_tbl
, sg_p
,
91 br_sg_port_rht_params
);
94 static struct net_bridge_mdb_entry
*br_mdb_ip_get_rcu(struct net_bridge
*br
,
97 return rhashtable_lookup(&br
->mdb_hash_tbl
, dst
, br_mdb_rht_params
);
100 struct net_bridge_mdb_entry
*br_mdb_ip_get(struct net_bridge
*br
,
103 struct net_bridge_mdb_entry
*ent
;
105 lockdep_assert_held_once(&br
->multicast_lock
);
108 ent
= rhashtable_lookup(&br
->mdb_hash_tbl
, dst
, br_mdb_rht_params
);
114 static struct net_bridge_mdb_entry
*br_mdb_ip4_get(struct net_bridge
*br
,
115 __be32 dst
, __u16 vid
)
119 memset(&br_dst
, 0, sizeof(br_dst
));
120 br_dst
.dst
.ip4
= dst
;
121 br_dst
.proto
= htons(ETH_P_IP
);
124 return br_mdb_ip_get(br
, &br_dst
);
127 #if IS_ENABLED(CONFIG_IPV6)
128 static struct net_bridge_mdb_entry
*br_mdb_ip6_get(struct net_bridge
*br
,
129 const struct in6_addr
*dst
,
134 memset(&br_dst
, 0, sizeof(br_dst
));
135 br_dst
.dst
.ip6
= *dst
;
136 br_dst
.proto
= htons(ETH_P_IPV6
);
139 return br_mdb_ip_get(br
, &br_dst
);
143 struct net_bridge_mdb_entry
*br_mdb_get(struct net_bridge
*br
,
144 struct sk_buff
*skb
, u16 vid
)
148 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
151 if (BR_INPUT_SKB_CB(skb
)->igmp
)
154 memset(&ip
, 0, sizeof(ip
));
155 ip
.proto
= skb
->protocol
;
158 switch (skb
->protocol
) {
159 case htons(ETH_P_IP
):
160 ip
.dst
.ip4
= ip_hdr(skb
)->daddr
;
161 if (br
->multicast_igmp_version
== 3) {
162 struct net_bridge_mdb_entry
*mdb
;
164 ip
.src
.ip4
= ip_hdr(skb
)->saddr
;
165 mdb
= br_mdb_ip_get_rcu(br
, &ip
);
171 #if IS_ENABLED(CONFIG_IPV6)
172 case htons(ETH_P_IPV6
):
173 ip
.dst
.ip6
= ipv6_hdr(skb
)->daddr
;
174 if (br
->multicast_mld_version
== 2) {
175 struct net_bridge_mdb_entry
*mdb
;
177 ip
.src
.ip6
= ipv6_hdr(skb
)->saddr
;
178 mdb
= br_mdb_ip_get_rcu(br
, &ip
);
181 memset(&ip
.src
.ip6
, 0, sizeof(ip
.src
.ip6
));
187 ether_addr_copy(ip
.dst
.mac_addr
, eth_hdr(skb
)->h_dest
);
190 return br_mdb_ip_get_rcu(br
, &ip
);
193 static bool br_port_group_equal(struct net_bridge_port_group
*p
,
194 struct net_bridge_port
*port
,
195 const unsigned char *src
)
197 if (p
->key
.port
!= port
)
200 if (!(port
->flags
& BR_MULTICAST_TO_UNICAST
))
203 return ether_addr_equal(src
, p
->eth_addr
);
206 static void __fwd_add_star_excl(struct net_bridge_port_group
*pg
,
209 struct net_bridge_port_group_sg_key sg_key
;
210 struct net_bridge
*br
= pg
->key
.port
->br
;
211 struct net_bridge_port_group
*src_pg
;
213 memset(&sg_key
, 0, sizeof(sg_key
));
214 sg_key
.port
= pg
->key
.port
;
215 sg_key
.addr
= *sg_ip
;
216 if (br_sg_port_find(br
, &sg_key
))
219 src_pg
= __br_multicast_add_group(br
, pg
->key
.port
, sg_ip
, pg
->eth_addr
,
220 MCAST_INCLUDE
, false, false);
221 if (IS_ERR_OR_NULL(src_pg
) ||
222 src_pg
->rt_protocol
!= RTPROT_KERNEL
)
225 src_pg
->flags
|= MDB_PG_FLAGS_STAR_EXCL
;
228 static void __fwd_del_star_excl(struct net_bridge_port_group
*pg
,
231 struct net_bridge_port_group_sg_key sg_key
;
232 struct net_bridge
*br
= pg
->key
.port
->br
;
233 struct net_bridge_port_group
*src_pg
;
235 memset(&sg_key
, 0, sizeof(sg_key
));
236 sg_key
.port
= pg
->key
.port
;
237 sg_key
.addr
= *sg_ip
;
238 src_pg
= br_sg_port_find(br
, &sg_key
);
239 if (!src_pg
|| !(src_pg
->flags
& MDB_PG_FLAGS_STAR_EXCL
) ||
240 src_pg
->rt_protocol
!= RTPROT_KERNEL
)
243 br_multicast_find_del_pg(br
, src_pg
);
246 /* When a port group transitions to (or is added as) EXCLUDE we need to add it
247 * to all other ports' S,G entries which are not blocked by the current group
248 * for proper replication, the assumption is that any S,G blocked entries
249 * are already added so the S,G,port lookup should skip them.
250 * When a port group transitions from EXCLUDE -> INCLUDE mode or is being
251 * deleted we need to remove it from all ports' S,G entries where it was
252 * automatically installed before (i.e. where it's MDB_PG_FLAGS_STAR_EXCL).
254 void br_multicast_star_g_handle_mode(struct net_bridge_port_group
*pg
,
257 struct net_bridge
*br
= pg
->key
.port
->br
;
258 struct net_bridge_port_group
*pg_lst
;
259 struct net_bridge_mdb_entry
*mp
;
262 if (WARN_ON(!br_multicast_is_star_g(&pg
->key
.addr
)))
265 mp
= br_mdb_ip_get(br
, &pg
->key
.addr
);
269 memset(&sg_ip
, 0, sizeof(sg_ip
));
270 sg_ip
= pg
->key
.addr
;
271 for (pg_lst
= mlock_dereference(mp
->ports
, br
);
273 pg_lst
= mlock_dereference(pg_lst
->next
, br
)) {
274 struct net_bridge_group_src
*src_ent
;
278 hlist_for_each_entry(src_ent
, &pg_lst
->src_list
, node
) {
279 if (!(src_ent
->flags
& BR_SGRP_F_INSTALLED
))
281 sg_ip
.src
= src_ent
->addr
.src
;
282 switch (filter_mode
) {
284 __fwd_del_star_excl(pg
, &sg_ip
);
287 __fwd_add_star_excl(pg
, &sg_ip
);
294 /* called when adding a new S,G with host_joined == false by default */
295 static void br_multicast_sg_host_state(struct net_bridge_mdb_entry
*star_mp
,
296 struct net_bridge_port_group
*sg
)
298 struct net_bridge_mdb_entry
*sg_mp
;
300 if (WARN_ON(!br_multicast_is_star_g(&star_mp
->addr
)))
302 if (!star_mp
->host_joined
)
305 sg_mp
= br_mdb_ip_get(star_mp
->br
, &sg
->key
.addr
);
308 sg_mp
->host_joined
= true;
311 /* set the host_joined state of all of *,G's S,G entries */
312 static void br_multicast_star_g_host_state(struct net_bridge_mdb_entry
*star_mp
)
314 struct net_bridge
*br
= star_mp
->br
;
315 struct net_bridge_mdb_entry
*sg_mp
;
316 struct net_bridge_port_group
*pg
;
319 if (WARN_ON(!br_multicast_is_star_g(&star_mp
->addr
)))
322 memset(&sg_ip
, 0, sizeof(sg_ip
));
323 sg_ip
= star_mp
->addr
;
324 for (pg
= mlock_dereference(star_mp
->ports
, br
);
326 pg
= mlock_dereference(pg
->next
, br
)) {
327 struct net_bridge_group_src
*src_ent
;
329 hlist_for_each_entry(src_ent
, &pg
->src_list
, node
) {
330 if (!(src_ent
->flags
& BR_SGRP_F_INSTALLED
))
332 sg_ip
.src
= src_ent
->addr
.src
;
333 sg_mp
= br_mdb_ip_get(br
, &sg_ip
);
336 sg_mp
->host_joined
= star_mp
->host_joined
;
341 static void br_multicast_sg_del_exclude_ports(struct net_bridge_mdb_entry
*sgmp
)
343 struct net_bridge_port_group __rcu
**pp
;
344 struct net_bridge_port_group
*p
;
346 /* *,G exclude ports are only added to S,G entries */
347 if (WARN_ON(br_multicast_is_star_g(&sgmp
->addr
)))
350 /* we need the STAR_EXCLUDE ports if there are non-STAR_EXCLUDE ports
351 * we should ignore perm entries since they're managed by user-space
353 for (pp
= &sgmp
->ports
;
354 (p
= mlock_dereference(*pp
, sgmp
->br
)) != NULL
;
356 if (!(p
->flags
& (MDB_PG_FLAGS_STAR_EXCL
|
357 MDB_PG_FLAGS_PERMANENT
)))
360 /* currently the host can only have joined the *,G which means
361 * we treat it as EXCLUDE {}, so for an S,G it's considered a
362 * STAR_EXCLUDE entry and we can safely leave it
364 sgmp
->host_joined
= false;
366 for (pp
= &sgmp
->ports
;
367 (p
= mlock_dereference(*pp
, sgmp
->br
)) != NULL
;) {
368 if (!(p
->flags
& MDB_PG_FLAGS_PERMANENT
))
369 br_multicast_del_pg(sgmp
, p
, pp
);
375 void br_multicast_sg_add_exclude_ports(struct net_bridge_mdb_entry
*star_mp
,
376 struct net_bridge_port_group
*sg
)
378 struct net_bridge_port_group_sg_key sg_key
;
379 struct net_bridge
*br
= star_mp
->br
;
380 struct net_bridge_port_group
*pg
;
382 if (WARN_ON(br_multicast_is_star_g(&sg
->key
.addr
)))
384 if (WARN_ON(!br_multicast_is_star_g(&star_mp
->addr
)))
387 br_multicast_sg_host_state(star_mp
, sg
);
388 memset(&sg_key
, 0, sizeof(sg_key
));
389 sg_key
.addr
= sg
->key
.addr
;
390 /* we need to add all exclude ports to the S,G */
391 for (pg
= mlock_dereference(star_mp
->ports
, br
);
393 pg
= mlock_dereference(pg
->next
, br
)) {
394 struct net_bridge_port_group
*src_pg
;
396 if (pg
== sg
|| pg
->filter_mode
== MCAST_INCLUDE
)
399 sg_key
.port
= pg
->key
.port
;
400 if (br_sg_port_find(br
, &sg_key
))
403 src_pg
= __br_multicast_add_group(br
, pg
->key
.port
,
406 MCAST_INCLUDE
, false, false);
407 if (IS_ERR_OR_NULL(src_pg
) ||
408 src_pg
->rt_protocol
!= RTPROT_KERNEL
)
410 src_pg
->flags
|= MDB_PG_FLAGS_STAR_EXCL
;
414 static void br_multicast_fwd_src_add(struct net_bridge_group_src
*src
)
416 struct net_bridge_mdb_entry
*star_mp
;
417 struct net_bridge_port_group
*sg
;
420 if (src
->flags
& BR_SGRP_F_INSTALLED
)
423 memset(&sg_ip
, 0, sizeof(sg_ip
));
424 sg_ip
= src
->pg
->key
.addr
;
425 sg_ip
.src
= src
->addr
.src
;
426 sg
= __br_multicast_add_group(src
->br
, src
->pg
->key
.port
, &sg_ip
,
427 src
->pg
->eth_addr
, MCAST_INCLUDE
, false,
428 !timer_pending(&src
->timer
));
429 if (IS_ERR_OR_NULL(sg
))
431 src
->flags
|= BR_SGRP_F_INSTALLED
;
432 sg
->flags
&= ~MDB_PG_FLAGS_STAR_EXCL
;
434 /* if it was added by user-space as perm we can skip next steps */
435 if (sg
->rt_protocol
!= RTPROT_KERNEL
&&
436 (sg
->flags
& MDB_PG_FLAGS_PERMANENT
))
439 /* the kernel is now responsible for removing this S,G */
440 del_timer(&sg
->timer
);
441 star_mp
= br_mdb_ip_get(src
->br
, &src
->pg
->key
.addr
);
445 br_multicast_sg_add_exclude_ports(star_mp
, sg
);
448 static void br_multicast_fwd_src_remove(struct net_bridge_group_src
*src
,
451 struct net_bridge_port_group
*p
, *pg
= src
->pg
;
452 struct net_bridge_port_group __rcu
**pp
;
453 struct net_bridge_mdb_entry
*mp
;
456 memset(&sg_ip
, 0, sizeof(sg_ip
));
457 sg_ip
= pg
->key
.addr
;
458 sg_ip
.src
= src
->addr
.src
;
460 mp
= br_mdb_ip_get(src
->br
, &sg_ip
);
464 for (pp
= &mp
->ports
;
465 (p
= mlock_dereference(*pp
, src
->br
)) != NULL
;
467 if (!br_port_group_equal(p
, pg
->key
.port
, pg
->eth_addr
))
470 if (p
->rt_protocol
!= RTPROT_KERNEL
&&
471 (p
->flags
& MDB_PG_FLAGS_PERMANENT
))
475 p
->flags
|= MDB_PG_FLAGS_FAST_LEAVE
;
476 br_multicast_del_pg(mp
, p
, pp
);
479 src
->flags
&= ~BR_SGRP_F_INSTALLED
;
482 /* install S,G and based on src's timer enable or disable forwarding */
483 static void br_multicast_fwd_src_handle(struct net_bridge_group_src
*src
)
485 struct net_bridge_port_group_sg_key sg_key
;
486 struct net_bridge_port_group
*sg
;
489 br_multicast_fwd_src_add(src
);
491 memset(&sg_key
, 0, sizeof(sg_key
));
492 sg_key
.addr
= src
->pg
->key
.addr
;
493 sg_key
.addr
.src
= src
->addr
.src
;
494 sg_key
.port
= src
->pg
->key
.port
;
496 sg
= br_sg_port_find(src
->br
, &sg_key
);
497 if (!sg
|| (sg
->flags
& MDB_PG_FLAGS_PERMANENT
))
500 old_flags
= sg
->flags
;
501 if (timer_pending(&src
->timer
))
502 sg
->flags
&= ~MDB_PG_FLAGS_BLOCKED
;
504 sg
->flags
|= MDB_PG_FLAGS_BLOCKED
;
506 if (old_flags
!= sg
->flags
) {
507 struct net_bridge_mdb_entry
*sg_mp
;
509 sg_mp
= br_mdb_ip_get(src
->br
, &sg_key
.addr
);
512 br_mdb_notify(src
->br
->dev
, sg_mp
, sg
, RTM_NEWMDB
);
516 static void br_multicast_destroy_mdb_entry(struct net_bridge_mcast_gc
*gc
)
518 struct net_bridge_mdb_entry
*mp
;
520 mp
= container_of(gc
, struct net_bridge_mdb_entry
, mcast_gc
);
521 WARN_ON(!hlist_unhashed(&mp
->mdb_node
));
524 del_timer_sync(&mp
->timer
);
528 static void br_multicast_del_mdb_entry(struct net_bridge_mdb_entry
*mp
)
530 struct net_bridge
*br
= mp
->br
;
532 rhashtable_remove_fast(&br
->mdb_hash_tbl
, &mp
->rhnode
,
534 hlist_del_init_rcu(&mp
->mdb_node
);
535 hlist_add_head(&mp
->mcast_gc
.gc_node
, &br
->mcast_gc_list
);
536 queue_work(system_long_wq
, &br
->mcast_gc_work
);
539 static void br_multicast_group_expired(struct timer_list
*t
)
541 struct net_bridge_mdb_entry
*mp
= from_timer(mp
, t
, timer
);
542 struct net_bridge
*br
= mp
->br
;
544 spin_lock(&br
->multicast_lock
);
545 if (hlist_unhashed(&mp
->mdb_node
) || !netif_running(br
->dev
) ||
546 timer_pending(&mp
->timer
))
549 br_multicast_host_leave(mp
, true);
553 br_multicast_del_mdb_entry(mp
);
555 spin_unlock(&br
->multicast_lock
);
558 static void br_multicast_destroy_group_src(struct net_bridge_mcast_gc
*gc
)
560 struct net_bridge_group_src
*src
;
562 src
= container_of(gc
, struct net_bridge_group_src
, mcast_gc
);
563 WARN_ON(!hlist_unhashed(&src
->node
));
565 del_timer_sync(&src
->timer
);
569 void br_multicast_del_group_src(struct net_bridge_group_src
*src
,
572 struct net_bridge
*br
= src
->pg
->key
.port
->br
;
574 br_multicast_fwd_src_remove(src
, fastleave
);
575 hlist_del_init_rcu(&src
->node
);
577 hlist_add_head(&src
->mcast_gc
.gc_node
, &br
->mcast_gc_list
);
578 queue_work(system_long_wq
, &br
->mcast_gc_work
);
581 static void br_multicast_destroy_port_group(struct net_bridge_mcast_gc
*gc
)
583 struct net_bridge_port_group
*pg
;
585 pg
= container_of(gc
, struct net_bridge_port_group
, mcast_gc
);
586 WARN_ON(!hlist_unhashed(&pg
->mglist
));
587 WARN_ON(!hlist_empty(&pg
->src_list
));
589 del_timer_sync(&pg
->rexmit_timer
);
590 del_timer_sync(&pg
->timer
);
594 void br_multicast_del_pg(struct net_bridge_mdb_entry
*mp
,
595 struct net_bridge_port_group
*pg
,
596 struct net_bridge_port_group __rcu
**pp
)
598 struct net_bridge
*br
= pg
->key
.port
->br
;
599 struct net_bridge_group_src
*ent
;
600 struct hlist_node
*tmp
;
602 rcu_assign_pointer(*pp
, pg
->next
);
603 hlist_del_init(&pg
->mglist
);
604 br_multicast_eht_clean_sets(pg
);
605 hlist_for_each_entry_safe(ent
, tmp
, &pg
->src_list
, node
)
606 br_multicast_del_group_src(ent
, false);
607 br_mdb_notify(br
->dev
, mp
, pg
, RTM_DELMDB
);
608 if (!br_multicast_is_star_g(&mp
->addr
)) {
609 rhashtable_remove_fast(&br
->sg_port_tbl
, &pg
->rhnode
,
610 br_sg_port_rht_params
);
611 br_multicast_sg_del_exclude_ports(mp
);
613 br_multicast_star_g_handle_mode(pg
, MCAST_INCLUDE
);
615 hlist_add_head(&pg
->mcast_gc
.gc_node
, &br
->mcast_gc_list
);
616 queue_work(system_long_wq
, &br
->mcast_gc_work
);
618 if (!mp
->ports
&& !mp
->host_joined
&& netif_running(br
->dev
))
619 mod_timer(&mp
->timer
, jiffies
);
622 static void br_multicast_find_del_pg(struct net_bridge
*br
,
623 struct net_bridge_port_group
*pg
)
625 struct net_bridge_port_group __rcu
**pp
;
626 struct net_bridge_mdb_entry
*mp
;
627 struct net_bridge_port_group
*p
;
629 mp
= br_mdb_ip_get(br
, &pg
->key
.addr
);
633 for (pp
= &mp
->ports
;
634 (p
= mlock_dereference(*pp
, br
)) != NULL
;
639 br_multicast_del_pg(mp
, pg
, pp
);
646 static void br_multicast_port_group_expired(struct timer_list
*t
)
648 struct net_bridge_port_group
*pg
= from_timer(pg
, t
, timer
);
649 struct net_bridge_group_src
*src_ent
;
650 struct net_bridge
*br
= pg
->key
.port
->br
;
651 struct hlist_node
*tmp
;
654 spin_lock(&br
->multicast_lock
);
655 if (!netif_running(br
->dev
) || timer_pending(&pg
->timer
) ||
656 hlist_unhashed(&pg
->mglist
) || pg
->flags
& MDB_PG_FLAGS_PERMANENT
)
659 changed
= !!(pg
->filter_mode
== MCAST_EXCLUDE
);
660 pg
->filter_mode
= MCAST_INCLUDE
;
661 hlist_for_each_entry_safe(src_ent
, tmp
, &pg
->src_list
, node
) {
662 if (!timer_pending(&src_ent
->timer
)) {
663 br_multicast_del_group_src(src_ent
, false);
668 if (hlist_empty(&pg
->src_list
)) {
669 br_multicast_find_del_pg(br
, pg
);
670 } else if (changed
) {
671 struct net_bridge_mdb_entry
*mp
= br_mdb_ip_get(br
, &pg
->key
.addr
);
673 if (changed
&& br_multicast_is_star_g(&pg
->key
.addr
))
674 br_multicast_star_g_handle_mode(pg
, MCAST_INCLUDE
);
678 br_mdb_notify(br
->dev
, mp
, pg
, RTM_NEWMDB
);
681 spin_unlock(&br
->multicast_lock
);
684 static void br_multicast_gc(struct hlist_head
*head
)
686 struct net_bridge_mcast_gc
*gcent
;
687 struct hlist_node
*tmp
;
689 hlist_for_each_entry_safe(gcent
, tmp
, head
, gc_node
) {
690 hlist_del_init(&gcent
->gc_node
);
691 gcent
->destroy(gcent
);
695 static struct sk_buff
*br_ip4_multicast_alloc_query(struct net_bridge
*br
,
696 struct net_bridge_port_group
*pg
,
697 __be32 ip_dst
, __be32 group
,
698 bool with_srcs
, bool over_lmqt
,
699 u8 sflag
, u8
*igmp_type
,
702 struct net_bridge_port
*p
= pg
? pg
->key
.port
: NULL
;
703 struct net_bridge_group_src
*ent
;
704 size_t pkt_size
, igmp_hdr_size
;
705 unsigned long now
= jiffies
;
706 struct igmpv3_query
*ihv3
;
707 void *csum_start
= NULL
;
708 __sum16
*csum
= NULL
;
716 igmp_hdr_size
= sizeof(*ih
);
717 if (br
->multicast_igmp_version
== 3) {
718 igmp_hdr_size
= sizeof(*ihv3
);
719 if (pg
&& with_srcs
) {
720 lmqt
= now
+ (br
->multicast_last_member_interval
*
721 br
->multicast_last_member_count
);
722 hlist_for_each_entry(ent
, &pg
->src_list
, node
) {
723 if (over_lmqt
== time_after(ent
->timer
.expires
,
725 ent
->src_query_rexmit_cnt
> 0)
731 igmp_hdr_size
+= lmqt_srcs
* sizeof(__be32
);
735 pkt_size
= sizeof(*eth
) + sizeof(*iph
) + 4 + igmp_hdr_size
;
736 if ((p
&& pkt_size
> p
->dev
->mtu
) ||
737 pkt_size
> br
->dev
->mtu
)
740 skb
= netdev_alloc_skb_ip_align(br
->dev
, pkt_size
);
744 skb
->protocol
= htons(ETH_P_IP
);
746 skb_reset_mac_header(skb
);
749 ether_addr_copy(eth
->h_source
, br
->dev
->dev_addr
);
750 ip_eth_mc_map(ip_dst
, eth
->h_dest
);
751 eth
->h_proto
= htons(ETH_P_IP
);
752 skb_put(skb
, sizeof(*eth
));
754 skb_set_network_header(skb
, skb
->len
);
756 iph
->tot_len
= htons(pkt_size
- sizeof(*eth
));
762 iph
->frag_off
= htons(IP_DF
);
764 iph
->protocol
= IPPROTO_IGMP
;
765 iph
->saddr
= br_opt_get(br
, BROPT_MULTICAST_QUERY_USE_IFADDR
) ?
766 inet_select_addr(br
->dev
, 0, RT_SCOPE_LINK
) : 0;
768 ((u8
*)&iph
[1])[0] = IPOPT_RA
;
769 ((u8
*)&iph
[1])[1] = 4;
770 ((u8
*)&iph
[1])[2] = 0;
771 ((u8
*)&iph
[1])[3] = 0;
775 skb_set_transport_header(skb
, skb
->len
);
776 *igmp_type
= IGMP_HOST_MEMBERSHIP_QUERY
;
778 switch (br
->multicast_igmp_version
) {
781 ih
->type
= IGMP_HOST_MEMBERSHIP_QUERY
;
782 ih
->code
= (group
? br
->multicast_last_member_interval
:
783 br
->multicast_query_response_interval
) /
784 (HZ
/ IGMP_TIMER_SCALE
);
788 csum_start
= (void *)ih
;
791 ihv3
= igmpv3_query_hdr(skb
);
792 ihv3
->type
= IGMP_HOST_MEMBERSHIP_QUERY
;
793 ihv3
->code
= (group
? br
->multicast_last_member_interval
:
794 br
->multicast_query_response_interval
) /
795 (HZ
/ IGMP_TIMER_SCALE
);
797 ihv3
->qqic
= br
->multicast_query_interval
/ HZ
;
798 ihv3
->nsrcs
= htons(lmqt_srcs
);
800 ihv3
->suppress
= sflag
;
804 csum_start
= (void *)ihv3
;
805 if (!pg
|| !with_srcs
)
809 hlist_for_each_entry(ent
, &pg
->src_list
, node
) {
810 if (over_lmqt
== time_after(ent
->timer
.expires
,
812 ent
->src_query_rexmit_cnt
> 0) {
813 ihv3
->srcs
[lmqt_srcs
++] = ent
->addr
.src
.ip4
;
814 ent
->src_query_rexmit_cnt
--;
815 if (need_rexmit
&& ent
->src_query_rexmit_cnt
)
819 if (WARN_ON(lmqt_srcs
!= ntohs(ihv3
->nsrcs
))) {
826 if (WARN_ON(!csum
|| !csum_start
)) {
831 *csum
= ip_compute_csum(csum_start
, igmp_hdr_size
);
832 skb_put(skb
, igmp_hdr_size
);
833 __skb_pull(skb
, sizeof(*eth
));
839 #if IS_ENABLED(CONFIG_IPV6)
840 static struct sk_buff
*br_ip6_multicast_alloc_query(struct net_bridge
*br
,
841 struct net_bridge_port_group
*pg
,
842 const struct in6_addr
*ip6_dst
,
843 const struct in6_addr
*group
,
844 bool with_srcs
, bool over_llqt
,
845 u8 sflag
, u8
*igmp_type
,
848 struct net_bridge_port
*p
= pg
? pg
->key
.port
: NULL
;
849 struct net_bridge_group_src
*ent
;
850 size_t pkt_size
, mld_hdr_size
;
851 unsigned long now
= jiffies
;
852 struct mld2_query
*mld2q
;
853 void *csum_start
= NULL
;
854 unsigned long interval
;
855 __sum16
*csum
= NULL
;
856 struct ipv6hdr
*ip6h
;
857 struct mld_msg
*mldq
;
864 mld_hdr_size
= sizeof(*mldq
);
865 if (br
->multicast_mld_version
== 2) {
866 mld_hdr_size
= sizeof(*mld2q
);
867 if (pg
&& with_srcs
) {
868 llqt
= now
+ (br
->multicast_last_member_interval
*
869 br
->multicast_last_member_count
);
870 hlist_for_each_entry(ent
, &pg
->src_list
, node
) {
871 if (over_llqt
== time_after(ent
->timer
.expires
,
873 ent
->src_query_rexmit_cnt
> 0)
879 mld_hdr_size
+= llqt_srcs
* sizeof(struct in6_addr
);
883 pkt_size
= sizeof(*eth
) + sizeof(*ip6h
) + 8 + mld_hdr_size
;
884 if ((p
&& pkt_size
> p
->dev
->mtu
) ||
885 pkt_size
> br
->dev
->mtu
)
888 skb
= netdev_alloc_skb_ip_align(br
->dev
, pkt_size
);
892 skb
->protocol
= htons(ETH_P_IPV6
);
894 /* Ethernet header */
895 skb_reset_mac_header(skb
);
898 ether_addr_copy(eth
->h_source
, br
->dev
->dev_addr
);
899 eth
->h_proto
= htons(ETH_P_IPV6
);
900 skb_put(skb
, sizeof(*eth
));
902 /* IPv6 header + HbH option */
903 skb_set_network_header(skb
, skb
->len
);
904 ip6h
= ipv6_hdr(skb
);
906 *(__force __be32
*)ip6h
= htonl(0x60000000);
907 ip6h
->payload_len
= htons(8 + mld_hdr_size
);
908 ip6h
->nexthdr
= IPPROTO_HOPOPTS
;
910 ip6h
->daddr
= *ip6_dst
;
911 if (ipv6_dev_get_saddr(dev_net(br
->dev
), br
->dev
, &ip6h
->daddr
, 0,
914 br_opt_toggle(br
, BROPT_HAS_IPV6_ADDR
, false);
918 br_opt_toggle(br
, BROPT_HAS_IPV6_ADDR
, true);
919 ipv6_eth_mc_map(&ip6h
->daddr
, eth
->h_dest
);
921 hopopt
= (u8
*)(ip6h
+ 1);
922 hopopt
[0] = IPPROTO_ICMPV6
; /* next hdr */
923 hopopt
[1] = 0; /* length of HbH */
924 hopopt
[2] = IPV6_TLV_ROUTERALERT
; /* Router Alert */
925 hopopt
[3] = 2; /* Length of RA Option */
926 hopopt
[4] = 0; /* Type = 0x0000 (MLD) */
928 hopopt
[6] = IPV6_TLV_PAD1
; /* Pad1 */
929 hopopt
[7] = IPV6_TLV_PAD1
; /* Pad1 */
931 skb_put(skb
, sizeof(*ip6h
) + 8);
934 skb_set_transport_header(skb
, skb
->len
);
935 interval
= ipv6_addr_any(group
) ?
936 br
->multicast_query_response_interval
:
937 br
->multicast_last_member_interval
;
938 *igmp_type
= ICMPV6_MGM_QUERY
;
939 switch (br
->multicast_mld_version
) {
941 mldq
= (struct mld_msg
*)icmp6_hdr(skb
);
942 mldq
->mld_type
= ICMPV6_MGM_QUERY
;
945 mldq
->mld_maxdelay
= htons((u16
)jiffies_to_msecs(interval
));
946 mldq
->mld_reserved
= 0;
947 mldq
->mld_mca
= *group
;
948 csum
= &mldq
->mld_cksum
;
949 csum_start
= (void *)mldq
;
952 mld2q
= (struct mld2_query
*)icmp6_hdr(skb
);
953 mld2q
->mld2q_mrc
= htons((u16
)jiffies_to_msecs(interval
));
954 mld2q
->mld2q_type
= ICMPV6_MGM_QUERY
;
955 mld2q
->mld2q_code
= 0;
956 mld2q
->mld2q_cksum
= 0;
957 mld2q
->mld2q_resv1
= 0;
958 mld2q
->mld2q_resv2
= 0;
959 mld2q
->mld2q_suppress
= sflag
;
960 mld2q
->mld2q_qrv
= 2;
961 mld2q
->mld2q_nsrcs
= htons(llqt_srcs
);
962 mld2q
->mld2q_qqic
= br
->multicast_query_interval
/ HZ
;
963 mld2q
->mld2q_mca
= *group
;
964 csum
= &mld2q
->mld2q_cksum
;
965 csum_start
= (void *)mld2q
;
966 if (!pg
|| !with_srcs
)
970 hlist_for_each_entry(ent
, &pg
->src_list
, node
) {
971 if (over_llqt
== time_after(ent
->timer
.expires
,
973 ent
->src_query_rexmit_cnt
> 0) {
974 mld2q
->mld2q_srcs
[llqt_srcs
++] = ent
->addr
.src
.ip6
;
975 ent
->src_query_rexmit_cnt
--;
976 if (need_rexmit
&& ent
->src_query_rexmit_cnt
)
980 if (WARN_ON(llqt_srcs
!= ntohs(mld2q
->mld2q_nsrcs
))) {
987 if (WARN_ON(!csum
|| !csum_start
)) {
992 *csum
= csum_ipv6_magic(&ip6h
->saddr
, &ip6h
->daddr
, mld_hdr_size
,
994 csum_partial(csum_start
, mld_hdr_size
, 0));
995 skb_put(skb
, mld_hdr_size
);
996 __skb_pull(skb
, sizeof(*eth
));
1003 static struct sk_buff
*br_multicast_alloc_query(struct net_bridge
*br
,
1004 struct net_bridge_port_group
*pg
,
1005 struct br_ip
*ip_dst
,
1006 struct br_ip
*group
,
1007 bool with_srcs
, bool over_lmqt
,
1008 u8 sflag
, u8
*igmp_type
,
1013 switch (group
->proto
) {
1014 case htons(ETH_P_IP
):
1015 ip4_dst
= ip_dst
? ip_dst
->dst
.ip4
: htonl(INADDR_ALLHOSTS_GROUP
);
1016 return br_ip4_multicast_alloc_query(br
, pg
,
1017 ip4_dst
, group
->dst
.ip4
,
1018 with_srcs
, over_lmqt
,
1021 #if IS_ENABLED(CONFIG_IPV6)
1022 case htons(ETH_P_IPV6
): {
1023 struct in6_addr ip6_dst
;
1026 ip6_dst
= ip_dst
->dst
.ip6
;
1028 ipv6_addr_set(&ip6_dst
, htonl(0xff020000), 0, 0,
1031 return br_ip6_multicast_alloc_query(br
, pg
,
1032 &ip6_dst
, &group
->dst
.ip6
,
1033 with_srcs
, over_lmqt
,
1042 struct net_bridge_mdb_entry
*br_multicast_new_group(struct net_bridge
*br
,
1043 struct br_ip
*group
)
1045 struct net_bridge_mdb_entry
*mp
;
1048 mp
= br_mdb_ip_get(br
, group
);
1052 if (atomic_read(&br
->mdb_hash_tbl
.nelems
) >= br
->hash_max
) {
1053 br_opt_toggle(br
, BROPT_MULTICAST_ENABLED
, false);
1054 return ERR_PTR(-E2BIG
);
1057 mp
= kzalloc(sizeof(*mp
), GFP_ATOMIC
);
1059 return ERR_PTR(-ENOMEM
);
1063 mp
->mcast_gc
.destroy
= br_multicast_destroy_mdb_entry
;
1064 timer_setup(&mp
->timer
, br_multicast_group_expired
, 0);
1065 err
= rhashtable_lookup_insert_fast(&br
->mdb_hash_tbl
, &mp
->rhnode
,
1071 hlist_add_head_rcu(&mp
->mdb_node
, &br
->mdb_list
);
1077 static void br_multicast_group_src_expired(struct timer_list
*t
)
1079 struct net_bridge_group_src
*src
= from_timer(src
, t
, timer
);
1080 struct net_bridge_port_group
*pg
;
1081 struct net_bridge
*br
= src
->br
;
1083 spin_lock(&br
->multicast_lock
);
1084 if (hlist_unhashed(&src
->node
) || !netif_running(br
->dev
) ||
1085 timer_pending(&src
->timer
))
1089 if (pg
->filter_mode
== MCAST_INCLUDE
) {
1090 br_multicast_del_group_src(src
, false);
1091 if (!hlist_empty(&pg
->src_list
))
1093 br_multicast_find_del_pg(br
, pg
);
1095 br_multicast_fwd_src_handle(src
);
1099 spin_unlock(&br
->multicast_lock
);
1102 struct net_bridge_group_src
*
1103 br_multicast_find_group_src(struct net_bridge_port_group
*pg
, struct br_ip
*ip
)
1105 struct net_bridge_group_src
*ent
;
1107 switch (ip
->proto
) {
1108 case htons(ETH_P_IP
):
1109 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
1110 if (ip
->src
.ip4
== ent
->addr
.src
.ip4
)
1113 #if IS_ENABLED(CONFIG_IPV6)
1114 case htons(ETH_P_IPV6
):
1115 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
1116 if (!ipv6_addr_cmp(&ent
->addr
.src
.ip6
, &ip
->src
.ip6
))
1125 static struct net_bridge_group_src
*
1126 br_multicast_new_group_src(struct net_bridge_port_group
*pg
, struct br_ip
*src_ip
)
1128 struct net_bridge_group_src
*grp_src
;
1130 if (unlikely(pg
->src_ents
>= PG_SRC_ENT_LIMIT
))
1133 switch (src_ip
->proto
) {
1134 case htons(ETH_P_IP
):
1135 if (ipv4_is_zeronet(src_ip
->src
.ip4
) ||
1136 ipv4_is_multicast(src_ip
->src
.ip4
))
1139 #if IS_ENABLED(CONFIG_IPV6)
1140 case htons(ETH_P_IPV6
):
1141 if (ipv6_addr_any(&src_ip
->src
.ip6
) ||
1142 ipv6_addr_is_multicast(&src_ip
->src
.ip6
))
1148 grp_src
= kzalloc(sizeof(*grp_src
), GFP_ATOMIC
);
1149 if (unlikely(!grp_src
))
1153 grp_src
->br
= pg
->key
.port
->br
;
1154 grp_src
->addr
= *src_ip
;
1155 grp_src
->mcast_gc
.destroy
= br_multicast_destroy_group_src
;
1156 timer_setup(&grp_src
->timer
, br_multicast_group_src_expired
, 0);
1158 hlist_add_head_rcu(&grp_src
->node
, &pg
->src_list
);
1164 struct net_bridge_port_group
*br_multicast_new_port_group(
1165 struct net_bridge_port
*port
,
1166 struct br_ip
*group
,
1167 struct net_bridge_port_group __rcu
*next
,
1168 unsigned char flags
,
1169 const unsigned char *src
,
1173 struct net_bridge_port_group
*p
;
1175 p
= kzalloc(sizeof(*p
), GFP_ATOMIC
);
1179 p
->key
.addr
= *group
;
1182 p
->filter_mode
= filter_mode
;
1183 p
->rt_protocol
= rt_protocol
;
1184 p
->eht_host_tree
= RB_ROOT
;
1185 p
->eht_set_tree
= RB_ROOT
;
1186 p
->mcast_gc
.destroy
= br_multicast_destroy_port_group
;
1187 INIT_HLIST_HEAD(&p
->src_list
);
1189 if (!br_multicast_is_star_g(group
) &&
1190 rhashtable_lookup_insert_fast(&port
->br
->sg_port_tbl
, &p
->rhnode
,
1191 br_sg_port_rht_params
)) {
1196 rcu_assign_pointer(p
->next
, next
);
1197 timer_setup(&p
->timer
, br_multicast_port_group_expired
, 0);
1198 timer_setup(&p
->rexmit_timer
, br_multicast_port_group_rexmit
, 0);
1199 hlist_add_head(&p
->mglist
, &port
->mglist
);
1202 memcpy(p
->eth_addr
, src
, ETH_ALEN
);
1204 eth_broadcast_addr(p
->eth_addr
);
1209 void br_multicast_host_join(struct net_bridge_mdb_entry
*mp
, bool notify
)
1211 if (!mp
->host_joined
) {
1212 mp
->host_joined
= true;
1213 if (br_multicast_is_star_g(&mp
->addr
))
1214 br_multicast_star_g_host_state(mp
);
1216 br_mdb_notify(mp
->br
->dev
, mp
, NULL
, RTM_NEWMDB
);
1219 if (br_group_is_l2(&mp
->addr
))
1222 mod_timer(&mp
->timer
, jiffies
+ mp
->br
->multicast_membership_interval
);
1225 void br_multicast_host_leave(struct net_bridge_mdb_entry
*mp
, bool notify
)
1227 if (!mp
->host_joined
)
1230 mp
->host_joined
= false;
1231 if (br_multicast_is_star_g(&mp
->addr
))
1232 br_multicast_star_g_host_state(mp
);
1234 br_mdb_notify(mp
->br
->dev
, mp
, NULL
, RTM_DELMDB
);
1237 static struct net_bridge_port_group
*
1238 __br_multicast_add_group(struct net_bridge
*br
,
1239 struct net_bridge_port
*port
,
1240 struct br_ip
*group
,
1241 const unsigned char *src
,
1246 struct net_bridge_port_group __rcu
**pp
;
1247 struct net_bridge_port_group
*p
= NULL
;
1248 struct net_bridge_mdb_entry
*mp
;
1249 unsigned long now
= jiffies
;
1251 if (!netif_running(br
->dev
) ||
1252 (port
&& port
->state
== BR_STATE_DISABLED
))
1255 mp
= br_multicast_new_group(br
, group
);
1257 return ERR_CAST(mp
);
1260 br_multicast_host_join(mp
, true);
1264 for (pp
= &mp
->ports
;
1265 (p
= mlock_dereference(*pp
, br
)) != NULL
;
1267 if (br_port_group_equal(p
, port
, src
))
1269 if ((unsigned long)p
->key
.port
< (unsigned long)port
)
1273 p
= br_multicast_new_port_group(port
, group
, *pp
, 0, src
,
1274 filter_mode
, RTPROT_KERNEL
);
1276 p
= ERR_PTR(-ENOMEM
);
1279 rcu_assign_pointer(*pp
, p
);
1281 p
->flags
|= MDB_PG_FLAGS_BLOCKED
;
1282 br_mdb_notify(br
->dev
, mp
, p
, RTM_NEWMDB
);
1286 mod_timer(&p
->timer
, now
+ br
->multicast_membership_interval
);
1292 static int br_multicast_add_group(struct net_bridge
*br
,
1293 struct net_bridge_port
*port
,
1294 struct br_ip
*group
,
1295 const unsigned char *src
,
1299 struct net_bridge_port_group
*pg
;
1302 spin_lock(&br
->multicast_lock
);
1303 pg
= __br_multicast_add_group(br
, port
, group
, src
, filter_mode
,
1304 igmpv2_mldv1
, false);
1305 /* NULL is considered valid for host joined groups */
1306 err
= PTR_ERR_OR_ZERO(pg
);
1307 spin_unlock(&br
->multicast_lock
);
1312 static int br_ip4_multicast_add_group(struct net_bridge
*br
,
1313 struct net_bridge_port
*port
,
1316 const unsigned char *src
,
1319 struct br_ip br_group
;
1322 if (ipv4_is_local_multicast(group
))
1325 memset(&br_group
, 0, sizeof(br_group
));
1326 br_group
.dst
.ip4
= group
;
1327 br_group
.proto
= htons(ETH_P_IP
);
1329 filter_mode
= igmpv2
? MCAST_EXCLUDE
: MCAST_INCLUDE
;
1331 return br_multicast_add_group(br
, port
, &br_group
, src
, filter_mode
,
1335 #if IS_ENABLED(CONFIG_IPV6)
1336 static int br_ip6_multicast_add_group(struct net_bridge
*br
,
1337 struct net_bridge_port
*port
,
1338 const struct in6_addr
*group
,
1340 const unsigned char *src
,
1343 struct br_ip br_group
;
1346 if (ipv6_addr_is_ll_all_nodes(group
))
1349 memset(&br_group
, 0, sizeof(br_group
));
1350 br_group
.dst
.ip6
= *group
;
1351 br_group
.proto
= htons(ETH_P_IPV6
);
1353 filter_mode
= mldv1
? MCAST_EXCLUDE
: MCAST_INCLUDE
;
1355 return br_multicast_add_group(br
, port
, &br_group
, src
, filter_mode
,
1360 static bool br_multicast_rport_del(struct hlist_node
*rlist
)
1362 if (hlist_unhashed(rlist
))
1365 hlist_del_init_rcu(rlist
);
1369 static bool br_ip4_multicast_rport_del(struct net_bridge_port
*p
)
1371 return br_multicast_rport_del(&p
->ip4_rlist
);
1374 static bool br_ip6_multicast_rport_del(struct net_bridge_port
*p
)
1376 #if IS_ENABLED(CONFIG_IPV6)
1377 return br_multicast_rport_del(&p
->ip6_rlist
);
1383 static void br_multicast_router_expired(struct net_bridge_port
*port
,
1384 struct timer_list
*t
,
1385 struct hlist_node
*rlist
)
1387 struct net_bridge
*br
= port
->br
;
1390 spin_lock(&br
->multicast_lock
);
1391 if (port
->multicast_router
== MDB_RTR_TYPE_DISABLED
||
1392 port
->multicast_router
== MDB_RTR_TYPE_PERM
||
1396 del
= br_multicast_rport_del(rlist
);
1397 br_multicast_rport_del_notify(port
, del
);
1399 spin_unlock(&br
->multicast_lock
);
1402 static void br_ip4_multicast_router_expired(struct timer_list
*t
)
1404 struct net_bridge_port
*port
= from_timer(port
, t
, ip4_mc_router_timer
);
1406 br_multicast_router_expired(port
, t
, &port
->ip4_rlist
);
1409 #if IS_ENABLED(CONFIG_IPV6)
1410 static void br_ip6_multicast_router_expired(struct timer_list
*t
)
1412 struct net_bridge_port
*port
= from_timer(port
, t
, ip6_mc_router_timer
);
1414 br_multicast_router_expired(port
, t
, &port
->ip6_rlist
);
1418 static void br_mc_router_state_change(struct net_bridge
*p
,
1421 struct switchdev_attr attr
= {
1423 .id
= SWITCHDEV_ATTR_ID_BRIDGE_MROUTER
,
1424 .flags
= SWITCHDEV_F_DEFER
,
1425 .u
.mrouter
= is_mc_router
,
1428 switchdev_port_attr_set(p
->dev
, &attr
, NULL
);
1431 static void br_multicast_local_router_expired(struct net_bridge
*br
,
1432 struct timer_list
*timer
)
1434 spin_lock(&br
->multicast_lock
);
1435 if (br
->multicast_router
== MDB_RTR_TYPE_DISABLED
||
1436 br
->multicast_router
== MDB_RTR_TYPE_PERM
||
1437 br_ip4_multicast_is_router(br
) ||
1438 br_ip6_multicast_is_router(br
))
1441 br_mc_router_state_change(br
, false);
1443 spin_unlock(&br
->multicast_lock
);
1446 static void br_ip4_multicast_local_router_expired(struct timer_list
*t
)
1448 struct net_bridge
*br
= from_timer(br
, t
, ip4_mc_router_timer
);
1450 br_multicast_local_router_expired(br
, t
);
1453 #if IS_ENABLED(CONFIG_IPV6)
1454 static void br_ip6_multicast_local_router_expired(struct timer_list
*t
)
1456 struct net_bridge
*br
= from_timer(br
, t
, ip6_mc_router_timer
);
1458 br_multicast_local_router_expired(br
, t
);
1462 static void br_multicast_querier_expired(struct net_bridge
*br
,
1463 struct bridge_mcast_own_query
*query
)
1465 spin_lock(&br
->multicast_lock
);
1466 if (!netif_running(br
->dev
) || !br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
1469 br_multicast_start_querier(br
, query
);
1472 spin_unlock(&br
->multicast_lock
);
1475 static void br_ip4_multicast_querier_expired(struct timer_list
*t
)
1477 struct net_bridge
*br
= from_timer(br
, t
, ip4_other_query
.timer
);
1479 br_multicast_querier_expired(br
, &br
->ip4_own_query
);
1482 #if IS_ENABLED(CONFIG_IPV6)
1483 static void br_ip6_multicast_querier_expired(struct timer_list
*t
)
1485 struct net_bridge
*br
= from_timer(br
, t
, ip6_other_query
.timer
);
1487 br_multicast_querier_expired(br
, &br
->ip6_own_query
);
1491 static void br_multicast_select_own_querier(struct net_bridge
*br
,
1493 struct sk_buff
*skb
)
1495 if (ip
->proto
== htons(ETH_P_IP
))
1496 br
->ip4_querier
.addr
.src
.ip4
= ip_hdr(skb
)->saddr
;
1497 #if IS_ENABLED(CONFIG_IPV6)
1499 br
->ip6_querier
.addr
.src
.ip6
= ipv6_hdr(skb
)->saddr
;
1503 static void __br_multicast_send_query(struct net_bridge
*br
,
1504 struct net_bridge_port
*port
,
1505 struct net_bridge_port_group
*pg
,
1506 struct br_ip
*ip_dst
,
1507 struct br_ip
*group
,
1512 bool over_lmqt
= !!sflag
;
1513 struct sk_buff
*skb
;
1517 skb
= br_multicast_alloc_query(br
, pg
, ip_dst
, group
, with_srcs
,
1518 over_lmqt
, sflag
, &igmp_type
,
1524 skb
->dev
= port
->dev
;
1525 br_multicast_count(br
, port
, skb
, igmp_type
,
1527 NF_HOOK(NFPROTO_BRIDGE
, NF_BR_LOCAL_OUT
,
1528 dev_net(port
->dev
), NULL
, skb
, NULL
, skb
->dev
,
1529 br_dev_queue_push_xmit
);
1531 if (over_lmqt
&& with_srcs
&& sflag
) {
1533 goto again_under_lmqt
;
1536 br_multicast_select_own_querier(br
, group
, skb
);
1537 br_multicast_count(br
, port
, skb
, igmp_type
,
1543 static void br_multicast_send_query(struct net_bridge
*br
,
1544 struct net_bridge_port
*port
,
1545 struct bridge_mcast_own_query
*own_query
)
1547 struct bridge_mcast_other_query
*other_query
= NULL
;
1548 struct br_ip br_group
;
1551 if (!netif_running(br
->dev
) ||
1552 !br_opt_get(br
, BROPT_MULTICAST_ENABLED
) ||
1553 !br_opt_get(br
, BROPT_MULTICAST_QUERIER
))
1556 memset(&br_group
.dst
, 0, sizeof(br_group
.dst
));
1558 if (port
? (own_query
== &port
->ip4_own_query
) :
1559 (own_query
== &br
->ip4_own_query
)) {
1560 other_query
= &br
->ip4_other_query
;
1561 br_group
.proto
= htons(ETH_P_IP
);
1562 #if IS_ENABLED(CONFIG_IPV6)
1564 other_query
= &br
->ip6_other_query
;
1565 br_group
.proto
= htons(ETH_P_IPV6
);
1569 if (!other_query
|| timer_pending(&other_query
->timer
))
1572 __br_multicast_send_query(br
, port
, NULL
, NULL
, &br_group
, false, 0,
1576 time
+= own_query
->startup_sent
< br
->multicast_startup_query_count
?
1577 br
->multicast_startup_query_interval
:
1578 br
->multicast_query_interval
;
1579 mod_timer(&own_query
->timer
, time
);
1583 br_multicast_port_query_expired(struct net_bridge_port
*port
,
1584 struct bridge_mcast_own_query
*query
)
1586 struct net_bridge
*br
= port
->br
;
1588 spin_lock(&br
->multicast_lock
);
1589 if (port
->state
== BR_STATE_DISABLED
||
1590 port
->state
== BR_STATE_BLOCKING
)
1593 if (query
->startup_sent
< br
->multicast_startup_query_count
)
1594 query
->startup_sent
++;
1596 br_multicast_send_query(port
->br
, port
, query
);
1599 spin_unlock(&br
->multicast_lock
);
1602 static void br_ip4_multicast_port_query_expired(struct timer_list
*t
)
1604 struct net_bridge_port
*port
= from_timer(port
, t
, ip4_own_query
.timer
);
1606 br_multicast_port_query_expired(port
, &port
->ip4_own_query
);
1609 #if IS_ENABLED(CONFIG_IPV6)
1610 static void br_ip6_multicast_port_query_expired(struct timer_list
*t
)
1612 struct net_bridge_port
*port
= from_timer(port
, t
, ip6_own_query
.timer
);
1614 br_multicast_port_query_expired(port
, &port
->ip6_own_query
);
1618 static void br_multicast_port_group_rexmit(struct timer_list
*t
)
1620 struct net_bridge_port_group
*pg
= from_timer(pg
, t
, rexmit_timer
);
1621 struct bridge_mcast_other_query
*other_query
= NULL
;
1622 struct net_bridge
*br
= pg
->key
.port
->br
;
1623 bool need_rexmit
= false;
1625 spin_lock(&br
->multicast_lock
);
1626 if (!netif_running(br
->dev
) || hlist_unhashed(&pg
->mglist
) ||
1627 !br_opt_get(br
, BROPT_MULTICAST_ENABLED
) ||
1628 !br_opt_get(br
, BROPT_MULTICAST_QUERIER
))
1631 if (pg
->key
.addr
.proto
== htons(ETH_P_IP
))
1632 other_query
= &br
->ip4_other_query
;
1633 #if IS_ENABLED(CONFIG_IPV6)
1635 other_query
= &br
->ip6_other_query
;
1638 if (!other_query
|| timer_pending(&other_query
->timer
))
1641 if (pg
->grp_query_rexmit_cnt
) {
1642 pg
->grp_query_rexmit_cnt
--;
1643 __br_multicast_send_query(br
, pg
->key
.port
, pg
, &pg
->key
.addr
,
1644 &pg
->key
.addr
, false, 1, NULL
);
1646 __br_multicast_send_query(br
, pg
->key
.port
, pg
, &pg
->key
.addr
,
1647 &pg
->key
.addr
, true, 0, &need_rexmit
);
1649 if (pg
->grp_query_rexmit_cnt
|| need_rexmit
)
1650 mod_timer(&pg
->rexmit_timer
, jiffies
+
1651 br
->multicast_last_member_interval
);
1653 spin_unlock(&br
->multicast_lock
);
1656 static int br_mc_disabled_update(struct net_device
*dev
, bool value
,
1657 struct netlink_ext_ack
*extack
)
1659 struct switchdev_attr attr
= {
1661 .id
= SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED
,
1662 .flags
= SWITCHDEV_F_DEFER
,
1663 .u
.mc_disabled
= !value
,
1666 return switchdev_port_attr_set(dev
, &attr
, extack
);
1669 int br_multicast_add_port(struct net_bridge_port
*port
)
1673 port
->multicast_router
= MDB_RTR_TYPE_TEMP_QUERY
;
1674 port
->multicast_eht_hosts_limit
= BR_MCAST_DEFAULT_EHT_HOSTS_LIMIT
;
1676 timer_setup(&port
->ip4_mc_router_timer
,
1677 br_ip4_multicast_router_expired
, 0);
1678 timer_setup(&port
->ip4_own_query
.timer
,
1679 br_ip4_multicast_port_query_expired
, 0);
1680 #if IS_ENABLED(CONFIG_IPV6)
1681 timer_setup(&port
->ip6_mc_router_timer
,
1682 br_ip6_multicast_router_expired
, 0);
1683 timer_setup(&port
->ip6_own_query
.timer
,
1684 br_ip6_multicast_port_query_expired
, 0);
1686 err
= br_mc_disabled_update(port
->dev
,
1687 br_opt_get(port
->br
,
1688 BROPT_MULTICAST_ENABLED
),
1690 if (err
&& err
!= -EOPNOTSUPP
)
1693 port
->mcast_stats
= netdev_alloc_pcpu_stats(struct bridge_mcast_stats
);
1694 if (!port
->mcast_stats
)
1700 void br_multicast_del_port(struct net_bridge_port
*port
)
1702 struct net_bridge
*br
= port
->br
;
1703 struct net_bridge_port_group
*pg
;
1704 HLIST_HEAD(deleted_head
);
1705 struct hlist_node
*n
;
1707 /* Take care of the remaining groups, only perm ones should be left */
1708 spin_lock_bh(&br
->multicast_lock
);
1709 hlist_for_each_entry_safe(pg
, n
, &port
->mglist
, mglist
)
1710 br_multicast_find_del_pg(br
, pg
);
1711 hlist_move_list(&br
->mcast_gc_list
, &deleted_head
);
1712 spin_unlock_bh(&br
->multicast_lock
);
1713 br_multicast_gc(&deleted_head
);
1714 del_timer_sync(&port
->ip4_mc_router_timer
);
1715 #if IS_ENABLED(CONFIG_IPV6)
1716 del_timer_sync(&port
->ip6_mc_router_timer
);
1718 free_percpu(port
->mcast_stats
);
1721 static void br_multicast_enable(struct bridge_mcast_own_query
*query
)
1723 query
->startup_sent
= 0;
1725 if (try_to_del_timer_sync(&query
->timer
) >= 0 ||
1726 del_timer(&query
->timer
))
1727 mod_timer(&query
->timer
, jiffies
);
1730 static void __br_multicast_enable_port(struct net_bridge_port
*port
)
1732 struct net_bridge
*br
= port
->br
;
1734 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
) || !netif_running(br
->dev
))
1737 br_multicast_enable(&port
->ip4_own_query
);
1738 #if IS_ENABLED(CONFIG_IPV6)
1739 br_multicast_enable(&port
->ip6_own_query
);
1741 if (port
->multicast_router
== MDB_RTR_TYPE_PERM
) {
1742 br_ip4_multicast_add_router(br
, port
);
1743 br_ip6_multicast_add_router(br
, port
);
1747 void br_multicast_enable_port(struct net_bridge_port
*port
)
1749 struct net_bridge
*br
= port
->br
;
1751 spin_lock(&br
->multicast_lock
);
1752 __br_multicast_enable_port(port
);
1753 spin_unlock(&br
->multicast_lock
);
1756 void br_multicast_disable_port(struct net_bridge_port
*port
)
1758 struct net_bridge
*br
= port
->br
;
1759 struct net_bridge_port_group
*pg
;
1760 struct hlist_node
*n
;
1763 spin_lock(&br
->multicast_lock
);
1764 hlist_for_each_entry_safe(pg
, n
, &port
->mglist
, mglist
)
1765 if (!(pg
->flags
& MDB_PG_FLAGS_PERMANENT
))
1766 br_multicast_find_del_pg(br
, pg
);
1768 del
|= br_ip4_multicast_rport_del(port
);
1769 del_timer(&port
->ip4_mc_router_timer
);
1770 del_timer(&port
->ip4_own_query
.timer
);
1771 del
|= br_ip6_multicast_rport_del(port
);
1772 #if IS_ENABLED(CONFIG_IPV6)
1773 del_timer(&port
->ip6_mc_router_timer
);
1774 del_timer(&port
->ip6_own_query
.timer
);
1776 br_multicast_rport_del_notify(port
, del
);
1777 spin_unlock(&br
->multicast_lock
);
1780 static int __grp_src_delete_marked(struct net_bridge_port_group
*pg
)
1782 struct net_bridge_group_src
*ent
;
1783 struct hlist_node
*tmp
;
1786 hlist_for_each_entry_safe(ent
, tmp
, &pg
->src_list
, node
)
1787 if (ent
->flags
& BR_SGRP_F_DELETE
) {
1788 br_multicast_del_group_src(ent
, false);
1795 static void __grp_src_mod_timer(struct net_bridge_group_src
*src
,
1796 unsigned long expires
)
1798 mod_timer(&src
->timer
, expires
);
1799 br_multicast_fwd_src_handle(src
);
1802 static void __grp_src_query_marked_and_rexmit(struct net_bridge_port_group
*pg
)
1804 struct bridge_mcast_other_query
*other_query
= NULL
;
1805 struct net_bridge
*br
= pg
->key
.port
->br
;
1806 u32 lmqc
= br
->multicast_last_member_count
;
1807 unsigned long lmqt
, lmi
, now
= jiffies
;
1808 struct net_bridge_group_src
*ent
;
1810 if (!netif_running(br
->dev
) ||
1811 !br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
1814 if (pg
->key
.addr
.proto
== htons(ETH_P_IP
))
1815 other_query
= &br
->ip4_other_query
;
1816 #if IS_ENABLED(CONFIG_IPV6)
1818 other_query
= &br
->ip6_other_query
;
1821 lmqt
= now
+ br_multicast_lmqt(br
);
1822 hlist_for_each_entry(ent
, &pg
->src_list
, node
) {
1823 if (ent
->flags
& BR_SGRP_F_SEND
) {
1824 ent
->flags
&= ~BR_SGRP_F_SEND
;
1825 if (ent
->timer
.expires
> lmqt
) {
1826 if (br_opt_get(br
, BROPT_MULTICAST_QUERIER
) &&
1828 !timer_pending(&other_query
->timer
))
1829 ent
->src_query_rexmit_cnt
= lmqc
;
1830 __grp_src_mod_timer(ent
, lmqt
);
1835 if (!br_opt_get(br
, BROPT_MULTICAST_QUERIER
) ||
1836 !other_query
|| timer_pending(&other_query
->timer
))
1839 __br_multicast_send_query(br
, pg
->key
.port
, pg
, &pg
->key
.addr
,
1840 &pg
->key
.addr
, true, 1, NULL
);
1842 lmi
= now
+ br
->multicast_last_member_interval
;
1843 if (!timer_pending(&pg
->rexmit_timer
) ||
1844 time_after(pg
->rexmit_timer
.expires
, lmi
))
1845 mod_timer(&pg
->rexmit_timer
, lmi
);
1848 static void __grp_send_query_and_rexmit(struct net_bridge_port_group
*pg
)
1850 struct bridge_mcast_other_query
*other_query
= NULL
;
1851 struct net_bridge
*br
= pg
->key
.port
->br
;
1852 unsigned long now
= jiffies
, lmi
;
1854 if (!netif_running(br
->dev
) ||
1855 !br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
1858 if (pg
->key
.addr
.proto
== htons(ETH_P_IP
))
1859 other_query
= &br
->ip4_other_query
;
1860 #if IS_ENABLED(CONFIG_IPV6)
1862 other_query
= &br
->ip6_other_query
;
1865 if (br_opt_get(br
, BROPT_MULTICAST_QUERIER
) &&
1866 other_query
&& !timer_pending(&other_query
->timer
)) {
1867 lmi
= now
+ br
->multicast_last_member_interval
;
1868 pg
->grp_query_rexmit_cnt
= br
->multicast_last_member_count
- 1;
1869 __br_multicast_send_query(br
, pg
->key
.port
, pg
, &pg
->key
.addr
,
1870 &pg
->key
.addr
, false, 0, NULL
);
1871 if (!timer_pending(&pg
->rexmit_timer
) ||
1872 time_after(pg
->rexmit_timer
.expires
, lmi
))
1873 mod_timer(&pg
->rexmit_timer
, lmi
);
1876 if (pg
->filter_mode
== MCAST_EXCLUDE
&&
1877 (!timer_pending(&pg
->timer
) ||
1878 time_after(pg
->timer
.expires
, now
+ br_multicast_lmqt(br
))))
1879 mod_timer(&pg
->timer
, now
+ br_multicast_lmqt(br
));
1882 /* State Msg type New state Actions
1883 * INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI
1884 * INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI
1885 * EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI
1887 static bool br_multicast_isinc_allow(struct net_bridge_port_group
*pg
, void *h_addr
,
1888 void *srcs
, u32 nsrcs
, size_t addr_size
,
1891 struct net_bridge
*br
= pg
->key
.port
->br
;
1892 struct net_bridge_group_src
*ent
;
1893 unsigned long now
= jiffies
;
1894 bool changed
= false;
1895 struct br_ip src_ip
;
1898 memset(&src_ip
, 0, sizeof(src_ip
));
1899 src_ip
.proto
= pg
->key
.addr
.proto
;
1900 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
1901 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
1902 ent
= br_multicast_find_group_src(pg
, &src_ip
);
1904 ent
= br_multicast_new_group_src(pg
, &src_ip
);
1910 __grp_src_mod_timer(ent
, now
+ br_multicast_gmi(br
));
1913 if (br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
))
1919 /* State Msg type New state Actions
1920 * INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
1924 static void __grp_src_isexc_incl(struct net_bridge_port_group
*pg
, void *h_addr
,
1925 void *srcs
, u32 nsrcs
, size_t addr_size
,
1928 struct net_bridge_group_src
*ent
;
1929 struct br_ip src_ip
;
1932 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
1933 ent
->flags
|= BR_SGRP_F_DELETE
;
1935 memset(&src_ip
, 0, sizeof(src_ip
));
1936 src_ip
.proto
= pg
->key
.addr
.proto
;
1937 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
1938 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
1939 ent
= br_multicast_find_group_src(pg
, &src_ip
);
1941 ent
->flags
&= ~BR_SGRP_F_DELETE
;
1943 ent
= br_multicast_new_group_src(pg
, &src_ip
);
1945 br_multicast_fwd_src_handle(ent
);
1948 br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
);
1950 __grp_src_delete_marked(pg
);
1953 /* State Msg type New state Actions
1954 * EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI
1959 static bool __grp_src_isexc_excl(struct net_bridge_port_group
*pg
, void *h_addr
,
1960 void *srcs
, u32 nsrcs
, size_t addr_size
,
1963 struct net_bridge
*br
= pg
->key
.port
->br
;
1964 struct net_bridge_group_src
*ent
;
1965 unsigned long now
= jiffies
;
1966 bool changed
= false;
1967 struct br_ip src_ip
;
1970 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
1971 ent
->flags
|= BR_SGRP_F_DELETE
;
1973 memset(&src_ip
, 0, sizeof(src_ip
));
1974 src_ip
.proto
= pg
->key
.addr
.proto
;
1975 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
1976 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
1977 ent
= br_multicast_find_group_src(pg
, &src_ip
);
1979 ent
->flags
&= ~BR_SGRP_F_DELETE
;
1981 ent
= br_multicast_new_group_src(pg
, &src_ip
);
1983 __grp_src_mod_timer(ent
,
1984 now
+ br_multicast_gmi(br
));
1990 if (br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
))
1993 if (__grp_src_delete_marked(pg
))
1999 static bool br_multicast_isexc(struct net_bridge_port_group
*pg
, void *h_addr
,
2000 void *srcs
, u32 nsrcs
, size_t addr_size
,
2003 struct net_bridge
*br
= pg
->key
.port
->br
;
2004 bool changed
= false;
2006 switch (pg
->filter_mode
) {
2008 __grp_src_isexc_incl(pg
, h_addr
, srcs
, nsrcs
, addr_size
,
2010 br_multicast_star_g_handle_mode(pg
, MCAST_EXCLUDE
);
2014 changed
= __grp_src_isexc_excl(pg
, h_addr
, srcs
, nsrcs
, addr_size
,
2019 pg
->filter_mode
= MCAST_EXCLUDE
;
2020 mod_timer(&pg
->timer
, jiffies
+ br_multicast_gmi(br
));
2025 /* State Msg type New state Actions
2026 * INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI
2029 static bool __grp_src_toin_incl(struct net_bridge_port_group
*pg
, void *h_addr
,
2030 void *srcs
, u32 nsrcs
, size_t addr_size
,
2033 struct net_bridge
*br
= pg
->key
.port
->br
;
2034 u32 src_idx
, to_send
= pg
->src_ents
;
2035 struct net_bridge_group_src
*ent
;
2036 unsigned long now
= jiffies
;
2037 bool changed
= false;
2038 struct br_ip src_ip
;
2040 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
2041 ent
->flags
|= BR_SGRP_F_SEND
;
2043 memset(&src_ip
, 0, sizeof(src_ip
));
2044 src_ip
.proto
= pg
->key
.addr
.proto
;
2045 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
2046 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
2047 ent
= br_multicast_find_group_src(pg
, &src_ip
);
2049 ent
->flags
&= ~BR_SGRP_F_SEND
;
2052 ent
= br_multicast_new_group_src(pg
, &src_ip
);
2057 __grp_src_mod_timer(ent
, now
+ br_multicast_gmi(br
));
2060 if (br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
))
2064 __grp_src_query_marked_and_rexmit(pg
);
2069 /* State Msg type New state Actions
2070 * EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI
2074 static bool __grp_src_toin_excl(struct net_bridge_port_group
*pg
, void *h_addr
,
2075 void *srcs
, u32 nsrcs
, size_t addr_size
,
2078 struct net_bridge
*br
= pg
->key
.port
->br
;
2079 u32 src_idx
, to_send
= pg
->src_ents
;
2080 struct net_bridge_group_src
*ent
;
2081 unsigned long now
= jiffies
;
2082 bool changed
= false;
2083 struct br_ip src_ip
;
2085 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
2086 if (timer_pending(&ent
->timer
))
2087 ent
->flags
|= BR_SGRP_F_SEND
;
2089 memset(&src_ip
, 0, sizeof(src_ip
));
2090 src_ip
.proto
= pg
->key
.addr
.proto
;
2091 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
2092 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
2093 ent
= br_multicast_find_group_src(pg
, &src_ip
);
2095 if (timer_pending(&ent
->timer
)) {
2096 ent
->flags
&= ~BR_SGRP_F_SEND
;
2100 ent
= br_multicast_new_group_src(pg
, &src_ip
);
2105 __grp_src_mod_timer(ent
, now
+ br_multicast_gmi(br
));
2108 if (br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
))
2112 __grp_src_query_marked_and_rexmit(pg
);
2114 __grp_send_query_and_rexmit(pg
);
2119 static bool br_multicast_toin(struct net_bridge_port_group
*pg
, void *h_addr
,
2120 void *srcs
, u32 nsrcs
, size_t addr_size
,
2123 bool changed
= false;
2125 switch (pg
->filter_mode
) {
2127 changed
= __grp_src_toin_incl(pg
, h_addr
, srcs
, nsrcs
, addr_size
,
2131 changed
= __grp_src_toin_excl(pg
, h_addr
, srcs
, nsrcs
, addr_size
,
2136 if (br_multicast_eht_should_del_pg(pg
)) {
2137 pg
->flags
|= MDB_PG_FLAGS_FAST_LEAVE
;
2138 br_multicast_find_del_pg(pg
->key
.port
->br
, pg
);
2139 /* a notification has already been sent and we shouldn't
2140 * access pg after the delete so we have to return false
2148 /* State Msg type New state Actions
2149 * INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
2154 static void __grp_src_toex_incl(struct net_bridge_port_group
*pg
, void *h_addr
,
2155 void *srcs
, u32 nsrcs
, size_t addr_size
,
2158 struct net_bridge_group_src
*ent
;
2159 u32 src_idx
, to_send
= 0;
2160 struct br_ip src_ip
;
2162 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
2163 ent
->flags
= (ent
->flags
& ~BR_SGRP_F_SEND
) | BR_SGRP_F_DELETE
;
2165 memset(&src_ip
, 0, sizeof(src_ip
));
2166 src_ip
.proto
= pg
->key
.addr
.proto
;
2167 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
2168 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
2169 ent
= br_multicast_find_group_src(pg
, &src_ip
);
2171 ent
->flags
= (ent
->flags
& ~BR_SGRP_F_DELETE
) |
2175 ent
= br_multicast_new_group_src(pg
, &src_ip
);
2178 br_multicast_fwd_src_handle(ent
);
2181 br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
);
2183 __grp_src_delete_marked(pg
);
2185 __grp_src_query_marked_and_rexmit(pg
);
2188 /* State Msg type New state Actions
2189 * EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer
2195 static bool __grp_src_toex_excl(struct net_bridge_port_group
*pg
, void *h_addr
,
2196 void *srcs
, u32 nsrcs
, size_t addr_size
,
2199 struct net_bridge_group_src
*ent
;
2200 u32 src_idx
, to_send
= 0;
2201 bool changed
= false;
2202 struct br_ip src_ip
;
2204 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
2205 ent
->flags
= (ent
->flags
& ~BR_SGRP_F_SEND
) | BR_SGRP_F_DELETE
;
2207 memset(&src_ip
, 0, sizeof(src_ip
));
2208 src_ip
.proto
= pg
->key
.addr
.proto
;
2209 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
2210 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
2211 ent
= br_multicast_find_group_src(pg
, &src_ip
);
2213 ent
->flags
&= ~BR_SGRP_F_DELETE
;
2215 ent
= br_multicast_new_group_src(pg
, &src_ip
);
2217 __grp_src_mod_timer(ent
, pg
->timer
.expires
);
2221 if (ent
&& timer_pending(&ent
->timer
)) {
2222 ent
->flags
|= BR_SGRP_F_SEND
;
2227 if (br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
))
2230 if (__grp_src_delete_marked(pg
))
2233 __grp_src_query_marked_and_rexmit(pg
);
2238 static bool br_multicast_toex(struct net_bridge_port_group
*pg
, void *h_addr
,
2239 void *srcs
, u32 nsrcs
, size_t addr_size
,
2242 struct net_bridge
*br
= pg
->key
.port
->br
;
2243 bool changed
= false;
2245 switch (pg
->filter_mode
) {
2247 __grp_src_toex_incl(pg
, h_addr
, srcs
, nsrcs
, addr_size
,
2249 br_multicast_star_g_handle_mode(pg
, MCAST_EXCLUDE
);
2253 changed
= __grp_src_toex_excl(pg
, h_addr
, srcs
, nsrcs
, addr_size
,
2258 pg
->filter_mode
= MCAST_EXCLUDE
;
2259 mod_timer(&pg
->timer
, jiffies
+ br_multicast_gmi(br
));
2264 /* State Msg type New state Actions
2265 * INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B)
2267 static bool __grp_src_block_incl(struct net_bridge_port_group
*pg
, void *h_addr
,
2268 void *srcs
, u32 nsrcs
, size_t addr_size
, int grec_type
)
2270 struct net_bridge_group_src
*ent
;
2271 u32 src_idx
, to_send
= 0;
2272 bool changed
= false;
2273 struct br_ip src_ip
;
2275 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
2276 ent
->flags
&= ~BR_SGRP_F_SEND
;
2278 memset(&src_ip
, 0, sizeof(src_ip
));
2279 src_ip
.proto
= pg
->key
.addr
.proto
;
2280 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
2281 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
2282 ent
= br_multicast_find_group_src(pg
, &src_ip
);
2284 ent
->flags
|= BR_SGRP_F_SEND
;
2289 if (br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
))
2293 __grp_src_query_marked_and_rexmit(pg
);
2298 /* State Msg type New state Actions
2299 * EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer
2302 static bool __grp_src_block_excl(struct net_bridge_port_group
*pg
, void *h_addr
,
2303 void *srcs
, u32 nsrcs
, size_t addr_size
, int grec_type
)
2305 struct net_bridge_group_src
*ent
;
2306 u32 src_idx
, to_send
= 0;
2307 bool changed
= false;
2308 struct br_ip src_ip
;
2310 hlist_for_each_entry(ent
, &pg
->src_list
, node
)
2311 ent
->flags
&= ~BR_SGRP_F_SEND
;
2313 memset(&src_ip
, 0, sizeof(src_ip
));
2314 src_ip
.proto
= pg
->key
.addr
.proto
;
2315 for (src_idx
= 0; src_idx
< nsrcs
; src_idx
++) {
2316 memcpy(&src_ip
.src
, srcs
+ (src_idx
* addr_size
), addr_size
);
2317 ent
= br_multicast_find_group_src(pg
, &src_ip
);
2319 ent
= br_multicast_new_group_src(pg
, &src_ip
);
2321 __grp_src_mod_timer(ent
, pg
->timer
.expires
);
2325 if (ent
&& timer_pending(&ent
->timer
)) {
2326 ent
->flags
|= BR_SGRP_F_SEND
;
2331 if (br_multicast_eht_handle(pg
, h_addr
, srcs
, nsrcs
, addr_size
, grec_type
))
2335 __grp_src_query_marked_and_rexmit(pg
);
2340 static bool br_multicast_block(struct net_bridge_port_group
*pg
, void *h_addr
,
2341 void *srcs
, u32 nsrcs
, size_t addr_size
, int grec_type
)
2343 bool changed
= false;
2345 switch (pg
->filter_mode
) {
2347 changed
= __grp_src_block_incl(pg
, h_addr
, srcs
, nsrcs
, addr_size
,
2351 changed
= __grp_src_block_excl(pg
, h_addr
, srcs
, nsrcs
, addr_size
,
2356 if ((pg
->filter_mode
== MCAST_INCLUDE
&& hlist_empty(&pg
->src_list
)) ||
2357 br_multicast_eht_should_del_pg(pg
)) {
2358 if (br_multicast_eht_should_del_pg(pg
))
2359 pg
->flags
|= MDB_PG_FLAGS_FAST_LEAVE
;
2360 br_multicast_find_del_pg(pg
->key
.port
->br
, pg
);
2361 /* a notification has already been sent and we shouldn't
2362 * access pg after the delete so we have to return false
2370 static struct net_bridge_port_group
*
2371 br_multicast_find_port(struct net_bridge_mdb_entry
*mp
,
2372 struct net_bridge_port
*p
,
2373 const unsigned char *src
)
2375 struct net_bridge
*br __maybe_unused
= mp
->br
;
2376 struct net_bridge_port_group
*pg
;
2378 for (pg
= mlock_dereference(mp
->ports
, br
);
2380 pg
= mlock_dereference(pg
->next
, br
))
2381 if (br_port_group_equal(pg
, p
, src
))
2387 static int br_ip4_multicast_igmp3_report(struct net_bridge
*br
,
2388 struct net_bridge_port
*port
,
2389 struct sk_buff
*skb
,
2392 bool igmpv2
= br
->multicast_igmp_version
== 2;
2393 struct net_bridge_mdb_entry
*mdst
;
2394 struct net_bridge_port_group
*pg
;
2395 const unsigned char *src
;
2396 struct igmpv3_report
*ih
;
2397 struct igmpv3_grec
*grec
;
2398 int i
, len
, num
, type
;
2399 __be32 group
, *h_addr
;
2400 bool changed
= false;
2404 ih
= igmpv3_report_hdr(skb
);
2405 num
= ntohs(ih
->ngrec
);
2406 len
= skb_transport_offset(skb
) + sizeof(*ih
);
2408 for (i
= 0; i
< num
; i
++) {
2409 len
+= sizeof(*grec
);
2410 if (!ip_mc_may_pull(skb
, len
))
2413 grec
= (void *)(skb
->data
+ len
- sizeof(*grec
));
2414 group
= grec
->grec_mca
;
2415 type
= grec
->grec_type
;
2416 nsrcs
= ntohs(grec
->grec_nsrcs
);
2419 if (!ip_mc_may_pull(skb
, len
))
2423 case IGMPV3_MODE_IS_INCLUDE
:
2424 case IGMPV3_MODE_IS_EXCLUDE
:
2425 case IGMPV3_CHANGE_TO_INCLUDE
:
2426 case IGMPV3_CHANGE_TO_EXCLUDE
:
2427 case IGMPV3_ALLOW_NEW_SOURCES
:
2428 case IGMPV3_BLOCK_OLD_SOURCES
:
2435 src
= eth_hdr(skb
)->h_source
;
2437 (type
== IGMPV3_CHANGE_TO_INCLUDE
||
2438 type
== IGMPV3_MODE_IS_INCLUDE
)) {
2439 if (!port
|| igmpv2
) {
2440 br_ip4_multicast_leave_group(br
, port
, group
, vid
, src
);
2444 err
= br_ip4_multicast_add_group(br
, port
, group
, vid
,
2450 if (!port
|| igmpv2
)
2453 spin_lock_bh(&br
->multicast_lock
);
2454 mdst
= br_mdb_ip4_get(br
, group
, vid
);
2456 goto unlock_continue
;
2457 pg
= br_multicast_find_port(mdst
, port
, src
);
2458 if (!pg
|| (pg
->flags
& MDB_PG_FLAGS_PERMANENT
))
2459 goto unlock_continue
;
2460 /* reload grec and host addr */
2461 grec
= (void *)(skb
->data
+ len
- sizeof(*grec
) - (nsrcs
* 4));
2462 h_addr
= &ip_hdr(skb
)->saddr
;
2464 case IGMPV3_ALLOW_NEW_SOURCES
:
2465 changed
= br_multicast_isinc_allow(pg
, h_addr
, grec
->grec_src
,
2466 nsrcs
, sizeof(__be32
), type
);
2468 case IGMPV3_MODE_IS_INCLUDE
:
2469 changed
= br_multicast_isinc_allow(pg
, h_addr
, grec
->grec_src
,
2470 nsrcs
, sizeof(__be32
), type
);
2472 case IGMPV3_MODE_IS_EXCLUDE
:
2473 changed
= br_multicast_isexc(pg
, h_addr
, grec
->grec_src
,
2474 nsrcs
, sizeof(__be32
), type
);
2476 case IGMPV3_CHANGE_TO_INCLUDE
:
2477 changed
= br_multicast_toin(pg
, h_addr
, grec
->grec_src
,
2478 nsrcs
, sizeof(__be32
), type
);
2480 case IGMPV3_CHANGE_TO_EXCLUDE
:
2481 changed
= br_multicast_toex(pg
, h_addr
, grec
->grec_src
,
2482 nsrcs
, sizeof(__be32
), type
);
2484 case IGMPV3_BLOCK_OLD_SOURCES
:
2485 changed
= br_multicast_block(pg
, h_addr
, grec
->grec_src
,
2486 nsrcs
, sizeof(__be32
), type
);
2490 br_mdb_notify(br
->dev
, mdst
, pg
, RTM_NEWMDB
);
2492 spin_unlock_bh(&br
->multicast_lock
);
2498 #if IS_ENABLED(CONFIG_IPV6)
2499 static int br_ip6_multicast_mld2_report(struct net_bridge
*br
,
2500 struct net_bridge_port
*port
,
2501 struct sk_buff
*skb
,
2504 bool mldv1
= br
->multicast_mld_version
== 1;
2505 struct net_bridge_mdb_entry
*mdst
;
2506 struct net_bridge_port_group
*pg
;
2507 unsigned int nsrcs_offset
;
2508 const unsigned char *src
;
2509 struct icmp6hdr
*icmp6h
;
2510 struct in6_addr
*h_addr
;
2511 struct mld2_grec
*grec
;
2512 unsigned int grec_len
;
2513 bool changed
= false;
2517 if (!ipv6_mc_may_pull(skb
, sizeof(*icmp6h
)))
2520 icmp6h
= icmp6_hdr(skb
);
2521 num
= ntohs(icmp6h
->icmp6_dataun
.un_data16
[1]);
2522 len
= skb_transport_offset(skb
) + sizeof(*icmp6h
);
2524 for (i
= 0; i
< num
; i
++) {
2525 __be16
*_nsrcs
, __nsrcs
;
2528 nsrcs_offset
= len
+ offsetof(struct mld2_grec
, grec_nsrcs
);
2530 if (skb_transport_offset(skb
) + ipv6_transport_len(skb
) <
2531 nsrcs_offset
+ sizeof(__nsrcs
))
2534 _nsrcs
= skb_header_pointer(skb
, nsrcs_offset
,
2535 sizeof(__nsrcs
), &__nsrcs
);
2539 nsrcs
= ntohs(*_nsrcs
);
2540 grec_len
= struct_size(grec
, grec_src
, nsrcs
);
2542 if (!ipv6_mc_may_pull(skb
, len
+ grec_len
))
2545 grec
= (struct mld2_grec
*)(skb
->data
+ len
);
2548 switch (grec
->grec_type
) {
2549 case MLD2_MODE_IS_INCLUDE
:
2550 case MLD2_MODE_IS_EXCLUDE
:
2551 case MLD2_CHANGE_TO_INCLUDE
:
2552 case MLD2_CHANGE_TO_EXCLUDE
:
2553 case MLD2_ALLOW_NEW_SOURCES
:
2554 case MLD2_BLOCK_OLD_SOURCES
:
2561 src
= eth_hdr(skb
)->h_source
;
2562 if ((grec
->grec_type
== MLD2_CHANGE_TO_INCLUDE
||
2563 grec
->grec_type
== MLD2_MODE_IS_INCLUDE
) &&
2565 if (!port
|| mldv1
) {
2566 br_ip6_multicast_leave_group(br
, port
,
2572 err
= br_ip6_multicast_add_group(br
, port
,
2573 &grec
->grec_mca
, vid
,
2582 spin_lock_bh(&br
->multicast_lock
);
2583 mdst
= br_mdb_ip6_get(br
, &grec
->grec_mca
, vid
);
2585 goto unlock_continue
;
2586 pg
= br_multicast_find_port(mdst
, port
, src
);
2587 if (!pg
|| (pg
->flags
& MDB_PG_FLAGS_PERMANENT
))
2588 goto unlock_continue
;
2589 h_addr
= &ipv6_hdr(skb
)->saddr
;
2590 switch (grec
->grec_type
) {
2591 case MLD2_ALLOW_NEW_SOURCES
:
2592 changed
= br_multicast_isinc_allow(pg
, h_addr
,
2593 grec
->grec_src
, nsrcs
,
2594 sizeof(struct in6_addr
),
2597 case MLD2_MODE_IS_INCLUDE
:
2598 changed
= br_multicast_isinc_allow(pg
, h_addr
,
2599 grec
->grec_src
, nsrcs
,
2600 sizeof(struct in6_addr
),
2603 case MLD2_MODE_IS_EXCLUDE
:
2604 changed
= br_multicast_isexc(pg
, h_addr
,
2605 grec
->grec_src
, nsrcs
,
2606 sizeof(struct in6_addr
),
2609 case MLD2_CHANGE_TO_INCLUDE
:
2610 changed
= br_multicast_toin(pg
, h_addr
,
2611 grec
->grec_src
, nsrcs
,
2612 sizeof(struct in6_addr
),
2615 case MLD2_CHANGE_TO_EXCLUDE
:
2616 changed
= br_multicast_toex(pg
, h_addr
,
2617 grec
->grec_src
, nsrcs
,
2618 sizeof(struct in6_addr
),
2621 case MLD2_BLOCK_OLD_SOURCES
:
2622 changed
= br_multicast_block(pg
, h_addr
,
2623 grec
->grec_src
, nsrcs
,
2624 sizeof(struct in6_addr
),
2629 br_mdb_notify(br
->dev
, mdst
, pg
, RTM_NEWMDB
);
2631 spin_unlock_bh(&br
->multicast_lock
);
2638 static bool br_ip4_multicast_select_querier(struct net_bridge
*br
,
2639 struct net_bridge_port
*port
,
2642 if (!timer_pending(&br
->ip4_own_query
.timer
) &&
2643 !timer_pending(&br
->ip4_other_query
.timer
))
2646 if (!br
->ip4_querier
.addr
.src
.ip4
)
2649 if (ntohl(saddr
) <= ntohl(br
->ip4_querier
.addr
.src
.ip4
))
2655 br
->ip4_querier
.addr
.src
.ip4
= saddr
;
2657 /* update protected by general multicast_lock by caller */
2658 rcu_assign_pointer(br
->ip4_querier
.port
, port
);
2663 #if IS_ENABLED(CONFIG_IPV6)
2664 static bool br_ip6_multicast_select_querier(struct net_bridge
*br
,
2665 struct net_bridge_port
*port
,
2666 struct in6_addr
*saddr
)
2668 if (!timer_pending(&br
->ip6_own_query
.timer
) &&
2669 !timer_pending(&br
->ip6_other_query
.timer
))
2672 if (ipv6_addr_cmp(saddr
, &br
->ip6_querier
.addr
.src
.ip6
) <= 0)
2678 br
->ip6_querier
.addr
.src
.ip6
= *saddr
;
2680 /* update protected by general multicast_lock by caller */
2681 rcu_assign_pointer(br
->ip6_querier
.port
, port
);
2688 br_multicast_update_query_timer(struct net_bridge
*br
,
2689 struct bridge_mcast_other_query
*query
,
2690 unsigned long max_delay
)
2692 if (!timer_pending(&query
->timer
))
2693 query
->delay_time
= jiffies
+ max_delay
;
2695 mod_timer(&query
->timer
, jiffies
+ br
->multicast_querier_interval
);
2698 static void br_port_mc_router_state_change(struct net_bridge_port
*p
,
2701 struct switchdev_attr attr
= {
2703 .id
= SWITCHDEV_ATTR_ID_PORT_MROUTER
,
2704 .flags
= SWITCHDEV_F_DEFER
,
2705 .u
.mrouter
= is_mc_router
,
2708 switchdev_port_attr_set(p
->dev
, &attr
, NULL
);
2711 static struct net_bridge_port
*
2712 br_multicast_rport_from_node(struct net_bridge
*br
,
2713 struct hlist_head
*mc_router_list
,
2714 struct hlist_node
*rlist
)
2716 #if IS_ENABLED(CONFIG_IPV6)
2717 if (mc_router_list
== &br
->ip6_mc_router_list
)
2718 return hlist_entry(rlist
, struct net_bridge_port
, ip6_rlist
);
2720 return hlist_entry(rlist
, struct net_bridge_port
, ip4_rlist
);
2723 static struct hlist_node
*
2724 br_multicast_get_rport_slot(struct net_bridge
*br
,
2725 struct net_bridge_port
*port
,
2726 struct hlist_head
*mc_router_list
)
2729 struct hlist_node
*slot
= NULL
;
2730 struct net_bridge_port
*p
;
2731 struct hlist_node
*rlist
;
2733 hlist_for_each(rlist
, mc_router_list
) {
2734 p
= br_multicast_rport_from_node(br
, mc_router_list
, rlist
);
2736 if ((unsigned long)port
>= (unsigned long)p
)
2745 static bool br_multicast_no_router_otherpf(struct net_bridge_port
*port
,
2746 struct hlist_node
*rnode
)
2748 #if IS_ENABLED(CONFIG_IPV6)
2749 if (rnode
!= &port
->ip6_rlist
)
2750 return hlist_unhashed(&port
->ip6_rlist
);
2752 return hlist_unhashed(&port
->ip4_rlist
);
2758 /* Add port to router_list
2759 * list is maintained ordered by pointer value
2760 * and locked by br->multicast_lock and RCU
2762 static void br_multicast_add_router(struct net_bridge
*br
,
2763 struct net_bridge_port
*port
,
2764 struct hlist_node
*rlist
,
2765 struct hlist_head
*mc_router_list
)
2767 struct hlist_node
*slot
;
2769 if (!hlist_unhashed(rlist
))
2772 slot
= br_multicast_get_rport_slot(br
, port
, mc_router_list
);
2775 hlist_add_behind_rcu(rlist
, slot
);
2777 hlist_add_head_rcu(rlist
, mc_router_list
);
2779 /* For backwards compatibility for now, only notify if we
2780 * switched from no IPv4/IPv6 multicast router to a new
2781 * IPv4 or IPv6 multicast router.
2783 if (br_multicast_no_router_otherpf(port
, rlist
)) {
2784 br_rtr_notify(br
->dev
, port
, RTM_NEWMDB
);
2785 br_port_mc_router_state_change(port
, true);
2789 /* Add port to router_list
2790 * list is maintained ordered by pointer value
2791 * and locked by br->multicast_lock and RCU
2793 static void br_ip4_multicast_add_router(struct net_bridge
*br
,
2794 struct net_bridge_port
*port
)
2796 br_multicast_add_router(br
, port
, &port
->ip4_rlist
,
2797 &br
->ip4_mc_router_list
);
2800 /* Add port to router_list
2801 * list is maintained ordered by pointer value
2802 * and locked by br->multicast_lock and RCU
2804 static void br_ip6_multicast_add_router(struct net_bridge
*br
,
2805 struct net_bridge_port
*port
)
2807 #if IS_ENABLED(CONFIG_IPV6)
2808 br_multicast_add_router(br
, port
, &port
->ip6_rlist
,
2809 &br
->ip6_mc_router_list
);
2813 static void br_multicast_mark_router(struct net_bridge
*br
,
2814 struct net_bridge_port
*port
,
2815 struct timer_list
*timer
,
2816 struct hlist_node
*rlist
,
2817 struct hlist_head
*mc_router_list
)
2819 unsigned long now
= jiffies
;
2822 if (br
->multicast_router
== MDB_RTR_TYPE_TEMP_QUERY
) {
2823 if (!br_ip4_multicast_is_router(br
) &&
2824 !br_ip6_multicast_is_router(br
))
2825 br_mc_router_state_change(br
, true);
2826 mod_timer(timer
, now
+ br
->multicast_querier_interval
);
2831 if (port
->multicast_router
== MDB_RTR_TYPE_DISABLED
||
2832 port
->multicast_router
== MDB_RTR_TYPE_PERM
)
2835 br_multicast_add_router(br
, port
, rlist
, mc_router_list
);
2836 mod_timer(timer
, now
+ br
->multicast_querier_interval
);
2839 static void br_ip4_multicast_mark_router(struct net_bridge
*br
,
2840 struct net_bridge_port
*port
)
2842 struct timer_list
*timer
= &br
->ip4_mc_router_timer
;
2843 struct hlist_node
*rlist
= NULL
;
2846 timer
= &port
->ip4_mc_router_timer
;
2847 rlist
= &port
->ip4_rlist
;
2850 br_multicast_mark_router(br
, port
, timer
, rlist
,
2851 &br
->ip4_mc_router_list
);
2854 static void br_ip6_multicast_mark_router(struct net_bridge
*br
,
2855 struct net_bridge_port
*port
)
2857 #if IS_ENABLED(CONFIG_IPV6)
2858 struct timer_list
*timer
= &br
->ip6_mc_router_timer
;
2859 struct hlist_node
*rlist
= NULL
;
2862 timer
= &port
->ip6_mc_router_timer
;
2863 rlist
= &port
->ip6_rlist
;
2866 br_multicast_mark_router(br
, port
, timer
, rlist
,
2867 &br
->ip6_mc_router_list
);
2872 br_ip4_multicast_query_received(struct net_bridge
*br
,
2873 struct net_bridge_port
*port
,
2874 struct bridge_mcast_other_query
*query
,
2875 struct br_ip
*saddr
,
2876 unsigned long max_delay
)
2878 if (!br_ip4_multicast_select_querier(br
, port
, saddr
->src
.ip4
))
2881 br_multicast_update_query_timer(br
, query
, max_delay
);
2882 br_ip4_multicast_mark_router(br
, port
);
2885 #if IS_ENABLED(CONFIG_IPV6)
2887 br_ip6_multicast_query_received(struct net_bridge
*br
,
2888 struct net_bridge_port
*port
,
2889 struct bridge_mcast_other_query
*query
,
2890 struct br_ip
*saddr
,
2891 unsigned long max_delay
)
2893 if (!br_ip6_multicast_select_querier(br
, port
, &saddr
->src
.ip6
))
2896 br_multicast_update_query_timer(br
, query
, max_delay
);
2897 br_ip6_multicast_mark_router(br
, port
);
2901 static void br_ip4_multicast_query(struct net_bridge
*br
,
2902 struct net_bridge_port
*port
,
2903 struct sk_buff
*skb
,
2906 unsigned int transport_len
= ip_transport_len(skb
);
2907 const struct iphdr
*iph
= ip_hdr(skb
);
2908 struct igmphdr
*ih
= igmp_hdr(skb
);
2909 struct net_bridge_mdb_entry
*mp
;
2910 struct igmpv3_query
*ih3
;
2911 struct net_bridge_port_group
*p
;
2912 struct net_bridge_port_group __rcu
**pp
;
2914 unsigned long max_delay
;
2915 unsigned long now
= jiffies
;
2918 spin_lock(&br
->multicast_lock
);
2919 if (!netif_running(br
->dev
) ||
2920 (port
&& port
->state
== BR_STATE_DISABLED
))
2925 if (transport_len
== sizeof(*ih
)) {
2926 max_delay
= ih
->code
* (HZ
/ IGMP_TIMER_SCALE
);
2929 max_delay
= 10 * HZ
;
2932 } else if (transport_len
>= sizeof(*ih3
)) {
2933 ih3
= igmpv3_query_hdr(skb
);
2935 (br
->multicast_igmp_version
== 3 && group
&& ih3
->suppress
))
2938 max_delay
= ih3
->code
?
2939 IGMPV3_MRC(ih3
->code
) * (HZ
/ IGMP_TIMER_SCALE
) : 1;
2945 saddr
.proto
= htons(ETH_P_IP
);
2946 saddr
.src
.ip4
= iph
->saddr
;
2948 br_ip4_multicast_query_received(br
, port
, &br
->ip4_other_query
,
2953 mp
= br_mdb_ip4_get(br
, group
, vid
);
2957 max_delay
*= br
->multicast_last_member_count
;
2959 if (mp
->host_joined
&&
2960 (timer_pending(&mp
->timer
) ?
2961 time_after(mp
->timer
.expires
, now
+ max_delay
) :
2962 try_to_del_timer_sync(&mp
->timer
) >= 0))
2963 mod_timer(&mp
->timer
, now
+ max_delay
);
2965 for (pp
= &mp
->ports
;
2966 (p
= mlock_dereference(*pp
, br
)) != NULL
;
2968 if (timer_pending(&p
->timer
) ?
2969 time_after(p
->timer
.expires
, now
+ max_delay
) :
2970 try_to_del_timer_sync(&p
->timer
) >= 0 &&
2971 (br
->multicast_igmp_version
== 2 ||
2972 p
->filter_mode
== MCAST_EXCLUDE
))
2973 mod_timer(&p
->timer
, now
+ max_delay
);
2977 spin_unlock(&br
->multicast_lock
);
2980 #if IS_ENABLED(CONFIG_IPV6)
2981 static int br_ip6_multicast_query(struct net_bridge
*br
,
2982 struct net_bridge_port
*port
,
2983 struct sk_buff
*skb
,
2986 unsigned int transport_len
= ipv6_transport_len(skb
);
2987 struct mld_msg
*mld
;
2988 struct net_bridge_mdb_entry
*mp
;
2989 struct mld2_query
*mld2q
;
2990 struct net_bridge_port_group
*p
;
2991 struct net_bridge_port_group __rcu
**pp
;
2993 unsigned long max_delay
;
2994 unsigned long now
= jiffies
;
2995 unsigned int offset
= skb_transport_offset(skb
);
2996 const struct in6_addr
*group
= NULL
;
2997 bool is_general_query
;
3000 spin_lock(&br
->multicast_lock
);
3001 if (!netif_running(br
->dev
) ||
3002 (port
&& port
->state
== BR_STATE_DISABLED
))
3005 if (transport_len
== sizeof(*mld
)) {
3006 if (!pskb_may_pull(skb
, offset
+ sizeof(*mld
))) {
3010 mld
= (struct mld_msg
*) icmp6_hdr(skb
);
3011 max_delay
= msecs_to_jiffies(ntohs(mld
->mld_maxdelay
));
3013 group
= &mld
->mld_mca
;
3015 if (!pskb_may_pull(skb
, offset
+ sizeof(*mld2q
))) {
3019 mld2q
= (struct mld2_query
*)icmp6_hdr(skb
);
3020 if (!mld2q
->mld2q_nsrcs
)
3021 group
= &mld2q
->mld2q_mca
;
3022 if (br
->multicast_mld_version
== 2 &&
3023 !ipv6_addr_any(&mld2q
->mld2q_mca
) &&
3024 mld2q
->mld2q_suppress
)
3027 max_delay
= max(msecs_to_jiffies(mldv2_mrc(mld2q
)), 1UL);
3030 is_general_query
= group
&& ipv6_addr_any(group
);
3032 if (is_general_query
) {
3033 saddr
.proto
= htons(ETH_P_IPV6
);
3034 saddr
.src
.ip6
= ipv6_hdr(skb
)->saddr
;
3036 br_ip6_multicast_query_received(br
, port
, &br
->ip6_other_query
,
3039 } else if (!group
) {
3043 mp
= br_mdb_ip6_get(br
, group
, vid
);
3047 max_delay
*= br
->multicast_last_member_count
;
3048 if (mp
->host_joined
&&
3049 (timer_pending(&mp
->timer
) ?
3050 time_after(mp
->timer
.expires
, now
+ max_delay
) :
3051 try_to_del_timer_sync(&mp
->timer
) >= 0))
3052 mod_timer(&mp
->timer
, now
+ max_delay
);
3054 for (pp
= &mp
->ports
;
3055 (p
= mlock_dereference(*pp
, br
)) != NULL
;
3057 if (timer_pending(&p
->timer
) ?
3058 time_after(p
->timer
.expires
, now
+ max_delay
) :
3059 try_to_del_timer_sync(&p
->timer
) >= 0 &&
3060 (br
->multicast_mld_version
== 1 ||
3061 p
->filter_mode
== MCAST_EXCLUDE
))
3062 mod_timer(&p
->timer
, now
+ max_delay
);
3066 spin_unlock(&br
->multicast_lock
);
3072 br_multicast_leave_group(struct net_bridge
*br
,
3073 struct net_bridge_port
*port
,
3074 struct br_ip
*group
,
3075 struct bridge_mcast_other_query
*other_query
,
3076 struct bridge_mcast_own_query
*own_query
,
3077 const unsigned char *src
)
3079 struct net_bridge_mdb_entry
*mp
;
3080 struct net_bridge_port_group
*p
;
3084 spin_lock(&br
->multicast_lock
);
3085 if (!netif_running(br
->dev
) ||
3086 (port
&& port
->state
== BR_STATE_DISABLED
))
3089 mp
= br_mdb_ip_get(br
, group
);
3093 if (port
&& (port
->flags
& BR_MULTICAST_FAST_LEAVE
)) {
3094 struct net_bridge_port_group __rcu
**pp
;
3096 for (pp
= &mp
->ports
;
3097 (p
= mlock_dereference(*pp
, br
)) != NULL
;
3099 if (!br_port_group_equal(p
, port
, src
))
3102 if (p
->flags
& MDB_PG_FLAGS_PERMANENT
)
3105 p
->flags
|= MDB_PG_FLAGS_FAST_LEAVE
;
3106 br_multicast_del_pg(mp
, p
, pp
);
3111 if (timer_pending(&other_query
->timer
))
3114 if (br_opt_get(br
, BROPT_MULTICAST_QUERIER
)) {
3115 __br_multicast_send_query(br
, port
, NULL
, NULL
, &mp
->addr
,
3118 time
= jiffies
+ br
->multicast_last_member_count
*
3119 br
->multicast_last_member_interval
;
3121 mod_timer(&own_query
->timer
, time
);
3123 for (p
= mlock_dereference(mp
->ports
, br
);
3125 p
= mlock_dereference(p
->next
, br
)) {
3126 if (!br_port_group_equal(p
, port
, src
))
3129 if (!hlist_unhashed(&p
->mglist
) &&
3130 (timer_pending(&p
->timer
) ?
3131 time_after(p
->timer
.expires
, time
) :
3132 try_to_del_timer_sync(&p
->timer
) >= 0)) {
3133 mod_timer(&p
->timer
, time
);
3141 time
= now
+ br
->multicast_last_member_count
*
3142 br
->multicast_last_member_interval
;
3145 if (mp
->host_joined
&&
3146 (timer_pending(&mp
->timer
) ?
3147 time_after(mp
->timer
.expires
, time
) :
3148 try_to_del_timer_sync(&mp
->timer
) >= 0)) {
3149 mod_timer(&mp
->timer
, time
);
3155 for (p
= mlock_dereference(mp
->ports
, br
);
3157 p
= mlock_dereference(p
->next
, br
)) {
3158 if (p
->key
.port
!= port
)
3161 if (!hlist_unhashed(&p
->mglist
) &&
3162 (timer_pending(&p
->timer
) ?
3163 time_after(p
->timer
.expires
, time
) :
3164 try_to_del_timer_sync(&p
->timer
) >= 0)) {
3165 mod_timer(&p
->timer
, time
);
3171 spin_unlock(&br
->multicast_lock
);
3174 static void br_ip4_multicast_leave_group(struct net_bridge
*br
,
3175 struct net_bridge_port
*port
,
3178 const unsigned char *src
)
3180 struct br_ip br_group
;
3181 struct bridge_mcast_own_query
*own_query
;
3183 if (ipv4_is_local_multicast(group
))
3186 own_query
= port
? &port
->ip4_own_query
: &br
->ip4_own_query
;
3188 memset(&br_group
, 0, sizeof(br_group
));
3189 br_group
.dst
.ip4
= group
;
3190 br_group
.proto
= htons(ETH_P_IP
);
3193 br_multicast_leave_group(br
, port
, &br_group
, &br
->ip4_other_query
,
3197 #if IS_ENABLED(CONFIG_IPV6)
3198 static void br_ip6_multicast_leave_group(struct net_bridge
*br
,
3199 struct net_bridge_port
*port
,
3200 const struct in6_addr
*group
,
3202 const unsigned char *src
)
3204 struct br_ip br_group
;
3205 struct bridge_mcast_own_query
*own_query
;
3207 if (ipv6_addr_is_ll_all_nodes(group
))
3210 own_query
= port
? &port
->ip6_own_query
: &br
->ip6_own_query
;
3212 memset(&br_group
, 0, sizeof(br_group
));
3213 br_group
.dst
.ip6
= *group
;
3214 br_group
.proto
= htons(ETH_P_IPV6
);
3217 br_multicast_leave_group(br
, port
, &br_group
, &br
->ip6_other_query
,
3222 static void br_multicast_err_count(const struct net_bridge
*br
,
3223 const struct net_bridge_port
*p
,
3226 struct bridge_mcast_stats __percpu
*stats
;
3227 struct bridge_mcast_stats
*pstats
;
3229 if (!br_opt_get(br
, BROPT_MULTICAST_STATS_ENABLED
))
3233 stats
= p
->mcast_stats
;
3235 stats
= br
->mcast_stats
;
3236 if (WARN_ON(!stats
))
3239 pstats
= this_cpu_ptr(stats
);
3241 u64_stats_update_begin(&pstats
->syncp
);
3243 case htons(ETH_P_IP
):
3244 pstats
->mstats
.igmp_parse_errors
++;
3246 #if IS_ENABLED(CONFIG_IPV6)
3247 case htons(ETH_P_IPV6
):
3248 pstats
->mstats
.mld_parse_errors
++;
3252 u64_stats_update_end(&pstats
->syncp
);
3255 static void br_multicast_pim(struct net_bridge
*br
,
3256 struct net_bridge_port
*port
,
3257 const struct sk_buff
*skb
)
3259 unsigned int offset
= skb_transport_offset(skb
);
3260 struct pimhdr
*pimhdr
, _pimhdr
;
3262 pimhdr
= skb_header_pointer(skb
, offset
, sizeof(_pimhdr
), &_pimhdr
);
3263 if (!pimhdr
|| pim_hdr_version(pimhdr
) != PIM_VERSION
||
3264 pim_hdr_type(pimhdr
) != PIM_TYPE_HELLO
)
3267 spin_lock(&br
->multicast_lock
);
3268 br_ip4_multicast_mark_router(br
, port
);
3269 spin_unlock(&br
->multicast_lock
);
3272 static int br_ip4_multicast_mrd_rcv(struct net_bridge
*br
,
3273 struct net_bridge_port
*port
,
3274 struct sk_buff
*skb
)
3276 if (ip_hdr(skb
)->protocol
!= IPPROTO_IGMP
||
3277 igmp_hdr(skb
)->type
!= IGMP_MRDISC_ADV
)
3280 spin_lock(&br
->multicast_lock
);
3281 br_ip4_multicast_mark_router(br
, port
);
3282 spin_unlock(&br
->multicast_lock
);
3287 static int br_multicast_ipv4_rcv(struct net_bridge
*br
,
3288 struct net_bridge_port
*port
,
3289 struct sk_buff
*skb
,
3292 const unsigned char *src
;
3296 err
= ip_mc_check_igmp(skb
);
3298 if (err
== -ENOMSG
) {
3299 if (!ipv4_is_local_multicast(ip_hdr(skb
)->daddr
)) {
3300 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 1;
3301 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb
)->daddr
)) {
3302 if (ip_hdr(skb
)->protocol
== IPPROTO_PIM
)
3303 br_multicast_pim(br
, port
, skb
);
3304 } else if (ipv4_is_all_snoopers(ip_hdr(skb
)->daddr
)) {
3305 br_ip4_multicast_mrd_rcv(br
, port
, skb
);
3309 } else if (err
< 0) {
3310 br_multicast_err_count(br
, port
, skb
->protocol
);
3315 src
= eth_hdr(skb
)->h_source
;
3316 BR_INPUT_SKB_CB(skb
)->igmp
= ih
->type
;
3319 case IGMP_HOST_MEMBERSHIP_REPORT
:
3320 case IGMPV2_HOST_MEMBERSHIP_REPORT
:
3321 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 1;
3322 err
= br_ip4_multicast_add_group(br
, port
, ih
->group
, vid
, src
,
3325 case IGMPV3_HOST_MEMBERSHIP_REPORT
:
3326 err
= br_ip4_multicast_igmp3_report(br
, port
, skb
, vid
);
3328 case IGMP_HOST_MEMBERSHIP_QUERY
:
3329 br_ip4_multicast_query(br
, port
, skb
, vid
);
3331 case IGMP_HOST_LEAVE_MESSAGE
:
3332 br_ip4_multicast_leave_group(br
, port
, ih
->group
, vid
, src
);
3336 br_multicast_count(br
, port
, skb
, BR_INPUT_SKB_CB(skb
)->igmp
,
3342 #if IS_ENABLED(CONFIG_IPV6)
3343 static void br_ip6_multicast_mrd_rcv(struct net_bridge
*br
,
3344 struct net_bridge_port
*port
,
3345 struct sk_buff
*skb
)
3347 if (icmp6_hdr(skb
)->icmp6_type
!= ICMPV6_MRDISC_ADV
)
3350 spin_lock(&br
->multicast_lock
);
3351 br_ip6_multicast_mark_router(br
, port
);
3352 spin_unlock(&br
->multicast_lock
);
3355 static int br_multicast_ipv6_rcv(struct net_bridge
*br
,
3356 struct net_bridge_port
*port
,
3357 struct sk_buff
*skb
,
3360 const unsigned char *src
;
3361 struct mld_msg
*mld
;
3364 err
= ipv6_mc_check_mld(skb
);
3366 if (err
== -ENOMSG
|| err
== -ENODATA
) {
3367 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb
)->daddr
))
3368 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 1;
3369 if (err
== -ENODATA
&&
3370 ipv6_addr_is_all_snoopers(&ipv6_hdr(skb
)->daddr
))
3371 br_ip6_multicast_mrd_rcv(br
, port
, skb
);
3374 } else if (err
< 0) {
3375 br_multicast_err_count(br
, port
, skb
->protocol
);
3379 mld
= (struct mld_msg
*)skb_transport_header(skb
);
3380 BR_INPUT_SKB_CB(skb
)->igmp
= mld
->mld_type
;
3382 switch (mld
->mld_type
) {
3383 case ICMPV6_MGM_REPORT
:
3384 src
= eth_hdr(skb
)->h_source
;
3385 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 1;
3386 err
= br_ip6_multicast_add_group(br
, port
, &mld
->mld_mca
, vid
,
3389 case ICMPV6_MLD2_REPORT
:
3390 err
= br_ip6_multicast_mld2_report(br
, port
, skb
, vid
);
3392 case ICMPV6_MGM_QUERY
:
3393 err
= br_ip6_multicast_query(br
, port
, skb
, vid
);
3395 case ICMPV6_MGM_REDUCTION
:
3396 src
= eth_hdr(skb
)->h_source
;
3397 br_ip6_multicast_leave_group(br
, port
, &mld
->mld_mca
, vid
, src
);
3401 br_multicast_count(br
, port
, skb
, BR_INPUT_SKB_CB(skb
)->igmp
,
3408 int br_multicast_rcv(struct net_bridge
*br
, struct net_bridge_port
*port
,
3409 struct sk_buff
*skb
, u16 vid
)
3413 BR_INPUT_SKB_CB(skb
)->igmp
= 0;
3414 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 0;
3416 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
3419 switch (skb
->protocol
) {
3420 case htons(ETH_P_IP
):
3421 ret
= br_multicast_ipv4_rcv(br
, port
, skb
, vid
);
3423 #if IS_ENABLED(CONFIG_IPV6)
3424 case htons(ETH_P_IPV6
):
3425 ret
= br_multicast_ipv6_rcv(br
, port
, skb
, vid
);
3433 static void br_multicast_query_expired(struct net_bridge
*br
,
3434 struct bridge_mcast_own_query
*query
,
3435 struct bridge_mcast_querier
*querier
)
3437 spin_lock(&br
->multicast_lock
);
3438 if (query
->startup_sent
< br
->multicast_startup_query_count
)
3439 query
->startup_sent
++;
3441 RCU_INIT_POINTER(querier
->port
, NULL
);
3442 br_multicast_send_query(br
, NULL
, query
);
3443 spin_unlock(&br
->multicast_lock
);
3446 static void br_ip4_multicast_query_expired(struct timer_list
*t
)
3448 struct net_bridge
*br
= from_timer(br
, t
, ip4_own_query
.timer
);
3450 br_multicast_query_expired(br
, &br
->ip4_own_query
, &br
->ip4_querier
);
3453 #if IS_ENABLED(CONFIG_IPV6)
3454 static void br_ip6_multicast_query_expired(struct timer_list
*t
)
3456 struct net_bridge
*br
= from_timer(br
, t
, ip6_own_query
.timer
);
3458 br_multicast_query_expired(br
, &br
->ip6_own_query
, &br
->ip6_querier
);
3462 static void br_multicast_gc_work(struct work_struct
*work
)
3464 struct net_bridge
*br
= container_of(work
, struct net_bridge
,
3466 HLIST_HEAD(deleted_head
);
3468 spin_lock_bh(&br
->multicast_lock
);
3469 hlist_move_list(&br
->mcast_gc_list
, &deleted_head
);
3470 spin_unlock_bh(&br
->multicast_lock
);
3472 br_multicast_gc(&deleted_head
);
3475 void br_multicast_init(struct net_bridge
*br
)
3477 br
->hash_max
= BR_MULTICAST_DEFAULT_HASH_MAX
;
3479 br
->multicast_router
= MDB_RTR_TYPE_TEMP_QUERY
;
3480 br
->multicast_last_member_count
= 2;
3481 br
->multicast_startup_query_count
= 2;
3483 br
->multicast_last_member_interval
= HZ
;
3484 br
->multicast_query_response_interval
= 10 * HZ
;
3485 br
->multicast_startup_query_interval
= 125 * HZ
/ 4;
3486 br
->multicast_query_interval
= 125 * HZ
;
3487 br
->multicast_querier_interval
= 255 * HZ
;
3488 br
->multicast_membership_interval
= 260 * HZ
;
3490 br
->ip4_other_query
.delay_time
= 0;
3491 br
->ip4_querier
.port
= NULL
;
3492 br
->multicast_igmp_version
= 2;
3493 #if IS_ENABLED(CONFIG_IPV6)
3494 br
->multicast_mld_version
= 1;
3495 br
->ip6_other_query
.delay_time
= 0;
3496 br
->ip6_querier
.port
= NULL
;
3498 br_opt_toggle(br
, BROPT_MULTICAST_ENABLED
, true);
3499 br_opt_toggle(br
, BROPT_HAS_IPV6_ADDR
, true);
3501 spin_lock_init(&br
->multicast_lock
);
3502 timer_setup(&br
->ip4_mc_router_timer
,
3503 br_ip4_multicast_local_router_expired
, 0);
3504 timer_setup(&br
->ip4_other_query
.timer
,
3505 br_ip4_multicast_querier_expired
, 0);
3506 timer_setup(&br
->ip4_own_query
.timer
,
3507 br_ip4_multicast_query_expired
, 0);
3508 #if IS_ENABLED(CONFIG_IPV6)
3509 timer_setup(&br
->ip6_mc_router_timer
,
3510 br_ip6_multicast_local_router_expired
, 0);
3511 timer_setup(&br
->ip6_other_query
.timer
,
3512 br_ip6_multicast_querier_expired
, 0);
3513 timer_setup(&br
->ip6_own_query
.timer
,
3514 br_ip6_multicast_query_expired
, 0);
3516 INIT_HLIST_HEAD(&br
->mdb_list
);
3517 INIT_HLIST_HEAD(&br
->mcast_gc_list
);
3518 INIT_WORK(&br
->mcast_gc_work
, br_multicast_gc_work
);
3521 static void br_ip4_multicast_join_snoopers(struct net_bridge
*br
)
3523 struct in_device
*in_dev
= in_dev_get(br
->dev
);
3528 __ip_mc_inc_group(in_dev
, htonl(INADDR_ALLSNOOPERS_GROUP
), GFP_ATOMIC
);
3532 #if IS_ENABLED(CONFIG_IPV6)
3533 static void br_ip6_multicast_join_snoopers(struct net_bridge
*br
)
3535 struct in6_addr addr
;
3537 ipv6_addr_set(&addr
, htonl(0xff020000), 0, 0, htonl(0x6a));
3538 ipv6_dev_mc_inc(br
->dev
, &addr
);
3541 static inline void br_ip6_multicast_join_snoopers(struct net_bridge
*br
)
3546 void br_multicast_join_snoopers(struct net_bridge
*br
)
3548 br_ip4_multicast_join_snoopers(br
);
3549 br_ip6_multicast_join_snoopers(br
);
3552 static void br_ip4_multicast_leave_snoopers(struct net_bridge
*br
)
3554 struct in_device
*in_dev
= in_dev_get(br
->dev
);
3556 if (WARN_ON(!in_dev
))
3559 __ip_mc_dec_group(in_dev
, htonl(INADDR_ALLSNOOPERS_GROUP
), GFP_ATOMIC
);
3563 #if IS_ENABLED(CONFIG_IPV6)
3564 static void br_ip6_multicast_leave_snoopers(struct net_bridge
*br
)
3566 struct in6_addr addr
;
3568 ipv6_addr_set(&addr
, htonl(0xff020000), 0, 0, htonl(0x6a));
3569 ipv6_dev_mc_dec(br
->dev
, &addr
);
3572 static inline void br_ip6_multicast_leave_snoopers(struct net_bridge
*br
)
3577 void br_multicast_leave_snoopers(struct net_bridge
*br
)
3579 br_ip4_multicast_leave_snoopers(br
);
3580 br_ip6_multicast_leave_snoopers(br
);
3583 static void __br_multicast_open(struct net_bridge
*br
,
3584 struct bridge_mcast_own_query
*query
)
3586 query
->startup_sent
= 0;
3588 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
3591 mod_timer(&query
->timer
, jiffies
);
3594 void br_multicast_open(struct net_bridge
*br
)
3596 __br_multicast_open(br
, &br
->ip4_own_query
);
3597 #if IS_ENABLED(CONFIG_IPV6)
3598 __br_multicast_open(br
, &br
->ip6_own_query
);
3602 void br_multicast_stop(struct net_bridge
*br
)
3604 del_timer_sync(&br
->ip4_mc_router_timer
);
3605 del_timer_sync(&br
->ip4_other_query
.timer
);
3606 del_timer_sync(&br
->ip4_own_query
.timer
);
3607 #if IS_ENABLED(CONFIG_IPV6)
3608 del_timer_sync(&br
->ip6_mc_router_timer
);
3609 del_timer_sync(&br
->ip6_other_query
.timer
);
3610 del_timer_sync(&br
->ip6_own_query
.timer
);
3614 void br_multicast_dev_del(struct net_bridge
*br
)
3616 struct net_bridge_mdb_entry
*mp
;
3617 HLIST_HEAD(deleted_head
);
3618 struct hlist_node
*tmp
;
3620 spin_lock_bh(&br
->multicast_lock
);
3621 hlist_for_each_entry_safe(mp
, tmp
, &br
->mdb_list
, mdb_node
)
3622 br_multicast_del_mdb_entry(mp
);
3623 hlist_move_list(&br
->mcast_gc_list
, &deleted_head
);
3624 spin_unlock_bh(&br
->multicast_lock
);
3626 br_multicast_gc(&deleted_head
);
3627 cancel_work_sync(&br
->mcast_gc_work
);
3632 int br_multicast_set_router(struct net_bridge
*br
, unsigned long val
)
3636 spin_lock_bh(&br
->multicast_lock
);
3639 case MDB_RTR_TYPE_DISABLED
:
3640 case MDB_RTR_TYPE_PERM
:
3641 br_mc_router_state_change(br
, val
== MDB_RTR_TYPE_PERM
);
3642 del_timer(&br
->ip4_mc_router_timer
);
3643 #if IS_ENABLED(CONFIG_IPV6)
3644 del_timer(&br
->ip6_mc_router_timer
);
3646 br
->multicast_router
= val
;
3649 case MDB_RTR_TYPE_TEMP_QUERY
:
3650 if (br
->multicast_router
!= MDB_RTR_TYPE_TEMP_QUERY
)
3651 br_mc_router_state_change(br
, false);
3652 br
->multicast_router
= val
;
3657 spin_unlock_bh(&br
->multicast_lock
);
3663 br_multicast_rport_del_notify(struct net_bridge_port
*p
, bool deleted
)
3668 /* For backwards compatibility for now, only notify if there is
3669 * no multicast router anymore for both IPv4 and IPv6.
3671 if (!hlist_unhashed(&p
->ip4_rlist
))
3673 #if IS_ENABLED(CONFIG_IPV6)
3674 if (!hlist_unhashed(&p
->ip6_rlist
))
3678 br_rtr_notify(p
->br
->dev
, p
, RTM_DELMDB
);
3679 br_port_mc_router_state_change(p
, false);
3681 /* don't allow timer refresh */
3682 if (p
->multicast_router
== MDB_RTR_TYPE_TEMP
)
3683 p
->multicast_router
= MDB_RTR_TYPE_TEMP_QUERY
;
3686 int br_multicast_set_port_router(struct net_bridge_port
*p
, unsigned long val
)
3688 struct net_bridge
*br
= p
->br
;
3689 unsigned long now
= jiffies
;
3693 spin_lock(&br
->multicast_lock
);
3694 if (p
->multicast_router
== val
) {
3695 /* Refresh the temp router port timer */
3696 if (p
->multicast_router
== MDB_RTR_TYPE_TEMP
) {
3697 mod_timer(&p
->ip4_mc_router_timer
,
3698 now
+ br
->multicast_querier_interval
);
3699 #if IS_ENABLED(CONFIG_IPV6)
3700 mod_timer(&p
->ip6_mc_router_timer
,
3701 now
+ br
->multicast_querier_interval
);
3708 case MDB_RTR_TYPE_DISABLED
:
3709 p
->multicast_router
= MDB_RTR_TYPE_DISABLED
;
3710 del
|= br_ip4_multicast_rport_del(p
);
3711 del_timer(&p
->ip4_mc_router_timer
);
3712 del
|= br_ip6_multicast_rport_del(p
);
3713 #if IS_ENABLED(CONFIG_IPV6)
3714 del_timer(&p
->ip6_mc_router_timer
);
3716 br_multicast_rport_del_notify(p
, del
);
3718 case MDB_RTR_TYPE_TEMP_QUERY
:
3719 p
->multicast_router
= MDB_RTR_TYPE_TEMP_QUERY
;
3720 del
|= br_ip4_multicast_rport_del(p
);
3721 del
|= br_ip6_multicast_rport_del(p
);
3722 br_multicast_rport_del_notify(p
, del
);
3724 case MDB_RTR_TYPE_PERM
:
3725 p
->multicast_router
= MDB_RTR_TYPE_PERM
;
3726 del_timer(&p
->ip4_mc_router_timer
);
3727 br_ip4_multicast_add_router(br
, p
);
3728 #if IS_ENABLED(CONFIG_IPV6)
3729 del_timer(&p
->ip6_mc_router_timer
);
3731 br_ip6_multicast_add_router(br
, p
);
3733 case MDB_RTR_TYPE_TEMP
:
3734 p
->multicast_router
= MDB_RTR_TYPE_TEMP
;
3735 br_ip4_multicast_mark_router(br
, p
);
3736 br_ip6_multicast_mark_router(br
, p
);
3743 spin_unlock(&br
->multicast_lock
);
3748 static void br_multicast_start_querier(struct net_bridge
*br
,
3749 struct bridge_mcast_own_query
*query
)
3751 struct net_bridge_port
*port
;
3753 __br_multicast_open(br
, query
);
3756 list_for_each_entry_rcu(port
, &br
->port_list
, list
) {
3757 if (port
->state
== BR_STATE_DISABLED
||
3758 port
->state
== BR_STATE_BLOCKING
)
3761 if (query
== &br
->ip4_own_query
)
3762 br_multicast_enable(&port
->ip4_own_query
);
3763 #if IS_ENABLED(CONFIG_IPV6)
3765 br_multicast_enable(&port
->ip6_own_query
);
3771 int br_multicast_toggle(struct net_bridge
*br
, unsigned long val
,
3772 struct netlink_ext_ack
*extack
)
3774 struct net_bridge_port
*port
;
3775 bool change_snoopers
= false;
3778 spin_lock_bh(&br
->multicast_lock
);
3779 if (!!br_opt_get(br
, BROPT_MULTICAST_ENABLED
) == !!val
)
3782 err
= br_mc_disabled_update(br
->dev
, val
, extack
);
3783 if (err
== -EOPNOTSUPP
)
3788 br_opt_toggle(br
, BROPT_MULTICAST_ENABLED
, !!val
);
3789 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
)) {
3790 change_snoopers
= true;
3794 if (!netif_running(br
->dev
))
3797 br_multicast_open(br
);
3798 list_for_each_entry(port
, &br
->port_list
, list
)
3799 __br_multicast_enable_port(port
);
3801 change_snoopers
= true;
3804 spin_unlock_bh(&br
->multicast_lock
);
3806 /* br_multicast_join_snoopers has the potential to cause
3807 * an MLD Report/Leave to be delivered to br_multicast_rcv,
3808 * which would in turn call br_multicast_add_group, which would
3809 * attempt to acquire multicast_lock. This function should be
3810 * called after the lock has been released to avoid deadlocks on
3813 * br_multicast_leave_snoopers does not have the problem since
3814 * br_multicast_rcv first checks BROPT_MULTICAST_ENABLED, and
3815 * returns without calling br_multicast_ipv4/6_rcv if it's not
3816 * enabled. Moved both functions out just for symmetry.
3818 if (change_snoopers
) {
3819 if (br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
3820 br_multicast_join_snoopers(br
);
3822 br_multicast_leave_snoopers(br
);
3828 bool br_multicast_enabled(const struct net_device
*dev
)
3830 struct net_bridge
*br
= netdev_priv(dev
);
3832 return !!br_opt_get(br
, BROPT_MULTICAST_ENABLED
);
3834 EXPORT_SYMBOL_GPL(br_multicast_enabled
);
3836 bool br_multicast_router(const struct net_device
*dev
)
3838 struct net_bridge
*br
= netdev_priv(dev
);
3841 spin_lock_bh(&br
->multicast_lock
);
3842 is_router
= br_multicast_is_router(br
, NULL
);
3843 spin_unlock_bh(&br
->multicast_lock
);
3846 EXPORT_SYMBOL_GPL(br_multicast_router
);
3848 int br_multicast_set_querier(struct net_bridge
*br
, unsigned long val
)
3850 unsigned long max_delay
;
3854 spin_lock_bh(&br
->multicast_lock
);
3855 if (br_opt_get(br
, BROPT_MULTICAST_QUERIER
) == val
)
3858 br_opt_toggle(br
, BROPT_MULTICAST_QUERIER
, !!val
);
3862 max_delay
= br
->multicast_query_response_interval
;
3864 if (!timer_pending(&br
->ip4_other_query
.timer
))
3865 br
->ip4_other_query
.delay_time
= jiffies
+ max_delay
;
3867 br_multicast_start_querier(br
, &br
->ip4_own_query
);
3869 #if IS_ENABLED(CONFIG_IPV6)
3870 if (!timer_pending(&br
->ip6_other_query
.timer
))
3871 br
->ip6_other_query
.delay_time
= jiffies
+ max_delay
;
3873 br_multicast_start_querier(br
, &br
->ip6_own_query
);
3877 spin_unlock_bh(&br
->multicast_lock
);
3882 int br_multicast_set_igmp_version(struct net_bridge
*br
, unsigned long val
)
3884 /* Currently we support only version 2 and 3 */
3893 spin_lock_bh(&br
->multicast_lock
);
3894 br
->multicast_igmp_version
= val
;
3895 spin_unlock_bh(&br
->multicast_lock
);
3900 #if IS_ENABLED(CONFIG_IPV6)
3901 int br_multicast_set_mld_version(struct net_bridge
*br
, unsigned long val
)
3903 /* Currently we support version 1 and 2 */
3912 spin_lock_bh(&br
->multicast_lock
);
3913 br
->multicast_mld_version
= val
;
3914 spin_unlock_bh(&br
->multicast_lock
);
3921 * br_multicast_list_adjacent - Returns snooped multicast addresses
3922 * @dev: The bridge port adjacent to which to retrieve addresses
3923 * @br_ip_list: The list to store found, snooped multicast IP addresses in
3925 * Creates a list of IP addresses (struct br_ip_list) sensed by the multicast
3926 * snooping feature on all bridge ports of dev's bridge device, excluding
3927 * the addresses from dev itself.
3929 * Returns the number of items added to br_ip_list.
3932 * - br_ip_list needs to be initialized by caller
3933 * - br_ip_list might contain duplicates in the end
3934 * (needs to be taken care of by caller)
3935 * - br_ip_list needs to be freed by caller
3937 int br_multicast_list_adjacent(struct net_device
*dev
,
3938 struct list_head
*br_ip_list
)
3940 struct net_bridge
*br
;
3941 struct net_bridge_port
*port
;
3942 struct net_bridge_port_group
*group
;
3943 struct br_ip_list
*entry
;
3947 if (!br_ip_list
|| !netif_is_bridge_port(dev
))
3950 port
= br_port_get_rcu(dev
);
3951 if (!port
|| !port
->br
)
3956 list_for_each_entry_rcu(port
, &br
->port_list
, list
) {
3957 if (!port
->dev
|| port
->dev
== dev
)
3960 hlist_for_each_entry_rcu(group
, &port
->mglist
, mglist
) {
3961 entry
= kmalloc(sizeof(*entry
), GFP_ATOMIC
);
3965 entry
->addr
= group
->key
.addr
;
3966 list_add(&entry
->list
, br_ip_list
);
3975 EXPORT_SYMBOL_GPL(br_multicast_list_adjacent
);
3978 * br_multicast_has_querier_anywhere - Checks for a querier on a bridge
3979 * @dev: The bridge port providing the bridge on which to check for a querier
3980 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
3982 * Checks whether the given interface has a bridge on top and if so returns
3983 * true if a valid querier exists anywhere on the bridged link layer.
3984 * Otherwise returns false.
3986 bool br_multicast_has_querier_anywhere(struct net_device
*dev
, int proto
)
3988 struct net_bridge
*br
;
3989 struct net_bridge_port
*port
;
3994 if (!netif_is_bridge_port(dev
))
3997 port
= br_port_get_rcu(dev
);
3998 if (!port
|| !port
->br
)
4003 memset(ð
, 0, sizeof(eth
));
4004 eth
.h_proto
= htons(proto
);
4006 ret
= br_multicast_querier_exists(br
, ð
, NULL
);
4012 EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere
);
4015 * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
4016 * @dev: The bridge port adjacent to which to check for a querier
4017 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
4019 * Checks whether the given interface has a bridge on top and if so returns
4020 * true if a selected querier is behind one of the other ports of this
4021 * bridge. Otherwise returns false.
4023 bool br_multicast_has_querier_adjacent(struct net_device
*dev
, int proto
)
4025 struct net_bridge
*br
;
4026 struct net_bridge_port
*port
;
4030 if (!netif_is_bridge_port(dev
))
4033 port
= br_port_get_rcu(dev
);
4034 if (!port
|| !port
->br
)
4041 if (!timer_pending(&br
->ip4_other_query
.timer
) ||
4042 rcu_dereference(br
->ip4_querier
.port
) == port
)
4045 #if IS_ENABLED(CONFIG_IPV6)
4047 if (!timer_pending(&br
->ip6_other_query
.timer
) ||
4048 rcu_dereference(br
->ip6_querier
.port
) == port
)
4061 EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent
);
4064 * br_multicast_has_router_adjacent - Checks for a router behind a bridge port
4065 * @dev: The bridge port adjacent to which to check for a multicast router
4066 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
4068 * Checks whether the given interface has a bridge on top and if so returns
4069 * true if a multicast router is behind one of the other ports of this
4070 * bridge. Otherwise returns false.
4072 bool br_multicast_has_router_adjacent(struct net_device
*dev
, int proto
)
4074 struct net_bridge_port
*port
, *p
;
4078 port
= br_port_get_check_rcu(dev
);
4084 hlist_for_each_entry_rcu(p
, &port
->br
->ip4_mc_router_list
,
4093 #if IS_ENABLED(CONFIG_IPV6)
4095 hlist_for_each_entry_rcu(p
, &port
->br
->ip6_mc_router_list
,
4106 /* when compiled without IPv6 support, be conservative and
4107 * always assume presence of an IPv6 multicast router
4116 EXPORT_SYMBOL_GPL(br_multicast_has_router_adjacent
);
4118 static void br_mcast_stats_add(struct bridge_mcast_stats __percpu
*stats
,
4119 const struct sk_buff
*skb
, u8 type
, u8 dir
)
4121 struct bridge_mcast_stats
*pstats
= this_cpu_ptr(stats
);
4122 __be16 proto
= skb
->protocol
;
4125 u64_stats_update_begin(&pstats
->syncp
);
4127 case htons(ETH_P_IP
):
4128 t_len
= ntohs(ip_hdr(skb
)->tot_len
) - ip_hdrlen(skb
);
4130 case IGMP_HOST_MEMBERSHIP_REPORT
:
4131 pstats
->mstats
.igmp_v1reports
[dir
]++;
4133 case IGMPV2_HOST_MEMBERSHIP_REPORT
:
4134 pstats
->mstats
.igmp_v2reports
[dir
]++;
4136 case IGMPV3_HOST_MEMBERSHIP_REPORT
:
4137 pstats
->mstats
.igmp_v3reports
[dir
]++;
4139 case IGMP_HOST_MEMBERSHIP_QUERY
:
4140 if (t_len
!= sizeof(struct igmphdr
)) {
4141 pstats
->mstats
.igmp_v3queries
[dir
]++;
4143 unsigned int offset
= skb_transport_offset(skb
);
4144 struct igmphdr
*ih
, _ihdr
;
4146 ih
= skb_header_pointer(skb
, offset
,
4147 sizeof(_ihdr
), &_ihdr
);
4151 pstats
->mstats
.igmp_v1queries
[dir
]++;
4153 pstats
->mstats
.igmp_v2queries
[dir
]++;
4156 case IGMP_HOST_LEAVE_MESSAGE
:
4157 pstats
->mstats
.igmp_leaves
[dir
]++;
4161 #if IS_ENABLED(CONFIG_IPV6)
4162 case htons(ETH_P_IPV6
):
4163 t_len
= ntohs(ipv6_hdr(skb
)->payload_len
) +
4164 sizeof(struct ipv6hdr
);
4165 t_len
-= skb_network_header_len(skb
);
4167 case ICMPV6_MGM_REPORT
:
4168 pstats
->mstats
.mld_v1reports
[dir
]++;
4170 case ICMPV6_MLD2_REPORT
:
4171 pstats
->mstats
.mld_v2reports
[dir
]++;
4173 case ICMPV6_MGM_QUERY
:
4174 if (t_len
!= sizeof(struct mld_msg
))
4175 pstats
->mstats
.mld_v2queries
[dir
]++;
4177 pstats
->mstats
.mld_v1queries
[dir
]++;
4179 case ICMPV6_MGM_REDUCTION
:
4180 pstats
->mstats
.mld_leaves
[dir
]++;
4184 #endif /* CONFIG_IPV6 */
4186 u64_stats_update_end(&pstats
->syncp
);
4189 void br_multicast_count(struct net_bridge
*br
, const struct net_bridge_port
*p
,
4190 const struct sk_buff
*skb
, u8 type
, u8 dir
)
4192 struct bridge_mcast_stats __percpu
*stats
;
4194 /* if multicast_disabled is true then igmp type can't be set */
4195 if (!type
|| !br_opt_get(br
, BROPT_MULTICAST_STATS_ENABLED
))
4199 stats
= p
->mcast_stats
;
4201 stats
= br
->mcast_stats
;
4202 if (WARN_ON(!stats
))
4205 br_mcast_stats_add(stats
, skb
, type
, dir
);
4208 int br_multicast_init_stats(struct net_bridge
*br
)
4210 br
->mcast_stats
= netdev_alloc_pcpu_stats(struct bridge_mcast_stats
);
4211 if (!br
->mcast_stats
)
4217 void br_multicast_uninit_stats(struct net_bridge
*br
)
4219 free_percpu(br
->mcast_stats
);
4222 /* noinline for https://bugs.llvm.org/show_bug.cgi?id=45802#c9 */
4223 static noinline_for_stack
void mcast_stats_add_dir(u64
*dst
, u64
*src
)
4225 dst
[BR_MCAST_DIR_RX
] += src
[BR_MCAST_DIR_RX
];
4226 dst
[BR_MCAST_DIR_TX
] += src
[BR_MCAST_DIR_TX
];
4229 void br_multicast_get_stats(const struct net_bridge
*br
,
4230 const struct net_bridge_port
*p
,
4231 struct br_mcast_stats
*dest
)
4233 struct bridge_mcast_stats __percpu
*stats
;
4234 struct br_mcast_stats tdst
;
4237 memset(dest
, 0, sizeof(*dest
));
4239 stats
= p
->mcast_stats
;
4241 stats
= br
->mcast_stats
;
4242 if (WARN_ON(!stats
))
4245 memset(&tdst
, 0, sizeof(tdst
));
4246 for_each_possible_cpu(i
) {
4247 struct bridge_mcast_stats
*cpu_stats
= per_cpu_ptr(stats
, i
);
4248 struct br_mcast_stats temp
;
4252 start
= u64_stats_fetch_begin_irq(&cpu_stats
->syncp
);
4253 memcpy(&temp
, &cpu_stats
->mstats
, sizeof(temp
));
4254 } while (u64_stats_fetch_retry_irq(&cpu_stats
->syncp
, start
));
4256 mcast_stats_add_dir(tdst
.igmp_v1queries
, temp
.igmp_v1queries
);
4257 mcast_stats_add_dir(tdst
.igmp_v2queries
, temp
.igmp_v2queries
);
4258 mcast_stats_add_dir(tdst
.igmp_v3queries
, temp
.igmp_v3queries
);
4259 mcast_stats_add_dir(tdst
.igmp_leaves
, temp
.igmp_leaves
);
4260 mcast_stats_add_dir(tdst
.igmp_v1reports
, temp
.igmp_v1reports
);
4261 mcast_stats_add_dir(tdst
.igmp_v2reports
, temp
.igmp_v2reports
);
4262 mcast_stats_add_dir(tdst
.igmp_v3reports
, temp
.igmp_v3reports
);
4263 tdst
.igmp_parse_errors
+= temp
.igmp_parse_errors
;
4265 mcast_stats_add_dir(tdst
.mld_v1queries
, temp
.mld_v1queries
);
4266 mcast_stats_add_dir(tdst
.mld_v2queries
, temp
.mld_v2queries
);
4267 mcast_stats_add_dir(tdst
.mld_leaves
, temp
.mld_leaves
);
4268 mcast_stats_add_dir(tdst
.mld_v1reports
, temp
.mld_v1reports
);
4269 mcast_stats_add_dir(tdst
.mld_v2reports
, temp
.mld_v2reports
);
4270 tdst
.mld_parse_errors
+= temp
.mld_parse_errors
;
4272 memcpy(dest
, &tdst
, sizeof(*dest
));
4275 int br_mdb_hash_init(struct net_bridge
*br
)
4279 err
= rhashtable_init(&br
->sg_port_tbl
, &br_sg_port_rht_params
);
4283 err
= rhashtable_init(&br
->mdb_hash_tbl
, &br_mdb_rht_params
);
4285 rhashtable_destroy(&br
->sg_port_tbl
);
4292 void br_mdb_hash_fini(struct net_bridge
*br
)
4294 rhashtable_destroy(&br
->sg_port_tbl
);
4295 rhashtable_destroy(&br
->mdb_hash_tbl
);