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/string.h>
21 #include <linux/net.h>
22 #include <linux/socket.h>
23 #include <linux/sockios.h>
24 #include <linux/init.h>
25 #include <linux/skbuff.h>
26 #include <linux/netlink.h>
27 #include <linux/rtnetlink.h>
28 #include <linux/proc_fs.h>
29 #include <linux/netdevice.h>
30 #include <linux/timer.h>
31 #include <linux/spinlock.h>
32 #include <asm/atomic.h>
33 #include <asm/uaccess.h>
34 #include <net/neighbour.h>
37 #include <net/fib_rules.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 static DEFINE_SPINLOCK(dn_fib_multipath_lock
);
59 static struct dn_fib_info
*dn_fib_info_list
;
60 static DEFINE_SPINLOCK(dn_fib_info_lock
);
66 } dn_fib_props
[RTN_MAX
+1] = {
67 [RTN_UNSPEC
] = { .error
= 0, .scope
= RT_SCOPE_NOWHERE
},
68 [RTN_UNICAST
] = { .error
= 0, .scope
= RT_SCOPE_UNIVERSE
},
69 [RTN_LOCAL
] = { .error
= 0, .scope
= RT_SCOPE_HOST
},
70 [RTN_BROADCAST
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_NOWHERE
},
71 [RTN_ANYCAST
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_NOWHERE
},
72 [RTN_MULTICAST
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_NOWHERE
},
73 [RTN_BLACKHOLE
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_UNIVERSE
},
74 [RTN_UNREACHABLE
] = { .error
= -EHOSTUNREACH
, .scope
= RT_SCOPE_UNIVERSE
},
75 [RTN_PROHIBIT
] = { .error
= -EACCES
, .scope
= RT_SCOPE_UNIVERSE
},
76 [RTN_THROW
] = { .error
= -EAGAIN
, .scope
= RT_SCOPE_UNIVERSE
},
77 [RTN_NAT
] = { .error
= 0, .scope
= RT_SCOPE_NOWHERE
},
78 [RTN_XRESOLVE
] = { .error
= -EINVAL
, .scope
= RT_SCOPE_NOWHERE
},
81 static int dn_fib_sync_down(__le16 local
, struct net_device
*dev
, int force
);
82 static int dn_fib_sync_up(struct net_device
*dev
);
84 void dn_fib_free_info(struct dn_fib_info
*fi
)
86 if (fi
->fib_dead
== 0) {
87 printk(KERN_DEBUG
"DECnet: BUG! Attempt to free alive dn_fib_info\n");
95 } endfor_nexthops(fi
);
99 void dn_fib_release_info(struct dn_fib_info
*fi
)
101 spin_lock(&dn_fib_info_lock
);
102 if (fi
&& --fi
->fib_treeref
== 0) {
104 fi
->fib_next
->fib_prev
= fi
->fib_prev
;
106 fi
->fib_prev
->fib_next
= fi
->fib_next
;
107 if (fi
== dn_fib_info_list
)
108 dn_fib_info_list
= fi
->fib_next
;
112 spin_unlock(&dn_fib_info_lock
);
115 static inline int dn_fib_nh_comp(const struct dn_fib_info
*fi
, const struct dn_fib_info
*ofi
)
117 const struct dn_fib_nh
*onh
= ofi
->fib_nh
;
120 if (nh
->nh_oif
!= onh
->nh_oif
||
121 nh
->nh_gw
!= onh
->nh_gw
||
122 nh
->nh_scope
!= onh
->nh_scope
||
123 nh
->nh_weight
!= onh
->nh_weight
||
124 ((nh
->nh_flags
^onh
->nh_flags
)&~RTNH_F_DEAD
))
127 } endfor_nexthops(fi
);
131 static inline struct dn_fib_info
*dn_fib_find_info(const struct dn_fib_info
*nfi
)
134 if (fi
->fib_nhs
!= nfi
->fib_nhs
)
136 if (nfi
->fib_protocol
== fi
->fib_protocol
&&
137 nfi
->fib_prefsrc
== fi
->fib_prefsrc
&&
138 nfi
->fib_priority
== fi
->fib_priority
&&
139 memcmp(nfi
->fib_metrics
, fi
->fib_metrics
, sizeof(fi
->fib_metrics
)) == 0 &&
140 ((nfi
->fib_flags
^fi
->fib_flags
)&~RTNH_F_DEAD
) == 0 &&
141 (nfi
->fib_nhs
== 0 || dn_fib_nh_comp(fi
, nfi
) == 0))
147 __le16
dn_fib_get_attr16(struct rtattr
*attr
, int attrlen
, int type
)
149 while(RTA_OK(attr
,attrlen
)) {
150 if (attr
->rta_type
== type
)
151 return *(__le16
*)RTA_DATA(attr
);
152 attr
= RTA_NEXT(attr
, attrlen
);
158 static int dn_fib_count_nhs(struct rtattr
*rta
)
161 struct rtnexthop
*nhp
= RTA_DATA(rta
);
162 int nhlen
= RTA_PAYLOAD(rta
);
164 while(nhlen
>= (int)sizeof(struct rtnexthop
)) {
165 if ((nhlen
-= nhp
->rtnh_len
) < 0)
168 nhp
= RTNH_NEXT(nhp
);
174 static int dn_fib_get_nhs(struct dn_fib_info
*fi
, const struct rtattr
*rta
, const struct rtmsg
*r
)
176 struct rtnexthop
*nhp
= RTA_DATA(rta
);
177 int nhlen
= RTA_PAYLOAD(rta
);
179 change_nexthops(fi
) {
180 int attrlen
= nhlen
- sizeof(struct rtnexthop
);
181 if (attrlen
< 0 || (nhlen
-= nhp
->rtnh_len
) < 0)
184 nh
->nh_flags
= (r
->rtm_flags
&~0xFF) | nhp
->rtnh_flags
;
185 nh
->nh_oif
= nhp
->rtnh_ifindex
;
186 nh
->nh_weight
= nhp
->rtnh_hops
+ 1;
189 nh
->nh_gw
= dn_fib_get_attr16(RTNH_DATA(nhp
), attrlen
, RTA_GATEWAY
);
191 nhp
= RTNH_NEXT(nhp
);
192 } endfor_nexthops(fi
);
198 static int dn_fib_check_nh(const struct rtmsg
*r
, struct dn_fib_info
*fi
, struct dn_fib_nh
*nh
)
204 struct dn_fib_res res
;
206 if (nh
->nh_flags
&RTNH_F_ONLINK
) {
207 struct net_device
*dev
;
209 if (r
->rtm_scope
>= RT_SCOPE_LINK
)
211 if (dnet_addr_type(nh
->nh_gw
) != RTN_UNICAST
)
213 if ((dev
= __dev_get_by_index(&init_net
, nh
->nh_oif
)) == NULL
)
215 if (!(dev
->flags
&IFF_UP
))
219 nh
->nh_scope
= RT_SCOPE_LINK
;
223 memset(&fl
, 0, sizeof(fl
));
224 fl
.fld_dst
= nh
->nh_gw
;
226 fl
.fld_scope
= r
->rtm_scope
+ 1;
228 if (fl
.fld_scope
< RT_SCOPE_LINK
)
229 fl
.fld_scope
= RT_SCOPE_LINK
;
231 if ((err
= dn_fib_lookup(&fl
, &res
)) != 0)
235 if (res
.type
!= RTN_UNICAST
&& res
.type
!= RTN_LOCAL
)
237 nh
->nh_scope
= res
.scope
;
238 nh
->nh_oif
= DN_FIB_RES_OIF(res
);
239 nh
->nh_dev
= DN_FIB_RES_DEV(res
);
240 if (nh
->nh_dev
== NULL
)
242 dev_hold(nh
->nh_dev
);
244 if (!(nh
->nh_dev
->flags
& IFF_UP
))
248 dn_fib_res_put(&res
);
251 struct net_device
*dev
;
253 if (nh
->nh_flags
&(RTNH_F_PERVASIVE
|RTNH_F_ONLINK
))
256 dev
= __dev_get_by_index(&init_net
, nh
->nh_oif
);
257 if (dev
== NULL
|| dev
->dn_ptr
== NULL
)
259 if (!(dev
->flags
&IFF_UP
))
262 dev_hold(nh
->nh_dev
);
263 nh
->nh_scope
= RT_SCOPE_HOST
;
270 struct dn_fib_info
*dn_fib_create_info(const struct rtmsg
*r
, struct dn_kern_rta
*rta
, const struct nlmsghdr
*nlh
, int *errp
)
273 struct dn_fib_info
*fi
= NULL
;
274 struct dn_fib_info
*ofi
;
277 if (r
->rtm_type
> RTN_MAX
)
280 if (dn_fib_props
[r
->rtm_type
].scope
> r
->rtm_scope
)
284 nhs
= dn_fib_count_nhs(rta
->rta_mp
);
289 fi
= kzalloc(sizeof(*fi
)+nhs
*sizeof(struct dn_fib_nh
), GFP_KERNEL
);
294 fi
->fib_protocol
= r
->rtm_protocol
;
296 fi
->fib_flags
= r
->rtm_flags
;
297 if (rta
->rta_priority
)
298 fi
->fib_priority
= *rta
->rta_priority
;
300 int attrlen
= RTA_PAYLOAD(rta
->rta_mx
);
301 struct rtattr
*attr
= RTA_DATA(rta
->rta_mx
);
303 while(RTA_OK(attr
, attrlen
)) {
304 unsigned flavour
= attr
->rta_type
;
306 if (flavour
> RTAX_MAX
)
308 fi
->fib_metrics
[flavour
-1] = *(unsigned*)RTA_DATA(attr
);
310 attr
= RTA_NEXT(attr
, attrlen
);
313 if (rta
->rta_prefsrc
)
314 memcpy(&fi
->fib_prefsrc
, rta
->rta_prefsrc
, 2);
317 if ((err
= dn_fib_get_nhs(fi
, rta
->rta_mp
, r
)) != 0)
319 if (rta
->rta_oif
&& fi
->fib_nh
->nh_oif
!= *rta
->rta_oif
)
321 if (rta
->rta_gw
&& memcmp(&fi
->fib_nh
->nh_gw
, rta
->rta_gw
, 2))
324 struct dn_fib_nh
*nh
= fi
->fib_nh
;
326 nh
->nh_oif
= *rta
->rta_oif
;
328 memcpy(&nh
->nh_gw
, rta
->rta_gw
, 2);
329 nh
->nh_flags
= r
->rtm_flags
;
333 if (r
->rtm_type
== RTN_NAT
) {
334 if (rta
->rta_gw
== NULL
|| nhs
!= 1 || rta
->rta_oif
)
336 memcpy(&fi
->fib_nh
->nh_gw
, rta
->rta_gw
, 2);
340 if (dn_fib_props
[r
->rtm_type
].error
) {
341 if (rta
->rta_gw
|| rta
->rta_oif
|| rta
->rta_mp
)
346 if (r
->rtm_scope
> RT_SCOPE_HOST
)
349 if (r
->rtm_scope
== RT_SCOPE_HOST
) {
350 struct dn_fib_nh
*nh
= fi
->fib_nh
;
352 /* Local address is added */
353 if (nhs
!= 1 || nh
->nh_gw
)
355 nh
->nh_scope
= RT_SCOPE_NOWHERE
;
356 nh
->nh_dev
= dev_get_by_index(&init_net
, fi
->fib_nh
->nh_oif
);
358 if (nh
->nh_dev
== NULL
)
361 change_nexthops(fi
) {
362 if ((err
= dn_fib_check_nh(r
, fi
, nh
)) != 0)
364 } endfor_nexthops(fi
)
367 if (fi
->fib_prefsrc
) {
368 if (r
->rtm_type
!= RTN_LOCAL
|| rta
->rta_dst
== NULL
||
369 memcmp(&fi
->fib_prefsrc
, rta
->rta_dst
, 2))
370 if (dnet_addr_type(fi
->fib_prefsrc
) != RTN_LOCAL
)
375 if ((ofi
= dn_fib_find_info(fi
)) != NULL
) {
377 dn_fib_free_info(fi
);
383 atomic_inc(&fi
->fib_clntref
);
384 spin_lock(&dn_fib_info_lock
);
385 fi
->fib_next
= dn_fib_info_list
;
387 if (dn_fib_info_list
)
388 dn_fib_info_list
->fib_prev
= fi
;
389 dn_fib_info_list
= fi
;
390 spin_unlock(&dn_fib_info_lock
);
400 dn_fib_free_info(fi
);
406 int dn_fib_semantic_match(int type
, struct dn_fib_info
*fi
, const struct flowi
*fl
, struct dn_fib_res
*res
)
408 int err
= dn_fib_props
[type
].error
;
411 if (fi
->fib_flags
& RTNH_F_DEAD
)
418 DN_FIB_RES_RESET(*res
);
419 atomic_inc(&fi
->fib_clntref
);
424 if (nh
->nh_flags
& RTNH_F_DEAD
)
426 if (!fl
->oif
|| fl
->oif
== nh
->nh_oif
)
429 if (nhsel
< fi
->fib_nhs
) {
431 atomic_inc(&fi
->fib_clntref
);
439 printk("DECnet: impossible routing event : dn_fib_semantic_match type=%d\n", type
);
447 void dn_fib_select_multipath(const struct flowi
*fl
, struct dn_fib_res
*res
)
449 struct dn_fib_info
*fi
= res
->fi
;
452 spin_lock_bh(&dn_fib_multipath_lock
);
453 if (fi
->fib_power
<= 0) {
455 change_nexthops(fi
) {
456 if (!(nh
->nh_flags
&RTNH_F_DEAD
)) {
457 power
+= nh
->nh_weight
;
458 nh
->nh_power
= nh
->nh_weight
;
460 } endfor_nexthops(fi
);
461 fi
->fib_power
= power
;
463 spin_unlock_bh(&dn_fib_multipath_lock
);
469 w
= jiffies
% fi
->fib_power
;
471 change_nexthops(fi
) {
472 if (!(nh
->nh_flags
&RTNH_F_DEAD
) && nh
->nh_power
) {
473 if ((w
-= nh
->nh_power
) <= 0) {
477 spin_unlock_bh(&dn_fib_multipath_lock
);
481 } endfor_nexthops(fi
);
483 spin_unlock_bh(&dn_fib_multipath_lock
);
487 static int dn_fib_check_attr(struct rtmsg
*r
, struct rtattr
**rta
)
491 for(i
= 1; i
<= RTA_MAX
; i
++) {
492 struct rtattr
*attr
= rta
[i
-1];
494 if (RTA_PAYLOAD(attr
) < 4 && RTA_PAYLOAD(attr
) != 2)
496 if (i
!= RTA_MULTIPATH
&& i
!= RTA_METRICS
&&
498 rta
[i
-1] = (struct rtattr
*)RTA_DATA(attr
);
505 static int dn_fib_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
507 struct net
*net
= sock_net(skb
->sk
);
508 struct dn_fib_table
*tb
;
509 struct rtattr
**rta
= arg
;
510 struct rtmsg
*r
= NLMSG_DATA(nlh
);
512 if (net
!= &init_net
)
515 if (dn_fib_check_attr(r
, rta
))
518 tb
= dn_fib_get_table(rtm_get_table(rta
, r
->rtm_table
), 0);
520 return tb
->delete(tb
, r
, (struct dn_kern_rta
*)rta
, nlh
, &NETLINK_CB(skb
));
525 static int dn_fib_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
527 struct net
*net
= sock_net(skb
->sk
);
528 struct dn_fib_table
*tb
;
529 struct rtattr
**rta
= arg
;
530 struct rtmsg
*r
= NLMSG_DATA(nlh
);
532 if (net
!= &init_net
)
535 if (dn_fib_check_attr(r
, rta
))
538 tb
= dn_fib_get_table(rtm_get_table(rta
, r
->rtm_table
), 1);
540 return tb
->insert(tb
, r
, (struct dn_kern_rta
*)rta
, nlh
, &NETLINK_CB(skb
));
545 static void fib_magic(int cmd
, int type
, __le16 dst
, int dst_len
, struct dn_ifaddr
*ifa
)
547 struct dn_fib_table
*tb
;
552 struct dn_kern_rta rta
;
554 memset(&req
.rtm
, 0, sizeof(req
.rtm
));
555 memset(&rta
, 0, sizeof(rta
));
557 if (type
== RTN_UNICAST
)
558 tb
= dn_fib_get_table(RT_MIN_TABLE
, 1);
560 tb
= dn_fib_get_table(RT_TABLE_LOCAL
, 1);
565 req
.nlh
.nlmsg_len
= sizeof(req
);
566 req
.nlh
.nlmsg_type
= cmd
;
567 req
.nlh
.nlmsg_flags
= NLM_F_REQUEST
|NLM_F_CREATE
|NLM_F_APPEND
;
568 req
.nlh
.nlmsg_pid
= 0;
569 req
.nlh
.nlmsg_seq
= 0;
571 req
.rtm
.rtm_dst_len
= dst_len
;
572 req
.rtm
.rtm_table
= tb
->n
;
573 req
.rtm
.rtm_protocol
= RTPROT_KERNEL
;
574 req
.rtm
.rtm_scope
= (type
!= RTN_LOCAL
? RT_SCOPE_LINK
: RT_SCOPE_HOST
);
575 req
.rtm
.rtm_type
= type
;
578 rta
.rta_prefsrc
= &ifa
->ifa_local
;
579 rta
.rta_oif
= &ifa
->ifa_dev
->dev
->ifindex
;
581 if (cmd
== RTM_NEWROUTE
)
582 tb
->insert(tb
, &req
.rtm
, &rta
, &req
.nlh
, NULL
);
584 tb
->delete(tb
, &req
.rtm
, &rta
, &req
.nlh
, NULL
);
587 static void dn_fib_add_ifaddr(struct dn_ifaddr
*ifa
)
590 fib_magic(RTM_NEWROUTE
, RTN_LOCAL
, ifa
->ifa_local
, 16, ifa
);
593 if (!(dev
->flags
&IFF_UP
))
595 /* In the future, we will want to add default routes here */
600 static void dn_fib_del_ifaddr(struct dn_ifaddr
*ifa
)
603 struct net_device
*dev
;
604 struct dn_dev
*dn_db
;
605 struct dn_ifaddr
*ifa2
;
609 /* Scan device list */
611 for_each_netdev_rcu(&init_net
, dev
) {
615 for(ifa2
= dn_db
->ifa_list
; ifa2
; ifa2
= ifa2
->ifa_next
) {
616 if (ifa2
->ifa_local
== ifa
->ifa_local
) {
625 fib_magic(RTM_DELROUTE
, RTN_LOCAL
, ifa
->ifa_local
, 16, ifa
);
627 if (dnet_addr_type(ifa
->ifa_local
) != RTN_LOCAL
) {
628 if (dn_fib_sync_down(ifa
->ifa_local
, NULL
, 0))
634 static void dn_fib_disable_addr(struct net_device
*dev
, int force
)
636 if (dn_fib_sync_down(0, dev
, force
))
638 dn_rt_cache_flush(0);
639 neigh_ifdown(&dn_neigh_table
, dev
);
642 static int dn_fib_dnaddr_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
644 struct dn_ifaddr
*ifa
= (struct dn_ifaddr
*)ptr
;
648 dn_fib_add_ifaddr(ifa
);
649 dn_fib_sync_up(ifa
->ifa_dev
->dev
);
650 dn_rt_cache_flush(-1);
653 dn_fib_del_ifaddr(ifa
);
654 if (ifa
->ifa_dev
&& ifa
->ifa_dev
->ifa_list
== NULL
) {
655 dn_fib_disable_addr(ifa
->ifa_dev
->dev
, 1);
657 dn_rt_cache_flush(-1);
664 static int dn_fib_sync_down(__le16 local
, struct net_device
*dev
, int force
)
667 int scope
= RT_SCOPE_NOWHERE
;
674 * This makes no sense for DECnet.... we will almost
675 * certainly have more than one local address the same
676 * over all our interfaces. It needs thinking about
679 if (local
&& fi
->fib_prefsrc
== local
) {
680 fi
->fib_flags
|= RTNH_F_DEAD
;
682 } else if (dev
&& fi
->fib_nhs
) {
685 change_nexthops(fi
) {
686 if (nh
->nh_flags
&RTNH_F_DEAD
)
688 else if (nh
->nh_dev
== dev
&&
689 nh
->nh_scope
!= scope
) {
690 spin_lock_bh(&dn_fib_multipath_lock
);
691 nh
->nh_flags
|= RTNH_F_DEAD
;
692 fi
->fib_power
-= nh
->nh_power
;
694 spin_unlock_bh(&dn_fib_multipath_lock
);
697 } endfor_nexthops(fi
)
698 if (dead
== fi
->fib_nhs
) {
699 fi
->fib_flags
|= RTNH_F_DEAD
;
708 static int dn_fib_sync_up(struct net_device
*dev
)
712 if (!(dev
->flags
&IFF_UP
))
718 change_nexthops(fi
) {
719 if (!(nh
->nh_flags
&RTNH_F_DEAD
)) {
723 if (nh
->nh_dev
== NULL
|| !(nh
->nh_dev
->flags
&IFF_UP
))
725 if (nh
->nh_dev
!= dev
|| dev
->dn_ptr
== NULL
)
728 spin_lock_bh(&dn_fib_multipath_lock
);
730 nh
->nh_flags
&= ~RTNH_F_DEAD
;
731 spin_unlock_bh(&dn_fib_multipath_lock
);
732 } endfor_nexthops(fi
);
735 fi
->fib_flags
&= ~RTNH_F_DEAD
;
742 static struct notifier_block dn_fib_dnaddr_notifier
= {
743 .notifier_call
= dn_fib_dnaddr_event
,
746 void __exit
dn_fib_cleanup(void)
748 dn_fib_table_cleanup();
749 dn_fib_rules_cleanup();
751 unregister_dnaddr_notifier(&dn_fib_dnaddr_notifier
);
755 void __init
dn_fib_init(void)
760 register_dnaddr_notifier(&dn_fib_dnaddr_notifier
);
762 rtnl_register(PF_DECnet
, RTM_NEWROUTE
, dn_fib_rtm_newroute
, NULL
);
763 rtnl_register(PF_DECnet
, RTM_DELROUTE
, dn_fib_rtm_delroute
, NULL
);