2 * Linux INET6 implementation
3 * Forwarding Information Database
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * $Id: ip6_fib.c,v 1.25 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 * Yuji SEKIYA @USAGI: Support default route on router node;
19 * remove ip6_null_entry from the top of
22 #include <linux/config.h>
23 #include <linux/errno.h>
24 #include <linux/types.h>
25 #include <linux/net.h>
26 #include <linux/route.h>
27 #include <linux/netdevice.h>
28 #include <linux/in6.h>
29 #include <linux/init.h>
32 #include <linux/proc_fs.h>
36 #include <net/ndisc.h>
37 #include <net/addrconf.h>
39 #include <net/ip6_fib.h>
40 #include <net/ip6_route.h>
43 #undef CONFIG_IPV6_SUBTREES
46 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
48 #define RT6_TRACE(x...) do { ; } while (0)
51 struct rt6_statistics rt6_stats
;
53 static kmem_cache_t
* fib6_node_kmem
;
57 #ifdef CONFIG_IPV6_SUBTREES
68 struct fib6_walker_t w
;
69 int (*func
)(struct rt6_info
*, void *arg
);
73 rwlock_t fib6_walker_lock
= RW_LOCK_UNLOCKED
;
76 #ifdef CONFIG_IPV6_SUBTREES
77 #define FWS_INIT FWS_S
78 #define SUBTREE(fn) ((fn)->subtree)
80 #define FWS_INIT FWS_L
81 #define SUBTREE(fn) NULL
84 static void fib6_prune_clones(struct fib6_node
*fn
, struct rt6_info
*rt
);
85 static struct fib6_node
* fib6_repair_tree(struct fib6_node
*fn
);
88 * A routing update causes an increase of the serial number on the
89 * afected subtree. This allows for cached routes to be asynchronously
90 * tested when modifications are made to the destination cache as a
91 * result of redirects, path MTU changes, etc.
94 static __u32 rt_sernum
= 0;
96 static struct timer_list ip6_fib_timer
= TIMER_INITIALIZER(fib6_run_gc
, 0, 0);
98 static struct fib6_walker_t fib6_walker_list
= {
99 &fib6_walker_list
, &fib6_walker_list
,
102 #define FOR_WALKERS(w) for ((w)=fib6_walker_list.next; (w) != &fib6_walker_list; (w)=(w)->next)
104 static __inline__ u32
fib6_new_sernum(void)
113 * Auxiliary address test functions for the radix tree.
115 * These assume a 32bit processor (although it will work on
120 * compare "prefix length" bits of an address
123 static __inline__
int addr_match(void *token1
, void *token2
, int prefixlen
)
130 pdw
= prefixlen
>> 5; /* num of whole __u32 in prefix */
131 pbi
= prefixlen
& 0x1f; /* num of bits in incomplete u32 in prefix */
134 if (memcmp(a1
, a2
, pdw
<< 2))
140 mask
= htonl((0xffffffff) << (32 - pbi
));
142 if ((a1
[pdw
] ^ a2
[pdw
]) & mask
)
153 static __inline__
int addr_bit_set(void *token
, int fn_bit
)
157 return htonl(1 << ((~fn_bit
)&0x1F)) & addr
[fn_bit
>>5];
161 * find the first different bit between two addresses
162 * length of address must be a multiple of 32bits
165 static __inline__
int addr_diff(void *token1
, void *token2
, int addrlen
)
173 for (i
= 0; i
< addrlen
; i
++) {
183 while ((xb
& (1 << j
)) == 0)
186 return (i
* 32 + 31 - j
);
191 * we should *never* get to this point since that
192 * would mean the addrs are equal
194 * However, we do get to it 8) And exacly, when
195 * addresses are equal 8)
197 * ip route add 1111::/128 via ...
198 * ip route add 1111::/64 via ...
201 * Ideally, this function should stop comparison
202 * at prefix length. It does not, but it is still OK,
203 * if returned value is greater than prefix length.
210 static __inline__
struct fib6_node
* node_alloc(void)
212 struct fib6_node
*fn
;
214 if ((fn
= kmem_cache_alloc(fib6_node_kmem
, SLAB_ATOMIC
)) != NULL
)
215 memset(fn
, 0, sizeof(struct fib6_node
));
220 static __inline__
void node_free(struct fib6_node
* fn
)
222 kmem_cache_free(fib6_node_kmem
, fn
);
225 static __inline__
void rt6_release(struct rt6_info
*rt
)
227 if (atomic_dec_and_test(&rt
->rt6i_ref
))
228 dst_free(&rt
->u
.dst
);
235 * return the apropriate node for a routing tree "add" operation
236 * by either creating and inserting or by returning an existing
240 static struct fib6_node
* fib6_add_1(struct fib6_node
*root
, void *addr
,
241 int addrlen
, int plen
,
244 struct fib6_node
*fn
, *in
, *ln
;
245 struct fib6_node
*pn
= NULL
;
249 __u32 sernum
= fib6_new_sernum();
251 RT6_TRACE("fib6_add_1\n");
253 /* insert node in tree */
258 key
= (struct rt6key
*)((u8
*)fn
->leaf
+ offset
);
263 if (plen
< fn
->fn_bit
||
264 !addr_match(&key
->addr
, addr
, fn
->fn_bit
))
271 if (plen
== fn
->fn_bit
) {
272 /* clean up an intermediate node */
273 if ((fn
->fn_flags
& RTN_RTINFO
) == 0) {
274 rt6_release(fn
->leaf
);
278 fn
->fn_sernum
= sernum
;
284 * We have more bits to go
287 /* Try to walk down on tree. */
288 fn
->fn_sernum
= sernum
;
289 dir
= addr_bit_set(addr
, fn
->fn_bit
);
291 fn
= dir
? fn
->right
: fn
->left
;
295 * We walked to the bottom of tree.
296 * Create new leaf node without children.
306 ln
->fn_sernum
= sernum
;
318 * split since we don't have a common prefix anymore or
319 * we have a less significant route.
320 * we've to insert an intermediate node on the list
321 * this new node will point to the one we need to create
327 /* find 1st bit in difference between the 2 addrs.
329 See comment in addr_diff: bit may be an invalid value,
330 but if it is >= plen, the value is ignored in any case.
333 bit
= addr_diff(addr
, &key
->addr
, addrlen
);
338 * (new leaf node)[ln] (old node)[fn]
344 if (in
== NULL
|| ln
== NULL
) {
353 * new intermediate node.
355 * be off since that an address that chooses one of
356 * the branches would not match less specific routes
357 * in the other branch
364 atomic_inc(&in
->leaf
->rt6i_ref
);
366 in
->fn_sernum
= sernum
;
368 /* update parent pointer */
379 ln
->fn_sernum
= sernum
;
381 if (addr_bit_set(addr
, bit
)) {
388 } else { /* plen <= bit */
391 * (new leaf node)[ln]
393 * (old node)[fn] NULL
405 ln
->fn_sernum
= sernum
;
412 if (addr_bit_set(&key
->addr
, plen
))
423 * Insert routing information in a node.
426 static int fib6_add_rt2node(struct fib6_node
*fn
, struct rt6_info
*rt
)
428 struct rt6_info
*iter
= NULL
;
429 struct rt6_info
**ins
;
433 if (fn
->fn_flags
&RTN_TL_ROOT
&&
434 fn
->leaf
== &ip6_null_entry
&&
435 !(rt
->rt6i_flags
& (RTF_DEFAULT
| RTF_ADDRCONF
| RTF_ALLONLINK
)) ){
437 * The top fib of ip6 routing table includes ip6_null_entry.
444 for (iter
= fn
->leaf
; iter
; iter
=iter
->u
.next
) {
446 * Search for duplicates
449 if (iter
->rt6i_metric
== rt
->rt6i_metric
) {
451 * Same priority level
454 if ((iter
->rt6i_dev
== rt
->rt6i_dev
) &&
455 (ipv6_addr_cmp(&iter
->rt6i_gateway
,
456 &rt
->rt6i_gateway
) == 0)) {
457 if (!(iter
->rt6i_flags
&RTF_EXPIRES
))
459 iter
->rt6i_expires
= rt
->rt6i_expires
;
460 if (!(rt
->rt6i_flags
&RTF_EXPIRES
)) {
461 iter
->rt6i_flags
&= ~RTF_EXPIRES
;
462 iter
->rt6i_expires
= 0;
468 if (iter
->rt6i_metric
> rt
->rt6i_metric
)
482 atomic_inc(&rt
->rt6i_ref
);
483 inet6_rt_notify(RTM_NEWROUTE
, rt
);
484 rt6_stats
.fib_rt_entries
++;
486 if ((fn
->fn_flags
& RTN_RTINFO
) == 0) {
487 rt6_stats
.fib_route_nodes
++;
488 fn
->fn_flags
|= RTN_RTINFO
;
494 static __inline__
void fib6_start_gc(struct rt6_info
*rt
)
496 if (ip6_fib_timer
.expires
== 0 &&
497 (rt
->rt6i_flags
& (RTF_EXPIRES
|RTF_CACHE
)))
498 mod_timer(&ip6_fib_timer
, jiffies
+ ip6_rt_gc_interval
);
502 * Add routing information to the routing tree.
503 * <destination addr>/<source addr>
504 * with source addr info in sub-trees
507 int fib6_add(struct fib6_node
*root
, struct rt6_info
*rt
)
509 struct fib6_node
*fn
;
512 fn
= fib6_add_1(root
, &rt
->rt6i_dst
.addr
, sizeof(struct in6_addr
),
513 rt
->rt6i_dst
.plen
, (u8
*) &rt
->rt6i_dst
- (u8
*) rt
);
518 #ifdef CONFIG_IPV6_SUBTREES
519 if (rt
->rt6i_src
.plen
) {
520 struct fib6_node
*sn
;
522 if (fn
->subtree
== NULL
) {
523 struct fib6_node
*sfn
;
535 /* Create subtree root node */
540 sfn
->leaf
= &ip6_null_entry
;
541 atomic_inc(&ip6_null_entry
.rt6i_ref
);
542 sfn
->fn_flags
= RTN_ROOT
;
543 sfn
->fn_sernum
= fib6_new_sernum();
545 /* Now add the first leaf node to new subtree */
547 sn
= fib6_add_1(sfn
, &rt
->rt6i_src
.addr
,
548 sizeof(struct in6_addr
), rt
->rt6i_src
.plen
,
549 (u8
*) &rt
->rt6i_src
- (u8
*) rt
);
552 /* If it is failed, discard just allocated
553 root, and then (in st_failure) stale node
560 /* Now link new subtree to main tree */
563 if (fn
->leaf
== NULL
) {
565 atomic_inc(&rt
->rt6i_ref
);
568 sn
= fib6_add_1(fn
->subtree
, &rt
->rt6i_src
.addr
,
569 sizeof(struct in6_addr
), rt
->rt6i_src
.plen
,
570 (u8
*) &rt
->rt6i_src
- (u8
*) rt
);
580 err
= fib6_add_rt2node(fn
, rt
);
584 if (!(rt
->rt6i_flags
&RTF_CACHE
))
585 fib6_prune_clones(fn
, rt
);
590 dst_free(&rt
->u
.dst
);
593 #ifdef CONFIG_IPV6_SUBTREES
594 /* Subtree creation failed, probably main tree node
595 is orphan. If it is, shot it.
598 if (fn
&& !(fn
->fn_flags
&RTN_RTINFO
|RTN_ROOT
))
600 dst_free(&rt
->u
.dst
);
606 * Routing tree lookup
611 int offset
; /* key offset on rt6_info */
612 struct in6_addr
*addr
; /* search key */
615 static struct fib6_node
* fib6_lookup_1(struct fib6_node
*root
,
616 struct lookup_args
*args
)
618 struct fib6_node
*fn
;
628 struct fib6_node
*next
;
630 dir
= addr_bit_set(args
->addr
, fn
->fn_bit
);
632 next
= dir
? fn
->right
: fn
->left
;
642 while ((fn
->fn_flags
& RTN_ROOT
) == 0) {
643 #ifdef CONFIG_IPV6_SUBTREES
645 struct fib6_node
*st
;
646 struct lookup_args
*narg
;
651 st
= fib6_lookup_1(fn
->subtree
, narg
);
653 if (st
&& !(st
->fn_flags
& RTN_ROOT
))
659 if (fn
->fn_flags
& RTN_RTINFO
) {
662 key
= (struct rt6key
*) ((u8
*) fn
->leaf
+
665 if (addr_match(&key
->addr
, args
->addr
, key
->plen
))
675 struct fib6_node
* fib6_lookup(struct fib6_node
*root
, struct in6_addr
*daddr
,
676 struct in6_addr
*saddr
)
678 struct lookup_args args
[2];
679 struct rt6_info
*rt
= NULL
;
680 struct fib6_node
*fn
;
682 args
[0].offset
= (u8
*) &rt
->rt6i_dst
- (u8
*) rt
;
683 args
[0].addr
= daddr
;
685 #ifdef CONFIG_IPV6_SUBTREES
686 args
[1].offset
= (u8
*) &rt
->rt6i_src
- (u8
*) rt
;
687 args
[1].addr
= saddr
;
690 fn
= fib6_lookup_1(root
, args
);
692 if (fn
== NULL
|| fn
->fn_flags
& RTN_TL_ROOT
)
699 * Get node with sepciafied destination prefix (and source prefix,
700 * if subtrees are used)
704 static struct fib6_node
* fib6_locate_1(struct fib6_node
*root
,
705 struct in6_addr
*addr
,
706 int plen
, int offset
)
708 struct fib6_node
*fn
;
710 for (fn
= root
; fn
; ) {
711 struct rt6key
*key
= (struct rt6key
*)((u8
*)fn
->leaf
+ offset
);
716 if (plen
< fn
->fn_bit
||
717 !addr_match(&key
->addr
, addr
, fn
->fn_bit
))
720 if (plen
== fn
->fn_bit
)
724 * We have more bits to go
726 if (addr_bit_set(addr
, fn
->fn_bit
))
734 struct fib6_node
* fib6_locate(struct fib6_node
*root
,
735 struct in6_addr
*daddr
, int dst_len
,
736 struct in6_addr
*saddr
, int src_len
)
738 struct rt6_info
*rt
= NULL
;
739 struct fib6_node
*fn
;
741 fn
= fib6_locate_1(root
, daddr
, dst_len
,
742 (u8
*) &rt
->rt6i_dst
- (u8
*) rt
);
744 #ifdef CONFIG_IPV6_SUBTREES
746 BUG_TRAP(saddr
!=NULL
);
750 fn
= fib6_locate_1(fn
, saddr
, src_len
,
751 (u8
*) &rt
->rt6i_src
- (u8
*) rt
);
755 if (fn
&& fn
->fn_flags
&RTN_RTINFO
)
767 static struct rt6_info
* fib6_find_prefix(struct fib6_node
*fn
)
769 if (fn
->fn_flags
&RTN_ROOT
)
770 return &ip6_null_entry
;
774 return fn
->left
->leaf
;
777 return fn
->right
->leaf
;
785 * Called to trim the tree of intermediate nodes when possible. "fn"
786 * is the node we want to try and remove.
789 static struct fib6_node
* fib6_repair_tree(struct fib6_node
*fn
)
793 struct fib6_node
*child
, *pn
;
794 struct fib6_walker_t
*w
;
798 RT6_TRACE("fixing tree: plen=%d iter=%d\n", fn
->fn_bit
, iter
);
801 BUG_TRAP(!(fn
->fn_flags
&RTN_RTINFO
));
802 BUG_TRAP(!(fn
->fn_flags
&RTN_TL_ROOT
));
803 BUG_TRAP(fn
->leaf
==NULL
);
807 if (fn
->right
) child
= fn
->right
, children
|= 1;
808 if (fn
->left
) child
= fn
->left
, children
|= 2;
810 if (children
== 3 || SUBTREE(fn
)
811 #ifdef CONFIG_IPV6_SUBTREES
812 /* Subtree root (i.e. fn) may have one child */
813 || (children
&& fn
->fn_flags
&RTN_ROOT
)
816 fn
->leaf
= fib6_find_prefix(fn
);
818 if (fn
->leaf
==NULL
) {
820 fn
->leaf
= &ip6_null_entry
;
823 atomic_inc(&fn
->leaf
->rt6i_ref
);
828 #ifdef CONFIG_IPV6_SUBTREES
829 if (SUBTREE(pn
) == fn
) {
830 BUG_TRAP(fn
->fn_flags
&RTN_ROOT
);
834 BUG_TRAP(!(fn
->fn_flags
&RTN_ROOT
));
836 if (pn
->right
== fn
) pn
->right
= child
;
837 else if (pn
->left
== fn
) pn
->left
= child
;
844 #ifdef CONFIG_IPV6_SUBTREES
848 read_lock(&fib6_walker_lock
);
852 w
->root
= w
->node
= NULL
;
853 RT6_TRACE("W %p adjusted by delroot 1\n", w
);
854 } else if (w
->node
== fn
) {
855 RT6_TRACE("W %p adjusted by delnode 1, s=%d/%d\n", w
, w
->state
, nstate
);
862 RT6_TRACE("W %p adjusted by delroot 2\n", w
);
867 RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w
, w
->state
);
868 w
->state
= w
->state
>=FWS_R
? FWS_U
: FWS_INIT
;
870 RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w
, w
->state
);
871 w
->state
= w
->state
>=FWS_C
? FWS_U
: FWS_INIT
;
876 read_unlock(&fib6_walker_lock
);
879 if (pn
->fn_flags
&RTN_RTINFO
|| SUBTREE(pn
))
882 rt6_release(pn
->leaf
);
888 static void fib6_del_route(struct fib6_node
*fn
, struct rt6_info
**rtp
)
890 struct fib6_walker_t
*w
;
891 struct rt6_info
*rt
= *rtp
;
893 RT6_TRACE("fib6_del_route\n");
897 rt
->rt6i_node
= NULL
;
898 rt6_stats
.fib_rt_entries
--;
901 read_lock(&fib6_walker_lock
);
903 if (w
->state
== FWS_C
&& w
->leaf
== rt
) {
904 RT6_TRACE("walker %p adjusted by delroute\n", w
);
905 w
->leaf
= rt
->u
.next
;
910 read_unlock(&fib6_walker_lock
);
914 if (fn
->leaf
== NULL
&& fn
->fn_flags
&RTN_TL_ROOT
)
915 fn
->leaf
= &ip6_null_entry
;
917 /* If it was last route, expunge its radix tree node */
918 if (fn
->leaf
== NULL
) {
919 fn
->fn_flags
&= ~RTN_RTINFO
;
920 rt6_stats
.fib_route_nodes
--;
921 fn
= fib6_repair_tree(fn
);
924 if (atomic_read(&rt
->rt6i_ref
) != 1) {
925 /* This route is used as dummy address holder in some split
926 * nodes. It is not leaked, but it still holds other resources,
927 * which must be released in time. So, scan ascendant nodes
928 * and replace dummy references to this route with references
929 * to still alive ones.
932 if (!(fn
->fn_flags
&RTN_RTINFO
) && fn
->leaf
== rt
) {
933 fn
->leaf
= fib6_find_prefix(fn
);
934 atomic_inc(&fn
->leaf
->rt6i_ref
);
939 /* No more references are possiible at this point. */
940 if (atomic_read(&rt
->rt6i_ref
) != 1) BUG();
943 inet6_rt_notify(RTM_DELROUTE
, rt
);
947 int fib6_del(struct rt6_info
*rt
)
949 struct fib6_node
*fn
= rt
->rt6i_node
;
950 struct rt6_info
**rtp
;
953 if (rt
->u
.dst
.obsolete
>0) {
954 BUG_TRAP(fn
==NULL
|| rt
->u
.dst
.obsolete
<=0);
958 if (fn
== NULL
|| rt
== &ip6_null_entry
)
961 BUG_TRAP(fn
->fn_flags
&RTN_RTINFO
);
963 if (!(rt
->rt6i_flags
&RTF_CACHE
))
964 fib6_prune_clones(fn
, rt
);
967 * Walk the leaf entries looking for ourself
970 for (rtp
= &fn
->leaf
; *rtp
; rtp
= &(*rtp
)->u
.next
) {
972 fib6_del_route(fn
, rtp
);
980 * Tree transversal function.
982 * Certainly, it is not interrupt safe.
983 * However, it is internally reenterable wrt itself and fib6_add/fib6_del.
984 * It means, that we can modify tree during walking
985 * and use this function for garbage collection, clone pruning,
986 * cleaning tree when a device goes down etc. etc.
988 * It guarantees that every node will be traversed,
989 * and that it will be traversed only once.
991 * Callback function w->func may return:
992 * 0 -> continue walking.
993 * positive value -> walking is suspended (used by tree dumps,
994 * and probably by gc, if it will be split to several slices)
995 * negative value -> terminate walking.
997 * The function itself returns:
998 * 0 -> walk is complete.
999 * >0 -> walk is incomplete (i.e. suspended)
1000 * <0 -> walk is terminated by an error.
1003 int fib6_walk_continue(struct fib6_walker_t
*w
)
1005 struct fib6_node
*fn
, *pn
;
1012 if (w
->prune
&& fn
!= w
->root
&&
1013 fn
->fn_flags
&RTN_RTINFO
&& w
->state
< FWS_C
) {
1018 #ifdef CONFIG_IPV6_SUBTREES
1021 w
->node
= SUBTREE(fn
);
1029 w
->state
= FWS_INIT
;
1035 w
->node
= fn
->right
;
1036 w
->state
= FWS_INIT
;
1042 if (w
->leaf
&& fn
->fn_flags
&RTN_RTINFO
) {
1043 int err
= w
->func(w
);
1054 #ifdef CONFIG_IPV6_SUBTREES
1055 if (SUBTREE(pn
) == fn
) {
1056 BUG_TRAP(fn
->fn_flags
&RTN_ROOT
);
1061 if (pn
->left
== fn
) {
1065 if (pn
->right
== fn
) {
1067 w
->leaf
= w
->node
->leaf
;
1077 int fib6_walk(struct fib6_walker_t
*w
)
1081 w
->state
= FWS_INIT
;
1084 fib6_walker_link(w
);
1085 res
= fib6_walk_continue(w
);
1087 fib6_walker_unlink(w
);
1091 static int fib6_clean_node(struct fib6_walker_t
*w
)
1094 struct rt6_info
*rt
;
1095 struct fib6_cleaner_t
*c
= (struct fib6_cleaner_t
*)w
;
1097 for (rt
= w
->leaf
; rt
; rt
= rt
->u
.next
) {
1098 res
= c
->func(rt
, c
->arg
);
1104 printk(KERN_DEBUG
"fib6_clean_node: del failed: rt=%p@%p err=%d\n", rt
, rt
->rt6i_node
, res
);
1117 * Convenient frontend to tree walker.
1119 * func is called on each route.
1120 * It may return -1 -> delete this route.
1121 * 0 -> continue walking
1123 * prune==1 -> only immediate children of node (certainly,
1124 * ignoring pure split nodes) will be scanned.
1127 void fib6_clean_tree(struct fib6_node
*root
,
1128 int (*func
)(struct rt6_info
*, void *arg
),
1129 int prune
, void *arg
)
1131 struct fib6_cleaner_t c
;
1134 c
.w
.func
= fib6_clean_node
;
1142 static int fib6_prune_clone(struct rt6_info
*rt
, void *arg
)
1144 if (rt
->rt6i_flags
& RTF_CACHE
) {
1145 RT6_TRACE("pruning clone %p\n", rt
);
1152 static void fib6_prune_clones(struct fib6_node
*fn
, struct rt6_info
*rt
)
1154 fib6_clean_tree(fn
, fib6_prune_clone
, 1, rt
);
1158 * Garbage collection
1161 static struct fib6_gc_args
1167 static int fib6_age(struct rt6_info
*rt
, void *arg
)
1169 unsigned long now
= jiffies
;
1172 * check addrconf expiration here.
1173 * Routes are expired even if they are in use.
1175 * Also age clones. Note, that clones are aged out
1176 * only if they are not in use now.
1179 if (rt
->rt6i_flags
&RTF_EXPIRES
&& rt
->rt6i_expires
) {
1180 if ((long)(now
- rt
->rt6i_expires
) > 0) {
1181 RT6_TRACE("expiring %p\n", rt
);
1185 } else if (rt
->rt6i_flags
& RTF_CACHE
) {
1186 if (atomic_read(&rt
->u
.dst
.__refcnt
) == 0 &&
1187 (long)(now
- rt
->u
.dst
.lastuse
) >= gc_args
.timeout
) {
1188 RT6_TRACE("aging clone %p\n", rt
);
1197 static spinlock_t fib6_gc_lock
= SPIN_LOCK_UNLOCKED
;
1199 void fib6_run_gc(unsigned long dummy
)
1201 if (dummy
!= ~0UL) {
1202 spin_lock_bh(&fib6_gc_lock
);
1203 gc_args
.timeout
= (int)dummy
;
1206 if (!spin_trylock(&fib6_gc_lock
)) {
1207 mod_timer(&ip6_fib_timer
, jiffies
+ HZ
);
1211 gc_args
.timeout
= ip6_rt_gc_interval
;
1216 write_lock_bh(&rt6_lock
);
1217 fib6_clean_tree(&ip6_routing_table
, fib6_age
, 0, NULL
);
1218 write_unlock_bh(&rt6_lock
);
1221 mod_timer(&ip6_fib_timer
, jiffies
+ ip6_rt_gc_interval
);
1223 del_timer(&ip6_fib_timer
);
1224 ip6_fib_timer
.expires
= 0;
1226 spin_unlock_bh(&fib6_gc_lock
);
1229 void __init
fib6_init(void)
1231 if (!fib6_node_kmem
)
1232 fib6_node_kmem
= kmem_cache_create("fib6_nodes",
1233 sizeof(struct fib6_node
),
1234 0, SLAB_HWCACHE_ALIGN
,
1239 void fib6_gc_cleanup(void)
1241 del_timer(&ip6_fib_timer
);