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