ipv4: Fix fib_trie build in some configurations. (b299e4f0) · Commits · e / devices / android_kernel_oneplus_sm8150

net/ipv4/fib_trie.c

+60 −60

Original line number	Original line	Diff line number	Diff line
	@@ -95,7 +95,7 @@ typedef unsigned int t_key;
	#define IS_TNODE(n) (!(n->parent & T_LEAF))		#define IS_TNODE(n) (!(n->parent & T_LEAF))
	#define IS_LEAF(n) (n->parent & T_LEAF)		#define IS_LEAF(n) (n->parent & T_LEAF)

	struct node {		struct rt_trie_node {
	unsigned long parent;		unsigned long parent;
	t_key key;		t_key key;
	};		};
	@@ -126,7 +126,7 @@ struct tnode {
	struct work_struct work;		struct work_struct work;
	struct tnode *tnode_free;		struct tnode *tnode_free;
	};		};
	struct node *child[0];		struct rt_trie_node *child[0];
	};		};

	#ifdef CONFIG_IP_FIB_TRIE_STATS		#ifdef CONFIG_IP_FIB_TRIE_STATS
	@@ -151,16 +151,16 @@ struct trie_stat {
	};		};

	struct trie {		struct trie {
	struct node *trie;		struct rt_trie_node *trie;
	#ifdef CONFIG_IP_FIB_TRIE_STATS		#ifdef CONFIG_IP_FIB_TRIE_STATS
	struct trie_use_stats stats;		struct trie_use_stats stats;
	#endif		#endif
	};		};

	static void put_child(struct trie t, struct tnode tn, int i, struct node *n);		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 node n,		static void tnode_put_child_reorg(struct tnode tn, int i, struct rt_trie_node n,
	int wasfull);		int wasfull);
	static struct node resize(struct trie t, struct tnode *tn);		static struct rt_trie_node resize(struct trie t, struct tnode *tn);
	static struct tnode inflate(struct trie t, struct tnode *tn);		static struct tnode inflate(struct trie t, struct tnode *tn);
	static struct tnode halve(struct trie t, struct tnode *tn);		static struct tnode halve(struct trie t, struct tnode *tn);
	/* tnodes to free after resize(); protected by RTNL */		/* tnodes to free after resize(); protected by RTNL */
	@@ -177,12 +177,12 @@ static const int sync_pages = 128;
	static struct kmem_cache *fn_alias_kmem __read_mostly;		static struct kmem_cache *fn_alias_kmem __read_mostly;
	static struct kmem_cache *trie_leaf_kmem __read_mostly;		static struct kmem_cache *trie_leaf_kmem __read_mostly;

	static inline struct tnode node_parent(struct node node)		static inline struct tnode node_parent(struct rt_trie_node node)
	{		{
	return (struct tnode *)(node->parent & ~NODE_TYPE_MASK);		return (struct tnode *)(node->parent & ~NODE_TYPE_MASK);
	}		}

	static inline struct tnode node_parent_rcu(struct node node)		static inline struct tnode node_parent_rcu(struct rt_trie_node node)
	{		{
	struct tnode *ret = node_parent(node);		struct tnode *ret = node_parent(node);

	@@ -192,22 +192,22 @@ static inline struct tnode node_parent_rcu(struct node node)
	/* Same as rcu_assign_pointer		/* Same as rcu_assign_pointer
	* but that macro() assumes that value is a pointer.		* but that macro() assumes that value is a pointer.
	*/		*/
	static inline void node_set_parent(struct node node, struct tnode ptr)		static inline void node_set_parent(struct rt_trie_node node, struct tnode ptr)
	{		{
	smp_wmb();		smp_wmb();
	node->parent = (unsigned long)ptr \| NODE_TYPE(node);		node->parent = (unsigned long)ptr \| NODE_TYPE(node);
	}		}

	static inline struct node tnode_get_child(struct tnode tn, unsigned int i)		static inline struct rt_trie_node tnode_get_child(struct tnode tn, unsigned int i)
	{		{
	BUG_ON(i >= 1U << tn->bits);		BUG_ON(i >= 1U << tn->bits);

	return tn->child[i];		return tn->child[i];
	}		}

	static inline struct node tnode_get_child_rcu(struct tnode tn, unsigned int i)		static inline struct rt_trie_node tnode_get_child_rcu(struct tnode tn, unsigned int i)
	{		{
	struct node *ret = tnode_get_child(tn, i);		struct rt_trie_node *ret = tnode_get_child(tn, i);

	return rcu_dereference_rtnl(ret);		return rcu_dereference_rtnl(ret);
	}		}
	@@ -378,7 +378,7 @@ static void __tnode_free_rcu(struct rcu_head *head)
	{		{
	struct tnode *tn = container_of(head, struct tnode, rcu);		struct tnode *tn = container_of(head, struct tnode, rcu);
	size_t size = sizeof(struct tnode) +		size_t size = sizeof(struct tnode) +
	(sizeof(struct node *) << tn->bits);		(sizeof(struct rt_trie_node *) << tn->bits);

	if (size <= PAGE_SIZE)		if (size <= PAGE_SIZE)
	kfree(tn);		kfree(tn);
	@@ -402,7 +402,7 @@ static void tnode_free_safe(struct tnode *tn)
	tn->tnode_free = tnode_free_head;		tn->tnode_free = tnode_free_head;
	tnode_free_head = tn;		tnode_free_head = tn;
	tnode_free_size += sizeof(struct tnode) +		tnode_free_size += sizeof(struct tnode) +
	(sizeof(struct node *) << tn->bits);		(sizeof(struct rt_trie_node *) << tn->bits);
	}		}

	static void tnode_free_flush(void)		static void tnode_free_flush(void)
	@@ -443,7 +443,7 @@ static struct leaf_info *leaf_info_new(int plen)

	static struct tnode *tnode_new(t_key key, int pos, int bits)		static struct tnode *tnode_new(t_key key, int pos, int bits)
	{		{
	size_t sz = sizeof(struct tnode) + (sizeof(struct node *) << bits);		size_t sz = sizeof(struct tnode) + (sizeof(struct rt_trie_node *) << bits);
	struct tnode *tn = tnode_alloc(sz);		struct tnode *tn = tnode_alloc(sz);

	if (tn) {		if (tn) {
	@@ -456,7 +456,7 @@ static struct tnode *tnode_new(t_key key, int pos, int bits)
	}		}

	pr_debug("AT %p s=%zu %zu\n", tn, sizeof(struct tnode),		pr_debug("AT %p s=%zu %zu\n", tn, sizeof(struct tnode),
	sizeof(struct node) << bits);		sizeof(struct rt_trie_node) << bits);
	return tn;		return tn;
	}		}

	@@ -465,7 +465,7 @@ static struct tnode *tnode_new(t_key key, int pos, int bits)
	* and no bits are skipped. See discussion in dyntree paper p. 6		* and no bits are skipped. See discussion in dyntree paper p. 6
	*/		*/

	static inline int tnode_full(const struct tnode tn, const struct node n)		static inline int tnode_full(const struct tnode tn, const struct rt_trie_node n)
	{		{
	if (n == NULL \|\| IS_LEAF(n))		if (n == NULL \|\| IS_LEAF(n))
	return 0;		return 0;
	@@ -474,7 +474,7 @@ static inline int tnode_full(const struct tnode tn, const struct node n)
	}		}

	static inline void put_child(struct trie t, struct tnode tn, int i,		static inline void put_child(struct trie t, struct tnode tn, int i,
	struct node *n)		struct rt_trie_node *n)
	{		{
	tnode_put_child_reorg(tn, i, n, -1);		tnode_put_child_reorg(tn, i, n, -1);
	}		}
	@@ -484,10 +484,10 @@ static inline void put_child(struct trie t, struct tnode tn, int i,
	* Update the value of full_children and empty_children.		* Update the value of full_children and empty_children.
	*/		*/

	static void tnode_put_child_reorg(struct tnode tn, int i, struct node n,		static void tnode_put_child_reorg(struct tnode tn, int i, struct rt_trie_node n,
	int wasfull)		int wasfull)
	{		{
	struct node *chi = tn->child[i];		struct rt_trie_node *chi = tn->child[i];
	int isfull;		int isfull;

	BUG_ON(i >= 1<<tn->bits);		BUG_ON(i >= 1<<tn->bits);
	@@ -515,7 +515,7 @@ static void tnode_put_child_reorg(struct tnode tn, int i, struct node n,
	}		}

	#define MAX_WORK 10		#define MAX_WORK 10
	static struct node resize(struct trie t, struct tnode *tn)		static struct rt_trie_node resize(struct trie t, struct tnode *tn)
	{		{
	int i;		int i;
	struct tnode *old_tn;		struct tnode *old_tn;
	@@ -605,7 +605,7 @@ static struct node resize(struct trie t, struct tnode *tn)

	/* Keep root node larger */		/* Keep root node larger */

	if (!node_parent((struct node *)tn)) {		if (!node_parent((struct rt_trie_node *)tn)) {
	inflate_threshold_use = inflate_threshold_root;		inflate_threshold_use = inflate_threshold_root;
	halve_threshold_use = halve_threshold_root;		halve_threshold_use = halve_threshold_root;
	} else {		} else {
	@@ -635,7 +635,7 @@ static struct node resize(struct trie t, struct tnode *tn)

	/* Return if at least one inflate is run */		/* Return if at least one inflate is run */
	if (max_work != MAX_WORK)		if (max_work != MAX_WORK)
	return (struct node *) tn;		return (struct rt_trie_node *) tn;

	/*		/*
	* Halve as long as the number of empty children in this		* Halve as long as the number of empty children in this
	@@ -663,7 +663,7 @@ static struct node resize(struct trie t, struct tnode *tn)
	if (tn->empty_children == tnode_child_length(tn) - 1) {		if (tn->empty_children == tnode_child_length(tn) - 1) {
	one_child:		one_child:
	for (i = 0; i < tnode_child_length(tn); i++) {		for (i = 0; i < tnode_child_length(tn); i++) {
	struct node *n;		struct rt_trie_node *n;

	n = tn->child[i];		n = tn->child[i];
	if (!n)		if (!n)
	@@ -676,7 +676,7 @@ static struct node resize(struct trie t, struct tnode *tn)
	return n;		return n;
	}		}
	}		}
	return (struct node *) tn;		return (struct rt_trie_node *) tn;
	}		}

	static struct tnode inflate(struct trie t, struct tnode *tn)		static struct tnode inflate(struct trie t, struct tnode *tn)
	@@ -723,14 +723,14 @@ static struct tnode inflate(struct trie t, struct tnode *tn)
	goto nomem;		goto nomem;
	}		}

	put_child(t, tn, 2i, (struct node ) left);		put_child(t, tn, 2i, (struct rt_trie_node ) left);
	put_child(t, tn, 2i+1, (struct node ) right);		put_child(t, tn, 2i+1, (struct rt_trie_node ) right);
	}		}
	}		}

	for (i = 0; i < olen; i++) {		for (i = 0; i < olen; i++) {
	struct tnode *inode;		struct tnode *inode;
	struct node *node = tnode_get_child(oldtnode, i);		struct rt_trie_node *node = tnode_get_child(oldtnode, i);
	struct tnode left, right;		struct tnode left, right;
	int size, j;		int size, j;

	@@ -825,7 +825,7 @@ static struct tnode inflate(struct trie t, struct tnode *tn)
	static struct tnode halve(struct trie t, struct tnode *tn)		static struct tnode halve(struct trie t, struct tnode *tn)
	{		{
	struct tnode *oldtnode = tn;		struct tnode *oldtnode = tn;
	struct node left, right;		struct rt_trie_node left, right;
	int i;		int i;
	int olen = tnode_child_length(tn);		int olen = tnode_child_length(tn);

	@@ -856,7 +856,7 @@ static struct tnode halve(struct trie t, struct tnode *tn)
	if (!newn)		if (!newn)
	goto nomem;		goto nomem;

	put_child(t, tn, i/2, (struct node *)newn);		put_child(t, tn, i/2, (struct rt_trie_node *)newn);
	}		}

	}		}
	@@ -958,7 +958,7 @@ fib_find_node(struct trie *t, u32 key)
	{		{
	int pos;		int pos;
	struct tnode *tn;		struct tnode *tn;
	struct node *n;		struct rt_trie_node *n;

	pos = 0;		pos = 0;
	n = rcu_dereference_rtnl(t->trie);		n = rcu_dereference_rtnl(t->trie);
	@@ -993,17 +993,17 @@ static void trie_rebalance(struct trie t, struct tnode tn)

	key = tn->key;		key = tn->key;

	while (tn != NULL && (tp = node_parent((struct node *)tn)) != NULL) {		while (tn != NULL && (tp = node_parent((struct rt_trie_node *)tn)) != NULL) {
	cindex = tkey_extract_bits(key, tp->pos, tp->bits);		cindex = tkey_extract_bits(key, tp->pos, tp->bits);
	wasfull = tnode_full(tp, tnode_get_child(tp, cindex));		wasfull = tnode_full(tp, tnode_get_child(tp, cindex));
	tn = (struct tnode ) resize(t, (struct tnode )tn);		tn = (struct tnode ) resize(t, (struct tnode )tn);

	tnode_put_child_reorg((struct tnode *)tp, cindex,		tnode_put_child_reorg((struct tnode *)tp, cindex,
	(struct node *)tn, wasfull);		(struct rt_trie_node *)tn, wasfull);

	tp = node_parent((struct node *) tn);		tp = node_parent((struct rt_trie_node *) tn);
	if (!tp)		if (!tp)
	rcu_assign_pointer(t->trie, (struct node *)tn);		rcu_assign_pointer(t->trie, (struct rt_trie_node *)tn);

	tnode_free_flush();		tnode_free_flush();
	if (!tp)		if (!tp)
	@@ -1015,7 +1015,7 @@ static void trie_rebalance(struct trie t, struct tnode tn)
	if (IS_TNODE(tn))		if (IS_TNODE(tn))
	tn = (struct tnode )resize(t, (struct tnode )tn);		tn = (struct tnode )resize(t, (struct tnode )tn);

	rcu_assign_pointer(t->trie, (struct node *)tn);		rcu_assign_pointer(t->trie, (struct rt_trie_node *)tn);
	tnode_free_flush();		tnode_free_flush();
	}		}

	@@ -1025,7 +1025,7 @@ static struct list_head fib_insert_node(struct trie t, u32 key, int plen)
	{		{
	int pos, newpos;		int pos, newpos;
	struct tnode tp = NULL, tn = NULL;		struct tnode tp = NULL, tn = NULL;
	struct node *n;		struct rt_trie_node *n;
	struct leaf *l;		struct leaf *l;
	int missbit;		int missbit;
	struct list_head *fa_head = NULL;		struct list_head *fa_head = NULL;
	@@ -1111,10 +1111,10 @@ static struct list_head fib_insert_node(struct trie t, u32 key, int plen)
	if (t->trie && n == NULL) {		if (t->trie && n == NULL) {
	/* Case 2: n is NULL, and will just insert a new leaf */		/* Case 2: n is NULL, and will just insert a new leaf */

	node_set_parent((struct node *)l, tp);		node_set_parent((struct rt_trie_node *)l, tp);

	cindex = tkey_extract_bits(key, tp->pos, tp->bits);		cindex = tkey_extract_bits(key, tp->pos, tp->bits);
	put_child(t, (struct tnode )tp, cindex, (struct node )l);		put_child(t, (struct tnode )tp, cindex, (struct rt_trie_node )l);
	} else {		} else {
	/* Case 3: n is a LEAF or a TNODE and the key doesn't match. */		/* Case 3: n is a LEAF or a TNODE and the key doesn't match. */
	/*		/*
	@@ -1141,18 +1141,18 @@ static struct list_head fib_insert_node(struct trie t, u32 key, int plen)
	return NULL;		return NULL;
	}		}

	node_set_parent((struct node *)tn, tp);		node_set_parent((struct rt_trie_node *)tn, tp);

	missbit = tkey_extract_bits(key, newpos, 1);		missbit = tkey_extract_bits(key, newpos, 1);
	put_child(t, tn, missbit, (struct node *)l);		put_child(t, tn, missbit, (struct rt_trie_node *)l);
	put_child(t, tn, 1-missbit, n);		put_child(t, tn, 1-missbit, n);

	if (tp) {		if (tp) {
	cindex = tkey_extract_bits(key, tp->pos, tp->bits);		cindex = tkey_extract_bits(key, tp->pos, tp->bits);
	put_child(t, (struct tnode *)tp, cindex,		put_child(t, (struct tnode *)tp, cindex,
	(struct node *)tn);		(struct rt_trie_node *)tn);
	} else {		} else {
	rcu_assign_pointer(t->trie, (struct node *)tn);		rcu_assign_pointer(t->trie, (struct rt_trie_node *)tn);
	tp = tn;		tp = tn;
	}		}
	}		}
	@@ -1376,7 +1376,7 @@ int fib_table_lookup(struct fib_table tb, const struct flowi flp,
	{		{
	struct trie t = (struct trie ) tb->tb_data;		struct trie t = (struct trie ) tb->tb_data;
	int ret;		int ret;
	struct node *n;		struct rt_trie_node *n;
	struct tnode *pn;		struct tnode *pn;
	int pos, bits;		int pos, bits;
	t_key key = ntohl(flp->fl4_dst);		t_key key = ntohl(flp->fl4_dst);
	@@ -1541,7 +1541,7 @@ int fib_table_lookup(struct fib_table tb, const struct flowi flp,
	if (chopped_off <= pn->bits) {		if (chopped_off <= pn->bits) {
	cindex &= ~(1 << (chopped_off-1));		cindex &= ~(1 << (chopped_off-1));
	} else {		} else {
	struct tnode parent = node_parent_rcu((struct node ) pn);		struct tnode parent = node_parent_rcu((struct rt_trie_node ) pn);
	if (!parent)		if (!parent)
	goto failed;		goto failed;

	@@ -1568,7 +1568,7 @@ int fib_table_lookup(struct fib_table tb, const struct flowi flp,
	*/		*/
	static void trie_leaf_remove(struct trie t, struct leaf l)		static void trie_leaf_remove(struct trie t, struct leaf l)
	{		{
	struct tnode tp = node_parent((struct node ) l);		struct tnode tp = node_parent((struct rt_trie_node ) l);

	pr_debug("entering trie_leaf_remove(%p)\n", l);		pr_debug("entering trie_leaf_remove(%p)\n", l);

	@@ -1706,7 +1706,7 @@ static int trie_flush_leaf(struct leaf *l)
	* Scan for the next right leaf starting at node p->child[idx]		* Scan for the next right leaf starting at node p->child[idx]
	* Since we have back pointer, no recursion necessary.		* Since we have back pointer, no recursion necessary.
	*/		*/
	static struct leaf leaf_walk_rcu(struct tnode p, struct node *c)		static struct leaf leaf_walk_rcu(struct tnode p, struct rt_trie_node *c)
	{		{
	do {		do {
	t_key idx;		t_key idx;
	@@ -1732,7 +1732,7 @@ static struct leaf leaf_walk_rcu(struct tnode p, struct node *c)
	}		}

	/* Node empty, walk back up to parent */		/* Node empty, walk back up to parent */
	c = (struct node *) p;		c = (struct rt_trie_node *) p;
	} while ((p = node_parent_rcu(c)) != NULL);		} while ((p = node_parent_rcu(c)) != NULL);

	return NULL; /* Root of trie */		return NULL; /* Root of trie */
	@@ -1753,7 +1753,7 @@ static struct leaf trie_firstleaf(struct trie t)

	static struct leaf trie_nextleaf(struct leaf l)		static struct leaf trie_nextleaf(struct leaf l)
	{		{
	struct node c = (struct node ) l;		struct rt_trie_node c = (struct rt_trie_node ) l;
	struct tnode *p = node_parent_rcu(c);		struct tnode *p = node_parent_rcu(c);

	if (!p)		if (!p)
	@@ -1961,7 +1961,7 @@ struct fib_trie_iter {
	unsigned int depth;		unsigned int depth;
	};		};

	static struct node fib_trie_get_next(struct fib_trie_iter iter)		static struct rt_trie_node fib_trie_get_next(struct fib_trie_iter iter)
	{		{
	struct tnode *tn = iter->tnode;		struct tnode *tn = iter->tnode;
	unsigned int cindex = iter->index;		unsigned int cindex = iter->index;
	@@ -1975,7 +1975,7 @@ static struct node fib_trie_get_next(struct fib_trie_iter iter)
	iter->tnode, iter->index, iter->depth);		iter->tnode, iter->index, iter->depth);
	rescan:		rescan:
	while (cindex < (1<<tn->bits)) {		while (cindex < (1<<tn->bits)) {
	struct node *n = tnode_get_child_rcu(tn, cindex);		struct rt_trie_node *n = tnode_get_child_rcu(tn, cindex);

	if (n) {		if (n) {
	if (IS_LEAF(n)) {		if (IS_LEAF(n)) {
	@@ -1994,7 +1994,7 @@ static struct node fib_trie_get_next(struct fib_trie_iter iter)
	}		}

	/* Current node exhausted, pop back up */		/* Current node exhausted, pop back up */
	p = node_parent_rcu((struct node *)tn);		p = node_parent_rcu((struct rt_trie_node *)tn);
	if (p) {		if (p) {
	cindex = tkey_extract_bits(tn->key, p->pos, p->bits)+1;		cindex = tkey_extract_bits(tn->key, p->pos, p->bits)+1;
	tn = p;		tn = p;
	@@ -2006,10 +2006,10 @@ static struct node fib_trie_get_next(struct fib_trie_iter iter)
	return NULL;		return NULL;
	}		}

	static struct node fib_trie_get_first(struct fib_trie_iter iter,		static struct rt_trie_node fib_trie_get_first(struct fib_trie_iter iter,
	struct trie *t)		struct trie *t)
	{		{
	struct node *n;		struct rt_trie_node *n;

	if (!t)		if (!t)
	return NULL;		return NULL;
	@@ -2033,7 +2033,7 @@ static struct node fib_trie_get_first(struct fib_trie_iter iter,

	static void trie_collect_stats(struct trie t, struct trie_stat s)		static void trie_collect_stats(struct trie t, struct trie_stat s)
	{		{
	struct node *n;		struct rt_trie_node *n;
	struct fib_trie_iter iter;		struct fib_trie_iter iter;

	memset(s, 0, sizeof(*s));		memset(s, 0, sizeof(*s));
	@@ -2106,7 +2106,7 @@ static void trie_show_stats(struct seq_file seq, struct trie_stat stat)
	seq_putc(seq, '\n');		seq_putc(seq, '\n');
	seq_printf(seq, "\tPointers: %u\n", pointers);		seq_printf(seq, "\tPointers: %u\n", pointers);

	bytes += sizeof(struct node ) pointers;		bytes += sizeof(struct rt_trie_node ) pointers;
	seq_printf(seq, "Null ptrs: %u\n", stat->nullpointers);		seq_printf(seq, "Null ptrs: %u\n", stat->nullpointers);
	seq_printf(seq, "Total size: %u kB\n", (bytes + 1023) / 1024);		seq_printf(seq, "Total size: %u kB\n", (bytes + 1023) / 1024);
	}		}
	@@ -2187,7 +2187,7 @@ static const struct file_operations fib_triestat_fops = {
	.release = single_release_net,		.release = single_release_net,
	};		};

	static struct node fib_trie_get_idx(struct seq_file seq, loff_t pos)		static struct rt_trie_node fib_trie_get_idx(struct seq_file seq, loff_t pos)
	{		{
	struct fib_trie_iter *iter = seq->private;		struct fib_trie_iter *iter = seq->private;
	struct net *net = seq_file_net(seq);		struct net *net = seq_file_net(seq);
	@@ -2200,7 +2200,7 @@ static struct node fib_trie_get_idx(struct seq_file seq, loff_t pos)
	struct fib_table *tb;		struct fib_table *tb;

	hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {		hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
	struct node *n;		struct rt_trie_node *n;

	for (n = fib_trie_get_first(iter,		for (n = fib_trie_get_first(iter,
	(struct trie *) tb->tb_data);		(struct trie *) tb->tb_data);
	@@ -2229,7 +2229,7 @@ static void fib_trie_seq_next(struct seq_file seq, void v, loff_t pos)
	struct fib_table *tb = iter->tb;		struct fib_table *tb = iter->tb;
	struct hlist_node *tb_node;		struct hlist_node *tb_node;
	unsigned int h;		unsigned int h;
	struct node *n;		struct rt_trie_node *n;

	++*pos;		++*pos;
	/* next node in same table */		/* next node in same table */
	@@ -2315,7 +2315,7 @@ static inline const char rtn_type(char buf, size_t len, unsigned int t)
	static int fib_trie_seq_show(struct seq_file seq, void v)		static int fib_trie_seq_show(struct seq_file seq, void v)
	{		{
	const struct fib_trie_iter *iter = seq->private;		const struct fib_trie_iter *iter = seq->private;
	struct node *n = v;		struct rt_trie_node *n = v;

	if (!node_parent_rcu(n))		if (!node_parent_rcu(n))
	fib_table_print(seq, iter->tb);		fib_table_print(seq, iter->tb);