net/ipv6/ip6mr.c

   1 /*
   2  *      Linux IPv6 multicast routing support for BSD pim6sd
   3  *      Based on net/ipv4/ipmr.c.
   4  *
   5  *      (c) 2004 Mickael Hoerdt, <hoerdt@clarinet.u-strasbg.fr>
   6  *              LSIIT Laboratory, Strasbourg, France
   7  *      (c) 2004 Jean-Philippe Andriot, <jean-philippe.andriot@6WIND.com>
   8  *              6WIND, Paris, France
   9  *      Copyright (C)2007,2008 USAGI/WIDE Project
  10  *              YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
  11  *
  12  *      This program is free software; you can redistribute it and/or
  13  *      modify it under the terms of the GNU General Public License
  14  *      as published by the Free Software Foundation; either version
  15  *      2 of the License, or (at your option) any later version.
  16  *
  17  */
  18
  19 #include <linux/uaccess.h>
  20 #include <linux/types.h>
  21 #include <linux/sched.h>
  22 #include <linux/errno.h>
  23 #include <linux/mm.h>
  24 #include <linux/kernel.h>
  25 #include <linux/fcntl.h>
  26 #include <linux/stat.h>
  27 #include <linux/socket.h>
  28 #include <linux/inet.h>
  29 #include <linux/netdevice.h>
  30 #include <linux/inetdevice.h>
  31 #include <linux/proc_fs.h>
  32 #include <linux/seq_file.h>
  33 #include <linux/init.h>
  34 #include <linux/compat.h>
  35 #include <linux/rhashtable.h>
  36 #include <net/protocol.h>
  37 #include <linux/skbuff.h>
  38 #include <net/raw.h>
  39 #include <linux/notifier.h>
  40 #include <linux/if_arp.h>
  41 #include <net/checksum.h>
  42 #include <net/netlink.h>
  43 #include <net/fib_rules.h>
  44
  45 #include <net/ipv6.h>
  46 #include <net/ip6_route.h>
  47 #include <linux/mroute6.h>
  48 #include <linux/pim.h>
  49 #include <net/addrconf.h>
  50 #include <linux/netfilter_ipv6.h>
  51 #include <linux/export.h>
  52 #include <net/ip6_checksum.h>
  53 #include <linux/netconf.h>
  54 #include <net/ip_tunnels.h>
  55
  56 #include <linux/nospec.h>
  57
  58 struct ip6mr_rule {
  59         struct fib_rule         common;
  60 };
  61
  62 struct ip6mr_result {
  63         struct mr_table *mrt;
  64 };
  65
  66 /* Big lock, protecting vif table, mrt cache and mroute socket state.
  67    Note that the changes are semaphored via rtnl_lock.
  68  */
  69
  70 static DEFINE_RWLOCK(mrt_lock);
  71
  72 /* Multicast router control variables */
  73
  74 /* Special spinlock for queue of unresolved entries */
  75 static DEFINE_SPINLOCK(mfc_unres_lock);
  76
  77 /* We return to original Alan's scheme. Hash table of resolved
  78    entries is changed only in process context and protected
  79    with weak lock mrt_lock. Queue of unresolved entries is protected
  80    with strong spinlock mfc_unres_lock.
  81
  82    In this case data path is free of exclusive locks at all.
  83  */
  84
  85 static struct kmem_cache *mrt_cachep __read_mostly;
  86
  87 static struct mr_table *ip6mr_new_table(struct net *net, u32 id);
  88 static void ip6mr_free_table(struct mr_table *mrt);
  89
  90 static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
  91                            struct net_device *dev, struct sk_buff *skb,
  92                            struct mfc6_cache *cache);
  93 static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt,
  94                               mifi_t mifi, int assert);
  95 static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
  96                               int cmd);
  97 static void mrt6msg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt);
  98 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
  99                                struct netlink_callback *cb);
 100 static void mroute_clean_tables(struct mr_table *mrt, bool all);
 101 static void ipmr_expire_process(struct timer_list *t);
 102
 103 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
 104 #define ip6mr_for_each_table(mrt, net) \
 105         list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
 106
 107 static struct mr_table *ip6mr_mr_table_iter(struct net *net,
 108                                             struct mr_table *mrt)
 109 {
 110         struct mr_table *ret;
 111
 112         if (!mrt)
 113                 ret = list_entry_rcu(net->ipv6.mr6_tables.next,
 114                                      struct mr_table, list);
 115         else
 116                 ret = list_entry_rcu(mrt->list.next,
 117                                      struct mr_table, list);
 118
 119         if (&ret->list == &net->ipv6.mr6_tables)
 120                 return NULL;
 121         return ret;
 122 }
 123
 124 static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
 125 {
 126         struct mr_table *mrt;
 127
 128         ip6mr_for_each_table(mrt, net) {
 129                 if (mrt->id == id)
 130                         return mrt;
 131         }
 132         return NULL;
 133 }
 134
 135 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
 136                             struct mr_table **mrt)
 137 {
 138         int err;
 139         struct ip6mr_result res;
 140         struct fib_lookup_arg arg = {
 141                 .result = &res,
 142                 .flags = FIB_LOOKUP_NOREF,
 143         };
 144
 145         /* update flow if oif or iif point to device enslaved to l3mdev */
 146         l3mdev_update_flow(net, flowi6_to_flowi(flp6));
 147
 148         err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
 149                                flowi6_to_flowi(flp6), 0, &arg);
 150         if (err < 0)
 151                 return err;
 152         *mrt = res.mrt;
 153         return 0;
 154 }
 155
 156 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
 157                              int flags, struct fib_lookup_arg *arg)
 158 {
 159         struct ip6mr_result *res = arg->result;
 160         struct mr_table *mrt;
 161
 162         switch (rule->action) {
 163         case FR_ACT_TO_TBL:
 164                 break;
 165         case FR_ACT_UNREACHABLE:
 166                 return -ENETUNREACH;
 167         case FR_ACT_PROHIBIT:
 168                 return -EACCES;
 169         case FR_ACT_BLACKHOLE:
 170         default:
 171                 return -EINVAL;
 172         }
 173
 174         arg->table = fib_rule_get_table(rule, arg);
 175
 176         mrt = ip6mr_get_table(rule->fr_net, arg->table);
 177         if (!mrt)
 178                 return -EAGAIN;
 179         res->mrt = mrt;
 180         return 0;
 181 }
 182
 183 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
 184 {
 185         return 1;
 186 }
 187
 188 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
 189         FRA_GENERIC_POLICY,
 190 };
 191
 192 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
 193                                 struct fib_rule_hdr *frh, struct nlattr **tb,
 194                                 struct netlink_ext_ack *extack)
 195 {
 196         return 0;
 197 }
 198
 199 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
 200                               struct nlattr **tb)
 201 {
 202         return 1;
 203 }
 204
 205 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
 206                            struct fib_rule_hdr *frh)
 207 {
 208         frh->dst_len = 0;
 209         frh->src_len = 0;
 210         frh->tos     = 0;
 211         return 0;
 212 }
 213
 214 static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
 215         .family         = RTNL_FAMILY_IP6MR,
 216         .rule_size      = sizeof(struct ip6mr_rule),
 217         .addr_size      = sizeof(struct in6_addr),
 218         .action         = ip6mr_rule_action,
 219         .match          = ip6mr_rule_match,
 220         .configure      = ip6mr_rule_configure,
 221         .compare        = ip6mr_rule_compare,
 222         .fill           = ip6mr_rule_fill,
 223         .nlgroup        = RTNLGRP_IPV6_RULE,
 224         .policy         = ip6mr_rule_policy,
 225         .owner          = THIS_MODULE,
 226 };
 227
 228 static int __net_init ip6mr_rules_init(struct net *net)
 229 {
 230         struct fib_rules_ops *ops;
 231         struct mr_table *mrt;
 232         int err;
 233
 234         ops = fib_rules_register(&ip6mr_rules_ops_template, net);
 235         if (IS_ERR(ops))
 236                 return PTR_ERR(ops);
 237
 238         INIT_LIST_HEAD(&net->ipv6.mr6_tables);
 239
 240         mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
 241         if (IS_ERR(mrt)) {
 242                 err = PTR_ERR(mrt);
 243                 goto err1;
 244         }
 245
 246         err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
 247         if (err < 0)
 248                 goto err2;
 249
 250         net->ipv6.mr6_rules_ops = ops;
 251         return 0;
 252
 253 err2:
 254         ip6mr_free_table(mrt);
 255 err1:
 256         fib_rules_unregister(ops);
 257         return err;
 258 }
 259
 260 static void __net_exit ip6mr_rules_exit(struct net *net)
 261 {
 262         struct mr_table *mrt, *next;
 263
 264         rtnl_lock();
 265         list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
 266                 list_del(&mrt->list);
 267                 ip6mr_free_table(mrt);
 268         }
 269         fib_rules_unregister(net->ipv6.mr6_rules_ops);
 270         rtnl_unlock();
 271 }
 272
 273 static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb)
 274 {
 275         return fib_rules_dump(net, nb, RTNL_FAMILY_IP6MR);
 276 }
 277
 278 static unsigned int ip6mr_rules_seq_read(struct net *net)
 279 {
 280         return fib_rules_seq_read(net, RTNL_FAMILY_IP6MR);
 281 }
 282
 283 bool ip6mr_rule_default(const struct fib_rule *rule)
 284 {
 285         return fib_rule_matchall(rule) && rule->action == FR_ACT_TO_TBL &&
 286                rule->table == RT6_TABLE_DFLT && !rule->l3mdev;
 287 }
 288 EXPORT_SYMBOL(ip6mr_rule_default);
 289 #else
 290 #define ip6mr_for_each_table(mrt, net) \
 291         for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
 292
 293 static struct mr_table *ip6mr_mr_table_iter(struct net *net,
 294                                             struct mr_table *mrt)
 295 {
 296         if (!mrt)
 297                 return net->ipv6.mrt6;
 298         return NULL;
 299 }
 300
 301 static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
 302 {
 303         return net->ipv6.mrt6;
 304 }
 305
 306 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
 307                             struct mr_table **mrt)
 308 {
 309         *mrt = net->ipv6.mrt6;
 310         return 0;
 311 }
 312
 313 static int __net_init ip6mr_rules_init(struct net *net)
 314 {
 315         struct mr_table *mrt;
 316
 317         mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
 318         if (IS_ERR(mrt))
 319                 return PTR_ERR(mrt);
 320         net->ipv6.mrt6 = mrt;
 321         return 0;
 322 }
 323
 324 static void __net_exit ip6mr_rules_exit(struct net *net)
 325 {
 326         rtnl_lock();
 327         ip6mr_free_table(net->ipv6.mrt6);
 328         net->ipv6.mrt6 = NULL;
 329         rtnl_unlock();
 330 }
 331
 332 static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb)
 333 {
 334         return 0;
 335 }
 336
 337 static unsigned int ip6mr_rules_seq_read(struct net *net)
 338 {
 339         return 0;
 340 }
 341 #endif
 342
 343 static int ip6mr_hash_cmp(struct rhashtable_compare_arg *arg,
 344                           const void *ptr)
 345 {
 346         const struct mfc6_cache_cmp_arg *cmparg = arg->key;
 347         struct mfc6_cache *c = (struct mfc6_cache *)ptr;
 348
 349         return !ipv6_addr_equal(&c->mf6c_mcastgrp, &cmparg->mf6c_mcastgrp) ||
 350                !ipv6_addr_equal(&c->mf6c_origin, &cmparg->mf6c_origin);
 351 }
 352
 353 static const struct rhashtable_params ip6mr_rht_params = {
 354         .head_offset = offsetof(struct mr_mfc, mnode),
 355         .key_offset = offsetof(struct mfc6_cache, cmparg),
 356         .key_len = sizeof(struct mfc6_cache_cmp_arg),
 357         .nelem_hint = 3,
 358         .locks_mul = 1,
 359         .obj_cmpfn = ip6mr_hash_cmp,
 360         .automatic_shrinking = true,
 361 };
 362
 363 static void ip6mr_new_table_set(struct mr_table *mrt,
 364                                 struct net *net)
 365 {
 366 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
 367         list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
 368 #endif
 369 }
 370
 371 static struct mfc6_cache_cmp_arg ip6mr_mr_table_ops_cmparg_any = {
 372         .mf6c_origin = IN6ADDR_ANY_INIT,
 373         .mf6c_mcastgrp = IN6ADDR_ANY_INIT,
 374 };
 375
 376 static struct mr_table_ops ip6mr_mr_table_ops = {
 377         .rht_params = &ip6mr_rht_params,
 378         .cmparg_any = &ip6mr_mr_table_ops_cmparg_any,
 379 };
 380
 381 static struct mr_table *ip6mr_new_table(struct net *net, u32 id)
 382 {
 383         struct mr_table *mrt;
 384
 385         mrt = ip6mr_get_table(net, id);
 386         if (mrt)
 387                 return mrt;
 388
 389         return mr_table_alloc(net, id, &ip6mr_mr_table_ops,
 390                               ipmr_expire_process, ip6mr_new_table_set);
 391 }
 392
 393 static void ip6mr_free_table(struct mr_table *mrt)
 394 {
 395         del_timer_sync(&mrt->ipmr_expire_timer);
 396         mroute_clean_tables(mrt, true);
 397         rhltable_destroy(&mrt->mfc_hash);
 398         kfree(mrt);
 399 }
 400
 401 #ifdef CONFIG_PROC_FS
 402 /* The /proc interfaces to multicast routing
 403  * /proc/ip6_mr_cache /proc/ip6_mr_vif
 404  */
 405
 406 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
 407         __acquires(mrt_lock)
 408 {
 409         struct mr_vif_iter *iter = seq->private;
 410         struct net *net = seq_file_net(seq);
 411         struct mr_table *mrt;
 412
 413         mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
 414         if (!mrt)
 415                 return ERR_PTR(-ENOENT);
 416
 417         iter->mrt = mrt;
 418
 419         read_lock(&mrt_lock);
 420         return mr_vif_seq_start(seq, pos);
 421 }
 422
 423 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
 424         __releases(mrt_lock)
 425 {
 426         read_unlock(&mrt_lock);
 427 }
 428
 429 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
 430 {
 431         struct mr_vif_iter *iter = seq->private;
 432         struct mr_table *mrt = iter->mrt;
 433
 434         if (v == SEQ_START_TOKEN) {
 435                 seq_puts(seq,
 436                          "Interface      BytesIn  PktsIn  BytesOut PktsOut Flags\n");
 437         } else {
 438                 const struct vif_device *vif = v;
 439                 const char *name = vif->dev ? vif->dev->name : "none";
 440
 441                 seq_printf(seq,
 442                            "%2td %-10s %8ld %7ld  %8ld %7ld %05X\n",
 443                            vif - mrt->vif_table,
 444                            name, vif->bytes_in, vif->pkt_in,
 445                            vif->bytes_out, vif->pkt_out,
 446                            vif->flags);
 447         }
 448         return 0;
 449 }
 450
 451 static const struct seq_operations ip6mr_vif_seq_ops = {
 452         .start = ip6mr_vif_seq_start,
 453         .next  = mr_vif_seq_next,
 454         .stop  = ip6mr_vif_seq_stop,
 455         .show  = ip6mr_vif_seq_show,
 456 };
 457
 458 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
 459 {
 460         struct net *net = seq_file_net(seq);
 461         struct mr_table *mrt;
 462
 463         mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
 464         if (!mrt)
 465                 return ERR_PTR(-ENOENT);
 466
 467         return mr_mfc_seq_start(seq, pos, mrt, &mfc_unres_lock);
 468 }
 469
 470 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
 471 {
 472         int n;
 473
 474         if (v == SEQ_START_TOKEN) {
 475                 seq_puts(seq,
 476                          "Group                            "
 477                          "Origin                           "
 478                          "Iif      Pkts  Bytes     Wrong  Oifs\n");
 479         } else {
 480                 const struct mfc6_cache *mfc = v;
 481                 const struct mr_mfc_iter *it = seq->private;
 482                 struct mr_table *mrt = it->mrt;
 483
 484                 seq_printf(seq, "%pI6 %pI6 %-3hd",
 485                            &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
 486                            mfc->_c.mfc_parent);
 487
 488                 if (it->cache != &mrt->mfc_unres_queue) {
 489                         seq_printf(seq, " %8lu %8lu %8lu",
 490                                    mfc->_c.mfc_un.res.pkt,
 491                                    mfc->_c.mfc_un.res.bytes,
 492                                    mfc->_c.mfc_un.res.wrong_if);
 493                         for (n = mfc->_c.mfc_un.res.minvif;
 494                              n < mfc->_c.mfc_un.res.maxvif; n++) {
 495                                 if (VIF_EXISTS(mrt, n) &&
 496                                     mfc->_c.mfc_un.res.ttls[n] < 255)
 497                                         seq_printf(seq,
 498                                                    " %2d:%-3d", n,
 499                                                    mfc->_c.mfc_un.res.ttls[n]);
 500                         }
 501                 } else {
 502                         /* unresolved mfc_caches don't contain
 503                          * pkt, bytes and wrong_if values
 504                          */
 505                         seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
 506                 }
 507                 seq_putc(seq, '\n');
 508         }
 509         return 0;
 510 }
 511
 512 static const struct seq_operations ipmr_mfc_seq_ops = {
 513         .start = ipmr_mfc_seq_start,
 514         .next  = mr_mfc_seq_next,
 515         .stop  = mr_mfc_seq_stop,
 516         .show  = ipmr_mfc_seq_show,
 517 };
 518 #endif
 519
 520 #ifdef CONFIG_IPV6_PIMSM_V2
 521
 522 static int pim6_rcv(struct sk_buff *skb)
 523 {
 524         struct pimreghdr *pim;
 525         struct ipv6hdr   *encap;
 526         struct net_device  *reg_dev = NULL;
 527         struct net *net = dev_net(skb->dev);
 528         struct mr_table *mrt;
 529         struct flowi6 fl6 = {
 530                 .flowi6_iif     = skb->dev->ifindex,
 531                 .flowi6_mark    = skb->mark,
 532         };
 533         int reg_vif_num;
 534
 535         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
 536                 goto drop;
 537
 538         pim = (struct pimreghdr *)skb_transport_header(skb);
 539         if (pim->type != ((PIM_VERSION << 4) | PIM_TYPE_REGISTER) ||
 540             (pim->flags & PIM_NULL_REGISTER) ||
 541             (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
 542                              sizeof(*pim), IPPROTO_PIM,
 543                              csum_partial((void *)pim, sizeof(*pim), 0)) &&
 544              csum_fold(skb_checksum(skb, 0, skb->len, 0))))
 545                 goto drop;
 546
 547         /* check if the inner packet is destined to mcast group */
 548         encap = (struct ipv6hdr *)(skb_transport_header(skb) +
 549                                    sizeof(*pim));
 550
 551         if (!ipv6_addr_is_multicast(&encap->daddr) ||
 552             encap->payload_len == 0 ||
 553             ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
 554                 goto drop;
 555
 556         if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
 557                 goto drop;
 558         reg_vif_num = mrt->mroute_reg_vif_num;
 559
 560         read_lock(&mrt_lock);
 561         if (reg_vif_num >= 0)
 562                 reg_dev = mrt->vif_table[reg_vif_num].dev;
 563         if (reg_dev)
 564                 dev_hold(reg_dev);
 565         read_unlock(&mrt_lock);
 566
 567         if (!reg_dev)
 568                 goto drop;
 569
 570         skb->mac_header = skb->network_header;
 571         skb_pull(skb, (u8 *)encap - skb->data);
 572         skb_reset_network_header(skb);
 573         skb->protocol = htons(ETH_P_IPV6);
 574         skb->ip_summed = CHECKSUM_NONE;
 575
 576         skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
 577
 578         netif_rx(skb);
 579
 580         dev_put(reg_dev);
 581         return 0;
 582  drop:
 583         kfree_skb(skb);
 584         return 0;
 585 }
 586
 587 static const struct inet6_protocol pim6_protocol = {
 588         .handler        =       pim6_rcv,
 589 };
 590
 591 /* Service routines creating virtual interfaces: PIMREG */
 592
 593 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
 594                                       struct net_device *dev)
 595 {
 596         struct net *net = dev_net(dev);
 597         struct mr_table *mrt;
 598         struct flowi6 fl6 = {
 599                 .flowi6_oif     = dev->ifindex,
 600                 .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
 601                 .flowi6_mark    = skb->mark,
 602         };
 603
 604         if (!pskb_inet_may_pull(skb))
 605                 goto tx_err;
 606
 607         if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
 608                 goto tx_err;
 609
 610         read_lock(&mrt_lock);
 611         dev->stats.tx_bytes += skb->len;
 612         dev->stats.tx_packets++;
 613         ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
 614         read_unlock(&mrt_lock);
 615         kfree_skb(skb);
 616         return NETDEV_TX_OK;
 617
 618 tx_err:
 619         dev->stats.tx_errors++;
 620         kfree_skb(skb);
 621         return NETDEV_TX_OK;
 622 }
 623
 624 static int reg_vif_get_iflink(const struct net_device *dev)
 625 {
 626         return 0;
 627 }
 628
 629 static const struct net_device_ops reg_vif_netdev_ops = {
 630         .ndo_start_xmit = reg_vif_xmit,
 631         .ndo_get_iflink = reg_vif_get_iflink,
 632 };
 633
 634 static void reg_vif_setup(struct net_device *dev)
 635 {
 636         dev->type               = ARPHRD_PIMREG;
 637         dev->mtu                = 1500 - sizeof(struct ipv6hdr) - 8;
 638         dev->flags              = IFF_NOARP;
 639         dev->netdev_ops         = &reg_vif_netdev_ops;
 640         dev->needs_free_netdev  = true;
 641         dev->features           |= NETIF_F_NETNS_LOCAL;
 642 }
 643
 644 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr_table *mrt)
 645 {
 646         struct net_device *dev;
 647         char name[IFNAMSIZ];
 648
 649         if (mrt->id == RT6_TABLE_DFLT)
 650                 sprintf(name, "pim6reg");
 651         else
 652                 sprintf(name, "pim6reg%u", mrt->id);
 653
 654         dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
 655         if (!dev)
 656                 return NULL;
 657
 658         dev_net_set(dev, net);
 659
 660         if (register_netdevice(dev)) {
 661                 free_netdev(dev);
 662                 return NULL;
 663         }
 664
 665         if (dev_open(dev, NULL))
 666                 goto failure;
 667
 668         dev_hold(dev);
 669         return dev;
 670
 671 failure:
 672         unregister_netdevice(dev);
 673         return NULL;
 674 }
 675 #endif
 676
 677 static int call_ip6mr_vif_entry_notifiers(struct net *net,
 678                                           enum fib_event_type event_type,
 679                                           struct vif_device *vif,
 680                                           mifi_t vif_index, u32 tb_id)
 681 {
 682         return mr_call_vif_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
 683                                      vif, vif_index, tb_id,
 684                                      &net->ipv6.ipmr_seq);
 685 }
 686
 687 static int call_ip6mr_mfc_entry_notifiers(struct net *net,
 688                                           enum fib_event_type event_type,
 689                                           struct mfc6_cache *mfc, u32 tb_id)
 690 {
 691         return mr_call_mfc_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
 692                                      &mfc->_c, tb_id, &net->ipv6.ipmr_seq);
 693 }
 694
 695 /* Delete a VIF entry */
 696 static int mif6_delete(struct mr_table *mrt, int vifi, int notify,
 697                        struct list_head *head)
 698 {
 699         struct vif_device *v;
 700         struct net_device *dev;
 701         struct inet6_dev *in6_dev;
 702
 703         if (vifi < 0 || vifi >= mrt->maxvif)
 704                 return -EADDRNOTAVAIL;
 705
 706         v = &mrt->vif_table[vifi];
 707
 708         if (VIF_EXISTS(mrt, vifi))
 709                 call_ip6mr_vif_entry_notifiers(read_pnet(&mrt->net),
 710                                                FIB_EVENT_VIF_DEL, v, vifi,
 711                                                mrt->id);
 712
 713         write_lock_bh(&mrt_lock);
 714         dev = v->dev;
 715         v->dev = NULL;
 716
 717         if (!dev) {
 718                 write_unlock_bh(&mrt_lock);
 719                 return -EADDRNOTAVAIL;
 720         }
 721
 722 #ifdef CONFIG_IPV6_PIMSM_V2
 723         if (vifi == mrt->mroute_reg_vif_num)
 724                 mrt->mroute_reg_vif_num = -1;
 725 #endif
 726
 727         if (vifi + 1 == mrt->maxvif) {
 728                 int tmp;
 729                 for (tmp = vifi - 1; tmp >= 0; tmp--) {
 730                         if (VIF_EXISTS(mrt, tmp))
 731                                 break;
 732                 }
 733                 mrt->maxvif = tmp + 1;
 734         }
 735
 736         write_unlock_bh(&mrt_lock);
 737
 738         dev_set_allmulti(dev, -1);
 739
 740         in6_dev = __in6_dev_get(dev);
 741         if (in6_dev) {
 742                 in6_dev->cnf.mc_forwarding--;
 743                 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
 744                                              NETCONFA_MC_FORWARDING,
 745                                              dev->ifindex, &in6_dev->cnf);
 746         }
 747
 748         if ((v->flags & MIFF_REGISTER) && !notify)
 749                 unregister_netdevice_queue(dev, head);
 750
 751         dev_put(dev);
 752         return 0;
 753 }
 754
 755 static inline void ip6mr_cache_free_rcu(struct rcu_head *head)
 756 {
 757         struct mr_mfc *c = container_of(head, struct mr_mfc, rcu);
 758
 759         kmem_cache_free(mrt_cachep, (struct mfc6_cache *)c);
 760 }
 761
 762 static inline void ip6mr_cache_free(struct mfc6_cache *c)
 763 {
 764         call_rcu(&c->_c.rcu, ip6mr_cache_free_rcu);
 765 }
 766
 767 /* Destroy an unresolved cache entry, killing queued skbs
 768    and reporting error to netlink readers.
 769  */
 770
 771 static void ip6mr_destroy_unres(struct mr_table *mrt, struct mfc6_cache *c)
 772 {
 773         struct net *net = read_pnet(&mrt->net);
 774         struct sk_buff *skb;
 775
 776         atomic_dec(&mrt->cache_resolve_queue_len);
 777
 778         while ((skb = skb_dequeue(&c->_c.mfc_un.unres.unresolved)) != NULL) {
 779                 if (ipv6_hdr(skb)->version == 0) {
 780                         struct nlmsghdr *nlh = skb_pull(skb,
 781                                                         sizeof(struct ipv6hdr));
 782                         nlh->nlmsg_type = NLMSG_ERROR;
 783                         nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
 784                         skb_trim(skb, nlh->nlmsg_len);
 785                         ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
 786                         rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
 787                 } else
 788                         kfree_skb(skb);
 789         }
 790
 791         ip6mr_cache_free(c);
 792 }
 793
 794
 795 /* Timer process for all the unresolved queue. */
 796
 797 static void ipmr_do_expire_process(struct mr_table *mrt)
 798 {
 799         unsigned long now = jiffies;
 800         unsigned long expires = 10 * HZ;
 801         struct mr_mfc *c, *next;
 802
 803         list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
 804                 if (time_after(c->mfc_un.unres.expires, now)) {
 805                         /* not yet... */
 806                         unsigned long interval = c->mfc_un.unres.expires - now;
 807                         if (interval < expires)
 808                                 expires = interval;
 809                         continue;
 810                 }
 811
 812                 list_del(&c->list);
 813                 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
 814                 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
 815         }
 816
 817         if (!list_empty(&mrt->mfc_unres_queue))
 818                 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
 819 }
 820
 821 static void ipmr_expire_process(struct timer_list *t)
 822 {
 823         struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
 824
 825         if (!spin_trylock(&mfc_unres_lock)) {
 826                 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
 827                 return;
 828         }
 829
 830         if (!list_empty(&mrt->mfc_unres_queue))
 831                 ipmr_do_expire_process(mrt);
 832
 833         spin_unlock(&mfc_unres_lock);
 834 }
 835
 836 /* Fill oifs list. It is called under write locked mrt_lock. */
 837
 838 static void ip6mr_update_thresholds(struct mr_table *mrt,
 839                                     struct mr_mfc *cache,
 840                                     unsigned char *ttls)
 841 {
 842         int vifi;
 843
 844         cache->mfc_un.res.minvif = MAXMIFS;
 845         cache->mfc_un.res.maxvif = 0;
 846         memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
 847
 848         for (vifi = 0; vifi < mrt->maxvif; vifi++) {
 849                 if (VIF_EXISTS(mrt, vifi) &&
 850                     ttls[vifi] && ttls[vifi] < 255) {
 851                         cache->mfc_un.res.ttls[vifi] = ttls[vifi];
 852                         if (cache->mfc_un.res.minvif > vifi)
 853                                 cache->mfc_un.res.minvif = vifi;
 854                         if (cache->mfc_un.res.maxvif <= vifi)
 855                                 cache->mfc_un.res.maxvif = vifi + 1;
 856                 }
 857         }
 858         cache->mfc_un.res.lastuse = jiffies;
 859 }
 860
 861 static int mif6_add(struct net *net, struct mr_table *mrt,
 862                     struct mif6ctl *vifc, int mrtsock)
 863 {
 864         int vifi = vifc->mif6c_mifi;
 865         struct vif_device *v = &mrt->vif_table[vifi];
 866         struct net_device *dev;
 867         struct inet6_dev *in6_dev;
 868         int err;
 869
 870         /* Is vif busy ? */
 871         if (VIF_EXISTS(mrt, vifi))
 872                 return -EADDRINUSE;
 873
 874         switch (vifc->mif6c_flags) {
 875 #ifdef CONFIG_IPV6_PIMSM_V2
 876         case MIFF_REGISTER:
 877                 /*
 878                  * Special Purpose VIF in PIM
 879                  * All the packets will be sent to the daemon
 880                  */
 881                 if (mrt->mroute_reg_vif_num >= 0)
 882                         return -EADDRINUSE;
 883                 dev = ip6mr_reg_vif(net, mrt);
 884                 if (!dev)
 885                         return -ENOBUFS;
 886                 err = dev_set_allmulti(dev, 1);
 887                 if (err) {
 888                         unregister_netdevice(dev);
 889                         dev_put(dev);
 890                         return err;
 891                 }
 892                 break;
 893 #endif
 894         case 0:
 895                 dev = dev_get_by_index(net, vifc->mif6c_pifi);
 896                 if (!dev)
 897                         return -EADDRNOTAVAIL;
 898                 err = dev_set_allmulti(dev, 1);
 899                 if (err) {
 900                         dev_put(dev);
 901                         return err;
 902                 }
 903                 break;
 904         default:
 905                 return -EINVAL;
 906         }
 907
 908         in6_dev = __in6_dev_get(dev);
 909         if (in6_dev) {
 910                 in6_dev->cnf.mc_forwarding++;
 911                 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
 912                                              NETCONFA_MC_FORWARDING,
 913                                              dev->ifindex, &in6_dev->cnf);
 914         }
 915
 916         /* Fill in the VIF structures */
 917         vif_device_init(v, dev, vifc->vifc_rate_limit, vifc->vifc_threshold,
 918                         vifc->mif6c_flags | (!mrtsock ? VIFF_STATIC : 0),
 919                         MIFF_REGISTER);
 920
 921         /* And finish update writing critical data */
 922         write_lock_bh(&mrt_lock);
 923         v->dev = dev;
 924 #ifdef CONFIG_IPV6_PIMSM_V2
 925         if (v->flags & MIFF_REGISTER)
 926                 mrt->mroute_reg_vif_num = vifi;
 927 #endif
 928         if (vifi + 1 > mrt->maxvif)
 929                 mrt->maxvif = vifi + 1;
 930         write_unlock_bh(&mrt_lock);
 931         call_ip6mr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD,
 932                                        v, vifi, mrt->id);
 933         return 0;
 934 }
 935
 936 static struct mfc6_cache *ip6mr_cache_find(struct mr_table *mrt,
 937                                            const struct in6_addr *origin,
 938                                            const struct in6_addr *mcastgrp)
 939 {
 940         struct mfc6_cache_cmp_arg arg = {
 941                 .mf6c_origin = *origin,
 942                 .mf6c_mcastgrp = *mcastgrp,
 943         };
 944
 945         return mr_mfc_find(mrt, &arg);
 946 }
 947
 948 /* Look for a (*,G) entry */
 949 static struct mfc6_cache *ip6mr_cache_find_any(struct mr_table *mrt,
 950                                                struct in6_addr *mcastgrp,
 951                                                mifi_t mifi)
 952 {
 953         struct mfc6_cache_cmp_arg arg = {
 954                 .mf6c_origin = in6addr_any,
 955                 .mf6c_mcastgrp = *mcastgrp,
 956         };
 957
 958         if (ipv6_addr_any(mcastgrp))
 959                 return mr_mfc_find_any_parent(mrt, mifi);
 960         return mr_mfc_find_any(mrt, mifi, &arg);
 961 }
 962
 963 /* Look for a (S,G,iif) entry if parent != -1 */
 964 static struct mfc6_cache *
 965 ip6mr_cache_find_parent(struct mr_table *mrt,
 966                         const struct in6_addr *origin,
 967                         const struct in6_addr *mcastgrp,
 968                         int parent)
 969 {
 970         struct mfc6_cache_cmp_arg arg = {
 971                 .mf6c_origin = *origin,
 972                 .mf6c_mcastgrp = *mcastgrp,
 973         };
 974
 975         return mr_mfc_find_parent(mrt, &arg, parent);
 976 }
 977
 978 /* Allocate a multicast cache entry */
 979 static struct mfc6_cache *ip6mr_cache_alloc(void)
 980 {
 981         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
 982         if (!c)
 983                 return NULL;
 984         c->_c.mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
 985         c->_c.mfc_un.res.minvif = MAXMIFS;
 986         c->_c.free = ip6mr_cache_free_rcu;
 987         refcount_set(&c->_c.mfc_un.res.refcount, 1);
 988         return c;
 989 }
 990
 991 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
 992 {
 993         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
 994         if (!c)
 995                 return NULL;
 996         skb_queue_head_init(&c->_c.mfc_un.unres.unresolved);
 997         c->_c.mfc_un.unres.expires = jiffies + 10 * HZ;
 998         return c;
 999 }
