2 * Linux IPv6 multicast routing support for BSD pim6sd
3 * Based on net/ipv4/ipmr.c.
5 * (c) 2004 Mickael Hoerdt, <hoerdt@clarinet.u-strasbg.fr>
6 * LSIIT Laboratory, Strasbourg, France
7 * (c) 2004 Jean-Philippe Andriot, <jean-philippe.andriot@6WIND.com>
9 * Copyright (C)2007,2008 USAGI/WIDE Project
10 * YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
19 #include <asm/system.h>
20 #include <asm/uaccess.h>
21 #include <linux/types.h>
22 #include <linux/sched.h>
23 #include <linux/errno.h>
24 #include <linux/timer.h>
26 #include <linux/kernel.h>
27 #include <linux/fcntl.h>
28 #include <linux/stat.h>
29 #include <linux/socket.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/inetdevice.h>
33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h>
35 #include <linux/init.h>
36 #include <net/protocol.h>
37 #include <linux/skbuff.h>
40 #include <linux/notifier.h>
41 #include <linux/if_arp.h>
42 #include <net/checksum.h>
43 #include <net/netlink.h>
46 #include <net/ip6_route.h>
47 #include <linux/mroute6.h>
48 #include <linux/pim.h>
49 #include <net/addrconf.h>
50 #include <linux/netfilter_ipv6.h>
52 struct sock
*mroute6_socket
;
55 /* Big lock, protecting vif table, mrt cache and mroute socket state.
56 Note that the changes are semaphored via rtnl_lock.
59 static DEFINE_RWLOCK(mrt_lock
);
62 * Multicast router control variables
65 static struct mif_device vif6_table
[MAXMIFS
]; /* Devices */
68 #define MIF_EXISTS(idx) (vif6_table[idx].dev != NULL)
70 static int mroute_do_assert
; /* Set in PIM assert */
71 #ifdef CONFIG_IPV6_PIMSM_V2
72 static int mroute_do_pim
;
74 #define mroute_do_pim 0
77 static struct mfc6_cache
*mfc6_cache_array
[MFC6_LINES
]; /* Forwarding cache */
79 static struct mfc6_cache
*mfc_unres_queue
; /* Queue of unresolved entries */
80 static atomic_t cache_resolve_queue_len
; /* Size of unresolved */
82 /* Special spinlock for queue of unresolved entries */
83 static DEFINE_SPINLOCK(mfc_unres_lock
);
85 /* We return to original Alan's scheme. Hash table of resolved
86 entries is changed only in process context and protected
87 with weak lock mrt_lock. Queue of unresolved entries is protected
88 with strong spinlock mfc_unres_lock.
90 In this case data path is free of exclusive locks at all.
93 static struct kmem_cache
*mrt_cachep __read_mostly
;
95 static int ip6_mr_forward(struct sk_buff
*skb
, struct mfc6_cache
*cache
);
96 static int ip6mr_cache_report(struct sk_buff
*pkt
, mifi_t mifi
, int assert);
97 static int ip6mr_fill_mroute(struct sk_buff
*skb
, struct mfc6_cache
*c
, struct rtmsg
*rtm
);
99 #ifdef CONFIG_IPV6_PIMSM_V2
100 static struct inet6_protocol pim6_protocol
;
103 static struct timer_list ipmr_expire_timer
;
106 #ifdef CONFIG_PROC_FS
108 struct ipmr_mfc_iter
{
109 struct mfc6_cache
**cache
;
114 static struct mfc6_cache
*ipmr_mfc_seq_idx(struct ipmr_mfc_iter
*it
, loff_t pos
)
116 struct mfc6_cache
*mfc
;
118 it
->cache
= mfc6_cache_array
;
119 read_lock(&mrt_lock
);
120 for (it
->ct
= 0; it
->ct
< ARRAY_SIZE(mfc6_cache_array
); it
->ct
++)
121 for (mfc
= mfc6_cache_array
[it
->ct
]; mfc
; mfc
= mfc
->next
)
124 read_unlock(&mrt_lock
);
126 it
->cache
= &mfc_unres_queue
;
127 spin_lock_bh(&mfc_unres_lock
);
128 for (mfc
= mfc_unres_queue
; mfc
; mfc
= mfc
->next
)
131 spin_unlock_bh(&mfc_unres_lock
);
141 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
144 struct ipmr_vif_iter
{
148 static struct mif_device
*ip6mr_vif_seq_idx(struct ipmr_vif_iter
*iter
,
151 for (iter
->ct
= 0; iter
->ct
< maxvif
; ++iter
->ct
) {
152 if (!MIF_EXISTS(iter
->ct
))
155 return &vif6_table
[iter
->ct
];
160 static void *ip6mr_vif_seq_start(struct seq_file
*seq
, loff_t
*pos
)
163 read_lock(&mrt_lock
);
164 return (*pos
? ip6mr_vif_seq_idx(seq
->private, *pos
- 1)
168 static void *ip6mr_vif_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
170 struct ipmr_vif_iter
*iter
= seq
->private;
173 if (v
== SEQ_START_TOKEN
)
174 return ip6mr_vif_seq_idx(iter
, 0);
176 while (++iter
->ct
< maxvif
) {
177 if (!MIF_EXISTS(iter
->ct
))
179 return &vif6_table
[iter
->ct
];
184 static void ip6mr_vif_seq_stop(struct seq_file
*seq
, void *v
)
187 read_unlock(&mrt_lock
);
190 static int ip6mr_vif_seq_show(struct seq_file
*seq
, void *v
)
192 if (v
== SEQ_START_TOKEN
) {
194 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
196 const struct mif_device
*vif
= v
;
197 const char *name
= vif
->dev
? vif
->dev
->name
: "none";
200 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
202 name
, vif
->bytes_in
, vif
->pkt_in
,
203 vif
->bytes_out
, vif
->pkt_out
,
209 static struct seq_operations ip6mr_vif_seq_ops
= {
210 .start
= ip6mr_vif_seq_start
,
211 .next
= ip6mr_vif_seq_next
,
212 .stop
= ip6mr_vif_seq_stop
,
213 .show
= ip6mr_vif_seq_show
,
216 static int ip6mr_vif_open(struct inode
*inode
, struct file
*file
)
218 return seq_open_private(file
, &ip6mr_vif_seq_ops
,
219 sizeof(struct ipmr_vif_iter
));
222 static struct file_operations ip6mr_vif_fops
= {
223 .owner
= THIS_MODULE
,
224 .open
= ip6mr_vif_open
,
227 .release
= seq_release
,
230 static void *ipmr_mfc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
232 return (*pos
? ipmr_mfc_seq_idx(seq
->private, *pos
- 1)
236 static void *ipmr_mfc_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
238 struct mfc6_cache
*mfc
= v
;
239 struct ipmr_mfc_iter
*it
= seq
->private;
243 if (v
== SEQ_START_TOKEN
)
244 return ipmr_mfc_seq_idx(seq
->private, 0);
249 if (it
->cache
== &mfc_unres_queue
)
252 BUG_ON(it
->cache
!= mfc6_cache_array
);
254 while (++it
->ct
< ARRAY_SIZE(mfc6_cache_array
)) {
255 mfc
= mfc6_cache_array
[it
->ct
];
260 /* exhausted cache_array, show unresolved */
261 read_unlock(&mrt_lock
);
262 it
->cache
= &mfc_unres_queue
;
265 spin_lock_bh(&mfc_unres_lock
);
266 mfc
= mfc_unres_queue
;
271 spin_unlock_bh(&mfc_unres_lock
);
277 static void ipmr_mfc_seq_stop(struct seq_file
*seq
, void *v
)
279 struct ipmr_mfc_iter
*it
= seq
->private;
281 if (it
->cache
== &mfc_unres_queue
)
282 spin_unlock_bh(&mfc_unres_lock
);
283 else if (it
->cache
== mfc6_cache_array
)
284 read_unlock(&mrt_lock
);
287 static int ipmr_mfc_seq_show(struct seq_file
*seq
, void *v
)
291 if (v
== SEQ_START_TOKEN
) {
295 "Iif Pkts Bytes Wrong Oifs\n");
297 const struct mfc6_cache
*mfc
= v
;
298 const struct ipmr_mfc_iter
*it
= seq
->private;
300 seq_printf(seq
, "%p6 %p6 %-3d %8ld %8ld %8ld",
301 &mfc
->mf6c_mcastgrp
, &mfc
->mf6c_origin
,
304 mfc
->mfc_un
.res
.bytes
,
305 mfc
->mfc_un
.res
.wrong_if
);
307 if (it
->cache
!= &mfc_unres_queue
) {
308 for (n
= mfc
->mfc_un
.res
.minvif
;
309 n
< mfc
->mfc_un
.res
.maxvif
; n
++) {
311 mfc
->mfc_un
.res
.ttls
[n
] < 255)
314 n
, mfc
->mfc_un
.res
.ttls
[n
]);
322 static struct seq_operations ipmr_mfc_seq_ops
= {
323 .start
= ipmr_mfc_seq_start
,
324 .next
= ipmr_mfc_seq_next
,
325 .stop
= ipmr_mfc_seq_stop
,
326 .show
= ipmr_mfc_seq_show
,
329 static int ipmr_mfc_open(struct inode
*inode
, struct file
*file
)
331 return seq_open_private(file
, &ipmr_mfc_seq_ops
,
332 sizeof(struct ipmr_mfc_iter
));
335 static struct file_operations ip6mr_mfc_fops
= {
336 .owner
= THIS_MODULE
,
337 .open
= ipmr_mfc_open
,
340 .release
= seq_release
,
344 #ifdef CONFIG_IPV6_PIMSM_V2
345 static int reg_vif_num
= -1;
347 static int pim6_rcv(struct sk_buff
*skb
)
349 struct pimreghdr
*pim
;
350 struct ipv6hdr
*encap
;
351 struct net_device
*reg_dev
= NULL
;
353 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(*encap
)))
356 pim
= (struct pimreghdr
*)skb_transport_header(skb
);
357 if (pim
->type
!= ((PIM_VERSION
<< 4) | PIM_REGISTER
) ||
358 (pim
->flags
& PIM_NULL_REGISTER
) ||
359 (ip_compute_csum((void *)pim
, sizeof(*pim
)) != 0 &&
360 csum_fold(skb_checksum(skb
, 0, skb
->len
, 0))))
363 /* check if the inner packet is destined to mcast group */
364 encap
= (struct ipv6hdr
*)(skb_transport_header(skb
) +
367 if (!ipv6_addr_is_multicast(&encap
->daddr
) ||
368 encap
->payload_len
== 0 ||
369 ntohs(encap
->payload_len
) + sizeof(*pim
) > skb
->len
)
372 read_lock(&mrt_lock
);
373 if (reg_vif_num
>= 0)
374 reg_dev
= vif6_table
[reg_vif_num
].dev
;
377 read_unlock(&mrt_lock
);
382 skb
->mac_header
= skb
->network_header
;
383 skb_pull(skb
, (u8
*)encap
- skb
->data
);
384 skb_reset_network_header(skb
);
386 skb
->protocol
= htons(ETH_P_IP
);
388 skb
->pkt_type
= PACKET_HOST
;
389 dst_release(skb
->dst
);
390 reg_dev
->stats
.rx_bytes
+= skb
->len
;
391 reg_dev
->stats
.rx_packets
++;
402 static struct inet6_protocol pim6_protocol
= {
406 /* Service routines creating virtual interfaces: PIMREG */
408 static int reg_vif_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
410 read_lock(&mrt_lock
);
411 dev
->stats
.tx_bytes
+= skb
->len
;
412 dev
->stats
.tx_packets
++;
413 ip6mr_cache_report(skb
, reg_vif_num
, MRT6MSG_WHOLEPKT
);
414 read_unlock(&mrt_lock
);
419 static void reg_vif_setup(struct net_device
*dev
)
421 dev
->type
= ARPHRD_PIMREG
;
422 dev
->mtu
= 1500 - sizeof(struct ipv6hdr
) - 8;
423 dev
->flags
= IFF_NOARP
;
424 dev
->hard_start_xmit
= reg_vif_xmit
;
425 dev
->destructor
= free_netdev
;
428 static struct net_device
*ip6mr_reg_vif(void)
430 struct net_device
*dev
;
432 dev
= alloc_netdev(0, "pim6reg", reg_vif_setup
);
436 if (register_netdevice(dev
)) {
449 /* allow the register to be completed before unregistering. */
453 unregister_netdevice(dev
);
462 static int mif6_delete(int vifi
)
464 struct mif_device
*v
;
465 struct net_device
*dev
;
466 if (vifi
< 0 || vifi
>= maxvif
)
467 return -EADDRNOTAVAIL
;
469 v
= &vif6_table
[vifi
];
471 write_lock_bh(&mrt_lock
);
476 write_unlock_bh(&mrt_lock
);
477 return -EADDRNOTAVAIL
;
480 #ifdef CONFIG_IPV6_PIMSM_V2
481 if (vifi
== reg_vif_num
)
485 if (vifi
+ 1 == maxvif
) {
487 for (tmp
= vifi
- 1; tmp
>= 0; tmp
--) {
494 write_unlock_bh(&mrt_lock
);
496 dev_set_allmulti(dev
, -1);
498 if (v
->flags
& MIFF_REGISTER
)
499 unregister_netdevice(dev
);
505 /* Destroy an unresolved cache entry, killing queued skbs
506 and reporting error to netlink readers.
509 static void ip6mr_destroy_unres(struct mfc6_cache
*c
)
513 atomic_dec(&cache_resolve_queue_len
);
515 while((skb
= skb_dequeue(&c
->mfc_un
.unres
.unresolved
)) != NULL
) {
516 if (ipv6_hdr(skb
)->version
== 0) {
517 struct nlmsghdr
*nlh
= (struct nlmsghdr
*)skb_pull(skb
, sizeof(struct ipv6hdr
));
518 nlh
->nlmsg_type
= NLMSG_ERROR
;
519 nlh
->nlmsg_len
= NLMSG_LENGTH(sizeof(struct nlmsgerr
));
520 skb_trim(skb
, nlh
->nlmsg_len
);
521 ((struct nlmsgerr
*)NLMSG_DATA(nlh
))->error
= -ETIMEDOUT
;
522 rtnl_unicast(skb
, &init_net
, NETLINK_CB(skb
).pid
);
527 kmem_cache_free(mrt_cachep
, c
);
531 /* Single timer process for all the unresolved queue. */
533 static void ipmr_do_expire_process(unsigned long dummy
)
535 unsigned long now
= jiffies
;
536 unsigned long expires
= 10 * HZ
;
537 struct mfc6_cache
*c
, **cp
;
539 cp
= &mfc_unres_queue
;
541 while ((c
= *cp
) != NULL
) {
542 if (time_after(c
->mfc_un
.unres
.expires
, now
)) {
544 unsigned long interval
= c
->mfc_un
.unres
.expires
- now
;
545 if (interval
< expires
)
552 ip6mr_destroy_unres(c
);
555 if (atomic_read(&cache_resolve_queue_len
))
556 mod_timer(&ipmr_expire_timer
, jiffies
+ expires
);
559 static void ipmr_expire_process(unsigned long dummy
)
561 if (!spin_trylock(&mfc_unres_lock
)) {
562 mod_timer(&ipmr_expire_timer
, jiffies
+ 1);
566 if (atomic_read(&cache_resolve_queue_len
))
567 ipmr_do_expire_process(dummy
);
569 spin_unlock(&mfc_unres_lock
);
572 /* Fill oifs list. It is called under write locked mrt_lock. */
574 static void ip6mr_update_thresholds(struct mfc6_cache
*cache
, unsigned char *ttls
)
578 cache
->mfc_un
.res
.minvif
= MAXMIFS
;
579 cache
->mfc_un
.res
.maxvif
= 0;
580 memset(cache
->mfc_un
.res
.ttls
, 255, MAXMIFS
);
582 for (vifi
= 0; vifi
< maxvif
; vifi
++) {
583 if (MIF_EXISTS(vifi
) && ttls
[vifi
] && ttls
[vifi
] < 255) {
584 cache
->mfc_un
.res
.ttls
[vifi
] = ttls
[vifi
];
585 if (cache
->mfc_un
.res
.minvif
> vifi
)
586 cache
->mfc_un
.res
.minvif
= vifi
;
587 if (cache
->mfc_un
.res
.maxvif
<= vifi
)
588 cache
->mfc_un
.res
.maxvif
= vifi
+ 1;
593 static int mif6_add(struct mif6ctl
*vifc
, int mrtsock
)
595 int vifi
= vifc
->mif6c_mifi
;
596 struct mif_device
*v
= &vif6_table
[vifi
];
597 struct net_device
*dev
;
601 if (MIF_EXISTS(vifi
))
604 switch (vifc
->mif6c_flags
) {
605 #ifdef CONFIG_IPV6_PIMSM_V2
608 * Special Purpose VIF in PIM
609 * All the packets will be sent to the daemon
611 if (reg_vif_num
>= 0)
613 dev
= ip6mr_reg_vif();
616 err
= dev_set_allmulti(dev
, 1);
618 unregister_netdevice(dev
);
625 dev
= dev_get_by_index(&init_net
, vifc
->mif6c_pifi
);
627 return -EADDRNOTAVAIL
;
628 err
= dev_set_allmulti(dev
, 1);
639 * Fill in the VIF structures
641 v
->rate_limit
= vifc
->vifc_rate_limit
;
642 v
->flags
= vifc
->mif6c_flags
;
644 v
->flags
|= VIFF_STATIC
;
645 v
->threshold
= vifc
->vifc_threshold
;
650 v
->link
= dev
->ifindex
;
651 if (v
->flags
& MIFF_REGISTER
)
652 v
->link
= dev
->iflink
;
654 /* And finish update writing critical data */
655 write_lock_bh(&mrt_lock
);
657 #ifdef CONFIG_IPV6_PIMSM_V2
658 if (v
->flags
& MIFF_REGISTER
)
661 if (vifi
+ 1 > maxvif
)
663 write_unlock_bh(&mrt_lock
);
667 static struct mfc6_cache
*ip6mr_cache_find(struct in6_addr
*origin
, struct in6_addr
*mcastgrp
)
669 int line
= MFC6_HASH(mcastgrp
, origin
);
670 struct mfc6_cache
*c
;
672 for (c
= mfc6_cache_array
[line
]; c
; c
= c
->next
) {
673 if (ipv6_addr_equal(&c
->mf6c_origin
, origin
) &&
674 ipv6_addr_equal(&c
->mf6c_mcastgrp
, mcastgrp
))
681 * Allocate a multicast cache entry
683 static struct mfc6_cache
*ip6mr_cache_alloc(void)
685 struct mfc6_cache
*c
= kmem_cache_alloc(mrt_cachep
, GFP_KERNEL
);
688 memset(c
, 0, sizeof(*c
));
689 c
->mfc_un
.res
.minvif
= MAXMIFS
;
693 static struct mfc6_cache
*ip6mr_cache_alloc_unres(void)
695 struct mfc6_cache
*c
= kmem_cache_alloc(mrt_cachep
, GFP_ATOMIC
);
698 memset(c
, 0, sizeof(*c
));
699 skb_queue_head_init(&c
->mfc_un
.unres
.unresolved
);
700 c
->mfc_un
.unres
.expires
= jiffies
+ 10 * HZ
;
705 * A cache entry has gone into a resolved state from queued
708 static void ip6mr_cache_resolve(struct mfc6_cache
*uc
, struct mfc6_cache
*c
)
713 * Play the pending entries through our router
716 while((skb
= __skb_dequeue(&uc
->mfc_un
.unres
.unresolved
))) {
717 if (ipv6_hdr(skb
)->version
== 0) {
719 struct nlmsghdr
*nlh
= (struct nlmsghdr
*)skb_pull(skb
, sizeof(struct ipv6hdr
));
721 if (ip6mr_fill_mroute(skb
, c
, NLMSG_DATA(nlh
)) > 0) {
722 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - (u8
*)nlh
;
724 nlh
->nlmsg_type
= NLMSG_ERROR
;
725 nlh
->nlmsg_len
= NLMSG_LENGTH(sizeof(struct nlmsgerr
));
726 skb_trim(skb
, nlh
->nlmsg_len
);
727 ((struct nlmsgerr
*)NLMSG_DATA(nlh
))->error
= -EMSGSIZE
;
729 err
= rtnl_unicast(skb
, &init_net
, NETLINK_CB(skb
).pid
);
731 ip6_mr_forward(skb
, c
);
736 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
737 * expects the following bizarre scheme.
739 * Called under mrt_lock.
742 static int ip6mr_cache_report(struct sk_buff
*pkt
, mifi_t mifi
, int assert)
748 #ifdef CONFIG_IPV6_PIMSM_V2
749 if (assert == MRT6MSG_WHOLEPKT
)
750 skb
= skb_realloc_headroom(pkt
, -skb_network_offset(pkt
)
754 skb
= alloc_skb(sizeof(struct ipv6hdr
) + sizeof(*msg
), GFP_ATOMIC
);
759 /* I suppose that internal messages
760 * do not require checksums */
762 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
764 #ifdef CONFIG_IPV6_PIMSM_V2
765 if (assert == MRT6MSG_WHOLEPKT
) {
766 /* Ugly, but we have no choice with this interface.
767 Duplicate old header, fix length etc.
768 And all this only to mangle msg->im6_msgtype and
769 to set msg->im6_mbz to "mbz" :-)
771 skb_push(skb
, -skb_network_offset(pkt
));
773 skb_push(skb
, sizeof(*msg
));
774 skb_reset_transport_header(skb
);
775 msg
= (struct mrt6msg
*)skb_transport_header(skb
);
777 msg
->im6_msgtype
= MRT6MSG_WHOLEPKT
;
778 msg
->im6_mif
= reg_vif_num
;
780 ipv6_addr_copy(&msg
->im6_src
, &ipv6_hdr(pkt
)->saddr
);
781 ipv6_addr_copy(&msg
->im6_dst
, &ipv6_hdr(pkt
)->daddr
);
783 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
791 skb_put(skb
, sizeof(struct ipv6hdr
));
792 skb_reset_network_header(skb
);
793 skb_copy_to_linear_data(skb
, ipv6_hdr(pkt
), sizeof(struct ipv6hdr
));
798 skb_put(skb
, sizeof(*msg
));
799 skb_reset_transport_header(skb
);
800 msg
= (struct mrt6msg
*)skb_transport_header(skb
);
803 msg
->im6_msgtype
= assert;
806 ipv6_addr_copy(&msg
->im6_src
, &ipv6_hdr(pkt
)->saddr
);
807 ipv6_addr_copy(&msg
->im6_dst
, &ipv6_hdr(pkt
)->daddr
);
809 skb
->dst
= dst_clone(pkt
->dst
);
810 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
812 skb_pull(skb
, sizeof(struct ipv6hdr
));
815 if (mroute6_socket
== NULL
) {
821 * Deliver to user space multicast routing algorithms
823 if ((ret
= sock_queue_rcv_skb(mroute6_socket
, skb
)) < 0) {
825 printk(KERN_WARNING
"mroute6: pending queue full, dropping entries.\n");
833 * Queue a packet for resolution. It gets locked cache entry!
837 ip6mr_cache_unresolved(mifi_t mifi
, struct sk_buff
*skb
)
840 struct mfc6_cache
*c
;
842 spin_lock_bh(&mfc_unres_lock
);
843 for (c
= mfc_unres_queue
; c
; c
= c
->next
) {
844 if (ipv6_addr_equal(&c
->mf6c_mcastgrp
, &ipv6_hdr(skb
)->daddr
) &&
845 ipv6_addr_equal(&c
->mf6c_origin
, &ipv6_hdr(skb
)->saddr
))
851 * Create a new entry if allowable
854 if (atomic_read(&cache_resolve_queue_len
) >= 10 ||
855 (c
= ip6mr_cache_alloc_unres()) == NULL
) {
856 spin_unlock_bh(&mfc_unres_lock
);
863 * Fill in the new cache entry
866 c
->mf6c_origin
= ipv6_hdr(skb
)->saddr
;
867 c
->mf6c_mcastgrp
= ipv6_hdr(skb
)->daddr
;
870 * Reflect first query at pim6sd
872 if ((err
= ip6mr_cache_report(skb
, mifi
, MRT6MSG_NOCACHE
)) < 0) {
873 /* If the report failed throw the cache entry
876 spin_unlock_bh(&mfc_unres_lock
);
878 kmem_cache_free(mrt_cachep
, c
);
883 atomic_inc(&cache_resolve_queue_len
);
884 c
->next
= mfc_unres_queue
;
887 ipmr_do_expire_process(1);
891 * See if we can append the packet
893 if (c
->mfc_un
.unres
.unresolved
.qlen
> 3) {
897 skb_queue_tail(&c
->mfc_un
.unres
.unresolved
, skb
);
901 spin_unlock_bh(&mfc_unres_lock
);
906 * MFC6 cache manipulation by user space
909 static int ip6mr_mfc_delete(struct mf6cctl
*mfc
)
912 struct mfc6_cache
*c
, **cp
;
914 line
= MFC6_HASH(&mfc
->mf6cc_mcastgrp
.sin6_addr
, &mfc
->mf6cc_origin
.sin6_addr
);
916 for (cp
= &mfc6_cache_array
[line
]; (c
= *cp
) != NULL
; cp
= &c
->next
) {
917 if (ipv6_addr_equal(&c
->mf6c_origin
, &mfc
->mf6cc_origin
.sin6_addr
) &&
918 ipv6_addr_equal(&c
->mf6c_mcastgrp
, &mfc
->mf6cc_mcastgrp
.sin6_addr
)) {
919 write_lock_bh(&mrt_lock
);
921 write_unlock_bh(&mrt_lock
);
923 kmem_cache_free(mrt_cachep
, c
);
930 static int ip6mr_device_event(struct notifier_block
*this,
931 unsigned long event
, void *ptr
)
933 struct net_device
*dev
= ptr
;
934 struct mif_device
*v
;
937 if (!net_eq(dev_net(dev
), &init_net
))
940 if (event
!= NETDEV_UNREGISTER
)
944 for (ct
= 0; ct
< maxvif
; ct
++, v
++) {
951 static struct notifier_block ip6_mr_notifier
= {
952 .notifier_call
= ip6mr_device_event
956 * Setup for IP multicast routing
959 int __init
ip6_mr_init(void)
963 mrt_cachep
= kmem_cache_create("ip6_mrt_cache",
964 sizeof(struct mfc6_cache
),
965 0, SLAB_HWCACHE_ALIGN
,
970 setup_timer(&ipmr_expire_timer
, ipmr_expire_process
, 0);
971 err
= register_netdevice_notifier(&ip6_mr_notifier
);
974 #ifdef CONFIG_PROC_FS
976 if (!proc_net_fops_create(&init_net
, "ip6_mr_vif", 0, &ip6mr_vif_fops
))
978 if (!proc_net_fops_create(&init_net
, "ip6_mr_cache",
980 goto proc_cache_fail
;
984 kmem_cache_destroy(mrt_cachep
);
985 #ifdef CONFIG_PROC_FS
987 unregister_netdevice_notifier(&ip6_mr_notifier
);
989 proc_net_remove(&init_net
, "ip6_mr_vif");
994 void ip6_mr_cleanup(void)
996 #ifdef CONFIG_PROC_FS
997 proc_net_remove(&init_net
, "ip6_mr_cache");
998 proc_net_remove(&init_net
, "ip6_mr_vif");
1000 unregister_netdevice_notifier(&ip6_mr_notifier
);
1001 del_timer(&ipmr_expire_timer
);
1002 kmem_cache_destroy(mrt_cachep
);
1005 static int ip6mr_mfc_add(struct mf6cctl
*mfc
, int mrtsock
)
1008 struct mfc6_cache
*uc
, *c
, **cp
;
1009 unsigned char ttls
[MAXMIFS
];
1012 memset(ttls
, 255, MAXMIFS
);
1013 for (i
= 0; i
< MAXMIFS
; i
++) {
1014 if (IF_ISSET(i
, &mfc
->mf6cc_ifset
))
1019 line
= MFC6_HASH(&mfc
->mf6cc_mcastgrp
.sin6_addr
, &mfc
->mf6cc_origin
.sin6_addr
);
1021 for (cp
= &mfc6_cache_array
[line
]; (c
= *cp
) != NULL
; cp
= &c
->next
) {
1022 if (ipv6_addr_equal(&c
->mf6c_origin
, &mfc
->mf6cc_origin
.sin6_addr
) &&
1023 ipv6_addr_equal(&c
->mf6c_mcastgrp
, &mfc
->mf6cc_mcastgrp
.sin6_addr
))
1028 write_lock_bh(&mrt_lock
);
1029 c
->mf6c_parent
= mfc
->mf6cc_parent
;
1030 ip6mr_update_thresholds(c
, ttls
);
1032 c
->mfc_flags
|= MFC_STATIC
;
1033 write_unlock_bh(&mrt_lock
);
1037 if (!ipv6_addr_is_multicast(&mfc
->mf6cc_mcastgrp
.sin6_addr
))
1040 c
= ip6mr_cache_alloc();
1044 c
->mf6c_origin
= mfc
->mf6cc_origin
.sin6_addr
;
1045 c
->mf6c_mcastgrp
= mfc
->mf6cc_mcastgrp
.sin6_addr
;
1046 c
->mf6c_parent
= mfc
->mf6cc_parent
;
1047 ip6mr_update_thresholds(c
, ttls
);
1049 c
->mfc_flags
|= MFC_STATIC
;
1051 write_lock_bh(&mrt_lock
);
1052 c
->next
= mfc6_cache_array
[line
];
1053 mfc6_cache_array
[line
] = c
;
1054 write_unlock_bh(&mrt_lock
);
1057 * Check to see if we resolved a queued list. If so we
1058 * need to send on the frames and tidy up.
1060 spin_lock_bh(&mfc_unres_lock
);
1061 for (cp
= &mfc_unres_queue
; (uc
= *cp
) != NULL
;
1063 if (ipv6_addr_equal(&uc
->mf6c_origin
, &c
->mf6c_origin
) &&
1064 ipv6_addr_equal(&uc
->mf6c_mcastgrp
, &c
->mf6c_mcastgrp
)) {
1066 if (atomic_dec_and_test(&cache_resolve_queue_len
))
1067 del_timer(&ipmr_expire_timer
);
1071 spin_unlock_bh(&mfc_unres_lock
);
1074 ip6mr_cache_resolve(uc
, c
);
1075 kmem_cache_free(mrt_cachep
, uc
);
1081 * Close the multicast socket, and clear the vif tables etc
1084 static void mroute_clean_tables(struct sock
*sk
)
1089 * Shut down all active vif entries
1091 for (i
= 0; i
< maxvif
; i
++) {
1092 if (!(vif6_table
[i
].flags
& VIFF_STATIC
))
1099 for (i
= 0; i
< ARRAY_SIZE(mfc6_cache_array
); i
++) {
1100 struct mfc6_cache
*c
, **cp
;
1102 cp
= &mfc6_cache_array
[i
];
1103 while ((c
= *cp
) != NULL
) {
1104 if (c
->mfc_flags
& MFC_STATIC
) {
1108 write_lock_bh(&mrt_lock
);
1110 write_unlock_bh(&mrt_lock
);
1112 kmem_cache_free(mrt_cachep
, c
);
1116 if (atomic_read(&cache_resolve_queue_len
) != 0) {
1117 struct mfc6_cache
*c
;
1119 spin_lock_bh(&mfc_unres_lock
);
1120 while (mfc_unres_queue
!= NULL
) {
1121 c
= mfc_unres_queue
;
1122 mfc_unres_queue
= c
->next
;
1123 spin_unlock_bh(&mfc_unres_lock
);
1125 ip6mr_destroy_unres(c
);
1127 spin_lock_bh(&mfc_unres_lock
);
1129 spin_unlock_bh(&mfc_unres_lock
);
1133 static int ip6mr_sk_init(struct sock
*sk
)
1138 write_lock_bh(&mrt_lock
);
1139 if (likely(mroute6_socket
== NULL
))
1140 mroute6_socket
= sk
;
1143 write_unlock_bh(&mrt_lock
);
1150 int ip6mr_sk_done(struct sock
*sk
)
1155 if (sk
== mroute6_socket
) {
1156 write_lock_bh(&mrt_lock
);
1157 mroute6_socket
= NULL
;
1158 write_unlock_bh(&mrt_lock
);
1160 mroute_clean_tables(sk
);
1169 * Socket options and virtual interface manipulation. The whole
1170 * virtual interface system is a complete heap, but unfortunately
1171 * that's how BSD mrouted happens to think. Maybe one day with a proper
1172 * MOSPF/PIM router set up we can clean this up.
1175 int ip6_mroute_setsockopt(struct sock
*sk
, int optname
, char __user
*optval
, int optlen
)
1182 if (optname
!= MRT6_INIT
) {
1183 if (sk
!= mroute6_socket
&& !capable(CAP_NET_ADMIN
))
1189 if (sk
->sk_type
!= SOCK_RAW
||
1190 inet_sk(sk
)->num
!= IPPROTO_ICMPV6
)
1192 if (optlen
< sizeof(int))
1195 return ip6mr_sk_init(sk
);
1198 return ip6mr_sk_done(sk
);
1201 if (optlen
< sizeof(vif
))
1203 if (copy_from_user(&vif
, optval
, sizeof(vif
)))
1205 if (vif
.mif6c_mifi
>= MAXMIFS
)
1208 ret
= mif6_add(&vif
, sk
== mroute6_socket
);
1213 if (optlen
< sizeof(mifi_t
))
1215 if (copy_from_user(&mifi
, optval
, sizeof(mifi_t
)))
1218 ret
= mif6_delete(mifi
);
1223 * Manipulate the forwarding caches. These live
1224 * in a sort of kernel/user symbiosis.
1228 if (optlen
< sizeof(mfc
))
1230 if (copy_from_user(&mfc
, optval
, sizeof(mfc
)))
1233 if (optname
== MRT6_DEL_MFC
)
1234 ret
= ip6mr_mfc_delete(&mfc
);
1236 ret
= ip6mr_mfc_add(&mfc
, sk
== mroute6_socket
);
1241 * Control PIM assert (to activate pim will activate assert)
1246 if (get_user(v
, (int __user
*)optval
))
1248 mroute_do_assert
= !!v
;
1252 #ifdef CONFIG_IPV6_PIMSM_V2
1256 if (get_user(v
, (int __user
*)optval
))
1261 if (v
!= mroute_do_pim
) {
1263 mroute_do_assert
= v
;
1265 ret
= inet6_add_protocol(&pim6_protocol
,
1268 ret
= inet6_del_protocol(&pim6_protocol
,
1279 * Spurious command, or MRT6_VERSION which you cannot
1283 return -ENOPROTOOPT
;
1288 * Getsock opt support for the multicast routing system.
1291 int ip6_mroute_getsockopt(struct sock
*sk
, int optname
, char __user
*optval
,
1301 #ifdef CONFIG_IPV6_PIMSM_V2
1303 val
= mroute_do_pim
;
1307 val
= mroute_do_assert
;
1310 return -ENOPROTOOPT
;
1313 if (get_user(olr
, optlen
))
1316 olr
= min_t(int, olr
, sizeof(int));
1320 if (put_user(olr
, optlen
))
1322 if (copy_to_user(optval
, &val
, olr
))
1328 * The IP multicast ioctl support routines.
1331 int ip6mr_ioctl(struct sock
*sk
, int cmd
, void __user
*arg
)
1333 struct sioc_sg_req6 sr
;
1334 struct sioc_mif_req6 vr
;
1335 struct mif_device
*vif
;
1336 struct mfc6_cache
*c
;
1339 case SIOCGETMIFCNT_IN6
:
1340 if (copy_from_user(&vr
, arg
, sizeof(vr
)))
1342 if (vr
.mifi
>= maxvif
)
1344 read_lock(&mrt_lock
);
1345 vif
= &vif6_table
[vr
.mifi
];
1346 if (MIF_EXISTS(vr
.mifi
)) {
1347 vr
.icount
= vif
->pkt_in
;
1348 vr
.ocount
= vif
->pkt_out
;
1349 vr
.ibytes
= vif
->bytes_in
;
1350 vr
.obytes
= vif
->bytes_out
;
1351 read_unlock(&mrt_lock
);
1353 if (copy_to_user(arg
, &vr
, sizeof(vr
)))
1357 read_unlock(&mrt_lock
);
1358 return -EADDRNOTAVAIL
;
1359 case SIOCGETSGCNT_IN6
:
1360 if (copy_from_user(&sr
, arg
, sizeof(sr
)))
1363 read_lock(&mrt_lock
);
1364 c
= ip6mr_cache_find(&sr
.src
.sin6_addr
, &sr
.grp
.sin6_addr
);
1366 sr
.pktcnt
= c
->mfc_un
.res
.pkt
;
1367 sr
.bytecnt
= c
->mfc_un
.res
.bytes
;
1368 sr
.wrong_if
= c
->mfc_un
.res
.wrong_if
;
1369 read_unlock(&mrt_lock
);
1371 if (copy_to_user(arg
, &sr
, sizeof(sr
)))
1375 read_unlock(&mrt_lock
);
1376 return -EADDRNOTAVAIL
;
1378 return -ENOIOCTLCMD
;
1383 static inline int ip6mr_forward2_finish(struct sk_buff
*skb
)
1385 IP6_INC_STATS_BH(dev_net(skb
->dst
->dev
), ip6_dst_idev(skb
->dst
),
1386 IPSTATS_MIB_OUTFORWDATAGRAMS
);
1387 return dst_output(skb
);
1391 * Processing handlers for ip6mr_forward
1394 static int ip6mr_forward2(struct sk_buff
*skb
, struct mfc6_cache
*c
, int vifi
)
1396 struct ipv6hdr
*ipv6h
;
1397 struct mif_device
*vif
= &vif6_table
[vifi
];
1398 struct net_device
*dev
;
1399 struct dst_entry
*dst
;
1402 if (vif
->dev
== NULL
)
1405 #ifdef CONFIG_IPV6_PIMSM_V2
1406 if (vif
->flags
& MIFF_REGISTER
) {
1408 vif
->bytes_out
+= skb
->len
;
1409 vif
->dev
->stats
.tx_bytes
+= skb
->len
;
1410 vif
->dev
->stats
.tx_packets
++;
1411 ip6mr_cache_report(skb
, vifi
, MRT6MSG_WHOLEPKT
);
1417 ipv6h
= ipv6_hdr(skb
);
1419 fl
= (struct flowi
) {
1422 { .daddr
= ipv6h
->daddr
, }
1426 dst
= ip6_route_output(&init_net
, NULL
, &fl
);
1430 dst_release(skb
->dst
);
1434 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1435 * not only before forwarding, but after forwarding on all output
1436 * interfaces. It is clear, if mrouter runs a multicasting
1437 * program, it should receive packets not depending to what interface
1438 * program is joined.
1439 * If we will not make it, the program will have to join on all
1440 * interfaces. On the other hand, multihoming host (or router, but
1441 * not mrouter) cannot join to more than one interface - it will
1442 * result in receiving multiple packets.
1447 vif
->bytes_out
+= skb
->len
;
1449 /* We are about to write */
1450 /* XXX: extension headers? */
1451 if (skb_cow(skb
, sizeof(*ipv6h
) + LL_RESERVED_SPACE(dev
)))
1454 ipv6h
= ipv6_hdr(skb
);
1457 IP6CB(skb
)->flags
|= IP6SKB_FORWARDED
;
1459 return NF_HOOK(PF_INET6
, NF_INET_FORWARD
, skb
, skb
->dev
, dev
,
1460 ip6mr_forward2_finish
);
1467 static int ip6mr_find_vif(struct net_device
*dev
)
1470 for (ct
= maxvif
- 1; ct
>= 0; ct
--) {
1471 if (vif6_table
[ct
].dev
== dev
)
1477 static int ip6_mr_forward(struct sk_buff
*skb
, struct mfc6_cache
*cache
)
1482 vif
= cache
->mf6c_parent
;
1483 cache
->mfc_un
.res
.pkt
++;
1484 cache
->mfc_un
.res
.bytes
+= skb
->len
;
1487 * Wrong interface: drop packet and (maybe) send PIM assert.
1489 if (vif6_table
[vif
].dev
!= skb
->dev
) {
1492 cache
->mfc_un
.res
.wrong_if
++;
1493 true_vifi
= ip6mr_find_vif(skb
->dev
);
1495 if (true_vifi
>= 0 && mroute_do_assert
&&
1496 /* pimsm uses asserts, when switching from RPT to SPT,
1497 so that we cannot check that packet arrived on an oif.
1498 It is bad, but otherwise we would need to move pretty
1499 large chunk of pimd to kernel. Ough... --ANK
1501 (mroute_do_pim
|| cache
->mfc_un
.res
.ttls
[true_vifi
] < 255) &&
1503 cache
->mfc_un
.res
.last_assert
+ MFC_ASSERT_THRESH
)) {
1504 cache
->mfc_un
.res
.last_assert
= jiffies
;
1505 ip6mr_cache_report(skb
, true_vifi
, MRT6MSG_WRONGMIF
);
1510 vif6_table
[vif
].pkt_in
++;
1511 vif6_table
[vif
].bytes_in
+= skb
->len
;
1516 for (ct
= cache
->mfc_un
.res
.maxvif
- 1; ct
>= cache
->mfc_un
.res
.minvif
; ct
--) {
1517 if (ipv6_hdr(skb
)->hop_limit
> cache
->mfc_un
.res
.ttls
[ct
]) {
1519 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1521 ip6mr_forward2(skb2
, cache
, psend
);
1527 ip6mr_forward2(skb
, cache
, psend
);
1538 * Multicast packets for forwarding arrive here
1541 int ip6_mr_input(struct sk_buff
*skb
)
1543 struct mfc6_cache
*cache
;
1545 read_lock(&mrt_lock
);
1546 cache
= ip6mr_cache_find(&ipv6_hdr(skb
)->saddr
, &ipv6_hdr(skb
)->daddr
);
1549 * No usable cache entry
1551 if (cache
== NULL
) {
1554 vif
= ip6mr_find_vif(skb
->dev
);
1556 int err
= ip6mr_cache_unresolved(vif
, skb
);
1557 read_unlock(&mrt_lock
);
1561 read_unlock(&mrt_lock
);
1566 ip6_mr_forward(skb
, cache
);
1568 read_unlock(&mrt_lock
);
1575 ip6mr_fill_mroute(struct sk_buff
*skb
, struct mfc6_cache
*c
, struct rtmsg
*rtm
)
1578 struct rtnexthop
*nhp
;
1579 struct net_device
*dev
= vif6_table
[c
->mf6c_parent
].dev
;
1580 u8
*b
= skb_tail_pointer(skb
);
1581 struct rtattr
*mp_head
;
1584 RTA_PUT(skb
, RTA_IIF
, 4, &dev
->ifindex
);
1586 mp_head
= (struct rtattr
*)skb_put(skb
, RTA_LENGTH(0));
1588 for (ct
= c
->mfc_un
.res
.minvif
; ct
< c
->mfc_un
.res
.maxvif
; ct
++) {
1589 if (c
->mfc_un
.res
.ttls
[ct
] < 255) {
1590 if (skb_tailroom(skb
) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp
)) + 4))
1591 goto rtattr_failure
;
1592 nhp
= (struct rtnexthop
*)skb_put(skb
, RTA_ALIGN(sizeof(*nhp
)));
1593 nhp
->rtnh_flags
= 0;
1594 nhp
->rtnh_hops
= c
->mfc_un
.res
.ttls
[ct
];
1595 nhp
->rtnh_ifindex
= vif6_table
[ct
].dev
->ifindex
;
1596 nhp
->rtnh_len
= sizeof(*nhp
);
1599 mp_head
->rta_type
= RTA_MULTIPATH
;
1600 mp_head
->rta_len
= skb_tail_pointer(skb
) - (u8
*)mp_head
;
1601 rtm
->rtm_type
= RTN_MULTICAST
;
1609 int ip6mr_get_route(struct sk_buff
*skb
, struct rtmsg
*rtm
, int nowait
)
1612 struct mfc6_cache
*cache
;
1613 struct rt6_info
*rt
= (struct rt6_info
*)skb
->dst
;
1615 read_lock(&mrt_lock
);
1616 cache
= ip6mr_cache_find(&rt
->rt6i_src
.addr
, &rt
->rt6i_dst
.addr
);
1619 struct sk_buff
*skb2
;
1620 struct ipv6hdr
*iph
;
1621 struct net_device
*dev
;
1625 read_unlock(&mrt_lock
);
1630 if (dev
== NULL
|| (vif
= ip6mr_find_vif(dev
)) < 0) {
1631 read_unlock(&mrt_lock
);
1635 /* really correct? */
1636 skb2
= alloc_skb(sizeof(struct ipv6hdr
), GFP_ATOMIC
);
1638 read_unlock(&mrt_lock
);
1642 skb_reset_transport_header(skb2
);
1644 skb_put(skb2
, sizeof(struct ipv6hdr
));
1645 skb_reset_network_header(skb2
);
1647 iph
= ipv6_hdr(skb2
);
1650 iph
->flow_lbl
[0] = 0;
1651 iph
->flow_lbl
[1] = 0;
1652 iph
->flow_lbl
[2] = 0;
1653 iph
->payload_len
= 0;
1654 iph
->nexthdr
= IPPROTO_NONE
;
1656 ipv6_addr_copy(&iph
->saddr
, &rt
->rt6i_src
.addr
);
1657 ipv6_addr_copy(&iph
->daddr
, &rt
->rt6i_dst
.addr
);
1659 err
= ip6mr_cache_unresolved(vif
, skb2
);
1660 read_unlock(&mrt_lock
);
1665 if (!nowait
&& (rtm
->rtm_flags
&RTM_F_NOTIFY
))
1666 cache
->mfc_flags
|= MFC_NOTIFY
;
1668 err
= ip6mr_fill_mroute(skb
, cache
, rtm
);
1669 read_unlock(&mrt_lock
);