ipv4: Remove fib_hash.
authorDavid S. Miller <davem@davemloft.net>
Tue, 1 Feb 2011 23:15:39 +0000 (15:15 -0800)
committerDavid S. Miller <davem@davemloft.net>
Tue, 1 Feb 2011 23:35:25 +0000 (15:35 -0800)
The time has finally come to remove the hash based routing table
implementation in ipv4.

FIB Trie is mature, well tested, and I've done an audit of it's code
to confirm that it implements insert, delete, and lookup with the same
identical semantics as fib_hash did.

If there are any semantic differences found in fib_trie, we should
simply fix them.

I've placed the trie statistic config option under advanced router
configuration.

Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Stephen Hemminger <shemminger@vyatta.com>
net/ipv4/Kconfig
net/ipv4/Makefile
net/ipv4/fib_hash.c [deleted file]

index 8949a05ac307d3c16241c85d979375288500e944..cbb505ba9324fa05caeb9f93e545d9cfaf42e7af 100644 (file)
@@ -55,45 +55,9 @@ config IP_ADVANCED_ROUTER
 
          If unsure, say N here.
 
-choice
-       prompt "Choose IP: FIB lookup algorithm (choose FIB_HASH if unsure)"
-       depends on IP_ADVANCED_ROUTER
-       default ASK_IP_FIB_HASH
-
-config ASK_IP_FIB_HASH
-       bool "FIB_HASH"
-       ---help---
-         Current FIB is very proven and good enough for most users.
-
-config IP_FIB_TRIE
-       bool "FIB_TRIE"
-       ---help---
-         Use new experimental LC-trie as FIB lookup algorithm.
-         This improves lookup performance if you have a large
-         number of routes.
-
-         LC-trie is a longest matching prefix lookup algorithm which
-         performs better than FIB_HASH for large routing tables.
-         But, it consumes more memory and is more complex.
-
-         LC-trie is described in:
-
-         IP-address lookup using LC-tries. Stefan Nilsson and Gunnar Karlsson
-         IEEE Journal on Selected Areas in Communications, 17(6):1083-1092,
-         June 1999
-
-         An experimental study of compression methods for dynamic tries
-         Stefan Nilsson and Matti Tikkanen. Algorithmica, 33(1):19-33, 2002.
-         <http://www.csc.kth.se/~snilsson/software/dyntrie2/>
-
-endchoice
-
-config IP_FIB_HASH
-       def_bool ASK_IP_FIB_HASH || !IP_ADVANCED_ROUTER
-
 config IP_FIB_TRIE_STATS
        bool "FIB TRIE statistics"
-       depends on IP_FIB_TRIE
+       depends on IP_ADVANCED_ROUTER
        ---help---
          Keep track of statistics on structure of FIB TRIE table.
          Useful for testing and measuring TRIE performance.
index 4978d22f9a75eafe3fe10d8cf93f6e8a2a7f647a..0dc772d0d1259e7228481d53108981a23b9d61ea 100644 (file)
@@ -10,12 +10,10 @@ obj-y     := route.o inetpeer.o protocol.o \
             tcp_minisocks.o tcp_cong.o \
             datagram.o raw.o udp.o udplite.o \
             arp.o icmp.o devinet.o af_inet.o  igmp.o \
-            fib_frontend.o fib_semantics.o \
+            fib_frontend.o fib_semantics.o fib_trie.o \
             inet_fragment.o
 
 obj-$(CONFIG_SYSCTL) += sysctl_net_ipv4.o
-obj-$(CONFIG_IP_FIB_HASH) += fib_hash.o
-obj-$(CONFIG_IP_FIB_TRIE) += fib_trie.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_IP_MULTIPLE_TABLES) += fib_rules.o
 obj-$(CONFIG_IP_MROUTE) += ipmr.o
