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 .local_out = ip6_local_out,
117 .entry_size = sizeof(struct rt6_info),
120 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
124 static struct dst_ops ip6_dst_blackhole_ops = {
126 .protocol = __constant_htons(ETH_P_IPV6),
127 .destroy = ip6_dst_destroy,
128 .check = ip6_dst_check,
129 .update_pmtu = ip6_rt_blackhole_update_pmtu,
130 .entry_size = sizeof(struct rt6_info),
133 struct rt6_info ip6_null_entry = {
136 .__refcnt = ATOMIC_INIT(1),
139 .error = -ENETUNREACH,
140 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
141 .input = ip6_pkt_discard,
142 .output = ip6_pkt_discard_out,
144 .path = (struct dst_entry*)&ip6_null_entry,
147 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
148 .rt6i_metric = ~(u32) 0,
149 .rt6i_ref = ATOMIC_INIT(1),
152 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
154 static int ip6_pkt_prohibit(struct sk_buff *skb);
155 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
157 struct rt6_info ip6_prohibit_entry = {
160 .__refcnt = ATOMIC_INIT(1),
164 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
165 .input = ip6_pkt_prohibit,
166 .output = ip6_pkt_prohibit_out,
168 .path = (struct dst_entry*)&ip6_prohibit_entry,
171 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
172 .rt6i_metric = ~(u32) 0,
173 .rt6i_ref = ATOMIC_INIT(1),
176 struct rt6_info ip6_blk_hole_entry = {
179 .__refcnt = ATOMIC_INIT(1),
183 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
184 .input = dst_discard,
185 .output = dst_discard,
187 .path = (struct dst_entry*)&ip6_blk_hole_entry,
190 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
191 .rt6i_metric = ~(u32) 0,
192 .rt6i_ref = ATOMIC_INIT(1),
197 /* allocate dst with ip6_dst_ops */
198 static __inline__ struct rt6_info *ip6_dst_alloc(void)
200 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
203 static void ip6_dst_destroy(struct dst_entry *dst)
205 struct rt6_info *rt = (struct rt6_info *)dst;
206 struct inet6_dev *idev = rt->rt6i_idev;
209 rt->rt6i_idev = NULL;
214 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
217 struct rt6_info *rt = (struct rt6_info *)dst;
218 struct inet6_dev *idev = rt->rt6i_idev;
220 if (dev != init_net.loopback_dev && idev != NULL && idev->dev == dev) {
221 struct inet6_dev *loopback_idev = in6_dev_get(init_net.loopback_dev);
222 if (loopback_idev != NULL) {
223 rt->rt6i_idev = loopback_idev;
229 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
231 return (rt->rt6i_flags & RTF_EXPIRES &&
232 time_after(jiffies, rt->rt6i_expires));
235 static inline int rt6_need_strict(struct in6_addr *daddr)
237 return (ipv6_addr_type(daddr) &
238 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL));
242 * Route lookup. Any table->tb6_lock is implied.
245 static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
249 struct rt6_info *local = NULL;
250 struct rt6_info *sprt;
253 for (sprt = rt; sprt; sprt = sprt->u.dst.rt6_next) {
254 struct net_device *dev = sprt->rt6i_dev;
255 if (dev->ifindex == oif)
257 if (dev->flags & IFF_LOOPBACK) {
258 if (sprt->rt6i_idev == NULL ||
259 sprt->rt6i_idev->dev->ifindex != oif) {
262 if (local && (!oif ||
263 local->rt6i_idev->dev->ifindex == oif))
274 return &ip6_null_entry;
279 #ifdef CONFIG_IPV6_ROUTER_PREF
280 static void rt6_probe(struct rt6_info *rt)
282 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
284 * Okay, this does not seem to be appropriate
285 * for now, however, we need to check if it
286 * is really so; aka Router Reachability Probing.
288 * Router Reachability Probe MUST be rate-limited
289 * to no more than one per minute.
291 if (!neigh || (neigh->nud_state & NUD_VALID))
293 read_lock_bh(&neigh->lock);
294 if (!(neigh->nud_state & NUD_VALID) &&
295 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
296 struct in6_addr mcaddr;
297 struct in6_addr *target;
299 neigh->updated = jiffies;
300 read_unlock_bh(&neigh->lock);
302 target = (struct in6_addr *)&neigh->primary_key;
303 addrconf_addr_solict_mult(target, &mcaddr);
304 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
306 read_unlock_bh(&neigh->lock);
309 static inline void rt6_probe(struct rt6_info *rt)
316 * Default Router Selection (RFC 2461 6.3.6)
318 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
320 struct net_device *dev = rt->rt6i_dev;
321 if (!oif || dev->ifindex == oif)
323 if ((dev->flags & IFF_LOOPBACK) &&
324 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
329 static inline int rt6_check_neigh(struct rt6_info *rt)
331 struct neighbour *neigh = rt->rt6i_nexthop;
333 if (rt->rt6i_flags & RTF_NONEXTHOP ||
334 !(rt->rt6i_flags & RTF_GATEWAY))
337 read_lock_bh(&neigh->lock);
338 if (neigh->nud_state & NUD_VALID)
340 #ifdef CONFIG_IPV6_ROUTER_PREF
341 else if (neigh->nud_state & NUD_FAILED)
346 read_unlock_bh(&neigh->lock);
352 static int rt6_score_route(struct rt6_info *rt, int oif,
357 m = rt6_check_dev(rt, oif);
358 if (!m && (strict & RT6_LOOKUP_F_IFACE))
360 #ifdef CONFIG_IPV6_ROUTER_PREF
361 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
363 n = rt6_check_neigh(rt);
364 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
369 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
370 int *mpri, struct rt6_info *match)
374 if (rt6_check_expired(rt))
377 m = rt6_score_route(rt, oif, strict);
382 if (strict & RT6_LOOKUP_F_REACHABLE)
386 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
394 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
395 struct rt6_info *rr_head,
396 u32 metric, int oif, int strict)
398 struct rt6_info *rt, *match;
402 for (rt = rr_head; rt && rt->rt6i_metric == metric;
403 rt = rt->u.dst.rt6_next)
404 match = find_match(rt, oif, strict, &mpri, match);
405 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
406 rt = rt->u.dst.rt6_next)
407 match = find_match(rt, oif, strict, &mpri, match);
412 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
414 struct rt6_info *match, *rt0;
416 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
417 __FUNCTION__, fn->leaf, oif);
421 fn->rr_ptr = rt0 = fn->leaf;
423 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
426 (strict & RT6_LOOKUP_F_REACHABLE)) {
427 struct rt6_info *next = rt0->u.dst.rt6_next;
429 /* no entries matched; do round-robin */
430 if (!next || next->rt6i_metric != rt0->rt6i_metric)
437 RT6_TRACE("%s() => %p\n",
438 __FUNCTION__, match);
440 return (match ? match : &ip6_null_entry);
443 #ifdef CONFIG_IPV6_ROUTE_INFO
444 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
445 struct in6_addr *gwaddr)
447 struct route_info *rinfo = (struct route_info *) opt;
448 struct in6_addr prefix_buf, *prefix;
453 if (len < sizeof(struct route_info)) {
457 /* Sanity check for prefix_len and length */
458 if (rinfo->length > 3) {
460 } else if (rinfo->prefix_len > 128) {
462 } else if (rinfo->prefix_len > 64) {
463 if (rinfo->length < 2) {
466 } else if (rinfo->prefix_len > 0) {
467 if (rinfo->length < 1) {
472 pref = rinfo->route_pref;
473 if (pref == ICMPV6_ROUTER_PREF_INVALID)
474 pref = ICMPV6_ROUTER_PREF_MEDIUM;
476 lifetime = ntohl(rinfo->lifetime);
477 if (lifetime == 0xffffffff) {
479 } else if (lifetime > 0x7fffffff/HZ) {
480 /* Avoid arithmetic overflow */
481 lifetime = 0x7fffffff/HZ - 1;
484 if (rinfo->length == 3)
485 prefix = (struct in6_addr *)rinfo->prefix;
487 /* this function is safe */
488 ipv6_addr_prefix(&prefix_buf,
489 (struct in6_addr *)rinfo->prefix,
491 prefix = &prefix_buf;
494 rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
496 if (rt && !lifetime) {
502 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
505 rt->rt6i_flags = RTF_ROUTEINFO |
506 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
509 if (lifetime == 0xffffffff) {
510 rt->rt6i_flags &= ~RTF_EXPIRES;
512 rt->rt6i_expires = jiffies + HZ * lifetime;
513 rt->rt6i_flags |= RTF_EXPIRES;
515 dst_release(&rt->u.dst);
521 #define BACKTRACK(saddr) \
523 if (rt == &ip6_null_entry) { \
524 struct fib6_node *pn; \
526 if (fn->fn_flags & RTN_TL_ROOT) \
529 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
530 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
533 if (fn->fn_flags & RTN_RTINFO) \
539 static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
540 struct flowi *fl, int flags)
542 struct fib6_node *fn;
545 read_lock_bh(&table->tb6_lock);
546 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
549 rt = rt6_device_match(rt, fl->oif, flags);
550 BACKTRACK(&fl->fl6_src);
552 dst_use(&rt->u.dst, jiffies);
553 read_unlock_bh(&table->tb6_lock);
558 struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
569 struct dst_entry *dst;
570 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
573 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
574 flags |= RT6_LOOKUP_F_HAS_SADDR;
577 dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_lookup);
579 return (struct rt6_info *) dst;
586 EXPORT_SYMBOL(rt6_lookup);
588 /* ip6_ins_rt is called with FREE table->tb6_lock.
589 It takes new route entry, the addition fails by any reason the
590 route is freed. In any case, if caller does not hold it, it may
594 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
597 struct fib6_table *table;
599 table = rt->rt6i_table;
600 write_lock_bh(&table->tb6_lock);
601 err = fib6_add(&table->tb6_root, rt, info);
602 write_unlock_bh(&table->tb6_lock);
607 int ip6_ins_rt(struct rt6_info *rt)
609 return __ip6_ins_rt(rt, NULL);
612 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
613 struct in6_addr *saddr)
621 rt = ip6_rt_copy(ort);
624 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
625 if (rt->rt6i_dst.plen != 128 &&
626 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
627 rt->rt6i_flags |= RTF_ANYCAST;
628 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
631 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
632 rt->rt6i_dst.plen = 128;
633 rt->rt6i_flags |= RTF_CACHE;
634 rt->u.dst.flags |= DST_HOST;
636 #ifdef CONFIG_IPV6_SUBTREES
637 if (rt->rt6i_src.plen && saddr) {
638 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
639 rt->rt6i_src.plen = 128;
643 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
650 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
652 struct rt6_info *rt = ip6_rt_copy(ort);
654 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
655 rt->rt6i_dst.plen = 128;
656 rt->rt6i_flags |= RTF_CACHE;
657 rt->u.dst.flags |= DST_HOST;
658 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
663 static struct rt6_info *ip6_pol_route(struct fib6_table *table, int oif,
664 struct flowi *fl, int flags)
666 struct fib6_node *fn;
667 struct rt6_info *rt, *nrt;
671 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
673 strict |= flags & RT6_LOOKUP_F_IFACE;
676 read_lock_bh(&table->tb6_lock);
679 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
682 rt = rt6_select(fn, oif, strict | reachable);
683 BACKTRACK(&fl->fl6_src);
684 if (rt == &ip6_null_entry ||
685 rt->rt6i_flags & RTF_CACHE)
688 dst_hold(&rt->u.dst);
689 read_unlock_bh(&table->tb6_lock);
691 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
692 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
694 #if CLONE_OFFLINK_ROUTE
695 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
701 dst_release(&rt->u.dst);
702 rt = nrt ? : &ip6_null_entry;
704 dst_hold(&rt->u.dst);
706 err = ip6_ins_rt(nrt);
715 * Race condition! In the gap, when table->tb6_lock was
716 * released someone could insert this route. Relookup.
718 dst_release(&rt->u.dst);
726 dst_hold(&rt->u.dst);
727 read_unlock_bh(&table->tb6_lock);
729 rt->u.dst.lastuse = jiffies;
735 static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
736 struct flowi *fl, int flags)
738 return ip6_pol_route(table, fl->iif, fl, flags);
741 void ip6_route_input(struct sk_buff *skb)
743 struct ipv6hdr *iph = ipv6_hdr(skb);
744 int flags = RT6_LOOKUP_F_HAS_SADDR;
746 .iif = skb->dev->ifindex,
751 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
755 .proto = iph->nexthdr,
758 if (rt6_need_strict(&iph->daddr))
759 flags |= RT6_LOOKUP_F_IFACE;
761 skb->dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_input);
764 static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
765 struct flowi *fl, int flags)
767 return ip6_pol_route(table, fl->oif, fl, flags);
770 struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
774 if (rt6_need_strict(&fl->fl6_dst))
775 flags |= RT6_LOOKUP_F_IFACE;
777 if (!ipv6_addr_any(&fl->fl6_src))
778 flags |= RT6_LOOKUP_F_HAS_SADDR;
780 return fib6_rule_lookup(fl, flags, ip6_pol_route_output);
783 EXPORT_SYMBOL(ip6_route_output);
785 int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
787 struct rt6_info *ort = (struct rt6_info *) *dstp;
788 struct rt6_info *rt = (struct rt6_info *)
789 dst_alloc(&ip6_dst_blackhole_ops);
790 struct dst_entry *new = NULL;
795 atomic_set(&new->__refcnt, 1);
797 new->input = dst_discard;
798 new->output = dst_discard;
800 memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
801 new->dev = ort->u.dst.dev;
804 rt->rt6i_idev = ort->rt6i_idev;
806 in6_dev_hold(rt->rt6i_idev);
807 rt->rt6i_expires = 0;
809 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
810 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
813 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
814 #ifdef CONFIG_IPV6_SUBTREES
815 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
823 return (new ? 0 : -ENOMEM);
825 EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
828 * Destination cache support functions
831 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
835 rt = (struct rt6_info *) dst;
837 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
843 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
845 struct rt6_info *rt = (struct rt6_info *) dst;
848 if (rt->rt6i_flags & RTF_CACHE)
856 static void ip6_link_failure(struct sk_buff *skb)
860 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
862 rt = (struct rt6_info *) skb->dst;
864 if (rt->rt6i_flags&RTF_CACHE) {
865 dst_set_expires(&rt->u.dst, 0);
866 rt->rt6i_flags |= RTF_EXPIRES;
867 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
868 rt->rt6i_node->fn_sernum = -1;
872 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
874 struct rt6_info *rt6 = (struct rt6_info*)dst;
876 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
877 rt6->rt6i_flags |= RTF_MODIFIED;
878 if (mtu < IPV6_MIN_MTU) {
880 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
882 dst->metrics[RTAX_MTU-1] = mtu;
883 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
887 static int ipv6_get_mtu(struct net_device *dev);
889 static inline unsigned int ipv6_advmss(unsigned int mtu)
891 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
893 if (mtu < ip6_rt_min_advmss)
894 mtu = ip6_rt_min_advmss;
897 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
898 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
899 * IPV6_MAXPLEN is also valid and means: "any MSS,
900 * rely only on pmtu discovery"
902 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
907 static struct dst_entry *ndisc_dst_gc_list;
908 static DEFINE_SPINLOCK(ndisc_lock);
910 struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
911 struct neighbour *neigh,
912 struct in6_addr *addr,
913 int (*output)(struct sk_buff *))
916 struct inet6_dev *idev = in6_dev_get(dev);
918 if (unlikely(idev == NULL))
921 rt = ip6_dst_alloc();
922 if (unlikely(rt == NULL)) {
931 neigh = ndisc_get_neigh(dev, addr);
934 rt->rt6i_idev = idev;
935 rt->rt6i_nexthop = neigh;
936 atomic_set(&rt->u.dst.__refcnt, 1);
937 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
938 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
939 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
940 rt->u.dst.output = output;
942 #if 0 /* there's no chance to use these for ndisc */
943 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
946 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
947 rt->rt6i_dst.plen = 128;
950 spin_lock_bh(&ndisc_lock);
951 rt->u.dst.next = ndisc_dst_gc_list;
952 ndisc_dst_gc_list = &rt->u.dst;
953 spin_unlock_bh(&ndisc_lock);
955 fib6_force_start_gc();
961 int ndisc_dst_gc(int *more)
963 struct dst_entry *dst, *next, **pprev;
969 spin_lock_bh(&ndisc_lock);
970 pprev = &ndisc_dst_gc_list;
972 while ((dst = *pprev) != NULL) {
973 if (!atomic_read(&dst->__refcnt)) {
983 spin_unlock_bh(&ndisc_lock);
988 static int ip6_dst_gc(void)
990 static unsigned expire = 30*HZ;
991 static unsigned long last_gc;
992 unsigned long now = jiffies;
994 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
995 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
1001 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
1002 expire = ip6_rt_gc_timeout>>1;
1005 expire -= expire>>ip6_rt_gc_elasticity;
1006 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
1009 /* Clean host part of a prefix. Not necessary in radix tree,
1010 but results in cleaner routing tables.
1012 Remove it only when all the things will work!
1015 static int ipv6_get_mtu(struct net_device *dev)
1017 int mtu = IPV6_MIN_MTU;
1018 struct inet6_dev *idev;
1020 idev = in6_dev_get(dev);
1022 mtu = idev->cnf.mtu6;
1028 int ipv6_get_hoplimit(struct net_device *dev)
1030 int hoplimit = ipv6_devconf.hop_limit;
1031 struct inet6_dev *idev;
1033 idev = in6_dev_get(dev);
1035 hoplimit = idev->cnf.hop_limit;
1045 int ip6_route_add(struct fib6_config *cfg)
1048 struct rt6_info *rt = NULL;
1049 struct net_device *dev = NULL;
1050 struct inet6_dev *idev = NULL;
1051 struct fib6_table *table;
1054 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1056 #ifndef CONFIG_IPV6_SUBTREES
1057 if (cfg->fc_src_len)
1060 if (cfg->fc_ifindex) {
1062 dev = dev_get_by_index(&init_net, cfg->fc_ifindex);
1065 idev = in6_dev_get(dev);
1070 if (cfg->fc_metric == 0)
1071 cfg->fc_metric = IP6_RT_PRIO_USER;
1073 table = fib6_new_table(cfg->fc_table);
1074 if (table == NULL) {
1079 rt = ip6_dst_alloc();
1086 rt->u.dst.obsolete = -1;
1087 rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
1089 if (cfg->fc_protocol == RTPROT_UNSPEC)
1090 cfg->fc_protocol = RTPROT_BOOT;
1091 rt->rt6i_protocol = cfg->fc_protocol;
1093 addr_type = ipv6_addr_type(&cfg->fc_dst);
1095 if (addr_type & IPV6_ADDR_MULTICAST)
1096 rt->u.dst.input = ip6_mc_input;
1098 rt->u.dst.input = ip6_forward;
1100 rt->u.dst.output = ip6_output;
1102 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1103 rt->rt6i_dst.plen = cfg->fc_dst_len;
1104 if (rt->rt6i_dst.plen == 128)
1105 rt->u.dst.flags = DST_HOST;
1107 #ifdef CONFIG_IPV6_SUBTREES
1108 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1109 rt->rt6i_src.plen = cfg->fc_src_len;
1112 rt->rt6i_metric = cfg->fc_metric;
1114 /* We cannot add true routes via loopback here,
1115 they would result in kernel looping; promote them to reject routes
1117 if ((cfg->fc_flags & RTF_REJECT) ||
1118 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1119 /* hold loopback dev/idev if we haven't done so. */
1120 if (dev != init_net.loopback_dev) {
1125 dev = init_net.loopback_dev;
1127 idev = in6_dev_get(dev);
1133 rt->u.dst.output = ip6_pkt_discard_out;
1134 rt->u.dst.input = ip6_pkt_discard;
1135 rt->u.dst.error = -ENETUNREACH;
1136 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1140 if (cfg->fc_flags & RTF_GATEWAY) {
1141 struct in6_addr *gw_addr;
1144 gw_addr = &cfg->fc_gateway;
1145 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
1146 gwa_type = ipv6_addr_type(gw_addr);
1148 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1149 struct rt6_info *grt;
1151 /* IPv6 strictly inhibits using not link-local
1152 addresses as nexthop address.
1153 Otherwise, router will not able to send redirects.
1154 It is very good, but in some (rare!) circumstances
1155 (SIT, PtP, NBMA NOARP links) it is handy to allow
1156 some exceptions. --ANK
1159 if (!(gwa_type&IPV6_ADDR_UNICAST))
1162 grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
1164 err = -EHOSTUNREACH;
1168 if (dev != grt->rt6i_dev) {
1169 dst_release(&grt->u.dst);
1173 dev = grt->rt6i_dev;
1174 idev = grt->rt6i_idev;
1176 in6_dev_hold(grt->rt6i_idev);
1178 if (!(grt->rt6i_flags&RTF_GATEWAY))
1180 dst_release(&grt->u.dst);
1186 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1194 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1195 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1196 if (IS_ERR(rt->rt6i_nexthop)) {
1197 err = PTR_ERR(rt->rt6i_nexthop);
1198 rt->rt6i_nexthop = NULL;
1203 rt->rt6i_flags = cfg->fc_flags;
1210 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1211 int type = nla_type(nla);
1214 if (type > RTAX_MAX) {
1219 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
1224 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1225 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1226 if (!rt->u.dst.metrics[RTAX_MTU-1])
1227 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1228 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1229 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1230 rt->u.dst.dev = dev;
1231 rt->rt6i_idev = idev;
1232 rt->rt6i_table = table;
1233 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1241 dst_free(&rt->u.dst);
1245 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1248 struct fib6_table *table;
1250 if (rt == &ip6_null_entry)
1253 table = rt->rt6i_table;
1254 write_lock_bh(&table->tb6_lock);
1256 err = fib6_del(rt, info);
1257 dst_release(&rt->u.dst);
1259 write_unlock_bh(&table->tb6_lock);
1264 int ip6_del_rt(struct rt6_info *rt)
1266 return __ip6_del_rt(rt, NULL);
1269 static int ip6_route_del(struct fib6_config *cfg)
1271 struct fib6_table *table;
1272 struct fib6_node *fn;
1273 struct rt6_info *rt;
1276 table = fib6_get_table(cfg->fc_table);
1280 read_lock_bh(&table->tb6_lock);
1282 fn = fib6_locate(&table->tb6_root,
1283 &cfg->fc_dst, cfg->fc_dst_len,
1284 &cfg->fc_src, cfg->fc_src_len);
1287 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1288 if (cfg->fc_ifindex &&
1289 (rt->rt6i_dev == NULL ||
1290 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1292 if (cfg->fc_flags & RTF_GATEWAY &&
1293 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1295 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1297 dst_hold(&rt->u.dst);
1298 read_unlock_bh(&table->tb6_lock);
1300 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1303 read_unlock_bh(&table->tb6_lock);
1311 struct ip6rd_flowi {
1313 struct in6_addr gateway;
1316 static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1320 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1321 struct rt6_info *rt;
1322 struct fib6_node *fn;
1325 * Get the "current" route for this destination and
1326 * check if the redirect has come from approriate router.
1328 * RFC 2461 specifies that redirects should only be
1329 * accepted if they come from the nexthop to the target.
1330 * Due to the way the routes are chosen, this notion
1331 * is a bit fuzzy and one might need to check all possible
1335 read_lock_bh(&table->tb6_lock);
1336 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1338 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1340 * Current route is on-link; redirect is always invalid.
1342 * Seems, previous statement is not true. It could
1343 * be node, which looks for us as on-link (f.e. proxy ndisc)
1344 * But then router serving it might decide, that we should
1345 * know truth 8)8) --ANK (980726).
1347 if (rt6_check_expired(rt))
1349 if (!(rt->rt6i_flags & RTF_GATEWAY))
1351 if (fl->oif != rt->rt6i_dev->ifindex)
1353 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1359 rt = &ip6_null_entry;
1360 BACKTRACK(&fl->fl6_src);
1362 dst_hold(&rt->u.dst);
1364 read_unlock_bh(&table->tb6_lock);
1369 static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1370 struct in6_addr *src,
1371 struct in6_addr *gateway,
1372 struct net_device *dev)
1374 int flags = RT6_LOOKUP_F_HAS_SADDR;
1375 struct ip6rd_flowi rdfl = {
1377 .oif = dev->ifindex,
1385 .gateway = *gateway,
1388 if (rt6_need_strict(dest))
1389 flags |= RT6_LOOKUP_F_IFACE;
1391 return (struct rt6_info *)fib6_rule_lookup((struct flowi *)&rdfl, flags, __ip6_route_redirect);
1394 void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1395 struct in6_addr *saddr,
1396 struct neighbour *neigh, u8 *lladdr, int on_link)
1398 struct rt6_info *rt, *nrt = NULL;
1399 struct netevent_redirect netevent;
1401 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1403 if (rt == &ip6_null_entry) {
1404 if (net_ratelimit())
1405 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1406 "for redirect target\n");
1411 * We have finally decided to accept it.
1414 neigh_update(neigh, lladdr, NUD_STALE,
1415 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1416 NEIGH_UPDATE_F_OVERRIDE|
1417 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1418 NEIGH_UPDATE_F_ISROUTER))
1422 * Redirect received -> path was valid.
1423 * Look, redirects are sent only in response to data packets,
1424 * so that this nexthop apparently is reachable. --ANK
1426 dst_confirm(&rt->u.dst);
1428 /* Duplicate redirect: silently ignore. */
1429 if (neigh == rt->u.dst.neighbour)
1432 nrt = ip6_rt_copy(rt);
1436 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1438 nrt->rt6i_flags &= ~RTF_GATEWAY;
1440 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1441 nrt->rt6i_dst.plen = 128;
1442 nrt->u.dst.flags |= DST_HOST;
1444 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1445 nrt->rt6i_nexthop = neigh_clone(neigh);
1446 /* Reset pmtu, it may be better */
1447 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1448 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1450 if (ip6_ins_rt(nrt))
1453 netevent.old = &rt->u.dst;
1454 netevent.new = &nrt->u.dst;
1455 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1457 if (rt->rt6i_flags&RTF_CACHE) {
1463 dst_release(&rt->u.dst);
1468 * Handle ICMP "packet too big" messages
1469 * i.e. Path MTU discovery
1472 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1473 struct net_device *dev, u32 pmtu)
1475 struct rt6_info *rt, *nrt;
1478 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1482 if (pmtu >= dst_mtu(&rt->u.dst))
1485 if (pmtu < IPV6_MIN_MTU) {
1487 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1488 * MTU (1280) and a fragment header should always be included
1489 * after a node receiving Too Big message reporting PMTU is
1490 * less than the IPv6 Minimum Link MTU.
1492 pmtu = IPV6_MIN_MTU;
1496 /* New mtu received -> path was valid.
1497 They are sent only in response to data packets,
1498 so that this nexthop apparently is reachable. --ANK
1500 dst_confirm(&rt->u.dst);
1502 /* Host route. If it is static, it would be better
1503 not to override it, but add new one, so that
1504 when cache entry will expire old pmtu
1505 would return automatically.
1507 if (rt->rt6i_flags & RTF_CACHE) {
1508 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1510 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1511 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1512 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1517 Two cases are possible:
1518 1. It is connected route. Action: COW
1519 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1521 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1522 nrt = rt6_alloc_cow(rt, daddr, saddr);
1524 nrt = rt6_alloc_clone(rt, daddr);
1527 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1529 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1531 /* According to RFC 1981, detecting PMTU increase shouldn't be
1532 * happened within 5 mins, the recommended timer is 10 mins.
1533 * Here this route expiration time is set to ip6_rt_mtu_expires
1534 * which is 10 mins. After 10 mins the decreased pmtu is expired
1535 * and detecting PMTU increase will be automatically happened.
1537 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1538 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1543 dst_release(&rt->u.dst);
1547 * Misc support functions
1550 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1552 struct rt6_info *rt = ip6_dst_alloc();
1555 rt->u.dst.input = ort->u.dst.input;
1556 rt->u.dst.output = ort->u.dst.output;
1558 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
1559 rt->u.dst.error = ort->u.dst.error;
1560 rt->u.dst.dev = ort->u.dst.dev;
1562 dev_hold(rt->u.dst.dev);
1563 rt->rt6i_idev = ort->rt6i_idev;
1565 in6_dev_hold(rt->rt6i_idev);
1566 rt->u.dst.lastuse = jiffies;
1567 rt->rt6i_expires = 0;
1569 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1570 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1571 rt->rt6i_metric = 0;
1573 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1574 #ifdef CONFIG_IPV6_SUBTREES
1575 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1577 rt->rt6i_table = ort->rt6i_table;
1582 #ifdef CONFIG_IPV6_ROUTE_INFO
1583 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1584 struct in6_addr *gwaddr, int ifindex)
1586 struct fib6_node *fn;
1587 struct rt6_info *rt = NULL;
1588 struct fib6_table *table;
1590 table = fib6_get_table(RT6_TABLE_INFO);
1594 write_lock_bh(&table->tb6_lock);
1595 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1599 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1600 if (rt->rt6i_dev->ifindex != ifindex)
1602 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1604 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1606 dst_hold(&rt->u.dst);
1610 write_unlock_bh(&table->tb6_lock);
1614 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1615 struct in6_addr *gwaddr, int ifindex,
1618 struct fib6_config cfg = {
1619 .fc_table = RT6_TABLE_INFO,
1621 .fc_ifindex = ifindex,
1622 .fc_dst_len = prefixlen,
1623 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1624 RTF_UP | RTF_PREF(pref),
1627 ipv6_addr_copy(&cfg.fc_dst, prefix);
1628 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1630 /* We should treat it as a default route if prefix length is 0. */
1632 cfg.fc_flags |= RTF_DEFAULT;
1634 ip6_route_add(&cfg);
1636 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1640 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1642 struct rt6_info *rt;
1643 struct fib6_table *table;
1645 table = fib6_get_table(RT6_TABLE_DFLT);
1649 write_lock_bh(&table->tb6_lock);
1650 for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
1651 if (dev == rt->rt6i_dev &&
1652 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1653 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1657 dst_hold(&rt->u.dst);
1658 write_unlock_bh(&table->tb6_lock);
1662 EXPORT_SYMBOL(rt6_get_dflt_router);
1664 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1665 struct net_device *dev,
1668 struct fib6_config cfg = {
1669 .fc_table = RT6_TABLE_DFLT,
1671 .fc_ifindex = dev->ifindex,
1672 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1673 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1676 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1678 ip6_route_add(&cfg);
1680 return rt6_get_dflt_router(gwaddr, dev);
1683 void rt6_purge_dflt_routers(void)
1685 struct rt6_info *rt;
1686 struct fib6_table *table;
1688 /* NOTE: Keep consistent with rt6_get_dflt_router */
1689 table = fib6_get_table(RT6_TABLE_DFLT);
1694 read_lock_bh(&table->tb6_lock);
1695 for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
1696 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1697 dst_hold(&rt->u.dst);
1698 read_unlock_bh(&table->tb6_lock);
1703 read_unlock_bh(&table->tb6_lock);
1706 static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1707 struct fib6_config *cfg)
1709 memset(cfg, 0, sizeof(*cfg));
1711 cfg->fc_table = RT6_TABLE_MAIN;
1712 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1713 cfg->fc_metric = rtmsg->rtmsg_metric;
1714 cfg->fc_expires = rtmsg->rtmsg_info;
1715 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1716 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1717 cfg->fc_flags = rtmsg->rtmsg_flags;
1719 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1720 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1721 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1724 int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1726 struct fib6_config cfg;
1727 struct in6_rtmsg rtmsg;
1731 case SIOCADDRT: /* Add a route */
1732 case SIOCDELRT: /* Delete a route */
1733 if (!capable(CAP_NET_ADMIN))
1735 err = copy_from_user(&rtmsg, arg,
1736 sizeof(struct in6_rtmsg));
1740 rtmsg_to_fib6_config(&rtmsg, &cfg);
1745 err = ip6_route_add(&cfg);
1748 err = ip6_route_del(&cfg);
1762 * Drop the packet on the floor
1765 static inline int ip6_pkt_drop(struct sk_buff *skb, int code,
1766 int ipstats_mib_noroutes)
1769 switch (ipstats_mib_noroutes) {
1770 case IPSTATS_MIB_INNOROUTES:
1771 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
1772 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED) {
1773 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
1777 case IPSTATS_MIB_OUTNOROUTES:
1778 IP6_INC_STATS(ip6_dst_idev(skb->dst), ipstats_mib_noroutes);
1781 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
1786 static int ip6_pkt_discard(struct sk_buff *skb)
1788 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
1791 static int ip6_pkt_discard_out(struct sk_buff *skb)
1793 skb->dev = skb->dst->dev;
1794 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1797 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
1799 static int ip6_pkt_prohibit(struct sk_buff *skb)
1801 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
1804 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1806 skb->dev = skb->dst->dev;
1807 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
1813 * Allocate a dst for local (unicast / anycast) address.
1816 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1817 const struct in6_addr *addr,
1820 struct rt6_info *rt = ip6_dst_alloc();
1823 return ERR_PTR(-ENOMEM);
1825 dev_hold(init_net.loopback_dev);
1828 rt->u.dst.flags = DST_HOST;
1829 rt->u.dst.input = ip6_input;
1830 rt->u.dst.output = ip6_output;
1831 rt->rt6i_dev = init_net.loopback_dev;
1832 rt->rt6i_idev = idev;
1833 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1834 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1835 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1836 rt->u.dst.obsolete = -1;
1838 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1840 rt->rt6i_flags |= RTF_ANYCAST;
1842 rt->rt6i_flags |= RTF_LOCAL;
1843 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1844 if (rt->rt6i_nexthop == NULL) {
1845 dst_free(&rt->u.dst);
1846 return ERR_PTR(-ENOMEM);
1849 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1850 rt->rt6i_dst.plen = 128;
1851 rt->rt6i_table = fib6_get_table(RT6_TABLE_LOCAL);
1853 atomic_set(&rt->u.dst.__refcnt, 1);
1858 static int fib6_ifdown(struct rt6_info *rt, void *arg)
1860 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1861 rt != &ip6_null_entry) {
1862 RT6_TRACE("deleted by ifdown %p\n", rt);
1868 void rt6_ifdown(struct net_device *dev)
1870 fib6_clean_all(fib6_ifdown, 0, dev);
1873 struct rt6_mtu_change_arg
1875 struct net_device *dev;
1879 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1881 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1882 struct inet6_dev *idev;
1884 /* In IPv6 pmtu discovery is not optional,
1885 so that RTAX_MTU lock cannot disable it.
1886 We still use this lock to block changes
1887 caused by addrconf/ndisc.
1890 idev = __in6_dev_get(arg->dev);
1894 /* For administrative MTU increase, there is no way to discover
1895 IPv6 PMTU increase, so PMTU increase should be updated here.
1896 Since RFC 1981 doesn't include administrative MTU increase
1897 update PMTU increase is a MUST. (i.e. jumbo frame)
1900 If new MTU is less than route PMTU, this new MTU will be the
1901 lowest MTU in the path, update the route PMTU to reflect PMTU
1902 decreases; if new MTU is greater than route PMTU, and the
1903 old MTU is the lowest MTU in the path, update the route PMTU
1904 to reflect the increase. In this case if the other nodes' MTU
1905 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1908 if (rt->rt6i_dev == arg->dev &&
1909 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1910 (dst_mtu(&rt->u.dst) > arg->mtu ||
1911 (dst_mtu(&rt->u.dst) < arg->mtu &&
1912 dst_mtu(&rt->u.dst) == idev->cnf.mtu6))) {
1913 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1914 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1919 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1921 struct rt6_mtu_change_arg arg = {
1926 fib6_clean_all(rt6_mtu_change_route, 0, &arg);
1929 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
1930 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
1931 [RTA_OIF] = { .type = NLA_U32 },
1932 [RTA_IIF] = { .type = NLA_U32 },
1933 [RTA_PRIORITY] = { .type = NLA_U32 },
1934 [RTA_METRICS] = { .type = NLA_NESTED },
1937 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1938 struct fib6_config *cfg)
1941 struct nlattr *tb[RTA_MAX+1];
1944 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1949 rtm = nlmsg_data(nlh);
1950 memset(cfg, 0, sizeof(*cfg));
1952 cfg->fc_table = rtm->rtm_table;
1953 cfg->fc_dst_len = rtm->rtm_dst_len;
1954 cfg->fc_src_len = rtm->rtm_src_len;
1955 cfg->fc_flags = RTF_UP;
1956 cfg->fc_protocol = rtm->rtm_protocol;
1958 if (rtm->rtm_type == RTN_UNREACHABLE)
1959 cfg->fc_flags |= RTF_REJECT;
1961 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1962 cfg->fc_nlinfo.nlh = nlh;
1964 if (tb[RTA_GATEWAY]) {
1965 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1966 cfg->fc_flags |= RTF_GATEWAY;
1970 int plen = (rtm->rtm_dst_len + 7) >> 3;
1972 if (nla_len(tb[RTA_DST]) < plen)
1975 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1979 int plen = (rtm->rtm_src_len + 7) >> 3;
1981 if (nla_len(tb[RTA_SRC]) < plen)
1984 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1988 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1990 if (tb[RTA_PRIORITY])
1991 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
1993 if (tb[RTA_METRICS]) {
1994 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
1995 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1999 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2006 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2008 struct net *net = skb->sk->sk_net;
2009 struct fib6_config cfg;
2012 if (net != &init_net)
2015 err = rtm_to_fib6_config(skb, nlh, &cfg);
2019 return ip6_route_del(&cfg);
2022 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2024 struct net *net = skb->sk->sk_net;
2025 struct fib6_config cfg;
2028 if (net != &init_net)
2031 err = rtm_to_fib6_config(skb, nlh, &cfg);
2035 return ip6_route_add(&cfg);
2038 static inline size_t rt6_nlmsg_size(void)
2040 return NLMSG_ALIGN(sizeof(struct rtmsg))
2041 + nla_total_size(16) /* RTA_SRC */
2042 + nla_total_size(16) /* RTA_DST */
2043 + nla_total_size(16) /* RTA_GATEWAY */
2044 + nla_total_size(16) /* RTA_PREFSRC */
2045 + nla_total_size(4) /* RTA_TABLE */
2046 + nla_total_size(4) /* RTA_IIF */
2047 + nla_total_size(4) /* RTA_OIF */
2048 + nla_total_size(4) /* RTA_PRIORITY */
2049 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2050 + nla_total_size(sizeof(struct rta_cacheinfo));
2053 static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
2054 struct in6_addr *dst, struct in6_addr *src,
2055 int iif, int type, u32 pid, u32 seq,
2056 int prefix, unsigned int flags)
2059 struct nlmsghdr *nlh;
2063 if (prefix) { /* user wants prefix routes only */
2064 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2065 /* success since this is not a prefix route */
2070 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2074 rtm = nlmsg_data(nlh);
2075 rtm->rtm_family = AF_INET6;
2076 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2077 rtm->rtm_src_len = rt->rt6i_src.plen;
2080 table = rt->rt6i_table->tb6_id;
2082 table = RT6_TABLE_UNSPEC;
2083 rtm->rtm_table = table;
2084 NLA_PUT_U32(skb, RTA_TABLE, table);
2085 if (rt->rt6i_flags&RTF_REJECT)
2086 rtm->rtm_type = RTN_UNREACHABLE;
2087 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2088 rtm->rtm_type = RTN_LOCAL;
2090 rtm->rtm_type = RTN_UNICAST;
2092 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2093 rtm->rtm_protocol = rt->rt6i_protocol;
2094 if (rt->rt6i_flags&RTF_DYNAMIC)
2095 rtm->rtm_protocol = RTPROT_REDIRECT;
2096 else if (rt->rt6i_flags & RTF_ADDRCONF)
2097 rtm->rtm_protocol = RTPROT_KERNEL;
2098 else if (rt->rt6i_flags&RTF_DEFAULT)
2099 rtm->rtm_protocol = RTPROT_RA;
2101 if (rt->rt6i_flags&RTF_CACHE)
2102 rtm->rtm_flags |= RTM_F_CLONED;
2105 NLA_PUT(skb, RTA_DST, 16, dst);
2106 rtm->rtm_dst_len = 128;
2107 } else if (rtm->rtm_dst_len)
2108 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
2109 #ifdef CONFIG_IPV6_SUBTREES
2111 NLA_PUT(skb, RTA_SRC, 16, src);
2112 rtm->rtm_src_len = 128;
2113 } else if (rtm->rtm_src_len)
2114 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
2117 NLA_PUT_U32(skb, RTA_IIF, iif);
2119 struct in6_addr saddr_buf;
2120 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
2121 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
2124 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2125 goto nla_put_failure;
2127 if (rt->u.dst.neighbour)
2128 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2131 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2133 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
2135 expires = rt->rt6i_expires ? rt->rt6i_expires - jiffies : 0;
2136 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2137 expires, rt->u.dst.error) < 0)
2138 goto nla_put_failure;
2140 return nlmsg_end(skb, nlh);
2143 nlmsg_cancel(skb, nlh);
2147 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2149 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2152 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2153 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2154 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2158 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2159 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
2160 prefix, NLM_F_MULTI);
2163 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2165 struct net *net = in_skb->sk->sk_net;
2166 struct nlattr *tb[RTA_MAX+1];
2167 struct rt6_info *rt;
2168 struct sk_buff *skb;
2173 if (net != &init_net)
2176 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2181 memset(&fl, 0, sizeof(fl));
2184 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2187 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2191 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2194 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2198 iif = nla_get_u32(tb[RTA_IIF]);
2201 fl.oif = nla_get_u32(tb[RTA_OIF]);
2204 struct net_device *dev;
2205 dev = __dev_get_by_index(&init_net, iif);
2212 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2218 /* Reserve room for dummy headers, this skb can pass
2219 through good chunk of routing engine.
2221 skb_reset_mac_header(skb);
2222 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2224 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
2225 skb->dst = &rt->u.dst;
2227 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
2228 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
2229 nlh->nlmsg_seq, 0, 0);
2235 err = rtnl_unicast(skb, &init_net, NETLINK_CB(in_skb).pid);
2240 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2242 struct sk_buff *skb;
2243 u32 pid = 0, seq = 0;
2244 struct nlmsghdr *nlh = NULL;
2251 seq = nlh->nlmsg_seq;
2254 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2258 err = rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0);
2260 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2261 WARN_ON(err == -EMSGSIZE);
2265 err = rtnl_notify(skb, &init_net, pid, RTNLGRP_IPV6_ROUTE, nlh, gfp_any());
2268 rtnl_set_sk_err(&init_net, RTNLGRP_IPV6_ROUTE, err);
2275 #ifdef CONFIG_PROC_FS
2277 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2288 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2290 struct seq_file *m = p_arg;
2292 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_dst.addr),
2295 #ifdef CONFIG_IPV6_SUBTREES
2296 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_src.addr),
2299 seq_puts(m, "00000000000000000000000000000000 00 ");
2302 if (rt->rt6i_nexthop) {
2303 seq_printf(m, NIP6_SEQFMT,
2304 NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
2306 seq_puts(m, "00000000000000000000000000000000");
2308 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2309 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2310 rt->u.dst.__use, rt->rt6i_flags,
2311 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2315 static int ipv6_route_show(struct seq_file *m, void *v)
2317 fib6_clean_all(rt6_info_route, 0, m);
2321 static int ipv6_route_open(struct inode *inode, struct file *file)
2323 return single_open(file, ipv6_route_show, NULL);
2326 static const struct file_operations ipv6_route_proc_fops = {
2327 .owner = THIS_MODULE,
2328 .open = ipv6_route_open,
2330 .llseek = seq_lseek,
2331 .release = single_release,
2334 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2336 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2337 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2338 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2339 rt6_stats.fib_rt_cache,
2340 atomic_read(&ip6_dst_ops.entries),
2341 rt6_stats.fib_discarded_routes);
2346 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2348 return single_open(file, rt6_stats_seq_show, NULL);
2351 static const struct file_operations rt6_stats_seq_fops = {
2352 .owner = THIS_MODULE,
2353 .open = rt6_stats_seq_open,
2355 .llseek = seq_lseek,
2356 .release = single_release,
2358 #endif /* CONFIG_PROC_FS */
2360 #ifdef CONFIG_SYSCTL
2362 static int flush_delay;
2365 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2366 void __user *buffer, size_t *lenp, loff_t *ppos)
2369 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2370 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2376 ctl_table ipv6_route_table[] = {
2378 .procname = "flush",
2379 .data = &flush_delay,
2380 .maxlen = sizeof(int),
2382 .proc_handler = &ipv6_sysctl_rtcache_flush
2385 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2386 .procname = "gc_thresh",
2387 .data = &ip6_dst_ops.gc_thresh,
2388 .maxlen = sizeof(int),
2390 .proc_handler = &proc_dointvec,
2393 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2394 .procname = "max_size",
2395 .data = &ip6_rt_max_size,
2396 .maxlen = sizeof(int),
2398 .proc_handler = &proc_dointvec,
2401 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2402 .procname = "gc_min_interval",
2403 .data = &ip6_rt_gc_min_interval,
2404 .maxlen = sizeof(int),
2406 .proc_handler = &proc_dointvec_jiffies,
2407 .strategy = &sysctl_jiffies,
2410 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2411 .procname = "gc_timeout",
2412 .data = &ip6_rt_gc_timeout,
2413 .maxlen = sizeof(int),
2415 .proc_handler = &proc_dointvec_jiffies,
2416 .strategy = &sysctl_jiffies,
2419 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2420 .procname = "gc_interval",
2421 .data = &ip6_rt_gc_interval,
2422 .maxlen = sizeof(int),
2424 .proc_handler = &proc_dointvec_jiffies,
2425 .strategy = &sysctl_jiffies,
2428 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2429 .procname = "gc_elasticity",
2430 .data = &ip6_rt_gc_elasticity,
2431 .maxlen = sizeof(int),
2433 .proc_handler = &proc_dointvec_jiffies,
2434 .strategy = &sysctl_jiffies,
2437 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2438 .procname = "mtu_expires",
2439 .data = &ip6_rt_mtu_expires,
2440 .maxlen = sizeof(int),
2442 .proc_handler = &proc_dointvec_jiffies,
2443 .strategy = &sysctl_jiffies,
2446 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2447 .procname = "min_adv_mss",
2448 .data = &ip6_rt_min_advmss,
2449 .maxlen = sizeof(int),
2451 .proc_handler = &proc_dointvec_jiffies,
2452 .strategy = &sysctl_jiffies,
2455 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2456 .procname = "gc_min_interval_ms",
2457 .data = &ip6_rt_gc_min_interval,
2458 .maxlen = sizeof(int),
2460 .proc_handler = &proc_dointvec_ms_jiffies,
2461 .strategy = &sysctl_ms_jiffies,
2468 void __init ip6_route_init(void)
2470 ip6_dst_ops.kmem_cachep =
2471 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2472 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2473 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops.kmem_cachep;
2476 proc_net_fops_create(&init_net, "ipv6_route", 0, &ipv6_route_proc_fops);
2477 proc_net_fops_create(&init_net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2481 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2485 __rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL);
2486 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL);
2487 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL);
2490 void ip6_route_cleanup(void)
2492 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2493 fib6_rules_cleanup();
2495 #ifdef CONFIG_PROC_FS
2496 proc_net_remove(&init_net, "ipv6_route");
2497 proc_net_remove(&init_net, "rt6_stats");
2504 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);