br_multicast.c (0f2ef911de0bdf3a0ea1d9b28e9126d3e018bbd5) br_multicast.c (ddd0d5293810c1882e2a96f8cce1678823b1dd38)
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Bridge multicast support.
4 *
5 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
6 */
7
8#include <linux/err.h>

--- 35 unchanged lines hidden (view full) ---

44
45static const struct rhashtable_params br_sg_port_rht_params = {
46 .head_offset = offsetof(struct net_bridge_port_group, rhnode),
47 .key_offset = offsetof(struct net_bridge_port_group, key),
48 .key_len = sizeof(struct net_bridge_port_group_sg_key),
49 .automatic_shrinking = true,
50};
51
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Bridge multicast support.
4 *
5 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
6 */
7
8#include <linux/err.h>

--- 35 unchanged lines hidden (view full) ---

44
45static const struct rhashtable_params br_sg_port_rht_params = {
46 .head_offset = offsetof(struct net_bridge_port_group, rhnode),
47 .key_offset = offsetof(struct net_bridge_port_group, key),
48 .key_len = sizeof(struct net_bridge_port_group_sg_key),
49 .automatic_shrinking = true,
50};
51
52static void br_multicast_start_querier(struct net_bridge *br,
52static void br_multicast_start_querier(struct net_bridge_mcast *brmctx,
53 struct bridge_mcast_own_query *query);
53 struct bridge_mcast_own_query *query);
54static void br_ip4_multicast_add_router(struct net_bridge *br,
55 struct net_bridge_port *port);
56static void br_ip4_multicast_leave_group(struct net_bridge *br,
57 struct net_bridge_port *port,
54static void br_ip4_multicast_add_router(struct net_bridge_mcast *brmctx,
55 struct net_bridge_mcast_port *pmctx);
56static void br_ip4_multicast_leave_group(struct net_bridge_mcast *brmctx,
57 struct net_bridge_mcast_port *pmctx,
58 __be32 group,
59 __u16 vid,
60 const unsigned char *src);
61static void br_multicast_port_group_rexmit(struct timer_list *t);
62
63static void
58 __be32 group,
59 __u16 vid,
60 const unsigned char *src);
61static void br_multicast_port_group_rexmit(struct timer_list *t);
62
63static void
64br_multicast_rport_del_notify(struct net_bridge_port *p, bool deleted);
65static void br_ip6_multicast_add_router(struct net_bridge *br,
66 struct net_bridge_port *port);
64br_multicast_rport_del_notify(struct net_bridge_mcast_port *pmctx, bool deleted);
65static void br_ip6_multicast_add_router(struct net_bridge_mcast *brmctx,
66 struct net_bridge_mcast_port *pmctx);
67#if IS_ENABLED(CONFIG_IPV6)
67#if IS_ENABLED(CONFIG_IPV6)
68static void br_ip6_multicast_leave_group(struct net_bridge *br,
69 struct net_bridge_port *port,
68static void br_ip6_multicast_leave_group(struct net_bridge_mcast *brmctx,
69 struct net_bridge_mcast_port *pmctx,
70 const struct in6_addr *group,
71 __u16 vid, const unsigned char *src);
72#endif
73static struct net_bridge_port_group *
70 const struct in6_addr *group,
71 __u16 vid, const unsigned char *src);
72#endif
73static struct net_bridge_port_group *
74__br_multicast_add_group(struct net_bridge *br,
75 struct net_bridge_port *port,
74__br_multicast_add_group(struct net_bridge_mcast *brmctx,
75 struct net_bridge_mcast_port *pmctx,
76 struct br_ip *group,
77 const unsigned char *src,
78 u8 filter_mode,
79 bool igmpv2_mldv1,
80 bool blocked);
81static void br_multicast_find_del_pg(struct net_bridge *br,
82 struct net_bridge_port_group *pg);
76 struct br_ip *group,
77 const unsigned char *src,
78 u8 filter_mode,
79 bool igmpv2_mldv1,
80 bool blocked);
81static void br_multicast_find_del_pg(struct net_bridge *br,
82 struct net_bridge_port_group *pg);
83static void __br_multicast_stop(struct net_bridge_mcast *brmctx);
83
84static struct net_bridge_port_group *
85br_sg_port_find(struct net_bridge *br,
86 struct net_bridge_port_group_sg_key *sg_p)
87{
88 lockdep_assert_held_once(&br->multicast_lock);
89
90 return rhashtable_lookup_fast(&br->sg_port_tbl, sg_p,

--- 44 unchanged lines hidden (view full) ---

135 br_dst.dst.ip6 = *dst;
136 br_dst.proto = htons(ETH_P_IPV6);
137 br_dst.vid = vid;
138
139 return br_mdb_ip_get(br, &br_dst);
140}
141#endif
142
84
85static struct net_bridge_port_group *
86br_sg_port_find(struct net_bridge *br,
87 struct net_bridge_port_group_sg_key *sg_p)
88{
89 lockdep_assert_held_once(&br->multicast_lock);
90
91 return rhashtable_lookup_fast(&br->sg_port_tbl, sg_p,

--- 44 unchanged lines hidden (view full) ---

136 br_dst.dst.ip6 = *dst;
137 br_dst.proto = htons(ETH_P_IPV6);
138 br_dst.vid = vid;
139
140 return br_mdb_ip_get(br, &br_dst);
141}
142#endif
143
143struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
144struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge_mcast *brmctx,
144 struct sk_buff *skb, u16 vid)
145{
145 struct sk_buff *skb, u16 vid)
146{
147 struct net_bridge *br = brmctx->br;
146 struct br_ip ip;
147
148 struct br_ip ip;
149
148 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
150 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
151 br_multicast_ctx_vlan_global_disabled(brmctx))
149 return NULL;
150
151 if (BR_INPUT_SKB_CB(skb)->igmp)
152 return NULL;
153
154 memset(&ip, 0, sizeof(ip));
155 ip.proto = skb->protocol;
156 ip.vid = vid;
157
158 switch (skb->protocol) {
159 case htons(ETH_P_IP):
160 ip.dst.ip4 = ip_hdr(skb)->daddr;
152 return NULL;
153
154 if (BR_INPUT_SKB_CB(skb)->igmp)
155 return NULL;
156
157 memset(&ip, 0, sizeof(ip));
158 ip.proto = skb->protocol;
159 ip.vid = vid;
160
161 switch (skb->protocol) {
162 case htons(ETH_P_IP):
163 ip.dst.ip4 = ip_hdr(skb)->daddr;
161 if (br->multicast_igmp_version == 3) {
164 if (brmctx->multicast_igmp_version == 3) {
162 struct net_bridge_mdb_entry *mdb;
163
164 ip.src.ip4 = ip_hdr(skb)->saddr;
165 mdb = br_mdb_ip_get_rcu(br, &ip);
166 if (mdb)
167 return mdb;
168 ip.src.ip4 = 0;
169 }
170 break;
171#if IS_ENABLED(CONFIG_IPV6)
172 case htons(ETH_P_IPV6):
173 ip.dst.ip6 = ipv6_hdr(skb)->daddr;
165 struct net_bridge_mdb_entry *mdb;
166
167 ip.src.ip4 = ip_hdr(skb)->saddr;
168 mdb = br_mdb_ip_get_rcu(br, &ip);
169 if (mdb)
170 return mdb;
171 ip.src.ip4 = 0;
172 }
173 break;
174#if IS_ENABLED(CONFIG_IPV6)
175 case htons(ETH_P_IPV6):
176 ip.dst.ip6 = ipv6_hdr(skb)->daddr;
174 if (br->multicast_mld_version == 2) {
177 if (brmctx->multicast_mld_version == 2) {
175 struct net_bridge_mdb_entry *mdb;
176
177 ip.src.ip6 = ipv6_hdr(skb)->saddr;
178 mdb = br_mdb_ip_get_rcu(br, &ip);
179 if (mdb)
180 return mdb;
181 memset(&ip.src.ip6, 0, sizeof(ip.src.ip6));
182 }
183 break;
184#endif
185 default:
186 ip.proto = 0;
187 ether_addr_copy(ip.dst.mac_addr, eth_hdr(skb)->h_dest);
188 }
189
190 return br_mdb_ip_get_rcu(br, &ip);
191}
192
178 struct net_bridge_mdb_entry *mdb;
179
180 ip.src.ip6 = ipv6_hdr(skb)->saddr;
181 mdb = br_mdb_ip_get_rcu(br, &ip);
182 if (mdb)
183 return mdb;
184 memset(&ip.src.ip6, 0, sizeof(ip.src.ip6));
185 }
186 break;
187#endif
188 default:
189 ip.proto = 0;
190 ether_addr_copy(ip.dst.mac_addr, eth_hdr(skb)->h_dest);
191 }
192
193 return br_mdb_ip_get_rcu(br, &ip);
194}
195
196/* IMPORTANT: this function must be used only when the contexts cannot be
197 * passed down (e.g. timer) and must be used for read-only purposes because
198 * the vlan snooping option can change, so it can return any context
199 * (non-vlan or vlan). Its initial intended purpose is to read timer values
200 * from the *current* context based on the option. At worst that could lead
201 * to inconsistent timers when the contexts are changed, i.e. src timer
202 * which needs to re-arm with a specific delay taken from the old context
203 */
204static struct net_bridge_mcast_port *
205br_multicast_pg_to_port_ctx(const struct net_bridge_port_group *pg)
206{
207 struct net_bridge_mcast_port *pmctx = &pg->key.port->multicast_ctx;
208 struct net_bridge_vlan *vlan;
209
210 lockdep_assert_held_once(&pg->key.port->br->multicast_lock);
211
212 /* if vlan snooping is disabled use the port's multicast context */
213 if (!pg->key.addr.vid ||
214 !br_opt_get(pg->key.port->br, BROPT_MCAST_VLAN_SNOOPING_ENABLED))
215 goto out;
216
217 /* locking is tricky here, due to different rules for multicast and
218 * vlans we need to take rcu to find the vlan and make sure it has
219 * the BR_VLFLAG_MCAST_ENABLED flag set, it can only change under
220 * multicast_lock which must be already held here, so the vlan's pmctx
221 * can safely be used on return
222 */
223 rcu_read_lock();
224 vlan = br_vlan_find(nbp_vlan_group_rcu(pg->key.port), pg->key.addr.vid);
225 if (vlan && !br_multicast_port_ctx_vlan_disabled(&vlan->port_mcast_ctx))
226 pmctx = &vlan->port_mcast_ctx;
227 else
228 pmctx = NULL;
229 rcu_read_unlock();
230out:
231 return pmctx;
232}
233
234/* when snooping we need to check if the contexts should be used
235 * in the following order:
236 * - if pmctx is non-NULL (port), check if it should be used
237 * - if pmctx is NULL (bridge), check if brmctx should be used
238 */
239static bool
240br_multicast_ctx_should_use(const struct net_bridge_mcast *brmctx,
241 const struct net_bridge_mcast_port *pmctx)
242{
243 if (!netif_running(brmctx->br->dev))
244 return false;
245
246 if (pmctx)
247 return !br_multicast_port_ctx_state_disabled(pmctx);
248 else
249 return !br_multicast_ctx_vlan_disabled(brmctx);
250}
251
193static bool br_port_group_equal(struct net_bridge_port_group *p,
194 struct net_bridge_port *port,
195 const unsigned char *src)
196{
197 if (p->key.port != port)
198 return false;
199
200 if (!(port->flags & BR_MULTICAST_TO_UNICAST))
201 return true;
202
203 return ether_addr_equal(src, p->eth_addr);
204}
205
252static bool br_port_group_equal(struct net_bridge_port_group *p,
253 struct net_bridge_port *port,
254 const unsigned char *src)
255{
256 if (p->key.port != port)
257 return false;
258
259 if (!(port->flags & BR_MULTICAST_TO_UNICAST))
260 return true;
261
262 return ether_addr_equal(src, p->eth_addr);
263}
264
206static void __fwd_add_star_excl(struct net_bridge_port_group *pg,
265static void __fwd_add_star_excl(struct net_bridge_mcast_port *pmctx,
266 struct net_bridge_port_group *pg,
207 struct br_ip *sg_ip)
208{
209 struct net_bridge_port_group_sg_key sg_key;
267 struct br_ip *sg_ip)
268{
269 struct net_bridge_port_group_sg_key sg_key;
210 struct net_bridge *br = pg->key.port->br;
211 struct net_bridge_port_group *src_pg;
270 struct net_bridge_port_group *src_pg;
271 struct net_bridge_mcast *brmctx;
212
213 memset(&sg_key, 0, sizeof(sg_key));
272
273 memset(&sg_key, 0, sizeof(sg_key));
274 brmctx = br_multicast_port_ctx_get_global(pmctx);
214 sg_key.port = pg->key.port;
215 sg_key.addr = *sg_ip;
275 sg_key.port = pg->key.port;
276 sg_key.addr = *sg_ip;
216 if (br_sg_port_find(br, &sg_key))
277 if (br_sg_port_find(brmctx->br, &sg_key))
217 return;
218
278 return;
279
219 src_pg = __br_multicast_add_group(br, pg->key.port, sg_ip, pg->eth_addr,
280 src_pg = __br_multicast_add_group(brmctx, pmctx,
281 sg_ip, pg->eth_addr,
220 MCAST_INCLUDE, false, false);
221 if (IS_ERR_OR_NULL(src_pg) ||
222 src_pg->rt_protocol != RTPROT_KERNEL)
223 return;
224
225 src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL;
226}
227

--- 23 unchanged lines hidden (view full) ---

251 * deleted we need to remove it from all ports' S,G entries where it was
252 * automatically installed before (i.e. where it's MDB_PG_FLAGS_STAR_EXCL).
253 */
254void br_multicast_star_g_handle_mode(struct net_bridge_port_group *pg,
255 u8 filter_mode)
256{
257 struct net_bridge *br = pg->key.port->br;
258 struct net_bridge_port_group *pg_lst;
282 MCAST_INCLUDE, false, false);
283 if (IS_ERR_OR_NULL(src_pg) ||
284 src_pg->rt_protocol != RTPROT_KERNEL)
285 return;
286
287 src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL;
288}
289

--- 23 unchanged lines hidden (view full) ---

313 * deleted we need to remove it from all ports' S,G entries where it was
314 * automatically installed before (i.e. where it's MDB_PG_FLAGS_STAR_EXCL).
315 */
316void br_multicast_star_g_handle_mode(struct net_bridge_port_group *pg,
317 u8 filter_mode)
318{
319 struct net_bridge *br = pg->key.port->br;
320 struct net_bridge_port_group *pg_lst;
321 struct net_bridge_mcast_port *pmctx;
259 struct net_bridge_mdb_entry *mp;
260 struct br_ip sg_ip;
261
262 if (WARN_ON(!br_multicast_is_star_g(&pg->key.addr)))
263 return;
264
265 mp = br_mdb_ip_get(br, &pg->key.addr);
266 if (!mp)
267 return;
322 struct net_bridge_mdb_entry *mp;
323 struct br_ip sg_ip;
324
325 if (WARN_ON(!br_multicast_is_star_g(&pg->key.addr)))
326 return;
327
328 mp = br_mdb_ip_get(br, &pg->key.addr);
329 if (!mp)
330 return;
331 pmctx = br_multicast_pg_to_port_ctx(pg);
332 if (!pmctx)
333 return;
268
269 memset(&sg_ip, 0, sizeof(sg_ip));
270 sg_ip = pg->key.addr;
334
335 memset(&sg_ip, 0, sizeof(sg_ip));
336 sg_ip = pg->key.addr;
337
271 for (pg_lst = mlock_dereference(mp->ports, br);
272 pg_lst;
273 pg_lst = mlock_dereference(pg_lst->next, br)) {
274 struct net_bridge_group_src *src_ent;
275
276 if (pg_lst == pg)
277 continue;
278 hlist_for_each_entry(src_ent, &pg_lst->src_list, node) {
279 if (!(src_ent->flags & BR_SGRP_F_INSTALLED))
280 continue;
281 sg_ip.src = src_ent->addr.src;
282 switch (filter_mode) {
283 case MCAST_INCLUDE:
284 __fwd_del_star_excl(pg, &sg_ip);
285 break;
286 case MCAST_EXCLUDE:
338 for (pg_lst = mlock_dereference(mp->ports, br);
339 pg_lst;
340 pg_lst = mlock_dereference(pg_lst->next, br)) {
341 struct net_bridge_group_src *src_ent;
342
343 if (pg_lst == pg)
344 continue;
345 hlist_for_each_entry(src_ent, &pg_lst->src_list, node) {
346 if (!(src_ent->flags & BR_SGRP_F_INSTALLED))
347 continue;
348 sg_ip.src = src_ent->addr.src;
349 switch (filter_mode) {
350 case MCAST_INCLUDE:
351 __fwd_del_star_excl(pg, &sg_ip);
352 break;
353 case MCAST_EXCLUDE:
287 __fwd_add_star_excl(pg, &sg_ip);
354 __fwd_add_star_excl(pmctx, pg, &sg_ip);
288 break;
289 }
290 }
291 }
292}
293
294/* called when adding a new S,G with host_joined == false by default */
295static void br_multicast_sg_host_state(struct net_bridge_mdb_entry *star_mp,

--- 76 unchanged lines hidden (view full) ---

372 }
373}
374
375void br_multicast_sg_add_exclude_ports(struct net_bridge_mdb_entry *star_mp,
376 struct net_bridge_port_group *sg)
377{
378 struct net_bridge_port_group_sg_key sg_key;
379 struct net_bridge *br = star_mp->br;
355 break;
356 }
357 }
358 }
359}
360
361/* called when adding a new S,G with host_joined == false by default */
362static void br_multicast_sg_host_state(struct net_bridge_mdb_entry *star_mp,

--- 76 unchanged lines hidden (view full) ---

439 }
440}
441
442void br_multicast_sg_add_exclude_ports(struct net_bridge_mdb_entry *star_mp,
443 struct net_bridge_port_group *sg)
444{
445 struct net_bridge_port_group_sg_key sg_key;
446 struct net_bridge *br = star_mp->br;
447 struct net_bridge_mcast_port *pmctx;
380 struct net_bridge_port_group *pg;
448 struct net_bridge_port_group *pg;
449 struct net_bridge_mcast *brmctx;
381
382 if (WARN_ON(br_multicast_is_star_g(&sg->key.addr)))
383 return;
384 if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr)))
385 return;
386
387 br_multicast_sg_host_state(star_mp, sg);
388 memset(&sg_key, 0, sizeof(sg_key));

--- 6 unchanged lines hidden (view full) ---

395
396 if (pg == sg || pg->filter_mode == MCAST_INCLUDE)
397 continue;
398
399 sg_key.port = pg->key.port;
400 if (br_sg_port_find(br, &sg_key))
401 continue;
402
450
451 if (WARN_ON(br_multicast_is_star_g(&sg->key.addr)))
452 return;
453 if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr)))
454 return;
455
456 br_multicast_sg_host_state(star_mp, sg);
457 memset(&sg_key, 0, sizeof(sg_key));

--- 6 unchanged lines hidden (view full) ---

464
465 if (pg == sg || pg->filter_mode == MCAST_INCLUDE)
466 continue;
467
468 sg_key.port = pg->key.port;
469 if (br_sg_port_find(br, &sg_key))
470 continue;
471
403 src_pg = __br_multicast_add_group(br, pg->key.port,
472 pmctx = br_multicast_pg_to_port_ctx(pg);
473 if (!pmctx)
474 continue;
475 brmctx = br_multicast_port_ctx_get_global(pmctx);
476
477 src_pg = __br_multicast_add_group(brmctx, pmctx,
404 &sg->key.addr,
405 sg->eth_addr,
406 MCAST_INCLUDE, false, false);
407 if (IS_ERR_OR_NULL(src_pg) ||
408 src_pg->rt_protocol != RTPROT_KERNEL)
409 continue;
410 src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL;
411 }
412}
413
414static void br_multicast_fwd_src_add(struct net_bridge_group_src *src)
415{
416 struct net_bridge_mdb_entry *star_mp;
478 &sg->key.addr,
479 sg->eth_addr,
480 MCAST_INCLUDE, false, false);
481 if (IS_ERR_OR_NULL(src_pg) ||
482 src_pg->rt_protocol != RTPROT_KERNEL)
483 continue;
484 src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL;
485 }
486}
487
488static void br_multicast_fwd_src_add(struct net_bridge_group_src *src)
489{
490 struct net_bridge_mdb_entry *star_mp;
491 struct net_bridge_mcast_port *pmctx;
417 struct net_bridge_port_group *sg;
492 struct net_bridge_port_group *sg;
493 struct net_bridge_mcast *brmctx;
418 struct br_ip sg_ip;
419
420 if (src->flags & BR_SGRP_F_INSTALLED)
421 return;
422
423 memset(&sg_ip, 0, sizeof(sg_ip));
494 struct br_ip sg_ip;
495
496 if (src->flags & BR_SGRP_F_INSTALLED)
497 return;
498
499 memset(&sg_ip, 0, sizeof(sg_ip));
500 pmctx = br_multicast_pg_to_port_ctx(src->pg);
501 if (!pmctx)
502 return;
503 brmctx = br_multicast_port_ctx_get_global(pmctx);
424 sg_ip = src->pg->key.addr;
425 sg_ip.src = src->addr.src;
504 sg_ip = src->pg->key.addr;
505 sg_ip.src = src->addr.src;
426 sg = __br_multicast_add_group(src->br, src->pg->key.port, &sg_ip,
506
507 sg = __br_multicast_add_group(brmctx, pmctx, &sg_ip,
427 src->pg->eth_addr, MCAST_INCLUDE, false,
428 !timer_pending(&src->timer));
429 if (IS_ERR_OR_NULL(sg))
430 return;
431 src->flags |= BR_SGRP_F_INSTALLED;
432 sg->flags &= ~MDB_PG_FLAGS_STAR_EXCL;
433
434 /* if it was added by user-space as perm we can skip next steps */

--- 252 unchanged lines hidden (view full) ---

687 struct hlist_node *tmp;
688
689 hlist_for_each_entry_safe(gcent, tmp, head, gc_node) {
690 hlist_del_init(&gcent->gc_node);
691 gcent->destroy(gcent);
692 }
693}
694
508 src->pg->eth_addr, MCAST_INCLUDE, false,
509 !timer_pending(&src->timer));
510 if (IS_ERR_OR_NULL(sg))
511 return;
512 src->flags |= BR_SGRP_F_INSTALLED;
513 sg->flags &= ~MDB_PG_FLAGS_STAR_EXCL;
514
515 /* if it was added by user-space as perm we can skip next steps */

--- 252 unchanged lines hidden (view full) ---

