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