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