projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: bridge: mcast: when igmpv3/mldv2 are enabled lookup (S,G) first, then (*,G)
[linux-block.git] / net / bridge / br_multicast.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
eb1d1641
HX		 2/*
3 * Bridge multicast support.
4 *
5 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
eb1d1641
HX		 6 */
7
8#include <linux/err.h>
07f8ac4a 9#include <linux/export.h>
eb1d1641
HX		 10#include <linux/if_ether.h>
11#include <linux/igmp.h>
4b3087c7 12#include <linux/in.h>
eb1d1641
HX		 13#include <linux/jhash.h>
14#include <linux/kernel.h>
b195167f 15#include <linux/log2.h>
eb1d1641
HX		 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>
1c8ad5bf 23#include <linux/inetdevice.h>
91b02d3d 24#include <linux/mroute.h>
eb1d1641 25#include <net/ip.h>
147c1e9b 26#include <net/switchdev.h>
dfd56b8b 27#if IS_ENABLED(CONFIG_IPV6)
4b3087c7 28#include <linux/icmpv6.h>
08b202b6
YH		 29#include <net/ipv6.h>
30#include <net/mld.h>
d4c4f07d 31#include <net/ip6_checksum.h>
3c3769e6 32#include <net/addrconf.h>
08b202b6 33#endif
eb1d1641
HX		 34
35#include "br_private.h"
36
19e3a9c9
NA		 37static const struct rhashtable_params br_mdb_rht_params = {
38 .head_offset = offsetof(struct net_bridge_mdb_entry, rhnode),
39 .key_offset = offsetof(struct net_bridge_mdb_entry, addr),
40 .key_len = sizeof(struct br_ip),
41 .automatic_shrinking = true,
19e3a9c9
NA		 42};
43
cc0fdd80 44static void br_multicast_start_querier(struct net_bridge *br,
90010b36 45 struct bridge_mcast_own_query *query);
754bc547
SA		 46static void br_multicast_add_router(struct net_bridge *br,
47 struct net_bridge_port *port);
bc8c20ac
SA		 48static void br_ip4_multicast_leave_group(struct net_bridge *br,
49 struct net_bridge_port *port,
50 __be32 group,
6db6f0ea
FF		 51 __u16 vid,
52 const unsigned char *src);
42c11ccf 53static void br_multicast_port_group_rexmit(struct timer_list *t);
6db6f0ea 54
f12e7d95 55static void __del_port_router(struct net_bridge_port *p);
bc8c20ac
SA		 56#if IS_ENABLED(CONFIG_IPV6)
57static void br_ip6_multicast_leave_group(struct net_bridge *br,
58 struct net_bridge_port *port,
59 const struct in6_addr *group,
6db6f0ea 60 __u16 vid, const unsigned char *src);
bc8c20ac 61#endif
c83b8fab 62
19e3a9c9
NA		 63static struct net_bridge_mdb_entry *br_mdb_ip_get_rcu(struct net_bridge *br,
64 struct br_ip *dst)
08b202b6 65{
19e3a9c9 66 return rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
08b202b6 67}
08b202b6 68
19e3a9c9
NA		 69struct net_bridge_mdb_entry *br_mdb_ip_get(struct net_bridge *br,
70 struct br_ip *dst)
eb1d1641 71{
19e3a9c9 72 struct net_bridge_mdb_entry *ent;
eb1d1641 73
19e3a9c9 74 lockdep_assert_held_once(&br->multicast_lock);
eb1d1641 75
19e3a9c9
NA		 76 rcu_read_lock();
77 ent = rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
78 rcu_read_unlock();
7f285fa7 79
19e3a9c9 80 return ent;
7f285fa7
HX		 81}
82
19e3a9c9
NA		 83static struct net_bridge_mdb_entry *br_mdb_ip4_get(struct net_bridge *br,
84 __be32 dst, __u16 vid)
eb1d1641 85{
8ef2a9a5
YH		 86 struct br_ip br_dst;
87
19e3a9c9 88 memset(&br_dst, 0, sizeof(br_dst));
eab3227b 89 br_dst.dst.ip4 = dst;
8ef2a9a5 90 br_dst.proto = htons(ETH_P_IP);
b0e9a30d 91 br_dst.vid = vid;
0821ec55 92
19e3a9c9 93 return br_mdb_ip_get(br, &br_dst);
8ef2a9a5
YH		 94}
95
dfd56b8b 96#if IS_ENABLED(CONFIG_IPV6)
19e3a9c9
NA		 97static struct net_bridge_mdb_entry *br_mdb_ip6_get(struct net_bridge *br,
98 const struct in6_addr *dst,
99 __u16 vid)
08b202b6
YH		 100{
101 struct br_ip br_dst;
0821ec55 102
19e3a9c9 103 memset(&br_dst, 0, sizeof(br_dst));
eab3227b 104 br_dst.dst.ip6 = *dst;
08b202b6 105 br_dst.proto = htons(ETH_P_IPV6);
b0e9a30d 106 br_dst.vid = vid;
08b202b6 107
19e3a9c9 108 return br_mdb_ip_get(br, &br_dst);
08b202b6
YH		 109}
110#endif
111
eb1d1641 112struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
fbca58a2 113 struct sk_buff *skb, u16 vid)
eb1d1641 114{
8ef2a9a5
YH		 115 struct br_ip ip;
116
13cefad2 117 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
eb1d1641
HX		 118 return NULL;
119
8ef2a9a5 120 if (BR_INPUT_SKB_CB(skb)->igmp)
eb1d1641
HX		 121 return NULL;
122
19e3a9c9 123 memset(&ip, 0, sizeof(ip));
8ef2a9a5 124 ip.proto = skb->protocol;
fbca58a2 125 ip.vid = vid;
8ef2a9a5 126
eb1d1641
HX		 127 switch (skb->protocol) {
128 case htons(ETH_P_IP):
eab3227b 129 ip.dst.ip4 = ip_hdr(skb)->daddr;
7d07a68c
NA		 130 if (br->multicast_igmp_version == 3) {
131 struct net_bridge_mdb_entry *mdb;
132
133 ip.src.ip4 = ip_hdr(skb)->saddr;
134 mdb = br_mdb_ip_get_rcu(br, &ip);
135 if (mdb)
136 return mdb;
137 ip.src.ip4 = 0;
138 }
8ef2a9a5 139 break;
dfd56b8b 140#if IS_ENABLED(CONFIG_IPV6)
08b202b6 141 case htons(ETH_P_IPV6):
eab3227b 142 ip.dst.ip6 = ipv6_hdr(skb)->daddr;
7d07a68c
NA		 143 if (br->multicast_mld_version == 2) {
144 struct net_bridge_mdb_entry *mdb;
145
146 ip.src.ip6 = ipv6_hdr(skb)->saddr;
147 mdb = br_mdb_ip_get_rcu(br, &ip);
148 if (mdb)
149 return mdb;
150 memset(&ip.src.ip6, 0, sizeof(ip.src.ip6));
151 }
08b202b6
YH		 152 break;
153#endif
8ef2a9a5
YH		 154 default:
155 return NULL;
eb1d1641
HX		 156 }
157
19e3a9c9 158 return br_mdb_ip_get_rcu(br, &ip);
eb1d1641
HX		 159}
160
e12cec65
NA		 161static void br_multicast_destroy_mdb_entry(struct net_bridge_mcast_gc *gc)
162{
163 struct net_bridge_mdb_entry *mp;
164
165 mp = container_of(gc, struct net_bridge_mdb_entry, mcast_gc);
166 WARN_ON(!hlist_unhashed(&mp->mdb_node));
167 WARN_ON(mp->ports);
168
169 del_timer_sync(&mp->timer);
170 kfree_rcu(mp, rcu);
171}
172
173static void br_multicast_del_mdb_entry(struct net_bridge_mdb_entry *mp)
174{
175 struct net_bridge *br = mp->br;
176
177 rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode,
178 br_mdb_rht_params);
179 hlist_del_init_rcu(&mp->mdb_node);
180 hlist_add_head(&mp->mcast_gc.gc_node, &br->mcast_gc_list);
181 queue_work(system_long_wq, &br->mcast_gc_work);
182}
183
88c1f37f 184static void br_multicast_group_expired(struct timer_list *t)
eb1d1641 185{
88c1f37f 186 struct net_bridge_mdb_entry *mp = from_timer(mp, t, timer);
eb1d1641 187 struct net_bridge *br = mp->br;
eb1d1641
HX		 188
189 spin_lock(&br->multicast_lock);
190 if (!netif_running(br->dev) || timer_pending(&mp->timer))
191 goto out;
192
1bc844ee 193 br_multicast_host_leave(mp, true);
eb1d1641
HX		 194
195 if (mp->ports)
196 goto out;
e12cec65
NA		 197 br_multicast_del_mdb_entry(mp);
198out:
199 spin_unlock(&br->multicast_lock);
200}
eb1d1641 201
e12cec65
NA		 202static void br_multicast_destroy_group_src(struct net_bridge_mcast_gc *gc)
203{
204 struct net_bridge_group_src *src;
eb1d1641 205
e12cec65
NA		 206 src = container_of(gc, struct net_bridge_group_src, mcast_gc);
207 WARN_ON(!hlist_unhashed(&src->node));
eb1d1641 208
e12cec65
NA		 209 del_timer_sync(&src->timer);
210 kfree_rcu(src, rcu);
eb1d1641
HX		 211}
212
8b671779
NA		 213static void br_multicast_del_group_src(struct net_bridge_group_src *src)
214{
215 struct net_bridge *br = src->pg->port->br;
216
217 hlist_del_init_rcu(&src->node);
218 src->pg->src_ents--;
e12cec65
NA		 219 hlist_add_head(&src->mcast_gc.gc_node, &br->mcast_gc_list);
220 queue_work(system_long_wq, &br->mcast_gc_work);
221}
222
223static void br_multicast_destroy_port_group(struct net_bridge_mcast_gc *gc)
224{
225 struct net_bridge_port_group *pg;
226
227 pg = container_of(gc, struct net_bridge_port_group, mcast_gc);
228 WARN_ON(!hlist_unhashed(&pg->mglist));
229 WARN_ON(!hlist_empty(&pg->src_list));
230
231 del_timer_sync(&pg->rexmit_timer);
232 del_timer_sync(&pg->timer);
233 kfree_rcu(pg, rcu);
8b671779
NA		 234}
235
681590bd
NA		 236void br_multicast_del_pg(struct net_bridge_mdb_entry *mp,
237 struct net_bridge_port_group *pg,
238 struct net_bridge_port_group __rcu **pp)
239{
240 struct net_bridge *br = pg->port->br;
8b671779
NA		 241 struct net_bridge_group_src *ent;
242 struct hlist_node *tmp;
681590bd
NA		 243
244 rcu_assign_pointer(*pp, pg->next);
245 hlist_del_init(&pg->mglist);
8b671779
NA		 246 hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
247 br_multicast_del_group_src(ent);
81f19838 248 br_mdb_notify(br->dev, mp, pg, RTM_DELMDB);
e12cec65
NA		 249 hlist_add_head(&pg->mcast_gc.gc_node, &br->mcast_gc_list);
250 queue_work(system_long_wq, &br->mcast_gc_work);
681590bd
NA		 251
252 if (!mp->ports && !mp->host_joined && netif_running(br->dev))
253 mod_timer(&mp->timer, jiffies);
254}
255
256static void br_multicast_find_del_pg(struct net_bridge *br,
257 struct net_bridge_port_group *pg)
eb1d1641 258{
8b671779 259 struct net_bridge_port_group __rcu **pp;
eb1d1641
HX		 260 struct net_bridge_mdb_entry *mp;
261 struct net_bridge_port_group *p;
e8051688 262
19e3a9c9 263 mp = br_mdb_ip_get(br, &pg->addr);
eb1d1641
HX		 264 if (WARN_ON(!mp))
265 return;
266
e8051688
ED		 267 for (pp = &mp->ports;
268 (p = mlock_dereference(*pp, br)) != NULL;
269 pp = &p->next) {
eb1d1641
HX		 270 if (p != pg)
271 continue;
272
681590bd 273 br_multicast_del_pg(mp, pg, pp);
eb1d1641
HX		 274 return;
275 }
276
277 WARN_ON(1);
278}
279
88c1f37f 280static void br_multicast_port_group_expired(struct timer_list *t)
eb1d1641 281{
88c1f37f 282 struct net_bridge_port_group *pg = from_timer(pg, t, timer);
d6c33d67 283 struct net_bridge_group_src *src_ent;
eb1d1641 284 struct net_bridge *br = pg->port->br;
d6c33d67
NA		 285 struct hlist_node *tmp;
286 bool changed;
eb1d1641
HX		 287
288 spin_lock(&br->multicast_lock);
289 if (!netif_running(br->dev) || timer_pending(&pg->timer) ||
9d06b6d8 290 hlist_unhashed(&pg->mglist) || pg->flags & MDB_PG_FLAGS_PERMANENT)
eb1d1641
HX		 291 goto out;
292
d6c33d67
NA		 293 changed = !!(pg->filter_mode == MCAST_EXCLUDE);
294 pg->filter_mode = MCAST_INCLUDE;
295 hlist_for_each_entry_safe(src_ent, tmp, &pg->src_list, node) {
296 if (!timer_pending(&src_ent->timer)) {
297 br_multicast_del_group_src(src_ent);
298 changed = true;
299 }
300 }
301
302 if (hlist_empty(&pg->src_list)) {
303 br_multicast_find_del_pg(br, pg);
304 } else if (changed) {
305 struct net_bridge_mdb_entry *mp = br_mdb_ip_get(br, &pg->addr);
eb1d1641 306
d6c33d67
NA		 307 if (WARN_ON(!mp))
308 goto out;
309 br_mdb_notify(br->dev, mp, pg, RTM_NEWMDB);
310 }
eb1d1641
HX		 311out:
312 spin_unlock(&br->multicast_lock);
313}
314
e12cec65
NA		 315static void br_multicast_gc(struct hlist_head *head)
316{
317 struct net_bridge_mcast_gc *gcent;
318 struct hlist_node *tmp;
319
320 hlist_for_each_entry_safe(gcent, tmp, head, gc_node) {
321 hlist_del_init(&gcent->gc_node);
322 gcent->destroy(gcent);
323 }
324}
325
8ef2a9a5 326static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br,
438ef2d0
NA		 327 struct net_bridge_port_group *pg,
328 __be32 ip_dst, __be32 group,
329 bool with_srcs, bool over_lmqt,
42c11ccf
NA		 330 u8 sflag, u8 *igmp_type,
331 bool *need_rexmit)
eb1d1641 332{
438ef2d0
NA		 333 struct net_bridge_port *p = pg ? pg->port : NULL;
334 struct net_bridge_group_src *ent;
335 size_t pkt_size, igmp_hdr_size;
336 unsigned long now = jiffies;
5e923585 337 struct igmpv3_query *ihv3;
438ef2d0
NA		 338 void *csum_start = NULL;
339 __sum16 *csum = NULL;
eb1d1641
HX		 340 struct sk_buff *skb;
341 struct igmphdr *ih;
342 struct ethhdr *eth;
438ef2d0 343 unsigned long lmqt;
eb1d1641 344 struct iphdr *iph;
438ef2d0 345 u16 lmqt_srcs = 0;
eb1d1641 346
5e923585 347 igmp_hdr_size = sizeof(*ih);
438ef2d0 348 if (br->multicast_igmp_version == 3) {
5e923585 349 igmp_hdr_size = sizeof(*ihv3);
438ef2d0
NA		 350 if (pg && with_srcs) {
351 lmqt = now + (br->multicast_last_member_interval *
352 br->multicast_last_member_count);
353 hlist_for_each_entry(ent, &pg->src_list, node) {
354 if (over_lmqt == time_after(ent->timer.expires,
355 lmqt) &&
356 ent->src_query_rexmit_cnt > 0)
357 lmqt_srcs++;
358 }
359
360 if (!lmqt_srcs)
361 return NULL;
362 igmp_hdr_size += lmqt_srcs * sizeof(__be32);
363 }
364 }
365
366 pkt_size = sizeof(*eth) + sizeof(*iph) + 4 + igmp_hdr_size;
367 if ((p && pkt_size > p->dev->mtu) ||
368 pkt_size > br->dev->mtu)
369 return NULL;
370
371 skb = netdev_alloc_skb_ip_align(br->dev, pkt_size);
eb1d1641
HX		 372 if (!skb)
373 goto out;
374
375 skb->protocol = htons(ETH_P_IP);
376
377 skb_reset_mac_header(skb);
378 eth = eth_hdr(skb);
379
e5a727f6 380 ether_addr_copy(eth->h_source, br->dev->dev_addr);
438ef2d0 381 ip_eth_mc_map(ip_dst, eth->h_dest);
eb1d1641
HX		 382 eth->h_proto = htons(ETH_P_IP);
383 skb_put(skb, sizeof(*eth));
384
385 skb_set_network_header(skb, skb->len);
386 iph = ip_hdr(skb);
438ef2d0 387 iph->tot_len = htons(pkt_size - sizeof(*eth));
eb1d1641
HX		 388
389 iph->version = 4;
390 iph->ihl = 6;
391 iph->tos = 0xc0;
eb1d1641
HX		 392 iph->id = 0;
393 iph->frag_off = htons(IP_DF);
394 iph->ttl = 1;
395 iph->protocol = IPPROTO_IGMP;
675779ad 396 iph->saddr = br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR) ?
1c8ad5bf 397 inet_select_addr(br->dev, 0, RT_SCOPE_LINK) : 0;
438ef2d0 398 iph->daddr = ip_dst;
eb1d1641
HX		 399 ((u8 *)&iph[1])[0] = IPOPT_RA;
400 ((u8 *)&iph[1])[1] = 4;
401 ((u8 *)&iph[1])[2] = 0;
402 ((u8 *)&iph[1])[3] = 0;
403 ip_send_check(iph);
404 skb_put(skb, 24);
405
406 skb_set_transport_header(skb, skb->len);
1080ab95 407 *igmp_type = IGMP_HOST_MEMBERSHIP_QUERY;
eb1d1641 408
5e923585
NA		 409 switch (br->multicast_igmp_version) {
410 case 2:
411 ih = igmp_hdr(skb);
412 ih->type = IGMP_HOST_MEMBERSHIP_QUERY;
413 ih->code = (group ? br->multicast_last_member_interval :
414 br->multicast_query_response_interval) /
415 (HZ / IGMP_TIMER_SCALE);
416 ih->group = group;
417 ih->csum = 0;
438ef2d0
NA		 418 csum = &ih->csum;
419 csum_start = (void *)ih;
5e923585
NA		 420 break;
421 case 3:
422 ihv3 = igmpv3_query_hdr(skb);
423 ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY;
424 ihv3->code = (group ? br->multicast_last_member_interval :
425 br->multicast_query_response_interval) /
426 (HZ / IGMP_TIMER_SCALE);
427 ihv3->group = group;
428 ihv3->qqic = br->multicast_query_interval / HZ;
438ef2d0 429 ihv3->nsrcs = htons(lmqt_srcs);
5e923585 430 ihv3->resv = 0;
438ef2d0 431 ihv3->suppress = sflag;
5e923585
NA		 432 ihv3->qrv = 2;
433 ihv3->csum = 0;
438ef2d0
NA		 434 csum = &ihv3->csum;
435 csum_start = (void *)ihv3;
436 if (!pg || !with_srcs)
437 break;
438
439 lmqt_srcs = 0;
440 hlist_for_each_entry(ent, &pg->src_list, node) {
441 if (over_lmqt == time_after(ent->timer.expires,
442 lmqt) &&
443 ent->src_query_rexmit_cnt > 0) {
deb96566 444 ihv3->srcs[lmqt_srcs++] = ent->addr.src.ip4;
438ef2d0 445 ent->src_query_rexmit_cnt--;
42c11ccf
NA		 446 if (need_rexmit && ent->src_query_rexmit_cnt)
447 *need_rexmit = true;
438ef2d0
NA		 448 }
449 }
450 if (WARN_ON(lmqt_srcs != ntohs(ihv3->nsrcs))) {
451 kfree_skb(skb);
452 return NULL;
453 }
5e923585
NA		 454 break;
455 }
456
438ef2d0
NA		 457 if (WARN_ON(!csum || !csum_start)) {
458 kfree_skb(skb);
459 return NULL;
460 }
461
462 *csum = ip_compute_csum(csum_start, igmp_hdr_size);
5e923585 463 skb_put(skb, igmp_hdr_size);
eb1d1641
HX		 464 __skb_pull(skb, sizeof(*eth));
465
466out:
467 return skb;
468}
469
dfd56b8b 470#if IS_ENABLED(CONFIG_IPV6)
08b202b6 471static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br,
438ef2d0
NA		 472 struct net_bridge_port_group *pg,
473 const struct in6_addr *ip6_dst,
474 const struct in6_addr *group,
475 bool with_srcs, bool over_llqt,
42c11ccf
NA		 476 u8 sflag, u8 *igmp_type,
477 bool *need_rexmit)
08b202b6 478{
438ef2d0
NA		 479 struct net_bridge_port *p = pg ? pg->port : NULL;
480 struct net_bridge_group_src *ent;
481 size_t pkt_size, mld_hdr_size;
482 unsigned long now = jiffies;
aa2ae3e7 483 struct mld2_query *mld2q;
438ef2d0 484 void *csum_start = NULL;
aa2ae3e7 485 unsigned long interval;
438ef2d0 486 __sum16 *csum = NULL;
08b202b6
YH		 487 struct ipv6hdr *ip6h;
488 struct mld_msg *mldq;
aa2ae3e7 489 struct sk_buff *skb;
438ef2d0 490 unsigned long llqt;
08b202b6 491 struct ethhdr *eth;
438ef2d0 492 u16 llqt_srcs = 0;
08b202b6 493 u8 *hopopt;
08b202b6 494
aa2ae3e7 495 mld_hdr_size = sizeof(*mldq);
438ef2d0 496 if (br->multicast_mld_version == 2) {
aa2ae3e7 497 mld_hdr_size = sizeof(*mld2q);
438ef2d0
NA		 498 if (pg && with_srcs) {
499 llqt = now + (br->multicast_last_member_interval *
500 br->multicast_last_member_count);
501 hlist_for_each_entry(ent, &pg->src_list, node) {
502 if (over_llqt == time_after(ent->timer.expires,
503 llqt) &&
504 ent->src_query_rexmit_cnt > 0)
505 llqt_srcs++;
506 }
507
508 if (!llqt_srcs)
509 return NULL;
510 mld_hdr_size += llqt_srcs * sizeof(struct in6_addr);
511 }
512 }
513
514 pkt_size = sizeof(*eth) + sizeof(*ip6h) + 8 + mld_hdr_size;
515 if ((p && pkt_size > p->dev->mtu) ||
516 pkt_size > br->dev->mtu)
517 return NULL;
518
519 skb = netdev_alloc_skb_ip_align(br->dev, pkt_size);
08b202b6
YH		 520 if (!skb)
521 goto out;
522
523 skb->protocol = htons(ETH_P_IPV6);
524
525 /* Ethernet header */
526 skb_reset_mac_header(skb);
527 eth = eth_hdr(skb);
528
e5a727f6 529 ether_addr_copy(eth->h_source, br->dev->dev_addr);
08b202b6
YH		 530 eth->h_proto = htons(ETH_P_IPV6);
531 skb_put(skb, sizeof(*eth));
532
533 /* IPv6 header + HbH option */
534 skb_set_network_header(skb, skb->len);
535 ip6h = ipv6_hdr(skb);
536
537 *(__force __be32 *)ip6h = htonl(0x60000000);
aa2ae3e7 538 ip6h->payload_len = htons(8 + mld_hdr_size);
08b202b6
YH		 539 ip6h->nexthdr = IPPROTO_HOPOPTS;
540 ip6h->hop_limit = 1;
438ef2d0 541 ip6h->daddr = *ip6_dst;
d1d81d4c
UW		 542 if (ipv6_dev_get_saddr(dev_net(br->dev), br->dev, &ip6h->daddr, 0,
543 &ip6h->saddr)) {
544 kfree_skb(skb);
675779ad 545 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, false);
d1d81d4c
UW		 546 return NULL;
547 }
0888d5f3 548
675779ad 549 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
36cff5a1 550 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
08b202b6
YH		 551
552 hopopt = (u8 *)(ip6h + 1);
553 hopopt[0] = IPPROTO_ICMPV6; /* next hdr */
554 hopopt[1] = 0; /* length of HbH */
555 hopopt[2] = IPV6_TLV_ROUTERALERT; /* Router Alert */
556 hopopt[3] = 2; /* Length of RA Option */
557 hopopt[4] = 0; /* Type = 0x0000 (MLD) */
558 hopopt[5] = 0;
1de5a71c
EZ		 559 hopopt[6] = IPV6_TLV_PAD1; /* Pad1 */
560 hopopt[7] = IPV6_TLV_PAD1; /* Pad1 */
08b202b6
YH		 561
562 skb_put(skb, sizeof(*ip6h) + 8);
563
564 /* ICMPv6 */
565 skb_set_transport_header(skb, skb->len);
438ef2d0 566 interval = ipv6_addr_any(group) ?
32de868c
LL		 567 br->multicast_query_response_interval :
568 br->multicast_last_member_interval;
1080ab95 569 *igmp_type = ICMPV6_MGM_QUERY;
aa2ae3e7
NA		 570 switch (br->multicast_mld_version) {
571 case 1:
572 mldq = (struct mld_msg *)icmp6_hdr(skb);
573 mldq->mld_type = ICMPV6_MGM_QUERY;
574 mldq->mld_code = 0;
575 mldq->mld_cksum = 0;
576 mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval));
577 mldq->mld_reserved = 0;
438ef2d0
NA		 578 mldq->mld_mca = *group;
579 csum = &mldq->mld_cksum;
580 csum_start = (void *)mldq;
aa2ae3e7
NA		 581 break;
582 case 2:
583 mld2q = (struct mld2_query *)icmp6_hdr(skb);
53631a5f 584 mld2q->mld2q_mrc = htons((u16)jiffies_to_msecs(interval));
aa2ae3e7
NA		 585 mld2q->mld2q_type = ICMPV6_MGM_QUERY;
586 mld2q->mld2q_code = 0;
587 mld2q->mld2q_cksum = 0;
588 mld2q->mld2q_resv1 = 0;
589 mld2q->mld2q_resv2 = 0;
438ef2d0 590 mld2q->mld2q_suppress = sflag;
aa2ae3e7 591 mld2q->mld2q_qrv = 2;
438ef2d0 592 mld2q->mld2q_nsrcs = htons(llqt_srcs);
aa2ae3e7 593 mld2q->mld2q_qqic = br->multicast_query_interval / HZ;
438ef2d0
NA		 594 mld2q->mld2q_mca = *group;
595 csum = &mld2q->mld2q_cksum;
596 csum_start = (void *)mld2q;
597 if (!pg || !with_srcs)
598 break;
599
600 llqt_srcs = 0;
601 hlist_for_each_entry(ent, &pg->src_list, node) {
602 if (over_llqt == time_after(ent->timer.expires,
603 llqt) &&
604 ent->src_query_rexmit_cnt > 0) {
deb96566 605 mld2q->mld2q_srcs[llqt_srcs++] = ent->addr.src.ip6;
438ef2d0 606 ent->src_query_rexmit_cnt--;
42c11ccf
NA		 607 if (need_rexmit && ent->src_query_rexmit_cnt)
608 *need_rexmit = true;
438ef2d0
NA		 609 }
610 }
611 if (WARN_ON(llqt_srcs != ntohs(mld2q->mld2q_nsrcs))) {
612 kfree_skb(skb);
613 return NULL;
614 }
aa2ae3e7
NA		 615 break;
616 }
08b202b6 617
438ef2d0
NA		 618 if (WARN_ON(!csum || !csum_start)) {
619 kfree_skb(skb);
620 return NULL;
621 }
622
623 *csum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr, mld_hdr_size,
624 IPPROTO_ICMPV6,
625 csum_partial(csum_start, mld_hdr_size, 0));
626 skb_put(skb, mld_hdr_size);
08b202b6
YH		 627 __skb_pull(skb, sizeof(*eth));
628
629out:
630 return skb;
631}
632#endif
633
8ef2a9a5 634static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
438ef2d0
NA		 635 struct net_bridge_port_group *pg,
636 struct br_ip *ip_dst,
637 struct br_ip *group,
638 bool with_srcs, bool over_lmqt,
42c11ccf
NA		 639 u8 sflag, u8 *igmp_type,
640 bool *need_rexmit)
8ef2a9a5 641{
438ef2d0
NA		 642 __be32 ip4_dst;
643
644 switch (group->proto) {
8ef2a9a5 645 case htons(ETH_P_IP):
eab3227b 646 ip4_dst = ip_dst ? ip_dst->dst.ip4 : htonl(INADDR_ALLHOSTS_GROUP);
438ef2d0 647 return br_ip4_multicast_alloc_query(br, pg,
eab3227b 648 ip4_dst, group->dst.ip4,
438ef2d0 649 with_srcs, over_lmqt,
42c11ccf
NA		 650 sflag, igmp_type,
651 need_rexmit);
dfd56b8b 652#if IS_ENABLED(CONFIG_IPV6)
438ef2d0
NA		 653 case htons(ETH_P_IPV6): {
654 struct in6_addr ip6_dst;
655
656 if (ip_dst)
eab3227b 657 ip6_dst = ip_dst->dst.ip6;
438ef2d0
NA		 658 else
659 ipv6_addr_set(&ip6_dst, htonl(0xff020000), 0, 0,
660 htonl(1));
661
662 return br_ip6_multicast_alloc_query(br, pg,
eab3227b 663 &ip6_dst, &group->dst.ip6,
438ef2d0 664 with_srcs, over_lmqt,
42c11ccf
NA		 665 sflag, igmp_type,
666 need_rexmit);
438ef2d0 667 }
08b202b6 668#endif
8ef2a9a5
YH		 669 }
670 return NULL;
671}
672
cfd56754 673struct net_bridge_mdb_entry *br_multicast_new_group(struct net_bridge *br,
5e923585 674 struct br_ip *group)
eb1d1641 675{
eb1d1641 676 struct net_bridge_mdb_entry *mp;
4c0833bc 677 int err;
eb1d1641 678
19e3a9c9
NA		 679 mp = br_mdb_ip_get(br, group);
680 if (mp)
681 return mp;
eb1d1641 682
19e3a9c9
NA		 683 if (atomic_read(&br->mdb_hash_tbl.nelems) >= br->hash_max) {
684 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, false);
685 return ERR_PTR(-E2BIG);
eb1d1641
HX		 686 }
687
688 mp = kzalloc(sizeof(*mp), GFP_ATOMIC);
689 if (unlikely(!mp))
4c0833bc 690 return ERR_PTR(-ENOMEM);
eb1d1641
HX		 691
692 mp->br = br;
8ef2a9a5 693 mp->addr = *group;
e12cec65 694 mp->mcast_gc.destroy = br_multicast_destroy_mdb_entry;
88c1f37f 695 timer_setup(&mp->timer, br_multicast_group_expired, 0);
19e3a9c9
NA		 696 err = rhashtable_lookup_insert_fast(&br->mdb_hash_tbl, &mp->rhnode,
697 br_mdb_rht_params);
698 if (err) {
699 kfree(mp);
700 mp = ERR_PTR(err);
701 } else {
702 hlist_add_head_rcu(&mp->mdb_node, &br->mdb_list);
703 }
1faabf2a 704
eb1d1641
HX		 705 return mp;
706}
707
8b671779
NA		 708static void br_multicast_group_src_expired(struct timer_list *t)
709{
710 struct net_bridge_group_src *src = from_timer(src, t, timer);
711 struct net_bridge_port_group *pg;
712 struct net_bridge *br = src->br;
713
714 spin_lock(&br->multicast_lock);
715 if (hlist_unhashed(&src->node) || !netif_running(br->dev) ||
716 timer_pending(&src->timer))
717 goto out;
718
719 pg = src->pg;
720 if (pg->filter_mode == MCAST_INCLUDE) {
721 br_multicast_del_group_src(src);
722 if (!hlist_empty(&pg->src_list))
723 goto out;
724 br_multicast_find_del_pg(br, pg);
725 }
726out:
727 spin_unlock(&br->multicast_lock);
728}
729
730static struct net_bridge_group_src *
731br_multicast_find_group_src(struct net_bridge_port_group *pg, struct br_ip *ip)
732{
733 struct net_bridge_group_src *ent;
734
735 switch (ip->proto) {
736 case htons(ETH_P_IP):
737 hlist_for_each_entry(ent, &pg->src_list, node)
deb96566 738 if (ip->src.ip4 == ent->addr.src.ip4)
8b671779
NA		 739 return ent;
740 break;
741#if IS_ENABLED(CONFIG_IPV6)
742 case htons(ETH_P_IPV6):
743 hlist_for_each_entry(ent, &pg->src_list, node)
deb96566 744 if (!ipv6_addr_cmp(&ent->addr.src.ip6, &ip->src.ip6))
8b671779
NA		 745 return ent;
746 break;
747#endif
748 }
749
750 return NULL;
751}
752
753static struct net_bridge_group_src *
754br_multicast_new_group_src(struct net_bridge_port_group *pg, struct br_ip *src_ip)
755{
756 struct net_bridge_group_src *grp_src;
757
758 if (unlikely(pg->src_ents >= PG_SRC_ENT_LIMIT))
759 return NULL;
760
761 switch (src_ip->proto) {
762 case htons(ETH_P_IP):
deb96566
NA		 763 if (ipv4_is_zeronet(src_ip->src.ip4) ||
764 ipv4_is_multicast(src_ip->src.ip4))
8b671779
NA		 765 return NULL;
766 break;
767#if IS_ENABLED(CONFIG_IPV6)
768 case htons(ETH_P_IPV6):
deb96566
NA		 769 if (ipv6_addr_any(&src_ip->src.ip6) ||
770 ipv6_addr_is_multicast(&src_ip->src.ip6))
8b671779
NA		 771 return NULL;
772 break;
773#endif
774 }
775
776 grp_src = kzalloc(sizeof(*grp_src), GFP_ATOMIC);
777 if (unlikely(!grp_src))
778 return NULL;
779
780 grp_src->pg = pg;
781 grp_src->br = pg->port->br;
782 grp_src->addr = *src_ip;
e12cec65 783 grp_src->mcast_gc.destroy = br_multicast_destroy_group_src;
8b671779
NA		 784 timer_setup(&grp_src->timer, br_multicast_group_src_expired, 0);
785
786 hlist_add_head_rcu(&grp_src->node, &pg->src_list);
787 pg->src_ents++;
788
789 return grp_src;
790}
791
cfd56754
CW		 792struct net_bridge_port_group *br_multicast_new_port_group(
793 struct net_bridge_port *port,
794 struct br_ip *group,
ccb1c31a 795 struct net_bridge_port_group __rcu *next,
6db6f0ea 796 unsigned char flags,
8b671779
NA		 797 const unsigned char *src,
798 u8 filter_mode)
cfd56754
CW		 799{
800 struct net_bridge_port_group *p;
801
802 p = kzalloc(sizeof(*p), GFP_ATOMIC);
803 if (unlikely(!p))
804 return NULL;
805
806 p->addr = *group;
807 p->port = port;
9d06b6d8 808 p->flags = flags;
8b671779 809 p->filter_mode = filter_mode;
e12cec65 810 p->mcast_gc.destroy = br_multicast_destroy_port_group;
8b671779 811 INIT_HLIST_HEAD(&p->src_list);
eca2a43b 812 rcu_assign_pointer(p->next, next);
88c1f37f 813 timer_setup(&p->timer, br_multicast_port_group_expired, 0);
42c11ccf
NA		 814 timer_setup(&p->rexmit_timer, br_multicast_port_group_rexmit, 0);
815 hlist_add_head(&p->mglist, &port->mglist);
6db6f0ea
FF		 816
817 if (src)
818 memcpy(p->eth_addr, src, ETH_ALEN);
819 else
1bfe45f4 820 eth_broadcast_addr(p->eth_addr);
6db6f0ea 821
cfd56754
CW		 822 return p;
823}
824
6db6f0ea
FF		 825static bool br_port_group_equal(struct net_bridge_port_group *p,
826 struct net_bridge_port *port,
827 const unsigned char *src)
828{
829 if (p->port != port)
830 return false;
831
832 if (!(port->flags & BR_MULTICAST_TO_UNICAST))
833 return true;
834
835 return ether_addr_equal(src, p->eth_addr);
836}
837
1bc844ee
NA		 838void br_multicast_host_join(struct net_bridge_mdb_entry *mp, bool notify)
839{
840 if (!mp->host_joined) {
841 mp->host_joined = true;
842 if (notify)
81f19838 843 br_mdb_notify(mp->br->dev, mp, NULL, RTM_NEWMDB);
1bc844ee
NA		 844 }
845 mod_timer(&mp->timer, jiffies + mp->br->multicast_membership_interval);
846}
847
848void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify)
849{
850 if (!mp->host_joined)
851 return;
852
853 mp->host_joined = false;
854 if (notify)
81f19838 855 br_mdb_notify(mp->br->dev, mp, NULL, RTM_DELMDB);
1bc844ee
NA		 856}
857
eb1d1641 858static int br_multicast_add_group(struct net_bridge *br,
8ef2a9a5 859 struct net_bridge_port *port,
6db6f0ea 860 struct br_ip *group,
8b671779 861 const unsigned char *src,
0436862e
NA		 862 u8 filter_mode,
863 bool igmpv2_mldv1)
eb1d1641 864{
e8051688 865 struct net_bridge_port_group __rcu **pp;
5e923585
NA		 866 struct net_bridge_port_group *p;
867 struct net_bridge_mdb_entry *mp;
454594f3 868 unsigned long now = jiffies;
eb1d1641
HX		 869 int err;
870
eb1d1641
HX		 871 spin_lock(&br->multicast_lock);
872 if (!netif_running(br->dev) ||
873 (port && port->state == BR_STATE_DISABLED))
874 goto out;
875
19e3a9c9 876 mp = br_multicast_new_group(br, group);
eb1d1641 877 err = PTR_ERR(mp);
4c0833bc 878 if (IS_ERR(mp))
eb1d1641
HX		 879 goto err;
880
881 if (!port) {
1bc844ee 882 br_multicast_host_join(mp, true);
eb1d1641
HX		 883 goto out;
884 }
885
e8051688
ED		 886 for (pp = &mp->ports;
887 (p = mlock_dereference(*pp, br)) != NULL;
888 pp = &p->next) {
6db6f0ea 889 if (br_port_group_equal(p, port, src))
454594f3 890 goto found;
eb1d1641
HX		 891 if ((unsigned long)p->port < (unsigned long)port)
892 break;
893 }
894
8b671779 895 p = br_multicast_new_port_group(port, group, *pp, 0, src, filter_mode);
eb1d1641
HX		 896 if (unlikely(!p))
897 goto err;
eb1d1641 898 rcu_assign_pointer(*pp, p);
81f19838 899 br_mdb_notify(br->dev, mp, p, RTM_NEWMDB);
eb1d1641 900
454594f3 901found:
0436862e
NA		 902 if (igmpv2_mldv1)
903 mod_timer(&p->timer, now + br->multicast_membership_interval);
81f19838 904
eb1d1641
HX		 905out:
906 err = 0;
907
908err:
909 spin_unlock(&br->multicast_lock);
910 return err;
911}
912
8ef2a9a5
YH		 913static int br_ip4_multicast_add_group(struct net_bridge *br,
914 struct net_bridge_port *port,
b0e9a30d 915 __be32 group,
6db6f0ea 916 __u16 vid,
8b671779
NA		 917 const unsigned char *src,
918 bool igmpv2)
8ef2a9a5
YH		 919{
920 struct br_ip br_group;
8b671779 921 u8 filter_mode;
8ef2a9a5
YH		 922
923 if (ipv4_is_local_multicast(group))
924 return 0;
925
1515a63f 926 memset(&br_group, 0, sizeof(br_group));
eab3227b 927 br_group.dst.ip4 = group;
8ef2a9a5 928 br_group.proto = htons(ETH_P_IP);
b0e9a30d 929 br_group.vid = vid;
8b671779 930 filter_mode = igmpv2 ? MCAST_EXCLUDE : MCAST_INCLUDE;
8ef2a9a5 931
0436862e
NA		 932 return br_multicast_add_group(br, port, &br_group, src, filter_mode,
933 igmpv2);
8ef2a9a5
YH		 934}
935
dfd56b8b 936#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 937static int br_ip6_multicast_add_group(struct net_bridge *br,
938 struct net_bridge_port *port,
b0e9a30d 939 const struct in6_addr *group,
6db6f0ea 940 __u16 vid,
8b671779
NA		 941 const unsigned char *src,
942 bool mldv1)
08b202b6
YH		 943{
944 struct br_ip br_group;
8b671779 945 u8 filter_mode;
08b202b6 946
3c3769e6 947 if (ipv6_addr_is_ll_all_nodes(group))
08b202b6
YH		 948 return 0;
949
19e3a9c9 950 memset(&br_group, 0, sizeof(br_group));
eab3227b 951 br_group.dst.ip6 = *group;
9cc6e0c4 952 br_group.proto = htons(ETH_P_IPV6);
b0e9a30d 953 br_group.vid = vid;
8b671779 954 filter_mode = mldv1 ? MCAST_EXCLUDE : MCAST_INCLUDE;
08b202b6 955
0436862e
NA		 956 return br_multicast_add_group(br, port, &br_group, src, filter_mode,
957 mldv1);
08b202b6
YH		 958}
959#endif
960
88c1f37f 961static void br_multicast_router_expired(struct timer_list *t)
eb1d1641 962{
88c1f37f
AP		 963 struct net_bridge_port *port =
964 from_timer(port, t, multicast_router_timer);
eb1d1641
HX		 965 struct net_bridge *br = port->br;
966
967 spin_lock(&br->multicast_lock);
a55d8246
NA		 968 if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
969 port->multicast_router == MDB_RTR_TYPE_PERM ||
f12e7d95 970 timer_pending(&port->multicast_router_timer))
eb1d1641
HX		 971 goto out;
972
f12e7d95 973 __del_port_router(port);
eb1d1641
HX		 974out:
975 spin_unlock(&br->multicast_lock);
976}
977
77041420
YG		 978static void br_mc_router_state_change(struct net_bridge *p,
979 bool is_mc_router)
980{
981 struct switchdev_attr attr = {
982 .orig_dev = p->dev,
983 .id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER,
984 .flags = SWITCHDEV_F_DEFER,
985 .u.mrouter = is_mc_router,
986 };
987
988 switchdev_port_attr_set(p->dev, &attr);
989}
990
88c1f37f 991static void br_multicast_local_router_expired(struct timer_list *t)
eb1d1641 992{
88c1f37f 993 struct net_bridge *br = from_timer(br, t, multicast_router_timer);
77041420
YG		 994
995 spin_lock(&br->multicast_lock);
996 if (br->multicast_router == MDB_RTR_TYPE_DISABLED ||
997 br->multicast_router == MDB_RTR_TYPE_PERM ||
998 timer_pending(&br->multicast_router_timer))
999 goto out;
1000
1001 br_mc_router_state_change(br, false);
1002out:
1003 spin_unlock(&br->multicast_lock);
eb1d1641
HX		 1004}
1005
cc0fdd80 1006static void br_multicast_querier_expired(struct net_bridge *br,
90010b36 1007 struct bridge_mcast_own_query *query)
c83b8fab 1008{
c83b8fab 1009 spin_lock(&br->multicast_lock);
13cefad2 1010 if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
c83b8fab
HX		 1011 goto out;
1012
cc0fdd80 1013 br_multicast_start_querier(br, query);
c83b8fab
HX		 1014
1015out:
1016 spin_unlock(&br->multicast_lock);
1017}
1018
88c1f37f 1019static void br_ip4_multicast_querier_expired(struct timer_list *t)
cc0fdd80 1020{
88c1f37f 1021 struct net_bridge *br = from_timer(br, t, ip4_other_query.timer);
cc0fdd80 1022
90010b36 1023 br_multicast_querier_expired(br, &br->ip4_own_query);
cc0fdd80
LL		 1024}
1025
1026#if IS_ENABLED(CONFIG_IPV6)
88c1f37f 1027static void br_ip6_multicast_querier_expired(struct timer_list *t)
cc0fdd80 1028{
88c1f37f 1029 struct net_bridge *br = from_timer(br, t, ip6_other_query.timer);
cc0fdd80 1030
90010b36 1031 br_multicast_querier_expired(br, &br->ip6_own_query);
cc0fdd80
LL		 1032}
1033#endif
1034
dc4eb53a
LL		 1035static void br_multicast_select_own_querier(struct net_bridge *br,
1036 struct br_ip *ip,
1037 struct sk_buff *skb)
1038{
1039 if (ip->proto == htons(ETH_P_IP))
deb96566 1040 br->ip4_querier.addr.src.ip4 = ip_hdr(skb)->saddr;
dc4eb53a
LL		 1041#if IS_ENABLED(CONFIG_IPV6)
1042 else
deb96566 1043 br->ip6_querier.addr.src.ip6 = ipv6_hdr(skb)->saddr;
dc4eb53a
LL		 1044#endif
1045}
1046
8ef2a9a5
YH		 1047static void __br_multicast_send_query(struct net_bridge *br,
1048 struct net_bridge_port *port,
438ef2d0
NA		 1049 struct net_bridge_port_group *pg,
1050 struct br_ip *ip_dst,
1051 struct br_ip *group,
1052 bool with_srcs,
42c11ccf
NA		 1053 u8 sflag,
1054 bool *need_rexmit)
eb1d1641 1055{
438ef2d0 1056 bool over_lmqt = !!sflag;
eb1d1641 1057 struct sk_buff *skb;
1080ab95 1058 u8 igmp_type;
eb1d1641 1059
438ef2d0
NA		 1060again_under_lmqt:
1061 skb = br_multicast_alloc_query(br, pg, ip_dst, group, with_srcs,
42c11ccf
NA		 1062 over_lmqt, sflag, &igmp_type,
1063 need_rexmit);
eb1d1641 1064 if (!skb)
8ef2a9a5 1065 return;
eb1d1641
HX		 1066
1067 if (port) {
eb1d1641 1068 skb->dev = port->dev;
a65056ec 1069 br_multicast_count(br, port, skb, igmp_type,
1080ab95 1070 BR_MCAST_DIR_TX);
29a26a56
EB		 1071 NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT,
1072 dev_net(port->dev), NULL, skb, NULL, skb->dev,
f0b4eece 1073 br_dev_queue_push_xmit);
438ef2d0
NA		 1074
1075 if (over_lmqt && with_srcs && sflag) {
1076 over_lmqt = false;
1077 goto again_under_lmqt;
1078 }
dc4eb53a 1079 } else {
438ef2d0 1080 br_multicast_select_own_querier(br, group, skb);
a65056ec 1081 br_multicast_count(br, port, skb, igmp_type,
1080ab95 1082 BR_MCAST_DIR_RX);
eb1d1641 1083 netif_rx(skb);
dc4eb53a 1084 }
8ef2a9a5
YH		 1085}
1086
1087static void br_multicast_send_query(struct net_bridge *br,
cc0fdd80 1088 struct net_bridge_port *port,
90010b36 1089 struct bridge_mcast_own_query *own_query)
8ef2a9a5 1090{
90010b36 1091 struct bridge_mcast_other_query *other_query = NULL;
5e923585
NA		 1092 struct br_ip br_group;
1093 unsigned long time;
8ef2a9a5 1094
13cefad2
NA		 1095 if (!netif_running(br->dev) ||
1096 !br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
675779ad 1097 !br_opt_get(br, BROPT_MULTICAST_QUERIER))
8ef2a9a5
YH		 1098 return;
1099
eab3227b 1100 memset(&br_group.dst, 0, sizeof(br_group.dst));
08b202b6 1101
90010b36
LL		 1102 if (port ? (own_query == &port->ip4_own_query) :
1103 (own_query == &br->ip4_own_query)) {
1104 other_query = &br->ip4_other_query;
cc0fdd80 1105 br_group.proto = htons(ETH_P_IP);
dfd56b8b 1106#if IS_ENABLED(CONFIG_IPV6)
cc0fdd80 1107 } else {
90010b36 1108 other_query = &br->ip6_other_query;
cc0fdd80 1109 br_group.proto = htons(ETH_P_IPV6);
08b202b6 1110#endif
cc0fdd80
LL		 1111 }
1112
90010b36 1113 if (!other_query || timer_pending(&other_query->timer))
cc0fdd80
LL		 1114 return;
1115
42c11ccf
NA		 1116 __br_multicast_send_query(br, port, NULL, NULL, &br_group, false, 0,
1117 NULL);
eb1d1641 1118
eb1d1641 1119 time = jiffies;
90010b36 1120 time += own_query->startup_sent < br->multicast_startup_query_count ?
eb1d1641
HX		 1121 br->multicast_startup_query_interval :
1122 br->multicast_query_interval;
90010b36 1123 mod_timer(&own_query->timer, time);
eb1d1641
HX		 1124}
1125
90010b36
LL		 1126static void
1127br_multicast_port_query_expired(struct net_bridge_port *port,
1128 struct bridge_mcast_own_query *query)
eb1d1641 1129{
eb1d1641
HX		 1130 struct net_bridge *br = port->br;
1131
1132 spin_lock(&br->multicast_lock);
02a780c0
DC		 1133 if (port->state == BR_STATE_DISABLED ||
1134 port->state == BR_STATE_BLOCKING)
eb1d1641
HX		 1135 goto out;
1136
cc0fdd80
LL		 1137 if (query->startup_sent < br->multicast_startup_query_count)
1138 query->startup_sent++;
eb1d1641 1139
cc0fdd80 1140 br_multicast_send_query(port->br, port, query);
eb1d1641
HX		 1141
1142out:
1143 spin_unlock(&br->multicast_lock);
1144}
1145
88c1f37f 1146static void br_ip4_multicast_port_query_expired(struct timer_list *t)
cc0fdd80 1147{
88c1f37f 1148 struct net_bridge_port *port = from_timer(port, t, ip4_own_query.timer);
cc0fdd80 1149
90010b36 1150 br_multicast_port_query_expired(port, &port->ip4_own_query);
cc0fdd80
LL		 1151}
1152
1153#if IS_ENABLED(CONFIG_IPV6)
88c1f37f 1154static void br_ip6_multicast_port_query_expired(struct timer_list *t)
cc0fdd80 1155{
88c1f37f 1156 struct net_bridge_port *port = from_timer(port, t, ip6_own_query.timer);
cc0fdd80 1157
90010b36 1158 br_multicast_port_query_expired(port, &port->ip6_own_query);
cc0fdd80
LL		 1159}
1160#endif
1161
42c11ccf
NA		 1162static void br_multicast_port_group_rexmit(struct timer_list *t)
1163{
1164 struct net_bridge_port_group *pg = from_timer(pg, t, rexmit_timer);
1165 struct bridge_mcast_other_query *other_query = NULL;
1166 struct net_bridge *br = pg->port->br;
1167 bool need_rexmit = false;
1168
1169 spin_lock(&br->multicast_lock);
1170 if (!netif_running(br->dev) || hlist_unhashed(&pg->mglist) ||
1171 !br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
1172 !br_opt_get(br, BROPT_MULTICAST_QUERIER))
1173 goto out;
1174
1175 if (pg->addr.proto == htons(ETH_P_IP))
1176 other_query = &br->ip4_other_query;
1177#if IS_ENABLED(CONFIG_IPV6)
1178 else
1179 other_query = &br->ip6_other_query;
1180#endif
1181
1182 if (!other_query || timer_pending(&other_query->timer))
1183 goto out;
1184
1185 if (pg->grp_query_rexmit_cnt) {
1186 pg->grp_query_rexmit_cnt--;
1187 __br_multicast_send_query(br, pg->port, pg, &pg->addr,
1188 &pg->addr, false, 1, NULL);
1189 }
1190 __br_multicast_send_query(br, pg->port, pg, &pg->addr,
1191 &pg->addr, true, 0, &need_rexmit);
1192
1193 if (pg->grp_query_rexmit_cnt || need_rexmit)
1194 mod_timer(&pg->rexmit_timer, jiffies +
1195 br->multicast_last_member_interval);
1196out:
1197 spin_unlock(&br->multicast_lock);
1198}
1199
147c1e9b
NF		 1200static void br_mc_disabled_update(struct net_device *dev, bool value)
1201{
1202 struct switchdev_attr attr = {
1203 .orig_dev = dev,
1204 .id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED,
1205 .flags = SWITCHDEV_F_DEFER,
13cefad2 1206 .u.mc_disabled = !value,
147c1e9b
NF		 1207 };
1208
1209 switchdev_port_attr_set(dev, &attr);
1210}
1211
1080ab95 1212int br_multicast_add_port(struct net_bridge_port *port)
eb1d1641 1213{
7f0aec7a 1214 port->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
eb1d1641 1215
88c1f37f
AP		 1216 timer_setup(&port->multicast_router_timer,
1217 br_multicast_router_expired, 0);
1218 timer_setup(&port->ip4_own_query.timer,
1219 br_ip4_multicast_port_query_expired, 0);
cc0fdd80 1220#if IS_ENABLED(CONFIG_IPV6)
88c1f37f
AP		 1221 timer_setup(&port->ip6_own_query.timer,
1222 br_ip6_multicast_port_query_expired, 0);
cc0fdd80 1223#endif
13cefad2
NA		 1224 br_mc_disabled_update(port->dev,
1225 br_opt_get(port->br, BROPT_MULTICAST_ENABLED));
147c1e9b 1226
1080ab95
NA		 1227 port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
1228 if (!port->mcast_stats)
1229 return -ENOMEM;
1230
1231 return 0;
eb1d1641
HX		 1232}
1233
1234void br_multicast_del_port(struct net_bridge_port *port)
1235{
e10177ab
SA		 1236 struct net_bridge *br = port->br;
1237 struct net_bridge_port_group *pg;
e12cec65 1238 HLIST_HEAD(deleted_head);
e10177ab
SA		 1239 struct hlist_node *n;
1240
1241 /* Take care of the remaining groups, only perm ones should be left */
1242 spin_lock_bh(&br->multicast_lock);
1243 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
681590bd 1244 br_multicast_find_del_pg(br, pg);
e12cec65 1245 hlist_move_list(&br->mcast_gc_list, &deleted_head);
e10177ab 1246 spin_unlock_bh(&br->multicast_lock);
e12cec65 1247 br_multicast_gc(&deleted_head);
eb1d1641 1248 del_timer_sync(&port->multicast_router_timer);
1080ab95 1249 free_percpu(port->mcast_stats);
eb1d1641
HX		 1250}
1251
90010b36 1252static void br_multicast_enable(struct bridge_mcast_own_query *query)
561f1103 1253{
cc0fdd80 1254 query->startup_sent = 0;
561f1103 1255
cc0fdd80
LL		 1256 if (try_to_del_timer_sync(&query->timer) >= 0 ||
1257 del_timer(&query->timer))
1258 mod_timer(&query->timer, jiffies);
561f1103
HX		 1259}
1260
7cb3f921 1261static void __br_multicast_enable_port(struct net_bridge_port *port)
eb1d1641
HX		 1262{
1263 struct net_bridge *br = port->br;
1264
13cefad2 1265 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || !netif_running(br->dev))
7cb3f921 1266 return;
eb1d1641 1267
90010b36 1268 br_multicast_enable(&port->ip4_own_query);
cc0fdd80 1269#if IS_ENABLED(CONFIG_IPV6)
90010b36 1270 br_multicast_enable(&port->ip6_own_query);
cc0fdd80 1271#endif
7f0aec7a
NA		 1272 if (port->multicast_router == MDB_RTR_TYPE_PERM &&
1273 hlist_unhashed(&port->rlist))
754bc547 1274 br_multicast_add_router(br, port);
7cb3f921 1275}
eb1d1641 1276
7cb3f921
NA		 1277void br_multicast_enable_port(struct net_bridge_port *port)
1278{
1279 struct net_bridge *br = port->br;
1280
1281 spin_lock(&br->multicast_lock);
1282 __br_multicast_enable_port(port);
eb1d1641
HX		 1283 spin_unlock(&br->multicast_lock);
1284}
1285
1286void br_multicast_disable_port(struct net_bridge_port *port)
1287{
1288 struct net_bridge *br = port->br;
1289 struct net_bridge_port_group *pg;
b67bfe0d 1290 struct hlist_node *n;
eb1d1641
HX		 1291
1292 spin_lock(&br->multicast_lock);
b67bfe0d 1293 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
9d06b6d8 1294 if (!(pg->flags & MDB_PG_FLAGS_PERMANENT))
681590bd 1295 br_multicast_find_del_pg(br, pg);
eb1d1641 1296
f12e7d95
NF		 1297 __del_port_router(port);
1298
eb1d1641 1299 del_timer(&port->multicast_router_timer);
90010b36 1300 del_timer(&port->ip4_own_query.timer);
cc0fdd80 1301#if IS_ENABLED(CONFIG_IPV6)
90010b36 1302 del_timer(&port->ip6_own_query.timer);
cc0fdd80 1303#endif
eb1d1641
HX		 1304 spin_unlock(&br->multicast_lock);
1305}
1306
e6231bca
NA		 1307static int __grp_src_delete_marked(struct net_bridge_port_group *pg)
1308{
1309 struct net_bridge_group_src *ent;
1310 struct hlist_node *tmp;
1311 int deleted = 0;
1312
1313 hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
1314 if (ent->flags & BR_SGRP_F_DELETE) {
1315 br_multicast_del_group_src(ent);
1316 deleted++;
1317 }
1318
1319 return deleted;
1320}
1321
5bf1e00b
NA		 1322static void __grp_src_query_marked_and_rexmit(struct net_bridge_port_group *pg)
1323{
1324 struct bridge_mcast_other_query *other_query = NULL;
1325 struct net_bridge *br = pg->port->br;
1326 u32 lmqc = br->multicast_last_member_count;
1327 unsigned long lmqt, lmi, now = jiffies;
1328 struct net_bridge_group_src *ent;
1329
1330 if (!netif_running(br->dev) ||
1331 !br_opt_get(br, BROPT_MULTICAST_ENABLED))
1332 return;
1333
1334 if (pg->addr.proto == htons(ETH_P_IP))
1335 other_query = &br->ip4_other_query;
1336#if IS_ENABLED(CONFIG_IPV6)
1337 else
1338 other_query = &br->ip6_other_query;
1339#endif
1340
1341 lmqt = now + br_multicast_lmqt(br);
1342 hlist_for_each_entry(ent, &pg->src_list, node) {
1343 if (ent->flags & BR_SGRP_F_SEND) {
1344 ent->flags &= ~BR_SGRP_F_SEND;
1345 if (ent->timer.expires > lmqt) {
1346 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) &&
1347 other_query &&
1348 !timer_pending(&other_query->timer))
1349 ent->src_query_rexmit_cnt = lmqc;
1350 mod_timer(&ent->timer, lmqt);
1351 }
1352 }
1353 }
1354
1355 if (!br_opt_get(br, BROPT_MULTICAST_QUERIER) ||
1356 !other_query || timer_pending(&other_query->timer))
1357 return;
1358
1359 __br_multicast_send_query(br, pg->port, pg, &pg->addr,
1360 &pg->addr, true, 1, NULL);
1361
1362 lmi = now + br->multicast_last_member_interval;
1363 if (!timer_pending(&pg->rexmit_timer) ||
1364 time_after(pg->rexmit_timer.expires, lmi))
1365 mod_timer(&pg->rexmit_timer, lmi);
1366}
1367
1368static void __grp_send_query_and_rexmit(struct net_bridge_port_group *pg)
1369{
1370 struct bridge_mcast_other_query *other_query = NULL;
1371 struct net_bridge *br = pg->port->br;
1372 unsigned long now = jiffies, lmi;
1373
1374 if (!netif_running(br->dev) ||
1375 !br_opt_get(br, BROPT_MULTICAST_ENABLED))
1376 return;
1377
1378 if (pg->addr.proto == htons(ETH_P_IP))
1379 other_query = &br->ip4_other_query;
1380#if IS_ENABLED(CONFIG_IPV6)
1381 else
1382 other_query = &br->ip6_other_query;
1383#endif
1384
1385 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) &&
1386 other_query && !timer_pending(&other_query->timer)) {
1387 lmi = now + br->multicast_last_member_interval;
1388 pg->grp_query_rexmit_cnt = br->multicast_last_member_count - 1;
1389 __br_multicast_send_query(br, pg->port, pg, &pg->addr,
1390 &pg->addr, false, 0, NULL);
1391 if (!timer_pending(&pg->rexmit_timer) ||
1392 time_after(pg->rexmit_timer.expires, lmi))
1393 mod_timer(&pg->rexmit_timer, lmi);
1394 }
1395
1396 if (pg->filter_mode == MCAST_EXCLUDE &&
1397 (!timer_pending(&pg->timer) ||
1398 time_after(pg->timer.expires, now + br_multicast_lmqt(br))))
1399 mod_timer(&pg->timer, now + br_multicast_lmqt(br));
1400}
1401
0436862e
NA		 1402/* State Msg type New state Actions
1403 * INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI
1404 * INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI
1405 * EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI
1406 */
1407static bool br_multicast_isinc_allow(struct net_bridge_port_group *pg,
1408 void *srcs, u32 nsrcs, size_t src_size)
1409{
1410 struct net_bridge *br = pg->port->br;
1411 struct net_bridge_group_src *ent;
1412 unsigned long now = jiffies;
1413 bool changed = false;
1414 struct br_ip src_ip;
1415 u32 src_idx;
1416
1417 memset(&src_ip, 0, sizeof(src_ip));
1418 src_ip.proto = pg->addr.proto;
1419 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1420 memcpy(&src_ip.src, srcs, src_size);
0436862e
NA		 1421 ent = br_multicast_find_group_src(pg, &src_ip);
1422 if (!ent) {
1423 ent = br_multicast_new_group_src(pg, &src_ip);
1424 if (ent)
1425 changed = true;
1426 }
1427
1428 if (ent)
1429 mod_timer(&ent->timer, now + br_multicast_gmi(br));
1430 srcs += src_size;
1431 }
1432
1433 return changed;
1434}
1435
e6231bca
NA		 1436/* State Msg type New state Actions
1437 * INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
1438 * Delete (A-B)
1439 * Group Timer=GMI
1440 */
1441static void __grp_src_isexc_incl(struct net_bridge_port_group *pg,
1442 void *srcs, u32 nsrcs, size_t src_size)
1443{
1444 struct net_bridge_group_src *ent;
1445 struct br_ip src_ip;
1446 u32 src_idx;
1447
1448 hlist_for_each_entry(ent, &pg->src_list, node)
1449 ent->flags |= BR_SGRP_F_DELETE;
1450
1451 memset(&src_ip, 0, sizeof(src_ip));
1452 src_ip.proto = pg->addr.proto;
1453 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1454 memcpy(&src_ip.src, srcs, src_size);
e6231bca
NA		 1455 ent = br_multicast_find_group_src(pg, &src_ip);
1456 if (ent)
1457 ent->flags &= ~BR_SGRP_F_DELETE;
1458 else
1459 br_multicast_new_group_src(pg, &src_ip);
1460 srcs += src_size;
1461 }
1462
1463 __grp_src_delete_marked(pg);
1464}
1465
1466/* State Msg type New state Actions
1467 * EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI
1468 * Delete (X-A)
1469 * Delete (Y-A)
1470 * Group Timer=GMI
1471 */
1472static bool __grp_src_isexc_excl(struct net_bridge_port_group *pg,
1473 void *srcs, u32 nsrcs, size_t src_size)
1474{
1475 struct net_bridge *br = pg->port->br;
1476 struct net_bridge_group_src *ent;
1477 unsigned long now = jiffies;
1478 bool changed = false;
1479 struct br_ip src_ip;
1480 u32 src_idx;
1481
1482 hlist_for_each_entry(ent, &pg->src_list, node)
1483 ent->flags |= BR_SGRP_F_DELETE;
1484
1485 memset(&src_ip, 0, sizeof(src_ip));
1486 src_ip.proto = pg->addr.proto;
1487 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1488 memcpy(&src_ip.src, srcs, src_size);
e6231bca
NA		 1489 ent = br_multicast_find_group_src(pg, &src_ip);
1490 if (ent) {
1491 ent->flags &= ~BR_SGRP_F_DELETE;
1492 } else {
1493 ent = br_multicast_new_group_src(pg, &src_ip);
1494 if (ent) {
1495 mod_timer(&ent->timer,
1496 now + br_multicast_gmi(br));
1497 changed = true;
1498 }
1499 }
1500 srcs += src_size;
1501 }
1502
1503 if (__grp_src_delete_marked(pg))
1504 changed = true;
1505
1506 return changed;
1507}
1508
1509static bool br_multicast_isexc(struct net_bridge_port_group *pg,
1510 void *srcs, u32 nsrcs, size_t src_size)
1511{
1512 struct net_bridge *br = pg->port->br;
1513 bool changed = false;
1514
1515 switch (pg->filter_mode) {
1516 case MCAST_INCLUDE:
1517 __grp_src_isexc_incl(pg, srcs, nsrcs, src_size);
1518 changed = true;
1519 break;
1520 case MCAST_EXCLUDE:
1521 changed = __grp_src_isexc_excl(pg, srcs, nsrcs, src_size);
1522 break;
1523 }
1524
1525 pg->filter_mode = MCAST_EXCLUDE;
1526 mod_timer(&pg->timer, jiffies + br_multicast_gmi(br));
1527
1528 return changed;
1529}
1530
5bf1e00b
NA		 1531/* State Msg type New state Actions
1532 * INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI
1533 * Send Q(G,A-B)
1534 */
1535static bool __grp_src_toin_incl(struct net_bridge_port_group *pg,
1536 void *srcs, u32 nsrcs, size_t src_size)
1537{
1538 struct net_bridge *br = pg->port->br;
1539 u32 src_idx, to_send = pg->src_ents;
1540 struct net_bridge_group_src *ent;
1541 unsigned long now = jiffies;
1542 bool changed = false;
1543 struct br_ip src_ip;
1544
1545 hlist_for_each_entry(ent, &pg->src_list, node)
1546 ent->flags |= BR_SGRP_F_SEND;
1547
1548 memset(&src_ip, 0, sizeof(src_ip));
1549 src_ip.proto = pg->addr.proto;
1550 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1551 memcpy(&src_ip.src, srcs, src_size);
5bf1e00b
NA		 1552 ent = br_multicast_find_group_src(pg, &src_ip);
1553 if (ent) {
1554 ent->flags &= ~BR_SGRP_F_SEND;
1555 to_send--;
1556 } else {
1557 ent = br_multicast_new_group_src(pg, &src_ip);
1558 if (ent)
1559 changed = true;
1560 }
1561 if (ent)
1562 mod_timer(&ent->timer, now + br_multicast_gmi(br));
1563 srcs += src_size;
1564 }
1565
1566 if (to_send)
1567 __grp_src_query_marked_and_rexmit(pg);
1568
1569 return changed;
1570}
1571
1572/* State Msg type New state Actions
1573 * EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI
1574 * Send Q(G,X-A)
1575 * Send Q(G)
1576 */
1577static bool __grp_src_toin_excl(struct net_bridge_port_group *pg,
1578 void *srcs, u32 nsrcs, size_t src_size)
1579{
1580 struct net_bridge *br = pg->port->br;
1581 u32 src_idx, to_send = pg->src_ents;
1582 struct net_bridge_group_src *ent;
1583 unsigned long now = jiffies;
1584 bool changed = false;
1585 struct br_ip src_ip;
1586
1587 hlist_for_each_entry(ent, &pg->src_list, node)
1588 if (timer_pending(&ent->timer))
1589 ent->flags |= BR_SGRP_F_SEND;
1590
1591 memset(&src_ip, 0, sizeof(src_ip));
1592 src_ip.proto = pg->addr.proto;
1593 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1594 memcpy(&src_ip.src, srcs, src_size);
5bf1e00b
NA		 1595 ent = br_multicast_find_group_src(pg, &src_ip);
1596 if (ent) {
1597 if (timer_pending(&ent->timer)) {
1598 ent->flags &= ~BR_SGRP_F_SEND;
1599 to_send--;
1600 }
1601 } else {
1602 ent = br_multicast_new_group_src(pg, &src_ip);
1603 if (ent)
1604 changed = true;
1605 }
1606 if (ent)
1607 mod_timer(&ent->timer, now + br_multicast_gmi(br));
1608 srcs += src_size;
1609 }
1610
1611 if (to_send)
1612 __grp_src_query_marked_and_rexmit(pg);
1613
1614 __grp_send_query_and_rexmit(pg);
1615
1616 return changed;
1617}
1618
1619static bool br_multicast_toin(struct net_bridge_port_group *pg,
1620 void *srcs, u32 nsrcs, size_t src_size)
1621{
1622 bool changed = false;
1623
1624 switch (pg->filter_mode) {
1625 case MCAST_INCLUDE:
1626 changed = __grp_src_toin_incl(pg, srcs, nsrcs, src_size);
1627 break;
1628 case MCAST_EXCLUDE:
1629 changed = __grp_src_toin_excl(pg, srcs, nsrcs, src_size);
1630 break;
1631 }
1632
1633 return changed;
1634}
1635
1636/* State Msg type New state Actions
1637 * INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
1638 * Delete (A-B)
1639 * Send Q(G,A*B)
1640 * Group Timer=GMI
1641 */
1642static void __grp_src_toex_incl(struct net_bridge_port_group *pg,
1643 void *srcs, u32 nsrcs, size_t src_size)
1644{
1645 struct net_bridge_group_src *ent;
1646 u32 src_idx, to_send = 0;
1647 struct br_ip src_ip;
1648
1649 hlist_for_each_entry(ent, &pg->src_list, node)
1650 ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE;
1651
1652 memset(&src_ip, 0, sizeof(src_ip));
1653 src_ip.proto = pg->addr.proto;
1654 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1655 memcpy(&src_ip.src, srcs, src_size);
5bf1e00b
NA		 1656 ent = br_multicast_find_group_src(pg, &src_ip);
1657 if (ent) {
1658 ent->flags = (ent->flags & ~BR_SGRP_F_DELETE) |
1659 BR_SGRP_F_SEND;
1660 to_send++;
1661 } else {
1662 br_multicast_new_group_src(pg, &src_ip);
1663 }
1664 srcs += src_size;
1665 }
1666
1667 __grp_src_delete_marked(pg);
1668 if (to_send)
1669 __grp_src_query_marked_and_rexmit(pg);
1670}
1671
1672/* State Msg type New state Actions
1673 * EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer
1674 * Delete (X-A)
1675 * Delete (Y-A)
1676 * Send Q(G,A-Y)
1677 * Group Timer=GMI
1678 */
1679static bool __grp_src_toex_excl(struct net_bridge_port_group *pg,
1680 void *srcs, u32 nsrcs, size_t src_size)
1681{
1682 struct net_bridge_group_src *ent;
1683 u32 src_idx, to_send = 0;
1684 bool changed = false;
1685 struct br_ip src_ip;
1686
1687 hlist_for_each_entry(ent, &pg->src_list, node)
1688 ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE;
1689
1690 memset(&src_ip, 0, sizeof(src_ip));
1691 src_ip.proto = pg->addr.proto;
1692 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1693 memcpy(&src_ip.src, srcs, src_size);
5bf1e00b
NA		 1694 ent = br_multicast_find_group_src(pg, &src_ip);
1695 if (ent) {
1696 ent->flags &= ~BR_SGRP_F_DELETE;
1697 } else {
1698 ent = br_multicast_new_group_src(pg, &src_ip);
1699 if (ent) {
1700 mod_timer(&ent->timer, pg->timer.expires);
1701 changed = true;
1702 }
1703 }
1704 if (ent && timer_pending(&ent->timer)) {
1705 ent->flags |= BR_SGRP_F_SEND;
1706 to_send++;
1707 }
1708 srcs += src_size;
1709 }
1710
1711 if (__grp_src_delete_marked(pg))
1712 changed = true;
1713 if (to_send)
1714 __grp_src_query_marked_and_rexmit(pg);
1715
1716 return changed;
1717}
1718
1719static bool br_multicast_toex(struct net_bridge_port_group *pg,
1720 void *srcs, u32 nsrcs, size_t src_size)
1721{
1722 struct net_bridge *br = pg->port->br;
1723 bool changed = false;
1724
1725 switch (pg->filter_mode) {
1726 case MCAST_INCLUDE:
1727 __grp_src_toex_incl(pg, srcs, nsrcs, src_size);
1728 changed = true;
1729 break;
1730 case MCAST_EXCLUDE:
d5bf31dd 1731 changed = __grp_src_toex_excl(pg, srcs, nsrcs, src_size);
5bf1e00b
NA		 1732 break;
1733 }
1734
1735 pg->filter_mode = MCAST_EXCLUDE;
1736 mod_timer(&pg->timer, jiffies + br_multicast_gmi(br));
1737
1738 return changed;
1739}
1740
109865fe
NA		 1741/* State Msg type New state Actions
1742 * INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B)
1743 */
1744static void __grp_src_block_incl(struct net_bridge_port_group *pg,
1745 void *srcs, u32 nsrcs, size_t src_size)
1746{
1747 struct net_bridge_group_src *ent;
1748 u32 src_idx, to_send = 0;
1749 struct br_ip src_ip;
1750
1751 hlist_for_each_entry(ent, &pg->src_list, node)
1752 ent->flags &= ~BR_SGRP_F_SEND;
1753
1754 memset(&src_ip, 0, sizeof(src_ip));
1755 src_ip.proto = pg->addr.proto;
1756 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1757 memcpy(&src_ip.src, srcs, src_size);
109865fe
NA		 1758 ent = br_multicast_find_group_src(pg, &src_ip);
1759 if (ent) {
1760 ent->flags |= BR_SGRP_F_SEND;
1761 to_send++;
1762 }
1763 srcs += src_size;
1764 }
1765
1766 if (to_send)
1767 __grp_src_query_marked_and_rexmit(pg);
1768
1769 if (pg->filter_mode == MCAST_INCLUDE && hlist_empty(&pg->src_list))
1770 br_multicast_find_del_pg(pg->port->br, pg);
1771}
1772
1773/* State Msg type New state Actions
1774 * EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer
1775 * Send Q(G,A-Y)
1776 */
1777static bool __grp_src_block_excl(struct net_bridge_port_group *pg,
1778 void *srcs, u32 nsrcs, size_t src_size)
1779{
1780 struct net_bridge_group_src *ent;
1781 u32 src_idx, to_send = 0;
1782 bool changed = false;
1783 struct br_ip src_ip;
1784
1785 hlist_for_each_entry(ent, &pg->src_list, node)
1786 ent->flags &= ~BR_SGRP_F_SEND;
1787
1788 memset(&src_ip, 0, sizeof(src_ip));
1789 src_ip.proto = pg->addr.proto;
1790 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
deb96566 1791 memcpy(&src_ip.src, srcs, src_size);
109865fe
NA		 1792 ent = br_multicast_find_group_src(pg, &src_ip);
1793 if (!ent) {
1794 ent = br_multicast_new_group_src(pg, &src_ip);
1795 if (ent) {
1796 mod_timer(&ent->timer, pg->timer.expires);
1797 changed = true;
1798 }
1799 }
1800 if (ent && timer_pending(&ent->timer)) {
1801 ent->flags |= BR_SGRP_F_SEND;
1802 to_send++;
1803 }
1804 srcs += src_size;
1805 }
1806
1807 if (to_send)
1808 __grp_src_query_marked_and_rexmit(pg);
1809
1810 return changed;
1811}
1812
1813static bool br_multicast_block(struct net_bridge_port_group *pg,
1814 void *srcs, u32 nsrcs, size_t src_size)
1815{
1816 bool changed = false;
1817
1818 switch (pg->filter_mode) {
1819 case MCAST_INCLUDE:
1820 __grp_src_block_incl(pg, srcs, nsrcs, src_size);
1821 break;
1822 case MCAST_EXCLUDE:
1823 changed = __grp_src_block_excl(pg, srcs, nsrcs, src_size);
1824 break;
1825 }
1826
1827 return changed;
1828}
1829
0436862e
NA		 1830static struct net_bridge_port_group *
1831br_multicast_find_port(struct net_bridge_mdb_entry *mp,
1832 struct net_bridge_port *p,
1833 const unsigned char *src)
1834{
071445c6 1835 struct net_bridge *br __maybe_unused = mp->br;
0436862e 1836 struct net_bridge_port_group *pg;
0436862e
NA		 1837
1838 for (pg = mlock_dereference(mp->ports, br);
1839 pg;
1840 pg = mlock_dereference(pg->next, br))
1841 if (br_port_group_equal(pg, p, src))
1842 return pg;
1843
1844 return NULL;
1845}
1846
8ef2a9a5
YH		 1847static int br_ip4_multicast_igmp3_report(struct net_bridge *br,
1848 struct net_bridge_port *port,
06499098
VY		 1849 struct sk_buff *skb,
1850 u16 vid)
eb1d1641 1851{
0436862e
NA		 1852 bool igmpv2 = br->multicast_igmp_version == 2;
1853 struct net_bridge_mdb_entry *mdst;
1854 struct net_bridge_port_group *pg;
6db6f0ea 1855 const unsigned char *src;
eb1d1641
HX		 1856 struct igmpv3_report *ih;
1857 struct igmpv3_grec *grec;
0436862e
NA		 1858 int i, len, num, type;
1859 bool changed = false;
eb1d1641 1860 __be32 group;
0436862e 1861 int err = 0;
e57f6185 1862 u16 nsrcs;
eb1d1641 1863
eb1d1641
HX		 1864 ih = igmpv3_report_hdr(skb);
1865 num = ntohs(ih->ngrec);
c2d4fbd2 1866 len = skb_transport_offset(skb) + sizeof(*ih);
eb1d1641
HX		 1867
1868 for (i = 0; i < num; i++) {
1869 len += sizeof(*grec);
ba5ea614 1870 if (!ip_mc_may_pull(skb, len))
eb1d1641
HX		 1871 return -EINVAL;
1872
fd218cf9 1873 grec = (void *)(skb->data + len - sizeof(*grec));
eb1d1641
HX		 1874 group = grec->grec_mca;
1875 type = grec->grec_type;
e57f6185 1876 nsrcs = ntohs(grec->grec_nsrcs);
eb1d1641 1877
e57f6185 1878 len += nsrcs * 4;
ba5ea614 1879 if (!ip_mc_may_pull(skb, len))
eb1d1641
HX		 1880 return -EINVAL;
1881
eb1d1641
HX		 1882 switch (type) {
1883 case IGMPV3_MODE_IS_INCLUDE:
1884 case IGMPV3_MODE_IS_EXCLUDE:
1885 case IGMPV3_CHANGE_TO_INCLUDE:
1886 case IGMPV3_CHANGE_TO_EXCLUDE:
1887 case IGMPV3_ALLOW_NEW_SOURCES:
1888 case IGMPV3_BLOCK_OLD_SOURCES:
1889 break;
1890
1891 default:
1892 continue;
1893 }
1894
6db6f0ea 1895 src = eth_hdr(skb)->h_source;
0436862e
NA		 1896 if (nsrcs == 0 &&
1897 (type == IGMPV3_CHANGE_TO_INCLUDE ||
1898 type == IGMPV3_MODE_IS_INCLUDE)) {
1899 if (!port || igmpv2) {
1900 br_ip4_multicast_leave_group(br, port, group, vid, src);
1901 continue;
1902 }
bc8c20ac 1903 } else {
6db6f0ea 1904 err = br_ip4_multicast_add_group(br, port, group, vid,
0436862e 1905 src, igmpv2);
bc8c20ac
SA		 1906 if (err)
1907 break;
1908 }
0436862e
NA		 1909
1910 if (!port || igmpv2)
1911 continue;
1912
1913 spin_lock_bh(&br->multicast_lock);
1914 mdst = br_mdb_ip4_get(br, group, vid);
1915 if (!mdst)
1916 goto unlock_continue;
1917 pg = br_multicast_find_port(mdst, port, src);
1918 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
1919 goto unlock_continue;
1920 /* reload grec */
1921 grec = (void *)(skb->data + len - sizeof(*grec) - (nsrcs * 4));
1922 switch (type) {
1923 case IGMPV3_ALLOW_NEW_SOURCES:
1924 changed = br_multicast_isinc_allow(pg, grec->grec_src,
1925 nsrcs, sizeof(__be32));
1926 break;
e6231bca
NA		 1927 case IGMPV3_MODE_IS_INCLUDE:
1928 changed = br_multicast_isinc_allow(pg, grec->grec_src, nsrcs,
1929 sizeof(__be32));
1930 break;
1931 case IGMPV3_MODE_IS_EXCLUDE:
1932 changed = br_multicast_isexc(pg, grec->grec_src, nsrcs,
1933 sizeof(__be32));
1934 break;
5bf1e00b
NA		 1935 case IGMPV3_CHANGE_TO_INCLUDE:
1936 changed = br_multicast_toin(pg, grec->grec_src, nsrcs,
1937 sizeof(__be32));
1938 break;
1939 case IGMPV3_CHANGE_TO_EXCLUDE:
1940 changed = br_multicast_toex(pg, grec->grec_src, nsrcs,
1941 sizeof(__be32));
1942 break;
109865fe
NA		 1943 case IGMPV3_BLOCK_OLD_SOURCES:
1944 changed = br_multicast_block(pg, grec->grec_src, nsrcs,
1945 sizeof(__be32));
1946 break;
0436862e
NA		 1947 }
1948 if (changed)
1949 br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB);
1950unlock_continue:
1951 spin_unlock_bh(&br->multicast_lock);
eb1d1641
HX		 1952 }
1953
1954 return err;
1955}
1956
dfd56b8b 1957#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 1958static int br_ip6_multicast_mld2_report(struct net_bridge *br,
1959 struct net_bridge_port *port,
06499098
VY		 1960 struct sk_buff *skb,
1961 u16 vid)
08b202b6 1962{
0436862e
NA		 1963 bool mldv1 = br->multicast_mld_version == 1;
1964 struct net_bridge_mdb_entry *mdst;
1965 struct net_bridge_port_group *pg;
ba5ea614 1966 unsigned int nsrcs_offset;
6db6f0ea 1967 const unsigned char *src;
08b202b6
YH		 1968 struct icmp6hdr *icmp6h;
1969 struct mld2_grec *grec;
ba5ea614 1970 unsigned int grec_len;
0436862e
NA		 1971 bool changed = false;
1972 int i, len, num;
08b202b6
YH		 1973 int err = 0;
1974
ba5ea614 1975 if (!ipv6_mc_may_pull(skb, sizeof(*icmp6h)))
08b202b6
YH		 1976 return -EINVAL;
1977
1978 icmp6h = icmp6_hdr(skb);
1979 num = ntohs(icmp6h->icmp6_dataun.un_data16[1]);
c2d4fbd2 1980 len = skb_transport_offset(skb) + sizeof(*icmp6h);
08b202b6
YH		 1981
1982 for (i = 0; i < num; i++) {
e57f6185
NA		 1983 __be16 *_nsrcs, __nsrcs;
1984 u16 nsrcs;
08b202b6 1985
ba5ea614
LL		 1986 nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs);
1987
1988 if (skb_transport_offset(skb) + ipv6_transport_len(skb) <
5fc6266a 1989 nsrcs_offset + sizeof(__nsrcs))
ba5ea614
LL		 1990 return -EINVAL;
1991
e57f6185
NA		 1992 _nsrcs = skb_header_pointer(skb, nsrcs_offset,
1993 sizeof(__nsrcs), &__nsrcs);
1994 if (!_nsrcs)
08b202b6
YH		 1995 return -EINVAL;
1996
e57f6185
NA		 1997 nsrcs = ntohs(*_nsrcs);
1998 grec_len = struct_size(grec, grec_src, nsrcs);
ba5ea614
LL		 1999
2000 if (!ipv6_mc_may_pull(skb, len + grec_len))
08b202b6
YH		 2001 return -EINVAL;
2002
2003 grec = (struct mld2_grec *)(skb->data + len);
ba5ea614 2004 len += grec_len;
08b202b6 2005
08b202b6
YH		 2006 switch (grec->grec_type) {
2007 case MLD2_MODE_IS_INCLUDE:
2008 case MLD2_MODE_IS_EXCLUDE:
2009 case MLD2_CHANGE_TO_INCLUDE:
2010 case MLD2_CHANGE_TO_EXCLUDE:
2011 case MLD2_ALLOW_NEW_SOURCES:
2012 case MLD2_BLOCK_OLD_SOURCES:
2013 break;
2014
2015 default:
2016 continue;
2017 }
2018
6db6f0ea 2019 src = eth_hdr(skb)->h_source;
bc8c20ac
SA		 2020 if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
2021 grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
e57f6185 2022 nsrcs == 0) {
0436862e
NA		 2023 if (!port || mldv1) {
2024 br_ip6_multicast_leave_group(br, port,
2025 &grec->grec_mca,
2026 vid, src);
2027 continue;
2028 }
bc8c20ac
SA		 2029 } else {
2030 err = br_ip6_multicast_add_group(br, port,
6db6f0ea 2031 &grec->grec_mca, vid,
0436862e 2032 src, mldv1);
9264251e 2033 if (err)
bc8c20ac
SA		 2034 break;
2035 }
0436862e
NA		 2036
2037 if (!port || mldv1)
2038 continue;
2039
2040 spin_lock_bh(&br->multicast_lock);
2041 mdst = br_mdb_ip6_get(br, &grec->grec_mca, vid);
2042 if (!mdst)
2043 goto unlock_continue;
2044 pg = br_multicast_find_port(mdst, port, src);
2045 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
2046 goto unlock_continue;
2047 switch (grec->grec_type) {
2048 case MLD2_ALLOW_NEW_SOURCES:
2049 changed = br_multicast_isinc_allow(pg, grec->grec_src,
2050 nsrcs,
2051 sizeof(struct in6_addr));
2052 break;
e6231bca
NA		 2053 case MLD2_MODE_IS_INCLUDE:
2054 changed = br_multicast_isinc_allow(pg, grec->grec_src, nsrcs,
2055 sizeof(struct in6_addr));
2056 break;
2057 case MLD2_MODE_IS_EXCLUDE:
2058 changed = br_multicast_isexc(pg, grec->grec_src, nsrcs,
2059 sizeof(struct in6_addr));
2060 break;
5bf1e00b
NA		 2061 case MLD2_CHANGE_TO_INCLUDE:
2062 changed = br_multicast_toin(pg, grec->grec_src, nsrcs,
2063 sizeof(struct in6_addr));
2064 break;
2065 case MLD2_CHANGE_TO_EXCLUDE:
2066 changed = br_multicast_toex(pg, grec->grec_src, nsrcs,
2067 sizeof(struct in6_addr));
2068 break;
109865fe
NA		 2069 case MLD2_BLOCK_OLD_SOURCES:
2070 changed = br_multicast_block(pg, grec->grec_src, nsrcs,
2071 sizeof(struct in6_addr));
2072 break;
0436862e
NA		 2073 }
2074 if (changed)
2075 br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB);
2076unlock_continue:
2077 spin_unlock_bh(&br->multicast_lock);
08b202b6
YH		 2078 }
2079
2080 return err;
2081}
2082#endif
2083
dc4eb53a 2084static bool br_ip4_multicast_select_querier(struct net_bridge *br,
2cd41431 2085 struct net_bridge_port *port,
dc4eb53a
LL		 2086 __be32 saddr)
2087{
2088 if (!timer_pending(&br->ip4_own_query.timer) &&
2089 !timer_pending(&br->ip4_other_query.timer))
2090 goto update;
2091
deb96566 2092 if (!br->ip4_querier.addr.src.ip4)
dc4eb53a
LL		 2093 goto update;
2094
deb96566 2095 if (ntohl(saddr) <= ntohl(br->ip4_querier.addr.src.ip4))
dc4eb53a
LL		 2096 goto update;
2097
2098 return false;
2099
2100update:
deb96566 2101 br->ip4_querier.addr.src.ip4 = saddr;
dc4eb53a 2102
2cd41431
LL		 2103 /* update protected by general multicast_lock by caller */
2104 rcu_assign_pointer(br->ip4_querier.port, port);
2105
dc4eb53a
LL		 2106 return true;
2107}
2108
2109#if IS_ENABLED(CONFIG_IPV6)
2110static bool br_ip6_multicast_select_querier(struct net_bridge *br,
2cd41431 2111 struct net_bridge_port *port,
dc4eb53a
LL		 2112 struct in6_addr *saddr)
2113{
2114 if (!timer_pending(&br->ip6_own_query.timer) &&
2115 !timer_pending(&br->ip6_other_query.timer))
2116 goto update;
2117
deb96566 2118 if (ipv6_addr_cmp(saddr, &br->ip6_querier.addr.src.ip6) <= 0)
dc4eb53a
LL		 2119 goto update;
2120
2121 return false;
2122
2123update:
deb96566 2124 br->ip6_querier.addr.src.ip6 = *saddr;
dc4eb53a 2125
2cd41431
LL		 2126 /* update protected by general multicast_lock by caller */
2127 rcu_assign_pointer(br->ip6_querier.port, port);
2128
dc4eb53a
LL		 2129 return true;
2130}
2131#endif
2132
2133static bool br_multicast_select_querier(struct net_bridge *br,
2cd41431 2134 struct net_bridge_port *port,
dc4eb53a
LL		 2135 struct br_ip *saddr)
2136{
2137 switch (saddr->proto) {
2138 case htons(ETH_P_IP):
deb96566 2139 return br_ip4_multicast_select_querier(br, port, saddr->src.ip4);
dc4eb53a
LL		 2140#if IS_ENABLED(CONFIG_IPV6)
2141 case htons(ETH_P_IPV6):
deb96566 2142 return br_ip6_multicast_select_querier(br, port, &saddr->src.ip6);
dc4eb53a
LL		 2143#endif
2144 }
2145
2146 return false;
2147}
2148
cc0fdd80 2149static void
90010b36
LL		 2150br_multicast_update_query_timer(struct net_bridge *br,
2151 struct bridge_mcast_other_query *query,
2152 unsigned long max_delay)
b00589af 2153{
90010b36
LL		 2154 if (!timer_pending(&query->timer))
2155 query->delay_time = jiffies + max_delay;
b00589af 2156
90010b36 2157 mod_timer(&query->timer, jiffies + br->multicast_querier_interval);
b00589af
LL		 2158}
2159
6d549648
NF		 2160static void br_port_mc_router_state_change(struct net_bridge_port *p,
2161 bool is_mc_router)
2162{
2163 struct switchdev_attr attr = {
2164 .orig_dev = p->dev,
2165 .id = SWITCHDEV_ATTR_ID_PORT_MROUTER,
2166 .flags = SWITCHDEV_F_DEFER,
2167 .u.mrouter = is_mc_router,
2168 };
2169
2170 switchdev_port_attr_set(p->dev, &attr);
2171}
2172
7e80c124 2173/*
7c77602f 2174 * Add port to router_list
7e80c124 2175 * list is maintained ordered by pointer value
2176 * and locked by br->multicast_lock and RCU
2177 */
0909e117
HX		 2178static void br_multicast_add_router(struct net_bridge *br,
2179 struct net_bridge_port *port)
2180{
dcdca2c4 2181 struct net_bridge_port *p;
b67bfe0d 2182 struct hlist_node *slot = NULL;
dcdca2c4 2183
1a040eac
NA		 2184 if (!hlist_unhashed(&port->rlist))
2185 return;
2186
b67bfe0d 2187 hlist_for_each_entry(p, &br->router_list, rlist) {
7e80c124 2188 if ((unsigned long) port >= (unsigned long) p)
2189 break;
b67bfe0d 2190 slot = &p->rlist;
dcdca2c4 2191 }
2192
7e80c124 2193 if (slot)
1d023284 2194 hlist_add_behind_rcu(&port->rlist, slot);
dcdca2c4 2195 else
2196 hlist_add_head_rcu(&port->rlist, &br->router_list);
949f1e39 2197 br_rtr_notify(br->dev, port, RTM_NEWMDB);
6d549648 2198 br_port_mc_router_state_change(port, true);
0909e117
HX		 2199}
2200
eb1d1641
HX		 2201static void br_multicast_mark_router(struct net_bridge *br,
2202 struct net_bridge_port *port)
2203{
2204 unsigned long now = jiffies;
eb1d1641
HX		 2205
2206 if (!port) {
77041420
YG		 2207 if (br->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) {
2208 if (!timer_pending(&br->multicast_router_timer))
2209 br_mc_router_state_change(br, true);
eb1d1641
HX		 2210 mod_timer(&br->multicast_router_timer,
2211 now + br->multicast_querier_interval);
77041420 2212 }
eb1d1641
HX		 2213 return;
2214 }
2215
a55d8246
NA		 2216 if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
2217 port->multicast_router == MDB_RTR_TYPE_PERM)
eb1d1641
HX		 2218 return;
2219
0909e117 2220 br_multicast_add_router(br, port);
eb1d1641 2221
eb1d1641
HX		 2222 mod_timer(&port->multicast_router_timer,
2223 now + br->multicast_querier_interval);
2224}
2225
2226static void br_multicast_query_received(struct net_bridge *br,
2227 struct net_bridge_port *port,
90010b36 2228 struct bridge_mcast_other_query *query,
dc4eb53a 2229 struct br_ip *saddr,
b00589af 2230 unsigned long max_delay)
eb1d1641 2231{
2cd41431 2232 if (!br_multicast_select_querier(br, port, saddr))
eb1d1641
HX		 2233 return;
2234
dc4eb53a 2235 br_multicast_update_query_timer(br, query, max_delay);
278e2148 2236 br_multicast_mark_router(br, port);
eb1d1641
HX		 2237}
2238
9c2e955c 2239static void br_ip4_multicast_query(struct net_bridge *br,
2240 struct net_bridge_port *port,
2241 struct sk_buff *skb,
2242 u16 vid)
eb1d1641 2243{
ba5ea614 2244 unsigned int transport_len = ip_transport_len(skb);
b71d1d42 2245 const struct iphdr *iph = ip_hdr(skb);
eb1d1641
HX		 2246 struct igmphdr *ih = igmp_hdr(skb);
2247 struct net_bridge_mdb_entry *mp;
2248 struct igmpv3_query *ih3;
2249 struct net_bridge_port_group *p;
e8051688 2250 struct net_bridge_port_group __rcu **pp;
dc4eb53a 2251 struct br_ip saddr;
eb1d1641
HX		 2252 unsigned long max_delay;
2253 unsigned long now = jiffies;
2254 __be32 group;
2255
2256 spin_lock(&br->multicast_lock);
2257 if (!netif_running(br->dev) ||
2258 (port && port->state == BR_STATE_DISABLED))
2259 goto out;
2260
eb1d1641
HX		 2261 group = ih->group;
2262
ba5ea614 2263 if (transport_len == sizeof(*ih)) {
eb1d1641
HX		 2264 max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
2265
2266 if (!max_delay) {
2267 max_delay = 10 * HZ;
2268 group = 0;
2269 }
ba5ea614 2270 } else if (transport_len >= sizeof(*ih3)) {
eb1d1641 2271 ih3 = igmpv3_query_hdr(skb);
23550b83
NA		 2272 if (ih3->nsrcs ||
2273 (br->multicast_igmp_version == 3 && group && ih3->suppress))
bec68ff1 2274 goto out;
eb1d1641 2275
0ba8c9ec
YH		 2276 max_delay = ih3->code ?
2277 IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1;
9afd85c9 2278 } else {
9ed973cc
LL		 2279 goto out;
2280 }
2281
dc4eb53a
LL		 2282 if (!group) {
2283 saddr.proto = htons(ETH_P_IP);
deb96566 2284 saddr.src.ip4 = iph->saddr;
b00589af 2285
dc4eb53a
LL		 2286 br_multicast_query_received(br, port, &br->ip4_other_query,
2287 &saddr, max_delay);
eb1d1641 2288 goto out;
dc4eb53a 2289 }
eb1d1641 2290
19e3a9c9 2291 mp = br_mdb_ip4_get(br, group, vid);
eb1d1641
HX		 2292 if (!mp)
2293 goto out;
2294
2295 max_delay *= br->multicast_last_member_count;
2296
ff0fd34e 2297 if (mp->host_joined &&
eb1d1641
HX		 2298 (timer_pending(&mp->timer) ?
2299 time_after(mp->timer.expires, now + max_delay) :
2300 try_to_del_timer_sync(&mp->timer) >= 0))
2301 mod_timer(&mp->timer, now + max_delay);
2302
e8051688
ED		 2303 for (pp = &mp->ports;
2304 (p = mlock_dereference(*pp, br)) != NULL;
2305 pp = &p->next) {
eb1d1641
HX		 2306 if (timer_pending(&p->timer) ?
2307 time_after(p->timer.expires, now + max_delay) :
23550b83
NA		 2308 try_to_del_timer_sync(&p->timer) >= 0 &&
2309 (br->multicast_igmp_version == 2 ||
2310 p->filter_mode == MCAST_EXCLUDE))
24f9cdcb 2311 mod_timer(&p->timer, now + max_delay);
eb1d1641
HX		 2312 }
2313
2314out:
2315 spin_unlock(&br->multicast_lock);
eb1d1641
HX		 2316}
2317
dfd56b8b 2318#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 2319static int br_ip6_multicast_query(struct net_bridge *br,
2320 struct net_bridge_port *port,
06499098
VY		 2321 struct sk_buff *skb,
2322 u16 vid)
08b202b6 2323{
ba5ea614 2324 unsigned int transport_len = ipv6_transport_len(skb);
eca2a43b 2325 struct mld_msg *mld;
08b202b6
YH		 2326 struct net_bridge_mdb_entry *mp;
2327 struct mld2_query *mld2q;
e8051688
ED		 2328 struct net_bridge_port_group *p;
2329 struct net_bridge_port_group __rcu **pp;
dc4eb53a 2330 struct br_ip saddr;
08b202b6
YH		 2331 unsigned long max_delay;
2332 unsigned long now = jiffies;
856ce5d0 2333 unsigned int offset = skb_transport_offset(skb);
b71d1d42 2334 const struct in6_addr *group = NULL;
9ed973cc 2335 bool is_general_query;
08b202b6
YH		 2336 int err = 0;
2337
2338 spin_lock(&br->multicast_lock);
2339 if (!netif_running(br->dev) ||
2340 (port && port->state == BR_STATE_DISABLED))
2341 goto out;
2342
ba5ea614 2343 if (transport_len == sizeof(*mld)) {
856ce5d0 2344 if (!pskb_may_pull(skb, offset + sizeof(*mld))) {
08b202b6
YH		 2345 err = -EINVAL;
2346 goto out;
2347 }
2348 mld = (struct mld_msg *) icmp6_hdr(skb);
4715213d 2349 max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));
08b202b6
YH		 2350 if (max_delay)
2351 group = &mld->mld_mca;
248ba8ec 2352 } else {
856ce5d0 2353 if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) {
08b202b6
YH		 2354 err = -EINVAL;
2355 goto out;
2356 }
2357 mld2q = (struct mld2_query *)icmp6_hdr(skb);
2358 if (!mld2q->mld2q_nsrcs)
2359 group = &mld2q->mld2q_mca;
23550b83
NA		 2360 if (br->multicast_mld_version == 2 &&
2361 !ipv6_addr_any(&mld2q->mld2q_mca) &&
2362 mld2q->mld2q_suppress)
2363 goto out;
e3f5b170
DB		 2364
2365 max_delay = max(msecs_to_jiffies(mldv2_mrc(mld2q)), 1UL);
08b202b6
YH		 2366 }
2367
9ed973cc
LL		 2368 is_general_query = group && ipv6_addr_any(group);
2369
dc4eb53a
LL		 2370 if (is_general_query) {
2371 saddr.proto = htons(ETH_P_IPV6);
deb96566 2372 saddr.src.ip6 = ipv6_hdr(skb)->saddr;
b00589af 2373
dc4eb53a
LL		 2374 br_multicast_query_received(br, port, &br->ip6_other_query,
2375 &saddr, max_delay);
08b202b6 2376 goto out;
6c03ee8b
LL		 2377 } else if (!group) {
2378 goto out;
dc4eb53a 2379 }
08b202b6 2380
19e3a9c9 2381 mp = br_mdb_ip6_get(br, group, vid);
08b202b6
YH		 2382 if (!mp)
2383 goto out;
2384
2385 max_delay *= br->multicast_last_member_count;
ff0fd34e 2386 if (mp->host_joined &&
08b202b6
YH		 2387 (timer_pending(&mp->timer) ?
2388 time_after(mp->timer.expires, now + max_delay) :
2389 try_to_del_timer_sync(&mp->timer) >= 0))
2390 mod_timer(&mp->timer, now + max_delay);
2391
e8051688
ED		 2392 for (pp = &mp->ports;
2393 (p = mlock_dereference(*pp, br)) != NULL;
2394 pp = &p->next) {
08b202b6
YH		 2395 if (timer_pending(&p->timer) ?
2396 time_after(p->timer.expires, now + max_delay) :
23550b83
NA		 2397 try_to_del_timer_sync(&p->timer) >= 0 &&
2398 (br->multicast_mld_version == 1 ||
2399 p->filter_mode == MCAST_EXCLUDE))
24f9cdcb 2400 mod_timer(&p->timer, now + max_delay);
08b202b6
YH		 2401 }
2402
2403out:
2404 spin_unlock(&br->multicast_lock);
2405 return err;
2406}
2407#endif
2408
90010b36
LL		 2409static void
2410br_multicast_leave_group(struct net_bridge *br,
2411 struct net_bridge_port *port,
2412 struct br_ip *group,
2413 struct bridge_mcast_other_query *other_query,
6db6f0ea
FF		 2414 struct bridge_mcast_own_query *own_query,
2415 const unsigned char *src)
eb1d1641 2416{
eb1d1641
HX		 2417 struct net_bridge_mdb_entry *mp;
2418 struct net_bridge_port_group *p;
2419 unsigned long now;
2420 unsigned long time;
2421
eb1d1641
HX		 2422 spin_lock(&br->multicast_lock);
2423 if (!netif_running(br->dev) ||
544586f7 2424 (port && port->state == BR_STATE_DISABLED))
eb1d1641
HX		 2425 goto out;
2426
19e3a9c9 2427 mp = br_mdb_ip_get(br, group);
eb1d1641
HX		 2428 if (!mp)
2429 goto out;
2430
544586f7
SA		 2431 if (port && (port->flags & BR_MULTICAST_FAST_LEAVE)) {
2432 struct net_bridge_port_group __rcu **pp;
2433
2434 for (pp = &mp->ports;
2435 (p = mlock_dereference(*pp, br)) != NULL;
2436 pp = &p->next) {
6db6f0ea 2437 if (!br_port_group_equal(p, port, src))
544586f7
SA		 2438 continue;
2439
5c725b6b
NA		 2440 if (p->flags & MDB_PG_FLAGS_PERMANENT)
2441 break;
2442
681590bd
NA		 2443 p->flags |= MDB_PG_FLAGS_FAST_LEAVE;
2444 br_multicast_del_pg(mp, p, pp);
544586f7
SA		 2445 }
2446 goto out;
2447 }
2448
2449 if (timer_pending(&other_query->timer))
2450 goto out;
2451
675779ad 2452 if (br_opt_get(br, BROPT_MULTICAST_QUERIER)) {
438ef2d0 2453 __br_multicast_send_query(br, port, NULL, NULL, &mp->addr,
42c11ccf 2454 false, 0, NULL);
6b7df111
CW		 2455
2456 time = jiffies + br->multicast_last_member_count *
2457 br->multicast_last_member_interval;
cc0fdd80 2458
90010b36 2459 mod_timer(&own_query->timer, time);
6b7df111
CW		 2460
2461 for (p = mlock_dereference(mp->ports, br);
2462 p != NULL;
2463 p = mlock_dereference(p->next, br)) {
6db6f0ea 2464 if (!br_port_group_equal(p, port, src))
6b7df111
CW		 2465 continue;
2466
2467 if (!hlist_unhashed(&p->mglist) &&
2468 (timer_pending(&p->timer) ?
2469 time_after(p->timer.expires, time) :
2470 try_to_del_timer_sync(&p->timer) >= 0)) {
2471 mod_timer(&p->timer, time);
2472 }
2473
2474 break;
2475 }
2476 }
2477
eb1d1641
HX		 2478 now = jiffies;
2479 time = now + br->multicast_last_member_count *
2480 br->multicast_last_member_interval;
2481
2482 if (!port) {
ff0fd34e 2483 if (mp->host_joined &&
eb1d1641
HX		 2484 (timer_pending(&mp->timer) ?
2485 time_after(mp->timer.expires, time) :
2486 try_to_del_timer_sync(&mp->timer) >= 0)) {
2487 mod_timer(&mp->timer, time);
eb1d1641 2488 }
454594f3
LL		 2489
2490 goto out;
2491 }
2492
2493 for (p = mlock_dereference(mp->ports, br);
2494 p != NULL;
2495 p = mlock_dereference(p->next, br)) {
2496 if (p->port != port)
2497 continue;
2498
2499 if (!hlist_unhashed(&p->mglist) &&
2500 (timer_pending(&p->timer) ?
2501 time_after(p->timer.expires, time) :
2502 try_to_del_timer_sync(&p->timer) >= 0)) {
2503 mod_timer(&p->timer, time);
2504 }
2505
2506 break;
eb1d1641 2507 }
eb1d1641
HX		 2508out:
2509 spin_unlock(&br->multicast_lock);
2510}
2511
8ef2a9a5
YH		 2512static void br_ip4_multicast_leave_group(struct net_bridge *br,
2513 struct net_bridge_port *port,
b0e9a30d 2514 __be32 group,
6db6f0ea
FF		 2515 __u16 vid,
2516 const unsigned char *src)
8ef2a9a5
YH		 2517{
2518 struct br_ip br_group;
90010b36 2519 struct bridge_mcast_own_query *own_query;
8ef2a9a5
YH		 2520
2521 if (ipv4_is_local_multicast(group))
2522 return;
2523
90010b36
LL		 2524 own_query = port ? &port->ip4_own_query : &br->ip4_own_query;
2525
1515a63f 2526 memset(&br_group, 0, sizeof(br_group));
eab3227b 2527 br_group.dst.ip4 = group;
8ef2a9a5 2528 br_group.proto = htons(ETH_P_IP);
b0e9a30d 2529 br_group.vid = vid;
8ef2a9a5 2530
90010b36 2531 br_multicast_leave_group(br, port, &br_group, &br->ip4_other_query,
6db6f0ea 2532 own_query, src);
8ef2a9a5
YH		 2533}
2534
dfd56b8b 2535#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 2536static void br_ip6_multicast_leave_group(struct net_bridge *br,
2537 struct net_bridge_port *port,
b0e9a30d 2538 const struct in6_addr *group,
6db6f0ea
FF		 2539 __u16 vid,
2540 const unsigned char *src)
08b202b6
YH		 2541{
2542 struct br_ip br_group;
90010b36 2543 struct bridge_mcast_own_query *own_query;
08b202b6 2544
3c3769e6 2545 if (ipv6_addr_is_ll_all_nodes(group))
08b202b6
YH		 2546 return;
2547
90010b36
LL		 2548 own_query = port ? &port->ip6_own_query : &br->ip6_own_query;
2549
1515a63f 2550 memset(&br_group, 0, sizeof(br_group));
eab3227b 2551 br_group.dst.ip6 = *group;
08b202b6 2552 br_group.proto = htons(ETH_P_IPV6);
b0e9a30d 2553 br_group.vid = vid;
08b202b6 2554
90010b36 2555 br_multicast_leave_group(br, port, &br_group, &br->ip6_other_query,
6db6f0ea 2556 own_query, src);
08b202b6
YH		 2557}
2558#endif
8ef2a9a5 2559
1080ab95
NA		 2560static void br_multicast_err_count(const struct net_bridge *br,
2561 const struct net_bridge_port *p,
2562 __be16 proto)
2563{
2564 struct bridge_mcast_stats __percpu *stats;
2565 struct bridge_mcast_stats *pstats;
2566
675779ad 2567 if (!br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
1080ab95
NA		 2568 return;
2569
2570 if (p)
2571 stats = p->mcast_stats;
2572 else
2573 stats = br->mcast_stats;
2574 if (WARN_ON(!stats))
2575 return;
2576
2577 pstats = this_cpu_ptr(stats);
2578
2579 u64_stats_update_begin(&pstats->syncp);
2580 switch (proto) {
2581 case htons(ETH_P_IP):
2582 pstats->mstats.igmp_parse_errors++;
2583 break;
2584#if IS_ENABLED(CONFIG_IPV6)
2585 case htons(ETH_P_IPV6):
2586 pstats->mstats.mld_parse_errors++;
2587 break;
2588#endif
2589 }
2590 u64_stats_update_end(&pstats->syncp);
2591}
2592
91b02d3d
NA		 2593static void br_multicast_pim(struct net_bridge *br,
2594 struct net_bridge_port *port,
2595 const struct sk_buff *skb)
2596{
2597 unsigned int offset = skb_transport_offset(skb);
2598 struct pimhdr *pimhdr, _pimhdr;
2599
2600 pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr);
2601 if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION ||
2602 pim_hdr_type(pimhdr) != PIM_TYPE_HELLO)
2603 return;
2604
2605 br_multicast_mark_router(br, port);
2606}
2607
4b3087c7
LL		 2608static int br_ip4_multicast_mrd_rcv(struct net_bridge *br,
2609 struct net_bridge_port *port,
2610 struct sk_buff *skb)
2611{
2612 if (ip_hdr(skb)->protocol != IPPROTO_IGMP ||
2613 igmp_hdr(skb)->type != IGMP_MRDISC_ADV)
2614 return -ENOMSG;
2615
2616 br_multicast_mark_router(br, port);
2617
2618 return 0;
2619}
2620
eb1d1641
HX		 2621static int br_multicast_ipv4_rcv(struct net_bridge *br,
2622 struct net_bridge_port *port,
06499098
VY		 2623 struct sk_buff *skb,
2624 u16 vid)
eb1d1641 2625{
6db6f0ea 2626 const unsigned char *src;
eb1d1641 2627 struct igmphdr *ih;
eb1d1641
HX		 2628 int err;
2629
ba5ea614 2630 err = ip_mc_check_igmp(skb);
eb1d1641 2631
9afd85c9 2632 if (err == -ENOMSG) {
91b02d3d 2633 if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) {
bd4265fe 2634 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
91b02d3d
NA		 2635 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) {
2636 if (ip_hdr(skb)->protocol == IPPROTO_PIM)
2637 br_multicast_pim(br, port, skb);
4b3087c7 2638 } else if (ipv4_is_all_snoopers(ip_hdr(skb)->daddr)) {
08e71623 2639 br_ip4_multicast_mrd_rcv(br, port, skb);
91b02d3d 2640 }
4b3087c7 2641
eb1d1641 2642 return 0;
9afd85c9 2643 } else if (err < 0) {
1080ab95 2644 br_multicast_err_count(br, port, skb->protocol);
9afd85c9 2645 return err;
bd4265fe 2646 }
eb1d1641 2647
9afd85c9 2648 ih = igmp_hdr(skb);
6db6f0ea 2649 src = eth_hdr(skb)->h_source;
1080ab95 2650 BR_INPUT_SKB_CB(skb)->igmp = ih->type;
eb1d1641
HX		 2651
2652 switch (ih->type) {
2653 case IGMP_HOST_MEMBERSHIP_REPORT:
2654 case IGMPV2_HOST_MEMBERSHIP_REPORT:
62b2bcb4 2655 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
8b671779
NA		 2656 err = br_ip4_multicast_add_group(br, port, ih->group, vid, src,
2657 true);
eb1d1641
HX		 2658 break;
2659 case IGMPV3_HOST_MEMBERSHIP_REPORT:
ba5ea614 2660 err = br_ip4_multicast_igmp3_report(br, port, skb, vid);
eb1d1641
HX		 2661 break;
2662 case IGMP_HOST_MEMBERSHIP_QUERY:
ba5ea614 2663 br_ip4_multicast_query(br, port, skb, vid);
eb1d1641
HX		 2664 break;
2665 case IGMP_HOST_LEAVE_MESSAGE:
6db6f0ea 2666 br_ip4_multicast_leave_group(br, port, ih->group, vid, src);
eb1d1641
HX		 2667 break;
2668 }
2669
a65056ec 2670 br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
1080ab95
NA		 2671 BR_MCAST_DIR_RX);
2672
eb1d1641
HX		 2673 return err;
2674}
2675
dfd56b8b 2676#if IS_ENABLED(CONFIG_IPV6)
4b3087c7
LL		 2677static int br_ip6_multicast_mrd_rcv(struct net_bridge *br,
2678 struct net_bridge_port *port,
2679 struct sk_buff *skb)
2680{
2681 int ret;
2682
2683 if (ipv6_hdr(skb)->nexthdr != IPPROTO_ICMPV6)
2684 return -ENOMSG;
2685
2686 ret = ipv6_mc_check_icmpv6(skb);
2687 if (ret < 0)
2688 return ret;
2689
2690 if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV)
2691 return -ENOMSG;
2692
2693 br_multicast_mark_router(br, port);
2694
2695 return 0;
2696}
2697
08b202b6
YH		 2698static int br_multicast_ipv6_rcv(struct net_bridge *br,
2699 struct net_bridge_port *port,
06499098
VY		 2700 struct sk_buff *skb,
2701 u16 vid)
08b202b6 2702{
6db6f0ea 2703 const unsigned char *src;
9afd85c9 2704 struct mld_msg *mld;
08b202b6
YH		 2705 int err;
2706
ba5ea614 2707 err = ipv6_mc_check_mld(skb);
08b202b6 2708
9afd85c9
LL		 2709 if (err == -ENOMSG) {
2710 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr))
2711 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
4b3087c7
LL		 2712
2713 if (ipv6_addr_is_all_snoopers(&ipv6_hdr(skb)->daddr)) {
2714 err = br_ip6_multicast_mrd_rcv(br, port, skb);
2715
2716 if (err < 0 && err != -ENOMSG) {
2717 br_multicast_err_count(br, port, skb->protocol);
2718 return err;
2719 }
2720 }
2721
08b202b6 2722 return 0;
9afd85c9 2723 } else if (err < 0) {
1080ab95 2724 br_multicast_err_count(br, port, skb->protocol);
9afd85c9 2725 return err;
08b202b6
YH		 2726 }
2727
9afd85c9 2728 mld = (struct mld_msg *)skb_transport_header(skb);
1080ab95 2729 BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type;
08b202b6 2730
9afd85c9 2731 switch (mld->mld_type) {
08b202b6 2732 case ICMPV6_MGM_REPORT:
6db6f0ea 2733 src = eth_hdr(skb)->h_source;
fc2af6c7 2734 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
6db6f0ea 2735 err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid,
8b671779 2736 src, true);
08b202b6 2737 break;
08b202b6 2738 case ICMPV6_MLD2_REPORT:
ba5ea614 2739 err = br_ip6_multicast_mld2_report(br, port, skb, vid);
08b202b6
YH		 2740 break;
2741 case ICMPV6_MGM_QUERY:
ba5ea614 2742 err = br_ip6_multicast_query(br, port, skb, vid);
08b202b6
YH		 2743 break;
2744 case ICMPV6_MGM_REDUCTION:
6db6f0ea
FF		 2745 src = eth_hdr(skb)->h_source;
2746 br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid, src);
9afd85c9 2747 break;
08b202b6
YH		 2748 }
2749
a65056ec 2750 br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
1080ab95
NA		 2751 BR_MCAST_DIR_RX);
2752
08b202b6
YH		 2753 return err;
2754}
2755#endif
2756
eb1d1641 2757int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
06499098 2758 struct sk_buff *skb, u16 vid)
eb1d1641 2759{
1080ab95
NA		 2760 int ret = 0;
2761
1fafc7a9
YH		 2762 BR_INPUT_SKB_CB(skb)->igmp = 0;
2763 BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
2764
13cefad2 2765 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
eb1d1641
HX		 2766 return 0;
2767
2768 switch (skb->protocol) {
2769 case htons(ETH_P_IP):
1080ab95
NA		 2770 ret = br_multicast_ipv4_rcv(br, port, skb, vid);
2771 break;
dfd56b8b 2772#if IS_ENABLED(CONFIG_IPV6)
08b202b6 2773 case htons(ETH_P_IPV6):
1080ab95
NA		 2774 ret = br_multicast_ipv6_rcv(br, port, skb, vid);
2775 break;
08b202b6 2776#endif
eb1d1641
HX		 2777 }
2778
1080ab95 2779 return ret;
eb1d1641
HX		 2780}
2781
cc0fdd80 2782static void br_multicast_query_expired(struct net_bridge *br,
2cd41431
LL		 2783 struct bridge_mcast_own_query *query,
2784 struct bridge_mcast_querier *querier)
cc0fdd80
LL		 2785{
2786 spin_lock(&br->multicast_lock);
2787 if (query->startup_sent < br->multicast_startup_query_count)
2788 query->startup_sent++;
2789
71d9f614 2790 RCU_INIT_POINTER(querier->port, NULL);
cc0fdd80
LL		 2791 br_multicast_send_query(br, NULL, query);
2792 spin_unlock(&br->multicast_lock);
2793}
2794
88c1f37f 2795static void br_ip4_multicast_query_expired(struct timer_list *t)
eb1d1641 2796{
88c1f37f 2797 struct net_bridge *br = from_timer(br, t, ip4_own_query.timer);
eb1d1641 2798
2cd41431 2799 br_multicast_query_expired(br, &br->ip4_own_query, &br->ip4_querier);
cc0fdd80 2800}
eb1d1641 2801
cc0fdd80 2802#if IS_ENABLED(CONFIG_IPV6)
88c1f37f 2803static void br_ip6_multicast_query_expired(struct timer_list *t)
cc0fdd80 2804{
88c1f37f 2805 struct net_bridge *br = from_timer(br, t, ip6_own_query.timer);
eb1d1641 2806
2cd41431 2807 br_multicast_query_expired(br, &br->ip6_own_query, &br->ip6_querier);
eb1d1641 2808}
cc0fdd80 2809#endif
eb1d1641 2810
e12cec65 2811static void br_multicast_gc_work(struct work_struct *work)
8b671779
NA		 2812{
2813 struct net_bridge *br = container_of(work, struct net_bridge,
e12cec65 2814 mcast_gc_work);
8b671779
NA		 2815 HLIST_HEAD(deleted_head);
2816
2817 spin_lock_bh(&br->multicast_lock);
e12cec65 2818 hlist_move_list(&br->mcast_gc_list, &deleted_head);
8b671779
NA		 2819 spin_unlock_bh(&br->multicast_lock);
2820
e12cec65 2821 br_multicast_gc(&deleted_head);
8b671779
NA		 2822}
2823
eb1d1641
HX		 2824void br_multicast_init(struct net_bridge *br)
2825{
d08c6bc0 2826 br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX;
eb1d1641 2827
7f0aec7a 2828 br->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
eb1d1641
HX		 2829 br->multicast_last_member_count = 2;
2830 br->multicast_startup_query_count = 2;
2831
2832 br->multicast_last_member_interval = HZ;
2833 br->multicast_query_response_interval = 10 * HZ;
2834 br->multicast_startup_query_interval = 125 * HZ / 4;
2835 br->multicast_query_interval = 125 * HZ;
2836 br->multicast_querier_interval = 255 * HZ;
2837 br->multicast_membership_interval = 260 * HZ;
2838
90010b36 2839 br->ip4_other_query.delay_time = 0;
2cd41431 2840 br->ip4_querier.port = NULL;
aa2ae3e7 2841 br->multicast_igmp_version = 2;
cc0fdd80 2842#if IS_ENABLED(CONFIG_IPV6)
aa2ae3e7 2843 br->multicast_mld_version = 1;
90010b36 2844 br->ip6_other_query.delay_time = 0;
2cd41431 2845 br->ip6_querier.port = NULL;
cc0fdd80 2846#endif
6919622a 2847 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true);
675779ad 2848 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
b00589af 2849
eb1d1641 2850 spin_lock_init(&br->multicast_lock);
88c1f37f
AP		 2851 timer_setup(&br->multicast_router_timer,
2852 br_multicast_local_router_expired, 0);
2853 timer_setup(&br->ip4_other_query.timer,
2854 br_ip4_multicast_querier_expired, 0);
2855 timer_setup(&br->ip4_own_query.timer,
2856 br_ip4_multicast_query_expired, 0);
cc0fdd80 2857#if IS_ENABLED(CONFIG_IPV6)
88c1f37f
AP		 2858 timer_setup(&br->ip6_other_query.timer,
2859 br_ip6_multicast_querier_expired, 0);
2860 timer_setup(&br->ip6_own_query.timer,
2861 br_ip6_multicast_query_expired, 0);
cc0fdd80 2862#endif
19e3a9c9 2863 INIT_HLIST_HEAD(&br->mdb_list);
e12cec65
NA		 2864 INIT_HLIST_HEAD(&br->mcast_gc_list);
2865 INIT_WORK(&br->mcast_gc_work, br_multicast_gc_work);
eb1d1641
HX		 2866}
2867
4effd28c
LL		 2868static void br_ip4_multicast_join_snoopers(struct net_bridge *br)
2869{
2870 struct in_device *in_dev = in_dev_get(br->dev);
2871
2872 if (!in_dev)
2873 return;
2874
9fb20801 2875 __ip_mc_inc_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC);
4effd28c
LL		 2876 in_dev_put(in_dev);
2877}
2878
2879#if IS_ENABLED(CONFIG_IPV6)
2880static void br_ip6_multicast_join_snoopers(struct net_bridge *br)
2881{
2882 struct in6_addr addr;
2883
2884 ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a));
2885 ipv6_dev_mc_inc(br->dev, &addr);
2886}
2887#else
2888static inline void br_ip6_multicast_join_snoopers(struct net_bridge *br)
2889{
2890}
2891#endif
2892
2893static void br_multicast_join_snoopers(struct net_bridge *br)
2894{
2895 br_ip4_multicast_join_snoopers(br);
2896 br_ip6_multicast_join_snoopers(br);
2897}
2898
2899static void br_ip4_multicast_leave_snoopers(struct net_bridge *br)
2900{
2901 struct in_device *in_dev = in_dev_get(br->dev);
2902
2903 if (WARN_ON(!in_dev))
2904 return;
2905
9fb20801 2906 __ip_mc_dec_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC);
4effd28c
LL		 2907 in_dev_put(in_dev);
2908}
2909
2910#if IS_ENABLED(CONFIG_IPV6)
2911static void br_ip6_multicast_leave_snoopers(struct net_bridge *br)
2912{
2913 struct in6_addr addr;
2914
2915 ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a));
2916 ipv6_dev_mc_dec(br->dev, &addr);
2917}
2918#else
2919static inline void br_ip6_multicast_leave_snoopers(struct net_bridge *br)
2920{
2921}
2922#endif
2923
2924static void br_multicast_leave_snoopers(struct net_bridge *br)
2925{
2926 br_ip4_multicast_leave_snoopers(br);
2927 br_ip6_multicast_leave_snoopers(br);
2928}
2929
cc0fdd80 2930static void __br_multicast_open(struct net_bridge *br,
90010b36 2931 struct bridge_mcast_own_query *query)
eb1d1641 2932{
cc0fdd80 2933 query->startup_sent = 0;
eb1d1641 2934
13cefad2 2935 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
eb1d1641
HX		 2936 return;
2937
cc0fdd80
LL		 2938 mod_timer(&query->timer, jiffies);
2939}
2940
2941void br_multicast_open(struct net_bridge *br)
2942{
4effd28c
LL		 2943 if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
2944 br_multicast_join_snoopers(br);
2945
90010b36 2946 __br_multicast_open(br, &br->ip4_own_query);
cc0fdd80 2947#if IS_ENABLED(CONFIG_IPV6)
90010b36 2948 __br_multicast_open(br, &br->ip6_own_query);
cc0fdd80 2949#endif
eb1d1641
HX		 2950}
2951
2952void br_multicast_stop(struct net_bridge *br)
2953{
eb1d1641 2954 del_timer_sync(&br->multicast_router_timer);
90010b36
LL		 2955 del_timer_sync(&br->ip4_other_query.timer);
2956 del_timer_sync(&br->ip4_own_query.timer);
cc0fdd80 2957#if IS_ENABLED(CONFIG_IPV6)
90010b36
LL		 2958 del_timer_sync(&br->ip6_other_query.timer);
2959 del_timer_sync(&br->ip6_own_query.timer);
cc0fdd80 2960#endif
4effd28c
LL		 2961
2962 if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
2963 br_multicast_leave_snoopers(br);
e10177ab
SA		 2964}
2965
2966void br_multicast_dev_del(struct net_bridge *br)
2967{
e10177ab 2968 struct net_bridge_mdb_entry *mp;
8b671779 2969 HLIST_HEAD(deleted_head);
19e3a9c9 2970 struct hlist_node *tmp;
eb1d1641
HX		 2971
2972 spin_lock_bh(&br->multicast_lock);
e12cec65
NA		 2973 hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node)
2974 br_multicast_del_mdb_entry(mp);
2975 hlist_move_list(&br->mcast_gc_list, &deleted_head);
eb1d1641 2976 spin_unlock_bh(&br->multicast_lock);
19e3a9c9 2977
e12cec65
NA		 2978 br_multicast_gc(&deleted_head);
2979 cancel_work_sync(&br->mcast_gc_work);
8b671779 2980
4329596c 2981 rcu_barrier();
eb1d1641 2982}
0909e117
HX		 2983
2984int br_multicast_set_router(struct net_bridge *br, unsigned long val)
2985{
6ae4ae8e 2986 int err = -EINVAL;
0909e117
HX		 2987
2988 spin_lock_bh(&br->multicast_lock);
0909e117
HX		 2989
2990 switch (val) {
7f0aec7a
NA		 2991 case MDB_RTR_TYPE_DISABLED:
2992 case MDB_RTR_TYPE_PERM:
77041420 2993 br_mc_router_state_change(br, val == MDB_RTR_TYPE_PERM);
0909e117 2994 del_timer(&br->multicast_router_timer);
77041420
YG		 2995 br->multicast_router = val;
2996 err = 0;
2997 break;
7f0aec7a 2998 case MDB_RTR_TYPE_TEMP_QUERY:
77041420
YG		 2999 if (br->multicast_router != MDB_RTR_TYPE_TEMP_QUERY)
3000 br_mc_router_state_change(br, false);
0909e117
HX		 3001 br->multicast_router = val;
3002 err = 0;
3003 break;
0909e117
HX		 3004 }
3005
0909e117
HX		 3006 spin_unlock_bh(&br->multicast_lock);
3007
3008 return err;
3009}
3010
7f0aec7a
NA		 3011static void __del_port_router(struct net_bridge_port *p)
3012{
3013 if (hlist_unhashed(&p->rlist))
3014 return;
3015 hlist_del_init_rcu(&p->rlist);
3016 br_rtr_notify(p->br->dev, p, RTM_DELMDB);
6d549648 3017 br_port_mc_router_state_change(p, false);
f12e7d95
NF		 3018
3019 /* don't allow timer refresh */
3020 if (p->multicast_router == MDB_RTR_TYPE_TEMP)
3021 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
7f0aec7a
NA		 3022}
3023
0909e117
HX		 3024int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val)
3025{
3026 struct net_bridge *br = p->br;
a55d8246 3027 unsigned long now = jiffies;
6ae4ae8e 3028 int err = -EINVAL;
0909e117
HX		 3029
3030 spin_lock(&br->multicast_lock);
4950cfd1 3031 if (p->multicast_router == val) {
a55d8246
NA		 3032 /* Refresh the temp router port timer */
3033 if (p->multicast_router == MDB_RTR_TYPE_TEMP)
3034 mod_timer(&p->multicast_router_timer,
3035 now + br->multicast_querier_interval);
4950cfd1
NA		 3036 err = 0;
3037 goto unlock;
3038 }
0909e117 3039 switch (val) {
7f0aec7a
NA		 3040 case MDB_RTR_TYPE_DISABLED:
3041 p->multicast_router = MDB_RTR_TYPE_DISABLED;
3042 __del_port_router(p);
3043 del_timer(&p->multicast_router_timer);
3044 break;
3045 case MDB_RTR_TYPE_TEMP_QUERY:
3046 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
3047 __del_port_router(p);
3048 break;
3049 case MDB_RTR_TYPE_PERM:
3050 p->multicast_router = MDB_RTR_TYPE_PERM;
0909e117 3051 del_timer(&p->multicast_router_timer);
0909e117
HX		 3052 br_multicast_add_router(br, p);
3053 break;
a55d8246
NA		 3054 case MDB_RTR_TYPE_TEMP:
3055 p->multicast_router = MDB_RTR_TYPE_TEMP;
3056 br_multicast_mark_router(br, p);
3057 break;
7f0aec7a
NA		 3058 default:
3059 goto unlock;
0909e117 3060 }
7f0aec7a
NA		 3061 err = 0;
3062unlock:
0909e117
HX		 3063 spin_unlock(&br->multicast_lock);
3064
3065 return err;
3066}
561f1103 3067
cc0fdd80 3068static void br_multicast_start_querier(struct net_bridge *br,
90010b36 3069 struct bridge_mcast_own_query *query)
561f1103
HX		 3070{
3071 struct net_bridge_port *port;
74857216 3072
cc0fdd80 3073 __br_multicast_open(br, query);
74857216 3074
c5b493ce
NA		 3075 rcu_read_lock();
3076 list_for_each_entry_rcu(port, &br->port_list, list) {
74857216
HX		 3077 if (port->state == BR_STATE_DISABLED ||
3078 port->state == BR_STATE_BLOCKING)
3079 continue;
3080
90010b36
LL		 3081 if (query == &br->ip4_own_query)
3082 br_multicast_enable(&port->ip4_own_query);
cc0fdd80
LL		 3083#if IS_ENABLED(CONFIG_IPV6)
3084 else
90010b36 3085 br_multicast_enable(&port->ip6_own_query);
cc0fdd80 3086#endif
74857216 3087 }
c5b493ce 3088 rcu_read_unlock();
74857216
HX		 3089}
3090
3091int br_multicast_toggle(struct net_bridge *br, unsigned long val)
3092{
7cb3f921 3093 struct net_bridge_port *port;
561f1103 3094
ef5e0d82 3095 spin_lock_bh(&br->multicast_lock);
13cefad2 3096 if (!!br_opt_get(br, BROPT_MULTICAST_ENABLED) == !!val)
561f1103
HX		 3097 goto unlock;
3098
13cefad2
NA		 3099 br_mc_disabled_update(br->dev, val);
3100 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, !!val);
4effd28c
LL		 3101 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) {
3102 br_multicast_leave_snoopers(br);
561f1103 3103 goto unlock;
4effd28c 3104 }
561f1103 3105
3a7fda06
HX		 3106 if (!netif_running(br->dev))
3107 goto unlock;
3108
7cb3f921
NA		 3109 br_multicast_open(br);
3110 list_for_each_entry(port, &br->port_list, list)
3111 __br_multicast_enable_port(port);
561f1103
HX		 3112
3113unlock:
ef5e0d82 3114 spin_unlock_bh(&br->multicast_lock);
561f1103 3115
a26d94bf 3116 return 0;
561f1103 3117}
b195167f 3118
9341b988
IS		 3119bool br_multicast_enabled(const struct net_device *dev)
3120{
3121 struct net_bridge *br = netdev_priv(dev);
3122
13cefad2 3123 return !!br_opt_get(br, BROPT_MULTICAST_ENABLED);
9341b988
IS		 3124}
3125EXPORT_SYMBOL_GPL(br_multicast_enabled);
3126
0912bda4
YG		 3127bool br_multicast_router(const struct net_device *dev)
3128{
3129 struct net_bridge *br = netdev_priv(dev);
3130 bool is_router;
3131
3132 spin_lock_bh(&br->multicast_lock);
3133 is_router = br_multicast_is_router(br);
3134 spin_unlock_bh(&br->multicast_lock);
3135 return is_router;
3136}
3137EXPORT_SYMBOL_GPL(br_multicast_router);
3138
c5c23260
HX		 3139int br_multicast_set_querier(struct net_bridge *br, unsigned long val)
3140{
b00589af
LL		 3141 unsigned long max_delay;
3142
c5c23260
HX		 3143 val = !!val;
3144
3145 spin_lock_bh(&br->multicast_lock);
675779ad 3146 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) == val)
c5c23260
HX		 3147 goto unlock;
3148
675779ad 3149 br_opt_toggle(br, BROPT_MULTICAST_QUERIER, !!val);
b00589af
LL		 3150 if (!val)
3151 goto unlock;
3152
3153 max_delay = br->multicast_query_response_interval;
b00589af 3154
90010b36
LL		 3155 if (!timer_pending(&br->ip4_other_query.timer))
3156 br->ip4_other_query.delay_time = jiffies + max_delay;
cc0fdd80 3157
90010b36 3158 br_multicast_start_querier(br, &br->ip4_own_query);
cc0fdd80
LL		 3159
3160#if IS_ENABLED(CONFIG_IPV6)
90010b36
LL		 3161 if (!timer_pending(&br->ip6_other_query.timer))
3162 br->ip6_other_query.delay_time = jiffies + max_delay;
cc0fdd80 3163
90010b36 3164 br_multicast_start_querier(br, &br->ip6_own_query);
cc0fdd80 3165#endif
c5c23260
HX		 3166
3167unlock:
3168 spin_unlock_bh(&br->multicast_lock);
3169
3170 return 0;
3171}
3172
5e923585
NA		 3173int br_multicast_set_igmp_version(struct net_bridge *br, unsigned long val)
3174{
3175 /* Currently we support only version 2 and 3 */
3176 switch (val) {
3177 case 2:
3178 case 3:
3179 break;
3180 default:
3181 return -EINVAL;
3182 }
3183
3184 spin_lock_bh(&br->multicast_lock);
3185 br->multicast_igmp_version = val;
3186 spin_unlock_bh(&br->multicast_lock);
3187
3188 return 0;
3189}
3190
aa2ae3e7
NA		 3191#if IS_ENABLED(CONFIG_IPV6)
3192int br_multicast_set_mld_version(struct net_bridge *br, unsigned long val)
3193{
3194 /* Currently we support version 1 and 2 */
3195 switch (val) {
3196 case 1:
3197 case 2:
3198 break;
3199 default:
3200 return -EINVAL;
3201 }
3202
3203 spin_lock_bh(&br->multicast_lock);
3204 br->multicast_mld_version = val;
3205 spin_unlock_bh(&br->multicast_lock);
3206
3207 return 0;
3208}
3209#endif
3210
07f8ac4a
LL		 3211/**
3212 * br_multicast_list_adjacent - Returns snooped multicast addresses
3213 * @dev: The bridge port adjacent to which to retrieve addresses
3214 * @br_ip_list: The list to store found, snooped multicast IP addresses in
3215 *
3216 * Creates a list of IP addresses (struct br_ip_list) sensed by the multicast
3217 * snooping feature on all bridge ports of dev's bridge device, excluding
3218 * the addresses from dev itself.
3219 *
3220 * Returns the number of items added to br_ip_list.
3221 *
3222 * Notes:
3223 * - br_ip_list needs to be initialized by caller
3224 * - br_ip_list might contain duplicates in the end
3225 * (needs to be taken care of by caller)
3226 * - br_ip_list needs to be freed by caller
3227 */
3228int br_multicast_list_adjacent(struct net_device *dev,
3229 struct list_head *br_ip_list)
3230{
3231 struct net_bridge *br;
3232 struct net_bridge_port *port;
3233 struct net_bridge_port_group *group;
3234 struct br_ip_list *entry;
3235 int count = 0;
3236
3237 rcu_read_lock();
35f861e3 3238 if (!br_ip_list || !netif_is_bridge_port(dev))
07f8ac4a
LL		 3239 goto unlock;
3240
3241 port = br_port_get_rcu(dev);
3242 if (!port || !port->br)
3243 goto unlock;
3244
3245 br = port->br;
3246
3247 list_for_each_entry_rcu(port, &br->port_list, list) {
3248 if (!port->dev || port->dev == dev)
3249 continue;
3250
3251 hlist_for_each_entry_rcu(group, &port->mglist, mglist) {
3252 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
3253 if (!entry)
3254 goto unlock;
3255
3256 entry->addr = group->addr;
3257 list_add(&entry->list, br_ip_list);
3258 count++;
3259 }
3260 }
3261
3262unlock:
3263 rcu_read_unlock();
3264 return count;
3265}
3266EXPORT_SYMBOL_GPL(br_multicast_list_adjacent);
2cd41431 3267
c34963e2
LL		 3268/**
3269 * br_multicast_has_querier_anywhere - Checks for a querier on a bridge
3270 * @dev: The bridge port providing the bridge on which to check for a querier
3271 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
3272 *
3273 * Checks whether the given interface has a bridge on top and if so returns
3274 * true if a valid querier exists anywhere on the bridged link layer.
3275 * Otherwise returns false.
3276 */
3277bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto)
3278{
3279 struct net_bridge *br;
3280 struct net_bridge_port *port;
3281 struct ethhdr eth;
3282 bool ret = false;
3283
3284 rcu_read_lock();
35f861e3 3285 if (!netif_is_bridge_port(dev))
c34963e2
LL		 3286 goto unlock;
3287
3288 port = br_port_get_rcu(dev);
3289 if (!port || !port->br)
3290 goto unlock;
3291
3292 br = port->br;
3293
3294 memset(&eth, 0, sizeof(eth));
3295 eth.h_proto = htons(proto);
3296
3297 ret = br_multicast_querier_exists(br, &eth);
3298
3299unlock:
3300 rcu_read_unlock();
3301 return ret;
3302}
3303EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere);
3304
2cd41431
LL		 3305/**
3306 * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
3307 * @dev: The bridge port adjacent to which to check for a querier
3308 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
3309 *
3310 * Checks whether the given interface has a bridge on top and if so returns
3311 * true if a selected querier is behind one of the other ports of this
3312 * bridge. Otherwise returns false.
3313 */
3314bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto)
3315{
3316 struct net_bridge *br;
3317 struct net_bridge_port *port;
3318 bool ret = false;
3319
3320 rcu_read_lock();
35f861e3 3321 if (!netif_is_bridge_port(dev))
2cd41431
LL		 3322 goto unlock;
3323
3324 port = br_port_get_rcu(dev);
3325 if (!port || !port->br)
3326 goto unlock;
3327
3328 br = port->br;
3329
3330 switch (proto) {
3331 case ETH_P_IP:
3332 if (!timer_pending(&br->ip4_other_query.timer) ||
3333 rcu_dereference(br->ip4_querier.port) == port)
3334 goto unlock;
3335 break;
3993c4e1 3336#if IS_ENABLED(CONFIG_IPV6)
2cd41431
LL		 3337 case ETH_P_IPV6:
3338 if (!timer_pending(&br->ip6_other_query.timer) ||
3339 rcu_dereference(br->ip6_querier.port) == port)
3340 goto unlock;
3341 break;
3993c4e1 3342#endif
2cd41431
LL		 3343 default:
3344 goto unlock;
3345 }
3346
3347 ret = true;
3348unlock:
3349 rcu_read_unlock();
3350 return ret;
3351}
3352EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent);
1080ab95
NA		 3353
3354static void br_mcast_stats_add(struct bridge_mcast_stats __percpu *stats,
a65056ec 3355 const struct sk_buff *skb, u8 type, u8 dir)
1080ab95
NA		 3356{
3357 struct bridge_mcast_stats *pstats = this_cpu_ptr(stats);
a65056ec
NA		 3358 __be16 proto = skb->protocol;
3359 unsigned int t_len;
1080ab95
NA		 3360
3361 u64_stats_update_begin(&pstats->syncp);
3362 switch (proto) {
3363 case htons(ETH_P_IP):
a65056ec 3364 t_len = ntohs(ip_hdr(skb)->tot_len) - ip_hdrlen(skb);
1080ab95
NA		 3365 switch (type) {
3366 case IGMP_HOST_MEMBERSHIP_REPORT:
3367 pstats->mstats.igmp_v1reports[dir]++;
3368 break;
3369 case IGMPV2_HOST_MEMBERSHIP_REPORT:
3370 pstats->mstats.igmp_v2reports[dir]++;
3371 break;
3372 case IGMPV3_HOST_MEMBERSHIP_REPORT:
3373 pstats->mstats.igmp_v3reports[dir]++;
3374 break;
3375 case IGMP_HOST_MEMBERSHIP_QUERY:
a65056ec
NA		 3376 if (t_len != sizeof(struct igmphdr)) {
3377 pstats->mstats.igmp_v3queries[dir]++;
3378 } else {
3379 unsigned int offset = skb_transport_offset(skb);
3380 struct igmphdr *ih, _ihdr;
3381
3382 ih = skb_header_pointer(skb, offset,
3383 sizeof(_ihdr), &_ihdr);
3384 if (!ih)
3385 break;
3386 if (!ih->code)
3387 pstats->mstats.igmp_v1queries[dir]++;
3388 else
3389 pstats->mstats.igmp_v2queries[dir]++;
3390 }
1080ab95
NA		 3391 break;
3392 case IGMP_HOST_LEAVE_MESSAGE:
3393 pstats->mstats.igmp_leaves[dir]++;
3394 break;
3395 }
3396 break;
3397#if IS_ENABLED(CONFIG_IPV6)
3398 case htons(ETH_P_IPV6):
a65056ec
NA		 3399 t_len = ntohs(ipv6_hdr(skb)->payload_len) +
3400 sizeof(struct ipv6hdr);
3401 t_len -= skb_network_header_len(skb);
1080ab95
NA		 3402 switch (type) {
3403 case ICMPV6_MGM_REPORT:
3404 pstats->mstats.mld_v1reports[dir]++;
3405 break;
3406 case ICMPV6_MLD2_REPORT:
3407 pstats->mstats.mld_v2reports[dir]++;
3408 break;
3409 case ICMPV6_MGM_QUERY:
a65056ec
NA		 3410 if (t_len != sizeof(struct mld_msg))
3411 pstats->mstats.mld_v2queries[dir]++;
3412 else
3413 pstats->mstats.mld_v1queries[dir]++;
1080ab95
NA		 3414 break;
3415 case ICMPV6_MGM_REDUCTION:
3416 pstats->mstats.mld_leaves[dir]++;
3417 break;
3418 }
3419 break;
3420#endif /* CONFIG_IPV6 */
3421 }
3422 u64_stats_update_end(&pstats->syncp);
3423}
3424
3425void br_multicast_count(struct net_bridge *br, const struct net_bridge_port *p,
a65056ec 3426 const struct sk_buff *skb, u8 type, u8 dir)
1080ab95
NA		 3427{
3428 struct bridge_mcast_stats __percpu *stats;
3429
3430 /* if multicast_disabled is true then igmp type can't be set */
675779ad 3431 if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
1080ab95
NA		 3432 return;
3433
3434 if (p)
3435 stats = p->mcast_stats;
3436 else
3437 stats = br->mcast_stats;
3438 if (WARN_ON(!stats))
3439 return;
3440
a65056ec 3441 br_mcast_stats_add(stats, skb, type, dir);
1080ab95
NA		 3442}
3443
3444int br_multicast_init_stats(struct net_bridge *br)
3445{
3446 br->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
3447 if (!br->mcast_stats)
3448 return -ENOMEM;
3449
3450 return 0;
3451}
3452
b6fe0440
IS		 3453void br_multicast_uninit_stats(struct net_bridge *br)
3454{
3455 free_percpu(br->mcast_stats);
3456}
3457
b3b6a84c
AB		 3458/* noinline for https://bugs.llvm.org/show_bug.cgi?id=45802#c9 */
3459static noinline_for_stack void mcast_stats_add_dir(u64 *dst, u64 *src)
1080ab95
NA		 3460{
3461 dst[BR_MCAST_DIR_RX] += src[BR_MCAST_DIR_RX];
3462 dst[BR_MCAST_DIR_TX] += src[BR_MCAST_DIR_TX];
3463}
3464
3465void br_multicast_get_stats(const struct net_bridge *br,
3466 const struct net_bridge_port *p,
3467 struct br_mcast_stats *dest)
3468{
3469 struct bridge_mcast_stats __percpu *stats;
3470 struct br_mcast_stats tdst;
3471 int i;
3472
3473 memset(dest, 0, sizeof(*dest));
3474 if (p)
3475 stats = p->mcast_stats;
3476 else
3477 stats = br->mcast_stats;
3478 if (WARN_ON(!stats))
3479 return;
3480
3481 memset(&tdst, 0, sizeof(tdst));
3482 for_each_possible_cpu(i) {
3483 struct bridge_mcast_stats *cpu_stats = per_cpu_ptr(stats, i);
3484 struct br_mcast_stats temp;
3485 unsigned int start;
3486
3487 do {
3488 start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
3489 memcpy(&temp, &cpu_stats->mstats, sizeof(temp));
3490 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
3491
a65056ec
NA		 3492 mcast_stats_add_dir(tdst.igmp_v1queries, temp.igmp_v1queries);
3493 mcast_stats_add_dir(tdst.igmp_v2queries, temp.igmp_v2queries);
3494 mcast_stats_add_dir(tdst.igmp_v3queries, temp.igmp_v3queries);
1080ab95
NA		 3495 mcast_stats_add_dir(tdst.igmp_leaves, temp.igmp_leaves);
3496 mcast_stats_add_dir(tdst.igmp_v1reports, temp.igmp_v1reports);
3497 mcast_stats_add_dir(tdst.igmp_v2reports, temp.igmp_v2reports);
3498 mcast_stats_add_dir(tdst.igmp_v3reports, temp.igmp_v3reports);
3499 tdst.igmp_parse_errors += temp.igmp_parse_errors;
3500
a65056ec
NA		 3501 mcast_stats_add_dir(tdst.mld_v1queries, temp.mld_v1queries);
3502 mcast_stats_add_dir(tdst.mld_v2queries, temp.mld_v2queries);
1080ab95
NA		 3503 mcast_stats_add_dir(tdst.mld_leaves, temp.mld_leaves);
3504 mcast_stats_add_dir(tdst.mld_v1reports, temp.mld_v1reports);
3505 mcast_stats_add_dir(tdst.mld_v2reports, temp.mld_v2reports);
3506 tdst.mld_parse_errors += temp.mld_parse_errors;
3507 }
3508 memcpy(dest, &tdst, sizeof(*dest));
3509}
19e3a9c9
NA		 3510
3511int br_mdb_hash_init(struct net_bridge *br)
3512{
3513 return rhashtable_init(&br->mdb_hash_tbl, &br_mdb_rht_params);
3514}
3515
3516void br_mdb_hash_fini(struct net_bridge *br)
3517{
3518 rhashtable_destroy(&br->mdb_hash_tbl);
3519}
Linux 6.x block layer and io_uring tree(s)