]> git.ipfire.org Git - thirdparty/kernel/stable.git/blame - net/bridge/br_multicast.c
projects / thirdparty / kernel / stable.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bridge: Add multicast_snooping sysfs toggle
[thirdparty/kernel/stable.git] / net / bridge / br_multicast.c
CommitLineData
eb1d1641
HX		 1/*
2 * Bridge multicast support.
3 *
4 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
9 * any later version.
10 *
11 */
12
13#include <linux/err.h>
14#include <linux/if_ether.h>
15#include <linux/igmp.h>
16#include <linux/jhash.h>
17#include <linux/kernel.h>
18#include <linux/netdevice.h>
19#include <linux/netfilter_bridge.h>
20#include <linux/random.h>
21#include <linux/rculist.h>
22#include <linux/skbuff.h>
23#include <linux/slab.h>
24#include <linux/timer.h>
25#include <net/ip.h>
26
27#include "br_private.h"
28
29static inline int br_ip_hash(struct net_bridge_mdb_htable *mdb, __be32 ip)
30{
31 return jhash_1word(mdb->secret, (u32)ip) & (mdb->max - 1);
32}
33
34static struct net_bridge_mdb_entry *__br_mdb_ip_get(
35 struct net_bridge_mdb_htable *mdb, __be32 dst, int hash)
36{
37 struct net_bridge_mdb_entry *mp;
38 struct hlist_node *p;
39
40 hlist_for_each_entry(mp, p, &mdb->mhash[hash], hlist[mdb->ver]) {
41 if (dst == mp->addr)
42 return mp;
43 }
44
45 return NULL;
46}
47
48static struct net_bridge_mdb_entry *br_mdb_ip_get(
49 struct net_bridge_mdb_htable *mdb, __be32 dst)
50{
51 return __br_mdb_ip_get(mdb, dst, br_ip_hash(mdb, dst));
52}
53
54struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
55 struct sk_buff *skb)
56{
57 struct net_bridge_mdb_htable *mdb = br->mdb;
58
59 if (!mdb || br->multicast_disabled)
60 return NULL;
61
62 switch (skb->protocol) {
63 case htons(ETH_P_IP):
64 if (BR_INPUT_SKB_CB(skb)->igmp)
65 break;
66 return br_mdb_ip_get(mdb, ip_hdr(skb)->daddr);
67 }
68
69 return NULL;
70}
71
72static void br_mdb_free(struct rcu_head *head)
73{
74 struct net_bridge_mdb_htable *mdb =
75 container_of(head, struct net_bridge_mdb_htable, rcu);
76 struct net_bridge_mdb_htable *old = mdb->old;
77
78 mdb->old = NULL;
79 kfree(old->mhash);
80 kfree(old);
81}
82
83static int br_mdb_copy(struct net_bridge_mdb_htable *new,
84 struct net_bridge_mdb_htable *old,
85 int elasticity)
86{
87 struct net_bridge_mdb_entry *mp;
88 struct hlist_node *p;
89 int maxlen;
90 int len;
91 int i;
92
93 for (i = 0; i < old->max; i++)
94 hlist_for_each_entry(mp, p, &old->mhash[i], hlist[old->ver])
95 hlist_add_head(&mp->hlist[new->ver],
96 &new->mhash[br_ip_hash(new, mp->addr)]);
97
98 if (!elasticity)
99 return 0;
100
101 maxlen = 0;
102 for (i = 0; i < new->max; i++) {
103 len = 0;
104 hlist_for_each_entry(mp, p, &new->mhash[i], hlist[new->ver])
105 len++;
106 if (len > maxlen)
107 maxlen = len;
108 }
109
110 return maxlen > elasticity ? -EINVAL : 0;
111}
112
113static void br_multicast_free_pg(struct rcu_head *head)
114{
115 struct net_bridge_port_group *p =
116 container_of(head, struct net_bridge_port_group, rcu);
117
118 kfree(p);
119}
120
121static void br_multicast_free_group(struct rcu_head *head)
122{
123 struct net_bridge_mdb_entry *mp =
124 container_of(head, struct net_bridge_mdb_entry, rcu);
125
126 kfree(mp);
127}
128
129static void br_multicast_group_expired(unsigned long data)
130{
131 struct net_bridge_mdb_entry *mp = (void *)data;
132 struct net_bridge *br = mp->br;
133 struct net_bridge_mdb_htable *mdb;
134
135 spin_lock(&br->multicast_lock);
136 if (!netif_running(br->dev) || timer_pending(&mp->timer))
137 goto out;
138
139 if (!hlist_unhashed(&mp->mglist))
140 hlist_del_init(&mp->mglist);
141
142 if (mp->ports)
143 goto out;
144
145 mdb = br->mdb;
146 hlist_del_rcu(&mp->hlist[mdb->ver]);
147 mdb->size--;
148
149 del_timer(&mp->query_timer);
150 call_rcu_bh(&mp->rcu, br_multicast_free_group);
151
152out:
153 spin_unlock(&br->multicast_lock);
154}
155
156static void br_multicast_del_pg(struct net_bridge *br,
157 struct net_bridge_port_group *pg)
158{
159 struct net_bridge_mdb_htable *mdb = br->mdb;
160 struct net_bridge_mdb_entry *mp;
161 struct net_bridge_port_group *p;
162 struct net_bridge_port_group **pp;
163
164 mp = br_mdb_ip_get(mdb, pg->addr);
165 if (WARN_ON(!mp))
166 return;
167
168 for (pp = &mp->ports; (p = *pp); pp = &p->next) {
169 if (p != pg)
170 continue;
171
172 *pp = p->next;
173 hlist_del_init(&p->mglist);
174 del_timer(&p->timer);
175 del_timer(&p->query_timer);
176 call_rcu_bh(&p->rcu, br_multicast_free_pg);
177
178 if (!mp->ports && hlist_unhashed(&mp->mglist) &&
179 netif_running(br->dev))
180 mod_timer(&mp->timer, jiffies);
181
182 return;
183 }
184
185 WARN_ON(1);
186}
187
188static void br_multicast_port_group_expired(unsigned long data)
189{
190 struct net_bridge_port_group *pg = (void *)data;
191 struct net_bridge *br = pg->port->br;
192
193 spin_lock(&br->multicast_lock);
194 if (!netif_running(br->dev) || timer_pending(&pg->timer) ||
195 hlist_unhashed(&pg->mglist))
196 goto out;
197
198 br_multicast_del_pg(br, pg);
199
200out:
201 spin_unlock(&br->multicast_lock);
202}
203
204static int br_mdb_rehash(struct net_bridge_mdb_htable **mdbp, int max,
205 int elasticity)
206{
207 struct net_bridge_mdb_htable *old = *mdbp;
208 struct net_bridge_mdb_htable *mdb;
209 int err;
210
211 mdb = kmalloc(sizeof(*mdb), GFP_ATOMIC);
212 if (!mdb)
213 return -ENOMEM;
214
215 mdb->max = max;
216 mdb->old = old;
217
218 mdb->mhash = kzalloc(max * sizeof(*mdb->mhash), GFP_ATOMIC);
219 if (!mdb->mhash) {
220 kfree(mdb);
221 return -ENOMEM;
222 }
223
224 mdb->size = old ? old->size : 0;
225 mdb->ver = old ? old->ver ^ 1 : 0;
226
227 if (!old || elasticity)
228 get_random_bytes(&mdb->secret, sizeof(mdb->secret));
229 else
230 mdb->secret = old->secret;
231
232 if (!old)
233 goto out;
234
235 err = br_mdb_copy(mdb, old, elasticity);
236 if (err) {
237 kfree(mdb->mhash);
238 kfree(mdb);
239 return err;
240 }
241
242 call_rcu_bh(&mdb->rcu, br_mdb_free);
243
244out:
245 rcu_assign_pointer(*mdbp, mdb);
246
247 return 0;
248}
249
250static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
251 __be32 group)
252{
253 struct sk_buff *skb;
254 struct igmphdr *ih;
255 struct ethhdr *eth;
256 struct iphdr *iph;
257
258 skb = netdev_alloc_skb_ip_align(br->dev, sizeof(*eth) + sizeof(*iph) +
259 sizeof(*ih) + 4);
260 if (!skb)
261 goto out;
262
263 skb->protocol = htons(ETH_P_IP);
264
265 skb_reset_mac_header(skb);
266 eth = eth_hdr(skb);
267
268 memcpy(eth->h_source, br->dev->dev_addr, 6);
269 eth->h_dest[0] = 1;
270 eth->h_dest[1] = 0;
271 eth->h_dest[2] = 0x5e;
272 eth->h_dest[3] = 0;
273 eth->h_dest[4] = 0;
274 eth->h_dest[5] = 1;
275 eth->h_proto = htons(ETH_P_IP);
276 skb_put(skb, sizeof(*eth));
277
278 skb_set_network_header(skb, skb->len);
279 iph = ip_hdr(skb);
280
281 iph->version = 4;
282 iph->ihl = 6;
283 iph->tos = 0xc0;
284 iph->tot_len = htons(sizeof(*iph) + sizeof(*ih) + 4);
285 iph->id = 0;
286 iph->frag_off = htons(IP_DF);
287 iph->ttl = 1;
288 iph->protocol = IPPROTO_IGMP;
289 iph->saddr = 0;
290 iph->daddr = htonl(INADDR_ALLHOSTS_GROUP);
291 ((u8 *)&iph[1])[0] = IPOPT_RA;
292 ((u8 *)&iph[1])[1] = 4;
293 ((u8 *)&iph[1])[2] = 0;
294 ((u8 *)&iph[1])[3] = 0;
295 ip_send_check(iph);
296 skb_put(skb, 24);
297
298 skb_set_transport_header(skb, skb->len);
299 ih = igmp_hdr(skb);
300 ih->type = IGMP_HOST_MEMBERSHIP_QUERY;
301 ih->code = (group ? br->multicast_last_member_interval :
302 br->multicast_query_response_interval) /
303 (HZ / IGMP_TIMER_SCALE);
304 ih->group = group;
305 ih->csum = 0;
306 ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr));
307 skb_put(skb, sizeof(*ih));
308
309 __skb_pull(skb, sizeof(*eth));
310
311out:
312 return skb;
313}
314
315static void br_multicast_send_group_query(struct net_bridge_mdb_entry *mp)
316{
317 struct net_bridge *br = mp->br;
318 struct sk_buff *skb;
319
320 skb = br_multicast_alloc_query(br, mp->addr);
321 if (!skb)
322 goto timer;
323
324 netif_rx(skb);
325
326timer:
327 if (++mp->queries_sent < br->multicast_last_member_count)
328 mod_timer(&mp->query_timer,
329 jiffies + br->multicast_last_member_interval);
330}
331
332static void br_multicast_group_query_expired(unsigned long data)
333{
334 struct net_bridge_mdb_entry *mp = (void *)data;
335 struct net_bridge *br = mp->br;
336
337 spin_lock(&br->multicast_lock);
338 if (!netif_running(br->dev) || hlist_unhashed(&mp->mglist) ||
339 mp->queries_sent >= br->multicast_last_member_count)
340 goto out;
341
342 br_multicast_send_group_query(mp);
343
344out:
345 spin_unlock(&br->multicast_lock);
346}
347
348static void br_multicast_send_port_group_query(struct net_bridge_port_group *pg)
349{
350 struct net_bridge_port *port = pg->port;
351 struct net_bridge *br = port->br;
352 struct sk_buff *skb;
353
354 skb = br_multicast_alloc_query(br, pg->addr);
355 if (!skb)
356 goto timer;
357
358 br_deliver(port, skb);
359
360timer:
361 if (++pg->queries_sent < br->multicast_last_member_count)
362 mod_timer(&pg->query_timer,
363 jiffies + br->multicast_last_member_interval);
364}
365
366static void br_multicast_port_group_query_expired(unsigned long data)
367{
368 struct net_bridge_port_group *pg = (void *)data;
369 struct net_bridge_port *port = pg->port;
370 struct net_bridge *br = port->br;
371
372 spin_lock(&br->multicast_lock);
373 if (!netif_running(br->dev) || hlist_unhashed(&pg->mglist) ||
374 pg->queries_sent >= br->multicast_last_member_count)
375 goto out;
376
377 br_multicast_send_port_group_query(pg);
378
379out:
380 spin_unlock(&br->multicast_lock);
381}
382
383static struct net_bridge_mdb_entry *br_multicast_get_group(
384 struct net_bridge *br, struct net_bridge_port *port, __be32 group,
385 int hash)
386{
387 struct net_bridge_mdb_htable *mdb = br->mdb;
388 struct net_bridge_mdb_entry *mp;
389 struct hlist_node *p;
390 unsigned count = 0;
391 unsigned max;
392 int elasticity;
393 int err;
394
395 hlist_for_each_entry(mp, p, &mdb->mhash[hash], hlist[mdb->ver]) {
396 count++;
397 if (unlikely(group == mp->addr)) {
398 return mp;
399 }
400 }
401
402 elasticity = 0;
403 max = mdb->max;
404
405 if (unlikely(count > br->hash_elasticity && count)) {
406 if (net_ratelimit())
407 printk(KERN_INFO "%s: Multicast hash table "
408 "chain limit reached: %s\n",
409 br->dev->name, port ? port->dev->name :
410 br->dev->name);
411
412 elasticity = br->hash_elasticity;
413 }
414
415 if (mdb->size >= max) {
416 max *= 2;
417 if (unlikely(max >= br->hash_max)) {
418 printk(KERN_WARNING "%s: Multicast hash table maximum "
419 "reached, disabling snooping: %s, %d\n",
420 br->dev->name, port ? port->dev->name :
421 br->dev->name,
422 max);
423 err = -E2BIG;
424disable:
425 br->multicast_disabled = 1;
426 goto err;
427 }
428 }
429
430 if (max > mdb->max || elasticity) {
431 if (mdb->old) {
432 if (net_ratelimit())
433 printk(KERN_INFO "%s: Multicast hash table "
434 "on fire: %s\n",
435 br->dev->name, port ? port->dev->name :
436 br->dev->name);
437 err = -EEXIST;
438 goto err;
439 }
440
441 err = br_mdb_rehash(&br->mdb, max, elasticity);
442 if (err) {
443 printk(KERN_WARNING "%s: Cannot rehash multicast "
444 "hash table, disabling snooping: "
445 "%s, %d, %d\n",
446 br->dev->name, port ? port->dev->name :
447 br->dev->name,
448 mdb->size, err);
449 goto disable;
450 }
451
452 err = -EAGAIN;
453 goto err;
454 }
455
456 return NULL;
457
458err:
459 mp = ERR_PTR(err);
460 return mp;
461}
462
463static struct net_bridge_mdb_entry *br_multicast_new_group(
464 struct net_bridge *br, struct net_bridge_port *port, __be32 group)
465{
466 struct net_bridge_mdb_htable *mdb = br->mdb;
467 struct net_bridge_mdb_entry *mp;
468 int hash;
469
470 if (!mdb) {
471 if (br_mdb_rehash(&br->mdb, BR_HASH_SIZE, 0))
472 return NULL;
473 goto rehash;
474 }
475
476 hash = br_ip_hash(mdb, group);
477 mp = br_multicast_get_group(br, port, group, hash);
478 switch (PTR_ERR(mp)) {
479 case 0:
480 break;
481
482 case -EAGAIN:
483rehash:
484 mdb = br->mdb;
485 hash = br_ip_hash(mdb, group);
486 break;
487
488 default:
489 goto out;
490 }
491
492 mp = kzalloc(sizeof(*mp), GFP_ATOMIC);
493 if (unlikely(!mp))
494 goto out;
495
496 mp->br = br;
497 mp->addr = group;
498 setup_timer(&mp->timer, br_multicast_group_expired,
499 (unsigned long)mp);
500 setup_timer(&mp->query_timer, br_multicast_group_query_expired,
501 (unsigned long)mp);
502
503 hlist_add_head_rcu(&mp->hlist[mdb->ver], &mdb->mhash[hash]);
504 mdb->size++;
505
506out:
507 return mp;
508}
509
510static int br_multicast_add_group(struct net_bridge *br,
511 struct net_bridge_port *port, __be32 group)
512{
513 struct net_bridge_mdb_entry *mp;
514 struct net_bridge_port_group *p;
515 struct net_bridge_port_group **pp;
516 unsigned long now = jiffies;
517 int err;
518
519 if (ipv4_is_local_multicast(group))
520 return 0;
521
522 spin_lock(&br->multicast_lock);
523 if (!netif_running(br->dev) ||
524 (port && port->state == BR_STATE_DISABLED))
525 goto out;
526
527 mp = br_multicast_new_group(br, port, group);
528 err = PTR_ERR(mp);
529 if (unlikely(IS_ERR(mp) || !mp))
530 goto err;
531
532 if (!port) {
533 hlist_add_head(&mp->mglist, &br->mglist);
534 mod_timer(&mp->timer, now + br->multicast_membership_interval);
535 goto out;
536 }
537
538 for (pp = &mp->ports; (p = *pp); pp = &p->next) {
539 if (p->port == port)
540 goto found;
541 if ((unsigned long)p->port < (unsigned long)port)
542 break;
543 }
544
545 p = kzalloc(sizeof(*p), GFP_ATOMIC);
546 err = -ENOMEM;
547 if (unlikely(!p))
548 goto err;
549
550 p->addr = group;
551 p->port = port;
552 p->next = *pp;
553 hlist_add_head(&p->mglist, &port->mglist);
554 setup_timer(&p->timer, br_multicast_port_group_expired,
555 (unsigned long)p);
556 setup_timer(&p->query_timer, br_multicast_port_group_query_expired,
557 (unsigned long)p);
558
559 rcu_assign_pointer(*pp, p);
560
561found:
562 mod_timer(&p->timer, now + br->multicast_membership_interval);
563out:
564 err = 0;
565
566err:
567 spin_unlock(&br->multicast_lock);
568 return err;
569}
570
571static void br_multicast_router_expired(unsigned long data)
572{
573 struct net_bridge_port *port = (void *)data;
574 struct net_bridge *br = port->br;
575
576 spin_lock(&br->multicast_lock);
577 if (port->multicast_router != 1 ||
578 timer_pending(&port->multicast_router_timer) ||
579 hlist_unhashed(&port->rlist))
580 goto out;
581
582 hlist_del_init_rcu(&port->rlist);
583
584out:
585 spin_unlock(&br->multicast_lock);
586}
587
588static void br_multicast_local_router_expired(unsigned long data)
589{
590}
591
592static void br_multicast_send_query(struct net_bridge *br,
593 struct net_bridge_port *port, u32 sent)
594{
595 unsigned long time;
596 struct sk_buff *skb;
597
598 if (!netif_running(br->dev) || br->multicast_disabled ||
599 timer_pending(&br->multicast_querier_timer))
600 return;
601
602 skb = br_multicast_alloc_query(br, 0);
603 if (!skb)
604 goto timer;
605
606 if (port) {
607 __skb_push(skb, sizeof(struct ethhdr));
608 skb->dev = port->dev;
609 NF_HOOK(PF_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
610 dev_queue_xmit);
611 } else
612 netif_rx(skb);
613
614timer:
615 time = jiffies;
616 time += sent < br->multicast_startup_query_count ?
617 br->multicast_startup_query_interval :
618 br->multicast_query_interval;
619 mod_timer(port ? &port->multicast_query_timer :
620 &br->multicast_query_timer, time);
621}
622
623static void br_multicast_port_query_expired(unsigned long data)
624{
625 struct net_bridge_port *port = (void *)data;
626 struct net_bridge *br = port->br;
627
628 spin_lock(&br->multicast_lock);
629 if (port && (port->state == BR_STATE_DISABLED ||
630 port->state == BR_STATE_BLOCKING))
631 goto out;
632
633 if (port->multicast_startup_queries_sent <
634 br->multicast_startup_query_count)
635 port->multicast_startup_queries_sent++;
636
637 br_multicast_send_query(port->br, port,
638 port->multicast_startup_queries_sent);
639
640out:
641 spin_unlock(&br->multicast_lock);
642}
643
644void br_multicast_add_port(struct net_bridge_port *port)
645{
646 port->multicast_router = 1;
647
648 setup_timer(&port->multicast_router_timer, br_multicast_router_expired,
649 (unsigned long)port);
650 setup_timer(&port->multicast_query_timer,
651 br_multicast_port_query_expired, (unsigned long)port);
652}
653
654void br_multicast_del_port(struct net_bridge_port *port)
655{
656 del_timer_sync(&port->multicast_router_timer);
657}
658
561f1103
HX		 659static void __br_multicast_enable_port(struct net_bridge_port *port)
660{
661 port->multicast_startup_queries_sent = 0;
662
663 if (try_to_del_timer_sync(&port->multicast_query_timer) >= 0 ||
664 del_timer(&port->multicast_query_timer))
665 mod_timer(&port->multicast_query_timer, jiffies);
666}
667
eb1d1641
HX		 668void br_multicast_enable_port(struct net_bridge_port *port)
669{
670 struct net_bridge *br = port->br;
671
672 spin_lock(&br->multicast_lock);
673 if (br->multicast_disabled || !netif_running(br->dev))
674 goto out;
675
561f1103 676 __br_multicast_enable_port(port);
eb1d1641
HX		 677
678out:
679 spin_unlock(&br->multicast_lock);
680}
681
682void br_multicast_disable_port(struct net_bridge_port *port)
683{
684 struct net_bridge *br = port->br;
685 struct net_bridge_port_group *pg;
686 struct hlist_node *p, *n;
687
688 spin_lock(&br->multicast_lock);
689 hlist_for_each_entry_safe(pg, p, n, &port->mglist, mglist)
690 br_multicast_del_pg(br, pg);
691
692 if (!hlist_unhashed(&port->rlist))
693 hlist_del_init_rcu(&port->rlist);
694 del_timer(&port->multicast_router_timer);
695 del_timer(&port->multicast_query_timer);
696 spin_unlock(&br->multicast_lock);
697}
698
699static int br_multicast_igmp3_report(struct net_bridge *br,
700 struct net_bridge_port *port,
701 struct sk_buff *skb)
702{
703 struct igmpv3_report *ih;
704 struct igmpv3_grec *grec;
705 int i;
706 int len;
707 int num;
708 int type;
709 int err = 0;
710 __be32 group;
711
712 if (!pskb_may_pull(skb, sizeof(*ih)))
713 return -EINVAL;
714
715 ih = igmpv3_report_hdr(skb);
716 num = ntohs(ih->ngrec);
717 len = sizeof(*ih);
718
719 for (i = 0; i < num; i++) {
720 len += sizeof(*grec);
721 if (!pskb_may_pull(skb, len))
722 return -EINVAL;
723
724 grec = (void *)(skb->data + len);
725 group = grec->grec_mca;
726 type = grec->grec_type;
727
728 len += grec->grec_nsrcs * 4;
729 if (!pskb_may_pull(skb, len))
730 return -EINVAL;
731
732 /* We treat this as an IGMPv2 report for now. */
733 switch (type) {
734 case IGMPV3_MODE_IS_INCLUDE:
735 case IGMPV3_MODE_IS_EXCLUDE:
736 case IGMPV3_CHANGE_TO_INCLUDE:
737 case IGMPV3_CHANGE_TO_EXCLUDE:
738 case IGMPV3_ALLOW_NEW_SOURCES:
739 case IGMPV3_BLOCK_OLD_SOURCES:
740 break;
741
742 default:
743 continue;
744 }
745
746 err = br_multicast_add_group(br, port, group);
747 if (err)
748 break;
749 }
750
751 return err;
752}
753
0909e117
HX		 754static void br_multicast_add_router(struct net_bridge *br,
755 struct net_bridge_port *port)
756{
757 struct hlist_node *p;
758 struct hlist_node **h;
759
760 for (h = &br->router_list.first;
761 (p = *h) &&
762 (unsigned long)container_of(p, struct net_bridge_port, rlist) >
763 (unsigned long)port;
764 h = &p->next)
765 ;
766
767 port->rlist.pprev = h;
768 port->rlist.next = p;
769 rcu_assign_pointer(*h, &port->rlist);
770 if (p)
771 p->pprev = &port->rlist.next;
772}
773
eb1d1641
HX		 774static void br_multicast_mark_router(struct net_bridge *br,
775 struct net_bridge_port *port)
776{
777 unsigned long now = jiffies;
eb1d1641
HX		 778
779 if (!port) {
780 if (br->multicast_router == 1)
781 mod_timer(&br->multicast_router_timer,
782 now + br->multicast_querier_interval);
783 return;
784 }
785
786 if (port->multicast_router != 1)
787 return;
788
789 if (!hlist_unhashed(&port->rlist))
790 goto timer;
791
0909e117 792 br_multicast_add_router(br, port);
eb1d1641
HX		 793
794timer:
795 mod_timer(&port->multicast_router_timer,
796 now + br->multicast_querier_interval);
797}
798
799static void br_multicast_query_received(struct net_bridge *br,
800 struct net_bridge_port *port,
801 __be32 saddr)
802{
803 if (saddr)
804 mod_timer(&br->multicast_querier_timer,
805 jiffies + br->multicast_querier_interval);
806 else if (timer_pending(&br->multicast_querier_timer))
807 return;
808
809 br_multicast_mark_router(br, port);
810}
811
812static int br_multicast_query(struct net_bridge *br,
813 struct net_bridge_port *port,
814 struct sk_buff *skb)
815{
816 struct iphdr *iph = ip_hdr(skb);
817 struct igmphdr *ih = igmp_hdr(skb);
818 struct net_bridge_mdb_entry *mp;
819 struct igmpv3_query *ih3;
820 struct net_bridge_port_group *p;
821 struct net_bridge_port_group **pp;
822 unsigned long max_delay;
823 unsigned long now = jiffies;
824 __be32 group;
825
826 spin_lock(&br->multicast_lock);
827 if (!netif_running(br->dev) ||
828 (port && port->state == BR_STATE_DISABLED))
829 goto out;
830
831 br_multicast_query_received(br, port, iph->saddr);
832
833 group = ih->group;
834
835 if (skb->len == sizeof(*ih)) {
836 max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
837
838 if (!max_delay) {
839 max_delay = 10 * HZ;
840 group = 0;
841 }
842 } else {
843 if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)))
844 return -EINVAL;
845
846 ih3 = igmpv3_query_hdr(skb);
847 if (ih3->nsrcs)
848 return 0;
849
850 max_delay = ih3->code ? 1 :
851 IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE);
852 }
853
854 if (!group)
855 goto out;
856
857 mp = br_mdb_ip_get(br->mdb, group);
858 if (!mp)
859 goto out;
860
861 max_delay *= br->multicast_last_member_count;
862
863 if (!hlist_unhashed(&mp->mglist) &&
864 (timer_pending(&mp->timer) ?
865 time_after(mp->timer.expires, now + max_delay) :
866 try_to_del_timer_sync(&mp->timer) >= 0))
867 mod_timer(&mp->timer, now + max_delay);
868
869 for (pp = &mp->ports; (p = *pp); pp = &p->next) {
870 if (timer_pending(&p->timer) ?
871 time_after(p->timer.expires, now + max_delay) :
872 try_to_del_timer_sync(&p->timer) >= 0)
873 mod_timer(&mp->timer, now + max_delay);
874 }
875
876out:
877 spin_unlock(&br->multicast_lock);
878 return 0;
879}
880
881static void br_multicast_leave_group(struct net_bridge *br,
882 struct net_bridge_port *port,
883 __be32 group)
884{
885 struct net_bridge_mdb_htable *mdb;
886 struct net_bridge_mdb_entry *mp;
887 struct net_bridge_port_group *p;
888 unsigned long now;
889 unsigned long time;
890
891 if (ipv4_is_local_multicast(group))
892 return;
893
894 spin_lock(&br->multicast_lock);
895 if (!netif_running(br->dev) ||
896 (port && port->state == BR_STATE_DISABLED) ||
897 timer_pending(&br->multicast_querier_timer))
898 goto out;
899
900 mdb = br->mdb;
901 mp = br_mdb_ip_get(mdb, group);
902 if (!mp)
903 goto out;
904
905 now = jiffies;
906 time = now + br->multicast_last_member_count *
907 br->multicast_last_member_interval;
908
909 if (!port) {
910 if (!hlist_unhashed(&mp->mglist) &&
911 (timer_pending(&mp->timer) ?
912 time_after(mp->timer.expires, time) :
913 try_to_del_timer_sync(&mp->timer) >= 0)) {
914 mod_timer(&mp->timer, time);
915
916 mp->queries_sent = 0;
917 mod_timer(&mp->query_timer, now);
918 }
919
920 goto out;
921 }
922
923 for (p = mp->ports; p; p = p->next) {
924 if (p->port != port)
925 continue;
926
927 if (!hlist_unhashed(&p->mglist) &&
928 (timer_pending(&p->timer) ?
929 time_after(p->timer.expires, time) :
930 try_to_del_timer_sync(&p->timer) >= 0)) {
931 mod_timer(&p->timer, time);
932
933 p->queries_sent = 0;
934 mod_timer(&p->query_timer, now);
935 }
936
937 break;
938 }
939
940out:
941 spin_unlock(&br->multicast_lock);
942}
943
944static int br_multicast_ipv4_rcv(struct net_bridge *br,
945 struct net_bridge_port *port,
946 struct sk_buff *skb)
947{
948 struct sk_buff *skb2 = skb;
949 struct iphdr *iph;
950 struct igmphdr *ih;
951 unsigned len;
952 unsigned offset;
953 int err;
954
955 BR_INPUT_SKB_CB(skb)->igmp = 0;
956 BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
957
958 /* We treat OOM as packet loss for now. */
959 if (!pskb_may_pull(skb, sizeof(*iph)))
960 return -EINVAL;
961
962 iph = ip_hdr(skb);
963
964 if (iph->ihl < 5 || iph->version != 4)
965 return -EINVAL;
966
967 if (!pskb_may_pull(skb, ip_hdrlen(skb)))
968 return -EINVAL;
969
970 iph = ip_hdr(skb);
971
972 if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
973 return -EINVAL;
974
975 if (iph->protocol != IPPROTO_IGMP)
976 return 0;
977
978 len = ntohs(iph->tot_len);
979 if (skb->len < len || len < ip_hdrlen(skb))
980 return -EINVAL;
981
982 if (skb->len > len) {
983 skb2 = skb_clone(skb, GFP_ATOMIC);
984 if (!skb2)
985 return -ENOMEM;
986
987 err = pskb_trim_rcsum(skb2, len);
988 if (err)
989 return err;
990 }
991
992 len -= ip_hdrlen(skb2);
993 offset = skb_network_offset(skb2) + ip_hdrlen(skb2);
994 __skb_pull(skb2, offset);
995 skb_reset_transport_header(skb2);
996
997 err = -EINVAL;
998 if (!pskb_may_pull(skb2, sizeof(*ih)))
999 goto out;
1000
1001 iph = ip_hdr(skb2);
1002
1003 switch (skb2->ip_summed) {
1004 case CHECKSUM_COMPLETE:
1005 if (!csum_fold(skb2->csum))
1006 break;
1007 /* fall through */
1008 case CHECKSUM_NONE:
1009 skb2->csum = 0;
1010 if (skb_checksum_complete(skb2))
1011 return -EINVAL;
1012 }
1013
1014 err = 0;
1015
1016 BR_INPUT_SKB_CB(skb)->igmp = 1;
1017 ih = igmp_hdr(skb2);
1018
1019 switch (ih->type) {
1020 case IGMP_HOST_MEMBERSHIP_REPORT:
1021 case IGMPV2_HOST_MEMBERSHIP_REPORT:
1022 BR_INPUT_SKB_CB(skb2)->mrouters_only = 1;
1023 err = br_multicast_add_group(br, port, ih->group);
1024 break;
1025 case IGMPV3_HOST_MEMBERSHIP_REPORT:
1026 err = br_multicast_igmp3_report(br, port, skb2);
1027 break;
1028 case IGMP_HOST_MEMBERSHIP_QUERY:
1029 err = br_multicast_query(br, port, skb2);
1030 break;
1031 case IGMP_HOST_LEAVE_MESSAGE:
1032 br_multicast_leave_group(br, port, ih->group);
1033 break;
1034 }
1035
1036out:
1037 __skb_push(skb2, offset);
1038 if (skb2 != skb)
1039 kfree_skb(skb2);
1040 return err;
1041}
1042
1043int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
1044 struct sk_buff *skb)
1045{
1046 if (br->multicast_disabled)
1047 return 0;
1048
1049 switch (skb->protocol) {
1050 case htons(ETH_P_IP):
1051 return br_multicast_ipv4_rcv(br, port, skb);
1052 }
1053
1054 return 0;
1055}
1056
1057static void br_multicast_query_expired(unsigned long data)
1058{
1059 struct net_bridge *br = (void *)data;
1060
1061 spin_lock(&br->multicast_lock);
1062 if (br->multicast_startup_queries_sent <
1063 br->multicast_startup_query_count)
1064 br->multicast_startup_queries_sent++;
1065
1066 br_multicast_send_query(br, NULL, br->multicast_startup_queries_sent);
1067
1068 spin_unlock(&br->multicast_lock);
1069}
1070
1071void br_multicast_init(struct net_bridge *br)
1072{
1073 br->hash_elasticity = 4;
1074 br->hash_max = 512;
1075
1076 br->multicast_router = 1;
1077 br->multicast_last_member_count = 2;
1078 br->multicast_startup_query_count = 2;
1079
1080 br->multicast_last_member_interval = HZ;
1081 br->multicast_query_response_interval = 10 * HZ;
1082 br->multicast_startup_query_interval = 125 * HZ / 4;
1083 br->multicast_query_interval = 125 * HZ;
1084 br->multicast_querier_interval = 255 * HZ;
1085 br->multicast_membership_interval = 260 * HZ;
1086
1087 spin_lock_init(&br->multicast_lock);
1088 setup_timer(&br->multicast_router_timer,
1089 br_multicast_local_router_expired, 0);
1090 setup_timer(&br->multicast_querier_timer,
1091 br_multicast_local_router_expired, 0);
1092 setup_timer(&br->multicast_query_timer, br_multicast_query_expired,
1093 (unsigned long)br);
1094}
1095
1096void br_multicast_open(struct net_bridge *br)
1097{
1098 br->multicast_startup_queries_sent = 0;
1099
1100 if (br->multicast_disabled)
1101 return;
1102
1103 mod_timer(&br->multicast_query_timer, jiffies);
1104}
1105
1106void br_multicast_stop(struct net_bridge *br)
1107{
1108 struct net_bridge_mdb_htable *mdb;
1109 struct net_bridge_mdb_entry *mp;
1110 struct hlist_node *p, *n;
1111 u32 ver;
1112 int i;
1113
1114 del_timer_sync(&br->multicast_router_timer);
1115 del_timer_sync(&br->multicast_querier_timer);
1116 del_timer_sync(&br->multicast_query_timer);
1117
1118 spin_lock_bh(&br->multicast_lock);
1119 mdb = br->mdb;
1120 if (!mdb)
1121 goto out;
1122
1123 br->mdb = NULL;
1124
1125 ver = mdb->ver;
1126 for (i = 0; i < mdb->max; i++) {
1127 hlist_for_each_entry_safe(mp, p, n, &mdb->mhash[i],
1128 hlist[ver]) {
1129 del_timer(&mp->timer);
1130 del_timer(&mp->query_timer);
1131 call_rcu_bh(&mp->rcu, br_multicast_free_group);
1132 }
1133 }
1134
1135 if (mdb->old) {
1136 spin_unlock_bh(&br->multicast_lock);
1137 synchronize_rcu_bh();
1138 spin_lock_bh(&br->multicast_lock);
1139 WARN_ON(mdb->old);
1140 }
1141
1142 mdb->old = mdb;
1143 call_rcu_bh(&mdb->rcu, br_mdb_free);
1144
1145out:
1146 spin_unlock_bh(&br->multicast_lock);
1147}
0909e117
HX		 1148
1149int br_multicast_set_router(struct net_bridge *br, unsigned long val)
1150{
1151 int err = -ENOENT;
1152
1153 spin_lock_bh(&br->multicast_lock);
1154 if (!netif_running(br->dev))
1155 goto unlock;
1156
1157 switch (val) {
1158 case 0:
1159 case 2:
1160 del_timer(&br->multicast_router_timer);
1161 /* fall through */
1162 case 1:
1163 br->multicast_router = val;
1164 err = 0;
1165 break;
1166
1167 default:
1168 err = -EINVAL;
1169 break;
1170 }
1171
1172unlock:
1173 spin_unlock_bh(&br->multicast_lock);
1174
1175 return err;
1176}
1177
1178int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val)
1179{
1180 struct net_bridge *br = p->br;
1181 int err = -ENOENT;
1182
1183 spin_lock(&br->multicast_lock);
1184 if (!netif_running(br->dev) || p->state == BR_STATE_DISABLED)
1185 goto unlock;
1186
1187 switch (val) {
1188 case 0:
1189 case 1:
1190 case 2:
1191 p->multicast_router = val;
1192 err = 0;
1193
1194 if (val < 2 && !hlist_unhashed(&p->rlist))
1195 hlist_del_init_rcu(&p->rlist);
1196
1197 if (val == 1)
1198 break;
1199
1200 del_timer(&p->multicast_router_timer);
1201
1202 if (val == 0)
1203 break;
1204
1205 br_multicast_add_router(br, p);
1206 break;
1207
1208 default:
1209 err = -EINVAL;
1210 break;
1211 }
1212
1213unlock:
1214 spin_unlock(&br->multicast_lock);
1215
1216 return err;
1217}
561f1103
HX		 1218
1219int br_multicast_toggle(struct net_bridge *br, unsigned long val)
1220{
1221 struct net_bridge_port *port;
1222 int err = -ENOENT;
1223
1224 spin_lock(&br->multicast_lock);
1225 if (!netif_running(br->dev))
1226 goto unlock;
1227
1228 err = 0;
1229 if (br->multicast_disabled == !val)
1230 goto unlock;
1231
1232 br->multicast_disabled = !val;
1233 if (br->multicast_disabled)
1234 goto unlock;
1235
1236 if (br->mdb) {
1237 if (br->mdb->old) {
1238 err = -EEXIST;
1239rollback:
1240 br->multicast_disabled = !!val;
1241 goto unlock;
1242 }
1243
1244 err = br_mdb_rehash(&br->mdb, br->mdb->max,
1245 br->hash_elasticity);
1246 if (err)
1247 goto rollback;
1248 }
1249
1250 br_multicast_open(br);
1251 list_for_each_entry(port, &br->port_list, list) {
1252 if (port->state == BR_STATE_DISABLED ||
1253 port->state == BR_STATE_BLOCKING)
1254 continue;
1255
1256 __br_multicast_enable_port(port);
1257 }
1258
1259unlock:
1260 spin_unlock(&br->multicast_lock);
1261
1262 return err;
1263}
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git