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/errno.h>
29 #include <linux/types.h>
30 #include <linux/times.h>
31 #include <linux/socket.h>
32 #include <linux/sockios.h>
33 #include <linux/net.h>
34 #include <linux/route.h>
35 #include <linux/netdevice.h>
36 #include <linux/in6.h>
37 #include <linux/init.h>
38 #include <linux/netlink.h>
39 #include <linux/if_arp.h>
42 #include <linux/proc_fs.h>
43 #include <linux/seq_file.h>
48 #include <net/ip6_fib.h>
49 #include <net/ip6_route.h>
50 #include <net/ndisc.h>
51 #include <net/addrconf.h>
53 #include <linux/rtnetlink.h>
56 #include <net/netevent.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 #ifdef CONFIG_IPV6_ROUTE_INFO
102 static struct rt6_info
*rt6_add_route_info(struct in6_addr
*prefix
, int prefixlen
,
103 struct in6_addr
*gwaddr
, int ifindex
,
105 static struct rt6_info
*rt6_get_route_info(struct in6_addr
*prefix
, int prefixlen
,
106 struct in6_addr
*gwaddr
, int ifindex
);
109 static struct dst_ops ip6_dst_ops
= {
111 .protocol
= __constant_htons(ETH_P_IPV6
),
114 .check
= ip6_dst_check
,
115 .destroy
= ip6_dst_destroy
,
116 .ifdown
= ip6_dst_ifdown
,
117 .negative_advice
= ip6_negative_advice
,
118 .link_failure
= ip6_link_failure
,
119 .update_pmtu
= ip6_rt_update_pmtu
,
120 .entry_size
= sizeof(struct rt6_info
),
123 struct rt6_info ip6_null_entry
= {
126 .__refcnt
= ATOMIC_INIT(1),
128 .dev
= &loopback_dev
,
130 .error
= -ENETUNREACH
,
131 .metrics
= { [RTAX_HOPLIMIT
- 1] = 255, },
132 .input
= ip6_pkt_discard
,
133 .output
= ip6_pkt_discard_out
,
135 .path
= (struct dst_entry
*)&ip6_null_entry
,
138 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
139 .rt6i_metric
= ~(u32
) 0,
140 .rt6i_ref
= ATOMIC_INIT(1),
143 struct fib6_node ip6_routing_table
= {
144 .leaf
= &ip6_null_entry
,
145 .fn_flags
= RTN_ROOT
| RTN_TL_ROOT
| RTN_RTINFO
,
148 /* Protects all the ip6 fib */
150 DEFINE_RWLOCK(rt6_lock
);
153 /* allocate dst with ip6_dst_ops */
154 static __inline__
struct rt6_info
*ip6_dst_alloc(void)
156 return (struct rt6_info
*)dst_alloc(&ip6_dst_ops
);
159 static void ip6_dst_destroy(struct dst_entry
*dst
)
161 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
162 struct inet6_dev
*idev
= rt
->rt6i_idev
;
165 rt
->rt6i_idev
= NULL
;
170 static void ip6_dst_ifdown(struct dst_entry
*dst
, struct net_device
*dev
,
173 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
174 struct inet6_dev
*idev
= rt
->rt6i_idev
;
176 if (dev
!= &loopback_dev
&& idev
!= NULL
&& idev
->dev
== dev
) {
177 struct inet6_dev
*loopback_idev
= in6_dev_get(&loopback_dev
);
178 if (loopback_idev
!= NULL
) {
179 rt
->rt6i_idev
= loopback_idev
;
185 static __inline__
int rt6_check_expired(const struct rt6_info
*rt
)
187 return (rt
->rt6i_flags
& RTF_EXPIRES
&&
188 time_after(jiffies
, rt
->rt6i_expires
));
192 * Route lookup. Any rt6_lock is implied.
195 static __inline__
struct rt6_info
*rt6_device_match(struct rt6_info
*rt
,
199 struct rt6_info
*local
= NULL
;
200 struct rt6_info
*sprt
;
203 for (sprt
= rt
; sprt
; sprt
= sprt
->u
.next
) {
204 struct net_device
*dev
= sprt
->rt6i_dev
;
205 if (dev
->ifindex
== oif
)
207 if (dev
->flags
& IFF_LOOPBACK
) {
208 if (sprt
->rt6i_idev
== NULL
||
209 sprt
->rt6i_idev
->dev
->ifindex
!= oif
) {
212 if (local
&& (!oif
||
213 local
->rt6i_idev
->dev
->ifindex
== oif
))
224 return &ip6_null_entry
;
229 #ifdef CONFIG_IPV6_ROUTER_PREF
230 static void rt6_probe(struct rt6_info
*rt
)
232 struct neighbour
*neigh
= rt
? rt
->rt6i_nexthop
: NULL
;
234 * Okay, this does not seem to be appropriate
235 * for now, however, we need to check if it
236 * is really so; aka Router Reachability Probing.
238 * Router Reachability Probe MUST be rate-limited
239 * to no more than one per minute.
241 if (!neigh
|| (neigh
->nud_state
& NUD_VALID
))
243 read_lock_bh(&neigh
->lock
);
244 if (!(neigh
->nud_state
& NUD_VALID
) &&
245 time_after(jiffies
, neigh
->updated
+ rt
->rt6i_idev
->cnf
.rtr_probe_interval
)) {
246 struct in6_addr mcaddr
;
247 struct in6_addr
*target
;
249 neigh
->updated
= jiffies
;
250 read_unlock_bh(&neigh
->lock
);
252 target
= (struct in6_addr
*)&neigh
->primary_key
;
253 addrconf_addr_solict_mult(target
, &mcaddr
);
254 ndisc_send_ns(rt
->rt6i_dev
, NULL
, target
, &mcaddr
, NULL
);
256 read_unlock_bh(&neigh
->lock
);
259 static inline void rt6_probe(struct rt6_info
*rt
)
266 * Default Router Selection (RFC 2461 6.3.6)
268 static int inline rt6_check_dev(struct rt6_info
*rt
, int oif
)
270 struct net_device
*dev
= rt
->rt6i_dev
;
271 if (!oif
|| dev
->ifindex
== oif
)
273 if ((dev
->flags
& IFF_LOOPBACK
) &&
274 rt
->rt6i_idev
&& rt
->rt6i_idev
->dev
->ifindex
== oif
)
279 static int inline rt6_check_neigh(struct rt6_info
*rt
)
281 struct neighbour
*neigh
= rt
->rt6i_nexthop
;
283 if (rt
->rt6i_flags
& RTF_NONEXTHOP
||
284 !(rt
->rt6i_flags
& RTF_GATEWAY
))
287 read_lock_bh(&neigh
->lock
);
288 if (neigh
->nud_state
& NUD_VALID
)
290 read_unlock_bh(&neigh
->lock
);
295 static int rt6_score_route(struct rt6_info
*rt
, int oif
,
300 m
= rt6_check_dev(rt
, oif
);
301 if (!m
&& (strict
& RT6_SELECT_F_IFACE
))
303 #ifdef CONFIG_IPV6_ROUTER_PREF
304 m
|= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt
->rt6i_flags
)) << 2;
306 n
= rt6_check_neigh(rt
);
309 else if (!n
&& strict
& RT6_SELECT_F_REACHABLE
)
314 static struct rt6_info
*rt6_select(struct rt6_info
**head
, int oif
,
317 struct rt6_info
*match
= NULL
, *last
= NULL
;
318 struct rt6_info
*rt
, *rt0
= *head
;
322 RT6_TRACE("%s(head=%p(*head=%p), oif=%d)\n",
323 __FUNCTION__
, head
, head
? *head
: NULL
, oif
);
325 for (rt
= rt0
, metric
= rt0
->rt6i_metric
;
326 rt
&& rt
->rt6i_metric
== metric
&& (!last
|| rt
!= rt0
);
330 if (rt6_check_expired(rt
))
335 m
= rt6_score_route(rt
, oif
, strict
);
349 (strict
& RT6_SELECT_F_REACHABLE
) &&
350 last
&& last
!= rt0
) {
351 /* no entries matched; do round-robin */
352 static DEFINE_SPINLOCK(lock
);
355 rt0
->u
.next
= last
->u
.next
;
360 RT6_TRACE("%s() => %p, score=%d\n",
361 __FUNCTION__
, match
, mpri
);
363 return (match
? match
: &ip6_null_entry
);
366 #ifdef CONFIG_IPV6_ROUTE_INFO
367 int rt6_route_rcv(struct net_device
*dev
, u8
*opt
, int len
,
368 struct in6_addr
*gwaddr
)
370 struct route_info
*rinfo
= (struct route_info
*) opt
;
371 struct in6_addr prefix_buf
, *prefix
;
376 if (len
< sizeof(struct route_info
)) {
380 /* Sanity check for prefix_len and length */
381 if (rinfo
->length
> 3) {
383 } else if (rinfo
->prefix_len
> 128) {
385 } else if (rinfo
->prefix_len
> 64) {
386 if (rinfo
->length
< 2) {
389 } else if (rinfo
->prefix_len
> 0) {
390 if (rinfo
->length
< 1) {
395 pref
= rinfo
->route_pref
;
396 if (pref
== ICMPV6_ROUTER_PREF_INVALID
)
397 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
399 lifetime
= htonl(rinfo
->lifetime
);
400 if (lifetime
== 0xffffffff) {
402 } else if (lifetime
> 0x7fffffff/HZ
) {
403 /* Avoid arithmetic overflow */
404 lifetime
= 0x7fffffff/HZ
- 1;
407 if (rinfo
->length
== 3)
408 prefix
= (struct in6_addr
*)rinfo
->prefix
;
410 /* this function is safe */
411 ipv6_addr_prefix(&prefix_buf
,
412 (struct in6_addr
*)rinfo
->prefix
,
414 prefix
= &prefix_buf
;
417 rt
= rt6_get_route_info(prefix
, rinfo
->prefix_len
, gwaddr
, dev
->ifindex
);
419 if (rt
&& !lifetime
) {
420 ip6_del_rt(rt
, NULL
, NULL
, NULL
);
425 rt
= rt6_add_route_info(prefix
, rinfo
->prefix_len
, gwaddr
, dev
->ifindex
,
428 rt
->rt6i_flags
= RTF_ROUTEINFO
|
429 (rt
->rt6i_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
432 if (lifetime
== 0xffffffff) {
433 rt
->rt6i_flags
&= ~RTF_EXPIRES
;
435 rt
->rt6i_expires
= jiffies
+ HZ
* lifetime
;
436 rt
->rt6i_flags
|= RTF_EXPIRES
;
438 dst_release(&rt
->u
.dst
);
444 struct rt6_info
*rt6_lookup(struct in6_addr
*daddr
, struct in6_addr
*saddr
,
447 struct fib6_node
*fn
;
450 read_lock_bh(&rt6_lock
);
451 fn
= fib6_lookup(&ip6_routing_table
, daddr
, saddr
);
452 rt
= rt6_device_match(fn
->leaf
, oif
, strict
);
453 dst_hold(&rt
->u
.dst
);
455 read_unlock_bh(&rt6_lock
);
457 rt
->u
.dst
.lastuse
= jiffies
;
458 if (rt
->u
.dst
.error
== 0)
460 dst_release(&rt
->u
.dst
);
464 /* ip6_ins_rt is called with FREE rt6_lock.
465 It takes new route entry, the addition fails by any reason the
466 route is freed. In any case, if caller does not hold it, it may
470 int ip6_ins_rt(struct rt6_info
*rt
, struct nlmsghdr
*nlh
,
471 void *_rtattr
, struct netlink_skb_parms
*req
)
475 write_lock_bh(&rt6_lock
);
476 err
= fib6_add(&ip6_routing_table
, rt
, nlh
, _rtattr
, req
);
477 write_unlock_bh(&rt6_lock
);
482 static struct rt6_info
*rt6_alloc_cow(struct rt6_info
*ort
, struct in6_addr
*daddr
,
483 struct in6_addr
*saddr
)
491 rt
= ip6_rt_copy(ort
);
494 if (!(rt
->rt6i_flags
&RTF_GATEWAY
)) {
495 if (rt
->rt6i_dst
.plen
!= 128 &&
496 ipv6_addr_equal(&rt
->rt6i_dst
.addr
, daddr
))
497 rt
->rt6i_flags
|= RTF_ANYCAST
;
498 ipv6_addr_copy(&rt
->rt6i_gateway
, daddr
);
501 ipv6_addr_copy(&rt
->rt6i_dst
.addr
, daddr
);
502 rt
->rt6i_dst
.plen
= 128;
503 rt
->rt6i_flags
|= RTF_CACHE
;
504 rt
->u
.dst
.flags
|= DST_HOST
;
506 #ifdef CONFIG_IPV6_SUBTREES
507 if (rt
->rt6i_src
.plen
&& saddr
) {
508 ipv6_addr_copy(&rt
->rt6i_src
.addr
, saddr
);
509 rt
->rt6i_src
.plen
= 128;
513 rt
->rt6i_nexthop
= ndisc_get_neigh(rt
->rt6i_dev
, &rt
->rt6i_gateway
);
520 static struct rt6_info
*rt6_alloc_clone(struct rt6_info
*ort
, struct in6_addr
*daddr
)
522 struct rt6_info
*rt
= ip6_rt_copy(ort
);
524 ipv6_addr_copy(&rt
->rt6i_dst
.addr
, daddr
);
525 rt
->rt6i_dst
.plen
= 128;
526 rt
->rt6i_flags
|= RTF_CACHE
;
527 if (rt
->rt6i_flags
& RTF_REJECT
)
528 rt
->u
.dst
.error
= ort
->u
.dst
.error
;
529 rt
->u
.dst
.flags
|= DST_HOST
;
530 rt
->rt6i_nexthop
= neigh_clone(ort
->rt6i_nexthop
);
535 #define BACKTRACK() \
536 if (rt == &ip6_null_entry) { \
537 while ((fn = fn->parent) != NULL) { \
538 if (fn->fn_flags & RTN_ROOT) { \
541 if (fn->fn_flags & RTN_RTINFO) \
547 void ip6_route_input(struct sk_buff
*skb
)
549 struct fib6_node
*fn
;
550 struct rt6_info
*rt
, *nrt
;
554 int reachable
= RT6_SELECT_F_REACHABLE
;
556 strict
= ipv6_addr_type(&skb
->nh
.ipv6h
->daddr
) & (IPV6_ADDR_MULTICAST
|IPV6_ADDR_LINKLOCAL
) ? RT6_SELECT_F_IFACE
: 0;
559 read_lock_bh(&rt6_lock
);
562 fn
= fib6_lookup(&ip6_routing_table
, &skb
->nh
.ipv6h
->daddr
,
563 &skb
->nh
.ipv6h
->saddr
);
566 rt
= rt6_select(&fn
->leaf
, skb
->dev
->ifindex
, strict
| reachable
);
568 if (rt
== &ip6_null_entry
||
569 rt
->rt6i_flags
& RTF_CACHE
)
572 dst_hold(&rt
->u
.dst
);
573 read_unlock_bh(&rt6_lock
);
575 if (!rt
->rt6i_nexthop
&& !(rt
->rt6i_flags
& RTF_NONEXTHOP
))
576 nrt
= rt6_alloc_cow(rt
, &skb
->nh
.ipv6h
->daddr
, &skb
->nh
.ipv6h
->saddr
);
578 #if CLONE_OFFLINK_ROUTE
579 nrt
= rt6_alloc_clone(rt
, &skb
->nh
.ipv6h
->daddr
);
585 dst_release(&rt
->u
.dst
);
586 rt
= nrt
? : &ip6_null_entry
;
588 dst_hold(&rt
->u
.dst
);
590 err
= ip6_ins_rt(nrt
, NULL
, NULL
, &NETLINK_CB(skb
));
599 * Race condition! In the gap, when rt6_lock was
600 * released someone could insert this route. Relookup.
602 dst_release(&rt
->u
.dst
);
610 dst_hold(&rt
->u
.dst
);
611 read_unlock_bh(&rt6_lock
);
613 rt
->u
.dst
.lastuse
= jiffies
;
615 skb
->dst
= (struct dst_entry
*) rt
;
619 struct dst_entry
* ip6_route_output(struct sock
*sk
, struct flowi
*fl
)
621 struct fib6_node
*fn
;
622 struct rt6_info
*rt
, *nrt
;
626 int reachable
= RT6_SELECT_F_REACHABLE
;
628 strict
= ipv6_addr_type(&fl
->fl6_dst
) & (IPV6_ADDR_MULTICAST
|IPV6_ADDR_LINKLOCAL
) ? RT6_SELECT_F_IFACE
: 0;
631 read_lock_bh(&rt6_lock
);
634 fn
= fib6_lookup(&ip6_routing_table
, &fl
->fl6_dst
, &fl
->fl6_src
);
637 rt
= rt6_select(&fn
->leaf
, fl
->oif
, strict
| reachable
);
639 if (rt
== &ip6_null_entry
||
640 rt
->rt6i_flags
& RTF_CACHE
)
643 dst_hold(&rt
->u
.dst
);
644 read_unlock_bh(&rt6_lock
);
646 if (!rt
->rt6i_nexthop
&& !(rt
->rt6i_flags
& RTF_NONEXTHOP
))
647 nrt
= rt6_alloc_cow(rt
, &fl
->fl6_dst
, &fl
->fl6_src
);
649 #if CLONE_OFFLINK_ROUTE
650 nrt
= rt6_alloc_clone(rt
, &fl
->fl6_dst
);
656 dst_release(&rt
->u
.dst
);
657 rt
= nrt
? : &ip6_null_entry
;
659 dst_hold(&rt
->u
.dst
);
661 err
= ip6_ins_rt(nrt
, NULL
, NULL
, NULL
);
670 * Race condition! In the gap, when rt6_lock was
671 * released someone could insert this route. Relookup.
673 dst_release(&rt
->u
.dst
);
681 dst_hold(&rt
->u
.dst
);
682 read_unlock_bh(&rt6_lock
);
684 rt
->u
.dst
.lastuse
= jiffies
;
691 * Destination cache support functions
694 static struct dst_entry
*ip6_dst_check(struct dst_entry
*dst
, u32 cookie
)
698 rt
= (struct rt6_info
*) dst
;
700 if (rt
&& rt
->rt6i_node
&& (rt
->rt6i_node
->fn_sernum
== cookie
))
706 static struct dst_entry
*ip6_negative_advice(struct dst_entry
*dst
)
708 struct rt6_info
*rt
= (struct rt6_info
*) dst
;
711 if (rt
->rt6i_flags
& RTF_CACHE
)
712 ip6_del_rt(rt
, NULL
, NULL
, NULL
);
719 static void ip6_link_failure(struct sk_buff
*skb
)
723 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_ADDR_UNREACH
, 0, skb
->dev
);
725 rt
= (struct rt6_info
*) skb
->dst
;
727 if (rt
->rt6i_flags
&RTF_CACHE
) {
728 dst_set_expires(&rt
->u
.dst
, 0);
729 rt
->rt6i_flags
|= RTF_EXPIRES
;
730 } else if (rt
->rt6i_node
&& (rt
->rt6i_flags
& RTF_DEFAULT
))
731 rt
->rt6i_node
->fn_sernum
= -1;
735 static void ip6_rt_update_pmtu(struct dst_entry
*dst
, u32 mtu
)
737 struct rt6_info
*rt6
= (struct rt6_info
*)dst
;
739 if (mtu
< dst_mtu(dst
) && rt6
->rt6i_dst
.plen
== 128) {
740 rt6
->rt6i_flags
|= RTF_MODIFIED
;
741 if (mtu
< IPV6_MIN_MTU
) {
743 dst
->metrics
[RTAX_FEATURES
-1] |= RTAX_FEATURE_ALLFRAG
;
745 dst
->metrics
[RTAX_MTU
-1] = mtu
;
746 call_netevent_notifiers(NETEVENT_PMTU_UPDATE
, dst
);
750 static int ipv6_get_mtu(struct net_device
*dev
);
752 static inline unsigned int ipv6_advmss(unsigned int mtu
)
754 mtu
-= sizeof(struct ipv6hdr
) + sizeof(struct tcphdr
);
756 if (mtu
< ip6_rt_min_advmss
)
757 mtu
= ip6_rt_min_advmss
;
760 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
761 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
762 * IPV6_MAXPLEN is also valid and means: "any MSS,
763 * rely only on pmtu discovery"
765 if (mtu
> IPV6_MAXPLEN
- sizeof(struct tcphdr
))
770 static struct dst_entry
*ndisc_dst_gc_list
;
771 DEFINE_SPINLOCK(ndisc_lock
);
773 struct dst_entry
*ndisc_dst_alloc(struct net_device
*dev
,
774 struct neighbour
*neigh
,
775 struct in6_addr
*addr
,
776 int (*output
)(struct sk_buff
*))
779 struct inet6_dev
*idev
= in6_dev_get(dev
);
781 if (unlikely(idev
== NULL
))
784 rt
= ip6_dst_alloc();
785 if (unlikely(rt
== NULL
)) {
794 neigh
= ndisc_get_neigh(dev
, addr
);
797 rt
->rt6i_idev
= idev
;
798 rt
->rt6i_nexthop
= neigh
;
799 atomic_set(&rt
->u
.dst
.__refcnt
, 1);
800 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = 255;
801 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = ipv6_get_mtu(rt
->rt6i_dev
);
802 rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(dst_mtu(&rt
->u
.dst
));
803 rt
->u
.dst
.output
= output
;
805 #if 0 /* there's no chance to use these for ndisc */
806 rt
->u
.dst
.flags
= ipv6_addr_type(addr
) & IPV6_ADDR_UNICAST
809 ipv6_addr_copy(&rt
->rt6i_dst
.addr
, addr
);
810 rt
->rt6i_dst
.plen
= 128;
813 spin_lock_bh(&ndisc_lock
);
814 rt
->u
.dst
.next
= ndisc_dst_gc_list
;
815 ndisc_dst_gc_list
= &rt
->u
.dst
;
816 spin_unlock_bh(&ndisc_lock
);
818 fib6_force_start_gc();
821 return (struct dst_entry
*)rt
;
824 int ndisc_dst_gc(int *more
)
826 struct dst_entry
*dst
, *next
, **pprev
;
832 spin_lock_bh(&ndisc_lock
);
833 pprev
= &ndisc_dst_gc_list
;
835 while ((dst
= *pprev
) != NULL
) {
836 if (!atomic_read(&dst
->__refcnt
)) {
846 spin_unlock_bh(&ndisc_lock
);
851 static int ip6_dst_gc(void)
853 static unsigned expire
= 30*HZ
;
854 static unsigned long last_gc
;
855 unsigned long now
= jiffies
;
857 if (time_after(last_gc
+ ip6_rt_gc_min_interval
, now
) &&
858 atomic_read(&ip6_dst_ops
.entries
) <= ip6_rt_max_size
)
864 if (atomic_read(&ip6_dst_ops
.entries
) < ip6_dst_ops
.gc_thresh
)
865 expire
= ip6_rt_gc_timeout
>>1;
868 expire
-= expire
>>ip6_rt_gc_elasticity
;
869 return (atomic_read(&ip6_dst_ops
.entries
) > ip6_rt_max_size
);
872 /* Clean host part of a prefix. Not necessary in radix tree,
873 but results in cleaner routing tables.
875 Remove it only when all the things will work!
878 static int ipv6_get_mtu(struct net_device
*dev
)
880 int mtu
= IPV6_MIN_MTU
;
881 struct inet6_dev
*idev
;
883 idev
= in6_dev_get(dev
);
885 mtu
= idev
->cnf
.mtu6
;
891 int ipv6_get_hoplimit(struct net_device
*dev
)
893 int hoplimit
= ipv6_devconf
.hop_limit
;
894 struct inet6_dev
*idev
;
896 idev
= in6_dev_get(dev
);
898 hoplimit
= idev
->cnf
.hop_limit
;
908 int ip6_route_add(struct in6_rtmsg
*rtmsg
, struct nlmsghdr
*nlh
,
909 void *_rtattr
, struct netlink_skb_parms
*req
)
914 struct rt6_info
*rt
= NULL
;
915 struct net_device
*dev
= NULL
;
916 struct inet6_dev
*idev
= NULL
;
919 rta
= (struct rtattr
**) _rtattr
;
921 if (rtmsg
->rtmsg_dst_len
> 128 || rtmsg
->rtmsg_src_len
> 128)
923 #ifndef CONFIG_IPV6_SUBTREES
924 if (rtmsg
->rtmsg_src_len
)
927 if (rtmsg
->rtmsg_ifindex
) {
929 dev
= dev_get_by_index(rtmsg
->rtmsg_ifindex
);
932 idev
= in6_dev_get(dev
);
937 if (rtmsg
->rtmsg_metric
== 0)
938 rtmsg
->rtmsg_metric
= IP6_RT_PRIO_USER
;
940 rt
= ip6_dst_alloc();
947 rt
->u
.dst
.obsolete
= -1;
948 rt
->rt6i_expires
= jiffies
+ clock_t_to_jiffies(rtmsg
->rtmsg_info
);
949 if (nlh
&& (r
= NLMSG_DATA(nlh
))) {
950 rt
->rt6i_protocol
= r
->rtm_protocol
;
952 rt
->rt6i_protocol
= RTPROT_BOOT
;
955 addr_type
= ipv6_addr_type(&rtmsg
->rtmsg_dst
);
957 if (addr_type
& IPV6_ADDR_MULTICAST
)
958 rt
->u
.dst
.input
= ip6_mc_input
;
960 rt
->u
.dst
.input
= ip6_forward
;
962 rt
->u
.dst
.output
= ip6_output
;
964 ipv6_addr_prefix(&rt
->rt6i_dst
.addr
,
965 &rtmsg
->rtmsg_dst
, rtmsg
->rtmsg_dst_len
);
966 rt
->rt6i_dst
.plen
= rtmsg
->rtmsg_dst_len
;
967 if (rt
->rt6i_dst
.plen
== 128)
968 rt
->u
.dst
.flags
= DST_HOST
;
970 #ifdef CONFIG_IPV6_SUBTREES
971 ipv6_addr_prefix(&rt
->rt6i_src
.addr
,
972 &rtmsg
->rtmsg_src
, rtmsg
->rtmsg_src_len
);
973 rt
->rt6i_src
.plen
= rtmsg
->rtmsg_src_len
;
976 rt
->rt6i_metric
= rtmsg
->rtmsg_metric
;
978 /* We cannot add true routes via loopback here,
979 they would result in kernel looping; promote them to reject routes
981 if ((rtmsg
->rtmsg_flags
&RTF_REJECT
) ||
982 (dev
&& (dev
->flags
&IFF_LOOPBACK
) && !(addr_type
&IPV6_ADDR_LOOPBACK
))) {
983 /* hold loopback dev/idev if we haven't done so. */
984 if (dev
!= &loopback_dev
) {
991 idev
= in6_dev_get(dev
);
997 rt
->u
.dst
.output
= ip6_pkt_discard_out
;
998 rt
->u
.dst
.input
= ip6_pkt_discard
;
999 rt
->u
.dst
.error
= -ENETUNREACH
;
1000 rt
->rt6i_flags
= RTF_REJECT
|RTF_NONEXTHOP
;
1004 if (rtmsg
->rtmsg_flags
& RTF_GATEWAY
) {
1005 struct in6_addr
*gw_addr
;
1008 gw_addr
= &rtmsg
->rtmsg_gateway
;
1009 ipv6_addr_copy(&rt
->rt6i_gateway
, &rtmsg
->rtmsg_gateway
);
1010 gwa_type
= ipv6_addr_type(gw_addr
);
1012 if (gwa_type
!= (IPV6_ADDR_LINKLOCAL
|IPV6_ADDR_UNICAST
)) {
1013 struct rt6_info
*grt
;
1015 /* IPv6 strictly inhibits using not link-local
1016 addresses as nexthop address.
1017 Otherwise, router will not able to send redirects.
1018 It is very good, but in some (rare!) circumstances
1019 (SIT, PtP, NBMA NOARP links) it is handy to allow
1020 some exceptions. --ANK
1023 if (!(gwa_type
&IPV6_ADDR_UNICAST
))
1026 grt
= rt6_lookup(gw_addr
, NULL
, rtmsg
->rtmsg_ifindex
, 1);
1028 err
= -EHOSTUNREACH
;
1032 if (dev
!= grt
->rt6i_dev
) {
1033 dst_release(&grt
->u
.dst
);
1037 dev
= grt
->rt6i_dev
;
1038 idev
= grt
->rt6i_idev
;
1040 in6_dev_hold(grt
->rt6i_idev
);
1042 if (!(grt
->rt6i_flags
&RTF_GATEWAY
))
1044 dst_release(&grt
->u
.dst
);
1050 if (dev
== NULL
|| (dev
->flags
&IFF_LOOPBACK
))
1058 if (rtmsg
->rtmsg_flags
& (RTF_GATEWAY
|RTF_NONEXTHOP
)) {
1059 rt
->rt6i_nexthop
= __neigh_lookup_errno(&nd_tbl
, &rt
->rt6i_gateway
, dev
);
1060 if (IS_ERR(rt
->rt6i_nexthop
)) {
1061 err
= PTR_ERR(rt
->rt6i_nexthop
);
1062 rt
->rt6i_nexthop
= NULL
;
1067 rt
->rt6i_flags
= rtmsg
->rtmsg_flags
;
1070 if (rta
&& rta
[RTA_METRICS
-1]) {
1071 int attrlen
= RTA_PAYLOAD(rta
[RTA_METRICS
-1]);
1072 struct rtattr
*attr
= RTA_DATA(rta
[RTA_METRICS
-1]);
1074 while (RTA_OK(attr
, attrlen
)) {
1075 unsigned flavor
= attr
->rta_type
;
1077 if (flavor
> RTAX_MAX
) {
1081 rt
->u
.dst
.metrics
[flavor
-1] =
1082 *(u32
*)RTA_DATA(attr
);
1084 attr
= RTA_NEXT(attr
, attrlen
);
1088 if (rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] == 0)
1089 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = -1;
1090 if (!rt
->u
.dst
.metrics
[RTAX_MTU
-1])
1091 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = ipv6_get_mtu(dev
);
1092 if (!rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1])
1093 rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(dst_mtu(&rt
->u
.dst
));
1094 rt
->u
.dst
.dev
= dev
;
1095 rt
->rt6i_idev
= idev
;
1096 return ip6_ins_rt(rt
, nlh
, _rtattr
, req
);
1104 dst_free((struct dst_entry
*) rt
);
1108 int ip6_del_rt(struct rt6_info
*rt
, struct nlmsghdr
*nlh
, void *_rtattr
, struct netlink_skb_parms
*req
)
1112 write_lock_bh(&rt6_lock
);
1114 err
= fib6_del(rt
, nlh
, _rtattr
, req
);
1115 dst_release(&rt
->u
.dst
);
1117 write_unlock_bh(&rt6_lock
);
1122 static int ip6_route_del(struct in6_rtmsg
*rtmsg
, struct nlmsghdr
*nlh
, void *_rtattr
, struct netlink_skb_parms
*req
)
1124 struct fib6_node
*fn
;
1125 struct rt6_info
*rt
;
1128 read_lock_bh(&rt6_lock
);
1130 fn
= fib6_locate(&ip6_routing_table
,
1131 &rtmsg
->rtmsg_dst
, rtmsg
->rtmsg_dst_len
,
1132 &rtmsg
->rtmsg_src
, rtmsg
->rtmsg_src_len
);
1135 for (rt
= fn
->leaf
; rt
; rt
= rt
->u
.next
) {
1136 if (rtmsg
->rtmsg_ifindex
&&
1137 (rt
->rt6i_dev
== NULL
||
1138 rt
->rt6i_dev
->ifindex
!= rtmsg
->rtmsg_ifindex
))
1140 if (rtmsg
->rtmsg_flags
&RTF_GATEWAY
&&
1141 !ipv6_addr_equal(&rtmsg
->rtmsg_gateway
, &rt
->rt6i_gateway
))
1143 if (rtmsg
->rtmsg_metric
&&
1144 rtmsg
->rtmsg_metric
!= rt
->rt6i_metric
)
1146 dst_hold(&rt
->u
.dst
);
1147 read_unlock_bh(&rt6_lock
);
1149 return ip6_del_rt(rt
, nlh
, _rtattr
, req
);
1152 read_unlock_bh(&rt6_lock
);
1160 void rt6_redirect(struct in6_addr
*dest
, struct in6_addr
*saddr
,
1161 struct neighbour
*neigh
, u8
*lladdr
, int on_link
)
1163 struct rt6_info
*rt
, *nrt
= NULL
;
1165 struct fib6_node
*fn
;
1166 struct netevent_redirect netevent
;
1169 * Get the "current" route for this destination and
1170 * check if the redirect has come from approriate router.
1172 * RFC 2461 specifies that redirects should only be
1173 * accepted if they come from the nexthop to the target.
1174 * Due to the way the routes are chosen, this notion
1175 * is a bit fuzzy and one might need to check all possible
1178 strict
= ipv6_addr_type(dest
) & (IPV6_ADDR_MULTICAST
| IPV6_ADDR_LINKLOCAL
);
1180 read_lock_bh(&rt6_lock
);
1181 fn
= fib6_lookup(&ip6_routing_table
, dest
, NULL
);
1183 for (rt
= fn
->leaf
; rt
; rt
= rt
->u
.next
) {
1185 * Current route is on-link; redirect is always invalid.
1187 * Seems, previous statement is not true. It could
1188 * be node, which looks for us as on-link (f.e. proxy ndisc)
1189 * But then router serving it might decide, that we should
1190 * know truth 8)8) --ANK (980726).
1192 if (rt6_check_expired(rt
))
1194 if (!(rt
->rt6i_flags
& RTF_GATEWAY
))
1196 if (neigh
->dev
!= rt
->rt6i_dev
)
1198 if (!ipv6_addr_equal(saddr
, &rt
->rt6i_gateway
))
1203 dst_hold(&rt
->u
.dst
);
1205 while ((fn
= fn
->parent
) != NULL
) {
1206 if (fn
->fn_flags
& RTN_ROOT
)
1208 if (fn
->fn_flags
& RTN_RTINFO
)
1212 read_unlock_bh(&rt6_lock
);
1215 if (net_ratelimit())
1216 printk(KERN_DEBUG
"rt6_redirect: source isn't a valid nexthop "
1217 "for redirect target\n");
1222 * We have finally decided to accept it.
1225 neigh_update(neigh
, lladdr
, NUD_STALE
,
1226 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1227 NEIGH_UPDATE_F_OVERRIDE
|
1228 (on_link
? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
1229 NEIGH_UPDATE_F_ISROUTER
))
1233 * Redirect received -> path was valid.
1234 * Look, redirects are sent only in response to data packets,
1235 * so that this nexthop apparently is reachable. --ANK
1237 dst_confirm(&rt
->u
.dst
);
1239 /* Duplicate redirect: silently ignore. */
1240 if (neigh
== rt
->u
.dst
.neighbour
)
1243 nrt
= ip6_rt_copy(rt
);
1247 nrt
->rt6i_flags
= RTF_GATEWAY
|RTF_UP
|RTF_DYNAMIC
|RTF_CACHE
;
1249 nrt
->rt6i_flags
&= ~RTF_GATEWAY
;
1251 ipv6_addr_copy(&nrt
->rt6i_dst
.addr
, dest
);
1252 nrt
->rt6i_dst
.plen
= 128;
1253 nrt
->u
.dst
.flags
|= DST_HOST
;
1255 ipv6_addr_copy(&nrt
->rt6i_gateway
, (struct in6_addr
*)neigh
->primary_key
);
1256 nrt
->rt6i_nexthop
= neigh_clone(neigh
);
1257 /* Reset pmtu, it may be better */
1258 nrt
->u
.dst
.metrics
[RTAX_MTU
-1] = ipv6_get_mtu(neigh
->dev
);
1259 nrt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(dst_mtu(&nrt
->u
.dst
));
1261 if (ip6_ins_rt(nrt
, NULL
, NULL
, NULL
))
1264 netevent
.old
= &rt
->u
.dst
;
1265 netevent
.new = &nrt
->u
.dst
;
1266 call_netevent_notifiers(NETEVENT_REDIRECT
, &netevent
);
1268 if (rt
->rt6i_flags
&RTF_CACHE
) {
1269 ip6_del_rt(rt
, NULL
, NULL
, NULL
);
1274 dst_release(&rt
->u
.dst
);
1279 * Handle ICMP "packet too big" messages
1280 * i.e. Path MTU discovery
1283 void rt6_pmtu_discovery(struct in6_addr
*daddr
, struct in6_addr
*saddr
,
1284 struct net_device
*dev
, u32 pmtu
)
1286 struct rt6_info
*rt
, *nrt
;
1289 rt
= rt6_lookup(daddr
, saddr
, dev
->ifindex
, 0);
1293 if (pmtu
>= dst_mtu(&rt
->u
.dst
))
1296 if (pmtu
< IPV6_MIN_MTU
) {
1298 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1299 * MTU (1280) and a fragment header should always be included
1300 * after a node receiving Too Big message reporting PMTU is
1301 * less than the IPv6 Minimum Link MTU.
1303 pmtu
= IPV6_MIN_MTU
;
1307 /* New mtu received -> path was valid.
1308 They are sent only in response to data packets,
1309 so that this nexthop apparently is reachable. --ANK
1311 dst_confirm(&rt
->u
.dst
);
1313 /* Host route. If it is static, it would be better
1314 not to override it, but add new one, so that
1315 when cache entry will expire old pmtu
1316 would return automatically.
1318 if (rt
->rt6i_flags
& RTF_CACHE
) {
1319 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = pmtu
;
1321 rt
->u
.dst
.metrics
[RTAX_FEATURES
-1] |= RTAX_FEATURE_ALLFRAG
;
1322 dst_set_expires(&rt
->u
.dst
, ip6_rt_mtu_expires
);
1323 rt
->rt6i_flags
|= RTF_MODIFIED
|RTF_EXPIRES
;
1328 Two cases are possible:
1329 1. It is connected route. Action: COW
1330 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1332 if (!rt
->rt6i_nexthop
&& !(rt
->rt6i_flags
& RTF_NONEXTHOP
))
1333 nrt
= rt6_alloc_cow(rt
, daddr
, saddr
);
1335 nrt
= rt6_alloc_clone(rt
, daddr
);
1338 nrt
->u
.dst
.metrics
[RTAX_MTU
-1] = pmtu
;
1340 nrt
->u
.dst
.metrics
[RTAX_FEATURES
-1] |= RTAX_FEATURE_ALLFRAG
;
1342 /* According to RFC 1981, detecting PMTU increase shouldn't be
1343 * happened within 5 mins, the recommended timer is 10 mins.
1344 * Here this route expiration time is set to ip6_rt_mtu_expires
1345 * which is 10 mins. After 10 mins the decreased pmtu is expired
1346 * and detecting PMTU increase will be automatically happened.
1348 dst_set_expires(&nrt
->u
.dst
, ip6_rt_mtu_expires
);
1349 nrt
->rt6i_flags
|= RTF_DYNAMIC
|RTF_EXPIRES
;
1351 ip6_ins_rt(nrt
, NULL
, NULL
, NULL
);
1354 dst_release(&rt
->u
.dst
);
1358 * Misc support functions
1361 static struct rt6_info
* ip6_rt_copy(struct rt6_info
*ort
)
1363 struct rt6_info
*rt
= ip6_dst_alloc();
1366 rt
->u
.dst
.input
= ort
->u
.dst
.input
;
1367 rt
->u
.dst
.output
= ort
->u
.dst
.output
;
1369 memcpy(rt
->u
.dst
.metrics
, ort
->u
.dst
.metrics
, RTAX_MAX
*sizeof(u32
));
1370 rt
->u
.dst
.dev
= ort
->u
.dst
.dev
;
1372 dev_hold(rt
->u
.dst
.dev
);
1373 rt
->rt6i_idev
= ort
->rt6i_idev
;
1375 in6_dev_hold(rt
->rt6i_idev
);
1376 rt
->u
.dst
.lastuse
= jiffies
;
1377 rt
->rt6i_expires
= 0;
1379 ipv6_addr_copy(&rt
->rt6i_gateway
, &ort
->rt6i_gateway
);
1380 rt
->rt6i_flags
= ort
->rt6i_flags
& ~RTF_EXPIRES
;
1381 rt
->rt6i_metric
= 0;
1383 memcpy(&rt
->rt6i_dst
, &ort
->rt6i_dst
, sizeof(struct rt6key
));
1384 #ifdef CONFIG_IPV6_SUBTREES
1385 memcpy(&rt
->rt6i_src
, &ort
->rt6i_src
, sizeof(struct rt6key
));
1391 #ifdef CONFIG_IPV6_ROUTE_INFO
1392 static struct rt6_info
*rt6_get_route_info(struct in6_addr
*prefix
, int prefixlen
,
1393 struct in6_addr
*gwaddr
, int ifindex
)
1395 struct fib6_node
*fn
;
1396 struct rt6_info
*rt
= NULL
;
1398 write_lock_bh(&rt6_lock
);
1399 fn
= fib6_locate(&ip6_routing_table
, prefix
,prefixlen
, NULL
, 0);
1403 for (rt
= fn
->leaf
; rt
; rt
= rt
->u
.next
) {
1404 if (rt
->rt6i_dev
->ifindex
!= ifindex
)
1406 if ((rt
->rt6i_flags
& (RTF_ROUTEINFO
|RTF_GATEWAY
)) != (RTF_ROUTEINFO
|RTF_GATEWAY
))
1408 if (!ipv6_addr_equal(&rt
->rt6i_gateway
, gwaddr
))
1410 dst_hold(&rt
->u
.dst
);
1414 write_unlock_bh(&rt6_lock
);
1418 static struct rt6_info
*rt6_add_route_info(struct in6_addr
*prefix
, int prefixlen
,
1419 struct in6_addr
*gwaddr
, int ifindex
,
1422 struct in6_rtmsg rtmsg
;
1424 memset(&rtmsg
, 0, sizeof(rtmsg
));
1425 rtmsg
.rtmsg_type
= RTMSG_NEWROUTE
;
1426 ipv6_addr_copy(&rtmsg
.rtmsg_dst
, prefix
);
1427 rtmsg
.rtmsg_dst_len
= prefixlen
;
1428 ipv6_addr_copy(&rtmsg
.rtmsg_gateway
, gwaddr
);
1429 rtmsg
.rtmsg_metric
= 1024;
1430 rtmsg
.rtmsg_flags
= RTF_GATEWAY
| RTF_ADDRCONF
| RTF_ROUTEINFO
| RTF_UP
| RTF_PREF(pref
);
1431 /* We should treat it as a default route if prefix length is 0. */
1433 rtmsg
.rtmsg_flags
|= RTF_DEFAULT
;
1434 rtmsg
.rtmsg_ifindex
= ifindex
;
1436 ip6_route_add(&rtmsg
, NULL
, NULL
, NULL
);
1438 return rt6_get_route_info(prefix
, prefixlen
, gwaddr
, ifindex
);
1442 struct rt6_info
*rt6_get_dflt_router(struct in6_addr
*addr
, struct net_device
*dev
)
1444 struct rt6_info
*rt
;
1445 struct fib6_node
*fn
;
1447 fn
= &ip6_routing_table
;
1449 write_lock_bh(&rt6_lock
);
1450 for (rt
= fn
->leaf
; rt
; rt
=rt
->u
.next
) {
1451 if (dev
== rt
->rt6i_dev
&&
1452 ((rt
->rt6i_flags
& (RTF_ADDRCONF
| RTF_DEFAULT
)) == (RTF_ADDRCONF
| RTF_DEFAULT
)) &&
1453 ipv6_addr_equal(&rt
->rt6i_gateway
, addr
))
1457 dst_hold(&rt
->u
.dst
);
1458 write_unlock_bh(&rt6_lock
);
1462 struct rt6_info
*rt6_add_dflt_router(struct in6_addr
*gwaddr
,
1463 struct net_device
*dev
,
1466 struct in6_rtmsg rtmsg
;
1468 memset(&rtmsg
, 0, sizeof(struct in6_rtmsg
));
1469 rtmsg
.rtmsg_type
= RTMSG_NEWROUTE
;
1470 ipv6_addr_copy(&rtmsg
.rtmsg_gateway
, gwaddr
);
1471 rtmsg
.rtmsg_metric
= 1024;
1472 rtmsg
.rtmsg_flags
= RTF_GATEWAY
| RTF_ADDRCONF
| RTF_DEFAULT
| RTF_UP
| RTF_EXPIRES
|
1475 rtmsg
.rtmsg_ifindex
= dev
->ifindex
;
1477 ip6_route_add(&rtmsg
, NULL
, NULL
, NULL
);
1478 return rt6_get_dflt_router(gwaddr
, dev
);
1481 void rt6_purge_dflt_routers(void)
1483 struct rt6_info
*rt
;
1486 read_lock_bh(&rt6_lock
);
1487 for (rt
= ip6_routing_table
.leaf
; rt
; rt
= rt
->u
.next
) {
1488 if (rt
->rt6i_flags
& (RTF_DEFAULT
| RTF_ADDRCONF
)) {
1489 dst_hold(&rt
->u
.dst
);
1491 read_unlock_bh(&rt6_lock
);
1493 ip6_del_rt(rt
, NULL
, NULL
, NULL
);
1498 read_unlock_bh(&rt6_lock
);
1501 int ipv6_route_ioctl(unsigned int cmd
, void __user
*arg
)
1503 struct in6_rtmsg rtmsg
;
1507 case SIOCADDRT
: /* Add a route */
1508 case SIOCDELRT
: /* Delete a route */
1509 if (!capable(CAP_NET_ADMIN
))
1511 err
= copy_from_user(&rtmsg
, arg
,
1512 sizeof(struct in6_rtmsg
));
1519 err
= ip6_route_add(&rtmsg
, NULL
, NULL
, NULL
);
1522 err
= ip6_route_del(&rtmsg
, NULL
, NULL
, NULL
);
1536 * Drop the packet on the floor
1539 static int ip6_pkt_discard(struct sk_buff
*skb
)
1541 int type
= ipv6_addr_type(&skb
->nh
.ipv6h
->daddr
);
1542 if (type
== IPV6_ADDR_ANY
|| type
== IPV6_ADDR_RESERVED
)
1543 IP6_INC_STATS(IPSTATS_MIB_INADDRERRORS
);
1545 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES
);
1546 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_NOROUTE
, 0, skb
->dev
);
1551 static int ip6_pkt_discard_out(struct sk_buff
*skb
)
1553 skb
->dev
= skb
->dst
->dev
;
1554 return ip6_pkt_discard(skb
);
1558 * Allocate a dst for local (unicast / anycast) address.
1561 struct rt6_info
*addrconf_dst_alloc(struct inet6_dev
*idev
,
1562 const struct in6_addr
*addr
,
1565 struct rt6_info
*rt
= ip6_dst_alloc();
1568 return ERR_PTR(-ENOMEM
);
1570 dev_hold(&loopback_dev
);
1573 rt
->u
.dst
.flags
= DST_HOST
;
1574 rt
->u
.dst
.input
= ip6_input
;
1575 rt
->u
.dst
.output
= ip6_output
;
1576 rt
->rt6i_dev
= &loopback_dev
;
1577 rt
->rt6i_idev
= idev
;
1578 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = ipv6_get_mtu(rt
->rt6i_dev
);
1579 rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(dst_mtu(&rt
->u
.dst
));
1580 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = -1;
1581 rt
->u
.dst
.obsolete
= -1;
1583 rt
->rt6i_flags
= RTF_UP
| RTF_NONEXTHOP
;
1585 rt
->rt6i_flags
|= RTF_ANYCAST
;
1587 rt
->rt6i_flags
|= RTF_LOCAL
;
1588 rt
->rt6i_nexthop
= ndisc_get_neigh(rt
->rt6i_dev
, &rt
->rt6i_gateway
);
1589 if (rt
->rt6i_nexthop
== NULL
) {
1590 dst_free((struct dst_entry
*) rt
);
1591 return ERR_PTR(-ENOMEM
);
1594 ipv6_addr_copy(&rt
->rt6i_dst
.addr
, addr
);
1595 rt
->rt6i_dst
.plen
= 128;
1597 atomic_set(&rt
->u
.dst
.__refcnt
, 1);
1602 static int fib6_ifdown(struct rt6_info
*rt
, void *arg
)
1604 if (((void*)rt
->rt6i_dev
== arg
|| arg
== NULL
) &&
1605 rt
!= &ip6_null_entry
) {
1606 RT6_TRACE("deleted by ifdown %p\n", rt
);
1612 void rt6_ifdown(struct net_device
*dev
)
1614 write_lock_bh(&rt6_lock
);
1615 fib6_clean_tree(&ip6_routing_table
, fib6_ifdown
, 0, dev
);
1616 write_unlock_bh(&rt6_lock
);
1619 struct rt6_mtu_change_arg
1621 struct net_device
*dev
;
1625 static int rt6_mtu_change_route(struct rt6_info
*rt
, void *p_arg
)
1627 struct rt6_mtu_change_arg
*arg
= (struct rt6_mtu_change_arg
*) p_arg
;
1628 struct inet6_dev
*idev
;
1630 /* In IPv6 pmtu discovery is not optional,
1631 so that RTAX_MTU lock cannot disable it.
1632 We still use this lock to block changes
1633 caused by addrconf/ndisc.
1636 idev
= __in6_dev_get(arg
->dev
);
1640 /* For administrative MTU increase, there is no way to discover
1641 IPv6 PMTU increase, so PMTU increase should be updated here.
1642 Since RFC 1981 doesn't include administrative MTU increase
1643 update PMTU increase is a MUST. (i.e. jumbo frame)
1646 If new MTU is less than route PMTU, this new MTU will be the
1647 lowest MTU in the path, update the route PMTU to reflect PMTU
1648 decreases; if new MTU is greater than route PMTU, and the
1649 old MTU is the lowest MTU in the path, update the route PMTU
1650 to reflect the increase. In this case if the other nodes' MTU
1651 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1654 if (rt
->rt6i_dev
== arg
->dev
&&
1655 !dst_metric_locked(&rt
->u
.dst
, RTAX_MTU
) &&
1656 (dst_mtu(&rt
->u
.dst
) > arg
->mtu
||
1657 (dst_mtu(&rt
->u
.dst
) < arg
->mtu
&&
1658 dst_mtu(&rt
->u
.dst
) == idev
->cnf
.mtu6
)))
1659 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = arg
->mtu
;
1660 rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(arg
->mtu
);
1664 void rt6_mtu_change(struct net_device
*dev
, unsigned mtu
)
1666 struct rt6_mtu_change_arg arg
;
1670 read_lock_bh(&rt6_lock
);
1671 fib6_clean_tree(&ip6_routing_table
, rt6_mtu_change_route
, 0, &arg
);
1672 read_unlock_bh(&rt6_lock
);
1675 static int inet6_rtm_to_rtmsg(struct rtmsg
*r
, struct rtattr
**rta
,
1676 struct in6_rtmsg
*rtmsg
)
1678 memset(rtmsg
, 0, sizeof(*rtmsg
));
1680 rtmsg
->rtmsg_dst_len
= r
->rtm_dst_len
;
1681 rtmsg
->rtmsg_src_len
= r
->rtm_src_len
;
1682 rtmsg
->rtmsg_flags
= RTF_UP
;
1683 if (r
->rtm_type
== RTN_UNREACHABLE
)
1684 rtmsg
->rtmsg_flags
|= RTF_REJECT
;
1686 if (rta
[RTA_GATEWAY
-1]) {
1687 if (rta
[RTA_GATEWAY
-1]->rta_len
!= RTA_LENGTH(16))
1689 memcpy(&rtmsg
->rtmsg_gateway
, RTA_DATA(rta
[RTA_GATEWAY
-1]), 16);
1690 rtmsg
->rtmsg_flags
|= RTF_GATEWAY
;
1692 if (rta
[RTA_DST
-1]) {
1693 if (RTA_PAYLOAD(rta
[RTA_DST
-1]) < ((r
->rtm_dst_len
+7)>>3))
1695 memcpy(&rtmsg
->rtmsg_dst
, RTA_DATA(rta
[RTA_DST
-1]), ((r
->rtm_dst_len
+7)>>3));
1697 if (rta
[RTA_SRC
-1]) {
1698 if (RTA_PAYLOAD(rta
[RTA_SRC
-1]) < ((r
->rtm_src_len
+7)>>3))
1700 memcpy(&rtmsg
->rtmsg_src
, RTA_DATA(rta
[RTA_SRC
-1]), ((r
->rtm_src_len
+7)>>3));
1702 if (rta
[RTA_OIF
-1]) {
1703 if (rta
[RTA_OIF
-1]->rta_len
!= RTA_LENGTH(sizeof(int)))
1705 memcpy(&rtmsg
->rtmsg_ifindex
, RTA_DATA(rta
[RTA_OIF
-1]), sizeof(int));
1707 if (rta
[RTA_PRIORITY
-1]) {
1708 if (rta
[RTA_PRIORITY
-1]->rta_len
!= RTA_LENGTH(4))
1710 memcpy(&rtmsg
->rtmsg_metric
, RTA_DATA(rta
[RTA_PRIORITY
-1]), 4);
1715 int inet6_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
1717 struct rtmsg
*r
= NLMSG_DATA(nlh
);
1718 struct in6_rtmsg rtmsg
;
1720 if (inet6_rtm_to_rtmsg(r
, arg
, &rtmsg
))
1722 return ip6_route_del(&rtmsg
, nlh
, arg
, &NETLINK_CB(skb
));
1725 int inet6_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
1727 struct rtmsg
*r
= NLMSG_DATA(nlh
);
1728 struct in6_rtmsg rtmsg
;
1730 if (inet6_rtm_to_rtmsg(r
, arg
, &rtmsg
))
1732 return ip6_route_add(&rtmsg
, nlh
, arg
, &NETLINK_CB(skb
));
1735 struct rt6_rtnl_dump_arg
1737 struct sk_buff
*skb
;
1738 struct netlink_callback
*cb
;
1741 static int rt6_fill_node(struct sk_buff
*skb
, struct rt6_info
*rt
,
1742 struct in6_addr
*dst
, struct in6_addr
*src
,
1743 int iif
, int type
, u32 pid
, u32 seq
,
1744 int prefix
, unsigned int flags
)
1747 struct nlmsghdr
*nlh
;
1748 unsigned char *b
= skb
->tail
;
1749 struct rta_cacheinfo ci
;
1751 if (prefix
) { /* user wants prefix routes only */
1752 if (!(rt
->rt6i_flags
& RTF_PREFIX_RT
)) {
1753 /* success since this is not a prefix route */
1758 nlh
= NLMSG_NEW(skb
, pid
, seq
, type
, sizeof(*rtm
), flags
);
1759 rtm
= NLMSG_DATA(nlh
);
1760 rtm
->rtm_family
= AF_INET6
;
1761 rtm
->rtm_dst_len
= rt
->rt6i_dst
.plen
;
1762 rtm
->rtm_src_len
= rt
->rt6i_src
.plen
;
1764 rtm
->rtm_table
= RT_TABLE_MAIN
;
1765 if (rt
->rt6i_flags
&RTF_REJECT
)
1766 rtm
->rtm_type
= RTN_UNREACHABLE
;
1767 else if (rt
->rt6i_dev
&& (rt
->rt6i_dev
->flags
&IFF_LOOPBACK
))
1768 rtm
->rtm_type
= RTN_LOCAL
;
1770 rtm
->rtm_type
= RTN_UNICAST
;
1772 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
1773 rtm
->rtm_protocol
= rt
->rt6i_protocol
;
1774 if (rt
->rt6i_flags
&RTF_DYNAMIC
)
1775 rtm
->rtm_protocol
= RTPROT_REDIRECT
;
1776 else if (rt
->rt6i_flags
& RTF_ADDRCONF
)
1777 rtm
->rtm_protocol
= RTPROT_KERNEL
;
1778 else if (rt
->rt6i_flags
&RTF_DEFAULT
)
1779 rtm
->rtm_protocol
= RTPROT_RA
;
1781 if (rt
->rt6i_flags
&RTF_CACHE
)
1782 rtm
->rtm_flags
|= RTM_F_CLONED
;
1785 RTA_PUT(skb
, RTA_DST
, 16, dst
);
1786 rtm
->rtm_dst_len
= 128;
1787 } else if (rtm
->rtm_dst_len
)
1788 RTA_PUT(skb
, RTA_DST
, 16, &rt
->rt6i_dst
.addr
);
1789 #ifdef CONFIG_IPV6_SUBTREES
1791 RTA_PUT(skb
, RTA_SRC
, 16, src
);
1792 rtm
->rtm_src_len
= 128;
1793 } else if (rtm
->rtm_src_len
)
1794 RTA_PUT(skb
, RTA_SRC
, 16, &rt
->rt6i_src
.addr
);
1797 RTA_PUT(skb
, RTA_IIF
, 4, &iif
);
1799 struct in6_addr saddr_buf
;
1800 if (ipv6_get_saddr(&rt
->u
.dst
, dst
, &saddr_buf
) == 0)
1801 RTA_PUT(skb
, RTA_PREFSRC
, 16, &saddr_buf
);
1803 if (rtnetlink_put_metrics(skb
, rt
->u
.dst
.metrics
) < 0)
1804 goto rtattr_failure
;
1805 if (rt
->u
.dst
.neighbour
)
1806 RTA_PUT(skb
, RTA_GATEWAY
, 16, &rt
->u
.dst
.neighbour
->primary_key
);
1808 RTA_PUT(skb
, RTA_OIF
, sizeof(int), &rt
->rt6i_dev
->ifindex
);
1809 RTA_PUT(skb
, RTA_PRIORITY
, 4, &rt
->rt6i_metric
);
1810 ci
.rta_lastuse
= jiffies_to_clock_t(jiffies
- rt
->u
.dst
.lastuse
);
1811 if (rt
->rt6i_expires
)
1812 ci
.rta_expires
= jiffies_to_clock_t(rt
->rt6i_expires
- jiffies
);
1815 ci
.rta_used
= rt
->u
.dst
.__use
;
1816 ci
.rta_clntref
= atomic_read(&rt
->u
.dst
.__refcnt
);
1817 ci
.rta_error
= rt
->u
.dst
.error
;
1821 RTA_PUT(skb
, RTA_CACHEINFO
, sizeof(ci
), &ci
);
1822 nlh
->nlmsg_len
= skb
->tail
- b
;
1827 skb_trim(skb
, b
- skb
->data
);
1831 static int rt6_dump_route(struct rt6_info
*rt
, void *p_arg
)
1833 struct rt6_rtnl_dump_arg
*arg
= (struct rt6_rtnl_dump_arg
*) p_arg
;
1836 if (arg
->cb
->nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(struct rtmsg
))) {
1837 struct rtmsg
*rtm
= NLMSG_DATA(arg
->cb
->nlh
);
1838 prefix
= (rtm
->rtm_flags
& RTM_F_PREFIX
) != 0;
1842 return rt6_fill_node(arg
->skb
, rt
, NULL
, NULL
, 0, RTM_NEWROUTE
,
1843 NETLINK_CB(arg
->cb
->skb
).pid
, arg
->cb
->nlh
->nlmsg_seq
,
1844 prefix
, NLM_F_MULTI
);
1847 static int fib6_dump_node(struct fib6_walker_t
*w
)
1850 struct rt6_info
*rt
;
1852 for (rt
= w
->leaf
; rt
; rt
= rt
->u
.next
) {
1853 res
= rt6_dump_route(rt
, w
->args
);
1855 /* Frame is full, suspend walking */
1865 static void fib6_dump_end(struct netlink_callback
*cb
)
1867 struct fib6_walker_t
*w
= (void*)cb
->args
[0];
1871 fib6_walker_unlink(w
);
1874 cb
->done
= (void*)cb
->args
[1];
1878 static int fib6_dump_done(struct netlink_callback
*cb
)
1881 return cb
->done
? cb
->done(cb
) : 0;
1884 int inet6_dump_fib(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1886 struct rt6_rtnl_dump_arg arg
;
1887 struct fib6_walker_t
*w
;
1893 w
= (void*)cb
->args
[0];
1897 * 1. hook callback destructor.
1899 cb
->args
[1] = (long)cb
->done
;
1900 cb
->done
= fib6_dump_done
;
1903 * 2. allocate and initialize walker.
1905 w
= kzalloc(sizeof(*w
), GFP_ATOMIC
);
1908 RT6_TRACE("dump<%p", w
);
1909 w
->root
= &ip6_routing_table
;
1910 w
->func
= fib6_dump_node
;
1912 cb
->args
[0] = (long)w
;
1913 read_lock_bh(&rt6_lock
);
1915 read_unlock_bh(&rt6_lock
);
1918 read_lock_bh(&rt6_lock
);
1919 res
= fib6_walk_continue(w
);
1920 read_unlock_bh(&rt6_lock
);
1923 if (res
<= 0 && skb
->len
== 0)
1924 RT6_TRACE("%p>dump end\n", w
);
1926 res
= res
< 0 ? res
: skb
->len
;
1927 /* res < 0 is an error. (really, impossible)
1928 res == 0 means that dump is complete, but skb still can contain data.
1929 res > 0 dump is not complete, but frame is full.
1931 /* Destroy walker, if dump of this table is complete. */
1937 int inet6_rtm_getroute(struct sk_buff
*in_skb
, struct nlmsghdr
* nlh
, void *arg
)
1939 struct rtattr
**rta
= arg
;
1942 struct sk_buff
*skb
;
1944 struct rt6_info
*rt
;
1946 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
1950 /* Reserve room for dummy headers, this skb can pass
1951 through good chunk of routing engine.
1953 skb
->mac
.raw
= skb
->data
;
1954 skb_reserve(skb
, MAX_HEADER
+ sizeof(struct ipv6hdr
));
1956 memset(&fl
, 0, sizeof(fl
));
1958 ipv6_addr_copy(&fl
.fl6_src
,
1959 (struct in6_addr
*)RTA_DATA(rta
[RTA_SRC
-1]));
1961 ipv6_addr_copy(&fl
.fl6_dst
,
1962 (struct in6_addr
*)RTA_DATA(rta
[RTA_DST
-1]));
1965 memcpy(&iif
, RTA_DATA(rta
[RTA_IIF
-1]), sizeof(int));
1968 struct net_device
*dev
;
1969 dev
= __dev_get_by_index(iif
);
1978 memcpy(&fl
.oif
, RTA_DATA(rta
[RTA_OIF
-1]), sizeof(int));
1980 rt
= (struct rt6_info
*)ip6_route_output(NULL
, &fl
);
1982 skb
->dst
= &rt
->u
.dst
;
1984 NETLINK_CB(skb
).dst_pid
= NETLINK_CB(in_skb
).pid
;
1985 err
= rt6_fill_node(skb
, rt
,
1986 &fl
.fl6_dst
, &fl
.fl6_src
,
1988 RTM_NEWROUTE
, NETLINK_CB(in_skb
).pid
,
1989 nlh
->nlmsg_seq
, 0, 0);
1995 err
= netlink_unicast(rtnl
, skb
, NETLINK_CB(in_skb
).pid
, MSG_DONTWAIT
);
2005 void inet6_rt_notify(int event
, struct rt6_info
*rt
, struct nlmsghdr
*nlh
,
2006 struct netlink_skb_parms
*req
)
2008 struct sk_buff
*skb
;
2009 int size
= NLMSG_SPACE(sizeof(struct rtmsg
)+256);
2010 u32 pid
= current
->pid
;
2016 seq
= nlh
->nlmsg_seq
;
2018 skb
= alloc_skb(size
, gfp_any());
2020 netlink_set_err(rtnl
, 0, RTNLGRP_IPV6_ROUTE
, ENOBUFS
);
2023 if (rt6_fill_node(skb
, rt
, NULL
, NULL
, 0, event
, pid
, seq
, 0, 0) < 0) {
2025 netlink_set_err(rtnl
, 0, RTNLGRP_IPV6_ROUTE
, EINVAL
);
2028 NETLINK_CB(skb
).dst_group
= RTNLGRP_IPV6_ROUTE
;
2029 netlink_broadcast(rtnl
, skb
, 0, RTNLGRP_IPV6_ROUTE
, gfp_any());
2036 #ifdef CONFIG_PROC_FS
2038 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2049 static int rt6_info_route(struct rt6_info
*rt
, void *p_arg
)
2051 struct rt6_proc_arg
*arg
= (struct rt6_proc_arg
*) p_arg
;
2054 if (arg
->skip
< arg
->offset
/ RT6_INFO_LEN
) {
2059 if (arg
->len
>= arg
->length
)
2062 for (i
=0; i
<16; i
++) {
2063 sprintf(arg
->buffer
+ arg
->len
, "%02x",
2064 rt
->rt6i_dst
.addr
.s6_addr
[i
]);
2067 arg
->len
+= sprintf(arg
->buffer
+ arg
->len
, " %02x ",
2070 #ifdef CONFIG_IPV6_SUBTREES
2071 for (i
=0; i
<16; i
++) {
2072 sprintf(arg
->buffer
+ arg
->len
, "%02x",
2073 rt
->rt6i_src
.addr
.s6_addr
[i
]);
2076 arg
->len
+= sprintf(arg
->buffer
+ arg
->len
, " %02x ",
2079 sprintf(arg
->buffer
+ arg
->len
,
2080 "00000000000000000000000000000000 00 ");
2084 if (rt
->rt6i_nexthop
) {
2085 for (i
=0; i
<16; i
++) {
2086 sprintf(arg
->buffer
+ arg
->len
, "%02x",
2087 rt
->rt6i_nexthop
->primary_key
[i
]);
2091 sprintf(arg
->buffer
+ arg
->len
,
2092 "00000000000000000000000000000000");
2095 arg
->len
+= sprintf(arg
->buffer
+ arg
->len
,
2096 " %08x %08x %08x %08x %8s\n",
2097 rt
->rt6i_metric
, atomic_read(&rt
->u
.dst
.__refcnt
),
2098 rt
->u
.dst
.__use
, rt
->rt6i_flags
,
2099 rt
->rt6i_dev
? rt
->rt6i_dev
->name
: "");
2103 static int rt6_proc_info(char *buffer
, char **start
, off_t offset
, int length
)
2105 struct rt6_proc_arg arg
;
2106 arg
.buffer
= buffer
;
2107 arg
.offset
= offset
;
2108 arg
.length
= length
;
2112 read_lock_bh(&rt6_lock
);
2113 fib6_clean_tree(&ip6_routing_table
, rt6_info_route
, 0, &arg
);
2114 read_unlock_bh(&rt6_lock
);
2118 *start
+= offset
% RT6_INFO_LEN
;
2120 arg
.len
-= offset
% RT6_INFO_LEN
;
2122 if (arg
.len
> length
)
2130 static int rt6_stats_seq_show(struct seq_file
*seq
, void *v
)
2132 seq_printf(seq
, "%04x %04x %04x %04x %04x %04x %04x\n",
2133 rt6_stats
.fib_nodes
, rt6_stats
.fib_route_nodes
,
2134 rt6_stats
.fib_rt_alloc
, rt6_stats
.fib_rt_entries
,
2135 rt6_stats
.fib_rt_cache
,
2136 atomic_read(&ip6_dst_ops
.entries
),
2137 rt6_stats
.fib_discarded_routes
);
2142 static int rt6_stats_seq_open(struct inode
*inode
, struct file
*file
)
2144 return single_open(file
, rt6_stats_seq_show
, NULL
);
2147 static struct file_operations rt6_stats_seq_fops
= {
2148 .owner
= THIS_MODULE
,
2149 .open
= rt6_stats_seq_open
,
2151 .llseek
= seq_lseek
,
2152 .release
= single_release
,
2154 #endif /* CONFIG_PROC_FS */
2156 #ifdef CONFIG_SYSCTL
2158 static int flush_delay
;
2161 int ipv6_sysctl_rtcache_flush(ctl_table
*ctl
, int write
, struct file
* filp
,
2162 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2165 proc_dointvec(ctl
, write
, filp
, buffer
, lenp
, ppos
);
2166 fib6_run_gc(flush_delay
<= 0 ? ~0UL : (unsigned long)flush_delay
);
2172 ctl_table ipv6_route_table
[] = {
2174 .ctl_name
= NET_IPV6_ROUTE_FLUSH
,
2175 .procname
= "flush",
2176 .data
= &flush_delay
,
2177 .maxlen
= sizeof(int),
2179 .proc_handler
= &ipv6_sysctl_rtcache_flush
2182 .ctl_name
= NET_IPV6_ROUTE_GC_THRESH
,
2183 .procname
= "gc_thresh",
2184 .data
= &ip6_dst_ops
.gc_thresh
,
2185 .maxlen
= sizeof(int),
2187 .proc_handler
= &proc_dointvec
,
2190 .ctl_name
= NET_IPV6_ROUTE_MAX_SIZE
,
2191 .procname
= "max_size",
2192 .data
= &ip6_rt_max_size
,
2193 .maxlen
= sizeof(int),
2195 .proc_handler
= &proc_dointvec
,
2198 .ctl_name
= NET_IPV6_ROUTE_GC_MIN_INTERVAL
,
2199 .procname
= "gc_min_interval",
2200 .data
= &ip6_rt_gc_min_interval
,
2201 .maxlen
= sizeof(int),
2203 .proc_handler
= &proc_dointvec_jiffies
,
2204 .strategy
= &sysctl_jiffies
,
2207 .ctl_name
= NET_IPV6_ROUTE_GC_TIMEOUT
,
2208 .procname
= "gc_timeout",
2209 .data
= &ip6_rt_gc_timeout
,
2210 .maxlen
= sizeof(int),
2212 .proc_handler
= &proc_dointvec_jiffies
,
2213 .strategy
= &sysctl_jiffies
,
2216 .ctl_name
= NET_IPV6_ROUTE_GC_INTERVAL
,
2217 .procname
= "gc_interval",
2218 .data
= &ip6_rt_gc_interval
,
2219 .maxlen
= sizeof(int),
2221 .proc_handler
= &proc_dointvec_jiffies
,
2222 .strategy
= &sysctl_jiffies
,
2225 .ctl_name
= NET_IPV6_ROUTE_GC_ELASTICITY
,
2226 .procname
= "gc_elasticity",
2227 .data
= &ip6_rt_gc_elasticity
,
2228 .maxlen
= sizeof(int),
2230 .proc_handler
= &proc_dointvec_jiffies
,
2231 .strategy
= &sysctl_jiffies
,
2234 .ctl_name
= NET_IPV6_ROUTE_MTU_EXPIRES
,
2235 .procname
= "mtu_expires",
2236 .data
= &ip6_rt_mtu_expires
,
2237 .maxlen
= sizeof(int),
2239 .proc_handler
= &proc_dointvec_jiffies
,
2240 .strategy
= &sysctl_jiffies
,
2243 .ctl_name
= NET_IPV6_ROUTE_MIN_ADVMSS
,
2244 .procname
= "min_adv_mss",
2245 .data
= &ip6_rt_min_advmss
,
2246 .maxlen
= sizeof(int),
2248 .proc_handler
= &proc_dointvec_jiffies
,
2249 .strategy
= &sysctl_jiffies
,
2252 .ctl_name
= NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS
,
2253 .procname
= "gc_min_interval_ms",
2254 .data
= &ip6_rt_gc_min_interval
,
2255 .maxlen
= sizeof(int),
2257 .proc_handler
= &proc_dointvec_ms_jiffies
,
2258 .strategy
= &sysctl_ms_jiffies
,
2265 void __init
ip6_route_init(void)
2267 struct proc_dir_entry
*p
;
2269 ip6_dst_ops
.kmem_cachep
= kmem_cache_create("ip6_dst_cache",
2270 sizeof(struct rt6_info
),
2271 0, SLAB_HWCACHE_ALIGN
,
2273 if (!ip6_dst_ops
.kmem_cachep
)
2274 panic("cannot create ip6_dst_cache");
2277 #ifdef CONFIG_PROC_FS
2278 p
= proc_net_create("ipv6_route", 0, rt6_proc_info
);
2280 p
->owner
= THIS_MODULE
;
2282 proc_net_fops_create("rt6_stats", S_IRUGO
, &rt6_stats_seq_fops
);
2289 void ip6_route_cleanup(void)
2291 #ifdef CONFIG_PROC_FS
2292 proc_net_remove("ipv6_route");
2293 proc_net_remove("rt6_stats");
2300 kmem_cache_destroy(ip6_dst_ops
.kmem_cachep
);