2 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * $Id: route.c,v 1.56 2001/10/31 21:55:55 davem Exp $
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
18 * YOSHIFUJI Hideaki @USAGI
19 * reworked default router selection.
20 * - respect outgoing interface
21 * - select from (probably) reachable routers (i.e.
22 * routers in REACHABLE, STALE, DELAY or PROBE states).
23 * - always select the same router if it is (probably)
24 * reachable. otherwise, round-robin the list.
26 * Fixed routing subtrees.
29 #include <linux/capability.h>
30 #include <linux/errno.h>
31 #include <linux/types.h>
32 #include <linux/times.h>
33 #include <linux/socket.h>
34 #include <linux/sockios.h>
35 #include <linux/net.h>
36 #include <linux/route.h>
37 #include <linux/netdevice.h>
38 #include <linux/in6.h>
39 #include <linux/init.h>
40 #include <linux/if_arp.h>
41 #include <linux/proc_fs.h>
42 #include <linux/seq_file.h>
43 #include <net/net_namespace.h>
46 #include <net/ip6_fib.h>
47 #include <net/ip6_route.h>
48 #include <net/ndisc.h>
49 #include <net/addrconf.h>
51 #include <linux/rtnetlink.h>
54 #include <net/netevent.h>
55 #include <net/netlink.h>
57 #include <asm/uaccess.h>
60 #include <linux/sysctl.h>
63 /* Set to 3 to get tracing. */
67 #define RDBG(x) printk x
68 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
71 #define RT6_TRACE(x...) do { ; } while (0)
74 #define CLONE_OFFLINK_ROUTE 0
76 static int ip6_rt_max_size
= 4096;
77 static int ip6_rt_gc_min_interval
= HZ
/ 2;
78 static int ip6_rt_gc_timeout
= 60*HZ
;
79 int ip6_rt_gc_interval
= 30*HZ
;
80 static int ip6_rt_gc_elasticity
= 9;
81 static int ip6_rt_mtu_expires
= 10*60*HZ
;
82 static int ip6_rt_min_advmss
= IPV6_MIN_MTU
- 20 - 40;
84 static struct rt6_info
* ip6_rt_copy(struct rt6_info
*ort
);
85 static struct dst_entry
*ip6_dst_check(struct dst_entry
*dst
, u32 cookie
);
86 static struct dst_entry
*ip6_negative_advice(struct dst_entry
*);
87 static void ip6_dst_destroy(struct dst_entry
*);
88 static void ip6_dst_ifdown(struct dst_entry
*,
89 struct net_device
*dev
, int how
);
90 static int ip6_dst_gc(void);
92 static int ip6_pkt_discard(struct sk_buff
*skb
);
93 static int ip6_pkt_discard_out(struct sk_buff
*skb
);
94 static void ip6_link_failure(struct sk_buff
*skb
);
95 static void ip6_rt_update_pmtu(struct dst_entry
*dst
, u32 mtu
);
97 #ifdef CONFIG_IPV6_ROUTE_INFO
98 static struct rt6_info
*rt6_add_route_info(struct in6_addr
*prefix
, int prefixlen
,
99 struct in6_addr
*gwaddr
, int ifindex
,
101 static struct rt6_info
*rt6_get_route_info(struct in6_addr
*prefix
, int prefixlen
,
102 struct in6_addr
*gwaddr
, int ifindex
);
105 static struct dst_ops ip6_dst_ops
= {
107 .protocol
= __constant_htons(ETH_P_IPV6
),
110 .check
= ip6_dst_check
,
111 .destroy
= ip6_dst_destroy
,
112 .ifdown
= ip6_dst_ifdown
,
113 .negative_advice
= ip6_negative_advice
,
114 .link_failure
= ip6_link_failure
,
115 .update_pmtu
= ip6_rt_update_pmtu
,
116 .local_out
= ip6_local_out
,
117 .entry_size
= sizeof(struct rt6_info
),
120 static void ip6_rt_blackhole_update_pmtu(struct dst_entry
*dst
, u32 mtu
)
124 static struct dst_ops ip6_dst_blackhole_ops
= {
126 .protocol
= __constant_htons(ETH_P_IPV6
),
127 .destroy
= ip6_dst_destroy
,
128 .check
= ip6_dst_check
,
129 .update_pmtu
= ip6_rt_blackhole_update_pmtu
,
130 .entry_size
= sizeof(struct rt6_info
),
133 struct rt6_info ip6_null_entry
= {
136 .__refcnt
= ATOMIC_INIT(1),
139 .error
= -ENETUNREACH
,
140 .metrics
= { [RTAX_HOPLIMIT
- 1] = 255, },
141 .input
= ip6_pkt_discard
,
142 .output
= ip6_pkt_discard_out
,
144 .path
= (struct dst_entry
*)&ip6_null_entry
,
147 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
148 .rt6i_metric
= ~(u32
) 0,
149 .rt6i_ref
= ATOMIC_INIT(1),
152 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
154 static int ip6_pkt_prohibit(struct sk_buff
*skb
);
155 static int ip6_pkt_prohibit_out(struct sk_buff
*skb
);
157 struct rt6_info ip6_prohibit_entry
= {
160 .__refcnt
= ATOMIC_INIT(1),
164 .metrics
= { [RTAX_HOPLIMIT
- 1] = 255, },
165 .input
= ip6_pkt_prohibit
,
166 .output
= ip6_pkt_prohibit_out
,
168 .path
= (struct dst_entry
*)&ip6_prohibit_entry
,
171 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
172 .rt6i_metric
= ~(u32
) 0,
173 .rt6i_ref
= ATOMIC_INIT(1),
176 struct rt6_info ip6_blk_hole_entry
= {
179 .__refcnt
= ATOMIC_INIT(1),
183 .metrics
= { [RTAX_HOPLIMIT
- 1] = 255, },
184 .input
= dst_discard
,
185 .output
= dst_discard
,
187 .path
= (struct dst_entry
*)&ip6_blk_hole_entry
,
190 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
191 .rt6i_metric
= ~(u32
) 0,
192 .rt6i_ref
= ATOMIC_INIT(1),
197 /* allocate dst with ip6_dst_ops */
198 static __inline__
struct rt6_info
*ip6_dst_alloc(void)
200 return (struct rt6_info
*)dst_alloc(&ip6_dst_ops
);
203 static void ip6_dst_destroy(struct dst_entry
*dst
)
205 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
206 struct inet6_dev
*idev
= rt
->rt6i_idev
;
209 rt
->rt6i_idev
= NULL
;
214 static void ip6_dst_ifdown(struct dst_entry
*dst
, struct net_device
*dev
,
217 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
218 struct inet6_dev
*idev
= rt
->rt6i_idev
;
219 struct net_device
*loopback_dev
=
220 dev
->nd_net
->loopback_dev
;
222 if (dev
!= loopback_dev
&& idev
!= NULL
&& idev
->dev
== dev
) {
223 struct inet6_dev
*loopback_idev
=
224 in6_dev_get(loopback_dev
);
225 if (loopback_idev
!= NULL
) {
226 rt
->rt6i_idev
= loopback_idev
;
232 static __inline__
int rt6_check_expired(const struct rt6_info
*rt
)
234 return (rt
->rt6i_flags
& RTF_EXPIRES
&&
235 time_after(jiffies
, rt
->rt6i_expires
));
238 static inline int rt6_need_strict(struct in6_addr
*daddr
)
240 return (ipv6_addr_type(daddr
) &
241 (IPV6_ADDR_MULTICAST
| IPV6_ADDR_LINKLOCAL
));
245 * Route lookup. Any table->tb6_lock is implied.
248 static __inline__
struct rt6_info
*rt6_device_match(struct rt6_info
*rt
,
252 struct rt6_info
*local
= NULL
;
253 struct rt6_info
*sprt
;
256 for (sprt
= rt
; sprt
; sprt
= sprt
->u
.dst
.rt6_next
) {
257 struct net_device
*dev
= sprt
->rt6i_dev
;
258 if (dev
->ifindex
== oif
)
260 if (dev
->flags
& IFF_LOOPBACK
) {
261 if (sprt
->rt6i_idev
== NULL
||
262 sprt
->rt6i_idev
->dev
->ifindex
!= oif
) {
265 if (local
&& (!oif
||
266 local
->rt6i_idev
->dev
->ifindex
== oif
))
277 return &ip6_null_entry
;
282 #ifdef CONFIG_IPV6_ROUTER_PREF
283 static void rt6_probe(struct rt6_info
*rt
)
285 struct neighbour
*neigh
= rt
? rt
->rt6i_nexthop
: NULL
;
287 * Okay, this does not seem to be appropriate
288 * for now, however, we need to check if it
289 * is really so; aka Router Reachability Probing.
291 * Router Reachability Probe MUST be rate-limited
292 * to no more than one per minute.
294 if (!neigh
|| (neigh
->nud_state
& NUD_VALID
))
296 read_lock_bh(&neigh
->lock
);
297 if (!(neigh
->nud_state
& NUD_VALID
) &&
298 time_after(jiffies
, neigh
->updated
+ rt
->rt6i_idev
->cnf
.rtr_probe_interval
)) {
299 struct in6_addr mcaddr
;
300 struct in6_addr
*target
;
302 neigh
->updated
= jiffies
;
303 read_unlock_bh(&neigh
->lock
);
305 target
= (struct in6_addr
*)&neigh
->primary_key
;
306 addrconf_addr_solict_mult(target
, &mcaddr
);
307 ndisc_send_ns(rt
->rt6i_dev
, NULL
, target
, &mcaddr
, NULL
);
309 read_unlock_bh(&neigh
->lock
);
312 static inline void rt6_probe(struct rt6_info
*rt
)
319 * Default Router Selection (RFC 2461 6.3.6)
321 static inline int rt6_check_dev(struct rt6_info
*rt
, int oif
)
323 struct net_device
*dev
= rt
->rt6i_dev
;
324 if (!oif
|| dev
->ifindex
== oif
)
326 if ((dev
->flags
& IFF_LOOPBACK
) &&
327 rt
->rt6i_idev
&& rt
->rt6i_idev
->dev
->ifindex
== oif
)
332 static inline int rt6_check_neigh(struct rt6_info
*rt
)
334 struct neighbour
*neigh
= rt
->rt6i_nexthop
;
336 if (rt
->rt6i_flags
& RTF_NONEXTHOP
||
337 !(rt
->rt6i_flags
& RTF_GATEWAY
))
340 read_lock_bh(&neigh
->lock
);
341 if (neigh
->nud_state
& NUD_VALID
)
343 #ifdef CONFIG_IPV6_ROUTER_PREF
344 else if (neigh
->nud_state
& NUD_FAILED
)
349 read_unlock_bh(&neigh
->lock
);
355 static int rt6_score_route(struct rt6_info
*rt
, int oif
,
360 m
= rt6_check_dev(rt
, oif
);
361 if (!m
&& (strict
& RT6_LOOKUP_F_IFACE
))
363 #ifdef CONFIG_IPV6_ROUTER_PREF
364 m
|= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt
->rt6i_flags
)) << 2;
366 n
= rt6_check_neigh(rt
);
367 if (!n
&& (strict
& RT6_LOOKUP_F_REACHABLE
))
372 static struct rt6_info
*find_match(struct rt6_info
*rt
, int oif
, int strict
,
373 int *mpri
, struct rt6_info
*match
)
377 if (rt6_check_expired(rt
))
380 m
= rt6_score_route(rt
, oif
, strict
);
385 if (strict
& RT6_LOOKUP_F_REACHABLE
)
389 } else if (strict
& RT6_LOOKUP_F_REACHABLE
) {
397 static struct rt6_info
*find_rr_leaf(struct fib6_node
*fn
,
398 struct rt6_info
*rr_head
,
399 u32 metric
, int oif
, int strict
)
401 struct rt6_info
*rt
, *match
;
405 for (rt
= rr_head
; rt
&& rt
->rt6i_metric
== metric
;
406 rt
= rt
->u
.dst
.rt6_next
)
407 match
= find_match(rt
, oif
, strict
, &mpri
, match
);
408 for (rt
= fn
->leaf
; rt
&& rt
!= rr_head
&& rt
->rt6i_metric
== metric
;
409 rt
= rt
->u
.dst
.rt6_next
)
410 match
= find_match(rt
, oif
, strict
, &mpri
, match
);
415 static struct rt6_info
*rt6_select(struct fib6_node
*fn
, int oif
, int strict
)
417 struct rt6_info
*match
, *rt0
;
419 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
420 __FUNCTION__
, fn
->leaf
, oif
);
424 fn
->rr_ptr
= rt0
= fn
->leaf
;
426 match
= find_rr_leaf(fn
, rt0
, rt0
->rt6i_metric
, oif
, strict
);
429 (strict
& RT6_LOOKUP_F_REACHABLE
)) {
430 struct rt6_info
*next
= rt0
->u
.dst
.rt6_next
;
432 /* no entries matched; do round-robin */
433 if (!next
|| next
->rt6i_metric
!= rt0
->rt6i_metric
)
440 RT6_TRACE("%s() => %p\n",
441 __FUNCTION__
, match
);
443 return (match
? match
: &ip6_null_entry
);
446 #ifdef CONFIG_IPV6_ROUTE_INFO
447 int rt6_route_rcv(struct net_device
*dev
, u8
*opt
, int len
,
448 struct in6_addr
*gwaddr
)
450 struct route_info
*rinfo
= (struct route_info
*) opt
;
451 struct in6_addr prefix_buf
, *prefix
;
456 if (len
< sizeof(struct route_info
)) {
460 /* Sanity check for prefix_len and length */
461 if (rinfo
->length
> 3) {
463 } else if (rinfo
->prefix_len
> 128) {
465 } else if (rinfo
->prefix_len
> 64) {
466 if (rinfo
->length
< 2) {
469 } else if (rinfo
->prefix_len
> 0) {
470 if (rinfo
->length
< 1) {
475 pref
= rinfo
->route_pref
;
476 if (pref
== ICMPV6_ROUTER_PREF_INVALID
)
477 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
479 lifetime
= ntohl(rinfo
->lifetime
);
480 if (lifetime
== 0xffffffff) {
482 } else if (lifetime
> 0x7fffffff/HZ
) {
483 /* Avoid arithmetic overflow */
484 lifetime
= 0x7fffffff/HZ
- 1;
487 if (rinfo
->length
== 3)
488 prefix
= (struct in6_addr
*)rinfo
->prefix
;
490 /* this function is safe */
491 ipv6_addr_prefix(&prefix_buf
,
492 (struct in6_addr
*)rinfo
->prefix
,
494 prefix
= &prefix_buf
;
497 rt
= rt6_get_route_info(prefix
, rinfo
->prefix_len
, gwaddr
, dev
->ifindex
);
499 if (rt
&& !lifetime
) {
505 rt
= rt6_add_route_info(prefix
, rinfo
->prefix_len
, gwaddr
, dev
->ifindex
,
508 rt
->rt6i_flags
= RTF_ROUTEINFO
|
509 (rt
->rt6i_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
512 if (lifetime
== 0xffffffff) {
513 rt
->rt6i_flags
&= ~RTF_EXPIRES
;
515 rt
->rt6i_expires
= jiffies
+ HZ
* lifetime
;
516 rt
->rt6i_flags
|= RTF_EXPIRES
;
518 dst_release(&rt
->u
.dst
);
524 #define BACKTRACK(saddr) \
526 if (rt == &ip6_null_entry) { \
527 struct fib6_node *pn; \
529 if (fn->fn_flags & RTN_TL_ROOT) \
532 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
533 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
536 if (fn->fn_flags & RTN_RTINFO) \
542 static struct rt6_info
*ip6_pol_route_lookup(struct fib6_table
*table
,
543 struct flowi
*fl
, int flags
)
545 struct fib6_node
*fn
;
548 read_lock_bh(&table
->tb6_lock
);
549 fn
= fib6_lookup(&table
->tb6_root
, &fl
->fl6_dst
, &fl
->fl6_src
);
552 rt
= rt6_device_match(rt
, fl
->oif
, flags
);
553 BACKTRACK(&fl
->fl6_src
);
555 dst_use(&rt
->u
.dst
, jiffies
);
556 read_unlock_bh(&table
->tb6_lock
);
561 struct rt6_info
*rt6_lookup(struct in6_addr
*daddr
, struct in6_addr
*saddr
,
572 struct dst_entry
*dst
;
573 int flags
= strict
? RT6_LOOKUP_F_IFACE
: 0;
576 memcpy(&fl
.fl6_src
, saddr
, sizeof(*saddr
));
577 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
580 dst
= fib6_rule_lookup(&fl
, flags
, ip6_pol_route_lookup
);
582 return (struct rt6_info
*) dst
;
589 EXPORT_SYMBOL(rt6_lookup
);
591 /* ip6_ins_rt is called with FREE table->tb6_lock.
592 It takes new route entry, the addition fails by any reason the
593 route is freed. In any case, if caller does not hold it, it may
597 static int __ip6_ins_rt(struct rt6_info
*rt
, struct nl_info
*info
)
600 struct fib6_table
*table
;
602 table
= rt
->rt6i_table
;
603 write_lock_bh(&table
->tb6_lock
);
604 err
= fib6_add(&table
->tb6_root
, rt
, info
);
605 write_unlock_bh(&table
->tb6_lock
);
610 int ip6_ins_rt(struct rt6_info
*rt
)
612 struct nl_info info
= {};
613 return __ip6_ins_rt(rt
, &info
);
616 static struct rt6_info
*rt6_alloc_cow(struct rt6_info
*ort
, struct in6_addr
*daddr
,
617 struct in6_addr
*saddr
)
625 rt
= ip6_rt_copy(ort
);
628 if (!(rt
->rt6i_flags
&RTF_GATEWAY
)) {
629 if (rt
->rt6i_dst
.plen
!= 128 &&
630 ipv6_addr_equal(&rt
->rt6i_dst
.addr
, daddr
))
631 rt
->rt6i_flags
|= RTF_ANYCAST
;
632 ipv6_addr_copy(&rt
->rt6i_gateway
, daddr
);
635 ipv6_addr_copy(&rt
->rt6i_dst
.addr
, daddr
);
636 rt
->rt6i_dst
.plen
= 128;
637 rt
->rt6i_flags
|= RTF_CACHE
;
638 rt
->u
.dst
.flags
|= DST_HOST
;
640 #ifdef CONFIG_IPV6_SUBTREES
641 if (rt
->rt6i_src
.plen
&& saddr
) {
642 ipv6_addr_copy(&rt
->rt6i_src
.addr
, saddr
);
643 rt
->rt6i_src
.plen
= 128;
647 rt
->rt6i_nexthop
= ndisc_get_neigh(rt
->rt6i_dev
, &rt
->rt6i_gateway
);
654 static struct rt6_info
*rt6_alloc_clone(struct rt6_info
*ort
, struct in6_addr
*daddr
)
656 struct rt6_info
*rt
= ip6_rt_copy(ort
);
658 ipv6_addr_copy(&rt
->rt6i_dst
.addr
, daddr
);
659 rt
->rt6i_dst
.plen
= 128;
660 rt
->rt6i_flags
|= RTF_CACHE
;
661 rt
->u
.dst
.flags
|= DST_HOST
;
662 rt
->rt6i_nexthop
= neigh_clone(ort
->rt6i_nexthop
);
667 static struct rt6_info
*ip6_pol_route(struct fib6_table
*table
, int oif
,
668 struct flowi
*fl
, int flags
)
670 struct fib6_node
*fn
;
671 struct rt6_info
*rt
, *nrt
;
675 int reachable
= ipv6_devconf
.forwarding
? 0 : RT6_LOOKUP_F_REACHABLE
;
677 strict
|= flags
& RT6_LOOKUP_F_IFACE
;
680 read_lock_bh(&table
->tb6_lock
);
683 fn
= fib6_lookup(&table
->tb6_root
, &fl
->fl6_dst
, &fl
->fl6_src
);
686 rt
= rt6_select(fn
, oif
, strict
| reachable
);
687 BACKTRACK(&fl
->fl6_src
);
688 if (rt
== &ip6_null_entry
||
689 rt
->rt6i_flags
& RTF_CACHE
)
692 dst_hold(&rt
->u
.dst
);
693 read_unlock_bh(&table
->tb6_lock
);
695 if (!rt
->rt6i_nexthop
&& !(rt
->rt6i_flags
& RTF_NONEXTHOP
))
696 nrt
= rt6_alloc_cow(rt
, &fl
->fl6_dst
, &fl
->fl6_src
);
698 #if CLONE_OFFLINK_ROUTE
699 nrt
= rt6_alloc_clone(rt
, &fl
->fl6_dst
);
705 dst_release(&rt
->u
.dst
);
706 rt
= nrt
? : &ip6_null_entry
;
708 dst_hold(&rt
->u
.dst
);
710 err
= ip6_ins_rt(nrt
);
719 * Race condition! In the gap, when table->tb6_lock was
720 * released someone could insert this route. Relookup.
722 dst_release(&rt
->u
.dst
);
730 dst_hold(&rt
->u
.dst
);
731 read_unlock_bh(&table
->tb6_lock
);
733 rt
->u
.dst
.lastuse
= jiffies
;
739 static struct rt6_info
*ip6_pol_route_input(struct fib6_table
*table
,
740 struct flowi
*fl
, int flags
)
742 return ip6_pol_route(table
, fl
->iif
, fl
, flags
);
745 void ip6_route_input(struct sk_buff
*skb
)
747 struct ipv6hdr
*iph
= ipv6_hdr(skb
);
748 int flags
= RT6_LOOKUP_F_HAS_SADDR
;
750 .iif
= skb
->dev
->ifindex
,
755 .flowlabel
= (* (__be32
*) iph
)&IPV6_FLOWINFO_MASK
,
759 .proto
= iph
->nexthdr
,
762 if (rt6_need_strict(&iph
->daddr
))
763 flags
|= RT6_LOOKUP_F_IFACE
;
765 skb
->dst
= fib6_rule_lookup(&fl
, flags
, ip6_pol_route_input
);
768 static struct rt6_info
*ip6_pol_route_output(struct fib6_table
*table
,
769 struct flowi
*fl
, int flags
)
771 return ip6_pol_route(table
, fl
->oif
, fl
, flags
);
774 struct dst_entry
* ip6_route_output(struct sock
*sk
, struct flowi
*fl
)
778 if (rt6_need_strict(&fl
->fl6_dst
))
779 flags
|= RT6_LOOKUP_F_IFACE
;
781 if (!ipv6_addr_any(&fl
->fl6_src
))
782 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
784 return fib6_rule_lookup(fl
, flags
, ip6_pol_route_output
);
787 EXPORT_SYMBOL(ip6_route_output
);
789 int ip6_dst_blackhole(struct sock
*sk
, struct dst_entry
**dstp
, struct flowi
*fl
)
791 struct rt6_info
*ort
= (struct rt6_info
*) *dstp
;
792 struct rt6_info
*rt
= (struct rt6_info
*)
793 dst_alloc(&ip6_dst_blackhole_ops
);
794 struct dst_entry
*new = NULL
;
799 atomic_set(&new->__refcnt
, 1);
801 new->input
= dst_discard
;
802 new->output
= dst_discard
;
804 memcpy(new->metrics
, ort
->u
.dst
.metrics
, RTAX_MAX
*sizeof(u32
));
805 new->dev
= ort
->u
.dst
.dev
;
808 rt
->rt6i_idev
= ort
->rt6i_idev
;
810 in6_dev_hold(rt
->rt6i_idev
);
811 rt
->rt6i_expires
= 0;
813 ipv6_addr_copy(&rt
->rt6i_gateway
, &ort
->rt6i_gateway
);
814 rt
->rt6i_flags
= ort
->rt6i_flags
& ~RTF_EXPIRES
;
817 memcpy(&rt
->rt6i_dst
, &ort
->rt6i_dst
, sizeof(struct rt6key
));
818 #ifdef CONFIG_IPV6_SUBTREES
819 memcpy(&rt
->rt6i_src
, &ort
->rt6i_src
, sizeof(struct rt6key
));
827 return (new ? 0 : -ENOMEM
);
829 EXPORT_SYMBOL_GPL(ip6_dst_blackhole
);
832 * Destination cache support functions
835 static struct dst_entry
*ip6_dst_check(struct dst_entry
*dst
, u32 cookie
)
839 rt
= (struct rt6_info
*) dst
;
841 if (rt
&& rt
->rt6i_node
&& (rt
->rt6i_node
->fn_sernum
== cookie
))
847 static struct dst_entry
*ip6_negative_advice(struct dst_entry
*dst
)
849 struct rt6_info
*rt
= (struct rt6_info
*) dst
;
852 if (rt
->rt6i_flags
& RTF_CACHE
)
860 static void ip6_link_failure(struct sk_buff
*skb
)
864 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_ADDR_UNREACH
, 0, skb
->dev
);
866 rt
= (struct rt6_info
*) skb
->dst
;
868 if (rt
->rt6i_flags
&RTF_CACHE
) {
869 dst_set_expires(&rt
->u
.dst
, 0);
870 rt
->rt6i_flags
|= RTF_EXPIRES
;
871 } else if (rt
->rt6i_node
&& (rt
->rt6i_flags
& RTF_DEFAULT
))
872 rt
->rt6i_node
->fn_sernum
= -1;
876 static void ip6_rt_update_pmtu(struct dst_entry
*dst
, u32 mtu
)
878 struct rt6_info
*rt6
= (struct rt6_info
*)dst
;
880 if (mtu
< dst_mtu(dst
) && rt6
->rt6i_dst
.plen
== 128) {
881 rt6
->rt6i_flags
|= RTF_MODIFIED
;
882 if (mtu
< IPV6_MIN_MTU
) {
884 dst
->metrics
[RTAX_FEATURES
-1] |= RTAX_FEATURE_ALLFRAG
;
886 dst
->metrics
[RTAX_MTU
-1] = mtu
;
887 call_netevent_notifiers(NETEVENT_PMTU_UPDATE
, dst
);
891 static int ipv6_get_mtu(struct net_device
*dev
);
893 static inline unsigned int ipv6_advmss(unsigned int mtu
)
895 mtu
-= sizeof(struct ipv6hdr
) + sizeof(struct tcphdr
);
897 if (mtu
< ip6_rt_min_advmss
)
898 mtu
= ip6_rt_min_advmss
;
901 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
902 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
903 * IPV6_MAXPLEN is also valid and means: "any MSS,
904 * rely only on pmtu discovery"
906 if (mtu
> IPV6_MAXPLEN
- sizeof(struct tcphdr
))
911 static struct dst_entry
*ndisc_dst_gc_list
;
912 static DEFINE_SPINLOCK(ndisc_lock
);
914 struct dst_entry
*ndisc_dst_alloc(struct net_device
*dev
,
915 struct neighbour
*neigh
,
916 struct in6_addr
*addr
,
917 int (*output
)(struct sk_buff
*))
920 struct inet6_dev
*idev
= in6_dev_get(dev
);
922 if (unlikely(idev
== NULL
))
925 rt
= ip6_dst_alloc();
926 if (unlikely(rt
== NULL
)) {
935 neigh
= ndisc_get_neigh(dev
, addr
);
938 rt
->rt6i_idev
= idev
;
939 rt
->rt6i_nexthop
= neigh
;
940 atomic_set(&rt
->u
.dst
.__refcnt
, 1);
941 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = 255;
942 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = ipv6_get_mtu(rt
->rt6i_dev
);
943 rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(dst_mtu(&rt
->u
.dst
));
944 rt
->u
.dst
.output
= output
;
946 #if 0 /* there's no chance to use these for ndisc */
947 rt
->u
.dst
.flags
= ipv6_addr_type(addr
) & IPV6_ADDR_UNICAST
950 ipv6_addr_copy(&rt
->rt6i_dst
.addr
, addr
);
951 rt
->rt6i_dst
.plen
= 128;
954 spin_lock_bh(&ndisc_lock
);
955 rt
->u
.dst
.next
= ndisc_dst_gc_list
;
956 ndisc_dst_gc_list
= &rt
->u
.dst
;
957 spin_unlock_bh(&ndisc_lock
);
959 fib6_force_start_gc();
965 int ndisc_dst_gc(int *more
)
967 struct dst_entry
*dst
, *next
, **pprev
;
973 spin_lock_bh(&ndisc_lock
);
974 pprev
= &ndisc_dst_gc_list
;
976 while ((dst
= *pprev
) != NULL
) {
977 if (!atomic_read(&dst
->__refcnt
)) {
987 spin_unlock_bh(&ndisc_lock
);
992 static int ip6_dst_gc(void)
994 static unsigned expire
= 30*HZ
;
995 static unsigned long last_gc
;
996 unsigned long now
= jiffies
;
998 if (time_after(last_gc
+ ip6_rt_gc_min_interval
, now
) &&
999 atomic_read(&ip6_dst_ops
.entries
) <= ip6_rt_max_size
)
1003 fib6_run_gc(expire
);
1005 if (atomic_read(&ip6_dst_ops
.entries
) < ip6_dst_ops
.gc_thresh
)
1006 expire
= ip6_rt_gc_timeout
>>1;
1009 expire
-= expire
>>ip6_rt_gc_elasticity
;
1010 return (atomic_read(&ip6_dst_ops
.entries
) > ip6_rt_max_size
);
1013 /* Clean host part of a prefix. Not necessary in radix tree,
1014 but results in cleaner routing tables.
1016 Remove it only when all the things will work!
1019 static int ipv6_get_mtu(struct net_device
*dev
)
1021 int mtu
= IPV6_MIN_MTU
;
1022 struct inet6_dev
*idev
;
1024 idev
= in6_dev_get(dev
);
1026 mtu
= idev
->cnf
.mtu6
;
1032 int ipv6_get_hoplimit(struct net_device
*dev
)
1034 int hoplimit
= ipv6_devconf
.hop_limit
;
1035 struct inet6_dev
*idev
;
1037 idev
= in6_dev_get(dev
);
1039 hoplimit
= idev
->cnf
.hop_limit
;
1049 int ip6_route_add(struct fib6_config
*cfg
)
1052 struct rt6_info
*rt
= NULL
;
1053 struct net_device
*dev
= NULL
;
1054 struct inet6_dev
*idev
= NULL
;
1055 struct fib6_table
*table
;
1058 if (cfg
->fc_dst_len
> 128 || cfg
->fc_src_len
> 128)
1060 #ifndef CONFIG_IPV6_SUBTREES
1061 if (cfg
->fc_src_len
)
1064 if (cfg
->fc_ifindex
) {
1066 dev
= dev_get_by_index(&init_net
, cfg
->fc_ifindex
);
1069 idev
= in6_dev_get(dev
);
1074 if (cfg
->fc_metric
== 0)
1075 cfg
->fc_metric
= IP6_RT_PRIO_USER
;
1077 table
= fib6_new_table(cfg
->fc_table
);
1078 if (table
== NULL
) {
1083 rt
= ip6_dst_alloc();
1090 rt
->u
.dst
.obsolete
= -1;
1091 rt
->rt6i_expires
= jiffies
+ clock_t_to_jiffies(cfg
->fc_expires
);
1093 if (cfg
->fc_protocol
== RTPROT_UNSPEC
)
1094 cfg
->fc_protocol
= RTPROT_BOOT
;
1095 rt
->rt6i_protocol
= cfg
->fc_protocol
;
1097 addr_type
= ipv6_addr_type(&cfg
->fc_dst
);
1099 if (addr_type
& IPV6_ADDR_MULTICAST
)
1100 rt
->u
.dst
.input
= ip6_mc_input
;
1102 rt
->u
.dst
.input
= ip6_forward
;
1104 rt
->u
.dst
.output
= ip6_output
;
1106 ipv6_addr_prefix(&rt
->rt6i_dst
.addr
, &cfg
->fc_dst
, cfg
->fc_dst_len
);
1107 rt
->rt6i_dst
.plen
= cfg
->fc_dst_len
;
1108 if (rt
->rt6i_dst
.plen
== 128)
1109 rt
->u
.dst
.flags
= DST_HOST
;
1111 #ifdef CONFIG_IPV6_SUBTREES
1112 ipv6_addr_prefix(&rt
->rt6i_src
.addr
, &cfg
->fc_src
, cfg
->fc_src_len
);
1113 rt
->rt6i_src
.plen
= cfg
->fc_src_len
;
1116 rt
->rt6i_metric
= cfg
->fc_metric
;
1118 /* We cannot add true routes via loopback here,
1119 they would result in kernel looping; promote them to reject routes
1121 if ((cfg
->fc_flags
& RTF_REJECT
) ||
1122 (dev
&& (dev
->flags
&IFF_LOOPBACK
) && !(addr_type
&IPV6_ADDR_LOOPBACK
))) {
1123 /* hold loopback dev/idev if we haven't done so. */
1124 if (dev
!= init_net
.loopback_dev
) {
1129 dev
= init_net
.loopback_dev
;
1131 idev
= in6_dev_get(dev
);
1137 rt
->u
.dst
.output
= ip6_pkt_discard_out
;
1138 rt
->u
.dst
.input
= ip6_pkt_discard
;
1139 rt
->u
.dst
.error
= -ENETUNREACH
;
1140 rt
->rt6i_flags
= RTF_REJECT
|RTF_NONEXTHOP
;
1144 if (cfg
->fc_flags
& RTF_GATEWAY
) {
1145 struct in6_addr
*gw_addr
;
1148 gw_addr
= &cfg
->fc_gateway
;
1149 ipv6_addr_copy(&rt
->rt6i_gateway
, gw_addr
);
1150 gwa_type
= ipv6_addr_type(gw_addr
);
1152 if (gwa_type
!= (IPV6_ADDR_LINKLOCAL
|IPV6_ADDR_UNICAST
)) {
1153 struct rt6_info
*grt
;
1155 /* IPv6 strictly inhibits using not link-local
1156 addresses as nexthop address.
1157 Otherwise, router will not able to send redirects.
1158 It is very good, but in some (rare!) circumstances
1159 (SIT, PtP, NBMA NOARP links) it is handy to allow
1160 some exceptions. --ANK
1163 if (!(gwa_type
&IPV6_ADDR_UNICAST
))
1166 grt
= rt6_lookup(gw_addr
, NULL
, cfg
->fc_ifindex
, 1);
1168 err
= -EHOSTUNREACH
;
1172 if (dev
!= grt
->rt6i_dev
) {
1173 dst_release(&grt
->u
.dst
);
1177 dev
= grt
->rt6i_dev
;
1178 idev
= grt
->rt6i_idev
;
1180 in6_dev_hold(grt
->rt6i_idev
);
1182 if (!(grt
->rt6i_flags
&RTF_GATEWAY
))
1184 dst_release(&grt
->u
.dst
);
1190 if (dev
== NULL
|| (dev
->flags
&IFF_LOOPBACK
))
1198 if (cfg
->fc_flags
& (RTF_GATEWAY
| RTF_NONEXTHOP
)) {
1199 rt
->rt6i_nexthop
= __neigh_lookup_errno(&nd_tbl
, &rt
->rt6i_gateway
, dev
);
1200 if (IS_ERR(rt
->rt6i_nexthop
)) {
1201 err
= PTR_ERR(rt
->rt6i_nexthop
);
1202 rt
->rt6i_nexthop
= NULL
;
1207 rt
->rt6i_flags
= cfg
->fc_flags
;
1214 nla_for_each_attr(nla
, cfg
->fc_mx
, cfg
->fc_mx_len
, remaining
) {
1215 int type
= nla_type(nla
);
1218 if (type
> RTAX_MAX
) {
1223 rt
->u
.dst
.metrics
[type
- 1] = nla_get_u32(nla
);
1228 if (rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] == 0)
1229 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = -1;
1230 if (!rt
->u
.dst
.metrics
[RTAX_MTU
-1])
1231 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = ipv6_get_mtu(dev
);
1232 if (!rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1])
1233 rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(dst_mtu(&rt
->u
.dst
));
1234 rt
->u
.dst
.dev
= dev
;
1235 rt
->rt6i_idev
= idev
;
1236 rt
->rt6i_table
= table
;
1237 return __ip6_ins_rt(rt
, &cfg
->fc_nlinfo
);
1245 dst_free(&rt
->u
.dst
);
1249 static int __ip6_del_rt(struct rt6_info
*rt
, struct nl_info
*info
)
1252 struct fib6_table
*table
;
1254 if (rt
== &ip6_null_entry
)
1257 table
= rt
->rt6i_table
;
1258 write_lock_bh(&table
->tb6_lock
);
1260 err
= fib6_del(rt
, info
);
1261 dst_release(&rt
->u
.dst
);
1263 write_unlock_bh(&table
->tb6_lock
);
1268 int ip6_del_rt(struct rt6_info
*rt
)
1270 struct nl_info info
= {};
1271 return __ip6_del_rt(rt
, &info
);
1274 static int ip6_route_del(struct fib6_config
*cfg
)
1276 struct fib6_table
*table
;
1277 struct fib6_node
*fn
;
1278 struct rt6_info
*rt
;
1281 table
= fib6_get_table(cfg
->fc_table
);
1285 read_lock_bh(&table
->tb6_lock
);
1287 fn
= fib6_locate(&table
->tb6_root
,
1288 &cfg
->fc_dst
, cfg
->fc_dst_len
,
1289 &cfg
->fc_src
, cfg
->fc_src_len
);
1292 for (rt
= fn
->leaf
; rt
; rt
= rt
->u
.dst
.rt6_next
) {
1293 if (cfg
->fc_ifindex
&&
1294 (rt
->rt6i_dev
== NULL
||
1295 rt
->rt6i_dev
->ifindex
!= cfg
->fc_ifindex
))
1297 if (cfg
->fc_flags
& RTF_GATEWAY
&&
1298 !ipv6_addr_equal(&cfg
->fc_gateway
, &rt
->rt6i_gateway
))
1300 if (cfg
->fc_metric
&& cfg
->fc_metric
!= rt
->rt6i_metric
)
1302 dst_hold(&rt
->u
.dst
);
1303 read_unlock_bh(&table
->tb6_lock
);
1305 return __ip6_del_rt(rt
, &cfg
->fc_nlinfo
);
1308 read_unlock_bh(&table
->tb6_lock
);
1316 struct ip6rd_flowi
{
1318 struct in6_addr gateway
;
1321 static struct rt6_info
*__ip6_route_redirect(struct fib6_table
*table
,
1325 struct ip6rd_flowi
*rdfl
= (struct ip6rd_flowi
*)fl
;
1326 struct rt6_info
*rt
;
1327 struct fib6_node
*fn
;
1330 * Get the "current" route for this destination and
1331 * check if the redirect has come from approriate router.
1333 * RFC 2461 specifies that redirects should only be
1334 * accepted if they come from the nexthop to the target.
1335 * Due to the way the routes are chosen, this notion
1336 * is a bit fuzzy and one might need to check all possible
1340 read_lock_bh(&table
->tb6_lock
);
1341 fn
= fib6_lookup(&table
->tb6_root
, &fl
->fl6_dst
, &fl
->fl6_src
);
1343 for (rt
= fn
->leaf
; rt
; rt
= rt
->u
.dst
.rt6_next
) {
1345 * Current route is on-link; redirect is always invalid.
1347 * Seems, previous statement is not true. It could
1348 * be node, which looks for us as on-link (f.e. proxy ndisc)
1349 * But then router serving it might decide, that we should
1350 * know truth 8)8) --ANK (980726).
1352 if (rt6_check_expired(rt
))
1354 if (!(rt
->rt6i_flags
& RTF_GATEWAY
))
1356 if (fl
->oif
!= rt
->rt6i_dev
->ifindex
)
1358 if (!ipv6_addr_equal(&rdfl
->gateway
, &rt
->rt6i_gateway
))
1364 rt
= &ip6_null_entry
;
1365 BACKTRACK(&fl
->fl6_src
);
1367 dst_hold(&rt
->u
.dst
);
1369 read_unlock_bh(&table
->tb6_lock
);
1374 static struct rt6_info
*ip6_route_redirect(struct in6_addr
*dest
,
1375 struct in6_addr
*src
,
1376 struct in6_addr
*gateway
,
1377 struct net_device
*dev
)
1379 int flags
= RT6_LOOKUP_F_HAS_SADDR
;
1380 struct ip6rd_flowi rdfl
= {
1382 .oif
= dev
->ifindex
,
1390 .gateway
= *gateway
,
1393 if (rt6_need_strict(dest
))
1394 flags
|= RT6_LOOKUP_F_IFACE
;
1396 return (struct rt6_info
*)fib6_rule_lookup((struct flowi
*)&rdfl
, flags
, __ip6_route_redirect
);
1399 void rt6_redirect(struct in6_addr
*dest
, struct in6_addr
*src
,
1400 struct in6_addr
*saddr
,
1401 struct neighbour
*neigh
, u8
*lladdr
, int on_link
)
1403 struct rt6_info
*rt
, *nrt
= NULL
;
1404 struct netevent_redirect netevent
;
1406 rt
= ip6_route_redirect(dest
, src
, saddr
, neigh
->dev
);
1408 if (rt
== &ip6_null_entry
) {
1409 if (net_ratelimit())
1410 printk(KERN_DEBUG
"rt6_redirect: source isn't a valid nexthop "
1411 "for redirect target\n");
1416 * We have finally decided to accept it.
1419 neigh_update(neigh
, lladdr
, NUD_STALE
,
1420 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1421 NEIGH_UPDATE_F_OVERRIDE
|
1422 (on_link
? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
1423 NEIGH_UPDATE_F_ISROUTER
))
1427 * Redirect received -> path was valid.
1428 * Look, redirects are sent only in response to data packets,
1429 * so that this nexthop apparently is reachable. --ANK
1431 dst_confirm(&rt
->u
.dst
);
1433 /* Duplicate redirect: silently ignore. */
1434 if (neigh
== rt
->u
.dst
.neighbour
)
1437 nrt
= ip6_rt_copy(rt
);
1441 nrt
->rt6i_flags
= RTF_GATEWAY
|RTF_UP
|RTF_DYNAMIC
|RTF_CACHE
;
1443 nrt
->rt6i_flags
&= ~RTF_GATEWAY
;
1445 ipv6_addr_copy(&nrt
->rt6i_dst
.addr
, dest
);
1446 nrt
->rt6i_dst
.plen
= 128;
1447 nrt
->u
.dst
.flags
|= DST_HOST
;
1449 ipv6_addr_copy(&nrt
->rt6i_gateway
, (struct in6_addr
*)neigh
->primary_key
);
1450 nrt
->rt6i_nexthop
= neigh_clone(neigh
);
1451 /* Reset pmtu, it may be better */
1452 nrt
->u
.dst
.metrics
[RTAX_MTU
-1] = ipv6_get_mtu(neigh
->dev
);
1453 nrt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(dst_mtu(&nrt
->u
.dst
));
1455 if (ip6_ins_rt(nrt
))
1458 netevent
.old
= &rt
->u
.dst
;
1459 netevent
.new = &nrt
->u
.dst
;
1460 call_netevent_notifiers(NETEVENT_REDIRECT
, &netevent
);
1462 if (rt
->rt6i_flags
&RTF_CACHE
) {
1468 dst_release(&rt
->u
.dst
);
1473 * Handle ICMP "packet too big" messages
1474 * i.e. Path MTU discovery
1477 void rt6_pmtu_discovery(struct in6_addr
*daddr
, struct in6_addr
*saddr
,
1478 struct net_device
*dev
, u32 pmtu
)
1480 struct rt6_info
*rt
, *nrt
;
1483 rt
= rt6_lookup(daddr
, saddr
, dev
->ifindex
, 0);
1487 if (pmtu
>= dst_mtu(&rt
->u
.dst
))
1490 if (pmtu
< IPV6_MIN_MTU
) {
1492 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1493 * MTU (1280) and a fragment header should always be included
1494 * after a node receiving Too Big message reporting PMTU is
1495 * less than the IPv6 Minimum Link MTU.
1497 pmtu
= IPV6_MIN_MTU
;
1501 /* New mtu received -> path was valid.
1502 They are sent only in response to data packets,
1503 so that this nexthop apparently is reachable. --ANK
1505 dst_confirm(&rt
->u
.dst
);
1507 /* Host route. If it is static, it would be better
1508 not to override it, but add new one, so that
1509 when cache entry will expire old pmtu
1510 would return automatically.
1512 if (rt
->rt6i_flags
& RTF_CACHE
) {
1513 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = pmtu
;
1515 rt
->u
.dst
.metrics
[RTAX_FEATURES
-1] |= RTAX_FEATURE_ALLFRAG
;
1516 dst_set_expires(&rt
->u
.dst
, ip6_rt_mtu_expires
);
1517 rt
->rt6i_flags
|= RTF_MODIFIED
|RTF_EXPIRES
;
1522 Two cases are possible:
1523 1. It is connected route. Action: COW
1524 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1526 if (!rt
->rt6i_nexthop
&& !(rt
->rt6i_flags
& RTF_NONEXTHOP
))
1527 nrt
= rt6_alloc_cow(rt
, daddr
, saddr
);
1529 nrt
= rt6_alloc_clone(rt
, daddr
);
1532 nrt
->u
.dst
.metrics
[RTAX_MTU
-1] = pmtu
;
1534 nrt
->u
.dst
.metrics
[RTAX_FEATURES
-1] |= RTAX_FEATURE_ALLFRAG
;
1536 /* According to RFC 1981, detecting PMTU increase shouldn't be
1537 * happened within 5 mins, the recommended timer is 10 mins.
1538 * Here this route expiration time is set to ip6_rt_mtu_expires
1539 * which is 10 mins. After 10 mins the decreased pmtu is expired
1540 * and detecting PMTU increase will be automatically happened.
1542 dst_set_expires(&nrt
->u
.dst
, ip6_rt_mtu_expires
);
1543 nrt
->rt6i_flags
|= RTF_DYNAMIC
|RTF_EXPIRES
;
1548 dst_release(&rt
->u
.dst
);
1552 * Misc support functions
1555 static struct rt6_info
* ip6_rt_copy(struct rt6_info
*ort
)
1557 struct rt6_info
*rt
= ip6_dst_alloc();
1560 rt
->u
.dst
.input
= ort
->u
.dst
.input
;
1561 rt
->u
.dst
.output
= ort
->u
.dst
.output
;
1563 memcpy(rt
->u
.dst
.metrics
, ort
->u
.dst
.metrics
, RTAX_MAX
*sizeof(u32
));
1564 rt
->u
.dst
.error
= ort
->u
.dst
.error
;
1565 rt
->u
.dst
.dev
= ort
->u
.dst
.dev
;
1567 dev_hold(rt
->u
.dst
.dev
);
1568 rt
->rt6i_idev
= ort
->rt6i_idev
;
1570 in6_dev_hold(rt
->rt6i_idev
);
1571 rt
->u
.dst
.lastuse
= jiffies
;
1572 rt
->rt6i_expires
= 0;
1574 ipv6_addr_copy(&rt
->rt6i_gateway
, &ort
->rt6i_gateway
);
1575 rt
->rt6i_flags
= ort
->rt6i_flags
& ~RTF_EXPIRES
;
1576 rt
->rt6i_metric
= 0;
1578 memcpy(&rt
->rt6i_dst
, &ort
->rt6i_dst
, sizeof(struct rt6key
));
1579 #ifdef CONFIG_IPV6_SUBTREES
1580 memcpy(&rt
->rt6i_src
, &ort
->rt6i_src
, sizeof(struct rt6key
));
1582 rt
->rt6i_table
= ort
->rt6i_table
;
1587 #ifdef CONFIG_IPV6_ROUTE_INFO
1588 static struct rt6_info
*rt6_get_route_info(struct in6_addr
*prefix
, int prefixlen
,
1589 struct in6_addr
*gwaddr
, int ifindex
)
1591 struct fib6_node
*fn
;
1592 struct rt6_info
*rt
= NULL
;
1593 struct fib6_table
*table
;
1595 table
= fib6_get_table(RT6_TABLE_INFO
);
1599 write_lock_bh(&table
->tb6_lock
);
1600 fn
= fib6_locate(&table
->tb6_root
, prefix
,prefixlen
, NULL
, 0);
1604 for (rt
= fn
->leaf
; rt
; rt
= rt
->u
.dst
.rt6_next
) {
1605 if (rt
->rt6i_dev
->ifindex
!= ifindex
)
1607 if ((rt
->rt6i_flags
& (RTF_ROUTEINFO
|RTF_GATEWAY
)) != (RTF_ROUTEINFO
|RTF_GATEWAY
))
1609 if (!ipv6_addr_equal(&rt
->rt6i_gateway
, gwaddr
))
1611 dst_hold(&rt
->u
.dst
);
1615 write_unlock_bh(&table
->tb6_lock
);
1619 static struct rt6_info
*rt6_add_route_info(struct in6_addr
*prefix
, int prefixlen
,
1620 struct in6_addr
*gwaddr
, int ifindex
,
1623 struct fib6_config cfg
= {
1624 .fc_table
= RT6_TABLE_INFO
,
1626 .fc_ifindex
= ifindex
,
1627 .fc_dst_len
= prefixlen
,
1628 .fc_flags
= RTF_GATEWAY
| RTF_ADDRCONF
| RTF_ROUTEINFO
|
1629 RTF_UP
| RTF_PREF(pref
),
1632 ipv6_addr_copy(&cfg
.fc_dst
, prefix
);
1633 ipv6_addr_copy(&cfg
.fc_gateway
, gwaddr
);
1635 /* We should treat it as a default route if prefix length is 0. */
1637 cfg
.fc_flags
|= RTF_DEFAULT
;
1639 ip6_route_add(&cfg
);
1641 return rt6_get_route_info(prefix
, prefixlen
, gwaddr
, ifindex
);
1645 struct rt6_info
*rt6_get_dflt_router(struct in6_addr
*addr
, struct net_device
*dev
)
1647 struct rt6_info
*rt
;
1648 struct fib6_table
*table
;
1650 table
= fib6_get_table(RT6_TABLE_DFLT
);
1654 write_lock_bh(&table
->tb6_lock
);
1655 for (rt
= table
->tb6_root
.leaf
; rt
; rt
=rt
->u
.dst
.rt6_next
) {
1656 if (dev
== rt
->rt6i_dev
&&
1657 ((rt
->rt6i_flags
& (RTF_ADDRCONF
| RTF_DEFAULT
)) == (RTF_ADDRCONF
| RTF_DEFAULT
)) &&
1658 ipv6_addr_equal(&rt
->rt6i_gateway
, addr
))
1662 dst_hold(&rt
->u
.dst
);
1663 write_unlock_bh(&table
->tb6_lock
);
1667 EXPORT_SYMBOL(rt6_get_dflt_router
);
1669 struct rt6_info
*rt6_add_dflt_router(struct in6_addr
*gwaddr
,
1670 struct net_device
*dev
,
1673 struct fib6_config cfg
= {
1674 .fc_table
= RT6_TABLE_DFLT
,
1676 .fc_ifindex
= dev
->ifindex
,
1677 .fc_flags
= RTF_GATEWAY
| RTF_ADDRCONF
| RTF_DEFAULT
|
1678 RTF_UP
| RTF_EXPIRES
| RTF_PREF(pref
),
1681 ipv6_addr_copy(&cfg
.fc_gateway
, gwaddr
);
1683 ip6_route_add(&cfg
);
1685 return rt6_get_dflt_router(gwaddr
, dev
);
1688 void rt6_purge_dflt_routers(void)
1690 struct rt6_info
*rt
;
1691 struct fib6_table
*table
;
1693 /* NOTE: Keep consistent with rt6_get_dflt_router */
1694 table
= fib6_get_table(RT6_TABLE_DFLT
);
1699 read_lock_bh(&table
->tb6_lock
);
1700 for (rt
= table
->tb6_root
.leaf
; rt
; rt
= rt
->u
.dst
.rt6_next
) {
1701 if (rt
->rt6i_flags
& (RTF_DEFAULT
| RTF_ADDRCONF
)) {
1702 dst_hold(&rt
->u
.dst
);
1703 read_unlock_bh(&table
->tb6_lock
);
1708 read_unlock_bh(&table
->tb6_lock
);
1711 static void rtmsg_to_fib6_config(struct in6_rtmsg
*rtmsg
,
1712 struct fib6_config
*cfg
)
1714 memset(cfg
, 0, sizeof(*cfg
));
1716 cfg
->fc_table
= RT6_TABLE_MAIN
;
1717 cfg
->fc_ifindex
= rtmsg
->rtmsg_ifindex
;
1718 cfg
->fc_metric
= rtmsg
->rtmsg_metric
;
1719 cfg
->fc_expires
= rtmsg
->rtmsg_info
;
1720 cfg
->fc_dst_len
= rtmsg
->rtmsg_dst_len
;
1721 cfg
->fc_src_len
= rtmsg
->rtmsg_src_len
;
1722 cfg
->fc_flags
= rtmsg
->rtmsg_flags
;
1724 ipv6_addr_copy(&cfg
->fc_dst
, &rtmsg
->rtmsg_dst
);
1725 ipv6_addr_copy(&cfg
->fc_src
, &rtmsg
->rtmsg_src
);
1726 ipv6_addr_copy(&cfg
->fc_gateway
, &rtmsg
->rtmsg_gateway
);
1729 int ipv6_route_ioctl(unsigned int cmd
, void __user
*arg
)
1731 struct fib6_config cfg
;
1732 struct in6_rtmsg rtmsg
;
1736 case SIOCADDRT
: /* Add a route */
1737 case SIOCDELRT
: /* Delete a route */
1738 if (!capable(CAP_NET_ADMIN
))
1740 err
= copy_from_user(&rtmsg
, arg
,
1741 sizeof(struct in6_rtmsg
));
1745 rtmsg_to_fib6_config(&rtmsg
, &cfg
);
1750 err
= ip6_route_add(&cfg
);
1753 err
= ip6_route_del(&cfg
);
1767 * Drop the packet on the floor
1770 static inline int ip6_pkt_drop(struct sk_buff
*skb
, int code
,
1771 int ipstats_mib_noroutes
)
1774 switch (ipstats_mib_noroutes
) {
1775 case IPSTATS_MIB_INNOROUTES
:
1776 type
= ipv6_addr_type(&ipv6_hdr(skb
)->daddr
);
1777 if (type
== IPV6_ADDR_ANY
|| type
== IPV6_ADDR_RESERVED
) {
1778 IP6_INC_STATS(ip6_dst_idev(skb
->dst
), IPSTATS_MIB_INADDRERRORS
);
1782 case IPSTATS_MIB_OUTNOROUTES
:
1783 IP6_INC_STATS(ip6_dst_idev(skb
->dst
), ipstats_mib_noroutes
);
1786 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, code
, 0, skb
->dev
);
1791 static int ip6_pkt_discard(struct sk_buff
*skb
)
1793 return ip6_pkt_drop(skb
, ICMPV6_NOROUTE
, IPSTATS_MIB_INNOROUTES
);
1796 static int ip6_pkt_discard_out(struct sk_buff
*skb
)
1798 skb
->dev
= skb
->dst
->dev
;
1799 return ip6_pkt_drop(skb
, ICMPV6_NOROUTE
, IPSTATS_MIB_OUTNOROUTES
);
1802 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
1804 static int ip6_pkt_prohibit(struct sk_buff
*skb
)
1806 return ip6_pkt_drop(skb
, ICMPV6_ADM_PROHIBITED
, IPSTATS_MIB_INNOROUTES
);
1809 static int ip6_pkt_prohibit_out(struct sk_buff
*skb
)
1811 skb
->dev
= skb
->dst
->dev
;
1812 return ip6_pkt_drop(skb
, ICMPV6_ADM_PROHIBITED
, IPSTATS_MIB_OUTNOROUTES
);
1818 * Allocate a dst for local (unicast / anycast) address.
1821 struct rt6_info
*addrconf_dst_alloc(struct inet6_dev
*idev
,
1822 const struct in6_addr
*addr
,
1825 struct rt6_info
*rt
= ip6_dst_alloc();
1828 return ERR_PTR(-ENOMEM
);
1830 dev_hold(init_net
.loopback_dev
);
1833 rt
->u
.dst
.flags
= DST_HOST
;
1834 rt
->u
.dst
.input
= ip6_input
;
1835 rt
->u
.dst
.output
= ip6_output
;
1836 rt
->rt6i_dev
= init_net
.loopback_dev
;
1837 rt
->rt6i_idev
= idev
;
1838 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = ipv6_get_mtu(rt
->rt6i_dev
);
1839 rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(dst_mtu(&rt
->u
.dst
));
1840 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = -1;
1841 rt
->u
.dst
.obsolete
= -1;
1843 rt
->rt6i_flags
= RTF_UP
| RTF_NONEXTHOP
;
1845 rt
->rt6i_flags
|= RTF_ANYCAST
;
1847 rt
->rt6i_flags
|= RTF_LOCAL
;
1848 rt
->rt6i_nexthop
= ndisc_get_neigh(rt
->rt6i_dev
, &rt
->rt6i_gateway
);
1849 if (rt
->rt6i_nexthop
== NULL
) {
1850 dst_free(&rt
->u
.dst
);
1851 return ERR_PTR(-ENOMEM
);
1854 ipv6_addr_copy(&rt
->rt6i_dst
.addr
, addr
);
1855 rt
->rt6i_dst
.plen
= 128;
1856 rt
->rt6i_table
= fib6_get_table(RT6_TABLE_LOCAL
);
1858 atomic_set(&rt
->u
.dst
.__refcnt
, 1);
1863 static int fib6_ifdown(struct rt6_info
*rt
, void *arg
)
1865 if (((void*)rt
->rt6i_dev
== arg
|| arg
== NULL
) &&
1866 rt
!= &ip6_null_entry
) {
1867 RT6_TRACE("deleted by ifdown %p\n", rt
);
1873 void rt6_ifdown(struct net_device
*dev
)
1875 fib6_clean_all(fib6_ifdown
, 0, dev
);
1878 struct rt6_mtu_change_arg
1880 struct net_device
*dev
;
1884 static int rt6_mtu_change_route(struct rt6_info
*rt
, void *p_arg
)
1886 struct rt6_mtu_change_arg
*arg
= (struct rt6_mtu_change_arg
*) p_arg
;
1887 struct inet6_dev
*idev
;
1889 /* In IPv6 pmtu discovery is not optional,
1890 so that RTAX_MTU lock cannot disable it.
1891 We still use this lock to block changes
1892 caused by addrconf/ndisc.
1895 idev
= __in6_dev_get(arg
->dev
);
1899 /* For administrative MTU increase, there is no way to discover
1900 IPv6 PMTU increase, so PMTU increase should be updated here.
1901 Since RFC 1981 doesn't include administrative MTU increase
1902 update PMTU increase is a MUST. (i.e. jumbo frame)
1905 If new MTU is less than route PMTU, this new MTU will be the
1906 lowest MTU in the path, update the route PMTU to reflect PMTU
1907 decreases; if new MTU is greater than route PMTU, and the
1908 old MTU is the lowest MTU in the path, update the route PMTU
1909 to reflect the increase. In this case if the other nodes' MTU
1910 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1913 if (rt
->rt6i_dev
== arg
->dev
&&
1914 !dst_metric_locked(&rt
->u
.dst
, RTAX_MTU
) &&
1915 (dst_mtu(&rt
->u
.dst
) > arg
->mtu
||
1916 (dst_mtu(&rt
->u
.dst
) < arg
->mtu
&&
1917 dst_mtu(&rt
->u
.dst
) == idev
->cnf
.mtu6
))) {
1918 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = arg
->mtu
;
1919 rt
->u
.dst
.metrics
[RTAX_ADVMSS
-1] = ipv6_advmss(arg
->mtu
);
1924 void rt6_mtu_change(struct net_device
*dev
, unsigned mtu
)
1926 struct rt6_mtu_change_arg arg
= {
1931 fib6_clean_all(rt6_mtu_change_route
, 0, &arg
);
1934 static const struct nla_policy rtm_ipv6_policy
[RTA_MAX
+1] = {
1935 [RTA_GATEWAY
] = { .len
= sizeof(struct in6_addr
) },
1936 [RTA_OIF
] = { .type
= NLA_U32
},
1937 [RTA_IIF
] = { .type
= NLA_U32
},
1938 [RTA_PRIORITY
] = { .type
= NLA_U32
},
1939 [RTA_METRICS
] = { .type
= NLA_NESTED
},
1942 static int rtm_to_fib6_config(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
1943 struct fib6_config
*cfg
)
1946 struct nlattr
*tb
[RTA_MAX
+1];
1949 err
= nlmsg_parse(nlh
, sizeof(*rtm
), tb
, RTA_MAX
, rtm_ipv6_policy
);
1954 rtm
= nlmsg_data(nlh
);
1955 memset(cfg
, 0, sizeof(*cfg
));
1957 cfg
->fc_table
= rtm
->rtm_table
;
1958 cfg
->fc_dst_len
= rtm
->rtm_dst_len
;
1959 cfg
->fc_src_len
= rtm
->rtm_src_len
;
1960 cfg
->fc_flags
= RTF_UP
;
1961 cfg
->fc_protocol
= rtm
->rtm_protocol
;
1963 if (rtm
->rtm_type
== RTN_UNREACHABLE
)
1964 cfg
->fc_flags
|= RTF_REJECT
;
1966 cfg
->fc_nlinfo
.pid
= NETLINK_CB(skb
).pid
;
1967 cfg
->fc_nlinfo
.nlh
= nlh
;
1969 if (tb
[RTA_GATEWAY
]) {
1970 nla_memcpy(&cfg
->fc_gateway
, tb
[RTA_GATEWAY
], 16);
1971 cfg
->fc_flags
|= RTF_GATEWAY
;
1975 int plen
= (rtm
->rtm_dst_len
+ 7) >> 3;
1977 if (nla_len(tb
[RTA_DST
]) < plen
)
1980 nla_memcpy(&cfg
->fc_dst
, tb
[RTA_DST
], plen
);
1984 int plen
= (rtm
->rtm_src_len
+ 7) >> 3;
1986 if (nla_len(tb
[RTA_SRC
]) < plen
)
1989 nla_memcpy(&cfg
->fc_src
, tb
[RTA_SRC
], plen
);
1993 cfg
->fc_ifindex
= nla_get_u32(tb
[RTA_OIF
]);
1995 if (tb
[RTA_PRIORITY
])
1996 cfg
->fc_metric
= nla_get_u32(tb
[RTA_PRIORITY
]);
1998 if (tb
[RTA_METRICS
]) {
1999 cfg
->fc_mx
= nla_data(tb
[RTA_METRICS
]);
2000 cfg
->fc_mx_len
= nla_len(tb
[RTA_METRICS
]);
2004 cfg
->fc_table
= nla_get_u32(tb
[RTA_TABLE
]);
2011 static int inet6_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
2013 struct net
*net
= skb
->sk
->sk_net
;
2014 struct fib6_config cfg
;
2017 if (net
!= &init_net
)
2020 err
= rtm_to_fib6_config(skb
, nlh
, &cfg
);
2024 return ip6_route_del(&cfg
);
2027 static int inet6_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
2029 struct net
*net
= skb
->sk
->sk_net
;
2030 struct fib6_config cfg
;
2033 if (net
!= &init_net
)
2036 err
= rtm_to_fib6_config(skb
, nlh
, &cfg
);
2040 return ip6_route_add(&cfg
);
2043 static inline size_t rt6_nlmsg_size(void)
2045 return NLMSG_ALIGN(sizeof(struct rtmsg
))
2046 + nla_total_size(16) /* RTA_SRC */
2047 + nla_total_size(16) /* RTA_DST */
2048 + nla_total_size(16) /* RTA_GATEWAY */
2049 + nla_total_size(16) /* RTA_PREFSRC */
2050 + nla_total_size(4) /* RTA_TABLE */
2051 + nla_total_size(4) /* RTA_IIF */
2052 + nla_total_size(4) /* RTA_OIF */
2053 + nla_total_size(4) /* RTA_PRIORITY */
2054 + RTAX_MAX
* nla_total_size(4) /* RTA_METRICS */
2055 + nla_total_size(sizeof(struct rta_cacheinfo
));
2058 static int rt6_fill_node(struct sk_buff
*skb
, struct rt6_info
*rt
,
2059 struct in6_addr
*dst
, struct in6_addr
*src
,
2060 int iif
, int type
, u32 pid
, u32 seq
,
2061 int prefix
, unsigned int flags
)
2064 struct nlmsghdr
*nlh
;
2068 if (prefix
) { /* user wants prefix routes only */
2069 if (!(rt
->rt6i_flags
& RTF_PREFIX_RT
)) {
2070 /* success since this is not a prefix route */
2075 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*rtm
), flags
);
2079 rtm
= nlmsg_data(nlh
);
2080 rtm
->rtm_family
= AF_INET6
;
2081 rtm
->rtm_dst_len
= rt
->rt6i_dst
.plen
;
2082 rtm
->rtm_src_len
= rt
->rt6i_src
.plen
;
2085 table
= rt
->rt6i_table
->tb6_id
;
2087 table
= RT6_TABLE_UNSPEC
;
2088 rtm
->rtm_table
= table
;
2089 NLA_PUT_U32(skb
, RTA_TABLE
, table
);
2090 if (rt
->rt6i_flags
&RTF_REJECT
)
2091 rtm
->rtm_type
= RTN_UNREACHABLE
;
2092 else if (rt
->rt6i_dev
&& (rt
->rt6i_dev
->flags
&IFF_LOOPBACK
))
2093 rtm
->rtm_type
= RTN_LOCAL
;
2095 rtm
->rtm_type
= RTN_UNICAST
;
2097 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
2098 rtm
->rtm_protocol
= rt
->rt6i_protocol
;
2099 if (rt
->rt6i_flags
&RTF_DYNAMIC
)
2100 rtm
->rtm_protocol
= RTPROT_REDIRECT
;
2101 else if (rt
->rt6i_flags
& RTF_ADDRCONF
)
2102 rtm
->rtm_protocol
= RTPROT_KERNEL
;
2103 else if (rt
->rt6i_flags
&RTF_DEFAULT
)
2104 rtm
->rtm_protocol
= RTPROT_RA
;
2106 if (rt
->rt6i_flags
&RTF_CACHE
)
2107 rtm
->rtm_flags
|= RTM_F_CLONED
;
2110 NLA_PUT(skb
, RTA_DST
, 16, dst
);
2111 rtm
->rtm_dst_len
= 128;
2112 } else if (rtm
->rtm_dst_len
)
2113 NLA_PUT(skb
, RTA_DST
, 16, &rt
->rt6i_dst
.addr
);
2114 #ifdef CONFIG_IPV6_SUBTREES
2116 NLA_PUT(skb
, RTA_SRC
, 16, src
);
2117 rtm
->rtm_src_len
= 128;
2118 } else if (rtm
->rtm_src_len
)
2119 NLA_PUT(skb
, RTA_SRC
, 16, &rt
->rt6i_src
.addr
);
2122 NLA_PUT_U32(skb
, RTA_IIF
, iif
);
2124 struct in6_addr saddr_buf
;
2125 if (ipv6_get_saddr(&rt
->u
.dst
, dst
, &saddr_buf
) == 0)
2126 NLA_PUT(skb
, RTA_PREFSRC
, 16, &saddr_buf
);
2129 if (rtnetlink_put_metrics(skb
, rt
->u
.dst
.metrics
) < 0)
2130 goto nla_put_failure
;
2132 if (rt
->u
.dst
.neighbour
)
2133 NLA_PUT(skb
, RTA_GATEWAY
, 16, &rt
->u
.dst
.neighbour
->primary_key
);
2136 NLA_PUT_U32(skb
, RTA_OIF
, rt
->rt6i_dev
->ifindex
);
2138 NLA_PUT_U32(skb
, RTA_PRIORITY
, rt
->rt6i_metric
);
2140 expires
= rt
->rt6i_expires
? rt
->rt6i_expires
- jiffies
: 0;
2141 if (rtnl_put_cacheinfo(skb
, &rt
->u
.dst
, 0, 0, 0,
2142 expires
, rt
->u
.dst
.error
) < 0)
2143 goto nla_put_failure
;
2145 return nlmsg_end(skb
, nlh
);
2148 nlmsg_cancel(skb
, nlh
);
2152 int rt6_dump_route(struct rt6_info
*rt
, void *p_arg
)
2154 struct rt6_rtnl_dump_arg
*arg
= (struct rt6_rtnl_dump_arg
*) p_arg
;
2157 if (nlmsg_len(arg
->cb
->nlh
) >= sizeof(struct rtmsg
)) {
2158 struct rtmsg
*rtm
= nlmsg_data(arg
->cb
->nlh
);
2159 prefix
= (rtm
->rtm_flags
& RTM_F_PREFIX
) != 0;
2163 return rt6_fill_node(arg
->skb
, rt
, NULL
, NULL
, 0, RTM_NEWROUTE
,
2164 NETLINK_CB(arg
->cb
->skb
).pid
, arg
->cb
->nlh
->nlmsg_seq
,
2165 prefix
, NLM_F_MULTI
);
2168 static int inet6_rtm_getroute(struct sk_buff
*in_skb
, struct nlmsghdr
* nlh
, void *arg
)
2170 struct net
*net
= in_skb
->sk
->sk_net
;
2171 struct nlattr
*tb
[RTA_MAX
+1];
2172 struct rt6_info
*rt
;
2173 struct sk_buff
*skb
;
2178 if (net
!= &init_net
)
2181 err
= nlmsg_parse(nlh
, sizeof(*rtm
), tb
, RTA_MAX
, rtm_ipv6_policy
);
2186 memset(&fl
, 0, sizeof(fl
));
2189 if (nla_len(tb
[RTA_SRC
]) < sizeof(struct in6_addr
))
2192 ipv6_addr_copy(&fl
.fl6_src
, nla_data(tb
[RTA_SRC
]));
2196 if (nla_len(tb
[RTA_DST
]) < sizeof(struct in6_addr
))
2199 ipv6_addr_copy(&fl
.fl6_dst
, nla_data(tb
[RTA_DST
]));
2203 iif
= nla_get_u32(tb
[RTA_IIF
]);
2206 fl
.oif
= nla_get_u32(tb
[RTA_OIF
]);
2209 struct net_device
*dev
;
2210 dev
= __dev_get_by_index(&init_net
, iif
);
2217 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
2223 /* Reserve room for dummy headers, this skb can pass
2224 through good chunk of routing engine.
2226 skb_reset_mac_header(skb
);
2227 skb_reserve(skb
, MAX_HEADER
+ sizeof(struct ipv6hdr
));
2229 rt
= (struct rt6_info
*) ip6_route_output(NULL
, &fl
);
2230 skb
->dst
= &rt
->u
.dst
;
2232 err
= rt6_fill_node(skb
, rt
, &fl
.fl6_dst
, &fl
.fl6_src
, iif
,
2233 RTM_NEWROUTE
, NETLINK_CB(in_skb
).pid
,
2234 nlh
->nlmsg_seq
, 0, 0);
2240 err
= rtnl_unicast(skb
, &init_net
, NETLINK_CB(in_skb
).pid
);
2245 void inet6_rt_notify(int event
, struct rt6_info
*rt
, struct nl_info
*info
)
2247 struct sk_buff
*skb
;
2252 seq
= info
->nlh
!= NULL
? info
->nlh
->nlmsg_seq
: 0;
2254 skb
= nlmsg_new(rt6_nlmsg_size(), gfp_any());
2258 err
= rt6_fill_node(skb
, rt
, NULL
, NULL
, 0,
2259 event
, info
->pid
, seq
, 0, 0);
2261 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2262 WARN_ON(err
== -EMSGSIZE
);
2266 err
= rtnl_notify(skb
, &init_net
, info
->pid
,
2267 RTNLGRP_IPV6_ROUTE
, info
->nlh
, gfp_any());
2270 rtnl_set_sk_err(&init_net
, RTNLGRP_IPV6_ROUTE
, err
);
2277 #ifdef CONFIG_PROC_FS
2279 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2290 static int rt6_info_route(struct rt6_info
*rt
, void *p_arg
)
2292 struct seq_file
*m
= p_arg
;
2294 seq_printf(m
, NIP6_SEQFMT
" %02x ", NIP6(rt
->rt6i_dst
.addr
),
2297 #ifdef CONFIG_IPV6_SUBTREES
2298 seq_printf(m
, NIP6_SEQFMT
" %02x ", NIP6(rt
->rt6i_src
.addr
),
2301 seq_puts(m
, "00000000000000000000000000000000 00 ");
2304 if (rt
->rt6i_nexthop
) {
2305 seq_printf(m
, NIP6_SEQFMT
,
2306 NIP6(*((struct in6_addr
*)rt
->rt6i_nexthop
->primary_key
)));
2308 seq_puts(m
, "00000000000000000000000000000000");
2310 seq_printf(m
, " %08x %08x %08x %08x %8s\n",
2311 rt
->rt6i_metric
, atomic_read(&rt
->u
.dst
.__refcnt
),
2312 rt
->u
.dst
.__use
, rt
->rt6i_flags
,
2313 rt
->rt6i_dev
? rt
->rt6i_dev
->name
: "");
2317 static int ipv6_route_show(struct seq_file
*m
, void *v
)
2319 fib6_clean_all(rt6_info_route
, 0, m
);
2323 static int ipv6_route_open(struct inode
*inode
, struct file
*file
)
2325 return single_open(file
, ipv6_route_show
, NULL
);
2328 static const struct file_operations ipv6_route_proc_fops
= {
2329 .owner
= THIS_MODULE
,
2330 .open
= ipv6_route_open
,
2332 .llseek
= seq_lseek
,
2333 .release
= single_release
,
2336 static int rt6_stats_seq_show(struct seq_file
*seq
, void *v
)
2338 seq_printf(seq
, "%04x %04x %04x %04x %04x %04x %04x\n",
2339 rt6_stats
.fib_nodes
, rt6_stats
.fib_route_nodes
,
2340 rt6_stats
.fib_rt_alloc
, rt6_stats
.fib_rt_entries
,
2341 rt6_stats
.fib_rt_cache
,
2342 atomic_read(&ip6_dst_ops
.entries
),
2343 rt6_stats
.fib_discarded_routes
);
2348 static int rt6_stats_seq_open(struct inode
*inode
, struct file
*file
)
2350 return single_open(file
, rt6_stats_seq_show
, NULL
);
2353 static const struct file_operations rt6_stats_seq_fops
= {
2354 .owner
= THIS_MODULE
,
2355 .open
= rt6_stats_seq_open
,
2357 .llseek
= seq_lseek
,
2358 .release
= single_release
,
2361 static int ipv6_route_proc_init(struct net
*net
)
2364 if (!proc_net_fops_create(net
, "ipv6_route",
2365 0, &ipv6_route_proc_fops
))
2368 if (!proc_net_fops_create(net
, "rt6_stats",
2369 S_IRUGO
, &rt6_stats_seq_fops
))
2370 goto out_ipv6_route
;
2376 proc_net_remove(net
, "ipv6_route");
2380 static void ipv6_route_proc_fini(struct net
*net
)
2382 proc_net_remove(net
, "ipv6_route");
2383 proc_net_remove(net
, "rt6_stats");
2386 static inline int ipv6_route_proc_init(struct net
*net
)
2390 static inline void ipv6_route_proc_fini(struct net
*net
)
2394 #endif /* CONFIG_PROC_FS */
2396 #ifdef CONFIG_SYSCTL
2398 static int flush_delay
;
2401 int ipv6_sysctl_rtcache_flush(ctl_table
*ctl
, int write
, struct file
* filp
,
2402 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2405 proc_dointvec(ctl
, write
, filp
, buffer
, lenp
, ppos
);
2406 fib6_run_gc(flush_delay
<= 0 ? ~0UL : (unsigned long)flush_delay
);
2412 ctl_table ipv6_route_table_template
[] = {
2414 .procname
= "flush",
2415 .data
= &flush_delay
,
2416 .maxlen
= sizeof(int),
2418 .proc_handler
= &ipv6_sysctl_rtcache_flush
2421 .ctl_name
= NET_IPV6_ROUTE_GC_THRESH
,
2422 .procname
= "gc_thresh",
2423 .data
= &ip6_dst_ops
.gc_thresh
,
2424 .maxlen
= sizeof(int),
2426 .proc_handler
= &proc_dointvec
,
2429 .ctl_name
= NET_IPV6_ROUTE_MAX_SIZE
,
2430 .procname
= "max_size",
2431 .data
= &ip6_rt_max_size
,
2432 .maxlen
= sizeof(int),
2434 .proc_handler
= &proc_dointvec
,
2437 .ctl_name
= NET_IPV6_ROUTE_GC_MIN_INTERVAL
,
2438 .procname
= "gc_min_interval",
2439 .data
= &ip6_rt_gc_min_interval
,
2440 .maxlen
= sizeof(int),
2442 .proc_handler
= &proc_dointvec_jiffies
,
2443 .strategy
= &sysctl_jiffies
,
2446 .ctl_name
= NET_IPV6_ROUTE_GC_TIMEOUT
,
2447 .procname
= "gc_timeout",
2448 .data
= &ip6_rt_gc_timeout
,
2449 .maxlen
= sizeof(int),
2451 .proc_handler
= &proc_dointvec_jiffies
,
2452 .strategy
= &sysctl_jiffies
,
2455 .ctl_name
= NET_IPV6_ROUTE_GC_INTERVAL
,
2456 .procname
= "gc_interval",
2457 .data
= &ip6_rt_gc_interval
,
2458 .maxlen
= sizeof(int),
2460 .proc_handler
= &proc_dointvec_jiffies
,
2461 .strategy
= &sysctl_jiffies
,
2464 .ctl_name
= NET_IPV6_ROUTE_GC_ELASTICITY
,
2465 .procname
= "gc_elasticity",
2466 .data
= &ip6_rt_gc_elasticity
,
2467 .maxlen
= sizeof(int),
2469 .proc_handler
= &proc_dointvec_jiffies
,
2470 .strategy
= &sysctl_jiffies
,
2473 .ctl_name
= NET_IPV6_ROUTE_MTU_EXPIRES
,
2474 .procname
= "mtu_expires",
2475 .data
= &ip6_rt_mtu_expires
,
2476 .maxlen
= sizeof(int),
2478 .proc_handler
= &proc_dointvec_jiffies
,
2479 .strategy
= &sysctl_jiffies
,
2482 .ctl_name
= NET_IPV6_ROUTE_MIN_ADVMSS
,
2483 .procname
= "min_adv_mss",
2484 .data
= &ip6_rt_min_advmss
,
2485 .maxlen
= sizeof(int),
2487 .proc_handler
= &proc_dointvec_jiffies
,
2488 .strategy
= &sysctl_jiffies
,
2491 .ctl_name
= NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS
,
2492 .procname
= "gc_min_interval_ms",
2493 .data
= &ip6_rt_gc_min_interval
,
2494 .maxlen
= sizeof(int),
2496 .proc_handler
= &proc_dointvec_ms_jiffies
,
2497 .strategy
= &sysctl_ms_jiffies
,
2502 struct ctl_table
*ipv6_route_sysctl_init(struct net
*net
)
2504 struct ctl_table
*table
;
2506 table
= kmemdup(ipv6_route_table_template
,
2507 sizeof(ipv6_route_table_template
),
2513 int __init
ip6_route_init(void)
2517 ip6_dst_ops
.kmem_cachep
=
2518 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info
), 0,
2519 SLAB_HWCACHE_ALIGN
, NULL
);
2520 if (!ip6_dst_ops
.kmem_cachep
)
2523 ip6_dst_blackhole_ops
.kmem_cachep
= ip6_dst_ops
.kmem_cachep
;
2527 goto out_kmem_cache
;
2529 ret
= ipv6_route_proc_init(&init_net
);
2537 ret
= fib6_rules_init();
2542 if (__rtnl_register(PF_INET6
, RTM_NEWROUTE
, inet6_rtm_newroute
, NULL
) ||
2543 __rtnl_register(PF_INET6
, RTM_DELROUTE
, inet6_rtm_delroute
, NULL
) ||
2544 __rtnl_register(PF_INET6
, RTM_GETROUTE
, inet6_rtm_getroute
, NULL
))
2545 goto fib6_rules_init
;
2552 fib6_rules_cleanup();
2556 ipv6_route_proc_fini(&init_net
);
2561 kmem_cache_destroy(ip6_dst_ops
.kmem_cachep
);
2565 void ip6_route_cleanup(void)
2567 fib6_rules_cleanup();
2568 ipv6_route_proc_fini(&init_net
);
2572 kmem_cache_destroy(ip6_dst_ops
.kmem_cachep
);