git.oblomov.eu Git - linux-2.6/blob - 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  *      $Id: route.c,v 1.56 2001/10/31 21:55:55 davem Exp $
   9  *
  10  *      This program is free software; you can redistribute it and/or
  11  *      modify it under the terms of the GNU General Public License
  12  *      as published by the Free Software Foundation; either version
  13  *      2 of the License, or (at your option) any later version.
  14  */
  15
  16 /*      Changes:
  17  *
  18  *      YOSHIFUJI Hideaki @USAGI
  19  *              reworked default router selection.
  20  *              - respect outgoing interface
  21  *              - select from (probably) reachable routers (i.e.
  22  *              routers in REACHABLE, STALE, DELAY or PROBE states).
  23  *              - always select the same router if it is (probably)
  24  *              reachable.  otherwise, round-robin the list.
  25  *      Ville Nuorvala
  26  *              Fixed routing subtrees.
  27  */
  28
  29 #include <linux/capability.h>
  30 #include <linux/errno.h>
  31 #include <linux/types.h>
  32 #include <linux/times.h>
  33 #include <linux/socket.h>
  34 #include <linux/sockios.h>
  35 #include <linux/net.h>
  36 #include <linux/route.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/in6.h>
  39 #include <linux/init.h>
  40 #include <linux/if_arp.h>
  41
  42 #ifdef  CONFIG_PROC_FS
  43 #include <linux/proc_fs.h>
  44 #include <linux/seq_file.h>
  45 #endif
  46
  47 #include <net/snmp.h>
  48 #include <net/ipv6.h>
  49 #include <net/ip6_fib.h>
  50 #include <net/ip6_route.h>
  51 #include <net/ndisc.h>
  52 #include <net/addrconf.h>
  53 #include <net/tcp.h>
  54 #include <linux/rtnetlink.h>
  55 #include <net/dst.h>
  56 #include <net/xfrm.h>
  57 #include <net/netevent.h>
  58 #include <net/netlink.h>
  59
  60 #include <asm/uaccess.h>
  61
  62 #ifdef CONFIG_SYSCTL
  63 #include <linux/sysctl.h>
  64 #endif
  65
  66 /* Set to 3 to get tracing. */
  67 #define RT6_DEBUG 2
  68
  69 #if RT6_DEBUG >= 3
  70 #define RDBG(x) printk x
  71 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
  72 #else
  73 #define RDBG(x)
  74 #define RT6_TRACE(x...) do { ; } while (0)
  75 #endif
  76
  77 #define CLONE_OFFLINK_ROUTE 0
  78
  79 static int ip6_rt_max_size = 4096;
  80 static int ip6_rt_gc_min_interval = HZ / 2;
  81 static int ip6_rt_gc_timeout = 60*HZ;
  82 int ip6_rt_gc_interval = 30*HZ;
  83 static int ip6_rt_gc_elasticity = 9;
  84 static int ip6_rt_mtu_expires = 10*60*HZ;
  85 static int ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
  86
  87 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
  88 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
  89 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
  90 static void             ip6_dst_destroy(struct dst_entry *);
  91 static void             ip6_dst_ifdown(struct dst_entry *,
  92                                        struct net_device *dev, int how);
  93 static int               ip6_dst_gc(void);
  94
  95 static int              ip6_pkt_discard(struct sk_buff *skb);
  96 static int              ip6_pkt_discard_out(struct sk_buff *skb);
  97 static void             ip6_link_failure(struct sk_buff *skb);
  98 static void             ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
  99
 100 #ifdef CONFIG_IPV6_ROUTE_INFO
 101 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
 102                                            struct in6_addr *gwaddr, int ifindex,
 103                                            unsigned pref);
 104 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
 105                                            struct in6_addr *gwaddr, int ifindex);
 106 #endif
 107
 108 static struct dst_ops ip6_dst_ops = {
 109         .family                 =       AF_INET6,
 110         .protocol               =       __constant_htons(ETH_P_IPV6),
 111         .gc                     =       ip6_dst_gc,
 112         .gc_thresh              =       1024,
 113         .check                  =       ip6_dst_check,
 114         .destroy                =       ip6_dst_destroy,
 115         .ifdown                 =       ip6_dst_ifdown,
 116         .negative_advice        =       ip6_negative_advice,
 117         .link_failure           =       ip6_link_failure,
 118         .update_pmtu            =       ip6_rt_update_pmtu,
 119         .entry_size             =       sizeof(struct rt6_info),
 120 };
 121
 122 struct rt6_info ip6_null_entry = {
 123         .u = {
 124                 .dst = {
 125                         .__refcnt       = ATOMIC_INIT(1),
 126                         .__use          = 1,
 127                         .dev            = &loopback_dev,
 128                         .obsolete       = -1,
 129                         .error          = -ENETUNREACH,
 130                         .metrics        = { [RTAX_HOPLIMIT - 1] = 255, },
 131                         .input          = ip6_pkt_discard,
 132                         .output         = ip6_pkt_discard_out,
 133                         .ops            = &ip6_dst_ops,
 134                         .path           = (struct dst_entry*)&ip6_null_entry,
 135                 }
 136         },
 137         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 138         .rt6i_metric    = ~(u32) 0,
 139         .rt6i_ref       = ATOMIC_INIT(1),
 140 };
 141
 142 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 143
 144 static int ip6_pkt_prohibit(struct sk_buff *skb);
 145 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
 146 static int ip6_pkt_blk_hole(struct sk_buff *skb);
 147
 148 struct rt6_info ip6_prohibit_entry = {
 149         .u = {
 150                 .dst = {
 151                         .__refcnt       = ATOMIC_INIT(1),
 152                         .__use          = 1,
 153                         .dev            = &loopback_dev,
 154                         .obsolete       = -1,
 155                         .error          = -EACCES,
 156                         .metrics        = { [RTAX_HOPLIMIT - 1] = 255, },
 157                         .input          = ip6_pkt_prohibit,
 158                         .output         = ip6_pkt_prohibit_out,
 159                         .ops            = &ip6_dst_ops,
 160                         .path           = (struct dst_entry*)&ip6_prohibit_entry,
 161                 }
 162         },
 163         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 164         .rt6i_metric    = ~(u32) 0,
 165         .rt6i_ref       = ATOMIC_INIT(1),
 166 };
 167
 168 struct rt6_info ip6_blk_hole_entry = {
 169         .u = {
 170                 .dst = {
 171                         .__refcnt       = ATOMIC_INIT(1),
 172                         .__use          = 1,
 173                         .dev            = &loopback_dev,
 174                         .obsolete       = -1,
 175                         .error          = -EINVAL,
 176                         .metrics        = { [RTAX_HOPLIMIT - 1] = 255, },
 177                         .input          = ip6_pkt_blk_hole,
 178                         .output         = ip6_pkt_blk_hole,
 179                         .ops            = &ip6_dst_ops,
 180                         .path           = (struct dst_entry*)&ip6_blk_hole_entry,
 181                 }
 182         },
 183         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 184         .rt6i_metric    = ~(u32) 0,
 185         .rt6i_ref       = ATOMIC_INIT(1),
 186 };
 187
 188 #endif
 189
 190 /* allocate dst with ip6_dst_ops */
 191 static __inline__ struct rt6_info *ip6_dst_alloc(void)
 192 {
 193         return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
 194 }
 195
 196 static void ip6_dst_destroy(struct dst_entry *dst)
 197 {
 198         struct rt6_info *rt = (struct rt6_info *)dst;
 199         struct inet6_dev *idev = rt->rt6i_idev;
 200
 201         if (idev != NULL) {
 202                 rt->rt6i_idev = NULL;
 203                 in6_dev_put(idev);
 204         }
 205 }
 206
 207 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
 208                            int how)
 209 {
 210         struct rt6_info *rt = (struct rt6_info *)dst;
 211         struct inet6_dev *idev = rt->rt6i_idev;
 212
 213         if (dev != &loopback_dev && idev != NULL && idev->dev == dev) {
 214                 struct inet6_dev *loopback_idev = in6_dev_get(&loopback_dev);
 215                 if (loopback_idev != NULL) {
 216                         rt->rt6i_idev = loopback_idev;
 217                         in6_dev_put(idev);
 218                 }
 219         }
 220 }
 221
 222 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
 223 {
 224         return (rt->rt6i_flags & RTF_EXPIRES &&
 225                 time_after(jiffies, rt->rt6i_expires));
 226 }
 227
 228 static inline int rt6_need_strict(struct in6_addr *daddr)
 229 {
 230         return (ipv6_addr_type(daddr) &
 231                 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL));
 232 }
 233
 234 /*
 235  *      Route lookup. Any table->tb6_lock is implied.
 236  */
 237
 238 static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
 239                                                     int oif,
 240                                                     int strict)
 241 {
 242         struct rt6_info *local = NULL;
 243         struct rt6_info *sprt;
 244
 245         if (oif) {
 246                 for (sprt = rt; sprt; sprt = sprt->u.dst.rt6_next) {
 247                         struct net_device *dev = sprt->rt6i_dev;
 248                         if (dev->ifindex == oif)
 249                                 return sprt;
 250                         if (dev->flags & IFF_LOOPBACK) {
 251                                 if (sprt->rt6i_idev == NULL ||
 252                                     sprt->rt6i_idev->dev->ifindex != oif) {
 253                                         if (strict && oif)
 254                                                 continue;
 255                                         if (local && (!oif ||
 256                                                       local->rt6i_idev->dev->ifindex == oif))
 257                                                 continue;
 258                                 }
 259                                 local = sprt;
 260                         }
 261                 }
 262
 263                 if (local)
 264                         return local;
 265
 266                 if (strict)
 267                         return &ip6_null_entry;
 268         }
 269         return rt;
 270 }
 271
 272 #ifdef CONFIG_IPV6_ROUTER_PREF
 273 static void rt6_probe(struct rt6_info *rt)
 274 {
 275         struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
 276         /*
 277          * Okay, this does not seem to be appropriate
 278          * for now, however, we need to check if it
 279          * is really so; aka Router Reachability Probing.
 280          *
 281          * Router Reachability Probe MUST be rate-limited
 282          * to no more than one per minute.
 283          */
 284         if (!neigh || (neigh->nud_state & NUD_VALID))
 285                 return;
 286         read_lock_bh(&neigh->lock);
 287         if (!(neigh->nud_state & NUD_VALID) &&
 288             time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
 289                 struct in6_addr mcaddr;
 290                 struct in6_addr *target;
 291
 292                 neigh->updated = jiffies;
 293                 read_unlock_bh(&neigh->lock);
 294
 295                 target = (struct in6_addr *)&neigh->primary_key;
 296                 addrconf_addr_solict_mult(target, &mcaddr);
 297                 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
 298         } else
 299                 read_unlock_bh(&neigh->lock);
 300 }
 301 #else
 302 static inline void rt6_probe(struct rt6_info *rt)
 303 {
 304         return;
 305 }
 306 #endif
 307
 308 /*
 309  * Default Router Selection (RFC 2461 6.3.6)
 310  */
 311 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
 312 {
 313         struct net_device *dev = rt->rt6i_dev;
 314         int ret = 0;
 315
 316         if (!oif)
 317                 return 2;
 318         if (dev->flags & IFF_LOOPBACK) {
 319                 if (!WARN_ON(rt->rt6i_idev == NULL) &&
 320                     rt->rt6i_idev->dev->ifindex == oif)
 321                         ret = 1;
 322                 else
 323                         return 0;
 324         }
 325         if (dev->ifindex == oif)
 326                 return 2;
 327
 328         return ret;
 329 }
 330
 331 static inline int rt6_check_neigh(struct rt6_info *rt)
 332 {
 333         struct neighbour *neigh = rt->rt6i_nexthop;
 334         int m = 0;
 335         if (rt->rt6i_flags & RTF_NONEXTHOP ||
 336             !(rt->rt6i_flags & RTF_GATEWAY))
 337                 m = 1;
 338         else if (neigh) {
 339                 read_lock_bh(&neigh->lock);
 340                 if (neigh->nud_state & NUD_VALID)
 341                         m = 2;
 342                 else if (!(neigh->nud_state & NUD_FAILED))
 343                         m = 1;
 344                 read_unlock_bh(&neigh->lock);
 345         }
 346         return m;
 347 }
 348
 349 static int rt6_score_route(struct rt6_info *rt, int oif,
 350                            int strict)
 351 {
 352         int m, n;
 353
 354         m = rt6_check_dev(rt, oif);
 355         if (!m && (strict & RT6_LOOKUP_F_IFACE))
 356                 return -1;
 357 #ifdef CONFIG_IPV6_ROUTER_PREF
 358         m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
 359 #endif
 360         n = rt6_check_neigh(rt);
 361         if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
 362                 return -1;
 363         return m;
 364 }
 365
 366 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
 367                                    int *mpri, struct rt6_info *match)
 368 {
 369         int m;
 370
 371         if (rt6_check_expired(rt))
 372                 goto out;
 373
 374         m = rt6_score_route(rt, oif, strict);
 375         if (m < 0)
 376                 goto out;
 377
 378         if (m > *mpri) {
 379                 if (strict & RT6_LOOKUP_F_REACHABLE)
 380                         rt6_probe(match);
 381                 *mpri = m;
 382                 match = rt;
 383         } else if (strict & RT6_LOOKUP_F_REACHABLE) {
 384                 rt6_probe(rt);
 385         }
 386
 387 out:
 388         return match;
 389 }
 390
 391 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
 392                                      struct rt6_info *rr_head,
 393                                      u32 metric, int oif, int strict)
 394 {
 395         struct rt6_info *rt, *match;
 396         int mpri = -1;
 397
 398         match = NULL;
 399         for (rt = rr_head; rt && rt->rt6i_metric == metric;
 400              rt = rt->u.dst.rt6_next)
 401                 match = find_match(rt, oif, strict, &mpri, match);
 402         for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
 403              rt = rt->u.dst.rt6_next)
 404                 match = find_match(rt, oif, strict, &mpri, match);
 405
 406         return match;
 407 }
 408
 409 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
 410 {
 411         struct rt6_info *match, *rt0;
 412
 413         RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
 414                   __FUNCTION__, fn->leaf, oif);
 415
 416         rt0 = fn->rr_ptr;
 417         if (!rt0)
 418                 fn->rr_ptr = rt0 = fn->leaf;
 419
 420         match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
 421
 422         if (!match &&
 423             (strict & RT6_LOOKUP_F_REACHABLE)) {
 424                 struct rt6_info *next = rt0->u.dst.rt6_next;
 425
 426                 /* no entries matched; do round-robin */
 427                 if (!next || next->rt6i_metric != rt0->rt6i_metric)
 428                         next = fn->leaf;
 429
 430                 if (next != rt0)
 431                         fn->rr_ptr = next;
 432         }
 433
 434         RT6_TRACE("%s() => %p\n",
 435                   __FUNCTION__, match);
 436
 437         return (match ? match : &ip6_null_entry);
 438 }
 439
 440 #ifdef CONFIG_IPV6_ROUTE_INFO
 441 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
 442                   struct in6_addr *gwaddr)
 443 {
 444         struct route_info *rinfo = (struct route_info *) opt;
 445         struct in6_addr prefix_buf, *prefix;
 446         unsigned int pref;
 447         u32 lifetime;
 448         struct rt6_info *rt;
 449
 450         if (len < sizeof(struct route_info)) {
 451                 return -EINVAL;
 452         }
 453
 454         /* Sanity check for prefix_len and length */
 455         if (rinfo->length > 3) {
 456                 return -EINVAL;
 457         } else if (rinfo->prefix_len > 128) {
 458                 return -EINVAL;
 459         } else if (rinfo->prefix_len > 64) {
 460                 if (rinfo->length < 2) {
 461                         return -EINVAL;
 462                 }
 463         } else if (rinfo->prefix_len > 0) {
 464                 if (rinfo->length < 1) {
 465                         return -EINVAL;
 466                 }
 467         }
 468
 469         pref = rinfo->route_pref;
 470         if (pref == ICMPV6_ROUTER_PREF_INVALID)
 471                 pref = ICMPV6_ROUTER_PREF_MEDIUM;
 472
 473         lifetime = ntohl(rinfo->lifetime);
 474         if (lifetime == 0xffffffff) {
 475                 /* infinity */
 476         } else if (lifetime > 0x7fffffff/HZ) {
 477                 /* Avoid arithmetic overflow */
 478                 lifetime = 0x7fffffff/HZ - 1;
 479         }
 480
 481         if (rinfo->length == 3)
 482                 prefix = (struct in6_addr *)rinfo->prefix;
 483         else {
 484                 /* this function is safe */
 485                 ipv6_addr_prefix(&prefix_buf,
 486                                  (struct in6_addr *)rinfo->prefix,
 487                                  rinfo->prefix_len);
 488                 prefix = &prefix_buf;
 489         }
 490
 491         rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
 492
 493         if (rt && !lifetime) {
 494                 ip6_del_rt(rt);
 495                 rt = NULL;
 496         }
 497
 498         if (!rt && lifetime)
 499                 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
 500                                         pref);
 501         else if (rt)
 502                 rt->rt6i_flags = RTF_ROUTEINFO |
 503                                  (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
 504
 505         if (rt) {
 506                 if (lifetime == 0xffffffff) {
 507                         rt->rt6i_flags &= ~RTF_EXPIRES;
 508                 } else {
 509                         rt->rt6i_expires = jiffies + HZ * lifetime;
 510                         rt->rt6i_flags |= RTF_EXPIRES;
 511                 }
 512                 dst_release(&rt->u.dst);
 513         }
 514         return 0;
 515 }
 516 #endif
 517
 518 #define BACKTRACK(saddr) \
 519 do { \
 520         if (rt == &ip6_null_entry) { \
 521                 struct fib6_node *pn; \
 522                 while (1) { \
 523                         if (fn->fn_flags & RTN_TL_ROOT) \
 524                                 goto out; \
 525                         pn = fn->parent; \
 526                         if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
 527                                 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
 528                         else \
 529                                 fn = pn; \
 530                         if (fn->fn_flags & RTN_RTINFO) \
 531                                 goto restart; \
 532                 } \
 533         } \
 534 } while(0)
 535
 536 static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
 537                                              struct flowi *fl, int flags)
 538 {
 539         struct fib6_node *fn;
 540         struct rt6_info *rt;
 541
 542         read_lock_bh(&table->tb6_lock);
 543         fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
 544 restart:
 545         rt = fn->leaf;
 546         rt = rt6_device_match(rt, fl->oif, flags);
 547         BACKTRACK(&fl->fl6_src);
 548 out:
 549         dst_hold(&rt->u.dst);
 550         read_unlock_bh(&table->tb6_lock);
 551
 552         rt->u.dst.lastuse = jiffies;
 553         rt->u.dst.__use++;
 554
 555         return rt;
 556
 557 }
 558
 559 struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
 560                             int oif, int strict)
 561 {
 562         struct flowi fl = {
 563                 .oif = oif,
 564                 .nl_u = {
 565                         .ip6_u = {
 566                                 .daddr = *daddr,
 567                         },
 568                 },
 569         };
 570         struct dst_entry *dst;
 571         int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
 572
 573         if (saddr) {
 574                 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
 575                 flags |= RT6_LOOKUP_F_HAS_SADDR;
 576         }
 577
 578         dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_lookup);
 579         if (dst->error == 0)
 580                 return (struct rt6_info *) dst;
 581
 582         dst_release(dst);
 583
 584         return NULL;
 585 }
 586
 587 /* ip6_ins_rt is called with FREE table->tb6_lock.
 588    It takes new route entry, the addition fails by any reason the
 589    route is freed. In any case, if caller does not hold it, it may
 590    be destroyed.
 591  */
 592
 593 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
 594 {
 595         int err;
 596         struct fib6_table *table;
 597
 598         table = rt->rt6i_table;
 599         write_lock_bh(&table->tb6_lock);
 600         err = fib6_add(&table->tb6_root, rt, info);
 601         write_unlock_bh(&table->tb6_lock);
 602
 603         return err;
 604 }
 605
 606 int ip6_ins_rt(struct rt6_info *rt)
 607 {
 608         return __ip6_ins_rt(rt, NULL);
 609 }
 610
 611 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
 612                                       struct in6_addr *saddr)
 613 {
 614         struct rt6_info *rt;
 615
 616         /*
 617          *      Clone the route.
 618          */
 619
 620         rt = ip6_rt_copy(ort);
 621
 622         if (rt) {
 623                 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
 624                         if (rt->rt6i_dst.plen != 128 &&
 625                             ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
 626                                 rt->rt6i_flags |= RTF_ANYCAST;
 627                         ipv6_addr_copy(&rt->rt6i_gateway, daddr);
 628                 }
 629
 630                 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
 631                 rt->rt6i_dst.plen = 128;
 632                 rt->rt6i_flags |= RTF_CACHE;
 633                 rt->u.dst.flags |= DST_HOST;
 634
 635 #ifdef CONFIG_IPV6_SUBTREES
 636                 if (rt->rt6i_src.plen && saddr) {
 637                         ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
 638                         rt->rt6i_src.plen = 128;
 639                 }
 640 #endif
 641
 642                 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
 643
 644         }
 645
 646         return rt;
 647 }
 648
 649 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
 650 {
 651         struct rt6_info *rt = ip6_rt_copy(ort);
 652         if (rt) {
 653                 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
 654                 rt->rt6i_dst.plen = 128;
 655                 rt->rt6i_flags |= RTF_CACHE;
 656                 rt->u.dst.flags |= DST_HOST;
 657                 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
 658         }
 659         return rt;
 660 }
 661
 662 static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
 663                                             struct flowi *fl, int flags)
 664 {
 665         struct fib6_node *fn;
 666         struct rt6_info *rt, *nrt;
 667         int strict = 0;
 668         int attempts = 3;
 669         int err;
 670         int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
 671
 672         strict |= flags & RT6_LOOKUP_F_IFACE;
 673
 674 relookup:
 675         read_lock_bh(&table->tb6_lock);
 676
 677 restart_2:
 678         fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
 679
 680 restart:
 681         rt = rt6_select(fn, fl->iif, strict | reachable);
 682         BACKTRACK(&fl->fl6_src);
 683         if (rt == &ip6_null_entry ||
 684             rt->rt6i_flags & RTF_CACHE)
 685                 goto out;
 686
 687         dst_hold(&rt->u.dst);
 688         read_unlock_bh(&table->tb6_lock);
 689
 690         if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
 691                 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
 692         else {
 693 #if CLONE_OFFLINK_ROUTE
 694                 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
 695 #else
 696                 goto out2;
 697 #endif
 698         }
 699
 700         dst_release(&rt->u.dst);
 701         rt = nrt ? : &ip6_null_entry;
 702
 703         dst_hold(&rt->u.dst);
 704         if (nrt) {
 705                 err = ip6_ins_rt(nrt);
 706                 if (!err)
 707                         goto out2;
 708         }
 709
 710         if (--attempts <= 0)
 711                 goto out2;
 712
 713         /*
 714          * Race condition! In the gap, when table->tb6_lock was
 715          * released someone could insert this route.  Relookup.
 716          */
 717         dst_release(&rt->u.dst);
 718         goto relookup;
 719
 720 out:
 721         if (reachable) {
 722                 reachable = 0;
 723                 goto restart_2;
 724         }
 725         dst_hold(&rt->u.dst);
 726         read_unlock_bh(&table->tb6_lock);
 727 out2:
 728         rt->u.dst.lastuse = jiffies;
 729         rt->u.dst.__use++;
 730
 731         return rt;
 732 }
 733
 734 void ip6_route_input(struct sk_buff *skb)
 735 {
 736         struct ipv6hdr *iph = skb->nh.ipv6h;
 737         int flags = RT6_LOOKUP_F_HAS_SADDR;
 738         struct flowi fl = {
 739                 .iif = skb->dev->ifindex,
 740                 .nl_u = {
 741                         .ip6_u = {
 742                                 .daddr = iph->daddr,
 743                                 .saddr = iph->saddr,
 744                                 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
 745                         },
 746                 },
 747                 .mark = skb->mark,
 748                 .proto = iph->nexthdr,
 749         };
 750
 751         if (rt6_need_strict(&iph->daddr))
 752                 flags |= RT6_LOOKUP_F_IFACE;
 753
 754         skb->dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_input);
 755 }
 756
 757 static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
 758                                              struct flowi *fl, int flags)
 759 {
 760         struct fib6_node *fn;
 761         struct rt6_info *rt, *nrt;
 762         int strict = 0;
 763         int attempts = 3;
 764         int err;
 765         int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
 766
 767         strict |= flags & RT6_LOOKUP_F_IFACE;
 768
 769 relookup:
 770         read_lock_bh(&table->tb6_lock);
 771
 772 restart_2:
 773         fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
 774
 775 restart:
 776         rt = rt6_select(fn, fl->oif, strict | reachable);
 777         BACKTRACK(&fl->fl6_src);
 778         if (rt == &ip6_null_entry ||
 779             rt->rt6i_flags & RTF_CACHE)
 780                 goto out;
 781
 782         dst_hold(&rt->u.dst);
 783         read_unlock_bh(&table->tb6_lock);
 784
 785         if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
 786                 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
 787         else {
 788 #if CLONE_OFFLINK_ROUTE
 789                 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
 790 #else
 791                 goto out2;
 792 #endif
 793         }
 794
 795         dst_release(&rt->u.dst);
 796         rt = nrt ? : &ip6_null_entry;
 797
 798         dst_hold(&rt->u.dst);
 799         if (nrt) {
 800                 err = ip6_ins_rt(nrt);
 801                 if (!err)
 802                         goto out2;
 803         }
 804
 805         if (--attempts <= 0)
 806                 goto out2;
 807
 808         /*
 809          * Race condition! In the gap, when table->tb6_lock was
 810          * released someone could insert this route.  Relookup.
 811          */
 812         dst_release(&rt->u.dst);
 813         goto relookup;
 814
 815 out:
 816         if (reachable) {
 817                 reachable = 0;
 818                 goto restart_2;
 819         }
 820         dst_hold(&rt->u.dst);
 821         read_unlock_bh(&table->tb6_lock);
 822 out2:
 823         rt->u.dst.lastuse = jiffies;
 824         rt->u.dst.__use++;
 825         return rt;
 826 }
 827
 828 struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
 829 {
 830         int flags = 0;
 831
 832         if (rt6_need_strict(&fl->fl6_dst))
 833                 flags |= RT6_LOOKUP_F_IFACE;
 834
 835         if (!ipv6_addr_any(&fl->fl6_src))
 836                 flags |= RT6_LOOKUP_F_HAS_SADDR;
 837
 838         return fib6_rule_lookup(fl, flags, ip6_pol_route_output);
 839 }
 840
 841
 842 /*
 843  *      Destination cache support functions
 844  */
 845
 846 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
 847 {
 848         struct rt6_info *rt;
 849
 850         rt = (struct rt6_info *) dst;
 851
 852         if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
 853                 return dst;
 854
 855         return NULL;
 856 }
 857
 858 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
 859 {
 860         struct rt6_info *rt = (struct rt6_info *) dst;
 861
 862         if (rt) {
 863                 if (rt->rt6i_flags & RTF_CACHE)
 864                         ip6_del_rt(rt);
 865                 else
 866                         dst_release(dst);
 867         }
 868         return NULL;
 869 }
 870
 871 static void ip6_link_failure(struct sk_buff *skb)
 872 {
 873         struct rt6_info *rt;
 874
 875         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
 876
 877         rt = (struct rt6_info *) skb->dst;
 878         if (rt) {
 879                 if (rt->rt6i_flags&RTF_CACHE) {
 880                         dst_set_expires(&rt->u.dst, 0);
 881                         rt->rt6i_flags |= RTF_EXPIRES;
 882                 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
 883                         rt->rt6i_node->fn_sernum = -1;
 884         }
 885 }
 886
 887 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
 888 {
 889         struct rt6_info *rt6 = (struct rt6_info*)dst;
 890
 891         if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
 892                 rt6->rt6i_flags |= RTF_MODIFIED;
 893                 if (mtu < IPV6_MIN_MTU) {
 894                         mtu = IPV6_MIN_MTU;
 895                         dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
 896                 }
 897                 dst->metrics[RTAX_MTU-1] = mtu;
 898                 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
 899         }
 900 }
 901
 902 static int ipv6_get_mtu(struct net_device *dev);
 903
 904 static inline unsigned int ipv6_advmss(unsigned int mtu)
 905 {
 906         mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
 907
 908         if (mtu < ip6_rt_min_advmss)
 909                 mtu = ip6_rt_min_advmss;
 910
 911         /*
 912          * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
 913          * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
 914          * IPV6_MAXPLEN is also valid and means: "any MSS,
 915          * rely only on pmtu discovery"
 916          */
 917         if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
 918                 mtu = IPV6_MAXPLEN;
 919         return mtu;
 920 }
 921
 922 static struct dst_entry *ndisc_dst_gc_list;
 923 static DEFINE_SPINLOCK(ndisc_lock);
 924
 925 struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
 926                                   struct neighbour *neigh,
 927                                   struct in6_addr *addr,
 928                                   int (*output)(struct sk_buff *))
 929 {
 930         struct rt6_info *rt;
 931         struct inet6_dev *idev = in6_dev_get(dev);
 932
 933         if (unlikely(idev == NULL))
 934                 return NULL;
 935
 936         rt = ip6_dst_alloc();
 937         if (unlikely(rt == NULL)) {
 938                 in6_dev_put(idev);
 939                 goto out;
 940         }
 941
 942         dev_hold(dev);
 943         if (neigh)
 944                 neigh_hold(neigh);
 945         else
 946                 neigh = ndisc_get_neigh(dev, addr);
 947
 948         rt->rt6i_dev      = dev;
 949         rt->rt6i_idev     = idev;
 950         rt->rt6i_nexthop  = neigh;
 951         atomic_set(&rt->u.dst.__refcnt, 1);
 952         rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
 953         rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
 954         rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
 955         rt->u.dst.output  = output;
 956
 957 #if 0   /* there's no chance to use these for ndisc */
 958         rt->u.dst.flags   = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
 959                                 ? DST_HOST
 960                                 : 0;
 961         ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
 962         rt->rt6i_dst.plen = 128;
 963 #endif
 964
 965         spin_lock_bh(&ndisc_lock);
 966         rt->u.dst.next = ndisc_dst_gc_list;
 967         ndisc_dst_gc_list = &rt->u.dst;
 968         spin_unlock_bh(&ndisc_lock);
 969
 970         fib6_force_start_gc();
 971
 972 out:
 973         return &rt->u.dst;
 974 }
 975
 976 int ndisc_dst_gc(int *more)
 977 {
 978         struct dst_entry *dst, *next, **pprev;
 979         int freed;
 980
 981         next = NULL;
 982         freed = 0;
 983
 984         spin_lock_bh(&ndisc_lock);
 985         pprev = &ndisc_dst_gc_list;
 986
 987         while ((dst = *pprev) != NULL) {
 988                 if (!atomic_read(&dst->__refcnt)) {
 989                         *pprev = dst->next;
 990                         dst_free(dst);
 991                         freed++;
 992                 } else {
 993                         pprev = &dst->next;
 994                         (*more)++;
 995                 }
 996         }
 997
 998         spin_unlock_bh(&ndisc_lock);
 999
1000         return freed;
1001 }
1002
1003 static int ip6_dst_gc(void)
1004 {
1005         static unsigned expire = 30*HZ;
1006         static unsigned long last_gc;
1007         unsigned long now = jiffies;
1008
1009         if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
1010             atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
1011                 goto out;
1012
1013         expire++;
1014         fib6_run_gc(expire);
1015         last_gc = now;
1016         if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
1017                 expire = ip6_rt_gc_timeout>>1;
1018
1019 out:
1020         expire -= expire>>ip6_rt_gc_elasticity;
1021         return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
1022 }
1023
1024 /* Clean host part of a prefix. Not necessary in radix tree,
1025    but results in cleaner routing tables.
1026
1027    Remove it only when all the things will work!
1028  */
1029
1030 static int ipv6_get_mtu(struct net_device *dev)
1031 {
1032         int mtu = IPV6_MIN_MTU;
1033         struct inet6_dev *idev;
1034
1035         idev = in6_dev_get(dev);
1036         if (idev) {
1037                 mtu = idev->cnf.mtu6;
1038                 in6_dev_put(idev);
1039         }
1040         return mtu;
1041 }
1042
1043 int ipv6_get_hoplimit(struct net_device *dev)
1044 {
1045         int hoplimit = ipv6_devconf.hop_limit;
1046         struct inet6_dev *idev;
1047
1048         idev = in6_dev_get(dev);
1049         if (idev) {
1050                 hoplimit = idev->cnf.hop_limit;
1051                 in6_dev_put(idev);
1052         }
1053         return hoplimit;
1054 }
1055
1056 /*
1057  *
1058  */
1059
1060 int ip6_route_add(struct fib6_config *cfg)
1061 {
1062         int err;
1063         struct rt6_info *rt = NULL;
1064         struct net_device *dev = NULL;
1065         struct inet6_dev *idev = NULL;
1066         struct fib6_table *table;
1067         int addr_type;
1068
1069         if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1070                 return -EINVAL;
1071 #ifndef CONFIG_IPV6_SUBTREES
1072         if (cfg->fc_src_len)
1073                 return -EINVAL;
1074 #endif
1075         if (cfg->fc_ifindex) {
1076                 err = -ENODEV;
1077                 dev = dev_get_by_index(cfg->fc_ifindex);
1078                 if (!dev)
1079                         goto out;
1080                 idev = in6_dev_get(dev);
1081                 if (!idev)
1082                         goto out;
1083         }
1084
1085         if (cfg->fc_metric == 0)
1086                 cfg->fc_metric = IP6_RT_PRIO_USER;
1087
1088         table = fib6_new_table(cfg->fc_table);
1089         if (table == NULL) {
1090                 err = -ENOBUFS;
1091                 goto out;
1092         }
1093
1094         rt = ip6_dst_alloc();
1095
1096         if (rt == NULL) {
1097                 err = -ENOMEM;
1098                 goto out;
1099         }
1100
1101         rt->u.dst.obsolete = -1;
1102         rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
1103
1104         if (cfg->fc_protocol == RTPROT_UNSPEC)
1105                 cfg->fc_protocol = RTPROT_BOOT;
1106         rt->rt6i_protocol = cfg->fc_protocol;
1107
1108         addr_type = ipv6_addr_type(&cfg->fc_dst);
1109
1110         if (addr_type & IPV6_ADDR_MULTICAST)
1111                 rt->u.dst.input = ip6_mc_input;
1112         else
1113                 rt->u.dst.input = ip6_forward;
1114
1115         rt->u.dst.output = ip6_output;
1116
1117         ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1118         rt->rt6i_dst.plen = cfg->fc_dst_len;
1119         if (rt->rt6i_dst.plen == 128)
1120                rt->u.dst.flags = DST_HOST;
1121
1122 #ifdef CONFIG_IPV6_SUBTREES
1123         ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1124         rt->rt6i_src.plen = cfg->fc_src_len;
1125 #endif
1126
1127         rt->rt6i_metric = cfg->fc_metric;
1128
1129         /* We cannot add true routes via loopback here,
1130            they would result in kernel looping; promote them to reject routes
1131          */
1132         if ((cfg->fc_flags & RTF_REJECT) ||
1133             (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1134                 /* hold loopback dev/idev if we haven't done so. */
1135                 if (dev != &loopback_dev) {
1136                         if (dev) {
1137                                 dev_put(dev);
1138                                 in6_dev_put(idev);
1139                         }
1140                         dev = &loopback_dev;
1141                         dev_hold(dev);
1142                         idev = in6_dev_get(dev);
1143                         if (!idev) {
1144                                 err = -ENODEV;
1145                                 goto out;
1146                         }
1147                 }
1148                 rt->u.dst.output = ip6_pkt_discard_out;
1149                 rt->u.dst.input = ip6_pkt_discard;
1150                 rt->u.dst.error = -ENETUNREACH;
1151                 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1152                 goto install_route;
1153         }
1154
1155         if (cfg->fc_flags & RTF_GATEWAY) {
1156                 struct in6_addr *gw_addr;
1157                 int gwa_type;
1158
1159                 gw_addr = &cfg->fc_gateway;
1160                 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
1161                 gwa_type = ipv6_addr_type(gw_addr);
1162
1163                 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1164                         struct rt6_info *grt;
1165
1166                         /* IPv6 strictly inhibits using not link-local
1167                            addresses as nexthop address.
1168                            Otherwise, router will not able to send redirects.
1169                            It is very good, but in some (rare!) circumstances
1170                            (SIT, PtP, NBMA NOARP links) it is handy to allow
1171                            some exceptions. --ANK
1172                          */
1173                         err = -EINVAL;
1174                         if (!(gwa_type&IPV6_ADDR_UNICAST))
1175                                 goto out;
1176
1177                         grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
1178
1179                         err = -EHOSTUNREACH;
1180                         if (grt == NULL)
1181                                 goto out;
1182                         if (dev) {
1183                                 if (dev != grt->rt6i_dev) {
1184                                         dst_release(&grt->u.dst);
1185                                         goto out;
1186                                 }
1187                         } else {
1188                                 dev = grt->rt6i_dev;
1189                                 idev = grt->rt6i_idev;
1190                                 dev_hold(dev);
1191                                 in6_dev_hold(grt->rt6i_idev);
1192                         }
1193                         if (!(grt->rt6i_flags&RTF_GATEWAY))
1194                                 err = 0;
1195                         dst_release(&grt->u.dst);
1196
1197                         if (err)
1198                                 goto out;
1199                 }
1200                 err = -EINVAL;
1201                 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1202                         goto out;
1203         }
1204
1205         err = -ENODEV;
1206         if (dev == NULL)
1207                 goto out;
1208
1209         if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1210                 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1211                 if (IS_ERR(rt->rt6i_nexthop)) {
1212                         err = PTR_ERR(rt->rt6i_nexthop);
1213                         rt->rt6i_nexthop = NULL;
1214                         goto out;
1215                 }
1216         }
1217
1218         rt->rt6i_flags = cfg->fc_flags;
1219
1220 install_route:
1221         if (cfg->fc_mx) {
1222                 struct nlattr *nla;
1223                 int remaining;
1224
1225                 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1226                         int type = nla->nla_type;
1227
1228                         if (type) {
1229                                 if (type > RTAX_MAX) {
1230                                         err = -EINVAL;
1231                                         goto out;
1232                                 }
1233
1234                                 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
1235                         }
1236                 }
1237         }
1238
1239         if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1240                 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1241         if (!rt->u.dst.metrics[RTAX_MTU-1])
1242                 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1243         if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1244                 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1245         rt->u.dst.dev = dev;
1246         rt->rt6i_idev = idev;
1247         rt->rt6i_table = table;
1248         return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1249
1250 out:
1251         if (dev)
1252                 dev_put(dev);
1253         if (idev)
1254                 in6_dev_put(idev);
1255         if (rt)
1256                 dst_free(&rt->u.dst);
1257         return err;
1258 }
1259
1260 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1261 {
1262         int err;
1263         struct fib6_table *table;
1264
1265         if (rt == &ip6_null_entry)
1266                 return -ENOENT;
1267
1268         table = rt->rt6i_table;
1269         write_lock_bh(&table->tb6_lock);
1270
1271         err = fib6_del(rt, info);
1272         dst_release(&rt->u.dst);
1273
1274         write_unlock_bh(&table->tb6_lock);
1275
1276         return err;
1277 }
1278
1279 int ip6_del_rt(struct rt6_info *rt)
1280 {
1281         return __ip6_del_rt(rt, NULL);
1282 }
1283
1284 static int ip6_route_del(struct fib6_config *cfg)
1285 {
1286         struct fib6_table *table;
1287         struct fib6_node *fn;
1288         struct rt6_info *rt;
1289         int err = -ESRCH;
1290
1291         table = fib6_get_table(cfg->fc_table);
1292         if (table == NULL)
1293                 return err;
1294
1295         read_lock_bh(&table->tb6_lock);
1296
1297         fn = fib6_locate(&table->tb6_root,
1298                          &cfg->fc_dst, cfg->fc_dst_len,
1299                          &cfg->fc_src, cfg->fc_src_len);
1300
1301         if (fn) {
1302                 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1303                         if (cfg->fc_ifindex &&
1304                             (rt->rt6i_dev == NULL ||
1305                              rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1306                                 continue;
1307                         if (cfg->fc_flags & RTF_GATEWAY &&
1308                             !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1309                                 continue;
1310                         if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1311                                 continue;
1312                         dst_hold(&rt->u.dst);
1313                         read_unlock_bh(&table->tb6_lock);
1314
1315                         return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1316                 }
1317         }
1318         read_unlock_bh(&table->tb6_lock);
1319
1320         return err;
1321 }
1322
1323 /*
1324  *      Handle redirects
1325  */
1326 struct ip6rd_flowi {
1327         struct flowi fl;
1328         struct in6_addr gateway;
1329 };
1330
1331 static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1332                                              struct flowi *fl,
1333                                              int flags)
1334 {
1335         struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1336         struct rt6_info *rt;
1337         struct fib6_node *fn;
1338
1339         /*
1340          * Get the "current" route for this destination and
1341          * check if the redirect has come from approriate router.
1342          *
1343          * RFC 2461 specifies that redirects should only be
1344          * accepted if they come from the nexthop to the target.
1345          * Due to the way the routes are chosen, this notion
1346          * is a bit fuzzy and one might need to check all possible
1347          * routes.
1348          */
1349
1350         read_lock_bh(&table->tb6_lock);
1351         fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1352 restart:
1353         for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1354                 /*
1355                  * Current route is on-link; redirect is always invalid.
1356                  *
1357                  * Seems, previous statement is not true. It could
1358                  * be node, which looks for us as on-link (f.e. proxy ndisc)
1359                  * But then router serving it might decide, that we should
1360                  * know truth 8)8) --ANK (980726).
1361                  */
1362                 if (rt6_check_expired(rt))
1363                         continue;
1364                 if (!(rt->rt6i_flags & RTF_GATEWAY))
1365                         continue;
1366                 if (fl->oif != rt->rt6i_dev->ifindex)
1367                         continue;
1368                 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1369                         continue;
1370                 break;
1371         }
1372
1373         if (!rt)
1374                 rt = &ip6_null_entry;
1375         BACKTRACK(&fl->fl6_src);
1376 out:
1377         dst_hold(&rt->u.dst);
1378
1379         read_unlock_bh(&table->tb6_lock);
1380
1381         return rt;
1382 };
1383
1384 static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1385                                            struct in6_addr *src,
1386                                            struct in6_addr *gateway,
1387                                            struct net_device *dev)
1388 {
1389         int flags = RT6_LOOKUP_F_HAS_SADDR;
1390         struct ip6rd_flowi rdfl = {
1391                 .fl = {
1392                         .oif = dev->ifindex,
1393                         .nl_u = {
1394                                 .ip6_u = {
1395                                         .daddr = *dest,
1396                                         .saddr = *src,
1397                                 },
1398                         },
1399                 },
1400                 .gateway = *gateway,
1401         };
1402
1403         if (rt6_need_strict(dest))
1404                 flags |= RT6_LOOKUP_F_IFACE;
1405
1406         return (struct rt6_info *)fib6_rule_lookup((struct flowi *)&rdfl, flags, __ip6_route_redirect);
1407 }
1408
1409 void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1410                   struct in6_addr *saddr,
1411                   struct neighbour *neigh, u8 *lladdr, int on_link)
1412 {
1413         struct rt6_info *rt, *nrt = NULL;
1414         struct netevent_redirect netevent;
1415
1416         rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1417
1418         if (rt == &ip6_null_entry) {
1419                 if (net_ratelimit())
1420                         printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1421                                "for redirect target\n");
1422                 goto out;
1423         }
1424
1425         /*
1426          *      We have finally decided to accept it.
1427          */
1428
1429         neigh_update(neigh, lladdr, NUD_STALE,
1430                      NEIGH_UPDATE_F_WEAK_OVERRIDE|
1431                      NEIGH_UPDATE_F_OVERRIDE|
1432                      (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1433                                      NEIGH_UPDATE_F_ISROUTER))
1434                      );
1435
1436         /*
1437          * Redirect received -> path was valid.
1438          * Look, redirects are sent only in response to data packets,
1439          * so that this nexthop apparently is reachable. --ANK
1440          */
1441         dst_confirm(&rt->u.dst);
1442
1443         /* Duplicate redirect: silently ignore. */
1444         if (neigh == rt->u.dst.neighbour)
1445                 goto out;
1446
1447         nrt = ip6_rt_copy(rt);
1448         if (nrt == NULL)
1449                 goto out;
1450
1451         nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1452         if (on_link)
1453                 nrt->rt6i_flags &= ~RTF_GATEWAY;
1454
1455         ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1456         nrt->rt6i_dst.plen = 128;
1457         nrt->u.dst.flags |= DST_HOST;
1458
1459         ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1460         nrt->rt6i_nexthop = neigh_clone(neigh);
1461         /* Reset pmtu, it may be better */
1462         nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1463         nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1464
1465         if (ip6_ins_rt(nrt))
1466                 goto out;
1467
1468         netevent.old = &rt->u.dst;
1469         netevent.new = &nrt->u.dst;
1470         call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1471
1472         if (rt->rt6i_flags&RTF_CACHE) {
1473                 ip6_del_rt(rt);
1474                 return;
1475         }
1476
1477 out:
1478         dst_release(&rt->u.dst);
1479         return;
1480 }
1481
1482 /*
1483  *      Handle ICMP "packet too big" messages
1484  *      i.e. Path MTU discovery
1485  */
1486
1487 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1488                         struct net_device *dev, u32 pmtu)
1489 {
1490         struct rt6_info *rt, *nrt;
1491         int allfrag = 0;
1492
1493         rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1494         if (rt == NULL)
1495                 return;
1496
1497         if (pmtu >= dst_mtu(&rt->u.dst))
1498                 goto out;
1499
1500         if (pmtu < IPV6_MIN_MTU) {
1501                 /*
1502                  * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1503                  * MTU (1280) and a fragment header should always be included
1504                  * after a node receiving Too Big message reporting PMTU is
1505                  * less than the IPv6 Minimum Link MTU.
1506                  */
1507                 pmtu = IPV6_MIN_MTU;
1508                 allfrag = 1;
1509         }
1510
1511         /* New mtu received -> path was valid.
1512            They are sent only in response to data packets,
1513            so that this nexthop apparently is reachable. --ANK
1514          */
1515         dst_confirm(&rt->u.dst);
1516
1517         /* Host route. If it is static, it would be better
1518            not to override it, but add new one, so that
1519            when cache entry will expire old pmtu
1520            would return automatically.
1521          */
1522         if (rt->rt6i_flags & RTF_CACHE) {
1523                 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1524                 if (allfrag)
1525                         rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1526                 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1527                 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1528                 goto out;
1529         }
1530
1531         /* Network route.
1532            Two cases are possible:
1533            1. It is connected route. Action: COW
1534            2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1535          */
1536         if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1537                 nrt = rt6_alloc_cow(rt, daddr, saddr);
1538         else
1539                 nrt = rt6_alloc_clone(rt, daddr);
1540
1541         if (nrt) {
1542                 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1543                 if (allfrag)
1544                         nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1545
1546                 /* According to RFC 1981, detecting PMTU increase shouldn't be
1547                  * happened within 5 mins, the recommended timer is 10 mins.
1548                  * Here this route expiration time is set to ip6_rt_mtu_expires
1549                  * which is 10 mins. After 10 mins the decreased pmtu is expired
1550                  * and detecting PMTU increase will be automatically happened.
1551                  */
1552                 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1553                 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1554
1555                 ip6_ins_rt(nrt);
1556         }
1557 out:
1558         dst_release(&rt->u.dst);
1559 }
1560
1561 /*
1562  *      Misc support functions
1563  */
1564
1565 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1566 {
1567         struct rt6_info *rt = ip6_dst_alloc();
1568
1569         if (rt) {
1570                 rt->u.dst.input = ort->u.dst.input;
1571                 rt->u.dst.output = ort->u.dst.output;
1572
1573                 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
1574                 rt->u.dst.error = ort->u.dst.error;
1575                 rt->u.dst.dev = ort->u.dst.dev;
1576                 if (rt->u.dst.dev)
1577                         dev_hold(rt->u.dst.dev);
1578                 rt->rt6i_idev = ort->rt6i_idev;
1579                 if (rt->rt6i_idev)
1580                         in6_dev_hold(rt->rt6i_idev);
1581                 rt->u.dst.lastuse = jiffies;
1582                 rt->rt6i_expires = 0;
1583
1584                 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1585                 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1586                 rt->rt6i_metric = 0;
1587
1588                 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1589 #ifdef CONFIG_IPV6_SUBTREES
1590                 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1591 #endif
1592                 rt->rt6i_table = ort->rt6i_table;
1593         }
1594         return rt;
1595 }
1596
1597 #ifdef CONFIG_IPV6_ROUTE_INFO
1598 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1599                                            struct in6_addr *gwaddr, int ifindex)
1600 {
1601         struct fib6_node *fn;
1602         struct rt6_info *rt = NULL;
1603         struct fib6_table *table;
1604
1605         table = fib6_get_table(RT6_TABLE_INFO);
1606         if (table == NULL)
1607                 return NULL;
1608
1609         write_lock_bh(&table->tb6_lock);
1610         fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1611         if (!fn)
1612                 goto out;
1613
1614         for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1615                 if (rt->rt6i_dev->ifindex != ifindex)
1616                         continue;
1617                 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1618                         continue;
1619                 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1620                         continue;
1621                 dst_hold(&rt->u.dst);
1622                 break;
1623         }
1624 out:
1625         write_unlock_bh(&table->tb6_lock);
1626         return rt;
1627 }
1628
1629 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1630                                            struct in6_addr *gwaddr, int ifindex,
1631                                            unsigned pref)
1632 {
1633         struct fib6_config cfg = {
1634                 .fc_table       = RT6_TABLE_INFO,
1635                 .fc_metric      = 1024,
1636                 .fc_ifindex     = ifindex,
1637                 .fc_dst_len     = prefixlen,
1638                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1639                                   RTF_UP | RTF_PREF(pref),
1640         };
1641
1642         ipv6_addr_copy(&cfg.fc_dst, prefix);
1643         ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1644
1645         /* We should treat it as a default route if prefix length is 0. */
1646         if (!prefixlen)
1647                 cfg.fc_flags |= RTF_DEFAULT;
1648
1649         ip6_route_add(&cfg);
1650
1651         return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1652 }
1653 #endif
1654
1655 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1656 {
1657         struct rt6_info *rt;
1658         struct fib6_table *table;
1659
1660         table = fib6_get_table(RT6_TABLE_DFLT);
1661         if (table == NULL)
1662                 return NULL;
1663
1664         write_lock_bh(&table->tb6_lock);
1665         for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
1666                 if (dev == rt->rt6i_dev &&
1667                     ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1668                     ipv6_addr_equal(&rt->rt6i_gateway, addr))
1669                         break;
1670         }
1671         if (rt)
1672                 dst_hold(&rt->u.dst);
1673         write_unlock_bh(&table->tb6_lock);
1674         return rt;
1675 }
1676
1677 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1678                                      struct net_device *dev,
1679                                      unsigned int pref)
1680 {
1681         struct fib6_config cfg = {
1682                 .fc_table       = RT6_TABLE_DFLT,
1683                 .fc_metric      = 1024,
1684                 .fc_ifindex     = dev->ifindex,
1685                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1686                                   RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1687         };
1688
1689         ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1690
1691         ip6_route_add(&cfg);
1692
1693         return rt6_get_dflt_router(gwaddr, dev);
1694 }
1695
1696 void rt6_purge_dflt_routers(void)
1697 {
1698         struct rt6_info *rt;
1699         struct fib6_table *table;
1700
1701         /* NOTE: Keep consistent with rt6_get_dflt_router */
1702         table = fib6_get_table(RT6_TABLE_DFLT);
1703         if (table == NULL)
1704                 return;
1705
1706 restart:
1707         read_lock_bh(&table->tb6_lock);
1708         for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
1709                 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1710                         dst_hold(&rt->u.dst);
1711                         read_unlock_bh(&table->tb6_lock);
1712                         ip6_del_rt(rt);
1713                         goto restart;
1714                 }
1715         }
1716         read_unlock_bh(&table->tb6_lock);
1717 }
1718
1719 static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1720                                  struct fib6_config *cfg)
1721 {
1722         memset(cfg, 0, sizeof(*cfg));
1723
1724         cfg->fc_table = RT6_TABLE_MAIN;
1725         cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1726         cfg->fc_metric = rtmsg->rtmsg_metric;
1727         cfg->fc_expires = rtmsg->rtmsg_info;
1728         cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1729         cfg->fc_src_len = rtmsg->rtmsg_src_len;
1730         cfg->fc_flags = rtmsg->rtmsg_flags;
1731
1732         ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1733         ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1734         ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1735 }
1736
1737 int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1738 {
1739         struct fib6_config cfg;
1740         struct in6_rtmsg rtmsg;
1741         int err;
1742
1743         switch(cmd) {
1744         case SIOCADDRT:         /* Add a route */
1745         case SIOCDELRT:         /* Delete a route */
1746                 if (!capable(CAP_NET_ADMIN))
1747                         return -EPERM;
1748                 err = copy_from_user(&rtmsg, arg,
1749                                      sizeof(struct in6_rtmsg));
1750                 if (err)
1751                         return -EFAULT;
1752
1753                 rtmsg_to_fib6_config(&rtmsg, &cfg);
1754
1755                 rtnl_lock();
1756                 switch (cmd) {
1757                 case SIOCADDRT:
1758                         err = ip6_route_add(&cfg);
1759                         break;
1760                 case SIOCDELRT:
1761                         err = ip6_route_del(&cfg);
1762                         break;
1763                 default:
1764                         err = -EINVAL;
1765                 }
1766                 rtnl_unlock();
1767
1768                 return err;
1769         };
1770
1771         return -EINVAL;
1772 }
1773
1774 /*
1775  *      Drop the packet on the floor
1776  */
1777
1778 static inline int ip6_pkt_drop(struct sk_buff *skb, int code)
1779 {
1780         int type = ipv6_addr_type(&skb->nh.ipv6h->daddr);
1781         if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED)
1782                 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
1783
1784         IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_OUTNOROUTES);
1785         icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
1786         kfree_skb(skb);
1787         return 0;
1788 }
1789
1790 static int ip6_pkt_discard(struct sk_buff *skb)
1791 {
1792         return ip6_pkt_drop(skb, ICMPV6_NOROUTE);
1793 }
1794
1795 static int ip6_pkt_discard_out(struct sk_buff *skb)
1796 {
1797         skb->dev = skb->dst->dev;
1798         return ip6_pkt_discard(skb);
1799 }
1800
1801 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
1802
1803 static int ip6_pkt_prohibit(struct sk_buff *skb)
1804 {
1805         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED);
1806 }
1807
1808 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1809 {
1810         skb->dev = skb->dst->dev;
1811         return ip6_pkt_prohibit(skb);
1812 }
1813
1814 static int ip6_pkt_blk_hole(struct sk_buff *skb)
1815 {
1816         kfree_skb(skb);
1817         return 0;
1818 }
1819
1820 #endif
1821
1822 /*
1823  *      Allocate a dst for local (unicast / anycast) address.
1824  */
1825
1826 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1827                                     const struct in6_addr *addr,
1828                                     int anycast)
1829 {
1830         struct rt6_info *rt = ip6_dst_alloc();
1831
1832         if (rt == NULL)
1833                 return ERR_PTR(-ENOMEM);
1834
1835         dev_hold(&loopback_dev);
1836         in6_dev_hold(idev);
1837
1838         rt->u.dst.flags = DST_HOST;
1839         rt->u.dst.input = ip6_input;
1840         rt->u.dst.output = ip6_output;
1841         rt->rt6i_dev = &loopback_dev;
1842         rt->rt6i_idev = idev;
1843         rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1844         rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1845         rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1846         rt->u.dst.obsolete = -1;
1847
1848         rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1849         if (anycast)
1850                 rt->rt6i_flags |= RTF_ANYCAST;
1851         else
1852                 rt->rt6i_flags |= RTF_LOCAL;
1853         rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1854         if (rt->rt6i_nexthop == NULL) {
1855                 dst_free(&rt->u.dst);
1856                 return ERR_PTR(-ENOMEM);
1857         }
1858
1859         ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1860         rt->rt6i_dst.plen = 128;
1861         rt->rt6i_table = fib6_get_table(RT6_TABLE_LOCAL);
1862
1863         atomic_set(&rt->u.dst.__refcnt, 1);
1864
1865         return rt;
1866 }
1867
1868 static int fib6_ifdown(struct rt6_info *rt, void *arg)
1869 {
1870         if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1871             rt != &ip6_null_entry) {
1872                 RT6_TRACE("deleted by ifdown %p\n", rt);
1873                 return -1;
1874         }
1875         return 0;
1876 }
1877
1878 void rt6_ifdown(struct net_device *dev)
1879 {
1880         fib6_clean_all(fib6_ifdown, 0, dev);
1881 }
1882
1883 struct rt6_mtu_change_arg
1884 {
1885         struct net_device *dev;
1886         unsigned mtu;
1887 };
1888
1889 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1890 {
1891         struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1892         struct inet6_dev *idev;
1893
1894         /* In IPv6 pmtu discovery is not optional,
1895            so that RTAX_MTU lock cannot disable it.
1896            We still use this lock to block changes
1897            caused by addrconf/ndisc.
1898         */
1899
1900         idev = __in6_dev_get(arg->dev);
1901         if (idev == NULL)
1902                 return 0;
1903
1904         /* For administrative MTU increase, there is no way to discover
1905            IPv6 PMTU increase, so PMTU increase should be updated here.
1906            Since RFC 1981 doesn't include administrative MTU increase
1907            update PMTU increase is a MUST. (i.e. jumbo frame)
1908          */
1909         /*
1910            If new MTU is less than route PMTU, this new MTU will be the
1911            lowest MTU in the path, update the route PMTU to reflect PMTU
1912            decreases; if new MTU is greater than route PMTU, and the
1913            old MTU is the lowest MTU in the path, update the route PMTU
1914            to reflect the increase. In this case if the other nodes' MTU
1915            also have the lowest MTU, TOO BIG MESSAGE will be lead to
1916            PMTU discouvery.
1917          */
1918         if (rt->rt6i_dev == arg->dev &&
1919             !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1920             (dst_mtu(&rt->u.dst) > arg->mtu ||
1921              (dst_mtu(&rt->u.dst) < arg->mtu &&
1922               dst_mtu(&rt->u.dst) == idev->cnf.mtu6)))
1923                 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1924         rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1925         return 0;
1926 }
1927
1928 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1929 {
1930         struct rt6_mtu_change_arg arg = {
1931                 .dev = dev,
1932                 .mtu = mtu,
1933         };
1934
1935         fib6_clean_all(rt6_mtu_change_route, 0, &arg);
1936 }
1937
1938 static struct nla_policy rtm_ipv6_policy[RTA_MAX+1] __read_mostly = {
1939         [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
1940         [RTA_OIF]               = { .type = NLA_U32 },
1941         [RTA_IIF]               = { .type = NLA_U32 },
1942         [RTA_PRIORITY]          = { .type = NLA_U32 },
1943         [RTA_METRICS]           = { .type = NLA_NESTED },
1944 };
1945
1946 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1947                               struct fib6_config *cfg)
1948 {
1949         struct rtmsg *rtm;
1950         struct nlattr *tb[RTA_MAX+1];
1951         int err;
1952
1953         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1954         if (err < 0)
1955                 goto errout;
1956
1957         err = -EINVAL;
1958         rtm = nlmsg_data(nlh);
1959         memset(cfg, 0, sizeof(*cfg));
1960
1961         cfg->fc_table = rtm->rtm_table;
1962         cfg->fc_dst_len = rtm->rtm_dst_len;
1963         cfg->fc_src_len = rtm->rtm_src_len;
1964         cfg->fc_flags = RTF_UP;
1965         cfg->fc_protocol = rtm->rtm_protocol;
1966
1967         if (rtm->rtm_type == RTN_UNREACHABLE)
1968                 cfg->fc_flags |= RTF_REJECT;
1969
1970         cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1971         cfg->fc_nlinfo.nlh = nlh;
1972
1973         if (tb[RTA_GATEWAY]) {
1974                 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1975                 cfg->fc_flags |= RTF_GATEWAY;
1976         }
1977
1978         if (tb[RTA_DST]) {
1979                 int plen = (rtm->rtm_dst_len + 7) >> 3;
1980
1981                 if (nla_len(tb[RTA_DST]) < plen)
1982                         goto errout;
1983
1984                 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1985         }
1986
1987         if (tb[RTA_SRC]) {
1988                 int plen = (rtm->rtm_src_len + 7) >> 3;
1989
1990                 if (nla_len(tb[RTA_SRC]) < plen)
1991                         goto errout;
1992
1993                 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1994         }
1995
1996         if (tb[RTA_OIF])
1997                 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1998
1999         if (tb[RTA_PRIORITY])
2000                 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2001
2002         if (tb[RTA_METRICS]) {
2003                 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2004                 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2005         }
2006
2007         if (tb[RTA_TABLE])
2008                 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2009
2010         err = 0;
2011 errout:
2012         return err;
2013 }
2014
2015 int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2016 {
2017         struct fib6_config cfg;
2018         int err;
2019
2020         err = rtm_to_fib6_config(skb, nlh, &cfg);
2021         if (err < 0)
2022                 return err;
2023
2024         return ip6_route_del(&cfg);
2025 }
2026
2027 int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2028 {
2029         struct fib6_config cfg;
2030         int err;
2031
2032         err = rtm_to_fib6_config(skb, nlh, &cfg);
2033         if (err < 0)
2034                 return err;
2035
2036         return ip6_route_add(&cfg);
2037 }
2038
2039 static inline size_t rt6_nlmsg_size(void)
2040 {
2041         return NLMSG_ALIGN(sizeof(struct rtmsg))
2042                + nla_total_size(16) /* RTA_SRC */
2043                + nla_total_size(16) /* RTA_DST */
2044                + nla_total_size(16) /* RTA_GATEWAY */
2045                + nla_total_size(16) /* RTA_PREFSRC */
2046                + nla_total_size(4) /* RTA_TABLE */
2047                + nla_total_size(4) /* RTA_IIF */
2048                + nla_total_size(4) /* RTA_OIF */
2049                + nla_total_size(4) /* RTA_PRIORITY */
2050                + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2051                + nla_total_size(sizeof(struct rta_cacheinfo));
2052 }
2053
2054 static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
2055                          struct in6_addr *dst, struct in6_addr *src,
2056                          int iif, int type, u32 pid, u32 seq,
2057                          int prefix, unsigned int flags)
2058 {
2059         struct rtmsg *rtm;
2060         struct nlmsghdr *nlh;
2061         long expires;
2062         u32 table;
2063
2064         if (prefix) {   /* user wants prefix routes only */
2065                 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2066                         /* success since this is not a prefix route */
2067                         return 1;
2068                 }
2069         }
2070
2071         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2072         if (nlh == NULL)
2073                 return -EMSGSIZE;
2074
2075         rtm = nlmsg_data(nlh);
2076         rtm->rtm_family = AF_INET6;
2077         rtm->rtm_dst_len = rt->rt6i_dst.plen;
2078         rtm->rtm_src_len = rt->rt6i_src.plen;
2079         rtm->rtm_tos = 0;
2080         if (rt->rt6i_table)
2081                 table = rt->rt6i_table->tb6_id;
2082         else
2083                 table = RT6_TABLE_UNSPEC;
2084         rtm->rtm_table = table;
2085         NLA_PUT_U32(skb, RTA_TABLE, table);
2086         if (rt->rt6i_flags&RTF_REJECT)
2087                 rtm->rtm_type = RTN_UNREACHABLE;
2088         else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2089                 rtm->rtm_type = RTN_LOCAL;
2090         else
2091                 rtm->rtm_type = RTN_UNICAST;
2092         rtm->rtm_flags = 0;
2093         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2094         rtm->rtm_protocol = rt->rt6i_protocol;
2095         if (rt->rt6i_flags&RTF_DYNAMIC)
2096                 rtm->rtm_protocol = RTPROT_REDIRECT;
2097         else if (rt->rt6i_flags & RTF_ADDRCONF)
2098                 rtm->rtm_protocol = RTPROT_KERNEL;
2099         else if (rt->rt6i_flags&RTF_DEFAULT)
2100                 rtm->rtm_protocol = RTPROT_RA;
2101
2102         if (rt->rt6i_flags&RTF_CACHE)
2103                 rtm->rtm_flags |= RTM_F_CLONED;
2104
2105         if (dst) {
2106                 NLA_PUT(skb, RTA_DST, 16, dst);
2107                 rtm->rtm_dst_len = 128;
2108         } else if (rtm->rtm_dst_len)
2109                 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
2110 #ifdef CONFIG_IPV6_SUBTREES
2111         if (src) {
2112                 NLA_PUT(skb, RTA_SRC, 16, src);
2113                 rtm->rtm_src_len = 128;
2114         } else if (rtm->rtm_src_len)
2115                 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
2116 #endif
2117         if (iif)
2118                 NLA_PUT_U32(skb, RTA_IIF, iif);
2119         else if (dst) {
2120                 struct in6_addr saddr_buf;
2121                 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
2122                         NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
2123         }
2124
2125         if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2126                 goto nla_put_failure;
2127
2128         if (rt->u.dst.neighbour)
2129                 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2130
2131         if (rt->u.dst.dev)
2132                 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2133
2134         NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
2135
2136         expires = rt->rt6i_expires ? rt->rt6i_expires - jiffies : 0;
2137         if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2138                                expires, rt->u.dst.error) < 0)
2139                 goto nla_put_failure;
2140
2141         return nlmsg_end(skb, nlh);
2142
2143 nla_put_failure:
2144         nlmsg_cancel(skb, nlh);
2145         return -EMSGSIZE;
2146 }
2147
2148 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2149 {
2150         struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2151         int prefix;
2152
2153         if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2154                 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2155                 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2156         } else
2157                 prefix = 0;
2158
2159         return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2160                      NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
2161                      prefix, NLM_F_MULTI);
2162 }
2163
2164 int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2165 {
2166         struct nlattr *tb[RTA_MAX+1];
2167         struct rt6_info *rt;
2168         struct sk_buff *skb;
2169         struct rtmsg *rtm;
2170         struct flowi fl;
2171         int err, iif = 0;
2172
2173         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2174         if (err < 0)
2175                 goto errout;
2176
2177         err = -EINVAL;
2178         memset(&fl, 0, sizeof(fl));
2179
2180         if (tb[RTA_SRC]) {
2181                 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2182                         goto errout;
2183
2184                 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2185         }
2186
2187         if (tb[RTA_DST]) {
2188                 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2189                         goto errout;
2190
2191                 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2192         }
2193
2194         if (tb[RTA_IIF])
2195                 iif = nla_get_u32(tb[RTA_IIF]);
2196
2197         if (tb[RTA_OIF])
2198                 fl.oif = nla_get_u32(tb[RTA_OIF]);
2199
2200         if (iif) {
2201                 struct net_device *dev;
2202                 dev = __dev_get_by_index(iif);
2203                 if (!dev) {
2204                         err = -ENODEV;
2205                         goto errout;
2206                 }
2207         }
2208
2209         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2210         if (skb == NULL) {
2211                 err = -ENOBUFS;
2212                 goto errout;
2213         }
2214
2215         /* Reserve room for dummy headers, this skb can pass
2216            through good chunk of routing engine.
2217          */
2218         skb->mac.raw = skb->data;
2219         skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2220
2221         rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
2222         skb->dst = &rt->u.dst;
2223
2224         err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
2225                             RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
2226                             nlh->nlmsg_seq, 0, 0);
2227         if (err < 0) {
2228                 kfree_skb(skb);
2229                 goto errout;
2230         }
2231
2232         err = rtnl_unicast(skb, NETLINK_CB(in_skb).pid);
2233 errout:
2234         return err;
2235 }
2236
2237 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2238 {
2239         struct sk_buff *skb;
2240         u32 pid = 0, seq = 0;
2241         struct nlmsghdr *nlh = NULL;
2242         int err = -ENOBUFS;
2243
2244         if (info) {
2245                 pid = info->pid;
2246                 nlh = info->nlh;
2247                 if (nlh)
2248                         seq = nlh->nlmsg_seq;
2249         }
2250
2251         skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2252         if (skb == NULL)
2253                 goto errout;
2254
2255         err = rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0);
2256         if (err < 0) {
2257                 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2258                 WARN_ON(err == -EMSGSIZE);
2259                 kfree_skb(skb);
2260                 goto errout;
2261         }
2262         err = rtnl_notify(skb, pid, RTNLGRP_IPV6_ROUTE, nlh, gfp_any());
2263 errout:
2264         if (err < 0)
2265                 rtnl_set_sk_err(RTNLGRP_IPV6_ROUTE, err);
2266 }
2267
2268 /*
2269  *      /proc
2270  */
2271
2272 #ifdef CONFIG_PROC_FS
2273
2274 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2275
2276 struct rt6_proc_arg
2277 {
2278         char *buffer;
2279         int offset;
2280         int length;
2281         int skip;
2282         int len;
2283 };
2284
2285 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2286 {
2287         struct rt6_proc_arg *arg = (struct rt6_proc_arg *) p_arg;
2288
2289         if (arg->skip < arg->offset / RT6_INFO_LEN) {
2290                 arg->skip++;
2291                 return 0;
2292         }
2293
2294         if (arg->len >= arg->length)
2295                 return 0;
2296
2297         arg->len += sprintf(arg->buffer + arg->len,
2298                             NIP6_SEQFMT " %02x ",
2299                             NIP6(rt->rt6i_dst.addr),
2300                             rt->rt6i_dst.plen);
2301
2302 #ifdef CONFIG_IPV6_SUBTREES
2303         arg->len += sprintf(arg->buffer + arg->len,
2304                             NIP6_SEQFMT " %02x ",
2305                             NIP6(rt->rt6i_src.addr),
2306                             rt->rt6i_src.plen);
2307 #else
2308         arg->len += sprintf(arg->buffer + arg->len,
2309                             "00000000000000000000000000000000 00 ");
2310 #endif
2311
2312         if (rt->rt6i_nexthop) {
2313                 arg->len += sprintf(arg->buffer + arg->len,
2314                                     NIP6_SEQFMT,
2315                                     NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
2316         } else {
2317                 arg->len += sprintf(arg->buffer + arg->len,
2318                                     "00000000000000000000000000000000");
2319         }
2320         arg->len += sprintf(arg->buffer + arg->len,
2321                             " %08x %08x %08x %08x %8s\n",
2322                             rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2323                             rt->u.dst.__use, rt->rt6i_flags,
2324                             rt->rt6i_dev ? rt->rt6i_dev->name : "");
2325         return 0;
2326 }
2327
2328 static int rt6_proc_info(char *buffer, char **start, off_t offset, int length)
2329 {
2330         struct rt6_proc_arg arg = {
2331                 .buffer = buffer,
2332                 .offset = offset,
2333                 .length = length,
2334         };
2335
2336         fib6_clean_all(rt6_info_route, 0, &arg);
2337
2338         *start = buffer;
2339         if (offset)
2340                 *start += offset % RT6_INFO_LEN;
2341
2342         arg.len -= offset % RT6_INFO_LEN;
2343
2344         if (arg.len > length)
2345                 arg.len = length;
2346         if (arg.len < 0)
2347                 arg.len = 0;
2348
2349         return arg.len;
2350 }
2351
2352 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2353 {
2354         seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2355                       rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2356                       rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2357                       rt6_stats.fib_rt_cache,
2358                       atomic_read(&ip6_dst_ops.entries),
2359                       rt6_stats.fib_discarded_routes);
2360
2361         return 0;
2362 }
2363
2364 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2365 {
2366         return single_open(file, rt6_stats_seq_show, NULL);
2367 }
2368
2369 static const struct file_operations rt6_stats_seq_fops = {
2370         .owner   = THIS_MODULE,
2371         .open    = rt6_stats_seq_open,
2372         .read    = seq_read,
2373         .llseek  = seq_lseek,
2374         .release = single_release,
2375 };
2376 #endif  /* CONFIG_PROC_FS */
2377
2378 #ifdef CONFIG_SYSCTL
2379
2380 static int flush_delay;
2381
2382 static
2383 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2384                               void __user *buffer, size_t *lenp, loff_t *ppos)
2385 {
2386         if (write) {
2387                 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2388                 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2389                 return 0;
2390         } else
2391                 return -EINVAL;
2392 }
2393
2394 ctl_table ipv6_route_table[] = {
2395         {
2396                 .ctl_name       =       NET_IPV6_ROUTE_FLUSH,
2397                 .procname       =       "flush",
2398                 .data           =       &flush_delay,
2399                 .maxlen         =       sizeof(int),
2400                 .mode           =       0200,
2401                 .proc_handler   =       &ipv6_sysctl_rtcache_flush
2402         },
2403         {
2404                 .ctl_name       =       NET_IPV6_ROUTE_GC_THRESH,
2405                 .procname       =       "gc_thresh",
2406                 .data           =       &ip6_dst_ops.gc_thresh,
2407                 .maxlen         =       sizeof(int),
2408                 .mode           =       0644,
2409                 .proc_handler   =       &proc_dointvec,
2410         },
2411         {
2412                 .ctl_name       =       NET_IPV6_ROUTE_MAX_SIZE,
2413                 .procname       =       "max_size",
2414                 .data           =       &ip6_rt_max_size,
2415                 .maxlen         =       sizeof(int),
2416                 .mode           =       0644,
2417                 .proc_handler   =       &proc_dointvec,
2418         },
2419         {
2420                 .ctl_name       =       NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2421                 .procname       =       "gc_min_interval",
2422                 .data           =       &ip6_rt_gc_min_interval,
2423                 .maxlen         =       sizeof(int),
2424                 .mode           =       0644,
2425                 .proc_handler   =       &proc_dointvec_jiffies,
2426                 .strategy       =       &sysctl_jiffies,
2427         },
2428         {
2429                 .ctl_name       =       NET_IPV6_ROUTE_GC_TIMEOUT,
2430                 .procname       =       "gc_timeout",
2431                 .data           =       &ip6_rt_gc_timeout,
2432                 .maxlen         =       sizeof(int),
2433                 .mode           =       0644,
2434                 .proc_handler   =       &proc_dointvec_jiffies,
2435                 .strategy       =       &sysctl_jiffies,
2436         },
2437         {
2438                 .ctl_name       =       NET_IPV6_ROUTE_GC_INTERVAL,
2439                 .procname       =       "gc_interval",
2440                 .data           =       &ip6_rt_gc_interval,
2441                 .maxlen         =       sizeof(int),
2442                 .mode           =       0644,
2443                 .proc_handler   =       &proc_dointvec_jiffies,
2444                 .strategy       =       &sysctl_jiffies,
2445         },
2446         {
2447                 .ctl_name       =       NET_IPV6_ROUTE_GC_ELASTICITY,
2448                 .procname       =       "gc_elasticity",
2449                 .data           =       &ip6_rt_gc_elasticity,
2450                 .maxlen         =       sizeof(int),
2451                 .mode           =       0644,
2452                 .proc_handler   =       &proc_dointvec_jiffies,
2453                 .strategy       =       &sysctl_jiffies,
2454         },
2455         {
2456                 .ctl_name       =       NET_IPV6_ROUTE_MTU_EXPIRES,
2457                 .procname       =       "mtu_expires",
2458                 .data           =       &ip6_rt_mtu_expires,
2459                 .maxlen         =       sizeof(int),
2460                 .mode           =       0644,
2461                 .proc_handler   =       &proc_dointvec_jiffies,
2462                 .strategy       =       &sysctl_jiffies,
2463         },
2464         {
2465                 .ctl_name       =       NET_IPV6_ROUTE_MIN_ADVMSS,
2466                 .procname       =       "min_adv_mss",
2467                 .data           =       &ip6_rt_min_advmss,
2468                 .maxlen         =       sizeof(int),
2469                 .mode           =       0644,
2470                 .proc_handler   =       &proc_dointvec_jiffies,
2471                 .strategy       =       &sysctl_jiffies,
2472         },
2473         {
2474                 .ctl_name       =       NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2475                 .procname       =       "gc_min_interval_ms",
2476                 .data           =       &ip6_rt_gc_min_interval,
2477                 .maxlen         =       sizeof(int),
2478                 .mode           =       0644,
2479                 .proc_handler   =       &proc_dointvec_ms_jiffies,
2480                 .strategy       =       &sysctl_ms_jiffies,
2481         },
2482         { .ctl_name = 0 }
2483 };
2484
2485 #endif
2486
2487 void __init ip6_route_init(void)
2488 {
2489         struct proc_dir_entry *p;
2490
2491         ip6_dst_ops.kmem_cachep =
2492                 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2493                                   SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
2494         fib6_init();
2495 #ifdef  CONFIG_PROC_FS
2496         p = proc_net_create("ipv6_route", 0, rt6_proc_info);
2497         if (p)
2498                 p->owner = THIS_MODULE;
2499
2500         proc_net_fops_create("rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2501 #endif
2502 #ifdef CONFIG_XFRM
2503         xfrm6_init();
2504 #endif
2505 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2506         fib6_rules_init();
2507 #endif
2508 }
2509
2510 void ip6_route_cleanup(void)
2511 {
2512 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2513         fib6_rules_cleanup();
2514 #endif
2515 #ifdef CONFIG_PROC_FS
2516         proc_net_remove("ipv6_route");
2517         proc_net_remove("rt6_stats");
2518 #endif
2519 #ifdef CONFIG_XFRM
2520         xfrm6_fini();
2521 #endif
2522         rt6_ifdown(NULL);
2523         fib6_gc_cleanup();
2524         kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2525 }