redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

reiserfs: rename p_s_tb to tb 

This patch is a simple s/p_s_tb/tb/g to the reiserfs code.  This is the
fourth in a series of patches to rip out some of the awful variable
naming in reiserfs.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
hifive-unleashed-5.1
Jeff Mahoney 2009-03-30 14:02:48 -04:00 committed by Linus Torvalds
parent 995c762ea4
commit a063ae1792
3 changed files with 252 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

478
fs/reiserfs/fix_node.c
View File

@ -749,26 +749,26 @@ else \
-1, -1);\ -1, -1);\
} }
static void free_buffers_in_tb(struct tree_balance *p_s_tb) static void free_buffers_in_tb(struct tree_balance *tb)
{ {
int n_counter; int n_counter;
pathrelse(p_s_tb->tb_path); pathrelse(tb->tb_path);
for (n_counter = 0; n_counter < MAX_HEIGHT; n_counter++) { for (n_counter = 0; n_counter < MAX_HEIGHT; n_counter++) {
brelse(p_s_tb->L[n_counter]); brelse(tb->L[n_counter]);
brelse(p_s_tb->R[n_counter]); brelse(tb->R[n_counter]);
brelse(p_s_tb->FL[n_counter]); brelse(tb->FL[n_counter]);
brelse(p_s_tb->FR[n_counter]); brelse(tb->FR[n_counter]);
brelse(p_s_tb->CFL[n_counter]); brelse(tb->CFL[n_counter]);
brelse(p_s_tb->CFR[n_counter]); brelse(tb->CFR[n_counter]);
p_s_tb->L[n_counter] = NULL; tb->L[n_counter] = NULL;
p_s_tb->R[n_counter] = NULL; tb->R[n_counter] = NULL;
p_s_tb->FL[n_counter] = NULL; tb->FL[n_counter] = NULL;
p_s_tb->FR[n_counter] = NULL; tb->FR[n_counter] = NULL;
p_s_tb->CFL[n_counter] = NULL; tb->CFL[n_counter] = NULL;
p_s_tb->CFR[n_counter] = NULL; tb->CFR[n_counter] = NULL;
} }
} }
@ -778,14 +778,14 @@ static void free_buffers_in_tb(struct tree_balance *p_s_tb)
* NO_DISK_SPACE - no disk space. * NO_DISK_SPACE - no disk space.
*/ */
/* The function is NOT SCHEDULE-SAFE! */ /* The function is NOT SCHEDULE-SAFE! */
static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h) static int get_empty_nodes(struct tree_balance *tb, int n_h)
{ {
struct buffer_head *p_s_new_bh, struct buffer_head *p_s_new_bh,
*p_s_Sh = PATH_H_PBUFFER(p_s_tb->tb_path, n_h); *p_s_Sh = PATH_H_PBUFFER(tb->tb_path, n_h);
b_blocknr_t *p_n_blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, }; b_blocknr_t *p_n_blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, };
int n_counter, n_number_of_freeblk, n_amount_needed, /* number of needed empty blocks */ int n_counter, n_number_of_freeblk, n_amount_needed, /* number of needed empty blocks */
n_retval = CARRY_ON; n_retval = CARRY_ON;
struct super_block *sb = p_s_tb->tb_sb; struct super_block *sb = tb->tb_sb;
/* number_of_freeblk is the number of empty blocks which have been /* number_of_freeblk is the number of empty blocks which have been
acquired for use by the balancing algorithm minus the number of acquired for use by the balancing algorithm minus the number of
@ -803,15 +803,15 @@ static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
the analysis or 0 if not restarted, then subtract the amount needed the analysis or 0 if not restarted, then subtract the amount needed
by all of the levels of the tree below n_h. */ by all of the levels of the tree below n_h. */
/* blknum includes S[n_h], so we subtract 1 in this calculation */ /* blknum includes S[n_h], so we subtract 1 in this calculation */
for (n_counter = 0, n_number_of_freeblk = p_s_tb->cur_blknum; for (n_counter = 0, n_number_of_freeblk = tb->cur_blknum;
n_counter < n_h; n_counter++) n_counter < n_h; n_counter++)
n_number_of_freeblk -= n_number_of_freeblk -=
(p_s_tb->blknum[n_counter]) ? (p_s_tb->blknum[n_counter] - (tb->blknum[n_counter]) ? (tb->blknum[n_counter] -
1) : 0; 1) : 0;
/* Allocate missing empty blocks. */ /* Allocate missing empty blocks. */
/* if p_s_Sh == 0 then we are getting a new root */ /* if p_s_Sh == 0 then we are getting a new root */
n_amount_needed = (p_s_Sh) ? (p_s_tb->blknum[n_h] - 1) : 1; n_amount_needed = (p_s_Sh) ? (tb->blknum[n_h] - 1) : 1;
/* Amount_needed = the amount that we need more than the amount that we have. */ /* Amount_needed = the amount that we need more than the amount that we have. */
if (n_amount_needed > n_number_of_freeblk) if (n_amount_needed > n_number_of_freeblk)
n_amount_needed -= n_number_of_freeblk; n_amount_needed -= n_number_of_freeblk;
@ -819,7 +819,7 @@ static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
return CARRY_ON; return CARRY_ON;
/* No need to check quota - is not allocated for blocks used for formatted nodes */ /* No need to check quota - is not allocated for blocks used for formatted nodes */
if (reiserfs_new_form_blocknrs(p_s_tb, a_n_blocknrs, if (reiserfs_new_form_blocknrs(tb, a_n_blocknrs,
n_amount_needed) == NO_DISK_SPACE) n_amount_needed) == NO_DISK_SPACE)
return NO_DISK_SPACE; return NO_DISK_SPACE;
@ -838,14 +838,14 @@ static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
p_s_new_bh); p_s_new_bh);
/* Put empty buffers into the array. */ /* Put empty buffers into the array. */
RFALSE(p_s_tb->FEB[p_s_tb->cur_blknum], RFALSE(tb->FEB[tb->cur_blknum],
"PAP-8141: busy slot for new buffer"); "PAP-8141: busy slot for new buffer");
set_buffer_journal_new(p_s_new_bh); set_buffer_journal_new(p_s_new_bh);
p_s_tb->FEB[p_s_tb->cur_blknum++] = p_s_new_bh; tb->FEB[tb->cur_blknum++] = p_s_new_bh;
} }
if (n_retval == CARRY_ON && FILESYSTEM_CHANGED_TB(p_s_tb)) if (n_retval == CARRY_ON && FILESYSTEM_CHANGED_TB(tb))
n_retval = REPEAT_SEARCH; n_retval = REPEAT_SEARCH;
return n_retval; return n_retval;
@ -896,33 +896,34 @@ static int get_rfree(struct tree_balance *tb, int h)
} }
/* Check whether left neighbor is in memory. */ /* Check whether left neighbor is in memory. */
static int is_left_neighbor_in_cache(struct tree_balance *p_s_tb, int n_h) static int is_left_neighbor_in_cache(struct tree_balance *tb, int n_h)
{ {
struct buffer_head *p_s_father, *left; struct buffer_head *p_s_father, *left;
struct super_block *sb = p_s_tb->tb_sb; struct super_block *sb = tb->tb_sb;
b_blocknr_t n_left_neighbor_blocknr; b_blocknr_t n_left_neighbor_blocknr;
int n_left_neighbor_position; int n_left_neighbor_position;
if (!p_s_tb->FL[n_h]) /* Father of the left neighbor does not exist. */ /* Father of the left neighbor does not exist. */
if (!tb->FL[n_h])
return 0; return 0;
/* Calculate father of the node to be balanced. */ /* Calculate father of the node to be balanced. */
p_s_father = PATH_H_PBUFFER(p_s_tb->tb_path, n_h + 1); p_s_father = PATH_H_PBUFFER(tb->tb_path, n_h + 1);
RFALSE(!p_s_father || RFALSE(!p_s_father ||
!B_IS_IN_TREE(p_s_father) || !B_IS_IN_TREE(p_s_father) ||
!B_IS_IN_TREE(p_s_tb->FL[n_h]) || !B_IS_IN_TREE(tb->FL[n_h]) ||
!buffer_uptodate(p_s_father) || !buffer_uptodate(p_s_father) ||
!buffer_uptodate(p_s_tb->FL[n_h]), !buffer_uptodate(tb->FL[n_h]),
"vs-8165: F[h] (%b) or FL[h] (%b) is invalid", "vs-8165: F[h] (%b) or FL[h] (%b) is invalid",
p_s_father, p_s_tb->FL[n_h]); p_s_father, tb->FL[n_h]);
/* Get position of the pointer to the left neighbor into the left father. */ /* Get position of the pointer to the left neighbor into the left father. */
n_left_neighbor_position = (p_s_father == p_s_tb->FL[n_h]) ? n_left_neighbor_position = (p_s_father == tb->FL[n_h]) ?
p_s_tb->lkey[n_h] : B_NR_ITEMS(p_s_tb->FL[n_h]); tb->lkey[n_h] : B_NR_ITEMS(tb->FL[n_h]);
/* Get left neighbor block number. */ /* Get left neighbor block number. */
n_left_neighbor_blocknr = n_left_neighbor_blocknr =
B_N_CHILD_NUM(p_s_tb->FL[n_h], n_left_neighbor_position); B_N_CHILD_NUM(tb->FL[n_h], n_left_neighbor_position);
/* Look for the left neighbor in the cache. */ /* Look for the left neighbor in the cache. */
if ((left = sb_find_get_block(sb, n_left_neighbor_blocknr))) { if ((left = sb_find_get_block(sb, n_left_neighbor_blocknr))) {
@ -953,14 +954,14 @@ static void decrement_key(struct cpu_key *p_s_key)
SCHEDULE_OCCURRED - schedule occurred while the function worked; SCHEDULE_OCCURRED - schedule occurred while the function worked;
* CARRY_ON - schedule didn't occur while the function worked; * CARRY_ON - schedule didn't occur while the function worked;
*/ */
static int get_far_parent(struct tree_balance *p_s_tb, static int get_far_parent(struct tree_balance *tb,
int n_h, int n_h,
struct buffer_head **pp_s_father, struct buffer_head **pp_s_father,
struct buffer_head **pp_s_com_father, char c_lr_par) struct buffer_head **pp_s_com_father, char c_lr_par)
{ {
struct buffer_head *p_s_parent; struct buffer_head *p_s_parent;
INITIALIZE_PATH(s_path_to_neighbor_father); INITIALIZE_PATH(s_path_to_neighbor_father);
struct treepath *p_s_path = p_s_tb->tb_path; struct treepath *p_s_path = tb->tb_path;
struct cpu_key s_lr_father_key; struct cpu_key s_lr_father_key;
int n_counter, int n_counter,
n_position = INT_MAX, n_position = INT_MAX,
@ -1005,9 +1006,9 @@ static int get_far_parent(struct tree_balance *p_s_tb,
if (n_counter == FIRST_PATH_ELEMENT_OFFSET) { if (n_counter == FIRST_PATH_ELEMENT_OFFSET) {
/* Check whether first buffer in the path is the root of the tree. */ /* Check whether first buffer in the path is the root of the tree. */
if (PATH_OFFSET_PBUFFER if (PATH_OFFSET_PBUFFER
(p_s_tb->tb_path, (tb->tb_path,
FIRST_PATH_ELEMENT_OFFSET)->b_blocknr == FIRST_PATH_ELEMENT_OFFSET)->b_blocknr ==
SB_ROOT_BLOCK(p_s_tb->tb_sb)) { SB_ROOT_BLOCK(tb->tb_sb)) {
*pp_s_father = *pp_s_com_father = NULL; *pp_s_father = *pp_s_com_father = NULL;
return CARRY_ON; return CARRY_ON;
} }
@ -1022,7 +1023,7 @@ static int get_far_parent(struct tree_balance *p_s_tb,
if (buffer_locked(*pp_s_com_father)) { if (buffer_locked(*pp_s_com_father)) {
__wait_on_buffer(*pp_s_com_father); __wait_on_buffer(*pp_s_com_father);
if (FILESYSTEM_CHANGED_TB(p_s_tb)) { if (FILESYSTEM_CHANGED_TB(tb)) {
brelse(*pp_s_com_father); brelse(*pp_s_com_father);
return REPEAT_SEARCH; return REPEAT_SEARCH;
} }
@ -1035,9 +1036,9 @@ static int get_far_parent(struct tree_balance *p_s_tb,
le_key2cpu_key(&s_lr_father_key, le_key2cpu_key(&s_lr_father_key,
B_N_PDELIM_KEY(*pp_s_com_father, B_N_PDELIM_KEY(*pp_s_com_father,
(c_lr_par == (c_lr_par ==
LEFT_PARENTS) ? (p_s_tb->lkey[n_h - 1] = LEFT_PARENTS) ? (tb->lkey[n_h - 1] =
n_position - n_position -
1) : (p_s_tb->rkey[n_h - 1) : (tb->rkey[n_h -
1] = 1] =
n_position))); n_position)));
@ -1045,12 +1046,12 @@ static int get_far_parent(struct tree_balance *p_s_tb,
decrement_key(&s_lr_father_key); decrement_key(&s_lr_father_key);
if (search_by_key if (search_by_key
(p_s_tb->tb_sb, &s_lr_father_key, &s_path_to_neighbor_father, (tb->tb_sb, &s_lr_father_key, &s_path_to_neighbor_father,
n_h + 1) == IO_ERROR) n_h + 1) == IO_ERROR)
// path is released // path is released
return IO_ERROR; return IO_ERROR;
if (FILESYSTEM_CHANGED_TB(p_s_tb)) { if (FILESYSTEM_CHANGED_TB(tb)) {
pathrelse(&s_path_to_neighbor_father); pathrelse(&s_path_to_neighbor_father);
brelse(*pp_s_com_father); brelse(*pp_s_com_father);
return REPEAT_SEARCH; return REPEAT_SEARCH;
@ -1075,24 +1076,26 @@ static int get_far_parent(struct tree_balance *p_s_tb,
* Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked; * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked;
* CARRY_ON - schedule didn't occur while the function worked; * CARRY_ON - schedule didn't occur while the function worked;
*/ */
static int get_parents(struct tree_balance *p_s_tb, int n_h) static int get_parents(struct tree_balance *tb, int n_h)
{ {
struct treepath *p_s_path = p_s_tb->tb_path; struct treepath *p_s_path = tb->tb_path;
int n_position, int n_position,
n_ret_value, n_ret_value,
n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h); n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h);
struct buffer_head *p_s_curf, *p_s_curcf; struct buffer_head *p_s_curf, *p_s_curcf;
/* Current node is the root of the tree or will be root of the tree */ /* Current node is the root of the tree or will be root of the tree */
if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) { if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
/* The root can not have parents. /* The root can not have parents.
Release nodes which previously were obtained as parents of the current node neighbors. */ Release nodes which previously were obtained as parents of the current node neighbors. */
brelse(p_s_tb->FL[n_h]); brelse(tb->FL[n_h]);
brelse(p_s_tb->CFL[n_h]); brelse(tb->CFL[n_h]);
brelse(p_s_tb->FR[n_h]); brelse(tb->FR[n_h]);
brelse(p_s_tb->CFR[n_h]); brelse(tb->CFR[n_h]);
p_s_tb->FL[n_h] = p_s_tb->CFL[n_h] = p_s_tb->FR[n_h] = tb->FL[n_h] = NULL;
p_s_tb->CFR[n_h] = NULL; tb->CFL[n_h] = NULL;
tb->FR[n_h] = NULL;
tb->CFR[n_h] = NULL;
return CARRY_ON; return CARRY_ON;
} }
@ -1104,22 +1107,22 @@ static int get_parents(struct tree_balance *p_s_tb, int n_h)
PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1); PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1);
get_bh(p_s_curf); get_bh(p_s_curf);
get_bh(p_s_curf); get_bh(p_s_curf);
p_s_tb->lkey[n_h] = n_position - 1; tb->lkey[n_h] = n_position - 1;
} else { } else {
/* Calculate current parent of L[n_path_offset], which is the left neighbor of the current node. /* Calculate current parent of L[n_path_offset], which is the left neighbor of the current node.
Calculate current common parent of L[n_path_offset] and the current node. Note that Calculate current common parent of L[n_path_offset] and the current node. Note that
CFL[n_path_offset] not equal FL[n_path_offset] and CFL[n_path_offset] not equal F[n_path_offset]. CFL[n_path_offset] not equal FL[n_path_offset] and CFL[n_path_offset] not equal F[n_path_offset].
Calculate lkey[n_path_offset]. */ Calculate lkey[n_path_offset]. */
if ((n_ret_value = get_far_parent(p_s_tb, n_h + 1, &p_s_curf, if ((n_ret_value = get_far_parent(tb, n_h + 1, &p_s_curf,
&p_s_curcf, &p_s_curcf,
LEFT_PARENTS)) != CARRY_ON) LEFT_PARENTS)) != CARRY_ON)
return n_ret_value; return n_ret_value;
} }
brelse(p_s_tb->FL[n_h]); brelse(tb->FL[n_h]);
p_s_tb->FL[n_h] = p_s_curf; /* New initialization of FL[n_h]. */ tb->FL[n_h] = p_s_curf; /* New initialization of FL[n_h]. */
brelse(p_s_tb->CFL[n_h]); brelse(tb->CFL[n_h]);
p_s_tb->CFL[n_h] = p_s_curcf; /* New initialization of CFL[n_h]. */ tb->CFL[n_h] = p_s_curcf; /* New initialization of CFL[n_h]. */
RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) || RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) ||
(p_s_curcf && !B_IS_IN_TREE(p_s_curcf)), (p_s_curcf && !B_IS_IN_TREE(p_s_curcf)),
@ -1133,7 +1136,7 @@ static int get_parents(struct tree_balance *p_s_tb, int n_h)
Calculate current common parent of R[n_h] and current node. Note that CFR[n_h] Calculate current common parent of R[n_h] and current node. Note that CFR[n_h]
not equal FR[n_path_offset] and CFR[n_h] not equal F[n_h]. */ not equal FR[n_path_offset] and CFR[n_h] not equal F[n_h]. */
if ((n_ret_value = if ((n_ret_value =
get_far_parent(p_s_tb, n_h + 1, &p_s_curf, &p_s_curcf, get_far_parent(tb, n_h + 1, &p_s_curf, &p_s_curcf,
RIGHT_PARENTS)) != CARRY_ON) RIGHT_PARENTS)) != CARRY_ON)
return n_ret_value; return n_ret_value;
} else { } else {
@ -1143,14 +1146,16 @@ static int get_parents(struct tree_balance *p_s_tb, int n_h)
PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1); PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1);
get_bh(p_s_curf); get_bh(p_s_curf);
get_bh(p_s_curf); get_bh(p_s_curf);
p_s_tb->rkey[n_h] = n_position; tb->rkey[n_h] = n_position;
} }
brelse(p_s_tb->FR[n_h]); brelse(tb->FR[n_h]);
p_s_tb->FR[n_h] = p_s_curf; /* New initialization of FR[n_path_offset]. */ /* New initialization of FR[n_path_offset]. */
tb->FR[n_h] = p_s_curf;
brelse(p_s_tb->CFR[n_h]); brelse(tb->CFR[n_h]);
p_s_tb->CFR[n_h] = p_s_curcf; /* New initialization of CFR[n_path_offset]. */ /* New initialization of CFR[n_path_offset]. */
tb->CFR[n_h] = p_s_curcf;
RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) || RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) ||
(p_s_curcf && !B_IS_IN_TREE(p_s_curcf)), (p_s_curcf && !B_IS_IN_TREE(p_s_curcf)),
@ -1885,12 +1890,12 @@ static int check_balance(int mode,
} }
/* Check whether parent at the path is the really parent of the current node.*/ /* Check whether parent at the path is the really parent of the current node.*/
static int get_direct_parent(struct tree_balance *p_s_tb, int n_h) static int get_direct_parent(struct tree_balance *tb, int n_h)
{ {
struct buffer_head *bh; struct buffer_head *bh;
struct treepath *p_s_path = p_s_tb->tb_path; struct treepath *p_s_path = tb->tb_path;
int n_position, int n_position,
n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h); n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h);
/* We are in the root or in the new root. */ /* We are in the root or in the new root. */
if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) { if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
@ -1899,7 +1904,7 @@ static int get_direct_parent(struct tree_balance *p_s_tb, int n_h)
"PAP-8260: invalid offset in the path"); "PAP-8260: invalid offset in the path");
if (PATH_OFFSET_PBUFFER(p_s_path, FIRST_PATH_ELEMENT_OFFSET)-> if (PATH_OFFSET_PBUFFER(p_s_path, FIRST_PATH_ELEMENT_OFFSET)->
b_blocknr == SB_ROOT_BLOCK(p_s_tb->tb_sb)) { b_blocknr == SB_ROOT_BLOCK(tb->tb_sb)) {
/* Root is not changed. */ /* Root is not changed. */
PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1) = NULL; PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1) = NULL;
PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1) = 0; PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1) = 0;
@ -1924,7 +1929,7 @@ static int get_direct_parent(struct tree_balance *p_s_tb, int n_h)
if (buffer_locked(bh)) { if (buffer_locked(bh)) {
__wait_on_buffer(bh); __wait_on_buffer(bh);
if (FILESYSTEM_CHANGED_TB(p_s_tb)) if (FILESYSTEM_CHANGED_TB(tb))
return REPEAT_SEARCH; return REPEAT_SEARCH;
} }
@ -1937,85 +1942,86 @@ static int get_direct_parent(struct tree_balance *p_s_tb, int n_h)
* Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked; * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked;
* CARRY_ON - schedule didn't occur while the function worked; * CARRY_ON - schedule didn't occur while the function worked;
*/ */
static int get_neighbors(struct tree_balance *p_s_tb, int n_h) static int get_neighbors(struct tree_balance *tb, int n_h)
{ {
int n_child_position, int n_child_position,
n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1); n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h + 1);
unsigned long n_son_number; unsigned long n_son_number;
struct super_block *sb = p_s_tb->tb_sb; struct super_block *sb = tb->tb_sb;
struct buffer_head *bh; struct buffer_head *bh;
PROC_INFO_INC(sb, get_neighbors[n_h]); PROC_INFO_INC(sb, get_neighbors[n_h]);
if (p_s_tb->lnum[n_h]) { if (tb->lnum[n_h]) {
/* We need left neighbor to balance S[n_h]. */ /* We need left neighbor to balance S[n_h]. */
PROC_INFO_INC(sb, need_l_neighbor[n_h]); PROC_INFO_INC(sb, need_l_neighbor[n_h]);
bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset); bh = PATH_OFFSET_PBUFFER(tb->tb_path, n_path_offset);
RFALSE(bh == p_s_tb->FL[n_h] && RFALSE(bh == tb->FL[n_h] &&
!PATH_OFFSET_POSITION(p_s_tb->tb_path, n_path_offset), !PATH_OFFSET_POSITION(tb->tb_path, n_path_offset),
"PAP-8270: invalid position in the parent"); "PAP-8270: invalid position in the parent");
n_child_position = n_child_position =
(bh == (bh ==
p_s_tb->FL[n_h]) ? p_s_tb->lkey[n_h] : B_NR_ITEMS(p_s_tb-> tb->FL[n_h]) ? tb->lkey[n_h] : B_NR_ITEMS(tb->
FL[n_h]); FL[n_h]);
n_son_number = B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position); n_son_number = B_N_CHILD_NUM(tb->FL[n_h], n_child_position);
bh = sb_bread(sb, n_son_number); bh = sb_bread(sb, n_son_number);
if (!bh) if (!bh)
return IO_ERROR; return IO_ERROR;
if (FILESYSTEM_CHANGED_TB(p_s_tb)) { if (FILESYSTEM_CHANGED_TB(tb)) {
brelse(bh); brelse(bh);
PROC_INFO_INC(sb, get_neighbors_restart[n_h]); PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
return REPEAT_SEARCH; return REPEAT_SEARCH;
} }
RFALSE(!B_IS_IN_TREE(p_s_tb->FL[n_h]) || RFALSE(!B_IS_IN_TREE(tb->FL[n_h]) ||
n_child_position > B_NR_ITEMS(p_s_tb->FL[n_h]) || n_child_position > B_NR_ITEMS(tb->FL[n_h]) ||
B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position) != B_N_CHILD_NUM(tb->FL[n_h], n_child_position) !=
bh->b_blocknr, "PAP-8275: invalid parent"); bh->b_blocknr, "PAP-8275: invalid parent");
RFALSE(!B_IS_IN_TREE(bh), "PAP-8280: invalid child"); RFALSE(!B_IS_IN_TREE(bh), "PAP-8280: invalid child");
RFALSE(!n_h && RFALSE(!n_h &&
B_FREE_SPACE(bh) != B_FREE_SPACE(bh) !=
MAX_CHILD_SIZE(bh) - MAX_CHILD_SIZE(bh) -
dc_size(B_N_CHILD(p_s_tb->FL[0], n_child_position)), dc_size(B_N_CHILD(tb->FL[0], n_child_position)),
"PAP-8290: invalid child size of left neighbor"); "PAP-8290: invalid child size of left neighbor");
brelse(p_s_tb->L[n_h]); brelse(tb->L[n_h]);
p_s_tb->L[n_h] = bh; tb->L[n_h] = bh;
} }
if (p_s_tb->rnum[n_h]) { /* We need right neighbor to balance S[n_path_offset]. */ /* We need right neighbor to balance S[n_path_offset]. */
if (tb->rnum[n_h]) {
PROC_INFO_INC(sb, need_r_neighbor[n_h]); PROC_INFO_INC(sb, need_r_neighbor[n_h]);
bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset); bh = PATH_OFFSET_PBUFFER(tb->tb_path, n_path_offset);
RFALSE(bh == p_s_tb->FR[n_h] && RFALSE(bh == tb->FR[n_h] &&
PATH_OFFSET_POSITION(p_s_tb->tb_path, PATH_OFFSET_POSITION(tb->tb_path,
n_path_offset) >= n_path_offset) >=
B_NR_ITEMS(bh), B_NR_ITEMS(bh),
"PAP-8295: invalid position in the parent"); "PAP-8295: invalid position in the parent");
n_child_position = n_child_position =
(bh == p_s_tb->FR[n_h]) ? p_s_tb->rkey[n_h] + 1 : 0; (bh == tb->FR[n_h]) ? tb->rkey[n_h] + 1 : 0;
n_son_number = B_N_CHILD_NUM(p_s_tb->FR[n_h], n_child_position); n_son_number = B_N_CHILD_NUM(tb->FR[n_h], n_child_position);
bh = sb_bread(sb, n_son_number); bh = sb_bread(sb, n_son_number);
if (!bh) if (!bh)
return IO_ERROR; return IO_ERROR;
if (FILESYSTEM_CHANGED_TB(p_s_tb)) { if (FILESYSTEM_CHANGED_TB(tb)) {
brelse(bh); brelse(bh);
PROC_INFO_INC(sb, get_neighbors_restart[n_h]); PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
return REPEAT_SEARCH; return REPEAT_SEARCH;
} }
brelse(p_s_tb->R[n_h]); brelse(tb->R[n_h]);
p_s_tb->R[n_h] = bh; tb->R[n_h] = bh;
RFALSE(!n_h RFALSE(!n_h
&& B_FREE_SPACE(bh) != && B_FREE_SPACE(bh) !=
MAX_CHILD_SIZE(bh) - MAX_CHILD_SIZE(bh) -
dc_size(B_N_CHILD(p_s_tb->FR[0], n_child_position)), dc_size(B_N_CHILD(tb->FR[0], n_child_position)),
"PAP-8300: invalid child size of right neighbor (%d != %d - %d)", "PAP-8300: invalid child size of right neighbor (%d != %d - %d)",
B_FREE_SPACE(bh), MAX_CHILD_SIZE(bh), B_FREE_SPACE(bh), MAX_CHILD_SIZE(bh),
dc_size(B_N_CHILD(p_s_tb->FR[0], n_child_position))); dc_size(B_N_CHILD(tb->FR[0], n_child_position)));
} }
return CARRY_ON; return CARRY_ON;
@ -2139,7 +2145,7 @@ static int clear_all_dirty_bits(struct super_block *s, struct buffer_head *bh)
return reiserfs_prepare_for_journal(s, bh, 0); return reiserfs_prepare_for_journal(s, bh, 0);
} }
static int wait_tb_buffers_until_unlocked(struct tree_balance *p_s_tb) static int wait_tb_buffers_until_unlocked(struct tree_balance *tb)
{ {
struct buffer_head *locked; struct buffer_head *locked;
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
@ -2151,95 +2157,94 @@ static int wait_tb_buffers_until_unlocked(struct tree_balance *p_s_tb)
locked = NULL; locked = NULL;
for (i = p_s_tb->tb_path->path_length; for (i = tb->tb_path->path_length;
!locked && i > ILLEGAL_PATH_ELEMENT_OFFSET; i--) { !locked && i > ILLEGAL_PATH_ELEMENT_OFFSET; i--) {
if (PATH_OFFSET_PBUFFER(p_s_tb->tb_path, i)) { if (PATH_OFFSET_PBUFFER(tb->tb_path, i)) {
/* if I understand correctly, we can only be sure the last buffer /* if I understand correctly, we can only be sure the last buffer
** in the path is in the tree --clm ** in the path is in the tree --clm
*/ */
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
if (PATH_PLAST_BUFFER(p_s_tb->tb_path) == if (PATH_PLAST_BUFFER(tb->tb_path) ==
PATH_OFFSET_PBUFFER(p_s_tb->tb_path, i)) { PATH_OFFSET_PBUFFER(tb->tb_path, i))
tb_buffer_sanity_check(p_s_tb->tb_sb, tb_buffer_sanity_check(tb->tb_sb,
PATH_OFFSET_PBUFFER PATH_OFFSET_PBUFFER
(p_s_tb->tb_path, (tb->tb_path,
i), "S", i), "S",
p_s_tb->tb_path-> tb->tb_path->
path_length - i); path_length - i);
}
#endif #endif
if (!clear_all_dirty_bits(p_s_tb->tb_sb, if (!clear_all_dirty_bits(tb->tb_sb,
PATH_OFFSET_PBUFFER PATH_OFFSET_PBUFFER
(p_s_tb->tb_path, (tb->tb_path,
i))) { i))) {
locked = locked =
PATH_OFFSET_PBUFFER(p_s_tb->tb_path, PATH_OFFSET_PBUFFER(tb->tb_path,
i); i);
} }
} }
} }
for (i = 0; !locked && i < MAX_HEIGHT && p_s_tb->insert_size[i]; for (i = 0; !locked && i < MAX_HEIGHT && tb->insert_size[i];
i++) { i++) {
if (p_s_tb->lnum[i]) { if (tb->lnum[i]) {
if (p_s_tb->L[i]) { if (tb->L[i]) {
tb_buffer_sanity_check(p_s_tb->tb_sb, tb_buffer_sanity_check(tb->tb_sb,
p_s_tb->L[i], tb->L[i],
"L", i); "L", i);
if (!clear_all_dirty_bits if (!clear_all_dirty_bits
(p_s_tb->tb_sb, p_s_tb->L[i])) (tb->tb_sb, tb->L[i]))
locked = p_s_tb->L[i]; locked = tb->L[i];
} }
if (!locked && p_s_tb->FL[i]) { if (!locked && tb->FL[i]) {
tb_buffer_sanity_check(p_s_tb->tb_sb, tb_buffer_sanity_check(tb->tb_sb,
p_s_tb->FL[i], tb->FL[i],
"FL", i); "FL", i);
if (!clear_all_dirty_bits if (!clear_all_dirty_bits
(p_s_tb->tb_sb, p_s_tb->FL[i])) (tb->tb_sb, tb->FL[i]))
locked = p_s_tb->FL[i]; locked = tb->FL[i];
} }
if (!locked && p_s_tb->CFL[i]) { if (!locked && tb->CFL[i]) {
tb_buffer_sanity_check(p_s_tb->tb_sb, tb_buffer_sanity_check(tb->tb_sb,
p_s_tb->CFL[i], tb->CFL[i],
"CFL", i); "CFL", i);
if (!clear_all_dirty_bits if (!clear_all_dirty_bits
(p_s_tb->tb_sb, p_s_tb->CFL[i])) (tb->tb_sb, tb->CFL[i]))
locked = p_s_tb->CFL[i]; locked = tb->CFL[i];
} }
} }
if (!locked && (p_s_tb->rnum[i])) { if (!locked && (tb->rnum[i])) {
if (p_s_tb->R[i]) { if (tb->R[i]) {
tb_buffer_sanity_check(p_s_tb->tb_sb, tb_buffer_sanity_check(tb->tb_sb,
p_s_tb->R[i], tb->R[i],
"R", i); "R", i);
if (!clear_all_dirty_bits if (!clear_all_dirty_bits
(p_s_tb->tb_sb, p_s_tb->R[i])) (tb->tb_sb, tb->R[i]))
locked = p_s_tb->R[i]; locked = tb->R[i];
} }
if (!locked && p_s_tb->FR[i]) { if (!locked && tb->FR[i]) {
tb_buffer_sanity_check(p_s_tb->tb_sb, tb_buffer_sanity_check(tb->tb_sb,
p_s_tb->FR[i], tb->FR[i],
"FR", i); "FR", i);
if (!clear_all_dirty_bits if (!clear_all_dirty_bits
(p_s_tb->tb_sb, p_s_tb->FR[i])) (tb->tb_sb, tb->FR[i]))
locked = p_s_tb->FR[i]; locked = tb->FR[i];
} }
if (!locked && p_s_tb->CFR[i]) { if (!locked && tb->CFR[i]) {
tb_buffer_sanity_check(p_s_tb->tb_sb, tb_buffer_sanity_check(tb->tb_sb,
p_s_tb->CFR[i], tb->CFR[i],
"CFR", i); "CFR", i);
if (!clear_all_dirty_bits if (!clear_all_dirty_bits
(p_s_tb->tb_sb, p_s_tb->CFR[i])) (tb->tb_sb, tb->CFR[i]))
locked = p_s_tb->CFR[i]; locked = tb->CFR[i];
} }
} }
} }
@ -2252,10 +2257,10 @@ static int wait_tb_buffers_until_unlocked(struct tree_balance *p_s_tb)
** --clm ** --clm
*/ */
for (i = 0; !locked && i < MAX_FEB_SIZE; i++) { for (i = 0; !locked && i < MAX_FEB_SIZE; i++) {
if (p_s_tb->FEB[i]) { if (tb->FEB[i]) {
if (!clear_all_dirty_bits if (!clear_all_dirty_bits
(p_s_tb->tb_sb, p_s_tb->FEB[i])) (tb->tb_sb, tb->FEB[i]))
locked = p_s_tb->FEB[i]; locked = tb->FEB[i];
} }
} }
@ -2263,21 +2268,20 @@ static int wait_tb_buffers_until_unlocked(struct tree_balance *p_s_tb)
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
repeat_counter++; repeat_counter++;
if ((repeat_counter % 10000) == 0) { if ((repeat_counter % 10000) == 0) {
reiserfs_warning(p_s_tb->tb_sb, "reiserfs-8200", reiserfs_warning(tb->tb_sb, "reiserfs-8200",
"too many iterations waiting " "too many iterations waiting "
"for buffer to unlock " "for buffer to unlock "
"(%b)", locked); "(%b)", locked);
/* Don't loop forever. Try to recover from possible error. */ /* Don't loop forever. Try to recover from possible error. */
return (FILESYSTEM_CHANGED_TB(p_s_tb)) ? return (FILESYSTEM_CHANGED_TB(tb)) ?
REPEAT_SEARCH : CARRY_ON; REPEAT_SEARCH : CARRY_ON;
} }
#endif #endif
__wait_on_buffer(locked); __wait_on_buffer(locked);
if (FILESYSTEM_CHANGED_TB(p_s_tb)) { if (FILESYSTEM_CHANGED_TB(tb))
return REPEAT_SEARCH; return REPEAT_SEARCH;
}
} }
} while (locked); } while (locked);
@ -2307,138 +2311,136 @@ static int wait_tb_buffers_until_unlocked(struct tree_balance *p_s_tb)
* tb tree_balance structure; * tb tree_balance structure;
* inum item number in S[h]; * inum item number in S[h];
* pos_in_item - comment this if you can * pos_in_item - comment this if you can
* ins_ih & ins_sd are used when inserting * ins_ih item head of item being inserted
* data inserted item or data to be pasted
* Returns: 1 - schedule occurred while the function worked; * Returns: 1 - schedule occurred while the function worked;
* 0 - schedule didn't occur while the function worked; * 0 - schedule didn't occur while the function worked;
* -1 - if no_disk_space * -1 - if no_disk_space
*/ */
int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb, struct item_head *p_s_ins_ih, // item head of item being inserted int fix_nodes(int n_op_mode, struct tree_balance *tb,
const void *data // inserted item or data to be pasted struct item_head *p_s_ins_ih, const void *data)
)
{ {
int n_ret_value, n_h, n_item_num = PATH_LAST_POSITION(p_s_tb->tb_path); int n_ret_value, n_h, n_item_num = PATH_LAST_POSITION(tb->tb_path);
int n_pos_in_item; int n_pos_in_item;
/* we set wait_tb_buffers_run when we have to restore any dirty bits cleared /* we set wait_tb_buffers_run when we have to restore any dirty bits cleared
** during wait_tb_buffers_run ** during wait_tb_buffers_run
*/ */
int wait_tb_buffers_run = 0; int wait_tb_buffers_run = 0;
struct buffer_head *p_s_tbS0 = PATH_PLAST_BUFFER(p_s_tb->tb_path); struct buffer_head *tbS0 = PATH_PLAST_BUFFER(tb->tb_path);
++REISERFS_SB(p_s_tb->tb_sb)->s_fix_nodes; ++REISERFS_SB(tb->tb_sb)->s_fix_nodes;
n_pos_in_item = p_s_tb->tb_path->pos_in_item; n_pos_in_item = tb->tb_path->pos_in_item;
p_s_tb->fs_gen = get_generation(p_s_tb->tb_sb); tb->fs_gen = get_generation(tb->tb_sb);
/* we prepare and log the super here so it will already be in the /* we prepare and log the super here so it will already be in the
** transaction when do_balance needs to change it. ** transaction when do_balance needs to change it.
** This way do_balance won't have to schedule when trying to prepare ** This way do_balance won't have to schedule when trying to prepare
** the super for logging ** the super for logging
*/ */
reiserfs_prepare_for_journal(p_s_tb->tb_sb, reiserfs_prepare_for_journal(tb->tb_sb,
SB_BUFFER_WITH_SB(p_s_tb->tb_sb), 1); SB_BUFFER_WITH_SB(tb->tb_sb), 1);
journal_mark_dirty(p_s_tb->transaction_handle, p_s_tb->tb_sb, journal_mark_dirty(tb->transaction_handle, tb->tb_sb,
SB_BUFFER_WITH_SB(p_s_tb->tb_sb)); SB_BUFFER_WITH_SB(tb->tb_sb));
if (FILESYSTEM_CHANGED_TB(p_s_tb)) if (FILESYSTEM_CHANGED_TB(tb))
return REPEAT_SEARCH; return REPEAT_SEARCH;
/* if it possible in indirect_to_direct conversion */ /* if it possible in indirect_to_direct conversion */
if (buffer_locked(p_s_tbS0)) { if (buffer_locked(tbS0)) {
__wait_on_buffer(p_s_tbS0); __wait_on_buffer(tbS0);
if (FILESYSTEM_CHANGED_TB(p_s_tb)) if (FILESYSTEM_CHANGED_TB(tb))
return REPEAT_SEARCH; return REPEAT_SEARCH;
} }
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
if (cur_tb) { if (cur_tb) {
print_cur_tb("fix_nodes"); print_cur_tb("fix_nodes");
reiserfs_panic(p_s_tb->tb_sb, "PAP-8305", reiserfs_panic(tb->tb_sb, "PAP-8305",
"there is pending do_balance"); "there is pending do_balance");
} }
if (!buffer_uptodate(p_s_tbS0) || !B_IS_IN_TREE(p_s_tbS0)) { if (!buffer_uptodate(tbS0) || !B_IS_IN_TREE(tbS0))
reiserfs_panic(p_s_tb->tb_sb, "PAP-8320", "S[0] (%b %z) is " reiserfs_panic(tb->tb_sb, "PAP-8320", "S[0] (%b %z) is "
"not uptodate at the beginning of fix_nodes " "not uptodate at the beginning of fix_nodes "
"or not in tree (mode %c)", "or not in tree (mode %c)",
p_s_tbS0, p_s_tbS0, n_op_mode); tbS0, tbS0, n_op_mode);
}
/* Check parameters. */ /* Check parameters. */
switch (n_op_mode) { switch (n_op_mode) {
case M_INSERT: case M_INSERT:
if (n_item_num <= 0 || n_item_num > B_NR_ITEMS(p_s_tbS0)) if (n_item_num <= 0 || n_item_num > B_NR_ITEMS(tbS0))
reiserfs_panic(p_s_tb->tb_sb, "PAP-8330", "Incorrect " reiserfs_panic(tb->tb_sb, "PAP-8330", "Incorrect "
"item number %d (in S0 - %d) in case " "item number %d (in S0 - %d) in case "
"of insert", n_item_num, "of insert", n_item_num,
B_NR_ITEMS(p_s_tbS0)); B_NR_ITEMS(tbS0));
break; break;
case M_PASTE: case M_PASTE:
case M_DELETE: case M_DELETE:
case M_CUT: case M_CUT:
if (n_item_num < 0 || n_item_num >= B_NR_ITEMS(p_s_tbS0)) { if (n_item_num < 0 || n_item_num >= B_NR_ITEMS(tbS0)) {
print_block(p_s_tbS0, 0, -1, -1); print_block(tbS0, 0, -1, -1);
reiserfs_panic(p_s_tb->tb_sb, "PAP-8335", "Incorrect " reiserfs_panic(tb->tb_sb, "PAP-8335", "Incorrect "
"item number(%d); mode = %c " "item number(%d); mode = %c "
"insert_size = %d", "insert_size = %d",
n_item_num, n_op_mode, n_item_num, n_op_mode,
p_s_tb->insert_size[0]); tb->insert_size[0]);
} }
break; break;
default: default:
reiserfs_panic(p_s_tb->tb_sb, "PAP-8340", "Incorrect mode " reiserfs_panic(tb->tb_sb, "PAP-8340", "Incorrect mode "
"of operation"); "of operation");
} }
#endif #endif
if (get_mem_for_virtual_node(p_s_tb) == REPEAT_SEARCH) if (get_mem_for_virtual_node(tb) == REPEAT_SEARCH)
// FIXME: maybe -ENOMEM when tb->vn_buf == 0? Now just repeat // FIXME: maybe -ENOMEM when tb->vn_buf == 0? Now just repeat
return REPEAT_SEARCH; return REPEAT_SEARCH;
/* Starting from the leaf level; for all levels n_h of the tree. */ /* Starting from the leaf level; for all levels n_h of the tree. */
for (n_h = 0; n_h < MAX_HEIGHT && p_s_tb->insert_size[n_h]; n_h++) { for (n_h = 0; n_h < MAX_HEIGHT && tb->insert_size[n_h]; n_h++) {
if ((n_ret_value = get_direct_parent(p_s_tb, n_h)) != CARRY_ON) { n_ret_value = get_direct_parent(tb, n_h);
if (n_ret_value != CARRY_ON)
goto repeat; goto repeat;
}
if ((n_ret_value = n_ret_value = check_balance(n_op_mode, tb, n_h, n_item_num,
check_balance(n_op_mode, p_s_tb, n_h, n_item_num, n_pos_in_item, p_s_ins_ih, data);
n_pos_in_item, p_s_ins_ih, if (n_ret_value != CARRY_ON) {
data)) != CARRY_ON) {
if (n_ret_value == NO_BALANCING_NEEDED) { if (n_ret_value == NO_BALANCING_NEEDED) {
/* No balancing for higher levels needed. */ /* No balancing for higher levels needed. */
if ((n_ret_value = n_ret_value = get_neighbors(tb, n_h);
get_neighbors(p_s_tb, n_h)) != CARRY_ON) { if (n_ret_value != CARRY_ON)
goto repeat; goto repeat;
}
if (n_h != MAX_HEIGHT - 1) if (n_h != MAX_HEIGHT - 1)
p_s_tb->insert_size[n_h + 1] = 0; tb->insert_size[n_h + 1] = 0;
/* ok, analysis and resource gathering are complete */ /* ok, analysis and resource gathering are complete */
break; break;
} }
goto repeat; goto repeat;
} }
if ((n_ret_value = get_neighbors(p_s_tb, n_h)) != CARRY_ON) { n_ret_value = get_neighbors(tb, n_h);
if (n_ret_value != CARRY_ON)
goto repeat; goto repeat;
}
if ((n_ret_value = get_empty_nodes(p_s_tb, n_h)) != CARRY_ON) { /* No disk space, or schedule occurred and analysis may be
goto repeat; /* No disk space, or schedule occurred and * invalid and needs to be redone. */
analysis may be invalid and needs to be redone. */ n_ret_value = get_empty_nodes(tb, n_h);
} if (n_ret_value != CARRY_ON)
goto repeat;
if (!PATH_H_PBUFFER(p_s_tb->tb_path, n_h)) { if (!PATH_H_PBUFFER(tb->tb_path, n_h)) {
/* We have a positive insert size but no nodes exist on this /* We have a positive insert size but no nodes exist on this
level, this means that we are creating a new root. */ level, this means that we are creating a new root. */
RFALSE(p_s_tb->blknum[n_h] != 1, RFALSE(tb->blknum[n_h] != 1,
"PAP-8350: creating new empty root"); "PAP-8350: creating new empty root");
if (n_h < MAX_HEIGHT - 1) if (n_h < MAX_HEIGHT - 1)
p_s_tb->insert_size[n_h + 1] = 0; tb->insert_size[n_h + 1] = 0;
} else if (!PATH_H_PBUFFER(p_s_tb->tb_path, n_h + 1)) { } else if (!PATH_H_PBUFFER(tb->tb_path, n_h + 1)) {
if (p_s_tb->blknum[n_h] > 1) { if (tb->blknum[n_h] > 1) {
/* The tree needs to be grown, so this node S[n_h] /* The tree needs to be grown, so this node S[n_h]
which is the root node is split into two nodes, which is the root node is split into two nodes,
and a new node (S[n_h+1]) will be created to and a new node (S[n_h+1]) will be created to
@ -2447,19 +2449,20 @@ int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb, struct item_head *p_s_
RFALSE(n_h == MAX_HEIGHT - 1, RFALSE(n_h == MAX_HEIGHT - 1,
"PAP-8355: attempt to create too high of a tree"); "PAP-8355: attempt to create too high of a tree");
p_s_tb->insert_size[n_h + 1] = tb->insert_size[n_h + 1] =
(DC_SIZE + (DC_SIZE +
KEY_SIZE) * (p_s_tb->blknum[n_h] - 1) + KEY_SIZE) * (tb->blknum[n_h] - 1) +
DC_SIZE; DC_SIZE;
} else if (n_h < MAX_HEIGHT - 1) } else if (n_h < MAX_HEIGHT - 1)
p_s_tb->insert_size[n_h + 1] = 0; tb->insert_size[n_h + 1] = 0;
} else } else
p_s_tb->insert_size[n_h + 1] = tb->insert_size[n_h + 1] =
(DC_SIZE + KEY_SIZE) * (p_s_tb->blknum[n_h] - 1); (DC_SIZE + KEY_SIZE) * (tb->blknum[n_h] - 1);
} }
if ((n_ret_value = wait_tb_buffers_until_unlocked(p_s_tb)) == CARRY_ON) { n_ret_value = wait_tb_buffers_until_unlocked(tb);
if (FILESYSTEM_CHANGED_TB(p_s_tb)) { if (n_ret_value == CARRY_ON) {
if (FILESYSTEM_CHANGED_TB(tb)) {
wait_tb_buffers_run = 1; wait_tb_buffers_run = 1;
n_ret_value = REPEAT_SEARCH; n_ret_value = REPEAT_SEARCH;
goto repeat; goto repeat;
@ -2482,50 +2485,49 @@ int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb, struct item_head *p_s_
/* Release path buffers. */ /* Release path buffers. */
if (wait_tb_buffers_run) { if (wait_tb_buffers_run) {
pathrelse_and_restore(p_s_tb->tb_sb, p_s_tb->tb_path); pathrelse_and_restore(tb->tb_sb, tb->tb_path);
} else { } else {
pathrelse(p_s_tb->tb_path); pathrelse(tb->tb_path);
} }
/* brelse all resources collected for balancing */ /* brelse all resources collected for balancing */
for (i = 0; i < MAX_HEIGHT; i++) { for (i = 0; i < MAX_HEIGHT; i++) {
if (wait_tb_buffers_run) { if (wait_tb_buffers_run) {
reiserfs_restore_prepared_buffer(p_s_tb->tb_sb, reiserfs_restore_prepared_buffer(tb->tb_sb,
p_s_tb->L[i]); tb->L[i]);
reiserfs_restore_prepared_buffer(p_s_tb->tb_sb, reiserfs_restore_prepared_buffer(tb->tb_sb,
p_s_tb->R[i]); tb->R[i]);
reiserfs_restore_prepared_buffer(p_s_tb->tb_sb, reiserfs_restore_prepared_buffer(tb->tb_sb,
p_s_tb->FL[i]); tb->FL[i]);
reiserfs_restore_prepared_buffer(p_s_tb->tb_sb, reiserfs_restore_prepared_buffer(tb->tb_sb,
p_s_tb->FR[i]); tb->FR[i]);
reiserfs_restore_prepared_buffer(p_s_tb->tb_sb, reiserfs_restore_prepared_buffer(tb->tb_sb,
p_s_tb-> tb->
CFL[i]); CFL[i]);
reiserfs_restore_prepared_buffer(p_s_tb->tb_sb, reiserfs_restore_prepared_buffer(tb->tb_sb,
p_s_tb-> tb->
CFR[i]); CFR[i]);
} }
brelse(p_s_tb->L[i]); brelse(tb->L[i]);
brelse(p_s_tb->R[i]); brelse(tb->R[i]);
brelse(p_s_tb->FL[i]); brelse(tb->FL[i]);
brelse(p_s_tb->FR[i]); brelse(tb->FR[i]);
brelse(p_s_tb->CFL[i]); brelse(tb->CFL[i]);
brelse(p_s_tb->CFR[i]); brelse(tb->CFR[i]);
p_s_tb->L[i] = NULL; tb->L[i] = NULL;
p_s_tb->R[i] = NULL; tb->R[i] = NULL;
p_s_tb->FL[i] = NULL; tb->FL[i] = NULL;
p_s_tb->FR[i] = NULL; tb->FR[i] = NULL;
p_s_tb->CFL[i] = NULL; tb->CFL[i] = NULL;
p_s_tb->CFR[i] = NULL; tb->CFR[i] = NULL;
} }
if (wait_tb_buffers_run) { if (wait_tb_buffers_run) {
for (i = 0; i < MAX_FEB_SIZE; i++) { for (i = 0; i < MAX_FEB_SIZE; i++) {
if (p_s_tb->FEB[i]) { if (tb->FEB[i])
reiserfs_restore_prepared_buffer reiserfs_restore_prepared_buffer
(p_s_tb->tb_sb, p_s_tb->FEB[i]); (tb->tb_sb, tb->FEB[i]);
}
} }
} }
return n_ret_value; return n_ret_value;
@ -2533,7 +2535,7 @@ int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb, struct item_head *p_s_
} }
/* Anatoly will probably forgive me renaming p_s_tb to tb. I just /* Anatoly will probably forgive me renaming tb to tb. I just
wanted to make lines shorter */ wanted to make lines shorter */
void unfix_nodes(struct tree_balance *tb) void unfix_nodes(struct tree_balance *tb)
{ {

21
fs/reiserfs/stree.c
View File

@ -1063,17 +1063,17 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
} }
/* Calculate number of bytes which will be deleted or cut during balance */ /* Calculate number of bytes which will be deleted or cut during balance */
static int calc_deleted_bytes_number(struct tree_balance *p_s_tb, char c_mode) static int calc_deleted_bytes_number(struct tree_balance *tb, char c_mode)
{ {
int n_del_size; int n_del_size;
struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_tb->tb_path); struct item_head *p_le_ih = PATH_PITEM_HEAD(tb->tb_path);
if (is_statdata_le_ih(p_le_ih)) if (is_statdata_le_ih(p_le_ih))
return 0; return 0;
n_del_size = n_del_size =
(c_mode == (c_mode ==
M_DELETE) ? ih_item_len(p_le_ih) : -p_s_tb->insert_size[0]; M_DELETE) ? ih_item_len(p_le_ih) : -tb->insert_size[0];
if (is_direntry_le_ih(p_le_ih)) { if (is_direntry_le_ih(p_le_ih)) {
// return EMPTY_DIR_SIZE; /* We delete emty directoris only. */ // return EMPTY_DIR_SIZE; /* We delete emty directoris only. */
// we can't use EMPTY_DIR_SIZE, as old format dirs have a different // we can't use EMPTY_DIR_SIZE, as old format dirs have a different
@ -1083,25 +1083,26 @@ static int calc_deleted_bytes_number(struct tree_balance *p_s_tb, char c_mode)
} }
if (is_indirect_le_ih(p_le_ih)) if (is_indirect_le_ih(p_le_ih))
n_del_size = (n_del_size / UNFM_P_SIZE) * (PATH_PLAST_BUFFER(p_s_tb->tb_path)->b_size); // - get_ih_free_space (p_le_ih); n_del_size = (n_del_size / UNFM_P_SIZE) *
(PATH_PLAST_BUFFER(tb->tb_path)->b_size);
return n_del_size; return n_del_size;
} }
static void init_tb_struct(struct reiserfs_transaction_handle *th, static void init_tb_struct(struct reiserfs_transaction_handle *th,
struct tree_balance *p_s_tb, struct tree_balance *tb,
struct super_block *sb, struct super_block *sb,
struct treepath *p_s_path, int n_size) struct treepath *p_s_path, int n_size)
{ {
BUG_ON(!th->t_trans_id); BUG_ON(!th->t_trans_id);
memset(p_s_tb, '\0', sizeof(struct tree_balance)); memset(tb, '\0', sizeof(struct tree_balance));
p_s_tb->transaction_handle = th; tb->transaction_handle = th;
p_s_tb->tb_sb = sb; tb->tb_sb = sb;
p_s_tb->tb_path = p_s_path; tb->tb_path = p_s_path;
PATH_OFFSET_PBUFFER(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL; PATH_OFFSET_PBUFFER(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
PATH_OFFSET_POSITION(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0; PATH_OFFSET_POSITION(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
p_s_tb->insert_size[0] = n_size; tb->insert_size[0] = n_size;
} }
void padd_item(char *item, int total_length, int length) void padd_item(char *item, int total_length, int length)

2
include/linux/reiserfs_fs.h
View File

@ -2004,7 +2004,7 @@ extern const struct address_space_operations reiserfs_address_space_operations;
/* fix_nodes.c */ /* fix_nodes.c */
int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb, int fix_nodes(int n_op_mode, struct tree_balance *tb,
struct item_head *p_s_ins_ih, const void *); struct item_head *p_s_ins_ih, const void *);
void unfix_nodes(struct tree_balance *); void unfix_nodes(struct tree_balance *);