]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blob - src/patches/suse-2.6.27.25/patches.suse/reiserfs-rename-p_s_tb.diff
projects / people / pmueller / ipfire-2.x.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added missing SuSE-Xen-Patches.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.25 / patches.suse / reiserfs-rename-p_s_tb.diff
1 From: Jeff Mahoney <jeffm@suse.com>
2 Subject: reiserfs: rename p_s_tb to tb
3
4 This patch is a simple s/p_s_tb/tb/g to the reiserfs code. This is the fourth
5 in a series of patches to rip out some of the awful variable naming in
6 reiserfs.
7
8 Signed-off-by: Jeff Mahoney <jeffm@suse.com>
9
10 ---
11
12 fs/reiserfs/fix_node.c | 482 ++++++++++++++++++++++----------------------
13 fs/reiserfs/stree.c | 21 +
14 include/linux/reiserfs_fs.h | 2
15 3 files changed, 254 insertions(+), 251 deletions(-)
16
17 --- a/fs/reiserfs/fix_node.c
18 +++ b/fs/reiserfs/fix_node.c
19 @@ -749,26 +749,26 @@ else \
20 -1, -1);\
21 }
22
23 -static void free_buffers_in_tb(struct tree_balance *p_s_tb)
24 +static void free_buffers_in_tb(struct tree_balance *tb)
25 {
26 int n_counter;
27
28 - pathrelse(p_s_tb->tb_path);
29 + pathrelse(tb->tb_path);
30
31 for (n_counter = 0; n_counter < MAX_HEIGHT; n_counter++) {
32 - brelse(p_s_tb->L[n_counter]);
33 - brelse(p_s_tb->R[n_counter]);
34 - brelse(p_s_tb->FL[n_counter]);
35 - brelse(p_s_tb->FR[n_counter]);
36 - brelse(p_s_tb->CFL[n_counter]);
37 - brelse(p_s_tb->CFR[n_counter]);
38 -
39 - p_s_tb->L[n_counter] = NULL;
40 - p_s_tb->R[n_counter] = NULL;
41 - p_s_tb->FL[n_counter] = NULL;
42 - p_s_tb->FR[n_counter] = NULL;
43 - p_s_tb->CFL[n_counter] = NULL;
44 - p_s_tb->CFR[n_counter] = NULL;
45 + brelse(tb->L[n_counter]);
46 + brelse(tb->R[n_counter]);
47 + brelse(tb->FL[n_counter]);
48 + brelse(tb->FR[n_counter]);
49 + brelse(tb->CFL[n_counter]);
50 + brelse(tb->CFR[n_counter]);
51 +
52 + tb->L[n_counter] = NULL;
53 + tb->R[n_counter] = NULL;
54 + tb->FL[n_counter] = NULL;
55 + tb->FR[n_counter] = NULL;
56 + tb->CFL[n_counter] = NULL;
57 + tb->CFR[n_counter] = NULL;
58 }
59 }
60
61 @@ -778,14 +778,14 @@ static void free_buffers_in_tb(struct tr
62 * NO_DISK_SPACE - no disk space.
63 */
64 /* The function is NOT SCHEDULE-SAFE! */
65 -static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
66 +static int get_empty_nodes(struct tree_balance *tb, int n_h)
67 {
68 struct buffer_head *p_s_new_bh,
69 - *p_s_Sh = PATH_H_PBUFFER(p_s_tb->tb_path, n_h);
70 + *p_s_Sh = PATH_H_PBUFFER(tb->tb_path, n_h);
71 b_blocknr_t *p_n_blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, };
72 int n_counter, n_number_of_freeblk, n_amount_needed, /* number of needed empty blocks */
73 n_retval = CARRY_ON;
74 - struct super_block *sb = p_s_tb->tb_sb;
75 + struct super_block *sb = tb->tb_sb;
76
77 /* number_of_freeblk is the number of empty blocks which have been
78 acquired for use by the balancing algorithm minus the number of
79 @@ -803,15 +803,15 @@ static int get_empty_nodes(struct tree_b
80 the analysis or 0 if not restarted, then subtract the amount needed
81 by all of the levels of the tree below n_h. */
82 /* blknum includes S[n_h], so we subtract 1 in this calculation */
83 - for (n_counter = 0, n_number_of_freeblk = p_s_tb->cur_blknum;
84 + for (n_counter = 0, n_number_of_freeblk = tb->cur_blknum;
85 n_counter < n_h; n_counter++)
86 n_number_of_freeblk -=
87 - (p_s_tb->blknum[n_counter]) ? (p_s_tb->blknum[n_counter] -
88 + (tb->blknum[n_counter]) ? (tb->blknum[n_counter] -
89 1) : 0;
90
91 /* Allocate missing empty blocks. */
92 /* if p_s_Sh == 0 then we are getting a new root */
93 - n_amount_needed = (p_s_Sh) ? (p_s_tb->blknum[n_h] - 1) : 1;
94 + n_amount_needed = (p_s_Sh) ? (tb->blknum[n_h] - 1) : 1;
95 /* Amount_needed = the amount that we need more than the amount that we have. */
96 if (n_amount_needed > n_number_of_freeblk)
97 n_amount_needed -= n_number_of_freeblk;
98 @@ -819,7 +819,7 @@ static int get_empty_nodes(struct tree_b
99 return CARRY_ON;
100
101 /* No need to check quota - is not allocated for blocks used for formatted nodes */
102 - if (reiserfs_new_form_blocknrs(p_s_tb, a_n_blocknrs,
103 + if (reiserfs_new_form_blocknrs(tb, a_n_blocknrs,
104 n_amount_needed) == NO_DISK_SPACE)
105 return NO_DISK_SPACE;
106
107 @@ -838,14 +838,14 @@ static int get_empty_nodes(struct tree_b
108 p_s_new_bh);
109
110 /* Put empty buffers into the array. */
111 - RFALSE(p_s_tb->FEB[p_s_tb->cur_blknum],
112 + RFALSE(tb->FEB[tb->cur_blknum],
113 "PAP-8141: busy slot for new buffer");
114
115 set_buffer_journal_new(p_s_new_bh);
116 - p_s_tb->FEB[p_s_tb->cur_blknum++] = p_s_new_bh;
117 + tb->FEB[tb->cur_blknum++] = p_s_new_bh;
118 }
119
120 - if (n_retval == CARRY_ON && FILESYSTEM_CHANGED_TB(p_s_tb))
121 + if (n_retval == CARRY_ON && FILESYSTEM_CHANGED_TB(tb))
122 n_retval = REPEAT_SEARCH;
123
124 return n_retval;
125 @@ -896,33 +896,34 @@ static int get_rfree(struct tree_balance
126 }
127
128 /* Check whether left neighbor is in memory. */
129 -static int is_left_neighbor_in_cache(struct tree_balance *p_s_tb, int n_h)
130 +static int is_left_neighbor_in_cache(struct tree_balance *tb, int n_h)
131 {
132 struct buffer_head *p_s_father, *left;
133 - struct super_block *sb = p_s_tb->tb_sb;
134 + struct super_block *sb = tb->tb_sb;
135 b_blocknr_t n_left_neighbor_blocknr;
136 int n_left_neighbor_position;
137
138 - if (!p_s_tb->FL[n_h]) /* Father of the left neighbor does not exist. */
139 + /* Father of the left neighbor does not exist. */
140 + if (!tb->FL[n_h])
141 return 0;
142
143 /* Calculate father of the node to be balanced. */
144 - p_s_father = PATH_H_PBUFFER(p_s_tb->tb_path, n_h + 1);
145 + p_s_father = PATH_H_PBUFFER(tb->tb_path, n_h + 1);
146
147 RFALSE(!p_s_father ||
148 !B_IS_IN_TREE(p_s_father) ||
149 - !B_IS_IN_TREE(p_s_tb->FL[n_h]) ||
150 + !B_IS_IN_TREE(tb->FL[n_h]) ||
151 !buffer_uptodate(p_s_father) ||
152 - !buffer_uptodate(p_s_tb->FL[n_h]),
153 + !buffer_uptodate(tb->FL[n_h]),
154 "vs-8165: F[h] (%b) or FL[h] (%b) is invalid",
155 - p_s_father, p_s_tb->FL[n_h]);
156 + p_s_father, tb->FL[n_h]);
157
158 /* Get position of the pointer to the left neighbor into the left father. */
159 - n_left_neighbor_position = (p_s_father == p_s_tb->FL[n_h]) ?
160 - p_s_tb->lkey[n_h] : B_NR_ITEMS(p_s_tb->FL[n_h]);
161 + n_left_neighbor_position = (p_s_father == tb->FL[n_h]) ?
162 + tb->lkey[n_h] : B_NR_ITEMS(tb->FL[n_h]);
163 /* Get left neighbor block number. */
164 n_left_neighbor_blocknr =
165 - B_N_CHILD_NUM(p_s_tb->FL[n_h], n_left_neighbor_position);
166 + B_N_CHILD_NUM(tb->FL[n_h], n_left_neighbor_position);
167 /* Look for the left neighbor in the cache. */
168 if ((left = sb_find_get_block(sb, n_left_neighbor_blocknr))) {
169
170 @@ -953,14 +954,14 @@ static void decrement_key(struct cpu_key
171 SCHEDULE_OCCURRED - schedule occurred while the function worked;
172 * CARRY_ON - schedule didn't occur while the function worked;
173 */
174 -static int get_far_parent(struct tree_balance *p_s_tb,
175 +static int get_far_parent(struct tree_balance *tb,
176 int n_h,
177 struct buffer_head **pp_s_father,
178 struct buffer_head **pp_s_com_father, char c_lr_par)
179 {
180 struct buffer_head *p_s_parent;
181 INITIALIZE_PATH(s_path_to_neighbor_father);
182 - struct treepath *p_s_path = p_s_tb->tb_path;
183 + struct treepath *p_s_path = tb->tb_path;
184 struct cpu_key s_lr_father_key;
185 int n_counter,
186 n_position = INT_MAX,
187 @@ -1005,9 +1006,9 @@ static int get_far_parent(struct tree_ba
188 if (n_counter == FIRST_PATH_ELEMENT_OFFSET) {
189 /* Check whether first buffer in the path is the root of the tree. */
190 if (PATH_OFFSET_PBUFFER
191 - (p_s_tb->tb_path,
192 + (tb->tb_path,
193 FIRST_PATH_ELEMENT_OFFSET)->b_blocknr ==
194 - SB_ROOT_BLOCK(p_s_tb->tb_sb)) {
195 + SB_ROOT_BLOCK(tb->tb_sb)) {
196 *pp_s_father = *pp_s_com_father = NULL;
197 return CARRY_ON;
198 }
199 @@ -1022,7 +1023,7 @@ static int get_far_parent(struct tree_ba
200
201 if (buffer_locked(*pp_s_com_father)) {
202 __wait_on_buffer(*pp_s_com_father);
203 - if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
204 + if (FILESYSTEM_CHANGED_TB(tb)) {
205 brelse(*pp_s_com_father);
206 return REPEAT_SEARCH;
207 }
208 @@ -1035,9 +1036,9 @@ static int get_far_parent(struct tree_ba
209 le_key2cpu_key(&s_lr_father_key,
210 B_N_PDELIM_KEY(*pp_s_com_father,
211 (c_lr_par ==
212 - LEFT_PARENTS) ? (p_s_tb->lkey[n_h - 1] =
213 + LEFT_PARENTS) ? (tb->lkey[n_h - 1] =
214 n_position -
215 - 1) : (p_s_tb->rkey[n_h -
216 + 1) : (tb->rkey[n_h -
217 1] =
218 n_position)));
219
220 @@ -1045,12 +1046,12 @@ static int get_far_parent(struct tree_ba
221 decrement_key(&s_lr_father_key);
222
223 if (search_by_key
224 - (p_s_tb->tb_sb, &s_lr_father_key, &s_path_to_neighbor_father,
225 + (tb->tb_sb, &s_lr_father_key, &s_path_to_neighbor_father,
226 n_h + 1) == IO_ERROR)
227 // path is released
228 return IO_ERROR;
229
230 - if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
231 + if (FILESYSTEM_CHANGED_TB(tb)) {
232 pathrelse(&s_path_to_neighbor_father);
233 brelse(*pp_s_com_father);
234 return REPEAT_SEARCH;
235 @@ -1075,24 +1076,26 @@ static int get_far_parent(struct tree_ba
236 * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked;
237 * CARRY_ON - schedule didn't occur while the function worked;
238 */
239 -static int get_parents(struct tree_balance *p_s_tb, int n_h)
240 +static int get_parents(struct tree_balance *tb, int n_h)
241 {
242 - struct treepath *p_s_path = p_s_tb->tb_path;
243 + struct treepath *p_s_path = tb->tb_path;
244 int n_position,
245 n_ret_value,
246 - n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
247 + n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h);
248 struct buffer_head *p_s_curf, *p_s_curcf;
249
250 /* Current node is the root of the tree or will be root of the tree */
251 if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
252 /* The root can not have parents.
253 Release nodes which previously were obtained as parents of the current node neighbors. */
254 - brelse(p_s_tb->FL[n_h]);
255 - brelse(p_s_tb->CFL[n_h]);
256 - brelse(p_s_tb->FR[n_h]);
257 - brelse(p_s_tb->CFR[n_h]);
258 - p_s_tb->FL[n_h] = p_s_tb->CFL[n_h] = p_s_tb->FR[n_h] =
259 - p_s_tb->CFR[n_h] = NULL;
260 + brelse(tb->FL[n_h]);
261 + brelse(tb->CFL[n_h]);
262 + brelse(tb->FR[n_h]);
263 + brelse(tb->CFR[n_h]);
264 + tb->FL[n_h] = NULL;
265 + tb->CFL[n_h] = NULL;
266 + tb->FR[n_h] = NULL;
267 + tb->CFR[n_h] = NULL;
268 return CARRY_ON;
269 }
270
271 @@ -1104,22 +1107,22 @@ static int get_parents(struct tree_balan
272 PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1);
273 get_bh(p_s_curf);
274 get_bh(p_s_curf);
275 - p_s_tb->lkey[n_h] = n_position - 1;
276 + tb->lkey[n_h] = n_position - 1;
277 } else {
278 /* Calculate current parent of L[n_path_offset], which is the left neighbor of the current node.
279 Calculate current common parent of L[n_path_offset] and the current node. Note that
280 CFL[n_path_offset] not equal FL[n_path_offset] and CFL[n_path_offset] not equal F[n_path_offset].
281 Calculate lkey[n_path_offset]. */
282 - if ((n_ret_value = get_far_parent(p_s_tb, n_h + 1, &p_s_curf,
283 + if ((n_ret_value = get_far_parent(tb, n_h + 1, &p_s_curf,
284 &p_s_curcf,
285 LEFT_PARENTS)) != CARRY_ON)
286 return n_ret_value;
287 }
288
289 - brelse(p_s_tb->FL[n_h]);
290 - p_s_tb->FL[n_h] = p_s_curf; /* New initialization of FL[n_h]. */
291 - brelse(p_s_tb->CFL[n_h]);
292 - p_s_tb->CFL[n_h] = p_s_curcf; /* New initialization of CFL[n_h]. */
293 + brelse(tb->FL[n_h]);
294 + tb->FL[n_h] = p_s_curf; /* New initialization of FL[n_h]. */
295 + brelse(tb->CFL[n_h]);
296 + tb->CFL[n_h] = p_s_curcf; /* New initialization of CFL[n_h]. */
297
298 RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) ||
299 (p_s_curcf && !B_IS_IN_TREE(p_s_curcf)),
300 @@ -1133,7 +1136,7 @@ static int get_parents(struct tree_balan
301 Calculate current common parent of R[n_h] and current node. Note that CFR[n_h]
302 not equal FR[n_path_offset] and CFR[n_h] not equal F[n_h]. */
303 if ((n_ret_value =
304 - get_far_parent(p_s_tb, n_h + 1, &p_s_curf, &p_s_curcf,
305 + get_far_parent(tb, n_h + 1, &p_s_curf, &p_s_curcf,
306 RIGHT_PARENTS)) != CARRY_ON)
307 return n_ret_value;
308 } else {
309 @@ -1143,14 +1146,16 @@ static int get_parents(struct tree_balan
310 PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1);
311 get_bh(p_s_curf);
312 get_bh(p_s_curf);
313 - p_s_tb->rkey[n_h] = n_position;
314 + tb->rkey[n_h] = n_position;
315 }
316
317 - brelse(p_s_tb->FR[n_h]);
318 - p_s_tb->FR[n_h] = p_s_curf; /* New initialization of FR[n_path_offset]. */
319 + brelse(tb->FR[n_h]);
320 + /* New initialization of FR[n_path_offset]. */
321 + tb->FR[n_h] = p_s_curf;
322
323 - brelse(p_s_tb->CFR[n_h]);
324 - p_s_tb->CFR[n_h] = p_s_curcf; /* New initialization of CFR[n_path_offset]. */
325 + brelse(tb->CFR[n_h]);
326 + /* New initialization of CFR[n_path_offset]. */
327 + tb->CFR[n_h] = p_s_curcf;
328
329 RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) ||
330 (p_s_curcf && !B_IS_IN_TREE(p_s_curcf)),
331 @@ -1885,12 +1890,12 @@ static int check_balance(int mode,
332 }
333
334 /* Check whether parent at the path is the really parent of the current node.*/
335 -static int get_direct_parent(struct tree_balance *p_s_tb, int n_h)
336 +static int get_direct_parent(struct tree_balance *tb, int n_h)
337 {
338 struct buffer_head *bh;
339 - struct treepath *p_s_path = p_s_tb->tb_path;
340 + struct treepath *p_s_path = tb->tb_path;
341 int n_position,
342 - n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
343 + n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h);
344
345 /* We are in the root or in the new root. */
346 if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
347 @@ -1899,7 +1904,7 @@ static int get_direct_parent(struct tree
348 "PAP-8260: invalid offset in the path");
349
350 if (PATH_OFFSET_PBUFFER(p_s_path, FIRST_PATH_ELEMENT_OFFSET)->
351 - b_blocknr == SB_ROOT_BLOCK(p_s_tb->tb_sb)) {
352 + b_blocknr == SB_ROOT_BLOCK(tb->tb_sb)) {
353 /* Root is not changed. */
354 PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1) = NULL;
355 PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1) = 0;
356 @@ -1924,7 +1929,7 @@ static int get_direct_parent(struct tree
357
358 if (buffer_locked(bh)) {
359 __wait_on_buffer(bh);
360 - if (FILESYSTEM_CHANGED_TB(p_s_tb))
361 + if (FILESYSTEM_CHANGED_TB(tb))
362 return REPEAT_SEARCH;
363 }
364
365 @@ -1937,85 +1942,86 @@ static int get_direct_parent(struct tree
366 * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked;
367 * CARRY_ON - schedule didn't occur while the function worked;
368 */
369 -static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
370 +static int get_neighbors(struct tree_balance *tb, int n_h)
371 {
372 int n_child_position,
373 - n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1);
374 + n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h + 1);
375 unsigned long n_son_number;
376 - struct super_block *sb = p_s_tb->tb_sb;
377 + struct super_block *sb = tb->tb_sb;
378 struct buffer_head *bh;
379
380 PROC_INFO_INC(sb, get_neighbors[n_h]);
381
382 - if (p_s_tb->lnum[n_h]) {
383 + if (tb->lnum[n_h]) {
384 /* We need left neighbor to balance S[n_h]. */
385 PROC_INFO_INC(sb, need_l_neighbor[n_h]);
386 - bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
387 + bh = PATH_OFFSET_PBUFFER(tb->tb_path, n_path_offset);
388
389 - RFALSE(bh == p_s_tb->FL[n_h] &&
390 - !PATH_OFFSET_POSITION(p_s_tb->tb_path, n_path_offset),
391 + RFALSE(bh == tb->FL[n_h] &&
392 + !PATH_OFFSET_POSITION(tb->tb_path, n_path_offset),
393 "PAP-8270: invalid position in the parent");
394
395 n_child_position =
396 (bh ==
397 - p_s_tb->FL[n_h]) ? p_s_tb->lkey[n_h] : B_NR_ITEMS(p_s_tb->
398 + tb->FL[n_h]) ? tb->lkey[n_h] : B_NR_ITEMS(tb->
399 FL[n_h]);
400 - n_son_number = B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position);
401 + n_son_number = B_N_CHILD_NUM(tb->FL[n_h], n_child_position);
402 bh = sb_bread(sb, n_son_number);
403 if (!bh)
404 return IO_ERROR;
405 - if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
406 + if (FILESYSTEM_CHANGED_TB(tb)) {
407 brelse(bh);
408 PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
409 return REPEAT_SEARCH;
410 }
411
412 - RFALSE(!B_IS_IN_TREE(p_s_tb->FL[n_h]) ||
413 - n_child_position > B_NR_ITEMS(p_s_tb->FL[n_h]) ||
414 - B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position) !=
415 + RFALSE(!B_IS_IN_TREE(tb->FL[n_h]) ||
416 + n_child_position > B_NR_ITEMS(tb->FL[n_h]) ||
417 + B_N_CHILD_NUM(tb->FL[n_h], n_child_position) !=
418 bh->b_blocknr, "PAP-8275: invalid parent");
419 RFALSE(!B_IS_IN_TREE(bh), "PAP-8280: invalid child");
420 RFALSE(!n_h &&
421 B_FREE_SPACE(bh) !=
422 MAX_CHILD_SIZE(bh) -
423 - dc_size(B_N_CHILD(p_s_tb->FL[0], n_child_position)),
424 + dc_size(B_N_CHILD(tb->FL[0], n_child_position)),
425 "PAP-8290: invalid child size of left neighbor");
426
427 - brelse(p_s_tb->L[n_h]);
428 - p_s_tb->L[n_h] = bh;
429 + brelse(tb->L[n_h]);
430 + tb->L[n_h] = bh;
431 }
432
433 - if (p_s_tb->rnum[n_h]) { /* We need right neighbor to balance S[n_path_offset]. */
434 + /* We need right neighbor to balance S[n_path_offset]. */
435 + if (tb->rnum[n_h]) {
436 PROC_INFO_INC(sb, need_r_neighbor[n_h]);
437 - bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
438 + bh = PATH_OFFSET_PBUFFER(tb->tb_path, n_path_offset);
439
440 - RFALSE(bh == p_s_tb->FR[n_h] &&
441 - PATH_OFFSET_POSITION(p_s_tb->tb_path,
442 + RFALSE(bh == tb->FR[n_h] &&
443 + PATH_OFFSET_POSITION(tb->tb_path,
444 n_path_offset) >=
445 B_NR_ITEMS(bh),
446 "PAP-8295: invalid position in the parent");
447
448 n_child_position =
449 - (bh == p_s_tb->FR[n_h]) ? p_s_tb->rkey[n_h] + 1 : 0;
450 - n_son_number = B_N_CHILD_NUM(p_s_tb->FR[n_h], n_child_position);
451 + (bh == tb->FR[n_h]) ? tb->rkey[n_h] + 1 : 0;
452 + n_son_number = B_N_CHILD_NUM(tb->FR[n_h], n_child_position);
453 bh = sb_bread(sb, n_son_number);
454 if (!bh)
455 return IO_ERROR;
456 - if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
457 + if (FILESYSTEM_CHANGED_TB(tb)) {
458 brelse(bh);
459 PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
460 return REPEAT_SEARCH;
461 }
462 - brelse(p_s_tb->R[n_h]);
463 - p_s_tb->R[n_h] = bh;
464 + brelse(tb->R[n_h]);
465 + tb->R[n_h] = bh;
466
467 RFALSE(!n_h
468 && B_FREE_SPACE(bh) !=
469 MAX_CHILD_SIZE(bh) -
470 - dc_size(B_N_CHILD(p_s_tb->FR[0], n_child_position)),
471 + dc_size(B_N_CHILD(tb->FR[0], n_child_position)),
472 "PAP-8300: invalid child size of right neighbor (%d != %d - %d)",
473 B_FREE_SPACE(bh), MAX_CHILD_SIZE(bh),
474 - dc_size(B_N_CHILD(p_s_tb->FR[0], n_child_position)));
475 + dc_size(B_N_CHILD(tb->FR[0], n_child_position)));
476
477 }
478 return CARRY_ON;
479 @@ -2139,7 +2145,7 @@ static int clear_all_dirty_bits(struct s
480 return reiserfs_prepare_for_journal(s, bh, 0);
481 }
482
483 -static int wait_tb_buffers_until_unlocked(struct tree_balance *p_s_tb)
484 +static int wait_tb_buffers_until_unlocked(struct tree_balance *tb)
485 {
486 struct buffer_head *locked;
487 #ifdef CONFIG_REISERFS_CHECK
488 @@ -2151,95 +2157,94 @@ static int wait_tb_buffers_until_unlocke
489
490 locked = NULL;
491
492 - for (i = p_s_tb->tb_path->path_length;
493 + for (i = tb->tb_path->path_length;
494 !locked && i > ILLEGAL_PATH_ELEMENT_OFFSET; i--) {
495 - if (PATH_OFFSET_PBUFFER(p_s_tb->tb_path, i)) {
496 + if (PATH_OFFSET_PBUFFER(tb->tb_path, i)) {
497 /* if I understand correctly, we can only be sure the last buffer
498 ** in the path is in the tree --clm
499 */
500 #ifdef CONFIG_REISERFS_CHECK
501 - if (PATH_PLAST_BUFFER(p_s_tb->tb_path) ==
502 - PATH_OFFSET_PBUFFER(p_s_tb->tb_path, i)) {
503 - tb_buffer_sanity_check(p_s_tb->tb_sb,
504 + if (PATH_PLAST_BUFFER(tb->tb_path) ==
505 + PATH_OFFSET_PBUFFER(tb->tb_path, i))
506 + tb_buffer_sanity_check(tb->tb_sb,
507 PATH_OFFSET_PBUFFER
508 - (p_s_tb->tb_path,
509 + (tb->tb_path,
510 i), "S",
511 - p_s_tb->tb_path->
512 + tb->tb_path->
513 path_length - i);
514 - }
515 #endif
516 - if (!clear_all_dirty_bits(p_s_tb->tb_sb,
517 + if (!clear_all_dirty_bits(tb->tb_sb,
518 PATH_OFFSET_PBUFFER
519 - (p_s_tb->tb_path,
520 + (tb->tb_path,
521 i))) {
522 locked =
523 - PATH_OFFSET_PBUFFER(p_s_tb->tb_path,
524 + PATH_OFFSET_PBUFFER(tb->tb_path,
525 i);
526 }
527 }
528 }
529
530 - for (i = 0; !locked && i < MAX_HEIGHT && p_s_tb->insert_size[i];
531 + for (i = 0; !locked && i < MAX_HEIGHT && tb->insert_size[i];
532 i++) {
533
534 - if (p_s_tb->lnum[i]) {
535 + if (tb->lnum[i]) {
536
537 - if (p_s_tb->L[i]) {
538 - tb_buffer_sanity_check(p_s_tb->tb_sb,
539 - p_s_tb->L[i],
540 + if (tb->L[i]) {
541 + tb_buffer_sanity_check(tb->tb_sb,
542 + tb->L[i],
543 "L", i);
544 if (!clear_all_dirty_bits
545 - (p_s_tb->tb_sb, p_s_tb->L[i]))
546 - locked = p_s_tb->L[i];
547 + (tb->tb_sb, tb->L[i]))
548 + locked = tb->L[i];
549 }
550
551 - if (!locked && p_s_tb->FL[i]) {
552 - tb_buffer_sanity_check(p_s_tb->tb_sb,
553 - p_s_tb->FL[i],
554 + if (!locked && tb->FL[i]) {
555 + tb_buffer_sanity_check(tb->tb_sb,
556 + tb->FL[i],
557 "FL", i);
558 if (!clear_all_dirty_bits
559 - (p_s_tb->tb_sb, p_s_tb->FL[i]))
560 - locked = p_s_tb->FL[i];
561 + (tb->tb_sb, tb->FL[i]))
562 + locked = tb->FL[i];
563 }
564
565 - if (!locked && p_s_tb->CFL[i]) {
566 - tb_buffer_sanity_check(p_s_tb->tb_sb,
567 - p_s_tb->CFL[i],
568 + if (!locked && tb->CFL[i]) {
569 + tb_buffer_sanity_check(tb->tb_sb,
570 + tb->CFL[i],
571 "CFL", i);
572 if (!clear_all_dirty_bits
573 - (p_s_tb->tb_sb, p_s_tb->CFL[i]))
574 - locked = p_s_tb->CFL[i];
575 + (tb->tb_sb, tb->CFL[i]))
576 + locked = tb->CFL[i];
577 }
578
579 }
580
581 - if (!locked && (p_s_tb->rnum[i])) {
582 + if (!locked && (tb->rnum[i])) {
583
584 - if (p_s_tb->R[i]) {
585 - tb_buffer_sanity_check(p_s_tb->tb_sb,
586 - p_s_tb->R[i],
587 + if (tb->R[i]) {
588 + tb_buffer_sanity_check(tb->tb_sb,
589 + tb->R[i],
590 "R", i);
591 if (!clear_all_dirty_bits
592 - (p_s_tb->tb_sb, p_s_tb->R[i]))
593 - locked = p_s_tb->R[i];
594 + (tb->tb_sb, tb->R[i]))
595 + locked = tb->R[i];
596 }
597
598 - if (!locked && p_s_tb->FR[i]) {
599 - tb_buffer_sanity_check(p_s_tb->tb_sb,
600 - p_s_tb->FR[i],
601 + if (!locked && tb->FR[i]) {
602 + tb_buffer_sanity_check(tb->tb_sb,
603 + tb->FR[i],
604 "FR", i);
605 if (!clear_all_dirty_bits
606 - (p_s_tb->tb_sb, p_s_tb->FR[i]))
607 - locked = p_s_tb->FR[i];
608 + (tb->tb_sb, tb->FR[i]))
609 + locked = tb->FR[i];
610 }
611
612 - if (!locked && p_s_tb->CFR[i]) {
613 - tb_buffer_sanity_check(p_s_tb->tb_sb,
614 - p_s_tb->CFR[i],
615 + if (!locked && tb->CFR[i]) {
616 + tb_buffer_sanity_check(tb->tb_sb,
617 + tb->CFR[i],
618 "CFR", i);
619 if (!clear_all_dirty_bits
620 - (p_s_tb->tb_sb, p_s_tb->CFR[i]))
621 - locked = p_s_tb->CFR[i];
622 + (tb->tb_sb, tb->CFR[i]))
623 + locked = tb->CFR[i];
624 }
625 }
626 }
627 @@ -2252,10 +2257,10 @@ static int wait_tb_buffers_until_unlocke
628 ** --clm
629 */
630 for (i = 0; !locked && i < MAX_FEB_SIZE; i++) {
631 - if (p_s_tb->FEB[i]) {
632 + if (tb->FEB[i]) {
633 if (!clear_all_dirty_bits
634 - (p_s_tb->tb_sb, p_s_tb->FEB[i]))
635 - locked = p_s_tb->FEB[i];
636 + (tb->tb_sb, tb->FEB[i]))
637 + locked = tb->FEB[i];
638 }
639 }
640
641 @@ -2263,21 +2268,20 @@ static int wait_tb_buffers_until_unlocke
642 #ifdef CONFIG_REISERFS_CHECK
643 repeat_counter++;
644 if ((repeat_counter % 10000) == 0) {
645 - reiserfs_warning(p_s_tb->tb_sb, "reiserfs-8200",
646 + reiserfs_warning(tb->tb_sb, "reiserfs-8200",
647 "too many iterations waiting "
648 "for buffer to unlock "
649 "(%b)", locked);
650
651 /* Don't loop forever. Try to recover from possible error. */
652
653 - return (FILESYSTEM_CHANGED_TB(p_s_tb)) ?
654 + return (FILESYSTEM_CHANGED_TB(tb)) ?
655 REPEAT_SEARCH : CARRY_ON;
656 }
657 #endif
658 __wait_on_buffer(locked);
659 - if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
660 + if (FILESYSTEM_CHANGED_TB(tb))
661 return REPEAT_SEARCH;
662 - }
663 }
664
665 } while (locked);
666 @@ -2307,138 +2311,136 @@ static int wait_tb_buffers_until_unlocke
667 * tb tree_balance structure;
668 * inum item number in S[h];
669 * pos_in_item - comment this if you can
670 - * ins_ih & ins_sd are used when inserting
671 + * ins_ih item head of item being inserted
672 + * data inserted item or data to be pasted
673 * Returns: 1 - schedule occurred while the function worked;
674 * 0 - schedule didn't occur while the function worked;
675 * -1 - if no_disk_space
676 */
677
678 -int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb, struct item_head *p_s_ins_ih, // item head of item being inserted
679 - const void *data // inserted item or data to be pasted
680 - )
681 +int fix_nodes(int n_op_mode, struct tree_balance *tb,
682 + struct item_head *p_s_ins_ih, const void *data)
683 {
684 - int n_ret_value, n_h, n_item_num = PATH_LAST_POSITION(p_s_tb->tb_path);
685 + int n_ret_value, n_h, n_item_num = PATH_LAST_POSITION(tb->tb_path);
686 int n_pos_in_item;
687
688 /* we set wait_tb_buffers_run when we have to restore any dirty bits cleared
689 ** during wait_tb_buffers_run
690 */
691 int wait_tb_buffers_run = 0;
692 - struct buffer_head *p_s_tbS0 = PATH_PLAST_BUFFER(p_s_tb->tb_path);
693 + struct buffer_head *tbS0 = PATH_PLAST_BUFFER(tb->tb_path);
694
695 - ++REISERFS_SB(p_s_tb->tb_sb)->s_fix_nodes;
696 + ++REISERFS_SB(tb->tb_sb)->s_fix_nodes;
697
698 - n_pos_in_item = p_s_tb->tb_path->pos_in_item;
699 + n_pos_in_item = tb->tb_path->pos_in_item;
700
701 - p_s_tb->fs_gen = get_generation(p_s_tb->tb_sb);
702 + tb->fs_gen = get_generation(tb->tb_sb);
703
704 /* we prepare and log the super here so it will already be in the
705 ** transaction when do_balance needs to change it.
706 ** This way do_balance won't have to schedule when trying to prepare
707 ** the super for logging
708 */
709 - reiserfs_prepare_for_journal(p_s_tb->tb_sb,
710 - SB_BUFFER_WITH_SB(p_s_tb->tb_sb), 1);
711 - journal_mark_dirty(p_s_tb->transaction_handle, p_s_tb->tb_sb,
712 - SB_BUFFER_WITH_SB(p_s_tb->tb_sb));
713 - if (FILESYSTEM_CHANGED_TB(p_s_tb))
714 + reiserfs_prepare_for_journal(tb->tb_sb,
715 + SB_BUFFER_WITH_SB(tb->tb_sb), 1);
716 + journal_mark_dirty(tb->transaction_handle, tb->tb_sb,
717 + SB_BUFFER_WITH_SB(tb->tb_sb));
718 + if (FILESYSTEM_CHANGED_TB(tb))
719 return REPEAT_SEARCH;
720
721 /* if it possible in indirect_to_direct conversion */
722 - if (buffer_locked(p_s_tbS0)) {
723 - __wait_on_buffer(p_s_tbS0);
724 - if (FILESYSTEM_CHANGED_TB(p_s_tb))
725 + if (buffer_locked(tbS0)) {
726 + __wait_on_buffer(tbS0);
727 + if (FILESYSTEM_CHANGED_TB(tb))
728 return REPEAT_SEARCH;
729 }
730 #ifdef CONFIG_REISERFS_CHECK
731 if (cur_tb) {
732 print_cur_tb("fix_nodes");
733 - reiserfs_panic(p_s_tb->tb_sb, "PAP-8305",
734 + reiserfs_panic(tb->tb_sb, "PAP-8305",
735 "there is pending do_balance");
736 }
737
738 - if (!buffer_uptodate(p_s_tbS0) || !B_IS_IN_TREE(p_s_tbS0)) {
739 - reiserfs_panic(p_s_tb->tb_sb, "PAP-8320", "S[0] (%b %z) is "
740 + if (!buffer_uptodate(tbS0) || !B_IS_IN_TREE(tbS0))
741 + reiserfs_panic(tb->tb_sb, "PAP-8320", "S[0] (%b %z) is "
742 "not uptodate at the beginning of fix_nodes "
743 "or not in tree (mode %c)",
744 - p_s_tbS0, p_s_tbS0, n_op_mode);
745 - }
746 + tbS0, tbS0, n_op_mode);
747
748 /* Check parameters. */
749 switch (n_op_mode) {
750 case M_INSERT:
751 - if (n_item_num <= 0 || n_item_num > B_NR_ITEMS(p_s_tbS0))
752 - reiserfs_panic(p_s_tb->tb_sb, "PAP-8330", "Incorrect "
753 + if (n_item_num <= 0 || n_item_num > B_NR_ITEMS(tbS0))
754 + reiserfs_panic(tb->tb_sb, "PAP-8330", "Incorrect "
755 "item number %d (in S0 - %d) in case "
756 "of insert", n_item_num,
757 - B_NR_ITEMS(p_s_tbS0));
758 + B_NR_ITEMS(tbS0));
759 break;
760 case M_PASTE:
761 case M_DELETE:
762 case M_CUT:
763 - if (n_item_num < 0 || n_item_num >= B_NR_ITEMS(p_s_tbS0)) {
764 - print_block(p_s_tbS0, 0, -1, -1);
765 - reiserfs_panic(p_s_tb->tb_sb, "PAP-8335", "Incorrect "
766 + if (n_item_num < 0 || n_item_num >= B_NR_ITEMS(tbS0)) {
767 + print_block(tbS0, 0, -1, -1);
768 + reiserfs_panic(tb->tb_sb, "PAP-8335", "Incorrect "
769 "item number(%d); mode = %c "
770 "insert_size = %d",
771 n_item_num, n_op_mode,
772 - p_s_tb->insert_size[0]);
773 + tb->insert_size[0]);
774 }
775 break;
776 default:
777 - reiserfs_panic(p_s_tb->tb_sb, "PAP-8340", "Incorrect mode "
778 + reiserfs_panic(tb->tb_sb, "PAP-8340", "Incorrect mode "
779 "of operation");
780 }
781 #endif
782
783 - if (get_mem_for_virtual_node(p_s_tb) == REPEAT_SEARCH)
784 + if (get_mem_for_virtual_node(tb) == REPEAT_SEARCH)
785 // FIXME: maybe -ENOMEM when tb->vn_buf == 0? Now just repeat
786 return REPEAT_SEARCH;
787
788 /* Starting from the leaf level; for all levels n_h of the tree. */
789 - for (n_h = 0; n_h < MAX_HEIGHT && p_s_tb->insert_size[n_h]; n_h++) {
790 - if ((n_ret_value = get_direct_parent(p_s_tb, n_h)) != CARRY_ON) {
791 + for (n_h = 0; n_h < MAX_HEIGHT && tb->insert_size[n_h]; n_h++) {
792 + n_ret_value = get_direct_parent(tb, n_h);
793 + if (n_ret_value != CARRY_ON)
794 goto repeat;
795 - }
796
797 - if ((n_ret_value =
798 - check_balance(n_op_mode, p_s_tb, n_h, n_item_num,
799 - n_pos_in_item, p_s_ins_ih,
800 - data)) != CARRY_ON) {
801 + n_ret_value = check_balance(n_op_mode, tb, n_h, n_item_num,
802 + n_pos_in_item, p_s_ins_ih, data);
803 + if (n_ret_value != CARRY_ON) {
804 if (n_ret_value == NO_BALANCING_NEEDED) {
805 /* No balancing for higher levels needed. */
806 - if ((n_ret_value =
807 - get_neighbors(p_s_tb, n_h)) != CARRY_ON) {
808 + n_ret_value = get_neighbors(tb, n_h);
809 + if (n_ret_value != CARRY_ON)
810 goto repeat;
811 - }
812 if (n_h != MAX_HEIGHT - 1)
813 - p_s_tb->insert_size[n_h + 1] = 0;
814 + tb->insert_size[n_h + 1] = 0;
815 /* ok, analysis and resource gathering are complete */
816 break;
817 }
818 goto repeat;
819 }
820
821 - if ((n_ret_value = get_neighbors(p_s_tb, n_h)) != CARRY_ON) {
822 + n_ret_value = get_neighbors(tb, n_h);
823 + if (n_ret_value != CARRY_ON)
824 goto repeat;
825 - }
826
827 - if ((n_ret_value = get_empty_nodes(p_s_tb, n_h)) != CARRY_ON) {
828 - goto repeat; /* No disk space, or schedule occurred and
829 - analysis may be invalid and needs to be redone. */
830 - }
831 + /* No disk space, or schedule occurred and analysis may be
832 + * invalid and needs to be redone. */
833 + n_ret_value = get_empty_nodes(tb, n_h);
834 + if (n_ret_value != CARRY_ON)
835 + goto repeat;
836
837 - if (!PATH_H_PBUFFER(p_s_tb->tb_path, n_h)) {
838 + if (!PATH_H_PBUFFER(tb->tb_path, n_h)) {
839 /* We have a positive insert size but no nodes exist on this
840 level, this means that we are creating a new root. */
841
842 - RFALSE(p_s_tb->blknum[n_h] != 1,
843 + RFALSE(tb->blknum[n_h] != 1,
844 "PAP-8350: creating new empty root");
845
846 if (n_h < MAX_HEIGHT - 1)
847 - p_s_tb->insert_size[n_h + 1] = 0;
848 - } else if (!PATH_H_PBUFFER(p_s_tb->tb_path, n_h + 1)) {
849 - if (p_s_tb->blknum[n_h] > 1) {
850 + tb->insert_size[n_h + 1] = 0;
851 + } else if (!PATH_H_PBUFFER(tb->tb_path, n_h + 1)) {
852 + if (tb->blknum[n_h] > 1) {
853 /* The tree needs to be grown, so this node S[n_h]
854 which is the root node is split into two nodes,
855 and a new node (S[n_h+1]) will be created to
856 @@ -2447,19 +2449,20 @@ int fix_nodes(int n_op_mode, struct tree
857 RFALSE(n_h == MAX_HEIGHT - 1,
858 "PAP-8355: attempt to create too high of a tree");
859
860 - p_s_tb->insert_size[n_h + 1] =
861 + tb->insert_size[n_h + 1] =
862 (DC_SIZE +
863 - KEY_SIZE) * (p_s_tb->blknum[n_h] - 1) +
864 + KEY_SIZE) * (tb->blknum[n_h] - 1) +
865 DC_SIZE;
866 } else if (n_h < MAX_HEIGHT - 1)
867 - p_s_tb->insert_size[n_h + 1] = 0;
868 + tb->insert_size[n_h + 1] = 0;
869 } else
870 - p_s_tb->insert_size[n_h + 1] =
871 - (DC_SIZE + KEY_SIZE) * (p_s_tb->blknum[n_h] - 1);
872 + tb->insert_size[n_h + 1] =
873 + (DC_SIZE + KEY_SIZE) * (tb->blknum[n_h] - 1);
874 }
875
876 - if ((n_ret_value = wait_tb_buffers_until_unlocked(p_s_tb)) == CARRY_ON) {
877 - if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
878 + n_ret_value = wait_tb_buffers_until_unlocked(tb);
879 + if (n_ret_value == CARRY_ON) {
880 + if (FILESYSTEM_CHANGED_TB(tb)) {
881 wait_tb_buffers_run = 1;
882 n_ret_value = REPEAT_SEARCH;
883 goto repeat;
884 @@ -2482,50 +2485,49 @@ int fix_nodes(int n_op_mode, struct tree
885
886 /* Release path buffers. */
887 if (wait_tb_buffers_run) {
888 - pathrelse_and_restore(p_s_tb->tb_sb, p_s_tb->tb_path);
889 + pathrelse_and_restore(tb->tb_sb, tb->tb_path);
890 } else {
891 - pathrelse(p_s_tb->tb_path);
892 + pathrelse(tb->tb_path);
893 }
894 /* brelse all resources collected for balancing */
895 for (i = 0; i < MAX_HEIGHT; i++) {
896 if (wait_tb_buffers_run) {
897 - reiserfs_restore_prepared_buffer(p_s_tb->tb_sb,
898 - p_s_tb->L[i]);
899 - reiserfs_restore_prepared_buffer(p_s_tb->tb_sb,
900 - p_s_tb->R[i]);
901 - reiserfs_restore_prepared_buffer(p_s_tb->tb_sb,
902 - p_s_tb->FL[i]);
903 - reiserfs_restore_prepared_buffer(p_s_tb->tb_sb,
904 - p_s_tb->FR[i]);
905 - reiserfs_restore_prepared_buffer(p_s_tb->tb_sb,
906 - p_s_tb->
907 + reiserfs_restore_prepared_buffer(tb->tb_sb,
908 + tb->L[i]);
909 + reiserfs_restore_prepared_buffer(tb->tb_sb,
910 + tb->R[i]);
911 + reiserfs_restore_prepared_buffer(tb->tb_sb,
912 + tb->FL[i]);
913 + reiserfs_restore_prepared_buffer(tb->tb_sb,
914 + tb->FR[i]);
915 + reiserfs_restore_prepared_buffer(tb->tb_sb,
916 + tb->
917 CFL[i]);
918 - reiserfs_restore_prepared_buffer(p_s_tb->tb_sb,
919 - p_s_tb->
920 + reiserfs_restore_prepared_buffer(tb->tb_sb,
921 + tb->
922 CFR[i]);
923 }
924
925 - brelse(p_s_tb->L[i]);
926 - brelse(p_s_tb->R[i]);
927 - brelse(p_s_tb->FL[i]);
928 - brelse(p_s_tb->FR[i]);
929 - brelse(p_s_tb->CFL[i]);
930 - brelse(p_s_tb->CFR[i]);
931 -
932 - p_s_tb->L[i] = NULL;
933 - p_s_tb->R[i] = NULL;
934 - p_s_tb->FL[i] = NULL;
935 - p_s_tb->FR[i] = NULL;
936 - p_s_tb->CFL[i] = NULL;
937 - p_s_tb->CFR[i] = NULL;
938 + brelse(tb->L[i]);
939 + brelse(tb->R[i]);
940 + brelse(tb->FL[i]);
941 + brelse(tb->FR[i]);
942 + brelse(tb->CFL[i]);
943 + brelse(tb->CFR[i]);
944 +
945 + tb->L[i] = NULL;
946 + tb->R[i] = NULL;
947 + tb->FL[i] = NULL;
948 + tb->FR[i] = NULL;
949 + tb->CFL[i] = NULL;
950 + tb->CFR[i] = NULL;
951 }
952
953 if (wait_tb_buffers_run) {
954 for (i = 0; i < MAX_FEB_SIZE; i++) {
955 - if (p_s_tb->FEB[i]) {
956 + if (tb->FEB[i])
957 reiserfs_restore_prepared_buffer
958 - (p_s_tb->tb_sb, p_s_tb->FEB[i]);
959 - }
960 + (tb->tb_sb, tb->FEB[i]);
961 }
962 }
963 return n_ret_value;
964 @@ -2533,7 +2535,7 @@ int fix_nodes(int n_op_mode, struct tree
965
966 }
967
968 -/* Anatoly will probably forgive me renaming p_s_tb to tb. I just
969 +/* Anatoly will probably forgive me renaming tb to tb. I just
970 wanted to make lines shorter */
971 void unfix_nodes(struct tree_balance *tb)
972 {
973 --- a/fs/reiserfs/stree.c
974 +++ b/fs/reiserfs/stree.c
975 @@ -1063,17 +1063,17 @@ static char prepare_for_delete_or_cut(st
976 }
977
978 /* Calculate number of bytes which will be deleted or cut during balance */
979 -static int calc_deleted_bytes_number(struct tree_balance *p_s_tb, char c_mode)
980 +static int calc_deleted_bytes_number(struct tree_balance *tb, char c_mode)
981 {
982 int n_del_size;
983 - struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_tb->tb_path);
984 + struct item_head *p_le_ih = PATH_PITEM_HEAD(tb->tb_path);
985
986 if (is_statdata_le_ih(p_le_ih))
987 return 0;
988
989 n_del_size =
990 (c_mode ==
991 - M_DELETE) ? ih_item_len(p_le_ih) : -p_s_tb->insert_size[0];
992 + M_DELETE) ? ih_item_len(p_le_ih) : -tb->insert_size[0];
993 if (is_direntry_le_ih(p_le_ih)) {
994 // return EMPTY_DIR_SIZE; /* We delete emty directoris only. */
995 // we can't use EMPTY_DIR_SIZE, as old format dirs have a different
996 @@ -1083,25 +1083,26 @@ static int calc_deleted_bytes_number(str
997 }
998
999 if (is_indirect_le_ih(p_le_ih))
1000 - n_del_size = (n_del_size / UNFM_P_SIZE) * (PATH_PLAST_BUFFER(p_s_tb->tb_path)->b_size); // - get_ih_free_space (p_le_ih);
1001 + n_del_size = (n_del_size / UNFM_P_SIZE) *
1002 + (PATH_PLAST_BUFFER(tb->tb_path)->b_size);
1003 return n_del_size;
1004 }
1005
1006 static void init_tb_struct(struct reiserfs_transaction_handle *th,
1007 - struct tree_balance *p_s_tb,
1008 + struct tree_balance *tb,
1009 struct super_block *sb,
1010 struct treepath *p_s_path, int n_size)
1011 {
1012
1013 BUG_ON(!th->t_trans_id);
1014
1015 - memset(p_s_tb, '\0', sizeof(struct tree_balance));
1016 - p_s_tb->transaction_handle = th;
1017 - p_s_tb->tb_sb = sb;
1018 - p_s_tb->tb_path = p_s_path;
1019 + memset(tb, '\0', sizeof(struct tree_balance));
1020 + tb->transaction_handle = th;
1021 + tb->tb_sb = sb;
1022 + tb->tb_path = p_s_path;
1023 PATH_OFFSET_PBUFFER(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
1024 PATH_OFFSET_POSITION(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
1025 - p_s_tb->insert_size[0] = n_size;
1026 + tb->insert_size[0] = n_size;
1027 }
1028
1029 void padd_item(char *item, int total_length, int length)
1030 --- a/include/linux/reiserfs_fs.h
1031 +++ b/include/linux/reiserfs_fs.h
1032 @@ -2004,7 +2004,7 @@ extern const struct address_space_operat
1033
1034 /* fix_nodes.c */
1035
1036 -int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb,
1037 +int fix_nodes(int n_op_mode, struct tree_balance *tb,
1038 struct item_head *p_s_ins_ih, const void *);
1039 void unfix_nodes(struct tree_balance *);
1040
Peter's tree of IPFire 2.x