2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
6 * IPv4 FIB: lookup engine and maintenance routines.
8 * Version: $Id: fib_hash.c,v 1.13 2001/10/31 21:55:54 davem Exp $
10 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
18 #include <asm/uaccess.h>
19 #include <asm/system.h>
20 #include <linux/bitops.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
24 #include <linux/string.h>
25 #include <linux/socket.h>
26 #include <linux/sockios.h>
27 #include <linux/errno.h>
29 #include <linux/inet.h>
30 #include <linux/inetdevice.h>
31 #include <linux/netdevice.h>
32 #include <linux/if_arp.h>
33 #include <linux/proc_fs.h>
34 #include <linux/skbuff.h>
35 #include <linux/netlink.h>
36 #include <linux/init.h>
39 #include <net/protocol.h>
40 #include <net/route.h>
43 #include <net/ip_fib.h>
45 #include "fib_lookup.h"
47 static struct kmem_cache
*fn_hash_kmem __read_mostly
;
48 static struct kmem_cache
*fn_alias_kmem __read_mostly
;
51 struct hlist_node fn_hash
;
52 struct list_head fn_alias
;
54 struct fib_alias fn_embedded_alias
;
57 #define EMBEDDED_HASH_SIZE (L1_CACHE_BYTES / sizeof(struct hlist_head))
60 struct fn_zone
*fz_next
; /* Next not empty zone */
61 struct hlist_head
*fz_hash
; /* Hash table pointer */
62 u32 fz_hashmask
; /* (fz_divisor - 1) */
64 u8 fz_order
; /* Zone order (0..32) */
65 u8 fz_revorder
; /* 32 - fz_order */
66 __be32 fz_mask
; /* inet_make_mask(order) */
67 #define FZ_MASK(fz) ((fz)->fz_mask)
69 struct hlist_head fz_embedded_hash
[EMBEDDED_HASH_SIZE
];
71 int fz_nent
; /* Number of entries */
72 int fz_divisor
; /* Hash size (mask+1) */
76 struct fn_zone
*fn_zones
[33];
77 struct fn_zone
*fn_zone_list
;
80 static inline u32
fn_hash(__be32 key
, struct fn_zone
*fz
)
82 u32 h
= ntohl(key
) >> fz
->fz_revorder
;
90 static inline __be32
fz_key(__be32 dst
, struct fn_zone
*fz
)
92 return dst
& FZ_MASK(fz
);
95 static DEFINE_RWLOCK(fib_hash_lock
);
96 static unsigned int fib_hash_genid
;
98 #define FZ_MAX_DIVISOR ((PAGE_SIZE<<MAX_ORDER) / sizeof(struct hlist_head))
100 static struct hlist_head
*fz_hash_alloc(int divisor
)
102 unsigned long size
= divisor
* sizeof(struct hlist_head
);
104 if (size
<= PAGE_SIZE
) {
105 return kzalloc(size
, GFP_KERNEL
);
107 return (struct hlist_head
*)
108 __get_free_pages(GFP_KERNEL
| __GFP_ZERO
, get_order(size
));
112 /* The fib hash lock must be held when this is called. */
113 static inline void fn_rebuild_zone(struct fn_zone
*fz
,
114 struct hlist_head
*old_ht
,
119 for (i
= 0; i
< old_divisor
; i
++) {
120 struct hlist_node
*node
, *n
;
123 hlist_for_each_entry_safe(f
, node
, n
, &old_ht
[i
], fn_hash
) {
124 struct hlist_head
*new_head
;
126 hlist_del(&f
->fn_hash
);
128 new_head
= &fz
->fz_hash
[fn_hash(f
->fn_key
, fz
)];
129 hlist_add_head(&f
->fn_hash
, new_head
);
134 static void fz_hash_free(struct hlist_head
*hash
, int divisor
)
136 unsigned long size
= divisor
* sizeof(struct hlist_head
);
138 if (size
<= PAGE_SIZE
)
141 free_pages((unsigned long)hash
, get_order(size
));
144 static void fn_rehash_zone(struct fn_zone
*fz
)
146 struct hlist_head
*ht
, *old_ht
;
147 int old_divisor
, new_divisor
;
150 new_divisor
= old_divisor
= fz
->fz_divisor
;
152 switch (old_divisor
) {
153 case EMBEDDED_HASH_SIZE
:
154 new_divisor
*= EMBEDDED_HASH_SIZE
;
156 case EMBEDDED_HASH_SIZE
*EMBEDDED_HASH_SIZE
:
157 new_divisor
*= (EMBEDDED_HASH_SIZE
/2);
160 if ((old_divisor
<< 1) > FZ_MAX_DIVISOR
) {
161 printk(KERN_CRIT
"route.c: bad divisor %d!\n", old_divisor
);
164 new_divisor
= (old_divisor
<< 1);
168 new_hashmask
= (new_divisor
- 1);
170 #if RT_CACHE_DEBUG >= 2
171 printk("fn_rehash_zone: hash for zone %d grows from %d\n", fz
->fz_order
, old_divisor
);
174 ht
= fz_hash_alloc(new_divisor
);
177 write_lock_bh(&fib_hash_lock
);
178 old_ht
= fz
->fz_hash
;
180 fz
->fz_hashmask
= new_hashmask
;
181 fz
->fz_divisor
= new_divisor
;
182 fn_rebuild_zone(fz
, old_ht
, old_divisor
);
184 write_unlock_bh(&fib_hash_lock
);
186 if (old_ht
!= fz
->fz_embedded_hash
)
187 fz_hash_free(old_ht
, old_divisor
);
191 static inline void fn_free_node(struct fib_node
* f
)
193 kmem_cache_free(fn_hash_kmem
, f
);
196 static inline void fn_free_alias(struct fib_alias
*fa
, struct fib_node
*f
)
198 fib_release_info(fa
->fa_info
);
199 if (fa
== &f
->fn_embedded_alias
)
202 kmem_cache_free(fn_alias_kmem
, fa
);
205 static struct fn_zone
*
206 fn_new_zone(struct fn_hash
*table
, int z
)
209 struct fn_zone
*fz
= kzalloc(sizeof(struct fn_zone
), GFP_KERNEL
);
213 fz
->fz_divisor
= z
? EMBEDDED_HASH_SIZE
: 1;
214 fz
->fz_hashmask
= fz
->fz_divisor
- 1;
215 fz
->fz_hash
= fz
->fz_embedded_hash
;
217 fz
->fz_revorder
= 32 - z
;
218 fz
->fz_mask
= inet_make_mask(z
);
220 /* Find the first not empty zone with more specific mask */
221 for (i
=z
+1; i
<=32; i
++)
222 if (table
->fn_zones
[i
])
224 write_lock_bh(&fib_hash_lock
);
226 /* No more specific masks, we are the first. */
227 fz
->fz_next
= table
->fn_zone_list
;
228 table
->fn_zone_list
= fz
;
230 fz
->fz_next
= table
->fn_zones
[i
]->fz_next
;
231 table
->fn_zones
[i
]->fz_next
= fz
;
233 table
->fn_zones
[z
] = fz
;
235 write_unlock_bh(&fib_hash_lock
);
240 fn_hash_lookup(struct fib_table
*tb
, const struct flowi
*flp
, struct fib_result
*res
)
244 struct fn_hash
*t
= (struct fn_hash
*)tb
->tb_data
;
246 read_lock(&fib_hash_lock
);
247 for (fz
= t
->fn_zone_list
; fz
; fz
= fz
->fz_next
) {
248 struct hlist_head
*head
;
249 struct hlist_node
*node
;
251 __be32 k
= fz_key(flp
->fl4_dst
, fz
);
253 head
= &fz
->fz_hash
[fn_hash(k
, fz
)];
254 hlist_for_each_entry(f
, node
, head
, fn_hash
) {
258 err
= fib_semantic_match(&f
->fn_alias
,
260 f
->fn_key
, fz
->fz_mask
,
268 read_unlock(&fib_hash_lock
);
273 fn_hash_select_default(struct fib_table
*tb
, const struct flowi
*flp
, struct fib_result
*res
)
276 struct hlist_node
*node
;
278 struct fib_info
*fi
= NULL
;
279 struct fib_info
*last_resort
;
280 struct fn_hash
*t
= (struct fn_hash
*)tb
->tb_data
;
281 struct fn_zone
*fz
= t
->fn_zones
[0];
290 read_lock(&fib_hash_lock
);
291 hlist_for_each_entry(f
, node
, &fz
->fz_hash
[0], fn_hash
) {
292 struct fib_alias
*fa
;
294 list_for_each_entry(fa
, &f
->fn_alias
, fa_list
) {
295 struct fib_info
*next_fi
= fa
->fa_info
;
297 if (fa
->fa_scope
!= res
->scope
||
298 fa
->fa_type
!= RTN_UNICAST
)
301 if (next_fi
->fib_priority
> res
->fi
->fib_priority
)
303 if (!next_fi
->fib_nh
[0].nh_gw
||
304 next_fi
->fib_nh
[0].nh_scope
!= RT_SCOPE_LINK
)
306 fa
->fa_state
|= FA_S_ACCESSED
;
309 if (next_fi
!= res
->fi
)
311 } else if (!fib_detect_death(fi
, order
, &last_resort
,
312 &last_idx
, &tb
->tb_default
)) {
313 fib_result_assign(res
, fi
);
314 tb
->tb_default
= order
;
322 if (order
<= 0 || fi
== NULL
) {
327 if (!fib_detect_death(fi
, order
, &last_resort
, &last_idx
, &tb
->tb_default
)) {
328 fib_result_assign(res
, fi
);
329 tb
->tb_default
= order
;
334 fib_result_assign(res
, last_resort
);
335 tb
->tb_default
= last_idx
;
337 read_unlock(&fib_hash_lock
);
340 /* Insert node F to FZ. */
341 static inline void fib_insert_node(struct fn_zone
*fz
, struct fib_node
*f
)
343 struct hlist_head
*head
= &fz
->fz_hash
[fn_hash(f
->fn_key
, fz
)];
345 hlist_add_head(&f
->fn_hash
, head
);
348 /* Return the node in FZ matching KEY. */
349 static struct fib_node
*fib_find_node(struct fn_zone
*fz
, __be32 key
)
351 struct hlist_head
*head
= &fz
->fz_hash
[fn_hash(key
, fz
)];
352 struct hlist_node
*node
;
355 hlist_for_each_entry(f
, node
, head
, fn_hash
) {
356 if (f
->fn_key
== key
)
363 static int fn_hash_insert(struct fib_table
*tb
, struct fib_config
*cfg
)
365 struct fn_hash
*table
= (struct fn_hash
*) tb
->tb_data
;
366 struct fib_node
*new_f
= NULL
;
368 struct fib_alias
*fa
, *new_fa
;
371 u8 tos
= cfg
->fc_tos
;
375 if (cfg
->fc_dst_len
> 32)
378 fz
= table
->fn_zones
[cfg
->fc_dst_len
];
379 if (!fz
&& !(fz
= fn_new_zone(table
, cfg
->fc_dst_len
)))
384 if (cfg
->fc_dst
& ~FZ_MASK(fz
))
386 key
= fz_key(cfg
->fc_dst
, fz
);
389 fi
= fib_create_info(cfg
);
393 if (fz
->fz_nent
> (fz
->fz_divisor
<<1) &&
394 fz
->fz_divisor
< FZ_MAX_DIVISOR
&&
395 (cfg
->fc_dst_len
== 32 ||
396 (1 << cfg
->fc_dst_len
) > fz
->fz_divisor
))
399 f
= fib_find_node(fz
, key
);
404 fa
= fib_find_alias(&f
->fn_alias
, tos
, fi
->fib_priority
);
406 /* Now fa, if non-NULL, points to the first fib alias
407 * with the same keys [prefix,tos,priority], if such key already
408 * exists or to the node before which we will insert new one.
410 * If fa is NULL, we will need to allocate a new one and
411 * insert to the head of f.
413 * If f is NULL, no fib node matched the destination key
414 * and we need to allocate a new one of those as well.
417 if (fa
&& fa
->fa_tos
== tos
&&
418 fa
->fa_info
->fib_priority
== fi
->fib_priority
) {
419 struct fib_alias
*fa_first
, *fa_match
;
422 if (cfg
->fc_nlflags
& NLM_F_EXCL
)
426 * 1. Find exact match for type, scope, fib_info to avoid
428 * 2. Find next 'fa' (or head), NLM_F_APPEND inserts before it
432 fa
= list_entry(fa
->fa_list
.prev
, struct fib_alias
, fa_list
);
433 list_for_each_entry_continue(fa
, &f
->fn_alias
, fa_list
) {
434 if (fa
->fa_tos
!= tos
)
436 if (fa
->fa_info
->fib_priority
!= fi
->fib_priority
)
438 if (fa
->fa_type
== cfg
->fc_type
&&
439 fa
->fa_scope
== cfg
->fc_scope
&&
446 if (cfg
->fc_nlflags
& NLM_F_REPLACE
) {
447 struct fib_info
*fi_drop
;
456 write_lock_bh(&fib_hash_lock
);
457 fi_drop
= fa
->fa_info
;
459 fa
->fa_type
= cfg
->fc_type
;
460 fa
->fa_scope
= cfg
->fc_scope
;
461 state
= fa
->fa_state
;
462 fa
->fa_state
&= ~FA_S_ACCESSED
;
464 write_unlock_bh(&fib_hash_lock
);
466 fib_release_info(fi_drop
);
467 if (state
& FA_S_ACCESSED
)
469 rtmsg_fib(RTM_NEWROUTE
, key
, fa
, cfg
->fc_dst_len
, tb
->tb_id
,
470 &cfg
->fc_nlinfo
, NLM_F_REPLACE
);
474 /* Error if we find a perfect match which
475 * uses the same scope, type, and nexthop
481 if (!(cfg
->fc_nlflags
& NLM_F_APPEND
))
486 if (!(cfg
->fc_nlflags
& NLM_F_CREATE
))
492 new_f
= kmem_cache_zalloc(fn_hash_kmem
, GFP_KERNEL
);
496 INIT_HLIST_NODE(&new_f
->fn_hash
);
497 INIT_LIST_HEAD(&new_f
->fn_alias
);
502 new_fa
= &f
->fn_embedded_alias
;
503 if (new_fa
->fa_info
!= NULL
) {
504 new_fa
= kmem_cache_alloc(fn_alias_kmem
, GFP_KERNEL
);
508 new_fa
->fa_info
= fi
;
509 new_fa
->fa_tos
= tos
;
510 new_fa
->fa_type
= cfg
->fc_type
;
511 new_fa
->fa_scope
= cfg
->fc_scope
;
512 new_fa
->fa_state
= 0;
515 * Insert new entry to the list.
518 write_lock_bh(&fib_hash_lock
);
520 fib_insert_node(fz
, new_f
);
521 list_add_tail(&new_fa
->fa_list
,
522 (fa
? &fa
->fa_list
: &f
->fn_alias
));
524 write_unlock_bh(&fib_hash_lock
);
530 rtmsg_fib(RTM_NEWROUTE
, key
, new_fa
, cfg
->fc_dst_len
, tb
->tb_id
,
536 kmem_cache_free(fn_hash_kmem
, new_f
);
537 fib_release_info(fi
);
542 static int fn_hash_delete(struct fib_table
*tb
, struct fib_config
*cfg
)
544 struct fn_hash
*table
= (struct fn_hash
*)tb
->tb_data
;
546 struct fib_alias
*fa
, *fa_to_delete
;
550 if (cfg
->fc_dst_len
> 32)
553 if ((fz
= table
->fn_zones
[cfg
->fc_dst_len
]) == NULL
)
558 if (cfg
->fc_dst
& ~FZ_MASK(fz
))
560 key
= fz_key(cfg
->fc_dst
, fz
);
563 f
= fib_find_node(fz
, key
);
568 fa
= fib_find_alias(&f
->fn_alias
, cfg
->fc_tos
, 0);
573 fa
= list_entry(fa
->fa_list
.prev
, struct fib_alias
, fa_list
);
574 list_for_each_entry_continue(fa
, &f
->fn_alias
, fa_list
) {
575 struct fib_info
*fi
= fa
->fa_info
;
577 if (fa
->fa_tos
!= cfg
->fc_tos
)
580 if ((!cfg
->fc_type
||
581 fa
->fa_type
== cfg
->fc_type
) &&
582 (cfg
->fc_scope
== RT_SCOPE_NOWHERE
||
583 fa
->fa_scope
== cfg
->fc_scope
) &&
584 (!cfg
->fc_protocol
||
585 fi
->fib_protocol
== cfg
->fc_protocol
) &&
586 fib_nh_match(cfg
, fi
) == 0) {
596 rtmsg_fib(RTM_DELROUTE
, key
, fa
, cfg
->fc_dst_len
,
597 tb
->tb_id
, &cfg
->fc_nlinfo
, 0);
600 write_lock_bh(&fib_hash_lock
);
601 list_del(&fa
->fa_list
);
602 if (list_empty(&f
->fn_alias
)) {
603 hlist_del(&f
->fn_hash
);
607 write_unlock_bh(&fib_hash_lock
);
609 if (fa
->fa_state
& FA_S_ACCESSED
)
611 fn_free_alias(fa
, f
);
622 static int fn_flush_list(struct fn_zone
*fz
, int idx
)
624 struct hlist_head
*head
= &fz
->fz_hash
[idx
];
625 struct hlist_node
*node
, *n
;
629 hlist_for_each_entry_safe(f
, node
, n
, head
, fn_hash
) {
630 struct fib_alias
*fa
, *fa_node
;
634 list_for_each_entry_safe(fa
, fa_node
, &f
->fn_alias
, fa_list
) {
635 struct fib_info
*fi
= fa
->fa_info
;
637 if (fi
&& (fi
->fib_flags
&RTNH_F_DEAD
)) {
638 write_lock_bh(&fib_hash_lock
);
639 list_del(&fa
->fa_list
);
640 if (list_empty(&f
->fn_alias
)) {
641 hlist_del(&f
->fn_hash
);
645 write_unlock_bh(&fib_hash_lock
);
647 fn_free_alias(fa
, f
);
659 static int fn_hash_flush(struct fib_table
*tb
)
661 struct fn_hash
*table
= (struct fn_hash
*) tb
->tb_data
;
665 for (fz
= table
->fn_zone_list
; fz
; fz
= fz
->fz_next
) {
668 for (i
= fz
->fz_divisor
- 1; i
>= 0; i
--)
669 found
+= fn_flush_list(fz
, i
);
676 fn_hash_dump_bucket(struct sk_buff
*skb
, struct netlink_callback
*cb
,
677 struct fib_table
*tb
,
679 struct hlist_head
*head
)
681 struct hlist_node
*node
;
687 hlist_for_each_entry(f
, node
, head
, fn_hash
) {
688 struct fib_alias
*fa
;
690 list_for_each_entry(fa
, &f
->fn_alias
, fa_list
) {
694 if (fib_dump_info(skb
, NETLINK_CB(cb
->skb
).pid
,
717 fn_hash_dump_zone(struct sk_buff
*skb
, struct netlink_callback
*cb
,
718 struct fib_table
*tb
,
724 for (h
=0; h
< fz
->fz_divisor
; h
++) {
725 if (h
< s_h
) continue;
727 memset(&cb
->args
[4], 0,
728 sizeof(cb
->args
) - 4*sizeof(cb
->args
[0]));
729 if (fz
->fz_hash
== NULL
||
730 hlist_empty(&fz
->fz_hash
[h
]))
732 if (fn_hash_dump_bucket(skb
, cb
, tb
, fz
, &fz
->fz_hash
[h
])<0) {
741 static int fn_hash_dump(struct fib_table
*tb
, struct sk_buff
*skb
, struct netlink_callback
*cb
)
745 struct fn_hash
*table
= (struct fn_hash
*)tb
->tb_data
;
748 read_lock(&fib_hash_lock
);
749 for (fz
= table
->fn_zone_list
, m
=0; fz
; fz
= fz
->fz_next
, m
++) {
750 if (m
< s_m
) continue;
752 memset(&cb
->args
[3], 0,
753 sizeof(cb
->args
) - 3*sizeof(cb
->args
[0]));
754 if (fn_hash_dump_zone(skb
, cb
, tb
, fz
) < 0) {
756 read_unlock(&fib_hash_lock
);
760 read_unlock(&fib_hash_lock
);
765 #ifdef CONFIG_IP_MULTIPLE_TABLES
766 struct fib_table
* fib_hash_init(u32 id
)
768 struct fib_table
* __init
fib_hash_init(u32 id
)
771 struct fib_table
*tb
;
773 if (fn_hash_kmem
== NULL
)
774 fn_hash_kmem
= kmem_cache_create("ip_fib_hash",
775 sizeof(struct fib_node
),
779 if (fn_alias_kmem
== NULL
)
780 fn_alias_kmem
= kmem_cache_create("ip_fib_alias",
781 sizeof(struct fib_alias
),
785 tb
= kmalloc(sizeof(struct fib_table
) + sizeof(struct fn_hash
),
792 tb
->tb_lookup
= fn_hash_lookup
;
793 tb
->tb_insert
= fn_hash_insert
;
794 tb
->tb_delete
= fn_hash_delete
;
795 tb
->tb_flush
= fn_hash_flush
;
796 tb
->tb_select_default
= fn_hash_select_default
;
797 tb
->tb_dump
= fn_hash_dump
;
798 memset(tb
->tb_data
, 0, sizeof(struct fn_hash
));
802 /* ------------------------------------------------------------------------ */
803 #ifdef CONFIG_PROC_FS
805 struct fib_iter_state
{
806 struct fn_zone
*zone
;
808 struct hlist_head
*hash_head
;
810 struct fib_alias
*fa
;
816 static struct fib_alias
*fib_get_first(struct seq_file
*seq
)
818 struct fib_iter_state
*iter
= seq
->private;
819 struct fn_hash
*table
= (struct fn_hash
*) ip_fib_main_table
->tb_data
;
822 iter
->hash_head
= NULL
;
826 iter
->genid
= fib_hash_genid
;
829 for (iter
->zone
= table
->fn_zone_list
; iter
->zone
;
830 iter
->zone
= iter
->zone
->fz_next
) {
833 if (!iter
->zone
->fz_nent
)
836 iter
->hash_head
= iter
->zone
->fz_hash
;
837 maxslot
= iter
->zone
->fz_divisor
;
839 for (iter
->bucket
= 0; iter
->bucket
< maxslot
;
840 ++iter
->bucket
, ++iter
->hash_head
) {
841 struct hlist_node
*node
;
844 hlist_for_each_entry(fn
,node
,iter
->hash_head
,fn_hash
) {
845 struct fib_alias
*fa
;
847 list_for_each_entry(fa
,&fn
->fn_alias
,fa_list
) {
859 static struct fib_alias
*fib_get_next(struct seq_file
*seq
)
861 struct fib_iter_state
*iter
= seq
->private;
863 struct fib_alias
*fa
;
865 /* Advance FA, if any. */
870 list_for_each_entry_continue(fa
, &fn
->fn_alias
, fa_list
) {
876 fa
= iter
->fa
= NULL
;
880 struct hlist_node
*node
= &fn
->fn_hash
;
881 hlist_for_each_entry_continue(fn
, node
, fn_hash
) {
884 list_for_each_entry(fa
, &fn
->fn_alias
, fa_list
) {
891 fn
= iter
->fn
= NULL
;
893 /* Advance hash chain. */
898 struct hlist_node
*node
;
901 maxslot
= iter
->zone
->fz_divisor
;
903 while (++iter
->bucket
< maxslot
) {
906 hlist_for_each_entry(fn
, node
, iter
->hash_head
, fn_hash
) {
907 list_for_each_entry(fa
, &fn
->fn_alias
, fa_list
) {
915 iter
->zone
= iter
->zone
->fz_next
;
921 iter
->hash_head
= iter
->zone
->fz_hash
;
923 hlist_for_each_entry(fn
, node
, iter
->hash_head
, fn_hash
) {
924 list_for_each_entry(fa
, &fn
->fn_alias
, fa_list
) {
936 static struct fib_alias
*fib_get_idx(struct seq_file
*seq
, loff_t pos
)
938 struct fib_iter_state
*iter
= seq
->private;
939 struct fib_alias
*fa
;
941 if (iter
->valid
&& pos
>= iter
->pos
&& iter
->genid
== fib_hash_genid
) {
945 fa
= fib_get_first(seq
);
948 while (pos
&& (fa
= fib_get_next(seq
)))
950 return pos
? NULL
: fa
;
953 static void *fib_seq_start(struct seq_file
*seq
, loff_t
*pos
)
957 read_lock(&fib_hash_lock
);
958 if (ip_fib_main_table
)
959 v
= *pos
? fib_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
963 static void *fib_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
966 return v
== SEQ_START_TOKEN
? fib_get_first(seq
) : fib_get_next(seq
);
969 static void fib_seq_stop(struct seq_file
*seq
, void *v
)
971 read_unlock(&fib_hash_lock
);
974 static unsigned fib_flag_trans(int type
, __be32 mask
, struct fib_info
*fi
)
976 static const unsigned type2flags
[RTN_MAX
+ 1] = {
977 [7] = RTF_REJECT
, [8] = RTF_REJECT
,
979 unsigned flags
= type2flags
[type
];
981 if (fi
&& fi
->fib_nh
->nh_gw
)
982 flags
|= RTF_GATEWAY
;
983 if (mask
== htonl(0xFFFFFFFF))
990 * This outputs /proc/net/route.
992 * It always works in backward compatibility mode.
993 * The format of the file is not supposed to be changed.
995 static int fib_seq_show(struct seq_file
*seq
, void *v
)
997 struct fib_iter_state
*iter
;
1002 struct fib_alias
*fa
;
1003 struct fib_info
*fi
;
1005 if (v
== SEQ_START_TOKEN
) {
1006 seq_printf(seq
, "%-127s\n", "Iface\tDestination\tGateway "
1007 "\tFlags\tRefCnt\tUse\tMetric\tMask\t\tMTU"
1012 iter
= seq
->private;
1017 mask
= FZ_MASK(iter
->zone
);
1018 flags
= fib_flag_trans(fa
->fa_type
, mask
, fi
);
1021 "%s\t%08X\t%08X\t%04X\t%d\t%u\t%d\t%08X\t%d\t%u\t%u%n",
1022 fi
->fib_dev
? fi
->fib_dev
->name
: "*", prefix
,
1023 fi
->fib_nh
->nh_gw
, flags
, 0, 0, fi
->fib_priority
,
1024 mask
, (fi
->fib_advmss
? fi
->fib_advmss
+ 40 : 0),
1026 fi
->fib_rtt
>> 3, &len
);
1029 "*\t%08X\t%08X\t%04X\t%d\t%u\t%d\t%08X\t%d\t%u\t%u%n",
1030 prefix
, 0, flags
, 0, 0, 0, mask
, 0, 0, 0, &len
);
1032 seq_printf(seq
, "%*s\n", 127 - len
, "");
1037 static const struct seq_operations fib_seq_ops
= {
1038 .start
= fib_seq_start
,
1039 .next
= fib_seq_next
,
1040 .stop
= fib_seq_stop
,
1041 .show
= fib_seq_show
,
1044 static int fib_seq_open(struct inode
*inode
, struct file
*file
)
1046 return seq_open_private(file
, &fib_seq_ops
,
1047 sizeof(struct fib_iter_state
));
1050 static const struct file_operations fib_seq_fops
= {
1051 .owner
= THIS_MODULE
,
1052 .open
= fib_seq_open
,
1054 .llseek
= seq_lseek
,
1055 .release
= seq_release_private
,
1058 int __init
fib_proc_init(void)
1060 if (!proc_net_fops_create("route", S_IRUGO
, &fib_seq_fops
))
1065 void __init
fib_proc_exit(void)
1067 proc_net_remove("route");
1069 #endif /* CONFIG_PROC_FS */