2 * Bridge multicast support.
4 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
13 #include <linux/err.h>
14 #include <linux/export.h>
15 #include <linux/if_ether.h>
16 #include <linux/igmp.h>
17 #include <linux/jhash.h>
18 #include <linux/kernel.h>
19 #include <linux/log2.h>
20 #include <linux/netdevice.h>
21 #include <linux/netfilter_bridge.h>
22 #include <linux/random.h>
23 #include <linux/rculist.h>
24 #include <linux/skbuff.h>
25 #include <linux/slab.h>
26 #include <linux/timer.h>
27 #include <linux/inetdevice.h>
28 #include <linux/mroute.h>
30 #include <net/switchdev.h>
31 #if IS_ENABLED(CONFIG_IPV6)
34 #include <net/ip6_checksum.h>
35 #include <net/addrconf.h>
38 #include "br_private.h"
40 static void br_multicast_start_querier(struct net_bridge
*br
,
41 struct bridge_mcast_own_query
*query
);
42 static void br_multicast_add_router(struct net_bridge
*br
,
43 struct net_bridge_port
*port
);
44 static void br_ip4_multicast_leave_group(struct net_bridge
*br
,
45 struct net_bridge_port
*port
,
48 const unsigned char *src
);
50 static void __del_port_router(struct net_bridge_port
*p
);
51 #if IS_ENABLED(CONFIG_IPV6)
52 static void br_ip6_multicast_leave_group(struct net_bridge
*br
,
53 struct net_bridge_port
*port
,
54 const struct in6_addr
*group
,
55 __u16 vid
, const unsigned char *src
);
57 unsigned int br_mdb_rehash_seq
;
59 static inline int br_ip_equal(const struct br_ip
*a
, const struct br_ip
*b
)
61 if (a
->proto
!= b
->proto
)
67 return a
->u
.ip4
== b
->u
.ip4
;
68 #if IS_ENABLED(CONFIG_IPV6)
69 case htons(ETH_P_IPV6
):
70 return ipv6_addr_equal(&a
->u
.ip6
, &b
->u
.ip6
);
76 static inline int __br_ip4_hash(struct net_bridge_mdb_htable
*mdb
, __be32 ip
,
79 return jhash_2words((__force u32
)ip
, vid
, mdb
->secret
) & (mdb
->max
- 1);
82 #if IS_ENABLED(CONFIG_IPV6)
83 static inline int __br_ip6_hash(struct net_bridge_mdb_htable
*mdb
,
84 const struct in6_addr
*ip
,
87 return jhash_2words(ipv6_addr_hash(ip
), vid
,
88 mdb
->secret
) & (mdb
->max
- 1);
92 static inline int br_ip_hash(struct net_bridge_mdb_htable
*mdb
,
97 return __br_ip4_hash(mdb
, ip
->u
.ip4
, ip
->vid
);
98 #if IS_ENABLED(CONFIG_IPV6)
99 case htons(ETH_P_IPV6
):
100 return __br_ip6_hash(mdb
, &ip
->u
.ip6
, ip
->vid
);
106 static struct net_bridge_mdb_entry
*__br_mdb_ip_get(
107 struct net_bridge_mdb_htable
*mdb
, struct br_ip
*dst
, int hash
)
109 struct net_bridge_mdb_entry
*mp
;
111 hlist_for_each_entry_rcu(mp
, &mdb
->mhash
[hash
], hlist
[mdb
->ver
]) {
112 if (br_ip_equal(&mp
->addr
, dst
))
119 struct net_bridge_mdb_entry
*br_mdb_ip_get(struct net_bridge_mdb_htable
*mdb
,
125 return __br_mdb_ip_get(mdb
, dst
, br_ip_hash(mdb
, dst
));
128 static struct net_bridge_mdb_entry
*br_mdb_ip4_get(
129 struct net_bridge_mdb_htable
*mdb
, __be32 dst
, __u16 vid
)
134 br_dst
.proto
= htons(ETH_P_IP
);
137 return br_mdb_ip_get(mdb
, &br_dst
);
140 #if IS_ENABLED(CONFIG_IPV6)
141 static struct net_bridge_mdb_entry
*br_mdb_ip6_get(
142 struct net_bridge_mdb_htable
*mdb
, const struct in6_addr
*dst
,
148 br_dst
.proto
= htons(ETH_P_IPV6
);
151 return br_mdb_ip_get(mdb
, &br_dst
);
155 struct net_bridge_mdb_entry
*br_mdb_get(struct net_bridge
*br
,
156 struct sk_buff
*skb
, u16 vid
)
158 struct net_bridge_mdb_htable
*mdb
= rcu_dereference(br
->mdb
);
161 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
164 if (BR_INPUT_SKB_CB(skb
)->igmp
)
167 ip
.proto
= skb
->protocol
;
170 switch (skb
->protocol
) {
171 case htons(ETH_P_IP
):
172 ip
.u
.ip4
= ip_hdr(skb
)->daddr
;
174 #if IS_ENABLED(CONFIG_IPV6)
175 case htons(ETH_P_IPV6
):
176 ip
.u
.ip6
= ipv6_hdr(skb
)->daddr
;
183 return br_mdb_ip_get(mdb
, &ip
);
186 static void br_mdb_free(struct rcu_head
*head
)
188 struct net_bridge_mdb_htable
*mdb
=
189 container_of(head
, struct net_bridge_mdb_htable
, rcu
);
190 struct net_bridge_mdb_htable
*old
= mdb
->old
;
197 static int br_mdb_copy(struct net_bridge_mdb_htable
*new,
198 struct net_bridge_mdb_htable
*old
,
201 struct net_bridge_mdb_entry
*mp
;
206 for (i
= 0; i
< old
->max
; i
++)
207 hlist_for_each_entry(mp
, &old
->mhash
[i
], hlist
[old
->ver
])
208 hlist_add_head(&mp
->hlist
[new->ver
],
209 &new->mhash
[br_ip_hash(new, &mp
->addr
)]);
215 for (i
= 0; i
< new->max
; i
++) {
217 hlist_for_each_entry(mp
, &new->mhash
[i
], hlist
[new->ver
])
223 return maxlen
> elasticity
? -EINVAL
: 0;
226 void br_multicast_free_pg(struct rcu_head
*head
)
228 struct net_bridge_port_group
*p
=
229 container_of(head
, struct net_bridge_port_group
, rcu
);
234 static void br_multicast_free_group(struct rcu_head
*head
)
236 struct net_bridge_mdb_entry
*mp
=
237 container_of(head
, struct net_bridge_mdb_entry
, rcu
);
242 static void br_multicast_group_expired(struct timer_list
*t
)
244 struct net_bridge_mdb_entry
*mp
= from_timer(mp
, t
, timer
);
245 struct net_bridge
*br
= mp
->br
;
246 struct net_bridge_mdb_htable
*mdb
;
248 spin_lock(&br
->multicast_lock
);
249 if (!netif_running(br
->dev
) || timer_pending(&mp
->timer
))
252 mp
->host_joined
= false;
253 br_mdb_notify(br
->dev
, NULL
, &mp
->addr
, RTM_DELMDB
, 0);
258 mdb
= mlock_dereference(br
->mdb
, br
);
260 hlist_del_rcu(&mp
->hlist
[mdb
->ver
]);
263 call_rcu_bh(&mp
->rcu
, br_multicast_free_group
);
266 spin_unlock(&br
->multicast_lock
);
269 static void br_multicast_del_pg(struct net_bridge
*br
,
270 struct net_bridge_port_group
*pg
)
272 struct net_bridge_mdb_htable
*mdb
;
273 struct net_bridge_mdb_entry
*mp
;
274 struct net_bridge_port_group
*p
;
275 struct net_bridge_port_group __rcu
**pp
;
277 mdb
= mlock_dereference(br
->mdb
, br
);
279 mp
= br_mdb_ip_get(mdb
, &pg
->addr
);
283 for (pp
= &mp
->ports
;
284 (p
= mlock_dereference(*pp
, br
)) != NULL
;
289 rcu_assign_pointer(*pp
, p
->next
);
290 hlist_del_init(&p
->mglist
);
291 del_timer(&p
->timer
);
292 br_mdb_notify(br
->dev
, p
->port
, &pg
->addr
, RTM_DELMDB
,
294 call_rcu_bh(&p
->rcu
, br_multicast_free_pg
);
296 if (!mp
->ports
&& !mp
->host_joined
&&
297 netif_running(br
->dev
))
298 mod_timer(&mp
->timer
, jiffies
);
306 static void br_multicast_port_group_expired(struct timer_list
*t
)
308 struct net_bridge_port_group
*pg
= from_timer(pg
, t
, timer
);
309 struct net_bridge
*br
= pg
->port
->br
;
311 spin_lock(&br
->multicast_lock
);
312 if (!netif_running(br
->dev
) || timer_pending(&pg
->timer
) ||
313 hlist_unhashed(&pg
->mglist
) || pg
->flags
& MDB_PG_FLAGS_PERMANENT
)
316 br_multicast_del_pg(br
, pg
);
319 spin_unlock(&br
->multicast_lock
);
322 static int br_mdb_rehash(struct net_bridge_mdb_htable __rcu
**mdbp
, int max
,
325 struct net_bridge_mdb_htable
*old
= rcu_dereference_protected(*mdbp
, 1);
326 struct net_bridge_mdb_htable
*mdb
;
329 mdb
= kmalloc(sizeof(*mdb
), GFP_ATOMIC
);
336 mdb
->mhash
= kcalloc(max
, sizeof(*mdb
->mhash
), GFP_ATOMIC
);
342 mdb
->size
= old
? old
->size
: 0;
343 mdb
->ver
= old
? old
->ver
^ 1 : 0;
345 if (!old
|| elasticity
)
346 get_random_bytes(&mdb
->secret
, sizeof(mdb
->secret
));
348 mdb
->secret
= old
->secret
;
353 err
= br_mdb_copy(mdb
, old
, elasticity
);
361 call_rcu_bh(&mdb
->rcu
, br_mdb_free
);
364 rcu_assign_pointer(*mdbp
, mdb
);
369 static struct sk_buff
*br_ip4_multicast_alloc_query(struct net_bridge
*br
,
373 struct igmpv3_query
*ihv3
;
374 size_t igmp_hdr_size
;
380 igmp_hdr_size
= sizeof(*ih
);
381 if (br
->multicast_igmp_version
== 3)
382 igmp_hdr_size
= sizeof(*ihv3
);
383 skb
= netdev_alloc_skb_ip_align(br
->dev
, sizeof(*eth
) + sizeof(*iph
) +
388 skb
->protocol
= htons(ETH_P_IP
);
390 skb_reset_mac_header(skb
);
393 ether_addr_copy(eth
->h_source
, br
->dev
->dev_addr
);
396 eth
->h_dest
[2] = 0x5e;
400 eth
->h_proto
= htons(ETH_P_IP
);
401 skb_put(skb
, sizeof(*eth
));
403 skb_set_network_header(skb
, skb
->len
);
409 iph
->tot_len
= htons(sizeof(*iph
) + igmp_hdr_size
+ 4);
411 iph
->frag_off
= htons(IP_DF
);
413 iph
->protocol
= IPPROTO_IGMP
;
414 iph
->saddr
= br_opt_get(br
, BROPT_MULTICAST_QUERY_USE_IFADDR
) ?
415 inet_select_addr(br
->dev
, 0, RT_SCOPE_LINK
) : 0;
416 iph
->daddr
= htonl(INADDR_ALLHOSTS_GROUP
);
417 ((u8
*)&iph
[1])[0] = IPOPT_RA
;
418 ((u8
*)&iph
[1])[1] = 4;
419 ((u8
*)&iph
[1])[2] = 0;
420 ((u8
*)&iph
[1])[3] = 0;
424 skb_set_transport_header(skb
, skb
->len
);
425 *igmp_type
= IGMP_HOST_MEMBERSHIP_QUERY
;
427 switch (br
->multicast_igmp_version
) {
430 ih
->type
= IGMP_HOST_MEMBERSHIP_QUERY
;
431 ih
->code
= (group
? br
->multicast_last_member_interval
:
432 br
->multicast_query_response_interval
) /
433 (HZ
/ IGMP_TIMER_SCALE
);
436 ih
->csum
= ip_compute_csum((void *)ih
, sizeof(*ih
));
439 ihv3
= igmpv3_query_hdr(skb
);
440 ihv3
->type
= IGMP_HOST_MEMBERSHIP_QUERY
;
441 ihv3
->code
= (group
? br
->multicast_last_member_interval
:
442 br
->multicast_query_response_interval
) /
443 (HZ
/ IGMP_TIMER_SCALE
);
445 ihv3
->qqic
= br
->multicast_query_interval
/ HZ
;
451 ihv3
->csum
= ip_compute_csum((void *)ihv3
, sizeof(*ihv3
));
455 skb_put(skb
, igmp_hdr_size
);
456 __skb_pull(skb
, sizeof(*eth
));
462 #if IS_ENABLED(CONFIG_IPV6)
463 static struct sk_buff
*br_ip6_multicast_alloc_query(struct net_bridge
*br
,
464 const struct in6_addr
*grp
,
467 struct mld2_query
*mld2q
;
468 unsigned long interval
;
469 struct ipv6hdr
*ip6h
;
470 struct mld_msg
*mldq
;
476 mld_hdr_size
= sizeof(*mldq
);
477 if (br
->multicast_mld_version
== 2)
478 mld_hdr_size
= sizeof(*mld2q
);
479 skb
= netdev_alloc_skb_ip_align(br
->dev
, sizeof(*eth
) + sizeof(*ip6h
) +
484 skb
->protocol
= htons(ETH_P_IPV6
);
486 /* Ethernet header */
487 skb_reset_mac_header(skb
);
490 ether_addr_copy(eth
->h_source
, br
->dev
->dev_addr
);
491 eth
->h_proto
= htons(ETH_P_IPV6
);
492 skb_put(skb
, sizeof(*eth
));
494 /* IPv6 header + HbH option */
495 skb_set_network_header(skb
, skb
->len
);
496 ip6h
= ipv6_hdr(skb
);
498 *(__force __be32
*)ip6h
= htonl(0x60000000);
499 ip6h
->payload_len
= htons(8 + mld_hdr_size
);
500 ip6h
->nexthdr
= IPPROTO_HOPOPTS
;
502 ipv6_addr_set(&ip6h
->daddr
, htonl(0xff020000), 0, 0, htonl(1));
503 if (ipv6_dev_get_saddr(dev_net(br
->dev
), br
->dev
, &ip6h
->daddr
, 0,
506 br_opt_toggle(br
, BROPT_HAS_IPV6_ADDR
, false);
510 br_opt_toggle(br
, BROPT_HAS_IPV6_ADDR
, true);
511 ipv6_eth_mc_map(&ip6h
->daddr
, eth
->h_dest
);
513 hopopt
= (u8
*)(ip6h
+ 1);
514 hopopt
[0] = IPPROTO_ICMPV6
; /* next hdr */
515 hopopt
[1] = 0; /* length of HbH */
516 hopopt
[2] = IPV6_TLV_ROUTERALERT
; /* Router Alert */
517 hopopt
[3] = 2; /* Length of RA Option */
518 hopopt
[4] = 0; /* Type = 0x0000 (MLD) */
520 hopopt
[6] = IPV6_TLV_PAD1
; /* Pad1 */
521 hopopt
[7] = IPV6_TLV_PAD1
; /* Pad1 */
523 skb_put(skb
, sizeof(*ip6h
) + 8);
526 skb_set_transport_header(skb
, skb
->len
);
527 interval
= ipv6_addr_any(grp
) ?
528 br
->multicast_query_response_interval
:
529 br
->multicast_last_member_interval
;
530 *igmp_type
= ICMPV6_MGM_QUERY
;
531 switch (br
->multicast_mld_version
) {
533 mldq
= (struct mld_msg
*)icmp6_hdr(skb
);
534 mldq
->mld_type
= ICMPV6_MGM_QUERY
;
537 mldq
->mld_maxdelay
= htons((u16
)jiffies_to_msecs(interval
));
538 mldq
->mld_reserved
= 0;
539 mldq
->mld_mca
= *grp
;
540 mldq
->mld_cksum
= csum_ipv6_magic(&ip6h
->saddr
, &ip6h
->daddr
,
541 sizeof(*mldq
), IPPROTO_ICMPV6
,
547 mld2q
= (struct mld2_query
*)icmp6_hdr(skb
);
548 mld2q
->mld2q_mrc
= htons((u16
)jiffies_to_msecs(interval
));
549 mld2q
->mld2q_type
= ICMPV6_MGM_QUERY
;
550 mld2q
->mld2q_code
= 0;
551 mld2q
->mld2q_cksum
= 0;
552 mld2q
->mld2q_resv1
= 0;
553 mld2q
->mld2q_resv2
= 0;
554 mld2q
->mld2q_suppress
= 0;
555 mld2q
->mld2q_qrv
= 2;
556 mld2q
->mld2q_nsrcs
= 0;
557 mld2q
->mld2q_qqic
= br
->multicast_query_interval
/ HZ
;
558 mld2q
->mld2q_mca
= *grp
;
559 mld2q
->mld2q_cksum
= csum_ipv6_magic(&ip6h
->saddr
, &ip6h
->daddr
,
567 skb_put(skb
, mld_hdr_size
);
569 __skb_pull(skb
, sizeof(*eth
));
576 static struct sk_buff
*br_multicast_alloc_query(struct net_bridge
*br
,
580 switch (addr
->proto
) {
581 case htons(ETH_P_IP
):
582 return br_ip4_multicast_alloc_query(br
, addr
->u
.ip4
, igmp_type
);
583 #if IS_ENABLED(CONFIG_IPV6)
584 case htons(ETH_P_IPV6
):
585 return br_ip6_multicast_alloc_query(br
, &addr
->u
.ip6
,
592 static struct net_bridge_mdb_entry
*br_multicast_get_group(
593 struct net_bridge
*br
, struct net_bridge_port
*port
,
594 struct br_ip
*group
, int hash
)
596 struct net_bridge_mdb_htable
*mdb
;
597 struct net_bridge_mdb_entry
*mp
;
598 unsigned int count
= 0;
603 mdb
= rcu_dereference_protected(br
->mdb
, 1);
604 hlist_for_each_entry(mp
, &mdb
->mhash
[hash
], hlist
[mdb
->ver
]) {
606 if (unlikely(br_ip_equal(group
, &mp
->addr
)))
613 if (unlikely(count
> br
->hash_elasticity
&& count
)) {
615 br_info(br
, "Multicast hash table "
616 "chain limit reached: %s\n",
617 port
? port
->dev
->name
: br
->dev
->name
);
619 elasticity
= br
->hash_elasticity
;
622 if (mdb
->size
>= max
) {
624 if (unlikely(max
> br
->hash_max
)) {
625 br_warn(br
, "Multicast hash table maximum of %d "
626 "reached, disabling snooping: %s\n",
628 port
? port
->dev
->name
: br
->dev
->name
);
631 br_opt_toggle(br
, BROPT_MULTICAST_ENABLED
, false);
636 if (max
> mdb
->max
|| elasticity
) {
639 br_info(br
, "Multicast hash table "
641 port
? port
->dev
->name
: br
->dev
->name
);
646 err
= br_mdb_rehash(&br
->mdb
, max
, elasticity
);
648 br_warn(br
, "Cannot rehash multicast "
649 "hash table, disabling snooping: %s, %d, %d\n",
650 port
? port
->dev
->name
: br
->dev
->name
,
666 struct net_bridge_mdb_entry
*br_multicast_new_group(struct net_bridge
*br
,
667 struct net_bridge_port
*p
,
670 struct net_bridge_mdb_htable
*mdb
;
671 struct net_bridge_mdb_entry
*mp
;
675 mdb
= rcu_dereference_protected(br
->mdb
, 1);
677 err
= br_mdb_rehash(&br
->mdb
, BR_HASH_SIZE
, 0);
683 hash
= br_ip_hash(mdb
, group
);
684 mp
= br_multicast_get_group(br
, p
, group
, hash
);
685 switch (PTR_ERR(mp
)) {
691 mdb
= rcu_dereference_protected(br
->mdb
, 1);
692 hash
= br_ip_hash(mdb
, group
);
699 mp
= kzalloc(sizeof(*mp
), GFP_ATOMIC
);
701 return ERR_PTR(-ENOMEM
);
705 timer_setup(&mp
->timer
, br_multicast_group_expired
, 0);
707 hlist_add_head_rcu(&mp
->hlist
[mdb
->ver
], &mdb
->mhash
[hash
]);
714 struct net_bridge_port_group
*br_multicast_new_port_group(
715 struct net_bridge_port
*port
,
717 struct net_bridge_port_group __rcu
*next
,
719 const unsigned char *src
)
721 struct net_bridge_port_group
*p
;
723 p
= kzalloc(sizeof(*p
), GFP_ATOMIC
);
730 rcu_assign_pointer(p
->next
, next
);
731 hlist_add_head(&p
->mglist
, &port
->mglist
);
732 timer_setup(&p
->timer
, br_multicast_port_group_expired
, 0);
735 memcpy(p
->eth_addr
, src
, ETH_ALEN
);
737 memset(p
->eth_addr
, 0xff, ETH_ALEN
);
742 static bool br_port_group_equal(struct net_bridge_port_group
*p
,
743 struct net_bridge_port
*port
,
744 const unsigned char *src
)
749 if (!(port
->flags
& BR_MULTICAST_TO_UNICAST
))
752 return ether_addr_equal(src
, p
->eth_addr
);
755 static int br_multicast_add_group(struct net_bridge
*br
,
756 struct net_bridge_port
*port
,
758 const unsigned char *src
)
760 struct net_bridge_port_group __rcu
**pp
;
761 struct net_bridge_port_group
*p
;
762 struct net_bridge_mdb_entry
*mp
;
763 unsigned long now
= jiffies
;
766 spin_lock(&br
->multicast_lock
);
767 if (!netif_running(br
->dev
) ||
768 (port
&& port
->state
== BR_STATE_DISABLED
))
771 mp
= br_multicast_new_group(br
, port
, group
);
777 if (!mp
->host_joined
) {
778 mp
->host_joined
= true;
779 br_mdb_notify(br
->dev
, NULL
, &mp
->addr
, RTM_NEWMDB
, 0);
781 mod_timer(&mp
->timer
, now
+ br
->multicast_membership_interval
);
785 for (pp
= &mp
->ports
;
786 (p
= mlock_dereference(*pp
, br
)) != NULL
;
788 if (br_port_group_equal(p
, port
, src
))
790 if ((unsigned long)p
->port
< (unsigned long)port
)
794 p
= br_multicast_new_port_group(port
, group
, *pp
, 0, src
);
797 rcu_assign_pointer(*pp
, p
);
798 br_mdb_notify(br
->dev
, port
, group
, RTM_NEWMDB
, 0);
801 mod_timer(&p
->timer
, now
+ br
->multicast_membership_interval
);
806 spin_unlock(&br
->multicast_lock
);
810 static int br_ip4_multicast_add_group(struct net_bridge
*br
,
811 struct net_bridge_port
*port
,
814 const unsigned char *src
)
816 struct br_ip br_group
;
818 if (ipv4_is_local_multicast(group
))
821 br_group
.u
.ip4
= group
;
822 br_group
.proto
= htons(ETH_P_IP
);
825 return br_multicast_add_group(br
, port
, &br_group
, src
);
828 #if IS_ENABLED(CONFIG_IPV6)
829 static int br_ip6_multicast_add_group(struct net_bridge
*br
,
830 struct net_bridge_port
*port
,
831 const struct in6_addr
*group
,
833 const unsigned char *src
)
835 struct br_ip br_group
;
837 if (ipv6_addr_is_ll_all_nodes(group
))
840 br_group
.u
.ip6
= *group
;
841 br_group
.proto
= htons(ETH_P_IPV6
);
844 return br_multicast_add_group(br
, port
, &br_group
, src
);
848 static void br_multicast_router_expired(struct timer_list
*t
)
850 struct net_bridge_port
*port
=
851 from_timer(port
, t
, multicast_router_timer
);
852 struct net_bridge
*br
= port
->br
;
854 spin_lock(&br
->multicast_lock
);
855 if (port
->multicast_router
== MDB_RTR_TYPE_DISABLED
||
856 port
->multicast_router
== MDB_RTR_TYPE_PERM
||
857 timer_pending(&port
->multicast_router_timer
))
860 __del_port_router(port
);
862 spin_unlock(&br
->multicast_lock
);
865 static void br_mc_router_state_change(struct net_bridge
*p
,
868 struct switchdev_attr attr
= {
870 .id
= SWITCHDEV_ATTR_ID_BRIDGE_MROUTER
,
871 .flags
= SWITCHDEV_F_DEFER
,
872 .u
.mrouter
= is_mc_router
,
875 switchdev_port_attr_set(p
->dev
, &attr
);
878 static void br_multicast_local_router_expired(struct timer_list
*t
)
880 struct net_bridge
*br
= from_timer(br
, t
, multicast_router_timer
);
882 spin_lock(&br
->multicast_lock
);
883 if (br
->multicast_router
== MDB_RTR_TYPE_DISABLED
||
884 br
->multicast_router
== MDB_RTR_TYPE_PERM
||
885 timer_pending(&br
->multicast_router_timer
))
888 br_mc_router_state_change(br
, false);
890 spin_unlock(&br
->multicast_lock
);
893 static void br_multicast_querier_expired(struct net_bridge
*br
,
894 struct bridge_mcast_own_query
*query
)
896 spin_lock(&br
->multicast_lock
);
897 if (!netif_running(br
->dev
) || !br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
900 br_multicast_start_querier(br
, query
);
903 spin_unlock(&br
->multicast_lock
);
906 static void br_ip4_multicast_querier_expired(struct timer_list
*t
)
908 struct net_bridge
*br
= from_timer(br
, t
, ip4_other_query
.timer
);
910 br_multicast_querier_expired(br
, &br
->ip4_own_query
);
913 #if IS_ENABLED(CONFIG_IPV6)
914 static void br_ip6_multicast_querier_expired(struct timer_list
*t
)
916 struct net_bridge
*br
= from_timer(br
, t
, ip6_other_query
.timer
);
918 br_multicast_querier_expired(br
, &br
->ip6_own_query
);
922 static void br_multicast_select_own_querier(struct net_bridge
*br
,
926 if (ip
->proto
== htons(ETH_P_IP
))
927 br
->ip4_querier
.addr
.u
.ip4
= ip_hdr(skb
)->saddr
;
928 #if IS_ENABLED(CONFIG_IPV6)
930 br
->ip6_querier
.addr
.u
.ip6
= ipv6_hdr(skb
)->saddr
;
934 static void __br_multicast_send_query(struct net_bridge
*br
,
935 struct net_bridge_port
*port
,
941 skb
= br_multicast_alloc_query(br
, ip
, &igmp_type
);
946 skb
->dev
= port
->dev
;
947 br_multicast_count(br
, port
, skb
, igmp_type
,
949 NF_HOOK(NFPROTO_BRIDGE
, NF_BR_LOCAL_OUT
,
950 dev_net(port
->dev
), NULL
, skb
, NULL
, skb
->dev
,
951 br_dev_queue_push_xmit
);
953 br_multicast_select_own_querier(br
, ip
, skb
);
954 br_multicast_count(br
, port
, skb
, igmp_type
,
960 static void br_multicast_send_query(struct net_bridge
*br
,
961 struct net_bridge_port
*port
,
962 struct bridge_mcast_own_query
*own_query
)
964 struct bridge_mcast_other_query
*other_query
= NULL
;
965 struct br_ip br_group
;
968 if (!netif_running(br
->dev
) ||
969 !br_opt_get(br
, BROPT_MULTICAST_ENABLED
) ||
970 !br_opt_get(br
, BROPT_MULTICAST_QUERIER
))
973 memset(&br_group
.u
, 0, sizeof(br_group
.u
));
975 if (port
? (own_query
== &port
->ip4_own_query
) :
976 (own_query
== &br
->ip4_own_query
)) {
977 other_query
= &br
->ip4_other_query
;
978 br_group
.proto
= htons(ETH_P_IP
);
979 #if IS_ENABLED(CONFIG_IPV6)
981 other_query
= &br
->ip6_other_query
;
982 br_group
.proto
= htons(ETH_P_IPV6
);
986 if (!other_query
|| timer_pending(&other_query
->timer
))
989 __br_multicast_send_query(br
, port
, &br_group
);
992 time
+= own_query
->startup_sent
< br
->multicast_startup_query_count
?
993 br
->multicast_startup_query_interval
:
994 br
->multicast_query_interval
;
995 mod_timer(&own_query
->timer
, time
);
999 br_multicast_port_query_expired(struct net_bridge_port
*port
,
1000 struct bridge_mcast_own_query
*query
)
1002 struct net_bridge
*br
= port
->br
;
1004 spin_lock(&br
->multicast_lock
);
1005 if (port
->state
== BR_STATE_DISABLED
||
1006 port
->state
== BR_STATE_BLOCKING
)
1009 if (query
->startup_sent
< br
->multicast_startup_query_count
)
1010 query
->startup_sent
++;
1012 br_multicast_send_query(port
->br
, port
, query
);
1015 spin_unlock(&br
->multicast_lock
);
1018 static void br_ip4_multicast_port_query_expired(struct timer_list
*t
)
1020 struct net_bridge_port
*port
= from_timer(port
, t
, ip4_own_query
.timer
);
1022 br_multicast_port_query_expired(port
, &port
->ip4_own_query
);
1025 #if IS_ENABLED(CONFIG_IPV6)
1026 static void br_ip6_multicast_port_query_expired(struct timer_list
*t
)
1028 struct net_bridge_port
*port
= from_timer(port
, t
, ip6_own_query
.timer
);
1030 br_multicast_port_query_expired(port
, &port
->ip6_own_query
);
1034 static void br_mc_disabled_update(struct net_device
*dev
, bool value
)
1036 struct switchdev_attr attr
= {
1038 .id
= SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED
,
1039 .flags
= SWITCHDEV_F_DEFER
,
1040 .u
.mc_disabled
= !value
,
1043 switchdev_port_attr_set(dev
, &attr
);
1046 int br_multicast_add_port(struct net_bridge_port
*port
)
1048 port
->multicast_router
= MDB_RTR_TYPE_TEMP_QUERY
;
1050 timer_setup(&port
->multicast_router_timer
,
1051 br_multicast_router_expired
, 0);
1052 timer_setup(&port
->ip4_own_query
.timer
,
1053 br_ip4_multicast_port_query_expired
, 0);
1054 #if IS_ENABLED(CONFIG_IPV6)
1055 timer_setup(&port
->ip6_own_query
.timer
,
1056 br_ip6_multicast_port_query_expired
, 0);
1058 br_mc_disabled_update(port
->dev
,
1059 br_opt_get(port
->br
, BROPT_MULTICAST_ENABLED
));
1061 port
->mcast_stats
= netdev_alloc_pcpu_stats(struct bridge_mcast_stats
);
1062 if (!port
->mcast_stats
)
1068 void br_multicast_del_port(struct net_bridge_port
*port
)
1070 struct net_bridge
*br
= port
->br
;
1071 struct net_bridge_port_group
*pg
;
1072 struct hlist_node
*n
;
1074 /* Take care of the remaining groups, only perm ones should be left */
1075 spin_lock_bh(&br
->multicast_lock
);
1076 hlist_for_each_entry_safe(pg
, n
, &port
->mglist
, mglist
)
1077 br_multicast_del_pg(br
, pg
);
1078 spin_unlock_bh(&br
->multicast_lock
);
1079 del_timer_sync(&port
->multicast_router_timer
);
1080 free_percpu(port
->mcast_stats
);
1083 static void br_multicast_enable(struct bridge_mcast_own_query
*query
)
1085 query
->startup_sent
= 0;
1087 if (try_to_del_timer_sync(&query
->timer
) >= 0 ||
1088 del_timer(&query
->timer
))
1089 mod_timer(&query
->timer
, jiffies
);
1092 static void __br_multicast_enable_port(struct net_bridge_port
*port
)
1094 struct net_bridge
*br
= port
->br
;
1096 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
) || !netif_running(br
->dev
))
1099 br_multicast_enable(&port
->ip4_own_query
);
1100 #if IS_ENABLED(CONFIG_IPV6)
1101 br_multicast_enable(&port
->ip6_own_query
);
1103 if (port
->multicast_router
== MDB_RTR_TYPE_PERM
&&
1104 hlist_unhashed(&port
->rlist
))
1105 br_multicast_add_router(br
, port
);
1108 void br_multicast_enable_port(struct net_bridge_port
*port
)
1110 struct net_bridge
*br
= port
->br
;
1112 spin_lock(&br
->multicast_lock
);
1113 __br_multicast_enable_port(port
);
1114 spin_unlock(&br
->multicast_lock
);
1117 void br_multicast_disable_port(struct net_bridge_port
*port
)
1119 struct net_bridge
*br
= port
->br
;
1120 struct net_bridge_port_group
*pg
;
1121 struct hlist_node
*n
;
1123 spin_lock(&br
->multicast_lock
);
1124 hlist_for_each_entry_safe(pg
, n
, &port
->mglist
, mglist
)
1125 if (!(pg
->flags
& MDB_PG_FLAGS_PERMANENT
))
1126 br_multicast_del_pg(br
, pg
);
1128 __del_port_router(port
);
1130 del_timer(&port
->multicast_router_timer
);
1131 del_timer(&port
->ip4_own_query
.timer
);
1132 #if IS_ENABLED(CONFIG_IPV6)
1133 del_timer(&port
->ip6_own_query
.timer
);
1135 spin_unlock(&br
->multicast_lock
);
1138 static int br_ip4_multicast_igmp3_report(struct net_bridge
*br
,
1139 struct net_bridge_port
*port
,
1140 struct sk_buff
*skb
,
1143 const unsigned char *src
;
1144 struct igmpv3_report
*ih
;
1145 struct igmpv3_grec
*grec
;
1153 ih
= igmpv3_report_hdr(skb
);
1154 num
= ntohs(ih
->ngrec
);
1155 len
= skb_transport_offset(skb
) + sizeof(*ih
);
1157 for (i
= 0; i
< num
; i
++) {
1158 len
+= sizeof(*grec
);
1159 if (!pskb_may_pull(skb
, len
))
1162 grec
= (void *)(skb
->data
+ len
- sizeof(*grec
));
1163 group
= grec
->grec_mca
;
1164 type
= grec
->grec_type
;
1166 len
+= ntohs(grec
->grec_nsrcs
) * 4;
1167 if (!pskb_may_pull(skb
, len
))
1170 /* We treat this as an IGMPv2 report for now. */
1172 case IGMPV3_MODE_IS_INCLUDE
:
1173 case IGMPV3_MODE_IS_EXCLUDE
:
1174 case IGMPV3_CHANGE_TO_INCLUDE
:
1175 case IGMPV3_CHANGE_TO_EXCLUDE
:
1176 case IGMPV3_ALLOW_NEW_SOURCES
:
1177 case IGMPV3_BLOCK_OLD_SOURCES
:
1184 src
= eth_hdr(skb
)->h_source
;
1185 if ((type
== IGMPV3_CHANGE_TO_INCLUDE
||
1186 type
== IGMPV3_MODE_IS_INCLUDE
) &&
1187 ntohs(grec
->grec_nsrcs
) == 0) {
1188 br_ip4_multicast_leave_group(br
, port
, group
, vid
, src
);
1190 err
= br_ip4_multicast_add_group(br
, port
, group
, vid
,
1200 #if IS_ENABLED(CONFIG_IPV6)
1201 static int br_ip6_multicast_mld2_report(struct net_bridge
*br
,
1202 struct net_bridge_port
*port
,
1203 struct sk_buff
*skb
,
1206 const unsigned char *src
;
1207 struct icmp6hdr
*icmp6h
;
1208 struct mld2_grec
*grec
;
1214 if (!pskb_may_pull(skb
, sizeof(*icmp6h
)))
1217 icmp6h
= icmp6_hdr(skb
);
1218 num
= ntohs(icmp6h
->icmp6_dataun
.un_data16
[1]);
1219 len
= skb_transport_offset(skb
) + sizeof(*icmp6h
);
1221 for (i
= 0; i
< num
; i
++) {
1222 __be16
*nsrcs
, _nsrcs
;
1224 nsrcs
= skb_header_pointer(skb
,
1225 len
+ offsetof(struct mld2_grec
,
1227 sizeof(_nsrcs
), &_nsrcs
);
1231 if (!pskb_may_pull(skb
,
1232 len
+ sizeof(*grec
) +
1233 sizeof(struct in6_addr
) * ntohs(*nsrcs
)))
1236 grec
= (struct mld2_grec
*)(skb
->data
+ len
);
1237 len
+= sizeof(*grec
) +
1238 sizeof(struct in6_addr
) * ntohs(*nsrcs
);
1240 /* We treat these as MLDv1 reports for now. */
1241 switch (grec
->grec_type
) {
1242 case MLD2_MODE_IS_INCLUDE
:
1243 case MLD2_MODE_IS_EXCLUDE
:
1244 case MLD2_CHANGE_TO_INCLUDE
:
1245 case MLD2_CHANGE_TO_EXCLUDE
:
1246 case MLD2_ALLOW_NEW_SOURCES
:
1247 case MLD2_BLOCK_OLD_SOURCES
:
1254 src
= eth_hdr(skb
)->h_source
;
1255 if ((grec
->grec_type
== MLD2_CHANGE_TO_INCLUDE
||
1256 grec
->grec_type
== MLD2_MODE_IS_INCLUDE
) &&
1257 ntohs(*nsrcs
) == 0) {
1258 br_ip6_multicast_leave_group(br
, port
, &grec
->grec_mca
,
1261 err
= br_ip6_multicast_add_group(br
, port
,
1262 &grec
->grec_mca
, vid
,
1273 static bool br_ip4_multicast_select_querier(struct net_bridge
*br
,
1274 struct net_bridge_port
*port
,
1277 if (!timer_pending(&br
->ip4_own_query
.timer
) &&
1278 !timer_pending(&br
->ip4_other_query
.timer
))
1281 if (!br
->ip4_querier
.addr
.u
.ip4
)
1284 if (ntohl(saddr
) <= ntohl(br
->ip4_querier
.addr
.u
.ip4
))
1290 br
->ip4_querier
.addr
.u
.ip4
= saddr
;
1292 /* update protected by general multicast_lock by caller */
1293 rcu_assign_pointer(br
->ip4_querier
.port
, port
);
1298 #if IS_ENABLED(CONFIG_IPV6)
1299 static bool br_ip6_multicast_select_querier(struct net_bridge
*br
,
1300 struct net_bridge_port
*port
,
1301 struct in6_addr
*saddr
)
1303 if (!timer_pending(&br
->ip6_own_query
.timer
) &&
1304 !timer_pending(&br
->ip6_other_query
.timer
))
1307 if (ipv6_addr_cmp(saddr
, &br
->ip6_querier
.addr
.u
.ip6
) <= 0)
1313 br
->ip6_querier
.addr
.u
.ip6
= *saddr
;
1315 /* update protected by general multicast_lock by caller */
1316 rcu_assign_pointer(br
->ip6_querier
.port
, port
);
1322 static bool br_multicast_select_querier(struct net_bridge
*br
,
1323 struct net_bridge_port
*port
,
1324 struct br_ip
*saddr
)
1326 switch (saddr
->proto
) {
1327 case htons(ETH_P_IP
):
1328 return br_ip4_multicast_select_querier(br
, port
, saddr
->u
.ip4
);
1329 #if IS_ENABLED(CONFIG_IPV6)
1330 case htons(ETH_P_IPV6
):
1331 return br_ip6_multicast_select_querier(br
, port
, &saddr
->u
.ip6
);
1339 br_multicast_update_query_timer(struct net_bridge
*br
,
1340 struct bridge_mcast_other_query
*query
,
1341 unsigned long max_delay
)
1343 if (!timer_pending(&query
->timer
))
1344 query
->delay_time
= jiffies
+ max_delay
;
1346 mod_timer(&query
->timer
, jiffies
+ br
->multicast_querier_interval
);
1349 static void br_port_mc_router_state_change(struct net_bridge_port
*p
,
1352 struct switchdev_attr attr
= {
1354 .id
= SWITCHDEV_ATTR_ID_PORT_MROUTER
,
1355 .flags
= SWITCHDEV_F_DEFER
,
1356 .u
.mrouter
= is_mc_router
,
1359 switchdev_port_attr_set(p
->dev
, &attr
);
1363 * Add port to router_list
1364 * list is maintained ordered by pointer value
1365 * and locked by br->multicast_lock and RCU
1367 static void br_multicast_add_router(struct net_bridge
*br
,
1368 struct net_bridge_port
*port
)
1370 struct net_bridge_port
*p
;
1371 struct hlist_node
*slot
= NULL
;
1373 if (!hlist_unhashed(&port
->rlist
))
1376 hlist_for_each_entry(p
, &br
->router_list
, rlist
) {
1377 if ((unsigned long) port
>= (unsigned long) p
)
1383 hlist_add_behind_rcu(&port
->rlist
, slot
);
1385 hlist_add_head_rcu(&port
->rlist
, &br
->router_list
);
1386 br_rtr_notify(br
->dev
, port
, RTM_NEWMDB
);
1387 br_port_mc_router_state_change(port
, true);
1390 static void br_multicast_mark_router(struct net_bridge
*br
,
1391 struct net_bridge_port
*port
)
1393 unsigned long now
= jiffies
;
1396 if (br
->multicast_router
== MDB_RTR_TYPE_TEMP_QUERY
) {
1397 if (!timer_pending(&br
->multicast_router_timer
))
1398 br_mc_router_state_change(br
, true);
1399 mod_timer(&br
->multicast_router_timer
,
1400 now
+ br
->multicast_querier_interval
);
1405 if (port
->multicast_router
== MDB_RTR_TYPE_DISABLED
||
1406 port
->multicast_router
== MDB_RTR_TYPE_PERM
)
1409 br_multicast_add_router(br
, port
);
1411 mod_timer(&port
->multicast_router_timer
,
1412 now
+ br
->multicast_querier_interval
);
1415 static void br_multicast_query_received(struct net_bridge
*br
,
1416 struct net_bridge_port
*port
,
1417 struct bridge_mcast_other_query
*query
,
1418 struct br_ip
*saddr
,
1419 unsigned long max_delay
)
1421 if (!br_multicast_select_querier(br
, port
, saddr
))
1424 br_multicast_update_query_timer(br
, query
, max_delay
);
1425 br_multicast_mark_router(br
, port
);
1428 static void br_ip4_multicast_query(struct net_bridge
*br
,
1429 struct net_bridge_port
*port
,
1430 struct sk_buff
*skb
,
1433 const struct iphdr
*iph
= ip_hdr(skb
);
1434 struct igmphdr
*ih
= igmp_hdr(skb
);
1435 struct net_bridge_mdb_entry
*mp
;
1436 struct igmpv3_query
*ih3
;
1437 struct net_bridge_port_group
*p
;
1438 struct net_bridge_port_group __rcu
**pp
;
1440 unsigned long max_delay
;
1441 unsigned long now
= jiffies
;
1442 unsigned int offset
= skb_transport_offset(skb
);
1445 spin_lock(&br
->multicast_lock
);
1446 if (!netif_running(br
->dev
) ||
1447 (port
&& port
->state
== BR_STATE_DISABLED
))
1452 if (skb
->len
== offset
+ sizeof(*ih
)) {
1453 max_delay
= ih
->code
* (HZ
/ IGMP_TIMER_SCALE
);
1456 max_delay
= 10 * HZ
;
1459 } else if (skb
->len
>= offset
+ sizeof(*ih3
)) {
1460 ih3
= igmpv3_query_hdr(skb
);
1464 max_delay
= ih3
->code
?
1465 IGMPV3_MRC(ih3
->code
) * (HZ
/ IGMP_TIMER_SCALE
) : 1;
1471 saddr
.proto
= htons(ETH_P_IP
);
1472 saddr
.u
.ip4
= iph
->saddr
;
1474 br_multicast_query_received(br
, port
, &br
->ip4_other_query
,
1479 mp
= br_mdb_ip4_get(mlock_dereference(br
->mdb
, br
), group
, vid
);
1483 max_delay
*= br
->multicast_last_member_count
;
1485 if (mp
->host_joined
&&
1486 (timer_pending(&mp
->timer
) ?
1487 time_after(mp
->timer
.expires
, now
+ max_delay
) :
1488 try_to_del_timer_sync(&mp
->timer
) >= 0))
1489 mod_timer(&mp
->timer
, now
+ max_delay
);
1491 for (pp
= &mp
->ports
;
1492 (p
= mlock_dereference(*pp
, br
)) != NULL
;
1494 if (timer_pending(&p
->timer
) ?
1495 time_after(p
->timer
.expires
, now
+ max_delay
) :
1496 try_to_del_timer_sync(&p
->timer
) >= 0)
1497 mod_timer(&p
->timer
, now
+ max_delay
);
1501 spin_unlock(&br
->multicast_lock
);
1504 #if IS_ENABLED(CONFIG_IPV6)
1505 static int br_ip6_multicast_query(struct net_bridge
*br
,
1506 struct net_bridge_port
*port
,
1507 struct sk_buff
*skb
,
1510 const struct ipv6hdr
*ip6h
= ipv6_hdr(skb
);
1511 struct mld_msg
*mld
;
1512 struct net_bridge_mdb_entry
*mp
;
1513 struct mld2_query
*mld2q
;
1514 struct net_bridge_port_group
*p
;
1515 struct net_bridge_port_group __rcu
**pp
;
1517 unsigned long max_delay
;
1518 unsigned long now
= jiffies
;
1519 unsigned int offset
= skb_transport_offset(skb
);
1520 const struct in6_addr
*group
= NULL
;
1521 bool is_general_query
;
1524 spin_lock(&br
->multicast_lock
);
1525 if (!netif_running(br
->dev
) ||
1526 (port
&& port
->state
== BR_STATE_DISABLED
))
1529 if (skb
->len
== offset
+ sizeof(*mld
)) {
1530 if (!pskb_may_pull(skb
, offset
+ sizeof(*mld
))) {
1534 mld
= (struct mld_msg
*) icmp6_hdr(skb
);
1535 max_delay
= msecs_to_jiffies(ntohs(mld
->mld_maxdelay
));
1537 group
= &mld
->mld_mca
;
1539 if (!pskb_may_pull(skb
, offset
+ sizeof(*mld2q
))) {
1543 mld2q
= (struct mld2_query
*)icmp6_hdr(skb
);
1544 if (!mld2q
->mld2q_nsrcs
)
1545 group
= &mld2q
->mld2q_mca
;
1547 max_delay
= max(msecs_to_jiffies(mldv2_mrc(mld2q
)), 1UL);
1550 is_general_query
= group
&& ipv6_addr_any(group
);
1552 if (is_general_query
) {
1553 saddr
.proto
= htons(ETH_P_IPV6
);
1554 saddr
.u
.ip6
= ip6h
->saddr
;
1556 br_multicast_query_received(br
, port
, &br
->ip6_other_query
,
1559 } else if (!group
) {
1563 mp
= br_mdb_ip6_get(mlock_dereference(br
->mdb
, br
), group
, vid
);
1567 max_delay
*= br
->multicast_last_member_count
;
1568 if (mp
->host_joined
&&
1569 (timer_pending(&mp
->timer
) ?
1570 time_after(mp
->timer
.expires
, now
+ max_delay
) :
1571 try_to_del_timer_sync(&mp
->timer
) >= 0))
1572 mod_timer(&mp
->timer
, now
+ max_delay
);
1574 for (pp
= &mp
->ports
;
1575 (p
= mlock_dereference(*pp
, br
)) != NULL
;
1577 if (timer_pending(&p
->timer
) ?
1578 time_after(p
->timer
.expires
, now
+ max_delay
) :
1579 try_to_del_timer_sync(&p
->timer
) >= 0)
1580 mod_timer(&p
->timer
, now
+ max_delay
);
1584 spin_unlock(&br
->multicast_lock
);
1590 br_multicast_leave_group(struct net_bridge
*br
,
1591 struct net_bridge_port
*port
,
1592 struct br_ip
*group
,
1593 struct bridge_mcast_other_query
*other_query
,
1594 struct bridge_mcast_own_query
*own_query
,
1595 const unsigned char *src
)
1597 struct net_bridge_mdb_htable
*mdb
;
1598 struct net_bridge_mdb_entry
*mp
;
1599 struct net_bridge_port_group
*p
;
1603 spin_lock(&br
->multicast_lock
);
1604 if (!netif_running(br
->dev
) ||
1605 (port
&& port
->state
== BR_STATE_DISABLED
))
1608 mdb
= mlock_dereference(br
->mdb
, br
);
1609 mp
= br_mdb_ip_get(mdb
, group
);
1613 if (port
&& (port
->flags
& BR_MULTICAST_FAST_LEAVE
)) {
1614 struct net_bridge_port_group __rcu
**pp
;
1616 for (pp
= &mp
->ports
;
1617 (p
= mlock_dereference(*pp
, br
)) != NULL
;
1619 if (!br_port_group_equal(p
, port
, src
))
1622 rcu_assign_pointer(*pp
, p
->next
);
1623 hlist_del_init(&p
->mglist
);
1624 del_timer(&p
->timer
);
1625 call_rcu_bh(&p
->rcu
, br_multicast_free_pg
);
1626 br_mdb_notify(br
->dev
, port
, group
, RTM_DELMDB
,
1629 if (!mp
->ports
&& !mp
->host_joined
&&
1630 netif_running(br
->dev
))
1631 mod_timer(&mp
->timer
, jiffies
);
1636 if (timer_pending(&other_query
->timer
))
1639 if (br_opt_get(br
, BROPT_MULTICAST_QUERIER
)) {
1640 __br_multicast_send_query(br
, port
, &mp
->addr
);
1642 time
= jiffies
+ br
->multicast_last_member_count
*
1643 br
->multicast_last_member_interval
;
1645 mod_timer(&own_query
->timer
, time
);
1647 for (p
= mlock_dereference(mp
->ports
, br
);
1649 p
= mlock_dereference(p
->next
, br
)) {
1650 if (!br_port_group_equal(p
, port
, src
))
1653 if (!hlist_unhashed(&p
->mglist
) &&
1654 (timer_pending(&p
->timer
) ?
1655 time_after(p
->timer
.expires
, time
) :
1656 try_to_del_timer_sync(&p
->timer
) >= 0)) {
1657 mod_timer(&p
->timer
, time
);
1665 time
= now
+ br
->multicast_last_member_count
*
1666 br
->multicast_last_member_interval
;
1669 if (mp
->host_joined
&&
1670 (timer_pending(&mp
->timer
) ?
1671 time_after(mp
->timer
.expires
, time
) :
1672 try_to_del_timer_sync(&mp
->timer
) >= 0)) {
1673 mod_timer(&mp
->timer
, time
);
1679 for (p
= mlock_dereference(mp
->ports
, br
);
1681 p
= mlock_dereference(p
->next
, br
)) {
1682 if (p
->port
!= port
)
1685 if (!hlist_unhashed(&p
->mglist
) &&
1686 (timer_pending(&p
->timer
) ?
1687 time_after(p
->timer
.expires
, time
) :
1688 try_to_del_timer_sync(&p
->timer
) >= 0)) {
1689 mod_timer(&p
->timer
, time
);
1695 spin_unlock(&br
->multicast_lock
);
1698 static void br_ip4_multicast_leave_group(struct net_bridge
*br
,
1699 struct net_bridge_port
*port
,
1702 const unsigned char *src
)
1704 struct br_ip br_group
;
1705 struct bridge_mcast_own_query
*own_query
;
1707 if (ipv4_is_local_multicast(group
))
1710 own_query
= port
? &port
->ip4_own_query
: &br
->ip4_own_query
;
1712 br_group
.u
.ip4
= group
;
1713 br_group
.proto
= htons(ETH_P_IP
);
1716 br_multicast_leave_group(br
, port
, &br_group
, &br
->ip4_other_query
,
1720 #if IS_ENABLED(CONFIG_IPV6)
1721 static void br_ip6_multicast_leave_group(struct net_bridge
*br
,
1722 struct net_bridge_port
*port
,
1723 const struct in6_addr
*group
,
1725 const unsigned char *src
)
1727 struct br_ip br_group
;
1728 struct bridge_mcast_own_query
*own_query
;
1730 if (ipv6_addr_is_ll_all_nodes(group
))
1733 own_query
= port
? &port
->ip6_own_query
: &br
->ip6_own_query
;
1735 br_group
.u
.ip6
= *group
;
1736 br_group
.proto
= htons(ETH_P_IPV6
);
1739 br_multicast_leave_group(br
, port
, &br_group
, &br
->ip6_other_query
,
1744 static void br_multicast_err_count(const struct net_bridge
*br
,
1745 const struct net_bridge_port
*p
,
1748 struct bridge_mcast_stats __percpu
*stats
;
1749 struct bridge_mcast_stats
*pstats
;
1751 if (!br_opt_get(br
, BROPT_MULTICAST_STATS_ENABLED
))
1755 stats
= p
->mcast_stats
;
1757 stats
= br
->mcast_stats
;
1758 if (WARN_ON(!stats
))
1761 pstats
= this_cpu_ptr(stats
);
1763 u64_stats_update_begin(&pstats
->syncp
);
1765 case htons(ETH_P_IP
):
1766 pstats
->mstats
.igmp_parse_errors
++;
1768 #if IS_ENABLED(CONFIG_IPV6)
1769 case htons(ETH_P_IPV6
):
1770 pstats
->mstats
.mld_parse_errors
++;
1774 u64_stats_update_end(&pstats
->syncp
);
1777 static void br_multicast_pim(struct net_bridge
*br
,
1778 struct net_bridge_port
*port
,
1779 const struct sk_buff
*skb
)
1781 unsigned int offset
= skb_transport_offset(skb
);
1782 struct pimhdr
*pimhdr
, _pimhdr
;
1784 pimhdr
= skb_header_pointer(skb
, offset
, sizeof(_pimhdr
), &_pimhdr
);
1785 if (!pimhdr
|| pim_hdr_version(pimhdr
) != PIM_VERSION
||
1786 pim_hdr_type(pimhdr
) != PIM_TYPE_HELLO
)
1789 br_multicast_mark_router(br
, port
);
1792 static int br_multicast_ipv4_rcv(struct net_bridge
*br
,
1793 struct net_bridge_port
*port
,
1794 struct sk_buff
*skb
,
1797 struct sk_buff
*skb_trimmed
= NULL
;
1798 const unsigned char *src
;
1802 err
= ip_mc_check_igmp(skb
, &skb_trimmed
);
1804 if (err
== -ENOMSG
) {
1805 if (!ipv4_is_local_multicast(ip_hdr(skb
)->daddr
)) {
1806 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 1;
1807 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb
)->daddr
)) {
1808 if (ip_hdr(skb
)->protocol
== IPPROTO_PIM
)
1809 br_multicast_pim(br
, port
, skb
);
1812 } else if (err
< 0) {
1813 br_multicast_err_count(br
, port
, skb
->protocol
);
1818 src
= eth_hdr(skb
)->h_source
;
1819 BR_INPUT_SKB_CB(skb
)->igmp
= ih
->type
;
1822 case IGMP_HOST_MEMBERSHIP_REPORT
:
1823 case IGMPV2_HOST_MEMBERSHIP_REPORT
:
1824 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 1;
1825 err
= br_ip4_multicast_add_group(br
, port
, ih
->group
, vid
, src
);
1827 case IGMPV3_HOST_MEMBERSHIP_REPORT
:
1828 err
= br_ip4_multicast_igmp3_report(br
, port
, skb_trimmed
, vid
);
1830 case IGMP_HOST_MEMBERSHIP_QUERY
:
1831 br_ip4_multicast_query(br
, port
, skb_trimmed
, vid
);
1833 case IGMP_HOST_LEAVE_MESSAGE
:
1834 br_ip4_multicast_leave_group(br
, port
, ih
->group
, vid
, src
);
1838 if (skb_trimmed
&& skb_trimmed
!= skb
)
1839 kfree_skb(skb_trimmed
);
1841 br_multicast_count(br
, port
, skb
, BR_INPUT_SKB_CB(skb
)->igmp
,
1847 #if IS_ENABLED(CONFIG_IPV6)
1848 static int br_multicast_ipv6_rcv(struct net_bridge
*br
,
1849 struct net_bridge_port
*port
,
1850 struct sk_buff
*skb
,
1853 struct sk_buff
*skb_trimmed
= NULL
;
1854 const unsigned char *src
;
1855 struct mld_msg
*mld
;
1858 err
= ipv6_mc_check_mld(skb
, &skb_trimmed
);
1860 if (err
== -ENOMSG
) {
1861 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb
)->daddr
))
1862 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 1;
1864 } else if (err
< 0) {
1865 br_multicast_err_count(br
, port
, skb
->protocol
);
1869 mld
= (struct mld_msg
*)skb_transport_header(skb
);
1870 BR_INPUT_SKB_CB(skb
)->igmp
= mld
->mld_type
;
1872 switch (mld
->mld_type
) {
1873 case ICMPV6_MGM_REPORT
:
1874 src
= eth_hdr(skb
)->h_source
;
1875 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 1;
1876 err
= br_ip6_multicast_add_group(br
, port
, &mld
->mld_mca
, vid
,
1879 case ICMPV6_MLD2_REPORT
:
1880 err
= br_ip6_multicast_mld2_report(br
, port
, skb_trimmed
, vid
);
1882 case ICMPV6_MGM_QUERY
:
1883 err
= br_ip6_multicast_query(br
, port
, skb_trimmed
, vid
);
1885 case ICMPV6_MGM_REDUCTION
:
1886 src
= eth_hdr(skb
)->h_source
;
1887 br_ip6_multicast_leave_group(br
, port
, &mld
->mld_mca
, vid
, src
);
1891 if (skb_trimmed
&& skb_trimmed
!= skb
)
1892 kfree_skb(skb_trimmed
);
1894 br_multicast_count(br
, port
, skb
, BR_INPUT_SKB_CB(skb
)->igmp
,
1901 int br_multicast_rcv(struct net_bridge
*br
, struct net_bridge_port
*port
,
1902 struct sk_buff
*skb
, u16 vid
)
1906 BR_INPUT_SKB_CB(skb
)->igmp
= 0;
1907 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 0;
1909 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
1912 switch (skb
->protocol
) {
1913 case htons(ETH_P_IP
):
1914 ret
= br_multicast_ipv4_rcv(br
, port
, skb
, vid
);
1916 #if IS_ENABLED(CONFIG_IPV6)
1917 case htons(ETH_P_IPV6
):
1918 ret
= br_multicast_ipv6_rcv(br
, port
, skb
, vid
);
1926 static void br_multicast_query_expired(struct net_bridge
*br
,
1927 struct bridge_mcast_own_query
*query
,
1928 struct bridge_mcast_querier
*querier
)
1930 spin_lock(&br
->multicast_lock
);
1931 if (query
->startup_sent
< br
->multicast_startup_query_count
)
1932 query
->startup_sent
++;
1934 RCU_INIT_POINTER(querier
->port
, NULL
);
1935 br_multicast_send_query(br
, NULL
, query
);
1936 spin_unlock(&br
->multicast_lock
);
1939 static void br_ip4_multicast_query_expired(struct timer_list
*t
)
1941 struct net_bridge
*br
= from_timer(br
, t
, ip4_own_query
.timer
);
1943 br_multicast_query_expired(br
, &br
->ip4_own_query
, &br
->ip4_querier
);
1946 #if IS_ENABLED(CONFIG_IPV6)
1947 static void br_ip6_multicast_query_expired(struct timer_list
*t
)
1949 struct net_bridge
*br
= from_timer(br
, t
, ip6_own_query
.timer
);
1951 br_multicast_query_expired(br
, &br
->ip6_own_query
, &br
->ip6_querier
);
1955 void br_multicast_init(struct net_bridge
*br
)
1957 br
->hash_elasticity
= 4;
1960 br
->multicast_router
= MDB_RTR_TYPE_TEMP_QUERY
;
1961 br
->multicast_last_member_count
= 2;
1962 br
->multicast_startup_query_count
= 2;
1964 br
->multicast_last_member_interval
= HZ
;
1965 br
->multicast_query_response_interval
= 10 * HZ
;
1966 br
->multicast_startup_query_interval
= 125 * HZ
/ 4;
1967 br
->multicast_query_interval
= 125 * HZ
;
1968 br
->multicast_querier_interval
= 255 * HZ
;
1969 br
->multicast_membership_interval
= 260 * HZ
;
1971 br
->ip4_other_query
.delay_time
= 0;
1972 br
->ip4_querier
.port
= NULL
;
1973 br
->multicast_igmp_version
= 2;
1974 #if IS_ENABLED(CONFIG_IPV6)
1975 br
->multicast_mld_version
= 1;
1976 br
->ip6_other_query
.delay_time
= 0;
1977 br
->ip6_querier
.port
= NULL
;
1979 br_opt_toggle(br
, BROPT_HAS_IPV6_ADDR
, true);
1981 spin_lock_init(&br
->multicast_lock
);
1982 timer_setup(&br
->multicast_router_timer
,
1983 br_multicast_local_router_expired
, 0);
1984 timer_setup(&br
->ip4_other_query
.timer
,
1985 br_ip4_multicast_querier_expired
, 0);
1986 timer_setup(&br
->ip4_own_query
.timer
,
1987 br_ip4_multicast_query_expired
, 0);
1988 #if IS_ENABLED(CONFIG_IPV6)
1989 timer_setup(&br
->ip6_other_query
.timer
,
1990 br_ip6_multicast_querier_expired
, 0);
1991 timer_setup(&br
->ip6_own_query
.timer
,
1992 br_ip6_multicast_query_expired
, 0);
1996 static void __br_multicast_open(struct net_bridge
*br
,
1997 struct bridge_mcast_own_query
*query
)
1999 query
->startup_sent
= 0;
2001 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
2004 mod_timer(&query
->timer
, jiffies
);
2007 void br_multicast_open(struct net_bridge
*br
)
2009 __br_multicast_open(br
, &br
->ip4_own_query
);
2010 #if IS_ENABLED(CONFIG_IPV6)
2011 __br_multicast_open(br
, &br
->ip6_own_query
);
2015 void br_multicast_stop(struct net_bridge
*br
)
2017 del_timer_sync(&br
->multicast_router_timer
);
2018 del_timer_sync(&br
->ip4_other_query
.timer
);
2019 del_timer_sync(&br
->ip4_own_query
.timer
);
2020 #if IS_ENABLED(CONFIG_IPV6)
2021 del_timer_sync(&br
->ip6_other_query
.timer
);
2022 del_timer_sync(&br
->ip6_own_query
.timer
);
2026 void br_multicast_dev_del(struct net_bridge
*br
)
2028 struct net_bridge_mdb_htable
*mdb
;
2029 struct net_bridge_mdb_entry
*mp
;
2030 struct hlist_node
*n
;
2034 spin_lock_bh(&br
->multicast_lock
);
2035 mdb
= mlock_dereference(br
->mdb
, br
);
2042 for (i
= 0; i
< mdb
->max
; i
++) {
2043 hlist_for_each_entry_safe(mp
, n
, &mdb
->mhash
[i
],
2045 del_timer(&mp
->timer
);
2046 call_rcu_bh(&mp
->rcu
, br_multicast_free_group
);
2051 spin_unlock_bh(&br
->multicast_lock
);
2053 spin_lock_bh(&br
->multicast_lock
);
2058 call_rcu_bh(&mdb
->rcu
, br_mdb_free
);
2061 spin_unlock_bh(&br
->multicast_lock
);
2064 int br_multicast_set_router(struct net_bridge
*br
, unsigned long val
)
2068 spin_lock_bh(&br
->multicast_lock
);
2071 case MDB_RTR_TYPE_DISABLED
:
2072 case MDB_RTR_TYPE_PERM
:
2073 br_mc_router_state_change(br
, val
== MDB_RTR_TYPE_PERM
);
2074 del_timer(&br
->multicast_router_timer
);
2075 br
->multicast_router
= val
;
2078 case MDB_RTR_TYPE_TEMP_QUERY
:
2079 if (br
->multicast_router
!= MDB_RTR_TYPE_TEMP_QUERY
)
2080 br_mc_router_state_change(br
, false);
2081 br
->multicast_router
= val
;
2086 spin_unlock_bh(&br
->multicast_lock
);
2091 static void __del_port_router(struct net_bridge_port
*p
)
2093 if (hlist_unhashed(&p
->rlist
))
2095 hlist_del_init_rcu(&p
->rlist
);
2096 br_rtr_notify(p
->br
->dev
, p
, RTM_DELMDB
);
2097 br_port_mc_router_state_change(p
, false);
2099 /* don't allow timer refresh */
2100 if (p
->multicast_router
== MDB_RTR_TYPE_TEMP
)
2101 p
->multicast_router
= MDB_RTR_TYPE_TEMP_QUERY
;
2104 int br_multicast_set_port_router(struct net_bridge_port
*p
, unsigned long val
)
2106 struct net_bridge
*br
= p
->br
;
2107 unsigned long now
= jiffies
;
2110 spin_lock(&br
->multicast_lock
);
2111 if (p
->multicast_router
== val
) {
2112 /* Refresh the temp router port timer */
2113 if (p
->multicast_router
== MDB_RTR_TYPE_TEMP
)
2114 mod_timer(&p
->multicast_router_timer
,
2115 now
+ br
->multicast_querier_interval
);
2120 case MDB_RTR_TYPE_DISABLED
:
2121 p
->multicast_router
= MDB_RTR_TYPE_DISABLED
;
2122 __del_port_router(p
);
2123 del_timer(&p
->multicast_router_timer
);
2125 case MDB_RTR_TYPE_TEMP_QUERY
:
2126 p
->multicast_router
= MDB_RTR_TYPE_TEMP_QUERY
;
2127 __del_port_router(p
);
2129 case MDB_RTR_TYPE_PERM
:
2130 p
->multicast_router
= MDB_RTR_TYPE_PERM
;
2131 del_timer(&p
->multicast_router_timer
);
2132 br_multicast_add_router(br
, p
);
2134 case MDB_RTR_TYPE_TEMP
:
2135 p
->multicast_router
= MDB_RTR_TYPE_TEMP
;
2136 br_multicast_mark_router(br
, p
);
2143 spin_unlock(&br
->multicast_lock
);
2148 static void br_multicast_start_querier(struct net_bridge
*br
,
2149 struct bridge_mcast_own_query
*query
)
2151 struct net_bridge_port
*port
;
2153 __br_multicast_open(br
, query
);
2155 list_for_each_entry(port
, &br
->port_list
, list
) {
2156 if (port
->state
== BR_STATE_DISABLED
||
2157 port
->state
== BR_STATE_BLOCKING
)
2160 if (query
== &br
->ip4_own_query
)
2161 br_multicast_enable(&port
->ip4_own_query
);
2162 #if IS_ENABLED(CONFIG_IPV6)
2164 br_multicast_enable(&port
->ip6_own_query
);
2169 int br_multicast_toggle(struct net_bridge
*br
, unsigned long val
)
2171 struct net_bridge_mdb_htable
*mdb
;
2172 struct net_bridge_port
*port
;
2175 spin_lock_bh(&br
->multicast_lock
);
2176 if (!!br_opt_get(br
, BROPT_MULTICAST_ENABLED
) == !!val
)
2179 br_mc_disabled_update(br
->dev
, val
);
2180 br_opt_toggle(br
, BROPT_MULTICAST_ENABLED
, !!val
);
2181 if (!br_opt_get(br
, BROPT_MULTICAST_ENABLED
))
2184 if (!netif_running(br
->dev
))
2187 mdb
= mlock_dereference(br
->mdb
, br
);
2192 br_opt_toggle(br
, BROPT_MULTICAST_ENABLED
, false);
2196 err
= br_mdb_rehash(&br
->mdb
, mdb
->max
,
2197 br
->hash_elasticity
);
2202 br_multicast_open(br
);
2203 list_for_each_entry(port
, &br
->port_list
, list
)
2204 __br_multicast_enable_port(port
);
2207 spin_unlock_bh(&br
->multicast_lock
);
2212 bool br_multicast_enabled(const struct net_device
*dev
)
2214 struct net_bridge
*br
= netdev_priv(dev
);
2216 return !!br_opt_get(br
, BROPT_MULTICAST_ENABLED
);
2218 EXPORT_SYMBOL_GPL(br_multicast_enabled
);
2220 bool br_multicast_router(const struct net_device
*dev
)
2222 struct net_bridge
*br
= netdev_priv(dev
);
2225 spin_lock_bh(&br
->multicast_lock
);
2226 is_router
= br_multicast_is_router(br
);
2227 spin_unlock_bh(&br
->multicast_lock
);
2230 EXPORT_SYMBOL_GPL(br_multicast_router
);
2232 int br_multicast_set_querier(struct net_bridge
*br
, unsigned long val
)
2234 unsigned long max_delay
;
2238 spin_lock_bh(&br
->multicast_lock
);
2239 if (br_opt_get(br
, BROPT_MULTICAST_QUERIER
) == val
)
2242 br_opt_toggle(br
, BROPT_MULTICAST_QUERIER
, !!val
);
2246 max_delay
= br
->multicast_query_response_interval
;
2248 if (!timer_pending(&br
->ip4_other_query
.timer
))
2249 br
->ip4_other_query
.delay_time
= jiffies
+ max_delay
;
2251 br_multicast_start_querier(br
, &br
->ip4_own_query
);
2253 #if IS_ENABLED(CONFIG_IPV6)
2254 if (!timer_pending(&br
->ip6_other_query
.timer
))
2255 br
->ip6_other_query
.delay_time
= jiffies
+ max_delay
;
2257 br_multicast_start_querier(br
, &br
->ip6_own_query
);
2261 spin_unlock_bh(&br
->multicast_lock
);
2266 int br_multicast_set_hash_max(struct net_bridge
*br
, unsigned long val
)
2270 struct net_bridge_mdb_htable
*mdb
;
2272 spin_lock_bh(&br
->multicast_lock
);
2273 if (!is_power_of_2(val
))
2276 mdb
= mlock_dereference(br
->mdb
, br
);
2277 if (mdb
&& val
< mdb
->size
)
2293 err
= br_mdb_rehash(&br
->mdb
, br
->hash_max
,
2294 br
->hash_elasticity
);
2300 spin_unlock_bh(&br
->multicast_lock
);
2305 int br_multicast_set_igmp_version(struct net_bridge
*br
, unsigned long val
)
2307 /* Currently we support only version 2 and 3 */
2316 spin_lock_bh(&br
->multicast_lock
);
2317 br
->multicast_igmp_version
= val
;
2318 spin_unlock_bh(&br
->multicast_lock
);
2323 #if IS_ENABLED(CONFIG_IPV6)
2324 int br_multicast_set_mld_version(struct net_bridge
*br
, unsigned long val
)
2326 /* Currently we support version 1 and 2 */
2335 spin_lock_bh(&br
->multicast_lock
);
2336 br
->multicast_mld_version
= val
;
2337 spin_unlock_bh(&br
->multicast_lock
);
2344 * br_multicast_list_adjacent - Returns snooped multicast addresses
2345 * @dev: The bridge port adjacent to which to retrieve addresses
2346 * @br_ip_list: The list to store found, snooped multicast IP addresses in
2348 * Creates a list of IP addresses (struct br_ip_list) sensed by the multicast
2349 * snooping feature on all bridge ports of dev's bridge device, excluding
2350 * the addresses from dev itself.
2352 * Returns the number of items added to br_ip_list.
2355 * - br_ip_list needs to be initialized by caller
2356 * - br_ip_list might contain duplicates in the end
2357 * (needs to be taken care of by caller)
2358 * - br_ip_list needs to be freed by caller
2360 int br_multicast_list_adjacent(struct net_device
*dev
,
2361 struct list_head
*br_ip_list
)
2363 struct net_bridge
*br
;
2364 struct net_bridge_port
*port
;
2365 struct net_bridge_port_group
*group
;
2366 struct br_ip_list
*entry
;
2370 if (!br_ip_list
|| !br_port_exists(dev
))
2373 port
= br_port_get_rcu(dev
);
2374 if (!port
|| !port
->br
)
2379 list_for_each_entry_rcu(port
, &br
->port_list
, list
) {
2380 if (!port
->dev
|| port
->dev
== dev
)
2383 hlist_for_each_entry_rcu(group
, &port
->mglist
, mglist
) {
2384 entry
= kmalloc(sizeof(*entry
), GFP_ATOMIC
);
2388 entry
->addr
= group
->addr
;
2389 list_add(&entry
->list
, br_ip_list
);
2398 EXPORT_SYMBOL_GPL(br_multicast_list_adjacent
);
2401 * br_multicast_has_querier_anywhere - Checks for a querier on a bridge
2402 * @dev: The bridge port providing the bridge on which to check for a querier
2403 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
2405 * Checks whether the given interface has a bridge on top and if so returns
2406 * true if a valid querier exists anywhere on the bridged link layer.
2407 * Otherwise returns false.
2409 bool br_multicast_has_querier_anywhere(struct net_device
*dev
, int proto
)
2411 struct net_bridge
*br
;
2412 struct net_bridge_port
*port
;
2417 if (!br_port_exists(dev
))
2420 port
= br_port_get_rcu(dev
);
2421 if (!port
|| !port
->br
)
2426 memset(ð
, 0, sizeof(eth
));
2427 eth
.h_proto
= htons(proto
);
2429 ret
= br_multicast_querier_exists(br
, ð
);
2435 EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere
);
2438 * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
2439 * @dev: The bridge port adjacent to which to check for a querier
2440 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
2442 * Checks whether the given interface has a bridge on top and if so returns
2443 * true if a selected querier is behind one of the other ports of this
2444 * bridge. Otherwise returns false.
2446 bool br_multicast_has_querier_adjacent(struct net_device
*dev
, int proto
)
2448 struct net_bridge
*br
;
2449 struct net_bridge_port
*port
;
2453 if (!br_port_exists(dev
))
2456 port
= br_port_get_rcu(dev
);
2457 if (!port
|| !port
->br
)
2464 if (!timer_pending(&br
->ip4_other_query
.timer
) ||
2465 rcu_dereference(br
->ip4_querier
.port
) == port
)
2468 #if IS_ENABLED(CONFIG_IPV6)
2470 if (!timer_pending(&br
->ip6_other_query
.timer
) ||
2471 rcu_dereference(br
->ip6_querier
.port
) == port
)
2484 EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent
);
2486 static void br_mcast_stats_add(struct bridge_mcast_stats __percpu
*stats
,
2487 const struct sk_buff
*skb
, u8 type
, u8 dir
)
2489 struct bridge_mcast_stats
*pstats
= this_cpu_ptr(stats
);
2490 __be16 proto
= skb
->protocol
;
2493 u64_stats_update_begin(&pstats
->syncp
);
2495 case htons(ETH_P_IP
):
2496 t_len
= ntohs(ip_hdr(skb
)->tot_len
) - ip_hdrlen(skb
);
2498 case IGMP_HOST_MEMBERSHIP_REPORT
:
2499 pstats
->mstats
.igmp_v1reports
[dir
]++;
2501 case IGMPV2_HOST_MEMBERSHIP_REPORT
:
2502 pstats
->mstats
.igmp_v2reports
[dir
]++;
2504 case IGMPV3_HOST_MEMBERSHIP_REPORT
:
2505 pstats
->mstats
.igmp_v3reports
[dir
]++;
2507 case IGMP_HOST_MEMBERSHIP_QUERY
:
2508 if (t_len
!= sizeof(struct igmphdr
)) {
2509 pstats
->mstats
.igmp_v3queries
[dir
]++;
2511 unsigned int offset
= skb_transport_offset(skb
);
2512 struct igmphdr
*ih
, _ihdr
;
2514 ih
= skb_header_pointer(skb
, offset
,
2515 sizeof(_ihdr
), &_ihdr
);
2519 pstats
->mstats
.igmp_v1queries
[dir
]++;
2521 pstats
->mstats
.igmp_v2queries
[dir
]++;
2524 case IGMP_HOST_LEAVE_MESSAGE
:
2525 pstats
->mstats
.igmp_leaves
[dir
]++;
2529 #if IS_ENABLED(CONFIG_IPV6)
2530 case htons(ETH_P_IPV6
):
2531 t_len
= ntohs(ipv6_hdr(skb
)->payload_len
) +
2532 sizeof(struct ipv6hdr
);
2533 t_len
-= skb_network_header_len(skb
);
2535 case ICMPV6_MGM_REPORT
:
2536 pstats
->mstats
.mld_v1reports
[dir
]++;
2538 case ICMPV6_MLD2_REPORT
:
2539 pstats
->mstats
.mld_v2reports
[dir
]++;
2541 case ICMPV6_MGM_QUERY
:
2542 if (t_len
!= sizeof(struct mld_msg
))
2543 pstats
->mstats
.mld_v2queries
[dir
]++;
2545 pstats
->mstats
.mld_v1queries
[dir
]++;
2547 case ICMPV6_MGM_REDUCTION
:
2548 pstats
->mstats
.mld_leaves
[dir
]++;
2552 #endif /* CONFIG_IPV6 */
2554 u64_stats_update_end(&pstats
->syncp
);
2557 void br_multicast_count(struct net_bridge
*br
, const struct net_bridge_port
*p
,
2558 const struct sk_buff
*skb
, u8 type
, u8 dir
)
2560 struct bridge_mcast_stats __percpu
*stats
;
2562 /* if multicast_disabled is true then igmp type can't be set */
2563 if (!type
|| !br_opt_get(br
, BROPT_MULTICAST_STATS_ENABLED
))
2567 stats
= p
->mcast_stats
;
2569 stats
= br
->mcast_stats
;
2570 if (WARN_ON(!stats
))
2573 br_mcast_stats_add(stats
, skb
, type
, dir
);
2576 int br_multicast_init_stats(struct net_bridge
*br
)
2578 br
->mcast_stats
= netdev_alloc_pcpu_stats(struct bridge_mcast_stats
);
2579 if (!br
->mcast_stats
)
2585 void br_multicast_uninit_stats(struct net_bridge
*br
)
2587 free_percpu(br
->mcast_stats
);
2590 static void mcast_stats_add_dir(u64
*dst
, u64
*src
)
2592 dst
[BR_MCAST_DIR_RX
] += src
[BR_MCAST_DIR_RX
];
2593 dst
[BR_MCAST_DIR_TX
] += src
[BR_MCAST_DIR_TX
];
2596 void br_multicast_get_stats(const struct net_bridge
*br
,
2597 const struct net_bridge_port
*p
,
2598 struct br_mcast_stats
*dest
)
2600 struct bridge_mcast_stats __percpu
*stats
;
2601 struct br_mcast_stats tdst
;
2604 memset(dest
, 0, sizeof(*dest
));
2606 stats
= p
->mcast_stats
;
2608 stats
= br
->mcast_stats
;
2609 if (WARN_ON(!stats
))
2612 memset(&tdst
, 0, sizeof(tdst
));
2613 for_each_possible_cpu(i
) {
2614 struct bridge_mcast_stats
*cpu_stats
= per_cpu_ptr(stats
, i
);
2615 struct br_mcast_stats temp
;
2619 start
= u64_stats_fetch_begin_irq(&cpu_stats
->syncp
);
2620 memcpy(&temp
, &cpu_stats
->mstats
, sizeof(temp
));
2621 } while (u64_stats_fetch_retry_irq(&cpu_stats
->syncp
, start
));
2623 mcast_stats_add_dir(tdst
.igmp_v1queries
, temp
.igmp_v1queries
);
2624 mcast_stats_add_dir(tdst
.igmp_v2queries
, temp
.igmp_v2queries
);
2625 mcast_stats_add_dir(tdst
.igmp_v3queries
, temp
.igmp_v3queries
);
2626 mcast_stats_add_dir(tdst
.igmp_leaves
, temp
.igmp_leaves
);
2627 mcast_stats_add_dir(tdst
.igmp_v1reports
, temp
.igmp_v1reports
);
2628 mcast_stats_add_dir(tdst
.igmp_v2reports
, temp
.igmp_v2reports
);
2629 mcast_stats_add_dir(tdst
.igmp_v3reports
, temp
.igmp_v3reports
);
2630 tdst
.igmp_parse_errors
+= temp
.igmp_parse_errors
;
2632 mcast_stats_add_dir(tdst
.mld_v1queries
, temp
.mld_v1queries
);
2633 mcast_stats_add_dir(tdst
.mld_v2queries
, temp
.mld_v2queries
);
2634 mcast_stats_add_dir(tdst
.mld_leaves
, temp
.mld_leaves
);
2635 mcast_stats_add_dir(tdst
.mld_v1reports
, temp
.mld_v1reports
);
2636 mcast_stats_add_dir(tdst
.mld_v2reports
, temp
.mld_v2reports
);
2637 tdst
.mld_parse_errors
+= temp
.mld_parse_errors
;
2639 memcpy(dest
, &tdst
, sizeof(*dest
));