768 struct hlist_node *tmp;
769
770 hlist_for_each_entry_safe(gcent, tmp, head, gc_node) {
771 hlist_del_init(&gcent->gc_node);
772 gcent->destroy(gcent);
773 }
774}
775
695static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br,
776static void __br_multicast_query_handle_vlan(struct net_bridge_mcast *brmctx,
777 struct net_bridge_mcast_port *pmctx,
778 struct sk_buff *skb)
779{
780 struct net_bridge_vlan *vlan = NULL;
781
782 if (pmctx && br_multicast_port_ctx_is_vlan(pmctx))
783 vlan = pmctx->vlan;
784 else if (br_multicast_ctx_is_vlan(brmctx))
785 vlan = brmctx->vlan;
786
787 if (vlan && !(vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
788 u16 vlan_proto;
789
790 if (br_vlan_get_proto(brmctx->br->dev, &vlan_proto) != 0)
791 return;
792 __vlan_hwaccel_put_tag(skb, htons(vlan_proto), vlan->vid);
793 }
794}
795
796static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge_mcast *brmctx,
797 struct net_bridge_mcast_port *pmctx,
696 struct net_bridge_port_group *pg,
697 __be32 ip_dst, __be32 group,
698 bool with_srcs, bool over_lmqt,
699 u8 sflag, u8 *igmp_type,
700 bool *need_rexmit)
701{
702 struct net_bridge_port *p = pg ? pg->key.port : NULL;
703 struct net_bridge_group_src *ent;

--- 5 unchanged lines hidden (view full) ---

709 struct sk_buff *skb;
710 struct igmphdr *ih;
711 struct ethhdr *eth;
712 unsigned long lmqt;
713 struct iphdr *iph;
714 u16 lmqt_srcs = 0;
715
716 igmp_hdr_size = sizeof(*ih);
798 struct net_bridge_port_group *pg,
799 __be32 ip_dst, __be32 group,
800 bool with_srcs, bool over_lmqt,
801 u8 sflag, u8 *igmp_type,
802 bool *need_rexmit)
803{
804 struct net_bridge_port *p = pg ? pg->key.port : NULL;
805 struct net_bridge_group_src *ent;

--- 5 unchanged lines hidden (view full) ---

811 struct sk_buff *skb;
812 struct igmphdr *ih;
813 struct ethhdr *eth;
814 unsigned long lmqt;
815 struct iphdr *iph;
816 u16 lmqt_srcs = 0;
817
818 igmp_hdr_size = sizeof(*ih);
717 if (br->multicast_igmp_version == 3) {
819 if (brmctx->multicast_igmp_version == 3) {
718 igmp_hdr_size = sizeof(*ihv3);
719 if (pg && with_srcs) {
820 igmp_hdr_size = sizeof(*ihv3);
821 if (pg && with_srcs) {
720 lmqt = now + (br->multicast_last_member_interval *
721 br->multicast_last_member_count);
822 lmqt = now + (brmctx->multicast_last_member_interval *
823 brmctx->multicast_last_member_count);
722 hlist_for_each_entry(ent, &pg->src_list, node) {
723 if (over_lmqt == time_after(ent->timer.expires,
724 lmqt) &&
725 ent->src_query_rexmit_cnt > 0)
726 lmqt_srcs++;
727 }
728
729 if (!lmqt_srcs)
730 return NULL;
731 igmp_hdr_size += lmqt_srcs * sizeof(__be32);
732 }
733 }
734
735 pkt_size = sizeof(*eth) + sizeof(*iph) + 4 + igmp_hdr_size;
736 if ((p && pkt_size > p->dev->mtu) ||
824 hlist_for_each_entry(ent, &pg->src_list, node) {
825 if (over_lmqt == time_after(ent->timer.expires,
826 lmqt) &&
827 ent->src_query_rexmit_cnt > 0)
828 lmqt_srcs++;
829 }
830
831 if (!lmqt_srcs)
832 return NULL;
833 igmp_hdr_size += lmqt_srcs * sizeof(__be32);
834 }
835 }
836
837 pkt_size = sizeof(*eth) + sizeof(*iph) + 4 + igmp_hdr_size;
838 if ((p && pkt_size > p->dev->mtu) ||
737 pkt_size > br->dev->mtu)
839 pkt_size > brmctx->br->dev->mtu)
738 return NULL;
739
840 return NULL;
841
740 skb = netdev_alloc_skb_ip_align(br->dev, pkt_size);
842 skb = netdev_alloc_skb_ip_align(brmctx->br->dev, pkt_size);
741 if (!skb)
742 goto out;
743
843 if (!skb)
844 goto out;
845
846 __br_multicast_query_handle_vlan(brmctx, pmctx, skb);
744 skb->protocol = htons(ETH_P_IP);
745
746 skb_reset_mac_header(skb);
747 eth = eth_hdr(skb);
748
847 skb->protocol = htons(ETH_P_IP);
848
849 skb_reset_mac_header(skb);
850 eth = eth_hdr(skb);
851
749 ether_addr_copy(eth->h_source, br->dev->dev_addr);
852 ether_addr_copy(eth->h_source, brmctx->br->dev->dev_addr);
750 ip_eth_mc_map(ip_dst, eth->h_dest);
751 eth->h_proto = htons(ETH_P_IP);
752 skb_put(skb, sizeof(*eth));
753
754 skb_set_network_header(skb, skb->len);
755 iph = ip_hdr(skb);
756 iph->tot_len = htons(pkt_size - sizeof(*eth));
757
758 iph->version = 4;
759 iph->ihl = 6;
760 iph->tos = 0xc0;
761 iph->id = 0;
762 iph->frag_off = htons(IP_DF);
763 iph->ttl = 1;
764 iph->protocol = IPPROTO_IGMP;
853 ip_eth_mc_map(ip_dst, eth->h_dest);
854 eth->h_proto = htons(ETH_P_IP);
855 skb_put(skb, sizeof(*eth));
856
857 skb_set_network_header(skb, skb->len);
858 iph = ip_hdr(skb);
859 iph->tot_len = htons(pkt_size - sizeof(*eth));
860
861 iph->version = 4;
862 iph->ihl = 6;
863 iph->tos = 0xc0;
864 iph->id = 0;
865 iph->frag_off = htons(IP_DF);
866 iph->ttl = 1;
867 iph->protocol = IPPROTO_IGMP;
765 iph->saddr = br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR) ?
766 inet_select_addr(br->dev, 0, RT_SCOPE_LINK) : 0;
868 iph->saddr = br_opt_get(brmctx->br, BROPT_MULTICAST_QUERY_USE_IFADDR) ?
869 inet_select_addr(brmctx->br->dev, 0, RT_SCOPE_LINK) : 0;
767 iph->daddr = ip_dst;
768 ((u8 *)&iph[1])[0] = IPOPT_RA;
769 ((u8 *)&iph[1])[1] = 4;
770 ((u8 *)&iph[1])[2] = 0;
771 ((u8 *)&iph[1])[3] = 0;
772 ip_send_check(iph);
773 skb_put(skb, 24);
774
775 skb_set_transport_header(skb, skb->len);
776 *igmp_type = IGMP_HOST_MEMBERSHIP_QUERY;
777
870 iph->daddr = ip_dst;
871 ((u8 *)&iph[1])[0] = IPOPT_RA;
872 ((u8 *)&iph[1])[1] = 4;
873 ((u8 *)&iph[1])[2] = 0;
874 ((u8 *)&iph[1])[3] = 0;
875 ip_send_check(iph);
876 skb_put(skb, 24);
877
878 skb_set_transport_header(skb, skb->len);
879 *igmp_type = IGMP_HOST_MEMBERSHIP_QUERY;
880
778 switch (br->multicast_igmp_version) {
881 switch (brmctx->multicast_igmp_version) {
779 case 2:
780 ih = igmp_hdr(skb);
781 ih->type = IGMP_HOST_MEMBERSHIP_QUERY;
882 case 2:
883 ih = igmp_hdr(skb);
884 ih->type = IGMP_HOST_MEMBERSHIP_QUERY;
782 ih->code = (group ? br->multicast_last_member_interval :
783 br->multicast_query_response_interval) /
885 ih->code = (group ? brmctx->multicast_last_member_interval :
886 brmctx->multicast_query_response_interval) /
784 (HZ / IGMP_TIMER_SCALE);
785 ih->group = group;
786 ih->csum = 0;
787 csum = &ih->csum;
788 csum_start = (void *)ih;
789 break;
790 case 3:
791 ihv3 = igmpv3_query_hdr(skb);
792 ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY;
887 (HZ / IGMP_TIMER_SCALE);
888 ih->group = group;
889 ih->csum = 0;
890 csum = &ih->csum;
891 csum_start = (void *)ih;
892 break;
893 case 3:
894 ihv3 = igmpv3_query_hdr(skb);
895 ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY;
793 ihv3->code = (group ? br->multicast_last_member_interval :
794 br->multicast_query_response_interval) /
896 ihv3->code = (group ? brmctx->multicast_last_member_interval :
897 brmctx->multicast_query_response_interval) /
795 (HZ / IGMP_TIMER_SCALE);
796 ihv3->group = group;
898 (HZ / IGMP_TIMER_SCALE);
899 ihv3->group = group;
797 ihv3->qqic = br->multicast_query_interval / HZ;
900 ihv3->qqic = brmctx->multicast_query_interval / HZ;
798 ihv3->nsrcs = htons(lmqt_srcs);
799 ihv3->resv = 0;
800 ihv3->suppress = sflag;
801 ihv3->qrv = 2;
802 ihv3->csum = 0;
803 csum = &ihv3->csum;
804 csum_start = (void *)ihv3;
805 if (!pg || !with_srcs)

--- 26 unchanged lines hidden (view full) ---

832 skb_put(skb, igmp_hdr_size);
833 __skb_pull(skb, sizeof(*eth));
834
835out:
836 return skb;
837}
838
839#if IS_ENABLED(CONFIG_IPV6)
901 ihv3->nsrcs = htons(lmqt_srcs);
902 ihv3->resv = 0;
903 ihv3->suppress = sflag;
904 ihv3->qrv = 2;
905 ihv3->csum = 0;
906 csum = &ihv3->csum;
907 csum_start = (void *)ihv3;
908 if (!pg || !with_srcs)

--- 26 unchanged lines hidden (view full) ---

935 skb_put(skb, igmp_hdr_size);
936 __skb_pull(skb, sizeof(*eth));
937
938out:
939 return skb;
940}
941
942#if IS_ENABLED(CONFIG_IPV6)
840static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br,
943static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge_mcast *brmctx,
944 struct net_bridge_mcast_port *pmctx,
841 struct net_bridge_port_group *pg,
842 const struct in6_addr *ip6_dst,
843 const struct in6_addr *group,
844 bool with_srcs, bool over_llqt,
845 u8 sflag, u8 *igmp_type,
846 bool *need_rexmit)
847{
848 struct net_bridge_port *p = pg ? pg->key.port : NULL;

--- 8 unchanged lines hidden (view full) ---

857 struct mld_msg *mldq;
858 struct sk_buff *skb;
859 unsigned long llqt;
860 struct ethhdr *eth;
861 u16 llqt_srcs = 0;
862 u8 *hopopt;
863
864 mld_hdr_size = sizeof(*mldq);
945 struct net_bridge_port_group *pg,
946 const struct in6_addr *ip6_dst,
947 const struct in6_addr *group,
948 bool with_srcs, bool over_llqt,
949 u8 sflag, u8 *igmp_type,
950 bool *need_rexmit)
951{
952 struct net_bridge_port *p = pg ? pg->key.port : NULL;

--- 8 unchanged lines hidden (view full) ---

961 struct mld_msg *mldq;
962 struct sk_buff *skb;
963 unsigned long llqt;
964 struct ethhdr *eth;
965 u16 llqt_srcs = 0;
966 u8 *hopopt;
967
968 mld_hdr_size = sizeof(*mldq);
865 if (br->multicast_mld_version == 2) {
969 if (brmctx->multicast_mld_version == 2) {
866 mld_hdr_size = sizeof(*mld2q);
867 if (pg && with_srcs) {
970 mld_hdr_size = sizeof(*mld2q);
971 if (pg && with_srcs) {
868 llqt = now + (br->multicast_last_member_interval *
869 br->multicast_last_member_count);
972 llqt = now + (brmctx->multicast_last_member_interval *
973 brmctx->multicast_last_member_count);
870 hlist_for_each_entry(ent, &pg->src_list, node) {
871 if (over_llqt == time_after(ent->timer.expires,
872 llqt) &&
873 ent->src_query_rexmit_cnt > 0)
874 llqt_srcs++;
875 }
876
877 if (!llqt_srcs)
878 return NULL;
879 mld_hdr_size += llqt_srcs * sizeof(struct in6_addr);
880 }
881 }
882
883 pkt_size = sizeof(*eth) + sizeof(*ip6h) + 8 + mld_hdr_size;
884 if ((p && pkt_size > p->dev->mtu) ||
974 hlist_for_each_entry(ent, &pg->src_list, node) {
975 if (over_llqt == time_after(ent->timer.expires,
976 llqt) &&
977 ent->src_query_rexmit_cnt > 0)
978 llqt_srcs++;
979 }
980
981 if (!llqt_srcs)
982 return NULL;
983 mld_hdr_size += llqt_srcs * sizeof(struct in6_addr);
984 }
985 }
986
987 pkt_size = sizeof(*eth) + sizeof(*ip6h) + 8 + mld_hdr_size;
988 if ((p && pkt_size > p->dev->mtu) ||
885 pkt_size > br->dev->mtu)
989 pkt_size > brmctx->br->dev->mtu)
886 return NULL;
887
990 return NULL;
991
888 skb = netdev_alloc_skb_ip_align(br->dev, pkt_size);
992 skb = netdev_alloc_skb_ip_align(brmctx->br->dev, pkt_size);
889 if (!skb)
890 goto out;
891
993 if (!skb)
994 goto out;
995
996 __br_multicast_query_handle_vlan(brmctx, pmctx, skb);
892 skb->protocol = htons(ETH_P_IPV6);
893
894 /* Ethernet header */
895 skb_reset_mac_header(skb);
896 eth = eth_hdr(skb);
897
997 skb->protocol = htons(ETH_P_IPV6);
998
999 /* Ethernet header */
1000 skb_reset_mac_header(skb);
1001 eth = eth_hdr(skb);
1002
898 ether_addr_copy(eth->h_source, br->dev->dev_addr);
1003 ether_addr_copy(eth->h_source, brmctx->br->dev->dev_addr);
899 eth->h_proto = htons(ETH_P_IPV6);
900 skb_put(skb, sizeof(*eth));
901
902 /* IPv6 header + HbH option */
903 skb_set_network_header(skb, skb->len);
904 ip6h = ipv6_hdr(skb);
905
906 *(__force __be32 *)ip6h = htonl(0x60000000);
907 ip6h->payload_len = htons(8 + mld_hdr_size);
908 ip6h->nexthdr = IPPROTO_HOPOPTS;
909 ip6h->hop_limit = 1;
910 ip6h->daddr = *ip6_dst;
1004 eth->h_proto = htons(ETH_P_IPV6);
1005 skb_put(skb, sizeof(*eth));
1006
1007 /* IPv6 header + HbH option */
1008 skb_set_network_header(skb, skb->len);
1009 ip6h = ipv6_hdr(skb);
1010
1011 *(__force __be32 *)ip6h = htonl(0x60000000);
1012 ip6h->payload_len = htons(8 + mld_hdr_size);
1013 ip6h->nexthdr = IPPROTO_HOPOPTS;
1014 ip6h->hop_limit = 1;
1015 ip6h->daddr = *ip6_dst;
911 if (ipv6_dev_get_saddr(dev_net(br->dev), br->dev, &ip6h->daddr, 0,
912 &ip6h->saddr)) {
1016 if (ipv6_dev_get_saddr(dev_net(brmctx->br->dev), brmctx->br->dev,
1017 &ip6h->daddr, 0, &ip6h->saddr)) {
913 kfree_skb(skb);
1018 kfree_skb(skb);
914 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, false);
1019 br_opt_toggle(brmctx->br, BROPT_HAS_IPV6_ADDR, false);
915 return NULL;
916 }
917
1020 return NULL;
1021 }
1022
918 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
1023 br_opt_toggle(brmctx->br, BROPT_HAS_IPV6_ADDR, true);
919 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
920
921 hopopt = (u8 *)(ip6h + 1);
922 hopopt[0] = IPPROTO_ICMPV6; /* next hdr */
923 hopopt[1] = 0; /* length of HbH */
924 hopopt[2] = IPV6_TLV_ROUTERALERT; /* Router Alert */
925 hopopt[3] = 2; /* Length of RA Option */
926 hopopt[4] = 0; /* Type = 0x0000 (MLD) */
927 hopopt[5] = 0;
928 hopopt[6] = IPV6_TLV_PAD1; /* Pad1 */
929 hopopt[7] = IPV6_TLV_PAD1; /* Pad1 */
930
931 skb_put(skb, sizeof(*ip6h) + 8);
932
933 /* ICMPv6 */
934 skb_set_transport_header(skb, skb->len);
935 interval = ipv6_addr_any(group) ?
1024 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
1025
1026 hopopt = (u8 *)(ip6h + 1);
1027 hopopt[0] = IPPROTO_ICMPV6; /* next hdr */
1028 hopopt[1] = 0; /* length of HbH */
1029 hopopt[2] = IPV6_TLV_ROUTERALERT; /* Router Alert */
1030 hopopt[3] = 2; /* Length of RA Option */
1031 hopopt[4] = 0; /* Type = 0x0000 (MLD) */
1032 hopopt[5] = 0;
1033 hopopt[6] = IPV6_TLV_PAD1; /* Pad1 */
1034 hopopt[7] = IPV6_TLV_PAD1; /* Pad1 */
1035
1036 skb_put(skb, sizeof(*ip6h) + 8);
1037
1038 /* ICMPv6 */
1039 skb_set_transport_header(skb, skb->len);
1040 interval = ipv6_addr_any(group) ?
936 br->multicast_query_response_interval :
937 br->multicast_last_member_interval;
1041 brmctx->multicast_query_response_interval :
1042 brmctx->multicast_last_member_interval;
938 *igmp_type = ICMPV6_MGM_QUERY;
1043 *igmp_type = ICMPV6_MGM_QUERY;
939 switch (br->multicast_mld_version) {
1044 switch (brmctx->multicast_mld_version) {
940 case 1:
941 mldq = (struct mld_msg *)icmp6_hdr(skb);
942 mldq->mld_type = ICMPV6_MGM_QUERY;
943 mldq->mld_code = 0;
944 mldq->mld_cksum = 0;
945 mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval));
946 mldq->mld_reserved = 0;
947 mldq->mld_mca = *group;

--- 6 unchanged lines hidden (view full) ---

954 mld2q->mld2q_type = ICMPV6_MGM_QUERY;
955 mld2q->mld2q_code = 0;
956 mld2q->mld2q_cksum = 0;
957 mld2q->mld2q_resv1 = 0;
958 mld2q->mld2q_resv2 = 0;
959 mld2q->mld2q_suppress = sflag;
960 mld2q->mld2q_qrv = 2;
961 mld2q->mld2q_nsrcs = htons(llqt_srcs);
1045 case 1:
1046 mldq = (struct mld_msg *)icmp6_hdr(skb);
1047 mldq->mld_type = ICMPV6_MGM_QUERY;
1048 mldq->mld_code = 0;
1049 mldq->mld_cksum = 0;
1050 mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval));
1051 mldq->mld_reserved = 0;
1052 mldq->mld_mca = *group;

--- 6 unchanged lines hidden (view full) ---

1059 mld2q->mld2q_type = ICMPV6_MGM_QUERY;
1060 mld2q->mld2q_code = 0;
1061 mld2q->mld2q_cksum = 0;
1062 mld2q->mld2q_resv1 = 0;
1063 mld2q->mld2q_resv2 = 0;
1064 mld2q->mld2q_suppress = sflag;
1065 mld2q->mld2q_qrv = 2;
1066 mld2q->mld2q_nsrcs = htons(llqt_srcs);
962 mld2q->mld2q_qqic = br->multicast_query_interval / HZ;
1067 mld2q->mld2q_qqic = brmctx->multicast_query_interval / HZ;
963 mld2q->mld2q_mca = *group;
964 csum = &mld2q->mld2q_cksum;
965 csum_start = (void *)mld2q;
966 if (!pg || !with_srcs)
967 break;
968
969 llqt_srcs = 0;
970 hlist_for_each_entry(ent, &pg->src_list, node) {

--- 24 unchanged lines hidden (view full) ---

995 skb_put(skb, mld_hdr_size);
996 __skb_pull(skb, sizeof(*eth));
997
998out:
999 return skb;
1000}
1001#endif
1002
1068 mld2q->mld2q_mca = *group;
1069 csum = &mld2q->mld2q_cksum;
1070 csum_start = (void *)mld2q;
1071 if (!pg || !with_srcs)
1072 break;
1073
1074 llqt_srcs = 0;
1075 hlist_for_each_entry(ent, &pg->src_list, node) {

--- 24 unchanged lines hidden (view full) ---

1100 skb_put(skb, mld_hdr_size);
1101 __skb_pull(skb, sizeof(*eth));
1102
1103out:
1104 return skb;
1105}
1106#endif
1107
1003static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
1108static struct sk_buff *br_multicast_alloc_query(struct net_bridge_mcast *brmctx,
1109 struct net_bridge_mcast_port *pmctx,
1004 struct net_bridge_port_group *pg,
1005 struct br_ip *ip_dst,
1006 struct br_ip *group,
1007 bool with_srcs, bool over_lmqt,
1008 u8 sflag, u8 *igmp_type,
1009 bool *need_rexmit)
1010{
1011 __be32 ip4_dst;
1012
1013 switch (group->proto) {
1014 case htons(ETH_P_IP):
1015 ip4_dst = ip_dst ? ip_dst->dst.ip4 : htonl(INADDR_ALLHOSTS_GROUP);
1110 struct net_bridge_port_group *pg,
1111 struct br_ip *ip_dst,
1112 struct br_ip *group,
1113 bool with_srcs, bool over_lmqt,
1114 u8 sflag, u8 *igmp_type,
1115 bool *need_rexmit)
1116{
1117 __be32 ip4_dst;
1118
1119 switch (group->proto) {
1120 case htons(ETH_P_IP):
1121 ip4_dst = ip_dst ? ip_dst->dst.ip4 : htonl(INADDR_ALLHOSTS_GROUP);
1016 return br_ip4_multicast_alloc_query(br, pg,
1122 return br_ip4_multicast_alloc_query(brmctx, pmctx, pg,
1017 ip4_dst, group->dst.ip4,
1018 with_srcs, over_lmqt,
1019 sflag, igmp_type,
1020 need_rexmit);
1021#if IS_ENABLED(CONFIG_IPV6)
1022 case htons(ETH_P_IPV6): {
1023 struct in6_addr ip6_dst;
1024
1025 if (ip_dst)
1026 ip6_dst = ip_dst->dst.ip6;
1027 else
1028 ipv6_addr_set(&ip6_dst, htonl(0xff020000), 0, 0,
1029 htonl(1));
1030
1123 ip4_dst, group->dst.ip4,
1124 with_srcs, over_lmqt,
1125 sflag, igmp_type,
1126 need_rexmit);
1127#if IS_ENABLED(CONFIG_IPV6)
1128 case htons(ETH_P_IPV6): {
1129 struct in6_addr ip6_dst;
1130
1131 if (ip_dst)
1132 ip6_dst = ip_dst->dst.ip6;
1133 else
1134 ipv6_addr_set(&ip6_dst, htonl(0xff020000), 0, 0,
1135 htonl(1));
1136
1031 return br_ip6_multicast_alloc_query(br, pg,
1137 return br_ip6_multicast_alloc_query(brmctx, pmctx, pg,
1032 &ip6_dst, &group->dst.ip6,
1033 with_srcs, over_lmqt,
1034 sflag, igmp_type,
1035 need_rexmit);
1036 }
1037#endif
1038 }
1039 return NULL;

--- 161 unchanged lines hidden (view full) ---

1201 if (src)
1202 memcpy(p->eth_addr, src, ETH_ALEN);
1203 else
1204 eth_broadcast_addr(p->eth_addr);
1205
1206 return p;
1207}
1208
1138 &ip6_dst, &group->dst.ip6,
1139 with_srcs, over_lmqt,
1140 sflag, igmp_type,
1141 need_rexmit);
1142 }
1143#endif
1144 }
1145 return NULL;

--- 161 unchanged lines hidden (view full) ---

