diff options
-rw-r--r-- | net/ipv4/af_inet.c | 2 | ||||
-rw-r--r-- | net/ipv4/fib_trie.c | 772 |
2 files changed, 388 insertions, 386 deletions
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c index ef7468376ae6..163ae4068b5f 100644 --- a/net/ipv4/af_inet.c +++ b/net/ipv4/af_inet.c @@ -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: diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c index 4be234c7d8c3..a701405fab0b 100644 --- a/net/ipv4/fib_trie.c +++ b/net/ipv4/fib_trie.c @@ -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) @@ -147,7 +147,7 @@ struct trie_stat { unsigned int leaves; unsigned int nullpointers; unsigned int nodesizes[MAX_CHILDS]; -}; +}; struct trie { struct node *trie; @@ -185,9 +185,9 @@ static void trie_bug(char *err) BUG(); } -static inline struct node *tnode_get_child(struct tnode *tn, int i) +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]; @@ -202,7 +202,7 @@ static inline int tnode_child_length(struct tnode *tn) _________________________________________________________________ | i | i | i | i | i | i | i | N | N | N | S | S | S | S | S | C | ---------------------------------------------------------------- - 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 + 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 _________________________________________________________________ | C | C | C | u | u | u | u | u | u | u | u | u | u | u | u | u | @@ -226,25 +226,25 @@ 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; -} +} 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,58 +430,58 @@ 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; } -static inline void put_child(struct trie *t, struct tnode *tn, int i, struct node *n) +static inline void put_child(struct trie *t, struct tnode *tn, int i, struct node *n) { tnode_put_child_reorg(tn, i, n, -1); } - /* + /* * Add a child at position i overwriting the old value. * Update the value of full_children and empty_children. */ -static void tnode_put_child_reorg(struct tnode *tn, int i, struct node *n, int wasfull) +static void tnode_put_child_reorg(struct tnode *tn, int i, struct node *n, int wasfull) { 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"); } write_lock_bh(&fib_lock); - chi = tn->child[i]; + chi = tn->child[i]; /* update emptyChildren */ if (n == NULL && chi != NULL) tn->empty_children++; else if (n != NULL && chi == NULL) tn->empty_children--; - + /* update fullChildren */ if (wasfull == -1) wasfull = tnode_full(tn, chi); isfull = tnode_full(tn, n); - if (wasfull && !isfull) + if (wasfull && !isfull) tn->full_children--; - - else if (!wasfull && isfull) + + else if (!wasfull && isfull) tn->full_children++; - if(n) - NODE_SET_PARENT(n, tn); + if (n) + NODE_SET_PARENT(n, tn); tn->child[i] = n; write_unlock_bh(&fib_lock); } -static struct node *resize(struct trie *t, struct tnode *tn) +static struct node *resize(struct trie *t, struct tnode *tn) { int i; int err = 0; @@ -487,8 +489,8 @@ static struct node *resize(struct trie *t, struct tnode *tn) if (!tn) return NULL; - if(trie_debug) - printk("In tnode_resize %p inflate_threshold=%d threshold=%d\n", + if (trie_debug) + printk("In tnode_resize %p inflate_threshold=%d threshold=%d\n", tn, inflate_threshold, halve_threshold); /* No children */ @@ -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); @@ -514,72 +516,72 @@ static struct node *resize(struct trie *t, struct tnode *tn) } write_unlock_bh(&fib_lock); } - /* + /* * Double as long as the resulting node has a number of * nonempty nodes that are above the threshold. */ /* - * From "Implementing a dynamic compressed trie" by Stefan Nilsson of - * the Helsinki University of Technology and Matti Tikkanen of Nokia + * From "Implementing a dynamic compressed trie" by Stefan Nilsson of + * the Helsinki University of Technology and Matti Tikkanen of Nokia * Telecommunications, page 6: - * "A node is doubled if the ratio of non-empty children to all + * "A node is doubled if the ratio of non-empty children to all * children in the *doubled* node is at least 'high'." * - * '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 + * '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 * multiply the left-hand side by 50. - * - * 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" + * + * 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" * children, that is non-null tnodes with a skip value of 0. - * All of those will be doubled in the resulting inflated tnode, so + * All of those will be doubled in the resulting inflated tnode, so * we just count them one extra time here. - * + * * A clearer way to write this would be: - * + * * to_be_doubled = tn->full_children; - * not_to_be_doubled = tnode_child_length(tn) - tn->empty_children - + * not_to_be_doubled = tnode_child_length(tn) - tn->empty_children - * tn->full_children; * * new_child_length = tnode_child_length(tn) * 2; * - * new_fill_factor = 100 * (not_to_be_doubled + 2*to_be_doubled) / + * new_fill_factor = 100 * (not_to_be_doubled + 2*to_be_doubled) / * 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 >= * inflate_threshold - * + * * avoid a division: * 100 * (not_to_be_doubled + 2*to_be_doubled) >= * inflate_threshold * new_child_length - * + * * expand not_to_be_doubled and to_be_doubled, and shorten: - * 100 * (tnode_child_length(tn) - tn->empty_children + + * 100 * (tnode_child_length(tn) - tn->empty_children + * tn->full_children ) >= inflate_threshold * new_child_length - * + * * expand new_child_length: - * 100 * (tnode_child_length(tn) - tn->empty_children + + * 100 * (tnode_child_length(tn) - tn->empty_children + * tn->full_children ) >= * inflate_threshold * tnode_child_length(tn) * 2 - * + * * shorten again: - * 50 * (tn->full_children + tnode_child_length(tn) - - * tn->empty_children ) >= inflate_threshold * + * 50 * (tn->full_children + tnode_child_length(tn) - + * tn->empty_children ) >= inflate_threshold * * tnode_child_length(tn) - * + * */ check_tnode(tn); - + err = 0; while ((tn->full_children > 0 && 50 * (tn->full_children + tnode_child_length(tn) - tn->empty_children) >= @@ -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 @@ -617,18 +619,18 @@ static struct node *resize(struct trie *t, struct tnode *tn) } } - + /* Only one child remains */ if (tn->empty_children == tnode_child_length(tn) - 1) for (i = 0; i < tnode_child_length(tn); i++) { - + write_lock_bh(&fib_lock); if (tn->child[i] != NULL) { /* 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); @@ -659,12 +661,12 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err) } /* - * 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 + * 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 * of tnode is ignored. */ - + for(i = 0; i < olen; i++) { struct tnode *inode = (struct tnode *) tnode_get_child(oldtnode, i); @@ -675,20 +677,20 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err) struct tnode *left, *right; t_key m = TKEY_GET_MASK(inode->pos, 1); - + left = tnode_new(inode->key&(~m), inode->pos + 1, inode->bits - 1); - if(!left) { - *err = -ENOMEM; + if (!left) { + *err = -ENOMEM; break; } - + right = tnode_new(inode->key|m, inode->pos + 1, inode->bits - 1); - if(!right) { - *err = -ENOMEM; + if (!right) { + *err = -ENOMEM; break; } @@ -697,32 +699,32 @@ 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]) + for(j = 0; j < size; j++) + if (tn->child[j]) tnode_free((struct tnode *)tn->child[j]); tnode_free(tn); - + *err = -ENOMEM; return oldtnode; } for(i = 0; i < olen; i++) { struct node *node = tnode_get_child(oldtnode, i); - + /* An empty child */ if (node == NULL) continue; /* 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 @@ -745,37 +747,37 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn, int *err) struct tnode *left, *right; int size, j; - /* 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 + /* 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 mask 'm' below will be a single "one" bit at * the position (inode->pos) */ - /* Use the old key, but set the new significant - * bit to zero. + /* Use the old key, but set the new significant + * bit to zero. */ 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"); - - tn=tnode_new(oldtnode->key, oldtnode->pos, oldtnode->bits - 1); + if (trie_debug) printk("In halve\n"); + + tn = tnode_new(oldtnode->key, oldtnode->pos, oldtnode->bits - 1); if (!tn) { *err = -ENOMEM; @@ -810,39 +812,39 @@ static struct tnode *halve(struct trie *t, struct tnode *tn, int *err) } /* - * 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 + * 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 * of tnode is ignored. */ for(i = 0; i < olen; i += 2) { left = tnode_get_child(oldtnode, i); 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) { - *err = -ENOMEM; + if (!newBinNode) { + *err = -ENOMEM; break; } put_child(t, tn, i/2, (struct node *)newBinNode); } } - if(*err) { + if (*err) { int size = tnode_child_length(tn); int j; - for(j = 0; j < size; j++) - if( tn->child[j]) + for(j = 0; j < size; j++) + if (tn->child[j]) tnode_free((struct tnode *)tn->child[j]); tnode_free(tn); - + *err = -ENOMEM; return oldtnode; } @@ -850,7 +852,7 @@ static struct tnode *halve(struct trie *t, struct tnode *tn, int *err) for(i = 0; i < olen; i += 2) { left = tnode_get_child(oldtnode, i); right = tnode_get_child(oldtnode, i+1); - + /* At least one of the children is empty */ if (left == NULL) { if (right == NULL) /* Both are empty */ @@ -858,14 +860,14 @@ static struct tnode *halve(struct trie *t, struct tnode *tn, int *err) put_child(t, tn, i/2, right); } else if (right == NULL) put_child(t, tn, i/2, left); - + /* Two nonempty children */ else { struct tnode *newBinNode = (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,35 +906,35 @@ 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; } 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) { - - if (new->plen > li->plen) + + if (new->plen > li->plen) break; - + last = li; } - if(last) + if (last) hlist_add_after(&last->hlist, &new->hlist); - else + else hlist_add_before(&new->hlist, &li->hlist); } write_unlock_bh(&fib_lock); @@ -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,23 +978,23 @@ 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; i = 0; 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); @@ -1001,14 +1002,14 @@ static struct node *trie_rebalance(struct trie *t, struct tnode *tn) wasfull = tnode_full(tp, tnode_get_child(tp, cindex)); 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); } /* Handle last (top) tnode */ - if (IS_TNODE(tn)) + if (IS_TNODE(tn)) tn = (struct tnode*) resize(t, (struct tnode *)tn); return (struct node*) tn; @@ -1022,42 +1023,42 @@ 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, + /* 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, * and we should just put our new leaf in that. - * 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 + * 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 * not be the parent's 'pos'+'bits'! * - * If it does match the current key, get pos/bits from it, extract + * If it does match the current key, get pos/bits from it, extract * 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. * - * 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. + * 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. * 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; - - check_tnode(tn); - if(tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) { + check_tnode(tn); + + 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(); } @@ -1069,21 +1070,21 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen) /* * n ----> NULL, LEAF or TNODE * - * tp is n's (parent) ----> NULL or TNODE + * tp is n's (parent) ----> NULL or TNODE */ - if(tp && IS_LEAF(tp)) + if (tp && IS_LEAF(tp)) BUG(); /* Case 1: n is a leaf. Compare prefixes */ - if (n != NULL && IS_LEAF(n) && tkey_equals(key, n->key)) { + if (n != NULL && IS_LEAF(n) && tkey_equals(key, n->key)) { struct leaf *l = ( struct leaf *) n; - + 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; @@ -1116,8 +1117,8 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen) if (t->trie && n == NULL) { NODE_SET_PARENT(l, tp); - - if (!tp) + + if (!tp) BUG(); else { @@ -1127,8 +1128,8 @@ fib_insert_node(struct trie *t, int *err, u32 key, int plen) } /* Case 3: n is a LEAF or a TNODE and the key doesn't match. */ else { - /* - * Add a new tnode here + /* + * Add a new tnode here * first tnode need some special handling */ @@ -1136,39 +1137,39 @@ 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); } else { newpos = 0; - tn = tnode_new(key, newpos, 1); /* First tnode */ + tn = tnode_new(key, newpos, 1); /* First tnode */ } - if(!tn) { + if (!tn) { free_leaf_info(li); tnode_free((struct tnode *) l); *err = -ENOMEM; goto err; - } - + } + NODE_SET_PARENT(tn, tp); missbit=tkey_extract_bits(key, newpos, 1); 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); } - else { + else { t->trie = (struct node*) tn; /* First tnode */ tp = tn; } } - if(tp && tp->pos+tp->bits > 32) { - printk("ERROR tp=%p pos=%d, bits=%d, key=%0x plen=%d\n", + 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); } /* Rebalance the trie */ @@ -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; @@ -1198,17 +1199,17 @@ fn_trie_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, return -EINVAL; key = 0; - if (rta->rta_dst) + if (rta->rta_dst) memcpy(&key, rta->rta_dst, 4); 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; @@ -1217,9 +1218,9 @@ fn_trie_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, goto err; l = fib_find_node(t, key); - fa = NULL; + 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; } @@ -1327,11 +1328,11 @@ out_free_new_fa: kmem_cache_free(fn_alias_kmem, new_fa); out: fib_release_info(fi); -err:; +err:; return err; } -static inline int check_leaf(struct trie *t, struct leaf *l, t_key key, int *plen, const struct flowi *flp, +static inline int check_leaf(struct trie *t, struct leaf *l, t_key key, int *plen, const struct flowi *flp, struct fib_result *res, int *err) { int i; @@ -1339,12 +1340,12 @@ static inline int check_leaf(struct trie *t, struct leaf *l, t_key key, int *pl struct leaf_info *li; struct hlist_head *hhead = &l->list; struct hlist_node *node; - + hlist_for_each_entry(li, node, hhead, hlist) { i = li->plen; mask = ntohl(inet_make_mask(i)); - if (l->key != (key & mask)) + if (l->key != (key & mask)) continue; if (((*err) = fib_semantic_match(&li->falh, flp, res, l->key, mask, i)) == 0) { @@ -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,19 +1386,19 @@ 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; } pn = (struct tnode *) n; chopped_off = 0; - + while (pn) { 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); @@ -1417,33 +1418,33 @@ fn_trie_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result int mp; /* - * It's a tnode, and we can do some extra checks here if we + * 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 + * 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, + * 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 + * paragraph) are also guaranteed ok, but the rest is * considered unknown. * * The skipped bits are key[pos+bits..cn->pos]. */ - - /* 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 + + /* 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 + * bits. Remember, since we have already indexed into the + * parent's child array, we know that the bits we chopped of * *are* zero. */ /* NOTA BENE: CHECKING ONLY SKIPPED BITS FOR THE NEW NODE HERE */ - + if (current_prefix_length < pos+bits) { if (tkey_extract_bits(cn->key, current_prefix_length, cn->pos - current_prefix_length) != 0 || @@ -1452,13 +1453,13 @@ fn_trie_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result } /* - * If chopped_off=0, the index is fully validated and we - * only need to look at the skipped bits for this, the new, + * If chopped_off=0, the index is fully validated and we + * only need to |