ipv4: Cleanup struct net dereference in rt_intern_hash
[linux-2.6.git] / net / ipv4 / route.c
index ce25a13..124af16 100644 (file)
@@ -5,8 +5,6 @@
  *
  *             ROUTE - implementation of the IP router.
  *
- * Version:    $Id: route.c,v 1.103 2002/01/12 07:44:09 davem Exp $
- *
  * Authors:    Ross Biro
  *             Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  *             Alan Cox, <gw4pts@gw4pts.ampr.org>
@@ -131,10 +129,10 @@ static int ip_rt_mtu_expires __read_mostly        = 10 * 60 * HZ;
 static int ip_rt_min_pmtu __read_mostly                = 512 + 20 + 20;
 static int ip_rt_min_advmss __read_mostly      = 256;
 static int ip_rt_secret_interval __read_mostly = 10 * 60 * HZ;
+static int rt_chain_length_max __read_mostly   = 20;
 
-static void rt_worker_func(struct work_struct *work);
-static DECLARE_DELAYED_WORK(expires_work, rt_worker_func);
-static struct timer_list rt_secret_timer;
+static struct delayed_work expires_work;
+static unsigned long expires_ljiffies;
 
 /*
  *     Interface to generic destination cache.
@@ -152,7 +150,7 @@ static int rt_garbage_collect(struct dst_ops *ops);
 
 static struct dst_ops ipv4_dst_ops = {
        .family =               AF_INET,
-       .protocol =             __constant_htons(ETH_P_IP),
+       .protocol =             cpu_to_be16(ETH_P_IP),
        .gc =                   rt_garbage_collect,
        .check =                ipv4_dst_check,
        .destroy =              ipv4_dst_destroy,
@@ -160,8 +158,7 @@ static struct dst_ops ipv4_dst_ops = {
        .negative_advice =      ipv4_negative_advice,
        .link_failure =         ipv4_link_failure,
        .update_pmtu =          ip_rt_update_pmtu,
-       .local_out =            ip_local_out,
-       .entry_size =           sizeof(struct rtable),
+       .local_out =            __ip_local_out,
        .entries =              ATOMIC_INIT(0),
 };
 
@@ -204,6 +201,7 @@ const __u8 ip_tos2prio[16] = {
 struct rt_hash_bucket {
        struct rtable   *chain;
 };
+
 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) || \
        defined(CONFIG_PROVE_LOCKING)
 /*
@@ -253,20 +251,25 @@ static inline void rt_hash_lock_init(void)
 static struct rt_hash_bucket   *rt_hash_table __read_mostly;
 static unsigned                        rt_hash_mask __read_mostly;
 static unsigned int            rt_hash_log  __read_mostly;
-static atomic_t                        rt_genid __read_mostly;
 
 static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
 #define RT_CACHE_STAT_INC(field) \
        (__raw_get_cpu_var(rt_cache_stat).field++)
 
-static inline unsigned int rt_hash(__be32 daddr, __be32 saddr, int idx)
+static inline unsigned int rt_hash(__be32 daddr, __be32 saddr, int idx,
+               int genid)
 {
        return jhash_3words((__force u32)(__be32)(daddr),
                            (__force u32)(__be32)(saddr),
-                           idx, atomic_read(&rt_genid))
+                           idx, genid)
                & rt_hash_mask;
 }
 
+static inline int rt_genid(struct net *net)
+{
+       return atomic_read(&net->ipv4.rt_genid);
+}
+
 #ifdef CONFIG_PROC_FS
 struct rt_cache_iter_state {
        struct seq_net_private p;
@@ -280,13 +283,15 @@ static struct rtable *rt_cache_get_first(struct seq_file *seq)
        struct rtable *r = NULL;
 
        for (st->bucket = rt_hash_mask; st->bucket >= 0; --st->bucket) {
+               if (!rt_hash_table[st->bucket].chain)
+                       continue;
                rcu_read_lock_bh();
-               r = rcu_dereference(rt_hash_table[st->bucket].chain);
+               r = rcu_dereference_bh(rt_hash_table[st->bucket].chain);
                while (r) {
                        if (dev_net(r->u.dst.dev) == seq_file_net(seq) &&
                            r->rt_genid == st->genid)
                                return r;
-                       r = rcu_dereference(r->u.dst.rt_next);
+                       r = rcu_dereference_bh(r->u.dst.rt_next);
                }
                rcu_read_unlock_bh();
        }
@@ -297,15 +302,18 @@ static struct rtable *__rt_cache_get_next(struct seq_file *seq,
                                          struct rtable *r)
 {
        struct rt_cache_iter_state *st = seq->private;
+
        r = r->u.dst.rt_next;
        while (!r) {
                rcu_read_unlock_bh();
-               if (--st->bucket < 0)
-                       break;
+               do {
+                       if (--st->bucket < 0)
+                               return NULL;
+               } while (!rt_hash_table[st->bucket].chain);
                rcu_read_lock_bh();
                r = rt_hash_table[st->bucket].chain;
        }
-       return rcu_dereference(r);
+       return rcu_dereference_bh(r);
 }
 
 static struct rtable *rt_cache_get_next(struct seq_file *seq,
@@ -336,7 +344,7 @@ static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
        struct rt_cache_iter_state *st = seq->private;
        if (*pos)
                return rt_cache_get_idx(seq, *pos - 1);
-       st->genid = atomic_read(&rt_genid);
+       st->genid = rt_genid(seq_file_net(seq));
        return SEQ_START_TOKEN;
 }
 
@@ -420,7 +428,7 @@ static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
        if (*pos == 0)
                return SEQ_START_TOKEN;
 
-       for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
+       for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
                if (!cpu_possible(cpu))
                        continue;
                *pos = cpu+1;
@@ -433,7 +441,7 @@ static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
        int cpu;
 
-       for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
+       for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
                if (!cpu_possible(cpu))
                        continue;
                *pos = cpu+1;
@@ -504,43 +512,42 @@ static const struct file_operations rt_cpu_seq_fops = {
 };
 
 #ifdef CONFIG_NET_CLS_ROUTE
-static int ip_rt_acct_read(char *buffer, char **start, off_t offset,
-                          int length, int *eof, void *data)
-{
-       unsigned int i;
-
-       if ((offset & 3) || (length & 3))
-               return -EIO;
-
-       if (offset >= sizeof(struct ip_rt_acct) * 256) {
-               *eof = 1;
-               return 0;
-       }
-
-       if (offset + length >= sizeof(struct ip_rt_acct) * 256) {
-               length = sizeof(struct ip_rt_acct) * 256 - offset;
-               *eof = 1;
+static int rt_acct_proc_show(struct seq_file *m, void *v)
+{
+       struct ip_rt_acct *dst, *src;
+       unsigned int i, j;
+
+       dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
+       if (!dst)
+               return -ENOMEM;
+
+       for_each_possible_cpu(i) {
+               src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
+               for (j = 0; j < 256; j++) {
+                       dst[j].o_bytes   += src[j].o_bytes;
+                       dst[j].o_packets += src[j].o_packets;
+                       dst[j].i_bytes   += src[j].i_bytes;
+                       dst[j].i_packets += src[j].i_packets;
+               }
        }
 
-       offset /= sizeof(u32);
-
-       if (length > 0) {
-               u32 *dst = (u32 *) buffer;
-
-               *start = buffer;
-               memset(dst, 0, length);
-
-               for_each_possible_cpu(i) {
-                       unsigned int j;
-                       u32 *src;
+       seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
+       kfree(dst);
+       return 0;
+}
 
-                       src = ((u32 *) per_cpu_ptr(ip_rt_acct, i)) + offset;
-                       for (j = 0; j < length/4; j++)
-                               dst[j] += src[j];
-               }
-       }
-       return length;
+static int rt_acct_proc_open(struct inode *inode, struct file *file)
+{
+       return single_open(file, rt_acct_proc_show, NULL);
 }
+
+static const struct file_operations rt_acct_proc_fops = {
+       .owner          = THIS_MODULE,
+       .open           = rt_acct_proc_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
 #endif
 
 static int __net_init ip_rt_do_proc_init(struct net *net)
@@ -558,8 +565,7 @@ static int __net_init ip_rt_do_proc_init(struct net *net)
                goto err2;
 
 #ifdef CONFIG_NET_CLS_ROUTE
-       pde = create_proc_read_entry("rt_acct", 0, net->proc_net,
-                       ip_rt_acct_read, NULL);
+       pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
        if (!pde)
                goto err3;
 #endif
@@ -579,7 +585,9 @@ static void __net_exit ip_rt_do_proc_exit(struct net *net)
 {
        remove_proc_entry("rt_cache", net->proc_net_stat);
        remove_proc_entry("rt_cache", net->proc_net);
+#ifdef CONFIG_NET_CLS_ROUTE
        remove_proc_entry("rt_acct", net->proc_net);
+#endif
 }
 
 static struct pernet_operations ip_rt_proc_ops __net_initdata =  {
@@ -667,6 +675,20 @@ static inline u32 rt_score(struct rtable *rt)
        return score;
 }
 
+static inline bool rt_caching(const struct net *net)
+{
+       return net->ipv4.current_rt_cache_rebuild_count <=
+               net->ipv4.sysctl_rt_cache_rebuild_count;
+}
+
+static inline bool compare_hash_inputs(const struct flowi *fl1,
+                                       const struct flowi *fl2)
+{
+       return (__force u32)(((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
+               (fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr) |
+               (fl1->iif ^ fl2->iif)) == 0);
+}
+
 static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
 {
        return ((__force u32)((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
@@ -680,7 +702,12 @@ static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
 
 static inline int compare_netns(struct rtable *rt1, struct rtable *rt2)
 {
-       return dev_net(rt1->u.dst.dev) == dev_net(rt2->u.dst.dev);
+       return net_eq(dev_net(rt1->u.dst.dev), dev_net(rt2->u.dst.dev));
+}
+
+static inline int rt_is_expired(struct rtable *rth)
+{
+       return rth->rt_genid != rt_genid(dev_net(rth->u.dst.dev));
 }
 
 /*
@@ -692,6 +719,7 @@ static void rt_do_flush(int process_context)
 {
        unsigned int i;
        struct rtable *rth, *next;
+       struct rtable * tail;
 
        for (i = 0; i <= rt_hash_mask; i++) {
                if (process_context && need_resched())
@@ -701,25 +729,88 @@ static void rt_do_flush(int process_context)
                        continue;
 
                spin_lock_bh(rt_hash_lock_addr(i));
+#ifdef CONFIG_NET_NS
+               {
+               struct rtable ** prev, * p;
+
+               rth = rt_hash_table[i].chain;
+
+               /* defer releasing the head of the list after spin_unlock */
+               for (tail = rth; tail; tail = tail->u.dst.rt_next)
+                       if (!rt_is_expired(tail))
+                               break;
+               if (rth != tail)
+                       rt_hash_table[i].chain = tail;
+
+               /* call rt_free on entries after the tail requiring flush */
+               prev = &rt_hash_table[i].chain;
+               for (p = *prev; p; p = next) {
+                       next = p->u.dst.rt_next;
+                       if (!rt_is_expired(p)) {
+                               prev = &p->u.dst.rt_next;
+                       } else {
+                               *prev = next;
+                               rt_free(p);
+                       }
+               }
+               }
+#else
                rth = rt_hash_table[i].chain;
                rt_hash_table[i].chain = NULL;