1307 if (src)
1308 memcpy(p->eth_addr, src, ETH_ALEN);
1309 else
1310 eth_broadcast_addr(p->eth_addr);
1311
1312 return p;
1313}
1314
1209void br_multicast_host_join(struct net_bridge_mdb_entry *mp, bool notify)
1315void br_multicast_host_join(const struct net_bridge_mcast *brmctx,
1316 struct net_bridge_mdb_entry *mp, bool notify)
1210{
1211 if (!mp->host_joined) {
1212 mp->host_joined = true;
1213 if (br_multicast_is_star_g(&mp->addr))
1214 br_multicast_star_g_host_state(mp);
1215 if (notify)
1216 br_mdb_notify(mp->br->dev, mp, NULL, RTM_NEWMDB);
1217 }
1218
1219 if (br_group_is_l2(&mp->addr))
1220 return;
1221
1317{
1318 if (!mp->host_joined) {
1319 mp->host_joined = true;
1320 if (br_multicast_is_star_g(&mp->addr))
1321 br_multicast_star_g_host_state(mp);
1322 if (notify)
1323 br_mdb_notify(mp->br->dev, mp, NULL, RTM_NEWMDB);
1324 }
1325
1326 if (br_group_is_l2(&mp->addr))
1327 return;
1328
1222 mod_timer(&mp->timer, jiffies + mp->br->multicast_membership_interval);
1329 mod_timer(&mp->timer, jiffies + brmctx->multicast_membership_interval);
1223}
1224
1225void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify)
1226{
1227 if (!mp->host_joined)
1228 return;
1229
1230 mp->host_joined = false;
1231 if (br_multicast_is_star_g(&mp->addr))
1232 br_multicast_star_g_host_state(mp);
1233 if (notify)
1234 br_mdb_notify(mp->br->dev, mp, NULL, RTM_DELMDB);
1235}
1236
1237static struct net_bridge_port_group *
1330}
1331
1332void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify)
1333{
1334 if (!mp->host_joined)
1335 return;
1336
1337 mp->host_joined = false;
1338 if (br_multicast_is_star_g(&mp->addr))
1339 br_multicast_star_g_host_state(mp);
1340 if (notify)
1341 br_mdb_notify(mp->br->dev, mp, NULL, RTM_DELMDB);
1342}
1343
1344static struct net_bridge_port_group *
1238__br_multicast_add_group(struct net_bridge *br,
1239 struct net_bridge_port *port,
1345__br_multicast_add_group(struct net_bridge_mcast *brmctx,
1346 struct net_bridge_mcast_port *pmctx,
1240 struct br_ip *group,
1241 const unsigned char *src,
1242 u8 filter_mode,
1243 bool igmpv2_mldv1,
1244 bool blocked)
1245{
1246 struct net_bridge_port_group __rcu **pp;
1247 struct net_bridge_port_group *p = NULL;
1248 struct net_bridge_mdb_entry *mp;
1249 unsigned long now = jiffies;
1250
1347 struct br_ip *group,
1348 const unsigned char *src,
1349 u8 filter_mode,
1350 bool igmpv2_mldv1,
1351 bool blocked)
1352{
1353 struct net_bridge_port_group __rcu **pp;
1354 struct net_bridge_port_group *p = NULL;
1355 struct net_bridge_mdb_entry *mp;
1356 unsigned long now = jiffies;
1357
1251 if (!netif_running(br->dev) ||
1252 (port && port->state == BR_STATE_DISABLED))
1358 if (!br_multicast_ctx_should_use(brmctx, pmctx))
1253 goto out;
1254
1359 goto out;
1360
1255 mp = br_multicast_new_group(br, group);
1361 mp = br_multicast_new_group(brmctx->br, group);
1256 if (IS_ERR(mp))
1257 return ERR_CAST(mp);
1258
1362 if (IS_ERR(mp))
1363 return ERR_CAST(mp);
1364
1259 if (!port) {
1260 br_multicast_host_join(mp, true);
1365 if (!pmctx) {
1366 br_multicast_host_join(brmctx, mp, true);
1261 goto out;
1262 }
1263
1264 for (pp = &mp->ports;
1367 goto out;
1368 }
1369
1370 for (pp = &mp->ports;
1265 (p = mlock_dereference(*pp, br)) != NULL;
1371 (p = mlock_dereference(*pp, brmctx->br)) != NULL;
1266 pp = &p->next) {
1372 pp = &p->next) {
1267 if (br_port_group_equal(p, port, src))
1373 if (br_port_group_equal(p, pmctx->port, src))
1268 goto found;
1374 goto found;
1269 if ((unsigned long)p->key.port < (unsigned long)port)
1375 if ((unsigned long)p->key.port < (unsigned long)pmctx->port)
1270 break;
1271 }
1272
1376 break;
1377 }
1378
1273 p = br_multicast_new_port_group(port, group, *pp, 0, src,
1379 p = br_multicast_new_port_group(pmctx->port, group, *pp, 0, src,
1274 filter_mode, RTPROT_KERNEL);
1275 if (unlikely(!p)) {
1276 p = ERR_PTR(-ENOMEM);
1277 goto out;
1278 }
1279 rcu_assign_pointer(*pp, p);
1280 if (blocked)
1281 p->flags |= MDB_PG_FLAGS_BLOCKED;
1380 filter_mode, RTPROT_KERNEL);
1381 if (unlikely(!p)) {
1382 p = ERR_PTR(-ENOMEM);
1383 goto out;
1384 }
1385 rcu_assign_pointer(*pp, p);
1386 if (blocked)
1387 p->flags |= MDB_PG_FLAGS_BLOCKED;
1282 br_mdb_notify(br->dev, mp, p, RTM_NEWMDB);
1388 br_mdb_notify(brmctx->br->dev, mp, p, RTM_NEWMDB);
1283
1284found:
1285 if (igmpv2_mldv1)
1389
1390found:
1391 if (igmpv2_mldv1)
1286 mod_timer(&p->timer, now + br->multicast_membership_interval);
1392 mod_timer(&p->timer,
1393 now + brmctx->multicast_membership_interval);
1287
1288out:
1289 return p;
1290}
1291
1394
1395out:
1396 return p;
1397}
1398
1292static int br_multicast_add_group(struct net_bridge *br,
1293 struct net_bridge_port *port,
1399static int br_multicast_add_group(struct net_bridge_mcast *brmctx,
1400 struct net_bridge_mcast_port *pmctx,
1294 struct br_ip *group,
1295 const unsigned char *src,
1296 u8 filter_mode,
1297 bool igmpv2_mldv1)
1298{
1299 struct net_bridge_port_group *pg;
1300 int err;
1301
1401 struct br_ip *group,
1402 const unsigned char *src,
1403 u8 filter_mode,
1404 bool igmpv2_mldv1)
1405{
1406 struct net_bridge_port_group *pg;
1407 int err;
1408
1302 spin_lock(&br->multicast_lock);
1303 pg = __br_multicast_add_group(br, port, group, src, filter_mode,
1409 spin_lock(&brmctx->br->multicast_lock);
1410 pg = __br_multicast_add_group(brmctx, pmctx, group, src, filter_mode,
1304 igmpv2_mldv1, false);
1305 /* NULL is considered valid for host joined groups */
1306 err = PTR_ERR_OR_ZERO(pg);
1411 igmpv2_mldv1, false);
1412 /* NULL is considered valid for host joined groups */
1413 err = PTR_ERR_OR_ZERO(pg);
1307 spin_unlock(&br->multicast_lock);
1414 spin_unlock(&brmctx->br->multicast_lock);
1308
1309 return err;
1310}
1311
1415
1416 return err;
1417}
1418
1312static int br_ip4_multicast_add_group(struct net_bridge *br,
1313 struct net_bridge_port *port,
1419static int br_ip4_multicast_add_group(struct net_bridge_mcast *brmctx,
1420 struct net_bridge_mcast_port *pmctx,
1314 __be32 group,
1315 __u16 vid,
1316 const unsigned char *src,
1317 bool igmpv2)
1318{
1319 struct br_ip br_group;
1320 u8 filter_mode;
1321
1322 if (ipv4_is_local_multicast(group))
1323 return 0;
1324
1325 memset(&br_group, 0, sizeof(br_group));
1326 br_group.dst.ip4 = group;
1327 br_group.proto = htons(ETH_P_IP);
1328 br_group.vid = vid;
1329 filter_mode = igmpv2 ? MCAST_EXCLUDE : MCAST_INCLUDE;
1330
1421 __be32 group,
1422 __u16 vid,
1423 const unsigned char *src,
1424 bool igmpv2)
1425{
1426 struct br_ip br_group;
1427 u8 filter_mode;
1428
1429 if (ipv4_is_local_multicast(group))
1430 return 0;
1431
1432 memset(&br_group, 0, sizeof(br_group));
1433 br_group.dst.ip4 = group;
1434 br_group.proto = htons(ETH_P_IP);
1435 br_group.vid = vid;
1436 filter_mode = igmpv2 ? MCAST_EXCLUDE : MCAST_INCLUDE;
1437
1331 return br_multicast_add_group(br, port, &br_group, src, filter_mode,
1332 igmpv2);
1438 return br_multicast_add_group(brmctx, pmctx, &br_group, src,
1439 filter_mode, igmpv2);
1333}
1334
1335#if IS_ENABLED(CONFIG_IPV6)
1440}
1441
1442#if IS_ENABLED(CONFIG_IPV6)
1336static int br_ip6_multicast_add_group(struct net_bridge *br,
1337 struct net_bridge_port *port,
1443static int br_ip6_multicast_add_group(struct net_bridge_mcast *brmctx,
1444 struct net_bridge_mcast_port *pmctx,
1338 const struct in6_addr *group,
1339 __u16 vid,
1340 const unsigned char *src,
1341 bool mldv1)
1342{
1343 struct br_ip br_group;
1344 u8 filter_mode;
1345
1346 if (ipv6_addr_is_ll_all_nodes(group))
1347 return 0;
1348
1349 memset(&br_group, 0, sizeof(br_group));
1350 br_group.dst.ip6 = *group;
1351 br_group.proto = htons(ETH_P_IPV6);
1352 br_group.vid = vid;
1353 filter_mode = mldv1 ? MCAST_EXCLUDE : MCAST_INCLUDE;
1354
1445 const struct in6_addr *group,
1446 __u16 vid,
1447 const unsigned char *src,
1448 bool mldv1)
1449{
1450 struct br_ip br_group;
1451 u8 filter_mode;
1452
1453 if (ipv6_addr_is_ll_all_nodes(group))
1454 return 0;
1455
1456 memset(&br_group, 0, sizeof(br_group));
1457 br_group.dst.ip6 = *group;
1458 br_group.proto = htons(ETH_P_IPV6);
1459 br_group.vid = vid;
1460 filter_mode = mldv1 ? MCAST_EXCLUDE : MCAST_INCLUDE;
1461
1355 return br_multicast_add_group(br, port, &br_group, src, filter_mode,
1356 mldv1);
1462 return br_multicast_add_group(brmctx, pmctx, &br_group, src,
1463 filter_mode, mldv1);
1357}
1358#endif
1359
1360static bool br_multicast_rport_del(struct hlist_node *rlist)
1361{
1362 if (hlist_unhashed(rlist))
1363 return false;
1364
1365 hlist_del_init_rcu(rlist);
1366 return true;
1367}
1368
1464}
1465#endif
1466
1467static bool br_multicast_rport_del(struct hlist_node *rlist)
1468{
1469 if (hlist_unhashed(rlist))
1470 return false;
1471
1472 hlist_del_init_rcu(rlist);
1473 return true;
1474}
1475
1369static bool br_ip4_multicast_rport_del(struct net_bridge_port *p)
1476static bool br_ip4_multicast_rport_del(struct net_bridge_mcast_port *pmctx)
1370{
1477{
1371 return br_multicast_rport_del(&p->ip4_rlist);
1478 return br_multicast_rport_del(&pmctx->ip4_rlist);
1372}
1373
1479}
1480
1374static bool br_ip6_multicast_rport_del(struct net_bridge_port *p)
1481static bool br_ip6_multicast_rport_del(struct net_bridge_mcast_port *pmctx)
1375{
1376#if IS_ENABLED(CONFIG_IPV6)
1482{
1483#if IS_ENABLED(CONFIG_IPV6)
1377 return br_multicast_rport_del(&p->ip6_rlist);
1484 return br_multicast_rport_del(&pmctx->ip6_rlist);
1378#else
1379 return false;
1380#endif
1381}
1382
1485#else
1486 return false;
1487#endif
1488}
1489
1383static void br_multicast_router_expired(struct net_bridge_port *port,
1490static void br_multicast_router_expired(struct net_bridge_mcast_port *pmctx,
1384 struct timer_list *t,
1385 struct hlist_node *rlist)
1386{
1491 struct timer_list *t,
1492 struct hlist_node *rlist)
1493{
1387 struct net_bridge *br = port->br;
1494 struct net_bridge *br = pmctx->port->br;
1388 bool del;
1389
1390 spin_lock(&br->multicast_lock);
1495 bool del;
1496
1497 spin_lock(&br->multicast_lock);
1391 if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
1392 port->multicast_router == MDB_RTR_TYPE_PERM ||
1498 if (pmctx->multicast_router == MDB_RTR_TYPE_DISABLED ||
1499 pmctx->multicast_router == MDB_RTR_TYPE_PERM ||
1393 timer_pending(t))
1394 goto out;
1395
1396 del = br_multicast_rport_del(rlist);
1500 timer_pending(t))
1501 goto out;
1502
1503 del = br_multicast_rport_del(rlist);
1397 br_multicast_rport_del_notify(port, del);
1504 br_multicast_rport_del_notify(pmctx, del);
1398out:
1399 spin_unlock(&br->multicast_lock);
1400}
1401
1402static void br_ip4_multicast_router_expired(struct timer_list *t)
1403{
1505out:
1506 spin_unlock(&br->multicast_lock);
1507}
1508
1509static void br_ip4_multicast_router_expired(struct timer_list *t)
1510{
1404 struct net_bridge_port *port = from_timer(port, t, ip4_mc_router_timer);
1511 struct net_bridge_mcast_port *pmctx = from_timer(pmctx, t,
1512 ip4_mc_router_timer);
1405
1513
1406 br_multicast_router_expired(port, t, &port->ip4_rlist);
1514 br_multicast_router_expired(pmctx, t, &pmctx->ip4_rlist);
1407}
1408
1409#if IS_ENABLED(CONFIG_IPV6)
1410static void br_ip6_multicast_router_expired(struct timer_list *t)
1411{
1515}
1516
1517#if IS_ENABLED(CONFIG_IPV6)
1518static void br_ip6_multicast_router_expired(struct timer_list *t)
1519{
1412 struct net_bridge_port *port = from_timer(port, t, ip6_mc_router_timer);
1520 struct net_bridge_mcast_port *pmctx = from_timer(pmctx, t,
1521 ip6_mc_router_timer);
1413
1522
1414 br_multicast_router_expired(port, t, &port->ip6_rlist);
1523 br_multicast_router_expired(pmctx, t, &pmctx->ip6_rlist);
1415}
1416#endif
1417
1418static void br_mc_router_state_change(struct net_bridge *p,
1419 bool is_mc_router)
1420{
1421 struct switchdev_attr attr = {
1422 .orig_dev = p->dev,
1423 .id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER,
1424 .flags = SWITCHDEV_F_DEFER,
1425 .u.mrouter = is_mc_router,
1426 };
1427
1428 switchdev_port_attr_set(p->dev, &attr, NULL);
1429}
1430
1524}
1525#endif
1526
1527static void br_mc_router_state_change(struct net_bridge *p,
1528 bool is_mc_router)
1529{
1530 struct switchdev_attr attr = {
1531 .orig_dev = p->dev,
1532 .id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER,
1533 .flags = SWITCHDEV_F_DEFER,
1534 .u.mrouter = is_mc_router,
1535 };
1536
1537 switchdev_port_attr_set(p->dev, &attr, NULL);
1538}
1539
1431static void br_multicast_local_router_expired(struct net_bridge *br,
1540static void br_multicast_local_router_expired(struct net_bridge_mcast *brmctx,
1432 struct timer_list *timer)
1433{
1541 struct timer_list *timer)
1542{
1434 spin_lock(&br->multicast_lock);
1435 if (br->multicast_router == MDB_RTR_TYPE_DISABLED ||
1436 br->multicast_router == MDB_RTR_TYPE_PERM ||
1437 br_ip4_multicast_is_router(br) ||
1438 br_ip6_multicast_is_router(br))
1543 spin_lock(&brmctx->br->multicast_lock);
1544 if (brmctx->multicast_router == MDB_RTR_TYPE_DISABLED ||
1545 brmctx->multicast_router == MDB_RTR_TYPE_PERM ||
1546 br_ip4_multicast_is_router(brmctx) ||
1547 br_ip6_multicast_is_router(brmctx))
1439 goto out;
1440
1548 goto out;
1549
1441 br_mc_router_state_change(br, false);
1550 br_mc_router_state_change(brmctx->br, false);
1442out:
1551out:
1443 spin_unlock(&br->multicast_lock);
1552 spin_unlock(&brmctx->br->multicast_lock);
1444}
1445
1446static void br_ip4_multicast_local_router_expired(struct timer_list *t)
1447{
1553}
1554
1555static void br_ip4_multicast_local_router_expired(struct timer_list *t)
1556{
1448 struct net_bridge *br = from_timer(br, t, ip4_mc_router_timer);
1557 struct net_bridge_mcast *brmctx = from_timer(brmctx, t,
1558 ip4_mc_router_timer);
1449
1559
1450 br_multicast_local_router_expired(br, t);
1560 br_multicast_local_router_expired(brmctx, t);
1451}
1452
1453#if IS_ENABLED(CONFIG_IPV6)
1454static void br_ip6_multicast_local_router_expired(struct timer_list *t)
1455{
1561}
1562
1563#if IS_ENABLED(CONFIG_IPV6)
1564static void br_ip6_multicast_local_router_expired(struct timer_list *t)
1565{
1456 struct net_bridge *br = from_timer(br, t, ip6_mc_router_timer);
1566 struct net_bridge_mcast *brmctx = from_timer(brmctx, t,
1567 ip6_mc_router_timer);
1457
1568
1458 br_multicast_local_router_expired(br, t);
1569 br_multicast_local_router_expired(brmctx, t);
1459}
1460#endif
1461
1570}
1571#endif
1572
1462static void br_multicast_querier_expired(struct net_bridge *br,
1573static void br_multicast_querier_expired(struct net_bridge_mcast *brmctx,
1463 struct bridge_mcast_own_query *query)
1464{
1574 struct bridge_mcast_own_query *query)
1575{
1465 spin_lock(&br->multicast_lock);
1466 if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
1576 spin_lock(&brmctx->br->multicast_lock);
1577 if (!netif_running(brmctx->br->dev) ||
1578 br_multicast_ctx_vlan_global_disabled(brmctx) ||
1579 !br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED))
1467 goto out;
1468
1580 goto out;
1581
1469 br_multicast_start_querier(br, query);
1582 br_multicast_start_querier(brmctx, query);
1470
1471out:
1583
1584out:
1472 spin_unlock(&br->multicast_lock);
1585 spin_unlock(&brmctx->br->multicast_lock);
1473}
1474
1475static void br_ip4_multicast_querier_expired(struct timer_list *t)
1476{
1586}
1587
1588static void br_ip4_multicast_querier_expired(struct timer_list *t)
1589{
1477 struct net_bridge *br = from_timer(br, t, ip4_other_query.timer);
1590 struct net_bridge_mcast *brmctx = from_timer(brmctx, t,
1591 ip4_other_query.timer);
1478
1592
1479 br_multicast_querier_expired(br, &br->ip4_own_query);
1593 br_multicast_querier_expired(brmctx, &brmctx->ip4_own_query);
1480}
1481
1482#if IS_ENABLED(CONFIG_IPV6)
1483static void br_ip6_multicast_querier_expired(struct timer_list *t)
1484{
1594}
1595
1596#if IS_ENABLED(CONFIG_IPV6)
1597static void br_ip6_multicast_querier_expired(struct timer_list *t)
1598{
1485 struct net_bridge *br = from_timer(br, t, ip6_other_query.timer);
1599 struct net_bridge_mcast *brmctx = from_timer(brmctx, t,
1600 ip6_other_query.timer);
1486
1601
1487 br_multicast_querier_expired(br, &br->ip6_own_query);
1602 br_multicast_querier_expired(brmctx, &brmctx->ip6_own_query);
1488}
1489#endif
1490
1603}
1604#endif
1605
1491static void br_multicast_select_own_querier(struct net_bridge *br,
1606static void br_multicast_select_own_querier(struct net_bridge_mcast *brmctx,
1492 struct br_ip *ip,
1493 struct sk_buff *skb)
1494{
1495 if (ip->proto == htons(ETH_P_IP))
1607 struct br_ip *ip,
1608 struct sk_buff *skb)
1609{
1610 if (ip->proto == htons(ETH_P_IP))
1496 br->ip4_querier.addr.src.ip4 = ip_hdr(skb)->saddr;
1611 brmctx->ip4_querier.addr.src.ip4 = ip_hdr(skb)->saddr;
1497#if IS_ENABLED(CONFIG_IPV6)
1498 else
1612#if IS_ENABLED(CONFIG_IPV6)
1613 else
1499 br->ip6_querier.addr.src.ip6 = ipv6_hdr(skb)->saddr;
1614 brmctx->ip6_querier.addr.src.ip6 = ipv6_hdr(skb)->saddr;
1500#endif
1501}
1502
1615#endif
1616}
1617
1503static void __br_multicast_send_query(struct net_bridge *br,
1504 struct net_bridge_port *port,
1618static void __br_multicast_send_query(struct net_bridge_mcast *brmctx,
1619 struct net_bridge_mcast_port *pmctx,
1505 struct net_bridge_port_group *pg,
1506 struct br_ip *ip_dst,
1507 struct br_ip *group,
1508 bool with_srcs,
1509 u8 sflag,
1510 bool *need_rexmit)
1511{
1512 bool over_lmqt = !!sflag;
1513 struct sk_buff *skb;
1514 u8 igmp_type;
1515
1620 struct net_bridge_port_group *pg,
1621 struct br_ip *ip_dst,
1622 struct br_ip *group,
1623 bool with_srcs,
1624 u8 sflag,
1625 bool *need_rexmit)
1626{
1627 bool over_lmqt = !!sflag;
1628 struct sk_buff *skb;
1629 u8 igmp_type;
1630
1631 if (!br_multicast_ctx_should_use(brmctx, pmctx) ||
1632 !br_multicast_ctx_matches_vlan_snooping(brmctx))
1633 return;
1634
1516again_under_lmqt:
1635again_under_lmqt:
1517 skb = br_multicast_alloc_query(br, pg, ip_dst, group, with_srcs,
1518 over_lmqt, sflag, &igmp_type,
1636 skb = br_multicast_alloc_query(brmctx, pmctx, pg, ip_dst, group,
1637 with_srcs, over_lmqt, sflag, &igmp_type,
1519 need_rexmit);
1520 if (!skb)
1521 return;
1522
1638 need_rexmit);
1639 if (!skb)
1640 return;
1641
1523 if (port) {
1524 skb->dev = port->dev;
1525 br_multicast_count(br, port, skb, igmp_type,
1642 if (pmctx) {
1643 skb->dev = pmctx->port->dev;
1644 br_multicast_count(brmctx->br, pmctx->port, skb, igmp_type,
1526 BR_MCAST_DIR_TX);
1527 NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT,
1645 BR_MCAST_DIR_TX);
1646 NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT,
1528 dev_net(port->dev), NULL, skb, NULL, skb->dev,
1647 dev_net(pmctx->port->dev), NULL, skb, NULL, skb->dev,
1529 br_dev_queue_push_xmit);
1530
1531 if (over_lmqt && with_srcs && sflag) {
1532 over_lmqt = false;
1533 goto again_under_lmqt;
1534 }
1535 } else {
1648 br_dev_queue_push_xmit);
1649
1650 if (over_lmqt && with_srcs && sflag) {
1651 over_lmqt = false;
1652 goto again_under_lmqt;
1653 }
1654 } else {
1536 br_multicast_select_own_querier(br, group, skb);
1537 br_multicast_count(br, port, skb, igmp_type,
1655 br_multicast_select_own_querier(brmctx, group, skb);
1656 br_multicast_count(brmctx->br, NULL, skb, igmp_type,
1538 BR_MCAST_DIR_RX);
1539 netif_rx(skb);
1540 }
1541}
1542
1657 BR_MCAST_DIR_RX);
1658 netif_rx(skb);
1659 }
1660}
1661
1543static void br_multicast_send_query(struct net_bridge *br,
1544 struct net_bridge_port *port,
1662static void br_multicast_read_querier(const struct bridge_mcast_querier *querier,
1663 struct bridge_mcast_querier *dest)
1664{
1665 unsigned int seq;
1666
1667 memset(dest, 0, sizeof(*dest));
1668 do {
1669 seq = read_seqcount_begin(&querier->seq);
1670 dest->port_ifidx = querier->port_ifidx;
1671 memcpy(&dest->addr, &querier->addr, sizeof(struct br_ip));
1672 } while (read_seqcount_retry(&querier->seq, seq));
1673}
1674
1675static void br_multicast_update_querier(struct net_bridge_mcast *brmctx,
1676 struct bridge_mcast_querier *querier,
1677 int ifindex,
1678 struct br_ip *saddr)
1679{
1680 lockdep_assert_held_once(&brmctx->br->multicast_lock);
1681
1682 write_seqcount_begin(&querier->seq);
1683 querier->port_ifidx = ifindex;
1684 memcpy(&querier->addr, saddr, sizeof(*saddr));
1685 write_seqcount_end(&querier->seq);
1686}
1687
1688static void br_multicast_send_query(struct net_bridge_mcast *brmctx,
1689 struct net_bridge_mcast_port *pmctx,
1545 struct bridge_mcast_own_query *own_query)
1546{
1547 struct bridge_mcast_other_query *other_query = NULL;
1690 struct bridge_mcast_own_query *own_query)
1691{
1692 struct bridge_mcast_other_query *other_query = NULL;
1693 struct bridge_mcast_querier *querier;
1548 struct br_ip br_group;
1549 unsigned long time;
1550
1694 struct br_ip br_group;
1695 unsigned long time;
1696
1551 if (!netif_running(br->dev) ||
1552 !br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
1553 !br_opt_get(br, BROPT_MULTICAST_QUERIER))
1697 if (!br_multicast_ctx_should_use(brmctx, pmctx) ||
1698 !br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED) ||
1699 !brmctx->multicast_querier)
1554 return;
1555
1556 memset(&br_group.dst, 0, sizeof(br_group.dst));
1557
1700 return;
1701
1702 memset(&br_group.dst, 0, sizeof(br_group.dst));
1703
1558 if (port ? (own_query == &port->ip4_own_query) :
1559 (own_query == &br->ip4_own_query)) {
1560 other_query = &br->ip4_other_query;
1704 if (pmctx ? (own_query == &pmctx->ip4_own_query) :
1705 (own_query == &brmctx->ip4_own_query)) {
1706 querier = &brmctx->ip4_querier;
1707 other_query = &brmctx->ip4_other_query;
1561 br_group.proto = htons(ETH_P_IP);
1562#if IS_ENABLED(CONFIG_IPV6)
1563 } else {
1708 br_group.proto = htons(ETH_P_IP);
1709#if IS_ENABLED(CONFIG_IPV6)
1710 } else {
1564 other_query = &br->ip6_other_query;
1711 querier = &brmctx->ip6_querier;
1712 other_query = &brmctx->ip6_other_query;
1565 br_group.proto = htons(ETH_P_IPV6);
1566#endif
1567 }
1568
1569 if (!other_query || timer_pending(&other_query->timer))
1570 return;
1571
1713 br_group.proto = htons(ETH_P_IPV6);
1714#endif
1715 }
1716
1717 if (!other_query || timer_pending(&other_query->timer))
1718 return;
1719
1572 __br_multicast_send_query(br, port, NULL, NULL, &br_group, false, 0,
1573 NULL);
1720 /* we're about to select ourselves as querier */
1721 if (!pmctx && querier->port_ifidx) {
1722 struct br_ip zeroip = {};
1574
1723
1724 br_multicast_update_querier(brmctx, querier, 0, &zeroip);
1725 }
1726
1727 __br_multicast_send_query(brmctx, pmctx, NULL, NULL, &br_group, false,
1728 0, NULL);
1729
1575 time = jiffies;
1730 time = jiffies;
1576 time += own_query->startup_sent < br->multicast_startup_query_count ?
1577 br->multicast_startup_query_interval :
1578 br->multicast_query_interval;
1731 time += own_query->startup_sent < brmctx->multicast_startup_query_count ?
1732 brmctx->multicast_startup_query_interval :
1733 brmctx->multicast_query_interval;
1579 mod_timer(&own_query->timer, time);
1580}
1581
1582static void
1734 mod_timer(&own_query->timer, time);
1735}
1736
1737static void
1583br_multicast_port_query_expired(struct net_bridge_port *port,
1738br_multicast_port_query_expired(struct net_bridge_mcast_port *pmctx,
1584 struct bridge_mcast_own_query *query)
1585{
1739 struct bridge_mcast_own_query *query)
1740{
1586 struct net_bridge *br = port->br;
1741 struct net_bridge *br = pmctx->port->br;
1742 struct net_bridge_mcast *brmctx;
1587
1588 spin_lock(&br->multicast_lock);
1743
1744 spin_lock(&br->multicast_lock);
1589 if (port->state == BR_STATE_DISABLED ||
1590 port->state == BR_STATE_BLOCKING)
1745 if (br_multicast_port_ctx_state_stopped(pmctx))
1591 goto out;
1592
1746 goto out;
1747
1593 if (query->startup_sent < br->multicast_startup_query_count)
1748 brmctx = br_multicast_port_ctx_get_global(pmctx);
1749 if (query->startup_sent < brmctx->multicast_startup_query_count)
1594 query->startup_sent++;
1595
1750 query->startup_sent++;
1751
1596 br_multicast_send_query(port->br, port, query);
1752 br_multicast_send_query(brmctx, pmctx, query);
1597
1598out:
1599 spin_unlock(&br->multicast_lock);
1600}
1601
1602static void br_ip4_multicast_port_query_expired(struct timer_list *t)
1603{
1753
1754out:
1755 spin_unlock(&br->multicast_lock);
1756}
1757
1758static void br_ip4_multicast_port_query_expired(struct timer_list *t)
1759{
1604 struct net_bridge_port *port = from_timer(port, t, ip4_own_query.timer);
1760 struct net_bridge_mcast_port *pmctx = from_timer(pmctx, t,
1761 ip4_own_query.timer);
1605
1762
1606 br_multicast_port_query_expired(port, &port->ip4_own_query);
1763 br_multicast_port_query_expired(pmctx, &pmctx->ip4_own_query);
1607}
1608
1609#if IS_ENABLED(CONFIG_IPV6)
1610static void br_ip6_multicast_port_query_expired(struct timer_list *t)
1611{
1764}
1765
1766#if IS_ENABLED(CONFIG_IPV6)
1767static void br_ip6_multicast_port_query_expired(struct timer_list *t)
1768{
1612 struct net_bridge_port *port = from_timer(port, t, ip6_own_query.timer);
1769 struct net_bridge_mcast_port *pmctx = from_timer(pmctx, t,
1770 ip6_own_query.timer);
1613
1771
1614 br_multicast_port_query_expired(port, &port->ip6_own_query);
1772 br_multicast_port_query_expired(pmctx, &pmctx->ip6_own_query);
1615}
1616#endif
1617
1618static void br_multicast_port_group_rexmit(struct timer_list *t)
1619{
1620 struct net_bridge_port_group *pg = from_timer(pg, t, rexmit_timer);
1621 struct bridge_mcast_other_query *other_query = NULL;
1622 struct net_bridge *br = pg->key.port->br;
1773}
1774#endif
1775
1776static void br_multicast_port_group_rexmit(struct timer_list *t)
1777{
1778 struct net_bridge_port_group *pg = from_timer(pg, t, rexmit_timer);
1779 struct bridge_mcast_other_query *other_query = NULL;
1780 struct net_bridge *br = pg->key.port->br;
1781 struct net_bridge_mcast_port *pmctx;
1782 struct net_bridge_mcast *brmctx;
1623 bool need_rexmit = false;
1624
1625 spin_lock(&br->multicast_lock);
1626 if (!netif_running(br->dev) || hlist_unhashed(&pg->mglist) ||
1783 bool need_rexmit = false;
1784
1785 spin_lock(&br->multicast_lock);
1786 if (!netif_running(br->dev) || hlist_unhashed(&pg->mglist) ||
1627 !br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
1628 !br_opt_get(br, BROPT_MULTICAST_QUERIER))
1787 !br_opt_get(br, BROPT_MULTICAST_ENABLED))
1629 goto out;
1630
1788 goto out;
1789
1790 pmctx = br_multicast_pg_to_port_ctx(pg);
1791 if (!pmctx)
1792 goto out;
1793 brmctx = br_multicast_port_ctx_get_global(pmctx);
1794 if (!brmctx->multicast_querier)
1795 goto out;
1796
1631 if (pg->key.addr.proto == htons(ETH_P_IP))
1797 if (pg->key.addr.proto == htons(ETH_P_IP))
1632 other_query = &br->ip4_other_query;
1798 other_query = &brmctx->ip4_other_query;
1633#if IS_ENABLED(CONFIG_IPV6)
1634 else
1799#if IS_ENABLED(CONFIG_IPV6)
1800 else
1635 other_query = &br->ip6_other_query;
1801 other_query = &brmctx->ip6_other_query;
1636#endif
1637
1638 if (!other_query || timer_pending(&other_query->timer))
1639 goto out;
1640
1641 if (pg->grp_query_rexmit_cnt) {
1642 pg->grp_query_rexmit_cnt--;
1802#endif
1803
1804 if (!other_query || timer_pending(&other_query->timer))
1805 goto out;
1806
1807 if (pg->grp_query_rexmit_cnt) {
1808 pg->grp_query_rexmit_cnt--;
1643 __br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
1809 __br_multicast_send_query(brmctx, pmctx, pg, &pg->key.addr,
1644 &pg->key.addr, false, 1, NULL);
1645 }
1810 &pg->key.addr, false, 1, NULL);
1811 }
1646 __br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
1812 __br_multicast_send_query(brmctx, pmctx, pg, &pg->key.addr,
1647 &pg->key.addr, true, 0, &need_rexmit);
1648
1649 if (pg->grp_query_rexmit_cnt || need_rexmit)
1650 mod_timer(&pg->rexmit_timer, jiffies +
1813 &pg->key.addr, true, 0, &need_rexmit);
1814
1815 if (pg->grp_query_rexmit_cnt || need_rexmit)
1816 mod_timer(&pg->rexmit_timer, jiffies +
1651 br->multicast_last_member_interval);
1817 brmctx->multicast_last_member_interval);
1652out:
1653 spin_unlock(&br->multicast_lock);
1654}
1655
1656static int br_mc_disabled_update(struct net_device *dev, bool value,
1657 struct netlink_ext_ack *extack)
1658{
1659 struct switchdev_attr attr = {
1660 .orig_dev = dev,
1661 .id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED,
1662 .flags = SWITCHDEV_F_DEFER,
1663 .u.mc_disabled = !value,
1664 };
1665
1666 return switchdev_port_attr_set(dev, &attr, extack);
1667}
1668
1818out:
1819 spin_unlock(&br->multicast_lock);
1820}
1821
1822static int br_mc_disabled_update(struct net_device *dev, bool value,
1823 struct netlink_ext_ack *extack)
1824{
1825 struct switchdev_attr attr = {
1826 .orig_dev = dev,
1827 .id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED,
1828 .flags = SWITCHDEV_F_DEFER,
1829 .u.mc_disabled = !value,
1830 };
1831
1832 return switchdev_port_attr_set(dev, &attr, extack);
1833}
1834
1669int br_multicast_add_port(struct net_bridge_port *port)
1835void br_multicast_port_ctx_init(struct net_bridge_port *port,
1836 struct net_bridge_vlan *vlan,
1837 struct net_bridge_mcast_port *pmctx)
1670{
1838{
1671 int err;
1672
1673 port->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
1674 port->multicast_eht_hosts_limit = BR_MCAST_DEFAULT_EHT_HOSTS_LIMIT;
1675
1676 timer_setup(&port->ip4_mc_router_timer,
1839 pmctx->port = port;
1840 pmctx->vlan = vlan;
1841 pmctx->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
1842 timer_setup(&pmctx->ip4_mc_router_timer,
1677 br_ip4_multicast_router_expired, 0);
1843 br_ip4_multicast_router_expired, 0);
1678 timer_setup(&port->ip4_own_query.timer,
1844 timer_setup(&pmctx->ip4_own_query.timer,
1679 br_ip4_multicast_port_query_expired, 0);
1680#if IS_ENABLED(CONFIG_IPV6)
1845 br_ip4_multicast_port_query_expired, 0);
1846#if IS_ENABLED(CONFIG_IPV6)
1681 timer_setup(&port->ip6_mc_router_timer,
1847 timer_setup(&pmctx->ip6_mc_router_timer,
1682 br_ip6_multicast_router_expired, 0);
1848 br_ip6_multicast_router_expired, 0);
1683 timer_setup(&port->ip6_own_query.timer,
1849 timer_setup(&pmctx->ip6_own_query.timer,
1684 br_ip6_multicast_port_query_expired, 0);
1685#endif
1850 br_ip6_multicast_port_query_expired, 0);
1851#endif
1852}
1853
1854void br_multicast_port_ctx_deinit(struct net_bridge_mcast_port *pmctx)
1855{
1856#if IS_ENABLED(CONFIG_IPV6)
1857 del_timer_sync(&pmctx->ip6_mc_router_timer);
1858#endif
1859 del_timer_sync(&pmctx->ip4_mc_router_timer);
1860}
1861
1862int br_multicast_add_port(struct net_bridge_port *port)
1863{
1864 int err;
1865
1866 port->multicast_eht_hosts_limit = BR_MCAST_DEFAULT_EHT_HOSTS_LIMIT;
1867 br_multicast_port_ctx_init(port, NULL, &port->multicast_ctx);
1868
1686 err = br_mc_disabled_update(port->dev,
1687 br_opt_get(port->br,
1688 BROPT_MULTICAST_ENABLED),
1689 NULL);
1690 if (err && err != -EOPNOTSUPP)
1691 return err;
1692
1693 port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);

--- 12 unchanged lines hidden (view full) ---

1706
1707 /* Take care of the remaining groups, only perm ones should be left */
1708 spin_lock_bh(&br->multicast_lock);
1709 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
1710 br_multicast_find_del_pg(br, pg);
1711 hlist_move_list(&br->mcast_gc_list, &deleted_head);
1712 spin_unlock_bh(&br->multicast_lock);
1713 br_multicast_gc(&deleted_head);
1869 err = br_mc_disabled_update(port->dev,
1870 br_opt_get(port->br,
1871 BROPT_MULTICAST_ENABLED),
1872 NULL);
1873 if (err && err != -EOPNOTSUPP)
1874 return err;
1875
1876 port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);

--- 12 unchanged lines hidden (view full) ---

