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 requirement 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 = ®_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 } 2074