1 // SPDX-License-Identifier: GPL-2.0
3 * DECnet An implementation of the DECnet protocol suite for the LINUX
4 * operating system. DECnet is implemented using the BSD Socket
5 * interface as the means of communication with the user level.
7 * DECnet Routing Forwarding Information Base (Routing Tables)
9 * Author: Steve Whitehouse <SteveW@ACM.org>
10 * Mostly copied from the IPv4 routing code
16 #include <linux/string.h>
17 #include <linux/net.h>
18 #include <linux/socket.h>
19 #include <linux/slab.h>
20 #include <linux/sockios.h>
21 #include <linux/init.h>
22 #include <linux/skbuff.h>
23 #include <linux/rtnetlink.h>
24 #include <linux/proc_fs.h>
25 #include <linux/netdevice.h>
26 #include <linux/timer.h>
27 #include <linux/spinlock.h>
28 #include <linux/atomic.h>
29 #include <linux/uaccess.h>
30 #include <linux/route.h> /* RTF_xxx */
31 #include <net/neighbour.h>
32 #include <net/netlink.h>
36 #include <net/fib_rules.h>
38 #include <net/dn_route.h>
39 #include <net/dn_fib.h>
40 #include <net/dn_neigh.h>
41 #include <net/dn_dev.h>
45 struct dn_zone
*dz_next
;
46 struct dn_fib_node
**dz_hash
;
50 #define DZ_HASHMASK(dz) ((dz)->dz_hashmask)
53 #define DZ_MASK(dz) ((dz)->dz_mask)
58 struct dn_zone
*dh_zones
[17];
59 struct dn_zone
*dh_zone_list
;
62 #define dz_key_0(key) ((key).datum = 0)
64 #define for_nexthops(fi) { int nhsel; const struct dn_fib_nh *nh;\
65 for(nhsel = 0, nh = (fi)->fib_nh; nhsel < (fi)->fib_nhs; nh++, nhsel++)
67 #define endfor_nexthops(fi) }
69 #define DN_MAX_DIVISOR 1024
71 #define DN_S_ACCESSED 2
73 #define DN_FIB_SCAN(f, fp) \
74 for( ; ((f) = *(fp)) != NULL; (fp) = &(f)->fn_next)
76 #define DN_FIB_SCAN_KEY(f, fp, key) \
77 for( ; ((f) = *(fp)) != NULL && dn_key_eq((f)->fn_key, (key)); (fp) = &(f)->fn_next)
79 #define RT_TABLE_MIN 1
80 #define DN_FIB_TABLE_HASHSZ 256
81 static struct hlist_head dn_fib_table_hash
[DN_FIB_TABLE_HASHSZ
];
82 static DEFINE_RWLOCK(dn_fib_tables_lock
);
84 static struct kmem_cache
*dn_hash_kmem __read_mostly
;
85 static int dn_fib_hash_zombies
;
87 static inline dn_fib_idx_t
dn_hash(dn_fib_key_t key
, struct dn_zone
*dz
)
89 u16 h
= le16_to_cpu(key
.datum
)>>(16 - dz
->dz_order
);
93 return *(dn_fib_idx_t
*)&h
;
96 static inline dn_fib_key_t
dz_key(__le16 dst
, struct dn_zone
*dz
)
99 k
.datum
= dst
& DZ_MASK(dz
);
103 static inline struct dn_fib_node
**dn_chain_p(dn_fib_key_t key
, struct dn_zone
*dz
)
105 return &dz
->dz_hash
[dn_hash(key
, dz
).datum
];
108 static inline struct dn_fib_node
*dz_chain(dn_fib_key_t key
, struct dn_zone
*dz
)
110 return dz
->dz_hash
[dn_hash(key
, dz
).datum
];
113 static inline int dn_key_eq(dn_fib_key_t a
, dn_fib_key_t b
)
115 return a
.datum
== b
.datum
;
118 static inline int dn_key_leq(dn_fib_key_t a
, dn_fib_key_t b
)
120 return a
.datum
<= b
.datum
;
123 static inline void dn_rebuild_zone(struct dn_zone
*dz
,
124 struct dn_fib_node
**old_ht
,
127 struct dn_fib_node
*f
, **fp
, *next
;
130 for(i
= 0; i
< old_divisor
; i
++) {
131 for(f
= old_ht
[i
]; f
; f
= next
) {
133 for(fp
= dn_chain_p(f
->fn_key
, dz
);
134 *fp
&& dn_key_leq((*fp
)->fn_key
, f
->fn_key
);
135 fp
= &(*fp
)->fn_next
)
143 static void dn_rehash_zone(struct dn_zone
*dz
)
145 struct dn_fib_node
**ht
, **old_ht
;
146 int old_divisor
, new_divisor
;
149 old_divisor
= dz
->dz_divisor
;
151 switch (old_divisor
) {
157 printk(KERN_DEBUG
"DECnet: dn_rehash_zone: BUG! %d\n",
161 new_hashmask
= 0x3FF;
165 ht
= kcalloc(new_divisor
, sizeof(struct dn_fib_node
*), GFP_KERNEL
);
169 write_lock_bh(&dn_fib_tables_lock
);
170 old_ht
= dz
->dz_hash
;
172 dz
->dz_hashmask
= new_hashmask
;
173 dz
->dz_divisor
= new_divisor
;
174 dn_rebuild_zone(dz
, old_ht
, old_divisor
);
175 write_unlock_bh(&dn_fib_tables_lock
);
179 static void dn_free_node(struct dn_fib_node
*f
)
181 dn_fib_release_info(DN_FIB_INFO(f
));
182 kmem_cache_free(dn_hash_kmem
, f
);
186 static struct dn_zone
*dn_new_zone(struct dn_hash
*table
, int z
)
189 struct dn_zone
*dz
= kzalloc(sizeof(struct dn_zone
), GFP_KERNEL
);
195 dz
->dz_hashmask
= 0x0F;
201 dz
->dz_hash
= kcalloc(dz
->dz_divisor
, sizeof(struct dn_fib_node
*), GFP_KERNEL
);
208 dz
->dz_mask
= dnet_make_mask(z
);
210 for(i
= z
+ 1; i
<= 16; i
++)
211 if (table
->dh_zones
[i
])
214 write_lock_bh(&dn_fib_tables_lock
);
216 dz
->dz_next
= table
->dh_zone_list
;
217 table
->dh_zone_list
= dz
;
219 dz
->dz_next
= table
->dh_zones
[i
]->dz_next
;
220 table
->dh_zones
[i
]->dz_next
= dz
;
222 table
->dh_zones
[z
] = dz
;
223 write_unlock_bh(&dn_fib_tables_lock
);
228 static int dn_fib_nh_match(struct rtmsg
*r
, struct nlmsghdr
*nlh
, struct nlattr
*attrs
[], struct dn_fib_info
*fi
)
230 struct rtnexthop
*nhp
;
233 if (attrs
[RTA_PRIORITY
] &&
234 nla_get_u32(attrs
[RTA_PRIORITY
]) != fi
->fib_priority
)
237 if (attrs
[RTA_OIF
] || attrs
[RTA_GATEWAY
]) {
238 if ((!attrs
[RTA_OIF
] || nla_get_u32(attrs
[RTA_OIF
]) == fi
->fib_nh
->nh_oif
) &&
239 (!attrs
[RTA_GATEWAY
] || nla_get_le16(attrs
[RTA_GATEWAY
]) != fi
->fib_nh
->nh_gw
))
244 if (!attrs
[RTA_MULTIPATH
])
247 nhp
= nla_data(attrs
[RTA_MULTIPATH
]);
248 nhlen
= nla_len(attrs
[RTA_MULTIPATH
]);
251 int attrlen
= nhlen
- sizeof(struct rtnexthop
);
254 if (attrlen
< 0 || (nhlen
-= nhp
->rtnh_len
) < 0)
256 if (nhp
->rtnh_ifindex
&& nhp
->rtnh_ifindex
!= nh
->nh_oif
)
259 struct nlattr
*gw_attr
;
261 gw_attr
= nla_find((struct nlattr
*) (nhp
+ 1), attrlen
, RTA_GATEWAY
);
262 gw
= gw_attr
? nla_get_le16(gw_attr
) : 0;
264 if (gw
&& gw
!= nh
->nh_gw
)
267 nhp
= RTNH_NEXT(nhp
);
268 } endfor_nexthops(fi
);
273 static inline size_t dn_fib_nlmsg_size(struct dn_fib_info
*fi
)
275 size_t payload
= NLMSG_ALIGN(sizeof(struct rtmsg
))
276 + nla_total_size(4) /* RTA_TABLE */
277 + nla_total_size(2) /* RTA_DST */
278 + nla_total_size(4) /* RTA_PRIORITY */
279 + nla_total_size(TCP_CA_NAME_MAX
); /* RTAX_CC_ALGO */
281 /* space for nested metrics */
282 payload
+= nla_total_size((RTAX_MAX
* nla_total_size(4)));
285 /* Also handles the special case fib_nhs == 1 */
287 /* each nexthop is packed in an attribute */
288 size_t nhsize
= nla_total_size(sizeof(struct rtnexthop
));
290 /* may contain a gateway attribute */
291 nhsize
+= nla_total_size(4);
293 /* all nexthops are packed in a nested attribute */
294 payload
+= nla_total_size(fi
->fib_nhs
* nhsize
);
300 static int dn_fib_dump_info(struct sk_buff
*skb
, u32 portid
, u32 seq
, int event
,
301 u32 tb_id
, u8 type
, u8 scope
, void *dst
, int dst_len
,
302 struct dn_fib_info
*fi
, unsigned int flags
)
305 struct nlmsghdr
*nlh
;
307 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*rtm
), flags
);
311 rtm
= nlmsg_data(nlh
);
312 rtm
->rtm_family
= AF_DECnet
;
313 rtm
->rtm_dst_len
= dst_len
;
314 rtm
->rtm_src_len
= 0;
316 rtm
->rtm_table
= tb_id
;
317 rtm
->rtm_flags
= fi
->fib_flags
;
318 rtm
->rtm_scope
= scope
;
319 rtm
->rtm_type
= type
;
320 rtm
->rtm_protocol
= fi
->fib_protocol
;
322 if (nla_put_u32(skb
, RTA_TABLE
, tb_id
) < 0)
325 if (rtm
->rtm_dst_len
&&
326 nla_put(skb
, RTA_DST
, 2, dst
) < 0)
329 if (fi
->fib_priority
&&
330 nla_put_u32(skb
, RTA_PRIORITY
, fi
->fib_priority
) < 0)
333 if (rtnetlink_put_metrics(skb
, fi
->fib_metrics
) < 0)
336 if (fi
->fib_nhs
== 1) {
337 if (fi
->fib_nh
->nh_gw
&&
338 nla_put_le16(skb
, RTA_GATEWAY
, fi
->fib_nh
->nh_gw
) < 0)
341 if (fi
->fib_nh
->nh_oif
&&
342 nla_put_u32(skb
, RTA_OIF
, fi
->fib_nh
->nh_oif
) < 0)
346 if (fi
->fib_nhs
> 1) {
347 struct rtnexthop
*nhp
;
348 struct nlattr
*mp_head
;
350 if (!(mp_head
= nla_nest_start(skb
, RTA_MULTIPATH
)))
354 if (!(nhp
= nla_reserve_nohdr(skb
, sizeof(*nhp
))))
357 nhp
->rtnh_flags
= nh
->nh_flags
& 0xFF;
358 nhp
->rtnh_hops
= nh
->nh_weight
- 1;
359 nhp
->rtnh_ifindex
= nh
->nh_oif
;
362 nla_put_le16(skb
, RTA_GATEWAY
, nh
->nh_gw
) < 0)
365 nhp
->rtnh_len
= skb_tail_pointer(skb
) - (unsigned char *)nhp
;
366 } endfor_nexthops(fi
);
368 nla_nest_end(skb
, mp_head
);
375 nlmsg_cancel(skb
, nlh
);
380 static void dn_rtmsg_fib(int event
, struct dn_fib_node
*f
, int z
, u32 tb_id
,
381 struct nlmsghdr
*nlh
, struct netlink_skb_parms
*req
)
384 u32 portid
= req
? req
->portid
: 0;
387 skb
= nlmsg_new(dn_fib_nlmsg_size(DN_FIB_INFO(f
)), GFP_KERNEL
);
391 err
= dn_fib_dump_info(skb
, portid
, nlh
->nlmsg_seq
, event
, tb_id
,
392 f
->fn_type
, f
->fn_scope
, &f
->fn_key
, z
,
395 /* -EMSGSIZE implies BUG in dn_fib_nlmsg_size() */
396 WARN_ON(err
== -EMSGSIZE
);
400 rtnl_notify(skb
, &init_net
, portid
, RTNLGRP_DECnet_ROUTE
, nlh
, GFP_KERNEL
);
404 rtnl_set_sk_err(&init_net
, RTNLGRP_DECnet_ROUTE
, err
);
407 static __inline__
int dn_hash_dump_bucket(struct sk_buff
*skb
,
408 struct netlink_callback
*cb
,
409 struct dn_fib_table
*tb
,
411 struct dn_fib_node
*f
)
416 for(i
= 0; f
; i
++, f
= f
->fn_next
) {
419 if (f
->fn_state
& DN_S_ZOMBIE
)
421 if (dn_fib_dump_info(skb
, NETLINK_CB(cb
->skb
).portid
,
425 (f
->fn_state
& DN_S_ZOMBIE
) ? 0 : f
->fn_type
,
426 f
->fn_scope
, &f
->fn_key
, dz
->dz_order
,
427 f
->fn_info
, NLM_F_MULTI
) < 0) {
436 static __inline__
int dn_hash_dump_zone(struct sk_buff
*skb
,
437 struct netlink_callback
*cb
,
438 struct dn_fib_table
*tb
,
444 for(h
= 0; h
< dz
->dz_divisor
; h
++) {
448 memset(&cb
->args
[4], 0, sizeof(cb
->args
) - 4*sizeof(cb
->args
[0]));
449 if (dz
->dz_hash
== NULL
|| dz
->dz_hash
[h
] == NULL
)
451 if (dn_hash_dump_bucket(skb
, cb
, tb
, dz
, dz
->dz_hash
[h
]) < 0) {
460 static int dn_fib_table_dump(struct dn_fib_table
*tb
, struct sk_buff
*skb
,
461 struct netlink_callback
*cb
)
465 struct dn_hash
*table
= (struct dn_hash
*)tb
->data
;
468 read_lock(&dn_fib_tables_lock
);
469 for(dz
= table
->dh_zone_list
, m
= 0; dz
; dz
= dz
->dz_next
, m
++) {
473 memset(&cb
->args
[3], 0, sizeof(cb
->args
) - 3*sizeof(cb
->args
[0]));
475 if (dn_hash_dump_zone(skb
, cb
, tb
, dz
) < 0) {
477 read_unlock(&dn_fib_tables_lock
);
481 read_unlock(&dn_fib_tables_lock
);
487 int dn_fib_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
489 struct net
*net
= sock_net(skb
->sk
);
491 unsigned int e
= 0, s_e
;
492 struct dn_fib_table
*tb
;
495 if (!net_eq(net
, &init_net
))
498 if (nlmsg_len(cb
->nlh
) >= sizeof(struct rtmsg
) &&
499 ((struct rtmsg
*)nlmsg_data(cb
->nlh
))->rtm_flags
&RTM_F_CLONED
)
500 return dn_cache_dump(skb
, cb
);
505 for (h
= s_h
; h
< DN_FIB_TABLE_HASHSZ
; h
++, s_h
= 0) {
507 hlist_for_each_entry(tb
, &dn_fib_table_hash
[h
], hlist
) {
511 memset(&cb
->args
[2], 0, sizeof(cb
->args
) -
512 2 * sizeof(cb
->args
[0]));
513 if (tb
->dump(tb
, skb
, cb
) < 0)
527 static int dn_fib_table_insert(struct dn_fib_table
*tb
, struct rtmsg
*r
, struct nlattr
*attrs
[],
528 struct nlmsghdr
*n
, struct netlink_skb_parms
*req
)
530 struct dn_hash
*table
= (struct dn_hash
*)tb
->data
;
531 struct dn_fib_node
*new_f
, *f
, **fp
, **del_fp
;
533 struct dn_fib_info
*fi
;
534 int z
= r
->rtm_dst_len
;
535 int type
= r
->rtm_type
;
542 dz
= table
->dh_zones
[z
];
543 if (!dz
&& !(dz
= dn_new_zone(table
, z
)))
547 if (attrs
[RTA_DST
]) {
548 __le16 dst
= nla_get_le16(attrs
[RTA_DST
]);
549 if (dst
& ~DZ_MASK(dz
))
551 key
= dz_key(dst
, dz
);
554 if ((fi
= dn_fib_create_info(r
, attrs
, n
, &err
)) == NULL
)
557 if (dz
->dz_nent
> (dz
->dz_divisor
<< 2) &&
558 dz
->dz_divisor
> DN_MAX_DIVISOR
&&
559 (z
==16 || (1<<z
) > dz
->dz_divisor
))
562 fp
= dn_chain_p(key
, dz
);
565 if (dn_key_leq(key
, f
->fn_key
))
571 if (f
&& (f
->fn_state
& DN_S_ZOMBIE
) &&
572 dn_key_eq(f
->fn_key
, key
)) {
579 DN_FIB_SCAN_KEY(f
, fp
, key
) {
580 if (fi
->fib_priority
<= DN_FIB_INFO(f
)->fib_priority
)
584 if (f
&& dn_key_eq(f
->fn_key
, key
) &&
585 fi
->fib_priority
== DN_FIB_INFO(f
)->fib_priority
) {
586 struct dn_fib_node
**ins_fp
;
589 if (n
->nlmsg_flags
& NLM_F_EXCL
)
592 if (n
->nlmsg_flags
& NLM_F_REPLACE
) {
602 DN_FIB_SCAN_KEY(f
, fp
, key
) {
603 if (fi
->fib_priority
!= DN_FIB_INFO(f
)->fib_priority
)
605 if (f
->fn_type
== type
&&
606 f
->fn_scope
== r
->rtm_scope
&&
607 DN_FIB_INFO(f
) == fi
)
611 if (!(n
->nlmsg_flags
& NLM_F_APPEND
)) {
619 if (!(n
->nlmsg_flags
& NLM_F_CREATE
))
624 new_f
= kmem_cache_zalloc(dn_hash_kmem
, GFP_KERNEL
);
629 new_f
->fn_type
= type
;
630 new_f
->fn_scope
= r
->rtm_scope
;
631 DN_FIB_INFO(new_f
) = fi
;
634 write_lock_bh(&dn_fib_tables_lock
);
636 write_unlock_bh(&dn_fib_tables_lock
);
641 write_lock_bh(&dn_fib_tables_lock
);
642 *del_fp
= f
->fn_next
;
643 write_unlock_bh(&dn_fib_tables_lock
);
645 if (!(f
->fn_state
& DN_S_ZOMBIE
))
646 dn_rtmsg_fib(RTM_DELROUTE
, f
, z
, tb
->n
, n
, req
);
647 if (f
->fn_state
& DN_S_ACCESSED
)
648 dn_rt_cache_flush(-1);
652 dn_rt_cache_flush(-1);
655 dn_rtmsg_fib(RTM_NEWROUTE
, new_f
, z
, tb
->n
, n
, req
);
659 dn_fib_release_info(fi
);
664 static int dn_fib_table_delete(struct dn_fib_table
*tb
, struct rtmsg
*r
, struct nlattr
*attrs
[],
665 struct nlmsghdr
*n
, struct netlink_skb_parms
*req
)
667 struct dn_hash
*table
= (struct dn_hash
*)tb
->data
;
668 struct dn_fib_node
**fp
, **del_fp
, *f
;
669 int z
= r
->rtm_dst_len
;
678 if ((dz
= table
->dh_zones
[z
]) == NULL
)
682 if (attrs
[RTA_DST
]) {
683 __le16 dst
= nla_get_le16(attrs
[RTA_DST
]);
684 if (dst
& ~DZ_MASK(dz
))
686 key
= dz_key(dst
, dz
);
689 fp
= dn_chain_p(key
, dz
);
692 if (dn_key_eq(f
->fn_key
, key
))
694 if (dn_key_leq(key
, f
->fn_key
))
700 DN_FIB_SCAN_KEY(f
, fp
, key
) {
701 struct dn_fib_info
*fi
= DN_FIB_INFO(f
);
703 if (f
->fn_state
& DN_S_ZOMBIE
)
708 if (del_fp
== NULL
&&
709 (!r
->rtm_type
|| f
->fn_type
== r
->rtm_type
) &&
710 (r
->rtm_scope
== RT_SCOPE_NOWHERE
|| f
->fn_scope
== r
->rtm_scope
) &&
712 fi
->fib_protocol
== r
->rtm_protocol
) &&
713 dn_fib_nh_match(r
, n
, attrs
, fi
) == 0)
719 dn_rtmsg_fib(RTM_DELROUTE
, f
, z
, tb
->n
, n
, req
);
722 write_lock_bh(&dn_fib_tables_lock
);
723 *del_fp
= f
->fn_next
;
724 write_unlock_bh(&dn_fib_tables_lock
);
726 if (f
->fn_state
& DN_S_ACCESSED
)
727 dn_rt_cache_flush(-1);
731 f
->fn_state
|= DN_S_ZOMBIE
;
732 if (f
->fn_state
& DN_S_ACCESSED
) {
733 f
->fn_state
&= ~DN_S_ACCESSED
;
734 dn_rt_cache_flush(-1);
736 if (++dn_fib_hash_zombies
> 128)
746 static inline int dn_flush_list(struct dn_fib_node
**fp
, int z
, struct dn_hash
*table
)
749 struct dn_fib_node
*f
;
751 while((f
= *fp
) != NULL
) {
752 struct dn_fib_info
*fi
= DN_FIB_INFO(f
);
754 if (fi
&& ((f
->fn_state
& DN_S_ZOMBIE
) || (fi
->fib_flags
& RTNH_F_DEAD
))) {
755 write_lock_bh(&dn_fib_tables_lock
);
757 write_unlock_bh(&dn_fib_tables_lock
);
769 static int dn_fib_table_flush(struct dn_fib_table
*tb
)
771 struct dn_hash
*table
= (struct dn_hash
*)tb
->data
;
775 dn_fib_hash_zombies
= 0;
776 for(dz
= table
->dh_zone_list
; dz
; dz
= dz
->dz_next
) {
779 for(i
= dz
->dz_divisor
-1; i
>= 0; i
--)
780 tmp
+= dn_flush_list(&dz
->dz_hash
[i
], dz
->dz_order
, table
);
788 static int dn_fib_table_lookup(struct dn_fib_table
*tb
, const struct flowidn
*flp
, struct dn_fib_res
*res
)
792 struct dn_hash
*t
= (struct dn_hash
*)tb
->data
;
794 read_lock(&dn_fib_tables_lock
);
795 for(dz
= t
->dh_zone_list
; dz
; dz
= dz
->dz_next
) {
796 struct dn_fib_node
*f
;
797 dn_fib_key_t k
= dz_key(flp
->daddr
, dz
);
799 for(f
= dz_chain(k
, dz
); f
; f
= f
->fn_next
) {
800 if (!dn_key_eq(k
, f
->fn_key
)) {
801 if (dn_key_leq(k
, f
->fn_key
))
807 f
->fn_state
|= DN_S_ACCESSED
;
809 if (f
->fn_state
&DN_S_ZOMBIE
)
812 if (f
->fn_scope
< flp
->flowidn_scope
)
815 err
= dn_fib_semantic_match(f
->fn_type
, DN_FIB_INFO(f
), flp
, res
);
818 res
->type
= f
->fn_type
;
819 res
->scope
= f
->fn_scope
;
820 res
->prefixlen
= dz
->dz_order
;
829 read_unlock(&dn_fib_tables_lock
);
834 struct dn_fib_table
*dn_fib_get_table(u32 n
, int create
)
836 struct dn_fib_table
*t
;
839 if (n
< RT_TABLE_MIN
)
842 if (n
> RT_TABLE_MAX
)
845 h
= n
& (DN_FIB_TABLE_HASHSZ
- 1);
847 hlist_for_each_entry_rcu(t
, &dn_fib_table_hash
[h
], hlist
) {
858 if (in_interrupt()) {
859 net_dbg_ratelimited("DECnet: BUG! Attempt to create routing table from interrupt\n");
863 t
= kzalloc(sizeof(struct dn_fib_table
) + sizeof(struct dn_hash
),
869 t
->insert
= dn_fib_table_insert
;
870 t
->delete = dn_fib_table_delete
;
871 t
->lookup
= dn_fib_table_lookup
;
872 t
->flush
= dn_fib_table_flush
;
873 t
->dump
= dn_fib_table_dump
;
874 hlist_add_head_rcu(&t
->hlist
, &dn_fib_table_hash
[h
]);
879 struct dn_fib_table
*dn_fib_empty_table(void)
883 for(id
= RT_TABLE_MIN
; id
<= RT_TABLE_MAX
; id
++)
884 if (dn_fib_get_table(id
, 0) == NULL
)
885 return dn_fib_get_table(id
, 1);
889 void dn_fib_flush(void)
892 struct dn_fib_table
*tb
;
895 for (h
= 0; h
< DN_FIB_TABLE_HASHSZ
; h
++) {
896 hlist_for_each_entry(tb
, &dn_fib_table_hash
[h
], hlist
)
897 flushed
+= tb
->flush(tb
);
901 dn_rt_cache_flush(-1);
904 void __init
dn_fib_table_init(void)
906 dn_hash_kmem
= kmem_cache_create("dn_fib_info_cache",
907 sizeof(struct dn_fib_info
),
908 0, SLAB_HWCACHE_ALIGN
,
912 void __exit
dn_fib_table_cleanup(void)
914 struct dn_fib_table
*t
;
915 struct hlist_node
*next
;
918 write_lock(&dn_fib_tables_lock
);
919 for (h
= 0; h
< DN_FIB_TABLE_HASHSZ
; h
++) {
920 hlist_for_each_entry_safe(t
, next
, &dn_fib_table_hash
[h
],
922 hlist_del(&t
->hlist
);
926 write_unlock(&dn_fib_tables_lock
);