2 * Bridge multicast support.
4 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
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)
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/log2.h>
19 #include <linux/netdevice.h>
20 #include <linux/netfilter_bridge.h>
21 #include <linux/random.h>
22 #include <linux/rculist.h>
23 #include <linux/skbuff.h>
24 #include <linux/slab.h>
25 #include <linux/timer.h>
28 #include "br_private.h"
30 static inline int br_ip_equal(const struct br_ip
*a
, const struct br_ip
*b
)
32 if (a
->proto
!= b
->proto
)
36 return a
->u
.ip4
== b
->u
.ip4
;
41 static inline int __br_ip4_hash(struct net_bridge_mdb_htable
*mdb
, __be32 ip
)
43 return jhash_1word(mdb
->secret
, (__force u32
)ip
) & (mdb
->max
- 1);
46 static inline int br_ip_hash(struct net_bridge_mdb_htable
*mdb
,
51 return __br_ip4_hash(mdb
, ip
->u
.ip4
);
56 static struct net_bridge_mdb_entry
*__br_mdb_ip_get(
57 struct net_bridge_mdb_htable
*mdb
, struct br_ip
*dst
, int hash
)
59 struct net_bridge_mdb_entry
*mp
;
62 hlist_for_each_entry_rcu(mp
, p
, &mdb
->mhash
[hash
], hlist
[mdb
->ver
]) {
63 if (br_ip_equal(&mp
->addr
, dst
))
70 static struct net_bridge_mdb_entry
*br_mdb_ip4_get(
71 struct net_bridge_mdb_htable
*mdb
, __be32 dst
)
76 br_dst
.proto
= htons(ETH_P_IP
);
78 return __br_mdb_ip_get(mdb
, &br_dst
, __br_ip4_hash(mdb
, dst
));
81 static struct net_bridge_mdb_entry
*br_mdb_ip_get(
82 struct net_bridge_mdb_htable
*mdb
, struct br_ip
*dst
)
84 return __br_mdb_ip_get(mdb
, dst
, br_ip_hash(mdb
, dst
));
87 struct net_bridge_mdb_entry
*br_mdb_get(struct net_bridge
*br
,
90 struct net_bridge_mdb_htable
*mdb
= br
->mdb
;
93 if (!mdb
|| br
->multicast_disabled
)
96 if (BR_INPUT_SKB_CB(skb
)->igmp
)
99 ip
.proto
= skb
->protocol
;
101 switch (skb
->protocol
) {
102 case htons(ETH_P_IP
):
103 ip
.u
.ip4
= ip_hdr(skb
)->daddr
;
109 return br_mdb_ip_get(mdb
, &ip
);
112 static void br_mdb_free(struct rcu_head
*head
)
114 struct net_bridge_mdb_htable
*mdb
=
115 container_of(head
, struct net_bridge_mdb_htable
, rcu
);
116 struct net_bridge_mdb_htable
*old
= mdb
->old
;
123 static int br_mdb_copy(struct net_bridge_mdb_htable
*new,
124 struct net_bridge_mdb_htable
*old
,
127 struct net_bridge_mdb_entry
*mp
;
128 struct hlist_node
*p
;
133 for (i
= 0; i
< old
->max
; i
++)
134 hlist_for_each_entry(mp
, p
, &old
->mhash
[i
], hlist
[old
->ver
])
135 hlist_add_head(&mp
->hlist
[new->ver
],
136 &new->mhash
[br_ip_hash(new, &mp
->addr
)]);
142 for (i
= 0; i
< new->max
; i
++) {
144 hlist_for_each_entry(mp
, p
, &new->mhash
[i
], hlist
[new->ver
])
150 return maxlen
> elasticity
? -EINVAL
: 0;
153 static void br_multicast_free_pg(struct rcu_head
*head
)
155 struct net_bridge_port_group
*p
=
156 container_of(head
, struct net_bridge_port_group
, rcu
);
161 static void br_multicast_free_group(struct rcu_head
*head
)
163 struct net_bridge_mdb_entry
*mp
=
164 container_of(head
, struct net_bridge_mdb_entry
, rcu
);
169 static void br_multicast_group_expired(unsigned long data
)
171 struct net_bridge_mdb_entry
*mp
= (void *)data
;
172 struct net_bridge
*br
= mp
->br
;
173 struct net_bridge_mdb_htable
*mdb
;
175 spin_lock(&br
->multicast_lock
);
176 if (!netif_running(br
->dev
) || timer_pending(&mp
->timer
))
179 if (!hlist_unhashed(&mp
->mglist
))
180 hlist_del_init(&mp
->mglist
);
186 hlist_del_rcu(&mp
->hlist
[mdb
->ver
]);
189 del_timer(&mp
->query_timer
);
190 call_rcu_bh(&mp
->rcu
, br_multicast_free_group
);
193 spin_unlock(&br
->multicast_lock
);
196 static void br_multicast_del_pg(struct net_bridge
*br
,
197 struct net_bridge_port_group
*pg
)
199 struct net_bridge_mdb_htable
*mdb
= br
->mdb
;
200 struct net_bridge_mdb_entry
*mp
;
201 struct net_bridge_port_group
*p
;
202 struct net_bridge_port_group
**pp
;
204 mp
= br_mdb_ip_get(mdb
, &pg
->addr
);
208 for (pp
= &mp
->ports
; (p
= *pp
); pp
= &p
->next
) {
213 hlist_del_init(&p
->mglist
);
214 del_timer(&p
->timer
);
215 del_timer(&p
->query_timer
);
216 call_rcu_bh(&p
->rcu
, br_multicast_free_pg
);
218 if (!mp
->ports
&& hlist_unhashed(&mp
->mglist
) &&
219 netif_running(br
->dev
))
220 mod_timer(&mp
->timer
, jiffies
);
228 static void br_multicast_port_group_expired(unsigned long data
)
230 struct net_bridge_port_group
*pg
= (void *)data
;
231 struct net_bridge
*br
= pg
->port
->br
;
233 spin_lock(&br
->multicast_lock
);
234 if (!netif_running(br
->dev
) || timer_pending(&pg
->timer
) ||
235 hlist_unhashed(&pg
->mglist
))
238 br_multicast_del_pg(br
, pg
);
241 spin_unlock(&br
->multicast_lock
);
244 static int br_mdb_rehash(struct net_bridge_mdb_htable
**mdbp
, int max
,
247 struct net_bridge_mdb_htable
*old
= *mdbp
;
248 struct net_bridge_mdb_htable
*mdb
;
251 mdb
= kmalloc(sizeof(*mdb
), GFP_ATOMIC
);
258 mdb
->mhash
= kzalloc(max
* sizeof(*mdb
->mhash
), GFP_ATOMIC
);
264 mdb
->size
= old
? old
->size
: 0;
265 mdb
->ver
= old
? old
->ver
^ 1 : 0;
267 if (!old
|| elasticity
)
268 get_random_bytes(&mdb
->secret
, sizeof(mdb
->secret
));
270 mdb
->secret
= old
->secret
;
275 err
= br_mdb_copy(mdb
, old
, elasticity
);
282 call_rcu_bh(&mdb
->rcu
, br_mdb_free
);
285 rcu_assign_pointer(*mdbp
, mdb
);
290 static struct sk_buff
*br_ip4_multicast_alloc_query(struct net_bridge
*br
,
298 skb
= netdev_alloc_skb_ip_align(br
->dev
, sizeof(*eth
) + sizeof(*iph
) +
303 skb
->protocol
= htons(ETH_P_IP
);
305 skb_reset_mac_header(skb
);
308 memcpy(eth
->h_source
, br
->dev
->dev_addr
, 6);
311 eth
->h_dest
[2] = 0x5e;
315 eth
->h_proto
= htons(ETH_P_IP
);
316 skb_put(skb
, sizeof(*eth
));
318 skb_set_network_header(skb
, skb
->len
);
324 iph
->tot_len
= htons(sizeof(*iph
) + sizeof(*ih
) + 4);
326 iph
->frag_off
= htons(IP_DF
);
328 iph
->protocol
= IPPROTO_IGMP
;
330 iph
->daddr
= htonl(INADDR_ALLHOSTS_GROUP
);
331 ((u8
*)&iph
[1])[0] = IPOPT_RA
;
332 ((u8
*)&iph
[1])[1] = 4;
333 ((u8
*)&iph
[1])[2] = 0;
334 ((u8
*)&iph
[1])[3] = 0;
338 skb_set_transport_header(skb
, skb
->len
);
340 ih
->type
= IGMP_HOST_MEMBERSHIP_QUERY
;
341 ih
->code
= (group
? br
->multicast_last_member_interval
:
342 br
->multicast_query_response_interval
) /
343 (HZ
/ IGMP_TIMER_SCALE
);
346 ih
->csum
= ip_compute_csum((void *)ih
, sizeof(struct igmphdr
));
347 skb_put(skb
, sizeof(*ih
));
349 __skb_pull(skb
, sizeof(*eth
));
355 static struct sk_buff
*br_multicast_alloc_query(struct net_bridge
*br
,
358 switch (addr
->proto
) {
359 case htons(ETH_P_IP
):
360 return br_ip4_multicast_alloc_query(br
, addr
->u
.ip4
);
365 static void br_multicast_send_group_query(struct net_bridge_mdb_entry
*mp
)
367 struct net_bridge
*br
= mp
->br
;
370 skb
= br_multicast_alloc_query(br
, &mp
->addr
);
377 if (++mp
->queries_sent
< br
->multicast_last_member_count
)
378 mod_timer(&mp
->query_timer
,
379 jiffies
+ br
->multicast_last_member_interval
);
382 static void br_multicast_group_query_expired(unsigned long data
)
384 struct net_bridge_mdb_entry
*mp
= (void *)data
;
385 struct net_bridge
*br
= mp
->br
;
387 spin_lock(&br
->multicast_lock
);
388 if (!netif_running(br
->dev
) || hlist_unhashed(&mp
->mglist
) ||
389 mp
->queries_sent
>= br
->multicast_last_member_count
)
392 br_multicast_send_group_query(mp
);
395 spin_unlock(&br
->multicast_lock
);
398 static void br_multicast_send_port_group_query(struct net_bridge_port_group
*pg
)
400 struct net_bridge_port
*port
= pg
->port
;
401 struct net_bridge
*br
= port
->br
;
404 skb
= br_multicast_alloc_query(br
, &pg
->addr
);
408 br_deliver(port
, skb
);
411 if (++pg
->queries_sent
< br
->multicast_last_member_count
)
412 mod_timer(&pg
->query_timer
,
413 jiffies
+ br
->multicast_last_member_interval
);
416 static void br_multicast_port_group_query_expired(unsigned long data
)
418 struct net_bridge_port_group
*pg
= (void *)data
;
419 struct net_bridge_port
*port
= pg
->port
;
420 struct net_bridge
*br
= port
->br
;
422 spin_lock(&br
->multicast_lock
);
423 if (!netif_running(br
->dev
) || hlist_unhashed(&pg
->mglist
) ||
424 pg
->queries_sent
>= br
->multicast_last_member_count
)
427 br_multicast_send_port_group_query(pg
);
430 spin_unlock(&br
->multicast_lock
);
433 static struct net_bridge_mdb_entry
*br_multicast_get_group(
434 struct net_bridge
*br
, struct net_bridge_port
*port
,
435 struct br_ip
*group
, int hash
)
437 struct net_bridge_mdb_htable
*mdb
= br
->mdb
;
438 struct net_bridge_mdb_entry
*mp
;
439 struct hlist_node
*p
;
445 hlist_for_each_entry(mp
, p
, &mdb
->mhash
[hash
], hlist
[mdb
->ver
]) {
447 if (unlikely(br_ip_equal(group
, &mp
->addr
)))
454 if (unlikely(count
> br
->hash_elasticity
&& count
)) {
456 printk(KERN_INFO
"%s: Multicast hash table "
457 "chain limit reached: %s\n",
458 br
->dev
->name
, port
? port
->dev
->name
:
461 elasticity
= br
->hash_elasticity
;
464 if (mdb
->size
>= max
) {
466 if (unlikely(max
>= br
->hash_max
)) {
467 printk(KERN_WARNING
"%s: Multicast hash table maximum "
468 "reached, disabling snooping: %s, %d\n",
469 br
->dev
->name
, port
? port
->dev
->name
:
474 br
->multicast_disabled
= 1;
479 if (max
> mdb
->max
|| elasticity
) {
482 printk(KERN_INFO
"%s: Multicast hash table "
484 br
->dev
->name
, port
? port
->dev
->name
:
490 err
= br_mdb_rehash(&br
->mdb
, max
, elasticity
);
492 printk(KERN_WARNING
"%s: Cannot rehash multicast "
493 "hash table, disabling snooping: "
495 br
->dev
->name
, port
? port
->dev
->name
:
512 static struct net_bridge_mdb_entry
*br_multicast_new_group(
513 struct net_bridge
*br
, struct net_bridge_port
*port
,
516 struct net_bridge_mdb_htable
*mdb
= br
->mdb
;
517 struct net_bridge_mdb_entry
*mp
;
521 if (br_mdb_rehash(&br
->mdb
, BR_HASH_SIZE
, 0))
526 hash
= br_ip_hash(mdb
, group
);
527 mp
= br_multicast_get_group(br
, port
, group
, hash
);
528 switch (PTR_ERR(mp
)) {
535 hash
= br_ip_hash(mdb
, group
);
542 mp
= kzalloc(sizeof(*mp
), GFP_ATOMIC
);
548 setup_timer(&mp
->timer
, br_multicast_group_expired
,
550 setup_timer(&mp
->query_timer
, br_multicast_group_query_expired
,
553 hlist_add_head_rcu(&mp
->hlist
[mdb
->ver
], &mdb
->mhash
[hash
]);
560 static int br_multicast_add_group(struct net_bridge
*br
,
561 struct net_bridge_port
*port
,
564 struct net_bridge_mdb_entry
*mp
;
565 struct net_bridge_port_group
*p
;
566 struct net_bridge_port_group
**pp
;
567 unsigned long now
= jiffies
;
570 spin_lock(&br
->multicast_lock
);
571 if (!netif_running(br
->dev
) ||
572 (port
&& port
->state
== BR_STATE_DISABLED
))
575 mp
= br_multicast_new_group(br
, port
, group
);
577 if (unlikely(IS_ERR(mp
) || !mp
))
581 hlist_add_head(&mp
->mglist
, &br
->mglist
);
582 mod_timer(&mp
->timer
, now
+ br
->multicast_membership_interval
);
586 for (pp
= &mp
->ports
; (p
= *pp
); pp
= &p
->next
) {
589 if ((unsigned long)p
->port
< (unsigned long)port
)
593 p
= kzalloc(sizeof(*p
), GFP_ATOMIC
);
601 hlist_add_head(&p
->mglist
, &port
->mglist
);
602 setup_timer(&p
->timer
, br_multicast_port_group_expired
,
604 setup_timer(&p
->query_timer
, br_multicast_port_group_query_expired
,
607 rcu_assign_pointer(*pp
, p
);
610 mod_timer(&p
->timer
, now
+ br
->multicast_membership_interval
);
615 spin_unlock(&br
->multicast_lock
);
619 static int br_ip4_multicast_add_group(struct net_bridge
*br
,
620 struct net_bridge_port
*port
,
623 struct br_ip br_group
;
625 if (ipv4_is_local_multicast(group
))
628 br_group
.u
.ip4
= group
;
629 br_group
.proto
= htons(ETH_P_IP
);
631 return br_multicast_add_group(br
, port
, &br_group
);
634 static void br_multicast_router_expired(unsigned long data
)
636 struct net_bridge_port
*port
= (void *)data
;
637 struct net_bridge
*br
= port
->br
;
639 spin_lock(&br
->multicast_lock
);
640 if (port
->multicast_router
!= 1 ||
641 timer_pending(&port
->multicast_router_timer
) ||
642 hlist_unhashed(&port
->rlist
))
645 hlist_del_init_rcu(&port
->rlist
);
648 spin_unlock(&br
->multicast_lock
);
651 static void br_multicast_local_router_expired(unsigned long data
)
655 static void __br_multicast_send_query(struct net_bridge
*br
,
656 struct net_bridge_port
*port
,
661 skb
= br_multicast_alloc_query(br
, ip
);
666 __skb_push(skb
, sizeof(struct ethhdr
));
667 skb
->dev
= port
->dev
;
668 NF_HOOK(PF_BRIDGE
, NF_BR_LOCAL_OUT
, skb
, NULL
, skb
->dev
,
674 static void br_multicast_send_query(struct net_bridge
*br
,
675 struct net_bridge_port
*port
, u32 sent
)
678 struct br_ip br_group
;
680 if (!netif_running(br
->dev
) || br
->multicast_disabled
||
681 timer_pending(&br
->multicast_querier_timer
))
685 br_group
.proto
= htons(ETH_P_IP
);
687 __br_multicast_send_query(br
, port
, &br_group
);
690 time
+= sent
< br
->multicast_startup_query_count
?
691 br
->multicast_startup_query_interval
:
692 br
->multicast_query_interval
;
693 mod_timer(port
? &port
->multicast_query_timer
:
694 &br
->multicast_query_timer
, time
);
697 static void br_multicast_port_query_expired(unsigned long data
)
699 struct net_bridge_port
*port
= (void *)data
;
700 struct net_bridge
*br
= port
->br
;
702 spin_lock(&br
->multicast_lock
);
703 if (port
->state
== BR_STATE_DISABLED
||
704 port
->state
== BR_STATE_BLOCKING
)
707 if (port
->multicast_startup_queries_sent
<
708 br
->multicast_startup_query_count
)
709 port
->multicast_startup_queries_sent
++;
711 br_multicast_send_query(port
->br
, port
,
712 port
->multicast_startup_queries_sent
);
715 spin_unlock(&br
->multicast_lock
);
718 void br_multicast_add_port(struct net_bridge_port
*port
)
720 port
->multicast_router
= 1;
722 setup_timer(&port
->multicast_router_timer
, br_multicast_router_expired
,
723 (unsigned long)port
);
724 setup_timer(&port
->multicast_query_timer
,
725 br_multicast_port_query_expired
, (unsigned long)port
);
728 void br_multicast_del_port(struct net_bridge_port
*port
)
730 del_timer_sync(&port
->multicast_router_timer
);
733 static void __br_multicast_enable_port(struct net_bridge_port
*port
)
735 port
->multicast_startup_queries_sent
= 0;
737 if (try_to_del_timer_sync(&port
->multicast_query_timer
) >= 0 ||
738 del_timer(&port
->multicast_query_timer
))
739 mod_timer(&port
->multicast_query_timer
, jiffies
);
742 void br_multicast_enable_port(struct net_bridge_port
*port
)
744 struct net_bridge
*br
= port
->br
;
746 spin_lock(&br
->multicast_lock
);
747 if (br
->multicast_disabled
|| !netif_running(br
->dev
))
750 __br_multicast_enable_port(port
);
753 spin_unlock(&br
->multicast_lock
);
756 void br_multicast_disable_port(struct net_bridge_port
*port
)
758 struct net_bridge
*br
= port
->br
;
759 struct net_bridge_port_group
*pg
;
760 struct hlist_node
*p
, *n
;
762 spin_lock(&br
->multicast_lock
);
763 hlist_for_each_entry_safe(pg
, p
, n
, &port
->mglist
, mglist
)
764 br_multicast_del_pg(br
, pg
);
766 if (!hlist_unhashed(&port
->rlist
))
767 hlist_del_init_rcu(&port
->rlist
);
768 del_timer(&port
->multicast_router_timer
);
769 del_timer(&port
->multicast_query_timer
);
770 spin_unlock(&br
->multicast_lock
);
773 static int br_ip4_multicast_igmp3_report(struct net_bridge
*br
,
774 struct net_bridge_port
*port
,
777 struct igmpv3_report
*ih
;
778 struct igmpv3_grec
*grec
;
786 if (!pskb_may_pull(skb
, sizeof(*ih
)))
789 ih
= igmpv3_report_hdr(skb
);
790 num
= ntohs(ih
->ngrec
);
793 for (i
= 0; i
< num
; i
++) {
794 len
+= sizeof(*grec
);
795 if (!pskb_may_pull(skb
, len
))
798 grec
= (void *)(skb
->data
+ len
- sizeof(*grec
));
799 group
= grec
->grec_mca
;
800 type
= grec
->grec_type
;
802 len
+= ntohs(grec
->grec_nsrcs
) * 4;
803 if (!pskb_may_pull(skb
, len
))
806 /* We treat this as an IGMPv2 report for now. */
808 case IGMPV3_MODE_IS_INCLUDE
:
809 case IGMPV3_MODE_IS_EXCLUDE
:
810 case IGMPV3_CHANGE_TO_INCLUDE
:
811 case IGMPV3_CHANGE_TO_EXCLUDE
:
812 case IGMPV3_ALLOW_NEW_SOURCES
:
813 case IGMPV3_BLOCK_OLD_SOURCES
:
820 err
= br_ip4_multicast_add_group(br
, port
, group
);
828 static void br_multicast_add_router(struct net_bridge
*br
,
829 struct net_bridge_port
*port
)
831 struct hlist_node
*p
;
832 struct hlist_node
**h
;
834 for (h
= &br
->router_list
.first
;
836 (unsigned long)container_of(p
, struct net_bridge_port
, rlist
) >
841 port
->rlist
.pprev
= h
;
842 port
->rlist
.next
= p
;
843 rcu_assign_pointer(*h
, &port
->rlist
);
845 p
->pprev
= &port
->rlist
.next
;
848 static void br_multicast_mark_router(struct net_bridge
*br
,
849 struct net_bridge_port
*port
)
851 unsigned long now
= jiffies
;
854 if (br
->multicast_router
== 1)
855 mod_timer(&br
->multicast_router_timer
,
856 now
+ br
->multicast_querier_interval
);
860 if (port
->multicast_router
!= 1)
863 if (!hlist_unhashed(&port
->rlist
))
866 br_multicast_add_router(br
, port
);
869 mod_timer(&port
->multicast_router_timer
,
870 now
+ br
->multicast_querier_interval
);
873 static void br_multicast_query_received(struct net_bridge
*br
,
874 struct net_bridge_port
*port
,
878 mod_timer(&br
->multicast_querier_timer
,
879 jiffies
+ br
->multicast_querier_interval
);
880 else if (timer_pending(&br
->multicast_querier_timer
))
883 br_multicast_mark_router(br
, port
);
886 static int br_ip4_multicast_query(struct net_bridge
*br
,
887 struct net_bridge_port
*port
,
890 struct iphdr
*iph
= ip_hdr(skb
);
891 struct igmphdr
*ih
= igmp_hdr(skb
);
892 struct net_bridge_mdb_entry
*mp
;
893 struct igmpv3_query
*ih3
;
894 struct net_bridge_port_group
*p
;
895 struct net_bridge_port_group
**pp
;
896 unsigned long max_delay
;
897 unsigned long now
= jiffies
;
901 spin_lock(&br
->multicast_lock
);
902 if (!netif_running(br
->dev
) ||
903 (port
&& port
->state
== BR_STATE_DISABLED
))
906 br_multicast_query_received(br
, port
, !!iph
->saddr
);
910 if (skb
->len
== sizeof(*ih
)) {
911 max_delay
= ih
->code
* (HZ
/ IGMP_TIMER_SCALE
);
918 if (!pskb_may_pull(skb
, sizeof(struct igmpv3_query
))) {
923 ih3
= igmpv3_query_hdr(skb
);
927 max_delay
= ih3
->code
?
928 IGMPV3_MRC(ih3
->code
) * (HZ
/ IGMP_TIMER_SCALE
) : 1;
934 mp
= br_mdb_ip4_get(br
->mdb
, group
);
938 max_delay
*= br
->multicast_last_member_count
;
940 if (!hlist_unhashed(&mp
->mglist
) &&
941 (timer_pending(&mp
->timer
) ?
942 time_after(mp
->timer
.expires
, now
+ max_delay
) :
943 try_to_del_timer_sync(&mp
->timer
) >= 0))
944 mod_timer(&mp
->timer
, now
+ max_delay
);
946 for (pp
= &mp
->ports
; (p
= *pp
); pp
= &p
->next
) {
947 if (timer_pending(&p
->timer
) ?
948 time_after(p
->timer
.expires
, now
+ max_delay
) :
949 try_to_del_timer_sync(&p
->timer
) >= 0)
950 mod_timer(&mp
->timer
, now
+ max_delay
);
954 spin_unlock(&br
->multicast_lock
);
958 static void br_multicast_leave_group(struct net_bridge
*br
,
959 struct net_bridge_port
*port
,
962 struct net_bridge_mdb_htable
*mdb
;
963 struct net_bridge_mdb_entry
*mp
;
964 struct net_bridge_port_group
*p
;
968 spin_lock(&br
->multicast_lock
);
969 if (!netif_running(br
->dev
) ||
970 (port
&& port
->state
== BR_STATE_DISABLED
) ||
971 timer_pending(&br
->multicast_querier_timer
))
975 mp
= br_mdb_ip_get(mdb
, group
);
980 time
= now
+ br
->multicast_last_member_count
*
981 br
->multicast_last_member_interval
;
984 if (!hlist_unhashed(&mp
->mglist
) &&
985 (timer_pending(&mp
->timer
) ?
986 time_after(mp
->timer
.expires
, time
) :
987 try_to_del_timer_sync(&mp
->timer
) >= 0)) {
988 mod_timer(&mp
->timer
, time
);
990 mp
->queries_sent
= 0;
991 mod_timer(&mp
->query_timer
, now
);
997 for (p
= mp
->ports
; p
; p
= p
->next
) {
1001 if (!hlist_unhashed(&p
->mglist
) &&
1002 (timer_pending(&p
->timer
) ?
1003 time_after(p
->timer
.expires
, time
) :
1004 try_to_del_timer_sync(&p
->timer
) >= 0)) {
1005 mod_timer(&p
->timer
, time
);
1007 p
->queries_sent
= 0;
1008 mod_timer(&p
->query_timer
, now
);
1015 spin_unlock(&br
->multicast_lock
);
1018 static void br_ip4_multicast_leave_group(struct net_bridge
*br
,
1019 struct net_bridge_port
*port
,
1022 struct br_ip br_group
;
1024 if (ipv4_is_local_multicast(group
))
1027 br_group
.u
.ip4
= group
;
1028 br_group
.proto
= htons(ETH_P_IP
);
1030 br_multicast_leave_group(br
, port
, &br_group
);
1034 static int br_multicast_ipv4_rcv(struct net_bridge
*br
,
1035 struct net_bridge_port
*port
,
1036 struct sk_buff
*skb
)
1038 struct sk_buff
*skb2
= skb
;
1045 BR_INPUT_SKB_CB(skb
)->igmp
= 0;
1046 BR_INPUT_SKB_CB(skb
)->mrouters_only
= 0;
1048 /* We treat OOM as packet loss for now. */
1049 if (!pskb_may_pull(skb
, sizeof(*iph
)))
1054 if (iph
->ihl
< 5 || iph
->version
!= 4)
1057 if (!pskb_may_pull(skb
, ip_hdrlen(skb
)))
1062 if (unlikely(ip_fast_csum((u8
*)iph
, iph
->ihl
)))
1065 if (iph
->protocol
!= IPPROTO_IGMP
)
1068 len
= ntohs(iph
->tot_len
);
1069 if (skb
->len
< len
|| len
< ip_hdrlen(skb
))
1072 if (skb
->len
> len
) {
1073 skb2
= skb_clone(skb
, GFP_ATOMIC
);
1077 err
= pskb_trim_rcsum(skb2
, len
);
1082 len
-= ip_hdrlen(skb2
);
1083 offset
= skb_network_offset(skb2
) + ip_hdrlen(skb2
);
1084 __skb_pull(skb2
, offset
);
1085 skb_reset_transport_header(skb2
);
1088 if (!pskb_may_pull(skb2
, sizeof(*ih
)))
1091 switch (skb2
->ip_summed
) {
1092 case CHECKSUM_COMPLETE
:
1093 if (!csum_fold(skb2
->csum
))
1098 if (skb_checksum_complete(skb2
))
1104 BR_INPUT_SKB_CB(skb
)->igmp
= 1;
1105 ih
= igmp_hdr(skb2
);
1108 case IGMP_HOST_MEMBERSHIP_REPORT
:
1109 case IGMPV2_HOST_MEMBERSHIP_REPORT
:
1110 BR_INPUT_SKB_CB(skb2
)->mrouters_only
= 1;
1111 err
= br_ip4_multicast_add_group(br
, port
, ih
->group
);
1113 case IGMPV3_HOST_MEMBERSHIP_REPORT
:
1114 err
= br_ip4_multicast_igmp3_report(br
, port
, skb2
);
1116 case IGMP_HOST_MEMBERSHIP_QUERY
:
1117 err
= br_ip4_multicast_query(br
, port
, skb2
);
1119 case IGMP_HOST_LEAVE_MESSAGE
:
1120 br_ip4_multicast_leave_group(br
, port
, ih
->group
);
1125 __skb_push(skb2
, offset
);
1132 int br_multicast_rcv(struct net_bridge
*br
, struct net_bridge_port
*port
,
1133 struct sk_buff
*skb
)
1135 if (br
->multicast_disabled
)
1138 switch (skb
->protocol
) {
1139 case htons(ETH_P_IP
):
1140 return br_multicast_ipv4_rcv(br
, port
, skb
);
1146 static void br_multicast_query_expired(unsigned long data
)
1148 struct net_bridge
*br
= (void *)data
;
1150 spin_lock(&br
->multicast_lock
);
1151 if (br
->multicast_startup_queries_sent
<
1152 br
->multicast_startup_query_count
)
1153 br
->multicast_startup_queries_sent
++;
1155 br_multicast_send_query(br
, NULL
, br
->multicast_startup_queries_sent
);
1157 spin_unlock(&br
->multicast_lock
);
1160 void br_multicast_init(struct net_bridge
*br
)
1162 br
->hash_elasticity
= 4;
1165 br
->multicast_router
= 1;
1166 br
->multicast_last_member_count
= 2;
1167 br
->multicast_startup_query_count
= 2;
1169 br
->multicast_last_member_interval
= HZ
;
1170 br
->multicast_query_response_interval
= 10 * HZ
;
1171 br
->multicast_startup_query_interval
= 125 * HZ
/ 4;
1172 br
->multicast_query_interval
= 125 * HZ
;
1173 br
->multicast_querier_interval
= 255 * HZ
;
1174 br
->multicast_membership_interval
= 260 * HZ
;
1176 spin_lock_init(&br
->multicast_lock
);
1177 setup_timer(&br
->multicast_router_timer
,
1178 br_multicast_local_router_expired
, 0);
1179 setup_timer(&br
->multicast_querier_timer
,
1180 br_multicast_local_router_expired
, 0);
1181 setup_timer(&br
->multicast_query_timer
, br_multicast_query_expired
,
1185 void br_multicast_open(struct net_bridge
*br
)
1187 br
->multicast_startup_queries_sent
= 0;
1189 if (br
->multicast_disabled
)
1192 mod_timer(&br
->multicast_query_timer
, jiffies
);
1195 void br_multicast_stop(struct net_bridge
*br
)
1197 struct net_bridge_mdb_htable
*mdb
;
1198 struct net_bridge_mdb_entry
*mp
;
1199 struct hlist_node
*p
, *n
;
1203 del_timer_sync(&br
->multicast_router_timer
);
1204 del_timer_sync(&br
->multicast_querier_timer
);
1205 del_timer_sync(&br
->multicast_query_timer
);
1207 spin_lock_bh(&br
->multicast_lock
);
1215 for (i
= 0; i
< mdb
->max
; i
++) {
1216 hlist_for_each_entry_safe(mp
, p
, n
, &mdb
->mhash
[i
],
1218 del_timer(&mp
->timer
);
1219 del_timer(&mp
->query_timer
);
1220 call_rcu_bh(&mp
->rcu
, br_multicast_free_group
);
1225 spin_unlock_bh(&br
->multicast_lock
);
1227 spin_lock_bh(&br
->multicast_lock
);
1232 call_rcu_bh(&mdb
->rcu
, br_mdb_free
);
1235 spin_unlock_bh(&br
->multicast_lock
);
1238 int br_multicast_set_router(struct net_bridge
*br
, unsigned long val
)
1242 spin_lock_bh(&br
->multicast_lock
);
1243 if (!netif_running(br
->dev
))
1249 del_timer(&br
->multicast_router_timer
);
1252 br
->multicast_router
= val
;
1262 spin_unlock_bh(&br
->multicast_lock
);
1267 int br_multicast_set_port_router(struct net_bridge_port
*p
, unsigned long val
)
1269 struct net_bridge
*br
= p
->br
;
1272 spin_lock(&br
->multicast_lock
);
1273 if (!netif_running(br
->dev
) || p
->state
== BR_STATE_DISABLED
)
1280 p
->multicast_router
= val
;
1283 if (val
< 2 && !hlist_unhashed(&p
->rlist
))
1284 hlist_del_init_rcu(&p
->rlist
);
1289 del_timer(&p
->multicast_router_timer
);
1294 br_multicast_add_router(br
, p
);
1303 spin_unlock(&br
->multicast_lock
);
1308 int br_multicast_toggle(struct net_bridge
*br
, unsigned long val
)
1310 struct net_bridge_port
*port
;
1313 spin_lock(&br
->multicast_lock
);
1314 if (!netif_running(br
->dev
))
1318 if (br
->multicast_disabled
== !val
)
1321 br
->multicast_disabled
= !val
;
1322 if (br
->multicast_disabled
)
1329 br
->multicast_disabled
= !!val
;
1333 err
= br_mdb_rehash(&br
->mdb
, br
->mdb
->max
,
1334 br
->hash_elasticity
);
1339 br_multicast_open(br
);
1340 list_for_each_entry(port
, &br
->port_list
, list
) {
1341 if (port
->state
== BR_STATE_DISABLED
||
1342 port
->state
== BR_STATE_BLOCKING
)
1345 __br_multicast_enable_port(port
);
1349 spin_unlock(&br
->multicast_lock
);
1354 int br_multicast_set_hash_max(struct net_bridge
*br
, unsigned long val
)
1359 spin_lock(&br
->multicast_lock
);
1360 if (!netif_running(br
->dev
))
1364 if (!is_power_of_2(val
))
1366 if (br
->mdb
&& val
< br
->mdb
->size
)
1382 err
= br_mdb_rehash(&br
->mdb
, br
->hash_max
,
1383 br
->hash_elasticity
);
1389 spin_unlock(&br
->multicast_lock
);