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>
69 RT6_NUD_FAIL_HARD = -3,
70 RT6_NUD_FAIL_PROBE = -2,
71 RT6_NUD_FAIL_DO_RR = -1,
75 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
76 const struct in6_addr *dest);
77 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
78 static unsigned int ip6_default_advmss(const struct dst_entry *dst);
79 static unsigned int ip6_mtu(const struct dst_entry *dst);
80 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
81 static void ip6_dst_destroy(struct dst_entry *);
82 static void ip6_dst_ifdown(struct dst_entry *,
83 struct net_device *dev, int how);
84 static int ip6_dst_gc(struct dst_ops *ops);
86 static int ip6_pkt_discard(struct sk_buff *skb);
87 static int ip6_pkt_discard_out(struct sk_buff *skb);
88 static int ip6_pkt_prohibit(struct sk_buff *skb);
89 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
90 static void ip6_link_failure(struct sk_buff *skb);
91 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
92 struct sk_buff *skb, u32 mtu);
93 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
95 static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
97 #ifdef CONFIG_IPV6_ROUTE_INFO
98 static struct rt6_info *rt6_add_route_info(struct net *net,
99 const struct in6_addr *prefix, int prefixlen,
100 const struct in6_addr *gwaddr, int ifindex,
102 static struct rt6_info *rt6_get_route_info(struct net *net,
103 const struct in6_addr *prefix, int prefixlen,
104 const struct in6_addr *gwaddr, int ifindex);
107 static void rt6_bind_peer(struct rt6_info *rt, int create)
109 struct inet_peer_base *base;
110 struct inet_peer *peer;
112 base = inetpeer_base_ptr(rt->_rt6i_peer);
116 peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
118 if (!rt6_set_peer(rt, peer))
123 static struct inet_peer *__rt6_get_peer(struct rt6_info *rt, int create)
125 if (rt6_has_peer(rt))
126 return rt6_peer_ptr(rt);
128 rt6_bind_peer(rt, create);
129 return (rt6_has_peer(rt) ? rt6_peer_ptr(rt) : NULL);
132 static struct inet_peer *rt6_get_peer_create(struct rt6_info *rt)
134 return __rt6_get_peer(rt, 1);
137 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
139 struct rt6_info *rt = (struct rt6_info *) dst;
140 struct inet_peer *peer;
143 if (!(rt->dst.flags & DST_HOST))
146 peer = rt6_get_peer_create(rt);
148 u32 *old_p = __DST_METRICS_PTR(old);
149 unsigned long prev, new;
152 if (inet_metrics_new(peer) ||
153 (old & DST_METRICS_FORCE_OVERWRITE))
154 memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
156 new = (unsigned long) p;
157 prev = cmpxchg(&dst->_metrics, old, new);
160 p = __DST_METRICS_PTR(prev);
161 if (prev & DST_METRICS_READ_ONLY)
168 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
172 struct in6_addr *p = &rt->rt6i_gateway;
174 if (!ipv6_addr_any(p))
175 return (const void *) p;
177 return &ipv6_hdr(skb)->daddr;
181 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
185 struct rt6_info *rt = (struct rt6_info *) dst;
188 daddr = choose_neigh_daddr(rt, skb, daddr);
189 n = __ipv6_neigh_lookup(dst->dev, daddr);
192 return neigh_create(&nd_tbl, daddr, dst->dev);
195 static struct dst_ops ip6_dst_ops_template = {
197 .protocol = cpu_to_be16(ETH_P_IPV6),
200 .check = ip6_dst_check,
201 .default_advmss = ip6_default_advmss,
203 .cow_metrics = ipv6_cow_metrics,
204 .destroy = ip6_dst_destroy,
205 .ifdown = ip6_dst_ifdown,
206 .negative_advice = ip6_negative_advice,
207 .link_failure = ip6_link_failure,
208 .update_pmtu = ip6_rt_update_pmtu,
209 .redirect = rt6_do_redirect,
210 .local_out = __ip6_local_out,
211 .neigh_lookup = ip6_neigh_lookup,
214 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
216 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
218 return mtu ? : dst->dev->mtu;
221 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
222 struct sk_buff *skb, u32 mtu)
226 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
231 static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
237 static struct dst_ops ip6_dst_blackhole_ops = {
239 .protocol = cpu_to_be16(ETH_P_IPV6),
240 .destroy = ip6_dst_destroy,
241 .check = ip6_dst_check,
242 .mtu = ip6_blackhole_mtu,
243 .default_advmss = ip6_default_advmss,
244 .update_pmtu = ip6_rt_blackhole_update_pmtu,
245 .redirect = ip6_rt_blackhole_redirect,
246 .cow_metrics = ip6_rt_blackhole_cow_metrics,
247 .neigh_lookup = ip6_neigh_lookup,
250 static const u32 ip6_template_metrics[RTAX_MAX] = {
251 [RTAX_HOPLIMIT - 1] = 0,
254 static const struct rt6_info ip6_null_entry_template = {
256 .__refcnt = ATOMIC_INIT(1),
258 .obsolete = DST_OBSOLETE_FORCE_CHK,
259 .error = -ENETUNREACH,
260 .input = ip6_pkt_discard,
261 .output = ip6_pkt_discard_out,
263 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
264 .rt6i_protocol = RTPROT_KERNEL,
265 .rt6i_metric = ~(u32) 0,
266 .rt6i_ref = ATOMIC_INIT(1),
269 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
271 static const struct rt6_info ip6_prohibit_entry_template = {
273 .__refcnt = ATOMIC_INIT(1),
275 .obsolete = DST_OBSOLETE_FORCE_CHK,
277 .input = ip6_pkt_prohibit,
278 .output = ip6_pkt_prohibit_out,
280 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
281 .rt6i_protocol = RTPROT_KERNEL,
282 .rt6i_metric = ~(u32) 0,
283 .rt6i_ref = ATOMIC_INIT(1),
286 static const struct rt6_info ip6_blk_hole_entry_template = {
288 .__refcnt = ATOMIC_INIT(1),
290 .obsolete = DST_OBSOLETE_FORCE_CHK,
292 .input = dst_discard,
293 .output = dst_discard,
295 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
296 .rt6i_protocol = RTPROT_KERNEL,
297 .rt6i_metric = ~(u32) 0,
298 .rt6i_ref = ATOMIC_INIT(1),
303 /* allocate dst with ip6_dst_ops */
304 static inline struct rt6_info *ip6_dst_alloc(struct net *net,
305 struct net_device *dev,
307 struct fib6_table *table)
309 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
310 0, DST_OBSOLETE_FORCE_CHK, flags);
313 struct dst_entry *dst = &rt->dst;
315 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
316 rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
317 rt->rt6i_genid = rt_genid_ipv6(net);
318 INIT_LIST_HEAD(&rt->rt6i_siblings);
323 static void ip6_dst_destroy(struct dst_entry *dst)
325 struct rt6_info *rt = (struct rt6_info *)dst;
326 struct inet6_dev *idev = rt->rt6i_idev;
327 struct dst_entry *from = dst->from;
329 if (!(rt->dst.flags & DST_HOST))
330 dst_destroy_metrics_generic(dst);
333 rt->rt6i_idev = NULL;
340 if (rt6_has_peer(rt)) {
341 struct inet_peer *peer = rt6_peer_ptr(rt);
346 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
349 struct rt6_info *rt = (struct rt6_info *)dst;
350 struct inet6_dev *idev = rt->rt6i_idev;
351 struct net_device *loopback_dev =
352 dev_net(dev)->loopback_dev;
354 if (dev != loopback_dev) {
355 if (idev && idev->dev == dev) {
356 struct inet6_dev *loopback_idev =
357 in6_dev_get(loopback_dev);
359 rt->rt6i_idev = loopback_idev;
366 static bool rt6_check_expired(const struct rt6_info *rt)
368 if (rt->rt6i_flags & RTF_EXPIRES) {
369 if (time_after(jiffies, rt->dst.expires))
371 } else if (rt->dst.from) {
372 return rt6_check_expired((struct rt6_info *) rt->dst.from);
377 /* Multipath route selection:
378 * Hash based function using packet header and flowlabel.
379 * Adapted from fib_info_hashfn()
381 static int rt6_info_hash_nhsfn(unsigned int candidate_count,
382 const struct flowi6 *fl6)
384 unsigned int val = fl6->flowi6_proto;
386 val ^= ipv6_addr_hash(&fl6->daddr);
387 val ^= ipv6_addr_hash(&fl6->saddr);
389 /* Work only if this not encapsulated */
390 switch (fl6->flowi6_proto) {
394 val ^= (__force u16)fl6->fl6_sport;
395 val ^= (__force u16)fl6->fl6_dport;
399 val ^= (__force u16)fl6->fl6_icmp_type;
400 val ^= (__force u16)fl6->fl6_icmp_code;
403 /* RFC6438 recommands to use flowlabel */
404 val ^= (__force u32)fl6->flowlabel;
406 /* Perhaps, we need to tune, this function? */
407 val = val ^ (val >> 7) ^ (val >> 12);
408 return val % candidate_count;
411 static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
412 struct flowi6 *fl6, int oif,
415 struct rt6_info *sibling, *next_sibling;
418 route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
419 /* Don't change the route, if route_choosen == 0
420 * (siblings does not include ourself)
423 list_for_each_entry_safe(sibling, next_sibling,
424 &match->rt6i_siblings, rt6i_siblings) {
426 if (route_choosen == 0) {
427 if (rt6_score_route(sibling, oif, strict) < 0)
437 * Route lookup. Any table->tb6_lock is implied.
440 static inline struct rt6_info *rt6_device_match(struct net *net,
442 const struct in6_addr *saddr,
446 struct rt6_info *local = NULL;
447 struct rt6_info *sprt;
449 if (!oif && ipv6_addr_any(saddr))
452 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
453 struct net_device *dev = sprt->dst.dev;
456 if (dev->ifindex == oif)
458 if (dev->flags & IFF_LOOPBACK) {
459 if (!sprt->rt6i_idev ||
460 sprt->rt6i_idev->dev->ifindex != oif) {
461 if (flags & RT6_LOOKUP_F_IFACE && oif)
463 if (local && (!oif ||
464 local->rt6i_idev->dev->ifindex == oif))
470 if (ipv6_chk_addr(net, saddr, dev,
471 flags & RT6_LOOKUP_F_IFACE))
480 if (flags & RT6_LOOKUP_F_IFACE)
481 return net->ipv6.ip6_null_entry;
487 #ifdef CONFIG_IPV6_ROUTER_PREF
488 struct __rt6_probe_work {
489 struct work_struct work;
490 struct in6_addr target;
491 struct net_device *dev;
494 static void rt6_probe_deferred(struct work_struct *w)
496 struct in6_addr mcaddr;
497 struct __rt6_probe_work *work =
498 container_of(w, struct __rt6_probe_work, work);
500 addrconf_addr_solict_mult(&work->target, &mcaddr);
501 ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);
506 static void rt6_probe(struct rt6_info *rt)
508 struct neighbour *neigh;
510 * Okay, this does not seem to be appropriate
511 * for now, however, we need to check if it
512 * is really so; aka Router Reachability Probing.
514 * Router Reachability Probe MUST be rate-limited
515 * to no more than one per minute.
517 if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
520 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
522 write_lock(&neigh->lock);
523 if (neigh->nud_state & NUD_VALID)
528 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
529 struct __rt6_probe_work *work;
531 work = kmalloc(sizeof(*work), GFP_ATOMIC);
534 __neigh_set_probe_once(neigh);
537 write_unlock(&neigh->lock);
540 INIT_WORK(&work->work, rt6_probe_deferred);
541 work->target = rt->rt6i_gateway;
542 dev_hold(rt->dst.dev);
543 work->dev = rt->dst.dev;
544 schedule_work(&work->work);
548 write_unlock(&neigh->lock);
550 rcu_read_unlock_bh();
553 static inline void rt6_probe(struct rt6_info *rt)
559 * Default Router Selection (RFC 2461 6.3.6)
561 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
563 struct net_device *dev = rt->dst.dev;
564 if (!oif || dev->ifindex == oif)
566 if ((dev->flags & IFF_LOOPBACK) &&
567 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
572 static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
574 struct neighbour *neigh;
575 enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
577 if (rt->rt6i_flags & RTF_NONEXTHOP ||
578 !(rt->rt6i_flags & RTF_GATEWAY))
579 return RT6_NUD_SUCCEED;
582 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
584 read_lock(&neigh->lock);
585 if (neigh->nud_state & NUD_VALID)
586 ret = RT6_NUD_SUCCEED;
587 #ifdef CONFIG_IPV6_ROUTER_PREF
588 else if (!(neigh->nud_state & NUD_FAILED))
589 ret = RT6_NUD_SUCCEED;
591 ret = RT6_NUD_FAIL_PROBE;
593 read_unlock(&neigh->lock);
595 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
596 RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
598 rcu_read_unlock_bh();
603 static int rt6_score_route(struct rt6_info *rt, int oif,
608 m = rt6_check_dev(rt, oif);
609 if (!m && (strict & RT6_LOOKUP_F_IFACE))
610 return RT6_NUD_FAIL_HARD;
611 #ifdef CONFIG_IPV6_ROUTER_PREF
612 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
614 if (strict & RT6_LOOKUP_F_REACHABLE) {
615 int n = rt6_check_neigh(rt);
622 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
623 int *mpri, struct rt6_info *match,
627 bool match_do_rr = false;
629 if (rt6_check_expired(rt))
632 m = rt6_score_route(rt, oif, strict);
633 if (m == RT6_NUD_FAIL_DO_RR) {
635 m = 0; /* lowest valid score */
636 } else if (m == RT6_NUD_FAIL_HARD) {
640 if (strict & RT6_LOOKUP_F_REACHABLE)
643 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
645 *do_rr = match_do_rr;
653 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
654 struct rt6_info *rr_head,
655 u32 metric, int oif, int strict,
658 struct rt6_info *rt, *match;
662 for (rt = rr_head; rt && rt->rt6i_metric == metric;
663 rt = rt->dst.rt6_next)
664 match = find_match(rt, oif, strict, &mpri, match, do_rr);
665 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
666 rt = rt->dst.rt6_next)
667 match = find_match(rt, oif, strict, &mpri, match, do_rr);
672 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
674 struct rt6_info *match, *rt0;
680 fn->rr_ptr = rt0 = fn->leaf;
682 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
686 struct rt6_info *next = rt0->dst.rt6_next;
688 /* no entries matched; do round-robin */
689 if (!next || next->rt6i_metric != rt0->rt6i_metric)
696 net = dev_net(rt0->dst.dev);
697 return match ? match : net->ipv6.ip6_null_entry;
700 #ifdef CONFIG_IPV6_ROUTE_INFO
701 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
702 const struct in6_addr *gwaddr)
704 struct net *net = dev_net(dev);
705 struct route_info *rinfo = (struct route_info *) opt;
706 struct in6_addr prefix_buf, *prefix;
708 unsigned long lifetime;
711 if (len < sizeof(struct route_info)) {
715 /* Sanity check for prefix_len and length */
716 if (rinfo->length > 3) {
718 } else if (rinfo->prefix_len > 128) {
720 } else if (rinfo->prefix_len > 64) {
721 if (rinfo->length < 2) {
724 } else if (rinfo->prefix_len > 0) {
725 if (rinfo->length < 1) {
730 pref = rinfo->route_pref;
731 if (pref == ICMPV6_ROUTER_PREF_INVALID)
734 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
736 if (rinfo->length == 3)
737 prefix = (struct in6_addr *)rinfo->prefix;
739 /* this function is safe */
740 ipv6_addr_prefix(&prefix_buf,
741 (struct in6_addr *)rinfo->prefix,
743 prefix = &prefix_buf;
746 if (rinfo->prefix_len == 0)
747 rt = rt6_get_dflt_router(gwaddr, dev);
749 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
750 gwaddr, dev->ifindex);
752 if (rt && !lifetime) {
758 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
761 rt->rt6i_flags = RTF_ROUTEINFO |
762 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
765 if (!addrconf_finite_timeout(lifetime))
766 rt6_clean_expires(rt);
768 rt6_set_expires(rt, jiffies + HZ * lifetime);
776 #define BACKTRACK(__net, saddr) \
778 if (rt == __net->ipv6.ip6_null_entry) { \
779 struct fib6_node *pn; \
781 if (fn->fn_flags & RTN_TL_ROOT) \
784 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
785 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
788 if (fn->fn_flags & RTN_RTINFO) \
794 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
795 struct fib6_table *table,
796 struct flowi6 *fl6, int flags)
798 struct fib6_node *fn;
801 read_lock_bh(&table->tb6_lock);
802 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
805 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
806 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
807 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
808 BACKTRACK(net, &fl6->saddr);
810 dst_use(&rt->dst, jiffies);
811 read_unlock_bh(&table->tb6_lock);
816 struct dst_entry * ip6_route_lookup(struct net *net, struct flowi6 *fl6,
819 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
821 EXPORT_SYMBOL_GPL(ip6_route_lookup);
823 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
824 const struct in6_addr *saddr, int oif, int strict)
826 struct flowi6 fl6 = {
830 struct dst_entry *dst;
831 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
834 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
835 flags |= RT6_LOOKUP_F_HAS_SADDR;
838 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
840 return (struct rt6_info *) dst;
847 EXPORT_SYMBOL(rt6_lookup);
849 /* ip6_ins_rt is called with FREE table->tb6_lock.
850 It takes new route entry, the addition fails by any reason the
851 route is freed. In any case, if caller does not hold it, it may
855 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
856 struct nlattr *mx, int mx_len)
859 struct fib6_table *table;
861 table = rt->rt6i_table;
862 write_lock_bh(&table->tb6_lock);
863 err = fib6_add(&table->tb6_root, rt, info, mx, mx_len);
864 write_unlock_bh(&table->tb6_lock);
869 int ip6_ins_rt(struct rt6_info *rt)
871 struct nl_info info = {
872 .nl_net = dev_net(rt->dst.dev),
874 return __ip6_ins_rt(rt, &info, NULL, 0);
877 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
878 const struct in6_addr *daddr,
879 const struct in6_addr *saddr)
887 rt = ip6_rt_copy(ort, daddr);
890 if (ort->rt6i_dst.plen != 128 &&
891 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
892 rt->rt6i_flags |= RTF_ANYCAST;
894 rt->rt6i_flags |= RTF_CACHE;
896 #ifdef CONFIG_IPV6_SUBTREES
897 if (rt->rt6i_src.plen && saddr) {
898 rt->rt6i_src.addr = *saddr;
899 rt->rt6i_src.plen = 128;
907 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
908 const struct in6_addr *daddr)
910 struct rt6_info *rt = ip6_rt_copy(ort, daddr);
913 rt->rt6i_flags |= RTF_CACHE;
917 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
918 struct flowi6 *fl6, int flags)
920 struct fib6_node *fn;
921 struct rt6_info *rt, *nrt;
925 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
927 strict |= flags & RT6_LOOKUP_F_IFACE;
930 read_lock_bh(&table->tb6_lock);
933 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
936 rt = rt6_select(fn, oif, strict | reachable);
937 if (rt->rt6i_nsiblings)
938 rt = rt6_multipath_select(rt, fl6, oif, strict | reachable);
939 BACKTRACK(net, &fl6->saddr);
940 if (rt == net->ipv6.ip6_null_entry ||
941 rt->rt6i_flags & RTF_CACHE)
945 read_unlock_bh(&table->tb6_lock);
947 if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
948 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
949 else if (!(rt->dst.flags & DST_HOST))
950 nrt = rt6_alloc_clone(rt, &fl6->daddr);
955 rt = nrt ? : net->ipv6.ip6_null_entry;
959 err = ip6_ins_rt(nrt);
968 * Race condition! In the gap, when table->tb6_lock was
969 * released someone could insert this route. Relookup.
980 read_unlock_bh(&table->tb6_lock);
982 rt->dst.lastuse = jiffies;
988 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
989 struct flowi6 *fl6, int flags)
991 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
994 static struct dst_entry *ip6_route_input_lookup(struct net *net,
995 struct net_device *dev,
996 struct flowi6 *fl6, int flags)
998 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
999 flags |= RT6_LOOKUP_F_IFACE;
1001 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
1004 void ip6_route_input(struct sk_buff *skb)
1006 const struct ipv6hdr *iph = ipv6_hdr(skb);
1007 struct net *net = dev_net(skb->dev);
1008 int flags = RT6_LOOKUP_F_HAS_SADDR;
1009 struct flowi6 fl6 = {
1010 .flowi6_iif = skb->dev->ifindex,
1011 .daddr = iph->daddr,
1012 .saddr = iph->saddr,
1013 .flowlabel = ip6_flowinfo(iph),
1014 .flowi6_mark = skb->mark,
1015 .flowi6_proto = iph->nexthdr,
1018 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
1021 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
1022 struct flowi6 *fl6, int flags)
1024 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
1027 struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
1032 fl6->flowi6_iif = LOOPBACK_IFINDEX;
1034 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
1035 flags |= RT6_LOOKUP_F_IFACE;
1037 if (!ipv6_addr_any(&fl6->saddr))
1038 flags |= RT6_LOOKUP_F_HAS_SADDR;
1040 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1042 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1045 EXPORT_SYMBOL(ip6_route_output);
1047 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1049 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1050 struct dst_entry *new = NULL;
1052 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1056 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1057 rt6_init_peer(rt, net->ipv6.peers);
1060 new->input = dst_discard;
1061 new->output = dst_discard;
1063 if (dst_metrics_read_only(&ort->dst))
1064 new->_metrics = ort->dst._metrics;
1066 dst_copy_metrics(new, &ort->dst);
1067 rt->rt6i_idev = ort->rt6i_idev;
1069 in6_dev_hold(rt->rt6i_idev);
1071 rt->rt6i_gateway = ort->rt6i_gateway;
1072 rt->rt6i_flags = ort->rt6i_flags;
1073 rt->rt6i_metric = 0;
1075 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1076 #ifdef CONFIG_IPV6_SUBTREES
1077 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1083 dst_release(dst_orig);
1084 return new ? new : ERR_PTR(-ENOMEM);
1088 * Destination cache support functions
1091 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1093 struct rt6_info *rt;
1095 rt = (struct rt6_info *) dst;
1097 /* All IPV6 dsts are created with ->obsolete set to the value
1098 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1099 * into this function always.
1101 if (rt->rt6i_genid != rt_genid_ipv6(dev_net(rt->dst.dev)))
1104 if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
1107 if (rt6_check_expired(rt))
1113 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1115 struct rt6_info *rt = (struct rt6_info *) dst;
1118 if (rt->rt6i_flags & RTF_CACHE) {
1119 if (rt6_check_expired(rt)) {
1131 static void ip6_link_failure(struct sk_buff *skb)
1133 struct rt6_info *rt;
1135 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1137 rt = (struct rt6_info *) skb_dst(skb);
1139 if (rt->rt6i_flags & RTF_CACHE) {
1143 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
1144 rt->rt6i_node->fn_sernum = -1;
1149 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1150 struct sk_buff *skb, u32 mtu)
1152 struct rt6_info *rt6 = (struct rt6_info*)dst;
1155 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
1156 struct net *net = dev_net(dst->dev);
1158 rt6->rt6i_flags |= RTF_MODIFIED;
1159 if (mtu < IPV6_MIN_MTU) {
1160 u32 features = dst_metric(dst, RTAX_FEATURES);
1162 features |= RTAX_FEATURE_ALLFRAG;
1163 dst_metric_set(dst, RTAX_FEATURES, features);
1165 dst_metric_set(dst, RTAX_MTU, mtu);
1166 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1170 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1173 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1174 struct dst_entry *dst;
1177 memset(&fl6, 0, sizeof(fl6));
1178 fl6.flowi6_oif = oif;
1179 fl6.flowi6_mark = mark;
1180 fl6.daddr = iph->daddr;
1181 fl6.saddr = iph->saddr;
1182 fl6.flowlabel = ip6_flowinfo(iph);
1184 dst = ip6_route_output(net, NULL, &fl6);
1186 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
1189 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1191 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1193 ip6_update_pmtu(skb, sock_net(sk), mtu,
1194 sk->sk_bound_dev_if, sk->sk_mark);
1196 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1198 /* Handle redirects */
1199 struct ip6rd_flowi {
1201 struct in6_addr gateway;
1204 static struct rt6_info *__ip6_route_redirect(struct net *net,
1205 struct fib6_table *table,
1209 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1210 struct rt6_info *rt;
1211 struct fib6_node *fn;
1213 /* Get the "current" route for this destination and
1214 * check if the redirect has come from approriate router.
1216 * RFC 4861 specifies that redirects should only be
1217 * accepted if they come from the nexthop to the target.
1218 * Due to the way the routes are chosen, this notion
1219 * is a bit fuzzy and one might need to check all possible
1223 read_lock_bh(&table->tb6_lock);
1224 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1226 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1227 if (rt6_check_expired(rt))
1231 if (!(rt->rt6i_flags & RTF_GATEWAY))
1233 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1235 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1241 rt = net->ipv6.ip6_null_entry;
1242 else if (rt->dst.error) {
1243 rt = net->ipv6.ip6_null_entry;
1246 BACKTRACK(net, &fl6->saddr);
1250 read_unlock_bh(&table->tb6_lock);
1255 static struct dst_entry *ip6_route_redirect(struct net *net,
1256 const struct flowi6 *fl6,
1257 const struct in6_addr *gateway)
1259 int flags = RT6_LOOKUP_F_HAS_SADDR;
1260 struct ip6rd_flowi rdfl;
1263 rdfl.gateway = *gateway;
1265 return fib6_rule_lookup(net, &rdfl.fl6,
1266 flags, __ip6_route_redirect);
1269 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1271 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1272 struct dst_entry *dst;
1275 memset(&fl6, 0, sizeof(fl6));
1276 fl6.flowi6_oif = oif;
1277 fl6.flowi6_mark = mark;
1278 fl6.daddr = iph->daddr;
1279 fl6.saddr = iph->saddr;
1280 fl6.flowlabel = ip6_flowinfo(iph);
1282 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1283 rt6_do_redirect(dst, NULL, skb);
1286 EXPORT_SYMBOL_GPL(ip6_redirect);
1288 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1291 const struct ipv6hdr *iph = ipv6_hdr(skb);
1292 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1293 struct dst_entry *dst;
1296 memset(&fl6, 0, sizeof(fl6));
1297 fl6.flowi6_oif = oif;
1298 fl6.flowi6_mark = mark;
1299 fl6.daddr = msg->dest;
1300 fl6.saddr = iph->daddr;
1302 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1303 rt6_do_redirect(dst, NULL, skb);
1307 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1309 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1311 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1313 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1315 struct net_device *dev = dst->dev;
1316 unsigned int mtu = dst_mtu(dst);
1317 struct net *net = dev_net(dev);
1319 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1321 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1322 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1325 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1326 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1327 * IPV6_MAXPLEN is also valid and means: "any MSS,
1328 * rely only on pmtu discovery"
1330 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1335 static unsigned int ip6_mtu(const struct dst_entry *dst)
1337 struct inet6_dev *idev;
1338 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1346 idev = __in6_dev_get(dst->dev);
1348 mtu = idev->cnf.mtu6;
1354 static struct dst_entry *icmp6_dst_gc_list;
1355 static DEFINE_SPINLOCK(icmp6_dst_lock);
1357 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1360 struct dst_entry *dst;
1361 struct rt6_info *rt;
1362 struct inet6_dev *idev = in6_dev_get(dev);
1363 struct net *net = dev_net(dev);
1365 if (unlikely(!idev))
1366 return ERR_PTR(-ENODEV);
1368 rt = ip6_dst_alloc(net, dev, 0, NULL);
1369 if (unlikely(!rt)) {
1371 dst = ERR_PTR(-ENOMEM);
1375 rt->dst.flags |= DST_HOST;
1376 rt->dst.output = ip6_output;
1377 atomic_set(&rt->dst.__refcnt, 1);
1378 rt->rt6i_gateway = fl6->daddr;
1379 rt->rt6i_dst.addr = fl6->daddr;
1380 rt->rt6i_dst.plen = 128;
1381 rt->rt6i_idev = idev;
1382 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1384 spin_lock_bh(&icmp6_dst_lock);
1385 rt->dst.next = icmp6_dst_gc_list;
1386 icmp6_dst_gc_list = &rt->dst;
1387 spin_unlock_bh(&icmp6_dst_lock);
1389 fib6_force_start_gc(net);
1391 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1397 int icmp6_dst_gc(void)
1399 struct dst_entry *dst, **pprev;
1402 spin_lock_bh(&icmp6_dst_lock);
1403 pprev = &icmp6_dst_gc_list;
1405 while ((dst = *pprev) != NULL) {
1406 if (!atomic_read(&dst->__refcnt)) {
1415 spin_unlock_bh(&icmp6_dst_lock);
1420 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1423 struct dst_entry *dst, **pprev;
1425 spin_lock_bh(&icmp6_dst_lock);
1426 pprev = &icmp6_dst_gc_list;
1427 while ((dst = *pprev) != NULL) {
1428 struct rt6_info *rt = (struct rt6_info *) dst;
1429 if (func(rt, arg)) {
1436 spin_unlock_bh(&icmp6_dst_lock);
1439 static int ip6_dst_gc(struct dst_ops *ops)
1441 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1442 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1443 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1444 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1445 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1446 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1449 entries = dst_entries_get_fast(ops);
1450 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1451 entries <= rt_max_size)
1454 net->ipv6.ip6_rt_gc_expire++;
1455 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, entries > rt_max_size);
1456 entries = dst_entries_get_slow(ops);
1457 if (entries < ops->gc_thresh)
1458 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1460 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1461 return entries > rt_max_size;
1468 int ip6_route_add(struct fib6_config *cfg)
1471 struct net *net = cfg->fc_nlinfo.nl_net;
1472 struct rt6_info *rt = NULL;
1473 struct net_device *dev = NULL;
1474 struct inet6_dev *idev = NULL;
1475 struct fib6_table *table;
1478 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1480 #ifndef CONFIG_IPV6_SUBTREES
1481 if (cfg->fc_src_len)
1484 if (cfg->fc_ifindex) {
1486 dev = dev_get_by_index(net, cfg->fc_ifindex);
1489 idev = in6_dev_get(dev);
1494 if (cfg->fc_metric == 0)
1495 cfg->fc_metric = IP6_RT_PRIO_USER;
1498 if (cfg->fc_nlinfo.nlh &&
1499 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1500 table = fib6_get_table(net, cfg->fc_table);
1502 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1503 table = fib6_new_table(net, cfg->fc_table);
1506 table = fib6_new_table(net, cfg->fc_table);
1512 rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);
1519 if (cfg->fc_flags & RTF_EXPIRES)
1520 rt6_set_expires(rt, jiffies +
1521 clock_t_to_jiffies(cfg->fc_expires));
1523 rt6_clean_expires(rt);
1525 if (cfg->fc_protocol == RTPROT_UNSPEC)
1526 cfg->fc_protocol = RTPROT_BOOT;
1527 rt->rt6i_protocol = cfg->fc_protocol;
1529 addr_type = ipv6_addr_type(&cfg->fc_dst);
1531 if (addr_type & IPV6_ADDR_MULTICAST)
1532 rt->dst.input = ip6_mc_input;
1533 else if (cfg->fc_flags & RTF_LOCAL)
1534 rt->dst.input = ip6_input;
1536 rt->dst.input = ip6_forward;
1538 rt->dst.output = ip6_output;
1540 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1541 rt->rt6i_dst.plen = cfg->fc_dst_len;
1542 if (rt->rt6i_dst.plen == 128) {
1543 rt->dst.flags |= DST_HOST;
1544 dst_metrics_set_force_overwrite(&rt->dst);
1547 #ifdef CONFIG_IPV6_SUBTREES
1548 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1549 rt->rt6i_src.plen = cfg->fc_src_len;
1552 rt->rt6i_metric = cfg->fc_metric;
1554 /* We cannot add true routes via loopback here,
1555 they would result in kernel looping; promote them to reject routes
1557 if ((cfg->fc_flags & RTF_REJECT) ||
1558 (dev && (dev->flags & IFF_LOOPBACK) &&
1559 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1560 !(cfg->fc_flags & RTF_LOCAL))) {
1561 /* hold loopback dev/idev if we haven't done so. */
1562 if (dev != net->loopback_dev) {
1567 dev = net->loopback_dev;
1569 idev = in6_dev_get(dev);
1575 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1576 switch (cfg->fc_type) {
1578 rt->dst.error = -EINVAL;
1579 rt->dst.output = dst_discard;
1580 rt->dst.input = dst_discard;
1583 rt->dst.error = -EACCES;
1584 rt->dst.output = ip6_pkt_prohibit_out;
1585 rt->dst.input = ip6_pkt_prohibit;
1589 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1591 rt->dst.output = ip6_pkt_discard_out;
1592 rt->dst.input = ip6_pkt_discard;
1598 if (cfg->fc_flags & RTF_GATEWAY) {
1599 const struct in6_addr *gw_addr;
1602 gw_addr = &cfg->fc_gateway;
1603 rt->rt6i_gateway = *gw_addr;
1604 gwa_type = ipv6_addr_type(gw_addr);
1606 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1607 struct rt6_info *grt;
1609 /* IPv6 strictly inhibits using not link-local
1610 addresses as nexthop address.
1611 Otherwise, router will not able to send redirects.
1612 It is very good, but in some (rare!) circumstances
1613 (SIT, PtP, NBMA NOARP links) it is handy to allow
1614 some exceptions. --ANK
1617 if (!(gwa_type & IPV6_ADDR_UNICAST))
1620 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1622 err = -EHOSTUNREACH;
1626 if (dev != grt->dst.dev) {
1632 idev = grt->rt6i_idev;
1634 in6_dev_hold(grt->rt6i_idev);
1636 if (!(grt->rt6i_flags & RTF_GATEWAY))
1644 if (!dev || (dev->flags & IFF_LOOPBACK))
1652 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1653 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1657 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1658 rt->rt6i_prefsrc.plen = 128;
1660 rt->rt6i_prefsrc.plen = 0;
1662 rt->rt6i_flags = cfg->fc_flags;
1666 rt->rt6i_idev = idev;
1667 rt->rt6i_table = table;
1669 cfg->fc_nlinfo.nl_net = dev_net(dev);
1671 return __ip6_ins_rt(rt, &cfg->fc_nlinfo, cfg->fc_mx, cfg->fc_mx_len);
1683 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1686 struct fib6_table *table;
1687 struct net *net = dev_net(rt->dst.dev);
1689 if (rt == net->ipv6.ip6_null_entry) {
1694 table = rt->rt6i_table;
1695 write_lock_bh(&table->tb6_lock);
1696 err = fib6_del(rt, info);
1697 write_unlock_bh(&table->tb6_lock);
1704 int ip6_del_rt(struct rt6_info *rt)
1706 struct nl_info info = {
1707 .nl_net = dev_net(rt->dst.dev),
1709 return __ip6_del_rt(rt, &info);
1712 static int ip6_route_del(struct fib6_config *cfg)
1714 struct fib6_table *table;
1715 struct fib6_node *fn;
1716 struct rt6_info *rt;
1719 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1723 read_lock_bh(&table->tb6_lock);
1725 fn = fib6_locate(&table->tb6_root,
1726 &cfg->fc_dst, cfg->fc_dst_len,
1727 &cfg->fc_src, cfg->fc_src_len);
1730 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1731 if (cfg->fc_ifindex &&
1733 rt->dst.dev->ifindex != cfg->fc_ifindex))
1735 if (cfg->fc_flags & RTF_GATEWAY &&
1736 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1738 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1741 read_unlock_bh(&table->tb6_lock);
1743 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1746 read_unlock_bh(&table->tb6_lock);
1751 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1753 struct net *net = dev_net(skb->dev);
1754 struct netevent_redirect netevent;
1755 struct rt6_info *rt, *nrt = NULL;
1756 struct ndisc_options ndopts;
1757 struct inet6_dev *in6_dev;
1758 struct neighbour *neigh;
1760 int optlen, on_link;
1763 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
1764 optlen -= sizeof(*msg);
1767 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1771 msg = (struct rd_msg *)icmp6_hdr(skb);
1773 if (ipv6_addr_is_multicast(&msg->dest)) {
1774 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1779 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
1781 } else if (ipv6_addr_type(&msg->target) !=
1782 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1783 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1787 in6_dev = __in6_dev_get(skb->dev);
1790 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1794 * The IP source address of the Redirect MUST be the same as the current
1795 * first-hop router for the specified ICMP Destination Address.
1798 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
1799 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1804 if (ndopts.nd_opts_tgt_lladdr) {
1805 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1808 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1813 rt = (struct rt6_info *) dst;
1814 if (rt == net->ipv6.ip6_null_entry) {
1815 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1819 /* Redirect received -> path was valid.
1820 * Look, redirects are sent only in response to data packets,
1821 * so that this nexthop apparently is reachable. --ANK
1823 dst_confirm(&rt->dst);
1825 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
1830 * We have finally decided to accept it.
1833 neigh_update(neigh, lladdr, NUD_STALE,
1834 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1835 NEIGH_UPDATE_F_OVERRIDE|
1836 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1837 NEIGH_UPDATE_F_ISROUTER))
1840 nrt = ip6_rt_copy(rt, &msg->dest);
1844 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1846 nrt->rt6i_flags &= ~RTF_GATEWAY;
1848 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1850 if (ip6_ins_rt(nrt))
1853 netevent.old = &rt->dst;
1854 netevent.new = &nrt->dst;
1855 netevent.daddr = &msg->dest;
1856 netevent.neigh = neigh;
1857 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1859 if (rt->rt6i_flags & RTF_CACHE) {
1860 rt = (struct rt6_info *) dst_clone(&rt->dst);
1865 neigh_release(neigh);
1869 * Misc support functions
1872 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1873 const struct in6_addr *dest)
1875 struct net *net = dev_net(ort->dst.dev);
1876 struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1880 rt->dst.input = ort->dst.input;
1881 rt->dst.output = ort->dst.output;
1882 rt->dst.flags |= DST_HOST;
1884 rt->rt6i_dst.addr = *dest;
1885 rt->rt6i_dst.plen = 128;
1886 dst_copy_metrics(&rt->dst, &ort->dst);
1887 rt->dst.error = ort->dst.error;
1888 rt->rt6i_idev = ort->rt6i_idev;
1890 in6_dev_hold(rt->rt6i_idev);
1891 rt->dst.lastuse = jiffies;
1893 if (ort->rt6i_flags & RTF_GATEWAY)
1894 rt->rt6i_gateway = ort->rt6i_gateway;
1896 rt->rt6i_gateway = *dest;
1897 rt->rt6i_flags = ort->rt6i_flags;
1898 rt6_set_from(rt, ort);
1899 rt->rt6i_metric = 0;
1901 #ifdef CONFIG_IPV6_SUBTREES
1902 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1904 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1905 rt->rt6i_table = ort->rt6i_table;
1910 #ifdef CONFIG_IPV6_ROUTE_INFO
1911 static struct rt6_info *rt6_get_route_info(struct net *net,
1912 const struct in6_addr *prefix, int prefixlen,
1913 const struct in6_addr *gwaddr, int ifindex)
1915 struct fib6_node *fn;
1916 struct rt6_info *rt = NULL;
1917 struct fib6_table *table;
1919 table = fib6_get_table(net, RT6_TABLE_INFO);
1923 read_lock_bh(&table->tb6_lock);
1924 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1928 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1929 if (rt->dst.dev->ifindex != ifindex)
1931 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1933 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1939 read_unlock_bh(&table->tb6_lock);
1943 static struct rt6_info *rt6_add_route_info(struct net *net,
1944 const struct in6_addr *prefix, int prefixlen,
1945 const struct in6_addr *gwaddr, int ifindex,
1948 struct fib6_config cfg = {
1949 .fc_table = RT6_TABLE_INFO,
1950 .fc_metric = IP6_RT_PRIO_USER,
1951 .fc_ifindex = ifindex,
1952 .fc_dst_len = prefixlen,
1953 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1954 RTF_UP | RTF_PREF(pref),
1955 .fc_nlinfo.portid = 0,
1956 .fc_nlinfo.nlh = NULL,
1957 .fc_nlinfo.nl_net = net,
1960 cfg.fc_dst = *prefix;
1961 cfg.fc_gateway = *gwaddr;
1963 /* We should treat it as a default route if prefix length is 0. */
1965 cfg.fc_flags |= RTF_DEFAULT;
1967 ip6_route_add(&cfg);
1969 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1973 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1975 struct rt6_info *rt;
1976 struct fib6_table *table;
1978 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1982 read_lock_bh(&table->tb6_lock);
1983 for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1984 if (dev == rt->dst.dev &&
1985 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1986 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1991 read_unlock_bh(&table->tb6_lock);
1995 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
1996 struct net_device *dev,
1999 struct fib6_config cfg = {
2000 .fc_table = RT6_TABLE_DFLT,
2001 .fc_metric = IP6_RT_PRIO_USER,
2002 .fc_ifindex = dev->ifindex,
2003 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2004 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
2005 .fc_nlinfo.portid = 0,
2006 .fc_nlinfo.nlh = NULL,
2007 .fc_nlinfo.nl_net = dev_net(dev),
2010 cfg.fc_gateway = *gwaddr;
2012 ip6_route_add(&cfg);
2014 return rt6_get_dflt_router(gwaddr, dev);
2017 void rt6_purge_dflt_routers(struct net *net)
2019 struct rt6_info *rt;
2020 struct fib6_table *table;
2022 /* NOTE: Keep consistent with rt6_get_dflt_router */
2023 table = fib6_get_table(net, RT6_TABLE_DFLT);
2028 read_lock_bh(&table->tb6_lock);
2029 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2030 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2031 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2033 read_unlock_bh(&table->tb6_lock);
2038 read_unlock_bh(&table->tb6_lock);
2041 static void rtmsg_to_fib6_config(struct net *net,
2042 struct in6_rtmsg *rtmsg,
2043 struct fib6_config *cfg)
2045 memset(cfg, 0, sizeof(*cfg));
2047 cfg->fc_table = RT6_TABLE_MAIN;
2048 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2049 cfg->fc_metric = rtmsg->rtmsg_metric;
2050 cfg->fc_expires = rtmsg->rtmsg_info;
2051 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2052 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2053 cfg->fc_flags = rtmsg->rtmsg_flags;
2055 cfg->fc_nlinfo.nl_net = net;
2057 cfg->fc_dst = rtmsg->rtmsg_dst;
2058 cfg->fc_src = rtmsg->rtmsg_src;
2059 cfg->fc_gateway = rtmsg->rtmsg_gateway;
2062 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2064 struct fib6_config cfg;
2065 struct in6_rtmsg rtmsg;
2069 case SIOCADDRT: /* Add a route */
2070 case SIOCDELRT: /* Delete a route */
2071 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2073 err = copy_from_user(&rtmsg, arg,
2074 sizeof(struct in6_rtmsg));
2078 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2083 err = ip6_route_add(&cfg);
2086 err = ip6_route_del(&cfg);
2100 * Drop the packet on the floor
2103 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2106 struct dst_entry *dst = skb_dst(skb);
2107 switch (ipstats_mib_noroutes) {
2108 case IPSTATS_MIB_INNOROUTES:
2109 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2110 if (type == IPV6_ADDR_ANY) {
2111 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2112 IPSTATS_MIB_INADDRERRORS);
2116 case IPSTATS_MIB_OUTNOROUTES:
2117 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2118 ipstats_mib_noroutes);
2121 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2126 static int ip6_pkt_discard(struct sk_buff *skb)
2128 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2131 static int ip6_pkt_discard_out(struct sk_buff *skb)
2133 skb->dev = skb_dst(skb)->dev;
2134 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2137 static int ip6_pkt_prohibit(struct sk_buff *skb)
2139 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2142 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2144 skb->dev = skb_dst(skb)->dev;
2145 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2149 * Allocate a dst for local (unicast / anycast) address.
2152 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2153 const struct in6_addr *addr,
2156 struct net *net = dev_net(idev->dev);
2157 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2160 return ERR_PTR(-ENOMEM);
2164 rt->dst.flags |= DST_HOST;
2165 rt->dst.input = ip6_input;
2166 rt->dst.output = ip6_output;
2167 rt->rt6i_idev = idev;
2169 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2171 rt->rt6i_flags |= RTF_ANYCAST;
2173 rt->rt6i_flags |= RTF_LOCAL;
2175 rt->rt6i_gateway = *addr;
2176 rt->rt6i_dst.addr = *addr;
2177 rt->rt6i_dst.plen = 128;
2178 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2180 atomic_set(&rt->dst.__refcnt, 1);
2185 int ip6_route_get_saddr(struct net *net,
2186 struct rt6_info *rt,
2187 const struct in6_addr *daddr,
2189 struct in6_addr *saddr)
2191 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2193 if (rt->rt6i_prefsrc.plen)
2194 *saddr = rt->rt6i_prefsrc.addr;
2196 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2197 daddr, prefs, saddr);
2201 /* remove deleted ip from prefsrc entries */
2202 struct arg_dev_net_ip {
2203 struct net_device *dev;
2205 struct in6_addr *addr;
2208 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2210 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2211 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2212 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2214 if (((void *)rt->dst.dev == dev || !dev) &&
2215 rt != net->ipv6.ip6_null_entry &&
2216 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2217 /* remove prefsrc entry */
2218 rt->rt6i_prefsrc.plen = 0;
2223 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2225 struct net *net = dev_net(ifp->idev->dev);
2226 struct arg_dev_net_ip adni = {
2227 .dev = ifp->idev->dev,
2231 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2234 struct arg_dev_net {
2235 struct net_device *dev;
2239 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2241 const struct arg_dev_net *adn = arg;
2242 const struct net_device *dev = adn->dev;
2244 if ((rt->dst.dev == dev || !dev) &&
2245 rt != adn->net->ipv6.ip6_null_entry)
2251 void rt6_ifdown(struct net *net, struct net_device *dev)
2253 struct arg_dev_net adn = {
2258 fib6_clean_all(net, fib6_ifdown, &adn);
2259 icmp6_clean_all(fib6_ifdown, &adn);
2262 struct rt6_mtu_change_arg {
2263 struct net_device *dev;
2267 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2269 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2270 struct inet6_dev *idev;
2272 /* In IPv6 pmtu discovery is not optional,
2273 so that RTAX_MTU lock cannot disable it.
2274 We still use this lock to block changes
2275 caused by addrconf/ndisc.
2278 idev = __in6_dev_get(arg->dev);
2282 /* For administrative MTU increase, there is no way to discover
2283 IPv6 PMTU increase, so PMTU increase should be updated here.
2284 Since RFC 1981 doesn't include administrative MTU increase
2285 update PMTU increase is a MUST. (i.e. jumbo frame)
2288 If new MTU is less than route PMTU, this new MTU will be the
2289 lowest MTU in the path, update the route PMTU to reflect PMTU
2290 decreases; if new MTU is greater than route PMTU, and the
2291 old MTU is the lowest MTU in the path, update the route PMTU
2292 to reflect the increase. In this case if the other nodes' MTU
2293 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2296 if (rt->dst.dev == arg->dev &&
2297 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2298 (dst_mtu(&rt->dst) >= arg->mtu ||
2299 (dst_mtu(&rt->dst) < arg->mtu &&
2300 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2301 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2306 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2308 struct rt6_mtu_change_arg arg = {
2313 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2316 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2317 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2318 [RTA_OIF] = { .type = NLA_U32 },
2319 [RTA_IIF] = { .type = NLA_U32 },
2320 [RTA_PRIORITY] = { .type = NLA_U32 },
2321 [RTA_METRICS] = { .type = NLA_NESTED },
2322 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2325 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2326 struct fib6_config *cfg)
2329 struct nlattr *tb[RTA_MAX+1];
2332 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2337 rtm = nlmsg_data(nlh);
2338 memset(cfg, 0, sizeof(*cfg));
2340 cfg->fc_table = rtm->rtm_table;
2341 cfg->fc_dst_len = rtm->rtm_dst_len;
2342 cfg->fc_src_len = rtm->rtm_src_len;
2343 cfg->fc_flags = RTF_UP;
2344 cfg->fc_protocol = rtm->rtm_protocol;
2345 cfg->fc_type = rtm->rtm_type;
2347 if (rtm->rtm_type == RTN_UNREACHABLE ||
2348 rtm->rtm_type == RTN_BLACKHOLE ||
2349 rtm->rtm_type == RTN_PROHIBIT ||
2350 rtm->rtm_type == RTN_THROW)
2351 cfg->fc_flags |= RTF_REJECT;
2353 if (rtm->rtm_type == RTN_LOCAL)
2354 cfg->fc_flags |= RTF_LOCAL;
2356 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2357 cfg->fc_nlinfo.nlh = nlh;
2358 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2360 if (tb[RTA_GATEWAY]) {
2361 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2362 cfg->fc_flags |= RTF_GATEWAY;
2366 int plen = (rtm->rtm_dst_len + 7) >> 3;
2368 if (nla_len(tb[RTA_DST]) < plen)
2371 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2375 int plen = (rtm->rtm_src_len + 7) >> 3;
2377 if (nla_len(tb[RTA_SRC]) < plen)
2380 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2383 if (tb[RTA_PREFSRC])
2384 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2387 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2389 if (tb[RTA_PRIORITY])
2390 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2392 if (tb[RTA_METRICS]) {
2393 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2394 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2398 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2400 if (tb[RTA_MULTIPATH]) {
2401 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2402 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2410 static int ip6_route_multipath(struct fib6_config *cfg, int add)
2412 struct fib6_config r_cfg;
2413 struct rtnexthop *rtnh;
2416 int err = 0, last_err = 0;
2419 rtnh = (struct rtnexthop *)cfg->fc_mp;
2420 remaining = cfg->fc_mp_len;
2422 /* Parse a Multipath Entry */
2423 while (rtnh_ok(rtnh, remaining)) {
2424 memcpy(&r_cfg, cfg, sizeof(*cfg));
2425 if (rtnh->rtnh_ifindex)
2426 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2428 attrlen = rtnh_attrlen(rtnh);
2430 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2432 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2434 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2435 r_cfg.fc_flags |= RTF_GATEWAY;
2438 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2441 /* If we are trying to remove a route, do not stop the
2442 * loop when ip6_route_del() fails (because next hop is
2443 * already gone), we should try to remove all next hops.
2446 /* If add fails, we should try to delete all
2447 * next hops that have been already added.
2453 /* Because each route is added like a single route we remove
2454 * this flag after the first nexthop (if there is a collision,
2455 * we have already fail to add the first nexthop:
2456 * fib6_add_rt2node() has reject it).
2458 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
2459 rtnh = rtnh_next(rtnh, &remaining);
2465 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh)
2467 struct fib6_config cfg;
2470 err = rtm_to_fib6_config(skb, nlh, &cfg);
2475 return ip6_route_multipath(&cfg, 0);
2477 return ip6_route_del(&cfg);
2480 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh)
2482 struct fib6_config cfg;
2485 err = rtm_to_fib6_config(skb, nlh, &cfg);
2490 return ip6_route_multipath(&cfg, 1);
2492 return ip6_route_add(&cfg);
2495 static inline size_t rt6_nlmsg_size(void)
2497 return NLMSG_ALIGN(sizeof(struct rtmsg))
2498 + nla_total_size(16) /* RTA_SRC */
2499 + nla_total_size(16) /* RTA_DST */
2500 + nla_total_size(16) /* RTA_GATEWAY */
2501 + nla_total_size(16) /* RTA_PREFSRC */
2502 + nla_total_size(4) /* RTA_TABLE */
2503 + nla_total_size(4) /* RTA_IIF */
2504 + nla_total_size(4) /* RTA_OIF */
2505 + nla_total_size(4) /* RTA_PRIORITY */
2506 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2507 + nla_total_size(sizeof(struct rta_cacheinfo));
2510 static int rt6_fill_node(struct net *net,
2511 struct sk_buff *skb, struct rt6_info *rt,
2512 struct in6_addr *dst, struct in6_addr *src,
2513 int iif, int type, u32 portid, u32 seq,
2514 int prefix, int nowait, unsigned int flags)
2517 struct nlmsghdr *nlh;
2521 if (prefix) { /* user wants prefix routes only */
2522 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2523 /* success since this is not a prefix route */
2528 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2532 rtm = nlmsg_data(nlh);
2533 rtm->rtm_family = AF_INET6;
2534 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2535 rtm->rtm_src_len = rt->rt6i_src.plen;
2538 table = rt->rt6i_table->tb6_id;
2540 table = RT6_TABLE_UNSPEC;
2541 rtm->rtm_table = table;
2542 if (nla_put_u32(skb, RTA_TABLE, table))
2543 goto nla_put_failure;
2544 if (rt->rt6i_flags & RTF_REJECT) {
2545 switch (rt->dst.error) {
2547 rtm->rtm_type = RTN_BLACKHOLE;
2550 rtm->rtm_type = RTN_PROHIBIT;
2553 rtm->rtm_type = RTN_THROW;
2556 rtm->rtm_type = RTN_UNREACHABLE;
2560 else if (rt->rt6i_flags & RTF_LOCAL)
2561 rtm->rtm_type = RTN_LOCAL;
2562 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2563 rtm->rtm_type = RTN_LOCAL;
2565 rtm->rtm_type = RTN_UNICAST;
2567 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2568 rtm->rtm_protocol = rt->rt6i_protocol;
2569 if (rt->rt6i_flags & RTF_DYNAMIC)
2570 rtm->rtm_protocol = RTPROT_REDIRECT;
2571 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2572 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2573 rtm->rtm_protocol = RTPROT_RA;
2575 rtm->rtm_protocol = RTPROT_KERNEL;
2578 if (rt->rt6i_flags & RTF_CACHE)
2579 rtm->rtm_flags |= RTM_F_CLONED;
2582 if (nla_put(skb, RTA_DST, 16, dst))
2583 goto nla_put_failure;
2584 rtm->rtm_dst_len = 128;
2585 } else if (rtm->rtm_dst_len)
2586 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2587 goto nla_put_failure;
2588 #ifdef CONFIG_IPV6_SUBTREES
2590 if (nla_put(skb, RTA_SRC, 16, src))
2591 goto nla_put_failure;
2592 rtm->rtm_src_len = 128;
2593 } else if (rtm->rtm_src_len &&
2594 nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2595 goto nla_put_failure;
2598 #ifdef CONFIG_IPV6_MROUTE
2599 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2600 int err = ip6mr_get_route(net, skb, rtm, nowait);
2605 goto nla_put_failure;
2607 if (err == -EMSGSIZE)
2608 goto nla_put_failure;
2613 if (nla_put_u32(skb, RTA_IIF, iif))
2614 goto nla_put_failure;
2616 struct in6_addr saddr_buf;
2617 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2618 nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2619 goto nla_put_failure;
2622 if (rt->rt6i_prefsrc.plen) {
2623 struct in6_addr saddr_buf;
2624 saddr_buf = rt->rt6i_prefsrc.addr;
2625 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2626 goto nla_put_failure;
2629 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2630 goto nla_put_failure;
2632 if (rt->rt6i_flags & RTF_GATEWAY) {
2633 if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
2634 goto nla_put_failure;
2638 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2639 goto nla_put_failure;
2640 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2641 goto nla_put_failure;
2643 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2645 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2646 goto nla_put_failure;
2648 return nlmsg_end(skb, nlh);
2651 nlmsg_cancel(skb, nlh);
2655 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2657 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2660 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2661 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2662 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2666 return rt6_fill_node(arg->net,
2667 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2668 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2669 prefix, 0, NLM_F_MULTI);
2672 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh)
2674 struct net *net = sock_net(in_skb->sk);
2675 struct nlattr *tb[RTA_MAX+1];
2676 struct rt6_info *rt;
2677 struct sk_buff *skb;
2680 int err, iif = 0, oif = 0;
2682 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2687 memset(&fl6, 0, sizeof(fl6));
2690 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2693 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2697 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2700 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2704 iif = nla_get_u32(tb[RTA_IIF]);
2707 oif = nla_get_u32(tb[RTA_OIF]);
2710 struct net_device *dev;
2713 dev = __dev_get_by_index(net, iif);
2719 fl6.flowi6_iif = iif;
2721 if (!ipv6_addr_any(&fl6.saddr))
2722 flags |= RT6_LOOKUP_F_HAS_SADDR;
2724 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2727 fl6.flowi6_oif = oif;
2729 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2732 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2739 /* Reserve room for dummy headers, this skb can pass
2740 through good chunk of routing engine.
2742 skb_reset_mac_header(skb);
2743 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2745 skb_dst_set(skb, &rt->dst);
2747 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2748 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2749 nlh->nlmsg_seq, 0, 0, 0);
2755 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2760 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2762 struct sk_buff *skb;
2763 struct net *net = info->nl_net;
2768 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2770 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2774 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2775 event, info->portid, seq, 0, 0, 0);
2777 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2778 WARN_ON(err == -EMSGSIZE);
2782 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2783 info->nlh, gfp_any());
2787 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2790 static int ip6_route_dev_notify(struct notifier_block *this,
2791 unsigned long event, void *ptr)
2793 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2794 struct net *net = dev_net(dev);
2796 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2797 net->ipv6.ip6_null_entry->dst.dev = dev;
2798 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2799 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2800 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2801 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2802 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2803 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2814 #ifdef CONFIG_PROC_FS
2816 static const struct file_operations ipv6_route_proc_fops = {
2817 .owner = THIS_MODULE,
2818 .open = ipv6_route_open,
2820 .llseek = seq_lseek,
2821 .release = seq_release_net,
2824 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2826 struct net *net = (struct net *)seq->private;
2827 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2828 net->ipv6.rt6_stats->fib_nodes,
2829 net->ipv6.rt6_stats->fib_route_nodes,
2830 net->ipv6.rt6_stats->fib_rt_alloc,
2831 net->ipv6.rt6_stats->fib_rt_entries,
2832 net->ipv6.rt6_stats->fib_rt_cache,
2833 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2834 net->ipv6.rt6_stats->fib_discarded_routes);
2839 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2841 return single_open_net(inode, file, rt6_stats_seq_show);
2844 static const struct file_operations rt6_stats_seq_fops = {
2845 .owner = THIS_MODULE,
2846 .open = rt6_stats_seq_open,
2848 .llseek = seq_lseek,
2849 .release = single_release_net,
2851 #endif /* CONFIG_PROC_FS */
2853 #ifdef CONFIG_SYSCTL
2856 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
2857 void __user *buffer, size_t *lenp, loff_t *ppos)
2864 net = (struct net *)ctl->extra1;
2865 delay = net->ipv6.sysctl.flush_delay;
2866 proc_dointvec(ctl, write, buffer, lenp, ppos);
2867 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
2871 struct ctl_table ipv6_route_table_template[] = {
2873 .procname = "flush",
2874 .data = &init_net.ipv6.sysctl.flush_delay,
2875 .maxlen = sizeof(int),
2877 .proc_handler = ipv6_sysctl_rtcache_flush
2880 .procname = "gc_thresh",
2881 .data = &ip6_dst_ops_template.gc_thresh,
2882 .maxlen = sizeof(int),
2884 .proc_handler = proc_dointvec,
2887 .procname = "max_size",
2888 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
2889 .maxlen = sizeof(int),
2891 .proc_handler = proc_dointvec,
2894 .procname = "gc_min_interval",
2895 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2896 .maxlen = sizeof(int),
2898 .proc_handler = proc_dointvec_jiffies,
2901 .procname = "gc_timeout",
2902 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2903 .maxlen = sizeof(int),
2905 .proc_handler = proc_dointvec_jiffies,
2908 .procname = "gc_interval",
2909 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2910 .maxlen = sizeof(int),
2912 .proc_handler = proc_dointvec_jiffies,
2915 .procname = "gc_elasticity",
2916 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2917 .maxlen = sizeof(int),
2919 .proc_handler = proc_dointvec,
2922 .procname = "mtu_expires",
2923 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2924 .maxlen = sizeof(int),
2926 .proc_handler = proc_dointvec_jiffies,
2929 .procname = "min_adv_mss",
2930 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2931 .maxlen = sizeof(int),
2933 .proc_handler = proc_dointvec,
2936 .procname = "gc_min_interval_ms",
2937 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2938 .maxlen = sizeof(int),
2940 .proc_handler = proc_dointvec_ms_jiffies,
2945 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2947 struct ctl_table *table;
2949 table = kmemdup(ipv6_route_table_template,
2950 sizeof(ipv6_route_table_template),
2954 table[0].data = &net->ipv6.sysctl.flush_delay;
2955 table[0].extra1 = net;
2956 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2957 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2958 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2959 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2960 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2961 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2962 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2963 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2964 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2966 /* Don't export sysctls to unprivileged users */
2967 if (net->user_ns != &init_user_ns)
2968 table[0].procname = NULL;
2975 static int __net_init ip6_route_net_init(struct net *net)
2979 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2980 sizeof(net->ipv6.ip6_dst_ops));
2982 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2983 goto out_ip6_dst_ops;
2985 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2986 sizeof(*net->ipv6.ip6_null_entry),
2988 if (!net->ipv6.ip6_null_entry)
2989 goto out_ip6_dst_entries;
2990 net->ipv6.ip6_null_entry->dst.path =
2991 (struct dst_entry *)net->ipv6.ip6_null_entry;
2992 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2993 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
2994 ip6_template_metrics, true);
2996 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2997 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2998 sizeof(*net->ipv6.ip6_prohibit_entry),
3000 if (!net->ipv6.ip6_prohibit_entry)
3001 goto out_ip6_null_entry;
3002 net->ipv6.ip6_prohibit_entry->dst.path =
3003 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3004 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3005 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3006 ip6_template_metrics, true);
3008 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3009 sizeof(*net->ipv6.ip6_blk_hole_entry),
3011 if (!net->ipv6.ip6_blk_hole_entry)
3012 goto out_ip6_prohibit_entry;
3013 net->ipv6.ip6_blk_hole_entry->dst.path =
3014 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3015 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3016 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3017 ip6_template_metrics, true);
3020 net->ipv6.sysctl.flush_delay = 0;
3021 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3022 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3023 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3024 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3025 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3026 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3027 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3029 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3035 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3036 out_ip6_prohibit_entry:
3037 kfree(net->ipv6.ip6_prohibit_entry);
3039 kfree(net->ipv6.ip6_null_entry);
3041 out_ip6_dst_entries:
3042 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3047 static void __net_exit ip6_route_net_exit(struct net *net)
3049 kfree(net->ipv6.ip6_null_entry);
3050 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3051 kfree(net->ipv6.ip6_prohibit_entry);
3052 kfree(net->ipv6.ip6_blk_hole_entry);
3054 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3057 static int __net_init ip6_route_net_init_late(struct net *net)
3059 #ifdef CONFIG_PROC_FS
3060 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3061 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3066 static void __net_exit ip6_route_net_exit_late(struct net *net)
3068 #ifdef CONFIG_PROC_FS
3069 remove_proc_entry("ipv6_route", net->proc_net);
3070 remove_proc_entry("rt6_stats", net->proc_net);
3074 static struct pernet_operations ip6_route_net_ops = {
3075 .init = ip6_route_net_init,
3076 .exit = ip6_route_net_exit,
3079 static int __net_init ipv6_inetpeer_init(struct net *net)
3081 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3085 inet_peer_base_init(bp);
3086 net->ipv6.peers = bp;
3090 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3092 struct inet_peer_base *bp = net->ipv6.peers;
3094 net->ipv6.peers = NULL;
3095 inetpeer_invalidate_tree(bp);
3099 static struct pernet_operations ipv6_inetpeer_ops = {
3100 .init = ipv6_inetpeer_init,
3101 .exit = ipv6_inetpeer_exit,
3104 static struct pernet_operations ip6_route_net_late_ops = {
3105 .init = ip6_route_net_init_late,
3106 .exit = ip6_route_net_exit_late,
3109 static struct notifier_block ip6_route_dev_notifier = {
3110 .notifier_call = ip6_route_dev_notify,
3114 int __init ip6_route_init(void)
3119 ip6_dst_ops_template.kmem_cachep =
3120 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3121 SLAB_HWCACHE_ALIGN, NULL);
3122 if (!ip6_dst_ops_template.kmem_cachep)
3125 ret = dst_entries_init(&ip6_dst_blackhole_ops);
3127 goto out_kmem_cache;
3129 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3131 goto out_dst_entries;
3133 ret = register_pernet_subsys(&ip6_route_net_ops);
3135 goto out_register_inetpeer;
3137 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3139 /* Registering of the loopback is done before this portion of code,
3140 * the loopback reference in rt6_info will not be taken, do it
3141 * manually for init_net */
3142 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3143 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3144 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3145 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3146 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3147 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3148 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3152 goto out_register_subsys;
3158 ret = fib6_rules_init();
3162 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3164 goto fib6_rules_init;
3167 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3168 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3169 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3170 goto out_register_late_subsys;
3172 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3174 goto out_register_late_subsys;
3179 out_register_late_subsys:
3180 unregister_pernet_subsys(&ip6_route_net_late_ops);
3182 fib6_rules_cleanup();
3187 out_register_subsys:
3188 unregister_pernet_subsys(&ip6_route_net_ops);
3189 out_register_inetpeer:
3190 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3192 dst_entries_destroy(&ip6_dst_blackhole_ops);
3194 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3198 void ip6_route_cleanup(void)
3200 unregister_netdevice_notifier(&ip6_route_dev_notifier);
3201 unregister_pernet_subsys(&ip6_route_net_late_ops);
3202 fib6_rules_cleanup();
3205 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3206 unregister_pernet_subsys(&ip6_route_net_ops);
3207 dst_entries_destroy(&ip6_dst_blackhole_ops);
3208 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);