2 * DECnet An implementation of the DECnet protocol suite for the LINUX
3 * operating system. DECnet is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
6 * DECnet Routing Forwarding Information Base (Routing Tables)
8 * Author: Steve Whitehouse <SteveW@ACM.org>
9 * Mostly copied from the IPv4 routing code
15 #include <linux/string.h>
16 #include <linux/net.h>
17 #include <linux/socket.h>
18 #include <linux/sockios.h>
19 #include <linux/init.h>
20 #include <linux/skbuff.h>
21 #include <linux/netlink.h>
22 #include <linux/rtnetlink.h>
23 #include <linux/proc_fs.h>
24 #include <linux/netdevice.h>
25 #include <linux/timer.h>
26 #include <linux/spinlock.h>
27 #include <asm/atomic.h>
28 #include <asm/uaccess.h>
29 #include <linux/route.h> /* RTF_xxx */
30 #include <net/neighbour.h>
31 #include <net/netlink.h>
34 #include <net/fib_rules.h>
36 #include <net/dn_route.h>
37 #include <net/dn_fib.h>
38 #include <net/dn_neigh.h>
39 #include <net/dn_dev.h>
43 struct dn_zone
*dz_next
;
44 struct dn_fib_node
**dz_hash
;
48 #define DZ_HASHMASK(dz) ((dz)->dz_hashmask)
51 #define DZ_MASK(dz) ((dz)->dz_mask)
56 struct dn_zone
*dh_zones
[17];
57 struct dn_zone
*dh_zone_list
;
60 #define dz_key_0(key) ((key).datum = 0)
61 #define dz_prefix(key,dz) ((key).datum)
63 #define for_nexthops(fi) { int nhsel; const struct dn_fib_nh *nh;\
64 for(nhsel = 0, nh = (fi)->fib_nh; nhsel < (fi)->fib_nhs; nh++, nhsel++)
66 #define endfor_nexthops(fi) }
68 #define DN_MAX_DIVISOR 1024
70 #define DN_S_ACCESSED 2
72 #define DN_FIB_SCAN(f, fp) \
73 for( ; ((f) = *(fp)) != NULL; (fp) = &(f)->fn_next)
75 #define DN_FIB_SCAN_KEY(f, fp, key) \
76 for( ; ((f) = *(fp)) != NULL && dn_key_eq((f)->fn_key, (key)); (fp) = &(f)->fn_next)
78 #define RT_TABLE_MIN 1
79 #define DN_FIB_TABLE_HASHSZ 256
80 static struct hlist_head dn_fib_table_hash
[DN_FIB_TABLE_HASHSZ
];
81 static DEFINE_RWLOCK(dn_fib_tables_lock
);
83 static struct kmem_cache
*dn_hash_kmem __read_mostly
;
84 static int dn_fib_hash_zombies
;
86 static inline dn_fib_idx_t
dn_hash(dn_fib_key_t key
, struct dn_zone
*dz
)
88 u16 h
= dn_ntohs(key
.datum
)>>(16 - dz
->dz_order
);
92 return *(dn_fib_idx_t
*)&h
;
95 static inline dn_fib_key_t
dz_key(__le16 dst
, struct dn_zone
*dz
)
98 k
.datum
= dst
& DZ_MASK(dz
);
102 static inline struct dn_fib_node
**dn_chain_p(dn_fib_key_t key
, struct dn_zone
*dz
)
104 return &dz
->dz_hash
[dn_hash(key
, dz
).datum
];
107 static inline struct dn_fib_node
*dz_chain(dn_fib_key_t key
, struct dn_zone
*dz
)
109 return dz
->dz_hash
[dn_hash(key
, dz
).datum
];
112 static inline int dn_key_eq(dn_fib_key_t a
, dn_fib_key_t b
)
114 return a
.datum
== b
.datum
;
117 static inline int dn_key_leq(dn_fib_key_t a
, dn_fib_key_t b
)
119 return a
.datum
<= b
.datum
;
122 static inline void dn_rebuild_zone(struct dn_zone
*dz
,
123 struct dn_fib_node
**old_ht
,
127 struct dn_fib_node
*f
, **fp
, *next
;
129 for(i
= 0; i
< old_divisor
; i
++) {
130 for(f
= old_ht
[i
]; f
; f
= f
->fn_next
) {
132 for(fp
= dn_chain_p(f
->fn_key
, dz
);
133 *fp
&& dn_key_leq((*fp
)->fn_key
, f
->fn_key
);
134 fp
= &(*fp
)->fn_next
)
142 static void dn_rehash_zone(struct dn_zone
*dz
)
144 struct dn_fib_node
**ht
, **old_ht
;
145 int old_divisor
, new_divisor
;
148 old_divisor
= dz
->dz_divisor
;
150 switch(old_divisor
) {
156 printk(KERN_DEBUG
"DECnet: dn_rehash_zone: BUG! %d\n", old_divisor
);
159 new_hashmask
= 0x3FF;
163 ht
= kcalloc(new_divisor
, sizeof(struct dn_fib_node
*), GFP_KERNEL
);
167 write_lock_bh(&dn_fib_tables_lock
);
168 old_ht
= dz
->dz_hash
;
170 dz
->dz_hashmask
= new_hashmask
;
171 dz
->dz_divisor
= new_divisor
;
172 dn_rebuild_zone(dz
, old_ht
, old_divisor
);
173 write_unlock_bh(&dn_fib_tables_lock
);
177 static void dn_free_node(struct dn_fib_node
*f
)
179 dn_fib_release_info(DN_FIB_INFO(f
));
180 kmem_cache_free(dn_hash_kmem
, f
);
184 static struct dn_zone
*dn_new_zone(struct dn_hash
*table
, int z
)
187 struct dn_zone
*dz
= kzalloc(sizeof(struct dn_zone
), GFP_KERNEL
);
193 dz
->dz_hashmask
= 0x0F;
199 dz
->dz_hash
= kcalloc(dz
->dz_divisor
, sizeof(struct dn_fib_node
*), GFP_KERNEL
);
206 dz
->dz_mask
= dnet_make_mask(z
);
208 for(i
= z
+ 1; i
<= 16; i
++)
209 if (table
->dh_zones
[i
])
212 write_lock_bh(&dn_fib_tables_lock
);
214 dz
->dz_next
= table
->dh_zone_list
;
215 table
->dh_zone_list
= dz
;
217 dz
->dz_next
= table
->dh_zones
[i
]->dz_next
;
218 table
->dh_zones
[i
]->dz_next
= dz
;
220 table
->dh_zones
[z
] = dz
;
221 write_unlock_bh(&dn_fib_tables_lock
);
226 static int dn_fib_nh_match(struct rtmsg
*r
, struct nlmsghdr
*nlh
, struct dn_kern_rta
*rta
, struct dn_fib_info
*fi
)
228 struct rtnexthop
*nhp
;
231 if (rta
->rta_priority
&& *rta
->rta_priority
!= fi
->fib_priority
)
234 if (rta
->rta_oif
|| rta
->rta_gw
) {
235 if ((!rta
->rta_oif
|| *rta
->rta_oif
== fi
->fib_nh
->nh_oif
) &&
236 (!rta
->rta_gw
|| memcmp(rta
->rta_gw
, &fi
->fib_nh
->nh_gw
, 2) == 0))
241 if (rta
->rta_mp
== NULL
)
244 nhp
= RTA_DATA(rta
->rta_mp
);
245 nhlen
= RTA_PAYLOAD(rta
->rta_mp
);
248 int attrlen
= nhlen
- sizeof(struct rtnexthop
);
251 if (attrlen
< 0 || (nhlen
-= nhp
->rtnh_len
) < 0)
253 if (nhp
->rtnh_ifindex
&& nhp
->rtnh_ifindex
!= nh
->nh_oif
)
256 gw
= dn_fib_get_attr16(RTNH_DATA(nhp
), attrlen
, RTA_GATEWAY
);
258 if (gw
&& gw
!= nh
->nh_gw
)
261 nhp
= RTNH_NEXT(nhp
);
262 } endfor_nexthops(fi
);
267 static inline size_t dn_fib_nlmsg_size(struct dn_fib_info
*fi
)
269 size_t payload
= NLMSG_ALIGN(sizeof(struct rtmsg
))
270 + nla_total_size(4) /* RTA_TABLE */
271 + nla_total_size(2) /* RTA_DST */
272 + nla_total_size(4); /* RTA_PRIORITY */
274 /* space for nested metrics */
275 payload
+= nla_total_size((RTAX_MAX
* nla_total_size(4)));
278 /* Also handles the special case fib_nhs == 1 */
280 /* each nexthop is packed in an attribute */
281 size_t nhsize
= nla_total_size(sizeof(struct rtnexthop
));
283 /* may contain a gateway attribute */
284 nhsize
+= nla_total_size(4);
286 /* all nexthops are packed in a nested attribute */
287 payload
+= nla_total_size(fi
->fib_nhs
* nhsize
);
293 static int dn_fib_dump_info(struct sk_buff
*skb
, u32 pid
, u32 seq
, int event
,
294 u32 tb_id
, u8 type
, u8 scope
, void *dst
, int dst_len
,
295 struct dn_fib_info
*fi
, unsigned int flags
)
298 struct nlmsghdr
*nlh
;
299 unsigned char *b
= skb_tail_pointer(skb
);
301 nlh
= NLMSG_NEW(skb
, pid
, seq
, event
, sizeof(*rtm
), flags
);
302 rtm
= NLMSG_DATA(nlh
);
303 rtm
->rtm_family
= AF_DECnet
;
304 rtm
->rtm_dst_len
= dst_len
;
305 rtm
->rtm_src_len
= 0;
307 rtm
->rtm_table
= tb_id
;
308 RTA_PUT_U32(skb
, RTA_TABLE
, tb_id
);
309 rtm
->rtm_flags
= fi
->fib_flags
;
310 rtm
->rtm_scope
= scope
;
311 rtm
->rtm_type
= type
;
312 if (rtm
->rtm_dst_len
)
313 RTA_PUT(skb
, RTA_DST
, 2, dst
);
314 rtm
->rtm_protocol
= fi
->fib_protocol
;
315 if (fi
->fib_priority
)
316 RTA_PUT(skb
, RTA_PRIORITY
, 4, &fi
->fib_priority
);
317 if (rtnetlink_put_metrics(skb
, fi
->fib_metrics
) < 0)
319 if (fi
->fib_nhs
== 1) {
320 if (fi
->fib_nh
->nh_gw
)
321 RTA_PUT(skb
, RTA_GATEWAY
, 2, &fi
->fib_nh
->nh_gw
);
322 if (fi
->fib_nh
->nh_oif
)
323 RTA_PUT(skb
, RTA_OIF
, sizeof(int), &fi
->fib_nh
->nh_oif
);
325 if (fi
->fib_nhs
> 1) {
326 struct rtnexthop
*nhp
;
327 struct rtattr
*mp_head
;
328 if (skb_tailroom(skb
) <= RTA_SPACE(0))
330 mp_head
= (struct rtattr
*)skb_put(skb
, RTA_SPACE(0));
333 if (skb_tailroom(skb
) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp
)) + 4))
335 nhp
= (struct rtnexthop
*)skb_put(skb
, RTA_ALIGN(sizeof(*nhp
)));
336 nhp
->rtnh_flags
= nh
->nh_flags
& 0xFF;
337 nhp
->rtnh_hops
= nh
->nh_weight
- 1;
338 nhp
->rtnh_ifindex
= nh
->nh_oif
;
340 RTA_PUT(skb
, RTA_GATEWAY
, 2, &nh
->nh_gw
);
341 nhp
->rtnh_len
= skb_tail_pointer(skb
) - (unsigned char *)nhp
;
342 } endfor_nexthops(fi
);
343 mp_head
->rta_type
= RTA_MULTIPATH
;
344 mp_head
->rta_len
= skb_tail_pointer(skb
) - (u8
*)mp_head
;
347 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
358 static void dn_rtmsg_fib(int event
, struct dn_fib_node
*f
, int z
, u32 tb_id
,
359 struct nlmsghdr
*nlh
, struct netlink_skb_parms
*req
)
362 u32 pid
= req
? req
->pid
: 0;
365 skb
= nlmsg_new(dn_fib_nlmsg_size(DN_FIB_INFO(f
)), GFP_KERNEL
);
369 err
= dn_fib_dump_info(skb
, pid
, nlh
->nlmsg_seq
, event
, tb_id
,
370 f
->fn_type
, f
->fn_scope
, &f
->fn_key
, z
,
373 /* -EMSGSIZE implies BUG in dn_fib_nlmsg_size() */
374 WARN_ON(err
== -EMSGSIZE
);
378 err
= rtnl_notify(skb
, &init_net
, pid
, RTNLGRP_DECnet_ROUTE
, nlh
, GFP_KERNEL
);
381 rtnl_set_sk_err(&init_net
, RTNLGRP_DECnet_ROUTE
, err
);
384 static __inline__
int dn_hash_dump_bucket(struct sk_buff
*skb
,
385 struct netlink_callback
*cb
,
386 struct dn_fib_table
*tb
,
388 struct dn_fib_node
*f
)
393 for(i
= 0; f
; i
++, f
= f
->fn_next
) {
396 if (f
->fn_state
& DN_S_ZOMBIE
)
398 if (dn_fib_dump_info(skb
, NETLINK_CB(cb
->skb
).pid
,
402 (f
->fn_state
& DN_S_ZOMBIE
) ? 0 : f
->fn_type
,
403 f
->fn_scope
, &f
->fn_key
, dz
->dz_order
,
404 f
->fn_info
, NLM_F_MULTI
) < 0) {
413 static __inline__
int dn_hash_dump_zone(struct sk_buff
*skb
,
414 struct netlink_callback
*cb
,
415 struct dn_fib_table
*tb
,
421 for(h
= 0; h
< dz
->dz_divisor
; h
++) {
425 memset(&cb
->args
[4], 0, sizeof(cb
->args
) - 4*sizeof(cb
->args
[0]));
426 if (dz
->dz_hash
== NULL
|| dz
->dz_hash
[h
] == NULL
)
428 if (dn_hash_dump_bucket(skb
, cb
, tb
, dz
, dz
->dz_hash
[h
]) < 0) {
437 static int dn_fib_table_dump(struct dn_fib_table
*tb
, struct sk_buff
*skb
,
438 struct netlink_callback
*cb
)
442 struct dn_hash
*table
= (struct dn_hash
*)tb
->data
;
445 read_lock(&dn_fib_tables_lock
);
446 for(dz
= table
->dh_zone_list
, m
= 0; dz
; dz
= dz
->dz_next
, m
++) {
450 memset(&cb
->args
[3], 0, sizeof(cb
->args
) - 3*sizeof(cb
->args
[0]));
452 if (dn_hash_dump_zone(skb
, cb
, tb
, dz
) < 0) {
454 read_unlock(&dn_fib_tables_lock
);
458 read_unlock(&dn_fib_tables_lock
);
464 int dn_fib_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
466 struct net
*net
= sock_net(skb
->sk
);
468 unsigned int e
= 0, s_e
;
469 struct dn_fib_table
*tb
;
470 struct hlist_node
*node
;
473 if (net
!= &init_net
)
476 if (NLMSG_PAYLOAD(cb
->nlh
, 0) >= sizeof(struct rtmsg
) &&
477 ((struct rtmsg
*)NLMSG_DATA(cb
->nlh
))->rtm_flags
&RTM_F_CLONED
)
478 return dn_cache_dump(skb
, cb
);
483 for (h
= s_h
; h
< DN_FIB_TABLE_HASHSZ
; h
++, s_h
= 0) {
485 hlist_for_each_entry(tb
, node
, &dn_fib_table_hash
[h
], hlist
) {
489 memset(&cb
->args
[2], 0, sizeof(cb
->args
) -
490 2 * sizeof(cb
->args
[0]));
491 if (tb
->dump(tb
, skb
, cb
) < 0)
505 static int dn_fib_table_insert(struct dn_fib_table
*tb
, struct rtmsg
*r
, struct dn_kern_rta
*rta
, struct nlmsghdr
*n
, struct netlink_skb_parms
*req
)
507 struct dn_hash
*table
= (struct dn_hash
*)tb
->data
;
508 struct dn_fib_node
*new_f
, *f
, **fp
, **del_fp
;
510 struct dn_fib_info
*fi
;
511 int z
= r
->rtm_dst_len
;
512 int type
= r
->rtm_type
;
519 dz
= table
->dh_zones
[z
];
520 if (!dz
&& !(dz
= dn_new_zone(table
, z
)))
526 memcpy(&dst
, rta
->rta_dst
, 2);
527 if (dst
& ~DZ_MASK(dz
))
529 key
= dz_key(dst
, dz
);
532 if ((fi
= dn_fib_create_info(r
, rta
, n
, &err
)) == NULL
)
535 if (dz
->dz_nent
> (dz
->dz_divisor
<< 2) &&
536 dz
->dz_divisor
> DN_MAX_DIVISOR
&&
537 (z
==16 || (1<<z
) > dz
->dz_divisor
))
540 fp
= dn_chain_p(key
, dz
);
543 if (dn_key_leq(key
, f
->fn_key
))
549 if (f
&& (f
->fn_state
& DN_S_ZOMBIE
) &&
550 dn_key_eq(f
->fn_key
, key
)) {
557 DN_FIB_SCAN_KEY(f
, fp
, key
) {
558 if (fi
->fib_priority
<= DN_FIB_INFO(f
)->fib_priority
)
562 if (f
&& dn_key_eq(f
->fn_key
, key
) &&
563 fi
->fib_priority
== DN_FIB_INFO(f
)->fib_priority
) {
564 struct dn_fib_node
**ins_fp
;
567 if (n
->nlmsg_flags
& NLM_F_EXCL
)
570 if (n
->nlmsg_flags
& NLM_F_REPLACE
) {
580 DN_FIB_SCAN_KEY(f
, fp
, key
) {
581 if (fi
->fib_priority
!= DN_FIB_INFO(f
)->fib_priority
)
583 if (f
->fn_type
== type
&& f
->fn_scope
== r
->rtm_scope
584 && DN_FIB_INFO(f
) == fi
)
588 if (!(n
->nlmsg_flags
& NLM_F_APPEND
)) {
596 if (!(n
->nlmsg_flags
& NLM_F_CREATE
))
601 new_f
= kmem_cache_zalloc(dn_hash_kmem
, GFP_KERNEL
);
606 new_f
->fn_type
= type
;
607 new_f
->fn_scope
= r
->rtm_scope
;
608 DN_FIB_INFO(new_f
) = fi
;
611 write_lock_bh(&dn_fib_tables_lock
);
613 write_unlock_bh(&dn_fib_tables_lock
);
618 write_lock_bh(&dn_fib_tables_lock
);
619 *del_fp
= f
->fn_next
;
620 write_unlock_bh(&dn_fib_tables_lock
);
622 if (!(f
->fn_state
& DN_S_ZOMBIE
))
623 dn_rtmsg_fib(RTM_DELROUTE
, f
, z
, tb
->n
, n
, req
);
624 if (f
->fn_state
& DN_S_ACCESSED
)
625 dn_rt_cache_flush(-1);
629 dn_rt_cache_flush(-1);
632 dn_rtmsg_fib(RTM_NEWROUTE
, new_f
, z
, tb
->n
, n
, req
);
636 dn_fib_release_info(fi
);
641 static int dn_fib_table_delete(struct dn_fib_table
*tb
, struct rtmsg
*r
, struct dn_kern_rta
*rta
, struct nlmsghdr
*n
, struct netlink_skb_parms
*req
)
643 struct dn_hash
*table
= (struct dn_hash
*)tb
->data
;
644 struct dn_fib_node
**fp
, **del_fp
, *f
;
645 int z
= r
->rtm_dst_len
;
654 if ((dz
= table
->dh_zones
[z
]) == NULL
)
660 memcpy(&dst
, rta
->rta_dst
, 2);
661 if (dst
& ~DZ_MASK(dz
))
663 key
= dz_key(dst
, dz
);
666 fp
= dn_chain_p(key
, dz
);
669 if (dn_key_eq(f
->fn_key
, key
))
671 if (dn_key_leq(key
, f
->fn_key
))
677 DN_FIB_SCAN_KEY(f
, fp
, key
) {
678 struct dn_fib_info
*fi
= DN_FIB_INFO(f
);
680 if (f
->fn_state
& DN_S_ZOMBIE
)
685 if (del_fp
== NULL
&&
686 (!r
->rtm_type
|| f
->fn_type
== r
->rtm_type
) &&
687 (r
->rtm_scope
== RT_SCOPE_NOWHERE
|| f
->fn_scope
== r
->rtm_scope
) &&
689 fi
->fib_protocol
== r
->rtm_protocol
) &&
690 dn_fib_nh_match(r
, n
, rta
, fi
) == 0)
696 dn_rtmsg_fib(RTM_DELROUTE
, f
, z
, tb
->n
, n
, req
);
699 write_lock_bh(&dn_fib_tables_lock
);
700 *del_fp
= f
->fn_next
;
701 write_unlock_bh(&dn_fib_tables_lock
);
703 if (f
->fn_state
& DN_S_ACCESSED
)
704 dn_rt_cache_flush(-1);
708 f
->fn_state
|= DN_S_ZOMBIE
;
709 if (f
->fn_state
& DN_S_ACCESSED
) {
710 f
->fn_state
&= ~DN_S_ACCESSED
;
711 dn_rt_cache_flush(-1);
713 if (++dn_fib_hash_zombies
> 128)
723 static inline int dn_flush_list(struct dn_fib_node
**fp
, int z
, struct dn_hash
*table
)
726 struct dn_fib_node
*f
;
728 while((f
= *fp
) != NULL
) {
729 struct dn_fib_info
*fi
= DN_FIB_INFO(f
);
731 if (fi
&& ((f
->fn_state
& DN_S_ZOMBIE
) || (fi
->fib_flags
& RTNH_F_DEAD
))) {
732 write_lock_bh(&dn_fib_tables_lock
);
734 write_unlock_bh(&dn_fib_tables_lock
);
746 static int dn_fib_table_flush(struct dn_fib_table
*tb
)
748 struct dn_hash
*table
= (struct dn_hash
*)tb
->data
;
752 dn_fib_hash_zombies
= 0;
753 for(dz
= table
->dh_zone_list
; dz
; dz
= dz
->dz_next
) {
756 for(i
= dz
->dz_divisor
-1; i
>= 0; i
--)
757 tmp
+= dn_flush_list(&dz
->dz_hash
[i
], dz
->dz_order
, table
);
765 static int dn_fib_table_lookup(struct dn_fib_table
*tb
, const struct flowi
*flp
, struct dn_fib_res
*res
)
769 struct dn_hash
*t
= (struct dn_hash
*)tb
->data
;
771 read_lock(&dn_fib_tables_lock
);
772 for(dz
= t
->dh_zone_list
; dz
; dz
= dz
->dz_next
) {
773 struct dn_fib_node
*f
;
774 dn_fib_key_t k
= dz_key(flp
->fld_dst
, dz
);
776 for(f
= dz_chain(k
, dz
); f
; f
= f
->fn_next
) {
777 if (!dn_key_eq(k
, f
->fn_key
)) {
778 if (dn_key_leq(k
, f
->fn_key
))
784 f
->fn_state
|= DN_S_ACCESSED
;
786 if (f
->fn_state
&DN_S_ZOMBIE
)
789 if (f
->fn_scope
< flp
->fld_scope
)
792 err
= dn_fib_semantic_match(f
->fn_type
, DN_FIB_INFO(f
), flp
, res
);
795 res
->type
= f
->fn_type
;
796 res
->scope
= f
->fn_scope
;
797 res
->prefixlen
= dz
->dz_order
;
806 read_unlock(&dn_fib_tables_lock
);
811 struct dn_fib_table
*dn_fib_get_table(u32 n
, int create
)
813 struct dn_fib_table
*t
;
814 struct hlist_node
*node
;
817 if (n
< RT_TABLE_MIN
)
820 if (n
> RT_TABLE_MAX
)
823 h
= n
& (DN_FIB_TABLE_HASHSZ
- 1);
825 hlist_for_each_entry_rcu(t
, node
, &dn_fib_table_hash
[h
], hlist
) {
836 if (in_interrupt() && net_ratelimit()) {
837 printk(KERN_DEBUG
"DECnet: BUG! Attempt to create routing table from interrupt\n");
841 t
= kzalloc(sizeof(struct dn_fib_table
) + sizeof(struct dn_hash
),
847 t
->insert
= dn_fib_table_insert
;
848 t
->delete = dn_fib_table_delete
;
849 t
->lookup
= dn_fib_table_lookup
;
850 t
->flush
= dn_fib_table_flush
;
851 t
->dump
= dn_fib_table_dump
;
852 hlist_add_head_rcu(&t
->hlist
, &dn_fib_table_hash
[h
]);
857 struct dn_fib_table
*dn_fib_empty_table(void)
861 for(id
= RT_TABLE_MIN
; id
<= RT_TABLE_MAX
; id
++)
862 if (dn_fib_get_table(id
, 0) == NULL
)
863 return dn_fib_get_table(id
, 1);
867 void dn_fib_flush(void)
870 struct dn_fib_table
*tb
;
871 struct hlist_node
*node
;
874 for (h
= 0; h
< DN_FIB_TABLE_HASHSZ
; h
++) {
875 hlist_for_each_entry(tb
, node
, &dn_fib_table_hash
[h
], hlist
)
876 flushed
+= tb
->flush(tb
);
880 dn_rt_cache_flush(-1);
883 void __init
dn_fib_table_init(void)
885 dn_hash_kmem
= kmem_cache_create("dn_fib_info_cache",
886 sizeof(struct dn_fib_info
),
887 0, SLAB_HWCACHE_ALIGN
,
891 void __exit
dn_fib_table_cleanup(void)
893 struct dn_fib_table
*t
;
894 struct hlist_node
*node
, *next
;
897 write_lock(&dn_fib_tables_lock
);
898 for (h
= 0; h
< DN_FIB_TABLE_HASHSZ
; h
++) {
899 hlist_for_each_entry_safe(t
, node
, next
, &dn_fib_table_hash
[h
],
901 hlist_del(&t
->hlist
);
905 write_unlock(&dn_fib_tables_lock
);