git.oblomov.eu Git - linux-2.6/blob - 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/init.h>
  37
  38 #include <net/arp.h>
  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 #include <net/netlink.h>
  46 #include <net/nexthop.h>
  47
  48 #include "fib_lookup.h"
  49
  50 static DEFINE_SPINLOCK(fib_info_lock);
  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 DEFINE_SPINLOCK(fib_multipath_lock);
  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 const struct
  86 {
  87         int     error;
  88         u8      scope;
  89 } fib_props[RTN_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(KERN_WARNING "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         release_net(fi->fib_net);
 156         kfree(fi);
 157 }
 158
 159 void fib_release_info(struct fib_info *fi)
 160 {
 161         spin_lock_bh(&fib_info_lock);
 162         if (fi && --fi->fib_treeref == 0) {
 163                 hlist_del(&fi->fib_hash);
 164                 if (fi->fib_prefsrc)
 165                         hlist_del(&fi->fib_lhash);
 166                 change_nexthops(fi) {
 167                         if (!nh->nh_dev)
 168                                 continue;
 169                         hlist_del(&nh->nh_hash);
 170                 } endfor_nexthops(fi)
 171                 fi->fib_dead = 1;
 172                 fib_info_put(fi);
 173         }
 174         spin_unlock_bh(&fib_info_lock);
 175 }
 176
 177 static __inline__ int nh_comp(const struct fib_info *fi, const struct fib_info *ofi)
 178 {
 179         const struct fib_nh *onh = ofi->fib_nh;
 180
 181         for_nexthops(fi) {
 182                 if (nh->nh_oif != onh->nh_oif ||
 183                     nh->nh_gw  != onh->nh_gw ||
 184                     nh->nh_scope != onh->nh_scope ||
 185 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 186                     nh->nh_weight != onh->nh_weight ||
 187 #endif
 188 #ifdef CONFIG_NET_CLS_ROUTE
 189                     nh->nh_tclassid != onh->nh_tclassid ||
 190 #endif
 191                     ((nh->nh_flags^onh->nh_flags)&~RTNH_F_DEAD))
 192                         return -1;
 193                 onh++;
 194         } endfor_nexthops(fi);
 195         return 0;
 196 }
 197
 198 static inline unsigned int fib_devindex_hashfn(unsigned int val)
 199 {
 200         unsigned int mask = DEVINDEX_HASHSIZE - 1;
 201
 202         return (val ^
 203                 (val >> DEVINDEX_HASHBITS) ^
 204                 (val >> (DEVINDEX_HASHBITS * 2))) & mask;
 205 }
 206
 207 static inline unsigned int fib_info_hashfn(const struct fib_info *fi)
 208 {
 209         unsigned int mask = (fib_hash_size - 1);
 210         unsigned int val = fi->fib_nhs;
 211
 212         val ^= fi->fib_protocol;
 213         val ^= (__force u32)fi->fib_prefsrc;
 214         val ^= fi->fib_priority;
 215         for_nexthops(fi) {
 216                 val ^= fib_devindex_hashfn(nh->nh_oif);
 217         } endfor_nexthops(fi)
 218
 219         return (val ^ (val >> 7) ^ (val >> 12)) & mask;
 220 }
 221
 222 static struct fib_info *fib_find_info(const struct fib_info *nfi)
 223 {
 224         struct hlist_head *head;
 225         struct hlist_node *node;
 226         struct fib_info *fi;
 227         unsigned int hash;
 228
 229         hash = fib_info_hashfn(nfi);
 230         head = &fib_info_hash[hash];
 231
 232         hlist_for_each_entry(fi, node, head, fib_hash) {
 233                 if (fi->fib_net != nfi->fib_net)
 234                         continue;
 235                 if (fi->fib_nhs != nfi->fib_nhs)
 236                         continue;
 237                 if (nfi->fib_protocol == fi->fib_protocol &&
 238                     nfi->fib_prefsrc == fi->fib_prefsrc &&
 239                     nfi->fib_priority == fi->fib_priority &&
 240                     memcmp(nfi->fib_metrics, fi->fib_metrics,
 241                            sizeof(fi->fib_metrics)) == 0 &&
 242                     ((nfi->fib_flags^fi->fib_flags)&~RTNH_F_DEAD) == 0 &&
 243                     (nfi->fib_nhs == 0 || nh_comp(fi, nfi) == 0))
 244                         return fi;
 245         }
 246
 247         return NULL;
 248 }
 249
 250 /* Check, that the gateway is already configured.
 251    Used only by redirect accept routine.
 252  */
 253
 254 int ip_fib_check_default(__be32 gw, struct net_device *dev)
 255 {
 256         struct hlist_head *head;
 257         struct hlist_node *node;
 258         struct fib_nh *nh;
 259         unsigned int hash;
 260
 261         spin_lock(&fib_info_lock);
 262
 263         hash = fib_devindex_hashfn(dev->ifindex);
 264         head = &fib_info_devhash[hash];
 265         hlist_for_each_entry(nh, node, head, nh_hash) {
 266                 if (nh->nh_dev == dev &&
 267                     nh->nh_gw == gw &&
 268                     !(nh->nh_flags&RTNH_F_DEAD)) {
 269                         spin_unlock(&fib_info_lock);
 270                         return 0;
 271                 }
 272         }
 273
 274         spin_unlock(&fib_info_lock);
 275
 276         return -1;
 277 }
 278
 279 static inline size_t fib_nlmsg_size(struct fib_info *fi)
 280 {
 281         size_t payload = NLMSG_ALIGN(sizeof(struct rtmsg))
 282                          + nla_total_size(4) /* RTA_TABLE */
 283                          + nla_total_size(4) /* RTA_DST */
 284                          + nla_total_size(4) /* RTA_PRIORITY */
 285                          + nla_total_size(4); /* RTA_PREFSRC */
 286
 287         /* space for nested metrics */
 288         payload += nla_total_size((RTAX_MAX * nla_total_size(4)));
 289
 290         if (fi->fib_nhs) {
 291                 /* Also handles the special case fib_nhs == 1 */
 292
 293                 /* each nexthop is packed in an attribute */
 294                 size_t nhsize = nla_total_size(sizeof(struct rtnexthop));
 295
 296                 /* may contain flow and gateway attribute */
 297                 nhsize += 2 * nla_total_size(4);
 298
 299                 /* all nexthops are packed in a nested attribute */
 300                 payload += nla_total_size(fi->fib_nhs * nhsize);
 301         }
 302
 303         return payload;
 304 }
 305
 306 void rtmsg_fib(int event, __be32 key, struct fib_alias *fa,
 307                int dst_len, u32 tb_id, struct nl_info *info,
 308                unsigned int nlm_flags)
 309 {
 310         struct sk_buff *skb;
 311         u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
 312         int err = -ENOBUFS;
 313
 314         skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL);
 315         if (skb == NULL)
 316                 goto errout;
 317
 318         err = fib_dump_info(skb, info->pid, seq, event, tb_id,
 319                             fa->fa_type, fa->fa_scope, key, dst_len,
 320                             fa->fa_tos, fa->fa_info, nlm_flags);
 321         if (err < 0) {
 322                 /* -EMSGSIZE implies BUG in fib_nlmsg_size() */
 323                 WARN_ON(err == -EMSGSIZE);
 324                 kfree_skb(skb);
 325                 goto errout;
 326         }
 327         err = rtnl_notify(skb, info->nl_net, info->pid, RTNLGRP_IPV4_ROUTE,
 328                           info->nlh, GFP_KERNEL);
 329 errout:
 330         if (err < 0)
 331                 rtnl_set_sk_err(info->nl_net, RTNLGRP_IPV4_ROUTE, err);
 332 }
 333
 334 /* Return the first fib alias matching TOS with
 335  * priority less than or equal to PRIO.
 336  */
 337 struct fib_alias *fib_find_alias(struct list_head *fah, u8 tos, u32 prio)
 338 {
 339         if (fah) {
 340                 struct fib_alias *fa;
 341                 list_for_each_entry(fa, fah, fa_list) {
 342                         if (fa->fa_tos > tos)
 343                                 continue;
 344                         if (fa->fa_info->fib_priority >= prio ||
 345                             fa->fa_tos < tos)
 346                                 return fa;
 347                 }
 348         }
 349         return NULL;
 350 }
 351
 352 int fib_detect_death(struct fib_info *fi, int order,
 353                      struct fib_info **last_resort, int *last_idx, int dflt)
 354 {
 355         struct neighbour *n;
 356         int state = NUD_NONE;
 357
 358         n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev);
 359         if (n) {
 360                 state = n->nud_state;
 361                 neigh_release(n);
 362         }
 363         if (state==NUD_REACHABLE)
 364                 return 0;
 365         if ((state&NUD_VALID) && order != dflt)
 366                 return 0;
 367         if ((state&NUD_VALID) ||
 368             (*last_idx<0 && order > dflt)) {
 369                 *last_resort = fi;
 370                 *last_idx = order;
 371         }
 372         return 1;
 373 }
 374
 375 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 376
 377 static int fib_count_nexthops(struct rtnexthop *rtnh, int remaining)
 378 {
 379         int nhs = 0;
 380
 381         while (rtnh_ok(rtnh, remaining)) {
 382                 nhs++;
 383                 rtnh = rtnh_next(rtnh, &remaining);
 384         }
 385
 386         /* leftover implies invalid nexthop configuration, discard it */
 387         return remaining > 0 ? 0 : nhs;
 388 }
 389
 390 static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
 391                        int remaining, struct fib_config *cfg)
 392 {
 393         change_nexthops(fi) {
 394                 int attrlen;
 395
 396                 if (!rtnh_ok(rtnh, remaining))
 397                         return -EINVAL;
 398
 399                 nh->nh_flags = (cfg->fc_flags & ~0xFF) | rtnh->rtnh_flags;
 400                 nh->nh_oif = rtnh->rtnh_ifindex;
 401                 nh->nh_weight = rtnh->rtnh_hops + 1;
 402
 403                 attrlen = rtnh_attrlen(rtnh);
 404                 if (attrlen > 0) {
 405                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
 406
 407                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
 408                         nh->nh_gw = nla ? nla_get_be32(nla) : 0;
 409 #ifdef CONFIG_NET_CLS_ROUTE
 410                         nla = nla_find(attrs, attrlen, RTA_FLOW);
 411                         nh->nh_tclassid = nla ? nla_get_u32(nla) : 0;
 412 #endif
 413                 }
 414
 415                 rtnh = rtnh_next(rtnh, &remaining);
 416         } endfor_nexthops(fi);
 417
 418         return 0;
 419 }
 420
 421 #endif
 422
 423 int fib_nh_match(struct fib_config *cfg, struct fib_info *fi)
 424 {
 425 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 426         struct rtnexthop *rtnh;
 427         int remaining;
 428 #endif
 429
 430         if (cfg->fc_priority && cfg->fc_priority != fi->fib_priority)
 431                 return 1;
 432
 433         if (cfg->fc_oif || cfg->fc_gw) {
 434                 if ((!cfg->fc_oif || cfg->fc_oif == fi->fib_nh->nh_oif) &&
 435                     (!cfg->fc_gw  || cfg->fc_gw == fi->fib_nh->nh_gw))
 436                         return 0;
 437                 return 1;
 438         }
 439
 440 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 441         if (cfg->fc_mp == NULL)
 442                 return 0;
 443
 444         rtnh = cfg->fc_mp;
 445         remaining = cfg->fc_mp_len;
 446
 447         for_nexthops(fi) {
 448                 int attrlen;
 449
 450                 if (!rtnh_ok(rtnh, remaining))
 451                         return -EINVAL;
 452
 453                 if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->nh_oif)
 454                         return 1;
 455
 456                 attrlen = rtnh_attrlen(rtnh);
 457                 if (attrlen < 0) {
 458                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
 459
 460                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
 461                         if (nla && nla_get_be32(nla) != nh->nh_gw)
 462                                 return 1;
 463 #ifdef CONFIG_NET_CLS_ROUTE
 464                         nla = nla_find(attrs, attrlen, RTA_FLOW);
 465                         if (nla && nla_get_u32(nla) != nh->nh_tclassid)
 466                                 return 1;
 467 #endif
 468                 }
 469
 470                 rtnh = rtnh_next(rtnh, &remaining);
 471         } endfor_nexthops(fi);
 472 #endif
 473         return 0;
 474 }
 475
 476
 477 /*
 478    Picture
 479    -------
 480
 481    Semantics of nexthop is very messy by historical reasons.
 482    We have to take into account, that:
 483    a) gateway can be actually local interface address,
 484       so that gatewayed route is direct.
 485    b) gateway must be on-link address, possibly
 486       described not by an ifaddr, but also by a direct route.
 487    c) If both gateway and interface are specified, they should not
 488       contradict.
 489    d) If we use tunnel routes, gateway could be not on-link.
 490
 491    Attempt to reconcile all of these (alas, self-contradictory) conditions
 492    results in pretty ugly and hairy code with obscure logic.
 493
 494    I chose to generalized it instead, so that the size
 495    of code does not increase practically, but it becomes
 496    much more general.
 497    Every prefix is assigned a "scope" value: "host" is local address,
 498    "link" is direct route,
 499    [ ... "site" ... "interior" ... ]
 500    and "universe" is true gateway route with global meaning.
 501
 502    Every prefix refers to a set of "nexthop"s (gw, oif),
 503    where gw must have narrower scope. This recursion stops
 504    when gw has LOCAL scope or if "nexthop" is declared ONLINK,
 505    which means that gw is forced to be on link.
 506
 507    Code is still hairy, but now it is apparently logically
 508    consistent and very flexible. F.e. as by-product it allows
 509    to co-exists in peace independent exterior and interior
 510    routing processes.
 511
 512    Normally it looks as following.
 513
 514    {universe prefix}  -> (gw, oif) [scope link]
 515                           |
 516                           |-> {link prefix} -> (gw, oif) [scope local]
 517                                                 |
 518                                                 |-> {local prefix} (terminal node)
 519  */
 520
 521 static int fib_check_nh(struct fib_config *cfg, struct fib_info *fi,
 522                         struct fib_nh *nh)
 523 {
 524         int err;
 525         struct net *net;
 526
 527         net = cfg->fc_nlinfo.nl_net;
 528         if (nh->nh_gw) {
 529                 struct fib_result res;
 530
 531 #ifdef CONFIG_IP_ROUTE_PERVASIVE
 532                 if (nh->nh_flags&RTNH_F_PERVASIVE)
 533                         return 0;
 534 #endif
 535                 if (nh->nh_flags&RTNH_F_ONLINK) {
 536                         struct net_device *dev;
 537
 538                         if (cfg->fc_scope >= RT_SCOPE_LINK)
 539                                 return -EINVAL;
 540                         if (inet_addr_type(net, nh->nh_gw) != RTN_UNICAST)
 541                                 return -EINVAL;
 542                         if ((dev = __dev_get_by_index(net, nh->nh_oif)) == NULL)
 543                                 return -ENODEV;
 544                         if (!(dev->flags&IFF_UP))
 545                                 return -ENETDOWN;
 546                         nh->nh_dev = dev;
 547                         dev_hold(dev);
 548                         nh->nh_scope = RT_SCOPE_LINK;
 549                         return 0;
 550                 }
 551                 {
 552                         struct flowi fl = {
 553                                 .nl_u = {
 554                                         .ip4_u = {
 555                                                 .daddr = nh->nh_gw,
 556                                                 .scope = cfg->fc_scope + 1,
 557                                         },
 558                                 },
 559                                 .oif = nh->nh_oif,
 560                         };
 561
 562                         /* It is not necessary, but requires a bit of thinking */
 563                         if (fl.fl4_scope < RT_SCOPE_LINK)
 564                                 fl.fl4_scope = RT_SCOPE_LINK;
 565                         if ((err = fib_lookup(net, &fl, &res)) != 0)
 566                                 return err;
 567                 }
 568                 err = -EINVAL;
 569                 if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
 570                         goto out;
 571                 nh->nh_scope = res.scope;
 572                 nh->nh_oif = FIB_RES_OIF(res);
 573                 if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
 574                         goto out;
 575                 dev_hold(nh->nh_dev);
 576                 err = -ENETDOWN;
 577                 if (!(nh->nh_dev->flags & IFF_UP))
 578                         goto out;
 579                 err = 0;
 580 out:
 581                 fib_res_put(&res);
 582                 return err;
 583         } else {
 584                 struct in_device *in_dev;
 585
 586                 if (nh->nh_flags&(RTNH_F_PERVASIVE|RTNH_F_ONLINK))
 587                         return -EINVAL;
 588
 589                 in_dev = inetdev_by_index(net, nh->nh_oif);
 590                 if (in_dev == NULL)
 591                         return -ENODEV;
 592                 if (!(in_dev->dev->flags&IFF_UP)) {
 593                         in_dev_put(in_dev);
 594                         return -ENETDOWN;
 595                 }
 596                 nh->nh_dev = in_dev->dev;
 597                 dev_hold(nh->nh_dev);
 598                 nh->nh_scope = RT_SCOPE_HOST;
 599                 in_dev_put(in_dev);
 600         }
 601         return 0;
 602 }
 603
 604 static inline unsigned int fib_laddr_hashfn(__be32 val)
 605 {
 606         unsigned int mask = (fib_hash_size - 1);
 607
 608         return ((__force u32)val ^ ((__force u32)val >> 7) ^ ((__force u32)val >> 14)) & mask;
 609 }
 610
 611 static struct hlist_head *fib_hash_alloc(int bytes)
 612 {
 613         if (bytes <= PAGE_SIZE)
 614                 return kzalloc(bytes, GFP_KERNEL);
 615         else
 616                 return (struct hlist_head *)
 617                         __get_free_pages(GFP_KERNEL | __GFP_ZERO, get_order(bytes));
 618 }
 619
 620 static void fib_hash_free(struct hlist_head *hash, int bytes)
 621 {
 622         if (!hash)
 623                 return;
 624
 625         if (bytes <= PAGE_SIZE)
 626                 kfree(hash);
 627         else
 628                 free_pages((unsigned long) hash, get_order(bytes));
 629 }
 630
 631 static void fib_hash_move(struct hlist_head *new_info_hash,
 632                           struct hlist_head *new_laddrhash,
 633                           unsigned int new_size)
 634 {
 635         struct hlist_head *old_info_hash, *old_laddrhash;
 636         unsigned int old_size = fib_hash_size;
 637         unsigned int i, bytes;
 638
 639         spin_lock_bh(&fib_info_lock);
 640         old_info_hash = fib_info_hash;
 641         old_laddrhash = fib_info_laddrhash;
 642         fib_hash_size = new_size;
 643
 644         for (i = 0; i < old_size; i++) {
 645                 struct hlist_head *head = &fib_info_hash[i];
 646                 struct hlist_node *node, *n;
 647                 struct fib_info *fi;
 648
 649                 hlist_for_each_entry_safe(fi, node, n, head, fib_hash) {
 650                         struct hlist_head *dest;
 651                         unsigned int new_hash;
 652
 653                         hlist_del(&fi->fib_hash);
 654
 655                         new_hash = fib_info_hashfn(fi);
 656                         dest = &new_info_hash[new_hash];
 657                         hlist_add_head(&fi->fib_hash, dest);
 658                 }
 659         }
 660         fib_info_hash = new_info_hash;
 661
 662         for (i = 0; i < old_size; i++) {
 663                 struct hlist_head *lhead = &fib_info_laddrhash[i];
 664                 struct hlist_node *node, *n;
 665                 struct fib_info *fi;
 666
 667                 hlist_for_each_entry_safe(fi, node, n, lhead, fib_lhash) {
 668                         struct hlist_head *ldest;
 669                         unsigned int new_hash;
 670
 671                         hlist_del(&fi->fib_lhash);
 672
 673                         new_hash = fib_laddr_hashfn(fi->fib_prefsrc);
 674                         ldest = &new_laddrhash[new_hash];
 675                         hlist_add_head(&fi->fib_lhash, ldest);
 676                 }
 677         }
 678         fib_info_laddrhash = new_laddrhash;
 679
 680         spin_unlock_bh(&fib_info_lock);
 681
 682         bytes = old_size * sizeof(struct hlist_head *);
 683         fib_hash_free(old_info_hash, bytes);
 684         fib_hash_free(old_laddrhash, bytes);
 685 }
 686
 687 struct fib_info *fib_create_info(struct fib_config *cfg)
 688 {
 689         int err;
 690         struct fib_info *fi = NULL;
 691         struct fib_info *ofi;
 692         int nhs = 1;
 693         struct net *net = cfg->fc_nlinfo.nl_net;
 694
 695         /* Fast check to catch the most weird cases */
 696         if (fib_props[cfg->fc_type].scope > cfg->fc_scope)
 697                 goto err_inval;
 698
 699 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 700         if (cfg->fc_mp) {
 701                 nhs = fib_count_nexthops(cfg->fc_mp, cfg->fc_mp_len);
 702                 if (nhs == 0)
 703                         goto err_inval;
 704         }
 705 #endif
 706
 707         err = -ENOBUFS;
 708         if (fib_info_cnt >= fib_hash_size) {
 709                 unsigned int new_size = fib_hash_size << 1;
 710                 struct hlist_head *new_info_hash;
 711                 struct hlist_head *new_laddrhash;
 712                 unsigned int bytes;
 713
 714                 if (!new_size)
 715                         new_size = 1;
 716                 bytes = new_size * sizeof(struct hlist_head *);
 717                 new_info_hash = fib_hash_alloc(bytes);
 718                 new_laddrhash = fib_hash_alloc(bytes);
 719                 if (!new_info_hash || !new_laddrhash) {
 720                         fib_hash_free(new_info_hash, bytes);
 721                         fib_hash_free(new_laddrhash, bytes);
 722                 } else
 723                         fib_hash_move(new_info_hash, new_laddrhash, new_size);
 724
 725                 if (!fib_hash_size)
 726                         goto failure;
 727         }
 728
 729         fi = kzalloc(sizeof(*fi)+nhs*sizeof(struct fib_nh), GFP_KERNEL);
 730         if (fi == NULL)
 731                 goto failure;
 732         fib_info_cnt++;
 733
 734         fi->fib_net = hold_net(net);
 735         fi->fib_protocol = cfg->fc_protocol;
 736         fi->fib_flags = cfg->fc_flags;
 737         fi->fib_priority = cfg->fc_priority;
 738         fi->fib_prefsrc = cfg->fc_prefsrc;
 739
 740         fi->fib_nhs = nhs;
 741         change_nexthops(fi) {
 742                 nh->nh_parent = fi;
 743         } endfor_nexthops(fi)
 744
 745         if (cfg->fc_mx) {
 746                 struct nlattr *nla;
 747                 int remaining;
 748
 749                 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
 750                         int type = nla_type(nla);
 751
 752                         if (type) {
 753                                 if (type > RTAX_MAX)
 754                                         goto err_inval;
 755                                 fi->fib_metrics[type - 1] = nla_get_u32(nla);
 756                         }
 757                 }
 758         }
 759
 760         if (cfg->fc_mp) {
 761 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 762                 err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg);
 763                 if (err != 0)
 764                         goto failure;
 765                 if (cfg->fc_oif && fi->fib_nh->nh_oif != cfg->fc_oif)
 766                         goto err_inval;
 767                 if (cfg->fc_gw && fi->fib_nh->nh_gw != cfg->fc_gw)
 768                         goto err_inval;
 769 #ifdef CONFIG_NET_CLS_ROUTE
 770                 if (cfg->fc_flow && fi->fib_nh->nh_tclassid != cfg->fc_flow)
 771                         goto err_inval;
 772 #endif
 773 #else
 774                 goto err_inval;
 775 #endif
 776         } else {
 777                 struct fib_nh *nh = fi->fib_nh;
 778
 779                 nh->nh_oif = cfg->fc_oif;
 780                 nh->nh_gw = cfg->fc_gw;
 781                 nh->nh_flags = cfg->fc_flags;
 782 #ifdef CONFIG_NET_CLS_ROUTE
 783                 nh->nh_tclassid = cfg->fc_flow;
 784 #endif
 785 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 786                 nh->nh_weight = 1;
 787 #endif
 788         }
 789
 790         if (fib_props[cfg->fc_type].error) {
 791                 if (cfg->fc_gw || cfg->fc_oif || cfg->fc_mp)
 792                         goto err_inval;
 793                 goto link_it;
 794         }
 795
 796         if (cfg->fc_scope > RT_SCOPE_HOST)
 797                 goto err_inval;
 798
 799         if (cfg->fc_scope == RT_SCOPE_HOST) {
 800                 struct fib_nh *nh = fi->fib_nh;
 801
 802                 /* Local address is added. */
 803                 if (nhs != 1 || nh->nh_gw)
 804                         goto err_inval;
 805                 nh->nh_scope = RT_SCOPE_NOWHERE;
 806                 nh->nh_dev = dev_get_by_index(net, fi->fib_nh->nh_oif);
 807                 err = -ENODEV;
 808                 if (nh->nh_dev == NULL)
 809                         goto failure;
 810         } else {
 811                 change_nexthops(fi) {
 812                         if ((err = fib_check_nh(cfg, fi, nh)) != 0)
 813                                 goto failure;
 814                 } endfor_nexthops(fi)
 815         }
 816
 817         if (fi->fib_prefsrc) {
 818                 if (cfg->fc_type != RTN_LOCAL || !cfg->fc_dst ||
 819                     fi->fib_prefsrc != cfg->fc_dst)
 820                         if (inet_addr_type(net, fi->fib_prefsrc) != RTN_LOCAL)
 821                                 goto err_inval;
 822         }
 823
 824 link_it:
 825         if ((ofi = fib_find_info(fi)) != NULL) {
 826                 fi->fib_dead = 1;
 827                 free_fib_info(fi);
 828                 ofi->fib_treeref++;
 829                 return ofi;
 830         }
 831
 832         fi->fib_treeref++;
 833         atomic_inc(&fi->fib_clntref);
 834         spin_lock_bh(&fib_info_lock);
 835         hlist_add_head(&fi->fib_hash,
 836                        &fib_info_hash[fib_info_hashfn(fi)]);
 837         if (fi->fib_prefsrc) {
 838                 struct hlist_head *head;
 839
 840                 head = &fib_info_laddrhash[fib_laddr_hashfn(fi->fib_prefsrc)];
 841                 hlist_add_head(&fi->fib_lhash, head);
 842         }
 843         change_nexthops(fi) {
 844                 struct hlist_head *head;
 845                 unsigned int hash;
 846
 847                 if (!nh->nh_dev)
 848                         continue;
 849                 hash = fib_devindex_hashfn(nh->nh_dev->ifindex);
 850                 head = &fib_info_devhash[hash];
 851                 hlist_add_head(&nh->nh_hash, head);
 852         } endfor_nexthops(fi)
 853         spin_unlock_bh(&fib_info_lock);
 854         return fi;
 855
 856 err_inval:
 857         err = -EINVAL;
 858
 859 failure:
 860         if (fi) {
 861                 fi->fib_dead = 1;
 862                 free_fib_info(fi);
 863         }
 864
 865         return ERR_PTR(err);
 866 }
 867
 868 /* Note! fib_semantic_match intentionally uses  RCU list functions. */
 869 int fib_semantic_match(struct list_head *head, const struct flowi *flp,
 870                        struct fib_result *res, __be32 zone, __be32 mask,
 871                         int prefixlen)
 872 {
 873         struct fib_alias *fa;
 874         int nh_sel = 0;
 875
 876         list_for_each_entry_rcu(fa, head, fa_list) {
 877                 int err;
 878
 879                 if (fa->fa_tos &&
 880                     fa->fa_tos != flp->fl4_tos)
 881                         continue;
 882
 883                 if (fa->fa_scope < flp->fl4_scope)
 884                         continue;
 885
 886                 fa->fa_state |= FA_S_ACCESSED;
 887
 888                 err = fib_props[fa->fa_type].error;
 889                 if (err == 0) {
 890                         struct fib_info *fi = fa->fa_info;
 891
 892                         if (fi->fib_flags & RTNH_F_DEAD)
 893                                 continue;
 894
 895                         switch (fa->fa_type) {
 896                         case RTN_UNICAST:
 897                         case RTN_LOCAL:
 898                         case RTN_BROADCAST:
 899                         case RTN_ANYCAST:
 900                         case RTN_MULTICAST:
 901                                 for_nexthops(fi) {
 902                                         if (nh->nh_flags&RTNH_F_DEAD)
 903                                                 continue;
 904                                         if (!flp->oif || flp->oif == nh->nh_oif)
 905                                                 break;
 906                                 }
 907 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 908                                 if (nhsel < fi->fib_nhs) {
 909                                         nh_sel = nhsel;
 910                                         goto out_fill_res;
 911                                 }
 912 #else
 913                                 if (nhsel < 1) {
 914                                         goto out_fill_res;
 915                                 }
 916 #endif
 917                                 endfor_nexthops(fi);
 918                                 continue;
 919
 920                         default:
 921                                 printk(KERN_WARNING "fib_semantic_match bad type %#x\n",
 922                                         fa->fa_type);
 923                                 return -EINVAL;
 924                         }
 925                 }
 926                 return err;
 927         }
 928         return 1;
 929
 930 out_fill_res:
 931         res->prefixlen = prefixlen;
 932         res->nh_sel = nh_sel;
 933         res->type = fa->fa_type;
 934         res->scope = fa->fa_scope;
 935         res->fi = fa->fa_info;
 936         atomic_inc(&res->fi->fib_clntref);
 937         return 0;
 938 }
 939
 940 /* Find appropriate source address to this destination */
 941
 942 __be32 __fib_res_prefsrc(struct fib_result *res)
 943 {
 944         return inet_select_addr(FIB_RES_DEV(*res), FIB_RES_GW(*res), res->scope);
 945 }
 946
 947 int fib_dump_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
 948                   u32 tb_id, u8 type, u8 scope, __be32 dst, int dst_len, u8 tos,
 949                   struct fib_info *fi, unsigned int flags)
 950 {
 951         struct nlmsghdr *nlh;
 952         struct rtmsg *rtm;
 953
 954         nlh = nlmsg_put(skb, pid, seq, event, sizeof(*rtm), flags);
 955         if (nlh == NULL)
 956                 return -EMSGSIZE;
 957
 958         rtm = nlmsg_data(nlh);
 959         rtm->rtm_family = AF_INET;
 960         rtm->rtm_dst_len = dst_len;
 961         rtm->rtm_src_len = 0;
 962         rtm->rtm_tos = tos;
 963         if (tb_id < 256)
 964                 rtm->rtm_table = tb_id;
 965         else
 966                 rtm->rtm_table = RT_TABLE_COMPAT;
 967         NLA_PUT_U32(skb, RTA_TABLE, tb_id);
 968         rtm->rtm_type = type;
 969         rtm->rtm_flags = fi->fib_flags;
 970         rtm->rtm_scope = scope;
 971         rtm->rtm_protocol = fi->fib_protocol;
 972
 973         if (rtm->rtm_dst_len)
 974                 NLA_PUT_BE32(skb, RTA_DST, dst);
 975
 976         if (fi->fib_priority)
 977                 NLA_PUT_U32(skb, RTA_PRIORITY, fi->fib_priority);
 978
 979         if (rtnetlink_put_metrics(skb, fi->fib_metrics) < 0)
 980                 goto nla_put_failure;
 981
 982         if (fi->fib_prefsrc)
 983                 NLA_PUT_BE32(skb, RTA_PREFSRC, fi->fib_prefsrc);
 984
 985         if (fi->fib_nhs == 1) {
 986                 if (fi->fib_nh->nh_gw)
 987                         NLA_PUT_BE32(skb, RTA_GATEWAY, fi->fib_nh->nh_gw);
 988
 989                 if (fi->fib_nh->nh_oif)
 990                         NLA_PUT_U32(skb, RTA_OIF, fi->fib_nh->nh_oif);
 991 #ifdef CONFIG_NET_CLS_ROUTE
 992                 if (fi->fib_nh[0].nh_tclassid)
 993                         NLA_PUT_U32(skb, RTA_FLOW, fi->fib_nh[0].nh_tclassid);
 994 #endif
 995         }
 996 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 997         if (fi->fib_nhs > 1) {
 998                 struct rtnexthop *rtnh;
 999                 struct nlattr *mp;
1000
1001                 mp = nla_nest_start(skb, RTA_MULTIPATH);
1002                 if (mp == NULL)
1003                         goto nla_put_failure;
1004
1005                 for_nexthops(fi) {
1006                         rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
1007                         if (rtnh == NULL)
1008                                 goto nla_put_failure;
1009
1010                         rtnh->rtnh_flags = nh->nh_flags & 0xFF;
1011                         rtnh->rtnh_hops = nh->nh_weight - 1;
1012                         rtnh->rtnh_ifindex = nh->nh_oif;
1013
1014                         if (nh->nh_gw)
1015                                 NLA_PUT_BE32(skb, RTA_GATEWAY, nh->nh_gw);
1016 #ifdef CONFIG_NET_CLS_ROUTE
1017                         if (nh->nh_tclassid)
1018                                 NLA_PUT_U32(skb, RTA_FLOW, nh->nh_tclassid);
1019 #endif
1020                         /* length of rtnetlink header + attributes */
1021                         rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *) rtnh;
1022                 } endfor_nexthops(fi);
1023
1024                 nla_nest_end(skb, mp);
1025         }
1026 #endif
1027         return nlmsg_end(skb, nlh);
1028
1029 nla_put_failure:
1030         nlmsg_cancel(skb, nlh);
1031         return -EMSGSIZE;
1032 }
1033
1034 /*
1035    Update FIB if:
1036    - local address disappeared -> we must delete all the entries
1037      referring to it.
1038    - device went down -> we must shutdown all nexthops going via it.
1039  */
1040 int fib_sync_down_addr(struct net *net, __be32 local)
1041 {
1042         int ret = 0;
1043         unsigned int hash = fib_laddr_hashfn(local);
1044         struct hlist_head *head = &fib_info_laddrhash[hash];
1045         struct hlist_node *node;
1046         struct fib_info *fi;
1047
1048         if (fib_info_laddrhash == NULL || local == 0)
1049                 return 0;
1050
1051         hlist_for_each_entry(fi, node, head, fib_lhash) {
1052                 if (fi->fib_net != net)
1053                         continue;
1054                 if (fi->fib_prefsrc == local) {
1055                         fi->fib_flags |= RTNH_F_DEAD;
1056                         ret++;
1057                 }
1058         }
1059         return ret;
1060 }
1061
1062 int fib_sync_down_dev(struct net_device *dev, int force)
1063 {
1064         int ret = 0;
1065         int scope = RT_SCOPE_NOWHERE;
1066         struct fib_info *prev_fi = NULL;
1067         unsigned int hash = fib_devindex_hashfn(dev->ifindex);
1068         struct hlist_head *head = &fib_info_devhash[hash];
1069         struct hlist_node *node;
1070         struct fib_nh *nh;
1071
1072         if (force)
1073                 scope = -1;
1074
1075         hlist_for_each_entry(nh, node, head, nh_hash) {
1076                 struct fib_info *fi = nh->nh_parent;
1077                 int dead;
1078
1079                 BUG_ON(!fi->fib_nhs);
1080                 if (nh->nh_dev != dev || fi == prev_fi)
1081                         continue;
1082                 prev_fi = fi;
1083                 dead = 0;
1084                 change_nexthops(fi) {
1085                         if (nh->nh_flags&RTNH_F_DEAD)
1086                                 dead++;
1087                         else if (nh->nh_dev == dev &&
1088                                         nh->nh_scope != scope) {
1089                                 nh->nh_flags |= RTNH_F_DEAD;
1090 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1091                                 spin_lock_bh(&fib_multipath_lock);
1092                                 fi->fib_power -= nh->nh_power;
1093                                 nh->nh_power = 0;
1094                                 spin_unlock_bh(&fib_multipath_lock);
1095 #endif
1096                                 dead++;
1097                         }
1098 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1099                         if (force > 1 && nh->nh_dev == dev) {
1100                                 dead = fi->fib_nhs;
1101                                 break;
1102                         }
1103 #endif
1104                 } endfor_nexthops(fi)
1105                 if (dead == fi->fib_nhs) {
1106                         fi->fib_flags |= RTNH_F_DEAD;
1107                         ret++;
1108                 }
1109         }
1110
1111         return ret;
1112 }
1113
1114 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1115
1116 /*
1117    Dead device goes up. We wake up dead nexthops.
1118    It takes sense only on multipath routes.
1119  */
1120
1121 int fib_sync_up(struct net_device *dev)
1122 {
1123         struct fib_info *prev_fi;
1124         unsigned int hash;
1125         struct hlist_head *head;
1126         struct hlist_node *node;
1127         struct fib_nh *nh;
1128         int ret;
1129
1130         if (!(dev->flags&IFF_UP))
1131                 return 0;
1132
1133         prev_fi = NULL;
1134         hash = fib_devindex_hashfn(dev->ifindex);
1135         head = &fib_info_devhash[hash];
1136         ret = 0;
1137
1138         hlist_for_each_entry(nh, node, head, nh_hash) {
1139                 struct fib_info *fi = nh->nh_parent;
1140                 int alive;
1141
1142                 BUG_ON(!fi->fib_nhs);
1143                 if (nh->nh_dev != dev || fi == prev_fi)
1144                         continue;
1145
1146                 prev_fi = fi;
1147                 alive = 0;
1148                 change_nexthops(fi) {
1149                         if (!(nh->nh_flags&RTNH_F_DEAD)) {
1150                                 alive++;
1151                                 continue;
1152                         }
1153                         if (nh->nh_dev == NULL || !(nh->nh_dev->flags&IFF_UP))
1154                                 continue;
1155                         if (nh->nh_dev != dev || !__in_dev_get_rtnl(dev))
1156                                 continue;
1157                         alive++;
1158                         spin_lock_bh(&fib_multipath_lock);
1159                         nh->nh_power = 0;
1160                         nh->nh_flags &= ~RTNH_F_DEAD;
1161                         spin_unlock_bh(&fib_multipath_lock);
1162                 } endfor_nexthops(fi)
1163
1164                 if (alive > 0) {
1165                         fi->fib_flags &= ~RTNH_F_DEAD;
1166                         ret++;
1167                 }
1168         }
1169
1170         return ret;
1171 }
1172
1173 /*
1174    The algorithm is suboptimal, but it provides really
1175    fair weighted route distribution.
1176  */
1177
1178 void fib_select_multipath(const struct flowi *flp, struct fib_result *res)
1179 {
1180         struct fib_info *fi = res->fi;
1181         int w;
1182
1183         spin_lock_bh(&fib_multipath_lock);
1184         if (fi->fib_power <= 0) {
1185                 int power = 0;
1186                 change_nexthops(fi) {
1187                         if (!(nh->nh_flags&RTNH_F_DEAD)) {
1188                                 power += nh->nh_weight;
1189                                 nh->nh_power = nh->nh_weight;
1190                         }
1191                 } endfor_nexthops(fi);
1192                 fi->fib_power = power;
1193                 if (power <= 0) {
1194                         spin_unlock_bh(&fib_multipath_lock);
1195                         /* Race condition: route has just become dead. */
1196                         res->nh_sel = 0;
1197                         return;
1198                 }
1199         }
1200
1201
1202         /* w should be random number [0..fi->fib_power-1],
1203            it is pretty bad approximation.
1204          */
1205
1206         w = jiffies % fi->fib_power;
1207
1208         change_nexthops(fi) {
1209                 if (!(nh->nh_flags&RTNH_F_DEAD) && nh->nh_power) {
1210                         if ((w -= nh->nh_power) <= 0) {
1211                                 nh->nh_power--;
1212                                 fi->fib_power--;
1213                                 res->nh_sel = nhsel;
1214                                 spin_unlock_bh(&fib_multipath_lock);
1215                                 return;
1216                         }
1217                 }
1218         } endfor_nexthops(fi);
1219
1220         /* Race condition: route has just become dead. */
1221         res->nh_sel = 0;
1222         spin_unlock_bh(&fib_multipath_lock);
1223 }
1224 #endif