net/ipv6/route.c

   1 /*
   2  *      Linux INET6 implementation
   3  *      FIB front-end.
   4  *
   5  *      Authors:
   6  *      Pedro Roque             <[email protected]>
   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 <linux/jhash.h>
  48 #include <net/net_namespace.h>
  49 #include <net/snmp.h>
  50 #include <net/ipv6.h>
  51 #include <net/ip6_fib.h>
  52 #include <net/ip6_route.h>
  53 #include <net/ndisc.h>
  54 #include <net/addrconf.h>
  55 #include <net/tcp.h>
  56 #include <linux/rtnetlink.h>
  57 #include <net/dst.h>
  58 #include <net/dst_metadata.h>
  59 #include <net/xfrm.h>
  60 #include <net/netevent.h>
  61 #include <net/netlink.h>
  62 #include <net/rtnh.h>
  63 #include <net/lwtunnel.h>
  64 #include <net/ip_tunnels.h>
  65 #include <net/l3mdev.h>
  66 #include <net/ip.h>
  67 #include <linux/uaccess.h>
  68
  69 #ifdef CONFIG_SYSCTL
  70 #include <linux/sysctl.h>
  71 #endif
  72
  73 static int ip6_rt_type_to_error(u8 fib6_type);
  74
  75 #define CREATE_TRACE_POINTS
  76 #include <trace/events/fib6.h>
  77 EXPORT_TRACEPOINT_SYMBOL_GPL(fib6_table_lookup);
  78 #undef CREATE_TRACE_POINTS
  79
  80 enum rt6_nud_state {
  81         RT6_NUD_FAIL_HARD = -3,
  82         RT6_NUD_FAIL_PROBE = -2,
  83         RT6_NUD_FAIL_DO_RR = -1,
  84         RT6_NUD_SUCCEED = 1
  85 };
  86
  87 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
  88 static unsigned int      ip6_default_advmss(const struct dst_entry *dst);
  89 static unsigned int      ip6_mtu(const struct dst_entry *dst);
  90 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
  91 static void             ip6_dst_destroy(struct dst_entry *);
  92 static void             ip6_dst_ifdown(struct dst_entry *,
  93                                        struct net_device *dev, int how);
  94 static int               ip6_dst_gc(struct dst_ops *ops);
  95
  96 static int              ip6_pkt_discard(struct sk_buff *skb);
  97 static int              ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb);
  98 static int              ip6_pkt_prohibit(struct sk_buff *skb);
  99 static int              ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb);
 100 static void             ip6_link_failure(struct sk_buff *skb);
 101 static void             ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
 102                                            struct sk_buff *skb, u32 mtu);
 103 static void             rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
 104                                         struct sk_buff *skb);
 105 static int rt6_score_route(const struct fib6_nh *nh, u32 fib6_flags, int oif,
 106                            int strict);
 107 static size_t rt6_nlmsg_size(struct fib6_info *rt);
 108 static int rt6_fill_node(struct net *net, struct sk_buff *skb,
 109                          struct fib6_info *rt, struct dst_entry *dst,
 110                          struct in6_addr *dest, struct in6_addr *src,
 111                          int iif, int type, u32 portid, u32 seq,
 112                          unsigned int flags);
 113 static struct rt6_info *rt6_find_cached_rt(const struct fib6_result *res,
 114                                            const struct in6_addr *daddr,
 115                                            const struct in6_addr *saddr);
 116
 117 #ifdef CONFIG_IPV6_ROUTE_INFO
 118 static struct fib6_info *rt6_add_route_info(struct net *net,
 119                                            const struct in6_addr *prefix, int prefixlen,
 120                                            const struct in6_addr *gwaddr,
 121                                            struct net_device *dev,
 122                                            unsigned int pref);
 123 static struct fib6_info *rt6_get_route_info(struct net *net,
 124                                            const struct in6_addr *prefix, int prefixlen,
 125                                            const struct in6_addr *gwaddr,
 126                                            struct net_device *dev);
 127 #endif
 128
 129 struct uncached_list {
 130         spinlock_t              lock;
 131         struct list_head        head;
 132 };
 133
 134 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
 135
 136 void rt6_uncached_list_add(struct rt6_info *rt)
 137 {
 138         struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);
 139
 140         rt->rt6i_uncached_list = ul;
 141
 142         spin_lock_bh(&ul->lock);
 143         list_add_tail(&rt->rt6i_uncached, &ul->head);
 144         spin_unlock_bh(&ul->lock);
 145 }
 146
 147 void rt6_uncached_list_del(struct rt6_info *rt)
 148 {
 149         if (!list_empty(&rt->rt6i_uncached)) {
 150                 struct uncached_list *ul = rt->rt6i_uncached_list;
 151                 struct net *net = dev_net(rt->dst.dev);
 152
 153                 spin_lock_bh(&ul->lock);
 154                 list_del(&rt->rt6i_uncached);
 155                 atomic_dec(&net->ipv6.rt6_stats->fib_rt_uncache);
 156                 spin_unlock_bh(&ul->lock);
 157         }
 158 }
 159
 160 static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
 161 {
 162         struct net_device *loopback_dev = net->loopback_dev;
 163         int cpu;
 164
 165         if (dev == loopback_dev)
 166                 return;
 167
 168         for_each_possible_cpu(cpu) {
 169                 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
 170                 struct rt6_info *rt;
 171
 172                 spin_lock_bh(&ul->lock);
 173                 list_for_each_entry(rt, &ul->head, rt6i_uncached) {
 174                         struct inet6_dev *rt_idev = rt->rt6i_idev;
 175                         struct net_device *rt_dev = rt->dst.dev;
 176
 177                         if (rt_idev->dev == dev) {
 178                                 rt->rt6i_idev = in6_dev_get(loopback_dev);
 179                                 in6_dev_put(rt_idev);
 180                         }
 181
 182                         if (rt_dev == dev) {
 183                                 rt->dst.dev = loopback_dev;
 184                                 dev_hold(rt->dst.dev);
 185                                 dev_put(rt_dev);
 186                         }
 187                 }
 188                 spin_unlock_bh(&ul->lock);
 189         }
 190 }
 191
 192 static inline const void *choose_neigh_daddr(const struct in6_addr *p,
 193                                              struct sk_buff *skb,
 194                                              const void *daddr)
 195 {
 196         if (!ipv6_addr_any(p))
 197                 return (const void *) p;
 198         else if (skb)
 199                 return &ipv6_hdr(skb)->daddr;
 200         return daddr;
 201 }
 202
 203 struct neighbour *ip6_neigh_lookup(const struct in6_addr *gw,
 204                                    struct net_device *dev,
 205                                    struct sk_buff *skb,
 206                                    const void *daddr)
 207 {
 208         struct neighbour *n;
 209
 210         daddr = choose_neigh_daddr(gw, skb, daddr);
 211         n = __ipv6_neigh_lookup(dev, daddr);
 212         if (n)
 213                 return n;
 214
 215         n = neigh_create(&nd_tbl, daddr, dev);
 216         return IS_ERR(n) ? NULL : n;
 217 }
 218
 219 static struct neighbour *ip6_dst_neigh_lookup(const struct dst_entry *dst,
 220                                               struct sk_buff *skb,
 221                                               const void *daddr)
 222 {
 223         const struct rt6_info *rt = container_of(dst, struct rt6_info, dst);
 224
 225         return ip6_neigh_lookup(&rt->rt6i_gateway, dst->dev, skb, daddr);
 226 }
 227
 228 static void ip6_confirm_neigh(const struct dst_entry *dst, const void *daddr)
 229 {
 230         struct net_device *dev = dst->dev;
 231         struct rt6_info *rt = (struct rt6_info *)dst;
 232
 233         daddr = choose_neigh_daddr(&rt->rt6i_gateway, NULL, daddr);
 234         if (!daddr)
 235                 return;
 236         if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
 237                 return;
 238         if (ipv6_addr_is_multicast((const struct in6_addr *)daddr))
 239                 return;
 240         __ipv6_confirm_neigh(dev, daddr);
 241 }
 242
 243 static struct dst_ops ip6_dst_ops_template = {
 244         .family                 =       AF_INET6,
 245         .gc                     =       ip6_dst_gc,
 246         .gc_thresh              =       1024,
 247         .check                  =       ip6_dst_check,
 248         .default_advmss         =       ip6_default_advmss,
 249         .mtu                    =       ip6_mtu,
 250         .cow_metrics            =       dst_cow_metrics_generic,
 251         .destroy                =       ip6_dst_destroy,
 252         .ifdown                 =       ip6_dst_ifdown,
 253         .negative_advice        =       ip6_negative_advice,
 254         .link_failure           =       ip6_link_failure,
 255         .update_pmtu            =       ip6_rt_update_pmtu,
 256         .redirect               =       rt6_do_redirect,
 257         .local_out              =       __ip6_local_out,
 258         .neigh_lookup           =       ip6_dst_neigh_lookup,
 259         .confirm_neigh          =       ip6_confirm_neigh,
 260 };
 261
 262 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
 263 {
 264         unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
 265
 266         return mtu ? : dst->dev->mtu;
 267 }
 268
 269 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
 270                                          struct sk_buff *skb, u32 mtu)
 271 {
 272 }
 273
 274 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
 275                                       struct sk_buff *skb)
 276 {
 277 }
 278
 279 static struct dst_ops ip6_dst_blackhole_ops = {
 280         .family                 =       AF_INET6,
 281         .destroy                =       ip6_dst_destroy,
 282         .check                  =       ip6_dst_check,
 283         .mtu                    =       ip6_blackhole_mtu,
 284         .default_advmss         =       ip6_default_advmss,
 285         .update_pmtu            =       ip6_rt_blackhole_update_pmtu,
 286         .redirect               =       ip6_rt_blackhole_redirect,
 287         .cow_metrics            =       dst_cow_metrics_generic,
 288         .neigh_lookup           =       ip6_dst_neigh_lookup,
 289 };
 290
 291 static const u32 ip6_template_metrics[RTAX_MAX] = {
 292         [RTAX_HOPLIMIT - 1] = 0,
 293 };
 294
 295 static const struct fib6_info fib6_null_entry_template = {
 296         .fib6_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 297         .fib6_protocol  = RTPROT_KERNEL,
 298         .fib6_metric    = ~(u32)0,
 299         .fib6_ref       = REFCOUNT_INIT(1),
 300         .fib6_type      = RTN_UNREACHABLE,
 301         .fib6_metrics   = (struct dst_metrics *)&dst_default_metrics,
 302 };
 303
 304 static const struct rt6_info ip6_null_entry_template = {
 305         .dst = {
 306                 .__refcnt       = ATOMIC_INIT(1),
 307                 .__use          = 1,
 308                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 309                 .error          = -ENETUNREACH,
 310                 .input          = ip6_pkt_discard,
 311                 .output         = ip6_pkt_discard_out,
 312         },
 313         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 314 };
 315
 316 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 317
 318 static const struct rt6_info ip6_prohibit_entry_template = {
 319         .dst = {
 320                 .__refcnt       = ATOMIC_INIT(1),
 321                 .__use          = 1,
 322                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 323                 .error          = -EACCES,
 324                 .input          = ip6_pkt_prohibit,
 325                 .output         = ip6_pkt_prohibit_out,
 326         },
 327         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 328 };
 329
 330 static const struct rt6_info ip6_blk_hole_entry_template = {
 331         .dst = {
 332                 .__refcnt       = ATOMIC_INIT(1),
 333                 .__use          = 1,
 334                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 335                 .error          = -EINVAL,
 336                 .input          = dst_discard,
 337                 .output         = dst_discard_out,
 338         },
 339         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 340 };
 341
 342 #endif
 343
 344 static void rt6_info_init(struct rt6_info *rt)
 345 {
 346         struct dst_entry *dst = &rt->dst;
 347
 348         memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
 349         INIT_LIST_HEAD(&rt->rt6i_uncached);
 350 }
 351
 352 /* allocate dst with ip6_dst_ops */
 353 struct rt6_info *ip6_dst_alloc(struct net *net, struct net_device *dev,
 354                                int flags)
 355 {
 356         struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
 357                                         1, DST_OBSOLETE_FORCE_CHK, flags);
 358
 359         if (rt) {
 360                 rt6_info_init(rt);
 361                 atomic_inc(&net->ipv6.rt6_stats->fib_rt_alloc);
 362         }
 363
 364         return rt;
 365 }
 366 EXPORT_SYMBOL(ip6_dst_alloc);
 367
 368 static void ip6_dst_destroy(struct dst_entry *dst)
 369 {
 370         struct rt6_info *rt = (struct rt6_info *)dst;
 371         struct fib6_info *from;
 372         struct inet6_dev *idev;
 373
 374         ip_dst_metrics_put(dst);
 375         rt6_uncached_list_del(rt);
 376
 377         idev = rt->rt6i_idev;
 378         if (idev) {
 379                 rt->rt6i_idev = NULL;
 380                 in6_dev_put(idev);
 381         }
 382
 383         from = xchg((__force struct fib6_info **)&rt->from, NULL);
 384         fib6_info_release(from);
 385 }
 386
 387 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
 388                            int how)
 389 {
 390         struct rt6_info *rt = (struct rt6_info *)dst;
 391         struct inet6_dev *idev = rt->rt6i_idev;
 392         struct net_device *loopback_dev =
 393                 dev_net(dev)->loopback_dev;
 394
 395         if (idev && idev->dev != loopback_dev) {
 396                 struct inet6_dev *loopback_idev = in6_dev_get(loopback_dev);
 397                 if (loopback_idev) {
 398                         rt->rt6i_idev = loopback_idev;
 399                         in6_dev_put(idev);
 400                 }
 401         }
 402 }
 403
 404 static bool __rt6_check_expired(const struct rt6_info *rt)
 405 {
 406         if (rt->rt6i_flags & RTF_EXPIRES)
 407                 return time_after(jiffies, rt->dst.expires);
 408         else
 409                 return false;
 410 }
 411
 412 static bool rt6_check_expired(const struct rt6_info *rt)
 413 {
 414         struct fib6_info *from;
 415
 416         from = rcu_dereference(rt->from);
 417
 418         if (rt->rt6i_flags & RTF_EXPIRES) {
 419                 if (time_after(jiffies, rt->dst.expires))
 420                         return true;
 421         } else if (from) {
 422                 return rt->dst.obsolete != DST_OBSOLETE_FORCE_CHK ||
 423                         fib6_check_expired(from);
 424         }
 425         return false;
 426 }
 427
 428 void fib6_select_path(const struct net *net, struct fib6_result *res,
 429                       struct flowi6 *fl6, int oif, bool have_oif_match,
 430                       const struct sk_buff *skb, int strict)
 431 {
 432         struct fib6_info *sibling, *next_sibling;
 433         struct fib6_info *match = res->f6i;
 434
 435         if (!match->fib6_nsiblings || have_oif_match)
 436                 goto out;
 437
 438         /* We might have already computed the hash for ICMPv6 errors. In such
 439          * case it will always be non-zero. Otherwise now is the time to do it.
 440          */
 441         if (!fl6->mp_hash)
 442                 fl6->mp_hash = rt6_multipath_hash(net, fl6, skb, NULL);
 443
 444         if (fl6->mp_hash <= atomic_read(&match->fib6_nh.fib_nh_upper_bound))
 445                 goto out;
 446
 447         list_for_each_entry_safe(sibling, next_sibling, &match->fib6_siblings,
 448                                  fib6_siblings) {
 449                 const struct fib6_nh *nh = &sibling->fib6_nh;
 450                 int nh_upper_bound;
 451
 452                 nh_upper_bound = atomic_read(&nh->fib_nh_upper_bound);
 453                 if (fl6->mp_hash > nh_upper_bound)
 454                         continue;
 455                 if (rt6_score_route(nh, sibling->fib6_flags, oif, strict) < 0)
 456                         break;
 457                 match = sibling;
 458                 break;
 459         }
 460
 461 out:
 462         res->f6i = match;
 463         res->nh = &match->fib6_nh;
 464 }
 465
 466 /*
 467  *      Route lookup. rcu_read_lock() should be held.
 468  */
 469
 470 static bool __rt6_device_match(struct net *net, const struct fib6_nh *nh,
 471                                const struct in6_addr *saddr, int oif, int flags)
 472 {
 473         const struct net_device *dev;
 474
 475         if (nh->fib_nh_flags & RTNH_F_DEAD)
 476                 return false;
 477
 478         dev = nh->fib_nh_dev;
 479         if (oif) {
 480                 if (dev->ifindex == oif)
 481                         return true;
 482         } else {
 483                 if (ipv6_chk_addr(net, saddr, dev,
 484                                   flags & RT6_LOOKUP_F_IFACE))
 485                         return true;
 486         }
 487
 488         return false;
 489 }
 490
 491 static void rt6_device_match(struct net *net, struct fib6_result *res,
 492                              const struct in6_addr *saddr, int oif, int flags)
 493 {
 494         struct fib6_info *f6i = res->f6i;
 495         struct fib6_info *spf6i;
 496         struct fib6_nh *nh;
 497
 498         if (!oif && ipv6_addr_any(saddr)) {
 499                 nh = &f6i->fib6_nh;
 500                 if (!(nh->fib_nh_flags & RTNH_F_DEAD))
 501                         goto out;
 502         }
 503
 504         for (spf6i = f6i; spf6i; spf6i = rcu_dereference(spf6i->fib6_next)) {
 505                 nh = &spf6i->fib6_nh;
 506                 if (__rt6_device_match(net, nh, saddr, oif, flags)) {
 507                         res->f6i = spf6i;
 508                         goto out;
 509                 }
 510         }
 511
 512         if (oif && flags & RT6_LOOKUP_F_IFACE) {
 513                 res->f6i = net->ipv6.fib6_null_entry;
 514                 nh = &res->f6i->fib6_nh;
 515                 goto out;
 516         }
 517
 518         nh = &f6i->fib6_nh;
 519         if (nh->fib_nh_flags & RTNH_F_DEAD) {
 520                 res->f6i = net->ipv6.fib6_null_entry;
 521                 nh = &res->f6i->fib6_nh;
 522         }
 523 out:
 524         res->nh = nh;
 525         res->fib6_type = res->f6i->fib6_type;
 526         res->fib6_flags = res->f6i->fib6_flags;
 527 }
 528
 529 #ifdef CONFIG_IPV6_ROUTER_PREF
 530 struct __rt6_probe_work {
 531         struct work_struct work;
 532         struct in6_addr target;
 533         struct net_device *dev;
 534 };
 535
 536 static void rt6_probe_deferred(struct work_struct *w)
 537 {
 538         struct in6_addr mcaddr;
 539         struct __rt6_probe_work *work =
 540                 container_of(w, struct __rt6_probe_work, work);
 541
 542         addrconf_addr_solict_mult(&work->target, &mcaddr);
 543         ndisc_send_ns(work->dev, &work->target, &mcaddr, NULL, 0);
 544         dev_put(work->dev);
 545         kfree(work);
 546 }
 547
 548 static void rt6_probe(struct fib6_nh *fib6_nh)
 549 {
 550         struct __rt6_probe_work *work = NULL;
 551         const struct in6_addr *nh_gw;
 552         struct neighbour *neigh;
 553         struct net_device *dev;
 554         struct inet6_dev *idev;
 555
 556         /*
 557          * Okay, this does not seem to be appropriate
 558          * for now, however, we need to check if it
 559          * is really so; aka Router Reachability Probing.
 560          *
 561          * Router Reachability Probe MUST be rate-limited
 562          * to no more than one per minute.
 563          */
 564         if (fib6_nh->fib_nh_gw_family)
 565                 return;
 566
 567         nh_gw = &fib6_nh->fib_nh_gw6;
 568         dev = fib6_nh->fib_nh_dev;
 569         rcu_read_lock_bh();
 570         idev = __in6_dev_get(dev);
 571         neigh = __ipv6_neigh_lookup_noref(dev, nh_gw);
 572         if (neigh) {
 573                 if (neigh->nud_state & NUD_VALID)
 574                         goto out;
 575
 576                 write_lock(&neigh->lock);
 577                 if (!(neigh->nud_state & NUD_VALID) &&
 578                     time_after(jiffies,
 579                                neigh->updated + idev->cnf.rtr_probe_interval)) {
 580                         work = kmalloc(sizeof(*work), GFP_ATOMIC);
 581                         if (work)
 582                                 __neigh_set_probe_once(neigh);
 583                 }
 584                 write_unlock(&neigh->lock);
 585         } else if (time_after(jiffies, fib6_nh->last_probe +
 586                                        idev->cnf.rtr_probe_interval)) {
 587                 work = kmalloc(sizeof(*work), GFP_ATOMIC);
 588         }
 589
 590         if (work) {
 591                 fib6_nh->last_probe = jiffies;
 592                 INIT_WORK(&work->work, rt6_probe_deferred);
 593                 work->target = *nh_gw;
 594                 dev_hold(dev);
 595                 work->dev = dev;
 596                 schedule_work(&work->work);
 597         }
 598
 599 out:
 600         rcu_read_unlock_bh();
 601 }
 602 #else
 603 static inline void rt6_probe(struct fib6_nh *fib6_nh)
 604 {
 605 }
 606 #endif
 607
 608 /*
 609  * Default Router Selection (RFC 2461 6.3.6)
 610  */
 611 static enum rt6_nud_state rt6_check_neigh(const struct fib6_nh *fib6_nh)
 612 {
 613         enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
 614         struct neighbour *neigh;
 615
 616         rcu_read_lock_bh();
 617         neigh = __ipv6_neigh_lookup_noref(fib6_nh->fib_nh_dev,
 618                                           &fib6_nh->fib_nh_gw6);
 619         if (neigh) {
 620                 read_lock(&neigh->lock);
 621                 if (neigh->nud_state & NUD_VALID)
 622                         ret = RT6_NUD_SUCCEED;
 623 #ifdef CONFIG_IPV6_ROUTER_PREF
 624                 else if (!(neigh->nud_state & NUD_FAILED))
 625                         ret = RT6_NUD_SUCCEED;
 626                 else
 627                         ret = RT6_NUD_FAIL_PROBE;
 628 #endif
 629                 read_unlock(&neigh->lock);
 630         } else {
 631                 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
 632                       RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
 633         }
 634         rcu_read_unlock_bh();
 635
 636         return ret;
 637 }
 638
 639 static int rt6_score_route(const struct fib6_nh *nh, u32 fib6_flags, int oif,
 640                            int strict)
 641 {
 642         int m = 0;
 643
 644         if (!oif || nh->fib_nh_dev->ifindex == oif)
 645                 m = 2;
 646
 647         if (!m && (strict & RT6_LOOKUP_F_IFACE))
 648                 return RT6_NUD_FAIL_HARD;
 649 #ifdef CONFIG_IPV6_ROUTER_PREF
 650         m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(fib6_flags)) << 2;
 651 #endif
 652         if ((strict & RT6_LOOKUP_F_REACHABLE) &&
 653             !(fib6_flags & RTF_NONEXTHOP) && nh->fib_nh_gw_family) {
 654                 int n = rt6_check_neigh(nh);
 655                 if (n < 0)
 656                         return n;
 657         }
 658         return m;
 659 }
 660
 661 static bool find_match(struct fib6_nh *nh, u32 fib6_flags,
 662                        int oif, int strict, int *mpri, bool *do_rr)
 663 {
 664         bool match_do_rr = false;
 665         bool rc = false;
 666         int m;
 667
 668         if (nh->fib_nh_flags & RTNH_F_DEAD)
 669                 goto out;
 670
 671         if (ip6_ignore_linkdown(nh->fib_nh_dev) &&
 672             nh->fib_nh_flags & RTNH_F_LINKDOWN &&
 673             !(strict & RT6_LOOKUP_F_IGNORE_LINKSTATE))
 674                 goto out;
 675
 676         m = rt6_score_route(nh, fib6_flags, oif, strict);
 677         if (m == RT6_NUD_FAIL_DO_RR) {
 678                 match_do_rr = true;
 679                 m = 0; /* lowest valid score */
 680         } else if (m == RT6_NUD_FAIL_HARD) {
 681                 goto out;
 682         }
 683
 684         if (strict & RT6_LOOKUP_F_REACHABLE)
 685                 rt6_probe(nh);
 686
 687         /* note that m can be RT6_NUD_FAIL_PROBE at this point */
 688         if (m > *mpri) {
 689                 *do_rr = match_do_rr;
 690                 *mpri = m;
 691                 rc = true;
 692         }
 693 out:
 694         return rc;
 695 }
 696
 697 static void __find_rr_leaf(struct fib6_info *f6i_start,
 698                            struct fib6_info *nomatch, u32 metric,
 699                            struct fib6_result *res, struct fib6_info **cont,
 700                            int oif, int strict, bool *do_rr, int *mpri)
 701 {
 702         struct fib6_info *f6i;
 703
 704         for (f6i = f6i_start;
 705              f6i && f6i != nomatch;
 706              f6i = rcu_dereference(f6i->fib6_next)) {
 707                 struct fib6_nh *nh;
 708
 709                 if (cont && f6i->fib6_metric != metric) {
 710                         *cont = f6i;
 711                         return;
 712                 }
 713
 714                 if (fib6_check_expired(f6i))
 715                         continue;
 716
 717                 nh = &f6i->fib6_nh;
 718                 if (find_match(nh, f6i->fib6_flags, oif, strict, mpri, do_rr)) {
 719                         res->f6i = f6i;
 720                         res->nh = nh;
 721                         res->fib6_flags = f6i->fib6_flags;
 722                         res->fib6_type = f6i->fib6_type;
 723                 }
 724         }
 725 }
 726
 727 static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
 728                          struct fib6_info *rr_head, int oif, int strict,
 729                          bool *do_rr, struct fib6_result *res)
 730 {
 731         u32 metric = rr_head->fib6_metric;
 732         struct fib6_info *cont = NULL;
 733         int mpri = -1;
 734
 735         __find_rr_leaf(rr_head, NULL, metric, res, &cont,
 736                        oif, strict, do_rr, &mpri);
 737
 738         __find_rr_leaf(leaf, rr_head, metric, res, &cont,
 739                        oif, strict, do_rr, &mpri);
 740
 741         if (res->f6i || !cont)
 742                 return;
 743
 744         __find_rr_leaf(cont, NULL, metric, res, NULL,
 745                        oif, strict, do_rr, &mpri);
 746 }
 747
 748 static void rt6_select(struct net *net, struct fib6_node *fn, int oif,
 749                        struct fib6_result *res, int strict)
 750 {
 751         struct fib6_info *leaf = rcu_dereference(fn->leaf);
 752         struct fib6_info *rt0;
 753         bool do_rr = false;
 754         int key_plen;
 755
 756         /* make sure this function or its helpers sets f6i */
 757         res->f6i = NULL;
 758
 759         if (!leaf || leaf == net->ipv6.fib6_null_entry)
 760                 goto out;
 761
 762         rt0 = rcu_dereference(fn->rr_ptr);
 763         if (!rt0)
 764                 rt0 = leaf;
 765
 766         /* Double check to make sure fn is not an intermediate node
 767          * and fn->leaf does not points to its child's leaf
 768          * (This might happen if all routes under fn are deleted from
 769          * the tree and fib6_repair_tree() is called on the node.)
 770          */
 771         key_plen = rt0->fib6_dst.plen;
 772 #ifdef CONFIG_IPV6_SUBTREES
 773         if (rt0->fib6_src.plen)
 774                 key_plen = rt0->fib6_src.plen;
 775 #endif
 776         if (fn->fn_bit != key_plen)
 777                 goto out;
 778
 779         find_rr_leaf(fn, leaf, rt0, oif, strict, &do_rr, res);
 780         if (do_rr) {
 781                 struct fib6_info *next = rcu_dereference(rt0->fib6_next);
 782
 783                 /* no entries matched; do round-robin */
 784                 if (!next || next->fib6_metric != rt0->fib6_metric)
 785                         next = leaf;
 786
 787                 if (next != rt0) {
 788                         spin_lock_bh(&leaf->fib6_table->tb6_lock);
 789                         /* make sure next is not being deleted from the tree */
 790                         if (next->fib6_node)
 791                                 rcu_assign_pointer(fn->rr_ptr, next);
 792                         spin_unlock_bh(&leaf->fib6_table->tb6_lock);
 793                 }
 794         }
 795
 796 out:
 797         if (!res->f6i) {
 798                 res->f6i = net->ipv6.fib6_null_entry;
 799                 res->nh = &res->f6i->fib6_nh;
 800                 res->fib6_flags = res->f6i->fib6_flags;
 801                 res->fib6_type = res->f6i->fib6_type;
 802         }
 803 }
 804
 805 static bool rt6_is_gw_or_nonexthop(const struct fib6_result *res)
 806 {
 807         return (res->f6i->fib6_flags & RTF_NONEXTHOP) ||
 808                res->nh->fib_nh_gw_family;
 809 }
 810
 811 #ifdef CONFIG_IPV6_ROUTE_INFO
 812 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
 813                   const struct in6_addr *gwaddr)
 814 {
 815         struct net *net = dev_net(dev);
 816         struct route_info *rinfo = (struct route_info *) opt;
 817         struct in6_addr prefix_buf, *prefix;
 818         unsigned int pref;
 819         unsigned long lifetime;
 820         struct fib6_info *rt;
 821
 822         if (len < sizeof(struct route_info)) {
 823                 return -EINVAL;
 824         }
 825
 826         /* Sanity check for prefix_len and length */
 827         if (rinfo->length > 3) {
 828                 return -EINVAL;
 829         } else if (rinfo->prefix_len > 128) {
 830                 return -EINVAL;
 831         } else if (rinfo->prefix_len > 64) {
 832                 if (rinfo->length < 2) {
 833                         return -EINVAL;
 834                 }
 835         } else if (rinfo->prefix_len > 0) {
 836                 if (rinfo->length < 1) {
 837                         return -EINVAL;
 838                 }
 839         }
 840
 841         pref = rinfo->route_pref;
 842         if (pref == ICMPV6_ROUTER_PREF_INVALID)
 843                 return -EINVAL;
 844
 845         lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
 846
 847         if (rinfo->length == 3)
 848                 prefix = (struct in6_addr *)rinfo->prefix;
 849         else {
 850                 /* this function is safe */
 851                 ipv6_addr_prefix(&prefix_buf,
 852                                  (struct in6_addr *)rinfo->prefix,
 853                                  rinfo->prefix_len);
 854                 prefix = &prefix_buf;
 855         }
 856
 857         if (rinfo->prefix_len == 0)
 858                 rt = rt6_get_dflt_router(net, gwaddr, dev);
 859         else
 860                 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
 861                                         gwaddr, dev);
 862
 863         if (rt && !lifetime) {
 864                 ip6_del_rt(net, rt);
 865                 rt = NULL;
 866         }
 867
 868         if (!rt && lifetime)
 869                 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr,
 870                                         dev, pref);
 871         else if (rt)
 872                 rt->fib6_flags = RTF_ROUTEINFO |
 873                                  (rt->fib6_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
 874
 875         if (rt) {
 876                 if (!addrconf_finite_timeout(lifetime))
 877                         fib6_clean_expires(rt);
 878                 else
 879                         fib6_set_expires(rt, jiffies + HZ * lifetime);
 880
 881                 fib6_info_release(rt);
 882         }
 883         return 0;
 884 }
 885 #endif
 886
 887 /*
 888  *      Misc support functions
 889  */
 890
 891 /* called with rcu_lock held */
 892 static struct net_device *ip6_rt_get_dev_rcu(const struct fib6_result *res)
 893 {
 894         struct net_device *dev = res->nh->fib_nh_dev;
 895
 896         if (res->fib6_flags & (RTF_LOCAL | RTF_ANYCAST)) {
 897                 /* for copies of local routes, dst->dev needs to be the
 898                  * device if it is a master device, the master device if
 899                  * device is enslaved, and the loopback as the default
 900                  */
 901                 if (netif_is_l3_slave(dev) &&
 902                     !rt6_need_strict(&res->f6i->fib6_dst.addr))
 903                         dev = l3mdev_master_dev_rcu(dev);
 904                 else if (!netif_is_l3_master(dev))
 905                         dev = dev_net(dev)->loopback_dev;
 906                 /* last case is netif_is_l3_master(dev) is true in which
 907                  * case we want dev returned to be dev
 908                  */
 909         }
 910
 911         return dev;
 912 }
 913
 914 static const int fib6_prop[RTN_MAX + 1] = {
 915         [RTN_UNSPEC]    = 0,
 916         [RTN_UNICAST]   = 0,
 917         [RTN_LOCAL]     = 0,
 918         [RTN_BROADCAST] = 0,
 919         [RTN_ANYCAST]   = 0,
 920         [RTN_MULTICAST] = 0,
 921         [RTN_BLACKHOLE] = -EINVAL,
 922         [RTN_UNREACHABLE] = -EHOSTUNREACH,
 923         [RTN_PROHIBIT]  = -EACCES,
 924         [RTN_THROW]     = -EAGAIN,
 925         [RTN_NAT]       = -EINVAL,
 926         [RTN_XRESOLVE]  = -EINVAL,
 927 };
 928
 929 static int ip6_rt_type_to_error(u8 fib6_type)
 930 {
 931         return fib6_prop[fib6_type];
 932 }
 933
 934 static unsigned short fib6_info_dst_flags(struct fib6_info *rt)
 935 {
 936         unsigned short flags = 0;
 937
 938         if (rt->dst_nocount)
 939                 flags |= DST_NOCOUNT;
 940         if (rt->dst_nopolicy)
 941                 flags |= DST_NOPOLICY;
 942         if (rt->dst_host)
 943                 flags |= DST_HOST;
 944
 945         return flags;
 946 }
 947
 948 static void ip6_rt_init_dst_reject(struct rt6_info *rt, u8 fib6_type)
 949 {
 950         rt->dst.error = ip6_rt_type_to_error(fib6_type);
 951
 952         switch (fib6_type) {
 953         case RTN_BLACKHOLE:
 954                 rt->dst.output = dst_discard_out;
 955                 rt->dst.input = dst_discard;
 956                 break;
 957         case RTN_PROHIBIT:
 958                 rt->dst.output = ip6_pkt_prohibit_out;
 959                 rt->dst.input = ip6_pkt_prohibit;
 960                 break;
 961         case RTN_THROW:
 962         case RTN_UNREACHABLE:
 963         default:
 964                 rt->dst.output = ip6_pkt_discard_out;
 965                 rt->dst.input = ip6_pkt_discard;
 966                 break;
 967         }
 968 }
 969
 970 static void ip6_rt_init_dst(struct rt6_info *rt, const struct fib6_result *res)
 971 {
 972         struct fib6_info *f6i = res->f6i;
 973
 974         if (res->fib6_flags & RTF_REJECT) {
 975                 ip6_rt_init_dst_reject(rt, res->fib6_type);
 976                 return;
 977         }
 978
 979         rt->dst.error = 0;
 980         rt->dst.output = ip6_output;
 981
 982         if (res->fib6_type == RTN_LOCAL || res->fib6_type == RTN_ANYCAST) {
 983                 rt->dst.input = ip6_input;
 984         } else if (ipv6_addr_type(&f6i->fib6_dst.addr) & IPV6_ADDR_MULTICAST) {
 985                 rt->dst.input = ip6_mc_input;
 986         } else {
 987                 rt->dst.input = ip6_forward;
 988         }
 989
 990         if (res->nh->fib_nh_lws) {
 991                 rt->dst.lwtstate = lwtstate_get(res->nh->fib_nh_lws);
 992                 lwtunnel_set_redirect(&rt->dst);
 993         }
 994
 995         rt->dst.lastuse = jiffies;
 996 }
 997
 998 /* Caller must already hold reference to @from */
 999 static void rt6_set_from(struct rt6_info *rt, struct fib6_info *from)
