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