+               tail = NULL;
+#endif
                spin_unlock_bh(rt_hash_lock_addr(i));
 
-               for (; rth; rth = next) {
+               for (; rth != tail; rth = next) {
                        next = rth->u.dst.rt_next;
                        rt_free(rth);
                }
        }
 }
 
+/*
+ * While freeing expired entries, we compute average chain length
+ * and standard deviation, using fixed-point arithmetic.
+ * This to have an estimation of rt_chain_length_max
+ *  rt_chain_length_max = max(elasticity, AVG + 4*SD)
+ * We use 3 bits for frational part, and 29 (or 61) for magnitude.
+ */
+
+#define FRACT_BITS 3
+#define ONE (1UL << FRACT_BITS)
+
+/*
+ * Given a hash chain and an item in this hash chain,
+ * find if a previous entry has the same hash_inputs
+ * (but differs on tos, mark or oif)
+ * Returns 0 if an alias is found.
+ * Returns ONE if rth has no alias before itself.
+ */
+static int has_noalias(const struct rtable *head, const struct rtable *rth)
+{
+       const struct rtable *aux = head;
+
+       while (aux != rth) {
+               if (compare_hash_inputs(&aux->fl, &rth->fl))
+                       return 0;
+               aux = aux->u.dst.rt_next;
+       }
+       return ONE;
+}
+
 static void rt_check_expire(void)
 {
        static unsigned int rover;
        unsigned int i = rover, goal;
        struct rtable *rth, **rthp;
+       unsigned long samples = 0;
+       unsigned long sum = 0, sum2 = 0;
+       unsigned long delta;
        u64 mult;
 
-       mult = ((u64)ip_rt_gc_interval) << rt_hash_log;
+       delta = jiffies - expires_ljiffies;
+       expires_ljiffies = jiffies;
+       mult = ((u64)delta) << rt_hash_log;
        if (ip_rt_gc_timeout > 1)
                do_div(mult, ip_rt_gc_timeout);
        goal = (unsigned int)mult;
@@ -727,6 +818,7 @@ static void rt_check_expire(void)
                goal = rt_hash_mask + 1;
        for (; goal > 0; goal--) {
                unsigned long tmo = ip_rt_gc_timeout;
+               unsigned long length;
 
                i = (i + 1) & rt_hash_mask;
                rthp = &rt_hash_table[i].chain;
@@ -734,11 +826,15 @@ static void rt_check_expire(void)
                if (need_resched())
                        cond_resched();
 
+               samples++;
+
                if (*rthp == NULL)
                        continue;
+               length = 0;
                spin_lock_bh(rt_hash_lock_addr(i));
                while ((rth = *rthp) != NULL) {
-                       if (rth->rt_genid != atomic_read(&rt_genid)) {
+                       prefetch(rth->u.dst.rt_next);
+                       if (rt_is_expired(rth)) {
                                *rthp = rth->u.dst.rt_next;
                                rt_free(rth);
                                continue;
@@ -746,21 +842,37 @@ static void rt_check_expire(void)
                        if (rth->u.dst.expires) {
                                /* Entry is expired even if it is in use */
                                if (time_before_eq(jiffies, rth->u.dst.expires)) {
+nofree:
                                        tmo >>= 1;
                                        rthp = &rth->u.dst.rt_next;
+                                       /*
+                                        * We only count entries on
+                                        * a chain with equal hash inputs once
+                                        * so that entries for different QOS
+                                        * levels, and other non-hash input
+                                        * attributes don't unfairly skew
+                                        * the length computation
+                                        */
+                                       length += has_noalias(rt_hash_table[i].chain, rth);
                                        continue;
                                }
-                       } else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout)) {
-                               tmo >>= 1;
-                               rthp = &rth->u.dst.rt_next;
-                               continue;
-                       }
+                       } else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout))
+                               goto nofree;
 
                        /* Cleanup aged off entries. */
                        *rthp = rth->u.dst.rt_next;
                        rt_free(rth);
                }
                spin_unlock_bh(rt_hash_lock_addr(i));
+               sum += length;
+               sum2 += length*length;
+       }
+       if (samples) {
+               unsigned long avg = sum / samples;
+               unsigned long sd = int_sqrt(sum2 / samples - avg*avg);
+               rt_chain_length_max = max_t(unsigned long,
+                                       ip_rt_gc_elasticity,
+                                       (avg + 4*sd) >> FRACT_BITS);
        }
        rover = i;
 }
@@ -781,32 +893,57 @@ static void rt_worker_func(struct work_struct *work)
  * many times (2^24) without giving recent rt_genid.
  * Jenkins hash is strong enough that litle changes of rt_genid are OK.
  */
-static void rt_cache_invalidate(void)
+static void rt_cache_invalidate(struct net *net)
 {
        unsigned char shuffle;
 
        get_random_bytes(&shuffle, sizeof(shuffle));
-       atomic_add(shuffle + 1U, &rt_genid);
+       atomic_add(shuffle + 1U, &net->ipv4.rt_genid);
 }
 
 /*
  * delay < 0  : invalidate cache (fast : entries will be deleted later)
  * delay >= 0 : invalidate & flush cache (can be long)
  */
-void rt_cache_flush(int delay)
+void rt_cache_flush(struct net *net, int delay)
 {
-       rt_cache_invalidate();
+       rt_cache_invalidate(net);
        if (delay >= 0)
                rt_do_flush(!in_softirq());
 }
 
+/* Flush previous cache invalidated entries from the cache */
+void rt_cache_flush_batch(void)
+{
+       rt_do_flush(!in_softirq());
+}
+
 /*
  * We change rt_genid and let gc do the cleanup
  */
