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