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 (Glue/Info List)
8 * Author: Steve Whitehouse <SteveW@ACM.org>
12 * Alexey Kuznetsov : SMP locking changes
13 * Steve Whitehouse : Rewrote it... Well to be more correct, I
14 * copied most of it from the ipv4 fib code.
15 * Steve Whitehouse : Updated it in style and fixed a few bugs
16 * which were fixed in the ipv4 code since
17 * this code was copied from it.
20 #include <linux/config.h>
21 #include <linux/string.h>
22 #include <linux/net.h>
23 #include <linux/socket.h>
24 #include <linux/sockios.h>
25 #include <linux/init.h>
26 #include <linux/skbuff.h>
27 #include <linux/netlink.h>
28 #include <linux/rtnetlink.h>
29 #include <linux/proc_fs.h>
30 #include <linux/netdevice.h>
31 #include <linux/timer.h>
32 #include <linux/spinlock.h>
33 #include <asm/atomic.h>
34 #include <asm/uaccess.h>
35 #include <net/neighbour.h>
39 #include <net/dn_route.h>
40 #include <net/dn_fib.h>
41 #include <net/dn_neigh.h>
42 #include <net/dn_dev.h>
44 #define RT_MIN_TABLE 1
46 #define for_fib_info() { struct dn_fib_info *fi;\
47 for(fi = dn_fib_info_list; fi; fi = fi->fib_next)
48 #define endfor_fib_info() }
50 #define for_nexthops(fi) { int nhsel; const struct dn_fib_nh *nh;\
51 for(nhsel = 0, nh = (fi)->fib_nh; nhsel < (fi)->fib_nhs; nh++, nhsel++)
53 #define change_nexthops(fi) { int nhsel; struct dn_fib_nh *nh;\
54 for(nhsel = 0, nh = (struct dn_fib_nh *)((fi)->fib_nh); nhsel < (fi)->fib_nhs; nh++, nhsel++)
56 #define endfor_nexthops(fi) }
58 extern int dn_cache_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
);
60 static DEFINE_SPINLOCK(dn_fib_multipath_lock
);
61 static struct dn_fib_info
*dn_fib_info_list
;
62 static DEFINE_RWLOCK(dn_fib_info_lock
);
68 } dn_fib_props
[RTA_MAX
+1] = {
69 [RTN_UNSPEC
] = { .error
= 0, .scope
= RT_SCOPE_NOWHERE
},
70 [RTN_UNICAST
] = { .error
= 0, .scope
= RT_SCOPE_UNIVERSE
},
71 [RTN_LOCAL
] = { .error
= 0, .scope
= RT_SCOPE_HOST
},
72 [RTN_BROADCAST
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_NOWHERE
},
73 [RTN_ANYCAST
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_NOWHERE
},
74 [RTN_MULTICAST
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_NOWHERE
},
75 [RTN_BLACKHOLE
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_UNIVERSE
},
76 [RTN_UNREACHABLE
] = { .error
= -EHOSTUNREACH
, .scope
= RT_SCOPE_UNIVERSE
},
77 [RTN_PROHIBIT
] = { .error
= -EACCES
, .scope
= RT_SCOPE_UNIVERSE
},
78 [RTN_THROW
] = { .error
= -EAGAIN
, .scope
= RT_SCOPE_UNIVERSE
},
79 [RTN_NAT
] = { .error
= 0, .scope
= RT_SCOPE_NOWHERE
},
80 [RTN_XRESOLVE
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_NOWHERE
},
83 void dn_fib_free_info(struct dn_fib_info
*fi
)
85 if (fi
->fib_dead
== 0) {
86 printk(KERN_DEBUG
"DECnet: BUG! Attempt to free alive dn_fib_info\n");
94 } endfor_nexthops(fi
);
98 void dn_fib_release_info(struct dn_fib_info
*fi
)
100 write_lock(&dn_fib_info_lock
);
101 if (fi
&& --fi
->fib_treeref
== 0) {
103 fi
->fib_next
->fib_prev
= fi
->fib_prev
;
105 fi
->fib_prev
->fib_next
= fi
->fib_next
;
106 if (fi
== dn_fib_info_list
)
107 dn_fib_info_list
= fi
->fib_next
;
111 write_unlock(&dn_fib_info_lock
);
114 static inline int dn_fib_nh_comp(const struct dn_fib_info
*fi
, const struct dn_fib_info
*ofi
)
116 const struct dn_fib_nh
*onh
= ofi
->fib_nh
;
119 if (nh
->nh_oif
!= onh
->nh_oif
||
120 nh
->nh_gw
!= onh
->nh_gw
||
121 nh
->nh_scope
!= onh
->nh_scope
||
122 nh
->nh_weight
!= onh
->nh_weight
||
123 ((nh
->nh_flags
^onh
->nh_flags
)&~RTNH_F_DEAD
))
126 } endfor_nexthops(fi
);
130 static inline struct dn_fib_info
*dn_fib_find_info(const struct dn_fib_info
*nfi
)
133 if (fi
->fib_nhs
!= nfi
->fib_nhs
)
135 if (nfi
->fib_protocol
== fi
->fib_protocol
&&
136 nfi
->fib_prefsrc
== fi
->fib_prefsrc
&&
137 nfi
->fib_priority
== fi
->fib_priority
&&
138 memcmp(nfi
->fib_metrics
, fi
->fib_metrics
, sizeof(fi
->fib_metrics
)) == 0 &&
139 ((nfi
->fib_flags
^fi
->fib_flags
)&~RTNH_F_DEAD
) == 0 &&
140 (nfi
->fib_nhs
== 0 || dn_fib_nh_comp(fi
, nfi
) == 0))
146 __le16
dn_fib_get_attr16(struct rtattr
*attr
, int attrlen
, int type
)
148 while(RTA_OK(attr
,attrlen
)) {
149 if (attr
->rta_type
== type
)
150 return *(__le16
*)RTA_DATA(attr
);
151 attr
= RTA_NEXT(attr
, attrlen
);
157 static int dn_fib_count_nhs(struct rtattr
*rta
)
160 struct rtnexthop
*nhp
= RTA_DATA(rta
);
161 int nhlen
= RTA_PAYLOAD(rta
);
163 while(nhlen
>= (int)sizeof(struct rtnexthop
)) {
164 if ((nhlen
-= nhp
->rtnh_len
) < 0)
167 nhp
= RTNH_NEXT(nhp
);
173 static int dn_fib_get_nhs(struct dn_fib_info
*fi
, const struct rtattr
*rta
, const struct rtmsg
*r
)
175 struct rtnexthop
*nhp
= RTA_DATA(rta
);
176 int nhlen
= RTA_PAYLOAD(rta
);
178 change_nexthops(fi
) {
179 int attrlen
= nhlen
- sizeof(struct rtnexthop
);
180 if (attrlen
< 0 || (nhlen
-= nhp
->rtnh_len
) < 0)
183 nh
->nh_flags
= (r
->rtm_flags
&~0xFF) | nhp
->rtnh_flags
;
184 nh
->nh_oif
= nhp
->rtnh_ifindex
;
185 nh
->nh_weight
= nhp
->rtnh_hops
+ 1;
188 nh
->nh_gw
= dn_fib_get_attr16(RTNH_DATA(nhp
), attrlen
, RTA_GATEWAY
);
190 nhp
= RTNH_NEXT(nhp
);
191 } endfor_nexthops(fi
);
197 static int dn_fib_check_nh(const struct rtmsg
*r
, struct dn_fib_info
*fi
, struct dn_fib_nh
*nh
)
203 struct dn_fib_res res
;
205 memset(&fl
, 0, sizeof(fl
));
207 if (nh
->nh_flags
&RTNH_F_ONLINK
) {
208 struct net_device
*dev
;
210 if (r
->rtm_scope
>= RT_SCOPE_LINK
)
212 if (dnet_addr_type(nh
->nh_gw
) != RTN_UNICAST
)
214 if ((dev
= __dev_get_by_index(nh
->nh_oif
)) == NULL
)
216 if (!(dev
->flags
&IFF_UP
))
220 nh
->nh_scope
= RT_SCOPE_LINK
;
224 memset(&fl
, 0, sizeof(fl
));
225 fl
.fld_dst
= nh
->nh_gw
;
227 fl
.fld_scope
= r
->rtm_scope
+ 1;
229 if (fl
.fld_scope
< RT_SCOPE_LINK
)
230 fl
.fld_scope
= RT_SCOPE_LINK
;
232 if ((err
= dn_fib_lookup(&fl
, &res
)) != 0)
236 if (res
.type
!= RTN_UNICAST
&& res
.type
!= RTN_LOCAL
)
238 nh
->nh_scope
= res
.scope
;
239 nh
->nh_oif
= DN_FIB_RES_OIF(res
);
240 nh
->nh_dev
= DN_FIB_RES_DEV(res
);
241 if (nh
->nh_dev
== NULL
)
243 dev_hold(nh
->nh_dev
);
245 if (!(nh
->nh_dev
->flags
& IFF_UP
))
249 dn_fib_res_put(&res
);
252 struct net_device
*dev
;
254 if (nh
->nh_flags
&(RTNH_F_PERVASIVE
|RTNH_F_ONLINK
))
257 dev
= __dev_get_by_index(nh
->nh_oif
);
258 if (dev
== NULL
|| dev
->dn_ptr
== NULL
)
260 if (!(dev
->flags
&IFF_UP
))
263 dev_hold(nh
->nh_dev
);
264 nh
->nh_scope
= RT_SCOPE_HOST
;
271 struct dn_fib_info
*dn_fib_create_info(const struct rtmsg
*r
, struct dn_kern_rta
*rta
, const struct nlmsghdr
*nlh
, int *errp
)
274 struct dn_fib_info
*fi
= NULL
;
275 struct dn_fib_info
*ofi
;
278 if (dn_fib_props
[r
->rtm_type
].scope
> r
->rtm_scope
)
282 nhs
= dn_fib_count_nhs(rta
->rta_mp
);
287 fi
= kmalloc(sizeof(*fi
)+nhs
*sizeof(struct dn_fib_nh
), GFP_KERNEL
);
291 memset(fi
, 0, sizeof(*fi
)+nhs
*sizeof(struct dn_fib_nh
));
293 fi
->fib_protocol
= r
->rtm_protocol
;
295 fi
->fib_flags
= r
->rtm_flags
;
296 if (rta
->rta_priority
)
297 fi
->fib_priority
= *rta
->rta_priority
;
299 int attrlen
= RTA_PAYLOAD(rta
->rta_mx
);
300 struct rtattr
*attr
= RTA_DATA(rta
->rta_mx
);
302 while(RTA_OK(attr
, attrlen
)) {
303 unsigned flavour
= attr
->rta_type
;
305 if (flavour
> RTAX_MAX
)
307 fi
->fib_metrics
[flavour
-1] = *(unsigned*)RTA_DATA(attr
);
309 attr
= RTA_NEXT(attr
, attrlen
);
312 if (rta
->rta_prefsrc
)
313 memcpy(&fi
->fib_prefsrc
, rta
->rta_prefsrc
, 2);
316 if ((err
= dn_fib_get_nhs(fi
, rta
->rta_mp
, r
)) != 0)
318 if (rta
->rta_oif
&& fi
->fib_nh
->nh_oif
!= *rta
->rta_oif
)
320 if (rta
->rta_gw
&& memcmp(&fi
->fib_nh
->nh_gw
, rta
->rta_gw
, 2))
323 struct dn_fib_nh
*nh
= fi
->fib_nh
;
325 nh
->nh_oif
= *rta
->rta_oif
;
327 memcpy(&nh
->nh_gw
, rta
->rta_gw
, 2);
328 nh
->nh_flags
= r
->rtm_flags
;
332 if (r
->rtm_type
== RTN_NAT
) {
333 if (rta
->rta_gw
== NULL
|| nhs
!= 1 || rta
->rta_oif
)
335 memcpy(&fi
->fib_nh
->nh_gw
, rta
->rta_gw
, 2);
339 if (dn_fib_props
[r
->rtm_type
].error
) {
340 if (rta
->rta_gw
|| rta
->rta_oif
|| rta
->rta_mp
)
345 if (r
->rtm_scope
> RT_SCOPE_HOST
)
348 if (r
->rtm_scope
== RT_SCOPE_HOST
) {
349 struct dn_fib_nh
*nh
= fi
->fib_nh
;
351 /* Local address is added */
352 if (nhs
!= 1 || nh
->nh_gw
)
354 nh
->nh_scope
= RT_SCOPE_NOWHERE
;
355 nh
->nh_dev
= dev_get_by_index(fi
->fib_nh
->nh_oif
);
357 if (nh
->nh_dev
== NULL
)
360 change_nexthops(fi
) {
361 if ((err
= dn_fib_check_nh(r
, fi
, nh
)) != 0)
363 } endfor_nexthops(fi
)
366 if (fi
->fib_prefsrc
) {
367 if (r
->rtm_type
!= RTN_LOCAL
|| rta
->rta_dst
== NULL
||
368 memcmp(&fi
->fib_prefsrc
, rta
->rta_dst
, 2))
369 if (dnet_addr_type(fi
->fib_prefsrc
) != RTN_LOCAL
)
374 if ((ofi
= dn_fib_find_info(fi
)) != NULL
) {
376 dn_fib_free_info(fi
);
382 atomic_inc(&fi
->fib_clntref
);
383 write_lock(&dn_fib_info_lock
);
384 fi
->fib_next
= dn_fib_info_list
;
386 if (dn_fib_info_list
)
387 dn_fib_info_list
->fib_prev
= fi
;
388 dn_fib_info_list
= fi
;
389 write_unlock(&dn_fib_info_lock
);
399 dn_fib_free_info(fi
);
405 int dn_fib_semantic_match(int type
, struct dn_fib_info
*fi
, const struct flowi
*fl
, struct dn_fib_res
*res
)
407 int err
= dn_fib_props
[type
].error
;
410 if (fi
->fib_flags
& RTNH_F_DEAD
)
417 DN_FIB_RES_RESET(*res
);
418 atomic_inc(&fi
->fib_clntref
);
423 if (nh
->nh_flags
& RTNH_F_DEAD
)
425 if (!fl
->oif
|| fl
->oif
== nh
->nh_oif
)
428 if (nhsel
< fi
->fib_nhs
) {
430 atomic_inc(&fi
->fib_clntref
);
438 printk("DECnet: impossible routing event : dn_fib_semantic_match type=%d\n", type
);
446 void dn_fib_select_multipath(const struct flowi
*fl
, struct dn_fib_res
*res
)
448 struct dn_fib_info
*fi
= res
->fi
;
451 spin_lock_bh(&dn_fib_multipath_lock
);
452 if (fi
->fib_power
<= 0) {
454 change_nexthops(fi
) {
455 if (!(nh
->nh_flags
&RTNH_F_DEAD
)) {
456 power
+= nh
->nh_weight
;
457 nh
->nh_power
= nh
->nh_weight
;
459 } endfor_nexthops(fi
);
460 fi
->fib_power
= power
;
462 spin_unlock_bh(&dn_fib_multipath_lock
);
468 w
= jiffies
% fi
->fib_power
;
470 change_nexthops(fi
) {
471 if (!(nh
->nh_flags
&RTNH_F_DEAD
) && nh
->nh_power
) {
472 if ((w
-= nh
->nh_power
) <= 0) {
476 spin_unlock_bh(&dn_fib_multipath_lock
);
480 } endfor_nexthops(fi
);
482 spin_unlock_bh(&dn_fib_multipath_lock
);
486 static int dn_fib_check_attr(struct rtmsg
*r
, struct rtattr
**rta
)
490 for(i
= 1; i
<= RTA_MAX
; i
++) {
491 struct rtattr
*attr
= rta
[i
-1];
493 if (RTA_PAYLOAD(attr
) < 4 && RTA_PAYLOAD(attr
) != 2)
495 if (i
!= RTA_MULTIPATH
&& i
!= RTA_METRICS
)
496 rta
[i
-1] = (struct rtattr
*)RTA_DATA(attr
);
503 int dn_fib_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
505 struct dn_fib_table
*tb
;
506 struct rtattr
**rta
= arg
;
507 struct rtmsg
*r
= NLMSG_DATA(nlh
);
509 if (dn_fib_check_attr(r
, rta
))
512 tb
= dn_fib_get_table(r
->rtm_table
, 0);
514 return tb
->delete(tb
, r
, (struct dn_kern_rta
*)rta
, nlh
, &NETLINK_CB(skb
));
519 int dn_fib_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
521 struct dn_fib_table
*tb
;
522 struct rtattr
**rta
= arg
;
523 struct rtmsg
*r
= NLMSG_DATA(nlh
);
525 if (dn_fib_check_attr(r
, rta
))
528 tb
= dn_fib_get_table(r
->rtm_table
, 1);
530 return tb
->insert(tb
, r
, (struct dn_kern_rta
*)rta
, nlh
, &NETLINK_CB(skb
));
536 int dn_fib_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
540 struct dn_fib_table
*tb
;
542 if (NLMSG_PAYLOAD(cb
->nlh
, 0) >= sizeof(struct rtmsg
) &&
543 ((struct rtmsg
*)NLMSG_DATA(cb
->nlh
))->rtm_flags
&RTM_F_CLONED
)
544 return dn_cache_dump(skb
, cb
);
548 s_t
= cb
->args
[0] = RT_MIN_TABLE
;
550 for(t
= s_t
; t
<= RT_TABLE_MAX
; t
++) {
554 memset(&cb
->args
[1], 0,
555 sizeof(cb
->args
) - sizeof(cb
->args
[0]));
556 tb
= dn_fib_get_table(t
, 0);
559 if (tb
->dump(tb
, skb
, cb
) < 0)
568 static void fib_magic(int cmd
, int type
, __le16 dst
, int dst_len
, struct dn_ifaddr
*ifa
)
570 struct dn_fib_table
*tb
;
575 struct dn_kern_rta rta
;
577 memset(&req
.rtm
, 0, sizeof(req
.rtm
));
578 memset(&rta
, 0, sizeof(rta
));
580 if (type
== RTN_UNICAST
)
581 tb
= dn_fib_get_table(RT_MIN_TABLE
, 1);
583 tb
= dn_fib_get_table(RT_TABLE_LOCAL
, 1);
588 req
.nlh
.nlmsg_len
= sizeof(req
);
589 req
.nlh
.nlmsg_type
= cmd
;
590 req
.nlh
.nlmsg_flags
= NLM_F_REQUEST
|NLM_F_CREATE
|NLM_F_APPEND
;
591 req
.nlh
.nlmsg_pid
= 0;
592 req
.nlh
.nlmsg_seq
= 0;
594 req
.rtm
.rtm_dst_len
= dst_len
;
595 req
.rtm
.rtm_table
= tb
->n
;
596 req
.rtm
.rtm_protocol
= RTPROT_KERNEL
;
597 req
.rtm
.rtm_scope
= (type
!= RTN_LOCAL
? RT_SCOPE_LINK
: RT_SCOPE_HOST
);
598 req
.rtm
.rtm_type
= type
;
601 rta
.rta_prefsrc
= &ifa
->ifa_local
;
602 rta
.rta_oif
= &ifa
->ifa_dev
->dev
->ifindex
;
604 if (cmd
== RTM_NEWROUTE
)
605 tb
->insert(tb
, &req
.rtm
, &rta
, &req
.nlh
, NULL
);
607 tb
->delete(tb
, &req
.rtm
, &rta
, &req
.nlh
, NULL
);
610 static void dn_fib_add_ifaddr(struct dn_ifaddr
*ifa
)
613 fib_magic(RTM_NEWROUTE
, RTN_LOCAL
, ifa
->ifa_local
, 16, ifa
);
616 if (!(dev
->flags
&IFF_UP
))
618 /* In the future, we will want to add default routes here */
623 static void dn_fib_del_ifaddr(struct dn_ifaddr
*ifa
)
626 struct net_device
*dev
;
627 struct dn_dev
*dn_db
;
628 struct dn_ifaddr
*ifa2
;
632 /* Scan device list */
633 read_lock(&dev_base_lock
);
634 for(dev
= dev_base
; dev
; dev
= dev
->next
) {
638 for(ifa2
= dn_db
->ifa_list
; ifa2
; ifa2
= ifa2
->ifa_next
) {
639 if (ifa2
->ifa_local
== ifa
->ifa_local
) {
645 read_unlock(&dev_base_lock
);
648 fib_magic(RTM_DELROUTE
, RTN_LOCAL
, ifa
->ifa_local
, 16, ifa
);
650 if (dnet_addr_type(ifa
->ifa_local
) != RTN_LOCAL
) {
651 if (dn_fib_sync_down(ifa
->ifa_local
, NULL
, 0))
657 static void dn_fib_disable_addr(struct net_device
*dev
, int force
)
659 if (dn_fib_sync_down(0, dev
, force
))
661 dn_rt_cache_flush(0);
662 neigh_ifdown(&dn_neigh_table
, dev
);
665 static int dn_fib_dnaddr_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
667 struct dn_ifaddr
*ifa
= (struct dn_ifaddr
*)ptr
;
671 dn_fib_add_ifaddr(ifa
);
672 dn_fib_sync_up(ifa
->ifa_dev
->dev
);
673 dn_rt_cache_flush(-1);
676 dn_fib_del_ifaddr(ifa
);
677 if (ifa
->ifa_dev
&& ifa
->ifa_dev
->ifa_list
== NULL
) {
678 dn_fib_disable_addr(ifa
->ifa_dev
->dev
, 1);
680 dn_rt_cache_flush(-1);
687 int dn_fib_sync_down(__le16 local
, struct net_device
*dev
, int force
)
690 int scope
= RT_SCOPE_NOWHERE
;
697 * This makes no sense for DECnet.... we will almost
698 * certainly have more than one local address the same
699 * over all our interfaces. It needs thinking about
702 if (local
&& fi
->fib_prefsrc
== local
) {
703 fi
->fib_flags
|= RTNH_F_DEAD
;
705 } else if (dev
&& fi
->fib_nhs
) {
708 change_nexthops(fi
) {
709 if (nh
->nh_flags
&RTNH_F_DEAD
)
711 else if (nh
->nh_dev
== dev
&&
712 nh
->nh_scope
!= scope
) {
713 spin_lock_bh(&dn_fib_multipath_lock
);
714 nh
->nh_flags
|= RTNH_F_DEAD
;
715 fi
->fib_power
-= nh
->nh_power
;
717 spin_unlock_bh(&dn_fib_multipath_lock
);
720 } endfor_nexthops(fi
)
721 if (dead
== fi
->fib_nhs
) {
722 fi
->fib_flags
|= RTNH_F_DEAD
;
731 int dn_fib_sync_up(struct net_device
*dev
)
735 if (!(dev
->flags
&IFF_UP
))
741 change_nexthops(fi
) {
742 if (!(nh
->nh_flags
&RTNH_F_DEAD
)) {
746 if (nh
->nh_dev
== NULL
|| !(nh
->nh_dev
->flags
&IFF_UP
))
748 if (nh
->nh_dev
!= dev
|| dev
->dn_ptr
== NULL
)
751 spin_lock_bh(&dn_fib_multipath_lock
);
753 nh
->nh_flags
&= ~RTNH_F_DEAD
;
754 spin_unlock_bh(&dn_fib_multipath_lock
);
755 } endfor_nexthops(fi
);
758 fi
->fib_flags
&= ~RTNH_F_DEAD
;
765 void dn_fib_flush(void)
768 struct dn_fib_table
*tb
;
771 for(id
= RT_TABLE_MAX
; id
> 0; id
--) {
772 if ((tb
= dn_fib_get_table(id
, 0)) == NULL
)
774 flushed
+= tb
->flush(tb
);
778 dn_rt_cache_flush(-1);
781 static struct notifier_block dn_fib_dnaddr_notifier
= {
782 .notifier_call
= dn_fib_dnaddr_event
,
785 void __exit
dn_fib_cleanup(void)
787 dn_fib_table_cleanup();
788 dn_fib_rules_cleanup();
790 unregister_dnaddr_notifier(&dn_fib_dnaddr_notifier
);
794 void __init
dn_fib_init(void)
800 register_dnaddr_notifier(&dn_fib_dnaddr_notifier
);