projects/linux·blob master · refs

5340 lines · 141.6 KiB

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