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