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