2 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
16 * YOSHIFUJI Hideaki @USAGI
17 * reworked default router selection.
18 * - respect outgoing interface
19 * - select from (probably) reachable routers (i.e.
20 * routers in REACHABLE, STALE, DELAY or PROBE states).
21 * - always select the same router if it is (probably)
22 * reachable. otherwise, round-robin the list.
24 * Fixed routing subtrees.
27 #define pr_fmt(fmt) "IPv6: " fmt
29 #include <linux/capability.h>
30 #include <linux/errno.h>
31 #include <linux/export.h>
32 #include <linux/types.h>
33 #include <linux/times.h>
34 #include <linux/socket.h>
35 #include <linux/sockios.h>
36 #include <linux/net.h>
37 #include <linux/route.h>
38 #include <linux/netdevice.h>
39 #include <linux/in6.h>
40 #include <linux/mroute6.h>
41 #include <linux/init.h>
42 #include <linux/if_arp.h>
43 #include <linux/proc_fs.h>
44 #include <linux/seq_file.h>
45 #include <linux/nsproxy.h>
46 #include <linux/slab.h>
47 #include <net/net_namespace.h>
50 #include <net/ip6_fib.h>
51 #include <net/ip6_route.h>
52 #include <net/ndisc.h>
53 #include <net/addrconf.h>
55 #include <linux/rtnetlink.h>
57 #include <net/dst_metadata.h>
59 #include <net/netevent.h>
60 #include <net/netlink.h>
61 #include <net/nexthop.h>
62 #include <net/lwtunnel.h>
63 #include <net/ip_tunnels.h>
64 #include <net/l3mdev.h>
65 #include <trace/events/fib6.h>
67 #include <linux/uaccess.h>
70 #include <linux/sysctl.h>
74 RT6_NUD_FAIL_HARD = -3,
75 RT6_NUD_FAIL_PROBE = -2,
76 RT6_NUD_FAIL_DO_RR = -1,
80 static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort);
81 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
82 static unsigned int ip6_default_advmss(const struct dst_entry *dst);
83 static unsigned int ip6_mtu(const struct dst_entry *dst);
84 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
85 static void ip6_dst_destroy(struct dst_entry *);
86 static void ip6_dst_ifdown(struct dst_entry *,
87 struct net_device *dev, int how);
88 static int ip6_dst_gc(struct dst_ops *ops);
90 static int ip6_pkt_discard(struct sk_buff *skb);
91 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb);
92 static int ip6_pkt_prohibit(struct sk_buff *skb);
93 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb);
94 static void ip6_link_failure(struct sk_buff *skb);
95 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
96 struct sk_buff *skb, u32 mtu);
97 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
99 static void rt6_dst_from_metrics_check(struct rt6_info *rt);
100 static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
101 static size_t rt6_nlmsg_size(struct rt6_info *rt);
102 static int rt6_fill_node(struct net *net,
103 struct sk_buff *skb, struct rt6_info *rt,
104 struct in6_addr *dst, struct in6_addr *src,
105 int iif, int type, u32 portid, u32 seq,
108 #ifdef CONFIG_IPV6_ROUTE_INFO
109 static struct rt6_info *rt6_add_route_info(struct net *net,
110 const struct in6_addr *prefix, int prefixlen,
111 const struct in6_addr *gwaddr,
112 struct net_device *dev,
114 static struct rt6_info *rt6_get_route_info(struct net *net,
115 const struct in6_addr *prefix, int prefixlen,
116 const struct in6_addr *gwaddr,
117 struct net_device *dev);
120 struct uncached_list {
122 struct list_head head;
125 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
127 static void rt6_uncached_list_add(struct rt6_info *rt)
129 struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);
131 rt->dst.flags |= DST_NOCACHE;
132 rt->rt6i_uncached_list = ul;
134 spin_lock_bh(&ul->lock);
135 list_add_tail(&rt->rt6i_uncached, &ul->head);
136 spin_unlock_bh(&ul->lock);
139 static void rt6_uncached_list_del(struct rt6_info *rt)
141 if (!list_empty(&rt->rt6i_uncached)) {
142 struct uncached_list *ul = rt->rt6i_uncached_list;
144 spin_lock_bh(&ul->lock);
145 list_del(&rt->rt6i_uncached);
146 spin_unlock_bh(&ul->lock);
150 static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
152 struct net_device *loopback_dev = net->loopback_dev;
155 if (dev == loopback_dev)
158 for_each_possible_cpu(cpu) {
159 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
162 spin_lock_bh(&ul->lock);
163 list_for_each_entry(rt, &ul->head, rt6i_uncached) {
164 struct inet6_dev *rt_idev = rt->rt6i_idev;
165 struct net_device *rt_dev = rt->dst.dev;
167 if (rt_idev->dev == dev) {
168 rt->rt6i_idev = in6_dev_get(loopback_dev);
169 in6_dev_put(rt_idev);
173 rt->dst.dev = loopback_dev;
174 dev_hold(rt->dst.dev);
178 spin_unlock_bh(&ul->lock);
182 static u32 *rt6_pcpu_cow_metrics(struct rt6_info *rt)
184 return dst_metrics_write_ptr(rt->dst.from);
187 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
189 struct rt6_info *rt = (struct rt6_info *)dst;
191 if (rt->rt6i_flags & RTF_PCPU)
192 return rt6_pcpu_cow_metrics(rt);
193 else if (rt->rt6i_flags & RTF_CACHE)
196 return dst_cow_metrics_generic(dst, old);
199 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
203 struct in6_addr *p = &rt->rt6i_gateway;
205 if (!ipv6_addr_any(p))
206 return (const void *) p;
208 return &ipv6_hdr(skb)->daddr;
212 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
216 struct rt6_info *rt = (struct rt6_info *) dst;
219 daddr = choose_neigh_daddr(rt, skb, daddr);
220 n = __ipv6_neigh_lookup(dst->dev, daddr);
223 return neigh_create(&nd_tbl, daddr, dst->dev);
226 static void ip6_confirm_neigh(const struct dst_entry *dst, const void *daddr)
228 struct net_device *dev = dst->dev;
229 struct rt6_info *rt = (struct rt6_info *)dst;
231 daddr = choose_neigh_daddr(rt, NULL, daddr);
234 if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
236 if (ipv6_addr_is_multicast((const struct in6_addr *)daddr))
238 __ipv6_confirm_neigh(dev, daddr);
241 static struct dst_ops ip6_dst_ops_template = {
245 .check = ip6_dst_check,
246 .default_advmss = ip6_default_advmss,
248 .cow_metrics = ipv6_cow_metrics,
249 .destroy = ip6_dst_destroy,
250 .ifdown = ip6_dst_ifdown,
251 .negative_advice = ip6_negative_advice,
252 .link_failure = ip6_link_failure,
253 .update_pmtu = ip6_rt_update_pmtu,
254 .redirect = rt6_do_redirect,
255 .local_out = __ip6_local_out,
256 .neigh_lookup = ip6_neigh_lookup,
257 .confirm_neigh = ip6_confirm_neigh,
260 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
262 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
264 return mtu ? : dst->dev->mtu;
267 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
268 struct sk_buff *skb, u32 mtu)
272 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
277 static struct dst_ops ip6_dst_blackhole_ops = {
279 .destroy = ip6_dst_destroy,
280 .check = ip6_dst_check,
281 .mtu = ip6_blackhole_mtu,
282 .default_advmss = ip6_default_advmss,
283 .update_pmtu = ip6_rt_blackhole_update_pmtu,
284 .redirect = ip6_rt_blackhole_redirect,
285 .cow_metrics = dst_cow_metrics_generic,
286 .neigh_lookup = ip6_neigh_lookup,
289 static const u32 ip6_template_metrics[RTAX_MAX] = {
290 [RTAX_HOPLIMIT - 1] = 0,
293 static const struct rt6_info ip6_null_entry_template = {
295 .__refcnt = ATOMIC_INIT(1),
297 .obsolete = DST_OBSOLETE_FORCE_CHK,
298 .error = -ENETUNREACH,
299 .input = ip6_pkt_discard,
300 .output = ip6_pkt_discard_out,
302 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
303 .rt6i_protocol = RTPROT_KERNEL,
304 .rt6i_metric = ~(u32) 0,
305 .rt6i_ref = ATOMIC_INIT(1),
308 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
310 static const struct rt6_info ip6_prohibit_entry_template = {
312 .__refcnt = ATOMIC_INIT(1),
314 .obsolete = DST_OBSOLETE_FORCE_CHK,
316 .input = ip6_pkt_prohibit,
317 .output = ip6_pkt_prohibit_out,
319 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
320 .rt6i_protocol = RTPROT_KERNEL,
321 .rt6i_metric = ~(u32) 0,
322 .rt6i_ref = ATOMIC_INIT(1),
325 static const struct rt6_info ip6_blk_hole_entry_template = {
327 .__refcnt = ATOMIC_INIT(1),
329 .obsolete = DST_OBSOLETE_FORCE_CHK,
331 .input = dst_discard,
332 .output = dst_discard_out,
334 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
335 .rt6i_protocol = RTPROT_KERNEL,
336 .rt6i_metric = ~(u32) 0,
337 .rt6i_ref = ATOMIC_INIT(1),
342 static void rt6_info_init(struct rt6_info *rt)
344 struct dst_entry *dst = &rt->dst;
346 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
347 INIT_LIST_HEAD(&rt->rt6i_siblings);
348 INIT_LIST_HEAD(&rt->rt6i_uncached);
351 /* allocate dst with ip6_dst_ops */
352 static struct rt6_info *__ip6_dst_alloc(struct net *net,
353 struct net_device *dev,
356 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
357 0, DST_OBSOLETE_FORCE_CHK, flags);
365 struct rt6_info *ip6_dst_alloc(struct net *net,
366 struct net_device *dev,
369 struct rt6_info *rt = __ip6_dst_alloc(net, dev, flags);
372 rt->rt6i_pcpu = alloc_percpu_gfp(struct rt6_info *, GFP_ATOMIC);
376 for_each_possible_cpu(cpu) {
379 p = per_cpu_ptr(rt->rt6i_pcpu, cpu);
380 /* no one shares rt */
384 dst_destroy((struct dst_entry *)rt);
391 EXPORT_SYMBOL(ip6_dst_alloc);
393 static void ip6_dst_destroy(struct dst_entry *dst)
395 struct rt6_info *rt = (struct rt6_info *)dst;
396 struct dst_entry *from = dst->from;
397 struct inet6_dev *idev;
399 dst_destroy_metrics_generic(dst);
400 free_percpu(rt->rt6i_pcpu);
401 rt6_uncached_list_del(rt);
403 idev = rt->rt6i_idev;
405 rt->rt6i_idev = NULL;
413 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
416 struct rt6_info *rt = (struct rt6_info *)dst;
417 struct inet6_dev *idev = rt->rt6i_idev;
418 struct net_device *loopback_dev =
419 dev_net(dev)->loopback_dev;
421 if (dev != loopback_dev) {
422 if (idev && idev->dev == dev) {
423 struct inet6_dev *loopback_idev =
424 in6_dev_get(loopback_dev);
426 rt->rt6i_idev = loopback_idev;
433 static bool __rt6_check_expired(const struct rt6_info *rt)
435 if (rt->rt6i_flags & RTF_EXPIRES)
436 return time_after(jiffies, rt->dst.expires);
441 static bool rt6_check_expired(const struct rt6_info *rt)
443 if (rt->rt6i_flags & RTF_EXPIRES) {
444 if (time_after(jiffies, rt->dst.expires))
446 } else if (rt->dst.from) {
447 return rt6_check_expired((struct rt6_info *) rt->dst.from);
452 /* Multipath route selection:
453 * Hash based function using packet header and flowlabel.
454 * Adapted from fib_info_hashfn()
456 static int rt6_info_hash_nhsfn(unsigned int candidate_count,
457 const struct flowi6 *fl6)
459 return get_hash_from_flowi6(fl6) % candidate_count;
462 static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
463 struct flowi6 *fl6, int oif,
466 struct rt6_info *sibling, *next_sibling;
469 route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
470 /* Don't change the route, if route_choosen == 0
471 * (siblings does not include ourself)
474 list_for_each_entry_safe(sibling, next_sibling,
475 &match->rt6i_siblings, rt6i_siblings) {
477 if (route_choosen == 0) {
478 if (rt6_score_route(sibling, oif, strict) < 0)
488 * Route lookup. Any table->tb6_lock is implied.
491 static inline struct rt6_info *rt6_device_match(struct net *net,
493 const struct in6_addr *saddr,
497 struct rt6_info *local = NULL;
498 struct rt6_info *sprt;
500 if (!oif && ipv6_addr_any(saddr))
503 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
504 struct net_device *dev = sprt->dst.dev;
507 if (dev->ifindex == oif)
509 if (dev->flags & IFF_LOOPBACK) {
510 if (!sprt->rt6i_idev ||
511 sprt->rt6i_idev->dev->ifindex != oif) {
512 if (flags & RT6_LOOKUP_F_IFACE)
515 local->rt6i_idev->dev->ifindex == oif)
521 if (ipv6_chk_addr(net, saddr, dev,
522 flags & RT6_LOOKUP_F_IFACE))
531 if (flags & RT6_LOOKUP_F_IFACE)
532 return net->ipv6.ip6_null_entry;
538 #ifdef CONFIG_IPV6_ROUTER_PREF
539 struct __rt6_probe_work {
540 struct work_struct work;
541 struct in6_addr target;
542 struct net_device *dev;
545 static void rt6_probe_deferred(struct work_struct *w)
547 struct in6_addr mcaddr;
548 struct __rt6_probe_work *work =
549 container_of(w, struct __rt6_probe_work, work);
551 addrconf_addr_solict_mult(&work->target, &mcaddr);
552 ndisc_send_ns(work->dev, &work->target, &mcaddr, NULL, 0);
557 static void rt6_probe(struct rt6_info *rt)
559 struct __rt6_probe_work *work;
560 struct neighbour *neigh;
562 * Okay, this does not seem to be appropriate
563 * for now, however, we need to check if it
564 * is really so; aka Router Reachability Probing.
566 * Router Reachability Probe MUST be rate-limited
567 * to no more than one per minute.
569 if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
572 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
574 if (neigh->nud_state & NUD_VALID)
578 write_lock(&neigh->lock);
579 if (!(neigh->nud_state & NUD_VALID) &&
582 rt->rt6i_idev->cnf.rtr_probe_interval)) {
583 work = kmalloc(sizeof(*work), GFP_ATOMIC);
585 __neigh_set_probe_once(neigh);
587 write_unlock(&neigh->lock);
589 work = kmalloc(sizeof(*work), GFP_ATOMIC);
593 INIT_WORK(&work->work, rt6_probe_deferred);
594 work->target = rt->rt6i_gateway;
595 dev_hold(rt->dst.dev);
596 work->dev = rt->dst.dev;
597 schedule_work(&work->work);
601 rcu_read_unlock_bh();
604 static inline void rt6_probe(struct rt6_info *rt)
610 * Default Router Selection (RFC 2461 6.3.6)
612 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
614 struct net_device *dev = rt->dst.dev;
615 if (!oif || dev->ifindex == oif)
617 if ((dev->flags & IFF_LOOPBACK) &&
618 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
623 static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
625 struct neighbour *neigh;
626 enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
628 if (rt->rt6i_flags & RTF_NONEXTHOP ||
629 !(rt->rt6i_flags & RTF_GATEWAY))
630 return RT6_NUD_SUCCEED;
633 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
635 read_lock(&neigh->lock);
636 if (neigh->nud_state & NUD_VALID)
637 ret = RT6_NUD_SUCCEED;
638 #ifdef CONFIG_IPV6_ROUTER_PREF
639 else if (!(neigh->nud_state & NUD_FAILED))
640 ret = RT6_NUD_SUCCEED;
642 ret = RT6_NUD_FAIL_PROBE;
644 read_unlock(&neigh->lock);
646 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
647 RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
649 rcu_read_unlock_bh();
654 static int rt6_score_route(struct rt6_info *rt, int oif,
659 m = rt6_check_dev(rt, oif);
660 if (!m && (strict & RT6_LOOKUP_F_IFACE))
661 return RT6_NUD_FAIL_HARD;
662 #ifdef CONFIG_IPV6_ROUTER_PREF
663 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
665 if (strict & RT6_LOOKUP_F_REACHABLE) {
666 int n = rt6_check_neigh(rt);
673 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
674 int *mpri, struct rt6_info *match,
678 bool match_do_rr = false;
679 struct inet6_dev *idev = rt->rt6i_idev;
680 struct net_device *dev = rt->dst.dev;
682 if (dev && !netif_carrier_ok(dev) &&
683 idev->cnf.ignore_routes_with_linkdown &&
684 !(strict & RT6_LOOKUP_F_IGNORE_LINKSTATE))
687 if (rt6_check_expired(rt))
690 m = rt6_score_route(rt, oif, strict);
691 if (m == RT6_NUD_FAIL_DO_RR) {
693 m = 0; /* lowest valid score */
694 } else if (m == RT6_NUD_FAIL_HARD) {
698 if (strict & RT6_LOOKUP_F_REACHABLE)
701 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
703 *do_rr = match_do_rr;
711 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
712 struct rt6_info *rr_head,
713 u32 metric, int oif, int strict,
716 struct rt6_info *rt, *match, *cont;
721 for (rt = rr_head; rt; rt = rt->dst.rt6_next) {
722 if (rt->rt6i_metric != metric) {
727 match = find_match(rt, oif, strict, &mpri, match, do_rr);
730 for (rt = fn->leaf; rt && rt != rr_head; rt = rt->dst.rt6_next) {
731 if (rt->rt6i_metric != metric) {
736 match = find_match(rt, oif, strict, &mpri, match, do_rr);
742 for (rt = cont; rt; rt = rt->dst.rt6_next)
743 match = find_match(rt, oif, strict, &mpri, match, do_rr);
748 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
750 struct rt6_info *match, *rt0;
756 fn->rr_ptr = rt0 = fn->leaf;
758 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
762 struct rt6_info *next = rt0->dst.rt6_next;
764 /* no entries matched; do round-robin */
765 if (!next || next->rt6i_metric != rt0->rt6i_metric)
772 net = dev_net(rt0->dst.dev);
773 return match ? match : net->ipv6.ip6_null_entry;
776 static bool rt6_is_gw_or_nonexthop(const struct rt6_info *rt)
778 return (rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY));
781 #ifdef CONFIG_IPV6_ROUTE_INFO
782 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
783 const struct in6_addr *gwaddr)
785 struct net *net = dev_net(dev);
786 struct route_info *rinfo = (struct route_info *) opt;
787 struct in6_addr prefix_buf, *prefix;
789 unsigned long lifetime;
792 if (len < sizeof(struct route_info)) {
796 /* Sanity check for prefix_len and length */
797 if (rinfo->length > 3) {
799 } else if (rinfo->prefix_len > 128) {
801 } else if (rinfo->prefix_len > 64) {
802 if (rinfo->length < 2) {
805 } else if (rinfo->prefix_len > 0) {
806 if (rinfo->length < 1) {
811 pref = rinfo->route_pref;
812 if (pref == ICMPV6_ROUTER_PREF_INVALID)
815 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
817 if (rinfo->length == 3)
818 prefix = (struct in6_addr *)rinfo->prefix;
820 /* this function is safe */
821 ipv6_addr_prefix(&prefix_buf,
822 (struct in6_addr *)rinfo->prefix,
824 prefix = &prefix_buf;
827 if (rinfo->prefix_len == 0)
828 rt = rt6_get_dflt_router(gwaddr, dev);
830 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
833 if (rt && !lifetime) {
839 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr,
842 rt->rt6i_flags = RTF_ROUTEINFO |
843 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
846 if (!addrconf_finite_timeout(lifetime))
847 rt6_clean_expires(rt);
849 rt6_set_expires(rt, jiffies + HZ * lifetime);
857 static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
858 struct in6_addr *saddr)
860 struct fib6_node *pn;
862 if (fn->fn_flags & RTN_TL_ROOT)
865 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
866 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
869 if (fn->fn_flags & RTN_RTINFO)
874 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
875 struct fib6_table *table,
876 struct flowi6 *fl6, int flags)
878 struct fib6_node *fn;
881 read_lock_bh(&table->tb6_lock);
882 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
885 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
886 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
887 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
888 if (rt == net->ipv6.ip6_null_entry) {
889 fn = fib6_backtrack(fn, &fl6->saddr);
893 dst_use(&rt->dst, jiffies);
894 read_unlock_bh(&table->tb6_lock);
896 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
902 struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
905 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
907 EXPORT_SYMBOL_GPL(ip6_route_lookup);
909 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
910 const struct in6_addr *saddr, int oif, int strict)
912 struct flowi6 fl6 = {
916 struct dst_entry *dst;
917 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
920 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
921 flags |= RT6_LOOKUP_F_HAS_SADDR;
924 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
926 return (struct rt6_info *) dst;
932 EXPORT_SYMBOL(rt6_lookup);
934 /* ip6_ins_rt is called with FREE table->tb6_lock.
935 It takes new route entry, the addition fails by any reason the
936 route is freed. In any case, if caller does not hold it, it may
940 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
941 struct mx6_config *mxc)
944 struct fib6_table *table;
946 table = rt->rt6i_table;
947 write_lock_bh(&table->tb6_lock);
948 err = fib6_add(&table->tb6_root, rt, info, mxc);
949 write_unlock_bh(&table->tb6_lock);
954 int ip6_ins_rt(struct rt6_info *rt)
956 struct nl_info info = { .nl_net = dev_net(rt->dst.dev), };
957 struct mx6_config mxc = { .mx = NULL, };
959 return __ip6_ins_rt(rt, &info, &mxc);
962 static struct rt6_info *ip6_rt_cache_alloc(struct rt6_info *ort,
963 const struct in6_addr *daddr,
964 const struct in6_addr *saddr)
972 if (ort->rt6i_flags & (RTF_CACHE | RTF_PCPU))
973 ort = (struct rt6_info *)ort->dst.from;
975 rt = __ip6_dst_alloc(dev_net(ort->dst.dev), ort->dst.dev, 0);
980 ip6_rt_copy_init(rt, ort);
981 rt->rt6i_flags |= RTF_CACHE;
983 rt->dst.flags |= DST_HOST;
984 rt->rt6i_dst.addr = *daddr;
985 rt->rt6i_dst.plen = 128;
987 if (!rt6_is_gw_or_nonexthop(ort)) {
988 if (ort->rt6i_dst.plen != 128 &&
989 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
990 rt->rt6i_flags |= RTF_ANYCAST;
991 #ifdef CONFIG_IPV6_SUBTREES
992 if (rt->rt6i_src.plen && saddr) {
993 rt->rt6i_src.addr = *saddr;
994 rt->rt6i_src.plen = 128;
1002 static struct rt6_info *ip6_rt_pcpu_alloc(struct rt6_info *rt)
1004 struct rt6_info *pcpu_rt;
1006 pcpu_rt = __ip6_dst_alloc(dev_net(rt->dst.dev),
1007 rt->dst.dev, rt->dst.flags);
1011 ip6_rt_copy_init(pcpu_rt, rt);
1012 pcpu_rt->rt6i_protocol = rt->rt6i_protocol;
1013 pcpu_rt->rt6i_flags |= RTF_PCPU;
1017 /* It should be called with read_lock_bh(&tb6_lock) acquired */
1018 static struct rt6_info *rt6_get_pcpu_route(struct rt6_info *rt)
1020 struct rt6_info *pcpu_rt, **p;
1022 p = this_cpu_ptr(rt->rt6i_pcpu);
1026 dst_hold(&pcpu_rt->dst);
1027 rt6_dst_from_metrics_check(pcpu_rt);
1032 static struct rt6_info *rt6_make_pcpu_route(struct rt6_info *rt)
1034 struct fib6_table *table = rt->rt6i_table;
1035 struct rt6_info *pcpu_rt, *prev, **p;
1037 pcpu_rt = ip6_rt_pcpu_alloc(rt);
1039 struct net *net = dev_net(rt->dst.dev);
1041 dst_hold(&net->ipv6.ip6_null_entry->dst);
1042 return net->ipv6.ip6_null_entry;
1045 read_lock_bh(&table->tb6_lock);
1046 if (rt->rt6i_pcpu) {
1047 p = this_cpu_ptr(rt->rt6i_pcpu);
1048 prev = cmpxchg(p, NULL, pcpu_rt);
1050 /* If someone did it before us, return prev instead */
1051 dst_destroy(&pcpu_rt->dst);
1055 /* rt has been removed from the fib6 tree
1056 * before we have a chance to acquire the read_lock.
1057 * In this case, don't brother to create a pcpu rt
1058 * since rt is going away anyway. The next
1059 * dst_check() will trigger a re-lookup.
1061 dst_destroy(&pcpu_rt->dst);
1064 dst_hold(&pcpu_rt->dst);
1065 rt6_dst_from_metrics_check(pcpu_rt);
1066 read_unlock_bh(&table->tb6_lock);
1070 struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table,
1071 int oif, struct flowi6 *fl6, int flags)
1073 struct fib6_node *fn, *saved_fn;
1074 struct rt6_info *rt;
1077 strict |= flags & RT6_LOOKUP_F_IFACE;
1078 strict |= flags & RT6_LOOKUP_F_IGNORE_LINKSTATE;
1079 if (net->ipv6.devconf_all->forwarding == 0)
1080 strict |= RT6_LOOKUP_F_REACHABLE;
1082 read_lock_bh(&table->tb6_lock);
1084 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1087 if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
1091 rt = rt6_select(fn, oif, strict);
1092 if (rt->rt6i_nsiblings)
1093 rt = rt6_multipath_select(rt, fl6, oif, strict);
1094 if (rt == net->ipv6.ip6_null_entry) {
1095 fn = fib6_backtrack(fn, &fl6->saddr);
1097 goto redo_rt6_select;
1098 else if (strict & RT6_LOOKUP_F_REACHABLE) {
1099 /* also consider unreachable route */
1100 strict &= ~RT6_LOOKUP_F_REACHABLE;
1102 goto redo_rt6_select;
1107 if (rt == net->ipv6.ip6_null_entry || (rt->rt6i_flags & RTF_CACHE)) {
1108 dst_use(&rt->dst, jiffies);
1109 read_unlock_bh(&table->tb6_lock);
1111 rt6_dst_from_metrics_check(rt);
1113 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
1115 } else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
1116 !(rt->rt6i_flags & RTF_GATEWAY))) {
1117 /* Create a RTF_CACHE clone which will not be
1118 * owned by the fib6 tree. It is for the special case where
1119 * the daddr in the skb during the neighbor look-up is different
1120 * from the fl6->daddr used to look-up route here.
1123 struct rt6_info *uncached_rt;
1125 dst_use(&rt->dst, jiffies);
1126 read_unlock_bh(&table->tb6_lock);
1128 uncached_rt = ip6_rt_cache_alloc(rt, &fl6->daddr, NULL);
1129 dst_release(&rt->dst);
1132 rt6_uncached_list_add(uncached_rt);
1134 uncached_rt = net->ipv6.ip6_null_entry;
1136 dst_hold(&uncached_rt->dst);
1138 trace_fib6_table_lookup(net, uncached_rt, table->tb6_id, fl6);
1142 /* Get a percpu copy */
1144 struct rt6_info *pcpu_rt;
1146 rt->dst.lastuse = jiffies;
1148 pcpu_rt = rt6_get_pcpu_route(rt);
1151 read_unlock_bh(&table->tb6_lock);
1153 /* We have to do the read_unlock first
1154 * because rt6_make_pcpu_route() may trigger
1155 * ip6_dst_gc() which will take the write_lock.
1158 read_unlock_bh(&table->tb6_lock);
1159 pcpu_rt = rt6_make_pcpu_route(rt);
1160 dst_release(&rt->dst);
1163 trace_fib6_table_lookup(net, pcpu_rt, table->tb6_id, fl6);
1168 EXPORT_SYMBOL_GPL(ip6_pol_route);
1170 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
1171 struct flowi6 *fl6, int flags)
1173 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
1176 struct dst_entry *ip6_route_input_lookup(struct net *net,
1177 struct net_device *dev,
1178 struct flowi6 *fl6, int flags)
1180 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
1181 flags |= RT6_LOOKUP_F_IFACE;
1183 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
1185 EXPORT_SYMBOL_GPL(ip6_route_input_lookup);
1187 void ip6_route_input(struct sk_buff *skb)
1189 const struct ipv6hdr *iph = ipv6_hdr(skb);
1190 struct net *net = dev_net(skb->dev);
1191 int flags = RT6_LOOKUP_F_HAS_SADDR;
1192 struct ip_tunnel_info *tun_info;
1193 struct flowi6 fl6 = {
1194 .flowi6_iif = skb->dev->ifindex,
1195 .daddr = iph->daddr,
1196 .saddr = iph->saddr,
1197 .flowlabel = ip6_flowinfo(iph),
1198 .flowi6_mark = skb->mark,
1199 .flowi6_proto = iph->nexthdr,
1202 tun_info = skb_tunnel_info(skb);
1203 if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
1204 fl6.flowi6_tun_key.tun_id = tun_info->key.tun_id;
1206 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
1209 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
1210 struct flowi6 *fl6, int flags)
1212 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
1215 struct dst_entry *ip6_route_output_flags(struct net *net, const struct sock *sk,
1216 struct flowi6 *fl6, int flags)
1220 if (rt6_need_strict(&fl6->daddr)) {
1221 struct dst_entry *dst;
1223 dst = l3mdev_link_scope_lookup(net, fl6);
1228 fl6->flowi6_iif = LOOPBACK_IFINDEX;
1230 any_src = ipv6_addr_any(&fl6->saddr);
1231 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr) ||
1232 (fl6->flowi6_oif && any_src))
1233 flags |= RT6_LOOKUP_F_IFACE;
1236 flags |= RT6_LOOKUP_F_HAS_SADDR;
1238 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1240 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1242 EXPORT_SYMBOL_GPL(ip6_route_output_flags);
1244 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1246 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1247 struct dst_entry *new = NULL;
1249 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1255 new->input = dst_discard;
1256 new->output = dst_discard_out;
1258 dst_copy_metrics(new, &ort->dst);
1259 rt->rt6i_idev = ort->rt6i_idev;
1261 in6_dev_hold(rt->rt6i_idev);
1263 rt->rt6i_gateway = ort->rt6i_gateway;
1264 rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;
1265 rt->rt6i_metric = 0;
1267 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1268 #ifdef CONFIG_IPV6_SUBTREES
1269 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1275 dst_release(dst_orig);
1276 return new ? new : ERR_PTR(-ENOMEM);
1280 * Destination cache support functions
1283 static void rt6_dst_from_metrics_check(struct rt6_info *rt)
1286 dst_metrics_ptr(&rt->dst) != dst_metrics_ptr(rt->dst.from))
1287 dst_init_metrics(&rt->dst, dst_metrics_ptr(rt->dst.from), true);
1290 static struct dst_entry *rt6_check(struct rt6_info *rt, u32 cookie)
1292 if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
1295 if (rt6_check_expired(rt))
1301 static struct dst_entry *rt6_dst_from_check(struct rt6_info *rt, u32 cookie)
1303 if (!__rt6_check_expired(rt) &&
1304 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1305 rt6_check((struct rt6_info *)(rt->dst.from), cookie))
1311 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1313 struct rt6_info *rt;
1315 rt = (struct rt6_info *) dst;
1317 /* All IPV6 dsts are created with ->obsolete set to the value
1318 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1319 * into this function always.
1322 rt6_dst_from_metrics_check(rt);
1324 if (rt->rt6i_flags & RTF_PCPU ||
1325 (unlikely(dst->flags & DST_NOCACHE) && rt->dst.from))
1326 return rt6_dst_from_check(rt, cookie);
1328 return rt6_check(rt, cookie);
1331 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1333 struct rt6_info *rt = (struct rt6_info *) dst;
1336 if (rt->rt6i_flags & RTF_CACHE) {
1337 if (rt6_check_expired(rt)) {
1349 static void ip6_link_failure(struct sk_buff *skb)
1351 struct rt6_info *rt;
1353 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1355 rt = (struct rt6_info *) skb_dst(skb);
1357 if (rt->rt6i_flags & RTF_CACHE) {
1360 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
1361 rt->rt6i_node->fn_sernum = -1;
1366 static void rt6_do_update_pmtu(struct rt6_info *rt, u32 mtu)
1368 struct net *net = dev_net(rt->dst.dev);
1370 rt->rt6i_flags |= RTF_MODIFIED;
1371 rt->rt6i_pmtu = mtu;
1372 rt6_update_expires(rt, net->ipv6.sysctl.ip6_rt_mtu_expires);
1375 static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
1377 return !(rt->rt6i_flags & RTF_CACHE) &&
1378 (rt->rt6i_flags & RTF_PCPU || rt->rt6i_node);
1381 static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,
1382 const struct ipv6hdr *iph, u32 mtu)
1384 const struct in6_addr *daddr, *saddr;
1385 struct rt6_info *rt6 = (struct rt6_info *)dst;
1387 if (rt6->rt6i_flags & RTF_LOCAL)
1390 if (dst_metric_locked(dst, RTAX_MTU))
1394 daddr = &iph->daddr;
1395 saddr = &iph->saddr;
1397 daddr = &sk->sk_v6_daddr;
1398 saddr = &inet6_sk(sk)->saddr;
1403 dst_confirm_neigh(dst, daddr);
1404 mtu = max_t(u32, mtu, IPV6_MIN_MTU);
1405 if (mtu >= dst_mtu(dst))
1408 if (!rt6_cache_allowed_for_pmtu(rt6)) {
1409 rt6_do_update_pmtu(rt6, mtu);
1411 struct rt6_info *nrt6;
1413 nrt6 = ip6_rt_cache_alloc(rt6, daddr, saddr);
1415 rt6_do_update_pmtu(nrt6, mtu);
1417 /* ip6_ins_rt(nrt6) will bump the
1418 * rt6->rt6i_node->fn_sernum
1419 * which will fail the next rt6_check() and
1420 * invalidate the sk->sk_dst_cache.
1427 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1428 struct sk_buff *skb, u32 mtu)
1430 __ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
1433 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1434 int oif, u32 mark, kuid_t uid)
1436 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1437 struct dst_entry *dst;
1440 memset(&fl6, 0, sizeof(fl6));
1441 fl6.flowi6_oif = oif;
1442 fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
1443 fl6.daddr = iph->daddr;
1444 fl6.saddr = iph->saddr;
1445 fl6.flowlabel = ip6_flowinfo(iph);
1446 fl6.flowi6_uid = uid;
1448 dst = ip6_route_output(net, NULL, &fl6);
1450 __ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
1453 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1455 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1457 struct dst_entry *dst;
1459 ip6_update_pmtu(skb, sock_net(sk), mtu,
1460 sk->sk_bound_dev_if, sk->sk_mark, sk->sk_uid);
1462 dst = __sk_dst_get(sk);
1463 if (!dst || !dst->obsolete ||
1464 dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
1468 if (!sock_owned_by_user(sk) && !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
1469 ip6_datagram_dst_update(sk, false);
1472 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1474 /* Handle redirects */
1475 struct ip6rd_flowi {
1477 struct in6_addr gateway;
1480 static struct rt6_info *__ip6_route_redirect(struct net *net,
1481 struct fib6_table *table,
1485 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1486 struct rt6_info *rt;
1487 struct fib6_node *fn;
1489 /* Get the "current" route for this destination and
1490 * check if the redirect has come from appropriate router.
1492 * RFC 4861 specifies that redirects should only be
1493 * accepted if they come from the nexthop to the target.
1494 * Due to the way the routes are chosen, this notion
1495 * is a bit fuzzy and one might need to check all possible
1499 read_lock_bh(&table->tb6_lock);
1500 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1502 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1503 if (rt6_check_expired(rt))
1507 if (!(rt->rt6i_flags & RTF_GATEWAY))
1509 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1511 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1517 rt = net->ipv6.ip6_null_entry;
1518 else if (rt->dst.error) {
1519 rt = net->ipv6.ip6_null_entry;
1523 if (rt == net->ipv6.ip6_null_entry) {
1524 fn = fib6_backtrack(fn, &fl6->saddr);
1532 read_unlock_bh(&table->tb6_lock);
1534 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
1538 static struct dst_entry *ip6_route_redirect(struct net *net,
1539 const struct flowi6 *fl6,
1540 const struct in6_addr *gateway)
1542 int flags = RT6_LOOKUP_F_HAS_SADDR;
1543 struct ip6rd_flowi rdfl;
1546 rdfl.gateway = *gateway;
1548 return fib6_rule_lookup(net, &rdfl.fl6,
1549 flags, __ip6_route_redirect);
1552 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark,
1555 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1556 struct dst_entry *dst;
1559 memset(&fl6, 0, sizeof(fl6));
1560 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1561 fl6.flowi6_oif = oif;
1562 fl6.flowi6_mark = mark;
1563 fl6.daddr = iph->daddr;
1564 fl6.saddr = iph->saddr;
1565 fl6.flowlabel = ip6_flowinfo(iph);
1566 fl6.flowi6_uid = uid;
1568 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1569 rt6_do_redirect(dst, NULL, skb);
1572 EXPORT_SYMBOL_GPL(ip6_redirect);
1574 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1577 const struct ipv6hdr *iph = ipv6_hdr(skb);
1578 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1579 struct dst_entry *dst;
1582 memset(&fl6, 0, sizeof(fl6));
1583 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1584 fl6.flowi6_oif = oif;
1585 fl6.flowi6_mark = mark;
1586 fl6.daddr = msg->dest;
1587 fl6.saddr = iph->daddr;
1588 fl6.flowi6_uid = sock_net_uid(net, NULL);
1590 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1591 rt6_do_redirect(dst, NULL, skb);
1595 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1597 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark,
1600 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1602 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1604 struct net_device *dev = dst->dev;
1605 unsigned int mtu = dst_mtu(dst);
1606 struct net *net = dev_net(dev);
1608 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1610 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1611 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1614 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1615 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1616 * IPV6_MAXPLEN is also valid and means: "any MSS,
1617 * rely only on pmtu discovery"
1619 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1624 static unsigned int ip6_mtu(const struct dst_entry *dst)
1626 const struct rt6_info *rt = (const struct rt6_info *)dst;
1627 unsigned int mtu = rt->rt6i_pmtu;
1628 struct inet6_dev *idev;
1633 mtu = dst_metric_raw(dst, RTAX_MTU);
1640 idev = __in6_dev_get(dst->dev);
1642 mtu = idev->cnf.mtu6;
1646 mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
1648 return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
1651 static struct dst_entry *icmp6_dst_gc_list;
1652 static DEFINE_SPINLOCK(icmp6_dst_lock);
1654 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1657 struct dst_entry *dst;
1658 struct rt6_info *rt;
1659 struct inet6_dev *idev = in6_dev_get(dev);
1660 struct net *net = dev_net(dev);
1662 if (unlikely(!idev))
1663 return ERR_PTR(-ENODEV);
1665 rt = ip6_dst_alloc(net, dev, 0);
1666 if (unlikely(!rt)) {
1668 dst = ERR_PTR(-ENOMEM);
1672 rt->dst.flags |= DST_HOST;
1673 rt->dst.output = ip6_output;
1674 atomic_set(&rt->dst.__refcnt, 1);
1675 rt->rt6i_gateway = fl6->daddr;
1676 rt->rt6i_dst.addr = fl6->daddr;
1677 rt->rt6i_dst.plen = 128;
1678 rt->rt6i_idev = idev;
1679 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1681 spin_lock_bh(&icmp6_dst_lock);
1682 rt->dst.next = icmp6_dst_gc_list;
1683 icmp6_dst_gc_list = &rt->dst;
1684 spin_unlock_bh(&icmp6_dst_lock);
1686 fib6_force_start_gc(net);
1688 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1694 int icmp6_dst_gc(void)
1696 struct dst_entry *dst, **pprev;
1699 spin_lock_bh(&icmp6_dst_lock);
1700 pprev = &icmp6_dst_gc_list;
1702 while ((dst = *pprev) != NULL) {
1703 if (!atomic_read(&dst->__refcnt)) {
1712 spin_unlock_bh(&icmp6_dst_lock);
1717 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1720 struct dst_entry *dst, **pprev;
1722 spin_lock_bh(&icmp6_dst_lock);
1723 pprev = &icmp6_dst_gc_list;
1724 while ((dst = *pprev) != NULL) {
1725 struct rt6_info *rt = (struct rt6_info *) dst;
1726 if (func(rt, arg)) {
1733 spin_unlock_bh(&icmp6_dst_lock);
1736 static int ip6_dst_gc(struct dst_ops *ops)
1738 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1739 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1740 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1741 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1742 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1743 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1746 entries = dst_entries_get_fast(ops);
1747 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1748 entries <= rt_max_size)
1751 net->ipv6.ip6_rt_gc_expire++;
1752 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
1753 entries = dst_entries_get_slow(ops);
1754 if (entries < ops->gc_thresh)
1755 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1757 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1758 return entries > rt_max_size;
1761 static int ip6_convert_metrics(struct mx6_config *mxc,
1762 const struct fib6_config *cfg)
1764 bool ecn_ca = false;
1772 mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1776 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1777 int type = nla_type(nla);
1782 if (unlikely(type > RTAX_MAX))
1785 if (type == RTAX_CC_ALGO) {
1786 char tmp[TCP_CA_NAME_MAX];
1788 nla_strlcpy(tmp, nla, sizeof(tmp));
1789 val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
1790 if (val == TCP_CA_UNSPEC)
1793 val = nla_get_u32(nla);
1795 if (type == RTAX_HOPLIMIT && val > 255)
1797 if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
1801 __set_bit(type - 1, mxc->mx_valid);
1805 __set_bit(RTAX_FEATURES - 1, mxc->mx_valid);
1806 mp[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
1816 static struct rt6_info *ip6_nh_lookup_table(struct net *net,
1817 struct fib6_config *cfg,
1818 const struct in6_addr *gw_addr)
1820 struct flowi6 fl6 = {
1821 .flowi6_oif = cfg->fc_ifindex,
1823 .saddr = cfg->fc_prefsrc,
1825 struct fib6_table *table;
1826 struct rt6_info *rt;
1827 int flags = RT6_LOOKUP_F_IFACE | RT6_LOOKUP_F_IGNORE_LINKSTATE;
1829 table = fib6_get_table(net, cfg->fc_table);
1833 if (!ipv6_addr_any(&cfg->fc_prefsrc))
1834 flags |= RT6_LOOKUP_F_HAS_SADDR;
1836 rt = ip6_pol_route(net, table, cfg->fc_ifindex, &fl6, flags);
1838 /* if table lookup failed, fall back to full lookup */
1839 if (rt == net->ipv6.ip6_null_entry) {
1847 static struct rt6_info *ip6_route_info_create(struct fib6_config *cfg)
1849 struct net *net = cfg->fc_nlinfo.nl_net;
1850 struct rt6_info *rt = NULL;
1851 struct net_device *dev = NULL;
1852 struct inet6_dev *idev = NULL;
1853 struct fib6_table *table;
1857 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1859 #ifndef CONFIG_IPV6_SUBTREES
1860 if (cfg->fc_src_len)
1863 if (cfg->fc_ifindex) {
1865 dev = dev_get_by_index(net, cfg->fc_ifindex);
1868 idev = in6_dev_get(dev);
1873 if (cfg->fc_metric == 0)
1874 cfg->fc_metric = IP6_RT_PRIO_USER;
1877 if (cfg->fc_nlinfo.nlh &&
1878 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1879 table = fib6_get_table(net, cfg->fc_table);
1881 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1882 table = fib6_new_table(net, cfg->fc_table);
1885 table = fib6_new_table(net, cfg->fc_table);
1891 rt = ip6_dst_alloc(net, NULL,
1892 (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT);
1899 if (cfg->fc_flags & RTF_EXPIRES)
1900 rt6_set_expires(rt, jiffies +
1901 clock_t_to_jiffies(cfg->fc_expires));
1903 rt6_clean_expires(rt);
1905 if (cfg->fc_protocol == RTPROT_UNSPEC)
1906 cfg->fc_protocol = RTPROT_BOOT;
1907 rt->rt6i_protocol = cfg->fc_protocol;
1909 addr_type = ipv6_addr_type(&cfg->fc_dst);
1911 if (addr_type & IPV6_ADDR_MULTICAST)
1912 rt->dst.input = ip6_mc_input;
1913 else if (cfg->fc_flags & RTF_LOCAL)
1914 rt->dst.input = ip6_input;
1916 rt->dst.input = ip6_forward;
1918 rt->dst.output = ip6_output;
1920 if (cfg->fc_encap) {
1921 struct lwtunnel_state *lwtstate;
1923 err = lwtunnel_build_state(cfg->fc_encap_type,
1924 cfg->fc_encap, AF_INET6, cfg,
1928 rt->dst.lwtstate = lwtstate_get(lwtstate);
1929 if (lwtunnel_output_redirect(rt->dst.lwtstate)) {
1930 rt->dst.lwtstate->orig_output = rt->dst.output;
1931 rt->dst.output = lwtunnel_output;
1933 if (lwtunnel_input_redirect(rt->dst.lwtstate)) {
1934 rt->dst.lwtstate->orig_input = rt->dst.input;
1935 rt->dst.input = lwtunnel_input;
1939 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1940 rt->rt6i_dst.plen = cfg->fc_dst_len;
1941 if (rt->rt6i_dst.plen == 128)
1942 rt->dst.flags |= DST_HOST;
1944 #ifdef CONFIG_IPV6_SUBTREES
1945 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1946 rt->rt6i_src.plen = cfg->fc_src_len;
1949 rt->rt6i_metric = cfg->fc_metric;
1951 /* We cannot add true routes via loopback here,
1952 they would result in kernel looping; promote them to reject routes
1954 if ((cfg->fc_flags & RTF_REJECT) ||
1955 (dev && (dev->flags & IFF_LOOPBACK) &&
1956 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1957 !(cfg->fc_flags & RTF_LOCAL))) {
1958 /* hold loopback dev/idev if we haven't done so. */
1959 if (dev != net->loopback_dev) {
1964 dev = net->loopback_dev;
1966 idev = in6_dev_get(dev);
1972 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1973 switch (cfg->fc_type) {
1975 rt->dst.error = -EINVAL;
1976 rt->dst.output = dst_discard_out;
1977 rt->dst.input = dst_discard;
1980 rt->dst.error = -EACCES;
1981 rt->dst.output = ip6_pkt_prohibit_out;
1982 rt->dst.input = ip6_pkt_prohibit;
1985 case RTN_UNREACHABLE:
1987 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1988 : (cfg->fc_type == RTN_UNREACHABLE)
1989 ? -EHOSTUNREACH : -ENETUNREACH;
1990 rt->dst.output = ip6_pkt_discard_out;
1991 rt->dst.input = ip6_pkt_discard;
1997 if (cfg->fc_flags & RTF_GATEWAY) {
1998 const struct in6_addr *gw_addr;
2001 gw_addr = &cfg->fc_gateway;
2002 gwa_type = ipv6_addr_type(gw_addr);
2004 /* if gw_addr is local we will fail to detect this in case
2005 * address is still TENTATIVE (DAD in progress). rt6_lookup()
2006 * will return already-added prefix route via interface that
2007 * prefix route was assigned to, which might be non-loopback.
2010 if (ipv6_chk_addr_and_flags(net, gw_addr,
2011 gwa_type & IPV6_ADDR_LINKLOCAL ?
2015 rt->rt6i_gateway = *gw_addr;
2017 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
2018 struct rt6_info *grt = NULL;
2020 /* IPv6 strictly inhibits using not link-local
2021 addresses as nexthop address.
2022 Otherwise, router will not able to send redirects.
2023 It is very good, but in some (rare!) circumstances
2024 (SIT, PtP, NBMA NOARP links) it is handy to allow
2025 some exceptions. --ANK
2026 We allow IPv4-mapped nexthops to support RFC4798-type
2029 if (!(gwa_type & (IPV6_ADDR_UNICAST |
2033 if (cfg->fc_table) {
2034 grt = ip6_nh_lookup_table(net, cfg, gw_addr);
2037 if (grt->rt6i_flags & RTF_GATEWAY ||
2038 (dev && dev != grt->dst.dev)) {
2046 grt = rt6_lookup(net, gw_addr, NULL,
2047 cfg->fc_ifindex, 1);
2049 err = -EHOSTUNREACH;
2053 if (dev != grt->dst.dev) {
2059 idev = grt->rt6i_idev;
2061 in6_dev_hold(grt->rt6i_idev);
2063 if (!(grt->rt6i_flags & RTF_GATEWAY))
2071 if (!dev || (dev->flags & IFF_LOOPBACK))
2079 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
2080 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
2084 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
2085 rt->rt6i_prefsrc.plen = 128;
2087 rt->rt6i_prefsrc.plen = 0;
2089 rt->rt6i_flags = cfg->fc_flags;
2093 rt->rt6i_idev = idev;
2094 rt->rt6i_table = table;
2096 cfg->fc_nlinfo.nl_net = dev_net(dev);
2107 return ERR_PTR(err);
2110 int ip6_route_add(struct fib6_config *cfg)
2112 struct mx6_config mxc = { .mx = NULL, };
2113 struct rt6_info *rt;
2116 rt = ip6_route_info_create(cfg);
2123 err = ip6_convert_metrics(&mxc, cfg);
2127 err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);
2139 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
2142 struct fib6_table *table;
2143 struct net *net = dev_net(rt->dst.dev);
2145 if (rt == net->ipv6.ip6_null_entry ||
2146 rt->dst.flags & DST_NOCACHE) {
2151 table = rt->rt6i_table;
2152 write_lock_bh(&table->tb6_lock);
2153 err = fib6_del(rt, info);
2154 write_unlock_bh(&table->tb6_lock);
2161 int ip6_del_rt(struct rt6_info *rt)
2163 struct nl_info info = {
2164 .nl_net = dev_net(rt->dst.dev),
2166 return __ip6_del_rt(rt, &info);
2169 static int __ip6_del_rt_siblings(struct rt6_info *rt, struct fib6_config *cfg)
2171 struct nl_info *info = &cfg->fc_nlinfo;
2172 struct sk_buff *skb = NULL;
2173 struct fib6_table *table;
2176 table = rt->rt6i_table;
2177 write_lock_bh(&table->tb6_lock);
2179 if (rt->rt6i_nsiblings && cfg->fc_delete_all_nh) {
2180 struct rt6_info *sibling, *next_sibling;
2182 /* prefer to send a single notification with all hops */
2183 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
2185 u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2187 if (rt6_fill_node(info->nl_net, skb, rt,
2188 NULL, NULL, 0, RTM_DELROUTE,
2189 info->portid, seq, 0) < 0) {
2193 info->skip_notify = 1;
2196 list_for_each_entry_safe(sibling, next_sibling,
2199 err = fib6_del(sibling, info);
2205 err = fib6_del(rt, info);
2207 write_unlock_bh(&table->tb6_lock);
2211 rtnl_notify(skb, info->nl_net, info->portid, RTNLGRP_IPV6_ROUTE,
2212 info->nlh, gfp_any());
2217 static int ip6_route_del(struct fib6_config *cfg)
2219 struct fib6_table *table;
2220 struct fib6_node *fn;
2221 struct rt6_info *rt;
2224 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
2228 read_lock_bh(&table->tb6_lock);
2230 fn = fib6_locate(&table->tb6_root,
2231 &cfg->fc_dst, cfg->fc_dst_len,
2232 &cfg->fc_src, cfg->fc_src_len);
2235 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2236 if ((rt->rt6i_flags & RTF_CACHE) &&
2237 !(cfg->fc_flags & RTF_CACHE))
2239 if (cfg->fc_ifindex &&
2241 rt->dst.dev->ifindex != cfg->fc_ifindex))
2243 if (cfg->fc_flags & RTF_GATEWAY &&
2244 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
2246 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
2248 if (cfg->fc_protocol && cfg->fc_protocol != rt->rt6i_protocol)
2251 read_unlock_bh(&table->tb6_lock);
2253 /* if gateway was specified only delete the one hop */
2254 if (cfg->fc_flags & RTF_GATEWAY)
2255 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
2257 return __ip6_del_rt_siblings(rt, cfg);
2260 read_unlock_bh(&table->tb6_lock);
2265 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
2267 struct netevent_redirect netevent;
2268 struct rt6_info *rt, *nrt = NULL;
2269 struct ndisc_options ndopts;
2270 struct inet6_dev *in6_dev;
2271 struct neighbour *neigh;
2273 int optlen, on_link;
2276 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
2277 optlen -= sizeof(*msg);
2280 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
2284 msg = (struct rd_msg *)icmp6_hdr(skb);
2286 if (ipv6_addr_is_multicast(&msg->dest)) {
2287 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
2292 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
2294 } else if (ipv6_addr_type(&msg->target) !=
2295 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
2296 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
2300 in6_dev = __in6_dev_get(skb->dev);
2303 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
2307 * The IP source address of the Redirect MUST be the same as the current
2308 * first-hop router for the specified ICMP Destination Address.
2311 if (!ndisc_parse_options(skb->dev, msg->opt, optlen, &ndopts)) {
2312 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
2317 if (ndopts.nd_opts_tgt_lladdr) {
2318 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
2321 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
2326 rt = (struct rt6_info *) dst;
2327 if (rt->rt6i_flags & RTF_REJECT) {
2328 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
2332 /* Redirect received -> path was valid.
2333 * Look, redirects are sent only in response to data packets,
2334 * so that this nexthop apparently is reachable. --ANK
2336 dst_confirm_neigh(&rt->dst, &ipv6_hdr(skb)->saddr);
2338 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
2343 * We have finally decided to accept it.
2346 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
2347 NEIGH_UPDATE_F_WEAK_OVERRIDE|
2348 NEIGH_UPDATE_F_OVERRIDE|
2349 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
2350 NEIGH_UPDATE_F_ISROUTER)),
2351 NDISC_REDIRECT, &ndopts);
2353 nrt = ip6_rt_cache_alloc(rt, &msg->dest, NULL);
2357 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
2359 nrt->rt6i_flags &= ~RTF_GATEWAY;
2361 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
2363 if (ip6_ins_rt(nrt))
2366 netevent.old = &rt->dst;
2367 netevent.new = &nrt->dst;
2368 netevent.daddr = &msg->dest;
2369 netevent.neigh = neigh;
2370 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
2372 if (rt->rt6i_flags & RTF_CACHE) {
2373 rt = (struct rt6_info *) dst_clone(&rt->dst);
2378 neigh_release(neigh);
2382 * Misc support functions
2385 static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
2387 BUG_ON(from->dst.from);
2389 rt->rt6i_flags &= ~RTF_EXPIRES;
2390 dst_hold(&from->dst);
2391 rt->dst.from = &from->dst;
2392 dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
2395 static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort)
2397 rt->dst.input = ort->dst.input;
2398 rt->dst.output = ort->dst.output;
2399 rt->rt6i_dst = ort->rt6i_dst;
2400 rt->dst.error = ort->dst.error;
2401 rt->rt6i_idev = ort->rt6i_idev;
2403 in6_dev_hold(rt->rt6i_idev);
2404 rt->dst.lastuse = jiffies;
2405 rt->rt6i_gateway = ort->rt6i_gateway;
2406 rt->rt6i_flags = ort->rt6i_flags;
2407 rt6_set_from(rt, ort);
2408 rt->rt6i_metric = ort->rt6i_metric;
2409 #ifdef CONFIG_IPV6_SUBTREES
2410 rt->rt6i_src = ort->rt6i_src;
2412 rt->rt6i_prefsrc = ort->rt6i_prefsrc;
2413 rt->rt6i_table = ort->rt6i_table;
2414 rt->dst.lwtstate = lwtstate_get(ort->dst.lwtstate);
2417 #ifdef CONFIG_IPV6_ROUTE_INFO
2418 static struct rt6_info *rt6_get_route_info(struct net *net,
2419 const struct in6_addr *prefix, int prefixlen,
2420 const struct in6_addr *gwaddr,
2421 struct net_device *dev)
2423 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO;
2424 int ifindex = dev->ifindex;
2425 struct fib6_node *fn;
2426 struct rt6_info *rt = NULL;
2427 struct fib6_table *table;
2429 table = fib6_get_table(net, tb_id);
2433 read_lock_bh(&table->tb6_lock);
2434 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
2438 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2439 if (rt->dst.dev->ifindex != ifindex)
2441 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
2443 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
2449 read_unlock_bh(&table->tb6_lock);
2453 static struct rt6_info *rt6_add_route_info(struct net *net,
2454 const struct in6_addr *prefix, int prefixlen,
2455 const struct in6_addr *gwaddr,
2456 struct net_device *dev,
2459 struct fib6_config cfg = {
2460 .fc_metric = IP6_RT_PRIO_USER,
2461 .fc_ifindex = dev->ifindex,
2462 .fc_dst_len = prefixlen,
2463 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2464 RTF_UP | RTF_PREF(pref),
2465 .fc_nlinfo.portid = 0,
2466 .fc_nlinfo.nlh = NULL,
2467 .fc_nlinfo.nl_net = net,
2470 cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO,
2471 cfg.fc_dst = *prefix;
2472 cfg.fc_gateway = *gwaddr;
2474 /* We should treat it as a default route if prefix length is 0. */
2476 cfg.fc_flags |= RTF_DEFAULT;
2478 ip6_route_add(&cfg);
2480 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, dev);
2484 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
2486 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT;
2487 struct rt6_info *rt;
2488 struct fib6_table *table;
2490 table = fib6_get_table(dev_net(dev), tb_id);
2494 read_lock_bh(&table->tb6_lock);
2495 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2496 if (dev == rt->dst.dev &&
2497 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
2498 ipv6_addr_equal(&rt->rt6i_gateway, addr))
2503 read_unlock_bh(&table->tb6_lock);
2507 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
2508 struct net_device *dev,
2511 struct fib6_config cfg = {
2512 .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
2513 .fc_metric = IP6_RT_PRIO_USER,
2514 .fc_ifindex = dev->ifindex,
2515 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2516 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
2517 .fc_nlinfo.portid = 0,
2518 .fc_nlinfo.nlh = NULL,
2519 .fc_nlinfo.nl_net = dev_net(dev),
2522 cfg.fc_gateway = *gwaddr;
2524 if (!ip6_route_add(&cfg)) {
2525 struct fib6_table *table;
2527 table = fib6_get_table(dev_net(dev), cfg.fc_table);
2529 table->flags |= RT6_TABLE_HAS_DFLT_ROUTER;
2532 return rt6_get_dflt_router(gwaddr, dev);
2535 static void __rt6_purge_dflt_routers(struct fib6_table *table)
2537 struct rt6_info *rt;
2540 read_lock_bh(&table->tb6_lock);
2541 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2542 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2543 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2545 read_unlock_bh(&table->tb6_lock);
2550 read_unlock_bh(&table->tb6_lock);
2552 table->flags &= ~RT6_TABLE_HAS_DFLT_ROUTER;
2555 void rt6_purge_dflt_routers(struct net *net)
2557 struct fib6_table *table;
2558 struct hlist_head *head;
2563 for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
2564 head = &net->ipv6.fib_table_hash[h];
2565 hlist_for_each_entry_rcu(table, head, tb6_hlist) {
2566 if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER)
2567 __rt6_purge_dflt_routers(table);
2574 static void rtmsg_to_fib6_config(struct net *net,
2575 struct in6_rtmsg *rtmsg,
2576 struct fib6_config *cfg)
2578 memset(cfg, 0, sizeof(*cfg));
2580 cfg->fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
2582 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2583 cfg->fc_metric = rtmsg->rtmsg_metric;
2584 cfg->fc_expires = rtmsg->rtmsg_info;
2585 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2586 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2587 cfg->fc_flags = rtmsg->rtmsg_flags;
2589 cfg->fc_nlinfo.nl_net = net;
2591 cfg->fc_dst = rtmsg->rtmsg_dst;
2592 cfg->fc_src = rtmsg->rtmsg_src;
2593 cfg->fc_gateway = rtmsg->rtmsg_gateway;
2596 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2598 struct fib6_config cfg;
2599 struct in6_rtmsg rtmsg;
2603 case SIOCADDRT: /* Add a route */
2604 case SIOCDELRT: /* Delete a route */
2605 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2607 err = copy_from_user(&rtmsg, arg,
2608 sizeof(struct in6_rtmsg));
2612 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2617 err = ip6_route_add(&cfg);
2620 err = ip6_route_del(&cfg);
2634 * Drop the packet on the floor
2637 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2640 struct dst_entry *dst = skb_dst(skb);
2641 switch (ipstats_mib_noroutes) {
2642 case IPSTATS_MIB_INNOROUTES:
2643 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2644 if (type == IPV6_ADDR_ANY) {
2645 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2646 IPSTATS_MIB_INADDRERRORS);
2650 case IPSTATS_MIB_OUTNOROUTES:
2651 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2652 ipstats_mib_noroutes);
2655 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2660 static int ip6_pkt_discard(struct sk_buff *skb)
2662 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2665 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
2667 skb->dev = skb_dst(skb)->dev;
2668 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2671 static int ip6_pkt_prohibit(struct sk_buff *skb)
2673 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2676 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
2678 skb->dev = skb_dst(skb)->dev;
2679 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2683 * Allocate a dst for local (unicast / anycast) address.
2686 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2687 const struct in6_addr *addr,
2691 struct net *net = dev_net(idev->dev);
2692 struct net_device *dev = net->loopback_dev;
2693 struct rt6_info *rt;
2695 /* use L3 Master device as loopback for host routes if device
2696 * is enslaved and address is not link local or multicast
2698 if (!rt6_need_strict(addr))
2699 dev = l3mdev_master_dev_rcu(idev->dev) ? : dev;
2701 rt = ip6_dst_alloc(net, dev, DST_NOCOUNT);
2703 return ERR_PTR(-ENOMEM);
2707 rt->dst.flags |= DST_HOST;
2708 rt->dst.input = ip6_input;
2709 rt->dst.output = ip6_output;
2710 rt->rt6i_idev = idev;
2712 rt->rt6i_protocol = RTPROT_KERNEL;
2713 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2715 rt->rt6i_flags |= RTF_ANYCAST;
2717 rt->rt6i_flags |= RTF_LOCAL;
2719 rt->rt6i_gateway = *addr;
2720 rt->rt6i_dst.addr = *addr;
2721 rt->rt6i_dst.plen = 128;
2722 tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;
2723 rt->rt6i_table = fib6_get_table(net, tb_id);
2724 rt->dst.flags |= DST_NOCACHE;
2726 atomic_set(&rt->dst.__refcnt, 1);
2731 /* remove deleted ip from prefsrc entries */
2732 struct arg_dev_net_ip {
2733 struct net_device *dev;
2735 struct in6_addr *addr;
2738 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2740 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2741 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2742 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2744 if (((void *)rt->dst.dev == dev || !dev) &&
2745 rt != net->ipv6.ip6_null_entry &&
2746 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2747 /* remove prefsrc entry */
2748 rt->rt6i_prefsrc.plen = 0;
2753 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2755 struct net *net = dev_net(ifp->idev->dev);
2756 struct arg_dev_net_ip adni = {
2757 .dev = ifp->idev->dev,
2761 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2764 #define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2765 #define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2767 /* Remove routers and update dst entries when gateway turn into host. */
2768 static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2770 struct in6_addr *gateway = (struct in6_addr *)arg;
2772 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2773 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2774 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2780 void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2782 fib6_clean_all(net, fib6_clean_tohost, gateway);
2785 struct arg_dev_net {
2786 struct net_device *dev;
2790 /* called with write lock held for table with rt */
2791 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2793 const struct arg_dev_net *adn = arg;
2794 const struct net_device *dev = adn->dev;
2796 if ((rt->dst.dev == dev || !dev) &&
2797 rt != adn->net->ipv6.ip6_null_entry &&
2798 (rt->rt6i_nsiblings == 0 ||
2799 !rt->rt6i_idev->cnf.ignore_routes_with_linkdown))
2805 void rt6_ifdown(struct net *net, struct net_device *dev)
2807 struct arg_dev_net adn = {
2812 fib6_clean_all(net, fib6_ifdown, &adn);
2813 icmp6_clean_all(fib6_ifdown, &adn);
2815 rt6_uncached_list_flush_dev(net, dev);
2818 struct rt6_mtu_change_arg {
2819 struct net_device *dev;
2823 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2825 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2826 struct inet6_dev *idev;
2828 /* In IPv6 pmtu discovery is not optional,
2829 so that RTAX_MTU lock cannot disable it.
2830 We still use this lock to block changes
2831 caused by addrconf/ndisc.
2834 idev = __in6_dev_get(arg->dev);
2838 /* For administrative MTU increase, there is no way to discover
2839 IPv6 PMTU increase, so PMTU increase should be updated here.
2840 Since RFC 1981 doesn't include administrative MTU increase
2841 update PMTU increase is a MUST. (i.e. jumbo frame)
2844 If new MTU is less than route PMTU, this new MTU will be the
2845 lowest MTU in the path, update the route PMTU to reflect PMTU
2846 decreases; if new MTU is greater than route PMTU, and the
2847 old MTU is the lowest MTU in the path, update the route PMTU
2848 to reflect the increase. In this case if the other nodes' MTU
2849 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2852 if (rt->dst.dev == arg->dev &&
2853 dst_metric_raw(&rt->dst, RTAX_MTU) &&
2854 !dst_metric_locked(&rt->dst, RTAX_MTU)) {
2855 if (rt->rt6i_flags & RTF_CACHE) {
2856 /* For RTF_CACHE with rt6i_pmtu == 0
2857 * (i.e. a redirected route),
2858 * the metrics of its rt->dst.from has already
2861 if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
2862 rt->rt6i_pmtu = arg->mtu;
2863 } else if (dst_mtu(&rt->dst) >= arg->mtu ||
2864 (dst_mtu(&rt->dst) < arg->mtu &&
2865 dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
2866 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2872 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2874 struct rt6_mtu_change_arg arg = {
2879 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2882 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2883 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2884 [RTA_OIF] = { .type = NLA_U32 },
2885 [RTA_IIF] = { .type = NLA_U32 },
2886 [RTA_PRIORITY] = { .type = NLA_U32 },
2887 [RTA_METRICS] = { .type = NLA_NESTED },
2888 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2889 [RTA_PREF] = { .type = NLA_U8 },
2890 [RTA_ENCAP_TYPE] = { .type = NLA_U16 },
2891 [RTA_ENCAP] = { .type = NLA_NESTED },
2892 [RTA_EXPIRES] = { .type = NLA_U32 },
2893 [RTA_UID] = { .type = NLA_U32 },
2896 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2897 struct fib6_config *cfg)
2900 struct nlattr *tb[RTA_MAX+1];
2904 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2909 rtm = nlmsg_data(nlh);
2910 memset(cfg, 0, sizeof(*cfg));
2912 cfg->fc_table = rtm->rtm_table;
2913 cfg->fc_dst_len = rtm->rtm_dst_len;
2914 cfg->fc_src_len = rtm->rtm_src_len;
2915 cfg->fc_flags = RTF_UP;
2916 cfg->fc_protocol = rtm->rtm_protocol;
2917 cfg->fc_type = rtm->rtm_type;
2919 if (rtm->rtm_type == RTN_UNREACHABLE ||
2920 rtm->rtm_type == RTN_BLACKHOLE ||
2921 rtm->rtm_type == RTN_PROHIBIT ||
2922 rtm->rtm_type == RTN_THROW)
2923 cfg->fc_flags |= RTF_REJECT;
2925 if (rtm->rtm_type == RTN_LOCAL)
2926 cfg->fc_flags |= RTF_LOCAL;
2928 if (rtm->rtm_flags & RTM_F_CLONED)
2929 cfg->fc_flags |= RTF_CACHE;
2931 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2932 cfg->fc_nlinfo.nlh = nlh;
2933 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2935 if (tb[RTA_GATEWAY]) {
2936 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
2937 cfg->fc_flags |= RTF_GATEWAY;
2941 int plen = (rtm->rtm_dst_len + 7) >> 3;
2943 if (nla_len(tb[RTA_DST]) < plen)
2946 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2950 int plen = (rtm->rtm_src_len + 7) >> 3;
2952 if (nla_len(tb[RTA_SRC]) < plen)
2955 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2958 if (tb[RTA_PREFSRC])
2959 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
2962 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2964 if (tb[RTA_PRIORITY])
2965 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2967 if (tb[RTA_METRICS]) {
2968 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2969 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2973 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2975 if (tb[RTA_MULTIPATH]) {
2976 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2977 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2979 err = lwtunnel_valid_encap_type_attr(cfg->fc_mp,
2986 pref = nla_get_u8(tb[RTA_PREF]);
2987 if (pref != ICMPV6_ROUTER_PREF_LOW &&
2988 pref != ICMPV6_ROUTER_PREF_HIGH)
2989 pref = ICMPV6_ROUTER_PREF_MEDIUM;
2990 cfg->fc_flags |= RTF_PREF(pref);
2994 cfg->fc_encap = tb[RTA_ENCAP];
2996 if (tb[RTA_ENCAP_TYPE]) {
2997 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
2999 err = lwtunnel_valid_encap_type(cfg->fc_encap_type);
3004 if (tb[RTA_EXPIRES]) {
3005 unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);
3007 if (addrconf_finite_timeout(timeout)) {
3008 cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
3009 cfg->fc_flags |= RTF_EXPIRES;
3019 struct rt6_info *rt6_info;
3020 struct fib6_config r_cfg;
3021 struct mx6_config mxc;
3022 struct list_head next;
3025 static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
3029 list_for_each_entry(nh, rt6_nh_list, next) {
3030 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6c nexthop %pI6c ifi %d\n",
3031 &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
3032 nh->r_cfg.fc_ifindex);
3036 static int ip6_route_info_append(struct list_head *rt6_nh_list,
3037 struct rt6_info *rt, struct fib6_config *r_cfg)
3040 struct rt6_info *rtnh;
3043 list_for_each_entry(nh, rt6_nh_list, next) {
3044 /* check if rt6_info already exists */
3045 rtnh = nh->rt6_info;
3047 if (rtnh->dst.dev == rt->dst.dev &&
3048 rtnh->rt6i_idev == rt->rt6i_idev &&
3049 ipv6_addr_equal(&rtnh->rt6i_gateway,
3054 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
3058 err = ip6_convert_metrics(&nh->mxc, r_cfg);
3063 memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
3064 list_add_tail(&nh->next, rt6_nh_list);
3069 static void ip6_route_mpath_notify(struct rt6_info *rt,
3070 struct rt6_info *rt_last,
3071 struct nl_info *info,
3074 /* if this is an APPEND route, then rt points to the first route
3075 * inserted and rt_last points to last route inserted. Userspace
3076 * wants a consistent dump of the route which starts at the first
3077 * nexthop. Since sibling routes are always added at the end of
3078 * the list, find the first sibling of the last route appended
3080 if ((nlflags & NLM_F_APPEND) && rt_last && rt_last->rt6i_nsiblings) {
3081 rt = list_first_entry(&rt_last->rt6i_siblings,
3087 inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
3090 static int ip6_route_multipath_add(struct fib6_config *cfg)
3092 struct rt6_info *rt_notif = NULL, *rt_last = NULL;
3093 struct nl_info *info = &cfg->fc_nlinfo;
3094 struct fib6_config r_cfg;
3095 struct rtnexthop *rtnh;
3096 struct rt6_info *rt;
3097 struct rt6_nh *err_nh;
3098 struct rt6_nh *nh, *nh_safe;
3104 int replace = (cfg->fc_nlinfo.nlh &&
3105 (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
3106 LIST_HEAD(rt6_nh_list);
3108 nlflags = replace ? NLM_F_REPLACE : NLM_F_CREATE;
3109 if (info->nlh && info->nlh->nlmsg_flags & NLM_F_APPEND)
3110 nlflags |= NLM_F_APPEND;
3112 remaining = cfg->fc_mp_len;
3113 rtnh = (struct rtnexthop *)cfg->fc_mp;
3115 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
3116 * rt6_info structs per nexthop
3118 while (rtnh_ok(rtnh, remaining)) {
3119 memcpy(&r_cfg, cfg, sizeof(*cfg));
3120 if (rtnh->rtnh_ifindex)
3121 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3123 attrlen = rtnh_attrlen(rtnh);
3125 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3127 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3129 r_cfg.fc_gateway = nla_get_in6_addr(nla);
3130 r_cfg.fc_flags |= RTF_GATEWAY;
3132 r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
3133 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
3135 r_cfg.fc_encap_type = nla_get_u16(nla);
3138 rt = ip6_route_info_create(&r_cfg);
3145 err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
3151 rtnh = rtnh_next(rtnh, &remaining);
3154 /* for add and replace send one notification with all nexthops.
3155 * Skip the notification in fib6_add_rt2node and send one with
3156 * the full route when done
3158 info->skip_notify = 1;
3161 list_for_each_entry(nh, &rt6_nh_list, next) {
3162 rt_last = nh->rt6_info;
3163 err = __ip6_ins_rt(nh->rt6_info, info, &nh->mxc);
3164 /* save reference to first route for notification */
3165 if (!rt_notif && !err)
3166 rt_notif = nh->rt6_info;
3168 /* nh->rt6_info is used or freed at this point, reset to NULL*/
3169 nh->rt6_info = NULL;
3172 ip6_print_replace_route_err(&rt6_nh_list);
3177 /* Because each route is added like a single route we remove
3178 * these flags after the first nexthop: if there is a collision,
3179 * we have already failed to add the first nexthop:
3180 * fib6_add_rt2node() has rejected it; when replacing, old
3181 * nexthops have been replaced by first new, the rest should
3184 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
3189 /* success ... tell user about new route */
3190 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
3194 /* send notification for routes that were added so that
3195 * the delete notifications sent by ip6_route_del are
3199 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
3201 /* Delete routes that were already added */
3202 list_for_each_entry(nh, &rt6_nh_list, next) {
3205 ip6_route_del(&nh->r_cfg);
3209 list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
3211 dst_free(&nh->rt6_info->dst);
3213 list_del(&nh->next);
3220 static int ip6_route_multipath_del(struct fib6_config *cfg)
3222 struct fib6_config r_cfg;
3223 struct rtnexthop *rtnh;
3226 int err = 1, last_err = 0;
3228 remaining = cfg->fc_mp_len;
3229 rtnh = (struct rtnexthop *)cfg->fc_mp;
3231 /* Parse a Multipath Entry */
3232 while (rtnh_ok(rtnh, remaining)) {
3233 memcpy(&r_cfg, cfg, sizeof(*cfg));
3234 if (rtnh->rtnh_ifindex)
3235 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3237 attrlen = rtnh_attrlen(rtnh);
3239 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3241 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3243 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
3244 r_cfg.fc_flags |= RTF_GATEWAY;
3247 err = ip6_route_del(&r_cfg);
3251 rtnh = rtnh_next(rtnh, &remaining);
3257 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
3259 struct fib6_config cfg;
3262 err = rtm_to_fib6_config(skb, nlh, &cfg);
3267 return ip6_route_multipath_del(&cfg);
3269 cfg.fc_delete_all_nh = 1;
3270 return ip6_route_del(&cfg);
3274 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
3276 struct fib6_config cfg;
3279 err = rtm_to_fib6_config(skb, nlh, &cfg);
3284 return ip6_route_multipath_add(&cfg);
3286 return ip6_route_add(&cfg);
3289 static size_t rt6_nlmsg_size(struct rt6_info *rt)
3291 int nexthop_len = 0;
3293 if (rt->rt6i_nsiblings) {
3294 nexthop_len = nla_total_size(0) /* RTA_MULTIPATH */
3295 + NLA_ALIGN(sizeof(struct rtnexthop))
3296 + nla_total_size(16) /* RTA_GATEWAY */
3297 + nla_total_size(4) /* RTA_OIF */
3298 + lwtunnel_get_encap_size(rt->dst.lwtstate);
3300 nexthop_len *= rt->rt6i_nsiblings;
3303 return NLMSG_ALIGN(sizeof(struct rtmsg))
3304 + nla_total_size(16) /* RTA_SRC */
3305 + nla_total_size(16) /* RTA_DST */
3306 + nla_total_size(16) /* RTA_GATEWAY */
3307 + nla_total_size(16) /* RTA_PREFSRC */
3308 + nla_total_size(4) /* RTA_TABLE */
3309 + nla_total_size(4) /* RTA_IIF */
3310 + nla_total_size(4) /* RTA_OIF */
3311 + nla_total_size(4) /* RTA_PRIORITY */
3312 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
3313 + nla_total_size(sizeof(struct rta_cacheinfo))
3314 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
3315 + nla_total_size(1) /* RTA_PREF */
3316 + lwtunnel_get_encap_size(rt->dst.lwtstate)
3320 static int rt6_nexthop_info(struct sk_buff *skb, struct rt6_info *rt,
3321 unsigned int *flags)
3323 if (!netif_running(rt->dst.dev) || !netif_carrier_ok(rt->dst.dev)) {
3324 *flags |= RTNH_F_LINKDOWN;
3325 if (rt->rt6i_idev->cnf.ignore_routes_with_linkdown)
3326 *flags |= RTNH_F_DEAD;
3329 if (rt->rt6i_flags & RTF_GATEWAY) {
3330 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
3331 goto nla_put_failure;
3335 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
3336 goto nla_put_failure;
3338 if (rt->dst.lwtstate &&
3339 lwtunnel_fill_encap(skb, rt->dst.lwtstate) < 0)
3340 goto nla_put_failure;
3348 static int rt6_add_nexthop(struct sk_buff *skb, struct rt6_info *rt)
3350 struct rtnexthop *rtnh;
3351 unsigned int flags = 0;
3353 rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
3355 goto nla_put_failure;
3357 rtnh->rtnh_hops = 0;
3358 rtnh->rtnh_ifindex = rt->dst.dev ? rt->dst.dev->ifindex : 0;
3360 if (rt6_nexthop_info(skb, rt, &flags) < 0)
3361 goto nla_put_failure;
3363 rtnh->rtnh_flags = flags;
3365 /* length of rtnetlink header + attributes */
3366 rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
3374 static int rt6_fill_node(struct net *net,
3375 struct sk_buff *skb, struct rt6_info *rt,
3376 struct in6_addr *dst, struct in6_addr *src,
3377 int iif, int type, u32 portid, u32 seq,
3380 u32 metrics[RTAX_MAX];
3382 struct nlmsghdr *nlh;
3386 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
3390 rtm = nlmsg_data(nlh);
3391 rtm->rtm_family = AF_INET6;
3392 rtm->rtm_dst_len = rt->rt6i_dst.plen;
3393 rtm->rtm_src_len = rt->rt6i_src.plen;
3396 table = rt->rt6i_table->tb6_id;
3398 table = RT6_TABLE_UNSPEC;
3399 rtm->rtm_table = table;
3400 if (nla_put_u32(skb, RTA_TABLE, table))
3401 goto nla_put_failure;
3402 if (rt->rt6i_flags & RTF_REJECT) {
3403 switch (rt->dst.error) {
3405 rtm->rtm_type = RTN_BLACKHOLE;
3408 rtm->rtm_type = RTN_PROHIBIT;
3411 rtm->rtm_type = RTN_THROW;
3414 rtm->rtm_type = RTN_UNREACHABLE;
3418 else if (rt->rt6i_flags & RTF_LOCAL)
3419 rtm->rtm_type = RTN_LOCAL;
3420 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
3421 rtm->rtm_type = RTN_LOCAL;
3423 rtm->rtm_type = RTN_UNICAST;
3425 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
3426 rtm->rtm_protocol = rt->rt6i_protocol;
3427 if (rt->rt6i_flags & RTF_DYNAMIC)
3428 rtm->rtm_protocol = RTPROT_REDIRECT;
3429 else if (rt->rt6i_flags & RTF_ADDRCONF) {
3430 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
3431 rtm->rtm_protocol = RTPROT_RA;
3433 rtm->rtm_protocol = RTPROT_KERNEL;
3436 if (rt->rt6i_flags & RTF_CACHE)
3437 rtm->rtm_flags |= RTM_F_CLONED;
3440 if (nla_put_in6_addr(skb, RTA_DST, dst))
3441 goto nla_put_failure;
3442 rtm->rtm_dst_len = 128;
3443 } else if (rtm->rtm_dst_len)
3444 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
3445 goto nla_put_failure;
3446 #ifdef CONFIG_IPV6_SUBTREES
3448 if (nla_put_in6_addr(skb, RTA_SRC, src))
3449 goto nla_put_failure;
3450 rtm->rtm_src_len = 128;
3451 } else if (rtm->rtm_src_len &&
3452 nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
3453 goto nla_put_failure;
3456 #ifdef CONFIG_IPV6_MROUTE
3457 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
3458 int err = ip6mr_get_route(net, skb, rtm, portid);
3463 goto nla_put_failure;
3466 if (nla_put_u32(skb, RTA_IIF, iif))
3467 goto nla_put_failure;
3469 struct in6_addr saddr_buf;
3470 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
3471 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
3472 goto nla_put_failure;
3475 if (rt->rt6i_prefsrc.plen) {
3476 struct in6_addr saddr_buf;
3477 saddr_buf = rt->rt6i_prefsrc.addr;
3478 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
3479 goto nla_put_failure;
3482 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
3484 metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
3485 if (rtnetlink_put_metrics(skb, metrics) < 0)
3486 goto nla_put_failure;
3488 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
3489 goto nla_put_failure;
3491 /* For multipath routes, walk the siblings list and add
3492 * each as a nexthop within RTA_MULTIPATH.
3494 if (rt->rt6i_nsiblings) {
3495 struct rt6_info *sibling, *next_sibling;
3498 mp = nla_nest_start(skb, RTA_MULTIPATH);
3500 goto nla_put_failure;
3502 if (rt6_add_nexthop(skb, rt) < 0)
3503 goto nla_put_failure;
3505 list_for_each_entry_safe(sibling, next_sibling,
3506 &rt->rt6i_siblings, rt6i_siblings) {
3507 if (rt6_add_nexthop(skb, sibling) < 0)
3508 goto nla_put_failure;
3511 nla_nest_end(skb, mp);
3513 if (rt6_nexthop_info(skb, rt, &rtm->rtm_flags) < 0)
3514 goto nla_put_failure;
3517 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
3519 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
3520 goto nla_put_failure;
3522 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
3523 goto nla_put_failure;
3526 nlmsg_end(skb, nlh);
3530 nlmsg_cancel(skb, nlh);
3534 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
3536 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
3537 struct net *net = arg->net;
3539 if (rt == net->ipv6.ip6_null_entry)
3542 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
3543 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
3545 /* user wants prefix routes only */
3546 if (rtm->rtm_flags & RTM_F_PREFIX &&
3547 !(rt->rt6i_flags & RTF_PREFIX_RT)) {
3548 /* success since this is not a prefix route */
3553 return rt6_fill_node(net,
3554 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
3555 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
3559 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
3561 struct net *net = sock_net(in_skb->sk);
3562 struct nlattr *tb[RTA_MAX+1];
3563 struct rt6_info *rt;
3564 struct sk_buff *skb;
3567 int err, iif = 0, oif = 0;
3569 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
3574 memset(&fl6, 0, sizeof(fl6));
3575 rtm = nlmsg_data(nlh);
3576 fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);
3579 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
3582 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
3586 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
3589 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
3593 iif = nla_get_u32(tb[RTA_IIF]);
3596 oif = nla_get_u32(tb[RTA_OIF]);
3599 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
3602 fl6.flowi6_uid = make_kuid(current_user_ns(),
3603 nla_get_u32(tb[RTA_UID]));
3605 fl6.flowi6_uid = iif ? INVALID_UID : current_uid();
3608 struct net_device *dev;
3611 dev = __dev_get_by_index(net, iif);
3617 fl6.flowi6_iif = iif;
3619 if (!ipv6_addr_any(&fl6.saddr))
3620 flags |= RT6_LOOKUP_F_HAS_SADDR;
3622 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
3625 fl6.flowi6_oif = oif;
3627 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
3630 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
3637 skb_dst_set(skb, &rt->dst);
3639 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
3640 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
3647 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
3652 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info,
3653 unsigned int nlm_flags)
3655 struct sk_buff *skb;
3656 struct net *net = info->nl_net;
3661 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
3663 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
3667 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
3668 event, info->portid, seq, nlm_flags);
3670 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
3671 WARN_ON(err == -EMSGSIZE);
3675 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
3676 info->nlh, gfp_any());
3680 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
3683 static int ip6_route_dev_notify(struct notifier_block *this,
3684 unsigned long event, void *ptr)
3686 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3687 struct net *net = dev_net(dev);
3689 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
3690 net->ipv6.ip6_null_entry->dst.dev = dev;
3691 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
3692 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3693 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
3694 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
3695 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
3696 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
3707 #ifdef CONFIG_PROC_FS
3709 static const struct file_operations ipv6_route_proc_fops = {
3710 .owner = THIS_MODULE,
3711 .open = ipv6_route_open,
3713 .llseek = seq_lseek,
3714 .release = seq_release_net,
3717 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
3719 struct net *net = (struct net *)seq->private;
3720 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
3721 net->ipv6.rt6_stats->fib_nodes,
3722 net->ipv6.rt6_stats->fib_route_nodes,
3723 net->ipv6.rt6_stats->fib_rt_alloc,
3724 net->ipv6.rt6_stats->fib_rt_entries,
3725 net->ipv6.rt6_stats->fib_rt_cache,
3726 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
3727 net->ipv6.rt6_stats->fib_discarded_routes);
3732 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
3734 return single_open_net(inode, file, rt6_stats_seq_show);
3737 static const struct file_operations rt6_stats_seq_fops = {
3738 .owner = THIS_MODULE,
3739 .open = rt6_stats_seq_open,
3741 .llseek = seq_lseek,
3742 .release = single_release_net,
3744 #endif /* CONFIG_PROC_FS */
3746 #ifdef CONFIG_SYSCTL
3749 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
3750 void __user *buffer, size_t *lenp, loff_t *ppos)
3757 net = (struct net *)ctl->extra1;
3758 delay = net->ipv6.sysctl.flush_delay;
3759 proc_dointvec(ctl, write, buffer, lenp, ppos);
3760 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
3764 struct ctl_table ipv6_route_table_template[] = {
3766 .procname = "flush",
3767 .data = &init_net.ipv6.sysctl.flush_delay,
3768 .maxlen = sizeof(int),
3770 .proc_handler = ipv6_sysctl_rtcache_flush
3773 .procname = "gc_thresh",
3774 .data = &ip6_dst_ops_template.gc_thresh,
3775 .maxlen = sizeof(int),
3777 .proc_handler = proc_dointvec,
3780 .procname = "max_size",
3781 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
3782 .maxlen = sizeof(int),
3784 .proc_handler = proc_dointvec,
3787 .procname = "gc_min_interval",
3788 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3789 .maxlen = sizeof(int),
3791 .proc_handler = proc_dointvec_jiffies,
3794 .procname = "gc_timeout",
3795 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
3796 .maxlen = sizeof(int),
3798 .proc_handler = proc_dointvec_jiffies,
3801 .procname = "gc_interval",
3802 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
3803 .maxlen = sizeof(int),
3805 .proc_handler = proc_dointvec_jiffies,
3808 .procname = "gc_elasticity",
3809 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
3810 .maxlen = sizeof(int),
3812 .proc_handler = proc_dointvec,
3815 .procname = "mtu_expires",
3816 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
3817 .maxlen = sizeof(int),
3819 .proc_handler = proc_dointvec_jiffies,
3822 .procname = "min_adv_mss",
3823 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
3824 .maxlen = sizeof(int),
3826 .proc_handler = proc_dointvec,
3829 .procname = "gc_min_interval_ms",
3830 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3831 .maxlen = sizeof(int),
3833 .proc_handler = proc_dointvec_ms_jiffies,
3838 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
3840 struct ctl_table *table;
3842 table = kmemdup(ipv6_route_table_template,
3843 sizeof(ipv6_route_table_template),
3847 table[0].data = &net->ipv6.sysctl.flush_delay;
3848 table[0].extra1 = net;
3849 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
3850 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3851 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3852 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3853 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3854 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3855 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3856 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
3857 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3859 /* Don't export sysctls to unprivileged users */
3860 if (net->user_ns != &init_user_ns)
3861 table[0].procname = NULL;
3868 static int __net_init ip6_route_net_init(struct net *net)
3872 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3873 sizeof(net->ipv6.ip6_dst_ops));
3875 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3876 goto out_ip6_dst_ops;
3878 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3879 sizeof(*net->ipv6.ip6_null_entry),
3881 if (!net->ipv6.ip6_null_entry)
3882 goto out_ip6_dst_entries;
3883 net->ipv6.ip6_null_entry->dst.path =
3884 (struct dst_entry *)net->ipv6.ip6_null_entry;
3885 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3886 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3887 ip6_template_metrics, true);
3889 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3890 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3891 sizeof(*net->ipv6.ip6_prohibit_entry),
3893 if (!net->ipv6.ip6_prohibit_entry)
3894 goto out_ip6_null_entry;
3895 net->ipv6.ip6_prohibit_entry->dst.path =
3896 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3897 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3898 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3899 ip6_template_metrics, true);
3901 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3902 sizeof(*net->ipv6.ip6_blk_hole_entry),
3904 if (!net->ipv6.ip6_blk_hole_entry)
3905 goto out_ip6_prohibit_entry;
3906 net->ipv6.ip6_blk_hole_entry->dst.path =
3907 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3908 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3909 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3910 ip6_template_metrics, true);
3913 net->ipv6.sysctl.flush_delay = 0;
3914 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3915 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3916 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3917 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3918 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3919 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3920 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3922 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3928 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3929 out_ip6_prohibit_entry:
3930 kfree(net->ipv6.ip6_prohibit_entry);
3932 kfree(net->ipv6.ip6_null_entry);
3934 out_ip6_dst_entries:
3935 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3940 static void __net_exit ip6_route_net_exit(struct net *net)
3942 kfree(net->ipv6.ip6_null_entry);
3943 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3944 kfree(net->ipv6.ip6_prohibit_entry);
3945 kfree(net->ipv6.ip6_blk_hole_entry);
3947 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3950 static int __net_init ip6_route_net_init_late(struct net *net)
3952 #ifdef CONFIG_PROC_FS
3953 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3954 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3959 static void __net_exit ip6_route_net_exit_late(struct net *net)
3961 #ifdef CONFIG_PROC_FS
3962 remove_proc_entry("ipv6_route", net->proc_net);
3963 remove_proc_entry("rt6_stats", net->proc_net);
3967 static struct pernet_operations ip6_route_net_ops = {
3968 .init = ip6_route_net_init,
3969 .exit = ip6_route_net_exit,
3972 static int __net_init ipv6_inetpeer_init(struct net *net)
3974 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3978 inet_peer_base_init(bp);
3979 net->ipv6.peers = bp;
3983 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3985 struct inet_peer_base *bp = net->ipv6.peers;
3987 net->ipv6.peers = NULL;
3988 inetpeer_invalidate_tree(bp);
3992 static struct pernet_operations ipv6_inetpeer_ops = {
3993 .init = ipv6_inetpeer_init,
3994 .exit = ipv6_inetpeer_exit,
3997 static struct pernet_operations ip6_route_net_late_ops = {
3998 .init = ip6_route_net_init_late,
3999 .exit = ip6_route_net_exit_late,
4002 static struct notifier_block ip6_route_dev_notifier = {
4003 .notifier_call = ip6_route_dev_notify,
4007 int __init ip6_route_init(void)
4013 ip6_dst_ops_template.kmem_cachep =
4014 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
4015 SLAB_HWCACHE_ALIGN, NULL);
4016 if (!ip6_dst_ops_template.kmem_cachep)
4019 ret = dst_entries_init(&ip6_dst_blackhole_ops);
4021 goto out_kmem_cache;
4023 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
4025 goto out_dst_entries;
4027 ret = register_pernet_subsys(&ip6_route_net_ops);
4029 goto out_register_inetpeer;
4031 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
4033 /* Registering of the loopback is done before this portion of code,
4034 * the loopback reference in rt6_info will not be taken, do it
4035 * manually for init_net */
4036 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
4037 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4038 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
4039 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
4040 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4041 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
4042 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4046 goto out_register_subsys;
4052 ret = fib6_rules_init();
4056 ret = register_pernet_subsys(&ip6_route_net_late_ops);
4058 goto fib6_rules_init;
4061 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
4062 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
4063 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
4064 goto out_register_late_subsys;
4066 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
4068 goto out_register_late_subsys;
4070 for_each_possible_cpu(cpu) {
4071 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
4073 INIT_LIST_HEAD(&ul->head);
4074 spin_lock_init(&ul->lock);
4080 out_register_late_subsys:
4081 unregister_pernet_subsys(&ip6_route_net_late_ops);
4083 fib6_rules_cleanup();
4088 out_register_subsys:
4089 unregister_pernet_subsys(&ip6_route_net_ops);
4090 out_register_inetpeer:
4091 unregister_pernet_subsys(&ipv6_inetpeer_ops);
4093 dst_entries_destroy(&ip6_dst_blackhole_ops);
4095 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
4099 void ip6_route_cleanup(void)
4101 unregister_netdevice_notifier(&ip6_route_dev_notifier);
4102 unregister_pernet_subsys(&ip6_route_net_late_ops);
4103 fib6_rules_cleanup();
4106 unregister_pernet_subsys(&ipv6_inetpeer_ops);
4107 unregister_pernet_subsys(&ip6_route_net_ops);
4108 dst_entries_destroy(&ip6_dst_blackhole_ops);
4109 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);