cleanup: remove unnecessary fs pointer passed with buffer_infos

There are a bunch of leaf helpers that accept a reiserfs_filsys_t when
one is passed via the buffer_info.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>

4 files changed, 114 insertions, 148 deletions

diff --git a/include/reiserfs_fs.h b/include/reiserfs_fs.h
index 1f2acbc..a05ea60 100644
--- a/include/reiserfs_fs.h
+++ b/include/reiserfs_fs.h
@@ -1481,14 +1481,15 @@ int leaf_move_items (int shift_mode, struct tree_balance * tb,
                      int mov_num, int mov_bytes, struct buffer_head * Snew);
 int leaf_shift_left (struct tree_balance * tb, int shift_num, int shift_bytes);
 int leaf_shift_right (struct tree_balance * tb, int shift_num, int shift_bytes);
-void leaf_delete_items (reiserfs_filsys_t *, struct buffer_info * cur_bi,
-                        int last_first, int first, int del_num, int del_bytes);
-void leaf_insert_into_buf (reiserfs_filsys_t *, struct buffer_info * bi,
-			   int before, struct item_head * inserted_item_ih, const char * inserted_item_body,
-			   int zeros_number);
-void leaf_paste_in_buffer (reiserfs_filsys_t *, struct buffer_info * bi, int pasted_item_num,
-			   int pos_in_item, int paste_size, const char * body, int zeros_number);
-void leaf_cut_from_buffer (reiserfs_filsys_t *, struct buffer_info * bi, int cut_item_num,
+void leaf_delete_items(struct buffer_info *cur_bi, int last_first, int first,
+		       int del_num, int del_bytes);
+void leaf_insert_into_buf(struct buffer_info *bi, int before,
+			  struct item_head * inserted_item_ih,
+			  const char * inserted_item_body, int zeros_number);
+void leaf_paste_in_buffer(struct buffer_info *bi, int pasted_item_num,
+			  int pos_in_item, int paste_size, const char * body,
+			  int zeros_number);
+void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,
                            int pos_in_item, int cut_size);
 void leaf_paste_entries (struct buffer_head * bh, int item_num, int before, int new_entry_count,
 			 struct reiserfs_de_head * new_dehs, const char * records,
diff --git a/reiserfscore/do_balan.c b/reiserfscore/do_balan.c
index 3453380..5331d97 100644
--- a/reiserfscore/do_balan.c
+++ b/reiserfscore/do_balan.c
@@ -66,7 +66,7 @@ static int balance_leaf_when_delete(	/*struct reiserfs_transaction_handle *th, *
 	switch (flag) {
 	case M_DELETE:		/* delete item in S[0] */
 
-		leaf_delete_items(tb->tb_fs, &bi, 0, item_pos, 1, -1);
+		leaf_delete_items(&bi, 0, item_pos, 1, -1);
 
 		if (!item_pos) {
 			// we have removed first item in the node - update left delimiting key
@@ -91,7 +91,7 @@ static int balance_leaf_when_delete(	/*struct reiserfs_transaction_handle *th, *
 				/* when we cut a directory tb->insert_size[0] means number
 				   of entries to be cut (always 1) */
 				tb->insert_size[0] = -1;
-				leaf_cut_from_buffer(tb->tb_fs, &bi, item_pos,
+				leaf_cut_from_buffer(&bi, item_pos,
 						     pos_in_item,
 						     -tb->insert_size[0]);
 
@@ -100,7 +100,7 @@ static int balance_leaf_when_delete(	/*struct reiserfs_transaction_handle *th, *
 						    tb->lkey[0], tbS0, 0);
 				}
 			} else {
-				leaf_cut_from_buffer(tb->tb_fs, &bi, item_pos,
+				leaf_cut_from_buffer(&bi, item_pos,
 						     pos_in_item,
 						     -tb->insert_size[0]);
 			}
@@ -266,7 +266,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 							new_item_len);
 					/* Insert new item into L[0] */
 					buffer_info_init_left(tb, &bi, 0);
-					leaf_insert_into_buf(tb->tb_fs, &bi,
+					leaf_insert_into_buf(&bi,
 							     n + item_pos -
 							     ret_val, ih, body,
 							     zeros_number >
@@ -300,7 +300,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 
 					/* Insert new item into L[0] */
 					buffer_info_init_left(tb, &bi, 0);
-					leaf_insert_into_buf(tb->tb_fs, &bi,
+					leaf_insert_into_buf(&bi,
 							     n + item_pos -
 							     ret_val, ih, body,
 							     zeros_number);
@@ -355,7 +355,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 							/* Append given directory entry to directory item */
 							buffer_info_init_left(tb, &bi, 0);
 							leaf_paste_in_buffer
-							    (tb->tb_fs, &bi,
+							    (&bi,
 							     n + item_pos -
 							     ret_val,
 							     l_pos_in_item,
@@ -428,7 +428,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 							/* Append to body of item in L[0] */
 							buffer_info_init_left(tb, &bi, 0);
 							leaf_paste_in_buffer
-							    (tb->tb_fs, &bi,
+							    (&bi,
 							     n + item_pos -
 							     ret_val,
 							     get_ih_item_len
@@ -528,7 +528,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 							    tb->lbytes);
 					/* Append to body of item in L[0] */
 					buffer_info_init_left(tb, &bi, 0);
-					leaf_paste_in_buffer(tb->tb_fs, &bi,
+					leaf_paste_in_buffer(&bi,
 							     n + item_pos -
 							     ret_val,
 							     pos_in_item,
@@ -633,7 +633,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 						zeros_number -= r_zeros_number;
 					}
 
-					leaf_insert_into_buf(tb->tb_fs, &bi, 0,
+					leaf_insert_into_buf(&bi, 0,
 							     ih, r_body,
 							     r_zeros_number);
 
@@ -662,7 +662,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 
 					/* Insert new item into R[0] */
 					buffer_info_init_right(tb, &bi, 0);
-					leaf_insert_into_buf(tb->tb_fs, &bi,
+					leaf_insert_into_buf(&bi,
 							     item_pos - n +
 							     tb->rnum[0] - 1,
 							     ih, body,
@@ -720,7 +720,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 
 							buffer_info_init_right(tb, &bi, 0);
 							leaf_paste_in_buffer
-							    (tb->tb_fs, &bi, 0,
+							    (&bi, 0,
 							     paste_entry_position,
 							     tb->insert_size[0],
 							     body,
@@ -852,8 +852,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 							    r_zeros_number;
 						}
 
-						leaf_paste_in_buffer(tb->tb_fs,
-								     &bi, 0,
+						leaf_paste_in_buffer(&bi, 0,
 								     n_shift,
 								     tb->
 								     insert_size
@@ -886,8 +885,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 					/* append item in R[0] */
 					if (pos_in_item >= 0) {
 						buffer_info_init_right(tb, &bi, 0);
-						leaf_paste_in_buffer(tb->tb_fs,
-								     &bi,
+						leaf_paste_in_buffer(&bi,
 								     item_pos -
 								     n +
 								     tb->
@@ -1040,8 +1038,8 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 						zeros_number -= r_zeros_number;
 					}
 
-					leaf_insert_into_buf(tb->tb_fs, &bi, 0,
-							     ih, r_body,
+					leaf_insert_into_buf(&bi, 0, ih,
+							     r_body,
 							     r_zeros_number);
 
 					/* Calculate key component and item length to insert into S[i] */
@@ -1060,7 +1058,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 
 					/* Insert new item into S_new[i] */
 					buffer_info_init_bh(tb, &bi, S_new[i]);
-					leaf_insert_into_buf(tb->tb_fs, &bi,
+					leaf_insert_into_buf(&bi,
 							     item_pos - n +
 							     snum[i] - 1, ih,
 							     body,
@@ -1108,7 +1106,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 							/* Paste given directory entry to directory item */
 							buffer_info_init_bh(tb, &bi, S_new[i]);
 							leaf_paste_in_buffer
-							    (tb->tb_fs, &bi, 0,
+							    (&bi, 0,
 							     pos_in_item -
 							     entry_count +
 							     sbytes[i] - 1,
@@ -1187,8 +1185,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 							    r_zeros_number;
 						}
 
-						leaf_paste_in_buffer(tb->tb_fs,
-								     &bi, 0,
+						leaf_paste_in_buffer(&bi, 0,
 								     n_shift,
 								     tb->
 								     insert_size
@@ -1246,7 +1243,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 							S_new[i]);
 					/* paste into item */
 					buffer_info_init_bh(tb, &bi, S_new[i]);
-					leaf_paste_in_buffer(tb->tb_fs, &bi,
+					leaf_paste_in_buffer(&bi,
 							     item_pos - n +
 							     snum[i],
 							     pos_in_item,
@@ -1308,7 +1305,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 		switch (flag) {
 		case M_INSERT:	/* insert item into S[0] */
 			buffer_info_init_tbS0(tb, &bi);
-			leaf_insert_into_buf(tb->tb_fs, &bi, item_pos, ih, body,
+			leaf_insert_into_buf(&bi, item_pos, ih, body,
 					     zeros_number);
 
 			/* If we insert the first key change the delimiting key */
@@ -1330,8 +1327,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 					    get_ih_entry_count(pasted)) {
 						/* prepare space */
 						buffer_info_init_tbS0(tb, &bi);
-						leaf_paste_in_buffer(tb->tb_fs,
-								     &bi,
+						leaf_paste_in_buffer(&bi,
 								     item_pos,
 								     pos_in_item,
 								     tb->
@@ -1371,8 +1367,7 @@ static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
 					if (pos_in_item ==
 					    get_ih_item_len(pasted)) {
 						buffer_info_init_tbS0(tb, &bi);
-						leaf_paste_in_buffer(tb->tb_fs,
-								     &bi,
+						leaf_paste_in_buffer(&bi,
 								     item_pos,
 								     pos_in_item,
 								     tb->
diff --git a/reiserfscore/ibalance.c b/reiserfscore/ibalance.c
index 00dd300..9e1a69e 100644
--- a/reiserfscore/ibalance.c
+++ b/reiserfscore/ibalance.c
@@ -71,8 +71,7 @@ static void internal_define_dest_src_infos(int shift_mode,
  * Insert count items into buffer cur before position to.
  * Items and node pointers are specified by inserted and bh respectively.
  */
-static void internal_insert_childs(reiserfs_filsys_t *fs,
-				   struct buffer_info *cur_bi,
+static void internal_insert_childs(struct buffer_info *cur_bi,
 				   int to, int count,
 				   struct item_head *inserted,
 				   struct buffer_head **bh)
@@ -142,8 +141,7 @@ static void internal_insert_childs(reiserfs_filsys_t *fs,
 
 /* Delete del_num items and node pointers from buffer cur starting from *
  * the first_i'th item and first_p'th pointers respectively.		*/
-static void internal_delete_pointers_items(reiserfs_filsys_t *fs,
-					   struct buffer_info *cur_bi,
+static void internal_delete_pointers_items(struct buffer_info *cur_bi,
 					   int first_p, int first_i,
 					   int del_num)
 {
@@ -190,25 +188,24 @@ static void internal_delete_pointers_items(reiserfs_filsys_t *fs,
 }
 
 /* delete n node pointers and items starting from given position */
-static void internal_delete_childs(reiserfs_filsys_t *fs,
-				   struct buffer_info *cur_bi, int from, int n)
+static void internal_delete_childs(struct buffer_info *cur_bi, int from, int n)
 {
-	int i_from;
+	int i_from = 0;
 
-	i_from = (from == 0) ? from : from - 1;
+	if (from)
+		i_from = from - 1;
 
 	/* delete n pointers starting from `from' position in CUR;
 	   delete n keys starting from 'i_from' position in CUR;
 	 */
-	internal_delete_pointers_items(fs, cur_bi, from, i_from, n);
+	internal_delete_pointers_items(cur_bi, from, i_from, n);
 }
 
 /* copy cpy_num node pointers and cpy_num - 1 items from buffer src to buffer dest
 * last_first == FIRST_TO_LAST means, that we copy first items from src to tail of dest
  * last_first == LAST_TO_FIRST means, that we copy last items from src to head of dest
  */
-static void internal_copy_pointers_items(reiserfs_filsys_t *fs,
-					 struct buffer_info *dest_bi,
+static void internal_copy_pointers_items(struct buffer_info *dest_bi,
 					 struct buffer_head *src,
 					 int last_first, int cpy_num)
 {
@@ -277,8 +274,7 @@ static void internal_copy_pointers_items(reiserfs_filsys_t *fs,
  * last_first == FIRST_TO_LAST means, that we copy/delete first items from src.
  * last_first == LAST_TO_FIRST means, that we copy/delete last items from src.
  */
-static void internal_move_pointers_items(reiserfs_filsys_t *fs,
-					 struct buffer_info *dest_bi,
+static void internal_move_pointers_items(struct buffer_info *dest_bi,
 					 struct buffer_info *src_bi,
 					 int last_first, int cpy_num,
 					 int del_par)
@@ -286,7 +282,7 @@ static void internal_move_pointers_items(reiserfs_filsys_t *fs,
 	int first_pointer;
 	int first_item;
 
-	internal_copy_pointers_items(fs, dest_bi, src_bi->bi_bh, last_first,
+	internal_copy_pointers_items(dest_bi, src_bi->bi_bh, last_first,
 				     cpy_num);
 
 	if (last_first == FIRST_TO_LAST) {	/* shift_left occurs */
@@ -294,7 +290,7 @@ static void internal_move_pointers_items(reiserfs_filsys_t *fs,
 		first_item = 0;
 		/* delete cpy_num - del_par pointers and keys starting for pointers with first_pointer,
 		   for key - with first_item */
-		internal_delete_pointers_items(fs, src_bi, first_pointer,
+		internal_delete_pointers_items(src_bi, first_pointer,
 					       first_item, cpy_num - del_par);
 	} else {		/* shift_right occurs */
 		int i, j;
@@ -304,14 +300,14 @@ static void internal_move_pointers_items(reiserfs_filsys_t *fs,
 		      B_NR_ITEMS(src_bi->bi_bh)) + 1) ? 0 : j - cpy_num +
 		    del_par;
 
-		internal_delete_pointers_items(fs, src_bi,
+		internal_delete_pointers_items(src_bi,
 					       j + 1 - cpy_num + del_par, i,
 					       cpy_num - del_par);
 	}
 }
 
 /* Insert n_src'th key of buffer src before n_dest'th key of buffer dest. */
-static void internal_insert_key(reiserfs_filsys_t *fs, struct buffer_info *dest_bi, int dest_position_before,	/* insert key before key with n_dest number */
+static void internal_insert_key(struct buffer_info *dest_bi, int dest_position_before,	/* insert key before key with n_dest number */
 				struct buffer_head *src, int src_position)
 {
 	struct buffer_head *dest = dest_bi->bi_bh;
@@ -366,8 +362,7 @@ static void internal_shift_left(int mode,	/* INTERNAL_FROM_S_TO_L | INTERNAL_FRO
 
 	if (pointer_amount) {
 		/* insert delimiting key from common father of dest and src to node dest into position B_NR_ITEM(dest) */
-		internal_insert_key(tb->tb_fs, &dest_bi,
-				    B_NR_ITEMS(dest_bi.bi_bh), cf,
+		internal_insert_key(&dest_bi, B_NR_ITEMS(dest_bi.bi_bh), cf,
 				    d_key_position);
 
 		if (B_NR_ITEMS(src_bi.bi_bh) == pointer_amount - 1) {
@@ -380,8 +375,8 @@ static void internal_shift_left(int mode,	/* INTERNAL_FROM_S_TO_L | INTERNAL_FRO
 				    pointer_amount - 1);
 	}
 	/* last parameter is del_parameter */
-	internal_move_pointers_items(tb->tb_fs, &dest_bi, &src_bi,
-				     FIRST_TO_LAST, pointer_amount, 0);
+	internal_move_pointers_items(&dest_bi, &src_bi, FIRST_TO_LAST,
+				     pointer_amount, 0);
 
 }
 
@@ -401,13 +396,12 @@ static void internal_shift1_left(struct tree_balance *tb,
 				       &dest_bi, &src_bi, &d_key_position, &cf);
 
 	if (pointer_amount > 0)	/* insert lkey[h]-th key  from CFL[h] to left neighbor L[h] */
-		internal_insert_key(tb->tb_fs, &dest_bi,
-				    B_NR_ITEMS(dest_bi.bi_bh), cf,
+		internal_insert_key(&dest_bi, B_NR_ITEMS(dest_bi.bi_bh), cf,
 				    d_key_position);
 
 	/* last parameter is del_parameter */
-	internal_move_pointers_items(tb->tb_fs, &dest_bi, &src_bi,
-				     FIRST_TO_LAST, pointer_amount, 1);
+	internal_move_pointers_items(&dest_bi, &src_bi, FIRST_TO_LAST,
+				     pointer_amount, 1);
 }
 
 /* Insert d_key'th (delimiting) key from buffer cfr to head of dest.
@@ -431,7 +425,7 @@ static void internal_shift_right(int mode,	/* INTERNAL_FROM_S_TO_R | INTERNAL_FR
 
 	if (pointer_amount > 0) {
 		/* insert delimiting key from common father of dest and src to dest node into position 0 */
-		internal_insert_key(tb->tb_fs, &dest_bi, 0, cf, d_key_position);
+		internal_insert_key(&dest_bi, 0, cf, d_key_position);
 		if (nr == pointer_amount - 1) {
 			/* when S[h] disappers replace left delemiting key as well */
 			if (tb->CFL[h])
@@ -443,8 +437,8 @@ static void internal_shift_right(int mode,	/* INTERNAL_FROM_S_TO_R | INTERNAL_FR
 	}
 
 	/* last parameter is del_parameter */
-	internal_move_pointers_items(tb->tb_fs, &dest_bi, &src_bi,
-				     LAST_TO_FIRST, pointer_amount, 0);
+	internal_move_pointers_items(&dest_bi, &src_bi, LAST_TO_FIRST,
+				     pointer_amount, 0);
 }
 
 /* Insert delimiting key to R[h].
@@ -463,11 +457,11 @@ static void internal_shift1_right(struct tree_balance *tb,
 				       &dest_bi, &src_bi, &d_key_position, &cf);
 
 	if (pointer_amount > 0)	/* insert rkey from CFR[h] to right neighbor R[h] */
-		internal_insert_key(tb->tb_fs, &dest_bi, 0, cf, d_key_position);
+		internal_insert_key(&dest_bi, 0, cf, d_key_position);
 
 	/* last parameter is del_parameter */
-	internal_move_pointers_items(tb->tb_fs, &dest_bi, &src_bi,
-				     LAST_TO_FIRST, pointer_amount, 1);
+	internal_move_pointers_items(&dest_bi, &src_bi, LAST_TO_FIRST,
+				     pointer_amount, 1);
 }
 
 /* Delete insert_num node pointers together with their left items
@@ -484,7 +478,7 @@ static void balance_internal_when_delete(struct tree_balance *tb,
 
 	/* delete child-node-pointer(s) together with their left item(s) */
 	buffer_info_init_tbSh(tb, &bi, h);
-	internal_delete_childs(tb->tb_fs, &bi, child_pos, -insert_num);
+	internal_delete_childs(&bi, child_pos, -insert_num);
 
 	n = B_NR_ITEMS(tbSh);
 
@@ -631,9 +625,7 @@ int balance_internal(struct tree_balance *tb,	/* tree_balance structure
 
 			/* insert insert_num keys and node-pointers into L[h] */
 			buffer_info_init_left(tb, &bi, h);
-			internal_insert_childs(tb->tb_fs, &bi,
-					       /*tb->L[h], tb->S[h-1]->b_next */
-					       n + child_pos + 1,
+			internal_insert_childs(&bi, n + child_pos + 1,
 					       insert_num, insert_key,
 					       insert_ptr);
 
@@ -647,9 +639,7 @@ int balance_internal(struct tree_balance *tb,	/* tree_balance structure
 			k = tb->lnum[h] - child_pos - 1;
 
 			buffer_info_init_left(tb, &bi, h);
-			internal_insert_childs(tb->tb_fs, &bi,
-					       /*tb->L[h], tb->S[h-1]->b_next, */
-					       n + child_pos + 1, k,
+			internal_insert_childs(&bi, n + child_pos + 1, k,
 					       insert_key, insert_ptr);
 
 			replace_lkey(tb, h, insert_key + k);
@@ -691,8 +681,7 @@ int balance_internal(struct tree_balance *tb,	/* tree_balance structure
 
 			/* insert insert_num keys and node-pointers into R[h] */
 			buffer_info_init_right(tb, &bi, h);
-			internal_insert_childs(tb->tb_fs, &bi,
-					       /*tb->R[h],tb->S[h-1]->b_next */
+			internal_insert_childs(&bi,
 					       child_pos - n - insert_num +
 					       tb->rnum[h] - 1,
 					       insert_num, insert_key,
@@ -707,9 +696,7 @@ int balance_internal(struct tree_balance *tb,	/* tree_balance structure
 			k = tb->rnum[h] - n + child_pos - 1;
 
 			buffer_info_init_right(tb, &bi, h);
-			internal_insert_childs(tb->tb_fs, &bi,
-					       /*tb->R[h], tb->R[h]->b_child, */
-					       0, k, insert_key + 1,
+			internal_insert_childs(&bi, 0, k, insert_key + 1,
 					       insert_ptr + 1);
 
 			replace_rkey(tb, h, insert_key + insert_num - k - 1);
@@ -806,8 +793,8 @@ int balance_internal(struct tree_balance *tb,	/* tree_balance structure
 			memcpy(&new_insert_key, internal_key(tbSh, n - snum),
 			       KEY_SIZE);
 			/* last parameter is del_par */
-			internal_move_pointers_items(tb->tb_fs, &dest_bi,
-						     &src_bi, LAST_TO_FIRST,
+			internal_move_pointers_items(&dest_bi, &src_bi,
+						     LAST_TO_FIRST,
 						     snum, 0);
 		} else if (n + insert_num - snum < child_pos) {
 			/* all new items fall into S_new */
@@ -817,14 +804,13 @@ int balance_internal(struct tree_balance *tb,	/* tree_balance structure
 			       internal_key(tbSh, n + insert_num - snum),
 			       KEY_SIZE);
 			/* last parameter is del_par */
-			internal_move_pointers_items(tb->tb_fs, &dest_bi,
-						     &src_bi, LAST_TO_FIRST,
+			internal_move_pointers_items(&dest_bi, &src_bi,
+						     LAST_TO_FIRST,
 						     snum - insert_num, 0);
 			/*                  internal_move_pointers_items(S_new,tbSh,1,snum - insert_num,0); */
 
 			/* insert insert_num keys and node-pointers into S_new */
-			internal_insert_childs(tb->tb_fs, &dest_bi,
-					       /*S_new,tb->S[h-1]->b_next, */
+			internal_insert_childs(&dest_bi,
 					       child_pos - n - insert_num +
 					       snum - 1,
 					       insert_num, insert_key,
@@ -836,15 +822,14 @@ int balance_internal(struct tree_balance *tb,	/* tree_balance structure
 
 			/* some items fall into S_new, but some don't fall */
 			/* last parameter is del_par */
-			internal_move_pointers_items(tb->tb_fs, &dest_bi,
-						     &src_bi, LAST_TO_FIRST,
+			internal_move_pointers_items(&dest_bi, &src_bi,
+						     LAST_TO_FIRST,
 						     n - child_pos + 1, 1);
 			/*                  internal_move_pointers_items(S_new,tbSh,1,n - child_pos + 1,1); */
 			/* calculate number of new items that fall into S_new */
 			k = snum - n + child_pos - 1;
 
-			internal_insert_childs(tb->tb_fs, &dest_bi, /*S_new, */
-					       0, k, insert_key + 1,
+			internal_insert_childs(&dest_bi, 0, k, insert_key + 1,
 					       insert_ptr + 1);
 
 			/* new_insert_key = insert_key[insert_num - k - 1] */
@@ -887,15 +872,13 @@ int balance_internal(struct tree_balance *tb,	/* tree_balance structure
 			if (tb->CFL[h - 1] || insert_num != 1 || h != 1)
 				die("balance_internal: invalid child_pos");
 			/* insert_child (tb->S[h], tb->S[h-1], child_pos, insert_num, B_N_ITEM_HEAD(tb->S[0],0), insert_ptr); */
-			internal_insert_childs(tb->tb_fs, &bi, child_pos,
-					       insert_num,
+			internal_insert_childs(&bi, child_pos, insert_num,
 					       item_head(PATH_PLAST_BUFFER
 							      (tb->tb_path), 0),
 					       insert_ptr);
 		} else
-			internal_insert_childs(tb->tb_fs, &bi, child_pos,
-					       insert_num, insert_key,
-					       insert_ptr);
+			internal_insert_childs(&bi, child_pos, insert_num,
+					       insert_key, insert_ptr);
 	}
 
 	memcpy(new_insert_key_addr, &new_insert_key, KEY_SIZE);
diff --git a/reiserfscore/lbalance.c b/reiserfscore/lbalance.c
index fe89a65..c477fa7 100644
--- a/reiserfscore/lbalance.c
+++ b/reiserfscore/lbalance.c
@@ -23,8 +23,7 @@ extern int init_pos_in_item;
 extern int init_mode;
 
 /* copy copy_count entries from source directory item to dest buffer (creating new item if needed) */
-static void leaf_copy_dir_entries(reiserfs_filsys_t *fs,
-				  struct buffer_info *dest_bi,
+static void leaf_copy_dir_entries(struct buffer_info *dest_bi,
 				  struct buffer_head *source, int last_first,
 				  int item_num, int from, int copy_count)
 {
@@ -98,13 +97,13 @@ static void leaf_copy_dir_entries(reiserfs_filsys_t *fs,
 		set_ih_flags(&new_ih, get_ih_flags(ih));
 
 		/* insert item into dest buffer */
-		leaf_insert_into_buf(fs, dest_bi,
+		leaf_insert_into_buf(dest_bi,
 				     (last_first ==
 				      LAST_TO_FIRST) ? 0 : B_NR_ITEMS(dest),
 				     &new_ih, NULL, 0);
 	} else {
 		/* prepare space for entries */
-		leaf_paste_in_buffer(fs, dest_bi,
+		leaf_paste_in_buffer(dest_bi,
 				     (last_first ==
 				      FIRST_TO_LAST) ? (B_NR_ITEMS(dest) -
 							1) : 0,
@@ -129,8 +128,7 @@ static void leaf_copy_dir_entries(reiserfs_filsys_t *fs,
    part of it or nothing (see the return 0 below) from SOURCE to the end
    (if last_first) or beginning (!last_first) of the DEST */
 /* returns 1 if anything was copied, else 0 */
-static int leaf_copy_boundary_item(reiserfs_filsys_t *fs,
-				   struct buffer_info *dest_bi,
+static int leaf_copy_boundary_item(struct buffer_info *dest_bi,
 				   struct buffer_head *src, int last_first,
 				   int bytes_or_entries)
 {
@@ -156,7 +154,7 @@ static int leaf_copy_boundary_item(reiserfs_filsys_t *fs,
 			if (bytes_or_entries == -1)
 				/* copy all entries to dest */
 				bytes_or_entries = get_ih_entry_count(ih);
-			leaf_copy_dir_entries(fs, dest_bi, src, FIRST_TO_LAST,
+			leaf_copy_dir_entries(dest_bi, src, FIRST_TO_LAST,
 					      0, 0, bytes_or_entries);
 			return 1;
 		}
@@ -169,7 +167,7 @@ static int leaf_copy_boundary_item(reiserfs_filsys_t *fs,
 
 		/* merge first item (or its part) of src buffer with the last
 		   item of dest buffer. Both are of the same file */
-		leaf_paste_in_buffer(fs, dest_bi, dest_nr_item - 1,
+		leaf_paste_in_buffer(dest_bi, dest_nr_item - 1,
 				     get_ih_item_len(dih), bytes_or_entries,
 				     ih_item_body(src, ih), 0);
 
@@ -199,7 +197,7 @@ static int leaf_copy_boundary_item(reiserfs_filsys_t *fs,
 			/* bytes_or_entries = entries number in last item body of SOURCE */
 			bytes_or_entries = get_ih_entry_count(ih);
 
-		leaf_copy_dir_entries(fs, dest_bi, src, LAST_TO_FIRST,
+		leaf_copy_dir_entries(dest_bi, src, LAST_TO_FIRST,
 				      src_nr_item - 1,
 				      get_ih_entry_count(ih) - bytes_or_entries,
 				      bytes_or_entries);
@@ -241,7 +239,7 @@ static int leaf_copy_boundary_item(reiserfs_filsys_t *fs,
 		}
 	}
 
-	leaf_paste_in_buffer(fs, dest_bi, 0, 0, bytes_or_entries,
+	leaf_paste_in_buffer(dest_bi, 0, 0, bytes_or_entries,
 			     ih_item_body(src,
 				       ih) + get_ih_item_len(ih) -
 			     bytes_or_entries, 0);
@@ -252,8 +250,7 @@ static int leaf_copy_boundary_item(reiserfs_filsys_t *fs,
  * last_first == FIRST_TO_LAST means, that we copy cpy_num  items beginning from first-th item in src to tail of dest
  * last_first == LAST_TO_FIRST means, that we copy cpy_num  items beginning from first-th item in src to head of dest
  */
-static void leaf_copy_items_entirely(reiserfs_filsys_t *fs,
-				     struct buffer_info *dest_bi,
+static void leaf_copy_items_entirely(struct buffer_info *dest_bi,
 				     struct buffer_head *src, int last_first,
 				     int first, int cpy_num)
 {
@@ -329,8 +326,7 @@ static void leaf_copy_items_entirely(reiserfs_filsys_t *fs,
 
 /* This function splits the (liquid) item into two items (useful when
    shifting part of an item into another node.) */
-static void leaf_item_bottle(reiserfs_filsys_t *fs,
-			     struct buffer_info *dest_bi,
+static void leaf_item_bottle(struct buffer_info *dest_bi,
 			     struct buffer_head *src, int last_first,
 			     int item_num, int cpy_bytes)
 {
@@ -340,7 +336,7 @@ static void leaf_item_bottle(reiserfs_filsys_t *fs,
 	if (last_first == FIRST_TO_LAST) {
 		/* if ( if item in position item_num in buffer SOURCE is directory item ) */
 		if (I_IS_DIRECTORY_ITEM(ih = item_head(src, item_num)))
-			leaf_copy_dir_entries(fs, dest_bi, src, FIRST_TO_LAST,
+			leaf_copy_dir_entries(dest_bi, src, FIRST_TO_LAST,
 					      item_num, 0, cpy_bytes);
 		else {
 			struct item_head n_ih;
@@ -358,14 +354,14 @@ static void leaf_item_bottle(reiserfs_filsys_t *fs,
 			//n_ih.ih_version = ih->ih_version;
 			set_ih_key_format(&n_ih, get_ih_key_format(ih));
 			set_ih_flags(&n_ih, get_ih_flags(ih));
-			leaf_insert_into_buf(fs, dest_bi, B_NR_ITEMS(dest),
+			leaf_insert_into_buf(dest_bi, B_NR_ITEMS(dest),
 					     &n_ih, item_body(src, item_num),
 					     0);
 		}
 	} else {
 		/*  if ( if item in position item_num in buffer SOURCE is directory item ) */
 		if (I_IS_DIRECTORY_ITEM(ih = item_head(src, item_num)))
-			leaf_copy_dir_entries(fs, dest_bi, src, LAST_TO_FIRST,
+			leaf_copy_dir_entries(dest_bi, src, LAST_TO_FIRST,
 					      item_num,
 					      get_ih_entry_count(ih) -
 					      cpy_bytes, cpy_bytes);
@@ -410,7 +406,7 @@ static void leaf_item_bottle(reiserfs_filsys_t *fs,
 			//n_ih.ih_version = ih->ih_version;
 			set_ih_key_format(&n_ih, get_ih_key_format(ih));
 			set_ih_flags(&n_ih, get_ih_flags(ih));
-			leaf_insert_into_buf(fs, dest_bi, 0, &n_ih,
+			leaf_insert_into_buf(dest_bi, 0, &n_ih,
 					     item_body(src,
 						       item_num) +
 					     get_ih_item_len(ih) - cpy_bytes,
@@ -423,8 +419,7 @@ static void leaf_item_bottle(reiserfs_filsys_t *fs,
    If cpy_bytes not equal to minus one than copy cpy_num-1 whole items from SOURCE to DEST.
    From last item copy cpy_num bytes for regular item and cpy_num directory entries for
    directory item. */
-static int leaf_copy_items(reiserfs_filsys_t *fs,
-			   struct buffer_info *dest_bi, struct buffer_head *src,
+static int leaf_copy_items(struct buffer_info *dest_bi, struct buffer_head *src,
 			   int last_first, int cpy_num, int cpy_bytes)
 {
 	int pos, i, src_nr_item, bytes;
@@ -441,7 +436,7 @@ static int leaf_copy_items(reiserfs_filsys_t *fs,
 			bytes = -1;
 
 		/* copy the first item or it part or nothing to the end of the DEST (i = leaf_copy_boundary_item(DEST,SOURCE,0,bytes)) */
-		i = leaf_copy_boundary_item(fs, dest_bi, src, FIRST_TO_LAST,
+		i = leaf_copy_boundary_item(dest_bi, src, FIRST_TO_LAST,
 					    bytes);
 		cpy_num -= i;
 		if (cpy_num == 0)
@@ -449,16 +444,16 @@ static int leaf_copy_items(reiserfs_filsys_t *fs,
 		pos += i;
 		if (cpy_bytes == -1)
 			/* copy first cpy_num items starting from position 'pos' of SOURCE to end of DEST */
-			leaf_copy_items_entirely(fs, dest_bi, src,
+			leaf_copy_items_entirely(dest_bi, src,
 						 FIRST_TO_LAST, pos, cpy_num);
 		else {
 			/* copy first cpy_num-1 items starting from position 'pos-1' of the SOURCE to the end of the DEST */
-			leaf_copy_items_entirely(fs, dest_bi, src,
+			leaf_copy_items_entirely(dest_bi, src,
 						 FIRST_TO_LAST, pos,
 						 cpy_num - 1);
 
 			/* copy part of the item which number is cpy_num+pos-1 to the end of the DEST */
-			leaf_item_bottle(fs, dest_bi, src, FIRST_TO_LAST,
+			leaf_item_bottle(dest_bi, src, FIRST_TO_LAST,
 					 cpy_num + pos - 1, cpy_bytes);
 		}
 	} else {
@@ -470,7 +465,7 @@ static int leaf_copy_items(reiserfs_filsys_t *fs,
 			bytes = -1;
 
 		/* copy the last item or it part or nothing to the begin of the DEST (i = leaf_copy_boundary_item(DEST,SOURCE,1,bytes)); */
-		i = leaf_copy_boundary_item(fs, dest_bi, src, LAST_TO_FIRST,
+		i = leaf_copy_boundary_item(dest_bi, src, LAST_TO_FIRST,
 					    bytes);
 
 		cpy_num -= i;
@@ -480,16 +475,16 @@ static int leaf_copy_items(reiserfs_filsys_t *fs,
 		pos = src_nr_item - cpy_num - i;
 		if (cpy_bytes == -1) {
 			/* starting from position 'pos' copy last cpy_num items of SOURCE to begin of DEST */
-			leaf_copy_items_entirely(fs, dest_bi, src,
+			leaf_copy_items_entirely(dest_bi, src,
 						 LAST_TO_FIRST, pos, cpy_num);
 		} else {
 			/* copy last cpy_num-1 items starting from position 'pos+1' of the SOURCE to the begin of the DEST; */
-			leaf_copy_items_entirely(fs, dest_bi, src,
+			leaf_copy_items_entirely(dest_bi, src,
 						 LAST_TO_FIRST, pos + 1,
 						 cpy_num - 1);
 
 			/* copy part of the item which number is pos to the begin of the DEST */
-			leaf_item_bottle(fs, dest_bi, src, LAST_TO_FIRST, pos,
+			leaf_item_bottle(dest_bi, src, LAST_TO_FIRST, pos,
 					 cpy_bytes);
 		}
 	}
@@ -556,11 +551,10 @@ int leaf_move_items(int shift_mode, struct tree_balance *tb,
 	leaf_define_dest_src_infos(shift_mode, tb, &dest_bi, &src_bi,
 				   &first_last, Snew);
 
-	ret_value =
-	    leaf_copy_items(tb->tb_fs, &dest_bi, src_bi.bi_bh, first_last,
-			    mov_num, mov_bytes);
+	ret_value = leaf_copy_items(&dest_bi, src_bi.bi_bh, first_last,
+				    mov_num, mov_bytes);
 
-	leaf_delete_items(tb->tb_fs, &src_bi, first_last,
+	leaf_delete_items(&src_bi, first_last,
 			  (first_last ==
 			   FIRST_TO_LAST) ? 0 : (B_NR_ITEMS(src_bi.bi_bh) -
 						 mov_num), mov_num, mov_bytes);
@@ -613,9 +607,7 @@ int leaf_shift_right(struct tree_balance *tb, int shift_num, int shift_bytes)
 	return ret_value;
 }
 
-static void leaf_delete_items_entirely(reiserfs_filsys_t *sb,
-				       /*struct reiserfs_transaction_handle *th, */
-				       struct buffer_info *bi,
+static void leaf_delete_items_entirely(struct buffer_info *bi,
 				       int first, int del_num);
 /*  If del_bytes == -1, starting from position 'first' delete del_num items in whole in buffer CUR.
     If not.
@@ -624,12 +616,11 @@ static void leaf_delete_items_entirely(reiserfs_filsys_t *sb,
     If last_first == 1. Starting from position 'first+1' delete del_num-1 items in whole. Delete part of body of
     the last item . Part defined by del_bytes. Don't delete last item header.
 */
-void leaf_delete_items(reiserfs_filsys_t *fs,
-		       struct buffer_info *cur_bi,
-		       int last_first, int first, int del_num, int del_bytes)
+void leaf_delete_items(struct buffer_info *cur_bi, int last_first, int first,
+		       int del_num, int del_bytes)
 {
-	struct buffer_head *bh;
-	int item_amount = B_NR_ITEMS(bh = cur_bi->bi_bh);
+	struct buffer_head *bh = cur_bi->bi_bh;;
+	int item_amount = B_NR_ITEMS(bh);
 
 	if (del_num == 0)
 		return;
@@ -642,22 +633,22 @@ void leaf_delete_items(reiserfs_filsys_t *fs,
 
 	if (del_bytes == -1)
 		/* delete del_num items beginning from item in position first */
-		leaf_delete_items_entirely(fs, cur_bi, first, del_num);
+		leaf_delete_items_entirely(cur_bi, first, del_num);
 	else {
 		if (last_first == FIRST_TO_LAST) {
 			/* delete del_num-1 items beginning from item in position first  */
-			leaf_delete_items_entirely(fs, cur_bi, first,
+			leaf_delete_items_entirely(cur_bi, first,
 						   del_num - 1);
 
 			/* delete the part of the first item of the bh do not
 			   delete item header */
-			leaf_cut_from_buffer(fs, cur_bi, 0, 0, del_bytes);
+			leaf_cut_from_buffer(cur_bi, 0, 0, del_bytes);
 		} else {
 			struct item_head *ih;
 			int len;
 
 			/* delete del_num-1 items beginning from item in position first+1  */
-			leaf_delete_items_entirely(fs, cur_bi, first + 1,
+			leaf_delete_items_entirely(cur_bi, first + 1,
 						   del_num - 1);
 
 			if (I_IS_DIRECTORY_ITEM
@@ -672,15 +663,14 @@ void leaf_delete_items(reiserfs_filsys_t *fs,
 			/* delete the part of the last item of the bh
 			   do not delete item header
 			 */
-			leaf_cut_from_buffer(fs, cur_bi, B_NR_ITEMS(bh) - 1,
+			leaf_cut_from_buffer(cur_bi, B_NR_ITEMS(bh) - 1,
 					     len - del_bytes, del_bytes);
 		}
 	}
 }
 
 /* insert item into the leaf node in position before */
-void leaf_insert_into_buf(reiserfs_filsys_t *s,
-			  struct buffer_info *bi,
+void leaf_insert_into_buf(struct buffer_info *bi,
 			  int before,
 			  struct item_head *inserted_item_ih,
 			  const char *inserted_item_body, int zeros_number)
@@ -756,8 +746,7 @@ void leaf_insert_into_buf(reiserfs_filsys_t *s,
 
 /* paste paste_size bytes to affected_item_num-th item.
    When item is a directory, this only prepare space for new entries */
-void leaf_paste_in_buffer(reiserfs_filsys_t *fs,
-			  struct buffer_info *bi,
+void leaf_paste_in_buffer(struct buffer_info *bi,
 			  int affected_item_num,
 			  int pos_in_item,
 			  int paste_size, const char *body, int zeros_number)
@@ -924,8 +913,7 @@ static int leaf_cut_entries(struct buffer_head *bh,
         pos_in_item - number of first deleted entry
         cut_size - count of deleted entries
     */
-void leaf_cut_from_buffer(reiserfs_filsys_t *fs,
-			  struct buffer_info *bi, int cut_item_num,
+void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,
 			  int pos_in_item, int cut_size)
 {
 	int nr;
@@ -1018,8 +1006,7 @@ void leaf_cut_from_buffer(reiserfs_filsys_t *fs,
 }
 
 /* delete del_num items from buffer starting from the first'th item */
-static void leaf_delete_items_entirely(reiserfs_filsys_t *fs,
-				       struct buffer_info *bi,
+static void leaf_delete_items_entirely(struct buffer_info *bi,
 				       int first, int del_num)
 {
 	struct buffer_head *bh = bi->bi_bh;
@@ -1170,7 +1157,7 @@ void delete_item(reiserfs_filsys_t *fs, struct buffer_head *bh, int item_num)
 	buffer_info_init_bh(NULL, &bi, bh);
 	bi.bi_fs = fs;
 
-	leaf_delete_items_entirely(fs, &bi, item_num, 1);
+	leaf_delete_items_entirely(&bi, item_num, 1);
 }
 
 void cut_entry(reiserfs_filsys_t *fs, struct buffer_head *bh,
@@ -1181,5 +1168,5 @@ void cut_entry(reiserfs_filsys_t *fs, struct buffer_head *bh,
 	buffer_info_init_bh(NULL, &bi, bh);
 	bi.bi_fs = fs;
 
-	leaf_cut_from_buffer(fs, &bi, item_num, entry_num, del_count);
+	leaf_cut_from_buffer(&bi, item_num, entry_num, del_count);
 }