+++ /dev/null
-From: Jeff Mahoney <jeffm@suse.com>
-Subject: reiserfs: rename [cn]_* variables
-
- This patch renames n_, c_, etc variables to something more sane. This is
- the sixth in a series of patches to rip out some of the awful variable
- naming in reiserfs.
-
-Signed-off-by: Jeff Mahoney <jeffm@suse.com>
-
----
-
- fs/reiserfs/file.c | 6
- fs/reiserfs/fix_node.c | 474 +++++++++++++++++++++---------------------
- fs/reiserfs/stree.c | 370 ++++++++++++++++----------------
- fs/reiserfs/tail_conversion.c | 30 +-
- 4 files changed, 438 insertions(+), 442 deletions(-)
-
---- a/fs/reiserfs/file.c
-+++ b/fs/reiserfs/file.c
-@@ -138,11 +138,11 @@ static int reiserfs_sync_file(struct fil
- struct dentry *dentry, int datasync)
- {
- struct inode *inode = dentry->d_inode;
-- int n_err;
-+ int err;
- int barrier_done;
-
- BUG_ON(!S_ISREG(inode->i_mode));
-- n_err = sync_mapping_buffers(inode->i_mapping);
-+ err = sync_mapping_buffers(inode->i_mapping);
- reiserfs_write_lock(inode->i_sb);
- barrier_done = reiserfs_commit_for_inode(inode);
- reiserfs_write_unlock(inode->i_sb);
-@@ -150,7 +150,7 @@ static int reiserfs_sync_file(struct fil
- blkdev_issue_flush(inode->i_sb->s_bdev, NULL);
- if (barrier_done < 0)
- return barrier_done;
-- return (n_err < 0) ? -EIO : 0;
-+ return (err < 0) ? -EIO : 0;
- }
-
- /* taken fs/buffer.c:__block_commit_write */
---- a/fs/reiserfs/fix_node.c
-+++ b/fs/reiserfs/fix_node.c
-@@ -751,24 +751,24 @@ else \
-
- static void free_buffers_in_tb(struct tree_balance *tb)
- {
-- int n_counter;
-+ int i;
-
- pathrelse(tb->tb_path);
-
-- for (n_counter = 0; n_counter < MAX_HEIGHT; n_counter++) {
-- brelse(tb->L[n_counter]);
-- brelse(tb->R[n_counter]);
-- brelse(tb->FL[n_counter]);
-- brelse(tb->FR[n_counter]);
-- brelse(tb->CFL[n_counter]);
-- brelse(tb->CFR[n_counter]);
--
-- tb->L[n_counter] = NULL;
-- tb->R[n_counter] = NULL;
-- tb->FL[n_counter] = NULL;
-- tb->FR[n_counter] = NULL;
-- tb->CFL[n_counter] = NULL;
-- tb->CFR[n_counter] = NULL;
-+ for (i = 0; i < MAX_HEIGHT; i++) {
-+ brelse(tb->L[i]);
-+ brelse(tb->R[i]);
-+ brelse(tb->FL[i]);
-+ brelse(tb->FR[i]);
-+ brelse(tb->CFL[i]);
-+ brelse(tb->CFR[i]);
-+
-+ tb->L[i] = NULL;
-+ tb->R[i] = NULL;
-+ tb->FL[i] = NULL;
-+ tb->FR[i] = NULL;
-+ tb->CFL[i] = NULL;
-+ tb->CFR[i] = NULL;
- }
- }
-
-@@ -778,13 +778,13 @@ static void free_buffers_in_tb(struct tr
- * NO_DISK_SPACE - no disk space.
- */
- /* The function is NOT SCHEDULE-SAFE! */
--static int get_empty_nodes(struct tree_balance *tb, int n_h)
-+static int get_empty_nodes(struct tree_balance *tb, int h)
- {
- struct buffer_head *new_bh,
-- *Sh = PATH_H_PBUFFER(tb->tb_path, n_h);
-- b_blocknr_t *blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, };
-- int n_counter, n_number_of_freeblk, n_amount_needed, /* number of needed empty blocks */
-- n_retval = CARRY_ON;
-+ *Sh = PATH_H_PBUFFER(tb->tb_path, h);
-+ b_blocknr_t *blocknr, blocknrs[MAX_AMOUNT_NEEDED] = { 0, };
-+ int counter, number_of_freeblk, amount_needed, /* number of needed empty blocks */
-+ retval = CARRY_ON;
- struct super_block *sb = tb->tb_sb;
-
- /* number_of_freeblk is the number of empty blocks which have been
-@@ -793,7 +793,7 @@ static int get_empty_nodes(struct tree_b
- number_of_freeblk = tb->cur_blknum can be non-zero if a schedule occurs
- after empty blocks are acquired, and the balancing analysis is
- then restarted, amount_needed is the number needed by this level
-- (n_h) of the balancing analysis.
-+ (h) of the balancing analysis.
-
- Note that for systems with many processes writing, it would be
- more layout optimal to calculate the total number needed by all
-@@ -801,31 +801,31 @@ static int get_empty_nodes(struct tree_b
-
- /* Initiate number_of_freeblk to the amount acquired prior to the restart of
- the analysis or 0 if not restarted, then subtract the amount needed
-- by all of the levels of the tree below n_h. */
-- /* blknum includes S[n_h], so we subtract 1 in this calculation */
-- for (n_counter = 0, n_number_of_freeblk = tb->cur_blknum;
-- n_counter < n_h; n_counter++)
-- n_number_of_freeblk -=
-- (tb->blknum[n_counter]) ? (tb->blknum[n_counter] -
-+ by all of the levels of the tree below h. */
-+ /* blknum includes S[h], so we subtract 1 in this calculation */
-+ for (counter = 0, number_of_freeblk = tb->cur_blknum;
-+ counter < h; counter++)
-+ number_of_freeblk -=
-+ (tb->blknum[counter]) ? (tb->blknum[counter] -
- 1) : 0;
-
- /* Allocate missing empty blocks. */
- /* if Sh == 0 then we are getting a new root */
-- n_amount_needed = (Sh) ? (tb->blknum[n_h] - 1) : 1;
-+ amount_needed = (Sh) ? (tb->blknum[h] - 1) : 1;
- /* Amount_needed = the amount that we need more than the amount that we have. */
-- if (n_amount_needed > n_number_of_freeblk)
-- n_amount_needed -= n_number_of_freeblk;
-+ if (amount_needed > number_of_freeblk)
-+ amount_needed -= number_of_freeblk;
- else /* If we have enough already then there is nothing to do. */
- return CARRY_ON;
-
- /* No need to check quota - is not allocated for blocks used for formatted nodes */
-- if (reiserfs_new_form_blocknrs(tb, a_n_blocknrs,
-- n_amount_needed) == NO_DISK_SPACE)
-+ if (reiserfs_new_form_blocknrs(tb, blocknrs,
-+ amount_needed) == NO_DISK_SPACE)
- return NO_DISK_SPACE;
-
- /* for each blocknumber we just got, get a buffer and stick it on FEB */
-- for (blocknr = a_n_blocknrs, n_counter = 0;
-- n_counter < n_amount_needed; blocknr++, n_counter++) {
-+ for (blocknr = blocknrs, counter = 0;
-+ counter < amount_needed; blocknr++, counter++) {
-
- RFALSE(!*blocknr,
- "PAP-8135: reiserfs_new_blocknrs failed when got new blocks");
-@@ -845,10 +845,10 @@ static int get_empty_nodes(struct tree_b
- tb->FEB[tb->cur_blknum++] = new_bh;
- }
-
-- if (n_retval == CARRY_ON && FILESYSTEM_CHANGED_TB(tb))
-- n_retval = REPEAT_SEARCH;
-+ if (retval == CARRY_ON && FILESYSTEM_CHANGED_TB(tb))
-+ retval = REPEAT_SEARCH;
-
-- return n_retval;
-+ return retval;
- }
-
- /* Get free space of the left neighbor, which is stored in the parent
-@@ -896,36 +896,36 @@ static int get_rfree(struct tree_balance
- }
-
- /* Check whether left neighbor is in memory. */
--static int is_left_neighbor_in_cache(struct tree_balance *tb, int n_h)
-+static int is_left_neighbor_in_cache(struct tree_balance *tb, int h)
- {
- struct buffer_head *father, *left;
- struct super_block *sb = tb->tb_sb;
-- b_blocknr_t n_left_neighbor_blocknr;
-- int n_left_neighbor_position;
-+ b_blocknr_t left_neighbor_blocknr;
-+ int left_neighbor_position;
-
- /* Father of the left neighbor does not exist. */
-- if (!tb->FL[n_h])
-+ if (!tb->FL[h])
- return 0;
-
- /* Calculate father of the node to be balanced. */
-- father = PATH_H_PBUFFER(tb->tb_path, n_h + 1);
-+ father = PATH_H_PBUFFER(tb->tb_path, h + 1);
-
- RFALSE(!father ||
- !B_IS_IN_TREE(father) ||
-- !B_IS_IN_TREE(tb->FL[n_h]) ||
-+ !B_IS_IN_TREE(tb->FL[h]) ||
- !buffer_uptodate(father) ||
-- !buffer_uptodate(tb->FL[n_h]),
-+ !buffer_uptodate(tb->FL[h]),
- "vs-8165: F[h] (%b) or FL[h] (%b) is invalid",
-- father, tb->FL[n_h]);
-+ father, tb->FL[h]);
-
- /* Get position of the pointer to the left neighbor into the left father. */
-- n_left_neighbor_position = (father == tb->FL[n_h]) ?
-- tb->lkey[n_h] : B_NR_ITEMS(tb->FL[n_h]);
-+ left_neighbor_position = (father == tb->FL[h]) ?
-+ tb->lkey[h] : B_NR_ITEMS(tb->FL[h]);
- /* Get left neighbor block number. */
-- n_left_neighbor_blocknr =
-- B_N_CHILD_NUM(tb->FL[n_h], n_left_neighbor_position);
-+ left_neighbor_blocknr =
-+ B_N_CHILD_NUM(tb->FL[h], left_neighbor_position);
- /* 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, left_neighbor_blocknr))) {
-
- RFALSE(buffer_uptodate(left) && !B_IS_IN_TREE(left),
- "vs-8170: left neighbor (%b %z) is not in the tree",
-@@ -955,7 +955,7 @@ static void decrement_key(struct cpu_key
- * CARRY_ON - schedule didn't occur while the function worked;
- */
- static int get_far_parent(struct tree_balance *tb,
-- int n_h,
-+ int h,
- struct buffer_head **pfather,
- struct buffer_head **pcom_father, char c_lr_par)
- {
-@@ -963,38 +963,38 @@ static int get_far_parent(struct tree_ba
- INITIALIZE_PATH(s_path_to_neighbor_father);
- struct treepath *path = tb->tb_path;
- struct cpu_key s_lr_father_key;
-- int n_counter,
-- n_position = INT_MAX,
-- n_first_last_position = 0,
-- n_path_offset = PATH_H_PATH_OFFSET(path, n_h);
-+ int counter,
-+ position = INT_MAX,
-+ first_last_position = 0,
-+ path_offset = PATH_H_PATH_OFFSET(path, h);
-
-- /* Starting from F[n_h] go upwards in the tree, and look for the common
-- ancestor of F[n_h], and its neighbor l/r, that should be obtained. */
-+ /* Starting from F[h] go upwards in the tree, and look for the common
-+ ancestor of F[h], and its neighbor l/r, that should be obtained. */
-
-- n_counter = n_path_offset;
-+ counter = path_offset;
-
-- RFALSE(n_counter < FIRST_PATH_ELEMENT_OFFSET,
-+ RFALSE(counter < FIRST_PATH_ELEMENT_OFFSET,
- "PAP-8180: invalid path length");
-
-- for (; n_counter > FIRST_PATH_ELEMENT_OFFSET; n_counter--) {
-+ for (; counter > FIRST_PATH_ELEMENT_OFFSET; counter--) {
- /* Check whether parent of the current buffer in the path is really parent in the tree. */
- if (!B_IS_IN_TREE
-- (parent = PATH_OFFSET_PBUFFER(path, n_counter - 1)))
-+ (parent = PATH_OFFSET_PBUFFER(path, counter - 1)))
- return REPEAT_SEARCH;
- /* Check whether position in the parent is correct. */
-- if ((n_position =
-+ if ((position =
- PATH_OFFSET_POSITION(path,
-- n_counter - 1)) >
-+ counter - 1)) >
- B_NR_ITEMS(parent))
- return REPEAT_SEARCH;
- /* Check whether parent at the path really points to the child. */
-- if (B_N_CHILD_NUM(parent, n_position) !=
-- PATH_OFFSET_PBUFFER(path, n_counter)->b_blocknr)
-+ if (B_N_CHILD_NUM(parent, position) !=
-+ PATH_OFFSET_PBUFFER(path, counter)->b_blocknr)
- return REPEAT_SEARCH;
- /* Return delimiting key if position in the parent is not equal to first/last one. */
- if (c_lr_par == RIGHT_PARENTS)
-- n_first_last_position = B_NR_ITEMS(parent);
-- if (n_position != n_first_last_position) {
-+ first_last_position = B_NR_ITEMS(parent);
-+ if (position != first_last_position) {
- *pcom_father = parent;
- get_bh(*pcom_father);
- /*(*pcom_father = parent)->b_count++; */
-@@ -1003,7 +1003,7 @@ static int get_far_parent(struct tree_ba
- }
-
- /* if we are in the root of the tree, then there is no common father */
-- if (n_counter == FIRST_PATH_ELEMENT_OFFSET) {
-+ if (counter == FIRST_PATH_ELEMENT_OFFSET) {
- /* Check whether first buffer in the path is the root of the tree. */
- if (PATH_OFFSET_PBUFFER
- (tb->tb_path,
-@@ -1036,18 +1036,18 @@ static int get_far_parent(struct tree_ba
- le_key2cpu_key(&s_lr_father_key,
- B_N_PDELIM_KEY(*pcom_father,
- (c_lr_par ==
-- LEFT_PARENTS) ? (tb->lkey[n_h - 1] =
-- n_position -
-- 1) : (tb->rkey[n_h -
-+ LEFT_PARENTS) ? (tb->lkey[h - 1] =
-+ position -
-+ 1) : (tb->rkey[h -
- 1] =
-- n_position)));
-+ position)));
-
- if (c_lr_par == LEFT_PARENTS)
- decrement_key(&s_lr_father_key);
-
- if (search_by_key
- (tb->tb_sb, &s_lr_father_key, &s_path_to_neighbor_father,
-- n_h + 1) == IO_ERROR)
-+ h + 1) == IO_ERROR)
- // path is released
- return IO_ERROR;
-
-@@ -1059,7 +1059,7 @@ static int get_far_parent(struct tree_ba
-
- *pfather = PATH_PLAST_BUFFER(&s_path_to_neighbor_father);
-
-- RFALSE(B_LEVEL(*pfather) != n_h + 1,
-+ RFALSE(B_LEVEL(*pfather) != h + 1,
- "PAP-8190: (%b %z) level too small", *pfather, *pfather);
- RFALSE(s_path_to_neighbor_father.path_length <
- FIRST_PATH_ELEMENT_OFFSET, "PAP-8192: path length is too small");
-@@ -1069,92 +1069,92 @@ static int get_far_parent(struct tree_ba
- return CARRY_ON;
- }
-
--/* Get parents of neighbors of node in the path(S[n_path_offset]) and common parents of
-- * S[n_path_offset] and L[n_path_offset]/R[n_path_offset]: F[n_path_offset], FL[n_path_offset],
-- * FR[n_path_offset], CFL[n_path_offset], CFR[n_path_offset].
-- * Calculate numbers of left and right delimiting keys position: lkey[n_path_offset], rkey[n_path_offset].
-+/* Get parents of neighbors of node in the path(S[path_offset]) and common parents of
-+ * S[path_offset] and L[path_offset]/R[path_offset]: F[path_offset], FL[path_offset],
-+ * FR[path_offset], CFL[path_offset], CFR[path_offset].
-+ * Calculate numbers of left and right delimiting keys position: lkey[path_offset], rkey[path_offset].
- * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked;
- * CARRY_ON - schedule didn't occur while the function worked;
- */
--static int get_parents(struct tree_balance *tb, int n_h)
-+static int get_parents(struct tree_balance *tb, int h)
- {
- struct treepath *path = tb->tb_path;
-- int n_position,
-- n_ret_value,
-- n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h);
-+ int position,
-+ ret,
-+ path_offset = PATH_H_PATH_OFFSET(tb->tb_path, h);
- struct buffer_head *curf, *curcf;
-
- /* Current node is the root of the tree or will be root of the tree */
-- if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
-+ if (path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
- /* The root can not have parents.
- Release nodes which previously were obtained as parents of the current node neighbors. */
-- brelse(tb->FL[n_h]);
-- brelse(tb->CFL[n_h]);
-- brelse(tb->FR[n_h]);
-- brelse(tb->CFR[n_h]);
-- tb->FL[n_h] = NULL;
-- tb->CFL[n_h] = NULL;
-- tb->FR[n_h] = NULL;
-- tb->CFR[n_h] = NULL;
-+ brelse(tb->FL[h]);
-+ brelse(tb->CFL[h]);
-+ brelse(tb->FR[h]);
-+ brelse(tb->CFR[h]);
-+ tb->FL[h] = NULL;
-+ tb->CFL[h] = NULL;
-+ tb->FR[h] = NULL;
-+ tb->CFR[h] = NULL;
- return CARRY_ON;
- }
-
-- /* Get parent FL[n_path_offset] of L[n_path_offset]. */
-- n_position = PATH_OFFSET_POSITION(path, n_path_offset - 1);
-- if (n_position) {
-+ /* Get parent FL[path_offset] of L[path_offset]. */
-+ position = PATH_OFFSET_POSITION(path, path_offset - 1);
-+ if (position) {
- /* Current node is not the first child of its parent. */
-- curf = PATH_OFFSET_PBUFFER(path, n_path_offset - 1);
-- curcf = PATH_OFFSET_PBUFFER(path, n_path_offset - 1);
-+ curf = PATH_OFFSET_PBUFFER(path, path_offset - 1);
-+ curcf = PATH_OFFSET_PBUFFER(path, path_offset - 1);
- get_bh(curf);
- get_bh(curf);
-- tb->lkey[n_h] = n_position - 1;
-+ tb->lkey[h] = position - 1;
- } else {
-- /* 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
-- 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]. */
-- if ((n_ret_value = get_far_parent(tb, n_h + 1, &curf,
-+ /* Calculate current parent of L[path_offset], which is the left neighbor of the current node.
-+ Calculate current common parent of L[path_offset] and the current node. Note that
-+ CFL[path_offset] not equal FL[path_offset] and CFL[path_offset] not equal F[path_offset].
-+ Calculate lkey[path_offset]. */
-+ if ((ret = get_far_parent(tb, h + 1, &curf,
- &curcf,
- LEFT_PARENTS)) != CARRY_ON)
-- return n_ret_value;
-+ return ret;
- }
-
-- brelse(tb->FL[n_h]);
-- tb->FL[n_h] = curf; /* New initialization of FL[n_h]. */
-- brelse(tb->CFL[n_h]);
-- tb->CFL[n_h] = curcf; /* New initialization of CFL[n_h]. */
-+ brelse(tb->FL[h]);
-+ tb->FL[h] = curf; /* New initialization of FL[h]. */
-+ brelse(tb->CFL[h]);
-+ tb->CFL[h] = curcf; /* New initialization of CFL[h]. */
-
- RFALSE((curf && !B_IS_IN_TREE(curf)) ||
- (curcf && !B_IS_IN_TREE(curcf)),
- "PAP-8195: FL (%b) or CFL (%b) is invalid", curf, curcf);
-
--/* Get parent FR[n_h] of R[n_h]. */
-+/* Get parent FR[h] of R[h]. */
-
--/* Current node is the last child of F[n_h]. FR[n_h] != F[n_h]. */
-- if (n_position == B_NR_ITEMS(PATH_H_PBUFFER(path, n_h + 1))) {
--/* Calculate current parent of R[n_h], which is the right neighbor of F[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]. */
-- if ((n_ret_value =
-- get_far_parent(tb, n_h + 1, &curf, &curcf,
-+/* Current node is the last child of F[h]. FR[h] != F[h]. */
-+ if (position == B_NR_ITEMS(PATH_H_PBUFFER(path, h + 1))) {
-+/* Calculate current parent of R[h], which is the right neighbor of F[h].
-+ Calculate current common parent of R[h] and current node. Note that CFR[h]
-+ not equal FR[path_offset] and CFR[h] not equal F[h]. */
-+ if ((ret =
-+ get_far_parent(tb, h + 1, &curf, &curcf,
- RIGHT_PARENTS)) != CARRY_ON)
-- return n_ret_value;
-+ return ret;
- } else {
--/* Current node is not the last child of its parent F[n_h]. */
-- curf = PATH_OFFSET_PBUFFER(path, n_path_offset - 1);
-- curcf = PATH_OFFSET_PBUFFER(path, n_path_offset - 1);
-+/* Current node is not the last child of its parent F[h]. */
-+ curf = PATH_OFFSET_PBUFFER(path, path_offset - 1);
-+ curcf = PATH_OFFSET_PBUFFER(path, path_offset - 1);
- get_bh(curf);
- get_bh(curf);
-- tb->rkey[n_h] = n_position;
-+ tb->rkey[h] = position;
- }
-
-- brelse(tb->FR[n_h]);
-- /* New initialization of FR[n_path_offset]. */
-- tb->FR[n_h] = curf;
-+ brelse(tb->FR[h]);
-+ /* New initialization of FR[path_offset]. */
-+ tb->FR[h] = curf;
-
-- brelse(tb->CFR[n_h]);
-- /* New initialization of CFR[n_path_offset]. */
-- tb->CFR[n_h] = curcf;
-+ brelse(tb->CFR[h]);
-+ /* New initialization of CFR[path_offset]. */
-+ tb->CFR[h] = curcf;
-
- RFALSE((curf && !B_IS_IN_TREE(curf)) ||
- (curcf && !B_IS_IN_TREE(curcf)),
-@@ -1222,7 +1222,7 @@ static int ip_check_balance(struct tree_
- contains node being balanced. The mnemonic is
- that the attempted change in node space used level
- is levbytes bytes. */
-- n_ret_value;
-+ ret;
-
- int lfree, sfree, rfree /* free space in L, S and R */ ;
-
-@@ -1262,22 +1262,22 @@ static int ip_check_balance(struct tree_
- if (!h)
- reiserfs_panic(tb->tb_sb, "vs-8210",
- "S[0] can not be 0");
-- switch (n_ret_value = get_empty_nodes(tb, h)) {
-+ switch (ret = get_empty_nodes(tb, h)) {
- case CARRY_ON:
- set_parameters(tb, h, 0, 0, 1, NULL, -1, -1);
- return NO_BALANCING_NEEDED; /* no balancing for higher levels needed */
-
- case NO_DISK_SPACE:
- case REPEAT_SEARCH:
-- return n_ret_value;
-+ return ret;
- default:
- reiserfs_panic(tb->tb_sb, "vs-8215", "incorrect "
- "return value of get_empty_nodes");
- }
- }
-
-- if ((n_ret_value = get_parents(tb, h)) != CARRY_ON) /* get parents of S[h] neighbors. */
-- return n_ret_value;
-+ if ((ret = get_parents(tb, h)) != CARRY_ON) /* get parents of S[h] neighbors. */
-+ return ret;
-
- sfree = B_FREE_SPACE(Sh);
-
-@@ -1564,7 +1564,7 @@ static int dc_check_balance_internal(str
- /* Sh is the node whose balance is currently being checked,
- and Fh is its father. */
- struct buffer_head *Sh, *Fh;
-- int maxsize, n_ret_value;
-+ int maxsize, ret;
- int lfree, rfree /* free space in L and R */ ;
-
- Sh = PATH_H_PBUFFER(tb->tb_path, h);
-@@ -1589,8 +1589,8 @@ static int dc_check_balance_internal(str
- return CARRY_ON;
- }
-
-- if ((n_ret_value = get_parents(tb, h)) != CARRY_ON)
-- return n_ret_value;
-+ if ((ret = get_parents(tb, h)) != CARRY_ON)
-+ return ret;
-
- /* get free space of neighbors */
- rfree = get_rfree(tb, h);
-@@ -1747,7 +1747,7 @@ static int dc_check_balance_leaf(struct
- attempted change in node space used level is levbytes bytes. */
- int levbytes;
- /* the maximal item size */
-- int maxsize, n_ret_value;
-+ int maxsize, ret;
- /* S0 is the node whose balance is currently being checked,
- and F0 is its father. */
- struct buffer_head *S0, *F0;
-@@ -1769,8 +1769,8 @@ static int dc_check_balance_leaf(struct
- return NO_BALANCING_NEEDED;
- }
-
-- if ((n_ret_value = get_parents(tb, h)) != CARRY_ON)
-- return n_ret_value;
-+ if ((ret = get_parents(tb, h)) != CARRY_ON)
-+ return ret;
-
- /* get free space of neighbors */
- rfree = get_rfree(tb, h);
-@@ -1889,40 +1889,40 @@ static int check_balance(int mode,
- }
-
- /* Check whether parent at the path is the really parent of the current node.*/
--static int get_direct_parent(struct tree_balance *tb, int n_h)
-+static int get_direct_parent(struct tree_balance *tb, int h)
- {
- struct buffer_head *bh;
- struct treepath *path = tb->tb_path;
-- int n_position,
-- n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h);
-+ int position,
-+ path_offset = PATH_H_PATH_OFFSET(tb->tb_path, h);
-
- /* We are in the root or in the new root. */
-- if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
-+ if (path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
-
-- RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET - 1,
-+ RFALSE(path_offset < FIRST_PATH_ELEMENT_OFFSET - 1,
- "PAP-8260: invalid offset in the path");
-
- if (PATH_OFFSET_PBUFFER(path, FIRST_PATH_ELEMENT_OFFSET)->
- b_blocknr == SB_ROOT_BLOCK(tb->tb_sb)) {
- /* Root is not changed. */
-- PATH_OFFSET_PBUFFER(path, n_path_offset - 1) = NULL;
-- PATH_OFFSET_POSITION(path, n_path_offset - 1) = 0;
-+ PATH_OFFSET_PBUFFER(path, path_offset - 1) = NULL;
-+ PATH_OFFSET_POSITION(path, path_offset - 1) = 0;
- return CARRY_ON;
- }
- return REPEAT_SEARCH; /* Root is changed and we must recalculate the path. */
- }
-
- if (!B_IS_IN_TREE
-- (bh = PATH_OFFSET_PBUFFER(path, n_path_offset - 1)))
-+ (bh = PATH_OFFSET_PBUFFER(path, path_offset - 1)))
- return REPEAT_SEARCH; /* Parent in the path is not in the tree. */
-
-- if ((n_position =
-+ if ((position =
- PATH_OFFSET_POSITION(path,
-- n_path_offset - 1)) > B_NR_ITEMS(bh))
-+ path_offset - 1)) > B_NR_ITEMS(bh))
- return REPEAT_SEARCH;
-
-- if (B_N_CHILD_NUM(bh, n_position) !=
-- PATH_OFFSET_PBUFFER(path, n_path_offset)->b_blocknr)
-+ if (B_N_CHILD_NUM(bh, position) !=
-+ PATH_OFFSET_PBUFFER(path, path_offset)->b_blocknr)
- /* Parent in the path is not parent of the current node in the tree. */
- return REPEAT_SEARCH;
-
-@@ -1935,92 +1935,92 @@ static int get_direct_parent(struct tree
- return CARRY_ON; /* Parent in the path is unlocked and really parent of the current node. */
- }
-
--/* Using lnum[n_h] and rnum[n_h] we should determine what neighbors
-- * of S[n_h] we
-- * need in order to balance S[n_h], and get them if necessary.
-+/* Using lnum[h] and rnum[h] we should determine what neighbors
-+ * of S[h] we
-+ * need in order to balance S[h], and get them if necessary.
- * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked;
- * CARRY_ON - schedule didn't occur while the function worked;
- */
--static int get_neighbors(struct tree_balance *tb, int n_h)
-+static int get_neighbors(struct tree_balance *tb, int h)
- {
-- int n_child_position,
-- n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h + 1);
-- unsigned long n_son_number;
-+ int child_position,
-+ path_offset = PATH_H_PATH_OFFSET(tb->tb_path, h + 1);
-+ unsigned long son_number;
- struct super_block *sb = tb->tb_sb;
- struct buffer_head *bh;
-
-- PROC_INFO_INC(sb, get_neighbors[n_h]);
-+ PROC_INFO_INC(sb, get_neighbors[h]);
-
-- if (tb->lnum[n_h]) {
-- /* We need left neighbor to balance S[n_h]. */
-- PROC_INFO_INC(sb, need_l_neighbor[n_h]);
-- bh = PATH_OFFSET_PBUFFER(tb->tb_path, n_path_offset);
-+ if (tb->lnum[h]) {
-+ /* We need left neighbor to balance S[h]. */
-+ PROC_INFO_INC(sb, need_l_neighbor[h]);
-+ bh = PATH_OFFSET_PBUFFER(tb->tb_path, path_offset);
-
-- RFALSE(bh == tb->FL[n_h] &&
-- !PATH_OFFSET_POSITION(tb->tb_path, n_path_offset),
-+ RFALSE(bh == tb->FL[h] &&
-+ !PATH_OFFSET_POSITION(tb->tb_path, path_offset),
- "PAP-8270: invalid position in the parent");
-
-- n_child_position =
-+ child_position =
- (bh ==
-- tb->FL[n_h]) ? tb->lkey[n_h] : B_NR_ITEMS(tb->
-- FL[n_h]);
-- n_son_number = B_N_CHILD_NUM(tb->FL[n_h], n_child_position);
-- bh = sb_bread(sb, n_son_number);
-+ tb->FL[h]) ? tb->lkey[h] : B_NR_ITEMS(tb->
-+ FL[h]);
-+ son_number = B_N_CHILD_NUM(tb->FL[h], child_position);
-+ bh = sb_bread(sb, son_number);
- if (!bh)
- return IO_ERROR;
- if (FILESYSTEM_CHANGED_TB(tb)) {
- brelse(bh);
-- PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
-+ PROC_INFO_INC(sb, get_neighbors_restart[h]);
- return REPEAT_SEARCH;
- }
-
-- RFALSE(!B_IS_IN_TREE(tb->FL[n_h]) ||
-- n_child_position > B_NR_ITEMS(tb->FL[n_h]) ||
-- B_N_CHILD_NUM(tb->FL[n_h], n_child_position) !=
-+ RFALSE(!B_IS_IN_TREE(tb->FL[h]) ||
-+ child_position > B_NR_ITEMS(tb->FL[h]) ||
-+ B_N_CHILD_NUM(tb->FL[h], child_position) !=
- bh->b_blocknr, "PAP-8275: invalid parent");
- RFALSE(!B_IS_IN_TREE(bh), "PAP-8280: invalid child");
-- RFALSE(!n_h &&
-+ RFALSE(!h &&
- B_FREE_SPACE(bh) !=
- MAX_CHILD_SIZE(bh) -
-- dc_size(B_N_CHILD(tb->FL[0], n_child_position)),
-+ dc_size(B_N_CHILD(tb->FL[0], child_position)),
- "PAP-8290: invalid child size of left neighbor");
-
-- brelse(tb->L[n_h]);
-- tb->L[n_h] = bh;
-+ brelse(tb->L[h]);
-+ tb->L[h] = bh;
- }
-
-- /* We need right neighbor to balance S[n_path_offset]. */
-- if (tb->rnum[n_h]) {
-- PROC_INFO_INC(sb, need_r_neighbor[n_h]);
-- bh = PATH_OFFSET_PBUFFER(tb->tb_path, n_path_offset);
-+ /* We need right neighbor to balance S[path_offset]. */
-+ if (tb->rnum[h]) { /* We need right neighbor to balance S[path_offset]. */
-+ PROC_INFO_INC(sb, need_r_neighbor[h]);
-+ bh = PATH_OFFSET_PBUFFER(tb->tb_path, path_offset);
-
-- RFALSE(bh == tb->FR[n_h] &&
-+ RFALSE(bh == tb->FR[h] &&
- PATH_OFFSET_POSITION(tb->tb_path,
-- n_path_offset) >=
-+ path_offset) >=
- B_NR_ITEMS(bh),
- "PAP-8295: invalid position in the parent");
-
-- n_child_position =
-- (bh == tb->FR[n_h]) ? tb->rkey[n_h] + 1 : 0;
-- n_son_number = B_N_CHILD_NUM(tb->FR[n_h], n_child_position);
-- bh = sb_bread(sb, n_son_number);
-+ child_position =
-+ (bh == tb->FR[h]) ? tb->rkey[h] + 1 : 0;
-+ son_number = B_N_CHILD_NUM(tb->FR[h], child_position);
-+ bh = sb_bread(sb, son_number);
- if (!bh)
- return IO_ERROR;
- if (FILESYSTEM_CHANGED_TB(tb)) {
- brelse(bh);
-- PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
-+ PROC_INFO_INC(sb, get_neighbors_restart[h]);
- return REPEAT_SEARCH;
- }
-- brelse(tb->R[n_h]);
-- tb->R[n_h] = bh;
-+ brelse(tb->R[h]);
-+ tb->R[h] = bh;
-
-- RFALSE(!n_h
-+ RFALSE(!h
- && B_FREE_SPACE(bh) !=
- MAX_CHILD_SIZE(bh) -
-- dc_size(B_N_CHILD(tb->FR[0], n_child_position)),
-+ dc_size(B_N_CHILD(tb->FR[0], child_position)),
- "PAP-8300: invalid child size of right neighbor (%d != %d - %d)",
- B_FREE_SPACE(bh), MAX_CHILD_SIZE(bh),
-- dc_size(B_N_CHILD(tb->FR[0], n_child_position)));
-+ dc_size(B_N_CHILD(tb->FR[0], child_position)));
-
- }
- return CARRY_ON;
-@@ -2317,11 +2317,11 @@ static int wait_tb_buffers_until_unlocke
- * -1 - if no_disk_space
- */
-
--int fix_nodes(int n_op_mode, struct tree_balance *tb,
-+int fix_nodes(int op_mode, struct tree_balance *tb,
- struct item_head *ins_ih, const void *data)
- {
-- int n_ret_value, n_h, n_item_num = PATH_LAST_POSITION(tb->tb_path);
-- int n_pos_in_item;
-+ int ret, h, item_num = PATH_LAST_POSITION(tb->tb_path);
-+ int pos_in_item;
-
- /* we set wait_tb_buffers_run when we have to restore any dirty bits cleared
- ** during wait_tb_buffers_run
-@@ -2331,7 +2331,7 @@ int fix_nodes(int n_op_mode, struct tree
-
- ++REISERFS_SB(tb->tb_sb)->s_fix_nodes;
-
-- n_pos_in_item = tb->tb_path->pos_in_item;
-+ pos_in_item = tb->tb_path->pos_in_item;
-
- tb->fs_gen = get_generation(tb->tb_sb);
-
-@@ -2364,26 +2364,26 @@ int fix_nodes(int n_op_mode, struct tree
- reiserfs_panic(tb->tb_sb, "PAP-8320", "S[0] (%b %z) is "
- "not uptodate at the beginning of fix_nodes "
- "or not in tree (mode %c)",
-- tbS0, tbS0, n_op_mode);
-+ tbS0, tbS0, op_mode);
-
- /* Check parameters. */
-- switch (n_op_mode) {
-+ switch (op_mode) {
- case M_INSERT:
-- if (n_item_num <= 0 || n_item_num > B_NR_ITEMS(tbS0))
-+ if (item_num <= 0 || item_num > B_NR_ITEMS(tbS0))
- reiserfs_panic(tb->tb_sb, "PAP-8330", "Incorrect "
- "item number %d (in S0 - %d) in case "
-- "of insert", n_item_num,
-+ "of insert", item_num,
- B_NR_ITEMS(tbS0));
- break;
- case M_PASTE:
- case M_DELETE:
- case M_CUT:
-- if (n_item_num < 0 || n_item_num >= B_NR_ITEMS(tbS0)) {
-+ if (item_num < 0 || item_num >= B_NR_ITEMS(tbS0)) {
- print_block(tbS0, 0, -1, -1);
- reiserfs_panic(tb->tb_sb, "PAP-8335", "Incorrect "
- "item number(%d); mode = %c "
- "insert_size = %d",
-- n_item_num, n_op_mode,
-+ item_num, op_mode,
- tb->insert_size[0]);
- }
- break;
-@@ -2397,73 +2397,73 @@ int fix_nodes(int n_op_mode, struct tree
- // FIXME: maybe -ENOMEM when tb->vn_buf == 0? Now just repeat
- return REPEAT_SEARCH;
-
-- /* Starting from the leaf level; for all levels n_h of the tree. */
-- for (n_h = 0; n_h < MAX_HEIGHT && tb->insert_size[n_h]; n_h++) {
-- n_ret_value = get_direct_parent(tb, n_h);
-- if (n_ret_value != CARRY_ON)
-+ /* Starting from the leaf level; for all levels h of the tree. */
-+ for (h = 0; h < MAX_HEIGHT && tb->insert_size[h]; h++) {
-+ ret = get_direct_parent(tb, h);
-+ if (ret != CARRY_ON)
- goto repeat;
-
-- n_ret_value = check_balance(n_op_mode, tb, n_h, n_item_num,
-- n_pos_in_item, ins_ih, data);
-- if (n_ret_value != CARRY_ON) {
-- if (n_ret_value == NO_BALANCING_NEEDED) {
-+ ret = check_balance(op_mode, tb, h, item_num,
-+ pos_in_item, ins_ih, data);
-+ if (ret != CARRY_ON) {
-+ if (ret == NO_BALANCING_NEEDED) {
- /* No balancing for higher levels needed. */
-- n_ret_value = get_neighbors(tb, n_h);
-- if (n_ret_value != CARRY_ON)
-+ ret = get_neighbors(tb, h);
-+ if (ret != CARRY_ON)
- goto repeat;
-- if (n_h != MAX_HEIGHT - 1)
-- tb->insert_size[n_h + 1] = 0;
-+ if (h != MAX_HEIGHT - 1)
-+ tb->insert_size[h + 1] = 0;
- /* ok, analysis and resource gathering are complete */
- break;
- }
- goto repeat;
- }
-
-- n_ret_value = get_neighbors(tb, n_h);
-- if (n_ret_value != CARRY_ON)
-+ ret = get_neighbors(tb, h);
-+ if (ret != CARRY_ON)
- goto repeat;
-
- /* No disk space, or schedule occurred and analysis may be
- * invalid and needs to be redone. */
-- n_ret_value = get_empty_nodes(tb, n_h);
-- if (n_ret_value != CARRY_ON)
-+ ret = get_empty_nodes(tb, h);
-+ if (ret != CARRY_ON)
- goto repeat;
-
-- if (!PATH_H_PBUFFER(tb->tb_path, n_h)) {
-+ if (!PATH_H_PBUFFER(tb->tb_path, h)) {
- /* We have a positive insert size but no nodes exist on this
- level, this means that we are creating a new root. */
-
-- RFALSE(tb->blknum[n_h] != 1,
-+ RFALSE(tb->blknum[h] != 1,
- "PAP-8350: creating new empty root");
-
-- if (n_h < MAX_HEIGHT - 1)
-- tb->insert_size[n_h + 1] = 0;
-- } else if (!PATH_H_PBUFFER(tb->tb_path, n_h + 1)) {
-- if (tb->blknum[n_h] > 1) {
-- /* The tree needs to be grown, so this node S[n_h]
-+ if (h < MAX_HEIGHT - 1)
-+ tb->insert_size[h + 1] = 0;
-+ } else if (!PATH_H_PBUFFER(tb->tb_path, h + 1)) {
-+ if (tb->blknum[h] > 1) {
-+ /* The tree needs to be grown, so this node S[h]
- 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[h+1]) will be created to
- become the root node. */
-
-- RFALSE(n_h == MAX_HEIGHT - 1,
-+ RFALSE(h == MAX_HEIGHT - 1,
- "PAP-8355: attempt to create too high of a tree");
-
-- tb->insert_size[n_h + 1] =
-+ tb->insert_size[h + 1] =
- (DC_SIZE +
-- KEY_SIZE) * (tb->blknum[n_h] - 1) +
-+ KEY_SIZE) * (tb->blknum[h] - 1) +
- DC_SIZE;
-- } else if (n_h < MAX_HEIGHT - 1)
-- tb->insert_size[n_h + 1] = 0;
-+ } else if (h < MAX_HEIGHT - 1)
-+ tb->insert_size[h + 1] = 0;
- } else
-- tb->insert_size[n_h + 1] =
-- (DC_SIZE + KEY_SIZE) * (tb->blknum[n_h] - 1);
-+ tb->insert_size[h + 1] =
-+ (DC_SIZE + KEY_SIZE) * (tb->blknum[h] - 1);
- }
-
-- n_ret_value = wait_tb_buffers_until_unlocked(tb);
-- if (n_ret_value == CARRY_ON) {
-+ ret = wait_tb_buffers_until_unlocked(tb);
-+ if (ret == CARRY_ON) {
- if (FILESYSTEM_CHANGED_TB(tb)) {
- wait_tb_buffers_run = 1;
-- n_ret_value = REPEAT_SEARCH;
-+ ret = REPEAT_SEARCH;
- goto repeat;
- } else {
- return CARRY_ON;
-@@ -2529,7 +2529,7 @@ int fix_nodes(int n_op_mode, struct tree
- (tb->tb_sb, tb->FEB[i]);
- }
- }
-- return n_ret_value;
-+ return ret;
- }
-
- }
---- a/fs/reiserfs/stree.c
-+++ b/fs/reiserfs/stree.c
-@@ -136,11 +136,11 @@ inline int comp_short_le_keys(const stru
- const struct reiserfs_key *key2)
- {
- __u32 *k1_u32, *k2_u32;
-- int n_key_length = REISERFS_SHORT_KEY_LEN;
-+ int key_length = REISERFS_SHORT_KEY_LEN;
-
- k1_u32 = (__u32 *) key1;
- k2_u32 = (__u32 *) key2;
-- for (; n_key_length--; ++k1_u32, ++k2_u32) {
-+ for (; key_length--; ++k1_u32, ++k2_u32) {
- if (le32_to_cpu(*k1_u32) < le32_to_cpu(*k2_u32))
- return -1;
- if (le32_to_cpu(*k1_u32) > le32_to_cpu(*k2_u32))
-@@ -177,10 +177,10 @@ inline int comp_le_keys(const struct rei
- * *pos = number of the searched element if found, else the *
- * number of the first element that is larger than key. *
- **************************************************************************/
--/* For those not familiar with binary search: n_lbound is the leftmost item that it
-- could be, n_rbound the rightmost item that it could be. We examine the item
-- halfway between n_lbound and n_rbound, and that tells us either that we can increase
-- n_lbound, or decrease n_rbound, or that we have found it, or if n_lbound <= n_rbound that
-+/* For those not familiar with binary search: lbound is the leftmost item that it
-+ could be, rbound the rightmost item that it could be. We examine the item
-+ halfway between lbound and rbound, and that tells us either that we can increase
-+ lbound, or decrease rbound, or that we have found it, or if lbound <= rbound that
- there are no possible items, and we have not found it. With each examination we
- cut the number of possible items it could be by one more than half rounded down,
- or we find it. */
-@@ -198,28 +198,27 @@ static inline int bin_search(const void
- int *pos /* Number of the searched for element. */
- )
- {
-- int n_rbound, n_lbound, n_j;
-+ int rbound, lbound, j;
-
-- for (n_j = ((n_rbound = num - 1) + (n_lbound = 0)) / 2;
-- n_lbound <= n_rbound; n_j = (n_rbound + n_lbound) / 2)
-+ for (j = ((rbound = num - 1) + (lbound = 0)) / 2;
-+ lbound <= rbound; j = (rbound + lbound) / 2)
- switch (comp_keys
-- ((struct reiserfs_key *)((char *)base +
-- n_j * width),
-+ ((struct reiserfs_key *)((char *)base + j * width),
- (struct cpu_key *)key)) {
- case -1:
-- n_lbound = n_j + 1;
-+ lbound = j + 1;
- continue;
- case 1:
-- n_rbound = n_j - 1;
-+ rbound = j - 1;
- continue;
- case 0:
-- *pos = n_j;
-+ *pos = j;
- return ITEM_FOUND; /* Key found in the array. */
- }
-
- /* bin_search did not find given key, it returns position of key,
- that is minimal and greater than the given one. */
-- *pos = n_lbound;
-+ *pos = lbound;
- return ITEM_NOT_FOUND;
- }
-
-@@ -242,43 +241,41 @@ static const struct reiserfs_key MAX_KEY
- of the path, and going upwards. We must check the path's validity at each step. If the key is not in
- the path, there is no delimiting key in the tree (buffer is first or last buffer in tree), and in this
- case we return a special key, either MIN_KEY or MAX_KEY. */
--static inline const struct reiserfs_key *get_lkey(const struct treepath
-- *chk_path,
-- const struct super_block
-- *sb)
-+static inline const struct reiserfs_key *get_lkey(const struct treepath *chk_path,
-+ const struct super_block *sb)
- {
-- int n_position, n_path_offset = chk_path->path_length;
-+ int position, path_offset = chk_path->path_length;
- struct buffer_head *parent;
-
-- RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET,
-+ RFALSE(path_offset < FIRST_PATH_ELEMENT_OFFSET,
- "PAP-5010: invalid offset in the path");
-
- /* While not higher in path than first element. */
-- while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
-+ while (path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
-
- RFALSE(!buffer_uptodate
-- (PATH_OFFSET_PBUFFER(chk_path, n_path_offset)),
-+ (PATH_OFFSET_PBUFFER(chk_path, path_offset)),
- "PAP-5020: parent is not uptodate");
-
- /* Parent at the path is not in the tree now. */
- if (!B_IS_IN_TREE
- (parent =
-- PATH_OFFSET_PBUFFER(chk_path, n_path_offset)))
-+ PATH_OFFSET_PBUFFER(chk_path, path_offset)))
- return &MAX_KEY;
- /* Check whether position in the parent is correct. */
-- if ((n_position =
-+ if ((position =
- PATH_OFFSET_POSITION(chk_path,
-- n_path_offset)) >
-+ path_offset)) >
- B_NR_ITEMS(parent))
- return &MAX_KEY;
- /* Check whether parent at the path really points to the child. */
-- if (B_N_CHILD_NUM(parent, n_position) !=
-+ if (B_N_CHILD_NUM(parent, position) !=
- PATH_OFFSET_PBUFFER(chk_path,
-- n_path_offset + 1)->b_blocknr)
-+ path_offset + 1)->b_blocknr)
- return &MAX_KEY;
- /* Return delimiting key if position in the parent is not equal to zero. */
-- if (n_position)
-- return B_N_PDELIM_KEY(parent, n_position - 1);
-+ if (position)
-+ return B_N_PDELIM_KEY(parent, position - 1);
- }
- /* Return MIN_KEY if we are in the root of the buffer tree. */
- if (PATH_OFFSET_PBUFFER(chk_path, FIRST_PATH_ELEMENT_OFFSET)->
-@@ -291,37 +288,37 @@ static inline const struct reiserfs_key
- inline const struct reiserfs_key *get_rkey(const struct treepath *chk_path,
- const struct super_block *sb)
- {
-- int n_position, n_path_offset = chk_path->path_length;
-+ int position, path_offset = chk_path->path_length;
- struct buffer_head *parent;
-
-- RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET,
-+ RFALSE(path_offset < FIRST_PATH_ELEMENT_OFFSET,
- "PAP-5030: invalid offset in the path");
-
-- while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
-+ while (path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
-
- RFALSE(!buffer_uptodate
-- (PATH_OFFSET_PBUFFER(chk_path, n_path_offset)),
-+ (PATH_OFFSET_PBUFFER(chk_path, path_offset)),
- "PAP-5040: parent is not uptodate");
-
- /* Parent at the path is not in the tree now. */
- if (!B_IS_IN_TREE
- (parent =
-- PATH_OFFSET_PBUFFER(chk_path, n_path_offset)))
-+ PATH_OFFSET_PBUFFER(chk_path, path_offset)))
- return &MIN_KEY;
- /* Check whether position in the parent is correct. */
-- if ((n_position =
-+ if ((position =
- PATH_OFFSET_POSITION(chk_path,
-- n_path_offset)) >
-+ path_offset)) >
- B_NR_ITEMS(parent))
- return &MIN_KEY;
- /* Check whether parent at the path really points to the child. */
-- if (B_N_CHILD_NUM(parent, n_position) !=
-+ if (B_N_CHILD_NUM(parent, position) !=
- PATH_OFFSET_PBUFFER(chk_path,
-- n_path_offset + 1)->b_blocknr)
-+ path_offset + 1)->b_blocknr)
- return &MIN_KEY;
- /* Return delimiting key if position in the parent is not the last one. */
-- if (n_position != B_NR_ITEMS(parent))
-- return B_N_PDELIM_KEY(parent, n_position);
-+ if (position != B_NR_ITEMS(parent))
-+ return B_N_PDELIM_KEY(parent, position);
- }
- /* Return MAX_KEY if we are in the root of the buffer tree. */
- if (PATH_OFFSET_PBUFFER(chk_path, FIRST_PATH_ELEMENT_OFFSET)->
-@@ -371,14 +368,14 @@ int reiserfs_check_path(struct treepath
- void pathrelse_and_restore(struct super_block *sb,
- struct treepath *search_path)
- {
-- int n_path_offset = search_path->path_length;
-+ int path_offset = search_path->path_length;
-
-- RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
-+ RFALSE(path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
- "clm-4000: invalid path offset");
-
-- while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
-+ while (path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
- struct buffer_head *bh;
-- bh = PATH_OFFSET_PBUFFER(search_path, n_path_offset--);
-+ bh = PATH_OFFSET_PBUFFER(search_path, path_offset--);
- reiserfs_restore_prepared_buffer(sb, bh);
- brelse(bh);
- }
-@@ -388,13 +385,13 @@ void pathrelse_and_restore(struct super_
- /* Drop the reference to each buffer in a path */
- void pathrelse(struct treepath *search_path)
- {
-- int n_path_offset = search_path->path_length;
-+ int path_offset = search_path->path_length;
-
-- RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
-+ RFALSE(path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
- "PAP-5090: invalid path offset");
-
-- while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET)
-- brelse(PATH_OFFSET_PBUFFER(search_path, n_path_offset--));
-+ while (path_offset > ILLEGAL_PATH_ELEMENT_OFFSET)
-+ brelse(PATH_OFFSET_PBUFFER(search_path, path_offset--));
-
- search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
- }
-@@ -572,16 +569,16 @@ int search_by_key(struct super_block *sb
- by the calling
- function. It is filled up
- by this function. */
-- int n_stop_level /* How far down the tree to search. To
-+ int stop_level /* How far down the tree to search. To
- stop at leaf level - set to
- DISK_LEAF_NODE_LEVEL */
- )
- {
-- b_blocknr_t n_block_number;
-+ b_blocknr_t block_number;
- int expected_level;
- struct buffer_head *bh;
- struct path_element *last_element;
-- int n_node_level, n_retval;
-+ int node_level, retval;
- int right_neighbor_of_leaf_node;
- int fs_gen;
- struct buffer_head *reada_bh[SEARCH_BY_KEY_READA];
-@@ -589,7 +586,7 @@ int search_by_key(struct super_block *sb
- int reada_count = 0;
-
- #ifdef CONFIG_REISERFS_CHECK
-- int n_repeat_counter = 0;
-+ int repeat_counter = 0;
- #endif
-
- PROC_INFO_INC(sb, search_by_key);
-@@ -605,16 +602,16 @@ int search_by_key(struct super_block *sb
- /* With each iteration of this loop we search through the items in the
- current node, and calculate the next current node(next path element)
- for the next iteration of this loop.. */
-- n_block_number = SB_ROOT_BLOCK(sb);
-+ block_number = SB_ROOT_BLOCK(sb);
- expected_level = -1;
- while (1) {
-
- #ifdef CONFIG_REISERFS_CHECK
-- if (!(++n_repeat_counter % 50000))
-+ if (!(++repeat_counter % 50000))
- reiserfs_warning(sb, "PAP-5100",
- "%s: there were %d iterations of "
- "while loop looking for key %K",
-- current->comm, n_repeat_counter,
-+ current->comm, repeat_counter,
- key);
- #endif
-
-@@ -627,7 +624,7 @@ int search_by_key(struct super_block *sb
- /* Read the next tree node, and set the last element in the path to
- have a pointer to it. */
- if ((bh = last_element->pe_buffer =
-- sb_getblk(sb, n_block_number))) {
-+ sb_getblk(sb, block_number))) {
- if (!buffer_uptodate(bh) && reada_count > 1)
- search_by_key_reada(sb, reada_bh,
- reada_blocks, reada_count);
-@@ -661,7 +658,7 @@ int search_by_key(struct super_block *sb
-
- /* Get the root block number so that we can repeat the search
- starting from the root. */
-- n_block_number = SB_ROOT_BLOCK(sb);
-+ block_number = SB_ROOT_BLOCK(sb);
- expected_level = -1;
- right_neighbor_of_leaf_node = 0;
-
-@@ -694,26 +691,26 @@ int search_by_key(struct super_block *sb
- }
-
- /* ok, we have acquired next formatted node in the tree */
-- n_node_level = B_LEVEL(bh);
-+ node_level = B_LEVEL(bh);
-
-- PROC_INFO_BH_STAT(sb, bh, n_node_level - 1);
-+ PROC_INFO_BH_STAT(sb, bh, node_level - 1);
-
-- RFALSE(n_node_level < n_stop_level,
-+ RFALSE(node_level < stop_level,
- "vs-5152: tree level (%d) is less than stop level (%d)",
-- n_node_level, n_stop_level);
-+ node_level, stop_level);
-
-- n_retval = bin_search(key, B_N_PITEM_HEAD(bh, 0),
-+ retval = bin_search(key, B_N_PITEM_HEAD(bh, 0),
- B_NR_ITEMS(bh),
-- (n_node_level ==
-+ (node_level ==
- DISK_LEAF_NODE_LEVEL) ? IH_SIZE :
- KEY_SIZE,
- &(last_element->pe_position));
-- if (n_node_level == n_stop_level) {
-- return n_retval;
-+ if (node_level == stop_level) {
-+ return retval;
- }
-
- /* we are not in the stop level */
-- if (n_retval == ITEM_FOUND)
-+ if (retval == ITEM_FOUND)
- /* item has been found, so we choose the pointer which is to the right of the found one */
- last_element->pe_position++;
-
-@@ -724,12 +721,12 @@ int search_by_key(struct super_block *sb
- /* So we have chosen a position in the current node which is
- an internal node. Now we calculate child block number by
- position in the node. */
-- n_block_number =
-+ block_number =
- B_N_CHILD_NUM(bh, last_element->pe_position);
-
- /* if we are going to read leaf nodes, try for read ahead as well */
- if ((search_path->reada & PATH_READA) &&
-- n_node_level == DISK_LEAF_NODE_LEVEL + 1) {
-+ node_level == DISK_LEAF_NODE_LEVEL + 1) {
- int pos = last_element->pe_position;
- int limit = B_NR_ITEMS(bh);
- struct reiserfs_key *le_key;
-@@ -781,7 +778,7 @@ int search_for_position_by_key(struct su
- )
- {
- struct item_head *p_le_ih; /* pointer to on-disk structure */
-- int n_blk_size;
-+ int blk_size;
- loff_t item_offset, offset;
- struct reiserfs_dir_entry de;
- int retval;
-@@ -816,7 +813,7 @@ int search_for_position_by_key(struct su
- p_le_ih =
- B_N_PITEM_HEAD(PATH_PLAST_BUFFER(search_path),
- --PATH_LAST_POSITION(search_path));
-- n_blk_size = sb->s_blocksize;
-+ blk_size = sb->s_blocksize;
-
- if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) {
- return FILE_NOT_FOUND;
-@@ -828,10 +825,10 @@ int search_for_position_by_key(struct su
-
- /* Needed byte is contained in the item pointed to by the path. */
- if (item_offset <= offset &&
-- item_offset + op_bytes_number(p_le_ih, n_blk_size) > offset) {
-+ item_offset + op_bytes_number(p_le_ih, blk_size) > offset) {
- pos_in_item(search_path) = offset - item_offset;
- if (is_indirect_le_ih(p_le_ih)) {
-- pos_in_item(search_path) /= n_blk_size;
-+ pos_in_item(search_path) /= blk_size;
- }
- return POSITION_FOUND;
- }
-@@ -891,7 +888,7 @@ static inline int prepare_for_direct_ite
- if (get_inode_item_key_version(inode) == KEY_FORMAT_3_6) {
- //
- round_len = ROUND_UP(new_file_length);
-- /* this was n_new_file_length < le_ih ... */
-+ /* this was new_file_length < le_ih ... */
- if (round_len < le_ih_k_offset(le_ih)) {
- *cut_size = -(IH_SIZE + ih_item_len(le_ih));
- return M_DELETE; /* Delete this item. */
-@@ -953,7 +950,7 @@ static inline int prepare_for_direntry_i
- This function returns a determination of what balance mode the calling function should employ. */
- static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, struct inode *inode, struct treepath *path, const struct cpu_key *item_key, int *removed, /* Number of unformatted nodes which were removed
- from end of the file. */
-- int *cut_size, unsigned long long n_new_file_length /* MAX_KEY_OFFSET in case of delete. */
-+ int *cut_size, unsigned long long new_file_length /* MAX_KEY_OFFSET in case of delete. */
- )
- {
- struct super_block *sb = inode->i_sb;
-@@ -965,7 +962,7 @@ static char prepare_for_delete_or_cut(st
- /* Stat_data item. */
- if (is_statdata_le_ih(p_le_ih)) {
-
-- RFALSE(n_new_file_length != max_reiserfs_offset(inode),
-+ RFALSE(new_file_length != max_reiserfs_offset(inode),
- "PAP-5210: mode must be M_DELETE");
-
- *cut_size = -(IH_SIZE + ih_item_len(p_le_ih));
-@@ -975,13 +972,13 @@ static char prepare_for_delete_or_cut(st
- /* Directory item. */
- if (is_direntry_le_ih(p_le_ih))
- return prepare_for_direntry_item(path, p_le_ih, inode,
-- n_new_file_length,
-+ new_file_length,
- cut_size);
-
- /* Direct item. */
- if (is_direct_le_ih(p_le_ih))
- return prepare_for_direct_item(path, p_le_ih, inode,
-- n_new_file_length, cut_size);
-+ new_file_length, cut_size);
-
- /* Case of an indirect item. */
- {
-@@ -992,10 +989,10 @@ static char prepare_for_delete_or_cut(st
- int result = M_CUT;
- int pos = 0;
-
-- if ( n_new_file_length == max_reiserfs_offset (inode) ) {
-+ if ( new_file_length == max_reiserfs_offset (inode) ) {
- /* prepare_for_delete_or_cut() is called by
- * reiserfs_delete_item() */
-- n_new_file_length = 0;
-+ new_file_length = 0;
- delete = 1;
- }
-
-@@ -1006,7 +1003,7 @@ static char prepare_for_delete_or_cut(st
- copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
- pos = I_UNFM_NUM(&s_ih);
-
-- while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > n_new_file_length) {
-+ while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > new_file_length) {
- __le32 *unfm;
- __u32 block;
-
-@@ -1062,35 +1059,34 @@ static char prepare_for_delete_or_cut(st
- }
-
- /* Calculate number of bytes which will be deleted or cut during balance */
--static int calc_deleted_bytes_number(struct tree_balance *tb, char c_mode)
-+static int calc_deleted_bytes_number(struct tree_balance *tb, char mode)
- {
-- int n_del_size;
-+ int del_size;
- struct item_head *p_le_ih = PATH_PITEM_HEAD(tb->tb_path);
-
- if (is_statdata_le_ih(p_le_ih))
- return 0;
-
-- n_del_size =
-- (c_mode ==
-+ del_size =
-+ (mode ==
- M_DELETE) ? ih_item_len(p_le_ih) : -tb->insert_size[0];
- if (is_direntry_le_ih(p_le_ih)) {
-- // return EMPTY_DIR_SIZE; /* We delete emty directoris only. */
-- // we can't use EMPTY_DIR_SIZE, as old format dirs have a different
-- // empty size. ick. FIXME, is this right?
-- //
-- return n_del_size;
-+ /* return EMPTY_DIR_SIZE; We delete emty directoris only.
-+ * we can't use EMPTY_DIR_SIZE, as old format dirs have a different
-+ * empty size. ick. FIXME, is this right? */
-+ return del_size;
- }
-
- if (is_indirect_le_ih(p_le_ih))
-- n_del_size = (n_del_size / UNFM_P_SIZE) *
-+ del_size = (del_size / UNFM_P_SIZE) *
- (PATH_PLAST_BUFFER(tb->tb_path)->b_size);
-- return n_del_size;
-+ return del_size;
- }
-
- static void init_tb_struct(struct reiserfs_transaction_handle *th,
- struct tree_balance *tb,
- struct super_block *sb,
-- struct treepath *path, int n_size)
-+ struct treepath *path, int size)
- {
-
- BUG_ON(!th->t_trans_id);
-@@ -1101,7 +1097,7 @@ static void init_tb_struct(struct reiser
- tb->tb_path = path;
- PATH_OFFSET_PBUFFER(path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
- PATH_OFFSET_POSITION(path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
-- tb->insert_size[0] = n_size;
-+ tb->insert_size[0] = size;
- }
-
- void padd_item(char *item, int total_length, int length)
-@@ -1156,11 +1152,11 @@ int reiserfs_delete_item(struct reiserfs
- struct item_head s_ih;
- struct item_head *q_ih;
- int quota_cut_bytes;
-- int n_ret_value, n_del_size, n_removed;
-+ int ret_value, del_size, removed;
-
- #ifdef CONFIG_REISERFS_CHECK
-- char c_mode;
-- int n_iter = 0;
-+ char mode;
-+ int iter = 0;
- #endif
-
- BUG_ON(!th->t_trans_id);
-@@ -1169,34 +1165,34 @@ int reiserfs_delete_item(struct reiserfs
- 0 /*size is unknown */ );
-
- while (1) {
-- n_removed = 0;
-+ removed = 0;
-
- #ifdef CONFIG_REISERFS_CHECK
-- n_iter++;
-- c_mode =
-+ iter++;
-+ mode =
- #endif
- prepare_for_delete_or_cut(th, inode, path,
-- item_key, &n_removed,
-- &n_del_size,
-+ item_key, &removed,
-+ &del_size,
- max_reiserfs_offset(inode));
-
-- RFALSE(c_mode != M_DELETE, "PAP-5320: mode must be M_DELETE");
-+ RFALSE(mode != M_DELETE, "PAP-5320: mode must be M_DELETE");
-
- copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
-- s_del_balance.insert_size[0] = n_del_size;
-+ s_del_balance.insert_size[0] = del_size;
-
-- n_ret_value = fix_nodes(M_DELETE, &s_del_balance, NULL, NULL);
-- if (n_ret_value != REPEAT_SEARCH)
-+ ret_value = fix_nodes(M_DELETE, &s_del_balance, NULL, NULL);
-+ if (ret_value != REPEAT_SEARCH)
- break;
-
- PROC_INFO_INC(sb, delete_item_restarted);
-
- // file system changed, repeat search
-- n_ret_value =
-+ ret_value =
- search_for_position_by_key(sb, item_key, path);
-- if (n_ret_value == IO_ERROR)
-+ if (ret_value == IO_ERROR)
- break;
-- if (n_ret_value == FILE_NOT_FOUND) {
-+ if (ret_value == FILE_NOT_FOUND) {
- reiserfs_warning(sb, "vs-5340",
- "no items of the file %K found",
- item_key);
-@@ -1204,12 +1200,12 @@ int reiserfs_delete_item(struct reiserfs
- }
- } /* while (1) */
-
-- if (n_ret_value != CARRY_ON) {
-+ if (ret_value != CARRY_ON) {
- unfix_nodes(&s_del_balance);
- return 0;
- }
- // reiserfs_delete_item returns item length when success
-- n_ret_value = calc_deleted_bytes_number(&s_del_balance, M_DELETE);
-+ ret_value = calc_deleted_bytes_number(&s_del_balance, M_DELETE);
- q_ih = get_ih(path);
- quota_cut_bytes = ih_item_len(q_ih);
-
-@@ -1255,7 +1251,7 @@ int reiserfs_delete_item(struct reiserfs
- off = ((le_ih_k_offset(&s_ih) - 1) & (PAGE_CACHE_SIZE - 1));
- memcpy(data + off,
- B_I_PITEM(PATH_PLAST_BUFFER(path), &s_ih),
-- n_ret_value);
-+ ret_value);
- kunmap_atomic(data, KM_USER0);
- }
- /* Perform balancing after all resources have been collected at once. */
-@@ -1269,7 +1265,7 @@ int reiserfs_delete_item(struct reiserfs
- DQUOT_FREE_SPACE_NODIRTY(inode, quota_cut_bytes);
-
- /* Return deleted body length */
-- return n_ret_value;
-+ return ret_value;
- }
-
- /* Summary Of Mechanisms For Handling Collisions Between Processes:
-@@ -1432,13 +1428,13 @@ static int maybe_indirect_to_direct(stru
- struct page *page,
- struct treepath *path,
- const struct cpu_key *item_key,
-- loff_t n_new_file_size, char *mode)
-+ loff_t new_file_size, char *mode)
- {
- struct super_block *sb = inode->i_sb;
-- int n_block_size = sb->s_blocksize;
-+ int block_size = sb->s_blocksize;
- int cut_bytes;
- BUG_ON(!th->t_trans_id);
-- BUG_ON(n_new_file_size != inode->i_size);
-+ BUG_ON(new_file_size != inode->i_size);
-
- /* the page being sent in could be NULL if there was an i/o error
- ** reading in the last block. The user will hit problems trying to
-@@ -1450,15 +1446,15 @@ static int maybe_indirect_to_direct(stru
- /* leave tail in an unformatted node */
- *mode = M_SKIP_BALANCING;
- cut_bytes =
-- n_block_size - (n_new_file_size & (n_block_size - 1));
-+ block_size - (new_file_size & (block_size - 1));
- pathrelse(path);
- return cut_bytes;
- }
- /* Perform the conversion to a direct_item. */
- /* return indirect_to_direct(inode, path, item_key,
-- n_new_file_size, mode); */
-+ new_file_size, mode); */
- return indirect2direct(th, inode, page, path, item_key,
-- n_new_file_size, mode);
-+ new_file_size, mode);
- }
-
- /* we did indirect_to_direct conversion. And we have inserted direct
-@@ -1512,7 +1508,7 @@ int reiserfs_cut_from_item(struct reiser
- struct treepath *path,
- struct cpu_key *item_key,
- struct inode *inode,
-- struct page *page, loff_t n_new_file_size)
-+ struct page *page, loff_t new_file_size)
- {
- struct super_block *sb = inode->i_sb;
- /* Every function which is going to call do_balance must first
-@@ -1521,10 +1517,10 @@ int reiserfs_cut_from_item(struct reiser
- After that we can make tree balancing. */
- struct tree_balance s_cut_balance;
- struct item_head *p_le_ih;
-- int n_cut_size = 0, /* Amount to be cut. */
-- n_ret_value = CARRY_ON, n_removed = 0, /* Number of the removed unformatted nodes. */
-- n_is_inode_locked = 0;
-- char c_mode; /* Mode of the balance. */
-+ int cut_size = 0, /* Amount to be cut. */
-+ ret_value = CARRY_ON, removed = 0, /* Number of the removed unformatted nodes. */
-+ is_inode_locked = 0;
-+ char mode; /* Mode of the balance. */
- int retval2 = -1;
- int quota_cut_bytes;
- loff_t tail_pos = 0;
-@@ -1532,7 +1528,7 @@ int reiserfs_cut_from_item(struct reiser
- BUG_ON(!th->t_trans_id);
-
- init_tb_struct(th, &s_cut_balance, inode->i_sb, path,
-- n_cut_size);
-+ cut_size);
-
- /* Repeat this loop until we either cut the item without needing
- to balance, or we fix_nodes without schedule occurring */
-@@ -1542,30 +1538,30 @@ int reiserfs_cut_from_item(struct reiser
- free unformatted nodes which are pointed to by the cut
- pointers. */
-
-- c_mode =
-+ mode =
- prepare_for_delete_or_cut(th, inode, path,
-- item_key, &n_removed,
-- &n_cut_size, n_new_file_size);
-- if (c_mode == M_CONVERT) {
-+ item_key, &removed,
-+ &cut_size, new_file_size);
-+ if (mode == M_CONVERT) {
- /* convert last unformatted node to direct item or leave
- tail in the unformatted node */
-- RFALSE(n_ret_value != CARRY_ON,
-+ RFALSE(ret_value != CARRY_ON,
- "PAP-5570: can not convert twice");
-
-- n_ret_value =
-+ ret_value =
- maybe_indirect_to_direct(th, inode, page,
- path, item_key,
-- n_new_file_size, &c_mode);
-- if (c_mode == M_SKIP_BALANCING)
-+ new_file_size, &mode);
-+ if (mode == M_SKIP_BALANCING)
- /* tail has been left in the unformatted node */
-- return n_ret_value;
-+ return ret_value;
-
-- n_is_inode_locked = 1;
-+ is_inode_locked = 1;
-
- /* removing of last unformatted node will change value we
- have to return to truncate. Save it */
-- retval2 = n_ret_value;
-- /*retval2 = sb->s_blocksize - (n_new_file_size & (sb->s_blocksize - 1)); */
-+ retval2 = ret_value;
-+ /*retval2 = sb->s_blocksize - (new_file_size & (sb->s_blocksize - 1)); */
-
- /* So, we have performed the first part of the conversion:
- inserting the new direct item. Now we are removing the
-@@ -1573,10 +1569,10 @@ int reiserfs_cut_from_item(struct reiser
- it. */
- set_cpu_key_k_type(item_key, TYPE_INDIRECT);
- item_key->key_length = 4;
-- n_new_file_size -=
-- (n_new_file_size & (sb->s_blocksize - 1));
-- tail_pos = n_new_file_size;
-- set_cpu_key_k_offset(item_key, n_new_file_size + 1);
-+ new_file_size -=
-+ (new_file_size & (sb->s_blocksize - 1));
-+ tail_pos = new_file_size;
-+ set_cpu_key_k_offset(item_key, new_file_size + 1);
- if (search_for_position_by_key
- (sb, item_key,
- path) == POSITION_NOT_FOUND) {
-@@ -1589,38 +1585,38 @@ int reiserfs_cut_from_item(struct reiser
- }
- continue;
- }
-- if (n_cut_size == 0) {
-+ if (cut_size == 0) {
- pathrelse(path);
- return 0;
- }
-
-- s_cut_balance.insert_size[0] = n_cut_size;
-+ s_cut_balance.insert_size[0] = cut_size;
-
-- n_ret_value = fix_nodes(c_mode, &s_cut_balance, NULL, NULL);
-- if (n_ret_value != REPEAT_SEARCH)
-+ ret_value = fix_nodes(mode, &s_cut_balance, NULL, NULL);
-+ if (ret_value != REPEAT_SEARCH)
- break;
-
- PROC_INFO_INC(sb, cut_from_item_restarted);
-
-- n_ret_value =
-+ ret_value =
- search_for_position_by_key(sb, item_key, path);
-- if (n_ret_value == POSITION_FOUND)
-+ if (ret_value == POSITION_FOUND)
- continue;
-
- reiserfs_warning(sb, "PAP-5610", "item %K not found",
- item_key);
- unfix_nodes(&s_cut_balance);
-- return (n_ret_value == IO_ERROR) ? -EIO : -ENOENT;
-+ return (ret_value == IO_ERROR) ? -EIO : -ENOENT;
- } /* while */
-
- // check fix_nodes results (IO_ERROR or NO_DISK_SPACE)
-- if (n_ret_value != CARRY_ON) {
-- if (n_is_inode_locked) {
-+ if (ret_value != CARRY_ON) {
-+ if (is_inode_locked) {
- // FIXME: this seems to be not needed: we are always able
- // to cut item
- indirect_to_direct_roll_back(th, inode, path);
- }
-- if (n_ret_value == NO_DISK_SPACE)
-+ if (ret_value == NO_DISK_SPACE)
- reiserfs_warning(sb, "reiserfs-5092",
- "NO_DISK_SPACE");
- unfix_nodes(&s_cut_balance);
-@@ -1629,24 +1625,24 @@ int reiserfs_cut_from_item(struct reiser
-
- /* go ahead and perform balancing */
-
-- RFALSE(c_mode == M_PASTE || c_mode == M_INSERT, "invalid mode");
-+ RFALSE(mode == M_PASTE || mode == M_INSERT, "invalid mode");
-
- /* Calculate number of bytes that need to be cut from the item. */
- quota_cut_bytes =
-- (c_mode ==
-+ (mode ==
- M_DELETE) ? ih_item_len(get_ih(path)) : -s_cut_balance.
- insert_size[0];
- if (retval2 == -1)
-- n_ret_value = calc_deleted_bytes_number(&s_cut_balance, c_mode);
-+ ret_value = calc_deleted_bytes_number(&s_cut_balance, mode);
- else
-- n_ret_value = retval2;
-+ ret_value = retval2;
-
- /* For direct items, we only change the quota when deleting the last
- ** item.
- */
- p_le_ih = PATH_PITEM_HEAD(s_cut_balance.tb_path);
- if (!S_ISLNK(inode->i_mode) && is_direct_le_ih(p_le_ih)) {
-- if (c_mode == M_DELETE &&
-+ if (mode == M_DELETE &&
- (le_ih_k_offset(p_le_ih) & (sb->s_blocksize - 1)) ==
- 1) {
- // FIXME: this is to keep 3.5 happy
-@@ -1657,7 +1653,7 @@ int reiserfs_cut_from_item(struct reiser
- }
- }
- #ifdef CONFIG_REISERFS_CHECK
-- if (n_is_inode_locked) {
-+ if (is_inode_locked) {
- struct item_head *le_ih =
- PATH_PITEM_HEAD(s_cut_balance.tb_path);
- /* we are going to complete indirect2direct conversion. Make
-@@ -1667,13 +1663,13 @@ int reiserfs_cut_from_item(struct reiser
- reiserfs_panic(sb, "vs-5652",
- "item must be indirect %h", le_ih);
-
-- if (c_mode == M_DELETE && ih_item_len(le_ih) != UNFM_P_SIZE)
-+ if (mode == M_DELETE && ih_item_len(le_ih) != UNFM_P_SIZE)
- reiserfs_panic(sb, "vs-5653", "completing "
- "indirect2direct conversion indirect "
- "item %h being deleted must be of "
- "4 byte long", le_ih);
-
-- if (c_mode == M_CUT
-+ if (mode == M_CUT
- && s_cut_balance.insert_size[0] != -UNFM_P_SIZE) {
- reiserfs_panic(sb, "vs-5654", "can not complete "
- "indirect2direct conversion of %h "
-@@ -1685,8 +1681,8 @@ int reiserfs_cut_from_item(struct reiser
- }
- #endif
-
-- do_balance(&s_cut_balance, NULL, NULL, c_mode);
-- if (n_is_inode_locked) {
-+ do_balance(&s_cut_balance, NULL, NULL, mode);
-+ if (is_inode_locked) {
- /* we've done an indirect->direct conversion. when the data block
- ** was freed, it was removed from the list of blocks that must
- ** be flushed before the transaction commits, make sure to
-@@ -1701,7 +1697,7 @@ int reiserfs_cut_from_item(struct reiser
- quota_cut_bytes, inode->i_uid, '?');
- #endif
- DQUOT_FREE_SPACE_NODIRTY(inode, quota_cut_bytes);
-- return n_ret_value;
-+ return ret_value;
- }
-
- static void truncate_directory(struct reiserfs_transaction_handle *th,
-@@ -1733,9 +1729,9 @@ int reiserfs_do_truncate(struct reiserfs
- INITIALIZE_PATH(s_search_path); /* Path to the current object item. */
- struct item_head *p_le_ih; /* Pointer to an item header. */
- struct cpu_key s_item_key; /* Key to search for a previous file item. */
-- loff_t n_file_size, /* Old file size. */
-- n_new_file_size; /* New file size. */
-- int n_deleted; /* Number of deleted or truncated bytes. */
-+ loff_t file_size, /* Old file size. */
-+ new_file_size; /* New file size. */
-+ int deleted; /* Number of deleted or truncated bytes. */
- int retval;
- int err = 0;
-
-@@ -1752,7 +1748,7 @@ int reiserfs_do_truncate(struct reiserfs
- }
-
- /* Get new file size. */
-- n_new_file_size = inode->i_size;
-+ new_file_size = inode->i_size;
-
- // FIXME: note, that key type is unimportant here
- make_cpu_key(&s_item_key, inode, max_reiserfs_offset(inode),
-@@ -1782,7 +1778,7 @@ int reiserfs_do_truncate(struct reiserfs
- /* Get real file size (total length of all file items) */
- p_le_ih = PATH_PITEM_HEAD(&s_search_path);
- if (is_statdata_le_ih(p_le_ih))
-- n_file_size = 0;
-+ file_size = 0;
- else {
- loff_t offset = le_ih_k_offset(p_le_ih);
- int bytes =
-@@ -1791,42 +1787,42 @@ int reiserfs_do_truncate(struct reiserfs
- /* this may mismatch with real file size: if last direct item
- had no padding zeros and last unformatted node had no free
- space, this file would have this file size */
-- n_file_size = offset + bytes - 1;
-+ file_size = offset + bytes - 1;
- }
- /*
- * are we doing a full truncate or delete, if so
- * kick in the reada code
- */
-- if (n_new_file_size == 0)
-+ if (new_file_size == 0)
- s_search_path.reada = PATH_READA | PATH_READA_BACK;
-
-- if (n_file_size == 0 || n_file_size < n_new_file_size) {
-+ if (file_size == 0 || file_size < new_file_size) {
- goto update_and_out;
- }
-
- /* Update key to search for the last file item. */
-- set_cpu_key_k_offset(&s_item_key, n_file_size);
-+ set_cpu_key_k_offset(&s_item_key, file_size);
-
- do {
- /* Cut or delete file item. */
-- n_deleted =
-+ deleted =
- reiserfs_cut_from_item(th, &s_search_path, &s_item_key,
-- inode, page, n_new_file_size);
-- if (n_deleted < 0) {
-+ inode, page, new_file_size);
-+ if (deleted < 0) {
- reiserfs_warning(inode->i_sb, "vs-5665",
- "reiserfs_cut_from_item failed");
- reiserfs_check_path(&s_search_path);
- return 0;
- }
-
-- RFALSE(n_deleted > n_file_size,
-+ RFALSE(deleted > file_size,
- "PAP-5670: reiserfs_cut_from_item: too many bytes deleted: deleted %d, file_size %lu, item_key %K",
-- n_deleted, n_file_size, &s_item_key);
-+ deleted, file_size, &s_item_key);
-
- /* Change key to search the last file item. */
-- n_file_size -= n_deleted;
-+ file_size -= deleted;
-
-- set_cpu_key_k_offset(&s_item_key, n_file_size);
-+ set_cpu_key_k_offset(&s_item_key, file_size);
-
- /* While there are bytes to truncate and previous file item is presented in the tree. */
-
-@@ -1857,13 +1853,13 @@ int reiserfs_do_truncate(struct reiserfs
- goto out;
- reiserfs_update_inode_transaction(inode);
- }
-- } while (n_file_size > ROUND_UP(n_new_file_size) &&
-+ } while (file_size > ROUND_UP(new_file_size) &&
- search_for_position_by_key(inode->i_sb, &s_item_key,
- &s_search_path) == POSITION_FOUND);
-
-- RFALSE(n_file_size > ROUND_UP(n_new_file_size),
-+ RFALSE(file_size > ROUND_UP(new_file_size),
- "PAP-5680: truncate did not finish: new_file_size %Ld, current %Ld, oid %d",
-- n_new_file_size, n_file_size, s_item_key.on_disk_key.k_objectid);
-+ new_file_size, file_size, s_item_key.on_disk_key.k_objectid);
-
- update_and_out:
- if (update_timestamps) {
-@@ -1918,7 +1914,7 @@ int reiserfs_paste_into_item(struct reis
- const struct cpu_key *key, /* Key to search for the needed item. */
- struct inode *inode, /* Inode item belongs to */
- const char *body, /* Pointer to the bytes to paste. */
-- int n_pasted_size)
-+ int pasted_size)
- { /* Size of pasted bytes. */
- struct tree_balance s_paste_balance;
- int retval;
-@@ -1931,16 +1927,16 @@ int reiserfs_paste_into_item(struct reis
- #ifdef REISERQUOTA_DEBUG
- reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
- "reiserquota paste_into_item(): allocating %u id=%u type=%c",
-- n_pasted_size, inode->i_uid,
-+ pasted_size, inode->i_uid,
- key2type(&(key->on_disk_key)));
- #endif
-
-- if (DQUOT_ALLOC_SPACE_NODIRTY(inode, n_pasted_size)) {
-+ if (DQUOT_ALLOC_SPACE_NODIRTY(inode, pasted_size)) {
- pathrelse(search_path);
- return -EDQUOT;
- }
- init_tb_struct(th, &s_paste_balance, th->t_super, search_path,
-- n_pasted_size);
-+ pasted_size);
- #ifdef DISPLACE_NEW_PACKING_LOCALITIES
- s_paste_balance.key = key->on_disk_key;
- #endif
-@@ -1988,10 +1984,10 @@ int reiserfs_paste_into_item(struct reis
- #ifdef REISERQUOTA_DEBUG
- reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
- "reiserquota paste_into_item(): freeing %u id=%u type=%c",
-- n_pasted_size, inode->i_uid,
-+ pasted_size, inode->i_uid,
- key2type(&(key->on_disk_key)));
- #endif
-- DQUOT_FREE_SPACE_NODIRTY(inode, n_pasted_size);
-+ DQUOT_FREE_SPACE_NODIRTY(inode, pasted_size);
- return retval;
- }
-
---- a/fs/reiserfs/tail_conversion.c
-+++ b/fs/reiserfs/tail_conversion.c
-@@ -26,7 +26,7 @@ int direct2indirect(struct reiserfs_tran
- converted item. */
- struct item_head ind_ih; /* new indirect item to be inserted or
- key of unfm pointer to be pasted */
-- int n_blk_size, n_retval; /* returned value for reiserfs_insert_item and clones */
-+ int blk_size, retval; /* returned value for reiserfs_insert_item and clones */
- unp_t unfm_ptr; /* Handle on an unformatted node
- that will be inserted in the
- tree. */
-@@ -35,7 +35,7 @@ int direct2indirect(struct reiserfs_tran
-
- REISERFS_SB(sb)->s_direct2indirect++;
-
-- n_blk_size = sb->s_blocksize;
-+ blk_size = sb->s_blocksize;
-
- /* and key to search for append or insert pointer to the new
- unformatted node. */
-@@ -64,17 +64,17 @@ int direct2indirect(struct reiserfs_tran
- set_ih_free_space(&ind_ih, 0); /* delete at nearest future */
- put_ih_item_len(&ind_ih, UNFM_P_SIZE);
- PATH_LAST_POSITION(path)++;
-- n_retval =
-+ retval =
- reiserfs_insert_item(th, path, &end_key, &ind_ih, inode,
- (char *)&unfm_ptr);
- } else {
- /* Paste into last indirect item of an object. */
-- n_retval = reiserfs_paste_into_item(th, path, &end_key, inode,
-+ retval = reiserfs_paste_into_item(th, path, &end_key, inode,
- (char *)&unfm_ptr,
- UNFM_P_SIZE);
- }
-- if (n_retval) {
-- return n_retval;
-+ if (retval) {
-+ return retval;
- }
- // note: from here there are two keys which have matching first
- // three key components. They only differ by the fourth one.
-@@ -98,7 +98,7 @@ int direct2indirect(struct reiserfs_tran
- RFALSE(!is_direct_le_ih(p_le_ih),
- "vs-14055: direct item expected(%K), found %h",
- &end_key, p_le_ih);
-- tail_size = (le_ih_k_offset(p_le_ih) & (n_blk_size - 1))
-+ tail_size = (le_ih_k_offset(p_le_ih) & (blk_size - 1))
- + ih_item_len(p_le_ih) - 1;
-
- /* we only send the unbh pointer if the buffer is not up to date.
-@@ -113,11 +113,11 @@ int direct2indirect(struct reiserfs_tran
- } else {
- up_to_date_bh = unbh;
- }
-- n_retval = reiserfs_delete_item(th, path, &end_key, inode,
-+ retval = reiserfs_delete_item(th, path, &end_key, inode,
- up_to_date_bh);
-
-- total_tail += n_retval;
-- if (tail_size == n_retval)
-+ total_tail += retval;
-+ if (tail_size == retval)
- // done: file does not have direct items anymore
- break;
-
-@@ -129,7 +129,7 @@ int direct2indirect(struct reiserfs_tran
- unsigned pgoff =
- (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
- char *kaddr = kmap_atomic(up_to_date_bh->b_page, KM_USER0);
-- memset(kaddr + pgoff, 0, n_blk_size - total_tail);
-+ memset(kaddr + pgoff, 0, blk_size - total_tail);
- kunmap_atomic(kaddr, KM_USER0);
- }
-
-@@ -181,7 +181,7 @@ int indirect2direct(struct reiserfs_tran
- {
- struct super_block *sb = inode->i_sb;
- struct item_head s_ih;
-- unsigned long n_block_size = sb->s_blocksize;
-+ unsigned long block_size = sb->s_blocksize;
- char *tail;
- int tail_len, round_tail_len;
- loff_t pos, pos1; /* position of first byte of the tail */
-@@ -196,7 +196,7 @@ int indirect2direct(struct reiserfs_tran
- /* store item head path points to. */
- copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
-
-- tail_len = (n_new_file_size & (n_block_size - 1));
-+ tail_len = (n_new_file_size & (block_size - 1));
- if (get_inode_sd_version(inode) == STAT_DATA_V2)
- round_tail_len = ROUND_UP(tail_len);
- else
-@@ -257,7 +257,7 @@ int indirect2direct(struct reiserfs_tran
- unformatted node. For now i_size is considered as guard for
- going out of file size */
- kunmap(page);
-- return n_block_size - round_tail_len;
-+ return block_size - round_tail_len;
- }
- kunmap(page);
-
-@@ -276,5 +276,5 @@ int indirect2direct(struct reiserfs_tran
- /* mark_file_with_tail (inode, pos1 + 1); */
- REISERFS_I(inode)->i_first_direct_byte = pos1 + 1;
-
-- return n_block_size - round_tail_len;
-+ return block_size - round_tail_len;
- }
projects / people / pmueller / ipfire-2.x.git / blobdiff