1889
1890 /* Take care of the remaining groups, only perm ones should be left */
1891 spin_lock_bh(&br->multicast_lock);
1892 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
1893 br_multicast_find_del_pg(br, pg);
1894 hlist_move_list(&br->mcast_gc_list, &deleted_head);
1895 spin_unlock_bh(&br->multicast_lock);
1896 br_multicast_gc(&deleted_head);
1714 del_timer_sync(&port->ip4_mc_router_timer);
1715#if IS_ENABLED(CONFIG_IPV6)
1716 del_timer_sync(&port->ip6_mc_router_timer);
1717#endif
1897 br_multicast_port_ctx_deinit(&port->multicast_ctx);
1718 free_percpu(port->mcast_stats);
1719}
1720
1721static void br_multicast_enable(struct bridge_mcast_own_query *query)
1722{
1723 query->startup_sent = 0;
1724
1725 if (try_to_del_timer_sync(&query->timer) >= 0 ||
1726 del_timer(&query->timer))
1727 mod_timer(&query->timer, jiffies);
1728}
1729
1898 free_percpu(port->mcast_stats);
1899}
1900
1901static void br_multicast_enable(struct bridge_mcast_own_query *query)
1902{
1903 query->startup_sent = 0;
1904
1905 if (try_to_del_timer_sync(&query->timer) >= 0 ||
1906 del_timer(&query->timer))
1907 mod_timer(&query->timer, jiffies);
1908}
1909
1730static void __br_multicast_enable_port(struct net_bridge_port *port)
1910static void __br_multicast_enable_port_ctx(struct net_bridge_mcast_port *pmctx)
1731{
1911{
1732 struct net_bridge *br = port->br;
1912 struct net_bridge *br = pmctx->port->br;
1913 struct net_bridge_mcast *brmctx;
1733
1914
1734 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || !netif_running(br->dev))
1915 brmctx = br_multicast_port_ctx_get_global(pmctx);
1916 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
1917 !netif_running(br->dev))
1735 return;
1736
1918 return;
1919
1737 br_multicast_enable(&port->ip4_own_query);
1920 br_multicast_enable(&pmctx->ip4_own_query);
1738#if IS_ENABLED(CONFIG_IPV6)
1921#if IS_ENABLED(CONFIG_IPV6)
1739 br_multicast_enable(&port->ip6_own_query);
1922 br_multicast_enable(&pmctx->ip6_own_query);
1740#endif
1923#endif
1741 if (port->multicast_router == MDB_RTR_TYPE_PERM) {
1742 br_ip4_multicast_add_router(br, port);
1743 br_ip6_multicast_add_router(br, port);
1924 if (pmctx->multicast_router == MDB_RTR_TYPE_PERM) {
1925 br_ip4_multicast_add_router(brmctx, pmctx);
1926 br_ip6_multicast_add_router(brmctx, pmctx);
1744 }
1745}
1746
1747void br_multicast_enable_port(struct net_bridge_port *port)
1748{
1749 struct net_bridge *br = port->br;
1750
1927 }
1928}
1929
1930void br_multicast_enable_port(struct net_bridge_port *port)
1931{
1932 struct net_bridge *br = port->br;
1933
1751 spin_lock(&br->multicast_lock);
1752 __br_multicast_enable_port(port);
1753 spin_unlock(&br->multicast_lock);
1934 spin_lock_bh(&br->multicast_lock);
1935 __br_multicast_enable_port_ctx(&port->multicast_ctx);
1936 spin_unlock_bh(&br->multicast_lock);
1754}
1755
1937}
1938
1756void br_multicast_disable_port(struct net_bridge_port *port)
1939static void __br_multicast_disable_port_ctx(struct net_bridge_mcast_port *pmctx)
1757{
1940{
1758 struct net_bridge *br = port->br;
1759 struct net_bridge_port_group *pg;
1760 struct hlist_node *n;
1761 bool del = false;
1762
1941 struct net_bridge_port_group *pg;
1942 struct hlist_node *n;
1943 bool del = false;
1944
1763 spin_lock(&br->multicast_lock);
1764 hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
1765 if (!(pg->flags & MDB_PG_FLAGS_PERMANENT))
1766 br_multicast_find_del_pg(br, pg);
1945 hlist_for_each_entry_safe(pg, n, &pmctx->port->mglist, mglist)
1946 if (!(pg->flags & MDB_PG_FLAGS_PERMANENT) &&
1947 (!br_multicast_port_ctx_is_vlan(pmctx) ||
1948 pg->key.addr.vid == pmctx->vlan->vid))
1949 br_multicast_find_del_pg(pmctx->port->br, pg);
1767
1950
1768 del |= br_ip4_multicast_rport_del(port);
1769 del_timer(&port->ip4_mc_router_timer);
1770 del_timer(&port->ip4_own_query.timer);
1771 del |= br_ip6_multicast_rport_del(port);
1951 del |= br_ip4_multicast_rport_del(pmctx);
1952 del_timer(&pmctx->ip4_mc_router_timer);
1953 del_timer(&pmctx->ip4_own_query.timer);
1954 del |= br_ip6_multicast_rport_del(pmctx);
1772#if IS_ENABLED(CONFIG_IPV6)
1955#if IS_ENABLED(CONFIG_IPV6)
1773 del_timer(&port->ip6_mc_router_timer);
1774 del_timer(&port->ip6_own_query.timer);
1956 del_timer(&pmctx->ip6_mc_router_timer);
1957 del_timer(&pmctx->ip6_own_query.timer);
1775#endif
1958#endif
1776 br_multicast_rport_del_notify(port, del);
1777 spin_unlock(&br->multicast_lock);
1959 br_multicast_rport_del_notify(pmctx, del);
1778}
1779
1960}
1961
1962void br_multicast_disable_port(struct net_bridge_port *port)
1963{
1964 spin_lock_bh(&port->br->multicast_lock);
1965 __br_multicast_disable_port_ctx(&port->multicast_ctx);
1966 spin_unlock_bh(&port->br->multicast_lock);
1967}
1968
1780static int __grp_src_delete_marked(struct net_bridge_port_group *pg)
1781{
1782 struct net_bridge_group_src *ent;
1783 struct hlist_node *tmp;
1784 int deleted = 0;
1785
1786 hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
1787 if (ent->flags & BR_SGRP_F_DELETE) {

--- 6 unchanged lines hidden (view full) ---

1794
1795static void __grp_src_mod_timer(struct net_bridge_group_src *src,
1796 unsigned long expires)
1797{
1798 mod_timer(&src->timer, expires);
1799 br_multicast_fwd_src_handle(src);
1800}
1801
1969static int __grp_src_delete_marked(struct net_bridge_port_group *pg)
1970{
1971 struct net_bridge_group_src *ent;
1972 struct hlist_node *tmp;
1973 int deleted = 0;
1974
1975 hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
1976 if (ent->flags & BR_SGRP_F_DELETE) {

--- 6 unchanged lines hidden (view full) ---

1983
1984static void __grp_src_mod_timer(struct net_bridge_group_src *src,
1985 unsigned long expires)
1986{
1987 mod_timer(&src->timer, expires);
1988 br_multicast_fwd_src_handle(src);
1989}
1990
1802static void __grp_src_query_marked_and_rexmit(struct net_bridge_port_group *pg)
1991static void __grp_src_query_marked_and_rexmit(struct net_bridge_mcast *brmctx,
1992 struct net_bridge_mcast_port *pmctx,
1993 struct net_bridge_port_group *pg)
1803{
1804 struct bridge_mcast_other_query *other_query = NULL;
1994{
1995 struct bridge_mcast_other_query *other_query = NULL;
1805 struct net_bridge *br = pg->key.port->br;
1806 u32 lmqc = br->multicast_last_member_count;
1996 u32 lmqc = brmctx->multicast_last_member_count;
1807 unsigned long lmqt, lmi, now = jiffies;
1808 struct net_bridge_group_src *ent;
1809
1997 unsigned long lmqt, lmi, now = jiffies;
1998 struct net_bridge_group_src *ent;
1999
1810 if (!netif_running(br->dev) ||
1811 !br_opt_get(br, BROPT_MULTICAST_ENABLED))
2000 if (!netif_running(brmctx->br->dev) ||
2001 !br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED))
1812 return;
1813
1814 if (pg->key.addr.proto == htons(ETH_P_IP))
2002 return;
2003
2004 if (pg->key.addr.proto == htons(ETH_P_IP))
1815 other_query = &br->ip4_other_query;
2005 other_query = &brmctx->ip4_other_query;
1816#if IS_ENABLED(CONFIG_IPV6)
1817 else
2006#if IS_ENABLED(CONFIG_IPV6)
2007 else
1818 other_query = &br->ip6_other_query;
2008 other_query = &brmctx->ip6_other_query;
1819#endif
1820
2009#endif
2010
1821 lmqt = now + br_multicast_lmqt(br);
2011 lmqt = now + br_multicast_lmqt(brmctx);
1822 hlist_for_each_entry(ent, &pg->src_list, node) {
1823 if (ent->flags & BR_SGRP_F_SEND) {
1824 ent->flags &= ~BR_SGRP_F_SEND;
1825 if (ent->timer.expires > lmqt) {
2012 hlist_for_each_entry(ent, &pg->src_list, node) {
2013 if (ent->flags & BR_SGRP_F_SEND) {
2014 ent->flags &= ~BR_SGRP_F_SEND;
2015 if (ent->timer.expires > lmqt) {
1826 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) &&
2016 if (brmctx->multicast_querier &&
1827 other_query &&
1828 !timer_pending(&other_query->timer))
1829 ent->src_query_rexmit_cnt = lmqc;
1830 __grp_src_mod_timer(ent, lmqt);
1831 }
1832 }
1833 }
1834
2017 other_query &&
2018 !timer_pending(&other_query->timer))
2019 ent->src_query_rexmit_cnt = lmqc;
2020 __grp_src_mod_timer(ent, lmqt);
2021 }
2022 }
2023 }
2024
1835 if (!br_opt_get(br, BROPT_MULTICAST_QUERIER) ||
2025 if (!brmctx->multicast_querier ||
1836 !other_query || timer_pending(&other_query->timer))
1837 return;
1838
2026 !other_query || timer_pending(&other_query->timer))
2027 return;
2028
1839 __br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
2029 __br_multicast_send_query(brmctx, pmctx, pg, &pg->key.addr,
1840 &pg->key.addr, true, 1, NULL);
1841
2030 &pg->key.addr, true, 1, NULL);
2031
1842 lmi = now + br->multicast_last_member_interval;
2032 lmi = now + brmctx->multicast_last_member_interval;
1843 if (!timer_pending(&pg->rexmit_timer) ||
1844 time_after(pg->rexmit_timer.expires, lmi))
1845 mod_timer(&pg->rexmit_timer, lmi);
1846}
1847
2033 if (!timer_pending(&pg->rexmit_timer) ||
2034 time_after(pg->rexmit_timer.expires, lmi))
2035 mod_timer(&pg->rexmit_timer, lmi);
2036}
2037
1848static void __grp_send_query_and_rexmit(struct net_bridge_port_group *pg)
2038static void __grp_send_query_and_rexmit(struct net_bridge_mcast *brmctx,
2039 struct net_bridge_mcast_port *pmctx,
2040 struct net_bridge_port_group *pg)
1849{
1850 struct bridge_mcast_other_query *other_query = NULL;
2041{
2042 struct bridge_mcast_other_query *other_query = NULL;
1851 struct net_bridge *br = pg->key.port->br;
1852 unsigned long now = jiffies, lmi;
1853
2043 unsigned long now = jiffies, lmi;
2044
1854 if (!netif_running(br->dev) ||
1855 !br_opt_get(br, BROPT_MULTICAST_ENABLED))
2045 if (!netif_running(brmctx->br->dev) ||
2046 !br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED))
1856 return;
1857
1858 if (pg->key.addr.proto == htons(ETH_P_IP))
2047 return;
2048
2049 if (pg->key.addr.proto == htons(ETH_P_IP))
1859 other_query = &br->ip4_other_query;
2050 other_query = &brmctx->ip4_other_query;
1860#if IS_ENABLED(CONFIG_IPV6)
1861 else
2051#if IS_ENABLED(CONFIG_IPV6)
2052 else
1862 other_query = &br->ip6_other_query;
2053 other_query = &brmctx->ip6_other_query;
1863#endif
1864
2054#endif
2055
1865 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) &&
2056 if (brmctx->multicast_querier &&
1866 other_query && !timer_pending(&other_query->timer)) {
2057 other_query && !timer_pending(&other_query->timer)) {
1867 lmi = now + br->multicast_last_member_interval;
1868 pg->grp_query_rexmit_cnt = br->multicast_last_member_count - 1;
1869 __br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
2058 lmi = now + brmctx->multicast_last_member_interval;
2059 pg->grp_query_rexmit_cnt = brmctx->multicast_last_member_count - 1;
2060 __br_multicast_send_query(brmctx, pmctx, pg, &pg->key.addr,
1870 &pg->key.addr, false, 0, NULL);
1871 if (!timer_pending(&pg->rexmit_timer) ||
1872 time_after(pg->rexmit_timer.expires, lmi))
1873 mod_timer(&pg->rexmit_timer, lmi);
1874 }
1875
1876 if (pg->filter_mode == MCAST_EXCLUDE &&
1877 (!timer_pending(&pg->timer) ||
2061 &pg->key.addr, false, 0, NULL);
2062 if (!timer_pending(&pg->rexmit_timer) ||
2063 time_after(pg->rexmit_timer.expires, lmi))
2064 mod_timer(&pg->rexmit_timer, lmi);
2065 }
2066
2067 if (pg->filter_mode == MCAST_EXCLUDE &&
2068 (!timer_pending(&pg->timer) ||
1878 time_after(pg->timer.expires, now + br_multicast_lmqt(br))))
1879 mod_timer(&pg->timer, now + br_multicast_lmqt(br));
2069 time_after(pg->timer.expires, now + br_multicast_lmqt(brmctx))))
2070 mod_timer(&pg->timer, now + br_multicast_lmqt(brmctx));
1880}
1881
1882/* State Msg type New state Actions
1883 * INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI
1884 * INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI
1885 * EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI
1886 */
2071}
2072
2073/* State Msg type New state Actions
2074 * INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI
2075 * INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI
2076 * EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI
2077 */
1887static bool br_multicast_isinc_allow(struct net_bridge_port_group *pg, void *h_addr,
2078static bool br_multicast_isinc_allow(const struct net_bridge_mcast *brmctx,
2079 struct net_bridge_port_group *pg, void *h_addr,
1888 void *srcs, u32 nsrcs, size_t addr_size,
1889 int grec_type)
1890{
2080 void *srcs, u32 nsrcs, size_t addr_size,
2081 int grec_type)
2082{
1891 struct net_bridge *br = pg->key.port->br;
1892 struct net_bridge_group_src *ent;
1893 unsigned long now = jiffies;
1894 bool changed = false;
1895 struct br_ip src_ip;
1896 u32 src_idx;
1897
1898 memset(&src_ip, 0, sizeof(src_ip));
1899 src_ip.proto = pg->key.addr.proto;
1900 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
1901 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
1902 ent = br_multicast_find_group_src(pg, &src_ip);
1903 if (!ent) {
1904 ent = br_multicast_new_group_src(pg, &src_ip);
1905 if (ent)
1906 changed = true;
1907 }
1908
1909 if (ent)
2083 struct net_bridge_group_src *ent;
2084 unsigned long now = jiffies;
2085 bool changed = false;
2086 struct br_ip src_ip;
2087 u32 src_idx;
2088
2089 memset(&src_ip, 0, sizeof(src_ip));
2090 src_ip.proto = pg->key.addr.proto;
2091 for (src_idx = 0; src_idx < nsrcs; src_idx++) {
2092 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
2093 ent = br_multicast_find_group_src(pg, &src_ip);
2094 if (!ent) {
2095 ent = br_multicast_new_group_src(pg, &src_ip);
2096 if (ent)
2097 changed = true;
2098 }
2099
2100 if (ent)
1910 __grp_src_mod_timer(ent, now + br_multicast_gmi(br));
2101 __grp_src_mod_timer(ent, now + br_multicast_gmi(brmctx));
1911 }
1912
2102 }
2103
1913 if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
2104 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2105 grec_type))
1914 changed = true;
1915
1916 return changed;
1917}
1918
1919/* State Msg type New state Actions
1920 * INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
1921 * Delete (A-B)
1922 * Group Timer=GMI
1923 */
2106 changed = true;
2107
2108 return changed;
2109}
2110
2111/* State Msg type New state Actions
2112 * INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
2113 * Delete (A-B)
2114 * Group Timer=GMI
2115 */
1924static void __grp_src_isexc_incl(struct net_bridge_port_group *pg, void *h_addr,
2116static void __grp_src_isexc_incl(const struct net_bridge_mcast *brmctx,
2117 struct net_bridge_port_group *pg, void *h_addr,
1925 void *srcs, u32 nsrcs, size_t addr_size,
1926 int grec_type)
1927{
1928 struct net_bridge_group_src *ent;
1929 struct br_ip src_ip;
1930 u32 src_idx;
1931
1932 hlist_for_each_entry(ent, &pg->src_list, node)

--- 7 unchanged lines hidden (view full) ---

1940 if (ent)
1941 ent->flags &= ~BR_SGRP_F_DELETE;
1942 else
1943 ent = br_multicast_new_group_src(pg, &src_ip);
1944 if (ent)
1945 br_multicast_fwd_src_handle(ent);
1946 }
1947
2118 void *srcs, u32 nsrcs, size_t addr_size,
2119 int grec_type)
2120{
2121 struct net_bridge_group_src *ent;
2122 struct br_ip src_ip;
2123 u32 src_idx;
2124
2125 hlist_for_each_entry(ent, &pg->src_list, node)

--- 7 unchanged lines hidden (view full) ---

2133 if (ent)
2134 ent->flags &= ~BR_SGRP_F_DELETE;
2135 else
2136 ent = br_multicast_new_group_src(pg, &src_ip);
2137 if (ent)
2138 br_multicast_fwd_src_handle(ent);
2139 }
2140
1948 br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type);
2141 br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2142 grec_type);
1949
1950 __grp_src_delete_marked(pg);
1951}
1952
1953/* State Msg type New state Actions
1954 * EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI
1955 * Delete (X-A)
1956 * Delete (Y-A)
1957 * Group Timer=GMI
1958 */
2143
2144 __grp_src_delete_marked(pg);
2145}
2146
2147/* State Msg type New state Actions
2148 * EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI
2149 * Delete (X-A)
2150 * Delete (Y-A)
2151 * Group Timer=GMI
2152 */
1959static bool __grp_src_isexc_excl(struct net_bridge_port_group *pg, void *h_addr,
2153static bool __grp_src_isexc_excl(const struct net_bridge_mcast *brmctx,
2154 struct net_bridge_port_group *pg, void *h_addr,
1960 void *srcs, u32 nsrcs, size_t addr_size,
1961 int grec_type)
1962{
2155 void *srcs, u32 nsrcs, size_t addr_size,
2156 int grec_type)
2157{
1963 struct net_bridge *br = pg->key.port->br;
1964 struct net_bridge_group_src *ent;
1965 unsigned long now = jiffies;
1966 bool changed = false;
1967 struct br_ip src_ip;
1968 u32 src_idx;
1969
1970 hlist_for_each_entry(ent, &pg->src_list, node)
1971 ent->flags |= BR_SGRP_F_DELETE;

--- 4 unchanged lines hidden (view full) ---

1976 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
1977 ent = br_multicast_find_group_src(pg, &src_ip);
1978 if (ent) {
1979 ent->flags &= ~BR_SGRP_F_DELETE;
1980 } else {
1981 ent = br_multicast_new_group_src(pg, &src_ip);
1982 if (ent) {
1983 __grp_src_mod_timer(ent,
2158 struct net_bridge_group_src *ent;
2159 unsigned long now = jiffies;
2160 bool changed = false;
2161 struct br_ip src_ip;
2162 u32 src_idx;
2163
2164 hlist_for_each_entry(ent, &pg->src_list, node)
2165 ent->flags |= BR_SGRP_F_DELETE;

--- 4 unchanged lines hidden (view full) ---

2170 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
2171 ent = br_multicast_find_group_src(pg, &src_ip);
2172 if (ent) {
2173 ent->flags &= ~BR_SGRP_F_DELETE;
2174 } else {
2175 ent = br_multicast_new_group_src(pg, &src_ip);
2176 if (ent) {
2177 __grp_src_mod_timer(ent,
1984 now + br_multicast_gmi(br));
2178 now + br_multicast_gmi(brmctx));
1985 changed = true;
1986 }
1987 }
1988 }
1989
2179 changed = true;
2180 }
2181 }
2182 }
2183
1990 if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
2184 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2185 grec_type))
1991 changed = true;
1992
1993 if (__grp_src_delete_marked(pg))
1994 changed = true;
1995
1996 return changed;
1997}
1998
2186 changed = true;
2187
2188 if (__grp_src_delete_marked(pg))
2189 changed = true;
2190
2191 return changed;
2192}
2193
1999static bool br_multicast_isexc(struct net_bridge_port_group *pg, void *h_addr,
2194static bool br_multicast_isexc(const struct net_bridge_mcast *brmctx,
2195 struct net_bridge_port_group *pg, void *h_addr,
2000 void *srcs, u32 nsrcs, size_t addr_size,
2001 int grec_type)
2002{
2196 void *srcs, u32 nsrcs, size_t addr_size,
2197 int grec_type)
2198{
2003 struct net_bridge *br = pg->key.port->br;
2004 bool changed = false;
2005
2006 switch (pg->filter_mode) {
2007 case MCAST_INCLUDE:
2199 bool changed = false;
2200
2201 switch (pg->filter_mode) {
2202 case MCAST_INCLUDE:
2008 __grp_src_isexc_incl(pg, h_addr, srcs, nsrcs, addr_size,
2203 __grp_src_isexc_incl(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2009 grec_type);
2010 br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE);
2011 changed = true;
2012 break;
2013 case MCAST_EXCLUDE:
2204 grec_type);
2205 br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE);
2206 changed = true;
2207 break;
2208 case MCAST_EXCLUDE:
2014 changed = __grp_src_isexc_excl(pg, h_addr, srcs, nsrcs, addr_size,
2015 grec_type);
2209 changed = __grp_src_isexc_excl(brmctx, pg, h_addr, srcs, nsrcs,
2210 addr_size, grec_type);
2016 break;
2017 }
2018
2019 pg->filter_mode = MCAST_EXCLUDE;
2211 break;
2212 }
2213
2214 pg->filter_mode = MCAST_EXCLUDE;
2020 mod_timer(&pg->timer, jiffies + br_multicast_gmi(br));
2215 mod_timer(&pg->timer, jiffies + br_multicast_gmi(brmctx));
2021
2022 return changed;
2023}
2024
2025/* State Msg type New state Actions
2026 * INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI
2027 * Send Q(G,A-B)
2028 */
2216
2217 return changed;
2218}
2219
2220/* State Msg type New state Actions
2221 * INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI
2222 * Send Q(G,A-B)
2223 */
2029static bool __grp_src_toin_incl(struct net_bridge_port_group *pg, void *h_addr,
2224static bool __grp_src_toin_incl(struct net_bridge_mcast *brmctx,
2225 struct net_bridge_mcast_port *pmctx,
2226 struct net_bridge_port_group *pg, void *h_addr,
2030 void *srcs, u32 nsrcs, size_t addr_size,
2031 int grec_type)
2032{
2227 void *srcs, u32 nsrcs, size_t addr_size,
2228 int grec_type)
2229{
2033 struct net_bridge *br = pg->key.port->br;
2034 u32 src_idx, to_send = pg->src_ents;
2035 struct net_bridge_group_src *ent;
2036 unsigned long now = jiffies;
2037 bool changed = false;
2038 struct br_ip src_ip;
2039
2040 hlist_for_each_entry(ent, &pg->src_list, node)
2041 ent->flags |= BR_SGRP_F_SEND;

--- 7 unchanged lines hidden (view full) ---

2049 ent->flags &= ~BR_SGRP_F_SEND;
2050 to_send--;
2051 } else {
2052 ent = br_multicast_new_group_src(pg, &src_ip);
2053 if (ent)
2054 changed = true;
2055 }
2056 if (ent)
2230 u32 src_idx, to_send = pg->src_ents;
2231 struct net_bridge_group_src *ent;
2232 unsigned long now = jiffies;
2233 bool changed = false;
2234 struct br_ip src_ip;
2235
2236 hlist_for_each_entry(ent, &pg->src_list, node)
2237 ent->flags |= BR_SGRP_F_SEND;

--- 7 unchanged lines hidden (view full) ---

2245 ent->flags &= ~BR_SGRP_F_SEND;
2246 to_send--;
2247 } else {
2248 ent = br_multicast_new_group_src(pg, &src_ip);
2249 if (ent)
2250 changed = true;
2251 }
2252 if (ent)
2057 __grp_src_mod_timer(ent, now + br_multicast_gmi(br));
2253 __grp_src_mod_timer(ent, now + br_multicast_gmi(brmctx));
2058 }
2059
2254 }
2255
2060 if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
2256 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2257 grec_type))
2061 changed = true;
2062
2063 if (to_send)
2258 changed = true;
2259
2260 if (to_send)
2064 __grp_src_query_marked_and_rexmit(pg);
2261 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg);
2065
2066 return changed;
2067}
2068
2069/* State Msg type New state Actions
2070 * EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI
2071 * Send Q(G,X-A)
2072 * Send Q(G)
2073 */
2262
2263 return changed;
2264}
2265
2266/* State Msg type New state Actions
2267 * EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI
2268 * Send Q(G,X-A)
2269 * Send Q(G)
2270 */
2074static bool __grp_src_toin_excl(struct net_bridge_port_group *pg, void *h_addr,
2271static bool __grp_src_toin_excl(struct net_bridge_mcast *brmctx,
2272 struct net_bridge_mcast_port *pmctx,
2273 struct net_bridge_port_group *pg, void *h_addr,
2075 void *srcs, u32 nsrcs, size_t addr_size,
2076 int grec_type)
2077{
2274 void *srcs, u32 nsrcs, size_t addr_size,
2275 int grec_type)
2276{
2078 struct net_bridge *br = pg->key.port->br;
2079 u32 src_idx, to_send = pg->src_ents;
2080 struct net_bridge_group_src *ent;
2081 unsigned long now = jiffies;
2082 bool changed = false;
2083 struct br_ip src_ip;
2084
2085 hlist_for_each_entry(ent, &pg->src_list, node)
2086 if (timer_pending(&ent->timer))

--- 10 unchanged lines hidden (view full) ---

2097 to_send--;
2098 }
2099 } else {
2100 ent = br_multicast_new_group_src(pg, &src_ip);
2101 if (ent)
2102 changed = true;
2103 }
2104 if (ent)
2277 u32 src_idx, to_send = pg->src_ents;
2278 struct net_bridge_group_src *ent;
2279 unsigned long now = jiffies;
2280 bool changed = false;
2281 struct br_ip src_ip;
2282
2283 hlist_for_each_entry(ent, &pg->src_list, node)
2284 if (timer_pending(&ent->timer))

--- 10 unchanged lines hidden (view full) ---

