git.oblomov.eu Git - linux-2.6/blob - net/ipv6/route.c

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