net/ipv6/route.c

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