1000 {
1001         rt->rt6i_flags &= ~RTF_EXPIRES;
1002         rcu_assign_pointer(rt->from, from);
1003         ip_dst_init_metrics(&rt->dst, from->fib6_metrics);
1004 }
1005
1006 /* Caller must already hold reference to f6i in result */
1007 static void ip6_rt_copy_init(struct rt6_info *rt, const struct fib6_result *res)
1008 {
1009         const struct fib6_nh *nh = res->nh;
1010         const struct net_device *dev = nh->fib_nh_dev;
1011         struct fib6_info *f6i = res->f6i;
1012
1013         ip6_rt_init_dst(rt, res);
1014
1015         rt->rt6i_dst = f6i->fib6_dst;
1016         rt->rt6i_idev = dev ? in6_dev_get(dev) : NULL;
1017         rt->rt6i_flags = res->fib6_flags;
1018         if (nh->fib_nh_gw_family) {
1019                 rt->rt6i_gateway = nh->fib_nh_gw6;
1020                 rt->rt6i_flags |= RTF_GATEWAY;
1021         }
1022         rt6_set_from(rt, f6i);
1023 #ifdef CONFIG_IPV6_SUBTREES
1024         rt->rt6i_src = f6i->fib6_src;
1025 #endif
1026 }
1027
1028 static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
1029                                         struct in6_addr *saddr)
1030 {
1031         struct fib6_node *pn, *sn;
1032         while (1) {
1033                 if (fn->fn_flags & RTN_TL_ROOT)
1034                         return NULL;
1035                 pn = rcu_dereference(fn->parent);
1036                 sn = FIB6_SUBTREE(pn);
1037                 if (sn && sn != fn)
1038                         fn = fib6_node_lookup(sn, NULL, saddr);
1039                 else
1040                         fn = pn;
1041                 if (fn->fn_flags & RTN_RTINFO)
1042                         return fn;
1043         }
1044 }
1045
1046 static bool ip6_hold_safe(struct net *net, struct rt6_info **prt)
1047 {
1048         struct rt6_info *rt = *prt;
1049
1050         if (dst_hold_safe(&rt->dst))
1051                 return true;
1052         if (net) {
1053                 rt = net->ipv6.ip6_null_entry;
1054                 dst_hold(&rt->dst);
1055         } else {
1056                 rt = NULL;
1057         }
1058         *prt = rt;
1059         return false;
1060 }
1061
1062 /* called with rcu_lock held */
1063 static struct rt6_info *ip6_create_rt_rcu(const struct fib6_result *res)
1064 {
1065         struct net_device *dev = res->nh->fib_nh_dev;
1066         struct fib6_info *f6i = res->f6i;
1067         unsigned short flags;
1068         struct rt6_info *nrt;
1069
1070         if (!fib6_info_hold_safe(f6i))
1071                 goto fallback;
1072
1073         flags = fib6_info_dst_flags(f6i);
1074         nrt = ip6_dst_alloc(dev_net(dev), dev, flags);
1075         if (!nrt) {
1076                 fib6_info_release(f6i);
1077                 goto fallback;
1078         }
1079
1080         ip6_rt_copy_init(nrt, res);
1081         return nrt;
1082
1083 fallback:
1084         nrt = dev_net(dev)->ipv6.ip6_null_entry;
1085         dst_hold(&nrt->dst);
1086         return nrt;
1087 }
1088
1089 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
1090                                              struct fib6_table *table,
1091                                              struct flowi6 *fl6,
1092                                              const struct sk_buff *skb,
1093                                              int flags)
1094 {
1095         struct fib6_result res = {};
1096         struct fib6_node *fn;
1097         struct rt6_info *rt;
1098
1099         if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
1100                 flags &= ~RT6_LOOKUP_F_IFACE;
1101
1102         rcu_read_lock();
1103         fn = fib6_node_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1104 restart:
1105         res.f6i = rcu_dereference(fn->leaf);
1106         if (!res.f6i)
1107                 res.f6i = net->ipv6.fib6_null_entry;
1108         else
1109                 rt6_device_match(net, &res, &fl6->saddr, fl6->flowi6_oif,
1110                                  flags);
1111
1112         if (res.f6i == net->ipv6.fib6_null_entry) {
1113                 fn = fib6_backtrack(fn, &fl6->saddr);
1114                 if (fn)
1115                         goto restart;
1116
1117                 rt = net->ipv6.ip6_null_entry;
1118                 dst_hold(&rt->dst);
1119                 goto out;
1120         }
1121
1122         fib6_select_path(net, &res, fl6, fl6->flowi6_oif,
1123                          fl6->flowi6_oif != 0, skb, flags);
1124
1125         /* Search through exception table */
1126         rt = rt6_find_cached_rt(&res, &fl6->daddr, &fl6->saddr);
1127         if (rt) {
1128                 if (ip6_hold_safe(net, &rt))
1129                         dst_use_noref(&rt->dst, jiffies);
1130         } else {
1131                 rt = ip6_create_rt_rcu(&res);
1132         }
1133
1134 out:
1135         trace_fib6_table_lookup(net, &res, table, fl6);
1136
1137         rcu_read_unlock();
1138
1139         return rt;
1140 }
1141
1142 struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
1143                                    const struct sk_buff *skb, int flags)
1144 {
1145         return fib6_rule_lookup(net, fl6, skb, flags, ip6_pol_route_lookup);
1146 }
1147 EXPORT_SYMBOL_GPL(ip6_route_lookup);
1148
1149 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
1150                             const struct in6_addr *saddr, int oif,
1151                             const struct sk_buff *skb, int strict)
1152 {
1153         struct flowi6 fl6 = {
1154                 .flowi6_oif = oif,
1155                 .daddr = *daddr,
1156         };
1157         struct dst_entry *dst;
1158         int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
1159
1160         if (saddr) {
1161                 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
1162                 flags |= RT6_LOOKUP_F_HAS_SADDR;
1163         }
1164
1165         dst = fib6_rule_lookup(net, &fl6, skb, flags, ip6_pol_route_lookup);
1166         if (dst->error == 0)
1167                 return (struct rt6_info *) dst;
1168
1169         dst_release(dst);
1170
1171         return NULL;
1172 }
1173 EXPORT_SYMBOL(rt6_lookup);
1174
1175 /* ip6_ins_rt is called with FREE table->tb6_lock.
1176  * It takes new route entry, the addition fails by any reason the
1177  * route is released.
1178  * Caller must hold dst before calling it.
1179  */
1180
1181 static int __ip6_ins_rt(struct fib6_info *rt, struct nl_info *info,
1182                         struct netlink_ext_ack *extack)
1183 {
1184         int err;
1185         struct fib6_table *table;
1186
1187         table = rt->fib6_table;
1188         spin_lock_bh(&table->tb6_lock);
1189         err = fib6_add(&table->tb6_root, rt, info, extack);
1190         spin_unlock_bh(&table->tb6_lock);
1191
1192         return err;
1193 }
1194
1195 int ip6_ins_rt(struct net *net, struct fib6_info *rt)
1196 {
1197         struct nl_info info = { .nl_net = net, };
1198
1199         return __ip6_ins_rt(rt, &info, NULL);
1200 }
1201
1202 static struct rt6_info *ip6_rt_cache_alloc(const struct fib6_result *res,
1203                                            const struct in6_addr *daddr,
1204                                            const struct in6_addr *saddr)
1205 {
1206         struct fib6_info *f6i = res->f6i;
1207         struct net_device *dev;
1208         struct rt6_info *rt;
1209
1210         /*
1211          *      Clone the route.
1212          */
1213
1214         if (!fib6_info_hold_safe(f6i))
1215                 return NULL;
1216
1217         dev = ip6_rt_get_dev_rcu(res);
1218         rt = ip6_dst_alloc(dev_net(dev), dev, 0);
1219         if (!rt) {
1220                 fib6_info_release(f6i);
1221                 return NULL;
1222         }
1223
1224         ip6_rt_copy_init(rt, res);
1225         rt->rt6i_flags |= RTF_CACHE;
1226         rt->dst.flags |= DST_HOST;
1227         rt->rt6i_dst.addr = *daddr;
1228         rt->rt6i_dst.plen = 128;
1229
1230         if (!rt6_is_gw_or_nonexthop(res)) {
1231                 if (f6i->fib6_dst.plen != 128 &&
1232                     ipv6_addr_equal(&f6i->fib6_dst.addr, daddr))
1233                         rt->rt6i_flags |= RTF_ANYCAST;
1234 #ifdef CONFIG_IPV6_SUBTREES
1235                 if (rt->rt6i_src.plen && saddr) {
1236                         rt->rt6i_src.addr = *saddr;
1237                         rt->rt6i_src.plen = 128;
1238                 }
1239 #endif
1240         }
1241
1242         return rt;
1243 }
1244
1245 static struct rt6_info *ip6_rt_pcpu_alloc(const struct fib6_result *res)
1246 {
1247         struct fib6_info *f6i = res->f6i;
1248         unsigned short flags = fib6_info_dst_flags(f6i);
1249         struct net_device *dev;
1250         struct rt6_info *pcpu_rt;
1251
1252         if (!fib6_info_hold_safe(f6i))
1253                 return NULL;
1254
1255         rcu_read_lock();
1256         dev = ip6_rt_get_dev_rcu(res);
1257         pcpu_rt = ip6_dst_alloc(dev_net(dev), dev, flags);
1258         rcu_read_unlock();
1259         if (!pcpu_rt) {
1260                 fib6_info_release(f6i);
1261                 return NULL;
1262         }
1263         ip6_rt_copy_init(pcpu_rt, res);
1264         pcpu_rt->rt6i_flags |= RTF_PCPU;
1265         return pcpu_rt;
1266 }
1267
1268 /* It should be called with rcu_read_lock() acquired */
1269 static struct rt6_info *rt6_get_pcpu_route(const struct fib6_result *res)
1270 {
1271         struct rt6_info *pcpu_rt, **p;
1272
1273         p = this_cpu_ptr(res->f6i->rt6i_pcpu);
1274         pcpu_rt = *p;
1275
1276         if (pcpu_rt)
1277                 ip6_hold_safe(NULL, &pcpu_rt);
1278
1279         return pcpu_rt;
1280 }
1281
1282 static struct rt6_info *rt6_make_pcpu_route(struct net *net,
1283                                             const struct fib6_result *res)
1284 {
1285         struct rt6_info *pcpu_rt, *prev, **p;
1286
1287         pcpu_rt = ip6_rt_pcpu_alloc(res);
1288         if (!pcpu_rt) {
1289                 dst_hold(&net->ipv6.ip6_null_entry->dst);
1290                 return net->ipv6.ip6_null_entry;
1291         }
1292
1293         dst_hold(&pcpu_rt->dst);
1294         p = this_cpu_ptr(res->f6i->rt6i_pcpu);
1295         prev = cmpxchg(p, NULL, pcpu_rt);
1296         BUG_ON(prev);
1297
1298         if (res->f6i->fib6_destroying) {
1299                 struct fib6_info *from;
1300
1301                 from = xchg((__force struct fib6_info **)&pcpu_rt->from, NULL);
1302                 fib6_info_release(from);
1303         }
1304
1305         return pcpu_rt;
1306 }
1307
1308 /* exception hash table implementation
1309  */
1310 static DEFINE_SPINLOCK(rt6_exception_lock);
1311
1312 /* Remove rt6_ex from hash table and free the memory
1313  * Caller must hold rt6_exception_lock
1314  */
1315 static void rt6_remove_exception(struct rt6_exception_bucket *bucket,
1316                                  struct rt6_exception *rt6_ex)
1317 {
1318         struct fib6_info *from;
1319         struct net *net;
1320
1321         if (!bucket || !rt6_ex)
1322                 return;
1323
1324         net = dev_net(rt6_ex->rt6i->dst.dev);
1325         net->ipv6.rt6_stats->fib_rt_cache--;
1326
1327         /* purge completely the exception to allow releasing the held resources:
1328          * some [sk] cache may keep the dst around for unlimited time
1329          */
1330         from = xchg((__force struct fib6_info **)&rt6_ex->rt6i->from, NULL);
1331         fib6_info_release(from);
1332         dst_dev_put(&rt6_ex->rt6i->dst);
1333
1334         hlist_del_rcu(&rt6_ex->hlist);
1335         dst_release(&rt6_ex->rt6i->dst);
1336         kfree_rcu(rt6_ex, rcu);
1337         WARN_ON_ONCE(!bucket->depth);
1338         bucket->depth--;
1339 }
1340
1341 /* Remove oldest rt6_ex in bucket and free the memory
1342  * Caller must hold rt6_exception_lock
1343  */
1344 static void rt6_exception_remove_oldest(struct rt6_exception_bucket *bucket)
1345 {
1346         struct rt6_exception *rt6_ex, *oldest = NULL;
1347
1348         if (!bucket)
1349                 return;
1350
1351         hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {
1352                 if (!oldest || time_before(rt6_ex->stamp, oldest->stamp))
1353                         oldest = rt6_ex;
1354         }
1355         rt6_remove_exception(bucket, oldest);
1356 }
1357
1358 static u32 rt6_exception_hash(const struct in6_addr *dst,
1359                               const struct in6_addr *src)
1360 {
1361         static u32 seed __read_mostly;
1362         u32 val;
1363
1364         net_get_random_once(&seed, sizeof(seed));
1365         val = jhash(dst, sizeof(*dst), seed);
1366
1367 #ifdef CONFIG_IPV6_SUBTREES
1368         if (src)
1369                 val = jhash(src, sizeof(*src), val);
1370 #endif
1371         return hash_32(val, FIB6_EXCEPTION_BUCKET_SIZE_SHIFT);
1372 }
1373
1374 /* Helper function to find the cached rt in the hash table
1375  * and update bucket pointer to point to the bucket for this
1376  * (daddr, saddr) pair
1377  * Caller must hold rt6_exception_lock
1378  */
1379 static struct rt6_exception *
1380 __rt6_find_exception_spinlock(struct rt6_exception_bucket **bucket,
1381                               const struct in6_addr *daddr,
1382                               const struct in6_addr *saddr)
1383 {
1384         struct rt6_exception *rt6_ex;
1385         u32 hval;
1386
1387         if (!(*bucket) || !daddr)
1388                 return NULL;
1389
1390         hval = rt6_exception_hash(daddr, saddr);
1391         *bucket += hval;
1392
1393         hlist_for_each_entry(rt6_ex, &(*bucket)->chain, hlist) {
1394                 struct rt6_info *rt6 = rt6_ex->rt6i;
1395                 bool matched = ipv6_addr_equal(daddr, &rt6->rt6i_dst.addr);
1396
1397 #ifdef CONFIG_IPV6_SUBTREES
1398                 if (matched && saddr)
1399                         matched = ipv6_addr_equal(saddr, &rt6->rt6i_src.addr);
1400 #endif
1401                 if (matched)
1402                         return rt6_ex;
1403         }
1404         return NULL;
1405 }
1406
1407 /* Helper function to find the cached rt in the hash table
1408  * and update bucket pointer to point to the bucket for this
1409  * (daddr, saddr) pair
1410  * Caller must hold rcu_read_lock()
1411  */
1412 static struct rt6_exception *
1413 __rt6_find_exception_rcu(struct rt6_exception_bucket **bucket,
1414                          const struct in6_addr *daddr,
1415                          const struct in6_addr *saddr)
1416 {
1417         struct rt6_exception *rt6_ex;
1418         u32 hval;
1419
1420         WARN_ON_ONCE(!rcu_read_lock_held());
1421
1422         if (!(*bucket) || !daddr)
1423                 return NULL;
1424
1425         hval = rt6_exception_hash(daddr, saddr);
1426         *bucket += hval;
1427
1428         hlist_for_each_entry_rcu(rt6_ex, &(*bucket)->chain, hlist) {
1429                 struct rt6_info *rt6 = rt6_ex->rt6i;
1430                 bool matched = ipv6_addr_equal(daddr, &rt6->rt6i_dst.addr);
1431
1432 #ifdef CONFIG_IPV6_SUBTREES
1433                 if (matched && saddr)
1434                         matched = ipv6_addr_equal(saddr, &rt6->rt6i_src.addr);
1435 #endif
1436                 if (matched)
1437                         return rt6_ex;
1438         }
1439         return NULL;
1440 }
1441
1442 static unsigned int fib6_mtu(const struct fib6_result *res)
1443 {
1444         const struct fib6_nh *nh = res->nh;
1445         unsigned int mtu;
1446
1447         if (res->f6i->fib6_pmtu) {
1448                 mtu = res->f6i->fib6_pmtu;
1449         } else {
1450                 struct net_device *dev = nh->fib_nh_dev;
1451                 struct inet6_dev *idev;
1452
1453                 rcu_read_lock();
1454                 idev = __in6_dev_get(dev);
1455                 mtu = idev->cnf.mtu6;
1456                 rcu_read_unlock();
1457         }
1458
1459         mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
1460
1461         return mtu - lwtunnel_headroom(nh->fib_nh_lws, mtu);
1462 }
1463
1464 static int rt6_insert_exception(struct rt6_info *nrt,
1465                                 const struct fib6_result *res)
1466 {
1467         struct net *net = dev_net(nrt->dst.dev);
1468         struct rt6_exception_bucket *bucket;
1469         struct in6_addr *src_key = NULL;
1470         struct rt6_exception *rt6_ex;
1471         struct fib6_info *f6i = res->f6i;
1472         int err = 0;
1473
1474         spin_lock_bh(&rt6_exception_lock);
1475
1476         if (f6i->exception_bucket_flushed) {
1477                 err = -EINVAL;
1478                 goto out;
1479         }
1480
1481         bucket = rcu_dereference_protected(f6i->rt6i_exception_bucket,
1482                                         lockdep_is_held(&rt6_exception_lock));
1483         if (!bucket) {
1484                 bucket = kcalloc(FIB6_EXCEPTION_BUCKET_SIZE, sizeof(*bucket),
1485                                  GFP_ATOMIC);
1486                 if (!bucket) {
1487                         err = -ENOMEM;
1488                         goto out;
1489                 }
1490                 rcu_assign_pointer(f6i->rt6i_exception_bucket, bucket);
1491         }
1492
1493 #ifdef CONFIG_IPV6_SUBTREES
1494         /* fib6_src.plen != 0 indicates f6i is in subtree
1495          * and exception table is indexed by a hash of
1496          * both fib6_dst and fib6_src.
1497          * Otherwise, the exception table is indexed by
1498          * a hash of only fib6_dst.
1499          */
1500         if (f6i->fib6_src.plen)
1501                 src_key = &nrt->rt6i_src.addr;
1502 #endif
1503         /* rt6_mtu_change() might lower mtu on f6i.
1504          * Only insert this exception route if its mtu
1505          * is less than f6i's mtu value.
1506          */
1507         if (dst_metric_raw(&nrt->dst, RTAX_MTU) >= fib6_mtu(res)) {
1508                 err = -EINVAL;
1509                 goto out;
1510         }
1511
1512         rt6_ex = __rt6_find_exception_spinlock(&bucket, &nrt->rt6i_dst.addr,
1513                                                src_key);
1514         if (rt6_ex)
1515                 rt6_remove_exception(bucket, rt6_ex);
1516
1517         rt6_ex = kzalloc(sizeof(*rt6_ex), GFP_ATOMIC);
1518         if (!rt6_ex) {
1519                 err = -ENOMEM;
1520                 goto out;
1521         }
1522         rt6_ex->rt6i = nrt;
1523         rt6_ex->stamp = jiffies;
1524         hlist_add_head_rcu(&rt6_ex->hlist, &bucket->chain);
1525         bucket->depth++;
1526         net->ipv6.rt6_stats->fib_rt_cache++;
1527
1528         if (bucket->depth > FIB6_MAX_DEPTH)
1529                 rt6_exception_remove_oldest(bucket);
1530
1531 out:
1532         spin_unlock_bh(&rt6_exception_lock);
1533
1534         /* Update fn->fn_sernum to invalidate all cached dst */
1535         if (!err) {
1536                 spin_lock_bh(&f6i->fib6_table->tb6_lock);
1537                 fib6_update_sernum(net, f6i);
1538                 spin_unlock_bh(&f6i->fib6_table->tb6_lock);
1539                 fib6_force_start_gc(net);
1540         }
1541
1542         return err;
1543 }
1544
1545 void rt6_flush_exceptions(struct fib6_info *rt)
1546 {
1547         struct rt6_exception_bucket *bucket;
1548         struct rt6_exception *rt6_ex;
1549         struct hlist_node *tmp;
1550         int i;
1551
1552         spin_lock_bh(&rt6_exception_lock);
1553         /* Prevent rt6_insert_exception() to recreate the bucket list */
1554         rt->exception_bucket_flushed = 1;
1555
1556         bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
1557                                     lockdep_is_held(&rt6_exception_lock));
1558         if (!bucket)
1559                 goto out;
1560
1561         for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
1562                 hlist_for_each_entry_safe(rt6_ex, tmp, &bucket->chain, hlist)
1563                         rt6_remove_exception(bucket, rt6_ex);
1564                 WARN_ON_ONCE(bucket->depth);
1565                 bucket++;
1566         }
1567
1568 out:
1569         spin_unlock_bh(&rt6_exception_lock);
1570 }
1571
1572 /* Find cached rt in the hash table inside passed in rt
1573  * Caller has to hold rcu_read_lock()
1574  */
1575 static struct rt6_info *rt6_find_cached_rt(const struct fib6_result *res,
1576                                            const struct in6_addr *daddr,
1577                                            const struct in6_addr *saddr)
1578 {
1579         const struct in6_addr *src_key = NULL;
1580         struct rt6_exception_bucket *bucket;
1581         struct rt6_exception *rt6_ex;
1582         struct rt6_info *ret = NULL;
1583
1584 #ifdef CONFIG_IPV6_SUBTREES
1585         /* fib6i_src.plen != 0 indicates f6i is in subtree
1586          * and exception table is indexed by a hash of
1587          * both fib6_dst and fib6_src.
1588          * However, the src addr used to create the hash
1589          * might not be exactly the passed in saddr which
1590          * is a /128 addr from the flow.
1591          * So we need to use f6i->fib6_src to redo lookup
1592          * if the passed in saddr does not find anything.
1593          * (See the logic in ip6_rt_cache_alloc() on how
1594          * rt->rt6i_src is updated.)
1595          */
1596         if (res->f6i->fib6_src.plen)
1597                 src_key = saddr;
1598 find_ex:
1599 #endif
1600         bucket = rcu_dereference(res->f6i->rt6i_exception_bucket);
1601         rt6_ex = __rt6_find_exception_rcu(&bucket, daddr, src_key);
1602
1603         if (rt6_ex && !rt6_check_expired(rt6_ex->rt6i))
1604                 ret = rt6_ex->rt6i;
1605
1606 #ifdef CONFIG_IPV6_SUBTREES
1607         /* Use fib6_src as src_key and redo lookup */
1608         if (!ret && src_key && src_key != &res->f6i->fib6_src.addr) {
1609                 src_key = &res->f6i->fib6_src.addr;
1610                 goto find_ex;
1611         }
1612 #endif
1613
1614         return ret;
1615 }
1616
1617 /* Remove the passed in cached rt from the hash table that contains it */
1618 static int rt6_remove_exception_rt(struct rt6_info *rt)
1619 {
1620         struct rt6_exception_bucket *bucket;
1621         struct in6_addr *src_key = NULL;
1622         struct rt6_exception *rt6_ex;
1623         struct fib6_info *from;
1624         int err;
1625
1626         from = rcu_dereference(rt->from);
1627         if (!from ||
1628             !(rt->rt6i_flags & RTF_CACHE))
1629                 return -EINVAL;
1630
1631         if (!rcu_access_pointer(from->rt6i_exception_bucket))
1632                 return -ENOENT;
1633
1634         spin_lock_bh(&rt6_exception_lock);
1635         bucket = rcu_dereference_protected(from->rt6i_exception_bucket,
1636                                     lockdep_is_held(&rt6_exception_lock));
1637 #ifdef CONFIG_IPV6_SUBTREES
1638         /* rt6i_src.plen != 0 indicates 'from' is in subtree
1639          * and exception table is indexed by a hash of
1640          * both rt6i_dst and rt6i_src.
1641          * Otherwise, the exception table is indexed by
1642          * a hash of only rt6i_dst.
1643          */
1644         if (from->fib6_src.plen)
1645                 src_key = &rt->rt6i_src.addr;
1646 #endif
1647         rt6_ex = __rt6_find_exception_spinlock(&bucket,
1648                                                &rt->rt6i_dst.addr,
1649                                                src_key);
1650         if (rt6_ex) {
1651                 rt6_remove_exception(bucket, rt6_ex);
1652                 err = 0;
1653         } else {
1654                 err = -ENOENT;
1655         }
1656
1657         spin_unlock_bh(&rt6_exception_lock);
1658         return err;
1659 }
1660
1661 /* Find rt6_ex which contains the passed in rt cache and
1662  * refresh its stamp
1663  */
1664 static void rt6_update_exception_stamp_rt(struct rt6_info *rt)
1665 {
1666         struct rt6_exception_bucket *bucket;
1667         struct in6_addr *src_key = NULL;
1668         struct rt6_exception *rt6_ex;
1669         struct fib6_info *from;
1670
1671         rcu_read_lock();
1672         from = rcu_dereference(rt->from);
1673         if (!from || !(rt->rt6i_flags & RTF_CACHE))
1674                 goto unlock;
1675
1676         bucket = rcu_dereference(from->rt6i_exception_bucket);
1677
1678 #ifdef CONFIG_IPV6_SUBTREES
1679         /* rt6i_src.plen != 0 indicates 'from' is in subtree
1680          * and exception table is indexed by a hash of
1681          * both rt6i_dst and rt6i_src.
1682          * Otherwise, the exception table is indexed by
1683          * a hash of only rt6i_dst.
1684          */
1685         if (from->fib6_src.plen)
1686                 src_key = &rt->rt6i_src.addr;
1687 #endif
1688         rt6_ex = __rt6_find_exception_rcu(&bucket,
1689                                           &rt->rt6i_dst.addr,
1690                                           src_key);
1691         if (rt6_ex)
1692                 rt6_ex->stamp = jiffies;
1693
1694 unlock:
1695         rcu_read_unlock();
1696 }
1697
1698 static bool rt6_mtu_change_route_allowed(struct inet6_dev *idev,
1699                                          struct rt6_info *rt, int mtu)
1700 {
1701         /* If the new MTU is lower than the route PMTU, this new MTU will be the
1702          * lowest MTU in the path: always allow updating the route PMTU to
1703          * reflect PMTU decreases.
1704          *
1705          * If the new MTU is higher, and the route PMTU is equal to the local
1706          * MTU, this means the old MTU is the lowest in the path, so allow
1707          * updating it: if other nodes now have lower MTUs, PMTU discovery will
1708          * handle this.
1709          */
1710
1711         if (dst_mtu(&rt->dst) >= mtu)
1712                 return true;
1713
1714         if (dst_mtu(&rt->dst) == idev->cnf.mtu6)
1715                 return true;
1716
1717         return false;
1718 }
1719
1720 static void rt6_exceptions_update_pmtu(struct inet6_dev *idev,
1721                                        struct fib6_info *rt, int mtu)
1722 {
1723         struct rt6_exception_bucket *bucket;
1724         struct rt6_exception *rt6_ex;
1725         int i;
1726
1727         bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
1728                                         lockdep_is_held(&rt6_exception_lock));
1729
1730         if (!bucket)
1731                 return;
1732
1733         for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
1734                 hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {
1735                         struct rt6_info *entry = rt6_ex->rt6i;
1736
1737                         /* For RTF_CACHE with rt6i_pmtu == 0 (i.e. a redirected
1738                          * route), the metrics of its rt->from have already
1739                          * been updated.
1740                          */
1741                         if (dst_metric_raw(&entry->dst, RTAX_MTU) &&
1742                             rt6_mtu_change_route_allowed(idev, entry, mtu))
1743                                 dst_metric_set(&entry->dst, RTAX_MTU, mtu);
1744                 }
1745                 bucket++;
1746         }
1747 }
1748
1749 #define RTF_CACHE_GATEWAY       (RTF_GATEWAY | RTF_CACHE)
1750
1751 static void rt6_exceptions_clean_tohost(struct fib6_info *rt,
1752                                         struct in6_addr *gateway)
1753 {
1754         struct rt6_exception_bucket *bucket;
1755         struct rt6_exception *rt6_ex;
1756         struct hlist_node *tmp;
1757         int i;
1758
1759         if (!rcu_access_pointer(rt->rt6i_exception_bucket))
1760                 return;
1761
1762         spin_lock_bh(&rt6_exception_lock);
1763         bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
1764                                      lockdep_is_held(&rt6_exception_lock));
1765
1766         if (bucket) {
1767                 for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
1768                         hlist_for_each_entry_safe(rt6_ex, tmp,
1769                                                   &bucket->chain, hlist) {
1770                                 struct rt6_info *entry = rt6_ex->rt6i;
1771
1772                                 if ((entry->rt6i_flags & RTF_CACHE_GATEWAY) ==
1773                                     RTF_CACHE_GATEWAY &&
1774                                     ipv6_addr_equal(gateway,
1775                                                     &entry->rt6i_gateway)) {
1776                                         rt6_remove_exception(bucket, rt6_ex);
1777                                 }
1778                         }
1779                         bucket++;
1780                 }
1781         }
1782
1783         spin_unlock_bh(&rt6_exception_lock);
1784 }
1785
1786 static void rt6_age_examine_exception(struct rt6_exception_bucket *bucket,
1787                                       struct rt6_exception *rt6_ex,
1788                                       struct fib6_gc_args *gc_args,
1789                                       unsigned long now)
1790 {
1791         struct rt6_info *rt = rt6_ex->rt6i;
1792
1793         /* we are pruning and obsoleting aged-out and non gateway exceptions
1794          * even if others have still references to them, so that on next
1795          * dst_check() such references can be dropped.
1796          * EXPIRES exceptions - e.g. pmtu-generated ones are pruned when
1797          * expired, independently from their aging, as per RFC 8201 section 4
1798          */
1799         if (!(rt->rt6i_flags & RTF_EXPIRES)) {
1800                 if (time_after_eq(now, rt->dst.lastuse + gc_args->timeout)) {
1801                         RT6_TRACE("aging clone %p\n", rt);
1802                         rt6_remove_exception(bucket, rt6_ex);
1803                         return;
1804                 }
1805         } else if (time_after(jiffies, rt->dst.expires)) {
1806                 RT6_TRACE("purging expired route %p\n", rt);
1807                 rt6_remove_exception(bucket, rt6_ex);
1808                 return;
1809         }
1810
1811         if (rt->rt6i_flags & RTF_GATEWAY) {
1812                 struct neighbour *neigh;
1813                 __u8 neigh_flags = 0;
1814
1815                 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
1816                 if (neigh)
1817                         neigh_flags = neigh->flags;
1818
1819                 if (!(neigh_flags & NTF_ROUTER)) {
1820                         RT6_TRACE("purging route %p via non-router but gateway\n",
1821                                   rt);
1822                         rt6_remove_exception(bucket, rt6_ex);
1823                         return;
1824                 }
1825         }
1826
1827         gc_args->more++;
1828 }
1829
1830 void rt6_age_exceptions(struct fib6_info *rt,
1831                         struct fib6_gc_args *gc_args,
1832                         unsigned long now)
1833 {
1834         struct rt6_exception_bucket *bucket;
1835         struct rt6_exception *rt6_ex;
1836         struct hlist_node *tmp;
1837         int i;
1838
1839         if (!rcu_access_pointer(rt->rt6i_exception_bucket))
1840                 return;
1841
1842         rcu_read_lock_bh();
1843         spin_lock(&rt6_exception_lock);
1844         bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
1845                                     lockdep_is_held(&rt6_exception_lock));
1846
1847         if (bucket) {
1848                 for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
1849                         hlist_for_each_entry_safe(rt6_ex, tmp,
1850                                                   &bucket->chain, hlist) {
1851                                 rt6_age_examine_exception(bucket, rt6_ex,
1852                                                           gc_args, now);
1853                         }
1854                         bucket++;
1855                 }
1856         }
1857         spin_unlock(&rt6_exception_lock);
1858         rcu_read_unlock_bh();
1859 }
1860
1861 /* must be called with rcu lock held */
1862 int fib6_table_lookup(struct net *net, struct fib6_table *table, int oif,
1863                       struct flowi6 *fl6, struct fib6_result *res, int strict)
1864 {
1865         struct fib6_node *fn, *saved_fn;
1866
1867         fn = fib6_node_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1868         saved_fn = fn;
1869
1870         if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
1871                 oif = 0;
1872
1873 redo_rt6_select:
1874         rt6_select(net, fn, oif, res, strict);
1875         if (res->f6i == net->ipv6.fib6_null_entry) {
1876                 fn = fib6_backtrack(fn, &fl6->saddr);
1877                 if (fn)
1878                         goto redo_rt6_select;
1879                 else if (strict & RT6_LOOKUP_F_REACHABLE) {
1880                         /* also consider unreachable route */
1881                         strict &= ~RT6_LOOKUP_F_REACHABLE;
1882                         fn = saved_fn;
1883                         goto redo_rt6_select;
1884                 }
1885         }
1886
1887         trace_fib6_table_lookup(net, res, table, fl6);
1888
1889         return 0;
1890 }
1891
1892 struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table,
1893                                int oif, struct flowi6 *fl6,
1894                                const struct sk_buff *skb, int flags)
1895 {
1896         struct fib6_result res = {};
1897         struct rt6_info *rt;
1898         int strict = 0;
1899
1900         strict |= flags & RT6_LOOKUP_F_IFACE;
1901         strict |= flags & RT6_LOOKUP_F_IGNORE_LINKSTATE;
1902         if (net->ipv6.devconf_all->forwarding == 0)
1903                 strict |= RT6_LOOKUP_F_REACHABLE;
1904
1905         rcu_read_lock();
1906
1907         fib6_table_lookup(net, table, oif, fl6, &res, strict);
1908         if (res.f6i == net->ipv6.fib6_null_entry) {
1909                 rt = net->ipv6.ip6_null_entry;
1910                 rcu_read_unlock();
1911                 dst_hold(&rt->dst);
1912                 return rt;
1913         }
1914
1915         fib6_select_path(net, &res, fl6, oif, false, skb, strict);
1916
1917         /*Search through exception table */
1918         rt = rt6_find_cached_rt(&res, &fl6->daddr, &fl6->saddr);
1919         if (rt) {
1920                 if (ip6_hold_safe(net, &rt))
1921                         dst_use_noref(&rt->dst, jiffies);
1922
1923                 rcu_read_unlock();
1924                 return rt;
1925         } else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
1926                             !res.nh->fib_nh_gw_family)) {
1927                 /* Create a RTF_CACHE clone which will not be
1928                  * owned by the fib6 tree.  It is for the special case where
1929                  * the daddr in the skb during the neighbor look-up is different
1930                  * from the fl6->daddr used to look-up route here.
1931                  */
1932                 struct rt6_info *uncached_rt;
1933
1934                 uncached_rt = ip6_rt_cache_alloc(&res, &fl6->daddr, NULL);
1935
1936                 rcu_read_unlock();
1937
1938                 if (uncached_rt) {
1939                         /* Uncached_rt's refcnt is taken during ip6_rt_cache_alloc()
1940                          * No need for another dst_hold()
1941                          */
1942                         rt6_uncached_list_add(uncached_rt);
1943                         atomic_inc(&net->ipv6.rt6_stats->fib_rt_uncache);
1944                 } else {
1945                         uncached_rt = net->ipv6.ip6_null_entry;
1946                         dst_hold(&uncached_rt->dst);
1947                 }
1948
1949                 return uncached_rt;
1950         } else {
1951                 /* Get a percpu copy */
1952
1953                 struct rt6_info *pcpu_rt;
1954
1955                 local_bh_disable();
1956                 pcpu_rt = rt6_get_pcpu_route(&res);
1957
1958                 if (!pcpu_rt)
1959                         pcpu_rt = rt6_make_pcpu_route(net, &res);
1960
1961                 local_bh_enable();
1962                 rcu_read_unlock();
1963
1964                 return pcpu_rt;
1965         }
1966 }
1967 EXPORT_SYMBOL_GPL(ip6_pol_route);
1968
1969 static struct rt6_info *ip6_pol_route_input(struct net *net,
1970                                             struct fib6_table *table,
1971                                             struct flowi6 *fl6,
1972                                             const struct sk_buff *skb,
1973                                             int flags)
1974 {
1975         return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, skb, flags);
1976 }
1977
1978 struct dst_entry *ip6_route_input_lookup(struct net *net,
1979                                          struct net_device *dev,
1980                                          struct flowi6 *fl6,
1981                                          const struct sk_buff *skb,
1982                                          int flags)
1983 {
1984         if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
1985                 flags |= RT6_LOOKUP_F_IFACE;
1986
1987         return fib6_rule_lookup(net, fl6, skb, flags, ip6_pol_route_input);
1988 }
1989 EXPORT_SYMBOL_GPL(ip6_route_input_lookup);
1990
1991 static void ip6_multipath_l3_keys(const struct sk_buff *skb,
1992                                   struct flow_keys *keys,
1993                                   struct flow_keys *flkeys)
1994 {
1995         const struct ipv6hdr *outer_iph = ipv6_hdr(skb);
1996         const struct ipv6hdr *key_iph = outer_iph;
1997         struct flow_keys *_flkeys = flkeys;
1998         const struct ipv6hdr *inner_iph;
1999         const struct icmp6hdr *icmph;
2000         struct ipv6hdr _inner_iph;
2001         struct icmp6hdr _icmph;
2002
2003         if (likely(outer_iph->nexthdr != IPPROTO_ICMPV6))
2004                 goto out;
2005
2006         icmph = skb_header_pointer(skb, skb_transport_offset(skb),
2007                                    sizeof(_icmph), &_icmph);
2008         if (!icmph)
2009                 goto out;
2010
2011         if (icmph->icmp6_type != ICMPV6_DEST_UNREACH &&
2012             icmph->icmp6_type != ICMPV6_PKT_TOOBIG &&
2013             icmph->icmp6_type != ICMPV6_TIME_EXCEED &&
2014             icmph->icmp6_type != ICMPV6_PARAMPROB)
2015                 goto out;
2016
2017         inner_iph = skb_header_pointer(skb,
2018                                        skb_transport_offset(skb) + sizeof(*icmph),
2019                                        sizeof(_inner_iph), &_inner_iph);
2020         if (!inner_iph)
2021                 goto out;
2022
2023         key_iph = inner_iph;
2024         _flkeys = NULL;
2025 out:
2026         if (_flkeys) {
2027                 keys->addrs.v6addrs.src = _flkeys->addrs.v6addrs.src;
2028                 keys->addrs.v6addrs.dst = _flkeys->addrs.v6addrs.dst;
2029                 keys->tags.flow_label = _flkeys->tags.flow_label;
2030                 keys->basic.ip_proto = _flkeys->basic.ip_proto;
2031         } else {
2032                 keys->addrs.v6addrs.src = key_iph->saddr;
2033                 keys->addrs.v6addrs.dst = key_iph->daddr;
2034                 keys->tags.flow_label = ip6_flowlabel(key_iph);
2035                 keys->basic.ip_proto = key_iph->nexthdr;
2036         }
2037 }
2038
2039 /* if skb is set it will be used and fl6 can be NULL */
2040 u32 rt6_multipath_hash(const struct net *net, const struct flowi6 *fl6,
2041                        const struct sk_buff *skb, struct flow_keys *flkeys)
2042 {
2043         struct flow_keys hash_keys;
2044         u32 mhash;
2045
2046         switch (ip6_multipath_hash_policy(net)) {
2047         case 0:
2048                 memset(&hash_keys, 0, sizeof(hash_keys));
2049                 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
2050                 if (skb) {
2051                         ip6_multipath_l3_keys(skb, &hash_keys, flkeys);
2052                 } else {
2053                         hash_keys.addrs.v6addrs.src = fl6->saddr;
2054                         hash_keys.addrs.v6addrs.dst = fl6->daddr;
2055                         hash_keys.tags.flow_label = (__force u32)flowi6_get_flowlabel(fl6);
2056                         hash_keys.basic.ip_proto = fl6->flowi6_proto;
2057                 }
2058                 break;
2059         case 1:
2060                 if (skb) {
2061                         unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
2062                         struct flow_keys keys;
2063
2064                         /* short-circuit if we already have L4 hash present */
2065                         if (skb->l4_hash)
2066                                 return skb_get_hash_raw(skb) >> 1;
2067
2068                         memset(&hash_keys, 0, sizeof(hash_keys));
2069
2070                         if (!flkeys) {
2071                                 skb_flow_dissect_flow_keys(skb, &keys, flag);
2072                                 flkeys = &keys;
2073                         }
2074                         hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
2075                         hash_keys.addrs.v6addrs.src = flkeys->addrs.v6addrs.src;
2076                         hash_keys.addrs.v6addrs.dst = flkeys->addrs.v6addrs.dst;
2077                         hash_keys.ports.src = flkeys->ports.src;
2078                         hash_keys.ports.dst = flkeys->ports.dst;
2079                         hash_keys.basic.ip_proto = flkeys->basic.ip_proto;
2080                 } else {
2081                         memset(&hash_keys, 0, sizeof(hash_keys));
2082                         hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
2083                         hash_keys.addrs.v6addrs.src = fl6->saddr;
2084                         hash_keys.addrs.v6addrs.dst = fl6->daddr;
2085                         hash_keys.ports.src = fl6->fl6_sport;
2086                         hash_keys.ports.dst = fl6->fl6_dport;
2087                         hash_keys.basic.ip_proto = fl6->flowi6_proto;
2088                 }
2089                 break;
2090         }
2091         mhash = flow_hash_from_keys(&hash_keys);
2092
2093         return mhash >> 1;
2094 }
2095
2096 void ip6_route_input(struct sk_buff *skb)
2097 {
2098         const struct ipv6hdr *iph = ipv6_hdr(skb);
2099         struct net *net = dev_net(skb->dev);
2100         int flags = RT6_LOOKUP_F_HAS_SADDR;
2101         struct ip_tunnel_info *tun_info;
2102         struct flowi6 fl6 = {
2103                 .flowi6_iif = skb->dev->ifindex,
2104                 .daddr = iph->daddr,
2105                 .saddr = iph->saddr,
2106                 .flowlabel = ip6_flowinfo(iph),
2107                 .flowi6_mark = skb->mark,
2108                 .flowi6_proto = iph->nexthdr,
2109         };
2110         struct flow_keys *flkeys = NULL, _flkeys;
2111
2112         tun_info = skb_tunnel_info(skb);
2113         if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
2114                 fl6.flowi6_tun_key.tun_id = tun_info->key.tun_id;
2115
2116         if (fib6_rules_early_flow_dissect(net, skb, &fl6, &_flkeys))
2117                 flkeys = &_flkeys;
2118
2119         if (unlikely(fl6.flowi6_proto == IPPROTO_ICMPV6))
2120                 fl6.mp_hash = rt6_multipath_hash(net, &fl6, skb, flkeys);
2121         skb_dst_drop(skb);
2122         skb_dst_set(skb,
2123                     ip6_route_input_lookup(net, skb->dev, &fl6, skb, flags));
2124 }
2125
2126 static struct rt6_info *ip6_pol_route_output(struct net *net,
2127                                              struct fib6_table *table,
2128                                              struct flowi6 *fl6,
2129                                              const struct sk_buff *skb,
2130                                              int flags)
2131 {
2132         return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, skb, flags);
2133 }
2134
2135 struct dst_entry *ip6_route_output_flags(struct net *net, const struct sock *sk,
2136                                          struct flowi6 *fl6, int flags)
2137 {
2138         bool any_src;
2139
2140         if (ipv6_addr_type(&fl6->daddr) &
2141             (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL)) {
2142                 struct dst_entry *dst;
2143
2144                 dst = l3mdev_link_scope_lookup(net, fl6);
2145                 if (dst)
2146                         return dst;
2147         }
2148
2149         fl6->flowi6_iif = LOOPBACK_IFINDEX;
2150
2151         any_src = ipv6_addr_any(&fl6->saddr);
2152         if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr) ||
2153             (fl6->flowi6_oif && any_src))
2154                 flags |= RT6_LOOKUP_F_IFACE;
2155
2156         if (!any_src)
2157                 flags |= RT6_LOOKUP_F_HAS_SADDR;
2158         else if (sk)
2159                 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
2160
2161         return fib6_rule_lookup(net, fl6, NULL, flags, ip6_pol_route_output);
2162 }
2163 EXPORT_SYMBOL_GPL(ip6_route_output_flags);
2164
2165 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2166 {
2167         struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
2168         struct net_device *loopback_dev = net->loopback_dev;
2169         struct dst_entry *new = NULL;
2170
2171         rt = dst_alloc(&ip6_dst_blackhole_ops, loopback_dev, 1,
2172                        DST_OBSOLETE_DEAD, 0);
2173         if (rt) {
2174                 rt6_info_init(rt);
2175                 atomic_inc(&net->ipv6.rt6_stats->fib_rt_alloc);
2176
2177                 new = &rt->dst;
2178                 new->__use = 1;
2179                 new->input = dst_discard;
2180                 new->output = dst_discard_out;
2181
2182                 dst_copy_metrics(new, &ort->dst);
2183
2184                 rt->rt6i_idev = in6_dev_get(loopback_dev);
2185                 rt->rt6i_gateway = ort->rt6i_gateway;
2186                 rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;
2187
2188                 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
2189 #ifdef CONFIG_IPV6_SUBTREES
2190                 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
2191 #endif
2192         }
2193
2194         dst_release(dst_orig);
2195         return new ? new : ERR_PTR(-ENOMEM);
2196 }
2197
2198 /*
2199  *      Destination cache support functions
2200  */
2201
2202 static bool fib6_check(struct fib6_info *f6i, u32 cookie)
2203 {
2204         u32 rt_cookie = 0;
2205
2206         if (!fib6_get_cookie_safe(f6i, &rt_cookie) || rt_cookie != cookie)
2207                 return false;
2208
2209         if (fib6_check_expired(f6i))
2210                 return false;
2211
2212         return true;
2213 }
2214
2215 static struct dst_entry *rt6_check(struct rt6_info *rt,
2216                                    struct fib6_info *from,
2217                                    u32 cookie)
2218 {
2219         u32 rt_cookie = 0;
2220
2221         if ((from && !fib6_get_cookie_safe(from, &rt_cookie)) ||
2222             rt_cookie != cookie)
2223                 return NULL;
2224
2225         if (rt6_check_expired(rt))
2226                 return NULL;
2227
2228         return &rt->dst;
2229 }
2230
2231 static struct dst_entry *rt6_dst_from_check(struct rt6_info *rt,
2232                                             struct fib6_info *from,
2233                                             u32 cookie)
2234 {
2235         if (!__rt6_check_expired(rt) &&
2236             rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
2237             fib6_check(from, cookie))
2238                 return &rt->dst;
2239         else
2240                 return NULL;
2241 }
2242
2243 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
2244 {
2245         struct dst_entry *dst_ret;
2246         struct fib6_info *from;
2247         struct rt6_info *rt;
2248
2249         rt = container_of(dst, struct rt6_info, dst);
2250
2251         rcu_read_lock();
2252
2253         /* All IPV6 dsts are created with ->obsolete set to the value
2254          * DST_OBSOLETE_FORCE_CHK which forces validation calls down
2255          * into this function always.
2256          */
2257
2258         from = rcu_dereference(rt->from);
2259
2260         if (from && (rt->rt6i_flags & RTF_PCPU ||
2261             unlikely(!list_empty(&rt->rt6i_uncached))))
2262                 dst_ret = rt6_dst_from_check(rt, from, cookie);
2263         else
2264                 dst_ret = rt6_check(rt, from, cookie);
2265
2266         rcu_read_unlock();
2267
2268         return dst_ret;
2269 }
2270
2271 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
2272 {
2273         struct rt6_info *rt = (struct rt6_info *) dst;
2274
2275         if (rt) {
2276                 if (rt->rt6i_flags & RTF_CACHE) {
2277                         rcu_read_lock();
2278                         if (rt6_check_expired(rt)) {
2279                                 rt6_remove_exception_rt(rt);
2280                                 dst = NULL;
2281                         }
2282                         rcu_read_unlock();
2283                 } else {
2284                         dst_release(dst);
2285                         dst = NULL;
2286                 }
2287         }
2288         return dst;
2289 }
2290
2291 static void ip6_link_failure(struct sk_buff *skb)
2292 {
2293         struct rt6_info *rt;
2294
2295         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
2296
2297         rt = (struct rt6_info *) skb_dst(skb);
2298         if (rt) {
2299                 rcu_read_lock();
2300                 if (rt->rt6i_flags & RTF_CACHE) {
2301                         rt6_remove_exception_rt(rt);
2302                 } else {
2303                         struct fib6_info *from;
2304                         struct fib6_node *fn;
2305
2306                         from = rcu_dereference(rt->from);
2307                         if (from) {
2308                                 fn = rcu_dereference(from->fib6_node);
2309                                 if (fn && (rt->rt6i_flags & RTF_DEFAULT))
2310                                         fn->fn_sernum = -1;
2311                         }
2312                 }
2313                 rcu_read_unlock();
2314         }
2315 }
2316
2317 static void rt6_update_expires(struct rt6_info *rt0, int timeout)
2318 {
2319         if (!(rt0->rt6i_flags & RTF_EXPIRES)) {
2320                 struct fib6_info *from;
2321
2322                 rcu_read_lock();
2323                 from = rcu_dereference(rt0->from);
2324                 if (from)
2325                         rt0->dst.expires = from->expires;
2326                 rcu_read_unlock();
2327         }
2328
2329         dst_set_expires(&rt0->dst, timeout);
2330         rt0->rt6i_flags |= RTF_EXPIRES;
2331 }
2332
2333 static void rt6_do_update_pmtu(struct rt6_info *rt, u32 mtu)
2334 {
2335         struct net *net = dev_net(rt->dst.dev);
2336
2337         dst_metric_set(&rt->dst, RTAX_MTU, mtu);
2338         rt->rt6i_flags |= RTF_MODIFIED;
2339         rt6_update_expires(rt, net->ipv6.sysctl.ip6_rt_mtu_expires);
2340 }
2341
2342 static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
2343 {
2344         return !(rt->rt6i_flags & RTF_CACHE) &&
2345                 (rt->rt6i_flags & RTF_PCPU || rcu_access_pointer(rt->from));
2346 }
2347
2348 static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,
2349                                  const struct ipv6hdr *iph, u32 mtu)
2350 {
2351         const struct in6_addr *daddr, *saddr;
2352         struct rt6_info *rt6 = (struct rt6_info *)dst;
2353
2354         if (dst_metric_locked(dst, RTAX_MTU))
2355                 return;
2356
2357         if (iph) {
2358                 daddr = &iph->daddr;
2359                 saddr = &iph->saddr;
2360         } else if (sk) {
2361                 daddr = &sk->sk_v6_daddr;
2362                 saddr = &inet6_sk(sk)->saddr;
2363         } else {
2364                 daddr = NULL;
2365                 saddr = NULL;
2366         }
2367         dst_confirm_neigh(dst, daddr);
2368         mtu = max_t(u32, mtu, IPV6_MIN_MTU);
2369         if (mtu >= dst_mtu(dst))
2370                 return;
2371
2372         if (!rt6_cache_allowed_for_pmtu(rt6)) {
2373                 rt6_do_update_pmtu(rt6, mtu);
2374                 /* update rt6_ex->stamp for cache */
2375                 if (rt6->rt6i_flags & RTF_CACHE)
2376                         rt6_update_exception_stamp_rt(rt6);
2377         } else if (daddr) {
2378                 struct fib6_result res = {};
2379                 struct rt6_info *nrt6;
2380
2381                 rcu_read_lock();
2382                 res.f6i = rcu_dereference(rt6->from);
2383                 if (!res.f6i) {
2384                         rcu_read_unlock();
2385                         return;
2386                 }
2387                 res.nh = &res.f6i->fib6_nh;
2388                 res.fib6_flags = res.f6i->fib6_flags;
2389                 res.fib6_type = res.f6i->fib6_type;
2390
2391                 nrt6 = ip6_rt_cache_alloc(&res, daddr, saddr);
2392                 if (nrt6) {
2393                         rt6_do_update_pmtu(nrt6, mtu);
2394                         if (rt6_insert_exception(nrt6, &res))
2395                                 dst_release_immediate(&nrt6->dst);
2396                 }
2397                 rcu_read_unlock();
2398         }
2399 }
2400
2401 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
2402                                struct sk_buff *skb, u32 mtu)
2403 {
2404         __ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
2405 }
2406
2407 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
2408                      int oif, u32 mark, kuid_t uid)
2409 {
2410         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
2411         struct dst_entry *dst;
2412         struct flowi6 fl6 = {
2413                 .flowi6_oif = oif,
2414                 .flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark),
2415                 .daddr = iph->daddr,
2416                 .saddr = iph->saddr,
2417                 .flowlabel = ip6_flowinfo(iph),
2418                 .flowi6_uid = uid,
2419         };
2420
2421         dst = ip6_route_output(net, NULL, &fl6);
2422         if (!dst->error)
2423                 __ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
2424         dst_release(dst);
2425 }
2426 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
2427
2428 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
2429 {
2430         int oif = sk->sk_bound_dev_if;
2431         struct dst_entry *dst;
2432
2433         if (!oif && skb->dev)
2434                 oif = l3mdev_master_ifindex(skb->dev);
2435
2436         ip6_update_pmtu(skb, sock_net(sk), mtu, oif, sk->sk_mark, sk->sk_uid);
2437
2438         dst = __sk_dst_get(sk);
2439         if (!dst || !dst->obsolete ||
2440             dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
2441                 return;
2442
2443         bh_lock_sock(sk);
2444         if (!sock_owned_by_user(sk) && !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
2445                 ip6_datagram_dst_update(sk, false);
2446         bh_unlock_sock(sk);
2447 }
2448 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
2449
2450 void ip6_sk_dst_store_flow(struct sock *sk, struct dst_entry *dst,
2451                            const struct flowi6 *fl6)
2452 {
2453 #ifdef CONFIG_IPV6_SUBTREES
2454         struct ipv6_pinfo *np = inet6_sk(sk);
2455 #endif
2456
2457         ip6_dst_store(sk, dst,
2458                       ipv6_addr_equal(&fl6->daddr, &sk->sk_v6_daddr) ?
2459                       &sk->sk_v6_daddr : NULL,
2460 #ifdef CONFIG_IPV6_SUBTREES
2461                       ipv6_addr_equal(&fl6->saddr, &np->saddr) ?
2462                       &np->saddr :
2463 #endif
2464                       NULL);
2465 }
2466
2467 static bool ip6_redirect_nh_match(const struct fib6_result *res,
2468                                   struct flowi6 *fl6,
2469                                   const struct in6_addr *gw,
2470                                   struct rt6_info **ret)
2471 {
2472         const struct fib6_nh *nh = res->nh;
2473
2474         if (nh->fib_nh_flags & RTNH_F_DEAD || !nh->fib_nh_gw_family ||
2475             fl6->flowi6_oif != nh->fib_nh_dev->ifindex)
2476                 return false;
2477
2478         /* rt_cache's gateway might be different from its 'parent'
2479          * in the case of an ip redirect.
2480          * So we keep searching in the exception table if the gateway
2481          * is different.
2482          */
2483         if (!ipv6_addr_equal(gw, &nh->fib_nh_gw6)) {
2484                 struct rt6_info *rt_cache;
2485
2486                 rt_cache = rt6_find_cached_rt(res, &fl6->daddr, &fl6->saddr);
2487                 if (rt_cache &&
2488                     ipv6_addr_equal(gw, &rt_cache->rt6i_gateway)) {
2489                         *ret = rt_cache;
2490                         return true;
2491                 }
2492                 return false;
2493         }
2494         return true;
2495 }
2496
2497 /* Handle redirects */
2498 struct ip6rd_flowi {
2499         struct flowi6 fl6;
2500         struct in6_addr gateway;
2501 };
2502
2503 static struct rt6_info *__ip6_route_redirect(struct net *net,
2504                                              struct fib6_table *table,
2505                                              struct flowi6 *fl6,
2506                                              const struct sk_buff *skb,
2507                                              int flags)
2508 {
2509         struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
2510         struct rt6_info *ret = NULL;
2511         struct fib6_result res = {};
2512         struct fib6_info *rt;
2513         struct fib6_node *fn;
2514
2515         /* Get the "current" route for this destination and
2516          * check if the redirect has come from appropriate router.
2517          *
2518          * RFC 4861 specifies that redirects should only be
2519          * accepted if they come from the nexthop to the target.
2520          * Due to the way the routes are chosen, this notion
2521          * is a bit fuzzy and one might need to check all possible
2522          * routes.
2523          */
2524
2525         rcu_read_lock();
2526         fn = fib6_node_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
2527 restart:
2528         for_each_fib6_node_rt_rcu(fn) {
2529                 res.f6i = rt;
2530                 res.nh = &rt->fib6_nh;
2531
2532                 if (fib6_check_expired(rt))
2533                         continue;
2534                 if (rt->fib6_flags & RTF_REJECT)
2535                         break;
2536                 if (ip6_redirect_nh_match(&res, fl6, &rdfl->gateway, &ret))
2537                         goto out;
2538         }
2539
2540         if (!rt)
2541                 rt = net->ipv6.fib6_null_entry;
2542         else if (rt->fib6_flags & RTF_REJECT) {
2543                 ret = net->ipv6.ip6_null_entry;
2544                 goto out;
2545         }
2546
2547         if (rt == net->ipv6.fib6_null_entry) {
2548                 fn = fib6_backtrack(fn, &fl6->saddr);
2549                 if (fn)
2550                         goto restart;
2551         }
2552
2553         res.f6i = rt;
2554         res.nh = &rt->fib6_nh;
2555 out:
2556         if (ret) {
2557                 ip6_hold_safe(net, &ret);
2558         } else {
2559                 res.fib6_flags = res.f6i->fib6_flags;
2560                 res.fib6_type = res.f6i->fib6_type;
2561                 ret = ip6_create_rt_rcu(&res);
2562         }
2563
2564         rcu_read_unlock();
2565
2566         trace_fib6_table_lookup(net, &res, table, fl6);
2567         return ret;
2568 };
2569
2570 static struct dst_entry *ip6_route_redirect(struct net *net,
2571                                             const struct flowi6 *fl6,
2572                                             const struct sk_buff *skb,
2573                                             const struct in6_addr *gateway)
2574 {
2575         int flags = RT6_LOOKUP_F_HAS_SADDR;
2576         struct ip6rd_flowi rdfl;
2577
2578         rdfl.fl6 = *fl6;
2579         rdfl.gateway = *gateway;
2580
2581         return fib6_rule_lookup(net, &rdfl.fl6, skb,
2582                                 flags, __ip6_route_redirect);
2583 }
2584
2585 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark,
2586                   kuid_t uid)
2587 {
2588         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
2589         struct dst_entry *dst;
2590         struct flowi6 fl6 = {
2591                 .flowi6_iif = LOOPBACK_IFINDEX,
2592                 .flowi6_oif = oif,
2593                 .flowi6_mark = mark,
2594                 .daddr = iph->daddr,
2595                 .saddr = iph->saddr,
2596                 .flowlabel = ip6_flowinfo(iph),
2597                 .flowi6_uid = uid,
2598         };
2599
2600         dst = ip6_route_redirect(net, &fl6, skb, &ipv6_hdr(skb)->saddr);
2601         rt6_do_redirect(dst, NULL, skb);
2602         dst_release(dst);
2603 }
2604 EXPORT_SYMBOL_GPL(ip6_redirect);
2605
2606 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif)
2607 {
2608         const struct ipv6hdr *iph = ipv6_hdr(skb);
2609         const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
2610         struct dst_entry *dst;
2611         struct flowi6 fl6 = {
2612                 .flowi6_iif = LOOPBACK_IFINDEX,
2613                 .flowi6_oif = oif,
2614                 .daddr = msg->dest,
2615                 .saddr = iph->daddr,
2616                 .flowi6_uid = sock_net_uid(net, NULL),
2617         };
2618
2619         dst = ip6_route_redirect(net, &fl6, skb, &iph->saddr);
2620         rt6_do_redirect(dst, NULL, skb);
2621         dst_release(dst);
2622 }
2623
2624 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
2625 {
2626         ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark,
2627                      sk->sk_uid);
2628 }
2629 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
2630
2631 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
2632 {
2633         struct net_device *dev = dst->dev;
2634         unsigned int mtu = dst_mtu(dst);
2635         struct net *net = dev_net(dev);
2636
2637         mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
2638
2639         if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
2640                 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
2641
2642         /*
2643          * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
2644          * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
2645          * IPV6_MAXPLEN is also valid and means: "any MSS,
2646          * rely only on pmtu discovery"
2647          */
2648         if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
2649                 mtu = IPV6_MAXPLEN;
2650         return mtu;
2651 }
2652
2653 static unsigned int ip6_mtu(const struct dst_entry *dst)
2654 {
2655         struct inet6_dev *idev;
2656         unsigned int mtu;
2657
2658         mtu = dst_metric_raw(dst, RTAX_MTU);
2659         if (mtu)
2660                 goto out;
2661
2662         mtu = IPV6_MIN_MTU;
2663
2664         rcu_read_lock();
2665         idev = __in6_dev_get(dst->dev);
2666         if (idev)
2667                 mtu = idev->cnf.mtu6;
2668         rcu_read_unlock();
2669
2670 out:
2671         mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
2672
2673         return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
2674 }
2675
2676 /* MTU selection:
2677  * 1. mtu on route is locked - use it
2678  * 2. mtu from nexthop exception
2679  * 3. mtu from egress device
2680  *
2681  * based on ip6_dst_mtu_forward and exception logic of
2682  * rt6_find_cached_rt; called with rcu_read_lock
2683  */
2684 u32 ip6_mtu_from_fib6(const struct fib6_result *res,
2685                       const struct in6_addr *daddr,
2686                       const struct in6_addr *saddr)
2687 {
2688         const struct fib6_nh *nh = res->nh;
2689         struct fib6_info *f6i = res->f6i;
2690         struct inet6_dev *idev;
2691         struct rt6_info *rt;
2692         u32 mtu = 0;
2693
2694         if (unlikely(fib6_metric_locked(f6i, RTAX_MTU))) {
2695                 mtu = f6i->fib6_pmtu;
2696                 if (mtu)
2697                         goto out;
2698         }
2699
2700         rt = rt6_find_cached_rt(res, daddr, saddr);
2701         if (unlikely(rt)) {
2702                 mtu = dst_metric_raw(&rt->dst, RTAX_MTU);
2703         } else {
2704                 struct net_device *dev = nh->fib_nh_dev;
2705
2706                 mtu = IPV6_MIN_MTU;
2707                 idev = __in6_dev_get(dev);
2708                 if (idev && idev->cnf.mtu6 > mtu)
2709                         mtu = idev->cnf.mtu6;
2710         }
2711
2712         mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
2713 out:
2714         return mtu - lwtunnel_headroom(nh->fib_nh_lws, mtu);
2715 }
2716
2717 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
2718                                   struct flowi6 *fl6)
2719 {
2720         struct dst_entry *dst;
2721         struct rt6_info *rt;
2722         struct inet6_dev *idev = in6_dev_get(dev);
2723         struct net *net = dev_net(dev);
2724
2725         if (unlikely(!idev))
2726                 return ERR_PTR(-ENODEV);
2727
2728         rt = ip6_dst_alloc(net, dev, 0);
2729         if (unlikely(!rt)) {
2730                 in6_dev_put(idev);
2731                 dst = ERR_PTR(-ENOMEM);
2732                 goto out;
2733         }
2734
2735         rt->dst.flags |= DST_HOST;
2736         rt->dst.input = ip6_input;
2737         rt->dst.output  = ip6_output;
2738         rt->rt6i_gateway  = fl6->daddr;
2739         rt->rt6i_dst.addr = fl6->daddr;
2740         rt->rt6i_dst.plen = 128;
2741         rt->rt6i_idev     = idev;
2742         dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
2743
2744         /* Add this dst into uncached_list so that rt6_disable_ip() can
2745          * do proper release of the net_device
2746          */
2747         rt6_uncached_list_add(rt);
2748         atomic_inc(&net->ipv6.rt6_stats->fib_rt_uncache);
2749
2750         dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
2751
2752 out:
2753         return dst;
2754 }
2755
2756 static int ip6_dst_gc(struct dst_ops *ops)
2757 {
2758         struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
2759         int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
2760         int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
2761         int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
2762         int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
2763         unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
2764         int entries;
2765
2766         entries = dst_entries_get_fast(ops);
2767         if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
2768             entries <= rt_max_size)
2769                 goto out;
2770
2771         net->ipv6.ip6_rt_gc_expire++;
2772         fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
2773         entries = dst_entries_get_slow(ops);
2774         if (entries < ops->gc_thresh)
2775                 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
2776 out:
2777         net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
2778         return entries > rt_max_size;
2779 }
2780
2781 static struct rt6_info *ip6_nh_lookup_table(struct net *net,
2782                                             struct fib6_config *cfg,
2783                                             const struct in6_addr *gw_addr,
2784                                             u32 tbid, int flags)
2785 {
2786         struct flowi6 fl6 = {
2787                 .flowi6_oif = cfg->fc_ifindex,
2788                 .daddr = *gw_addr,
2789                 .saddr = cfg->fc_prefsrc,
2790         };
2791         struct fib6_table *table;
2792         struct rt6_info *rt;
2793
2794         table = fib6_get_table(net, tbid);
2795         if (!table)
2796                 return NULL;
2797
2798         if (!ipv6_addr_any(&cfg->fc_prefsrc))
2799                 flags |= RT6_LOOKUP_F_HAS_SADDR;
2800
2801         flags |= RT6_LOOKUP_F_IGNORE_LINKSTATE;
2802         rt = ip6_pol_route(net, table, cfg->fc_ifindex, &fl6, NULL, flags);
2803
2804         /* if table lookup failed, fall back to full lookup */
2805         if (rt == net->ipv6.ip6_null_entry) {
2806                 ip6_rt_put(rt);
2807                 rt = NULL;
2808         }
2809
2810         return rt;
2811 }
2812
2813 static int ip6_route_check_nh_onlink(struct net *net,
2814                                      struct fib6_config *cfg,
2815                                      const struct net_device *dev,
2816                                      struct netlink_ext_ack *extack)
2817 {
2818         u32 tbid = l3mdev_fib_table(dev) ? : RT_TABLE_MAIN;
2819         const struct in6_addr *gw_addr = &cfg->fc_gateway;
2820         u32 flags = RTF_LOCAL | RTF_ANYCAST | RTF_REJECT;
2821         struct fib6_info *from;
2822         struct rt6_info *grt;
2823         int err;
2824
2825         err = 0;
2826         grt = ip6_nh_lookup_table(net, cfg, gw_addr, tbid, 0);
2827         if (grt) {
2828                 rcu_read_lock();
2829                 from = rcu_dereference(grt->from);
2830                 if (!grt->dst.error &&
2831                     /* ignore match if it is the default route */
2832                     from && !ipv6_addr_any(&from->fib6_dst.addr) &&
2833                     (grt->rt6i_flags & flags || dev != grt->dst.dev)) {
2834                         NL_SET_ERR_MSG(extack,
2835                                        "Nexthop has invalid gateway or device mismatch");
2836                         err = -EINVAL;
2837                 }
2838                 rcu_read_unlock();
2839
2840                 ip6_rt_put(grt);
2841         }
2842
2843         return err;
2844 }
2845
2846 static int ip6_route_check_nh(struct net *net,
2847                               struct fib6_config *cfg,
2848                               struct net_device **_dev,
2849                               struct inet6_dev **idev)
2850 {
2851         const struct in6_addr *gw_addr = &cfg->fc_gateway;
2852         struct net_device *dev = _dev ? *_dev : NULL;
2853         struct rt6_info *grt = NULL;
2854         int err = -EHOSTUNREACH;
2855
2856         if (cfg->fc_table) {
2857                 int flags = RT6_LOOKUP_F_IFACE;
2858
2859                 grt = ip6_nh_lookup_table(net, cfg, gw_addr,
2860                                           cfg->fc_table, flags);
2861                 if (grt) {
2862                         if (grt->rt6i_flags & RTF_GATEWAY ||
2863                             (dev && dev != grt->dst.dev)) {
2864                                 ip6_rt_put(grt);
2865                                 grt = NULL;
2866                         }
2867                 }
2868         }
2869
2870         if (!grt)
2871                 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, NULL, 1);
2872
2873         if (!grt)
2874                 goto out;
2875
2876         if (dev) {
2877                 if (dev != grt->dst.dev) {
2878                         ip6_rt_put(grt);
2879                         goto out;
2880                 }
2881         } else {
2882                 *_dev = dev = grt->dst.dev;
2883                 *idev = grt->rt6i_idev;
2884                 dev_hold(dev);
2885                 in6_dev_hold(grt->rt6i_idev);
2886         }
2887
2888         if (!(grt->rt6i_flags & RTF_GATEWAY))
2889                 err = 0;
2890
2891         ip6_rt_put(grt);
2892
2893 out:
2894         return err;
2895 }
2896
2897 static int ip6_validate_gw(struct net *net, struct fib6_config *cfg,
2898                            struct net_device **_dev, struct inet6_dev **idev,
2899                            struct netlink_ext_ack *extack)
2900 {
2901         const struct in6_addr *gw_addr = &cfg->fc_gateway;
2902         int gwa_type = ipv6_addr_type(gw_addr);
2903         bool skip_dev = gwa_type & IPV6_ADDR_LINKLOCAL ? false : true;
2904         const struct net_device *dev = *_dev;
2905         bool need_addr_check = !dev;
2906         int err = -EINVAL;
2907
2908         /* if gw_addr is local we will fail to detect this in case
2909          * address is still TENTATIVE (DAD in progress). rt6_lookup()
2910          * will return already-added prefix route via interface that
2911          * prefix route was assigned to, which might be non-loopback.
2912          */
2913         if (dev &&
2914             ipv6_chk_addr_and_flags(net, gw_addr, dev, skip_dev, 0, 0)) {
2915                 NL_SET_ERR_MSG(extack, "Gateway can not be a local address");
2916                 goto out;
2917         }
2918
2919         if (gwa_type != (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_UNICAST)) {
2920                 /* IPv6 strictly inhibits using not link-local
2921                  * addresses as nexthop address.
2922                  * Otherwise, router will not able to send redirects.
2923                  * It is very good, but in some (rare!) circumstances
2924                  * (SIT, PtP, NBMA NOARP links) it is handy to allow
2925                  * some exceptions. --ANK
2926                  * We allow IPv4-mapped nexthops to support RFC4798-type
2927                  * addressing
2928                  */
2929                 if (!(gwa_type & (IPV6_ADDR_UNICAST | IPV6_ADDR_MAPPED))) {
2930                         NL_SET_ERR_MSG(extack, "Invalid gateway address");
2931                         goto out;
2932                 }
2933
2934                 if (cfg->fc_flags & RTNH_F_ONLINK)
2935                         err = ip6_route_check_nh_onlink(net, cfg, dev, extack);
2936                 else
2937                         err = ip6_route_check_nh(net, cfg, _dev, idev);
2938
2939                 if (err)
2940                         goto out;
2941         }
2942
2943         /* reload in case device was changed */
2944         dev = *_dev;
2945
2946         err = -EINVAL;
2947         if (!dev) {
2948                 NL_SET_ERR_MSG(extack, "Egress device not specified");
2949                 goto out;
2950         } else if (dev->flags & IFF_LOOPBACK) {
2951                 NL_SET_ERR_MSG(extack,
2952                                "Egress device can not be loopback device for this route");
2953                 goto out;
2954         }
2955
2956         /* if we did not check gw_addr above, do so now that the
2957          * egress device has been resolved.
2958          */
2959         if (need_addr_check &&
2960             ipv6_chk_addr_and_flags(net, gw_addr, dev, skip_dev, 0, 0)) {
2961                 NL_SET_ERR_MSG(extack, "Gateway can not be a local address");
2962                 goto out;
2963         }
2964
2965         err = 0;
2966 out:
2967         return err;
2968 }
2969
2970 static bool fib6_is_reject(u32 flags, struct net_device *dev, int addr_type)
2971 {
2972         if ((flags & RTF_REJECT) ||
2973             (dev && (dev->flags & IFF_LOOPBACK) &&
2974              !(addr_type & IPV6_ADDR_LOOPBACK) &&
2975              !(flags & RTF_LOCAL)))
2976                 return true;
2977
2978         return false;
2979 }
2980
2981 int fib6_nh_init(struct net *net, struct fib6_nh *fib6_nh,
2982                  struct fib6_config *cfg, gfp_t gfp_flags,
2983                  struct netlink_ext_ack *extack)
2984 {
2985         struct net_device *dev = NULL;
2986         struct inet6_dev *idev = NULL;
2987         int addr_type;
2988         int err;
2989
2990         fib6_nh->fib_nh_family = AF_INET6;
2991
2992         err = -ENODEV;
2993         if (cfg->fc_ifindex) {
2994                 dev = dev_get_by_index(net, cfg->fc_ifindex);
2995                 if (!dev)
2996                         goto out;
2997                 idev = in6_dev_get(dev);
2998                 if (!idev)
2999                         goto out;
3000         }
3001
3002         if (cfg->fc_flags & RTNH_F_ONLINK) {
3003                 if (!dev) {
3004                         NL_SET_ERR_MSG(extack,
3005                                        "Nexthop device required for onlink");
3006                         goto out;
3007                 }
3008
3009                 if (!(dev->flags & IFF_UP)) {
3010                         NL_SET_ERR_MSG(extack, "Nexthop device is not up");
3011                         err = -ENETDOWN;
3012                         goto out;
3013                 }
3014
3015                 fib6_nh->fib_nh_flags |= RTNH_F_ONLINK;
3016         }
3017
3018         fib6_nh->fib_nh_weight = 1;
3019
3020         /* We cannot add true routes via loopback here,
3021          * they would result in kernel looping; promote them to reject routes
3022          */
3023         addr_type = ipv6_addr_type(&cfg->fc_dst);
3024         if (fib6_is_reject(cfg->fc_flags, dev, addr_type)) {
3025                 /* hold loopback dev/idev if we haven't done so. */
3026                 if (dev != net->loopback_dev) {
3027                         if (dev) {
3028                                 dev_put(dev);
3029                                 in6_dev_put(idev);
3030                         }
3031                         dev = net->loopback_dev;
3032                         dev_hold(dev);
3033                         idev = in6_dev_get(dev);
3034                         if (!idev) {
3035                                 err = -ENODEV;
3036                                 goto out;
3037                         }
3038                 }
3039                 goto set_dev;
3040         }
3041
3042         if (cfg->fc_flags & RTF_GATEWAY) {
3043                 err = ip6_validate_gw(net, cfg, &dev, &idev, extack);
3044                 if (err)
3045                         goto out;
3046
3047                 fib6_nh->fib_nh_gw6 = cfg->fc_gateway;
3048                 fib6_nh->fib_nh_gw_family = AF_INET6;
3049         }
3050
3051         err = -ENODEV;
3052         if (!dev)
3053                 goto out;
3054
3055         if (idev->cnf.disable_ipv6) {
3056                 NL_SET_ERR_MSG(extack, "IPv6 is disabled on nexthop device");
3057                 err = -EACCES;
3058                 goto out;
3059         }
3060
3061         if (!(dev->flags & IFF_UP) && !cfg->fc_ignore_dev_down) {
3062                 NL_SET_ERR_MSG(extack, "Nexthop device is not up");
3063                 err = -ENETDOWN;
3064                 goto out;
3065         }
3066
3067         if (!(cfg->fc_flags & (RTF_LOCAL | RTF_ANYCAST)) &&
3068             !netif_carrier_ok(dev))
3069                 fib6_nh->fib_nh_flags |= RTNH_F_LINKDOWN;
3070
3071         err = fib_nh_common_init(&fib6_nh->nh_common, cfg->fc_encap,
3072                                  cfg->fc_encap_type, cfg, gfp_flags, extack);
3073         if (err)
3074                 goto out;
3075 set_dev:
3076         fib6_nh->fib_nh_dev = dev;
3077         fib6_nh->fib_nh_oif = dev->ifindex;
3078         err = 0;
3079 out:
3080         if (idev)
3081                 in6_dev_put(idev);
3082
3083         if (err) {
3084                 lwtstate_put(fib6_nh->fib_nh_lws);
3085                 fib6_nh->fib_nh_lws = NULL;
3086                 if (dev)
3087                         dev_put(dev);
3088         }
3089
3090         return err;
3091 }
3092
3093 void fib6_nh_release(struct fib6_nh *fib6_nh)
3094 {
3095         fib_nh_common_release(&fib6_nh->nh_common);
3096 }
3097
3098 static struct fib6_info *ip6_route_info_create(struct fib6_config *cfg,
3099                                               gfp_t gfp_flags,
3100                                               struct netlink_ext_ack *extack)
3101 {
3102         struct net *net = cfg->fc_nlinfo.nl_net;
3103         struct fib6_info *rt = NULL;
3104         struct fib6_table *table;
3105         int err = -EINVAL;
3106         int addr_type;
3107
3108         /* RTF_PCPU is an internal flag; can not be set by userspace */
3109         if (cfg->fc_flags & RTF_PCPU) {
3110                 NL_SET_ERR_MSG(extack, "Userspace can not set RTF_PCPU");
3111                 goto out;
3112         }
3113
3114         /* RTF_CACHE is an internal flag; can not be set by userspace */
3115         if (cfg->fc_flags & RTF_CACHE) {
3116                 NL_SET_ERR_MSG(extack, "Userspace can not set RTF_CACHE");
3117                 goto out;
3118         }
3119
3120         if (cfg->fc_type > RTN_MAX) {
3121                 NL_SET_ERR_MSG(extack, "Invalid route type");
3122                 goto out;
3123         }
3124
3125         if (cfg->fc_dst_len > 128) {
3126                 NL_SET_ERR_MSG(extack, "Invalid prefix length");
3127                 goto out;
3128         }
3129         if (cfg->fc_src_len > 128) {
3130                 NL_SET_ERR_MSG(extack, "Invalid source address length");
3131                 goto out;
3132         }
3133 #ifndef CONFIG_IPV6_SUBTREES
3134         if (cfg->fc_src_len) {
3135                 NL_SET_ERR_MSG(extack,
3136                                "Specifying source address requires IPV6_SUBTREES to be enabled");
3137                 goto out;
3138         }
3139 #endif
3140
3141         err = -ENOBUFS;
3142         if (cfg->fc_nlinfo.nlh &&
3143             !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
3144                 table = fib6_get_table(net, cfg->fc_table);
3145                 if (!table) {
3146                         pr_warn("NLM_F_CREATE should be specified when creating new route\n");
3147                         table = fib6_new_table(net, cfg->fc_table);
3148                 }
3149         } else {
3150                 table = fib6_new_table(net, cfg->fc_table);
3151         }
3152
3153         if (!table)
3154                 goto out;
3155
3156         err = -ENOMEM;
3157         rt = fib6_info_alloc(gfp_flags);
3158         if (!rt)
3159                 goto out;
3160
3161         rt->fib6_metrics = ip_fib_metrics_init(net, cfg->fc_mx, cfg->fc_mx_len,
3162                                                extack);
3163         if (IS_ERR(rt->fib6_metrics)) {
3164                 err = PTR_ERR(rt->fib6_metrics);
3165                 /* Do not leave garbage there. */
3166                 rt->fib6_metrics = (struct dst_metrics *)&dst_default_metrics;
3167                 goto out;
3168         }
3169
3170         if (cfg->fc_flags & RTF_ADDRCONF)
3171                 rt->dst_nocount = true;
3172
3173         if (cfg->fc_flags & RTF_EXPIRES)
3174                 fib6_set_expires(rt, jiffies +
3175                                 clock_t_to_jiffies(cfg->fc_expires));
3176         else
3177                 fib6_clean_expires(rt);
3178
3179         if (cfg->fc_protocol == RTPROT_UNSPEC)
3180                 cfg->fc_protocol = RTPROT_BOOT;
3181         rt->fib6_protocol = cfg->fc_protocol;
3182
3183         rt->fib6_table = table;
3184         rt->fib6_metric = cfg->fc_metric;
3185         rt->fib6_type = cfg->fc_type;
3186         rt->fib6_flags = cfg->fc_flags & ~RTF_GATEWAY;
3187
3188         ipv6_addr_prefix(&rt->fib6_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
3189         rt->fib6_dst.plen = cfg->fc_dst_len;
3190         if (rt->fib6_dst.plen == 128)
3191                 rt->dst_host = true;
3192
3193 #ifdef CONFIG_IPV6_SUBTREES
3194         ipv6_addr_prefix(&rt->fib6_src.addr, &cfg->fc_src, cfg->fc_src_len);
3195         rt->fib6_src.plen = cfg->fc_src_len;
3196 #endif
3197         err = fib6_nh_init(net, &rt->fib6_nh, cfg, gfp_flags, extack);
3198         if (err)
3199                 goto out;
3200
3201         /* We cannot add true routes via loopback here,
3202          * they would result in kernel looping; promote them to reject routes
3203          */
3204         addr_type = ipv6_addr_type(&cfg->fc_dst);
3205         if (fib6_is_reject(cfg->fc_flags, rt->fib6_nh.fib_nh_dev, addr_type))
3206                 rt->fib6_flags = RTF_REJECT | RTF_NONEXTHOP;
3207
3208         if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
3209                 struct net_device *dev = fib6_info_nh_dev(rt);
3210
3211                 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
3212                         NL_SET_ERR_MSG(extack, "Invalid source address");
3213                         err = -EINVAL;
3214                         goto out;
3215                 }
3216                 rt->fib6_prefsrc.addr = cfg->fc_prefsrc;
3217                 rt->fib6_prefsrc.plen = 128;
3218         } else
3219                 rt->fib6_prefsrc.plen = 0;
3220
3221         return rt;
3222 out:
3223         fib6_info_release(rt);
3224         return ERR_PTR(err);
3225 }
3226
3227 int ip6_route_add(struct fib6_config *cfg, gfp_t gfp_flags,
3228                   struct netlink_ext_ack *extack)
3229 {
3230         struct fib6_info *rt;
3231         int err;
3232
3233         rt = ip6_route_info_create(cfg, gfp_flags, extack);
3234         if (IS_ERR(rt))
3235                 return PTR_ERR(rt);
3236
3237         err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, extack);
3238         fib6_info_release(rt);
3239
3240         return err;
3241 }
3242
3243 static int __ip6_del_rt(struct fib6_info *rt, struct nl_info *info)
3244 {
3245         struct net *net = info->nl_net;
3246         struct fib6_table *table;
3247         int err;
3248
3249         if (rt == net->ipv6.fib6_null_entry) {
3250                 err = -ENOENT;
3251                 goto out;
3252         }
3253
3254         table = rt->fib6_table;
3255         spin_lock_bh(&table->tb6_lock);
3256         err = fib6_del(rt, info);
3257         spin_unlock_bh(&table->tb6_lock);
3258
3259 out:
3260         fib6_info_release(rt);
3261         return err;
3262 }
3263
3264 int ip6_del_rt(struct net *net, struct fib6_info *rt)
3265 {
3266         struct nl_info info = { .nl_net = net };
3267
3268         return __ip6_del_rt(rt, &info);
3269 }
3270
3271 static int __ip6_del_rt_siblings(struct fib6_info *rt, struct fib6_config *cfg)
3272 {
3273         struct nl_info *info = &cfg->fc_nlinfo;
3274         struct net *net = info->nl_net;
3275         struct sk_buff *skb = NULL;
3276         struct fib6_table *table;
3277         int err = -ENOENT;
3278
3279         if (rt == net->ipv6.fib6_null_entry)
3280                 goto out_put;
3281         table = rt->fib6_table;
3282         spin_lock_bh(&table->tb6_lock);
3283
3284         if (rt->fib6_nsiblings && cfg->fc_delete_all_nh) {
3285                 struct fib6_info *sibling, *next_sibling;
3286
3287                 /* prefer to send a single notification with all hops */
3288                 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
3289                 if (skb) {
3290                         u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
3291
3292                         if (rt6_fill_node(net, skb, rt, NULL,
3293                                           NULL, NULL, 0, RTM_DELROUTE,
3294                                           info->portid, seq, 0) < 0) {
3295                                 kfree_skb(skb);
3296                                 skb = NULL;
3297                         } else
3298                                 info->skip_notify = 1;
3299                 }
3300
3301                 list_for_each_entry_safe(sibling, next_sibling,
3302                                          &rt->fib6_siblings,
3303                                          fib6_siblings) {
3304                         err = fib6_del(sibling, info);
3305                         if (err)
3306                                 goto out_unlock;
3307                 }
3308         }
3309
3310         err = fib6_del(rt, info);
3311 out_unlock:
3312         spin_unlock_bh(&table->tb6_lock);
3313 out_put:
3314         fib6_info_release(rt);
3315
3316         if (skb) {
3317                 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
3318                             info->nlh, gfp_any());
3319         }
3320         return err;
3321 }
3322
3323 static int ip6_del_cached_rt(struct rt6_info *rt, struct fib6_config *cfg)
3324 {
3325         int rc = -ESRCH;
3326
3327         if (cfg->fc_ifindex && rt->dst.dev->ifindex != cfg->fc_ifindex)
3328                 goto out;
3329
3330         if (cfg->fc_flags & RTF_GATEWAY &&
3331             !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
3332                 goto out;
3333
3334         rc = rt6_remove_exception_rt(rt);
3335 out:
3336         return rc;
3337 }
3338
3339 static int ip6_route_del(struct fib6_config *cfg,
3340                          struct netlink_ext_ack *extack)
3341 {
3342         struct rt6_info *rt_cache;
3343         struct fib6_table *table;
3344         struct fib6_info *rt;
3345         struct fib6_node *fn;
3346         int err = -ESRCH;
3347
3348         table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
3349         if (!table) {
3350                 NL_SET_ERR_MSG(extack, "FIB table does not exist");
3351                 return err;
3352         }
3353
3354         rcu_read_lock();
3355
3356         fn = fib6_locate(&table->tb6_root,
3357                          &cfg->fc_dst, cfg->fc_dst_len,
3358                          &cfg->fc_src, cfg->fc_src_len,
3359                          !(cfg->fc_flags & RTF_CACHE));
3360
3361         if (fn) {
3362                 for_each_fib6_node_rt_rcu(fn) {
3363                         struct fib6_nh *nh;
3364
3365                         if (cfg->fc_flags & RTF_CACHE) {
3366                                 struct fib6_result res = {
3367                                         .f6i = rt,
3368                                 };
3369                                 int rc;
3370
3371                                 rt_cache = rt6_find_cached_rt(&res,
3372                                                               &cfg->fc_dst,
3373                                                               &cfg->fc_src);
3374                                 if (rt_cache) {
3375                                         rc = ip6_del_cached_rt(rt_cache, cfg);
3376                                         if (rc != -ESRCH) {
3377                                                 rcu_read_unlock();
3378                                                 return rc;
3379                                         }
3380                                 }
3381                                 continue;
3382                         }
3383
3384                         nh = &rt->fib6_nh;
3385                         if (cfg->fc_ifindex &&
3386                             (!nh->fib_nh_dev ||
3387                              nh->fib_nh_dev->ifindex != cfg->fc_ifindex))
3388                                 continue;
3389                         if (cfg->fc_flags & RTF_GATEWAY &&
3390                             !ipv6_addr_equal(&cfg->fc_gateway, &nh->fib_nh_gw6))
3391                                 continue;
3392                         if (cfg->fc_metric && cfg->fc_metric != rt->fib6_metric)
3393                                 continue;
3394                         if (cfg->fc_protocol && cfg->fc_protocol != rt->fib6_protocol)
3395                                 continue;
3396                         if (!fib6_info_hold_safe(rt))
3397                                 continue;
3398                         rcu_read_unlock();
3399
3400                         /* if gateway was specified only delete the one hop */
3401                         if (cfg->fc_flags & RTF_GATEWAY)
3402                                 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
3403
3404                         return __ip6_del_rt_siblings(rt, cfg);
3405                 }
3406         }
3407         rcu_read_unlock();
3408
3409         return err;
3410 }
3411
3412 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
3413 {
3414         struct netevent_redirect netevent;
3415         struct rt6_info *rt, *nrt = NULL;
3416         struct fib6_result res = {};
3417         struct ndisc_options ndopts;
3418         struct inet6_dev *in6_dev;
3419         struct neighbour *neigh;
3420         struct rd_msg *msg;
3421         int optlen, on_link;
3422         u8 *lladdr;
3423
3424         optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
3425         optlen -= sizeof(*msg);
3426
3427         if (optlen < 0) {
3428                 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
3429                 return;
3430         }
3431
3432         msg = (struct rd_msg *)icmp6_hdr(skb);
3433
3434         if (ipv6_addr_is_multicast(&msg->dest)) {
3435                 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
3436                 return;
3437         }
3438
3439         on_link = 0;
3440         if (ipv6_addr_equal(&msg->dest, &msg->target)) {
3441                 on_link = 1;
3442         } else if (ipv6_addr_type(&msg->target) !=
3443                    (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
3444                 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
3445                 return;
3446         }
3447
3448         in6_dev = __in6_dev_get(skb->dev);
3449         if (!in6_dev)
3450                 return;
3451         if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
3452                 return;
3453
3454         /* RFC2461 8.1:
3455          *      The IP source address of the Redirect MUST be the same as the current
3456          *      first-hop router for the specified ICMP Destination Address.
3457          */
3458
3459         if (!ndisc_parse_options(skb->dev, msg->opt, optlen, &ndopts)) {
3460                 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
3461                 return;
3462         }
3463
3464         lladdr = NULL;
3465         if (ndopts.nd_opts_tgt_lladdr) {
3466                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
3467                                              skb->dev);
3468                 if (!lladdr) {
3469                         net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
3470                         return;
3471                 }
3472         }
3473
3474         rt = (struct rt6_info *) dst;
3475         if (rt->rt6i_flags & RTF_REJECT) {
3476                 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
3477                 return;
3478         }
3479
3480         /* Redirect received -> path was valid.
3481          * Look, redirects are sent only in response to data packets,
3482          * so that this nexthop apparently is reachable. --ANK
3483          */
3484         dst_confirm_neigh(&rt->dst, &ipv6_hdr(skb)->saddr);
3485
3486         neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
3487         if (!neigh)
3488                 return;
3489
3490         /*
3491          *      We have finally decided to accept it.
3492          */
3493
3494         ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
3495                      NEIGH_UPDATE_F_WEAK_OVERRIDE|
3496                      NEIGH_UPDATE_F_OVERRIDE|
3497                      (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
3498                                      NEIGH_UPDATE_F_ISROUTER)),
3499                      NDISC_REDIRECT, &ndopts);
3500
3501         rcu_read_lock();
3502         res.f6i = rcu_dereference(rt->from);
3503         if (!res.f6i)
3504                 goto out;
3505
3506         res.nh = &res.f6i->fib6_nh;
3507         res.fib6_flags = res.f6i->fib6_flags;
3508         res.fib6_type = res.f6i->fib6_type;
3509         nrt = ip6_rt_cache_alloc(&res, &msg->dest, NULL);
3510         if (!nrt)
3511                 goto out;
3512
3513         nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
3514         if (on_link)
3515                 nrt->rt6i_flags &= ~RTF_GATEWAY;
3516
3517         nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
3518
3519         /* rt6_insert_exception() will take care of duplicated exceptions */
3520         if (rt6_insert_exception(nrt, &res)) {
3521                 dst_release_immediate(&nrt->dst);
3522                 goto out;
3523         }
3524
3525         netevent.old = &rt->dst;
3526         netevent.new = &nrt->dst;
3527         netevent.daddr = &msg->dest;
3528         netevent.neigh = neigh;
3529         call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
3530
3531 out:
3532         rcu_read_unlock();
3533         neigh_release(neigh);
3534 }
3535
3536 #ifdef CONFIG_IPV6_ROUTE_INFO
3537 static struct fib6_info *rt6_get_route_info(struct net *net,
3538                                            const struct in6_addr *prefix, int prefixlen,
3539                                            const struct in6_addr *gwaddr,
3540                                            struct net_device *dev)
3541 {
3542         u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO;
3543         int ifindex = dev->ifindex;
3544         struct fib6_node *fn;
3545         struct fib6_info *rt = NULL;
3546         struct fib6_table *table;
3547
3548         table = fib6_get_table(net, tb_id);
3549         if (!table)
3550                 return NULL;
3551
3552         rcu_read_lock();
3553         fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0, true);
3554         if (!fn)
3555                 goto out;
3556
3557         for_each_fib6_node_rt_rcu(fn) {
3558                 if (rt->fib6_nh.fib_nh_dev->ifindex != ifindex)
3559                         continue;
3560                 if (!(rt->fib6_flags & RTF_ROUTEINFO) ||
3561                     !rt->fib6_nh.fib_nh_gw_family)
3562                         continue;
3563                 if (!ipv6_addr_equal(&rt->fib6_nh.fib_nh_gw6, gwaddr))
3564                         continue;
3565                 if (!fib6_info_hold_safe(rt))
3566                         continue;
3567                 break;
3568         }
3569 out:
3570         rcu_read_unlock();
3571         return rt;
3572 }
3573
3574 static struct fib6_info *rt6_add_route_info(struct net *net,
3575                                            const struct in6_addr *prefix, int prefixlen,
3576                                            const struct in6_addr *gwaddr,
3577                                            struct net_device *dev,
3578                                            unsigned int pref)
3579 {
3580         struct fib6_config cfg = {
3581                 .fc_metric      = IP6_RT_PRIO_USER,
3582                 .fc_ifindex     = dev->ifindex,
3583                 .fc_dst_len     = prefixlen,
3584                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
3585                                   RTF_UP | RTF_PREF(pref),
3586                 .fc_protocol = RTPROT_RA,
3587                 .fc_type = RTN_UNICAST,
3588                 .fc_nlinfo.portid = 0,
3589                 .fc_nlinfo.nlh = NULL,
3590                 .fc_nlinfo.nl_net = net,
3591         };
3592
3593         cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO,
3594         cfg.fc_dst = *prefix;
3595         cfg.fc_gateway = *gwaddr;
3596
3597         /* We should treat it as a default route if prefix length is 0. */
3598         if (!prefixlen)
3599                 cfg.fc_flags |= RTF_DEFAULT;
3600
3601         ip6_route_add(&cfg, GFP_ATOMIC, NULL);
3602
3603         return rt6_get_route_info(net, prefix, prefixlen, gwaddr, dev);
3604 }
3605 #endif
3606
3607 struct fib6_info *rt6_get_dflt_router(struct net *net,
3608                                      const struct in6_addr *addr,
3609                                      struct net_device *dev)
3610 {
3611         u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT;
3612         struct fib6_info *rt;
3613         struct fib6_table *table;
3614
3615         table = fib6_get_table(net, tb_id);
3616         if (!table)
3617                 return NULL;
3618
3619         rcu_read_lock();
3620         for_each_fib6_node_rt_rcu(&table->tb6_root) {
3621                 struct fib6_nh *nh = &rt->fib6_nh;
3622
3623                 if (dev == nh->fib_nh_dev &&
3624                     ((rt->fib6_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
3625                     ipv6_addr_equal(&nh->fib_nh_gw6, addr))
3626                         break;
3627         }
3628         if (rt && !fib6_info_hold_safe(rt))
3629                 rt = NULL;
3630         rcu_read_unlock();
3631         return rt;
3632 }
3633
3634 struct fib6_info *rt6_add_dflt_router(struct net *net,
3635                                      const struct in6_addr *gwaddr,
3636                                      struct net_device *dev,
3637                                      unsigned int pref)
3638 {
3639         struct fib6_config cfg = {
3640                 .fc_table       = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
3641                 .fc_metric      = IP6_RT_PRIO_USER,
3642                 .fc_ifindex     = dev->ifindex,
3643                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
3644                                   RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
3645                 .fc_protocol = RTPROT_RA,
3646                 .fc_type = RTN_UNICAST,
3647                 .fc_nlinfo.portid = 0,
3648                 .fc_nlinfo.nlh = NULL,
3649                 .fc_nlinfo.nl_net = net,
3650         };
3651
3652         cfg.fc_gateway = *gwaddr;
3653
3654         if (!ip6_route_add(&cfg, GFP_ATOMIC, NULL)) {
3655                 struct fib6_table *table;
3656
3657                 table = fib6_get_table(dev_net(dev), cfg.fc_table);
3658                 if (table)
3659                         table->flags |= RT6_TABLE_HAS_DFLT_ROUTER;
3660         }
3661
3662         return rt6_get_dflt_router(net, gwaddr, dev);
3663 }
3664
3665 static void __rt6_purge_dflt_routers(struct net *net,
3666                                      struct fib6_table *table)
3667 {
3668         struct fib6_info *rt;
3669
3670 restart:
3671         rcu_read_lock();
3672         for_each_fib6_node_rt_rcu(&table->tb6_root) {
3673                 struct net_device *dev = fib6_info_nh_dev(rt);
3674                 struct inet6_dev *idev = dev ? __in6_dev_get(dev) : NULL;
3675
3676                 if (rt->fib6_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
3677                     (!idev || idev->cnf.accept_ra != 2) &&
3678                     fib6_info_hold_safe(rt)) {
3679                         rcu_read_unlock();
3680                         ip6_del_rt(net, rt);
3681                         goto restart;
3682                 }
3683         }
3684         rcu_read_unlock();
3685
3686         table->flags &= ~RT6_TABLE_HAS_DFLT_ROUTER;
3687 }
3688
3689 void rt6_purge_dflt_routers(struct net *net)
3690 {
3691         struct fib6_table *table;
3692         struct hlist_head *head;
3693         unsigned int h;
3694
3695         rcu_read_lock();
3696
3697         for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
3698                 head = &net->ipv6.fib_table_hash[h];
3699                 hlist_for_each_entry_rcu(table, head, tb6_hlist) {
3700                         if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER)
3701                                 __rt6_purge_dflt_routers(net, table);
3702                 }
3703         }
3704
3705         rcu_read_unlock();
3706 }
3707
3708 static void rtmsg_to_fib6_config(struct net *net,
3709                                  struct in6_rtmsg *rtmsg,
3710                                  struct fib6_config *cfg)
3711 {
3712         *cfg = (struct fib6_config){
3713                 .fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
3714                          : RT6_TABLE_MAIN,
3715                 .fc_ifindex = rtmsg->rtmsg_ifindex,
3716                 .fc_metric = rtmsg->rtmsg_metric ? : IP6_RT_PRIO_USER,
3717                 .fc_expires = rtmsg->rtmsg_info,
3718                 .fc_dst_len = rtmsg->rtmsg_dst_len,
3719                 .fc_src_len = rtmsg->rtmsg_src_len,
3720                 .fc_flags = rtmsg->rtmsg_flags,
3721                 .fc_type = rtmsg->rtmsg_type,
3722
3723                 .fc_nlinfo.nl_net = net,
3724
3725                 .fc_dst = rtmsg->rtmsg_dst,
3726                 .fc_src = rtmsg->rtmsg_src,
3727                 .fc_gateway = rtmsg->rtmsg_gateway,
3728         };
3729 }
3730
3731 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3732 {
3733         struct fib6_config cfg;
3734         struct in6_rtmsg rtmsg;
3735         int err;
3736
3737         switch (cmd) {
3738         case SIOCADDRT:         /* Add a route */
3739         case SIOCDELRT:         /* Delete a route */
3740                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
3741                         return -EPERM;
3742                 err = copy_from_user(&rtmsg, arg,
3743                                      sizeof(struct in6_rtmsg));
3744                 if (err)
3745                         return -EFAULT;
3746
3747                 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
3748
3749                 rtnl_lock();
3750                 switch (cmd) {
3751                 case SIOCADDRT:
3752                         err = ip6_route_add(&cfg, GFP_KERNEL, NULL);
3753                         break;
3754                 case SIOCDELRT:
3755                         err = ip6_route_del(&cfg, NULL);
3756                         break;
3757                 default:
3758                         err = -EINVAL;
3759                 }
3760                 rtnl_unlock();
3761
3762                 return err;
3763         }
3764
3765         return -EINVAL;
3766 }
3767
3768 /*
3769  *      Drop the packet on the floor
3770  */
3771
3772 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
3773 {
3774         struct dst_entry *dst = skb_dst(skb);
3775         struct net *net = dev_net(dst->dev);
3776         struct inet6_dev *idev;
3777         int type;
3778
3779         if (netif_is_l3_master(skb->dev) &&
3780             dst->dev == net->loopback_dev)
3781                 idev = __in6_dev_get_safely(dev_get_by_index_rcu(net, IP6CB(skb)->iif));
3782         else
3783                 idev = ip6_dst_idev(dst);
3784
3785         switch (ipstats_mib_noroutes) {
3786         case IPSTATS_MIB_INNOROUTES:
3787                 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
3788                 if (type == IPV6_ADDR_ANY) {
3789                         IP6_INC_STATS(net, idev, IPSTATS_MIB_INADDRERRORS);
3790                         break;
3791                 }
3792                 /* FALLTHROUGH */
3793         case IPSTATS_MIB_OUTNOROUTES:
3794                 IP6_INC_STATS(net, idev, ipstats_mib_noroutes);
3795                 break;
3796         }
3797
3798         /* Start over by dropping the dst for l3mdev case */
3799         if (netif_is_l3_master(skb->dev))
3800                 skb_dst_drop(skb);
3801
3802         icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
3803         kfree_skb(skb);
3804         return 0;
3805 }
3806
3807 static int ip6_pkt_discard(struct sk_buff *skb)
3808 {
3809         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
3810 }
3811
3812 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
3813 {
3814         skb->dev = skb_dst(skb)->dev;
3815         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
3816 }
3817
3818 static int ip6_pkt_prohibit(struct sk_buff *skb)
3819 {
3820         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
3821 }
3822
3823 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
3824 {
3825         skb->dev = skb_dst(skb)->dev;
3826         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
3827 }
3828
3829 /*
3830  *      Allocate a dst for local (unicast / anycast) address.
3831  */
3832
3833 struct fib6_info *addrconf_f6i_alloc(struct net *net,
3834                                      struct inet6_dev *idev,
3835                                      const struct in6_addr *addr,
3836                                      bool anycast, gfp_t gfp_flags)
3837 {
3838         struct fib6_config cfg = {
3839                 .fc_table = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL,
3840                 .fc_ifindex = idev->dev->ifindex,
3841                 .fc_flags = RTF_UP | RTF_ADDRCONF | RTF_NONEXTHOP,
3842                 .fc_dst = *addr,
3843                 .fc_dst_len = 128,
3844                 .fc_protocol = RTPROT_KERNEL,
3845                 .fc_nlinfo.nl_net = net,
3846                 .fc_ignore_dev_down = true,
3847         };
3848
3849         if (anycast) {
3850                 cfg.fc_type = RTN_ANYCAST;
3851                 cfg.fc_flags |= RTF_ANYCAST;
3852         } else {
3853                 cfg.fc_type = RTN_LOCAL;
3854                 cfg.fc_flags |= RTF_LOCAL;
3855         }
3856
3857         return ip6_route_info_create(&cfg, gfp_flags, NULL);
3858 }
3859
3860 /* remove deleted ip from prefsrc entries */
3861 struct arg_dev_net_ip {
3862         struct net_device *dev;
3863         struct net *net;
3864         struct in6_addr *addr;
3865 };
3866
3867 static int fib6_remove_prefsrc(struct fib6_info *rt, void *arg)
3868 {
3869         struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
3870         struct net *net = ((struct arg_dev_net_ip *)arg)->net;
3871         struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
3872
3873         if (((void *)rt->fib6_nh.fib_nh_dev == dev || !dev) &&
3874             rt != net->ipv6.fib6_null_entry &&
3875             ipv6_addr_equal(addr, &rt->fib6_prefsrc.addr)) {
3876                 spin_lock_bh(&rt6_exception_lock);
3877                 /* remove prefsrc entry */
3878                 rt->fib6_prefsrc.plen = 0;
3879                 spin_unlock_bh(&rt6_exception_lock);
3880         }
3881         return 0;
3882 }
3883
3884 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
3885 {
3886         struct net *net = dev_net(ifp->idev->dev);
3887         struct arg_dev_net_ip adni = {
3888                 .dev = ifp->idev->dev,
3889                 .net = net,
3890                 .addr = &ifp->addr,
3891         };
3892         fib6_clean_all(net, fib6_remove_prefsrc, &adni);
3893 }
3894
3895 #define RTF_RA_ROUTER           (RTF_ADDRCONF | RTF_DEFAULT)
3896
3897 /* Remove routers and update dst entries when gateway turn into host. */
3898 static int fib6_clean_tohost(struct fib6_info *rt, void *arg)
3899 {
3900         struct in6_addr *gateway = (struct in6_addr *)arg;
3901
3902         if (((rt->fib6_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) &&
3903             rt->fib6_nh.fib_nh_gw_family &&
3904             ipv6_addr_equal(gateway, &rt->fib6_nh.fib_nh_gw6)) {
3905                 return -1;
3906         }
3907
3908         /* Further clean up cached routes in exception table.
3909          * This is needed because cached route may have a different
3910          * gateway than its 'parent' in the case of an ip redirect.
3911          */
3912         rt6_exceptions_clean_tohost(rt, gateway);
3913
3914         return 0;
3915 }
3916
3917 void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
3918 {
3919         fib6_clean_all(net, fib6_clean_tohost, gateway);
3920 }
3921
3922 struct arg_netdev_event {
3923         const struct net_device *dev;
3924         union {
3925                 unsigned char nh_flags;
3926                 unsigned long event;
3927         };
3928 };
3929
3930 static struct fib6_info *rt6_multipath_first_sibling(const struct fib6_info *rt)
3931 {
3932         struct fib6_info *iter;
3933         struct fib6_node *fn;
3934
3935         fn = rcu_dereference_protected(rt->fib6_node,
3936                         lockdep_is_held(&rt->fib6_table->tb6_lock));
3937         iter = rcu_dereference_protected(fn->leaf,
3938                         lockdep_is_held(&rt->fib6_table->tb6_lock));
3939         while (iter) {
3940                 if (iter->fib6_metric == rt->fib6_metric &&
3941                     rt6_qualify_for_ecmp(iter))
3942                         return iter;
3943                 iter = rcu_dereference_protected(iter->fib6_next,
3944                                 lockdep_is_held(&rt->fib6_table->tb6_lock));
3945         }
3946
3947         return NULL;
3948 }
3949
3950 static bool rt6_is_dead(const struct fib6_info *rt)
3951 {
3952         if (rt->fib6_nh.fib_nh_flags & RTNH_F_DEAD ||
3953             (rt->fib6_nh.fib_nh_flags & RTNH_F_LINKDOWN &&
3954              ip6_ignore_linkdown(rt->fib6_nh.fib_nh_dev)))
3955                 return true;
3956
3957         return false;
3958 }
3959
3960 static int rt6_multipath_total_weight(const struct fib6_info *rt)
3961 {
3962         struct fib6_info *iter;
3963         int total = 0;
3964
3965         if (!rt6_is_dead(rt))
3966                 total += rt->fib6_nh.fib_nh_weight;
3967
3968         list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) {
3969                 if (!rt6_is_dead(iter))
3970                         total += iter->fib6_nh.fib_nh_weight;
3971         }
3972
3973         return total;
3974 }
3975
3976 static void rt6_upper_bound_set(struct fib6_info *rt, int *weight, int total)
3977 {
3978         int upper_bound = -1;
3979
3980         if (!rt6_is_dead(rt)) {
3981                 *weight += rt->fib6_nh.fib_nh_weight;
3982                 upper_bound = DIV_ROUND_CLOSEST_ULL((u64) (*weight) << 31,
3983                                                     total) - 1;
3984         }
3985         atomic_set(&rt->fib6_nh.fib_nh_upper_bound, upper_bound);
3986 }
3987
3988 static void rt6_multipath_upper_bound_set(struct fib6_info *rt, int total)
3989 {
3990         struct fib6_info *iter;
3991         int weight = 0;
3992
3993         rt6_upper_bound_set(rt, &weight, total);
3994
3995         list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
3996                 rt6_upper_bound_set(iter, &weight, total);
3997 }
3998
3999 void rt6_multipath_rebalance(struct fib6_info *rt)
4000 {
4001         struct fib6_info *first;
4002         int total;
4003
4004         /* In case the entire multipath route was marked for flushing,
4005          * then there is no need to rebalance upon the removal of every
4006          * sibling route.
4007          */
4008         if (!rt->fib6_nsiblings || rt->should_flush)
4009                 return;
4010
4011         /* During lookup routes are evaluated in order, so we need to
4012          * make sure upper bounds are assigned from the first sibling
4013          * onwards.
4014          */
4015         first = rt6_multipath_first_sibling(rt);
4016         if (WARN_ON_ONCE(!first))
4017                 return;
4018
4019         total = rt6_multipath_total_weight(first);
4020         rt6_multipath_upper_bound_set(first, total);
4021 }
4022
4023 static int fib6_ifup(struct fib6_info *rt, void *p_arg)
4024 {
4025         const struct arg_netdev_event *arg = p_arg;
4026         struct net *net = dev_net(arg->dev);
4027
4028         if (rt != net->ipv6.fib6_null_entry &&
4029             rt->fib6_nh.fib_nh_dev == arg->dev) {
4030                 rt->fib6_nh.fib_nh_flags &= ~arg->nh_flags;
4031                 fib6_update_sernum_upto_root(net, rt);
4032                 rt6_multipath_rebalance(rt);
4033         }
4034
4035         return 0;
4036 }
4037
4038 void rt6_sync_up(struct net_device *dev, unsigned char nh_flags)
4039 {
4040         struct arg_netdev_event arg = {
4041                 .dev = dev,
4042                 {
4043                         .nh_flags = nh_flags,
4044                 },
4045         };
4046
4047         if (nh_flags & RTNH_F_DEAD && netif_carrier_ok(dev))
4048                 arg.nh_flags |= RTNH_F_LINKDOWN;
4049
4050         fib6_clean_all(dev_net(dev), fib6_ifup, &arg);
4051 }
4052
4053 static bool rt6_multipath_uses_dev(const struct fib6_info *rt,
4054                                    const struct net_device *dev)
4055 {
4056         struct fib6_info *iter;
4057
4058         if (rt->fib6_nh.fib_nh_dev == dev)
4059                 return true;
4060         list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
4061                 if (iter->fib6_nh.fib_nh_dev == dev)
4062                         return true;
4063
4064         return false;
4065 }
4066
4067 static void rt6_multipath_flush(struct fib6_info *rt)
4068 {
4069         struct fib6_info *iter;
4070
4071         rt->should_flush = 1;
4072         list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
4073                 iter->should_flush = 1;
4074 }
4075
4076 static unsigned int rt6_multipath_dead_count(const struct fib6_info *rt,
4077                                              const struct net_device *down_dev)
4078 {
4079         struct fib6_info *iter;
4080         unsigned int dead = 0;
4081
4082         if (rt->fib6_nh.fib_nh_dev == down_dev ||
4083             rt->fib6_nh.fib_nh_flags & RTNH_F_DEAD)
4084                 dead++;
4085         list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
4086                 if (iter->fib6_nh.fib_nh_dev == down_dev ||
4087                     iter->fib6_nh.fib_nh_flags & RTNH_F_DEAD)
4088                         dead++;
4089
4090         return dead;
4091 }
4092
4093 static void rt6_multipath_nh_flags_set(struct fib6_info *rt,
4094                                        const struct net_device *dev,
4095                                        unsigned char nh_flags)
4096 {
4097         struct fib6_info *iter;
4098
4099         if (rt->fib6_nh.fib_nh_dev == dev)
4100                 rt->fib6_nh.fib_nh_flags |= nh_flags;
4101         list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
4102                 if (iter->fib6_nh.fib_nh_dev == dev)
4103                         iter->fib6_nh.fib_nh_flags |= nh_flags;
4104 }
4105
4106 /* called with write lock held for table with rt */
4107 static int fib6_ifdown(struct fib6_info *rt, void *p_arg)
4108 {
4109         const struct arg_netdev_event *arg = p_arg;
4110         const struct net_device *dev = arg->dev;
4111         struct net *net = dev_net(dev);
4112
4113         if (rt == net->ipv6.fib6_null_entry)
4114                 return 0;
4115
4116         switch (arg->event) {
4117         case NETDEV_UNREGISTER:
4118                 return rt->fib6_nh.fib_nh_dev == dev ? -1 : 0;
4119         case NETDEV_DOWN:
4120                 if (rt->should_flush)
4121                         return -1;
4122                 if (!rt->fib6_nsiblings)
4123                         return rt->fib6_nh.fib_nh_dev == dev ? -1 : 0;
4124                 if (rt6_multipath_uses_dev(rt, dev)) {
4125                         unsigned int count;
4126
4127                         count = rt6_multipath_dead_count(rt, dev);
4128                         if (rt->fib6_nsiblings + 1 == count) {
4129                                 rt6_multipath_flush(rt);
4130                                 return -1;
4131                         }
4132                         rt6_multipath_nh_flags_set(rt, dev, RTNH_F_DEAD |
4133                                                    RTNH_F_LINKDOWN);
4134                         fib6_update_sernum(net, rt);
4135                         rt6_multipath_rebalance(rt);
4136                 }
4137                 return -2;
4138         case NETDEV_CHANGE:
4139                 if (rt->fib6_nh.fib_nh_dev != dev ||
4140                     rt->fib6_flags & (RTF_LOCAL | RTF_ANYCAST))
4141                         break;
4142                 rt->fib6_nh.fib_nh_flags |= RTNH_F_LINKDOWN;
4143                 rt6_multipath_rebalance(rt);
4144                 break;
4145         }
4146
4147         return 0;
4148 }
4149
4150 void rt6_sync_down_dev(struct net_device *dev, unsigned long event)
4151 {
4152         struct arg_netdev_event arg = {
4153                 .dev = dev,
4154                 {
4155                         .event = event,
4156                 },
4157         };
4158         struct net *net = dev_net(dev);
4159
4160         if (net->ipv6.sysctl.skip_notify_on_dev_down)
4161                 fib6_clean_all_skip_notify(net, fib6_ifdown, &arg);
4162         else
4163                 fib6_clean_all(net, fib6_ifdown, &arg);
4164 }
4165
4166 void rt6_disable_ip(struct net_device *dev, unsigned long event)
4167 {
4168         rt6_sync_down_dev(dev, event);
4169         rt6_uncached_list_flush_dev(dev_net(dev), dev);
4170         neigh_ifdown(&nd_tbl, dev);
4171 }
4172
4173 struct rt6_mtu_change_arg {
4174         struct net_device *dev;
4175         unsigned int mtu;
4176 };
4177
4178 static int rt6_mtu_change_route(struct fib6_info *rt, void *p_arg)
4179 {
4180         struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
4181         struct inet6_dev *idev;
4182
4183         /* In IPv6 pmtu discovery is not optional,
4184            so that RTAX_MTU lock cannot disable it.
4185            We still use this lock to block changes
4186            caused by addrconf/ndisc.
4187         */
4188
4189         idev = __in6_dev_get(arg->dev);
4190         if (!idev)
4191                 return 0;
4192
4193         /* For administrative MTU increase, there is no way to discover
4194            IPv6 PMTU increase, so PMTU increase should be updated here.
4195            Since RFC 1981 doesn't include administrative MTU increase
4196            update PMTU increase is a MUST. (i.e. jumbo frame)
4197          */
4198         if (rt->fib6_nh.fib_nh_dev == arg->dev &&
4199             !fib6_metric_locked(rt, RTAX_MTU)) {
4200                 u32 mtu = rt->fib6_pmtu;
4201
4202                 if (mtu >= arg->mtu ||
4203                     (mtu < arg->mtu && mtu == idev->cnf.mtu6))
4204                         fib6_metric_set(rt, RTAX_MTU, arg->mtu);
4205
4206                 spin_lock_bh(&rt6_exception_lock);
4207                 rt6_exceptions_update_pmtu(idev, rt, arg->mtu);
4208                 spin_unlock_bh(&rt6_exception_lock);
4209         }
4210         return 0;
4211 }
4212
4213 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
4214 {
4215         struct rt6_mtu_change_arg arg = {
4216                 .dev = dev,
4217                 .mtu = mtu,
4218         };
4219
4220         fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
4221 }
4222
4223 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
4224         [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
4225         [RTA_PREFSRC]           = { .len = sizeof(struct in6_addr) },
4226         [RTA_OIF]               = { .type = NLA_U32 },
4227         [RTA_IIF]               = { .type = NLA_U32 },
4228         [RTA_PRIORITY]          = { .type = NLA_U32 },
4229         [RTA_METRICS]           = { .type = NLA_NESTED },
4230         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
4231         [RTA_PREF]              = { .type = NLA_U8 },
4232         [RTA_ENCAP_TYPE]        = { .type = NLA_U16 },
4233         [RTA_ENCAP]             = { .type = NLA_NESTED },
4234         [RTA_EXPIRES]           = { .type = NLA_U32 },
4235         [RTA_UID]               = { .type = NLA_U32 },
4236         [RTA_MARK]              = { .type = NLA_U32 },
4237         [RTA_TABLE]             = { .type = NLA_U32 },
4238         [RTA_IP_PROTO]          = { .type = NLA_U8 },
4239         [RTA_SPORT]             = { .type = NLA_U16 },
4240         [RTA_DPORT]             = { .type = NLA_U16 },
4241 };
4242
4243 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
4244                               struct fib6_config *cfg,
4245                               struct netlink_ext_ack *extack)
4246 {
4247         struct rtmsg *rtm;
4248         struct nlattr *tb[RTA_MAX+1];
4249         unsigned int pref;
4250         int err;
4251
4252         err = nlmsg_parse_deprecated(nlh, sizeof(*rtm), tb, RTA_MAX,
4253                                      rtm_ipv6_policy, extack);
4254         if (err < 0)
4255                 goto errout;
4256
4257         err = -EINVAL;
4258         rtm = nlmsg_data(nlh);
4259
4260         *cfg = (struct fib6_config){
4261                 .fc_table = rtm->rtm_table,
4262                 .fc_dst_len = rtm->rtm_dst_len,
4263                 .fc_src_len = rtm->rtm_src_len,
4264                 .fc_flags = RTF_UP,
4265                 .fc_protocol = rtm->rtm_protocol,
4266                 .fc_type = rtm->rtm_type,
4267
4268                 .fc_nlinfo.portid = NETLINK_CB(skb).portid,
4269                 .fc_nlinfo.nlh = nlh,
4270                 .fc_nlinfo.nl_net = sock_net(skb->sk),
4271         };
4272
4273         if (rtm->rtm_type == RTN_UNREACHABLE ||
4274             rtm->rtm_type == RTN_BLACKHOLE ||
4275             rtm->rtm_type == RTN_PROHIBIT ||
4276             rtm->rtm_type == RTN_THROW)
4277                 cfg->fc_flags |= RTF_REJECT;
4278
4279         if (rtm->rtm_type == RTN_LOCAL)
4280                 cfg->fc_flags |= RTF_LOCAL;
4281
4282         if (rtm->rtm_flags & RTM_F_CLONED)
4283                 cfg->fc_flags |= RTF_CACHE;
4284
4285         cfg->fc_flags |= (rtm->rtm_flags & RTNH_F_ONLINK);
4286
4287         if (tb[RTA_GATEWAY]) {
4288                 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
4289                 cfg->fc_flags |= RTF_GATEWAY;
4290         }
4291         if (tb[RTA_VIA]) {
4292                 NL_SET_ERR_MSG(extack, "IPv6 does not support RTA_VIA attribute");
4293                 goto errout;
4294         }
4295
4296         if (tb[RTA_DST]) {
4297                 int plen = (rtm->rtm_dst_len + 7) >> 3;
4298
4299                 if (nla_len(tb[RTA_DST]) < plen)
4300                         goto errout;
4301
4302                 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
4303         }
4304
4305         if (tb[RTA_SRC]) {
4306                 int plen = (rtm->rtm_src_len + 7) >> 3;
4307
4308                 if (nla_len(tb[RTA_SRC]) < plen)
4309                         goto errout;
4310
4311                 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
4312         }
4313
4314         if (tb[RTA_PREFSRC])
4315                 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
4316
4317         if (tb[RTA_OIF])
4318                 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
4319
4320         if (tb[RTA_PRIORITY])
4321                 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
4322
4323         if (tb[RTA_METRICS]) {
4324                 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
4325                 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
4326         }
4327
4328         if (tb[RTA_TABLE])
4329                 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
4330
4331         if (tb[RTA_MULTIPATH]) {
4332                 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
4333                 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
4334
4335                 err = lwtunnel_valid_encap_type_attr(cfg->fc_mp,
4336                                                      cfg->fc_mp_len, extack);
4337                 if (err < 0)
4338                         goto errout;
4339         }
4340
4341         if (tb[RTA_PREF]) {
4342                 pref = nla_get_u8(tb[RTA_PREF]);
4343                 if (pref != ICMPV6_ROUTER_PREF_LOW &&
4344                     pref != ICMPV6_ROUTER_PREF_HIGH)
4345                         pref = ICMPV6_ROUTER_PREF_MEDIUM;
4346                 cfg->fc_flags |= RTF_PREF(pref);
4347         }
4348
4349         if (tb[RTA_ENCAP])
4350                 cfg->fc_encap = tb[RTA_ENCAP];
4351
4352         if (tb[RTA_ENCAP_TYPE]) {
4353                 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
4354
4355                 err = lwtunnel_valid_encap_type(cfg->fc_encap_type, extack);
4356                 if (err < 0)
4357                         goto errout;
4358         }
4359
4360         if (tb[RTA_EXPIRES]) {
4361                 unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);
4362
4363                 if (addrconf_finite_timeout(timeout)) {
4364                         cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
4365                         cfg->fc_flags |= RTF_EXPIRES;
4366                 }
4367         }
4368
4369         err = 0;
4370 errout:
4371         return err;
4372 }
4373
4374 struct rt6_nh {
4375         struct fib6_info *fib6_info;
4376         struct fib6_config r_cfg;
4377         struct list_head next;
4378 };
4379
4380 static int ip6_route_info_append(struct net *net,
4381                                  struct list_head *rt6_nh_list,
4382                                  struct fib6_info *rt,
4383                                  struct fib6_config *r_cfg)
4384 {
4385         struct rt6_nh *nh;
4386         int err = -EEXIST;
4387
4388         list_for_each_entry(nh, rt6_nh_list, next) {
4389                 /* check if fib6_info already exists */
4390                 if (rt6_duplicate_nexthop(nh->fib6_info, rt))
4391                         return err;
4392         }
4393
4394         nh = kzalloc(sizeof(*nh), GFP_KERNEL);
4395         if (!nh)
4396                 return -ENOMEM;
4397         nh->fib6_info = rt;
4398         memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
4399         list_add_tail(&nh->next, rt6_nh_list);
4400
4401         return 0;
4402 }
4403
4404 static void ip6_route_mpath_notify(struct fib6_info *rt,
4405                                    struct fib6_info *rt_last,
4406                                    struct nl_info *info,
4407                                    __u16 nlflags)
4408 {
4409         /* if this is an APPEND route, then rt points to the first route
4410          * inserted and rt_last points to last route inserted. Userspace
4411          * wants a consistent dump of the route which starts at the first
4412          * nexthop. Since sibling routes are always added at the end of
4413          * the list, find the first sibling of the last route appended
4414          */
4415         if ((nlflags & NLM_F_APPEND) && rt_last && rt_last->fib6_nsiblings) {
4416                 rt = list_first_entry(&rt_last->fib6_siblings,
4417                                       struct fib6_info,
4418                                       fib6_siblings);
4419         }
4420
4421         if (rt)
4422                 inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
4423 }
4424
4425 static int ip6_route_multipath_add(struct fib6_config *cfg,
4426                                    struct netlink_ext_ack *extack)
4427 {
4428         struct fib6_info *rt_notif = NULL, *rt_last = NULL;
4429         struct nl_info *info = &cfg->fc_nlinfo;
4430         struct fib6_config r_cfg;
4431         struct rtnexthop *rtnh;
4432         struct fib6_info *rt;
4433         struct rt6_nh *err_nh;
4434         struct rt6_nh *nh, *nh_safe;
4435         __u16 nlflags;
4436         int remaining;
4437         int attrlen;
4438         int err = 1;
4439         int nhn = 0;
4440         int replace = (cfg->fc_nlinfo.nlh &&
4441                        (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
4442         LIST_HEAD(rt6_nh_list);
4443
4444         nlflags = replace ? NLM_F_REPLACE : NLM_F_CREATE;
4445         if (info->nlh && info->nlh->nlmsg_flags & NLM_F_APPEND)
4446                 nlflags |= NLM_F_APPEND;
4447
4448         remaining = cfg->fc_mp_len;
4449         rtnh = (struct rtnexthop *)cfg->fc_mp;
4450
4451         /* Parse a Multipath Entry and build a list (rt6_nh_list) of
4452          * fib6_info structs per nexthop
4453          */
4454         while (rtnh_ok(rtnh, remaining)) {
4455                 memcpy(&r_cfg, cfg, sizeof(*cfg));
4456                 if (rtnh->rtnh_ifindex)
4457                         r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
4458
4459                 attrlen = rtnh_attrlen(rtnh);
4460                 if (attrlen > 0) {
4461                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
4462
4463                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
4464                         if (nla) {
4465                                 r_cfg.fc_gateway = nla_get_in6_addr(nla);
4466                                 r_cfg.fc_flags |= RTF_GATEWAY;
4467                         }
4468                         r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
4469                         nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
4470                         if (nla)
4471                                 r_cfg.fc_encap_type = nla_get_u16(nla);
4472                 }
4473
4474                 r_cfg.fc_flags |= (rtnh->rtnh_flags & RTNH_F_ONLINK);
4475                 rt = ip6_route_info_create(&r_cfg, GFP_KERNEL, extack);
4476                 if (IS_ERR(rt)) {
4477                         err = PTR_ERR(rt);
4478                         rt = NULL;
4479                         goto cleanup;
4480                 }
4481                 if (!rt6_qualify_for_ecmp(rt)) {
4482                         err = -EINVAL;
4483                         NL_SET_ERR_MSG(extack,
4484                                        "Device only routes can not be added for IPv6 using the multipath API.");
4485                         fib6_info_release(rt);
4486                         goto cleanup;
4487                 }
4488
4489                 rt->fib6_nh.fib_nh_weight = rtnh->rtnh_hops + 1;
4490
4491                 err = ip6_route_info_append(info->nl_net, &rt6_nh_list,
4492                                             rt, &r_cfg);
4493                 if (err) {
4494                         fib6_info_release(rt);
4495                         goto cleanup;
4496                 }
4497
4498                 rtnh = rtnh_next(rtnh, &remaining);
4499         }
4500
4501         /* for add and replace send one notification with all nexthops.
4502          * Skip the notification in fib6_add_rt2node and send one with
4503          * the full route when done
4504          */
4505         info->skip_notify = 1;
4506
4507         err_nh = NULL;
4508         list_for_each_entry(nh, &rt6_nh_list, next) {
4509                 err = __ip6_ins_rt(nh->fib6_info, info, extack);
4510                 fib6_info_release(nh->fib6_info);
4511
4512                 if (!err) {
4513                         /* save reference to last route successfully inserted */
4514                         rt_last = nh->fib6_info;
4515
4516                         /* save reference to first route for notification */
4517                         if (!rt_notif)
4518                                 rt_notif = nh->fib6_info;
4519                 }
4520
4521                 /* nh->fib6_info is used or freed at this point, reset to NULL*/
4522                 nh->fib6_info = NULL;
4523                 if (err) {
4524                         if (replace && nhn)
4525                                 NL_SET_ERR_MSG_MOD(extack,
4526                                                    "multipath route replace failed (check consistency of installed routes)");
4527                         err_nh = nh;
4528                         goto add_errout;
4529                 }
4530
4531                 /* Because each route is added like a single route we remove
4532                  * these flags after the first nexthop: if there is a collision,
4533                  * we have already failed to add the first nexthop:
4534                  * fib6_add_rt2node() has rejected it; when replacing, old
4535                  * nexthops have been replaced by first new, the rest should
4536                  * be added to it.
4537                  */
4538                 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
4539                                                      NLM_F_REPLACE);
4540                 nhn++;
4541         }
4542
4543         /* success ... tell user about new route */
4544         ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
4545         goto cleanup;
4546
4547 add_errout:
4548         /* send notification for routes that were added so that
4549          * the delete notifications sent by ip6_route_del are
4550          * coherent
4551          */
4552         if (rt_notif)
4553                 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
4554
4555         /* Delete routes that were already added */
4556         list_for_each_entry(nh, &rt6_nh_list, next) {
4557                 if (err_nh == nh)
4558                         break;
4559                 ip6_route_del(&nh->r_cfg, extack);
4560         }
4561
4562 cleanup:
4563         list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
4564                 if (nh->fib6_info)
4565                         fib6_info_release(nh->fib6_info);
4566                 list_del(&nh->next);
4567                 kfree(nh);
4568         }
4569
4570         return err;
4571 }
4572
4573 static int ip6_route_multipath_del(struct fib6_config *cfg,
4574                                    struct netlink_ext_ack *extack)
4575 {
4576         struct fib6_config r_cfg;
4577         struct rtnexthop *rtnh;
4578         int remaining;
4579         int attrlen;
4580         int err = 1, last_err = 0;
4581
4582         remaining = cfg->fc_mp_len;
4583         rtnh = (struct rtnexthop *)cfg->fc_mp;
4584
4585         /* Parse a Multipath Entry */
4586         while (rtnh_ok(rtnh, remaining)) {
4587                 memcpy(&r_cfg, cfg, sizeof(*cfg));
4588                 if (rtnh->rtnh_ifindex)
4589                         r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
4590
4591                 attrlen = rtnh_attrlen(rtnh);
4592                 if (attrlen > 0) {
4593                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
4594
4595                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
4596                         if (nla) {
4597                                 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
4598                                 r_cfg.fc_flags |= RTF_GATEWAY;
4599                         }
4600                 }
4601                 err = ip6_route_del(&r_cfg, extack);
4602                 if (err)
4603                         last_err = err;
4604
4605                 rtnh = rtnh_next(rtnh, &remaining);
4606         }
4607
4608         return last_err;
4609 }
4610
4611 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh,
4612                               struct netlink_ext_ack *extack)
4613 {
4614         struct fib6_config cfg;
4615         int err;
4616
4617         err = rtm_to_fib6_config(skb, nlh, &cfg, extack);
4618         if (err < 0)
4619                 return err;
4620
4621         if (cfg.fc_mp)
4622                 return ip6_route_multipath_del(&cfg, extack);
4623         else {
4624                 cfg.fc_delete_all_nh = 1;
4625                 return ip6_route_del(&cfg, extack);
4626         }
4627 }
4628
4629 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh,
4630                               struct netlink_ext_ack *extack)
4631 {
4632         struct fib6_config cfg;
4633         int err;
4634
4635         err = rtm_to_fib6_config(skb, nlh, &cfg, extack);
4636         if (err < 0)
4637                 return err;
4638
4639         if (cfg.fc_metric == 0)
4640                 cfg.fc_metric = IP6_RT_PRIO_USER;
4641
4642         if (cfg.fc_mp)
4643                 return ip6_route_multipath_add(&cfg, extack);
4644         else
4645                 return ip6_route_add(&cfg, GFP_KERNEL, extack);
4646 }
4647
4648 static size_t rt6_nlmsg_size(struct fib6_info *rt)
4649 {
4650         int nexthop_len = 0;
4651
4652         if (rt->fib6_nsiblings) {
4653                 nexthop_len = nla_total_size(0)  /* RTA_MULTIPATH */
4654                             + NLA_ALIGN(sizeof(struct rtnexthop))
4655                             + nla_total_size(16) /* RTA_GATEWAY */
4656                             + lwtunnel_get_encap_size(rt->fib6_nh.fib_nh_lws);
4657
4658                 nexthop_len *= rt->fib6_nsiblings;
4659         }
4660
4661         return NLMSG_ALIGN(sizeof(struct rtmsg))
4662                + nla_total_size(16) /* RTA_SRC */
4663                + nla_total_size(16) /* RTA_DST */
4664                + nla_total_size(16) /* RTA_GATEWAY */
4665                + nla_total_size(16) /* RTA_PREFSRC */
4666                + nla_total_size(4) /* RTA_TABLE */
4667                + nla_total_size(4) /* RTA_IIF */
4668                + nla_total_size(4) /* RTA_OIF */
4669                + nla_total_size(4) /* RTA_PRIORITY */
4670                + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
4671                + nla_total_size(sizeof(struct rta_cacheinfo))
4672                + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
4673                + nla_total_size(1) /* RTA_PREF */
4674                + lwtunnel_get_encap_size(rt->fib6_nh.fib_nh_lws)
4675                + nexthop_len;
4676 }
4677
4678 static int rt6_fill_node(struct net *net, struct sk_buff *skb,
4679                          struct fib6_info *rt, struct dst_entry *dst,
4680                          struct in6_addr *dest, struct in6_addr *src,
4681                          int iif, int type, u32 portid, u32 seq,
4682                          unsigned int flags)
4683 {
4684         struct rt6_info *rt6 = (struct rt6_info *)dst;
4685         struct rt6key *rt6_dst, *rt6_src;
4686         u32 *pmetrics, table, rt6_flags;
4687         struct nlmsghdr *nlh;
4688         struct rtmsg *rtm;
4689         long expires = 0;
4690
4691         nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
4692         if (!nlh)
4693                 return -EMSGSIZE;
4694
4695         if (rt6) {
4696                 rt6_dst = &rt6->rt6i_dst;
4697                 rt6_src = &rt6->rt6i_src;
4698                 rt6_flags = rt6->rt6i_flags;
4699         } else {
4700                 rt6_dst = &rt->fib6_dst;
4701                 rt6_src = &rt->fib6_src;
4702                 rt6_flags = rt->fib6_flags;
4703         }
4704
4705         rtm = nlmsg_data(nlh);
4706         rtm->rtm_family = AF_INET6;
4707         rtm->rtm_dst_len = rt6_dst->plen;
4708         rtm->rtm_src_len = rt6_src->plen;
4709         rtm->rtm_tos = 0;
4710         if (rt->fib6_table)
4711                 table = rt->fib6_table->tb6_id;
4712         else
4713                 table = RT6_TABLE_UNSPEC;
4714         rtm->rtm_table = table < 256 ? table : RT_TABLE_COMPAT;
4715         if (nla_put_u32(skb, RTA_TABLE, table))
4716                 goto nla_put_failure;
4717
4718         rtm->rtm_type = rt->fib6_type;
4719         rtm->rtm_flags = 0;
4720         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
4721         rtm->rtm_protocol = rt->fib6_protocol;
4722
4723         if (rt6_flags & RTF_CACHE)
4724                 rtm->rtm_flags |= RTM_F_CLONED;
4725
4726         if (dest) {
4727                 if (nla_put_in6_addr(skb, RTA_DST, dest))
4728                         goto nla_put_failure;
4729                 rtm->rtm_dst_len = 128;
4730         } else if (rtm->rtm_dst_len)
4731                 if (nla_put_in6_addr(skb, RTA_DST, &rt6_dst->addr))
4732                         goto nla_put_failure;
4733 #ifdef CONFIG_IPV6_SUBTREES
4734         if (src) {
4735                 if (nla_put_in6_addr(skb, RTA_SRC, src))
4736                         goto nla_put_failure;
4737                 rtm->rtm_src_len = 128;
4738         } else if (rtm->rtm_src_len &&
4739                    nla_put_in6_addr(skb, RTA_SRC, &rt6_src->addr))
4740                 goto nla_put_failure;
4741 #endif
4742         if (iif) {
4743 #ifdef CONFIG_IPV6_MROUTE
4744                 if (ipv6_addr_is_multicast(&rt6_dst->addr)) {
4745                         int err = ip6mr_get_route(net, skb, rtm, portid);
4746
4747                         if (err == 0)
4748                                 return 0;
4749                         if (err < 0)
4750                                 goto nla_put_failure;
4751                 } else
4752 #endif
4753                         if (nla_put_u32(skb, RTA_IIF, iif))
4754                                 goto nla_put_failure;
4755         } else if (dest) {
4756                 struct in6_addr saddr_buf;
4757                 if (ip6_route_get_saddr(net, rt, dest, 0, &saddr_buf) == 0 &&
4758                     nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
4759                         goto nla_put_failure;
4760         }
4761
4762         if (rt->fib6_prefsrc.plen) {
4763                 struct in6_addr saddr_buf;
4764                 saddr_buf = rt->fib6_prefsrc.addr;
4765                 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
4766                         goto nla_put_failure;
4767         }
4768
4769         pmetrics = dst ? dst_metrics_ptr(dst) : rt->fib6_metrics->metrics;
4770         if (rtnetlink_put_metrics(skb, pmetrics) < 0)
4771                 goto nla_put_failure;
4772
4773         if (nla_put_u32(skb, RTA_PRIORITY, rt->fib6_metric))
4774                 goto nla_put_failure;
4775
4776         /* For multipath routes, walk the siblings list and add
4777          * each as a nexthop within RTA_MULTIPATH.
4778          */
4779         if (rt6) {
4780                 if (rt6_flags & RTF_GATEWAY &&
4781                     nla_put_in6_addr(skb, RTA_GATEWAY, &rt6->rt6i_gateway))
4782                         goto nla_put_failure;
4783
4784                 if (dst->dev && nla_put_u32(skb, RTA_OIF, dst->dev->ifindex))
4785                         goto nla_put_failure;
4786         } else if (rt->fib6_nsiblings) {
4787                 struct fib6_info *sibling, *next_sibling;
4788                 struct nlattr *mp;
4789
4790                 mp = nla_nest_start_noflag(skb, RTA_MULTIPATH);
4791                 if (!mp)
4792                         goto nla_put_failure;
4793
4794                 if (fib_add_nexthop(skb, &rt->fib6_nh.nh_common,
4795                                     rt->fib6_nh.fib_nh_weight) < 0)
4796                         goto nla_put_failure;
4797
4798                 list_for_each_entry_safe(sibling, next_sibling,
4799                                          &rt->fib6_siblings, fib6_siblings) {
4800                         if (fib_add_nexthop(skb, &sibling->fib6_nh.nh_common,
4801                                             sibling->fib6_nh.fib_nh_weight) < 0)
4802                                 goto nla_put_failure;
4803                 }
4804
4805                 nla_nest_end(skb, mp);
4806         } else {
4807                 unsigned char nh_flags = 0;
4808
4809                 if (fib_nexthop_info(skb, &rt->fib6_nh.nh_common,
4810                                      &nh_flags, false) < 0)
4811                         goto nla_put_failure;
4812
4813                 rtm->rtm_flags |= nh_flags;
4814         }
4815
4816         if (rt6_flags & RTF_EXPIRES) {
4817                 expires = dst ? dst->expires : rt->expires;
4818                 expires -= jiffies;
4819         }
4820
4821         if (rtnl_put_cacheinfo(skb, dst, 0, expires, dst ? dst->error : 0) < 0)
4822                 goto nla_put_failure;
4823
4824         if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt6_flags)))
4825                 goto nla_put_failure;
4826
4827
4828         nlmsg_end(skb, nlh);
4829         return 0;
4830
4831 nla_put_failure:
4832         nlmsg_cancel(skb, nlh);
4833         return -EMSGSIZE;
4834 }
4835
4836 static bool fib6_info_uses_dev(const struct fib6_info *f6i,
4837                                const struct net_device *dev)
4838 {
4839         if (f6i->fib6_nh.fib_nh_dev == dev)
4840                 return true;
4841
4842         if (f6i->fib6_nsiblings) {
4843                 struct fib6_info *sibling, *next_sibling;
4844
4845                 list_for_each_entry_safe(sibling, next_sibling,
4846                                          &f6i->fib6_siblings, fib6_siblings) {
4847                         if (sibling->fib6_nh.fib_nh_dev == dev)
4848                                 return true;
4849                 }
4850         }
4851
4852         return false;
4853 }
4854
4855 int rt6_dump_route(struct fib6_info *rt, void *p_arg)
4856 {
4857         struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
4858         struct fib_dump_filter *filter = &arg->filter;
4859         unsigned int flags = NLM_F_MULTI;
4860         struct net *net = arg->net;
4861
4862         if (rt == net->ipv6.fib6_null_entry)
4863                 return 0;
4864
4865         if ((filter->flags & RTM_F_PREFIX) &&
4866             !(rt->fib6_flags & RTF_PREFIX_RT)) {
4867                 /* success since this is not a prefix route */
4868                 return 1;
4869         }
4870         if (filter->filter_set) {
4871                 if ((filter->rt_type && rt->fib6_type != filter->rt_type) ||
4872                     (filter->dev && !fib6_info_uses_dev(rt, filter->dev)) ||
4873                     (filter->protocol && rt->fib6_protocol != filter->protocol)) {
4874                         return 1;
4875                 }
4876                 flags |= NLM_F_DUMP_FILTERED;
4877         }
4878
4879         return rt6_fill_node(net, arg->skb, rt, NULL, NULL, NULL, 0,
4880                              RTM_NEWROUTE, NETLINK_CB(arg->cb->skb).portid,
4881                              arg->cb->nlh->nlmsg_seq, flags);
4882 }
4883
4884 static int inet6_rtm_valid_getroute_req(struct sk_buff *skb,
4885                                         const struct nlmsghdr *nlh,
4886                                         struct nlattr **tb,
4887                                         struct netlink_ext_ack *extack)
4888 {
4889         struct rtmsg *rtm;
4890         int i, err;
4891
4892         if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm))) {
4893                 NL_SET_ERR_MSG_MOD(extack,
4894                                    "Invalid header for get route request");
4895                 return -EINVAL;
4896         }
4897
4898         if (!netlink_strict_get_check(skb))
4899                 return nlmsg_parse_deprecated(nlh, sizeof(*rtm), tb, RTA_MAX,
4900                                               rtm_ipv6_policy, extack);
4901
4902         rtm = nlmsg_data(nlh);
4903         if ((rtm->rtm_src_len && rtm->rtm_src_len != 128) ||
4904             (rtm->rtm_dst_len && rtm->rtm_dst_len != 128) ||
4905             rtm->rtm_table || rtm->rtm_protocol || rtm->rtm_scope ||
4906             rtm->rtm_type) {
4907                 NL_SET_ERR_MSG_MOD(extack, "Invalid values in header for get route request");
4908                 return -EINVAL;
4909         }
4910         if (rtm->rtm_flags & ~RTM_F_FIB_MATCH) {
4911                 NL_SET_ERR_MSG_MOD(extack,
4912                                    "Invalid flags for get route request");
4913                 return -EINVAL;
4914         }
4915
4916         err = nlmsg_parse_deprecated_strict(nlh, sizeof(*rtm), tb, RTA_MAX,
4917                                             rtm_ipv6_policy, extack);
4918         if (err)
4919                 return err;
4920
4921         if ((tb[RTA_SRC] && !rtm->rtm_src_len) ||
4922             (tb[RTA_DST] && !rtm->rtm_dst_len)) {
4923                 NL_SET_ERR_MSG_MOD(extack, "rtm_src_len and rtm_dst_len must be 128 for IPv6");
4924                 return -EINVAL;
4925         }
4926
4927         for (i = 0; i <= RTA_MAX; i++) {
4928                 if (!tb[i])
4929                         continue;
4930
4931                 switch (i) {
4932                 case RTA_SRC:
4933                 case RTA_DST:
4934                 case RTA_IIF:
4935                 case RTA_OIF:
4936                 case RTA_MARK:
4937                 case RTA_UID:
4938                 case RTA_SPORT:
4939                 case RTA_DPORT:
4940                 case RTA_IP_PROTO:
4941                         break;
4942                 default:
4943                         NL_SET_ERR_MSG_MOD(extack, "Unsupported attribute in get route request");
4944                         return -EINVAL;
4945                 }
4946         }
4947
4948         return 0;
4949 }
4950
4951 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
4952                               struct netlink_ext_ack *extack)
4953 {
4954         struct net *net = sock_net(in_skb->sk);
4955         struct nlattr *tb[RTA_MAX+1];
4956         int err, iif = 0, oif = 0;
4957         struct fib6_info *from;
4958         struct dst_entry *dst;
4959         struct rt6_info *rt;
4960         struct sk_buff *skb;
4961         struct rtmsg *rtm;
4962         struct flowi6 fl6 = {};
4963         bool fibmatch;
4964
4965         err = inet6_rtm_valid_getroute_req(in_skb, nlh, tb, extack);
4966         if (err < 0)
4967                 goto errout;
4968
4969         err = -EINVAL;
4970         rtm = nlmsg_data(nlh);
4971         fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);
4972         fibmatch = !!(rtm->rtm_flags & RTM_F_FIB_MATCH);
4973
4974         if (tb[RTA_SRC]) {
4975                 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
4976                         goto errout;
4977
4978                 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
4979         }
4980
4981         if (tb[RTA_DST]) {
4982                 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
4983                         goto errout;
4984
4985                 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
4986         }
4987
4988         if (tb[RTA_IIF])
4989                 iif = nla_get_u32(tb[RTA_IIF]);
4990
4991         if (tb[RTA_OIF])
4992                 oif = nla_get_u32(tb[RTA_OIF]);
4993
4994         if (tb[RTA_MARK])
4995                 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
4996
4997         if (tb[RTA_UID])
4998                 fl6.flowi6_uid = make_kuid(current_user_ns(),
4999                                            nla_get_u32(tb[RTA_UID]));
5000         else
5001                 fl6.flowi6_uid = iif ? INVALID_UID : current_uid();
5002
5003         if (tb[RTA_SPORT])
5004                 fl6.fl6_sport = nla_get_be16(tb[RTA_SPORT]);
5005
5006         if (tb[RTA_DPORT])
5007                 fl6.fl6_dport = nla_get_be16(tb[RTA_DPORT]);
5008
5009         if (tb[RTA_IP_PROTO]) {
5010                 err = rtm_getroute_parse_ip_proto(tb[RTA_IP_PROTO],
5011                                                   &fl6.flowi6_proto, AF_INET6,
5012                                                   extack);
5013                 if (err)
5014                         goto errout;
5015         }
5016
5017         if (iif) {
5018                 struct net_device *dev;
5019                 int flags = 0;
5020
5021                 rcu_read_lock();
5022
5023                 dev = dev_get_by_index_rcu(net, iif);
5024                 if (!dev) {
5025                         rcu_read_unlock();
5026                         err = -ENODEV;
5027                         goto errout;
5028                 }
5029
5030                 fl6.flowi6_iif = iif;
5031
5032                 if (!ipv6_addr_any(&fl6.saddr))
5033                         flags |= RT6_LOOKUP_F_HAS_SADDR;
5034
5035                 dst = ip6_route_input_lookup(net, dev, &fl6, NULL, flags);
5036
5037                 rcu_read_unlock();
5038         } else {
5039                 fl6.flowi6_oif = oif;
5040
5041                 dst = ip6_route_output(net, NULL, &fl6);
5042         }
5043
5044
5045         rt = container_of(dst, struct rt6_info, dst);
5046         if (rt->dst.error) {
5047                 err = rt->dst.error;
5048                 ip6_rt_put(rt);
5049                 goto errout;
5050         }
5051
5052         if (rt == net->ipv6.ip6_null_entry) {
5053                 err = rt->dst.error;
5054                 ip6_rt_put(rt);
5055                 goto errout;
5056         }
5057
5058         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
5059         if (!skb) {
5060                 ip6_rt_put(rt);
5061                 err = -ENOBUFS;
5062                 goto errout;
5063         }
5064
5065         skb_dst_set(skb, &rt->dst);
5066
5067         rcu_read_lock();
5068         from = rcu_dereference(rt->from);
5069         if (from) {
5070                 if (fibmatch)
5071                         err = rt6_fill_node(net, skb, from, NULL, NULL, NULL,
5072                                             iif, RTM_NEWROUTE,
5073                                             NETLINK_CB(in_skb).portid,
5074                                             nlh->nlmsg_seq, 0);
5075                 else
5076                         err = rt6_fill_node(net, skb, from, dst, &fl6.daddr,
5077                                             &fl6.saddr, iif, RTM_NEWROUTE,
5078                                             NETLINK_CB(in_skb).portid,
5079                                             nlh->nlmsg_seq, 0);
5080         } else {
5081                 err = -ENETUNREACH;
5082         }
5083         rcu_read_unlock();
5084
5085         if (err < 0) {
5086                 kfree_skb(skb);
5087                 goto errout;
5088         }
5089
5090         err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
5091 errout:
5092         return err;
5093 }
5094
5095 void inet6_rt_notify(int event, struct fib6_info *rt, struct nl_info *info,
5096                      unsigned int nlm_flags)
5097 {
5098         struct sk_buff *skb;
5099         struct net *net = info->nl_net;
5100         u32 seq;
5101         int err;
5102
5103         err = -ENOBUFS;
5104         seq = info->nlh ? info->nlh->nlmsg_seq : 0;
5105
5106         skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
5107         if (!skb)
5108                 goto errout;
5109
5110         err = rt6_fill_node(net, skb, rt, NULL, NULL, NULL, 0,
5111                             event, info->portid, seq, nlm_flags);
5112         if (err < 0) {
5113                 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
5114                 WARN_ON(err == -EMSGSIZE);
5115                 kfree_skb(skb);
5116                 goto errout;
5117         }
5118         rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
5119                     info->nlh, gfp_any());
5120         return;
5121 errout:
5122         if (err < 0)
5123                 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
5124 }
5125
5126 static int ip6_route_dev_notify(struct notifier_block *this,
5127                                 unsigned long event, void *ptr)
5128 {
5129         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
5130         struct net *net = dev_net(dev);
5131
5132         if (!(dev->flags & IFF_LOOPBACK))
5133                 return NOTIFY_OK;
5134
5135         if (event == NETDEV_REGISTER) {
5136                 net->ipv6.fib6_null_entry->fib6_nh.fib_nh_dev = dev;
5137                 net->ipv6.ip6_null_entry->dst.dev = dev;
5138                 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
5139 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5140                 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
5141                 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
5142                 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
5143                 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
5144 #endif
5145          } else if (event == NETDEV_UNREGISTER &&
5146                     dev->reg_state != NETREG_UNREGISTERED) {
5147                 /* NETDEV_UNREGISTER could be fired for multiple times by
5148                  * netdev_wait_allrefs(). Make sure we only call this once.
5149                  */
5150                 in6_dev_put_clear(&net->ipv6.ip6_null_entry->rt6i_idev);
5151 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5152                 in6_dev_put_clear(&net->ipv6.ip6_prohibit_entry->rt6i_idev);
5153                 in6_dev_put_clear(&net->ipv6.ip6_blk_hole_entry->rt6i_idev);
5154 #endif
5155         }
5156
5157         return NOTIFY_OK;
5158 }
5159
5160 /*
5161  *      /proc
5162  */
5163
5164 #ifdef CONFIG_PROC_FS
5165 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
5166 {
5167         struct net *net = (struct net *)seq->private;
5168         seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
5169                    net->ipv6.rt6_stats->fib_nodes,
5170                    net->ipv6.rt6_stats->fib_route_nodes,
5171                    atomic_read(&net->ipv6.rt6_stats->fib_rt_alloc),
5172                    net->ipv6.rt6_stats->fib_rt_entries,
5173                    net->ipv6.rt6_stats->fib_rt_cache,
5174                    dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
5175                    net->ipv6.rt6_stats->fib_discarded_routes);
5176
5177         return 0;
5178 }
5179 #endif  /* CONFIG_PROC_FS */
5180
5181 #ifdef CONFIG_SYSCTL
5182
5183 static
5184 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
5185                               void __user *buffer, size_t *lenp, loff_t *ppos)
5186 {
5187         struct net *net;
5188         int delay;
5189         int ret;
5190         if (!write)
5191                 return -EINVAL;
5192
5193         net = (struct net *)ctl->extra1;
5194         delay = net->ipv6.sysctl.flush_delay;
5195         ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
5196         if (ret)
5197                 return ret;
5198
5199         fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
5200         return 0;
5201 }
5202
5203 static int zero;
5204 static int one = 1;
5205
5206 static struct ctl_table ipv6_route_table_template[] = {
5207         {
5208                 .procname       =       "flush",
5209                 .data           =       &init_net.ipv6.sysctl.flush_delay,
5210                 .maxlen         =       sizeof(int),
5211                 .mode           =       0200,
5212                 .proc_handler   =       ipv6_sysctl_rtcache_flush
5213         },
5214         {
5215                 .procname       =       "gc_thresh",
5216                 .data           =       &ip6_dst_ops_template.gc_thresh,
5217                 .maxlen         =       sizeof(int),
5218                 .mode           =       0644,
5219                 .proc_handler   =       proc_dointvec,
5220         },
5221         {
5222                 .procname       =       "max_size",
5223                 .data           =       &init_net.ipv6.sysctl.ip6_rt_max_size,
5224                 .maxlen         =       sizeof(int),
5225                 .mode           =       0644,
5226                 .proc_handler   =       proc_dointvec,
5227         },
5228         {
5229                 .procname       =       "gc_min_interval",
5230                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
5231                 .maxlen         =       sizeof(int),
5232                 .mode           =       0644,
5233                 .proc_handler   =       proc_dointvec_jiffies,
5234         },
5235         {
5236                 .procname       =       "gc_timeout",
5237                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
5238                 .maxlen         =       sizeof(int),
5239                 .mode           =       0644,
5240                 .proc_handler   =       proc_dointvec_jiffies,
5241         },
5242         {
5243                 .procname       =       "gc_interval",
5244                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_interval,
5245                 .maxlen         =       sizeof(int),
5246                 .mode           =       0644,
5247                 .proc_handler   =       proc_dointvec_jiffies,
5248         },
5249         {
5250                 .procname       =       "gc_elasticity",
5251                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
5252                 .maxlen         =       sizeof(int),
5253                 .mode           =       0644,
5254                 .proc_handler   =       proc_dointvec,
5255         },
5256         {
5257                 .procname       =       "mtu_expires",
5258                 .data           =       &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
5259                 .maxlen         =       sizeof(int),
5260                 .mode           =       0644,
5261                 .proc_handler   =       proc_dointvec_jiffies,
5262         },
5263         {
5264                 .procname       =       "min_adv_mss",
5265                 .data           =       &init_net.ipv6.sysctl.ip6_rt_min_advmss,
5266                 .maxlen         =       sizeof(int),
5267                 .mode           =       0644,
5268                 .proc_handler   =       proc_dointvec,
5269         },
5270         {
5271                 .procname       =       "gc_min_interval_ms",
5272                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
5273                 .maxlen         =       sizeof(int),
5274                 .mode           =       0644,
5275                 .proc_handler   =       proc_dointvec_ms_jiffies,
5276         },
5277         {
5278                 .procname       =       "skip_notify_on_dev_down",
5279                 .data           =       &init_net.ipv6.sysctl.skip_notify_on_dev_down,
5280                 .maxlen         =       sizeof(int),
5281                 .mode           =       0644,
5282                 .proc_handler   =       proc_dointvec,
5283                 .extra1         =       &zero,
5284                 .extra2         =       &one,
5285         },
5286         { }
5287 };
5288
5289 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
5290 {
5291         struct ctl_table *table;
5292
5293         table = kmemdup(ipv6_route_table_template,
5294                         sizeof(ipv6_route_table_template),
5295                         GFP_KERNEL);
5296
5297         if (table) {
5298                 table[0].data = &net->ipv6.sysctl.flush_delay;
5299                 table[0].extra1 = net;
5300                 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5301                 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
5302                 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
5303                 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
5304                 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
5305                 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
5306                 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
5307                 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
5308                 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
5309                 table[10].data = &net->ipv6.sysctl.skip_notify_on_dev_down;
5310
5311                 /* Don't export sysctls to unprivileged users */
5312                 if (net->user_ns != &init_user_ns)
5313                         table[0].procname = NULL;
5314         }
5315
5316         return table;
5317 }
5318 #endif
5319
5320 static int __net_init ip6_route_net_init(struct net *net)
5321 {
5322         int ret = -ENOMEM;
5323
5324         memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
5325                sizeof(net->ipv6.ip6_dst_ops));
5326
5327         if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
5328                 goto out_ip6_dst_ops;
5329
5330         net->ipv6.fib6_null_entry = kmemdup(&fib6_null_entry_template,
5331                                             sizeof(*net->ipv6.fib6_null_entry),
5332                                             GFP_KERNEL);
5333         if (!net->ipv6.fib6_null_entry)
5334                 goto out_ip6_dst_entries;
5335
5336         net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
5337                                            sizeof(*net->ipv6.ip6_null_entry),
5338                                            GFP_KERNEL);
5339         if (!net->ipv6.ip6_null_entry)
5340                 goto out_fib6_null_entry;
5341         net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
5342         dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
5343                          ip6_template_metrics, true);
5344
5345 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5346         net->ipv6.fib6_has_custom_rules = false;
5347         net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
5348                                                sizeof(*net->ipv6.ip6_prohibit_entry),
5349                                                GFP_KERNEL);
5350         if (!net->ipv6.ip6_prohibit_entry)
5351                 goto out_ip6_null_entry;
5352         net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
5353         dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
5354                          ip6_template_metrics, true);
5355
5356         net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
5357                                                sizeof(*net->ipv6.ip6_blk_hole_entry),
5358                                                GFP_KERNEL);
5359         if (!net->ipv6.ip6_blk_hole_entry)
5360                 goto out_ip6_prohibit_entry;
5361         net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
5362         dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
5363                          ip6_template_metrics, true);
5364 #endif
5365
5366         net->ipv6.sysctl.flush_delay = 0;
5367         net->ipv6.sysctl.ip6_rt_max_size = 4096;
5368         net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
5369         net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
5370         net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
5371         net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
5372         net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
5373         net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
5374         net->ipv6.sysctl.skip_notify_on_dev_down = 0;
5375
5376         net->ipv6.ip6_rt_gc_expire = 30*HZ;
5377
5378         ret = 0;
5379 out:
5380         return ret;
5381
5382 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5383 out_ip6_prohibit_entry:
5384         kfree(net->ipv6.ip6_prohibit_entry);
5385 out_ip6_null_entry:
5386         kfree(net->ipv6.ip6_null_entry);
5387 #endif
5388 out_fib6_null_entry:
5389         kfree(net->ipv6.fib6_null_entry);
5390 out_ip6_dst_entries:
5391         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
5392 out_ip6_dst_ops:
5393         goto out;
5394 }
5395
5396 static void __net_exit ip6_route_net_exit(struct net *net)
5397 {
5398         kfree(net->ipv6.fib6_null_entry);
5399         kfree(net->ipv6.ip6_null_entry);
5400 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5401         kfree(net->ipv6.ip6_prohibit_entry);
5402         kfree(net->ipv6.ip6_blk_hole_entry);
5403 #endif
5404         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
5405 }
5406
5407 static int __net_init ip6_route_net_init_late(struct net *net)
5408 {
5409 #ifdef CONFIG_PROC_FS
5410         proc_create_net("ipv6_route", 0, net->proc_net, &ipv6_route_seq_ops,
5411                         sizeof(struct ipv6_route_iter));
5412         proc_create_net_single("rt6_stats", 0444, net->proc_net,
5413                         rt6_stats_seq_show, NULL);
5414 #endif
5415         return 0;
5416 }
5417
5418 static void __net_exit ip6_route_net_exit_late(struct net *net)
5419 {
5420 #ifdef CONFIG_PROC_FS
5421         remove_proc_entry("ipv6_route", net->proc_net);
5422         remove_proc_entry("rt6_stats", net->proc_net);
5423 #endif
5424 }
5425
5426 static struct pernet_operations ip6_route_net_ops = {
5427         .init = ip6_route_net_init,
5428         .exit = ip6_route_net_exit,
5429 };
5430
5431 static int __net_init ipv6_inetpeer_init(struct net *net)
5432 {
5433         struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
5434
5435         if (!bp)
5436                 return -ENOMEM;
5437         inet_peer_base_init(bp);
5438         net->ipv6.peers = bp;
5439         return 0;
5440 }
5441
5442 static void __net_exit ipv6_inetpeer_exit(struct net *net)
5443 {
5444         struct inet_peer_base *bp = net->ipv6.peers;
5445
5446         net->ipv6.peers = NULL;
5447         inetpeer_invalidate_tree(bp);
5448         kfree(bp);
5449 }
5450
5451 static struct pernet_operations ipv6_inetpeer_ops = {
5452         .init   =       ipv6_inetpeer_init,
5453         .exit   =       ipv6_inetpeer_exit,
5454 };
5455
5456 static struct pernet_operations ip6_route_net_late_ops = {
5457         .init = ip6_route_net_init_late,
5458         .exit = ip6_route_net_exit_late,
5459 };
5460
5461 static struct notifier_block ip6_route_dev_notifier = {
5462         .notifier_call = ip6_route_dev_notify,
5463         .priority = ADDRCONF_NOTIFY_PRIORITY - 10,
5464 };
5465
5466 void __init ip6_route_init_special_entries(void)
5467 {
5468         /* Registering of the loopback is done before this portion of code,
5469          * the loopback reference in rt6_info will not be taken, do it
5470          * manually for init_net */
5471         init_net.ipv6.fib6_null_entry->fib6_nh.fib_nh_dev = init_net.loopback_dev;
5472         init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
5473         init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
5474   #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5475         init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
5476         init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
5477         init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
5478         init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
5479   #endif
5480 }
5481
5482 int __init ip6_route_init(void)
5483 {
5484         int ret;
5485         int cpu;
5486
5487         ret = -ENOMEM;
5488         ip6_dst_ops_template.kmem_cachep =
5489                 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
5490                                   SLAB_HWCACHE_ALIGN, NULL);
5491         if (!ip6_dst_ops_template.kmem_cachep)
5492                 goto out;
5493
5494         ret = dst_entries_init(&ip6_dst_blackhole_ops);
5495         if (ret)
5496                 goto out_kmem_cache;
5497
5498         ret = register_pernet_subsys(&ipv6_inetpeer_ops);
5499         if (ret)
5500                 goto out_dst_entries;
5501
5502         ret = register_pernet_subsys(&ip6_route_net_ops);
5503         if (ret)
5504                 goto out_register_inetpeer;
5505
5506         ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
5507
5508         ret = fib6_init();
5509         if (ret)
5510                 goto out_register_subsys;
5511
5512         ret = xfrm6_init();
5513         if (ret)
5514                 goto out_fib6_init;
5515
5516         ret = fib6_rules_init();
5517         if (ret)
5518                 goto xfrm6_init;
5519
5520         ret = register_pernet_subsys(&ip6_route_net_late_ops);
5521         if (ret)
5522                 goto fib6_rules_init;
5523
5524         ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_NEWROUTE,
5525                                    inet6_rtm_newroute, NULL, 0);
5526         if (ret < 0)
5527                 goto out_register_late_subsys;
5528
5529         ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_DELROUTE,
5530                                    inet6_rtm_delroute, NULL, 0);
5531         if (ret < 0)
5532                 goto out_register_late_subsys;
5533
5534         ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETROUTE,
5535                                    inet6_rtm_getroute, NULL,
5536                                    RTNL_FLAG_DOIT_UNLOCKED);
5537         if (ret < 0)
5538                 goto out_register_late_subsys;
5539
5540         ret = register_netdevice_notifier(&ip6_route_dev_notifier);
5541         if (ret)
5542                 goto out_register_late_subsys;
5543
5544         for_each_possible_cpu(cpu) {
5545                 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
5546
5547                 INIT_LIST_HEAD(&ul->head);
5548                 spin_lock_init(&ul->lock);
5549         }
5550
5551 out:
5552         return ret;
5553
5554 out_register_late_subsys:
5555         rtnl_unregister_all(PF_INET6);
5556         unregister_pernet_subsys(&ip6_route_net_late_ops);
5557 fib6_rules_init:
5558         fib6_rules_cleanup();
5559 xfrm6_init:
5560         xfrm6_fini();
5561 out_fib6_init:
5562         fib6_gc_cleanup();
5563 out_register_subsys:
5564         unregister_pernet_subsys(&ip6_route_net_ops);
5565 out_register_inetpeer:
5566         unregister_pernet_subsys(&ipv6_inetpeer_ops);
5567 out_dst_entries:
5568         dst_entries_destroy(&ip6_dst_blackhole_ops);
5569 out_kmem_cache:
5570         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
5571         goto out;
5572 }
5573
5574 void ip6_route_cleanup(void)
5575 {
5576         unregister_netdevice_notifier(&ip6_route_dev_notifier);
5577         unregister_pernet_subsys(&ip6_route_net_late_ops);
5578         fib6_rules_cleanup();
5579         xfrm6_fini();
5580         fib6_gc_cleanup();
5581         unregister_pernet_subsys(&ipv6_inetpeer_ops);
5582         unregister_pernet_subsys(&ip6_route_net_ops);
5583         dst_entries_destroy(&ip6_dst_blackhole_ops);
5584         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
5585 }