[IPV4]: Fix up lots of little whitespace indentation stuff in fib_trie.
Signed-off-by: Stephen Hemminger <shemminger@osdl.org> Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Stephen Hemminger
David S. Miller
parent
23a534e7b1
commit
c877efb207
|
|
@ -1157,7 +1157,7 @@ static int __init ipv4_proc_init(void)
|
|||
#ifdef CONFIG_IP_FIB_TRIE
|
||||
if (fib_stat_proc_init())
|
||||
goto out_fib_stat;
|
||||
#endif
|
||||
#endif
|
||||
if (ip_misc_proc_init())
|
||||
goto out_misc;
|
||||
out:
|
||||
|
|
|
|||
|
|
@ -90,14 +90,14 @@ typedef unsigned int t_key;
|
|||
#define T_LEAF 1
|
||||
#define NODE_TYPE_MASK 0x1UL
|
||||
#define NODE_PARENT(_node) \
|
||||
((struct tnode *)((_node)->_parent & ~NODE_TYPE_MASK))
|
||||
((struct tnode *)((_node)->_parent & ~NODE_TYPE_MASK))
|
||||
#define NODE_SET_PARENT(_node, _ptr) \
|
||||
((_node)->_parent = (((unsigned long)(_ptr)) | \
|
||||
((_node)->_parent = (((unsigned long)(_ptr)) | \
|
||||
((_node)->_parent & NODE_TYPE_MASK)))
|
||||
#define NODE_INIT_PARENT(_node, _type) \
|
||||
((_node)->_parent = (_type))
|
||||
((_node)->_parent = (_type))
|
||||
#define NODE_TYPE(_node) \
|
||||
((_node)->_parent & NODE_TYPE_MASK)
|
||||
((_node)->_parent & NODE_TYPE_MASK)
|
||||
|
||||
#define IS_TNODE(n) (!(n->_parent & T_LEAF))
|
||||
#define IS_LEAF(n) (n->_parent & T_LEAF)
|
||||
|
|
@ -187,7 +187,7 @@ static void trie_bug(char *err)
|
|||
|
||||
static inline struct node *tnode_get_child(struct tnode *tn, int i)
|
||||
{
|
||||
if (i >= 1<<tn->bits)
|
||||
if (i >= 1<<tn->bits)
|
||||
trie_bug("tnode_get_child");
|
||||
|
||||
return tn->child[i];
|
||||
|
|
@ -226,13 +226,13 @@ static inline t_key tkey_extract_bits(t_key a, int offset, int bits)
|
|||
|
||||
static inline int tkey_equals(t_key a, t_key b)
|
||||
{
|
||||
return a == b;
|
||||
return a == b;
|
||||
}
|
||||
|
||||
static inline int tkey_sub_equals(t_key a, int offset, int bits, t_key b)
|
||||
{
|
||||
if (bits == 0 || offset >= KEYLENGTH)
|
||||
return 1;
|
||||
if (bits == 0 || offset >= KEYLENGTH)
|
||||
return 1;
|
||||
bits = bits > KEYLENGTH ? KEYLENGTH : bits;
|
||||
return ((a ^ b) << offset) >> (KEYLENGTH - bits) == 0;
|
||||
}
|
||||
|
|
@ -242,9 +242,9 @@ static inline int tkey_mismatch(t_key a, int offset, t_key b)
|
|||
t_key diff = a ^ b;
|
||||
int i = offset;
|
||||
|
||||
if(!diff)
|
||||
return 0;
|
||||
while((diff << i) >> (KEYLENGTH-1) == 0)
|
||||
if (!diff)
|
||||
return 0;
|
||||
while ((diff << i) >> (KEYLENGTH-1) == 0)
|
||||
i++;
|
||||
return i;
|
||||
}
|
||||
|
|
@ -314,6 +314,7 @@ static void fn_free_alias(struct fib_alias *fa)
|
|||
The bits from (n->pos) to (n->pos + n->bits - 1) - "C" - are the index into
|
||||
n's child array, and will of course be different for each child.
|
||||
|
||||
|
||||
The rest of the bits, from (n->pos + n->bits) onward, are completely unknown
|
||||
at this point.
|
||||
|
||||
|
|
@ -321,7 +322,7 @@ static void fn_free_alias(struct fib_alias *fa)
|
|||
|
||||
static void check_tnode(struct tnode *tn)
|
||||
{
|
||||
if(tn && tn->pos+tn->bits > 32) {
|
||||
if (tn && tn->pos+tn->bits > 32) {
|
||||
printk("TNODE ERROR tn=%p, pos=%d, bits=%d\n", tn, tn->pos, tn->bits);
|
||||
}
|
||||
}
|
||||
|
|
@ -332,7 +333,7 @@ static int inflate_threshold = 50;
|
|||
static struct leaf *leaf_new(void)
|
||||
{
|
||||
struct leaf *l = kmalloc(sizeof(struct leaf), GFP_KERNEL);
|
||||
if(l) {
|
||||
if (l) {
|
||||
NODE_INIT_PARENT(l, T_LEAF);
|
||||
INIT_HLIST_HEAD(&l->list);
|
||||
}
|
||||
|
|
@ -342,7 +343,7 @@ static struct leaf *leaf_new(void)
|
|||
static struct leaf_info *leaf_info_new(int plen)
|
||||
{
|
||||
struct leaf_info *li = kmalloc(sizeof(struct leaf_info), GFP_KERNEL);
|
||||
if(li) {
|
||||
if (li) {
|
||||
li->plen = plen;
|
||||
INIT_LIST_HEAD(&li->falh);
|
||||
}
|
||||
|
|
@ -365,7 +366,7 @@ static struct tnode *tnode_alloc(unsigned int size)
|
|||
return kmalloc(size, GFP_KERNEL);
|
||||
} else {
|
||||
return (struct tnode *)
|
||||
__get_free_pages(GFP_KERNEL, get_order(size));
|
||||
__get_free_pages(GFP_KERNEL, get_order(size));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -386,7 +387,7 @@ static struct tnode* tnode_new(t_key key, int pos, int bits)
|
|||
int sz = sizeof(struct tnode) + nchildren * sizeof(struct node *);
|
||||
struct tnode *tn = tnode_alloc(sz);
|
||||
|
||||
if(tn) {
|
||||
if (tn) {
|
||||
memset(tn, 0, sz);
|
||||
NODE_INIT_PARENT(tn, T_TNODE);
|
||||
tn->pos = pos;
|
||||
|
|
@ -395,7 +396,8 @@ static struct tnode* tnode_new(t_key key, int pos, int bits)
|
|||
tn->full_children = 0;
|
||||
tn->empty_children = 1<<bits;
|
||||
}
|
||||
if(trie_debug > 0)
|
||||
|
||||
if (trie_debug > 0)
|
||||
printk("AT %p s=%u %u\n", tn, (unsigned int) sizeof(struct tnode),
|
||||
(unsigned int) (sizeof(struct node) * 1<<bits));
|
||||
return tn;
|
||||
|
|
@ -403,17 +405,17 @@ static struct tnode* tnode_new(t_key key, int pos, int bits)
|
|||
|
||||
static void tnode_free(struct tnode *tn)
|
||||
{
|
||||
if(!tn) {
|
||||
if (!tn) {
|
||||
trie_bug("tnode_free\n");
|
||||
}
|
||||
if(IS_LEAF(tn)) {
|
||||
if (IS_LEAF(tn)) {
|
||||
free_leaf((struct leaf *)tn);
|
||||
if(trie_debug > 0 )
|
||||
if (trie_debug > 0 )
|
||||
printk("FL %p \n", tn);
|
||||
}
|
||||
else if(IS_TNODE(tn)) {
|
||||
else if (IS_TNODE(tn)) {
|
||||
__tnode_free(tn);
|
||||
if(trie_debug > 0 )
|
||||
if (trie_debug > 0 )
|
||||
printk("FT %p \n", tn);
|
||||
}
|
||||
else {
|
||||
|
|
@ -428,7 +430,7 @@ static void tnode_free(struct tnode *tn)
|
|||
|
||||
static inline int tnode_full(struct tnode *tn, struct node *n)
|
||||
{
|
||||
if(n == NULL || IS_LEAF(n))
|
||||
if (n == NULL || IS_LEAF(n))
|
||||
return 0;
|
||||
|
||||
return ((struct tnode *) n)->pos == tn->pos + tn->bits;
|
||||
|
|
@ -449,7 +451,7 @@ static void tnode_put_child_reorg(struct tnode *tn, int i, struct node *n, int w
|
|||
struct node *chi;
|
||||
int isfull;
|
||||
|
||||
if(i >= 1<<tn->bits) {
|
||||
if (i >= 1<<tn->bits) {
|
||||
printk("bits=%d, i=%d\n", tn->bits, i);
|
||||
trie_bug("tnode_put_child_reorg bits");
|
||||
}
|
||||
|
|
@ -472,7 +474,7 @@ static void tnode_put_child_reorg(struct tnode *tn, int i, struct node *n, int w
|
|||
|
||||
else if (!wasfull && isfull)
|
||||
tn->full_children++;
|
||||
if(n)
|
||||
if (n)
|
||||
NODE_SET_PARENT(n, tn);
|
||||
|
||||
tn->child[i] = n;
|
||||
|
|
@ -487,7 +489,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
|
|||
if (!tn)
|
||||
return NULL;
|
||||
|
||||
if(trie_debug)
|
||||
if (trie_debug)
|
||||
printk("In tnode_resize %p inflate_threshold=%d threshold=%d\n",
|
||||
tn, inflate_threshold, halve_threshold);
|
||||
|
||||
|
|
@ -505,7 +507,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
|
|||
|
||||
/* compress one level */
|
||||
struct node *n = tn->child[i];
|
||||
if(n)
|
||||
if (n)
|
||||
NODE_INIT_PARENT(n, NODE_TYPE(n));
|
||||
|
||||
write_unlock_bh(&fib_lock);
|
||||
|
|
@ -552,7 +554,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
|
|||
* new_child_length;
|
||||
* if (new_fill_factor >= inflate_threshold)
|
||||
*
|
||||
* ...and so on, tho it would mess up the while() loop.
|
||||
* ...and so on, tho it would mess up the while () loop.
|
||||
*
|
||||
* anyway,
|
||||
* 100 * (not_to_be_doubled + 2*to_be_doubled) / new_child_length >=
|
||||
|
|
@ -587,7 +589,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
|
|||
|
||||
tn = inflate(t, tn, &err);
|
||||
|
||||
if(err) {
|
||||
if (err) {
|
||||
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
||||
t->stats.resize_node_skipped++;
|
||||
#endif
|
||||
|
|
@ -609,7 +611,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
|
|||
|
||||
tn = halve(t, tn, &err);
|
||||
|
||||
if(err) {
|
||||
if (err) {
|
||||
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
||||
t->stats.resize_node_skipped++;
|
||||
#endif
|
||||
|
|
@ -628,7 +630,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
|
|||
/* compress one level */
|
||||
struct node *n = tn->child[i];
|
||||
|
||||
if(n)
|
||||
if (n)
|
||||
NODE_INIT_PARENT(n, NODE_TYPE(n));
|
||||
|
||||
write_unlock_bh(&fib_lock);
|
||||
|
|
@ -648,7 +650,7 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err)
|
|||
int olen = tnode_child_length(tn);
|
||||
int i;
|
||||
|
||||
if(trie_debug)
|
||||
if (trie_debug)
|
||||
printk("In inflate\n");
|
||||
|
||||
tn = tnode_new(oldtnode->key, oldtnode->pos, oldtnode->bits + 1);
|
||||
|
|
@ -679,7 +681,7 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err)
|
|||
left = tnode_new(inode->key&(~m), inode->pos + 1,
|
||||
inode->bits - 1);
|
||||
|
||||
if(!left) {
|
||||
if (!left) {
|
||||
*err = -ENOMEM;
|
||||
break;
|
||||
}
|
||||
|
|
@ -687,7 +689,7 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err)
|
|||
right = tnode_new(inode->key|m, inode->pos + 1,
|
||||
inode->bits - 1);
|
||||
|
||||
if(!right) {
|
||||
if (!right) {
|
||||
*err = -ENOMEM;
|
||||
break;
|
||||
}
|
||||
|
|
@ -697,12 +699,12 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err)
|
|||
}
|
||||
}
|
||||
|
||||
if(*err) {
|
||||
if (*err) {
|
||||
int size = tnode_child_length(tn);
|
||||
int j;
|
||||
|
||||
for(j = 0; j < size; j++)
|
||||
if( tn->child[j])
|
||||
if (tn->child[j])
|
||||
tnode_free((struct tnode *)tn->child[j]);
|
||||
|
||||
tnode_free(tn);
|
||||
|
|
@ -720,9 +722,9 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err)
|
|||
|
||||
/* A leaf or an internal node with skipped bits */
|
||||
|
||||
if(IS_LEAF(node) || ((struct tnode *) node)->pos >
|
||||
if (IS_LEAF(node) || ((struct tnode *) node)->pos >
|
||||
tn->pos + tn->bits - 1) {
|
||||
if(tkey_extract_bits(node->key, oldtnode->pos + oldtnode->bits,
|
||||
if (tkey_extract_bits(node->key, oldtnode->pos + oldtnode->bits,
|
||||
1) == 0)
|
||||
put_child(t, tn, 2*i, node);
|
||||
else
|
||||
|
|
@ -769,13 +771,13 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err)
|
|||
left = (struct tnode *) tnode_get_child(tn, 2*i);
|
||||
put_child(t, tn, 2*i, NULL);
|
||||
|
||||
if(!left)
|
||||
if (!left)
|
||||
BUG();
|
||||
|
||||
right = (struct tnode *) tnode_get_child(tn, 2*i+1);
|
||||
put_child(t, tn, 2*i+1, NULL);
|
||||
|
||||
if(!right)
|
||||
if (!right)
|
||||
BUG();
|
||||
|
||||
size = tnode_child_length(left);
|
||||
|
|
@ -800,9 +802,9 @@ static struct tnode *halve(struct trie *t, struct tnode *tn, int *err)
|
|||
int i;
|
||||
int olen = tnode_child_length(tn);
|
||||
|
||||
if(trie_debug) printk("In halve\n");
|
||||
if (trie_debug) printk("In halve\n");
|
||||
|
||||
tn=tnode_new(oldtnode->key, oldtnode->pos, oldtnode->bits - 1);
|
||||
tn = tnode_new(oldtnode->key, oldtnode->pos, oldtnode->bits - 1);
|
||||
|
||||
if (!tn) {
|
||||
*err = -ENOMEM;
|
||||
|
|
@ -821,11 +823,11 @@ static struct tnode *halve(struct trie *t, struct tnode *tn, int *err)
|
|||
right = tnode_get_child(oldtnode, i+1);
|
||||
|
||||
/* Two nonempty children */
|
||||
if( left && right) {
|
||||
if (left && right) {
|
||||
struct tnode *newBinNode =
|
||||
tnode_new(left->key, tn->pos + tn->bits, 1);
|
||||
|
||||
if(!newBinNode) {
|
||||
if (!newBinNode) {
|
||||
*err = -ENOMEM;
|
||||
break;
|
||||
}
|
||||
|
|
@ -833,12 +835,12 @@ static struct tnode *halve(struct trie *t, struct tnode *tn, int *err)
|
|||
}
|
||||
}
|
||||
|
||||
if(*err) {
|
||||
if (*err) {
|
||||
int size = tnode_child_length(tn);
|
||||
int j;
|
||||
|
||||
for(j = 0; j < size; j++)
|
||||
if( tn->child[j])
|
||||
if (tn->child[j])
|
||||
tnode_free((struct tnode *)tn->child[j]);
|
||||
|
||||
tnode_free(tn);
|
||||
|
|
@ -865,7 +867,7 @@ static struct tnode *halve(struct trie *t, struct tnode *tn, int *err)
|
|||
(struct tnode *) tnode_get_child(tn, i/2);
|
||||
put_child(t, tn, i/2, NULL);
|
||||
|
||||
if(!newBinNode)
|
||||
if (!newBinNode)
|
||||
BUG();
|
||||
|
||||
put_child(t, newBinNode, 0, left);
|
||||
|
|
@ -879,7 +881,7 @@ static struct tnode *halve(struct trie *t, struct tnode *tn, int *err)
|
|||
|
||||
static void *trie_init(struct trie *t)
|
||||
{
|
||||
if(t) {
|
||||
if (t) {
|
||||
t->size = 0;
|
||||
t->trie = NULL;
|
||||
t->revision = 0;
|
||||
|
|
@ -896,8 +898,7 @@ static struct leaf_info *find_leaf_info(struct hlist_head *head, int plen)
|
|||
struct leaf_info *li;
|
||||
|
||||
hlist_for_each_entry(li, node, head, hlist) {
|
||||
|
||||
if ( li->plen == plen )
|
||||
if (li->plen == plen)
|
||||
return li;
|
||||
}
|
||||
return NULL;
|
||||
|
|
@ -905,10 +906,10 @@ static struct leaf_info *find_leaf_info(struct hlist_head *head, int plen)
|
|||
|
||||
static inline struct list_head * get_fa_head(struct leaf *l, int plen)
|
||||
{
|
||||
struct list_head *fa_head=NULL;
|
||||
struct list_head *fa_head = NULL;
|
||||
struct leaf_info *li = find_leaf_info(&l->list, plen);
|
||||
|
||||
if(li)
|
||||
if (li)
|
||||
fa_head = &li->falh;
|
||||
|
||||
return fa_head;
|
||||
|
|
@ -916,12 +917,12 @@ static inline struct list_head * get_fa_head(struct leaf *l, int plen)
|
|||
|
||||
static void insert_leaf_info(struct hlist_head *head, struct leaf_info *new)
|
||||
{
|
||||
struct leaf_info *li=NULL, *last=NULL;
|
||||
struct leaf_info *li = NULL, *last = NULL;
|
||||
struct hlist_node *node, *tmp;
|
||||
|
||||
write_lock_bh(&fib_lock);
|
||||
|
||||
if(hlist_empty(head))
|
||||
if (hlist_empty(head))
|
||||
hlist_add_head(&new->hlist, head);
|
||||
else {
|
||||
hlist_for_each_entry_safe(li, node, tmp, head, hlist) {
|
||||
|
|
@ -931,7 +932,7 @@ static void insert_leaf_info(struct hlist_head *head, struct leaf_info *new)
|
|||
|
||||
last = li;
|
||||
}
|
||||
if(last)
|
||||
if (last)
|
||||
hlist_add_after(&last->hlist, &new->hlist);
|
||||
else
|
||||
hlist_add_before(&new->hlist, &li->hlist);
|
||||
|
|
@ -947,14 +948,14 @@ fib_find_node(struct trie *t, u32 key)
|
|||
struct node *n;
|
||||
|
||||
pos = 0;
|
||||
n=t->trie;
|
||||
n = t->trie;
|
||||
|
||||
while (n != NULL && NODE_TYPE(n) == T_TNODE) {
|
||||
tn = (struct tnode *) n;
|
||||
|
||||
check_tnode(tn);
|
||||
|
||||
if(tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) {
|
||||
if (tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) {
|
||||
pos=tn->pos + tn->bits;
|
||||
n = tnode_get_child(tn, tkey_extract_bits(key, tn->pos, tn->bits));
|
||||
}
|
||||
|
|
@ -977,7 +978,7 @@ static struct node *trie_rebalance(struct trie *t, struct tnode *tn)
|
|||
t_key cindex, key;
|
||||
struct tnode *tp = NULL;
|
||||
|
||||
if(!tn)
|
||||
if (!tn)
|
||||
BUG();
|
||||
|
||||
key = tn->key;
|
||||
|
|
@ -985,15 +986,15 @@ static struct node *trie_rebalance(struct trie *t, struct tnode *tn)
|
|||
|
||||
while (tn != NULL && NODE_PARENT(tn) != NULL) {
|
||||
|
||||
if( i > 10 ) {
|
||||
if (i > 10) {
|
||||
printk("Rebalance tn=%p \n", tn);
|
||||
if(tn) printk("tn->parent=%p \n", NODE_PARENT(tn));
|
||||
if (tn) printk("tn->parent=%p \n", NODE_PARENT(tn));
|
||||
|
||||
printk("Rebalance tp=%p \n", tp);
|
||||
if(tp) printk("tp->parent=%p \n", NODE_PARENT(tp));
|
||||
if (tp) printk("tp->parent=%p \n", NODE_PARENT(tp));
|
||||
}
|
||||
|
||||
if( i > 12 ) BUG();
|
||||
if (i > 12) BUG();
|
||||
i++;
|
||||
|
||||
tp = NODE_PARENT(tn);
|
||||
|
|
@ -1002,7 +1003,7 @@ static struct node *trie_rebalance(struct trie *t, struct tnode *tn)
|
|||
tn = (struct tnode *) resize (t, (struct tnode *)tn);
|
||||
tnode_put_child_reorg((struct tnode *)tp, cindex,(struct node*)tn, wasfull);
|
||||
|
||||
if(!NODE_PARENT(tn))
|
||||
if (!NODE_PARENT(tn))
|
||||
break;
|
||||
|
||||
tn = NODE_PARENT(tn);
|
||||
|
|
@ -1022,12 +1023,12 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
struct node *n;
|
||||
struct leaf *l;
|
||||
int missbit;
|
||||
struct list_head *fa_head=NULL;
|
||||
struct list_head *fa_head = NULL;
|
||||
struct leaf_info *li;
|
||||
t_key cindex;
|
||||
|
||||
pos = 0;
|
||||
n=t->trie;
|
||||
n = t->trie;
|
||||
|
||||
/* 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,
|
||||
|
|
@ -1052,12 +1053,12 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
|
||||
check_tnode(tn);
|
||||
|
||||
if(tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) {
|
||||
if (tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) {
|
||||
tp = tn;
|
||||
pos=tn->pos + tn->bits;
|
||||
n = tnode_get_child(tn, tkey_extract_bits(key, tn->pos, tn->bits));
|
||||
|
||||
if(n && NODE_PARENT(n) != tn) {
|
||||
if (n && NODE_PARENT(n) != tn) {
|
||||
printk("BUG tn=%p, n->parent=%p\n", tn, NODE_PARENT(n));
|
||||
BUG();
|
||||
}
|
||||
|
|
@ -1072,7 +1073,7 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
* tp is n's (parent) ----> NULL or TNODE
|
||||
*/
|
||||
|
||||
if(tp && IS_LEAF(tp))
|
||||
if (tp && IS_LEAF(tp))
|
||||
BUG();
|
||||
|
||||
|
||||
|
|
@ -1083,7 +1084,7 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
|
||||
li = leaf_info_new(plen);
|
||||
|
||||
if(! li) {
|
||||
if (!li) {
|
||||
*err = -ENOMEM;
|
||||
goto err;
|
||||
}
|
||||
|
|
@ -1095,7 +1096,7 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
t->size++;
|
||||
l = leaf_new();
|
||||
|
||||
if(! l) {
|
||||
if (!l) {
|
||||
*err = -ENOMEM;
|
||||
goto err;
|
||||
}
|
||||
|
|
@ -1103,7 +1104,7 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
l->key = key;
|
||||
li = leaf_info_new(plen);
|
||||
|
||||
if(! li) {
|
||||
if (!li) {
|
||||
tnode_free((struct tnode *) l);
|
||||
*err = -ENOMEM;
|
||||
goto err;
|
||||
|
|
@ -1136,7 +1137,7 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
pos=tp->pos+tp->bits;
|
||||
else
|
||||
pos=0;
|
||||
if(n) {
|
||||
if (n) {
|
||||
newpos = tkey_mismatch(key, pos, n->key);
|
||||
tn = tnode_new(n->key, newpos, 1);
|
||||
}
|
||||
|
|
@ -1145,7 +1146,7 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
tn = tnode_new(key, newpos, 1); /* First tnode */
|
||||
}
|
||||
|
||||
if(!tn) {
|
||||
if (!tn) {
|
||||
free_leaf_info(li);
|
||||
tnode_free((struct tnode *) l);
|
||||
*err = -ENOMEM;
|
||||
|
|
@ -1158,7 +1159,7 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
put_child(t, tn, missbit, (struct node *)l);
|
||||
put_child(t, tn, 1-missbit, n);
|
||||
|
||||
if(tp) {
|
||||
if (tp) {
|
||||
cindex = tkey_extract_bits(key, tp->pos, tp->bits);
|
||||
put_child(t, (struct tnode *)tp, cindex, (struct node *)tn);
|
||||
}
|
||||
|
|
@ -1167,7 +1168,7 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen)
|
|||
tp = tn;
|
||||
}
|
||||
}
|
||||
if(tp && tp->pos+tp->bits > 32) {
|
||||
if (tp && tp->pos+tp->bits > 32) {
|
||||
printk("ERROR tp=%p pos=%d, bits=%d, key=%0x plen=%d\n",
|
||||
tp, tp->pos, tp->bits, key, plen);
|
||||
}
|
||||
|
|
@ -1185,7 +1186,7 @@ fn_trie_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta,
|
|||
{
|
||||
struct trie *t = (struct trie *) tb->tb_data;
|
||||
struct fib_alias *fa, *new_fa;
|
||||
struct list_head *fa_head=NULL;
|
||||
struct list_head *fa_head = NULL;
|
||||
struct fib_info *fi;
|
||||
int plen = r->rtm_dst_len;
|
||||
int type = r->rtm_type;
|
||||
|
|
@ -1203,12 +1204,12 @@ fn_trie_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta,
|
|||
|
||||
key = ntohl(key);
|
||||
|
||||
if(trie_debug)
|
||||
if (trie_debug)
|
||||
printk("Insert table=%d %08x/%d\n", tb->tb_id, key, plen);
|
||||
|
||||
mask = ntohl( inet_make_mask(plen) );
|
||||
mask = ntohl( inet_make_mask(plen) );
|
||||
|
||||
if(key & ~mask)
|
||||
if (key & ~mask)
|
||||
return -EINVAL;
|
||||
|
||||
key = key & mask;
|
||||
|
|
@ -1219,7 +1220,7 @@ fn_trie_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta,
|
|||
l = fib_find_node(t, key);
|
||||
fa = NULL;
|
||||
|
||||
if(l) {
|
||||
if (l) {
|
||||
fa_head = get_fa_head(l, plen);
|
||||
fa = fib_find_alias(fa_head, tos, fi->fib_priority);
|
||||
}
|
||||
|
|
@ -1298,16 +1299,16 @@ fn_trie_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta,
|
|||
new_fa->fa_scope = r->rtm_scope;
|
||||
new_fa->fa_state = 0;
|
||||
#if 0
|
||||
new_fa->dst = NULL;
|
||||
new_fa->dst = NULL;
|
||||
#endif
|
||||
/*
|
||||
* Insert new entry to the list.
|
||||
*/
|
||||
|
||||
if(!fa_head) {
|
||||
if (!fa_head) {
|
||||
fa_head = fib_insert_node(t, &err, key, plen);
|
||||
err = 0;
|
||||
if(err)
|
||||
if (err)
|
||||
goto out_free_new_fa;
|
||||
}
|
||||
|
||||
|
|
@ -1376,7 +1377,7 @@ fn_trie_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result
|
|||
n = t->trie;
|
||||
|
||||
read_lock(&fib_lock);
|
||||
if(!n)
|
||||
if (!n)
|
||||
goto failed;
|
||||
|
||||
#ifdef CONFIG_IP_FIB_TRIE_STATS
|
||||
|
|
@ -1385,7 +1386,7 @@ fn_trie_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result
|
|||
|
||||
/* Just a leaf? */
|
||||
if (IS_LEAF(n)) {
|
||||
if( check_leaf(t, (struct leaf *)n, key, &plen, flp, res, &ret) )
|
||||
if (check_leaf(t, (struct leaf *)n, key, &plen, flp, res, &ret))
|
||||
goto found;
|
||||
goto failed;
|
||||
}
|
||||
|
|
@ -1397,7 +1398,7 @@ fn_trie_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result
|
|||
pos = pn->pos;
|
||||
bits = pn->bits;
|
||||
|
||||
if(!chopped_off)
|
||||
if (!chopped_off)
|
||||
cindex = tkey_extract_bits(MASK_PFX(key, current_prefix_length), pos, bits);
|
||||
|
||||
n = tnode_get_child(pn, cindex);
|
||||
|
|
@ -1481,7 +1482,7 @@ fn_trie_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result
|
|||
*/
|
||||
|
||||
node_prefix = MASK_PFX(cn->key, cn->pos);
|
||||
key_prefix = MASK_PFX(key, cn->pos);
|
||||
key_prefix = MASK_PFX(key, cn->pos);
|
||||
pref_mismatch = key_prefix^node_prefix;
|
||||
mp = 0;
|
||||
|
||||
|
|
@ -1507,7 +1508,7 @@ fn_trie_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result
|
|||
continue;
|
||||
}
|
||||
if (IS_LEAF(n)) {
|
||||
if( check_leaf(t, (struct leaf *)n, key, &plen, flp, res, &ret))
|
||||
if (check_leaf(t, (struct leaf *)n, key, &plen, flp, res, &ret))
|
||||
goto found;
|
||||
}
|
||||
backtrace:
|
||||
|
|
@ -1527,10 +1528,10 @@ backtrace:
|
|||
* chopped off all bits in this tnode walk up to our parent.
|
||||
*/
|
||||
|
||||
if(chopped_off <= pn->bits)
|
||||
if (chopped_off <= pn->bits)
|
||||
cindex &= ~(1 << (chopped_off-1));
|
||||
else {
|
||||
if( NODE_PARENT(pn) == NULL)
|
||||
if (NODE_PARENT(pn) == NULL)
|
||||
goto failed;
|
||||
|
||||
/* Get Child's index */
|
||||
|
|
@ -1545,7 +1546,7 @@ backtrace:
|
|||
}
|
||||
}
|
||||
failed:
|
||||
ret = 1;
|
||||
ret = 1;
|
||||
found:
|
||||
read_unlock(&fib_lock);
|
||||
return ret;
|
||||
|
|
@ -1558,7 +1559,7 @@ static int trie_leaf_remove(struct trie *t, t_key key)
|
|||
struct node *n = t->trie;
|
||||
struct leaf *l;
|
||||
|
||||
if(trie_debug)
|
||||
if (trie_debug)
|
||||
printk("entering trie_leaf_remove(%p)\n", n);
|
||||
|
||||
/* Note that in the case skipped bits, those bits are *not* checked!
|
||||
|
|
@ -1571,14 +1572,14 @@ static int trie_leaf_remove(struct trie *t, t_key key)
|
|||
check_tnode(tn);
|
||||
n = tnode_get_child(tn ,tkey_extract_bits(key, tn->pos, tn->bits));
|
||||
|
||||
if(n && NODE_PARENT(n) != tn) {
|
||||
if (n && NODE_PARENT(n) != tn) {
|
||||
printk("BUG tn=%p, n->parent=%p\n", tn, NODE_PARENT(n));
|
||||
BUG();
|
||||
}
|
||||
}
|
||||
l = (struct leaf *) n;
|
||||
|
||||
if(!n || !tkey_equals(l->key, key))
|
||||
if (!n || !tkey_equals(l->key, key))
|
||||
return 0;
|
||||
|
||||
/*
|
||||
|
|
@ -1592,7 +1593,7 @@ static int trie_leaf_remove(struct trie *t, t_key key)
|
|||
tp = NODE_PARENT(n);
|
||||
tnode_free((struct tnode *) n);
|
||||
|
||||
if(tp) {
|
||||
if (tp) {
|
||||
cindex = tkey_extract_bits(key, tp->pos, tp->bits);
|
||||
put_child(t, (struct tnode *)tp, cindex, NULL);
|
||||
t->trie = trie_rebalance(t, tp);
|
||||
|
|
@ -1623,15 +1624,15 @@ fn_trie_delete(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta,
|
|||
memcpy(&key, rta->rta_dst, 4);
|
||||
|
||||
key = ntohl(key);
|
||||
mask = ntohl( inet_make_mask(plen) );
|
||||
mask = ntohl( inet_make_mask(plen) );
|
||||
|
||||
if(key & ~mask)
|
||||
if (key & ~mask)
|
||||
return -EINVAL;
|
||||
|
||||
key = key & mask;
|
||||
l = fib_find_node(t, key);
|
||||
|
||||
if(!l)
|
||||
if (!l)
|
||||
return -ESRCH;
|
||||
|
||||
fa_head = get_fa_head(l, plen);
|
||||
|
|
@ -1677,16 +1678,16 @@ fn_trie_delete(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta,
|
|||
|
||||
list_del(&fa->fa_list);
|
||||
|
||||
if(list_empty(fa_head)) {
|
||||
if (list_empty(fa_head)) {
|
||||
hlist_del(&li->hlist);
|
||||
kill_li = 1;
|
||||
}
|
||||
write_unlock_bh(&fib_lock);
|
||||
|
||||
if(kill_li)
|
||||
if (kill_li)
|
||||
free_leaf_info(li);
|
||||
|
||||
if(hlist_empty(&l->list))
|
||||
if (hlist_empty(&l->list))
|
||||
trie_leaf_remove(t, key);
|
||||
|
||||
if (fa->fa_state & FA_S_ACCESSED)
|
||||
|
|
@ -1748,8 +1749,8 @@ static struct leaf *nextleaf(struct trie *t, struct leaf *thisleaf)
|
|||
struct tnode *p;
|
||||
int idx;
|
||||
|
||||
if(c == NULL) {
|
||||
if(t->trie == NULL)
|
||||
if (c == NULL) {
|
||||
if (t->trie == NULL)
|
||||
return NULL;
|
||||
|
||||
if (IS_LEAF(t->trie)) /* trie w. just a leaf */
|
||||
|
|
@ -1759,18 +1760,19 @@ static struct leaf *nextleaf(struct trie *t, struct leaf *thisleaf)
|
|||
}
|
||||
else
|
||||
p = (struct tnode *) NODE_PARENT(c);
|
||||
|
||||
while (p) {
|
||||
int pos, last;
|
||||
|
||||
/* Find the next child of the parent */
|
||||
if(c)
|
||||
pos = 1 + tkey_extract_bits(c->key, p->pos, p->bits);
|
||||
if (c)
|
||||
pos = 1 + tkey_extract_bits(c->key, p->pos, p->bits);
|
||||
else
|
||||
pos = 0;
|
||||
|
||||
last = 1 << p->bits;
|
||||
for(idx = pos; idx < last ; idx++) {
|
||||
if( p->child[idx]) {
|
||||
if (p->child[idx]) {
|
||||
|
||||
/* Decend if tnode */
|
||||
|
||||
|
|
@ -1779,11 +1781,11 @@ static struct leaf *nextleaf(struct trie *t, struct leaf *thisleaf)
|
|||
idx = 0;
|
||||
|
||||
/* Rightmost non-NULL branch */
|
||||
if( p && IS_TNODE(p) )
|
||||
while ( p->child[idx] == NULL && idx < (1 << p->bits) ) idx++;
|
||||
if (p && IS_TNODE(p))
|
||||
while (p->child[idx] == NULL && idx < (1 << p->bits)) idx++;
|
||||
|
||||
/* Done with this tnode? */
|
||||
if( idx >= (1 << p->bits) || p->child[idx] == NULL )
|
||||
if (idx >= (1 << p->bits) || p->child[idx] == NULL )
|
||||
goto up;
|
||||
}
|
||||
return (struct leaf*) p->child[idx];
|
||||
|
|
@ -1816,7 +1818,7 @@ static int fn_trie_flush(struct fib_table *tb)
|
|||
if (ll && hlist_empty(&ll->list))
|
||||
trie_leaf_remove(t, ll->key);
|
||||
|
||||
if(trie_debug)
|
||||
if (trie_debug)
|
||||
printk("trie_flush found=%d\n", found);
|
||||
return found;
|
||||
}
|
||||
|
|
@ -1841,11 +1843,11 @@ fn_trie_select_default(struct fib_table *tb, const struct flowi *flp, struct fib
|
|||
read_lock(&fib_lock);
|
||||
|
||||
l = fib_find_node(t, 0);
|
||||
if(!l)
|
||||
if (!l)
|
||||
goto out;
|
||||
|
||||
fa_head = get_fa_head(l, 0);
|
||||
if(!fa_head)
|
||||
if (!fa_head)
|
||||
goto out;
|
||||
|
||||
if (list_empty(fa_head))
|
||||
|
|
@ -1969,10 +1971,10 @@ static int fn_trie_dump_plen(struct trie *t, int plen, struct fib_table *tb, str
|
|||
|
||||
fa_head = get_fa_head(l, plen);
|
||||
|
||||
if(!fa_head)
|
||||
if (!fa_head)
|
||||
continue;
|
||||
|
||||
if(list_empty(fa_head))
|
||||
if (list_empty(fa_head))
|
||||
continue;
|
||||
|
||||
if (fn_trie_dump_fa(l->key, plen, fa_head, tb, skb, cb)<0) {
|
||||
|
|
@ -2049,9 +2051,9 @@ struct fib_table * __init fib_hash_init(int id)
|
|||
trie_init(t);
|
||||
|
||||
if (id == RT_TABLE_LOCAL)
|
||||
trie_local=t;
|
||||
else if (id == RT_TABLE_MAIN)
|
||||
trie_main=t;
|
||||
trie_local = t;
|
||||
else if (id == RT_TABLE_MAIN)
|
||||
trie_main = t;
|
||||
|
||||
if (id == RT_TABLE_LOCAL)
|
||||
printk("IPv4 FIB: Using LC-trie version %s\n", VERSION);
|
||||
|
|
@ -2093,7 +2095,7 @@ static void printnode_seq(struct seq_file *seq, int indent, struct node *n,
|
|||
seq_printf(seq, "key=%d.%d.%d.%d\n",
|
||||
n->key >> 24, (n->key >> 16) % 256, (n->key >> 8) % 256, n->key % 256);
|
||||
else {
|
||||
int plen=((struct tnode *)n)->pos;
|
||||
int plen = ((struct tnode *)n)->pos;
|
||||
t_key prf=MASK_PFX(n->key, plen);
|
||||
seq_printf(seq, "key=%d.%d.%d.%d/%d\n",
|
||||
prf >> 24, (prf >> 16) % 256, (prf >> 8) % 256, prf % 256, plen);
|
||||
|
|
@ -2103,14 +2105,14 @@ static void printnode_seq(struct seq_file *seq, int indent, struct node *n,
|
|||
struct fib_alias *fa;
|
||||
int i;
|
||||
for (i=32; i>=0; i--)
|
||||
if(find_leaf_info(&l->list, i)) {
|
||||
if (find_leaf_info(&l->list, i)) {
|
||||
|
||||
struct list_head *fa_head = get_fa_head(l, i);
|
||||
|
||||
if(!fa_head)
|
||||
if (!fa_head)
|
||||
continue;
|
||||
|
||||
if(list_empty(fa_head))
|
||||
if (list_empty(fa_head))
|
||||
continue;
|
||||
|
||||
putspace_seq(seq, indent+2);
|
||||
|
|
@ -2136,7 +2138,7 @@ static void printnode_seq(struct seq_file *seq, int indent, struct node *n,
|
|||
}
|
||||
}
|
||||
else if (IS_TNODE(n)) {
|
||||
struct tnode *tn=(struct tnode *)n;
|
||||
struct tnode *tn = (struct tnode *)n;
|
||||
putspace_seq(seq, indent); seq_printf(seq, "| ");
|
||||
seq_printf(seq, "{key prefix=%08x/", tn->key&TKEY_GET_MASK(0, tn->pos));
|
||||
printbin_seq(seq, tkey_extract_bits(tn->key, 0, tn->pos), tn->pos);
|
||||
|
|
@ -2152,7 +2154,7 @@ static void printnode_seq(struct seq_file *seq, int indent, struct node *n,
|
|||
|
||||
static void trie_dump_seq(struct seq_file *seq, struct trie *t)
|
||||
{
|
||||
struct node *n=t->trie;
|
||||
struct node *n = t->trie;
|
||||
int cindex=0;
|
||||
int indent=1;
|
||||
int pend=0;
|
||||
|
|
@ -2164,7 +2166,7 @@ static void trie_dump_seq(struct seq_file *seq, struct trie *t)
|
|||
if (n) {
|
||||
printnode_seq(seq, indent, n, pend, cindex, 0);
|
||||
if (IS_TNODE(n)) {
|
||||
struct tnode *tn=(struct tnode *)n;
|
||||
struct tnode *tn = (struct tnode *)n;
|
||||
pend = tn->pos+tn->bits;
|
||||
putspace_seq(seq, indent); seq_printf(seq, "\\--\n");
|
||||
indent += 3;
|
||||
|
|
@ -2186,9 +2188,9 @@ static void trie_dump_seq(struct seq_file *seq, struct trie *t)
|
|||
*/
|
||||
|
||||
depth++;
|
||||
n=tn->child[cindex];
|
||||
tn=(struct tnode *)n;
|
||||
pend=tn->pos+tn->bits;
|
||||
n = tn->child[cindex];
|
||||
tn = (struct tnode *)n;
|
||||
pend = tn->pos+tn->bits;
|
||||
putspace_seq(seq, indent); seq_printf(seq, "\\--\n");
|
||||
indent+=3;
|
||||
cindex=0;
|
||||
|
|
@ -2217,8 +2219,8 @@ static void trie_dump_seq(struct seq_file *seq, struct trie *t)
|
|||
cindex = tkey_extract_bits(tn->key, NODE_PARENT(tn)->pos, NODE_PARENT(tn)->bits);
|
||||
tn = NODE_PARENT(tn);
|
||||
cindex++;
|
||||
n=(struct node *)tn;
|
||||
pend=tn->pos+tn->bits;
|
||||
n = (struct node *)tn;
|
||||
pend = tn->pos+tn->bits;
|
||||
indent-=3;
|
||||
depth--;
|
||||
}
|
||||
|
|
@ -2237,7 +2239,7 @@ static struct trie_stat *trie_stat_new(void)
|
|||
struct trie_stat *s = kmalloc(sizeof(struct trie_stat), GFP_KERNEL);
|
||||
int i;
|
||||
|
||||
if(s) {
|
||||
if (s) {
|
||||
s->totdepth = 0;
|
||||
s->maxdepth = 0;
|
||||
s->tnodes = 0;
|
||||
|
|
@ -2252,7 +2254,7 @@ static struct trie_stat *trie_stat_new(void)
|
|||
|
||||
static struct trie_stat *trie_collect_stats(struct trie *t)
|
||||
{
|
||||
struct node *n=t->trie;
|
||||
struct node *n = t->trie;
|
||||
struct trie_stat *s = trie_stat_new();
|
||||
int cindex = 0;
|
||||
int indent = 1;
|
||||
|
|
@ -2265,7 +2267,7 @@ static struct trie_stat *trie_collect_stats(struct trie *t)
|
|||
if (n) {
|
||||
if (IS_TNODE(n)) {
|
||||
struct tnode *tn = (struct tnode *)n;
|
||||
pend=tn->pos+tn->bits;
|
||||
pend = tn->pos+tn->bits;
|
||||
indent += 3;
|
||||
s->nodesizes[tn->bits]++;
|
||||
depth++;
|
||||
|
|
@ -2328,7 +2330,7 @@ static struct trie_stat *trie_collect_stats(struct trie *t)
|
|||
tn = NODE_PARENT(tn);
|
||||
cindex++;
|
||||
n = (struct node *)tn;
|
||||
pend=tn->pos+tn->bits;
|
||||
pend = tn->pos+tn->bits;
|
||||
indent -= 3;
|
||||
depth--;
|
||||
}
|
||||
|
|
@ -2464,10 +2466,10 @@ static int fib_triestat_seq_show(struct seq_file *seq, void *v)
|
|||
}
|
||||
|
||||
static struct seq_operations fib_triestat_seq_ops = {
|
||||
.start = fib_triestat_seq_start,
|
||||
.next = fib_triestat_seq_next,
|
||||
.stop = fib_triestat_seq_stop,
|
||||
.show = fib_triestat_seq_show,
|
||||
.start = fib_triestat_seq_start,
|
||||
.next = fib_triestat_seq_next,
|
||||
.stop = fib_triestat_seq_stop,
|
||||
.show = fib_triestat_seq_show,
|
||||
};
|
||||
|
||||
static int fib_triestat_seq_open(struct inode *inode, struct file *file)
|
||||
|
|
@ -2479,7 +2481,7 @@ static int fib_triestat_seq_open(struct inode *inode, struct file *file)
|
|||
if (rc)
|
||||
goto out_kfree;
|
||||
|
||||
seq = file->private_data;
|
||||
seq = file->private_data;
|
||||
out:
|
||||
return rc;
|
||||
out_kfree:
|
||||
|
|
@ -2487,11 +2489,11 @@ out_kfree:
|
|||
}
|
||||
|
||||
static struct file_operations fib_triestat_seq_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = fib_triestat_seq_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = seq_release_private,
|
||||
.owner = THIS_MODULE,
|
||||
.open = fib_triestat_seq_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = seq_release_private,
|
||||
};
|
||||
|
||||
int __init fib_stat_proc_init(void)
|
||||
|
|
@ -2565,10 +2567,10 @@ static int fib_trie_seq_show(struct seq_file *seq, void *v)
|
|||
}
|
||||
|
||||
static struct seq_operations fib_trie_seq_ops = {
|
||||
.start = fib_trie_seq_start,
|
||||
.next = fib_trie_seq_next,
|
||||
.stop = fib_trie_seq_stop,
|
||||
.show = fib_trie_seq_show,
|
||||
.start = fib_trie_seq_start,
|
||||
.next = fib_trie_seq_next,
|
||||
.stop = fib_trie_seq_stop,
|
||||
.show = fib_trie_seq_show,
|
||||
};
|
||||
|
||||
static int fib_trie_seq_open(struct inode *inode, struct file *file)
|
||||
|
|
@ -2580,7 +2582,7 @@ static int fib_trie_seq_open(struct inode *inode, struct file *file)
|
|||
if (rc)
|
||||
goto out_kfree;
|
||||
|
||||
seq = file->private_data;
|
||||
seq = file->private_data;
|
||||
out:
|
||||
return rc;
|
||||
out_kfree:
|
||||
|
|
@ -2588,11 +2590,11 @@ out_kfree:
|
|||
}
|
||||
|
||||
static struct file_operations fib_trie_seq_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = fib_trie_seq_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = seq_release_private,
|
||||
.owner = THIS_MODULE,
|
||||
.open = fib_trie_seq_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release= seq_release_private,
|
||||
};
|
||||
|
||||
int __init fib_proc_init(void)
|
||||
|
|
|
|||
Loading…
Reference in a new issue