]> git.ipfire.org Git - thirdparty/kernel/stable.git/blame - net/bridge/br_multicast.c
projects / thirdparty / kernel / stable.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bridge: simplify ip_mc_check_igmp() and ipv6_mc_check_mld() internals
[thirdparty/kernel/stable.git] / net / bridge / br_multicast.c
CommitLineData
eb1d1641
HX		 1/*
2 * Bridge multicast support.
3 *
4 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
9 * any later version.
10 *
11 */
12
13#include <linux/err.h>
07f8ac4a 14#include <linux/export.h>
eb1d1641
HX		 15#include <linux/if_ether.h>
16#include <linux/igmp.h>
17#include <linux/jhash.h>
18#include <linux/kernel.h>
b195167f 19#include <linux/log2.h>
eb1d1641
HX		 20#include <linux/netdevice.h>
21#include <linux/netfilter_bridge.h>
22#include <linux/random.h>
23#include <linux/rculist.h>
24#include <linux/skbuff.h>
25#include <linux/slab.h>
26#include <linux/timer.h>
1c8ad5bf 27#include <linux/inetdevice.h>
91b02d3d 28#include <linux/mroute.h>
eb1d1641 29#include <net/ip.h>
147c1e9b 30#include <net/switchdev.h>
dfd56b8b 31#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 32#include <net/ipv6.h>
33#include <net/mld.h>
d4c4f07d 34#include <net/ip6_checksum.h>
3c3769e6 35#include <net/addrconf.h>
08b202b6 36#endif
eb1d1641
HX		 37
38#include "br_private.h"
39
19e3a9c9
NA		 40static const struct rhashtable_params br_mdb_rht_params = {
41 .head_offset = offsetof(struct net_bridge_mdb_entry, rhnode),
42 .key_offset = offsetof(struct net_bridge_mdb_entry, addr),
43 .key_len = sizeof(struct br_ip),
44 .automatic_shrinking = true,
45 .locks_mul = 1,
46};
47
cc0fdd80 48static void br_multicast_start_querier(struct net_bridge *br,
90010b36 49 struct bridge_mcast_own_query *query);
754bc547
SA		 50static void br_multicast_add_router(struct net_bridge *br,
51 struct net_bridge_port *port);
bc8c20ac
SA		 52static void br_ip4_multicast_leave_group(struct net_bridge *br,
53 struct net_bridge_port *port,
54 __be32 group,
6db6f0ea
FF		 55 __u16 vid,
56 const unsigned char *src);
57
f12e7d95 58static void __del_port_router(struct net_bridge_port *p);
bc8c20ac
SA		 59#if IS_ENABLED(CONFIG_IPV6)
60static void br_ip6_multicast_leave_group(struct net_bridge *br,
61 struct net_bridge_port *port,
62 const struct in6_addr *group,
6db6f0ea 63 __u16 vid, const unsigned char *src);
bc8c20ac 64#endif
c83b8fab 65
8ef2a9a5
YH		 66static inline int br_ip_equal(const struct br_ip *a, const struct br_ip *b)
67{
68 if (a->proto != b->proto)
69 return 0;
b0e9a30d
VY		 70 if (a->vid != b->vid)
71 return 0;
8ef2a9a5
YH		 72 switch (a->proto) {
73 case htons(ETH_P_IP):
74 return a->u.ip4 == b->u.ip4;
dfd56b8b 75#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 76 case htons(ETH_P_IPV6):
77 return ipv6_addr_equal(&a->u.ip6, &b->u.ip6);
78#endif
8ef2a9a5
YH		 79 }
80 return 0;
81}
82
19e3a9c9
NA		 83static struct net_bridge_mdb_entry *br_mdb_ip_get_rcu(struct net_bridge *br,
84 struct br_ip *dst)
08b202b6 85{
19e3a9c9 86 return rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
08b202b6 87}
08b202b6 88
19e3a9c9
NA		 89struct net_bridge_mdb_entry *br_mdb_ip_get(struct net_bridge *br,
90 struct br_ip *dst)
eb1d1641 91{
19e3a9c9 92 struct net_bridge_mdb_entry *ent;
eb1d1641 93
19e3a9c9 94 lockdep_assert_held_once(&br->multicast_lock);
eb1d1641 95
19e3a9c9
NA		 96 rcu_read_lock();
97 ent = rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
98 rcu_read_unlock();
7f285fa7 99
19e3a9c9 100 return ent;
7f285fa7
HX		 101}
102
19e3a9c9
NA		 103static struct net_bridge_mdb_entry *br_mdb_ip4_get(struct net_bridge *br,
104 __be32 dst, __u16 vid)
eb1d1641 105{
8ef2a9a5
YH		 106 struct br_ip br_dst;
107
19e3a9c9 108 memset(&br_dst, 0, sizeof(br_dst));
8ef2a9a5
YH		 109 br_dst.u.ip4 = dst;
110 br_dst.proto = htons(ETH_P_IP);
b0e9a30d 111 br_dst.vid = vid;
0821ec55 112
19e3a9c9 113 return br_mdb_ip_get(br, &br_dst);
8ef2a9a5
YH		 114}
115
dfd56b8b 116#if IS_ENABLED(CONFIG_IPV6)
19e3a9c9
NA		 117static struct net_bridge_mdb_entry *br_mdb_ip6_get(struct net_bridge *br,
118 const struct in6_addr *dst,
119 __u16 vid)
08b202b6
YH		 120{
121 struct br_ip br_dst;
0821ec55 122
19e3a9c9 123 memset(&br_dst, 0, sizeof(br_dst));
4e3fd7a0 124 br_dst.u.ip6 = *dst;
08b202b6 125 br_dst.proto = htons(ETH_P_IPV6);
b0e9a30d 126 br_dst.vid = vid;
08b202b6 127
19e3a9c9 128 return br_mdb_ip_get(br, &br_dst);
08b202b6
YH		 129}
130#endif
131
eb1d1641 132struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
fbca58a2 133 struct sk_buff *skb, u16 vid)
eb1d1641 134{
8ef2a9a5
YH		 135 struct br_ip ip;
136
13cefad2 137 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
eb1d1641
HX		 138 return NULL;
139
8ef2a9a5 140 if (BR_INPUT_SKB_CB(skb)->igmp)
eb1d1641
HX		 141 return NULL;
142
19e3a9c9 143 memset(&ip, 0, sizeof(ip));
8ef2a9a5 144 ip.proto = skb->protocol;
fbca58a2 145 ip.vid = vid;
8ef2a9a5 146
eb1d1641
HX		 147 switch (skb->protocol) {
148 case htons(ETH_P_IP):
8ef2a9a5
YH		 149 ip.u.ip4 = ip_hdr(skb)->daddr;
150 break;
dfd56b8b 151#if IS_ENABLED(CONFIG_IPV6)
08b202b6 152 case htons(ETH_P_IPV6):
4e3fd7a0 153 ip.u.ip6 = ipv6_hdr(skb)->daddr;
08b202b6
YH		 154 break;
155#endif
8ef2a9a5
YH		 156 default:
157 return NULL;
eb1d1641
HX		 158 }
159
19e3a9c9 160 return br_mdb_ip_get_rcu(br, &ip);
eb1d1641
HX		 161}
162
88c1f37f 163static void br_multicast_group_expired(struct timer_list *t)
eb1d1641 164{
88c1f37f 165 struct net_bridge_mdb_entry *mp = from_timer(mp, t, timer);
eb1d1641 166 struct net_bridge *br = mp->br;
eb1d1641
HX		 167
168 spin_lock(&br->multicast_lock);
169 if (!netif_running(br->dev) || timer_pending(&mp->timer))
170 goto out;
171
ff0fd34e 172 mp->host_joined = false;
2a26028d 173 br_mdb_notify(br->dev, NULL, &mp->addr, RTM_DELMDB, 0);
eb1d1641
HX		 174
175 if (mp->ports)
176 goto out;
177
19e3a9c9
NA		 178 rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode,
179 br_mdb_rht_params);
180 hlist_del_rcu(&mp->mdb_node);
eb1d1641 181
4329596c 182 kfree_rcu(mp, rcu);
eb1d1641
HX		 183
184out:
185 spin_unlock(&br->multicast_lock);
186}
187
188static void br_multicast_del_pg(struct net_bridge *br,
189 struct net_bridge_port_group *pg)
190{
eb1d1641
HX		 191 struct net_bridge_mdb_entry *mp;
192 struct net_bridge_port_group *p;
e8051688
ED		 193 struct net_bridge_port_group __rcu **pp;
194
19e3a9c9 195 mp = br_mdb_ip_get(br, &pg->addr);
eb1d1641
HX		 196 if (WARN_ON(!mp))
197 return;
198
e8051688
ED		 199 for (pp = &mp->ports;
200 (p = mlock_dereference(*pp, br)) != NULL;
201 pp = &p->next) {
eb1d1641
HX		 202 if (p != pg)
203 continue;
204
83f6a740 205 rcu_assign_pointer(*pp, p->next);
eb1d1641
HX		 206 hlist_del_init(&p->mglist);
207 del_timer(&p->timer);
45ebcce5
ER		 208 br_mdb_notify(br->dev, p->port, &pg->addr, RTM_DELMDB,
209 p->flags);
4329596c 210 kfree_rcu(p, rcu);
eb1d1641 211
ff0fd34e 212 if (!mp->ports && !mp->host_joined &&
eb1d1641
HX		 213 netif_running(br->dev))
214 mod_timer(&mp->timer, jiffies);
215
216 return;
217 }
218
219 WARN_ON(1);
220}
221
88c1f37f 222static void br_multicast_port_group_expired(struct timer_list *t)
eb1d1641 223{
88c1f37f 224 struct net_bridge_port_group *pg = from_timer(pg, t, timer);
eb1d1641
HX		 225 struct net_bridge *br = pg->port->br;
226
227 spin_lock(&br->multicast_lock);
228 if (!netif_running(br->dev) || timer_pending(&pg->timer) ||
9d06b6d8 229 hlist_unhashed(&pg->mglist) || pg->flags & MDB_PG_FLAGS_PERMANENT)
eb1d1641
HX		 230 goto out;
231
232 br_multicast_del_pg(br, pg);
233
234out:
235 spin_unlock(&br->multicast_lock);
236}
237
8ef2a9a5 238static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br,
1080ab95
NA		 239 __be32 group,
240 u8 *igmp_type)
eb1d1641 241{
5e923585
NA		 242 struct igmpv3_query *ihv3;
243 size_t igmp_hdr_size;
eb1d1641
HX		 244 struct sk_buff *skb;
245 struct igmphdr *ih;
246 struct ethhdr *eth;
247 struct iphdr *iph;
248
5e923585
NA		 249 igmp_hdr_size = sizeof(*ih);
250 if (br->multicast_igmp_version == 3)
251 igmp_hdr_size = sizeof(*ihv3);
eb1d1641 252 skb = netdev_alloc_skb_ip_align(br->dev, sizeof(*eth) + sizeof(*iph) +
5e923585 253 igmp_hdr_size + 4);
eb1d1641
HX		 254 if (!skb)
255 goto out;
256
257 skb->protocol = htons(ETH_P_IP);
258
259 skb_reset_mac_header(skb);
260 eth = eth_hdr(skb);
261
e5a727f6 262 ether_addr_copy(eth->h_source, br->dev->dev_addr);
eb1d1641
HX		 263 eth->h_dest[0] = 1;
264 eth->h_dest[1] = 0;
265 eth->h_dest[2] = 0x5e;
266 eth->h_dest[3] = 0;
267 eth->h_dest[4] = 0;
268 eth->h_dest[5] = 1;
269 eth->h_proto = htons(ETH_P_IP);
270 skb_put(skb, sizeof(*eth));
271
272 skb_set_network_header(skb, skb->len);
273 iph = ip_hdr(skb);
274
275 iph->version = 4;
276 iph->ihl = 6;
277 iph->tos = 0xc0;
5e923585 278 iph->tot_len = htons(sizeof(*iph) + igmp_hdr_size + 4);
eb1d1641
HX		 279 iph->id = 0;
280 iph->frag_off = htons(IP_DF);
281 iph->ttl = 1;
282 iph->protocol = IPPROTO_IGMP;
675779ad 283 iph->saddr = br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR) ?
1c8ad5bf 284 inet_select_addr(br->dev, 0, RT_SCOPE_LINK) : 0;
eb1d1641
HX		 285 iph->daddr = htonl(INADDR_ALLHOSTS_GROUP);
286 ((u8 *)&iph[1])[0] = IPOPT_RA;
287 ((u8 *)&iph[1])[1] = 4;
288 ((u8 *)&iph[1])[2] = 0;
289 ((u8 *)&iph[1])[3] = 0;
290 ip_send_check(iph);
291 skb_put(skb, 24);
292
293 skb_set_transport_header(skb, skb->len);
1080ab95 294 *igmp_type = IGMP_HOST_MEMBERSHIP_QUERY;
eb1d1641 295
5e923585
NA		 296 switch (br->multicast_igmp_version) {
297 case 2:
298 ih = igmp_hdr(skb);
299 ih->type = IGMP_HOST_MEMBERSHIP_QUERY;
300 ih->code = (group ? br->multicast_last_member_interval :
301 br->multicast_query_response_interval) /
302 (HZ / IGMP_TIMER_SCALE);
303 ih->group = group;
304 ih->csum = 0;
305 ih->csum = ip_compute_csum((void *)ih, sizeof(*ih));
306 break;
307 case 3:
308 ihv3 = igmpv3_query_hdr(skb);
309 ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY;
310 ihv3->code = (group ? br->multicast_last_member_interval :
311 br->multicast_query_response_interval) /
312 (HZ / IGMP_TIMER_SCALE);
313 ihv3->group = group;
314 ihv3->qqic = br->multicast_query_interval / HZ;
315 ihv3->nsrcs = 0;
316 ihv3->resv = 0;
317 ihv3->suppress = 0;
318 ihv3->qrv = 2;
319 ihv3->csum = 0;
320 ihv3->csum = ip_compute_csum((void *)ihv3, sizeof(*ihv3));
321 break;
322 }
323
324 skb_put(skb, igmp_hdr_size);
eb1d1641
HX		 325 __skb_pull(skb, sizeof(*eth));
326
327out:
328 return skb;
329}
330
dfd56b8b 331#if IS_ENABLED(CONFIG_IPV6)
08b202b6 332static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br,
1080ab95
NA		 333 const struct in6_addr *grp,
334 u8 *igmp_type)
08b202b6 335{
aa2ae3e7
NA		 336 struct mld2_query *mld2q;
337 unsigned long interval;
08b202b6
YH		 338 struct ipv6hdr *ip6h;
339 struct mld_msg *mldq;
aa2ae3e7
NA		 340 size_t mld_hdr_size;
341 struct sk_buff *skb;
08b202b6
YH		 342 struct ethhdr *eth;
343 u8 *hopopt;
08b202b6 344
aa2ae3e7
NA		 345 mld_hdr_size = sizeof(*mldq);
346 if (br->multicast_mld_version == 2)
347 mld_hdr_size = sizeof(*mld2q);
08b202b6 348 skb = netdev_alloc_skb_ip_align(br->dev, sizeof(*eth) + sizeof(*ip6h) +
aa2ae3e7 349 8 + mld_hdr_size);
08b202b6
YH		 350 if (!skb)
351 goto out;
352
353 skb->protocol = htons(ETH_P_IPV6);
354
355 /* Ethernet header */
356 skb_reset_mac_header(skb);
357 eth = eth_hdr(skb);
358
e5a727f6 359 ether_addr_copy(eth->h_source, br->dev->dev_addr);
08b202b6
YH		 360 eth->h_proto = htons(ETH_P_IPV6);
361 skb_put(skb, sizeof(*eth));
362
363 /* IPv6 header + HbH option */
364 skb_set_network_header(skb, skb->len);
365 ip6h = ipv6_hdr(skb);
366
367 *(__force __be32 *)ip6h = htonl(0x60000000);
aa2ae3e7 368 ip6h->payload_len = htons(8 + mld_hdr_size);
08b202b6
YH		 369 ip6h->nexthdr = IPPROTO_HOPOPTS;
370 ip6h->hop_limit = 1;
a7bff75b 371 ipv6_addr_set(&ip6h->daddr, htonl(0xff020000), 0, 0, htonl(1));
d1d81d4c
UW		 372 if (ipv6_dev_get_saddr(dev_net(br->dev), br->dev, &ip6h->daddr, 0,
373 &ip6h->saddr)) {
374 kfree_skb(skb);
675779ad 375 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, false);
d1d81d4c
UW		 376 return NULL;
377 }
0888d5f3 378
675779ad 379 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
36cff5a1 380 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
08b202b6
YH		 381
382 hopopt = (u8 *)(ip6h + 1);
383 hopopt[0] = IPPROTO_ICMPV6; /* next hdr */
384 hopopt[1] = 0; /* length of HbH */
385 hopopt[2] = IPV6_TLV_ROUTERALERT; /* Router Alert */
386 hopopt[3] = 2; /* Length of RA Option */
387 hopopt[4] = 0; /* Type = 0x0000 (MLD) */
388 hopopt[5] = 0;
1de5a71c
EZ		 389 hopopt[6] = IPV6_TLV_PAD1; /* Pad1 */
390 hopopt[7] = IPV6_TLV_PAD1; /* Pad1 */
08b202b6
YH		 391
392 skb_put(skb, sizeof(*ip6h) + 8);
393
394 /* ICMPv6 */
395 skb_set_transport_header(skb, skb->len);
1080ab95 396 interval = ipv6_addr_any(grp) ?
32de868c
LL		 397 br->multicast_query_response_interval :
398 br->multicast_last_member_interval;
1080ab95 399 *igmp_type = ICMPV6_MGM_QUERY;
aa2ae3e7
NA		 400 switch (br->multicast_mld_version) {
401 case 1:
402 mldq = (struct mld_msg *)icmp6_hdr(skb);
403 mldq->mld_type = ICMPV6_MGM_QUERY;
404 mldq->mld_code = 0;
405 mldq->mld_cksum = 0;
406 mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval));
407 mldq->mld_reserved = 0;
408 mldq->mld_mca = *grp;
409 mldq->mld_cksum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
410 sizeof(*mldq), IPPROTO_ICMPV6,
411 csum_partial(mldq,
412 sizeof(*mldq),
413 0));
414 break;
415 case 2:
416 mld2q = (struct mld2_query *)icmp6_hdr(skb);
53631a5f 417 mld2q->mld2q_mrc = htons((u16)jiffies_to_msecs(interval));
aa2ae3e7
NA		 418 mld2q->mld2q_type = ICMPV6_MGM_QUERY;
419 mld2q->mld2q_code = 0;
420 mld2q->mld2q_cksum = 0;
421 mld2q->mld2q_resv1 = 0;
422 mld2q->mld2q_resv2 = 0;
423 mld2q->mld2q_suppress = 0;
424 mld2q->mld2q_qrv = 2;
425 mld2q->mld2q_nsrcs = 0;
426 mld2q->mld2q_qqic = br->multicast_query_interval / HZ;
427 mld2q->mld2q_mca = *grp;
428 mld2q->mld2q_cksum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
429 sizeof(*mld2q),
430 IPPROTO_ICMPV6,
431 csum_partial(mld2q,
432 sizeof(*mld2q),
433 0));
434 break;
435 }
436 skb_put(skb, mld_hdr_size);
08b202b6
YH		 437
438 __skb_pull(skb, sizeof(*eth));
439
440out:
441 return skb;
442}
443#endif
444
8ef2a9a5 445static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
1080ab95
NA		 446 struct br_ip *addr,
447 u8 *igmp_type)
8ef2a9a5
YH		 448{
449 switch (addr->proto) {
450 case htons(ETH_P_IP):
1080ab95 451 return br_ip4_multicast_alloc_query(br, addr->u.ip4, igmp_type);
dfd56b8b 452#if IS_ENABLED(CONFIG_IPV6)
08b202b6 453 case htons(ETH_P_IPV6):
1080ab95
NA		 454 return br_ip6_multicast_alloc_query(br, &addr->u.ip6,
455 igmp_type);
08b202b6 456#endif
8ef2a9a5
YH		 457 }
458 return NULL;
459}
460
cfd56754 461struct net_bridge_mdb_entry *br_multicast_new_group(struct net_bridge *br,
5e923585 462 struct br_ip *group)
eb1d1641 463{
eb1d1641 464 struct net_bridge_mdb_entry *mp;
4c0833bc 465 int err;
eb1d1641 466
19e3a9c9
NA		 467 mp = br_mdb_ip_get(br, group);
468 if (mp)
469 return mp;
eb1d1641 470
19e3a9c9
NA		 471 if (atomic_read(&br->mdb_hash_tbl.nelems) >= br->hash_max) {
472 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, false);
473 return ERR_PTR(-E2BIG);
eb1d1641
HX		 474 }
475
476 mp = kzalloc(sizeof(*mp), GFP_ATOMIC);
477 if (unlikely(!mp))
4c0833bc 478 return ERR_PTR(-ENOMEM);
eb1d1641
HX		 479
480 mp->br = br;
8ef2a9a5 481 mp->addr = *group;
88c1f37f 482 timer_setup(&mp->timer, br_multicast_group_expired, 0);
19e3a9c9
NA		 483 err = rhashtable_lookup_insert_fast(&br->mdb_hash_tbl, &mp->rhnode,
484 br_mdb_rht_params);
485 if (err) {
486 kfree(mp);
487 mp = ERR_PTR(err);
488 } else {
489 hlist_add_head_rcu(&mp->mdb_node, &br->mdb_list);
490 }
1faabf2a 491
eb1d1641
HX		 492 return mp;
493}
494
cfd56754
CW		 495struct net_bridge_port_group *br_multicast_new_port_group(
496 struct net_bridge_port *port,
497 struct br_ip *group,
ccb1c31a 498 struct net_bridge_port_group __rcu *next,
6db6f0ea
FF		 499 unsigned char flags,
500 const unsigned char *src)
cfd56754
CW		 501{
502 struct net_bridge_port_group *p;
503
504 p = kzalloc(sizeof(*p), GFP_ATOMIC);
505 if (unlikely(!p))
506 return NULL;
507
508 p->addr = *group;
509 p->port = port;
9d06b6d8 510 p->flags = flags;
eca2a43b 511 rcu_assign_pointer(p->next, next);
cfd56754 512 hlist_add_head(&p->mglist, &port->mglist);
88c1f37f 513 timer_setup(&p->timer, br_multicast_port_group_expired, 0);
6db6f0ea
FF		 514
515 if (src)
516 memcpy(p->eth_addr, src, ETH_ALEN);
517 else
518 memset(p->eth_addr, 0xff, ETH_ALEN);
519
cfd56754
CW		 520 return p;
521}
522
6db6f0ea
FF		 523static bool br_port_group_equal(struct net_bridge_port_group *p,
524 struct net_bridge_port *port,
525 const unsigned char *src)
526{
527 if (p->port != port)
528 return false;
529
530 if (!(port->flags & BR_MULTICAST_TO_UNICAST))
531 return true;
532
533 return ether_addr_equal(src, p->eth_addr);
534}
535
eb1d1641 536static int br_multicast_add_group(struct net_bridge *br,
8ef2a9a5 537 struct net_bridge_port *port,
6db6f0ea
FF		 538 struct br_ip *group,
539 const unsigned char *src)
eb1d1641 540{
e8051688 541 struct net_bridge_port_group __rcu **pp;
5e923585
NA		 542 struct net_bridge_port_group *p;
543 struct net_bridge_mdb_entry *mp;
454594f3 544 unsigned long now = jiffies;
eb1d1641
HX		 545 int err;
546
eb1d1641
HX		 547 spin_lock(&br->multicast_lock);
548 if (!netif_running(br->dev) ||
549 (port && port->state == BR_STATE_DISABLED))
550 goto out;
551
19e3a9c9 552 mp = br_multicast_new_group(br, group);
eb1d1641 553 err = PTR_ERR(mp);
4c0833bc 554 if (IS_ERR(mp))
eb1d1641
HX		 555 goto err;
556
557 if (!port) {
2a26028d
AL		 558 if (!mp->host_joined) {
559 mp->host_joined = true;
560 br_mdb_notify(br->dev, NULL, &mp->addr, RTM_NEWMDB, 0);
561 }
454594f3 562 mod_timer(&mp->timer, now + br->multicast_membership_interval);
eb1d1641
HX		 563 goto out;
564 }
565
e8051688
ED		 566 for (pp = &mp->ports;
567 (p = mlock_dereference(*pp, br)) != NULL;
568 pp = &p->next) {
6db6f0ea 569 if (br_port_group_equal(p, port, src))
454594f3 570 goto found;
eb1d1641
HX		 571 if ((unsigned long)p->port < (unsigned long)port)
572 break;
573 }
574
6db6f0ea 575 p = br_multicast_new_port_group(port, group, *pp, 0, src);
eb1d1641
HX		 576 if (unlikely(!p))
577 goto err;
eb1d1641 578 rcu_assign_pointer(*pp, p);
45ebcce5 579 br_mdb_notify(br->dev, port, group, RTM_NEWMDB, 0);
eb1d1641 580
454594f3
LL		 581found:
582 mod_timer(&p->timer, now + br->multicast_membership_interval);
eb1d1641
HX		 583out:
584 err = 0;
585
586err:
587 spin_unlock(&br->multicast_lock);
588 return err;
589}
590
8ef2a9a5
YH		 591static int br_ip4_multicast_add_group(struct net_bridge *br,
592 struct net_bridge_port *port,
b0e9a30d 593 __be32 group,
6db6f0ea
FF		 594 __u16 vid,
595 const unsigned char *src)
8ef2a9a5
YH		 596{
597 struct br_ip br_group;
598
599 if (ipv4_is_local_multicast(group))
600 return 0;
601
602 br_group.u.ip4 = group;
603 br_group.proto = htons(ETH_P_IP);
b0e9a30d 604 br_group.vid = vid;
8ef2a9a5 605
6db6f0ea 606 return br_multicast_add_group(br, port, &br_group, src);
8ef2a9a5
YH		 607}
608
dfd56b8b 609#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 610static int br_ip6_multicast_add_group(struct net_bridge *br,
611 struct net_bridge_port *port,
b0e9a30d 612 const struct in6_addr *group,
6db6f0ea
FF		 613 __u16 vid,
614 const unsigned char *src)
08b202b6
YH		 615{
616 struct br_ip br_group;
617
3c3769e6 618 if (ipv6_addr_is_ll_all_nodes(group))
08b202b6
YH		 619 return 0;
620
19e3a9c9 621 memset(&br_group, 0, sizeof(br_group));
4e3fd7a0 622 br_group.u.ip6 = *group;
9cc6e0c4 623 br_group.proto = htons(ETH_P_IPV6);
b0e9a30d 624 br_group.vid = vid;
08b202b6 625
6db6f0ea 626 return br_multicast_add_group(br, port, &br_group, src);
08b202b6
YH		 627}
628#endif
629
88c1f37f 630static void br_multicast_router_expired(struct timer_list *t)
eb1d1641 631{
88c1f37f
AP		 632 struct net_bridge_port *port =
633 from_timer(port, t, multicast_router_timer);
eb1d1641
HX		 634 struct net_bridge *br = port->br;
635
636 spin_lock(&br->multicast_lock);
a55d8246
NA		 637 if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
638 port->multicast_router == MDB_RTR_TYPE_PERM ||
f12e7d95 639 timer_pending(&port->multicast_router_timer))
eb1d1641
HX		 640 goto out;
641
f12e7d95 642 __del_port_router(port);
eb1d1641
HX		 643out:
644 spin_unlock(&br->multicast_lock);
645}
646
77041420
YG		 647static void br_mc_router_state_change(struct net_bridge *p,
648 bool is_mc_router)
649{
650 struct switchdev_attr attr = {
651 .orig_dev = p->dev,
652 .id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER,
653 .flags = SWITCHDEV_F_DEFER,
654 .u.mrouter = is_mc_router,
655 };
656
657 switchdev_port_attr_set(p->dev, &attr);
658}
659
88c1f37f 660static void br_multicast_local_router_expired(struct timer_list *t)
eb1d1641 661{
88c1f37f 662 struct net_bridge *br = from_timer(br, t, multicast_router_timer);
77041420
YG		 663
664 spin_lock(&br->multicast_lock);
665 if (br->multicast_router == MDB_RTR_TYPE_DISABLED ||
666 br->multicast_router == MDB_RTR_TYPE_PERM ||
667 timer_pending(&br->multicast_router_timer))
668 goto out;
669
670 br_mc_router_state_change(br, false);
671out:
672 spin_unlock(&br->multicast_lock);
eb1d1641
HX		 673}
674
cc0fdd80 675static void br_multicast_querier_expired(struct net_bridge *br,
90010b36 676 struct bridge_mcast_own_query *query)
c83b8fab 677{
c83b8fab 678 spin_lock(&br->multicast_lock);
13cefad2 679 if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
c83b8fab
HX		 680 goto out;
681
cc0fdd80 682 br_multicast_start_querier(br, query);
c83b8fab
HX		 683
684out:
685 spin_unlock(&br->multicast_lock);
686}
687
88c1f37f 688static void br_ip4_multicast_querier_expired(struct timer_list *t)
cc0fdd80 689{
88c1f37f 690 struct net_bridge *br = from_timer(br, t, ip4_other_query.timer);
cc0fdd80 691
90010b36 692 br_multicast_querier_expired(br, &br->ip4_own_query);
cc0fdd80
LL		 693}
694
695#if IS_ENABLED(CONFIG_IPV6)
88c1f37f 696static void br_ip6_multicast_querier_expired(struct timer_list *t)
cc0fdd80 697{
88c1f37f 698 struct net_bridge *br = from_timer(br, t, ip6_other_query.timer);
cc0fdd80 699
90010b36 700 br_multicast_querier_expired(br, &br->ip6_own_query);
cc0fdd80
LL		 701}
702#endif
703
dc4eb53a
LL		 704static void br_multicast_select_own_querier(struct net_bridge *br,
705 struct br_ip *ip,
706 struct sk_buff *skb)
707{
708 if (ip->proto == htons(ETH_P_IP))
709 br->ip4_querier.addr.u.ip4 = ip_hdr(skb)->saddr;
710#if IS_ENABLED(CONFIG_IPV6)
711 else
712 br->ip6_querier.addr.u.ip6 = ipv6_hdr(skb)->saddr;
713#endif
714}
715
8ef2a9a5
YH		 716static void __br_multicast_send_query(struct net_bridge *br,
717 struct net_bridge_port *port,
718 struct br_ip *ip)
eb1d1641 719{
eb1d1641 720 struct sk_buff *skb;
1080ab95 721 u8 igmp_type;
eb1d1641 722
1080ab95 723 skb = br_multicast_alloc_query(br, ip, &igmp_type);
eb1d1641 724 if (!skb)
8ef2a9a5 725 return;
eb1d1641
HX		 726
727 if (port) {
eb1d1641 728 skb->dev = port->dev;
a65056ec 729 br_multicast_count(br, port, skb, igmp_type,
1080ab95 730 BR_MCAST_DIR_TX);
29a26a56
EB		 731 NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT,
732 dev_net(port->dev), NULL, skb, NULL, skb->dev,
f0b4eece 733 br_dev_queue_push_xmit);
dc4eb53a
LL		 734 } else {
735 br_multicast_select_own_querier(br, ip, skb);
a65056ec 736 br_multicast_count(br, port, skb, igmp_type,
1080ab95 737 BR_MCAST_DIR_RX);
eb1d1641 738 netif_rx(skb);
dc4eb53a 739 }
8ef2a9a5
YH		 740}
741
742static void br_multicast_send_query(struct net_bridge *br,
cc0fdd80 743 struct net_bridge_port *port,
90010b36 744 struct bridge_mcast_own_query *own_query)
8ef2a9a5 745{
90010b36 746 struct bridge_mcast_other_query *other_query = NULL;
5e923585
NA		 747 struct br_ip br_group;
748 unsigned long time;
8ef2a9a5 749
13cefad2
NA		 750 if (!netif_running(br->dev) ||
751 !br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
675779ad 752 !br_opt_get(br, BROPT_MULTICAST_QUERIER))
8ef2a9a5
YH		 753 return;
754
08b202b6
YH		 755 memset(&br_group.u, 0, sizeof(br_group.u));
756
90010b36
LL		 757 if (port ? (own_query == &port->ip4_own_query) :
758 (own_query == &br->ip4_own_query)) {
759 other_query = &br->ip4_other_query;
cc0fdd80 760 br_group.proto = htons(ETH_P_IP);
dfd56b8b 761#if IS_ENABLED(CONFIG_IPV6)
cc0fdd80 762 } else {
90010b36 763 other_query = &br->ip6_other_query;
cc0fdd80 764 br_group.proto = htons(ETH_P_IPV6);
08b202b6 765#endif
cc0fdd80
LL		 766 }
767
90010b36 768 if (!other_query || timer_pending(&other_query->timer))
cc0fdd80
LL		 769 return;
770
771 __br_multicast_send_query(br, port, &br_group);
eb1d1641 772
eb1d1641 773 time = jiffies;
90010b36 774 time += own_query->startup_sent < br->multicast_startup_query_count ?
eb1d1641
HX		 775 br->multicast_startup_query_interval :
776 br->multicast_query_interval;
90010b36 777 mod_timer(&own_query->timer, time);
eb1d1641
HX		 778}
779
90010b36
LL		 780static void
781br_multicast_port_query_expired(struct net_bridge_port *port,
782 struct bridge_mcast_own_query *query)
eb1d1641 783{
eb1d1641
HX		 784 struct net_bridge *br = port->br;
785
786 spin_lock(&br->multicast_lock);
02a780c0
DC		 787 if (port->state == BR_STATE_DISABLED ||
788 port->state == BR_STATE_BLOCKING)
eb1d1641
HX		 789 goto out;
790
cc0fdd80
LL		 791 if (query->startup_sent < br->multicast_startup_query_count)
792 query->startup_sent++;
eb1d1641 793
cc0fdd80 794 br_multicast_send_query(port->br, port, query);
eb1d1641
HX		 795
796out:
797 spin_unlock(&br->multicast_lock);
798}
799
88c1f37f 800static void br_ip4_multicast_port_query_expired(struct timer_list *t)
cc0fdd80 801{
88c1f37f 802 struct net_bridge_port *port = from_timer(port, t, ip4_own_query.timer);
cc0fdd80 803
90010b36 804 br_multicast_port_query_expired(port, &port->ip4_own_query);
cc0fdd80
LL		 805}
806
807#if IS_ENABLED(CONFIG_IPV6)
88c1f37f 808static void br_ip6_multicast_port_query_expired(struct timer_list *t)
cc0fdd80 809{
88c1f37f 810 struct net_bridge_port *port = from_timer(port, t, ip6_own_query.timer);
cc0fdd80 811
90010b36 812 br_multicast_port_query_expired(port, &port->ip6_own_query);
cc0fdd80
LL		 813}
814#endif
815
147c1e9b
NF		 816static void br_mc_disabled_update(struct net_device *dev, bool value)
817{
818 struct switchdev_attr attr = {
819 .orig_dev = dev,
820 .id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED,
821 .flags = SWITCHDEV_F_DEFER,
13cefad2 822 .u.mc_disabled = !value,
147c1e9b
NF		 823 };
824
825 switchdev_port_attr_set(dev, &attr);
826}
827
1080ab95 828int br_multicast_add_port(struct net_bridge_port *port)
eb1d1641 829{
7f0aec7a 830 port->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
eb1d1641 831
88c1f37f
AP		 832 timer_setup(&port->multicast_router_timer,
833 br_multicast_router_expired, 0);
834 timer_setup(&port->ip4_own_query.timer,
835 br_ip4_multicast_port_query_expired, 0);
cc0fdd80 836#if IS_ENABLED(CONFIG_IPV6)
88c1f37f
AP		 837 timer_setup(&port->ip6_own_query.timer,
838 br_ip6_multicast_port_query_expired, 0);
cc0fdd80 839#endif
13cefad2
NA		 840 br_mc_disabled_update(port->dev,
841 br_opt_get(port->br, BROPT_MULTICAST_ENABLED));
147c1e9b 842
1080ab95
NA		 843 port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
844 if (!port->mcast_stats)
845 return -ENOMEM;
846
847 return 0;
eb1d1641
HX		 848}
849
850void br_multicast_del_port(struct net_bridge_port *port)
851{
e10177ab
SA		 852 struct net_bridge *br = port->br;
853 struct net_bridge_port_group *pg;
854 struct hlist_node *n;
855
856 /* Take care of the remaining groups, only perm ones should be left */
857 spin_lock_bh(&br->multicast_lock);
858 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
859 br_multicast_del_pg(br, pg);
860 spin_unlock_bh(&br->multicast_lock);
eb1d1641 861 del_timer_sync(&port->multicast_router_timer);
1080ab95 862 free_percpu(port->mcast_stats);
eb1d1641
HX		 863}
864
90010b36 865static void br_multicast_enable(struct bridge_mcast_own_query *query)
561f1103 866{
cc0fdd80 867 query->startup_sent = 0;
561f1103 868
cc0fdd80
LL		 869 if (try_to_del_timer_sync(&query->timer) >= 0 ||
870 del_timer(&query->timer))
871 mod_timer(&query->timer, jiffies);
561f1103
HX		 872}
873
7cb3f921 874static void __br_multicast_enable_port(struct net_bridge_port *port)
eb1d1641
HX		 875{
876 struct net_bridge *br = port->br;
877
13cefad2 878 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || !netif_running(br->dev))
7cb3f921 879 return;
eb1d1641 880
90010b36 881 br_multicast_enable(&port->ip4_own_query);
cc0fdd80 882#if IS_ENABLED(CONFIG_IPV6)
90010b36 883 br_multicast_enable(&port->ip6_own_query);
cc0fdd80 884#endif
7f0aec7a
NA		 885 if (port->multicast_router == MDB_RTR_TYPE_PERM &&
886 hlist_unhashed(&port->rlist))
754bc547 887 br_multicast_add_router(br, port);
7cb3f921 888}
eb1d1641 889
7cb3f921
NA		 890void br_multicast_enable_port(struct net_bridge_port *port)
891{
892 struct net_bridge *br = port->br;
893
894 spin_lock(&br->multicast_lock);
895 __br_multicast_enable_port(port);
eb1d1641
HX		 896 spin_unlock(&br->multicast_lock);
897}
898
899void br_multicast_disable_port(struct net_bridge_port *port)
900{
901 struct net_bridge *br = port->br;
902 struct net_bridge_port_group *pg;
b67bfe0d 903 struct hlist_node *n;
eb1d1641
HX		 904
905 spin_lock(&br->multicast_lock);
b67bfe0d 906 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
9d06b6d8 907 if (!(pg->flags & MDB_PG_FLAGS_PERMANENT))
e10177ab 908 br_multicast_del_pg(br, pg);
eb1d1641 909
f12e7d95
NF		 910 __del_port_router(port);
911
eb1d1641 912 del_timer(&port->multicast_router_timer);
90010b36 913 del_timer(&port->ip4_own_query.timer);
cc0fdd80 914#if IS_ENABLED(CONFIG_IPV6)
90010b36 915 del_timer(&port->ip6_own_query.timer);
cc0fdd80 916#endif
eb1d1641
HX		 917 spin_unlock(&br->multicast_lock);
918}
919
8ef2a9a5
YH		 920static int br_ip4_multicast_igmp3_report(struct net_bridge *br,
921 struct net_bridge_port *port,
06499098
VY		 922 struct sk_buff *skb,
923 u16 vid)
eb1d1641 924{
6db6f0ea 925 const unsigned char *src;
eb1d1641
HX		 926 struct igmpv3_report *ih;
927 struct igmpv3_grec *grec;
928 int i;
929 int len;
930 int num;
931 int type;
932 int err = 0;
933 __be32 group;
934
eb1d1641
HX		 935 ih = igmpv3_report_hdr(skb);
936 num = ntohs(ih->ngrec);
c2d4fbd2 937 len = skb_transport_offset(skb) + sizeof(*ih);
eb1d1641
HX		 938
939 for (i = 0; i < num; i++) {
940 len += sizeof(*grec);
ba5ea614 941 if (!ip_mc_may_pull(skb, len))
eb1d1641
HX		 942 return -EINVAL;
943
fd218cf9 944 grec = (void *)(skb->data + len - sizeof(*grec));
eb1d1641
HX		 945 group = grec->grec_mca;
946 type = grec->grec_type;
947
8eabf95c 948 len += ntohs(grec->grec_nsrcs) * 4;
ba5ea614 949 if (!ip_mc_may_pull(skb, len))
eb1d1641
HX		 950 return -EINVAL;
951
952 /* We treat this as an IGMPv2 report for now. */
953 switch (type) {
954 case IGMPV3_MODE_IS_INCLUDE:
955 case IGMPV3_MODE_IS_EXCLUDE:
956 case IGMPV3_CHANGE_TO_INCLUDE:
957 case IGMPV3_CHANGE_TO_EXCLUDE:
958 case IGMPV3_ALLOW_NEW_SOURCES:
959 case IGMPV3_BLOCK_OLD_SOURCES:
960 break;
961
962 default:
963 continue;
964 }
965
6db6f0ea 966 src = eth_hdr(skb)->h_source;
bc8c20ac
SA		 967 if ((type == IGMPV3_CHANGE_TO_INCLUDE ||
968 type == IGMPV3_MODE_IS_INCLUDE) &&
969 ntohs(grec->grec_nsrcs) == 0) {
6db6f0ea 970 br_ip4_multicast_leave_group(br, port, group, vid, src);
bc8c20ac 971 } else {
6db6f0ea
FF		 972 err = br_ip4_multicast_add_group(br, port, group, vid,
973 src);
bc8c20ac
SA		 974 if (err)
975 break;
976 }
eb1d1641
HX		 977 }
978
979 return err;
980}
981
dfd56b8b 982#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 983static int br_ip6_multicast_mld2_report(struct net_bridge *br,
984 struct net_bridge_port *port,
06499098
VY		 985 struct sk_buff *skb,
986 u16 vid)
08b202b6 987{
ba5ea614 988 unsigned int nsrcs_offset;
6db6f0ea 989 const unsigned char *src;
08b202b6
YH		 990 struct icmp6hdr *icmp6h;
991 struct mld2_grec *grec;
ba5ea614 992 unsigned int grec_len;
08b202b6
YH		 993 int i;
994 int len;
995 int num;
996 int err = 0;
997
ba5ea614 998 if (!ipv6_mc_may_pull(skb, sizeof(*icmp6h)))
08b202b6
YH		 999 return -EINVAL;
1000
1001 icmp6h = icmp6_hdr(skb);
1002 num = ntohs(icmp6h->icmp6_dataun.un_data16[1]);
c2d4fbd2 1003 len = skb_transport_offset(skb) + sizeof(*icmp6h);
08b202b6
YH		 1004
1005 for (i = 0; i < num; i++) {
1006 __be16 *nsrcs, _nsrcs;
1007
ba5ea614
LL		 1008 nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs);
1009
1010 if (skb_transport_offset(skb) + ipv6_transport_len(skb) <
1011 nsrcs_offset + sizeof(_nsrcs))
1012 return -EINVAL;
1013
1014 nsrcs = skb_header_pointer(skb, nsrcs_offset,
08b202b6
YH		 1015 sizeof(_nsrcs), &_nsrcs);
1016 if (!nsrcs)
1017 return -EINVAL;
1018
ba5ea614
LL		 1019 grec_len = sizeof(*grec) +
1020 sizeof(struct in6_addr) * ntohs(*nsrcs);
1021
1022 if (!ipv6_mc_may_pull(skb, len + grec_len))
08b202b6
YH		 1023 return -EINVAL;
1024
1025 grec = (struct mld2_grec *)(skb->data + len);
ba5ea614 1026 len += grec_len;
08b202b6
YH		 1027
1028 /* We treat these as MLDv1 reports for now. */
1029 switch (grec->grec_type) {
1030 case MLD2_MODE_IS_INCLUDE:
1031 case MLD2_MODE_IS_EXCLUDE:
1032 case MLD2_CHANGE_TO_INCLUDE:
1033 case MLD2_CHANGE_TO_EXCLUDE:
1034 case MLD2_ALLOW_NEW_SOURCES:
1035 case MLD2_BLOCK_OLD_SOURCES:
1036 break;
1037
1038 default:
1039 continue;
1040 }
1041
6db6f0ea 1042 src = eth_hdr(skb)->h_source;
bc8c20ac
SA		 1043 if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
1044 grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
1045 ntohs(*nsrcs) == 0) {
1046 br_ip6_multicast_leave_group(br, port, &grec->grec_mca,
6db6f0ea 1047 vid, src);
bc8c20ac
SA		 1048 } else {
1049 err = br_ip6_multicast_add_group(br, port,
6db6f0ea
FF		 1050 &grec->grec_mca, vid,
1051 src);
9264251e 1052 if (err)
bc8c20ac
SA		 1053 break;
1054 }
08b202b6
YH		 1055 }
1056
1057 return err;
1058}
1059#endif
1060
dc4eb53a 1061static bool br_ip4_multicast_select_querier(struct net_bridge *br,
2cd41431 1062 struct net_bridge_port *port,
dc4eb53a
LL		 1063 __be32 saddr)
1064{
1065 if (!timer_pending(&br->ip4_own_query.timer) &&
1066 !timer_pending(&br->ip4_other_query.timer))
1067 goto update;
1068
1069 if (!br->ip4_querier.addr.u.ip4)
1070 goto update;
1071
1072 if (ntohl(saddr) <= ntohl(br->ip4_querier.addr.u.ip4))
1073 goto update;
1074
1075 return false;
1076
1077update:
1078 br->ip4_querier.addr.u.ip4 = saddr;
1079
2cd41431
LL		 1080 /* update protected by general multicast_lock by caller */
1081 rcu_assign_pointer(br->ip4_querier.port, port);
1082
dc4eb53a
LL		 1083 return true;
1084}
1085
1086#if IS_ENABLED(CONFIG_IPV6)
1087static bool br_ip6_multicast_select_querier(struct net_bridge *br,
2cd41431 1088 struct net_bridge_port *port,
dc4eb53a
LL		 1089 struct in6_addr *saddr)
1090{
1091 if (!timer_pending(&br->ip6_own_query.timer) &&
1092 !timer_pending(&br->ip6_other_query.timer))
1093 goto update;
1094
1095 if (ipv6_addr_cmp(saddr, &br->ip6_querier.addr.u.ip6) <= 0)
1096 goto update;
1097
1098 return false;
1099
1100update:
1101 br->ip6_querier.addr.u.ip6 = *saddr;
1102
2cd41431
LL		 1103 /* update protected by general multicast_lock by caller */
1104 rcu_assign_pointer(br->ip6_querier.port, port);
1105
dc4eb53a
LL		 1106 return true;
1107}
1108#endif
1109
1110static bool br_multicast_select_querier(struct net_bridge *br,
2cd41431 1111 struct net_bridge_port *port,
dc4eb53a
LL		 1112 struct br_ip *saddr)
1113{
1114 switch (saddr->proto) {
1115 case htons(ETH_P_IP):
2cd41431 1116 return br_ip4_multicast_select_querier(br, port, saddr->u.ip4);
dc4eb53a
LL		 1117#if IS_ENABLED(CONFIG_IPV6)
1118 case htons(ETH_P_IPV6):
2cd41431 1119 return br_ip6_multicast_select_querier(br, port, &saddr->u.ip6);
dc4eb53a
LL		 1120#endif
1121 }
1122
1123 return false;
1124}
1125
cc0fdd80 1126static void
90010b36
LL		 1127br_multicast_update_query_timer(struct net_bridge *br,
1128 struct bridge_mcast_other_query *query,
1129 unsigned long max_delay)
b00589af 1130{
90010b36
LL		 1131 if (!timer_pending(&query->timer))
1132 query->delay_time = jiffies + max_delay;
b00589af 1133
90010b36 1134 mod_timer(&query->timer, jiffies + br->multicast_querier_interval);
b00589af
LL		 1135}
1136
6d549648
NF		 1137static void br_port_mc_router_state_change(struct net_bridge_port *p,
1138 bool is_mc_router)
1139{
1140 struct switchdev_attr attr = {
1141 .orig_dev = p->dev,
1142 .id = SWITCHDEV_ATTR_ID_PORT_MROUTER,
1143 .flags = SWITCHDEV_F_DEFER,
1144 .u.mrouter = is_mc_router,
1145 };
1146
1147 switchdev_port_attr_set(p->dev, &attr);
1148}
1149
7e80c124 1150/*
7c77602f 1151 * Add port to router_list
7e80c124 1152 * list is maintained ordered by pointer value
1153 * and locked by br->multicast_lock and RCU
1154 */
0909e117
HX		 1155static void br_multicast_add_router(struct net_bridge *br,
1156 struct net_bridge_port *port)
1157{
dcdca2c4 1158 struct net_bridge_port *p;
b67bfe0d 1159 struct hlist_node *slot = NULL;
dcdca2c4 1160
1a040eac
NA		 1161 if (!hlist_unhashed(&port->rlist))
1162 return;
1163
b67bfe0d 1164 hlist_for_each_entry(p, &br->router_list, rlist) {
7e80c124 1165 if ((unsigned long) port >= (unsigned long) p)
1166 break;
b67bfe0d 1167 slot = &p->rlist;
dcdca2c4 1168 }
1169
7e80c124 1170 if (slot)
1d023284 1171 hlist_add_behind_rcu(&port->rlist, slot);
dcdca2c4 1172 else
1173 hlist_add_head_rcu(&port->rlist, &br->router_list);
949f1e39 1174 br_rtr_notify(br->dev, port, RTM_NEWMDB);
6d549648 1175 br_port_mc_router_state_change(port, true);
0909e117
HX		 1176}
1177
eb1d1641
HX		 1178static void br_multicast_mark_router(struct net_bridge *br,
1179 struct net_bridge_port *port)
1180{
1181 unsigned long now = jiffies;
eb1d1641
HX		 1182
1183 if (!port) {
77041420
YG		 1184 if (br->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) {
1185 if (!timer_pending(&br->multicast_router_timer))
1186 br_mc_router_state_change(br, true);
eb1d1641
HX		 1187 mod_timer(&br->multicast_router_timer,
1188 now + br->multicast_querier_interval);
77041420 1189 }
eb1d1641
HX		 1190 return;
1191 }
1192
a55d8246
NA		 1193 if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
1194 port->multicast_router == MDB_RTR_TYPE_PERM)
eb1d1641
HX		 1195 return;
1196
0909e117 1197 br_multicast_add_router(br, port);
eb1d1641 1198
eb1d1641
HX		 1199 mod_timer(&port->multicast_router_timer,
1200 now + br->multicast_querier_interval);
1201}
1202
1203static void br_multicast_query_received(struct net_bridge *br,
1204 struct net_bridge_port *port,
90010b36 1205 struct bridge_mcast_other_query *query,
dc4eb53a 1206 struct br_ip *saddr,
b00589af 1207 unsigned long max_delay)
eb1d1641 1208{
2cd41431 1209 if (!br_multicast_select_querier(br, port, saddr))
eb1d1641
HX		 1210 return;
1211
dc4eb53a 1212 br_multicast_update_query_timer(br, query, max_delay);
5a2de63f
HL		 1213
1214 /* Based on RFC4541, section 2.1.1 IGMP Forwarding Rules,
1215 * the arrival port for IGMP Queries where the source address
1216 * is 0.0.0.0 should not be added to router port list.
1217 */
1218 if ((saddr->proto == htons(ETH_P_IP) && saddr->u.ip4) ||
0fe5119e 1219 saddr->proto == htons(ETH_P_IPV6))
5a2de63f 1220 br_multicast_mark_router(br, port);
eb1d1641
HX		 1221}
1222
9c2e955c 1223static void br_ip4_multicast_query(struct net_bridge *br,
1224 struct net_bridge_port *port,
1225 struct sk_buff *skb,
1226 u16 vid)
eb1d1641 1227{
ba5ea614 1228 unsigned int transport_len = ip_transport_len(skb);
b71d1d42 1229 const struct iphdr *iph = ip_hdr(skb);
eb1d1641
HX		 1230 struct igmphdr *ih = igmp_hdr(skb);
1231 struct net_bridge_mdb_entry *mp;
1232 struct igmpv3_query *ih3;
1233 struct net_bridge_port_group *p;
e8051688 1234 struct net_bridge_port_group __rcu **pp;
dc4eb53a 1235 struct br_ip saddr;
eb1d1641
HX		 1236 unsigned long max_delay;
1237 unsigned long now = jiffies;
1238 __be32 group;
1239
1240 spin_lock(&br->multicast_lock);
1241 if (!netif_running(br->dev) ||
1242 (port && port->state == BR_STATE_DISABLED))
1243 goto out;
1244
eb1d1641
HX		 1245 group = ih->group;
1246
ba5ea614 1247 if (transport_len == sizeof(*ih)) {
eb1d1641
HX		 1248 max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
1249
1250 if (!max_delay) {
1251 max_delay = 10 * HZ;
1252 group = 0;
1253 }
ba5ea614 1254 } else if (transport_len >= sizeof(*ih3)) {
eb1d1641
HX		 1255 ih3 = igmpv3_query_hdr(skb);
1256 if (ih3->nsrcs)
bec68ff1 1257 goto out;
eb1d1641 1258
0ba8c9ec
YH		 1259 max_delay = ih3->code ?
1260 IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1;
9afd85c9 1261 } else {
9ed973cc
LL		 1262 goto out;
1263 }
1264
dc4eb53a
LL		 1265 if (!group) {
1266 saddr.proto = htons(ETH_P_IP);
1267 saddr.u.ip4 = iph->saddr;
b00589af 1268
dc4eb53a
LL		 1269 br_multicast_query_received(br, port, &br->ip4_other_query,
1270 &saddr, max_delay);
eb1d1641 1271 goto out;
dc4eb53a 1272 }
eb1d1641 1273
19e3a9c9 1274 mp = br_mdb_ip4_get(br, group, vid);
eb1d1641
HX		 1275 if (!mp)
1276 goto out;
1277
1278 max_delay *= br->multicast_last_member_count;
1279
ff0fd34e 1280 if (mp->host_joined &&
eb1d1641
HX		 1281 (timer_pending(&mp->timer) ?
1282 time_after(mp->timer.expires, now + max_delay) :
1283 try_to_del_timer_sync(&mp->timer) >= 0))
1284 mod_timer(&mp->timer, now + max_delay);
1285
e8051688
ED		 1286 for (pp = &mp->ports;
1287 (p = mlock_dereference(*pp, br)) != NULL;
1288 pp = &p->next) {
eb1d1641
HX		 1289 if (timer_pending(&p->timer) ?
1290 time_after(p->timer.expires, now + max_delay) :
1291 try_to_del_timer_sync(&p->timer) >= 0)
24f9cdcb 1292 mod_timer(&p->timer, now + max_delay);
eb1d1641
HX		 1293 }
1294
1295out:
1296 spin_unlock(&br->multicast_lock);
eb1d1641
HX		 1297}
1298
dfd56b8b 1299#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 1300static int br_ip6_multicast_query(struct net_bridge *br,
1301 struct net_bridge_port *port,
06499098
VY		 1302 struct sk_buff *skb,
1303 u16 vid)
08b202b6 1304{
ba5ea614 1305 unsigned int transport_len = ipv6_transport_len(skb);
b71d1d42 1306 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
eca2a43b 1307 struct mld_msg *mld;
08b202b6
YH		 1308 struct net_bridge_mdb_entry *mp;
1309 struct mld2_query *mld2q;
e8051688
ED		 1310 struct net_bridge_port_group *p;
1311 struct net_bridge_port_group __rcu **pp;
dc4eb53a 1312 struct br_ip saddr;
08b202b6
YH		 1313 unsigned long max_delay;
1314 unsigned long now = jiffies;
856ce5d0 1315 unsigned int offset = skb_transport_offset(skb);
b71d1d42 1316 const struct in6_addr *group = NULL;
9ed973cc 1317 bool is_general_query;
08b202b6
YH		 1318 int err = 0;
1319
1320 spin_lock(&br->multicast_lock);
1321 if (!netif_running(br->dev) ||
1322 (port && port->state == BR_STATE_DISABLED))
1323 goto out;
1324
ba5ea614 1325 if (transport_len == sizeof(*mld)) {
856ce5d0 1326 if (!pskb_may_pull(skb, offset + sizeof(*mld))) {
08b202b6
YH		 1327 err = -EINVAL;
1328 goto out;
1329 }
1330 mld = (struct mld_msg *) icmp6_hdr(skb);
4715213d 1331 max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));
08b202b6
YH		 1332 if (max_delay)
1333 group = &mld->mld_mca;
248ba8ec 1334 } else {
856ce5d0 1335 if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) {
08b202b6
YH		 1336 err = -EINVAL;
1337 goto out;
1338 }
1339 mld2q = (struct mld2_query *)icmp6_hdr(skb);
1340 if (!mld2q->mld2q_nsrcs)
1341 group = &mld2q->mld2q_mca;
e3f5b170
DB		 1342
1343 max_delay = max(msecs_to_jiffies(mldv2_mrc(mld2q)), 1UL);
08b202b6
YH		 1344 }
1345
9ed973cc
LL		 1346 is_general_query = group && ipv6_addr_any(group);
1347
dc4eb53a
LL		 1348 if (is_general_query) {
1349 saddr.proto = htons(ETH_P_IPV6);
1350 saddr.u.ip6 = ip6h->saddr;
b00589af 1351
dc4eb53a
LL		 1352 br_multicast_query_received(br, port, &br->ip6_other_query,
1353 &saddr, max_delay);
08b202b6 1354 goto out;
6c03ee8b
LL		 1355 } else if (!group) {
1356 goto out;
dc4eb53a 1357 }
08b202b6 1358
19e3a9c9 1359 mp = br_mdb_ip6_get(br, group, vid);
08b202b6
YH		 1360 if (!mp)
1361 goto out;
1362
1363 max_delay *= br->multicast_last_member_count;
ff0fd34e 1364 if (mp->host_joined &&
08b202b6
YH		 1365 (timer_pending(&mp->timer) ?
1366 time_after(mp->timer.expires, now + max_delay) :
1367 try_to_del_timer_sync(&mp->timer) >= 0))
1368 mod_timer(&mp->timer, now + max_delay);
1369
e8051688
ED		 1370 for (pp = &mp->ports;
1371 (p = mlock_dereference(*pp, br)) != NULL;
1372 pp = &p->next) {
08b202b6
YH		 1373 if (timer_pending(&p->timer) ?
1374 time_after(p->timer.expires, now + max_delay) :
1375 try_to_del_timer_sync(&p->timer) >= 0)
24f9cdcb 1376 mod_timer(&p->timer, now + max_delay);
08b202b6
YH		 1377 }
1378
1379out:
1380 spin_unlock(&br->multicast_lock);
1381 return err;
1382}
1383#endif
1384
90010b36
LL		 1385static void
1386br_multicast_leave_group(struct net_bridge *br,
1387 struct net_bridge_port *port,
1388 struct br_ip *group,
1389 struct bridge_mcast_other_query *other_query,
6db6f0ea
FF		 1390 struct bridge_mcast_own_query *own_query,
1391 const unsigned char *src)
eb1d1641 1392{
eb1d1641
HX		 1393 struct net_bridge_mdb_entry *mp;
1394 struct net_bridge_port_group *p;
1395 unsigned long now;
1396 unsigned long time;
1397
eb1d1641
HX		 1398 spin_lock(&br->multicast_lock);
1399 if (!netif_running(br->dev) ||
544586f7 1400 (port && port->state == BR_STATE_DISABLED))
eb1d1641
HX		 1401 goto out;
1402
19e3a9c9 1403 mp = br_mdb_ip_get(br, group);
eb1d1641
HX		 1404 if (!mp)
1405 goto out;
1406
544586f7
SA		 1407 if (port && (port->flags & BR_MULTICAST_FAST_LEAVE)) {
1408 struct net_bridge_port_group __rcu **pp;
1409
1410 for (pp = &mp->ports;
1411 (p = mlock_dereference(*pp, br)) != NULL;
1412 pp = &p->next) {
6db6f0ea 1413 if (!br_port_group_equal(p, port, src))
544586f7
SA		 1414 continue;
1415
1416 rcu_assign_pointer(*pp, p->next);
1417 hlist_del_init(&p->mglist);
1418 del_timer(&p->timer);
4329596c 1419 kfree_rcu(p, rcu);
45ebcce5
ER		 1420 br_mdb_notify(br->dev, port, group, RTM_DELMDB,
1421 p->flags);
544586f7 1422
ff0fd34e 1423 if (!mp->ports && !mp->host_joined &&
544586f7
SA		 1424 netif_running(br->dev))
1425 mod_timer(&mp->timer, jiffies);
1426 }
1427 goto out;
1428 }
1429
1430 if (timer_pending(&other_query->timer))
1431 goto out;
1432
675779ad 1433 if (br_opt_get(br, BROPT_MULTICAST_QUERIER)) {
6b7df111
CW		 1434 __br_multicast_send_query(br, port, &mp->addr);
1435
1436 time = jiffies + br->multicast_last_member_count *
1437 br->multicast_last_member_interval;
cc0fdd80 1438
90010b36 1439 mod_timer(&own_query->timer, time);
6b7df111
CW		 1440
1441 for (p = mlock_dereference(mp->ports, br);
1442 p != NULL;
1443 p = mlock_dereference(p->next, br)) {
6db6f0ea 1444 if (!br_port_group_equal(p, port, src))
6b7df111
CW		 1445 continue;
1446
1447 if (!hlist_unhashed(&p->mglist) &&
1448 (timer_pending(&p->timer) ?
1449 time_after(p->timer.expires, time) :
1450 try_to_del_timer_sync(&p->timer) >= 0)) {
1451 mod_timer(&p->timer, time);
1452 }
1453
1454 break;
1455 }
1456 }
1457
eb1d1641
HX		 1458 now = jiffies;
1459 time = now + br->multicast_last_member_count *
1460 br->multicast_last_member_interval;
1461
1462 if (!port) {
ff0fd34e 1463 if (mp->host_joined &&
eb1d1641
HX		 1464 (timer_pending(&mp->timer) ?
1465 time_after(mp->timer.expires, time) :
1466 try_to_del_timer_sync(&mp->timer) >= 0)) {
1467 mod_timer(&mp->timer, time);
eb1d1641 1468 }
454594f3
LL		 1469
1470 goto out;
1471 }
1472
1473 for (p = mlock_dereference(mp->ports, br);
1474 p != NULL;
1475 p = mlock_dereference(p->next, br)) {
1476 if (p->port != port)
1477 continue;
1478
1479 if (!hlist_unhashed(&p->mglist) &&
1480 (timer_pending(&p->timer) ?
1481 time_after(p->timer.expires, time) :
1482 try_to_del_timer_sync(&p->timer) >= 0)) {
1483 mod_timer(&p->timer, time);
1484 }
1485
1486 break;
eb1d1641 1487 }
eb1d1641
HX		 1488out:
1489 spin_unlock(&br->multicast_lock);
1490}
1491
8ef2a9a5
YH		 1492static void br_ip4_multicast_leave_group(struct net_bridge *br,
1493 struct net_bridge_port *port,
b0e9a30d 1494 __be32 group,
6db6f0ea
FF		 1495 __u16 vid,
1496 const unsigned char *src)
8ef2a9a5
YH		 1497{
1498 struct br_ip br_group;
90010b36 1499 struct bridge_mcast_own_query *own_query;
8ef2a9a5
YH		 1500
1501 if (ipv4_is_local_multicast(group))
1502 return;
1503
90010b36
LL		 1504 own_query = port ? &port->ip4_own_query : &br->ip4_own_query;
1505
8ef2a9a5
YH		 1506 br_group.u.ip4 = group;
1507 br_group.proto = htons(ETH_P_IP);
b0e9a30d 1508 br_group.vid = vid;
8ef2a9a5 1509
90010b36 1510 br_multicast_leave_group(br, port, &br_group, &br->ip4_other_query,
6db6f0ea 1511 own_query, src);
8ef2a9a5
YH		 1512}
1513
dfd56b8b 1514#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 1515static void br_ip6_multicast_leave_group(struct net_bridge *br,
1516 struct net_bridge_port *port,
b0e9a30d 1517 const struct in6_addr *group,
6db6f0ea
FF		 1518 __u16 vid,
1519 const unsigned char *src)
08b202b6
YH		 1520{
1521 struct br_ip br_group;
90010b36 1522 struct bridge_mcast_own_query *own_query;
08b202b6 1523
3c3769e6 1524 if (ipv6_addr_is_ll_all_nodes(group))
08b202b6
YH		 1525 return;
1526
90010b36
LL		 1527 own_query = port ? &port->ip6_own_query : &br->ip6_own_query;
1528
4e3fd7a0 1529 br_group.u.ip6 = *group;
08b202b6 1530 br_group.proto = htons(ETH_P_IPV6);
b0e9a30d 1531 br_group.vid = vid;
08b202b6 1532
90010b36 1533 br_multicast_leave_group(br, port, &br_group, &br->ip6_other_query,
6db6f0ea 1534 own_query, src);
08b202b6
YH		 1535}
1536#endif
8ef2a9a5 1537
1080ab95
NA		 1538static void br_multicast_err_count(const struct net_bridge *br,
1539 const struct net_bridge_port *p,
1540 __be16 proto)
1541{
1542 struct bridge_mcast_stats __percpu *stats;
1543 struct bridge_mcast_stats *pstats;
1544
675779ad 1545 if (!br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
1080ab95
NA		 1546 return;
1547
1548 if (p)
1549 stats = p->mcast_stats;
1550 else
1551 stats = br->mcast_stats;
1552 if (WARN_ON(!stats))
1553 return;
1554
1555 pstats = this_cpu_ptr(stats);
1556
1557 u64_stats_update_begin(&pstats->syncp);
1558 switch (proto) {
1559 case htons(ETH_P_IP):
1560 pstats->mstats.igmp_parse_errors++;
1561 break;
1562#if IS_ENABLED(CONFIG_IPV6)
1563 case htons(ETH_P_IPV6):
1564 pstats->mstats.mld_parse_errors++;
1565 break;
1566#endif
1567 }
1568 u64_stats_update_end(&pstats->syncp);
1569}
1570
91b02d3d
NA		 1571static void br_multicast_pim(struct net_bridge *br,
1572 struct net_bridge_port *port,
1573 const struct sk_buff *skb)
1574{
1575 unsigned int offset = skb_transport_offset(skb);
1576 struct pimhdr *pimhdr, _pimhdr;
1577
1578 pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr);
1579 if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION ||
1580 pim_hdr_type(pimhdr) != PIM_TYPE_HELLO)
1581 return;
1582
1583 br_multicast_mark_router(br, port);
1584}
1585
eb1d1641
HX		 1586static int br_multicast_ipv4_rcv(struct net_bridge *br,
1587 struct net_bridge_port *port,
06499098
VY		 1588 struct sk_buff *skb,
1589 u16 vid)
eb1d1641 1590{
6db6f0ea 1591 const unsigned char *src;
eb1d1641 1592 struct igmphdr *ih;
eb1d1641
HX		 1593 int err;
1594
ba5ea614 1595 err = ip_mc_check_igmp(skb);
eb1d1641 1596
9afd85c9 1597 if (err == -ENOMSG) {
91b02d3d 1598 if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) {
bd4265fe 1599 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
91b02d3d
NA		 1600 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) {
1601 if (ip_hdr(skb)->protocol == IPPROTO_PIM)
1602 br_multicast_pim(br, port, skb);
1603 }
eb1d1641 1604 return 0;
9afd85c9 1605 } else if (err < 0) {
1080ab95 1606 br_multicast_err_count(br, port, skb->protocol);
9afd85c9 1607 return err;
bd4265fe 1608 }
eb1d1641 1609
9afd85c9 1610 ih = igmp_hdr(skb);
6db6f0ea 1611 src = eth_hdr(skb)->h_source;
1080ab95 1612 BR_INPUT_SKB_CB(skb)->igmp = ih->type;
eb1d1641
HX		 1613
1614 switch (ih->type) {
1615 case IGMP_HOST_MEMBERSHIP_REPORT:
1616 case IGMPV2_HOST_MEMBERSHIP_REPORT:
62b2bcb4 1617 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
6db6f0ea 1618 err = br_ip4_multicast_add_group(br, port, ih->group, vid, src);
eb1d1641
HX		 1619 break;
1620 case IGMPV3_HOST_MEMBERSHIP_REPORT:
ba5ea614 1621 err = br_ip4_multicast_igmp3_report(br, port, skb, vid);
eb1d1641
HX		 1622 break;
1623 case IGMP_HOST_MEMBERSHIP_QUERY:
ba5ea614 1624 br_ip4_multicast_query(br, port, skb, vid);
eb1d1641
HX		 1625 break;
1626 case IGMP_HOST_LEAVE_MESSAGE:
6db6f0ea 1627 br_ip4_multicast_leave_group(br, port, ih->group, vid, src);
eb1d1641
HX		 1628 break;
1629 }
1630
a65056ec 1631 br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
1080ab95
NA		 1632 BR_MCAST_DIR_RX);
1633
eb1d1641
HX		 1634 return err;
1635}
1636
dfd56b8b 1637#if IS_ENABLED(CONFIG_IPV6)
08b202b6
YH		 1638static int br_multicast_ipv6_rcv(struct net_bridge *br,
1639 struct net_bridge_port *port,
06499098
VY		 1640 struct sk_buff *skb,
1641 u16 vid)
08b202b6 1642{
6db6f0ea 1643 const unsigned char *src;
9afd85c9 1644 struct mld_msg *mld;
08b202b6
YH		 1645 int err;
1646
ba5ea614 1647 err = ipv6_mc_check_mld(skb);
08b202b6 1648
9afd85c9
LL		 1649 if (err == -ENOMSG) {
1650 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr))
1651 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
08b202b6 1652 return 0;
9afd85c9 1653 } else if (err < 0) {
1080ab95 1654 br_multicast_err_count(br, port, skb->protocol);
9afd85c9 1655 return err;
08b202b6
YH		 1656 }
1657
9afd85c9 1658 mld = (struct mld_msg *)skb_transport_header(skb);
1080ab95 1659 BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type;
08b202b6 1660
9afd85c9 1661 switch (mld->mld_type) {
08b202b6 1662 case ICMPV6_MGM_REPORT:
6db6f0ea 1663 src = eth_hdr(skb)->h_source;
fc2af6c7 1664 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
6db6f0ea
FF		 1665 err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid,
1666 src);
08b202b6 1667 break;
08b202b6 1668 case ICMPV6_MLD2_REPORT:
ba5ea614 1669 err = br_ip6_multicast_mld2_report(br, port, skb, vid);
08b202b6
YH		 1670 break;
1671 case ICMPV6_MGM_QUERY:
ba5ea614 1672 err = br_ip6_multicast_query(br, port, skb, vid);
08b202b6
YH		 1673 break;
1674 case ICMPV6_MGM_REDUCTION:
6db6f0ea
FF		 1675 src = eth_hdr(skb)->h_source;
1676 br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid, src);
9afd85c9 1677 break;
08b202b6
YH		 1678 }
1679
a65056ec 1680 br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
1080ab95
NA		 1681 BR_MCAST_DIR_RX);
1682
08b202b6
YH		 1683 return err;
1684}
1685#endif
1686
eb1d1641 1687int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
06499098 1688 struct sk_buff *skb, u16 vid)
eb1d1641 1689{
1080ab95
NA		 1690 int ret = 0;
1691
1fafc7a9
YH		 1692 BR_INPUT_SKB_CB(skb)->igmp = 0;
1693 BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
1694
13cefad2 1695 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
eb1d1641
HX		 1696 return 0;
1697
1698 switch (skb->protocol) {
1699 case htons(ETH_P_IP):
1080ab95
NA		 1700 ret = br_multicast_ipv4_rcv(br, port, skb, vid);
1701 break;
dfd56b8b 1702#if IS_ENABLED(CONFIG_IPV6)
08b202b6 1703 case htons(ETH_P_IPV6):
1080ab95
NA		 1704 ret = br_multicast_ipv6_rcv(br, port, skb, vid);
1705 break;
08b202b6 1706#endif
eb1d1641
HX		 1707 }
1708
1080ab95 1709 return ret;
eb1d1641
HX		 1710}
1711
cc0fdd80 1712static void br_multicast_query_expired(struct net_bridge *br,
2cd41431
LL		 1713 struct bridge_mcast_own_query *query,
1714 struct bridge_mcast_querier *querier)
cc0fdd80
LL		 1715{
1716 spin_lock(&br->multicast_lock);
1717 if (query->startup_sent < br->multicast_startup_query_count)
1718 query->startup_sent++;
1719
71d9f614 1720 RCU_INIT_POINTER(querier->port, NULL);
cc0fdd80
LL		 1721 br_multicast_send_query(br, NULL, query);
1722 spin_unlock(&br->multicast_lock);
1723}
1724
88c1f37f 1725static void br_ip4_multicast_query_expired(struct timer_list *t)
eb1d1641 1726{
88c1f37f 1727 struct net_bridge *br = from_timer(br, t, ip4_own_query.timer);
eb1d1641 1728
2cd41431 1729 br_multicast_query_expired(br, &br->ip4_own_query, &br->ip4_querier);
cc0fdd80 1730}
eb1d1641 1731
cc0fdd80 1732#if IS_ENABLED(CONFIG_IPV6)
88c1f37f 1733static void br_ip6_multicast_query_expired(struct timer_list *t)
cc0fdd80 1734{
88c1f37f 1735 struct net_bridge *br = from_timer(br, t, ip6_own_query.timer);
eb1d1641 1736
2cd41431 1737 br_multicast_query_expired(br, &br->ip6_own_query, &br->ip6_querier);
eb1d1641 1738}
cc0fdd80 1739#endif
eb1d1641
HX		 1740
1741void br_multicast_init(struct net_bridge *br)
1742{
d08c6bc0 1743 br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX;
eb1d1641 1744
7f0aec7a 1745 br->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
eb1d1641
HX		 1746 br->multicast_last_member_count = 2;
1747 br->multicast_startup_query_count = 2;
1748
1749 br->multicast_last_member_interval = HZ;
1750 br->multicast_query_response_interval = 10 * HZ;
1751 br->multicast_startup_query_interval = 125 * HZ / 4;
1752 br->multicast_query_interval = 125 * HZ;
1753 br->multicast_querier_interval = 255 * HZ;
1754 br->multicast_membership_interval = 260 * HZ;
1755
90010b36 1756 br->ip4_other_query.delay_time = 0;
2cd41431 1757 br->ip4_querier.port = NULL;
aa2ae3e7 1758 br->multicast_igmp_version = 2;
cc0fdd80 1759#if IS_ENABLED(CONFIG_IPV6)
aa2ae3e7 1760 br->multicast_mld_version = 1;
90010b36 1761 br->ip6_other_query.delay_time = 0;
2cd41431 1762 br->ip6_querier.port = NULL;
cc0fdd80 1763#endif
6919622a 1764 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true);
675779ad 1765 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
b00589af 1766
eb1d1641 1767 spin_lock_init(&br->multicast_lock);
88c1f37f
AP		 1768 timer_setup(&br->multicast_router_timer,
1769 br_multicast_local_router_expired, 0);
1770 timer_setup(&br->ip4_other_query.timer,
1771 br_ip4_multicast_querier_expired, 0);
1772 timer_setup(&br->ip4_own_query.timer,
1773 br_ip4_multicast_query_expired, 0);
cc0fdd80 1774#if IS_ENABLED(CONFIG_IPV6)
88c1f37f
AP		 1775 timer_setup(&br->ip6_other_query.timer,
1776 br_ip6_multicast_querier_expired, 0);
1777 timer_setup(&br->ip6_own_query.timer,
1778 br_ip6_multicast_query_expired, 0);
cc0fdd80 1779#endif
19e3a9c9 1780 INIT_HLIST_HEAD(&br->mdb_list);
eb1d1641
HX		 1781}
1782
cc0fdd80 1783static void __br_multicast_open(struct net_bridge *br,
90010b36 1784 struct bridge_mcast_own_query *query)
eb1d1641 1785{
cc0fdd80 1786 query->startup_sent = 0;
eb1d1641 1787
13cefad2 1788 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
eb1d1641
HX		 1789 return;
1790
cc0fdd80
LL		 1791 mod_timer(&query->timer, jiffies);
1792}
1793
1794void br_multicast_open(struct net_bridge *br)
1795{
90010b36 1796 __br_multicast_open(br, &br->ip4_own_query);
cc0fdd80 1797#if IS_ENABLED(CONFIG_IPV6)
90010b36 1798 __br_multicast_open(br, &br->ip6_own_query);
cc0fdd80 1799#endif
eb1d1641
HX		 1800}
1801
1802void br_multicast_stop(struct net_bridge *br)
1803{
eb1d1641 1804 del_timer_sync(&br->multicast_router_timer);
90010b36
LL		 1805 del_timer_sync(&br->ip4_other_query.timer);
1806 del_timer_sync(&br->ip4_own_query.timer);
cc0fdd80 1807#if IS_ENABLED(CONFIG_IPV6)
90010b36
LL		 1808 del_timer_sync(&br->ip6_other_query.timer);
1809 del_timer_sync(&br->ip6_own_query.timer);
cc0fdd80 1810#endif
e10177ab
SA		 1811}
1812
1813void br_multicast_dev_del(struct net_bridge *br)
1814{
e10177ab 1815 struct net_bridge_mdb_entry *mp;
19e3a9c9 1816 struct hlist_node *tmp;
eb1d1641
HX		 1817
1818 spin_lock_bh(&br->multicast_lock);
19e3a9c9
NA		 1819 hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node) {
1820 del_timer(&mp->timer);
1821 rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode,
1822 br_mdb_rht_params);
1823 hlist_del_rcu(&mp->mdb_node);
4329596c 1824 kfree_rcu(mp, rcu);
eb1d1641 1825 }
eb1d1641 1826 spin_unlock_bh(&br->multicast_lock);
19e3a9c9 1827
4329596c 1828 rcu_barrier();
eb1d1641 1829}
0909e117
HX		 1830
1831int br_multicast_set_router(struct net_bridge *br, unsigned long val)
1832{
6ae4ae8e 1833 int err = -EINVAL;
0909e117
HX		 1834
1835 spin_lock_bh(&br->multicast_lock);
0909e117
HX		 1836
1837 switch (val) {
7f0aec7a
NA		 1838 case MDB_RTR_TYPE_DISABLED:
1839 case MDB_RTR_TYPE_PERM:
77041420 1840 br_mc_router_state_change(br, val == MDB_RTR_TYPE_PERM);
0909e117 1841 del_timer(&br->multicast_router_timer);
77041420
YG		 1842 br->multicast_router = val;
1843 err = 0;
1844 break;
7f0aec7a 1845 case MDB_RTR_TYPE_TEMP_QUERY:
77041420
YG		 1846 if (br->multicast_router != MDB_RTR_TYPE_TEMP_QUERY)
1847 br_mc_router_state_change(br, false);
0909e117
HX		 1848 br->multicast_router = val;
1849 err = 0;
1850 break;
0909e117
HX		 1851 }
1852
0909e117
HX		 1853 spin_unlock_bh(&br->multicast_lock);
1854
1855 return err;
1856}
1857
7f0aec7a
NA		 1858static void __del_port_router(struct net_bridge_port *p)
1859{
1860 if (hlist_unhashed(&p->rlist))
1861 return;
1862 hlist_del_init_rcu(&p->rlist);
1863 br_rtr_notify(p->br->dev, p, RTM_DELMDB);
6d549648 1864 br_port_mc_router_state_change(p, false);
f12e7d95
NF		 1865
1866 /* don't allow timer refresh */
1867 if (p->multicast_router == MDB_RTR_TYPE_TEMP)
1868 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
7f0aec7a
NA		 1869}
1870
0909e117
HX		 1871int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val)
1872{
1873 struct net_bridge *br = p->br;
a55d8246 1874 unsigned long now = jiffies;
6ae4ae8e 1875 int err = -EINVAL;
0909e117
HX		 1876
1877 spin_lock(&br->multicast_lock);
4950cfd1 1878 if (p->multicast_router == val) {
a55d8246
NA		 1879 /* Refresh the temp router port timer */
1880 if (p->multicast_router == MDB_RTR_TYPE_TEMP)
1881 mod_timer(&p->multicast_router_timer,
1882 now + br->multicast_querier_interval);
4950cfd1
NA		 1883 err = 0;
1884 goto unlock;
1885 }
0909e117 1886 switch (val) {
7f0aec7a
NA		 1887 case MDB_RTR_TYPE_DISABLED:
1888 p->multicast_router = MDB_RTR_TYPE_DISABLED;
1889 __del_port_router(p);
1890 del_timer(&p->multicast_router_timer);
1891 break;
1892 case MDB_RTR_TYPE_TEMP_QUERY:
1893 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
1894 __del_port_router(p);
1895 break;
1896 case MDB_RTR_TYPE_PERM:
1897 p->multicast_router = MDB_RTR_TYPE_PERM;
0909e117 1898 del_timer(&p->multicast_router_timer);
0909e117
HX		 1899 br_multicast_add_router(br, p);
1900 break;
a55d8246
NA		 1901 case MDB_RTR_TYPE_TEMP:
1902 p->multicast_router = MDB_RTR_TYPE_TEMP;
1903 br_multicast_mark_router(br, p);
1904 break;
7f0aec7a
NA		 1905 default:
1906 goto unlock;
0909e117 1907 }
7f0aec7a
NA		 1908 err = 0;
1909unlock:
0909e117
HX		 1910 spin_unlock(&br->multicast_lock);
1911
1912 return err;
1913}
561f1103 1914
cc0fdd80 1915static void br_multicast_start_querier(struct net_bridge *br,
90010b36 1916 struct bridge_mcast_own_query *query)
561f1103
HX		 1917{
1918 struct net_bridge_port *port;
74857216 1919
cc0fdd80 1920 __br_multicast_open(br, query);
74857216
HX		 1921
1922 list_for_each_entry(port, &br->port_list, list) {
1923 if (port->state == BR_STATE_DISABLED ||
1924 port->state == BR_STATE_BLOCKING)
1925 continue;
1926
90010b36
LL		 1927 if (query == &br->ip4_own_query)
1928 br_multicast_enable(&port->ip4_own_query);
cc0fdd80
LL		 1929#if IS_ENABLED(CONFIG_IPV6)
1930 else
90010b36 1931 br_multicast_enable(&port->ip6_own_query);
cc0fdd80 1932#endif
74857216
HX		 1933 }
1934}
1935
1936int br_multicast_toggle(struct net_bridge *br, unsigned long val)
1937{
7cb3f921 1938 struct net_bridge_port *port;
561f1103 1939
ef5e0d82 1940 spin_lock_bh(&br->multicast_lock);
13cefad2 1941 if (!!br_opt_get(br, BROPT_MULTICAST_ENABLED) == !!val)
561f1103
HX		 1942 goto unlock;
1943
13cefad2
NA		 1944 br_mc_disabled_update(br->dev, val);
1945 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, !!val);
1946 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
561f1103
HX		 1947 goto unlock;
1948
3a7fda06
HX		 1949 if (!netif_running(br->dev))
1950 goto unlock;
1951
7cb3f921
NA		 1952 br_multicast_open(br);
1953 list_for_each_entry(port, &br->port_list, list)
1954 __br_multicast_enable_port(port);
561f1103
HX		 1955
1956unlock:
ef5e0d82 1957 spin_unlock_bh(&br->multicast_lock);
561f1103 1958
a26d94bf 1959 return 0;
561f1103 1960}
b195167f 1961
9341b988
IS		 1962bool br_multicast_enabled(const struct net_device *dev)
1963{
1964 struct net_bridge *br = netdev_priv(dev);
1965
13cefad2 1966 return !!br_opt_get(br, BROPT_MULTICAST_ENABLED);
9341b988
IS		 1967}
1968EXPORT_SYMBOL_GPL(br_multicast_enabled);
1969
0912bda4
YG		 1970bool br_multicast_router(const struct net_device *dev)
1971{
1972 struct net_bridge *br = netdev_priv(dev);
1973 bool is_router;
1974
1975 spin_lock_bh(&br->multicast_lock);
1976 is_router = br_multicast_is_router(br);
1977 spin_unlock_bh(&br->multicast_lock);
1978 return is_router;
1979}
1980EXPORT_SYMBOL_GPL(br_multicast_router);
1981
c5c23260
HX		 1982int br_multicast_set_querier(struct net_bridge *br, unsigned long val)
1983{
b00589af
LL		 1984 unsigned long max_delay;
1985
c5c23260
HX		 1986 val = !!val;
1987
1988 spin_lock_bh(&br->multicast_lock);
675779ad 1989 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) == val)
c5c23260
HX		 1990 goto unlock;
1991
675779ad 1992 br_opt_toggle(br, BROPT_MULTICAST_QUERIER, !!val);
b00589af
LL		 1993 if (!val)
1994 goto unlock;
1995
1996 max_delay = br->multicast_query_response_interval;
b00589af 1997
90010b36
LL		 1998 if (!timer_pending(&br->ip4_other_query.timer))
1999 br->ip4_other_query.delay_time = jiffies + max_delay;
cc0fdd80 2000
90010b36 2001 br_multicast_start_querier(br, &br->ip4_own_query);
cc0fdd80
LL		 2002
2003#if IS_ENABLED(CONFIG_IPV6)
90010b36
LL		 2004 if (!timer_pending(&br->ip6_other_query.timer))
2005 br->ip6_other_query.delay_time = jiffies + max_delay;
cc0fdd80 2006
90010b36 2007 br_multicast_start_querier(br, &br->ip6_own_query);
cc0fdd80 2008#endif
c5c23260
HX		 2009
2010unlock:
2011 spin_unlock_bh(&br->multicast_lock);
2012
2013 return 0;
2014}
2015
5e923585
NA		 2016int br_multicast_set_igmp_version(struct net_bridge *br, unsigned long val)
2017{
2018 /* Currently we support only version 2 and 3 */
2019 switch (val) {
2020 case 2:
2021 case 3:
2022 break;
2023 default:
2024 return -EINVAL;
2025 }
2026
2027 spin_lock_bh(&br->multicast_lock);
2028 br->multicast_igmp_version = val;
2029 spin_unlock_bh(&br->multicast_lock);
2030
2031 return 0;
2032}
2033
aa2ae3e7
NA		 2034#if IS_ENABLED(CONFIG_IPV6)
2035int br_multicast_set_mld_version(struct net_bridge *br, unsigned long val)
2036{
2037 /* Currently we support version 1 and 2 */
2038 switch (val) {
2039 case 1:
2040 case 2:
2041 break;
2042 default:
2043 return -EINVAL;
2044 }
2045
2046 spin_lock_bh(&br->multicast_lock);
2047 br->multicast_mld_version = val;
2048 spin_unlock_bh(&br->multicast_lock);
2049
2050 return 0;
2051}
2052#endif
2053
07f8ac4a
LL		 2054/**
2055 * br_multicast_list_adjacent - Returns snooped multicast addresses
2056 * @dev: The bridge port adjacent to which to retrieve addresses
2057 * @br_ip_list: The list to store found, snooped multicast IP addresses in
2058 *
2059 * Creates a list of IP addresses (struct br_ip_list) sensed by the multicast
2060 * snooping feature on all bridge ports of dev's bridge device, excluding
2061 * the addresses from dev itself.
2062 *
2063 * Returns the number of items added to br_ip_list.
2064 *
2065 * Notes:
2066 * - br_ip_list needs to be initialized by caller
2067 * - br_ip_list might contain duplicates in the end
2068 * (needs to be taken care of by caller)
2069 * - br_ip_list needs to be freed by caller
2070 */
2071int br_multicast_list_adjacent(struct net_device *dev,
2072 struct list_head *br_ip_list)
2073{
2074 struct net_bridge *br;
2075 struct net_bridge_port *port;
2076 struct net_bridge_port_group *group;
2077 struct br_ip_list *entry;
2078 int count = 0;
2079
2080 rcu_read_lock();
2081 if (!br_ip_list || !br_port_exists(dev))
2082 goto unlock;
2083
2084 port = br_port_get_rcu(dev);
2085 if (!port || !port->br)
2086 goto unlock;
2087
2088 br = port->br;
2089
2090 list_for_each_entry_rcu(port, &br->port_list, list) {
2091 if (!port->dev || port->dev == dev)
2092 continue;
2093
2094 hlist_for_each_entry_rcu(group, &port->mglist, mglist) {
2095 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
2096 if (!entry)
2097 goto unlock;
2098
2099 entry->addr = group->addr;
2100 list_add(&entry->list, br_ip_list);
2101 count++;
2102 }
2103 }
2104
2105unlock:
2106 rcu_read_unlock();
2107 return count;
2108}
2109EXPORT_SYMBOL_GPL(br_multicast_list_adjacent);
2cd41431 2110
c34963e2
LL		 2111/**
2112 * br_multicast_has_querier_anywhere - Checks for a querier on a bridge
2113 * @dev: The bridge port providing the bridge on which to check for a querier
2114 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
2115 *
2116 * Checks whether the given interface has a bridge on top and if so returns
2117 * true if a valid querier exists anywhere on the bridged link layer.
2118 * Otherwise returns false.
2119 */
2120bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto)
2121{
2122 struct net_bridge *br;
2123 struct net_bridge_port *port;
2124 struct ethhdr eth;
2125 bool ret = false;
2126
2127 rcu_read_lock();
2128 if (!br_port_exists(dev))
2129 goto unlock;
2130
2131 port = br_port_get_rcu(dev);
2132 if (!port || !port->br)
2133 goto unlock;
2134
2135 br = port->br;
2136
2137 memset(&eth, 0, sizeof(eth));
2138 eth.h_proto = htons(proto);
2139
2140 ret = br_multicast_querier_exists(br, &eth);
2141
2142unlock:
2143 rcu_read_unlock();
2144 return ret;
2145}
2146EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere);
2147
2cd41431
LL		 2148/**
2149 * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
2150 * @dev: The bridge port adjacent to which to check for a querier
2151 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
2152 *
2153 * Checks whether the given interface has a bridge on top and if so returns
2154 * true if a selected querier is behind one of the other ports of this
2155 * bridge. Otherwise returns false.
2156 */
2157bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto)
2158{
2159 struct net_bridge *br;
2160 struct net_bridge_port *port;
2161 bool ret = false;
2162
2163 rcu_read_lock();
2164 if (!br_port_exists(dev))
2165 goto unlock;
2166
2167 port = br_port_get_rcu(dev);
2168 if (!port || !port->br)
2169 goto unlock;
2170
2171 br = port->br;
2172
2173 switch (proto) {
2174 case ETH_P_IP:
2175 if (!timer_pending(&br->ip4_other_query.timer) ||
2176 rcu_dereference(br->ip4_querier.port) == port)
2177 goto unlock;
2178 break;
3993c4e1 2179#if IS_ENABLED(CONFIG_IPV6)
2cd41431
LL		 2180 case ETH_P_IPV6:
2181 if (!timer_pending(&br->ip6_other_query.timer) ||
2182 rcu_dereference(br->ip6_querier.port) == port)
2183 goto unlock;
2184 break;
3993c4e1 2185#endif
2cd41431
LL		 2186 default:
2187 goto unlock;
2188 }
2189
2190 ret = true;
2191unlock:
2192 rcu_read_unlock();
2193 return ret;
2194}
2195EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent);
1080ab95
NA		 2196
2197static void br_mcast_stats_add(struct bridge_mcast_stats __percpu *stats,
a65056ec 2198 const struct sk_buff *skb, u8 type, u8 dir)
1080ab95
NA		 2199{
2200 struct bridge_mcast_stats *pstats = this_cpu_ptr(stats);
a65056ec
NA		 2201 __be16 proto = skb->protocol;
2202 unsigned int t_len;
1080ab95
NA		 2203
2204 u64_stats_update_begin(&pstats->syncp);
2205 switch (proto) {
2206 case htons(ETH_P_IP):
a65056ec 2207 t_len = ntohs(ip_hdr(skb)->tot_len) - ip_hdrlen(skb);
1080ab95
NA		 2208 switch (type) {
2209 case IGMP_HOST_MEMBERSHIP_REPORT:
2210 pstats->mstats.igmp_v1reports[dir]++;
2211 break;
2212 case IGMPV2_HOST_MEMBERSHIP_REPORT:
2213 pstats->mstats.igmp_v2reports[dir]++;
2214 break;
2215 case IGMPV3_HOST_MEMBERSHIP_REPORT:
2216 pstats->mstats.igmp_v3reports[dir]++;
2217 break;
2218 case IGMP_HOST_MEMBERSHIP_QUERY:
a65056ec
NA		 2219 if (t_len != sizeof(struct igmphdr)) {
2220 pstats->mstats.igmp_v3queries[dir]++;
2221 } else {
2222 unsigned int offset = skb_transport_offset(skb);
2223 struct igmphdr *ih, _ihdr;
2224
2225 ih = skb_header_pointer(skb, offset,
2226 sizeof(_ihdr), &_ihdr);
2227 if (!ih)
2228 break;
2229 if (!ih->code)
2230 pstats->mstats.igmp_v1queries[dir]++;
2231 else
2232 pstats->mstats.igmp_v2queries[dir]++;
2233 }
1080ab95
NA		 2234 break;
2235 case IGMP_HOST_LEAVE_MESSAGE:
2236 pstats->mstats.igmp_leaves[dir]++;
2237 break;
2238 }
2239 break;
2240#if IS_ENABLED(CONFIG_IPV6)
2241 case htons(ETH_P_IPV6):
a65056ec
NA		 2242 t_len = ntohs(ipv6_hdr(skb)->payload_len) +
2243 sizeof(struct ipv6hdr);
2244 t_len -= skb_network_header_len(skb);
1080ab95
NA		 2245 switch (type) {
2246 case ICMPV6_MGM_REPORT:
2247 pstats->mstats.mld_v1reports[dir]++;
2248 break;
2249 case ICMPV6_MLD2_REPORT:
2250 pstats->mstats.mld_v2reports[dir]++;
2251 break;
2252 case ICMPV6_MGM_QUERY:
a65056ec
NA		 2253 if (t_len != sizeof(struct mld_msg))
2254 pstats->mstats.mld_v2queries[dir]++;
2255 else
2256 pstats->mstats.mld_v1queries[dir]++;
1080ab95
NA		 2257 break;
2258 case ICMPV6_MGM_REDUCTION:
2259 pstats->mstats.mld_leaves[dir]++;
2260 break;
2261 }
2262 break;
2263#endif /* CONFIG_IPV6 */
2264 }
2265 u64_stats_update_end(&pstats->syncp);
2266}
2267
2268void br_multicast_count(struct net_bridge *br, const struct net_bridge_port *p,
a65056ec 2269 const struct sk_buff *skb, u8 type, u8 dir)
1080ab95
NA		 2270{
2271 struct bridge_mcast_stats __percpu *stats;
2272
2273 /* if multicast_disabled is true then igmp type can't be set */
675779ad 2274 if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
1080ab95
NA		 2275 return;
2276
2277 if (p)
2278 stats = p->mcast_stats;
2279 else
2280 stats = br->mcast_stats;
2281 if (WARN_ON(!stats))
2282 return;
2283
a65056ec 2284 br_mcast_stats_add(stats, skb, type, dir);
1080ab95
NA		 2285}
2286
2287int br_multicast_init_stats(struct net_bridge *br)
2288{
2289 br->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
2290 if (!br->mcast_stats)
2291 return -ENOMEM;
2292
2293 return 0;
2294}
2295
b6fe0440
IS		 2296void br_multicast_uninit_stats(struct net_bridge *br)
2297{
2298 free_percpu(br->mcast_stats);
2299}
2300
1080ab95
NA		 2301static void mcast_stats_add_dir(u64 *dst, u64 *src)
2302{
2303 dst[BR_MCAST_DIR_RX] += src[BR_MCAST_DIR_RX];
2304 dst[BR_MCAST_DIR_TX] += src[BR_MCAST_DIR_TX];
2305}
2306
2307void br_multicast_get_stats(const struct net_bridge *br,
2308 const struct net_bridge_port *p,
2309 struct br_mcast_stats *dest)
2310{
2311 struct bridge_mcast_stats __percpu *stats;
2312 struct br_mcast_stats tdst;
2313 int i;
2314
2315 memset(dest, 0, sizeof(*dest));
2316 if (p)
2317 stats = p->mcast_stats;
2318 else
2319 stats = br->mcast_stats;
2320 if (WARN_ON(!stats))
2321 return;
2322
2323 memset(&tdst, 0, sizeof(tdst));
2324 for_each_possible_cpu(i) {
2325 struct bridge_mcast_stats *cpu_stats = per_cpu_ptr(stats, i);
2326 struct br_mcast_stats temp;
2327 unsigned int start;
2328
2329 do {
2330 start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
2331 memcpy(&temp, &cpu_stats->mstats, sizeof(temp));
2332 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
2333
a65056ec
NA		 2334 mcast_stats_add_dir(tdst.igmp_v1queries, temp.igmp_v1queries);
2335 mcast_stats_add_dir(tdst.igmp_v2queries, temp.igmp_v2queries);
2336 mcast_stats_add_dir(tdst.igmp_v3queries, temp.igmp_v3queries);
1080ab95
NA		 2337 mcast_stats_add_dir(tdst.igmp_leaves, temp.igmp_leaves);
2338 mcast_stats_add_dir(tdst.igmp_v1reports, temp.igmp_v1reports);
2339 mcast_stats_add_dir(tdst.igmp_v2reports, temp.igmp_v2reports);
2340 mcast_stats_add_dir(tdst.igmp_v3reports, temp.igmp_v3reports);
2341 tdst.igmp_parse_errors += temp.igmp_parse_errors;
2342
a65056ec
NA		 2343 mcast_stats_add_dir(tdst.mld_v1queries, temp.mld_v1queries);
2344 mcast_stats_add_dir(tdst.mld_v2queries, temp.mld_v2queries);
1080ab95
NA		 2345 mcast_stats_add_dir(tdst.mld_leaves, temp.mld_leaves);
2346 mcast_stats_add_dir(tdst.mld_v1reports, temp.mld_v1reports);
2347 mcast_stats_add_dir(tdst.mld_v2reports, temp.mld_v2reports);
2348 tdst.mld_parse_errors += temp.mld_parse_errors;
2349 }
2350 memcpy(dest, &tdst, sizeof(*dest));
2351}
19e3a9c9
NA		 2352
2353int br_mdb_hash_init(struct net_bridge *br)
2354{
2355 return rhashtable_init(&br->mdb_hash_tbl, &br_mdb_rht_params);
2356}
2357
2358void br_mdb_hash_fini(struct net_bridge *br)
2359{
2360 rhashtable_destroy(&br->mdb_hash_tbl);
2361}
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git