2005-06-21 19:43:18 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Robert Olsson <robert.olsson@its.uu.se> Uppsala Universitet
|
|
|
|
* & Swedish University of Agricultural Sciences.
|
|
|
|
*
|
2007-02-09 14:24:47 +00:00
|
|
|
* Jens Laas <jens.laas@data.slu.se> Swedish University of
|
2005-06-21 19:43:18 +00:00
|
|
|
* Agricultural Sciences.
|
2007-02-09 14:24:47 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* Hans Liss <hans.liss@its.uu.se> Uppsala Universitet
|
|
|
|
*
|
2011-03-31 01:57:33 +00:00
|
|
|
* This work is based on the LPC-trie which is originally described in:
|
2007-02-09 14:24:47 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* An experimental study of compression methods for dynamic tries
|
|
|
|
* Stefan Nilsson and Matti Tikkanen. Algorithmica, 33(1):19-33, 2002.
|
2010-10-18 09:03:14 +00:00
|
|
|
* http://www.csc.kth.se/~snilsson/software/dyntrie2/
|
2005-06-21 19:43:18 +00:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IP-address lookup using LC-tries. Stefan Nilsson and Gunnar Karlsson
|
|
|
|
* IEEE Journal on Selected Areas in Communications, 17(6):1083-1092, June 1999
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Code from fib_hash has been reused which includes the following header:
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* 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.
|
2005-12-22 19:25:10 +00:00
|
|
|
*
|
|
|
|
* Substantial contributions to this work comes from:
|
|
|
|
*
|
|
|
|
* David S. Miller, <davem@davemloft.net>
|
|
|
|
* Stephen Hemminger <shemminger@osdl.org>
|
|
|
|
* Paul E. McKenney <paulmck@us.ibm.com>
|
|
|
|
* Patrick McHardy <kaber@trash.net>
|
2005-06-21 19:43:18 +00:00
|
|
|
*/
|
|
|
|
|
2009-08-29 06:57:15 +00:00
|
|
|
#define VERSION "0.409"
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
2007-10-19 06:40:25 +00:00
|
|
|
#include <linux/bitops.h>
|
2005-06-21 19:43:18 +00:00
|
|
|
#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>
|
2006-01-03 22:38:34 +00:00
|
|
|
#include <linux/inetdevice.h>
|
2005-06-21 19:43:18 +00:00
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/proc_fs.h>
|
2005-08-25 20:01:29 +00:00
|
|
|
#include <linux/rcupdate.h>
|
2005-06-21 19:43:18 +00:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netlink.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/list.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-05-22 20:47:17 +00:00
|
|
|
#include <linux/prefetch.h>
|
2011-07-15 15:47:34 +00:00
|
|
|
#include <linux/export.h>
|
2007-09-12 10:01:34 +00:00
|
|
|
#include <net/net_namespace.h>
|
2005-06-21 19:43:18 +00:00
|
|
|
#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"
|
|
|
|
|
2006-03-21 05:35:01 +00:00
|
|
|
#define MAX_STAT_DEPTH 32
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
#define KEYLENGTH (8*sizeof(t_key))
|
|
|
|
|
|
|
|
typedef unsigned int t_key;
|
|
|
|
|
|
|
|
#define T_TNODE 0
|
|
|
|
#define T_LEAF 1
|
|
|
|
#define NODE_TYPE_MASK 0x1UL
|
2005-08-25 20:01:29 +00:00
|
|
|
#define NODE_TYPE(node) ((node)->parent & NODE_TYPE_MASK)
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
#define IS_TNODE(n) (!(n->parent & T_LEAF))
|
|
|
|
#define IS_LEAF(n) (n->parent & T_LEAF)
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node {
|
2005-08-10 03:24:39 +00:00
|
|
|
unsigned long parent;
|
2008-01-14 06:31:44 +00:00
|
|
|
t_key key;
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct leaf {
|
2005-08-10 03:24:39 +00:00
|
|
|
unsigned long parent;
|
2008-01-14 06:31:44 +00:00
|
|
|
t_key key;
|
2005-06-21 19:43:18 +00:00
|
|
|
struct hlist_head list;
|
2005-08-25 20:01:29 +00:00
|
|
|
struct rcu_head rcu;
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct leaf_info {
|
|
|
|
struct hlist_node hlist;
|
|
|
|
int plen;
|
2011-07-18 03:16:33 +00:00
|
|
|
u32 mask_plen; /* ntohl(inet_make_mask(plen)) */
|
2005-06-21 19:43:18 +00:00
|
|
|
struct list_head falh;
|
2011-07-18 03:16:33 +00:00
|
|
|
struct rcu_head rcu;
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct tnode {
|
2005-08-10 03:24:39 +00:00
|
|
|
unsigned long parent;
|
2008-01-14 06:31:44 +00:00
|
|
|
t_key key;
|
2008-01-13 05:27:41 +00:00
|
|
|
unsigned char pos; /* 2log(KEYLENGTH) bits needed */
|
|
|
|
unsigned char bits; /* 2log(KEYLENGTH) bits needed */
|
2008-01-14 06:31:44 +00:00
|
|
|
unsigned int full_children; /* KEYLENGTH bits needed */
|
|
|
|
unsigned int empty_children; /* KEYLENGTH bits needed */
|
2008-04-10 09:56:38 +00:00
|
|
|
union {
|
|
|
|
struct rcu_head rcu;
|
|
|
|
struct work_struct work;
|
2009-06-15 09:31:29 +00:00
|
|
|
struct tnode *tnode_free;
|
2008-04-10 09:56:38 +00:00
|
|
|
};
|
2011-03-31 08:51:35 +00:00
|
|
|
struct rt_trie_node __rcu *child[0];
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
struct trie_use_stats {
|
|
|
|
unsigned int gets;
|
|
|
|
unsigned int backtrack;
|
|
|
|
unsigned int semantic_match_passed;
|
|
|
|
unsigned int semantic_match_miss;
|
|
|
|
unsigned int null_node_hit;
|
2005-07-05 22:02:40 +00:00
|
|
|
unsigned int resize_node_skipped;
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct trie_stat {
|
|
|
|
unsigned int totdepth;
|
|
|
|
unsigned int maxdepth;
|
|
|
|
unsigned int tnodes;
|
|
|
|
unsigned int leaves;
|
|
|
|
unsigned int nullpointers;
|
2008-01-23 05:54:05 +00:00
|
|
|
unsigned int prefixes;
|
2006-03-21 05:35:01 +00:00
|
|
|
unsigned int nodesizes[MAX_STAT_DEPTH];
|
2005-07-19 21:01:51 +00:00
|
|
|
};
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
struct trie {
|
2011-03-31 08:51:35 +00:00
|
|
|
struct rt_trie_node __rcu *trie;
|
2005-06-21 19:43:18 +00:00
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
struct trie_use_stats stats;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
static void put_child(struct trie *t, struct tnode *tn, int i, struct rt_trie_node *n);
|
|
|
|
static void tnode_put_child_reorg(struct tnode *tn, int i, struct rt_trie_node *n,
|
2008-01-23 05:53:36 +00:00
|
|
|
int wasfull);
|
2011-02-03 04:48:10 +00:00
|
|
|
static struct rt_trie_node *resize(struct trie *t, struct tnode *tn);
|
2005-08-10 03:25:06 +00:00
|
|
|
static struct tnode *inflate(struct trie *t, struct tnode *tn);
|
|
|
|
static struct tnode *halve(struct trie *t, struct tnode *tn);
|
2009-06-15 09:31:29 +00:00
|
|
|
/* tnodes to free after resize(); protected by RTNL */
|
|
|
|
static struct tnode *tnode_free_head;
|
2009-07-14 08:33:08 +00:00
|
|
|
static size_t tnode_free_size;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* synchronize_rcu after call_rcu for that many pages; it should be especially
|
|
|
|
* useful before resizing the root node with PREEMPT_NONE configs; the value was
|
|
|
|
* obtained experimentally, aiming to avoid visible slowdown.
|
|
|
|
*/
|
|
|
|
static const int sync_pages = 128;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2006-12-07 04:33:20 +00:00
|
|
|
static struct kmem_cache *fn_alias_kmem __read_mostly;
|
2008-01-23 05:51:50 +00:00
|
|
|
static struct kmem_cache *trie_leaf_kmem __read_mostly;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
/*
|
|
|
|
* caller must hold RTNL
|
|
|
|
*/
|
|
|
|
static inline struct tnode *node_parent(const struct rt_trie_node *node)
|
2007-08-10 22:22:13 +00:00
|
|
|
{
|
2011-03-31 08:51:35 +00:00
|
|
|
unsigned long parent;
|
|
|
|
|
|
|
|
parent = rcu_dereference_index_check(node->parent, lockdep_rtnl_is_held());
|
|
|
|
|
|
|
|
return (struct tnode *)(parent & ~NODE_TYPE_MASK);
|
2008-01-18 11:31:36 +00:00
|
|
|
}
|
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
/*
|
|
|
|
* caller must hold RCU read lock or RTNL
|
|
|
|
*/
|
|
|
|
static inline struct tnode *node_parent_rcu(const struct rt_trie_node *node)
|
2008-01-18 11:31:36 +00:00
|
|
|
{
|
2011-03-31 08:51:35 +00:00
|
|
|
unsigned long parent;
|
|
|
|
|
|
|
|
parent = rcu_dereference_index_check(node->parent, rcu_read_lock_held() ||
|
|
|
|
lockdep_rtnl_is_held());
|
2007-08-10 22:22:13 +00:00
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
return (struct tnode *)(parent & ~NODE_TYPE_MASK);
|
2007-08-10 22:22:13 +00:00
|
|
|
}
|
|
|
|
|
2012-01-12 04:41:32 +00:00
|
|
|
/* Same as rcu_assign_pointer
|
2008-03-23 00:59:58 +00:00
|
|
|
* but that macro() assumes that value is a pointer.
|
|
|
|
*/
|
2011-02-03 04:48:10 +00:00
|
|
|
static inline void node_set_parent(struct rt_trie_node *node, struct tnode *ptr)
|
2007-08-10 22:22:13 +00:00
|
|
|
{
|
2008-03-23 00:59:58 +00:00
|
|
|
smp_wmb();
|
|
|
|
node->parent = (unsigned long)ptr | NODE_TYPE(node);
|
2007-08-10 22:22:13 +00:00
|
|
|
}
|
2005-08-25 20:01:29 +00:00
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
/*
|
|
|
|
* caller must hold RTNL
|
|
|
|
*/
|
|
|
|
static inline struct rt_trie_node *tnode_get_child(const struct tnode *tn, unsigned int i)
|
2008-01-18 11:31:36 +00:00
|
|
|
{
|
|
|
|
BUG_ON(i >= 1U << tn->bits);
|
2005-08-25 20:01:29 +00:00
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
return rtnl_dereference(tn->child[i]);
|
2008-01-18 11:31:36 +00:00
|
|
|
}
|
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
/*
|
|
|
|
* caller must hold RCU read lock or RTNL
|
|
|
|
*/
|
|
|
|
static inline struct rt_trie_node *tnode_get_child_rcu(const struct tnode *tn, unsigned int i)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2011-03-31 08:51:35 +00:00
|
|
|
BUG_ON(i >= 1U << tn->bits);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
return rcu_dereference_rtnl(tn->child[i]);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-08-10 03:25:39 +00:00
|
|
|
static inline int tnode_child_length(const struct tnode *tn)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-08-10 03:24:39 +00:00
|
|
|
return 1 << tn->bits;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2011-02-16 22:56:22 +00:00
|
|
|
static inline t_key mask_pfx(t_key k, unsigned int l)
|
2007-08-10 22:22:58 +00:00
|
|
|
{
|
|
|
|
return (l == 0) ? 0 : k >> (KEYLENGTH-l) << (KEYLENGTH-l);
|
|
|
|
}
|
|
|
|
|
2011-02-16 22:56:22 +00:00
|
|
|
static inline t_key tkey_extract_bits(t_key a, unsigned int offset, unsigned int bits)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-08-10 03:24:39 +00:00
|
|
|
if (offset < KEYLENGTH)
|
2005-06-21 19:43:18 +00:00
|
|
|
return ((t_key)(a << offset)) >> (KEYLENGTH - bits);
|
2005-08-10 03:24:39 +00:00
|
|
|
else
|
2005-06-21 19:43:18 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tkey_equals(t_key a, t_key b)
|
|
|
|
{
|
2005-07-19 21:01:51 +00:00
|
|
|
return a == b;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tkey_sub_equals(t_key a, int offset, int bits, t_key b)
|
|
|
|
{
|
2005-07-19 21:01:51 +00:00
|
|
|
if (bits == 0 || offset >= KEYLENGTH)
|
|
|
|
return 1;
|
2005-08-10 03:24:39 +00:00
|
|
|
bits = bits > KEYLENGTH ? KEYLENGTH : bits;
|
|
|
|
return ((a ^ b) << offset) >> (KEYLENGTH - bits) == 0;
|
2005-07-19 21:01:51 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
static inline int tkey_mismatch(t_key a, int offset, t_key b)
|
|
|
|
{
|
|
|
|
t_key diff = a ^ b;
|
|
|
|
int i = offset;
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (!diff)
|
|
|
|
return 0;
|
|
|
|
while ((diff << i) >> (KEYLENGTH-1) == 0)
|
2005-06-21 19:43:18 +00:00
|
|
|
i++;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-02-09 14:24:47 +00:00
|
|
|
To understand this stuff, an understanding of keys and all their bits is
|
|
|
|
necessary. Every node in the trie has a key associated with it, but not
|
2005-06-21 19:43:18 +00:00
|
|
|
all of the bits in that key are significant.
|
|
|
|
|
|
|
|
Consider a node 'n' and its parent 'tp'.
|
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
If n is a leaf, every bit in its key is significant. Its presence is
|
|
|
|
necessitated by path compression, since during a tree traversal (when
|
|
|
|
searching for a leaf - unless we are doing an insertion) we will completely
|
|
|
|
ignore all skipped bits we encounter. Thus we need to verify, at the end of
|
|
|
|
a potentially successful search, that we have indeed been walking the
|
2005-06-21 19:43:18 +00:00
|
|
|
correct key path.
|
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
Note that we can never "miss" the correct key in the tree if present by
|
|
|
|
following the wrong path. Path compression ensures that segments of the key
|
|
|
|
that are the same for all keys with a given prefix are skipped, but the
|
|
|
|
skipped part *is* identical for each node in the subtrie below the skipped
|
|
|
|
bit! trie_insert() in this implementation takes care of that - note the
|
2005-06-21 19:43:18 +00:00
|
|
|
call to tkey_sub_equals() in trie_insert().
|
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
if n is an internal node - a 'tnode' here, the various parts of its key
|
2005-06-21 19:43:18 +00:00
|
|
|
have many different meanings.
|
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
Example:
|
2005-06-21 19:43:18 +00:00
|
|
|
_________________________________________________________________
|
|
|
|
| i | i | i | i | i | i | i | N | N | N | S | S | S | S | S | C |
|
|
|
|
-----------------------------------------------------------------
|
2007-02-09 14:24:47 +00:00
|
|
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
_________________________________________________________________
|
|
|
|
| C | C | C | u | u | u | u | u | u | u | u | u | u | u | u | u |
|
|
|
|
-----------------------------------------------------------------
|
|
|
|
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
|
|
|
|
|
|
|
|
tp->pos = 7
|
|
|
|
tp->bits = 3
|
|
|
|
n->pos = 15
|
2005-08-10 03:24:39 +00:00
|
|
|
n->bits = 4
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
First, let's just ignore the bits that come before the parent tp, that is
|
|
|
|
the bits from 0 to (tp->pos-1). They are *known* but at this point we do
|
2005-06-21 19:43:18 +00:00
|
|
|
not use them for anything.
|
|
|
|
|
|
|
|
The bits from (tp->pos) to (tp->pos + tp->bits - 1) - "N", above - are the
|
2007-02-09 14:24:47 +00:00
|
|
|
index into the parent's child array. That is, they will be used to find
|
2005-06-21 19:43:18 +00:00
|
|
|
'n' among tp's children.
|
|
|
|
|
|
|
|
The bits from (tp->pos + tp->bits) to (n->pos - 1) - "S" - are skipped bits
|
|
|
|
for the node n.
|
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
All the bits we have seen so far are significant to the node n. The rest
|
2005-06-21 19:43:18 +00:00
|
|
|
of the bits are really not needed or indeed known in n->key.
|
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
The bits from (n->pos) to (n->pos + n->bits - 1) - "C" - are the index into
|
2005-06-21 19:43:18 +00:00
|
|
|
n's child array, and will of course be different for each child.
|
2007-02-09 14:24:47 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
The rest of the bits, from (n->pos + n->bits) onward, are completely unknown
|
|
|
|
at this point.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2005-08-24 04:59:41 +00:00
|
|
|
static inline void check_tnode(const struct tnode *tn)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-08-24 04:59:41 +00:00
|
|
|
WARN_ON(tn && tn->pos+tn->bits > 32);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2007-12-13 17:47:57 +00:00
|
|
|
static const int halve_threshold = 25;
|
|
|
|
static const int inflate_threshold = 50;
|
ipv4: Fix fib_trie rebalancing, part 4 (root thresholds)
Pawel Staszewski wrote:
<blockquote>
Some time ago i report this:
http://bugzilla.kernel.org/show_bug.cgi?id=6648
and now with 2.6.29 / 2.6.29.1 / 2.6.29.3 and 2.6.30 it back
dmesg output:
oprofile: using NMI interrupt.
Fix inflate_threshold_root. Now=15 size=11 bits
...
Fix inflate_threshold_root. Now=15 size=11 bits
cat /proc/net/fib_triestat
Basic info: size of leaf: 40 bytes, size of tnode: 56 bytes.
Main:
Aver depth: 2.28
Max depth: 6
Leaves: 276539
Prefixes: 289922
Internal nodes: 66762
1: 35046 2: 13824 3: 9508 4: 4897 5: 2331 6: 1149 7: 5
9: 1 18: 1
Pointers: 691228
Null ptrs: 347928
Total size: 35709 kB
</blockquote>
It seems, the current threshold for root resizing is too aggressive,
and it causes misleading warnings during big updates, but it might be
also responsible for memory problems, especially with non-preempt
configs, when RCU freeing is delayed long after call_rcu.
It should be also mentioned that because of non-atomic changes during
resizing/rebalancing the current lookup algorithm can miss valid leaves
so it's additional argument to shorten these activities even at a cost
of a minimally longer searching.
This patch restores values before the patch "[IPV4]: fib_trie root
node settings", commit: 965ffea43d4ebe8cd7b9fee78d651268dd7d23c5 from
v2.6.22.
Pawel's report:
<blockquote>
I dont see any big change of (cpu load or faster/slower
routing/propagating routes from bgpd or something else) - in avg there
is from 2% to 3% more of CPU load i dont know why but it is - i change
from "preempt" to "no preempt" 3 times and check this my "mpstat -P ALL
1 30"
always avg cpu load was from 2 to 3% more compared to "no preempt"
[...]
cat /proc/net/fib_triestat
Basic info: size of leaf: 20 bytes, size of tnode: 36 bytes.
Main:
Aver depth: 2.44
Max depth: 6
Leaves: 277814
Prefixes: 291306
Internal nodes: 66420
1: 32737 2: 14850 3: 10332 4: 4871 5: 2313 6: 942 7: 371 8: 3 17: 1
Pointers: 599098
Null ptrs: 254865
Total size: 18067 kB
</blockquote>
According to this and other similar reports average depth is slightly
increased (~0.2), and root nodes are shorter (log 17 vs. 18), but
there is no visible performance decrease. So, until memory handling is
improved or added parameters for changing this individually, this
patch resets to safer defaults.
Reported-by: Pawel Staszewski <pstaszewski@itcare.pl>
Reported-by: Jorge Boncompte [DTI2] <jorge@dti2.net>
Signed-off-by: Jarek Poplawski <jarkao2@gmail.com>
Tested-by: Pawel Staszewski <pstaszewski@itcare.pl>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-08 02:39:16 +00:00
|
|
|
static const int halve_threshold_root = 15;
|
2009-08-29 06:57:15 +00:00
|
|
|
static const int inflate_threshold_root = 30;
|
2005-08-25 20:01:29 +00:00
|
|
|
|
|
|
|
static void __alias_free_mem(struct rcu_head *head)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-08-25 20:01:29 +00:00
|
|
|
struct fib_alias *fa = container_of(head, struct fib_alias, rcu);
|
|
|
|
kmem_cache_free(fn_alias_kmem, fa);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
static inline void alias_free_mem_rcu(struct fib_alias *fa)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-08-25 20:01:29 +00:00
|
|
|
call_rcu(&fa->rcu, __alias_free_mem);
|
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
static void __leaf_free_rcu(struct rcu_head *head)
|
|
|
|
{
|
2008-01-23 05:51:50 +00:00
|
|
|
struct leaf *l = container_of(head, struct leaf, rcu);
|
|
|
|
kmem_cache_free(trie_leaf_kmem, l);
|
2005-08-25 20:01:29 +00:00
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2008-04-10 10:47:34 +00:00
|
|
|
static inline void free_leaf(struct leaf *l)
|
|
|
|
{
|
|
|
|
call_rcu_bh(&l->rcu, __leaf_free_rcu);
|
|
|
|
}
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
static inline void free_leaf_info(struct leaf_info *leaf)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2011-03-18 03:42:34 +00:00
|
|
|
kfree_rcu(leaf, rcu);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2008-01-14 06:31:44 +00:00
|
|
|
static struct tnode *tnode_alloc(size_t size)
|
2005-07-05 21:44:55 +00:00
|
|
|
{
|
2005-08-25 20:01:29 +00:00
|
|
|
if (size <= PAGE_SIZE)
|
2008-01-14 06:31:44 +00:00
|
|
|
return kzalloc(size, GFP_KERNEL);
|
2008-04-10 09:56:38 +00:00
|
|
|
else
|
2010-11-20 07:46:35 +00:00
|
|
|
return vzalloc(size);
|
2008-04-10 09:56:38 +00:00
|
|
|
}
|
2005-08-25 20:01:29 +00:00
|
|
|
|
2008-04-10 09:56:38 +00:00
|
|
|
static void __tnode_vfree(struct work_struct *arg)
|
|
|
|
{
|
|
|
|
struct tnode *tn = container_of(arg, struct tnode, work);
|
|
|
|
vfree(tn);
|
2005-07-05 21:44:55 +00:00
|
|
|
}
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
static void __tnode_free_rcu(struct rcu_head *head)
|
2005-07-05 21:44:55 +00:00
|
|
|
{
|
2005-08-25 20:01:29 +00:00
|
|
|
struct tnode *tn = container_of(head, struct tnode, rcu);
|
2008-01-14 06:31:44 +00:00
|
|
|
size_t size = sizeof(struct tnode) +
|
2011-02-03 04:48:10 +00:00
|
|
|
(sizeof(struct rt_trie_node *) << tn->bits);
|
2005-07-05 21:44:55 +00:00
|
|
|
|
|
|
|
if (size <= PAGE_SIZE)
|
|
|
|
kfree(tn);
|
2008-04-10 09:56:38 +00:00
|
|
|
else {
|
|
|
|
INIT_WORK(&tn->work, __tnode_vfree);
|
|
|
|
schedule_work(&tn->work);
|
|
|
|
}
|
2005-07-05 21:44:55 +00:00
|
|
|
}
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
static inline void tnode_free(struct tnode *tn)
|
|
|
|
{
|
2008-04-10 10:47:34 +00:00
|
|
|
if (IS_LEAF(tn))
|
|
|
|
free_leaf((struct leaf *) tn);
|
|
|
|
else
|
2006-04-04 19:53:35 +00:00
|
|
|
call_rcu(&tn->rcu, __tnode_free_rcu);
|
2005-08-25 20:01:29 +00:00
|
|
|
}
|
|
|
|
|
2009-06-15 09:31:29 +00:00
|
|
|
static void tnode_free_safe(struct tnode *tn)
|
|
|
|
{
|
|
|
|
BUG_ON(IS_LEAF(tn));
|
2009-06-18 07:28:51 +00:00
|
|
|
tn->tnode_free = tnode_free_head;
|
|
|
|
tnode_free_head = tn;
|
2009-07-14 08:33:08 +00:00
|
|
|
tnode_free_size += sizeof(struct tnode) +
|
2011-02-03 04:48:10 +00:00
|
|
|
(sizeof(struct rt_trie_node *) << tn->bits);
|
2009-06-15 09:31:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void tnode_free_flush(void)
|
|
|
|
{
|
|
|
|
struct tnode *tn;
|
|
|
|
|
|
|
|
while ((tn = tnode_free_head)) {
|
|
|
|
tnode_free_head = tn->tnode_free;
|
|
|
|
tn->tnode_free = NULL;
|
|
|
|
tnode_free(tn);
|
|
|
|
}
|
2009-07-14 08:33:08 +00:00
|
|
|
|
|
|
|
if (tnode_free_size >= PAGE_SIZE * sync_pages) {
|
|
|
|
tnode_free_size = 0;
|
|
|
|
synchronize_rcu();
|
|
|
|
}
|
2009-06-15 09:31:29 +00:00
|
|
|
}
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
static struct leaf *leaf_new(void)
|
|
|
|
{
|
2008-01-23 05:51:50 +00:00
|
|
|
struct leaf *l = kmem_cache_alloc(trie_leaf_kmem, GFP_KERNEL);
|
2005-08-25 20:01:29 +00:00
|
|
|
if (l) {
|
|
|
|
l->parent = T_LEAF;
|
|
|
|
INIT_HLIST_HEAD(&l->list);
|
|
|
|
}
|
|
|
|
return l;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct leaf_info *leaf_info_new(int plen)
|
|
|
|
{
|
|
|
|
struct leaf_info *li = kmalloc(sizeof(struct leaf_info), GFP_KERNEL);
|
|
|
|
if (li) {
|
|
|
|
li->plen = plen;
|
2011-07-18 03:16:33 +00:00
|
|
|
li->mask_plen = ntohl(inet_make_mask(plen));
|
2005-08-25 20:01:29 +00:00
|
|
|
INIT_LIST_HEAD(&li->falh);
|
|
|
|
}
|
|
|
|
return li;
|
|
|
|
}
|
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
static struct tnode *tnode_new(t_key key, int pos, int bits)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2011-02-03 04:48:10 +00:00
|
|
|
size_t sz = sizeof(struct tnode) + (sizeof(struct rt_trie_node *) << bits);
|
2005-07-05 21:44:55 +00:00
|
|
|
struct tnode *tn = tnode_alloc(sz);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (tn) {
|
2005-08-25 20:01:29 +00:00
|
|
|
tn->parent = T_TNODE;
|
2005-06-21 19:43:18 +00:00
|
|
|
tn->pos = pos;
|
|
|
|
tn->bits = bits;
|
|
|
|
tn->key = key;
|
|
|
|
tn->full_children = 0;
|
|
|
|
tn->empty_children = 1<<bits;
|
|
|
|
}
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2010-09-09 23:32:28 +00:00
|
|
|
pr_debug("AT %p s=%zu %zu\n", tn, sizeof(struct tnode),
|
2011-02-03 04:48:10 +00:00
|
|
|
sizeof(struct rt_trie_node) << bits);
|
2005-06-21 19:43:18 +00:00
|
|
|
return tn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether a tnode 'n' is "full", i.e. it is an internal node
|
|
|
|
* and no bits are skipped. See discussion in dyntree paper p. 6
|
|
|
|
*/
|
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
static inline int tnode_full(const struct tnode *tn, const struct rt_trie_node *n)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-07-19 21:01:51 +00:00
|
|
|
if (n == NULL || IS_LEAF(n))
|
2005-06-21 19:43:18 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return ((struct tnode *) n)->pos == tn->pos + tn->bits;
|
|
|
|
}
|
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
static inline void put_child(struct trie *t, struct tnode *tn, int i,
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
tnode_put_child_reorg(tn, i, n, -1);
|
|
|
|
}
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
/*
|
2005-06-21 19:43:18 +00:00
|
|
|
* Add a child at position i overwriting the old value.
|
|
|
|
* Update the value of full_children and empty_children.
|
|
|
|
*/
|
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
static void tnode_put_child_reorg(struct tnode *tn, int i, struct rt_trie_node *n,
|
2008-01-23 05:53:36 +00:00
|
|
|
int wasfull)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2011-03-31 08:51:35 +00:00
|
|
|
struct rt_trie_node *chi = rtnl_dereference(tn->child[i]);
|
2005-06-21 19:43:18 +00:00
|
|
|
int isfull;
|
|
|
|
|
2005-08-24 04:59:41 +00:00
|
|
|
BUG_ON(i >= 1<<tn->bits);
|
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* update emptyChildren */
|
|
|
|
if (n == NULL && chi != NULL)
|
|
|
|
tn->empty_children++;
|
|
|
|
else if (n != NULL && chi == NULL)
|
|
|
|
tn->empty_children--;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* update fullChildren */
|
2005-08-10 03:24:39 +00:00
|
|
|
if (wasfull == -1)
|
2005-06-21 19:43:18 +00:00
|
|
|
wasfull = tnode_full(tn, chi);
|
|
|
|
|
|
|
|
isfull = tnode_full(tn, n);
|
2005-07-19 21:01:51 +00:00
|
|
|
if (wasfull && !isfull)
|
2005-06-21 19:43:18 +00:00
|
|
|
tn->full_children--;
|
2005-07-19 21:01:51 +00:00
|
|
|
else if (!wasfull && isfull)
|
2005-06-21 19:43:18 +00:00
|
|
|
tn->full_children++;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (n)
|
2007-08-10 22:22:13 +00:00
|
|
|
node_set_parent(n, tn);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2012-01-12 04:41:32 +00:00
|
|
|
rcu_assign_pointer(tn->child[i], n);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2009-08-29 06:57:15 +00:00
|
|
|
#define MAX_WORK 10
|
2011-02-03 04:48:10 +00:00
|
|
|
static struct rt_trie_node *resize(struct trie *t, struct tnode *tn)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
int i;
|
2005-08-10 03:25:06 +00:00
|
|
|
struct tnode *old_tn;
|
2005-10-04 20:01:58 +00:00
|
|
|
int inflate_threshold_use;
|
|
|
|
int halve_threshold_use;
|
2009-08-29 06:57:15 +00:00
|
|
|
int max_work;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
if (!tn)
|
2005-06-21 19:43:18 +00:00
|
|
|
return NULL;
|
|
|
|
|
2005-08-24 04:59:41 +00:00
|
|
|
pr_debug("In tnode_resize %p inflate_threshold=%d threshold=%d\n",
|
|
|
|
tn, inflate_threshold, halve_threshold);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
/* No children */
|
|
|
|
if (tn->empty_children == tnode_child_length(tn)) {
|
2009-06-15 09:31:29 +00:00
|
|
|
tnode_free_safe(tn);
|
2005-06-21 19:43:18 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* One child */
|
|
|
|
if (tn->empty_children == tnode_child_length(tn) - 1)
|
2009-08-29 06:57:15 +00:00
|
|
|
goto one_child;
|
2005-07-19 21:01:51 +00:00
|
|
|
/*
|
2005-06-21 19:43:18 +00:00
|
|
|
* Double as long as the resulting node has a number of
|
|
|
|
* nonempty nodes that are above the threshold.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2005-07-19 21:01:51 +00:00
|
|
|
* From "Implementing a dynamic compressed trie" by Stefan Nilsson of
|
|
|
|
* the Helsinki University of Technology and Matti Tikkanen of Nokia
|
2005-06-21 19:43:18 +00:00
|
|
|
* Telecommunications, page 6:
|
2005-07-19 21:01:51 +00:00
|
|
|
* "A node is doubled if the ratio of non-empty children to all
|
2005-06-21 19:43:18 +00:00
|
|
|
* children in the *doubled* node is at least 'high'."
|
|
|
|
*
|
2005-07-19 21:01:51 +00:00
|
|
|
* 'high' in this instance is the variable 'inflate_threshold'. It
|
|
|
|
* is expressed as a percentage, so we multiply it with
|
|
|
|
* tnode_child_length() and instead of multiplying by 2 (since the
|
|
|
|
* child array will be doubled by inflate()) and multiplying
|
|
|
|
* the left-hand side by 100 (to handle the percentage thing) we
|
2005-06-21 19:43:18 +00:00
|
|
|
* multiply the left-hand side by 50.
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
|
|
|
* The left-hand side may look a bit weird: tnode_child_length(tn)
|
|
|
|
* - tn->empty_children is of course the number of non-null children
|
|
|
|
* in the current node. tn->full_children is the number of "full"
|
2005-06-21 19:43:18 +00:00
|
|
|
* children, that is non-null tnodes with a skip value of 0.
|
2005-07-19 21:01:51 +00:00
|
|
|
* All of those will be doubled in the resulting inflated tnode, so
|
2005-06-21 19:43:18 +00:00
|
|
|
* we just count them one extra time here.
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* A clearer way to write this would be:
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* to_be_doubled = tn->full_children;
|
2005-07-19 21:01:51 +00:00
|
|
|
* not_to_be_doubled = tnode_child_length(tn) - tn->empty_children -
|
2005-06-21 19:43:18 +00:00
|
|
|
* tn->full_children;
|
|
|
|
*
|
|
|
|
* new_child_length = tnode_child_length(tn) * 2;
|
|
|
|
*
|
2005-07-19 21:01:51 +00:00
|
|
|
* new_fill_factor = 100 * (not_to_be_doubled + 2*to_be_doubled) /
|
2005-06-21 19:43:18 +00:00
|
|
|
* new_child_length;
|
|
|
|
* if (new_fill_factor >= inflate_threshold)
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
|
|
|
* ...and so on, tho it would mess up the while () loop.
|
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* anyway,
|
|
|
|
* 100 * (not_to_be_doubled + 2*to_be_doubled) / new_child_length >=
|
|
|
|
* inflate_threshold
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* avoid a division:
|
|
|
|
* 100 * (not_to_be_doubled + 2*to_be_doubled) >=
|
|
|
|
* inflate_threshold * new_child_length
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* expand not_to_be_doubled and to_be_doubled, and shorten:
|
2005-07-19 21:01:51 +00:00
|
|
|
* 100 * (tnode_child_length(tn) - tn->empty_children +
|
2005-08-10 03:24:39 +00:00
|
|
|
* tn->full_children) >= inflate_threshold * new_child_length
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* expand new_child_length:
|
2005-07-19 21:01:51 +00:00
|
|
|
* 100 * (tnode_child_length(tn) - tn->empty_children +
|
2005-08-10 03:24:39 +00:00
|
|
|
* tn->full_children) >=
|
2005-06-21 19:43:18 +00:00
|
|
|
* inflate_threshold * tnode_child_length(tn) * 2
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
* shorten again:
|
2005-07-19 21:01:51 +00:00
|
|
|
* 50 * (tn->full_children + tnode_child_length(tn) -
|
2005-08-10 03:24:39 +00:00
|
|
|
* tn->empty_children) >= inflate_threshold *
|
2005-06-21 19:43:18 +00:00
|
|
|
* tnode_child_length(tn)
|
2005-07-19 21:01:51 +00:00
|
|
|
*
|
2005-06-21 19:43:18 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
check_tnode(tn);
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-10-04 20:01:58 +00:00
|
|
|
/* Keep root node larger */
|
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
if (!node_parent((struct rt_trie_node *)tn)) {
|
2009-08-29 06:57:15 +00:00
|
|
|
inflate_threshold_use = inflate_threshold_root;
|
|
|
|
halve_threshold_use = halve_threshold_root;
|
2010-09-09 23:32:28 +00:00
|
|
|
} else {
|
2005-10-04 20:01:58 +00:00
|
|
|
inflate_threshold_use = inflate_threshold;
|
2009-08-29 06:57:15 +00:00
|
|
|
halve_threshold_use = halve_threshold;
|
|
|
|
}
|
2005-10-04 20:01:58 +00:00
|
|
|
|
2009-08-29 06:57:15 +00:00
|
|
|
max_work = MAX_WORK;
|
|
|
|
while ((tn->full_children > 0 && max_work-- &&
|
2008-01-23 05:53:36 +00:00
|
|
|
50 * (tn->full_children + tnode_child_length(tn)
|
|
|
|
- tn->empty_children)
|
|
|
|
>= inflate_threshold_use * tnode_child_length(tn))) {
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:25:06 +00:00
|
|
|
old_tn = tn;
|
|
|
|
tn = inflate(t, tn);
|
2008-01-23 05:53:36 +00:00
|
|
|
|
2005-08-10 03:25:06 +00:00
|
|
|
if (IS_ERR(tn)) {
|
|
|
|
tn = old_tn;
|
2005-07-05 22:02:40 +00:00
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
t->stats.resize_node_skipped++;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
check_tnode(tn);
|
|
|
|
|
2009-08-29 06:57:15 +00:00
|
|
|
/* Return if at least one inflate is run */
|
2010-09-09 23:32:28 +00:00
|
|
|
if (max_work != MAX_WORK)
|
2011-02-03 04:48:10 +00:00
|
|
|
return (struct rt_trie_node *) tn;
|
2009-08-29 06:57:15 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/*
|
|
|
|
* Halve as long as the number of empty children in this
|
|
|
|
* node is above threshold.
|
|
|
|
*/
|
2005-07-05 22:02:40 +00:00
|
|
|
|
2009-08-29 06:57:15 +00:00
|
|
|
max_work = MAX_WORK;
|
|
|
|
while (tn->bits > 1 && max_work-- &&
|
2005-06-21 19:43:18 +00:00
|
|
|
100 * (tnode_child_length(tn) - tn->empty_children) <
|
2005-10-04 20:01:58 +00:00
|
|
|
halve_threshold_use * tnode_child_length(tn)) {
|
2005-07-05 22:02:40 +00:00
|
|
|
|
2005-08-10 03:25:06 +00:00
|
|
|
old_tn = tn;
|
|
|
|
tn = halve(t, tn);
|
|
|
|
if (IS_ERR(tn)) {
|
|
|
|
tn = old_tn;
|
2005-07-05 22:02:40 +00:00
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
t->stats.resize_node_skipped++;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* Only one child remains */
|
2009-08-29 06:57:15 +00:00
|
|
|
if (tn->empty_children == tnode_child_length(tn) - 1) {
|
|
|
|
one_child:
|
2005-06-21 19:43:18 +00:00
|
|
|
for (i = 0; i < tnode_child_length(tn); i++) {
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
n = rtnl_dereference(tn->child[i]);
|
2005-08-25 20:01:29 +00:00
|
|
|
if (!n)
|
2005-08-10 03:24:39 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* compress one level */
|
|
|
|
|
2007-08-10 22:22:13 +00:00
|
|
|
node_set_parent(n, NULL);
|
2009-06-15 09:31:29 +00:00
|
|
|
tnode_free_safe(tn);
|
2005-08-10 03:24:39 +00:00
|
|
|
return n;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2009-08-29 06:57:15 +00:00
|
|
|
}
|
2011-02-03 04:48:10 +00:00
|
|
|
return (struct rt_trie_node *) tn;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2011-03-31 08:51:35 +00:00
|
|
|
|
|
|
|
static void tnode_clean_free(struct tnode *tn)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct tnode *tofree;
|
|
|
|
|
|
|
|
for (i = 0; i < tnode_child_length(tn); i++) {
|
|
|
|
tofree = (struct tnode *)rtnl_dereference(tn->child[i]);
|
|
|
|
if (tofree)
|
|
|
|
tnode_free(tofree);
|
|
|
|
}
|
|
|
|
tnode_free(tn);
|
|
|
|
}
|
|
|
|
|
2005-08-10 03:25:06 +00:00
|
|
|
static struct tnode *inflate(struct trie *t, struct tnode *tn)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct tnode *oldtnode = tn;
|
|
|
|
int olen = tnode_child_length(tn);
|
|
|
|
int i;
|
|
|
|
|
2005-08-24 04:59:41 +00:00
|
|
|
pr_debug("In inflate\n");
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
tn = tnode_new(oldtnode->key, oldtnode->pos, oldtnode->bits + 1);
|
|
|
|
|
2005-08-24 04:59:41 +00:00
|
|
|
if (!tn)
|
2005-08-10 03:25:06 +00:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-07-05 22:02:40 +00:00
|
|
|
|
|
|
|
/*
|
2005-07-19 21:01:51 +00:00
|
|
|
* Preallocate and store tnodes before the actual work so we
|
|
|
|
* don't get into an inconsistent state if memory allocation
|
|
|
|
* fails. In case of failure we return the oldnode and inflate
|
2005-07-05 22:02:40 +00:00
|
|
|
* of tnode is ignored.
|
|
|
|
*/
|
2005-08-10 03:24:39 +00:00
|
|
|
|
|
|
|
for (i = 0; i < olen; i++) {
|
2008-01-23 05:53:36 +00:00
|
|
|
struct tnode *inode;
|
2005-07-05 22:02:40 +00:00
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
inode = (struct tnode *) tnode_get_child(oldtnode, i);
|
2005-07-05 22:02:40 +00:00
|
|
|
if (inode &&
|
|
|
|
IS_TNODE(inode) &&
|
|
|
|
inode->pos == oldtnode->pos + oldtnode->bits &&
|
|
|
|
inode->bits > 1) {
|
|
|
|
struct tnode *left, *right;
|
2007-08-10 22:22:58 +00:00
|
|
|
t_key m = ~0U << (KEYLENGTH - 1) >> inode->pos;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-07-05 22:02:40 +00:00
|
|
|
left = tnode_new(inode->key&(~m), inode->pos + 1,
|
|
|
|
inode->bits - 1);
|
2005-08-10 03:25:06 +00:00
|
|
|
if (!left)
|
|
|
|
goto nomem;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-07-05 22:02:40 +00:00
|
|
|
right = tnode_new(inode->key|m, inode->pos + 1,
|
|
|
|
inode->bits - 1);
|
|
|
|
|
2007-02-09 14:24:47 +00:00
|
|
|
if (!right) {
|
2005-08-10 03:25:06 +00:00
|
|
|
tnode_free(left);
|
|
|
|
goto nomem;
|
2007-02-09 14:24:47 +00:00
|
|
|
}
|
2005-07-05 22:02:40 +00:00
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
put_child(t, tn, 2*i, (struct rt_trie_node *) left);
|
|
|
|
put_child(t, tn, 2*i+1, (struct rt_trie_node *) right);
|
2005-07-05 22:02:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
for (i = 0; i < olen; i++) {
|
2008-01-13 05:25:02 +00:00
|
|
|
struct tnode *inode;
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *node = tnode_get_child(oldtnode, i);
|
2005-08-10 03:24:39 +00:00
|
|
|
struct tnode *left, *right;
|
|
|
|
int size, j;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* An empty child */
|
|
|
|
if (node == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* A leaf or an internal node with skipped bits */
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (IS_LEAF(node) || ((struct tnode *) node)->pos >
|
2005-06-21 19:43:18 +00:00
|
|
|
tn->pos + tn->bits - 1) {
|
2008-01-23 05:53:36 +00:00
|
|
|
if (tkey_extract_bits(node->key,
|
|
|
|
oldtnode->pos + oldtnode->bits,
|
|
|
|
1) == 0)
|
2005-06-21 19:43:18 +00:00
|
|
|
put_child(t, tn, 2*i, node);
|
|
|
|
else
|
|
|
|
put_child(t, tn, 2*i+1, node);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* An internal node with two children */
|
|
|
|
inode = (struct tnode *) node;
|
|
|
|
|
|
|
|
if (inode->bits == 1) {
|
2011-03-31 08:51:35 +00:00
|
|
|
put_child(t, tn, 2*i, rtnl_dereference(inode->child[0]));
|
|
|
|
put_child(t, tn, 2*i+1, rtnl_dereference(inode->child[1]));
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2009-06-15 09:31:29 +00:00
|
|
|
tnode_free_safe(inode);
|
2005-08-10 03:24:39 +00:00
|
|
|
continue;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
/* An internal node with more than two children */
|
|
|
|
|
|
|
|
/* We will replace this node 'inode' with two new
|
|
|
|
* ones, 'left' and 'right', each with half of the
|
|
|
|
* original children. The two new nodes will have
|
|
|
|
* a position one bit further down the key and this
|
|
|
|
* means that the "significant" part of their keys
|
|
|
|
* (see the discussion near the top of this file)
|
|
|
|
* will differ by one bit, which will be "0" in
|
|
|
|
* left's key and "1" in right's key. Since we are
|
|
|
|
* moving the key position by one step, the bit that
|
|
|
|
* we are moving away from - the bit at position
|
|
|
|
* (inode->pos) - is the one that will differ between
|
|
|
|
* left and right. So... we synthesize that bit in the
|
|
|
|
* two new keys.
|
|
|
|
* The mask 'm' below will be a single "one" bit at
|
|
|
|
* the position (inode->pos)
|
|
|
|
*/
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
/* Use the old key, but set the new significant
|
|
|
|
* bit to zero.
|
|
|
|
*/
|
2005-07-05 22:02:40 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
left = (struct tnode *) tnode_get_child(tn, 2*i);
|
|
|
|
put_child(t, tn, 2*i, NULL);
|
2005-07-05 22:02:40 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
BUG_ON(!left);
|
2005-07-05 22:02:40 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
right = (struct tnode *) tnode_get_child(tn, 2*i+1);
|
|
|
|
put_child(t, tn, 2*i+1, NULL);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
BUG_ON(!right);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
size = tnode_child_length(left);
|
|
|
|
for (j = 0; j < size; j++) {
|
2011-03-31 08:51:35 +00:00
|
|
|
put_child(t, left, j, rtnl_dereference(inode->child[j]));
|
|
|
|
put_child(t, right, j, rtnl_dereference(inode->child[j + size]));
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
put_child(t, tn, 2*i, resize(t, left));
|
|
|
|
put_child(t, tn, 2*i+1, resize(t, right));
|
|
|
|
|
2009-06-15 09:31:29 +00:00
|
|
|
tnode_free_safe(inode);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2009-06-15 09:31:29 +00:00
|
|
|
tnode_free_safe(oldtnode);
|
2005-06-21 19:43:18 +00:00
|
|
|
return tn;
|
2005-08-10 03:25:06 +00:00
|
|
|
nomem:
|
2011-03-31 08:51:35 +00:00
|
|
|
tnode_clean_free(tn);
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-08-10 03:25:06 +00:00
|
|
|
static struct tnode *halve(struct trie *t, struct tnode *tn)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct tnode *oldtnode = tn;
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *left, *right;
|
2005-06-21 19:43:18 +00:00
|
|
|
int i;
|
|
|
|
int olen = tnode_child_length(tn);
|
|
|
|
|
2005-08-24 04:59:41 +00:00
|
|
|
pr_debug("In halve\n");
|
2005-07-19 21:01:51 +00:00
|
|
|
|
|
|
|
tn = tnode_new(oldtnode->key, oldtnode->pos, oldtnode->bits - 1);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:25:06 +00:00
|
|
|
if (!tn)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-07-05 22:02:40 +00:00
|
|
|
|
|
|
|
/*
|
2005-07-19 21:01:51 +00:00
|
|
|
* Preallocate and store tnodes before the actual work so we
|
|
|
|
* don't get into an inconsistent state if memory allocation
|
|
|
|
* fails. In case of failure we return the oldnode and halve
|
2005-07-05 22:02:40 +00:00
|
|
|
* of tnode is ignored.
|
|
|
|
*/
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
for (i = 0; i < olen; i += 2) {
|
2005-07-05 22:02:40 +00:00
|
|
|
left = tnode_get_child(oldtnode, i);
|
|
|
|
right = tnode_get_child(oldtnode, i+1);
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-07-05 22:02:40 +00:00
|
|
|
/* Two nonempty children */
|
2005-08-24 04:59:41 +00:00
|
|
|
if (left && right) {
|
2005-08-10 03:25:06 +00:00
|
|
|
struct tnode *newn;
|
2005-08-24 04:59:41 +00:00
|
|
|
|
2005-08-10 03:25:06 +00:00
|
|
|
newn = tnode_new(left->key, tn->pos + tn->bits, 1);
|
2005-08-24 04:59:41 +00:00
|
|
|
|
|
|
|
if (!newn)
|
2005-08-10 03:25:06 +00:00
|
|
|
goto nomem;
|
2005-08-24 04:59:41 +00:00
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
put_child(t, tn, i/2, (struct rt_trie_node *)newn);
|
2005-07-05 22:02:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
for (i = 0; i < olen; i += 2) {
|
|
|
|
struct tnode *newBinNode;
|
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
left = tnode_get_child(oldtnode, i);
|
|
|
|
right = tnode_get_child(oldtnode, i+1);
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* At least one of the children is empty */
|
|
|
|
if (left == NULL) {
|
|
|
|
if (right == NULL) /* Both are empty */
|
|
|
|
continue;
|
|
|
|
put_child(t, tn, i/2, right);
|
2005-08-10 03:24:39 +00:00
|
|
|
continue;
|
2005-08-24 04:59:41 +00:00
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
|
|
|
|
if (right == NULL) {
|
2005-06-21 19:43:18 +00:00
|
|
|
put_child(t, tn, i/2, left);
|
2005-08-10 03:24:39 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* Two nonempty children */
|
2005-08-10 03:24:39 +00:00
|
|
|
newBinNode = (struct tnode *) tnode_get_child(tn, i/2);
|
|
|
|
put_child(t, tn, i/2, NULL);
|
|
|
|
put_child(t, newBinNode, 0, left);
|
|
|
|
put_child(t, newBinNode, 1, right);
|
|
|
|
put_child(t, tn, i/2, resize(t, newBinNode));
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2009-06-15 09:31:29 +00:00
|
|
|
tnode_free_safe(oldtnode);
|
2005-06-21 19:43:18 +00:00
|
|
|
return tn;
|
2005-08-10 03:25:06 +00:00
|
|
|
nomem:
|
2011-03-31 08:51:35 +00:00
|
|
|
tnode_clean_free(tn);
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-09-19 22:31:18 +00:00
|
|
|
/* readside must use rcu_read_lock currently dump routines
|
2005-08-25 20:01:29 +00:00
|
|
|
via get_fa_head and dump */
|
|
|
|
|
2005-09-19 22:31:18 +00:00
|
|
|
static struct leaf_info *find_leaf_info(struct leaf *l, int plen)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-09-19 22:31:18 +00:00
|
|
|
struct hlist_head *head = &l->list;
|
2005-06-21 19:43:18 +00:00
|
|
|
struct hlist_node *node;
|
|
|
|
struct leaf_info *li;
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
hlist_for_each_entry_rcu(li, node, head, hlist)
|
2005-07-19 21:01:51 +00:00
|
|
|
if (li->plen == plen)
|
2005-06-21 19:43:18 +00:00
|
|
|
return li;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
static inline struct list_head *get_fa_head(struct leaf *l, int plen)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-09-19 22:31:18 +00:00
|
|
|
struct leaf_info *li = find_leaf_info(l, plen);
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (!li)
|
|
|
|
return NULL;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
return &li->falh;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void insert_leaf_info(struct hlist_head *head, struct leaf_info *new)
|
|
|
|
{
|
2007-02-09 14:24:47 +00:00
|
|
|
struct leaf_info *li = NULL, *last = NULL;
|
|
|
|
struct hlist_node *node;
|
|
|
|
|
|
|
|
if (hlist_empty(head)) {
|
|
|
|
hlist_add_head_rcu(&new->hlist, head);
|
|
|
|
} else {
|
|
|
|
hlist_for_each_entry(li, node, head, hlist) {
|
|
|
|
if (new->plen > li->plen)
|
|
|
|
break;
|
|
|
|
|
|
|
|
last = li;
|
|
|
|
}
|
|
|
|
if (last)
|
|
|
|
hlist_add_after_rcu(&last->hlist, &new->hlist);
|
|
|
|
else
|
|
|
|
hlist_add_before_rcu(&new->hlist, &li->hlist);
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
/* rcu_read_lock needs to be hold by caller from readside */
|
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
static struct leaf *
|
|
|
|
fib_find_node(struct trie *t, u32 key)
|
|
|
|
{
|
|
|
|
int pos;
|
|
|
|
struct tnode *tn;
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
pos = 0;
|
2010-09-09 23:32:28 +00:00
|
|
|
n = rcu_dereference_rtnl(t->trie);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
while (n != NULL && NODE_TYPE(n) == T_TNODE) {
|
|
|
|
tn = (struct tnode *) n;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
check_tnode(tn);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) {
|
2005-08-10 03:24:39 +00:00
|
|
|
pos = tn->pos + tn->bits;
|
2008-01-23 05:53:36 +00:00
|
|
|
n = tnode_get_child_rcu(tn,
|
|
|
|
tkey_extract_bits(key,
|
|
|
|
tn->pos,
|
|
|
|
tn->bits));
|
2005-08-10 03:24:39 +00:00
|
|
|
} else
|
2005-06-21 19:43:18 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Case we have found a leaf. Compare prefixes */
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (n != NULL && IS_LEAF(n) && tkey_equals(key, n->key))
|
|
|
|
return (struct leaf *)n;
|
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-06-18 07:28:51 +00:00
|
|
|
static void trie_rebalance(struct trie *t, struct tnode *tn)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
int wasfull;
|
2009-05-21 22:20:59 +00:00
|
|
|
t_key cindex, key;
|
2007-08-10 22:22:13 +00:00
|
|
|
struct tnode *tp;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2009-05-21 22:20:59 +00:00
|
|
|
key = tn->key;
|
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
while (tn != NULL && (tp = node_parent((struct rt_trie_node *)tn)) != NULL) {
|
2005-06-21 19:43:18 +00:00
|
|
|
cindex = tkey_extract_bits(key, tp->pos, tp->bits);
|
|
|
|
wasfull = tnode_full(tp, tnode_get_child(tp, cindex));
|
2012-06-03 17:41:40 +00:00
|
|
|
tn = (struct tnode *)resize(t, tn);
|
2008-01-23 05:53:36 +00:00
|
|
|
|
2012-06-03 17:41:40 +00:00
|
|
|
tnode_put_child_reorg(tp, cindex,
|
2011-02-03 04:48:10 +00:00
|
|
|
(struct rt_trie_node *)tn, wasfull);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
tp = node_parent((struct rt_trie_node *) tn);
|
2009-06-30 19:47:19 +00:00
|
|
|
if (!tp)
|
2012-01-12 04:41:32 +00:00
|
|
|
rcu_assign_pointer(t->trie, (struct rt_trie_node *)tn);
|
2009-06-30 19:47:19 +00:00
|
|
|
|
2009-06-15 09:31:29 +00:00
|
|
|
tnode_free_flush();
|
2007-08-10 22:22:13 +00:00
|
|
|
if (!tp)
|
2005-06-21 19:43:18 +00:00
|
|
|
break;
|
2007-08-10 22:22:13 +00:00
|
|
|
tn = tp;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2007-08-10 22:22:13 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* Handle last (top) tnode */
|
2009-06-18 07:28:51 +00:00
|
|
|
if (IS_TNODE(tn))
|
2012-06-03 17:41:40 +00:00
|
|
|
tn = (struct tnode *)resize(t, tn);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2012-01-12 04:41:32 +00:00
|
|
|
rcu_assign_pointer(t->trie, (struct rt_trie_node *)tn);
|
2009-06-18 07:28:51 +00:00
|
|
|
tnode_free_flush();
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
/* only used from updater-side */
|
|
|
|
|
2008-01-13 04:57:07 +00:00
|
|
|
static struct list_head *fib_insert_node(struct trie *t, u32 key, int plen)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
int pos, newpos;
|
|
|
|
struct tnode *tp = NULL, *tn = NULL;
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n;
|
2005-06-21 19:43:18 +00:00
|
|
|
struct leaf *l;
|
|
|
|
int missbit;
|
2005-07-19 21:01:51 +00:00
|
|
|
struct list_head *fa_head = NULL;
|
2005-06-21 19:43:18 +00:00
|
|
|
struct leaf_info *li;
|
|
|
|
t_key cindex;
|
|
|
|
|
|
|
|
pos = 0;
|
2011-03-31 08:51:35 +00:00
|
|
|
n = rtnl_dereference(t->trie);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
/* If we point to NULL, stop. Either the tree is empty and we should
|
|
|
|
* just put a new leaf in if, or we have reached an empty child slot,
|
2005-06-21 19:43:18 +00:00
|
|
|
* and we should just put our new leaf in that.
|
2005-07-19 21:01:51 +00:00
|
|
|
* If we point to a T_TNODE, check if it matches our key. Note that
|
|
|
|
* a T_TNODE might be skipping any number of bits - its 'pos' need
|
2005-06-21 19:43:18 +00:00
|
|
|
* not be the parent's 'pos'+'bits'!
|
|
|
|
*
|
2005-07-19 21:01:51 +00:00
|
|
|
* If it does match the current key, get pos/bits from it, extract
|
2005-06-21 19:43:18 +00:00
|
|
|
* the index from our key, push the T_TNODE and walk the tree.
|
|
|
|
*
|
|
|
|
* If it doesn't, we have to replace it with a new T_TNODE.
|
|
|
|
*
|
2005-07-19 21:01:51 +00:00
|
|
|
* If we point to a T_LEAF, it might or might not have the same key
|
|
|
|
* as we do. If it does, just change the value, update the T_LEAF's
|
|
|
|
* value, and return it.
|
2005-06-21 19:43:18 +00:00
|
|
|
* If it doesn't, we need to replace it with a T_TNODE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
while (n != NULL && NODE_TYPE(n) == T_TNODE) {
|
|
|
|
tn = (struct tnode *) n;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
check_tnode(tn);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) {
|
2005-06-21 19:43:18 +00:00
|
|
|
tp = tn;
|
2005-08-10 03:24:39 +00:00
|
|
|
pos = tn->pos + tn->bits;
|
2008-01-23 05:53:36 +00:00
|
|
|
n = tnode_get_child(tn,
|
|
|
|
tkey_extract_bits(key,
|
|
|
|
tn->pos,
|
|
|
|
tn->bits));
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2007-08-10 22:22:13 +00:00
|
|
|
BUG_ON(n && node_parent(n) != tn);
|
2005-08-10 03:24:39 +00:00
|
|
|
} else
|
2005-06-21 19:43:18 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* n ----> NULL, LEAF or TNODE
|
|
|
|
*
|
2005-07-19 21:01:51 +00:00
|
|
|
* tp is n's (parent) ----> NULL or TNODE
|
2005-06-21 19:43:18 +00:00
|
|
|
*/
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
BUG_ON(tp && IS_LEAF(tp));
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
/* Case 1: n is a leaf. Compare prefixes */
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (n != NULL && IS_LEAF(n) && tkey_equals(key, n->key)) {
|
2008-01-13 05:25:02 +00:00
|
|
|
l = (struct leaf *) n;
|
2005-06-21 19:43:18 +00:00
|
|
|
li = leaf_info_new(plen);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2008-01-13 04:57:07 +00:00
|
|
|
if (!li)
|
|
|
|
return NULL;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
fa_head = &li->falh;
|
|
|
|
insert_leaf_info(&l->list, li);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
l = leaf_new();
|
|
|
|
|
2008-01-13 04:57:07 +00:00
|
|
|
if (!l)
|
|
|
|
return NULL;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
l->key = key;
|
|
|
|
li = leaf_info_new(plen);
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (!li) {
|
2008-04-10 10:47:34 +00:00
|
|
|
free_leaf(l);
|
2008-01-13 04:57:07 +00:00
|
|
|
return NULL;
|
2005-06-28 22:00:39 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
fa_head = &li->falh;
|
|
|
|
insert_leaf_info(&l->list, li);
|
|
|
|
|
|
|
|
if (t->trie && n == NULL) {
|
2005-08-10 03:24:39 +00:00
|
|
|
/* Case 2: n is NULL, and will just insert a new leaf */
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
node_set_parent((struct rt_trie_node *)l, tp);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
cindex = tkey_extract_bits(key, tp->pos, tp->bits);
|
2012-06-03 17:41:40 +00:00
|
|
|
put_child(t, tp, cindex, (struct rt_trie_node *)l);
|
2005-08-10 03:24:39 +00:00
|
|
|
} else {
|
|
|
|
/* Case 3: n is a LEAF or a TNODE and the key doesn't match. */
|
2005-07-19 21:01:51 +00:00
|
|
|
/*
|
|
|
|
* Add a new tnode here
|
2005-06-21 19:43:18 +00:00
|
|
|
* first tnode need some special handling
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (tp)
|
2005-08-10 03:24:39 +00:00
|
|
|
pos = tp->pos+tp->bits;
|
2005-06-21 19:43:18 +00:00
|
|
|
else
|
2005-08-10 03:24:39 +00:00
|
|
|
pos = 0;
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (n) {
|
2005-06-21 19:43:18 +00:00
|
|
|
newpos = tkey_mismatch(key, pos, n->key);
|
|
|
|
tn = tnode_new(n->key, newpos, 1);
|
2005-08-10 03:24:39 +00:00
|
|
|
} else {
|
2005-06-21 19:43:18 +00:00
|
|
|
newpos = 0;
|
2005-07-19 21:01:51 +00:00
|
|
|
tn = tnode_new(key, newpos, 1); /* First tnode */
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (!tn) {
|
2005-06-28 22:00:39 +00:00
|
|
|
free_leaf_info(li);
|
2008-04-10 10:47:34 +00:00
|
|
|
free_leaf(l);
|
2008-01-13 04:57:07 +00:00
|
|
|
return NULL;
|
2005-08-10 03:24:39 +00:00
|
|
|
}
|
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
node_set_parent((struct rt_trie_node *)tn, tp);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
missbit = tkey_extract_bits(key, newpos, 1);
|
2011-02-03 04:48:10 +00:00
|
|
|
put_child(t, tn, missbit, (struct rt_trie_node *)l);
|
2005-06-21 19:43:18 +00:00
|
|
|
put_child(t, tn, 1-missbit, n);
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (tp) {
|
2005-06-21 19:43:18 +00:00
|
|
|
cindex = tkey_extract_bits(key, tp->pos, tp->bits);
|
2012-06-03 17:41:40 +00:00
|
|
|
put_child(t, tp, cindex, (struct rt_trie_node *)tn);
|
2005-08-10 03:24:39 +00:00
|
|
|
} else {
|
2012-01-12 04:41:32 +00:00
|
|
|
rcu_assign_pointer(t->trie, (struct rt_trie_node *)tn);
|
2005-06-21 19:43:18 +00:00
|
|
|
tp = tn;
|
|
|
|
}
|
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
|
|
|
|
if (tp && tp->pos + tp->bits > 32)
|
2012-03-11 18:36:11 +00:00
|
|
|
pr_warn("fib_trie tp=%p pos=%d, bits=%d, key=%0x plen=%d\n",
|
|
|
|
tp, tp->pos, tp->bits, key, plen);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* Rebalance the trie */
|
2005-08-25 20:01:29 +00:00
|
|
|
|
2009-06-18 07:28:51 +00:00
|
|
|
trie_rebalance(t, tp);
|
2005-06-28 22:00:39 +00:00
|
|
|
done:
|
2005-06-21 19:43:18 +00:00
|
|
|
return fa_head;
|
|
|
|
}
|
|
|
|
|
2007-03-26 21:22:22 +00:00
|
|
|
/*
|
|
|
|
* Caller must hold RTNL.
|
|
|
|
*/
|
2009-09-20 10:35:36 +00:00
|
|
|
int fib_table_insert(struct fib_table *tb, struct fib_config *cfg)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct trie *t = (struct trie *) tb->tb_data;
|
|
|
|
struct fib_alias *fa, *new_fa;
|
2005-07-19 21:01:51 +00:00
|
|
|
struct list_head *fa_head = NULL;
|
2005-06-21 19:43:18 +00:00
|
|
|
struct fib_info *fi;
|
2006-08-18 01:14:52 +00:00
|
|
|
int plen = cfg->fc_dst_len;
|
|
|
|
u8 tos = cfg->fc_tos;
|
2005-06-21 19:43:18 +00:00
|
|
|
u32 key, mask;
|
|
|
|
int err;
|
|
|
|
struct leaf *l;
|
|
|
|
|
|
|
|
if (plen > 32)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-08-18 01:14:52 +00:00
|
|
|
key = ntohl(cfg->fc_dst);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2006-08-11 06:08:33 +00:00
|
|
|
pr_debug("Insert table=%u %08x/%d\n", tb->tb_id, key, plen);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
mask = ntohl(inet_make_mask(plen));
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (key & ~mask)
|
2005-06-21 19:43:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
key = key & mask;
|
|
|
|
|
2006-08-18 01:14:52 +00:00
|
|
|
fi = fib_create_info(cfg);
|
|
|
|
if (IS_ERR(fi)) {
|
|
|
|
err = PTR_ERR(fi);
|
2005-06-21 19:43:18 +00:00
|
|
|
goto err;
|
2006-08-18 01:14:52 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
l = fib_find_node(t, key);
|
2005-07-19 21:01:51 +00:00
|
|
|
fa = NULL;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (l) {
|
2005-06-21 19:43:18 +00:00
|
|
|
fa_head = get_fa_head(l, plen);
|
|
|
|
fa = fib_find_alias(fa_head, 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.
|
|
|
|
*/
|
|
|
|
|
2008-01-29 05:18:06 +00:00
|
|
|
if (fa && fa->fa_tos == tos &&
|
|
|
|
fa->fa_info->fib_priority == fi->fib_priority) {
|
|
|
|
struct fib_alias *fa_first, *fa_match;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
err = -EEXIST;
|
2006-08-18 01:14:52 +00:00
|
|
|
if (cfg->fc_nlflags & NLM_F_EXCL)
|
2005-06-21 19:43:18 +00:00
|
|
|
goto out;
|
|
|
|
|
2008-01-29 05:18:06 +00:00
|
|
|
/* 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, fa_head, 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_info == fi) {
|
|
|
|
fa_match = fa;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-18 01:14:52 +00:00
|
|
|
if (cfg->fc_nlflags & NLM_F_REPLACE) {
|
2005-06-21 19:43:18 +00:00
|
|
|
struct fib_info *fi_drop;
|
|
|
|
u8 state;
|
|
|
|
|
2008-01-29 05:18:06 +00:00
|
|
|
fa = fa_first;
|
|
|
|
if (fa_match) {
|
|
|
|
if (fa == fa_match)
|
|
|
|
err = 0;
|
2008-01-18 11:45:18 +00:00
|
|
|
goto out;
|
2008-01-29 05:18:06 +00:00
|
|
|
}
|
2005-08-25 20:01:29 +00:00
|
|
|
err = -ENOBUFS;
|
2006-12-07 04:33:17 +00:00
|
|
|
new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
|
2005-08-25 20:01:29 +00:00
|
|
|
if (new_fa == NULL)
|
|
|
|
goto out;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
fi_drop = fa->fa_info;
|
2005-08-25 20:01:29 +00:00
|
|
|
new_fa->fa_tos = fa->fa_tos;
|
|
|
|
new_fa->fa_info = fi;
|
2006-08-18 01:14:52 +00:00
|
|
|
new_fa->fa_type = cfg->fc_type;
|
2005-06-21 19:43:18 +00:00
|
|
|
state = fa->fa_state;
|
2008-01-29 05:18:06 +00:00
|
|
|
new_fa->fa_state = state & ~FA_S_ACCESSED;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
list_replace_rcu(&fa->fa_list, &new_fa->fa_list);
|
|
|
|
alias_free_mem_rcu(fa);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
fib_release_info(fi_drop);
|
|
|
|
if (state & FA_S_ACCESSED)
|
2008-07-06 02:00:44 +00:00
|
|
|
rt_cache_flush(cfg->fc_nlinfo.nl_net, -1);
|
2007-05-23 21:55:06 +00:00
|
|
|
rtmsg_fib(RTM_NEWROUTE, htonl(key), new_fa, plen,
|
|
|
|
tb->tb_id, &cfg->fc_nlinfo, NLM_F_REPLACE);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
goto succeeded;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
/* Error if we find a perfect match which
|
|
|
|
* uses the same scope, type, and nexthop
|
|
|
|
* information.
|
|
|
|
*/
|
2008-01-29 05:18:06 +00:00
|
|
|
if (fa_match)
|
|
|
|
goto out;
|
2008-01-23 05:53:36 +00:00
|
|
|
|
2006-08-18 01:14:52 +00:00
|
|
|
if (!(cfg->fc_nlflags & NLM_F_APPEND))
|
2008-01-29 05:18:06 +00:00
|
|
|
fa = fa_first;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
err = -ENOENT;
|
2006-08-18 01:14:52 +00:00
|
|
|
if (!(cfg->fc_nlflags & NLM_F_CREATE))
|
2005-06-21 19:43:18 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = -ENOBUFS;
|
2006-12-07 04:33:17 +00:00
|
|
|
new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
|
2005-06-21 19:43:18 +00:00
|
|
|
if (new_fa == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
new_fa->fa_info = fi;
|
|
|
|
new_fa->fa_tos = tos;
|
2006-08-18 01:14:52 +00:00
|
|
|
new_fa->fa_type = cfg->fc_type;
|
2005-06-21 19:43:18 +00:00
|
|
|
new_fa->fa_state = 0;
|
|
|
|
/*
|
|
|
|
* Insert new entry to the list.
|
|
|
|
*/
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (!fa_head) {
|
2008-01-13 04:57:07 +00:00
|
|
|
fa_head = fib_insert_node(t, key, plen);
|
|
|
|
if (unlikely(!fa_head)) {
|
|
|
|
err = -ENOMEM;
|
2005-06-28 22:00:39 +00:00
|
|
|
goto out_free_new_fa;
|
2008-01-13 04:57:07 +00:00
|
|
|
}
|
2005-06-28 22:00:39 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2011-04-14 21:49:37 +00:00
|
|
|
if (!plen)
|
|
|
|
tb->tb_num_default++;
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
list_add_tail_rcu(&new_fa->fa_list,
|
|
|
|
(fa ? &fa->fa_list : fa_head));
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-07-06 02:00:44 +00:00
|
|
|
rt_cache_flush(cfg->fc_nlinfo.nl_net, -1);
|
2006-08-18 01:14:52 +00:00
|
|
|
rtmsg_fib(RTM_NEWROUTE, htonl(key), new_fa, plen, tb->tb_id,
|
2007-05-23 21:55:06 +00:00
|
|
|
&cfg->fc_nlinfo, 0);
|
2005-06-21 19:43:18 +00:00
|
|
|
succeeded:
|
|
|
|
return 0;
|
2005-06-28 22:00:39 +00:00
|
|
|
|
|
|
|
out_free_new_fa:
|
|
|
|
kmem_cache_free(fn_alias_kmem, new_fa);
|
2005-06-21 19:43:18 +00:00
|
|
|
out:
|
|
|
|
fib_release_info(fi);
|
2005-08-10 03:24:39 +00:00
|
|
|
err:
|
2005-06-21 19:43:18 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-09-19 22:31:18 +00:00
|
|
|
/* should be called with rcu_read_lock */
|
2011-02-01 00:10:03 +00:00
|
|
|
static int check_leaf(struct fib_table *tb, struct trie *t, struct leaf *l,
|
2011-03-12 00:54:08 +00:00
|
|
|
t_key key, const struct flowi4 *flp,
|
2010-10-05 10:41:36 +00:00
|
|
|
struct fib_result *res, int fib_flags)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct leaf_info *li;
|
|
|
|
struct hlist_head *hhead = &l->list;
|
|
|
|
struct hlist_node *node;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
hlist_for_each_entry_rcu(li, node, hhead, hlist) {
|
2011-03-07 23:01:10 +00:00
|
|
|
struct fib_alias *fa;
|
2008-01-23 05:53:36 +00:00
|
|
|
|
2011-07-18 03:16:33 +00:00
|
|
|
if (l->key != (key & li->mask_plen))
|
2005-06-21 19:43:18 +00:00
|
|
|
continue;
|
|
|
|
|
2011-03-07 23:01:10 +00:00
|
|
|
list_for_each_entry_rcu(fa, &li->falh, fa_list) {
|
|
|
|
struct fib_info *fi = fa->fa_info;
|
|
|
|
int nhsel, err;
|
2008-01-23 05:53:36 +00:00
|
|
|
|
2011-03-12 00:54:08 +00:00
|
|
|
if (fa->fa_tos && fa->fa_tos != flp->flowi4_tos)
|
2011-03-07 23:01:10 +00:00
|
|
|
continue;
|
2012-05-11 02:16:32 +00:00
|
|
|
if (fi->fib_dead)
|
|
|
|
continue;
|
2011-03-25 01:06:47 +00:00
|
|
|
if (fa->fa_info->fib_scope < flp->flowi4_scope)
|
2011-03-07 23:01:10 +00:00
|
|
|
continue;
|
|
|
|
fib_alias_accessed(fa);
|
|
|
|
err = fib_props[fa->fa_type].error;
|
|
|
|
if (err) {
|
2005-06-21 19:43:18 +00:00
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
2011-03-26 03:33:23 +00:00
|
|
|
t->stats.semantic_match_passed++;
|
2011-03-07 23:01:10 +00:00
|
|
|
#endif
|
2011-03-26 03:33:23 +00:00
|
|
|
return err;
|
2011-03-07 23:01:10 +00:00
|
|
|
}
|
|
|
|
if (fi->fib_flags & RTNH_F_DEAD)
|
|
|
|
continue;
|
|
|
|
for (nhsel = 0; nhsel < fi->fib_nhs; nhsel++) {
|
|
|
|
const struct fib_nh *nh = &fi->fib_nh[nhsel];
|
|
|
|
|
|
|
|
if (nh->nh_flags & RTNH_F_DEAD)
|
|
|
|
continue;
|
2011-03-12 00:54:08 +00:00
|
|
|
if (flp->flowi4_oif && flp->flowi4_oif != nh->nh_oif)
|
2011-03-07 23:01:10 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
t->stats.semantic_match_passed++;
|
|
|
|
#endif
|
2011-07-18 03:16:33 +00:00
|
|
|
res->prefixlen = li->plen;
|
2011-03-07 23:01:10 +00:00
|
|
|
res->nh_sel = nhsel;
|
|
|
|
res->type = fa->fa_type;
|
2011-03-25 01:06:47 +00:00
|
|
|
res->scope = fa->fa_info->fib_scope;
|
2011-03-07 23:01:10 +00:00
|
|
|
res->fi = fi;
|
|
|
|
res->table = tb;
|
|
|
|
res->fa_head = &li->falh;
|
|
|
|
if (!(fib_flags & FIB_LOOKUP_NOREF))
|
2011-07-18 03:16:33 +00:00
|
|
|
atomic_inc(&fi->fib_clntref);
|
2011-03-07 23:01:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
t->stats.semantic_match_miss++;
|
2005-06-21 19:43:18 +00:00
|
|
|
#endif
|
|
|
|
}
|
2008-01-23 05:53:36 +00:00
|
|
|
|
2008-07-10 23:52:52 +00:00
|
|
|
return 1;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2011-03-12 00:54:08 +00:00
|
|
|
int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp,
|
2010-10-05 10:41:36 +00:00
|
|
|
struct fib_result *res, int fib_flags)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct trie *t = (struct trie *) tb->tb_data;
|
2008-07-10 23:52:52 +00:00
|
|
|
int ret;
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n;
|
2005-06-21 19:43:18 +00:00
|
|
|
struct tnode *pn;
|
2011-02-16 22:56:22 +00:00
|
|
|
unsigned int pos, bits;
|
2011-03-12 00:54:08 +00:00
|
|
|
t_key key = ntohl(flp->daddr);
|
2011-02-16 22:56:22 +00:00
|
|
|
unsigned int chopped_off;
|
2005-06-21 19:43:18 +00:00
|
|
|
t_key cindex = 0;
|
2011-02-16 22:56:22 +00:00
|
|
|
unsigned int current_prefix_length = KEYLENGTH;
|
2005-08-10 03:24:39 +00:00
|
|
|
struct tnode *cn;
|
2010-10-13 06:56:11 +00:00
|
|
|
t_key pref_mismatch;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
rcu_read_lock();
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
n = rcu_dereference(t->trie);
|
2005-07-19 21:01:51 +00:00
|
|
|
if (!n)
|
2005-06-21 19:43:18 +00:00
|
|
|
goto failed;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
t->stats.gets++;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Just a leaf? */
|
|
|
|
if (IS_LEAF(n)) {
|
2011-02-01 00:10:03 +00:00
|
|
|
ret = check_leaf(tb, t, (struct leaf *)n, key, flp, res, fib_flags);
|
2008-01-23 05:53:36 +00:00
|
|
|
goto found;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2008-01-23 05:53:36 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
pn = (struct tnode *) n;
|
|
|
|
chopped_off = 0;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
while (pn) {
|
2005-06-21 19:43:18 +00:00
|
|
|
pos = pn->pos;
|
|
|
|
bits = pn->bits;
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (!chopped_off)
|
2007-08-10 22:22:58 +00:00
|
|
|
cindex = tkey_extract_bits(mask_pfx(key, current_prefix_length),
|
|
|
|
pos, bits);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2009-07-14 11:20:32 +00:00
|
|
|
n = tnode_get_child_rcu(pn, cindex);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
if (n == NULL) {
|
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
t->stats.null_node_hit++;
|
|
|
|
#endif
|
|
|
|
goto backtrace;
|
|
|
|
}
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (IS_LEAF(n)) {
|
2011-02-01 00:10:03 +00:00
|
|
|
ret = check_leaf(tb, t, (struct leaf *)n, key, flp, res, fib_flags);
|
2008-07-10 23:52:52 +00:00
|
|
|
if (ret > 0)
|
2005-08-10 03:24:39 +00:00
|
|
|
goto backtrace;
|
2008-01-23 05:53:36 +00:00
|
|
|
goto found;
|
2005-08-10 03:24:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cn = (struct tnode *)n;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
/*
|
|
|
|
* It's a tnode, and we can do some extra checks here if we
|
|
|
|
* like, to avoid descending into a dead-end branch.
|
|
|
|
* This tnode is in the parent's child array at index
|
|
|
|
* key[p_pos..p_pos+p_bits] but potentially with some bits
|
|
|
|
* chopped off, so in reality the index may be just a
|
|
|
|
* subprefix, padded with zero at the end.
|
|
|
|
* We can also take a look at any skipped bits in this
|
|
|
|
* tnode - everything up to p_pos is supposed to be ok,
|
|
|
|
* and the non-chopped bits of the index (se previous
|
|
|
|
* paragraph) are also guaranteed ok, but the rest is
|
|
|
|
* considered unknown.
|
|
|
|
*
|
|
|
|
* The skipped bits are key[pos+bits..cn->pos].
|
|
|
|
*/
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
/* If current_prefix_length < pos+bits, we are already doing
|
|
|
|
* actual prefix matching, which means everything from
|
|
|
|
* pos+(bits-chopped_off) onward must be zero along some
|
|
|
|
* branch of this subtree - otherwise there is *no* valid
|
|
|
|
* prefix present. Here we can only check the skipped
|
|
|
|
* bits. Remember, since we have already indexed into the
|
|
|
|
* parent's child array, we know that the bits we chopped of
|
|
|
|
* *are* zero.
|
|
|
|
*/
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
/* NOTA BENE: Checking only skipped bits
|
|
|
|
for the new node here */
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (current_prefix_length < pos+bits) {
|
|
|
|
if (tkey_extract_bits(cn->key, current_prefix_length,
|
2008-01-23 05:53:36 +00:00
|
|
|
cn->pos - current_prefix_length)
|
|
|
|
|| !(cn->child[0]))
|
2005-08-10 03:24:39 +00:00
|
|
|
goto backtrace;
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
/*
|
|
|
|
* If chopped_off=0, the index is fully validated and we
|
|
|
|
* only need to look at the skipped bits for this, the new,
|
|
|
|
* tnode. What we actually want to do is to find out if
|
|
|
|
* these skipped bits match our key perfectly, or if we will
|
|
|
|
* have to count on finding a matching prefix further down,
|
|
|
|
* because if we do, we would like to have some way of
|
|
|
|
* verifying the existence of such a prefix at this point.
|
|
|
|
*/
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
/* The only thing we can do at this point is to verify that
|
|
|
|
* any such matching prefix can indeed be a prefix to our
|
|
|
|
* key, and if the bits in the node we are inspecting that
|
|
|
|
* do not match our key are not ZERO, this cannot be true.
|
|
|
|
* Thus, find out where there is a mismatch (before cn->pos)
|
|
|
|
* and verify that all the mismatching bits are zero in the
|
|
|
|
* new tnode's key.
|
|
|
|
*/
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
/*
|
|
|
|
* Note: We aren't very concerned about the piece of
|
|
|
|
* the key that precede pn->pos+pn->bits, since these
|
|
|
|
* have already been checked. The bits after cn->pos
|
|
|
|
* aren't checked since these are by definition
|
|
|
|
* "unknown" at this point. Thus, what we want to see
|
|
|
|
* is if we are about to enter the "prefix matching"
|
|
|
|
* state, and in that case verify that the skipped
|
|
|
|
* bits that will prevail throughout this subtree are
|
|
|
|
* zero, as they have to be if we are to find a
|
|
|
|
* matching prefix.
|
2005-08-10 03:24:39 +00:00
|
|
|
*/
|
|
|
|
|
2010-10-13 06:56:11 +00:00
|
|
|
pref_mismatch = mask_pfx(cn->key ^ key, cn->pos);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
/*
|
|
|
|
* In short: If skipped bits in this node do not match
|
|
|
|
* the search key, enter the "prefix matching"
|
|
|
|
* state.directly.
|
2005-08-10 03:24:39 +00:00
|
|
|
*/
|
|
|
|
if (pref_mismatch) {
|
2010-10-13 06:56:11 +00:00
|
|
|
int mp = KEYLENGTH - fls(pref_mismatch);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2010-10-13 06:56:11 +00:00
|
|
|
if (tkey_extract_bits(cn->key, mp, cn->pos - mp) != 0)
|
2005-08-10 03:24:39 +00:00
|
|
|
goto backtrace;
|
|
|
|
|
|
|
|
if (current_prefix_length >= cn->pos)
|
|
|
|
current_prefix_length = mp;
|
2005-07-19 21:01:51 +00:00
|
|
|
}
|
2008-01-23 05:53:36 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
pn = (struct tnode *)n; /* Descend */
|
|
|
|
chopped_off = 0;
|
|
|
|
continue;
|
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
backtrace:
|
|
|
|
chopped_off++;
|
|
|
|
|
|
|
|
/* As zero don't change the child key (cindex) */
|
2008-01-23 05:53:36 +00:00
|
|
|
while ((chopped_off <= pn->bits)
|
|
|
|
&& !(cindex & (1<<(chopped_off-1))))
|
2005-06-21 19:43:18 +00:00
|
|
|
chopped_off++;
|
|
|
|
|
|
|
|
/* Decrease current_... with bits chopped off */
|
|
|
|
if (current_prefix_length > pn->pos + pn->bits - chopped_off)
|
2008-01-23 05:53:36 +00:00
|
|
|
current_prefix_length = pn->pos + pn->bits
|
|
|
|
- chopped_off;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/*
|
2005-07-19 21:01:51 +00:00
|
|
|
* Either we do the actual chop off according or if we have
|
2005-06-21 19:43:18 +00:00
|
|
|
* chopped off all bits in this tnode walk up to our parent.
|
|
|
|
*/
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (chopped_off <= pn->bits) {
|
2005-06-21 19:43:18 +00:00
|
|
|
cindex &= ~(1 << (chopped_off-1));
|
2005-08-10 03:24:39 +00:00
|
|
|
} else {
|
2011-02-03 04:48:10 +00:00
|
|
|
struct tnode *parent = node_parent_rcu((struct rt_trie_node *) pn);
|
2007-08-10 22:22:13 +00:00
|
|
|
if (!parent)
|
2005-06-21 19:43:18 +00:00
|
|
|
goto failed;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
/* Get Child's index */
|
2007-08-10 22:22:13 +00:00
|
|
|
cindex = tkey_extract_bits(pn->key, parent->pos, parent->bits);
|
|
|
|
pn = parent;
|
2005-06-21 19:43:18 +00:00
|
|
|
chopped_off = 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
t->stats.backtrack++;
|
|
|
|
#endif
|
|
|
|
goto backtrace;
|
2005-07-19 21:01:51 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
failed:
|
2005-07-19 21:01:51 +00:00
|
|
|
ret = 1;
|
2005-06-21 19:43:18 +00:00
|
|
|
found:
|
2005-08-25 20:01:29 +00:00
|
|
|
rcu_read_unlock();
|
2005-06-21 19:43:18 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2011-08-25 11:46:12 +00:00
|
|
|
EXPORT_SYMBOL_GPL(fib_table_lookup);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-23 05:56:34 +00:00
|
|
|
/*
|
|
|
|
* Remove the leaf and return parent.
|
|
|
|
*/
|
|
|
|
static void trie_leaf_remove(struct trie *t, struct leaf *l)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2011-02-03 04:48:10 +00:00
|
|
|
struct tnode *tp = node_parent((struct rt_trie_node *) l);
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2008-01-23 05:56:34 +00:00
|
|
|
pr_debug("entering trie_leaf_remove(%p)\n", l);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (tp) {
|
2008-01-23 05:56:34 +00:00
|
|
|
t_key cindex = tkey_extract_bits(l->key, tp->pos, tp->bits);
|
2012-06-03 17:41:40 +00:00
|
|
|
put_child(t, tp, cindex, NULL);
|
2009-06-18 07:28:51 +00:00
|
|
|
trie_rebalance(t, tp);
|
2005-08-10 03:24:39 +00:00
|
|
|
} else
|
2011-08-01 16:19:00 +00:00
|
|
|
RCU_INIT_POINTER(t->trie, NULL);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-04-10 10:47:34 +00:00
|
|
|
free_leaf(l);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2007-03-26 21:22:22 +00:00
|
|
|
/*
|
|
|
|
* Caller must hold RTNL.
|
|
|
|
*/
|
2009-09-20 10:35:36 +00:00
|
|
|
int fib_table_delete(struct fib_table *tb, struct fib_config *cfg)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct trie *t = (struct trie *) tb->tb_data;
|
|
|
|
u32 key, mask;
|
2006-08-18 01:14:52 +00:00
|
|
|
int plen = cfg->fc_dst_len;
|
|
|
|
u8 tos = cfg->fc_tos;
|
2005-06-21 19:43:18 +00:00
|
|
|
struct fib_alias *fa, *fa_to_delete;
|
|
|
|
struct list_head *fa_head;
|
|
|
|
struct leaf *l;
|
2005-08-10 03:24:39 +00:00
|
|
|
struct leaf_info *li;
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (plen > 32)
|
2005-06-21 19:43:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-08-18 01:14:52 +00:00
|
|
|
key = ntohl(cfg->fc_dst);
|
2005-08-10 03:24:39 +00:00
|
|
|
mask = ntohl(inet_make_mask(plen));
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (key & ~mask)
|
2005-06-21 19:43:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
key = key & mask;
|
|
|
|
l = fib_find_node(t, key);
|
|
|
|
|
2005-07-19 21:01:51 +00:00
|
|
|
if (!l)
|
2005-06-21 19:43:18 +00:00
|
|
|
return -ESRCH;
|
|
|
|
|
|
|
|
fa_head = get_fa_head(l, plen);
|
|
|
|
fa = fib_find_alias(fa_head, tos, 0);
|
|
|
|
|
|
|
|
if (!fa)
|
|
|
|
return -ESRCH;
|
|
|
|
|
2005-08-24 04:59:41 +00:00
|
|
|
pr_debug("Deleting %08x/%d tos=%d t=%p\n", key, plen, tos, t);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
fa_to_delete = NULL;
|
2008-01-29 05:18:06 +00:00
|
|
|
fa = list_entry(fa->fa_list.prev, struct fib_alias, fa_list);
|
|
|
|
list_for_each_entry_continue(fa, fa_head, fa_list) {
|
2005-06-21 19:43:18 +00:00
|
|
|
struct fib_info *fi = fa->fa_info;
|
|
|
|
|
|
|
|
if (fa->fa_tos != tos)
|
|
|
|
break;
|
|
|
|
|
2006-08-18 01:14:52 +00:00
|
|
|
if ((!cfg->fc_type || fa->fa_type == cfg->fc_type) &&
|
|
|
|
(cfg->fc_scope == RT_SCOPE_NOWHERE ||
|
2011-03-25 01:06:47 +00:00
|
|
|
fa->fa_info->fib_scope == cfg->fc_scope) &&
|
2011-03-19 12:13:46 +00:00
|
|
|
(!cfg->fc_prefsrc ||
|
|
|
|
fi->fib_prefsrc == cfg->fc_prefsrc) &&
|
2006-08-18 01:14:52 +00:00
|
|
|
(!cfg->fc_protocol ||
|
|
|
|
fi->fib_protocol == cfg->fc_protocol) &&
|
|
|
|
fib_nh_match(cfg, fi) == 0) {
|
2005-06-21 19:43:18 +00:00
|
|
|
fa_to_delete = fa;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (!fa_to_delete)
|
|
|
|
return -ESRCH;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
fa = fa_to_delete;
|
2006-08-18 01:14:52 +00:00
|
|
|
rtmsg_fib(RTM_DELROUTE, htonl(key), fa, plen, tb->tb_id,
|
2007-05-23 21:55:06 +00:00
|
|
|
&cfg->fc_nlinfo, 0);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
|
|
|
l = fib_find_node(t, key);
|
2005-09-19 22:31:18 +00:00
|
|
|
li = find_leaf_info(l, plen);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
list_del_rcu(&fa->fa_list);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2011-04-14 21:49:37 +00:00
|
|
|
if (!plen)
|
|
|
|
tb->tb_num_default--;
|
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (list_empty(fa_head)) {
|
2005-08-25 20:01:29 +00:00
|
|
|
hlist_del_rcu(&li->hlist);
|
2005-08-10 03:24:39 +00:00
|
|
|
free_leaf_info(li);
|
2005-08-25 20:01:29 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (hlist_empty(&l->list))
|
2008-01-23 05:56:34 +00:00
|
|
|
trie_leaf_remove(t, l);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-10 03:24:39 +00:00
|
|
|
if (fa->fa_state & FA_S_ACCESSED)
|
2008-07-06 02:00:44 +00:00
|
|
|
rt_cache_flush(cfg->fc_nlinfo.nl_net, -1);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
fib_release_info(fa->fa_info);
|
|
|
|
alias_free_mem_rcu(fa);
|
2005-08-10 03:24:39 +00:00
|
|
|
return 0;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2008-04-10 10:46:12 +00:00
|
|
|
static int trie_flush_list(struct list_head *head)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct fib_alias *fa, *fa_node;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(fa, fa_node, head, fa_list) {
|
|
|
|
struct fib_info *fi = fa->fa_info;
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
if (fi && (fi->fib_flags & RTNH_F_DEAD)) {
|
|
|
|
list_del_rcu(&fa->fa_list);
|
|
|
|
fib_release_info(fa->fa_info);
|
|
|
|
alias_free_mem_rcu(fa);
|
2005-06-21 19:43:18 +00:00
|
|
|
found++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2008-04-10 10:46:12 +00:00
|
|
|
static int trie_flush_leaf(struct leaf *l)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
int found = 0;
|
|
|
|
struct hlist_head *lih = &l->list;
|
|
|
|
struct hlist_node *node, *tmp;
|
|
|
|
struct leaf_info *li = NULL;
|
|
|
|
|
|
|
|
hlist_for_each_entry_safe(li, node, tmp, lih, hlist) {
|
2008-04-10 10:46:12 +00:00
|
|
|
found += trie_flush_list(&li->falh);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
if (list_empty(&li->falh)) {
|
2005-08-25 20:01:29 +00:00
|
|
|
hlist_del_rcu(&li->hlist);
|
2005-06-21 19:43:18 +00:00
|
|
|
free_leaf_info(li);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2008-01-23 05:55:32 +00:00
|
|
|
/*
|
|
|
|
* Scan for the next right leaf starting at node p->child[idx]
|
|
|
|
* Since we have back pointer, no recursion necessary.
|
|
|
|
*/
|
2011-02-03 04:48:10 +00:00
|
|
|
static struct leaf *leaf_walk_rcu(struct tnode *p, struct rt_trie_node *c)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-01-23 05:55:32 +00:00
|
|
|
do {
|
|
|
|
t_key idx;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
|
|
|
if (c)
|
2008-01-23 05:55:32 +00:00
|
|
|
idx = tkey_extract_bits(c->key, p->pos, p->bits) + 1;
|
2005-07-19 21:01:51 +00:00
|
|
|
else
|
2008-01-23 05:55:32 +00:00
|
|
|
idx = 0;
|
2005-08-25 20:01:29 +00:00
|
|
|
|
2008-01-23 05:55:32 +00:00
|
|
|
while (idx < 1u << p->bits) {
|
|
|
|
c = tnode_get_child_rcu(p, idx++);
|
2005-08-25 20:01:29 +00:00
|
|
|
if (!c)
|
2005-08-10 03:24:39 +00:00
|
|
|
continue;
|
|
|
|
|
2008-01-23 05:55:32 +00:00
|
|
|
if (IS_LEAF(c)) {
|
2011-03-31 08:51:35 +00:00
|
|
|
prefetch(rcu_dereference_rtnl(p->child[idx]));
|
2008-01-23 05:55:32 +00:00
|
|
|
return (struct leaf *) c;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2008-01-23 05:55:32 +00:00
|
|
|
|
|
|
|
/* Rescan start scanning in new node */
|
|
|
|
p = (struct tnode *) c;
|
|
|
|
idx = 0;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2008-01-23 05:55:32 +00:00
|
|
|
|
|
|
|
/* Node empty, walk back up to parent */
|
2011-02-03 04:48:10 +00:00
|
|
|
c = (struct rt_trie_node *) p;
|
2010-09-09 23:32:28 +00:00
|
|
|
} while ((p = node_parent_rcu(c)) != NULL);
|
2008-01-23 05:55:32 +00:00
|
|
|
|
|
|
|
return NULL; /* Root of trie */
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct leaf *trie_firstleaf(struct trie *t)
|
|
|
|
{
|
2010-09-09 23:32:28 +00:00
|
|
|
struct tnode *n = (struct tnode *)rcu_dereference_rtnl(t->trie);
|
2008-01-23 05:55:32 +00:00
|
|
|
|
|
|
|
if (!n)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (IS_LEAF(n)) /* trie is just a leaf */
|
|
|
|
return (struct leaf *) n;
|
|
|
|
|
|
|
|
return leaf_walk_rcu(n, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct leaf *trie_nextleaf(struct leaf *l)
|
|
|
|
{
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *c = (struct rt_trie_node *) l;
|
2009-07-14 11:20:32 +00:00
|
|
|
struct tnode *p = node_parent_rcu(c);
|
2008-01-23 05:55:32 +00:00
|
|
|
|
|
|
|
if (!p)
|
|
|
|
return NULL; /* trie with just one leaf */
|
|
|
|
|
|
|
|
return leaf_walk_rcu(p, c);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2008-02-01 00:45:47 +00:00
|
|
|
static struct leaf *trie_leafindex(struct trie *t, int index)
|
|
|
|
{
|
|
|
|
struct leaf *l = trie_firstleaf(t);
|
|
|
|
|
2008-02-12 05:12:49 +00:00
|
|
|
while (l && index-- > 0)
|
2008-02-01 00:45:47 +00:00
|
|
|
l = trie_nextleaf(l);
|
2008-02-12 05:12:49 +00:00
|
|
|
|
2008-02-01 00:45:47 +00:00
|
|
|
return l;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-03-26 21:22:22 +00:00
|
|
|
/*
|
|
|
|
* Caller must hold RTNL.
|
|
|
|
*/
|
2009-09-20 10:35:36 +00:00
|
|
|
int fib_table_flush(struct fib_table *tb)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct trie *t = (struct trie *) tb->tb_data;
|
2008-01-23 05:56:34 +00:00
|
|
|
struct leaf *l, *ll = NULL;
|
2008-01-23 05:55:32 +00:00
|
|
|
int found = 0;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-23 05:55:32 +00:00
|
|
|
for (l = trie_firstleaf(t); l; l = trie_nextleaf(l)) {
|
2008-04-10 10:46:12 +00:00
|
|
|
found += trie_flush_leaf(l);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
if (ll && hlist_empty(&ll->list))
|
2008-01-23 05:56:34 +00:00
|
|
|
trie_leaf_remove(t, ll);
|
2005-06-21 19:43:18 +00:00
|
|
|
ll = l;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ll && hlist_empty(&ll->list))
|
2008-01-23 05:56:34 +00:00
|
|
|
trie_leaf_remove(t, ll);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2012-06-11 07:01:52 +00:00
|
|
|
inetpeer_invalidate_tree(&tb->tb_peers);
|
|
|
|
|
2005-08-24 04:59:41 +00:00
|
|
|
pr_debug("trie_flush found=%d\n", found);
|
2005-06-21 19:43:18 +00:00
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2010-10-28 02:00:43 +00:00
|
|
|
void fib_free_table(struct fib_table *tb)
|
|
|
|
{
|
|
|
|
kfree(tb);
|
|
|
|
}
|
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
static int fn_trie_dump_fa(t_key key, int plen, struct list_head *fah,
|
|
|
|
struct fib_table *tb,
|
2005-06-21 19:43:18 +00:00
|
|
|
struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
|
|
|
int i, s_i;
|
|
|
|
struct fib_alias *fa;
|
2006-09-27 05:21:45 +00:00
|
|
|
__be32 xkey = htonl(key);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-02-01 00:45:47 +00:00
|
|
|
s_i = cb->args[5];
|
2005-06-21 19:43:18 +00:00
|
|
|
i = 0;
|
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
/* rcu_read_lock is hold by caller */
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(fa, fah, fa_list) {
|
2005-06-21 19:43:18 +00:00
|
|
|
if (i < s_i) {
|
|
|
|
i++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fib_dump_info(skb, NETLINK_CB(cb->skb).pid,
|
|
|
|
cb->nlh->nlmsg_seq,
|
|
|
|
RTM_NEWROUTE,
|
|
|
|
tb->tb_id,
|
|
|
|
fa->fa_type,
|
2006-08-18 01:15:17 +00:00
|
|
|
xkey,
|
2005-06-21 19:43:18 +00:00
|
|
|
plen,
|
|
|
|
fa->fa_tos,
|
2008-01-23 05:55:01 +00:00
|
|
|
fa->fa_info, NLM_F_MULTI) < 0) {
|
2008-02-01 00:45:47 +00:00
|
|
|
cb->args[5] = i;
|
2005-06-21 19:43:18 +00:00
|
|
|
return -1;
|
2005-08-10 03:24:39 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
i++;
|
|
|
|
}
|
2008-02-01 00:45:47 +00:00
|
|
|
cb->args[5] = i;
|
2005-06-21 19:43:18 +00:00
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
2008-01-23 05:56:11 +00:00
|
|
|
static int fn_trie_dump_leaf(struct leaf *l, struct fib_table *tb,
|
|
|
|
struct sk_buff *skb, struct netlink_callback *cb)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-01-23 05:56:11 +00:00
|
|
|
struct leaf_info *li;
|
|
|
|
struct hlist_node *node;
|
|
|
|
int i, s_i;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-02-01 00:45:47 +00:00
|
|
|
s_i = cb->args[4];
|
2008-01-23 05:56:11 +00:00
|
|
|
i = 0;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-23 05:56:11 +00:00
|
|
|
/* rcu_read_lock is hold by caller */
|
|
|
|
hlist_for_each_entry_rcu(li, node, &l->list, hlist) {
|
|
|
|
if (i < s_i) {
|
|
|
|
i++;
|
2005-06-21 19:43:18 +00:00
|
|
|
continue;
|
2008-01-23 05:56:11 +00:00
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2008-01-23 05:56:11 +00:00
|
|
|
if (i > s_i)
|
2008-02-01 00:45:47 +00:00
|
|
|
cb->args[5] = 0;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-23 05:56:11 +00:00
|
|
|
if (list_empty(&li->falh))
|
2005-06-21 19:43:18 +00:00
|
|
|
continue;
|
|
|
|
|
2008-01-23 05:56:11 +00:00
|
|
|
if (fn_trie_dump_fa(l->key, li->plen, &li->falh, tb, skb, cb) < 0) {
|
2008-02-01 00:45:47 +00:00
|
|
|
cb->args[4] = i;
|
2005-06-21 19:43:18 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-01-23 05:56:11 +00:00
|
|
|
i++;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2008-01-23 05:56:11 +00:00
|
|
|
|
2008-02-01 00:45:47 +00:00
|
|
|
cb->args[4] = i;
|
2005-06-21 19:43:18 +00:00
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
2009-09-20 10:35:36 +00:00
|
|
|
int fib_table_dump(struct fib_table *tb, struct sk_buff *skb,
|
|
|
|
struct netlink_callback *cb)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-01-23 05:56:11 +00:00
|
|
|
struct leaf *l;
|
2005-06-21 19:43:18 +00:00
|
|
|
struct trie *t = (struct trie *) tb->tb_data;
|
2008-01-23 05:57:22 +00:00
|
|
|
t_key key = cb->args[2];
|
2008-02-01 00:45:47 +00:00
|
|
|
int count = cb->args[3];
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-08-25 20:01:29 +00:00
|
|
|
rcu_read_lock();
|
2008-01-23 05:57:22 +00:00
|
|
|
/* Dump starting at last key.
|
|
|
|
* Note: 0.0.0.0/0 (ie default) is first key.
|
|
|
|
*/
|
2008-02-01 00:45:47 +00:00
|
|
|
if (count == 0)
|
2008-01-23 05:57:22 +00:00
|
|
|
l = trie_firstleaf(t);
|
|
|
|
else {
|
2008-02-01 00:45:47 +00:00
|
|
|
/* Normally, continue from last key, but if that is missing
|
|
|
|
* fallback to using slow rescan
|
|
|
|
*/
|
2008-01-23 05:57:22 +00:00
|
|
|
l = fib_find_node(t, key);
|
2008-02-01 00:45:47 +00:00
|
|
|
if (!l)
|
|
|
|
l = trie_leafindex(t, count);
|
2008-01-23 05:57:22 +00:00
|
|
|
}
|
2008-01-23 05:56:11 +00:00
|
|
|
|
2008-01-23 05:57:22 +00:00
|
|
|
while (l) {
|
|
|
|
cb->args[2] = l->key;
|
2008-01-23 05:56:11 +00:00
|
|
|
if (fn_trie_dump_leaf(l, tb, skb, cb) < 0) {
|
2008-02-01 00:45:47 +00:00
|
|
|
cb->args[3] = count;
|
2008-01-23 05:56:11 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
return -1;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2008-01-23 05:57:22 +00:00
|
|
|
|
2008-02-01 00:45:47 +00:00
|
|
|
++count;
|
2008-01-23 05:57:22 +00:00
|
|
|
l = trie_nextleaf(l);
|
2008-02-01 00:45:47 +00:00
|
|
|
memset(&cb->args[4], 0,
|
|
|
|
sizeof(cb->args) - 4*sizeof(cb->args[0]));
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2008-02-01 00:45:47 +00:00
|
|
|
cb->args[3] = count;
|
2005-08-25 20:01:29 +00:00
|
|
|
rcu_read_unlock();
|
2008-01-23 05:56:11 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
2011-02-01 23:30:56 +00:00
|
|
|
void __init fib_trie_init(void)
|
2008-01-15 07:14:20 +00:00
|
|
|
{
|
2008-01-23 05:53:36 +00:00
|
|
|
fn_alias_kmem = kmem_cache_create("ip_fib_alias",
|
|
|
|
sizeof(struct fib_alias),
|
2008-01-23 05:51:50 +00:00
|
|
|
0, SLAB_PANIC, NULL);
|
|
|
|
|
|
|
|
trie_leaf_kmem = kmem_cache_create("ip_fib_trie",
|
|
|
|
max(sizeof(struct leaf),
|
|
|
|
sizeof(struct leaf_info)),
|
|
|
|
0, SLAB_PANIC, NULL);
|
2008-01-15 07:14:20 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-15 07:14:20 +00:00
|
|
|
|
2011-02-01 23:30:56 +00:00
|
|
|
struct fib_table *fib_trie_table(u32 id)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
|
|
|
struct fib_table *tb;
|
|
|
|
struct trie *t;
|
|
|
|
|
|
|
|
tb = kmalloc(sizeof(struct fib_table) + sizeof(struct trie),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (tb == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
tb->tb_id = id;
|
2007-12-08 08:32:23 +00:00
|
|
|
tb->tb_default = -1;
|
2011-04-14 21:49:37 +00:00
|
|
|
tb->tb_num_default = 0;
|
2012-06-11 07:01:52 +00:00
|
|
|
inet_peer_base_init(&tb->tb_peers);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
t = (struct trie *) tb->tb_data;
|
2008-01-13 04:49:13 +00:00
|
|
|
memset(t, 0, sizeof(*t));
|
2005-06-21 19:43:18 +00:00
|
|
|
|
|
|
|
return tb;
|
|
|
|
}
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
/* Depth first Trie walk iterator */
|
|
|
|
struct fib_trie_iter {
|
2008-01-10 11:27:17 +00:00
|
|
|
struct seq_net_private p;
|
2008-03-24 05:43:56 +00:00
|
|
|
struct fib_table *tb;
|
2005-09-09 20:35:42 +00:00
|
|
|
struct tnode *tnode;
|
2010-09-09 23:32:28 +00:00
|
|
|
unsigned int index;
|
|
|
|
unsigned int depth;
|
2005-09-09 20:35:42 +00:00
|
|
|
};
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
static struct rt_trie_node *fib_trie_get_next(struct fib_trie_iter *iter)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-09-09 20:35:42 +00:00
|
|
|
struct tnode *tn = iter->tnode;
|
2010-09-09 23:32:28 +00:00
|
|
|
unsigned int cindex = iter->index;
|
2005-09-09 20:35:42 +00:00
|
|
|
struct tnode *p;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2007-01-24 22:42:04 +00:00
|
|
|
/* A single entry routing table */
|
|
|
|
if (!tn)
|
|
|
|
return NULL;
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
pr_debug("get_next iter={node=%p index=%d depth=%d}\n",
|
|
|
|
iter->tnode, iter->index, iter->depth);
|
|
|
|
rescan:
|
|
|
|
while (cindex < (1<<tn->bits)) {
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n = tnode_get_child_rcu(tn, cindex);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
if (n) {
|
|
|
|
if (IS_LEAF(n)) {
|
|
|
|
iter->tnode = tn;
|
|
|
|
iter->index = cindex + 1;
|
|
|
|
} else {
|
|
|
|
/* push down one level */
|
|
|
|
iter->tnode = (struct tnode *) n;
|
|
|
|
iter->index = 0;
|
|
|
|
++iter->depth;
|
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
++cindex;
|
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
/* Current node exhausted, pop back up */
|
2011-02-03 04:48:10 +00:00
|
|
|
p = node_parent_rcu((struct rt_trie_node *)tn);
|
2005-09-09 20:35:42 +00:00
|
|
|
if (p) {
|
|
|
|
cindex = tkey_extract_bits(tn->key, p->pos, p->bits)+1;
|
|
|
|
tn = p;
|
|
|
|
--iter->depth;
|
|
|
|
goto rescan;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2005-09-09 20:35:42 +00:00
|
|
|
|
|
|
|
/* got root? */
|
|
|
|
return NULL;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
static struct rt_trie_node *fib_trie_get_first(struct fib_trie_iter *iter,
|
2005-09-09 20:35:42 +00:00
|
|
|
struct trie *t)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n;
|
2006-03-21 05:34:12 +00:00
|
|
|
|
2007-03-09 04:44:43 +00:00
|
|
|
if (!t)
|
2006-03-21 05:34:12 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
n = rcu_dereference(t->trie);
|
2008-03-24 05:43:56 +00:00
|
|
|
if (!n)
|
2006-03-21 05:34:12 +00:00
|
|
|
return NULL;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
if (IS_TNODE(n)) {
|
|
|
|
iter->tnode = (struct tnode *) n;
|
|
|
|
iter->index = 0;
|
|
|
|
iter->depth = 1;
|
|
|
|
} else {
|
|
|
|
iter->tnode = NULL;
|
|
|
|
iter->index = 0;
|
|
|
|
iter->depth = 0;
|
2005-08-10 03:24:39 +00:00
|
|
|
}
|
2008-03-24 05:43:56 +00:00
|
|
|
|
|
|
|
return n;
|
2005-09-09 20:35:42 +00:00
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static void trie_collect_stats(struct trie *t, struct trie_stat *s)
|
|
|
|
{
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n;
|
2005-09-09 20:35:42 +00:00
|
|
|
struct fib_trie_iter iter;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
memset(s, 0, sizeof(*s));
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
rcu_read_lock();
|
2008-03-24 05:43:56 +00:00
|
|
|
for (n = fib_trie_get_first(&iter, t); n; n = fib_trie_get_next(&iter)) {
|
2005-09-09 20:35:42 +00:00
|
|
|
if (IS_LEAF(n)) {
|
2008-01-23 05:54:05 +00:00
|
|
|
struct leaf *l = (struct leaf *)n;
|
|
|
|
struct leaf_info *li;
|
|
|
|
struct hlist_node *tmp;
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
s->leaves++;
|
|
|
|
s->totdepth += iter.depth;
|
|
|
|
if (iter.depth > s->maxdepth)
|
|
|
|
s->maxdepth = iter.depth;
|
2008-01-23 05:54:05 +00:00
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(li, tmp, &l->list, hlist)
|
|
|
|
++s->prefixes;
|
2005-09-09 20:35:42 +00:00
|
|
|
} else {
|
|
|
|
const struct tnode *tn = (const struct tnode *) n;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
s->tnodes++;
|
2007-03-09 04:44:43 +00:00
|
|
|
if (tn->bits < MAX_STAT_DEPTH)
|
2006-03-21 05:35:01 +00:00
|
|
|
s->nodesizes[tn->bits]++;
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
for (i = 0; i < (1<<tn->bits); i++)
|
|
|
|
if (!tn->child[i])
|
|
|
|
s->nullpointers++;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
}
|
2005-08-25 20:01:29 +00:00
|
|
|
rcu_read_unlock();
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
/*
|
|
|
|
* This outputs /proc/net/fib_triestats
|
|
|
|
*/
|
|
|
|
static void trie_show_stats(struct seq_file *seq, struct trie_stat *stat)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2010-09-09 23:32:28 +00:00
|
|
|
unsigned int i, max, pointers, bytes, avdepth;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
if (stat->leaves)
|
|
|
|
avdepth = stat->totdepth*100 / stat->leaves;
|
|
|
|
else
|
|
|
|
avdepth = 0;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2008-01-23 05:53:36 +00:00
|
|
|
seq_printf(seq, "\tAver depth: %u.%02d\n",
|
|
|
|
avdepth / 100, avdepth % 100);
|
2005-09-09 20:35:42 +00:00
|
|
|
seq_printf(seq, "\tMax depth: %u\n", stat->maxdepth);
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
seq_printf(seq, "\tLeaves: %u\n", stat->leaves);
|
|
|
|
bytes = sizeof(struct leaf) * stat->leaves;
|
2008-01-23 05:54:05 +00:00
|
|
|
|
|
|
|
seq_printf(seq, "\tPrefixes: %u\n", stat->prefixes);
|
|
|
|
bytes += sizeof(struct leaf_info) * stat->prefixes;
|
|
|
|
|
2008-01-13 04:55:55 +00:00
|
|
|
seq_printf(seq, "\tInternal nodes: %u\n\t", stat->tnodes);
|
2005-09-09 20:35:42 +00:00
|
|
|
bytes += sizeof(struct tnode) * stat->tnodes;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2006-03-21 05:35:01 +00:00
|
|
|
max = MAX_STAT_DEPTH;
|
|
|
|
while (max > 0 && stat->nodesizes[max-1] == 0)
|
2005-09-09 20:35:42 +00:00
|
|
|
max--;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
pointers = 0;
|
|
|
|
for (i = 1; i <= max; i++)
|
|
|
|
if (stat->nodesizes[i] != 0) {
|
2008-01-13 04:55:55 +00:00
|
|
|
seq_printf(seq, " %u: %u", i, stat->nodesizes[i]);
|
2005-09-09 20:35:42 +00:00
|
|
|
pointers += (1<<i) * stat->nodesizes[i];
|
|
|
|
}
|
|
|
|
seq_putc(seq, '\n');
|
2008-01-13 04:55:55 +00:00
|
|
|
seq_printf(seq, "\tPointers: %u\n", pointers);
|
2005-08-25 20:01:29 +00:00
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
bytes += sizeof(struct rt_trie_node *) * pointers;
|
2008-01-13 04:55:55 +00:00
|
|
|
seq_printf(seq, "Null ptrs: %u\n", stat->nullpointers);
|
|
|
|
seq_printf(seq, "Total size: %u kB\n", (bytes + 1023) / 1024);
|
2008-01-13 05:23:17 +00:00
|
|
|
}
|
2005-08-25 20:01:29 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
2008-01-13 05:23:17 +00:00
|
|
|
static void trie_show_usage(struct seq_file *seq,
|
|
|
|
const struct trie_use_stats *stats)
|
|
|
|
{
|
|
|
|
seq_printf(seq, "\nCounters:\n---------\n");
|
2008-01-23 05:53:36 +00:00
|
|
|
seq_printf(seq, "gets = %u\n", stats->gets);
|
|
|
|
seq_printf(seq, "backtracks = %u\n", stats->backtrack);
|
|
|
|
seq_printf(seq, "semantic match passed = %u\n",
|
|
|
|
stats->semantic_match_passed);
|
|
|
|
seq_printf(seq, "semantic match miss = %u\n",
|
|
|
|
stats->semantic_match_miss);
|
|
|
|
seq_printf(seq, "null node hit= %u\n", stats->null_node_hit);
|
|
|
|
seq_printf(seq, "skipped node resize = %u\n\n",
|
|
|
|
stats->resize_node_skipped);
|
2005-09-09 20:35:42 +00:00
|
|
|
}
|
2008-01-13 05:23:17 +00:00
|
|
|
#endif /* CONFIG_IP_FIB_TRIE_STATS */
|
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
static void fib_table_print(struct seq_file *seq, struct fib_table *tb)
|
2008-01-15 07:11:54 +00:00
|
|
|
{
|
2008-03-24 05:43:56 +00:00
|
|
|
if (tb->tb_id == RT_TABLE_LOCAL)
|
|
|
|
seq_puts(seq, "Local:\n");
|
|
|
|
else if (tb->tb_id == RT_TABLE_MAIN)
|
|
|
|
seq_puts(seq, "Main:\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "Id %d:\n", tb->tb_id);
|
2008-01-15 07:11:54 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static int fib_triestat_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2008-01-10 11:27:17 +00:00
|
|
|
struct net *net = (struct net *)seq->private;
|
2008-03-24 05:43:56 +00:00
|
|
|
unsigned int h;
|
2007-12-07 08:47:47 +00:00
|
|
|
|
2008-01-15 07:11:54 +00:00
|
|
|
seq_printf(seq,
|
2008-01-23 05:53:36 +00:00
|
|
|
"Basic info: size of leaf:"
|
|
|
|
" %Zd bytes, size of tnode: %Zd bytes.\n",
|
2008-01-15 07:11:54 +00:00
|
|
|
sizeof(struct leaf), sizeof(struct tnode));
|
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
|
|
|
|
struct hlist_head *head = &net->ipv4.fib_table_hash[h];
|
|
|
|
struct hlist_node *node;
|
|
|
|
struct fib_table *tb;
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
|
|
|
|
struct trie *t = (struct trie *) tb->tb_data;
|
|
|
|
struct trie_stat stat;
|
2007-12-07 08:47:47 +00:00
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
if (!t)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
fib_table_print(seq, tb);
|
|
|
|
|
|
|
|
trie_collect_stats(t, &stat);
|
|
|
|
trie_show_stats(seq, &stat);
|
|
|
|
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
|
|
|
trie_show_usage(seq, &t->stats);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
return 0;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static int fib_triestat_seq_open(struct inode *inode, struct file *file)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-07-18 11:07:21 +00:00
|
|
|
return single_open_net(inode, file, fib_triestat_seq_show);
|
2008-01-10 11:27:17 +00:00
|
|
|
}
|
|
|
|
|
2007-02-12 08:55:35 +00:00
|
|
|
static const struct file_operations fib_triestat_fops = {
|
2005-09-09 20:35:42 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = fib_triestat_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-07-18 11:07:44 +00:00
|
|
|
.release = single_release_net,
|
2005-09-09 20:35:42 +00:00
|
|
|
};
|
|
|
|
|
2011-02-03 04:48:10 +00:00
|
|
|
static struct rt_trie_node *fib_trie_get_idx(struct seq_file *seq, loff_t pos)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-03-25 17:36:06 +00:00
|
|
|
struct fib_trie_iter *iter = seq->private;
|
|
|
|
struct net *net = seq_file_net(seq);
|
2005-09-09 20:35:42 +00:00
|
|
|
loff_t idx = 0;
|
2008-03-24 05:43:56 +00:00
|
|
|
unsigned int h;
|
2005-09-09 20:35:42 +00:00
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
|
|
|
|
struct hlist_head *head = &net->ipv4.fib_table_hash[h];
|
|
|
|
struct hlist_node *node;
|
|
|
|
struct fib_table *tb;
|
2005-09-09 20:35:42 +00:00
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n;
|
2008-03-24 05:43:56 +00:00
|
|
|
|
|
|
|
for (n = fib_trie_get_first(iter,
|
|
|
|
(struct trie *) tb->tb_data);
|
|
|
|
n; n = fib_trie_get_next(iter))
|
|
|
|
if (pos == idx++) {
|
|
|
|
iter->tb = tb;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
}
|
2005-09-09 20:35:42 +00:00
|
|
|
}
|
2008-03-24 05:43:56 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static void *fib_trie_seq_start(struct seq_file *seq, loff_t *pos)
|
2008-01-13 05:25:02 +00:00
|
|
|
__acquires(RCU)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-09-09 20:35:42 +00:00
|
|
|
rcu_read_lock();
|
2008-03-25 17:36:06 +00:00
|
|
|
return fib_trie_get_idx(seq, *pos);
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static void *fib_trie_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-09-09 20:35:42 +00:00
|
|
|
struct fib_trie_iter *iter = seq->private;
|
2008-03-25 17:36:06 +00:00
|
|
|
struct net *net = seq_file_net(seq);
|
2008-03-24 05:43:56 +00:00
|
|
|
struct fib_table *tb = iter->tb;
|
|
|
|
struct hlist_node *tb_node;
|
|
|
|
unsigned int h;
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n;
|
2005-09-09 20:35:42 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
++*pos;
|
2008-03-24 05:43:56 +00:00
|
|
|
/* next node in same table */
|
|
|
|
n = fib_trie_get_next(iter);
|
|
|
|
if (n)
|
|
|
|
return n;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
/* walk rest of this hash chain */
|
|
|
|
h = tb->tb_id & (FIB_TABLE_HASHSZ - 1);
|
2011-03-31 08:51:35 +00:00
|
|
|
while ((tb_node = rcu_dereference(hlist_next_rcu(&tb->tb_hlist)))) {
|
2008-03-24 05:43:56 +00:00
|
|
|
tb = hlist_entry(tb_node, struct fib_table, tb_hlist);
|
|
|
|
n = fib_trie_get_first(iter, (struct trie *) tb->tb_data);
|
|
|
|
if (n)
|
|
|
|
goto found;
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
/* new hash chain */
|
|
|
|
while (++h < FIB_TABLE_HASHSZ) {
|
|
|
|
struct hlist_head *head = &net->ipv4.fib_table_hash[h];
|
|
|
|
hlist_for_each_entry_rcu(tb, tb_node, head, tb_hlist) {
|
|
|
|
n = fib_trie_get_first(iter, (struct trie *) tb->tb_data);
|
|
|
|
if (n)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
}
|
2005-09-09 20:35:42 +00:00
|
|
|
return NULL;
|
2008-03-24 05:43:56 +00:00
|
|
|
|
|
|
|
found:
|
|
|
|
iter->tb = tb;
|
|
|
|
return n;
|
2005-09-09 20:35:42 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static void fib_trie_seq_stop(struct seq_file *seq, void *v)
|
2008-01-13 05:25:02 +00:00
|
|
|
__releases(RCU)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-09-09 20:35:42 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static void seq_indent(struct seq_file *seq, int n)
|
|
|
|
{
|
2010-09-09 23:32:28 +00:00
|
|
|
while (n-- > 0)
|
|
|
|
seq_puts(seq, " ");
|
2005-09-09 20:35:42 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-15 07:09:56 +00:00
|
|
|
static inline const char *rtn_scope(char *buf, size_t len, enum rt_scope_t s)
|
2005-09-09 20:35:42 +00:00
|
|
|
{
|
2007-03-09 04:44:43 +00:00
|
|
|
switch (s) {
|
2005-09-09 20:35:42 +00:00
|
|
|
case RT_SCOPE_UNIVERSE: return "universe";
|
|
|
|
case RT_SCOPE_SITE: return "site";
|
|
|
|
case RT_SCOPE_LINK: return "link";
|
|
|
|
case RT_SCOPE_HOST: return "host";
|
|
|
|
case RT_SCOPE_NOWHERE: return "nowhere";
|
|
|
|
default:
|
2008-01-15 07:09:56 +00:00
|
|
|
snprintf(buf, len, "scope=%d", s);
|
2005-09-09 20:35:42 +00:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2009-08-05 17:42:58 +00:00
|
|
|
static const char *const rtn_type_names[__RTN_MAX] = {
|
2005-09-09 20:35:42 +00:00
|
|
|
[RTN_UNSPEC] = "UNSPEC",
|
|
|
|
[RTN_UNICAST] = "UNICAST",
|
|
|
|
[RTN_LOCAL] = "LOCAL",
|
|
|
|
[RTN_BROADCAST] = "BROADCAST",
|
|
|
|
[RTN_ANYCAST] = "ANYCAST",
|
|
|
|
[RTN_MULTICAST] = "MULTICAST",
|
|
|
|
[RTN_BLACKHOLE] = "BLACKHOLE",
|
|
|
|
[RTN_UNREACHABLE] = "UNREACHABLE",
|
|
|
|
[RTN_PROHIBIT] = "PROHIBIT",
|
|
|
|
[RTN_THROW] = "THROW",
|
|
|
|
[RTN_NAT] = "NAT",
|
|
|
|
[RTN_XRESOLVE] = "XRESOLVE",
|
|
|
|
};
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2010-09-09 23:32:28 +00:00
|
|
|
static inline const char *rtn_type(char *buf, size_t len, unsigned int t)
|
2005-09-09 20:35:42 +00:00
|
|
|
{
|
|
|
|
if (t < __RTN_MAX && rtn_type_names[t])
|
|
|
|
return rtn_type_names[t];
|
2008-01-15 07:09:56 +00:00
|
|
|
snprintf(buf, len, "type %u", t);
|
2005-09-09 20:35:42 +00:00
|
|
|
return buf;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
/* Pretty print the trie */
|
|
|
|
static int fib_trie_seq_show(struct seq_file *seq, void *v)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-09-09 20:35:42 +00:00
|
|
|
const struct fib_trie_iter *iter = seq->private;
|
2011-02-03 04:48:10 +00:00
|
|
|
struct rt_trie_node *n = v;
|
2005-07-19 21:01:51 +00:00
|
|
|
|
2008-03-24 05:43:56 +00:00
|
|
|
if (!node_parent_rcu(n))
|
|
|
|
fib_table_print(seq, iter->tb);
|
2007-01-27 03:06:01 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
if (IS_TNODE(n)) {
|
|
|
|
struct tnode *tn = (struct tnode *) n;
|
2007-08-10 22:22:58 +00:00
|
|
|
__be32 prf = htonl(mask_pfx(tn->key, tn->pos));
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-09-19 22:29:52 +00:00
|
|
|
seq_indent(seq, iter->depth-1);
|
2008-10-31 07:53:57 +00:00
|
|
|
seq_printf(seq, " +-- %pI4/%d %d %d %d\n",
|
|
|
|
&prf, tn->pos, tn->bits, tn->full_children,
|
2005-09-19 22:29:52 +00:00
|
|
|
tn->empty_children);
|
2007-02-09 14:24:47 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
} else {
|
|
|
|
struct leaf *l = (struct leaf *) n;
|
2008-01-23 05:54:37 +00:00
|
|
|
struct leaf_info *li;
|
|
|
|
struct hlist_node *node;
|
2006-09-27 05:21:45 +00:00
|
|
|
__be32 val = htonl(l->key);
|
2005-09-09 20:35:42 +00:00
|
|
|
|
|
|
|
seq_indent(seq, iter->depth);
|
2008-10-31 07:53:57 +00:00
|
|
|
seq_printf(seq, " |-- %pI4\n", &val);
|
2008-01-23 05:54:37 +00:00
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(li, node, &l->list, hlist) {
|
|
|
|
struct fib_alias *fa;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(fa, &li->falh, fa_list) {
|
|
|
|
char buf1[32], buf2[32];
|
|
|
|
|
|
|
|
seq_indent(seq, iter->depth+1);
|
|
|
|
seq_printf(seq, " /%d %s %s", li->plen,
|
|
|
|
rtn_scope(buf1, sizeof(buf1),
|
2011-03-25 01:06:47 +00:00
|
|
|
fa->fa_info->fib_scope),
|
2008-01-23 05:54:37 +00:00
|
|
|
rtn_type(buf2, sizeof(buf2),
|
|
|
|
fa->fa_type));
|
|
|
|
if (fa->fa_tos)
|
2008-02-05 10:58:45 +00:00
|
|
|
seq_printf(seq, " tos=%d", fa->fa_tos);
|
2008-01-23 05:54:37 +00:00
|
|
|
seq_putc(seq, '\n');
|
2005-09-09 20:35:42 +00:00
|
|
|
}
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
2005-09-09 20:35:42 +00:00
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-12 21:34:29 +00:00
|
|
|
static const struct seq_operations fib_trie_seq_ops = {
|
2005-09-09 20:35:42 +00:00
|
|
|
.start = fib_trie_seq_start,
|
|
|
|
.next = fib_trie_seq_next,
|
|
|
|
.stop = fib_trie_seq_stop,
|
|
|
|
.show = fib_trie_seq_show,
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static int fib_trie_seq_open(struct inode *inode, struct file *file)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-01-10 11:27:17 +00:00
|
|
|
return seq_open_net(inode, file, &fib_trie_seq_ops,
|
|
|
|
sizeof(struct fib_trie_iter));
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2007-02-12 08:55:35 +00:00
|
|
|
static const struct file_operations fib_trie_fops = {
|
2005-09-09 20:35:42 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = fib_trie_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-01-10 11:27:17 +00:00
|
|
|
.release = seq_release_net,
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
|
2008-02-12 05:14:39 +00:00
|
|
|
struct fib_route_iter {
|
|
|
|
struct seq_net_private p;
|
|
|
|
struct trie *main_trie;
|
|
|
|
loff_t pos;
|
|
|
|
t_key key;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct leaf *fib_route_get_idx(struct fib_route_iter *iter, loff_t pos)
|
|
|
|
{
|
|
|
|
struct leaf *l = NULL;
|
|
|
|
struct trie *t = iter->main_trie;
|
|
|
|
|
|
|
|
/* use cache location of last found key */
|
|
|
|
if (iter->pos > 0 && pos >= iter->pos && (l = fib_find_node(t, iter->key)))
|
|
|
|
pos -= iter->pos;
|
|
|
|
else {
|
|
|
|
iter->pos = 0;
|
|
|
|
l = trie_firstleaf(t);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (l && pos-- > 0) {
|
|
|
|
iter->pos++;
|
|
|
|
l = trie_nextleaf(l);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (l)
|
|
|
|
iter->key = pos; /* remember it */
|
|
|
|
else
|
|
|
|
iter->pos = 0; /* forget it */
|
|
|
|
|
|
|
|
return l;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *fib_route_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
__acquires(RCU)
|
|
|
|
{
|
|
|
|
struct fib_route_iter *iter = seq->private;
|
|
|
|
struct fib_table *tb;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2008-03-25 17:36:06 +00:00
|
|
|
tb = fib_get_table(seq_file_net(seq), RT_TABLE_MAIN);
|
2008-02-12 05:14:39 +00:00
|
|
|
if (!tb)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
iter->main_trie = (struct trie *) tb->tb_data;
|
|
|
|
if (*pos == 0)
|
|
|
|
return SEQ_START_TOKEN;
|
|
|
|
else
|
|
|
|
return fib_route_get_idx(iter, *pos - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *fib_route_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct fib_route_iter *iter = seq->private;
|
|
|
|
struct leaf *l = v;
|
|
|
|
|
|
|
|
++*pos;
|
|
|
|
if (v == SEQ_START_TOKEN) {
|
|
|
|
iter->pos = 0;
|
|
|
|
l = trie_firstleaf(iter->main_trie);
|
|
|
|
} else {
|
|
|
|
iter->pos++;
|
|
|
|
l = trie_nextleaf(l);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (l)
|
|
|
|
iter->key = l->key;
|
|
|
|
else
|
|
|
|
iter->pos = 0;
|
|
|
|
return l;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fib_route_seq_stop(struct seq_file *seq, void *v)
|
|
|
|
__releases(RCU)
|
|
|
|
{
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2010-09-09 23:32:28 +00:00
|
|
|
static unsigned int fib_flag_trans(int type, __be32 mask, const struct fib_info *fi)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2010-09-09 23:32:28 +00:00
|
|
|
unsigned int flags = 0;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2010-09-09 23:32:28 +00:00
|
|
|
if (type == RTN_UNREACHABLE || type == RTN_PROHIBIT)
|
|
|
|
flags = RTF_REJECT;
|
2005-09-09 20:35:42 +00:00
|
|
|
if (fi && fi->fib_nh->nh_gw)
|
|
|
|
flags |= RTF_GATEWAY;
|
2006-09-27 05:21:45 +00:00
|
|
|
if (mask == htonl(0xFFFFFFFF))
|
2005-09-09 20:35:42 +00:00
|
|
|
flags |= RTF_HOST;
|
|
|
|
flags |= RTF_UP;
|
|
|
|
return flags;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
/*
|
|
|
|
* This outputs /proc/net/route.
|
|
|
|
* The format of the file is not supposed to be changed
|
2010-09-09 23:32:28 +00:00
|
|
|
* and needs to be same as fib_hash output to avoid breaking
|
2005-09-09 20:35:42 +00:00
|
|
|
* legacy utilities
|
|
|
|
*/
|
|
|
|
static int fib_route_seq_show(struct seq_file *seq, void *v)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2005-09-09 20:35:42 +00:00
|
|
|
struct leaf *l = v;
|
2008-01-23 05:54:37 +00:00
|
|
|
struct leaf_info *li;
|
|
|
|
struct hlist_node *node;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
if (v == SEQ_START_TOKEN) {
|
|
|
|
seq_printf(seq, "%-127s\n", "Iface\tDestination\tGateway "
|
|
|
|
"\tFlags\tRefCnt\tUse\tMetric\tMask\t\tMTU"
|
|
|
|
"\tWindow\tIRTT");
|
|
|
|
return 0;
|
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-01-23 05:54:37 +00:00
|
|
|
hlist_for_each_entry_rcu(li, node, &l->list, hlist) {
|
2005-09-09 20:35:42 +00:00
|
|
|
struct fib_alias *fa;
|
2006-09-27 05:21:45 +00:00
|
|
|
__be32 mask, prefix;
|
2005-08-10 03:24:39 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
mask = inet_make_mask(li->plen);
|
|
|
|
prefix = htonl(l->key);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
list_for_each_entry_rcu(fa, &li->falh, fa_list) {
|
2005-10-14 23:42:39 +00:00
|
|
|
const struct fib_info *fi = fa->fa_info;
|
2010-09-09 23:32:28 +00:00
|
|
|
unsigned int flags = fib_flag_trans(fa->fa_type, mask, fi);
|
2008-04-24 08:02:16 +00:00
|
|
|
int len;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
if (fa->fa_type == RTN_BROADCAST
|
|
|
|
|| fa->fa_type == RTN_MULTICAST)
|
|
|
|
continue;
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
if (fi)
|
2008-04-24 08:02:16 +00:00
|
|
|
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",
|
2005-09-09 20:35:42 +00:00
|
|
|
fi->fib_dev ? fi->fib_dev->name : "*",
|
|
|
|
prefix,
|
|
|
|
fi->fib_nh->nh_gw, flags, 0, 0,
|
|
|
|
fi->fib_priority,
|
|
|
|
mask,
|
2008-01-23 05:53:36 +00:00
|
|
|
(fi->fib_advmss ?
|
|
|
|
fi->fib_advmss + 40 : 0),
|
2005-09-09 20:35:42 +00:00
|
|
|
fi->fib_window,
|
2008-04-24 08:02:16 +00:00
|
|
|
fi->fib_rtt >> 3, &len);
|
2005-09-09 20:35:42 +00:00
|
|
|
else
|
2008-04-24 08:02:16 +00:00
|
|
|
seq_printf(seq,
|
|
|
|
"*\t%08X\t%08X\t%04X\t%d\t%u\t"
|
|
|
|
"%d\t%08X\t%d\t%u\t%u%n",
|
2005-09-09 20:35:42 +00:00
|
|
|
prefix, 0, flags, 0, 0, 0,
|
2008-04-24 08:02:16 +00:00
|
|
|
mask, 0, 0, 0, &len);
|
2005-06-21 19:43:18 +00:00
|
|
|
|
2008-04-24 08:02:16 +00:00
|
|
|
seq_printf(seq, "%*s\n", 127 - len, "");
|
2005-09-09 20:35:42 +00:00
|
|
|
}
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-12 21:34:29 +00:00
|
|
|
static const struct seq_operations fib_route_seq_ops = {
|
2008-02-12 05:14:39 +00:00
|
|
|
.start = fib_route_seq_start,
|
|
|
|
.next = fib_route_seq_next,
|
|
|
|
.stop = fib_route_seq_stop,
|
2005-09-09 20:35:42 +00:00
|
|
|
.show = fib_route_seq_show,
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
|
2005-09-09 20:35:42 +00:00
|
|
|
static int fib_route_seq_open(struct inode *inode, struct file *file)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-01-10 11:27:17 +00:00
|
|
|
return seq_open_net(inode, file, &fib_route_seq_ops,
|
2008-02-12 05:14:39 +00:00
|
|
|
sizeof(struct fib_route_iter));
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2007-02-12 08:55:35 +00:00
|
|
|
static const struct file_operations fib_route_fops = {
|
2005-09-09 20:35:42 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = fib_route_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-01-10 11:27:17 +00:00
|
|
|
.release = seq_release_net,
|
2005-06-21 19:43:18 +00:00
|
|
|
};
|
|
|
|
|
2008-01-10 11:21:09 +00:00
|
|
|
int __net_init fib_proc_init(struct net *net)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-01-10 11:21:09 +00:00
|
|
|
if (!proc_net_fops_create(net, "fib_trie", S_IRUGO, &fib_trie_fops))
|
2005-09-09 20:35:42 +00:00
|
|
|
goto out1;
|
|
|
|
|
2008-01-10 11:21:09 +00:00
|
|
|
if (!proc_net_fops_create(net, "fib_triestat", S_IRUGO,
|
|
|
|
&fib_triestat_fops))
|
2005-09-09 20:35:42 +00:00
|
|
|
goto out2;
|
|
|
|
|
2008-01-10 11:21:09 +00:00
|
|
|
if (!proc_net_fops_create(net, "route", S_IRUGO, &fib_route_fops))
|
2005-09-09 20:35:42 +00:00
|
|
|
goto out3;
|
|
|
|
|
2005-06-21 19:43:18 +00:00
|
|
|
return 0;
|
2005-09-09 20:35:42 +00:00
|
|
|
|
|
|
|
out3:
|
2008-01-10 11:21:09 +00:00
|
|
|
proc_net_remove(net, "fib_triestat");
|
2005-09-09 20:35:42 +00:00
|
|
|
out2:
|
2008-01-10 11:21:09 +00:00
|
|
|
proc_net_remove(net, "fib_trie");
|
2005-09-09 20:35:42 +00:00
|
|
|
out1:
|
|
|
|
return -ENOMEM;
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
2008-01-10 11:21:09 +00:00
|
|
|
void __net_exit fib_proc_exit(struct net *net)
|
2005-06-21 19:43:18 +00:00
|
|
|
{
|
2008-01-10 11:21:09 +00:00
|
|
|
proc_net_remove(net, "fib_trie");
|
|
|
|
proc_net_remove(net, "fib_triestat");
|
|
|
|
proc_net_remove(net, "route");
|
2005-06-21 19:43:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_PROC_FS */
|