Remove obsolete #include <linux/config.h>
[linux-2.6.git] / net / ipv4 / fib_semantics.c
1 /*
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.
5  *
6  *              IPv4 Forwarding Information Base: semantics.
7  *
8  * Version:     $Id: fib_semantics.c,v 1.19 2002/01/12 07:54:56 davem Exp $
9  *
10  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
11  *
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.
16  */
17
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>
23 #include <linux/jiffies.h>
24 #include <linux/mm.h>
25 #include <linux/string.h>
26 #include <linux/socket.h>
27 #include <linux/sockios.h>
28 #include <linux/errno.h>
29 #include <linux/in.h>
30 #include <linux/inet.h>
31 #include <linux/inetdevice.h>
32 #include <linux/netdevice.h>
33 #include <linux/if_arp.h>
34 #include <linux/proc_fs.h>
35 #include <linux/skbuff.h>
36 #include <linux/netlink.h>
37 #include <linux/init.h>
38
39 #include <net/arp.h>
40 #include <net/ip.h>
41 #include <net/protocol.h>
42 #include <net/route.h>
43 #include <net/tcp.h>
44 #include <net/sock.h>
45 #include <net/ip_fib.h>
46 #include <net/ip_mp_alg.h>
47
48 #include "fib_lookup.h"
49
50 #define FSprintk(a...)
51
52 static DEFINE_RWLOCK(fib_info_lock);
53 static struct hlist_head *fib_info_hash;
54 static struct hlist_head *fib_info_laddrhash;
55 static unsigned int fib_hash_size;
56 static unsigned int fib_info_cnt;
57
58 #define DEVINDEX_HASHBITS 8
59 #define DEVINDEX_HASHSIZE (1U << DEVINDEX_HASHBITS)
60 static struct hlist_head fib_info_devhash[DEVINDEX_HASHSIZE];
61
62 #ifdef CONFIG_IP_ROUTE_MULTIPATH
63
64 static DEFINE_SPINLOCK(fib_multipath_lock);
65
66 #define for_nexthops(fi) { int nhsel; const struct fib_nh * nh; \
67 for (nhsel=0, nh = (fi)->fib_nh; nhsel < (fi)->fib_nhs; nh++, nhsel++)
68
69 #define change_nexthops(fi) { int nhsel; struct fib_nh * nh; \
70 for (nhsel=0, nh = (struct fib_nh*)((fi)->fib_nh); nhsel < (fi)->fib_nhs; nh++, nhsel++)
71
72 #else /* CONFIG_IP_ROUTE_MULTIPATH */
73
74 /* Hope, that gcc will optimize it to get rid of dummy loop */
75
76 #define for_nexthops(fi) { int nhsel=0; const struct fib_nh * nh = (fi)->fib_nh; \
77 for (nhsel=0; nhsel < 1; nhsel++)
78
79 #define change_nexthops(fi) { int nhsel=0; struct fib_nh * nh = (struct fib_nh*)((fi)->fib_nh); \
80 for (nhsel=0; nhsel < 1; nhsel++)
81
82 #endif /* CONFIG_IP_ROUTE_MULTIPATH */
83
84 #define endfor_nexthops(fi) }
85
86
87 static const struct 
88 {
89         int     error;
90         u8      scope;
91 } fib_props[RTA_MAX + 1] = {
92         {
93                 .error  = 0,
94                 .scope  = RT_SCOPE_NOWHERE,
95         },      /* RTN_UNSPEC */
96         {
97                 .error  = 0,
98                 .scope  = RT_SCOPE_UNIVERSE,
99         },      /* RTN_UNICAST */
100         {
101                 .error  = 0,
102                 .scope  = RT_SCOPE_HOST,
103         },      /* RTN_LOCAL */
104         {
105                 .error  = 0,
106                 .scope  = RT_SCOPE_LINK,
107         },      /* RTN_BROADCAST */
108         {
109                 .error  = 0,
110                 .scope  = RT_SCOPE_LINK,
111         },      /* RTN_ANYCAST */
112         {
113                 .error  = 0,
114                 .scope  = RT_SCOPE_UNIVERSE,
115         },      /* RTN_MULTICAST */
116         {
117                 .error  = -EINVAL,
118                 .scope  = RT_SCOPE_UNIVERSE,
119         },      /* RTN_BLACKHOLE */
120         {
121                 .error  = -EHOSTUNREACH,
122                 .scope  = RT_SCOPE_UNIVERSE,
123         },      /* RTN_UNREACHABLE */
124         {
125                 .error  = -EACCES,
126                 .scope  = RT_SCOPE_UNIVERSE,
127         },      /* RTN_PROHIBIT */
128         {
129                 .error  = -EAGAIN,
130                 .scope  = RT_SCOPE_UNIVERSE,
131         },      /* RTN_THROW */
132         {
133                 .error  = -EINVAL,
134                 .scope  = RT_SCOPE_NOWHERE,
135         },      /* RTN_NAT */
136         {
137                 .error  = -EINVAL,
138                 .scope  = RT_SCOPE_NOWHERE,
139         },      /* RTN_XRESOLVE */
140 };
141
142
143 /* Release a nexthop info record */
144
145 void free_fib_info(struct fib_info *fi)
146 {
147         if (fi->fib_dead == 0) {
148                 printk("Freeing alive fib_info %p\n", fi);
149                 return;
150         }
151         change_nexthops(fi) {
152                 if (nh->nh_dev)
153                         dev_put(nh->nh_dev);
154                 nh->nh_dev = NULL;
155         } endfor_nexthops(fi);
156         fib_info_cnt--;
157         kfree(fi);
158 }
159
160 void fib_release_info(struct fib_info *fi)
161 {
162         write_lock(&fib_info_lock);
163         if (fi && --fi->fib_treeref == 0) {
164                 hlist_del(&fi->fib_hash);
165                 if (fi->fib_prefsrc)
166                         hlist_del(&fi->fib_lhash);
167                 change_nexthops(fi) {
168                         if (!nh->nh_dev)
169                                 continue;
170                         hlist_del(&nh->nh_hash);
171                 } endfor_nexthops(fi)
172                 fi->fib_dead = 1;
173                 fib_info_put(fi);
174         }
175         write_unlock(&fib_info_lock);
176 }
177
178 static __inline__ int nh_comp(const struct fib_info *fi, const struct fib_info *ofi)
179 {
180         const struct fib_nh *onh = ofi->fib_nh;
181
182         for_nexthops(fi) {
183                 if (nh->nh_oif != onh->nh_oif ||
184                     nh->nh_gw  != onh->nh_gw ||
185                     nh->nh_scope != onh->nh_scope ||
186 #ifdef CONFIG_IP_ROUTE_MULTIPATH
187                     nh->nh_weight != onh->nh_weight ||
188 #endif
189 #ifdef CONFIG_NET_CLS_ROUTE
190                     nh->nh_tclassid != onh->nh_tclassid ||
191 #endif
192                     ((nh->nh_flags^onh->nh_flags)&~RTNH_F_DEAD))
193                         return -1;
194                 onh++;
195         } endfor_nexthops(fi);
196         return 0;
197 }
198
199 static inline unsigned int fib_info_hashfn(const struct fib_info *fi)
200 {
201         unsigned int mask = (fib_hash_size - 1);
202         unsigned int val = fi->fib_nhs;
203
204         val ^= fi->fib_protocol;
205         val ^= fi->fib_prefsrc;
206         val ^= fi->fib_priority;
207
208         return (val ^ (val >> 7) ^ (val >> 12)) & mask;
209 }
210
211 static struct fib_info *fib_find_info(const struct fib_info *nfi)
212 {
213         struct hlist_head *head;
214         struct hlist_node *node;
215         struct fib_info *fi;
216         unsigned int hash;
217
218         hash = fib_info_hashfn(nfi);
219         head = &fib_info_hash[hash];
220
221         hlist_for_each_entry(fi, node, head, fib_hash) {
222                 if (fi->fib_nhs != nfi->fib_nhs)
223                         continue;
224                 if (nfi->fib_protocol == fi->fib_protocol &&
225                     nfi->fib_prefsrc == fi->fib_prefsrc &&
226                     nfi->fib_priority == fi->fib_priority &&
227                     memcmp(nfi->fib_metrics, fi->fib_metrics,
228                            sizeof(fi->fib_metrics)) == 0 &&
229                     ((nfi->fib_flags^fi->fib_flags)&~RTNH_F_DEAD) == 0 &&
230                     (nfi->fib_nhs == 0 || nh_comp(fi, nfi) == 0))
231                         return fi;
232         }
233
234         return NULL;
235 }
236
237 static inline unsigned int fib_devindex_hashfn(unsigned int val)
238 {
239         unsigned int mask = DEVINDEX_HASHSIZE - 1;
240
241         return (val ^
242                 (val >> DEVINDEX_HASHBITS) ^
243                 (val >> (DEVINDEX_HASHBITS * 2))) & mask;
244 }
245
246 /* Check, that the gateway is already configured.
247    Used only by redirect accept routine.
248  */
249
250 int ip_fib_check_default(u32 gw, struct net_device *dev)
251 {
252         struct hlist_head *head;
253         struct hlist_node *node;
254         struct fib_nh *nh;
255         unsigned int hash;
256
257         read_lock(&fib_info_lock);
258
259         hash = fib_devindex_hashfn(dev->ifindex);
260         head = &fib_info_devhash[hash];
261         hlist_for_each_entry(nh, node, head, nh_hash) {
262                 if (nh->nh_dev == dev &&
263                     nh->nh_gw == gw &&
264                     !(nh->nh_flags&RTNH_F_DEAD)) {
265                         read_unlock(&fib_info_lock);
266                         return 0;
267                 }
268         }
269
270         read_unlock(&fib_info_lock);
271
272         return -1;
273 }
274
275 void rtmsg_fib(int event, u32 key, struct fib_alias *fa,
276                int z, int tb_id,
277                struct nlmsghdr *n, struct netlink_skb_parms *req)
278 {
279         struct sk_buff *skb;
280         u32 pid = req ? req->pid : n->nlmsg_pid;
281         int size = NLMSG_SPACE(sizeof(struct rtmsg)+256);
282
283         skb = alloc_skb(size, GFP_KERNEL);
284         if (!skb)
285                 return;
286
287         if (fib_dump_info(skb, pid, n->nlmsg_seq, event, tb_id,
288                           fa->fa_type, fa->fa_scope, &key, z,
289                           fa->fa_tos,
290                           fa->fa_info, 0) < 0) {
291                 kfree_skb(skb);
292                 return;
293         }
294         NETLINK_CB(skb).dst_group = RTNLGRP_IPV4_ROUTE;
295         if (n->nlmsg_flags&NLM_F_ECHO)
296                 atomic_inc(&skb->users);
297         netlink_broadcast(rtnl, skb, pid, RTNLGRP_IPV4_ROUTE, GFP_KERNEL);
298         if (n->nlmsg_flags&NLM_F_ECHO)
299                 netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
300 }
301
302 /* Return the first fib alias matching TOS with
303  * priority less than or equal to PRIO.
304  */
305 struct fib_alias *fib_find_alias(struct list_head *fah, u8 tos, u32 prio)
306 {
307         if (fah) {
308                 struct fib_alias *fa;
309                 list_for_each_entry(fa, fah, fa_list) {
310                         if (fa->fa_tos > tos)
311                                 continue;
312                         if (fa->fa_info->fib_priority >= prio ||
313                             fa->fa_tos < tos)
314                                 return fa;
315                 }
316         }
317         return NULL;
318 }
319
320 int fib_detect_death(struct fib_info *fi, int order,
321                      struct fib_info **last_resort, int *last_idx, int *dflt)
322 {
323         struct neighbour *n;
324         int state = NUD_NONE;
325
326         n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev);
327         if (n) {
328                 state = n->nud_state;
329                 neigh_release(n);
330         }
331         if (state==NUD_REACHABLE)
332                 return 0;
333         if ((state&NUD_VALID) && order != *dflt)
334                 return 0;
335         if ((state&NUD_VALID) ||
336             (*last_idx<0 && order > *dflt)) {
337                 *last_resort = fi;
338                 *last_idx = order;
339         }
340         return 1;
341 }
342
343 #ifdef CONFIG_IP_ROUTE_MULTIPATH
344
345 static u32 fib_get_attr32(struct rtattr *attr, int attrlen, int type)
346 {
347         while (RTA_OK(attr,attrlen)) {
348                 if (attr->rta_type == type)
349                         return *(u32*)RTA_DATA(attr);
350                 attr = RTA_NEXT(attr, attrlen);
351         }
352         return 0;
353 }
354
355 static int
356 fib_count_nexthops(struct rtattr *rta)
357 {
358         int nhs = 0;
359         struct rtnexthop *nhp = RTA_DATA(rta);
360         int nhlen = RTA_PAYLOAD(rta);
361
362         while (nhlen >= (int)sizeof(struct rtnexthop)) {
363                 if ((nhlen -= nhp->rtnh_len) < 0)
364                         return 0;
365                 nhs++;
366                 nhp = RTNH_NEXT(nhp);
367         };
368         return nhs;
369 }
370
371 static int
372 fib_get_nhs(struct fib_info *fi, const struct rtattr *rta, const struct rtmsg *r)
373 {
374         struct rtnexthop *nhp = RTA_DATA(rta);
375         int nhlen = RTA_PAYLOAD(rta);
376
377         change_nexthops(fi) {
378                 int attrlen = nhlen - sizeof(struct rtnexthop);
379                 if (attrlen < 0 || (nhlen -= nhp->rtnh_len) < 0)
380                         return -EINVAL;
381                 nh->nh_flags = (r->rtm_flags&~0xFF) | nhp->rtnh_flags;
382                 nh->nh_oif = nhp->rtnh_ifindex;
383                 nh->nh_weight = nhp->rtnh_hops + 1;
384                 if (attrlen) {
385                         nh->nh_gw = fib_get_attr32(RTNH_DATA(nhp), attrlen, RTA_GATEWAY);
386 #ifdef CONFIG_NET_CLS_ROUTE
387                         nh->nh_tclassid = fib_get_attr32(RTNH_DATA(nhp), attrlen, RTA_FLOW);
388 #endif
389                 }
390                 nhp = RTNH_NEXT(nhp);
391         } endfor_nexthops(fi);
392         return 0;
393 }
394
395 #endif
396
397 int fib_nh_match(struct rtmsg *r, struct nlmsghdr *nlh, struct kern_rta *rta,
398                  struct fib_info *fi)
399 {
400 #ifdef CONFIG_IP_ROUTE_MULTIPATH
401         struct rtnexthop *nhp;
402         int nhlen;
403 #endif
404
405         if (rta->rta_priority &&
406             *rta->rta_priority != fi->fib_priority)
407                 return 1;
408
409         if (rta->rta_oif || rta->rta_gw) {
410                 if ((!rta->rta_oif || *rta->rta_oif == fi->fib_nh->nh_oif) &&
411                     (!rta->rta_gw  || memcmp(rta->rta_gw, &fi->fib_nh->nh_gw, 4) == 0))
412                         return 0;
413                 return 1;
414         }
415
416 #ifdef CONFIG_IP_ROUTE_MULTIPATH
417         if (rta->rta_mp == NULL)
418                 return 0;
419         nhp = RTA_DATA(rta->rta_mp);
420         nhlen = RTA_PAYLOAD(rta->rta_mp);
421         
422         for_nexthops(fi) {
423                 int attrlen = nhlen - sizeof(struct rtnexthop);
424                 u32 gw;
425
426                 if (attrlen < 0 || (nhlen -= nhp->rtnh_len) < 0)
427                         return -EINVAL;
428                 if (nhp->rtnh_ifindex && nhp->rtnh_ifindex != nh->nh_oif)
429                         return 1;
430                 if (attrlen) {
431                         gw = fib_get_attr32(RTNH_DATA(nhp), attrlen, RTA_GATEWAY);
432                         if (gw && gw != nh->nh_gw)
433                                 return 1;
434 #ifdef CONFIG_NET_CLS_ROUTE
435                         gw = fib_get_attr32(RTNH_DATA(nhp), attrlen, RTA_FLOW);
436                         if (gw && gw != nh->nh_tclassid)
437                                 return 1;
438 #endif
439                 }
440                 nhp = RTNH_NEXT(nhp);
441         } endfor_nexthops(fi);
442 #endif
443         return 0;
444 }
445
446
447 /*
448    Picture
449    -------
450
451    Semantics of nexthop is very messy by historical reasons.
452    We have to take into account, that:
453    a) gateway can be actually local interface address,
454       so that gatewayed route is direct.
455    b) gateway must be on-link address, possibly
456       described not by an ifaddr, but also by a direct route.
457    c) If both gateway and interface are specified, they should not
458       contradict.
459    d) If we use tunnel routes, gateway could be not on-link.
460
461    Attempt to reconcile all of these (alas, self-contradictory) conditions
462    results in pretty ugly and hairy code with obscure logic.
463
464    I chose to generalized it instead, so that the size
465    of code does not increase practically, but it becomes
466    much more general.
467    Every prefix is assigned a "scope" value: "host" is local address,
468    "link" is direct route,
469    [ ... "site" ... "interior" ... ]
470    and "universe" is true gateway route with global meaning.
471
472    Every prefix refers to a set of "nexthop"s (gw, oif),
473    where gw must have narrower scope. This recursion stops
474    when gw has LOCAL scope or if "nexthop" is declared ONLINK,
475    which means that gw is forced to be on link.
476
477    Code is still hairy, but now it is apparently logically
478    consistent and very flexible. F.e. as by-product it allows
479    to co-exists in peace independent exterior and interior
480    routing processes.
481
482    Normally it looks as following.
483
484    {universe prefix}  -> (gw, oif) [scope link]
485                           |
486                           |-> {link prefix} -> (gw, oif) [scope local]
487                                                 |
488                                                 |-> {local prefix} (terminal node)
489  */
490
491 static int fib_check_nh(const struct rtmsg *r, struct fib_info *fi, struct fib_nh *nh)
492 {
493         int err;
494
495         if (nh->nh_gw) {
496                 struct fib_result res;
497
498 #ifdef CONFIG_IP_ROUTE_PERVASIVE
499                 if (nh->nh_flags&RTNH_F_PERVASIVE)
500                         return 0;
501 #endif
502                 if (nh->nh_flags&RTNH_F_ONLINK) {
503                         struct net_device *dev;
504
505                         if (r->rtm_scope >= RT_SCOPE_LINK)
506                                 return -EINVAL;
507                         if (inet_addr_type(nh->nh_gw) != RTN_UNICAST)
508                                 return -EINVAL;
509                         if ((dev = __dev_get_by_index(nh->nh_oif)) == NULL)
510                                 return -ENODEV;
511                         if (!(dev->flags&IFF_UP))
512                                 return -ENETDOWN;
513                         nh->nh_dev = dev;
514                         dev_hold(dev);
515                         nh->nh_scope = RT_SCOPE_LINK;
516                         return 0;
517                 }
518                 {
519                         struct flowi fl = { .nl_u = { .ip4_u =
520                                                       { .daddr = nh->nh_gw,
521                                                         .scope = r->rtm_scope + 1 } },
522                                             .oif = nh->nh_oif };
523
524                         /* It is not necessary, but requires a bit of thinking */
525                         if (fl.fl4_scope < RT_SCOPE_LINK)
526                                 fl.fl4_scope = RT_SCOPE_LINK;
527                         if ((err = fib_lookup(&fl, &res)) != 0)
528                                 return err;
529                 }
530                 err = -EINVAL;
531                 if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
532                         goto out;
533                 nh->nh_scope = res.scope;
534                 nh->nh_oif = FIB_RES_OIF(res);
535                 if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
536                         goto out;
537                 dev_hold(nh->nh_dev);
538                 err = -ENETDOWN;
539                 if (!(nh->nh_dev->flags & IFF_UP))
540                         goto out;
541                 err = 0;
542 out:
543                 fib_res_put(&res);
544                 return err;
545         } else {
546                 struct in_device *in_dev;
547
548                 if (nh->nh_flags&(RTNH_F_PERVASIVE|RTNH_F_ONLINK))
549                         return -EINVAL;
550
551                 in_dev = inetdev_by_index(nh->nh_oif);
552                 if (in_dev == NULL)
553                         return -ENODEV;
554                 if (!(in_dev->dev->flags&IFF_UP)) {
555                         in_dev_put(in_dev);
556                         return -ENETDOWN;
557                 }
558                 nh->nh_dev = in_dev->dev;
559                 dev_hold(nh->nh_dev);
560                 nh->nh_scope = RT_SCOPE_HOST;
561                 in_dev_put(in_dev);
562         }
563         return 0;
564 }
565
566 static inline unsigned int fib_laddr_hashfn(u32 val)
567 {
568         unsigned int mask = (fib_hash_size - 1);
569
570         return (val ^ (val >> 7) ^ (val >> 14)) & mask;
571 }
572
573 static struct hlist_head *fib_hash_alloc(int bytes)
574 {
575         if (bytes <= PAGE_SIZE)
576                 return kmalloc(bytes, GFP_KERNEL);
577         else
578                 return (struct hlist_head *)
579                         __get_free_pages(GFP_KERNEL, get_order(bytes));
580 }
581
582 static void fib_hash_free(struct hlist_head *hash, int bytes)
583 {
584         if (!hash)
585                 return;
586
587         if (bytes <= PAGE_SIZE)
588                 kfree(hash);
589         else
590                 free_pages((unsigned long) hash, get_order(bytes));
591 }
592
593 static void fib_hash_move(struct hlist_head *new_info_hash,
594                           struct hlist_head *new_laddrhash,
595                           unsigned int new_size)
596 {
597         struct hlist_head *old_info_hash, *old_laddrhash;
598         unsigned int old_size = fib_hash_size;
599         unsigned int i, bytes;
600
601         write_lock(&fib_info_lock);
602         old_info_hash = fib_info_hash;
603         old_laddrhash = fib_info_laddrhash;
604         fib_hash_size = new_size;
605
606         for (i = 0; i < old_size; i++) {
607                 struct hlist_head *head = &fib_info_hash[i];
608                 struct hlist_node *node, *n;
609                 struct fib_info *fi;
610
611                 hlist_for_each_entry_safe(fi, node, n, head, fib_hash) {
612                         struct hlist_head *dest;
613                         unsigned int new_hash;
614
615                         hlist_del(&fi->fib_hash);
616
617                         new_hash = fib_info_hashfn(fi);
618                         dest = &new_info_hash[new_hash];
619                         hlist_add_head(&fi->fib_hash, dest);
620                 }
621         }
622         fib_info_hash = new_info_hash;
623
624         for (i = 0; i < old_size; i++) {
625                 struct hlist_head *lhead = &fib_info_laddrhash[i];
626                 struct hlist_node *node, *n;
627                 struct fib_info *fi;
628
629                 hlist_for_each_entry_safe(fi, node, n, lhead, fib_lhash) {
630                         struct hlist_head *ldest;
631                         unsigned int new_hash;
632
633                         hlist_del(&fi->fib_lhash);
634
635                         new_hash = fib_laddr_hashfn(fi->fib_prefsrc);
636                         ldest = &new_laddrhash[new_hash];
637                         hlist_add_head(&fi->fib_lhash, ldest);
638                 }
639         }
640         fib_info_laddrhash = new_laddrhash;
641
642         write_unlock(&fib_info_lock);
643
644         bytes = old_size * sizeof(struct hlist_head *);
645         fib_hash_free(old_info_hash, bytes);
646         fib_hash_free(old_laddrhash, bytes);
647 }
648
649 struct fib_info *
650 fib_create_info(const struct rtmsg *r, struct kern_rta *rta,
651                 const struct nlmsghdr *nlh, int *errp)
652 {
653         int err;
654         struct fib_info *fi = NULL;
655         struct fib_info *ofi;
656 #ifdef CONFIG_IP_ROUTE_MULTIPATH
657         int nhs = 1;
658 #else
659         const int nhs = 1;
660 #endif
661 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
662         u32 mp_alg = IP_MP_ALG_NONE;
663 #endif
664
665         /* Fast check to catch the most weird cases */
666         if (fib_props[r->rtm_type].scope > r->rtm_scope)
667                 goto err_inval;
668
669 #ifdef CONFIG_IP_ROUTE_MULTIPATH
670         if (rta->rta_mp) {
671                 nhs = fib_count_nexthops(rta->rta_mp);
672                 if (nhs == 0)
673                         goto err_inval;
674         }
675 #endif
676 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
677         if (rta->rta_mp_alg) {
678                 mp_alg = *rta->rta_mp_alg;
679
680                 if (mp_alg < IP_MP_ALG_NONE ||
681                     mp_alg > IP_MP_ALG_MAX)
682                         goto err_inval;
683         }
684 #endif
685
686         err = -ENOBUFS;
687         if (fib_info_cnt >= fib_hash_size) {
688                 unsigned int new_size = fib_hash_size << 1;
689                 struct hlist_head *new_info_hash;
690                 struct hlist_head *new_laddrhash;
691                 unsigned int bytes;
692
693                 if (!new_size)
694                         new_size = 1;
695                 bytes = new_size * sizeof(struct hlist_head *);
696                 new_info_hash = fib_hash_alloc(bytes);
697                 new_laddrhash = fib_hash_alloc(bytes);
698                 if (!new_info_hash || !new_laddrhash) {
699                         fib_hash_free(new_info_hash, bytes);
700                         fib_hash_free(new_laddrhash, bytes);
701                 } else {
702                         memset(new_info_hash, 0, bytes);
703                         memset(new_laddrhash, 0, bytes);
704
705                         fib_hash_move(new_info_hash, new_laddrhash, new_size);
706                 }
707
708                 if (!fib_hash_size)
709                         goto failure;
710         }
711
712         fi = kmalloc(sizeof(*fi)+nhs*sizeof(struct fib_nh), GFP_KERNEL);
713         if (fi == NULL)
714                 goto failure;
715         fib_info_cnt++;
716         memset(fi, 0, sizeof(*fi)+nhs*sizeof(struct fib_nh));
717
718         fi->fib_protocol = r->rtm_protocol;
719
720         fi->fib_nhs = nhs;
721         change_nexthops(fi) {
722                 nh->nh_parent = fi;
723         } endfor_nexthops(fi)
724
725         fi->fib_flags = r->rtm_flags;
726         if (rta->rta_priority)
727                 fi->fib_priority = *rta->rta_priority;
728         if (rta->rta_mx) {
729                 int attrlen = RTA_PAYLOAD(rta->rta_mx);
730                 struct rtattr *attr = RTA_DATA(rta->rta_mx);
731
732                 while (RTA_OK(attr, attrlen)) {
733                         unsigned flavor = attr->rta_type;
734                         if (flavor) {
735                                 if (flavor > RTAX_MAX)
736                                         goto err_inval;
737                                 fi->fib_metrics[flavor-1] = *(unsigned*)RTA_DATA(attr);
738                         }
739                         attr = RTA_NEXT(attr, attrlen);
740                 }
741         }
742         if (rta->rta_prefsrc)
743                 memcpy(&fi->fib_prefsrc, rta->rta_prefsrc, 4);
744
745         if (rta->rta_mp) {
746 #ifdef CONFIG_IP_ROUTE_MULTIPATH
747                 if ((err = fib_get_nhs(fi, rta->rta_mp, r)) != 0)
748                         goto failure;
749                 if (rta->rta_oif && fi->fib_nh->nh_oif != *rta->rta_oif)
750                         goto err_inval;
751                 if (rta->rta_gw && memcmp(&fi->fib_nh->nh_gw, rta->rta_gw, 4))
752                         goto err_inval;
753 #ifdef CONFIG_NET_CLS_ROUTE
754                 if (rta->rta_flow && memcmp(&fi->fib_nh->nh_tclassid, rta->rta_flow, 4))
755                         goto err_inval;
756 #endif
757 #else
758                 goto err_inval;
759 #endif
760         } else {
761                 struct fib_nh *nh = fi->fib_nh;
762                 if (rta->rta_oif)
763                         nh->nh_oif = *rta->rta_oif;
764                 if (rta->rta_gw)
765                         memcpy(&nh->nh_gw, rta->rta_gw, 4);
766 #ifdef CONFIG_NET_CLS_ROUTE
767                 if (rta->rta_flow)
768                         memcpy(&nh->nh_tclassid, rta->rta_flow, 4);
769 #endif
770                 nh->nh_flags = r->rtm_flags;
771 #ifdef CONFIG_IP_ROUTE_MULTIPATH
772                 nh->nh_weight = 1;
773 #endif
774         }
775
776 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
777         fi->fib_mp_alg = mp_alg;
778 #endif
779
780         if (fib_props[r->rtm_type].error) {
781                 if (rta->rta_gw || rta->rta_oif || rta->rta_mp)
782                         goto err_inval;
783                 goto link_it;
784         }
785
786         if (r->rtm_scope > RT_SCOPE_HOST)
787                 goto err_inval;
788
789         if (r->rtm_scope == RT_SCOPE_HOST) {
790                 struct fib_nh *nh = fi->fib_nh;
791
792                 /* Local address is added. */
793                 if (nhs != 1 || nh->nh_gw)
794                         goto err_inval;
795                 nh->nh_scope = RT_SCOPE_NOWHERE;
796                 nh->nh_dev = dev_get_by_index(fi->fib_nh->nh_oif);
797                 err = -ENODEV;
798                 if (nh->nh_dev == NULL)
799                         goto failure;
800         } else {
801                 change_nexthops(fi) {
802                         if ((err = fib_check_nh(r, fi, nh)) != 0)
803                                 goto failure;
804                 } endfor_nexthops(fi)
805         }
806
807         if (fi->fib_prefsrc) {
808                 if (r->rtm_type != RTN_LOCAL || rta->rta_dst == NULL ||
809                     memcmp(&fi->fib_prefsrc, rta->rta_dst, 4))
810                         if (inet_addr_type(fi->fib_prefsrc) != RTN_LOCAL)
811                                 goto err_inval;
812         }
813
814 link_it:
815         if ((ofi = fib_find_info(fi)) != NULL) {
816                 fi->fib_dead = 1;
817                 free_fib_info(fi);
818                 ofi->fib_treeref++;
819                 return ofi;
820         }
821
822         fi->fib_treeref++;
823         atomic_inc(&fi->fib_clntref);
824         write_lock(&fib_info_lock);
825         hlist_add_head(&fi->fib_hash,
826                        &fib_info_hash[fib_info_hashfn(fi)]);
827         if (fi->fib_prefsrc) {
828                 struct hlist_head *head;
829
830                 head = &fib_info_laddrhash[fib_laddr_hashfn(fi->fib_prefsrc)];
831                 hlist_add_head(&fi->fib_lhash, head);
832         }
833         change_nexthops(fi) {
834                 struct hlist_head *head;
835                 unsigned int hash;
836
837                 if (!nh->nh_dev)
838                         continue;
839                 hash = fib_devindex_hashfn(nh->nh_dev->ifindex);
840                 head = &fib_info_devhash[hash];
841                 hlist_add_head(&nh->nh_hash, head);
842         } endfor_nexthops(fi)
843         write_unlock(&fib_info_lock);
844         return fi;
845
846 err_inval:
847         err = -EINVAL;
848
849 failure:
850         *errp = err;
851         if (fi) {
852                 fi->fib_dead = 1;
853                 free_fib_info(fi);
854         }
855         return NULL;
856 }
857
858 /* Note! fib_semantic_match intentionally uses  RCU list functions. */
859 int fib_semantic_match(struct list_head *head, const struct flowi *flp,
860                        struct fib_result *res, __u32 zone, __u32 mask, 
861                         int prefixlen)
862 {
863         struct fib_alias *fa;
864         int nh_sel = 0;
865
866         list_for_each_entry_rcu(fa, head, fa_list) {
867                 int err;
868
869                 if (fa->fa_tos &&
870                     fa->fa_tos != flp->fl4_tos)
871                         continue;
872
873                 if (fa->fa_scope < flp->fl4_scope)
874                         continue;
875
876                 fa->fa_state |= FA_S_ACCESSED;
877
878                 err = fib_props[fa->fa_type].error;
879                 if (err == 0) {
880                         struct fib_info *fi = fa->fa_info;
881
882                         if (fi->fib_flags & RTNH_F_DEAD)
883                                 continue;
884
885                         switch (fa->fa_type) {
886                         case RTN_UNICAST:
887                         case RTN_LOCAL:
888                         case RTN_BROADCAST:
889                         case RTN_ANYCAST:
890                         case RTN_MULTICAST:
891                                 for_nexthops(fi) {
892                                         if (nh->nh_flags&RTNH_F_DEAD)
893                                                 continue;
894                                         if (!flp->oif || flp->oif == nh->nh_oif)
895                                                 break;
896                                 }
897 #ifdef CONFIG_IP_ROUTE_MULTIPATH
898                                 if (nhsel < fi->fib_nhs) {
899                                         nh_sel = nhsel;
900                                         goto out_fill_res;
901                                 }
902 #else
903                                 if (nhsel < 1) {
904                                         goto out_fill_res;
905                                 }
906 #endif
907                                 endfor_nexthops(fi);
908                                 continue;
909
910                         default:
911                                 printk(KERN_DEBUG "impossible 102\n");
912                                 return -EINVAL;
913                         };
914                 }
915                 return err;
916         }
917         return 1;
918
919 out_fill_res:
920         res->prefixlen = prefixlen;
921         res->nh_sel = nh_sel;
922         res->type = fa->fa_type;
923         res->scope = fa->fa_scope;
924         res->fi = fa->fa_info;
925 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
926         res->netmask = mask;
927         res->network = zone &
928                 (0xFFFFFFFF >> (32 - prefixlen));
929 #endif
930         atomic_inc(&res->fi->fib_clntref);
931         return 0;
932 }
933
934 /* Find appropriate source address to this destination */
935
936 u32 __fib_res_prefsrc(struct fib_result *res)
937 {
938         return inet_select_addr(FIB_RES_DEV(*res), FIB_RES_GW(*res), res->scope);
939 }
940
941 int
942 fib_dump_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
943               u8 tb_id, u8 type, u8 scope, void *dst, int dst_len, u8 tos,
944               struct fib_info *fi, unsigned int flags)
945 {
946         struct rtmsg *rtm;
947         struct nlmsghdr  *nlh;
948         unsigned char    *b = skb->tail;
949
950         nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*rtm), flags);
951         rtm = NLMSG_DATA(nlh);
952         rtm->rtm_family = AF_INET;
953         rtm->rtm_dst_len = dst_len;
954         rtm->rtm_src_len = 0;
955         rtm->rtm_tos = tos;
956         rtm->rtm_table = tb_id;
957         rtm->rtm_type = type;
958         rtm->rtm_flags = fi->fib_flags;
959         rtm->rtm_scope = scope;
960         if (rtm->rtm_dst_len)
961                 RTA_PUT(skb, RTA_DST, 4, dst);
962         rtm->rtm_protocol = fi->fib_protocol;
963         if (fi->fib_priority)
964                 RTA_PUT(skb, RTA_PRIORITY, 4, &fi->fib_priority);
965 #ifdef CONFIG_NET_CLS_ROUTE
966         if (fi->fib_nh[0].nh_tclassid)
967                 RTA_PUT(skb, RTA_FLOW, 4, &fi->fib_nh[0].nh_tclassid);
968 #endif
969         if (rtnetlink_put_metrics(skb, fi->fib_metrics) < 0)
970                 goto rtattr_failure;
971         if (fi->fib_prefsrc)
972                 RTA_PUT(skb, RTA_PREFSRC, 4, &fi->fib_prefsrc);
973         if (fi->fib_nhs == 1) {
974                 if (fi->fib_nh->nh_gw)
975                         RTA_PUT(skb, RTA_GATEWAY, 4, &fi->fib_nh->nh_gw);
976                 if (fi->fib_nh->nh_oif)
977                         RTA_PUT(skb, RTA_OIF, sizeof(int), &fi->fib_nh->nh_oif);
978         }
979 #ifdef CONFIG_IP_ROUTE_MULTIPATH
980         if (fi->fib_nhs > 1) {
981                 struct rtnexthop *nhp;
982                 struct rtattr *mp_head;
983                 if (skb_tailroom(skb) <= RTA_SPACE(0))
984                         goto rtattr_failure;
985                 mp_head = (struct rtattr*)skb_put(skb, RTA_SPACE(0));
986
987                 for_nexthops(fi) {
988                         if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
989                                 goto rtattr_failure;
990                         nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
991                         nhp->rtnh_flags = nh->nh_flags & 0xFF;
992                         nhp->rtnh_hops = nh->nh_weight-1;
993                         nhp->rtnh_ifindex = nh->nh_oif;
994                         if (nh->nh_gw)
995                                 RTA_PUT(skb, RTA_GATEWAY, 4, &nh->nh_gw);
996                         nhp->rtnh_len = skb->tail - (unsigned char*)nhp;
997                 } endfor_nexthops(fi);
998                 mp_head->rta_type = RTA_MULTIPATH;
999                 mp_head->rta_len = skb->tail - (u8*)mp_head;
1000         }
1001 #endif
1002         nlh->nlmsg_len = skb->tail - b;
1003         return skb->len;
1004
1005 nlmsg_failure:
1006 rtattr_failure:
1007         skb_trim(skb, b - skb->data);
1008         return -1;
1009 }
1010
1011 #ifndef CONFIG_IP_NOSIOCRT
1012
1013 int
1014 fib_convert_rtentry(int cmd, struct nlmsghdr *nl, struct rtmsg *rtm,
1015                     struct kern_rta *rta, struct rtentry *r)
1016 {
1017         int    plen;
1018         u32    *ptr;
1019
1020         memset(rtm, 0, sizeof(*rtm));
1021         memset(rta, 0, sizeof(*rta));
1022
1023         if (r->rt_dst.sa_family != AF_INET)
1024                 return -EAFNOSUPPORT;
1025
1026         /* Check mask for validity:
1027            a) it must be contiguous.
1028            b) destination must have all host bits clear.
1029            c) if application forgot to set correct family (AF_INET),
1030               reject request unless it is absolutely clear i.e.
1031               both family and mask are zero.
1032          */
1033         plen = 32;
1034         ptr = &((struct sockaddr_in*)&r->rt_dst)->sin_addr.s_addr;
1035         if (!(r->rt_flags&RTF_HOST)) {
1036                 u32 mask = ((struct sockaddr_in*)&r->rt_genmask)->sin_addr.s_addr;
1037                 if (r->rt_genmask.sa_family != AF_INET) {
1038                         if (mask || r->rt_genmask.sa_family)
1039                                 return -EAFNOSUPPORT;
1040                 }
1041                 if (bad_mask(mask, *ptr))
1042                         return -EINVAL;
1043                 plen = inet_mask_len(mask);
1044         }
1045
1046         nl->nlmsg_flags = NLM_F_REQUEST;
1047         nl->nlmsg_pid = 0;
1048         nl->nlmsg_seq = 0;
1049         nl->nlmsg_len = NLMSG_LENGTH(sizeof(*rtm));
1050         if (cmd == SIOCDELRT) {
1051                 nl->nlmsg_type = RTM_DELROUTE;
1052                 nl->nlmsg_flags = 0;
1053         } else {
1054                 nl->nlmsg_type = RTM_NEWROUTE;
1055                 nl->nlmsg_flags = NLM_F_REQUEST|NLM_F_CREATE;
1056                 rtm->rtm_protocol = RTPROT_BOOT;
1057         }
1058
1059         rtm->rtm_dst_len = plen;
1060         rta->rta_dst = ptr;
1061
1062         if (r->rt_metric) {
1063                 *(u32*)&r->rt_pad3 = r->rt_metric - 1;
1064                 rta->rta_priority = (u32*)&r->rt_pad3;
1065         }
1066         if (r->rt_flags&RTF_REJECT) {
1067                 rtm->rtm_scope = RT_SCOPE_HOST;
1068                 rtm->rtm_type = RTN_UNREACHABLE;
1069                 return 0;
1070         }
1071         rtm->rtm_scope = RT_SCOPE_NOWHERE;
1072         rtm->rtm_type = RTN_UNICAST;
1073
1074         if (r->rt_dev) {
1075                 char *colon;
1076                 struct net_device *dev;
1077                 char   devname[IFNAMSIZ];
1078
1079                 if (copy_from_user(devname, r->rt_dev, IFNAMSIZ-1))
1080                         return -EFAULT;
1081                 devname[IFNAMSIZ-1] = 0;
1082                 colon = strchr(devname, ':');
1083                 if (colon)
1084                         *colon = 0;
1085                 dev = __dev_get_by_name(devname);
1086                 if (!dev)
1087                         return -ENODEV;
1088                 rta->rta_oif = &dev->ifindex;
1089                 if (colon) {
1090                         struct in_ifaddr *ifa;
1091                         struct in_device *in_dev = __in_dev_get_rtnl(dev);
1092                         if (!in_dev)
1093                                 return -ENODEV;
1094                         *colon = ':';
1095                         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
1096                                 if (strcmp(ifa->ifa_label, devname) == 0)
1097                                         break;
1098                         if (ifa == NULL)
1099                                 return -ENODEV;
1100                         rta->rta_prefsrc = &ifa->ifa_local;
1101                 }
1102         }
1103
1104         ptr = &((struct sockaddr_in*)&r->rt_gateway)->sin_addr.s_addr;
1105         if (r->rt_gateway.sa_family == AF_INET && *ptr) {
1106                 rta->rta_gw = ptr;
1107                 if (r->rt_flags&RTF_GATEWAY && inet_addr_type(*ptr) == RTN_UNICAST)
1108                         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
1109         }
1110
1111         if (cmd == SIOCDELRT)
1112                 return 0;
1113
1114         if (r->rt_flags&RTF_GATEWAY && rta->rta_gw == NULL)
1115                 return -EINVAL;
1116
1117         if (rtm->rtm_scope == RT_SCOPE_NOWHERE)
1118                 rtm->rtm_scope = RT_SCOPE_LINK;
1119
1120         if (r->rt_flags&(RTF_MTU|RTF_WINDOW|RTF_IRTT)) {
1121                 struct rtattr *rec;
1122                 struct rtattr *mx = kmalloc(RTA_LENGTH(3*RTA_LENGTH(4)), GFP_KERNEL);
1123                 if (mx == NULL)
1124                         return -ENOMEM;
1125                 rta->rta_mx = mx;
1126                 mx->rta_type = RTA_METRICS;
1127                 mx->rta_len  = RTA_LENGTH(0);
1128                 if (r->rt_flags&RTF_MTU) {
1129                         rec = (void*)((char*)mx + RTA_ALIGN(mx->rta_len));
1130                         rec->rta_type = RTAX_ADVMSS;
1131                         rec->rta_len = RTA_LENGTH(4);
1132                         mx->rta_len += RTA_LENGTH(4);
1133                         *(u32*)RTA_DATA(rec) = r->rt_mtu - 40;
1134                 }
1135                 if (r->rt_flags&RTF_WINDOW) {
1136                         rec = (void*)((char*)mx + RTA_ALIGN(mx->rta_len));
1137                         rec->rta_type = RTAX_WINDOW;
1138                         rec->rta_len = RTA_LENGTH(4);
1139                         mx->rta_len += RTA_LENGTH(4);
1140                         *(u32*)RTA_DATA(rec) = r->rt_window;
1141                 }
1142                 if (r->rt_flags&RTF_IRTT) {
1143                         rec = (void*)((char*)mx + RTA_ALIGN(mx->rta_len));
1144                         rec->rta_type = RTAX_RTT;
1145                         rec->rta_len = RTA_LENGTH(4);
1146                         mx->rta_len += RTA_LENGTH(4);
1147                         *(u32*)RTA_DATA(rec) = r->rt_irtt<<3;
1148                 }
1149         }
1150         return 0;
1151 }
1152
1153 #endif
1154
1155 /*
1156    Update FIB if:
1157    - local address disappeared -> we must delete all the entries
1158      referring to it.
1159    - device went down -> we must shutdown all nexthops going via it.
1160  */
1161
1162 int fib_sync_down(u32 local, struct net_device *dev, int force)
1163 {
1164         int ret = 0;
1165         int scope = RT_SCOPE_NOWHERE;
1166         
1167         if (force)
1168                 scope = -1;
1169
1170         if (local && fib_info_laddrhash) {
1171                 unsigned int hash = fib_laddr_hashfn(local);
1172                 struct hlist_head *head = &fib_info_laddrhash[hash];
1173                 struct hlist_node *node;
1174                 struct fib_info *fi;
1175
1176                 hlist_for_each_entry(fi, node, head, fib_lhash) {
1177                         if (fi->fib_prefsrc == local) {
1178                                 fi->fib_flags |= RTNH_F_DEAD;
1179                                 ret++;
1180                         }
1181                 }
1182         }
1183
1184         if (dev) {
1185                 struct fib_info *prev_fi = NULL;
1186                 unsigned int hash = fib_devindex_hashfn(dev->ifindex);
1187                 struct hlist_head *head = &fib_info_devhash[hash];
1188                 struct hlist_node *node;
1189                 struct fib_nh *nh;
1190
1191                 hlist_for_each_entry(nh, node, head, nh_hash) {
1192                         struct fib_info *fi = nh->nh_parent;
1193                         int dead;
1194
1195                         BUG_ON(!fi->fib_nhs);
1196                         if (nh->nh_dev != dev || fi == prev_fi)
1197                                 continue;
1198                         prev_fi = fi;
1199                         dead = 0;
1200                         change_nexthops(fi) {
1201                                 if (nh->nh_flags&RTNH_F_DEAD)
1202                                         dead++;
1203                                 else if (nh->nh_dev == dev &&
1204                                          nh->nh_scope != scope) {
1205                                         nh->nh_flags |= RTNH_F_DEAD;
1206 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1207                                         spin_lock_bh(&fib_multipath_lock);
1208                                         fi->fib_power -= nh->nh_power;
1209                                         nh->nh_power = 0;
1210                                         spin_unlock_bh(&fib_multipath_lock);
1211 #endif
1212                                         dead++;
1213                                 }
1214 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1215                                 if (force > 1 && nh->nh_dev == dev) {
1216                                         dead = fi->fib_nhs;
1217                                         break;
1218                                 }
1219 #endif
1220                         } endfor_nexthops(fi)
1221                         if (dead == fi->fib_nhs) {
1222                                 fi->fib_flags |= RTNH_F_DEAD;
1223                                 ret++;
1224                         }
1225                 }
1226         }
1227
1228         return ret;
1229 }
1230
1231 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1232
1233 /*
1234    Dead device goes up. We wake up dead nexthops.
1235    It takes sense only on multipath routes.
1236  */
1237
1238 int fib_sync_up(struct net_device *dev)
1239 {
1240         struct fib_info *prev_fi;
1241         unsigned int hash;
1242         struct hlist_head *head;
1243         struct hlist_node *node;
1244         struct fib_nh *nh;
1245         int ret;
1246
1247         if (!(dev->flags&IFF_UP))
1248                 return 0;
1249
1250         prev_fi = NULL;
1251         hash = fib_devindex_hashfn(dev->ifindex);
1252         head = &fib_info_devhash[hash];
1253         ret = 0;
1254
1255         hlist_for_each_entry(nh, node, head, nh_hash) {
1256                 struct fib_info *fi = nh->nh_parent;
1257                 int alive;
1258
1259                 BUG_ON(!fi->fib_nhs);
1260                 if (nh->nh_dev != dev || fi == prev_fi)
1261                         continue;
1262
1263                 prev_fi = fi;
1264                 alive = 0;
1265                 change_nexthops(fi) {
1266                         if (!(nh->nh_flags&RTNH_F_DEAD)) {
1267                                 alive++;
1268                                 continue;
1269                         }
1270                         if (nh->nh_dev == NULL || !(nh->nh_dev->flags&IFF_UP))
1271                                 continue;
1272                         if (nh->nh_dev != dev || !__in_dev_get_rtnl(dev))
1273                                 continue;
1274                         alive++;
1275                         spin_lock_bh(&fib_multipath_lock);
1276                         nh->nh_power = 0;
1277                         nh->nh_flags &= ~RTNH_F_DEAD;
1278                         spin_unlock_bh(&fib_multipath_lock);
1279                 } endfor_nexthops(fi)
1280
1281                 if (alive > 0) {
1282                         fi->fib_flags &= ~RTNH_F_DEAD;
1283                         ret++;
1284                 }
1285         }
1286
1287         return ret;
1288 }
1289
1290 /*
1291    The algorithm is suboptimal, but it provides really
1292    fair weighted route distribution.
1293  */
1294
1295 void fib_select_multipath(const struct flowi *flp, struct fib_result *res)
1296 {
1297         struct fib_info *fi = res->fi;
1298         int w;
1299
1300         spin_lock_bh(&fib_multipath_lock);
1301         if (fi->fib_power <= 0) {
1302                 int power = 0;
1303                 change_nexthops(fi) {
1304                         if (!(nh->nh_flags&RTNH_F_DEAD)) {
1305                                 power += nh->nh_weight;
1306                                 nh->nh_power = nh->nh_weight;
1307                         }
1308                 } endfor_nexthops(fi);
1309                 fi->fib_power = power;
1310                 if (power <= 0) {
1311                         spin_unlock_bh(&fib_multipath_lock);
1312                         /* Race condition: route has just become dead. */
1313                         res->nh_sel = 0;
1314                         return;
1315                 }
1316         }
1317
1318
1319         /* w should be random number [0..fi->fib_power-1],
1320            it is pretty bad approximation.
1321          */
1322
1323         w = jiffies % fi->fib_power;
1324
1325         change_nexthops(fi) {
1326                 if (!(nh->nh_flags&RTNH_F_DEAD) && nh->nh_power) {
1327                         if ((w -= nh->nh_power) <= 0) {
1328                                 nh->nh_power--;
1329                                 fi->fib_power--;
1330                                 res->nh_sel = nhsel;
1331                                 spin_unlock_bh(&fib_multipath_lock);
1332                                 return;
1333                         }
1334                 }
1335         } endfor_nexthops(fi);
1336
1337         /* Race condition: route has just become dead. */
1338         res->nh_sel = 0;
1339         spin_unlock_bh(&fib_multipath_lock);
1340 }
1341 #endif