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 sock *sk, struct sk_buff *skb);
88 static int ip6_pkt_prohibit(struct sk_buff *skb);
89 static int ip6_pkt_prohibit_out(struct sock *sk, 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 void rt6_dst_from_metrics_check(struct rt6_info *rt);
96 static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
98 #ifdef CONFIG_IPV6_ROUTE_INFO
99 static struct rt6_info *rt6_add_route_info(struct net *net,
100 const struct in6_addr *prefix, int prefixlen,
101 const struct in6_addr *gwaddr, int ifindex,
103 static struct rt6_info *rt6_get_route_info(struct net *net,
104 const struct in6_addr *prefix, int prefixlen,
105 const struct in6_addr *gwaddr, int ifindex);
108 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
110 struct rt6_info *rt = (struct rt6_info *)dst;
112 if (rt->rt6i_flags & RTF_CACHE)
115 return dst_cow_metrics_generic(dst, old);
118 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
122 struct in6_addr *p = &rt->rt6i_gateway;
124 if (!ipv6_addr_any(p))
125 return (const void *) p;
127 return &ipv6_hdr(skb)->daddr;
131 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
135 struct rt6_info *rt = (struct rt6_info *) dst;
138 daddr = choose_neigh_daddr(rt, skb, daddr);
139 n = __ipv6_neigh_lookup(dst->dev, daddr);
142 return neigh_create(&nd_tbl, daddr, dst->dev);
145 static struct dst_ops ip6_dst_ops_template = {
149 .check = ip6_dst_check,
150 .default_advmss = ip6_default_advmss,
152 .cow_metrics = ipv6_cow_metrics,
153 .destroy = ip6_dst_destroy,
154 .ifdown = ip6_dst_ifdown,
155 .negative_advice = ip6_negative_advice,
156 .link_failure = ip6_link_failure,
157 .update_pmtu = ip6_rt_update_pmtu,
158 .redirect = rt6_do_redirect,
159 .local_out = __ip6_local_out,
160 .neigh_lookup = ip6_neigh_lookup,
163 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
165 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
167 return mtu ? : dst->dev->mtu;
170 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
171 struct sk_buff *skb, u32 mtu)
175 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
180 static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
186 static struct dst_ops ip6_dst_blackhole_ops = {
188 .destroy = ip6_dst_destroy,
189 .check = ip6_dst_check,
190 .mtu = ip6_blackhole_mtu,
191 .default_advmss = ip6_default_advmss,
192 .update_pmtu = ip6_rt_blackhole_update_pmtu,
193 .redirect = ip6_rt_blackhole_redirect,
194 .cow_metrics = ip6_rt_blackhole_cow_metrics,
195 .neigh_lookup = ip6_neigh_lookup,
198 static const u32 ip6_template_metrics[RTAX_MAX] = {
199 [RTAX_HOPLIMIT - 1] = 0,
202 static const struct rt6_info ip6_null_entry_template = {
204 .__refcnt = ATOMIC_INIT(1),
206 .obsolete = DST_OBSOLETE_FORCE_CHK,
207 .error = -ENETUNREACH,
208 .input = ip6_pkt_discard,
209 .output = ip6_pkt_discard_out,
211 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
212 .rt6i_protocol = RTPROT_KERNEL,
213 .rt6i_metric = ~(u32) 0,
214 .rt6i_ref = ATOMIC_INIT(1),
217 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
219 static const struct rt6_info ip6_prohibit_entry_template = {
221 .__refcnt = ATOMIC_INIT(1),
223 .obsolete = DST_OBSOLETE_FORCE_CHK,
225 .input = ip6_pkt_prohibit,
226 .output = ip6_pkt_prohibit_out,
228 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
229 .rt6i_protocol = RTPROT_KERNEL,
230 .rt6i_metric = ~(u32) 0,
231 .rt6i_ref = ATOMIC_INIT(1),
234 static const struct rt6_info ip6_blk_hole_entry_template = {
236 .__refcnt = ATOMIC_INIT(1),
238 .obsolete = DST_OBSOLETE_FORCE_CHK,
240 .input = dst_discard,
241 .output = dst_discard_sk,
243 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
244 .rt6i_protocol = RTPROT_KERNEL,
245 .rt6i_metric = ~(u32) 0,
246 .rt6i_ref = ATOMIC_INIT(1),
251 /* allocate dst with ip6_dst_ops */
252 static inline struct rt6_info *ip6_dst_alloc(struct net *net,
253 struct net_device *dev,
255 struct fib6_table *table)
257 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
258 0, DST_OBSOLETE_FORCE_CHK, flags);
261 struct dst_entry *dst = &rt->dst;
263 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
264 INIT_LIST_HEAD(&rt->rt6i_siblings);
269 static void ip6_dst_destroy(struct dst_entry *dst)
271 struct rt6_info *rt = (struct rt6_info *)dst;
272 struct inet6_dev *idev = rt->rt6i_idev;
273 struct dst_entry *from = dst->from;
275 dst_destroy_metrics_generic(dst);
278 rt->rt6i_idev = NULL;
286 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
289 struct rt6_info *rt = (struct rt6_info *)dst;
290 struct inet6_dev *idev = rt->rt6i_idev;
291 struct net_device *loopback_dev =
292 dev_net(dev)->loopback_dev;
294 if (dev != loopback_dev) {
295 if (idev && idev->dev == dev) {
296 struct inet6_dev *loopback_idev =
297 in6_dev_get(loopback_dev);
299 rt->rt6i_idev = loopback_idev;
306 static bool rt6_check_expired(const struct rt6_info *rt)
308 if (rt->rt6i_flags & RTF_EXPIRES) {
309 if (time_after(jiffies, rt->dst.expires))
311 } else if (rt->dst.from) {
312 return rt6_check_expired((struct rt6_info *) rt->dst.from);
317 /* Multipath route selection:
318 * Hash based function using packet header and flowlabel.
319 * Adapted from fib_info_hashfn()
321 static int rt6_info_hash_nhsfn(unsigned int candidate_count,
322 const struct flowi6 *fl6)
324 unsigned int val = fl6->flowi6_proto;
326 val ^= ipv6_addr_hash(&fl6->daddr);
327 val ^= ipv6_addr_hash(&fl6->saddr);
329 /* Work only if this not encapsulated */
330 switch (fl6->flowi6_proto) {
334 val ^= (__force u16)fl6->fl6_sport;
335 val ^= (__force u16)fl6->fl6_dport;
339 val ^= (__force u16)fl6->fl6_icmp_type;
340 val ^= (__force u16)fl6->fl6_icmp_code;
343 /* RFC6438 recommands to use flowlabel */
344 val ^= (__force u32)fl6->flowlabel;
346 /* Perhaps, we need to tune, this function? */
347 val = val ^ (val >> 7) ^ (val >> 12);
348 return val % candidate_count;
351 static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
352 struct flowi6 *fl6, int oif,
355 struct rt6_info *sibling, *next_sibling;
358 route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
359 /* Don't change the route, if route_choosen == 0
360 * (siblings does not include ourself)
363 list_for_each_entry_safe(sibling, next_sibling,
364 &match->rt6i_siblings, rt6i_siblings) {
366 if (route_choosen == 0) {
367 if (rt6_score_route(sibling, oif, strict) < 0)
377 * Route lookup. Any table->tb6_lock is implied.
380 static inline struct rt6_info *rt6_device_match(struct net *net,
382 const struct in6_addr *saddr,
386 struct rt6_info *local = NULL;
387 struct rt6_info *sprt;
389 if (!oif && ipv6_addr_any(saddr))
392 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
393 struct net_device *dev = sprt->dst.dev;
396 if (dev->ifindex == oif)
398 if (dev->flags & IFF_LOOPBACK) {
399 if (!sprt->rt6i_idev ||
400 sprt->rt6i_idev->dev->ifindex != oif) {
401 if (flags & RT6_LOOKUP_F_IFACE && oif)
403 if (local && (!oif ||
404 local->rt6i_idev->dev->ifindex == oif))
410 if (ipv6_chk_addr(net, saddr, dev,
411 flags & RT6_LOOKUP_F_IFACE))
420 if (flags & RT6_LOOKUP_F_IFACE)
421 return net->ipv6.ip6_null_entry;
427 #ifdef CONFIG_IPV6_ROUTER_PREF
428 struct __rt6_probe_work {
429 struct work_struct work;
430 struct in6_addr target;
431 struct net_device *dev;
434 static void rt6_probe_deferred(struct work_struct *w)
436 struct in6_addr mcaddr;
437 struct __rt6_probe_work *work =
438 container_of(w, struct __rt6_probe_work, work);
440 addrconf_addr_solict_mult(&work->target, &mcaddr);
441 ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);
446 static void rt6_probe(struct rt6_info *rt)
448 struct neighbour *neigh;
450 * Okay, this does not seem to be appropriate
451 * for now, however, we need to check if it
452 * is really so; aka Router Reachability Probing.
454 * Router Reachability Probe MUST be rate-limited
455 * to no more than one per minute.
457 if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
460 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
462 write_lock(&neigh->lock);
463 if (neigh->nud_state & NUD_VALID)
468 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
469 struct __rt6_probe_work *work;
471 work = kmalloc(sizeof(*work), GFP_ATOMIC);
474 __neigh_set_probe_once(neigh);
477 write_unlock(&neigh->lock);
480 INIT_WORK(&work->work, rt6_probe_deferred);
481 work->target = rt->rt6i_gateway;
482 dev_hold(rt->dst.dev);
483 work->dev = rt->dst.dev;
484 schedule_work(&work->work);
488 write_unlock(&neigh->lock);
490 rcu_read_unlock_bh();
493 static inline void rt6_probe(struct rt6_info *rt)
499 * Default Router Selection (RFC 2461 6.3.6)
501 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
503 struct net_device *dev = rt->dst.dev;
504 if (!oif || dev->ifindex == oif)
506 if ((dev->flags & IFF_LOOPBACK) &&
507 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
512 static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
514 struct neighbour *neigh;
515 enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
517 if (rt->rt6i_flags & RTF_NONEXTHOP ||
518 !(rt->rt6i_flags & RTF_GATEWAY))
519 return RT6_NUD_SUCCEED;
522 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
524 read_lock(&neigh->lock);
525 if (neigh->nud_state & NUD_VALID)
526 ret = RT6_NUD_SUCCEED;
527 #ifdef CONFIG_IPV6_ROUTER_PREF
528 else if (!(neigh->nud_state & NUD_FAILED))
529 ret = RT6_NUD_SUCCEED;
531 ret = RT6_NUD_FAIL_PROBE;
533 read_unlock(&neigh->lock);
535 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
536 RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
538 rcu_read_unlock_bh();
543 static int rt6_score_route(struct rt6_info *rt, int oif,
548 m = rt6_check_dev(rt, oif);
549 if (!m && (strict & RT6_LOOKUP_F_IFACE))
550 return RT6_NUD_FAIL_HARD;
551 #ifdef CONFIG_IPV6_ROUTER_PREF
552 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
554 if (strict & RT6_LOOKUP_F_REACHABLE) {
555 int n = rt6_check_neigh(rt);
562 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
563 int *mpri, struct rt6_info *match,
567 bool match_do_rr = false;
569 if (rt6_check_expired(rt))
572 m = rt6_score_route(rt, oif, strict);
573 if (m == RT6_NUD_FAIL_DO_RR) {
575 m = 0; /* lowest valid score */
576 } else if (m == RT6_NUD_FAIL_HARD) {
580 if (strict & RT6_LOOKUP_F_REACHABLE)
583 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
585 *do_rr = match_do_rr;
593 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
594 struct rt6_info *rr_head,
595 u32 metric, int oif, int strict,
598 struct rt6_info *rt, *match, *cont;
603 for (rt = rr_head; rt; rt = rt->dst.rt6_next) {
604 if (rt->rt6i_metric != metric) {
609 match = find_match(rt, oif, strict, &mpri, match, do_rr);
612 for (rt = fn->leaf; rt && rt != rr_head; rt = rt->dst.rt6_next) {
613 if (rt->rt6i_metric != metric) {
618 match = find_match(rt, oif, strict, &mpri, match, do_rr);
624 for (rt = cont; rt; rt = rt->dst.rt6_next)
625 match = find_match(rt, oif, strict, &mpri, match, do_rr);
630 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
632 struct rt6_info *match, *rt0;
638 fn->rr_ptr = rt0 = fn->leaf;
640 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
644 struct rt6_info *next = rt0->dst.rt6_next;
646 /* no entries matched; do round-robin */
647 if (!next || next->rt6i_metric != rt0->rt6i_metric)
654 net = dev_net(rt0->dst.dev);
655 return match ? match : net->ipv6.ip6_null_entry;
658 #ifdef CONFIG_IPV6_ROUTE_INFO
659 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
660 const struct in6_addr *gwaddr)
662 struct net *net = dev_net(dev);
663 struct route_info *rinfo = (struct route_info *) opt;
664 struct in6_addr prefix_buf, *prefix;
666 unsigned long lifetime;
669 if (len < sizeof(struct route_info)) {
673 /* Sanity check for prefix_len and length */
674 if (rinfo->length > 3) {
676 } else if (rinfo->prefix_len > 128) {
678 } else if (rinfo->prefix_len > 64) {
679 if (rinfo->length < 2) {
682 } else if (rinfo->prefix_len > 0) {
683 if (rinfo->length < 1) {
688 pref = rinfo->route_pref;
689 if (pref == ICMPV6_ROUTER_PREF_INVALID)
692 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
694 if (rinfo->length == 3)
695 prefix = (struct in6_addr *)rinfo->prefix;
697 /* this function is safe */
698 ipv6_addr_prefix(&prefix_buf,
699 (struct in6_addr *)rinfo->prefix,
701 prefix = &prefix_buf;
704 if (rinfo->prefix_len == 0)
705 rt = rt6_get_dflt_router(gwaddr, dev);
707 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
708 gwaddr, dev->ifindex);
710 if (rt && !lifetime) {
716 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
719 rt->rt6i_flags = RTF_ROUTEINFO |
720 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
723 if (!addrconf_finite_timeout(lifetime))
724 rt6_clean_expires(rt);
726 rt6_set_expires(rt, jiffies + HZ * lifetime);
734 static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
735 struct in6_addr *saddr)
737 struct fib6_node *pn;
739 if (fn->fn_flags & RTN_TL_ROOT)
742 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
743 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
746 if (fn->fn_flags & RTN_RTINFO)
751 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
752 struct fib6_table *table,
753 struct flowi6 *fl6, int flags)
755 struct fib6_node *fn;
758 read_lock_bh(&table->tb6_lock);
759 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
762 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
763 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
764 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
765 if (rt == net->ipv6.ip6_null_entry) {
766 fn = fib6_backtrack(fn, &fl6->saddr);
770 dst_use(&rt->dst, jiffies);
771 read_unlock_bh(&table->tb6_lock);
776 struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
779 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
781 EXPORT_SYMBOL_GPL(ip6_route_lookup);
783 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
784 const struct in6_addr *saddr, int oif, int strict)
786 struct flowi6 fl6 = {
790 struct dst_entry *dst;
791 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
794 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
795 flags |= RT6_LOOKUP_F_HAS_SADDR;
798 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
800 return (struct rt6_info *) dst;
806 EXPORT_SYMBOL(rt6_lookup);
808 /* ip6_ins_rt is called with FREE table->tb6_lock.
809 It takes new route entry, the addition fails by any reason the
810 route is freed. In any case, if caller does not hold it, it may
814 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
815 struct mx6_config *mxc)
818 struct fib6_table *table;
820 table = rt->rt6i_table;
821 write_lock_bh(&table->tb6_lock);
822 err = fib6_add(&table->tb6_root, rt, info, mxc);
823 write_unlock_bh(&table->tb6_lock);
828 int ip6_ins_rt(struct rt6_info *rt)
830 struct nl_info info = { .nl_net = dev_net(rt->dst.dev), };
831 struct mx6_config mxc = { .mx = NULL, };
833 return __ip6_ins_rt(rt, &info, &mxc);
836 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
837 const struct in6_addr *daddr,
838 const struct in6_addr *saddr)
846 rt = ip6_rt_copy(ort, daddr);
849 if (ort->rt6i_dst.plen != 128 &&
850 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
851 rt->rt6i_flags |= RTF_ANYCAST;
853 rt->rt6i_flags |= RTF_CACHE;
855 #ifdef CONFIG_IPV6_SUBTREES
856 if (rt->rt6i_src.plen && saddr) {
857 rt->rt6i_src.addr = *saddr;
858 rt->rt6i_src.plen = 128;
866 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
867 const struct in6_addr *daddr)
869 struct rt6_info *rt = ip6_rt_copy(ort, daddr);
872 rt->rt6i_flags |= RTF_CACHE;
876 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
877 struct flowi6 *fl6, int flags)
879 struct fib6_node *fn, *saved_fn;
880 struct rt6_info *rt, *nrt;
885 strict |= flags & RT6_LOOKUP_F_IFACE;
886 if (net->ipv6.devconf_all->forwarding == 0)
887 strict |= RT6_LOOKUP_F_REACHABLE;
889 redo_fib6_lookup_lock:
890 read_lock_bh(&table->tb6_lock);
892 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
896 rt = rt6_select(fn, oif, strict);
897 if (rt->rt6i_nsiblings)
898 rt = rt6_multipath_select(rt, fl6, oif, strict);
899 if (rt == net->ipv6.ip6_null_entry) {
900 fn = fib6_backtrack(fn, &fl6->saddr);
902 goto redo_rt6_select;
903 else if (strict & RT6_LOOKUP_F_REACHABLE) {
904 /* also consider unreachable route */
905 strict &= ~RT6_LOOKUP_F_REACHABLE;
907 goto redo_rt6_select;
910 read_unlock_bh(&table->tb6_lock);
916 read_unlock_bh(&table->tb6_lock);
918 if (rt->rt6i_flags & RTF_CACHE)
921 if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
922 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
923 else if (!(rt->dst.flags & DST_HOST) || !(rt->rt6i_flags & RTF_LOCAL))
924 nrt = rt6_alloc_clone(rt, &fl6->daddr);
929 rt = nrt ? : net->ipv6.ip6_null_entry;
933 err = ip6_ins_rt(nrt);
942 * Race condition! In the gap, when table->tb6_lock was
943 * released someone could insert this route. Relookup.
946 goto redo_fib6_lookup_lock;
949 rt6_dst_from_metrics_check(rt);
950 rt->dst.lastuse = jiffies;
956 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
957 struct flowi6 *fl6, int flags)
959 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
962 static struct dst_entry *ip6_route_input_lookup(struct net *net,
963 struct net_device *dev,
964 struct flowi6 *fl6, int flags)
966 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
967 flags |= RT6_LOOKUP_F_IFACE;
969 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
972 void ip6_route_input(struct sk_buff *skb)
974 const struct ipv6hdr *iph = ipv6_hdr(skb);
975 struct net *net = dev_net(skb->dev);
976 int flags = RT6_LOOKUP_F_HAS_SADDR;
977 struct flowi6 fl6 = {
978 .flowi6_iif = skb->dev->ifindex,
981 .flowlabel = ip6_flowinfo(iph),
982 .flowi6_mark = skb->mark,
983 .flowi6_proto = iph->nexthdr,
986 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
989 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
990 struct flowi6 *fl6, int flags)
992 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
995 struct dst_entry *ip6_route_output(struct net *net, const struct sock *sk,
1000 fl6->flowi6_iif = LOOPBACK_IFINDEX;
1002 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
1003 flags |= RT6_LOOKUP_F_IFACE;
1005 if (!ipv6_addr_any(&fl6->saddr))
1006 flags |= RT6_LOOKUP_F_HAS_SADDR;
1008 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1010 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1012 EXPORT_SYMBOL(ip6_route_output);
1014 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1016 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1017 struct dst_entry *new = NULL;
1019 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1023 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1026 new->input = dst_discard;
1027 new->output = dst_discard_sk;
1029 if (dst_metrics_read_only(&ort->dst))
1030 new->_metrics = ort->dst._metrics;
1032 dst_copy_metrics(new, &ort->dst);
1033 rt->rt6i_idev = ort->rt6i_idev;
1035 in6_dev_hold(rt->rt6i_idev);
1037 rt->rt6i_gateway = ort->rt6i_gateway;
1038 rt->rt6i_flags = ort->rt6i_flags;
1039 rt->rt6i_metric = 0;
1041 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1042 #ifdef CONFIG_IPV6_SUBTREES
1043 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1049 dst_release(dst_orig);
1050 return new ? new : ERR_PTR(-ENOMEM);
1054 * Destination cache support functions
1057 static void rt6_dst_from_metrics_check(struct rt6_info *rt)
1060 dst_metrics_ptr(&rt->dst) != dst_metrics_ptr(rt->dst.from))
1061 dst_init_metrics(&rt->dst, dst_metrics_ptr(rt->dst.from), true);
1064 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1066 struct rt6_info *rt;
1068 rt = (struct rt6_info *) dst;
1070 /* All IPV6 dsts are created with ->obsolete set to the value
1071 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1072 * into this function always.
1074 if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
1077 if (rt6_check_expired(rt))
1080 rt6_dst_from_metrics_check(rt);
1085 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1087 struct rt6_info *rt = (struct rt6_info *) dst;
1090 if (rt->rt6i_flags & RTF_CACHE) {
1091 if (rt6_check_expired(rt)) {
1103 static void ip6_link_failure(struct sk_buff *skb)
1105 struct rt6_info *rt;
1107 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1109 rt = (struct rt6_info *) skb_dst(skb);
1111 if (rt->rt6i_flags & RTF_CACHE) {
1115 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
1116 rt->rt6i_node->fn_sernum = -1;
1121 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1122 struct sk_buff *skb, u32 mtu)
1124 struct rt6_info *rt6 = (struct rt6_info *)dst;
1127 if (mtu < dst_mtu(dst) && (rt6->rt6i_flags & RTF_CACHE)) {
1128 struct net *net = dev_net(dst->dev);
1130 rt6->rt6i_flags |= RTF_MODIFIED;
1131 if (mtu < IPV6_MIN_MTU)
1134 rt6->rt6i_pmtu = mtu;
1135 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1139 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1142 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1143 struct dst_entry *dst;
1146 memset(&fl6, 0, sizeof(fl6));
1147 fl6.flowi6_oif = oif;
1148 fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
1149 fl6.daddr = iph->daddr;
1150 fl6.saddr = iph->saddr;
1151 fl6.flowlabel = ip6_flowinfo(iph);
1153 dst = ip6_route_output(net, NULL, &fl6);
1155 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
1158 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1160 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1162 ip6_update_pmtu(skb, sock_net(sk), mtu,
1163 sk->sk_bound_dev_if, sk->sk_mark);
1165 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1167 /* Handle redirects */
1168 struct ip6rd_flowi {
1170 struct in6_addr gateway;
1173 static struct rt6_info *__ip6_route_redirect(struct net *net,
1174 struct fib6_table *table,
1178 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1179 struct rt6_info *rt;
1180 struct fib6_node *fn;
1182 /* Get the "current" route for this destination and
1183 * check if the redirect has come from approriate router.
1185 * RFC 4861 specifies that redirects should only be
1186 * accepted if they come from the nexthop to the target.
1187 * Due to the way the routes are chosen, this notion
1188 * is a bit fuzzy and one might need to check all possible
1192 read_lock_bh(&table->tb6_lock);
1193 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1195 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1196 if (rt6_check_expired(rt))
1200 if (!(rt->rt6i_flags & RTF_GATEWAY))
1202 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1204 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1210 rt = net->ipv6.ip6_null_entry;
1211 else if (rt->dst.error) {
1212 rt = net->ipv6.ip6_null_entry;
1216 if (rt == net->ipv6.ip6_null_entry) {
1217 fn = fib6_backtrack(fn, &fl6->saddr);
1225 read_unlock_bh(&table->tb6_lock);
1230 static struct dst_entry *ip6_route_redirect(struct net *net,
1231 const struct flowi6 *fl6,
1232 const struct in6_addr *gateway)
1234 int flags = RT6_LOOKUP_F_HAS_SADDR;
1235 struct ip6rd_flowi rdfl;
1238 rdfl.gateway = *gateway;
1240 return fib6_rule_lookup(net, &rdfl.fl6,
1241 flags, __ip6_route_redirect);
1244 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1246 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1247 struct dst_entry *dst;
1250 memset(&fl6, 0, sizeof(fl6));
1251 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1252 fl6.flowi6_oif = oif;
1253 fl6.flowi6_mark = mark;
1254 fl6.daddr = iph->daddr;
1255 fl6.saddr = iph->saddr;
1256 fl6.flowlabel = ip6_flowinfo(iph);
1258 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1259 rt6_do_redirect(dst, NULL, skb);
1262 EXPORT_SYMBOL_GPL(ip6_redirect);
1264 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1267 const struct ipv6hdr *iph = ipv6_hdr(skb);
1268 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1269 struct dst_entry *dst;
1272 memset(&fl6, 0, sizeof(fl6));
1273 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1274 fl6.flowi6_oif = oif;
1275 fl6.flowi6_mark = mark;
1276 fl6.daddr = msg->dest;
1277 fl6.saddr = iph->daddr;
1279 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1280 rt6_do_redirect(dst, NULL, skb);
1284 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1286 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1288 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1290 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1292 struct net_device *dev = dst->dev;
1293 unsigned int mtu = dst_mtu(dst);
1294 struct net *net = dev_net(dev);
1296 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1298 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1299 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1302 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1303 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1304 * IPV6_MAXPLEN is also valid and means: "any MSS,
1305 * rely only on pmtu discovery"
1307 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1312 static unsigned int ip6_mtu(const struct dst_entry *dst)
1314 const struct rt6_info *rt = (const struct rt6_info *)dst;
1315 unsigned int mtu = rt->rt6i_pmtu;
1316 struct inet6_dev *idev;
1321 mtu = dst_metric_raw(dst, RTAX_MTU);
1328 idev = __in6_dev_get(dst->dev);
1330 mtu = idev->cnf.mtu6;
1334 return min_t(unsigned int, mtu, IP6_MAX_MTU);
1337 static struct dst_entry *icmp6_dst_gc_list;
1338 static DEFINE_SPINLOCK(icmp6_dst_lock);
1340 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1343 struct dst_entry *dst;
1344 struct rt6_info *rt;
1345 struct inet6_dev *idev = in6_dev_get(dev);
1346 struct net *net = dev_net(dev);
1348 if (unlikely(!idev))
1349 return ERR_PTR(-ENODEV);
1351 rt = ip6_dst_alloc(net, dev, 0, NULL);
1352 if (unlikely(!rt)) {
1354 dst = ERR_PTR(-ENOMEM);
1358 rt->dst.flags |= DST_HOST;
1359 rt->dst.output = ip6_output;
1360 atomic_set(&rt->dst.__refcnt, 1);
1361 rt->rt6i_gateway = fl6->daddr;
1362 rt->rt6i_dst.addr = fl6->daddr;
1363 rt->rt6i_dst.plen = 128;
1364 rt->rt6i_idev = idev;
1365 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1367 spin_lock_bh(&icmp6_dst_lock);
1368 rt->dst.next = icmp6_dst_gc_list;
1369 icmp6_dst_gc_list = &rt->dst;
1370 spin_unlock_bh(&icmp6_dst_lock);
1372 fib6_force_start_gc(net);
1374 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1380 int icmp6_dst_gc(void)
1382 struct dst_entry *dst, **pprev;
1385 spin_lock_bh(&icmp6_dst_lock);
1386 pprev = &icmp6_dst_gc_list;
1388 while ((dst = *pprev) != NULL) {
1389 if (!atomic_read(&dst->__refcnt)) {
1398 spin_unlock_bh(&icmp6_dst_lock);
1403 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1406 struct dst_entry *dst, **pprev;
1408 spin_lock_bh(&icmp6_dst_lock);
1409 pprev = &icmp6_dst_gc_list;
1410 while ((dst = *pprev) != NULL) {
1411 struct rt6_info *rt = (struct rt6_info *) dst;
1412 if (func(rt, arg)) {
1419 spin_unlock_bh(&icmp6_dst_lock);
1422 static int ip6_dst_gc(struct dst_ops *ops)
1424 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1425 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1426 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1427 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1428 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1429 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1432 entries = dst_entries_get_fast(ops);
1433 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1434 entries <= rt_max_size)
1437 net->ipv6.ip6_rt_gc_expire++;
1438 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
1439 entries = dst_entries_get_slow(ops);
1440 if (entries < ops->gc_thresh)
1441 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1443 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1444 return entries > rt_max_size;
1447 static int ip6_convert_metrics(struct mx6_config *mxc,
1448 const struct fib6_config *cfg)
1457 mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1461 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1462 int type = nla_type(nla);
1467 if (unlikely(type > RTAX_MAX))
1469 if (type == RTAX_CC_ALGO) {
1470 char tmp[TCP_CA_NAME_MAX];
1472 nla_strlcpy(tmp, nla, sizeof(tmp));
1473 val = tcp_ca_get_key_by_name(tmp);
1474 if (val == TCP_CA_UNSPEC)
1477 val = nla_get_u32(nla);
1481 __set_bit(type - 1, mxc->mx_valid);
1493 int ip6_route_add(struct fib6_config *cfg)
1496 struct net *net = cfg->fc_nlinfo.nl_net;
1497 struct rt6_info *rt = NULL;
1498 struct net_device *dev = NULL;
1499 struct inet6_dev *idev = NULL;
1500 struct fib6_table *table;
1501 struct mx6_config mxc = { .mx = NULL, };
1504 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1506 #ifndef CONFIG_IPV6_SUBTREES
1507 if (cfg->fc_src_len)
1510 if (cfg->fc_ifindex) {
1512 dev = dev_get_by_index(net, cfg->fc_ifindex);
1515 idev = in6_dev_get(dev);
1520 if (cfg->fc_metric == 0)
1521 cfg->fc_metric = IP6_RT_PRIO_USER;
1524 if (cfg->fc_nlinfo.nlh &&
1525 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1526 table = fib6_get_table(net, cfg->fc_table);
1528 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1529 table = fib6_new_table(net, cfg->fc_table);
1532 table = fib6_new_table(net, cfg->fc_table);
1538 rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);
1545 if (cfg->fc_flags & RTF_EXPIRES)
1546 rt6_set_expires(rt, jiffies +
1547 clock_t_to_jiffies(cfg->fc_expires));
1549 rt6_clean_expires(rt);
1551 if (cfg->fc_protocol == RTPROT_UNSPEC)
1552 cfg->fc_protocol = RTPROT_BOOT;
1553 rt->rt6i_protocol = cfg->fc_protocol;
1555 addr_type = ipv6_addr_type(&cfg->fc_dst);
1557 if (addr_type & IPV6_ADDR_MULTICAST)
1558 rt->dst.input = ip6_mc_input;
1559 else if (cfg->fc_flags & RTF_LOCAL)
1560 rt->dst.input = ip6_input;
1562 rt->dst.input = ip6_forward;
1564 rt->dst.output = ip6_output;
1566 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1567 rt->rt6i_dst.plen = cfg->fc_dst_len;
1568 if (rt->rt6i_dst.plen == 128)
1569 rt->dst.flags |= DST_HOST;
1571 #ifdef CONFIG_IPV6_SUBTREES
1572 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1573 rt->rt6i_src.plen = cfg->fc_src_len;
1576 rt->rt6i_metric = cfg->fc_metric;
1578 /* We cannot add true routes via loopback here,
1579 they would result in kernel looping; promote them to reject routes
1581 if ((cfg->fc_flags & RTF_REJECT) ||
1582 (dev && (dev->flags & IFF_LOOPBACK) &&
1583 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1584 !(cfg->fc_flags & RTF_LOCAL))) {
1585 /* hold loopback dev/idev if we haven't done so. */
1586 if (dev != net->loopback_dev) {
1591 dev = net->loopback_dev;
1593 idev = in6_dev_get(dev);
1599 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1600 switch (cfg->fc_type) {
1602 rt->dst.error = -EINVAL;
1603 rt->dst.output = dst_discard_sk;
1604 rt->dst.input = dst_discard;
1607 rt->dst.error = -EACCES;
1608 rt->dst.output = ip6_pkt_prohibit_out;
1609 rt->dst.input = ip6_pkt_prohibit;
1613 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1615 rt->dst.output = ip6_pkt_discard_out;
1616 rt->dst.input = ip6_pkt_discard;
1622 if (cfg->fc_flags & RTF_GATEWAY) {
1623 const struct in6_addr *gw_addr;
1626 gw_addr = &cfg->fc_gateway;
1628 /* if gw_addr is local we will fail to detect this in case
1629 * address is still TENTATIVE (DAD in progress). rt6_lookup()
1630 * will return already-added prefix route via interface that
1631 * prefix route was assigned to, which might be non-loopback.
1634 if (ipv6_chk_addr_and_flags(net, gw_addr, NULL, 0, 0))
1637 rt->rt6i_gateway = *gw_addr;
1638 gwa_type = ipv6_addr_type(gw_addr);
1640 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1641 struct rt6_info *grt;
1643 /* IPv6 strictly inhibits using not link-local
1644 addresses as nexthop address.
1645 Otherwise, router will not able to send redirects.
1646 It is very good, but in some (rare!) circumstances
1647 (SIT, PtP, NBMA NOARP links) it is handy to allow
1648 some exceptions. --ANK
1650 if (!(gwa_type & IPV6_ADDR_UNICAST))
1653 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1655 err = -EHOSTUNREACH;
1659 if (dev != grt->dst.dev) {
1665 idev = grt->rt6i_idev;
1667 in6_dev_hold(grt->rt6i_idev);
1669 if (!(grt->rt6i_flags & RTF_GATEWAY))
1677 if (!dev || (dev->flags & IFF_LOOPBACK))
1685 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1686 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1690 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1691 rt->rt6i_prefsrc.plen = 128;
1693 rt->rt6i_prefsrc.plen = 0;
1695 rt->rt6i_flags = cfg->fc_flags;
1699 rt->rt6i_idev = idev;
1700 rt->rt6i_table = table;
1702 cfg->fc_nlinfo.nl_net = dev_net(dev);
1704 err = ip6_convert_metrics(&mxc, cfg);
1708 err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);
1722 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1725 struct fib6_table *table;
1726 struct net *net = dev_net(rt->dst.dev);
1728 if (rt == net->ipv6.ip6_null_entry) {
1733 table = rt->rt6i_table;
1734 write_lock_bh(&table->tb6_lock);
1735 err = fib6_del(rt, info);
1736 write_unlock_bh(&table->tb6_lock);
1743 int ip6_del_rt(struct rt6_info *rt)
1745 struct nl_info info = {
1746 .nl_net = dev_net(rt->dst.dev),
1748 return __ip6_del_rt(rt, &info);
1751 static int ip6_route_del(struct fib6_config *cfg)
1753 struct fib6_table *table;
1754 struct fib6_node *fn;
1755 struct rt6_info *rt;
1758 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1762 read_lock_bh(&table->tb6_lock);
1764 fn = fib6_locate(&table->tb6_root,
1765 &cfg->fc_dst, cfg->fc_dst_len,
1766 &cfg->fc_src, cfg->fc_src_len);
1769 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1770 if ((rt->rt6i_flags & RTF_CACHE) &&
1771 !(cfg->fc_flags & RTF_CACHE))
1773 if (cfg->fc_ifindex &&
1775 rt->dst.dev->ifindex != cfg->fc_ifindex))
1777 if (cfg->fc_flags & RTF_GATEWAY &&
1778 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1780 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1783 read_unlock_bh(&table->tb6_lock);
1785 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1788 read_unlock_bh(&table->tb6_lock);
1793 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1795 struct net *net = dev_net(skb->dev);
1796 struct netevent_redirect netevent;
1797 struct rt6_info *rt, *nrt = NULL;
1798 struct ndisc_options ndopts;
1799 struct inet6_dev *in6_dev;
1800 struct neighbour *neigh;
1802 int optlen, on_link;
1805 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
1806 optlen -= sizeof(*msg);
1809 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1813 msg = (struct rd_msg *)icmp6_hdr(skb);
1815 if (ipv6_addr_is_multicast(&msg->dest)) {
1816 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1821 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
1823 } else if (ipv6_addr_type(&msg->target) !=
1824 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1825 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1829 in6_dev = __in6_dev_get(skb->dev);
1832 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1836 * The IP source address of the Redirect MUST be the same as the current
1837 * first-hop router for the specified ICMP Destination Address.
1840 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
1841 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1846 if (ndopts.nd_opts_tgt_lladdr) {
1847 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1850 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1855 rt = (struct rt6_info *) dst;
1856 if (rt == net->ipv6.ip6_null_entry) {
1857 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1861 /* Redirect received -> path was valid.
1862 * Look, redirects are sent only in response to data packets,
1863 * so that this nexthop apparently is reachable. --ANK
1865 dst_confirm(&rt->dst);
1867 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
1872 * We have finally decided to accept it.
1875 neigh_update(neigh, lladdr, NUD_STALE,
1876 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1877 NEIGH_UPDATE_F_OVERRIDE|
1878 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1879 NEIGH_UPDATE_F_ISROUTER))
1882 nrt = ip6_rt_copy(rt, &msg->dest);
1886 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1888 nrt->rt6i_flags &= ~RTF_GATEWAY;
1890 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1892 if (ip6_ins_rt(nrt))
1895 netevent.old = &rt->dst;
1896 netevent.new = &nrt->dst;
1897 netevent.daddr = &msg->dest;
1898 netevent.neigh = neigh;
1899 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1901 if (rt->rt6i_flags & RTF_CACHE) {
1902 rt = (struct rt6_info *) dst_clone(&rt->dst);
1907 neigh_release(neigh);
1911 * Misc support functions
1914 static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
1916 BUG_ON(from->dst.from);
1918 rt->rt6i_flags &= ~RTF_EXPIRES;
1919 dst_hold(&from->dst);
1920 rt->dst.from = &from->dst;
1921 dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
1924 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1925 const struct in6_addr *dest)
1927 struct net *net = dev_net(ort->dst.dev);
1928 struct rt6_info *rt;
1930 if (ort->rt6i_flags & RTF_CACHE)
1931 ort = (struct rt6_info *)ort->dst.from;
1933 rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1937 rt->dst.input = ort->dst.input;
1938 rt->dst.output = ort->dst.output;
1939 rt->dst.flags |= DST_HOST;
1941 rt->rt6i_dst.addr = *dest;
1942 rt->rt6i_dst.plen = 128;
1943 rt->dst.error = ort->dst.error;
1944 rt->rt6i_idev = ort->rt6i_idev;
1946 in6_dev_hold(rt->rt6i_idev);
1947 rt->dst.lastuse = jiffies;
1948 rt->rt6i_gateway = ort->rt6i_gateway;
1949 rt->rt6i_flags = ort->rt6i_flags;
1950 rt6_set_from(rt, ort);
1951 rt->rt6i_metric = 0;
1953 #ifdef CONFIG_IPV6_SUBTREES
1954 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1956 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1957 rt->rt6i_table = ort->rt6i_table;
1962 #ifdef CONFIG_IPV6_ROUTE_INFO
1963 static struct rt6_info *rt6_get_route_info(struct net *net,
1964 const struct in6_addr *prefix, int prefixlen,
1965 const struct in6_addr *gwaddr, int ifindex)
1967 struct fib6_node *fn;
1968 struct rt6_info *rt = NULL;
1969 struct fib6_table *table;
1971 table = fib6_get_table(net, RT6_TABLE_INFO);
1975 read_lock_bh(&table->tb6_lock);
1976 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
1980 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1981 if (rt->dst.dev->ifindex != ifindex)
1983 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1985 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1991 read_unlock_bh(&table->tb6_lock);
1995 static struct rt6_info *rt6_add_route_info(struct net *net,
1996 const struct in6_addr *prefix, int prefixlen,
1997 const struct in6_addr *gwaddr, int ifindex,
2000 struct fib6_config cfg = {
2001 .fc_table = RT6_TABLE_INFO,
2002 .fc_metric = IP6_RT_PRIO_USER,
2003 .fc_ifindex = ifindex,
2004 .fc_dst_len = prefixlen,
2005 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2006 RTF_UP | RTF_PREF(pref),
2007 .fc_nlinfo.portid = 0,
2008 .fc_nlinfo.nlh = NULL,
2009 .fc_nlinfo.nl_net = net,
2012 cfg.fc_dst = *prefix;
2013 cfg.fc_gateway = *gwaddr;
2015 /* We should treat it as a default route if prefix length is 0. */
2017 cfg.fc_flags |= RTF_DEFAULT;
2019 ip6_route_add(&cfg);
2021 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
2025 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
2027 struct rt6_info *rt;
2028 struct fib6_table *table;
2030 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
2034 read_lock_bh(&table->tb6_lock);
2035 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2036 if (dev == rt->dst.dev &&
2037 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
2038 ipv6_addr_equal(&rt->rt6i_gateway, addr))
2043 read_unlock_bh(&table->tb6_lock);
2047 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
2048 struct net_device *dev,
2051 struct fib6_config cfg = {
2052 .fc_table = RT6_TABLE_DFLT,
2053 .fc_metric = IP6_RT_PRIO_USER,
2054 .fc_ifindex = dev->ifindex,
2055 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2056 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
2057 .fc_nlinfo.portid = 0,
2058 .fc_nlinfo.nlh = NULL,
2059 .fc_nlinfo.nl_net = dev_net(dev),
2062 cfg.fc_gateway = *gwaddr;
2064 ip6_route_add(&cfg);
2066 return rt6_get_dflt_router(gwaddr, dev);
2069 void rt6_purge_dflt_routers(struct net *net)
2071 struct rt6_info *rt;
2072 struct fib6_table *table;
2074 /* NOTE: Keep consistent with rt6_get_dflt_router */
2075 table = fib6_get_table(net, RT6_TABLE_DFLT);
2080 read_lock_bh(&table->tb6_lock);
2081 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2082 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2083 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2085 read_unlock_bh(&table->tb6_lock);
2090 read_unlock_bh(&table->tb6_lock);
2093 static void rtmsg_to_fib6_config(struct net *net,
2094 struct in6_rtmsg *rtmsg,
2095 struct fib6_config *cfg)
2097 memset(cfg, 0, sizeof(*cfg));
2099 cfg->fc_table = RT6_TABLE_MAIN;
2100 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2101 cfg->fc_metric = rtmsg->rtmsg_metric;
2102 cfg->fc_expires = rtmsg->rtmsg_info;
2103 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2104 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2105 cfg->fc_flags = rtmsg->rtmsg_flags;
2107 cfg->fc_nlinfo.nl_net = net;
2109 cfg->fc_dst = rtmsg->rtmsg_dst;
2110 cfg->fc_src = rtmsg->rtmsg_src;
2111 cfg->fc_gateway = rtmsg->rtmsg_gateway;
2114 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2116 struct fib6_config cfg;
2117 struct in6_rtmsg rtmsg;
2121 case SIOCADDRT: /* Add a route */
2122 case SIOCDELRT: /* Delete a route */
2123 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2125 err = copy_from_user(&rtmsg, arg,
2126 sizeof(struct in6_rtmsg));
2130 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2135 err = ip6_route_add(&cfg);
2138 err = ip6_route_del(&cfg);
2152 * Drop the packet on the floor
2155 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2158 struct dst_entry *dst = skb_dst(skb);
2159 switch (ipstats_mib_noroutes) {
2160 case IPSTATS_MIB_INNOROUTES:
2161 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2162 if (type == IPV6_ADDR_ANY) {
2163 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2164 IPSTATS_MIB_INADDRERRORS);
2168 case IPSTATS_MIB_OUTNOROUTES:
2169 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2170 ipstats_mib_noroutes);
2173 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2178 static int ip6_pkt_discard(struct sk_buff *skb)
2180 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2183 static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)
2185 skb->dev = skb_dst(skb)->dev;
2186 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2189 static int ip6_pkt_prohibit(struct sk_buff *skb)
2191 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2194 static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)
2196 skb->dev = skb_dst(skb)->dev;
2197 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2201 * Allocate a dst for local (unicast / anycast) address.
2204 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2205 const struct in6_addr *addr,
2208 struct net *net = dev_net(idev->dev);
2209 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2212 return ERR_PTR(-ENOMEM);
2216 rt->dst.flags |= DST_HOST;
2217 rt->dst.input = ip6_input;
2218 rt->dst.output = ip6_output;
2219 rt->rt6i_idev = idev;
2221 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2223 rt->rt6i_flags |= RTF_ANYCAST;
2225 rt->rt6i_flags |= RTF_LOCAL;
2227 rt->rt6i_gateway = *addr;
2228 rt->rt6i_dst.addr = *addr;
2229 rt->rt6i_dst.plen = 128;
2230 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2232 atomic_set(&rt->dst.__refcnt, 1);
2237 int ip6_route_get_saddr(struct net *net,
2238 struct rt6_info *rt,
2239 const struct in6_addr *daddr,
2241 struct in6_addr *saddr)
2243 struct inet6_dev *idev =
2244 rt ? ip6_dst_idev((struct dst_entry *)rt) : NULL;
2246 if (rt && rt->rt6i_prefsrc.plen)
2247 *saddr = rt->rt6i_prefsrc.addr;
2249 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2250 daddr, prefs, saddr);
2254 /* remove deleted ip from prefsrc entries */
2255 struct arg_dev_net_ip {
2256 struct net_device *dev;
2258 struct in6_addr *addr;
2261 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2263 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2264 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2265 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2267 if (((void *)rt->dst.dev == dev || !dev) &&
2268 rt != net->ipv6.ip6_null_entry &&
2269 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2270 /* remove prefsrc entry */
2271 rt->rt6i_prefsrc.plen = 0;
2276 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2278 struct net *net = dev_net(ifp->idev->dev);
2279 struct arg_dev_net_ip adni = {
2280 .dev = ifp->idev->dev,
2284 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2287 #define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2288 #define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2290 /* Remove routers and update dst entries when gateway turn into host. */
2291 static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2293 struct in6_addr *gateway = (struct in6_addr *)arg;
2295 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2296 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2297 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2303 void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2305 fib6_clean_all(net, fib6_clean_tohost, gateway);
2308 struct arg_dev_net {
2309 struct net_device *dev;
2313 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2315 const struct arg_dev_net *adn = arg;
2316 const struct net_device *dev = adn->dev;
2318 if ((rt->dst.dev == dev || !dev) &&
2319 rt != adn->net->ipv6.ip6_null_entry)
2325 void rt6_ifdown(struct net *net, struct net_device *dev)
2327 struct arg_dev_net adn = {
2332 fib6_clean_all(net, fib6_ifdown, &adn);
2333 icmp6_clean_all(fib6_ifdown, &adn);
2336 struct rt6_mtu_change_arg {
2337 struct net_device *dev;
2341 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2343 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2344 struct inet6_dev *idev;
2346 /* In IPv6 pmtu discovery is not optional,
2347 so that RTAX_MTU lock cannot disable it.
2348 We still use this lock to block changes
2349 caused by addrconf/ndisc.
2352 idev = __in6_dev_get(arg->dev);
2356 /* For administrative MTU increase, there is no way to discover
2357 IPv6 PMTU increase, so PMTU increase should be updated here.
2358 Since RFC 1981 doesn't include administrative MTU increase
2359 update PMTU increase is a MUST. (i.e. jumbo frame)
2362 If new MTU is less than route PMTU, this new MTU will be the
2363 lowest MTU in the path, update the route PMTU to reflect PMTU
2364 decreases; if new MTU is greater than route PMTU, and the
2365 old MTU is the lowest MTU in the path, update the route PMTU
2366 to reflect the increase. In this case if the other nodes' MTU
2367 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2370 if (rt->dst.dev == arg->dev &&
2371 !dst_metric_locked(&rt->dst, RTAX_MTU)) {
2372 if (rt->rt6i_flags & RTF_CACHE) {
2373 /* For RTF_CACHE with rt6i_pmtu == 0
2374 * (i.e. a redirected route),
2375 * the metrics of its rt->dst.from has already
2378 if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
2379 rt->rt6i_pmtu = arg->mtu;
2380 } else if (dst_mtu(&rt->dst) >= arg->mtu ||
2381 (dst_mtu(&rt->dst) < arg->mtu &&
2382 dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
2383 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2389 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2391 struct rt6_mtu_change_arg arg = {
2396 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2399 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2400 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2401 [RTA_OIF] = { .type = NLA_U32 },
2402 [RTA_IIF] = { .type = NLA_U32 },
2403 [RTA_PRIORITY] = { .type = NLA_U32 },
2404 [RTA_METRICS] = { .type = NLA_NESTED },
2405 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2406 [RTA_PREF] = { .type = NLA_U8 },
2409 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2410 struct fib6_config *cfg)
2413 struct nlattr *tb[RTA_MAX+1];
2417 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2422 rtm = nlmsg_data(nlh);
2423 memset(cfg, 0, sizeof(*cfg));
2425 cfg->fc_table = rtm->rtm_table;
2426 cfg->fc_dst_len = rtm->rtm_dst_len;
2427 cfg->fc_src_len = rtm->rtm_src_len;
2428 cfg->fc_flags = RTF_UP;
2429 cfg->fc_protocol = rtm->rtm_protocol;
2430 cfg->fc_type = rtm->rtm_type;
2432 if (rtm->rtm_type == RTN_UNREACHABLE ||
2433 rtm->rtm_type == RTN_BLACKHOLE ||
2434 rtm->rtm_type == RTN_PROHIBIT ||
2435 rtm->rtm_type == RTN_THROW)
2436 cfg->fc_flags |= RTF_REJECT;
2438 if (rtm->rtm_type == RTN_LOCAL)
2439 cfg->fc_flags |= RTF_LOCAL;
2441 if (rtm->rtm_flags & RTM_F_CLONED)
2442 cfg->fc_flags |= RTF_CACHE;
2444 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2445 cfg->fc_nlinfo.nlh = nlh;
2446 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2448 if (tb[RTA_GATEWAY]) {
2449 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
2450 cfg->fc_flags |= RTF_GATEWAY;
2454 int plen = (rtm->rtm_dst_len + 7) >> 3;
2456 if (nla_len(tb[RTA_DST]) < plen)
2459 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2463 int plen = (rtm->rtm_src_len + 7) >> 3;
2465 if (nla_len(tb[RTA_SRC]) < plen)
2468 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2471 if (tb[RTA_PREFSRC])
2472 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
2475 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2477 if (tb[RTA_PRIORITY])
2478 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2480 if (tb[RTA_METRICS]) {
2481 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2482 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2486 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2488 if (tb[RTA_MULTIPATH]) {
2489 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2490 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2494 pref = nla_get_u8(tb[RTA_PREF]);
2495 if (pref != ICMPV6_ROUTER_PREF_LOW &&
2496 pref != ICMPV6_ROUTER_PREF_HIGH)
2497 pref = ICMPV6_ROUTER_PREF_MEDIUM;
2498 cfg->fc_flags |= RTF_PREF(pref);
2506 static int ip6_route_multipath(struct fib6_config *cfg, int add)
2508 struct fib6_config r_cfg;
2509 struct rtnexthop *rtnh;
2512 int err = 0, last_err = 0;
2514 remaining = cfg->fc_mp_len;
2516 rtnh = (struct rtnexthop *)cfg->fc_mp;
2518 /* Parse a Multipath Entry */
2519 while (rtnh_ok(rtnh, remaining)) {
2520 memcpy(&r_cfg, cfg, sizeof(*cfg));
2521 if (rtnh->rtnh_ifindex)
2522 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2524 attrlen = rtnh_attrlen(rtnh);
2526 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2528 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2530 r_cfg.fc_gateway = nla_get_in6_addr(nla);
2531 r_cfg.fc_flags |= RTF_GATEWAY;
2534 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2537 /* If we are trying to remove a route, do not stop the
2538 * loop when ip6_route_del() fails (because next hop is
2539 * already gone), we should try to remove all next hops.
2542 /* If add fails, we should try to delete all
2543 * next hops that have been already added.
2546 remaining = cfg->fc_mp_len - remaining;
2550 /* Because each route is added like a single route we remove
2551 * these flags after the first nexthop: if there is a collision,
2552 * we have already failed to add the first nexthop:
2553 * fib6_add_rt2node() has rejected it; when replacing, old
2554 * nexthops have been replaced by first new, the rest should
2557 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
2559 rtnh = rtnh_next(rtnh, &remaining);
2565 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
2567 struct fib6_config cfg;
2570 err = rtm_to_fib6_config(skb, nlh, &cfg);
2575 return ip6_route_multipath(&cfg, 0);
2577 return ip6_route_del(&cfg);
2580 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
2582 struct fib6_config cfg;
2585 err = rtm_to_fib6_config(skb, nlh, &cfg);
2590 return ip6_route_multipath(&cfg, 1);
2592 return ip6_route_add(&cfg);
2595 static inline size_t rt6_nlmsg_size(void)
2597 return NLMSG_ALIGN(sizeof(struct rtmsg))
2598 + nla_total_size(16) /* RTA_SRC */
2599 + nla_total_size(16) /* RTA_DST */
2600 + nla_total_size(16) /* RTA_GATEWAY */
2601 + nla_total_size(16) /* RTA_PREFSRC */
2602 + nla_total_size(4) /* RTA_TABLE */
2603 + nla_total_size(4) /* RTA_IIF */
2604 + nla_total_size(4) /* RTA_OIF */
2605 + nla_total_size(4) /* RTA_PRIORITY */
2606 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2607 + nla_total_size(sizeof(struct rta_cacheinfo))
2608 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
2609 + nla_total_size(1); /* RTA_PREF */
2612 static int rt6_fill_node(struct net *net,
2613 struct sk_buff *skb, struct rt6_info *rt,
2614 struct in6_addr *dst, struct in6_addr *src,
2615 int iif, int type, u32 portid, u32 seq,
2616 int prefix, int nowait, unsigned int flags)
2618 u32 metrics[RTAX_MAX];
2620 struct nlmsghdr *nlh;
2624 if (prefix) { /* user wants prefix routes only */
2625 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2626 /* success since this is not a prefix route */
2631 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2635 rtm = nlmsg_data(nlh);
2636 rtm->rtm_family = AF_INET6;
2637 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2638 rtm->rtm_src_len = rt->rt6i_src.plen;
2641 table = rt->rt6i_table->tb6_id;
2643 table = RT6_TABLE_UNSPEC;
2644 rtm->rtm_table = table;
2645 if (nla_put_u32(skb, RTA_TABLE, table))
2646 goto nla_put_failure;
2647 if (rt->rt6i_flags & RTF_REJECT) {
2648 switch (rt->dst.error) {
2650 rtm->rtm_type = RTN_BLACKHOLE;
2653 rtm->rtm_type = RTN_PROHIBIT;
2656 rtm->rtm_type = RTN_THROW;
2659 rtm->rtm_type = RTN_UNREACHABLE;
2663 else if (rt->rt6i_flags & RTF_LOCAL)
2664 rtm->rtm_type = RTN_LOCAL;
2665 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2666 rtm->rtm_type = RTN_LOCAL;
2668 rtm->rtm_type = RTN_UNICAST;
2670 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2671 rtm->rtm_protocol = rt->rt6i_protocol;
2672 if (rt->rt6i_flags & RTF_DYNAMIC)
2673 rtm->rtm_protocol = RTPROT_REDIRECT;
2674 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2675 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2676 rtm->rtm_protocol = RTPROT_RA;
2678 rtm->rtm_protocol = RTPROT_KERNEL;
2681 if (rt->rt6i_flags & RTF_CACHE)
2682 rtm->rtm_flags |= RTM_F_CLONED;
2685 if (nla_put_in6_addr(skb, RTA_DST, dst))
2686 goto nla_put_failure;
2687 rtm->rtm_dst_len = 128;
2688 } else if (rtm->rtm_dst_len)
2689 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
2690 goto nla_put_failure;
2691 #ifdef CONFIG_IPV6_SUBTREES
2693 if (nla_put_in6_addr(skb, RTA_SRC, src))
2694 goto nla_put_failure;
2695 rtm->rtm_src_len = 128;
2696 } else if (rtm->rtm_src_len &&
2697 nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
2698 goto nla_put_failure;
2701 #ifdef CONFIG_IPV6_MROUTE
2702 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2703 int err = ip6mr_get_route(net, skb, rtm, nowait);
2708 goto nla_put_failure;
2710 if (err == -EMSGSIZE)
2711 goto nla_put_failure;
2716 if (nla_put_u32(skb, RTA_IIF, iif))
2717 goto nla_put_failure;
2719 struct in6_addr saddr_buf;
2720 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2721 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
2722 goto nla_put_failure;
2725 if (rt->rt6i_prefsrc.plen) {
2726 struct in6_addr saddr_buf;
2727 saddr_buf = rt->rt6i_prefsrc.addr;
2728 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
2729 goto nla_put_failure;
2732 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2734 metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
2735 if (rtnetlink_put_metrics(skb, metrics) < 0)
2736 goto nla_put_failure;
2738 if (rt->rt6i_flags & RTF_GATEWAY) {
2739 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
2740 goto nla_put_failure;
2744 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2745 goto nla_put_failure;
2746 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2747 goto nla_put_failure;
2749 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2751 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2752 goto nla_put_failure;
2754 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
2755 goto nla_put_failure;
2757 nlmsg_end(skb, nlh);
2761 nlmsg_cancel(skb, nlh);
2765 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2767 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2770 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2771 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2772 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2776 return rt6_fill_node(arg->net,
2777 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2778 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2779 prefix, 0, NLM_F_MULTI);
2782 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
2784 struct net *net = sock_net(in_skb->sk);
2785 struct nlattr *tb[RTA_MAX+1];
2786 struct rt6_info *rt;
2787 struct sk_buff *skb;
2790 int err, iif = 0, oif = 0;
2792 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2797 memset(&fl6, 0, sizeof(fl6));
2800 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2803 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2807 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2810 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2814 iif = nla_get_u32(tb[RTA_IIF]);
2817 oif = nla_get_u32(tb[RTA_OIF]);
2820 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
2823 struct net_device *dev;
2826 dev = __dev_get_by_index(net, iif);
2832 fl6.flowi6_iif = iif;
2834 if (!ipv6_addr_any(&fl6.saddr))
2835 flags |= RT6_LOOKUP_F_HAS_SADDR;
2837 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2840 fl6.flowi6_oif = oif;
2842 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2845 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2852 /* Reserve room for dummy headers, this skb can pass
2853 through good chunk of routing engine.
2855 skb_reset_mac_header(skb);
2856 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2858 skb_dst_set(skb, &rt->dst);
2860 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2861 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2862 nlh->nlmsg_seq, 0, 0, 0);
2868 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2873 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2875 struct sk_buff *skb;
2876 struct net *net = info->nl_net;
2881 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2883 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2887 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2888 event, info->portid, seq, 0, 0, 0);
2890 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2891 WARN_ON(err == -EMSGSIZE);
2895 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2896 info->nlh, gfp_any());
2900 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2903 static int ip6_route_dev_notify(struct notifier_block *this,
2904 unsigned long event, void *ptr)
2906 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2907 struct net *net = dev_net(dev);
2909 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2910 net->ipv6.ip6_null_entry->dst.dev = dev;
2911 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2912 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2913 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2914 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2915 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2916 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2927 #ifdef CONFIG_PROC_FS
2929 static const struct file_operations ipv6_route_proc_fops = {
2930 .owner = THIS_MODULE,
2931 .open = ipv6_route_open,
2933 .llseek = seq_lseek,
2934 .release = seq_release_net,
2937 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2939 struct net *net = (struct net *)seq->private;
2940 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2941 net->ipv6.rt6_stats->fib_nodes,
2942 net->ipv6.rt6_stats->fib_route_nodes,
2943 net->ipv6.rt6_stats->fib_rt_alloc,
2944 net->ipv6.rt6_stats->fib_rt_entries,
2945 net->ipv6.rt6_stats->fib_rt_cache,
2946 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2947 net->ipv6.rt6_stats->fib_discarded_routes);
2952 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2954 return single_open_net(inode, file, rt6_stats_seq_show);
2957 static const struct file_operations rt6_stats_seq_fops = {
2958 .owner = THIS_MODULE,
2959 .open = rt6_stats_seq_open,
2961 .llseek = seq_lseek,
2962 .release = single_release_net,
2964 #endif /* CONFIG_PROC_FS */
2966 #ifdef CONFIG_SYSCTL
2969 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
2970 void __user *buffer, size_t *lenp, loff_t *ppos)
2977 net = (struct net *)ctl->extra1;
2978 delay = net->ipv6.sysctl.flush_delay;
2979 proc_dointvec(ctl, write, buffer, lenp, ppos);
2980 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
2984 struct ctl_table ipv6_route_table_template[] = {
2986 .procname = "flush",
2987 .data = &init_net.ipv6.sysctl.flush_delay,
2988 .maxlen = sizeof(int),
2990 .proc_handler = ipv6_sysctl_rtcache_flush
2993 .procname = "gc_thresh",
2994 .data = &ip6_dst_ops_template.gc_thresh,
2995 .maxlen = sizeof(int),
2997 .proc_handler = proc_dointvec,
3000 .procname = "max_size",
3001 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
3002 .maxlen = sizeof(int),
3004 .proc_handler = proc_dointvec,
3007 .procname = "gc_min_interval",
3008 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3009 .maxlen = sizeof(int),
3011 .proc_handler = proc_dointvec_jiffies,
3014 .procname = "gc_timeout",
3015 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
3016 .maxlen = sizeof(int),
3018 .proc_handler = proc_dointvec_jiffies,
3021 .procname = "gc_interval",
3022 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
3023 .maxlen = sizeof(int),
3025 .proc_handler = proc_dointvec_jiffies,
3028 .procname = "gc_elasticity",
3029 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
3030 .maxlen = sizeof(int),
3032 .proc_handler = proc_dointvec,
3035 .procname = "mtu_expires",
3036 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
3037 .maxlen = sizeof(int),
3039 .proc_handler = proc_dointvec_jiffies,
3042 .procname = "min_adv_mss",
3043 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
3044 .maxlen = sizeof(int),
3046 .proc_handler = proc_dointvec,
3049 .procname = "gc_min_interval_ms",
3050 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3051 .maxlen = sizeof(int),
3053 .proc_handler = proc_dointvec_ms_jiffies,
3058 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
3060 struct ctl_table *table;
3062 table = kmemdup(ipv6_route_table_template,
3063 sizeof(ipv6_route_table_template),
3067 table[0].data = &net->ipv6.sysctl.flush_delay;
3068 table[0].extra1 = net;
3069 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
3070 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3071 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3072 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3073 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3074 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3075 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3076 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
3077 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3079 /* Don't export sysctls to unprivileged users */
3080 if (net->user_ns != &init_user_ns)
3081 table[0].procname = NULL;
3088 static int __net_init ip6_route_net_init(struct net *net)
3092 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3093 sizeof(net->ipv6.ip6_dst_ops));
3095 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3096 goto out_ip6_dst_ops;
3098 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3099 sizeof(*net->ipv6.ip6_null_entry),
3101 if (!net->ipv6.ip6_null_entry)
3102 goto out_ip6_dst_entries;
3103 net->ipv6.ip6_null_entry->dst.path =
3104 (struct dst_entry *)net->ipv6.ip6_null_entry;
3105 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3106 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3107 ip6_template_metrics, true);
3109 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3110 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3111 sizeof(*net->ipv6.ip6_prohibit_entry),
3113 if (!net->ipv6.ip6_prohibit_entry)
3114 goto out_ip6_null_entry;
3115 net->ipv6.ip6_prohibit_entry->dst.path =
3116 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3117 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3118 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3119 ip6_template_metrics, true);
3121 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3122 sizeof(*net->ipv6.ip6_blk_hole_entry),
3124 if (!net->ipv6.ip6_blk_hole_entry)
3125 goto out_ip6_prohibit_entry;
3126 net->ipv6.ip6_blk_hole_entry->dst.path =
3127 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3128 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3129 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3130 ip6_template_metrics, true);
3133 net->ipv6.sysctl.flush_delay = 0;
3134 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3135 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3136 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3137 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3138 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3139 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3140 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3142 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3148 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3149 out_ip6_prohibit_entry:
3150 kfree(net->ipv6.ip6_prohibit_entry);
3152 kfree(net->ipv6.ip6_null_entry);
3154 out_ip6_dst_entries:
3155 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3160 static void __net_exit ip6_route_net_exit(struct net *net)
3162 kfree(net->ipv6.ip6_null_entry);
3163 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3164 kfree(net->ipv6.ip6_prohibit_entry);
3165 kfree(net->ipv6.ip6_blk_hole_entry);
3167 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3170 static int __net_init ip6_route_net_init_late(struct net *net)
3172 #ifdef CONFIG_PROC_FS
3173 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3174 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3179 static void __net_exit ip6_route_net_exit_late(struct net *net)
3181 #ifdef CONFIG_PROC_FS
3182 remove_proc_entry("ipv6_route", net->proc_net);
3183 remove_proc_entry("rt6_stats", net->proc_net);
3187 static struct pernet_operations ip6_route_net_ops = {
3188 .init = ip6_route_net_init,
3189 .exit = ip6_route_net_exit,
3192 static int __net_init ipv6_inetpeer_init(struct net *net)
3194 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3198 inet_peer_base_init(bp);
3199 net->ipv6.peers = bp;
3203 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3205 struct inet_peer_base *bp = net->ipv6.peers;
3207 net->ipv6.peers = NULL;
3208 inetpeer_invalidate_tree(bp);
3212 static struct pernet_operations ipv6_inetpeer_ops = {
3213 .init = ipv6_inetpeer_init,
3214 .exit = ipv6_inetpeer_exit,
3217 static struct pernet_operations ip6_route_net_late_ops = {
3218 .init = ip6_route_net_init_late,
3219 .exit = ip6_route_net_exit_late,
3222 static struct notifier_block ip6_route_dev_notifier = {
3223 .notifier_call = ip6_route_dev_notify,
3227 int __init ip6_route_init(void)
3232 ip6_dst_ops_template.kmem_cachep =
3233 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3234 SLAB_HWCACHE_ALIGN, NULL);
3235 if (!ip6_dst_ops_template.kmem_cachep)
3238 ret = dst_entries_init(&ip6_dst_blackhole_ops);
3240 goto out_kmem_cache;
3242 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3244 goto out_dst_entries;
3246 ret = register_pernet_subsys(&ip6_route_net_ops);
3248 goto out_register_inetpeer;
3250 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3252 /* Registering of the loopback is done before this portion of code,
3253 * the loopback reference in rt6_info will not be taken, do it
3254 * manually for init_net */
3255 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3256 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3257 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3258 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3259 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3260 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3261 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3265 goto out_register_subsys;
3271 ret = fib6_rules_init();
3275 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3277 goto fib6_rules_init;
3280 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3281 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3282 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3283 goto out_register_late_subsys;
3285 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3287 goto out_register_late_subsys;
3292 out_register_late_subsys:
3293 unregister_pernet_subsys(&ip6_route_net_late_ops);
3295 fib6_rules_cleanup();
3300 out_register_subsys:
3301 unregister_pernet_subsys(&ip6_route_net_ops);
3302 out_register_inetpeer:
3303 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3305 dst_entries_destroy(&ip6_dst_blackhole_ops);
3307 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3311 void ip6_route_cleanup(void)
3313 unregister_netdevice_notifier(&ip6_route_dev_notifier);
3314 unregister_pernet_subsys(&ip6_route_net_late_ops);
3315 fib6_rules_cleanup();
3318 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3319 unregister_pernet_subsys(&ip6_route_net_ops);
3320 dst_entries_destroy(&ip6_dst_blackhole_ops);
3321 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);