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.
27 #include <linux/capability.h>
28 #include <linux/config.h>
29 #include <linux/errno.h>
30 #include <linux/types.h>
31 #include <linux/times.h>
32 #include <linux/socket.h>
33 #include <linux/sockios.h>
34 #include <linux/net.h>
35 #include <linux/route.h>
36 #include <linux/netdevice.h>
37 #include <linux/in6.h>
38 #include <linux/init.h>
39 #include <linux/netlink.h>
40 #include <linux/if_arp.h>
43 #include <linux/proc_fs.h>
44 #include <linux/seq_file.h>
49 #include <net/ip6_fib.h>
50 #include <net/ip6_route.h>
51 #include <net/ndisc.h>
52 #include <net/addrconf.h>
54 #include <linux/rtnetlink.h>
58 #include <asm/uaccess.h>
61 #include <linux/sysctl.h>
64 /* Set to 3 to get tracing. */
68 #define RDBG(x) printk x
69 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
72 #define RT6_TRACE(x...) do { ; } while (0)
75 #define CLONE_OFFLINK_ROUTE 0
77 #define RT6_SELECT_F_IFACE 0x1
78 #define RT6_SELECT_F_REACHABLE 0x2
80 static int ip6_rt_max_size = 4096;
81 static int ip6_rt_gc_min_interval = HZ / 2;
82 static int ip6_rt_gc_timeout = 60*HZ;
83 int ip6_rt_gc_interval = 30*HZ;
84 static int ip6_rt_gc_elasticity = 9;
85 static int ip6_rt_mtu_expires = 10*60*HZ;
86 static int ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
88 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
89 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
90 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
91 static void ip6_dst_destroy(struct dst_entry *);
92 static void ip6_dst_ifdown(struct dst_entry *,
93 struct net_device *dev, int how);
94 static int ip6_dst_gc(void);
96 static int ip6_pkt_discard(struct sk_buff *skb);
97 static int ip6_pkt_discard_out(struct sk_buff *skb);
98 static void ip6_link_failure(struct sk_buff *skb);
99 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
101 static struct dst_ops ip6_dst_ops = {
103 .protocol = __constant_htons(ETH_P_IPV6),
106 .check = ip6_dst_check,
107 .destroy = ip6_dst_destroy,
108 .ifdown = ip6_dst_ifdown,
109 .negative_advice = ip6_negative_advice,
110 .link_failure = ip6_link_failure,
111 .update_pmtu = ip6_rt_update_pmtu,
112 .entry_size = sizeof(struct rt6_info),
115 struct rt6_info ip6_null_entry = {
118 .__refcnt = ATOMIC_INIT(1),
120 .dev = &loopback_dev,
122 .error = -ENETUNREACH,
123 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
124 .input = ip6_pkt_discard,
125 .output = ip6_pkt_discard_out,
127 .path = (struct dst_entry*)&ip6_null_entry,
130 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
131 .rt6i_metric = ~(u32) 0,
132 .rt6i_ref = ATOMIC_INIT(1),
135 struct fib6_node ip6_routing_table = {
136 .leaf = &ip6_null_entry,
137 .fn_flags = RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO,
140 /* Protects all the ip6 fib */
142 DEFINE_RWLOCK(rt6_lock);
145 /* allocate dst with ip6_dst_ops */
146 static __inline__ struct rt6_info *ip6_dst_alloc(void)
148 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
151 static void ip6_dst_destroy(struct dst_entry *dst)
153 struct rt6_info *rt = (struct rt6_info *)dst;
154 struct inet6_dev *idev = rt->rt6i_idev;
157 rt->rt6i_idev = NULL;
162 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
165 struct rt6_info *rt = (struct rt6_info *)dst;
166 struct inet6_dev *idev = rt->rt6i_idev;
168 if (dev != &loopback_dev && idev != NULL && idev->dev == dev) {
169 struct inet6_dev *loopback_idev = in6_dev_get(&loopback_dev);
170 if (loopback_idev != NULL) {
171 rt->rt6i_idev = loopback_idev;
177 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
179 return (rt->rt6i_flags & RTF_EXPIRES &&
180 time_after(jiffies, rt->rt6i_expires));
184 * Route lookup. Any rt6_lock is implied.
187 static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
191 struct rt6_info *local = NULL;
192 struct rt6_info *sprt;
195 for (sprt = rt; sprt; sprt = sprt->u.next) {
196 struct net_device *dev = sprt->rt6i_dev;
197 if (dev->ifindex == oif)
199 if (dev->flags & IFF_LOOPBACK) {
200 if (sprt->rt6i_idev == NULL ||
201 sprt->rt6i_idev->dev->ifindex != oif) {
204 if (local && (!oif ||
205 local->rt6i_idev->dev->ifindex == oif))
216 return &ip6_null_entry;
222 * Default Router Selection (RFC 2461 6.3.6)
224 static int inline rt6_check_dev(struct rt6_info *rt, int oif)
226 struct net_device *dev = rt->rt6i_dev;
227 if (!oif || dev->ifindex == oif)
229 if ((dev->flags & IFF_LOOPBACK) &&
230 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
235 static int inline rt6_check_neigh(struct rt6_info *rt)
237 struct neighbour *neigh = rt->rt6i_nexthop;
240 read_lock_bh(&neigh->lock);
241 if (neigh->nud_state & NUD_VALID)
243 read_unlock_bh(&neigh->lock);
248 static int rt6_score_route(struct rt6_info *rt, int oif,
251 int m = rt6_check_dev(rt, oif);
252 if (!m && (strict & RT6_SELECT_F_IFACE))
254 if (rt6_check_neigh(rt))
256 else if (strict & RT6_SELECT_F_REACHABLE)
261 static struct rt6_info *rt6_select(struct rt6_info **head, int oif,
264 struct rt6_info *match = NULL, *last = NULL;
265 struct rt6_info *rt, *rt0 = *head;
269 RT6_TRACE("%s(head=%p(*head=%p), oif=%d)\n",
270 __FUNCTION__, head, head ? *head : NULL, oif);
272 for (rt = rt0, metric = rt0->rt6i_metric;
273 rt && rt->rt6i_metric == metric;
277 if (rt6_check_expired(rt))
282 m = rt6_score_route(rt, oif, strict);
293 (strict & RT6_SELECT_F_REACHABLE) &&
294 last && last != rt0) {
295 /* no entries matched; do round-robin */
297 rt0->u.next = last->u.next;
301 RT6_TRACE("%s() => %p, score=%d\n",
302 __FUNCTION__, match, mpri);
304 return (match ? match : &ip6_null_entry);
307 struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
310 struct fib6_node *fn;
313 read_lock_bh(&rt6_lock);
314 fn = fib6_lookup(&ip6_routing_table, daddr, saddr);
315 rt = rt6_device_match(fn->leaf, oif, strict);
316 dst_hold(&rt->u.dst);
318 read_unlock_bh(&rt6_lock);
320 rt->u.dst.lastuse = jiffies;
321 if (rt->u.dst.error == 0)
323 dst_release(&rt->u.dst);
327 /* ip6_ins_rt is called with FREE rt6_lock.
328 It takes new route entry, the addition fails by any reason the
329 route is freed. In any case, if caller does not hold it, it may
333 int ip6_ins_rt(struct rt6_info *rt, struct nlmsghdr *nlh,
334 void *_rtattr, struct netlink_skb_parms *req)
338 write_lock_bh(&rt6_lock);
339 err = fib6_add(&ip6_routing_table, rt, nlh, _rtattr, req);
340 write_unlock_bh(&rt6_lock);
345 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
346 struct in6_addr *saddr)
354 rt = ip6_rt_copy(ort);
357 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
358 if (rt->rt6i_dst.plen != 128 &&
359 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
360 rt->rt6i_flags |= RTF_ANYCAST;
361 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
364 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
365 rt->rt6i_dst.plen = 128;
366 rt->rt6i_flags |= RTF_CACHE;
367 rt->u.dst.flags |= DST_HOST;
369 #ifdef CONFIG_IPV6_SUBTREES
370 if (rt->rt6i_src.plen && saddr) {
371 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
372 rt->rt6i_src.plen = 128;
376 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
383 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
385 struct rt6_info *rt = ip6_rt_copy(ort);
387 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
388 rt->rt6i_dst.plen = 128;
389 rt->rt6i_flags |= RTF_CACHE;
390 if (rt->rt6i_flags & RTF_REJECT)
391 rt->u.dst.error = ort->u.dst.error;
392 rt->u.dst.flags |= DST_HOST;
393 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
398 #define BACKTRACK() \
399 if (rt == &ip6_null_entry) { \
400 while ((fn = fn->parent) != NULL) { \
401 if (fn->fn_flags & RTN_ROOT) { \
404 if (fn->fn_flags & RTN_RTINFO) \
410 void ip6_route_input(struct sk_buff *skb)
412 struct fib6_node *fn;
413 struct rt6_info *rt, *nrt;
417 int reachable = RT6_SELECT_F_REACHABLE;
419 strict = ipv6_addr_type(&skb->nh.ipv6h->daddr) & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL) ? RT6_SELECT_F_IFACE : 0;
422 read_lock_bh(&rt6_lock);
425 fn = fib6_lookup(&ip6_routing_table, &skb->nh.ipv6h->daddr,
426 &skb->nh.ipv6h->saddr);
429 rt = rt6_select(&fn->leaf, skb->dev->ifindex, strict | reachable);
431 if (rt == &ip6_null_entry ||
432 rt->rt6i_flags & RTF_CACHE)
435 dst_hold(&rt->u.dst);
436 read_unlock_bh(&rt6_lock);
438 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
439 nrt = rt6_alloc_cow(rt, &skb->nh.ipv6h->daddr, &skb->nh.ipv6h->saddr);
441 #if CLONE_OFFLINK_ROUTE
442 nrt = rt6_alloc_clone(rt, &skb->nh.ipv6h->daddr);
448 dst_release(&rt->u.dst);
449 rt = nrt ? : &ip6_null_entry;
451 dst_hold(&rt->u.dst);
453 err = ip6_ins_rt(nrt, NULL, NULL, &NETLINK_CB(skb));
462 * Race condition! In the gap, when rt6_lock was
463 * released someone could insert this route. Relookup.
465 dst_release(&rt->u.dst);
473 dst_hold(&rt->u.dst);
474 read_unlock_bh(&rt6_lock);
476 rt->u.dst.lastuse = jiffies;
478 skb->dst = (struct dst_entry *) rt;
482 struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
484 struct fib6_node *fn;
485 struct rt6_info *rt, *nrt;
489 int reachable = RT6_SELECT_F_REACHABLE;
491 strict = ipv6_addr_type(&fl->fl6_dst) & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL) ? RT6_SELECT_F_IFACE : 0;
494 read_lock_bh(&rt6_lock);
497 fn = fib6_lookup(&ip6_routing_table, &fl->fl6_dst, &fl->fl6_src);
500 rt = rt6_select(&fn->leaf, fl->oif, strict | reachable);
502 if (rt == &ip6_null_entry ||
503 rt->rt6i_flags & RTF_CACHE)
506 dst_hold(&rt->u.dst);
507 read_unlock_bh(&rt6_lock);
509 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
510 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
512 #if CLONE_OFFLINK_ROUTE
513 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
519 dst_release(&rt->u.dst);
520 rt = nrt ? : &ip6_null_entry;
522 dst_hold(&rt->u.dst);
524 err = ip6_ins_rt(nrt, NULL, NULL, NULL);
533 * Race condition! In the gap, when rt6_lock was
534 * released someone could insert this route. Relookup.
536 dst_release(&rt->u.dst);
544 dst_hold(&rt->u.dst);
545 read_unlock_bh(&rt6_lock);
547 rt->u.dst.lastuse = jiffies;
554 * Destination cache support functions
557 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
561 rt = (struct rt6_info *) dst;
563 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
569 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
571 struct rt6_info *rt = (struct rt6_info *) dst;
574 if (rt->rt6i_flags & RTF_CACHE)
575 ip6_del_rt(rt, NULL, NULL, NULL);
582 static void ip6_link_failure(struct sk_buff *skb)
586 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
588 rt = (struct rt6_info *) skb->dst;
590 if (rt->rt6i_flags&RTF_CACHE) {
591 dst_set_expires(&rt->u.dst, 0);
592 rt->rt6i_flags |= RTF_EXPIRES;
593 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
594 rt->rt6i_node->fn_sernum = -1;
598 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
600 struct rt6_info *rt6 = (struct rt6_info*)dst;
602 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
603 rt6->rt6i_flags |= RTF_MODIFIED;
604 if (mtu < IPV6_MIN_MTU) {
606 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
608 dst->metrics[RTAX_MTU-1] = mtu;
612 /* Protected by rt6_lock. */
613 static struct dst_entry *ndisc_dst_gc_list;
614 static int ipv6_get_mtu(struct net_device *dev);
616 static inline unsigned int ipv6_advmss(unsigned int mtu)
618 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
620 if (mtu < ip6_rt_min_advmss)
621 mtu = ip6_rt_min_advmss;
624 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
625 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
626 * IPV6_MAXPLEN is also valid and means: "any MSS,
627 * rely only on pmtu discovery"
629 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
634 struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
635 struct neighbour *neigh,
636 struct in6_addr *addr,
637 int (*output)(struct sk_buff *))
640 struct inet6_dev *idev = in6_dev_get(dev);
642 if (unlikely(idev == NULL))
645 rt = ip6_dst_alloc();
646 if (unlikely(rt == NULL)) {
655 neigh = ndisc_get_neigh(dev, addr);
658 rt->rt6i_idev = idev;
659 rt->rt6i_nexthop = neigh;
660 atomic_set(&rt->u.dst.__refcnt, 1);
661 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
662 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
663 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
664 rt->u.dst.output = output;
666 #if 0 /* there's no chance to use these for ndisc */
667 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
670 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
671 rt->rt6i_dst.plen = 128;
674 write_lock_bh(&rt6_lock);
675 rt->u.dst.next = ndisc_dst_gc_list;
676 ndisc_dst_gc_list = &rt->u.dst;
677 write_unlock_bh(&rt6_lock);
679 fib6_force_start_gc();
682 return (struct dst_entry *)rt;
685 int ndisc_dst_gc(int *more)
687 struct dst_entry *dst, *next, **pprev;
691 pprev = &ndisc_dst_gc_list;
693 while ((dst = *pprev) != NULL) {
694 if (!atomic_read(&dst->__refcnt)) {
707 static int ip6_dst_gc(void)
709 static unsigned expire = 30*HZ;
710 static unsigned long last_gc;
711 unsigned long now = jiffies;
713 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
714 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
720 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
721 expire = ip6_rt_gc_timeout>>1;
724 expire -= expire>>ip6_rt_gc_elasticity;
725 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
728 /* Clean host part of a prefix. Not necessary in radix tree,
729 but results in cleaner routing tables.
731 Remove it only when all the things will work!
734 static int ipv6_get_mtu(struct net_device *dev)
736 int mtu = IPV6_MIN_MTU;
737 struct inet6_dev *idev;
739 idev = in6_dev_get(dev);
741 mtu = idev->cnf.mtu6;
747 int ipv6_get_hoplimit(struct net_device *dev)
749 int hoplimit = ipv6_devconf.hop_limit;
750 struct inet6_dev *idev;
752 idev = in6_dev_get(dev);
754 hoplimit = idev->cnf.hop_limit;
764 int ip6_route_add(struct in6_rtmsg *rtmsg, struct nlmsghdr *nlh,
765 void *_rtattr, struct netlink_skb_parms *req)
770 struct rt6_info *rt = NULL;
771 struct net_device *dev = NULL;
772 struct inet6_dev *idev = NULL;
775 rta = (struct rtattr **) _rtattr;
777 if (rtmsg->rtmsg_dst_len > 128 || rtmsg->rtmsg_src_len > 128)
779 #ifndef CONFIG_IPV6_SUBTREES
780 if (rtmsg->rtmsg_src_len)
783 if (rtmsg->rtmsg_ifindex) {
785 dev = dev_get_by_index(rtmsg->rtmsg_ifindex);
788 idev = in6_dev_get(dev);
793 if (rtmsg->rtmsg_metric == 0)
794 rtmsg->rtmsg_metric = IP6_RT_PRIO_USER;
796 rt = ip6_dst_alloc();
803 rt->u.dst.obsolete = -1;
804 rt->rt6i_expires = jiffies + clock_t_to_jiffies(rtmsg->rtmsg_info);
805 if (nlh && (r = NLMSG_DATA(nlh))) {
806 rt->rt6i_protocol = r->rtm_protocol;
808 rt->rt6i_protocol = RTPROT_BOOT;
811 addr_type = ipv6_addr_type(&rtmsg->rtmsg_dst);
813 if (addr_type & IPV6_ADDR_MULTICAST)
814 rt->u.dst.input = ip6_mc_input;
816 rt->u.dst.input = ip6_forward;
818 rt->u.dst.output = ip6_output;
820 ipv6_addr_prefix(&rt->rt6i_dst.addr,
821 &rtmsg->rtmsg_dst, rtmsg->rtmsg_dst_len);
822 rt->rt6i_dst.plen = rtmsg->rtmsg_dst_len;
823 if (rt->rt6i_dst.plen == 128)
824 rt->u.dst.flags = DST_HOST;
826 #ifdef CONFIG_IPV6_SUBTREES
827 ipv6_addr_prefix(&rt->rt6i_src.addr,
828 &rtmsg->rtmsg_src, rtmsg->rtmsg_src_len);
829 rt->rt6i_src.plen = rtmsg->rtmsg_src_len;
832 rt->rt6i_metric = rtmsg->rtmsg_metric;
834 /* We cannot add true routes via loopback here,
835 they would result in kernel looping; promote them to reject routes
837 if ((rtmsg->rtmsg_flags&RTF_REJECT) ||
838 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
839 /* hold loopback dev/idev if we haven't done so. */
840 if (dev != &loopback_dev) {
847 idev = in6_dev_get(dev);
853 rt->u.dst.output = ip6_pkt_discard_out;
854 rt->u.dst.input = ip6_pkt_discard;
855 rt->u.dst.error = -ENETUNREACH;
856 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
860 if (rtmsg->rtmsg_flags & RTF_GATEWAY) {
861 struct in6_addr *gw_addr;
864 gw_addr = &rtmsg->rtmsg_gateway;
865 ipv6_addr_copy(&rt->rt6i_gateway, &rtmsg->rtmsg_gateway);
866 gwa_type = ipv6_addr_type(gw_addr);
868 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
869 struct rt6_info *grt;
871 /* IPv6 strictly inhibits using not link-local
872 addresses as nexthop address.
873 Otherwise, router will not able to send redirects.
874 It is very good, but in some (rare!) circumstances
875 (SIT, PtP, NBMA NOARP links) it is handy to allow
876 some exceptions. --ANK
879 if (!(gwa_type&IPV6_ADDR_UNICAST))
882 grt = rt6_lookup(gw_addr, NULL, rtmsg->rtmsg_ifindex, 1);
888 if (dev != grt->rt6i_dev) {
889 dst_release(&grt->u.dst);
894 idev = grt->rt6i_idev;
896 in6_dev_hold(grt->rt6i_idev);
898 if (!(grt->rt6i_flags&RTF_GATEWAY))
900 dst_release(&grt->u.dst);
906 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
914 if (rtmsg->rtmsg_flags & (RTF_GATEWAY|RTF_NONEXTHOP)) {
915 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
916 if (IS_ERR(rt->rt6i_nexthop)) {
917 err = PTR_ERR(rt->rt6i_nexthop);
918 rt->rt6i_nexthop = NULL;
923 rt->rt6i_flags = rtmsg->rtmsg_flags;
926 if (rta && rta[RTA_METRICS-1]) {
927 int attrlen = RTA_PAYLOAD(rta[RTA_METRICS-1]);
928 struct rtattr *attr = RTA_DATA(rta[RTA_METRICS-1]);
930 while (RTA_OK(attr, attrlen)) {
931 unsigned flavor = attr->rta_type;
933 if (flavor > RTAX_MAX) {
937 rt->u.dst.metrics[flavor-1] =
938 *(u32 *)RTA_DATA(attr);
940 attr = RTA_NEXT(attr, attrlen);
944 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
945 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
946 if (!rt->u.dst.metrics[RTAX_MTU-1])
947 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
948 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
949 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
951 rt->rt6i_idev = idev;
952 return ip6_ins_rt(rt, nlh, _rtattr, req);
960 dst_free((struct dst_entry *) rt);
964 int ip6_del_rt(struct rt6_info *rt, struct nlmsghdr *nlh, void *_rtattr, struct netlink_skb_parms *req)
968 write_lock_bh(&rt6_lock);
970 err = fib6_del(rt, nlh, _rtattr, req);
971 dst_release(&rt->u.dst);
973 write_unlock_bh(&rt6_lock);
978 static int ip6_route_del(struct in6_rtmsg *rtmsg, struct nlmsghdr *nlh, void *_rtattr, struct netlink_skb_parms *req)
980 struct fib6_node *fn;
984 read_lock_bh(&rt6_lock);
986 fn = fib6_locate(&ip6_routing_table,
987 &rtmsg->rtmsg_dst, rtmsg->rtmsg_dst_len,
988 &rtmsg->rtmsg_src, rtmsg->rtmsg_src_len);
991 for (rt = fn->leaf; rt; rt = rt->u.next) {
992 if (rtmsg->rtmsg_ifindex &&
993 (rt->rt6i_dev == NULL ||
994 rt->rt6i_dev->ifindex != rtmsg->rtmsg_ifindex))
996 if (rtmsg->rtmsg_flags&RTF_GATEWAY &&
997 !ipv6_addr_equal(&rtmsg->rtmsg_gateway, &rt->rt6i_gateway))
999 if (rtmsg->rtmsg_metric &&
1000 rtmsg->rtmsg_metric != rt->rt6i_metric)
1002 dst_hold(&rt->u.dst);
1003 read_unlock_bh(&rt6_lock);
1005 return ip6_del_rt(rt, nlh, _rtattr, req);
1008 read_unlock_bh(&rt6_lock);
1016 void rt6_redirect(struct in6_addr *dest, struct in6_addr *saddr,
1017 struct neighbour *neigh, u8 *lladdr, int on_link)
1019 struct rt6_info *rt, *nrt;
1021 /* Locate old route to this destination. */
1022 rt = rt6_lookup(dest, NULL, neigh->dev->ifindex, 1);
1027 if (neigh->dev != rt->rt6i_dev)
1031 * Current route is on-link; redirect is always invalid.
1033 * Seems, previous statement is not true. It could
1034 * be node, which looks for us as on-link (f.e. proxy ndisc)
1035 * But then router serving it might decide, that we should
1036 * know truth 8)8) --ANK (980726).
1038 if (!(rt->rt6i_flags&RTF_GATEWAY))
1042 * RFC 2461 specifies that redirects should only be
1043 * accepted if they come from the nexthop to the target.
1044 * Due to the way default routers are chosen, this notion
1045 * is a bit fuzzy and one might need to check all default
1048 if (!ipv6_addr_equal(saddr, &rt->rt6i_gateway)) {
1049 if (rt->rt6i_flags & RTF_DEFAULT) {
1050 struct rt6_info *rt1;
1052 read_lock(&rt6_lock);
1053 for (rt1 = ip6_routing_table.leaf; rt1; rt1 = rt1->u.next) {
1054 if (ipv6_addr_equal(saddr, &rt1->rt6i_gateway)) {
1055 dst_hold(&rt1->u.dst);
1056 dst_release(&rt->u.dst);
1057 read_unlock(&rt6_lock);
1062 read_unlock(&rt6_lock);
1064 if (net_ratelimit())
1065 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1066 "for redirect target\n");
1073 * We have finally decided to accept it.
1076 neigh_update(neigh, lladdr, NUD_STALE,
1077 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1078 NEIGH_UPDATE_F_OVERRIDE|
1079 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1080 NEIGH_UPDATE_F_ISROUTER))
1084 * Redirect received -> path was valid.
1085 * Look, redirects are sent only in response to data packets,
1086 * so that this nexthop apparently is reachable. --ANK
1088 dst_confirm(&rt->u.dst);
1090 /* Duplicate redirect: silently ignore. */
1091 if (neigh == rt->u.dst.neighbour)
1094 nrt = ip6_rt_copy(rt);
1098 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1100 nrt->rt6i_flags &= ~RTF_GATEWAY;
1102 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1103 nrt->rt6i_dst.plen = 128;
1104 nrt->u.dst.flags |= DST_HOST;
1106 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1107 nrt->rt6i_nexthop = neigh_clone(neigh);
1108 /* Reset pmtu, it may be better */
1109 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1110 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1112 if (ip6_ins_rt(nrt, NULL, NULL, NULL))
1115 if (rt->rt6i_flags&RTF_CACHE) {
1116 ip6_del_rt(rt, NULL, NULL, NULL);
1121 dst_release(&rt->u.dst);
1126 * Handle ICMP "packet too big" messages
1127 * i.e. Path MTU discovery
1130 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1131 struct net_device *dev, u32 pmtu)
1133 struct rt6_info *rt, *nrt;
1136 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1140 if (pmtu >= dst_mtu(&rt->u.dst))
1143 if (pmtu < IPV6_MIN_MTU) {
1145 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1146 * MTU (1280) and a fragment header should always be included
1147 * after a node receiving Too Big message reporting PMTU is
1148 * less than the IPv6 Minimum Link MTU.
1150 pmtu = IPV6_MIN_MTU;
1154 /* New mtu received -> path was valid.
1155 They are sent only in response to data packets,
1156 so that this nexthop apparently is reachable. --ANK
1158 dst_confirm(&rt->u.dst);
1160 /* Host route. If it is static, it would be better
1161 not to override it, but add new one, so that
1162 when cache entry will expire old pmtu
1163 would return automatically.
1165 if (rt->rt6i_flags & RTF_CACHE) {
1166 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1168 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1169 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1170 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1175 Two cases are possible:
1176 1. It is connected route. Action: COW
1177 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1179 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1180 nrt = rt6_alloc_cow(rt, daddr, saddr);
1182 nrt = rt6_alloc_clone(rt, daddr);
1185 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1187 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1189 /* According to RFC 1981, detecting PMTU increase shouldn't be
1190 * happened within 5 mins, the recommended timer is 10 mins.
1191 * Here this route expiration time is set to ip6_rt_mtu_expires
1192 * which is 10 mins. After 10 mins the decreased pmtu is expired
1193 * and detecting PMTU increase will be automatically happened.
1195 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1196 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1198 ip6_ins_rt(nrt, NULL, NULL, NULL);
1201 dst_release(&rt->u.dst);
1205 * Misc support functions
1208 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1210 struct rt6_info *rt = ip6_dst_alloc();
1213 rt->u.dst.input = ort->u.dst.input;
1214 rt->u.dst.output = ort->u.dst.output;
1216 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
1217 rt->u.dst.dev = ort->u.dst.dev;
1219 dev_hold(rt->u.dst.dev);
1220 rt->rt6i_idev = ort->rt6i_idev;
1222 in6_dev_hold(rt->rt6i_idev);
1223 rt->u.dst.lastuse = jiffies;
1224 rt->rt6i_expires = 0;
1226 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1227 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1228 rt->rt6i_metric = 0;
1230 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1231 #ifdef CONFIG_IPV6_SUBTREES
1232 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1238 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1240 struct rt6_info *rt;
1241 struct fib6_node *fn;
1243 fn = &ip6_routing_table;
1245 write_lock_bh(&rt6_lock);
1246 for (rt = fn->leaf; rt; rt=rt->u.next) {
1247 if (dev == rt->rt6i_dev &&
1248 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1249 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1253 dst_hold(&rt->u.dst);
1254 write_unlock_bh(&rt6_lock);
1258 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1259 struct net_device *dev)
1261 struct in6_rtmsg rtmsg;
1263 memset(&rtmsg, 0, sizeof(struct in6_rtmsg));
1264 rtmsg.rtmsg_type = RTMSG_NEWROUTE;
1265 ipv6_addr_copy(&rtmsg.rtmsg_gateway, gwaddr);
1266 rtmsg.rtmsg_metric = 1024;
1267 rtmsg.rtmsg_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT | RTF_UP | RTF_EXPIRES;
1269 rtmsg.rtmsg_ifindex = dev->ifindex;
1271 ip6_route_add(&rtmsg, NULL, NULL, NULL);
1272 return rt6_get_dflt_router(gwaddr, dev);
1275 void rt6_purge_dflt_routers(void)
1277 struct rt6_info *rt;
1280 read_lock_bh(&rt6_lock);
1281 for (rt = ip6_routing_table.leaf; rt; rt = rt->u.next) {
1282 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1283 dst_hold(&rt->u.dst);
1285 read_unlock_bh(&rt6_lock);
1287 ip6_del_rt(rt, NULL, NULL, NULL);
1292 read_unlock_bh(&rt6_lock);
1295 int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1297 struct in6_rtmsg rtmsg;
1301 case SIOCADDRT: /* Add a route */
1302 case SIOCDELRT: /* Delete a route */
1303 if (!capable(CAP_NET_ADMIN))
1305 err = copy_from_user(&rtmsg, arg,
1306 sizeof(struct in6_rtmsg));
1313 err = ip6_route_add(&rtmsg, NULL, NULL, NULL);
1316 err = ip6_route_del(&rtmsg, NULL, NULL, NULL);
1330 * Drop the packet on the floor
1333 static int ip6_pkt_discard(struct sk_buff *skb)
1335 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
1336 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_NOROUTE, 0, skb->dev);
1341 static int ip6_pkt_discard_out(struct sk_buff *skb)
1343 skb->dev = skb->dst->dev;
1344 return ip6_pkt_discard(skb);
1348 * Allocate a dst for local (unicast / anycast) address.
1351 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1352 const struct in6_addr *addr,
1355 struct rt6_info *rt = ip6_dst_alloc();
1358 return ERR_PTR(-ENOMEM);
1360 dev_hold(&loopback_dev);
1363 rt->u.dst.flags = DST_HOST;
1364 rt->u.dst.input = ip6_input;
1365 rt->u.dst.output = ip6_output;
1366 rt->rt6i_dev = &loopback_dev;
1367 rt->rt6i_idev = idev;
1368 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1369 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1370 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1371 rt->u.dst.obsolete = -1;
1373 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1375 rt->rt6i_flags |= RTF_ANYCAST;
1377 rt->rt6i_flags |= RTF_LOCAL;
1378 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1379 if (rt->rt6i_nexthop == NULL) {
1380 dst_free((struct dst_entry *) rt);
1381 return ERR_PTR(-ENOMEM);
1384 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1385 rt->rt6i_dst.plen = 128;
1387 atomic_set(&rt->u.dst.__refcnt, 1);
1392 static int fib6_ifdown(struct rt6_info *rt, void *arg)
1394 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1395 rt != &ip6_null_entry) {
1396 RT6_TRACE("deleted by ifdown %p\n", rt);
1402 void rt6_ifdown(struct net_device *dev)
1404 write_lock_bh(&rt6_lock);
1405 fib6_clean_tree(&ip6_routing_table, fib6_ifdown, 0, dev);
1406 write_unlock_bh(&rt6_lock);
1409 struct rt6_mtu_change_arg
1411 struct net_device *dev;
1415 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1417 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1418 struct inet6_dev *idev;
1420 /* In IPv6 pmtu discovery is not optional,
1421 so that RTAX_MTU lock cannot disable it.
1422 We still use this lock to block changes
1423 caused by addrconf/ndisc.
1426 idev = __in6_dev_get(arg->dev);
1430 /* For administrative MTU increase, there is no way to discover
1431 IPv6 PMTU increase, so PMTU increase should be updated here.
1432 Since RFC 1981 doesn't include administrative MTU increase
1433 update PMTU increase is a MUST. (i.e. jumbo frame)
1436 If new MTU is less than route PMTU, this new MTU will be the
1437 lowest MTU in the path, update the route PMTU to reflect PMTU
1438 decreases; if new MTU is greater than route PMTU, and the
1439 old MTU is the lowest MTU in the path, update the route PMTU
1440 to reflect the increase. In this case if the other nodes' MTU
1441 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1444 if (rt->rt6i_dev == arg->dev &&
1445 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1446 (dst_mtu(&rt->u.dst) > arg->mtu ||
1447 (dst_mtu(&rt->u.dst) < arg->mtu &&
1448 dst_mtu(&rt->u.dst) == idev->cnf.mtu6)))
1449 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1450 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1454 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1456 struct rt6_mtu_change_arg arg;
1460 read_lock_bh(&rt6_lock);
1461 fib6_clean_tree(&ip6_routing_table, rt6_mtu_change_route, 0, &arg);
1462 read_unlock_bh(&rt6_lock);
1465 static int inet6_rtm_to_rtmsg(struct rtmsg *r, struct rtattr **rta,
1466 struct in6_rtmsg *rtmsg)
1468 memset(rtmsg, 0, sizeof(*rtmsg));
1470 rtmsg->rtmsg_dst_len = r->rtm_dst_len;
1471 rtmsg->rtmsg_src_len = r->rtm_src_len;
1472 rtmsg->rtmsg_flags = RTF_UP;
1473 if (r->rtm_type == RTN_UNREACHABLE)
1474 rtmsg->rtmsg_flags |= RTF_REJECT;
1476 if (rta[RTA_GATEWAY-1]) {
1477 if (rta[RTA_GATEWAY-1]->rta_len != RTA_LENGTH(16))
1479 memcpy(&rtmsg->rtmsg_gateway, RTA_DATA(rta[RTA_GATEWAY-1]), 16);
1480 rtmsg->rtmsg_flags |= RTF_GATEWAY;
1482 if (rta[RTA_DST-1]) {
1483 if (RTA_PAYLOAD(rta[RTA_DST-1]) < ((r->rtm_dst_len+7)>>3))
1485 memcpy(&rtmsg->rtmsg_dst, RTA_DATA(rta[RTA_DST-1]), ((r->rtm_dst_len+7)>>3));
1487 if (rta[RTA_SRC-1]) {
1488 if (RTA_PAYLOAD(rta[RTA_SRC-1]) < ((r->rtm_src_len+7)>>3))
1490 memcpy(&rtmsg->rtmsg_src, RTA_DATA(rta[RTA_SRC-1]), ((r->rtm_src_len+7)>>3));
1492 if (rta[RTA_OIF-1]) {
1493 if (rta[RTA_OIF-1]->rta_len != RTA_LENGTH(sizeof(int)))
1495 memcpy(&rtmsg->rtmsg_ifindex, RTA_DATA(rta[RTA_OIF-1]), sizeof(int));
1497 if (rta[RTA_PRIORITY-1]) {
1498 if (rta[RTA_PRIORITY-1]->rta_len != RTA_LENGTH(4))
1500 memcpy(&rtmsg->rtmsg_metric, RTA_DATA(rta[RTA_PRIORITY-1]), 4);
1505 int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1507 struct rtmsg *r = NLMSG_DATA(nlh);
1508 struct in6_rtmsg rtmsg;
1510 if (inet6_rtm_to_rtmsg(r, arg, &rtmsg))
1512 return ip6_route_del(&rtmsg, nlh, arg, &NETLINK_CB(skb));
1515 int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1517 struct rtmsg *r = NLMSG_DATA(nlh);
1518 struct in6_rtmsg rtmsg;
1520 if (inet6_rtm_to_rtmsg(r, arg, &rtmsg))
1522 return ip6_route_add(&rtmsg, nlh, arg, &NETLINK_CB(skb));
1525 struct rt6_rtnl_dump_arg
1527 struct sk_buff *skb;
1528 struct netlink_callback *cb;
1531 static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
1532 struct in6_addr *dst, struct in6_addr *src,
1533 int iif, int type, u32 pid, u32 seq,
1534 int prefix, unsigned int flags)
1537 struct nlmsghdr *nlh;
1538 unsigned char *b = skb->tail;
1539 struct rta_cacheinfo ci;
1541 if (prefix) { /* user wants prefix routes only */
1542 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
1543 /* success since this is not a prefix route */
1548 nlh = NLMSG_NEW(skb, pid, seq, type, sizeof(*rtm), flags);
1549 rtm = NLMSG_DATA(nlh);
1550 rtm->rtm_family = AF_INET6;
1551 rtm->rtm_dst_len = rt->rt6i_dst.plen;
1552 rtm->rtm_src_len = rt->rt6i_src.plen;
1554 rtm->rtm_table = RT_TABLE_MAIN;
1555 if (rt->rt6i_flags&RTF_REJECT)
1556 rtm->rtm_type = RTN_UNREACHABLE;
1557 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
1558 rtm->rtm_type = RTN_LOCAL;
1560 rtm->rtm_type = RTN_UNICAST;
1562 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
1563 rtm->rtm_protocol = rt->rt6i_protocol;
1564 if (rt->rt6i_flags&RTF_DYNAMIC)
1565 rtm->rtm_protocol = RTPROT_REDIRECT;
1566 else if (rt->rt6i_flags & RTF_ADDRCONF)
1567 rtm->rtm_protocol = RTPROT_KERNEL;
1568 else if (rt->rt6i_flags&RTF_DEFAULT)
1569 rtm->rtm_protocol = RTPROT_RA;
1571 if (rt->rt6i_flags&RTF_CACHE)
1572 rtm->rtm_flags |= RTM_F_CLONED;
1575 RTA_PUT(skb, RTA_DST, 16, dst);
1576 rtm->rtm_dst_len = 128;
1577 } else if (rtm->rtm_dst_len)
1578 RTA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
1579 #ifdef CONFIG_IPV6_SUBTREES
1581 RTA_PUT(skb, RTA_SRC, 16, src);
1582 rtm->rtm_src_len = 128;
1583 } else if (rtm->rtm_src_len)
1584 RTA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
1587 RTA_PUT(skb, RTA_IIF, 4, &iif);
1589 struct in6_addr saddr_buf;
1590 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
1591 RTA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
1593 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
1594 goto rtattr_failure;
1595 if (rt->u.dst.neighbour)
1596 RTA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
1598 RTA_PUT(skb, RTA_OIF, sizeof(int), &rt->rt6i_dev->ifindex);
1599 RTA_PUT(skb, RTA_PRIORITY, 4, &rt->rt6i_metric);
1600 ci.rta_lastuse = jiffies_to_clock_t(jiffies - rt->u.dst.lastuse);
1601 if (rt->rt6i_expires)
1602 ci.rta_expires = jiffies_to_clock_t(rt->rt6i_expires - jiffies);
1605 ci.rta_used = rt->u.dst.__use;
1606 ci.rta_clntref = atomic_read(&rt->u.dst.__refcnt);
1607 ci.rta_error = rt->u.dst.error;
1611 RTA_PUT(skb, RTA_CACHEINFO, sizeof(ci), &ci);
1612 nlh->nlmsg_len = skb->tail - b;
1617 skb_trim(skb, b - skb->data);
1621 static int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1623 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
1626 if (arg->cb->nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(struct rtmsg))) {
1627 struct rtmsg *rtm = NLMSG_DATA(arg->cb->nlh);
1628 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
1632 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
1633 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
1634 prefix, NLM_F_MULTI);
1637 static int fib6_dump_node(struct fib6_walker_t *w)
1640 struct rt6_info *rt;
1642 for (rt = w->leaf; rt; rt = rt->u.next) {
1643 res = rt6_dump_route(rt, w->args);
1645 /* Frame is full, suspend walking */
1655 static void fib6_dump_end(struct netlink_callback *cb)
1657 struct fib6_walker_t *w = (void*)cb->args[0];
1661 fib6_walker_unlink(w);
1664 cb->done = (void*)cb->args[1];
1668 static int fib6_dump_done(struct netlink_callback *cb)
1671 return cb->done ? cb->done(cb) : 0;
1674 int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
1676 struct rt6_rtnl_dump_arg arg;
1677 struct fib6_walker_t *w;
1683 w = (void*)cb->args[0];
1687 * 1. hook callback destructor.
1689 cb->args[1] = (long)cb->done;
1690 cb->done = fib6_dump_done;
1693 * 2. allocate and initialize walker.
1695 w = kmalloc(sizeof(*w), GFP_ATOMIC);
1698 RT6_TRACE("dump<%p", w);
1699 memset(w, 0, sizeof(*w));
1700 w->root = &ip6_routing_table;
1701 w->func = fib6_dump_node;
1703 cb->args[0] = (long)w;
1704 read_lock_bh(&rt6_lock);
1706 read_unlock_bh(&rt6_lock);
1709 read_lock_bh(&rt6_lock);
1710 res = fib6_walk_continue(w);
1711 read_unlock_bh(&rt6_lock);
1714 if (res <= 0 && skb->len == 0)
1715 RT6_TRACE("%p>dump end\n", w);
1717 res = res < 0 ? res : skb->len;
1718 /* res < 0 is an error. (really, impossible)
1719 res == 0 means that dump is complete, but skb still can contain data.
1720 res > 0 dump is not complete, but frame is full.
1722 /* Destroy walker, if dump of this table is complete. */
1728 int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
1730 struct rtattr **rta = arg;
1733 struct sk_buff *skb;
1735 struct rt6_info *rt;
1737 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1741 /* Reserve room for dummy headers, this skb can pass
1742 through good chunk of routing engine.
1744 skb->mac.raw = skb->data;
1745 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1747 memset(&fl, 0, sizeof(fl));
1749 ipv6_addr_copy(&fl.fl6_src,
1750 (struct in6_addr*)RTA_DATA(rta[RTA_SRC-1]));
1752 ipv6_addr_copy(&fl.fl6_dst,
1753 (struct in6_addr*)RTA_DATA(rta[RTA_DST-1]));
1756 memcpy(&iif, RTA_DATA(rta[RTA_IIF-1]), sizeof(int));
1759 struct net_device *dev;
1760 dev = __dev_get_by_index(iif);
1769 memcpy(&fl.oif, RTA_DATA(rta[RTA_OIF-1]), sizeof(int));
1771 rt = (struct rt6_info*)ip6_route_output(NULL, &fl);
1773 skb->dst = &rt->u.dst;
1775 NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
1776 err = rt6_fill_node(skb, rt,
1777 &fl.fl6_dst, &fl.fl6_src,
1779 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
1780 nlh->nlmsg_seq, 0, 0);
1786 err = netlink_unicast(rtnl, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
1796 void inet6_rt_notify(int event, struct rt6_info *rt, struct nlmsghdr *nlh,
1797 struct netlink_skb_parms *req)
1799 struct sk_buff *skb;
1800 int size = NLMSG_SPACE(sizeof(struct rtmsg)+256);
1801 u32 pid = current->pid;
1807 seq = nlh->nlmsg_seq;
1809 skb = alloc_skb(size, gfp_any());
1811 netlink_set_err(rtnl, 0, RTNLGRP_IPV6_ROUTE, ENOBUFS);
1814 if (rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0) < 0) {
1816 netlink_set_err(rtnl, 0, RTNLGRP_IPV6_ROUTE, EINVAL);
1819 NETLINK_CB(skb).dst_group = RTNLGRP_IPV6_ROUTE;
1820 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV6_ROUTE, gfp_any());
1827 #ifdef CONFIG_PROC_FS
1829 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
1840 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
1842 struct rt6_proc_arg *arg = (struct rt6_proc_arg *) p_arg;
1845 if (arg->skip < arg->offset / RT6_INFO_LEN) {
1850 if (arg->len >= arg->length)
1853 for (i=0; i<16; i++) {
1854 sprintf(arg->buffer + arg->len, "%02x",
1855 rt->rt6i_dst.addr.s6_addr[i]);
1858 arg->len += sprintf(arg->buffer + arg->len, " %02x ",
1861 #ifdef CONFIG_IPV6_SUBTREES
1862 for (i=0; i<16; i++) {
1863 sprintf(arg->buffer + arg->len, "%02x",
1864 rt->rt6i_src.addr.s6_addr[i]);
1867 arg->len += sprintf(arg->buffer + arg->len, " %02x ",
1870 sprintf(arg->buffer + arg->len,
1871 "00000000000000000000000000000000 00 ");
1875 if (rt->rt6i_nexthop) {
1876 for (i=0; i<16; i++) {
1877 sprintf(arg->buffer + arg->len, "%02x",
1878 rt->rt6i_nexthop->primary_key[i]);
1882 sprintf(arg->buffer + arg->len,
1883 "00000000000000000000000000000000");
1886 arg->len += sprintf(arg->buffer + arg->len,
1887 " %08x %08x %08x %08x %8s\n",
1888 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
1889 rt->u.dst.__use, rt->rt6i_flags,
1890 rt->rt6i_dev ? rt->rt6i_dev->name : "");
1894 static int rt6_proc_info(char *buffer, char **start, off_t offset, int length)
1896 struct rt6_proc_arg arg;
1897 arg.buffer = buffer;
1898 arg.offset = offset;
1899 arg.length = length;
1903 read_lock_bh(&rt6_lock);
1904 fib6_clean_tree(&ip6_routing_table, rt6_info_route, 0, &arg);
1905 read_unlock_bh(&rt6_lock);
1909 *start += offset % RT6_INFO_LEN;
1911 arg.len -= offset % RT6_INFO_LEN;
1913 if (arg.len > length)
1921 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
1923 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
1924 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
1925 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
1926 rt6_stats.fib_rt_cache,
1927 atomic_read(&ip6_dst_ops.entries),
1928 rt6_stats.fib_discarded_routes);
1933 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
1935 return single_open(file, rt6_stats_seq_show, NULL);
1938 static struct file_operations rt6_stats_seq_fops = {
1939 .owner = THIS_MODULE,
1940 .open = rt6_stats_seq_open,
1942 .llseek = seq_lseek,
1943 .release = single_release,
1945 #endif /* CONFIG_PROC_FS */
1947 #ifdef CONFIG_SYSCTL
1949 static int flush_delay;
1952 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
1953 void __user *buffer, size_t *lenp, loff_t *ppos)
1956 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1957 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
1963 ctl_table ipv6_route_table[] = {
1965 .ctl_name = NET_IPV6_ROUTE_FLUSH,
1966 .procname = "flush",
1967 .data = &flush_delay,
1968 .maxlen = sizeof(int),
1970 .proc_handler = &ipv6_sysctl_rtcache_flush
1973 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
1974 .procname = "gc_thresh",
1975 .data = &ip6_dst_ops.gc_thresh,
1976 .maxlen = sizeof(int),
1978 .proc_handler = &proc_dointvec,
1981 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
1982 .procname = "max_size",
1983 .data = &ip6_rt_max_size,
1984 .maxlen = sizeof(int),
1986 .proc_handler = &proc_dointvec,
1989 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
1990 .procname = "gc_min_interval",
1991 .data = &ip6_rt_gc_min_interval,
1992 .maxlen = sizeof(int),
1994 .proc_handler = &proc_dointvec_jiffies,
1995 .strategy = &sysctl_jiffies,
1998 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
1999 .procname = "gc_timeout",
2000 .data = &ip6_rt_gc_timeout,
2001 .maxlen = sizeof(int),
2003 .proc_handler = &proc_dointvec_jiffies,
2004 .strategy = &sysctl_jiffies,
2007 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2008 .procname = "gc_interval",
2009 .data = &ip6_rt_gc_interval,
2010 .maxlen = sizeof(int),
2012 .proc_handler = &proc_dointvec_jiffies,
2013 .strategy = &sysctl_jiffies,
2016 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2017 .procname = "gc_elasticity",
2018 .data = &ip6_rt_gc_elasticity,
2019 .maxlen = sizeof(int),
2021 .proc_handler = &proc_dointvec_jiffies,
2022 .strategy = &sysctl_jiffies,
2025 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2026 .procname = "mtu_expires",
2027 .data = &ip6_rt_mtu_expires,
2028 .maxlen = sizeof(int),
2030 .proc_handler = &proc_dointvec_jiffies,
2031 .strategy = &sysctl_jiffies,
2034 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2035 .procname = "min_adv_mss",
2036 .data = &ip6_rt_min_advmss,
2037 .maxlen = sizeof(int),
2039 .proc_handler = &proc_dointvec_jiffies,
2040 .strategy = &sysctl_jiffies,
2043 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2044 .procname = "gc_min_interval_ms",
2045 .data = &ip6_rt_gc_min_interval,
2046 .maxlen = sizeof(int),
2048 .proc_handler = &proc_dointvec_ms_jiffies,
2049 .strategy = &sysctl_ms_jiffies,
2056 void __init ip6_route_init(void)
2058 struct proc_dir_entry *p;
2060 ip6_dst_ops.kmem_cachep = kmem_cache_create("ip6_dst_cache",
2061 sizeof(struct rt6_info),
2062 0, SLAB_HWCACHE_ALIGN,
2064 if (!ip6_dst_ops.kmem_cachep)
2065 panic("cannot create ip6_dst_cache");
2068 #ifdef CONFIG_PROC_FS
2069 p = proc_net_create("ipv6_route", 0, rt6_proc_info);
2071 p->owner = THIS_MODULE;
2073 proc_net_fops_create("rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2080 void ip6_route_cleanup(void)
2082 #ifdef CONFIG_PROC_FS
2083 proc_net_remove("ipv6_route");
2084 proc_net_remove("rt6_stats");
2091 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);