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 (skb
->nh
.iph
->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 (skb
->nh
.iph
->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
- (u8
*)nlh
;
518 nlh
->nlmsg_type
= NLMSG_ERROR
;
519 nlh
->nlmsg_len
= NLMSG_LENGTH(sizeof(struct nlmsgerr
));
520 skb_trim(skb
, nlh
->nlmsg_len
);
522 e
->error
= -EMSGSIZE
;
523 memset(&e
->msg
, 0, sizeof(e
->msg
));
526 rtnl_unicast(skb
, NETLINK_CB(skb
).pid
);
528 ip_mr_forward(skb
, c
, 0);
533 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
534 * expects the following bizarre scheme.
536 * Called under mrt_lock.
539 static int ipmr_cache_report(struct sk_buff
*pkt
, vifi_t vifi
, int assert)
542 const int ihl
= ip_hdrlen(pkt
);
543 struct igmphdr
*igmp
;
547 #ifdef CONFIG_IP_PIMSM
548 if (assert == IGMPMSG_WHOLEPKT
)
549 skb
= skb_realloc_headroom(pkt
, sizeof(struct iphdr
));
552 skb
= alloc_skb(128, GFP_ATOMIC
);
557 #ifdef CONFIG_IP_PIMSM
558 if (assert == IGMPMSG_WHOLEPKT
) {
559 /* Ugly, but we have no choice with this interface.
560 Duplicate old header, fix ihl, length etc.
561 And all this only to mangle msg->im_msgtype and
562 to set msg->im_mbz to "mbz" :-)
564 skb_push(skb
, sizeof(struct iphdr
));
565 skb_reset_network_header(skb
);
566 skb
->h
.raw
= skb
->data
;
567 msg
= (struct igmpmsg
*)skb_network_header(skb
);
568 memcpy(msg
, skb_network_header(pkt
), sizeof(struct iphdr
));
569 msg
->im_msgtype
= IGMPMSG_WHOLEPKT
;
571 msg
->im_vif
= reg_vif_num
;
572 skb
->nh
.iph
->ihl
= sizeof(struct iphdr
) >> 2;
573 skb
->nh
.iph
->tot_len
= htons(ntohs(pkt
->nh
.iph
->tot_len
) + sizeof(struct iphdr
));
582 skb
->nh
.iph
= (struct iphdr
*)skb_put(skb
, ihl
);
583 memcpy(skb
->data
,pkt
->data
,ihl
);
584 skb
->nh
.iph
->protocol
= 0; /* Flag to the kernel this is a route add */
585 msg
= (struct igmpmsg
*)skb
->nh
.iph
;
587 skb
->dst
= dst_clone(pkt
->dst
);
593 igmp
=(struct igmphdr
*)skb_put(skb
,sizeof(struct igmphdr
));
595 msg
->im_msgtype
= assert;
597 skb
->nh
.iph
->tot_len
=htons(skb
->len
); /* Fix the length */
598 skb
->h
.raw
= skb
->nh
.raw
;
601 if (mroute_socket
== NULL
) {
609 if ((ret
=sock_queue_rcv_skb(mroute_socket
,skb
))<0) {
611 printk(KERN_WARNING
"mroute: pending queue full, dropping entries.\n");
619 * Queue a packet for resolution. It gets locked cache entry!
623 ipmr_cache_unresolved(vifi_t vifi
, struct sk_buff
*skb
)
628 spin_lock_bh(&mfc_unres_lock
);
629 for (c
=mfc_unres_queue
; c
; c
=c
->next
) {
630 if (c
->mfc_mcastgrp
== skb
->nh
.iph
->daddr
&&
631 c
->mfc_origin
== skb
->nh
.iph
->saddr
)
637 * Create a new entry if allowable
640 if (atomic_read(&cache_resolve_queue_len
)>=10 ||
641 (c
=ipmr_cache_alloc_unres())==NULL
) {
642 spin_unlock_bh(&mfc_unres_lock
);
649 * Fill in the new cache entry
652 c
->mfc_origin
=skb
->nh
.iph
->saddr
;
653 c
->mfc_mcastgrp
=skb
->nh
.iph
->daddr
;
656 * Reflect first query at mrouted.
658 if ((err
= ipmr_cache_report(skb
, vifi
, IGMPMSG_NOCACHE
))<0) {
659 /* If the report failed throw the cache entry
662 spin_unlock_bh(&mfc_unres_lock
);
664 kmem_cache_free(mrt_cachep
, c
);
669 atomic_inc(&cache_resolve_queue_len
);
670 c
->next
= mfc_unres_queue
;
673 mod_timer(&ipmr_expire_timer
, c
->mfc_un
.unres
.expires
);
677 * See if we can append the packet
679 if (c
->mfc_un
.unres
.unresolved
.qlen
>3) {
683 skb_queue_tail(&c
->mfc_un
.unres
.unresolved
,skb
);
687 spin_unlock_bh(&mfc_unres_lock
);
692 * MFC cache manipulation by user space mroute daemon
695 static int ipmr_mfc_delete(struct mfcctl
*mfc
)
698 struct mfc_cache
*c
, **cp
;
700 line
=MFC_HASH(mfc
->mfcc_mcastgrp
.s_addr
, mfc
->mfcc_origin
.s_addr
);
702 for (cp
=&mfc_cache_array
[line
]; (c
=*cp
) != NULL
; cp
= &c
->next
) {
703 if (c
->mfc_origin
== mfc
->mfcc_origin
.s_addr
&&
704 c
->mfc_mcastgrp
== mfc
->mfcc_mcastgrp
.s_addr
) {
705 write_lock_bh(&mrt_lock
);
707 write_unlock_bh(&mrt_lock
);
709 kmem_cache_free(mrt_cachep
, c
);
716 static int ipmr_mfc_add(struct mfcctl
*mfc
, int mrtsock
)
719 struct mfc_cache
*uc
, *c
, **cp
;
721 line
=MFC_HASH(mfc
->mfcc_mcastgrp
.s_addr
, mfc
->mfcc_origin
.s_addr
);
723 for (cp
=&mfc_cache_array
[line
]; (c
=*cp
) != NULL
; cp
= &c
->next
) {
724 if (c
->mfc_origin
== mfc
->mfcc_origin
.s_addr
&&
725 c
->mfc_mcastgrp
== mfc
->mfcc_mcastgrp
.s_addr
)
730 write_lock_bh(&mrt_lock
);
731 c
->mfc_parent
= mfc
->mfcc_parent
;
732 ipmr_update_thresholds(c
, mfc
->mfcc_ttls
);
734 c
->mfc_flags
|= MFC_STATIC
;
735 write_unlock_bh(&mrt_lock
);
739 if (!MULTICAST(mfc
->mfcc_mcastgrp
.s_addr
))
742 c
=ipmr_cache_alloc();
746 c
->mfc_origin
=mfc
->mfcc_origin
.s_addr
;
747 c
->mfc_mcastgrp
=mfc
->mfcc_mcastgrp
.s_addr
;
748 c
->mfc_parent
=mfc
->mfcc_parent
;
749 ipmr_update_thresholds(c
, mfc
->mfcc_ttls
);
751 c
->mfc_flags
|= MFC_STATIC
;
753 write_lock_bh(&mrt_lock
);
754 c
->next
= mfc_cache_array
[line
];
755 mfc_cache_array
[line
] = c
;
756 write_unlock_bh(&mrt_lock
);
759 * Check to see if we resolved a queued list. If so we
760 * need to send on the frames and tidy up.
762 spin_lock_bh(&mfc_unres_lock
);
763 for (cp
= &mfc_unres_queue
; (uc
=*cp
) != NULL
;
765 if (uc
->mfc_origin
== c
->mfc_origin
&&
766 uc
->mfc_mcastgrp
== c
->mfc_mcastgrp
) {
768 if (atomic_dec_and_test(&cache_resolve_queue_len
))
769 del_timer(&ipmr_expire_timer
);
773 spin_unlock_bh(&mfc_unres_lock
);
776 ipmr_cache_resolve(uc
, c
);
777 kmem_cache_free(mrt_cachep
, uc
);
783 * Close the multicast socket, and clear the vif tables etc
786 static void mroute_clean_tables(struct sock
*sk
)
791 * Shut down all active vif entries
793 for (i
=0; i
<maxvif
; i
++) {
794 if (!(vif_table
[i
].flags
&VIFF_STATIC
))
801 for (i
=0;i
<MFC_LINES
;i
++) {
802 struct mfc_cache
*c
, **cp
;
804 cp
= &mfc_cache_array
[i
];
805 while ((c
= *cp
) != NULL
) {
806 if (c
->mfc_flags
&MFC_STATIC
) {
810 write_lock_bh(&mrt_lock
);
812 write_unlock_bh(&mrt_lock
);
814 kmem_cache_free(mrt_cachep
, c
);
818 if (atomic_read(&cache_resolve_queue_len
) != 0) {
821 spin_lock_bh(&mfc_unres_lock
);
822 while (mfc_unres_queue
!= NULL
) {
824 mfc_unres_queue
= c
->next
;
825 spin_unlock_bh(&mfc_unres_lock
);
827 ipmr_destroy_unres(c
);
829 spin_lock_bh(&mfc_unres_lock
);
831 spin_unlock_bh(&mfc_unres_lock
);
835 static void mrtsock_destruct(struct sock
*sk
)
838 if (sk
== mroute_socket
) {
839 ipv4_devconf
.mc_forwarding
--;
841 write_lock_bh(&mrt_lock
);
843 write_unlock_bh(&mrt_lock
);
845 mroute_clean_tables(sk
);
851 * Socket options and virtual interface manipulation. The whole
852 * virtual interface system is a complete heap, but unfortunately
853 * that's how BSD mrouted happens to think. Maybe one day with a proper
854 * MOSPF/PIM router set up we can clean this up.
857 int ip_mroute_setsockopt(struct sock
*sk
,int optname
,char __user
*optval
,int optlen
)
863 if (optname
!= MRT_INIT
) {
864 if (sk
!= mroute_socket
&& !capable(CAP_NET_ADMIN
))
870 if (sk
->sk_type
!= SOCK_RAW
||
871 inet_sk(sk
)->num
!= IPPROTO_IGMP
)
873 if (optlen
!=sizeof(int))
882 ret
= ip_ra_control(sk
, 1, mrtsock_destruct
);
884 write_lock_bh(&mrt_lock
);
886 write_unlock_bh(&mrt_lock
);
888 ipv4_devconf
.mc_forwarding
++;
893 if (sk
!=mroute_socket
)
895 return ip_ra_control(sk
, 0, NULL
);
898 if (optlen
!=sizeof(vif
))
900 if (copy_from_user(&vif
,optval
,sizeof(vif
)))
902 if (vif
.vifc_vifi
>= MAXVIFS
)
905 if (optname
==MRT_ADD_VIF
) {
906 ret
= vif_add(&vif
, sk
==mroute_socket
);
908 ret
= vif_delete(vif
.vifc_vifi
);
914 * Manipulate the forwarding caches. These live
915 * in a sort of kernel/user symbiosis.
919 if (optlen
!=sizeof(mfc
))
921 if (copy_from_user(&mfc
,optval
, sizeof(mfc
)))
924 if (optname
==MRT_DEL_MFC
)
925 ret
= ipmr_mfc_delete(&mfc
);
927 ret
= ipmr_mfc_add(&mfc
, sk
==mroute_socket
);
931 * Control PIM assert.
936 if (get_user(v
,(int __user
*)optval
))
938 mroute_do_assert
=(v
)?1:0;
941 #ifdef CONFIG_IP_PIMSM
945 if (get_user(v
,(int __user
*)optval
))
950 if (v
!= mroute_do_pim
) {
952 mroute_do_assert
= v
;
953 #ifdef CONFIG_IP_PIMSM_V2
955 ret
= inet_add_protocol(&pim_protocol
,
958 ret
= inet_del_protocol(&pim_protocol
,
969 * Spurious command, or MRT_VERSION which you cannot
978 * Getsock opt support for the multicast routing system.
981 int ip_mroute_getsockopt(struct sock
*sk
,int optname
,char __user
*optval
,int __user
*optlen
)
986 if (optname
!=MRT_VERSION
&&
987 #ifdef CONFIG_IP_PIMSM
993 if (get_user(olr
, optlen
))
996 olr
= min_t(unsigned int, olr
, sizeof(int));
1000 if (put_user(olr
,optlen
))
1002 if (optname
==MRT_VERSION
)
1004 #ifdef CONFIG_IP_PIMSM
1005 else if (optname
==MRT_PIM
)
1009 val
=mroute_do_assert
;
1010 if (copy_to_user(optval
,&val
,olr
))
1016 * The IP multicast ioctl support routines.
1019 int ipmr_ioctl(struct sock
*sk
, int cmd
, void __user
*arg
)
1021 struct sioc_sg_req sr
;
1022 struct sioc_vif_req vr
;
1023 struct vif_device
*vif
;
1024 struct mfc_cache
*c
;
1028 if (copy_from_user(&vr
,arg
,sizeof(vr
)))
1030 if (vr
.vifi
>=maxvif
)
1032 read_lock(&mrt_lock
);
1033 vif
=&vif_table
[vr
.vifi
];
1034 if (VIF_EXISTS(vr
.vifi
)) {
1035 vr
.icount
=vif
->pkt_in
;
1036 vr
.ocount
=vif
->pkt_out
;
1037 vr
.ibytes
=vif
->bytes_in
;
1038 vr
.obytes
=vif
->bytes_out
;
1039 read_unlock(&mrt_lock
);
1041 if (copy_to_user(arg
,&vr
,sizeof(vr
)))
1045 read_unlock(&mrt_lock
);
1046 return -EADDRNOTAVAIL
;
1048 if (copy_from_user(&sr
,arg
,sizeof(sr
)))
1051 read_lock(&mrt_lock
);
1052 c
= ipmr_cache_find(sr
.src
.s_addr
, sr
.grp
.s_addr
);
1054 sr
.pktcnt
= c
->mfc_un
.res
.pkt
;
1055 sr
.bytecnt
= c
->mfc_un
.res
.bytes
;
1056 sr
.wrong_if
= c
->mfc_un
.res
.wrong_if
;
1057 read_unlock(&mrt_lock
);
1059 if (copy_to_user(arg
,&sr
,sizeof(sr
)))
1063 read_unlock(&mrt_lock
);
1064 return -EADDRNOTAVAIL
;
1066 return -ENOIOCTLCMD
;
1071 static int ipmr_device_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1073 struct vif_device
*v
;
1075 if (event
!= NETDEV_UNREGISTER
)
1078 for (ct
=0;ct
<maxvif
;ct
++,v
++) {
1086 static struct notifier_block ip_mr_notifier
={
1087 .notifier_call
= ipmr_device_event
,
1091 * Encapsulate a packet by attaching a valid IPIP header to it.
1092 * This avoids tunnel drivers and other mess and gives us the speed so
1093 * important for multicast video.
1096 static void ip_encap(struct sk_buff
*skb
, __be32 saddr
, __be32 daddr
)
1099 struct iphdr
*old_iph
= skb
->nh
.iph
;
1101 skb_push(skb
, sizeof(struct iphdr
));
1102 skb
->h
.ipiph
= skb
->nh
.iph
;
1103 skb_reset_network_header(skb
);
1107 iph
->tos
= old_iph
->tos
;
1108 iph
->ttl
= old_iph
->ttl
;
1112 iph
->protocol
= IPPROTO_IPIP
;
1114 iph
->tot_len
= htons(skb
->len
);
1115 ip_select_ident(iph
, skb
->dst
, NULL
);
1118 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
1122 static inline int ipmr_forward_finish(struct sk_buff
*skb
)
1124 struct ip_options
* opt
= &(IPCB(skb
)->opt
);
1126 IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS
);
1128 if (unlikely(opt
->optlen
))
1129 ip_forward_options(skb
);
1131 return dst_output(skb
);
1135 * Processing handlers for ipmr_forward
1138 static void ipmr_queue_xmit(struct sk_buff
*skb
, struct mfc_cache
*c
, int vifi
)
1140 struct iphdr
*iph
= skb
->nh
.iph
;
1141 struct vif_device
*vif
= &vif_table
[vifi
];
1142 struct net_device
*dev
;
1146 if (vif
->dev
== NULL
)
1149 #ifdef CONFIG_IP_PIMSM
1150 if (vif
->flags
& VIFF_REGISTER
) {
1152 vif
->bytes_out
+=skb
->len
;
1153 ((struct net_device_stats
*)netdev_priv(vif
->dev
))->tx_bytes
+= skb
->len
;
1154 ((struct net_device_stats
*)netdev_priv(vif
->dev
))->tx_packets
++;
1155 ipmr_cache_report(skb
, vifi
, IGMPMSG_WHOLEPKT
);
1161 if (vif
->flags
&VIFF_TUNNEL
) {
1162 struct flowi fl
= { .oif
= vif
->link
,
1164 { .daddr
= vif
->remote
,
1165 .saddr
= vif
->local
,
1166 .tos
= RT_TOS(iph
->tos
) } },
1167 .proto
= IPPROTO_IPIP
};
1168 if (ip_route_output_key(&rt
, &fl
))
1170 encap
= sizeof(struct iphdr
);
1172 struct flowi fl
= { .oif
= vif
->link
,
1174 { .daddr
= iph
->daddr
,
1175 .tos
= RT_TOS(iph
->tos
) } },
1176 .proto
= IPPROTO_IPIP
};
1177 if (ip_route_output_key(&rt
, &fl
))
1181 dev
= rt
->u
.dst
.dev
;
1183 if (skb
->len
+encap
> dst_mtu(&rt
->u
.dst
) && (ntohs(iph
->frag_off
) & IP_DF
)) {
1184 /* Do not fragment multicasts. Alas, IPv4 does not
1185 allow to send ICMP, so that packets will disappear
1189 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS
);
1194 encap
+= LL_RESERVED_SPACE(dev
) + rt
->u
.dst
.header_len
;
1196 if (skb_cow(skb
, encap
)) {
1202 vif
->bytes_out
+=skb
->len
;
1204 dst_release(skb
->dst
);
1205 skb
->dst
= &rt
->u
.dst
;
1207 ip_decrease_ttl(iph
);
1209 /* FIXME: forward and output firewalls used to be called here.
1210 * What do we do with netfilter? -- RR */
1211 if (vif
->flags
& VIFF_TUNNEL
) {
1212 ip_encap(skb
, vif
->local
, vif
->remote
);
1213 /* FIXME: extra output firewall step used to be here. --RR */
1214 ((struct ip_tunnel
*)netdev_priv(vif
->dev
))->stat
.tx_packets
++;
1215 ((struct ip_tunnel
*)netdev_priv(vif
->dev
))->stat
.tx_bytes
+=skb
->len
;
1218 IPCB(skb
)->flags
|= IPSKB_FORWARDED
;
1221 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1222 * not only before forwarding, but after forwarding on all output
1223 * interfaces. It is clear, if mrouter runs a multicasting
1224 * program, it should receive packets not depending to what interface
1225 * program is joined.
1226 * If we will not make it, the program will have to join on all
1227 * interfaces. On the other hand, multihoming host (or router, but
1228 * not mrouter) cannot join to more than one interface - it will
1229 * result in receiving multiple packets.
1231 NF_HOOK(PF_INET
, NF_IP_FORWARD
, skb
, skb
->dev
, dev
,
1232 ipmr_forward_finish
);
1240 static int ipmr_find_vif(struct net_device
*dev
)
1243 for (ct
=maxvif
-1; ct
>=0; ct
--) {
1244 if (vif_table
[ct
].dev
== dev
)
1250 /* "local" means that we should preserve one skb (for local delivery) */
1252 static int ip_mr_forward(struct sk_buff
*skb
, struct mfc_cache
*cache
, int local
)
1257 vif
= cache
->mfc_parent
;
1258 cache
->mfc_un
.res
.pkt
++;
1259 cache
->mfc_un
.res
.bytes
+= skb
->len
;
1262 * Wrong interface: drop packet and (maybe) send PIM assert.
1264 if (vif_table
[vif
].dev
!= skb
->dev
) {
1267 if (((struct rtable
*)skb
->dst
)->fl
.iif
== 0) {
1268 /* It is our own packet, looped back.
1269 Very complicated situation...
1271 The best workaround until routing daemons will be
1272 fixed is not to redistribute packet, if it was
1273 send through wrong interface. It means, that
1274 multicast applications WILL NOT work for
1275 (S,G), which have default multicast route pointing
1276 to wrong oif. In any case, it is not a good
1277 idea to use multicasting applications on router.
1282 cache
->mfc_un
.res
.wrong_if
++;
1283 true_vifi
= ipmr_find_vif(skb
->dev
);
1285 if (true_vifi
>= 0 && mroute_do_assert
&&
1286 /* pimsm uses asserts, when switching from RPT to SPT,
1287 so that we cannot check that packet arrived on an oif.
1288 It is bad, but otherwise we would need to move pretty
1289 large chunk of pimd to kernel. Ough... --ANK
1291 (mroute_do_pim
|| cache
->mfc_un
.res
.ttls
[true_vifi
] < 255) &&
1293 cache
->mfc_un
.res
.last_assert
+ MFC_ASSERT_THRESH
)) {
1294 cache
->mfc_un
.res
.last_assert
= jiffies
;
1295 ipmr_cache_report(skb
, true_vifi
, IGMPMSG_WRONGVIF
);
1300 vif_table
[vif
].pkt_in
++;
1301 vif_table
[vif
].bytes_in
+=skb
->len
;
1306 for (ct
= cache
->mfc_un
.res
.maxvif
-1; ct
>= cache
->mfc_un
.res
.minvif
; ct
--) {
1307 if (skb
->nh
.iph
->ttl
> cache
->mfc_un
.res
.ttls
[ct
]) {
1309 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1311 ipmr_queue_xmit(skb2
, cache
, psend
);
1318 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1320 ipmr_queue_xmit(skb2
, cache
, psend
);
1322 ipmr_queue_xmit(skb
, cache
, psend
);
1335 * Multicast packets for forwarding arrive here
1338 int ip_mr_input(struct sk_buff
*skb
)
1340 struct mfc_cache
*cache
;
1341 int local
= ((struct rtable
*)skb
->dst
)->rt_flags
&RTCF_LOCAL
;
1343 /* Packet is looped back after forward, it should not be
1344 forwarded second time, but still can be delivered locally.
1346 if (IPCB(skb
)->flags
&IPSKB_FORWARDED
)
1350 if (IPCB(skb
)->opt
.router_alert
) {
1351 if (ip_call_ra_chain(skb
))
1353 } else if (skb
->nh
.iph
->protocol
== IPPROTO_IGMP
){
1354 /* IGMPv1 (and broken IGMPv2 implementations sort of
1355 Cisco IOS <= 11.2(8)) do not put router alert
1356 option to IGMP packets destined to routable
1357 groups. It is very bad, because it means
1358 that we can forward NO IGMP messages.
1360 read_lock(&mrt_lock
);
1361 if (mroute_socket
) {
1363 raw_rcv(mroute_socket
, skb
);
1364 read_unlock(&mrt_lock
);
1367 read_unlock(&mrt_lock
);
1371 read_lock(&mrt_lock
);
1372 cache
= ipmr_cache_find(skb
->nh
.iph
->saddr
, skb
->nh
.iph
->daddr
);
1375 * No usable cache entry
1381 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1382 ip_local_deliver(skb
);
1384 read_unlock(&mrt_lock
);
1390 vif
= ipmr_find_vif(skb
->dev
);
1392 int err
= ipmr_cache_unresolved(vif
, skb
);
1393 read_unlock(&mrt_lock
);
1397 read_unlock(&mrt_lock
);
1402 ip_mr_forward(skb
, cache
, local
);
1404 read_unlock(&mrt_lock
);
1407 return ip_local_deliver(skb
);
1413 return ip_local_deliver(skb
);
1418 #ifdef CONFIG_IP_PIMSM_V1
1420 * Handle IGMP messages of PIMv1
1423 int pim_rcv_v1(struct sk_buff
* skb
)
1425 struct igmphdr
*pim
;
1426 struct iphdr
*encap
;
1427 struct net_device
*reg_dev
= NULL
;
1429 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(*encap
)))
1432 pim
= (struct igmphdr
*)skb
->h
.raw
;
1434 if (!mroute_do_pim
||
1435 skb
->len
< sizeof(*pim
) + sizeof(*encap
) ||
1436 pim
->group
!= PIM_V1_VERSION
|| pim
->code
!= PIM_V1_REGISTER
)
1439 encap
= (struct iphdr
*)(skb
->h
.raw
+ sizeof(struct igmphdr
));
1442 a. packet is really destinted to a multicast group
1443 b. packet is not a NULL-REGISTER
1444 c. packet is not truncated
1446 if (!MULTICAST(encap
->daddr
) ||
1447 encap
->tot_len
== 0 ||
1448 ntohs(encap
->tot_len
) + sizeof(*pim
) > skb
->len
)
1451 read_lock(&mrt_lock
);
1452 if (reg_vif_num
>= 0)
1453 reg_dev
= vif_table
[reg_vif_num
].dev
;
1456 read_unlock(&mrt_lock
);
1458 if (reg_dev
== NULL
)
1461 skb
->mac
.raw
= skb
->nh
.raw
;
1462 skb_pull(skb
, (u8
*)encap
- skb
->data
);
1463 skb_reset_network_header(skb
);
1465 skb
->protocol
= htons(ETH_P_IP
);
1467 skb
->pkt_type
= PACKET_HOST
;
1468 dst_release(skb
->dst
);
1470 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_bytes
+= skb
->len
;
1471 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_packets
++;
1482 #ifdef CONFIG_IP_PIMSM_V2
1483 static int pim_rcv(struct sk_buff
* skb
)
1485 struct pimreghdr
*pim
;
1486 struct iphdr
*encap
;
1487 struct net_device
*reg_dev
= NULL
;
1489 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(*encap
)))
1492 pim
= (struct pimreghdr
*)skb
->h
.raw
;
1493 if (pim
->type
!= ((PIM_VERSION
<<4)|(PIM_REGISTER
)) ||
1494 (pim
->flags
&PIM_NULL_REGISTER
) ||
1495 (ip_compute_csum((void *)pim
, sizeof(*pim
)) != 0 &&
1496 csum_fold(skb_checksum(skb
, 0, skb
->len
, 0))))
1499 /* check if the inner packet is destined to mcast group */
1500 encap
= (struct iphdr
*)(skb
->h
.raw
+ sizeof(struct pimreghdr
));
1501 if (!MULTICAST(encap
->daddr
) ||
1502 encap
->tot_len
== 0 ||
1503 ntohs(encap
->tot_len
) + sizeof(*pim
) > skb
->len
)
1506 read_lock(&mrt_lock
);
1507 if (reg_vif_num
>= 0)
1508 reg_dev
= vif_table
[reg_vif_num
].dev
;
1511 read_unlock(&mrt_lock
);
1513 if (reg_dev
== NULL
)
1516 skb
->mac
.raw
= skb
->nh
.raw
;
1517 skb_pull(skb
, (u8
*)encap
- skb
->data
);
1518 skb_reset_network_header(skb
);
1520 skb
->protocol
= htons(ETH_P_IP
);
1522 skb
->pkt_type
= PACKET_HOST
;
1523 dst_release(skb
->dst
);
1524 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_bytes
+= skb
->len
;
1525 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_packets
++;
1538 ipmr_fill_mroute(struct sk_buff
*skb
, struct mfc_cache
*c
, struct rtmsg
*rtm
)
1541 struct rtnexthop
*nhp
;
1542 struct net_device
*dev
= vif_table
[c
->mfc_parent
].dev
;
1544 struct rtattr
*mp_head
;
1547 RTA_PUT(skb
, RTA_IIF
, 4, &dev
->ifindex
);
1549 mp_head
= (struct rtattr
*)skb_put(skb
, RTA_LENGTH(0));
1551 for (ct
= c
->mfc_un
.res
.minvif
; ct
< c
->mfc_un
.res
.maxvif
; ct
++) {
1552 if (c
->mfc_un
.res
.ttls
[ct
] < 255) {
1553 if (skb_tailroom(skb
) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp
)) + 4))
1554 goto rtattr_failure
;
1555 nhp
= (struct rtnexthop
*)skb_put(skb
, RTA_ALIGN(sizeof(*nhp
)));
1556 nhp
->rtnh_flags
= 0;
1557 nhp
->rtnh_hops
= c
->mfc_un
.res
.ttls
[ct
];
1558 nhp
->rtnh_ifindex
= vif_table
[ct
].dev
->ifindex
;
1559 nhp
->rtnh_len
= sizeof(*nhp
);
1562 mp_head
->rta_type
= RTA_MULTIPATH
;
1563 mp_head
->rta_len
= skb
->tail
- (u8
*)mp_head
;
1564 rtm
->rtm_type
= RTN_MULTICAST
;
1568 skb_trim(skb
, b
- skb
->data
);
1572 int ipmr_get_route(struct sk_buff
*skb
, struct rtmsg
*rtm
, int nowait
)
1575 struct mfc_cache
*cache
;
1576 struct rtable
*rt
= (struct rtable
*)skb
->dst
;
1578 read_lock(&mrt_lock
);
1579 cache
= ipmr_cache_find(rt
->rt_src
, rt
->rt_dst
);
1582 struct sk_buff
*skb2
;
1583 struct net_device
*dev
;
1587 read_unlock(&mrt_lock
);
1592 if (dev
== NULL
|| (vif
= ipmr_find_vif(dev
)) < 0) {
1593 read_unlock(&mrt_lock
);
1596 skb2
= skb_clone(skb
, GFP_ATOMIC
);
1598 read_unlock(&mrt_lock
);
1602 skb_push(skb2
, sizeof(struct iphdr
));
1603 skb_reset_network_header(skb2
);
1604 skb2
->nh
.iph
->ihl
= sizeof(struct iphdr
)>>2;
1605 skb2
->nh
.iph
->saddr
= rt
->rt_src
;
1606 skb2
->nh
.iph
->daddr
= rt
->rt_dst
;
1607 skb2
->nh
.iph
->version
= 0;
1608 err
= ipmr_cache_unresolved(vif
, skb2
);
1609 read_unlock(&mrt_lock
);
1613 if (!nowait
&& (rtm
->rtm_flags
&RTM_F_NOTIFY
))
1614 cache
->mfc_flags
|= MFC_NOTIFY
;
1615 err
= ipmr_fill_mroute(skb
, cache
, rtm
);
1616 read_unlock(&mrt_lock
);
1620 #ifdef CONFIG_PROC_FS
1622 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1624 struct ipmr_vif_iter
{
1628 static struct vif_device
*ipmr_vif_seq_idx(struct ipmr_vif_iter
*iter
,
1631 for (iter
->ct
= 0; iter
->ct
< maxvif
; ++iter
->ct
) {
1632 if (!VIF_EXISTS(iter
->ct
))
1635 return &vif_table
[iter
->ct
];
1640 static void *ipmr_vif_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1642 read_lock(&mrt_lock
);
1643 return *pos
? ipmr_vif_seq_idx(seq
->private, *pos
- 1)
1647 static void *ipmr_vif_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1649 struct ipmr_vif_iter
*iter
= seq
->private;
1652 if (v
== SEQ_START_TOKEN
)
1653 return ipmr_vif_seq_idx(iter
, 0);
1655 while (++iter
->ct
< maxvif
) {
1656 if (!VIF_EXISTS(iter
->ct
))
1658 return &vif_table
[iter
->ct
];
1663 static void ipmr_vif_seq_stop(struct seq_file
*seq
, void *v
)
1665 read_unlock(&mrt_lock
);
1668 static int ipmr_vif_seq_show(struct seq_file
*seq
, void *v
)
1670 if (v
== SEQ_START_TOKEN
) {
1672 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1674 const struct vif_device
*vif
= v
;
1675 const char *name
= vif
->dev
? vif
->dev
->name
: "none";
1678 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1680 name
, vif
->bytes_in
, vif
->pkt_in
,
1681 vif
->bytes_out
, vif
->pkt_out
,
1682 vif
->flags
, vif
->local
, vif
->remote
);
1687 static const struct seq_operations ipmr_vif_seq_ops
= {
1688 .start
= ipmr_vif_seq_start
,
1689 .next
= ipmr_vif_seq_next
,
1690 .stop
= ipmr_vif_seq_stop
,
1691 .show
= ipmr_vif_seq_show
,
1694 static int ipmr_vif_open(struct inode
*inode
, struct file
*file
)
1696 struct seq_file
*seq
;
1698 struct ipmr_vif_iter
*s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1703 rc
= seq_open(file
, &ipmr_vif_seq_ops
);
1708 seq
= file
->private_data
;
1718 static const struct file_operations ipmr_vif_fops
= {
1719 .owner
= THIS_MODULE
,
1720 .open
= ipmr_vif_open
,
1722 .llseek
= seq_lseek
,
1723 .release
= seq_release_private
,
1726 struct ipmr_mfc_iter
{
1727 struct mfc_cache
**cache
;
1732 static struct mfc_cache
*ipmr_mfc_seq_idx(struct ipmr_mfc_iter
*it
, loff_t pos
)
1734 struct mfc_cache
*mfc
;
1736 it
->cache
= mfc_cache_array
;
1737 read_lock(&mrt_lock
);
1738 for (it
->ct
= 0; it
->ct
< MFC_LINES
; it
->ct
++)
1739 for (mfc
= mfc_cache_array
[it
->ct
]; mfc
; mfc
= mfc
->next
)
1742 read_unlock(&mrt_lock
);
1744 it
->cache
= &mfc_unres_queue
;
1745 spin_lock_bh(&mfc_unres_lock
);
1746 for (mfc
= mfc_unres_queue
; mfc
; mfc
= mfc
->next
)
1749 spin_unlock_bh(&mfc_unres_lock
);
1756 static void *ipmr_mfc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1758 struct ipmr_mfc_iter
*it
= seq
->private;
1761 return *pos
? ipmr_mfc_seq_idx(seq
->private, *pos
- 1)
1765 static void *ipmr_mfc_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1767 struct mfc_cache
*mfc
= v
;
1768 struct ipmr_mfc_iter
*it
= seq
->private;
1772 if (v
== SEQ_START_TOKEN
)
1773 return ipmr_mfc_seq_idx(seq
->private, 0);
1778 if (it
->cache
== &mfc_unres_queue
)
1781 BUG_ON(it
->cache
!= mfc_cache_array
);
1783 while (++it
->ct
< MFC_LINES
) {
1784 mfc
= mfc_cache_array
[it
->ct
];
1789 /* exhausted cache_array, show unresolved */
1790 read_unlock(&mrt_lock
);
1791 it
->cache
= &mfc_unres_queue
;
1794 spin_lock_bh(&mfc_unres_lock
);
1795 mfc
= mfc_unres_queue
;
1800 spin_unlock_bh(&mfc_unres_lock
);
1806 static void ipmr_mfc_seq_stop(struct seq_file
*seq
, void *v
)
1808 struct ipmr_mfc_iter
*it
= seq
->private;
1810 if (it
->cache
== &mfc_unres_queue
)
1811 spin_unlock_bh(&mfc_unres_lock
);
1812 else if (it
->cache
== mfc_cache_array
)
1813 read_unlock(&mrt_lock
);
1816 static int ipmr_mfc_seq_show(struct seq_file
*seq
, void *v
)
1820 if (v
== SEQ_START_TOKEN
) {
1822 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1824 const struct mfc_cache
*mfc
= v
;
1825 const struct ipmr_mfc_iter
*it
= seq
->private;
1827 seq_printf(seq
, "%08lX %08lX %-3d %8ld %8ld %8ld",
1828 (unsigned long) mfc
->mfc_mcastgrp
,
1829 (unsigned long) mfc
->mfc_origin
,
1831 mfc
->mfc_un
.res
.pkt
,
1832 mfc
->mfc_un
.res
.bytes
,
1833 mfc
->mfc_un
.res
.wrong_if
);
1835 if (it
->cache
!= &mfc_unres_queue
) {
1836 for (n
= mfc
->mfc_un
.res
.minvif
;
1837 n
< mfc
->mfc_un
.res
.maxvif
; n
++ ) {
1839 && mfc
->mfc_un
.res
.ttls
[n
] < 255)
1842 n
, mfc
->mfc_un
.res
.ttls
[n
]);
1845 seq_putc(seq
, '\n');
1850 static const struct seq_operations ipmr_mfc_seq_ops
= {
1851 .start
= ipmr_mfc_seq_start
,
1852 .next
= ipmr_mfc_seq_next
,
1853 .stop
= ipmr_mfc_seq_stop
,
1854 .show
= ipmr_mfc_seq_show
,
1857 static int ipmr_mfc_open(struct inode
*inode
, struct file
*file
)
1859 struct seq_file
*seq
;
1861 struct ipmr_mfc_iter
*s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1866 rc
= seq_open(file
, &ipmr_mfc_seq_ops
);
1870 seq
= file
->private_data
;
1880 static const struct file_operations ipmr_mfc_fops
= {
1881 .owner
= THIS_MODULE
,
1882 .open
= ipmr_mfc_open
,
1884 .llseek
= seq_lseek
,
1885 .release
= seq_release_private
,
1889 #ifdef CONFIG_IP_PIMSM_V2
1890 static struct net_protocol pim_protocol
= {
1897 * Setup for IP multicast routing
1900 void __init
ip_mr_init(void)
1902 mrt_cachep
= kmem_cache_create("ip_mrt_cache",
1903 sizeof(struct mfc_cache
),
1904 0, SLAB_HWCACHE_ALIGN
|SLAB_PANIC
,
1906 init_timer(&ipmr_expire_timer
);
1907 ipmr_expire_timer
.function
=ipmr_expire_process
;
1908 register_netdevice_notifier(&ip_mr_notifier
);
1909 #ifdef CONFIG_PROC_FS
1910 proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops
);
1911 proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops
);