-static void rt_secret_rebuild(unsigned long dummy)
+static void rt_secret_rebuild(unsigned long __net)
 {
-       rt_cache_invalidate();
-       mod_timer(&rt_secret_timer, jiffies + ip_rt_secret_interval);
+       struct net *net = (struct net *)__net;
+       rt_cache_invalidate(net);
+       mod_timer(&net->ipv4.rt_secret_timer, jiffies + ip_rt_secret_interval);
+}
+
+static void rt_secret_rebuild_oneshot(struct net *net)
+{
+       del_timer_sync(&net->ipv4.rt_secret_timer);
+       rt_cache_invalidate(net);
+       if (ip_rt_secret_interval)
+               mod_timer(&net->ipv4.rt_secret_timer, jiffies + ip_rt_secret_interval);
+}
+
+static void rt_emergency_hash_rebuild(struct net *net)
+{
+       if (net_ratelimit()) {
+               printk(KERN_WARNING "Route hash chain too long!\n");
+               printk(KERN_WARNING "Adjust your secret_interval!\n");
+       }
+
+       rt_secret_rebuild_oneshot(net);
 }
 
 /*
@@ -882,7 +1019,7 @@ static int rt_garbage_collect(struct dst_ops *ops)
                        rthp = &rt_hash_table[k].chain;
                        spin_lock_bh(rt_hash_lock_addr(k));
                        while ((rth = *rthp) != NULL) {
-                               if (rth->rt_genid == atomic_read(&rt_genid) &&
+                               if (!rt_is_expired(rth) &&
                                        !rt_may_expire(rth, tmo, expire)) {
                                        tmo >>= 1;
                                        rthp = &rth->u.dst.rt_next;
@@ -944,7 +1081,23 @@ work_done:
 out:   return 0;
 }
 
-static int rt_intern_hash(unsigned hash, struct rtable *rt, struct rtable **rp)
+/*
+ * Returns number of entries in a hash chain that have different hash_inputs
+ */
+static int slow_chain_length(const struct rtable *head)
+{
+       int length = 0;
+       const struct rtable *rth = head;
+
+       while (rth) {
+               length += has_noalias(head, rth);
+               rth = rth->u.dst.rt_next;
+       }
+       return length >> FRACT_BITS;
+}
+
+static int rt_intern_hash(unsigned hash, struct rtable *rt,
+                         struct rtable **rp, struct sk_buff *skb)
 {
        struct rtable   *rth, **rthp;
        unsigned long   now;
@@ -960,11 +1113,43 @@ restart:
        candp = NULL;
        now = jiffies;
 
+       if (!rt_caching(dev_net(rt->u.dst.dev))) {
+               /*
+                * If we're not caching, just tell the caller we
+                * were successful and don't touch the route.  The
+                * caller hold the sole reference to the cache entry, and
+                * it will be released when the caller is done with it.
+                * If we drop it here, the callers have no way to resolve routes
+                * when we're not caching.  Instead, just point *rp at rt, so
+                * the caller gets a single use out of the route
+                * Note that we do rt_free on this new route entry, so that
+                * once its refcount hits zero, we are still able to reap it
+                * (Thanks Alexey)
+                * Note also the rt_free uses call_rcu.  We don't actually
+                * need rcu protection here, this is just our path to get
+                * on the route gc list.
+                */
+
+               if (rt->rt_type == RTN_UNICAST || rt->fl.iif == 0) {
+                       int err = arp_bind_neighbour(&rt->u.dst);
+                       if (err) {
+                               if (net_ratelimit())
+                                       printk(KERN_WARNING
+                                           "Neighbour table failure & not caching routes.\n");
+                               rt_drop(rt);
+                               return err;
+                       }
+               }
+
+               rt_free(rt);
+               goto skip_hashing;
+       }
+
        rthp = &rt_hash_table[hash].chain;
 
        spin_lock_bh(rt_hash_lock_addr(hash));
        while ((rth = *rthp) != NULL) {
-               if (rth->rt_genid != atomic_read(&rt_genid)) {
+               if (rt_is_expired(rth)) {
                        *rthp = rth->u.dst.rt_next;
                        rt_free(rth);
                        continue;
@@ -989,7 +1174,10 @@ restart:
                        spin_unlock_bh(rt_hash_lock_addr(hash));
 
                        rt_drop(rt);
-                       *rp = rth;
+                       if (rp)
+                               *rp = rth;
+                       else
+                               skb_dst_set(skb, &rth->u.dst);
                        return 0;
                }
 
@@ -1019,6 +1207,17 @@ restart:
                        *candp = cand->u.dst.rt_next;
                        rt_free(cand);
                }
+       } else {
+               if (chain_length > rt_chain_length_max &&
+                   slow_chain_length(rt_hash_table[hash].chain) > rt_chain_length_max) {
+                       struct net *net = dev_net(rt->u.dst.dev);
+                       int num = ++net->ipv4.current_rt_cache_rebuild_count;
+                       if (!rt_caching(net)) {
+                               printk(KERN_WARNING "%s: %d rebuilds is over limit, route caching disabled\n",
+                                       rt->u.dst.dev->name, num);
+                       }
+                       rt_emergency_hash_rebuild(net);
+               }
        }
 
        /* Try to bind route to arp only if it is output
@@ -1057,19 +1256,31 @@ restart:
        }
 
        rt->u.dst.rt_next = rt_hash_table[hash].chain;
+
 #if RT_CACHE_DEBUG >= 2
        if (rt->u.dst.rt_next) {
                struct rtable *trt;
-               printk(KERN_DEBUG "rt_cache @%02x: " NIPQUAD_FMT, hash,
-                      NIPQUAD(rt->rt_dst));
+               printk(KERN_DEBUG "rt_cache @%02x: %pI4",
+                      hash, &rt->rt_dst);
                for (trt = rt->u.dst.rt_next; trt; trt = trt->u.dst.rt_next)
-                       printk(" . " NIPQUAD_FMT, NIPQUAD(trt->rt_dst));
+                       printk(" . %pI4", &trt->rt_dst);
                printk("\n");
        }
 #endif
-       rt_hash_table[hash].chain = rt;
+       /*
+        * Since lookup is lockfree, we must make sure
+        * previous writes to rt are comitted to memory
+        * before making rt visible to other CPUS.
+        */
+       rcu_assign_pointer(rt_hash_table[hash].chain, rt);
+
        spin_unlock_bh(rt_hash_lock_addr(hash));
-       *rp = rt;
+
+skip_hashing:
+       if (rp)
+               *rp = rt;
+       else
+               skb_dst_set(skb, &rt->u.dst);
        return 0;
 }
 
@@ -1140,7 +1351,7 @@ static void rt_del(unsigned hash, struct rtable *rt)
        spin_lock_bh(rt_hash_lock_addr(hash));
        ip_rt_put(rt);
        while ((aux = *rthp) != NULL) {
-               if (aux == rt || (aux->rt_genid != atomic_read(&rt_genid))) {
+               if (aux == rt || rt_is_expired(aux)) {
                        *rthp = aux->u.dst.rt_next;
                        rt_free(aux);
                        continue;
@@ -1165,9 +1376,12 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
                return;
 
        net = dev_net(dev);
-       if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev)
-           || ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw)
-           || ipv4_is_zeronet(new_gw))
+       if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
+           ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
+           ipv4_is_zeronet(new_gw))
+               goto reject_redirect;
+
+       if (!rt_caching(net))
                goto reject_redirect;
 
        if (!IN_DEV_SHARED_MEDIA(in_dev)) {
@@ -1182,7 +1396,8 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
 
        for (i = 0; i < 2; i++) {
                for (k = 0; k < 2; k++) {
-                       unsigned hash = rt_hash(daddr, skeys[i], ikeys[k]);
+                       unsigned hash = rt_hash(daddr, skeys[i], ikeys[k],
+                                               rt_genid(net));
 
                        rthp=&rt_hash_table[hash].chain;
 
@@ -1194,7 +1409,7 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
                                    rth->fl.fl4_src != skeys[i] ||
                                    rth->fl.oif != ikeys[k] ||
                                    rth->fl.iif != 0 ||
-                                   rth->rt_genid != atomic_read(&rt_genid) ||
+                                   rt_is_expired(rth) ||
                                    !net_eq(dev_net(rth->u.dst.dev), net)) {
                                        rthp = &rth->u.dst.rt_next;
                                        continue;
@@ -1219,7 +1434,6 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
 
                                /* Copy all the information. */
                                *rt = *rth;
-                               INIT_RCU_HEAD(&rt->u.dst.rcu_head);
                                rt->u.dst.__use         = 1;
                                atomic_set(&rt->u.dst.__refcnt, 1);
                                rt->u.dst.child         = NULL;
@@ -1227,13 +1441,15 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
                                        dev_hold(rt->u.dst.dev);
                                if (rt->idev)
                                        in_dev_hold(rt->idev);
-                               rt->u.dst.obsolete      = 0;
+                               rt->u.dst.obsolete      = -1;
                                rt->u.dst.lastuse       = jiffies;
                                rt->u.dst.path          = &rt->u.dst;
                                rt->u.dst.neighbour     = NULL;
                                rt->u.dst.hh            = NULL;
+#ifdef CONFIG_XFRM
                                rt->u.dst.xfrm          = NULL;
-                               rt->rt_genid            = atomic_read(&rt_genid);
+#endif
+                               rt->rt_genid            = rt_genid(net);
                                rt->rt_flags            |= RTCF_REDIRECTED;
 
                                /* Gateway is different ... */
@@ -1261,7 +1477,7 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
                                                        &netevent);
 
                                rt_del(hash, rth);
-                               if (!rt_intern_hash(hash, rt, &rt))
+                               if (!rt_intern_hash(hash, rt, &rt, NULL))
                                        ip_rt_put(rt);
                                goto do_next;
                        }
@@ -1276,11 +1492,10 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
 reject_redirect:
 #ifdef CONFIG_IP_ROUTE_VERBOSE
        if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
-               printk(KERN_INFO "Redirect from " NIPQUAD_FMT " on %s about "
-                       NIPQUAD_FMT " ignored.\n"
-                       "  Advised path = " NIPQUAD_FMT " -> " NIPQUAD_FMT "\n",
-                      NIPQUAD(old_gw), dev->name, NIPQUAD(new_gw),
-                      NIPQUAD(saddr), NIPQUAD(daddr));
+               printk(KERN_INFO "Redirect from %pI4 on %s about %pI4 ignored.\n"
+                       "  Advised path = %pI4 -> %pI4\n",
+                      &old_gw, dev->name, &new_gw,
+                      &saddr, &daddr);
 #endif
        in_dev_put(in_dev);
 }
