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 #include <linux/capability.h>
28 #include <linux/errno.h>
29 #include <linux/types.h>
30 #include <linux/times.h>
31 #include <linux/socket.h>
32 #include <linux/sockios.h>
33 #include <linux/net.h>
34 #include <linux/route.h>
35 #include <linux/netdevice.h>
36 #include <linux/in6.h>
37 #include <linux/mroute6.h>
38 #include <linux/init.h>
39 #include <linux/if_arp.h>
40 #include <linux/proc_fs.h>
41 #include <linux/seq_file.h>
42 #include <linux/nsproxy.h>
43 #include <linux/slab.h>
44 #include <net/net_namespace.h>
47 #include <net/ip6_fib.h>
48 #include <net/ip6_route.h>
49 #include <net/ndisc.h>
50 #include <net/addrconf.h>
52 #include <linux/rtnetlink.h>
55 #include <net/netevent.h>
56 #include <net/netlink.h>
58 #include <asm/uaccess.h>
61 #include <linux/sysctl.h>
64 /* Set to 3 to get tracing. */
68 #define RDBG(x) printk x
69 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
72 #define RT6_TRACE(x...) do { ; } while (0)
75 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
76 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
77 static unsigned int ip6_default_advmss(const struct dst_entry *dst);
78 static unsigned int ip6_default_mtu(const struct dst_entry *dst);
79 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
80 static void ip6_dst_destroy(struct dst_entry *);
81 static void ip6_dst_ifdown(struct dst_entry *,
82 struct net_device *dev, int how);
83 static int ip6_dst_gc(struct dst_ops *ops);
85 static int ip6_pkt_discard(struct sk_buff *skb);
86 static int ip6_pkt_discard_out(struct sk_buff *skb);
87 static void ip6_link_failure(struct sk_buff *skb);
88 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
90 #ifdef CONFIG_IPV6_ROUTE_INFO
91 static struct rt6_info *rt6_add_route_info(struct net *net,
92 struct in6_addr *prefix, int prefixlen,
93 struct in6_addr *gwaddr, int ifindex,
95 static struct rt6_info *rt6_get_route_info(struct net *net,
96 struct in6_addr *prefix, int prefixlen,
97 struct in6_addr *gwaddr, int ifindex);
100 static struct dst_ops ip6_dst_ops_template = {
102 .protocol = cpu_to_be16(ETH_P_IPV6),
105 .check = ip6_dst_check,
106 .default_advmss = ip6_default_advmss,
107 .default_mtu = ip6_default_mtu,
108 .destroy = ip6_dst_destroy,
109 .ifdown = ip6_dst_ifdown,
110 .negative_advice = ip6_negative_advice,
111 .link_failure = ip6_link_failure,
112 .update_pmtu = ip6_rt_update_pmtu,
113 .local_out = __ip6_local_out,
116 static unsigned int ip6_blackhole_default_mtu(const struct dst_entry *dst)
121 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
125 static struct dst_ops ip6_dst_blackhole_ops = {
127 .protocol = cpu_to_be16(ETH_P_IPV6),
128 .destroy = ip6_dst_destroy,
129 .check = ip6_dst_check,
130 .default_mtu = ip6_blackhole_default_mtu,
131 .update_pmtu = ip6_rt_blackhole_update_pmtu,
134 static struct rt6_info ip6_null_entry_template = {
136 .__refcnt = ATOMIC_INIT(1),
139 .error = -ENETUNREACH,
140 .input = ip6_pkt_discard,
141 .output = ip6_pkt_discard_out,
143 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
144 .rt6i_protocol = RTPROT_KERNEL,
145 .rt6i_metric = ~(u32) 0,
146 .rt6i_ref = ATOMIC_INIT(1),
149 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
151 static int ip6_pkt_prohibit(struct sk_buff *skb);
152 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
154 static struct rt6_info ip6_prohibit_entry_template = {
156 .__refcnt = ATOMIC_INIT(1),
160 .input = ip6_pkt_prohibit,
161 .output = ip6_pkt_prohibit_out,
163 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
164 .rt6i_protocol = RTPROT_KERNEL,
165 .rt6i_metric = ~(u32) 0,
166 .rt6i_ref = ATOMIC_INIT(1),
169 static struct rt6_info ip6_blk_hole_entry_template = {
171 .__refcnt = ATOMIC_INIT(1),
175 .input = dst_discard,
176 .output = dst_discard,
178 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
179 .rt6i_protocol = RTPROT_KERNEL,
180 .rt6i_metric = ~(u32) 0,
181 .rt6i_ref = ATOMIC_INIT(1),
186 /* allocate dst with ip6_dst_ops */
187 static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops)
189 return (struct rt6_info *)dst_alloc(ops);
192 static void ip6_dst_destroy(struct dst_entry *dst)
194 struct rt6_info *rt = (struct rt6_info *)dst;
195 struct inet6_dev *idev = rt->rt6i_idev;
196 struct inet_peer *peer = rt->rt6i_peer;
199 rt->rt6i_idev = NULL;
203 rt->rt6i_peer = NULL;
208 void rt6_bind_peer(struct rt6_info *rt, int create)
210 struct inet_peer *peer;
212 peer = inet_getpeer_v6(&rt->rt6i_dst.addr, create);
213 if (peer && cmpxchg(&rt->rt6i_peer, NULL, peer) != NULL)
217 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
220 struct rt6_info *rt = (struct rt6_info *)dst;
221 struct inet6_dev *idev = rt->rt6i_idev;
222 struct net_device *loopback_dev =
223 dev_net(dev)->loopback_dev;
225 if (dev != loopback_dev && idev != NULL && idev->dev == dev) {
226 struct inet6_dev *loopback_idev =
227 in6_dev_get(loopback_dev);
228 if (loopback_idev != NULL) {
229 rt->rt6i_idev = loopback_idev;
235 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
237 return (rt->rt6i_flags & RTF_EXPIRES) &&
238 time_after(jiffies, rt->rt6i_expires);
241 static inline int rt6_need_strict(struct in6_addr *daddr)
243 return ipv6_addr_type(daddr) &
244 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
248 * Route lookup. Any table->tb6_lock is implied.
251 static inline struct rt6_info *rt6_device_match(struct net *net,
253 struct in6_addr *saddr,
257 struct rt6_info *local = NULL;
258 struct rt6_info *sprt;
260 if (!oif && ipv6_addr_any(saddr))
263 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
264 struct net_device *dev = sprt->rt6i_dev;
267 if (dev->ifindex == oif)
269 if (dev->flags & IFF_LOOPBACK) {
270 if (sprt->rt6i_idev == NULL ||
271 sprt->rt6i_idev->dev->ifindex != oif) {
272 if (flags & RT6_LOOKUP_F_IFACE && oif)
274 if (local && (!oif ||
275 local->rt6i_idev->dev->ifindex == oif))
281 if (ipv6_chk_addr(net, saddr, dev,
282 flags & RT6_LOOKUP_F_IFACE))
291 if (flags & RT6_LOOKUP_F_IFACE)
292 return net->ipv6.ip6_null_entry;
298 #ifdef CONFIG_IPV6_ROUTER_PREF
299 static void rt6_probe(struct rt6_info *rt)
301 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
303 * Okay, this does not seem to be appropriate
304 * for now, however, we need to check if it
305 * is really so; aka Router Reachability Probing.
307 * Router Reachability Probe MUST be rate-limited
308 * to no more than one per minute.
310 if (!neigh || (neigh->nud_state & NUD_VALID))
312 read_lock_bh(&neigh->lock);
313 if (!(neigh->nud_state & NUD_VALID) &&
314 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
315 struct in6_addr mcaddr;
316 struct in6_addr *target;
318 neigh->updated = jiffies;
319 read_unlock_bh(&neigh->lock);
321 target = (struct in6_addr *)&neigh->primary_key;
322 addrconf_addr_solict_mult(target, &mcaddr);
323 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
325 read_unlock_bh(&neigh->lock);
328 static inline void rt6_probe(struct rt6_info *rt)
334 * Default Router Selection (RFC 2461 6.3.6)
336 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
338 struct net_device *dev = rt->rt6i_dev;
339 if (!oif || dev->ifindex == oif)
341 if ((dev->flags & IFF_LOOPBACK) &&
342 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
347 static inline int rt6_check_neigh(struct rt6_info *rt)
349 struct neighbour *neigh = rt->rt6i_nexthop;
351 if (rt->rt6i_flags & RTF_NONEXTHOP ||
352 !(rt->rt6i_flags & RTF_GATEWAY))
355 read_lock_bh(&neigh->lock);
356 if (neigh->nud_state & NUD_VALID)
358 #ifdef CONFIG_IPV6_ROUTER_PREF
359 else if (neigh->nud_state & NUD_FAILED)
364 read_unlock_bh(&neigh->lock);
370 static int rt6_score_route(struct rt6_info *rt, int oif,
375 m = rt6_check_dev(rt, oif);
376 if (!m && (strict & RT6_LOOKUP_F_IFACE))
378 #ifdef CONFIG_IPV6_ROUTER_PREF
379 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
381 n = rt6_check_neigh(rt);
382 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
387 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
388 int *mpri, struct rt6_info *match)
392 if (rt6_check_expired(rt))
395 m = rt6_score_route(rt, oif, strict);
400 if (strict & RT6_LOOKUP_F_REACHABLE)
404 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
412 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
413 struct rt6_info *rr_head,
414 u32 metric, int oif, int strict)
416 struct rt6_info *rt, *match;
420 for (rt = rr_head; rt && rt->rt6i_metric == metric;
421 rt = rt->dst.rt6_next)
422 match = find_match(rt, oif, strict, &mpri, match);
423 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
424 rt = rt->dst.rt6_next)
425 match = find_match(rt, oif, strict, &mpri, match);
430 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
432 struct rt6_info *match, *rt0;
435 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
436 __func__, fn->leaf, oif);
440 fn->rr_ptr = rt0 = fn->leaf;
442 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
445 (strict & RT6_LOOKUP_F_REACHABLE)) {
446 struct rt6_info *next = rt0->dst.rt6_next;
448 /* no entries matched; do round-robin */
449 if (!next || next->rt6i_metric != rt0->rt6i_metric)
456 RT6_TRACE("%s() => %p\n",
459 net = dev_net(rt0->rt6i_dev);
460 return match ? match : net->ipv6.ip6_null_entry;
463 #ifdef CONFIG_IPV6_ROUTE_INFO
464 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
465 struct in6_addr *gwaddr)
467 struct net *net = dev_net(dev);
468 struct route_info *rinfo = (struct route_info *) opt;
469 struct in6_addr prefix_buf, *prefix;
471 unsigned long lifetime;
474 if (len < sizeof(struct route_info)) {
478 /* Sanity check for prefix_len and length */
479 if (rinfo->length > 3) {
481 } else if (rinfo->prefix_len > 128) {
483 } else if (rinfo->prefix_len > 64) {
484 if (rinfo->length < 2) {
487 } else if (rinfo->prefix_len > 0) {
488 if (rinfo->length < 1) {
493 pref = rinfo->route_pref;
494 if (pref == ICMPV6_ROUTER_PREF_INVALID)
497 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
499 if (rinfo->length == 3)
500 prefix = (struct in6_addr *)rinfo->prefix;
502 /* this function is safe */
503 ipv6_addr_prefix(&prefix_buf,
504 (struct in6_addr *)rinfo->prefix,
506 prefix = &prefix_buf;
509 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
512 if (rt && !lifetime) {
518 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
521 rt->rt6i_flags = RTF_ROUTEINFO |
522 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
525 if (!addrconf_finite_timeout(lifetime)) {
526 rt->rt6i_flags &= ~RTF_EXPIRES;
528 rt->rt6i_expires = jiffies + HZ * lifetime;
529 rt->rt6i_flags |= RTF_EXPIRES;
531 dst_release(&rt->dst);
537 #define BACKTRACK(__net, saddr) \
539 if (rt == __net->ipv6.ip6_null_entry) { \
540 struct fib6_node *pn; \
542 if (fn->fn_flags & RTN_TL_ROOT) \
545 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
546 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
549 if (fn->fn_flags & RTN_RTINFO) \
555 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
556 struct fib6_table *table,
557 struct flowi *fl, int flags)
559 struct fib6_node *fn;
562 read_lock_bh(&table->tb6_lock);
563 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
566 rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags);
567 BACKTRACK(net, &fl->fl6_src);
569 dst_use(&rt->dst, jiffies);
570 read_unlock_bh(&table->tb6_lock);
575 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
576 const struct in6_addr *saddr, int oif, int strict)
582 struct dst_entry *dst;
583 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
586 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
587 flags |= RT6_LOOKUP_F_HAS_SADDR;
590 dst = fib6_rule_lookup(net, &fl, flags, ip6_pol_route_lookup);
592 return (struct rt6_info *) dst;
599 EXPORT_SYMBOL(rt6_lookup);
601 /* ip6_ins_rt is called with FREE table->tb6_lock.
602 It takes new route entry, the addition fails by any reason the
603 route is freed. In any case, if caller does not hold it, it may
607 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
610 struct fib6_table *table;
612 table = rt->rt6i_table;
613 write_lock_bh(&table->tb6_lock);
614 err = fib6_add(&table->tb6_root, rt, info);
615 write_unlock_bh(&table->tb6_lock);
620 int ip6_ins_rt(struct rt6_info *rt)
622 struct nl_info info = {
623 .nl_net = dev_net(rt->rt6i_dev),
625 return __ip6_ins_rt(rt, &info);
628 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
629 struct in6_addr *saddr)
637 rt = ip6_rt_copy(ort);
640 struct neighbour *neigh;
641 int attempts = !in_softirq();
643 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
644 if (rt->rt6i_dst.plen != 128 &&
645 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
646 rt->rt6i_flags |= RTF_ANYCAST;
647 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
650 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
651 rt->rt6i_dst.plen = 128;
652 rt->rt6i_flags |= RTF_CACHE;
653 rt->dst.flags |= DST_HOST;
655 #ifdef CONFIG_IPV6_SUBTREES
656 if (rt->rt6i_src.plen && saddr) {
657 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
658 rt->rt6i_src.plen = 128;
663 neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
665 struct net *net = dev_net(rt->rt6i_dev);
666 int saved_rt_min_interval =
667 net->ipv6.sysctl.ip6_rt_gc_min_interval;
668 int saved_rt_elasticity =
669 net->ipv6.sysctl.ip6_rt_gc_elasticity;
671 if (attempts-- > 0) {
672 net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
673 net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
675 ip6_dst_gc(&net->ipv6.ip6_dst_ops);
677 net->ipv6.sysctl.ip6_rt_gc_elasticity =
679 net->ipv6.sysctl.ip6_rt_gc_min_interval =
680 saved_rt_min_interval;
686 "ipv6: Neighbour table overflow.\n");
690 rt->rt6i_nexthop = neigh;
697 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
699 struct rt6_info *rt = ip6_rt_copy(ort);
701 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
702 rt->rt6i_dst.plen = 128;
703 rt->rt6i_flags |= RTF_CACHE;
704 rt->dst.flags |= DST_HOST;
705 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
710 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
711 struct flowi *fl, int flags)
713 struct fib6_node *fn;
714 struct rt6_info *rt, *nrt;
718 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
720 strict |= flags & RT6_LOOKUP_F_IFACE;
723 read_lock_bh(&table->tb6_lock);
726 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
729 rt = rt6_select(fn, oif, strict | reachable);
731 BACKTRACK(net, &fl->fl6_src);
732 if (rt == net->ipv6.ip6_null_entry ||
733 rt->rt6i_flags & RTF_CACHE)
737 read_unlock_bh(&table->tb6_lock);
739 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
740 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
742 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
744 dst_release(&rt->dst);
745 rt = nrt ? : net->ipv6.ip6_null_entry;
749 err = ip6_ins_rt(nrt);
758 * Race condition! In the gap, when table->tb6_lock was
759 * released someone could insert this route. Relookup.
761 dst_release(&rt->dst);
770 read_unlock_bh(&table->tb6_lock);
772 rt->dst.lastuse = jiffies;
778 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
779 struct flowi *fl, int flags)
781 return ip6_pol_route(net, table, fl->iif, fl, flags);
784 void ip6_route_input(struct sk_buff *skb)
786 struct ipv6hdr *iph = ipv6_hdr(skb);
787 struct net *net = dev_net(skb->dev);
788 int flags = RT6_LOOKUP_F_HAS_SADDR;
790 .iif = skb->dev->ifindex,
791 .fl6_dst = iph->daddr,
792 .fl6_src = iph->saddr,
793 .fl6_flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
795 .proto = iph->nexthdr,
798 if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG)
799 flags |= RT6_LOOKUP_F_IFACE;
801 skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));
804 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
805 struct flowi *fl, int flags)
807 return ip6_pol_route(net, table, fl->oif, fl, flags);
810 struct dst_entry * ip6_route_output(struct net *net, struct sock *sk,
815 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl->fl6_dst))
816 flags |= RT6_LOOKUP_F_IFACE;
818 if (!ipv6_addr_any(&fl->fl6_src))
819 flags |= RT6_LOOKUP_F_HAS_SADDR;
821 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
823 return fib6_rule_lookup(net, fl, flags, ip6_pol_route_output);
826 EXPORT_SYMBOL(ip6_route_output);
828 int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
830 struct rt6_info *ort = (struct rt6_info *) *dstp;
831 struct rt6_info *rt = (struct rt6_info *)
832 dst_alloc(&ip6_dst_blackhole_ops);
833 struct dst_entry *new = NULL;
838 atomic_set(&new->__refcnt, 1);
840 new->input = dst_discard;
841 new->output = dst_discard;
843 dst_copy_metrics(new, &ort->dst);
844 new->dev = ort->dst.dev;
847 rt->rt6i_idev = ort->rt6i_idev;
849 in6_dev_hold(rt->rt6i_idev);
850 rt->rt6i_expires = 0;
852 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
853 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
856 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
857 #ifdef CONFIG_IPV6_SUBTREES
858 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
866 return new ? 0 : -ENOMEM;
868 EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
871 * Destination cache support functions
874 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
878 rt = (struct rt6_info *) dst;
880 if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
886 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
888 struct rt6_info *rt = (struct rt6_info *) dst;
891 if (rt->rt6i_flags & RTF_CACHE) {
892 if (rt6_check_expired(rt)) {
904 static void ip6_link_failure(struct sk_buff *skb)
908 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
910 rt = (struct rt6_info *) skb_dst(skb);
912 if (rt->rt6i_flags&RTF_CACHE) {
913 dst_set_expires(&rt->dst, 0);
914 rt->rt6i_flags |= RTF_EXPIRES;
915 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
916 rt->rt6i_node->fn_sernum = -1;
920 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
922 struct rt6_info *rt6 = (struct rt6_info*)dst;
924 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
925 rt6->rt6i_flags |= RTF_MODIFIED;
926 if (mtu < IPV6_MIN_MTU) {
927 u32 features = dst_metric(dst, RTAX_FEATURES);
929 features |= RTAX_FEATURE_ALLFRAG;
930 dst_metric_set(dst, RTAX_FEATURES, features);
932 dst_metric_set(dst, RTAX_MTU, mtu);
933 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
937 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
939 struct net_device *dev = dst->dev;
940 unsigned int mtu = dst_mtu(dst);
941 struct net *net = dev_net(dev);
943 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
945 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
946 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
949 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
950 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
951 * IPV6_MAXPLEN is also valid and means: "any MSS,
952 * rely only on pmtu discovery"
954 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
959 static unsigned int ip6_default_mtu(const struct dst_entry *dst)
961 unsigned int mtu = IPV6_MIN_MTU;
962 struct inet6_dev *idev;
965 idev = __in6_dev_get(dst->dev);
967 mtu = idev->cnf.mtu6;
973 static struct dst_entry *icmp6_dst_gc_list;
974 static DEFINE_SPINLOCK(icmp6_dst_lock);
976 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
977 struct neighbour *neigh,
978 const struct in6_addr *addr)
981 struct inet6_dev *idev = in6_dev_get(dev);
982 struct net *net = dev_net(dev);
984 if (unlikely(idev == NULL))
987 rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
988 if (unlikely(rt == NULL)) {
997 neigh = ndisc_get_neigh(dev, addr);
1003 rt->rt6i_idev = idev;
1004 rt->rt6i_nexthop = neigh;
1005 atomic_set(&rt->dst.__refcnt, 1);
1006 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 255);
1007 rt->dst.output = ip6_output;
1009 #if 0 /* there's no chance to use these for ndisc */
1010 rt->dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
1013 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1014 rt->rt6i_dst.plen = 128;
1017 spin_lock_bh(&icmp6_dst_lock);
1018 rt->dst.next = icmp6_dst_gc_list;
1019 icmp6_dst_gc_list = &rt->dst;
1020 spin_unlock_bh(&icmp6_dst_lock);
1022 fib6_force_start_gc(net);
1028 int icmp6_dst_gc(void)
1030 struct dst_entry *dst, *next, **pprev;
1035 spin_lock_bh(&icmp6_dst_lock);
1036 pprev = &icmp6_dst_gc_list;
1038 while ((dst = *pprev) != NULL) {
1039 if (!atomic_read(&dst->__refcnt)) {
1048 spin_unlock_bh(&icmp6_dst_lock);
1053 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1056 struct dst_entry *dst, **pprev;
1058 spin_lock_bh(&icmp6_dst_lock);
1059 pprev = &icmp6_dst_gc_list;
1060 while ((dst = *pprev) != NULL) {
1061 struct rt6_info *rt = (struct rt6_info *) dst;
1062 if (func(rt, arg)) {
1069 spin_unlock_bh(&icmp6_dst_lock);
1072 static int ip6_dst_gc(struct dst_ops *ops)
1074 unsigned long now = jiffies;
1075 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1076 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1077 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1078 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1079 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1080 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1083 entries = dst_entries_get_fast(ops);
1084 if (time_after(rt_last_gc + rt_min_interval, now) &&
1085 entries <= rt_max_size)
1088 net->ipv6.ip6_rt_gc_expire++;
1089 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1090 net->ipv6.ip6_rt_last_gc = now;
1091 entries = dst_entries_get_slow(ops);
1092 if (entries < ops->gc_thresh)
1093 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1095 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1096 return entries > rt_max_size;
1099 /* Clean host part of a prefix. Not necessary in radix tree,
1100 but results in cleaner routing tables.
1102 Remove it only when all the things will work!
1105 int ip6_dst_hoplimit(struct dst_entry *dst)
1107 int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
1108 if (hoplimit == 0) {
1109 struct net_device *dev = dst->dev;
1110 struct inet6_dev *idev;
1113 idev = __in6_dev_get(dev);
1115 hoplimit = idev->cnf.hop_limit;
1117 hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
1122 EXPORT_SYMBOL(ip6_dst_hoplimit);
1128 int ip6_route_add(struct fib6_config *cfg)
1131 struct net *net = cfg->fc_nlinfo.nl_net;
1132 struct rt6_info *rt = NULL;
1133 struct net_device *dev = NULL;
1134 struct inet6_dev *idev = NULL;
1135 struct fib6_table *table;
1138 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1140 #ifndef CONFIG_IPV6_SUBTREES
1141 if (cfg->fc_src_len)
1144 if (cfg->fc_ifindex) {
1146 dev = dev_get_by_index(net, cfg->fc_ifindex);
1149 idev = in6_dev_get(dev);
1154 if (cfg->fc_metric == 0)
1155 cfg->fc_metric = IP6_RT_PRIO_USER;
1157 table = fib6_new_table(net, cfg->fc_table);
1158 if (table == NULL) {
1163 rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
1170 rt->dst.obsolete = -1;
1171 rt->rt6i_expires = (cfg->fc_flags & RTF_EXPIRES) ?
1172 jiffies + clock_t_to_jiffies(cfg->fc_expires) :
1175 if (cfg->fc_protocol == RTPROT_UNSPEC)
1176 cfg->fc_protocol = RTPROT_BOOT;
1177 rt->rt6i_protocol = cfg->fc_protocol;
1179 addr_type = ipv6_addr_type(&cfg->fc_dst);
1181 if (addr_type & IPV6_ADDR_MULTICAST)
1182 rt->dst.input = ip6_mc_input;
1183 else if (cfg->fc_flags & RTF_LOCAL)
1184 rt->dst.input = ip6_input;
1186 rt->dst.input = ip6_forward;
1188 rt->dst.output = ip6_output;
1190 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1191 rt->rt6i_dst.plen = cfg->fc_dst_len;
1192 if (rt->rt6i_dst.plen == 128)
1193 rt->dst.flags = DST_HOST;
1195 #ifdef CONFIG_IPV6_SUBTREES
1196 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1197 rt->rt6i_src.plen = cfg->fc_src_len;
1200 rt->rt6i_metric = cfg->fc_metric;
1202 /* We cannot add true routes via loopback here,
1203 they would result in kernel looping; promote them to reject routes
1205 if ((cfg->fc_flags & RTF_REJECT) ||
1206 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK)
1207 && !(cfg->fc_flags&RTF_LOCAL))) {
1208 /* hold loopback dev/idev if we haven't done so. */
1209 if (dev != net->loopback_dev) {
1214 dev = net->loopback_dev;
1216 idev = in6_dev_get(dev);
1222 rt->dst.output = ip6_pkt_discard_out;
1223 rt->dst.input = ip6_pkt_discard;
1224 rt->dst.error = -ENETUNREACH;
1225 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1229 if (cfg->fc_flags & RTF_GATEWAY) {
1230 struct in6_addr *gw_addr;
1233 gw_addr = &cfg->fc_gateway;
1234 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
1235 gwa_type = ipv6_addr_type(gw_addr);
1237 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1238 struct rt6_info *grt;
1240 /* IPv6 strictly inhibits using not link-local
1241 addresses as nexthop address.
1242 Otherwise, router will not able to send redirects.
1243 It is very good, but in some (rare!) circumstances
1244 (SIT, PtP, NBMA NOARP links) it is handy to allow
1245 some exceptions. --ANK
1248 if (!(gwa_type&IPV6_ADDR_UNICAST))
1251 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1253 err = -EHOSTUNREACH;
1257 if (dev != grt->rt6i_dev) {
1258 dst_release(&grt->dst);
1262 dev = grt->rt6i_dev;
1263 idev = grt->rt6i_idev;
1265 in6_dev_hold(grt->rt6i_idev);
1267 if (!(grt->rt6i_flags&RTF_GATEWAY))
1269 dst_release(&grt->dst);
1275 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1283 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1284 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1285 if (IS_ERR(rt->rt6i_nexthop)) {
1286 err = PTR_ERR(rt->rt6i_nexthop);
1287 rt->rt6i_nexthop = NULL;
1292 rt->rt6i_flags = cfg->fc_flags;
1299 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1300 int type = nla_type(nla);
1303 if (type > RTAX_MAX) {
1308 dst_metric_set(&rt->dst, type, nla_get_u32(nla));
1314 rt->rt6i_idev = idev;
1315 rt->rt6i_table = table;
1317 cfg->fc_nlinfo.nl_net = dev_net(dev);
1319 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1331 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1334 struct fib6_table *table;
1335 struct net *net = dev_net(rt->rt6i_dev);
1337 if (rt == net->ipv6.ip6_null_entry)
1340 table = rt->rt6i_table;
1341 write_lock_bh(&table->tb6_lock);
1343 err = fib6_del(rt, info);
1344 dst_release(&rt->dst);
1346 write_unlock_bh(&table->tb6_lock);
1351 int ip6_del_rt(struct rt6_info *rt)
1353 struct nl_info info = {
1354 .nl_net = dev_net(rt->rt6i_dev),
1356 return __ip6_del_rt(rt, &info);
1359 static int ip6_route_del(struct fib6_config *cfg)
1361 struct fib6_table *table;
1362 struct fib6_node *fn;
1363 struct rt6_info *rt;
1366 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1370 read_lock_bh(&table->tb6_lock);
1372 fn = fib6_locate(&table->tb6_root,
1373 &cfg->fc_dst, cfg->fc_dst_len,
1374 &cfg->fc_src, cfg->fc_src_len);
1377 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1378 if (cfg->fc_ifindex &&
1379 (rt->rt6i_dev == NULL ||
1380 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1382 if (cfg->fc_flags & RTF_GATEWAY &&
1383 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1385 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1388 read_unlock_bh(&table->tb6_lock);
1390 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1393 read_unlock_bh(&table->tb6_lock);
1401 struct ip6rd_flowi {
1403 struct in6_addr gateway;
1406 static struct rt6_info *__ip6_route_redirect(struct net *net,
1407 struct fib6_table *table,
1411 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1412 struct rt6_info *rt;
1413 struct fib6_node *fn;
1416 * Get the "current" route for this destination and
1417 * check if the redirect has come from approriate router.
1419 * RFC 2461 specifies that redirects should only be
1420 * accepted if they come from the nexthop to the target.
1421 * Due to the way the routes are chosen, this notion
1422 * is a bit fuzzy and one might need to check all possible
1426 read_lock_bh(&table->tb6_lock);
1427 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1429 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1431 * Current route is on-link; redirect is always invalid.
1433 * Seems, previous statement is not true. It could
1434 * be node, which looks for us as on-link (f.e. proxy ndisc)
1435 * But then router serving it might decide, that we should
1436 * know truth 8)8) --ANK (980726).
1438 if (rt6_check_expired(rt))
1440 if (!(rt->rt6i_flags & RTF_GATEWAY))
1442 if (fl->oif != rt->rt6i_dev->ifindex)
1444 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1450 rt = net->ipv6.ip6_null_entry;
1451 BACKTRACK(net, &fl->fl6_src);
1455 read_unlock_bh(&table->tb6_lock);
1460 static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1461 struct in6_addr *src,
1462 struct in6_addr *gateway,
1463 struct net_device *dev)
1465 int flags = RT6_LOOKUP_F_HAS_SADDR;
1466 struct net *net = dev_net(dev);
1467 struct ip6rd_flowi rdfl = {
1469 .oif = dev->ifindex,
1475 ipv6_addr_copy(&rdfl.gateway, gateway);
1477 if (rt6_need_strict(dest))
1478 flags |= RT6_LOOKUP_F_IFACE;
1480 return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,
1481 flags, __ip6_route_redirect);
1484 void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1485 struct in6_addr *saddr,
1486 struct neighbour *neigh, u8 *lladdr, int on_link)
1488 struct rt6_info *rt, *nrt = NULL;
1489 struct netevent_redirect netevent;
1490 struct net *net = dev_net(neigh->dev);
1492 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1494 if (rt == net->ipv6.ip6_null_entry) {
1495 if (net_ratelimit())
1496 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1497 "for redirect target\n");
1502 * We have finally decided to accept it.
1505 neigh_update(neigh, lladdr, NUD_STALE,
1506 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1507 NEIGH_UPDATE_F_OVERRIDE|
1508 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1509 NEIGH_UPDATE_F_ISROUTER))
1513 * Redirect received -> path was valid.
1514 * Look, redirects are sent only in response to data packets,
1515 * so that this nexthop apparently is reachable. --ANK
1517 dst_confirm(&rt->dst);
1519 /* Duplicate redirect: silently ignore. */
1520 if (neigh == rt->dst.neighbour)
1523 nrt = ip6_rt_copy(rt);
1527 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1529 nrt->rt6i_flags &= ~RTF_GATEWAY;
1531 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1532 nrt->rt6i_dst.plen = 128;
1533 nrt->dst.flags |= DST_HOST;
1535 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1536 nrt->rt6i_nexthop = neigh_clone(neigh);
1538 if (ip6_ins_rt(nrt))
1541 netevent.old = &rt->dst;
1542 netevent.new = &nrt->dst;
1543 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1545 if (rt->rt6i_flags&RTF_CACHE) {
1551 dst_release(&rt->dst);
1555 * Handle ICMP "packet too big" messages
1556 * i.e. Path MTU discovery
1559 static void rt6_do_pmtu_disc(struct in6_addr *daddr, struct in6_addr *saddr,
1560 struct net *net, u32 pmtu, int ifindex)
1562 struct rt6_info *rt, *nrt;
1565 rt = rt6_lookup(net, daddr, saddr, ifindex, 0);
1569 if (rt6_check_expired(rt)) {
1574 if (pmtu >= dst_mtu(&rt->dst))
1577 if (pmtu < IPV6_MIN_MTU) {
1579 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1580 * MTU (1280) and a fragment header should always be included
1581 * after a node receiving Too Big message reporting PMTU is
1582 * less than the IPv6 Minimum Link MTU.
1584 pmtu = IPV6_MIN_MTU;
1588 /* New mtu received -> path was valid.
1589 They are sent only in response to data packets,
1590 so that this nexthop apparently is reachable. --ANK
1592 dst_confirm(&rt->dst);
1594 /* Host route. If it is static, it would be better
1595 not to override it, but add new one, so that
1596 when cache entry will expire old pmtu
1597 would return automatically.
1599 if (rt->rt6i_flags & RTF_CACHE) {
1600 dst_metric_set(&rt->dst, RTAX_MTU, pmtu);
1602 u32 features = dst_metric(&rt->dst, RTAX_FEATURES);
1603 features |= RTAX_FEATURE_ALLFRAG;
1604 dst_metric_set(&rt->dst, RTAX_FEATURES, features);
1606 dst_set_expires(&rt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
1607 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1612 Two cases are possible:
1613 1. It is connected route. Action: COW
1614 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1616 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1617 nrt = rt6_alloc_cow(rt, daddr, saddr);
1619 nrt = rt6_alloc_clone(rt, daddr);
1622 dst_metric_set(&nrt->dst, RTAX_MTU, pmtu);
1624 u32 features = dst_metric(&nrt->dst, RTAX_FEATURES);
1625 features |= RTAX_FEATURE_ALLFRAG;
1626 dst_metric_set(&nrt->dst, RTAX_FEATURES, features);
1629 /* According to RFC 1981, detecting PMTU increase shouldn't be
1630 * happened within 5 mins, the recommended timer is 10 mins.
1631 * Here this route expiration time is set to ip6_rt_mtu_expires
1632 * which is 10 mins. After 10 mins the decreased pmtu is expired
1633 * and detecting PMTU increase will be automatically happened.
1635 dst_set_expires(&nrt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
1636 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1641 dst_release(&rt->dst);
1644 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1645 struct net_device *dev, u32 pmtu)
1647 struct net *net = dev_net(dev);
1650 * RFC 1981 states that a node "MUST reduce the size of the packets it
1651 * is sending along the path" that caused the Packet Too Big message.
1652 * Since it's not possible in the general case to determine which
1653 * interface was used to send the original packet, we update the MTU
1654 * on the interface that will be used to send future packets. We also
1655 * update the MTU on the interface that received the Packet Too Big in
1656 * case the original packet was forced out that interface with
1657 * SO_BINDTODEVICE or similar. This is the next best thing to the
1658 * correct behaviour, which would be to update the MTU on all
1661 rt6_do_pmtu_disc(daddr, saddr, net, pmtu, 0);
1662 rt6_do_pmtu_disc(daddr, saddr, net, pmtu, dev->ifindex);
1666 * Misc support functions
1669 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1671 struct net *net = dev_net(ort->rt6i_dev);
1672 struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
1675 rt->dst.input = ort->dst.input;
1676 rt->dst.output = ort->dst.output;
1678 dst_copy_metrics(&rt->dst, &ort->dst);
1679 rt->dst.error = ort->dst.error;
1680 rt->dst.dev = ort->dst.dev;
1682 dev_hold(rt->dst.dev);
1683 rt->rt6i_idev = ort->rt6i_idev;
1685 in6_dev_hold(rt->rt6i_idev);
1686 rt->dst.lastuse = jiffies;
1687 rt->rt6i_expires = 0;
1689 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1690 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1691 rt->rt6i_metric = 0;
1693 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1694 #ifdef CONFIG_IPV6_SUBTREES
1695 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1697 rt->rt6i_table = ort->rt6i_table;
1702 #ifdef CONFIG_IPV6_ROUTE_INFO
1703 static struct rt6_info *rt6_get_route_info(struct net *net,
1704 struct in6_addr *prefix, int prefixlen,
1705 struct in6_addr *gwaddr, int ifindex)
1707 struct fib6_node *fn;
1708 struct rt6_info *rt = NULL;
1709 struct fib6_table *table;
1711 table = fib6_get_table(net, RT6_TABLE_INFO);
1715 write_lock_bh(&table->tb6_lock);
1716 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1720 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1721 if (rt->rt6i_dev->ifindex != ifindex)
1723 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1725 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1731 write_unlock_bh(&table->tb6_lock);
1735 static struct rt6_info *rt6_add_route_info(struct net *net,
1736 struct in6_addr *prefix, int prefixlen,
1737 struct in6_addr *gwaddr, int ifindex,
1740 struct fib6_config cfg = {
1741 .fc_table = RT6_TABLE_INFO,
1742 .fc_metric = IP6_RT_PRIO_USER,
1743 .fc_ifindex = ifindex,
1744 .fc_dst_len = prefixlen,
1745 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1746 RTF_UP | RTF_PREF(pref),
1748 .fc_nlinfo.nlh = NULL,
1749 .fc_nlinfo.nl_net = net,
1752 ipv6_addr_copy(&cfg.fc_dst, prefix);
1753 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1755 /* We should treat it as a default route if prefix length is 0. */
1757 cfg.fc_flags |= RTF_DEFAULT;
1759 ip6_route_add(&cfg);
1761 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1765 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1767 struct rt6_info *rt;
1768 struct fib6_table *table;
1770 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1774 write_lock_bh(&table->tb6_lock);
1775 for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1776 if (dev == rt->rt6i_dev &&
1777 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1778 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1783 write_unlock_bh(&table->tb6_lock);
1787 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1788 struct net_device *dev,
1791 struct fib6_config cfg = {
1792 .fc_table = RT6_TABLE_DFLT,
1793 .fc_metric = IP6_RT_PRIO_USER,
1794 .fc_ifindex = dev->ifindex,
1795 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1796 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1798 .fc_nlinfo.nlh = NULL,
1799 .fc_nlinfo.nl_net = dev_net(dev),
1802 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1804 ip6_route_add(&cfg);
1806 return rt6_get_dflt_router(gwaddr, dev);
1809 void rt6_purge_dflt_routers(struct net *net)
1811 struct rt6_info *rt;
1812 struct fib6_table *table;
1814 /* NOTE: Keep consistent with rt6_get_dflt_router */
1815 table = fib6_get_table(net, RT6_TABLE_DFLT);
1820 read_lock_bh(&table->tb6_lock);
1821 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
1822 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1824 read_unlock_bh(&table->tb6_lock);
1829 read_unlock_bh(&table->tb6_lock);
1832 static void rtmsg_to_fib6_config(struct net *net,
1833 struct in6_rtmsg *rtmsg,
1834 struct fib6_config *cfg)
1836 memset(cfg, 0, sizeof(*cfg));
1838 cfg->fc_table = RT6_TABLE_MAIN;
1839 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1840 cfg->fc_metric = rtmsg->rtmsg_metric;
1841 cfg->fc_expires = rtmsg->rtmsg_info;
1842 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1843 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1844 cfg->fc_flags = rtmsg->rtmsg_flags;
1846 cfg->fc_nlinfo.nl_net = net;
1848 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1849 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1850 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1853 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1855 struct fib6_config cfg;
1856 struct in6_rtmsg rtmsg;
1860 case SIOCADDRT: /* Add a route */
1861 case SIOCDELRT: /* Delete a route */
1862 if (!capable(CAP_NET_ADMIN))
1864 err = copy_from_user(&rtmsg, arg,
1865 sizeof(struct in6_rtmsg));
1869 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
1874 err = ip6_route_add(&cfg);
1877 err = ip6_route_del(&cfg);
1891 * Drop the packet on the floor
1894 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1897 struct dst_entry *dst = skb_dst(skb);
1898 switch (ipstats_mib_noroutes) {
1899 case IPSTATS_MIB_INNOROUTES:
1900 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
1901 if (type == IPV6_ADDR_ANY) {
1902 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1903 IPSTATS_MIB_INADDRERRORS);
1907 case IPSTATS_MIB_OUTNOROUTES:
1908 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1909 ipstats_mib_noroutes);
1912 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
1917 static int ip6_pkt_discard(struct sk_buff *skb)
1919 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
1922 static int ip6_pkt_discard_out(struct sk_buff *skb)
1924 skb->dev = skb_dst(skb)->dev;
1925 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1928 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
1930 static int ip6_pkt_prohibit(struct sk_buff *skb)
1932 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
1935 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1937 skb->dev = skb_dst(skb)->dev;
1938 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
1944 * Allocate a dst for local (unicast / anycast) address.
1947 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1948 const struct in6_addr *addr,
1951 struct net *net = dev_net(idev->dev);
1952 struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
1953 struct neighbour *neigh;
1956 if (net_ratelimit())
1957 pr_warning("IPv6: Maximum number of routes reached,"
1958 " consider increasing route/max_size.\n");
1959 return ERR_PTR(-ENOMEM);
1962 dev_hold(net->loopback_dev);
1965 rt->dst.flags = DST_HOST;
1966 rt->dst.input = ip6_input;
1967 rt->dst.output = ip6_output;
1968 rt->rt6i_dev = net->loopback_dev;
1969 rt->rt6i_idev = idev;
1970 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, -1);
1971 rt->dst.obsolete = -1;
1973 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1975 rt->rt6i_flags |= RTF_ANYCAST;
1977 rt->rt6i_flags |= RTF_LOCAL;
1978 neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1979 if (IS_ERR(neigh)) {
1982 /* We are casting this because that is the return
1983 * value type. But an errno encoded pointer is the
1984 * same regardless of the underlying pointer type,
1985 * and that's what we are returning. So this is OK.
1987 return (struct rt6_info *) neigh;
1989 rt->rt6i_nexthop = neigh;
1991 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1992 rt->rt6i_dst.plen = 128;
1993 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
1995 atomic_set(&rt->dst.__refcnt, 1);
2000 struct arg_dev_net {
2001 struct net_device *dev;
2005 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2007 const struct arg_dev_net *adn = arg;
2008 const struct net_device *dev = adn->dev;
2010 if ((rt->rt6i_dev == dev || dev == NULL) &&
2011 rt != adn->net->ipv6.ip6_null_entry) {
2012 RT6_TRACE("deleted by ifdown %p\n", rt);
2018 void rt6_ifdown(struct net *net, struct net_device *dev)
2020 struct arg_dev_net adn = {
2025 fib6_clean_all(net, fib6_ifdown, 0, &adn);
2026 icmp6_clean_all(fib6_ifdown, &adn);
2029 struct rt6_mtu_change_arg
2031 struct net_device *dev;
2035 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2037 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2038 struct inet6_dev *idev;
2040 /* In IPv6 pmtu discovery is not optional,
2041 so that RTAX_MTU lock cannot disable it.
2042 We still use this lock to block changes
2043 caused by addrconf/ndisc.
2046 idev = __in6_dev_get(arg->dev);
2050 /* For administrative MTU increase, there is no way to discover
2051 IPv6 PMTU increase, so PMTU increase should be updated here.
2052 Since RFC 1981 doesn't include administrative MTU increase
2053 update PMTU increase is a MUST. (i.e. jumbo frame)
2056 If new MTU is less than route PMTU, this new MTU will be the
2057 lowest MTU in the path, update the route PMTU to reflect PMTU
2058 decreases; if new MTU is greater than route PMTU, and the
2059 old MTU is the lowest MTU in the path, update the route PMTU
2060 to reflect the increase. In this case if the other nodes' MTU
2061 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2064 if (rt->rt6i_dev == arg->dev &&
2065 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2066 (dst_mtu(&rt->dst) >= arg->mtu ||
2067 (dst_mtu(&rt->dst) < arg->mtu &&
2068 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2069 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2074 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
2076 struct rt6_mtu_change_arg arg = {
2081 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
2084 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2085 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2086 [RTA_OIF] = { .type = NLA_U32 },
2087 [RTA_IIF] = { .type = NLA_U32 },
2088 [RTA_PRIORITY] = { .type = NLA_U32 },
2089 [RTA_METRICS] = { .type = NLA_NESTED },
2092 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2093 struct fib6_config *cfg)
2096 struct nlattr *tb[RTA_MAX+1];
2099 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2104 rtm = nlmsg_data(nlh);
2105 memset(cfg, 0, sizeof(*cfg));
2107 cfg->fc_table = rtm->rtm_table;
2108 cfg->fc_dst_len = rtm->rtm_dst_len;
2109 cfg->fc_src_len = rtm->rtm_src_len;
2110 cfg->fc_flags = RTF_UP;
2111 cfg->fc_protocol = rtm->rtm_protocol;
2113 if (rtm->rtm_type == RTN_UNREACHABLE)
2114 cfg->fc_flags |= RTF_REJECT;
2116 if (rtm->rtm_type == RTN_LOCAL)
2117 cfg->fc_flags |= RTF_LOCAL;
2119 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
2120 cfg->fc_nlinfo.nlh = nlh;
2121 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2123 if (tb[RTA_GATEWAY]) {
2124 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2125 cfg->fc_flags |= RTF_GATEWAY;
2129 int plen = (rtm->rtm_dst_len + 7) >> 3;
2131 if (nla_len(tb[RTA_DST]) < plen)
2134 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2138 int plen = (rtm->rtm_src_len + 7) >> 3;
2140 if (nla_len(tb[RTA_SRC]) < plen)
2143 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2147 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2149 if (tb[RTA_PRIORITY])
2150 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2152 if (tb[RTA_METRICS]) {
2153 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2154 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2158 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2165 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2167 struct fib6_config cfg;
2170 err = rtm_to_fib6_config(skb, nlh, &cfg);
2174 return ip6_route_del(&cfg);
2177 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2179 struct fib6_config cfg;
2182 err = rtm_to_fib6_config(skb, nlh, &cfg);
2186 return ip6_route_add(&cfg);
2189 static inline size_t rt6_nlmsg_size(void)
2191 return NLMSG_ALIGN(sizeof(struct rtmsg))
2192 + nla_total_size(16) /* RTA_SRC */
2193 + nla_total_size(16) /* RTA_DST */
2194 + nla_total_size(16) /* RTA_GATEWAY */
2195 + nla_total_size(16) /* RTA_PREFSRC */
2196 + nla_total_size(4) /* RTA_TABLE */
2197 + nla_total_size(4) /* RTA_IIF */
2198 + nla_total_size(4) /* RTA_OIF */
2199 + nla_total_size(4) /* RTA_PRIORITY */
2200 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2201 + nla_total_size(sizeof(struct rta_cacheinfo));
2204 static int rt6_fill_node(struct net *net,
2205 struct sk_buff *skb, struct rt6_info *rt,
2206 struct in6_addr *dst, struct in6_addr *src,
2207 int iif, int type, u32 pid, u32 seq,
2208 int prefix, int nowait, unsigned int flags)
2211 struct nlmsghdr *nlh;
2215 if (prefix) { /* user wants prefix routes only */
2216 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2217 /* success since this is not a prefix route */
2222 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2226 rtm = nlmsg_data(nlh);
2227 rtm->rtm_family = AF_INET6;
2228 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2229 rtm->rtm_src_len = rt->rt6i_src.plen;
2232 table = rt->rt6i_table->tb6_id;
2234 table = RT6_TABLE_UNSPEC;
2235 rtm->rtm_table = table;
2236 NLA_PUT_U32(skb, RTA_TABLE, table);
2237 if (rt->rt6i_flags&RTF_REJECT)
2238 rtm->rtm_type = RTN_UNREACHABLE;
2239 else if (rt->rt6i_flags&RTF_LOCAL)
2240 rtm->rtm_type = RTN_LOCAL;
2241 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2242 rtm->rtm_type = RTN_LOCAL;
2244 rtm->rtm_type = RTN_UNICAST;
2246 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2247 rtm->rtm_protocol = rt->rt6i_protocol;
2248 if (rt->rt6i_flags&RTF_DYNAMIC)
2249 rtm->rtm_protocol = RTPROT_REDIRECT;
2250 else if (rt->rt6i_flags & RTF_ADDRCONF)
2251 rtm->rtm_protocol = RTPROT_KERNEL;
2252 else if (rt->rt6i_flags&RTF_DEFAULT)
2253 rtm->rtm_protocol = RTPROT_RA;
2255 if (rt->rt6i_flags&RTF_CACHE)
2256 rtm->rtm_flags |= RTM_F_CLONED;
2259 NLA_PUT(skb, RTA_DST, 16, dst);
2260 rtm->rtm_dst_len = 128;
2261 } else if (rtm->rtm_dst_len)
2262 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
2263 #ifdef CONFIG_IPV6_SUBTREES
2265 NLA_PUT(skb, RTA_SRC, 16, src);
2266 rtm->rtm_src_len = 128;
2267 } else if (rtm->rtm_src_len)
2268 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
2271 #ifdef CONFIG_IPV6_MROUTE
2272 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2273 int err = ip6mr_get_route(net, skb, rtm, nowait);
2278 goto nla_put_failure;
2280 if (err == -EMSGSIZE)
2281 goto nla_put_failure;
2286 NLA_PUT_U32(skb, RTA_IIF, iif);
2288 struct inet6_dev *idev = ip6_dst_idev(&rt->dst);
2289 struct in6_addr saddr_buf;
2290 if (ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2291 dst, 0, &saddr_buf) == 0)
2292 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
2295 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2296 goto nla_put_failure;
2298 if (rt->dst.neighbour)
2299 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->dst.neighbour->primary_key);
2302 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2304 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
2306 if (!(rt->rt6i_flags & RTF_EXPIRES))
2308 else if (rt->rt6i_expires - jiffies < INT_MAX)
2309 expires = rt->rt6i_expires - jiffies;
2313 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, 0, 0,
2314 expires, rt->dst.error) < 0)
2315 goto nla_put_failure;
2317 return nlmsg_end(skb, nlh);
2320 nlmsg_cancel(skb, nlh);
2324 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2326 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2329 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2330 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2331 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2335 return rt6_fill_node(arg->net,
2336 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2337 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
2338 prefix, 0, NLM_F_MULTI);
2341 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2343 struct net *net = sock_net(in_skb->sk);
2344 struct nlattr *tb[RTA_MAX+1];
2345 struct rt6_info *rt;
2346 struct sk_buff *skb;
2351 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2356 memset(&fl, 0, sizeof(fl));
2359 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2362 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2366 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2369 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2373 iif = nla_get_u32(tb[RTA_IIF]);
2376 fl.oif = nla_get_u32(tb[RTA_OIF]);
2379 struct net_device *dev;
2380 dev = __dev_get_by_index(net, iif);
2387 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2393 /* Reserve room for dummy headers, this skb can pass
2394 through good chunk of routing engine.
2396 skb_reset_mac_header(skb);
2397 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2399 rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl);
2400 skb_dst_set(skb, &rt->dst);
2402 err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
2403 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
2404 nlh->nlmsg_seq, 0, 0, 0);
2410 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
2415 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2417 struct sk_buff *skb;
2418 struct net *net = info->nl_net;
2423 seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;
2425 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2429 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2430 event, info->pid, seq, 0, 0, 0);
2432 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2433 WARN_ON(err == -EMSGSIZE);
2437 rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE,
2438 info->nlh, gfp_any());
2442 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2445 static int ip6_route_dev_notify(struct notifier_block *this,
2446 unsigned long event, void *data)
2448 struct net_device *dev = (struct net_device *)data;
2449 struct net *net = dev_net(dev);
2451 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2452 net->ipv6.ip6_null_entry->dst.dev = dev;
2453 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2454 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2455 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2456 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2457 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2458 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2469 #ifdef CONFIG_PROC_FS
2480 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2482 struct seq_file *m = p_arg;
2484 seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
2486 #ifdef CONFIG_IPV6_SUBTREES
2487 seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
2489 seq_puts(m, "00000000000000000000000000000000 00 ");
2492 if (rt->rt6i_nexthop) {
2493 seq_printf(m, "%pi6", rt->rt6i_nexthop->primary_key);
2495 seq_puts(m, "00000000000000000000000000000000");
2497 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2498 rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2499 rt->dst.__use, rt->rt6i_flags,
2500 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2504 static int ipv6_route_show(struct seq_file *m, void *v)
2506 struct net *net = (struct net *)m->private;
2507 fib6_clean_all(net, rt6_info_route, 0, m);
2511 static int ipv6_route_open(struct inode *inode, struct file *file)
2513 return single_open_net(inode, file, ipv6_route_show);
2516 static const struct file_operations ipv6_route_proc_fops = {
2517 .owner = THIS_MODULE,
2518 .open = ipv6_route_open,
2520 .llseek = seq_lseek,
2521 .release = single_release_net,
2524 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2526 struct net *net = (struct net *)seq->private;
2527 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2528 net->ipv6.rt6_stats->fib_nodes,
2529 net->ipv6.rt6_stats->fib_route_nodes,
2530 net->ipv6.rt6_stats->fib_rt_alloc,
2531 net->ipv6.rt6_stats->fib_rt_entries,
2532 net->ipv6.rt6_stats->fib_rt_cache,
2533 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2534 net->ipv6.rt6_stats->fib_discarded_routes);
2539 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2541 return single_open_net(inode, file, rt6_stats_seq_show);
2544 static const struct file_operations rt6_stats_seq_fops = {
2545 .owner = THIS_MODULE,
2546 .open = rt6_stats_seq_open,
2548 .llseek = seq_lseek,
2549 .release = single_release_net,
2551 #endif /* CONFIG_PROC_FS */
2553 #ifdef CONFIG_SYSCTL
2556 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
2557 void __user *buffer, size_t *lenp, loff_t *ppos)
2559 struct net *net = current->nsproxy->net_ns;
2560 int delay = net->ipv6.sysctl.flush_delay;
2562 proc_dointvec(ctl, write, buffer, lenp, ppos);
2563 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
2569 ctl_table ipv6_route_table_template[] = {
2571 .procname = "flush",
2572 .data = &init_net.ipv6.sysctl.flush_delay,
2573 .maxlen = sizeof(int),
2575 .proc_handler = ipv6_sysctl_rtcache_flush
2578 .procname = "gc_thresh",
2579 .data = &ip6_dst_ops_template.gc_thresh,
2580 .maxlen = sizeof(int),
2582 .proc_handler = proc_dointvec,
2585 .procname = "max_size",
2586 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
2587 .maxlen = sizeof(int),
2589 .proc_handler = proc_dointvec,
2592 .procname = "gc_min_interval",
2593 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2594 .maxlen = sizeof(int),
2596 .proc_handler = proc_dointvec_jiffies,
2599 .procname = "gc_timeout",
2600 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2601 .maxlen = sizeof(int),
2603 .proc_handler = proc_dointvec_jiffies,
2606 .procname = "gc_interval",
2607 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2608 .maxlen = sizeof(int),
2610 .proc_handler = proc_dointvec_jiffies,
2613 .procname = "gc_elasticity",
2614 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2615 .maxlen = sizeof(int),
2617 .proc_handler = proc_dointvec,
2620 .procname = "mtu_expires",
2621 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2622 .maxlen = sizeof(int),
2624 .proc_handler = proc_dointvec_jiffies,
2627 .procname = "min_adv_mss",
2628 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2629 .maxlen = sizeof(int),
2631 .proc_handler = proc_dointvec,
2634 .procname = "gc_min_interval_ms",
2635 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2636 .maxlen = sizeof(int),
2638 .proc_handler = proc_dointvec_ms_jiffies,
2643 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2645 struct ctl_table *table;
2647 table = kmemdup(ipv6_route_table_template,
2648 sizeof(ipv6_route_table_template),
2652 table[0].data = &net->ipv6.sysctl.flush_delay;
2653 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2654 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2655 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2656 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2657 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2658 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2659 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2660 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2661 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2668 static int __net_init ip6_route_net_init(struct net *net)
2672 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2673 sizeof(net->ipv6.ip6_dst_ops));
2675 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2676 goto out_ip6_dst_ops;
2678 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2679 sizeof(*net->ipv6.ip6_null_entry),
2681 if (!net->ipv6.ip6_null_entry)
2682 goto out_ip6_dst_entries;
2683 net->ipv6.ip6_null_entry->dst.path =
2684 (struct dst_entry *)net->ipv6.ip6_null_entry;
2685 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2686 dst_metric_set(&net->ipv6.ip6_null_entry->dst, RTAX_HOPLIMIT, 255);
2688 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2689 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2690 sizeof(*net->ipv6.ip6_prohibit_entry),
2692 if (!net->ipv6.ip6_prohibit_entry)
2693 goto out_ip6_null_entry;
2694 net->ipv6.ip6_prohibit_entry->dst.path =
2695 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
2696 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2697 dst_metric_set(&net->ipv6.ip6_prohibit_entry->dst, RTAX_HOPLIMIT, 255);
2699 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
2700 sizeof(*net->ipv6.ip6_blk_hole_entry),
2702 if (!net->ipv6.ip6_blk_hole_entry)
2703 goto out_ip6_prohibit_entry;
2704 net->ipv6.ip6_blk_hole_entry->dst.path =
2705 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
2706 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2707 dst_metric_set(&net->ipv6.ip6_blk_hole_entry->dst, RTAX_HOPLIMIT, 255);
2710 net->ipv6.sysctl.flush_delay = 0;
2711 net->ipv6.sysctl.ip6_rt_max_size = 4096;
2712 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
2713 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
2714 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
2715 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
2716 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
2717 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
2719 #ifdef CONFIG_PROC_FS
2720 proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
2721 proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2723 net->ipv6.ip6_rt_gc_expire = 30*HZ;
2729 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2730 out_ip6_prohibit_entry:
2731 kfree(net->ipv6.ip6_prohibit_entry);
2733 kfree(net->ipv6.ip6_null_entry);
2735 out_ip6_dst_entries:
2736 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
2741 static void __net_exit ip6_route_net_exit(struct net *net)
2743 #ifdef CONFIG_PROC_FS
2744 proc_net_remove(net, "ipv6_route");
2745 proc_net_remove(net, "rt6_stats");
2747 kfree(net->ipv6.ip6_null_entry);
2748 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2749 kfree(net->ipv6.ip6_prohibit_entry);
2750 kfree(net->ipv6.ip6_blk_hole_entry);
2752 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
2755 static struct pernet_operations ip6_route_net_ops = {
2756 .init = ip6_route_net_init,
2757 .exit = ip6_route_net_exit,
2760 static struct notifier_block ip6_route_dev_notifier = {
2761 .notifier_call = ip6_route_dev_notify,
2765 int __init ip6_route_init(void)
2770 ip6_dst_ops_template.kmem_cachep =
2771 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2772 SLAB_HWCACHE_ALIGN, NULL);
2773 if (!ip6_dst_ops_template.kmem_cachep)
2776 ret = dst_entries_init(&ip6_dst_blackhole_ops);
2778 goto out_kmem_cache;
2780 ret = register_pernet_subsys(&ip6_route_net_ops);
2782 goto out_dst_entries;
2784 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
2786 /* Registering of the loopback is done before this portion of code,
2787 * the loopback reference in rt6_info will not be taken, do it
2788 * manually for init_net */
2789 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
2790 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2791 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2792 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
2793 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2794 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
2795 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2799 goto out_register_subsys;
2805 ret = fib6_rules_init();
2810 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||
2811 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||
2812 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))
2813 goto fib6_rules_init;
2815 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
2817 goto fib6_rules_init;
2823 fib6_rules_cleanup();
2828 out_register_subsys:
2829 unregister_pernet_subsys(&ip6_route_net_ops);
2831 dst_entries_destroy(&ip6_dst_blackhole_ops);
2833 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
2837 void ip6_route_cleanup(void)
2839 unregister_netdevice_notifier(&ip6_route_dev_notifier);
2840 fib6_rules_cleanup();
2843 unregister_pernet_subsys(&ip6_route_net_ops);
2844 dst_entries_destroy(&ip6_dst_blackhole_ops);
2845 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);