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>
58 #include <net/netevent.h>
59 #include <net/netlink.h>
60 #include <net/nexthop.h>
62 #include <asm/uaccess.h>
65 #include <linux/sysctl.h>
68 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
69 const struct in6_addr *dest);
70 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
71 static unsigned int ip6_default_advmss(const struct dst_entry *dst);
72 static unsigned int ip6_mtu(const struct dst_entry *dst);
73 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
74 static void ip6_dst_destroy(struct dst_entry *);
75 static void ip6_dst_ifdown(struct dst_entry *,
76 struct net_device *dev, int how);
77 static int ip6_dst_gc(struct dst_ops *ops);
79 static int ip6_pkt_discard(struct sk_buff *skb);
80 static int ip6_pkt_discard_out(struct sk_buff *skb);
81 static void ip6_link_failure(struct sk_buff *skb);
82 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
83 struct sk_buff *skb, u32 mtu);
84 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
87 #ifdef CONFIG_IPV6_ROUTE_INFO
88 static struct rt6_info *rt6_add_route_info(struct net *net,
89 const struct in6_addr *prefix, int prefixlen,
90 const struct in6_addr *gwaddr, int ifindex,
92 static struct rt6_info *rt6_get_route_info(struct net *net,
93 const struct in6_addr *prefix, int prefixlen,
94 const struct in6_addr *gwaddr, int ifindex);
97 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
99 struct rt6_info *rt = (struct rt6_info *) dst;
100 struct inet_peer *peer;
103 if (!(rt->dst.flags & DST_HOST))
106 peer = rt6_get_peer_create(rt);
108 u32 *old_p = __DST_METRICS_PTR(old);
109 unsigned long prev, new;
112 if (inet_metrics_new(peer))
113 memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
115 new = (unsigned long) p;
116 prev = cmpxchg(&dst->_metrics, old, new);
119 p = __DST_METRICS_PTR(prev);
120 if (prev & DST_METRICS_READ_ONLY)
127 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
131 struct in6_addr *p = &rt->rt6i_gateway;
133 if (!ipv6_addr_any(p))
134 return (const void *) p;
136 return &ipv6_hdr(skb)->daddr;
140 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
144 struct rt6_info *rt = (struct rt6_info *) dst;
147 daddr = choose_neigh_daddr(rt, skb, daddr);
148 n = __ipv6_neigh_lookup(dst->dev, daddr);
151 return neigh_create(&nd_tbl, daddr, dst->dev);
154 static int rt6_bind_neighbour(struct rt6_info *rt, struct net_device *dev)
156 struct neighbour *n = __ipv6_neigh_lookup(dev, &rt->rt6i_gateway);
158 n = neigh_create(&nd_tbl, &rt->rt6i_gateway, dev);
167 static struct dst_ops ip6_dst_ops_template = {
169 .protocol = cpu_to_be16(ETH_P_IPV6),
172 .check = ip6_dst_check,
173 .default_advmss = ip6_default_advmss,
175 .cow_metrics = ipv6_cow_metrics,
176 .destroy = ip6_dst_destroy,
177 .ifdown = ip6_dst_ifdown,
178 .negative_advice = ip6_negative_advice,
179 .link_failure = ip6_link_failure,
180 .update_pmtu = ip6_rt_update_pmtu,
181 .redirect = rt6_do_redirect,
182 .local_out = __ip6_local_out,
183 .neigh_lookup = ip6_neigh_lookup,
186 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
188 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
190 return mtu ? : dst->dev->mtu;
193 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
194 struct sk_buff *skb, u32 mtu)
198 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
203 static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
209 static struct dst_ops ip6_dst_blackhole_ops = {
211 .protocol = cpu_to_be16(ETH_P_IPV6),
212 .destroy = ip6_dst_destroy,
213 .check = ip6_dst_check,
214 .mtu = ip6_blackhole_mtu,
215 .default_advmss = ip6_default_advmss,
216 .update_pmtu = ip6_rt_blackhole_update_pmtu,
217 .redirect = ip6_rt_blackhole_redirect,
218 .cow_metrics = ip6_rt_blackhole_cow_metrics,
219 .neigh_lookup = ip6_neigh_lookup,
222 static const u32 ip6_template_metrics[RTAX_MAX] = {
223 [RTAX_HOPLIMIT - 1] = 0,
226 static const struct rt6_info ip6_null_entry_template = {
228 .__refcnt = ATOMIC_INIT(1),
230 .obsolete = DST_OBSOLETE_FORCE_CHK,
231 .error = -ENETUNREACH,
232 .input = ip6_pkt_discard,
233 .output = ip6_pkt_discard_out,
235 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
236 .rt6i_protocol = RTPROT_KERNEL,
237 .rt6i_metric = ~(u32) 0,
238 .rt6i_ref = ATOMIC_INIT(1),
241 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
243 static int ip6_pkt_prohibit(struct sk_buff *skb);
244 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
246 static const struct rt6_info ip6_prohibit_entry_template = {
248 .__refcnt = ATOMIC_INIT(1),
250 .obsolete = DST_OBSOLETE_FORCE_CHK,
252 .input = ip6_pkt_prohibit,
253 .output = ip6_pkt_prohibit_out,
255 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
256 .rt6i_protocol = RTPROT_KERNEL,
257 .rt6i_metric = ~(u32) 0,
258 .rt6i_ref = ATOMIC_INIT(1),
261 static const struct rt6_info ip6_blk_hole_entry_template = {
263 .__refcnt = ATOMIC_INIT(1),
265 .obsolete = DST_OBSOLETE_FORCE_CHK,
267 .input = dst_discard,
268 .output = dst_discard,
270 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
271 .rt6i_protocol = RTPROT_KERNEL,
272 .rt6i_metric = ~(u32) 0,
273 .rt6i_ref = ATOMIC_INIT(1),
278 /* allocate dst with ip6_dst_ops */
279 static inline struct rt6_info *ip6_dst_alloc(struct net *net,
280 struct net_device *dev,
282 struct fib6_table *table)
284 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
285 0, DST_OBSOLETE_FORCE_CHK, flags);
288 struct dst_entry *dst = &rt->dst;
290 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
291 rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
292 rt->rt6i_genid = rt_genid(net);
293 INIT_LIST_HEAD(&rt->rt6i_siblings);
294 rt->rt6i_nsiblings = 0;
299 static void ip6_dst_destroy(struct dst_entry *dst)
301 struct rt6_info *rt = (struct rt6_info *)dst;
302 struct inet6_dev *idev = rt->rt6i_idev;
305 neigh_release(rt->n);
307 if (!(rt->dst.flags & DST_HOST))
308 dst_destroy_metrics_generic(dst);
311 rt->rt6i_idev = NULL;
315 if (!(rt->rt6i_flags & RTF_EXPIRES) && dst->from)
316 dst_release(dst->from);
318 if (rt6_has_peer(rt)) {
319 struct inet_peer *peer = rt6_peer_ptr(rt);
324 void rt6_bind_peer(struct rt6_info *rt, int create)
326 struct inet_peer_base *base;
327 struct inet_peer *peer;
329 base = inetpeer_base_ptr(rt->_rt6i_peer);
333 peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
335 if (!rt6_set_peer(rt, peer))
340 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
343 struct rt6_info *rt = (struct rt6_info *)dst;
344 struct inet6_dev *idev = rt->rt6i_idev;
345 struct net_device *loopback_dev =
346 dev_net(dev)->loopback_dev;
348 if (dev != loopback_dev) {
349 if (idev && idev->dev == dev) {
350 struct inet6_dev *loopback_idev =
351 in6_dev_get(loopback_dev);
353 rt->rt6i_idev = loopback_idev;
357 if (rt->n && rt->n->dev == dev) {
358 rt->n->dev = loopback_dev;
359 dev_hold(loopback_dev);
365 static bool rt6_check_expired(const struct rt6_info *rt)
367 if (rt->rt6i_flags & RTF_EXPIRES) {
368 if (time_after(jiffies, rt->dst.expires))
370 } else if (rt->dst.from) {
371 return rt6_check_expired((struct rt6_info *) rt->dst.from);
376 static bool rt6_need_strict(const struct in6_addr *daddr)
378 return ipv6_addr_type(daddr) &
379 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
382 /* Multipath route selection:
383 * Hash based function using packet header and flowlabel.
384 * Adapted from fib_info_hashfn()
386 static int rt6_info_hash_nhsfn(unsigned int candidate_count,
387 const struct flowi6 *fl6)
389 unsigned int val = fl6->flowi6_proto;
391 val ^= ipv6_addr_hash(&fl6->daddr);
392 val ^= ipv6_addr_hash(&fl6->saddr);
394 /* Work only if this not encapsulated */
395 switch (fl6->flowi6_proto) {
399 val ^= (__force u16)fl6->fl6_sport;
400 val ^= (__force u16)fl6->fl6_dport;
404 val ^= (__force u16)fl6->fl6_icmp_type;
405 val ^= (__force u16)fl6->fl6_icmp_code;
408 /* RFC6438 recommands to use flowlabel */
409 val ^= (__force u32)fl6->flowlabel;
411 /* Perhaps, we need to tune, this function? */
412 val = val ^ (val >> 7) ^ (val >> 12);
413 return val % candidate_count;
416 static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
419 struct rt6_info *sibling, *next_sibling;
422 route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
423 /* Don't change the route, if route_choosen == 0
424 * (siblings does not include ourself)
427 list_for_each_entry_safe(sibling, next_sibling,
428 &match->rt6i_siblings, rt6i_siblings) {
430 if (route_choosen == 0) {
439 * Route lookup. Any table->tb6_lock is implied.
442 static inline struct rt6_info *rt6_device_match(struct net *net,
444 const struct in6_addr *saddr,
448 struct rt6_info *local = NULL;
449 struct rt6_info *sprt;
451 if (!oif && ipv6_addr_any(saddr))
454 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
455 struct net_device *dev = sprt->dst.dev;
458 if (dev->ifindex == oif)
460 if (dev->flags & IFF_LOOPBACK) {
461 if (!sprt->rt6i_idev ||
462 sprt->rt6i_idev->dev->ifindex != oif) {
463 if (flags & RT6_LOOKUP_F_IFACE && oif)
465 if (local && (!oif ||
466 local->rt6i_idev->dev->ifindex == oif))
472 if (ipv6_chk_addr(net, saddr, dev,
473 flags & RT6_LOOKUP_F_IFACE))
482 if (flags & RT6_LOOKUP_F_IFACE)
483 return net->ipv6.ip6_null_entry;
489 #ifdef CONFIG_IPV6_ROUTER_PREF
490 static void rt6_probe(struct rt6_info *rt)
492 struct neighbour *neigh;
494 * Okay, this does not seem to be appropriate
495 * for now, however, we need to check if it
496 * is really so; aka Router Reachability Probing.
498 * Router Reachability Probe MUST be rate-limited
499 * to no more than one per minute.
501 neigh = rt ? rt->n : NULL;
504 write_lock_bh(&neigh->lock);
505 if (neigh->nud_state & NUD_VALID) {
506 write_unlock_bh(&neigh->lock);
509 if (!(neigh->nud_state & NUD_VALID) &&
510 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
511 struct in6_addr mcaddr;
512 struct in6_addr *target;
514 neigh->updated = jiffies;
515 write_unlock_bh(&neigh->lock);
517 target = (struct in6_addr *)&neigh->primary_key;
518 addrconf_addr_solict_mult(target, &mcaddr);
519 ndisc_send_ns(rt->dst.dev, NULL, target, &mcaddr, NULL);
521 write_unlock_bh(&neigh->lock);
525 static inline void rt6_probe(struct rt6_info *rt)
531 * Default Router Selection (RFC 2461 6.3.6)
533 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
535 struct net_device *dev = rt->dst.dev;
536 if (!oif || dev->ifindex == oif)
538 if ((dev->flags & IFF_LOOPBACK) &&
539 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
544 static inline bool rt6_check_neigh(struct rt6_info *rt)
546 struct neighbour *neigh;
550 if (rt->rt6i_flags & RTF_NONEXTHOP ||
551 !(rt->rt6i_flags & RTF_GATEWAY))
554 read_lock_bh(&neigh->lock);
555 if (neigh->nud_state & NUD_VALID)
557 #ifdef CONFIG_IPV6_ROUTER_PREF
558 else if (!(neigh->nud_state & NUD_FAILED))
561 read_unlock_bh(&neigh->lock);
566 static int rt6_score_route(struct rt6_info *rt, int oif,
571 m = rt6_check_dev(rt, oif);
572 if (!m && (strict & RT6_LOOKUP_F_IFACE))
574 #ifdef CONFIG_IPV6_ROUTER_PREF
575 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
577 if (!rt6_check_neigh(rt) && (strict & RT6_LOOKUP_F_REACHABLE))
582 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
583 int *mpri, struct rt6_info *match)
587 if (rt6_check_expired(rt))
590 m = rt6_score_route(rt, oif, strict);
595 if (strict & RT6_LOOKUP_F_REACHABLE)
599 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
607 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
608 struct rt6_info *rr_head,
609 u32 metric, int oif, int strict)
611 struct rt6_info *rt, *match;
615 for (rt = rr_head; rt && rt->rt6i_metric == metric;
616 rt = rt->dst.rt6_next)
617 match = find_match(rt, oif, strict, &mpri, match);
618 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
619 rt = rt->dst.rt6_next)
620 match = find_match(rt, oif, strict, &mpri, match);
625 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
627 struct rt6_info *match, *rt0;
632 fn->rr_ptr = rt0 = fn->leaf;
634 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
637 (strict & RT6_LOOKUP_F_REACHABLE)) {
638 struct rt6_info *next = rt0->dst.rt6_next;
640 /* no entries matched; do round-robin */
641 if (!next || next->rt6i_metric != rt0->rt6i_metric)
648 net = dev_net(rt0->dst.dev);
649 return match ? match : net->ipv6.ip6_null_entry;
652 #ifdef CONFIG_IPV6_ROUTE_INFO
653 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
654 const struct in6_addr *gwaddr)
656 struct net *net = dev_net(dev);
657 struct route_info *rinfo = (struct route_info *) opt;
658 struct in6_addr prefix_buf, *prefix;
660 unsigned long lifetime;
663 if (len < sizeof(struct route_info)) {
667 /* Sanity check for prefix_len and length */
668 if (rinfo->length > 3) {
670 } else if (rinfo->prefix_len > 128) {
672 } else if (rinfo->prefix_len > 64) {
673 if (rinfo->length < 2) {
676 } else if (rinfo->prefix_len > 0) {
677 if (rinfo->length < 1) {
682 pref = rinfo->route_pref;
683 if (pref == ICMPV6_ROUTER_PREF_INVALID)
686 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
688 if (rinfo->length == 3)
689 prefix = (struct in6_addr *)rinfo->prefix;
691 /* this function is safe */
692 ipv6_addr_prefix(&prefix_buf,
693 (struct in6_addr *)rinfo->prefix,
695 prefix = &prefix_buf;
698 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
701 if (rt && !lifetime) {
707 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
710 rt->rt6i_flags = RTF_ROUTEINFO |
711 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
714 if (!addrconf_finite_timeout(lifetime))
715 rt6_clean_expires(rt);
717 rt6_set_expires(rt, jiffies + HZ * lifetime);
725 #define BACKTRACK(__net, saddr) \
727 if (rt == __net->ipv6.ip6_null_entry) { \
728 struct fib6_node *pn; \
730 if (fn->fn_flags & RTN_TL_ROOT) \
733 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
734 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
737 if (fn->fn_flags & RTN_RTINFO) \
743 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
744 struct fib6_table *table,
745 struct flowi6 *fl6, int flags)
747 struct fib6_node *fn;
750 read_lock_bh(&table->tb6_lock);
751 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
754 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
755 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
756 rt = rt6_multipath_select(rt, fl6);
757 BACKTRACK(net, &fl6->saddr);
759 dst_use(&rt->dst, jiffies);
760 read_unlock_bh(&table->tb6_lock);
765 struct dst_entry * ip6_route_lookup(struct net *net, struct flowi6 *fl6,
768 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
770 EXPORT_SYMBOL_GPL(ip6_route_lookup);
772 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
773 const struct in6_addr *saddr, int oif, int strict)
775 struct flowi6 fl6 = {
779 struct dst_entry *dst;
780 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
783 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
784 flags |= RT6_LOOKUP_F_HAS_SADDR;
787 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
789 return (struct rt6_info *) dst;
796 EXPORT_SYMBOL(rt6_lookup);
798 /* ip6_ins_rt is called with FREE table->tb6_lock.
799 It takes new route entry, the addition fails by any reason the
800 route is freed. In any case, if caller does not hold it, it may
804 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
807 struct fib6_table *table;
809 table = rt->rt6i_table;
810 write_lock_bh(&table->tb6_lock);
811 err = fib6_add(&table->tb6_root, rt, info);
812 write_unlock_bh(&table->tb6_lock);
817 int ip6_ins_rt(struct rt6_info *rt)
819 struct nl_info info = {
820 .nl_net = dev_net(rt->dst.dev),
822 return __ip6_ins_rt(rt, &info);
825 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
826 const struct in6_addr *daddr,
827 const struct in6_addr *saddr)
835 rt = ip6_rt_copy(ort, daddr);
838 int attempts = !in_softirq();
840 if (!(rt->rt6i_flags & RTF_GATEWAY)) {
841 if (ort->rt6i_dst.plen != 128 &&
842 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
843 rt->rt6i_flags |= RTF_ANYCAST;
844 rt->rt6i_gateway = *daddr;
847 rt->rt6i_flags |= RTF_CACHE;
849 #ifdef CONFIG_IPV6_SUBTREES
850 if (rt->rt6i_src.plen && saddr) {
851 rt->rt6i_src.addr = *saddr;
852 rt->rt6i_src.plen = 128;
857 if (rt6_bind_neighbour(rt, rt->dst.dev)) {
858 struct net *net = dev_net(rt->dst.dev);
859 int saved_rt_min_interval =
860 net->ipv6.sysctl.ip6_rt_gc_min_interval;
861 int saved_rt_elasticity =
862 net->ipv6.sysctl.ip6_rt_gc_elasticity;
864 if (attempts-- > 0) {
865 net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
866 net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
868 ip6_dst_gc(&net->ipv6.ip6_dst_ops);
870 net->ipv6.sysctl.ip6_rt_gc_elasticity =
872 net->ipv6.sysctl.ip6_rt_gc_min_interval =
873 saved_rt_min_interval;
877 net_warn_ratelimited("Neighbour table overflow\n");
886 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
887 const struct in6_addr *daddr)
889 struct rt6_info *rt = ip6_rt_copy(ort, daddr);
892 rt->rt6i_flags |= RTF_CACHE;
893 rt->n = neigh_clone(ort->n);
898 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
899 struct flowi6 *fl6, int flags)
901 struct fib6_node *fn;
902 struct rt6_info *rt, *nrt;
906 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
908 strict |= flags & RT6_LOOKUP_F_IFACE;
911 read_lock_bh(&table->tb6_lock);
914 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
917 rt = rt6_select(fn, oif, strict | reachable);
918 if (rt->rt6i_nsiblings && oif == 0)
919 rt = rt6_multipath_select(rt, fl6);
920 BACKTRACK(net, &fl6->saddr);
921 if (rt == net->ipv6.ip6_null_entry ||
922 rt->rt6i_flags & RTF_CACHE)
926 read_unlock_bh(&table->tb6_lock);
928 if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
929 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
930 else if (!(rt->dst.flags & DST_HOST))
931 nrt = rt6_alloc_clone(rt, &fl6->daddr);
936 rt = nrt ? : net->ipv6.ip6_null_entry;
940 err = ip6_ins_rt(nrt);
949 * Race condition! In the gap, when table->tb6_lock was
950 * released someone could insert this route. Relookup.
961 read_unlock_bh(&table->tb6_lock);
963 rt->dst.lastuse = jiffies;
969 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
970 struct flowi6 *fl6, int flags)
972 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
975 static struct dst_entry *ip6_route_input_lookup(struct net *net,
976 struct net_device *dev,
977 struct flowi6 *fl6, int flags)
979 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
980 flags |= RT6_LOOKUP_F_IFACE;
982 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
985 void ip6_route_input(struct sk_buff *skb)
987 const struct ipv6hdr *iph = ipv6_hdr(skb);
988 struct net *net = dev_net(skb->dev);
989 int flags = RT6_LOOKUP_F_HAS_SADDR;
990 struct flowi6 fl6 = {
991 .flowi6_iif = skb->dev->ifindex,
994 .flowlabel = ip6_flowinfo(iph),
995 .flowi6_mark = skb->mark,
996 .flowi6_proto = iph->nexthdr,
999 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
1002 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
1003 struct flowi6 *fl6, int flags)
1005 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
1008 struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
1013 fl6->flowi6_iif = LOOPBACK_IFINDEX;
1015 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
1016 flags |= RT6_LOOKUP_F_IFACE;
1018 if (!ipv6_addr_any(&fl6->saddr))
1019 flags |= RT6_LOOKUP_F_HAS_SADDR;
1021 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1023 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1026 EXPORT_SYMBOL(ip6_route_output);
1028 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1030 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1031 struct dst_entry *new = NULL;
1033 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1037 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1038 rt6_init_peer(rt, net->ipv6.peers);
1041 new->input = dst_discard;
1042 new->output = dst_discard;
1044 if (dst_metrics_read_only(&ort->dst))
1045 new->_metrics = ort->dst._metrics;
1047 dst_copy_metrics(new, &ort->dst);
1048 rt->rt6i_idev = ort->rt6i_idev;
1050 in6_dev_hold(rt->rt6i_idev);
1052 rt->rt6i_gateway = ort->rt6i_gateway;
1053 rt->rt6i_flags = ort->rt6i_flags;
1054 rt6_clean_expires(rt);
1055 rt->rt6i_metric = 0;
1057 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1058 #ifdef CONFIG_IPV6_SUBTREES
1059 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1065 dst_release(dst_orig);
1066 return new ? new : ERR_PTR(-ENOMEM);
1070 * Destination cache support functions
1073 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1075 struct rt6_info *rt;
1077 rt = (struct rt6_info *) dst;
1079 /* All IPV6 dsts are created with ->obsolete set to the value
1080 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1081 * into this function always.
1083 if (rt->rt6i_genid != rt_genid(dev_net(rt->dst.dev)))
1086 if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
1092 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1094 struct rt6_info *rt = (struct rt6_info *) dst;
1097 if (rt->rt6i_flags & RTF_CACHE) {
1098 if (rt6_check_expired(rt)) {
1110 static void ip6_link_failure(struct sk_buff *skb)
1112 struct rt6_info *rt;
1114 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1116 rt = (struct rt6_info *) skb_dst(skb);
1118 if (rt->rt6i_flags & RTF_CACHE)
1119 rt6_update_expires(rt, 0);
1120 else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
1121 rt->rt6i_node->fn_sernum = -1;
1125 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1126 struct sk_buff *skb, u32 mtu)
1128 struct rt6_info *rt6 = (struct rt6_info*)dst;
1131 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
1132 struct net *net = dev_net(dst->dev);
1134 rt6->rt6i_flags |= RTF_MODIFIED;
1135 if (mtu < IPV6_MIN_MTU) {
1136 u32 features = dst_metric(dst, RTAX_FEATURES);
1138 features |= RTAX_FEATURE_ALLFRAG;
1139 dst_metric_set(dst, RTAX_FEATURES, features);
1141 dst_metric_set(dst, RTAX_MTU, mtu);
1142 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1146 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1149 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1150 struct dst_entry *dst;
1153 memset(&fl6, 0, sizeof(fl6));
1154 fl6.flowi6_oif = oif;
1155 fl6.flowi6_mark = mark;
1156 fl6.flowi6_flags = 0;
1157 fl6.daddr = iph->daddr;
1158 fl6.saddr = iph->saddr;
1159 fl6.flowlabel = ip6_flowinfo(iph);
1161 dst = ip6_route_output(net, NULL, &fl6);
1163 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
1166 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1168 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1170 ip6_update_pmtu(skb, sock_net(sk), mtu,
1171 sk->sk_bound_dev_if, sk->sk_mark);
1173 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1175 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1177 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1178 struct dst_entry *dst;
1181 memset(&fl6, 0, sizeof(fl6));
1182 fl6.flowi6_oif = oif;
1183 fl6.flowi6_mark = mark;
1184 fl6.flowi6_flags = 0;
1185 fl6.daddr = iph->daddr;
1186 fl6.saddr = iph->saddr;
1187 fl6.flowlabel = ip6_flowinfo(iph);
1189 dst = ip6_route_output(net, NULL, &fl6);
1191 rt6_do_redirect(dst, NULL, skb);
1194 EXPORT_SYMBOL_GPL(ip6_redirect);
1196 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1198 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1200 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1202 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1204 struct net_device *dev = dst->dev;
1205 unsigned int mtu = dst_mtu(dst);
1206 struct net *net = dev_net(dev);
1208 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1210 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1211 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1214 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1215 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1216 * IPV6_MAXPLEN is also valid and means: "any MSS,
1217 * rely only on pmtu discovery"
1219 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1224 static unsigned int ip6_mtu(const struct dst_entry *dst)
1226 struct inet6_dev *idev;
1227 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1235 idev = __in6_dev_get(dst->dev);
1237 mtu = idev->cnf.mtu6;
1243 static struct dst_entry *icmp6_dst_gc_list;
1244 static DEFINE_SPINLOCK(icmp6_dst_lock);
1246 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1247 struct neighbour *neigh,
1250 struct dst_entry *dst;
1251 struct rt6_info *rt;
1252 struct inet6_dev *idev = in6_dev_get(dev);
1253 struct net *net = dev_net(dev);
1255 if (unlikely(!idev))
1256 return ERR_PTR(-ENODEV);
1258 rt = ip6_dst_alloc(net, dev, 0, NULL);
1259 if (unlikely(!rt)) {
1261 dst = ERR_PTR(-ENOMEM);
1268 neigh = ip6_neigh_lookup(&rt->dst, NULL, &fl6->daddr);
1269 if (IS_ERR(neigh)) {
1272 return ERR_CAST(neigh);
1276 rt->dst.flags |= DST_HOST;
1277 rt->dst.output = ip6_output;
1279 atomic_set(&rt->dst.__refcnt, 1);
1280 rt->rt6i_dst.addr = fl6->daddr;
1281 rt->rt6i_dst.plen = 128;
1282 rt->rt6i_idev = idev;
1283 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1285 spin_lock_bh(&icmp6_dst_lock);
1286 rt->dst.next = icmp6_dst_gc_list;
1287 icmp6_dst_gc_list = &rt->dst;
1288 spin_unlock_bh(&icmp6_dst_lock);
1290 fib6_force_start_gc(net);
1292 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1298 int icmp6_dst_gc(void)
1300 struct dst_entry *dst, **pprev;
1303 spin_lock_bh(&icmp6_dst_lock);
1304 pprev = &icmp6_dst_gc_list;
1306 while ((dst = *pprev) != NULL) {
1307 if (!atomic_read(&dst->__refcnt)) {
1316 spin_unlock_bh(&icmp6_dst_lock);
1321 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1324 struct dst_entry *dst, **pprev;
1326 spin_lock_bh(&icmp6_dst_lock);
1327 pprev = &icmp6_dst_gc_list;
1328 while ((dst = *pprev) != NULL) {
1329 struct rt6_info *rt = (struct rt6_info *) dst;
1330 if (func(rt, arg)) {
1337 spin_unlock_bh(&icmp6_dst_lock);
1340 static int ip6_dst_gc(struct dst_ops *ops)
1342 unsigned long now = jiffies;
1343 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1344 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1345 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1346 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1347 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1348 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1351 entries = dst_entries_get_fast(ops);
1352 if (time_after(rt_last_gc + rt_min_interval, now) &&
1353 entries <= rt_max_size)
1356 net->ipv6.ip6_rt_gc_expire++;
1357 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1358 net->ipv6.ip6_rt_last_gc = now;
1359 entries = dst_entries_get_slow(ops);
1360 if (entries < ops->gc_thresh)
1361 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1363 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1364 return entries > rt_max_size;
1367 int ip6_dst_hoplimit(struct dst_entry *dst)
1369 int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
1370 if (hoplimit == 0) {
1371 struct net_device *dev = dst->dev;
1372 struct inet6_dev *idev;
1375 idev = __in6_dev_get(dev);
1377 hoplimit = idev->cnf.hop_limit;
1379 hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
1384 EXPORT_SYMBOL(ip6_dst_hoplimit);
1390 int ip6_route_add(struct fib6_config *cfg)
1393 struct net *net = cfg->fc_nlinfo.nl_net;
1394 struct rt6_info *rt = NULL;
1395 struct net_device *dev = NULL;
1396 struct inet6_dev *idev = NULL;
1397 struct fib6_table *table;
1400 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1402 #ifndef CONFIG_IPV6_SUBTREES
1403 if (cfg->fc_src_len)
1406 if (cfg->fc_ifindex) {
1408 dev = dev_get_by_index(net, cfg->fc_ifindex);
1411 idev = in6_dev_get(dev);
1416 if (cfg->fc_metric == 0)
1417 cfg->fc_metric = IP6_RT_PRIO_USER;
1420 if (cfg->fc_nlinfo.nlh &&
1421 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1422 table = fib6_get_table(net, cfg->fc_table);
1424 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1425 table = fib6_new_table(net, cfg->fc_table);
1428 table = fib6_new_table(net, cfg->fc_table);
1434 rt = ip6_dst_alloc(net, NULL, DST_NOCOUNT, table);
1441 if (cfg->fc_flags & RTF_EXPIRES)
1442 rt6_set_expires(rt, jiffies +
1443 clock_t_to_jiffies(cfg->fc_expires));
1445 rt6_clean_expires(rt);
1447 if (cfg->fc_protocol == RTPROT_UNSPEC)
1448 cfg->fc_protocol = RTPROT_BOOT;
1449 rt->rt6i_protocol = cfg->fc_protocol;
1451 addr_type = ipv6_addr_type(&cfg->fc_dst);
1453 if (addr_type & IPV6_ADDR_MULTICAST)
1454 rt->dst.input = ip6_mc_input;
1455 else if (cfg->fc_flags & RTF_LOCAL)
1456 rt->dst.input = ip6_input;
1458 rt->dst.input = ip6_forward;
1460 rt->dst.output = ip6_output;
1462 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1463 rt->rt6i_dst.plen = cfg->fc_dst_len;
1464 if (rt->rt6i_dst.plen == 128)
1465 rt->dst.flags |= DST_HOST;
1467 if (!(rt->dst.flags & DST_HOST) && cfg->fc_mx) {
1468 u32 *metrics = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1473 dst_init_metrics(&rt->dst, metrics, 0);
1475 #ifdef CONFIG_IPV6_SUBTREES
1476 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1477 rt->rt6i_src.plen = cfg->fc_src_len;
1480 rt->rt6i_metric = cfg->fc_metric;
1482 /* We cannot add true routes via loopback here,
1483 they would result in kernel looping; promote them to reject routes
1485 if ((cfg->fc_flags & RTF_REJECT) ||
1486 (dev && (dev->flags & IFF_LOOPBACK) &&
1487 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1488 !(cfg->fc_flags & RTF_LOCAL))) {
1489 /* hold loopback dev/idev if we haven't done so. */
1490 if (dev != net->loopback_dev) {
1495 dev = net->loopback_dev;
1497 idev = in6_dev_get(dev);
1503 rt->dst.output = ip6_pkt_discard_out;
1504 rt->dst.input = ip6_pkt_discard;
1505 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1506 switch (cfg->fc_type) {
1508 rt->dst.error = -EINVAL;
1511 rt->dst.error = -EACCES;
1514 rt->dst.error = -EAGAIN;
1517 rt->dst.error = -ENETUNREACH;
1523 if (cfg->fc_flags & RTF_GATEWAY) {
1524 const struct in6_addr *gw_addr;
1527 gw_addr = &cfg->fc_gateway;
1528 rt->rt6i_gateway = *gw_addr;
1529 gwa_type = ipv6_addr_type(gw_addr);
1531 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1532 struct rt6_info *grt;
1534 /* IPv6 strictly inhibits using not link-local
1535 addresses as nexthop address.
1536 Otherwise, router will not able to send redirects.
1537 It is very good, but in some (rare!) circumstances
1538 (SIT, PtP, NBMA NOARP links) it is handy to allow
1539 some exceptions. --ANK
1542 if (!(gwa_type & IPV6_ADDR_UNICAST))
1545 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1547 err = -EHOSTUNREACH;
1551 if (dev != grt->dst.dev) {
1557 idev = grt->rt6i_idev;
1559 in6_dev_hold(grt->rt6i_idev);
1561 if (!(grt->rt6i_flags & RTF_GATEWAY))
1569 if (!dev || (dev->flags & IFF_LOOPBACK))
1577 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1578 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1582 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1583 rt->rt6i_prefsrc.plen = 128;
1585 rt->rt6i_prefsrc.plen = 0;
1587 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1588 err = rt6_bind_neighbour(rt, dev);
1593 rt->rt6i_flags = cfg->fc_flags;
1600 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1601 int type = nla_type(nla);
1604 if (type > RTAX_MAX) {
1609 dst_metric_set(&rt->dst, type, nla_get_u32(nla));
1615 rt->rt6i_idev = idev;
1616 rt->rt6i_table = table;
1618 cfg->fc_nlinfo.nl_net = dev_net(dev);
1620 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1632 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1635 struct fib6_table *table;
1636 struct net *net = dev_net(rt->dst.dev);
1638 if (rt == net->ipv6.ip6_null_entry) {
1643 table = rt->rt6i_table;
1644 write_lock_bh(&table->tb6_lock);
1645 err = fib6_del(rt, info);
1646 write_unlock_bh(&table->tb6_lock);
1653 int ip6_del_rt(struct rt6_info *rt)
1655 struct nl_info info = {
1656 .nl_net = dev_net(rt->dst.dev),
1658 return __ip6_del_rt(rt, &info);
1661 static int ip6_route_del(struct fib6_config *cfg)
1663 struct fib6_table *table;
1664 struct fib6_node *fn;
1665 struct rt6_info *rt;
1668 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1672 read_lock_bh(&table->tb6_lock);
1674 fn = fib6_locate(&table->tb6_root,
1675 &cfg->fc_dst, cfg->fc_dst_len,
1676 &cfg->fc_src, cfg->fc_src_len);
1679 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1680 if (cfg->fc_ifindex &&
1682 rt->dst.dev->ifindex != cfg->fc_ifindex))
1684 if (cfg->fc_flags & RTF_GATEWAY &&
1685 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1687 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1690 read_unlock_bh(&table->tb6_lock);
1692 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1695 read_unlock_bh(&table->tb6_lock);
1700 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1702 struct net *net = dev_net(skb->dev);
1703 struct netevent_redirect netevent;
1704 struct rt6_info *rt, *nrt = NULL;
1705 struct ndisc_options ndopts;
1706 struct neighbour *old_neigh;
1707 struct inet6_dev *in6_dev;
1708 struct neighbour *neigh;
1710 int optlen, on_link;
1713 optlen = skb->tail - skb->transport_header;
1714 optlen -= sizeof(*msg);
1717 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1721 msg = (struct rd_msg *)icmp6_hdr(skb);
1723 if (ipv6_addr_is_multicast(&msg->dest)) {
1724 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1729 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
1731 } else if (ipv6_addr_type(&msg->target) !=
1732 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1733 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1737 in6_dev = __in6_dev_get(skb->dev);
1740 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1744 * The IP source address of the Redirect MUST be the same as the current
1745 * first-hop router for the specified ICMP Destination Address.
1748 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
1749 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1754 if (ndopts.nd_opts_tgt_lladdr) {
1755 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1758 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1763 rt = (struct rt6_info *) dst;
1764 if (rt == net->ipv6.ip6_null_entry) {
1765 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1769 /* Redirect received -> path was valid.
1770 * Look, redirects are sent only in response to data packets,
1771 * so that this nexthop apparently is reachable. --ANK
1773 dst_confirm(&rt->dst);
1775 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
1779 /* Duplicate redirect: silently ignore. */
1781 if (neigh == old_neigh)
1785 * We have finally decided to accept it.
1788 neigh_update(neigh, lladdr, NUD_STALE,
1789 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1790 NEIGH_UPDATE_F_OVERRIDE|
1791 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1792 NEIGH_UPDATE_F_ISROUTER))
1795 nrt = ip6_rt_copy(rt, &msg->dest);
1799 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1801 nrt->rt6i_flags &= ~RTF_GATEWAY;
1803 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1804 nrt->n = neigh_clone(neigh);
1806 if (ip6_ins_rt(nrt))
1809 netevent.old = &rt->dst;
1810 netevent.new = &nrt->dst;
1811 netevent.daddr = &msg->dest;
1812 netevent.neigh = neigh;
1813 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1815 if (rt->rt6i_flags & RTF_CACHE) {
1816 rt = (struct rt6_info *) dst_clone(&rt->dst);
1821 neigh_release(neigh);
1825 * Misc support functions
1828 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1829 const struct in6_addr *dest)
1831 struct net *net = dev_net(ort->dst.dev);
1832 struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1836 rt->dst.input = ort->dst.input;
1837 rt->dst.output = ort->dst.output;
1838 rt->dst.flags |= DST_HOST;
1840 rt->rt6i_dst.addr = *dest;
1841 rt->rt6i_dst.plen = 128;
1842 dst_copy_metrics(&rt->dst, &ort->dst);
1843 rt->dst.error = ort->dst.error;
1844 rt->rt6i_idev = ort->rt6i_idev;
1846 in6_dev_hold(rt->rt6i_idev);
1847 rt->dst.lastuse = jiffies;
1849 rt->rt6i_gateway = ort->rt6i_gateway;
1850 rt->rt6i_flags = ort->rt6i_flags;
1851 if ((ort->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) ==
1852 (RTF_DEFAULT | RTF_ADDRCONF))
1853 rt6_set_from(rt, ort);
1855 rt6_clean_expires(rt);
1856 rt->rt6i_metric = 0;
1858 #ifdef CONFIG_IPV6_SUBTREES
1859 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1861 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1862 rt->rt6i_table = ort->rt6i_table;
1867 #ifdef CONFIG_IPV6_ROUTE_INFO
1868 static struct rt6_info *rt6_get_route_info(struct net *net,
1869 const struct in6_addr *prefix, int prefixlen,
1870 const struct in6_addr *gwaddr, int ifindex)
1872 struct fib6_node *fn;
1873 struct rt6_info *rt = NULL;
1874 struct fib6_table *table;
1876 table = fib6_get_table(net, RT6_TABLE_INFO);
1880 read_lock_bh(&table->tb6_lock);
1881 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1885 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1886 if (rt->dst.dev->ifindex != ifindex)
1888 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1890 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1896 read_unlock_bh(&table->tb6_lock);
1900 static struct rt6_info *rt6_add_route_info(struct net *net,
1901 const struct in6_addr *prefix, int prefixlen,
1902 const struct in6_addr *gwaddr, int ifindex,
1905 struct fib6_config cfg = {
1906 .fc_table = RT6_TABLE_INFO,
1907 .fc_metric = IP6_RT_PRIO_USER,
1908 .fc_ifindex = ifindex,
1909 .fc_dst_len = prefixlen,
1910 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1911 RTF_UP | RTF_PREF(pref),
1912 .fc_nlinfo.portid = 0,
1913 .fc_nlinfo.nlh = NULL,
1914 .fc_nlinfo.nl_net = net,
1917 cfg.fc_dst = *prefix;
1918 cfg.fc_gateway = *gwaddr;
1920 /* We should treat it as a default route if prefix length is 0. */
1922 cfg.fc_flags |= RTF_DEFAULT;
1924 ip6_route_add(&cfg);
1926 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1930 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1932 struct rt6_info *rt;
1933 struct fib6_table *table;
1935 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1939 read_lock_bh(&table->tb6_lock);
1940 for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1941 if (dev == rt->dst.dev &&
1942 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1943 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1948 read_unlock_bh(&table->tb6_lock);
1952 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
1953 struct net_device *dev,
1956 struct fib6_config cfg = {
1957 .fc_table = RT6_TABLE_DFLT,
1958 .fc_metric = IP6_RT_PRIO_USER,
1959 .fc_ifindex = dev->ifindex,
1960 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1961 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1962 .fc_nlinfo.portid = 0,
1963 .fc_nlinfo.nlh = NULL,
1964 .fc_nlinfo.nl_net = dev_net(dev),
1967 cfg.fc_gateway = *gwaddr;
1969 ip6_route_add(&cfg);
1971 return rt6_get_dflt_router(gwaddr, dev);
1974 void rt6_purge_dflt_routers(struct net *net)
1976 struct rt6_info *rt;
1977 struct fib6_table *table;
1979 /* NOTE: Keep consistent with rt6_get_dflt_router */
1980 table = fib6_get_table(net, RT6_TABLE_DFLT);
1985 read_lock_bh(&table->tb6_lock);
1986 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
1987 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1989 read_unlock_bh(&table->tb6_lock);
1994 read_unlock_bh(&table->tb6_lock);
1997 static void rtmsg_to_fib6_config(struct net *net,
1998 struct in6_rtmsg *rtmsg,
1999 struct fib6_config *cfg)
2001 memset(cfg, 0, sizeof(*cfg));
2003 cfg->fc_table = RT6_TABLE_MAIN;
2004 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2005 cfg->fc_metric = rtmsg->rtmsg_metric;
2006 cfg->fc_expires = rtmsg->rtmsg_info;
2007 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2008 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2009 cfg->fc_flags = rtmsg->rtmsg_flags;
2011 cfg->fc_nlinfo.nl_net = net;
2013 cfg->fc_dst = rtmsg->rtmsg_dst;
2014 cfg->fc_src = rtmsg->rtmsg_src;
2015 cfg->fc_gateway = rtmsg->rtmsg_gateway;
2018 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2020 struct fib6_config cfg;
2021 struct in6_rtmsg rtmsg;
2025 case SIOCADDRT: /* Add a route */
2026 case SIOCDELRT: /* Delete a route */
2027 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2029 err = copy_from_user(&rtmsg, arg,
2030 sizeof(struct in6_rtmsg));
2034 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2039 err = ip6_route_add(&cfg);
2042 err = ip6_route_del(&cfg);
2056 * Drop the packet on the floor
2059 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2062 struct dst_entry *dst = skb_dst(skb);
2063 switch (ipstats_mib_noroutes) {
2064 case IPSTATS_MIB_INNOROUTES:
2065 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2066 if (type == IPV6_ADDR_ANY) {
2067 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2068 IPSTATS_MIB_INADDRERRORS);
2072 case IPSTATS_MIB_OUTNOROUTES:
2073 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2074 ipstats_mib_noroutes);
2077 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2082 static int ip6_pkt_discard(struct sk_buff *skb)
2084 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2087 static int ip6_pkt_discard_out(struct sk_buff *skb)
2089 skb->dev = skb_dst(skb)->dev;
2090 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2093 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2095 static int ip6_pkt_prohibit(struct sk_buff *skb)
2097 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2100 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2102 skb->dev = skb_dst(skb)->dev;
2103 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2109 * Allocate a dst for local (unicast / anycast) address.
2112 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2113 const struct in6_addr *addr,
2116 struct net *net = dev_net(idev->dev);
2117 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev, 0, NULL);
2121 net_warn_ratelimited("Maximum number of routes reached, consider increasing route/max_size\n");
2122 return ERR_PTR(-ENOMEM);
2127 rt->dst.flags |= DST_HOST;
2128 rt->dst.input = ip6_input;
2129 rt->dst.output = ip6_output;
2130 rt->rt6i_idev = idev;
2132 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2134 rt->rt6i_flags |= RTF_ANYCAST;
2136 rt->rt6i_flags |= RTF_LOCAL;
2137 err = rt6_bind_neighbour(rt, rt->dst.dev);
2140 return ERR_PTR(err);
2143 rt->rt6i_dst.addr = *addr;
2144 rt->rt6i_dst.plen = 128;
2145 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2147 atomic_set(&rt->dst.__refcnt, 1);
2152 int ip6_route_get_saddr(struct net *net,
2153 struct rt6_info *rt,
2154 const struct in6_addr *daddr,
2156 struct in6_addr *saddr)
2158 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2160 if (rt->rt6i_prefsrc.plen)
2161 *saddr = rt->rt6i_prefsrc.addr;
2163 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2164 daddr, prefs, saddr);
2168 /* remove deleted ip from prefsrc entries */
2169 struct arg_dev_net_ip {
2170 struct net_device *dev;
2172 struct in6_addr *addr;
2175 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2177 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2178 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2179 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2181 if (((void *)rt->dst.dev == dev || !dev) &&
2182 rt != net->ipv6.ip6_null_entry &&
2183 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2184 /* remove prefsrc entry */
2185 rt->rt6i_prefsrc.plen = 0;
2190 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2192 struct net *net = dev_net(ifp->idev->dev);
2193 struct arg_dev_net_ip adni = {
2194 .dev = ifp->idev->dev,
2198 fib6_clean_all(net, fib6_remove_prefsrc, 0, &adni);
2201 struct arg_dev_net {
2202 struct net_device *dev;
2206 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2208 const struct arg_dev_net *adn = arg;
2209 const struct net_device *dev = adn->dev;
2211 if ((rt->dst.dev == dev || !dev) &&
2212 rt != adn->net->ipv6.ip6_null_entry)
2218 void rt6_ifdown(struct net *net, struct net_device *dev)
2220 struct arg_dev_net adn = {
2225 fib6_clean_all(net, fib6_ifdown, 0, &adn);
2226 icmp6_clean_all(fib6_ifdown, &adn);
2229 struct rt6_mtu_change_arg {
2230 struct net_device *dev;
2234 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2236 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2237 struct inet6_dev *idev;
2239 /* In IPv6 pmtu discovery is not optional,
2240 so that RTAX_MTU lock cannot disable it.
2241 We still use this lock to block changes
2242 caused by addrconf/ndisc.
2245 idev = __in6_dev_get(arg->dev);
2249 /* For administrative MTU increase, there is no way to discover
2250 IPv6 PMTU increase, so PMTU increase should be updated here.
2251 Since RFC 1981 doesn't include administrative MTU increase
2252 update PMTU increase is a MUST. (i.e. jumbo frame)
2255 If new MTU is less than route PMTU, this new MTU will be the
2256 lowest MTU in the path, update the route PMTU to reflect PMTU
2257 decreases; if new MTU is greater than route PMTU, and the
2258 old MTU is the lowest MTU in the path, update the route PMTU
2259 to reflect the increase. In this case if the other nodes' MTU
2260 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2263 if (rt->dst.dev == arg->dev &&
2264 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2265 (dst_mtu(&rt->dst) >= arg->mtu ||
2266 (dst_mtu(&rt->dst) < arg->mtu &&
2267 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2268 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2273 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2275 struct rt6_mtu_change_arg arg = {
2280 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
2283 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2284 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2285 [RTA_OIF] = { .type = NLA_U32 },
2286 [RTA_IIF] = { .type = NLA_U32 },
2287 [RTA_PRIORITY] = { .type = NLA_U32 },
2288 [RTA_METRICS] = { .type = NLA_NESTED },
2289 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2292 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2293 struct fib6_config *cfg)
2296 struct nlattr *tb[RTA_MAX+1];
2299 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2304 rtm = nlmsg_data(nlh);
2305 memset(cfg, 0, sizeof(*cfg));
2307 cfg->fc_table = rtm->rtm_table;
2308 cfg->fc_dst_len = rtm->rtm_dst_len;
2309 cfg->fc_src_len = rtm->rtm_src_len;
2310 cfg->fc_flags = RTF_UP;
2311 cfg->fc_protocol = rtm->rtm_protocol;
2312 cfg->fc_type = rtm->rtm_type;
2314 if (rtm->rtm_type == RTN_UNREACHABLE ||
2315 rtm->rtm_type == RTN_BLACKHOLE ||
2316 rtm->rtm_type == RTN_PROHIBIT ||
2317 rtm->rtm_type == RTN_THROW)
2318 cfg->fc_flags |= RTF_REJECT;
2320 if (rtm->rtm_type == RTN_LOCAL)
2321 cfg->fc_flags |= RTF_LOCAL;
2323 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2324 cfg->fc_nlinfo.nlh = nlh;
2325 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2327 if (tb[RTA_GATEWAY]) {
2328 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2329 cfg->fc_flags |= RTF_GATEWAY;
2333 int plen = (rtm->rtm_dst_len + 7) >> 3;
2335 if (nla_len(tb[RTA_DST]) < plen)
2338 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2342 int plen = (rtm->rtm_src_len + 7) >> 3;
2344 if (nla_len(tb[RTA_SRC]) < plen)
2347 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2350 if (tb[RTA_PREFSRC])
2351 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2354 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2356 if (tb[RTA_PRIORITY])
2357 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2359 if (tb[RTA_METRICS]) {
2360 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2361 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2365 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2367 if (tb[RTA_MULTIPATH]) {
2368 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2369 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2377 static int ip6_route_multipath(struct fib6_config *cfg, int add)
2379 struct fib6_config r_cfg;
2380 struct rtnexthop *rtnh;
2383 int err = 0, last_err = 0;
2386 rtnh = (struct rtnexthop *)cfg->fc_mp;
2387 remaining = cfg->fc_mp_len;
2389 /* Parse a Multipath Entry */
2390 while (rtnh_ok(rtnh, remaining)) {
2391 memcpy(&r_cfg, cfg, sizeof(*cfg));
2392 if (rtnh->rtnh_ifindex)
2393 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2395 attrlen = rtnh_attrlen(rtnh);
2397 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2399 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2401 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2402 r_cfg.fc_flags |= RTF_GATEWAY;
2405 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2408 /* If we are trying to remove a route, do not stop the
2409 * loop when ip6_route_del() fails (because next hop is
2410 * already gone), we should try to remove all next hops.
2413 /* If add fails, we should try to delete all
2414 * next hops that have been already added.
2420 /* Because each route is added like a single route we remove
2421 * this flag after the first nexthop (if there is a collision,
2422 * we have already fail to add the first nexthop:
2423 * fib6_add_rt2node() has reject it).
2425 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
2426 rtnh = rtnh_next(rtnh, &remaining);
2432 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2434 struct fib6_config cfg;
2437 err = rtm_to_fib6_config(skb, nlh, &cfg);
2442 return ip6_route_multipath(&cfg, 0);
2444 return ip6_route_del(&cfg);
2447 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2449 struct fib6_config cfg;
2452 err = rtm_to_fib6_config(skb, nlh, &cfg);
2457 return ip6_route_multipath(&cfg, 1);
2459 return ip6_route_add(&cfg);
2462 static inline size_t rt6_nlmsg_size(void)
2464 return NLMSG_ALIGN(sizeof(struct rtmsg))
2465 + nla_total_size(16) /* RTA_SRC */
2466 + nla_total_size(16) /* RTA_DST */
2467 + nla_total_size(16) /* RTA_GATEWAY */
2468 + nla_total_size(16) /* RTA_PREFSRC */
2469 + nla_total_size(4) /* RTA_TABLE */
2470 + nla_total_size(4) /* RTA_IIF */
2471 + nla_total_size(4) /* RTA_OIF */
2472 + nla_total_size(4) /* RTA_PRIORITY */
2473 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2474 + nla_total_size(sizeof(struct rta_cacheinfo));
2477 static int rt6_fill_node(struct net *net,
2478 struct sk_buff *skb, struct rt6_info *rt,
2479 struct in6_addr *dst, struct in6_addr *src,
2480 int iif, int type, u32 portid, u32 seq,
2481 int prefix, int nowait, unsigned int flags)
2484 struct nlmsghdr *nlh;
2488 if (prefix) { /* user wants prefix routes only */
2489 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2490 /* success since this is not a prefix route */
2495 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2499 rtm = nlmsg_data(nlh);
2500 rtm->rtm_family = AF_INET6;
2501 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2502 rtm->rtm_src_len = rt->rt6i_src.plen;
2505 table = rt->rt6i_table->tb6_id;
2507 table = RT6_TABLE_UNSPEC;
2508 rtm->rtm_table = table;
2509 if (nla_put_u32(skb, RTA_TABLE, table))
2510 goto nla_put_failure;
2511 if (rt->rt6i_flags & RTF_REJECT) {
2512 switch (rt->dst.error) {
2514 rtm->rtm_type = RTN_BLACKHOLE;
2517 rtm->rtm_type = RTN_PROHIBIT;
2520 rtm->rtm_type = RTN_THROW;
2523 rtm->rtm_type = RTN_UNREACHABLE;
2527 else if (rt->rt6i_flags & RTF_LOCAL)
2528 rtm->rtm_type = RTN_LOCAL;
2529 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2530 rtm->rtm_type = RTN_LOCAL;
2532 rtm->rtm_type = RTN_UNICAST;
2534 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2535 rtm->rtm_protocol = rt->rt6i_protocol;
2536 if (rt->rt6i_flags & RTF_DYNAMIC)
2537 rtm->rtm_protocol = RTPROT_REDIRECT;
2538 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2539 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2540 rtm->rtm_protocol = RTPROT_RA;
2542 rtm->rtm_protocol = RTPROT_KERNEL;
2545 if (rt->rt6i_flags & RTF_CACHE)
2546 rtm->rtm_flags |= RTM_F_CLONED;
2549 if (nla_put(skb, RTA_DST, 16, dst))
2550 goto nla_put_failure;
2551 rtm->rtm_dst_len = 128;
2552 } else if (rtm->rtm_dst_len)
2553 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2554 goto nla_put_failure;
2555 #ifdef CONFIG_IPV6_SUBTREES
2557 if (nla_put(skb, RTA_SRC, 16, src))
2558 goto nla_put_failure;
2559 rtm->rtm_src_len = 128;
2560 } else if (rtm->rtm_src_len &&
2561 nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2562 goto nla_put_failure;
2565 #ifdef CONFIG_IPV6_MROUTE
2566 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2567 int err = ip6mr_get_route(net, skb, rtm, nowait);
2572 goto nla_put_failure;
2574 if (err == -EMSGSIZE)
2575 goto nla_put_failure;
2580 if (nla_put_u32(skb, RTA_IIF, iif))
2581 goto nla_put_failure;
2583 struct in6_addr saddr_buf;
2584 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2585 nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2586 goto nla_put_failure;
2589 if (rt->rt6i_prefsrc.plen) {
2590 struct in6_addr saddr_buf;
2591 saddr_buf = rt->rt6i_prefsrc.addr;
2592 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2593 goto nla_put_failure;
2596 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2597 goto nla_put_failure;
2599 if (rt->rt6i_flags & RTF_GATEWAY) {
2600 if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
2601 goto nla_put_failure;
2605 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2606 goto nla_put_failure;
2607 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2608 goto nla_put_failure;
2610 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2612 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2613 goto nla_put_failure;
2615 return nlmsg_end(skb, nlh);
2618 nlmsg_cancel(skb, nlh);
2622 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2624 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2627 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2628 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2629 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2633 return rt6_fill_node(arg->net,
2634 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2635 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2636 prefix, 0, NLM_F_MULTI);
2639 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2641 struct net *net = sock_net(in_skb->sk);
2642 struct nlattr *tb[RTA_MAX+1];
2643 struct rt6_info *rt;
2644 struct sk_buff *skb;
2647 int err, iif = 0, oif = 0;
2649 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2654 memset(&fl6, 0, sizeof(fl6));
2657 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2660 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2664 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2667 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2671 iif = nla_get_u32(tb[RTA_IIF]);
2674 oif = nla_get_u32(tb[RTA_OIF]);
2677 struct net_device *dev;
2680 dev = __dev_get_by_index(net, iif);
2686 fl6.flowi6_iif = iif;
2688 if (!ipv6_addr_any(&fl6.saddr))
2689 flags |= RT6_LOOKUP_F_HAS_SADDR;
2691 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2694 fl6.flowi6_oif = oif;
2696 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2699 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2706 /* Reserve room for dummy headers, this skb can pass
2707 through good chunk of routing engine.
2709 skb_reset_mac_header(skb);
2710 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2712 skb_dst_set(skb, &rt->dst);
2714 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2715 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2716 nlh->nlmsg_seq, 0, 0, 0);
2722 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2727 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2729 struct sk_buff *skb;
2730 struct net *net = info->nl_net;
2735 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2737 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2741 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2742 event, info->portid, seq, 0, 0, 0);
2744 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2745 WARN_ON(err == -EMSGSIZE);
2749 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2750 info->nlh, gfp_any());
2754 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2757 static int ip6_route_dev_notify(struct notifier_block *this,
2758 unsigned long event, void *data)
2760 struct net_device *dev = (struct net_device *)data;
2761 struct net *net = dev_net(dev);
2763 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2764 net->ipv6.ip6_null_entry->dst.dev = dev;
2765 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2766 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2767 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2768 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2769 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2770 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2781 #ifdef CONFIG_PROC_FS
2792 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2794 struct seq_file *m = p_arg;
2796 seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
2798 #ifdef CONFIG_IPV6_SUBTREES
2799 seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
2801 seq_puts(m, "00000000000000000000000000000000 00 ");
2803 if (rt->rt6i_flags & RTF_GATEWAY) {
2804 seq_printf(m, "%pi6", &rt->rt6i_gateway);
2806 seq_puts(m, "00000000000000000000000000000000");
2808 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2809 rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2810 rt->dst.__use, rt->rt6i_flags,
2811 rt->dst.dev ? rt->dst.dev->name : "");
2815 static int ipv6_route_show(struct seq_file *m, void *v)
2817 struct net *net = (struct net *)m->private;
2818 fib6_clean_all_ro(net, rt6_info_route, 0, m);
2822 static int ipv6_route_open(struct inode *inode, struct file *file)
2824 return single_open_net(inode, file, ipv6_route_show);
2827 static const struct file_operations ipv6_route_proc_fops = {
2828 .owner = THIS_MODULE,
2829 .open = ipv6_route_open,
2831 .llseek = seq_lseek,
2832 .release = single_release_net,
2835 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2837 struct net *net = (struct net *)seq->private;
2838 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2839 net->ipv6.rt6_stats->fib_nodes,
2840 net->ipv6.rt6_stats->fib_route_nodes,
2841 net->ipv6.rt6_stats->fib_rt_alloc,
2842 net->ipv6.rt6_stats->fib_rt_entries,
2843 net->ipv6.rt6_stats->fib_rt_cache,
2844 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2845 net->ipv6.rt6_stats->fib_discarded_routes);
2850 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2852 return single_open_net(inode, file, rt6_stats_seq_show);
2855 static const struct file_operations rt6_stats_seq_fops = {
2856 .owner = THIS_MODULE,
2857 .open = rt6_stats_seq_open,
2859 .llseek = seq_lseek,
2860 .release = single_release_net,
2862 #endif /* CONFIG_PROC_FS */
2864 #ifdef CONFIG_SYSCTL
2867 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
2868 void __user *buffer, size_t *lenp, loff_t *ppos)
2875 net = (struct net *)ctl->extra1;
2876 delay = net->ipv6.sysctl.flush_delay;
2877 proc_dointvec(ctl, write, buffer, lenp, ppos);
2878 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
2882 ctl_table ipv6_route_table_template[] = {
2884 .procname = "flush",
2885 .data = &init_net.ipv6.sysctl.flush_delay,
2886 .maxlen = sizeof(int),
2888 .proc_handler = ipv6_sysctl_rtcache_flush
2891 .procname = "gc_thresh",
2892 .data = &ip6_dst_ops_template.gc_thresh,
2893 .maxlen = sizeof(int),
2895 .proc_handler = proc_dointvec,
2898 .procname = "max_size",
2899 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
2900 .maxlen = sizeof(int),
2902 .proc_handler = proc_dointvec,
2905 .procname = "gc_min_interval",
2906 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2907 .maxlen = sizeof(int),
2909 .proc_handler = proc_dointvec_jiffies,
2912 .procname = "gc_timeout",
2913 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2914 .maxlen = sizeof(int),
2916 .proc_handler = proc_dointvec_jiffies,
2919 .procname = "gc_interval",
2920 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2921 .maxlen = sizeof(int),
2923 .proc_handler = proc_dointvec_jiffies,
2926 .procname = "gc_elasticity",
2927 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2928 .maxlen = sizeof(int),
2930 .proc_handler = proc_dointvec,
2933 .procname = "mtu_expires",
2934 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2935 .maxlen = sizeof(int),
2937 .proc_handler = proc_dointvec_jiffies,
2940 .procname = "min_adv_mss",
2941 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2942 .maxlen = sizeof(int),
2944 .proc_handler = proc_dointvec,
2947 .procname = "gc_min_interval_ms",
2948 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2949 .maxlen = sizeof(int),
2951 .proc_handler = proc_dointvec_ms_jiffies,
2956 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2958 struct ctl_table *table;
2960 table = kmemdup(ipv6_route_table_template,
2961 sizeof(ipv6_route_table_template),
2965 table[0].data = &net->ipv6.sysctl.flush_delay;
2966 table[0].extra1 = net;
2967 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2968 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2969 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2970 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2971 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2972 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2973 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2974 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2975 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2977 /* Don't export sysctls to unprivileged users */
2978 if (net->user_ns != &init_user_ns)
2979 table[0].procname = NULL;
2986 static int __net_init ip6_route_net_init(struct net *net)
2990 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2991 sizeof(net->ipv6.ip6_dst_ops));
2993 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2994 goto out_ip6_dst_ops;
2996 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2997 sizeof(*net->ipv6.ip6_null_entry),
2999 if (!net->ipv6.ip6_null_entry)
3000 goto out_ip6_dst_entries;
3001 net->ipv6.ip6_null_entry->dst.path =
3002 (struct dst_entry *)net->ipv6.ip6_null_entry;
3003 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3004 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3005 ip6_template_metrics, true);
3007 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3008 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3009 sizeof(*net->ipv6.ip6_prohibit_entry),
3011 if (!net->ipv6.ip6_prohibit_entry)
3012 goto out_ip6_null_entry;
3013 net->ipv6.ip6_prohibit_entry->dst.path =
3014 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3015 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3016 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3017 ip6_template_metrics, true);
3019 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3020 sizeof(*net->ipv6.ip6_blk_hole_entry),
3022 if (!net->ipv6.ip6_blk_hole_entry)
3023 goto out_ip6_prohibit_entry;
3024 net->ipv6.ip6_blk_hole_entry->dst.path =
3025 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3026 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3027 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3028 ip6_template_metrics, true);
3031 net->ipv6.sysctl.flush_delay = 0;
3032 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3033 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3034 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3035 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3036 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3037 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3038 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3040 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3046 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3047 out_ip6_prohibit_entry:
3048 kfree(net->ipv6.ip6_prohibit_entry);
3050 kfree(net->ipv6.ip6_null_entry);
3052 out_ip6_dst_entries:
3053 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3058 static void __net_exit ip6_route_net_exit(struct net *net)
3060 kfree(net->ipv6.ip6_null_entry);
3061 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3062 kfree(net->ipv6.ip6_prohibit_entry);
3063 kfree(net->ipv6.ip6_blk_hole_entry);
3065 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3068 static int __net_init ip6_route_net_init_late(struct net *net)
3070 #ifdef CONFIG_PROC_FS
3071 proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
3072 proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
3077 static void __net_exit ip6_route_net_exit_late(struct net *net)
3079 #ifdef CONFIG_PROC_FS
3080 proc_net_remove(net, "ipv6_route");
3081 proc_net_remove(net, "rt6_stats");
3085 static struct pernet_operations ip6_route_net_ops = {
3086 .init = ip6_route_net_init,
3087 .exit = ip6_route_net_exit,
3090 static int __net_init ipv6_inetpeer_init(struct net *net)
3092 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3096 inet_peer_base_init(bp);
3097 net->ipv6.peers = bp;
3101 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3103 struct inet_peer_base *bp = net->ipv6.peers;
3105 net->ipv6.peers = NULL;
3106 inetpeer_invalidate_tree(bp);
3110 static struct pernet_operations ipv6_inetpeer_ops = {
3111 .init = ipv6_inetpeer_init,
3112 .exit = ipv6_inetpeer_exit,
3115 static struct pernet_operations ip6_route_net_late_ops = {
3116 .init = ip6_route_net_init_late,
3117 .exit = ip6_route_net_exit_late,
3120 static struct notifier_block ip6_route_dev_notifier = {
3121 .notifier_call = ip6_route_dev_notify,
3125 int __init ip6_route_init(void)
3130 ip6_dst_ops_template.kmem_cachep =
3131 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3132 SLAB_HWCACHE_ALIGN, NULL);
3133 if (!ip6_dst_ops_template.kmem_cachep)
3136 ret = dst_entries_init(&ip6_dst_blackhole_ops);
3138 goto out_kmem_cache;
3140 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3142 goto out_dst_entries;
3144 ret = register_pernet_subsys(&ip6_route_net_ops);
3146 goto out_register_inetpeer;
3148 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3150 /* Registering of the loopback is done before this portion of code,
3151 * the loopback reference in rt6_info will not be taken, do it
3152 * manually for init_net */
3153 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3154 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3155 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3156 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3157 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3158 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3159 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3163 goto out_register_subsys;
3169 ret = fib6_rules_init();
3173 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3175 goto fib6_rules_init;
3178 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3179 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3180 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3181 goto out_register_late_subsys;
3183 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3185 goto out_register_late_subsys;
3190 out_register_late_subsys:
3191 unregister_pernet_subsys(&ip6_route_net_late_ops);
3193 fib6_rules_cleanup();
3198 out_register_subsys:
3199 unregister_pernet_subsys(&ip6_route_net_ops);
3200 out_register_inetpeer:
3201 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3203 dst_entries_destroy(&ip6_dst_blackhole_ops);
3205 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3209 void ip6_route_cleanup(void)
3211 unregister_netdevice_notifier(&ip6_route_dev_notifier);
3212 unregister_pernet_subsys(&ip6_route_net_late_ops);
3213 fib6_rules_cleanup();
3216 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3217 unregister_pernet_subsys(&ip6_route_net_ops);
3218 dst_entries_destroy(&ip6_dst_blackhole_ops);
3219 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);