@@ -1291,17 +1506,18 @@ static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
        struct dst_entry *ret = dst;
 
        if (rt) {
-               if (dst->obsolete) {
+               if (dst->obsolete > 0) {
                        ip_rt_put(rt);
                        ret = NULL;
                } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
-                          rt->u.dst.expires) {
+                          (rt->u.dst.expires &&
+                           time_after_eq(jiffies, rt->u.dst.expires))) {
                        unsigned hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src,
-                                               rt->fl.oif);
+                                               rt->fl.oif,
+                                               rt_genid(dev_net(dst->dev)));
 #if RT_CACHE_DEBUG >= 1
-                       printk(KERN_DEBUG "ipv4_negative_advice: redirect to "
-                                         NIPQUAD_FMT "/%02x dropped\n",
-                               NIPQUAD(rt->rt_dst), rt->fl.fl4_tos);
+                       printk(KERN_DEBUG "ipv4_negative_advice: redirect to %pI4/%02x dropped\n",
+                               &rt->rt_dst, rt->fl.fl4_tos);
 #endif
                        rt_del(hash, rt);
                        ret = NULL;
@@ -1328,14 +1544,18 @@ static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
 
 void ip_rt_send_redirect(struct sk_buff *skb)
 {
-       struct rtable *rt = skb->rtable;
-       struct in_device *in_dev = in_dev_get(rt->u.dst.dev);
+       struct rtable *rt = skb_rtable(skb);
+       struct in_device *in_dev;
+       int log_martians;
 
-       if (!in_dev)
+       rcu_read_lock();
+       in_dev = __in_dev_get_rcu(rt->u.dst.dev);
+       if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
+               rcu_read_unlock();
                return;
-
-       if (!IN_DEV_TX_REDIRECTS(in_dev))
-               goto out;
+       }
+       log_martians = IN_DEV_LOG_MARTIANS(in_dev);
+       rcu_read_unlock();
 
        /* No redirected packets during ip_rt_redirect_silence;
         * reset the algorithm.
@@ -1348,7 +1568,7 @@ void ip_rt_send_redirect(struct sk_buff *skb)
         */
        if (rt->u.dst.rate_tokens >= ip_rt_redirect_number) {
                rt->u.dst.rate_last = jiffies;
-               goto out;
+               return;
        }
 
        /* Check for load limit; set rate_last to the latest sent
@@ -1362,22 +1582,19 @@ void ip_rt_send_redirect(struct sk_buff *skb)
                rt->u.dst.rate_last = jiffies;
                ++rt->u.dst.rate_tokens;
 #ifdef CONFIG_IP_ROUTE_VERBOSE
-               if (IN_DEV_LOG_MARTIANS(in_dev) &&
+               if (log_martians &&
                    rt->u.dst.rate_tokens == ip_rt_redirect_number &&
                    net_ratelimit())
-                       printk(KERN_WARNING "host " NIPQUAD_FMT "/if%d ignores "
-                               "redirects for " NIPQUAD_FMT " to " NIPQUAD_FMT ".\n",
-                               NIPQUAD(rt->rt_src), rt->rt_iif,
-                               NIPQUAD(rt->rt_dst), NIPQUAD(rt->rt_gateway));
+                       printk(KERN_WARNING "host %pI4/if%d ignores redirects for %pI4 to %pI4.\n",
+                               &rt->rt_src, rt->rt_iif,
+                               &rt->rt_dst, &rt->rt_gateway);
 #endif
        }
-out:
-       in_dev_put(in_dev);
 }
 
 static int ip_error(struct sk_buff *skb)
 {
-       struct rtable *rt = skb->rtable;
+       struct rtable *rt = skb_rtable(skb);
        unsigned long now;
        int code;
 
@@ -1390,7 +1607,8 @@ static int ip_error(struct sk_buff *skb)
                        break;
                case ENETUNREACH:
                        code = ICMP_NET_UNREACH;
-                       IP_INC_STATS_BH(IPSTATS_MIB_INNOROUTES);
+                       IP_INC_STATS_BH(dev_net(rt->u.dst.dev),
+                                       IPSTATS_MIB_INNOROUTES);
                        break;
                case EACCES:
                        code = ICMP_PKT_FILTERED;
@@ -1430,46 +1648,50 @@ static inline unsigned short guess_mtu(unsigned short old_mtu)
 }
 
 unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
-                                unsigned short new_mtu)
+                                unsigned short new_mtu,
+                                struct net_device *dev)
 {
-       int i;
+       int i, k;
        unsigned short old_mtu = ntohs(iph->tot_len);
        struct rtable *rth;
+       int  ikeys[2] = { dev->ifindex, 0 };
        __be32  skeys[2] = { iph->saddr, 0, };
        __be32  daddr = iph->daddr;
        unsigned short est_mtu = 0;
 
-       if (ipv4_config.no_pmtu_disc)
-               return 0;
-
-       for (i = 0; i < 2; i++) {
-               unsigned hash = rt_hash(daddr, skeys[i], 0);
+       for (k = 0; k < 2; k++) {
+               for (i = 0; i < 2; i++) {
+                       unsigned hash = rt_hash(daddr, skeys[i], ikeys[k],
+                                               rt_genid(net));
 
-               rcu_read_lock();
-               for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
-                    rth = rcu_dereference(rth->u.dst.rt_next)) {
-                       if (rth->fl.fl4_dst == daddr &&
-                           rth->fl.fl4_src == skeys[i] &&
-                           rth->rt_dst  == daddr &&
-                           rth->rt_src  == iph->saddr &&
-                           rth->fl.iif == 0 &&
-                           !(dst_metric_locked(&rth->u.dst, RTAX_MTU)) &&
-                           net_eq(dev_net(rth->u.dst.dev), net) &&
-                           rth->rt_genid == atomic_read(&rt_genid)) {
+                       rcu_read_lock();
+                       for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
+                            rth = rcu_dereference(rth->u.dst.rt_next)) {
                                unsigned short mtu = new_mtu;
 
+                               if (rth->fl.fl4_dst != daddr ||
+                                   rth->fl.fl4_src != skeys[i] ||
+                                   rth->rt_dst != daddr ||
+                                   rth->rt_src != iph->saddr ||
+                                   rth->fl.oif != ikeys[k] ||
+                                   rth->fl.iif != 0 ||
+                                   dst_metric_locked(&rth->u.dst, RTAX_MTU) ||
+                                   !net_eq(dev_net(rth->u.dst.dev), net) ||
+                                   rt_is_expired(rth))
+                                       continue;
+
                                if (new_mtu < 68 || new_mtu >= old_mtu) {
 
                                        /* BSD 4.2 compatibility hack :-( */
                                        if (mtu == 0 &&
-                                           old_mtu >= rth->u.dst.metrics[RTAX_MTU-1] &&
+                                           old_mtu >= dst_mtu(&rth->u.dst) &&
                                            old_mtu >= 68 + (iph->ihl << 2))
                                                old_mtu -= iph->ihl << 2;
 
                                        mtu = guess_mtu(old_mtu);
                                }
