2 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * $Id: route.c,v 1.56 2001/10/31 21:55:55 davem Exp $
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
18 * YOSHIFUJI Hideaki @USAGI
19 * reworked default router selection.
20 * - respect outgoing interface
21 * - select from (probably) reachable routers (i.e.
22 * routers in REACHABLE, STALE, DELAY or PROBE states).
23 * - always select the same router if it is (probably)
24 * reachable. otherwise, round-robin the list.
26 * Fixed routing subtrees.
29 #include <linux/capability.h>
30 #include <linux/errno.h>
31 #include <linux/types.h>
32 #include <linux/times.h>
33 #include <linux/socket.h>
34 #include <linux/sockios.h>
35 #include <linux/net.h>
36 #include <linux/route.h>
37 #include <linux/netdevice.h>
38 #include <linux/in6.h>
39 #include <linux/init.h>
40 #include <linux/if_arp.h>
41 #include <linux/proc_fs.h>
42 #include <linux/seq_file.h>
43 #include <net/net_namespace.h>
46 #include <net/ip6_fib.h>
47 #include <net/ip6_route.h>
48 #include <net/ndisc.h>
49 #include <net/addrconf.h>
51 #include <linux/rtnetlink.h>
54 #include <net/netevent.h>
55 #include <net/netlink.h>
57 #include <asm/uaccess.h>
60 #include <linux/sysctl.h>
63 /* Set to 3 to get tracing. */
67 #define RDBG(x) printk x
68 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
71 #define RT6_TRACE(x...) do { ; } while (0)
74 #define CLONE_OFFLINK_ROUTE 0
76 static int ip6_rt_max_size = 4096;
77 static int ip6_rt_gc_min_interval = HZ / 2;
78 static int ip6_rt_gc_timeout = 60*HZ;
79 int ip6_rt_gc_interval = 30*HZ;
80 static int ip6_rt_gc_elasticity = 9;
81 static int ip6_rt_mtu_expires = 10*60*HZ;
82 static int ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
84 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
85 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
86 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
87 static void ip6_dst_destroy(struct dst_entry *);
88 static void ip6_dst_ifdown(struct dst_entry *,
89 struct net_device *dev, int how);
90 static int ip6_dst_gc(void);
92 static int ip6_pkt_discard(struct sk_buff *skb);
93 static int ip6_pkt_discard_out(struct sk_buff *skb);
94 static void ip6_link_failure(struct sk_buff *skb);
95 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
97 #ifdef CONFIG_IPV6_ROUTE_INFO
98 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
99 struct in6_addr *gwaddr, int ifindex,
101 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
102 struct in6_addr *gwaddr, int ifindex);
105 static struct dst_ops ip6_dst_ops = {
107 .protocol = __constant_htons(ETH_P_IPV6),
110 .check = ip6_dst_check,
111 .destroy = ip6_dst_destroy,
112 .ifdown = ip6_dst_ifdown,
113 .negative_advice = ip6_negative_advice,
114 .link_failure = ip6_link_failure,
115 .update_pmtu = ip6_rt_update_pmtu,
116 .entry_size = sizeof(struct rt6_info),
119 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
123 static struct dst_ops ip6_dst_blackhole_ops = {
125 .protocol = __constant_htons(ETH_P_IPV6),
126 .destroy = ip6_dst_destroy,
127 .check = ip6_dst_check,
128 .update_pmtu = ip6_rt_blackhole_update_pmtu,
129 .entry_size = sizeof(struct rt6_info),
132 struct rt6_info ip6_null_entry = {
135 .__refcnt = ATOMIC_INIT(1),
138 .error = -ENETUNREACH,
139 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
140 .input = ip6_pkt_discard,
141 .output = ip6_pkt_discard_out,
143 .path = (struct dst_entry*)&ip6_null_entry,
146 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
147 .rt6i_metric = ~(u32) 0,
148 .rt6i_ref = ATOMIC_INIT(1),
151 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
153 static int ip6_pkt_prohibit(struct sk_buff *skb);
154 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
156 struct rt6_info ip6_prohibit_entry = {
159 .__refcnt = ATOMIC_INIT(1),
163 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
164 .input = ip6_pkt_prohibit,
165 .output = ip6_pkt_prohibit_out,
167 .path = (struct dst_entry*)&ip6_prohibit_entry,
170 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
171 .rt6i_metric = ~(u32) 0,
172 .rt6i_ref = ATOMIC_INIT(1),
175 struct rt6_info ip6_blk_hole_entry = {
178 .__refcnt = ATOMIC_INIT(1),
182 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
183 .input = dst_discard,
184 .output = dst_discard,
186 .path = (struct dst_entry*)&ip6_blk_hole_entry,
189 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
190 .rt6i_metric = ~(u32) 0,
191 .rt6i_ref = ATOMIC_INIT(1),
196 /* allocate dst with ip6_dst_ops */
197 static __inline__ struct rt6_info *ip6_dst_alloc(void)
199 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
202 static void ip6_dst_destroy(struct dst_entry *dst)
204 struct rt6_info *rt = (struct rt6_info *)dst;
205 struct inet6_dev *idev = rt->rt6i_idev;
208 rt->rt6i_idev = NULL;
213 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
216 struct rt6_info *rt = (struct rt6_info *)dst;
217 struct inet6_dev *idev = rt->rt6i_idev;
219 if (dev != init_net.loopback_dev && idev != NULL && idev->dev == dev) {
220 struct inet6_dev *loopback_idev = in6_dev_get(init_net.loopback_dev);
221 if (loopback_idev != NULL) {
222 rt->rt6i_idev = loopback_idev;
228 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
230 return (rt->rt6i_flags & RTF_EXPIRES &&
231 time_after(jiffies, rt->rt6i_expires));
234 static inline int rt6_need_strict(struct in6_addr *daddr)
236 return (ipv6_addr_type(daddr) &
237 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL));
241 * Route lookup. Any table->tb6_lock is implied.
244 static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
248 struct rt6_info *local = NULL;
249 struct rt6_info *sprt;
252 for (sprt = rt; sprt; sprt = sprt->u.dst.rt6_next) {
253 struct net_device *dev = sprt->rt6i_dev;
254 if (dev->ifindex == oif)
256 if (dev->flags & IFF_LOOPBACK) {
257 if (sprt->rt6i_idev == NULL ||
258 sprt->rt6i_idev->dev->ifindex != oif) {
261 if (local && (!oif ||
262 local->rt6i_idev->dev->ifindex == oif))
273 return &ip6_null_entry;
278 #ifdef CONFIG_IPV6_ROUTER_PREF
279 static void rt6_probe(struct rt6_info *rt)
281 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
283 * Okay, this does not seem to be appropriate
284 * for now, however, we need to check if it
285 * is really so; aka Router Reachability Probing.
287 * Router Reachability Probe MUST be rate-limited
288 * to no more than one per minute.
290 if (!neigh || (neigh->nud_state & NUD_VALID))
292 read_lock_bh(&neigh->lock);
293 if (!(neigh->nud_state & NUD_VALID) &&
294 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
295 struct in6_addr mcaddr;
296 struct in6_addr *target;
298 neigh->updated = jiffies;
299 read_unlock_bh(&neigh->lock);
301 target = (struct in6_addr *)&neigh->primary_key;
302 addrconf_addr_solict_mult(target, &mcaddr);
303 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
305 read_unlock_bh(&neigh->lock);
308 static inline void rt6_probe(struct rt6_info *rt)
315 * Default Router Selection (RFC 2461 6.3.6)
317 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
319 struct net_device *dev = rt->rt6i_dev;
320 if (!oif || dev->ifindex == oif)
322 if ((dev->flags & IFF_LOOPBACK) &&
323 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
328 static inline int rt6_check_neigh(struct rt6_info *rt)
330 struct neighbour *neigh = rt->rt6i_nexthop;
332 if (rt->rt6i_flags & RTF_NONEXTHOP ||
333 !(rt->rt6i_flags & RTF_GATEWAY))
336 read_lock_bh(&neigh->lock);
337 if (neigh->nud_state & NUD_VALID)
339 #ifdef CONFIG_IPV6_ROUTER_PREF
340 else if (neigh->nud_state & NUD_FAILED)
345 read_unlock_bh(&neigh->lock);
351 static int rt6_score_route(struct rt6_info *rt, int oif,
356 m = rt6_check_dev(rt, oif);
357 if (!m && (strict & RT6_LOOKUP_F_IFACE))
359 #ifdef CONFIG_IPV6_ROUTER_PREF
360 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
362 n = rt6_check_neigh(rt);
363 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
368 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
369 int *mpri, struct rt6_info *match)
373 if (rt6_check_expired(rt))
376 m = rt6_score_route(rt, oif, strict);
381 if (strict & RT6_LOOKUP_F_REACHABLE)
385 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
393 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
394 struct rt6_info *rr_head,
395 u32 metric, int oif, int strict)
397 struct rt6_info *rt, *match;
401 for (rt = rr_head; rt && rt->rt6i_metric == metric;
402 rt = rt->u.dst.rt6_next)
403 match = find_match(rt, oif, strict, &mpri, match);
404 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
405 rt = rt->u.dst.rt6_next)
406 match = find_match(rt, oif, strict, &mpri, match);
411 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
413 struct rt6_info *match, *rt0;
415 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
416 __FUNCTION__, fn->leaf, oif);
420 fn->rr_ptr = rt0 = fn->leaf;
422 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
425 (strict & RT6_LOOKUP_F_REACHABLE)) {
426 struct rt6_info *next = rt0->u.dst.rt6_next;
428 /* no entries matched; do round-robin */
429 if (!next || next->rt6i_metric != rt0->rt6i_metric)
436 RT6_TRACE("%s() => %p\n",
437 __FUNCTION__, match);
439 return (match ? match : &ip6_null_entry);
442 #ifdef CONFIG_IPV6_ROUTE_INFO
443 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
444 struct in6_addr *gwaddr)
446 struct route_info *rinfo = (struct route_info *) opt;
447 struct in6_addr prefix_buf, *prefix;
452 if (len < sizeof(struct route_info)) {
456 /* Sanity check for prefix_len and length */
457 if (rinfo->length > 3) {
459 } else if (rinfo->prefix_len > 128) {
461 } else if (rinfo->prefix_len > 64) {
462 if (rinfo->length < 2) {
465 } else if (rinfo->prefix_len > 0) {
466 if (rinfo->length < 1) {
471 pref = rinfo->route_pref;
472 if (pref == ICMPV6_ROUTER_PREF_INVALID)
473 pref = ICMPV6_ROUTER_PREF_MEDIUM;
475 lifetime = ntohl(rinfo->lifetime);
476 if (lifetime == 0xffffffff) {
478 } else if (lifetime > 0x7fffffff/HZ) {
479 /* Avoid arithmetic overflow */
480 lifetime = 0x7fffffff/HZ - 1;
483 if (rinfo->length == 3)
484 prefix = (struct in6_addr *)rinfo->prefix;
486 /* this function is safe */
487 ipv6_addr_prefix(&prefix_buf,
488 (struct in6_addr *)rinfo->prefix,
490 prefix = &prefix_buf;
493 rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
495 if (rt && !lifetime) {
501 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
504 rt->rt6i_flags = RTF_ROUTEINFO |
505 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
508 if (lifetime == 0xffffffff) {
509 rt->rt6i_flags &= ~RTF_EXPIRES;
511 rt->rt6i_expires = jiffies + HZ * lifetime;
512 rt->rt6i_flags |= RTF_EXPIRES;
514 dst_release(&rt->u.dst);
520 #define BACKTRACK(saddr) \
522 if (rt == &ip6_null_entry) { \
523 struct fib6_node *pn; \
525 if (fn->fn_flags & RTN_TL_ROOT) \
528 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
529 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
532 if (fn->fn_flags & RTN_RTINFO) \
538 static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
539 struct flowi *fl, int flags)
541 struct fib6_node *fn;
544 read_lock_bh(&table->tb6_lock);
545 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
548 rt = rt6_device_match(rt, fl->oif, flags);
549 BACKTRACK(&fl->fl6_src);
551 dst_use(&rt->u.dst, jiffies);
552 read_unlock_bh(&table->tb6_lock);
557 struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
568 struct dst_entry *dst;
569 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
572 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
573 flags |= RT6_LOOKUP_F_HAS_SADDR;
576 dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_lookup);
578 return (struct rt6_info *) dst;
585 EXPORT_SYMBOL(rt6_lookup);
587 /* ip6_ins_rt is called with FREE table->tb6_lock.
588 It takes new route entry, the addition fails by any reason the
589 route is freed. In any case, if caller does not hold it, it may
593 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
596 struct fib6_table *table;
598 table = rt->rt6i_table;
599 write_lock_bh(&table->tb6_lock);
600 err = fib6_add(&table->tb6_root, rt, info);
601 write_unlock_bh(&table->tb6_lock);
606 int ip6_ins_rt(struct rt6_info *rt)
608 return __ip6_ins_rt(rt, NULL);
611 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
612 struct in6_addr *saddr)
620 rt = ip6_rt_copy(ort);
623 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
624 if (rt->rt6i_dst.plen != 128 &&
625 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
626 rt->rt6i_flags |= RTF_ANYCAST;
627 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
630 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
631 rt->rt6i_dst.plen = 128;
632 rt->rt6i_flags |= RTF_CACHE;
633 rt->u.dst.flags |= DST_HOST;
635 #ifdef CONFIG_IPV6_SUBTREES
636 if (rt->rt6i_src.plen && saddr) {
637 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
638 rt->rt6i_src.plen = 128;
642 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
649 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
651 struct rt6_info *rt = ip6_rt_copy(ort);
653 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
654 rt->rt6i_dst.plen = 128;
655 rt->rt6i_flags |= RTF_CACHE;
656 rt->u.dst.flags |= DST_HOST;
657 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
662 static struct rt6_info *ip6_pol_route(struct fib6_table *table, int oif,
663 struct flowi *fl, int flags)
665 struct fib6_node *fn;
666 struct rt6_info *rt, *nrt;
670 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
672 strict |= flags & RT6_LOOKUP_F_IFACE;
675 read_lock_bh(&table->tb6_lock);
678 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
681 rt = rt6_select(fn, oif, strict | reachable);
682 BACKTRACK(&fl->fl6_src);
683 if (rt == &ip6_null_entry ||
684 rt->rt6i_flags & RTF_CACHE)
687 dst_hold(&rt->u.dst);
688 read_unlock_bh(&table->tb6_lock);
690 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
691 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
693 #if CLONE_OFFLINK_ROUTE
694 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
700 dst_release(&rt->u.dst);
701 rt = nrt ? : &ip6_null_entry;
703 dst_hold(&rt->u.dst);
705 err = ip6_ins_rt(nrt);
714 * Race condition! In the gap, when table->tb6_lock was
715 * released someone could insert this route. Relookup.
717 dst_release(&rt->u.dst);
725 dst_hold(&rt->u.dst);
726 read_unlock_bh(&table->tb6_lock);
728 rt->u.dst.lastuse = jiffies;
734 static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
735 struct flowi *fl, int flags)
737 return ip6_pol_route(table, fl->iif, fl, flags);
740 void ip6_route_input(struct sk_buff *skb)
742 struct ipv6hdr *iph = ipv6_hdr(skb);
743 int flags = RT6_LOOKUP_F_HAS_SADDR;
745 .iif = skb->dev->ifindex,
750 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
754 .proto = iph->nexthdr,
757 if (rt6_need_strict(&iph->daddr))
758 flags |= RT6_LOOKUP_F_IFACE;
760 skb->dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_input);
763 static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
764 struct flowi *fl, int flags)
766 return ip6_pol_route(table, fl->oif, fl, flags);
769 struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
773 if (rt6_need_strict(&fl->fl6_dst))
774 flags |= RT6_LOOKUP_F_IFACE;
776 if (!ipv6_addr_any(&fl->fl6_src))
777 flags |= RT6_LOOKUP_F_HAS_SADDR;
779 return fib6_rule_lookup(fl, flags, ip6_pol_route_output);
782 EXPORT_SYMBOL(ip6_route_output);
784 int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
786 struct rt6_info *ort = (struct rt6_info *) *dstp;
787 struct rt6_info *rt = (struct rt6_info *)
788 dst_alloc(&ip6_dst_blackhole_ops);
789 struct dst_entry *new = NULL;
794 atomic_set(&new->__refcnt, 1);
796 new->input = dst_discard;
797 new->output = dst_discard;
799 memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
800 new->dev = ort->u.dst.dev;
803 rt->rt6i_idev = ort->rt6i_idev;
805 in6_dev_hold(rt->rt6i_idev);
806 rt->rt6i_expires = 0;
808 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
809 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
812 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
813 #ifdef CONFIG_IPV6_SUBTREES
814 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
822 return (new ? 0 : -ENOMEM);
824 EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
827 * Destination cache support functions
830 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
834 rt = (struct rt6_info *) dst;
836 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
842 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
844 struct rt6_info *rt = (struct rt6_info *) dst;
847 if (rt->rt6i_flags & RTF_CACHE)
855 static void ip6_link_failure(struct sk_buff *skb)
859 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
861 rt = (struct rt6_info *) skb->dst;
863 if (rt->rt6i_flags&RTF_CACHE) {
864 dst_set_expires(&rt->u.dst, 0);
865 rt->rt6i_flags |= RTF_EXPIRES;
866 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
867 rt->rt6i_node->fn_sernum = -1;
871 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
873 struct rt6_info *rt6 = (struct rt6_info*)dst;
875 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
876 rt6->rt6i_flags |= RTF_MODIFIED;
877 if (mtu < IPV6_MIN_MTU) {
879 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
881 dst->metrics[RTAX_MTU-1] = mtu;
882 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
886 static int ipv6_get_mtu(struct net_device *dev);
888 static inline unsigned int ipv6_advmss(unsigned int mtu)
890 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
892 if (mtu < ip6_rt_min_advmss)
893 mtu = ip6_rt_min_advmss;
896 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
897 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
898 * IPV6_MAXPLEN is also valid and means: "any MSS,
899 * rely only on pmtu discovery"
901 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
906 static struct dst_entry *ndisc_dst_gc_list;
907 static DEFINE_SPINLOCK(ndisc_lock);
909 struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
910 struct neighbour *neigh,
911 struct in6_addr *addr,
912 int (*output)(struct sk_buff *))
915 struct inet6_dev *idev = in6_dev_get(dev);
917 if (unlikely(idev == NULL))
920 rt = ip6_dst_alloc();
921 if (unlikely(rt == NULL)) {
930 neigh = ndisc_get_neigh(dev, addr);
933 rt->rt6i_idev = idev;
934 rt->rt6i_nexthop = neigh;
935 atomic_set(&rt->u.dst.__refcnt, 1);
936 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
937 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
938 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
939 rt->u.dst.output = output;
941 #if 0 /* there's no chance to use these for ndisc */
942 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
945 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
946 rt->rt6i_dst.plen = 128;
949 spin_lock_bh(&ndisc_lock);
950 rt->u.dst.next = ndisc_dst_gc_list;
951 ndisc_dst_gc_list = &rt->u.dst;
952 spin_unlock_bh(&ndisc_lock);
954 fib6_force_start_gc();
960 int ndisc_dst_gc(int *more)
962 struct dst_entry *dst, *next, **pprev;
968 spin_lock_bh(&ndisc_lock);
969 pprev = &ndisc_dst_gc_list;
971 while ((dst = *pprev) != NULL) {
972 if (!atomic_read(&dst->__refcnt)) {
982 spin_unlock_bh(&ndisc_lock);
987 static int ip6_dst_gc(void)
989 static unsigned expire = 30*HZ;
990 static unsigned long last_gc;
991 unsigned long now = jiffies;
993 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
994 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
1000 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
1001 expire = ip6_rt_gc_timeout>>1;
1004 expire -= expire>>ip6_rt_gc_elasticity;
1005 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
1008 /* Clean host part of a prefix. Not necessary in radix tree,
1009 but results in cleaner routing tables.
1011 Remove it only when all the things will work!
1014 static int ipv6_get_mtu(struct net_device *dev)
1016 int mtu = IPV6_MIN_MTU;
1017 struct inet6_dev *idev;
1019 idev = in6_dev_get(dev);
1021 mtu = idev->cnf.mtu6;
1027 int ipv6_get_hoplimit(struct net_device *dev)
1029 int hoplimit = ipv6_devconf.hop_limit;
1030 struct inet6_dev *idev;
1032 idev = in6_dev_get(dev);
1034 hoplimit = idev->cnf.hop_limit;
1044 int ip6_route_add(struct fib6_config *cfg)
1047 struct rt6_info *rt = NULL;
1048 struct net_device *dev = NULL;
1049 struct inet6_dev *idev = NULL;
1050 struct fib6_table *table;
1053 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1055 #ifndef CONFIG_IPV6_SUBTREES
1056 if (cfg->fc_src_len)
1059 if (cfg->fc_ifindex) {
1061 dev = dev_get_by_index(&init_net, cfg->fc_ifindex);
1064 idev = in6_dev_get(dev);
1069 if (cfg->fc_metric == 0)
1070 cfg->fc_metric = IP6_RT_PRIO_USER;
1072 table = fib6_new_table(cfg->fc_table);
1073 if (table == NULL) {
1078 rt = ip6_dst_alloc();
1085 rt->u.dst.obsolete = -1;
1086 rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
1088 if (cfg->fc_protocol == RTPROT_UNSPEC)
1089 cfg->fc_protocol = RTPROT_BOOT;
1090 rt->rt6i_protocol = cfg->fc_protocol;
1092 addr_type = ipv6_addr_type(&cfg->fc_dst);
1094 if (addr_type & IPV6_ADDR_MULTICAST)
1095 rt->u.dst.input = ip6_mc_input;
1097 rt->u.dst.input = ip6_forward;
1099 rt->u.dst.output = ip6_output;
1101 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1102 rt->rt6i_dst.plen = cfg->fc_dst_len;
1103 if (rt->rt6i_dst.plen == 128)
1104 rt->u.dst.flags = DST_HOST;
1106 #ifdef CONFIG_IPV6_SUBTREES
1107 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1108 rt->rt6i_src.plen = cfg->fc_src_len;
1111 rt->rt6i_metric = cfg->fc_metric;
1113 /* We cannot add true routes via loopback here,
1114 they would result in kernel looping; promote them to reject routes
1116 if ((cfg->fc_flags & RTF_REJECT) ||
1117 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1118 /* hold loopback dev/idev if we haven't done so. */
1119 if (dev != init_net.loopback_dev) {
1124 dev = init_net.loopback_dev;
1126 idev = in6_dev_get(dev);
1132 rt->u.dst.output = ip6_pkt_discard_out;
1133 rt->u.dst.input = ip6_pkt_discard;
1134 rt->u.dst.error = -ENETUNREACH;
1135 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1139 if (cfg->fc_flags & RTF_GATEWAY) {
1140 struct in6_addr *gw_addr;
1143 gw_addr = &cfg->fc_gateway;
1144 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
1145 gwa_type = ipv6_addr_type(gw_addr);
1147 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1148 struct rt6_info *grt;
1150 /* IPv6 strictly inhibits using not link-local
1151 addresses as nexthop address.
1152 Otherwise, router will not able to send redirects.
1153 It is very good, but in some (rare!) circumstances
1154 (SIT, PtP, NBMA NOARP links) it is handy to allow
1155 some exceptions. --ANK
1158 if (!(gwa_type&IPV6_ADDR_UNICAST))
1161 grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
1163 err = -EHOSTUNREACH;
1167 if (dev != grt->rt6i_dev) {
1168 dst_release(&grt->u.dst);
1172 dev = grt->rt6i_dev;
1173 idev = grt->rt6i_idev;
1175 in6_dev_hold(grt->rt6i_idev);
1177 if (!(grt->rt6i_flags&RTF_GATEWAY))
1179 dst_release(&grt->u.dst);
1185 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1193 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1194 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1195 if (IS_ERR(rt->rt6i_nexthop)) {
1196 err = PTR_ERR(rt->rt6i_nexthop);
1197 rt->rt6i_nexthop = NULL;
1202 rt->rt6i_flags = cfg->fc_flags;
1209 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1210 int type = nla_type(nla);
1213 if (type > RTAX_MAX) {
1218 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
1223 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1224 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1225 if (!rt->u.dst.metrics[RTAX_MTU-1])
1226 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1227 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1228 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1229 rt->u.dst.dev = dev;
1230 rt->rt6i_idev = idev;
1231 rt->rt6i_table = table;
1232 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1240 dst_free(&rt->u.dst);
1244 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1247 struct fib6_table *table;
1249 if (rt == &ip6_null_entry)
1252 table = rt->rt6i_table;
1253 write_lock_bh(&table->tb6_lock);
1255 err = fib6_del(rt, info);
1256 dst_release(&rt->u.dst);
1258 write_unlock_bh(&table->tb6_lock);
1263 int ip6_del_rt(struct rt6_info *rt)
1265 return __ip6_del_rt(rt, NULL);
1268 static int ip6_route_del(struct fib6_config *cfg)
1270 struct fib6_table *table;
1271 struct fib6_node *fn;
1272 struct rt6_info *rt;
1275 table = fib6_get_table(cfg->fc_table);
1279 read_lock_bh(&table->tb6_lock);
1281 fn = fib6_locate(&table->tb6_root,
1282 &cfg->fc_dst, cfg->fc_dst_len,
1283 &cfg->fc_src, cfg->fc_src_len);
1286 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1287 if (cfg->fc_ifindex &&
1288 (rt->rt6i_dev == NULL ||
1289 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1291 if (cfg->fc_flags & RTF_GATEWAY &&
1292 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1294 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1296 dst_hold(&rt->u.dst);
1297 read_unlock_bh(&table->tb6_lock);
1299 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1302 read_unlock_bh(&table->tb6_lock);
1310 struct ip6rd_flowi {
1312 struct in6_addr gateway;
1315 static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1319 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1320 struct rt6_info *rt;
1321 struct fib6_node *fn;
1324 * Get the "current" route for this destination and
1325 * check if the redirect has come from approriate router.
1327 * RFC 2461 specifies that redirects should only be
1328 * accepted if they come from the nexthop to the target.
1329 * Due to the way the routes are chosen, this notion
1330 * is a bit fuzzy and one might need to check all possible
1334 read_lock_bh(&table->tb6_lock);
1335 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1337 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1339 * Current route is on-link; redirect is always invalid.
1341 * Seems, previous statement is not true. It could
1342 * be node, which looks for us as on-link (f.e. proxy ndisc)
1343 * But then router serving it might decide, that we should
1344 * know truth 8)8) --ANK (980726).
1346 if (rt6_check_expired(rt))
1348 if (!(rt->rt6i_flags & RTF_GATEWAY))
1350 if (fl->oif != rt->rt6i_dev->ifindex)
1352 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1358 rt = &ip6_null_entry;
1359 BACKTRACK(&fl->fl6_src);
1361 dst_hold(&rt->u.dst);
1363 read_unlock_bh(&table->tb6_lock);
1368 static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1369 struct in6_addr *src,
1370 struct in6_addr *gateway,
1371 struct net_device *dev)
1373 int flags = RT6_LOOKUP_F_HAS_SADDR;
1374 struct ip6rd_flowi rdfl = {
1376 .oif = dev->ifindex,
1384 .gateway = *gateway,
1387 if (rt6_need_strict(dest))
1388 flags |= RT6_LOOKUP_F_IFACE;
1390 return (struct rt6_info *)fib6_rule_lookup((struct flowi *)&rdfl, flags, __ip6_route_redirect);
1393 void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1394 struct in6_addr *saddr,
1395 struct neighbour *neigh, u8 *lladdr, int on_link)
1397 struct rt6_info *rt, *nrt = NULL;
1398 struct netevent_redirect netevent;
1400 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1402 if (rt == &ip6_null_entry) {
1403 if (net_ratelimit())
1404 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1405 "for redirect target\n");
1410 * We have finally decided to accept it.
1413 neigh_update(neigh, lladdr, NUD_STALE,
1414 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1415 NEIGH_UPDATE_F_OVERRIDE|
1416 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1417 NEIGH_UPDATE_F_ISROUTER))
1421 * Redirect received -> path was valid.
1422 * Look, redirects are sent only in response to data packets,
1423 * so that this nexthop apparently is reachable. --ANK
1425 dst_confirm(&rt->u.dst);
1427 /* Duplicate redirect: silently ignore. */
1428 if (neigh == rt->u.dst.neighbour)
1431 nrt = ip6_rt_copy(rt);
1435 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1437 nrt->rt6i_flags &= ~RTF_GATEWAY;
1439 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1440 nrt->rt6i_dst.plen = 128;
1441 nrt->u.dst.flags |= DST_HOST;
1443 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1444 nrt->rt6i_nexthop = neigh_clone(neigh);
1445 /* Reset pmtu, it may be better */
1446 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1447 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1449 if (ip6_ins_rt(nrt))
1452 netevent.old = &rt->u.dst;
1453 netevent.new = &nrt->u.dst;
1454 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1456 if (rt->rt6i_flags&RTF_CACHE) {
1462 dst_release(&rt->u.dst);
1467 * Handle ICMP "packet too big" messages
1468 * i.e. Path MTU discovery
1471 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1472 struct net_device *dev, u32 pmtu)
1474 struct rt6_info *rt, *nrt;
1477 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1481 if (pmtu >= dst_mtu(&rt->u.dst))
1484 if (pmtu < IPV6_MIN_MTU) {
1486 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1487 * MTU (1280) and a fragment header should always be included
1488 * after a node receiving Too Big message reporting PMTU is
1489 * less than the IPv6 Minimum Link MTU.
1491 pmtu = IPV6_MIN_MTU;
1495 /* New mtu received -> path was valid.
1496 They are sent only in response to data packets,
1497 so that this nexthop apparently is reachable. --ANK
1499 dst_confirm(&rt->u.dst);
1501 /* Host route. If it is static, it would be better
1502 not to override it, but add new one, so that
1503 when cache entry will expire old pmtu
1504 would return automatically.
1506 if (rt->rt6i_flags & RTF_CACHE) {
1507 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1509 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1510 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1511 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1516 Two cases are possible:
1517 1. It is connected route. Action: COW
1518 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1520 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1521 nrt = rt6_alloc_cow(rt, daddr, saddr);
1523 nrt = rt6_alloc_clone(rt, daddr);
1526 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1528 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1530 /* According to RFC 1981, detecting PMTU increase shouldn't be
1531 * happened within 5 mins, the recommended timer is 10 mins.
1532 * Here this route expiration time is set to ip6_rt_mtu_expires
1533 * which is 10 mins. After 10 mins the decreased pmtu is expired
1534 * and detecting PMTU increase will be automatically happened.
1536 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1537 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1542 dst_release(&rt->u.dst);
1546 * Misc support functions
1549 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1551 struct rt6_info *rt = ip6_dst_alloc();
1554 rt->u.dst.input = ort->u.dst.input;
1555 rt->u.dst.output = ort->u.dst.output;
1557 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
1558 rt->u.dst.error = ort->u.dst.error;
1559 rt->u.dst.dev = ort->u.dst.dev;
1561 dev_hold(rt->u.dst.dev);
1562 rt->rt6i_idev = ort->rt6i_idev;
1564 in6_dev_hold(rt->rt6i_idev);
1565 rt->u.dst.lastuse = jiffies;
1566 rt->rt6i_expires = 0;
1568 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1569 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1570 rt->rt6i_metric = 0;
1572 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1573 #ifdef CONFIG_IPV6_SUBTREES
1574 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1576 rt->rt6i_table = ort->rt6i_table;
1581 #ifdef CONFIG_IPV6_ROUTE_INFO
1582 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1583 struct in6_addr *gwaddr, int ifindex)
1585 struct fib6_node *fn;
1586 struct rt6_info *rt = NULL;
1587 struct fib6_table *table;
1589 table = fib6_get_table(RT6_TABLE_INFO);
1593 write_lock_bh(&table->tb6_lock);
1594 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1598 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1599 if (rt->rt6i_dev->ifindex != ifindex)
1601 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1603 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1605 dst_hold(&rt->u.dst);
1609 write_unlock_bh(&table->tb6_lock);
1613 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1614 struct in6_addr *gwaddr, int ifindex,
1617 struct fib6_config cfg = {
1618 .fc_table = RT6_TABLE_INFO,
1620 .fc_ifindex = ifindex,
1621 .fc_dst_len = prefixlen,
1622 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1623 RTF_UP | RTF_PREF(pref),
1626 ipv6_addr_copy(&cfg.fc_dst, prefix);
1627 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1629 /* We should treat it as a default route if prefix length is 0. */
1631 cfg.fc_flags |= RTF_DEFAULT;
1633 ip6_route_add(&cfg);
1635 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1639 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1641 struct rt6_info *rt;
1642 struct fib6_table *table;
1644 table = fib6_get_table(RT6_TABLE_DFLT);
1648 write_lock_bh(&table->tb6_lock);
1649 for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
1650 if (dev == rt->rt6i_dev &&
1651 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1652 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1656 dst_hold(&rt->u.dst);
1657 write_unlock_bh(&table->tb6_lock);
1661 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1662 struct net_device *dev,
1665 struct fib6_config cfg = {
1666 .fc_table = RT6_TABLE_DFLT,
1668 .fc_ifindex = dev->ifindex,
1669 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1670 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1673 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1675 ip6_route_add(&cfg);
1677 return rt6_get_dflt_router(gwaddr, dev);
1680 void rt6_purge_dflt_routers(void)
1682 struct rt6_info *rt;
1683 struct fib6_table *table;
1685 /* NOTE: Keep consistent with rt6_get_dflt_router */
1686 table = fib6_get_table(RT6_TABLE_DFLT);
1691 read_lock_bh(&table->tb6_lock);
1692 for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
1693 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1694 dst_hold(&rt->u.dst);
1695 read_unlock_bh(&table->tb6_lock);
1700 read_unlock_bh(&table->tb6_lock);
1703 static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1704 struct fib6_config *cfg)
1706 memset(cfg, 0, sizeof(*cfg));
1708 cfg->fc_table = RT6_TABLE_MAIN;
1709 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1710 cfg->fc_metric = rtmsg->rtmsg_metric;
1711 cfg->fc_expires = rtmsg->rtmsg_info;
1712 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1713 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1714 cfg->fc_flags = rtmsg->rtmsg_flags;
1716 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1717 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1718 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1721 int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1723 struct fib6_config cfg;
1724 struct in6_rtmsg rtmsg;
1728 case SIOCADDRT: /* Add a route */
1729 case SIOCDELRT: /* Delete a route */
1730 if (!capable(CAP_NET_ADMIN))
1732 err = copy_from_user(&rtmsg, arg,
1733 sizeof(struct in6_rtmsg));
1737 rtmsg_to_fib6_config(&rtmsg, &cfg);
1742 err = ip6_route_add(&cfg);
1745 err = ip6_route_del(&cfg);
1759 * Drop the packet on the floor
1762 static inline int ip6_pkt_drop(struct sk_buff *skb, int code,
1763 int ipstats_mib_noroutes)
1766 switch (ipstats_mib_noroutes) {
1767 case IPSTATS_MIB_INNOROUTES:
1768 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
1769 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED) {
1770 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
1774 case IPSTATS_MIB_OUTNOROUTES:
1775 IP6_INC_STATS(ip6_dst_idev(skb->dst), ipstats_mib_noroutes);
1778 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
1783 static int ip6_pkt_discard(struct sk_buff *skb)
1785 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
1788 static int ip6_pkt_discard_out(struct sk_buff *skb)
1790 skb->dev = skb->dst->dev;
1791 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1794 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
1796 static int ip6_pkt_prohibit(struct sk_buff *skb)
1798 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
1801 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1803 skb->dev = skb->dst->dev;
1804 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
1810 * Allocate a dst for local (unicast / anycast) address.
1813 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1814 const struct in6_addr *addr,
1817 struct rt6_info *rt = ip6_dst_alloc();
1820 return ERR_PTR(-ENOMEM);
1822 dev_hold(init_net.loopback_dev);
1825 rt->u.dst.flags = DST_HOST;
1826 rt->u.dst.input = ip6_input;
1827 rt->u.dst.output = ip6_output;
1828 rt->rt6i_dev = init_net.loopback_dev;
1829 rt->rt6i_idev = idev;
1830 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1831 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1832 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1833 rt->u.dst.obsolete = -1;
1835 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1837 rt->rt6i_flags |= RTF_ANYCAST;
1839 rt->rt6i_flags |= RTF_LOCAL;
1840 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1841 if (rt->rt6i_nexthop == NULL) {
1842 dst_free(&rt->u.dst);
1843 return ERR_PTR(-ENOMEM);
1846 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1847 rt->rt6i_dst.plen = 128;
1848 rt->rt6i_table = fib6_get_table(RT6_TABLE_LOCAL);
1850 atomic_set(&rt->u.dst.__refcnt, 1);
1855 static int fib6_ifdown(struct rt6_info *rt, void *arg)
1857 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1858 rt != &ip6_null_entry) {
1859 RT6_TRACE("deleted by ifdown %p\n", rt);
1865 void rt6_ifdown(struct net_device *dev)
1867 fib6_clean_all(fib6_ifdown, 0, dev);
1870 struct rt6_mtu_change_arg
1872 struct net_device *dev;
1876 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1878 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1879 struct inet6_dev *idev;
1881 /* In IPv6 pmtu discovery is not optional,
1882 so that RTAX_MTU lock cannot disable it.
1883 We still use this lock to block changes
1884 caused by addrconf/ndisc.
1887 idev = __in6_dev_get(arg->dev);
1891 /* For administrative MTU increase, there is no way to discover
1892 IPv6 PMTU increase, so PMTU increase should be updated here.
1893 Since RFC 1981 doesn't include administrative MTU increase
1894 update PMTU increase is a MUST. (i.e. jumbo frame)
1897 If new MTU is less than route PMTU, this new MTU will be the
1898 lowest MTU in the path, update the route PMTU to reflect PMTU
1899 decreases; if new MTU is greater than route PMTU, and the
1900 old MTU is the lowest MTU in the path, update the route PMTU
1901 to reflect the increase. In this case if the other nodes' MTU
1902 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1905 if (rt->rt6i_dev == arg->dev &&
1906 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1907 (dst_mtu(&rt->u.dst) > arg->mtu ||
1908 (dst_mtu(&rt->u.dst) < arg->mtu &&
1909 dst_mtu(&rt->u.dst) == idev->cnf.mtu6))) {
1910 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1911 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1916 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1918 struct rt6_mtu_change_arg arg = {
1923 fib6_clean_all(rt6_mtu_change_route, 0, &arg);
1926 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
1927 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
1928 [RTA_OIF] = { .type = NLA_U32 },
1929 [RTA_IIF] = { .type = NLA_U32 },
1930 [RTA_PRIORITY] = { .type = NLA_U32 },
1931 [RTA_METRICS] = { .type = NLA_NESTED },
1934 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1935 struct fib6_config *cfg)
1938 struct nlattr *tb[RTA_MAX+1];
1941 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1946 rtm = nlmsg_data(nlh);
1947 memset(cfg, 0, sizeof(*cfg));
1949 cfg->fc_table = rtm->rtm_table;
1950 cfg->fc_dst_len = rtm->rtm_dst_len;
1951 cfg->fc_src_len = rtm->rtm_src_len;
1952 cfg->fc_flags = RTF_UP;
1953 cfg->fc_protocol = rtm->rtm_protocol;
1955 if (rtm->rtm_type == RTN_UNREACHABLE)
1956 cfg->fc_flags |= RTF_REJECT;
1958 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1959 cfg->fc_nlinfo.nlh = nlh;
1961 if (tb[RTA_GATEWAY]) {
1962 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1963 cfg->fc_flags |= RTF_GATEWAY;
1967 int plen = (rtm->rtm_dst_len + 7) >> 3;
1969 if (nla_len(tb[RTA_DST]) < plen)
1972 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1976 int plen = (rtm->rtm_src_len + 7) >> 3;
1978 if (nla_len(tb[RTA_SRC]) < plen)
1981 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1985 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1987 if (tb[RTA_PRIORITY])
1988 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
1990 if (tb[RTA_METRICS]) {
1991 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
1992 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1996 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2003 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2005 struct fib6_config cfg;
2008 err = rtm_to_fib6_config(skb, nlh, &cfg);
2012 return ip6_route_del(&cfg);
2015 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2017 struct fib6_config cfg;
2020 err = rtm_to_fib6_config(skb, nlh, &cfg);
2024 return ip6_route_add(&cfg);
2027 static inline size_t rt6_nlmsg_size(void)
2029 return NLMSG_ALIGN(sizeof(struct rtmsg))
2030 + nla_total_size(16) /* RTA_SRC */
2031 + nla_total_size(16) /* RTA_DST */
2032 + nla_total_size(16) /* RTA_GATEWAY */
2033 + nla_total_size(16) /* RTA_PREFSRC */
2034 + nla_total_size(4) /* RTA_TABLE */
2035 + nla_total_size(4) /* RTA_IIF */
2036 + nla_total_size(4) /* RTA_OIF */
2037 + nla_total_size(4) /* RTA_PRIORITY */
2038 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2039 + nla_total_size(sizeof(struct rta_cacheinfo));
2042 static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
2043 struct in6_addr *dst, struct in6_addr *src,
2044 int iif, int type, u32 pid, u32 seq,
2045 int prefix, unsigned int flags)
2048 struct nlmsghdr *nlh;
2052 if (prefix) { /* user wants prefix routes only */
2053 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2054 /* success since this is not a prefix route */
2059 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2063 rtm = nlmsg_data(nlh);
2064 rtm->rtm_family = AF_INET6;
2065 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2066 rtm->rtm_src_len = rt->rt6i_src.plen;
2069 table = rt->rt6i_table->tb6_id;
2071 table = RT6_TABLE_UNSPEC;
2072 rtm->rtm_table = table;
2073 NLA_PUT_U32(skb, RTA_TABLE, table);
2074 if (rt->rt6i_flags&RTF_REJECT)
2075 rtm->rtm_type = RTN_UNREACHABLE;
2076 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2077 rtm->rtm_type = RTN_LOCAL;
2079 rtm->rtm_type = RTN_UNICAST;
2081 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2082 rtm->rtm_protocol = rt->rt6i_protocol;
2083 if (rt->rt6i_flags&RTF_DYNAMIC)
2084 rtm->rtm_protocol = RTPROT_REDIRECT;
2085 else if (rt->rt6i_flags & RTF_ADDRCONF)
2086 rtm->rtm_protocol = RTPROT_KERNEL;
2087 else if (rt->rt6i_flags&RTF_DEFAULT)
2088 rtm->rtm_protocol = RTPROT_RA;
2090 if (rt->rt6i_flags&RTF_CACHE)
2091 rtm->rtm_flags |= RTM_F_CLONED;
2094 NLA_PUT(skb, RTA_DST, 16, dst);
2095 rtm->rtm_dst_len = 128;
2096 } else if (rtm->rtm_dst_len)
2097 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
2098 #ifdef CONFIG_IPV6_SUBTREES
2100 NLA_PUT(skb, RTA_SRC, 16, src);
2101 rtm->rtm_src_len = 128;
2102 } else if (rtm->rtm_src_len)
2103 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
2106 NLA_PUT_U32(skb, RTA_IIF, iif);
2108 struct in6_addr saddr_buf;
2109 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
2110 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
2113 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2114 goto nla_put_failure;
2116 if (rt->u.dst.neighbour)
2117 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2120 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2122 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
2124 expires = rt->rt6i_expires ? rt->rt6i_expires - jiffies : 0;
2125 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2126 expires, rt->u.dst.error) < 0)
2127 goto nla_put_failure;
2129 return nlmsg_end(skb, nlh);
2132 nlmsg_cancel(skb, nlh);
2136 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2138 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2141 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2142 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2143 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2147 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2148 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
2149 prefix, NLM_F_MULTI);
2152 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2154 struct nlattr *tb[RTA_MAX+1];
2155 struct rt6_info *rt;
2156 struct sk_buff *skb;
2161 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2166 memset(&fl, 0, sizeof(fl));
2169 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2172 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2176 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2179 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2183 iif = nla_get_u32(tb[RTA_IIF]);
2186 fl.oif = nla_get_u32(tb[RTA_OIF]);
2189 struct net_device *dev;
2190 dev = __dev_get_by_index(&init_net, iif);
2197 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2203 /* Reserve room for dummy headers, this skb can pass
2204 through good chunk of routing engine.
2206 skb_reset_mac_header(skb);
2207 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2209 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
2210 skb->dst = &rt->u.dst;
2212 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
2213 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
2214 nlh->nlmsg_seq, 0, 0);
2220 err = rtnl_unicast(skb, NETLINK_CB(in_skb).pid);
2225 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2227 struct sk_buff *skb;
2228 u32 pid = 0, seq = 0;
2229 struct nlmsghdr *nlh = NULL;
2236 seq = nlh->nlmsg_seq;
2239 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2243 err = rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0);
2245 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2246 WARN_ON(err == -EMSGSIZE);
2250 err = rtnl_notify(skb, pid, RTNLGRP_IPV6_ROUTE, nlh, gfp_any());
2253 rtnl_set_sk_err(RTNLGRP_IPV6_ROUTE, err);
2260 #ifdef CONFIG_PROC_FS
2262 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2273 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2275 struct seq_file *m = p_arg;
2277 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_dst.addr),
2280 #ifdef CONFIG_IPV6_SUBTREES
2281 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_src.addr),
2284 seq_puts(m, "00000000000000000000000000000000 00 ");
2287 if (rt->rt6i_nexthop) {
2288 seq_printf(m, NIP6_SEQFMT,
2289 NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
2291 seq_puts(m, "00000000000000000000000000000000");
2293 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2294 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2295 rt->u.dst.__use, rt->rt6i_flags,
2296 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2300 static int ipv6_route_show(struct seq_file *m, void *v)
2302 fib6_clean_all(rt6_info_route, 0, m);
2306 static int ipv6_route_open(struct inode *inode, struct file *file)
2308 return single_open(file, ipv6_route_show, NULL);
2311 static const struct file_operations ipv6_route_proc_fops = {
2312 .owner = THIS_MODULE,
2313 .open = ipv6_route_open,
2315 .llseek = seq_lseek,
2316 .release = single_release,
2319 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2321 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2322 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2323 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2324 rt6_stats.fib_rt_cache,
2325 atomic_read(&ip6_dst_ops.entries),
2326 rt6_stats.fib_discarded_routes);
2331 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2333 return single_open(file, rt6_stats_seq_show, NULL);
2336 static const struct file_operations rt6_stats_seq_fops = {
2337 .owner = THIS_MODULE,
2338 .open = rt6_stats_seq_open,
2340 .llseek = seq_lseek,
2341 .release = single_release,
2343 #endif /* CONFIG_PROC_FS */
2345 #ifdef CONFIG_SYSCTL
2347 static int flush_delay;
2350 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2351 void __user *buffer, size_t *lenp, loff_t *ppos)
2354 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2355 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2361 ctl_table ipv6_route_table[] = {
2363 .procname = "flush",
2364 .data = &flush_delay,
2365 .maxlen = sizeof(int),
2367 .proc_handler = &ipv6_sysctl_rtcache_flush
2370 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2371 .procname = "gc_thresh",
2372 .data = &ip6_dst_ops.gc_thresh,
2373 .maxlen = sizeof(int),
2375 .proc_handler = &proc_dointvec,
2378 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2379 .procname = "max_size",
2380 .data = &ip6_rt_max_size,
2381 .maxlen = sizeof(int),
2383 .proc_handler = &proc_dointvec,
2386 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2387 .procname = "gc_min_interval",
2388 .data = &ip6_rt_gc_min_interval,
2389 .maxlen = sizeof(int),
2391 .proc_handler = &proc_dointvec_jiffies,
2392 .strategy = &sysctl_jiffies,
2395 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2396 .procname = "gc_timeout",
2397 .data = &ip6_rt_gc_timeout,
2398 .maxlen = sizeof(int),
2400 .proc_handler = &proc_dointvec_jiffies,
2401 .strategy = &sysctl_jiffies,
2404 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2405 .procname = "gc_interval",
2406 .data = &ip6_rt_gc_interval,
2407 .maxlen = sizeof(int),
2409 .proc_handler = &proc_dointvec_jiffies,
2410 .strategy = &sysctl_jiffies,
2413 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2414 .procname = "gc_elasticity",
2415 .data = &ip6_rt_gc_elasticity,
2416 .maxlen = sizeof(int),
2418 .proc_handler = &proc_dointvec_jiffies,
2419 .strategy = &sysctl_jiffies,
2422 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2423 .procname = "mtu_expires",
2424 .data = &ip6_rt_mtu_expires,
2425 .maxlen = sizeof(int),
2427 .proc_handler = &proc_dointvec_jiffies,
2428 .strategy = &sysctl_jiffies,
2431 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2432 .procname = "min_adv_mss",
2433 .data = &ip6_rt_min_advmss,
2434 .maxlen = sizeof(int),
2436 .proc_handler = &proc_dointvec_jiffies,
2437 .strategy = &sysctl_jiffies,
2440 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2441 .procname = "gc_min_interval_ms",
2442 .data = &ip6_rt_gc_min_interval,
2443 .maxlen = sizeof(int),
2445 .proc_handler = &proc_dointvec_ms_jiffies,
2446 .strategy = &sysctl_ms_jiffies,
2453 void __init ip6_route_init(void)
2455 ip6_dst_ops.kmem_cachep =
2456 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2457 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2458 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops.kmem_cachep;
2461 proc_net_fops_create(&init_net, "ipv6_route", 0, &ipv6_route_proc_fops);
2462 proc_net_fops_create(&init_net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2466 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2470 __rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL);
2471 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL);
2472 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL);
2475 void ip6_route_cleanup(void)
2477 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2478 fib6_rules_cleanup();
2480 #ifdef CONFIG_PROC_FS
2481 proc_net_remove(&init_net, "ipv6_route");
2482 proc_net_remove(&init_net, "rt6_stats");
2489 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);