net/ipv6/route.c

   1 /*
   2  *      Linux INET6 implementation
   3  *      FIB front-end.
   4  *
   5  *      Authors:
   6  *      Pedro Roque             <roque@di.fc.ul.pt>
   7  *
   8  *      This program is free software; you can redistribute it and/or
   9  *      modify it under the terms of the GNU General Public License
  10  *      as published by the Free Software Foundation; either version
  11  *      2 of the License, or (at your option) any later version.
  12  */
  13
  14 /*      Changes:
  15  *
  16  *      YOSHIFUJI Hideaki @USAGI
  17  *              reworked default router selection.
  18  *              - respect outgoing interface
  19  *              - select from (probably) reachable routers (i.e.
  20  *              routers in REACHABLE, STALE, DELAY or PROBE states).
  21  *              - always select the same router if it is (probably)
  22  *              reachable.  otherwise, round-robin the list.
  23  *      Ville Nuorvala
  24  *              Fixed routing subtrees.
  25  */
  26
  27 #define pr_fmt(fmt) "IPv6: " fmt
  28
  29 #include <linux/capability.h>
  30 #include <linux/errno.h>
  31 #include <linux/export.h>
  32 #include <linux/types.h>
  33 #include <linux/times.h>
  34 #include <linux/socket.h>
  35 #include <linux/sockios.h>
  36 #include <linux/net.h>
  37 #include <linux/route.h>
  38 #include <linux/netdevice.h>
  39 #include <linux/in6.h>
  40 #include <linux/mroute6.h>
  41 #include <linux/init.h>
  42 #include <linux/if_arp.h>
  43 #include <linux/proc_fs.h>
  44 #include <linux/seq_file.h>
  45 #include <linux/nsproxy.h>
  46 #include <linux/slab.h>
  47 #include <net/net_namespace.h>
  48 #include <net/snmp.h>
  49 #include <net/ipv6.h>
  50 #include <net/ip6_fib.h>
  51 #include <net/ip6_route.h>
  52 #include <net/ndisc.h>
  53 #include <net/addrconf.h>
  54 #include <net/tcp.h>
  55 #include <linux/rtnetlink.h>
  56 #include <net/dst.h>
  57 #include <net/dst_metadata.h>
  58 #include <net/xfrm.h>
  59 #include <net/netevent.h>
  60 #include <net/netlink.h>
  61 #include <net/nexthop.h>
  62 #include <net/lwtunnel.h>
  63 #include <net/ip_tunnels.h>
  64 #include <net/l3mdev.h>
  65 #include <trace/events/fib6.h>
  66
  67 #include <asm/uaccess.h>
  68
  69 #ifdef CONFIG_SYSCTL
  70 #include <linux/sysctl.h>
  71 #endif
  72
  73 enum rt6_nud_state {
  74         RT6_NUD_FAIL_HARD = -3,
  75         RT6_NUD_FAIL_PROBE = -2,
  76         RT6_NUD_FAIL_DO_RR = -1,
  77         RT6_NUD_SUCCEED = 1
  78 };
  79
  80 static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort);
  81 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
  82 static unsigned int      ip6_default_advmss(const struct dst_entry *dst);
  83 static unsigned int      ip6_mtu(const struct dst_entry *dst);
  84 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
  85 static void             ip6_dst_destroy(struct dst_entry *);
  86 static void             ip6_dst_ifdown(struct dst_entry *,
  87                                        struct net_device *dev, int how);
  88 static int               ip6_dst_gc(struct dst_ops *ops);
  89
  90 static int              ip6_pkt_discard(struct sk_buff *skb);
  91 static int              ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb);
  92 static int              ip6_pkt_prohibit(struct sk_buff *skb);
  93 static int              ip6_pkt_prohibit_out(struct net *net, struct sock *sk, 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, struct sock *sk,
  96                                            struct sk_buff *skb, u32 mtu);
  97 static void             rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
  98                                         struct sk_buff *skb);
  99 static void             rt6_dst_from_metrics_check(struct rt6_info *rt);
 100 static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
 101
 102 #ifdef CONFIG_IPV6_ROUTE_INFO
 103 static struct rt6_info *rt6_add_route_info(struct net *net,
 104                                            const struct in6_addr *prefix, int prefixlen,
 105                                            const struct in6_addr *gwaddr, int ifindex,
 106                                            unsigned int pref);
 107 static struct rt6_info *rt6_get_route_info(struct net *net,
 108                                            const struct in6_addr *prefix, int prefixlen,
 109                                            const struct in6_addr *gwaddr, int ifindex);
 110 #endif
 111
 112 struct uncached_list {
 113         spinlock_t              lock;
 114         struct list_head        head;
 115 };
 116
 117 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
 118
 119 static void rt6_uncached_list_add(struct rt6_info *rt)
 120 {
 121         struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);
 122
 123         rt->dst.flags |= DST_NOCACHE;
 124         rt->rt6i_uncached_list = ul;
 125
 126         spin_lock_bh(&ul->lock);
 127         list_add_tail(&rt->rt6i_uncached, &ul->head);
 128         spin_unlock_bh(&ul->lock);
 129 }
 130
 131 static void rt6_uncached_list_del(struct rt6_info *rt)
 132 {
 133         if (!list_empty(&rt->rt6i_uncached)) {
 134                 struct uncached_list *ul = rt->rt6i_uncached_list;
 135
 136                 spin_lock_bh(&ul->lock);
 137                 list_del(&rt->rt6i_uncached);
 138                 spin_unlock_bh(&ul->lock);
 139         }
 140 }
 141
 142 static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
 143 {
 144         struct net_device *loopback_dev = net->loopback_dev;
 145         int cpu;
 146
 147         if (dev == loopback_dev)
 148                 return;
 149
 150         for_each_possible_cpu(cpu) {
 151                 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
 152                 struct rt6_info *rt;
 153
 154                 spin_lock_bh(&ul->lock);
 155                 list_for_each_entry(rt, &ul->head, rt6i_uncached) {
 156                         struct inet6_dev *rt_idev = rt->rt6i_idev;
 157                         struct net_device *rt_dev = rt->dst.dev;
 158
 159                         if (rt_idev->dev == dev) {
 160                                 rt->rt6i_idev = in6_dev_get(loopback_dev);
 161                                 in6_dev_put(rt_idev);
 162                         }
 163
 164                         if (rt_dev == dev) {
 165                                 rt->dst.dev = loopback_dev;
 166                                 dev_hold(rt->dst.dev);
 167                                 dev_put(rt_dev);
 168                         }
 169                 }
 170                 spin_unlock_bh(&ul->lock);
 171         }
 172 }
 173
 174 static u32 *rt6_pcpu_cow_metrics(struct rt6_info *rt)
 175 {
 176         return dst_metrics_write_ptr(rt->dst.from);
 177 }
 178
 179 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
 180 {
 181         struct rt6_info *rt = (struct rt6_info *)dst;
 182
 183         if (rt->rt6i_flags & RTF_PCPU)
 184                 return rt6_pcpu_cow_metrics(rt);
 185         else if (rt->rt6i_flags & RTF_CACHE)
 186                 return NULL;
 187         else
 188                 return dst_cow_metrics_generic(dst, old);
 189 }
 190
 191 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
 192                                              struct sk_buff *skb,
 193                                              const void *daddr)
 194 {
 195         struct in6_addr *p = &rt->rt6i_gateway;
 196
 197         if (!ipv6_addr_any(p))
 198                 return (const void *) p;
 199         else if (skb)
 200                 return &ipv6_hdr(skb)->daddr;
 201         return daddr;
 202 }
 203
 204 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
 205                                           struct sk_buff *skb,
 206                                           const void *daddr)
 207 {
 208         struct rt6_info *rt = (struct rt6_info *) dst;
 209         struct neighbour *n;
 210
 211         daddr = choose_neigh_daddr(rt, skb, daddr);
 212         n = __ipv6_neigh_lookup(dst->dev, daddr);
 213         if (n)
 214                 return n;
 215         return neigh_create(&nd_tbl, daddr, dst->dev);
 216 }
 217
 218 static struct dst_ops ip6_dst_ops_template = {
 219         .family                 =       AF_INET6,
 220         .gc                     =       ip6_dst_gc,
 221         .gc_thresh              =       1024,
 222         .check                  =       ip6_dst_check,
 223         .default_advmss         =       ip6_default_advmss,
 224         .mtu                    =       ip6_mtu,
 225         .cow_metrics            =       ipv6_cow_metrics,
 226         .destroy                =       ip6_dst_destroy,
 227         .ifdown                 =       ip6_dst_ifdown,
 228         .negative_advice        =       ip6_negative_advice,
 229         .link_failure           =       ip6_link_failure,
 230         .update_pmtu            =       ip6_rt_update_pmtu,
 231         .redirect               =       rt6_do_redirect,
 232         .local_out              =       __ip6_local_out,
 233         .neigh_lookup           =       ip6_neigh_lookup,
 234 };
 235
 236 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
 237 {
 238         unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
 239
 240         return mtu ? : dst->dev->mtu;
 241 }
 242
 243 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
 244                                          struct sk_buff *skb, u32 mtu)
 245 {
 246 }
 247
 248 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
 249                                       struct sk_buff *skb)
 250 {
 251 }
 252
 253 static struct dst_ops ip6_dst_blackhole_ops = {
 254         .family                 =       AF_INET6,
 255         .destroy                =       ip6_dst_destroy,
 256         .check                  =       ip6_dst_check,
 257         .mtu                    =       ip6_blackhole_mtu,
 258         .default_advmss         =       ip6_default_advmss,
 259         .update_pmtu            =       ip6_rt_blackhole_update_pmtu,
 260         .redirect               =       ip6_rt_blackhole_redirect,
 261         .cow_metrics            =       dst_cow_metrics_generic,
 262         .neigh_lookup           =       ip6_neigh_lookup,
 263 };
 264
 265 static const u32 ip6_template_metrics[RTAX_MAX] = {
 266         [RTAX_HOPLIMIT - 1] = 0,
 267 };
 268
 269 static const struct rt6_info ip6_null_entry_template = {
 270         .dst = {
 271                 .__refcnt       = ATOMIC_INIT(1),
 272                 .__use          = 1,
 273                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 274                 .error          = -ENETUNREACH,
 275                 .input          = ip6_pkt_discard,
 276                 .output         = ip6_pkt_discard_out,
 277         },
 278         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 279         .rt6i_protocol  = RTPROT_KERNEL,
 280         .rt6i_metric    = ~(u32) 0,
 281         .rt6i_ref       = ATOMIC_INIT(1),
 282 };
 283
 284 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 285
 286 static const struct rt6_info ip6_prohibit_entry_template = {
 287         .dst = {
 288                 .__refcnt       = ATOMIC_INIT(1),
 289                 .__use          = 1,
 290                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 291                 .error          = -EACCES,
 292                 .input          = ip6_pkt_prohibit,
 293                 .output         = ip6_pkt_prohibit_out,
 294         },
 295         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 296         .rt6i_protocol  = RTPROT_KERNEL,
 297         .rt6i_metric    = ~(u32) 0,
 298         .rt6i_ref       = ATOMIC_INIT(1),
 299 };
 300
 301 static const struct rt6_info ip6_blk_hole_entry_template = {
 302         .dst = {
 303                 .__refcnt       = ATOMIC_INIT(1),
 304                 .__use          = 1,
 305                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 306                 .error          = -EINVAL,
 307                 .input          = dst_discard,
 308                 .output         = dst_discard_out,
 309         },
 310         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 311         .rt6i_protocol  = RTPROT_KERNEL,
 312         .rt6i_metric    = ~(u32) 0,
 313         .rt6i_ref       = ATOMIC_INIT(1),
 314 };
 315
 316 #endif
 317
 318 static void rt6_info_init(struct rt6_info *rt)
 319 {
 320         struct dst_entry *dst = &rt->dst;
 321
 322         memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
 323         INIT_LIST_HEAD(&rt->rt6i_siblings);
 324         INIT_LIST_HEAD(&rt->rt6i_uncached);
 325 }
 326
 327 /* allocate dst with ip6_dst_ops */
 328 static struct rt6_info *__ip6_dst_alloc(struct net *net,
 329                                         struct net_device *dev,
 330                                         int flags)
 331 {
 332         struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
 333                                         0, DST_OBSOLETE_FORCE_CHK, flags);
 334
 335         if (rt)
 336                 rt6_info_init(rt);
 337
 338         return rt;
 339 }
 340
 341 static struct rt6_info *ip6_dst_alloc(struct net *net,
 342                                       struct net_device *dev,
 343                                       int flags)
 344 {
 345         struct rt6_info *rt = __ip6_dst_alloc(net, dev, flags);
 346
 347         if (rt) {
 348                 rt->rt6i_pcpu = alloc_percpu_gfp(struct rt6_info *, GFP_ATOMIC);
 349                 if (rt->rt6i_pcpu) {
 350                         int cpu;
 351
 352                         for_each_possible_cpu(cpu) {
 353                                 struct rt6_info **p;
 354
 355                                 p = per_cpu_ptr(rt->rt6i_pcpu, cpu);
 356                                 /* no one shares rt */
 357                                 *p =  NULL;
 358                         }
 359                 } else {
 360                         dst_destroy((struct dst_entry *)rt);
 361                         return NULL;
 362                 }
 363         }
 364
 365         return rt;
 366 }
 367
 368 static void ip6_dst_destroy(struct dst_entry *dst)
 369 {
 370         struct rt6_info *rt = (struct rt6_info *)dst;
 371         struct dst_entry *from = dst->from;
 372         struct inet6_dev *idev;
 373
 374         dst_destroy_metrics_generic(dst);
 375         free_percpu(rt->rt6i_pcpu);
 376         rt6_uncached_list_del(rt);
 377
 378         idev = rt->rt6i_idev;
 379         if (idev) {
 380                 rt->rt6i_idev = NULL;
 381                 in6_dev_put(idev);
 382         }
 383
 384         dst->from = NULL;
 385         dst_release(from);
 386 }
 387
 388 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
 389                            int how)
 390 {
 391         struct rt6_info *rt = (struct rt6_info *)dst;
 392         struct inet6_dev *idev = rt->rt6i_idev;
 393         struct net_device *loopback_dev =
 394                 dev_net(dev)->loopback_dev;
 395
 396         if (dev != loopback_dev) {
 397                 if (idev && idev->dev == dev) {
 398                         struct inet6_dev *loopback_idev =
 399                                 in6_dev_get(loopback_dev);
 400                         if (loopback_idev) {
 401                                 rt->rt6i_idev = loopback_idev;
 402                                 in6_dev_put(idev);
 403                         }
 404                 }
 405         }
 406 }
 407
 408 static bool __rt6_check_expired(const struct rt6_info *rt)
 409 {
 410         if (rt->rt6i_flags & RTF_EXPIRES)
 411                 return time_after(jiffies, rt->dst.expires);
 412         else
 413                 return false;
 414 }
 415
 416 static bool rt6_check_expired(const struct rt6_info *rt)
 417 {
 418         if (rt->rt6i_flags & RTF_EXPIRES) {
 419                 if (time_after(jiffies, rt->dst.expires))
 420                         return true;
 421         } else if (rt->dst.from) {
 422                 return rt6_check_expired((struct rt6_info *) rt->dst.from);
 423         }
 424         return false;
 425 }
 426
 427 /* Multipath route selection:
 428  *   Hash based function using packet header and flowlabel.
 429  * Adapted from fib_info_hashfn()
 430  */
 431 static int rt6_info_hash_nhsfn(unsigned int candidate_count,
 432                                const struct flowi6 *fl6)
 433 {
 434         return get_hash_from_flowi6(fl6) % candidate_count;
 435 }
 436
 437 static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
 438                                              struct flowi6 *fl6, int oif,
 439                                              int strict)
 440 {
 441         struct rt6_info *sibling, *next_sibling;
 442         int route_choosen;
 443
 444         route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
 445         /* Don't change the route, if route_choosen == 0
 446          * (siblings does not include ourself)
 447          */
 448         if (route_choosen)
 449                 list_for_each_entry_safe(sibling, next_sibling,
 450                                 &match->rt6i_siblings, rt6i_siblings) {
 451                         route_choosen--;
 452                         if (route_choosen == 0) {
 453                                 if (rt6_score_route(sibling, oif, strict) < 0)
 454                                         break;
 455                                 match = sibling;
 456                                 break;
 457                         }
 458                 }
 459         return match;
 460 }
 461
 462 /*
 463  *      Route lookup. Any table->tb6_lock is implied.
 464  */
 465
 466 static inline struct rt6_info *rt6_device_match(struct net *net,
 467                                                     struct rt6_info *rt,
 468                                                     const struct in6_addr *saddr,
 469                                                     int oif,
 470                                                     int flags)
 471 {
 472         struct rt6_info *local = NULL;
 473         struct rt6_info *sprt;
 474
 475         if (!oif && ipv6_addr_any(saddr))
 476                 goto out;
 477
 478         for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
 479                 struct net_device *dev = sprt->dst.dev;
 480
 481                 if (oif) {
 482                         if (dev->ifindex == oif)
 483                                 return sprt;
 484                         if (dev->flags & IFF_LOOPBACK) {
 485                                 if (!sprt->rt6i_idev ||
 486                                     sprt->rt6i_idev->dev->ifindex != oif) {
 487                                         if (flags & RT6_LOOKUP_F_IFACE)
 488                                                 continue;
 489                                         if (local &&
 490                                             local->rt6i_idev->dev->ifindex == oif)
 491                                                 continue;
 492                                 }
 493                                 local = sprt;
 494                         }
 495                 } else {
 496                         if (ipv6_chk_addr(net, saddr, dev,
 497                                           flags & RT6_LOOKUP_F_IFACE))
 498                                 return sprt;
 499                 }
 500         }
 501
 502         if (oif) {
 503                 if (local)
 504                         return local;
 505
 506                 if (flags & RT6_LOOKUP_F_IFACE)
 507                         return net->ipv6.ip6_null_entry;
 508         }
 509 out:
 510         return rt;
 511 }
 512
 513 #ifdef CONFIG_IPV6_ROUTER_PREF
 514 struct __rt6_probe_work {
 515         struct work_struct work;
 516         struct in6_addr target;
 517         struct net_device *dev;
 518 };
 519
 520 static void rt6_probe_deferred(struct work_struct *w)
 521 {
 522         struct in6_addr mcaddr;
 523         struct __rt6_probe_work *work =
 524                 container_of(w, struct __rt6_probe_work, work);
 525
 526         addrconf_addr_solict_mult(&work->target, &mcaddr);
 527         ndisc_send_ns(work->dev, &work->target, &mcaddr, NULL);
 528         dev_put(work->dev);
 529         kfree(work);
 530 }
 531
 532 static void rt6_probe(struct rt6_info *rt)
 533 {
 534         struct __rt6_probe_work *work;
 535         struct neighbour *neigh;
 536         /*
 537          * Okay, this does not seem to be appropriate
 538          * for now, however, we need to check if it
 539          * is really so; aka Router Reachability Probing.
 540          *
 541          * Router Reachability Probe MUST be rate-limited
 542          * to no more than one per minute.
 543          */
 544         if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
 545                 return;
 546         rcu_read_lock_bh();
 547         neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
 548         if (neigh) {
 549                 if (neigh->nud_state & NUD_VALID)
 550                         goto out;
 551
 552                 work = NULL;
 553                 write_lock(&neigh->lock);
 554                 if (!(neigh->nud_state & NUD_VALID) &&
 555                     time_after(jiffies,
 556                                neigh->updated +
 557                                rt->rt6i_idev->cnf.rtr_probe_interval)) {
 558                         work = kmalloc(sizeof(*work), GFP_ATOMIC);
 559                         if (work)
 560                                 __neigh_set_probe_once(neigh);
 561                 }
 562                 write_unlock(&neigh->lock);
 563         } else {
 564                 work = kmalloc(sizeof(*work), GFP_ATOMIC);
 565         }
 566
 567         if (work) {
 568                 INIT_WORK(&work->work, rt6_probe_deferred);
 569                 work->target = rt->rt6i_gateway;
 570                 dev_hold(rt->dst.dev);
 571                 work->dev = rt->dst.dev;
 572                 schedule_work(&work->work);
 573         }
 574
 575 out:
 576         rcu_read_unlock_bh();
 577 }
 578 #else
 579 static inline void rt6_probe(struct rt6_info *rt)
 580 {
 581 }
 582 #endif
 583
 584 /*
 585  * Default Router Selection (RFC 2461 6.3.6)
 586  */
 587 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
 588 {
 589         struct net_device *dev = rt->dst.dev;
 590         if (!oif || dev->ifindex == oif)
 591                 return 2;
 592         if ((dev->flags & IFF_LOOPBACK) &&
 593             rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
 594                 return 1;
 595         return 0;
 596 }
 597
 598 static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
 599 {
 600         struct neighbour *neigh;
 601         enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
 602
 603         if (rt->rt6i_flags & RTF_NONEXTHOP ||
 604             !(rt->rt6i_flags & RTF_GATEWAY))
 605                 return RT6_NUD_SUCCEED;
 606
 607         rcu_read_lock_bh();
 608         neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
 609         if (neigh) {
 610                 read_lock(&neigh->lock);
 611                 if (neigh->nud_state & NUD_VALID)
 612                         ret = RT6_NUD_SUCCEED;
 613 #ifdef CONFIG_IPV6_ROUTER_PREF
 614                 else if (!(neigh->nud_state & NUD_FAILED))
 615                         ret = RT6_NUD_SUCCEED;
 616                 else
 617                         ret = RT6_NUD_FAIL_PROBE;
 618 #endif
 619                 read_unlock(&neigh->lock);
 620         } else {
 621                 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
 622                       RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
 623         }
 624         rcu_read_unlock_bh();
 625
 626         return ret;
 627 }
 628
 629 static int rt6_score_route(struct rt6_info *rt, int oif,
 630                            int strict)
 631 {
 632         int m;
 633
 634         m = rt6_check_dev(rt, oif);
 635         if (!m && (strict & RT6_LOOKUP_F_IFACE))
 636                 return RT6_NUD_FAIL_HARD;
 637 #ifdef CONFIG_IPV6_ROUTER_PREF
 638         m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
 639 #endif
 640         if (strict & RT6_LOOKUP_F_REACHABLE) {
 641                 int n = rt6_check_neigh(rt);
 642                 if (n < 0)
 643                         return n;
 644         }
 645         return m;
 646 }
 647
 648 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
 649                                    int *mpri, struct rt6_info *match,
 650                                    bool *do_rr)
 651 {
 652         int m;
 653         bool match_do_rr = false;
 654         struct inet6_dev *idev = rt->rt6i_idev;
 655         struct net_device *dev = rt->dst.dev;
 656
 657         if (dev && !netif_carrier_ok(dev) &&
 658             idev->cnf.ignore_routes_with_linkdown)
 659                 goto out;
 660
 661         if (rt6_check_expired(rt))
 662                 goto out;
 663
 664         m = rt6_score_route(rt, oif, strict);
 665         if (m == RT6_NUD_FAIL_DO_RR) {
 666                 match_do_rr = true;
 667                 m = 0; /* lowest valid score */
 668         } else if (m == RT6_NUD_FAIL_HARD) {
 669                 goto out;
 670         }
 671
 672         if (strict & RT6_LOOKUP_F_REACHABLE)
 673                 rt6_probe(rt);
 674
 675         /* note that m can be RT6_NUD_FAIL_PROBE at this point */
 676         if (m > *mpri) {
 677                 *do_rr = match_do_rr;
 678                 *mpri = m;
 679                 match = rt;
 680         }
 681 out:
 682         return match;
 683 }
 684
 685 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
 686                                      struct rt6_info *rr_head,
 687                                      u32 metric, int oif, int strict,
 688                                      bool *do_rr)
 689 {
 690         struct rt6_info *rt, *match, *cont;
 691         int mpri = -1;
 692
 693         match = NULL;
 694         cont = NULL;
 695         for (rt = rr_head; rt; rt = rt->dst.rt6_next) {
 696                 if (rt->rt6i_metric != metric) {
 697                         cont = rt;
 698                         break;
 699                 }
 700
 701                 match = find_match(rt, oif, strict, &mpri, match, do_rr);
 702         }
 703
 704         for (rt = fn->leaf; rt && rt != rr_head; rt = rt->dst.rt6_next) {
 705                 if (rt->rt6i_metric != metric) {
 706                         cont = rt;
 707                         break;
 708                 }
 709
 710                 match = find_match(rt, oif, strict, &mpri, match, do_rr);
 711         }
 712
 713         if (match || !cont)
 714                 return match;
 715
 716         for (rt = cont; rt; rt = rt->dst.rt6_next)
 717                 match = find_match(rt, oif, strict, &mpri, match, do_rr);
 718
 719         return match;
 720 }
 721
 722 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
 723 {
 724         struct rt6_info *match, *rt0;
 725         struct net *net;
 726         bool do_rr = false;
 727
 728         rt0 = fn->rr_ptr;
 729         if (!rt0)
 730                 fn->rr_ptr = rt0 = fn->leaf;
 731
 732         match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
 733                              &do_rr);
 734
 735         if (do_rr) {
 736                 struct rt6_info *next = rt0->dst.rt6_next;
 737
 738                 /* no entries matched; do round-robin */
 739                 if (!next || next->rt6i_metric != rt0->rt6i_metric)
 740                         next = fn->leaf;
 741
 742                 if (next != rt0)
 743                         fn->rr_ptr = next;
 744         }
 745
 746         net = dev_net(rt0->dst.dev);
 747         return match ? match : net->ipv6.ip6_null_entry;
 748 }
 749
 750 static bool rt6_is_gw_or_nonexthop(const struct rt6_info *rt)
 751 {
 752         return (rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY));
 753 }
 754
 755 #ifdef CONFIG_IPV6_ROUTE_INFO
 756 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
 757                   const struct in6_addr *gwaddr)
 758 {
 759         struct net *net = dev_net(dev);
 760         struct route_info *rinfo = (struct route_info *) opt;
 761         struct in6_addr prefix_buf, *prefix;
 762         unsigned int pref;
 763         unsigned long lifetime;
 764         struct rt6_info *rt;
 765
 766         if (len < sizeof(struct route_info)) {
 767                 return -EINVAL;
 768         }
 769
 770         /* Sanity check for prefix_len and length */
 771         if (rinfo->length > 3) {
 772                 return -EINVAL;
 773         } else if (rinfo->prefix_len > 128) {
 774                 return -EINVAL;
 775         } else if (rinfo->prefix_len > 64) {
 776                 if (rinfo->length < 2) {
 777                         return -EINVAL;
 778                 }
 779         } else if (rinfo->prefix_len > 0) {
 780                 if (rinfo->length < 1) {
 781                         return -EINVAL;
 782                 }
 783         }
 784
 785         pref = rinfo->route_pref;
 786         if (pref == ICMPV6_ROUTER_PREF_INVALID)
 787                 return -EINVAL;
 788
 789         lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
 790
 791         if (rinfo->length == 3)
 792                 prefix = (struct in6_addr *)rinfo->prefix;
 793         else {
 794                 /* this function is safe */
 795                 ipv6_addr_prefix(&prefix_buf,
 796                                  (struct in6_addr *)rinfo->prefix,
 797                                  rinfo->prefix_len);
 798                 prefix = &prefix_buf;
 799         }
 800
 801         if (rinfo->prefix_len == 0)
 802                 rt = rt6_get_dflt_router(gwaddr, dev);
 803         else
 804                 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
 805                                         gwaddr, dev->ifindex);
 806
 807         if (rt && !lifetime) {
 808                 ip6_del_rt(rt);
 809                 rt = NULL;
 810         }
 811
 812         if (!rt && lifetime)
 813                 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
 814                                         pref);
 815         else if (rt)
 816                 rt->rt6i_flags = RTF_ROUTEINFO |
 817                                  (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
 818
 819         if (rt) {
 820                 if (!addrconf_finite_timeout(lifetime))
 821                         rt6_clean_expires(rt);
 822                 else
 823                         rt6_set_expires(rt, jiffies + HZ * lifetime);
 824
 825                 ip6_rt_put(rt);
 826         }
 827         return 0;
 828 }
 829 #endif
 830
 831 static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
 832                                         struct in6_addr *saddr)
 833 {
 834         struct fib6_node *pn;
 835         while (1) {
 836                 if (fn->fn_flags & RTN_TL_ROOT)
 837                         return NULL;
 838                 pn = fn->parent;
 839                 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
 840                         fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
 841                 else
 842                         fn = pn;
 843                 if (fn->fn_flags & RTN_RTINFO)
 844                         return fn;
 845         }
 846 }
 847
 848 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
 849                                              struct fib6_table *table,
 850                                              struct flowi6 *fl6, int flags)
 851 {
 852         struct fib6_node *fn;
 853         struct rt6_info *rt;
 854
 855         read_lock_bh(&table->tb6_lock);
 856         fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
 857 restart:
 858         rt = fn->leaf;
 859         rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
 860         if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
 861                 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
 862         if (rt == net->ipv6.ip6_null_entry) {
 863                 fn = fib6_backtrack(fn, &fl6->saddr);
 864                 if (fn)
 865                         goto restart;
 866         }
 867         dst_use(&rt->dst, jiffies);
 868         read_unlock_bh(&table->tb6_lock);
 869
 870         trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
 871
 872         return rt;
 873
 874 }
 875
 876 struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
 877                                     int flags)
 878 {
 879         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
 880 }
 881 EXPORT_SYMBOL_GPL(ip6_route_lookup);
 882
 883 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
 884                             const struct in6_addr *saddr, int oif, int strict)
 885 {
 886         struct flowi6 fl6 = {
 887                 .flowi6_oif = oif,
 888                 .daddr = *daddr,
 889         };
 890         struct dst_entry *dst;
 891         int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
 892
 893         if (saddr) {
 894                 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
 895                 flags |= RT6_LOOKUP_F_HAS_SADDR;
 896         }
 897
 898         dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
 899         if (dst->error == 0)
 900                 return (struct rt6_info *) dst;
 901
 902         dst_release(dst);
 903
 904         return NULL;
 905 }
 906 EXPORT_SYMBOL(rt6_lookup);
 907
 908 /* ip6_ins_rt is called with FREE table->tb6_lock.
 909    It takes new route entry, the addition fails by any reason the
 910    route is freed. In any case, if caller does not hold it, it may
 911    be destroyed.
 912  */
 913
 914 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
 915                         struct mx6_config *mxc)
 916 {
 917         int err;
 918         struct fib6_table *table;
 919
 920         table = rt->rt6i_table;
 921         write_lock_bh(&table->tb6_lock);
 922         err = fib6_add(&table->tb6_root, rt, info, mxc);
 923         write_unlock_bh(&table->tb6_lock);
 924
 925         return err;
 926 }
 927
 928 int ip6_ins_rt(struct rt6_info *rt)
 929 {
 930         struct nl_info info = { .nl_net = dev_net(rt->dst.dev), };
 931         struct mx6_config mxc = { .mx = NULL, };
 932
 933         return __ip6_ins_rt(rt, &info, &mxc);
 934 }
 935
 936 static struct rt6_info *ip6_rt_cache_alloc(struct rt6_info *ort,
 937                                            const struct in6_addr *daddr,
 938                                            const struct in6_addr *saddr)
 939 {
 940         struct rt6_info *rt;
 941
 942         /*
 943          *      Clone the route.
 944          */
 945
 946         if (ort->rt6i_flags & (RTF_CACHE | RTF_PCPU))
 947                 ort = (struct rt6_info *)ort->dst.from;
 948
 949         rt = __ip6_dst_alloc(dev_net(ort->dst.dev), ort->dst.dev, 0);
 950
 951         if (!rt)
 952                 return NULL;
 953
 954         ip6_rt_copy_init(rt, ort);
 955         rt->rt6i_flags |= RTF_CACHE;
 956         rt->rt6i_metric = 0;
 957         rt->dst.flags |= DST_HOST;
 958         rt->rt6i_dst.addr = *daddr;
 959         rt->rt6i_dst.plen = 128;
 960
 961         if (!rt6_is_gw_or_nonexthop(ort)) {
 962                 if (ort->rt6i_dst.plen != 128 &&
 963                     ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
 964                         rt->rt6i_flags |= RTF_ANYCAST;
 965 #ifdef CONFIG_IPV6_SUBTREES
 966                 if (rt->rt6i_src.plen && saddr) {
 967                         rt->rt6i_src.addr = *saddr;
 968                         rt->rt6i_src.plen = 128;
 969                 }
 970 #endif
 971         }
 972
 973         return rt;
 974 }
 975
 976 static struct rt6_info *ip6_rt_pcpu_alloc(struct rt6_info *rt)
 977 {
 978         struct rt6_info *pcpu_rt;
 979
 980         pcpu_rt = __ip6_dst_alloc(dev_net(rt->dst.dev),
 981                                   rt->dst.dev, rt->dst.flags);
 982
 983         if (!pcpu_rt)
 984                 return NULL;
 985         ip6_rt_copy_init(pcpu_rt, rt);
 986         pcpu_rt->rt6i_protocol = rt->rt6i_protocol;
 987         pcpu_rt->rt6i_flags |= RTF_PCPU;
 988         return pcpu_rt;
 989 }
 990
 991 /* It should be called with read_lock_bh(&tb6_lock) acquired */
 992 static struct rt6_info *rt6_get_pcpu_route(struct rt6_info *rt)
 993 {
 994         struct rt6_info *pcpu_rt, **p;
 995
 996         p = this_cpu_ptr(rt->rt6i_pcpu);
 997         pcpu_rt = *p;
 998
 999         if (pcpu_rt) {
1000                 dst_hold(&pcpu_rt->dst);
1001                 rt6_dst_from_metrics_check(pcpu_rt);
1002         }
1003         return pcpu_rt;
1004 }
1005
1006 static struct rt6_info *rt6_make_pcpu_route(struct rt6_info *rt)
1007 {
1008         struct fib6_table *table = rt->rt6i_table;
1009         struct rt6_info *pcpu_rt, *prev, **p;
1010
1011         pcpu_rt = ip6_rt_pcpu_alloc(rt);
1012         if (!pcpu_rt) {
1013                 struct net *net = dev_net(rt->dst.dev);
1014
1015                 dst_hold(&net->ipv6.ip6_null_entry->dst);
1016                 return net->ipv6.ip6_null_entry;
1017         }
1018
1019         read_lock_bh(&table->tb6_lock);
1020         if (rt->rt6i_pcpu) {
1021                 p = this_cpu_ptr(rt->rt6i_pcpu);
1022                 prev = cmpxchg(p, NULL, pcpu_rt);
1023                 if (prev) {
1024                         /* If someone did it before us, return prev instead */
1025                         dst_destroy(&pcpu_rt->dst);
1026                         pcpu_rt = prev;
1027                 }
1028         } else {
1029                 /* rt has been removed from the fib6 tree
1030                  * before we have a chance to acquire the read_lock.
1031                  * In this case, don't brother to create a pcpu rt
1032                  * since rt is going away anyway.  The next
1033                  * dst_check() will trigger a re-lookup.
1034                  */
1035                 dst_destroy(&pcpu_rt->dst);
1036                 pcpu_rt = rt;
1037         }
1038         dst_hold(&pcpu_rt->dst);
1039         rt6_dst_from_metrics_check(pcpu_rt);
1040         read_unlock_bh(&table->tb6_lock);
1041         return pcpu_rt;
1042 }
1043
1044 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
1045                                       struct flowi6 *fl6, int flags)
1046 {
1047         struct fib6_node *fn, *saved_fn;
1048         struct rt6_info *rt;
1049         int strict = 0;
1050
1051         strict |= flags & RT6_LOOKUP_F_IFACE;
1052         if (net->ipv6.devconf_all->forwarding == 0)
1053                 strict |= RT6_LOOKUP_F_REACHABLE;
1054
1055         read_lock_bh(&table->tb6_lock);
1056
1057         fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1058         saved_fn = fn;
1059
1060         if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
1061                 oif = 0;
1062
1063 redo_rt6_select:
1064         rt = rt6_select(fn, oif, strict);
1065         if (rt->rt6i_nsiblings)
1066                 rt = rt6_multipath_select(rt, fl6, oif, strict);
1067         if (rt == net->ipv6.ip6_null_entry) {
1068                 fn = fib6_backtrack(fn, &fl6->saddr);
1069                 if (fn)
1070                         goto redo_rt6_select;
1071                 else if (strict & RT6_LOOKUP_F_REACHABLE) {
1072                         /* also consider unreachable route */
1073                         strict &= ~RT6_LOOKUP_F_REACHABLE;
1074                         fn = saved_fn;
1075                         goto redo_rt6_select;
1076                 }
1077         }
1078
1079
1080         if (rt == net->ipv6.ip6_null_entry || (rt->rt6i_flags & RTF_CACHE)) {
1081                 dst_use(&rt->dst, jiffies);
1082                 read_unlock_bh(&table->tb6_lock);
1083
1084                 rt6_dst_from_metrics_check(rt);
1085
1086                 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
1087                 return rt;
1088         } else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
1089                             !(rt->rt6i_flags & RTF_GATEWAY))) {
1090                 /* Create a RTF_CACHE clone which will not be
1091                  * owned by the fib6 tree.  It is for the special case where
1092                  * the daddr in the skb during the neighbor look-up is different
1093                  * from the fl6->daddr used to look-up route here.
1094                  */
1095
1096                 struct rt6_info *uncached_rt;
1097
1098                 dst_use(&rt->dst, jiffies);
1099                 read_unlock_bh(&table->tb6_lock);
1100
1101                 uncached_rt = ip6_rt_cache_alloc(rt, &fl6->daddr, NULL);
1102                 dst_release(&rt->dst);
1103
1104                 if (uncached_rt)
1105                         rt6_uncached_list_add(uncached_rt);
1106                 else
1107                         uncached_rt = net->ipv6.ip6_null_entry;
1108
1109                 dst_hold(&uncached_rt->dst);
1110
1111                 trace_fib6_table_lookup(net, uncached_rt, table->tb6_id, fl6);
1112                 return uncached_rt;
1113
1114         } else {
1115                 /* Get a percpu copy */
1116
1117                 struct rt6_info *pcpu_rt;
1118
1119                 rt->dst.lastuse = jiffies;
1120                 rt->dst.__use++;
1121                 pcpu_rt = rt6_get_pcpu_route(rt);
1122
1123                 if (pcpu_rt) {
1124                         read_unlock_bh(&table->tb6_lock);
1125                 } else {
1126                         /* We have to do the read_unlock first
1127                          * because rt6_make_pcpu_route() may trigger
1128                          * ip6_dst_gc() which will take the write_lock.
1129                          */
1130                         dst_hold(&rt->dst);
1131                         read_unlock_bh(&table->tb6_lock);
1132                         pcpu_rt = rt6_make_pcpu_route(rt);
1133                         dst_release(&rt->dst);
1134                 }
1135
1136                 trace_fib6_table_lookup(net, pcpu_rt, table->tb6_id, fl6);
1137                 return pcpu_rt;
1138
1139         }
1140 }
1141
1142 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
1143                                             struct flowi6 *fl6, int flags)
1144 {
1145         return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
1146 }
1147
1148 static struct dst_entry *ip6_route_input_lookup(struct net *net,
1149                                                 struct net_device *dev,
1150                                                 struct flowi6 *fl6, int flags)
1151 {
1152         if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
1153                 flags |= RT6_LOOKUP_F_IFACE;
1154
1155         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
1156 }
1157
1158 void ip6_route_input(struct sk_buff *skb)
1159 {
1160         const struct ipv6hdr *iph = ipv6_hdr(skb);
1161         struct net *net = dev_net(skb->dev);
1162         int flags = RT6_LOOKUP_F_HAS_SADDR;
1163         struct ip_tunnel_info *tun_info;
1164         struct flowi6 fl6 = {
1165                 .flowi6_iif = l3mdev_fib_oif(skb->dev),
1166                 .daddr = iph->daddr,
1167                 .saddr = iph->saddr,
1168                 .flowlabel = ip6_flowinfo(iph),
1169                 .flowi6_mark = skb->mark,
1170                 .flowi6_proto = iph->nexthdr,
1171         };
1172
1173         tun_info = skb_tunnel_info(skb);
1174         if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
1175                 fl6.flowi6_tun_key.tun_id = tun_info->key.tun_id;
1176         skb_dst_drop(skb);
1177         skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
1178 }
1179
1180 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
1181                                              struct flowi6 *fl6, int flags)
1182 {
1183         return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
1184 }
1185
1186 struct dst_entry *ip6_route_output(struct net *net, const struct sock *sk,
1187                                     struct flowi6 *fl6)
1188 {
1189         struct dst_entry *dst;
1190         int flags = 0;
1191         bool any_src;
1192
1193         dst = l3mdev_rt6_dst_by_oif(net, fl6);
1194         if (dst)
1195                 return dst;
1196
1197         fl6->flowi6_iif = LOOPBACK_IFINDEX;
1198
1199         any_src = ipv6_addr_any(&fl6->saddr);
1200         if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr) ||
1201             (fl6->flowi6_oif && any_src))
1202                 flags |= RT6_LOOKUP_F_IFACE;
1203
1204         if (!any_src)
1205                 flags |= RT6_LOOKUP_F_HAS_SADDR;
1206         else if (sk)
1207                 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1208
1209         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1210 }
1211 EXPORT_SYMBOL(ip6_route_output);
1212
1213 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1214 {
1215         struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1216         struct dst_entry *new = NULL;
1217
1218         rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1219         if (rt) {
1220                 rt6_info_init(rt);
1221
1222                 new = &rt->dst;
1223                 new->__use = 1;
1224                 new->input = dst_discard;
1225                 new->output = dst_discard_out;
1226
1227                 dst_copy_metrics(new, &ort->dst);
1228                 rt->rt6i_idev = ort->rt6i_idev;
1229                 if (rt->rt6i_idev)
1230                         in6_dev_hold(rt->rt6i_idev);
1231
1232                 rt->rt6i_gateway = ort->rt6i_gateway;
1233                 rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;
1234                 rt->rt6i_metric = 0;
1235
1236                 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1237 #ifdef CONFIG_IPV6_SUBTREES
1238                 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1239 #endif
1240
1241                 dst_free(new);
1242         }
1243
1244         dst_release(dst_orig);
1245         return new ? new : ERR_PTR(-ENOMEM);
1246 }
1247
1248 /*
1249  *      Destination cache support functions
1250  */
1251
1252 static void rt6_dst_from_metrics_check(struct rt6_info *rt)
1253 {
1254         if (rt->dst.from &&
1255             dst_metrics_ptr(&rt->dst) != dst_metrics_ptr(rt->dst.from))
1256                 dst_init_metrics(&rt->dst, dst_metrics_ptr(rt->dst.from), true);
1257 }
1258
1259 static struct dst_entry *rt6_check(struct rt6_info *rt, u32 cookie)
1260 {
1261         if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
1262                 return NULL;
1263
1264         if (rt6_check_expired(rt))
1265                 return NULL;
1266
1267         return &rt->dst;
1268 }
1269
1270 static struct dst_entry *rt6_dst_from_check(struct rt6_info *rt, u32 cookie)
1271 {
1272         if (!__rt6_check_expired(rt) &&
1273             rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1274             rt6_check((struct rt6_info *)(rt->dst.from), cookie))
1275                 return &rt->dst;
1276         else
1277                 return NULL;
1278 }
1279
1280 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1281 {
1282         struct rt6_info *rt;
1283
1284         rt = (struct rt6_info *) dst;
1285
1286         /* All IPV6 dsts are created with ->obsolete set to the value
1287          * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1288          * into this function always.
1289          */
1290
1291         rt6_dst_from_metrics_check(rt);
1292
1293         if (rt->rt6i_flags & RTF_PCPU ||
1294             (unlikely(dst->flags & DST_NOCACHE) && rt->dst.from))
1295                 return rt6_dst_from_check(rt, cookie);
1296         else
1297                 return rt6_check(rt, cookie);
1298 }
1299
1300 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1301 {
1302         struct rt6_info *rt = (struct rt6_info *) dst;
1303
1304         if (rt) {
1305                 if (rt->rt6i_flags & RTF_CACHE) {
1306                         if (rt6_check_expired(rt)) {
1307                                 ip6_del_rt(rt);
1308                                 dst = NULL;
1309                         }
1310                 } else {
1311                         dst_release(dst);
1312                         dst = NULL;
1313                 }
1314         }
1315         return dst;
1316 }
1317
1318 static void ip6_link_failure(struct sk_buff *skb)
1319 {
1320         struct rt6_info *rt;
1321
1322         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1323
1324         rt = (struct rt6_info *) skb_dst(skb);
1325         if (rt) {
1326                 if (rt->rt6i_flags & RTF_CACHE) {
1327                         dst_hold(&rt->dst);
1328                         ip6_del_rt(rt);
1329                 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
1330                         rt->rt6i_node->fn_sernum = -1;
1331                 }
1332         }
1333 }
1334
1335 static void rt6_do_update_pmtu(struct rt6_info *rt, u32 mtu)
1336 {
1337         struct net *net = dev_net(rt->dst.dev);
1338
1339         rt->rt6i_flags |= RTF_MODIFIED;
1340         rt->rt6i_pmtu = mtu;
1341         rt6_update_expires(rt, net->ipv6.sysctl.ip6_rt_mtu_expires);
1342 }
1343
1344 static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
1345 {
1346         return !(rt->rt6i_flags & RTF_CACHE) &&
1347                 (rt->rt6i_flags & RTF_PCPU || rt->rt6i_node);
1348 }
1349
1350 static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,
1351                                  const struct ipv6hdr *iph, u32 mtu)
1352 {
1353         struct rt6_info *rt6 = (struct rt6_info *)dst;
1354
1355         if (rt6->rt6i_flags & RTF_LOCAL)
1356                 return;
1357
1358         dst_confirm(dst);
1359         mtu = max_t(u32, mtu, IPV6_MIN_MTU);
1360         if (mtu >= dst_mtu(dst))
1361                 return;
1362
1363         if (!rt6_cache_allowed_for_pmtu(rt6)) {
1364                 rt6_do_update_pmtu(rt6, mtu);
1365         } else {
1366                 const struct in6_addr *daddr, *saddr;
1367                 struct rt6_info *nrt6;
1368
1369                 if (iph) {
1370                         daddr = &iph->daddr;
1371                         saddr = &iph->saddr;
1372                 } else if (sk) {
1373                         daddr = &sk->sk_v6_daddr;
1374                         saddr = &inet6_sk(sk)->saddr;
1375                 } else {
1376                         return;
1377                 }
1378                 nrt6 = ip6_rt_cache_alloc(rt6, daddr, saddr);
1379                 if (nrt6) {
1380                         rt6_do_update_pmtu(nrt6, mtu);
1381
1382                         /* ip6_ins_rt(nrt6) will bump the
1383                          * rt6->rt6i_node->fn_sernum
1384                          * which will fail the next rt6_check() and
1385                          * invalidate the sk->sk_dst_cache.
1386                          */
1387                         ip6_ins_rt(nrt6);
1388                 }
1389         }
1390 }
1391
1392 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1393                                struct sk_buff *skb, u32 mtu)
1394 {
1395         __ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
1396 }
1397
1398 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1399                      int oif, u32 mark)
1400 {
1401         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1402         struct dst_entry *dst;
1403         struct flowi6 fl6;
1404
1405         memset(&fl6, 0, sizeof(fl6));
1406         fl6.flowi6_oif = oif;
1407         fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
1408         fl6.daddr = iph->daddr;
1409         fl6.saddr = iph->saddr;
1410         fl6.flowlabel = ip6_flowinfo(iph);
1411
1412         dst = ip6_route_output(net, NULL, &fl6);
1413         if (!dst->error)
1414                 __ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
1415         dst_release(dst);
1416 }
1417 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1418
1419 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1420 {
1421         ip6_update_pmtu(skb, sock_net(sk), mtu,
1422                         sk->sk_bound_dev_if, sk->sk_mark);
1423 }
1424 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1425
1426 /* Handle redirects */
1427 struct ip6rd_flowi {
1428         struct flowi6 fl6;
1429         struct in6_addr gateway;
1430 };
1431
1432 static struct rt6_info *__ip6_route_redirect(struct net *net,
1433                                              struct fib6_table *table,
1434                                              struct flowi6 *fl6,
1435                                              int flags)
1436 {
1437         struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1438         struct rt6_info *rt;
1439         struct fib6_node *fn;
1440
1441         /* Get the "current" route for this destination and
1442          * check if the redirect has come from approriate router.
1443          *
1444          * RFC 4861 specifies that redirects should only be
1445          * accepted if they come from the nexthop to the target.
1446          * Due to the way the routes are chosen, this notion
1447          * is a bit fuzzy and one might need to check all possible
1448          * routes.
1449          */
1450
1451         read_lock_bh(&table->tb6_lock);
1452         fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1453 restart:
1454         for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1455                 if (rt6_check_expired(rt))
1456                         continue;
1457                 if (rt->dst.error)
1458                         break;
1459                 if (!(rt->rt6i_flags & RTF_GATEWAY))
1460                         continue;
1461                 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1462                         continue;
1463                 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1464                         continue;
1465                 break;
1466         }
1467
1468         if (!rt)
1469                 rt = net->ipv6.ip6_null_entry;
1470         else if (rt->dst.error) {
1471                 rt = net->ipv6.ip6_null_entry;
1472                 goto out;
1473         }
1474
1475         if (rt == net->ipv6.ip6_null_entry) {
1476                 fn = fib6_backtrack(fn, &fl6->saddr);
1477                 if (fn)
1478                         goto restart;
1479         }
1480
1481 out:
1482         dst_hold(&rt->dst);
1483
1484         read_unlock_bh(&table->tb6_lock);
1485
1486         trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
1487         return rt;
1488 };
1489
1490 static struct dst_entry *ip6_route_redirect(struct net *net,
1491                                         const struct flowi6 *fl6,
1492                                         const struct in6_addr *gateway)
1493 {
1494         int flags = RT6_LOOKUP_F_HAS_SADDR;
1495         struct ip6rd_flowi rdfl;
1496
1497         rdfl.fl6 = *fl6;
1498         rdfl.gateway = *gateway;
1499
1500         return fib6_rule_lookup(net, &rdfl.fl6,
1501                                 flags, __ip6_route_redirect);
1502 }
1503
1504 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1505 {
1506         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1507         struct dst_entry *dst;
1508         struct flowi6 fl6;
1509
1510         memset(&fl6, 0, sizeof(fl6));
1511         fl6.flowi6_iif = LOOPBACK_IFINDEX;
1512         fl6.flowi6_oif = oif;
1513         fl6.flowi6_mark = mark;
1514         fl6.daddr = iph->daddr;
1515         fl6.saddr = iph->saddr;
1516         fl6.flowlabel = ip6_flowinfo(iph);
1517
1518         dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1519         rt6_do_redirect(dst, NULL, skb);
1520         dst_release(dst);
1521 }
1522 EXPORT_SYMBOL_GPL(ip6_redirect);
1523
1524 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1525                             u32 mark)
1526 {
1527         const struct ipv6hdr *iph = ipv6_hdr(skb);
1528         const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1529         struct dst_entry *dst;
1530         struct flowi6 fl6;
1531
1532         memset(&fl6, 0, sizeof(fl6));
1533         fl6.flowi6_iif = LOOPBACK_IFINDEX;
1534         fl6.flowi6_oif = oif;
1535         fl6.flowi6_mark = mark;
1536         fl6.daddr = msg->dest;
1537         fl6.saddr = iph->daddr;
1538
1539         dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1540         rt6_do_redirect(dst, NULL, skb);
1541         dst_release(dst);
1542 }
1543
1544 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1545 {
1546         ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1547 }
1548 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1549
1550 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1551 {
1552         struct net_device *dev = dst->dev;
1553         unsigned int mtu = dst_mtu(dst);
1554         struct net *net = dev_net(dev);
1555
1556         mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1557
1558         if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1559                 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1560
1561         /*
1562          * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1563          * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1564          * IPV6_MAXPLEN is also valid and means: "any MSS,
1565          * rely only on pmtu discovery"
1566          */
1567         if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1568                 mtu = IPV6_MAXPLEN;
1569         return mtu;
1570 }
1571
1572 static unsigned int ip6_mtu(const struct dst_entry *dst)
1573 {
1574         const struct rt6_info *rt = (const struct rt6_info *)dst;
1575         unsigned int mtu = rt->rt6i_pmtu;
1576         struct inet6_dev *idev;
1577
1578         if (mtu)
1579                 goto out;
1580
1581         mtu = dst_metric_raw(dst, RTAX_MTU);
1582         if (mtu)
1583                 goto out;
1584
1585         mtu = IPV6_MIN_MTU;
1586
1587         rcu_read_lock();
1588         idev = __in6_dev_get(dst->dev);
1589         if (idev)
1590                 mtu = idev->cnf.mtu6;
1591         rcu_read_unlock();
1592
1593 out:
1594         return min_t(unsigned int, mtu, IP6_MAX_MTU);
1595 }
1596
1597 static struct dst_entry *icmp6_dst_gc_list;
1598 static DEFINE_SPINLOCK(icmp6_dst_lock);
1599
1600 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1601                                   struct flowi6 *fl6)
1602 {
1603         struct dst_entry *dst;
1604         struct rt6_info *rt;
1605         struct inet6_dev *idev = in6_dev_get(dev);
1606         struct net *net = dev_net(dev);
1607
1608         if (unlikely(!idev))
1609                 return ERR_PTR(-ENODEV);
1610
1611         rt = ip6_dst_alloc(net, dev, 0);
1612         if (unlikely(!rt)) {
1613                 in6_dev_put(idev);
1614                 dst = ERR_PTR(-ENOMEM);
1615                 goto out;
1616         }
1617
1618         rt->dst.flags |= DST_HOST;
1619         rt->dst.output  = ip6_output;
1620         atomic_set(&rt->dst.__refcnt, 1);
1621         rt->rt6i_gateway  = fl6->daddr;
1622         rt->rt6i_dst.addr = fl6->daddr;
1623         rt->rt6i_dst.plen = 128;
1624         rt->rt6i_idev     = idev;
1625         dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1626
1627         spin_lock_bh(&icmp6_dst_lock);
1628         rt->dst.next = icmp6_dst_gc_list;
1629         icmp6_dst_gc_list = &rt->dst;
1630         spin_unlock_bh(&icmp6_dst_lock);
1631
1632         fib6_force_start_gc(net);
1633
1634         dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1635
1636 out:
1637         return dst;
1638 }
1639
1640 int icmp6_dst_gc(void)
1641 {
1642         struct dst_entry *dst, **pprev;
1643         int more = 0;
1644
1645         spin_lock_bh(&icmp6_dst_lock);
1646         pprev = &icmp6_dst_gc_list;
1647
1648         while ((dst = *pprev) != NULL) {
1649                 if (!atomic_read(&dst->__refcnt)) {
1650                         *pprev = dst->next;
1651                         dst_free(dst);
1652                 } else {
1653                         pprev = &dst->next;
1654                         ++more;
1655                 }
1656         }
1657
1658         spin_unlock_bh(&icmp6_dst_lock);
1659
1660         return more;
1661 }
1662
1663 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1664                             void *arg)
1665 {
1666         struct dst_entry *dst, **pprev;
1667
1668         spin_lock_bh(&icmp6_dst_lock);
1669         pprev = &icmp6_dst_gc_list;
1670         while ((dst = *pprev) != NULL) {
1671                 struct rt6_info *rt = (struct rt6_info *) dst;
1672                 if (func(rt, arg)) {
1673                         *pprev = dst->next;
1674                         dst_free(dst);
1675                 } else {
1676                         pprev = &dst->next;
1677                 }
1678         }
1679         spin_unlock_bh(&icmp6_dst_lock);
1680 }
1681
1682 static int ip6_dst_gc(struct dst_ops *ops)
1683 {
1684         struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1685         int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1686         int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1687         int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1688         int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1689         unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1690         int entries;
1691
1692         entries = dst_entries_get_fast(ops);
1693         if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1694             entries <= rt_max_size)
1695                 goto out;
1696
1697         net->ipv6.ip6_rt_gc_expire++;
1698         fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
1699         entries = dst_entries_get_slow(ops);
1700         if (entries < ops->gc_thresh)
1701                 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1702 out:
1703         net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1704         return entries > rt_max_size;
1705 }
1706
1707 static int ip6_convert_metrics(struct mx6_config *mxc,
1708                                const struct fib6_config *cfg)
1709 {
1710         bool ecn_ca = false;
1711         struct nlattr *nla;
1712         int remaining;
1713         u32 *mp;
1714
1715         if (!cfg->fc_mx)
1716                 return 0;
1717
1718         mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1719         if (unlikely(!mp))
1720                 return -ENOMEM;
1721
1722         nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1723                 int type = nla_type(nla);
1724                 u32 val;
1725
1726                 if (!type)
1727                         continue;
1728                 if (unlikely(type > RTAX_MAX))
1729                         goto err;
1730
1731                 if (type == RTAX_CC_ALGO) {
1732                         char tmp[TCP_CA_NAME_MAX];
1733
1734                         nla_strlcpy(tmp, nla, sizeof(tmp));
1735                         val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
1736                         if (val == TCP_CA_UNSPEC)
1737                                 goto err;
1738                 } else {
1739                         val = nla_get_u32(nla);
1740                 }
1741                 if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
1742                         goto err;
1743
1744                 mp[type - 1] = val;
1745                 __set_bit(type - 1, mxc->mx_valid);
1746         }
1747
1748         if (ecn_ca) {
1749                 __set_bit(RTAX_FEATURES - 1, mxc->mx_valid);
1750                 mp[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
1751         }
1752
1753         mxc->mx = mp;
1754         return 0;
1755  err:
1756         kfree(mp);
1757         return -EINVAL;
1758 }
1759
1760 static struct rt6_info *ip6_route_info_create(struct fib6_config *cfg)
1761 {
1762         struct net *net = cfg->fc_nlinfo.nl_net;
1763         struct rt6_info *rt = NULL;
1764         struct net_device *dev = NULL;
1765         struct inet6_dev *idev = NULL;
1766         struct fib6_table *table;
1767         int addr_type;
1768         int err = -EINVAL;
1769
1770         if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1771                 goto out;
1772 #ifndef CONFIG_IPV6_SUBTREES
1773         if (cfg->fc_src_len)
1774                 goto out;
1775 #endif
1776         if (cfg->fc_ifindex) {
1777                 err = -ENODEV;
1778                 dev = dev_get_by_index(net, cfg->fc_ifindex);
1779                 if (!dev)
1780                         goto out;
1781                 idev = in6_dev_get(dev);
1782                 if (!idev)
1783                         goto out;
1784         }
1785
1786         if (cfg->fc_metric == 0)
1787                 cfg->fc_metric = IP6_RT_PRIO_USER;
1788
1789         err = -ENOBUFS;
1790         if (cfg->fc_nlinfo.nlh &&
1791             !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1792                 table = fib6_get_table(net, cfg->fc_table);
1793                 if (!table) {
1794                         pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1795                         table = fib6_new_table(net, cfg->fc_table);
1796                 }
1797         } else {
1798                 table = fib6_new_table(net, cfg->fc_table);
1799         }
1800
1801         if (!table)
1802                 goto out;
1803
1804         rt = ip6_dst_alloc(net, NULL,
1805                            (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT);
1806
1807         if (!rt) {
1808                 err = -ENOMEM;
1809                 goto out;
1810         }
1811
1812         if (cfg->fc_flags & RTF_EXPIRES)
1813                 rt6_set_expires(rt, jiffies +
1814                                 clock_t_to_jiffies(cfg->fc_expires));
1815         else
1816                 rt6_clean_expires(rt);
1817
1818         if (cfg->fc_protocol == RTPROT_UNSPEC)
1819                 cfg->fc_protocol = RTPROT_BOOT;
1820         rt->rt6i_protocol = cfg->fc_protocol;
1821
1822         addr_type = ipv6_addr_type(&cfg->fc_dst);
1823
1824         if (addr_type & IPV6_ADDR_MULTICAST)
1825                 rt->dst.input = ip6_mc_input;
1826         else if (cfg->fc_flags & RTF_LOCAL)
1827                 rt->dst.input = ip6_input;
1828         else
1829                 rt->dst.input = ip6_forward;
1830
1831         rt->dst.output = ip6_output;
1832
1833         if (cfg->fc_encap) {
1834                 struct lwtunnel_state *lwtstate;
1835
1836                 err = lwtunnel_build_state(dev, cfg->fc_encap_type,
1837                                            cfg->fc_encap, AF_INET6, cfg,
1838                                            &lwtstate);
1839                 if (err)
1840                         goto out;
1841                 rt->dst.lwtstate = lwtstate_get(lwtstate);
1842                 if (lwtunnel_output_redirect(rt->dst.lwtstate)) {
1843                         rt->dst.lwtstate->orig_output = rt->dst.output;
1844                         rt->dst.output = lwtunnel_output;
1845                 }
1846                 if (lwtunnel_input_redirect(rt->dst.lwtstate)) {
1847                         rt->dst.lwtstate->orig_input = rt->dst.input;
1848                         rt->dst.input = lwtunnel_input;
1849                 }
1850         }
1851
1852         ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1853         rt->rt6i_dst.plen = cfg->fc_dst_len;
1854         if (rt->rt6i_dst.plen == 128)
1855                 rt->dst.flags |= DST_HOST;
1856
1857 #ifdef CONFIG_IPV6_SUBTREES
1858         ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1859         rt->rt6i_src.plen = cfg->fc_src_len;
1860 #endif
1861
1862         rt->rt6i_metric = cfg->fc_metric;
1863
1864         /* We cannot add true routes via loopback here,
1865            they would result in kernel looping; promote them to reject routes
1866          */
1867         if ((cfg->fc_flags & RTF_REJECT) ||
1868             (dev && (dev->flags & IFF_LOOPBACK) &&
1869              !(addr_type & IPV6_ADDR_LOOPBACK) &&
1870              !(cfg->fc_flags & RTF_LOCAL))) {
1871                 /* hold loopback dev/idev if we haven't done so. */
1872                 if (dev != net->loopback_dev) {
1873                         if (dev) {
1874                                 dev_put(dev);
1875                                 in6_dev_put(idev);
1876                         }
1877                         dev = net->loopback_dev;
1878                         dev_hold(dev);
1879                         idev = in6_dev_get(dev);
1880                         if (!idev) {
1881                                 err = -ENODEV;
1882                                 goto out;
1883                         }
1884                 }
1885                 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1886                 switch (cfg->fc_type) {
1887                 case RTN_BLACKHOLE:
1888                         rt->dst.error = -EINVAL;
1889                         rt->dst.output = dst_discard_out;
1890                         rt->dst.input = dst_discard;
1891                         break;
1892                 case RTN_PROHIBIT:
1893                         rt->dst.error = -EACCES;
1894                         rt->dst.output = ip6_pkt_prohibit_out;
1895                         rt->dst.input = ip6_pkt_prohibit;
1896                         break;
1897                 case RTN_THROW:
1898                 case RTN_UNREACHABLE:
1899                 default:
1900                         rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1901                                         : (cfg->fc_type == RTN_UNREACHABLE)
1902                                         ? -EHOSTUNREACH : -ENETUNREACH;
1903                         rt->dst.output = ip6_pkt_discard_out;
1904                         rt->dst.input = ip6_pkt_discard;
1905                         break;
1906                 }
1907                 goto install_route;
1908         }
1909
1910         if (cfg->fc_flags & RTF_GATEWAY) {
1911                 const struct in6_addr *gw_addr;
1912                 int gwa_type;
1913
1914                 gw_addr = &cfg->fc_gateway;
1915                 gwa_type = ipv6_addr_type(gw_addr);
1916
1917                 /* if gw_addr is local we will fail to detect this in case
1918                  * address is still TENTATIVE (DAD in progress). rt6_lookup()
1919                  * will return already-added prefix route via interface that
1920                  * prefix route was assigned to, which might be non-loopback.
1921                  */
1922                 err = -EINVAL;
1923                 if (ipv6_chk_addr_and_flags(net, gw_addr,
1924                                             gwa_type & IPV6_ADDR_LINKLOCAL ?
1925                                             dev : NULL, 0, 0))
1926                         goto out;
1927
1928                 rt->rt6i_gateway = *gw_addr;
1929
1930                 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1931                         struct rt6_info *grt;
1932
1933                         /* IPv6 strictly inhibits using not link-local
1934                            addresses as nexthop address.
1935                            Otherwise, router will not able to send redirects.
1936                            It is very good, but in some (rare!) circumstances
1937                            (SIT, PtP, NBMA NOARP links) it is handy to allow
1938                            some exceptions. --ANK
1939                          */
1940                         if (!(gwa_type & IPV6_ADDR_UNICAST))
1941                                 goto out;
1942
1943                         grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1944
1945                         err = -EHOSTUNREACH;
1946                         if (!grt)
1947                                 goto out;
1948                         if (dev) {
1949                                 if (dev != grt->dst.dev) {
1950                                         ip6_rt_put(grt);
1951                                         goto out;
1952                                 }
1953                         } else {
1954                                 dev = grt->dst.dev;
1955                                 idev = grt->rt6i_idev;
1956                                 dev_hold(dev);
1957                                 in6_dev_hold(grt->rt6i_idev);
1958                         }
1959                         if (!(grt->rt6i_flags & RTF_GATEWAY))
1960                                 err = 0;
1961                         ip6_rt_put(grt);
1962
1963                         if (err)
1964                                 goto out;
1965                 }
1966                 err = -EINVAL;
1967                 if (!dev || (dev->flags & IFF_LOOPBACK))
1968                         goto out;
1969         }
1970
1971         err = -ENODEV;
1972         if (!dev)
1973                 goto out;
1974
1975         if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1976                 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1977                         err = -EINVAL;
1978                         goto out;
1979                 }
1980                 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1981                 rt->rt6i_prefsrc.plen = 128;
1982         } else
1983                 rt->rt6i_prefsrc.plen = 0;
1984
1985         rt->rt6i_flags = cfg->fc_flags;
1986
1987 install_route:
1988         rt->dst.dev = dev;
1989         rt->rt6i_idev = idev;
1990         rt->rt6i_table = table;
1991
1992         cfg->fc_nlinfo.nl_net = dev_net(dev);
1993
1994         return rt;
1995 out:
1996         if (dev)
1997                 dev_put(dev);
1998         if (idev)
1999                 in6_dev_put(idev);
2000         if (rt)
2001                 dst_free(&rt->dst);
2002
2003         return ERR_PTR(err);
2004 }
2005
2006 int ip6_route_add(struct fib6_config *cfg)
2007 {
2008         struct mx6_config mxc = { .mx = NULL, };
2009         struct rt6_info *rt;
2010         int err;
2011
2012         rt = ip6_route_info_create(cfg);
2013         if (IS_ERR(rt)) {
2014                 err = PTR_ERR(rt);
2015                 rt = NULL;
2016                 goto out;
2017         }
2018
2019         err = ip6_convert_metrics(&mxc, cfg);
2020         if (err)
2021                 goto out;
2022
2023         err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);
2024
2025         kfree(mxc.mx);
2026
2027         return err;
2028 out:
2029         if (rt)
2030                 dst_free(&rt->dst);
2031
2032         return err;
2033 }
2034
2035 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
2036 {
2037         int err;
2038         struct fib6_table *table;
2039         struct net *net = dev_net(rt->dst.dev);
2040
2041         if (rt == net->ipv6.ip6_null_entry ||
2042             rt->dst.flags & DST_NOCACHE) {
2043                 err = -ENOENT;
2044                 goto out;
2045         }
2046
2047         table = rt->rt6i_table;
2048         write_lock_bh(&table->tb6_lock);
2049         err = fib6_del(rt, info);
2050         write_unlock_bh(&table->tb6_lock);
2051
2052 out:
2053         ip6_rt_put(rt);
2054         return err;
2055 }
2056
2057 int ip6_del_rt(struct rt6_info *rt)
2058 {
2059         struct nl_info info = {
2060                 .nl_net = dev_net(rt->dst.dev),
2061         };
2062         return __ip6_del_rt(rt, &info);
2063 }
2064
2065 static int ip6_route_del(struct fib6_config *cfg)
2066 {
2067         struct fib6_table *table;
2068         struct fib6_node *fn;
2069         struct rt6_info *rt;
2070         int err = -ESRCH;
2071
2072         table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
2073         if (!table)
2074                 return err;
2075
2076         read_lock_bh(&table->tb6_lock);
2077
2078         fn = fib6_locate(&table->tb6_root,
2079                          &cfg->fc_dst, cfg->fc_dst_len,
2080                          &cfg->fc_src, cfg->fc_src_len);
2081
2082         if (fn) {
2083                 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2084                         if ((rt->rt6i_flags & RTF_CACHE) &&
2085                             !(cfg->fc_flags & RTF_CACHE))
2086                                 continue;
2087                         if (cfg->fc_ifindex &&
2088                             (!rt->dst.dev ||
2089                              rt->dst.dev->ifindex != cfg->fc_ifindex))
2090                                 continue;
2091                         if (cfg->fc_flags & RTF_GATEWAY &&
2092                             !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
2093                                 continue;
2094                         if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
2095                                 continue;
2096                         dst_hold(&rt->dst);
2097                         read_unlock_bh(&table->tb6_lock);
2098
2099                         return __ip6_del_rt(rt, &cfg->fc_nlinfo);
2100                 }
2101         }
2102         read_unlock_bh(&table->tb6_lock);
2103
2104         return err;
2105 }
2106
2107 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
2108 {
2109         struct netevent_redirect netevent;
2110         struct rt6_info *rt, *nrt = NULL;
2111         struct ndisc_options ndopts;
2112         struct inet6_dev *in6_dev;
2113         struct neighbour *neigh;
2114         struct rd_msg *msg;
2115         int optlen, on_link;
2116         u8 *lladdr;
2117
2118         optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
2119         optlen -= sizeof(*msg);
2120
2121         if (optlen < 0) {
2122                 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
2123                 return;
2124         }
2125
2126         msg = (struct rd_msg *)icmp6_hdr(skb);
2127
2128         if (ipv6_addr_is_multicast(&msg->dest)) {
2129                 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
2130                 return;
2131         }
2132
2133         on_link = 0;
2134         if (ipv6_addr_equal(&msg->dest, &msg->target)) {
2135                 on_link = 1;
2136         } else if (ipv6_addr_type(&msg->target) !=
2137                    (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
2138                 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
2139                 return;
2140         }
2141
2142         in6_dev = __in6_dev_get(skb->dev);
2143         if (!in6_dev)
2144                 return;
2145         if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
2146                 return;
2147
2148         /* RFC2461 8.1:
2149          *      The IP source address of the Redirect MUST be the same as the current
2150          *      first-hop router for the specified ICMP Destination Address.
2151          */
2152
2153         if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
2154                 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
2155                 return;
2156         }
2157
2158         lladdr = NULL;
2159         if (ndopts.nd_opts_tgt_lladdr) {
2160                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
2161                                              skb->dev);
2162                 if (!lladdr) {
2163                         net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
2164                         return;
2165                 }
2166         }
2167
2168         rt = (struct rt6_info *) dst;
2169         if (rt->rt6i_flags & RTF_REJECT) {
2170                 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
2171                 return;
2172         }
2173
2174         /* Redirect received -> path was valid.
2175          * Look, redirects are sent only in response to data packets,
2176          * so that this nexthop apparently is reachable. --ANK
2177          */
2178         dst_confirm(&rt->dst);
2179
2180         neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
2181         if (!neigh)
2182                 return;
2183
2184         /*
2185          *      We have finally decided to accept it.
2186          */
2187
2188         neigh_update(neigh, lladdr, NUD_STALE,
2189                      NEIGH_UPDATE_F_WEAK_OVERRIDE|
2190                      NEIGH_UPDATE_F_OVERRIDE|
2191                      (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
2192                                      NEIGH_UPDATE_F_ISROUTER))
2193                      );
2194
2195         nrt = ip6_rt_cache_alloc(rt, &msg->dest, NULL);
2196         if (!nrt)
2197                 goto out;
2198
2199         nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
2200         if (on_link)
2201                 nrt->rt6i_flags &= ~RTF_GATEWAY;
2202
2203         nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
2204
2205         if (ip6_ins_rt(nrt))
2206                 goto out;
2207
2208         netevent.old = &rt->dst;
2209         netevent.new = &nrt->dst;
2210         netevent.daddr = &msg->dest;
2211         netevent.neigh = neigh;
2212         call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
2213
2214         if (rt->rt6i_flags & RTF_CACHE) {
2215                 rt = (struct rt6_info *) dst_clone(&rt->dst);
2216                 ip6_del_rt(rt);
2217         }
2218
2219 out:
2220         neigh_release(neigh);
2221 }
2222
2223 /*
2224  *      Misc support functions
2225  */
2226
2227 static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
2228 {
2229         BUG_ON(from->dst.from);
2230
2231         rt->rt6i_flags &= ~RTF_EXPIRES;
2232         dst_hold(&from->dst);
2233         rt->dst.from = &from->dst;
2234         dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
2235 }
2236
2237 static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort)
2238 {
2239         rt->dst.input = ort->dst.input;
2240         rt->dst.output = ort->dst.output;
2241         rt->rt6i_dst = ort->rt6i_dst;
2242         rt->dst.error = ort->dst.error;
2243         rt->rt6i_idev = ort->rt6i_idev;
2244         if (rt->rt6i_idev)
2245                 in6_dev_hold(rt->rt6i_idev);
2246         rt->dst.lastuse = jiffies;
2247         rt->rt6i_gateway = ort->rt6i_gateway;
2248         rt->rt6i_flags = ort->rt6i_flags;
2249         rt6_set_from(rt, ort);
2250         rt->rt6i_metric = ort->rt6i_metric;
2251 #ifdef CONFIG_IPV6_SUBTREES
2252         rt->rt6i_src = ort->rt6i_src;
2253 #endif
2254         rt->rt6i_prefsrc = ort->rt6i_prefsrc;
2255         rt->rt6i_table = ort->rt6i_table;
2256         rt->dst.lwtstate = lwtstate_get(ort->dst.lwtstate);
2257 }
2258
2259 #ifdef CONFIG_IPV6_ROUTE_INFO
2260 static struct rt6_info *rt6_get_route_info(struct net *net,
2261                                            const struct in6_addr *prefix, int prefixlen,
2262                                            const struct in6_addr *gwaddr, int ifindex)
2263 {
2264         struct fib6_node *fn;
2265         struct rt6_info *rt = NULL;
2266         struct fib6_table *table;
2267
2268         table = fib6_get_table(net, RT6_TABLE_INFO);
2269         if (!table)
2270                 return NULL;
2271
2272         read_lock_bh(&table->tb6_lock);
2273         fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
2274         if (!fn)
2275                 goto out;
2276
2277         for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2278                 if (rt->dst.dev->ifindex != ifindex)
2279                         continue;
2280                 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
2281                         continue;
2282                 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
2283                         continue;
2284                 dst_hold(&rt->dst);
2285                 break;
2286         }
2287 out:
2288         read_unlock_bh(&table->tb6_lock);
2289         return rt;
2290 }
2291
2292 static struct rt6_info *rt6_add_route_info(struct net *net,
2293                                            const struct in6_addr *prefix, int prefixlen,
2294                                            const struct in6_addr *gwaddr, int ifindex,
2295                                            unsigned int pref)
2296 {
2297         struct fib6_config cfg = {
2298                 .fc_metric      = IP6_RT_PRIO_USER,
2299                 .fc_ifindex     = ifindex,
2300                 .fc_dst_len     = prefixlen,
2301                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2302                                   RTF_UP | RTF_PREF(pref),
2303                 .fc_nlinfo.portid = 0,
2304                 .fc_nlinfo.nlh = NULL,
2305                 .fc_nlinfo.nl_net = net,
2306         };
2307
2308         cfg.fc_table = l3mdev_fib_table_by_index(net, ifindex) ? : RT6_TABLE_INFO;
2309         cfg.fc_dst = *prefix;
2310         cfg.fc_gateway = *gwaddr;
2311
2312         /* We should treat it as a default route if prefix length is 0. */
2313         if (!prefixlen)
2314                 cfg.fc_flags |= RTF_DEFAULT;
2315
2316         ip6_route_add(&cfg);
2317
2318         return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
2319 }
2320 #endif
2321
2322 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
2323 {
2324         struct rt6_info *rt;
2325         struct fib6_table *table;
2326
2327         table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
2328         if (!table)
2329                 return NULL;
2330
2331         read_lock_bh(&table->tb6_lock);
2332         for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2333                 if (dev == rt->dst.dev &&
2334                     ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
2335                     ipv6_addr_equal(&rt->rt6i_gateway, addr))
2336                         break;
2337         }
2338         if (rt)
2339                 dst_hold(&rt->dst);
2340         read_unlock_bh(&table->tb6_lock);
2341         return rt;
2342 }
2343
2344 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
2345                                      struct net_device *dev,
2346                                      unsigned int pref)
2347 {
2348         struct fib6_config cfg = {
2349                 .fc_table       = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
2350                 .fc_metric      = IP6_RT_PRIO_USER,
2351                 .fc_ifindex     = dev->ifindex,
2352                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2353                                   RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
2354                 .fc_nlinfo.portid = 0,
2355                 .fc_nlinfo.nlh = NULL,
2356                 .fc_nlinfo.nl_net = dev_net(dev),
2357         };
2358
2359         cfg.fc_gateway = *gwaddr;
2360
2361         ip6_route_add(&cfg);
2362
2363         return rt6_get_dflt_router(gwaddr, dev);
2364 }
2365
2366 void rt6_purge_dflt_routers(struct net *net)
2367 {
2368         struct rt6_info *rt;
2369         struct fib6_table *table;
2370
2371         /* NOTE: Keep consistent with rt6_get_dflt_router */
2372         table = fib6_get_table(net, RT6_TABLE_DFLT);
2373         if (!table)
2374                 return;
2375
2376 restart:
2377         read_lock_bh(&table->tb6_lock);
2378         for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2379                 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2380                     (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2381                         dst_hold(&rt->dst);
2382                         read_unlock_bh(&table->tb6_lock);
2383                         ip6_del_rt(rt);
2384                         goto restart;
2385                 }
2386         }
2387         read_unlock_bh(&table->tb6_lock);
2388 }
2389
2390 static void rtmsg_to_fib6_config(struct net *net,
2391                                  struct in6_rtmsg *rtmsg,
2392                                  struct fib6_config *cfg)
2393 {
2394         memset(cfg, 0, sizeof(*cfg));
2395
2396         cfg->fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
2397                          : RT6_TABLE_MAIN;
2398         cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2399         cfg->fc_metric = rtmsg->rtmsg_metric;
2400         cfg->fc_expires = rtmsg->rtmsg_info;
2401         cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2402         cfg->fc_src_len = rtmsg->rtmsg_src_len;
2403         cfg->fc_flags = rtmsg->rtmsg_flags;
2404
2405         cfg->fc_nlinfo.nl_net = net;
2406
2407         cfg->fc_dst = rtmsg->rtmsg_dst;
2408         cfg->fc_src = rtmsg->rtmsg_src;
2409         cfg->fc_gateway = rtmsg->rtmsg_gateway;
2410 }
2411
2412 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2413 {
2414         struct fib6_config cfg;
2415         struct in6_rtmsg rtmsg;
2416         int err;
2417
2418         switch (cmd) {
2419         case SIOCADDRT:         /* Add a route */
2420         case SIOCDELRT:         /* Delete a route */
2421                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2422                         return -EPERM;
2423                 err = copy_from_user(&rtmsg, arg,
2424                                      sizeof(struct in6_rtmsg));
2425                 if (err)
2426                         return -EFAULT;
2427
2428                 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2429
2430                 rtnl_lock();
2431                 switch (cmd) {
2432                 case SIOCADDRT:
2433                         err = ip6_route_add(&cfg);
2434                         break;
2435                 case SIOCDELRT:
2436                         err = ip6_route_del(&cfg);
2437                         break;
2438                 default:
2439                         err = -EINVAL;
2440                 }
2441                 rtnl_unlock();
2442
2443                 return err;
2444         }
2445
2446         return -EINVAL;
2447 }
2448
2449 /*
2450  *      Drop the packet on the floor
2451  */
2452
2453 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2454 {
2455         int type;
2456         struct dst_entry *dst = skb_dst(skb);
2457         switch (ipstats_mib_noroutes) {
2458         case IPSTATS_MIB_INNOROUTES:
2459                 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2460                 if (type == IPV6_ADDR_ANY) {
2461                         IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2462                                       IPSTATS_MIB_INADDRERRORS);
2463                         break;
2464                 }
2465                 /* FALLTHROUGH */
2466         case IPSTATS_MIB_OUTNOROUTES:
2467                 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2468                               ipstats_mib_noroutes);
2469                 break;
2470         }
2471         icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2472         kfree_skb(skb);
2473         return 0;
2474 }
2475
2476 static int ip6_pkt_discard(struct sk_buff *skb)
2477 {
2478         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2479 }
2480
2481 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
2482 {
2483         skb->dev = skb_dst(skb)->dev;
2484         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2485 }
2486
2487 static int ip6_pkt_prohibit(struct sk_buff *skb)
2488 {
2489         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2490 }
2491
2492 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
2493 {
2494         skb->dev = skb_dst(skb)->dev;
2495         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2496 }
2497
2498 /*
2499  *      Allocate a dst for local (unicast / anycast) address.
2500  */
2501
2502 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2503                                     const struct in6_addr *addr,
2504                                     bool anycast)
2505 {
2506         u32 tb_id;
2507         struct net *net = dev_net(idev->dev);
2508         struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2509                                             DST_NOCOUNT);
2510         if (!rt)
2511                 return ERR_PTR(-ENOMEM);
2512
2513         in6_dev_hold(idev);
2514
2515         rt->dst.flags |= DST_HOST;
2516         rt->dst.input = ip6_input;
2517         rt->dst.output = ip6_output;
2518         rt->rt6i_idev = idev;
2519
2520         rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2521         if (anycast)
2522                 rt->rt6i_flags |= RTF_ANYCAST;
2523         else
2524                 rt->rt6i_flags |= RTF_LOCAL;
2525
2526         rt->rt6i_gateway  = *addr;
2527         rt->rt6i_dst.addr = *addr;
2528         rt->rt6i_dst.plen = 128;
2529         tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;
2530         rt->rt6i_table = fib6_get_table(net, tb_id);
2531         rt->dst.flags |= DST_NOCACHE;
2532
2533         atomic_set(&rt->dst.__refcnt, 1);
2534
2535         return rt;
2536 }
2537
2538 int ip6_route_get_saddr(struct net *net,
2539                         struct rt6_info *rt,
2540                         const struct in6_addr *daddr,
2541                         unsigned int prefs,
2542                         struct in6_addr *saddr)
2543 {
2544         struct inet6_dev *idev =
2545                 rt ? ip6_dst_idev((struct dst_entry *)rt) : NULL;
2546         int err = 0;
2547         if (rt && rt->rt6i_prefsrc.plen)
2548                 *saddr = rt->rt6i_prefsrc.addr;
2549         else
2550                 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2551                                          daddr, prefs, saddr);
2552         return err;
2553 }
2554
2555 /* remove deleted ip from prefsrc entries */
2556 struct arg_dev_net_ip {
2557         struct net_device *dev;
2558         struct net *net;
2559         struct in6_addr *addr;
2560 };
2561
2562 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2563 {
2564         struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2565         struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2566         struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2567
2568         if (((void *)rt->dst.dev == dev || !dev) &&
2569             rt != net->ipv6.ip6_null_entry &&
2570             ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2571                 /* remove prefsrc entry */
2572                 rt->rt6i_prefsrc.plen = 0;
2573         }
2574         return 0;
2575 }
2576
2577 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2578 {
2579         struct net *net = dev_net(ifp->idev->dev);
2580         struct arg_dev_net_ip adni = {
2581                 .dev = ifp->idev->dev,
2582                 .net = net,
2583                 .addr = &ifp->addr,
2584         };
2585         fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2586 }
2587
2588 #define RTF_RA_ROUTER           (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2589 #define RTF_CACHE_GATEWAY       (RTF_GATEWAY | RTF_CACHE)
2590
2591 /* Remove routers and update dst entries when gateway turn into host. */
2592 static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2593 {
2594         struct in6_addr *gateway = (struct in6_addr *)arg;
2595
2596         if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2597              ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2598              ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2599                 return -1;
2600         }
2601         return 0;
2602 }
2603
2604 void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2605 {
2606         fib6_clean_all(net, fib6_clean_tohost, gateway);
2607 }
2608
2609 struct arg_dev_net {
2610         struct net_device *dev;
2611         struct net *net;
2612 };
2613
2614 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2615 {
2616         const struct arg_dev_net *adn = arg;
2617         const struct net_device *dev = adn->dev;
2618
2619         if ((rt->dst.dev == dev || !dev) &&
2620             rt != adn->net->ipv6.ip6_null_entry)
2621                 return -1;
2622
2623         return 0;
2624 }
2625
2626 void rt6_ifdown(struct net *net, struct net_device *dev)
2627 {
2628         struct arg_dev_net adn = {
2629                 .dev = dev,
2630                 .net = net,
2631         };
2632
2633         fib6_clean_all(net, fib6_ifdown, &adn);
2634         icmp6_clean_all(fib6_ifdown, &adn);
2635         if (dev)
2636                 rt6_uncached_list_flush_dev(net, dev);
2637 }
2638
2639 struct rt6_mtu_change_arg {
2640         struct net_device *dev;
2641         unsigned int mtu;
2642 };
2643
2644 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2645 {
2646         struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2647         struct inet6_dev *idev;
2648
2649         /* In IPv6 pmtu discovery is not optional,
2650            so that RTAX_MTU lock cannot disable it.
2651            We still use this lock to block changes
2652            caused by addrconf/ndisc.
2653         */
2654
2655         idev = __in6_dev_get(arg->dev);
2656         if (!idev)
2657                 return 0;
2658
2659         /* For administrative MTU increase, there is no way to discover
2660            IPv6 PMTU increase, so PMTU increase should be updated here.
2661            Since RFC 1981 doesn't include administrative MTU increase
2662            update PMTU increase is a MUST. (i.e. jumbo frame)
2663          */
2664         /*
2665            If new MTU is less than route PMTU, this new MTU will be the
2666            lowest MTU in the path, update the route PMTU to reflect PMTU
2667            decreases; if new MTU is greater than route PMTU, and the
2668            old MTU is the lowest MTU in the path, update the route PMTU
2669            to reflect the increase. In this case if the other nodes' MTU
2670            also have the lowest MTU, TOO BIG MESSAGE will be lead to
2671            PMTU discouvery.
2672          */
2673         if (rt->dst.dev == arg->dev &&
2674             !dst_metric_locked(&rt->dst, RTAX_MTU)) {
2675                 if (rt->rt6i_flags & RTF_CACHE) {
2676                         /* For RTF_CACHE with rt6i_pmtu == 0
2677                          * (i.e. a redirected route),
2678                          * the metrics of its rt->dst.from has already
2679                          * been updated.
2680                          */
2681                         if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
2682                                 rt->rt6i_pmtu = arg->mtu;
2683                 } else if (dst_mtu(&rt->dst) >= arg->mtu ||
2684                            (dst_mtu(&rt->dst) < arg->mtu &&
2685                             dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
2686                         dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2687                 }
2688         }
2689         return 0;
2690 }
2691
2692 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2693 {
2694         struct rt6_mtu_change_arg arg = {
2695                 .dev = dev,
2696                 .mtu = mtu,
2697         };
2698
2699         fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2700 }
2701
2702 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2703         [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
2704         [RTA_OIF]               = { .type = NLA_U32 },
2705         [RTA_IIF]               = { .type = NLA_U32 },
2706         [RTA_PRIORITY]          = { .type = NLA_U32 },
2707         [RTA_METRICS]           = { .type = NLA_NESTED },
2708         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
2709         [RTA_PREF]              = { .type = NLA_U8 },
2710         [RTA_ENCAP_TYPE]        = { .type = NLA_U16 },
2711         [RTA_ENCAP]             = { .type = NLA_NESTED },
2712         [RTA_EXPIRES]           = { .type = NLA_U32 },
2713 };
2714
2715 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2716                               struct fib6_config *cfg)
2717 {
2718         struct rtmsg *rtm;
2719         struct nlattr *tb[RTA_MAX+1];
2720         unsigned int pref;
2721         int err;
2722
2723         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2724         if (err < 0)
2725                 goto errout;
2726
2727         err = -EINVAL;
2728         rtm = nlmsg_data(nlh);
2729         memset(cfg, 0, sizeof(*cfg));
2730
2731         cfg->fc_table = rtm->rtm_table;
2732         cfg->fc_dst_len = rtm->rtm_dst_len;
2733         cfg->fc_src_len = rtm->rtm_src_len;
2734         cfg->fc_flags = RTF_UP;
2735         cfg->fc_protocol = rtm->rtm_protocol;
2736         cfg->fc_type = rtm->rtm_type;
2737
2738         if (rtm->rtm_type == RTN_UNREACHABLE ||
2739             rtm->rtm_type == RTN_BLACKHOLE ||
2740             rtm->rtm_type == RTN_PROHIBIT ||
2741             rtm->rtm_type == RTN_THROW)
2742                 cfg->fc_flags |= RTF_REJECT;
2743
2744         if (rtm->rtm_type == RTN_LOCAL)
2745                 cfg->fc_flags |= RTF_LOCAL;
2746
2747         if (rtm->rtm_flags & RTM_F_CLONED)
2748                 cfg->fc_flags |= RTF_CACHE;
2749
2750         cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2751         cfg->fc_nlinfo.nlh = nlh;
2752         cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2753
2754         if (tb[RTA_GATEWAY]) {
2755                 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
2756                 cfg->fc_flags |= RTF_GATEWAY;
2757         }
2758
2759         if (tb[RTA_DST]) {
2760                 int plen = (rtm->rtm_dst_len + 7) >> 3;
2761
2762                 if (nla_len(tb[RTA_DST]) < plen)
2763                         goto errout;
2764
2765                 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2766         }
2767
2768         if (tb[RTA_SRC]) {
2769                 int plen = (rtm->rtm_src_len + 7) >> 3;
2770
2771                 if (nla_len(tb[RTA_SRC]) < plen)
2772                         goto errout;
2773
2774                 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2775         }
2776
2777         if (tb[RTA_PREFSRC])
2778                 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
2779
2780         if (tb[RTA_OIF])
2781                 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2782
2783         if (tb[RTA_PRIORITY])
2784                 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2785
2786         if (tb[RTA_METRICS]) {
2787                 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2788                 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2789         }
2790
2791         if (tb[RTA_TABLE])
2792                 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2793
2794         if (tb[RTA_MULTIPATH]) {
2795                 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2796                 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2797         }
2798
2799         if (tb[RTA_PREF]) {
2800                 pref = nla_get_u8(tb[RTA_PREF]);
2801                 if (pref != ICMPV6_ROUTER_PREF_LOW &&
2802                     pref != ICMPV6_ROUTER_PREF_HIGH)
2803                         pref = ICMPV6_ROUTER_PREF_MEDIUM;
2804                 cfg->fc_flags |= RTF_PREF(pref);
2805         }
2806
2807         if (tb[RTA_ENCAP])
2808                 cfg->fc_encap = tb[RTA_ENCAP];
2809
2810         if (tb[RTA_ENCAP_TYPE])
2811                 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
2812
2813         if (tb[RTA_EXPIRES]) {
2814                 unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);
2815
2816                 if (addrconf_finite_timeout(timeout)) {
2817                         cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
2818                         cfg->fc_flags |= RTF_EXPIRES;
2819                 }
2820         }
2821
2822         err = 0;
2823 errout:
2824         return err;
2825 }
2826
2827 struct rt6_nh {
2828         struct rt6_info *rt6_info;
2829         struct fib6_config r_cfg;
2830         struct mx6_config mxc;
2831         struct list_head next;
2832 };
2833
2834 static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
2835 {
2836         struct rt6_nh *nh;
2837
2838         list_for_each_entry(nh, rt6_nh_list, next) {
2839                 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6 nexthop %pI6 ifi %d\n",
2840                         &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
2841                         nh->r_cfg.fc_ifindex);
2842         }
2843 }
2844
2845 static int ip6_route_info_append(struct list_head *rt6_nh_list,
2846                                  struct rt6_info *rt, struct fib6_config *r_cfg)
2847 {
2848         struct rt6_nh *nh;
2849         struct rt6_info *rtnh;
2850         int err = -EEXIST;
2851
2852         list_for_each_entry(nh, rt6_nh_list, next) {
2853                 /* check if rt6_info already exists */
2854                 rtnh = nh->rt6_info;
2855
2856                 if (rtnh->dst.dev == rt->dst.dev &&
2857                     rtnh->rt6i_idev == rt->rt6i_idev &&
2858                     ipv6_addr_equal(&rtnh->rt6i_gateway,
2859                                     &rt->rt6i_gateway))
2860                         return err;
2861         }
2862
2863         nh = kzalloc(sizeof(*nh), GFP_KERNEL);
2864         if (!nh)
2865                 return -ENOMEM;
2866         nh->rt6_info = rt;
2867         err = ip6_convert_metrics(&nh->mxc, r_cfg);
2868         if (err) {
2869                 kfree(nh);
2870                 return err;
2871         }
2872         memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
2873         list_add_tail(&nh->next, rt6_nh_list);
2874
2875         return 0;
2876 }
2877
2878 static int ip6_route_multipath_add(struct fib6_config *cfg)
2879 {
2880         struct fib6_config r_cfg;
2881         struct rtnexthop *rtnh;
2882         struct rt6_info *rt;
2883         struct rt6_nh *err_nh;
2884         struct rt6_nh *nh, *nh_safe;
2885         int remaining;
2886         int attrlen;
2887         int err = 1;
2888         int nhn = 0;
2889         int replace = (cfg->fc_nlinfo.nlh &&
2890                        (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
2891         LIST_HEAD(rt6_nh_list);
2892
2893         remaining = cfg->fc_mp_len;
2894         rtnh = (struct rtnexthop *)cfg->fc_mp;
2895
2896         /* Parse a Multipath Entry and build a list (rt6_nh_list) of
2897          * rt6_info structs per nexthop
2898          */
2899         while (rtnh_ok(rtnh, remaining)) {
2900                 memcpy(&r_cfg, cfg, sizeof(*cfg));
2901                 if (rtnh->rtnh_ifindex)
2902                         r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2903
2904                 attrlen = rtnh_attrlen(rtnh);
2905                 if (attrlen > 0) {
2906                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2907
2908                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2909                         if (nla) {
2910                                 r_cfg.fc_gateway = nla_get_in6_addr(nla);
2911                                 r_cfg.fc_flags |= RTF_GATEWAY;
2912                         }
2913                         r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
2914                         nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
2915                         if (nla)
2916                                 r_cfg.fc_encap_type = nla_get_u16(nla);
2917                 }
2918
2919                 rt = ip6_route_info_create(&r_cfg);
2920                 if (IS_ERR(rt)) {
2921                         err = PTR_ERR(rt);
2922                         rt = NULL;
2923                         goto cleanup;
2924                 }
2925
2926                 err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
2927                 if (err) {
2928                         dst_free(&rt->dst);
2929                         goto cleanup;
2930                 }
2931
2932                 rtnh = rtnh_next(rtnh, &remaining);
2933         }
2934
2935         err_nh = NULL;
2936         list_for_each_entry(nh, &rt6_nh_list, next) {
2937                 err = __ip6_ins_rt(nh->rt6_info, &cfg->fc_nlinfo, &nh->mxc);
2938                 /* nh->rt6_info is used or freed at this point, reset to NULL*/
2939                 nh->rt6_info = NULL;
2940                 if (err) {
2941                         if (replace && nhn)
2942                                 ip6_print_replace_route_err(&rt6_nh_list);
2943                         err_nh = nh;
2944                         goto add_errout;
2945                 }
2946
2947                 /* Because each route is added like a single route we remove
2948                  * these flags after the first nexthop: if there is a collision,
2949                  * we have already failed to add the first nexthop:
2950                  * fib6_add_rt2node() has rejected it; when replacing, old
2951                  * nexthops have been replaced by first new, the rest should
2952                  * be added to it.
2953                  */
2954                 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
2955                                                      NLM_F_REPLACE);
2956                 nhn++;
2957         }
2958
2959         goto cleanup;
2960
2961 add_errout:
2962         /* Delete routes that were already added */
2963         list_for_each_entry(nh, &rt6_nh_list, next) {
2964                 if (err_nh == nh)
2965                         break;
2966                 ip6_route_del(&nh->r_cfg);
2967         }
2968
2969 cleanup:
2970         list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
2971                 if (nh->rt6_info)
2972                         dst_free(&nh->rt6_info->dst);
2973                 kfree(nh->mxc.mx);
2974                 list_del(&nh->next);
2975                 kfree(nh);
2976         }
2977
2978         return err;
2979 }
2980
2981 static int ip6_route_multipath_del(struct fib6_config *cfg)
2982 {
2983         struct fib6_config r_cfg;
2984         struct rtnexthop *rtnh;
2985         int remaining;
2986         int attrlen;
2987         int err = 1, last_err = 0;
2988
2989         remaining = cfg->fc_mp_len;
2990         rtnh = (struct rtnexthop *)cfg->fc_mp;
2991
2992         /* Parse a Multipath Entry */
2993         while (rtnh_ok(rtnh, remaining)) {
2994                 memcpy(&r_cfg, cfg, sizeof(*cfg));
2995                 if (rtnh->rtnh_ifindex)
2996                         r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2997
2998                 attrlen = rtnh_attrlen(rtnh);
2999                 if (attrlen > 0) {
3000                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3001
3002                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3003                         if (nla) {
3004                                 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
3005                                 r_cfg.fc_flags |= RTF_GATEWAY;
3006                         }
3007                 }
3008                 err = ip6_route_del(&r_cfg);
3009                 if (err)
3010                         last_err = err;
3011
3012                 rtnh = rtnh_next(rtnh, &remaining);
3013         }
3014
3015         return last_err;
3016 }
3017
3018 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
3019 {
3020         struct fib6_config cfg;
3021         int err;
3022
3023         err = rtm_to_fib6_config(skb, nlh, &cfg);
3024         if (err < 0)
3025                 return err;
3026
3027         if (cfg.fc_mp)
3028                 return ip6_route_multipath_del(&cfg);
3029         else
3030                 return ip6_route_del(&cfg);
3031 }
3032
3033 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
3034 {
3035         struct fib6_config cfg;
3036         int err;
3037
3038         err = rtm_to_fib6_config(skb, nlh, &cfg);
3039         if (err < 0)
3040                 return err;
3041
3042         if (cfg.fc_mp)
3043                 return ip6_route_multipath_add(&cfg);
3044         else
3045                 return ip6_route_add(&cfg);
3046 }
3047
3048 static inline size_t rt6_nlmsg_size(struct rt6_info *rt)
3049 {
3050         return NLMSG_ALIGN(sizeof(struct rtmsg))
3051                + nla_total_size(16) /* RTA_SRC */
3052                + nla_total_size(16) /* RTA_DST */
3053                + nla_total_size(16) /* RTA_GATEWAY */
3054                + nla_total_size(16) /* RTA_PREFSRC */
3055                + nla_total_size(4) /* RTA_TABLE */
3056                + nla_total_size(4) /* RTA_IIF */
3057                + nla_total_size(4) /* RTA_OIF */
3058                + nla_total_size(4) /* RTA_PRIORITY */
3059                + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
3060                + nla_total_size(sizeof(struct rta_cacheinfo))
3061                + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
3062                + nla_total_size(1) /* RTA_PREF */
3063                + lwtunnel_get_encap_size(rt->dst.lwtstate);
3064 }
3065
3066 static int rt6_fill_node(struct net *net,
3067                          struct sk_buff *skb, struct rt6_info *rt,
3068                          struct in6_addr *dst, struct in6_addr *src,
3069                          int iif, int type, u32 portid, u32 seq,
3070                          int prefix, int nowait, unsigned int flags)
3071 {
3072         u32 metrics[RTAX_MAX];
3073         struct rtmsg *rtm;
3074         struct nlmsghdr *nlh;
3075         long expires;
3076         u32 table;
3077
3078         if (prefix) {   /* user wants prefix routes only */
3079                 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
3080                         /* success since this is not a prefix route */
3081                         return 1;
3082                 }
3083         }
3084
3085         nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
3086         if (!nlh)
3087                 return -EMSGSIZE;
3088
3089         rtm = nlmsg_data(nlh);
3090         rtm->rtm_family = AF_INET6;
3091         rtm->rtm_dst_len = rt->rt6i_dst.plen;
3092         rtm->rtm_src_len = rt->rt6i_src.plen;
3093         rtm->rtm_tos = 0;
3094         if (rt->rt6i_table)
3095                 table = rt->rt6i_table->tb6_id;
3096         else
3097                 table = RT6_TABLE_UNSPEC;
3098         rtm->rtm_table = table;
3099         if (nla_put_u32(skb, RTA_TABLE, table))
3100                 goto nla_put_failure;
3101         if (rt->rt6i_flags & RTF_REJECT) {
3102                 switch (rt->dst.error) {
3103                 case -EINVAL:
3104                         rtm->rtm_type = RTN_BLACKHOLE;
3105                         break;
3106                 case -EACCES:
3107                         rtm->rtm_type = RTN_PROHIBIT;
3108                         break;
3109                 case -EAGAIN:
3110                         rtm->rtm_type = RTN_THROW;
3111                         break;
3112                 default:
3113                         rtm->rtm_type = RTN_UNREACHABLE;
3114                         break;
3115                 }
3116         }
3117         else if (rt->rt6i_flags & RTF_LOCAL)
3118                 rtm->rtm_type = RTN_LOCAL;
3119         else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
3120                 rtm->rtm_type = RTN_LOCAL;
3121         else
3122                 rtm->rtm_type = RTN_UNICAST;
3123         rtm->rtm_flags = 0;
3124         if (!netif_carrier_ok(rt->dst.dev)) {
3125                 rtm->rtm_flags |= RTNH_F_LINKDOWN;
3126                 if (rt->rt6i_idev->cnf.ignore_routes_with_linkdown)
3127                         rtm->rtm_flags |= RTNH_F_DEAD;
3128         }
3129         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
3130         rtm->rtm_protocol = rt->rt6i_protocol;
3131         if (rt->rt6i_flags & RTF_DYNAMIC)
3132                 rtm->rtm_protocol = RTPROT_REDIRECT;
3133         else if (rt->rt6i_flags & RTF_ADDRCONF) {
3134                 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
3135                         rtm->rtm_protocol = RTPROT_RA;
3136                 else
3137                         rtm->rtm_protocol = RTPROT_KERNEL;
3138         }
3139
3140         if (rt->rt6i_flags & RTF_CACHE)
3141                 rtm->rtm_flags |= RTM_F_CLONED;
3142
3143         if (dst) {
3144                 if (nla_put_in6_addr(skb, RTA_DST, dst))
3145                         goto nla_put_failure;
3146                 rtm->rtm_dst_len = 128;
3147         } else if (rtm->rtm_dst_len)
3148                 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
3149                         goto nla_put_failure;
3150 #ifdef CONFIG_IPV6_SUBTREES
3151         if (src) {
3152                 if (nla_put_in6_addr(skb, RTA_SRC, src))
3153                         goto nla_put_failure;
3154                 rtm->rtm_src_len = 128;
3155         } else if (rtm->rtm_src_len &&
3156                    nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
3157                 goto nla_put_failure;
3158 #endif
3159         if (iif) {
3160 #ifdef CONFIG_IPV6_MROUTE
3161                 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
3162                         int err = ip6mr_get_route(net, skb, rtm, nowait);
3163                         if (err <= 0) {
3164                                 if (!nowait) {
3165                                         if (err == 0)
3166                                                 return 0;
3167                                         goto nla_put_failure;
3168                                 } else {
3169                                         if (err == -EMSGSIZE)
3170                                                 goto nla_put_failure;
3171                                 }
3172                         }
3173                 } else
3174 #endif
3175                         if (nla_put_u32(skb, RTA_IIF, iif))
3176                                 goto nla_put_failure;
3177         } else if (dst) {
3178                 struct in6_addr saddr_buf;
3179                 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
3180                     nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
3181                         goto nla_put_failure;
3182         }
3183
3184         if (rt->rt6i_prefsrc.plen) {
3185                 struct in6_addr saddr_buf;
3186                 saddr_buf = rt->rt6i_prefsrc.addr;
3187                 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
3188                         goto nla_put_failure;
3189         }
3190
3191         memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
3192         if (rt->rt6i_pmtu)
3193                 metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
3194         if (rtnetlink_put_metrics(skb, metrics) < 0)
3195                 goto nla_put_failure;
3196
3197         if (rt->rt6i_flags & RTF_GATEWAY) {
3198                 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
3199                         goto nla_put_failure;
3200         }
3201
3202         if (rt->dst.dev &&
3203             nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
3204                 goto nla_put_failure;
3205         if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
3206                 goto nla_put_failure;
3207
3208         expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
3209
3210         if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
3211                 goto nla_put_failure;
3212
3213         if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
3214                 goto nla_put_failure;
3215
3216         lwtunnel_fill_encap(skb, rt->dst.lwtstate);
3217
3218         nlmsg_end(skb, nlh);
3219         return 0;
3220
3221 nla_put_failure:
3222         nlmsg_cancel(skb, nlh);
3223         return -EMSGSIZE;
3224 }
3225
3226 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
3227 {
3228         struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
3229         int prefix;
3230
3231         if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
3232                 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
3233                 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
3234         } else
3235                 prefix = 0;
3236
3237         return rt6_fill_node(arg->net,
3238                      arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
3239                      NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
3240                      prefix, 0, NLM_F_MULTI);
3241 }
3242
3243 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
3244 {
3245         struct net *net = sock_net(in_skb->sk);
3246         struct nlattr *tb[RTA_MAX+1];
3247         struct rt6_info *rt;
3248         struct sk_buff *skb;
3249         struct rtmsg *rtm;
3250         struct flowi6 fl6;
3251         int err, iif = 0, oif = 0;
3252
3253         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
3254         if (err < 0)
3255                 goto errout;
3256
3257         err = -EINVAL;
3258         memset(&fl6, 0, sizeof(fl6));
3259
3260         if (tb[RTA_SRC]) {
3261                 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
3262                         goto errout;
3263
3264                 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
3265         }
3266
3267         if (tb[RTA_DST]) {
3268                 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
3269                         goto errout;
3270
3271                 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
3272         }
3273
3274         if (tb[RTA_IIF])
3275                 iif = nla_get_u32(tb[RTA_IIF]);
3276
3277         if (tb[RTA_OIF])
3278                 oif = nla_get_u32(tb[RTA_OIF]);
3279
3280         if (tb[RTA_MARK])
3281                 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
3282
3283         if (iif) {
3284                 struct net_device *dev;
3285                 int flags = 0;
3286
3287                 dev = __dev_get_by_index(net, iif);
3288                 if (!dev) {
3289                         err = -ENODEV;
3290                         goto errout;
3291                 }
3292
3293                 fl6.flowi6_iif = iif;
3294
3295                 if (!ipv6_addr_any(&fl6.saddr))
3296                         flags |= RT6_LOOKUP_F_HAS_SADDR;
3297
3298                 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
3299                                                                flags);
3300         } else {
3301                 fl6.flowi6_oif = oif;
3302
3303                 if (netif_index_is_l3_master(net, oif)) {
3304                         fl6.flowi6_flags = FLOWI_FLAG_L3MDEV_SRC |
3305                                            FLOWI_FLAG_SKIP_NH_OIF;
3306                 }
3307
3308                 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
3309         }
3310
3311         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
3312         if (!skb) {
3313                 ip6_rt_put(rt);
3314                 err = -ENOBUFS;
3315                 goto errout;
3316         }
3317
3318         /* Reserve room for dummy headers, this skb can pass
3319            through good chunk of routing engine.
3320          */
3321         skb_reset_mac_header(skb);
3322         skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
3323
3324         skb_dst_set(skb, &rt->dst);
3325
3326         err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
3327                             RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
3328                             nlh->nlmsg_seq, 0, 0, 0);
3329         if (err < 0) {
3330                 kfree_skb(skb);
3331                 goto errout;
3332         }
3333
3334         err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
3335 errout:
3336         return err;
3337 }
3338
3339 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info,
3340                      unsigned int nlm_flags)
3341 {
3342         struct sk_buff *skb;
3343         struct net *net = info->nl_net;
3344         u32 seq;
3345         int err;
3346
3347         err = -ENOBUFS;
3348         seq = info->nlh ? info->nlh->nlmsg_seq : 0;
3349
3350         skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
3351         if (!skb)
3352                 goto errout;
3353
3354         err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
3355                                 event, info->portid, seq, 0, 0, nlm_flags);
3356         if (err < 0) {
3357                 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
3358                 WARN_ON(err == -EMSGSIZE);
3359                 kfree_skb(skb);
3360                 goto errout;
3361         }
3362         rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
3363                     info->nlh, gfp_any());
3364         return;
3365 errout:
3366         if (err < 0)
3367                 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
3368 }
3369
3370 static int ip6_route_dev_notify(struct notifier_block *this,
3371                                 unsigned long event, void *ptr)
3372 {
3373         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3374         struct net *net = dev_net(dev);
3375
3376         if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
3377                 net->ipv6.ip6_null_entry->dst.dev = dev;
3378                 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
3379 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3380                 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
3381                 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
3382                 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
3383                 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
3384 #endif
3385         }
3386
3387         return NOTIFY_OK;
3388 }
3389
3390 /*
3391  *      /proc
3392  */
3393
3394 #ifdef CONFIG_PROC_FS
3395
3396 static const struct file_operations ipv6_route_proc_fops = {
3397         .owner          = THIS_MODULE,
3398         .open           = ipv6_route_open,
3399         .read           = seq_read,
3400         .llseek         = seq_lseek,
3401         .release        = seq_release_net,
3402 };
3403
3404 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
3405 {
3406         struct net *net = (struct net *)seq->private;
3407         seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
3408                    net->ipv6.rt6_stats->fib_nodes,
3409                    net->ipv6.rt6_stats->fib_route_nodes,
3410                    net->ipv6.rt6_stats->fib_rt_alloc,
3411                    net->ipv6.rt6_stats->fib_rt_entries,
3412                    net->ipv6.rt6_stats->fib_rt_cache,
3413                    dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
3414                    net->ipv6.rt6_stats->fib_discarded_routes);
3415
3416         return 0;
3417 }
3418
3419 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
3420 {
3421         return single_open_net(inode, file, rt6_stats_seq_show);
3422 }
3423
3424 static const struct file_operations rt6_stats_seq_fops = {
3425         .owner   = THIS_MODULE,
3426         .open    = rt6_stats_seq_open,
3427         .read    = seq_read,
3428         .llseek  = seq_lseek,
3429         .release = single_release_net,
3430 };
3431 #endif  /* CONFIG_PROC_FS */
3432
3433 #ifdef CONFIG_SYSCTL
3434
3435 static
3436 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
3437                               void __user *buffer, size_t *lenp, loff_t *ppos)
3438 {
3439         struct net *net;
3440         int delay;
3441         if (!write)
3442                 return -EINVAL;
3443
3444         net = (struct net *)ctl->extra1;
3445         delay = net->ipv6.sysctl.flush_delay;
3446         proc_dointvec(ctl, write, buffer, lenp, ppos);
3447         fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
3448         return 0;
3449 }
3450
3451 struct ctl_table ipv6_route_table_template[] = {
3452         {
3453                 .procname       =       "flush",
3454                 .data           =       &init_net.ipv6.sysctl.flush_delay,
3455                 .maxlen         =       sizeof(int),
3456                 .mode           =       0200,
3457                 .proc_handler   =       ipv6_sysctl_rtcache_flush
3458         },
3459         {
3460                 .procname       =       "gc_thresh",
3461                 .data           =       &ip6_dst_ops_template.gc_thresh,
3462                 .maxlen         =       sizeof(int),
3463                 .mode           =       0644,
3464                 .proc_handler   =       proc_dointvec,
3465         },
3466         {
3467                 .procname       =       "max_size",
3468                 .data           =       &init_net.ipv6.sysctl.ip6_rt_max_size,
3469                 .maxlen         =       sizeof(int),
3470                 .mode           =       0644,
3471                 .proc_handler   =       proc_dointvec,
3472         },
3473         {
3474                 .procname       =       "gc_min_interval",
3475                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3476                 .maxlen         =       sizeof(int),
3477                 .mode           =       0644,
3478                 .proc_handler   =       proc_dointvec_jiffies,
3479         },
3480         {
3481                 .procname       =       "gc_timeout",
3482                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
3483                 .maxlen         =       sizeof(int),
3484                 .mode           =       0644,
3485                 .proc_handler   =       proc_dointvec_jiffies,
3486         },
3487         {
3488                 .procname       =       "gc_interval",
3489                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_interval,
3490                 .maxlen         =       sizeof(int),
3491                 .mode           =       0644,
3492                 .proc_handler   =       proc_dointvec_jiffies,
3493         },
3494         {
3495                 .procname       =       "gc_elasticity",
3496                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
3497                 .maxlen         =       sizeof(int),
3498                 .mode           =       0644,
3499                 .proc_handler   =       proc_dointvec,
3500         },
3501         {
3502                 .procname       =       "mtu_expires",
3503                 .data           =       &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
3504                 .maxlen         =       sizeof(int),
3505                 .mode           =       0644,
3506                 .proc_handler   =       proc_dointvec_jiffies,
3507         },
3508         {
3509                 .procname       =       "min_adv_mss",
3510                 .data           =       &init_net.ipv6.sysctl.ip6_rt_min_advmss,
3511                 .maxlen         =       sizeof(int),
3512                 .mode           =       0644,
3513                 .proc_handler   =       proc_dointvec,
3514         },
3515         {
3516                 .procname       =       "gc_min_interval_ms",
3517                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3518                 .maxlen         =       sizeof(int),
3519                 .mode           =       0644,
3520                 .proc_handler   =       proc_dointvec_ms_jiffies,
3521         },
3522         { }
3523 };
3524
3525 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
3526 {
3527         struct ctl_table *table;
3528
3529         table = kmemdup(ipv6_route_table_template,
3530                         sizeof(ipv6_route_table_template),
3531                         GFP_KERNEL);
3532
3533         if (table) {
3534                 table[0].data = &net->ipv6.sysctl.flush_delay;
3535                 table[0].extra1 = net;
3536                 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
3537                 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3538                 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3539                 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3540                 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3541                 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3542                 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3543                 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
3544                 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3545
3546                 /* Don't export sysctls to unprivileged users */
3547                 if (net->user_ns != &init_user_ns)
3548                         table[0].procname = NULL;
3549         }
3550
3551         return table;
3552 }
3553 #endif
3554
3555 static int __net_init ip6_route_net_init(struct net *net)
3556 {
3557         int ret = -ENOMEM;
3558
3559         memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3560                sizeof(net->ipv6.ip6_dst_ops));
3561
3562         if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3563                 goto out_ip6_dst_ops;
3564
3565         net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3566                                            sizeof(*net->ipv6.ip6_null_entry),
3567                                            GFP_KERNEL);
3568         if (!net->ipv6.ip6_null_entry)
3569                 goto out_ip6_dst_entries;
3570         net->ipv6.ip6_null_entry->dst.path =
3571                 (struct dst_entry *)net->ipv6.ip6_null_entry;
3572         net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3573         dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3574                          ip6_template_metrics, true);
3575
3576 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3577         net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3578                                                sizeof(*net->ipv6.ip6_prohibit_entry),
3579                                                GFP_KERNEL);
3580         if (!net->ipv6.ip6_prohibit_entry)
3581                 goto out_ip6_null_entry;
3582         net->ipv6.ip6_prohibit_entry->dst.path =
3583                 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3584         net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3585         dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3586                          ip6_template_metrics, true);
3587
3588         net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3589                                                sizeof(*net->ipv6.ip6_blk_hole_entry),
3590                                                GFP_KERNEL);
3591         if (!net->ipv6.ip6_blk_hole_entry)
3592                 goto out_ip6_prohibit_entry;
3593         net->ipv6.ip6_blk_hole_entry->dst.path =
3594                 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3595         net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3596         dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3597                          ip6_template_metrics, true);
3598 #endif
3599
3600         net->ipv6.sysctl.flush_delay = 0;
3601         net->ipv6.sysctl.ip6_rt_max_size = 4096;
3602         net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3603         net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3604         net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3605         net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3606         net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3607         net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3608
3609         net->ipv6.ip6_rt_gc_expire = 30*HZ;
3610
3611         ret = 0;
3612 out:
3613         return ret;
3614
3615 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3616 out_ip6_prohibit_entry:
3617         kfree(net->ipv6.ip6_prohibit_entry);
3618 out_ip6_null_entry:
3619         kfree(net->ipv6.ip6_null_entry);
3620 #endif
3621 out_ip6_dst_entries:
3622         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3623 out_ip6_dst_ops:
3624         goto out;
3625 }
3626
3627 static void __net_exit ip6_route_net_exit(struct net *net)
3628 {
3629         kfree(net->ipv6.ip6_null_entry);
3630 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3631         kfree(net->ipv6.ip6_prohibit_entry);
3632         kfree(net->ipv6.ip6_blk_hole_entry);
3633 #endif
3634         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3635 }
3636
3637 static int __net_init ip6_route_net_init_late(struct net *net)
3638 {
3639 #ifdef CONFIG_PROC_FS
3640         proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3641         proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3642 #endif
3643         return 0;
3644 }
3645
3646 static void __net_exit ip6_route_net_exit_late(struct net *net)
3647 {
3648 #ifdef CONFIG_PROC_FS
3649         remove_proc_entry("ipv6_route", net->proc_net);
3650         remove_proc_entry("rt6_stats", net->proc_net);
3651 #endif
3652 }
3653
3654 static struct pernet_operations ip6_route_net_ops = {
3655         .init = ip6_route_net_init,
3656         .exit = ip6_route_net_exit,
3657 };
3658
3659 static int __net_init ipv6_inetpeer_init(struct net *net)
3660 {
3661         struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3662
3663         if (!bp)
3664                 return -ENOMEM;
3665         inet_peer_base_init(bp);
3666         net->ipv6.peers = bp;
3667         return 0;
3668 }
3669
3670 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3671 {
3672         struct inet_peer_base *bp = net->ipv6.peers;
3673
3674         net->ipv6.peers = NULL;
3675         inetpeer_invalidate_tree(bp);
3676         kfree(bp);
3677 }
3678
3679 static struct pernet_operations ipv6_inetpeer_ops = {
3680         .init   =       ipv6_inetpeer_init,
3681         .exit   =       ipv6_inetpeer_exit,
3682 };
3683
3684 static struct pernet_operations ip6_route_net_late_ops = {
3685         .init = ip6_route_net_init_late,
3686         .exit = ip6_route_net_exit_late,
3687 };
3688
3689 static struct notifier_block ip6_route_dev_notifier = {
3690         .notifier_call = ip6_route_dev_notify,
3691         .priority = 0,
3692 };
3693
3694 int __init ip6_route_init(void)
3695 {
3696         int ret;
3697         int cpu;
3698
3699         ret = -ENOMEM;
3700         ip6_dst_ops_template.kmem_cachep =
3701                 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3702                                   SLAB_HWCACHE_ALIGN, NULL);
3703         if (!ip6_dst_ops_template.kmem_cachep)
3704                 goto out;
3705
3706         ret = dst_entries_init(&ip6_dst_blackhole_ops);
3707         if (ret)
3708                 goto out_kmem_cache;
3709
3710         ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3711         if (ret)
3712                 goto out_dst_entries;
3713
3714         ret = register_pernet_subsys(&ip6_route_net_ops);
3715         if (ret)
3716                 goto out_register_inetpeer;
3717
3718         ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3719
3720         /* Registering of the loopback is done before this portion of code,
3721          * the loopback reference in rt6_info will not be taken, do it
3722          * manually for init_net */
3723         init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3724         init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3725   #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3726         init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3727         init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3728         init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3729         init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3730   #endif
3731         ret = fib6_init();
3732         if (ret)
3733                 goto out_register_subsys;
3734
3735         ret = xfrm6_init();
3736         if (ret)
3737                 goto out_fib6_init;
3738
3739         ret = fib6_rules_init();
3740         if (ret)
3741                 goto xfrm6_init;
3742
3743         ret = register_pernet_subsys(&ip6_route_net_late_ops);
3744         if (ret)
3745                 goto fib6_rules_init;
3746
3747         ret = -ENOBUFS;
3748         if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3749             __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3750             __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3751                 goto out_register_late_subsys;
3752
3753         ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3754         if (ret)
3755                 goto out_register_late_subsys;
3756
3757         for_each_possible_cpu(cpu) {
3758                 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
3759
3760                 INIT_LIST_HEAD(&ul->head);
3761                 spin_lock_init(&ul->lock);
3762         }
3763
3764 out:
3765         return ret;
3766
3767 out_register_late_subsys:
3768         unregister_pernet_subsys(&ip6_route_net_late_ops);
3769 fib6_rules_init:
3770         fib6_rules_cleanup();
3771 xfrm6_init:
3772         xfrm6_fini();
3773 out_fib6_init:
3774         fib6_gc_cleanup();
3775 out_register_subsys:
3776         unregister_pernet_subsys(&ip6_route_net_ops);
3777 out_register_inetpeer:
3778         unregister_pernet_subsys(&ipv6_inetpeer_ops);
3779 out_dst_entries:
3780         dst_entries_destroy(&ip6_dst_blackhole_ops);
3781 out_kmem_cache:
3782         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3783         goto out;
3784 }
3785
3786 void ip6_route_cleanup(void)
3787 {
3788         unregister_netdevice_notifier(&ip6_route_dev_notifier);
3789         unregister_pernet_subsys(&ip6_route_net_late_ops);
3790         fib6_rules_cleanup();
3791         xfrm6_fini();
3792         fib6_gc_cleanup();
3793         unregister_pernet_subsys(&ipv6_inetpeer_ops);
3794         unregister_pernet_subsys(&ip6_route_net_ops);
3795         dst_entries_destroy(&ip6_dst_blackhole_ops);
3796         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3797 }