net/ipv4/route.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  *              ROUTE - implementation of the IP router.
   7  *
   8  * Version:     $Id: route.c,v 1.103 2002/01/12 07:44:09 davem Exp $
   9  *
  10  * Authors:     Ross Biro
  11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
  13  *              Linus Torvalds, <Linus.Torvalds@helsinki.fi>
  14  *              Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  15  *
  16  * Fixes:
  17  *              Alan Cox        :       Verify area fixes.
  18  *              Alan Cox        :       cli() protects routing changes
  19  *              Rui Oliveira    :       ICMP routing table updates
  20  *              (rco@di.uminho.pt)      Routing table insertion and update
  21  *              Linus Torvalds  :       Rewrote bits to be sensible
  22  *              Alan Cox        :       Added BSD route gw semantics
  23  *              Alan Cox        :       Super /proc >4K
  24  *              Alan Cox        :       MTU in route table
  25  *              Alan Cox        :       MSS actually. Also added the window
  26  *                                      clamper.
  27  *              Sam Lantinga    :       Fixed route matching in rt_del()
  28  *              Alan Cox        :       Routing cache support.
  29  *              Alan Cox        :       Removed compatibility cruft.
  30  *              Alan Cox        :       RTF_REJECT support.
  31  *              Alan Cox        :       TCP irtt support.
  32  *              Jonathan Naylor :       Added Metric support.
  33  *      Miquel van Smoorenburg  :       BSD API fixes.
  34  *      Miquel van Smoorenburg  :       Metrics.
  35  *              Alan Cox        :       Use __u32 properly
  36  *              Alan Cox        :       Aligned routing errors more closely with BSD
  37  *                                      our system is still very different.
  38  *              Alan Cox        :       Faster /proc handling
  39  *      Alexey Kuznetsov        :       Massive rework to support tree based routing,
  40  *                                      routing caches and better behaviour.
  41  *
  42  *              Olaf Erb        :       irtt wasn't being copied right.
  43  *              Bjorn Ekwall    :       Kerneld route support.
  44  *              Alan Cox        :       Multicast fixed (I hope)
  45  *              Pavel Krauz     :       Limited broadcast fixed
  46  *              Mike McLagan    :       Routing by source
  47  *      Alexey Kuznetsov        :       End of old history. Split to fib.c and
  48  *                                      route.c and rewritten from scratch.
  49  *              Andi Kleen      :       Load-limit warning messages.
  50  *      Vitaly E. Lavrov        :       Transparent proxy revived after year coma.
  51  *      Vitaly E. Lavrov        :       Race condition in ip_route_input_slow.
  52  *      Tobias Ringstrom        :       Uninitialized res.type in ip_route_output_slow.
  53  *      Vladimir V. Ivanov      :       IP rule info (flowid) is really useful.
  54  *              Marc Boucher    :       routing by fwmark
  55  *      Robert Olsson           :       Added rt_cache statistics
  56  *      Arnaldo C. Melo         :       Convert proc stuff to seq_file
  57  *
  58  *              This program is free software; you can redistribute it and/or
  59  *              modify it under the terms of the GNU General Public License
  60  *              as published by the Free Software Foundation; either version
  61  *              2 of the License, or (at your option) any later version.
  62  */
  63
  64 #include <linux/config.h>
  65 #include <linux/module.h>
  66 #include <asm/uaccess.h>
  67 #include <asm/system.h>
  68 #include <linux/bitops.h>
  69 #include <linux/types.h>
  70 #include <linux/kernel.h>
  71 #include <linux/sched.h>
  72 #include <linux/mm.h>
  73 #include <linux/string.h>
  74 #include <linux/socket.h>
  75 #include <linux/sockios.h>
  76 #include <linux/errno.h>
  77 #include <linux/in.h>
  78 #include <linux/inet.h>
  79 #include <linux/netdevice.h>
  80 #include <linux/proc_fs.h>
  81 #include <linux/init.h>
  82 #include <linux/skbuff.h>
  83 #include <linux/rtnetlink.h>
  84 #include <linux/inetdevice.h>
  85 #include <linux/igmp.h>
  86 #include <linux/pkt_sched.h>
  87 #include <linux/mroute.h>
  88 #include <linux/netfilter_ipv4.h>
  89 #include <linux/random.h>
  90 #include <linux/jhash.h>
  91 #include <linux/rcupdate.h>
  92 #include <linux/times.h>
  93 #include <net/protocol.h>
  94 #include <net/ip.h>
  95 #include <net/route.h>
  96 #include <net/inetpeer.h>
  97 #include <net/sock.h>
  98 #include <net/ip_fib.h>
  99 #include <net/arp.h>
 100 #include <net/tcp.h>
 101 #include <net/icmp.h>
 102 #include <net/xfrm.h>
 103 #include <net/ip_mp_alg.h>
 104 #ifdef CONFIG_SYSCTL
 105 #include <linux/sysctl.h>
 106 #endif
 107
 108 #define RT_FL_TOS(oldflp) \
 109     ((u32)(oldflp->fl4_tos & (IPTOS_RT_MASK | RTO_ONLINK)))
 110
 111 #define IP_MAX_MTU      0xFFF0
 112
 113 #define RT_GC_TIMEOUT (300*HZ)
 114
 115 static int ip_rt_min_delay              = 2 * HZ;
 116 static int ip_rt_max_delay              = 10 * HZ;
 117 static int ip_rt_max_size;
 118 static int ip_rt_gc_timeout             = RT_GC_TIMEOUT;
 119 static int ip_rt_gc_interval            = 60 * HZ;
 120 static int ip_rt_gc_min_interval        = HZ / 2;
 121 static int ip_rt_redirect_number        = 9;
 122 static int ip_rt_redirect_load          = HZ / 50;
 123 static int ip_rt_redirect_silence       = ((HZ / 50) << (9 + 1));
 124 static int ip_rt_error_cost             = HZ;
 125 static int ip_rt_error_burst            = 5 * HZ;
 126 static int ip_rt_gc_elasticity          = 8;
 127 static int ip_rt_mtu_expires            = 10 * 60 * HZ;
 128 static int ip_rt_min_pmtu               = 512 + 20 + 20;
 129 static int ip_rt_min_advmss             = 256;
 130 static int ip_rt_secret_interval        = 10 * 60 * HZ;
 131 static unsigned long rt_deadline;
 132
 133 #define RTprint(a...)   printk(KERN_DEBUG a)
 134
 135 static struct timer_list rt_flush_timer;
 136 static struct timer_list rt_periodic_timer;
 137 static struct timer_list rt_secret_timer;
 138
 139 /*
 140  *      Interface to generic destination cache.
 141  */
 142
 143 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
 144 static void              ipv4_dst_destroy(struct dst_entry *dst);
 145 static void              ipv4_dst_ifdown(struct dst_entry *dst,
 146                                          struct net_device *dev, int how);
 147 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
 148 static void              ipv4_link_failure(struct sk_buff *skb);
 149 static void              ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
 150 static int rt_garbage_collect(void);
 151
 152
 153 static struct dst_ops ipv4_dst_ops = {
 154         .family =               AF_INET,
 155         .protocol =             __constant_htons(ETH_P_IP),
 156         .gc =                   rt_garbage_collect,
 157         .check =                ipv4_dst_check,
 158         .destroy =              ipv4_dst_destroy,
 159         .ifdown =               ipv4_dst_ifdown,
 160         .negative_advice =      ipv4_negative_advice,
 161         .link_failure =         ipv4_link_failure,
 162         .update_pmtu =          ip_rt_update_pmtu,
 163         .entry_size =           sizeof(struct rtable),
 164 };
 165
 166 #define ECN_OR_COST(class)      TC_PRIO_##class
 167
 168 __u8 ip_tos2prio[16] = {
 169         TC_PRIO_BESTEFFORT,
 170         ECN_OR_COST(FILLER),
 171         TC_PRIO_BESTEFFORT,
 172         ECN_OR_COST(BESTEFFORT),
 173         TC_PRIO_BULK,
 174         ECN_OR_COST(BULK),
 175         TC_PRIO_BULK,
 176         ECN_OR_COST(BULK),
 177         TC_PRIO_INTERACTIVE,
 178         ECN_OR_COST(INTERACTIVE),
 179         TC_PRIO_INTERACTIVE,
 180         ECN_OR_COST(INTERACTIVE),
 181         TC_PRIO_INTERACTIVE_BULK,
 182         ECN_OR_COST(INTERACTIVE_BULK),
 183         TC_PRIO_INTERACTIVE_BULK,
 184         ECN_OR_COST(INTERACTIVE_BULK)
 185 };
 186
 187
 188 /*
 189  * Route cache.
 190  */
 191
 192 /* The locking scheme is rather straight forward:
 193  *
 194  * 1) Read-Copy Update protects the buckets of the central route hash.
 195  * 2) Only writers remove entries, and they hold the lock
 196  *    as they look at rtable reference counts.
 197  * 3) Only readers acquire references to rtable entries,
 198  *    they do so with atomic increments and with the
 199  *    lock held.
 200  */
 201
 202 struct rt_hash_bucket {
 203         struct rtable   *chain;
 204         spinlock_t      lock;
 205 } __attribute__((__aligned__(8)));
 206
 207 static struct rt_hash_bucket    *rt_hash_table;
 208 static unsigned                 rt_hash_mask;
 209 static int                      rt_hash_log;
 210 static unsigned int             rt_hash_rnd;
 211
 212 struct rt_cache_stat *rt_cache_stat;
 213
 214 static int rt_intern_hash(unsigned hash, struct rtable *rth,
 215                                 struct rtable **res);
 216
 217 static unsigned int rt_hash_code(u32 daddr, u32 saddr, u8 tos)
 218 {
 219         return (jhash_3words(daddr, saddr, (u32) tos, rt_hash_rnd)
 220                 & rt_hash_mask);
 221 }
 222
 223 #ifdef CONFIG_PROC_FS
 224 struct rt_cache_iter_state {
 225         int bucket;
 226 };
 227
 228 static struct rtable *rt_cache_get_first(struct seq_file *seq)
 229 {
 230         struct rtable *r = NULL;
 231         struct rt_cache_iter_state *st = seq->private;
 232
 233         for (st->bucket = rt_hash_mask; st->bucket >= 0; --st->bucket) {
 234                 rcu_read_lock_bh();
 235                 r = rt_hash_table[st->bucket].chain;
 236                 if (r)
 237                         break;
 238                 rcu_read_unlock_bh();
 239         }
 240         return r;
 241 }
 242
 243 static struct rtable *rt_cache_get_next(struct seq_file *seq, struct rtable *r)
 244 {
 245         struct rt_cache_iter_state *st = rcu_dereference(seq->private);
 246
 247         r = r->u.rt_next;
 248         while (!r) {
 249                 rcu_read_unlock_bh();
 250                 if (--st->bucket < 0)
 251                         break;
 252                 rcu_read_lock_bh();
 253                 r = rt_hash_table[st->bucket].chain;
 254         }
 255         return r;
 256 }
 257
 258 static struct rtable *rt_cache_get_idx(struct seq_file *seq, loff_t pos)
 259 {
 260         struct rtable *r = rt_cache_get_first(seq);
 261
 262         if (r)
 263                 while (pos && (r = rt_cache_get_next(seq, r)))
 264                         --pos;
 265         return pos ? NULL : r;
 266 }
 267
 268 static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
 269 {
 270         return *pos ? rt_cache_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
 271 }
 272
 273 static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 274 {
 275         struct rtable *r = NULL;
 276
 277         if (v == SEQ_START_TOKEN)
 278                 r = rt_cache_get_first(seq);
 279         else
 280                 r = rt_cache_get_next(seq, v);
 281         ++*pos;
 282         return r;
 283 }
 284
 285 static void rt_cache_seq_stop(struct seq_file *seq, void *v)
 286 {
 287         if (v && v != SEQ_START_TOKEN)
 288                 rcu_read_unlock_bh();
 289 }
 290
 291 static int rt_cache_seq_show(struct seq_file *seq, void *v)
 292 {
 293         if (v == SEQ_START_TOKEN)
 294                 seq_printf(seq, "%-127s\n",
 295                            "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
 296                            "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
 297                            "HHUptod\tSpecDst");
 298         else {
 299                 struct rtable *r = v;
 300                 char temp[256];
 301
 302                 sprintf(temp, "%s\t%08lX\t%08lX\t%8X\t%d\t%u\t%d\t"
 303                               "%08lX\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X",
 304                         r->u.dst.dev ? r->u.dst.dev->name : "*",
 305                         (unsigned long)r->rt_dst, (unsigned long)r->rt_gateway,
 306                         r->rt_flags, atomic_read(&r->u.dst.__refcnt),
 307                         r->u.dst.__use, 0, (unsigned long)r->rt_src,
 308                         (dst_metric(&r->u.dst, RTAX_ADVMSS) ?
 309                              (int)dst_metric(&r->u.dst, RTAX_ADVMSS) + 40 : 0),
 310                         dst_metric(&r->u.dst, RTAX_WINDOW),
 311                         (int)((dst_metric(&r->u.dst, RTAX_RTT) >> 3) +
 312                               dst_metric(&r->u.dst, RTAX_RTTVAR)),
 313                         r->fl.fl4_tos,
 314                         r->u.dst.hh ? atomic_read(&r->u.dst.hh->hh_refcnt) : -1,
 315                         r->u.dst.hh ? (r->u.dst.hh->hh_output ==
 316                                        dev_queue_xmit) : 0,
 317                         r->rt_spec_dst);
 318                 seq_printf(seq, "%-127s\n", temp);
 319         }
 320         return 0;
 321 }
 322
 323 static struct seq_operations rt_cache_seq_ops = {
 324         .start  = rt_cache_seq_start,
 325         .next   = rt_cache_seq_next,
 326         .stop   = rt_cache_seq_stop,
 327         .show   = rt_cache_seq_show,
 328 };
 329
 330 static int rt_cache_seq_open(struct inode *inode, struct file *file)
 331 {
 332         struct seq_file *seq;
 333         int rc = -ENOMEM;
 334         struct rt_cache_iter_state *s = kmalloc(sizeof(*s), GFP_KERNEL);
 335
 336         if (!s)
 337                 goto out;
 338         rc = seq_open(file, &rt_cache_seq_ops);
 339         if (rc)
 340                 goto out_kfree;
 341         seq          = file->private_data;
 342         seq->private = s;
 343         memset(s, 0, sizeof(*s));
 344 out:
 345         return rc;
 346 out_kfree:
 347         kfree(s);
 348         goto out;
 349 }
 350
 351 static struct file_operations rt_cache_seq_fops = {
 352         .owner   = THIS_MODULE,
 353         .open    = rt_cache_seq_open,
 354         .read    = seq_read,
 355         .llseek  = seq_lseek,
 356         .release = seq_release_private,
 357 };
 358
 359
 360 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
 361 {
 362         int cpu;
 363
 364         if (*pos == 0)
 365                 return SEQ_START_TOKEN;
 366
 367         for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
 368                 if (!cpu_possible(cpu))
 369                         continue;
 370                 *pos = cpu+1;
 371                 return per_cpu_ptr(rt_cache_stat, cpu);
 372         }
 373         return NULL;
 374 }
 375
 376 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 377 {
 378         int cpu;
 379
 380         for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
 381                 if (!cpu_possible(cpu))
 382                         continue;
 383                 *pos = cpu+1;
 384                 return per_cpu_ptr(rt_cache_stat, cpu);
 385         }
 386         return NULL;
 387
 388 }
 389
 390 static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
 391 {
 392
 393 }
 394
 395 static int rt_cpu_seq_show(struct seq_file *seq, void *v)
 396 {
 397         struct rt_cache_stat *st = v;
 398
 399         if (v == SEQ_START_TOKEN) {
 400                 seq_printf(seq, "entries  in_hit in_slow_tot in_slow_mc in_no_route in_brd in_martian_dst in_martian_src  out_hit out_slow_tot out_slow_mc  gc_total gc_ignored gc_goal_miss gc_dst_overflow in_hlist_search out_hlist_search\n");
 401                 return 0;
 402         }
 403
 404         seq_printf(seq,"%08x  %08x %08x %08x %08x %08x %08x %08x "
 405                    " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
 406                    atomic_read(&ipv4_dst_ops.entries),
 407                    st->in_hit,
 408                    st->in_slow_tot,
 409                    st->in_slow_mc,
 410                    st->in_no_route,
 411                    st->in_brd,
 412                    st->in_martian_dst,
 413                    st->in_martian_src,
 414
 415                    st->out_hit,
 416                    st->out_slow_tot,
 417                    st->out_slow_mc,
 418
 419                    st->gc_total,
 420                    st->gc_ignored,
 421                    st->gc_goal_miss,
 422                    st->gc_dst_overflow,
 423                    st->in_hlist_search,
 424                    st->out_hlist_search
 425                 );
 426         return 0;
 427 }
 428
 429 static struct seq_operations rt_cpu_seq_ops = {
 430         .start  = rt_cpu_seq_start,
 431         .next   = rt_cpu_seq_next,
 432         .stop   = rt_cpu_seq_stop,
 433         .show   = rt_cpu_seq_show,
 434 };
 435
 436
 437 static int rt_cpu_seq_open(struct inode *inode, struct file *file)
 438 {
 439         return seq_open(file, &rt_cpu_seq_ops);
 440 }
 441
 442 static struct file_operations rt_cpu_seq_fops = {
 443         .owner   = THIS_MODULE,
 444         .open    = rt_cpu_seq_open,
 445         .read    = seq_read,
 446         .llseek  = seq_lseek,
 447         .release = seq_release,
 448 };
 449
 450 #endif /* CONFIG_PROC_FS */
 451
 452 static __inline__ void rt_free(struct rtable *rt)
 453 {
 454         multipath_remove(rt);
 455         call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
 456 }
 457
 458 static __inline__ void rt_drop(struct rtable *rt)
 459 {
 460         multipath_remove(rt);
 461         ip_rt_put(rt);
 462         call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
 463 }
 464
 465 static __inline__ int rt_fast_clean(struct rtable *rth)
 466 {
 467         /* Kill broadcast/multicast entries very aggresively, if they
 468            collide in hash table with more useful entries */
 469         return (rth->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) &&
 470                 rth->fl.iif && rth->u.rt_next;
 471 }
 472
 473 static __inline__ int rt_valuable(struct rtable *rth)
 474 {
 475         return (rth->rt_flags & (RTCF_REDIRECTED | RTCF_NOTIFY)) ||
 476                 rth->u.dst.expires;
 477 }
 478
 479 static int rt_may_expire(struct rtable *rth, unsigned long tmo1, unsigned long tmo2)
 480 {
 481         unsigned long age;
 482         int ret = 0;
 483
 484         if (atomic_read(&rth->u.dst.__refcnt))
 485                 goto out;
 486
 487         ret = 1;
 488         if (rth->u.dst.expires &&
 489             time_after_eq(jiffies, rth->u.dst.expires))
 490                 goto out;
 491
 492         age = jiffies - rth->u.dst.lastuse;
 493         ret = 0;
 494         if ((age <= tmo1 && !rt_fast_clean(rth)) ||
 495             (age <= tmo2 && rt_valuable(rth)))
 496                 goto out;
 497         ret = 1;
 498 out:    return ret;
 499 }
 500
 501 /* Bits of score are:
 502  * 31: very valuable
 503  * 30: not quite useless
 504  * 29..0: usage counter
 505  */
 506 static inline u32 rt_score(struct rtable *rt)
 507 {
 508         u32 score = jiffies - rt->u.dst.lastuse;
 509
 510         score = ~score & ~(3<<30);
 511
 512         if (rt_valuable(rt))
 513                 score |= (1<<31);
 514
 515         if (!rt->fl.iif ||
 516             !(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST|RTCF_LOCAL)))
 517                 score |= (1<<30);
 518
 519         return score;
 520 }
 521
 522 static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
 523 {
 524         return memcmp(&fl1->nl_u.ip4_u, &fl2->nl_u.ip4_u, sizeof(fl1->nl_u.ip4_u)) == 0 &&
 525                fl1->oif     == fl2->oif &&
 526                fl1->iif     == fl2->iif;
 527 }
 528
 529 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
 530 static struct rtable **rt_remove_balanced_route(struct rtable **chain_head,
 531                                                 struct rtable *expentry,
 532                                                 int *removed_count)
 533 {
 534         int passedexpired = 0;
 535         struct rtable **nextstep = NULL;
 536         struct rtable **rthp = chain_head;
 537         struct rtable *rth;
 538
 539         if (removed_count)
 540                 *removed_count = 0;
 541
 542         while ((rth = *rthp) != NULL) {
 543                 if (rth == expentry)
 544                         passedexpired = 1;
 545
 546                 if (((*rthp)->u.dst.flags & DST_BALANCED) != 0  &&
 547                     compare_keys(&(*rthp)->fl, &expentry->fl)) {
 548                         if (*rthp == expentry) {
 549                                 *rthp = rth->u.rt_next;
 550                                 continue;
 551                         } else {
 552                                 *rthp = rth->u.rt_next;
 553                                 rt_free(rth);
 554                                 if (removed_count)
 555                                         ++(*removed_count);
 556                         }
 557                 } else {
 558                         if (!((*rthp)->u.dst.flags & DST_BALANCED) &&
 559                             passedexpired && !nextstep)
 560                                 nextstep = &rth->u.rt_next;
 561
 562                         rthp = &rth->u.rt_next;
 563                 }
 564         }
 565
 566         rt_free(expentry);
 567         if (removed_count)
 568                 ++(*removed_count);
 569
 570         return nextstep;
 571 }
 572 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
 573
 574
 575 /* This runs via a timer and thus is always in BH context. */
 576 static void rt_check_expire(unsigned long dummy)
 577 {
 578         static int rover;
 579         int i = rover, t;
 580         struct rtable *rth, **rthp;
 581         unsigned long now = jiffies;
 582
 583         for (t = ip_rt_gc_interval << rt_hash_log; t >= 0;
 584              t -= ip_rt_gc_timeout) {
 585                 unsigned long tmo = ip_rt_gc_timeout;
 586
 587                 i = (i + 1) & rt_hash_mask;
 588                 rthp = &rt_hash_table[i].chain;
 589
 590                 spin_lock(&rt_hash_table[i].lock);
 591                 while ((rth = *rthp) != NULL) {
 592                         if (rth->u.dst.expires) {
 593                                 /* Entry is expired even if it is in use */
 594                                 if (time_before_eq(now, rth->u.dst.expires)) {
 595                                         tmo >>= 1;
 596                                         rthp = &rth->u.rt_next;
 597                                         continue;
 598                                 }
 599                         } else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout)) {
 600                                 tmo >>= 1;
 601                                 rthp = &rth->u.rt_next;
 602                                 continue;
 603                         }
 604
 605                         /* Cleanup aged off entries. */
 606 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
 607                         /* remove all related balanced entries if necessary */
 608                         if (rth->u.dst.flags & DST_BALANCED) {
 609                                 rthp = rt_remove_balanced_route(
 610                                         &rt_hash_table[i].chain,
 611                                         rth, NULL);
 612                                 if (!rthp)
 613                                         break;
 614                         } else {
 615                                 *rthp = rth->u.rt_next;
 616                                 rt_free(rth);
 617                         }
 618 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
 619                         *rthp = rth->u.rt_next;
 620                         rt_free(rth);
 621 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
 622                 }
 623                 spin_unlock(&rt_hash_table[i].lock);
 624
 625                 /* Fallback loop breaker. */
 626                 if (time_after(jiffies, now))
 627                         break;
 628         }
 629         rover = i;
 630         mod_timer(&rt_periodic_timer, now + ip_rt_gc_interval);
 631 }
 632
 633 /* This can run from both BH and non-BH contexts, the latter
 634  * in the case of a forced flush event.
 635  */
 636 static void rt_run_flush(unsigned long dummy)
 637 {
 638         int i;
 639         struct rtable *rth, *next;
 640
 641         rt_deadline = 0;
 642
 643         get_random_bytes(&rt_hash_rnd, 4);
 644
 645         for (i = rt_hash_mask; i >= 0; i--) {
 646                 spin_lock_bh(&rt_hash_table[i].lock);
 647                 rth = rt_hash_table[i].chain;
 648                 if (rth)
 649                         rt_hash_table[i].chain = NULL;
 650                 spin_unlock_bh(&rt_hash_table[i].lock);
 651
 652                 for (; rth; rth = next) {
 653                         next = rth->u.rt_next;
 654                         rt_free(rth);
 655                 }
 656         }
 657 }
 658
 659 static DEFINE_SPINLOCK(rt_flush_lock);
 660
 661 void rt_cache_flush(int delay)
 662 {
 663         unsigned long now = jiffies;
 664         int user_mode = !in_softirq();
 665
 666         if (delay < 0)
 667                 delay = ip_rt_min_delay;
 668
 669         /* flush existing multipath state*/
 670         multipath_flush();
 671
 672         spin_lock_bh(&rt_flush_lock);
 673
 674         if (del_timer(&rt_flush_timer) && delay > 0 && rt_deadline) {
 675                 long tmo = (long)(rt_deadline - now);
 676
 677                 /* If flush timer is already running
 678                    and flush request is not immediate (delay > 0):
 679
 680                    if deadline is not achieved, prolongate timer to "delay",
 681                    otherwise fire it at deadline time.
 682                  */
 683
 684                 if (user_mode && tmo < ip_rt_max_delay-ip_rt_min_delay)
 685                         tmo = 0;
 686
 687                 if (delay > tmo)
 688                         delay = tmo;
 689         }
 690
 691         if (delay <= 0) {
 692                 spin_unlock_bh(&rt_flush_lock);
 693                 rt_run_flush(0);
 694                 return;
 695         }
 696
 697         if (rt_deadline == 0)
 698                 rt_deadline = now + ip_rt_max_delay;
 699
 700         mod_timer(&rt_flush_timer, now+delay);
 701         spin_unlock_bh(&rt_flush_lock);
 702 }
 703
 704 static void rt_secret_rebuild(unsigned long dummy)
 705 {
 706         unsigned long now = jiffies;
 707
 708         rt_cache_flush(0);
 709         mod_timer(&rt_secret_timer, now + ip_rt_secret_interval);
 710 }
 711
 712 /*
 713    Short description of GC goals.
 714
 715    We want to build algorithm, which will keep routing cache
 716    at some equilibrium point, when number of aged off entries
 717    is kept approximately equal to newly generated ones.
 718
 719    Current expiration strength is variable "expire".
 720    We try to adjust it dynamically, so that if networking
 721    is idle expires is large enough to keep enough of warm entries,
 722    and when load increases it reduces to limit cache size.
 723  */
 724
 725 static int rt_garbage_collect(void)
 726 {
 727         static unsigned long expire = RT_GC_TIMEOUT;
 728         static unsigned long last_gc;
 729         static int rover;
 730         static int equilibrium;
 731         struct rtable *rth, **rthp;
 732         unsigned long now = jiffies;
 733         int goal;
 734
 735         /*
 736          * Garbage collection is pretty expensive,
 737          * do not make it too frequently.
 738          */
 739
 740         RT_CACHE_STAT_INC(gc_total);
 741
 742         if (now - last_gc < ip_rt_gc_min_interval &&
 743             atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) {
 744                 RT_CACHE_STAT_INC(gc_ignored);
 745                 goto out;
 746         }
 747
 748         /* Calculate number of entries, which we want to expire now. */
 749         goal = atomic_read(&ipv4_dst_ops.entries) -
 750                 (ip_rt_gc_elasticity << rt_hash_log);
 751         if (goal <= 0) {
 752                 if (equilibrium < ipv4_dst_ops.gc_thresh)
 753                         equilibrium = ipv4_dst_ops.gc_thresh;
 754                 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
 755                 if (goal > 0) {
 756                         equilibrium += min_t(unsigned int, goal / 2, rt_hash_mask + 1);
 757                         goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
 758                 }
 759         } else {
 760                 /* We are in dangerous area. Try to reduce cache really
 761                  * aggressively.
 762                  */
 763                 goal = max_t(unsigned int, goal / 2, rt_hash_mask + 1);
 764                 equilibrium = atomic_read(&ipv4_dst_ops.entries) - goal;
 765         }
 766
 767         if (now - last_gc >= ip_rt_gc_min_interval)
 768                 last_gc = now;
 769
 770         if (goal <= 0) {
 771                 equilibrium += goal;
 772                 goto work_done;
 773         }
 774
 775         do {
 776                 int i, k;
 777
 778                 for (i = rt_hash_mask, k = rover; i >= 0; i--) {
 779                         unsigned long tmo = expire;
 780
 781                         k = (k + 1) & rt_hash_mask;
 782                         rthp = &rt_hash_table[k].chain;
 783                         spin_lock_bh(&rt_hash_table[k].lock);
 784                         while ((rth = *rthp) != NULL) {
 785                                 if (!rt_may_expire(rth, tmo, expire)) {
 786                                         tmo >>= 1;
 787                                         rthp = &rth->u.rt_next;
 788                                         continue;
 789                                 }
 790 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
 791                                 /* remove all related balanced entries
 792                                  * if necessary
 793                                  */
 794                                 if (rth->u.dst.flags & DST_BALANCED) {
 795                                         int r;
 796
 797                                         rthp = rt_remove_balanced_route(
 798                                                 &rt_hash_table[i].chain,
 799                                                 rth,
 800                                                 &r);
 801                                         goal -= r;
 802                                         if (!rthp)
 803                                                 break;
 804                                 } else {
 805                                         *rthp = rth->u.rt_next;
 806                                         rt_free(rth);
 807                                         goal--;
 808                                 }
 809 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
 810                                 *rthp = rth->u.rt_next;
 811                                 rt_free(rth);
 812                                 goal--;
 813 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
 814                         }
 815                         spin_unlock_bh(&rt_hash_table[k].lock);
 816                         if (goal <= 0)
 817                                 break;
 818                 }
 819                 rover = k;
 820
 821                 if (goal <= 0)
 822                         goto work_done;
 823
 824                 /* Goal is not achieved. We stop process if:
 825
 826                    - if expire reduced to zero. Otherwise, expire is halfed.
 827                    - if table is not full.
 828                    - if we are called from interrupt.
 829                    - jiffies check is just fallback/debug loop breaker.
 830                      We will not spin here for long time in any case.
 831                  */
 832
 833                 RT_CACHE_STAT_INC(gc_goal_miss);
 834
 835                 if (expire == 0)
 836                         break;
 837
 838                 expire >>= 1;
 839 #if RT_CACHE_DEBUG >= 2
 840                 printk(KERN_DEBUG "expire>> %u %d %d %d\n", expire,
 841                                 atomic_read(&ipv4_dst_ops.entries), goal, i);
 842 #endif
 843
 844                 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
 845                         goto out;
 846         } while (!in_softirq() && time_before_eq(jiffies, now));
 847
 848         if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
 849                 goto out;
 850         if (net_ratelimit())
 851                 printk(KERN_WARNING "dst cache overflow\n");
 852         RT_CACHE_STAT_INC(gc_dst_overflow);
 853         return 1;
 854
 855 work_done:
 856         expire += ip_rt_gc_min_interval;
 857         if (expire > ip_rt_gc_timeout ||
 858             atomic_read(&ipv4_dst_ops.entries) < ipv4_dst_ops.gc_thresh)
 859                 expire = ip_rt_gc_timeout;
 860 #if RT_CACHE_DEBUG >= 2
 861         printk(KERN_DEBUG "expire++ %u %d %d %d\n", expire,
 862                         atomic_read(&ipv4_dst_ops.entries), goal, rover);
 863 #endif
 864 out:    return 0;
 865 }
 866
 867 static int rt_intern_hash(unsigned hash, struct rtable *rt, struct rtable **rp)
 868 {
 869         struct rtable   *rth, **rthp;
 870         unsigned long   now;
 871         struct rtable *cand, **candp;
 872         u32             min_score;
 873         int             chain_length;
 874         int attempts = !in_softirq();
 875
 876 restart:
 877         chain_length = 0;
 878         min_score = ~(u32)0;
 879         cand = NULL;
 880         candp = NULL;
 881         now = jiffies;
 882
 883         rthp = &rt_hash_table[hash].chain;
 884
 885         spin_lock_bh(&rt_hash_table[hash].lock);
 886         while ((rth = *rthp) != NULL) {
 887 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
 888                 if (!(rth->u.dst.flags & DST_BALANCED) &&
 889                     compare_keys(&rth->fl, &rt->fl)) {
 890 #else
 891                 if (compare_keys(&rth->fl, &rt->fl)) {
 892 #endif
 893                         /* Put it first */
 894                         *rthp = rth->u.rt_next;
 895                         /*
 896                          * Since lookup is lockfree, the deletion
 897                          * must be visible to another weakly ordered CPU before
 898                          * the insertion at the start of the hash chain.
 899                          */
 900                         rcu_assign_pointer(rth->u.rt_next,
 901                                            rt_hash_table[hash].chain);
 902                         /*
 903                          * Since lookup is lockfree, the update writes
 904                          * must be ordered for consistency on SMP.
 905                          */
 906                         rcu_assign_pointer(rt_hash_table[hash].chain, rth);
 907
 908                         rth->u.dst.__use++;
 909                         dst_hold(&rth->u.dst);
 910                         rth->u.dst.lastuse = now;
 911                         spin_unlock_bh(&rt_hash_table[hash].lock);
 912
 913                         rt_drop(rt);
 914                         *rp = rth;
 915                         return 0;
 916                 }
 917
 918                 if (!atomic_read(&rth->u.dst.__refcnt)) {
 919                         u32 score = rt_score(rth);
 920
 921                         if (score <= min_score) {
 922                                 cand = rth;
 923                                 candp = rthp;
 924                                 min_score = score;
 925                         }
 926                 }
 927
 928                 chain_length++;
 929
 930                 rthp = &rth->u.rt_next;
 931         }
 932
 933         if (cand) {
 934                 /* ip_rt_gc_elasticity used to be average length of chain
 935                  * length, when exceeded gc becomes really aggressive.
 936                  *
 937                  * The second limit is less certain. At the moment it allows
 938                  * only 2 entries per bucket. We will see.
 939                  */
 940                 if (chain_length > ip_rt_gc_elasticity) {
 941                         *candp = cand->u.rt_next;
 942                         rt_free(cand);
 943                 }
 944         }
 945
 946         /* Try to bind route to arp only if it is output
 947            route or unicast forwarding path.
 948          */
 949         if (rt->rt_type == RTN_UNICAST || rt->fl.iif == 0) {
 950                 int err = arp_bind_neighbour(&rt->u.dst);
 951                 if (err) {
 952                         spin_unlock_bh(&rt_hash_table[hash].lock);
 953
 954                         if (err != -ENOBUFS) {
 955                                 rt_drop(rt);
 956                                 return err;
 957                         }
 958
 959                         /* Neighbour tables are full and nothing
 960                            can be released. Try to shrink route cache,
 961                            it is most likely it holds some neighbour records.
 962                          */
 963                         if (attempts-- > 0) {
 964                                 int saved_elasticity = ip_rt_gc_elasticity;
 965                                 int saved_int = ip_rt_gc_min_interval;
 966                                 ip_rt_gc_elasticity     = 1;
 967                                 ip_rt_gc_min_interval   = 0;
 968                                 rt_garbage_collect();
 969                                 ip_rt_gc_min_interval   = saved_int;
 970                                 ip_rt_gc_elasticity     = saved_elasticity;
 971                                 goto restart;
 972                         }
 973
 974                         if (net_ratelimit())
 975                                 printk(KERN_WARNING "Neighbour table overflow.\n");
 976                         rt_drop(rt);
 977                         return -ENOBUFS;
 978                 }
 979         }
 980
 981         rt->u.rt_next = rt_hash_table[hash].chain;
 982 #if RT_CACHE_DEBUG >= 2
 983         if (rt->u.rt_next) {
 984                 struct rtable *trt;
 985                 printk(KERN_DEBUG "rt_cache @%02x: %u.%u.%u.%u", hash,
 986                        NIPQUAD(rt->rt_dst));
 987                 for (trt = rt->u.rt_next; trt; trt = trt->u.rt_next)
 988                         printk(" . %u.%u.%u.%u", NIPQUAD(trt->rt_dst));
 989                 printk("\n");
 990         }
 991 #endif
 992         rt_hash_table[hash].chain = rt;
 993         spin_unlock_bh(&rt_hash_table[hash].lock);
 994         *rp = rt;
 995         return 0;
 996 }
 997
 998 void rt_bind_peer(struct rtable *rt, int create)
 999 {
1000         static DEFINE_SPINLOCK(rt_peer_lock);
1001         struct inet_peer *peer;
1002
1003         peer = inet_getpeer(rt->rt_dst, create);
1004
1005         spin_lock_bh(&rt_peer_lock);
1006         if (rt->peer == NULL) {
1007                 rt->peer = peer;
1008                 peer = NULL;
1009         }
1010         spin_unlock_bh(&rt_peer_lock);
1011         if (peer)
1012                 inet_putpeer(peer);
1013 }
1014
1015 /*
1016  * Peer allocation may fail only in serious out-of-memory conditions.  However
1017  * we still can generate some output.
1018  * Random ID selection looks a bit dangerous because we have no chances to
1019  * select ID being unique in a reasonable period of time.
1020  * But broken packet identifier may be better than no packet at all.
1021  */
1022 static void ip_select_fb_ident(struct iphdr *iph)
1023 {
1024         static DEFINE_SPINLOCK(ip_fb_id_lock);
1025         static u32 ip_fallback_id;
1026         u32 salt;
1027
1028         spin_lock_bh(&ip_fb_id_lock);
1029         salt = secure_ip_id(ip_fallback_id ^ iph->daddr);
1030         iph->id = htons(salt & 0xFFFF);
1031         ip_fallback_id = salt;
1032         spin_unlock_bh(&ip_fb_id_lock);
1033 }
1034
1035 void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more)
1036 {
1037         struct rtable *rt = (struct rtable *) dst;
1038
1039         if (rt) {
1040                 if (rt->peer == NULL)
1041                         rt_bind_peer(rt, 1);
1042
1043                 /* If peer is attached to destination, it is never detached,
1044                    so that we need not to grab a lock to dereference it.
1045                  */
1046                 if (rt->peer) {
1047                         iph->id = htons(inet_getid(rt->peer, more));
1048                         return;
1049                 }
1050         } else
1051                 printk(KERN_DEBUG "rt_bind_peer(0) @%p\n",
1052                        __builtin_return_address(0));
1053
1054         ip_select_fb_ident(iph);
1055 }
1056
1057 static void rt_del(unsigned hash, struct rtable *rt)
1058 {
1059         struct rtable **rthp;
1060
1061         spin_lock_bh(&rt_hash_table[hash].lock);
1062         ip_rt_put(rt);
1063         for (rthp = &rt_hash_table[hash].chain; *rthp;
1064              rthp = &(*rthp)->u.rt_next)
1065                 if (*rthp == rt) {
1066                         *rthp = rt->u.rt_next;
1067                         rt_free(rt);
1068                         break;
1069                 }
1070         spin_unlock_bh(&rt_hash_table[hash].lock);
1071 }
1072
1073 void ip_rt_redirect(u32 old_gw, u32 daddr, u32 new_gw,
1074                     u32 saddr, u8 tos, struct net_device *dev)
1075 {
1076         int i, k;
1077         struct in_device *in_dev = in_dev_get(dev);
1078         struct rtable *rth, **rthp;
1079         u32  skeys[2] = { saddr, 0 };
1080         int  ikeys[2] = { dev->ifindex, 0 };
1081
1082         tos &= IPTOS_RT_MASK;
1083
1084         if (!in_dev)
1085                 return;
1086
1087         if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev)
1088             || MULTICAST(new_gw) || BADCLASS(new_gw) || ZERONET(new_gw))
1089                 goto reject_redirect;
1090
1091         if (!IN_DEV_SHARED_MEDIA(in_dev)) {
1092                 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
1093                         goto reject_redirect;
1094                 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
1095                         goto reject_redirect;
1096         } else {
1097                 if (inet_addr_type(new_gw) != RTN_UNICAST)
1098                         goto reject_redirect;
1099         }
1100
1101         for (i = 0; i < 2; i++) {
1102                 for (k = 0; k < 2; k++) {
1103                         unsigned hash = rt_hash_code(daddr,
1104                                                      skeys[i] ^ (ikeys[k] << 5),
1105                                                      tos);
1106
1107                         rthp=&rt_hash_table[hash].chain;
1108
1109                         rcu_read_lock();
1110                         while ((rth = rcu_dereference(*rthp)) != NULL) {
1111                                 struct rtable *rt;
1112
1113                                 if (rth->fl.fl4_dst != daddr ||
1114                                     rth->fl.fl4_src != skeys[i] ||
1115                                     rth->fl.fl4_tos != tos ||
1116                                     rth->fl.oif != ikeys[k] ||
1117                                     rth->fl.iif != 0) {
1118                                         rthp = &rth->u.rt_next;
1119                                         continue;
1120                                 }
1121
1122                                 if (rth->rt_dst != daddr ||
1123                                     rth->rt_src != saddr ||
1124                                     rth->u.dst.error ||
1125                                     rth->rt_gateway != old_gw ||
1126                                     rth->u.dst.dev != dev)
1127                                         break;
1128
1129                                 dst_hold(&rth->u.dst);
1130                                 rcu_read_unlock();
1131
1132                                 rt = dst_alloc(&ipv4_dst_ops);
1133                                 if (rt == NULL) {
1134                                         ip_rt_put(rth);
1135                                         in_dev_put(in_dev);
1136                                         return;
1137                                 }
1138
1139                                 /* Copy all the information. */
1140                                 *rt = *rth;
1141                                 INIT_RCU_HEAD(&rt->u.dst.rcu_head);
1142                                 rt->u.dst.__use         = 1;
1143                                 atomic_set(&rt->u.dst.__refcnt, 1);
1144                                 rt->u.dst.child         = NULL;
1145                                 if (rt->u.dst.dev)
1146                                         dev_hold(rt->u.dst.dev);
1147                                 if (rt->idev)
1148                                         in_dev_hold(rt->idev);
1149                                 rt->u.dst.obsolete      = 0;
1150                                 rt->u.dst.lastuse       = jiffies;
1151                                 rt->u.dst.path          = &rt->u.dst;
1152                                 rt->u.dst.neighbour     = NULL;
1153                                 rt->u.dst.hh            = NULL;
1154                                 rt->u.dst.xfrm          = NULL;
1155
1156                                 rt->rt_flags            |= RTCF_REDIRECTED;
1157
1158                                 /* Gateway is different ... */
1159                                 rt->rt_gateway          = new_gw;
1160
1161                                 /* Redirect received -> path was valid */
1162                                 dst_confirm(&rth->u.dst);
1163
1164                                 if (rt->peer)
1165                                         atomic_inc(&rt->peer->refcnt);
1166
1167                                 if (arp_bind_neighbour(&rt->u.dst) ||
1168                                     !(rt->u.dst.neighbour->nud_state &
1169                                             NUD_VALID)) {
1170                                         if (rt->u.dst.neighbour)
1171                                                 neigh_event_send(rt->u.dst.neighbour, NULL);
1172                                         ip_rt_put(rth);
1173                                         rt_drop(rt);
1174                                         goto do_next;
1175                                 }
1176
1177                                 rt_del(hash, rth);
1178                                 if (!rt_intern_hash(hash, rt, &rt))
1179                                         ip_rt_put(rt);
1180                                 goto do_next;
1181                         }
1182                         rcu_read_unlock();
1183                 do_next:
1184                         ;
1185                 }
1186         }
1187         in_dev_put(in_dev);
1188         return;
1189
1190 reject_redirect:
1191 #ifdef CONFIG_IP_ROUTE_VERBOSE
1192         if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
1193                 printk(KERN_INFO "Redirect from %u.%u.%u.%u on %s about "
1194                         "%u.%u.%u.%u ignored.\n"
1195                         "  Advised path = %u.%u.%u.%u -> %u.%u.%u.%u, "
1196                         "tos %02x\n",
1197                        NIPQUAD(old_gw), dev->name, NIPQUAD(new_gw),
1198                        NIPQUAD(saddr), NIPQUAD(daddr), tos);
1199 #endif
1200         in_dev_put(in_dev);
1201 }
1202
1203 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
1204 {
1205         struct rtable *rt = (struct rtable*)dst;
1206         struct dst_entry *ret = dst;
1207
1208         if (rt) {
1209                 if (dst->obsolete) {
1210                         ip_rt_put(rt);
1211                         ret = NULL;
1212                 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
1213                            rt->u.dst.expires) {
1214                         unsigned hash = rt_hash_code(rt->fl.fl4_dst,
1215                                                      rt->fl.fl4_src ^
1216                                                         (rt->fl.oif << 5),
1217                                                      rt->fl.fl4_tos);
1218 #if RT_CACHE_DEBUG >= 1
1219                         printk(KERN_DEBUG "ip_rt_advice: redirect to "
1220                                           "%u.%u.%u.%u/%02x dropped\n",
1221                                 NIPQUAD(rt->rt_dst), rt->fl.fl4_tos);
1222 #endif
1223                         rt_del(hash, rt);
1224                         ret = NULL;
1225                 }
1226         }
1227         return ret;
1228 }
1229
1230 /*
1231  * Algorithm:
1232  *      1. The first ip_rt_redirect_number redirects are sent
1233  *         with exponential backoff, then we stop sending them at all,
1234  *         assuming that the host ignores our redirects.
1235  *      2. If we did not see packets requiring redirects
1236  *         during ip_rt_redirect_silence, we assume that the host
1237  *         forgot redirected route and start to send redirects again.
1238  *
1239  * This algorithm is much cheaper and more intelligent than dumb load limiting
1240  * in icmp.c.
1241  *
1242  * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
1243  * and "frag. need" (breaks PMTU discovery) in icmp.c.
1244  */
1245
1246 void ip_rt_send_redirect(struct sk_buff *skb)
1247 {
1248         struct rtable *rt = (struct rtable*)skb->dst;
1249         struct in_device *in_dev = in_dev_get(rt->u.dst.dev);
1250
1251         if (!in_dev)
1252                 return;
1253
1254         if (!IN_DEV_TX_REDIRECTS(in_dev))
1255                 goto out;
1256
1257         /* No redirected packets during ip_rt_redirect_silence;
1258          * reset the algorithm.
1259          */
1260         if (time_after(jiffies, rt->u.dst.rate_last + ip_rt_redirect_silence))
1261                 rt->u.dst.rate_tokens = 0;
1262
1263         /* Too many ignored redirects; do not send anything
1264          * set u.dst.rate_last to the last seen redirected packet.
1265          */
1266         if (rt->u.dst.rate_tokens >= ip_rt_redirect_number) {
1267                 rt->u.dst.rate_last = jiffies;
1268                 goto out;
1269         }
1270
1271         /* Check for load limit; set rate_last to the latest sent
1272          * redirect.
1273          */
1274         if (time_after(jiffies,
1275                        (rt->u.dst.rate_last +
1276                         (ip_rt_redirect_load << rt->u.dst.rate_tokens)))) {
1277                 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
1278                 rt->u.dst.rate_last = jiffies;
1279                 ++rt->u.dst.rate_tokens;
1280 #ifdef CONFIG_IP_ROUTE_VERBOSE
1281                 if (IN_DEV_LOG_MARTIANS(in_dev) &&
1282                     rt->u.dst.rate_tokens == ip_rt_redirect_number &&
1283                     net_ratelimit())
1284                         printk(KERN_WARNING "host %u.%u.%u.%u/if%d ignores "
1285                                 "redirects for %u.%u.%u.%u to %u.%u.%u.%u.\n",
1286                                 NIPQUAD(rt->rt_src), rt->rt_iif,
1287                                 NIPQUAD(rt->rt_dst), NIPQUAD(rt->rt_gateway));
1288 #endif
1289         }
1290 out:
1291         in_dev_put(in_dev);
1292 }
1293
1294 static int ip_error(struct sk_buff *skb)
1295 {
1296         struct rtable *rt = (struct rtable*)skb->dst;
1297         unsigned long now;
1298         int code;
1299
1300         switch (rt->u.dst.error) {
1301                 case EINVAL:
1302                 default:
1303                         goto out;
1304                 case EHOSTUNREACH:
1305                         code = ICMP_HOST_UNREACH;
1306                         break;
1307                 case ENETUNREACH:
1308                         code = ICMP_NET_UNREACH;
1309                         break;
1310                 case EACCES:
1311                         code = ICMP_PKT_FILTERED;
1312                         break;
1313         }
1314
1315         now = jiffies;
1316         rt->u.dst.rate_tokens += now - rt->u.dst.rate_last;
1317         if (rt->u.dst.rate_tokens > ip_rt_error_burst)
1318                 rt->u.dst.rate_tokens = ip_rt_error_burst;
1319         rt->u.dst.rate_last = now;
1320         if (rt->u.dst.rate_tokens >= ip_rt_error_cost) {
1321                 rt->u.dst.rate_tokens -= ip_rt_error_cost;
1322                 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
1323         }
1324
1325 out:    kfree_skb(skb);
1326         return 0;
1327 }
1328
1329 /*
1330  *      The last two values are not from the RFC but
1331  *      are needed for AMPRnet AX.25 paths.
1332  */
1333
1334 static unsigned short mtu_plateau[] =
1335 {32000, 17914, 8166, 4352, 2002, 1492, 576, 296, 216, 128 };
1336
1337 static __inline__ unsigned short guess_mtu(unsigned short old_mtu)
1338 {
1339         int i;
1340
1341         for (i = 0; i < ARRAY_SIZE(mtu_plateau); i++)
1342                 if (old_mtu > mtu_plateau[i])
1343                         return mtu_plateau[i];
1344         return 68;
1345 }
1346
1347 unsigned short ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu)
1348 {
1349         int i;
1350         unsigned short old_mtu = ntohs(iph->tot_len);
1351         struct rtable *rth;
1352         u32  skeys[2] = { iph->saddr, 0, };
1353         u32  daddr = iph->daddr;
1354         u8   tos = iph->tos & IPTOS_RT_MASK;
1355         unsigned short est_mtu = 0;
1356
1357         if (ipv4_config.no_pmtu_disc)
1358                 return 0;
1359
1360         for (i = 0; i < 2; i++) {
1361                 unsigned hash = rt_hash_code(daddr, skeys[i], tos);
1362
1363                 rcu_read_lock();
1364                 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
1365                      rth = rcu_dereference(rth->u.rt_next)) {
1366                         if (rth->fl.fl4_dst == daddr &&
1367                             rth->fl.fl4_src == skeys[i] &&
1368                             rth->rt_dst  == daddr &&
1369                             rth->rt_src  == iph->saddr &&
1370                             rth->fl.fl4_tos == tos &&
1371                             rth->fl.iif == 0 &&
1372                             !(dst_metric_locked(&rth->u.dst, RTAX_MTU))) {
1373                                 unsigned short mtu = new_mtu;
1374
1375                                 if (new_mtu < 68 || new_mtu >= old_mtu) {
1376
1377                                         /* BSD 4.2 compatibility hack :-( */
1378                                         if (mtu == 0 &&
1379                                             old_mtu >= rth->u.dst.metrics[RTAX_MTU-1] &&
1380                                             old_mtu >= 68 + (iph->ihl << 2))
1381                                                 old_mtu -= iph->ihl << 2;
1382
1383                                         mtu = guess_mtu(old_mtu);
1384                                 }
1385                                 if (mtu <= rth->u.dst.metrics[RTAX_MTU-1]) {
1386                                         if (mtu < rth->u.dst.metrics[RTAX_MTU-1]) {
1387                                                 dst_confirm(&rth->u.dst);
1388                                                 if (mtu < ip_rt_min_pmtu) {
1389                                                         mtu = ip_rt_min_pmtu;
1390                                                         rth->u.dst.metrics[RTAX_LOCK-1] |=
1391                                                                 (1 << RTAX_MTU);
1392                                                 }
1393                                                 rth->u.dst.metrics[RTAX_MTU-1] = mtu;
1394                                                 dst_set_expires(&rth->u.dst,
1395                                                         ip_rt_mtu_expires);
1396                                         }
1397                                         est_mtu = mtu;
1398                                 }
1399                         }
1400                 }
1401                 rcu_read_unlock();
1402         }
1403         return est_mtu ? : new_mtu;
1404 }
1405
1406 static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
1407 {
1408         if (dst->metrics[RTAX_MTU-1] > mtu && mtu >= 68 &&
1409             !(dst_metric_locked(dst, RTAX_MTU))) {
1410                 if (mtu < ip_rt_min_pmtu) {
1411                         mtu = ip_rt_min_pmtu;
1412                         dst->metrics[RTAX_LOCK-1] |= (1 << RTAX_MTU);
1413                 }
1414                 dst->metrics[RTAX_MTU-1] = mtu;
1415                 dst_set_expires(dst, ip_rt_mtu_expires);
1416         }
1417 }
1418
1419 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1420 {
1421         return NULL;
1422 }
1423
1424 static void ipv4_dst_destroy(struct dst_entry *dst)
1425 {
1426         struct rtable *rt = (struct rtable *) dst;
1427         struct inet_peer *peer = rt->peer;
1428         struct in_device *idev = rt->idev;
1429
1430         if (peer) {
1431                 rt->peer = NULL;
1432                 inet_putpeer(peer);
1433         }
1434
1435         if (idev) {
1436                 rt->idev = NULL;
1437                 in_dev_put(idev);
1438         }
1439 }
1440
1441 static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
1442                             int how)
1443 {
1444         struct rtable *rt = (struct rtable *) dst;
1445         struct in_device *idev = rt->idev;
1446         if (dev != &loopback_dev && idev && idev->dev == dev) {
1447                 struct in_device *loopback_idev = in_dev_get(&loopback_dev);
1448                 if (loopback_idev) {
1449                         rt->idev = loopback_idev;
1450                         in_dev_put(idev);
1451                 }
1452         }
1453 }
1454
1455 static void ipv4_link_failure(struct sk_buff *skb)
1456 {
1457         struct rtable *rt;
1458
1459         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1460
1461         rt = (struct rtable *) skb->dst;
1462         if (rt)
1463                 dst_set_expires(&rt->u.dst, 0);
1464 }
1465
1466 static int ip_rt_bug(struct sk_buff *skb)
1467 {
1468         printk(KERN_DEBUG "ip_rt_bug: %u.%u.%u.%u -> %u.%u.%u.%u, %s\n",
1469                 NIPQUAD(skb->nh.iph->saddr), NIPQUAD(skb->nh.iph->daddr),
1470                 skb->dev ? skb->dev->name : "?");
1471         kfree_skb(skb);
1472         return 0;
1473 }
1474
1475 /*
1476    We do not cache source address of outgoing interface,
1477    because it is used only by IP RR, TS and SRR options,
1478    so that it out of fast path.
1479
1480    BTW remember: "addr" is allowed to be not aligned
1481    in IP options!
1482  */
1483
1484 void ip_rt_get_source(u8 *addr, struct rtable *rt)
1485 {
1486         u32 src;
1487         struct fib_result res;
1488
1489         if (rt->fl.iif == 0)
1490                 src = rt->rt_src;
1491         else if (fib_lookup(&rt->fl, &res) == 0) {
1492                 src = FIB_RES_PREFSRC(res);
1493                 fib_res_put(&res);
1494         } else
1495                 src = inet_select_addr(rt->u.dst.dev, rt->rt_gateway,
1496                                         RT_SCOPE_UNIVERSE);
1497         memcpy(addr, &src, 4);
1498 }
1499
1500 #ifdef CONFIG_NET_CLS_ROUTE
1501 static void set_class_tag(struct rtable *rt, u32 tag)
1502 {
1503         if (!(rt->u.dst.tclassid & 0xFFFF))
1504                 rt->u.dst.tclassid |= tag & 0xFFFF;
1505         if (!(rt->u.dst.tclassid & 0xFFFF0000))
1506                 rt->u.dst.tclassid |= tag & 0xFFFF0000;
1507 }
1508 #endif
1509
1510 static void rt_set_nexthop(struct rtable *rt, struct fib_result *res, u32 itag)
1511 {
1512         struct fib_info *fi = res->fi;
1513
1514         if (fi) {
1515                 if (FIB_RES_GW(*res) &&
1516                     FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
1517                         rt->rt_gateway = FIB_RES_GW(*res);
1518                 memcpy(rt->u.dst.metrics, fi->fib_metrics,
1519                        sizeof(rt->u.dst.metrics));
1520                 if (fi->fib_mtu == 0) {
1521                         rt->u.dst.metrics[RTAX_MTU-1] = rt->u.dst.dev->mtu;
1522                         if (rt->u.dst.metrics[RTAX_LOCK-1] & (1 << RTAX_MTU) &&
1523                             rt->rt_gateway != rt->rt_dst &&
1524                             rt->u.dst.dev->mtu > 576)
1525                                 rt->u.dst.metrics[RTAX_MTU-1] = 576;
1526                 }
1527 #ifdef CONFIG_NET_CLS_ROUTE
1528                 rt->u.dst.tclassid = FIB_RES_NH(*res).nh_tclassid;
1529 #endif
1530         } else
1531                 rt->u.dst.metrics[RTAX_MTU-1]= rt->u.dst.dev->mtu;
1532
1533         if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1534                 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = sysctl_ip_default_ttl;
1535         if (rt->u.dst.metrics[RTAX_MTU-1] > IP_MAX_MTU)
1536                 rt->u.dst.metrics[RTAX_MTU-1] = IP_MAX_MTU;
1537         if (rt->u.dst.metrics[RTAX_ADVMSS-1] == 0)
1538                 rt->u.dst.metrics[RTAX_ADVMSS-1] = max_t(unsigned int, rt->u.dst.dev->mtu - 40,
1539                                        ip_rt_min_advmss);
1540         if (rt->u.dst.metrics[RTAX_ADVMSS-1] > 65535 - 40)
1541                 rt->u.dst.metrics[RTAX_ADVMSS-1] = 65535 - 40;
1542
1543 #ifdef CONFIG_NET_CLS_ROUTE
1544 #ifdef CONFIG_IP_MULTIPLE_TABLES
1545         set_class_tag(rt, fib_rules_tclass(res));
1546 #endif
1547         set_class_tag(rt, itag);
1548 #endif
1549         rt->rt_type = res->type;
1550 }
1551
1552 static int ip_route_input_mc(struct sk_buff *skb, u32 daddr, u32 saddr,
1553                                 u8 tos, struct net_device *dev, int our)
1554 {
1555         unsigned hash;
1556         struct rtable *rth;
1557         u32 spec_dst;
1558         struct in_device *in_dev = in_dev_get(dev);
1559         u32 itag = 0;
1560
1561         /* Primary sanity checks. */
1562
1563         if (in_dev == NULL)
1564                 return -EINVAL;
1565
1566         if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr) ||
1567             skb->protocol != htons(ETH_P_IP))
1568                 goto e_inval;
1569
1570         if (ZERONET(saddr)) {
1571                 if (!LOCAL_MCAST(daddr))
1572                         goto e_inval;
1573                 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
1574         } else if (fib_validate_source(saddr, 0, tos, 0,
1575                                         dev, &spec_dst, &itag) < 0)
1576                 goto e_inval;
1577
1578         rth = dst_alloc(&ipv4_dst_ops);
1579         if (!rth)
1580                 goto e_nobufs;
1581
1582         rth->u.dst.output= ip_rt_bug;
1583
1584         atomic_set(&rth->u.dst.__refcnt, 1);
1585         rth->u.dst.flags= DST_HOST;
1586         if (in_dev->cnf.no_policy)
1587                 rth->u.dst.flags |= DST_NOPOLICY;
1588         rth->fl.fl4_dst = daddr;
1589         rth->rt_dst     = daddr;
1590         rth->fl.fl4_tos = tos;
1591 #ifdef CONFIG_IP_ROUTE_FWMARK
1592         rth->fl.fl4_fwmark= skb->nfmark;
1593 #endif
1594         rth->fl.fl4_src = saddr;
1595         rth->rt_src     = saddr;
1596 #ifdef CONFIG_NET_CLS_ROUTE
1597         rth->u.dst.tclassid = itag;
1598 #endif
1599         rth->rt_iif     =
1600         rth->fl.iif     = dev->ifindex;
1601         rth->u.dst.dev  = &loopback_dev;
1602         dev_hold(rth->u.dst.dev);
1603         rth->idev       = in_dev_get(rth->u.dst.dev);
1604         rth->fl.oif     = 0;
1605         rth->rt_gateway = daddr;
1606         rth->rt_spec_dst= spec_dst;
1607         rth->rt_type    = RTN_MULTICAST;
1608         rth->rt_flags   = RTCF_MULTICAST;
1609         if (our) {
1610                 rth->u.dst.input= ip_local_deliver;
1611                 rth->rt_flags |= RTCF_LOCAL;
1612         }
1613
1614 #ifdef CONFIG_IP_MROUTE
1615         if (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev))
1616                 rth->u.dst.input = ip_mr_input;
1617 #endif
1618         RT_CACHE_STAT_INC(in_slow_mc);
1619
1620         in_dev_put(in_dev);
1621         hash = rt_hash_code(daddr, saddr ^ (dev->ifindex << 5), tos);
1622         return rt_intern_hash(hash, rth, (struct rtable**) &skb->dst);
1623
1624 e_nobufs:
1625         in_dev_put(in_dev);
1626         return -ENOBUFS;
1627
1628 e_inval:
1629         in_dev_put(in_dev);
1630         return -EINVAL;
1631 }
1632
1633
1634 static void ip_handle_martian_source(struct net_device *dev,
1635                                      struct in_device *in_dev,
1636                                      struct sk_buff *skb,
1637                                      u32 daddr,
1638                                      u32 saddr)
1639 {
1640         RT_CACHE_STAT_INC(in_martian_src);
1641 #ifdef CONFIG_IP_ROUTE_VERBOSE
1642         if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1643                 /*
1644                  *      RFC1812 recommendation, if source is martian,
1645                  *      the only hint is MAC header.
1646                  */
1647                 printk(KERN_WARNING "martian source %u.%u.%u.%u from "
1648                         "%u.%u.%u.%u, on dev %s\n",
1649                         NIPQUAD(daddr), NIPQUAD(saddr), dev->name);
1650                 if (dev->hard_header_len) {
1651                         int i;
1652                         unsigned char *p = skb->mac.raw;
1653                         printk(KERN_WARNING "ll header: ");
1654                         for (i = 0; i < dev->hard_header_len; i++, p++) {
1655                                 printk("%02x", *p);
1656                                 if (i < (dev->hard_header_len - 1))
1657                                         printk(":");
1658                         }
1659                         printk("\n");
1660                 }
1661         }
1662 #endif
1663 }
1664
1665 static inline int __mkroute_input(struct sk_buff *skb,
1666                                   struct fib_result* res,
1667                                   struct in_device *in_dev,
1668                                   u32 daddr, u32 saddr, u32 tos,
1669                                   struct rtable **result)
1670 {
1671
1672         struct rtable *rth;
1673         int err;
1674         struct in_device *out_dev;
1675         unsigned flags = 0;
1676         u32 spec_dst, itag;
1677
1678         /* get a working reference to the output device */
1679         out_dev = in_dev_get(FIB_RES_DEV(*res));
1680         if (out_dev == NULL) {
1681                 if (net_ratelimit())
1682                         printk(KERN_CRIT "Bug in ip_route_input" \
1683                                "_slow(). Please, report\n");
1684                 return -EINVAL;
1685         }
1686
1687
1688         err = fib_validate_source(saddr, daddr, tos, FIB_RES_OIF(*res),
1689                                   in_dev->dev, &spec_dst, &itag);
1690         if (err < 0) {
1691                 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1692                                          saddr);
1693
1694                 err = -EINVAL;
1695                 goto cleanup;
1696         }
1697
1698         if (err)
1699                 flags |= RTCF_DIRECTSRC;
1700
1701         if (out_dev == in_dev && err && !(flags & (RTCF_NAT | RTCF_MASQ)) &&
1702             (IN_DEV_SHARED_MEDIA(out_dev) ||
1703              inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1704                 flags |= RTCF_DOREDIRECT;
1705
1706         if (skb->protocol != htons(ETH_P_IP)) {
1707                 /* Not IP (i.e. ARP). Do not create route, if it is
1708                  * invalid for proxy arp. DNAT routes are always valid.
1709                  */
1710                 if (out_dev == in_dev && !(flags & RTCF_DNAT)) {
1711                         err = -EINVAL;
1712                         goto cleanup;
1713                 }
1714         }
1715
1716
1717         rth = dst_alloc(&ipv4_dst_ops);
1718         if (!rth) {
1719                 err = -ENOBUFS;
1720                 goto cleanup;
1721         }
1722
1723         rth->u.dst.flags= DST_HOST;
1724 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
1725         if (res->fi->fib_nhs > 1)
1726                 rth->u.dst.flags |= DST_BALANCED;
1727 #endif
1728         if (in_dev->cnf.no_policy)
1729                 rth->u.dst.flags |= DST_NOPOLICY;
1730         if (in_dev->cnf.no_xfrm)
1731                 rth->u.dst.flags |= DST_NOXFRM;
1732         rth->fl.fl4_dst = daddr;
1733         rth->rt_dst     = daddr;
1734         rth->fl.fl4_tos = tos;
1735 #ifdef CONFIG_IP_ROUTE_FWMARK
1736         rth->fl.fl4_fwmark= skb->nfmark;
1737 #endif
1738         rth->fl.fl4_src = saddr;
1739         rth->rt_src     = saddr;
1740         rth->rt_gateway = daddr;
1741         rth->rt_iif     =
1742                 rth->fl.iif     = in_dev->dev->ifindex;
1743         rth->u.dst.dev  = (out_dev)->dev;
1744         dev_hold(rth->u.dst.dev);
1745         rth->idev       = in_dev_get(rth->u.dst.dev);
1746         rth->fl.oif     = 0;
1747         rth->rt_spec_dst= spec_dst;
1748
1749         rth->u.dst.input = ip_forward;
1750         rth->u.dst.output = ip_output;
1751
1752         rt_set_nexthop(rth, res, itag);
1753
1754         rth->rt_flags = flags;
1755
1756         *result = rth;
1757         err = 0;
1758  cleanup:
1759         /* release the working reference to the output device */
1760         in_dev_put(out_dev);
1761         return err;
1762 }
1763
1764 static inline int ip_mkroute_input_def(struct sk_buff *skb,
1765                                        struct fib_result* res,
1766                                        const struct flowi *fl,
1767                                        struct in_device *in_dev,
1768                                        u32 daddr, u32 saddr, u32 tos)
1769 {
1770         struct rtable* rth;
1771         int err;
1772         unsigned hash;
1773
1774 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1775         if (res->fi && res->fi->fib_nhs > 1 && fl->oif == 0)
1776                 fib_select_multipath(fl, res);
1777 #endif
1778
1779         /* create a routing cache entry */
1780         err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos, &rth);
1781         if (err)
1782                 return err;
1783         atomic_set(&rth->u.dst.__refcnt, 1);
1784
1785         /* put it into the cache */
1786         hash = rt_hash_code(daddr, saddr ^ (fl->iif << 5), tos);
1787         return rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
1788 }
1789
1790 static inline int ip_mkroute_input(struct sk_buff *skb,
1791                                    struct fib_result* res,
1792                                    const struct flowi *fl,
1793                                    struct in_device *in_dev,
1794                                    u32 daddr, u32 saddr, u32 tos)
1795 {
1796 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
1797         struct rtable* rth;
1798         unsigned char hop, hopcount, lasthop;
1799         int err = -EINVAL;
1800         unsigned int hash;
1801
1802         if (res->fi)
1803                 hopcount = res->fi->fib_nhs;
1804         else
1805                 hopcount = 1;
1806
1807         lasthop = hopcount - 1;
1808
1809         /* distinguish between multipath and singlepath */
1810         if (hopcount < 2)
1811                 return ip_mkroute_input_def(skb, res, fl, in_dev, daddr,
1812                                             saddr, tos);
1813
1814         /* add all alternatives to the routing cache */
1815         for (hop = 0; hop < hopcount; hop++) {
1816                 res->nh_sel = hop;
1817
1818                 /* create a routing cache entry */
1819                 err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos,
1820                                       &rth);
1821                 if (err)
1822                         return err;
1823
1824                 /* put it into the cache */
1825                 hash = rt_hash_code(daddr, saddr ^ (fl->iif << 5), tos);
1826                 err = rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
1827                 if (err)
1828                         return err;
1829
1830                 /* forward hop information to multipath impl. */
1831                 multipath_set_nhinfo(rth,
1832                                      FIB_RES_NETWORK(*res),
1833                                      FIB_RES_NETMASK(*res),
1834                                      res->prefixlen,
1835                                      &FIB_RES_NH(*res));
1836
1837                 /* only for the last hop the reference count is handled
1838                  * outside
1839                  */
1840                 if (hop == lasthop)
1841                         atomic_set(&(skb->dst->__refcnt), 1);
1842         }
1843         return err;
1844 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED  */
1845         return ip_mkroute_input_def(skb, res, fl, in_dev, daddr, saddr, tos);
1846 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED  */
1847 }
1848
1849
1850 /*
1851  *      NOTE. We drop all the packets that has local source
1852  *      addresses, because every properly looped back packet
1853  *      must have correct destination already attached by output routine.
1854  *
1855  *      Such approach solves two big problems:
1856  *      1. Not simplex devices are handled properly.
1857  *      2. IP spoofing attempts are filtered with 100% of guarantee.
1858  */
1859
1860 static int ip_route_input_slow(struct sk_buff *skb, u32 daddr, u32 saddr,
1861                                u8 tos, struct net_device *dev)
1862 {
1863         struct fib_result res;
1864         struct in_device *in_dev = in_dev_get(dev);
1865         struct flowi fl = { .nl_u = { .ip4_u =
1866                                       { .daddr = daddr,
1867                                         .saddr = saddr,
1868                                         .tos = tos,
1869                                         .scope = RT_SCOPE_UNIVERSE,
1870 #ifdef CONFIG_IP_ROUTE_FWMARK
1871                                         .fwmark = skb->nfmark
1872 #endif
1873                                       } },
1874                             .iif = dev->ifindex };
1875         unsigned        flags = 0;
1876         u32             itag = 0;
1877         struct rtable * rth;
1878         unsigned        hash;
1879         u32             spec_dst;
1880         int             err = -EINVAL;
1881         int             free_res = 0;
1882
1883         /* IP on this device is disabled. */
1884
1885         if (!in_dev)
1886                 goto out;
1887
1888         /* Check for the most weird martians, which can be not detected
1889            by fib_lookup.
1890          */
1891
1892         if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr))
1893                 goto martian_source;
1894
1895         if (daddr == 0xFFFFFFFF || (saddr == 0 && daddr == 0))
1896                 goto brd_input;
1897
1898         /* Accept zero addresses only to limited broadcast;
1899          * I even do not know to fix it or not. Waiting for complains :-)
1900          */
1901         if (ZERONET(saddr))
1902                 goto martian_source;
1903
1904         if (BADCLASS(daddr) || ZERONET(daddr) || LOOPBACK(daddr))
1905                 goto martian_destination;
1906
1907         /*
1908          *      Now we are ready to route packet.
1909          */
1910         if ((err = fib_lookup(&fl, &res)) != 0) {
1911                 if (!IN_DEV_FORWARD(in_dev))
1912                         goto e_inval;
1913                 goto no_route;
1914         }
1915         free_res = 1;
1916
1917         RT_CACHE_STAT_INC(in_slow_tot);
1918
1919         if (res.type == RTN_BROADCAST)
1920                 goto brd_input;
1921
1922         if (res.type == RTN_LOCAL) {
1923                 int result;
1924                 result = fib_validate_source(saddr, daddr, tos,
1925                                              loopback_dev.ifindex,
1926                                              dev, &spec_dst, &itag);
1927                 if (result < 0)
1928                         goto martian_source;
1929                 if (result)
1930                         flags |= RTCF_DIRECTSRC;
1931                 spec_dst = daddr;
1932                 goto local_input;
1933         }
1934
1935         if (!IN_DEV_FORWARD(in_dev))
1936                 goto e_inval;
1937         if (res.type != RTN_UNICAST)
1938                 goto martian_destination;
1939
1940         err = ip_mkroute_input(skb, &res, &fl, in_dev, daddr, saddr, tos);
1941         if (err == -ENOBUFS)
1942                 goto e_nobufs;
1943         if (err == -EINVAL)
1944                 goto e_inval;
1945
1946 done:
1947         in_dev_put(in_dev);
1948         if (free_res)
1949                 fib_res_put(&res);
1950 out:    return err;
1951
1952 brd_input:
1953         if (skb->protocol != htons(ETH_P_IP))
1954                 goto e_inval;
1955
1956         if (ZERONET(saddr))
1957                 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
1958         else {
1959                 err = fib_validate_source(saddr, 0, tos, 0, dev, &spec_dst,
1960                                           &itag);
1961                 if (err < 0)
1962                         goto martian_source;
1963                 if (err)
1964                         flags |= RTCF_DIRECTSRC;
1965         }
1966         flags |= RTCF_BROADCAST;
1967         res.type = RTN_BROADCAST;
1968         RT_CACHE_STAT_INC(in_brd);
1969
1970 local_input:
1971         rth = dst_alloc(&ipv4_dst_ops);
1972         if (!rth)
1973                 goto e_nobufs;
1974
1975         rth->u.dst.output= ip_rt_bug;
1976
1977         atomic_set(&rth->u.dst.__refcnt, 1);
1978         rth->u.dst.flags= DST_HOST;
1979         if (in_dev->cnf.no_policy)
1980                 rth->u.dst.flags |= DST_NOPOLICY;
1981         rth->fl.fl4_dst = daddr;
1982         rth->rt_dst     = daddr;
1983         rth->fl.fl4_tos = tos;
1984 #ifdef CONFIG_IP_ROUTE_FWMARK
1985         rth->fl.fl4_fwmark= skb->nfmark;
1986 #endif
1987         rth->fl.fl4_src = saddr;
1988         rth->rt_src     = saddr;
1989 #ifdef CONFIG_NET_CLS_ROUTE
1990         rth->u.dst.tclassid = itag;
1991 #endif
1992         rth->rt_iif     =
1993         rth->fl.iif     = dev->ifindex;
1994         rth->u.dst.dev  = &loopback_dev;
1995         dev_hold(rth->u.dst.dev);
1996         rth->idev       = in_dev_get(rth->u.dst.dev);
1997         rth->rt_gateway = daddr;
1998         rth->rt_spec_dst= spec_dst;
1999         rth->u.dst.input= ip_local_deliver;
2000         rth->rt_flags   = flags|RTCF_LOCAL;
2001         if (res.type == RTN_UNREACHABLE) {
2002                 rth->u.dst.input= ip_error;
2003                 rth->u.dst.error= -err;
2004                 rth->rt_flags   &= ~RTCF_LOCAL;
2005         }
2006         rth->rt_type    = res.type;
2007         hash = rt_hash_code(daddr, saddr ^ (fl.iif << 5), tos);
2008         err = rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
2009         goto done;
2010
2011 no_route:
2012         RT_CACHE_STAT_INC(in_no_route);
2013         spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
2014         res.type = RTN_UNREACHABLE;
2015         goto local_input;
2016
2017         /*
2018          *      Do not cache martian addresses: they should be logged (RFC1812)
2019          */
2020 martian_destination:
2021         RT_CACHE_STAT_INC(in_martian_dst);
2022 #ifdef CONFIG_IP_ROUTE_VERBOSE
2023         if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
2024                 printk(KERN_WARNING "martian destination %u.%u.%u.%u from "
2025                         "%u.%u.%u.%u, dev %s\n",
2026                         NIPQUAD(daddr), NIPQUAD(saddr), dev->name);
2027 #endif
2028 e_inval:
2029         err = -EINVAL;
2030         goto done;
2031
2032 e_nobufs:
2033         err = -ENOBUFS;
2034         goto done;
2035
2036 martian_source:
2037         ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
2038         goto e_inval;
2039 }
2040
2041 int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
2042                    u8 tos, struct net_device *dev)
2043 {
2044         struct rtable * rth;
2045         unsigned        hash;
2046         int iif = dev->ifindex;
2047
2048         tos &= IPTOS_RT_MASK;
2049         hash = rt_hash_code(daddr, saddr ^ (iif << 5), tos);
2050
2051         rcu_read_lock();
2052         for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
2053              rth = rcu_dereference(rth->u.rt_next)) {
2054                 if (rth->fl.fl4_dst == daddr &&
2055                     rth->fl.fl4_src == saddr &&
2056                     rth->fl.iif == iif &&
2057                     rth->fl.oif == 0 &&
2058 #ifdef CONFIG_IP_ROUTE_FWMARK
2059                     rth->fl.fl4_fwmark == skb->nfmark &&
2060 #endif
2061                     rth->fl.fl4_tos == tos) {
2062                         rth->u.dst.lastuse = jiffies;
2063                         dst_hold(&rth->u.dst);
2064                         rth->u.dst.__use++;
2065                         RT_CACHE_STAT_INC(in_hit);
2066                         rcu_read_unlock();
2067                         skb->dst = (struct dst_entry*)rth;
2068                         return 0;
2069                 }
2070                 RT_CACHE_STAT_INC(in_hlist_search);
2071         }
2072         rcu_read_unlock();
2073
2074         /* Multicast recognition logic is moved from route cache to here.
2075            The problem was that too many Ethernet cards have broken/missing
2076            hardware multicast filters :-( As result the host on multicasting
2077            network acquires a lot of useless route cache entries, sort of
2078            SDR messages from all the world. Now we try to get rid of them.
2079            Really, provided software IP multicast filter is organized
2080            reasonably (at least, hashed), it does not result in a slowdown
2081            comparing with route cache reject entries.
2082            Note, that multicast routers are not affected, because
2083            route cache entry is created eventually.
2084          */
2085         if (MULTICAST(daddr)) {
2086                 struct in_device *in_dev;
2087
2088                 rcu_read_lock();
2089                 if ((in_dev = __in_dev_get(dev)) != NULL) {
2090                         int our = ip_check_mc(in_dev, daddr, saddr,
2091                                 skb->nh.iph->protocol);
2092                         if (our
2093 #ifdef CONFIG_IP_MROUTE
2094                             || (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev))
2095 #endif
2096                             ) {
2097                                 rcu_read_unlock();
2098                                 return ip_route_input_mc(skb, daddr, saddr,
2099                                                          tos, dev, our);
2100                         }
2101                 }
2102                 rcu_read_unlock();
2103                 return -EINVAL;
2104         }
2105         return ip_route_input_slow(skb, daddr, saddr, tos, dev);
2106 }
2107
2108 static inline int __mkroute_output(struct rtable **result,
2109                                    struct fib_result* res,
2110                                    const struct flowi *fl,
2111                                    const struct flowi *oldflp,
2112                                    struct net_device *dev_out,
2113                                    unsigned flags)
2114 {
2115         struct rtable *rth;
2116         struct in_device *in_dev;
2117         u32 tos = RT_FL_TOS(oldflp);
2118         int err = 0;
2119
2120         if (LOOPBACK(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK))
2121                 return -EINVAL;
2122
2123         if (fl->fl4_dst == 0xFFFFFFFF)
2124                 res->type = RTN_BROADCAST;
2125         else if (MULTICAST(fl->fl4_dst))
2126                 res->type = RTN_MULTICAST;
2127         else if (BADCLASS(fl->fl4_dst) || ZERONET(fl->fl4_dst))
2128                 return -EINVAL;
2129
2130         if (dev_out->flags & IFF_LOOPBACK)
2131                 flags |= RTCF_LOCAL;
2132
2133         /* get work reference to inet device */
2134         in_dev = in_dev_get(dev_out);
2135         if (!in_dev)
2136                 return -EINVAL;
2137
2138         if (res->type == RTN_BROADCAST) {
2139                 flags |= RTCF_BROADCAST | RTCF_LOCAL;
2140                 if (res->fi) {
2141                         fib_info_put(res->fi);
2142                         res->fi = NULL;
2143                 }
2144         } else if (res->type == RTN_MULTICAST) {
2145                 flags |= RTCF_MULTICAST|RTCF_LOCAL;
2146                 if (!ip_check_mc(in_dev, oldflp->fl4_dst, oldflp->fl4_src,
2147                                  oldflp->proto))
2148                         flags &= ~RTCF_LOCAL;
2149                 /* If multicast route do not exist use
2150                    default one, but do not gateway in this case.
2151                    Yes, it is hack.
2152                  */
2153                 if (res->fi && res->prefixlen < 4) {
2154                         fib_info_put(res->fi);
2155                         res->fi = NULL;
2156                 }
2157         }
2158
2159
2160         rth = dst_alloc(&ipv4_dst_ops);
2161         if (!rth) {
2162                 err = -ENOBUFS;
2163                 goto cleanup;
2164         }
2165
2166         rth->u.dst.flags= DST_HOST;
2167 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
2168         if (res->fi) {
2169                 rth->rt_multipath_alg = res->fi->fib_mp_alg;
2170                 if (res->fi->fib_nhs > 1)
2171                         rth->u.dst.flags |= DST_BALANCED;
2172         }
2173 #endif
2174         if (in_dev->cnf.no_xfrm)
2175                 rth->u.dst.flags |= DST_NOXFRM;
2176         if (in_dev->cnf.no_policy)
2177                 rth->u.dst.flags |= DST_NOPOLICY;
2178
2179         rth->fl.fl4_dst = oldflp->fl4_dst;
2180         rth->fl.fl4_tos = tos;
2181         rth->fl.fl4_src = oldflp->fl4_src;
2182         rth->fl.oif     = oldflp->oif;
2183 #ifdef CONFIG_IP_ROUTE_FWMARK
2184         rth->fl.fl4_fwmark= oldflp->fl4_fwmark;
2185 #endif
2186         rth->rt_dst     = fl->fl4_dst;
2187         rth->rt_src     = fl->fl4_src;
2188         rth->rt_iif     = oldflp->oif ? : dev_out->ifindex;
2189         /* get references to the devices that are to be hold by the routing
2190            cache entry */
2191         rth->u.dst.dev  = dev_out;
2192         dev_hold(dev_out);
2193         rth->idev       = in_dev_get(dev_out);
2194         rth->rt_gateway = fl->fl4_dst;
2195         rth->rt_spec_dst= fl->fl4_src;
2196
2197         rth->u.dst.output=ip_output;
2198
2199         RT_CACHE_STAT_INC(out_slow_tot);
2200
2201         if (flags & RTCF_LOCAL) {
2202                 rth->u.dst.input = ip_local_deliver;
2203                 rth->rt_spec_dst = fl->fl4_dst;
2204         }
2205         if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
2206                 rth->rt_spec_dst = fl->fl4_src;
2207                 if (flags & RTCF_LOCAL &&
2208                     !(dev_out->flags & IFF_LOOPBACK)) {
2209                         rth->u.dst.output = ip_mc_output;
2210                         RT_CACHE_STAT_INC(out_slow_mc);
2211                 }
2212 #ifdef CONFIG_IP_MROUTE
2213                 if (res->type == RTN_MULTICAST) {
2214                         if (IN_DEV_MFORWARD(in_dev) &&
2215                             !LOCAL_MCAST(oldflp->fl4_dst)) {
2216                                 rth->u.dst.input = ip_mr_input;
2217                                 rth->u.dst.output = ip_mc_output;
2218                         }
2219                 }
2220 #endif
2221         }
2222
2223         rt_set_nexthop(rth, res, 0);
2224
2225         rth->rt_flags = flags;
2226
2227         *result = rth;
2228  cleanup:
2229         /* release work reference to inet device */
2230         in_dev_put(in_dev);
2231
2232         return err;
2233 }
2234
2235 static inline int ip_mkroute_output_def(struct rtable **rp,
2236                                         struct fib_result* res,
2237                                         const struct flowi *fl,
2238                                         const struct flowi *oldflp,
2239                                         struct net_device *dev_out,
2240                                         unsigned flags)
2241 {
2242         struct rtable *rth;
2243         int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
2244         unsigned hash;
2245         if (err == 0) {
2246                 u32 tos = RT_FL_TOS(oldflp);
2247
2248                 atomic_set(&rth->u.dst.__refcnt, 1);
2249
2250                 hash = rt_hash_code(oldflp->fl4_dst,
2251                                     oldflp->fl4_src ^ (oldflp->oif << 5), tos);
2252                 err = rt_intern_hash(hash, rth, rp);
2253         }
2254
2255         return err;
2256 }
2257
2258 static inline int ip_mkroute_output(struct rtable** rp,
2259                                     struct fib_result* res,
2260                                     const struct flowi *fl,
2261                                     const struct flowi *oldflp,
2262                                     struct net_device *dev_out,
2263                                     unsigned flags)
2264 {
2265 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
2266         u32 tos = RT_FL_TOS(oldflp);
2267         unsigned char hop;
2268         unsigned hash;
2269         int err = -EINVAL;
2270         struct rtable *rth;
2271
2272         if (res->fi && res->fi->fib_nhs > 1) {
2273                 unsigned char hopcount = res->fi->fib_nhs;
2274
2275                 for (hop = 0; hop < hopcount; hop++) {
2276                         struct net_device *dev2nexthop;
2277
2278                         res->nh_sel = hop;
2279
2280                         /* hold a work reference to the output device */
2281                         dev2nexthop = FIB_RES_DEV(*res);
2282                         dev_hold(dev2nexthop);
2283
2284                         err = __mkroute_output(&rth, res, fl, oldflp,
2285                                                dev2nexthop, flags);
2286
2287                         if (err != 0)
2288                                 goto cleanup;
2289
2290                         hash = rt_hash_code(oldflp->fl4_dst,
2291                                             oldflp->fl4_src ^
2292                                             (oldflp->oif << 5), tos);
2293                         err = rt_intern_hash(hash, rth, rp);
2294
2295                         /* forward hop information to multipath impl. */
2296                         multipath_set_nhinfo(rth,
2297                                              FIB_RES_NETWORK(*res),
2298                                              FIB_RES_NETMASK(*res),
2299                                              res->prefixlen,
2300                                              &FIB_RES_NH(*res));
2301                 cleanup:
2302                         /* release work reference to output device */
2303                         dev_put(dev2nexthop);
2304
2305                         if (err != 0)
2306                                 return err;
2307                 }
2308                 atomic_set(&(*rp)->u.dst.__refcnt, 1);
2309                 return err;
2310         } else {
2311                 return ip_mkroute_output_def(rp, res, fl, oldflp, dev_out,
2312                                              flags);
2313         }
2314 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
2315         return ip_mkroute_output_def(rp, res, fl, oldflp, dev_out, flags);
2316 #endif
2317 }
2318
2319 /*
2320  * Major route resolver routine.
2321  */
2322
2323 static int ip_route_output_slow(struct rtable **rp, const struct flowi *oldflp)
2324 {
2325         u32 tos = RT_FL_TOS(oldflp);
2326         struct flowi fl = { .nl_u = { .ip4_u =
2327                                       { .daddr = oldflp->fl4_dst,
2328                                         .saddr = oldflp->fl4_src,
2329                                         .tos = tos & IPTOS_RT_MASK,
2330                                         .scope = ((tos & RTO_ONLINK) ?
2331                                                   RT_SCOPE_LINK :
2332                                                   RT_SCOPE_UNIVERSE),
2333 #ifdef CONFIG_IP_ROUTE_FWMARK
2334                                         .fwmark = oldflp->fl4_fwmark
2335 #endif
2336                                       } },
2337                             .iif = loopback_dev.ifindex,
2338                             .oif = oldflp->oif };
2339         struct fib_result res;
2340         unsigned flags = 0;
2341         struct net_device *dev_out = NULL;
2342         int free_res = 0;
2343         int err;
2344
2345
2346         res.fi          = NULL;
2347 #ifdef CONFIG_IP_MULTIPLE_TABLES
2348         res.r           = NULL;
2349 #endif
2350
2351         if (oldflp->fl4_src) {
2352                 err = -EINVAL;
2353                 if (MULTICAST(oldflp->fl4_src) ||
2354                     BADCLASS(oldflp->fl4_src) ||
2355                     ZERONET(oldflp->fl4_src))
2356                         goto out;
2357
2358                 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2359                 dev_out = ip_dev_find(oldflp->fl4_src);
2360                 if (dev_out == NULL)
2361                         goto out;
2362
2363                 /* I removed check for oif == dev_out->oif here.
2364                    It was wrong for two reasons:
2365                    1. ip_dev_find(saddr) can return wrong iface, if saddr is
2366                       assigned to multiple interfaces.
2367                    2. Moreover, we are allowed to send packets with saddr
2368                       of another iface. --ANK
2369                  */
2370
2371                 if (oldflp->oif == 0
2372                     && (MULTICAST(oldflp->fl4_dst) || oldflp->fl4_dst == 0xFFFFFFFF)) {
2373                         /* Special hack: user can direct multicasts
2374                            and limited broadcast via necessary interface
2375                            without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2376                            This hack is not just for fun, it allows
2377                            vic,vat and friends to work.
2378                            They bind socket to loopback, set ttl to zero
2379                            and expect that it will work.
2380                            From the viewpoint of routing cache they are broken,
2381                            because we are not allowed to build multicast path
2382                            with loopback source addr (look, routing cache
2383                            cannot know, that ttl is zero, so that packet
2384                            will not leave this host and route is valid).
2385                            Luckily, this hack is good workaround.
2386                          */
2387
2388                         fl.oif = dev_out->ifindex;
2389                         goto make_route;
2390                 }
2391                 if (dev_out)
2392                         dev_put(dev_out);
2393                 dev_out = NULL;
2394         }
2395
2396
2397         if (oldflp->oif) {
2398                 dev_out = dev_get_by_index(oldflp->oif);
2399                 err = -ENODEV;
2400                 if (dev_out == NULL)
2401                         goto out;
2402                 if (__in_dev_get(dev_out) == NULL) {
2403                         dev_put(dev_out);
2404                         goto out;       /* Wrong error code */
2405                 }
2406
2407                 if (LOCAL_MCAST(oldflp->fl4_dst) || oldflp->fl4_dst == 0xFFFFFFFF) {
2408                         if (!fl.fl4_src)
2409                                 fl.fl4_src = inet_select_addr(dev_out, 0,
2410                                                               RT_SCOPE_LINK);
2411                         goto make_route;
2412                 }
2413                 if (!fl.fl4_src) {
2414                         if (MULTICAST(oldflp->fl4_dst))
2415                                 fl.fl4_src = inet_select_addr(dev_out, 0,
2416                                                               fl.fl4_scope);
2417                         else if (!oldflp->fl4_dst)
2418                                 fl.fl4_src = inet_select_addr(dev_out, 0,
2419                                                               RT_SCOPE_HOST);
2420                 }
2421         }
2422
2423         if (!fl.fl4_dst) {
2424                 fl.fl4_dst = fl.fl4_src;
2425                 if (!fl.fl4_dst)
2426                         fl.fl4_dst = fl.fl4_src = htonl(INADDR_LOOPBACK);
2427                 if (dev_out)
2428                         dev_put(dev_out);
2429                 dev_out = &loopback_dev;
2430                 dev_hold(dev_out);
2431                 fl.oif = loopback_dev.ifindex;
2432                 res.type = RTN_LOCAL;
2433                 flags |= RTCF_LOCAL;
2434                 goto make_route;
2435         }
2436
2437         if (fib_lookup(&fl, &res)) {
2438                 res.fi = NULL;
2439                 if (oldflp->oif) {
2440                         /* Apparently, routing tables are wrong. Assume,
2441                            that the destination is on link.
2442
2443                            WHY? DW.
2444                            Because we are allowed to send to iface
2445                            even if it has NO routes and NO assigned
2446                            addresses. When oif is specified, routing
2447                            tables are looked up with only one purpose:
2448                            to catch if destination is gatewayed, rather than
2449                            direct. Moreover, if MSG_DONTROUTE is set,
2450                            we send packet, ignoring both routing tables
2451                            and ifaddr state. --ANK
2452
2453
2454                            We could make it even if oif is unknown,
2455                            likely IPv6, but we do not.
2456                          */
2457
2458                         if (fl.fl4_src == 0)
2459                                 fl.fl4_src = inet_select_addr(dev_out, 0,
2460                                                               RT_SCOPE_LINK);
2461                         res.type = RTN_UNICAST;
2462                         goto make_route;
2463                 }
2464                 if (dev_out)
2465                         dev_put(dev_out);
2466                 err = -ENETUNREACH;
2467                 goto out;
2468         }
2469         free_res = 1;
2470
2471         if (res.type == RTN_LOCAL) {
2472                 if (!fl.fl4_src)
2473                         fl.fl4_src = fl.fl4_dst;
2474                 if (dev_out)
2475                         dev_put(dev_out);
2476                 dev_out = &loopback_dev;
2477                 dev_hold(dev_out);
2478                 fl.oif = dev_out->ifindex;
2479                 if (res.fi)
2480                         fib_info_put(res.fi);
2481                 res.fi = NULL;
2482                 flags |= RTCF_LOCAL;
2483                 goto make_route;
2484         }
2485
2486 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2487         if (res.fi->fib_nhs > 1 && fl.oif == 0)
2488                 fib_select_multipath(&fl, &res);
2489         else
2490 #endif
2491         if (!res.prefixlen && res.type == RTN_UNICAST && !fl.oif)
2492                 fib_select_default(&fl, &res);
2493
2494         if (!fl.fl4_src)
2495                 fl.fl4_src = FIB_RES_PREFSRC(res);
2496
2497         if (dev_out)
2498                 dev_put(dev_out);
2499         dev_out = FIB_RES_DEV(res);
2500         dev_hold(dev_out);
2501         fl.oif = dev_out->ifindex;
2502
2503
2504 make_route:
2505         err = ip_mkroute_output(rp, &res, &fl, oldflp, dev_out, flags);
2506
2507
2508         if (free_res)
2509                 fib_res_put(&res);
2510         if (dev_out)
2511                 dev_put(dev_out);
2512 out:    return err;
2513 }
2514
2515 int __ip_route_output_key(struct rtable **rp, const struct flowi *flp)
2516 {
2517         unsigned hash;
2518         struct rtable *rth;
2519
2520         hash = rt_hash_code(flp->fl4_dst, flp->fl4_src ^ (flp->oif << 5), flp->fl4_tos);
2521
2522         rcu_read_lock_bh();
2523         for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
2524                 rth = rcu_dereference(rth->u.rt_next)) {
2525                 if (rth->fl.fl4_dst == flp->fl4_dst &&
2526                     rth->fl.fl4_src == flp->fl4_src &&
2527                     rth->fl.iif == 0 &&
2528                     rth->fl.oif == flp->oif &&
2529 #ifdef CONFIG_IP_ROUTE_FWMARK
2530                     rth->fl.fl4_fwmark == flp->fl4_fwmark &&
2531 #endif
2532                     !((rth->fl.fl4_tos ^ flp->fl4_tos) &
2533                             (IPTOS_RT_MASK | RTO_ONLINK))) {
2534
2535                         /* check for multipath routes and choose one if
2536                          * necessary
2537                          */
2538                         if (multipath_select_route(flp, rth, rp)) {
2539                                 dst_hold(&(*rp)->u.dst);
2540                                 RT_CACHE_STAT_INC(out_hit);
2541                                 rcu_read_unlock_bh();
2542                                 return 0;
2543                         }
2544
2545                         rth->u.dst.lastuse = jiffies;
2546                         dst_hold(&rth->u.dst);
2547                         rth->u.dst.__use++;
2548                         RT_CACHE_STAT_INC(out_hit);
2549                         rcu_read_unlock_bh();
2550                         *rp = rth;
2551                         return 0;
2552                 }
2553                 RT_CACHE_STAT_INC(out_hlist_search);
2554         }
2555         rcu_read_unlock_bh();
2556
2557         return ip_route_output_slow(rp, flp);
2558 }
2559
2560 int ip_route_output_flow(struct rtable **rp, struct flowi *flp, struct sock *sk, int flags)
2561 {
2562         int err;
2563
2564         if ((err = __ip_route_output_key(rp, flp)) != 0)
2565                 return err;
2566
2567         if (flp->proto) {
2568                 if (!flp->fl4_src)
2569                         flp->fl4_src = (*rp)->rt_src;
2570                 if (!flp->fl4_dst)
2571                         flp->fl4_dst = (*rp)->rt_dst;
2572                 return xfrm_lookup((struct dst_entry **)rp, flp, sk, flags);
2573         }
2574
2575         return 0;
2576 }
2577
2578 int ip_route_output_key(struct rtable **rp, struct flowi *flp)
2579 {
2580         return ip_route_output_flow(rp, flp, NULL, 0);
2581 }
2582
2583 static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
2584                         int nowait)
2585 {
2586         struct rtable *rt = (struct rtable*)skb->dst;
2587         struct rtmsg *r;
2588         struct nlmsghdr  *nlh;
2589         unsigned char    *b = skb->tail;
2590         struct rta_cacheinfo ci;
2591 #ifdef CONFIG_IP_MROUTE
2592         struct rtattr *eptr;
2593 #endif
2594         nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*r));
2595         r = NLMSG_DATA(nlh);
2596         nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;
2597         r->rtm_family    = AF_INET;
2598         r->rtm_dst_len  = 32;
2599         r->rtm_src_len  = 0;
2600         r->rtm_tos      = rt->fl.fl4_tos;
2601         r->rtm_table    = RT_TABLE_MAIN;
2602         r->rtm_type     = rt->rt_type;
2603         r->rtm_scope    = RT_SCOPE_UNIVERSE;
2604         r->rtm_protocol = RTPROT_UNSPEC;
2605         r->rtm_flags    = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2606         if (rt->rt_flags & RTCF_NOTIFY)
2607                 r->rtm_flags |= RTM_F_NOTIFY;
2608         RTA_PUT(skb, RTA_DST, 4, &rt->rt_dst);
2609         if (rt->fl.fl4_src) {
2610                 r->rtm_src_len = 32;
2611                 RTA_PUT(skb, RTA_SRC, 4, &rt->fl.fl4_src);
2612         }
2613         if (rt->u.dst.dev)
2614                 RTA_PUT(skb, RTA_OIF, sizeof(int), &rt->u.dst.dev->ifindex);
2615 #ifdef CONFIG_NET_CLS_ROUTE
2616         if (rt->u.dst.tclassid)
2617                 RTA_PUT(skb, RTA_FLOW, 4, &rt->u.dst.tclassid);
2618 #endif
2619 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
2620         if (rt->rt_multipath_alg != IP_MP_ALG_NONE) {
2621                 __u32 alg = rt->rt_multipath_alg;
2622
2623                 RTA_PUT(skb, RTA_MP_ALGO, 4, &alg);
2624         }
2625 #endif
2626         if (rt->fl.iif)
2627                 RTA_PUT(skb, RTA_PREFSRC, 4, &rt->rt_spec_dst);
2628         else if (rt->rt_src != rt->fl.fl4_src)
2629                 RTA_PUT(skb, RTA_PREFSRC, 4, &rt->rt_src);
2630         if (rt->rt_dst != rt->rt_gateway)
2631                 RTA_PUT(skb, RTA_GATEWAY, 4, &rt->rt_gateway);
2632         if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2633                 goto rtattr_failure;
2634         ci.rta_lastuse  = jiffies_to_clock_t(jiffies - rt->u.dst.lastuse);
2635         ci.rta_used     = rt->u.dst.__use;
2636         ci.rta_clntref  = atomic_read(&rt->u.dst.__refcnt);
2637         if (rt->u.dst.expires)
2638                 ci.rta_expires = jiffies_to_clock_t(rt->u.dst.expires - jiffies);
2639         else
2640                 ci.rta_expires = 0;
2641         ci.rta_error    = rt->u.dst.error;
2642         ci.rta_id       = ci.rta_ts = ci.rta_tsage = 0;
2643         if (rt->peer) {
2644                 ci.rta_id = rt->peer->ip_id_count;
2645                 if (rt->peer->tcp_ts_stamp) {
2646                         ci.rta_ts = rt->peer->tcp_ts;
2647                         ci.rta_tsage = xtime.tv_sec - rt->peer->tcp_ts_stamp;
2648                 }
2649         }
2650 #ifdef CONFIG_IP_MROUTE
2651         eptr = (struct rtattr*)skb->tail;
2652 #endif
2653         RTA_PUT(skb, RTA_CACHEINFO, sizeof(ci), &ci);
2654         if (rt->fl.iif) {
2655 #ifdef CONFIG_IP_MROUTE
2656                 u32 dst = rt->rt_dst;
2657
2658                 if (MULTICAST(dst) && !LOCAL_MCAST(dst) &&
2659                     ipv4_devconf.mc_forwarding) {
2660                         int err = ipmr_get_route(skb, r, nowait);
2661                         if (err <= 0) {
2662                                 if (!nowait) {
2663                                         if (err == 0)
2664                                                 return 0;
2665                                         goto nlmsg_failure;
2666                                 } else {
2667                                         if (err == -EMSGSIZE)
2668                                                 goto nlmsg_failure;
2669                                         ((struct rta_cacheinfo*)RTA_DATA(eptr))->rta_error = err;
2670                                 }
2671                         }
2672                 } else
2673 #endif
2674                         RTA_PUT(skb, RTA_IIF, sizeof(int), &rt->fl.iif);
2675         }
2676
2677         nlh->nlmsg_len = skb->tail - b;
2678         return skb->len;
2679
2680 nlmsg_failure:
2681 rtattr_failure:
2682         skb_trim(skb, b - skb->data);
2683         return -1;
2684 }
2685
2686 int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2687 {
2688         struct rtattr **rta = arg;
2689         struct rtmsg *rtm = NLMSG_DATA(nlh);
2690         struct rtable *rt = NULL;
2691         u32 dst = 0;
2692         u32 src = 0;
2693         int iif = 0;
2694         int err = -ENOBUFS;
2695         struct sk_buff *skb;
2696
2697         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2698         if (!skb)
2699                 goto out;
2700
2701         /* Reserve room for dummy headers, this skb can pass
2702            through good chunk of routing engine.
2703          */
2704         skb->mac.raw = skb->data;
2705         skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2706
2707         if (rta[RTA_SRC - 1])
2708                 memcpy(&src, RTA_DATA(rta[RTA_SRC - 1]), 4);
2709         if (rta[RTA_DST - 1])
2710                 memcpy(&dst, RTA_DATA(rta[RTA_DST - 1]), 4);
2711         if (rta[RTA_IIF - 1])
2712                 memcpy(&iif, RTA_DATA(rta[RTA_IIF - 1]), sizeof(int));
2713
2714         if (iif) {
2715                 struct net_device *dev = __dev_get_by_index(iif);
2716                 err = -ENODEV;
2717                 if (!dev)
2718                         goto out_free;
2719                 skb->protocol   = htons(ETH_P_IP);
2720                 skb->dev        = dev;
2721                 local_bh_disable();
2722                 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2723                 local_bh_enable();
2724                 rt = (struct rtable*)skb->dst;
2725                 if (!err && rt->u.dst.error)
2726                         err = -rt->u.dst.error;
2727         } else {
2728                 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = dst,
2729                                                          .saddr = src,
2730                                                          .tos = rtm->rtm_tos } } };
2731                 int oif = 0;
2732                 if (rta[RTA_OIF - 1])
2733                         memcpy(&oif, RTA_DATA(rta[RTA_OIF - 1]), sizeof(int));
2734                 fl.oif = oif;
2735                 err = ip_route_output_key(&rt, &fl);
2736         }
2737         if (err)
2738                 goto out_free;
2739
2740         skb->dst = &rt->u.dst;
2741         if (rtm->rtm_flags & RTM_F_NOTIFY)
2742                 rt->rt_flags |= RTCF_NOTIFY;
2743
2744         NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
2745
2746         err = rt_fill_info(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
2747                                 RTM_NEWROUTE, 0);
2748         if (!err)
2749                 goto out_free;
2750         if (err < 0) {
2751                 err = -EMSGSIZE;
2752                 goto out_free;
2753         }
2754
2755         err = netlink_unicast(rtnl, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
2756         if (err > 0)
2757                 err = 0;
2758 out:    return err;
2759
2760 out_free:
2761         kfree_skb(skb);
2762         goto out;
2763 }
2764
2765 int ip_rt_dump(struct sk_buff *skb,  struct netlink_callback *cb)
2766 {
2767         struct rtable *rt;
2768         int h, s_h;
2769         int idx, s_idx;
2770
2771         s_h = cb->args[0];
2772         s_idx = idx = cb->args[1];
2773         for (h = 0; h <= rt_hash_mask; h++) {
2774                 if (h < s_h) continue;
2775                 if (h > s_h)
2776                         s_idx = 0;
2777                 rcu_read_lock_bh();
2778                 for (rt = rcu_dereference(rt_hash_table[h].chain), idx = 0; rt;
2779                      rt = rcu_dereference(rt->u.rt_next), idx++) {
2780                         if (idx < s_idx)
2781                                 continue;
2782                         skb->dst = dst_clone(&rt->u.dst);
2783                         if (rt_fill_info(skb, NETLINK_CB(cb->skb).pid,
2784                                          cb->nlh->nlmsg_seq,
2785                                          RTM_NEWROUTE, 1) <= 0) {
2786                                 dst_release(xchg(&skb->dst, NULL));
2787                                 rcu_read_unlock_bh();
2788                                 goto done;
2789                         }
2790                         dst_release(xchg(&skb->dst, NULL));
2791                 }
2792                 rcu_read_unlock_bh();
2793         }
2794
2795 done:
2796         cb->args[0] = h;
2797         cb->args[1] = idx;
2798         return skb->len;
2799 }
2800
2801 void ip_rt_multicast_event(struct in_device *in_dev)
2802 {
2803         rt_cache_flush(0);
2804 }
2805
2806 #ifdef CONFIG_SYSCTL
2807 static int flush_delay;
2808
2809 static int ipv4_sysctl_rtcache_flush(ctl_table *ctl, int write,
2810                                         struct file *filp, void __user *buffer,
2811                                         size_t *lenp, loff_t *ppos)
2812 {
2813         if (write) {
2814                 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2815                 rt_cache_flush(flush_delay);
2816                 return 0;
2817         }
2818
2819         return -EINVAL;
2820 }
2821
2822 static int ipv4_sysctl_rtcache_flush_strategy(ctl_table *table,
2823                                                 int __user *name,
2824                                                 int nlen,
2825                                                 void __user *oldval,
2826                                                 size_t __user *oldlenp,
2827                                                 void __user *newval,
2828                                                 size_t newlen,
2829                                                 void **context)
2830 {
2831         int delay;
2832         if (newlen != sizeof(int))
2833                 return -EINVAL;
2834         if (get_user(delay, (int __user *)newval))
2835                 return -EFAULT;
2836         rt_cache_flush(delay);
2837         return 0;
2838 }
2839
2840 ctl_table ipv4_route_table[] = {
2841         {
2842                 .ctl_name       = NET_IPV4_ROUTE_FLUSH,
2843                 .procname       = "flush",
2844                 .data           = &flush_delay,
2845                 .maxlen         = sizeof(int),
2846                 .mode           = 0200,
2847                 .proc_handler   = &ipv4_sysctl_rtcache_flush,
2848                 .strategy       = &ipv4_sysctl_rtcache_flush_strategy,
2849         },
2850         {
2851                 .ctl_name       = NET_IPV4_ROUTE_MIN_DELAY,
2852                 .procname       = "min_delay",
2853                 .data           = &ip_rt_min_delay,
2854                 .maxlen         = sizeof(int),
2855                 .mode           = 0644,
2856                 .proc_handler   = &proc_dointvec_jiffies,
2857                 .strategy       = &sysctl_jiffies,
2858         },
2859         {
2860                 .ctl_name       = NET_IPV4_ROUTE_MAX_DELAY,
2861                 .procname       = "max_delay",
2862                 .data           = &ip_rt_max_delay,
2863                 .maxlen         = sizeof(int),
2864                 .mode           = 0644,
2865                 .proc_handler   = &proc_dointvec_jiffies,
2866                 .strategy       = &sysctl_jiffies,
2867         },
2868         {
2869                 .ctl_name       = NET_IPV4_ROUTE_GC_THRESH,
2870                 .procname       = "gc_thresh",
2871                 .data           = &ipv4_dst_ops.gc_thresh,
2872                 .maxlen         = sizeof(int),
2873                 .mode           = 0644,
2874                 .proc_handler   = &proc_dointvec,
2875         },
2876         {
2877                 .ctl_name       = NET_IPV4_ROUTE_MAX_SIZE,
2878                 .procname       = "max_size",
2879                 .data           = &ip_rt_max_size,
2880                 .maxlen         = sizeof(int),
2881                 .mode           = 0644,
2882                 .proc_handler   = &proc_dointvec,
2883         },
2884         {
2885                 /*  Deprecated. Use gc_min_interval_ms */
2886
2887                 .ctl_name       = NET_IPV4_ROUTE_GC_MIN_INTERVAL,
2888                 .procname       = "gc_min_interval",
2889                 .data           = &ip_rt_gc_min_interval,
2890                 .maxlen         = sizeof(int),
2891                 .mode           = 0644,
2892                 .proc_handler   = &proc_dointvec_jiffies,
2893                 .strategy       = &sysctl_jiffies,
2894         },
2895         {
2896                 .ctl_name       = NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS,
2897                 .procname       = "gc_min_interval_ms",
2898                 .data           = &ip_rt_gc_min_interval,
2899                 .maxlen         = sizeof(int),
2900                 .mode           = 0644,
2901                 .proc_handler   = &proc_dointvec_ms_jiffies,
2902                 .strategy       = &sysctl_ms_jiffies,
2903         },
2904         {
2905                 .ctl_name       = NET_IPV4_ROUTE_GC_TIMEOUT,
2906                 .procname       = "gc_timeout",
2907                 .data           = &ip_rt_gc_timeout,
2908                 .maxlen         = sizeof(int),
2909                 .mode           = 0644,
2910                 .proc_handler   = &proc_dointvec_jiffies,
2911                 .strategy       = &sysctl_jiffies,
2912         },
2913         {
2914                 .ctl_name       = NET_IPV4_ROUTE_GC_INTERVAL,
2915                 .procname       = "gc_interval",
2916                 .data           = &ip_rt_gc_interval,
2917                 .maxlen         = sizeof(int),
2918                 .mode           = 0644,
2919                 .proc_handler   = &proc_dointvec_jiffies,
2920                 .strategy       = &sysctl_jiffies,
2921         },
2922         {
2923                 .ctl_name       = NET_IPV4_ROUTE_REDIRECT_LOAD,
2924                 .procname       = "redirect_load",
2925                 .data           = &ip_rt_redirect_load,
2926                 .maxlen         = sizeof(int),
2927                 .mode           = 0644,
2928                 .proc_handler   = &proc_dointvec,
2929         },
2930         {
2931                 .ctl_name       = NET_IPV4_ROUTE_REDIRECT_NUMBER,
2932                 .procname       = "redirect_number",
2933                 .data           = &ip_rt_redirect_number,
2934                 .maxlen         = sizeof(int),
2935                 .mode           = 0644,
2936                 .proc_handler   = &proc_dointvec,
2937         },
2938         {
2939                 .ctl_name       = NET_IPV4_ROUTE_REDIRECT_SILENCE,
2940                 .procname       = "redirect_silence",
2941                 .data           = &ip_rt_redirect_silence,
2942                 .maxlen         = sizeof(int),
2943                 .mode           = 0644,
2944                 .proc_handler   = &proc_dointvec,
2945         },
2946         {
2947                 .ctl_name       = NET_IPV4_ROUTE_ERROR_COST,
2948                 .procname       = "error_cost",
2949                 .data           = &ip_rt_error_cost,
2950                 .maxlen         = sizeof(int),
2951                 .mode           = 0644,
2952                 .proc_handler   = &proc_dointvec,
2953         },
2954         {
2955                 .ctl_name       = NET_IPV4_ROUTE_ERROR_BURST,
2956                 .procname       = "error_burst",
2957                 .data           = &ip_rt_error_burst,
2958                 .maxlen         = sizeof(int),
2959                 .mode           = 0644,
2960                 .proc_handler   = &proc_dointvec,
2961         },
2962         {
2963                 .ctl_name       = NET_IPV4_ROUTE_GC_ELASTICITY,
2964                 .procname       = "gc_elasticity",
2965                 .data           = &ip_rt_gc_elasticity,
2966                 .maxlen         = sizeof(int),
2967                 .mode           = 0644,
2968                 .proc_handler   = &proc_dointvec,
2969         },
2970         {
2971                 .ctl_name       = NET_IPV4_ROUTE_MTU_EXPIRES,
2972                 .procname       = "mtu_expires",
2973                 .data           = &ip_rt_mtu_expires,
2974                 .maxlen         = sizeof(int),
2975                 .mode           = 0644,
2976                 .proc_handler   = &proc_dointvec_jiffies,
2977                 .strategy       = &sysctl_jiffies,
2978         },
2979         {
2980                 .ctl_name       = NET_IPV4_ROUTE_MIN_PMTU,
2981                 .procname       = "min_pmtu",
2982                 .data           = &ip_rt_min_pmtu,
2983                 .maxlen         = sizeof(int),
2984                 .mode           = 0644,
2985                 .proc_handler   = &proc_dointvec,
2986         },
2987         {
2988                 .ctl_name       = NET_IPV4_ROUTE_MIN_ADVMSS,
2989                 .procname       = "min_adv_mss",
2990                 .data           = &ip_rt_min_advmss,
2991                 .maxlen         = sizeof(int),
2992                 .mode           = 0644,
2993                 .proc_handler   = &proc_dointvec,
2994         },
2995         {
2996                 .ctl_name       = NET_IPV4_ROUTE_SECRET_INTERVAL,
2997                 .procname       = "secret_interval",
2998                 .data           = &ip_rt_secret_interval,
2999                 .maxlen         = sizeof(int),
3000                 .mode           = 0644,
3001                 .proc_handler   = &proc_dointvec_jiffies,
3002                 .strategy       = &sysctl_jiffies,
3003         },
3004         { .ctl_name = 0 }
3005 };
3006 #endif
3007
3008 #ifdef CONFIG_NET_CLS_ROUTE
3009 struct ip_rt_acct *ip_rt_acct;
3010
3011 /* This code sucks.  But you should have seen it before! --RR */
3012
3013 /* IP route accounting ptr for this logical cpu number. */
3014 #define IP_RT_ACCT_CPU(i) (ip_rt_acct + i * 256)
3015
3016 #ifdef CONFIG_PROC_FS
3017 static int ip_rt_acct_read(char *buffer, char **start, off_t offset,
3018                            int length, int *eof, void *data)
3019 {
3020         unsigned int i;
3021
3022         if ((offset & 3) || (length & 3))
3023                 return -EIO;
3024
3025         if (offset >= sizeof(struct ip_rt_acct) * 256) {
3026                 *eof = 1;
3027                 return 0;
3028         }
3029
3030         if (offset + length >= sizeof(struct ip_rt_acct) * 256) {
3031                 length = sizeof(struct ip_rt_acct) * 256 - offset;
3032                 *eof = 1;
3033         }
3034
3035         offset /= sizeof(u32);
3036
3037         if (length > 0) {
3038                 u32 *src = ((u32 *) IP_RT_ACCT_CPU(0)) + offset;
3039                 u32 *dst = (u32 *) buffer;
3040
3041                 /* Copy first cpu. */
3042                 *start = buffer;
3043                 memcpy(dst, src, length);
3044
3045                 /* Add the other cpus in, one int at a time */
3046                 for_each_cpu(i) {
3047                         unsigned int j;
3048
3049                         src = ((u32 *) IP_RT_ACCT_CPU(i)) + offset;
3050
3051                         for (j = 0; j < length/4; j++)
3052                                 dst[j] += src[j];
3053                 }
3054         }
3055         return length;
3056 }
3057 #endif /* CONFIG_PROC_FS */
3058 #endif /* CONFIG_NET_CLS_ROUTE */
3059
3060 static __initdata unsigned long rhash_entries;
3061 static int __init set_rhash_entries(char *str)
3062 {
3063         if (!str)
3064                 return 0;
3065         rhash_entries = simple_strtoul(str, &str, 0);
3066         return 1;
3067 }
3068 __setup("rhash_entries=", set_rhash_entries);
3069
3070 int __init ip_rt_init(void)
3071 {
3072         int i, order, goal, rc = 0;
3073
3074         rt_hash_rnd = (int) ((num_physpages ^ (num_physpages>>8)) ^
3075                              (jiffies ^ (jiffies >> 7)));
3076
3077 #ifdef CONFIG_NET_CLS_ROUTE
3078         for (order = 0;
3079              (PAGE_SIZE << order) < 256 * sizeof(struct ip_rt_acct) * NR_CPUS; order++)
3080                 /* NOTHING */;
3081         ip_rt_acct = (struct ip_rt_acct *)__get_free_pages(GFP_KERNEL, order);
3082         if (!ip_rt_acct)
3083                 panic("IP: failed to allocate ip_rt_acct\n");
3084         memset(ip_rt_acct, 0, PAGE_SIZE << order);
3085 #endif
3086
3087         ipv4_dst_ops.kmem_cachep = kmem_cache_create("ip_dst_cache",
3088                                                      sizeof(struct rtable),
3089                                                      0, SLAB_HWCACHE_ALIGN,
3090                                                      NULL, NULL);
3091
3092         if (!ipv4_dst_ops.kmem_cachep)
3093                 panic("IP: failed to allocate ip_dst_cache\n");
3094
3095         goal = num_physpages >> (26 - PAGE_SHIFT);
3096         if (rhash_entries)
3097                 goal = (rhash_entries * sizeof(struct rt_hash_bucket)) >> PAGE_SHIFT;
3098         for (order = 0; (1UL << order) < goal; order++)
3099                 /* NOTHING */;
3100
3101         do {
3102                 rt_hash_mask = (1UL << order) * PAGE_SIZE /
3103                         sizeof(struct rt_hash_bucket);
3104                 while (rt_hash_mask & (rt_hash_mask - 1))
3105                         rt_hash_mask--;
3106                 rt_hash_table = (struct rt_hash_bucket *)
3107                         __get_free_pages(GFP_ATOMIC, order);
3108         } while (rt_hash_table == NULL && --order > 0);
3109
3110         if (!rt_hash_table)
3111                 panic("Failed to allocate IP route cache hash table\n");
3112
3113         printk(KERN_INFO "IP: routing cache hash table of %u buckets, %ldKbytes\n",
3114                rt_hash_mask,
3115                (long) (rt_hash_mask * sizeof(struct rt_hash_bucket)) / 1024);
3116
3117         for (rt_hash_log = 0; (1 << rt_hash_log) != rt_hash_mask; rt_hash_log++)
3118                 /* NOTHING */;
3119
3120         rt_hash_mask--;
3121         for (i = 0; i <= rt_hash_mask; i++) {
3122                 spin_lock_init(&rt_hash_table[i].lock);
3123                 rt_hash_table[i].chain = NULL;
3124         }
3125
3126         ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1);
3127         ip_rt_max_size = (rt_hash_mask + 1) * 16;
3128
3129         rt_cache_stat = alloc_percpu(struct rt_cache_stat);
3130         if (!rt_cache_stat)
3131                 return -ENOMEM;
3132
3133         devinet_init();
3134         ip_fib_init();
3135
3136         init_timer(&rt_flush_timer);
3137         rt_flush_timer.function = rt_run_flush;
3138         init_timer(&rt_periodic_timer);
3139         rt_periodic_timer.function = rt_check_expire;
3140         init_timer(&rt_secret_timer);
3141         rt_secret_timer.function = rt_secret_rebuild;
3142
3143         /* All the timers, started at system startup tend
3144            to synchronize. Perturb it a bit.
3145          */
3146         rt_periodic_timer.expires = jiffies + net_random() % ip_rt_gc_interval +
3147                                         ip_rt_gc_interval;
3148         add_timer(&rt_periodic_timer);
3149
3150         rt_secret_timer.expires = jiffies + net_random() % ip_rt_secret_interval +
3151                 ip_rt_secret_interval;
3152         add_timer(&rt_secret_timer);
3153
3154 #ifdef CONFIG_PROC_FS
3155         {
3156         struct proc_dir_entry *rtstat_pde = NULL; /* keep gcc happy */
3157         if (!proc_net_fops_create("rt_cache", S_IRUGO, &rt_cache_seq_fops) ||
3158             !(rtstat_pde = create_proc_entry("rt_cache", S_IRUGO,
3159                                              proc_net_stat))) {
3160                 free_percpu(rt_cache_stat);
3161                 return -ENOMEM;
3162         }
3163         rtstat_pde->proc_fops = &rt_cpu_seq_fops;
3164         }
3165 #ifdef CONFIG_NET_CLS_ROUTE
3166         create_proc_read_entry("rt_acct", 0, proc_net, ip_rt_acct_read, NULL);
3167 #endif
3168 #endif
3169 #ifdef CONFIG_XFRM
3170         xfrm_init();
3171         xfrm4_init();
3172 #endif
3173         return rc;
3174 }
3175
3176 EXPORT_SYMBOL(__ip_select_ident);
3177 EXPORT_SYMBOL(ip_route_input);
3178 EXPORT_SYMBOL(ip_route_output_key);