2 * IP multicast routing support for mrouted 3.6/3.8
4 * (c) 1995 Alan Cox, <alan@redhat.com>
5 * Linux Consultancy and Custom Driver Development
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
12 * Version: $Id: ipmr.c,v 1.65 2001/10/31 21:55:54 davem Exp $
15 * Michael Chastain : Incorrect size of copying.
16 * Alan Cox : Added the cache manager code
17 * Alan Cox : Fixed the clone/copy bug and device race.
18 * Mike McLagan : Routing by source
19 * Malcolm Beattie : Buffer handling fixes.
20 * Alexey Kuznetsov : Double buffer free and other fixes.
21 * SVR Anand : Fixed several multicast bugs and problems.
22 * Alexey Kuznetsov : Status, optimisations and more.
23 * Brad Parker : Better behaviour on mrouted upcall
25 * Carlos Picoto : PIMv1 Support
26 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
27 * Relax this requrement to work with older peers.
31 #include <asm/system.h>
32 #include <asm/uaccess.h>
33 #include <linux/types.h>
34 #include <linux/capability.h>
35 #include <linux/errno.h>
36 #include <linux/timer.h>
38 #include <linux/kernel.h>
39 #include <linux/fcntl.h>
40 #include <linux/stat.h>
41 #include <linux/socket.h>
43 #include <linux/inet.h>
44 #include <linux/netdevice.h>
45 #include <linux/inetdevice.h>
46 #include <linux/igmp.h>
47 #include <linux/proc_fs.h>
48 #include <linux/seq_file.h>
49 #include <linux/mroute.h>
50 #include <linux/init.h>
51 #include <linux/if_ether.h>
53 #include <net/protocol.h>
54 #include <linux/skbuff.h>
55 #include <net/route.h>
60 #include <linux/notifier.h>
61 #include <linux/if_arp.h>
62 #include <linux/netfilter_ipv4.h>
64 #include <net/checksum.h>
66 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
67 #define CONFIG_IP_PIMSM 1
70 static struct sock
*mroute_socket
;
73 /* Big lock, protecting vif table, mrt cache and mroute socket state.
74 Note that the changes are semaphored via rtnl_lock.
77 static DEFINE_RWLOCK(mrt_lock
);
80 * Multicast router control variables
83 static struct vif_device vif_table
[MAXVIFS
]; /* Devices */
86 #define VIF_EXISTS(idx) (vif_table[idx].dev != NULL)
88 static int mroute_do_assert
; /* Set in PIM assert */
89 static int mroute_do_pim
;
91 static struct mfc_cache
*mfc_cache_array
[MFC_LINES
]; /* Forwarding cache */
93 static struct mfc_cache
*mfc_unres_queue
; /* Queue of unresolved entries */
94 static atomic_t cache_resolve_queue_len
; /* Size of unresolved */
96 /* Special spinlock for queue of unresolved entries */
97 static DEFINE_SPINLOCK(mfc_unres_lock
);
99 /* We return to original Alan's scheme. Hash table of resolved
100 entries is changed only in process context and protected
101 with weak lock mrt_lock. Queue of unresolved entries is protected
102 with strong spinlock mfc_unres_lock.
104 In this case data path is free of exclusive locks at all.
107 static struct kmem_cache
*mrt_cachep __read_mostly
;
109 static int ip_mr_forward(struct sk_buff
*skb
, struct mfc_cache
*cache
, int local
);
110 static int ipmr_cache_report(struct sk_buff
*pkt
, vifi_t vifi
, int assert);
111 static int ipmr_fill_mroute(struct sk_buff
*skb
, struct mfc_cache
*c
, struct rtmsg
*rtm
);
113 #ifdef CONFIG_IP_PIMSM_V2
114 static struct net_protocol pim_protocol
;
117 static struct timer_list ipmr_expire_timer
;
119 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
122 struct net_device
*ipmr_new_tunnel(struct vifctl
*v
)
124 struct net_device
*dev
;
126 dev
= __dev_get_by_name("tunl0");
132 struct ip_tunnel_parm p
;
133 struct in_device
*in_dev
;
135 memset(&p
, 0, sizeof(p
));
136 p
.iph
.daddr
= v
->vifc_rmt_addr
.s_addr
;
137 p
.iph
.saddr
= v
->vifc_lcl_addr
.s_addr
;
140 p
.iph
.protocol
= IPPROTO_IPIP
;
141 sprintf(p
.name
, "dvmrp%d", v
->vifc_vifi
);
142 ifr
.ifr_ifru
.ifru_data
= (void*)&p
;
144 oldfs
= get_fs(); set_fs(KERNEL_DS
);
145 err
= dev
->do_ioctl(dev
, &ifr
, SIOCADDTUNNEL
);
150 if (err
== 0 && (dev
= __dev_get_by_name(p
.name
)) != NULL
) {
151 dev
->flags
|= IFF_MULTICAST
;
153 in_dev
= __in_dev_get_rtnl(dev
);
154 if (in_dev
== NULL
&& (in_dev
= inetdev_init(dev
)) == NULL
)
156 in_dev
->cnf
.rp_filter
= 0;
165 /* allow the register to be completed before unregistering. */
169 unregister_netdevice(dev
);
173 #ifdef CONFIG_IP_PIMSM
175 static int reg_vif_num
= -1;
177 static int reg_vif_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
179 read_lock(&mrt_lock
);
180 ((struct net_device_stats
*)netdev_priv(dev
))->tx_bytes
+= skb
->len
;
181 ((struct net_device_stats
*)netdev_priv(dev
))->tx_packets
++;
182 ipmr_cache_report(skb
, reg_vif_num
, IGMPMSG_WHOLEPKT
);
183 read_unlock(&mrt_lock
);
188 static struct net_device_stats
*reg_vif_get_stats(struct net_device
*dev
)
190 return (struct net_device_stats
*)netdev_priv(dev
);
193 static void reg_vif_setup(struct net_device
*dev
)
195 dev
->type
= ARPHRD_PIMREG
;
196 dev
->mtu
= ETH_DATA_LEN
- sizeof(struct iphdr
) - 8;
197 dev
->flags
= IFF_NOARP
;
198 dev
->hard_start_xmit
= reg_vif_xmit
;
199 dev
->get_stats
= reg_vif_get_stats
;
200 dev
->destructor
= free_netdev
;
203 static struct net_device
*ipmr_reg_vif(void)
205 struct net_device
*dev
;
206 struct in_device
*in_dev
;
208 dev
= alloc_netdev(sizeof(struct net_device_stats
), "pimreg",
214 if (register_netdevice(dev
)) {
220 if ((in_dev
= inetdev_init(dev
)) == NULL
)
223 in_dev
->cnf
.rp_filter
= 0;
231 /* allow the register to be completed before unregistering. */
235 unregister_netdevice(dev
);
244 static int vif_delete(int vifi
)
246 struct vif_device
*v
;
247 struct net_device
*dev
;
248 struct in_device
*in_dev
;
250 if (vifi
< 0 || vifi
>= maxvif
)
251 return -EADDRNOTAVAIL
;
253 v
= &vif_table
[vifi
];
255 write_lock_bh(&mrt_lock
);
260 write_unlock_bh(&mrt_lock
);
261 return -EADDRNOTAVAIL
;
264 #ifdef CONFIG_IP_PIMSM
265 if (vifi
== reg_vif_num
)
269 if (vifi
+1 == maxvif
) {
271 for (tmp
=vifi
-1; tmp
>=0; tmp
--) {
278 write_unlock_bh(&mrt_lock
);
280 dev_set_allmulti(dev
, -1);
282 if ((in_dev
= __in_dev_get_rtnl(dev
)) != NULL
) {
283 in_dev
->cnf
.mc_forwarding
--;
284 ip_rt_multicast_event(in_dev
);
287 if (v
->flags
&(VIFF_TUNNEL
|VIFF_REGISTER
))
288 unregister_netdevice(dev
);
294 /* Destroy an unresolved cache entry, killing queued skbs
295 and reporting error to netlink readers.
298 static void ipmr_destroy_unres(struct mfc_cache
*c
)
303 atomic_dec(&cache_resolve_queue_len
);
305 while ((skb
=skb_dequeue(&c
->mfc_un
.unres
.unresolved
))) {
306 if (ip_hdr(skb
)->version
== 0) {
307 struct nlmsghdr
*nlh
= (struct nlmsghdr
*)skb_pull(skb
, sizeof(struct iphdr
));
308 nlh
->nlmsg_type
= NLMSG_ERROR
;
309 nlh
->nlmsg_len
= NLMSG_LENGTH(sizeof(struct nlmsgerr
));
310 skb_trim(skb
, nlh
->nlmsg_len
);
312 e
->error
= -ETIMEDOUT
;
313 memset(&e
->msg
, 0, sizeof(e
->msg
));
315 rtnl_unicast(skb
, NETLINK_CB(skb
).pid
);
320 kmem_cache_free(mrt_cachep
, c
);
324 /* Single timer process for all the unresolved queue. */
326 static void ipmr_expire_process(unsigned long dummy
)
329 unsigned long expires
;
330 struct mfc_cache
*c
, **cp
;
332 if (!spin_trylock(&mfc_unres_lock
)) {
333 mod_timer(&ipmr_expire_timer
, jiffies
+HZ
/10);
337 if (atomic_read(&cache_resolve_queue_len
) == 0)
342 cp
= &mfc_unres_queue
;
344 while ((c
=*cp
) != NULL
) {
345 if (time_after(c
->mfc_un
.unres
.expires
, now
)) {
346 unsigned long interval
= c
->mfc_un
.unres
.expires
- now
;
347 if (interval
< expires
)
355 ipmr_destroy_unres(c
);
358 if (atomic_read(&cache_resolve_queue_len
))
359 mod_timer(&ipmr_expire_timer
, jiffies
+ expires
);
362 spin_unlock(&mfc_unres_lock
);
365 /* Fill oifs list. It is called under write locked mrt_lock. */
367 static void ipmr_update_thresholds(struct mfc_cache
*cache
, unsigned char *ttls
)
371 cache
->mfc_un
.res
.minvif
= MAXVIFS
;
372 cache
->mfc_un
.res
.maxvif
= 0;
373 memset(cache
->mfc_un
.res
.ttls
, 255, MAXVIFS
);
375 for (vifi
=0; vifi
<maxvif
; vifi
++) {
376 if (VIF_EXISTS(vifi
) && ttls
[vifi
] && ttls
[vifi
] < 255) {
377 cache
->mfc_un
.res
.ttls
[vifi
] = ttls
[vifi
];
378 if (cache
->mfc_un
.res
.minvif
> vifi
)
379 cache
->mfc_un
.res
.minvif
= vifi
;
380 if (cache
->mfc_un
.res
.maxvif
<= vifi
)
381 cache
->mfc_un
.res
.maxvif
= vifi
+ 1;
386 static int vif_add(struct vifctl
*vifc
, int mrtsock
)
388 int vifi
= vifc
->vifc_vifi
;
389 struct vif_device
*v
= &vif_table
[vifi
];
390 struct net_device
*dev
;
391 struct in_device
*in_dev
;
394 if (VIF_EXISTS(vifi
))
397 switch (vifc
->vifc_flags
) {
398 #ifdef CONFIG_IP_PIMSM
401 * Special Purpose VIF in PIM
402 * All the packets will be sent to the daemon
404 if (reg_vif_num
>= 0)
406 dev
= ipmr_reg_vif();
412 dev
= ipmr_new_tunnel(vifc
);
417 dev
= ip_dev_find(vifc
->vifc_lcl_addr
.s_addr
);
419 return -EADDRNOTAVAIL
;
426 if ((in_dev
= __in_dev_get_rtnl(dev
)) == NULL
)
427 return -EADDRNOTAVAIL
;
428 in_dev
->cnf
.mc_forwarding
++;
429 dev_set_allmulti(dev
, +1);
430 ip_rt_multicast_event(in_dev
);
433 * Fill in the VIF structures
435 v
->rate_limit
=vifc
->vifc_rate_limit
;
436 v
->local
=vifc
->vifc_lcl_addr
.s_addr
;
437 v
->remote
=vifc
->vifc_rmt_addr
.s_addr
;
438 v
->flags
=vifc
->vifc_flags
;
440 v
->flags
|= VIFF_STATIC
;
441 v
->threshold
=vifc
->vifc_threshold
;
446 v
->link
= dev
->ifindex
;
447 if (v
->flags
&(VIFF_TUNNEL
|VIFF_REGISTER
))
448 v
->link
= dev
->iflink
;
450 /* And finish update writing critical data */
451 write_lock_bh(&mrt_lock
);
454 #ifdef CONFIG_IP_PIMSM
455 if (v
->flags
&VIFF_REGISTER
)
460 write_unlock_bh(&mrt_lock
);
464 static struct mfc_cache
*ipmr_cache_find(__be32 origin
, __be32 mcastgrp
)
466 int line
=MFC_HASH(mcastgrp
,origin
);
469 for (c
=mfc_cache_array
[line
]; c
; c
= c
->next
) {
470 if (c
->mfc_origin
==origin
&& c
->mfc_mcastgrp
==mcastgrp
)
477 * Allocate a multicast cache entry
479 static struct mfc_cache
*ipmr_cache_alloc(void)
481 struct mfc_cache
*c
=kmem_cache_zalloc(mrt_cachep
, GFP_KERNEL
);
484 c
->mfc_un
.res
.minvif
= MAXVIFS
;
488 static struct mfc_cache
*ipmr_cache_alloc_unres(void)
490 struct mfc_cache
*c
=kmem_cache_zalloc(mrt_cachep
, GFP_ATOMIC
);
493 skb_queue_head_init(&c
->mfc_un
.unres
.unresolved
);
494 c
->mfc_un
.unres
.expires
= jiffies
+ 10*HZ
;
499 * A cache entry has gone into a resolved state from queued
502 static void ipmr_cache_resolve(struct mfc_cache
*uc
, struct mfc_cache
*c
)
508 * Play the pending entries through our router
511 while ((skb
=__skb_dequeue(&uc
->mfc_un
.unres
.unresolved
))) {
512 if (ip_hdr(skb
)->version
== 0) {
513 struct nlmsghdr
*nlh
= (struct nlmsghdr
*)skb_pull(skb
, sizeof(struct iphdr
));
515 if (ipmr_fill_mroute(skb
, c
, NLMSG_DATA(nlh
)) > 0) {
516 nlh
->nlmsg_len
= (skb_tail_pointer(skb
) -
519 nlh
->nlmsg_type
= NLMSG_ERROR
;
520 nlh
->nlmsg_len
= NLMSG_LENGTH(sizeof(struct nlmsgerr
));
521 skb_trim(skb
, nlh
->nlmsg_len
);
523 e
->error
= -EMSGSIZE
;
524 memset(&e
->msg
, 0, sizeof(e
->msg
));
527 rtnl_unicast(skb
, NETLINK_CB(skb
).pid
);
529 ip_mr_forward(skb
, c
, 0);
534 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
535 * expects the following bizarre scheme.
537 * Called under mrt_lock.
540 static int ipmr_cache_report(struct sk_buff
*pkt
, vifi_t vifi
, int assert)
543 const int ihl
= ip_hdrlen(pkt
);
544 struct igmphdr
*igmp
;
548 #ifdef CONFIG_IP_PIMSM
549 if (assert == IGMPMSG_WHOLEPKT
)
550 skb
= skb_realloc_headroom(pkt
, sizeof(struct iphdr
));
553 skb
= alloc_skb(128, GFP_ATOMIC
);
558 #ifdef CONFIG_IP_PIMSM
559 if (assert == IGMPMSG_WHOLEPKT
) {
560 /* Ugly, but we have no choice with this interface.
561 Duplicate old header, fix ihl, length etc.
562 And all this only to mangle msg->im_msgtype and
563 to set msg->im_mbz to "mbz" :-)
565 skb_push(skb
, sizeof(struct iphdr
));
566 skb_reset_network_header(skb
);
567 skb_reset_transport_header(skb
);
568 msg
= (struct igmpmsg
*)skb_network_header(skb
);
569 memcpy(msg
, skb_network_header(pkt
), sizeof(struct iphdr
));
570 msg
->im_msgtype
= IGMPMSG_WHOLEPKT
;
572 msg
->im_vif
= reg_vif_num
;
573 ip_hdr(skb
)->ihl
= sizeof(struct iphdr
) >> 2;
574 ip_hdr(skb
)->tot_len
= htons(ntohs(ip_hdr(pkt
)->tot_len
) +
575 sizeof(struct iphdr
));
584 skb
->network_header
= skb
->tail
;
586 memcpy(skb
->data
,pkt
->data
,ihl
);
587 ip_hdr(skb
)->protocol
= 0; /* Flag to the kernel this is a route add */
588 msg
= (struct igmpmsg
*)skb_network_header(skb
);
590 skb
->dst
= dst_clone(pkt
->dst
);
596 igmp
=(struct igmphdr
*)skb_put(skb
,sizeof(struct igmphdr
));
598 msg
->im_msgtype
= assert;
600 ip_hdr(skb
)->tot_len
= htons(skb
->len
); /* Fix the length */
601 skb
->transport_header
= skb
->network_header
;
604 if (mroute_socket
== NULL
) {
612 if ((ret
=sock_queue_rcv_skb(mroute_socket
,skb
))<0) {
614 printk(KERN_WARNING
"mroute: pending queue full, dropping entries.\n");
622 * Queue a packet for resolution. It gets locked cache entry!
626 ipmr_cache_unresolved(vifi_t vifi
, struct sk_buff
*skb
)
630 const struct iphdr
*iph
= ip_hdr(skb
);
632 spin_lock_bh(&mfc_unres_lock
);
633 for (c
=mfc_unres_queue
; c
; c
=c
->next
) {
634 if (c
->mfc_mcastgrp
== iph
->daddr
&&
635 c
->mfc_origin
== iph
->saddr
)
641 * Create a new entry if allowable
644 if (atomic_read(&cache_resolve_queue_len
)>=10 ||
645 (c
=ipmr_cache_alloc_unres())==NULL
) {
646 spin_unlock_bh(&mfc_unres_lock
);
653 * Fill in the new cache entry
656 c
->mfc_origin
= iph
->saddr
;
657 c
->mfc_mcastgrp
= iph
->daddr
;
660 * Reflect first query at mrouted.
662 if ((err
= ipmr_cache_report(skb
, vifi
, IGMPMSG_NOCACHE
))<0) {
663 /* If the report failed throw the cache entry
666 spin_unlock_bh(&mfc_unres_lock
);
668 kmem_cache_free(mrt_cachep
, c
);
673 atomic_inc(&cache_resolve_queue_len
);
674 c
->next
= mfc_unres_queue
;
677 mod_timer(&ipmr_expire_timer
, c
->mfc_un
.unres
.expires
);
681 * See if we can append the packet
683 if (c
->mfc_un
.unres
.unresolved
.qlen
>3) {
687 skb_queue_tail(&c
->mfc_un
.unres
.unresolved
,skb
);
691 spin_unlock_bh(&mfc_unres_lock
);
696 * MFC cache manipulation by user space mroute daemon
699 static int ipmr_mfc_delete(struct mfcctl
*mfc
)
702 struct mfc_cache
*c
, **cp
;
704 line
=MFC_HASH(mfc
->mfcc_mcastgrp
.s_addr
, mfc
->mfcc_origin
.s_addr
);
706 for (cp
=&mfc_cache_array
[line
]; (c
=*cp
) != NULL
; cp
= &c
->next
) {
707 if (c
->mfc_origin
== mfc
->mfcc_origin
.s_addr
&&
708 c
->mfc_mcastgrp
== mfc
->mfcc_mcastgrp
.s_addr
) {
709 write_lock_bh(&mrt_lock
);
711 write_unlock_bh(&mrt_lock
);
713 kmem_cache_free(mrt_cachep
, c
);
720 static int ipmr_mfc_add(struct mfcctl
*mfc
, int mrtsock
)
723 struct mfc_cache
*uc
, *c
, **cp
;
725 line
=MFC_HASH(mfc
->mfcc_mcastgrp
.s_addr
, mfc
->mfcc_origin
.s_addr
);
727 for (cp
=&mfc_cache_array
[line
]; (c
=*cp
) != NULL
; cp
= &c
->next
) {
728 if (c
->mfc_origin
== mfc
->mfcc_origin
.s_addr
&&
729 c
->mfc_mcastgrp
== mfc
->mfcc_mcastgrp
.s_addr
)
734 write_lock_bh(&mrt_lock
);
735 c
->mfc_parent
= mfc
->mfcc_parent
;
736 ipmr_update_thresholds(c
, mfc
->mfcc_ttls
);
738 c
->mfc_flags
|= MFC_STATIC
;
739 write_unlock_bh(&mrt_lock
);
743 if (!MULTICAST(mfc
->mfcc_mcastgrp
.s_addr
))
746 c
=ipmr_cache_alloc();
750 c
->mfc_origin
=mfc
->mfcc_origin
.s_addr
;
751 c
->mfc_mcastgrp
=mfc
->mfcc_mcastgrp
.s_addr
;
752 c
->mfc_parent
=mfc
->mfcc_parent
;
753 ipmr_update_thresholds(c
, mfc
->mfcc_ttls
);
755 c
->mfc_flags
|= MFC_STATIC
;
757 write_lock_bh(&mrt_lock
);
758 c
->next
= mfc_cache_array
[line
];
759 mfc_cache_array
[line
] = c
;
760 write_unlock_bh(&mrt_lock
);
763 * Check to see if we resolved a queued list. If so we
764 * need to send on the frames and tidy up.
766 spin_lock_bh(&mfc_unres_lock
);
767 for (cp
= &mfc_unres_queue
; (uc
=*cp
) != NULL
;
769 if (uc
->mfc_origin
== c
->mfc_origin
&&
770 uc
->mfc_mcastgrp
== c
->mfc_mcastgrp
) {
772 if (atomic_dec_and_test(&cache_resolve_queue_len
))
773 del_timer(&ipmr_expire_timer
);
777 spin_unlock_bh(&mfc_unres_lock
);
780 ipmr_cache_resolve(uc
, c
);
781 kmem_cache_free(mrt_cachep
, uc
);
787 * Close the multicast socket, and clear the vif tables etc
790 static void mroute_clean_tables(struct sock
*sk
)
795 * Shut down all active vif entries
797 for (i
=0; i
<maxvif
; i
++) {
798 if (!(vif_table
[i
].flags
&VIFF_STATIC
))
805 for (i
=0;i
<MFC_LINES
;i
++) {
806 struct mfc_cache
*c
, **cp
;
808 cp
= &mfc_cache_array
[i
];
809 while ((c
= *cp
) != NULL
) {
810 if (c
->mfc_flags
&MFC_STATIC
) {
814 write_lock_bh(&mrt_lock
);
816 write_unlock_bh(&mrt_lock
);
818 kmem_cache_free(mrt_cachep
, c
);
822 if (atomic_read(&cache_resolve_queue_len
) != 0) {
825 spin_lock_bh(&mfc_unres_lock
);
826 while (mfc_unres_queue
!= NULL
) {
828 mfc_unres_queue
= c
->next
;
829 spin_unlock_bh(&mfc_unres_lock
);
831 ipmr_destroy_unres(c
);
833 spin_lock_bh(&mfc_unres_lock
);
835 spin_unlock_bh(&mfc_unres_lock
);
839 static void mrtsock_destruct(struct sock
*sk
)
842 if (sk
== mroute_socket
) {
843 ipv4_devconf
.mc_forwarding
--;
845 write_lock_bh(&mrt_lock
);
847 write_unlock_bh(&mrt_lock
);
849 mroute_clean_tables(sk
);
855 * Socket options and virtual interface manipulation. The whole
856 * virtual interface system is a complete heap, but unfortunately
857 * that's how BSD mrouted happens to think. Maybe one day with a proper
858 * MOSPF/PIM router set up we can clean this up.
861 int ip_mroute_setsockopt(struct sock
*sk
,int optname
,char __user
*optval
,int optlen
)
867 if (optname
!= MRT_INIT
) {
868 if (sk
!= mroute_socket
&& !capable(CAP_NET_ADMIN
))
874 if (sk
->sk_type
!= SOCK_RAW
||
875 inet_sk(sk
)->num
!= IPPROTO_IGMP
)
877 if (optlen
!=sizeof(int))
886 ret
= ip_ra_control(sk
, 1, mrtsock_destruct
);
888 write_lock_bh(&mrt_lock
);
890 write_unlock_bh(&mrt_lock
);
892 ipv4_devconf
.mc_forwarding
++;
897 if (sk
!=mroute_socket
)
899 return ip_ra_control(sk
, 0, NULL
);
902 if (optlen
!=sizeof(vif
))
904 if (copy_from_user(&vif
,optval
,sizeof(vif
)))
906 if (vif
.vifc_vifi
>= MAXVIFS
)
909 if (optname
==MRT_ADD_VIF
) {
910 ret
= vif_add(&vif
, sk
==mroute_socket
);
912 ret
= vif_delete(vif
.vifc_vifi
);
918 * Manipulate the forwarding caches. These live
919 * in a sort of kernel/user symbiosis.
923 if (optlen
!=sizeof(mfc
))
925 if (copy_from_user(&mfc
,optval
, sizeof(mfc
)))
928 if (optname
==MRT_DEL_MFC
)
929 ret
= ipmr_mfc_delete(&mfc
);
931 ret
= ipmr_mfc_add(&mfc
, sk
==mroute_socket
);
935 * Control PIM assert.
940 if (get_user(v
,(int __user
*)optval
))
942 mroute_do_assert
=(v
)?1:0;
945 #ifdef CONFIG_IP_PIMSM
949 if (get_user(v
,(int __user
*)optval
))
954 if (v
!= mroute_do_pim
) {
956 mroute_do_assert
= v
;
957 #ifdef CONFIG_IP_PIMSM_V2
959 ret
= inet_add_protocol(&pim_protocol
,
962 ret
= inet_del_protocol(&pim_protocol
,
973 * Spurious command, or MRT_VERSION which you cannot
982 * Getsock opt support for the multicast routing system.
985 int ip_mroute_getsockopt(struct sock
*sk
,int optname
,char __user
*optval
,int __user
*optlen
)
990 if (optname
!=MRT_VERSION
&&
991 #ifdef CONFIG_IP_PIMSM
997 if (get_user(olr
, optlen
))
1000 olr
= min_t(unsigned int, olr
, sizeof(int));
1004 if (put_user(olr
,optlen
))
1006 if (optname
==MRT_VERSION
)
1008 #ifdef CONFIG_IP_PIMSM
1009 else if (optname
==MRT_PIM
)
1013 val
=mroute_do_assert
;
1014 if (copy_to_user(optval
,&val
,olr
))
1020 * The IP multicast ioctl support routines.
1023 int ipmr_ioctl(struct sock
*sk
, int cmd
, void __user
*arg
)
1025 struct sioc_sg_req sr
;
1026 struct sioc_vif_req vr
;
1027 struct vif_device
*vif
;
1028 struct mfc_cache
*c
;
1032 if (copy_from_user(&vr
,arg
,sizeof(vr
)))
1034 if (vr
.vifi
>=maxvif
)
1036 read_lock(&mrt_lock
);
1037 vif
=&vif_table
[vr
.vifi
];
1038 if (VIF_EXISTS(vr
.vifi
)) {
1039 vr
.icount
=vif
->pkt_in
;
1040 vr
.ocount
=vif
->pkt_out
;
1041 vr
.ibytes
=vif
->bytes_in
;
1042 vr
.obytes
=vif
->bytes_out
;
1043 read_unlock(&mrt_lock
);
1045 if (copy_to_user(arg
,&vr
,sizeof(vr
)))
1049 read_unlock(&mrt_lock
);
1050 return -EADDRNOTAVAIL
;
1052 if (copy_from_user(&sr
,arg
,sizeof(sr
)))
1055 read_lock(&mrt_lock
);
1056 c
= ipmr_cache_find(sr
.src
.s_addr
, sr
.grp
.s_addr
);
1058 sr
.pktcnt
= c
->mfc_un
.res
.pkt
;
1059 sr
.bytecnt
= c
->mfc_un
.res
.bytes
;
1060 sr
.wrong_if
= c
->mfc_un
.res
.wrong_if
;
1061 read_unlock(&mrt_lock
);
1063 if (copy_to_user(arg
,&sr
,sizeof(sr
)))
1067 read_unlock(&mrt_lock
);
1068 return -EADDRNOTAVAIL
;
1070 return -ENOIOCTLCMD
;
1075 static int ipmr_device_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1077 struct vif_device
*v
;
1079 if (event
!= NETDEV_UNREGISTER
)
1082 for (ct
=0;ct
<maxvif
;ct
++,v
++) {
1090 static struct notifier_block ip_mr_notifier
={
1091 .notifier_call
= ipmr_device_event
,
1095 * Encapsulate a packet by attaching a valid IPIP header to it.
1096 * This avoids tunnel drivers and other mess and gives us the speed so
1097 * important for multicast video.
1100 static void ip_encap(struct sk_buff
*skb
, __be32 saddr
, __be32 daddr
)
1103 struct iphdr
*old_iph
= ip_hdr(skb
);
1105 skb_push(skb
, sizeof(struct iphdr
));
1106 skb
->transport_header
= skb
->network_header
;
1107 skb_reset_network_header(skb
);
1111 iph
->tos
= old_iph
->tos
;
1112 iph
->ttl
= old_iph
->ttl
;
1116 iph
->protocol
= IPPROTO_IPIP
;
1118 iph
->tot_len
= htons(skb
->len
);
1119 ip_select_ident(iph
, skb
->dst
, NULL
);
1122 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
1126 static inline int ipmr_forward_finish(struct sk_buff
*skb
)
1128 struct ip_options
* opt
= &(IPCB(skb
)->opt
);
1130 IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS
);
1132 if (unlikely(opt
->optlen
))
1133 ip_forward_options(skb
);
1135 return dst_output(skb
);
1139 * Processing handlers for ipmr_forward
1142 static void ipmr_queue_xmit(struct sk_buff
*skb
, struct mfc_cache
*c
, int vifi
)
1144 const struct iphdr
*iph
= ip_hdr(skb
);
1145 struct vif_device
*vif
= &vif_table
[vifi
];
1146 struct net_device
*dev
;
1150 if (vif
->dev
== NULL
)
1153 #ifdef CONFIG_IP_PIMSM
1154 if (vif
->flags
& VIFF_REGISTER
) {
1156 vif
->bytes_out
+=skb
->len
;
1157 ((struct net_device_stats
*)netdev_priv(vif
->dev
))->tx_bytes
+= skb
->len
;
1158 ((struct net_device_stats
*)netdev_priv(vif
->dev
))->tx_packets
++;
1159 ipmr_cache_report(skb
, vifi
, IGMPMSG_WHOLEPKT
);
1165 if (vif
->flags
&VIFF_TUNNEL
) {
1166 struct flowi fl
= { .oif
= vif
->link
,
1168 { .daddr
= vif
->remote
,
1169 .saddr
= vif
->local
,
1170 .tos
= RT_TOS(iph
->tos
) } },
1171 .proto
= IPPROTO_IPIP
};
1172 if (ip_route_output_key(&rt
, &fl
))
1174 encap
= sizeof(struct iphdr
);
1176 struct flowi fl
= { .oif
= vif
->link
,
1178 { .daddr
= iph
->daddr
,
1179 .tos
= RT_TOS(iph
->tos
) } },
1180 .proto
= IPPROTO_IPIP
};
1181 if (ip_route_output_key(&rt
, &fl
))
1185 dev
= rt
->u
.dst
.dev
;
1187 if (skb
->len
+encap
> dst_mtu(&rt
->u
.dst
) && (ntohs(iph
->frag_off
) & IP_DF
)) {
1188 /* Do not fragment multicasts. Alas, IPv4 does not
1189 allow to send ICMP, so that packets will disappear
1193 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS
);
1198 encap
+= LL_RESERVED_SPACE(dev
) + rt
->u
.dst
.header_len
;
1200 if (skb_cow(skb
, encap
)) {
1206 vif
->bytes_out
+=skb
->len
;
1208 dst_release(skb
->dst
);
1209 skb
->dst
= &rt
->u
.dst
;
1210 ip_decrease_ttl(ip_hdr(skb
));
1212 /* FIXME: forward and output firewalls used to be called here.
1213 * What do we do with netfilter? -- RR */
1214 if (vif
->flags
& VIFF_TUNNEL
) {
1215 ip_encap(skb
, vif
->local
, vif
->remote
);
1216 /* FIXME: extra output firewall step used to be here. --RR */
1217 ((struct ip_tunnel
*)netdev_priv(vif
->dev
))->stat
.tx_packets
++;
1218 ((struct ip_tunnel
*)netdev_priv(vif
->dev
))->stat
.tx_bytes
+=skb
->len
;
1221 IPCB(skb
)->flags
|= IPSKB_FORWARDED
;
1224 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1225 * not only before forwarding, but after forwarding on all output
1226 * interfaces. It is clear, if mrouter runs a multicasting
1227 * program, it should receive packets not depending to what interface
1228 * program is joined.
1229 * If we will not make it, the program will have to join on all
1230 * interfaces. On the other hand, multihoming host (or router, but
1231 * not mrouter) cannot join to more than one interface - it will
1232 * result in receiving multiple packets.
1234 NF_HOOK(PF_INET
, NF_IP_FORWARD
, skb
, skb
->dev
, dev
,
1235 ipmr_forward_finish
);
1243 static int ipmr_find_vif(struct net_device
*dev
)
1246 for (ct
=maxvif
-1; ct
>=0; ct
--) {
1247 if (vif_table
[ct
].dev
== dev
)
1253 /* "local" means that we should preserve one skb (for local delivery) */
1255 static int ip_mr_forward(struct sk_buff
*skb
, struct mfc_cache
*cache
, int local
)
1260 vif
= cache
->mfc_parent
;
1261 cache
->mfc_un
.res
.pkt
++;
1262 cache
->mfc_un
.res
.bytes
+= skb
->len
;
1265 * Wrong interface: drop packet and (maybe) send PIM assert.
1267 if (vif_table
[vif
].dev
!= skb
->dev
) {
1270 if (((struct rtable
*)skb
->dst
)->fl
.iif
== 0) {
1271 /* It is our own packet, looped back.
1272 Very complicated situation...
1274 The best workaround until routing daemons will be
1275 fixed is not to redistribute packet, if it was
1276 send through wrong interface. It means, that
1277 multicast applications WILL NOT work for
1278 (S,G), which have default multicast route pointing
1279 to wrong oif. In any case, it is not a good
1280 idea to use multicasting applications on router.
1285 cache
->mfc_un
.res
.wrong_if
++;
1286 true_vifi
= ipmr_find_vif(skb
->dev
);
1288 if (true_vifi
>= 0 && mroute_do_assert
&&
1289 /* pimsm uses asserts, when switching from RPT to SPT,
1290 so that we cannot check that packet arrived on an oif.
1291 It is bad, but otherwise we would need to move pretty
1292 large chunk of pimd to kernel. Ough... --ANK
1294 (mroute_do_pim
|| cache
->mfc_un
.res
.ttls
[true_vifi
] < 255) &&
1296 cache
->mfc_un
.res
.last_assert
+ MFC_ASSERT_THRESH
)) {
1297 cache
->mfc_un
.res
.last_assert
= jiffies
;
1298 ipmr_cache_report(skb
, true_vifi
, IGMPMSG_WRONGVIF
);
1303 vif_table
[vif
].pkt_in
++;
1304 vif_table
[vif
].bytes_in
+=skb
->len
;
1309 for (ct
= cache
->mfc_un
.res
.maxvif
-1; ct
>= cache
->mfc_un
.res
.minvif
; ct
--) {
1310 if (ip_hdr(skb
)->ttl
> cache
->mfc_un
.res
.ttls
[ct
]) {
1312 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1314 ipmr_queue_xmit(skb2
, cache
, psend
);
1321 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1323 ipmr_queue_xmit(skb2
, cache
, psend
);
1325 ipmr_queue_xmit(skb
, cache
, psend
);
1338 * Multicast packets for forwarding arrive here
1341 int ip_mr_input(struct sk_buff
*skb
)
1343 struct mfc_cache
*cache
;
1344 int local
= ((struct rtable
*)skb
->dst
)->rt_flags
&RTCF_LOCAL
;
1346 /* Packet is looped back after forward, it should not be
1347 forwarded second time, but still can be delivered locally.
1349 if (IPCB(skb
)->flags
&IPSKB_FORWARDED
)
1353 if (IPCB(skb
)->opt
.router_alert
) {
1354 if (ip_call_ra_chain(skb
))
1356 } else if (ip_hdr(skb
)->protocol
== IPPROTO_IGMP
){
1357 /* IGMPv1 (and broken IGMPv2 implementations sort of
1358 Cisco IOS <= 11.2(8)) do not put router alert
1359 option to IGMP packets destined to routable
1360 groups. It is very bad, because it means
1361 that we can forward NO IGMP messages.
1363 read_lock(&mrt_lock
);
1364 if (mroute_socket
) {
1366 raw_rcv(mroute_socket
, skb
);
1367 read_unlock(&mrt_lock
);
1370 read_unlock(&mrt_lock
);
1374 read_lock(&mrt_lock
);
1375 cache
= ipmr_cache_find(ip_hdr(skb
)->saddr
, ip_hdr(skb
)->daddr
);
1378 * No usable cache entry
1384 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1385 ip_local_deliver(skb
);
1387 read_unlock(&mrt_lock
);
1393 vif
= ipmr_find_vif(skb
->dev
);
1395 int err
= ipmr_cache_unresolved(vif
, skb
);
1396 read_unlock(&mrt_lock
);
1400 read_unlock(&mrt_lock
);
1405 ip_mr_forward(skb
, cache
, local
);
1407 read_unlock(&mrt_lock
);
1410 return ip_local_deliver(skb
);
1416 return ip_local_deliver(skb
);
1421 #ifdef CONFIG_IP_PIMSM_V1
1423 * Handle IGMP messages of PIMv1
1426 int pim_rcv_v1(struct sk_buff
* skb
)
1428 struct igmphdr
*pim
;
1429 struct iphdr
*encap
;
1430 struct net_device
*reg_dev
= NULL
;
1432 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(*encap
)))
1435 pim
= igmp_hdr(skb
);
1437 if (!mroute_do_pim
||
1438 skb
->len
< sizeof(*pim
) + sizeof(*encap
) ||
1439 pim
->group
!= PIM_V1_VERSION
|| pim
->code
!= PIM_V1_REGISTER
)
1442 encap
= (struct iphdr
*)(skb_transport_header(skb
) +
1443 sizeof(struct igmphdr
));
1446 a. packet is really destinted to a multicast group
1447 b. packet is not a NULL-REGISTER
1448 c. packet is not truncated
1450 if (!MULTICAST(encap
->daddr
) ||
1451 encap
->tot_len
== 0 ||
1452 ntohs(encap
->tot_len
) + sizeof(*pim
) > skb
->len
)
1455 read_lock(&mrt_lock
);
1456 if (reg_vif_num
>= 0)
1457 reg_dev
= vif_table
[reg_vif_num
].dev
;
1460 read_unlock(&mrt_lock
);
1462 if (reg_dev
== NULL
)
1465 skb
->mac_header
= skb
->network_header
;
1466 skb_pull(skb
, (u8
*)encap
- skb
->data
);
1467 skb_reset_network_header(skb
);
1469 skb
->protocol
= htons(ETH_P_IP
);
1471 skb
->pkt_type
= PACKET_HOST
;
1472 dst_release(skb
->dst
);
1474 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_bytes
+= skb
->len
;
1475 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_packets
++;
1486 #ifdef CONFIG_IP_PIMSM_V2
1487 static int pim_rcv(struct sk_buff
* skb
)
1489 struct pimreghdr
*pim
;
1490 struct iphdr
*encap
;
1491 struct net_device
*reg_dev
= NULL
;
1493 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(*encap
)))
1496 pim
= (struct pimreghdr
*)skb_transport_header(skb
);
1497 if (pim
->type
!= ((PIM_VERSION
<<4)|(PIM_REGISTER
)) ||
1498 (pim
->flags
&PIM_NULL_REGISTER
) ||
1499 (ip_compute_csum((void *)pim
, sizeof(*pim
)) != 0 &&
1500 csum_fold(skb_checksum(skb
, 0, skb
->len
, 0))))
1503 /* check if the inner packet is destined to mcast group */
1504 encap
= (struct iphdr
*)(skb_transport_header(skb
) +
1505 sizeof(struct pimreghdr
));
1506 if (!MULTICAST(encap
->daddr
) ||
1507 encap
->tot_len
== 0 ||
1508 ntohs(encap
->tot_len
) + sizeof(*pim
) > skb
->len
)
1511 read_lock(&mrt_lock
);
1512 if (reg_vif_num
>= 0)
1513 reg_dev
= vif_table
[reg_vif_num
].dev
;
1516 read_unlock(&mrt_lock
);
1518 if (reg_dev
== NULL
)
1521 skb
->mac_header
= skb
->network_header
;
1522 skb_pull(skb
, (u8
*)encap
- skb
->data
);
1523 skb_reset_network_header(skb
);
1525 skb
->protocol
= htons(ETH_P_IP
);
1527 skb
->pkt_type
= PACKET_HOST
;
1528 dst_release(skb
->dst
);
1529 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_bytes
+= skb
->len
;
1530 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_packets
++;
1543 ipmr_fill_mroute(struct sk_buff
*skb
, struct mfc_cache
*c
, struct rtmsg
*rtm
)
1546 struct rtnexthop
*nhp
;
1547 struct net_device
*dev
= vif_table
[c
->mfc_parent
].dev
;
1548 u8
*b
= skb_tail_pointer(skb
);
1549 struct rtattr
*mp_head
;
1552 RTA_PUT(skb
, RTA_IIF
, 4, &dev
->ifindex
);
1554 mp_head
= (struct rtattr
*)skb_put(skb
, RTA_LENGTH(0));
1556 for (ct
= c
->mfc_un
.res
.minvif
; ct
< c
->mfc_un
.res
.maxvif
; ct
++) {
1557 if (c
->mfc_un
.res
.ttls
[ct
] < 255) {
1558 if (skb_tailroom(skb
) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp
)) + 4))
1559 goto rtattr_failure
;
1560 nhp
= (struct rtnexthop
*)skb_put(skb
, RTA_ALIGN(sizeof(*nhp
)));
1561 nhp
->rtnh_flags
= 0;
1562 nhp
->rtnh_hops
= c
->mfc_un
.res
.ttls
[ct
];
1563 nhp
->rtnh_ifindex
= vif_table
[ct
].dev
->ifindex
;
1564 nhp
->rtnh_len
= sizeof(*nhp
);
1567 mp_head
->rta_type
= RTA_MULTIPATH
;
1568 mp_head
->rta_len
= skb_tail_pointer(skb
) - (u8
*)mp_head
;
1569 rtm
->rtm_type
= RTN_MULTICAST
;
1573 skb_trim(skb
, b
- skb
->data
);
1577 int ipmr_get_route(struct sk_buff
*skb
, struct rtmsg
*rtm
, int nowait
)
1580 struct mfc_cache
*cache
;
1581 struct rtable
*rt
= (struct rtable
*)skb
->dst
;
1583 read_lock(&mrt_lock
);
1584 cache
= ipmr_cache_find(rt
->rt_src
, rt
->rt_dst
);
1587 struct sk_buff
*skb2
;
1589 struct net_device
*dev
;
1593 read_unlock(&mrt_lock
);
1598 if (dev
== NULL
|| (vif
= ipmr_find_vif(dev
)) < 0) {
1599 read_unlock(&mrt_lock
);
1602 skb2
= skb_clone(skb
, GFP_ATOMIC
);
1604 read_unlock(&mrt_lock
);
1608 skb_push(skb2
, sizeof(struct iphdr
));
1609 skb_reset_network_header(skb2
);
1611 iph
->ihl
= sizeof(struct iphdr
) >> 2;
1612 iph
->saddr
= rt
->rt_src
;
1613 iph
->daddr
= rt
->rt_dst
;
1615 err
= ipmr_cache_unresolved(vif
, skb2
);
1616 read_unlock(&mrt_lock
);
1620 if (!nowait
&& (rtm
->rtm_flags
&RTM_F_NOTIFY
))
1621 cache
->mfc_flags
|= MFC_NOTIFY
;
1622 err
= ipmr_fill_mroute(skb
, cache
, rtm
);
1623 read_unlock(&mrt_lock
);
1627 #ifdef CONFIG_PROC_FS
1629 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1631 struct ipmr_vif_iter
{
1635 static struct vif_device
*ipmr_vif_seq_idx(struct ipmr_vif_iter
*iter
,
1638 for (iter
->ct
= 0; iter
->ct
< maxvif
; ++iter
->ct
) {
1639 if (!VIF_EXISTS(iter
->ct
))
1642 return &vif_table
[iter
->ct
];
1647 static void *ipmr_vif_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1649 read_lock(&mrt_lock
);
1650 return *pos
? ipmr_vif_seq_idx(seq
->private, *pos
- 1)
1654 static void *ipmr_vif_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1656 struct ipmr_vif_iter
*iter
= seq
->private;
1659 if (v
== SEQ_START_TOKEN
)
1660 return ipmr_vif_seq_idx(iter
, 0);
1662 while (++iter
->ct
< maxvif
) {
1663 if (!VIF_EXISTS(iter
->ct
))
1665 return &vif_table
[iter
->ct
];
1670 static void ipmr_vif_seq_stop(struct seq_file
*seq
, void *v
)
1672 read_unlock(&mrt_lock
);
1675 static int ipmr_vif_seq_show(struct seq_file
*seq
, void *v
)
1677 if (v
== SEQ_START_TOKEN
) {
1679 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1681 const struct vif_device
*vif
= v
;
1682 const char *name
= vif
->dev
? vif
->dev
->name
: "none";
1685 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1687 name
, vif
->bytes_in
, vif
->pkt_in
,
1688 vif
->bytes_out
, vif
->pkt_out
,
1689 vif
->flags
, vif
->local
, vif
->remote
);
1694 static const struct seq_operations ipmr_vif_seq_ops
= {
1695 .start
= ipmr_vif_seq_start
,
1696 .next
= ipmr_vif_seq_next
,
1697 .stop
= ipmr_vif_seq_stop
,
1698 .show
= ipmr_vif_seq_show
,
1701 static int ipmr_vif_open(struct inode
*inode
, struct file
*file
)
1703 struct seq_file
*seq
;
1705 struct ipmr_vif_iter
*s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1710 rc
= seq_open(file
, &ipmr_vif_seq_ops
);
1715 seq
= file
->private_data
;
1725 static const struct file_operations ipmr_vif_fops
= {
1726 .owner
= THIS_MODULE
,
1727 .open
= ipmr_vif_open
,
1729 .llseek
= seq_lseek
,
1730 .release
= seq_release_private
,
1733 struct ipmr_mfc_iter
{
1734 struct mfc_cache
**cache
;
1739 static struct mfc_cache
*ipmr_mfc_seq_idx(struct ipmr_mfc_iter
*it
, loff_t pos
)
1741 struct mfc_cache
*mfc
;
1743 it
->cache
= mfc_cache_array
;
1744 read_lock(&mrt_lock
);
1745 for (it
->ct
= 0; it
->ct
< MFC_LINES
; it
->ct
++)
1746 for (mfc
= mfc_cache_array
[it
->ct
]; mfc
; mfc
= mfc
->next
)
1749 read_unlock(&mrt_lock
);
1751 it
->cache
= &mfc_unres_queue
;
1752 spin_lock_bh(&mfc_unres_lock
);
1753 for (mfc
= mfc_unres_queue
; mfc
; mfc
= mfc
->next
)
1756 spin_unlock_bh(&mfc_unres_lock
);
1763 static void *ipmr_mfc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1765 struct ipmr_mfc_iter
*it
= seq
->private;
1768 return *pos
? ipmr_mfc_seq_idx(seq
->private, *pos
- 1)
1772 static void *ipmr_mfc_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1774 struct mfc_cache
*mfc
= v
;
1775 struct ipmr_mfc_iter
*it
= seq
->private;
1779 if (v
== SEQ_START_TOKEN
)
1780 return ipmr_mfc_seq_idx(seq
->private, 0);
1785 if (it
->cache
== &mfc_unres_queue
)
1788 BUG_ON(it
->cache
!= mfc_cache_array
);
1790 while (++it
->ct
< MFC_LINES
) {
1791 mfc
= mfc_cache_array
[it
->ct
];
1796 /* exhausted cache_array, show unresolved */
1797 read_unlock(&mrt_lock
);
1798 it
->cache
= &mfc_unres_queue
;
1801 spin_lock_bh(&mfc_unres_lock
);
1802 mfc
= mfc_unres_queue
;
1807 spin_unlock_bh(&mfc_unres_lock
);
1813 static void ipmr_mfc_seq_stop(struct seq_file
*seq
, void *v
)
1815 struct ipmr_mfc_iter
*it
= seq
->private;
1817 if (it
->cache
== &mfc_unres_queue
)
1818 spin_unlock_bh(&mfc_unres_lock
);
1819 else if (it
->cache
== mfc_cache_array
)
1820 read_unlock(&mrt_lock
);
1823 static int ipmr_mfc_seq_show(struct seq_file
*seq
, void *v
)
1827 if (v
== SEQ_START_TOKEN
) {
1829 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1831 const struct mfc_cache
*mfc
= v
;
1832 const struct ipmr_mfc_iter
*it
= seq
->private;
1834 seq_printf(seq
, "%08lX %08lX %-3d %8ld %8ld %8ld",
1835 (unsigned long) mfc
->mfc_mcastgrp
,
1836 (unsigned long) mfc
->mfc_origin
,
1838 mfc
->mfc_un
.res
.pkt
,
1839 mfc
->mfc_un
.res
.bytes
,
1840 mfc
->mfc_un
.res
.wrong_if
);
1842 if (it
->cache
!= &mfc_unres_queue
) {
1843 for (n
= mfc
->mfc_un
.res
.minvif
;
1844 n
< mfc
->mfc_un
.res
.maxvif
; n
++ ) {
1846 && mfc
->mfc_un
.res
.ttls
[n
] < 255)
1849 n
, mfc
->mfc_un
.res
.ttls
[n
]);
1852 seq_putc(seq
, '\n');
1857 static const struct seq_operations ipmr_mfc_seq_ops
= {
1858 .start
= ipmr_mfc_seq_start
,
1859 .next
= ipmr_mfc_seq_next
,
1860 .stop
= ipmr_mfc_seq_stop
,
1861 .show
= ipmr_mfc_seq_show
,
1864 static int ipmr_mfc_open(struct inode
*inode
, struct file
*file
)
1866 struct seq_file
*seq
;
1868 struct ipmr_mfc_iter
*s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1873 rc
= seq_open(file
, &ipmr_mfc_seq_ops
);
1877 seq
= file
->private_data
;
1887 static const struct file_operations ipmr_mfc_fops
= {
1888 .owner
= THIS_MODULE
,
1889 .open
= ipmr_mfc_open
,
1891 .llseek
= seq_lseek
,
1892 .release
= seq_release_private
,
1896 #ifdef CONFIG_IP_PIMSM_V2
1897 static struct net_protocol pim_protocol
= {
1904 * Setup for IP multicast routing
1907 void __init
ip_mr_init(void)
1909 mrt_cachep
= kmem_cache_create("ip_mrt_cache",
1910 sizeof(struct mfc_cache
),
1911 0, SLAB_HWCACHE_ALIGN
|SLAB_PANIC
,
1913 init_timer(&ipmr_expire_timer
);
1914 ipmr_expire_timer
.function
=ipmr_expire_process
;
1915 register_netdevice_notifier(&ip_mr_notifier
);
1916 #ifdef CONFIG_PROC_FS
1917 proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops
);
1918 proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops
);