-                               if (mtu <= rth->u.dst.metrics[RTAX_MTU-1]) {
-                                       if (mtu < rth->u.dst.metrics[RTAX_MTU-1]) {
+                               if (mtu <= dst_mtu(&rth->u.dst)) {
+                                       if (mtu < dst_mtu(&rth->u.dst)) {
                                                dst_confirm(&rth->u.dst);
                                                if (mtu < ip_rt_min_pmtu) {
                                                        mtu = ip_rt_min_pmtu;
@@ -1483,15 +1705,15 @@ unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
                                        est_mtu = mtu;
                                }
                        }
+                       rcu_read_unlock();
                }
-               rcu_read_unlock();
        }
        return est_mtu ? : new_mtu;
 }
 
 static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
 {
-       if (dst->metrics[RTAX_MTU-1] > mtu && mtu >= 68 &&
+       if (dst_mtu(dst) > mtu && mtu >= 68 &&
            !(dst_metric_locked(dst, RTAX_MTU))) {
                if (mtu < ip_rt_min_pmtu) {
                        mtu = ip_rt_min_pmtu;
@@ -1505,7 +1727,9 @@ static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
 
 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
 {
-       return NULL;
+       if (rt_is_expired((struct rtable *)dst))
+               return NULL;
+       return dst;
 }
 
 static void ipv4_dst_destroy(struct dst_entry *dst)
@@ -1546,15 +1770,15 @@ static void ipv4_link_failure(struct sk_buff *skb)
 
        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
 
-       rt = skb->rtable;
+       rt = skb_rtable(skb);
        if (rt)
                dst_set_expires(&rt->u.dst, 0);
 }
 
 static int ip_rt_bug(struct sk_buff *skb)
 {
-       printk(KERN_DEBUG "ip_rt_bug: " NIPQUAD_FMT " -> " NIPQUAD_FMT ", %s\n",
-               NIPQUAD(ip_hdr(skb)->saddr), NIPQUAD(ip_hdr(skb)->daddr),
+       printk(KERN_DEBUG "ip_rt_bug: %pI4 -> %pI4, %s\n",
+               &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
                skb->dev ? skb->dev->name : "?");
        kfree_skb(skb);
        return 0;
@@ -1607,7 +1831,7 @@ static void rt_set_nexthop(struct rtable *rt, struct fib_result *res, u32 itag)
                       sizeof(rt->u.dst.metrics));
                if (fi->fib_mtu == 0) {
                        rt->u.dst.metrics[RTAX_MTU-1] = rt->u.dst.dev->mtu;
-                       if (rt->u.dst.metrics[RTAX_LOCK-1] & (1 << RTAX_MTU) &&
+                       if (dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
                            rt->rt_gateway != rt->rt_dst &&
                            rt->u.dst.dev->mtu > 576)
                                rt->u.dst.metrics[RTAX_MTU-1] = 576;
@@ -1618,14 +1842,14 @@ static void rt_set_nexthop(struct rtable *rt, struct fib_result *res, u32 itag)
        } else
                rt->u.dst.metrics[RTAX_MTU-1]= rt->u.dst.dev->mtu;
 
-       if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
+       if (dst_metric(&rt->u.dst, RTAX_HOPLIMIT) == 0)
                rt->u.dst.metrics[RTAX_HOPLIMIT-1] = sysctl_ip_default_ttl;
-       if (rt->u.dst.metrics[RTAX_MTU-1] > IP_MAX_MTU)
+       if (dst_mtu(&rt->u.dst) > IP_MAX_MTU)
                rt->u.dst.metrics[RTAX_MTU-1] = IP_MAX_MTU;
-       if (rt->u.dst.metrics[RTAX_ADVMSS-1] == 0)
+       if (dst_metric(&rt->u.dst, RTAX_ADVMSS) == 0)
                rt->u.dst.metrics[RTAX_ADVMSS-1] = max_t(unsigned int, rt->u.dst.dev->mtu - 40,
                                       ip_rt_min_advmss);
-       if (rt->u.dst.metrics[RTAX_ADVMSS-1] > 65535 - 40)
+       if (dst_metric(&rt->u.dst, RTAX_ADVMSS) > 65535 - 40)
                rt->u.dst.metrics[RTAX_ADVMSS-1] = 65535 - 40;
 
 #ifdef CONFIG_NET_CLS_ROUTE
@@ -1660,14 +1884,15 @@ static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                        goto e_inval;
                spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
        } else if (fib_validate_source(saddr, 0, tos, 0,
-                                       dev, &spec_dst, &itag) < 0)
+                                       dev, &spec_dst, &itag, 0) < 0)
                goto e_inval;
 
        rth = dst_alloc(&ipv4_dst_ops);
        if (!rth)
                goto e_nobufs;
 
-       rth->u.dst.output= ip_rt_bug;
+       rth->u.dst.output = ip_rt_bug;
+       rth->u.dst.obsolete = -1;
 
        atomic_set(&rth->u.dst.__refcnt, 1);
        rth->u.dst.flags= DST_HOST;
@@ -1690,7 +1915,7 @@ static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
        rth->fl.oif     = 0;
        rth->rt_gateway = daddr;
        rth->rt_spec_dst= spec_dst;
-       rth->rt_genid   = atomic_read(&rt_genid);
+       rth->rt_genid   = rt_genid(dev_net(dev));
        rth->rt_flags   = RTCF_MULTICAST;
        rth->rt_type    = RTN_MULTICAST;
        if (our) {
@@ -1705,8 +1930,8 @@ static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
        RT_CACHE_STAT_INC(in_slow_mc);
 
        in_dev_put(in_dev);
-       hash = rt_hash(daddr, saddr, dev->ifindex);
-       return rt_intern_hash(hash, rth, &skb->rtable);
+       hash = rt_hash(daddr, saddr, dev->ifindex, rt_genid(dev_net(dev)));
+       return rt_intern_hash(hash, rth, NULL, skb);
 
 e_nobufs:
        in_dev_put(in_dev);
@@ -1731,9 +1956,8 @@ static void ip_handle_martian_source(struct net_device *dev,
                 *      RFC1812 recommendation, if source is martian,
                 *      the only hint is MAC header.
                 */
-               printk(KERN_WARNING "martian source " NIPQUAD_FMT " from "
-                       NIPQUAD_FMT", on dev %s\n",
-                       NIPQUAD(daddr), NIPQUAD(saddr), dev->name);
+               printk(KERN_WARNING "martian source %pI4 from %pI4, on dev %s\n",
+                       &daddr, &saddr, dev->name);
                if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
                        int i;
                        const unsigned char *p = skb_mac_header(skb);
@@ -1774,7 +1998,7 @@ static int __mkroute_input(struct sk_buff *skb,
 
 
        err = fib_validate_source(saddr, daddr, tos, FIB_RES_OIF(*res),
-                                 in_dev->dev, &spec_dst, &itag);
+                                 in_dev->dev, &spec_dst, &itag, skb->mark);
        if (err < 0) {
                ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
                                         saddr);
@@ -1786,7 +2010,7 @@ static int __mkroute_input(struct sk_buff *skb,
        if (err)
                flags |= RTCF_DIRECTSRC;
 
-       if (out_dev == in_dev && err && !(flags & RTCF_MASQ) &&
+       if (out_dev == in_dev && err &&
            (IN_DEV_SHARED_MEDIA(out_dev) ||
             inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
                flags |= RTCF_DOREDIRECT;
@@ -1794,8 +2018,13 @@ static int __mkroute_input(struct sk_buff *skb,
        if (skb->protocol != htons(ETH_P_IP)) {
                /* Not IP (i.e. ARP). Do not create route, if it is
                 * invalid for proxy arp. DNAT routes are always valid.
+                *
+                * Proxy arp feature have been extended to allow, ARP
+                * replies back to the same interface, to support
+                * Private VLAN switch technologies. See arp.c.
                 */
-               if (out_dev == in_dev) {
+               if (out_dev == in_dev &&
+                   IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
                        err = -EINVAL;
                        goto cleanup;
                }
@@ -1829,9 +2058,10 @@ static int __mkroute_input(struct sk_buff *skb,
        rth->fl.oif     = 0;
        rth->rt_spec_dst= spec_dst;
 
+       rth->u.dst.obsolete = -1;
        rth->u.dst.input = ip_forward;
        rth->u.dst.output = ip_output;
-       rth->rt_genid = atomic_read(&rt_genid);
+       rth->rt_genid = rt_genid(dev_net(rth->u.dst.dev));
 
        rt_set_nexthop(rth, res, itag);
 
@@ -1866,8 +2096,9 @@ static int ip_mkroute_input(struct sk_buff *skb,
                return err;
 
        /* put it into the cache */
-       hash = rt_hash(daddr, saddr, fl->iif);
-       return rt_intern_hash(hash, rth, &skb->rtable);
+       hash = rt_hash(daddr, saddr, fl->iif,
+                      rt_genid(dev_net(rth->u.dst.dev)));
+       return rt_intern_hash(hash, rth, NULL, skb);
 }
 
 /*
@@ -1947,7 +2178,7 @@ static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                int result;
                result = fib_validate_source(saddr, daddr, tos,
                                             net->loopback_dev->ifindex,
-                                            dev, &spec_dst, &itag);
+                                            dev, &spec_dst, &itag, skb->mark);
                if (result < 0)
                        goto martian_source;
                if (result)
@@ -1976,7 +2207,7 @@ brd_input:
                spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
        else {
                err = fib_validate_source(saddr, 0, tos, 0, dev, &spec_dst,
-                                         &itag);
+                                         &itag, skb->mark);
                if (err < 0)
                        goto martian_source;
                if (err)
@@ -1992,7 +2223,8 @@ local_input:
                goto e_nobufs;
 
        rth->u.dst.output= ip_rt_bug;
-       rth->rt_genid = atomic_read(&rt_genid);
+       rth->u.dst.obsolete = -1;
+       rth->rt_genid = rt_genid(net);
 
        atomic_set(&rth->u.dst.__refcnt, 1);
        rth->u.dst.flags= DST_HOST;
@@ -2022,8 +2254,8 @@ local_input:
                rth->rt_flags   &= ~RTCF_LOCAL;
        }
        rth->rt_type    = res.type;
-       hash = rt_hash(daddr, saddr, fl.iif);
-       err = rt_intern_hash(hash, rth, &skb->rtable);
+       hash = rt_hash(daddr, saddr, fl.iif, rt_genid(net));
+       err = rt_intern_hash(hash, rth, NULL, skb);
        goto done;
 
 no_route:
@@ -2041,9 +2273,8 @@ martian_destination:
        RT_CACHE_STAT_INC(in_martian_dst);
 #ifdef CONFIG_IP_ROUTE_VERBOSE
        if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
-               printk(KERN_WARNING "martian destination " NIPQUAD_FMT " from "
-                       NIPQUAD_FMT ", dev %s\n",
-                       NIPQUAD(daddr), NIPQUAD(saddr), dev->name);
+               printk(KERN_WARNING "martian destination %pI4 from %pI4, dev %s\n",
+                       &daddr, &saddr, dev->name);
 #endif
 
 e_hostunreach:
@@ -2072,8 +2303,12 @@ int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
        struct net *net;
 
        net = dev_net(dev);
+
+       if (!rt_caching(net))
+               goto skip_cache;
+
        tos &= IPTOS_RT_MASK;
-       hash = rt_hash(daddr, saddr, iif);
+       hash = rt_hash(daddr, saddr, iif, rt_genid(net));
 
        rcu_read_lock();
        for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
@@ -2085,17 +2320,18 @@ int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                     (rth->fl.fl4_tos ^ tos)) == 0 &&
                    rth->fl.mark == skb->mark &&
                    net_eq(dev_net(rth->u.dst.dev), net) &&
-                   rth->rt_genid == atomic_read(&rt_genid)) {
+                   !rt_is_expired(rth)) {
                        dst_use(&rth->u.dst, jiffies);
                        RT_CACHE_STAT_INC(in_hit);
                        rcu_read_unlock();
-                       skb->rtable = rth;
+                       skb_dst_set(skb, &rth->u.dst);
                        return 0;
                }
                RT_CACHE_STAT_INC(in_hlist_search);
        }
        rcu_read_unlock();
 
+skip_cache:
        /* Multicast recognition logic is moved from route cache to here.
           The problem was that too many Ethernet cards have broken/missing
           hardware multicast filters :-( As result the host on multicasting
@@ -2116,10 +2352,11 @@ int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                                ip_hdr(skb)->protocol);
                        if (our
 #ifdef CONFIG_IP_MROUTE
-                           || (!ipv4_is_local_multicast(daddr) &&
-                               IN_DEV_MFORWARD(in_dev))
+                               ||
+                           (!ipv4_is_local_multicast(daddr) &&
+                            IN_DEV_MFORWARD(in_dev))
 #endif
-                           ) {
+                          ) {
                                rcu_read_unlock();
                                return ip_route_input_mc(skb, daddr, saddr,
                                                         tos, dev, our);
@@ -2213,7 +2450,8 @@ static int __mkroute_output(struct rtable **result,
        rth->rt_spec_dst= fl->fl4_src;
 
        rth->u.dst.output=ip_output;
-       rth->rt_genid = atomic_read(&rt_genid);
+       rth->u.dst.obsolete = -1;
+       rth->rt_genid = rt_genid(dev_net(dev_out));
 
        RT_CACHE_STAT_INC(out_slow_tot);
 
@@ -2262,8 +2500,9 @@ static int ip_mkroute_output(struct rtable **rp,
        int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
        unsigned hash;
        if (err == 0) {
-               hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src, oldflp->oif);
-               err = rt_intern_hash(hash, rth, rp);
+               hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src, oldflp->oif,
+                              rt_genid(dev_net(dev_out)));
+               err = rt_intern_hash(hash, rth, rp, NULL);
        }
 
        return err;
@@ -2307,11 +2546,6 @@ static int ip_route_output_slow(struct net *net, struct rtable **rp,
                    ipv4_is_zeronet(oldflp->fl4_src))
                        goto out;
 
-               /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
-               dev_out = ip_dev_find(net, oldflp->fl4_src);
-               if (dev_out == NULL)
-                       goto out;
-
                /* I removed check for oif == dev_out->oif here.
                   It was wrong for two reasons:
                   1. ip_dev_find(net, saddr) can return wrong iface, if saddr
@@ -2320,9 +2554,14 @@ static int ip_route_output_slow(struct net *net, struct rtable **rp,
                      of another iface. --ANK
                 */
 
-               if (oldflp->oif == 0
-                   && (ipv4_is_multicast(oldflp->fl4_dst) ||
-                       oldflp->fl4_dst == htonl(0xFFFFFFFF))) {
+               if (oldflp->oif == 0 &&
+                   (ipv4_is_multicast(oldflp->fl4_dst) ||
+                    oldflp->fl4_dst == htonl(0xFFFFFFFF))) {
+                       /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
+                       dev_out = ip_dev_find(net, oldflp->fl4_src);
+                       if (dev_out == NULL)
+                               goto out;
+
                        /* Special hack: user can direct multicasts
                           and limited broadcast via necessary interface
                           without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
@@ -2341,9 +2580,15 @@ static int ip_route_output_slow(struct net *net, struct rtable **rp,
                        fl.oif = dev_out->ifindex;
                        goto make_route;
                }
-               if (dev_out)
+
+               if (!(oldflp->flags & FLOWI_FLAG_ANYSRC)) {
+                       /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
+                       dev_out = ip_dev_find(net, oldflp->fl4_src);
+                       if (dev_out == NULL)
+                               goto out;
                        dev_put(dev_out);
-               dev_out = NULL;
+                       dev_out = NULL;
+               }
        }
 
 
@@ -2474,11 +2719,14 @@ int __ip_route_output_key(struct net *net, struct rtable **rp,
        unsigned hash;
        struct rtable *rth;
 
-       hash = rt_hash(flp->fl4_dst, flp->fl4_src, flp->oif);
+       if (!rt_caching(net))
+               goto slow_output;
+
+       hash = rt_hash(flp->fl4_dst, flp->fl4_src, flp->oif, rt_genid(net));
 
        rcu_read_lock_bh();
-       for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
-               rth = rcu_dereference(rth->u.dst.rt_next)) {
+       for (rth = rcu_dereference_bh(rt_hash_table[hash].chain); rth;
+               rth = rcu_dereference_bh(rth->u.dst.rt_next)) {
                if (rth->fl.fl4_dst == flp->fl4_dst &&
                    rth->fl.fl4_src == flp->fl4_src &&
                    rth->fl.iif == 0 &&
@@ -2487,7 +2735,7 @@ int __ip_route_output_key(struct net *net, struct rtable **rp,
                    !((rth->fl.fl4_tos ^ flp->fl4_tos) &
                            (IPTOS_RT_MASK | RTO_ONLINK)) &&
                    net_eq(dev_net(rth->u.dst.dev), net) &&
-                   rth->rt_genid == atomic_read(&rt_genid)) {
+                   !rt_is_expired(rth)) {
                        dst_use(&rth->u.dst, jiffies);
                        RT_CACHE_STAT_INC(out_hit);
                        rcu_read_unlock_bh();
@@ -2498,6 +2746,7 @@ int __ip_route_output_key(struct net *net, struct rtable **rp,
        }
        rcu_read_unlock_bh();
 
+slow_output:
        return ip_route_output_slow(net, rp, flp);
 }
 
@@ -2509,16 +2758,15 @@ static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
 
 static struct dst_ops ipv4_dst_blackhole_ops = {
        .family                 =       AF_INET,
-       .protocol               =       __constant_htons(ETH_P_IP),
+       .protocol               =       cpu_to_be16(ETH_P_IP),
        .destroy                =       ipv4_dst_destroy,
        .check                  =       ipv4_dst_check,
        .update_pmtu            =       ipv4_rt_blackhole_update_pmtu,
-       .entry_size             =       sizeof(struct rtable),
        .entries                =       ATOMIC_INIT(0),
 };
 
 
-static int ipv4_dst_blackhole(struct rtable **rp, struct flowi *flp)
+static int ipv4_dst_blackhole(struct net *net, struct rtable **rp, struct flowi *flp)
 {
        struct rtable *ort = *rp;
        struct rtable *rt = (struct rtable *)
@@ -2542,7 +2790,7 @@ static int ipv4_dst_blackhole(struct rtable **rp, struct flowi *flp)
                rt->idev = ort->idev;
                if (rt->idev)
                        in_dev_hold(rt->idev);
-               rt->rt_genid = atomic_read(&rt_genid);
+               rt->rt_genid = rt_genid(net);
                rt->rt_flags = ort->rt_flags;
                rt->rt_type = ort->rt_type;
                rt->rt_dst = ort->rt_dst;
@@ -2575,10 +2823,10 @@ int ip_route_output_flow(struct net *net, struct rtable **rp, struct flowi *flp,
                        flp->fl4_src = (*rp)->rt_src;
                if (!flp->fl4_dst)
                        flp->fl4_dst = (*rp)->rt_dst;
-               err = __xfrm_lookup((struct dst_entry **)rp, flp, sk,
+               err = __xfrm_lookup(net, (struct dst_entry **)rp, flp, sk,
                                    flags ? XFRM_LOOKUP_WAIT : 0);
                if (err == -EREMOTE)
-                       err = ipv4_dst_blackhole(rp, flp);
+                       err = ipv4_dst_blackhole(net, rp, flp);
 
                return err;
        }
@@ -2593,10 +2841,11 @@ int ip_route_output_key(struct net *net, struct rtable **rp, struct flowi *flp)
        return ip_route_output_flow(net, rp, flp, NULL, 0);
 }
 
-static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
+static int rt_fill_info(struct net *net,
+                       struct sk_buff *skb, u32 pid, u32 seq, int event,
                        int nowait, unsigned int flags)
 {
-       struct rtable *rt = skb->rtable;
+       struct rtable *rt = skb_rtable(skb);
        struct rtmsg *r;
        struct nlmsghdr *nlh;
        long expires;
@@ -2646,7 +2895,7 @@ static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
        error = rt->u.dst.error;
        expires = rt->u.dst.expires ? rt->u.dst.expires - jiffies : 0;
        if (rt->peer) {
-               id = rt->peer->ip_id_count;
+               id = atomic_read(&rt->peer->ip_id_count) & 0xffff;
                if (rt->peer->tcp_ts_stamp) {
                        ts = rt->peer->tcp_ts;
                        tsage = get_seconds() - rt->peer->tcp_ts_stamp;
@@ -2658,8 +2907,8 @@ static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
                __be32 dst = rt->rt_dst;
 
                if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
-                   IPV4_DEVCONF_ALL(&init_net, MC_FORWARDING)) {
-                       int err = ipmr_get_route(skb, r, nowait);
+                   IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
+                       int err = ipmr_get_route(net, skb, r, nowait);
                        if (err <= 0) {
                                if (!nowait) {
                                        if (err == 0)
@@ -2740,7 +2989,7 @@ static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void
                err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
                local_bh_enable();
 
-               rt = skb->rtable;
+               rt = skb_rtable(skb);
                if (err == 0 && rt->u.dst.error)
                        err = -rt->u.dst.error;
        } else {
@@ -2760,11 +3009,11 @@ static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void
        if (err)
                goto errout_free;
 
-       skb->rtable = rt;
+       skb_dst_set(skb, &rt->u.dst);
        if (rtm->rtm_flags & RTM_F_NOTIFY)
                rt->rt_flags |= RTCF_NOTIFY;
 
-       err = rt_fill_info(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
+       err = rt_fill_info(net, skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
                           RTM_NEWROUTE, 0, 0);
        if (err <= 0)
                goto errout_free;
@@ -2791,26 +3040,27 @@ int ip_rt_dump(struct sk_buff *skb,  struct netlink_callback *cb)
        if (s_h < 0)
                s_h = 0;
        s_idx = idx = cb->args[1];
-       for (h = s_h; h <= rt_hash_mask; h++) {
+       for (h = s_h; h <= rt_hash_mask; h++, s_idx = 0) {
+               if (!rt_hash_table[h].chain)
+                       continue;
                rcu_read_lock_bh();
-               for (rt = rcu_dereference(rt_hash_table[h].chain), idx = 0; rt;
-                    rt = rcu_dereference(rt->u.dst.rt_next), idx++) {
+               for (rt = rcu_dereference_bh(rt_hash_table[h].chain), idx = 0; rt;
+                    rt = rcu_dereference_bh(rt->u.dst.rt_next), idx++) {
                        if (!net_eq(dev_net(rt->u.dst.dev), net) || idx < s_idx)
                                continue;
-                       if (rt->rt_genid != atomic_read(&rt_genid))
+                       if (rt_is_expired(rt))
                                continue;
-                       skb->dst = dst_clone(&rt->u.dst);
-                       if (rt_fill_info(skb, NETLINK_CB(cb->skb).pid,
+                       skb_dst_set(skb, dst_clone(&rt->u.dst));
+                       if (rt_fill_info(net, skb, NETLINK_CB(cb->skb).pid,
                                         cb->nlh->nlmsg_seq, RTM_NEWROUTE,
                                         1, NLM_F_MULTI) <= 0) {
-                               dst_release(xchg(&skb->dst, NULL));
+                               skb_dst_drop(skb);
                                rcu_read_unlock_bh();
                                goto done;
                        }
-                       dst_release(xchg(&skb->dst, NULL));
+                       skb_dst_drop(skb);
                }
                rcu_read_unlock_bh();
-               s_idx = 0;
        }
 
 done:
@@ -2821,194 +3071,299 @@ done:
 
 void ip_rt_multicast_event(struct in_device *in_dev)
 {
-       rt_cache_flush(0);
+       rt_cache_flush(dev_net(in_dev->dev), 0);
 }
 
 #ifdef CONFIG_SYSCTL
-static int flush_delay;
-
-static int ipv4_sysctl_rtcache_flush(ctl_table *ctl, int write,
-                                       struct file *filp, void __user *buffer,
+static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
+                                       void __user *buffer,
                                        size_t *lenp, loff_t *ppos)
 {
        if (write) {
-               proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
-               rt_cache_flush(flush_delay);
+               int flush_delay;
+               ctl_table ctl;
+               struct net *net;
+
+               memcpy(&ctl, __ctl, sizeof(ctl));
+               ctl.data = &flush_delay;
+               proc_dointvec(&ctl, write, buffer, lenp, ppos);
+
+               net = (struct net *)__ctl->extra1;
+               rt_cache_flush(net, flush_delay);
                return 0;
        }
 
        return -EINVAL;
 }
 
-static int ipv4_sysctl_rtcache_flush_strategy(ctl_table *table,
-                                               int __user *name,
-                                               int nlen,
-                                               void __user *oldval,
-                                               size_t __user *oldlenp,
-                                               void __user *newval,
-                                               size_t newlen)
+static void rt_secret_reschedule(int old)
 {
-       int delay;
-       if (newlen != sizeof(int))
-               return -EINVAL;
-       if (get_user(delay, (int __user *)newval))
-               return -EFAULT;
-       rt_cache_flush(delay);
-       return 0;
+       struct net *net;
+       int new = ip_rt_secret_interval;
+       int diff = new - old;
+
+       if (!diff)
+               return;
+
+       rtnl_lock();
+       for_each_net(net) {
+               int deleted = del_timer_sync(&net->ipv4.rt_secret_timer);
+               long time;
+
+               if (!new)
+                       continue;
+
+               if (deleted) {
+                       time = net->ipv4.rt_secret_timer.expires - jiffies;
+
+                       if (time <= 0 || (time += diff) <= 0)
+                               time = 0;
+               } else
+                       time = new;
+
+               mod_timer(&net->ipv4.rt_secret_timer, jiffies + time);
+       }
+       rtnl_unlock();
 }
 
-ctl_table ipv4_route_table[] = {
-       {
-               .ctl_name       = NET_IPV4_ROUTE_FLUSH,
-               .procname       = "flush",
-               .data           = &flush_delay,
-               .maxlen         = sizeof(int),
-               .mode           = 0200,
-               .proc_handler   = &ipv4_sysctl_rtcache_flush,
-               .strategy       = &ipv4_sysctl_rtcache_flush_strategy,
-       },
+static int ipv4_sysctl_rt_secret_interval(ctl_table *ctl, int write,
+                                         void __user *buffer, size_t *lenp,
+                                         loff_t *ppos)
+{
+       int old = ip_rt_secret_interval;
+       int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
+
+       rt_secret_reschedule(old);
+
+       return ret;
+}
+
+static ctl_table ipv4_route_table[] = {
        {
-               .ctl_name       = NET_IPV4_ROUTE_GC_THRESH,
                .procname       = "gc_thresh",
                .data           = &ipv4_dst_ops.gc_thresh,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_MAX_SIZE,
                .procname       = "max_size",
                .data           = &ip_rt_max_size,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
                /*  Deprecated. Use gc_min_interval_ms */
 
-               .ctl_name       = NET_IPV4_ROUTE_GC_MIN_INTERVAL,
                .procname       = "gc_min_interval",
                .data           = &ip_rt_gc_min_interval,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec_jiffies,
-               .strategy       = &sysctl_jiffies,
+               .proc_handler   = proc_dointvec_jiffies,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS,
                .procname       = "gc_min_interval_ms",
                .data           = &ip_rt_gc_min_interval,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec_ms_jiffies,
-               .strategy       = &sysctl_ms_jiffies,
+               .proc_handler   = proc_dointvec_ms_jiffies,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_GC_TIMEOUT,
                .procname       = "gc_timeout",
                .data           = &ip_rt_gc_timeout,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec_jiffies,
-               .strategy       = &sysctl_jiffies,
+               .proc_handler   = proc_dointvec_jiffies,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_GC_INTERVAL,
                .procname       = "gc_interval",
                .data           = &ip_rt_gc_interval,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec_jiffies,
-               .strategy       = &sysctl_jiffies,
+               .proc_handler   = proc_dointvec_jiffies,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_REDIRECT_LOAD,
                .procname       = "redirect_load",
                .data           = &ip_rt_redirect_load,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_REDIRECT_NUMBER,
                .procname       = "redirect_number",
                .data           = &ip_rt_redirect_number,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_REDIRECT_SILENCE,
                .procname       = "redirect_silence",
                .data           = &ip_rt_redirect_silence,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_ERROR_COST,
                .procname       = "error_cost",
                .data           = &ip_rt_error_cost,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_ERROR_BURST,
                .procname       = "error_burst",
                .data           = &ip_rt_error_burst,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_GC_ELASTICITY,
                .procname       = "gc_elasticity",
                .data           = &ip_rt_gc_elasticity,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_MTU_EXPIRES,
                .procname       = "mtu_expires",
                .data           = &ip_rt_mtu_expires,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec_jiffies,
-               .strategy       = &sysctl_jiffies,
+               .proc_handler   = proc_dointvec_jiffies,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_MIN_PMTU,
                .procname       = "min_pmtu",
                .data           = &ip_rt_min_pmtu,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_MIN_ADVMSS,
                .procname       = "min_adv_mss",
                .data           = &ip_rt_min_advmss,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
-               .ctl_name       = NET_IPV4_ROUTE_SECRET_INTERVAL,
                .procname       = "secret_interval",
                .data           = &ip_rt_secret_interval,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec_jiffies,
-               .strategy       = &sysctl_jiffies,
+               .proc_handler   = ipv4_sysctl_rt_secret_interval,
+       },
+       { }
+};
+
+static struct ctl_table empty[1];
+
+static struct ctl_table ipv4_skeleton[] =
+{
+       { .procname = "route", 
+         .mode = 0555, .child = ipv4_route_table},
+       { .procname = "neigh", 
+         .mode = 0555, .child = empty},
+       { }
+};
+
+static __net_initdata struct ctl_path ipv4_path[] = {
+       { .procname = "net", },
+       { .procname = "ipv4", },
+       { },
+};
+
+static struct ctl_table ipv4_route_flush_table[] = {
+       {
+               .procname       = "flush",
+               .maxlen         = sizeof(int),
+               .mode           = 0200,
+               .proc_handler   = ipv4_sysctl_rtcache_flush,
        },
-       { .ctl_name = 0 }
+       { },
+};
+
+static __net_initdata struct ctl_path ipv4_route_path[] = {
+       { .procname = "net", },
+       { .procname = "ipv4", },
+       { .procname = "route", },
+       { },
+};
+
+static __net_init int sysctl_route_net_init(struct net *net)
+{
+       struct ctl_table *tbl;
+
+       tbl = ipv4_route_flush_table;
+       if (!net_eq(net, &init_net)) {
+               tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
+               if (tbl == NULL)
+                       goto err_dup;
+       }
+       tbl[0].extra1 = net;
+
+       net->ipv4.route_hdr =
+               register_net_sysctl_table(net, ipv4_route_path, tbl);
+       if (net->ipv4.route_hdr == NULL)
+               goto err_reg;
+       return 0;
+
+err_reg:
+       if (tbl != ipv4_route_flush_table)
+               kfree(tbl);
+err_dup:
+       return -ENOMEM;
+}
+
+static __net_exit void sysctl_route_net_exit(struct net *net)
+{
+       struct ctl_table *tbl;
+
+       tbl = net->ipv4.route_hdr->ctl_table_arg;
+       unregister_net_sysctl_table(net->ipv4.route_hdr);
+       BUG_ON(tbl == ipv4_route_flush_table);
+       kfree(tbl);
+}
+
+static __net_initdata struct pernet_operations sysctl_route_ops = {
+       .init = sysctl_route_net_init,
+       .exit = sysctl_route_net_exit,
 };
 #endif
 
+
+static __net_init int rt_secret_timer_init(struct net *net)
+{
+       atomic_set(&net->ipv4.rt_genid,
+                       (int) ((num_physpages ^ (num_physpages>>8)) ^
+                       (jiffies ^ (jiffies >> 7))));
+
+       net->ipv4.rt_secret_timer.function = rt_secret_rebuild;
+       net->ipv4.rt_secret_timer.data = (unsigned long)net;
+       init_timer_deferrable(&net->ipv4.rt_secret_timer);
+
+       if (ip_rt_secret_interval) {
+               net->ipv4.rt_secret_timer.expires =
+                       jiffies + net_random() % ip_rt_secret_interval +
+                       ip_rt_secret_interval;
+               add_timer(&net->ipv4.rt_secret_timer);
+       }
+       return 0;
+}
+
+static __net_exit void rt_secret_timer_exit(struct net *net)
+{
+       del_timer_sync(&net->ipv4.rt_secret_timer);
+}
+
+static __net_initdata struct pernet_operations rt_secret_timer_ops = {
+       .init = rt_secret_timer_init,
+       .exit = rt_secret_timer_exit,
+};
+
+
 #ifdef CONFIG_NET_CLS_ROUTE
-struct ip_rt_acct *ip_rt_acct __read_mostly;
+struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
 #endif /* CONFIG_NET_CLS_ROUTE */
 
 static __initdata unsigned long rhash_entries;
@@ -3025,11 +3380,8 @@ int __init ip_rt_init(void)
 {
        int rc = 0;
 
-       atomic_set(&rt_genid, (int) ((num_physpages ^ (num_physpages>>8)) ^
-                            (jiffies ^ (jiffies >> 7))));
-
 #ifdef CONFIG_NET_CLS_ROUTE
-       ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct));
+       ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
        if (!ip_rt_acct)
                panic("IP: failed to allocate ip_rt_acct\n");
 #endif
@@ -3044,12 +3396,12 @@ int __init ip_rt_init(void)
                alloc_large_system_hash("IP route cache",
                                        sizeof(struct rt_hash_bucket),
                                        rhash_entries,
-                                       (num_physpages >= 128 * 1024) ?
+                                       (totalram_pages >= 128 * 1024) ?
                                        15 : 17,
                                        0,
                                        &rt_hash_log,
                                        &rt_hash_mask,
-                                       0);
+                                       rhash_entries ? 0 : 512 * 1024);
        memset(rt_hash_table, 0, (rt_hash_mask + 1) * sizeof(struct rt_hash_bucket));
        rt_hash_lock_init();
 
@@ -3059,31 +3411,42 @@ int __init ip_rt_init(void)
        devinet_init();
        ip_fib_init();
 
-       rt_secret_timer.function = rt_secret_rebuild;
-       rt_secret_timer.data = 0;
-       init_timer_deferrable(&rt_secret_timer);
-
        /* All the timers, started at system startup tend
           to synchronize. Perturb it a bit.
         */
+       INIT_DELAYED_WORK_DEFERRABLE(&expires_work, rt_worker_func);
+       expires_ljiffies = jiffies;
        schedule_delayed_work(&expires_work,
                net_random() % ip_rt_gc_interval + ip_rt_gc_interval);
 
-       rt_secret_timer.expires = jiffies + net_random() % ip_rt_secret_interval +
-               ip_rt_secret_interval;
-       add_timer(&rt_secret_timer);
+       if (register_pernet_subsys(&rt_secret_timer_ops))
+               printk(KERN_ERR "Unable to setup rt_secret_timer\n");
 
        if (ip_rt_proc_init())
                printk(KERN_ERR "Unable to create route proc files\n");
 #ifdef CONFIG_XFRM
        xfrm_init();
-       xfrm4_init();
+       xfrm4_init(ip_rt_max_size);
 #endif
        rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL);
 
+#ifdef CONFIG_SYSCTL
+       register_pernet_subsys(&sysctl_route_ops);
+#endif
        return rc;
 }
 
+#ifdef CONFIG_SYSCTL
+/*
+ * We really need to sanitize the damn ipv4 init order, then all
+ * this nonsense will go away.
+ */
+void __init ip_static_sysctl_init(void)
+{
+       register_sysctl_paths(ipv4_path, ipv4_skeleton);
+}
+#endif
+
 EXPORT_SYMBOL(__ip_select_ident);
 EXPORT_SYMBOL(ip_route_input);
 EXPORT_SYMBOL(ip_route_output_key);