diff --git a/net/ipv4/fib_hash.c b/net/ipv4/fib_hash.c
deleted file mode 100644 (file)
index fadb602..0000000
+++ /dev/null
@@ -1,1061 +0,0 @@
-/*
- * INET                An implementation of the TCP/IP protocol suite for the LINUX
- *             operating system.  INET is implemented using the  BSD Socket
- *             interface as the means of communication with the user level.
- *
- *             IPv4 FIB: lookup engine and maintenance routines.
- *
- * Authors:    Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
- *
- *             This program is free software; you can redistribute it and/or
- *             modify it under the terms of the GNU General Public License
- *             as published by the Free Software Foundation; either version
- *             2 of the License, or (at your option) any later version.
- */
-
-#include <asm/uaccess.h>
-#include <asm/system.h>
-#include <linux/bitops.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/string.h>
-#include <linux/socket.h>
-#include <linux/sockios.h>
-#include <linux/errno.h>
-#include <linux/in.h>
-#include <linux/inet.h>
-#include <linux/inetdevice.h>
-#include <linux/netdevice.h>
-#include <linux/if_arp.h>
-#include <linux/proc_fs.h>
-#include <linux/skbuff.h>
-#include <linux/netlink.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-
-#include <net/net_namespace.h>
-#include <net/ip.h>
-#include <net/protocol.h>
-#include <net/route.h>
-#include <net/tcp.h>
-#include <net/sock.h>
-#include <net/ip_fib.h>
-
-#include "fib_lookup.h"
-
-static struct kmem_cache *fn_hash_kmem __read_mostly;
-static struct kmem_cache *fn_alias_kmem __read_mostly;
-
-struct fib_node {
-       struct hlist_node       fn_hash;
-       struct list_head        fn_alias;
-       __be32                  fn_key;
-       struct fib_alias        fn_embedded_alias;
-};
-
-#define EMBEDDED_HASH_SIZE (L1_CACHE_BYTES / sizeof(struct hlist_head))
-
-struct fn_zone {
-       struct fn_zone __rcu    *fz_next;       /* Next not empty zone  */
-       struct hlist_head __rcu *fz_hash;       /* Hash table pointer   */
-       seqlock_t               fz_lock;
-       u32                     fz_hashmask;    /* (fz_divisor - 1)     */
-
-       u8                      fz_order;       /* Zone order (0..32)   */
-       u8                      fz_revorder;    /* 32 - fz_order        */
-       __be32                  fz_mask;        /* inet_make_mask(order) */
-#define FZ_MASK(fz)            ((fz)->fz_mask)
-
-       struct hlist_head       fz_embedded_hash[EMBEDDED_HASH_SIZE];
-
-       int                     fz_nent;        /* Number of entries    */
-       int                     fz_divisor;     /* Hash size (mask+1)   */
-};
-
-struct fn_hash {
-       struct fn_zone          *fn_zones[33];
-       struct fn_zone __rcu    *fn_zone_list;
-};
-
-static inline u32 fn_hash(__be32 key, struct fn_zone *fz)
-{
-       u32 h = ntohl(key) >> fz->fz_revorder;
-       h ^= (h>>20);
-       h ^= (h>>10);
-       h ^= (h>>5);
-       h &= fz->fz_hashmask;
-       return h;
-}
-
-static inline __be32 fz_key(__be32 dst, struct fn_zone *fz)
-{
-       return dst & FZ_MASK(fz);
-}
-
-static unsigned int fib_hash_genid;
-
-#define FZ_MAX_DIVISOR ((PAGE_SIZE<<MAX_ORDER) / sizeof(struct hlist_head))
-
-static struct hlist_head *fz_hash_alloc(int divisor)
-{
-       unsigned long size = divisor * sizeof(struct hlist_head);
-
-       if (size <= PAGE_SIZE)
-               return kzalloc(size, GFP_KERNEL);
-
-       return (struct hlist_head *)
-               __get_free_pages(GFP_KERNEL | __GFP_ZERO, get_order(size));
-}
-
-/* The fib hash lock must be held when this is called. */
-static inline void fn_rebuild_zone(struct fn_zone *fz,
-                                  struct hlist_head *old_ht,
-                                  int old_divisor)
-{
-       int i;
-
-       for (i = 0; i < old_divisor; i++) {
-               struct hlist_node *node, *n;
-               struct fib_node *f;
-
-               hlist_for_each_entry_safe(f, node, n, &old_ht[i], fn_hash) {
-                       struct hlist_head *new_head;
-
-                       hlist_del_rcu(&f->fn_hash);
-
-                       new_head = rcu_dereference_protected(fz->fz_hash, 1) +
-                                  fn_hash(f->fn_key, fz);
-                       hlist_add_head_rcu(&f->fn_hash, new_head);
-               }
-       }
-}
-
-static void fz_hash_free(struct hlist_head *hash, int divisor)
-{
-       unsigned long size = divisor * sizeof(struct hlist_head);
-
-       if (size <= PAGE_SIZE)
-               kfree(hash);
-       else
-               free_pages((unsigned long)hash, get_order(size));
-}
-
-static void fn_rehash_zone(struct fn_zone *fz)
-{
-       struct hlist_head *ht, *old_ht;
-       int old_divisor, new_divisor;
-       u32 new_hashmask;
-
-       new_divisor = old_divisor = fz->fz_divisor;
-
-       switch (old_divisor) {
-       case EMBEDDED_HASH_SIZE:
-               new_divisor *= EMBEDDED_HASH_SIZE;
-               break;
-       case EMBEDDED_HASH_SIZE*EMBEDDED_HASH_SIZE:
-               new_divisor *= (EMBEDDED_HASH_SIZE/2);
-               break;
-       default:
-               if ((old_divisor << 1) > FZ_MAX_DIVISOR) {
-                       printk(KERN_CRIT "route.c: bad divisor %d!\n", old_divisor);
-                       return;
-               }
-               new_divisor = (old_divisor << 1);
-               break;
-       }
-
-       new_hashmask = (new_divisor - 1);
-
-#if RT_CACHE_DEBUG >= 2
-       printk(KERN_DEBUG "fn_rehash_zone: hash for zone %d grows from %d\n",
-              fz->fz_order, old_divisor);
-#endif
-
-       ht = fz_hash_alloc(new_divisor);
-
-       if (ht) {
-               struct fn_zone nfz;
-
-               memcpy(&nfz, fz, sizeof(nfz));
-
-               write_seqlock_bh(&fz->fz_lock);
-               old_ht = rcu_dereference_protected(fz->fz_hash, 1);
-               RCU_INIT_POINTER(nfz.fz_hash, ht);
-               nfz.fz_hashmask = new_hashmask;
-               nfz.fz_divisor = new_divisor;
-               fn_rebuild_zone(&nfz, old_ht, old_divisor);
-               fib_hash_genid++;
-               rcu_assign_pointer(fz->fz_hash, ht);
-               fz->fz_hashmask = new_hashmask;
-               fz->fz_divisor = new_divisor;
-               write_sequnlock_bh(&fz->fz_lock);
-
-               if (old_ht != fz->fz_embedded_hash) {
-                       synchronize_rcu();
-                       fz_hash_free(old_ht, old_divisor);
-               }
-       }
-}
-
-static void fn_free_node_rcu(struct rcu_head *head)
-{
-       struct fib_node *f = container_of(head, struct fib_node, fn_embedded_alias.rcu);
-
-       kmem_cache_free(fn_hash_kmem, f);
-}
-
-static inline void fn_free_node(struct fib_node *f)
-{
-       call_rcu(&f->fn_embedded_alias.rcu, fn_free_node_rcu);
-}
-
-static void fn_free_alias_rcu(struct rcu_head *head)
-{
-       struct fib_alias *fa = container_of(head, struct fib_alias, rcu);
-
-       kmem_cache_free(fn_alias_kmem, fa);
-}
-
-static inline void fn_free_alias(struct fib_alias *fa, struct fib_node *f)
-{
-       fib_release_info(fa->fa_info);
-       if (fa == &f->fn_embedded_alias)
-               fa->fa_info = NULL;
-       else
-               call_rcu(&fa->rcu, fn_free_alias_rcu);
-}
-
-static struct fn_zone *
-fn_new_zone(struct fn_hash *table, int z)
-{
-       int i;
-       struct fn_zone *fz = kzalloc(sizeof(struct fn_zone), GFP_KERNEL);
-       if (!fz)
-               return NULL;
-
-       seqlock_init(&fz->fz_lock);
-       fz->fz_divisor = z ? EMBEDDED_HASH_SIZE : 1;
-       fz->fz_hashmask = fz->fz_divisor - 1;
-       RCU_INIT_POINTER(fz->fz_hash, fz->fz_embedded_hash);
-       fz->fz_order = z;
-       fz->fz_revorder = 32 - z;
-       fz->fz_mask = inet_make_mask(z);
-
-       /* Find the first not empty zone with more specific mask */
-       for (i = z + 1; i <= 32; i++)
-               if (table->fn_zones[i])
-                       break;
-       if (i > 32) {
-               /* No more specific masks, we are the first. */
-               rcu_assign_pointer(fz->fz_next,
-                                  rtnl_dereference(table->fn_zone_list));
-               rcu_assign_pointer(table->fn_zone_list, fz);
-       } else {
-               rcu_assign_pointer(fz->fz_next,
-                                  rtnl_dereference(table->fn_zones[i]->fz_next));
-               rcu_assign_pointer(table->fn_zones[i]->fz_next, fz);
-       }
-       table->fn_zones[z] = fz;
-       fib_hash_genid++;
-       return fz;
-}
-
-int fib_table_lookup(struct fib_table *tb,
-                    const struct flowi *flp, struct fib_result *res,
-                    int fib_flags)
-{
-       int err;
-       struct fn_zone *fz;
-       struct fn_hash *t = (struct fn_hash *)tb->tb_data;
-
-       rcu_read_lock();
-       for (fz = rcu_dereference(t->fn_zone_list);
-            fz != NULL;
-            fz = rcu_dereference(fz->fz_next)) {
-               struct hlist_head *head;
-               struct hlist_node *node;
-               struct fib_node *f;
-               __be32 k;
-               unsigned int seq;
-
-               do {
-                       seq = read_seqbegin(&fz->fz_lock);
-                       k = fz_key(flp->fl4_dst, fz);
-
-                       head = rcu_dereference(fz->fz_hash) + fn_hash(k, fz);
-                       hlist_for_each_entry_rcu(f, node, head, fn_hash) {
-                               if (f->fn_key != k)
-                                       continue;
-
-                               err = fib_semantic_match(tb, &f->fn_alias,
-                                                flp, res,
-                                                fz->fz_order, fib_flags);
-                               if (err <= 0)
-                                       goto out;
-                       }
-               } while (read_seqretry(&fz->fz_lock, seq));
-       }
-       err = 1;
-out:
-       rcu_read_unlock();
-       return err;
-}
-
-/* Insert node F to FZ. */
-static inline void fib_insert_node(struct fn_zone *fz, struct fib_node *f)
-{
-       struct hlist_head *head = rtnl_dereference(fz->fz_hash) + fn_hash(f->fn_key, fz);
-
-       hlist_add_head_rcu(&f->fn_hash, head);
-}
-
-/* Return the node in FZ matching KEY. */
-static struct fib_node *fib_find_node(struct fn_zone *fz, __be32 key)
-{
-       struct hlist_head *head = rtnl_dereference(fz->fz_hash) + fn_hash(key, fz);
-       struct hlist_node *node;
-       struct fib_node *f;
-
-       hlist_for_each_entry_rcu(f, node, head, fn_hash) {
-               if (f->fn_key == key)
-                       return f;
-       }
-
-       return NULL;
-}
-
-
-static struct fib_alias *fib_fast_alloc(struct fib_node *f)
-{
-       struct fib_alias *fa = &f->fn_embedded_alias;
-
-       if (fa->fa_info != NULL)
-               fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
-       return fa;
-}
-
-/* Caller must hold RTNL. */
-int fib_table_insert(struct fib_table *tb, struct fib_config *cfg)
-{
-       struct fn_hash *table = (struct fn_hash *) tb->tb_data;
-       struct fib_node *new_f = NULL;
-       struct fib_node *f;
-       struct fib_alias *fa, *new_fa;
-       struct fn_zone *fz;
-       struct fib_info *fi;
-       u8 tos = cfg->fc_tos;
-       __be32 key;
-       int err;
-
-       if (cfg->fc_dst_len > 32)
-               return -EINVAL;
-
-       fz = table->fn_zones[cfg->fc_dst_len];
-       if (!fz && !(fz = fn_new_zone(table, cfg->fc_dst_len)))
-               return -ENOBUFS;
-
-       key = 0;
-       if (cfg->fc_dst) {
-               if (cfg->fc_dst & ~FZ_MASK(fz))
-                       return -EINVAL;
-               key = fz_key(cfg->fc_dst, fz);
-       }
-
-       fi = fib_create_info(cfg);
-       if (IS_ERR(fi))
-               return PTR_ERR(fi);
-
-       if (fz->fz_nent > (fz->fz_divisor<<1) &&
-           fz->fz_divisor < FZ_MAX_DIVISOR &&
-           (cfg->fc_dst_len == 32 ||
-            (1 << cfg->fc_dst_len) > fz->fz_divisor))
-               fn_rehash_zone(fz);
-
-       f = fib_find_node(fz, key);
-
-       if (!f)
-               fa = NULL;
-       else
-               fa = fib_find_alias(&f->fn_alias, tos, fi->fib_priority);
-
-       /* Now fa, if non-NULL, points to the first fib alias
-        * with the same keys [prefix,tos,priority], if such key already
-        * exists or to the node before which we will insert new one.
-        *
-        * If fa is NULL, we will need to allocate a new one and
-        * insert to the head of f.
-        *
-        * If f is NULL, no fib node matched the destination key
-        * and we need to allocate a new one of those as well.
-        */
-
-       if (fa && fa->fa_tos == tos &&
-           fa->fa_info->fib_priority == fi->fib_priority) {
-               struct fib_alias *fa_first, *fa_match;
-
-               err = -EEXIST;
-               if (cfg->fc_nlflags & NLM_F_EXCL)
-                       goto out;
-
-               /* We have 2 goals:
-                * 1. Find exact match for type, scope, fib_info to avoid
-                * duplicate routes
-                * 2. Find next 'fa' (or head), NLM_F_APPEND inserts before it
-                */
-               fa_match = NULL;
-               fa_first = fa;
-               fa = list_entry(fa->fa_list.prev, struct fib_alias, fa_list);
-               list_for_each_entry_continue(fa, &f->fn_alias, fa_list) {
-                       if (fa->fa_tos != tos)
-                               break;
-                       if (fa->fa_info->fib_priority != fi->fib_priority)
-                               break;
-                       if (fa->fa_type == cfg->fc_type &&
-                           fa->fa_scope == cfg->fc_scope &&
-                           fa->fa_info == fi) {
-                               fa_match = fa;
-                               break;
-                       }
-               }
-
-               if (cfg->fc_nlflags & NLM_F_REPLACE) {
-                       u8 state;
-
-                       fa = fa_first;
-                       if (fa_match) {
-                               if (fa == fa_match)
-                                       err = 0;
-                               goto out;
-                       }
-                       err = -ENOBUFS;
-                       new_fa = fib_fast_alloc(f);
-                       if (new_fa == NULL)
-                               goto out;
-
-                       new_fa->fa_tos = fa->fa_tos;
-                       new_fa->fa_info = fi;
-                       new_fa->fa_type = cfg->fc_type;
-                       new_fa->fa_scope = cfg->fc_scope;
-                       state = fa->fa_state;
-                       new_fa->fa_state = state & ~FA_S_ACCESSED;
-                       fib_hash_genid++;
-                       list_replace_rcu(&fa->fa_list, &new_fa->fa_list);
-
-                       fn_free_alias(fa, f);
-                       if (state & FA_S_ACCESSED)
-                               rt_cache_flush(cfg->fc_nlinfo.nl_net, -1);
-                       rtmsg_fib(RTM_NEWROUTE, key, new_fa, cfg->fc_dst_len,
-                                 tb->tb_id, &cfg->fc_nlinfo, NLM_F_REPLACE);
-                       return 0;
-               }
-
-               /* Error if we find a perfect match which
-                * uses the same scope, type, and nexthop
-                * information.
-                */
-               if (fa_match)
-                       goto out;
-
-               if (!(cfg->fc_nlflags & NLM_F_APPEND))
-                       fa = fa_first;
-       }
-
-       err = -ENOENT;
-       if (!(cfg->fc_nlflags & NLM_F_CREATE))
-               goto out;
-
-       err = -ENOBUFS;
-
-       if (!f) {
-               new_f = kmem_cache_zalloc(fn_hash_kmem, GFP_KERNEL);
-               if (new_f == NULL)
-                       goto out;
-
-               INIT_HLIST_NODE(&new_f->fn_hash);
-               INIT_LIST_HEAD(&new_f->fn_alias);
-               new_f->fn_key = key;
-               f = new_f;
-       }
-
-       new_fa = fib_fast_alloc(f);
-       if (new_fa == NULL)
-               goto out;
-
-       new_fa->fa_info = fi;
-       new_fa->fa_tos = tos;
-       new_fa->fa_type = cfg->fc_type;
-       new_fa->fa_scope = cfg->fc_scope;
-       new_fa->fa_state = 0;
-
-       /*
-        * Insert new entry to the list.
-        */
-
-       if (new_f)
-               fib_insert_node(fz, new_f);
-       list_add_tail_rcu(&new_fa->fa_list,
-                (fa ? &fa->fa_list : &f->fn_alias));
-       fib_hash_genid++;
-
-       if (new_f)
-               fz->fz_nent++;
-       rt_cache_flush(cfg->fc_nlinfo.nl_net, -1);
-
-       rtmsg_fib(RTM_NEWROUTE, key, new_fa, cfg->fc_dst_len, tb->tb_id,
-                 &cfg->fc_nlinfo, 0);
-       return 0;
-
-out:
-       if (new_f)
-               kmem_cache_free(fn_hash_kmem, new_f);
-       fib_release_info(fi);
-       return err;
-}
-
-int fib_table_delete(struct fib_table *tb, struct fib_config *cfg)
-{
-       struct fn_hash *table = (struct fn_hash *)tb->tb_data;
-       struct fib_node *f;
-       struct fib_alias *fa, *fa_to_delete;
-       struct fn_zone *fz;
-       __be32 key;
-
-       if (cfg->fc_dst_len > 32)
-               return -EINVAL;
-
-       if ((fz  = table->fn_zones[cfg->fc_dst_len]) == NULL)
-               return -ESRCH;
-
-       key = 0;
-       if (cfg->fc_dst) {
-               if (cfg->fc_dst & ~FZ_MASK(fz))
-                       return -EINVAL;
-               key = fz_key(cfg->fc_dst, fz);
-       }
-
-       f = fib_find_node(fz, key);
-
-       if (!f)
-               fa = NULL;
-       else
-               fa = fib_find_alias(&f->fn_alias, cfg->fc_tos, 0);
-       if (!fa)
-               return -ESRCH;
-
-       fa_to_delete = NULL;
-       fa = list_entry(fa->fa_list.prev, struct fib_alias, fa_list);
-       list_for_each_entry_continue(fa, &f->fn_alias, fa_list) {
-               struct fib_info *fi = fa->fa_info;
-
-               if (fa->fa_tos != cfg->fc_tos)
-                       break;
-
-               if ((!cfg->fc_type ||
-                    fa->fa_type == cfg->fc_type) &&
-                   (cfg->fc_scope == RT_SCOPE_NOWHERE ||
-                    fa->fa_scope == cfg->fc_scope) &&
-                   (!cfg->fc_protocol ||
-                    fi->fib_protocol == cfg->fc_protocol) &&
-                   fib_nh_match(cfg, fi) == 0) {
-                       fa_to_delete = fa;
-                       break;
-               }
-       }
-
-       if (fa_to_delete) {
-               int kill_fn;
-
-               fa = fa_to_delete;
-               rtmsg_fib(RTM_DELROUTE, key, fa, cfg->fc_dst_len,
-                         tb->tb_id, &cfg->fc_nlinfo, 0);
-
-               kill_fn = 0;
-               list_del_rcu(&fa->fa_list);
-               if (list_empty(&f->fn_alias)) {
-                       hlist_del_rcu(&f->fn_hash);
-                       kill_fn = 1;
-               }
-               fib_hash_genid++;
-
-               if (fa->fa_state & FA_S_ACCESSED)
-                       rt_cache_flush(cfg->fc_nlinfo.nl_net, -1);
-               fn_free_alias(fa, f);
-               if (kill_fn) {
-                       fn_free_node(f);
-                       fz->fz_nent--;
-               }
-
-               return 0;
-       }
-       return -ESRCH;
-}
-
-static int fn_flush_list(struct fn_zone *fz, int idx)
-{
-       struct hlist_head *head = rtnl_dereference(fz->fz_hash) + idx;
-       struct hlist_node *node, *n;
-       struct fib_node *f;
-       int found = 0;
-
-       hlist_for_each_entry_safe(f, node, n, head, fn_hash) {
-               struct fib_alias *fa, *fa_node;
-               int kill_f;
-
-               kill_f = 0;
-               list_for_each_entry_safe(fa, fa_node, &f->fn_alias, fa_list) {
-                       struct fib_info *fi = fa->fa_info;
-
-                       if (fi && (fi->fib_flags&RTNH_F_DEAD)) {
-                               list_del_rcu(&fa->fa_list);
-                               if (list_empty(&f->fn_alias)) {
-                                       hlist_del_rcu(&f->fn_hash);
-                                       kill_f = 1;
-                               }
-                               fib_hash_genid++;
-
-                               fn_free_alias(fa, f);
-                               found++;
-                       }
-               }
-               if (kill_f) {
-                       fn_free_node(f);
-                       fz->fz_nent--;
-               }
-       }
-       return found;
-}
-
-/* caller must hold RTNL. */
-int fib_table_flush(struct fib_table *tb)
-{
-       struct fn_hash *table = (struct fn_hash *) tb->tb_data;
-       struct fn_zone *fz;
-       int found = 0;
-
-       for (fz = rtnl_dereference(table->fn_zone_list);
-            fz != NULL;
-            fz = rtnl_dereference(fz->fz_next)) {
-               int i;
-
-               for (i = fz->fz_divisor - 1; i >= 0; i--)
-                       found += fn_flush_list(fz, i);
-       }
-       return found;
-}
-
-void fib_free_table(struct fib_table *tb)
-{
-       struct fn_hash *table = (struct fn_hash *) tb->tb_data;
-       struct fn_zone *fz, *next;
-
-       next = table->fn_zone_list;
-       while (next != NULL) {
-               fz = next;
-               next = fz->fz_next;
-
-               if (fz->fz_hash != fz->fz_embedded_hash)
-                       fz_hash_free(fz->fz_hash, fz->fz_divisor);
-
-               kfree(fz);
-       }
-
-       kfree(tb);
-}
-
-static inline int
-fn_hash_dump_bucket(struct sk_buff *skb, struct netlink_callback *cb,
-                    struct fib_table *tb,
-                    struct fn_zone *fz,
-                    struct hlist_head *head)
-{
-       struct hlist_node *node;
-       struct fib_node *f;
-       int i, s_i;
-
-       s_i = cb->args[4];
-       i = 0;
-       hlist_for_each_entry_rcu(f, node, head, fn_hash) {
-               struct fib_alias *fa;
-
-               list_for_each_entry_rcu(fa, &f->fn_alias, fa_list) {
-                       if (i < s_i)
-                               goto next;
-
-                       if (fib_dump_info(skb, NETLINK_CB(cb->skb).pid,
-                                         cb->nlh->nlmsg_seq,
-                                         RTM_NEWROUTE,
-                                         tb->tb_id,
-                                         fa->fa_type,
-                                         fa->fa_scope,
-                                         f->fn_key,
-                                         fz->fz_order,
-                                         fa->fa_tos,
-                                         fa->fa_info,
-                                         NLM_F_MULTI) < 0) {
-                               cb->args[4] = i;
-                               return -1;
-                       }
-next:
-                       i++;
-               }
-       }
-       cb->args[4] = i;
-       return skb->len;
-}
-
-static inline int
-fn_hash_dump_zone(struct sk_buff *skb, struct netlink_callback *cb,
-                  struct fib_table *tb,
-                  struct fn_zone *fz)
-{
-       int h, s_h;
-       struct hlist_head *head = rcu_dereference(fz->fz_hash);
-
-       if (head == NULL)
-               return skb->len;
-       s_h = cb->args[3];
-       for (h = s_h; h < fz->fz_divisor; h++) {
-               if (hlist_empty(head + h))
-                       continue;
-               if (fn_hash_dump_bucket(skb, cb, tb, fz, head + h) < 0) {
-                       cb->args[3] = h;
-                       return -1;
-               }
-               memset(&cb->args[4], 0,
-                      sizeof(cb->args) - 4*sizeof(cb->args[0]));
-       }
-       cb->args[3] = h;
-       return skb->len;
-}
-
-int fib_table_dump(struct fib_table *tb, struct sk_buff *skb,
-                  struct netlink_callback *cb)
-{
-       int m = 0, s_m;
-       struct fn_zone *fz;
-       struct fn_hash *table = (struct fn_hash *)tb->tb_data;
-
-       s_m = cb->args[2];
-       rcu_read_lock();
-       for (fz = rcu_dereference(table->fn_zone_list);
-            fz != NULL;
-            fz = rcu_dereference(fz->fz_next), m++) {
-               if (m < s_m)
-                       continue;
-               if (fn_hash_dump_zone(skb, cb, tb, fz) < 0) {
-                       cb->args[2] = m;
-                       rcu_read_unlock();
-                       return -1;
-               }
-               memset(&cb->args[3], 0,
-                      sizeof(cb->args) - 3*sizeof(cb->args[0]));
-       }
-       rcu_read_unlock();
-       cb->args[2] = m;
-       return skb->len;
-}
-
-void __init fib_hash_init(void)
-{
-       fn_hash_kmem = kmem_cache_create("ip_fib_hash", sizeof(struct fib_node),
-                                        0, SLAB_PANIC, NULL);
-
-       fn_alias_kmem = kmem_cache_create("ip_fib_alias", sizeof(struct fib_alias),
-                                         0, SLAB_PANIC, NULL);
-
-}
-
-struct fib_table *fib_hash_table(u32 id)
-{
-       struct fib_table *tb;
-
-       tb = kmalloc(sizeof(struct fib_table) + sizeof(struct fn_hash),
-                    GFP_KERNEL);
-       if (tb == NULL)
-               return NULL;
-
-       tb->tb_id = id;
-       tb->tb_default = -1;
-
-       memset(tb->tb_data, 0, sizeof(struct fn_hash));
-       return tb;
-}
-
-/* ------------------------------------------------------------------------ */
-#ifdef CONFIG_PROC_FS
-
-struct fib_iter_state {
-       struct seq_net_private p;
-       struct fn_zone  *zone;
-       int             bucket;
-       struct hlist_head *hash_head;
-       struct fib_node *fn;
-       struct fib_alias *fa;
-       loff_t pos;
-       unsigned int genid;
-       int valid;
-};
-
-static struct fib_alias *fib_get_first(struct seq_file *seq)
-{
-       struct fib_iter_state *iter = seq->private;
-       struct fib_table *main_table;
-       struct fn_hash *table;
-
-       main_table = fib_get_table(seq_file_net(seq), RT_TABLE_MAIN);
-       table = (struct fn_hash *)main_table->tb_data;
-
-       iter->bucket    = 0;
-       iter->hash_head = NULL;
-       iter->fn        = NULL;
-       iter->fa        = NULL;
-       iter->pos       = 0;
-       iter->genid     = fib_hash_genid;
-       iter->valid     = 1;
-
-       for (iter->zone = rcu_dereference(table->fn_zone_list);
-            iter->zone != NULL;
-            iter->zone = rcu_dereference(iter->zone->fz_next)) {
-               int maxslot;
-
-               if (!iter->zone->fz_nent)
-                       continue;
-
-               iter->hash_head = rcu_dereference(iter->zone->fz_hash);
-               maxslot = iter->zone->fz_divisor;
-
-               for (iter->bucket = 0; iter->bucket < maxslot;
-                    ++iter->bucket, ++iter->hash_head) {
-                       struct hlist_node *node;
-                       struct fib_node *fn;
-
-                       hlist_for_each_entry(fn, node, iter->hash_head, fn_hash) {
-                               struct fib_alias *fa;
-
-                               list_for_each_entry(fa, &fn->fn_alias, fa_list) {
-                                       iter->fn = fn;
-                                       iter->fa = fa;
-                                       goto out;
-                               }
-                       }
-               }
-       }
-out:
-       return iter->fa;
-}
-
-static struct fib_alias *fib_get_next(struct seq_file *seq)
-{
-       struct fib_iter_state *iter = seq->private;
-       struct fib_node *fn;
-       struct fib_alias *fa;
-
-       /* Advance FA, if any. */
-       fn = iter->fn;
-       fa = iter->fa;
-       if (fa) {
-               BUG_ON(!fn);
-               list_for_each_entry_continue(fa, &fn->fn_alias, fa_list) {
-                       iter->fa = fa;
-                       goto out;
-               }
-       }
-
-       fa = iter->fa = NULL;
-
-       /* Advance FN. */
-       if (fn) {
-               struct hlist_node *node = &fn->fn_hash;
-               hlist_for_each_entry_continue(fn, node, fn_hash) {
-                       iter->fn = fn;
-
-                       list_for_each_entry(fa, &fn->fn_alias, fa_list) {
-                               iter->fa = fa;
-                               goto out;
-                       }
-               }
-       }
-
-       fn = iter->fn = NULL;
-
-       /* Advance hash chain. */
-       if (!iter->zone)
-               goto out;
-
-       for (;;) {
-               struct hlist_node *node;
-               int maxslot;
-
-               maxslot = iter->zone->fz_divisor;
-
-               while (++iter->bucket < maxslot) {
-                       iter->hash_head++;
-
-                       hlist_for_each_entry(fn, node, iter->hash_head, fn_hash) {
-                               list_for_each_entry(fa, &fn->fn_alias, fa_list) {
-                                       iter->fn = fn;
-                                       iter->fa = fa;
-                                       goto out;
-                               }
-                       }
-               }
-
-               iter->zone = rcu_dereference(iter->zone->fz_next);
-
-               if (!iter->zone)
-                       goto out;
-
-               iter->bucket = 0;
-               iter->hash_head = rcu_dereference(iter->zone->fz_hash);
-
-               hlist_for_each_entry(fn, node, iter->hash_head, fn_hash) {
-                       list_for_each_entry(fa, &fn->fn_alias, fa_list) {
-                               iter->fn = fn;
-                               iter->fa = fa;
-                               goto out;
-                       }
-               }
-       }
-out:
-       iter->pos++;
-       return fa;
-}
-
-static struct fib_alias *fib_get_idx(struct seq_file *seq, loff_t pos)
-{
-       struct fib_iter_state *iter = seq->private;
-       struct fib_alias *fa;
-
-       if (iter->valid && pos >= iter->pos && iter->genid == fib_hash_genid) {
-               fa   = iter->fa;
-               pos -= iter->pos;
-       } else
-               fa = fib_get_first(seq);
-
-       if (fa)
-               while (pos && (fa = fib_get_next(seq)))
-                       --pos;
-       return pos ? NULL : fa;
-}
-
-static void *fib_seq_start(struct seq_file *seq, loff_t *pos)
-       __acquires(RCU)
-{
-       void *v = NULL;
-
-       rcu_read_lock();
-       if (fib_get_table(seq_file_net(seq), RT_TABLE_MAIN))
-               v = *pos ? fib_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
-       return v;
-}
-
-static void *fib_seq_next(struct seq_file *seq, void *v, loff_t *pos)
-{
-       ++*pos;
-       return v == SEQ_START_TOKEN ? fib_get_first(seq) : fib_get_next(seq);
-}
-
-static void fib_seq_stop(struct seq_file *seq, void *v)
-       __releases(RCU)
-{
-       rcu_read_unlock();
-}
-
-static unsigned fib_flag_trans(int type, __be32 mask, struct fib_info *fi)
-{
-       static const unsigned type2flags[RTN_MAX + 1] = {
-               [7] = RTF_REJECT,
-               [8] = RTF_REJECT,
-       };
-       unsigned flags = type2flags[type];
-
-       if (fi && fi->fib_nh->nh_gw)
-               flags |= RTF_GATEWAY;
-       if (mask == htonl(0xFFFFFFFF))
-               flags |= RTF_HOST;
-       flags |= RTF_UP;
-       return flags;
-}
-
-/*
- *     This outputs /proc/net/route.
- *
- *     It always works in backward compatibility mode.
- *     The format of the file is not supposed to be changed.
- */
-static int fib_seq_show(struct seq_file *seq, void *v)
-{
-       struct fib_iter_state *iter;
-       int len;
-       __be32 prefix, mask;
-       unsigned flags;
-       struct fib_node *f;
-       struct fib_alias *fa;
-       struct fib_info *fi;
-
-       if (v == SEQ_START_TOKEN) {
-               seq_printf(seq, "%-127s\n", "Iface\tDestination\tGateway "
-                          "\tFlags\tRefCnt\tUse\tMetric\tMask\t\tMTU"
-                          "\tWindow\tIRTT");
-               goto out;
-       }
-
-       iter    = seq->private;
-       f       = iter->fn;
-       fa      = iter->fa;
-       fi      = fa->fa_info;
-       prefix  = f->fn_key;
-       mask    = FZ_MASK(iter->zone);
-       flags   = fib_flag_trans(fa->fa_type, mask, fi);
-       if (fi)
-               seq_printf(seq,
-                        "%s\t%08X\t%08X\t%04X\t%d\t%u\t%d\t%08X\t%d\t%u\t%u%n",
-                        fi->fib_dev ? fi->fib_dev->name : "*", prefix,
-                        fi->fib_nh->nh_gw, flags, 0, 0, fi->fib_priority,
-                        mask, (fi->fib_advmss ? fi->fib_advmss + 40 : 0),
-                        fi->fib_window,
-                        fi->fib_rtt >> 3, &len);
-       else
-               seq_printf(seq,
-                        "*\t%08X\t%08X\t%04X\t%d\t%u\t%d\t%08X\t%d\t%u\t%u%n",
-                        prefix, 0, flags, 0, 0, 0, mask, 0, 0, 0, &len);
-
-       seq_printf(seq, "%*s\n", 127 - len, "");
-out:
-       return 0;
-}
-
-static const struct seq_operations fib_seq_ops = {
-       .start  = fib_seq_start,
-       .next   = fib_seq_next,
-       .stop   = fib_seq_stop,
-       .show   = fib_seq_show,
-};
-
-static int fib_seq_open(struct inode *inode, struct file *file)
-{
-       return seq_open_net(inode, file, &fib_seq_ops,
-                           sizeof(struct fib_iter_state));
-}
-
-static const struct file_operations fib_seq_fops = {
-       .owner          = THIS_MODULE,
-       .open           = fib_seq_open,
-       .read           = seq_read,
-       .llseek         = seq_lseek,
-       .release        = seq_release_net,
-};
-
-int __net_init fib_proc_init(struct net *net)
-{
-       if (!proc_net_fops_create(net, "route", S_IRUGO, &fib_seq_fops))
-               return -ENOMEM;
-       return 0;
-}
-
-void __net_exit fib_proc_exit(struct net *net)
-{
-       proc_net_remove(net, "route");
-}
-#endif /* CONFIG_PROC_FS */