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