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>
52 #include <net/net_namespace.h>
54 #include <net/protocol.h>
55 #include <linux/skbuff.h>
56 #include <net/route.h>
61 #include <linux/notifier.h>
62 #include <linux/if_arp.h>
63 #include <linux/netfilter_ipv4.h>
65 #include <net/checksum.h>
66 #include <net/netlink.h>
68 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
69 #define CONFIG_IP_PIMSM 1
72 static struct sock
*mroute_socket
;
75 /* Big lock, protecting vif table, mrt cache and mroute socket state.
76 Note that the changes are semaphored via rtnl_lock.
79 static DEFINE_RWLOCK(mrt_lock
);
82 * Multicast router control variables
85 static struct vif_device vif_table
[MAXVIFS
]; /* Devices */
88 #define VIF_EXISTS(idx) (vif_table[idx].dev != NULL)
90 static int mroute_do_assert
; /* Set in PIM assert */
91 static int mroute_do_pim
;
93 static struct mfc_cache
*mfc_cache_array
[MFC_LINES
]; /* Forwarding cache */
95 static struct mfc_cache
*mfc_unres_queue
; /* Queue of unresolved entries */
96 static atomic_t cache_resolve_queue_len
; /* Size of unresolved */
98 /* Special spinlock for queue of unresolved entries */
99 static DEFINE_SPINLOCK(mfc_unres_lock
);
101 /* We return to original Alan's scheme. Hash table of resolved
102 entries is changed only in process context and protected
103 with weak lock mrt_lock. Queue of unresolved entries is protected
104 with strong spinlock mfc_unres_lock.
106 In this case data path is free of exclusive locks at all.
109 static struct kmem_cache
*mrt_cachep __read_mostly
;
111 static int ip_mr_forward(struct sk_buff
*skb
, struct mfc_cache
*cache
, int local
);
112 static int ipmr_cache_report(struct sk_buff
*pkt
, vifi_t vifi
, int assert);
113 static int ipmr_fill_mroute(struct sk_buff
*skb
, struct mfc_cache
*c
, struct rtmsg
*rtm
);
115 #ifdef CONFIG_IP_PIMSM_V2
116 static struct net_protocol pim_protocol
;
119 static struct timer_list ipmr_expire_timer
;
121 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
124 struct net_device
*ipmr_new_tunnel(struct vifctl
*v
)
126 struct net_device
*dev
;
128 dev
= __dev_get_by_name("tunl0");
134 struct ip_tunnel_parm p
;
135 struct in_device
*in_dev
;
137 memset(&p
, 0, sizeof(p
));
138 p
.iph
.daddr
= v
->vifc_rmt_addr
.s_addr
;
139 p
.iph
.saddr
= v
->vifc_lcl_addr
.s_addr
;
142 p
.iph
.protocol
= IPPROTO_IPIP
;
143 sprintf(p
.name
, "dvmrp%d", v
->vifc_vifi
);
144 ifr
.ifr_ifru
.ifru_data
= (void*)&p
;
146 oldfs
= get_fs(); set_fs(KERNEL_DS
);
147 err
= dev
->do_ioctl(dev
, &ifr
, SIOCADDTUNNEL
);
152 if (err
== 0 && (dev
= __dev_get_by_name(p
.name
)) != NULL
) {
153 dev
->flags
|= IFF_MULTICAST
;
155 in_dev
= __in_dev_get_rtnl(dev
);
159 ipv4_devconf_setall(in_dev
);
160 IPV4_DEVCONF(in_dev
->cnf
, RP_FILTER
) = 0;
169 /* allow the register to be completed before unregistering. */
173 unregister_netdevice(dev
);
177 #ifdef CONFIG_IP_PIMSM
179 static int reg_vif_num
= -1;
181 static int reg_vif_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
183 read_lock(&mrt_lock
);
184 ((struct net_device_stats
*)netdev_priv(dev
))->tx_bytes
+= skb
->len
;
185 ((struct net_device_stats
*)netdev_priv(dev
))->tx_packets
++;
186 ipmr_cache_report(skb
, reg_vif_num
, IGMPMSG_WHOLEPKT
);
187 read_unlock(&mrt_lock
);
192 static struct net_device_stats
*reg_vif_get_stats(struct net_device
*dev
)
194 return (struct net_device_stats
*)netdev_priv(dev
);
197 static void reg_vif_setup(struct net_device
*dev
)
199 dev
->type
= ARPHRD_PIMREG
;
200 dev
->mtu
= ETH_DATA_LEN
- sizeof(struct iphdr
) - 8;
201 dev
->flags
= IFF_NOARP
;
202 dev
->hard_start_xmit
= reg_vif_xmit
;
203 dev
->get_stats
= reg_vif_get_stats
;
204 dev
->destructor
= free_netdev
;
207 static struct net_device
*ipmr_reg_vif(void)
209 struct net_device
*dev
;
210 struct in_device
*in_dev
;
212 dev
= alloc_netdev(sizeof(struct net_device_stats
), "pimreg",
218 if (register_netdevice(dev
)) {
225 if ((in_dev
= __in_dev_get_rcu(dev
)) == NULL
) {
230 ipv4_devconf_setall(in_dev
);
231 IPV4_DEVCONF(in_dev
->cnf
, RP_FILTER
) = 0;
240 /* allow the register to be completed before unregistering. */
244 unregister_netdevice(dev
);
253 static int vif_delete(int vifi
)
255 struct vif_device
*v
;
256 struct net_device
*dev
;
257 struct in_device
*in_dev
;
259 if (vifi
< 0 || vifi
>= maxvif
)
260 return -EADDRNOTAVAIL
;
262 v
= &vif_table
[vifi
];
264 write_lock_bh(&mrt_lock
);
269 write_unlock_bh(&mrt_lock
);
270 return -EADDRNOTAVAIL
;
273 #ifdef CONFIG_IP_PIMSM
274 if (vifi
== reg_vif_num
)
278 if (vifi
+1 == maxvif
) {
280 for (tmp
=vifi
-1; tmp
>=0; tmp
--) {
287 write_unlock_bh(&mrt_lock
);
289 dev_set_allmulti(dev
, -1);
291 if ((in_dev
= __in_dev_get_rtnl(dev
)) != NULL
) {
292 IPV4_DEVCONF(in_dev
->cnf
, MC_FORWARDING
)--;
293 ip_rt_multicast_event(in_dev
);
296 if (v
->flags
&(VIFF_TUNNEL
|VIFF_REGISTER
))
297 unregister_netdevice(dev
);
303 /* Destroy an unresolved cache entry, killing queued skbs
304 and reporting error to netlink readers.
307 static void ipmr_destroy_unres(struct mfc_cache
*c
)
312 atomic_dec(&cache_resolve_queue_len
);
314 while ((skb
=skb_dequeue(&c
->mfc_un
.unres
.unresolved
))) {
315 if (ip_hdr(skb
)->version
== 0) {
316 struct nlmsghdr
*nlh
= (struct nlmsghdr
*)skb_pull(skb
, sizeof(struct iphdr
));
317 nlh
->nlmsg_type
= NLMSG_ERROR
;
318 nlh
->nlmsg_len
= NLMSG_LENGTH(sizeof(struct nlmsgerr
));
319 skb_trim(skb
, nlh
->nlmsg_len
);
321 e
->error
= -ETIMEDOUT
;
322 memset(&e
->msg
, 0, sizeof(e
->msg
));
324 rtnl_unicast(skb
, NETLINK_CB(skb
).pid
);
329 kmem_cache_free(mrt_cachep
, c
);
333 /* Single timer process for all the unresolved queue. */
335 static void ipmr_expire_process(unsigned long dummy
)
338 unsigned long expires
;
339 struct mfc_cache
*c
, **cp
;
341 if (!spin_trylock(&mfc_unres_lock
)) {
342 mod_timer(&ipmr_expire_timer
, jiffies
+HZ
/10);
346 if (atomic_read(&cache_resolve_queue_len
) == 0)
351 cp
= &mfc_unres_queue
;
353 while ((c
=*cp
) != NULL
) {
354 if (time_after(c
->mfc_un
.unres
.expires
, now
)) {
355 unsigned long interval
= c
->mfc_un
.unres
.expires
- now
;
356 if (interval
< expires
)
364 ipmr_destroy_unres(c
);
367 if (atomic_read(&cache_resolve_queue_len
))
368 mod_timer(&ipmr_expire_timer
, jiffies
+ expires
);
371 spin_unlock(&mfc_unres_lock
);
374 /* Fill oifs list. It is called under write locked mrt_lock. */
376 static void ipmr_update_thresholds(struct mfc_cache
*cache
, unsigned char *ttls
)
380 cache
->mfc_un
.res
.minvif
= MAXVIFS
;
381 cache
->mfc_un
.res
.maxvif
= 0;
382 memset(cache
->mfc_un
.res
.ttls
, 255, MAXVIFS
);
384 for (vifi
=0; vifi
<maxvif
; vifi
++) {
385 if (VIF_EXISTS(vifi
) && ttls
[vifi
] && ttls
[vifi
] < 255) {
386 cache
->mfc_un
.res
.ttls
[vifi
] = ttls
[vifi
];
387 if (cache
->mfc_un
.res
.minvif
> vifi
)
388 cache
->mfc_un
.res
.minvif
= vifi
;
389 if (cache
->mfc_un
.res
.maxvif
<= vifi
)
390 cache
->mfc_un
.res
.maxvif
= vifi
+ 1;
395 static int vif_add(struct vifctl
*vifc
, int mrtsock
)
397 int vifi
= vifc
->vifc_vifi
;
398 struct vif_device
*v
= &vif_table
[vifi
];
399 struct net_device
*dev
;
400 struct in_device
*in_dev
;
403 if (VIF_EXISTS(vifi
))
406 switch (vifc
->vifc_flags
) {
407 #ifdef CONFIG_IP_PIMSM
410 * Special Purpose VIF in PIM
411 * All the packets will be sent to the daemon
413 if (reg_vif_num
>= 0)
415 dev
= ipmr_reg_vif();
421 dev
= ipmr_new_tunnel(vifc
);
426 dev
= ip_dev_find(vifc
->vifc_lcl_addr
.s_addr
);
428 return -EADDRNOTAVAIL
;
435 if ((in_dev
= __in_dev_get_rtnl(dev
)) == NULL
)
436 return -EADDRNOTAVAIL
;
437 IPV4_DEVCONF(in_dev
->cnf
, MC_FORWARDING
)++;
438 dev_set_allmulti(dev
, +1);
439 ip_rt_multicast_event(in_dev
);
442 * Fill in the VIF structures
444 v
->rate_limit
=vifc
->vifc_rate_limit
;
445 v
->local
=vifc
->vifc_lcl_addr
.s_addr
;
446 v
->remote
=vifc
->vifc_rmt_addr
.s_addr
;
447 v
->flags
=vifc
->vifc_flags
;
449 v
->flags
|= VIFF_STATIC
;
450 v
->threshold
=vifc
->vifc_threshold
;
455 v
->link
= dev
->ifindex
;
456 if (v
->flags
&(VIFF_TUNNEL
|VIFF_REGISTER
))
457 v
->link
= dev
->iflink
;
459 /* And finish update writing critical data */
460 write_lock_bh(&mrt_lock
);
463 #ifdef CONFIG_IP_PIMSM
464 if (v
->flags
&VIFF_REGISTER
)
469 write_unlock_bh(&mrt_lock
);
473 static struct mfc_cache
*ipmr_cache_find(__be32 origin
, __be32 mcastgrp
)
475 int line
=MFC_HASH(mcastgrp
,origin
);
478 for (c
=mfc_cache_array
[line
]; c
; c
= c
->next
) {
479 if (c
->mfc_origin
==origin
&& c
->mfc_mcastgrp
==mcastgrp
)
486 * Allocate a multicast cache entry
488 static struct mfc_cache
*ipmr_cache_alloc(void)
490 struct mfc_cache
*c
=kmem_cache_zalloc(mrt_cachep
, GFP_KERNEL
);
493 c
->mfc_un
.res
.minvif
= MAXVIFS
;
497 static struct mfc_cache
*ipmr_cache_alloc_unres(void)
499 struct mfc_cache
*c
=kmem_cache_zalloc(mrt_cachep
, GFP_ATOMIC
);
502 skb_queue_head_init(&c
->mfc_un
.unres
.unresolved
);
503 c
->mfc_un
.unres
.expires
= jiffies
+ 10*HZ
;
508 * A cache entry has gone into a resolved state from queued
511 static void ipmr_cache_resolve(struct mfc_cache
*uc
, struct mfc_cache
*c
)
517 * Play the pending entries through our router
520 while ((skb
=__skb_dequeue(&uc
->mfc_un
.unres
.unresolved
))) {
521 if (ip_hdr(skb
)->version
== 0) {
522 struct nlmsghdr
*nlh
= (struct nlmsghdr
*)skb_pull(skb
, sizeof(struct iphdr
));
524 if (ipmr_fill_mroute(skb
, c
, NLMSG_DATA(nlh
)) > 0) {
525 nlh
->nlmsg_len
= (skb_tail_pointer(skb
) -
528 nlh
->nlmsg_type
= NLMSG_ERROR
;
529 nlh
->nlmsg_len
= NLMSG_LENGTH(sizeof(struct nlmsgerr
));
530 skb_trim(skb
, nlh
->nlmsg_len
);
532 e
->error
= -EMSGSIZE
;
533 memset(&e
->msg
, 0, sizeof(e
->msg
));
536 rtnl_unicast(skb
, NETLINK_CB(skb
).pid
);
538 ip_mr_forward(skb
, c
, 0);
543 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
544 * expects the following bizarre scheme.
546 * Called under mrt_lock.
549 static int ipmr_cache_report(struct sk_buff
*pkt
, vifi_t vifi
, int assert)
552 const int ihl
= ip_hdrlen(pkt
);
553 struct igmphdr
*igmp
;
557 #ifdef CONFIG_IP_PIMSM
558 if (assert == IGMPMSG_WHOLEPKT
)
559 skb
= skb_realloc_headroom(pkt
, sizeof(struct iphdr
));
562 skb
= alloc_skb(128, GFP_ATOMIC
);
567 #ifdef CONFIG_IP_PIMSM
568 if (assert == IGMPMSG_WHOLEPKT
) {
569 /* Ugly, but we have no choice with this interface.
570 Duplicate old header, fix ihl, length etc.
571 And all this only to mangle msg->im_msgtype and
572 to set msg->im_mbz to "mbz" :-)
574 skb_push(skb
, sizeof(struct iphdr
));
575 skb_reset_network_header(skb
);
576 skb_reset_transport_header(skb
);
577 msg
= (struct igmpmsg
*)skb_network_header(skb
);
578 memcpy(msg
, skb_network_header(pkt
), sizeof(struct iphdr
));
579 msg
->im_msgtype
= IGMPMSG_WHOLEPKT
;
581 msg
->im_vif
= reg_vif_num
;
582 ip_hdr(skb
)->ihl
= sizeof(struct iphdr
) >> 2;
583 ip_hdr(skb
)->tot_len
= htons(ntohs(ip_hdr(pkt
)->tot_len
) +
584 sizeof(struct iphdr
));
593 skb
->network_header
= skb
->tail
;
595 skb_copy_to_linear_data(skb
, pkt
->data
, ihl
);
596 ip_hdr(skb
)->protocol
= 0; /* Flag to the kernel this is a route add */
597 msg
= (struct igmpmsg
*)skb_network_header(skb
);
599 skb
->dst
= dst_clone(pkt
->dst
);
605 igmp
=(struct igmphdr
*)skb_put(skb
,sizeof(struct igmphdr
));
607 msg
->im_msgtype
= assert;
609 ip_hdr(skb
)->tot_len
= htons(skb
->len
); /* Fix the length */
610 skb
->transport_header
= skb
->network_header
;
613 if (mroute_socket
== NULL
) {
621 if ((ret
=sock_queue_rcv_skb(mroute_socket
,skb
))<0) {
623 printk(KERN_WARNING
"mroute: pending queue full, dropping entries.\n");
631 * Queue a packet for resolution. It gets locked cache entry!
635 ipmr_cache_unresolved(vifi_t vifi
, struct sk_buff
*skb
)
639 const struct iphdr
*iph
= ip_hdr(skb
);
641 spin_lock_bh(&mfc_unres_lock
);
642 for (c
=mfc_unres_queue
; c
; c
=c
->next
) {
643 if (c
->mfc_mcastgrp
== iph
->daddr
&&
644 c
->mfc_origin
== iph
->saddr
)
650 * Create a new entry if allowable
653 if (atomic_read(&cache_resolve_queue_len
)>=10 ||
654 (c
=ipmr_cache_alloc_unres())==NULL
) {
655 spin_unlock_bh(&mfc_unres_lock
);
662 * Fill in the new cache entry
665 c
->mfc_origin
= iph
->saddr
;
666 c
->mfc_mcastgrp
= iph
->daddr
;
669 * Reflect first query at mrouted.
671 if ((err
= ipmr_cache_report(skb
, vifi
, IGMPMSG_NOCACHE
))<0) {
672 /* If the report failed throw the cache entry
675 spin_unlock_bh(&mfc_unres_lock
);
677 kmem_cache_free(mrt_cachep
, c
);
682 atomic_inc(&cache_resolve_queue_len
);
683 c
->next
= mfc_unres_queue
;
686 mod_timer(&ipmr_expire_timer
, c
->mfc_un
.unres
.expires
);
690 * See if we can append the packet
692 if (c
->mfc_un
.unres
.unresolved
.qlen
>3) {
696 skb_queue_tail(&c
->mfc_un
.unres
.unresolved
,skb
);
700 spin_unlock_bh(&mfc_unres_lock
);
705 * MFC cache manipulation by user space mroute daemon
708 static int ipmr_mfc_delete(struct mfcctl
*mfc
)
711 struct mfc_cache
*c
, **cp
;
713 line
=MFC_HASH(mfc
->mfcc_mcastgrp
.s_addr
, mfc
->mfcc_origin
.s_addr
);
715 for (cp
=&mfc_cache_array
[line
]; (c
=*cp
) != NULL
; cp
= &c
->next
) {
716 if (c
->mfc_origin
== mfc
->mfcc_origin
.s_addr
&&
717 c
->mfc_mcastgrp
== mfc
->mfcc_mcastgrp
.s_addr
) {
718 write_lock_bh(&mrt_lock
);
720 write_unlock_bh(&mrt_lock
);
722 kmem_cache_free(mrt_cachep
, c
);
729 static int ipmr_mfc_add(struct mfcctl
*mfc
, int mrtsock
)
732 struct mfc_cache
*uc
, *c
, **cp
;
734 line
=MFC_HASH(mfc
->mfcc_mcastgrp
.s_addr
, mfc
->mfcc_origin
.s_addr
);
736 for (cp
=&mfc_cache_array
[line
]; (c
=*cp
) != NULL
; cp
= &c
->next
) {
737 if (c
->mfc_origin
== mfc
->mfcc_origin
.s_addr
&&
738 c
->mfc_mcastgrp
== mfc
->mfcc_mcastgrp
.s_addr
)
743 write_lock_bh(&mrt_lock
);
744 c
->mfc_parent
= mfc
->mfcc_parent
;
745 ipmr_update_thresholds(c
, mfc
->mfcc_ttls
);
747 c
->mfc_flags
|= MFC_STATIC
;
748 write_unlock_bh(&mrt_lock
);
752 if (!MULTICAST(mfc
->mfcc_mcastgrp
.s_addr
))
755 c
=ipmr_cache_alloc();
759 c
->mfc_origin
=mfc
->mfcc_origin
.s_addr
;
760 c
->mfc_mcastgrp
=mfc
->mfcc_mcastgrp
.s_addr
;
761 c
->mfc_parent
=mfc
->mfcc_parent
;
762 ipmr_update_thresholds(c
, mfc
->mfcc_ttls
);
764 c
->mfc_flags
|= MFC_STATIC
;
766 write_lock_bh(&mrt_lock
);
767 c
->next
= mfc_cache_array
[line
];
768 mfc_cache_array
[line
] = c
;
769 write_unlock_bh(&mrt_lock
);
772 * Check to see if we resolved a queued list. If so we
773 * need to send on the frames and tidy up.
775 spin_lock_bh(&mfc_unres_lock
);
776 for (cp
= &mfc_unres_queue
; (uc
=*cp
) != NULL
;
778 if (uc
->mfc_origin
== c
->mfc_origin
&&
779 uc
->mfc_mcastgrp
== c
->mfc_mcastgrp
) {
781 if (atomic_dec_and_test(&cache_resolve_queue_len
))
782 del_timer(&ipmr_expire_timer
);
786 spin_unlock_bh(&mfc_unres_lock
);
789 ipmr_cache_resolve(uc
, c
);
790 kmem_cache_free(mrt_cachep
, uc
);
796 * Close the multicast socket, and clear the vif tables etc
799 static void mroute_clean_tables(struct sock
*sk
)
804 * Shut down all active vif entries
806 for (i
=0; i
<maxvif
; i
++) {
807 if (!(vif_table
[i
].flags
&VIFF_STATIC
))
814 for (i
=0;i
<MFC_LINES
;i
++) {
815 struct mfc_cache
*c
, **cp
;
817 cp
= &mfc_cache_array
[i
];
818 while ((c
= *cp
) != NULL
) {
819 if (c
->mfc_flags
&MFC_STATIC
) {
823 write_lock_bh(&mrt_lock
);
825 write_unlock_bh(&mrt_lock
);
827 kmem_cache_free(mrt_cachep
, c
);
831 if (atomic_read(&cache_resolve_queue_len
) != 0) {
834 spin_lock_bh(&mfc_unres_lock
);
835 while (mfc_unres_queue
!= NULL
) {
837 mfc_unres_queue
= c
->next
;
838 spin_unlock_bh(&mfc_unres_lock
);
840 ipmr_destroy_unres(c
);
842 spin_lock_bh(&mfc_unres_lock
);
844 spin_unlock_bh(&mfc_unres_lock
);
848 static void mrtsock_destruct(struct sock
*sk
)
851 if (sk
== mroute_socket
) {
852 IPV4_DEVCONF_ALL(MC_FORWARDING
)--;
854 write_lock_bh(&mrt_lock
);
856 write_unlock_bh(&mrt_lock
);
858 mroute_clean_tables(sk
);
864 * Socket options and virtual interface manipulation. The whole
865 * virtual interface system is a complete heap, but unfortunately
866 * that's how BSD mrouted happens to think. Maybe one day with a proper
867 * MOSPF/PIM router set up we can clean this up.
870 int ip_mroute_setsockopt(struct sock
*sk
,int optname
,char __user
*optval
,int optlen
)
876 if (optname
!= MRT_INIT
) {
877 if (sk
!= mroute_socket
&& !capable(CAP_NET_ADMIN
))
883 if (sk
->sk_type
!= SOCK_RAW
||
884 inet_sk(sk
)->num
!= IPPROTO_IGMP
)
886 if (optlen
!=sizeof(int))
895 ret
= ip_ra_control(sk
, 1, mrtsock_destruct
);
897 write_lock_bh(&mrt_lock
);
899 write_unlock_bh(&mrt_lock
);
901 IPV4_DEVCONF_ALL(MC_FORWARDING
)++;
906 if (sk
!=mroute_socket
)
908 return ip_ra_control(sk
, 0, NULL
);
911 if (optlen
!=sizeof(vif
))
913 if (copy_from_user(&vif
,optval
,sizeof(vif
)))
915 if (vif
.vifc_vifi
>= MAXVIFS
)
918 if (optname
==MRT_ADD_VIF
) {
919 ret
= vif_add(&vif
, sk
==mroute_socket
);
921 ret
= vif_delete(vif
.vifc_vifi
);
927 * Manipulate the forwarding caches. These live
928 * in a sort of kernel/user symbiosis.
932 if (optlen
!=sizeof(mfc
))
934 if (copy_from_user(&mfc
,optval
, sizeof(mfc
)))
937 if (optname
==MRT_DEL_MFC
)
938 ret
= ipmr_mfc_delete(&mfc
);
940 ret
= ipmr_mfc_add(&mfc
, sk
==mroute_socket
);
944 * Control PIM assert.
949 if (get_user(v
,(int __user
*)optval
))
951 mroute_do_assert
=(v
)?1:0;
954 #ifdef CONFIG_IP_PIMSM
958 if (get_user(v
,(int __user
*)optval
))
963 if (v
!= mroute_do_pim
) {
965 mroute_do_assert
= v
;
966 #ifdef CONFIG_IP_PIMSM_V2
968 ret
= inet_add_protocol(&pim_protocol
,
971 ret
= inet_del_protocol(&pim_protocol
,
982 * Spurious command, or MRT_VERSION which you cannot
991 * Getsock opt support for the multicast routing system.
994 int ip_mroute_getsockopt(struct sock
*sk
,int optname
,char __user
*optval
,int __user
*optlen
)
999 if (optname
!=MRT_VERSION
&&
1000 #ifdef CONFIG_IP_PIMSM
1003 optname
!=MRT_ASSERT
)
1004 return -ENOPROTOOPT
;
1006 if (get_user(olr
, optlen
))
1009 olr
= min_t(unsigned int, olr
, sizeof(int));
1013 if (put_user(olr
,optlen
))
1015 if (optname
==MRT_VERSION
)
1017 #ifdef CONFIG_IP_PIMSM
1018 else if (optname
==MRT_PIM
)
1022 val
=mroute_do_assert
;
1023 if (copy_to_user(optval
,&val
,olr
))
1029 * The IP multicast ioctl support routines.
1032 int ipmr_ioctl(struct sock
*sk
, int cmd
, void __user
*arg
)
1034 struct sioc_sg_req sr
;
1035 struct sioc_vif_req vr
;
1036 struct vif_device
*vif
;
1037 struct mfc_cache
*c
;
1041 if (copy_from_user(&vr
,arg
,sizeof(vr
)))
1043 if (vr
.vifi
>=maxvif
)
1045 read_lock(&mrt_lock
);
1046 vif
=&vif_table
[vr
.vifi
];
1047 if (VIF_EXISTS(vr
.vifi
)) {
1048 vr
.icount
=vif
->pkt_in
;
1049 vr
.ocount
=vif
->pkt_out
;
1050 vr
.ibytes
=vif
->bytes_in
;
1051 vr
.obytes
=vif
->bytes_out
;
1052 read_unlock(&mrt_lock
);
1054 if (copy_to_user(arg
,&vr
,sizeof(vr
)))
1058 read_unlock(&mrt_lock
);
1059 return -EADDRNOTAVAIL
;
1061 if (copy_from_user(&sr
,arg
,sizeof(sr
)))
1064 read_lock(&mrt_lock
);
1065 c
= ipmr_cache_find(sr
.src
.s_addr
, sr
.grp
.s_addr
);
1067 sr
.pktcnt
= c
->mfc_un
.res
.pkt
;
1068 sr
.bytecnt
= c
->mfc_un
.res
.bytes
;
1069 sr
.wrong_if
= c
->mfc_un
.res
.wrong_if
;
1070 read_unlock(&mrt_lock
);
1072 if (copy_to_user(arg
,&sr
,sizeof(sr
)))
1076 read_unlock(&mrt_lock
);
1077 return -EADDRNOTAVAIL
;
1079 return -ENOIOCTLCMD
;
1084 static int ipmr_device_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1086 struct vif_device
*v
;
1088 if (event
!= NETDEV_UNREGISTER
)
1091 for (ct
=0;ct
<maxvif
;ct
++,v
++) {
1099 static struct notifier_block ip_mr_notifier
={
1100 .notifier_call
= ipmr_device_event
,
1104 * Encapsulate a packet by attaching a valid IPIP header to it.
1105 * This avoids tunnel drivers and other mess and gives us the speed so
1106 * important for multicast video.
1109 static void ip_encap(struct sk_buff
*skb
, __be32 saddr
, __be32 daddr
)
1112 struct iphdr
*old_iph
= ip_hdr(skb
);
1114 skb_push(skb
, sizeof(struct iphdr
));
1115 skb
->transport_header
= skb
->network_header
;
1116 skb_reset_network_header(skb
);
1120 iph
->tos
= old_iph
->tos
;
1121 iph
->ttl
= old_iph
->ttl
;
1125 iph
->protocol
= IPPROTO_IPIP
;
1127 iph
->tot_len
= htons(skb
->len
);
1128 ip_select_ident(iph
, skb
->dst
, NULL
);
1131 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
1135 static inline int ipmr_forward_finish(struct sk_buff
*skb
)
1137 struct ip_options
* opt
= &(IPCB(skb
)->opt
);
1139 IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS
);
1141 if (unlikely(opt
->optlen
))
1142 ip_forward_options(skb
);
1144 return dst_output(skb
);
1148 * Processing handlers for ipmr_forward
1151 static void ipmr_queue_xmit(struct sk_buff
*skb
, struct mfc_cache
*c
, int vifi
)
1153 const struct iphdr
*iph
= ip_hdr(skb
);
1154 struct vif_device
*vif
= &vif_table
[vifi
];
1155 struct net_device
*dev
;
1159 if (vif
->dev
== NULL
)
1162 #ifdef CONFIG_IP_PIMSM
1163 if (vif
->flags
& VIFF_REGISTER
) {
1165 vif
->bytes_out
+=skb
->len
;
1166 ((struct net_device_stats
*)netdev_priv(vif
->dev
))->tx_bytes
+= skb
->len
;
1167 ((struct net_device_stats
*)netdev_priv(vif
->dev
))->tx_packets
++;
1168 ipmr_cache_report(skb
, vifi
, IGMPMSG_WHOLEPKT
);
1174 if (vif
->flags
&VIFF_TUNNEL
) {
1175 struct flowi fl
= { .oif
= vif
->link
,
1177 { .daddr
= vif
->remote
,
1178 .saddr
= vif
->local
,
1179 .tos
= RT_TOS(iph
->tos
) } },
1180 .proto
= IPPROTO_IPIP
};
1181 if (ip_route_output_key(&rt
, &fl
))
1183 encap
= sizeof(struct iphdr
);
1185 struct flowi fl
= { .oif
= vif
->link
,
1187 { .daddr
= iph
->daddr
,
1188 .tos
= RT_TOS(iph
->tos
) } },
1189 .proto
= IPPROTO_IPIP
};
1190 if (ip_route_output_key(&rt
, &fl
))
1194 dev
= rt
->u
.dst
.dev
;
1196 if (skb
->len
+encap
> dst_mtu(&rt
->u
.dst
) && (ntohs(iph
->frag_off
) & IP_DF
)) {
1197 /* Do not fragment multicasts. Alas, IPv4 does not
1198 allow to send ICMP, so that packets will disappear
1202 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS
);
1207 encap
+= LL_RESERVED_SPACE(dev
) + rt
->u
.dst
.header_len
;
1209 if (skb_cow(skb
, encap
)) {
1215 vif
->bytes_out
+=skb
->len
;
1217 dst_release(skb
->dst
);
1218 skb
->dst
= &rt
->u
.dst
;
1219 ip_decrease_ttl(ip_hdr(skb
));
1221 /* FIXME: forward and output firewalls used to be called here.
1222 * What do we do with netfilter? -- RR */
1223 if (vif
->flags
& VIFF_TUNNEL
) {
1224 ip_encap(skb
, vif
->local
, vif
->remote
);
1225 /* FIXME: extra output firewall step used to be here. --RR */
1226 ((struct ip_tunnel
*)netdev_priv(vif
->dev
))->stat
.tx_packets
++;
1227 ((struct ip_tunnel
*)netdev_priv(vif
->dev
))->stat
.tx_bytes
+=skb
->len
;
1230 IPCB(skb
)->flags
|= IPSKB_FORWARDED
;
1233 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1234 * not only before forwarding, but after forwarding on all output
1235 * interfaces. It is clear, if mrouter runs a multicasting
1236 * program, it should receive packets not depending to what interface
1237 * program is joined.
1238 * If we will not make it, the program will have to join on all
1239 * interfaces. On the other hand, multihoming host (or router, but
1240 * not mrouter) cannot join to more than one interface - it will
1241 * result in receiving multiple packets.
1243 NF_HOOK(PF_INET
, NF_IP_FORWARD
, skb
, skb
->dev
, dev
,
1244 ipmr_forward_finish
);
1252 static int ipmr_find_vif(struct net_device
*dev
)
1255 for (ct
=maxvif
-1; ct
>=0; ct
--) {
1256 if (vif_table
[ct
].dev
== dev
)
1262 /* "local" means that we should preserve one skb (for local delivery) */
1264 static int ip_mr_forward(struct sk_buff
*skb
, struct mfc_cache
*cache
, int local
)
1269 vif
= cache
->mfc_parent
;
1270 cache
->mfc_un
.res
.pkt
++;
1271 cache
->mfc_un
.res
.bytes
+= skb
->len
;
1274 * Wrong interface: drop packet and (maybe) send PIM assert.
1276 if (vif_table
[vif
].dev
!= skb
->dev
) {
1279 if (((struct rtable
*)skb
->dst
)->fl
.iif
== 0) {
1280 /* It is our own packet, looped back.
1281 Very complicated situation...
1283 The best workaround until routing daemons will be
1284 fixed is not to redistribute packet, if it was
1285 send through wrong interface. It means, that
1286 multicast applications WILL NOT work for
1287 (S,G), which have default multicast route pointing
1288 to wrong oif. In any case, it is not a good
1289 idea to use multicasting applications on router.
1294 cache
->mfc_un
.res
.wrong_if
++;
1295 true_vifi
= ipmr_find_vif(skb
->dev
);
1297 if (true_vifi
>= 0 && mroute_do_assert
&&
1298 /* pimsm uses asserts, when switching from RPT to SPT,
1299 so that we cannot check that packet arrived on an oif.
1300 It is bad, but otherwise we would need to move pretty
1301 large chunk of pimd to kernel. Ough... --ANK
1303 (mroute_do_pim
|| cache
->mfc_un
.res
.ttls
[true_vifi
] < 255) &&
1305 cache
->mfc_un
.res
.last_assert
+ MFC_ASSERT_THRESH
)) {
1306 cache
->mfc_un
.res
.last_assert
= jiffies
;
1307 ipmr_cache_report(skb
, true_vifi
, IGMPMSG_WRONGVIF
);
1312 vif_table
[vif
].pkt_in
++;
1313 vif_table
[vif
].bytes_in
+=skb
->len
;
1318 for (ct
= cache
->mfc_un
.res
.maxvif
-1; ct
>= cache
->mfc_un
.res
.minvif
; ct
--) {
1319 if (ip_hdr(skb
)->ttl
> cache
->mfc_un
.res
.ttls
[ct
]) {
1321 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1323 ipmr_queue_xmit(skb2
, cache
, psend
);
1330 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1332 ipmr_queue_xmit(skb2
, cache
, psend
);
1334 ipmr_queue_xmit(skb
, cache
, psend
);
1347 * Multicast packets for forwarding arrive here
1350 int ip_mr_input(struct sk_buff
*skb
)
1352 struct mfc_cache
*cache
;
1353 int local
= ((struct rtable
*)skb
->dst
)->rt_flags
&RTCF_LOCAL
;
1355 /* Packet is looped back after forward, it should not be
1356 forwarded second time, but still can be delivered locally.
1358 if (IPCB(skb
)->flags
&IPSKB_FORWARDED
)
1362 if (IPCB(skb
)->opt
.router_alert
) {
1363 if (ip_call_ra_chain(skb
))
1365 } else if (ip_hdr(skb
)->protocol
== IPPROTO_IGMP
){
1366 /* IGMPv1 (and broken IGMPv2 implementations sort of
1367 Cisco IOS <= 11.2(8)) do not put router alert
1368 option to IGMP packets destined to routable
1369 groups. It is very bad, because it means
1370 that we can forward NO IGMP messages.
1372 read_lock(&mrt_lock
);
1373 if (mroute_socket
) {
1375 raw_rcv(mroute_socket
, skb
);
1376 read_unlock(&mrt_lock
);
1379 read_unlock(&mrt_lock
);
1383 read_lock(&mrt_lock
);
1384 cache
= ipmr_cache_find(ip_hdr(skb
)->saddr
, ip_hdr(skb
)->daddr
);
1387 * No usable cache entry
1393 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1394 ip_local_deliver(skb
);
1396 read_unlock(&mrt_lock
);
1402 vif
= ipmr_find_vif(skb
->dev
);
1404 int err
= ipmr_cache_unresolved(vif
, skb
);
1405 read_unlock(&mrt_lock
);
1409 read_unlock(&mrt_lock
);
1414 ip_mr_forward(skb
, cache
, local
);
1416 read_unlock(&mrt_lock
);
1419 return ip_local_deliver(skb
);
1425 return ip_local_deliver(skb
);
1430 #ifdef CONFIG_IP_PIMSM_V1
1432 * Handle IGMP messages of PIMv1
1435 int pim_rcv_v1(struct sk_buff
* skb
)
1437 struct igmphdr
*pim
;
1438 struct iphdr
*encap
;
1439 struct net_device
*reg_dev
= NULL
;
1441 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(*encap
)))
1444 pim
= igmp_hdr(skb
);
1446 if (!mroute_do_pim
||
1447 skb
->len
< sizeof(*pim
) + sizeof(*encap
) ||
1448 pim
->group
!= PIM_V1_VERSION
|| pim
->code
!= PIM_V1_REGISTER
)
1451 encap
= (struct iphdr
*)(skb_transport_header(skb
) +
1452 sizeof(struct igmphdr
));
1455 a. packet is really destinted to a multicast group
1456 b. packet is not a NULL-REGISTER
1457 c. packet is not truncated
1459 if (!MULTICAST(encap
->daddr
) ||
1460 encap
->tot_len
== 0 ||
1461 ntohs(encap
->tot_len
) + sizeof(*pim
) > skb
->len
)
1464 read_lock(&mrt_lock
);
1465 if (reg_vif_num
>= 0)
1466 reg_dev
= vif_table
[reg_vif_num
].dev
;
1469 read_unlock(&mrt_lock
);
1471 if (reg_dev
== NULL
)
1474 skb
->mac_header
= skb
->network_header
;
1475 skb_pull(skb
, (u8
*)encap
- skb
->data
);
1476 skb_reset_network_header(skb
);
1478 skb
->protocol
= htons(ETH_P_IP
);
1480 skb
->pkt_type
= PACKET_HOST
;
1481 dst_release(skb
->dst
);
1483 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_bytes
+= skb
->len
;
1484 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_packets
++;
1495 #ifdef CONFIG_IP_PIMSM_V2
1496 static int pim_rcv(struct sk_buff
* skb
)
1498 struct pimreghdr
*pim
;
1499 struct iphdr
*encap
;
1500 struct net_device
*reg_dev
= NULL
;
1502 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(*encap
)))
1505 pim
= (struct pimreghdr
*)skb_transport_header(skb
);
1506 if (pim
->type
!= ((PIM_VERSION
<<4)|(PIM_REGISTER
)) ||
1507 (pim
->flags
&PIM_NULL_REGISTER
) ||
1508 (ip_compute_csum((void *)pim
, sizeof(*pim
)) != 0 &&
1509 csum_fold(skb_checksum(skb
, 0, skb
->len
, 0))))
1512 /* check if the inner packet is destined to mcast group */
1513 encap
= (struct iphdr
*)(skb_transport_header(skb
) +
1514 sizeof(struct pimreghdr
));
1515 if (!MULTICAST(encap
->daddr
) ||
1516 encap
->tot_len
== 0 ||
1517 ntohs(encap
->tot_len
) + sizeof(*pim
) > skb
->len
)
1520 read_lock(&mrt_lock
);
1521 if (reg_vif_num
>= 0)
1522 reg_dev
= vif_table
[reg_vif_num
].dev
;
1525 read_unlock(&mrt_lock
);
1527 if (reg_dev
== NULL
)
1530 skb
->mac_header
= skb
->network_header
;
1531 skb_pull(skb
, (u8
*)encap
- skb
->data
);
1532 skb_reset_network_header(skb
);
1534 skb
->protocol
= htons(ETH_P_IP
);
1536 skb
->pkt_type
= PACKET_HOST
;
1537 dst_release(skb
->dst
);
1538 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_bytes
+= skb
->len
;
1539 ((struct net_device_stats
*)netdev_priv(reg_dev
))->rx_packets
++;
1552 ipmr_fill_mroute(struct sk_buff
*skb
, struct mfc_cache
*c
, struct rtmsg
*rtm
)
1555 struct rtnexthop
*nhp
;
1556 struct net_device
*dev
= vif_table
[c
->mfc_parent
].dev
;
1557 u8
*b
= skb_tail_pointer(skb
);
1558 struct rtattr
*mp_head
;
1561 RTA_PUT(skb
, RTA_IIF
, 4, &dev
->ifindex
);
1563 mp_head
= (struct rtattr
*)skb_put(skb
, RTA_LENGTH(0));
1565 for (ct
= c
->mfc_un
.res
.minvif
; ct
< c
->mfc_un
.res
.maxvif
; ct
++) {
1566 if (c
->mfc_un
.res
.ttls
[ct
] < 255) {
1567 if (skb_tailroom(skb
) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp
)) + 4))
1568 goto rtattr_failure
;
1569 nhp
= (struct rtnexthop
*)skb_put(skb
, RTA_ALIGN(sizeof(*nhp
)));
1570 nhp
->rtnh_flags
= 0;
1571 nhp
->rtnh_hops
= c
->mfc_un
.res
.ttls
[ct
];
1572 nhp
->rtnh_ifindex
= vif_table
[ct
].dev
->ifindex
;
1573 nhp
->rtnh_len
= sizeof(*nhp
);
1576 mp_head
->rta_type
= RTA_MULTIPATH
;
1577 mp_head
->rta_len
= skb_tail_pointer(skb
) - (u8
*)mp_head
;
1578 rtm
->rtm_type
= RTN_MULTICAST
;
1586 int ipmr_get_route(struct sk_buff
*skb
, struct rtmsg
*rtm
, int nowait
)
1589 struct mfc_cache
*cache
;
1590 struct rtable
*rt
= (struct rtable
*)skb
->dst
;
1592 read_lock(&mrt_lock
);
1593 cache
= ipmr_cache_find(rt
->rt_src
, rt
->rt_dst
);
1596 struct sk_buff
*skb2
;
1598 struct net_device
*dev
;
1602 read_unlock(&mrt_lock
);
1607 if (dev
== NULL
|| (vif
= ipmr_find_vif(dev
)) < 0) {
1608 read_unlock(&mrt_lock
);
1611 skb2
= skb_clone(skb
, GFP_ATOMIC
);
1613 read_unlock(&mrt_lock
);
1617 skb_push(skb2
, sizeof(struct iphdr
));
1618 skb_reset_network_header(skb2
);
1620 iph
->ihl
= sizeof(struct iphdr
) >> 2;
1621 iph
->saddr
= rt
->rt_src
;
1622 iph
->daddr
= rt
->rt_dst
;
1624 err
= ipmr_cache_unresolved(vif
, skb2
);
1625 read_unlock(&mrt_lock
);
1629 if (!nowait
&& (rtm
->rtm_flags
&RTM_F_NOTIFY
))
1630 cache
->mfc_flags
|= MFC_NOTIFY
;
1631 err
= ipmr_fill_mroute(skb
, cache
, rtm
);
1632 read_unlock(&mrt_lock
);
1636 #ifdef CONFIG_PROC_FS
1638 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1640 struct ipmr_vif_iter
{
1644 static struct vif_device
*ipmr_vif_seq_idx(struct ipmr_vif_iter
*iter
,
1647 for (iter
->ct
= 0; iter
->ct
< maxvif
; ++iter
->ct
) {
1648 if (!VIF_EXISTS(iter
->ct
))
1651 return &vif_table
[iter
->ct
];
1656 static void *ipmr_vif_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1658 read_lock(&mrt_lock
);
1659 return *pos
? ipmr_vif_seq_idx(seq
->private, *pos
- 1)
1663 static void *ipmr_vif_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1665 struct ipmr_vif_iter
*iter
= seq
->private;
1668 if (v
== SEQ_START_TOKEN
)
1669 return ipmr_vif_seq_idx(iter
, 0);
1671 while (++iter
->ct
< maxvif
) {
1672 if (!VIF_EXISTS(iter
->ct
))
1674 return &vif_table
[iter
->ct
];
1679 static void ipmr_vif_seq_stop(struct seq_file
*seq
, void *v
)
1681 read_unlock(&mrt_lock
);
1684 static int ipmr_vif_seq_show(struct seq_file
*seq
, void *v
)
1686 if (v
== SEQ_START_TOKEN
) {
1688 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1690 const struct vif_device
*vif
= v
;
1691 const char *name
= vif
->dev
? vif
->dev
->name
: "none";
1694 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1696 name
, vif
->bytes_in
, vif
->pkt_in
,
1697 vif
->bytes_out
, vif
->pkt_out
,
1698 vif
->flags
, vif
->local
, vif
->remote
);
1703 static const struct seq_operations ipmr_vif_seq_ops
= {
1704 .start
= ipmr_vif_seq_start
,
1705 .next
= ipmr_vif_seq_next
,
1706 .stop
= ipmr_vif_seq_stop
,
1707 .show
= ipmr_vif_seq_show
,
1710 static int ipmr_vif_open(struct inode
*inode
, struct file
*file
)
1712 struct seq_file
*seq
;
1714 struct ipmr_vif_iter
*s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1719 rc
= seq_open(file
, &ipmr_vif_seq_ops
);
1724 seq
= file
->private_data
;
1734 static const struct file_operations ipmr_vif_fops
= {
1735 .owner
= THIS_MODULE
,
1736 .open
= ipmr_vif_open
,
1738 .llseek
= seq_lseek
,
1739 .release
= seq_release_private
,
1742 struct ipmr_mfc_iter
{
1743 struct mfc_cache
**cache
;
1748 static struct mfc_cache
*ipmr_mfc_seq_idx(struct ipmr_mfc_iter
*it
, loff_t pos
)
1750 struct mfc_cache
*mfc
;
1752 it
->cache
= mfc_cache_array
;
1753 read_lock(&mrt_lock
);
1754 for (it
->ct
= 0; it
->ct
< MFC_LINES
; it
->ct
++)
1755 for (mfc
= mfc_cache_array
[it
->ct
]; mfc
; mfc
= mfc
->next
)
1758 read_unlock(&mrt_lock
);
1760 it
->cache
= &mfc_unres_queue
;
1761 spin_lock_bh(&mfc_unres_lock
);
1762 for (mfc
= mfc_unres_queue
; mfc
; mfc
= mfc
->next
)
1765 spin_unlock_bh(&mfc_unres_lock
);
1772 static void *ipmr_mfc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1774 struct ipmr_mfc_iter
*it
= seq
->private;
1777 return *pos
? ipmr_mfc_seq_idx(seq
->private, *pos
- 1)
1781 static void *ipmr_mfc_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1783 struct mfc_cache
*mfc
= v
;
1784 struct ipmr_mfc_iter
*it
= seq
->private;
1788 if (v
== SEQ_START_TOKEN
)
1789 return ipmr_mfc_seq_idx(seq
->private, 0);
1794 if (it
->cache
== &mfc_unres_queue
)
1797 BUG_ON(it
->cache
!= mfc_cache_array
);
1799 while (++it
->ct
< MFC_LINES
) {
1800 mfc
= mfc_cache_array
[it
->ct
];
1805 /* exhausted cache_array, show unresolved */
1806 read_unlock(&mrt_lock
);
1807 it
->cache
= &mfc_unres_queue
;
1810 spin_lock_bh(&mfc_unres_lock
);
1811 mfc
= mfc_unres_queue
;
1816 spin_unlock_bh(&mfc_unres_lock
);
1822 static void ipmr_mfc_seq_stop(struct seq_file
*seq
, void *v
)
1824 struct ipmr_mfc_iter
*it
= seq
->private;
1826 if (it
->cache
== &mfc_unres_queue
)
1827 spin_unlock_bh(&mfc_unres_lock
);
1828 else if (it
->cache
== mfc_cache_array
)
1829 read_unlock(&mrt_lock
);
1832 static int ipmr_mfc_seq_show(struct seq_file
*seq
, void *v
)
1836 if (v
== SEQ_START_TOKEN
) {
1838 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1840 const struct mfc_cache
*mfc
= v
;
1841 const struct ipmr_mfc_iter
*it
= seq
->private;
1843 seq_printf(seq
, "%08lX %08lX %-3d %8ld %8ld %8ld",
1844 (unsigned long) mfc
->mfc_mcastgrp
,
1845 (unsigned long) mfc
->mfc_origin
,
1847 mfc
->mfc_un
.res
.pkt
,
1848 mfc
->mfc_un
.res
.bytes
,
1849 mfc
->mfc_un
.res
.wrong_if
);
1851 if (it
->cache
!= &mfc_unres_queue
) {
1852 for (n
= mfc
->mfc_un
.res
.minvif
;
1853 n
< mfc
->mfc_un
.res
.maxvif
; n
++ ) {
1855 && mfc
->mfc_un
.res
.ttls
[n
] < 255)
1858 n
, mfc
->mfc_un
.res
.ttls
[n
]);
1861 seq_putc(seq
, '\n');
1866 static const struct seq_operations ipmr_mfc_seq_ops
= {
1867 .start
= ipmr_mfc_seq_start
,
1868 .next
= ipmr_mfc_seq_next
,
1869 .stop
= ipmr_mfc_seq_stop
,
1870 .show
= ipmr_mfc_seq_show
,
1873 static int ipmr_mfc_open(struct inode
*inode
, struct file
*file
)
1875 struct seq_file
*seq
;
1877 struct ipmr_mfc_iter
*s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1882 rc
= seq_open(file
, &ipmr_mfc_seq_ops
);
1886 seq
= file
->private_data
;
1896 static const struct file_operations ipmr_mfc_fops
= {
1897 .owner
= THIS_MODULE
,
1898 .open
= ipmr_mfc_open
,
1900 .llseek
= seq_lseek
,
1901 .release
= seq_release_private
,
1905 #ifdef CONFIG_IP_PIMSM_V2
1906 static struct net_protocol pim_protocol
= {
1913 * Setup for IP multicast routing
1916 void __init
ip_mr_init(void)
1918 mrt_cachep
= kmem_cache_create("ip_mrt_cache",
1919 sizeof(struct mfc_cache
),
1920 0, SLAB_HWCACHE_ALIGN
|SLAB_PANIC
,
1922 init_timer(&ipmr_expire_timer
);
1923 ipmr_expire_timer
.function
=ipmr_expire_process
;
1924 register_netdevice_notifier(&ip_mr_notifier
);
1925 #ifdef CONFIG_PROC_FS
1926 proc_net_fops_create(&init_net
, "ip_mr_vif", 0, &ipmr_vif_fops
);
1927 proc_net_fops_create(&init_net
, "ip_mr_cache", 0, &ipmr_mfc_fops
);