2295 to_send--;
2296 }
2297 } else {
2298 ent = br_multicast_new_group_src(pg, &src_ip);
2299 if (ent)
2300 changed = true;
2301 }
2302 if (ent)
2105 __grp_src_mod_timer(ent, now + br_multicast_gmi(br));
2303 __grp_src_mod_timer(ent, now + br_multicast_gmi(brmctx));
2106 }
2107
2304 }
2305
2108 if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
2306 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2307 grec_type))
2109 changed = true;
2110
2111 if (to_send)
2308 changed = true;
2309
2310 if (to_send)
2112 __grp_src_query_marked_and_rexmit(pg);
2311 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg);
2113
2312
2114 __grp_send_query_and_rexmit(pg);
2313 __grp_send_query_and_rexmit(brmctx, pmctx, pg);
2115
2116 return changed;
2117}
2118
2314
2315 return changed;
2316}
2317
2119static bool br_multicast_toin(struct net_bridge_port_group *pg, void *h_addr,
2318static bool br_multicast_toin(struct net_bridge_mcast *brmctx,
2319 struct net_bridge_mcast_port *pmctx,
2320 struct net_bridge_port_group *pg, void *h_addr,
2120 void *srcs, u32 nsrcs, size_t addr_size,
2121 int grec_type)
2122{
2123 bool changed = false;
2124
2125 switch (pg->filter_mode) {
2126 case MCAST_INCLUDE:
2321 void *srcs, u32 nsrcs, size_t addr_size,
2322 int grec_type)
2323{
2324 bool changed = false;
2325
2326 switch (pg->filter_mode) {
2327 case MCAST_INCLUDE:
2127 changed = __grp_src_toin_incl(pg, h_addr, srcs, nsrcs, addr_size,
2128 grec_type);
2328 changed = __grp_src_toin_incl(brmctx, pmctx, pg, h_addr, srcs,
2329 nsrcs, addr_size, grec_type);
2129 break;
2130 case MCAST_EXCLUDE:
2330 break;
2331 case MCAST_EXCLUDE:
2131 changed = __grp_src_toin_excl(pg, h_addr, srcs, nsrcs, addr_size,
2132 grec_type);
2332 changed = __grp_src_toin_excl(brmctx, pmctx, pg, h_addr, srcs,
2333 nsrcs, addr_size, grec_type);
2133 break;
2134 }
2135
2136 if (br_multicast_eht_should_del_pg(pg)) {
2137 pg->flags |= MDB_PG_FLAGS_FAST_LEAVE;
2138 br_multicast_find_del_pg(pg->key.port->br, pg);
2139 /* a notification has already been sent and we shouldn't
2140 * access pg after the delete so we have to return false

--- 5 unchanged lines hidden (view full) ---

2146}
2147
2148/* State Msg type New state Actions
2149 * INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
2150 * Delete (A-B)
2151 * Send Q(G,A*B)
2152 * Group Timer=GMI
2153 */
2334 break;
2335 }
2336
2337 if (br_multicast_eht_should_del_pg(pg)) {
2338 pg->flags |= MDB_PG_FLAGS_FAST_LEAVE;
2339 br_multicast_find_del_pg(pg->key.port->br, pg);
2340 /* a notification has already been sent and we shouldn't
2341 * access pg after the delete so we have to return false

--- 5 unchanged lines hidden (view full) ---

2347}
2348
2349/* State Msg type New state Actions
2350 * INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
2351 * Delete (A-B)
2352 * Send Q(G,A*B)
2353 * Group Timer=GMI
2354 */
2154static void __grp_src_toex_incl(struct net_bridge_port_group *pg, void *h_addr,
2355static void __grp_src_toex_incl(struct net_bridge_mcast *brmctx,
2356 struct net_bridge_mcast_port *pmctx,
2357 struct net_bridge_port_group *pg, void *h_addr,
2155 void *srcs, u32 nsrcs, size_t addr_size,
2156 int grec_type)
2157{
2158 struct net_bridge_group_src *ent;
2159 u32 src_idx, to_send = 0;
2160 struct br_ip src_ip;
2161
2162 hlist_for_each_entry(ent, &pg->src_list, node)

--- 10 unchanged lines hidden (view full) ---

2173 to_send++;
2174 } else {
2175 ent = br_multicast_new_group_src(pg, &src_ip);
2176 }
2177 if (ent)
2178 br_multicast_fwd_src_handle(ent);
2179 }
2180
2358 void *srcs, u32 nsrcs, size_t addr_size,
2359 int grec_type)
2360{
2361 struct net_bridge_group_src *ent;
2362 u32 src_idx, to_send = 0;
2363 struct br_ip src_ip;
2364
2365 hlist_for_each_entry(ent, &pg->src_list, node)

--- 10 unchanged lines hidden (view full) ---

2376 to_send++;
2377 } else {
2378 ent = br_multicast_new_group_src(pg, &src_ip);
2379 }
2380 if (ent)
2381 br_multicast_fwd_src_handle(ent);
2382 }
2383
2181 br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type);
2384 br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2385 grec_type);
2182
2183 __grp_src_delete_marked(pg);
2184 if (to_send)
2386
2387 __grp_src_delete_marked(pg);
2388 if (to_send)
2185 __grp_src_query_marked_and_rexmit(pg);
2389 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg);
2186}
2187
2188/* State Msg type New state Actions
2189 * EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer
2190 * Delete (X-A)
2191 * Delete (Y-A)
2192 * Send Q(G,A-Y)
2193 * Group Timer=GMI
2194 */
2390}
2391
2392/* State Msg type New state Actions
2393 * EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer
2394 * Delete (X-A)
2395 * Delete (Y-A)
2396 * Send Q(G,A-Y)
2397 * Group Timer=GMI
2398 */
2195static bool __grp_src_toex_excl(struct net_bridge_port_group *pg, void *h_addr,
2399static bool __grp_src_toex_excl(struct net_bridge_mcast *brmctx,
2400 struct net_bridge_mcast_port *pmctx,
2401 struct net_bridge_port_group *pg, void *h_addr,
2196 void *srcs, u32 nsrcs, size_t addr_size,
2197 int grec_type)
2198{
2199 struct net_bridge_group_src *ent;
2200 u32 src_idx, to_send = 0;
2201 bool changed = false;
2202 struct br_ip src_ip;
2203

--- 15 unchanged lines hidden (view full) ---

2219 }
2220 }
2221 if (ent && timer_pending(&ent->timer)) {
2222 ent->flags |= BR_SGRP_F_SEND;
2223 to_send++;
2224 }
2225 }
2226
2402 void *srcs, u32 nsrcs, size_t addr_size,
2403 int grec_type)
2404{
2405 struct net_bridge_group_src *ent;
2406 u32 src_idx, to_send = 0;
2407 bool changed = false;
2408 struct br_ip src_ip;
2409

--- 15 unchanged lines hidden (view full) ---

2425 }
2426 }
2427 if (ent && timer_pending(&ent->timer)) {
2428 ent->flags |= BR_SGRP_F_SEND;
2429 to_send++;
2430 }
2431 }
2432
2227 if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
2433 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2434 grec_type))
2228 changed = true;
2229
2230 if (__grp_src_delete_marked(pg))
2231 changed = true;
2232 if (to_send)
2435 changed = true;
2436
2437 if (__grp_src_delete_marked(pg))
2438 changed = true;
2439 if (to_send)
2233 __grp_src_query_marked_and_rexmit(pg);
2440 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg);
2234
2235 return changed;
2236}
2237
2441
2442 return changed;
2443}
2444
2238static bool br_multicast_toex(struct net_bridge_port_group *pg, void *h_addr,
2445static bool br_multicast_toex(struct net_bridge_mcast *brmctx,
2446 struct net_bridge_mcast_port *pmctx,
2447 struct net_bridge_port_group *pg, void *h_addr,
2239 void *srcs, u32 nsrcs, size_t addr_size,
2240 int grec_type)
2241{
2448 void *srcs, u32 nsrcs, size_t addr_size,
2449 int grec_type)
2450{
2242 struct net_bridge *br = pg->key.port->br;
2243 bool changed = false;
2244
2245 switch (pg->filter_mode) {
2246 case MCAST_INCLUDE:
2451 bool changed = false;
2452
2453 switch (pg->filter_mode) {
2454 case MCAST_INCLUDE:
2247 __grp_src_toex_incl(pg, h_addr, srcs, nsrcs, addr_size,
2248 grec_type);
2455 __grp_src_toex_incl(brmctx, pmctx, pg, h_addr, srcs, nsrcs,
2456 addr_size, grec_type);
2249 br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE);
2250 changed = true;
2251 break;
2252 case MCAST_EXCLUDE:
2457 br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE);
2458 changed = true;
2459 break;
2460 case MCAST_EXCLUDE:
2253 changed = __grp_src_toex_excl(pg, h_addr, srcs, nsrcs, addr_size,
2254 grec_type);
2461 changed = __grp_src_toex_excl(brmctx, pmctx, pg, h_addr, srcs,
2462 nsrcs, addr_size, grec_type);
2255 break;
2256 }
2257
2258 pg->filter_mode = MCAST_EXCLUDE;
2463 break;
2464 }
2465
2466 pg->filter_mode = MCAST_EXCLUDE;
2259 mod_timer(&pg->timer, jiffies + br_multicast_gmi(br));
2467 mod_timer(&pg->timer, jiffies + br_multicast_gmi(brmctx));
2260
2261 return changed;
2262}
2263
2264/* State Msg type New state Actions
2265 * INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B)
2266 */
2468
2469 return changed;
2470}
2471
2472/* State Msg type New state Actions
2473 * INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B)
2474 */
2267static bool __grp_src_block_incl(struct net_bridge_port_group *pg, void *h_addr,
2475static bool __grp_src_block_incl(struct net_bridge_mcast *brmctx,
2476 struct net_bridge_mcast_port *pmctx,
2477 struct net_bridge_port_group *pg, void *h_addr,
2268 void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
2269{
2270 struct net_bridge_group_src *ent;
2271 u32 src_idx, to_send = 0;
2272 bool changed = false;
2273 struct br_ip src_ip;
2274
2275 hlist_for_each_entry(ent, &pg->src_list, node)

--- 5 unchanged lines hidden (view full) ---

2281 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
2282 ent = br_multicast_find_group_src(pg, &src_ip);
2283 if (ent) {
2284 ent->flags |= BR_SGRP_F_SEND;
2285 to_send++;
2286 }
2287 }
2288
2478 void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
2479{
2480 struct net_bridge_group_src *ent;
2481 u32 src_idx, to_send = 0;
2482 bool changed = false;
2483 struct br_ip src_ip;
2484
2485 hlist_for_each_entry(ent, &pg->src_list, node)

--- 5 unchanged lines hidden (view full) ---

2491 memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
2492 ent = br_multicast_find_group_src(pg, &src_ip);
2493 if (ent) {
2494 ent->flags |= BR_SGRP_F_SEND;
2495 to_send++;
2496 }
2497 }
2498
2289 if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
2499 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2500 grec_type))
2290 changed = true;
2291
2292 if (to_send)
2501 changed = true;
2502
2503 if (to_send)
2293 __grp_src_query_marked_and_rexmit(pg);
2504 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg);
2294
2295 return changed;
2296}
2297
2298/* State Msg type New state Actions
2299 * EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer
2300 * Send Q(G,A-Y)
2301 */
2505
2506 return changed;
2507}
2508
2509/* State Msg type New state Actions
2510 * EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer
2511 * Send Q(G,A-Y)
2512 */
2302static bool __grp_src_block_excl(struct net_bridge_port_group *pg, void *h_addr,
2513static bool __grp_src_block_excl(struct net_bridge_mcast *brmctx,
2514 struct net_bridge_mcast_port *pmctx,
2515 struct net_bridge_port_group *pg, void *h_addr,
2303 void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
2304{
2305 struct net_bridge_group_src *ent;
2306 u32 src_idx, to_send = 0;
2307 bool changed = false;
2308 struct br_ip src_ip;
2309
2310 hlist_for_each_entry(ent, &pg->src_list, node)

--- 12 unchanged lines hidden (view full) ---

2323 }
2324 }
2325 if (ent && timer_pending(&ent->timer)) {
2326 ent->flags |= BR_SGRP_F_SEND;
2327 to_send++;
2328 }
2329 }
2330
2516 void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
2517{
2518 struct net_bridge_group_src *ent;
2519 u32 src_idx, to_send = 0;
2520 bool changed = false;
2521 struct br_ip src_ip;
2522
2523 hlist_for_each_entry(ent, &pg->src_list, node)

--- 12 unchanged lines hidden (view full) ---

2536 }
2537 }
2538 if (ent && timer_pending(&ent->timer)) {
2539 ent->flags |= BR_SGRP_F_SEND;
2540 to_send++;
2541 }
2542 }
2543
2331 if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
2544 if (br_multicast_eht_handle(brmctx, pg, h_addr, srcs, nsrcs, addr_size,
2545 grec_type))
2332 changed = true;
2333
2334 if (to_send)
2546 changed = true;
2547
2548 if (to_send)
2335 __grp_src_query_marked_and_rexmit(pg);
2549 __grp_src_query_marked_and_rexmit(brmctx, pmctx, pg);
2336
2337 return changed;
2338}
2339
2550
2551 return changed;
2552}
2553
2340static bool br_multicast_block(struct net_bridge_port_group *pg, void *h_addr,
2554static bool br_multicast_block(struct net_bridge_mcast *brmctx,
2555 struct net_bridge_mcast_port *pmctx,
2556 struct net_bridge_port_group *pg, void *h_addr,
2341 void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
2342{
2343 bool changed = false;
2344
2345 switch (pg->filter_mode) {
2346 case MCAST_INCLUDE:
2557 void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
2558{
2559 bool changed = false;
2560
2561 switch (pg->filter_mode) {
2562 case MCAST_INCLUDE:
2347 changed = __grp_src_block_incl(pg, h_addr, srcs, nsrcs, addr_size,
2348 grec_type);
2563 changed = __grp_src_block_incl(brmctx, pmctx, pg, h_addr, srcs,
2564 nsrcs, addr_size, grec_type);
2349 break;
2350 case MCAST_EXCLUDE:
2565 break;
2566 case MCAST_EXCLUDE:
2351 changed = __grp_src_block_excl(pg, h_addr, srcs, nsrcs, addr_size,
2352 grec_type);
2567 changed = __grp_src_block_excl(brmctx, pmctx, pg, h_addr, srcs,
2568 nsrcs, addr_size, grec_type);
2353 break;
2354 }
2355
2356 if ((pg->filter_mode == MCAST_INCLUDE && hlist_empty(&pg->src_list)) ||
2357 br_multicast_eht_should_del_pg(pg)) {
2358 if (br_multicast_eht_should_del_pg(pg))
2359 pg->flags |= MDB_PG_FLAGS_FAST_LEAVE;
2360 br_multicast_find_del_pg(pg->key.port->br, pg);

--- 18 unchanged lines hidden (view full) ---

2379 pg;
2380 pg = mlock_dereference(pg->next, br))
2381 if (br_port_group_equal(pg, p, src))
2382 return pg;
2383
2384 return NULL;
2385}
2386
2569 break;
2570 }
2571
2572 if ((pg->filter_mode == MCAST_INCLUDE && hlist_empty(&pg->src_list)) ||
2573 br_multicast_eht_should_del_pg(pg)) {
2574 if (br_multicast_eht_should_del_pg(pg))
2575 pg->flags |= MDB_PG_FLAGS_FAST_LEAVE;
2576 br_multicast_find_del_pg(pg->key.port->br, pg);

--- 18 unchanged lines hidden (view full) ---

2595 pg;
2596 pg = mlock_dereference(pg->next, br))
2597 if (br_port_group_equal(pg, p, src))
2598 return pg;
2599
2600 return NULL;
2601}
2602
2387static int br_ip4_multicast_igmp3_report(struct net_bridge *br,
2388 struct net_bridge_port *port,
2603static int br_ip4_multicast_igmp3_report(struct net_bridge_mcast *brmctx,
2604 struct net_bridge_mcast_port *pmctx,
2389 struct sk_buff *skb,
2390 u16 vid)
2391{
2605 struct sk_buff *skb,
2606 u16 vid)
2607{
2392 bool igmpv2 = br->multicast_igmp_version == 2;
2608 bool igmpv2 = brmctx->multicast_igmp_version == 2;
2393 struct net_bridge_mdb_entry *mdst;
2394 struct net_bridge_port_group *pg;
2395 const unsigned char *src;
2396 struct igmpv3_report *ih;
2397 struct igmpv3_grec *grec;
2398 int i, len, num, type;
2399 __be32 group, *h_addr;
2400 bool changed = false;

--- 30 unchanged lines hidden (view full) ---

2431 default:
2432 continue;
2433 }
2434
2435 src = eth_hdr(skb)->h_source;
2436 if (nsrcs == 0 &&
2437 (type == IGMPV3_CHANGE_TO_INCLUDE ||
2438 type == IGMPV3_MODE_IS_INCLUDE)) {
2609 struct net_bridge_mdb_entry *mdst;
2610 struct net_bridge_port_group *pg;
2611 const unsigned char *src;
2612 struct igmpv3_report *ih;
2613 struct igmpv3_grec *grec;
2614 int i, len, num, type;
2615 __be32 group, *h_addr;
2616 bool changed = false;

--- 30 unchanged lines hidden (view full) ---

2647 default:
2648 continue;
2649 }
2650
2651 src = eth_hdr(skb)->h_source;
2652 if (nsrcs == 0 &&
2653 (type == IGMPV3_CHANGE_TO_INCLUDE ||
2654 type == IGMPV3_MODE_IS_INCLUDE)) {
2439 if (!port || igmpv2) {
2440 br_ip4_multicast_leave_group(br, port, group, vid, src);
2655 if (!pmctx || igmpv2) {
2656 br_ip4_multicast_leave_group(brmctx, pmctx,
2657 group, vid, src);
2441 continue;
2442 }
2443 } else {
2658 continue;
2659 }
2660 } else {
2444 err = br_ip4_multicast_add_group(br, port, group, vid,
2445 src, igmpv2);
2661 err = br_ip4_multicast_add_group(brmctx, pmctx, group,
2662 vid, src, igmpv2);
2446 if (err)
2447 break;
2448 }
2449
2663 if (err)
2664 break;
2665 }
2666
2450 if (!port || igmpv2)
2667 if (!pmctx || igmpv2)
2451 continue;
2452
2668 continue;
2669
2453 spin_lock_bh(&br->multicast_lock);
2454 mdst = br_mdb_ip4_get(br, group, vid);
2670 spin_lock_bh(&brmctx->br->multicast_lock);
2671 if (!br_multicast_ctx_should_use(brmctx, pmctx))
2672 goto unlock_continue;
2673
2674 mdst = br_mdb_ip4_get(brmctx->br, group, vid);
2455 if (!mdst)
2456 goto unlock_continue;
2675 if (!mdst)
2676 goto unlock_continue;
2457 pg = br_multicast_find_port(mdst, port, src);
2677 pg = br_multicast_find_port(mdst, pmctx->port, src);
2458 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
2459 goto unlock_continue;
2460 /* reload grec and host addr */
2461 grec = (void *)(skb->data + len - sizeof(*grec) - (nsrcs * 4));
2462 h_addr = &ip_hdr(skb)->saddr;
2463 switch (type) {
2464 case IGMPV3_ALLOW_NEW_SOURCES:
2678 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
2679 goto unlock_continue;
2680 /* reload grec and host addr */
2681 grec = (void *)(skb->data + len - sizeof(*grec) - (nsrcs * 4));
2682 h_addr = &ip_hdr(skb)->saddr;
2683 switch (type) {
2684 case IGMPV3_ALLOW_NEW_SOURCES:
2465 changed = br_multicast_isinc_allow(pg, h_addr, grec->grec_src,
2685 changed = br_multicast_isinc_allow(brmctx, pg, h_addr,
2686 grec->grec_src,
2466 nsrcs, sizeof(__be32), type);
2467 break;
2468 case IGMPV3_MODE_IS_INCLUDE:
2687 nsrcs, sizeof(__be32), type);
2688 break;
2689 case IGMPV3_MODE_IS_INCLUDE:
2469 changed = br_multicast_isinc_allow(pg, h_addr, grec->grec_src,
2690 changed = br_multicast_isinc_allow(brmctx, pg, h_addr,
2691 grec->grec_src,
2470 nsrcs, sizeof(__be32), type);
2471 break;
2472 case IGMPV3_MODE_IS_EXCLUDE:
2692 nsrcs, sizeof(__be32), type);
2693 break;
2694 case IGMPV3_MODE_IS_EXCLUDE:
2473 changed = br_multicast_isexc(pg, h_addr, grec->grec_src,
2695 changed = br_multicast_isexc(brmctx, pg, h_addr,
2696 grec->grec_src,
2474 nsrcs, sizeof(__be32), type);
2475 break;
2476 case IGMPV3_CHANGE_TO_INCLUDE:
2697 nsrcs, sizeof(__be32), type);
2698 break;
2699 case IGMPV3_CHANGE_TO_INCLUDE:
2477 changed = br_multicast_toin(pg, h_addr, grec->grec_src,
2700 changed = br_multicast_toin(brmctx, pmctx, pg, h_addr,
2701 grec->grec_src,
2478 nsrcs, sizeof(__be32), type);
2479 break;
2480 case IGMPV3_CHANGE_TO_EXCLUDE:
2702 nsrcs, sizeof(__be32), type);
2703 break;
2704 case IGMPV3_CHANGE_TO_EXCLUDE:
2481 changed = br_multicast_toex(pg, h_addr, grec->grec_src,
2705 changed = br_multicast_toex(brmctx, pmctx, pg, h_addr,
2706 grec->grec_src,
2482 nsrcs, sizeof(__be32), type);
2483 break;
2484 case IGMPV3_BLOCK_OLD_SOURCES:
2707 nsrcs, sizeof(__be32), type);
2708 break;
2709 case IGMPV3_BLOCK_OLD_SOURCES:
2485 changed = br_multicast_block(pg, h_addr, grec->grec_src,
2710 changed = br_multicast_block(brmctx, pmctx, pg, h_addr,
2711 grec->grec_src,
2486 nsrcs, sizeof(__be32), type);
2487 break;
2488 }
2489 if (changed)
2712 nsrcs, sizeof(__be32), type);
2713 break;
2714 }
2715 if (changed)
2490 br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB);
2716 br_mdb_notify(brmctx->br->dev, mdst, pg, RTM_NEWMDB);
2491unlock_continue:
2717unlock_continue:
2492 spin_unlock_bh(&br->multicast_lock);
2718 spin_unlock_bh(&brmctx->br->multicast_lock);
2493 }
2494
2495 return err;
2496}
2497
2498#if IS_ENABLED(CONFIG_IPV6)
2719 }
2720
2721 return err;
2722}
2723
2724#if IS_ENABLED(CONFIG_IPV6)
2499static int br_ip6_multicast_mld2_report(struct net_bridge *br,
2500 struct net_bridge_port *port,
2725static int br_ip6_multicast_mld2_report(struct net_bridge_mcast *brmctx,
2726 struct net_bridge_mcast_port *pmctx,
2501 struct sk_buff *skb,
2502 u16 vid)
2503{
2727 struct sk_buff *skb,
2728 u16 vid)
2729{
2504 bool mldv1 = br->multicast_mld_version == 1;
2730 bool mldv1 = brmctx->multicast_mld_version == 1;
2505 struct net_bridge_mdb_entry *mdst;
2506 struct net_bridge_port_group *pg;
2507 unsigned int nsrcs_offset;
2731 struct net_bridge_mdb_entry *mdst;
2732 struct net_bridge_port_group *pg;
2733 unsigned int nsrcs_offset;
2734 struct mld2_report *mld2r;
2508 const unsigned char *src;
2735 const unsigned char *src;
2509 struct icmp6hdr *icmp6h;
2510 struct in6_addr *h_addr;
2511 struct mld2_grec *grec;
2512 unsigned int grec_len;
2513 bool changed = false;
2514 int i, len, num;
2515 int err = 0;
2516
2736 struct in6_addr *h_addr;
2737 struct mld2_grec *grec;
2738 unsigned int grec_len;
2739 bool changed = false;
2740 int i, len, num;
2741 int err = 0;
2742
2517 if (!ipv6_mc_may_pull(skb, sizeof(*icmp6h)))
2743 if (!ipv6_mc_may_pull(skb, sizeof(*mld2r)))
2518 return -EINVAL;
2519
2744 return -EINVAL;
2745
2520 icmp6h = icmp6_hdr(skb);
2521 num = ntohs(icmp6h->icmp6_dataun.un_data16[1]);
2522 len = skb_transport_offset(skb) + sizeof(*icmp6h);
2746 mld2r = (struct mld2_report *)icmp6_hdr(skb);
2747 num = ntohs(mld2r->mld2r_ngrec);
2748 len = skb_transport_offset(skb) + sizeof(*mld2r);
2523
2524 for (i = 0; i < num; i++) {
2525 __be16 *_nsrcs, __nsrcs;
2526 u16 nsrcs;
2527
2528 nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs);
2529
2530 if (skb_transport_offset(skb) + ipv6_transport_len(skb) <

--- 26 unchanged lines hidden (view full) ---

2557 default:
2558 continue;
2559 }
2560
2561 src = eth_hdr(skb)->h_source;
2562 if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
2563 grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
2564 nsrcs == 0) {
2749
2750 for (i = 0; i < num; i++) {
2751 __be16 *_nsrcs, __nsrcs;
2752 u16 nsrcs;
2753
2754 nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs);
2755
2756 if (skb_transport_offset(skb) + ipv6_transport_len(skb) <

--- 26 unchanged lines hidden (view full) ---

2783 default:
2784 continue;
2785 }
2786
2787 src = eth_hdr(skb)->h_source;
2788 if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
2789 grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
2790 nsrcs == 0) {
2565 if (!port || mldv1) {
2566 br_ip6_multicast_leave_group(br, port,
2791 if (!pmctx || mldv1) {
2792 br_ip6_multicast_leave_group(brmctx, pmctx,
2567 &grec->grec_mca,
2568 vid, src);
2569 continue;
2570 }
2571 } else {
2793 &grec->grec_mca,
2794 vid, src);
2795 continue;
2796 }
2797 } else {
2572 err = br_ip6_multicast_add_group(br, port,
2798 err = br_ip6_multicast_add_group(brmctx, pmctx,
2573 &grec->grec_mca, vid,
2574 src, mldv1);
2575 if (err)
2576 break;
2577 }
2578
2799 &grec->grec_mca, vid,
2800 src, mldv1);
2801 if (err)
2802 break;
2803 }
2804
2579 if (!port || mldv1)
2805 if (!pmctx || mldv1)
2580 continue;
2581
2806 continue;
2807
2582 spin_lock_bh(&br->multicast_lock);
2583 mdst = br_mdb_ip6_get(br, &grec->grec_mca, vid);
2808 spin_lock_bh(&brmctx->br->multicast_lock);
2809 if (!br_multicast_ctx_should_use(brmctx, pmctx))
2810 goto unlock_continue;
2811
2812 mdst = br_mdb_ip6_get(brmctx->br, &grec->grec_mca, vid);
2584 if (!mdst)
2585 goto unlock_continue;
2813 if (!mdst)
2814 goto unlock_continue;
2586 pg = br_multicast_find_port(mdst, port, src);
2815 pg = br_multicast_find_port(mdst, pmctx->port, src);
2587 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
2588 goto unlock_continue;
2589 h_addr = &ipv6_hdr(skb)->saddr;
2590 switch (grec->grec_type) {
2591 case MLD2_ALLOW_NEW_SOURCES:
2816 if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
2817 goto unlock_continue;
2818 h_addr = &ipv6_hdr(skb)->saddr;
2819 switch (grec->grec_type) {
2820 case MLD2_ALLOW_NEW_SOURCES:
2592 changed = br_multicast_isinc_allow(pg, h_addr,
2821 changed = br_multicast_isinc_allow(brmctx, pg, h_addr,
2593 grec->grec_src, nsrcs,
2594 sizeof(struct in6_addr),
2595 grec->grec_type);
2596 break;
2597 case MLD2_MODE_IS_INCLUDE:
2822 grec->grec_src, nsrcs,
2823 sizeof(struct in6_addr),
2824 grec->grec_type);
2825 break;
2826 case MLD2_MODE_IS_INCLUDE:
2598 changed = br_multicast_isinc_allow(pg, h_addr,
2827 changed = br_multicast_isinc_allow(brmctx, pg, h_addr,
2599 grec->grec_src, nsrcs,
2600 sizeof(struct in6_addr),
2601 grec->grec_type);
2602 break;
2603 case MLD2_MODE_IS_EXCLUDE:
2828 grec->grec_src, nsrcs,
2829 sizeof(struct in6_addr),
2830 grec->grec_type);
2831 break;
2832 case MLD2_MODE_IS_EXCLUDE:
2604 changed = br_multicast_isexc(pg, h_addr,
2833 changed = br_multicast_isexc(brmctx, pg, h_addr,
2605 grec->grec_src, nsrcs,
2606 sizeof(struct in6_addr),
2607 grec->grec_type);
2608 break;
2609 case MLD2_CHANGE_TO_INCLUDE:
2834 grec->grec_src, nsrcs,
2835 sizeof(struct in6_addr),
2836 grec->grec_type);
2837 break;
2838 case MLD2_CHANGE_TO_INCLUDE:
2610 changed = br_multicast_toin(pg, h_addr,
2839 changed = br_multicast_toin(brmctx, pmctx, pg, h_addr,
2611 grec->grec_src, nsrcs,
2612 sizeof(struct in6_addr),
2613 grec->grec_type);
2614 break;
2615 case MLD2_CHANGE_TO_EXCLUDE:
2840 grec->grec_src, nsrcs,
2841 sizeof(struct in6_addr),
2842 grec->grec_type);
2843 break;
2844 case MLD2_CHANGE_TO_EXCLUDE:
2616 changed = br_multicast_toex(pg, h_addr,
2845 changed = br_multicast_toex(brmctx, pmctx, pg, h_addr,
2617 grec->grec_src, nsrcs,
2618 sizeof(struct in6_addr),
2619 grec->grec_type);
2620 break;
2621 case MLD2_BLOCK_OLD_SOURCES:
2846 grec->grec_src, nsrcs,
2847 sizeof(struct in6_addr),
2848 grec->grec_type);
2849 break;
2850 case MLD2_BLOCK_OLD_SOURCES:
2622 changed = br_multicast_block(pg, h_addr,
2851 changed = br_multicast_block(brmctx, pmctx, pg, h_addr,
2623 grec->grec_src, nsrcs,
2624 sizeof(struct in6_addr),
2625 grec->grec_type);
2626 break;
2627 }
2628 if (changed)
2852 grec->grec_src, nsrcs,
2853 sizeof(struct in6_addr),
2854 grec->grec_type);
2855 break;
2856 }
2857 if (changed)
2629 br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB);
2858 br_mdb_notify(brmctx->br->dev, mdst, pg, RTM_NEWMDB);
2630unlock_continue:
2859unlock_continue:
2631 spin_unlock_bh(&br->multicast_lock);
2860 spin_unlock_bh(&brmctx->br->multicast_lock);
2632 }
2633
2634 return err;
2635}
2636#endif
2637
2861 }
2862
2863 return err;
2864}
2865#endif
2866
2638static bool br_ip4_multicast_select_querier(struct net_bridge *br,
2639 struct net_bridge_port *port,
2640 __be32 saddr)
2867static bool br_multicast_select_querier(struct net_bridge_mcast *brmctx,
2868 struct net_bridge_mcast_port *pmctx,
2869 struct br_ip *saddr)
2641{
2870{
2642 if (!timer_pending(&br->ip4_own_query.timer) &&
2643 !timer_pending(&br->ip4_other_query.timer))
2644 goto update;
2871 int port_ifidx = pmctx ? pmctx->port->dev->ifindex : 0;
2872 struct timer_list *own_timer, *other_timer;
2873 struct bridge_mcast_querier *querier;
2645
2874
2646 if (!br->ip4_querier.addr.src.ip4)
2647 goto update;
2875 switch (saddr->proto) {
2876 case htons(ETH_P_IP):
2877 querier = &brmctx->ip4_querier;
2878 own_timer = &brmctx->ip4_own_query.timer;
2879 other_timer = &brmctx->ip4_other_query.timer;
2880 if (!querier->addr.src.ip4 ||
2881 ntohl(saddr->src.ip4) <= ntohl(querier->addr.src.ip4))
2882 goto update;
2883 break;
2884#if IS_ENABLED(CONFIG_IPV6)
2885 case htons(ETH_P_IPV6):
2886 querier = &brmctx->ip6_querier;
2887 own_timer = &brmctx->ip6_own_query.timer;
2888 other_timer = &brmctx->ip6_other_query.timer;
2889 if (ipv6_addr_cmp(&saddr->src.ip6, &querier->addr.src.ip6) <= 0)
2890 goto update;
2891 break;
2892#endif
2893 default:
2894 return false;
2895 }
2648
2896
2649 if (ntohl(saddr) <= ntohl(br->ip4_querier.addr.src.ip4))
2897 if (!timer_pending(own_timer) && !timer_pending(other_timer))
2650 goto update;
2651
2652 return false;
2653
2654update:
2898 goto update;
2899
2900 return false;
2901
2902update:
2655 br->ip4_querier.addr.src.ip4 = saddr;
2903 br_multicast_update_querier(brmctx, querier, port_ifidx, saddr);
2656
2904
2657 /* update protected by general multicast_lock by caller */
2658 rcu_assign_pointer(br->ip4_querier.port, port);
2659
2660 return true;
2661}
2662
2905 return true;
2906}
2907
2908static struct net_bridge_port *
2909__br_multicast_get_querier_port(struct net_bridge *br,
2910 const struct bridge_mcast_querier *querier)
2911{
2912 int port_ifidx = READ_ONCE(querier->port_ifidx);
2913 struct net_bridge_port *p;
2914 struct net_device *dev;
2915
2916 if (port_ifidx == 0)
2917 return NULL;
2918
2919 dev = dev_get_by_index_rcu(dev_net(br->dev), port_ifidx);
2920 if (!dev)
2921 return NULL;
2922 p = br_port_get_rtnl_rcu(dev);
2923 if (!p || p->br != br)
2924 return NULL;
2925
2926 return p;
2927}
2928
2929size_t br_multicast_querier_state_size(void)
2930{
2931 return nla_total_size(0) + /* nest attribute */
2932 nla_total_size(sizeof(__be32)) + /* BRIDGE_QUERIER_IP_ADDRESS */
2933 nla_total_size(sizeof(int)) + /* BRIDGE_QUERIER_IP_PORT */
2934 nla_total_size_64bit(sizeof(u64)) + /* BRIDGE_QUERIER_IP_OTHER_TIMER */
2663#if IS_ENABLED(CONFIG_IPV6)
2935#if IS_ENABLED(CONFIG_IPV6)
2664static bool br_ip6_multicast_select_querier(struct net_bridge *br,
2665 struct net_bridge_port *port,
2666 struct in6_addr *saddr)
2936 nla_total_size(sizeof(struct in6_addr)) + /* BRIDGE_QUERIER_IPV6_ADDRESS */
2937 nla_total_size(sizeof(int)) + /* BRIDGE_QUERIER_IPV6_PORT */
2938 nla_total_size_64bit(sizeof(u64)) + /* BRIDGE_QUERIER_IPV6_OTHER_TIMER */
2939#endif
2940 0;
2941}
2942
2943/* protected by rtnl or rcu */
2944int br_multicast_dump_querier_state(struct sk_buff *skb,
2945 const struct net_bridge_mcast *brmctx,
2946 int nest_attr)
2667{
2947{
2668 if (!timer_pending(&br->ip6_own_query.timer) &&
2669 !timer_pending(&br->ip6_other_query.timer))
2670 goto update;
2948 struct bridge_mcast_querier querier = {};
2949 struct net_bridge_port *p;
2950 struct nlattr *nest;
2671
2951
2672 if (ipv6_addr_cmp(saddr, &br->ip6_querier.addr.src.ip6) <= 0)
2673 goto update;
2952 if (!br_opt_get(brmctx->br, BROPT_MULTICAST_ENABLED) ||
2953 br_multicast_ctx_vlan_global_disabled(brmctx))
2954 return 0;
2674
2955
2675 return false;
2956 nest = nla_nest_start(skb, nest_attr);
2957 if (!nest)
2958 return -EMSGSIZE;
2676
2959
2677update:
2678 br->ip6_querier.addr.src.ip6 = *saddr;
2960 rcu_read_lock();
2961 if (!brmctx->multicast_querier &&
2962 !timer_pending(&brmctx->ip4_other_query.timer))
2963 goto out_v6;
2679
2964
2680 /* update protected by general multicast_lock by caller */
2681 rcu_assign_pointer(br->ip6_querier.port, port);
2965 br_multicast_read_querier(&brmctx->ip4_querier, &querier);
2966 if (nla_put_in_addr(skb, BRIDGE_QUERIER_IP_ADDRESS,
2967 querier.addr.src.ip4)) {
2968 rcu_read_unlock();
2969 goto out_err;
2970 }
2682
2971
2683 return true;
2684}
2972 p = __br_multicast_get_querier_port(brmctx->br, &querier);
2973 if (timer_pending(&brmctx->ip4_other_query.timer) &&
2974 (nla_put_u64_64bit(skb, BRIDGE_QUERIER_IP_OTHER_TIMER,
2975 br_timer_value(&brmctx->ip4_other_query.timer),
2976 BRIDGE_QUERIER_PAD) ||
2977 (p && nla_put_u32(skb, BRIDGE_QUERIER_IP_PORT, p->dev->ifindex)))) {
2978 rcu_read_unlock();
2979 goto out_err;
2980 }
2981
2982out_v6:
2983#if IS_ENABLED(CONFIG_IPV6)
2984 if (!brmctx->multicast_querier &&
2985 !timer_pending(&brmctx->ip6_other_query.timer))
2986 goto out;
2987
2988 br_multicast_read_querier(&brmctx->ip6_querier, &querier);
2989 if (nla_put_in6_addr(skb, BRIDGE_QUERIER_IPV6_ADDRESS,
2990 &querier.addr.src.ip6)) {
2991 rcu_read_unlock();
2992 goto out_err;
2993 }
2994
2995 p = __br_multicast_get_querier_port(brmctx->br, &querier);
2996 if (timer_pending(&brmctx->ip6_other_query.timer) &&
2997 (nla_put_u64_64bit(skb, BRIDGE_QUERIER_IPV6_OTHER_TIMER,
2998 br_timer_value(&brmctx->ip6_other_query.timer),
2999 BRIDGE_QUERIER_PAD) ||
3000 (p && nla_put_u32(skb, BRIDGE_QUERIER_IPV6_PORT,
3001 p->dev->ifindex)))) {
3002 rcu_read_unlock();
3003 goto out_err;
3004 }
3005out:
2685#endif
3006#endif
3007 rcu_read_unlock();
3008 nla_nest_end(skb, nest);
3009 if (!nla_len(nest))
3010 nla_nest_cancel(skb, nest);
2686
3011
3012 return 0;
3013
3014out_err:
3015 nla_nest_cancel(skb, nest);
3016 return -EMSGSIZE;
3017}
3018
2687static void
3019static void
2688br_multicast_update_query_timer(struct net_bridge *br,
3020br_multicast_update_query_timer(struct net_bridge_mcast *brmctx,
2689 struct bridge_mcast_other_query *query,
2690 unsigned long max_delay)
2691{
2692 if (!timer_pending(&query->timer))
2693 query->delay_time = jiffies + max_delay;
2694
3021 struct bridge_mcast_other_query *query,
3022 unsigned long max_delay)
3023{
3024 if (!timer_pending(&query->timer))
3025 query->delay_time = jiffies + max_delay;
3026
2695 mod_timer(&query->timer, jiffies + br->multicast_querier_interval);
3027 mod_timer(&query->timer, jiffies + brmctx->multicast_querier_interval);
2696}
2697
2698static void br_port_mc_router_state_change(struct net_bridge_port *p,
2699 bool is_mc_router)
2700{
2701 struct switchdev_attr attr = {
2702 .orig_dev = p->dev,
2703 .id = SWITCHDEV_ATTR_ID_PORT_MROUTER,
2704 .flags = SWITCHDEV_F_DEFER,
2705 .u.mrouter = is_mc_router,
2706 };
2707
2708 switchdev_port_attr_set(p->dev, &attr, NULL);
2709}
2710
2711static struct net_bridge_port *
3028}
3029
3030static void br_port_mc_router_state_change(struct net_bridge_port *p,
3031 bool is_mc_router)
3032{
3033 struct switchdev_attr attr = {
3034 .orig_dev = p->dev,
3035 .id = SWITCHDEV_ATTR_ID_PORT_MROUTER,
3036 .flags = SWITCHDEV_F_DEFER,
3037 .u.mrouter = is_mc_router,
3038 };
3039
3040 switchdev_port_attr_set(p->dev, &attr, NULL);
3041}
3042
3043static struct net_bridge_port *
2712br_multicast_rport_from_node(struct net_bridge *br,
3044br_multicast_rport_from_node(struct net_bridge_mcast *brmctx,
2713 struct hlist_head *mc_router_list,
2714 struct hlist_node *rlist)
2715{
3045 struct hlist_head *mc_router_list,
3046 struct hlist_node *rlist)
3047{
3048 struct net_bridge_mcast_port *pmctx;
3049
2716#if IS_ENABLED(CONFIG_IPV6)
3050#if IS_ENABLED(CONFIG_IPV6)
2717 if (mc_router_list == &br->ip6_mc_router_list)
2718 return hlist_entry(rlist, struct net_bridge_port, ip6_rlist);
3051 if (mc_router_list == &brmctx->ip6_mc_router_list)
3052 pmctx = hlist_entry(rlist, struct net_bridge_mcast_port,
3053 ip6_rlist);
3054 else
2719#endif
3055#endif
2720 return hlist_entry(rlist, struct net_bridge_port, ip4_rlist);
3056 pmctx = hlist_entry(rlist, struct net_bridge_mcast_port,
3057 ip4_rlist);
3058
3059 return pmctx->port;
2721}
2722
2723static struct hlist_node *
3060}
3061
3062static struct hlist_node *
2724br_multicast_get_rport_slot(struct net_bridge *br,
3063br_multicast_get_rport_slot(struct net_bridge_mcast *brmctx,
2725 struct net_bridge_port *port,
2726 struct hlist_head *mc_router_list)
2727
2728{
2729 struct hlist_node *slot = NULL;
2730 struct net_bridge_port *p;
2731 struct hlist_node *rlist;
2732
2733 hlist_for_each(rlist, mc_router_list) {
3064 struct net_bridge_port *port,
3065 struct hlist_head *mc_router_list)
3066
3067{
3068 struct hlist_node *slot = NULL;
3069 struct net_bridge_port *p;
3070 struct hlist_node *rlist;
3071
3072 hlist_for_each(rlist, mc_router_list) {
2734 p = br_multicast_rport_from_node(br, mc_router_list, rlist);
3073 p = br_multicast_rport_from_node(brmctx, mc_router_list, rlist);
2735
2736 if ((unsigned long)port >= (unsigned long)p)
2737 break;
2738
2739 slot = rlist;
2740 }
2741
2742 return slot;
2743}
2744
3074
3075 if ((unsigned long)port >= (unsigned long)p)
3076 break;
3077
3078 slot = rlist;
3079 }
3080
3081 return slot;
3082}
3083
2745static bool br_multicast_no_router_otherpf(struct net_bridge_port *port,
3084static bool br_multicast_no_router_otherpf(struct net_bridge_mcast_port *pmctx,
2746 struct hlist_node *rnode)
2747{
2748#if IS_ENABLED(CONFIG_IPV6)
3085 struct hlist_node *rnode)
3086{
3087#if IS_ENABLED(CONFIG_IPV6)
2749 if (rnode != &port->ip6_rlist)
2750 return hlist_unhashed(&port->ip6_rlist);
3088 if (rnode != &pmctx->ip6_rlist)
3089 return hlist_unhashed(&pmctx->ip6_rlist);
2751 else
3090 else
2752 return hlist_unhashed(&port->ip4_rlist);
3091 return hlist_unhashed(&pmctx->ip4_rlist);
2753#else
2754 return true;
2755#endif
2756}
2757
2758/* Add port to router_list
2759 * list is maintained ordered by pointer value
2760 * and locked by br->multicast_lock and RCU
2761 */
3092#else
3093 return true;
3094#endif
3095}
3096
3097/* Add port to router_list
3098 * list is maintained ordered by pointer value
3099 * and locked by br->multicast_lock and RCU
3100 */
2762static void br_multicast_add_router(struct net_bridge *br,
2763 struct net_bridge_port *port,
3101static void br_multicast_add_router(struct net_bridge_mcast *brmctx,
3102 struct net_bridge_mcast_port *pmctx,
2764 struct hlist_node *rlist,
2765 struct hlist_head *mc_router_list)
2766{
2767 struct hlist_node *slot;
2768
2769 if (!hlist_unhashed(rlist))
2770 return;
2771
3103 struct hlist_node *rlist,
3104 struct hlist_head *mc_router_list)
3105{
3106 struct hlist_node *slot;
3107
3108 if (!hlist_unhashed(rlist))
3109 return;
3110
2772 slot = br_multicast_get_rport_slot(br, port, mc_router_list);
3111 slot = br_multicast_get_rport_slot(brmctx, pmctx->port, mc_router_list);
2773
2774 if (slot)
2775 hlist_add_behind_rcu(rlist, slot);
2776 else
2777 hlist_add_head_rcu(rlist, mc_router_list);
2778
2779 /* For backwards compatibility for now, only notify if we
2780 * switched from no IPv4/IPv6 multicast router to a new
2781 * IPv4 or IPv6 multicast router.
2782 */
3112
3113 if (slot)
3114 hlist_add_behind_rcu(rlist, slot);
3115 else
3116 hlist_add_head_rcu(rlist, mc_router_list);
3117
3118 /* For backwards compatibility for now, only notify if we
3119 * switched from no IPv4/IPv6 multicast router to a new
3120 * IPv4 or IPv6 multicast router.
3121 */
2783 if (br_multicast_no_router_otherpf(port, rlist)) {
2784 br_rtr_notify(br->dev, port, RTM_NEWMDB);
2785 br_port_mc_router_state_change(port, true);
3122 if (br_multicast_no_router_otherpf(pmctx, rlist)) {
3123 br_rtr_notify(pmctx->port->br->dev, pmctx, RTM_NEWMDB);
3124 br_port_mc_router_state_change(pmctx->port, true);
2786 }
2787}
2788
2789/* Add port to router_list
2790 * list is maintained ordered by pointer value
2791 * and locked by br->multicast_lock and RCU
2792 */
3125 }
3126}
3127
3128/* Add port to router_list
3129 * list is maintained ordered by pointer value
3130 * and locked by br->multicast_lock and RCU
3131 */
2793static void br_ip4_multicast_add_router(struct net_bridge *br,
2794 struct net_bridge_port *port)
3132static void br_ip4_multicast_add_router(struct net_bridge_mcast *brmctx,
3133 struct net_bridge_mcast_port *pmctx)
2795{
3134{
2796 br_multicast_add_router(br, port, &port->ip4_rlist,
2797 &br->ip4_mc_router_list);
3135 br_multicast_add_router(brmctx, pmctx, &pmctx->ip4_rlist,
3136 &brmctx->ip4_mc_router_list);
2798}
2799
2800/* Add port to router_list
2801 * list is maintained ordered by pointer value
2802 * and locked by br->multicast_lock and RCU
2803 */
3137}
3138
3139/* Add port to router_list
3140 * list is maintained ordered by pointer value
3141 * and locked by br->multicast_lock and RCU
3142 */
2804static void br_ip6_multicast_add_router(struct net_bridge *br,
2805 struct net_bridge_port *port)
3143static void br_ip6_multicast_add_router(struct net_bridge_mcast *brmctx,
3144 struct net_bridge_mcast_port *pmctx)
2806{
2807#if IS_ENABLED(CONFIG_IPV6)
3145{
3146#if IS_ENABLED(CONFIG_IPV6)
2808 br_multicast_add_router(br, port, &port->ip6_rlist,
2809 &br->ip6_mc_router_list);
3147 br_multicast_add_router(brmctx, pmctx, &pmctx->ip6_rlist,
3148 &brmctx->ip6_mc_router_list);
2810#endif
2811}
2812
3149#endif
3150}
3151
2813static void br_multicast_mark_router(struct net_bridge *br,
2814 struct net_bridge_port *port,
3152static void br_multicast_mark_router(struct net_bridge_mcast *brmctx,
3153 struct net_bridge_mcast_port *pmctx,
2815 struct timer_list *timer,
2816 struct hlist_node *rlist,
2817 struct hlist_head *mc_router_list)
2818{
2819 unsigned long now = jiffies;
2820
3154 struct timer_list *timer,
3155 struct hlist_node *rlist,
3156 struct hlist_head *mc_router_list)
3157{
3158 unsigned long now = jiffies;
3159
2821 if (!port) {
2822 if (br->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) {
2823 if (!br_ip4_multicast_is_router(br) &&
2824 !br_ip6_multicast_is_router(br))
2825 br_mc_router_state_change(br, true);
2826 mod_timer(timer, now + br->multicast_querier_interval);
3160 if (!br_multicast_ctx_should_use(brmctx, pmctx))
3161 return;
3162
3163 if (!pmctx) {
3164 if (brmctx->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) {
3165 if (!br_ip4_multicast_is_router(brmctx) &&
3166 !br_ip6_multicast_is_router(brmctx))
3167 br_mc_router_state_change(brmctx->br, true);
3168 mod_timer(timer, now + brmctx->multicast_querier_interval);
2827 }
2828 return;
2829 }
2830
3169 }
3170 return;
3171 }
3172
2831 if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
2832 port->multicast_router == MDB_RTR_TYPE_PERM)
3173 if (pmctx->multicast_router == MDB_RTR_TYPE_DISABLED ||
3174 pmctx->multicast_router == MDB_RTR_TYPE_PERM)
2833 return;
2834
3175 return;
3176
2835 br_multicast_add_router(br, port, rlist, mc_router_list);
2836 mod_timer(timer, now + br->multicast_querier_interval);
3177 br_multicast_add_router(brmctx, pmctx, rlist, mc_router_list);
3178 mod_timer(timer, now + brmctx->multicast_querier_interval);
2837}
2838
3179}
3180
2839static void br_ip4_multicast_mark_router(struct net_bridge *br,
2840 struct net_bridge_port *port)
3181static void br_ip4_multicast_mark_router(struct net_bridge_mcast *brmctx,
3182 struct net_bridge_mcast_port *pmctx)
2841{
3183{
2842 struct timer_list *timer = &br->ip4_mc_router_timer;
3184 struct timer_list *timer = &brmctx->ip4_mc_router_timer;
2843 struct hlist_node *rlist = NULL;
2844
3185 struct hlist_node *rlist = NULL;
3186
2845 if (port) {
2846 timer = &port->ip4_mc_router_timer;
2847 rlist = &port->ip4_rlist;
3187 if (pmctx) {
3188 timer = &pmctx->ip4_mc_router_timer;
3189 rlist = &pmctx->ip4_rlist;
2848 }
2849
3190 }
3191
2850 br_multicast_mark_router(br, port, timer, rlist,
2851 &br->ip4_mc_router_list);
3192 br_multicast_mark_router(brmctx, pmctx, timer, rlist,
3193 &brmctx->ip4_mc_router_list);
2852}
2853
3194}
3195
2854static void br_ip6_multicast_mark_router(struct net_bridge *br,
2855 struct net_bridge_port *port)
3196static void br_ip6_multicast_mark_router(struct net_bridge_mcast *brmctx,
3197 struct net_bridge_mcast_port *pmctx)
2856{
2857#if IS_ENABLED(CONFIG_IPV6)
3198{
3199#if IS_ENABLED(CONFIG_IPV6)
2858 struct timer_list *timer = &br->ip6_mc_router_timer;
3200 struct timer_list *timer = &brmctx->ip6_mc_router_timer;
2859 struct hlist_node *rlist = NULL;
2860
3201 struct hlist_node *rlist = NULL;
3202
2861 if (port) {
2862 timer = &port->ip6_mc_router_timer;
2863 rlist = &port->ip6_rlist;
3203 if (pmctx) {
3204 timer = &pmctx->ip6_mc_router_timer;
3205 rlist = &pmctx->ip6_rlist;
2864 }
2865
3206 }
3207
2866 br_multicast_mark_router(br, port, timer, rlist,
2867 &br->ip6_mc_router_list);
3208 br_multicast_mark_router(brmctx, pmctx, timer, rlist,
3209 &brmctx->ip6_mc_router_list);
2868#endif
2869}
2870
2871static void
3210#endif
3211}
3212
3213static void
2872br_ip4_multicast_query_received(struct net_bridge *br,
2873 struct net_bridge_port *port,
3214br_ip4_multicast_query_received(struct net_bridge_mcast *brmctx,
3215 struct net_bridge_mcast_port *pmctx,
2874 struct bridge_mcast_other_query *query,
2875 struct br_ip *saddr,
2876 unsigned long max_delay)
2877{
3216 struct bridge_mcast_other_query *query,
3217 struct br_ip *saddr,
3218 unsigned long max_delay)
3219{
2878 if (!br_ip4_multicast_select_querier(br, port, saddr->src.ip4))
3220 if (!br_multicast_select_querier(brmctx, pmctx, saddr))
2879 return;
2880
3221 return;
3222
2881 br_multicast_update_query_timer(br, query, max_delay);
2882 br_ip4_multicast_mark_router(br, port);
3223 br_multicast_update_query_timer(brmctx, query, max_delay);
3224 br_ip4_multicast_mark_router(brmctx, pmctx);
2883}
2884
2885#if IS_ENABLED(CONFIG_IPV6)
2886static void
3225}
3226
3227#if IS_ENABLED(CONFIG_IPV6)
3228static void
2887br_ip6_multicast_query_received(struct net_bridge *br,
2888 struct net_bridge_port *port,
3229br_ip6_multicast_query_received(struct net_bridge_mcast *brmctx,
3230 struct net_bridge_mcast_port *pmctx,
2889 struct bridge_mcast_other_query *query,
2890 struct br_ip *saddr,
2891 unsigned long max_delay)
2892{
3231 struct bridge_mcast_other_query *query,
3232 struct br_ip *saddr,
3233 unsigned long max_delay)
3234{
2893 if (!br_ip6_multicast_select_querier(br, port, &saddr->src.ip6))
3235 if (!br_multicast_select_querier(brmctx, pmctx, saddr))
2894 return;
2895
3236 return;
3237
2896 br_multicast_update_query_timer(br, query, max_delay);
2897 br_ip6_multicast_mark_router(br, port);
3238 br_multicast_update_query_timer(brmctx, query, max_delay);
3239 br_ip6_multicast_mark_router(brmctx, pmctx);
2898}
2899#endif
2900
3240}
3241#endif
3242
2901static void br_ip4_multicast_query(struct net_bridge *br,
2902 struct net_bridge_port *port,
3243static void br_ip4_multicast_query(struct net_bridge_mcast *brmctx,
3244 struct net_bridge_mcast_port *pmctx,
2903 struct sk_buff *skb,
2904 u16 vid)
2905{
2906 unsigned int transport_len = ip_transport_len(skb);
2907 const struct iphdr *iph = ip_hdr(skb);
2908 struct igmphdr *ih = igmp_hdr(skb);
2909 struct net_bridge_mdb_entry *mp;
2910 struct igmpv3_query *ih3;
2911 struct net_bridge_port_group *p;
2912 struct net_bridge_port_group __rcu **pp;
3245 struct sk_buff *skb,
3246 u16 vid)
3247{
3248 unsigned int transport_len = ip_transport_len(skb);
3249 const struct iphdr *iph = ip_hdr(skb);
3250 struct igmphdr *ih = igmp_hdr(skb);
3251 struct net_bridge_mdb_entry *mp;
3252 struct igmpv3_query *ih3;
3253 struct net_bridge_port_group *p;
3254 struct net_bridge_port_group __rcu **pp;
2913 struct br_ip saddr;
3255 struct br_ip saddr = {};
2914 unsigned long max_delay;
2915 unsigned long now = jiffies;
2916 __be32 group;
2917
3256 unsigned long max_delay;
3257 unsigned long now = jiffies;
3258 __be32 group;
3259
2918 spin_lock(&br->multicast_lock);
2919 if (!netif_running(br->dev) ||
2920 (port && port->state == BR_STATE_DISABLED))
3260 spin_lock(&brmctx->br->multicast_lock);
3261 if (!br_multicast_ctx_should_use(brmctx, pmctx))
2921 goto out;
2922
2923 group = ih->group;
2924
2925 if (transport_len == sizeof(*ih)) {
2926 max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
2927
2928 if (!max_delay) {
2929 max_delay = 10 * HZ;
2930 group = 0;
2931 }
2932 } else if (transport_len >= sizeof(*ih3)) {
2933 ih3 = igmpv3_query_hdr(skb);
2934 if (ih3->nsrcs ||
3262 goto out;
3263
3264 group = ih->group;
3265
3266 if (transport_len == sizeof(*ih)) {
3267 max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
3268
3269 if (!max_delay) {
3270 max_delay = 10 * HZ;
3271 group = 0;
3272 }
3273 } else if (transport_len >= sizeof(*ih3)) {
3274 ih3 = igmpv3_query_hdr(skb);
3275 if (ih3->nsrcs ||
2935 (br->multicast_igmp_version == 3 && group && ih3->suppress))
3276 (brmctx->multicast_igmp_version == 3 && group &&
3277 ih3->suppress))
2936 goto out;
2937
2938 max_delay = ih3->code ?
2939 IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1;
2940 } else {
2941 goto out;
2942 }
2943
2944 if (!group) {
2945 saddr.proto = htons(ETH_P_IP);
2946 saddr.src.ip4 = iph->saddr;
2947
3278 goto out;
3279
3280 max_delay = ih3->code ?
3281 IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1;
3282 } else {
3283 goto out;
3284 }
3285
3286 if (!group) {
3287 saddr.proto = htons(ETH_P_IP);
3288 saddr.src.ip4 = iph->saddr;
3289
2948 br_ip4_multicast_query_received(br, port, &br->ip4_other_query,
3290 br_ip4_multicast_query_received(brmctx, pmctx,
3291 &brmctx->ip4_other_query,
2949 &saddr, max_delay);
2950 goto out;
2951 }
2952
3292 &saddr, max_delay);
3293 goto out;
3294 }
3295
2953 mp = br_mdb_ip4_get(br, group, vid);
3296 mp = br_mdb_ip4_get(brmctx->br, group, vid);
2954 if (!mp)
2955 goto out;
2956
3297 if (!mp)
3298 goto out;
3299
2957 max_delay *= br->multicast_last_member_count;
3300 max_delay *= brmctx->multicast_last_member_count;
2958
2959 if (mp->host_joined &&
2960 (timer_pending(&mp->timer) ?
2961 time_after(mp->timer.expires, now + max_delay) :
2962 try_to_del_timer_sync(&mp->timer) >= 0))
2963 mod_timer(&mp->timer, now + max_delay);
2964
2965 for (pp = &mp->ports;
3301
3302 if (mp->host_joined &&
3303 (timer_pending(&mp->timer) ?
3304 time_after(mp->timer.expires, now + max_delay) :
3305 try_to_del_timer_sync(&mp->timer) >= 0))
3306 mod_timer(&mp->timer, now + max_delay);
3307
3308 for (pp = &mp->ports;
2966 (p = mlock_dereference(*pp, br)) != NULL;
3309 (p = mlock_dereference(*pp, brmctx->br)) != NULL;
2967 pp = &p->next) {
2968 if (timer_pending(&p->timer) ?
2969 time_after(p->timer.expires, now + max_delay) :
2970 try_to_del_timer_sync(&p->timer) >= 0 &&
3310 pp = &p->next) {
3311 if (timer_pending(&p->timer) ?
3312 time_after(p->timer.expires, now + max_delay) :
3313 try_to_del_timer_sync(&p->timer) >= 0 &&
2971 (br->multicast_igmp_version == 2 ||
3314 (brmctx->multicast_igmp_version == 2 ||
2972 p->filter_mode == MCAST_EXCLUDE))
2973 mod_timer(&p->timer, now + max_delay);
2974 }
2975
2976out:
3315 p->filter_mode == MCAST_EXCLUDE))
3316 mod_timer(&p->timer, now + max_delay);
3317 }
3318
3319out:
2977 spin_unlock(&br->multicast_lock);
3320 spin_unlock(&brmctx->br->multicast_lock);
2978}
2979
2980#if IS_ENABLED(CONFIG_IPV6)
3321}
3322
3323#if IS_ENABLED(CONFIG_IPV6)
2981static int br_ip6_multicast_query(struct net_bridge *br,
2982 struct net_bridge_port *port,
3324static int br_ip6_multicast_query(struct net_bridge_mcast *brmctx,
3325 struct net_bridge_mcast_port *pmctx,
2983 struct sk_buff *skb,
2984 u16 vid)
2985{
2986 unsigned int transport_len = ipv6_transport_len(skb);
2987 struct mld_msg *mld;
2988 struct net_bridge_mdb_entry *mp;
2989 struct mld2_query *mld2q;
2990 struct net_bridge_port_group *p;
2991 struct net_bridge_port_group __rcu **pp;
3326 struct sk_buff *skb,
3327 u16 vid)
3328{
3329 unsigned int transport_len = ipv6_transport_len(skb);
3330 struct mld_msg *mld;
3331 struct net_bridge_mdb_entry *mp;
3332 struct mld2_query *mld2q;
3333 struct net_bridge_port_group *p;
3334 struct net_bridge_port_group __rcu **pp;
2992 struct br_ip saddr;
3335 struct br_ip saddr = {};
2993 unsigned long max_delay;
2994 unsigned long now = jiffies;
2995 unsigned int offset = skb_transport_offset(skb);
2996 const struct in6_addr *group = NULL;
2997 bool is_general_query;
2998 int err = 0;
2999
3336 unsigned long max_delay;
3337 unsigned long now = jiffies;
3338 unsigned int offset = skb_transport_offset(skb);
3339 const struct in6_addr *group = NULL;
3340 bool is_general_query;
3341 int err = 0;
3342
3000 spin_lock(&br->multicast_lock);
3001 if (!netif_running(br->dev) ||
3002 (port && port->state == BR_STATE_DISABLED))
3343 spin_lock(&brmctx->br->multicast_lock);
3344 if (!br_multicast_ctx_should_use(brmctx, pmctx))
3003 goto out;
3004
3005 if (transport_len == sizeof(*mld)) {
3006 if (!pskb_may_pull(skb, offset + sizeof(*mld))) {
3007 err = -EINVAL;
3008 goto out;
3009 }
3010 mld = (struct mld_msg *) icmp6_hdr(skb);
3011 max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));
3012 if (max_delay)
3013 group = &mld->mld_mca;
3014 } else {
3015 if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) {
3016 err = -EINVAL;
3017 goto out;
3018 }
3019 mld2q = (struct mld2_query *)icmp6_hdr(skb);
3020 if (!mld2q->mld2q_nsrcs)
3021 group = &mld2q->mld2q_mca;
3345 goto out;
3346
3347 if (transport_len == sizeof(*mld)) {
3348 if (!pskb_may_pull(skb, offset + sizeof(*mld))) {
3349 err = -EINVAL;
3350 goto out;
3351 }
3352 mld = (struct mld_msg *) icmp6_hdr(skb);
3353 max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));
3354 if (max_delay)
3355 group = &mld->mld_mca;
3356 } else {
3357 if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) {
3358 err = -EINVAL;
3359 goto out;
3360 }
3361 mld2q = (struct mld2_query *)icmp6_hdr(skb);
3362 if (!mld2q->mld2q_nsrcs)
3363 group = &mld2q->mld2q_mca;
3022 if (br->multicast_mld_version == 2 &&
3364 if (brmctx->multicast_mld_version == 2 &&
3023 !ipv6_addr_any(&mld2q->mld2q_mca) &&
3024 mld2q->mld2q_suppress)
3025 goto out;
3026
3027 max_delay = max(msecs_to_jiffies(mldv2_mrc(mld2q)), 1UL);
3028 }
3029
3030 is_general_query = group && ipv6_addr_any(group);
3031
3032 if (is_general_query) {
3033 saddr.proto = htons(ETH_P_IPV6);
3034 saddr.src.ip6 = ipv6_hdr(skb)->saddr;
3035
3365 !ipv6_addr_any(&mld2q->mld2q_mca) &&
3366 mld2q->mld2q_suppress)
3367 goto out;
3368
3369 max_delay = max(msecs_to_jiffies(mldv2_mrc(mld2q)), 1UL);
3370 }
3371
3372 is_general_query = group && ipv6_addr_any(group);
3373
3374 if (is_general_query) {
3375 saddr.proto = htons(ETH_P_IPV6);
3376 saddr.src.ip6 = ipv6_hdr(skb)->saddr;
3377
3036 br_ip6_multicast_query_received(br, port, &br->ip6_other_query,
3378 br_ip6_multicast_query_received(brmctx, pmctx,
3379 &brmctx->ip6_other_query,
3037 &saddr, max_delay);
3038 goto out;
3039 } else if (!group) {
3040 goto out;
3041 }
3042
3380 &saddr, max_delay);
3381 goto out;
3382 } else if (!group) {
3383 goto out;
3384 }
3385
3043 mp = br_mdb_ip6_get(br, group, vid);
3386 mp = br_mdb_ip6_get(brmctx->br, group, vid);
3044 if (!mp)
3045 goto out;
3046
3387 if (!mp)
3388 goto out;
3389
3047 max_delay *= br->multicast_last_member_count;
3390 max_delay *= brmctx->multicast_last_member_count;
3048 if (mp->host_joined &&
3049 (timer_pending(&mp->timer) ?
3050 time_after(mp->timer.expires, now + max_delay) :
3051 try_to_del_timer_sync(&mp->timer) >= 0))
3052 mod_timer(&mp->timer, now + max_delay);
3053
3054 for (pp = &mp->ports;
3391 if (mp->host_joined &&
3392 (timer_pending(&mp->timer) ?
3393 time_after(mp->timer.expires, now + max_delay) :
3394 try_to_del_timer_sync(&mp->timer) >= 0))
3395 mod_timer(&mp->timer, now + max_delay);
3396
3397 for (pp = &mp->ports;
3055 (p = mlock_dereference(*pp, br)) != NULL;
3398 (p = mlock_dereference(*pp, brmctx->br)) != NULL;
3056 pp = &p->next) {
3057 if (timer_pending(&p->timer) ?
3058 time_after(p->timer.expires, now + max_delay) :
3059 try_to_del_timer_sync(&p->timer) >= 0 &&
3399 pp = &p->next) {
3400 if (timer_pending(&p->timer) ?
3401 time_after(p->timer.expires, now + max_delay) :
3402 try_to_del_timer_sync(&p->timer) >= 0 &&
3060 (br->multicast_mld_version == 1 ||
3403 (brmctx->multicast_mld_version == 1 ||
3061 p->filter_mode == MCAST_EXCLUDE))
3062 mod_timer(&p->timer, now + max_delay);
3063 }
3064
3065out:
3404 p->filter_mode == MCAST_EXCLUDE))
3405 mod_timer(&p->timer, now + max_delay);
3406 }
3407
3408out:
3066 spin_unlock(&br->multicast_lock);
3409 spin_unlock(&brmctx->br->multicast_lock);
3067 return err;
3068}
3069#endif
3070
3071static void
3410 return err;
3411}
3412#endif
3413
3414static void
3072br_multicast_leave_group(struct net_bridge *br,
3073 struct net_bridge_port *port,
3415br_multicast_leave_group(struct net_bridge_mcast *brmctx,
3416 struct net_bridge_mcast_port *pmctx,
3074 struct br_ip *group,
3075 struct bridge_mcast_other_query *other_query,
3076 struct bridge_mcast_own_query *own_query,
3077 const unsigned char *src)
3078{
3079 struct net_bridge_mdb_entry *mp;
3080 struct net_bridge_port_group *p;
3081 unsigned long now;
3082 unsigned long time;
3083
3417 struct br_ip *group,
3418 struct bridge_mcast_other_query *other_query,
3419 struct bridge_mcast_own_query *own_query,
3420 const unsigned char *src)
3421{
3422 struct net_bridge_mdb_entry *mp;
3423 struct net_bridge_port_group *p;
3424 unsigned long now;
3425 unsigned long time;
3426
3084 spin_lock(&br->multicast_lock);
3085 if (!netif_running(br->dev) ||
3086 (port && port->state == BR_STATE_DISABLED))
3427 spin_lock(&brmctx->br->multicast_lock);
3428 if (!br_multicast_ctx_should_use(brmctx, pmctx))
3087 goto out;
3088
3429 goto out;
3430
3089 mp = br_mdb_ip_get(br, group);
3431 mp = br_mdb_ip_get(brmctx->br, group);
3090 if (!mp)
3091 goto out;
3092
3432 if (!mp)
3433 goto out;
3434
3093 if (port && (port->flags & BR_MULTICAST_FAST_LEAVE)) {
3435 if (pmctx && (pmctx->port->flags & BR_MULTICAST_FAST_LEAVE)) {
3094 struct net_bridge_port_group __rcu **pp;
3095
3096 for (pp = &mp->ports;
3436 struct net_bridge_port_group __rcu **pp;
3437
3438 for (pp = &mp->ports;
3097 (p = mlock_dereference(*pp, br)) != NULL;
3439 (p = mlock_dereference(*pp, brmctx->br)) != NULL;
3098 pp = &p->next) {
3440 pp = &p->next) {
3099 if (!br_port_group_equal(p, port, src))
3441 if (!br_port_group_equal(p, pmctx->port, src))
3100 continue;
3101
3102 if (p->flags & MDB_PG_FLAGS_PERMANENT)
3103 break;
3104
3105 p->flags |= MDB_PG_FLAGS_FAST_LEAVE;
3106 br_multicast_del_pg(mp, p, pp);
3107 }
3108 goto out;
3109 }
3110
3111 if (timer_pending(&other_query->timer))
3112 goto out;
3113
3442 continue;
3443
3444 if (p->flags & MDB_PG_FLAGS_PERMANENT)
3445 break;
3446
3447 p->flags |= MDB_PG_FLAGS_FAST_LEAVE;
3448 br_multicast_del_pg(mp, p, pp);
3449 }
3450 goto out;
3451 }
3452
3453 if (timer_pending(&other_query->timer))
3454 goto out;
3455
3114 if (br_opt_get(br, BROPT_MULTICAST_QUERIER)) {
3115 __br_multicast_send_query(br, port, NULL, NULL, &mp->addr,
3456 if (brmctx->multicast_querier) {
3457 __br_multicast_send_query(brmctx, pmctx, NULL, NULL, &mp->addr,
3116 false, 0, NULL);
3117
3458 false, 0, NULL);
3459
3118 time = jiffies + br->multicast_last_member_count *
3119 br->multicast_last_member_interval;
3460 time = jiffies + brmctx->multicast_last_member_count *
3461 brmctx->multicast_last_member_interval;
3120
3121 mod_timer(&own_query->timer, time);
3122
3462
3463 mod_timer(&own_query->timer, time);
3464
3123 for (p = mlock_dereference(mp->ports, br);
3124 p != NULL;
3125 p = mlock_dereference(p->next, br)) {
3126 if (!br_port_group_equal(p, port, src))
3465 for (p = mlock_dereference(mp->ports, brmctx->br);
3466 p != NULL && pmctx != NULL;
3467 p = mlock_dereference(p->next, brmctx->br)) {
3468 if (!br_port_group_equal(p, pmctx->port, src))
3127 continue;
3128
3129 if (!hlist_unhashed(&p->mglist) &&
3130 (timer_pending(&p->timer) ?
3131 time_after(p->timer.expires, time) :
3132 try_to_del_timer_sync(&p->timer) >= 0)) {
3133 mod_timer(&p->timer, time);
3134 }
3135
3136 break;
3137 }
3138 }
3139
3140 now = jiffies;
3469 continue;
3470
3471 if (!hlist_unhashed(&p->mglist) &&
3472 (timer_pending(&p->timer) ?
3473 time_after(p->timer.expires, time) :
3474 try_to_del_timer_sync(&p->timer) >= 0)) {
3475 mod_timer(&p->timer, time);
3476 }
3477
3478 break;
3479 }
3480 }
3481
3482 now = jiffies;
3141 time = now + br->multicast_last_member_count *
3142 br->multicast_last_member_interval;
3483 time = now + brmctx->multicast_last_member_count *
3484 brmctx->multicast_last_member_interval;
3143
3485
3144 if (!port) {
3486 if (!pmctx) {
3145 if (mp->host_joined &&
3146 (timer_pending(&mp->timer) ?
3147 time_after(mp->timer.expires, time) :
3148 try_to_del_timer_sync(&mp->timer) >= 0)) {
3149 mod_timer(&mp->timer, time);
3150 }
3151
3152 goto out;
3153 }
3154
3487 if (mp->host_joined &&
3488 (timer_pending(&mp->timer) ?
3489 time_after(mp->timer.expires, time) :
3490 try_to_del_timer_sync(&mp->timer) >= 0)) {
3491 mod_timer(&mp->timer, time);
3492 }
3493
3494 goto out;
3495 }
3496
3155 for (p = mlock_dereference(mp->ports, br);
3497 for (p = mlock_dereference(mp->ports, brmctx->br);
3156 p != NULL;
3498 p != NULL;
3157 p = mlock_dereference(p->next, br)) {
3158 if (p->key.port != port)
3499 p = mlock_dereference(p->next, brmctx->br)) {
3500 if (p->key.port != pmctx->port)
3159 continue;
3160
3161 if (!hlist_unhashed(&p->mglist) &&
3162 (timer_pending(&p->timer) ?
3163 time_after(p->timer.expires, time) :
3164 try_to_del_timer_sync(&p->timer) >= 0)) {
3165 mod_timer(&p->timer, time);
3166 }
3167
3168 break;
3169 }
3170out:
3501 continue;
3502
3503 if (!hlist_unhashed(&p->mglist) &&
3504 (timer_pending(&p->timer) ?
3505 time_after(p->timer.expires, time) :
3506 try_to_del_timer_sync(&p->timer) >= 0)) {
3507 mod_timer(&p->timer, time);
3508 }
3509
3510 break;
3511 }
3512out:
3171 spin_unlock(&br->multicast_lock);
3513 spin_unlock(&brmctx->br->multicast_lock);
3172}
3173
3514}
3515
3174static void br_ip4_multicast_leave_group(struct net_bridge *br,
3175 struct net_bridge_port *port,
3516static void br_ip4_multicast_leave_group(struct net_bridge_mcast *brmctx,
3517 struct net_bridge_mcast_port *pmctx,
3176 __be32 group,
3177 __u16 vid,
3178 const unsigned char *src)
3179{
3180 struct br_ip br_group;
3181 struct bridge_mcast_own_query *own_query;
3182
3183 if (ipv4_is_local_multicast(group))
3184 return;
3185
3518 __be32 group,
3519 __u16 vid,
3520 const unsigned char *src)
3521{
3522 struct br_ip br_group;
3523 struct bridge_mcast_own_query *own_query;
3524
3525 if (ipv4_is_local_multicast(group))
3526 return;
3527
3186 own_query = port ? &port->ip4_own_query : &br->ip4_own_query;
3528 own_query = pmctx ? &pmctx->ip4_own_query : &brmctx->ip4_own_query;
3187
3188 memset(&br_group, 0, sizeof(br_group));
3189 br_group.dst.ip4 = group;
3190 br_group.proto = htons(ETH_P_IP);
3191 br_group.vid = vid;
3192
3529
3530 memset(&br_group, 0, sizeof(br_group));
3531 br_group.dst.ip4 = group;
3532 br_group.proto = htons(ETH_P_IP);
3533 br_group.vid = vid;
3534
3193 br_multicast_leave_group(br, port, &br_group, &br->ip4_other_query,
3535 br_multicast_leave_group(brmctx, pmctx, &br_group,
3536 &brmctx->ip4_other_query,
3194 own_query, src);
3195}
3196
3197#if IS_ENABLED(CONFIG_IPV6)
3537 own_query, src);
3538}
3539
3540#if IS_ENABLED(CONFIG_IPV6)
3198static void br_ip6_multicast_leave_group(struct net_bridge *br,
3199 struct net_bridge_port *port,
3541static void br_ip6_multicast_leave_group(struct net_bridge_mcast *brmctx,
3542 struct net_bridge_mcast_port *pmctx,
3200 const struct in6_addr *group,
3201 __u16 vid,
3202 const unsigned char *src)
3203{
3204 struct br_ip br_group;
3205 struct bridge_mcast_own_query *own_query;
3206
3207 if (ipv6_addr_is_ll_all_nodes(group))
3208 return;
3209
3543 const struct in6_addr *group,
3544 __u16 vid,
3545 const unsigned char *src)
3546{
3547 struct br_ip br_group;
3548 struct bridge_mcast_own_query *own_query;
3549
3550 if (ipv6_addr_is_ll_all_nodes(group))
3551 return;
3552
3210 own_query = port ? &port->ip6_own_query : &br->ip6_own_query;
3553 own_query = pmctx ? &pmctx->ip6_own_query : &brmctx->ip6_own_query;
3211
3212 memset(&br_group, 0, sizeof(br_group));
3213 br_group.dst.ip6 = *group;
3214 br_group.proto = htons(ETH_P_IPV6);
3215 br_group.vid = vid;
3216
3554
3555 memset(&br_group, 0, sizeof(br_group));
3556 br_group.dst.ip6 = *group;
3557 br_group.proto = htons(ETH_P_IPV6);
3558 br_group.vid = vid;
3559
3217 br_multicast_leave_group(br, port, &br_group, &br->ip6_other_query,
3560 br_multicast_leave_group(brmctx, pmctx, &br_group,
3561 &brmctx->ip6_other_query,
3218 own_query, src);
3219}
3220#endif
3221
3222static void br_multicast_err_count(const struct net_bridge *br,
3223 const struct net_bridge_port *p,
3224 __be16 proto)
3225{

--- 21 unchanged lines hidden (view full) ---

3247 case htons(ETH_P_IPV6):
3248 pstats->mstats.mld_parse_errors++;
3249 break;
3250#endif
3251 }
3252 u64_stats_update_end(&pstats->syncp);
3253}
3254
3562 own_query, src);
3563}
3564#endif
3565
3566static void br_multicast_err_count(const struct net_bridge *br,
3567 const struct net_bridge_port *p,
3568 __be16 proto)
3569{

--- 21 unchanged lines hidden (view full) ---

3591 case htons(ETH_P_IPV6):
3592 pstats->mstats.mld_parse_errors++;
3593 break;
3594#endif
3595 }
3596 u64_stats_update_end(&pstats->syncp);
3597}
3598
3255static void br_multicast_pim(struct net_bridge *br,
3256 struct net_bridge_port *port,
3599static void br_multicast_pim(struct net_bridge_mcast *brmctx,
3600 struct net_bridge_mcast_port *pmctx,
3257 const struct sk_buff *skb)
3258{
3259 unsigned int offset = skb_transport_offset(skb);
3260 struct pimhdr *pimhdr, _pimhdr;
3261
3262 pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr);
3263 if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION ||
3264 pim_hdr_type(pimhdr) != PIM_TYPE_HELLO)
3265 return;
3266
3601 const struct sk_buff *skb)
3602{
3603 unsigned int offset = skb_transport_offset(skb);
3604 struct pimhdr *pimhdr, _pimhdr;
3605
3606 pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr);
3607 if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION ||
3608 pim_hdr_type(pimhdr) != PIM_TYPE_HELLO)
3609 return;
3610
3267 spin_lock(&br->multicast_lock);
3268 br_ip4_multicast_mark_router(br, port);
3269 spin_unlock(&br->multicast_lock);
3611 spin_lock(&brmctx->br->multicast_lock);
3612 br_ip4_multicast_mark_router(brmctx, pmctx);
3613 spin_unlock(&brmctx->br->multicast_lock);
3270}
3271
3614}
3615
3272static int br_ip4_multicast_mrd_rcv(struct net_bridge *br,
3273 struct net_bridge_port *port,
3616static int br_ip4_multicast_mrd_rcv(struct net_bridge_mcast *brmctx,
3617 struct net_bridge_mcast_port *pmctx,
3274 struct sk_buff *skb)
3275{
3276 if (ip_hdr(skb)->protocol != IPPROTO_IGMP ||
3277 igmp_hdr(skb)->type != IGMP_MRDISC_ADV)
3278 return -ENOMSG;
3279
3618 struct sk_buff *skb)
3619{
3620 if (ip_hdr(skb)->protocol != IPPROTO_IGMP ||
3621 igmp_hdr(skb)->type != IGMP_MRDISC_ADV)
3622 return -ENOMSG;
3623
3280 spin_lock(&br->multicast_lock);
3281 br_ip4_multicast_mark_router(br, port);
3282 spin_unlock(&br->multicast_lock);
3624 spin_lock(&brmctx->br->multicast_lock);
3625 br_ip4_multicast_mark_router(brmctx, pmctx);
3626 spin_unlock(&brmctx->br->multicast_lock);
3283
3284 return 0;
3285}
3286
3627
3628 return 0;
3629}
3630
3287static int br_multicast_ipv4_rcv(struct net_bridge *br,
3288 struct net_bridge_port *port,
3631static int br_multicast_ipv4_rcv(struct net_bridge_mcast *brmctx,
3632 struct net_bridge_mcast_port *pmctx,
3289 struct sk_buff *skb,
3290 u16 vid)
3291{
3633 struct sk_buff *skb,
3634 u16 vid)
3635{
3636 struct net_bridge_port *p = pmctx ? pmctx->port : NULL;
3292 const unsigned char *src;
3293 struct igmphdr *ih;
3294 int err;
3295
3296 err = ip_mc_check_igmp(skb);
3297
3298 if (err == -ENOMSG) {
3299 if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) {
3300 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
3301 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) {
3302 if (ip_hdr(skb)->protocol == IPPROTO_PIM)
3637 const unsigned char *src;
3638 struct igmphdr *ih;
3639 int err;
3640
3641 err = ip_mc_check_igmp(skb);
3642
3643 if (err == -ENOMSG) {
3644 if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) {
3645 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
3646 } else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) {
3647 if (ip_hdr(skb)->protocol == IPPROTO_PIM)
3303 br_multicast_pim(br, port, skb);
3648 br_multicast_pim(brmctx, pmctx, skb);
3304 } else if (ipv4_is_all_snoopers(ip_hdr(skb)->daddr)) {
3649 } else if (ipv4_is_all_snoopers(ip_hdr(skb)->daddr)) {
3305 br_ip4_multicast_mrd_rcv(br, port, skb);
3650 br_ip4_multicast_mrd_rcv(brmctx, pmctx, skb);
3306 }
3307
3308 return 0;
3309 } else if (err < 0) {
3651 }
3652
3653 return 0;
3654 } else if (err < 0) {
3310 br_multicast_err_count(br, port, skb->protocol);
3655 br_multicast_err_count(brmctx->br, p, skb->protocol);
3311 return err;
3312 }
3313
3314 ih = igmp_hdr(skb);
3315 src = eth_hdr(skb)->h_source;
3316 BR_INPUT_SKB_CB(skb)->igmp = ih->type;
3317
3318 switch (ih->type) {
3319 case IGMP_HOST_MEMBERSHIP_REPORT:
3320 case IGMPV2_HOST_MEMBERSHIP_REPORT:
3321 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
3656 return err;
3657 }
3658
3659 ih = igmp_hdr(skb);
3660 src = eth_hdr(skb)->h_source;
3661 BR_INPUT_SKB_CB(skb)->igmp = ih->type;
3662
3663 switch (ih->type) {
3664 case IGMP_HOST_MEMBERSHIP_REPORT:
3665 case IGMPV2_HOST_MEMBERSHIP_REPORT:
3666 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
3322 err = br_ip4_multicast_add_group(br, port, ih->group, vid, src,
3323 true);
3667 err = br_ip4_multicast_add_group(brmctx, pmctx, ih->group, vid,
3668 src, true);
3324 break;
3325 case IGMPV3_HOST_MEMBERSHIP_REPORT:
3669 break;
3670 case IGMPV3_HOST_MEMBERSHIP_REPORT:
3326 err = br_ip4_multicast_igmp3_report(br, port, skb, vid);
3671 err = br_ip4_multicast_igmp3_report(brmctx, pmctx, skb, vid);
3327 break;
3328 case IGMP_HOST_MEMBERSHIP_QUERY:
3672 break;
3673 case IGMP_HOST_MEMBERSHIP_QUERY:
3329 br_ip4_multicast_query(br, port, skb, vid);
3674 br_ip4_multicast_query(brmctx, pmctx, skb, vid);
3330 break;
3331 case IGMP_HOST_LEAVE_MESSAGE:
3675 break;
3676 case IGMP_HOST_LEAVE_MESSAGE:
3332 br_ip4_multicast_leave_group(br, port, ih->group, vid, src);
3677 br_ip4_multicast_leave_group(brmctx, pmctx, ih->group, vid, src);
3333 break;
3334 }
3335
3678 break;
3679 }
3680
3336 br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
3681 br_multicast_count(brmctx->br, p, skb, BR_INPUT_SKB_CB(skb)->igmp,
3337 BR_MCAST_DIR_RX);
3338
3339 return err;
3340}
3341
3342#if IS_ENABLED(CONFIG_IPV6)
3682 BR_MCAST_DIR_RX);
3683
3684 return err;
3685}
3686
3687#if IS_ENABLED(CONFIG_IPV6)
3343static void br_ip6_multicast_mrd_rcv(struct net_bridge *br,
3344 struct net_bridge_port *port,
3688static void br_ip6_multicast_mrd_rcv(struct net_bridge_mcast *brmctx,
3689 struct net_bridge_mcast_port *pmctx,
3345 struct sk_buff *skb)
3346{
3347 if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV)
3348 return;
3349
3690 struct sk_buff *skb)
3691{
3692 if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV)
3693 return;
3694
3350 spin_lock(&br->multicast_lock);
3351 br_ip6_multicast_mark_router(br, port);
3352 spin_unlock(&br->multicast_lock);
3695 spin_lock(&brmctx->br->multicast_lock);
3696 br_ip6_multicast_mark_router(brmctx, pmctx);
3697 spin_unlock(&brmctx->br->multicast_lock);
3353}
3354
3698}
3699
3355static int br_multicast_ipv6_rcv(struct net_bridge *br,
3356 struct net_bridge_port *port,
3700static int br_multicast_ipv6_rcv(struct net_bridge_mcast *brmctx,
3701 struct net_bridge_mcast_port *pmctx,
3357 struct sk_buff *skb,
3358 u16 vid)
3359{
3702 struct sk_buff *skb,
3703 u16 vid)
3704{
3705 struct net_bridge_port *p = pmctx ? pmctx->port : NULL;
3360 const unsigned char *src;
3361 struct mld_msg *mld;
3362 int err;
3363
3364 err = ipv6_mc_check_mld(skb);
3365
3366 if (err == -ENOMSG || err == -ENODATA) {
3367 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr))
3368 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
3369 if (err == -ENODATA &&
3370 ipv6_addr_is_all_snoopers(&ipv6_hdr(skb)->daddr))
3706 const unsigned char *src;
3707 struct mld_msg *mld;
3708 int err;
3709
3710 err = ipv6_mc_check_mld(skb);
3711
3712 if (err == -ENOMSG || err == -ENODATA) {
3713 if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr))
3714 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
3715 if (err == -ENODATA &&
3716 ipv6_addr_is_all_snoopers(&ipv6_hdr(skb)->daddr))
3371 br_ip6_multicast_mrd_rcv(br, port, skb);
3717 br_ip6_multicast_mrd_rcv(brmctx, pmctx, skb);
3372
3373 return 0;
3374 } else if (err < 0) {
3718
3719 return 0;
3720 } else if (err < 0) {
3375 br_multicast_err_count(br, port, skb->protocol);
3721 br_multicast_err_count(brmctx->br, p, skb->protocol);
3376 return err;
3377 }
3378
3379 mld = (struct mld_msg *)skb_transport_header(skb);
3380 BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type;
3381
3382 switch (mld->mld_type) {
3383 case ICMPV6_MGM_REPORT:
3384 src = eth_hdr(skb)->h_source;
3385 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
3722 return err;
3723 }
3724
3725 mld = (struct mld_msg *)skb_transport_header(skb);
3726 BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type;
3727
3728 switch (mld->mld_type) {
3729 case ICMPV6_MGM_REPORT:
3730 src = eth_hdr(skb)->h_source;
3731 BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
3386 err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid,
3387 src, true);
3732 err = br_ip6_multicast_add_group(brmctx, pmctx, &mld->mld_mca,
3733 vid, src, true);
3388 break;
3389 case ICMPV6_MLD2_REPORT:
3734 break;
3735 case ICMPV6_MLD2_REPORT:
3390 err = br_ip6_multicast_mld2_report(br, port, skb, vid);
3736 err = br_ip6_multicast_mld2_report(brmctx, pmctx, skb, vid);
3391 break;
3392 case ICMPV6_MGM_QUERY:
3737 break;
3738 case ICMPV6_MGM_QUERY:
3393 err = br_ip6_multicast_query(br, port, skb, vid);
3739 err = br_ip6_multicast_query(brmctx, pmctx, skb, vid);
3394 break;
3395 case ICMPV6_MGM_REDUCTION:
3396 src = eth_hdr(skb)->h_source;
3740 break;
3741 case ICMPV6_MGM_REDUCTION:
3742 src = eth_hdr(skb)->h_source;
3397 br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid, src);
3743 br_ip6_multicast_leave_group(brmctx, pmctx, &mld->mld_mca, vid,
3744 src);
3398 break;
3399 }
3400
3745 break;
3746 }
3747
3401 br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
3748 br_multicast_count(brmctx->br, p, skb, BR_INPUT_SKB_CB(skb)->igmp,
3402 BR_MCAST_DIR_RX);
3403
3404 return err;
3405}
3406#endif
3407
3749 BR_MCAST_DIR_RX);
3750
3751 return err;
3752}
3753#endif
3754
3408int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
3755int br_multicast_rcv(struct net_bridge_mcast **brmctx,
3756 struct net_bridge_mcast_port **pmctx,
3757 struct net_bridge_vlan *vlan,
3409 struct sk_buff *skb, u16 vid)
3410{
3411 int ret = 0;
3412
3413 BR_INPUT_SKB_CB(skb)->igmp = 0;
3414 BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
3415
3758 struct sk_buff *skb, u16 vid)
3759{
3760 int ret = 0;
3761
3762 BR_INPUT_SKB_CB(skb)->igmp = 0;
3763 BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
3764
3416 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
3765 if (!br_opt_get((*brmctx)->br, BROPT_MULTICAST_ENABLED))
3417 return 0;
3418
3766 return 0;
3767
3768 if (br_opt_get((*brmctx)->br, BROPT_MCAST_VLAN_SNOOPING_ENABLED) && vlan) {
3769 const struct net_bridge_vlan *masterv;
3770
3771 /* the vlan has the master flag set only when transmitting
3772 * through the bridge device
3773 */
3774 if (br_vlan_is_master(vlan)) {
3775 masterv = vlan;
3776 *brmctx = &vlan->br_mcast_ctx;
3777 *pmctx = NULL;
3778 } else {
3779 masterv = vlan->brvlan;
3780 *brmctx = &vlan->brvlan->br_mcast_ctx;
3781 *pmctx = &vlan->port_mcast_ctx;
3782 }
3783
3784 if (!(masterv->priv_flags & BR_VLFLAG_GLOBAL_MCAST_ENABLED))
3785 return 0;
3786 }
3787
3419 switch (skb->protocol) {
3420 case htons(ETH_P_IP):
3788 switch (skb->protocol) {
3789 case htons(ETH_P_IP):
3421 ret = br_multicast_ipv4_rcv(br, port, skb, vid);
3790 ret = br_multicast_ipv4_rcv(*brmctx, *pmctx, skb, vid);
3422 break;
3423#if IS_ENABLED(CONFIG_IPV6)
3424 case htons(ETH_P_IPV6):
3791 break;
3792#if IS_ENABLED(CONFIG_IPV6)
3793 case htons(ETH_P_IPV6):
3425 ret = br_multicast_ipv6_rcv(br, port, skb, vid);
3794 ret = br_multicast_ipv6_rcv(*brmctx, *pmctx, skb, vid);
3426 break;
3427#endif
3428 }
3429
3430 return ret;
3431}
3432
3795 break;
3796#endif
3797 }
3798
3799 return ret;
3800}
3801
3433static void br_multicast_query_expired(struct net_bridge *br,
3802static void br_multicast_query_expired(struct net_bridge_mcast *brmctx,
3434 struct bridge_mcast_own_query *query,
3435 struct bridge_mcast_querier *querier)
3436{
3803 struct bridge_mcast_own_query *query,
3804 struct bridge_mcast_querier *querier)
3805{
3437 spin_lock(&br->multicast_lock);
3438 if (query->startup_sent < br->multicast_startup_query_count)
3806 spin_lock(&brmctx->br->multicast_lock);
3807 if (br_multicast_ctx_vlan_disabled(brmctx))
3808 goto out;
3809
3810 if (query->startup_sent < brmctx->multicast_startup_query_count)
3439 query->startup_sent++;
3440
3811 query->startup_sent++;
3812
3441 RCU_INIT_POINTER(querier->port, NULL);
3442 br_multicast_send_query(br, NULL, query);
3443 spin_unlock(&br->multicast_lock);
3813 br_multicast_send_query(brmctx, NULL, query);
3814out:
3815 spin_unlock(&brmctx->br->multicast_lock);
3444}
3445
3446static void br_ip4_multicast_query_expired(struct timer_list *t)
3447{
3816}
3817
3818static void br_ip4_multicast_query_expired(struct timer_list *t)
3819{
3448 struct net_bridge *br = from_timer(br, t, ip4_own_query.timer);
3820 struct net_bridge_mcast *brmctx = from_timer(brmctx, t,
3821 ip4_own_query.timer);
3449
3822
3450 br_multicast_query_expired(br, &br->ip4_own_query, &br->ip4_querier);
3823 br_multicast_query_expired(brmctx, &brmctx->ip4_own_query,
3824 &brmctx->ip4_querier);
3451}
3452
3453#if IS_ENABLED(CONFIG_IPV6)
3454static void br_ip6_multicast_query_expired(struct timer_list *t)
3455{
3825}
3826
3827#if IS_ENABLED(CONFIG_IPV6)
3828static void br_ip6_multicast_query_expired(struct timer_list *t)
3829{
3456 struct net_bridge *br = from_timer(br, t, ip6_own_query.timer);
3830 struct net_bridge_mcast *brmctx = from_timer(brmctx, t,
3831 ip6_own_query.timer);
3457
3832
3458 br_multicast_query_expired(br, &br->ip6_own_query, &br->ip6_querier);
3833 br_multicast_query_expired(brmctx, &brmctx->ip6_own_query,
3834 &brmctx->ip6_querier);
3459}
3460#endif
3461
3462static void br_multicast_gc_work(struct work_struct *work)
3463{
3464 struct net_bridge *br = container_of(work, struct net_bridge,
3465 mcast_gc_work);
3466 HLIST_HEAD(deleted_head);
3467
3468 spin_lock_bh(&br->multicast_lock);
3469 hlist_move_list(&br->mcast_gc_list, &deleted_head);
3470 spin_unlock_bh(&br->multicast_lock);
3471
3472 br_multicast_gc(&deleted_head);
3473}
3474
3835}
3836#endif
3837
3838static void br_multicast_gc_work(struct work_struct *work)
3839{
3840 struct net_bridge *br = container_of(work, struct net_bridge,
3841 mcast_gc_work);
3842 HLIST_HEAD(deleted_head);
3843
3844 spin_lock_bh(&br->multicast_lock);
3845 hlist_move_list(&br->mcast_gc_list, &deleted_head);
3846 spin_unlock_bh(&br->multicast_lock);
3847
3848 br_multicast_gc(&deleted_head);
3849}
3850
3475void br_multicast_init(struct net_bridge *br)
3851void br_multicast_ctx_init(struct net_bridge *br,
3852 struct net_bridge_vlan *vlan,
3853 struct net_bridge_mcast *brmctx)
3476{
3854{
3477 br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX;
3855 brmctx->br = br;
3856 brmctx->vlan = vlan;
3857 brmctx->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
3858 brmctx->multicast_last_member_count = 2;
3859 brmctx->multicast_startup_query_count = 2;
3478
3860
3479 br->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
3480 br->multicast_last_member_count = 2;
3481 br->multicast_startup_query_count = 2;
3861 brmctx->multicast_last_member_interval = HZ;
3862 brmctx->multicast_query_response_interval = 10 * HZ;
3863 brmctx->multicast_startup_query_interval = 125 * HZ / 4;
3864 brmctx->multicast_query_interval = 125 * HZ;
3865 brmctx->multicast_querier_interval = 255 * HZ;
3866 brmctx->multicast_membership_interval = 260 * HZ;
3482
3867
3483 br->multicast_last_member_interval = HZ;
3484 br->multicast_query_response_interval = 10 * HZ;
3485 br->multicast_startup_query_interval = 125 * HZ / 4;
3486 br->multicast_query_interval = 125 * HZ;
3487 br->multicast_querier_interval = 255 * HZ;
3488 br->multicast_membership_interval = 260 * HZ;
3489
3490 br->ip4_other_query.delay_time = 0;
3491 br->ip4_querier.port = NULL;
3492 br->multicast_igmp_version = 2;
3868 brmctx->ip4_other_query.delay_time = 0;
3869 brmctx->ip4_querier.port_ifidx = 0;
3870 seqcount_init(&brmctx->ip4_querier.seq);
3871 brmctx->multicast_igmp_version = 2;
3493#if IS_ENABLED(CONFIG_IPV6)
3872#if IS_ENABLED(CONFIG_IPV6)
3494 br->multicast_mld_version = 1;
3495 br->ip6_other_query.delay_time = 0;
3496 br->ip6_querier.port = NULL;
3873 brmctx->multicast_mld_version = 1;
3874 brmctx->ip6_other_query.delay_time = 0;
3875 brmctx->ip6_querier.port_ifidx = 0;
3876 seqcount_init(&brmctx->ip6_querier.seq);
3497#endif
3877#endif
3498 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true);
3499 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
3500
3878
3501 spin_lock_init(&br->multicast_lock);
3502 timer_setup(&br->ip4_mc_router_timer,
3879 timer_setup(&brmctx->ip4_mc_router_timer,
3503 br_ip4_multicast_local_router_expired, 0);
3880 br_ip4_multicast_local_router_expired, 0);
3504 timer_setup(&br->ip4_other_query.timer,
3881 timer_setup(&brmctx->ip4_other_query.timer,
3505 br_ip4_multicast_querier_expired, 0);
3882 br_ip4_multicast_querier_expired, 0);
3506 timer_setup(&br->ip4_own_query.timer,
3883 timer_setup(&brmctx->ip4_own_query.timer,
3507 br_ip4_multicast_query_expired, 0);
3508#if IS_ENABLED(CONFIG_IPV6)
3884 br_ip4_multicast_query_expired, 0);
3885#if IS_ENABLED(CONFIG_IPV6)
3509 timer_setup(&br->ip6_mc_router_timer,
3886 timer_setup(&brmctx->ip6_mc_router_timer,
3510 br_ip6_multicast_local_router_expired, 0);
3887 br_ip6_multicast_local_router_expired, 0);
3511 timer_setup(&br->ip6_other_query.timer,
3888 timer_setup(&brmctx->ip6_other_query.timer,
3512 br_ip6_multicast_querier_expired, 0);
3889 br_ip6_multicast_querier_expired, 0);
3513 timer_setup(&br->ip6_own_query.timer,
3890 timer_setup(&brmctx->ip6_own_query.timer,
3514 br_ip6_multicast_query_expired, 0);
3515#endif
3891 br_ip6_multicast_query_expired, 0);
3892#endif
3893}
3894
3895void br_multicast_ctx_deinit(struct net_bridge_mcast *brmctx)
3896{
3897 __br_multicast_stop(brmctx);
3898}
3899
3900void br_multicast_init(struct net_bridge *br)
3901{
3902 br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX;
3903
3904 br_multicast_ctx_init(br, NULL, &br->multicast_ctx);
3905
3906 br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true);
3907 br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
3908
3909 spin_lock_init(&br->multicast_lock);
3516 INIT_HLIST_HEAD(&br->mdb_list);
3517 INIT_HLIST_HEAD(&br->mcast_gc_list);
3518 INIT_WORK(&br->mcast_gc_work, br_multicast_gc_work);
3519}
3520
3521static void br_ip4_multicast_join_snoopers(struct net_bridge *br)
3522{
3523 struct in_device *in_dev = in_dev_get(br->dev);

--- 51 unchanged lines hidden (view full) ---

3575#endif
3576
3577void br_multicast_leave_snoopers(struct net_bridge *br)
3578{
3579 br_ip4_multicast_leave_snoopers(br);
3580 br_ip6_multicast_leave_snoopers(br);
3581}
3582
3910 INIT_HLIST_HEAD(&br->mdb_list);
3911 INIT_HLIST_HEAD(&br->mcast_gc_list);
3912 INIT_WORK(&br->mcast_gc_work, br_multicast_gc_work);
3913}
3914
3915static void br_ip4_multicast_join_snoopers(struct net_bridge *br)
3916{
3917 struct in_device *in_dev = in_dev_get(br->dev);

--- 51 unchanged lines hidden (view full) ---

3969#endif
3970
3971void br_multicast_leave_snoopers(struct net_bridge *br)
3972{
3973 br_ip4_multicast_leave_snoopers(br);
3974 br_ip6_multicast_leave_snoopers(br);
3975}
3976
3583static void __br_multicast_open(struct net_bridge *br,
3584 struct bridge_mcast_own_query *query)
3977static void __br_multicast_open_query(struct net_bridge *br,
3978 struct bridge_mcast_own_query *query)
3585{
3586 query->startup_sent = 0;
3587
3588 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
3589 return;
3590
3591 mod_timer(&query->timer, jiffies);
3592}
3593
3979{
3980 query->startup_sent = 0;
3981
3982 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
3983 return;
3984
3985 mod_timer(&query->timer, jiffies);
3986}
3987
3594void br_multicast_open(struct net_bridge *br)
3988static void __br_multicast_open(struct net_bridge_mcast *brmctx)
3595{
3989{
3596 __br_multicast_open(br, &br->ip4_own_query);
3990 __br_multicast_open_query(brmctx->br, &brmctx->ip4_own_query);
3597#if IS_ENABLED(CONFIG_IPV6)
3991#if IS_ENABLED(CONFIG_IPV6)
3598 __br_multicast_open(br, &br->ip6_own_query);
3992 __br_multicast_open_query(brmctx->br, &brmctx->ip6_own_query);
3599#endif
3600}
3601
3993#endif
3994}
3995
3602void br_multicast_stop(struct net_bridge *br)
3996void br_multicast_open(struct net_bridge *br)
3603{
3997{
3604 del_timer_sync(&br->ip4_mc_router_timer);
3605 del_timer_sync(&br->ip4_other_query.timer);
3606 del_timer_sync(&br->ip4_own_query.timer);
3998 ASSERT_RTNL();
3999
4000 if (br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) {
4001 struct net_bridge_vlan_group *vg;
4002 struct net_bridge_vlan *vlan;
4003
4004 vg = br_vlan_group(br);
4005 if (vg) {
4006 list_for_each_entry(vlan, &vg->vlan_list, vlist) {
4007 struct net_bridge_mcast *brmctx;
4008
4009 brmctx = &vlan->br_mcast_ctx;
4010 if (br_vlan_is_brentry(vlan) &&
4011 !br_multicast_ctx_vlan_disabled(brmctx))
4012 __br_multicast_open(&vlan->br_mcast_ctx);
4013 }
4014 }
4015 } else {
4016 __br_multicast_open(&br->multicast_ctx);
4017 }
4018}
4019
4020static void __br_multicast_stop(struct net_bridge_mcast *brmctx)
4021{
4022 del_timer_sync(&brmctx->ip4_mc_router_timer);
4023 del_timer_sync(&brmctx->ip4_other_query.timer);
4024 del_timer_sync(&brmctx->ip4_own_query.timer);
3607#if IS_ENABLED(CONFIG_IPV6)
4025#if IS_ENABLED(CONFIG_IPV6)
3608 del_timer_sync(&br->ip6_mc_router_timer);
3609 del_timer_sync(&br->ip6_other_query.timer);
3610 del_timer_sync(&br->ip6_own_query.timer);
4026 del_timer_sync(&brmctx->ip6_mc_router_timer);
4027 del_timer_sync(&brmctx->ip6_other_query.timer);
4028 del_timer_sync(&brmctx->ip6_own_query.timer);
3611#endif
3612}
3613
4029#endif
4030}
4031
4032void br_multicast_toggle_one_vlan(struct net_bridge_vlan *vlan, bool on)
4033{
4034 struct net_bridge *br;
4035
4036 /* it's okay to check for the flag without the multicast lock because it
4037 * can only change under RTNL -> multicast_lock, we need the latter to
4038 * sync with timers and packets
4039 */
4040 if (on == !!(vlan->priv_flags & BR_VLFLAG_MCAST_ENABLED))
4041 return;
4042
4043 if (br_vlan_is_master(vlan)) {
4044 br = vlan->br;
4045
4046 if (!br_vlan_is_brentry(vlan) ||
4047 (on &&
4048 br_multicast_ctx_vlan_global_disabled(&vlan->br_mcast_ctx)))
4049 return;
4050
4051 spin_lock_bh(&br->multicast_lock);
4052 vlan->priv_flags ^= BR_VLFLAG_MCAST_ENABLED;
4053 spin_unlock_bh(&br->multicast_lock);
4054
4055 if (on)
4056 __br_multicast_open(&vlan->br_mcast_ctx);
4057 else
4058 __br_multicast_stop(&vlan->br_mcast_ctx);
4059 } else {
4060 struct net_bridge_mcast *brmctx;
4061
4062 brmctx = br_multicast_port_ctx_get_global(&vlan->port_mcast_ctx);
4063 if (on && br_multicast_ctx_vlan_global_disabled(brmctx))
4064 return;
4065
4066 br = vlan->port->br;
4067 spin_lock_bh(&br->multicast_lock);
4068 vlan->priv_flags ^= BR_VLFLAG_MCAST_ENABLED;
4069 if (on)
4070 __br_multicast_enable_port_ctx(&vlan->port_mcast_ctx);
4071 else
4072 __br_multicast_disable_port_ctx(&vlan->port_mcast_ctx);
4073 spin_unlock_bh(&br->multicast_lock);
4074 }
4075}
4076
4077static void br_multicast_toggle_vlan(struct net_bridge_vlan *vlan, bool on)
4078{
4079 struct net_bridge_port *p;
4080
4081 if (WARN_ON_ONCE(!br_vlan_is_master(vlan)))
4082 return;
4083
4084 list_for_each_entry(p, &vlan->br->port_list, list) {
4085 struct net_bridge_vlan *vport;
4086
4087 vport = br_vlan_find(nbp_vlan_group(p), vlan->vid);
4088 if (!vport)
4089 continue;
4090 br_multicast_toggle_one_vlan(vport, on);
4091 }
4092
4093 if (br_vlan_is_brentry(vlan))
4094 br_multicast_toggle_one_vlan(vlan, on);
4095}
4096
4097int br_multicast_toggle_vlan_snooping(struct net_bridge *br, bool on,
4098 struct netlink_ext_ack *extack)
4099{
4100 struct net_bridge_vlan_group *vg;
4101 struct net_bridge_vlan *vlan;
4102 struct net_bridge_port *p;
4103
4104 if (br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED) == on)
4105 return 0;
4106
4107 if (on && !br_opt_get(br, BROPT_VLAN_ENABLED)) {
4108 NL_SET_ERR_MSG_MOD(extack, "Cannot enable multicast vlan snooping with vlan filtering disabled");
4109 return -EINVAL;
4110 }
4111
4112 vg = br_vlan_group(br);
4113 if (!vg)
4114 return 0;
4115
4116 br_opt_toggle(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED, on);
4117
4118 /* disable/enable non-vlan mcast contexts based on vlan snooping */
4119 if (on)
4120 __br_multicast_stop(&br->multicast_ctx);
4121 else
4122 __br_multicast_open(&br->multicast_ctx);
4123 list_for_each_entry(p, &br->port_list, list) {
4124 if (on)
4125 br_multicast_disable_port(p);
4126 else
4127 br_multicast_enable_port(p);
4128 }
4129
4130 list_for_each_entry(vlan, &vg->vlan_list, vlist)
4131 br_multicast_toggle_vlan(vlan, on);
4132
4133 return 0;
4134}
4135
4136bool br_multicast_toggle_global_vlan(struct net_bridge_vlan *vlan, bool on)
4137{
4138 ASSERT_RTNL();
4139
4140 /* BR_VLFLAG_GLOBAL_MCAST_ENABLED relies on eventual consistency and
4141 * requires only RTNL to change
4142 */
4143 if (on == !!(vlan->priv_flags & BR_VLFLAG_GLOBAL_MCAST_ENABLED))
4144 return false;
4145
4146 vlan->priv_flags ^= BR_VLFLAG_GLOBAL_MCAST_ENABLED;
4147 br_multicast_toggle_vlan(vlan, on);
4148
4149 return true;
4150}
4151
4152void br_multicast_stop(struct net_bridge *br)
4153{
4154 ASSERT_RTNL();
4155
4156 if (br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) {
4157 struct net_bridge_vlan_group *vg;
4158 struct net_bridge_vlan *vlan;
4159
4160 vg = br_vlan_group(br);
4161 if (vg) {
4162 list_for_each_entry(vlan, &vg->vlan_list, vlist) {
4163 struct net_bridge_mcast *brmctx;
4164
4165 brmctx = &vlan->br_mcast_ctx;
4166 if (br_vlan_is_brentry(vlan) &&
4167 !br_multicast_ctx_vlan_disabled(brmctx))
4168 __br_multicast_stop(&vlan->br_mcast_ctx);
4169 }
4170 }
4171 } else {
4172 __br_multicast_stop(&br->multicast_ctx);
4173 }
4174}
4175
3614void br_multicast_dev_del(struct net_bridge *br)
3615{
3616 struct net_bridge_mdb_entry *mp;
3617 HLIST_HEAD(deleted_head);
3618 struct hlist_node *tmp;
3619
3620 spin_lock_bh(&br->multicast_lock);
3621 hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node)
3622 br_multicast_del_mdb_entry(mp);
3623 hlist_move_list(&br->mcast_gc_list, &deleted_head);
3624 spin_unlock_bh(&br->multicast_lock);
3625
4176void br_multicast_dev_del(struct net_bridge *br)
4177{
4178 struct net_bridge_mdb_entry *mp;
4179 HLIST_HEAD(deleted_head);
4180 struct hlist_node *tmp;
4181
4182 spin_lock_bh(&br->multicast_lock);
4183 hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node)
4184 br_multicast_del_mdb_entry(mp);
4185 hlist_move_list(&br->mcast_gc_list, &deleted_head);
4186 spin_unlock_bh(&br->multicast_lock);
4187
4188 br_multicast_ctx_deinit(&br->multicast_ctx);
3626 br_multicast_gc(&deleted_head);
3627 cancel_work_sync(&br->mcast_gc_work);
3628
3629 rcu_barrier();
3630}
3631
4189 br_multicast_gc(&deleted_head);
4190 cancel_work_sync(&br->mcast_gc_work);
4191
4192 rcu_barrier();
4193}
4194
3632int br_multicast_set_router(struct net_bridge *br, unsigned long val)
4195int br_multicast_set_router(struct net_bridge_mcast *brmctx, unsigned long val)
3633{
3634 int err = -EINVAL;
3635
4196{
4197 int err = -EINVAL;
4198
3636 spin_lock_bh(&br->multicast_lock);
4199 spin_lock_bh(&brmctx->br->multicast_lock);
3637
3638 switch (val) {
3639 case MDB_RTR_TYPE_DISABLED:
3640 case MDB_RTR_TYPE_PERM:
4200
4201 switch (val) {
4202 case MDB_RTR_TYPE_DISABLED:
4203 case MDB_RTR_TYPE_PERM:
3641 br_mc_router_state_change(br, val == MDB_RTR_TYPE_PERM);
3642 del_timer(&br->ip4_mc_router_timer);
4204 br_mc_router_state_change(brmctx->br, val == MDB_RTR_TYPE_PERM);
4205 del_timer(&brmctx->ip4_mc_router_timer);
3643#if IS_ENABLED(CONFIG_IPV6)
4206#if IS_ENABLED(CONFIG_IPV6)
3644 del_timer(&br->ip6_mc_router_timer);
4207 del_timer(&brmctx->ip6_mc_router_timer);
3645#endif
4208#endif
3646 br->multicast_router = val;
4209 brmctx->multicast_router = val;
3647 err = 0;
3648 break;
3649 case MDB_RTR_TYPE_TEMP_QUERY:
4210 err = 0;
4211 break;
4212 case MDB_RTR_TYPE_TEMP_QUERY:
3650 if (br->multicast_router != MDB_RTR_TYPE_TEMP_QUERY)
3651 br_mc_router_state_change(br, false);
3652 br->multicast_router = val;
4213 if (brmctx->multicast_router != MDB_RTR_TYPE_TEMP_QUERY)
4214 br_mc_router_state_change(brmctx->br, false);
4215 brmctx->multicast_router = val;
3653 err = 0;
3654 break;
3655 }
3656
4216 err = 0;
4217 break;
4218 }
4219
3657 spin_unlock_bh(&br->multicast_lock);
4220 spin_unlock_bh(&brmctx->br->multicast_lock);
3658
3659 return err;
3660}
3661
3662static void
4221
4222 return err;
4223}
4224
4225static void
3663br_multicast_rport_del_notify(struct net_bridge_port *p, bool deleted)
4226br_multicast_rport_del_notify(struct net_bridge_mcast_port *pmctx, bool deleted)
3664{
3665 if (!deleted)
3666 return;
3667
3668 /* For backwards compatibility for now, only notify if there is
3669 * no multicast router anymore for both IPv4 and IPv6.
3670 */
4227{
4228 if (!deleted)
4229 return;
4230
4231 /* For backwards compatibility for now, only notify if there is
4232 * no multicast router anymore for both IPv4 and IPv6.
4233 */
3671 if (!hlist_unhashed(&p->ip4_rlist))
4234 if (!hlist_unhashed(&pmctx->ip4_rlist))
3672 return;
3673#if IS_ENABLED(CONFIG_IPV6)
4235 return;
4236#if IS_ENABLED(CONFIG_IPV6)
3674 if (!hlist_unhashed(&p->ip6_rlist))
4237 if (!hlist_unhashed(&pmctx->ip6_rlist))
3675 return;
3676#endif
3677
4238 return;
4239#endif
4240
3678 br_rtr_notify(p->br->dev, p, RTM_DELMDB);
3679 br_port_mc_router_state_change(p, false);
4241 br_rtr_notify(pmctx->port->br->dev, pmctx, RTM_DELMDB);
4242 br_port_mc_router_state_change(pmctx->port, false);
3680
3681 /* don't allow timer refresh */
4243
4244 /* don't allow timer refresh */
3682 if (p->multicast_router == MDB_RTR_TYPE_TEMP)
3683 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
4245 if (pmctx->multicast_router == MDB_RTR_TYPE_TEMP)
4246 pmctx->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
3684}
3685
4247}
4248
3686int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val)
4249int br_multicast_set_port_router(struct net_bridge_mcast_port *pmctx,
4250 unsigned long val)
3687{
4251{
3688 struct net_bridge *br = p->br;
4252 struct net_bridge_mcast *brmctx;
3689 unsigned long now = jiffies;
3690 int err = -EINVAL;
3691 bool del = false;
3692
4253 unsigned long now = jiffies;
4254 int err = -EINVAL;
4255 bool del = false;
4256
3693 spin_lock(&br->multicast_lock);
3694 if (p->multicast_router == val) {
4257 brmctx = br_multicast_port_ctx_get_global(pmctx);
4258 spin_lock_bh(&brmctx->br->multicast_lock);
4259 if (pmctx->multicast_router == val) {
3695 /* Refresh the temp router port timer */
4260 /* Refresh the temp router port timer */
3696 if (p->multicast_router == MDB_RTR_TYPE_TEMP) {
3697 mod_timer(&p->ip4_mc_router_timer,
3698 now + br->multicast_querier_interval);
4261 if (pmctx->multicast_router == MDB_RTR_TYPE_TEMP) {
4262 mod_timer(&pmctx->ip4_mc_router_timer,
4263 now + brmctx->multicast_querier_interval);
3699#if IS_ENABLED(CONFIG_IPV6)
4264#if IS_ENABLED(CONFIG_IPV6)
3700 mod_timer(&p->ip6_mc_router_timer,
3701 now + br->multicast_querier_interval);
4265 mod_timer(&pmctx->ip6_mc_router_timer,
4266 now + brmctx->multicast_querier_interval);
3702#endif
3703 }
3704 err = 0;
3705 goto unlock;
3706 }
3707 switch (val) {
3708 case MDB_RTR_TYPE_DISABLED:
4267#endif
4268 }
4269 err = 0;
4270 goto unlock;
4271 }
4272 switch (val) {
4273 case MDB_RTR_TYPE_DISABLED:
3709 p->multicast_router = MDB_RTR_TYPE_DISABLED;
3710 del |= br_ip4_multicast_rport_del(p);
3711 del_timer(&p->ip4_mc_router_timer);
3712 del |= br_ip6_multicast_rport_del(p);
4274 pmctx->multicast_router = MDB_RTR_TYPE_DISABLED;
4275 del |= br_ip4_multicast_rport_del(pmctx);
4276 del_timer(&pmctx->ip4_mc_router_timer);
4277 del |= br_ip6_multicast_rport_del(pmctx);
3713#if IS_ENABLED(CONFIG_IPV6)
4278#if IS_ENABLED(CONFIG_IPV6)
3714 del_timer(&p->ip6_mc_router_timer);
4279 del_timer(&pmctx->ip6_mc_router_timer);
3715#endif
4280#endif
3716 br_multicast_rport_del_notify(p, del);
4281 br_multicast_rport_del_notify(pmctx, del);
3717 break;
3718 case MDB_RTR_TYPE_TEMP_QUERY:
4282 break;
4283 case MDB_RTR_TYPE_TEMP_QUERY:
3719 p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
3720 del |= br_ip4_multicast_rport_del(p);
3721 del |= br_ip6_multicast_rport_del(p);
3722 br_multicast_rport_del_notify(p, del);
4284 pmctx->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
4285 del |= br_ip4_multicast_rport_del(pmctx);
4286 del |= br_ip6_multicast_rport_del(pmctx);
4287 br_multicast_rport_del_notify(pmctx, del);
3723 break;
3724 case MDB_RTR_TYPE_PERM:
4288 break;
4289 case MDB_RTR_TYPE_PERM:
3725 p->multicast_router = MDB_RTR_TYPE_PERM;
3726 del_timer(&p->ip4_mc_router_timer);
3727 br_ip4_multicast_add_router(br, p);
4290 pmctx->multicast_router = MDB_RTR_TYPE_PERM;
4291 del_timer(&pmctx->ip4_mc_router_timer);
4292 br_ip4_multicast_add_router(brmctx, pmctx);
3728#if IS_ENABLED(CONFIG_IPV6)
4293#if IS_ENABLED(CONFIG_IPV6)
3729 del_timer(&p->ip6_mc_router_timer);
4294 del_timer(&pmctx->ip6_mc_router_timer);
3730#endif
4295#endif
3731 br_ip6_multicast_add_router(br, p);
4296 br_ip6_multicast_add_router(brmctx, pmctx);
3732 break;
3733 case MDB_RTR_TYPE_TEMP:
4297 break;
4298 case MDB_RTR_TYPE_TEMP:
3734 p->multicast_router = MDB_RTR_TYPE_TEMP;
3735 br_ip4_multicast_mark_router(br, p);
3736 br_ip6_multicast_mark_router(br, p);
4299 pmctx->multicast_router = MDB_RTR_TYPE_TEMP;
4300 br_ip4_multicast_mark_router(brmctx, pmctx);
4301 br_ip6_multicast_mark_router(brmctx, pmctx);
3737 break;
3738 default:
3739 goto unlock;
3740 }
3741 err = 0;
3742unlock:
4302 break;
4303 default:
4304 goto unlock;
4305 }
4306 err = 0;
4307unlock:
3743 spin_unlock(&br->multicast_lock);
4308 spin_unlock_bh(&brmctx->br->multicast_lock);
3744
3745 return err;
3746}
3747
4309
4310 return err;
4311}
4312
3748static void br_multicast_start_querier(struct net_bridge *br,
4313int br_multicast_set_vlan_router(struct net_bridge_vlan *v, u8 mcast_router)
4314{
4315 int err;
4316
4317 if (br_vlan_is_master(v))
4318 err = br_multicast_set_router(&v->br_mcast_ctx, mcast_router);
4319 else
4320 err = br_multicast_set_port_router(&v->port_mcast_ctx,
4321 mcast_router);
4322
4323 return err;
4324}
4325
4326static void br_multicast_start_querier(struct net_bridge_mcast *brmctx,
3749 struct bridge_mcast_own_query *query)
3750{
3751 struct net_bridge_port *port;
3752
4327 struct bridge_mcast_own_query *query)
4328{
4329 struct net_bridge_port *port;
4330
3753 __br_multicast_open(br, query);
4331 if (!br_multicast_ctx_matches_vlan_snooping(brmctx))
4332 return;
3754
4333
4334 __br_multicast_open_query(brmctx->br, query);
4335
3755 rcu_read_lock();
4336 rcu_read_lock();
3756 list_for_each_entry_rcu(port, &br->port_list, list) {
3757 if (port->state == BR_STATE_DISABLED ||
3758 port->state == BR_STATE_BLOCKING)
4337 list_for_each_entry_rcu(port, &brmctx->br->port_list, list) {
4338 struct bridge_mcast_own_query *ip4_own_query;
4339#if IS_ENABLED(CONFIG_IPV6)
4340 struct bridge_mcast_own_query *ip6_own_query;
4341#endif
4342
4343 if (br_multicast_port_ctx_state_stopped(&port->multicast_ctx))
3759 continue;
3760
4344 continue;
4345
3761 if (query == &br->ip4_own_query)
3762 br_multicast_enable(&port->ip4_own_query);
4346 if (br_multicast_ctx_is_vlan(brmctx)) {
4347 struct net_bridge_vlan *vlan;
4348
4349 vlan = br_vlan_find(nbp_vlan_group_rcu(port),
4350 brmctx->vlan->vid);
4351 if (!vlan ||
4352 br_multicast_port_ctx_state_stopped(&vlan->port_mcast_ctx))
4353 continue;
4354
4355 ip4_own_query = &vlan->port_mcast_ctx.ip4_own_query;
3763#if IS_ENABLED(CONFIG_IPV6)
4356#if IS_ENABLED(CONFIG_IPV6)
4357 ip6_own_query = &vlan->port_mcast_ctx.ip6_own_query;
4358#endif
4359 } else {
4360 ip4_own_query = &port->multicast_ctx.ip4_own_query;
4361#if IS_ENABLED(CONFIG_IPV6)
4362 ip6_own_query = &port->multicast_ctx.ip6_own_query;
4363#endif
4364 }
4365
4366 if (query == &brmctx->ip4_own_query)
4367 br_multicast_enable(ip4_own_query);
4368#if IS_ENABLED(CONFIG_IPV6)
3764 else
4369 else
3765 br_multicast_enable(&port->ip6_own_query);
4370 br_multicast_enable(ip6_own_query);
3766#endif
3767 }
3768 rcu_read_unlock();
3769}
3770
3771int br_multicast_toggle(struct net_bridge *br, unsigned long val,
3772 struct netlink_ext_ack *extack)
3773{

--- 17 unchanged lines hidden (view full) ---

3791 goto unlock;
3792 }
3793
3794 if (!netif_running(br->dev))
3795 goto unlock;
3796
3797 br_multicast_open(br);
3798 list_for_each_entry(port, &br->port_list, list)
4371#endif
4372 }
4373 rcu_read_unlock();
4374}
4375
4376int br_multicast_toggle(struct net_bridge *br, unsigned long val,
4377 struct netlink_ext_ack *extack)
4378{

--- 17 unchanged lines hidden (view full) ---

4396 goto unlock;
4397 }
4398
4399 if (!netif_running(br->dev))
4400 goto unlock;
4401
4402 br_multicast_open(br);
4403 list_for_each_entry(port, &br->port_list, list)
3799 __br_multicast_enable_port(port);
4404 __br_multicast_enable_port_ctx(&port->multicast_ctx);
3800
3801 change_snoopers = true;
3802
3803unlock:
3804 spin_unlock_bh(&br->multicast_lock);
3805
3806 /* br_multicast_join_snoopers has the potential to cause
3807 * an MLD Report/Leave to be delivered to br_multicast_rcv,

--- 26 unchanged lines hidden (view full) ---

3834EXPORT_SYMBOL_GPL(br_multicast_enabled);
3835
3836bool br_multicast_router(const struct net_device *dev)
3837{
3838 struct net_bridge *br = netdev_priv(dev);
3839 bool is_router;
3840
3841 spin_lock_bh(&br->multicast_lock);
4405
4406 change_snoopers = true;
4407
4408unlock:
4409 spin_unlock_bh(&br->multicast_lock);
4410
4411 /* br_multicast_join_snoopers has the potential to cause
4412 * an MLD Report/Leave to be delivered to br_multicast_rcv,

--- 26 unchanged lines hidden (view full) ---

4439EXPORT_SYMBOL_GPL(br_multicast_enabled);
4440
4441bool br_multicast_router(const struct net_device *dev)
4442{
4443 struct net_bridge *br = netdev_priv(dev);
4444 bool is_router;
4445
4446 spin_lock_bh(&br->multicast_lock);
3842 is_router = br_multicast_is_router(br, NULL);
4447 is_router = br_multicast_is_router(&br->multicast_ctx, NULL);
3843 spin_unlock_bh(&br->multicast_lock);
3844 return is_router;
3845}
3846EXPORT_SYMBOL_GPL(br_multicast_router);
3847
4448 spin_unlock_bh(&br->multicast_lock);
4449 return is_router;
4450}
4451EXPORT_SYMBOL_GPL(br_multicast_router);
4452
3848int br_multicast_set_querier(struct net_bridge *br, unsigned long val)
4453int br_multicast_set_querier(struct net_bridge_mcast *brmctx, unsigned long val)
3849{
3850 unsigned long max_delay;
3851
3852 val = !!val;
3853
4454{
4455 unsigned long max_delay;
4456
4457 val = !!val;
4458
3854 spin_lock_bh(&br->multicast_lock);
3855 if (br_opt_get(br, BROPT_MULTICAST_QUERIER) == val)
4459 spin_lock_bh(&brmctx->br->multicast_lock);
4460 if (brmctx->multicast_querier == val)
3856 goto unlock;
3857
4461 goto unlock;
4462
3858 br_opt_toggle(br, BROPT_MULTICAST_QUERIER, !!val);
4463 WRITE_ONCE(brmctx->multicast_querier, val);
3859 if (!val)
3860 goto unlock;
3861
4464 if (!val)
4465 goto unlock;
4466
3862 max_delay = br->multicast_query_response_interval;
4467 max_delay = brmctx->multicast_query_response_interval;
3863
4468
3864 if (!timer_pending(&br->ip4_other_query.timer))
3865 br->ip4_other_query.delay_time = jiffies + max_delay;
4469 if (!timer_pending(&brmctx->ip4_other_query.timer))
4470 brmctx->ip4_other_query.delay_time = jiffies + max_delay;
3866
4471
3867 br_multicast_start_querier(br, &br->ip4_own_query);
4472 br_multicast_start_querier(brmctx, &brmctx->ip4_own_query);
3868
3869#if IS_ENABLED(CONFIG_IPV6)
4473
4474#if IS_ENABLED(CONFIG_IPV6)
3870 if (!timer_pending(&br->ip6_other_query.timer))
3871 br->ip6_other_query.delay_time = jiffies + max_delay;
4475 if (!timer_pending(&brmctx->ip6_other_query.timer))
4476 brmctx->ip6_other_query.delay_time = jiffies + max_delay;
3872
4477
3873 br_multicast_start_querier(br, &br->ip6_own_query);
4478 br_multicast_start_querier(brmctx, &brmctx->ip6_own_query);
3874#endif
3875
3876unlock:
4479#endif
4480
4481unlock:
3877 spin_unlock_bh(&br->multicast_lock);
4482 spin_unlock_bh(&brmctx->br->multicast_lock);
3878
3879 return 0;
3880}
3881
4483
4484 return 0;
4485}
4486
3882int br_multicast_set_igmp_version(struct net_bridge *br, unsigned long val)
4487int br_multicast_set_igmp_version(struct net_bridge_mcast *brmctx,
4488 unsigned long val)
3883{
3884 /* Currently we support only version 2 and 3 */
3885 switch (val) {
3886 case 2:
3887 case 3:
3888 break;
3889 default:
3890 return -EINVAL;
3891 }
3892
4489{
4490 /* Currently we support only version 2 and 3 */
4491 switch (val) {
4492 case 2:
4493 case 3:
4494 break;
4495 default:
4496 return -EINVAL;
4497 }
4498
3893 spin_lock_bh(&br->multicast_lock);
3894 br->multicast_igmp_version = val;
3895 spin_unlock_bh(&br->multicast_lock);
4499 spin_lock_bh(&brmctx->br->multicast_lock);
4500 brmctx->multicast_igmp_version = val;
4501 spin_unlock_bh(&brmctx->br->multicast_lock);
3896
3897 return 0;
3898}
3899
3900#if IS_ENABLED(CONFIG_IPV6)
4502
4503 return 0;
4504}
4505
4506#if IS_ENABLED(CONFIG_IPV6)
3901int br_multicast_set_mld_version(struct net_bridge *br, unsigned long val)
4507int br_multicast_set_mld_version(struct net_bridge_mcast *brmctx,
4508 unsigned long val)
3902{
3903 /* Currently we support version 1 and 2 */
3904 switch (val) {
3905 case 1:
3906 case 2:
3907 break;
3908 default:
3909 return -EINVAL;
3910 }
3911
4509{
4510 /* Currently we support version 1 and 2 */
4511 switch (val) {
4512 case 1:
4513 case 2:
4514 break;
4515 default:
4516 return -EINVAL;
4517 }
4518
3912 spin_lock_bh(&br->multicast_lock);
3913 br->multicast_mld_version = val;
3914 spin_unlock_bh(&br->multicast_lock);
4519 spin_lock_bh(&brmctx->br->multicast_lock);
4520 brmctx->multicast_mld_version = val;
4521 spin_unlock_bh(&brmctx->br->multicast_lock);
3915
3916 return 0;
3917}
3918#endif
3919
3920/**
3921 * br_multicast_list_adjacent - Returns snooped multicast addresses
3922 * @dev: The bridge port adjacent to which to retrieve addresses

--- 75 unchanged lines hidden (view full) ---

3998 if (!port || !port->br)
3999 goto unlock;
4000
4001 br = port->br;
4002
4003 memset(&eth, 0, sizeof(eth));
4004 eth.h_proto = htons(proto);
4005
4522
4523 return 0;
4524}
4525#endif
4526
4527/**
4528 * br_multicast_list_adjacent - Returns snooped multicast addresses
4529 * @dev: The bridge port adjacent to which to retrieve addresses

--- 75 unchanged lines hidden (view full) ---

4605 if (!port || !port->br)
4606 goto unlock;
4607
4608 br = port->br;
4609
4610 memset(&eth, 0, sizeof(eth));
4611 eth.h_proto = htons(proto);
4612
4006 ret = br_multicast_querier_exists(br, &eth, NULL);
4613 ret = br_multicast_querier_exists(&br->multicast_ctx, &eth, NULL);
4007
4008unlock:
4009 rcu_read_unlock();
4010 return ret;
4011}
4012EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere);
4013
4014/**
4015 * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
4016 * @dev: The bridge port adjacent to which to check for a querier
4017 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
4018 *
4019 * Checks whether the given interface has a bridge on top and if so returns
4020 * true if a selected querier is behind one of the other ports of this
4021 * bridge. Otherwise returns false.
4022 */
4023bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto)
4024{
4614
4615unlock:
4616 rcu_read_unlock();
4617 return ret;
4618}
4619EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere);
4620
4621/**
4622 * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
4623 * @dev: The bridge port adjacent to which to check for a querier
4624 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
4625 *
4626 * Checks whether the given interface has a bridge on top and if so returns
4627 * true if a selected querier is behind one of the other ports of this
4628 * bridge. Otherwise returns false.
4629 */
4630bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto)
4631{
4632 struct net_bridge_mcast *brmctx;
4025 struct net_bridge *br;
4026 struct net_bridge_port *port;
4027 bool ret = false;
4633 struct net_bridge *br;
4634 struct net_bridge_port *port;
4635 bool ret = false;
4636 int port_ifidx;
4028
4029 rcu_read_lock();
4030 if (!netif_is_bridge_port(dev))
4031 goto unlock;
4032
4033 port = br_port_get_rcu(dev);
4034 if (!port || !port->br)
4035 goto unlock;
4036
4037 br = port->br;
4637
4638 rcu_read_lock();
4639 if (!netif_is_bridge_port(dev))
4640 goto unlock;
4641
4642 port = br_port_get_rcu(dev);
4643 if (!port || !port->br)
4644 goto unlock;
4645
4646 br = port->br;
4647 brmctx = &br->multicast_ctx;
4038
4039 switch (proto) {
4040 case ETH_P_IP:
4648
4649 switch (proto) {
4650 case ETH_P_IP:
4041 if (!timer_pending(&br->ip4_other_query.timer) ||
4042 rcu_dereference(br->ip4_querier.port) == port)
4651 port_ifidx = brmctx->ip4_querier.port_ifidx;
4652 if (!timer_pending(&brmctx->ip4_other_query.timer) ||
4653 port_ifidx == port->dev->ifindex)
4043 goto unlock;
4044 break;
4045#if IS_ENABLED(CONFIG_IPV6)
4046 case ETH_P_IPV6:
4654 goto unlock;
4655 break;
4656#if IS_ENABLED(CONFIG_IPV6)
4657 case ETH_P_IPV6:
4047 if (!timer_pending(&br->ip6_other_query.timer) ||
4048 rcu_dereference(br->ip6_querier.port) == port)
4658 port_ifidx = brmctx->ip6_querier.port_ifidx;
4659 if (!timer_pending(&brmctx->ip6_other_query.timer) ||
4660 port_ifidx == port->dev->ifindex)
4049 goto unlock;
4050 break;
4051#endif
4052 default:
4053 goto unlock;
4054 }
4055
4056 ret = true;

--- 9 unchanged lines hidden (view full) ---

4066 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
4067 *
4068 * Checks whether the given interface has a bridge on top and if so returns
4069 * true if a multicast router is behind one of the other ports of this
4070 * bridge. Otherwise returns false.
4071 */
4072bool br_multicast_has_router_adjacent(struct net_device *dev, int proto)
4073{
4661 goto unlock;
4662 break;
4663#endif
4664 default:
4665 goto unlock;
4666 }
4667
4668 ret = true;

--- 9 unchanged lines hidden (view full) ---

4678 * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
4679 *
4680 * Checks whether the given interface has a bridge on top and if so returns
4681 * true if a multicast router is behind one of the other ports of this
4682 * bridge. Otherwise returns false.
4683 */
4684bool br_multicast_has_router_adjacent(struct net_device *dev, int proto)
4685{
4074 struct net_bridge_port *port, *p;
4686 struct net_bridge_mcast_port *pmctx;
4687 struct net_bridge_mcast *brmctx;
4688 struct net_bridge_port *port;
4075 bool ret = false;
4076
4077 rcu_read_lock();
4078 port = br_port_get_check_rcu(dev);
4079 if (!port)
4080 goto unlock;
4081
4689 bool ret = false;
4690
4691 rcu_read_lock();
4692 port = br_port_get_check_rcu(dev);
4693 if (!port)
4694 goto unlock;
4695
4696 brmctx = &port->br->multicast_ctx;
4082 switch (proto) {
4083 case ETH_P_IP:
4697 switch (proto) {
4698 case ETH_P_IP:
4084 hlist_for_each_entry_rcu(p, &port->br->ip4_mc_router_list,
4699 hlist_for_each_entry_rcu(pmctx, &brmctx->ip4_mc_router_list,
4085 ip4_rlist) {
4700 ip4_rlist) {
4086 if (p == port)
4701 if (pmctx->port == port)
4087 continue;
4088
4089 ret = true;
4090 goto unlock;
4091 }
4092 break;
4093#if IS_ENABLED(CONFIG_IPV6)
4094 case ETH_P_IPV6:
4702 continue;
4703
4704 ret = true;
4705 goto unlock;
4706 }
4707 break;
4708#if IS_ENABLED(CONFIG_IPV6)
4709 case ETH_P_IPV6:
4095 hlist_for_each_entry_rcu(p, &port->br->ip6_mc_router_list,
4710 hlist_for_each_entry_rcu(pmctx, &brmctx->ip6_mc_router_list,
4096 ip6_rlist) {
4711 ip6_rlist) {
4097 if (p == port)
4712 if (pmctx->port == port)
4098 continue;
4099
4100 ret = true;
4101 goto unlock;
4102 }
4103 break;
4104#endif
4105 default:

--- 75 unchanged lines hidden (view full) ---

4181 break;
4182 }
4183 break;
4184#endif /* CONFIG_IPV6 */
4185 }
4186 u64_stats_update_end(&pstats->syncp);
4187}
4188
4713 continue;
4714
4715 ret = true;
4716 goto unlock;
4717 }
4718 break;
4719#endif
4720 default:

--- 75 unchanged lines hidden (view full) ---

4796 break;
4797 }
4798 break;
4799#endif /* CONFIG_IPV6 */
4800 }
4801 u64_stats_update_end(&pstats->syncp);
4802}
4803
4189void br_multicast_count(struct net_bridge *br, const struct net_bridge_port *p,
4804void br_multicast_count(struct net_bridge *br,
4805 const struct net_bridge_port *p,
4190 const struct sk_buff *skb, u8 type, u8 dir)
4191{
4192 struct bridge_mcast_stats __percpu *stats;
4193
4194 /* if multicast_disabled is true then igmp type can't be set */
4195 if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
4196 return;
4197

--- 99 unchanged lines hidden --- 		4806 const struct sk_buff *skb, u8 type, u8 dir)
4807{
4808 struct bridge_mcast_stats __percpu *stats;
4809
4810 /* if multicast_disabled is true then igmp type can't be set */
4811 if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
4812 return;
4813

--- 99 unchanged lines hidden ---