1000
1001 /*
1002  *      A cache entry has gone into a resolved state from queued
1003  */
1004
1005 static void ip6mr_cache_resolve(struct net *net, struct mr_table *mrt,
1006                                 struct mfc6_cache *uc, struct mfc6_cache *c)
1007 {
1008         struct sk_buff *skb;
1009
1010         /*
1011          *      Play the pending entries through our router
1012          */
1013
1014         while ((skb = __skb_dequeue(&uc->_c.mfc_un.unres.unresolved))) {
1015                 if (ipv6_hdr(skb)->version == 0) {
1016                         struct nlmsghdr *nlh = skb_pull(skb,
1017                                                         sizeof(struct ipv6hdr));
1018
1019                         if (mr_fill_mroute(mrt, skb, &c->_c,
1020                                            nlmsg_data(nlh)) > 0) {
1021                                 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1022                         } else {
1023                                 nlh->nlmsg_type = NLMSG_ERROR;
1024                                 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1025                                 skb_trim(skb, nlh->nlmsg_len);
1026                                 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1027                         }
1028                         rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1029                 } else
1030                         ip6_mr_forward(net, mrt, skb->dev, skb, c);
1031         }
1032 }
1033
1034 /*
1035  *      Bounce a cache query up to pim6sd and netlink.
1036  *
1037  *      Called under mrt_lock.
1038  */
1039
1040 static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt,
1041                               mifi_t mifi, int assert)
1042 {
1043         struct sock *mroute6_sk;
1044         struct sk_buff *skb;
1045         struct mrt6msg *msg;
1046         int ret;
1047
1048 #ifdef CONFIG_IPV6_PIMSM_V2
1049         if (assert == MRT6MSG_WHOLEPKT)
1050                 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1051                                                 +sizeof(*msg));
1052         else
1053 #endif
1054                 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1055
1056         if (!skb)
1057                 return -ENOBUFS;
1058
1059         /* I suppose that internal messages
1060          * do not require checksums */
1061
1062         skb->ip_summed = CHECKSUM_UNNECESSARY;
1063
1064 #ifdef CONFIG_IPV6_PIMSM_V2
1065         if (assert == MRT6MSG_WHOLEPKT) {
1066                 /* Ugly, but we have no choice with this interface.
1067                    Duplicate old header, fix length etc.
1068                    And all this only to mangle msg->im6_msgtype and
1069                    to set msg->im6_mbz to "mbz" :-)
1070                  */
1071                 skb_push(skb, -skb_network_offset(pkt));
1072
1073                 skb_push(skb, sizeof(*msg));
1074                 skb_reset_transport_header(skb);
1075                 msg = (struct mrt6msg *)skb_transport_header(skb);
1076                 msg->im6_mbz = 0;
1077                 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1078                 msg->im6_mif = mrt->mroute_reg_vif_num;
1079                 msg->im6_pad = 0;
1080                 msg->im6_src = ipv6_hdr(pkt)->saddr;
1081                 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1082
1083                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1084         } else
1085 #endif
1086         {
1087         /*
1088          *      Copy the IP header
1089          */
1090
1091         skb_put(skb, sizeof(struct ipv6hdr));
1092         skb_reset_network_header(skb);
1093         skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1094
1095         /*
1096          *      Add our header
1097          */
1098         skb_put(skb, sizeof(*msg));
1099         skb_reset_transport_header(skb);
1100         msg = (struct mrt6msg *)skb_transport_header(skb);
1101
1102         msg->im6_mbz = 0;
1103         msg->im6_msgtype = assert;
1104         msg->im6_mif = mifi;
1105         msg->im6_pad = 0;
1106         msg->im6_src = ipv6_hdr(pkt)->saddr;
1107         msg->im6_dst = ipv6_hdr(pkt)->daddr;
1108
1109         skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1110         skb->ip_summed = CHECKSUM_UNNECESSARY;
1111         }
1112
1113         rcu_read_lock();
1114         mroute6_sk = rcu_dereference(mrt->mroute_sk);
1115         if (!mroute6_sk) {
1116                 rcu_read_unlock();
1117                 kfree_skb(skb);
1118                 return -EINVAL;
1119         }
1120
1121         mrt6msg_netlink_event(mrt, skb);
1122
1123         /* Deliver to user space multicast routing algorithms */
1124         ret = sock_queue_rcv_skb(mroute6_sk, skb);
1125         rcu_read_unlock();
1126         if (ret < 0) {
1127                 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1128                 kfree_skb(skb);
1129         }
1130
1131         return ret;
1132 }
1133
1134 /* Queue a packet for resolution. It gets locked cache entry! */
1135 static int ip6mr_cache_unresolved(struct mr_table *mrt, mifi_t mifi,
1136                                   struct sk_buff *skb, struct net_device *dev)
1137 {
1138         struct mfc6_cache *c;
1139         bool found = false;
1140         int err;
1141
1142         spin_lock_bh(&mfc_unres_lock);
1143         list_for_each_entry(c, &mrt->mfc_unres_queue, _c.list) {
1144                 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1145                     ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1146                         found = true;
1147                         break;
1148                 }
1149         }
1150
1151         if (!found) {
1152                 /*
1153                  *      Create a new entry if allowable
1154                  */
1155
1156                 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1157                     (c = ip6mr_cache_alloc_unres()) == NULL) {
1158                         spin_unlock_bh(&mfc_unres_lock);
1159
1160                         kfree_skb(skb);
1161                         return -ENOBUFS;
1162                 }
1163
1164                 /* Fill in the new cache entry */
1165                 c->_c.mfc_parent = -1;
1166                 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1167                 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1168
1169                 /*
1170                  *      Reflect first query at pim6sd
1171                  */
1172                 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1173                 if (err < 0) {
1174                         /* If the report failed throw the cache entry
1175                            out - Brad Parker
1176                          */
1177                         spin_unlock_bh(&mfc_unres_lock);
1178
1179                         ip6mr_cache_free(c);
1180                         kfree_skb(skb);
1181                         return err;
1182                 }
1183
1184                 atomic_inc(&mrt->cache_resolve_queue_len);
1185                 list_add(&c->_c.list, &mrt->mfc_unres_queue);
1186                 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1187
1188                 ipmr_do_expire_process(mrt);
1189         }
1190
1191         /* See if we can append the packet */
1192         if (c->_c.mfc_un.unres.unresolved.qlen > 3) {
1193                 kfree_skb(skb);
1194                 err = -ENOBUFS;
1195         } else {
1196                 if (dev) {
1197                         skb->dev = dev;
1198                         skb->skb_iif = dev->ifindex;
1199                 }
1200                 skb_queue_tail(&c->_c.mfc_un.unres.unresolved, skb);
1201                 err = 0;
1202         }
1203
1204         spin_unlock_bh(&mfc_unres_lock);
1205         return err;
1206 }
1207
1208 /*
1209  *      MFC6 cache manipulation by user space
1210  */
1211
1212 static int ip6mr_mfc_delete(struct mr_table *mrt, struct mf6cctl *mfc,
1213                             int parent)
1214 {
1215         struct mfc6_cache *c;
1216
1217         /* The entries are added/deleted only under RTNL */
1218         rcu_read_lock();
1219         c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1220                                     &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1221         rcu_read_unlock();
1222         if (!c)
1223                 return -ENOENT;
1224         rhltable_remove(&mrt->mfc_hash, &c->_c.mnode, ip6mr_rht_params);
1225         list_del_rcu(&c->_c.list);
1226
1227         call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1228                                        FIB_EVENT_ENTRY_DEL, c, mrt->id);
1229         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1230         mr_cache_put(&c->_c);
1231         return 0;
1232 }
1233
1234 static int ip6mr_device_event(struct notifier_block *this,
1235                               unsigned long event, void *ptr)
1236 {
1237         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1238         struct net *net = dev_net(dev);
1239         struct mr_table *mrt;
1240         struct vif_device *v;
1241         int ct;
1242
1243         if (event != NETDEV_UNREGISTER)
1244                 return NOTIFY_DONE;
1245
1246         ip6mr_for_each_table(mrt, net) {
1247                 v = &mrt->vif_table[0];
1248                 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1249                         if (v->dev == dev)
1250                                 mif6_delete(mrt, ct, 1, NULL);
1251                 }
1252         }
1253
1254         return NOTIFY_DONE;
1255 }
1256
1257 static unsigned int ip6mr_seq_read(struct net *net)
1258 {
1259         ASSERT_RTNL();
1260
1261         return net->ipv6.ipmr_seq + ip6mr_rules_seq_read(net);
1262 }
1263
1264 static int ip6mr_dump(struct net *net, struct notifier_block *nb)
1265 {
1266         return mr_dump(net, nb, RTNL_FAMILY_IP6MR, ip6mr_rules_dump,
1267                        ip6mr_mr_table_iter, &mrt_lock);
1268 }
1269
1270 static struct notifier_block ip6_mr_notifier = {
1271         .notifier_call = ip6mr_device_event
1272 };
1273
1274 static const struct fib_notifier_ops ip6mr_notifier_ops_template = {
1275         .family         = RTNL_FAMILY_IP6MR,
1276         .fib_seq_read   = ip6mr_seq_read,
1277         .fib_dump       = ip6mr_dump,
1278         .owner          = THIS_MODULE,
1279 };
1280
1281 static int __net_init ip6mr_notifier_init(struct net *net)
1282 {
1283         struct fib_notifier_ops *ops;
1284
1285         net->ipv6.ipmr_seq = 0;
1286
1287         ops = fib_notifier_ops_register(&ip6mr_notifier_ops_template, net);
1288         if (IS_ERR(ops))
1289                 return PTR_ERR(ops);
1290
1291         net->ipv6.ip6mr_notifier_ops = ops;
1292
1293         return 0;
1294 }
1295
1296 static void __net_exit ip6mr_notifier_exit(struct net *net)
1297 {
1298         fib_notifier_ops_unregister(net->ipv6.ip6mr_notifier_ops);
1299         net->ipv6.ip6mr_notifier_ops = NULL;
1300 }
1301
1302 /* Setup for IP multicast routing */
1303 static int __net_init ip6mr_net_init(struct net *net)
1304 {
1305         int err;
1306
1307         err = ip6mr_notifier_init(net);
1308         if (err)
1309                 return err;
1310
1311         err = ip6mr_rules_init(net);
1312         if (err < 0)
1313                 goto ip6mr_rules_fail;
1314
1315 #ifdef CONFIG_PROC_FS
1316         err = -ENOMEM;
1317         if (!proc_create_net("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_seq_ops,
1318                         sizeof(struct mr_vif_iter)))
1319                 goto proc_vif_fail;
1320         if (!proc_create_net("ip6_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
1321                         sizeof(struct mr_mfc_iter)))
1322                 goto proc_cache_fail;
1323 #endif
1324
1325         return 0;
1326
1327 #ifdef CONFIG_PROC_FS
1328 proc_cache_fail:
1329         remove_proc_entry("ip6_mr_vif", net->proc_net);
1330 proc_vif_fail:
1331         ip6mr_rules_exit(net);
1332 #endif
1333 ip6mr_rules_fail:
1334         ip6mr_notifier_exit(net);
1335         return err;
1336 }
1337
1338 static void __net_exit ip6mr_net_exit(struct net *net)
1339 {
1340 #ifdef CONFIG_PROC_FS
1341         remove_proc_entry("ip6_mr_cache", net->proc_net);
1342         remove_proc_entry("ip6_mr_vif", net->proc_net);
1343 #endif
1344         ip6mr_rules_exit(net);
1345         ip6mr_notifier_exit(net);
1346 }
1347
1348 static struct pernet_operations ip6mr_net_ops = {
1349         .init = ip6mr_net_init,
1350         .exit = ip6mr_net_exit,
1351 };
1352
1353 int __init ip6_mr_init(void)
1354 {
1355         int err;
1356
1357         mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1358                                        sizeof(struct mfc6_cache),
1359                                        0, SLAB_HWCACHE_ALIGN,
1360                                        NULL);
1361         if (!mrt_cachep)
1362                 return -ENOMEM;
1363
1364         err = register_pernet_subsys(&ip6mr_net_ops);
1365         if (err)
1366                 goto reg_pernet_fail;
1367
1368         err = register_netdevice_notifier(&ip6_mr_notifier);
1369         if (err)
1370                 goto reg_notif_fail;
1371 #ifdef CONFIG_IPV6_PIMSM_V2
1372         if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1373                 pr_err("%s: can't add PIM protocol\n", __func__);
1374                 err = -EAGAIN;
1375                 goto add_proto_fail;
1376         }
1377 #endif
1378         err = rtnl_register_module(THIS_MODULE, RTNL_FAMILY_IP6MR, RTM_GETROUTE,
1379                                    NULL, ip6mr_rtm_dumproute, 0);
1380         if (err == 0)
1381                 return 0;
1382
1383 #ifdef CONFIG_IPV6_PIMSM_V2
1384         inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1385 add_proto_fail:
1386         unregister_netdevice_notifier(&ip6_mr_notifier);
1387 #endif
1388 reg_notif_fail:
1389         unregister_pernet_subsys(&ip6mr_net_ops);
1390 reg_pernet_fail:
1391         kmem_cache_destroy(mrt_cachep);
1392         return err;
1393 }
1394
1395 void ip6_mr_cleanup(void)
1396 {
1397         rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1398 #ifdef CONFIG_IPV6_PIMSM_V2
1399         inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1400 #endif
1401         unregister_netdevice_notifier(&ip6_mr_notifier);
1402         unregister_pernet_subsys(&ip6mr_net_ops);
1403         kmem_cache_destroy(mrt_cachep);
1404 }
1405
1406 static int ip6mr_mfc_add(struct net *net, struct mr_table *mrt,
1407                          struct mf6cctl *mfc, int mrtsock, int parent)
1408 {
1409         unsigned char ttls[MAXMIFS];
1410         struct mfc6_cache *uc, *c;
1411         struct mr_mfc *_uc;
1412         bool found;
1413         int i, err;
1414
1415         if (mfc->mf6cc_parent >= MAXMIFS)
1416                 return -ENFILE;
1417
1418         memset(ttls, 255, MAXMIFS);
1419         for (i = 0; i < MAXMIFS; i++) {
1420                 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1421                         ttls[i] = 1;
1422         }
1423
1424         /* The entries are added/deleted only under RTNL */
1425         rcu_read_lock();
1426         c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1427                                     &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1428         rcu_read_unlock();
1429         if (c) {
1430                 write_lock_bh(&mrt_lock);
1431                 c->_c.mfc_parent = mfc->mf6cc_parent;
1432                 ip6mr_update_thresholds(mrt, &c->_c, ttls);
1433                 if (!mrtsock)
1434                         c->_c.mfc_flags |= MFC_STATIC;
1435                 write_unlock_bh(&mrt_lock);
1436                 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE,
1437                                                c, mrt->id);
1438                 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1439                 return 0;
1440         }
1441
1442         if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1443             !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1444                 return -EINVAL;
1445
1446         c = ip6mr_cache_alloc();
1447         if (!c)
1448                 return -ENOMEM;
1449
1450         c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1451         c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1452         c->_c.mfc_parent = mfc->mf6cc_parent;
1453         ip6mr_update_thresholds(mrt, &c->_c, ttls);
1454         if (!mrtsock)
1455                 c->_c.mfc_flags |= MFC_STATIC;
1456
1457         err = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->_c.mnode,
1458                                   ip6mr_rht_params);
1459         if (err) {
1460                 pr_err("ip6mr: rhtable insert error %d\n", err);
1461                 ip6mr_cache_free(c);
1462                 return err;
1463         }
1464         list_add_tail_rcu(&c->_c.list, &mrt->mfc_cache_list);
1465
1466         /* Check to see if we resolved a queued list. If so we
1467          * need to send on the frames and tidy up.
1468          */
1469         found = false;
1470         spin_lock_bh(&mfc_unres_lock);
1471         list_for_each_entry(_uc, &mrt->mfc_unres_queue, list) {
1472                 uc = (struct mfc6_cache *)_uc;
1473                 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1474                     ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1475                         list_del(&_uc->list);
1476                         atomic_dec(&mrt->cache_resolve_queue_len);
1477                         found = true;
1478                         break;
1479                 }
1480         }
1481         if (list_empty(&mrt->mfc_unres_queue))
1482                 del_timer(&mrt->ipmr_expire_timer);
1483         spin_unlock_bh(&mfc_unres_lock);
1484
1485         if (found) {
1486                 ip6mr_cache_resolve(net, mrt, uc, c);
1487                 ip6mr_cache_free(uc);
1488         }
1489         call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD,
1490                                        c, mrt->id);
1491         mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1492         return 0;
1493 }
1494
1495 /*
1496  *      Close the multicast socket, and clear the vif tables etc
1497  */
1498
1499 static void mroute_clean_tables(struct mr_table *mrt, bool all)
1500 {
1501         struct mr_mfc *c, *tmp;
1502         LIST_HEAD(list);
1503         int i;
1504
1505         /* Shut down all active vif entries */
1506         for (i = 0; i < mrt->maxvif; i++) {
1507                 if (!all && (mrt->vif_table[i].flags & VIFF_STATIC))
1508                         continue;
1509                 mif6_delete(mrt, i, 0, &list);
1510         }
1511         unregister_netdevice_many(&list);
1512
1513         /* Wipe the cache */
1514         list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
1515                 if (!all && (c->mfc_flags & MFC_STATIC))
1516                         continue;
1517                 rhltable_remove(&mrt->mfc_hash, &c->mnode, ip6mr_rht_params);
1518                 list_del_rcu(&c->list);
1519                 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
1520                 mr_cache_put(c);
1521         }
1522
1523         if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1524                 spin_lock_bh(&mfc_unres_lock);
1525                 list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
1526                         list_del(&c->list);
1527                         call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1528                                                        FIB_EVENT_ENTRY_DEL,
1529                                                        (struct mfc6_cache *)c,
1530                                                        mrt->id);
1531                         mr6_netlink_event(mrt, (struct mfc6_cache *)c,
1532                                           RTM_DELROUTE);
1533                         ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
1534                 }
1535                 spin_unlock_bh(&mfc_unres_lock);
1536         }
1537 }
1538
1539 static int ip6mr_sk_init(struct mr_table *mrt, struct sock *sk)
1540 {
1541         int err = 0;
1542         struct net *net = sock_net(sk);
1543
1544         rtnl_lock();
1545         write_lock_bh(&mrt_lock);
1546         if (rtnl_dereference(mrt->mroute_sk)) {
1547                 err = -EADDRINUSE;
1548         } else {
1549                 rcu_assign_pointer(mrt->mroute_sk, sk);
1550                 sock_set_flag(sk, SOCK_RCU_FREE);
1551                 net->ipv6.devconf_all->mc_forwarding++;
1552         }
1553         write_unlock_bh(&mrt_lock);
1554
1555         if (!err)
1556                 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1557                                              NETCONFA_MC_FORWARDING,
1558                                              NETCONFA_IFINDEX_ALL,
1559                                              net->ipv6.devconf_all);
1560         rtnl_unlock();
1561
1562         return err;
1563 }
1564
1565 int ip6mr_sk_done(struct sock *sk)
1566 {
1567         int err = -EACCES;
1568         struct net *net = sock_net(sk);
1569         struct mr_table *mrt;
1570
1571         if (sk->sk_type != SOCK_RAW ||
1572             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1573                 return err;
1574
1575         rtnl_lock();
1576         ip6mr_for_each_table(mrt, net) {
1577                 if (sk == rtnl_dereference(mrt->mroute_sk)) {
1578                         write_lock_bh(&mrt_lock);
1579                         RCU_INIT_POINTER(mrt->mroute_sk, NULL);
1580                         /* Note that mroute_sk had SOCK_RCU_FREE set,
1581                          * so the RCU grace period before sk freeing
1582                          * is guaranteed by sk_destruct()
1583                          */
1584                         net->ipv6.devconf_all->mc_forwarding--;
1585                         write_unlock_bh(&mrt_lock);
1586                         inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1587                                                      NETCONFA_MC_FORWARDING,
1588                                                      NETCONFA_IFINDEX_ALL,
1589                                                      net->ipv6.devconf_all);
1590
1591                         mroute_clean_tables(mrt, false);
1592                         err = 0;
1593                         break;
1594                 }
1595         }
1596         rtnl_unlock();
1597
1598         return err;
1599 }
1600
1601 bool mroute6_is_socket(struct net *net, struct sk_buff *skb)
1602 {
1603         struct mr_table *mrt;
1604         struct flowi6 fl6 = {
1605                 .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
1606                 .flowi6_oif     = skb->dev->ifindex,
1607                 .flowi6_mark    = skb->mark,
1608         };
1609
1610         if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1611                 return NULL;
1612
1613         return rcu_access_pointer(mrt->mroute_sk);
1614 }
1615 EXPORT_SYMBOL(mroute6_is_socket);
1616
1617 /*
1618  *      Socket options and virtual interface manipulation. The whole
1619  *      virtual interface system is a complete heap, but unfortunately
1620  *      that's how BSD mrouted happens to think. Maybe one day with a proper
1621  *      MOSPF/PIM router set up we can clean this up.
1622  */
1623
1624 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1625 {
1626         int ret, parent = 0;
1627         struct mif6ctl vif;
1628         struct mf6cctl mfc;
1629         mifi_t mifi;
1630         struct net *net = sock_net(sk);
1631         struct mr_table *mrt;
1632
1633         if (sk->sk_type != SOCK_RAW ||
1634             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1635                 return -EOPNOTSUPP;
1636
1637         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1638         if (!mrt)
1639                 return -ENOENT;
1640
1641         if (optname != MRT6_INIT) {
1642                 if (sk != rcu_access_pointer(mrt->mroute_sk) &&
1643                     !ns_capable(net->user_ns, CAP_NET_ADMIN))
1644                         return -EACCES;
1645         }
1646
1647         switch (optname) {
1648         case MRT6_INIT:
1649                 if (optlen < sizeof(int))
1650                         return -EINVAL;
1651
1652                 return ip6mr_sk_init(mrt, sk);
1653
1654         case MRT6_DONE:
1655                 return ip6mr_sk_done(sk);
1656
1657         case MRT6_ADD_MIF:
1658                 if (optlen < sizeof(vif))
1659                         return -EINVAL;
1660                 if (copy_from_user(&vif, optval, sizeof(vif)))
1661                         return -EFAULT;
1662                 if (vif.mif6c_mifi >= MAXMIFS)
1663                         return -ENFILE;
1664                 rtnl_lock();
1665                 ret = mif6_add(net, mrt, &vif,
1666                                sk == rtnl_dereference(mrt->mroute_sk));
1667                 rtnl_unlock();
1668                 return ret;
1669
1670         case MRT6_DEL_MIF:
1671                 if (optlen < sizeof(mifi_t))
1672                         return -EINVAL;
1673                 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1674                         return -EFAULT;
1675                 rtnl_lock();
1676                 ret = mif6_delete(mrt, mifi, 0, NULL);
1677                 rtnl_unlock();
1678                 return ret;
1679
1680         /*
1681          *      Manipulate the forwarding caches. These live
1682          *      in a sort of kernel/user symbiosis.
1683          */
1684         case MRT6_ADD_MFC:
1685         case MRT6_DEL_MFC:
1686                 parent = -1;
1687                 /* fall through */
1688         case MRT6_ADD_MFC_PROXY:
1689         case MRT6_DEL_MFC_PROXY:
1690                 if (optlen < sizeof(mfc))
1691                         return -EINVAL;
1692                 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1693                         return -EFAULT;
1694                 if (parent == 0)
1695                         parent = mfc.mf6cc_parent;
1696                 rtnl_lock();
1697                 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1698                         ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1699                 else
1700                         ret = ip6mr_mfc_add(net, mrt, &mfc,
1701                                             sk ==
1702                                             rtnl_dereference(mrt->mroute_sk),
1703                                             parent);
1704                 rtnl_unlock();
1705                 return ret;
1706
1707         /*
1708          *      Control PIM assert (to activate pim will activate assert)
1709          */
1710         case MRT6_ASSERT:
1711         {
1712                 int v;
1713
1714                 if (optlen != sizeof(v))
1715                         return -EINVAL;
1716                 if (get_user(v, (int __user *)optval))
1717                         return -EFAULT;
1718                 mrt->mroute_do_assert = v;
1719                 return 0;
1720         }
1721
1722 #ifdef CONFIG_IPV6_PIMSM_V2
1723         case MRT6_PIM:
1724         {
1725                 int v;
1726
1727                 if (optlen != sizeof(v))
1728                         return -EINVAL;
1729                 if (get_user(v, (int __user *)optval))
1730                         return -EFAULT;
1731                 v = !!v;
1732                 rtnl_lock();
1733                 ret = 0;
1734                 if (v != mrt->mroute_do_pim) {
1735                         mrt->mroute_do_pim = v;
1736                         mrt->mroute_do_assert = v;
1737                 }
1738                 rtnl_unlock();
1739                 return ret;
1740         }
1741
1742 #endif
1743 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1744         case MRT6_TABLE:
1745         {
1746                 u32 v;
1747
1748                 if (optlen != sizeof(u32))
1749                         return -EINVAL;
1750                 if (get_user(v, (u32 __user *)optval))
1751                         return -EFAULT;
1752                 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1753                 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1754                         return -EINVAL;
1755                 if (sk == rcu_access_pointer(mrt->mroute_sk))
1756                         return -EBUSY;
1757
1758                 rtnl_lock();
1759                 ret = 0;
1760                 mrt = ip6mr_new_table(net, v);
1761                 if (IS_ERR(mrt))
1762                         ret = PTR_ERR(mrt);
1763                 else
1764                         raw6_sk(sk)->ip6mr_table = v;
1765                 rtnl_unlock();
1766                 return ret;
1767         }
1768 #endif
1769         /*
1770          *      Spurious command, or MRT6_VERSION which you cannot
1771          *      set.
1772          */
1773         default:
1774                 return -ENOPROTOOPT;
1775         }
1776 }
1777
1778 /*
1779  *      Getsock opt support for the multicast routing system.
1780  */
1781
1782 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1783                           int __user *optlen)
1784 {
1785         int olr;
1786         int val;
1787         struct net *net = sock_net(sk);
1788         struct mr_table *mrt;
1789
1790         if (sk->sk_type != SOCK_RAW ||
1791             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1792                 return -EOPNOTSUPP;
1793
1794         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1795         if (!mrt)
1796                 return -ENOENT;
1797
1798         switch (optname) {
1799         case MRT6_VERSION:
1800                 val = 0x0305;
1801                 break;
1802 #ifdef CONFIG_IPV6_PIMSM_V2
1803         case MRT6_PIM:
1804                 val = mrt->mroute_do_pim;
1805                 break;
1806 #endif
1807         case MRT6_ASSERT:
1808                 val = mrt->mroute_do_assert;
1809                 break;
1810         default:
1811                 return -ENOPROTOOPT;
1812         }
1813
1814         if (get_user(olr, optlen))
1815                 return -EFAULT;
1816
1817         olr = min_t(int, olr, sizeof(int));
1818         if (olr < 0)
1819                 return -EINVAL;
1820
1821         if (put_user(olr, optlen))
1822                 return -EFAULT;
1823         if (copy_to_user(optval, &val, olr))
1824                 return -EFAULT;
1825         return 0;
1826 }
1827
1828 /*
1829  *      The IP multicast ioctl support routines.
1830  */
1831
1832 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1833 {
1834         struct sioc_sg_req6 sr;
1835         struct sioc_mif_req6 vr;
1836         struct vif_device *vif;
1837         struct mfc6_cache *c;
1838         struct net *net = sock_net(sk);
1839         struct mr_table *mrt;
1840
1841         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1842         if (!mrt)
1843                 return -ENOENT;
1844
1845         switch (cmd) {
1846         case SIOCGETMIFCNT_IN6:
1847                 if (copy_from_user(&vr, arg, sizeof(vr)))
1848                         return -EFAULT;
1849                 if (vr.mifi >= mrt->maxvif)
1850                         return -EINVAL;
1851                 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1852                 read_lock(&mrt_lock);
1853                 vif = &mrt->vif_table[vr.mifi];
1854                 if (VIF_EXISTS(mrt, vr.mifi)) {
1855                         vr.icount = vif->pkt_in;
1856                         vr.ocount = vif->pkt_out;
1857                         vr.ibytes = vif->bytes_in;
1858                         vr.obytes = vif->bytes_out;
1859                         read_unlock(&mrt_lock);
1860
1861                         if (copy_to_user(arg, &vr, sizeof(vr)))
1862                                 return -EFAULT;
1863                         return 0;
1864                 }
1865                 read_unlock(&mrt_lock);
1866                 return -EADDRNOTAVAIL;
1867         case SIOCGETSGCNT_IN6:
1868                 if (copy_from_user(&sr, arg, sizeof(sr)))
1869                         return -EFAULT;
1870
1871                 rcu_read_lock();
1872                 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1873                 if (c) {
1874                         sr.pktcnt = c->_c.mfc_un.res.pkt;
1875                         sr.bytecnt = c->_c.mfc_un.res.bytes;
1876                         sr.wrong_if = c->_c.mfc_un.res.wrong_if;
1877                         rcu_read_unlock();
1878
1879                         if (copy_to_user(arg, &sr, sizeof(sr)))
1880                                 return -EFAULT;
1881                         return 0;
1882                 }
1883                 rcu_read_unlock();
1884                 return -EADDRNOTAVAIL;
1885         default:
1886                 return -ENOIOCTLCMD;
1887         }
1888 }
1889
1890 #ifdef CONFIG_COMPAT
1891 struct compat_sioc_sg_req6 {
1892         struct sockaddr_in6 src;
1893         struct sockaddr_in6 grp;
1894         compat_ulong_t pktcnt;
1895         compat_ulong_t bytecnt;
1896         compat_ulong_t wrong_if;
1897 };
1898
1899 struct compat_sioc_mif_req6 {
1900         mifi_t  mifi;
1901         compat_ulong_t icount;
1902         compat_ulong_t ocount;
1903         compat_ulong_t ibytes;
1904         compat_ulong_t obytes;
1905 };
1906
1907 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1908 {
1909         struct compat_sioc_sg_req6 sr;
1910         struct compat_sioc_mif_req6 vr;
1911         struct vif_device *vif;
1912         struct mfc6_cache *c;
1913         struct net *net = sock_net(sk);
1914         struct mr_table *mrt;
1915
1916         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1917         if (!mrt)
1918                 return -ENOENT;
1919
1920         switch (cmd) {
1921         case SIOCGETMIFCNT_IN6:
1922                 if (copy_from_user(&vr, arg, sizeof(vr)))
1923                         return -EFAULT;
1924                 if (vr.mifi >= mrt->maxvif)
1925                         return -EINVAL;
1926                 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1927                 read_lock(&mrt_lock);
1928                 vif = &mrt->vif_table[vr.mifi];
1929                 if (VIF_EXISTS(mrt, vr.mifi)) {
1930                         vr.icount = vif->pkt_in;
1931                         vr.ocount = vif->pkt_out;
1932                         vr.ibytes = vif->bytes_in;
1933                         vr.obytes = vif->bytes_out;
1934                         read_unlock(&mrt_lock);
1935
1936                         if (copy_to_user(arg, &vr, sizeof(vr)))
1937                                 return -EFAULT;
1938                         return 0;
1939                 }
1940                 read_unlock(&mrt_lock);
1941                 return -EADDRNOTAVAIL;
1942         case SIOCGETSGCNT_IN6:
1943                 if (copy_from_user(&sr, arg, sizeof(sr)))
1944                         return -EFAULT;
1945
1946                 rcu_read_lock();
1947                 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1948                 if (c) {
1949                         sr.pktcnt = c->_c.mfc_un.res.pkt;
1950                         sr.bytecnt = c->_c.mfc_un.res.bytes;
1951                         sr.wrong_if = c->_c.mfc_un.res.wrong_if;
1952                         rcu_read_unlock();
1953
1954                         if (copy_to_user(arg, &sr, sizeof(sr)))
1955                                 return -EFAULT;
1956                         return 0;
1957                 }
1958                 rcu_read_unlock();
1959                 return -EADDRNOTAVAIL;
1960         default:
1961                 return -ENOIOCTLCMD;
1962         }
1963 }
1964 #endif
1965
1966 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
1967 {
1968         __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
1969                         IPSTATS_MIB_OUTFORWDATAGRAMS);
1970         __IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
1971                         IPSTATS_MIB_OUTOCTETS, skb->len);
1972         return dst_output(net, sk, skb);
1973 }
1974
1975 /*
1976  *      Processing handlers for ip6mr_forward
1977  */
1978
1979 static int ip6mr_forward2(struct net *net, struct mr_table *mrt,
1980                           struct sk_buff *skb, int vifi)
1981 {
1982         struct ipv6hdr *ipv6h;
1983         struct vif_device *vif = &mrt->vif_table[vifi];
1984         struct net_device *dev;
1985         struct dst_entry *dst;
1986         struct flowi6 fl6;
1987
1988         if (!vif->dev)
1989                 goto out_free;
1990
1991 #ifdef CONFIG_IPV6_PIMSM_V2
1992         if (vif->flags & MIFF_REGISTER) {
1993                 vif->pkt_out++;
1994                 vif->bytes_out += skb->len;
1995                 vif->dev->stats.tx_bytes += skb->len;
1996                 vif->dev->stats.tx_packets++;
1997                 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
1998                 goto out_free;
1999         }
2000 #endif
2001
2002         ipv6h = ipv6_hdr(skb);
2003
2004         fl6 = (struct flowi6) {
2005                 .flowi6_oif = vif->link,
2006                 .daddr = ipv6h->daddr,
2007         };
2008
2009         dst = ip6_route_output(net, NULL, &fl6);
2010         if (dst->error) {
2011                 dst_release(dst);
2012                 goto out_free;
2013         }
2014
2015         skb_dst_drop(skb);
2016         skb_dst_set(skb, dst);
2017
2018         /*
2019          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2020          * not only before forwarding, but after forwarding on all output
2021          * interfaces. It is clear, if mrouter runs a multicasting
2022          * program, it should receive packets not depending to what interface
2023          * program is joined.
2024          * If we will not make it, the program will have to join on all
2025          * interfaces. On the other hand, multihoming host (or router, but
2026          * not mrouter) cannot join to more than one interface - it will
2027          * result in receiving multiple packets.
2028          */
2029         dev = vif->dev;
2030         skb->dev = dev;
2031         vif->pkt_out++;
2032         vif->bytes_out += skb->len;
2033
2034         /* We are about to write */
2035         /* XXX: extension headers? */
2036         if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2037                 goto out_free;
2038
2039         ipv6h = ipv6_hdr(skb);
2040         ipv6h->hop_limit--;
2041
2042         IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2043
2044         return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2045                        net, NULL, skb, skb->dev, dev,
2046                        ip6mr_forward2_finish);
2047
2048 out_free:
2049         kfree_skb(skb);
2050         return 0;
2051 }
2052
2053 static int ip6mr_find_vif(struct mr_table *mrt, struct net_device *dev)
2054 {
2055         int ct;
2056
2057         for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2058                 if (mrt->vif_table[ct].dev == dev)
2059                         break;
2060         }
2061         return ct;
2062 }
2063
2064 static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
2065                            struct net_device *dev, struct sk_buff *skb,
2066                            struct mfc6_cache *c)
2067 {
2068         int psend = -1;
2069         int vif, ct;
2070         int true_vifi = ip6mr_find_vif(mrt, dev);
2071
2072         vif = c->_c.mfc_parent;
2073         c->_c.mfc_un.res.pkt++;
2074         c->_c.mfc_un.res.bytes += skb->len;
2075         c->_c.mfc_un.res.lastuse = jiffies;
2076
2077         if (ipv6_addr_any(&c->mf6c_origin) && true_vifi >= 0) {
2078                 struct mfc6_cache *cache_proxy;
2079
2080                 /* For an (*,G) entry, we only check that the incoming
2081                  * interface is part of the static tree.
2082                  */
2083                 rcu_read_lock();
2084                 cache_proxy = mr_mfc_find_any_parent(mrt, vif);
2085                 if (cache_proxy &&
2086                     cache_proxy->_c.mfc_un.res.ttls[true_vifi] < 255) {
2087                         rcu_read_unlock();
2088                         goto forward;
2089                 }
2090                 rcu_read_unlock();
2091         }
2092
2093         /*
2094          * Wrong interface: drop packet and (maybe) send PIM assert.
2095          */
2096         if (mrt->vif_table[vif].dev != dev) {
2097                 c->_c.mfc_un.res.wrong_if++;
2098
2099                 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2100                     /* pimsm uses asserts, when switching from RPT to SPT,
2101                        so that we cannot check that packet arrived on an oif.
2102                        It is bad, but otherwise we would need to move pretty
2103                        large chunk of pimd to kernel. Ough... --ANK
2104                      */
2105                     (mrt->mroute_do_pim ||
2106                      c->_c.mfc_un.res.ttls[true_vifi] < 255) &&
2107                     time_after(jiffies,
2108                                c->_c.mfc_un.res.last_assert +
2109                                MFC_ASSERT_THRESH)) {
2110                         c->_c.mfc_un.res.last_assert = jiffies;
2111                         ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2112                 }
2113                 goto dont_forward;
2114         }
2115
2116 forward:
2117         mrt->vif_table[vif].pkt_in++;
2118         mrt->vif_table[vif].bytes_in += skb->len;
2119
2120         /*
2121          *      Forward the frame
2122          */
2123         if (ipv6_addr_any(&c->mf6c_origin) &&
2124             ipv6_addr_any(&c->mf6c_mcastgrp)) {
2125                 if (true_vifi >= 0 &&
2126                     true_vifi != c->_c.mfc_parent &&
2127                     ipv6_hdr(skb)->hop_limit >
2128                                 c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) {
2129                         /* It's an (*,*) entry and the packet is not coming from
2130                          * the upstream: forward the packet to the upstream
2131                          * only.
2132                          */
2133                         psend = c->_c.mfc_parent;
2134                         goto last_forward;
2135                 }
2136                 goto dont_forward;
2137         }
2138         for (ct = c->_c.mfc_un.res.maxvif - 1;
2139              ct >= c->_c.mfc_un.res.minvif; ct--) {
2140                 /* For (*,G) entry, don't forward to the incoming interface */
2141                 if ((!ipv6_addr_any(&c->mf6c_origin) || ct != true_vifi) &&
2142                     ipv6_hdr(skb)->hop_limit > c->_c.mfc_un.res.ttls[ct]) {
2143                         if (psend != -1) {
2144                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2145                                 if (skb2)
2146                                         ip6mr_forward2(net, mrt, skb2, psend);
2147                         }
2148                         psend = ct;
2149                 }
2150         }
2151 last_forward:
2152         if (psend != -1) {
2153                 ip6mr_forward2(net, mrt, skb, psend);
2154                 return;
2155         }
2156
2157 dont_forward:
2158         kfree_skb(skb);
2159 }
2160
2161
2162 /*
2163  *      Multicast packets for forwarding arrive here
2164  */
2165
2166 int ip6_mr_input(struct sk_buff *skb)
2167 {
2168         struct mfc6_cache *cache;
2169         struct net *net = dev_net(skb->dev);
2170         struct mr_table *mrt;
2171         struct flowi6 fl6 = {
2172                 .flowi6_iif     = skb->dev->ifindex,
2173                 .flowi6_mark    = skb->mark,
2174         };
2175         int err;
2176         struct net_device *dev;
2177
2178         /* skb->dev passed in is the master dev for vrfs.
2179          * Get the proper interface that does have a vif associated with it.
2180          */
2181         dev = skb->dev;
2182         if (netif_is_l3_master(skb->dev)) {
2183                 dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
2184                 if (!dev) {
2185                         kfree_skb(skb);
2186                         return -ENODEV;
2187                 }
2188         }
2189
2190         err = ip6mr_fib_lookup(net, &fl6, &mrt);
2191         if (err < 0) {
2192                 kfree_skb(skb);
2193                 return err;
2194         }
2195
2196         read_lock(&mrt_lock);
2197         cache = ip6mr_cache_find(mrt,
2198                                  &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2199         if (!cache) {
2200                 int vif = ip6mr_find_vif(mrt, dev);
2201
2202                 if (vif >= 0)
2203                         cache = ip6mr_cache_find_any(mrt,
2204                                                      &ipv6_hdr(skb)->daddr,
2205                                                      vif);
2206         }
2207
2208         /*
2209          *      No usable cache entry
2210          */
2211         if (!cache) {
2212                 int vif;
2213
2214                 vif = ip6mr_find_vif(mrt, dev);
2215                 if (vif >= 0) {
2216                         int err = ip6mr_cache_unresolved(mrt, vif, skb, dev);
2217                         read_unlock(&mrt_lock);
2218
2219                         return err;
2220                 }
2221                 read_unlock(&mrt_lock);
2222                 kfree_skb(skb);
2223                 return -ENODEV;
2224         }
2225
2226         ip6_mr_forward(net, mrt, dev, skb, cache);
2227
2228         read_unlock(&mrt_lock);
2229
2230         return 0;
2231 }
2232
2233 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2234                     u32 portid)
2235 {
2236         int err;
2237         struct mr_table *mrt;
2238         struct mfc6_cache *cache;
2239         struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2240
2241         mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2242         if (!mrt)
2243                 return -ENOENT;
2244
2245         read_lock(&mrt_lock);
2246         cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2247         if (!cache && skb->dev) {
2248                 int vif = ip6mr_find_vif(mrt, skb->dev);
2249
2250                 if (vif >= 0)
2251                         cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2252                                                      vif);
2253         }
2254
2255         if (!cache) {
2256                 struct sk_buff *skb2;
2257                 struct ipv6hdr *iph;
2258                 struct net_device *dev;
2259                 int vif;
2260
2261                 dev = skb->dev;
2262                 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2263                         read_unlock(&mrt_lock);
2264                         return -ENODEV;
2265                 }
2266
2267                 /* really correct? */
2268                 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2269                 if (!skb2) {
2270                         read_unlock(&mrt_lock);
2271                         return -ENOMEM;
2272                 }
2273
2274                 NETLINK_CB(skb2).portid = portid;
2275                 skb_reset_transport_header(skb2);
2276
2277                 skb_put(skb2, sizeof(struct ipv6hdr));
2278                 skb_reset_network_header(skb2);
2279
2280                 iph = ipv6_hdr(skb2);
2281                 iph->version = 0;
2282                 iph->priority = 0;
2283                 iph->flow_lbl[0] = 0;
2284                 iph->flow_lbl[1] = 0;
2285                 iph->flow_lbl[2] = 0;
2286                 iph->payload_len = 0;
2287                 iph->nexthdr = IPPROTO_NONE;
2288                 iph->hop_limit = 0;
2289                 iph->saddr = rt->rt6i_src.addr;
2290                 iph->daddr = rt->rt6i_dst.addr;
2291
2292                 err = ip6mr_cache_unresolved(mrt, vif, skb2, dev);
2293                 read_unlock(&mrt_lock);
2294
2295                 return err;
2296         }
2297
2298         err = mr_fill_mroute(mrt, skb, &cache->_c, rtm);
2299         read_unlock(&mrt_lock);
2300         return err;
2301 }
2302
2303 static int ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2304                              u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2305                              int flags)
2306 {
2307         struct nlmsghdr *nlh;
2308         struct rtmsg *rtm;
2309         int err;
2310
2311         nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2312         if (!nlh)
2313                 return -EMSGSIZE;
2314
2315         rtm = nlmsg_data(nlh);
2316         rtm->rtm_family   = RTNL_FAMILY_IP6MR;
2317         rtm->rtm_dst_len  = 128;
2318         rtm->rtm_src_len  = 128;
2319         rtm->rtm_tos      = 0;
2320         rtm->rtm_table    = mrt->id;
2321         if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2322                 goto nla_put_failure;
2323         rtm->rtm_type = RTN_MULTICAST;
2324         rtm->rtm_scope    = RT_SCOPE_UNIVERSE;
2325         if (c->_c.mfc_flags & MFC_STATIC)
2326                 rtm->rtm_protocol = RTPROT_STATIC;
2327         else
2328                 rtm->rtm_protocol = RTPROT_MROUTED;
2329         rtm->rtm_flags    = 0;
2330
2331         if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2332             nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2333                 goto nla_put_failure;
2334         err = mr_fill_mroute(mrt, skb, &c->_c, rtm);
2335         /* do not break the dump if cache is unresolved */
2336         if (err < 0 && err != -ENOENT)
2337                 goto nla_put_failure;
2338
2339         nlmsg_end(skb, nlh);
2340         return 0;
2341
2342 nla_put_failure:
2343         nlmsg_cancel(skb, nlh);
2344         return -EMSGSIZE;
2345 }
2346
2347 static int _ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2348                               u32 portid, u32 seq, struct mr_mfc *c,
2349                               int cmd, int flags)
2350 {
2351         return ip6mr_fill_mroute(mrt, skb, portid, seq, (struct mfc6_cache *)c,
2352                                  cmd, flags);
2353 }
2354
2355 static int mr6_msgsize(bool unresolved, int maxvif)
2356 {
2357         size_t len =
2358                 NLMSG_ALIGN(sizeof(struct rtmsg))
2359                 + nla_total_size(4)     /* RTA_TABLE */
2360                 + nla_total_size(sizeof(struct in6_addr))       /* RTA_SRC */
2361                 + nla_total_size(sizeof(struct in6_addr))       /* RTA_DST */
2362                 ;
2363
2364         if (!unresolved)
2365                 len = len
2366                       + nla_total_size(4)       /* RTA_IIF */
2367                       + nla_total_size(0)       /* RTA_MULTIPATH */
2368                       + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2369                                                 /* RTA_MFC_STATS */
2370                       + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
2371                 ;
2372
2373         return len;
2374 }
2375
2376 static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
2377                               int cmd)
2378 {
2379         struct net *net = read_pnet(&mrt->net);
2380         struct sk_buff *skb;
2381         int err = -ENOBUFS;
2382
2383         skb = nlmsg_new(mr6_msgsize(mfc->_c.mfc_parent >= MAXMIFS, mrt->maxvif),
2384                         GFP_ATOMIC);
2385         if (!skb)
2386                 goto errout;
2387
2388         err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2389         if (err < 0)
2390                 goto errout;
2391
2392         rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2393         return;
2394
2395 errout:
2396         kfree_skb(skb);
2397         if (err < 0)
2398                 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2399 }
2400
2401 static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
2402 {
2403         size_t len =
2404                 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2405                 + nla_total_size(1)     /* IP6MRA_CREPORT_MSGTYPE */
2406                 + nla_total_size(4)     /* IP6MRA_CREPORT_MIF_ID */
2407                                         /* IP6MRA_CREPORT_SRC_ADDR */
2408                 + nla_total_size(sizeof(struct in6_addr))
2409                                         /* IP6MRA_CREPORT_DST_ADDR */
2410                 + nla_total_size(sizeof(struct in6_addr))
2411                                         /* IP6MRA_CREPORT_PKT */
2412                 + nla_total_size(payloadlen)
2413                 ;
2414
2415         return len;
2416 }
2417
2418 static void mrt6msg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt)
2419 {
2420         struct net *net = read_pnet(&mrt->net);
2421         struct nlmsghdr *nlh;
2422         struct rtgenmsg *rtgenm;
2423         struct mrt6msg *msg;
2424         struct sk_buff *skb;
2425         struct nlattr *nla;
2426         int payloadlen;
2427
2428         payloadlen = pkt->len - sizeof(struct mrt6msg);
2429         msg = (struct mrt6msg *)skb_transport_header(pkt);
2430
2431         skb = nlmsg_new(mrt6msg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2432         if (!skb)
2433                 goto errout;
2434
2435         nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2436                         sizeof(struct rtgenmsg), 0);
2437         if (!nlh)
2438                 goto errout;
2439         rtgenm = nlmsg_data(nlh);
2440         rtgenm->rtgen_family = RTNL_FAMILY_IP6MR;
2441         if (nla_put_u8(skb, IP6MRA_CREPORT_MSGTYPE, msg->im6_msgtype) ||
2442             nla_put_u32(skb, IP6MRA_CREPORT_MIF_ID, msg->im6_mif) ||
2443             nla_put_in6_addr(skb, IP6MRA_CREPORT_SRC_ADDR,
2444                              &msg->im6_src) ||
2445             nla_put_in6_addr(skb, IP6MRA_CREPORT_DST_ADDR,
2446                              &msg->im6_dst))
2447                 goto nla_put_failure;
2448
2449         nla = nla_reserve(skb, IP6MRA_CREPORT_PKT, payloadlen);
2450         if (!nla || skb_copy_bits(pkt, sizeof(struct mrt6msg),
2451                                   nla_data(nla), payloadlen))
2452                 goto nla_put_failure;
2453
2454         nlmsg_end(skb, nlh);
2455
2456         rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE_R, NULL, GFP_ATOMIC);
2457         return;
2458
2459 nla_put_failure:
2460         nlmsg_cancel(skb, nlh);
2461 errout:
2462         kfree_skb(skb);
2463         rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE_R, -ENOBUFS);
2464 }
2465
2466 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2467 {
2468         const struct nlmsghdr *nlh = cb->nlh;
2469         struct fib_dump_filter filter = {};
2470         int err;
2471
2472         if (cb->strict_check) {
2473                 err = ip_valid_fib_dump_req(sock_net(skb->sk), nlh,
2474                                             &filter, cb);
2475                 if (err < 0)
2476                         return err;
2477         }
2478
2479         if (filter.table_id) {
2480                 struct mr_table *mrt;
2481
2482                 mrt = ip6mr_get_table(sock_net(skb->sk), filter.table_id);
2483                 if (!mrt) {
2484                         if (filter.dump_all_families)
2485                                 return skb->len;
2486
2487                         NL_SET_ERR_MSG_MOD(cb->extack, "MR table does not exist");
2488                         return -ENOENT;
2489                 }
2490                 err = mr_table_dump(mrt, skb, cb, _ip6mr_fill_mroute,
2491                                     &mfc_unres_lock, &filter);
2492                 return skb->len ? : err;
2493         }
2494
2495         return mr_rtm_dumproute(skb, cb, ip6mr_mr_table_iter,
2496                                 _ip6mr_fill_mroute, &mfc_unres_lock, &filter);
2497 }