?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
powerpc/cpumask: Dynamically allocate cpu_sibling_map and cpu_core_map cpumasks
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / ipv4 / ipmr.c
blob9d4f6d1340a438b2f8004d3906b52e6bfe069756
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 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
758 }
759
760 /*
761 * See if we can append the packet
762 */
763 if (c->mfc_un.unres.unresolved.qlen>3) {
764 kfree_skb(skb);
765 err = -ENOBUFS;
766 } else {
767 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
768 err = 0;
769 }
770
771 spin_unlock_bh(&mfc_unres_lock);
772 return err;
773 }
774
775 /*
776 * MFC cache manipulation by user space mroute daemon
777 */
778
779 static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc)
780 {
781 int line;
782 struct mfc_cache *c, **cp;
783
784 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
785
786 for (cp = &net->ipv4.mfc_cache_array[line];
787 (c = *cp) != NULL; cp = &c->next) {
788 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
789 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
790 write_lock_bh(&mrt_lock);
791 *cp = c->next;
792 write_unlock_bh(&mrt_lock);
793
794 ipmr_cache_free(c);
795 return 0;
796 }
797 }
798 return -ENOENT;
799 }
800
801 static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
802 {
803 int line;
804 struct mfc_cache *uc, *c, **cp;
805
806 if (mfc->mfcc_parent >= MAXVIFS)
807 return -ENFILE;
808
809 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
810
811 for (cp = &net->ipv4.mfc_cache_array[line];
812 (c = *cp) != NULL; cp = &c->next) {
813 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
814 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
815 break;
816 }
817
818 if (c != NULL) {
819 write_lock_bh(&mrt_lock);
820 c->mfc_parent = mfc->mfcc_parent;
821 ipmr_update_thresholds(c, mfc->mfcc_ttls);
822 if (!mrtsock)
823 c->mfc_flags |= MFC_STATIC;
824 write_unlock_bh(&mrt_lock);
825 return 0;
826 }
827
828 if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
829 return -EINVAL;
830
831 c = ipmr_cache_alloc(net);
832 if (c == NULL)
833 return -ENOMEM;
834
835 c->mfc_origin = mfc->mfcc_origin.s_addr;
836 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
837 c->mfc_parent = mfc->mfcc_parent;
838 ipmr_update_thresholds(c, mfc->mfcc_ttls);
839 if (!mrtsock)
840 c->mfc_flags |= MFC_STATIC;
841
842 write_lock_bh(&mrt_lock);
843 c->next = net->ipv4.mfc_cache_array[line];
844 net->ipv4.mfc_cache_array[line] = c;
845 write_unlock_bh(&mrt_lock);
846
847 /*
848 * Check to see if we resolved a queued list. If so we
849 * need to send on the frames and tidy up.
850 */
851 spin_lock_bh(&mfc_unres_lock);
852 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
853 cp = &uc->next) {
854 if (net_eq(mfc_net(uc), net) &&
855 uc->mfc_origin == c->mfc_origin &&
856 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
857 *cp = uc->next;
858 atomic_dec(&net->ipv4.cache_resolve_queue_len);
859 break;
860 }
861 }
862 if (mfc_unres_queue == NULL)
863 del_timer(&ipmr_expire_timer);
864 spin_unlock_bh(&mfc_unres_lock);
865
866 if (uc) {
867 ipmr_cache_resolve(uc, c);
868 ipmr_cache_free(uc);
869 }
870 return 0;
871 }
872
873 /*
874 * Close the multicast socket, and clear the vif tables etc
875 */
876
877 static void mroute_clean_tables(struct net *net)
878 {
879 int i;
880 LIST_HEAD(list);
881
882 /*
883 * Shut down all active vif entries
884 */
885 for (i = 0; i < net->ipv4.maxvif; i++) {
886 if (!(net->ipv4.vif_table[i].flags&VIFF_STATIC))
887 vif_delete(net, i, 0, &list);
888 }
889 unregister_netdevice_many(&list);
890
891 /*
892 * Wipe the cache
893 */
894 for (i=0; i<MFC_LINES; i++) {
895 struct mfc_cache *c, **cp;
896
897 cp = &net->ipv4.mfc_cache_array[i];
898 while ((c = *cp) != NULL) {
899 if (c->mfc_flags&MFC_STATIC) {
900 cp = &c->next;
901 continue;
902 }
903 write_lock_bh(&mrt_lock);
904 *cp = c->next;
905 write_unlock_bh(&mrt_lock);
906
907 ipmr_cache_free(c);
908 }
909 }
910
911 if (atomic_read(&net->ipv4.cache_resolve_queue_len) != 0) {
912 struct mfc_cache *c, **cp;
913
914 spin_lock_bh(&mfc_unres_lock);
915 cp = &mfc_unres_queue;
916 while ((c = *cp) != NULL) {
917 if (!net_eq(mfc_net(c), net)) {
918 cp = &c->next;
919 continue;
920 }
921 *cp = c->next;
922
923 ipmr_destroy_unres(c);
924 }
925 spin_unlock_bh(&mfc_unres_lock);
926 }
927 }
928
929 static void mrtsock_destruct(struct sock *sk)
930 {
931 struct net *net = sock_net(sk);
932
933 rtnl_lock();
934 if (sk == net->ipv4.mroute_sk) {
935 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
936
937 write_lock_bh(&mrt_lock);
938 net->ipv4.mroute_sk = NULL;
939 write_unlock_bh(&mrt_lock);
940
941 mroute_clean_tables(net);
942 }
943 rtnl_unlock();
944 }
945
946 /*
947 * Socket options and virtual interface manipulation. The whole
948 * virtual interface system is a complete heap, but unfortunately
949 * that's how BSD mrouted happens to think. Maybe one day with a proper
950 * MOSPF/PIM router set up we can clean this up.
951 */
952
953 int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
954 {
955 int ret;
956 struct vifctl vif;
957 struct mfcctl mfc;
958 struct net *net = sock_net(sk);
959
960 if (optname != MRT_INIT) {
961 if (sk != net->ipv4.mroute_sk && !capable(CAP_NET_ADMIN))
962 return -EACCES;
963 }
964
965 switch (optname) {
966 case MRT_INIT:
967 if (sk->sk_type != SOCK_RAW ||
968 inet_sk(sk)->inet_num != IPPROTO_IGMP)
969 return -EOPNOTSUPP;
970 if (optlen != sizeof(int))
971 return -ENOPROTOOPT;
972
973 rtnl_lock();
974 if (net->ipv4.mroute_sk) {
975 rtnl_unlock();
976 return -EADDRINUSE;
977 }
978
979 ret = ip_ra_control(sk, 1, mrtsock_destruct);
980 if (ret == 0) {
981 write_lock_bh(&mrt_lock);
982 net->ipv4.mroute_sk = sk;
983 write_unlock_bh(&mrt_lock);
984
985 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
986 }
987 rtnl_unlock();
988 return ret;
989 case MRT_DONE:
990 if (sk != net->ipv4.mroute_sk)
991 return -EACCES;
992 return ip_ra_control(sk, 0, NULL);
993 case MRT_ADD_VIF:
994 case MRT_DEL_VIF:
995 if (optlen != sizeof(vif))
996 return -EINVAL;
997 if (copy_from_user(&vif, optval, sizeof(vif)))
998 return -EFAULT;
999 if (vif.vifc_vifi >= MAXVIFS)
1000 return -ENFILE;
1001 rtnl_lock();
1002 if (optname == MRT_ADD_VIF) {
1003 ret = vif_add(net, &vif, sk == net->ipv4.mroute_sk);
1004 } else {
1005 ret = vif_delete(net, vif.vifc_vifi, 0, NULL);
1006 }
1007 rtnl_unlock();
1008 return ret;
1009
1010 /*
1011 * Manipulate the forwarding caches. These live
1012 * in a sort of kernel/user symbiosis.
1013 */
1014 case MRT_ADD_MFC:
1015 case MRT_DEL_MFC:
1016 if (optlen != sizeof(mfc))
1017 return -EINVAL;
1018 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1019 return -EFAULT;
1020 rtnl_lock();
1021 if (optname == MRT_DEL_MFC)
1022 ret = ipmr_mfc_delete(net, &mfc);
1023 else
1024 ret = ipmr_mfc_add(net, &mfc, sk == net->ipv4.mroute_sk);
1025 rtnl_unlock();
1026 return ret;
1027 /*
1028 * Control PIM assert.
1029 */
1030 case MRT_ASSERT:
1031 {
1032 int v;
1033 if (get_user(v,(int __user *)optval))
1034 return -EFAULT;
1035 net->ipv4.mroute_do_assert = (v) ? 1 : 0;
1036 return 0;
1037 }
1038 #ifdef CONFIG_IP_PIMSM
1039 case MRT_PIM:
1040 {
1041 int v;
1042
1043 if (get_user(v,(int __user *)optval))
1044 return -EFAULT;
1045 v = (v) ? 1 : 0;
1046
1047 rtnl_lock();
1048 ret = 0;
1049 if (v != net->ipv4.mroute_do_pim) {
1050 net->ipv4.mroute_do_pim = v;
1051 net->ipv4.mroute_do_assert = v;
1052 }
1053 rtnl_unlock();
1054 return ret;
1055 }
1056 #endif
1057 /*
1058 * Spurious command, or MRT_VERSION which you cannot
1059 * set.
1060 */
1061 default:
1062 return -ENOPROTOOPT;
1063 }
1064 }
1065
1066 /*
1067 * Getsock opt support for the multicast routing system.
1068 */
1069
1070 int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
1071 {
1072 int olr;
1073 int val;
1074 struct net *net = sock_net(sk);
1075
1076 if (optname != MRT_VERSION &&
1077 #ifdef CONFIG_IP_PIMSM
1078 optname!=MRT_PIM &&
1079 #endif
1080 optname!=MRT_ASSERT)
1081 return -ENOPROTOOPT;
1082
1083 if (get_user(olr, optlen))
1084 return -EFAULT;
1085
1086 olr = min_t(unsigned int, olr, sizeof(int));
1087 if (olr < 0)
1088 return -EINVAL;
1089
1090 if (put_user(olr, optlen))
1091 return -EFAULT;
1092 if (optname == MRT_VERSION)
1093 val = 0x0305;
1094 #ifdef CONFIG_IP_PIMSM
1095 else if (optname == MRT_PIM)
1096 val = net->ipv4.mroute_do_pim;
1097 #endif
1098 else
1099 val = net->ipv4.mroute_do_assert;
1100 if (copy_to_user(optval, &val, olr))
1101 return -EFAULT;
1102 return 0;
1103 }
1104
1105 /*
1106 * The IP multicast ioctl support routines.
1107 */
1108
1109 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1110 {
1111 struct sioc_sg_req sr;
1112 struct sioc_vif_req vr;
1113 struct vif_device *vif;
1114 struct mfc_cache *c;
1115 struct net *net = sock_net(sk);
1116
1117 switch (cmd) {
1118 case SIOCGETVIFCNT:
1119 if (copy_from_user(&vr, arg, sizeof(vr)))
1120 return -EFAULT;
1121 if (vr.vifi >= net->ipv4.maxvif)
1122 return -EINVAL;
1123 read_lock(&mrt_lock);
1124 vif = &net->ipv4.vif_table[vr.vifi];
1125 if (VIF_EXISTS(net, vr.vifi)) {
1126 vr.icount = vif->pkt_in;
1127 vr.ocount = vif->pkt_out;
1128 vr.ibytes = vif->bytes_in;
1129 vr.obytes = vif->bytes_out;
1130 read_unlock(&mrt_lock);
1131
1132 if (copy_to_user(arg, &vr, sizeof(vr)))
1133 return -EFAULT;
1134 return 0;
1135 }
1136 read_unlock(&mrt_lock);
1137 return -EADDRNOTAVAIL;
1138 case SIOCGETSGCNT:
1139 if (copy_from_user(&sr, arg, sizeof(sr)))
1140 return -EFAULT;
1141
1142 read_lock(&mrt_lock);
1143 c = ipmr_cache_find(net, sr.src.s_addr, sr.grp.s_addr);
1144 if (c) {
1145 sr.pktcnt = c->mfc_un.res.pkt;
1146 sr.bytecnt = c->mfc_un.res.bytes;
1147 sr.wrong_if = c->mfc_un.res.wrong_if;
1148 read_unlock(&mrt_lock);
1149
1150 if (copy_to_user(arg, &sr, sizeof(sr)))
1151 return -EFAULT;
1152 return 0;
1153 }
1154 read_unlock(&mrt_lock);
1155 return -EADDRNOTAVAIL;
1156 default:
1157 return -ENOIOCTLCMD;
1158 }
1159 }
1160
1161
1162 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1163 {
1164 struct net_device *dev = ptr;
1165 struct net *net = dev_net(dev);
1166 struct vif_device *v;
1167 int ct;
1168 LIST_HEAD(list);
1169
1170 if (event != NETDEV_UNREGISTER)
1171 return NOTIFY_DONE;
1172 v = &net->ipv4.vif_table[0];
1173 for (ct = 0; ct < net->ipv4.maxvif; ct++, v++) {
1174 if (v->dev == dev)
1175 vif_delete(net, ct, 1, &list);
1176 }
1177 unregister_netdevice_many(&list);
1178 return NOTIFY_DONE;
1179 }
1180
1181
1182 static struct notifier_block ip_mr_notifier = {
1183 .notifier_call = ipmr_device_event,
1184 };
1185
1186 /*
1187 * Encapsulate a packet by attaching a valid IPIP header to it.
1188 * This avoids tunnel drivers and other mess and gives us the speed so
1189 * important for multicast video.
1190 */
1191
1192 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1193 {
1194 struct iphdr *iph;
1195 struct iphdr *old_iph = ip_hdr(skb);
1196
1197 skb_push(skb, sizeof(struct iphdr));
1198 skb->transport_header = skb->network_header;
1199 skb_reset_network_header(skb);
1200 iph = ip_hdr(skb);
1201
1202 iph->version = 4;
1203 iph->tos = old_iph->tos;
1204 iph->ttl = old_iph->ttl;
1205 iph->frag_off = 0;
1206 iph->daddr = daddr;
1207 iph->saddr = saddr;
1208 iph->protocol = IPPROTO_IPIP;
1209 iph->ihl = 5;
1210 iph->tot_len = htons(skb->len);
1211 ip_select_ident(iph, skb_dst(skb), NULL);
1212 ip_send_check(iph);
1213
1214 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1215 nf_reset(skb);
1216 }
1217
1218 static inline int ipmr_forward_finish(struct sk_buff *skb)
1219 {
1220 struct ip_options * opt = &(IPCB(skb)->opt);
1221
1222 IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
1223
1224 if (unlikely(opt->optlen))
1225 ip_forward_options(skb);
1226
1227 return dst_output(skb);
1228 }
1229
1230 /*
1231 * Processing handlers for ipmr_forward
1232 */
1233
1234 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1235 {
1236 struct net *net = mfc_net(c);
1237 const struct iphdr *iph = ip_hdr(skb);
1238 struct vif_device *vif = &net->ipv4.vif_table[vifi];
1239 struct net_device *dev;
1240 struct rtable *rt;
1241 int encap = 0;
1242
1243 if (vif->dev == NULL)
1244 goto out_free;
1245
1246 #ifdef CONFIG_IP_PIMSM
1247 if (vif->flags & VIFF_REGISTER) {
1248 vif->pkt_out++;
1249 vif->bytes_out += skb->len;
1250 vif->dev->stats.tx_bytes += skb->len;
1251 vif->dev->stats.tx_packets++;
1252 ipmr_cache_report(net, skb, vifi, IGMPMSG_WHOLEPKT);
1253 goto out_free;
1254 }
1255 #endif
1256
1257 if (vif->flags&VIFF_TUNNEL) {
1258 struct flowi fl = { .oif = vif->link,
1259 .nl_u = { .ip4_u =
1260 { .daddr = vif->remote,
1261 .saddr = vif->local,
1262 .tos = RT_TOS(iph->tos) } },
1263 .proto = IPPROTO_IPIP };
1264 if (ip_route_output_key(net, &rt, &fl))
1265 goto out_free;
1266 encap = sizeof(struct iphdr);
1267 } else {
1268 struct flowi fl = { .oif = vif->link,
1269 .nl_u = { .ip4_u =
1270 { .daddr = iph->daddr,
1271 .tos = RT_TOS(iph->tos) } },
1272 .proto = IPPROTO_IPIP };
1273 if (ip_route_output_key(net, &rt, &fl))
1274 goto out_free;
1275 }
1276
1277 dev = rt->u.dst.dev;
1278
1279 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1280 /* Do not fragment multicasts. Alas, IPv4 does not
1281 allow to send ICMP, so that packets will disappear
1282 to blackhole.
1283 */
1284
1285 IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
1286 ip_rt_put(rt);
1287 goto out_free;
1288 }
1289
1290 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1291
1292 if (skb_cow(skb, encap)) {
1293 ip_rt_put(rt);
1294 goto out_free;
1295 }
1296
1297 vif->pkt_out++;
1298 vif->bytes_out += skb->len;
1299
1300 skb_dst_drop(skb);
1301 skb_dst_set(skb, &rt->u.dst);
1302 ip_decrease_ttl(ip_hdr(skb));
1303
1304 /* FIXME: forward and output firewalls used to be called here.
1305 * What do we do with netfilter? -- RR */
1306 if (vif->flags & VIFF_TUNNEL) {
1307 ip_encap(skb, vif->local, vif->remote);
1308 /* FIXME: extra output firewall step used to be here. --RR */
1309 vif->dev->stats.tx_packets++;
1310 vif->dev->stats.tx_bytes += skb->len;
1311 }
1312
1313 IPCB(skb)->flags |= IPSKB_FORWARDED;
1314
1315 /*
1316 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1317 * not only before forwarding, but after forwarding on all output
1318 * interfaces. It is clear, if mrouter runs a multicasting
1319 * program, it should receive packets not depending to what interface
1320 * program is joined.
1321 * If we will not make it, the program will have to join on all
1322 * interfaces. On the other hand, multihoming host (or router, but
1323 * not mrouter) cannot join to more than one interface - it will
1324 * result in receiving multiple packets.
1325 */
1326 NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, dev,
1327 ipmr_forward_finish);
1328 return;
1329
1330 out_free:
1331 kfree_skb(skb);
1332 return;
1333 }
1334
1335 static int ipmr_find_vif(struct net_device *dev)
1336 {
1337 struct net *net = dev_net(dev);
1338 int ct;
1339 for (ct = net->ipv4.maxvif-1; ct >= 0; ct--) {
1340 if (net->ipv4.vif_table[ct].dev == dev)
1341 break;
1342 }
1343 return ct;
1344 }
1345
1346 /* "local" means that we should preserve one skb (for local delivery) */
1347
1348 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1349 {
1350 int psend = -1;
1351 int vif, ct;
1352 struct net *net = mfc_net(cache);
1353
1354 vif = cache->mfc_parent;
1355 cache->mfc_un.res.pkt++;
1356 cache->mfc_un.res.bytes += skb->len;
1357
1358 /*
1359 * Wrong interface: drop packet and (maybe) send PIM assert.
1360 */
1361 if (net->ipv4.vif_table[vif].dev != skb->dev) {
1362 int true_vifi;
1363
1364 if (skb_rtable(skb)->fl.iif == 0) {
1365 /* It is our own packet, looped back.
1366 Very complicated situation...
1367
1368 The best workaround until routing daemons will be
1369 fixed is not to redistribute packet, if it was
1370 send through wrong interface. It means, that
1371 multicast applications WILL NOT work for
1372 (S,G), which have default multicast route pointing
1373 to wrong oif. In any case, it is not a good
1374 idea to use multicasting applications on router.
1375 */
1376 goto dont_forward;
1377 }
1378
1379 cache->mfc_un.res.wrong_if++;
1380 true_vifi = ipmr_find_vif(skb->dev);
1381
1382 if (true_vifi >= 0 && net->ipv4.mroute_do_assert &&
1383 /* pimsm uses asserts, when switching from RPT to SPT,
1384 so that we cannot check that packet arrived on an oif.
1385 It is bad, but otherwise we would need to move pretty
1386 large chunk of pimd to kernel. Ough... --ANK
1387 */
1388 (net->ipv4.mroute_do_pim ||
1389 cache->mfc_un.res.ttls[true_vifi] < 255) &&
1390 time_after(jiffies,
1391 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1392 cache->mfc_un.res.last_assert = jiffies;
1393 ipmr_cache_report(net, skb, true_vifi, IGMPMSG_WRONGVIF);
1394 }
1395 goto dont_forward;
1396 }
1397
1398 net->ipv4.vif_table[vif].pkt_in++;
1399 net->ipv4.vif_table[vif].bytes_in += skb->len;
1400
1401 /*
1402 * Forward the frame
1403 */
1404 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1405 if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
1406 if (psend != -1) {
1407 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1408 if (skb2)
1409 ipmr_queue_xmit(skb2, cache, psend);
1410 }
1411 psend = ct;
1412 }
1413 }
1414 if (psend != -1) {
1415 if (local) {
1416 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1417 if (skb2)
1418 ipmr_queue_xmit(skb2, cache, psend);
1419 } else {
1420 ipmr_queue_xmit(skb, cache, psend);
1421 return 0;
1422 }
1423 }
1424
1425 dont_forward:
1426 if (!local)
1427 kfree_skb(skb);
1428 return 0;
1429 }
1430
1431
1432 /*
1433 * Multicast packets for forwarding arrive here
1434 */
1435
1436 int ip_mr_input(struct sk_buff *skb)
1437 {
1438 struct mfc_cache *cache;
1439 struct net *net = dev_net(skb->dev);
1440 int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
1441
1442 /* Packet is looped back after forward, it should not be
1443 forwarded second time, but still can be delivered locally.
1444 */
1445 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1446 goto dont_forward;
1447
1448 if (!local) {
1449 if (IPCB(skb)->opt.router_alert) {
1450 if (ip_call_ra_chain(skb))
1451 return 0;
1452 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){
1453 /* IGMPv1 (and broken IGMPv2 implementations sort of
1454 Cisco IOS <= 11.2(8)) do not put router alert
1455 option to IGMP packets destined to routable
1456 groups. It is very bad, because it means
1457 that we can forward NO IGMP messages.
1458 */
1459 read_lock(&mrt_lock);
1460 if (net->ipv4.mroute_sk) {
1461 nf_reset(skb);
1462 raw_rcv(net->ipv4.mroute_sk, skb);
1463 read_unlock(&mrt_lock);
1464 return 0;
1465 }
1466 read_unlock(&mrt_lock);
1467 }
1468 }
1469
1470 read_lock(&mrt_lock);
1471 cache = ipmr_cache_find(net, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
1472
1473 /*
1474 * No usable cache entry
1475 */
1476 if (cache == NULL) {
1477 int vif;
1478
1479 if (local) {
1480 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1481 ip_local_deliver(skb);
1482 if (skb2 == NULL) {
1483 read_unlock(&mrt_lock);
1484 return -ENOBUFS;
1485 }
1486 skb = skb2;
1487 }
1488
1489 vif = ipmr_find_vif(skb->dev);
1490 if (vif >= 0) {
1491 int err = ipmr_cache_unresolved(net, vif, skb);
1492 read_unlock(&mrt_lock);
1493
1494 return err;
1495 }
1496 read_unlock(&mrt_lock);
1497 kfree_skb(skb);
1498 return -ENODEV;
1499 }
1500
1501 ip_mr_forward(skb, cache, local);
1502
1503 read_unlock(&mrt_lock);
1504
1505 if (local)
1506 return ip_local_deliver(skb);
1507
1508 return 0;
1509
1510 dont_forward:
1511 if (local)
1512 return ip_local_deliver(skb);
1513 kfree_skb(skb);
1514 return 0;
1515 }
1516
1517 #ifdef CONFIG_IP_PIMSM
1518 static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
1519 {
1520 struct net_device *reg_dev = NULL;
1521 struct iphdr *encap;
1522 struct net *net = dev_net(skb->dev);
1523
1524 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
1525 /*
1526 Check that:
1527 a. packet is really destinted to a multicast group
1528 b. packet is not a NULL-REGISTER
1529 c. packet is not truncated
1530 */
1531 if (!ipv4_is_multicast(encap->daddr) ||
1532 encap->tot_len == 0 ||
1533 ntohs(encap->tot_len) + pimlen > skb->len)
1534 return 1;
1535
1536 read_lock(&mrt_lock);
1537 if (net->ipv4.mroute_reg_vif_num >= 0)
1538 reg_dev = net->ipv4.vif_table[net->ipv4.mroute_reg_vif_num].dev;
1539 if (reg_dev)
1540 dev_hold(reg_dev);
1541 read_unlock(&mrt_lock);
1542
1543 if (reg_dev == NULL)
1544 return 1;
1545
1546 skb->mac_header = skb->network_header;
1547 skb_pull(skb, (u8*)encap - skb->data);
1548 skb_reset_network_header(skb);
1549 skb->dev = reg_dev;
1550 skb->protocol = htons(ETH_P_IP);
1551 skb->ip_summed = 0;
1552 skb->pkt_type = PACKET_HOST;
1553 skb_dst_drop(skb);
1554 reg_dev->stats.rx_bytes += skb->len;
1555 reg_dev->stats.rx_packets++;
1556 nf_reset(skb);
1557 netif_rx(skb);
1558 dev_put(reg_dev);
1559
1560 return 0;
1561 }
1562 #endif
1563
1564 #ifdef CONFIG_IP_PIMSM_V1
1565 /*
1566 * Handle IGMP messages of PIMv1
1567 */
1568
1569 int pim_rcv_v1(struct sk_buff * skb)
1570 {
1571 struct igmphdr *pim;
1572 struct net *net = dev_net(skb->dev);
1573
1574 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1575 goto drop;
1576
1577 pim = igmp_hdr(skb);
1578
1579 if (!net->ipv4.mroute_do_pim ||
1580 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1581 goto drop;
1582
1583 if (__pim_rcv(skb, sizeof(*pim))) {
1584 drop:
1585 kfree_skb(skb);
1586 }
1587 return 0;
1588 }
1589 #endif
1590
1591 #ifdef CONFIG_IP_PIMSM_V2
1592 static int pim_rcv(struct sk_buff * skb)
1593 {
1594 struct pimreghdr *pim;
1595
1596 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1597 goto drop;
1598
1599 pim = (struct pimreghdr *)skb_transport_header(skb);
1600 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1601 (pim->flags&PIM_NULL_REGISTER) ||
1602 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1603 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1604 goto drop;
1605
1606 if (__pim_rcv(skb, sizeof(*pim))) {
1607 drop:
1608 kfree_skb(skb);
1609 }
1610 return 0;
1611 }
1612 #endif
1613
1614 static int
1615 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1616 {
1617 int ct;
1618 struct rtnexthop *nhp;
1619 struct net *net = mfc_net(c);
1620 u8 *b = skb_tail_pointer(skb);
1621 struct rtattr *mp_head;
1622
1623 /* If cache is unresolved, don't try to parse IIF and OIF */
1624 if (c->mfc_parent > MAXVIFS)
1625 return -ENOENT;
1626
1627 if (VIF_EXISTS(net, c->mfc_parent))
1628 RTA_PUT(skb, RTA_IIF, 4, &net->ipv4.vif_table[c->mfc_parent].dev->ifindex);
1629
1630 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1631
1632 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1633 if (VIF_EXISTS(net, ct) && c->mfc_un.res.ttls[ct] < 255) {
1634 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1635 goto rtattr_failure;
1636 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1637 nhp->rtnh_flags = 0;
1638 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1639 nhp->rtnh_ifindex = net->ipv4.vif_table[ct].dev->ifindex;
1640 nhp->rtnh_len = sizeof(*nhp);
1641 }
1642 }
1643 mp_head->rta_type = RTA_MULTIPATH;
1644 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1645 rtm->rtm_type = RTN_MULTICAST;
1646 return 1;
1647
1648 rtattr_failure:
1649 nlmsg_trim(skb, b);
1650 return -EMSGSIZE;
1651 }
1652
1653 int ipmr_get_route(struct net *net,
1654 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1655 {
1656 int err;
1657 struct mfc_cache *cache;
1658 struct rtable *rt = skb_rtable(skb);
1659
1660 read_lock(&mrt_lock);
1661 cache = ipmr_cache_find(net, rt->rt_src, rt->rt_dst);
1662
1663 if (cache == NULL) {
1664 struct sk_buff *skb2;
1665 struct iphdr *iph;
1666 struct net_device *dev;
1667 int vif;
1668
1669 if (nowait) {
1670 read_unlock(&mrt_lock);
1671 return -EAGAIN;
1672 }
1673
1674 dev = skb->dev;
1675 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1676 read_unlock(&mrt_lock);
1677 return -ENODEV;
1678 }
1679 skb2 = skb_clone(skb, GFP_ATOMIC);
1680 if (!skb2) {
1681 read_unlock(&mrt_lock);
1682 return -ENOMEM;
1683 }
1684
1685 skb_push(skb2, sizeof(struct iphdr));
1686 skb_reset_network_header(skb2);
1687 iph = ip_hdr(skb2);
1688 iph->ihl = sizeof(struct iphdr) >> 2;
1689 iph->saddr = rt->rt_src;
1690 iph->daddr = rt->rt_dst;
1691 iph->version = 0;
1692 err = ipmr_cache_unresolved(net, vif, skb2);
1693 read_unlock(&mrt_lock);
1694 return err;
1695 }
1696
1697 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1698 cache->mfc_flags |= MFC_NOTIFY;
1699 err = ipmr_fill_mroute(skb, cache, rtm);
1700 read_unlock(&mrt_lock);
1701 return err;
1702 }
1703
1704 #ifdef CONFIG_PROC_FS
1705 /*
1706 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1707 */
1708 struct ipmr_vif_iter {
1709 struct seq_net_private p;
1710 int ct;
1711 };
1712
1713 static struct vif_device *ipmr_vif_seq_idx(struct net *net,
1714 struct ipmr_vif_iter *iter,
1715 loff_t pos)
1716 {
1717 for (iter->ct = 0; iter->ct < net->ipv4.maxvif; ++iter->ct) {
1718 if (!VIF_EXISTS(net, iter->ct))
1719 continue;
1720 if (pos-- == 0)
1721 return &net->ipv4.vif_table[iter->ct];
1722 }
1723 return NULL;
1724 }
1725
1726 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1727 __acquires(mrt_lock)
1728 {
1729 struct net *net = seq_file_net(seq);
1730
1731 read_lock(&mrt_lock);
1732 return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
1733 : SEQ_START_TOKEN;
1734 }
1735
1736 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1737 {
1738 struct ipmr_vif_iter *iter = seq->private;
1739 struct net *net = seq_file_net(seq);
1740
1741 ++*pos;
1742 if (v == SEQ_START_TOKEN)
1743 return ipmr_vif_seq_idx(net, iter, 0);
1744
1745 while (++iter->ct < net->ipv4.maxvif) {
1746 if (!VIF_EXISTS(net, iter->ct))
1747 continue;
1748 return &net->ipv4.vif_table[iter->ct];
1749 }
1750 return NULL;
1751 }
1752
1753 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1754 __releases(mrt_lock)
1755 {
1756 read_unlock(&mrt_lock);
1757 }
1758
1759 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1760 {
1761 struct net *net = seq_file_net(seq);
1762
1763 if (v == SEQ_START_TOKEN) {
1764 seq_puts(seq,
1765 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1766 } else {
1767 const struct vif_device *vif = v;
1768 const char *name = vif->dev ? vif->dev->name : "none";
1769
1770 seq_printf(seq,
1771 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1772 vif - net->ipv4.vif_table,
1773 name, vif->bytes_in, vif->pkt_in,
1774 vif->bytes_out, vif->pkt_out,
1775 vif->flags, vif->local, vif->remote);
1776 }
1777 return 0;
1778 }
1779
1780 static const struct seq_operations ipmr_vif_seq_ops = {
1781 .start = ipmr_vif_seq_start,
1782 .next = ipmr_vif_seq_next,
1783 .stop = ipmr_vif_seq_stop,
1784 .show = ipmr_vif_seq_show,
1785 };
1786
1787 static int ipmr_vif_open(struct inode *inode, struct file *file)
1788 {
1789 return seq_open_net(inode, file, &ipmr_vif_seq_ops,
1790 sizeof(struct ipmr_vif_iter));
1791 }
1792
1793 static const struct file_operations ipmr_vif_fops = {
1794 .owner = THIS_MODULE,
1795 .open = ipmr_vif_open,
1796 .read = seq_read,
1797 .llseek = seq_lseek,
1798 .release = seq_release_net,
1799 };
1800
1801 struct ipmr_mfc_iter {
1802 struct seq_net_private p;
1803 struct mfc_cache **cache;
1804 int ct;
1805 };
1806
1807
1808 static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
1809 struct ipmr_mfc_iter *it, loff_t pos)
1810 {
1811 struct mfc_cache *mfc;
1812
1813 it->cache = net->ipv4.mfc_cache_array;
1814 read_lock(&mrt_lock);
1815 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1816 for (mfc = net->ipv4.mfc_cache_array[it->ct];
1817 mfc; mfc = mfc->next)
1818 if (pos-- == 0)
1819 return mfc;
1820 read_unlock(&mrt_lock);
1821
1822 it->cache = &mfc_unres_queue;
1823 spin_lock_bh(&mfc_unres_lock);
1824 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1825 if (net_eq(mfc_net(mfc), net) &&
1826 pos-- == 0)
1827 return mfc;
1828 spin_unlock_bh(&mfc_unres_lock);
1829
1830 it->cache = NULL;
1831 return NULL;
1832 }
1833
1834
1835 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1836 {
1837 struct ipmr_mfc_iter *it = seq->private;
1838 struct net *net = seq_file_net(seq);
1839
1840 it->cache = NULL;
1841 it->ct = 0;
1842 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
1843 : SEQ_START_TOKEN;
1844 }
1845
1846 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1847 {
1848 struct mfc_cache *mfc = v;
1849 struct ipmr_mfc_iter *it = seq->private;
1850 struct net *net = seq_file_net(seq);
1851
1852 ++*pos;
1853
1854 if (v == SEQ_START_TOKEN)
1855 return ipmr_mfc_seq_idx(net, seq->private, 0);
1856
1857 if (mfc->next)
1858 return mfc->next;
1859
1860 if (it->cache == &mfc_unres_queue)
1861 goto end_of_list;
1862
1863 BUG_ON(it->cache != net->ipv4.mfc_cache_array);
1864
1865 while (++it->ct < MFC_LINES) {
1866 mfc = net->ipv4.mfc_cache_array[it->ct];
1867 if (mfc)
1868 return mfc;
1869 }
1870
1871 /* exhausted cache_array, show unresolved */
1872 read_unlock(&mrt_lock);
1873 it->cache = &mfc_unres_queue;
1874 it->ct = 0;
1875
1876 spin_lock_bh(&mfc_unres_lock);
1877 mfc = mfc_unres_queue;
1878 while (mfc && !net_eq(mfc_net(mfc), net))
1879 mfc = mfc->next;
1880 if (mfc)
1881 return mfc;
1882
1883 end_of_list:
1884 spin_unlock_bh(&mfc_unres_lock);
1885 it->cache = NULL;
1886
1887 return NULL;
1888 }
1889
1890 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1891 {
1892 struct ipmr_mfc_iter *it = seq->private;
1893 struct net *net = seq_file_net(seq);
1894
1895 if (it->cache == &mfc_unres_queue)
1896 spin_unlock_bh(&mfc_unres_lock);
1897 else if (it->cache == net->ipv4.mfc_cache_array)
1898 read_unlock(&mrt_lock);
1899 }
1900
1901 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1902 {
1903 int n;
1904 struct net *net = seq_file_net(seq);
1905
1906 if (v == SEQ_START_TOKEN) {
1907 seq_puts(seq,
1908 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1909 } else {
1910 const struct mfc_cache *mfc = v;
1911 const struct ipmr_mfc_iter *it = seq->private;
1912
1913 seq_printf(seq, "%08lX %08lX %-3hd",
1914 (unsigned long) mfc->mfc_mcastgrp,
1915 (unsigned long) mfc->mfc_origin,
1916 mfc->mfc_parent);
1917
1918 if (it->cache != &mfc_unres_queue) {
1919 seq_printf(seq, " %8lu %8lu %8lu",
1920 mfc->mfc_un.res.pkt,
1921 mfc->mfc_un.res.bytes,
1922 mfc->mfc_un.res.wrong_if);
1923 for (n = mfc->mfc_un.res.minvif;
1924 n < mfc->mfc_un.res.maxvif; n++ ) {
1925 if (VIF_EXISTS(net, n) &&
1926 mfc->mfc_un.res.ttls[n] < 255)
1927 seq_printf(seq,
1928 " %2d:%-3d",
1929 n, mfc->mfc_un.res.ttls[n]);
1930 }
1931 } else {
1932 /* unresolved mfc_caches don't contain
1933 * pkt, bytes and wrong_if values
1934 */
1935 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
1936 }
1937 seq_putc(seq, '\n');
1938 }
1939 return 0;
1940 }
1941
1942 static const struct seq_operations ipmr_mfc_seq_ops = {
1943 .start = ipmr_mfc_seq_start,
1944 .next = ipmr_mfc_seq_next,
1945 .stop = ipmr_mfc_seq_stop,
1946 .show = ipmr_mfc_seq_show,
1947 };
1948
1949 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1950 {
1951 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
1952 sizeof(struct ipmr_mfc_iter));
1953 }
1954
1955 static const struct file_operations ipmr_mfc_fops = {
1956 .owner = THIS_MODULE,
1957 .open = ipmr_mfc_open,
1958 .read = seq_read,
1959 .llseek = seq_lseek,
1960 .release = seq_release_net,
1961 };
1962 #endif
1963
1964 #ifdef CONFIG_IP_PIMSM_V2
1965 static const struct net_protocol pim_protocol = {
1966 .handler = pim_rcv,
1967 .netns_ok = 1,
1968 };
1969 #endif
1970
1971
1972 /*
1973 * Setup for IP multicast routing
1974 */
1975 static int __net_init ipmr_net_init(struct net *net)
1976 {
1977 int err = 0;
1978
1979 net->ipv4.vif_table = kcalloc(MAXVIFS, sizeof(struct vif_device),
1980 GFP_KERNEL);
1981 if (!net->ipv4.vif_table) {
1982 err = -ENOMEM;
1983 goto fail;
1984 }
1985
1986 /* Forwarding cache */
1987 net->ipv4.mfc_cache_array = kcalloc(MFC_LINES,
1988 sizeof(struct mfc_cache *),
1989 GFP_KERNEL);
1990 if (!net->ipv4.mfc_cache_array) {
1991 err = -ENOMEM;
1992 goto fail_mfc_cache;
1993 }
1994
1995 #ifdef CONFIG_IP_PIMSM
1996 net->ipv4.mroute_reg_vif_num = -1;
1997 #endif
1998
1999 #ifdef CONFIG_PROC_FS
2000 err = -ENOMEM;
2001 if (!proc_net_fops_create(net, "ip_mr_vif", 0, &ipmr_vif_fops))
2002 goto proc_vif_fail;
2003 if (!proc_net_fops_create(net, "ip_mr_cache", 0, &ipmr_mfc_fops))
2004 goto proc_cache_fail;
2005 #endif
2006 return 0;
2007
2008 #ifdef CONFIG_PROC_FS
2009 proc_cache_fail:
2010 proc_net_remove(net, "ip_mr_vif");
2011 proc_vif_fail:
2012 kfree(net->ipv4.mfc_cache_array);
2013 #endif
2014 fail_mfc_cache:
2015 kfree(net->ipv4.vif_table);
2016 fail:
2017 return err;
2018 }
2019
2020 static void __net_exit ipmr_net_exit(struct net *net)
2021 {
2022 #ifdef CONFIG_PROC_FS
2023 proc_net_remove(net, "ip_mr_cache");
2024 proc_net_remove(net, "ip_mr_vif");
2025 #endif
2026 kfree(net->ipv4.mfc_cache_array);
2027 kfree(net->ipv4.vif_table);
2028 }
2029
2030 static struct pernet_operations ipmr_net_ops = {
2031 .init = ipmr_net_init,
2032 .exit = ipmr_net_exit,
2033 };
2034
2035 int __init ip_mr_init(void)
2036 {
2037 int err;
2038
2039 mrt_cachep = kmem_cache_create("ip_mrt_cache",
2040 sizeof(struct mfc_cache),
2041 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
2042 NULL);
2043 if (!mrt_cachep)
2044 return -ENOMEM;
2045
2046 err = register_pernet_subsys(&ipmr_net_ops);
2047 if (err)
2048 goto reg_pernet_fail;
2049
2050 setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
2051 err = register_netdevice_notifier(&ip_mr_notifier);
2052 if (err)
2053 goto reg_notif_fail;
2054 #ifdef CONFIG_IP_PIMSM_V2
2055 if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
2056 printk(KERN_ERR "ip_mr_init: can't add PIM protocol\n");
2057 err = -EAGAIN;
2058 goto add_proto_fail;
2059 }
2060 #endif
2061 return 0;
2062
2063 #ifdef CONFIG_IP_PIMSM_V2
2064 add_proto_fail:
2065 unregister_netdevice_notifier(&ip_mr_notifier);
2066 #endif
2067 reg_notif_fail:
2068 del_timer(&ipmr_expire_timer);
2069 unregister_pernet_subsys(&ipmr_net_ops);
2070 reg_pernet_fail:
2071 kmem_cache_destroy(mrt_cachep);
2072 return err;
2073 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree