net/ipv6/route.c

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