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