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