net/ipv6/route.c

   1 /*
   2  *      Linux INET6 implementation
   3  *      FIB front-end.
   4  *
   5  *      Authors:
   6  *      Pedro Roque             <roque@di.fc.ul.pt>
   7  *
   8  *      This program is free software; you can redistribute it and/or
   9  *      modify it under the terms of the GNU General Public License
  10  *      as published by the Free Software Foundation; either version
  11  *      2 of the License, or (at your option) any later version.
  12  */
  13
  14 /*      Changes:
  15  *
  16  *      YOSHIFUJI Hideaki @USAGI
  17  *              reworked default router selection.
  18  *              - respect outgoing interface
  19  *              - select from (probably) reachable routers (i.e.
  20  *              routers in REACHABLE, STALE, DELAY or PROBE states).
  21  *              - always select the same router if it is (probably)
  22  *              reachable.  otherwise, round-robin the list.
  23  *      Ville Nuorvala
  24  *              Fixed routing subtrees.
  25  */
  26
  27 #define pr_fmt(fmt) "IPv6: " fmt
  28
  29 #include <linux/capability.h>
  30 #include <linux/errno.h>
  31 #include <linux/export.h>
  32 #include <linux/types.h>
  33 #include <linux/times.h>
  34 #include <linux/socket.h>
  35 #include <linux/sockios.h>
  36 #include <linux/net.h>
  37 #include <linux/route.h>
  38 #include <linux/netdevice.h>
  39 #include <linux/in6.h>
  40 #include <linux/mroute6.h>
  41 #include <linux/init.h>
  42 #include <linux/if_arp.h>
  43 #include <linux/proc_fs.h>
  44 #include <linux/seq_file.h>
  45 #include <linux/nsproxy.h>
  46 #include <linux/slab.h>
  47 #include <net/net_namespace.h>
  48 #include <net/snmp.h>
  49 #include <net/ipv6.h>
  50 #include <net/ip6_fib.h>
  51 #include <net/ip6_route.h>
  52 #include <net/ndisc.h>
  53 #include <net/addrconf.h>
  54 #include <net/tcp.h>
  55 #include <linux/rtnetlink.h>
  56 #include <net/dst.h>
  57 #include <net/xfrm.h>
  58 #include <net/netevent.h>
  59 #include <net/netlink.h>
  60
  61 #include <asm/uaccess.h>
  62
  63 #ifdef CONFIG_SYSCTL
  64 #include <linux/sysctl.h>
  65 #endif
  66
  67 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
  68                                     const struct in6_addr *dest);
  69 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
  70 static unsigned int      ip6_default_advmss(const struct dst_entry *dst);
  71 static unsigned int      ip6_mtu(const struct dst_entry *dst);
  72 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
  73 static void             ip6_dst_destroy(struct dst_entry *);
  74 static void             ip6_dst_ifdown(struct dst_entry *,
  75                                        struct net_device *dev, int how);
  76 static int               ip6_dst_gc(struct dst_ops *ops);
  77
  78 static int              ip6_pkt_discard(struct sk_buff *skb);
  79 static int              ip6_pkt_discard_out(struct sk_buff *skb);
  80 static void             ip6_link_failure(struct sk_buff *skb);
  81 static void             ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
  82 static void             rt6_do_redirect(struct dst_entry *dst, struct sk_buff *skb);
  83
  84 #ifdef CONFIG_IPV6_ROUTE_INFO
  85 static struct rt6_info *rt6_add_route_info(struct net *net,
  86                                            const struct in6_addr *prefix, int prefixlen,
  87                                            const struct in6_addr *gwaddr, int ifindex,
  88                                            unsigned int pref);
  89 static struct rt6_info *rt6_get_route_info(struct net *net,
  90                                            const struct in6_addr *prefix, int prefixlen,
  91                                            const struct in6_addr *gwaddr, int ifindex);
  92 #endif
  93
  94 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
  95 {
  96         struct rt6_info *rt = (struct rt6_info *) dst;
  97         struct inet_peer *peer;
  98         u32 *p = NULL;
  99
 100         if (!(rt->dst.flags & DST_HOST))
 101                 return NULL;
 102
 103         peer = rt6_get_peer_create(rt);
 104         if (peer) {
 105                 u32 *old_p = __DST_METRICS_PTR(old);
 106                 unsigned long prev, new;
 107
 108                 p = peer->metrics;
 109                 if (inet_metrics_new(peer))
 110                         memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
 111
 112                 new = (unsigned long) p;
 113                 prev = cmpxchg(&dst->_metrics, old, new);
 114
 115                 if (prev != old) {
 116                         p = __DST_METRICS_PTR(prev);
 117                         if (prev & DST_METRICS_READ_ONLY)
 118                                 p = NULL;
 119                 }
 120         }
 121         return p;
 122 }
 123
 124 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
 125                                              struct sk_buff *skb,
 126                                              const void *daddr)
 127 {
 128         struct in6_addr *p = &rt->rt6i_gateway;
 129
 130         if (!ipv6_addr_any(p))
 131                 return (const void *) p;
 132         else if (skb)
 133                 return &ipv6_hdr(skb)->daddr;
 134         return daddr;
 135 }
 136
 137 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
 138                                           struct sk_buff *skb,
 139                                           const void *daddr)
 140 {
 141         struct rt6_info *rt = (struct rt6_info *) dst;
 142         struct neighbour *n;
 143
 144         daddr = choose_neigh_daddr(rt, skb, daddr);
 145         n = __ipv6_neigh_lookup(&nd_tbl, dst->dev, daddr);
 146         if (n)
 147                 return n;
 148         return neigh_create(&nd_tbl, daddr, dst->dev);
 149 }
 150
 151 static int rt6_bind_neighbour(struct rt6_info *rt, struct net_device *dev)
 152 {
 153         struct neighbour *n = __ipv6_neigh_lookup(&nd_tbl, dev, &rt->rt6i_gateway);
 154         if (!n) {
 155                 n = neigh_create(&nd_tbl, &rt->rt6i_gateway, dev);
 156                 if (IS_ERR(n))
 157                         return PTR_ERR(n);
 158         }
 159         rt->n = n;
 160
 161         return 0;
 162 }
 163
 164 static struct dst_ops ip6_dst_ops_template = {
 165         .family                 =       AF_INET6,
 166         .protocol               =       cpu_to_be16(ETH_P_IPV6),
 167         .gc                     =       ip6_dst_gc,
 168         .gc_thresh              =       1024,
 169         .check                  =       ip6_dst_check,
 170         .default_advmss         =       ip6_default_advmss,
 171         .mtu                    =       ip6_mtu,
 172         .cow_metrics            =       ipv6_cow_metrics,
 173         .destroy                =       ip6_dst_destroy,
 174         .ifdown                 =       ip6_dst_ifdown,
 175         .negative_advice        =       ip6_negative_advice,
 176         .link_failure           =       ip6_link_failure,
 177         .update_pmtu            =       ip6_rt_update_pmtu,
 178         .redirect               =       rt6_do_redirect,
 179         .local_out              =       __ip6_local_out,
 180         .neigh_lookup           =       ip6_neigh_lookup,
 181 };
 182
 183 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
 184 {
 185         unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
 186
 187         return mtu ? : dst->dev->mtu;
 188 }
 189
 190 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
 191 {
 192 }
 193
 194 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sk_buff *skb)
 195 {
 196 }
 197
 198 static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
 199                                          unsigned long old)
 200 {
 201         return NULL;
 202 }
 203
 204 static struct dst_ops ip6_dst_blackhole_ops = {
 205         .family                 =       AF_INET6,
 206         .protocol               =       cpu_to_be16(ETH_P_IPV6),
 207         .destroy                =       ip6_dst_destroy,
 208         .check                  =       ip6_dst_check,
 209         .mtu                    =       ip6_blackhole_mtu,
 210         .default_advmss         =       ip6_default_advmss,
 211         .update_pmtu            =       ip6_rt_blackhole_update_pmtu,
 212         .redirect               =       ip6_rt_blackhole_redirect,
 213         .cow_metrics            =       ip6_rt_blackhole_cow_metrics,
 214         .neigh_lookup           =       ip6_neigh_lookup,
 215 };
 216
 217 static const u32 ip6_template_metrics[RTAX_MAX] = {
 218         [RTAX_HOPLIMIT - 1] = 255,
 219 };
 220
 221 static struct rt6_info ip6_null_entry_template = {
 222         .dst = {
 223                 .__refcnt       = ATOMIC_INIT(1),
 224                 .__use          = 1,
 225                 .obsolete       = -1,
 226                 .error          = -ENETUNREACH,
 227                 .input          = ip6_pkt_discard,
 228                 .output         = ip6_pkt_discard_out,
 229         },
 230         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 231         .rt6i_protocol  = RTPROT_KERNEL,
 232         .rt6i_metric    = ~(u32) 0,
 233         .rt6i_ref       = ATOMIC_INIT(1),
 234 };
 235
 236 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 237
 238 static int ip6_pkt_prohibit(struct sk_buff *skb);
 239 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
 240
 241 static struct rt6_info ip6_prohibit_entry_template = {
 242         .dst = {
 243                 .__refcnt       = ATOMIC_INIT(1),
 244                 .__use          = 1,
 245                 .obsolete       = -1,
 246                 .error          = -EACCES,
 247                 .input          = ip6_pkt_prohibit,
 248                 .output         = ip6_pkt_prohibit_out,
 249         },
 250         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 251         .rt6i_protocol  = RTPROT_KERNEL,
 252         .rt6i_metric    = ~(u32) 0,
 253         .rt6i_ref       = ATOMIC_INIT(1),
 254 };
 255
 256 static struct rt6_info ip6_blk_hole_entry_template = {
 257         .dst = {
 258                 .__refcnt       = ATOMIC_INIT(1),
 259                 .__use          = 1,
 260                 .obsolete       = -1,
 261                 .error          = -EINVAL,
 262                 .input          = dst_discard,
 263                 .output         = dst_discard,
 264         },
 265         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 266         .rt6i_protocol  = RTPROT_KERNEL,
 267         .rt6i_metric    = ~(u32) 0,
 268         .rt6i_ref       = ATOMIC_INIT(1),
 269 };
 270
 271 #endif
 272
 273 /* allocate dst with ip6_dst_ops */
 274 static inline struct rt6_info *ip6_dst_alloc(struct net *net,
 275                                              struct net_device *dev,
 276                                              int flags,
 277                                              struct fib6_table *table)
 278 {
 279         struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
 280                                         0, 0, flags);
 281
 282         if (rt) {
 283                 memset(&rt->n, 0,
 284                        sizeof(*rt) - sizeof(struct dst_entry));
 285                 rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
 286         }
 287         return rt;
 288 }
 289
 290 static void ip6_dst_destroy(struct dst_entry *dst)
 291 {
 292         struct rt6_info *rt = (struct rt6_info *)dst;
 293         struct inet6_dev *idev = rt->rt6i_idev;
 294
 295         if (rt->n)
 296                 neigh_release(rt->n);
 297
 298         if (!(rt->dst.flags & DST_HOST))
 299                 dst_destroy_metrics_generic(dst);
 300
 301         if (idev) {
 302                 rt->rt6i_idev = NULL;
 303                 in6_dev_put(idev);
 304         }
 305
 306         if (!(rt->rt6i_flags & RTF_EXPIRES) && dst->from)
 307                 dst_release(dst->from);
 308
 309         if (rt6_has_peer(rt)) {
 310                 struct inet_peer *peer = rt6_peer_ptr(rt);
 311                 inet_putpeer(peer);
 312         }
 313 }
 314
 315 static atomic_t __rt6_peer_genid = ATOMIC_INIT(0);
 316
 317 static u32 rt6_peer_genid(void)
 318 {
 319         return atomic_read(&__rt6_peer_genid);
 320 }
 321
 322 void rt6_bind_peer(struct rt6_info *rt, int create)
 323 {
 324         struct inet_peer_base *base;
 325         struct inet_peer *peer;
 326
 327         base = inetpeer_base_ptr(rt->_rt6i_peer);
 328         if (!base)
 329                 return;
 330
 331         peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
 332         if (peer) {
 333                 if (!rt6_set_peer(rt, peer))
 334                         inet_putpeer(peer);
 335                 else
 336                         rt->rt6i_peer_genid = rt6_peer_genid();
 337         }
 338 }
 339
 340 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
 341                            int how)
 342 {
 343         struct rt6_info *rt = (struct rt6_info *)dst;
 344         struct inet6_dev *idev = rt->rt6i_idev;
 345         struct net_device *loopback_dev =
 346                 dev_net(dev)->loopback_dev;
 347
 348         if (dev != loopback_dev) {
 349                 if (idev && idev->dev == dev) {
 350                         struct inet6_dev *loopback_idev =
 351                                 in6_dev_get(loopback_dev);
 352                         if (loopback_idev) {
 353                                 rt->rt6i_idev = loopback_idev;
 354                                 in6_dev_put(idev);
 355                         }
 356                 }
 357                 if (rt->n && rt->n->dev == dev) {
 358                         rt->n->dev = loopback_dev;
 359                         dev_hold(loopback_dev);
 360                         dev_put(dev);
 361                 }
 362         }
 363 }
 364
 365 static bool rt6_check_expired(const struct rt6_info *rt)
 366 {
 367         struct rt6_info *ort = NULL;
 368
 369         if (rt->rt6i_flags & RTF_EXPIRES) {
 370                 if (time_after(jiffies, rt->dst.expires))
 371                         return true;
 372         } else if (rt->dst.from) {
 373                 ort = (struct rt6_info *) rt->dst.from;
 374                 return (ort->rt6i_flags & RTF_EXPIRES) &&
 375                         time_after(jiffies, ort->dst.expires);
 376         }
 377         return false;
 378 }
 379
 380 static bool rt6_need_strict(const struct in6_addr *daddr)
 381 {
 382         return ipv6_addr_type(daddr) &
 383                 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
 384 }
 385
 386 /*
 387  *      Route lookup. Any table->tb6_lock is implied.
 388  */
 389
 390 static inline struct rt6_info *rt6_device_match(struct net *net,
 391                                                     struct rt6_info *rt,
 392                                                     const struct in6_addr *saddr,
 393                                                     int oif,
 394                                                     int flags)
 395 {
 396         struct rt6_info *local = NULL;
 397         struct rt6_info *sprt;
 398
 399         if (!oif && ipv6_addr_any(saddr))
 400                 goto out;
 401
 402         for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
 403                 struct net_device *dev = sprt->dst.dev;
 404
 405                 if (oif) {
 406                         if (dev->ifindex == oif)
 407                                 return sprt;
 408                         if (dev->flags & IFF_LOOPBACK) {
 409                                 if (!sprt->rt6i_idev ||
 410                                     sprt->rt6i_idev->dev->ifindex != oif) {
 411                                         if (flags & RT6_LOOKUP_F_IFACE && oif)
 412                                                 continue;
 413                                         if (local && (!oif ||
 414                                                       local->rt6i_idev->dev->ifindex == oif))
 415                                                 continue;
 416                                 }
 417                                 local = sprt;
 418                         }
 419                 } else {
 420                         if (ipv6_chk_addr(net, saddr, dev,
 421                                           flags & RT6_LOOKUP_F_IFACE))
 422                                 return sprt;
 423                 }
 424         }
 425
 426         if (oif) {
 427                 if (local)
 428                         return local;
 429
 430                 if (flags & RT6_LOOKUP_F_IFACE)
 431                         return net->ipv6.ip6_null_entry;
 432         }
 433 out:
 434         return rt;
 435 }
 436
 437 #ifdef CONFIG_IPV6_ROUTER_PREF
 438 static void rt6_probe(struct rt6_info *rt)
 439 {
 440         struct neighbour *neigh;
 441         /*
 442          * Okay, this does not seem to be appropriate
 443          * for now, however, we need to check if it
 444          * is really so; aka Router Reachability Probing.
 445          *
 446          * Router Reachability Probe MUST be rate-limited
 447          * to no more than one per minute.
 448          */
 449         rcu_read_lock();
 450         neigh = rt ? rt->n : NULL;
 451         if (!neigh || (neigh->nud_state & NUD_VALID))
 452                 goto out;
 453         read_lock_bh(&neigh->lock);
 454         if (!(neigh->nud_state & NUD_VALID) &&
 455             time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
 456                 struct in6_addr mcaddr;
 457                 struct in6_addr *target;
 458
 459                 neigh->updated = jiffies;
 460                 read_unlock_bh(&neigh->lock);
 461
 462                 target = (struct in6_addr *)&neigh->primary_key;
 463                 addrconf_addr_solict_mult(target, &mcaddr);
 464                 ndisc_send_ns(rt->dst.dev, NULL, target, &mcaddr, NULL);
 465         } else {
 466                 read_unlock_bh(&neigh->lock);
 467         }
 468 out:
 469         rcu_read_unlock();
 470 }
 471 #else
 472 static inline void rt6_probe(struct rt6_info *rt)
 473 {
 474 }
 475 #endif
 476
 477 /*
 478  * Default Router Selection (RFC 2461 6.3.6)
 479  */
 480 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
 481 {
 482         struct net_device *dev = rt->dst.dev;
 483         if (!oif || dev->ifindex == oif)
 484                 return 2;
 485         if ((dev->flags & IFF_LOOPBACK) &&
 486             rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
 487                 return 1;
 488         return 0;
 489 }
 490
 491 static inline int rt6_check_neigh(struct rt6_info *rt)
 492 {
 493         struct neighbour *neigh;
 494         int m;
 495
 496         rcu_read_lock();
 497         neigh = rt->n;
 498         if (rt->rt6i_flags & RTF_NONEXTHOP ||
 499             !(rt->rt6i_flags & RTF_GATEWAY))
 500                 m = 1;
 501         else if (neigh) {
 502                 read_lock_bh(&neigh->lock);
 503                 if (neigh->nud_state & NUD_VALID)
 504                         m = 2;
 505 #ifdef CONFIG_IPV6_ROUTER_PREF
 506                 else if (neigh->nud_state & NUD_FAILED)
 507                         m = 0;
 508 #endif
 509                 else
 510                         m = 1;
 511                 read_unlock_bh(&neigh->lock);
 512         } else
 513                 m = 0;
 514         rcu_read_unlock();
 515         return m;
 516 }
 517
 518 static int rt6_score_route(struct rt6_info *rt, int oif,
 519                            int strict)
 520 {
 521         int m, n;
 522
 523         m = rt6_check_dev(rt, oif);
 524         if (!m && (strict & RT6_LOOKUP_F_IFACE))
 525                 return -1;
 526 #ifdef CONFIG_IPV6_ROUTER_PREF
 527         m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
 528 #endif
 529         n = rt6_check_neigh(rt);
 530         if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
 531                 return -1;
 532         return m;
 533 }
 534
 535 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
 536                                    int *mpri, struct rt6_info *match)
 537 {
 538         int m;
 539
 540         if (rt6_check_expired(rt))
 541                 goto out;
 542
 543         m = rt6_score_route(rt, oif, strict);
 544         if (m < 0)
 545                 goto out;
 546
 547         if (m > *mpri) {
 548                 if (strict & RT6_LOOKUP_F_REACHABLE)
 549                         rt6_probe(match);
 550                 *mpri = m;
 551                 match = rt;
 552         } else if (strict & RT6_LOOKUP_F_REACHABLE) {
 553                 rt6_probe(rt);
 554         }
 555
 556 out:
 557         return match;
 558 }
 559
 560 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
 561                                      struct rt6_info *rr_head,
 562                                      u32 metric, int oif, int strict)
 563 {
 564         struct rt6_info *rt, *match;
 565         int mpri = -1;
 566
 567         match = NULL;
 568         for (rt = rr_head; rt && rt->rt6i_metric == metric;
 569              rt = rt->dst.rt6_next)
 570                 match = find_match(rt, oif, strict, &mpri, match);
 571         for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
 572              rt = rt->dst.rt6_next)
 573                 match = find_match(rt, oif, strict, &mpri, match);
 574
 575         return match;
 576 }
 577
 578 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
 579 {
 580         struct rt6_info *match, *rt0;
 581         struct net *net;
 582
 583         rt0 = fn->rr_ptr;
 584         if (!rt0)
 585                 fn->rr_ptr = rt0 = fn->leaf;
 586
 587         match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
 588
 589         if (!match &&
 590             (strict & RT6_LOOKUP_F_REACHABLE)) {
 591                 struct rt6_info *next = rt0->dst.rt6_next;
 592
 593                 /* no entries matched; do round-robin */
 594                 if (!next || next->rt6i_metric != rt0->rt6i_metric)
 595                         next = fn->leaf;
 596
 597                 if (next != rt0)
 598                         fn->rr_ptr = next;
 599         }
 600
 601         net = dev_net(rt0->dst.dev);
 602         return match ? match : net->ipv6.ip6_null_entry;
 603 }
 604
 605 #ifdef CONFIG_IPV6_ROUTE_INFO
 606 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
 607                   const struct in6_addr *gwaddr)
 608 {
 609         struct net *net = dev_net(dev);
 610         struct route_info *rinfo = (struct route_info *) opt;
 611         struct in6_addr prefix_buf, *prefix;
 612         unsigned int pref;
 613         unsigned long lifetime;
 614         struct rt6_info *rt;
 615
 616         if (len < sizeof(struct route_info)) {
 617                 return -EINVAL;
 618         }
 619
 620         /* Sanity check for prefix_len and length */
 621         if (rinfo->length > 3) {
 622                 return -EINVAL;
 623         } else if (rinfo->prefix_len > 128) {
 624                 return -EINVAL;
 625         } else if (rinfo->prefix_len > 64) {
 626                 if (rinfo->length < 2) {
 627                         return -EINVAL;
 628                 }
 629         } else if (rinfo->prefix_len > 0) {
 630                 if (rinfo->length < 1) {
 631                         return -EINVAL;
 632                 }
 633         }
 634
 635         pref = rinfo->route_pref;
 636         if (pref == ICMPV6_ROUTER_PREF_INVALID)
 637                 return -EINVAL;
 638
 639         lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
 640
 641         if (rinfo->length == 3)
 642                 prefix = (struct in6_addr *)rinfo->prefix;
 643         else {
 644                 /* this function is safe */
 645                 ipv6_addr_prefix(&prefix_buf,
 646                                  (struct in6_addr *)rinfo->prefix,
 647                                  rinfo->prefix_len);
 648                 prefix = &prefix_buf;
 649         }
 650
 651         rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
 652                                 dev->ifindex);
 653
 654         if (rt && !lifetime) {
 655                 ip6_del_rt(rt);
 656                 rt = NULL;
 657         }
 658
 659         if (!rt && lifetime)
 660                 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
 661                                         pref);
 662         else if (rt)
 663                 rt->rt6i_flags = RTF_ROUTEINFO |
 664                                  (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
 665
 666         if (rt) {
 667                 if (!addrconf_finite_timeout(lifetime))
 668                         rt6_clean_expires(rt);
 669                 else
 670                         rt6_set_expires(rt, jiffies + HZ * lifetime);
 671
 672                 dst_release(&rt->dst);
 673         }
 674         return 0;
 675 }
 676 #endif
 677
 678 #define BACKTRACK(__net, saddr)                 \
 679 do { \
 680         if (rt == __net->ipv6.ip6_null_entry) { \
 681                 struct fib6_node *pn; \
 682                 while (1) { \
 683                         if (fn->fn_flags & RTN_TL_ROOT) \
 684                                 goto out; \
 685                         pn = fn->parent; \
 686                         if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
 687                                 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
 688                         else \
 689                                 fn = pn; \
 690                         if (fn->fn_flags & RTN_RTINFO) \
 691                                 goto restart; \
 692                 } \
 693         } \
 694 } while (0)
 695
 696 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
 697                                              struct fib6_table *table,
 698                                              struct flowi6 *fl6, int flags)
 699 {
 700         struct fib6_node *fn;
 701         struct rt6_info *rt;
 702
 703         read_lock_bh(&table->tb6_lock);
 704         fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
 705 restart:
 706         rt = fn->leaf;
 707         rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
 708         BACKTRACK(net, &fl6->saddr);
 709 out:
 710         dst_use(&rt->dst, jiffies);
 711         read_unlock_bh(&table->tb6_lock);
 712         return rt;
 713
 714 }
 715
 716 struct dst_entry * ip6_route_lookup(struct net *net, struct flowi6 *fl6,
 717                                     int flags)
 718 {
 719         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
 720 }
 721 EXPORT_SYMBOL_GPL(ip6_route_lookup);
 722
 723 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
 724                             const struct in6_addr *saddr, int oif, int strict)
 725 {
 726         struct flowi6 fl6 = {
 727                 .flowi6_oif = oif,
 728                 .daddr = *daddr,
 729         };
 730         struct dst_entry *dst;
 731         int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
 732
 733         if (saddr) {
 734                 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
 735                 flags |= RT6_LOOKUP_F_HAS_SADDR;
 736         }
 737
 738         dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
 739         if (dst->error == 0)
 740                 return (struct rt6_info *) dst;
 741
 742         dst_release(dst);
 743
 744         return NULL;
 745 }
 746
 747 EXPORT_SYMBOL(rt6_lookup);
 748
 749 /* ip6_ins_rt is called with FREE table->tb6_lock.
 750    It takes new route entry, the addition fails by any reason the
 751    route is freed. In any case, if caller does not hold it, it may
 752    be destroyed.
 753  */
 754
 755 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
 756 {
 757         int err;
 758         struct fib6_table *table;
 759
 760         table = rt->rt6i_table;
 761         write_lock_bh(&table->tb6_lock);
 762         err = fib6_add(&table->tb6_root, rt, info);
 763         write_unlock_bh(&table->tb6_lock);
 764
 765         return err;
 766 }
 767
 768 int ip6_ins_rt(struct rt6_info *rt)
 769 {
 770         struct nl_info info = {
 771                 .nl_net = dev_net(rt->dst.dev),
 772         };
 773         return __ip6_ins_rt(rt, &info);
 774 }
 775
 776 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
 777                                       const struct in6_addr *daddr,
 778                                       const struct in6_addr *saddr)
 779 {
 780         struct rt6_info *rt;
 781
 782         /*
 783          *      Clone the route.
 784          */
 785
 786         rt = ip6_rt_copy(ort, daddr);
 787
 788         if (rt) {
 789                 int attempts = !in_softirq();
 790
 791                 if (!(rt->rt6i_flags & RTF_GATEWAY)) {
 792                         if (ort->rt6i_dst.plen != 128 &&
 793                             ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
 794                                 rt->rt6i_flags |= RTF_ANYCAST;
 795                         rt->rt6i_gateway = *daddr;
 796                 }
 797
 798                 rt->rt6i_flags |= RTF_CACHE;
 799
 800 #ifdef CONFIG_IPV6_SUBTREES
 801                 if (rt->rt6i_src.plen && saddr) {
 802                         rt->rt6i_src.addr = *saddr;
 803                         rt->rt6i_src.plen = 128;
 804                 }
 805 #endif
 806
 807         retry:
 808                 if (rt6_bind_neighbour(rt, rt->dst.dev)) {
 809                         struct net *net = dev_net(rt->dst.dev);
 810                         int saved_rt_min_interval =
 811                                 net->ipv6.sysctl.ip6_rt_gc_min_interval;
 812                         int saved_rt_elasticity =
 813                                 net->ipv6.sysctl.ip6_rt_gc_elasticity;
 814
 815                         if (attempts-- > 0) {
 816                                 net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
 817                                 net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
 818
 819                                 ip6_dst_gc(&net->ipv6.ip6_dst_ops);
 820
 821                                 net->ipv6.sysctl.ip6_rt_gc_elasticity =
 822                                         saved_rt_elasticity;
 823                                 net->ipv6.sysctl.ip6_rt_gc_min_interval =
 824                                         saved_rt_min_interval;
 825                                 goto retry;
 826                         }
 827
 828                         net_warn_ratelimited("Neighbour table overflow\n");
 829                         dst_free(&rt->dst);
 830                         return NULL;
 831                 }
 832         }
 833
 834         return rt;
 835 }
 836
 837 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
 838                                         const struct in6_addr *daddr)
 839 {
 840         struct rt6_info *rt = ip6_rt_copy(ort, daddr);
 841
 842         if (rt) {
 843                 rt->rt6i_flags |= RTF_CACHE;
 844                 rt->n = neigh_clone(ort->n);
 845         }
 846         return rt;
 847 }
 848
 849 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
 850                                       struct flowi6 *fl6, int flags)
 851 {
 852         struct fib6_node *fn;
 853         struct rt6_info *rt, *nrt;
 854         int strict = 0;
 855         int attempts = 3;
 856         int err;
 857         int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
 858
 859         strict |= flags & RT6_LOOKUP_F_IFACE;
 860
 861 relookup:
 862         read_lock_bh(&table->tb6_lock);
 863
 864 restart_2:
 865         fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
 866
 867 restart:
 868         rt = rt6_select(fn, oif, strict | reachable);
 869
 870         BACKTRACK(net, &fl6->saddr);
 871         if (rt == net->ipv6.ip6_null_entry ||
 872             rt->rt6i_flags & RTF_CACHE)
 873                 goto out;
 874
 875         dst_hold(&rt->dst);
 876         read_unlock_bh(&table->tb6_lock);
 877
 878         if (!rt->n && !(rt->rt6i_flags & RTF_NONEXTHOP))
 879                 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
 880         else if (!(rt->dst.flags & DST_HOST))
 881                 nrt = rt6_alloc_clone(rt, &fl6->daddr);
 882         else
 883                 goto out2;
 884
 885         dst_release(&rt->dst);
 886         rt = nrt ? : net->ipv6.ip6_null_entry;
 887
 888         dst_hold(&rt->dst);
 889         if (nrt) {
 890                 err = ip6_ins_rt(nrt);
 891                 if (!err)
 892                         goto out2;
 893         }
 894
 895         if (--attempts <= 0)
 896                 goto out2;
 897
 898         /*
 899          * Race condition! In the gap, when table->tb6_lock was
 900          * released someone could insert this route.  Relookup.
 901          */
 902         dst_release(&rt->dst);
 903         goto relookup;
 904
 905 out:
 906         if (reachable) {
 907                 reachable = 0;
 908                 goto restart_2;
 909         }
 910         dst_hold(&rt->dst);
 911         read_unlock_bh(&table->tb6_lock);
 912 out2:
 913         rt->dst.lastuse = jiffies;
 914         rt->dst.__use++;
 915
 916         return rt;
 917 }
 918
 919 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
 920                                             struct flowi6 *fl6, int flags)
 921 {
 922         return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
 923 }
 924
 925 static struct dst_entry *ip6_route_input_lookup(struct net *net,
 926                                                 struct net_device *dev,
 927                                                 struct flowi6 *fl6, int flags)
 928 {
 929         if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
 930                 flags |= RT6_LOOKUP_F_IFACE;
 931
 932         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
 933 }
 934
 935 void ip6_route_input(struct sk_buff *skb)
 936 {
 937         const struct ipv6hdr *iph = ipv6_hdr(skb);
 938         struct net *net = dev_net(skb->dev);
 939         int flags = RT6_LOOKUP_F_HAS_SADDR;
 940         struct flowi6 fl6 = {
 941                 .flowi6_iif = skb->dev->ifindex,
 942                 .daddr = iph->daddr,
 943                 .saddr = iph->saddr,
 944                 .flowlabel = (* (__be32 *) iph) & IPV6_FLOWINFO_MASK,
 945                 .flowi6_mark = skb->mark,
 946                 .flowi6_proto = iph->nexthdr,
 947         };
 948
 949         skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
 950 }
 951
 952 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
 953                                              struct flowi6 *fl6, int flags)
 954 {
 955         return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
 956 }
 957
 958 struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
 959                                     struct flowi6 *fl6)
 960 {
 961         int flags = 0;
 962
 963         fl6->flowi6_iif = net->loopback_dev->ifindex;
 964
 965         if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
 966                 flags |= RT6_LOOKUP_F_IFACE;
 967
 968         if (!ipv6_addr_any(&fl6->saddr))
 969                 flags |= RT6_LOOKUP_F_HAS_SADDR;
 970         else if (sk)
 971                 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
 972
 973         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
 974 }
 975
 976 EXPORT_SYMBOL(ip6_route_output);
 977
 978 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
 979 {
 980         struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
 981         struct dst_entry *new = NULL;
 982
 983         rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, 0, 0);
 984         if (rt) {
 985                 memset(&rt->rt6i_table, 0, sizeof(*rt) - sizeof(struct dst_entry));
 986                 rt6_init_peer(rt, net->ipv6.peers);
 987
 988                 new = &rt->dst;
 989
 990                 new->__use = 1;
 991                 new->input = dst_discard;
 992                 new->output = dst_discard;
 993
 994                 if (dst_metrics_read_only(&ort->dst))
 995                         new->_metrics = ort->dst._metrics;
 996                 else
 997                         dst_copy_metrics(new, &ort->dst);
 998                 rt->rt6i_idev = ort->rt6i_idev;
 999                 if (rt->rt6i_idev)
1000                         in6_dev_hold(rt->rt6i_idev);
1001
1002                 rt->rt6i_gateway = ort->rt6i_gateway;
1003                 rt->rt6i_flags = ort->rt6i_flags;
1004                 rt6_clean_expires(rt);
1005                 rt->rt6i_metric = 0;
1006
1007                 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1008 #ifdef CONFIG_IPV6_SUBTREES
1009                 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1010 #endif
1011
1012                 dst_free(new);
1013         }
1014
1015         dst_release(dst_orig);
1016         return new ? new : ERR_PTR(-ENOMEM);
1017 }
1018
1019 /*
1020  *      Destination cache support functions
1021  */
1022
1023 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1024 {
1025         struct rt6_info *rt;
1026
1027         rt = (struct rt6_info *) dst;
1028
1029         if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie)) {
1030                 if (rt->rt6i_peer_genid != rt6_peer_genid()) {
1031                         if (!rt6_has_peer(rt))
1032                                 rt6_bind_peer(rt, 0);
1033                         rt->rt6i_peer_genid = rt6_peer_genid();
1034                 }
1035                 return dst;
1036         }
1037         return NULL;
1038 }
1039
1040 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1041 {
1042         struct rt6_info *rt = (struct rt6_info *) dst;
1043
1044         if (rt) {
1045                 if (rt->rt6i_flags & RTF_CACHE) {
1046                         if (rt6_check_expired(rt)) {
1047                                 ip6_del_rt(rt);
1048                                 dst = NULL;
1049                         }
1050                 } else {
1051                         dst_release(dst);
1052                         dst = NULL;
1053                 }
1054         }
1055         return dst;
1056 }
1057
1058 static void ip6_link_failure(struct sk_buff *skb)
1059 {
1060         struct rt6_info *rt;
1061
1062         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1063
1064         rt = (struct rt6_info *) skb_dst(skb);
1065         if (rt) {
1066                 if (rt->rt6i_flags & RTF_CACHE)
1067                         rt6_update_expires(rt, 0);
1068                 else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
1069                         rt->rt6i_node->fn_sernum = -1;
1070         }
1071 }
1072
1073 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
1074 {
1075         struct rt6_info *rt6 = (struct rt6_info*)dst;
1076
1077         dst_confirm(dst);
1078         if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
1079                 struct net *net = dev_net(dst->dev);
1080
1081                 rt6->rt6i_flags |= RTF_MODIFIED;
1082                 if (mtu < IPV6_MIN_MTU) {
1083                         u32 features = dst_metric(dst, RTAX_FEATURES);
1084                         mtu = IPV6_MIN_MTU;
1085                         features |= RTAX_FEATURE_ALLFRAG;
1086                         dst_metric_set(dst, RTAX_FEATURES, features);
1087                 }
1088                 dst_metric_set(dst, RTAX_MTU, mtu);
1089                 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1090         }
1091 }
1092
1093 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1094                      int oif, u32 mark)
1095 {
1096         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1097         struct dst_entry *dst;
1098         struct flowi6 fl6;
1099
1100         memset(&fl6, 0, sizeof(fl6));
1101         fl6.flowi6_oif = oif;
1102         fl6.flowi6_mark = mark;
1103         fl6.flowi6_flags = 0;
1104         fl6.daddr = iph->daddr;
1105         fl6.saddr = iph->saddr;
1106         fl6.flowlabel = (*(__be32 *) iph) & IPV6_FLOWINFO_MASK;
1107
1108         dst = ip6_route_output(net, NULL, &fl6);
1109         if (!dst->error)
1110                 ip6_rt_update_pmtu(dst, ntohl(mtu));
1111         dst_release(dst);
1112 }
1113 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1114
1115 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1116 {
1117         ip6_update_pmtu(skb, sock_net(sk), mtu,
1118                         sk->sk_bound_dev_if, sk->sk_mark);
1119 }
1120 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1121
1122 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1123 {
1124         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1125         struct dst_entry *dst;
1126         struct flowi6 fl6;
1127
1128         memset(&fl6, 0, sizeof(fl6));
1129         fl6.flowi6_oif = oif;
1130         fl6.flowi6_mark = mark;
1131         fl6.flowi6_flags = 0;
1132         fl6.daddr = iph->daddr;
1133         fl6.saddr = iph->saddr;
1134         fl6.flowlabel = (*(__be32 *) iph) & IPV6_FLOWINFO_MASK;
1135
1136         dst = ip6_route_output(net, NULL, &fl6);
1137         if (!dst->error)
1138                 rt6_do_redirect(dst, skb);
1139         dst_release(dst);
1140 }
1141 EXPORT_SYMBOL_GPL(ip6_redirect);
1142
1143 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1144 {
1145         ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1146 }
1147 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1148
1149 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1150 {
1151         struct net_device *dev = dst->dev;
1152         unsigned int mtu = dst_mtu(dst);
1153         struct net *net = dev_net(dev);
1154
1155         mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1156
1157         if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1158                 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1159
1160         /*
1161          * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1162          * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1163          * IPV6_MAXPLEN is also valid and means: "any MSS,
1164          * rely only on pmtu discovery"
1165          */
1166         if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1167                 mtu = IPV6_MAXPLEN;
1168         return mtu;
1169 }
1170
1171 static unsigned int ip6_mtu(const struct dst_entry *dst)
1172 {
1173         struct inet6_dev *idev;
1174         unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1175
1176         if (mtu)
1177                 return mtu;
1178
1179         mtu = IPV6_MIN_MTU;
1180
1181         rcu_read_lock();
1182         idev = __in6_dev_get(dst->dev);
1183         if (idev)
1184                 mtu = idev->cnf.mtu6;
1185         rcu_read_unlock();
1186
1187         return mtu;
1188 }
1189
1190 static struct dst_entry *icmp6_dst_gc_list;
1191 static DEFINE_SPINLOCK(icmp6_dst_lock);
1192
1193 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1194                                   struct neighbour *neigh,
1195                                   struct flowi6 *fl6)
1196 {
1197         struct dst_entry *dst;
1198         struct rt6_info *rt;
1199         struct inet6_dev *idev = in6_dev_get(dev);
1200         struct net *net = dev_net(dev);
1201
1202         if (unlikely(!idev))
1203                 return ERR_PTR(-ENODEV);
1204
1205         rt = ip6_dst_alloc(net, dev, 0, NULL);
1206         if (unlikely(!rt)) {
1207                 in6_dev_put(idev);
1208                 dst = ERR_PTR(-ENOMEM);
1209                 goto out;
1210         }
1211
1212         if (neigh)
1213                 neigh_hold(neigh);
1214         else {
1215                 neigh = ip6_neigh_lookup(&rt->dst, NULL, &fl6->daddr);
1216                 if (IS_ERR(neigh)) {
1217                         in6_dev_put(idev);
1218                         dst_free(&rt->dst);
1219                         return ERR_CAST(neigh);
1220                 }
1221         }
1222
1223         rt->dst.flags |= DST_HOST;
1224         rt->dst.output  = ip6_output;
1225         rt->n = neigh;
1226         atomic_set(&rt->dst.__refcnt, 1);
1227         rt->rt6i_dst.addr = fl6->daddr;
1228         rt->rt6i_dst.plen = 128;
1229         rt->rt6i_idev     = idev;
1230         dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 255);
1231
1232         spin_lock_bh(&icmp6_dst_lock);
1233         rt->dst.next = icmp6_dst_gc_list;
1234         icmp6_dst_gc_list = &rt->dst;
1235         spin_unlock_bh(&icmp6_dst_lock);
1236
1237         fib6_force_start_gc(net);
1238
1239         dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1240
1241 out:
1242         return dst;
1243 }
1244
1245 int icmp6_dst_gc(void)
1246 {
1247         struct dst_entry *dst, **pprev;
1248         int more = 0;
1249
1250         spin_lock_bh(&icmp6_dst_lock);
1251         pprev = &icmp6_dst_gc_list;
1252
1253         while ((dst = *pprev) != NULL) {
1254                 if (!atomic_read(&dst->__refcnt)) {
1255                         *pprev = dst->next;
1256                         dst_free(dst);
1257                 } else {
1258                         pprev = &dst->next;
1259                         ++more;
1260                 }
1261         }
1262
1263         spin_unlock_bh(&icmp6_dst_lock);
1264
1265         return more;
1266 }
1267
1268 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1269                             void *arg)
1270 {
1271         struct dst_entry *dst, **pprev;
1272
1273         spin_lock_bh(&icmp6_dst_lock);
1274         pprev = &icmp6_dst_gc_list;
1275         while ((dst = *pprev) != NULL) {
1276                 struct rt6_info *rt = (struct rt6_info *) dst;
1277                 if (func(rt, arg)) {
1278                         *pprev = dst->next;
1279                         dst_free(dst);
1280                 } else {
1281                         pprev = &dst->next;
1282                 }
1283         }
1284         spin_unlock_bh(&icmp6_dst_lock);
1285 }
1286
1287 static int ip6_dst_gc(struct dst_ops *ops)
1288 {
1289         unsigned long now = jiffies;
1290         struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1291         int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1292         int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1293         int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1294         int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1295         unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1296         int entries;
1297
1298         entries = dst_entries_get_fast(ops);
1299         if (time_after(rt_last_gc + rt_min_interval, now) &&
1300             entries <= rt_max_size)
1301                 goto out;
1302
1303         net->ipv6.ip6_rt_gc_expire++;
1304         fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1305         net->ipv6.ip6_rt_last_gc = now;
1306         entries = dst_entries_get_slow(ops);
1307         if (entries < ops->gc_thresh)
1308                 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1309 out:
1310         net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1311         return entries > rt_max_size;
1312 }
1313
1314 /* Clean host part of a prefix. Not necessary in radix tree,
1315    but results in cleaner routing tables.
1316
1317    Remove it only when all the things will work!
1318  */
1319
1320 int ip6_dst_hoplimit(struct dst_entry *dst)
1321 {
1322         int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
1323         if (hoplimit == 0) {
1324                 struct net_device *dev = dst->dev;
1325                 struct inet6_dev *idev;
1326
1327                 rcu_read_lock();
1328                 idev = __in6_dev_get(dev);
1329                 if (idev)
1330                         hoplimit = idev->cnf.hop_limit;
1331                 else
1332                         hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
1333                 rcu_read_unlock();
1334         }
1335         return hoplimit;
1336 }
1337 EXPORT_SYMBOL(ip6_dst_hoplimit);
1338
1339 /*
1340  *
1341  */
1342
1343 int ip6_route_add(struct fib6_config *cfg)
1344 {
1345         int err;
1346         struct net *net = cfg->fc_nlinfo.nl_net;
1347         struct rt6_info *rt = NULL;
1348         struct net_device *dev = NULL;
1349         struct inet6_dev *idev = NULL;
1350         struct fib6_table *table;
1351         int addr_type;
1352
1353         if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1354                 return -EINVAL;
1355 #ifndef CONFIG_IPV6_SUBTREES
1356         if (cfg->fc_src_len)
1357                 return -EINVAL;
1358 #endif
1359         if (cfg->fc_ifindex) {
1360                 err = -ENODEV;
1361                 dev = dev_get_by_index(net, cfg->fc_ifindex);
1362                 if (!dev)
1363                         goto out;
1364                 idev = in6_dev_get(dev);
1365                 if (!idev)
1366                         goto out;
1367         }
1368
1369         if (cfg->fc_metric == 0)
1370                 cfg->fc_metric = IP6_RT_PRIO_USER;
1371
1372         err = -ENOBUFS;
1373         if (cfg->fc_nlinfo.nlh &&
1374             !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1375                 table = fib6_get_table(net, cfg->fc_table);
1376                 if (!table) {
1377                         pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1378                         table = fib6_new_table(net, cfg->fc_table);
1379                 }
1380         } else {
1381                 table = fib6_new_table(net, cfg->fc_table);
1382         }
1383
1384         if (!table)
1385                 goto out;
1386
1387         rt = ip6_dst_alloc(net, NULL, DST_NOCOUNT, table);
1388
1389         if (!rt) {
1390                 err = -ENOMEM;
1391                 goto out;
1392         }
1393
1394         rt->dst.obsolete = -1;
1395
1396         if (cfg->fc_flags & RTF_EXPIRES)
1397                 rt6_set_expires(rt, jiffies +
1398                                 clock_t_to_jiffies(cfg->fc_expires));
1399         else
1400                 rt6_clean_expires(rt);
1401
1402         if (cfg->fc_protocol == RTPROT_UNSPEC)
1403                 cfg->fc_protocol = RTPROT_BOOT;
1404         rt->rt6i_protocol = cfg->fc_protocol;
1405
1406         addr_type = ipv6_addr_type(&cfg->fc_dst);
1407
1408         if (addr_type & IPV6_ADDR_MULTICAST)
1409                 rt->dst.input = ip6_mc_input;
1410         else if (cfg->fc_flags & RTF_LOCAL)
1411                 rt->dst.input = ip6_input;
1412         else
1413                 rt->dst.input = ip6_forward;
1414
1415         rt->dst.output = ip6_output;
1416
1417         ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1418         rt->rt6i_dst.plen = cfg->fc_dst_len;
1419         if (rt->rt6i_dst.plen == 128)
1420                rt->dst.flags |= DST_HOST;
1421
1422         if (!(rt->dst.flags & DST_HOST) && cfg->fc_mx) {
1423                 u32 *metrics = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1424                 if (!metrics) {
1425                         err = -ENOMEM;
1426                         goto out;
1427                 }
1428                 dst_init_metrics(&rt->dst, metrics, 0);
1429         }
1430 #ifdef CONFIG_IPV6_SUBTREES
1431         ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1432         rt->rt6i_src.plen = cfg->fc_src_len;
1433 #endif
1434
1435         rt->rt6i_metric = cfg->fc_metric;
1436
1437         /* We cannot add true routes via loopback here,
1438            they would result in kernel looping; promote them to reject routes
1439          */
1440         if ((cfg->fc_flags & RTF_REJECT) ||
1441             (dev && (dev->flags & IFF_LOOPBACK) &&
1442              !(addr_type & IPV6_ADDR_LOOPBACK) &&
1443              !(cfg->fc_flags & RTF_LOCAL))) {
1444                 /* hold loopback dev/idev if we haven't done so. */
1445                 if (dev != net->loopback_dev) {
1446                         if (dev) {
1447                                 dev_put(dev);
1448                                 in6_dev_put(idev);
1449                         }
1450                         dev = net->loopback_dev;
1451                         dev_hold(dev);
1452                         idev = in6_dev_get(dev);
1453                         if (!idev) {
1454                                 err = -ENODEV;
1455                                 goto out;
1456                         }
1457                 }
1458                 rt->dst.output = ip6_pkt_discard_out;
1459                 rt->dst.input = ip6_pkt_discard;
1460                 rt->dst.error = -ENETUNREACH;
1461                 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1462                 goto install_route;
1463         }
1464
1465         if (cfg->fc_flags & RTF_GATEWAY) {
1466                 const struct in6_addr *gw_addr;
1467                 int gwa_type;
1468
1469                 gw_addr = &cfg->fc_gateway;
1470                 rt->rt6i_gateway = *gw_addr;
1471                 gwa_type = ipv6_addr_type(gw_addr);
1472
1473                 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1474                         struct rt6_info *grt;
1475
1476                         /* IPv6 strictly inhibits using not link-local
1477                            addresses as nexthop address.
1478                            Otherwise, router will not able to send redirects.
1479                            It is very good, but in some (rare!) circumstances
1480                            (SIT, PtP, NBMA NOARP links) it is handy to allow
1481                            some exceptions. --ANK
1482                          */
1483                         err = -EINVAL;
1484                         if (!(gwa_type & IPV6_ADDR_UNICAST))
1485                                 goto out;
1486
1487                         grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1488
1489                         err = -EHOSTUNREACH;
1490                         if (!grt)
1491                                 goto out;
1492                         if (dev) {
1493                                 if (dev != grt->dst.dev) {
1494                                         dst_release(&grt->dst);
1495                                         goto out;
1496                                 }
1497                         } else {
1498                                 dev = grt->dst.dev;
1499                                 idev = grt->rt6i_idev;
1500                                 dev_hold(dev);
1501                                 in6_dev_hold(grt->rt6i_idev);
1502                         }
1503                         if (!(grt->rt6i_flags & RTF_GATEWAY))
1504                                 err = 0;
1505                         dst_release(&grt->dst);
1506
1507                         if (err)
1508                                 goto out;
1509                 }
1510                 err = -EINVAL;
1511                 if (!dev || (dev->flags & IFF_LOOPBACK))
1512                         goto out;
1513         }
1514
1515         err = -ENODEV;
1516         if (!dev)
1517                 goto out;
1518
1519         if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1520                 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1521                         err = -EINVAL;
1522                         goto out;
1523                 }
1524                 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1525                 rt->rt6i_prefsrc.plen = 128;
1526         } else
1527                 rt->rt6i_prefsrc.plen = 0;
1528
1529         if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1530                 err = rt6_bind_neighbour(rt, dev);
1531                 if (err)
1532                         goto out;
1533         }
1534
1535         rt->rt6i_flags = cfg->fc_flags;
1536
1537 install_route:
1538         if (cfg->fc_mx) {
1539                 struct nlattr *nla;
1540                 int remaining;
1541
1542                 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1543                         int type = nla_type(nla);
1544
1545                         if (type) {
1546                                 if (type > RTAX_MAX) {
1547                                         err = -EINVAL;
1548                                         goto out;
1549                                 }
1550
1551                                 dst_metric_set(&rt->dst, type, nla_get_u32(nla));
1552                         }
1553                 }
1554         }
1555
1556         rt->dst.dev = dev;
1557         rt->rt6i_idev = idev;
1558         rt->rt6i_table = table;
1559
1560         cfg->fc_nlinfo.nl_net = dev_net(dev);
1561
1562         return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1563
1564 out:
1565         if (dev)
1566                 dev_put(dev);
1567         if (idev)
1568                 in6_dev_put(idev);
1569         if (rt)
1570                 dst_free(&rt->dst);
1571         return err;
1572 }
1573
1574 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1575 {
1576         int err;
1577         struct fib6_table *table;
1578         struct net *net = dev_net(rt->dst.dev);
1579
1580         if (rt == net->ipv6.ip6_null_entry)
1581                 return -ENOENT;
1582
1583         table = rt->rt6i_table;
1584         write_lock_bh(&table->tb6_lock);
1585
1586         err = fib6_del(rt, info);
1587         dst_release(&rt->dst);
1588
1589         write_unlock_bh(&table->tb6_lock);
1590
1591         return err;
1592 }
1593
1594 int ip6_del_rt(struct rt6_info *rt)
1595 {
1596         struct nl_info info = {
1597                 .nl_net = dev_net(rt->dst.dev),
1598         };
1599         return __ip6_del_rt(rt, &info);
1600 }
1601
1602 static int ip6_route_del(struct fib6_config *cfg)
1603 {
1604         struct fib6_table *table;
1605         struct fib6_node *fn;
1606         struct rt6_info *rt;
1607         int err = -ESRCH;
1608
1609         table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1610         if (!table)
1611                 return err;
1612
1613         read_lock_bh(&table->tb6_lock);
1614
1615         fn = fib6_locate(&table->tb6_root,
1616                          &cfg->fc_dst, cfg->fc_dst_len,
1617                          &cfg->fc_src, cfg->fc_src_len);
1618
1619         if (fn) {
1620                 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1621                         if (cfg->fc_ifindex &&
1622                             (!rt->dst.dev ||
1623                              rt->dst.dev->ifindex != cfg->fc_ifindex))
1624                                 continue;
1625                         if (cfg->fc_flags & RTF_GATEWAY &&
1626                             !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1627                                 continue;
1628                         if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1629                                 continue;
1630                         dst_hold(&rt->dst);
1631                         read_unlock_bh(&table->tb6_lock);
1632
1633                         return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1634                 }
1635         }
1636         read_unlock_bh(&table->tb6_lock);
1637
1638         return err;
1639 }
1640
1641 static void rt6_do_redirect(struct dst_entry *dst, struct sk_buff *skb)
1642 {
1643         struct net *net = dev_net(skb->dev);
1644         struct netevent_redirect netevent;
1645         struct rt6_info *rt, *nrt = NULL;
1646         const struct in6_addr *target;
1647         struct ndisc_options ndopts;
1648         const struct in6_addr *dest;
1649         struct neighbour *old_neigh;
1650         struct inet6_dev *in6_dev;
1651         struct neighbour *neigh;
1652         struct icmp6hdr *icmph;
1653         int optlen, on_link;
1654         u8 *lladdr;
1655
1656         optlen = skb->tail - skb->transport_header;
1657         optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1658
1659         if (optlen < 0) {
1660                 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1661                 return;
1662         }
1663
1664         icmph = icmp6_hdr(skb);
1665         target = (const struct in6_addr *) (icmph + 1);
1666         dest = target + 1;
1667
1668         if (ipv6_addr_is_multicast(dest)) {
1669                 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1670                 return;
1671         }
1672
1673         on_link = 0;
1674         if (ipv6_addr_equal(dest, target)) {
1675                 on_link = 1;
1676         } else if (ipv6_addr_type(target) !=
1677                    (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1678                 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1679                 return;
1680         }
1681
1682         in6_dev = __in6_dev_get(skb->dev);
1683         if (!in6_dev)
1684                 return;
1685         if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1686                 return;
1687
1688         /* RFC2461 8.1:
1689          *      The IP source address of the Redirect MUST be the same as the current
1690          *      first-hop router for the specified ICMP Destination Address.
1691          */
1692
1693         if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1694                 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1695                 return;
1696         }
1697
1698         lladdr = NULL;
1699         if (ndopts.nd_opts_tgt_lladdr) {
1700                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1701                                              skb->dev);
1702                 if (!lladdr) {
1703                         net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1704                         return;
1705                 }
1706         }
1707
1708         rt = (struct rt6_info *) dst;
1709         if (rt == net->ipv6.ip6_null_entry) {
1710                 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1711                 return;
1712         }
1713
1714         /* Redirect received -> path was valid.
1715          * Look, redirects are sent only in response to data packets,
1716          * so that this nexthop apparently is reachable. --ANK
1717          */
1718         dst_confirm(&rt->dst);
1719
1720         neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1721         if (!neigh)
1722                 return;
1723
1724         /* Duplicate redirect: silently ignore. */
1725         old_neigh = rt->n;
1726         if (neigh == old_neigh)
1727                 goto out;
1728
1729         /*
1730          *      We have finally decided to accept it.
1731          */
1732
1733         neigh_update(neigh, lladdr, NUD_STALE,
1734                      NEIGH_UPDATE_F_WEAK_OVERRIDE|
1735                      NEIGH_UPDATE_F_OVERRIDE|
1736                      (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1737                                      NEIGH_UPDATE_F_ISROUTER))
1738                      );
1739
1740         nrt = ip6_rt_copy(rt, dest);
1741         if (!nrt)
1742                 goto out;
1743
1744         nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1745         if (on_link)
1746                 nrt->rt6i_flags &= ~RTF_GATEWAY;
1747
1748         nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1749         nrt->n = neigh_clone(neigh);
1750
1751         if (ip6_ins_rt(nrt))
1752                 goto out;
1753
1754         netevent.old = &rt->dst;
1755         netevent.old_neigh = old_neigh;
1756         netevent.new = &nrt->dst;
1757         netevent.new_neigh = neigh;
1758         netevent.daddr = dest;
1759         call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1760
1761         if (rt->rt6i_flags & RTF_CACHE) {
1762                 rt = (struct rt6_info *) dst_clone(&rt->dst);
1763                 ip6_del_rt(rt);
1764         }
1765
1766 out:
1767         neigh_release(neigh);
1768 }
1769
1770 /*
1771  *      Misc support functions
1772  */
1773
1774 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1775                                     const struct in6_addr *dest)
1776 {
1777         struct net *net = dev_net(ort->dst.dev);
1778         struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1779                                             ort->rt6i_table);
1780
1781         if (rt) {
1782                 rt->dst.input = ort->dst.input;
1783                 rt->dst.output = ort->dst.output;
1784                 rt->dst.flags |= DST_HOST;
1785
1786                 rt->rt6i_dst.addr = *dest;
1787                 rt->rt6i_dst.plen = 128;
1788                 dst_copy_metrics(&rt->dst, &ort->dst);
1789                 rt->dst.error = ort->dst.error;
1790                 rt->rt6i_idev = ort->rt6i_idev;
1791                 if (rt->rt6i_idev)
1792                         in6_dev_hold(rt->rt6i_idev);
1793                 rt->dst.lastuse = jiffies;
1794
1795                 rt->rt6i_gateway = ort->rt6i_gateway;
1796                 rt->rt6i_flags = ort->rt6i_flags;
1797                 if ((ort->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) ==
1798                     (RTF_DEFAULT | RTF_ADDRCONF))
1799                         rt6_set_from(rt, ort);
1800                 else
1801                         rt6_clean_expires(rt);
1802                 rt->rt6i_metric = 0;
1803
1804 #ifdef CONFIG_IPV6_SUBTREES
1805                 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1806 #endif
1807                 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1808                 rt->rt6i_table = ort->rt6i_table;
1809         }
1810         return rt;
1811 }
1812
1813 #ifdef CONFIG_IPV6_ROUTE_INFO
1814 static struct rt6_info *rt6_get_route_info(struct net *net,
1815                                            const struct in6_addr *prefix, int prefixlen,
1816                                            const struct in6_addr *gwaddr, int ifindex)
1817 {
1818         struct fib6_node *fn;
1819         struct rt6_info *rt = NULL;
1820         struct fib6_table *table;
1821
1822         table = fib6_get_table(net, RT6_TABLE_INFO);
1823         if (!table)
1824                 return NULL;
1825
1826         write_lock_bh(&table->tb6_lock);
1827         fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1828         if (!fn)
1829                 goto out;
1830
1831         for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1832                 if (rt->dst.dev->ifindex != ifindex)
1833                         continue;
1834                 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1835                         continue;
1836                 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1837                         continue;
1838                 dst_hold(&rt->dst);
1839                 break;
1840         }
1841 out:
1842         write_unlock_bh(&table->tb6_lock);
1843         return rt;
1844 }
1845
1846 static struct rt6_info *rt6_add_route_info(struct net *net,
1847                                            const struct in6_addr *prefix, int prefixlen,
1848                                            const struct in6_addr *gwaddr, int ifindex,
1849                                            unsigned int pref)
1850 {
1851         struct fib6_config cfg = {
1852                 .fc_table       = RT6_TABLE_INFO,
1853                 .fc_metric      = IP6_RT_PRIO_USER,
1854                 .fc_ifindex     = ifindex,
1855                 .fc_dst_len     = prefixlen,
1856                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1857                                   RTF_UP | RTF_PREF(pref),
1858                 .fc_nlinfo.pid = 0,
1859                 .fc_nlinfo.nlh = NULL,
1860                 .fc_nlinfo.nl_net = net,
1861         };
1862
1863         cfg.fc_dst = *prefix;
1864         cfg.fc_gateway = *gwaddr;
1865
1866         /* We should treat it as a default route if prefix length is 0. */
1867         if (!prefixlen)
1868                 cfg.fc_flags |= RTF_DEFAULT;
1869
1870         ip6_route_add(&cfg);
1871
1872         return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1873 }
1874 #endif
1875
1876 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1877 {
1878         struct rt6_info *rt;
1879         struct fib6_table *table;
1880
1881         table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1882         if (!table)
1883                 return NULL;
1884
1885         write_lock_bh(&table->tb6_lock);
1886         for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1887                 if (dev == rt->dst.dev &&
1888                     ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1889                     ipv6_addr_equal(&rt->rt6i_gateway, addr))
1890                         break;
1891         }
1892         if (rt)
1893                 dst_hold(&rt->dst);
1894         write_unlock_bh(&table->tb6_lock);
1895         return rt;
1896 }
1897
1898 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
1899                                      struct net_device *dev,
1900                                      unsigned int pref)
1901 {
1902         struct fib6_config cfg = {
1903                 .fc_table       = RT6_TABLE_DFLT,
1904                 .fc_metric      = IP6_RT_PRIO_USER,
1905                 .fc_ifindex     = dev->ifindex,
1906                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1907                                   RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1908                 .fc_nlinfo.pid = 0,
1909                 .fc_nlinfo.nlh = NULL,
1910                 .fc_nlinfo.nl_net = dev_net(dev),
1911         };
1912
1913         cfg.fc_gateway = *gwaddr;
1914
1915         ip6_route_add(&cfg);
1916
1917         return rt6_get_dflt_router(gwaddr, dev);
1918 }
1919
1920 void rt6_purge_dflt_routers(struct net *net)
1921 {
1922         struct rt6_info *rt;
1923         struct fib6_table *table;
1924
1925         /* NOTE: Keep consistent with rt6_get_dflt_router */
1926         table = fib6_get_table(net, RT6_TABLE_DFLT);
1927         if (!table)
1928                 return;
1929
1930 restart:
1931         read_lock_bh(&table->tb6_lock);
1932         for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
1933                 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1934                         dst_hold(&rt->dst);
1935                         read_unlock_bh(&table->tb6_lock);
1936                         ip6_del_rt(rt);
1937                         goto restart;
1938                 }
1939         }
1940         read_unlock_bh(&table->tb6_lock);
1941 }
1942
1943 static void rtmsg_to_fib6_config(struct net *net,
1944                                  struct in6_rtmsg *rtmsg,
1945                                  struct fib6_config *cfg)
1946 {
1947         memset(cfg, 0, sizeof(*cfg));
1948
1949         cfg->fc_table = RT6_TABLE_MAIN;
1950         cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1951         cfg->fc_metric = rtmsg->rtmsg_metric;
1952         cfg->fc_expires = rtmsg->rtmsg_info;
1953         cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1954         cfg->fc_src_len = rtmsg->rtmsg_src_len;
1955         cfg->fc_flags = rtmsg->rtmsg_flags;
1956
1957         cfg->fc_nlinfo.nl_net = net;
1958
1959         cfg->fc_dst = rtmsg->rtmsg_dst;
1960         cfg->fc_src = rtmsg->rtmsg_src;
1961         cfg->fc_gateway = rtmsg->rtmsg_gateway;
1962 }
1963
1964 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1965 {
1966         struct fib6_config cfg;
1967         struct in6_rtmsg rtmsg;
1968         int err;
1969
1970         switch(cmd) {
1971         case SIOCADDRT:         /* Add a route */
1972         case SIOCDELRT:         /* Delete a route */
1973                 if (!capable(CAP_NET_ADMIN))
1974                         return -EPERM;
1975                 err = copy_from_user(&rtmsg, arg,
1976                                      sizeof(struct in6_rtmsg));
1977                 if (err)
1978                         return -EFAULT;
1979
1980                 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
1981
1982                 rtnl_lock();
1983                 switch (cmd) {
1984                 case SIOCADDRT:
1985                         err = ip6_route_add(&cfg);
1986                         break;
1987                 case SIOCDELRT:
1988                         err = ip6_route_del(&cfg);
1989                         break;
1990                 default:
1991                         err = -EINVAL;
1992                 }
1993                 rtnl_unlock();
1994
1995                 return err;
1996         }
1997
1998         return -EINVAL;
1999 }
2000
2001 /*
2002  *      Drop the packet on the floor
2003  */
2004
2005 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2006 {
2007         int type;
2008         struct dst_entry *dst = skb_dst(skb);
2009         switch (ipstats_mib_noroutes) {
2010         case IPSTATS_MIB_INNOROUTES:
2011                 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2012                 if (type == IPV6_ADDR_ANY) {
2013                         IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2014                                       IPSTATS_MIB_INADDRERRORS);
2015                         break;
2016                 }
2017                 /* FALLTHROUGH */
2018         case IPSTATS_MIB_OUTNOROUTES:
2019                 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2020                               ipstats_mib_noroutes);
2021                 break;
2022         }
2023         icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2024         kfree_skb(skb);
2025         return 0;
2026 }
2027
2028 static int ip6_pkt_discard(struct sk_buff *skb)
2029 {
2030         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2031 }
2032
2033 static int ip6_pkt_discard_out(struct sk_buff *skb)
2034 {
2035         skb->dev = skb_dst(skb)->dev;
2036         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2037 }
2038
2039 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2040
2041 static int ip6_pkt_prohibit(struct sk_buff *skb)
2042 {
2043         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2044 }
2045
2046 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2047 {
2048         skb->dev = skb_dst(skb)->dev;
2049         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2050 }
2051
2052 #endif
2053
2054 /*
2055  *      Allocate a dst for local (unicast / anycast) address.
2056  */
2057
2058 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2059                                     const struct in6_addr *addr,
2060                                     bool anycast)
2061 {
2062         struct net *net = dev_net(idev->dev);
2063         struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev, 0, NULL);
2064         int err;
2065
2066         if (!rt) {
2067                 net_warn_ratelimited("Maximum number of routes reached, consider increasing route/max_size\n");
2068                 return ERR_PTR(-ENOMEM);
2069         }
2070
2071         in6_dev_hold(idev);
2072
2073         rt->dst.flags |= DST_HOST;
2074         rt->dst.input = ip6_input;
2075         rt->dst.output = ip6_output;
2076         rt->rt6i_idev = idev;
2077         rt->dst.obsolete = -1;
2078
2079         rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2080         if (anycast)
2081                 rt->rt6i_flags |= RTF_ANYCAST;
2082         else
2083                 rt->rt6i_flags |= RTF_LOCAL;
2084         err = rt6_bind_neighbour(rt, rt->dst.dev);
2085         if (err) {
2086                 dst_free(&rt->dst);
2087                 return ERR_PTR(err);
2088         }
2089
2090         rt->rt6i_dst.addr = *addr;
2091         rt->rt6i_dst.plen = 128;
2092         rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2093
2094         atomic_set(&rt->dst.__refcnt, 1);
2095
2096         return rt;
2097 }
2098
2099 int ip6_route_get_saddr(struct net *net,
2100                         struct rt6_info *rt,
2101                         const struct in6_addr *daddr,
2102                         unsigned int prefs,
2103                         struct in6_addr *saddr)
2104 {
2105         struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2106         int err = 0;
2107         if (rt->rt6i_prefsrc.plen)
2108                 *saddr = rt->rt6i_prefsrc.addr;
2109         else
2110                 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2111                                          daddr, prefs, saddr);
2112         return err;
2113 }
2114
2115 /* remove deleted ip from prefsrc entries */
2116 struct arg_dev_net_ip {
2117         struct net_device *dev;
2118         struct net *net;
2119         struct in6_addr *addr;
2120 };
2121
2122 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2123 {
2124         struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2125         struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2126         struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2127
2128         if (((void *)rt->dst.dev == dev || !dev) &&
2129             rt != net->ipv6.ip6_null_entry &&
2130             ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2131                 /* remove prefsrc entry */
2132                 rt->rt6i_prefsrc.plen = 0;
2133         }
2134         return 0;
2135 }
2136
2137 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2138 {
2139         struct net *net = dev_net(ifp->idev->dev);
2140         struct arg_dev_net_ip adni = {
2141                 .dev = ifp->idev->dev,
2142                 .net = net,
2143                 .addr = &ifp->addr,
2144         };
2145         fib6_clean_all(net, fib6_remove_prefsrc, 0, &adni);
2146 }
2147
2148 struct arg_dev_net {
2149         struct net_device *dev;
2150         struct net *net;
2151 };
2152
2153 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2154 {
2155         const struct arg_dev_net *adn = arg;
2156         const struct net_device *dev = adn->dev;
2157
2158         if ((rt->dst.dev == dev || !dev) &&
2159             rt != adn->net->ipv6.ip6_null_entry)
2160                 return -1;
2161
2162         return 0;
2163 }
2164
2165 void rt6_ifdown(struct net *net, struct net_device *dev)
2166 {
2167         struct arg_dev_net adn = {
2168                 .dev = dev,
2169                 .net = net,
2170         };
2171
2172         fib6_clean_all(net, fib6_ifdown, 0, &adn);
2173         icmp6_clean_all(fib6_ifdown, &adn);
2174 }
2175
2176 struct rt6_mtu_change_arg {
2177         struct net_device *dev;
2178         unsigned int mtu;
2179 };
2180
2181 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2182 {
2183         struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2184         struct inet6_dev *idev;
2185
2186         /* In IPv6 pmtu discovery is not optional,
2187            so that RTAX_MTU lock cannot disable it.
2188            We still use this lock to block changes
2189            caused by addrconf/ndisc.
2190         */
2191
2192         idev = __in6_dev_get(arg->dev);
2193         if (!idev)
2194                 return 0;
2195
2196         /* For administrative MTU increase, there is no way to discover
2197            IPv6 PMTU increase, so PMTU increase should be updated here.
2198            Since RFC 1981 doesn't include administrative MTU increase
2199            update PMTU increase is a MUST. (i.e. jumbo frame)
2200          */
2201         /*
2202            If new MTU is less than route PMTU, this new MTU will be the
2203            lowest MTU in the path, update the route PMTU to reflect PMTU
2204            decreases; if new MTU is greater than route PMTU, and the
2205            old MTU is the lowest MTU in the path, update the route PMTU
2206            to reflect the increase. In this case if the other nodes' MTU
2207            also have the lowest MTU, TOO BIG MESSAGE will be lead to
2208            PMTU discouvery.
2209          */
2210         if (rt->dst.dev == arg->dev &&
2211             !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2212             (dst_mtu(&rt->dst) >= arg->mtu ||
2213              (dst_mtu(&rt->dst) < arg->mtu &&
2214               dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2215                 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2216         }
2217         return 0;
2218 }
2219
2220 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2221 {
2222         struct rt6_mtu_change_arg arg = {
2223                 .dev = dev,
2224                 .mtu = mtu,
2225         };
2226
2227         fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
2228 }
2229
2230 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2231         [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
2232         [RTA_OIF]               = { .type = NLA_U32 },
2233         [RTA_IIF]               = { .type = NLA_U32 },
2234         [RTA_PRIORITY]          = { .type = NLA_U32 },
2235         [RTA_METRICS]           = { .type = NLA_NESTED },
2236 };
2237
2238 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2239                               struct fib6_config *cfg)
2240 {
2241         struct rtmsg *rtm;
2242         struct nlattr *tb[RTA_MAX+1];
2243         int err;
2244
2245         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2246         if (err < 0)
2247                 goto errout;
2248
2249         err = -EINVAL;
2250         rtm = nlmsg_data(nlh);
2251         memset(cfg, 0, sizeof(*cfg));
2252
2253         cfg->fc_table = rtm->rtm_table;
2254         cfg->fc_dst_len = rtm->rtm_dst_len;
2255         cfg->fc_src_len = rtm->rtm_src_len;
2256         cfg->fc_flags = RTF_UP;
2257         cfg->fc_protocol = rtm->rtm_protocol;
2258
2259         if (rtm->rtm_type == RTN_UNREACHABLE)
2260                 cfg->fc_flags |= RTF_REJECT;
2261
2262         if (rtm->rtm_type == RTN_LOCAL)
2263                 cfg->fc_flags |= RTF_LOCAL;
2264
2265         cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
2266         cfg->fc_nlinfo.nlh = nlh;
2267         cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2268
2269         if (tb[RTA_GATEWAY]) {
2270                 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2271                 cfg->fc_flags |= RTF_GATEWAY;
2272         }
2273
2274         if (tb[RTA_DST]) {
2275                 int plen = (rtm->rtm_dst_len + 7) >> 3;
2276
2277                 if (nla_len(tb[RTA_DST]) < plen)
2278                         goto errout;
2279
2280                 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2281         }
2282
2283         if (tb[RTA_SRC]) {
2284                 int plen = (rtm->rtm_src_len + 7) >> 3;
2285
2286                 if (nla_len(tb[RTA_SRC]) < plen)
2287                         goto errout;
2288
2289                 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2290         }
2291
2292         if (tb[RTA_PREFSRC])
2293                 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2294
2295         if (tb[RTA_OIF])
2296                 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2297
2298         if (tb[RTA_PRIORITY])
2299                 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2300
2301         if (tb[RTA_METRICS]) {
2302                 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2303                 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2304         }
2305
2306         if (tb[RTA_TABLE])
2307                 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2308
2309         err = 0;
2310 errout:
2311         return err;
2312 }
2313
2314 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2315 {
2316         struct fib6_config cfg;
2317         int err;
2318
2319         err = rtm_to_fib6_config(skb, nlh, &cfg);
2320         if (err < 0)
2321                 return err;
2322
2323         return ip6_route_del(&cfg);
2324 }
2325
2326 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2327 {
2328         struct fib6_config cfg;
2329         int err;
2330
2331         err = rtm_to_fib6_config(skb, nlh, &cfg);
2332         if (err < 0)
2333                 return err;
2334
2335         return ip6_route_add(&cfg);
2336 }
2337
2338 static inline size_t rt6_nlmsg_size(void)
2339 {
2340         return NLMSG_ALIGN(sizeof(struct rtmsg))
2341                + nla_total_size(16) /* RTA_SRC */
2342                + nla_total_size(16) /* RTA_DST */
2343                + nla_total_size(16) /* RTA_GATEWAY */
2344                + nla_total_size(16) /* RTA_PREFSRC */
2345                + nla_total_size(4) /* RTA_TABLE */
2346                + nla_total_size(4) /* RTA_IIF */
2347                + nla_total_size(4) /* RTA_OIF */
2348                + nla_total_size(4) /* RTA_PRIORITY */
2349                + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2350                + nla_total_size(sizeof(struct rta_cacheinfo));
2351 }
2352
2353 static int rt6_fill_node(struct net *net,
2354                          struct sk_buff *skb, struct rt6_info *rt,
2355                          struct in6_addr *dst, struct in6_addr *src,
2356                          int iif, int type, u32 pid, u32 seq,
2357                          int prefix, int nowait, unsigned int flags)
2358 {
2359         struct rtmsg *rtm;
2360         struct nlmsghdr *nlh;
2361         long expires;
2362         u32 table;
2363         struct neighbour *n;
2364
2365         if (prefix) {   /* user wants prefix routes only */
2366                 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2367                         /* success since this is not a prefix route */
2368                         return 1;
2369                 }
2370         }
2371
2372         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2373         if (!nlh)
2374                 return -EMSGSIZE;
2375
2376         rtm = nlmsg_data(nlh);
2377         rtm->rtm_family = AF_INET6;
2378         rtm->rtm_dst_len = rt->rt6i_dst.plen;
2379         rtm->rtm_src_len = rt->rt6i_src.plen;
2380         rtm->rtm_tos = 0;
2381         if (rt->rt6i_table)
2382                 table = rt->rt6i_table->tb6_id;
2383         else
2384                 table = RT6_TABLE_UNSPEC;
2385         rtm->rtm_table = table;
2386         if (nla_put_u32(skb, RTA_TABLE, table))
2387                 goto nla_put_failure;
2388         if (rt->rt6i_flags & RTF_REJECT)
2389                 rtm->rtm_type = RTN_UNREACHABLE;
2390         else if (rt->rt6i_flags & RTF_LOCAL)
2391                 rtm->rtm_type = RTN_LOCAL;
2392         else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2393                 rtm->rtm_type = RTN_LOCAL;
2394         else
2395                 rtm->rtm_type = RTN_UNICAST;
2396         rtm->rtm_flags = 0;
2397         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2398         rtm->rtm_protocol = rt->rt6i_protocol;
2399         if (rt->rt6i_flags & RTF_DYNAMIC)
2400                 rtm->rtm_protocol = RTPROT_REDIRECT;
2401         else if (rt->rt6i_flags & RTF_ADDRCONF)
2402                 rtm->rtm_protocol = RTPROT_KERNEL;
2403         else if (rt->rt6i_flags & RTF_DEFAULT)
2404                 rtm->rtm_protocol = RTPROT_RA;
2405
2406         if (rt->rt6i_flags & RTF_CACHE)
2407                 rtm->rtm_flags |= RTM_F_CLONED;
2408
2409         if (dst) {
2410                 if (nla_put(skb, RTA_DST, 16, dst))
2411                         goto nla_put_failure;
2412                 rtm->rtm_dst_len = 128;
2413         } else if (rtm->rtm_dst_len)
2414                 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2415                         goto nla_put_failure;
2416 #ifdef CONFIG_IPV6_SUBTREES
2417         if (src) {
2418                 if (nla_put(skb, RTA_SRC, 16, src))
2419                         goto nla_put_failure;
2420                 rtm->rtm_src_len = 128;
2421         } else if (rtm->rtm_src_len &&
2422                    nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2423                 goto nla_put_failure;
2424 #endif
2425         if (iif) {
2426 #ifdef CONFIG_IPV6_MROUTE
2427                 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2428                         int err = ip6mr_get_route(net, skb, rtm, nowait);
2429                         if (err <= 0) {
2430                                 if (!nowait) {
2431                                         if (err == 0)
2432                                                 return 0;
2433                                         goto nla_put_failure;
2434                                 } else {
2435                                         if (err == -EMSGSIZE)
2436                                                 goto nla_put_failure;
2437                                 }
2438                         }
2439                 } else
2440 #endif
2441                         if (nla_put_u32(skb, RTA_IIF, iif))
2442                                 goto nla_put_failure;
2443         } else if (dst) {
2444                 struct in6_addr saddr_buf;
2445                 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2446                     nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2447                         goto nla_put_failure;
2448         }
2449
2450         if (rt->rt6i_prefsrc.plen) {
2451                 struct in6_addr saddr_buf;
2452                 saddr_buf = rt->rt6i_prefsrc.addr;
2453                 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2454                         goto nla_put_failure;
2455         }
2456
2457         if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2458                 goto nla_put_failure;
2459
2460         rcu_read_lock();
2461         n = rt->n;
2462         if (n) {
2463                 if (nla_put(skb, RTA_GATEWAY, 16, &n->primary_key) < 0) {
2464                         rcu_read_unlock();
2465                         goto nla_put_failure;
2466                 }
2467         }
2468         rcu_read_unlock();
2469
2470         if (rt->dst.dev &&
2471             nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2472                 goto nla_put_failure;
2473         if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2474                 goto nla_put_failure;
2475         if (!(rt->rt6i_flags & RTF_EXPIRES))
2476                 expires = 0;
2477         else if (rt->dst.expires - jiffies < INT_MAX)
2478                 expires = rt->dst.expires - jiffies;
2479         else
2480                 expires = INT_MAX;
2481
2482         if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2483                 goto nla_put_failure;
2484
2485         return nlmsg_end(skb, nlh);
2486
2487 nla_put_failure:
2488         nlmsg_cancel(skb, nlh);
2489         return -EMSGSIZE;
2490 }
2491
2492 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2493 {
2494         struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2495         int prefix;
2496
2497         if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2498                 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2499                 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2500         } else
2501                 prefix = 0;
2502
2503         return rt6_fill_node(arg->net,
2504                      arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2505                      NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
2506                      prefix, 0, NLM_F_MULTI);
2507 }
2508
2509 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2510 {
2511         struct net *net = sock_net(in_skb->sk);
2512         struct nlattr *tb[RTA_MAX+1];
2513         struct rt6_info *rt;
2514         struct sk_buff *skb;
2515         struct rtmsg *rtm;
2516         struct flowi6 fl6;
2517         int err, iif = 0, oif = 0;
2518
2519         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2520         if (err < 0)
2521                 goto errout;
2522
2523         err = -EINVAL;
2524         memset(&fl6, 0, sizeof(fl6));
2525
2526         if (tb[RTA_SRC]) {
2527                 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2528                         goto errout;
2529
2530                 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2531         }
2532
2533         if (tb[RTA_DST]) {
2534                 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2535                         goto errout;
2536
2537                 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2538         }
2539
2540         if (tb[RTA_IIF])
2541                 iif = nla_get_u32(tb[RTA_IIF]);
2542
2543         if (tb[RTA_OIF])
2544                 oif = nla_get_u32(tb[RTA_OIF]);
2545
2546         if (iif) {
2547                 struct net_device *dev;
2548                 int flags = 0;
2549
2550                 dev = __dev_get_by_index(net, iif);
2551                 if (!dev) {
2552                         err = -ENODEV;
2553                         goto errout;
2554                 }
2555
2556                 fl6.flowi6_iif = iif;
2557
2558                 if (!ipv6_addr_any(&fl6.saddr))
2559                         flags |= RT6_LOOKUP_F_HAS_SADDR;
2560
2561                 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2562                                                                flags);
2563         } else {
2564                 fl6.flowi6_oif = oif;
2565
2566                 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2567         }
2568
2569         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2570         if (!skb) {
2571                 dst_release(&rt->dst);
2572                 err = -ENOBUFS;
2573                 goto errout;
2574         }
2575
2576         /* Reserve room for dummy headers, this skb can pass
2577            through good chunk of routing engine.
2578          */
2579         skb_reset_mac_header(skb);
2580         skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2581
2582         skb_dst_set(skb, &rt->dst);
2583
2584         err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2585                             RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
2586                             nlh->nlmsg_seq, 0, 0, 0);
2587         if (err < 0) {
2588                 kfree_skb(skb);
2589                 goto errout;
2590         }
2591
2592         err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
2593 errout:
2594         return err;
2595 }
2596
2597 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2598 {
2599         struct sk_buff *skb;
2600         struct net *net = info->nl_net;
2601         u32 seq;
2602         int err;
2603
2604         err = -ENOBUFS;
2605         seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2606
2607         skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2608         if (!skb)
2609                 goto errout;
2610
2611         err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2612                                 event, info->pid, seq, 0, 0, 0);
2613         if (err < 0) {
2614                 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2615                 WARN_ON(err == -EMSGSIZE);
2616                 kfree_skb(skb);
2617                 goto errout;
2618         }
2619         rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE,
2620                     info->nlh, gfp_any());
2621         return;
2622 errout:
2623         if (err < 0)
2624                 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2625 }
2626
2627 static int ip6_route_dev_notify(struct notifier_block *this,
2628                                 unsigned long event, void *data)
2629 {
2630         struct net_device *dev = (struct net_device *)data;
2631         struct net *net = dev_net(dev);
2632
2633         if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2634                 net->ipv6.ip6_null_entry->dst.dev = dev;
2635                 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2636 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2637                 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2638                 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2639                 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2640                 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2641 #endif
2642         }
2643
2644         return NOTIFY_OK;
2645 }
2646
2647 /*
2648  *      /proc
2649  */
2650
2651 #ifdef CONFIG_PROC_FS
2652
2653 struct rt6_proc_arg
2654 {
2655         char *buffer;
2656         int offset;
2657         int length;
2658         int skip;
2659         int len;
2660 };
2661
2662 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2663 {
2664         struct seq_file *m = p_arg;
2665         struct neighbour *n;
2666
2667         seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
2668
2669 #ifdef CONFIG_IPV6_SUBTREES
2670         seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
2671 #else
2672         seq_puts(m, "00000000000000000000000000000000 00 ");
2673 #endif
2674         rcu_read_lock();
2675         n = rt->n;
2676         if (n) {
2677                 seq_printf(m, "%pi6", n->primary_key);
2678         } else {
2679                 seq_puts(m, "00000000000000000000000000000000");
2680         }
2681         rcu_read_unlock();
2682         seq_printf(m, " %08x %08x %08x %08x %8s\n",
2683                    rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2684                    rt->dst.__use, rt->rt6i_flags,
2685                    rt->dst.dev ? rt->dst.dev->name : "");
2686         return 0;
2687 }
2688
2689 static int ipv6_route_show(struct seq_file *m, void *v)
2690 {
2691         struct net *net = (struct net *)m->private;
2692         fib6_clean_all_ro(net, rt6_info_route, 0, m);
2693         return 0;
2694 }
2695
2696 static int ipv6_route_open(struct inode *inode, struct file *file)
2697 {
2698         return single_open_net(inode, file, ipv6_route_show);
2699 }
2700
2701 static const struct file_operations ipv6_route_proc_fops = {
2702         .owner          = THIS_MODULE,
2703         .open           = ipv6_route_open,
2704         .read           = seq_read,
2705         .llseek         = seq_lseek,
2706         .release        = single_release_net,
2707 };
2708
2709 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2710 {
2711         struct net *net = (struct net *)seq->private;
2712         seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2713                    net->ipv6.rt6_stats->fib_nodes,
2714                    net->ipv6.rt6_stats->fib_route_nodes,
2715                    net->ipv6.rt6_stats->fib_rt_alloc,
2716                    net->ipv6.rt6_stats->fib_rt_entries,
2717                    net->ipv6.rt6_stats->fib_rt_cache,
2718                    dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2719                    net->ipv6.rt6_stats->fib_discarded_routes);
2720
2721         return 0;
2722 }
2723
2724 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2725 {
2726         return single_open_net(inode, file, rt6_stats_seq_show);
2727 }
2728
2729 static const struct file_operations rt6_stats_seq_fops = {
2730         .owner   = THIS_MODULE,
2731         .open    = rt6_stats_seq_open,
2732         .read    = seq_read,
2733         .llseek  = seq_lseek,
2734         .release = single_release_net,
2735 };
2736 #endif  /* CONFIG_PROC_FS */
2737
2738 #ifdef CONFIG_SYSCTL
2739
2740 static
2741 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
2742                               void __user *buffer, size_t *lenp, loff_t *ppos)
2743 {
2744         struct net *net;
2745         int delay;
2746         if (!write)
2747                 return -EINVAL;
2748
2749         net = (struct net *)ctl->extra1;
2750         delay = net->ipv6.sysctl.flush_delay;
2751         proc_dointvec(ctl, write, buffer, lenp, ppos);
2752         fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
2753         return 0;
2754 }
2755
2756 ctl_table ipv6_route_table_template[] = {
2757         {
2758                 .procname       =       "flush",
2759                 .data           =       &init_net.ipv6.sysctl.flush_delay,
2760                 .maxlen         =       sizeof(int),
2761                 .mode           =       0200,
2762                 .proc_handler   =       ipv6_sysctl_rtcache_flush
2763         },
2764         {
2765                 .procname       =       "gc_thresh",
2766                 .data           =       &ip6_dst_ops_template.gc_thresh,
2767                 .maxlen         =       sizeof(int),
2768                 .mode           =       0644,
2769                 .proc_handler   =       proc_dointvec,
2770         },
2771         {
2772                 .procname       =       "max_size",
2773                 .data           =       &init_net.ipv6.sysctl.ip6_rt_max_size,
2774                 .maxlen         =       sizeof(int),
2775                 .mode           =       0644,
2776                 .proc_handler   =       proc_dointvec,
2777         },
2778         {
2779                 .procname       =       "gc_min_interval",
2780                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2781                 .maxlen         =       sizeof(int),
2782                 .mode           =       0644,
2783                 .proc_handler   =       proc_dointvec_jiffies,
2784         },
2785         {
2786                 .procname       =       "gc_timeout",
2787                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2788                 .maxlen         =       sizeof(int),
2789                 .mode           =       0644,
2790                 .proc_handler   =       proc_dointvec_jiffies,
2791         },
2792         {
2793                 .procname       =       "gc_interval",
2794                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2795                 .maxlen         =       sizeof(int),
2796                 .mode           =       0644,
2797                 .proc_handler   =       proc_dointvec_jiffies,
2798         },
2799         {
2800                 .procname       =       "gc_elasticity",
2801                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2802                 .maxlen         =       sizeof(int),
2803                 .mode           =       0644,
2804                 .proc_handler   =       proc_dointvec,
2805         },
2806         {
2807                 .procname       =       "mtu_expires",
2808                 .data           =       &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2809                 .maxlen         =       sizeof(int),
2810                 .mode           =       0644,
2811                 .proc_handler   =       proc_dointvec_jiffies,
2812         },
2813         {
2814                 .procname       =       "min_adv_mss",
2815                 .data           =       &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2816                 .maxlen         =       sizeof(int),
2817                 .mode           =       0644,
2818                 .proc_handler   =       proc_dointvec,
2819         },
2820         {
2821                 .procname       =       "gc_min_interval_ms",
2822                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2823                 .maxlen         =       sizeof(int),
2824                 .mode           =       0644,
2825                 .proc_handler   =       proc_dointvec_ms_jiffies,
2826         },
2827         { }
2828 };
2829
2830 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2831 {
2832         struct ctl_table *table;
2833
2834         table = kmemdup(ipv6_route_table_template,
2835                         sizeof(ipv6_route_table_template),
2836                         GFP_KERNEL);
2837
2838         if (table) {
2839                 table[0].data = &net->ipv6.sysctl.flush_delay;
2840                 table[0].extra1 = net;
2841                 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2842                 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2843                 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2844                 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2845                 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2846                 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2847                 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2848                 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2849                 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2850         }
2851
2852         return table;
2853 }
2854 #endif
2855
2856 static int __net_init ip6_route_net_init(struct net *net)
2857 {
2858         int ret = -ENOMEM;
2859
2860         memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2861                sizeof(net->ipv6.ip6_dst_ops));
2862
2863         if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2864                 goto out_ip6_dst_ops;
2865
2866         net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2867                                            sizeof(*net->ipv6.ip6_null_entry),
2868                                            GFP_KERNEL);
2869         if (!net->ipv6.ip6_null_entry)
2870                 goto out_ip6_dst_entries;
2871         net->ipv6.ip6_null_entry->dst.path =
2872                 (struct dst_entry *)net->ipv6.ip6_null_entry;
2873         net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2874         dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
2875                          ip6_template_metrics, true);
2876
2877 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2878         net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2879                                                sizeof(*net->ipv6.ip6_prohibit_entry),
2880                                                GFP_KERNEL);
2881         if (!net->ipv6.ip6_prohibit_entry)
2882                 goto out_ip6_null_entry;
2883         net->ipv6.ip6_prohibit_entry->dst.path =
2884                 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
2885         net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2886         dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
2887                          ip6_template_metrics, true);
2888
2889         net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
2890                                                sizeof(*net->ipv6.ip6_blk_hole_entry),
2891                                                GFP_KERNEL);
2892         if (!net->ipv6.ip6_blk_hole_entry)
2893                 goto out_ip6_prohibit_entry;
2894         net->ipv6.ip6_blk_hole_entry->dst.path =
2895                 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
2896         net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2897         dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
2898                          ip6_template_metrics, true);
2899 #endif
2900
2901         net->ipv6.sysctl.flush_delay = 0;
2902         net->ipv6.sysctl.ip6_rt_max_size = 4096;
2903         net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
2904         net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
2905         net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
2906         net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
2907         net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
2908         net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
2909
2910         net->ipv6.ip6_rt_gc_expire = 30*HZ;
2911
2912         ret = 0;
2913 out:
2914         return ret;
2915
2916 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2917 out_ip6_prohibit_entry:
2918         kfree(net->ipv6.ip6_prohibit_entry);
2919 out_ip6_null_entry:
2920         kfree(net->ipv6.ip6_null_entry);
2921 #endif
2922 out_ip6_dst_entries:
2923         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
2924 out_ip6_dst_ops:
2925         goto out;
2926 }
2927
2928 static void __net_exit ip6_route_net_exit(struct net *net)
2929 {
2930         kfree(net->ipv6.ip6_null_entry);
2931 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2932         kfree(net->ipv6.ip6_prohibit_entry);
2933         kfree(net->ipv6.ip6_blk_hole_entry);
2934 #endif
2935         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
2936 }
2937
2938 static int __net_init ip6_route_net_init_late(struct net *net)
2939 {
2940 #ifdef CONFIG_PROC_FS
2941         proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
2942         proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2943 #endif
2944         return 0;
2945 }
2946
2947 static void __net_exit ip6_route_net_exit_late(struct net *net)
2948 {
2949 #ifdef CONFIG_PROC_FS
2950         proc_net_remove(net, "ipv6_route");
2951         proc_net_remove(net, "rt6_stats");
2952 #endif
2953 }
2954
2955 static struct pernet_operations ip6_route_net_ops = {
2956         .init = ip6_route_net_init,
2957         .exit = ip6_route_net_exit,
2958 };
2959
2960 static int __net_init ipv6_inetpeer_init(struct net *net)
2961 {
2962         struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2963
2964         if (!bp)
2965                 return -ENOMEM;
2966         inet_peer_base_init(bp);
2967         net->ipv6.peers = bp;
2968         return 0;
2969 }
2970
2971 static void __net_exit ipv6_inetpeer_exit(struct net *net)
2972 {
2973         struct inet_peer_base *bp = net->ipv6.peers;
2974
2975         net->ipv6.peers = NULL;
2976         inetpeer_invalidate_tree(bp);
2977         kfree(bp);
2978 }
2979
2980 static struct pernet_operations ipv6_inetpeer_ops = {
2981         .init   =       ipv6_inetpeer_init,
2982         .exit   =       ipv6_inetpeer_exit,
2983 };
2984
2985 static struct pernet_operations ip6_route_net_late_ops = {
2986         .init = ip6_route_net_init_late,
2987         .exit = ip6_route_net_exit_late,
2988 };
2989
2990 static struct notifier_block ip6_route_dev_notifier = {
2991         .notifier_call = ip6_route_dev_notify,
2992         .priority = 0,
2993 };
2994
2995 int __init ip6_route_init(void)
2996 {
2997         int ret;
2998
2999         ret = -ENOMEM;
3000         ip6_dst_ops_template.kmem_cachep =
3001                 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3002                                   SLAB_HWCACHE_ALIGN, NULL);
3003         if (!ip6_dst_ops_template.kmem_cachep)
3004                 goto out;
3005
3006         ret = dst_entries_init(&ip6_dst_blackhole_ops);
3007         if (ret)
3008                 goto out_kmem_cache;
3009
3010         ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3011         if (ret)
3012                 goto out_dst_entries;
3013
3014         ret = register_pernet_subsys(&ip6_route_net_ops);
3015         if (ret)
3016                 goto out_register_inetpeer;
3017
3018         ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3019
3020         /* Registering of the loopback is done before this portion of code,
3021          * the loopback reference in rt6_info will not be taken, do it
3022          * manually for init_net */
3023         init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3024         init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3025   #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3026         init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3027         init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3028         init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3029         init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3030   #endif
3031         ret = fib6_init();
3032         if (ret)
3033                 goto out_register_subsys;
3034
3035         ret = xfrm6_init();
3036         if (ret)
3037                 goto out_fib6_init;
3038
3039         ret = fib6_rules_init();
3040         if (ret)
3041                 goto xfrm6_init;
3042
3043         ret = register_pernet_subsys(&ip6_route_net_late_ops);
3044         if (ret)
3045                 goto fib6_rules_init;
3046
3047         ret = -ENOBUFS;
3048         if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3049             __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3050             __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3051                 goto out_register_late_subsys;
3052
3053         ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3054         if (ret)
3055                 goto out_register_late_subsys;
3056
3057 out:
3058         return ret;
3059
3060 out_register_late_subsys:
3061         unregister_pernet_subsys(&ip6_route_net_late_ops);
3062 fib6_rules_init:
3063         fib6_rules_cleanup();
3064 xfrm6_init:
3065         xfrm6_fini();
3066 out_fib6_init:
3067         fib6_gc_cleanup();
3068 out_register_subsys:
3069         unregister_pernet_subsys(&ip6_route_net_ops);
3070 out_register_inetpeer:
3071         unregister_pernet_subsys(&ipv6_inetpeer_ops);
3072 out_dst_entries:
3073         dst_entries_destroy(&ip6_dst_blackhole_ops);
3074 out_kmem_cache:
3075         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3076         goto out;
3077 }
3078
3079 void ip6_route_cleanup(void)
3080 {
3081         unregister_netdevice_notifier(&ip6_route_dev_notifier);
3082         unregister_pernet_subsys(&ip6_route_net_late_ops);
3083         fib6_rules_cleanup();
3084         xfrm6_fini();
3085         fib6_gc_cleanup();
3086         unregister_pernet_subsys(&ipv6_inetpeer_ops);
3087         unregister_pernet_subsys(&ip6_route_net_ops);
3088         dst_entries_destroy(&ip6_dst_blackhole_ops);
3089         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3090 }