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