?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
code style scripts/checkpatch.pl (linux-3.9-rc1) formatting
[linux-2.6.34.14-moxart.git] / net / ipv4 / ipmr.c
blobec19a890c9a0eb02ba9deec1b099422690e621c0
1 /*
2 * IP multicast routing support for mrouted 3.6/3.8
3 *
4 * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
5 * Linux Consultancy and Custom Driver Development
6 *
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.
11 *
12 * Fixes:
13 * Michael Chastain : Incorrect size of copying.
14 * Alan Cox : Added the cache manager code
15 * Alan Cox : Fixed the clone/copy bug and device race.
16 * Mike McLagan : Routing by source
17 * Malcolm Beattie : Buffer handling fixes.
18 * Alexey Kuznetsov : Double buffer free and other fixes.
19 * SVR Anand : Fixed several multicast bugs and problems.
20 * Alexey Kuznetsov : Status, optimisations and more.
21 * Brad Parker : Better behaviour on mrouted upcall
22 * overflow.
23 * Carlos Picoto : PIMv1 Support
24 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
25 * Relax this requrement to work with older peers.
26 *
27 */
28
29 #include <asm/system.h>
30 #include <asm/uaccess.h>
31 #include <linux/types.h>
32 #include <linux/capability.h>
33 #include <linux/errno.h>
34 #include <linux/timer.h>
35 #include <linux/mm.h>
36 #include <linux/kernel.h>
37 #include <linux/fcntl.h>
38 #include <linux/stat.h>
39 #include <linux/socket.h>
40 #include <linux/in.h>
41 #include <linux/inet.h>
42 #include <linux/netdevice.h>
43 #include <linux/inetdevice.h>
44 #include <linux/igmp.h>
45 #include <linux/proc_fs.h>
46 #include <linux/seq_file.h>
47 #include <linux/mroute.h>
48 #include <linux/init.h>
49 #include <linux/if_ether.h>
50 #include <linux/slab.h>
51 #include <net/net_namespace.h>
52 #include <net/ip.h>
53 #include <net/protocol.h>
54 #include <linux/skbuff.h>
55 #include <net/route.h>
56 #include <net/sock.h>
57 #include <net/icmp.h>
58 #include <net/udp.h>
59 #include <net/raw.h>
60 #include <linux/notifier.h>
61 #include <linux/if_arp.h>
62 #include <linux/netfilter_ipv4.h>
63 #include <net/ipip.h>
64 #include <net/checksum.h>
65 #include <net/netlink.h>
66
67 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
68 #define CONFIG_IP_PIMSM 1
69 #endif
70
71 /* Big lock, protecting vif table, mrt cache and mroute socket state.
72 Note that the changes are semaphored via rtnl_lock.
73 */
74
75 static DEFINE_RWLOCK(mrt_lock);
76
77 /*
78 * Multicast router control variables
79 */
80
81 #define VIF_EXISTS(_net, _idx) ((_net)->ipv4.vif_table[_idx].dev != NULL)
82
83 static struct mfc_cache *mfc_unres_queue; /* Queue of unresolved entries */
84
85 /* Special spinlock for queue of unresolved entries */
86 static DEFINE_SPINLOCK(mfc_unres_lock);
87
88 /* We return to original Alan's scheme. Hash table of resolved
89 entries is changed only in process context and protected
90 with weak lock mrt_lock. Queue of unresolved entries is protected
91 with strong spinlock mfc_unres_lock.
92
93 In this case data path is free of exclusive locks at all.
94 */
95
96 static struct kmem_cache *mrt_cachep __read_mostly;
97
98 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local);
99 static int ipmr_cache_report(struct net *net,
100 struct sk_buff *pkt, vifi_t vifi, int assert);
101 static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm);
102
103 static struct timer_list ipmr_expire_timer;
104
105 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
106
107 static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
108 {
109 struct net *net = dev_net(dev);
110
111 dev_close(dev);
112
113 dev = __dev_get_by_name(net, "tunl0");
114 if (dev) {
115 const struct net_device_ops *ops = dev->netdev_ops;
116 struct ifreq ifr;
117 struct ip_tunnel_parm p;
118
119 memset(&p, 0, sizeof(p));
120 p.iph.daddr = v->vifc_rmt_addr.s_addr;
121 p.iph.saddr = v->vifc_lcl_addr.s_addr;
122 p.iph.version = 4;
123 p.iph.ihl = 5;
124 p.iph.protocol = IPPROTO_IPIP;
125 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
126 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
127
128 if (ops->ndo_do_ioctl) {
129 mm_segment_t oldfs = get_fs();
130
131 set_fs(KERNEL_DS);
132 ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
133 set_fs(oldfs);
134 }
135 }
136 }
137
138 static
139 struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
140 {
141 struct net_device *dev;
142
143 dev = __dev_get_by_name(net, "tunl0");
144
145 if (dev) {
146 const struct net_device_ops *ops = dev->netdev_ops;
147 int err;
148 struct ifreq ifr;
149 struct ip_tunnel_parm p;
150 struct in_device *in_dev;
151
152 memset(&p, 0, sizeof(p));
153 p.iph.daddr = v->vifc_rmt_addr.s_addr;
154 p.iph.saddr = v->vifc_lcl_addr.s_addr;
155 p.iph.version = 4;
156 p.iph.ihl = 5;
157 p.iph.protocol = IPPROTO_IPIP;
158 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
159 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
160
161 if (ops->ndo_do_ioctl) {
162 mm_segment_t oldfs = get_fs();
163
164 set_fs(KERNEL_DS);
165 err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
166 set_fs(oldfs);
167 } else
168 err = -EOPNOTSUPP;
169
170 dev = NULL;
171
172 if (err == 0 &&
173 (dev = __dev_get_by_name(net, p.name)) != NULL) {
174 dev->flags |= IFF_MULTICAST;
175
176 in_dev = __in_dev_get_rtnl(dev);
177 if (in_dev == NULL)
178 goto failure;
179
180 ipv4_devconf_setall(in_dev);
181 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
182
183 if (dev_open(dev))
184 goto failure;
185 dev_hold(dev);
186 }
187 }
188 return dev;
189
190 failure:
191 /* allow the register to be completed before unregistering. */
192 rtnl_unlock();
193 rtnl_lock();
194
195 unregister_netdevice(dev);
196 return NULL;
197 }
198
199 #ifdef CONFIG_IP_PIMSM
200
201 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
202 {
203 struct net *net = dev_net(dev);
204
205 read_lock(&mrt_lock);
206 dev->stats.tx_bytes += skb->len;
207 dev->stats.tx_packets++;
208 ipmr_cache_report(net, skb, net->ipv4.mroute_reg_vif_num,
209 IGMPMSG_WHOLEPKT);
210 read_unlock(&mrt_lock);
211 kfree_skb(skb);
212 return NETDEV_TX_OK;
213 }
214
215 static const struct net_device_ops reg_vif_netdev_ops = {
216 .ndo_start_xmit = reg_vif_xmit,
217 };
218
219 static void reg_vif_setup(struct net_device *dev)
220 {
221 dev->type = ARPHRD_PIMREG;
222 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
223 dev->flags = IFF_NOARP;
224 dev->netdev_ops = &reg_vif_netdev_ops,
225 dev->destructor = free_netdev;
226 dev->features |= NETIF_F_NETNS_LOCAL;
227 }
228
229 static struct net_device *ipmr_reg_vif(struct net *net)
230 {
231 struct net_device *dev;
232 struct in_device *in_dev;
233
234 dev = alloc_netdev(0, "pimreg", reg_vif_setup);
235
236 if (dev == NULL)
237 return NULL;
238
239 dev_net_set(dev, net);
240
241 if (register_netdevice(dev)) {
242 free_netdev(dev);
243 return NULL;
244 }
245 dev->iflink = 0;
246
247 rcu_read_lock();
248 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
249 rcu_read_unlock();
250 goto failure;
251 }
252
253 ipv4_devconf_setall(in_dev);
254 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
255 rcu_read_unlock();
256
257 if (dev_open(dev))
258 goto failure;
259
260 dev_hold(dev);
261
262 return dev;
263
264 failure:
265 /* allow the register to be completed before unregistering. */
266 rtnl_unlock();
267 rtnl_lock();
268
269 unregister_netdevice(dev);
270 return NULL;
271 }
272 #endif
273
274 /*
275 * Delete a VIF entry
276 * @notify: Set to 1, if the caller is a notifier_call
277 */
278
279 static int vif_delete(struct net *net, int vifi, int notify,
280 struct list_head *head)
281 {
282 struct vif_device *v;
283 struct net_device *dev;
284 struct in_device *in_dev;
285
286 if (vifi < 0 || vifi >= net->ipv4.maxvif)
287 return -EADDRNOTAVAIL;
288
289 v = &net->ipv4.vif_table[vifi];
290
291 write_lock_bh(&mrt_lock);
292 dev = v->dev;
293 v->dev = NULL;
294
295 if (!dev) {
296 write_unlock_bh(&mrt_lock);
297 return -EADDRNOTAVAIL;
298 }
299
300 #ifdef CONFIG_IP_PIMSM
301 if (vifi == net->ipv4.mroute_reg_vif_num)
302 net->ipv4.mroute_reg_vif_num = -1;
303 #endif
304
305 if (vifi+1 == net->ipv4.maxvif) {
306 int tmp;
307 for (tmp=vifi-1; tmp>=0; tmp--) {
308 if (VIF_EXISTS(net, tmp))
309 break;
310 }
311 net->ipv4.maxvif = tmp+1;
312 }
313
314 write_unlock_bh(&mrt_lock);
315
316 dev_set_allmulti(dev, -1);
317
318 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
319 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
320 ip_rt_multicast_event(in_dev);
321 }
322
323 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER) && !notify)
324 unregister_netdevice_queue(dev, head);
325
326 dev_put(dev);
327 return 0;
328 }
329
330 static inline void ipmr_cache_free(struct mfc_cache *c)
331 {
332 release_net(mfc_net(c));
333 kmem_cache_free(mrt_cachep, c);
334 }
335
336 /* Destroy an unresolved cache entry, killing queued skbs
337 and reporting error to netlink readers.
338 */
339
340 static void ipmr_destroy_unres(struct mfc_cache *c)
341 {
342 struct sk_buff *skb;
343 struct nlmsgerr *e;
344 struct net *net = mfc_net(c);
345
346 atomic_dec(&net->ipv4.cache_resolve_queue_len);
347
348 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
349 if (ip_hdr(skb)->version == 0) {
350 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
351 nlh->nlmsg_type = NLMSG_ERROR;
352 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
353 skb_trim(skb, nlh->nlmsg_len);
354 e = NLMSG_DATA(nlh);
355 e->error = -ETIMEDOUT;
356 memset(&e->msg, 0, sizeof(e->msg));
357
358 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
359 } else
360 kfree_skb(skb);
361 }
362
363 ipmr_cache_free(c);
364 }
365
366
367 /* Single timer process for all the unresolved queue. */
368
369 static void ipmr_expire_process(unsigned long dummy)
370 {
371 unsigned long now;
372 unsigned long expires;
373 struct mfc_cache *c, **cp;
374
375 if (!spin_trylock(&mfc_unres_lock)) {
376 mod_timer(&ipmr_expire_timer, jiffies+HZ/10);
377 return;
378 }
379
380 if (mfc_unres_queue == NULL)
381 goto out;
382
383 now = jiffies;
384 expires = 10*HZ;
385 cp = &mfc_unres_queue;
386
387 while ((c=*cp) != NULL) {
388 if (time_after(c->mfc_un.unres.expires, now)) {
389 unsigned long interval = c->mfc_un.unres.expires - now;
390 if (interval < expires)
391 expires = interval;
392 cp = &c->next;
393 continue;
394 }
395
396 *cp = c->next;
397
398 ipmr_destroy_unres(c);
399 }
400
401 if (mfc_unres_queue != NULL)
402 mod_timer(&ipmr_expire_timer, jiffies + expires);
403
404 out:
405 spin_unlock(&mfc_unres_lock);
406 }
407
408 /* Fill oifs list. It is called under write locked mrt_lock. */
409
410 static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
411 {
412 int vifi;
413 struct net *net = mfc_net(cache);
414
415 cache->mfc_un.res.minvif = MAXVIFS;
416 cache->mfc_un.res.maxvif = 0;
417 memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
418
419 for (vifi = 0; vifi < net->ipv4.maxvif; vifi++) {
420 if (VIF_EXISTS(net, vifi) &&
421 ttls[vifi] && ttls[vifi] < 255) {
422 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
423 if (cache->mfc_un.res.minvif > vifi)
424 cache->mfc_un.res.minvif = vifi;
425 if (cache->mfc_un.res.maxvif <= vifi)
426 cache->mfc_un.res.maxvif = vifi + 1;
427 }
428 }
429 }
430
431 static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
432 {
433 int vifi = vifc->vifc_vifi;
434 struct vif_device *v = &net->ipv4.vif_table[vifi];
435 struct net_device *dev;
436 struct in_device *in_dev;
437 int err;
438
439 /* Is vif busy ? */
440 if (VIF_EXISTS(net, vifi))
441 return -EADDRINUSE;
442
443 switch (vifc->vifc_flags) {
444 #ifdef CONFIG_IP_PIMSM
445 case VIFF_REGISTER:
446 /*
447 * Special Purpose VIF in PIM
448 * All the packets will be sent to the daemon
449 */
450 if (net->ipv4.mroute_reg_vif_num >= 0)
451 return -EADDRINUSE;
452 dev = ipmr_reg_vif(net);
453 if (!dev)
454 return -ENOBUFS;
455 err = dev_set_allmulti(dev, 1);
456 if (err) {
457 unregister_netdevice(dev);
458 dev_put(dev);
459 return err;
460 }
461 break;
462 #endif
463 case VIFF_TUNNEL:
464 dev = ipmr_new_tunnel(net, vifc);
465 if (!dev)
466 return -ENOBUFS;
467 err = dev_set_allmulti(dev, 1);
468 if (err) {
469 ipmr_del_tunnel(dev, vifc);
470 dev_put(dev);
471 return err;
472 }
473 break;
474
475 case VIFF_USE_IFINDEX:
476 case 0:
477 if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
478 dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
479 if (dev && dev->ip_ptr == NULL) {
480 dev_put(dev);
481 return -EADDRNOTAVAIL;
482 }
483 } else
484 dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
485
486 if (!dev)
487 return -EADDRNOTAVAIL;
488 err = dev_set_allmulti(dev, 1);
489 if (err) {
490 dev_put(dev);
491 return err;
492 }
493 break;
494 default:
495 return -EINVAL;
496 }
497
498 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) {
499 dev_put(dev);
500 return -EADDRNOTAVAIL;
501 }
502 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
503 ip_rt_multicast_event(in_dev);
504
505 /*
506 * Fill in the VIF structures
507 */
508 v->rate_limit = vifc->vifc_rate_limit;
509 v->local = vifc->vifc_lcl_addr.s_addr;
510 v->remote = vifc->vifc_rmt_addr.s_addr;
511 v->flags = vifc->vifc_flags;
512 if (!mrtsock)
513 v->flags |= VIFF_STATIC;
514 v->threshold = vifc->vifc_threshold;
515 v->bytes_in = 0;
516 v->bytes_out = 0;
517 v->pkt_in = 0;
518 v->pkt_out = 0;
519 v->link = dev->ifindex;
520 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
521 v->link = dev->iflink;
522
523 /* And finish update writing critical data */
524 write_lock_bh(&mrt_lock);
525 v->dev = dev;
526 #ifdef CONFIG_IP_PIMSM
527 if (v->flags&VIFF_REGISTER)
528 net->ipv4.mroute_reg_vif_num = vifi;
529 #endif
530 if (vifi+1 > net->ipv4.maxvif)
531 net->ipv4.maxvif = vifi+1;
532 write_unlock_bh(&mrt_lock);
533 return 0;
534 }
535
536 static struct mfc_cache *ipmr_cache_find(struct net *net,
537 __be32 origin,
538 __be32 mcastgrp)
539 {
540 int line = MFC_HASH(mcastgrp, origin);
541 struct mfc_cache *c;
542
543 for (c = net->ipv4.mfc_cache_array[line]; c; c = c->next) {
544 if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp)
545 break;
546 }
547 return c;
548 }
549
550 /*
551 * Allocate a multicast cache entry
552 */
553 static struct mfc_cache *ipmr_cache_alloc(struct net *net)
554 {
555 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
556 if (c == NULL)
557 return NULL;
558 c->mfc_un.res.minvif = MAXVIFS;
559 mfc_net_set(c, net);
560 return c;
561 }
562
563 static struct mfc_cache *ipmr_cache_alloc_unres(struct net *net)
564 {
565 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
566 if (c == NULL)
567 return NULL;
568 skb_queue_head_init(&c->mfc_un.unres.unresolved);
569 c->mfc_un.unres.expires = jiffies + 10*HZ;
570 mfc_net_set(c, net);
571 return c;
572 }
573
574 /*
575 * A cache entry has gone into a resolved state from queued
576 */
577
578 static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
579 {
580 struct sk_buff *skb;
581 struct nlmsgerr *e;
582
583 /*
584 * Play the pending entries through our router
585 */
586
587 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
588 if (ip_hdr(skb)->version == 0) {
589 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
590
591 if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
592 nlh->nlmsg_len = (skb_tail_pointer(skb) -
593 (u8 *)nlh);
594 } else {
595 nlh->nlmsg_type = NLMSG_ERROR;
596 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
597 skb_trim(skb, nlh->nlmsg_len);
598 e = NLMSG_DATA(nlh);
599 e->error = -EMSGSIZE;
600 memset(&e->msg, 0, sizeof(e->msg));
601 }
602
603 rtnl_unicast(skb, mfc_net(c), NETLINK_CB(skb).pid);
604 } else
605 ip_mr_forward(skb, c, 0);
606 }
607 }
608
609 /*
610 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
611 * expects the following bizarre scheme.
612 *
613 * Called under mrt_lock.
614 */
615
616 static int ipmr_cache_report(struct net *net,
617 struct sk_buff *pkt, vifi_t vifi, int assert)
618 {
619 struct sk_buff *skb;
620 const int ihl = ip_hdrlen(pkt);
621 struct igmphdr *igmp;
622 struct igmpmsg *msg;
623 int ret;
624
625 #ifdef CONFIG_IP_PIMSM
626 if (assert == IGMPMSG_WHOLEPKT)
627 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
628 else
629 #endif
630 skb = alloc_skb(128, GFP_ATOMIC);
631
632 if (!skb)
633 return -ENOBUFS;
634
635 #ifdef CONFIG_IP_PIMSM
636 if (assert == IGMPMSG_WHOLEPKT) {
637 /* Ugly, but we have no choice with this interface.
638 Duplicate old header, fix ihl, length etc.
639 And all this only to mangle msg->im_msgtype and
640 to set msg->im_mbz to "mbz" :-)
641 */
642 skb_push(skb, sizeof(struct iphdr));
643 skb_reset_network_header(skb);
644 skb_reset_transport_header(skb);
645 msg = (struct igmpmsg *)skb_network_header(skb);
646 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
647 msg->im_msgtype = IGMPMSG_WHOLEPKT;
648 msg->im_mbz = 0;
649 msg->im_vif = net->ipv4.mroute_reg_vif_num;
650 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
651 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
652 sizeof(struct iphdr));
653 } else
654 #endif
655 {
656
657 /*
658 * Copy the IP header
659 */
660
661 skb->network_header = skb->tail;
662 skb_put(skb, ihl);
663 skb_copy_to_linear_data(skb, pkt->data, ihl);
664 ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */
665 msg = (struct igmpmsg *)skb_network_header(skb);
666 msg->im_vif = vifi;
667 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
668
669 /*
670 * Add our header
671 */
672
673 igmp=(struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
674 igmp->type =
675 msg->im_msgtype = assert;
676 igmp->code = 0;
677 ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
678 skb->transport_header = skb->network_header;
679 }
680
681 if (net->ipv4.mroute_sk == NULL) {
682 kfree_skb(skb);
683 return -EINVAL;
684 }
685
686 /*
687 * Deliver to mrouted
688 */
689 ret = sock_queue_rcv_skb(net->ipv4.mroute_sk, skb);
690 if (ret < 0) {
691 if (net_ratelimit())
692 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
693 kfree_skb(skb);
694 }
695
696 return ret;
697 }
698
699 /*
700 * Queue a packet for resolution. It gets locked cache entry!
701 */
702
703 static int
704 ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
705 {
706 int err;
707 struct mfc_cache *c;
708 const struct iphdr *iph = ip_hdr(skb);
709
710 spin_lock_bh(&mfc_unres_lock);
711 for (c=mfc_unres_queue; c; c=c->next) {
712 if (net_eq(mfc_net(c), net) &&
713 c->mfc_mcastgrp == iph->daddr &&
714 c->mfc_origin == iph->saddr)
715 break;
716 }
717
718 if (c == NULL) {
719 /*
720 * Create a new entry if allowable
721 */
722
723 if (atomic_read(&net->ipv4.cache_resolve_queue_len) >= 10 ||
724 (c = ipmr_cache_alloc_unres(net)) == NULL) {
725 spin_unlock_bh(&mfc_unres_lock);
726
727 kfree_skb(skb);
728 return -ENOBUFS;
729 }
730
731 /*
732 * Fill in the new cache entry
733 */
734 c->mfc_parent = -1;
735 c->mfc_origin = iph->saddr;
736 c->mfc_mcastgrp = iph->daddr;
737
738 /*
739 * Reflect first query at mrouted.
740 */
741 err = ipmr_cache_report(net, skb, vifi, IGMPMSG_NOCACHE);
742 if (err < 0) {
743 /* If the report failed throw the cache entry
744 out - Brad Parker
745 */
746 spin_unlock_bh(&mfc_unres_lock);
747
748 ipmr_cache_free(c);
749 kfree_skb(skb);
750 return err;
751 }
752
753 atomic_inc(&net->ipv4.cache_resolve_queue_len);
754 c->next = mfc_unres_queue;
755 mfc_unres_queue = c;
756
757 if (atomic_read(&net->ipv4.cache_resolve_queue_len) == 1)
758 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
759 }
760
761 /*
762 * See if we can append the packet
763 */
764 if (c->mfc_un.unres.unresolved.qlen>3) {
765 kfree_skb(skb);
766 err = -ENOBUFS;
767 } else {
768 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
769 err = 0;
770 }
771
772 spin_unlock_bh(&mfc_unres_lock);
773 return err;
774 }
775
776 /*
777 * MFC cache manipulation by user space mroute daemon
778 */
779
780 static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc)
781 {
782 int line;
783 struct mfc_cache *c, **cp;
784
785 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
786
787 for (cp = &net->ipv4.mfc_cache_array[line];
788 (c = *cp) != NULL; cp = &c->next) {
789 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
790 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
791 write_lock_bh(&mrt_lock);
792 *cp = c->next;
793 write_unlock_bh(&mrt_lock);
794
795 ipmr_cache_free(c);
796 return 0;
797 }
798 }
799 return -ENOENT;
800 }
801
802 static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
803 {
804 int line;
805 struct mfc_cache *uc, *c, **cp;
806
807 if (mfc->mfcc_parent >= MAXVIFS)
808 return -ENFILE;
809
810 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
811
812 for (cp = &net->ipv4.mfc_cache_array[line];
813 (c = *cp) != NULL; cp = &c->next) {
814 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
815 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
816 break;
817 }
818
819 if (c != NULL) {
820 write_lock_bh(&mrt_lock);
821 c->mfc_parent = mfc->mfcc_parent;
822 ipmr_update_thresholds(c, mfc->mfcc_ttls);
823 if (!mrtsock)
824 c->mfc_flags |= MFC_STATIC;
825 write_unlock_bh(&mrt_lock);
826 return 0;
827 }
828
829 if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
830 return -EINVAL;
831
832 c = ipmr_cache_alloc(net);
833 if (c == NULL)
834 return -ENOMEM;
835
836 c->mfc_origin = mfc->mfcc_origin.s_addr;
837 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
838 c->mfc_parent = mfc->mfcc_parent;
839 ipmr_update_thresholds(c, mfc->mfcc_ttls);
840 if (!mrtsock)
841 c->mfc_flags |= MFC_STATIC;
842
843 write_lock_bh(&mrt_lock);
844 c->next = net->ipv4.mfc_cache_array[line];
845 net->ipv4.mfc_cache_array[line] = c;
846 write_unlock_bh(&mrt_lock);
847
848 /*
849 * Check to see if we resolved a queued list. If so we
850 * need to send on the frames and tidy up.
851 */
852 spin_lock_bh(&mfc_unres_lock);
853 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
854 cp = &uc->next) {
855 if (net_eq(mfc_net(uc), net) &&
856 uc->mfc_origin == c->mfc_origin &&
857 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
858 *cp = uc->next;
859 atomic_dec(&net->ipv4.cache_resolve_queue_len);
860 break;
861 }
862 }
863 if (mfc_unres_queue == NULL)
864 del_timer(&ipmr_expire_timer);
865 spin_unlock_bh(&mfc_unres_lock);
866
867 if (uc) {
868 ipmr_cache_resolve(uc, c);
869 ipmr_cache_free(uc);
870 }
871 return 0;
872 }
873
874 /*
875 * Close the multicast socket, and clear the vif tables etc
876 */
877
878 static void mroute_clean_tables(struct net *net)
879 {
880 int i;
881 LIST_HEAD(list);
882
883 /*
884 * Shut down all active vif entries
885 */
886 for (i = 0; i < net->ipv4.maxvif; i++) {
887 if (!(net->ipv4.vif_table[i].flags&VIFF_STATIC))
888 vif_delete(net, i, 0, &list);
889 }
890 unregister_netdevice_many(&list);
891
892 /*
893 * Wipe the cache
894 */
895 for (i=0; i<MFC_LINES; i++) {
896 struct mfc_cache *c, **cp;
897
898 cp = &net->ipv4.mfc_cache_array[i];
899 while ((c = *cp) != NULL) {
900 if (c->mfc_flags&MFC_STATIC) {
901 cp = &c->next;
902 continue;
903 }
904 write_lock_bh(&mrt_lock);
905 *cp = c->next;
906 write_unlock_bh(&mrt_lock);
907
908 ipmr_cache_free(c);
909 }
910 }
911
912 if (atomic_read(&net->ipv4.cache_resolve_queue_len) != 0) {
913 struct mfc_cache *c, **cp;
914
915 spin_lock_bh(&mfc_unres_lock);
916 cp = &mfc_unres_queue;
917 while ((c = *cp) != NULL) {
918 if (!net_eq(mfc_net(c), net)) {
919 cp = &c->next;
920 continue;
921 }
922 *cp = c->next;
923
924 ipmr_destroy_unres(c);
925 }
926 spin_unlock_bh(&mfc_unres_lock);
927 }
928 }
929
930 static void mrtsock_destruct(struct sock *sk)
931 {
932 struct net *net = sock_net(sk);
933
934 rtnl_lock();
935 if (sk == net->ipv4.mroute_sk) {
936 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
937
938 write_lock_bh(&mrt_lock);
939 net->ipv4.mroute_sk = NULL;
940 write_unlock_bh(&mrt_lock);
941
942 mroute_clean_tables(net);
943 }
944 rtnl_unlock();
945 }
946
947 /*
948 * Socket options and virtual interface manipulation. The whole
949 * virtual interface system is a complete heap, but unfortunately
950 * that's how BSD mrouted happens to think. Maybe one day with a proper
951 * MOSPF/PIM router set up we can clean this up.
952 */
953
954 int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
955 {
956 int ret;
957 struct vifctl vif;
958 struct mfcctl mfc;
959 struct net *net = sock_net(sk);
960
961 if (optname != MRT_INIT) {
962 if (sk != net->ipv4.mroute_sk && !capable(CAP_NET_ADMIN))
963 return -EACCES;
964 }
965
966 switch (optname) {
967 case MRT_INIT:
968 if (sk->sk_type != SOCK_RAW ||
969 inet_sk(sk)->inet_num != IPPROTO_IGMP)
970 return -EOPNOTSUPP;
971 if (optlen != sizeof(int))
972 return -ENOPROTOOPT;
973
974 rtnl_lock();
975 if (net->ipv4.mroute_sk) {
976 rtnl_unlock();
977 return -EADDRINUSE;
978 }
979
980 ret = ip_ra_control(sk, 1, mrtsock_destruct);
981 if (ret == 0) {
982 write_lock_bh(&mrt_lock);
983 net->ipv4.mroute_sk = sk;
984 write_unlock_bh(&mrt_lock);
985
986 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
987 }
988 rtnl_unlock();
989 return ret;
990 case MRT_DONE:
991 if (sk != net->ipv4.mroute_sk)
992 return -EACCES;
993 return ip_ra_control(sk, 0, NULL);
994 case MRT_ADD_VIF:
995 case MRT_DEL_VIF:
996 if (optlen != sizeof(vif))
997 return -EINVAL;
998 if (copy_from_user(&vif, optval, sizeof(vif)))
999 return -EFAULT;
1000 if (vif.vifc_vifi >= MAXVIFS)
1001 return -ENFILE;
1002 rtnl_lock();
1003 if (optname == MRT_ADD_VIF) {
1004 ret = vif_add(net, &vif, sk == net->ipv4.mroute_sk);
1005 } else {
1006 ret = vif_delete(net, vif.vifc_vifi, 0, NULL);
1007 }
1008 rtnl_unlock();
1009 return ret;
1010
1011 /*
1012 * Manipulate the forwarding caches. These live
1013 * in a sort of kernel/user symbiosis.
1014 */
1015 case MRT_ADD_MFC:
1016 case MRT_DEL_MFC:
1017 if (optlen != sizeof(mfc))
1018 return -EINVAL;
1019 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1020 return -EFAULT;
1021 rtnl_lock();
1022 if (optname == MRT_DEL_MFC)
1023 ret = ipmr_mfc_delete(net, &mfc);
1024 else
1025 ret = ipmr_mfc_add(net, &mfc, sk == net->ipv4.mroute_sk);
1026 rtnl_unlock();
1027 return ret;
1028 /*
1029 * Control PIM assert.
1030 */
1031 case MRT_ASSERT:
1032 {
1033 int v;
1034 if (get_user(v,(int __user *)optval))
1035 return -EFAULT;
1036 net->ipv4.mroute_do_assert = (v) ? 1 : 0;
1037 return 0;
1038 }
1039 #ifdef CONFIG_IP_PIMSM
1040 case MRT_PIM:
1041 {
1042 int v;
1043
1044 if (get_user(v,(int __user *)optval))
1045 return -EFAULT;
1046 v = (v) ? 1 : 0;
1047
1048 rtnl_lock();
1049 ret = 0;
1050 if (v != net->ipv4.mroute_do_pim) {
1051 net->ipv4.mroute_do_pim = v;
1052 net->ipv4.mroute_do_assert = v;
1053 }
1054 rtnl_unlock();
1055 return ret;
1056 }
1057 #endif
1058 /*
1059 * Spurious command, or MRT_VERSION which you cannot
1060 * set.
1061 */
1062 default:
1063 return -ENOPROTOOPT;
1064 }
1065 }
1066
1067 /*
1068 * Getsock opt support for the multicast routing system.
1069 */
1070
1071 int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
1072 {
1073 int olr;
1074 int val;
1075 struct net *net = sock_net(sk);
1076
1077 if (optname != MRT_VERSION &&
1078 #ifdef CONFIG_IP_PIMSM
1079 optname!=MRT_PIM &&
1080 #endif
1081 optname!=MRT_ASSERT)
1082 return -ENOPROTOOPT;
1083
1084 if (get_user(olr, optlen))
1085 return -EFAULT;
1086
1087 olr = min_t(unsigned int, olr, sizeof(int));
1088 if (olr < 0)
1089 return -EINVAL;
1090
1091 if (put_user(olr, optlen))
1092 return -EFAULT;
1093 if (optname == MRT_VERSION)
1094 val = 0x0305;
1095 #ifdef CONFIG_IP_PIMSM
1096 else if (optname == MRT_PIM)
1097 val = net->ipv4.mroute_do_pim;
1098 #endif
1099 else
1100 val = net->ipv4.mroute_do_assert;
1101 if (copy_to_user(optval, &val, olr))
1102 return -EFAULT;
1103 return 0;
1104 }
1105
1106 /*
1107 * The IP multicast ioctl support routines.
1108 */
1109
1110 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1111 {
1112 struct sioc_sg_req sr;
1113 struct sioc_vif_req vr;
1114 struct vif_device *vif;
1115 struct mfc_cache *c;
1116 struct net *net = sock_net(sk);
1117
1118 switch (cmd) {
1119 case SIOCGETVIFCNT:
1120 if (copy_from_user(&vr, arg, sizeof(vr)))
1121 return -EFAULT;
1122 if (vr.vifi >= net->ipv4.maxvif)
1123 return -EINVAL;
1124 read_lock(&mrt_lock);
1125 vif = &net->ipv4.vif_table[vr.vifi];
1126 if (VIF_EXISTS(net, vr.vifi)) {
1127 vr.icount = vif->pkt_in;
1128 vr.ocount = vif->pkt_out;
1129 vr.ibytes = vif->bytes_in;
1130 vr.obytes = vif->bytes_out;
1131 read_unlock(&mrt_lock);
1132
1133 if (copy_to_user(arg, &vr, sizeof(vr)))
1134 return -EFAULT;
1135 return 0;
1136 }
1137 read_unlock(&mrt_lock);
1138 return -EADDRNOTAVAIL;
1139 case SIOCGETSGCNT:
1140 if (copy_from_user(&sr, arg, sizeof(sr)))
1141 return -EFAULT;
1142
1143 read_lock(&mrt_lock);
1144 c = ipmr_cache_find(net, sr.src.s_addr, sr.grp.s_addr);
1145 if (c) {
1146 sr.pktcnt = c->mfc_un.res.pkt;
1147 sr.bytecnt = c->mfc_un.res.bytes;
1148 sr.wrong_if = c->mfc_un.res.wrong_if;
1149 read_unlock(&mrt_lock);
1150
1151 if (copy_to_user(arg, &sr, sizeof(sr)))
1152 return -EFAULT;
1153 return 0;
1154 }
1155 read_unlock(&mrt_lock);
1156 return -EADDRNOTAVAIL;
1157 default:
1158 return -ENOIOCTLCMD;
1159 }
1160 }
1161
1162
1163 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1164 {
1165 struct net_device *dev = ptr;
1166 struct net *net = dev_net(dev);
1167 struct vif_device *v;
1168 int ct;
1169 LIST_HEAD(list);
1170
1171 if (event != NETDEV_UNREGISTER)
1172 return NOTIFY_DONE;
1173 v = &net->ipv4.vif_table[0];
1174 for (ct = 0; ct < net->ipv4.maxvif; ct++, v++) {
1175 if (v->dev == dev)
1176 vif_delete(net, ct, 1, &list);
1177 }
1178 unregister_netdevice_many(&list);
1179 return NOTIFY_DONE;
1180 }
1181
1182
1183 static struct notifier_block ip_mr_notifier = {
1184 .notifier_call = ipmr_device_event,
1185 };
1186
1187 /*
1188 * Encapsulate a packet by attaching a valid IPIP header to it.
1189 * This avoids tunnel drivers and other mess and gives us the speed so
1190 * important for multicast video.
1191 */
1192
1193 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1194 {
1195 struct iphdr *iph;
1196 struct iphdr *old_iph = ip_hdr(skb);
1197
1198 skb_push(skb, sizeof(struct iphdr));
1199 skb->transport_header = skb->network_header;
1200 skb_reset_network_header(skb);
1201 iph = ip_hdr(skb);
1202
1203 iph->version = 4;
1204 iph->tos = old_iph->tos;
1205 iph->ttl = old_iph->ttl;
1206 iph->frag_off = 0;
1207 iph->daddr = daddr;
1208 iph->saddr = saddr;
1209 iph->protocol = IPPROTO_IPIP;
1210 iph->ihl = 5;
1211 iph->tot_len = htons(skb->len);
1212 ip_select_ident(iph, skb_dst(skb), NULL);
1213 ip_send_check(iph);
1214
1215 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1216 nf_reset(skb);
1217 }
1218
1219 static inline int ipmr_forward_finish(struct sk_buff *skb)
1220 {
1221 struct ip_options * opt = &(IPCB(skb)->opt);
1222
1223 IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
1224
1225 if (unlikely(opt->optlen))
1226 ip_forward_options(skb);
1227
1228 return dst_output(skb);
1229 }
1230
1231 /*
1232 * Processing handlers for ipmr_forward
1233 */
1234
1235 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1236 {
1237 struct net *net = mfc_net(c);
1238 const struct iphdr *iph = ip_hdr(skb);
1239 struct vif_device *vif = &net->ipv4.vif_table[vifi];
1240 struct net_device *dev;
1241 struct rtable *rt;
1242 int encap = 0;
1243
1244 if (vif->dev == NULL)
1245 goto out_free;
1246
1247 #ifdef CONFIG_IP_PIMSM
1248 if (vif->flags & VIFF_REGISTER) {
1249 vif->pkt_out++;
1250 vif->bytes_out += skb->len;
1251 vif->dev->stats.tx_bytes += skb->len;
1252 vif->dev->stats.tx_packets++;
1253 ipmr_cache_report(net, skb, vifi, IGMPMSG_WHOLEPKT);
1254 goto out_free;
1255 }
1256 #endif
1257
1258 if (vif->flags&VIFF_TUNNEL) {
1259 struct flowi fl = { .oif = vif->link,
1260 .nl_u = { .ip4_u =
1261 { .daddr = vif->remote,
1262 .saddr = vif->local,
1263 .tos = RT_TOS(iph->tos) } },
1264 .proto = IPPROTO_IPIP };
1265 if (ip_route_output_key(net, &rt, &fl))
1266 goto out_free;
1267 encap = sizeof(struct iphdr);
1268 } else {
1269 struct flowi fl = { .oif = vif->link,
1270 .nl_u = { .ip4_u =
1271 { .daddr = iph->daddr,
1272 .tos = RT_TOS(iph->tos) } },
1273 .proto = IPPROTO_IPIP };
1274 if (ip_route_output_key(net, &rt, &fl))
1275 goto out_free;
1276 }
1277
1278 dev = rt->u.dst.dev;
1279
1280 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1281 /* Do not fragment multicasts. Alas, IPv4 does not
1282 allow to send ICMP, so that packets will disappear
1283 to blackhole.
1284 */
1285
1286 IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
1287 ip_rt_put(rt);
1288 goto out_free;
1289 }
1290
1291 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1292
1293 if (skb_cow(skb, encap)) {
1294 ip_rt_put(rt);
1295 goto out_free;
1296 }
1297
1298 vif->pkt_out++;
1299 vif->bytes_out += skb->len;
1300
1301 skb_dst_drop(skb);
1302 skb_dst_set(skb, &rt->u.dst);
1303 ip_decrease_ttl(ip_hdr(skb));
1304
1305 /* FIXME: forward and output firewalls used to be called here.
1306 * What do we do with netfilter? -- RR */
1307 if (vif->flags & VIFF_TUNNEL) {
1308 ip_encap(skb, vif->local, vif->remote);
1309 /* FIXME: extra output firewall step used to be here. --RR */
1310 vif->dev->stats.tx_packets++;
1311 vif->dev->stats.tx_bytes += skb->len;
1312 }
1313
1314 IPCB(skb)->flags |= IPSKB_FORWARDED;
1315
1316 /*
1317 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1318 * not only before forwarding, but after forwarding on all output
1319 * interfaces. It is clear, if mrouter runs a multicasting
1320 * program, it should receive packets not depending to what interface
1321 * program is joined.
1322 * If we will not make it, the program will have to join on all
1323 * interfaces. On the other hand, multihoming host (or router, but
1324 * not mrouter) cannot join to more than one interface - it will
1325 * result in receiving multiple packets.
1326 */
1327 NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, dev,
1328 ipmr_forward_finish);
1329 return;
1330
1331 out_free:
1332 kfree_skb(skb);
1333 return;
1334 }
1335
1336 static int ipmr_find_vif(struct net_device *dev)
1337 {
1338 struct net *net = dev_net(dev);
1339 int ct;
1340 for (ct = net->ipv4.maxvif-1; ct >= 0; ct--) {
1341 if (net->ipv4.vif_table[ct].dev == dev)
1342 break;
1343 }
1344 return ct;
1345 }
1346
1347 /* "local" means that we should preserve one skb (for local delivery) */
1348
1349 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1350 {
1351 int psend = -1;
1352 int vif, ct;
1353 struct net *net = mfc_net(cache);
1354
1355 vif = cache->mfc_parent;
1356 cache->mfc_un.res.pkt++;
1357 cache->mfc_un.res.bytes += skb->len;
1358
1359 /*
1360 * Wrong interface: drop packet and (maybe) send PIM assert.
1361 */
1362 if (net->ipv4.vif_table[vif].dev != skb->dev) {
1363 int true_vifi;
1364
1365 if (skb_rtable(skb)->fl.iif == 0) {
1366 /* It is our own packet, looped back.
1367 Very complicated situation...
1368
1369 The best workaround until routing daemons will be
1370 fixed is not to redistribute packet, if it was
1371 send through wrong interface. It means, that
1372 multicast applications WILL NOT work for
1373 (S,G), which have default multicast route pointing
1374 to wrong oif. In any case, it is not a good
1375 idea to use multicasting applications on router.
1376 */
1377 goto dont_forward;
1378 }
1379
1380 cache->mfc_un.res.wrong_if++;
1381 true_vifi = ipmr_find_vif(skb->dev);
1382
1383 if (true_vifi >= 0 && net->ipv4.mroute_do_assert &&
1384 /* pimsm uses asserts, when switching from RPT to SPT,
1385 so that we cannot check that packet arrived on an oif.
1386 It is bad, but otherwise we would need to move pretty
1387 large chunk of pimd to kernel. Ough... --ANK
1388 */
1389 (net->ipv4.mroute_do_pim ||
1390 cache->mfc_un.res.ttls[true_vifi] < 255) &&
1391 time_after(jiffies,
1392 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1393 cache->mfc_un.res.last_assert = jiffies;
1394 ipmr_cache_report(net, skb, true_vifi, IGMPMSG_WRONGVIF);
1395 }
1396 goto dont_forward;
1397 }
1398
1399 net->ipv4.vif_table[vif].pkt_in++;
1400 net->ipv4.vif_table[vif].bytes_in += skb->len;
1401
1402 /*
1403 * Forward the frame
1404 */
1405 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1406 if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
1407 if (psend != -1) {
1408 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1409 if (skb2)
1410 ipmr_queue_xmit(skb2, cache, psend);
1411 }
1412 psend = ct;
1413 }
1414 }
1415 if (psend != -1) {
1416 if (local) {
1417 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1418 if (skb2)
1419 ipmr_queue_xmit(skb2, cache, psend);
1420 } else {
1421 ipmr_queue_xmit(skb, cache, psend);
1422 return 0;
1423 }
1424 }
1425
1426 dont_forward:
1427 if (!local)
1428 kfree_skb(skb);
1429 return 0;
1430 }
1431
1432
1433 /*
1434 * Multicast packets for forwarding arrive here
1435 */
1436
1437 int ip_mr_input(struct sk_buff *skb)
1438 {
1439 struct mfc_cache *cache;
1440 struct net *net = dev_net(skb->dev);
1441 int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
1442
1443 /* Packet is looped back after forward, it should not be
1444 forwarded second time, but still can be delivered locally.
1445 */
1446 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1447 goto dont_forward;
1448
1449 if (!local) {
1450 if (IPCB(skb)->opt.router_alert) {
1451 if (ip_call_ra_chain(skb))
1452 return 0;
1453 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){
1454 /* IGMPv1 (and broken IGMPv2 implementations sort of
1455 Cisco IOS <= 11.2(8)) do not put router alert
1456 option to IGMP packets destined to routable
1457 groups. It is very bad, because it means
1458 that we can forward NO IGMP messages.
1459 */
1460 read_lock(&mrt_lock);
1461 if (net->ipv4.mroute_sk) {
1462 nf_reset(skb);
1463 raw_rcv(net->ipv4.mroute_sk, skb);
1464 read_unlock(&mrt_lock);
1465 return 0;
1466 }
1467 read_unlock(&mrt_lock);
1468 }
1469 }
1470
1471 read_lock(&mrt_lock);
1472 cache = ipmr_cache_find(net, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
1473
1474 /*
1475 * No usable cache entry
1476 */
1477 if (cache == NULL) {
1478 int vif;
1479
1480 if (local) {
1481 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1482 ip_local_deliver(skb);
1483 if (skb2 == NULL) {
1484 read_unlock(&mrt_lock);
1485 return -ENOBUFS;
1486 }
1487 skb = skb2;
1488 }
1489
1490 vif = ipmr_find_vif(skb->dev);
1491 if (vif >= 0) {
1492 int err = ipmr_cache_unresolved(net, vif, skb);
1493 read_unlock(&mrt_lock);
1494
1495 return err;
1496 }
1497 read_unlock(&mrt_lock);
1498 kfree_skb(skb);
1499 return -ENODEV;
1500 }
1501
1502 ip_mr_forward(skb, cache, local);
1503
1504 read_unlock(&mrt_lock);
1505
1506 if (local)
1507 return ip_local_deliver(skb);
1508
1509 return 0;
1510
1511 dont_forward:
1512 if (local)
1513 return ip_local_deliver(skb);
1514 kfree_skb(skb);
1515 return 0;
1516 }
1517
1518 #ifdef CONFIG_IP_PIMSM
1519 static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
1520 {
1521 struct net_device *reg_dev = NULL;
1522 struct iphdr *encap;
1523 struct net *net = dev_net(skb->dev);
1524
1525 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
1526 /*
1527 Check that:
1528 a. packet is really destinted to a multicast group
1529 b. packet is not a NULL-REGISTER
1530 c. packet is not truncated
1531 */
1532 if (!ipv4_is_multicast(encap->daddr) ||
1533 encap->tot_len == 0 ||
1534 ntohs(encap->tot_len) + pimlen > skb->len)
1535 return 1;
1536
1537 read_lock(&mrt_lock);
1538 if (net->ipv4.mroute_reg_vif_num >= 0)
1539 reg_dev = net->ipv4.vif_table[net->ipv4.mroute_reg_vif_num].dev;
1540 if (reg_dev)
1541 dev_hold(reg_dev);
1542 read_unlock(&mrt_lock);
1543
1544 if (reg_dev == NULL)
1545 return 1;
1546
1547 skb->mac_header = skb->network_header;
1548 skb_pull(skb, (u8*)encap - skb->data);
1549 skb_reset_network_header(skb);
1550 skb->dev = reg_dev;
1551 skb->protocol = htons(ETH_P_IP);
1552 skb->ip_summed = 0;
1553 skb->pkt_type = PACKET_HOST;
1554 skb_dst_drop(skb);
1555 reg_dev->stats.rx_bytes += skb->len;
1556 reg_dev->stats.rx_packets++;
1557 nf_reset(skb);
1558 netif_rx(skb);
1559 dev_put(reg_dev);
1560
1561 return 0;
1562 }
1563 #endif
1564
1565 #ifdef CONFIG_IP_PIMSM_V1
1566 /*
1567 * Handle IGMP messages of PIMv1
1568 */
1569
1570 int pim_rcv_v1(struct sk_buff * skb)
1571 {
1572 struct igmphdr *pim;
1573 struct net *net = dev_net(skb->dev);
1574
1575 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1576 goto drop;
1577
1578 pim = igmp_hdr(skb);
1579
1580 if (!net->ipv4.mroute_do_pim ||
1581 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1582 goto drop;
1583
1584 if (__pim_rcv(skb, sizeof(*pim))) {
1585 drop:
1586 kfree_skb(skb);
1587 }
1588 return 0;
1589 }
1590 #endif
1591
1592 #ifdef CONFIG_IP_PIMSM_V2
1593 static int pim_rcv(struct sk_buff * skb)
1594 {
1595 struct pimreghdr *pim;
1596
1597 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1598 goto drop;
1599
1600 pim = (struct pimreghdr *)skb_transport_header(skb);
1601 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1602 (pim->flags&PIM_NULL_REGISTER) ||
1603 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1604 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1605 goto drop;
1606
1607 if (__pim_rcv(skb, sizeof(*pim))) {
1608 drop:
1609 kfree_skb(skb);
1610 }
1611 return 0;
1612 }
1613 #endif
1614
1615 static int
1616 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1617 {
1618 int ct;
1619 struct rtnexthop *nhp;
1620 struct net *net = mfc_net(c);
1621 u8 *b = skb_tail_pointer(skb);
1622 struct rtattr *mp_head;
1623
1624 /* If cache is unresolved, don't try to parse IIF and OIF */
1625 if (c->mfc_parent > MAXVIFS)
1626 return -ENOENT;
1627
1628 if (VIF_EXISTS(net, c->mfc_parent))
1629 RTA_PUT(skb, RTA_IIF, 4, &net->ipv4.vif_table[c->mfc_parent].dev->ifindex);
1630
1631 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1632
1633 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1634 if (VIF_EXISTS(net, ct) && c->mfc_un.res.ttls[ct] < 255) {
1635 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1636 goto rtattr_failure;
1637 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1638 nhp->rtnh_flags = 0;
1639 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1640 nhp->rtnh_ifindex = net->ipv4.vif_table[ct].dev->ifindex;
1641 nhp->rtnh_len = sizeof(*nhp);
1642 }
1643 }
1644 mp_head->rta_type = RTA_MULTIPATH;
1645 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1646 rtm->rtm_type = RTN_MULTICAST;
1647 return 1;
1648
1649 rtattr_failure:
1650 nlmsg_trim(skb, b);
1651 return -EMSGSIZE;
1652 }
1653
1654 int ipmr_get_route(struct net *net,
1655 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1656 {
1657 int err;
1658 struct mfc_cache *cache;
1659 struct rtable *rt = skb_rtable(skb);
1660
1661 read_lock(&mrt_lock);
1662 cache = ipmr_cache_find(net, rt->rt_src, rt->rt_dst);
1663
1664 if (cache == NULL) {
1665 struct sk_buff *skb2;
1666 struct iphdr *iph;
1667 struct net_device *dev;
1668 int vif;
1669
1670 if (nowait) {
1671 read_unlock(&mrt_lock);
1672 return -EAGAIN;
1673 }
1674
1675 dev = skb->dev;
1676 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1677 read_unlock(&mrt_lock);
1678 return -ENODEV;
1679 }
1680 skb2 = skb_clone(skb, GFP_ATOMIC);
1681 if (!skb2) {
1682 read_unlock(&mrt_lock);
1683 return -ENOMEM;
1684 }
1685
1686 skb_push(skb2, sizeof(struct iphdr));
1687 skb_reset_network_header(skb2);
1688 iph = ip_hdr(skb2);
1689 iph->ihl = sizeof(struct iphdr) >> 2;
1690 iph->saddr = rt->rt_src;
1691 iph->daddr = rt->rt_dst;
1692 iph->version = 0;
1693 err = ipmr_cache_unresolved(net, vif, skb2);
1694 read_unlock(&mrt_lock);
1695 return err;
1696 }
1697
1698 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1699 cache->mfc_flags |= MFC_NOTIFY;
1700 err = ipmr_fill_mroute(skb, cache, rtm);
1701 read_unlock(&mrt_lock);
1702 return err;
1703 }
1704
1705 #ifdef CONFIG_PROC_FS
1706 /*
1707 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1708 */
1709 struct ipmr_vif_iter {
1710 struct seq_net_private p;
1711 int ct;
1712 };
1713
1714 static struct vif_device *ipmr_vif_seq_idx(struct net *net,
1715 struct ipmr_vif_iter *iter,
1716 loff_t pos)
1717 {
1718 for (iter->ct = 0; iter->ct < net->ipv4.maxvif; ++iter->ct) {
1719 if (!VIF_EXISTS(net, iter->ct))
1720 continue;
1721 if (pos-- == 0)
1722 return &net->ipv4.vif_table[iter->ct];
1723 }
1724 return NULL;
1725 }
1726
1727 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1728 __acquires(mrt_lock)
1729 {
1730 struct net *net = seq_file_net(seq);
1731
1732 read_lock(&mrt_lock);
1733 return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
1734 : SEQ_START_TOKEN;
1735 }
1736
1737 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1738 {
1739 struct ipmr_vif_iter *iter = seq->private;
1740 struct net *net = seq_file_net(seq);
1741
1742 ++*pos;
1743 if (v == SEQ_START_TOKEN)
1744 return ipmr_vif_seq_idx(net, iter, 0);
1745
1746 while (++iter->ct < net->ipv4.maxvif) {
1747 if (!VIF_EXISTS(net, iter->ct))
1748 continue;
1749 return &net->ipv4.vif_table[iter->ct];
1750 }
1751 return NULL;
1752 }
1753
1754 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1755 __releases(mrt_lock)
1756 {
1757 read_unlock(&mrt_lock);
1758 }
1759
1760 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1761 {
1762 struct net *net = seq_file_net(seq);
1763
1764 if (v == SEQ_START_TOKEN) {
1765 seq_puts(seq,
1766 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1767 } else {
1768 const struct vif_device *vif = v;
1769 const char *name = vif->dev ? vif->dev->name : "none";
1770
1771 seq_printf(seq,
1772 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1773 vif - net->ipv4.vif_table,
1774 name, vif->bytes_in, vif->pkt_in,
1775 vif->bytes_out, vif->pkt_out,
1776 vif->flags, vif->local, vif->remote);
1777 }
1778 return 0;
1779 }
1780
1781 static const struct seq_operations ipmr_vif_seq_ops = {
1782 .start = ipmr_vif_seq_start,
1783 .next = ipmr_vif_seq_next,
1784 .stop = ipmr_vif_seq_stop,
1785 .show = ipmr_vif_seq_show,
1786 };
1787
1788 static int ipmr_vif_open(struct inode *inode, struct file *file)
1789 {
1790 return seq_open_net(inode, file, &ipmr_vif_seq_ops,
1791 sizeof(struct ipmr_vif_iter));
1792 }
1793
1794 static const struct file_operations ipmr_vif_fops = {
1795 .owner = THIS_MODULE,
1796 .open = ipmr_vif_open,
1797 .read = seq_read,
1798 .llseek = seq_lseek,
1799 .release = seq_release_net,
1800 };
1801
1802 struct ipmr_mfc_iter {
1803 struct seq_net_private p;
1804 struct mfc_cache **cache;
1805 int ct;
1806 };
1807
1808
1809 static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
1810 struct ipmr_mfc_iter *it, loff_t pos)
1811 {
1812 struct mfc_cache *mfc;
1813
1814 it->cache = net->ipv4.mfc_cache_array;
1815 read_lock(&mrt_lock);
1816 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1817 for (mfc = net->ipv4.mfc_cache_array[it->ct];
1818 mfc; mfc = mfc->next)
1819 if (pos-- == 0)
1820 return mfc;
1821 read_unlock(&mrt_lock);
1822
1823 it->cache = &mfc_unres_queue;
1824 spin_lock_bh(&mfc_unres_lock);
1825 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1826 if (net_eq(mfc_net(mfc), net) &&
1827 pos-- == 0)
1828 return mfc;
1829 spin_unlock_bh(&mfc_unres_lock);
1830
1831 it->cache = NULL;
1832 return NULL;
1833 }
1834
1835
1836 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1837 {
1838 struct ipmr_mfc_iter *it = seq->private;
1839 struct net *net = seq_file_net(seq);
1840
1841 it->cache = NULL;
1842 it->ct = 0;
1843 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
1844 : SEQ_START_TOKEN;
1845 }
1846
1847 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1848 {
1849 struct mfc_cache *mfc = v;
1850 struct ipmr_mfc_iter *it = seq->private;
1851 struct net *net = seq_file_net(seq);
1852
1853 ++*pos;
1854
1855 if (v == SEQ_START_TOKEN)
1856 return ipmr_mfc_seq_idx(net, seq->private, 0);
1857
1858 if (mfc->next)
1859 return mfc->next;
1860
1861 if (it->cache == &mfc_unres_queue)
1862 goto end_of_list;
1863
1864 BUG_ON(it->cache != net->ipv4.mfc_cache_array);
1865
1866 while (++it->ct < MFC_LINES) {
1867 mfc = net->ipv4.mfc_cache_array[it->ct];
1868 if (mfc)
1869 return mfc;
1870 }
1871
1872 /* exhausted cache_array, show unresolved */
1873 read_unlock(&mrt_lock);
1874 it->cache = &mfc_unres_queue;
1875 it->ct = 0;
1876
1877 spin_lock_bh(&mfc_unres_lock);
1878 mfc = mfc_unres_queue;
1879 while (mfc && !net_eq(mfc_net(mfc), net))
1880 mfc = mfc->next;
1881 if (mfc)
1882 return mfc;
1883
1884 end_of_list:
1885 spin_unlock_bh(&mfc_unres_lock);
1886 it->cache = NULL;
1887
1888 return NULL;
1889 }
1890
1891 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1892 {
1893 struct ipmr_mfc_iter *it = seq->private;
1894 struct net *net = seq_file_net(seq);
1895
1896 if (it->cache == &mfc_unres_queue)
1897 spin_unlock_bh(&mfc_unres_lock);
1898 else if (it->cache == net->ipv4.mfc_cache_array)
1899 read_unlock(&mrt_lock);
1900 }
1901
1902 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1903 {
1904 int n;
1905 struct net *net = seq_file_net(seq);
1906
1907 if (v == SEQ_START_TOKEN) {
1908 seq_puts(seq,
1909 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1910 } else {
1911 const struct mfc_cache *mfc = v;
1912 const struct ipmr_mfc_iter *it = seq->private;
1913
1914 seq_printf(seq, "%08lX %08lX %-3hd",
1915 (unsigned long) mfc->mfc_mcastgrp,
1916 (unsigned long) mfc->mfc_origin,
1917 mfc->mfc_parent);
1918
1919 if (it->cache != &mfc_unres_queue) {
1920 seq_printf(seq, " %8lu %8lu %8lu",
1921 mfc->mfc_un.res.pkt,
1922 mfc->mfc_un.res.bytes,
1923 mfc->mfc_un.res.wrong_if);
1924 for (n = mfc->mfc_un.res.minvif;
1925 n < mfc->mfc_un.res.maxvif; n++ ) {
1926 if (VIF_EXISTS(net, n) &&
1927 mfc->mfc_un.res.ttls[n] < 255)
1928 seq_printf(seq,
1929 " %2d:%-3d",
1930 n, mfc->mfc_un.res.ttls[n]);
1931 }
1932 } else {
1933 /* unresolved mfc_caches don't contain
1934 * pkt, bytes and wrong_if values
1935 */
1936 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
1937 }
1938 seq_putc(seq, '\n');
1939 }
1940 return 0;
1941 }
1942
1943 static const struct seq_operations ipmr_mfc_seq_ops = {
1944 .start = ipmr_mfc_seq_start,
1945 .next = ipmr_mfc_seq_next,
1946 .stop = ipmr_mfc_seq_stop,
1947 .show = ipmr_mfc_seq_show,
1948 };
1949
1950 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1951 {
1952 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
1953 sizeof(struct ipmr_mfc_iter));
1954 }
1955
1956 static const struct file_operations ipmr_mfc_fops = {
1957 .owner = THIS_MODULE,
1958 .open = ipmr_mfc_open,
1959 .read = seq_read,
1960 .llseek = seq_lseek,
1961 .release = seq_release_net,
1962 };
1963 #endif
1964
1965 #ifdef CONFIG_IP_PIMSM_V2
1966 static const struct net_protocol pim_protocol = {
1967 .handler = pim_rcv,
1968 .netns_ok = 1,
1969 };
1970 #endif
1971
1972
1973 /*
1974 * Setup for IP multicast routing
1975 */
1976 static int __net_init ipmr_net_init(struct net *net)
1977 {
1978 int err = 0;
1979
1980 net->ipv4.vif_table = kcalloc(MAXVIFS, sizeof(struct vif_device),
1981 GFP_KERNEL);
1982 if (!net->ipv4.vif_table) {
1983 err = -ENOMEM;
1984 goto fail;
1985 }
1986
1987 /* Forwarding cache */
1988 net->ipv4.mfc_cache_array = kcalloc(MFC_LINES,
1989 sizeof(struct mfc_cache *),
1990 GFP_KERNEL);
1991 if (!net->ipv4.mfc_cache_array) {
1992 err = -ENOMEM;
1993 goto fail_mfc_cache;
1994 }
1995
1996 #ifdef CONFIG_IP_PIMSM
1997 net->ipv4.mroute_reg_vif_num = -1;
1998 #endif
1999
2000 #ifdef CONFIG_PROC_FS
2001 err = -ENOMEM;
2002 if (!proc_net_fops_create(net, "ip_mr_vif", 0, &ipmr_vif_fops))
2003 goto proc_vif_fail;
2004 if (!proc_net_fops_create(net, "ip_mr_cache", 0, &ipmr_mfc_fops))
2005 goto proc_cache_fail;
2006 #endif
2007 return 0;
2008
2009 #ifdef CONFIG_PROC_FS
2010 proc_cache_fail:
2011 proc_net_remove(net, "ip_mr_vif");
2012 proc_vif_fail:
2013 kfree(net->ipv4.mfc_cache_array);
2014 #endif
2015 fail_mfc_cache:
2016 kfree(net->ipv4.vif_table);
2017 fail:
2018 return err;
2019 }
2020
2021 static void __net_exit ipmr_net_exit(struct net *net)
2022 {
2023 #ifdef CONFIG_PROC_FS
2024 proc_net_remove(net, "ip_mr_cache");
2025 proc_net_remove(net, "ip_mr_vif");
2026 #endif
2027 kfree(net->ipv4.mfc_cache_array);
2028 kfree(net->ipv4.vif_table);
2029 }
2030
2031 static struct pernet_operations ipmr_net_ops = {
2032 .init = ipmr_net_init,
2033 .exit = ipmr_net_exit,
2034 };
2035
2036 int __init ip_mr_init(void)
2037 {
2038 int err;
2039
2040 mrt_cachep = kmem_cache_create("ip_mrt_cache",
2041 sizeof(struct mfc_cache),
2042 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
2043 NULL);
2044 if (!mrt_cachep)
2045 return -ENOMEM;
2046
2047 err = register_pernet_subsys(&ipmr_net_ops);
2048 if (err)
2049 goto reg_pernet_fail;
2050
2051 setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
2052 err = register_netdevice_notifier(&ip_mr_notifier);
2053 if (err)
2054 goto reg_notif_fail;
2055 #ifdef CONFIG_IP_PIMSM_V2
2056 if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
2057 printk(KERN_ERR "ip_mr_init: can't add PIM protocol\n");
2058 err = -EAGAIN;
2059 goto add_proto_fail;
2060 }
2061 #endif
2062 return 0;
2063
2064 #ifdef CONFIG_IP_PIMSM_V2
2065 add_proto_fail:
2066 unregister_netdevice_notifier(&ip_mr_notifier);
2067 #endif
2068 reg_notif_fail:
2069 del_timer(&ipmr_expire_timer);
2070 unregister_pernet_subsys(&ipmr_net_ops);
2071 reg_pernet_fail:
2072 kmem_cache_destroy(mrt_cachep);
2073 return err;
2074 }
Linux ARM platform port for MOXA ART SoC