1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Multicast support for IPv6
4 * Linux INET6 implementation
7 * Pedro Roque <roque@di.fc.ul.pt>
9 * Based on linux/ipv4/igmp.c and linux/ipv4/ip_sockglue.c
14 * yoshfuji : fix format of router-alert option
15 * YOSHIFUJI Hideaki @USAGI:
16 * Fixed source address for MLD message based on
17 * <draft-ietf-magma-mld-source-05.txt>.
18 * YOSHIFUJI Hideaki @USAGI:
19 * - Ignore Queries for invalid addresses.
20 * - MLD for link-local addresses.
21 * David L Stevens <dlstevens@us.ibm.com>:
25 #include <linux/module.h>
26 #include <linux/errno.h>
27 #include <linux/types.h>
28 #include <linux/string.h>
29 #include <linux/socket.h>
30 #include <linux/sockios.h>
31 #include <linux/jiffies.h>
32 #include <linux/net.h>
34 #include <linux/in6.h>
35 #include <linux/netdevice.h>
36 #include <linux/if_arp.h>
37 #include <linux/route.h>
38 #include <linux/init.h>
39 #include <linux/proc_fs.h>
40 #include <linux/seq_file.h>
41 #include <linux/slab.h>
42 #include <linux/pkt_sched.h>
44 #include <linux/workqueue.h>
46 #include <linux/netfilter.h>
47 #include <linux/netfilter_ipv6.h>
49 #include <net/net_namespace.h>
54 #include <net/protocol.h>
55 #include <net/if_inet6.h>
56 #include <net/ndisc.h>
57 #include <net/addrconf.h>
58 #include <net/ip6_route.h>
59 #include <net/inet_common.h>
61 #include <net/ip6_checksum.h>
63 /* Ensure that we have struct in6_addr aligned on 32bit word. */
64 static int __mld2_query_bugs
[] __attribute__((__unused__
)) = {
65 BUILD_BUG_ON_ZERO(offsetof(struct mld2_query
, mld2q_srcs
) % 4),
66 BUILD_BUG_ON_ZERO(offsetof(struct mld2_report
, mld2r_grec
) % 4),
67 BUILD_BUG_ON_ZERO(offsetof(struct mld2_grec
, grec_mca
) % 4)
70 static struct workqueue_struct
*mld_wq
;
71 static struct in6_addr mld2_all_mcr
= MLD2_ALL_MCR_INIT
;
73 static void igmp6_join_group(struct ifmcaddr6
*ma
);
74 static void igmp6_leave_group(struct ifmcaddr6
*ma
);
75 static void mld_mca_work(struct work_struct
*work
);
77 static void mld_ifc_event(struct inet6_dev
*idev
);
78 static bool mld_in_v1_mode(const struct inet6_dev
*idev
);
79 static int sf_setstate(struct ifmcaddr6
*pmc
);
80 static void sf_markstate(struct ifmcaddr6
*pmc
);
81 static void ip6_mc_clear_src(struct ifmcaddr6
*pmc
);
82 static int ip6_mc_del_src(struct inet6_dev
*idev
, const struct in6_addr
*pmca
,
83 int sfmode
, int sfcount
, const struct in6_addr
*psfsrc
,
85 static int ip6_mc_add_src(struct inet6_dev
*idev
, const struct in6_addr
*pmca
,
86 int sfmode
, int sfcount
, const struct in6_addr
*psfsrc
,
88 static int ip6_mc_leave_src(struct sock
*sk
, struct ipv6_mc_socklist
*iml
,
89 struct inet6_dev
*idev
);
90 static int __ipv6_dev_mc_inc(struct net_device
*dev
,
91 const struct in6_addr
*addr
, unsigned int mode
);
93 #define MLD_QRV_DEFAULT 2
94 /* RFC3810, 9.2. Query Interval */
95 #define MLD_QI_DEFAULT (125 * HZ)
96 /* RFC3810, 9.3. Query Response Interval */
97 #define MLD_QRI_DEFAULT (10 * HZ)
99 /* RFC3810, 8.1 Query Version Distinctions */
100 #define MLD_V1_QUERY_LEN 24
101 #define MLD_V2_QUERY_LEN_MIN 28
103 #define IPV6_MLD_MAX_MSF 64
105 int sysctl_mld_max_msf __read_mostly
= IPV6_MLD_MAX_MSF
;
106 int sysctl_mld_qrv __read_mostly
= MLD_QRV_DEFAULT
;
109 * socket join on multicast group
111 #define mc_dereference(e, idev) \
112 rcu_dereference_protected(e, lockdep_is_held(&(idev)->mc_lock))
114 #define sock_dereference(e, sk) \
115 rcu_dereference_protected(e, lockdep_sock_is_held(sk))
117 #define for_each_pmc_socklock(np, sk, pmc) \
118 for (pmc = sock_dereference((np)->ipv6_mc_list, sk); \
120 pmc = sock_dereference(pmc->next, sk))
122 #define for_each_pmc_rcu(np, pmc) \
123 for (pmc = rcu_dereference((np)->ipv6_mc_list); \
125 pmc = rcu_dereference(pmc->next))
127 #define for_each_psf_mclock(mc, psf) \
128 for (psf = mc_dereference((mc)->mca_sources, mc->idev); \
130 psf = mc_dereference(psf->sf_next, mc->idev))
132 #define for_each_psf_rcu(mc, psf) \
133 for (psf = rcu_dereference((mc)->mca_sources); \
135 psf = rcu_dereference(psf->sf_next))
137 #define for_each_psf_tomb(mc, psf) \
138 for (psf = mc_dereference((mc)->mca_tomb, mc->idev); \
140 psf = mc_dereference(psf->sf_next, mc->idev))
142 #define for_each_mc_mclock(idev, mc) \
143 for (mc = mc_dereference((idev)->mc_list, idev); \
145 mc = mc_dereference(mc->next, idev))
147 #define for_each_mc_rcu(idev, mc) \
148 for (mc = rcu_dereference((idev)->mc_list); \
150 mc = rcu_dereference(mc->next))
152 #define for_each_mc_tomb(idev, mc) \
153 for (mc = mc_dereference((idev)->mc_tomb, idev); \
155 mc = mc_dereference(mc->next, idev))
157 static int unsolicited_report_interval(struct inet6_dev
*idev
)
161 if (mld_in_v1_mode(idev
))
162 iv
= idev
->cnf
.mldv1_unsolicited_report_interval
;
164 iv
= idev
->cnf
.mldv2_unsolicited_report_interval
;
166 return iv
> 0 ? iv
: 1;
169 static int __ipv6_sock_mc_join(struct sock
*sk
, int ifindex
,
170 const struct in6_addr
*addr
, unsigned int mode
)
172 struct net_device
*dev
= NULL
;
173 struct ipv6_mc_socklist
*mc_lst
;
174 struct ipv6_pinfo
*np
= inet6_sk(sk
);
175 struct net
*net
= sock_net(sk
);
180 if (!ipv6_addr_is_multicast(addr
))
183 for_each_pmc_socklock(np
, sk
, mc_lst
) {
184 if ((ifindex
== 0 || mc_lst
->ifindex
== ifindex
) &&
185 ipv6_addr_equal(&mc_lst
->addr
, addr
))
189 mc_lst
= sock_kmalloc(sk
, sizeof(struct ipv6_mc_socklist
), GFP_KERNEL
);
195 mc_lst
->addr
= *addr
;
199 rt
= rt6_lookup(net
, addr
, NULL
, 0, NULL
, 0);
205 dev
= __dev_get_by_index(net
, ifindex
);
208 sock_kfree_s(sk
, mc_lst
, sizeof(*mc_lst
));
212 mc_lst
->ifindex
= dev
->ifindex
;
213 mc_lst
->sfmode
= mode
;
214 RCU_INIT_POINTER(mc_lst
->sflist
, NULL
);
217 * now add/increase the group membership on the device
220 err
= __ipv6_dev_mc_inc(dev
, addr
, mode
);
223 sock_kfree_s(sk
, mc_lst
, sizeof(*mc_lst
));
227 mc_lst
->next
= np
->ipv6_mc_list
;
228 rcu_assign_pointer(np
->ipv6_mc_list
, mc_lst
);
233 int ipv6_sock_mc_join(struct sock
*sk
, int ifindex
, const struct in6_addr
*addr
)
235 return __ipv6_sock_mc_join(sk
, ifindex
, addr
, MCAST_EXCLUDE
);
237 EXPORT_SYMBOL(ipv6_sock_mc_join
);
239 int ipv6_sock_mc_join_ssm(struct sock
*sk
, int ifindex
,
240 const struct in6_addr
*addr
, unsigned int mode
)
242 return __ipv6_sock_mc_join(sk
, ifindex
, addr
, mode
);
246 * socket leave on multicast group
248 int ipv6_sock_mc_drop(struct sock
*sk
, int ifindex
, const struct in6_addr
*addr
)
250 struct ipv6_pinfo
*np
= inet6_sk(sk
);
251 struct ipv6_mc_socklist
*mc_lst
;
252 struct ipv6_mc_socklist __rcu
**lnk
;
253 struct net
*net
= sock_net(sk
);
257 if (!ipv6_addr_is_multicast(addr
))
260 for (lnk
= &np
->ipv6_mc_list
;
261 (mc_lst
= sock_dereference(*lnk
, sk
)) != NULL
;
262 lnk
= &mc_lst
->next
) {
263 if ((ifindex
== 0 || mc_lst
->ifindex
== ifindex
) &&
264 ipv6_addr_equal(&mc_lst
->addr
, addr
)) {
265 struct net_device
*dev
;
269 dev
= __dev_get_by_index(net
, mc_lst
->ifindex
);
271 struct inet6_dev
*idev
= __in6_dev_get(dev
);
273 ip6_mc_leave_src(sk
, mc_lst
, idev
);
275 __ipv6_dev_mc_dec(idev
, &mc_lst
->addr
);
277 ip6_mc_leave_src(sk
, mc_lst
, NULL
);
280 atomic_sub(sizeof(*mc_lst
), &sk
->sk_omem_alloc
);
281 kfree_rcu(mc_lst
, rcu
);
286 return -EADDRNOTAVAIL
;
288 EXPORT_SYMBOL(ipv6_sock_mc_drop
);
290 static struct inet6_dev
*ip6_mc_find_dev_rtnl(struct net
*net
,
291 const struct in6_addr
*group
,
294 struct net_device
*dev
= NULL
;
295 struct inet6_dev
*idev
= NULL
;
298 struct rt6_info
*rt
= rt6_lookup(net
, group
, NULL
, 0, NULL
, 0);
305 dev
= __dev_get_by_index(net
, ifindex
);
310 idev
= __in6_dev_get(dev
);
318 void __ipv6_sock_mc_close(struct sock
*sk
)
320 struct ipv6_pinfo
*np
= inet6_sk(sk
);
321 struct ipv6_mc_socklist
*mc_lst
;
322 struct net
*net
= sock_net(sk
);
326 while ((mc_lst
= sock_dereference(np
->ipv6_mc_list
, sk
)) != NULL
) {
327 struct net_device
*dev
;
329 np
->ipv6_mc_list
= mc_lst
->next
;
331 dev
= __dev_get_by_index(net
, mc_lst
->ifindex
);
333 struct inet6_dev
*idev
= __in6_dev_get(dev
);
335 ip6_mc_leave_src(sk
, mc_lst
, idev
);
337 __ipv6_dev_mc_dec(idev
, &mc_lst
->addr
);
339 ip6_mc_leave_src(sk
, mc_lst
, NULL
);
342 atomic_sub(sizeof(*mc_lst
), &sk
->sk_omem_alloc
);
343 kfree_rcu(mc_lst
, rcu
);
347 void ipv6_sock_mc_close(struct sock
*sk
)
349 struct ipv6_pinfo
*np
= inet6_sk(sk
);
351 if (!rcu_access_pointer(np
->ipv6_mc_list
))
356 __ipv6_sock_mc_close(sk
);
361 int ip6_mc_source(int add
, int omode
, struct sock
*sk
,
362 struct group_source_req
*pgsr
)
364 struct in6_addr
*source
, *group
;
365 struct ipv6_mc_socklist
*pmc
;
366 struct inet6_dev
*idev
;
367 struct ipv6_pinfo
*inet6
= inet6_sk(sk
);
368 struct ip6_sf_socklist
*psl
;
369 struct net
*net
= sock_net(sk
);
374 source
= &((struct sockaddr_in6
*)&pgsr
->gsr_source
)->sin6_addr
;
375 group
= &((struct sockaddr_in6
*)&pgsr
->gsr_group
)->sin6_addr
;
377 if (!ipv6_addr_is_multicast(group
))
380 idev
= ip6_mc_find_dev_rtnl(net
, group
, pgsr
->gsr_interface
);
384 err
= -EADDRNOTAVAIL
;
386 mutex_lock(&idev
->mc_lock
);
387 for_each_pmc_socklock(inet6
, sk
, pmc
) {
388 if (pgsr
->gsr_interface
&& pmc
->ifindex
!= pgsr
->gsr_interface
)
390 if (ipv6_addr_equal(&pmc
->addr
, group
))
393 if (!pmc
) { /* must have a prior join */
397 /* if a source filter was set, must be the same mode as before */
398 if (rcu_access_pointer(pmc
->sflist
)) {
399 if (pmc
->sfmode
!= omode
) {
403 } else if (pmc
->sfmode
!= omode
) {
404 /* allow mode switches for empty-set filters */
405 ip6_mc_add_src(idev
, group
, omode
, 0, NULL
, 0);
406 ip6_mc_del_src(idev
, group
, pmc
->sfmode
, 0, NULL
, 0);
410 psl
= sock_dereference(pmc
->sflist
, sk
);
413 goto done
; /* err = -EADDRNOTAVAIL */
415 for (i
= 0; i
< psl
->sl_count
; i
++) {
416 rv
= !ipv6_addr_equal(&psl
->sl_addr
[i
], source
);
420 if (rv
) /* source not found */
421 goto done
; /* err = -EADDRNOTAVAIL */
423 /* special case - (INCLUDE, empty) == LEAVE_GROUP */
424 if (psl
->sl_count
== 1 && omode
== MCAST_INCLUDE
) {
429 /* update the interface filter */
430 ip6_mc_del_src(idev
, group
, omode
, 1, source
, 1);
432 for (j
= i
+1; j
< psl
->sl_count
; j
++)
433 psl
->sl_addr
[j
-1] = psl
->sl_addr
[j
];
438 /* else, add a new source to the filter */
440 if (psl
&& psl
->sl_count
>= sysctl_mld_max_msf
) {
444 if (!psl
|| psl
->sl_count
== psl
->sl_max
) {
445 struct ip6_sf_socklist
*newpsl
;
446 int count
= IP6_SFBLOCK
;
449 count
+= psl
->sl_max
;
450 newpsl
= sock_kmalloc(sk
, struct_size(newpsl
, sl_addr
, count
),
456 newpsl
->sl_max
= count
;
457 newpsl
->sl_count
= count
- IP6_SFBLOCK
;
459 for (i
= 0; i
< psl
->sl_count
; i
++)
460 newpsl
->sl_addr
[i
] = psl
->sl_addr
[i
];
461 atomic_sub(struct_size(psl
, sl_addr
, psl
->sl_max
),
464 rcu_assign_pointer(pmc
->sflist
, newpsl
);
468 rv
= 1; /* > 0 for insert logic below if sl_count is 0 */
469 for (i
= 0; i
< psl
->sl_count
; i
++) {
470 rv
= !ipv6_addr_equal(&psl
->sl_addr
[i
], source
);
471 if (rv
== 0) /* There is an error in the address. */
474 for (j
= psl
->sl_count
-1; j
>= i
; j
--)
475 psl
->sl_addr
[j
+1] = psl
->sl_addr
[j
];
476 psl
->sl_addr
[i
] = *source
;
479 /* update the interface list */
480 ip6_mc_add_src(idev
, group
, omode
, 1, source
, 1);
482 mutex_unlock(&idev
->mc_lock
);
484 err
= ipv6_sock_mc_drop(sk
, pgsr
->gsr_interface
, group
);
488 int ip6_mc_msfilter(struct sock
*sk
, struct group_filter
*gsf
,
489 struct sockaddr_storage
*list
)
491 const struct in6_addr
*group
;
492 struct ipv6_mc_socklist
*pmc
;
493 struct inet6_dev
*idev
;
494 struct ipv6_pinfo
*inet6
= inet6_sk(sk
);
495 struct ip6_sf_socklist
*newpsl
, *psl
;
496 struct net
*net
= sock_net(sk
);
500 group
= &((struct sockaddr_in6
*)&gsf
->gf_group
)->sin6_addr
;
502 if (!ipv6_addr_is_multicast(group
))
504 if (gsf
->gf_fmode
!= MCAST_INCLUDE
&&
505 gsf
->gf_fmode
!= MCAST_EXCLUDE
)
508 idev
= ip6_mc_find_dev_rtnl(net
, group
, gsf
->gf_interface
);
514 if (gsf
->gf_fmode
== MCAST_INCLUDE
&& gsf
->gf_numsrc
== 0) {
519 for_each_pmc_socklock(inet6
, sk
, pmc
) {
520 if (pmc
->ifindex
!= gsf
->gf_interface
)
522 if (ipv6_addr_equal(&pmc
->addr
, group
))
525 if (!pmc
) { /* must have a prior join */
529 if (gsf
->gf_numsrc
) {
530 newpsl
= sock_kmalloc(sk
, struct_size(newpsl
, sl_addr
,
537 newpsl
->sl_max
= newpsl
->sl_count
= gsf
->gf_numsrc
;
538 for (i
= 0; i
< newpsl
->sl_count
; ++i
, ++list
) {
539 struct sockaddr_in6
*psin6
;
541 psin6
= (struct sockaddr_in6
*)list
;
542 newpsl
->sl_addr
[i
] = psin6
->sin6_addr
;
544 mutex_lock(&idev
->mc_lock
);
545 err
= ip6_mc_add_src(idev
, group
, gsf
->gf_fmode
,
546 newpsl
->sl_count
, newpsl
->sl_addr
, 0);
548 mutex_unlock(&idev
->mc_lock
);
549 sock_kfree_s(sk
, newpsl
, struct_size(newpsl
, sl_addr
,
553 mutex_unlock(&idev
->mc_lock
);
556 mutex_lock(&idev
->mc_lock
);
557 ip6_mc_add_src(idev
, group
, gsf
->gf_fmode
, 0, NULL
, 0);
558 mutex_unlock(&idev
->mc_lock
);
561 mutex_lock(&idev
->mc_lock
);
562 psl
= sock_dereference(pmc
->sflist
, sk
);
564 ip6_mc_del_src(idev
, group
, pmc
->sfmode
,
565 psl
->sl_count
, psl
->sl_addr
, 0);
566 atomic_sub(struct_size(psl
, sl_addr
, psl
->sl_max
),
569 ip6_mc_del_src(idev
, group
, pmc
->sfmode
, 0, NULL
, 0);
571 rcu_assign_pointer(pmc
->sflist
, newpsl
);
572 mutex_unlock(&idev
->mc_lock
);
574 pmc
->sfmode
= gsf
->gf_fmode
;
578 err
= ipv6_sock_mc_drop(sk
, gsf
->gf_interface
, group
);
582 int ip6_mc_msfget(struct sock
*sk
, struct group_filter
*gsf
,
583 struct sockaddr_storage __user
*p
)
585 struct ipv6_pinfo
*inet6
= inet6_sk(sk
);
586 const struct in6_addr
*group
;
587 struct ipv6_mc_socklist
*pmc
;
588 struct ip6_sf_socklist
*psl
;
589 int i
, count
, copycount
;
591 group
= &((struct sockaddr_in6
*)&gsf
->gf_group
)->sin6_addr
;
593 if (!ipv6_addr_is_multicast(group
))
596 /* changes to the ipv6_mc_list require the socket lock and
597 * rtnl lock. We have the socket lock, so reading the list is safe.
600 for_each_pmc_socklock(inet6
, sk
, pmc
) {
601 if (pmc
->ifindex
!= gsf
->gf_interface
)
603 if (ipv6_addr_equal(group
, &pmc
->addr
))
606 if (!pmc
) /* must have a prior join */
607 return -EADDRNOTAVAIL
;
609 gsf
->gf_fmode
= pmc
->sfmode
;
610 psl
= sock_dereference(pmc
->sflist
, sk
);
611 count
= psl
? psl
->sl_count
: 0;
613 copycount
= count
< gsf
->gf_numsrc
? count
: gsf
->gf_numsrc
;
614 gsf
->gf_numsrc
= count
;
616 for (i
= 0; i
< copycount
; i
++, p
++) {
617 struct sockaddr_in6
*psin6
;
618 struct sockaddr_storage ss
;
620 psin6
= (struct sockaddr_in6
*)&ss
;
621 memset(&ss
, 0, sizeof(ss
));
622 psin6
->sin6_family
= AF_INET6
;
623 psin6
->sin6_addr
= psl
->sl_addr
[i
];
624 if (copy_to_user(p
, &ss
, sizeof(ss
)))
630 bool inet6_mc_check(struct sock
*sk
, const struct in6_addr
*mc_addr
,
631 const struct in6_addr
*src_addr
)
633 struct ipv6_pinfo
*np
= inet6_sk(sk
);
634 struct ipv6_mc_socklist
*mc
;
635 struct ip6_sf_socklist
*psl
;
639 for_each_pmc_rcu(np
, mc
) {
640 if (ipv6_addr_equal(&mc
->addr
, mc_addr
))
647 psl
= rcu_dereference(mc
->sflist
);
649 rv
= mc
->sfmode
== MCAST_EXCLUDE
;
653 for (i
= 0; i
< psl
->sl_count
; i
++) {
654 if (ipv6_addr_equal(&psl
->sl_addr
[i
], src_addr
))
657 if (mc
->sfmode
== MCAST_INCLUDE
&& i
>= psl
->sl_count
)
659 if (mc
->sfmode
== MCAST_EXCLUDE
&& i
< psl
->sl_count
)
667 /* called with mc_lock */
668 static void igmp6_group_added(struct ifmcaddr6
*mc
)
670 struct net_device
*dev
= mc
->idev
->dev
;
671 char buf
[MAX_ADDR_LEN
];
673 if (IPV6_ADDR_MC_SCOPE(&mc
->mca_addr
) <
674 IPV6_ADDR_SCOPE_LINKLOCAL
)
677 if (!(mc
->mca_flags
&MAF_LOADED
)) {
678 mc
->mca_flags
|= MAF_LOADED
;
679 if (ndisc_mc_map(&mc
->mca_addr
, buf
, dev
, 0) == 0)
680 dev_mc_add(dev
, buf
);
683 if (!(dev
->flags
& IFF_UP
) || (mc
->mca_flags
& MAF_NOREPORT
))
686 if (mld_in_v1_mode(mc
->idev
)) {
687 igmp6_join_group(mc
);
692 /* Based on RFC3810 6.1, for newly added INCLUDE SSM, we
693 * should not send filter-mode change record as the mode
694 * should be from IN() to IN(A).
696 if (mc
->mca_sfmode
== MCAST_EXCLUDE
)
697 mc
->mca_crcount
= mc
->idev
->mc_qrv
;
699 mld_ifc_event(mc
->idev
);
702 /* called with mc_lock */
703 static void igmp6_group_dropped(struct ifmcaddr6
*mc
)
705 struct net_device
*dev
= mc
->idev
->dev
;
706 char buf
[MAX_ADDR_LEN
];
708 if (IPV6_ADDR_MC_SCOPE(&mc
->mca_addr
) <
709 IPV6_ADDR_SCOPE_LINKLOCAL
)
712 if (mc
->mca_flags
&MAF_LOADED
) {
713 mc
->mca_flags
&= ~MAF_LOADED
;
714 if (ndisc_mc_map(&mc
->mca_addr
, buf
, dev
, 0) == 0)
715 dev_mc_del(dev
, buf
);
718 if (mc
->mca_flags
& MAF_NOREPORT
)
722 igmp6_leave_group(mc
);
724 if (cancel_delayed_work(&mc
->mca_work
))
725 refcount_dec(&mc
->mca_refcnt
);
729 * deleted ifmcaddr6 manipulation
730 * called with mc_lock
732 static void mld_add_delrec(struct inet6_dev
*idev
, struct ifmcaddr6
*im
)
734 struct ifmcaddr6
*pmc
;
736 /* this is an "ifmcaddr6" for convenience; only the fields below
737 * are actually used. In particular, the refcnt and users are not
738 * used for management of the delete list. Using the same structure
739 * for deleted items allows change reports to use common code with
740 * non-deleted or query-response MCA's.
742 pmc
= kzalloc(sizeof(*pmc
), GFP_KERNEL
);
746 pmc
->idev
= im
->idev
;
748 pmc
->mca_addr
= im
->mca_addr
;
749 pmc
->mca_crcount
= idev
->mc_qrv
;
750 pmc
->mca_sfmode
= im
->mca_sfmode
;
751 if (pmc
->mca_sfmode
== MCAST_INCLUDE
) {
752 struct ip6_sf_list
*psf
;
754 rcu_assign_pointer(pmc
->mca_tomb
,
755 mc_dereference(im
->mca_tomb
, idev
));
756 rcu_assign_pointer(pmc
->mca_sources
,
757 mc_dereference(im
->mca_sources
, idev
));
758 RCU_INIT_POINTER(im
->mca_tomb
, NULL
);
759 RCU_INIT_POINTER(im
->mca_sources
, NULL
);
761 for_each_psf_mclock(pmc
, psf
)
762 psf
->sf_crcount
= pmc
->mca_crcount
;
765 rcu_assign_pointer(pmc
->next
, idev
->mc_tomb
);
766 rcu_assign_pointer(idev
->mc_tomb
, pmc
);
769 /* called with mc_lock */
770 static void mld_del_delrec(struct inet6_dev
*idev
, struct ifmcaddr6
*im
)
772 struct ip6_sf_list
*psf
, *sources
, *tomb
;
773 struct in6_addr
*pmca
= &im
->mca_addr
;
774 struct ifmcaddr6
*pmc
, *pmc_prev
;
777 for_each_mc_tomb(idev
, pmc
) {
778 if (ipv6_addr_equal(&pmc
->mca_addr
, pmca
))
784 rcu_assign_pointer(pmc_prev
->next
, pmc
->next
);
786 rcu_assign_pointer(idev
->mc_tomb
, pmc
->next
);
790 im
->idev
= pmc
->idev
;
791 if (im
->mca_sfmode
== MCAST_INCLUDE
) {
792 tomb
= rcu_replace_pointer(im
->mca_tomb
,
793 mc_dereference(pmc
->mca_tomb
, pmc
->idev
),
794 lockdep_is_held(&im
->idev
->mc_lock
));
795 rcu_assign_pointer(pmc
->mca_tomb
, tomb
);
797 sources
= rcu_replace_pointer(im
->mca_sources
,
798 mc_dereference(pmc
->mca_sources
, pmc
->idev
),
799 lockdep_is_held(&im
->idev
->mc_lock
));
800 rcu_assign_pointer(pmc
->mca_sources
, sources
);
801 for_each_psf_mclock(im
, psf
)
802 psf
->sf_crcount
= idev
->mc_qrv
;
804 im
->mca_crcount
= idev
->mc_qrv
;
806 in6_dev_put(pmc
->idev
);
807 ip6_mc_clear_src(pmc
);
812 /* called with mc_lock */
813 static void mld_clear_delrec(struct inet6_dev
*idev
)
815 struct ifmcaddr6
*pmc
, *nextpmc
;
817 pmc
= mc_dereference(idev
->mc_tomb
, idev
);
818 RCU_INIT_POINTER(idev
->mc_tomb
, NULL
);
820 for (; pmc
; pmc
= nextpmc
) {
821 nextpmc
= mc_dereference(pmc
->next
, idev
);
822 ip6_mc_clear_src(pmc
);
823 in6_dev_put(pmc
->idev
);
827 /* clear dead sources, too */
828 for_each_mc_mclock(idev
, pmc
) {
829 struct ip6_sf_list
*psf
, *psf_next
;
831 psf
= mc_dereference(pmc
->mca_tomb
, idev
);
832 RCU_INIT_POINTER(pmc
->mca_tomb
, NULL
);
833 for (; psf
; psf
= psf_next
) {
834 psf_next
= mc_dereference(psf
->sf_next
, idev
);
840 static void mld_clear_query(struct inet6_dev
*idev
)
844 spin_lock_bh(&idev
->mc_query_lock
);
845 while ((skb
= __skb_dequeue(&idev
->mc_query_queue
)))
847 spin_unlock_bh(&idev
->mc_query_lock
);
850 static void mld_clear_report(struct inet6_dev
*idev
)
854 spin_lock_bh(&idev
->mc_report_lock
);
855 while ((skb
= __skb_dequeue(&idev
->mc_report_queue
)))
857 spin_unlock_bh(&idev
->mc_report_lock
);
860 static void mca_get(struct ifmcaddr6
*mc
)
862 refcount_inc(&mc
->mca_refcnt
);
865 static void ma_put(struct ifmcaddr6
*mc
)
867 if (refcount_dec_and_test(&mc
->mca_refcnt
)) {
868 in6_dev_put(mc
->idev
);
873 /* called with mc_lock */
874 static struct ifmcaddr6
*mca_alloc(struct inet6_dev
*idev
,
875 const struct in6_addr
*addr
,
878 struct ifmcaddr6
*mc
;
880 mc
= kzalloc(sizeof(*mc
), GFP_KERNEL
);
884 INIT_DELAYED_WORK(&mc
->mca_work
, mld_mca_work
);
886 mc
->mca_addr
= *addr
;
887 mc
->idev
= idev
; /* reference taken by caller */
889 /* mca_stamp should be updated upon changes */
890 mc
->mca_cstamp
= mc
->mca_tstamp
= jiffies
;
891 refcount_set(&mc
->mca_refcnt
, 1);
893 mc
->mca_sfmode
= mode
;
894 mc
->mca_sfcount
[mode
] = 1;
896 if (ipv6_addr_is_ll_all_nodes(&mc
->mca_addr
) ||
897 IPV6_ADDR_MC_SCOPE(&mc
->mca_addr
) < IPV6_ADDR_SCOPE_LINKLOCAL
)
898 mc
->mca_flags
|= MAF_NOREPORT
;
904 * device multicast group inc (add if not found)
906 static int __ipv6_dev_mc_inc(struct net_device
*dev
,
907 const struct in6_addr
*addr
, unsigned int mode
)
909 struct ifmcaddr6
*mc
;
910 struct inet6_dev
*idev
;
914 /* we need to take a reference on idev */
915 idev
= in6_dev_get(dev
);
925 mutex_lock(&idev
->mc_lock
);
926 for_each_mc_mclock(idev
, mc
) {
927 if (ipv6_addr_equal(&mc
->mca_addr
, addr
)) {
929 ip6_mc_add_src(idev
, &mc
->mca_addr
, mode
, 0, NULL
, 0);
930 mutex_unlock(&idev
->mc_lock
);
936 mc
= mca_alloc(idev
, addr
, mode
);
938 mutex_unlock(&idev
->mc_lock
);
943 rcu_assign_pointer(mc
->next
, idev
->mc_list
);
944 rcu_assign_pointer(idev
->mc_list
, mc
);
948 mld_del_delrec(idev
, mc
);
949 igmp6_group_added(mc
);
950 mutex_unlock(&idev
->mc_lock
);
955 int ipv6_dev_mc_inc(struct net_device
*dev
, const struct in6_addr
*addr
)
957 return __ipv6_dev_mc_inc(dev
, addr
, MCAST_EXCLUDE
);
959 EXPORT_SYMBOL(ipv6_dev_mc_inc
);
962 * device multicast group del
964 int __ipv6_dev_mc_dec(struct inet6_dev
*idev
, const struct in6_addr
*addr
)
966 struct ifmcaddr6
*ma
, __rcu
**map
;
970 mutex_lock(&idev
->mc_lock
);
971 for (map
= &idev
->mc_list
;
972 (ma
= mc_dereference(*map
, idev
));
974 if (ipv6_addr_equal(&ma
->mca_addr
, addr
)) {
975 if (--ma
->mca_users
== 0) {
978 igmp6_group_dropped(ma
);
979 ip6_mc_clear_src(ma
);
980 mutex_unlock(&idev
->mc_lock
);
985 mutex_unlock(&idev
->mc_lock
);
990 mutex_unlock(&idev
->mc_lock
);
994 int ipv6_dev_mc_dec(struct net_device
*dev
, const struct in6_addr
*addr
)
996 struct inet6_dev
*idev
;
1001 idev
= __in6_dev_get(dev
);
1005 err
= __ipv6_dev_mc_dec(idev
, addr
);
1009 EXPORT_SYMBOL(ipv6_dev_mc_dec
);
1012 * check if the interface/address pair is valid
1014 bool ipv6_chk_mcast_addr(struct net_device
*dev
, const struct in6_addr
*group
,
1015 const struct in6_addr
*src_addr
)
1017 struct inet6_dev
*idev
;
1018 struct ifmcaddr6
*mc
;
1022 idev
= __in6_dev_get(dev
);
1024 for_each_mc_rcu(idev
, mc
) {
1025 if (ipv6_addr_equal(&mc
->mca_addr
, group
))
1029 if (src_addr
&& !ipv6_addr_any(src_addr
)) {
1030 struct ip6_sf_list
*psf
;
1032 for_each_psf_rcu(mc
, psf
) {
1033 if (ipv6_addr_equal(&psf
->sf_addr
, src_addr
))
1037 rv
= psf
->sf_count
[MCAST_INCLUDE
] ||
1038 psf
->sf_count
[MCAST_EXCLUDE
] !=
1039 mc
->mca_sfcount
[MCAST_EXCLUDE
];
1041 rv
= mc
->mca_sfcount
[MCAST_EXCLUDE
] != 0;
1043 rv
= true; /* don't filter unspecified source */
1050 /* called with mc_lock */
1051 static void mld_gq_start_work(struct inet6_dev
*idev
)
1053 unsigned long tv
= prandom_u32() % idev
->mc_maxdelay
;
1055 idev
->mc_gq_running
= 1;
1056 if (!mod_delayed_work(mld_wq
, &idev
->mc_gq_work
, tv
+ 2))
1060 /* called with mc_lock */
1061 static void mld_gq_stop_work(struct inet6_dev
*idev
)
1063 idev
->mc_gq_running
= 0;
1064 if (cancel_delayed_work(&idev
->mc_gq_work
))
1065 __in6_dev_put(idev
);
1068 /* called with mc_lock */
1069 static void mld_ifc_start_work(struct inet6_dev
*idev
, unsigned long delay
)
1071 unsigned long tv
= prandom_u32() % delay
;
1073 if (!mod_delayed_work(mld_wq
, &idev
->mc_ifc_work
, tv
+ 2))
1077 /* called with mc_lock */
1078 static void mld_ifc_stop_work(struct inet6_dev
*idev
)
1080 idev
->mc_ifc_count
= 0;
1081 if (cancel_delayed_work(&idev
->mc_ifc_work
))
1082 __in6_dev_put(idev
);
1085 /* called with mc_lock */
1086 static void mld_dad_start_work(struct inet6_dev
*idev
, unsigned long delay
)
1088 unsigned long tv
= prandom_u32() % delay
;
1090 if (!mod_delayed_work(mld_wq
, &idev
->mc_dad_work
, tv
+ 2))
1094 static void mld_dad_stop_work(struct inet6_dev
*idev
)
1096 if (cancel_delayed_work(&idev
->mc_dad_work
))
1097 __in6_dev_put(idev
);
1100 static void mld_query_stop_work(struct inet6_dev
*idev
)
1102 spin_lock_bh(&idev
->mc_query_lock
);
1103 if (cancel_delayed_work(&idev
->mc_query_work
))
1104 __in6_dev_put(idev
);
1105 spin_unlock_bh(&idev
->mc_query_lock
);
1108 static void mld_report_stop_work(struct inet6_dev
*idev
)
1110 if (cancel_delayed_work_sync(&idev
->mc_report_work
))
1111 __in6_dev_put(idev
);
1115 * IGMP handling (alias multicast ICMPv6 messages)
1116 * called with mc_lock
1118 static void igmp6_group_queried(struct ifmcaddr6
*ma
, unsigned long resptime
)
1120 unsigned long delay
= resptime
;
1122 /* Do not start work for these addresses */
1123 if (ipv6_addr_is_ll_all_nodes(&ma
->mca_addr
) ||
1124 IPV6_ADDR_MC_SCOPE(&ma
->mca_addr
) < IPV6_ADDR_SCOPE_LINKLOCAL
)
1127 if (cancel_delayed_work(&ma
->mca_work
)) {
1128 refcount_dec(&ma
->mca_refcnt
);
1129 delay
= ma
->mca_work
.timer
.expires
- jiffies
;
1132 if (delay
>= resptime
)
1133 delay
= prandom_u32() % resptime
;
1135 if (!mod_delayed_work(mld_wq
, &ma
->mca_work
, delay
))
1136 refcount_inc(&ma
->mca_refcnt
);
1137 ma
->mca_flags
|= MAF_TIMER_RUNNING
;
1140 /* mark EXCLUDE-mode sources
1141 * called with mc_lock
1143 static bool mld_xmarksources(struct ifmcaddr6
*pmc
, int nsrcs
,
1144 const struct in6_addr
*srcs
)
1146 struct ip6_sf_list
*psf
;
1150 for_each_psf_mclock(pmc
, psf
) {
1151 if (scount
== nsrcs
)
1153 for (i
= 0; i
< nsrcs
; i
++) {
1154 /* skip inactive filters */
1155 if (psf
->sf_count
[MCAST_INCLUDE
] ||
1156 pmc
->mca_sfcount
[MCAST_EXCLUDE
] !=
1157 psf
->sf_count
[MCAST_EXCLUDE
])
1159 if (ipv6_addr_equal(&srcs
[i
], &psf
->sf_addr
)) {
1165 pmc
->mca_flags
&= ~MAF_GSQUERY
;
1166 if (scount
== nsrcs
) /* all sources excluded */
1171 /* called with mc_lock */
1172 static bool mld_marksources(struct ifmcaddr6
*pmc
, int nsrcs
,
1173 const struct in6_addr
*srcs
)
1175 struct ip6_sf_list
*psf
;
1178 if (pmc
->mca_sfmode
== MCAST_EXCLUDE
)
1179 return mld_xmarksources(pmc
, nsrcs
, srcs
);
1181 /* mark INCLUDE-mode sources */
1184 for_each_psf_mclock(pmc
, psf
) {
1185 if (scount
== nsrcs
)
1187 for (i
= 0; i
< nsrcs
; i
++) {
1188 if (ipv6_addr_equal(&srcs
[i
], &psf
->sf_addr
)) {
1196 pmc
->mca_flags
&= ~MAF_GSQUERY
;
1199 pmc
->mca_flags
|= MAF_GSQUERY
;
1203 static int mld_force_mld_version(const struct inet6_dev
*idev
)
1205 /* Normally, both are 0 here. If enforcement to a particular is
1206 * being used, individual device enforcement will have a lower
1207 * precedence over 'all' device (.../conf/all/force_mld_version).
1210 if (dev_net(idev
->dev
)->ipv6
.devconf_all
->force_mld_version
!= 0)
1211 return dev_net(idev
->dev
)->ipv6
.devconf_all
->force_mld_version
;
1213 return idev
->cnf
.force_mld_version
;
1216 static bool mld_in_v2_mode_only(const struct inet6_dev
*idev
)
1218 return mld_force_mld_version(idev
) == 2;
1221 static bool mld_in_v1_mode_only(const struct inet6_dev
*idev
)
1223 return mld_force_mld_version(idev
) == 1;
1226 static bool mld_in_v1_mode(const struct inet6_dev
*idev
)
1228 if (mld_in_v2_mode_only(idev
))
1230 if (mld_in_v1_mode_only(idev
))
1232 if (idev
->mc_v1_seen
&& time_before(jiffies
, idev
->mc_v1_seen
))
1238 static void mld_set_v1_mode(struct inet6_dev
*idev
)
1240 /* RFC3810, relevant sections:
1241 * - 9.1. Robustness Variable
1242 * - 9.2. Query Interval
1243 * - 9.3. Query Response Interval
1244 * - 9.12. Older Version Querier Present Timeout
1246 unsigned long switchback
;
1248 switchback
= (idev
->mc_qrv
* idev
->mc_qi
) + idev
->mc_qri
;
1250 idev
->mc_v1_seen
= jiffies
+ switchback
;
1253 static void mld_update_qrv(struct inet6_dev
*idev
,
1254 const struct mld2_query
*mlh2
)
1256 /* RFC3810, relevant sections:
1257 * - 5.1.8. QRV (Querier's Robustness Variable)
1258 * - 9.1. Robustness Variable
1261 /* The value of the Robustness Variable MUST NOT be zero,
1262 * and SHOULD NOT be one. Catch this here if we ever run
1263 * into such a case in future.
1265 const int min_qrv
= min(MLD_QRV_DEFAULT
, sysctl_mld_qrv
);
1266 WARN_ON(idev
->mc_qrv
== 0);
1268 if (mlh2
->mld2q_qrv
> 0)
1269 idev
->mc_qrv
= mlh2
->mld2q_qrv
;
1271 if (unlikely(idev
->mc_qrv
< min_qrv
)) {
1272 net_warn_ratelimited("IPv6: MLD: clamping QRV from %u to %u!\n",
1273 idev
->mc_qrv
, min_qrv
);
1274 idev
->mc_qrv
= min_qrv
;
1278 static void mld_update_qi(struct inet6_dev
*idev
,
1279 const struct mld2_query
*mlh2
)
1281 /* RFC3810, relevant sections:
1282 * - 5.1.9. QQIC (Querier's Query Interval Code)
1283 * - 9.2. Query Interval
1284 * - 9.12. Older Version Querier Present Timeout
1285 * (the [Query Interval] in the last Query received)
1287 unsigned long mc_qqi
;
1289 if (mlh2
->mld2q_qqic
< 128) {
1290 mc_qqi
= mlh2
->mld2q_qqic
;
1292 unsigned long mc_man
, mc_exp
;
1294 mc_exp
= MLDV2_QQIC_EXP(mlh2
->mld2q_qqic
);
1295 mc_man
= MLDV2_QQIC_MAN(mlh2
->mld2q_qqic
);
1297 mc_qqi
= (mc_man
| 0x10) << (mc_exp
+ 3);
1300 idev
->mc_qi
= mc_qqi
* HZ
;
1303 static void mld_update_qri(struct inet6_dev
*idev
,
1304 const struct mld2_query
*mlh2
)
1306 /* RFC3810, relevant sections:
1307 * - 5.1.3. Maximum Response Code
1308 * - 9.3. Query Response Interval
1310 idev
->mc_qri
= msecs_to_jiffies(mldv2_mrc(mlh2
));
1313 static int mld_process_v1(struct inet6_dev
*idev
, struct mld_msg
*mld
,
1314 unsigned long *max_delay
, bool v1_query
)
1316 unsigned long mldv1_md
;
1318 /* Ignore v1 queries */
1319 if (mld_in_v2_mode_only(idev
))
1322 mldv1_md
= ntohs(mld
->mld_maxdelay
);
1324 /* When in MLDv1 fallback and a MLDv2 router start-up being
1325 * unaware of current MLDv1 operation, the MRC == MRD mapping
1326 * only works when the exponential algorithm is not being
1327 * used (as MLDv1 is unaware of such things).
1329 * According to the RFC author, the MLDv2 implementations
1330 * he's aware of all use a MRC < 32768 on start up queries.
1332 * Thus, should we *ever* encounter something else larger
1333 * than that, just assume the maximum possible within our
1337 mldv1_md
= min(mldv1_md
, MLDV1_MRD_MAX_COMPAT
);
1339 *max_delay
= max(msecs_to_jiffies(mldv1_md
), 1UL);
1341 /* MLDv1 router present: we need to go into v1 mode *only*
1342 * when an MLDv1 query is received as per section 9.12. of
1343 * RFC3810! And we know from RFC2710 section 3.7 that MLDv1
1344 * queries MUST be of exactly 24 octets.
1347 mld_set_v1_mode(idev
);
1349 /* cancel MLDv2 report work */
1350 mld_gq_stop_work(idev
);
1351 /* cancel the interface change work */
1352 mld_ifc_stop_work(idev
);
1353 /* clear deleted report items */
1354 mld_clear_delrec(idev
);
1359 static void mld_process_v2(struct inet6_dev
*idev
, struct mld2_query
*mld
,
1360 unsigned long *max_delay
)
1362 *max_delay
= max(msecs_to_jiffies(mldv2_mrc(mld
)), 1UL);
1364 mld_update_qrv(idev
, mld
);
1365 mld_update_qi(idev
, mld
);
1366 mld_update_qri(idev
, mld
);
1368 idev
->mc_maxdelay
= *max_delay
;
1373 /* called with rcu_read_lock() */
1374 void igmp6_event_query(struct sk_buff
*skb
)
1376 struct inet6_dev
*idev
= __in6_dev_get(skb
->dev
);
1378 if (!idev
|| idev
->dead
)
1381 spin_lock_bh(&idev
->mc_query_lock
);
1382 if (skb_queue_len(&idev
->mc_query_queue
) < MLD_MAX_SKBS
) {
1383 __skb_queue_tail(&idev
->mc_query_queue
, skb
);
1384 if (!mod_delayed_work(mld_wq
, &idev
->mc_query_work
, 0))
1388 spin_unlock_bh(&idev
->mc_query_lock
);
1393 static void __mld_query_work(struct sk_buff
*skb
)
1395 struct mld2_query
*mlh2
= NULL
;
1396 const struct in6_addr
*group
;
1397 unsigned long max_delay
;
1398 struct inet6_dev
*idev
;
1399 struct ifmcaddr6
*ma
;
1400 struct mld_msg
*mld
;
1405 if (!pskb_may_pull(skb
, sizeof(struct in6_addr
)))
1408 /* compute payload length excluding extension headers */
1409 len
= ntohs(ipv6_hdr(skb
)->payload_len
) + sizeof(struct ipv6hdr
);
1410 len
-= skb_network_header_len(skb
);
1413 * Upon reception of an MLD message that contains a Query, the node
1414 * checks if the source address of the message is a valid link-local
1415 * address, if the Hop Limit is set to 1, and if the Router Alert
1416 * option is present in the Hop-By-Hop Options header of the IPv6
1417 * packet. If any of these checks fails, the packet is dropped.
1419 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
) ||
1420 ipv6_hdr(skb
)->hop_limit
!= 1 ||
1421 !(IP6CB(skb
)->flags
& IP6SKB_ROUTERALERT
) ||
1422 IP6CB(skb
)->ra
!= htons(IPV6_OPT_ROUTERALERT_MLD
))
1425 idev
= in6_dev_get(skb
->dev
);
1429 mld
= (struct mld_msg
*)icmp6_hdr(skb
);
1430 group
= &mld
->mld_mca
;
1431 group_type
= ipv6_addr_type(group
);
1433 if (group_type
!= IPV6_ADDR_ANY
&&
1434 !(group_type
&IPV6_ADDR_MULTICAST
))
1437 if (len
< MLD_V1_QUERY_LEN
) {
1439 } else if (len
== MLD_V1_QUERY_LEN
|| mld_in_v1_mode(idev
)) {
1440 err
= mld_process_v1(idev
, mld
, &max_delay
,
1441 len
== MLD_V1_QUERY_LEN
);
1444 } else if (len
>= MLD_V2_QUERY_LEN_MIN
) {
1445 int srcs_offset
= sizeof(struct mld2_query
) -
1446 sizeof(struct icmp6hdr
);
1448 if (!pskb_may_pull(skb
, srcs_offset
))
1451 mlh2
= (struct mld2_query
*)skb_transport_header(skb
);
1453 mld_process_v2(idev
, mlh2
, &max_delay
);
1455 if (group_type
== IPV6_ADDR_ANY
) { /* general query */
1456 if (mlh2
->mld2q_nsrcs
)
1457 goto out
; /* no sources allowed */
1459 mld_gq_start_work(idev
);
1462 /* mark sources to include, if group & source-specific */
1463 if (mlh2
->mld2q_nsrcs
!= 0) {
1464 if (!pskb_may_pull(skb
, srcs_offset
+
1465 ntohs(mlh2
->mld2q_nsrcs
) * sizeof(struct in6_addr
)))
1468 mlh2
= (struct mld2_query
*)skb_transport_header(skb
);
1475 if (group_type
== IPV6_ADDR_ANY
) {
1476 for_each_mc_mclock(idev
, ma
) {
1477 igmp6_group_queried(ma
, max_delay
);
1480 for_each_mc_mclock(idev
, ma
) {
1481 if (!ipv6_addr_equal(group
, &ma
->mca_addr
))
1483 if (ma
->mca_flags
& MAF_TIMER_RUNNING
) {
1484 /* gsquery <- gsquery && mark */
1486 ma
->mca_flags
&= ~MAF_GSQUERY
;
1488 /* gsquery <- mark */
1490 ma
->mca_flags
|= MAF_GSQUERY
;
1492 ma
->mca_flags
&= ~MAF_GSQUERY
;
1494 if (!(ma
->mca_flags
& MAF_GSQUERY
) ||
1495 mld_marksources(ma
, ntohs(mlh2
->mld2q_nsrcs
), mlh2
->mld2q_srcs
))
1496 igmp6_group_queried(ma
, max_delay
);
1507 static void mld_query_work(struct work_struct
*work
)
1509 struct inet6_dev
*idev
= container_of(to_delayed_work(work
),
1512 struct sk_buff_head q
;
1513 struct sk_buff
*skb
;
1514 bool rework
= false;
1517 skb_queue_head_init(&q
);
1519 spin_lock_bh(&idev
->mc_query_lock
);
1520 while ((skb
= __skb_dequeue(&idev
->mc_query_queue
))) {
1521 __skb_queue_tail(&q
, skb
);
1523 if (++cnt
>= MLD_MAX_QUEUE
) {
1525 schedule_delayed_work(&idev
->mc_query_work
, 0);
1529 spin_unlock_bh(&idev
->mc_query_lock
);
1531 mutex_lock(&idev
->mc_lock
);
1532 while ((skb
= __skb_dequeue(&q
)))
1533 __mld_query_work(skb
);
1534 mutex_unlock(&idev
->mc_lock
);
1540 /* called with rcu_read_lock() */
1541 void igmp6_event_report(struct sk_buff
*skb
)
1543 struct inet6_dev
*idev
= __in6_dev_get(skb
->dev
);
1545 if (!idev
|| idev
->dead
)
1548 spin_lock_bh(&idev
->mc_report_lock
);
1549 if (skb_queue_len(&idev
->mc_report_queue
) < MLD_MAX_SKBS
) {
1550 __skb_queue_tail(&idev
->mc_report_queue
, skb
);
1551 if (!mod_delayed_work(mld_wq
, &idev
->mc_report_work
, 0))
1555 spin_unlock_bh(&idev
->mc_report_lock
);
1560 static void __mld_report_work(struct sk_buff
*skb
)
1562 struct inet6_dev
*idev
;
1563 struct ifmcaddr6
*ma
;
1564 struct mld_msg
*mld
;
1567 /* Our own report looped back. Ignore it. */
1568 if (skb
->pkt_type
== PACKET_LOOPBACK
)
1571 /* send our report if the MC router may not have heard this report */
1572 if (skb
->pkt_type
!= PACKET_MULTICAST
&&
1573 skb
->pkt_type
!= PACKET_BROADCAST
)
1576 if (!pskb_may_pull(skb
, sizeof(*mld
) - sizeof(struct icmp6hdr
)))
1579 mld
= (struct mld_msg
*)icmp6_hdr(skb
);
1581 /* Drop reports with not link local source */
1582 addr_type
= ipv6_addr_type(&ipv6_hdr(skb
)->saddr
);
1583 if (addr_type
!= IPV6_ADDR_ANY
&&
1584 !(addr_type
&IPV6_ADDR_LINKLOCAL
))
1587 idev
= in6_dev_get(skb
->dev
);
1592 * Cancel the work for this group
1595 for_each_mc_mclock(idev
, ma
) {
1596 if (ipv6_addr_equal(&ma
->mca_addr
, &mld
->mld_mca
)) {
1597 if (cancel_delayed_work(&ma
->mca_work
))
1598 refcount_dec(&ma
->mca_refcnt
);
1599 ma
->mca_flags
&= ~(MAF_LAST_REPORTER
|
1610 static void mld_report_work(struct work_struct
*work
)
1612 struct inet6_dev
*idev
= container_of(to_delayed_work(work
),
1615 struct sk_buff_head q
;
1616 struct sk_buff
*skb
;
1617 bool rework
= false;
1620 skb_queue_head_init(&q
);
1621 spin_lock_bh(&idev
->mc_report_lock
);
1622 while ((skb
= __skb_dequeue(&idev
->mc_report_queue
))) {
1623 __skb_queue_tail(&q
, skb
);
1625 if (++cnt
>= MLD_MAX_QUEUE
) {
1627 schedule_delayed_work(&idev
->mc_report_work
, 0);
1631 spin_unlock_bh(&idev
->mc_report_lock
);
1633 mutex_lock(&idev
->mc_lock
);
1634 while ((skb
= __skb_dequeue(&q
)))
1635 __mld_report_work(skb
);
1636 mutex_unlock(&idev
->mc_lock
);
1642 static bool is_in(struct ifmcaddr6
*pmc
, struct ip6_sf_list
*psf
, int type
,
1643 int gdeleted
, int sdeleted
)
1646 case MLD2_MODE_IS_INCLUDE
:
1647 case MLD2_MODE_IS_EXCLUDE
:
1648 if (gdeleted
|| sdeleted
)
1650 if (!((pmc
->mca_flags
& MAF_GSQUERY
) && !psf
->sf_gsresp
)) {
1651 if (pmc
->mca_sfmode
== MCAST_INCLUDE
)
1653 /* don't include if this source is excluded
1656 if (psf
->sf_count
[MCAST_INCLUDE
])
1657 return type
== MLD2_MODE_IS_INCLUDE
;
1658 return pmc
->mca_sfcount
[MCAST_EXCLUDE
] ==
1659 psf
->sf_count
[MCAST_EXCLUDE
];
1662 case MLD2_CHANGE_TO_INCLUDE
:
1663 if (gdeleted
|| sdeleted
)
1665 return psf
->sf_count
[MCAST_INCLUDE
] != 0;
1666 case MLD2_CHANGE_TO_EXCLUDE
:
1667 if (gdeleted
|| sdeleted
)
1669 if (pmc
->mca_sfcount
[MCAST_EXCLUDE
] == 0 ||
1670 psf
->sf_count
[MCAST_INCLUDE
])
1672 return pmc
->mca_sfcount
[MCAST_EXCLUDE
] ==
1673 psf
->sf_count
[MCAST_EXCLUDE
];
1674 case MLD2_ALLOW_NEW_SOURCES
:
1675 if (gdeleted
|| !psf
->sf_crcount
)
1677 return (pmc
->mca_sfmode
== MCAST_INCLUDE
) ^ sdeleted
;
1678 case MLD2_BLOCK_OLD_SOURCES
:
1679 if (pmc
->mca_sfmode
== MCAST_INCLUDE
)
1680 return gdeleted
|| (psf
->sf_crcount
&& sdeleted
);
1681 return psf
->sf_crcount
&& !gdeleted
&& !sdeleted
;
1687 mld_scount(struct ifmcaddr6
*pmc
, int type
, int gdeleted
, int sdeleted
)
1689 struct ip6_sf_list
*psf
;
1692 for_each_psf_mclock(pmc
, psf
) {
1693 if (!is_in(pmc
, psf
, type
, gdeleted
, sdeleted
))
1700 static void ip6_mc_hdr(struct sock
*sk
, struct sk_buff
*skb
,
1701 struct net_device
*dev
,
1702 const struct in6_addr
*saddr
,
1703 const struct in6_addr
*daddr
,
1706 struct ipv6hdr
*hdr
;
1708 skb
->protocol
= htons(ETH_P_IPV6
);
1711 skb_reset_network_header(skb
);
1712 skb_put(skb
, sizeof(struct ipv6hdr
));
1713 hdr
= ipv6_hdr(skb
);
1715 ip6_flow_hdr(hdr
, 0, 0);
1717 hdr
->payload_len
= htons(len
);
1718 hdr
->nexthdr
= proto
;
1719 hdr
->hop_limit
= inet6_sk(sk
)->hop_limit
;
1721 hdr
->saddr
= *saddr
;
1722 hdr
->daddr
= *daddr
;
1725 static struct sk_buff
*mld_newpack(struct inet6_dev
*idev
, unsigned int mtu
)
1727 u8 ra
[8] = { IPPROTO_ICMPV6
, 0, IPV6_TLV_ROUTERALERT
,
1728 2, 0, 0, IPV6_TLV_PADN
, 0 };
1729 struct net_device
*dev
= idev
->dev
;
1730 int hlen
= LL_RESERVED_SPACE(dev
);
1731 int tlen
= dev
->needed_tailroom
;
1732 struct net
*net
= dev_net(dev
);
1733 const struct in6_addr
*saddr
;
1734 struct in6_addr addr_buf
;
1735 struct mld2_report
*pmr
;
1736 struct sk_buff
*skb
;
1741 sk
= net
->ipv6
.igmp_sk
;
1742 /* we assume size > sizeof(ra) here
1743 * Also try to not allocate high-order pages for big MTU
1745 size
= min_t(int, mtu
, PAGE_SIZE
/ 2) + hlen
+ tlen
;
1746 skb
= sock_alloc_send_skb(sk
, size
, 1, &err
);
1750 skb
->priority
= TC_PRIO_CONTROL
;
1751 skb_reserve(skb
, hlen
);
1752 skb_tailroom_reserve(skb
, mtu
, tlen
);
1754 if (ipv6_get_lladdr(dev
, &addr_buf
, IFA_F_TENTATIVE
)) {
1755 /* <draft-ietf-magma-mld-source-05.txt>:
1756 * use unspecified address as the source address
1757 * when a valid link-local address is not available.
1759 saddr
= &in6addr_any
;
1763 ip6_mc_hdr(sk
, skb
, dev
, saddr
, &mld2_all_mcr
, NEXTHDR_HOP
, 0);
1765 skb_put_data(skb
, ra
, sizeof(ra
));
1767 skb_set_transport_header(skb
, skb_tail_pointer(skb
) - skb
->data
);
1768 skb_put(skb
, sizeof(*pmr
));
1769 pmr
= (struct mld2_report
*)skb_transport_header(skb
);
1770 pmr
->mld2r_type
= ICMPV6_MLD2_REPORT
;
1771 pmr
->mld2r_resv1
= 0;
1772 pmr
->mld2r_cksum
= 0;
1773 pmr
->mld2r_resv2
= 0;
1774 pmr
->mld2r_ngrec
= 0;
1778 static void mld_sendpack(struct sk_buff
*skb
)
1780 struct ipv6hdr
*pip6
= ipv6_hdr(skb
);
1781 struct mld2_report
*pmr
=
1782 (struct mld2_report
*)skb_transport_header(skb
);
1783 int payload_len
, mldlen
;
1784 struct inet6_dev
*idev
;
1785 struct net
*net
= dev_net(skb
->dev
);
1788 struct dst_entry
*dst
;
1791 idev
= __in6_dev_get(skb
->dev
);
1792 IP6_UPD_PO_STATS(net
, idev
, IPSTATS_MIB_OUT
, skb
->len
);
1794 payload_len
= (skb_tail_pointer(skb
) - skb_network_header(skb
)) -
1796 mldlen
= skb_tail_pointer(skb
) - skb_transport_header(skb
);
1797 pip6
->payload_len
= htons(payload_len
);
1799 pmr
->mld2r_cksum
= csum_ipv6_magic(&pip6
->saddr
, &pip6
->daddr
, mldlen
,
1801 csum_partial(skb_transport_header(skb
),
1804 icmpv6_flow_init(net
->ipv6
.igmp_sk
, &fl6
, ICMPV6_MLD2_REPORT
,
1805 &ipv6_hdr(skb
)->saddr
, &ipv6_hdr(skb
)->daddr
,
1807 dst
= icmp6_dst_alloc(skb
->dev
, &fl6
);
1814 skb_dst_set(skb
, dst
);
1818 err
= NF_HOOK(NFPROTO_IPV6
, NF_INET_LOCAL_OUT
,
1819 net
, net
->ipv6
.igmp_sk
, skb
, NULL
, skb
->dev
,
1823 ICMP6MSGOUT_INC_STATS(net
, idev
, ICMPV6_MLD2_REPORT
);
1824 ICMP6_INC_STATS(net
, idev
, ICMP6_MIB_OUTMSGS
);
1826 IP6_INC_STATS(net
, idev
, IPSTATS_MIB_OUTDISCARDS
);
1837 static int grec_size(struct ifmcaddr6
*pmc
, int type
, int gdel
, int sdel
)
1839 return sizeof(struct mld2_grec
) + 16 * mld_scount(pmc
,type
,gdel
,sdel
);
1842 static struct sk_buff
*add_grhead(struct sk_buff
*skb
, struct ifmcaddr6
*pmc
,
1843 int type
, struct mld2_grec
**ppgr
, unsigned int mtu
)
1845 struct mld2_report
*pmr
;
1846 struct mld2_grec
*pgr
;
1849 skb
= mld_newpack(pmc
->idev
, mtu
);
1853 pgr
= skb_put(skb
, sizeof(struct mld2_grec
));
1854 pgr
->grec_type
= type
;
1855 pgr
->grec_auxwords
= 0;
1856 pgr
->grec_nsrcs
= 0;
1857 pgr
->grec_mca
= pmc
->mca_addr
; /* structure copy */
1858 pmr
= (struct mld2_report
*)skb_transport_header(skb
);
1859 pmr
->mld2r_ngrec
= htons(ntohs(pmr
->mld2r_ngrec
)+1);
1864 #define AVAILABLE(skb) ((skb) ? skb_availroom(skb) : 0)
1866 /* called with mc_lock */
1867 static struct sk_buff
*add_grec(struct sk_buff
*skb
, struct ifmcaddr6
*pmc
,
1868 int type
, int gdeleted
, int sdeleted
,
1871 struct ip6_sf_list
*psf
, *psf_prev
, *psf_next
;
1872 int scount
, stotal
, first
, isquery
, truncate
;
1873 struct ip6_sf_list __rcu
**psf_list
;
1874 struct inet6_dev
*idev
= pmc
->idev
;
1875 struct net_device
*dev
= idev
->dev
;
1876 struct mld2_grec
*pgr
= NULL
;
1877 struct mld2_report
*pmr
;
1880 if (pmc
->mca_flags
& MAF_NOREPORT
)
1883 mtu
= READ_ONCE(dev
->mtu
);
1884 if (mtu
< IPV6_MIN_MTU
)
1887 isquery
= type
== MLD2_MODE_IS_INCLUDE
||
1888 type
== MLD2_MODE_IS_EXCLUDE
;
1889 truncate
= type
== MLD2_MODE_IS_EXCLUDE
||
1890 type
== MLD2_CHANGE_TO_EXCLUDE
;
1892 stotal
= scount
= 0;
1894 psf_list
= sdeleted
? &pmc
->mca_tomb
: &pmc
->mca_sources
;
1896 if (!rcu_access_pointer(*psf_list
))
1899 pmr
= skb
? (struct mld2_report
*)skb_transport_header(skb
) : NULL
;
1901 /* EX and TO_EX get a fresh packet, if needed */
1903 if (pmr
&& pmr
->mld2r_ngrec
&&
1904 AVAILABLE(skb
) < grec_size(pmc
, type
, gdeleted
, sdeleted
)) {
1907 skb
= mld_newpack(idev
, mtu
);
1912 for (psf
= mc_dereference(*psf_list
, idev
);
1915 struct in6_addr
*psrc
;
1917 psf_next
= mc_dereference(psf
->sf_next
, idev
);
1919 if (!is_in(pmc
, psf
, type
, gdeleted
, sdeleted
) && !crsend
) {
1924 /* Based on RFC3810 6.1. Should not send source-list change
1925 * records when there is a filter mode change.
1927 if (((gdeleted
&& pmc
->mca_sfmode
== MCAST_EXCLUDE
) ||
1928 (!gdeleted
&& pmc
->mca_crcount
)) &&
1929 (type
== MLD2_ALLOW_NEW_SOURCES
||
1930 type
== MLD2_BLOCK_OLD_SOURCES
) && psf
->sf_crcount
)
1931 goto decrease_sf_crcount
;
1933 /* clear marks on query responses */
1937 if (AVAILABLE(skb
) < sizeof(*psrc
) +
1938 first
*sizeof(struct mld2_grec
)) {
1939 if (truncate
&& !first
)
1940 break; /* truncate these */
1942 pgr
->grec_nsrcs
= htons(scount
);
1945 skb
= mld_newpack(idev
, mtu
);
1950 skb
= add_grhead(skb
, pmc
, type
, &pgr
, mtu
);
1955 psrc
= skb_put(skb
, sizeof(*psrc
));
1956 *psrc
= psf
->sf_addr
;
1958 if ((type
== MLD2_ALLOW_NEW_SOURCES
||
1959 type
== MLD2_BLOCK_OLD_SOURCES
) && psf
->sf_crcount
) {
1960 decrease_sf_crcount
:
1962 if ((sdeleted
|| gdeleted
) && psf
->sf_crcount
== 0) {
1964 rcu_assign_pointer(psf_prev
->sf_next
,
1965 mc_dereference(psf
->sf_next
, idev
));
1967 rcu_assign_pointer(*psf_list
,
1968 mc_dereference(psf
->sf_next
, idev
));
1969 kfree_rcu(psf
, rcu
);
1978 if (type
== MLD2_ALLOW_NEW_SOURCES
||
1979 type
== MLD2_BLOCK_OLD_SOURCES
)
1981 if (pmc
->mca_crcount
|| isquery
|| crsend
) {
1982 /* make sure we have room for group header */
1983 if (skb
&& AVAILABLE(skb
) < sizeof(struct mld2_grec
)) {
1985 skb
= NULL
; /* add_grhead will get a new one */
1987 skb
= add_grhead(skb
, pmc
, type
, &pgr
, mtu
);
1991 pgr
->grec_nsrcs
= htons(scount
);
1994 pmc
->mca_flags
&= ~MAF_GSQUERY
; /* clear query state */
1998 /* called with mc_lock */
1999 static void mld_send_report(struct inet6_dev
*idev
, struct ifmcaddr6
*pmc
)
2001 struct sk_buff
*skb
= NULL
;
2005 for_each_mc_mclock(idev
, pmc
) {
2006 if (pmc
->mca_flags
& MAF_NOREPORT
)
2008 if (pmc
->mca_sfcount
[MCAST_EXCLUDE
])
2009 type
= MLD2_MODE_IS_EXCLUDE
;
2011 type
= MLD2_MODE_IS_INCLUDE
;
2012 skb
= add_grec(skb
, pmc
, type
, 0, 0, 0);
2015 if (pmc
->mca_sfcount
[MCAST_EXCLUDE
])
2016 type
= MLD2_MODE_IS_EXCLUDE
;
2018 type
= MLD2_MODE_IS_INCLUDE
;
2019 skb
= add_grec(skb
, pmc
, type
, 0, 0, 0);
2026 * remove zero-count source records from a source filter list
2027 * called with mc_lock
2029 static void mld_clear_zeros(struct ip6_sf_list __rcu
**ppsf
, struct inet6_dev
*idev
)
2031 struct ip6_sf_list
*psf_prev
, *psf_next
, *psf
;
2034 for (psf
= mc_dereference(*ppsf
, idev
);
2037 psf_next
= mc_dereference(psf
->sf_next
, idev
);
2038 if (psf
->sf_crcount
== 0) {
2040 rcu_assign_pointer(psf_prev
->sf_next
,
2041 mc_dereference(psf
->sf_next
, idev
));
2043 rcu_assign_pointer(*ppsf
,
2044 mc_dereference(psf
->sf_next
, idev
));
2045 kfree_rcu(psf
, rcu
);
2052 /* called with mc_lock */
2053 static void mld_send_cr(struct inet6_dev
*idev
)
2055 struct ifmcaddr6
*pmc
, *pmc_prev
, *pmc_next
;
2056 struct sk_buff
*skb
= NULL
;
2061 for (pmc
= mc_dereference(idev
->mc_tomb
, idev
);
2064 pmc_next
= mc_dereference(pmc
->next
, idev
);
2065 if (pmc
->mca_sfmode
== MCAST_INCLUDE
) {
2066 type
= MLD2_BLOCK_OLD_SOURCES
;
2067 dtype
= MLD2_BLOCK_OLD_SOURCES
;
2068 skb
= add_grec(skb
, pmc
, type
, 1, 0, 0);
2069 skb
= add_grec(skb
, pmc
, dtype
, 1, 1, 0);
2071 if (pmc
->mca_crcount
) {
2072 if (pmc
->mca_sfmode
== MCAST_EXCLUDE
) {
2073 type
= MLD2_CHANGE_TO_INCLUDE
;
2074 skb
= add_grec(skb
, pmc
, type
, 1, 0, 0);
2077 if (pmc
->mca_crcount
== 0) {
2078 mld_clear_zeros(&pmc
->mca_tomb
, idev
);
2079 mld_clear_zeros(&pmc
->mca_sources
, idev
);
2082 if (pmc
->mca_crcount
== 0 &&
2083 !rcu_access_pointer(pmc
->mca_tomb
) &&
2084 !rcu_access_pointer(pmc
->mca_sources
)) {
2086 rcu_assign_pointer(pmc_prev
->next
, pmc_next
);
2088 rcu_assign_pointer(idev
->mc_tomb
, pmc_next
);
2089 in6_dev_put(pmc
->idev
);
2090 kfree_rcu(pmc
, rcu
);
2096 for_each_mc_mclock(idev
, pmc
) {
2097 if (pmc
->mca_sfcount
[MCAST_EXCLUDE
]) {
2098 type
= MLD2_BLOCK_OLD_SOURCES
;
2099 dtype
= MLD2_ALLOW_NEW_SOURCES
;
2101 type
= MLD2_ALLOW_NEW_SOURCES
;
2102 dtype
= MLD2_BLOCK_OLD_SOURCES
;
2104 skb
= add_grec(skb
, pmc
, type
, 0, 0, 0);
2105 skb
= add_grec(skb
, pmc
, dtype
, 0, 1, 0); /* deleted sources */
2107 /* filter mode changes */
2108 if (pmc
->mca_crcount
) {
2109 if (pmc
->mca_sfmode
== MCAST_EXCLUDE
)
2110 type
= MLD2_CHANGE_TO_EXCLUDE
;
2112 type
= MLD2_CHANGE_TO_INCLUDE
;
2113 skb
= add_grec(skb
, pmc
, type
, 0, 0, 0);
2119 (void) mld_sendpack(skb
);
2122 static void igmp6_send(struct in6_addr
*addr
, struct net_device
*dev
, int type
)
2124 struct net
*net
= dev_net(dev
);
2125 struct sock
*sk
= net
->ipv6
.igmp_sk
;
2126 struct inet6_dev
*idev
;
2127 struct sk_buff
*skb
;
2128 struct mld_msg
*hdr
;
2129 const struct in6_addr
*snd_addr
, *saddr
;
2130 struct in6_addr addr_buf
;
2131 int hlen
= LL_RESERVED_SPACE(dev
);
2132 int tlen
= dev
->needed_tailroom
;
2133 int err
, len
, payload_len
, full_len
;
2134 u8 ra
[8] = { IPPROTO_ICMPV6
, 0,
2135 IPV6_TLV_ROUTERALERT
, 2, 0, 0,
2138 struct dst_entry
*dst
;
2140 if (type
== ICMPV6_MGM_REDUCTION
)
2141 snd_addr
= &in6addr_linklocal_allrouters
;
2145 len
= sizeof(struct icmp6hdr
) + sizeof(struct in6_addr
);
2146 payload_len
= len
+ sizeof(ra
);
2147 full_len
= sizeof(struct ipv6hdr
) + payload_len
;
2150 IP6_UPD_PO_STATS(net
, __in6_dev_get(dev
),
2151 IPSTATS_MIB_OUT
, full_len
);
2154 skb
= sock_alloc_send_skb(sk
, hlen
+ tlen
+ full_len
, 1, &err
);
2158 IP6_INC_STATS(net
, __in6_dev_get(dev
),
2159 IPSTATS_MIB_OUTDISCARDS
);
2163 skb
->priority
= TC_PRIO_CONTROL
;
2164 skb_reserve(skb
, hlen
);
2166 if (ipv6_get_lladdr(dev
, &addr_buf
, IFA_F_TENTATIVE
)) {
2167 /* <draft-ietf-magma-mld-source-05.txt>:
2168 * use unspecified address as the source address
2169 * when a valid link-local address is not available.
2171 saddr
= &in6addr_any
;
2175 ip6_mc_hdr(sk
, skb
, dev
, saddr
, snd_addr
, NEXTHDR_HOP
, payload_len
);
2177 skb_put_data(skb
, ra
, sizeof(ra
));
2179 hdr
= skb_put_zero(skb
, sizeof(struct mld_msg
));
2180 hdr
->mld_type
= type
;
2181 hdr
->mld_mca
= *addr
;
2183 hdr
->mld_cksum
= csum_ipv6_magic(saddr
, snd_addr
, len
,
2185 csum_partial(hdr
, len
, 0));
2188 idev
= __in6_dev_get(skb
->dev
);
2190 icmpv6_flow_init(sk
, &fl6
, type
,
2191 &ipv6_hdr(skb
)->saddr
, &ipv6_hdr(skb
)->daddr
,
2193 dst
= icmp6_dst_alloc(skb
->dev
, &fl6
);
2199 skb_dst_set(skb
, dst
);
2200 err
= NF_HOOK(NFPROTO_IPV6
, NF_INET_LOCAL_OUT
,
2201 net
, sk
, skb
, NULL
, skb
->dev
,
2205 ICMP6MSGOUT_INC_STATS(net
, idev
, type
);
2206 ICMP6_INC_STATS(net
, idev
, ICMP6_MIB_OUTMSGS
);
2208 IP6_INC_STATS(net
, idev
, IPSTATS_MIB_OUTDISCARDS
);
2218 /* called with mc_lock */
2219 static void mld_send_initial_cr(struct inet6_dev
*idev
)
2221 struct sk_buff
*skb
;
2222 struct ifmcaddr6
*pmc
;
2225 if (mld_in_v1_mode(idev
))
2229 for_each_mc_mclock(idev
, pmc
) {
2230 if (pmc
->mca_sfcount
[MCAST_EXCLUDE
])
2231 type
= MLD2_CHANGE_TO_EXCLUDE
;
2233 type
= MLD2_ALLOW_NEW_SOURCES
;
2234 skb
= add_grec(skb
, pmc
, type
, 0, 0, 1);
2240 void ipv6_mc_dad_complete(struct inet6_dev
*idev
)
2242 mutex_lock(&idev
->mc_lock
);
2243 idev
->mc_dad_count
= idev
->mc_qrv
;
2244 if (idev
->mc_dad_count
) {
2245 mld_send_initial_cr(idev
);
2246 idev
->mc_dad_count
--;
2247 if (idev
->mc_dad_count
)
2248 mld_dad_start_work(idev
,
2249 unsolicited_report_interval(idev
));
2251 mutex_unlock(&idev
->mc_lock
);
2254 static void mld_dad_work(struct work_struct
*work
)
2256 struct inet6_dev
*idev
= container_of(to_delayed_work(work
),
2259 mutex_lock(&idev
->mc_lock
);
2260 mld_send_initial_cr(idev
);
2261 if (idev
->mc_dad_count
) {
2262 idev
->mc_dad_count
--;
2263 if (idev
->mc_dad_count
)
2264 mld_dad_start_work(idev
,
2265 unsolicited_report_interval(idev
));
2267 mutex_unlock(&idev
->mc_lock
);
2271 /* called with mc_lock */
2272 static int ip6_mc_del1_src(struct ifmcaddr6
*pmc
, int sfmode
,
2273 const struct in6_addr
*psfsrc
)
2275 struct ip6_sf_list
*psf
, *psf_prev
;
2279 for_each_psf_mclock(pmc
, psf
) {
2280 if (ipv6_addr_equal(&psf
->sf_addr
, psfsrc
))
2284 if (!psf
|| psf
->sf_count
[sfmode
] == 0) {
2285 /* source filter not found, or count wrong => bug */
2288 psf
->sf_count
[sfmode
]--;
2289 if (!psf
->sf_count
[MCAST_INCLUDE
] && !psf
->sf_count
[MCAST_EXCLUDE
]) {
2290 struct inet6_dev
*idev
= pmc
->idev
;
2292 /* no more filters for this source */
2294 rcu_assign_pointer(psf_prev
->sf_next
,
2295 mc_dereference(psf
->sf_next
, idev
));
2297 rcu_assign_pointer(pmc
->mca_sources
,
2298 mc_dereference(psf
->sf_next
, idev
));
2300 if (psf
->sf_oldin
&& !(pmc
->mca_flags
& MAF_NOREPORT
) &&
2301 !mld_in_v1_mode(idev
)) {
2302 psf
->sf_crcount
= idev
->mc_qrv
;
2303 rcu_assign_pointer(psf
->sf_next
,
2304 mc_dereference(pmc
->mca_tomb
, idev
));
2305 rcu_assign_pointer(pmc
->mca_tomb
, psf
);
2308 kfree_rcu(psf
, rcu
);
2314 /* called with mc_lock */
2315 static int ip6_mc_del_src(struct inet6_dev
*idev
, const struct in6_addr
*pmca
,
2316 int sfmode
, int sfcount
, const struct in6_addr
*psfsrc
,
2319 struct ifmcaddr6
*pmc
;
2326 for_each_mc_mclock(idev
, pmc
) {
2327 if (ipv6_addr_equal(pmca
, &pmc
->mca_addr
))
2335 if (!pmc
->mca_sfcount
[sfmode
])
2338 pmc
->mca_sfcount
[sfmode
]--;
2341 for (i
= 0; i
< sfcount
; i
++) {
2342 int rv
= ip6_mc_del1_src(pmc
, sfmode
, &psfsrc
[i
]);
2344 changerec
|= rv
> 0;
2348 if (pmc
->mca_sfmode
== MCAST_EXCLUDE
&&
2349 pmc
->mca_sfcount
[MCAST_EXCLUDE
] == 0 &&
2350 pmc
->mca_sfcount
[MCAST_INCLUDE
]) {
2351 struct ip6_sf_list
*psf
;
2353 /* filter mode change */
2354 pmc
->mca_sfmode
= MCAST_INCLUDE
;
2355 pmc
->mca_crcount
= idev
->mc_qrv
;
2356 idev
->mc_ifc_count
= pmc
->mca_crcount
;
2357 for_each_psf_mclock(pmc
, psf
)
2358 psf
->sf_crcount
= 0;
2359 mld_ifc_event(pmc
->idev
);
2360 } else if (sf_setstate(pmc
) || changerec
) {
2361 mld_ifc_event(pmc
->idev
);
2368 * Add multicast single-source filter to the interface list
2369 * called with mc_lock
2371 static int ip6_mc_add1_src(struct ifmcaddr6
*pmc
, int sfmode
,
2372 const struct in6_addr
*psfsrc
)
2374 struct ip6_sf_list
*psf
, *psf_prev
;
2377 for_each_psf_mclock(pmc
, psf
) {
2378 if (ipv6_addr_equal(&psf
->sf_addr
, psfsrc
))
2383 psf
= kzalloc(sizeof(*psf
), GFP_KERNEL
);
2387 psf
->sf_addr
= *psfsrc
;
2389 rcu_assign_pointer(psf_prev
->sf_next
, psf
);
2391 rcu_assign_pointer(pmc
->mca_sources
, psf
);
2394 psf
->sf_count
[sfmode
]++;
2398 /* called with mc_lock */
2399 static void sf_markstate(struct ifmcaddr6
*pmc
)
2401 struct ip6_sf_list
*psf
;
2402 int mca_xcount
= pmc
->mca_sfcount
[MCAST_EXCLUDE
];
2404 for_each_psf_mclock(pmc
, psf
) {
2405 if (pmc
->mca_sfcount
[MCAST_EXCLUDE
]) {
2406 psf
->sf_oldin
= mca_xcount
==
2407 psf
->sf_count
[MCAST_EXCLUDE
] &&
2408 !psf
->sf_count
[MCAST_INCLUDE
];
2410 psf
->sf_oldin
= psf
->sf_count
[MCAST_INCLUDE
] != 0;
2415 /* called with mc_lock */
2416 static int sf_setstate(struct ifmcaddr6
*pmc
)
2418 struct ip6_sf_list
*psf
, *dpsf
;
2419 int mca_xcount
= pmc
->mca_sfcount
[MCAST_EXCLUDE
];
2420 int qrv
= pmc
->idev
->mc_qrv
;
2424 for_each_psf_mclock(pmc
, psf
) {
2425 if (pmc
->mca_sfcount
[MCAST_EXCLUDE
]) {
2426 new_in
= mca_xcount
== psf
->sf_count
[MCAST_EXCLUDE
] &&
2427 !psf
->sf_count
[MCAST_INCLUDE
];
2429 new_in
= psf
->sf_count
[MCAST_INCLUDE
] != 0;
2431 if (!psf
->sf_oldin
) {
2432 struct ip6_sf_list
*prev
= NULL
;
2434 for_each_psf_tomb(pmc
, dpsf
) {
2435 if (ipv6_addr_equal(&dpsf
->sf_addr
,
2442 rcu_assign_pointer(prev
->sf_next
,
2443 mc_dereference(dpsf
->sf_next
,
2446 rcu_assign_pointer(pmc
->mca_tomb
,
2447 mc_dereference(dpsf
->sf_next
,
2449 kfree_rcu(dpsf
, rcu
);
2451 psf
->sf_crcount
= qrv
;
2454 } else if (psf
->sf_oldin
) {
2455 psf
->sf_crcount
= 0;
2457 * add or update "delete" records if an active filter
2461 for_each_psf_tomb(pmc
, dpsf
)
2462 if (ipv6_addr_equal(&dpsf
->sf_addr
,
2466 dpsf
= kmalloc(sizeof(*dpsf
), GFP_KERNEL
);
2470 rcu_assign_pointer(dpsf
->sf_next
,
2471 mc_dereference(pmc
->mca_tomb
, pmc
->idev
));
2472 rcu_assign_pointer(pmc
->mca_tomb
, dpsf
);
2474 dpsf
->sf_crcount
= qrv
;
2482 * Add multicast source filter list to the interface list
2483 * called with mc_lock
2485 static int ip6_mc_add_src(struct inet6_dev
*idev
, const struct in6_addr
*pmca
,
2486 int sfmode
, int sfcount
, const struct in6_addr
*psfsrc
,
2489 struct ifmcaddr6
*pmc
;
2496 for_each_mc_mclock(idev
, pmc
) {
2497 if (ipv6_addr_equal(pmca
, &pmc
->mca_addr
))
2504 isexclude
= pmc
->mca_sfmode
== MCAST_EXCLUDE
;
2506 pmc
->mca_sfcount
[sfmode
]++;
2508 for (i
= 0; i
< sfcount
; i
++) {
2509 err
= ip6_mc_add1_src(pmc
, sfmode
, &psfsrc
[i
]);
2517 pmc
->mca_sfcount
[sfmode
]--;
2518 for (j
= 0; j
< i
; j
++)
2519 ip6_mc_del1_src(pmc
, sfmode
, &psfsrc
[j
]);
2520 } else if (isexclude
!= (pmc
->mca_sfcount
[MCAST_EXCLUDE
] != 0)) {
2521 struct ip6_sf_list
*psf
;
2523 /* filter mode change */
2524 if (pmc
->mca_sfcount
[MCAST_EXCLUDE
])
2525 pmc
->mca_sfmode
= MCAST_EXCLUDE
;
2526 else if (pmc
->mca_sfcount
[MCAST_INCLUDE
])
2527 pmc
->mca_sfmode
= MCAST_INCLUDE
;
2528 /* else no filters; keep old mode for reports */
2530 pmc
->mca_crcount
= idev
->mc_qrv
;
2531 idev
->mc_ifc_count
= pmc
->mca_crcount
;
2532 for_each_psf_mclock(pmc
, psf
)
2533 psf
->sf_crcount
= 0;
2534 mld_ifc_event(idev
);
2535 } else if (sf_setstate(pmc
)) {
2536 mld_ifc_event(idev
);
2541 /* called with mc_lock */
2542 static void ip6_mc_clear_src(struct ifmcaddr6
*pmc
)
2544 struct ip6_sf_list
*psf
, *nextpsf
;
2546 for (psf
= mc_dereference(pmc
->mca_tomb
, pmc
->idev
);
2549 nextpsf
= mc_dereference(psf
->sf_next
, pmc
->idev
);
2550 kfree_rcu(psf
, rcu
);
2552 RCU_INIT_POINTER(pmc
->mca_tomb
, NULL
);
2553 for (psf
= mc_dereference(pmc
->mca_sources
, pmc
->idev
);
2556 nextpsf
= mc_dereference(psf
->sf_next
, pmc
->idev
);
2557 kfree_rcu(psf
, rcu
);
2559 RCU_INIT_POINTER(pmc
->mca_sources
, NULL
);
2560 pmc
->mca_sfmode
= MCAST_EXCLUDE
;
2561 pmc
->mca_sfcount
[MCAST_INCLUDE
] = 0;
2562 pmc
->mca_sfcount
[MCAST_EXCLUDE
] = 1;
2565 /* called with mc_lock */
2566 static void igmp6_join_group(struct ifmcaddr6
*ma
)
2568 unsigned long delay
;
2570 if (ma
->mca_flags
& MAF_NOREPORT
)
2573 igmp6_send(&ma
->mca_addr
, ma
->idev
->dev
, ICMPV6_MGM_REPORT
);
2575 delay
= prandom_u32() % unsolicited_report_interval(ma
->idev
);
2577 if (cancel_delayed_work(&ma
->mca_work
)) {
2578 refcount_dec(&ma
->mca_refcnt
);
2579 delay
= ma
->mca_work
.timer
.expires
- jiffies
;
2582 if (!mod_delayed_work(mld_wq
, &ma
->mca_work
, delay
))
2583 refcount_inc(&ma
->mca_refcnt
);
2584 ma
->mca_flags
|= MAF_TIMER_RUNNING
| MAF_LAST_REPORTER
;
2587 static int ip6_mc_leave_src(struct sock
*sk
, struct ipv6_mc_socklist
*iml
,
2588 struct inet6_dev
*idev
)
2590 struct ip6_sf_socklist
*psl
;
2593 psl
= sock_dereference(iml
->sflist
, sk
);
2596 mutex_lock(&idev
->mc_lock
);
2599 /* any-source empty exclude case */
2600 err
= ip6_mc_del_src(idev
, &iml
->addr
, iml
->sfmode
, 0, NULL
, 0);
2602 err
= ip6_mc_del_src(idev
, &iml
->addr
, iml
->sfmode
,
2603 psl
->sl_count
, psl
->sl_addr
, 0);
2604 RCU_INIT_POINTER(iml
->sflist
, NULL
);
2605 atomic_sub(struct_size(psl
, sl_addr
, psl
->sl_max
),
2606 &sk
->sk_omem_alloc
);
2607 kfree_rcu(psl
, rcu
);
2611 mutex_unlock(&idev
->mc_lock
);
2616 /* called with mc_lock */
2617 static void igmp6_leave_group(struct ifmcaddr6
*ma
)
2619 if (mld_in_v1_mode(ma
->idev
)) {
2620 if (ma
->mca_flags
& MAF_LAST_REPORTER
) {
2621 igmp6_send(&ma
->mca_addr
, ma
->idev
->dev
,
2622 ICMPV6_MGM_REDUCTION
);
2625 mld_add_delrec(ma
->idev
, ma
);
2626 mld_ifc_event(ma
->idev
);
2630 static void mld_gq_work(struct work_struct
*work
)
2632 struct inet6_dev
*idev
= container_of(to_delayed_work(work
),
2636 mutex_lock(&idev
->mc_lock
);
2637 mld_send_report(idev
, NULL
);
2638 idev
->mc_gq_running
= 0;
2639 mutex_unlock(&idev
->mc_lock
);
2644 static void mld_ifc_work(struct work_struct
*work
)
2646 struct inet6_dev
*idev
= container_of(to_delayed_work(work
),
2650 mutex_lock(&idev
->mc_lock
);
2653 if (idev
->mc_ifc_count
) {
2654 idev
->mc_ifc_count
--;
2655 if (idev
->mc_ifc_count
)
2656 mld_ifc_start_work(idev
,
2657 unsolicited_report_interval(idev
));
2659 mutex_unlock(&idev
->mc_lock
);
2663 /* called with mc_lock */
2664 static void mld_ifc_event(struct inet6_dev
*idev
)
2666 if (mld_in_v1_mode(idev
))
2669 idev
->mc_ifc_count
= idev
->mc_qrv
;
2670 mld_ifc_start_work(idev
, 1);
2673 static void mld_mca_work(struct work_struct
*work
)
2675 struct ifmcaddr6
*ma
= container_of(to_delayed_work(work
),
2676 struct ifmcaddr6
, mca_work
);
2678 mutex_lock(&ma
->idev
->mc_lock
);
2679 if (mld_in_v1_mode(ma
->idev
))
2680 igmp6_send(&ma
->mca_addr
, ma
->idev
->dev
, ICMPV6_MGM_REPORT
);
2682 mld_send_report(ma
->idev
, ma
);
2683 ma
->mca_flags
|= MAF_LAST_REPORTER
;
2684 ma
->mca_flags
&= ~MAF_TIMER_RUNNING
;
2685 mutex_unlock(&ma
->idev
->mc_lock
);
2690 /* Device changing type */
2692 void ipv6_mc_unmap(struct inet6_dev
*idev
)
2694 struct ifmcaddr6
*i
;
2696 /* Install multicast list, except for all-nodes (already installed) */
2698 mutex_lock(&idev
->mc_lock
);
2699 for_each_mc_mclock(idev
, i
)
2700 igmp6_group_dropped(i
);
2701 mutex_unlock(&idev
->mc_lock
);
2704 void ipv6_mc_remap(struct inet6_dev
*idev
)
2709 /* Device going down */
2710 void ipv6_mc_down(struct inet6_dev
*idev
)
2712 struct ifmcaddr6
*i
;
2714 mutex_lock(&idev
->mc_lock
);
2715 /* Withdraw multicast list */
2716 for_each_mc_mclock(idev
, i
)
2717 igmp6_group_dropped(i
);
2718 mutex_unlock(&idev
->mc_lock
);
2720 /* Should stop work after group drop. or we will
2721 * start work again in mld_ifc_event()
2724 mld_query_stop_work(idev
);
2725 mld_report_stop_work(idev
);
2726 mld_ifc_stop_work(idev
);
2727 mld_gq_stop_work(idev
);
2728 mld_dad_stop_work(idev
);
2731 static void ipv6_mc_reset(struct inet6_dev
*idev
)
2733 idev
->mc_qrv
= sysctl_mld_qrv
;
2734 idev
->mc_qi
= MLD_QI_DEFAULT
;
2735 idev
->mc_qri
= MLD_QRI_DEFAULT
;
2736 idev
->mc_v1_seen
= 0;
2737 idev
->mc_maxdelay
= unsolicited_report_interval(idev
);
2740 /* Device going up */
2742 void ipv6_mc_up(struct inet6_dev
*idev
)
2744 struct ifmcaddr6
*i
;
2746 /* Install multicast list, except for all-nodes (already installed) */
2748 ipv6_mc_reset(idev
);
2749 mutex_lock(&idev
->mc_lock
);
2750 for_each_mc_mclock(idev
, i
) {
2751 mld_del_delrec(idev
, i
);
2752 igmp6_group_added(i
);
2754 mutex_unlock(&idev
->mc_lock
);
2757 /* IPv6 device initialization. */
2759 void ipv6_mc_init_dev(struct inet6_dev
*idev
)
2761 idev
->mc_gq_running
= 0;
2762 INIT_DELAYED_WORK(&idev
->mc_gq_work
, mld_gq_work
);
2763 RCU_INIT_POINTER(idev
->mc_tomb
, NULL
);
2764 idev
->mc_ifc_count
= 0;
2765 INIT_DELAYED_WORK(&idev
->mc_ifc_work
, mld_ifc_work
);
2766 INIT_DELAYED_WORK(&idev
->mc_dad_work
, mld_dad_work
);
2767 INIT_DELAYED_WORK(&idev
->mc_query_work
, mld_query_work
);
2768 INIT_DELAYED_WORK(&idev
->mc_report_work
, mld_report_work
);
2769 skb_queue_head_init(&idev
->mc_query_queue
);
2770 skb_queue_head_init(&idev
->mc_report_queue
);
2771 spin_lock_init(&idev
->mc_query_lock
);
2772 spin_lock_init(&idev
->mc_report_lock
);
2773 mutex_init(&idev
->mc_lock
);
2774 ipv6_mc_reset(idev
);
2778 * Device is about to be destroyed: clean up.
2781 void ipv6_mc_destroy_dev(struct inet6_dev
*idev
)
2783 struct ifmcaddr6
*i
;
2785 /* Deactivate works */
2787 mutex_lock(&idev
->mc_lock
);
2788 mld_clear_delrec(idev
);
2789 mutex_unlock(&idev
->mc_lock
);
2790 mld_clear_query(idev
);
2791 mld_clear_report(idev
);
2793 /* Delete all-nodes address. */
2794 /* We cannot call ipv6_dev_mc_dec() directly, our caller in
2795 * addrconf.c has NULL'd out dev->ip6_ptr so in6_dev_get() will
2798 __ipv6_dev_mc_dec(idev
, &in6addr_linklocal_allnodes
);
2800 if (idev
->cnf
.forwarding
)
2801 __ipv6_dev_mc_dec(idev
, &in6addr_linklocal_allrouters
);
2803 mutex_lock(&idev
->mc_lock
);
2804 while ((i
= mc_dereference(idev
->mc_list
, idev
))) {
2805 rcu_assign_pointer(idev
->mc_list
, mc_dereference(i
->next
, idev
));
2807 ip6_mc_clear_src(i
);
2810 mutex_unlock(&idev
->mc_lock
);
2813 static void ipv6_mc_rejoin_groups(struct inet6_dev
*idev
)
2815 struct ifmcaddr6
*pmc
;
2819 mutex_lock(&idev
->mc_lock
);
2820 if (mld_in_v1_mode(idev
)) {
2821 for_each_mc_mclock(idev
, pmc
)
2822 igmp6_join_group(pmc
);
2824 mld_send_report(idev
, NULL
);
2826 mutex_unlock(&idev
->mc_lock
);
2829 static int ipv6_mc_netdev_event(struct notifier_block
*this,
2830 unsigned long event
,
2833 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
2834 struct inet6_dev
*idev
= __in6_dev_get(dev
);
2837 case NETDEV_RESEND_IGMP
:
2839 ipv6_mc_rejoin_groups(idev
);
2848 static struct notifier_block igmp6_netdev_notifier
= {
2849 .notifier_call
= ipv6_mc_netdev_event
,
2852 #ifdef CONFIG_PROC_FS
2853 struct igmp6_mc_iter_state
{
2854 struct seq_net_private p
;
2855 struct net_device
*dev
;
2856 struct inet6_dev
*idev
;
2859 #define igmp6_mc_seq_private(seq) ((struct igmp6_mc_iter_state *)(seq)->private)
2861 static inline struct ifmcaddr6
*igmp6_mc_get_first(struct seq_file
*seq
)
2863 struct ifmcaddr6
*im
= NULL
;
2864 struct igmp6_mc_iter_state
*state
= igmp6_mc_seq_private(seq
);
2865 struct net
*net
= seq_file_net(seq
);
2868 for_each_netdev_rcu(net
, state
->dev
) {
2869 struct inet6_dev
*idev
;
2870 idev
= __in6_dev_get(state
->dev
);
2874 im
= rcu_dereference(idev
->mc_list
);
2883 static struct ifmcaddr6
*igmp6_mc_get_next(struct seq_file
*seq
, struct ifmcaddr6
*im
)
2885 struct igmp6_mc_iter_state
*state
= igmp6_mc_seq_private(seq
);
2887 im
= rcu_dereference(im
->next
);
2889 state
->dev
= next_net_device_rcu(state
->dev
);
2894 state
->idev
= __in6_dev_get(state
->dev
);
2897 im
= rcu_dereference(state
->idev
->mc_list
);
2902 static struct ifmcaddr6
*igmp6_mc_get_idx(struct seq_file
*seq
, loff_t pos
)
2904 struct ifmcaddr6
*im
= igmp6_mc_get_first(seq
);
2906 while (pos
&& (im
= igmp6_mc_get_next(seq
, im
)) != NULL
)
2908 return pos
? NULL
: im
;
2911 static void *igmp6_mc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2915 return igmp6_mc_get_idx(seq
, *pos
);
2918 static void *igmp6_mc_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2920 struct ifmcaddr6
*im
= igmp6_mc_get_next(seq
, v
);
2926 static void igmp6_mc_seq_stop(struct seq_file
*seq
, void *v
)
2929 struct igmp6_mc_iter_state
*state
= igmp6_mc_seq_private(seq
);
2931 if (likely(state
->idev
))
2937 static int igmp6_mc_seq_show(struct seq_file
*seq
, void *v
)
2939 struct ifmcaddr6
*im
= (struct ifmcaddr6
*)v
;
2940 struct igmp6_mc_iter_state
*state
= igmp6_mc_seq_private(seq
);
2943 "%-4d %-15s %pi6 %5d %08X %ld\n",
2944 state
->dev
->ifindex
, state
->dev
->name
,
2946 im
->mca_users
, im
->mca_flags
,
2947 (im
->mca_flags
& MAF_TIMER_RUNNING
) ?
2948 jiffies_to_clock_t(im
->mca_work
.timer
.expires
- jiffies
) : 0);
2952 static const struct seq_operations igmp6_mc_seq_ops
= {
2953 .start
= igmp6_mc_seq_start
,
2954 .next
= igmp6_mc_seq_next
,
2955 .stop
= igmp6_mc_seq_stop
,
2956 .show
= igmp6_mc_seq_show
,
2959 struct igmp6_mcf_iter_state
{
2960 struct seq_net_private p
;
2961 struct net_device
*dev
;
2962 struct inet6_dev
*idev
;
2963 struct ifmcaddr6
*im
;
2966 #define igmp6_mcf_seq_private(seq) ((struct igmp6_mcf_iter_state *)(seq)->private)
2968 static inline struct ip6_sf_list
*igmp6_mcf_get_first(struct seq_file
*seq
)
2970 struct ip6_sf_list
*psf
= NULL
;
2971 struct ifmcaddr6
*im
= NULL
;
2972 struct igmp6_mcf_iter_state
*state
= igmp6_mcf_seq_private(seq
);
2973 struct net
*net
= seq_file_net(seq
);
2977 for_each_netdev_rcu(net
, state
->dev
) {
2978 struct inet6_dev
*idev
;
2979 idev
= __in6_dev_get(state
->dev
);
2980 if (unlikely(idev
== NULL
))
2983 im
= rcu_dereference(idev
->mc_list
);
2985 psf
= rcu_dereference(im
->mca_sources
);
2996 static struct ip6_sf_list
*igmp6_mcf_get_next(struct seq_file
*seq
, struct ip6_sf_list
*psf
)
2998 struct igmp6_mcf_iter_state
*state
= igmp6_mcf_seq_private(seq
);
3000 psf
= rcu_dereference(psf
->sf_next
);
3002 state
->im
= rcu_dereference(state
->im
->next
);
3003 while (!state
->im
) {
3004 state
->dev
= next_net_device_rcu(state
->dev
);
3009 state
->idev
= __in6_dev_get(state
->dev
);
3012 state
->im
= rcu_dereference(state
->idev
->mc_list
);
3016 psf
= rcu_dereference(state
->im
->mca_sources
);
3022 static struct ip6_sf_list
*igmp6_mcf_get_idx(struct seq_file
*seq
, loff_t pos
)
3024 struct ip6_sf_list
*psf
= igmp6_mcf_get_first(seq
);
3026 while (pos
&& (psf
= igmp6_mcf_get_next(seq
, psf
)) != NULL
)
3028 return pos
? NULL
: psf
;
3031 static void *igmp6_mcf_seq_start(struct seq_file
*seq
, loff_t
*pos
)
3035 return *pos
? igmp6_mcf_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
3038 static void *igmp6_mcf_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
3040 struct ip6_sf_list
*psf
;
3041 if (v
== SEQ_START_TOKEN
)
3042 psf
= igmp6_mcf_get_first(seq
);
3044 psf
= igmp6_mcf_get_next(seq
, v
);
3049 static void igmp6_mcf_seq_stop(struct seq_file
*seq
, void *v
)
3052 struct igmp6_mcf_iter_state
*state
= igmp6_mcf_seq_private(seq
);
3054 if (likely(state
->im
))
3056 if (likely(state
->idev
))
3063 static int igmp6_mcf_seq_show(struct seq_file
*seq
, void *v
)
3065 struct ip6_sf_list
*psf
= (struct ip6_sf_list
*)v
;
3066 struct igmp6_mcf_iter_state
*state
= igmp6_mcf_seq_private(seq
);
3068 if (v
== SEQ_START_TOKEN
) {
3069 seq_puts(seq
, "Idx Device Multicast Address Source Address INC EXC\n");
3072 "%3d %6.6s %pi6 %pi6 %6lu %6lu\n",
3073 state
->dev
->ifindex
, state
->dev
->name
,
3074 &state
->im
->mca_addr
,
3076 psf
->sf_count
[MCAST_INCLUDE
],
3077 psf
->sf_count
[MCAST_EXCLUDE
]);
3082 static const struct seq_operations igmp6_mcf_seq_ops
= {
3083 .start
= igmp6_mcf_seq_start
,
3084 .next
= igmp6_mcf_seq_next
,
3085 .stop
= igmp6_mcf_seq_stop
,
3086 .show
= igmp6_mcf_seq_show
,
3089 static int __net_init
igmp6_proc_init(struct net
*net
)
3094 if (!proc_create_net("igmp6", 0444, net
->proc_net
, &igmp6_mc_seq_ops
,
3095 sizeof(struct igmp6_mc_iter_state
)))
3097 if (!proc_create_net("mcfilter6", 0444, net
->proc_net
,
3099 sizeof(struct igmp6_mcf_iter_state
)))
3100 goto out_proc_net_igmp6
;
3107 remove_proc_entry("igmp6", net
->proc_net
);
3111 static void __net_exit
igmp6_proc_exit(struct net
*net
)
3113 remove_proc_entry("mcfilter6", net
->proc_net
);
3114 remove_proc_entry("igmp6", net
->proc_net
);
3117 static inline int igmp6_proc_init(struct net
*net
)
3121 static inline void igmp6_proc_exit(struct net
*net
)
3126 static int __net_init
igmp6_net_init(struct net
*net
)
3130 err
= inet_ctl_sock_create(&net
->ipv6
.igmp_sk
, PF_INET6
,
3131 SOCK_RAW
, IPPROTO_ICMPV6
, net
);
3133 pr_err("Failed to initialize the IGMP6 control socket (err %d)\n",
3138 inet6_sk(net
->ipv6
.igmp_sk
)->hop_limit
= 1;
3139 net
->ipv6
.igmp_sk
->sk_allocation
= GFP_KERNEL
;
3141 err
= inet_ctl_sock_create(&net
->ipv6
.mc_autojoin_sk
, PF_INET6
,
3142 SOCK_RAW
, IPPROTO_ICMPV6
, net
);
3144 pr_err("Failed to initialize the IGMP6 autojoin socket (err %d)\n",
3146 goto out_sock_create
;
3149 err
= igmp6_proc_init(net
);
3151 goto out_sock_create_autojoin
;
3155 out_sock_create_autojoin
:
3156 inet_ctl_sock_destroy(net
->ipv6
.mc_autojoin_sk
);
3158 inet_ctl_sock_destroy(net
->ipv6
.igmp_sk
);
3163 static void __net_exit
igmp6_net_exit(struct net
*net
)
3165 inet_ctl_sock_destroy(net
->ipv6
.igmp_sk
);
3166 inet_ctl_sock_destroy(net
->ipv6
.mc_autojoin_sk
);
3167 igmp6_proc_exit(net
);
3170 static struct pernet_operations igmp6_net_ops
= {
3171 .init
= igmp6_net_init
,
3172 .exit
= igmp6_net_exit
,
3175 int __init
igmp6_init(void)
3179 err
= register_pernet_subsys(&igmp6_net_ops
);
3183 mld_wq
= create_workqueue("mld");
3185 unregister_pernet_subsys(&igmp6_net_ops
);
3192 int __init
igmp6_late_init(void)
3194 return register_netdevice_notifier(&igmp6_netdev_notifier
);
3197 void igmp6_cleanup(void)
3199 unregister_pernet_subsys(&igmp6_net_ops
);
3200 destroy_workqueue(mld_wq
);
3203 void igmp6_late_cleanup(void)
3205 unregister_netdevice_notifier(&igmp6_netdev_notifier
);