]> git.ipfire.org Git - ipfire-2.x.git/blame - src/patches/suse-2.6.27.31/patches.suse/reiserfs-rename-p_s_bh.diff
projects / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add a patch to fix Intel E100 wake-on-lan problems.
[ipfire-2.x.git] / src / patches / suse-2.6.27.31 / patches.suse / reiserfs-rename-p_s_bh.diff
CommitLineData
6a930a95
BS		 1From: Jeff Mahoney <jeffm@suse.com>
2Subject: reiserfs: rename p_s_bh to bh
3
4 This patch is a simple s/p_s_bh/bh/g to the reiserfs code. This is the second
5 in a series of patches to rip out some of the awful variable naming in
6 reiserfs.
7
8Signed-off-by: Jeff Mahoney <jeffm@suse.com>
9
10---
11
12 fs/reiserfs/fix_node.c | 94 ++++++++++++++++++++------------------------
13 fs/reiserfs/stree.c | 63 ++++++++++++++---------------
14 include/linux/reiserfs_fs.h | 37 ++++++++---------
15 3 files changed, 94 insertions(+), 100 deletions(-)
16
17--- a/fs/reiserfs/fix_node.c
18+++ b/fs/reiserfs/fix_node.c
19@@ -1887,7 +1887,7 @@ static int check_balance(int mode,
20 /* Check whether parent at the path is the really parent of the current node.*/
21 static int get_direct_parent(struct tree_balance *p_s_tb, int n_h)
22 {
23- struct buffer_head *p_s_bh;
24+ struct buffer_head *bh;
25 struct treepath *p_s_path = p_s_tb->tb_path;
26 int n_position,
27 n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
28@@ -1909,21 +1909,21 @@ static int get_direct_parent(struct tree
29 }
30
31 if (!B_IS_IN_TREE
32- (p_s_bh = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1)))
33+ (bh = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1)))
34 return REPEAT_SEARCH; /* Parent in the path is not in the tree. */
35
36 if ((n_position =
37 PATH_OFFSET_POSITION(p_s_path,
38- n_path_offset - 1)) > B_NR_ITEMS(p_s_bh))
39+ n_path_offset - 1)) > B_NR_ITEMS(bh))
40 return REPEAT_SEARCH;
41
42- if (B_N_CHILD_NUM(p_s_bh, n_position) !=
43+ if (B_N_CHILD_NUM(bh, n_position) !=
44 PATH_OFFSET_PBUFFER(p_s_path, n_path_offset)->b_blocknr)
45 /* Parent in the path is not parent of the current node in the tree. */
46 return REPEAT_SEARCH;
47
48- if (buffer_locked(p_s_bh)) {
49- __wait_on_buffer(p_s_bh);
50+ if (buffer_locked(bh)) {
51+ __wait_on_buffer(bh);
52 if (FILESYSTEM_CHANGED_TB(p_s_tb))
53 return REPEAT_SEARCH;
54 }
55@@ -1943,29 +1943,29 @@ static int get_neighbors(struct tree_bal
56 n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1);
57 unsigned long n_son_number;
58 struct super_block *sb = p_s_tb->tb_sb;
59- struct buffer_head *p_s_bh;
60+ struct buffer_head *bh;
61
62 PROC_INFO_INC(sb, get_neighbors[n_h]);
63
64 if (p_s_tb->lnum[n_h]) {
65 /* We need left neighbor to balance S[n_h]. */
66 PROC_INFO_INC(sb, need_l_neighbor[n_h]);
67- p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
68+ bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
69
70- RFALSE(p_s_bh == p_s_tb->FL[n_h] &&
71+ RFALSE(bh == p_s_tb->FL[n_h] &&
72 !PATH_OFFSET_POSITION(p_s_tb->tb_path, n_path_offset),
73 "PAP-8270: invalid position in the parent");
74
75 n_child_position =
76- (p_s_bh ==
77+ (bh ==
78 p_s_tb->FL[n_h]) ? p_s_tb->lkey[n_h] : B_NR_ITEMS(p_s_tb->
79 FL[n_h]);
80 n_son_number = B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position);
81- p_s_bh = sb_bread(sb, n_son_number);
82- if (!p_s_bh)
83+ bh = sb_bread(sb, n_son_number);
84+ if (!bh)
85 return IO_ERROR;
86 if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
87- brelse(p_s_bh);
88+ brelse(bh);
89 PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
90 return REPEAT_SEARCH;
91 }
92@@ -1973,48 +1973,48 @@ static int get_neighbors(struct tree_bal
93 RFALSE(!B_IS_IN_TREE(p_s_tb->FL[n_h]) ||
94 n_child_position > B_NR_ITEMS(p_s_tb->FL[n_h]) ||
95 B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position) !=
96- p_s_bh->b_blocknr, "PAP-8275: invalid parent");
97- RFALSE(!B_IS_IN_TREE(p_s_bh), "PAP-8280: invalid child");
98+ bh->b_blocknr, "PAP-8275: invalid parent");
99+ RFALSE(!B_IS_IN_TREE(bh), "PAP-8280: invalid child");
100 RFALSE(!n_h &&
101- B_FREE_SPACE(p_s_bh) !=
102- MAX_CHILD_SIZE(p_s_bh) -
103+ B_FREE_SPACE(bh) !=
104+ MAX_CHILD_SIZE(bh) -
105 dc_size(B_N_CHILD(p_s_tb->FL[0], n_child_position)),
106 "PAP-8290: invalid child size of left neighbor");
107
108 brelse(p_s_tb->L[n_h]);
109- p_s_tb->L[n_h] = p_s_bh;
110+ p_s_tb->L[n_h] = bh;
111 }
112
113 if (p_s_tb->rnum[n_h]) { /* We need right neighbor to balance S[n_path_offset]. */
114 PROC_INFO_INC(sb, need_r_neighbor[n_h]);
115- p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
116+ bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
117
118- RFALSE(p_s_bh == p_s_tb->FR[n_h] &&
119+ RFALSE(bh == p_s_tb->FR[n_h] &&
120 PATH_OFFSET_POSITION(p_s_tb->tb_path,
121 n_path_offset) >=
122- B_NR_ITEMS(p_s_bh),
123+ B_NR_ITEMS(bh),
124 "PAP-8295: invalid position in the parent");
125
126 n_child_position =
127- (p_s_bh == p_s_tb->FR[n_h]) ? p_s_tb->rkey[n_h] + 1 : 0;
128+ (bh == p_s_tb->FR[n_h]) ? p_s_tb->rkey[n_h] + 1 : 0;
129 n_son_number = B_N_CHILD_NUM(p_s_tb->FR[n_h], n_child_position);
130- p_s_bh = sb_bread(sb, n_son_number);
131- if (!p_s_bh)
132+ bh = sb_bread(sb, n_son_number);
133+ if (!bh)
134 return IO_ERROR;
135 if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
136- brelse(p_s_bh);
137+ brelse(bh);
138 PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
139 return REPEAT_SEARCH;
140 }
141 brelse(p_s_tb->R[n_h]);
142- p_s_tb->R[n_h] = p_s_bh;
143+ p_s_tb->R[n_h] = bh;
144
145 RFALSE(!n_h
146- && B_FREE_SPACE(p_s_bh) !=
147- MAX_CHILD_SIZE(p_s_bh) -
148+ && B_FREE_SPACE(bh) !=
149+ MAX_CHILD_SIZE(bh) -
150 dc_size(B_N_CHILD(p_s_tb->FR[0], n_child_position)),
151 "PAP-8300: invalid child size of right neighbor (%d != %d - %d)",
152- B_FREE_SPACE(p_s_bh), MAX_CHILD_SIZE(p_s_bh),
153+ B_FREE_SPACE(bh), MAX_CHILD_SIZE(bh),
154 dc_size(B_N_CHILD(p_s_tb->FR[0], n_child_position)));
155
156 }
157@@ -2090,51 +2090,45 @@ static int get_mem_for_virtual_node(stru
158
159 #ifdef CONFIG_REISERFS_CHECK
160 static void tb_buffer_sanity_check(struct super_block *sb,
161- struct buffer_head *p_s_bh,
162+ struct buffer_head *bh,
163 const char *descr, int level)
164 {
165- if (p_s_bh) {
166- if (atomic_read(&(p_s_bh->b_count)) <= 0) {
167+ if (bh) {
168+ if (atomic_read(&(bh->b_count)) <= 0)
169
170 reiserfs_panic(sb, "jmacd-1", "negative or zero "
171 "reference counter for buffer %s[%d] "
172- "(%b)", descr, level, p_s_bh);
173- }
174+ "(%b)", descr, level, bh);
175
176- if (!buffer_uptodate(p_s_bh)) {
177+ if (!buffer_uptodate(bh))
178 reiserfs_panic(sb, "jmacd-2", "buffer is not up "
179 "to date %s[%d] (%b)",
180- descr, level, p_s_bh);
181- }
182+ descr, level, bh);
183
184- if (!B_IS_IN_TREE(p_s_bh)) {
185+ if (!B_IS_IN_TREE(bh))
186 reiserfs_panic(sb, "jmacd-3", "buffer is not "
187 "in tree %s[%d] (%b)",
188- descr, level, p_s_bh);
189- }
190+ descr, level, bh);
191
192- if (p_s_bh->b_bdev != sb->s_bdev) {
193+ if (bh->b_bdev != sb->s_bdev)
194 reiserfs_panic(sb, "jmacd-4", "buffer has wrong "
195 "device %s[%d] (%b)",
196- descr, level, p_s_bh);
197- }
198+ descr, level, bh);
199
200- if (p_s_bh->b_size != sb->s_blocksize) {
201+ if (bh->b_size != sb->s_blocksize)
202 reiserfs_panic(sb, "jmacd-5", "buffer has wrong "
203 "blocksize %s[%d] (%b)",
204- descr, level, p_s_bh);
205- }
206+ descr, level, bh);
207
208- if (p_s_bh->b_blocknr > SB_BLOCK_COUNT(sb)) {
209+ if (bh->b_blocknr > SB_BLOCK_COUNT(sb))
210 reiserfs_panic(sb, "jmacd-6", "buffer block "
211 "number too high %s[%d] (%b)",
212- descr, level, p_s_bh);
213- }
214+ descr, level, bh);
215 }
216 }
217 #else
218 static void tb_buffer_sanity_check(struct super_block *sb,
219- struct buffer_head *p_s_bh,
220+ struct buffer_head *bh,
221 const char *descr, int level)
222 {;
223 }
224--- a/fs/reiserfs/stree.c
225+++ b/fs/reiserfs/stree.c
226@@ -56,13 +56,13 @@
227 #include <linux/quotaops.h>
228
229 /* Does the buffer contain a disk block which is in the tree. */
230-inline int B_IS_IN_TREE(const struct buffer_head *p_s_bh)
231+inline int B_IS_IN_TREE(const struct buffer_head *bh)
232 {
233
234- RFALSE(B_LEVEL(p_s_bh) > MAX_HEIGHT,
235- "PAP-1010: block (%b) has too big level (%z)", p_s_bh, p_s_bh);
236+ RFALSE(B_LEVEL(bh) > MAX_HEIGHT,
237+ "PAP-1010: block (%b) has too big level (%z)", bh, bh);
238
239- return (B_LEVEL(p_s_bh) != FREE_LEVEL);
240+ return (B_LEVEL(bh) != FREE_LEVEL);
241 }
242
243 //
244@@ -579,7 +579,7 @@ int search_by_key(struct super_block *sb
245 {
246 b_blocknr_t n_block_number;
247 int expected_level;
248- struct buffer_head *p_s_bh;
249+ struct buffer_head *bh;
250 struct path_element *p_s_last_element;
251 int n_node_level, n_retval;
252 int right_neighbor_of_leaf_node;
253@@ -626,15 +626,14 @@ int search_by_key(struct super_block *sb
254
255 /* Read the next tree node, and set the last element in the path to
256 have a pointer to it. */
257- if ((p_s_bh = p_s_last_element->pe_buffer =
258+ if ((bh = p_s_last_element->pe_buffer =
259 sb_getblk(sb, n_block_number))) {
260- if (!buffer_uptodate(p_s_bh) && reada_count > 1) {
261+ if (!buffer_uptodate(bh) && reada_count > 1)
262 search_by_key_reada(sb, reada_bh,
263 reada_blocks, reada_count);
264- }
265- ll_rw_block(READ, 1, &p_s_bh);
266- wait_on_buffer(p_s_bh);
267- if (!buffer_uptodate(p_s_bh))
268+ ll_rw_block(READ, 1, &bh);
269+ wait_on_buffer(bh);
270+ if (!buffer_uptodate(bh))
271 goto io_error;
272 } else {
273 io_error:
274@@ -651,8 +650,8 @@ int search_by_key(struct super_block *sb
275 to search is still in the tree rooted from the current buffer. If
276 not then repeat search from the root. */
277 if (fs_changed(fs_gen, sb) &&
278- (!B_IS_IN_TREE(p_s_bh) ||
279- B_LEVEL(p_s_bh) != expected_level ||
280+ (!B_IS_IN_TREE(bh) ||
281+ B_LEVEL(bh) != expected_level ||
282 !key_in_buffer(p_s_search_path, p_s_key, sb))) {
283 PROC_INFO_INC(sb, search_by_key_fs_changed);
284 PROC_INFO_INC(sb, search_by_key_restarted);
285@@ -686,25 +685,25 @@ int search_by_key(struct super_block *sb
286
287 // make sure, that the node contents look like a node of
288 // certain level
289- if (!is_tree_node(p_s_bh, expected_level)) {
290+ if (!is_tree_node(bh, expected_level)) {
291 reiserfs_error(sb, "vs-5150",
292 "invalid format found in block %ld. "
293- "Fsck?", p_s_bh->b_blocknr);
294+ "Fsck?", bh->b_blocknr);
295 pathrelse(p_s_search_path);
296 return IO_ERROR;
297 }
298
299 /* ok, we have acquired next formatted node in the tree */
300- n_node_level = B_LEVEL(p_s_bh);
301+ n_node_level = B_LEVEL(bh);
302
303- PROC_INFO_BH_STAT(sb, p_s_bh, n_node_level - 1);
304+ PROC_INFO_BH_STAT(sb, bh, n_node_level - 1);
305
306 RFALSE(n_node_level < n_stop_level,
307 "vs-5152: tree level (%d) is less than stop level (%d)",
308 n_node_level, n_stop_level);
309
310- n_retval = bin_search(p_s_key, B_N_PITEM_HEAD(p_s_bh, 0),
311- B_NR_ITEMS(p_s_bh),
312+ n_retval = bin_search(p_s_key, B_N_PITEM_HEAD(bh, 0),
313+ B_NR_ITEMS(bh),
314 (n_node_level ==
315 DISK_LEAF_NODE_LEVEL) ? IH_SIZE :
316 KEY_SIZE,
317@@ -726,13 +725,13 @@ int search_by_key(struct super_block *sb
318 an internal node. Now we calculate child block number by
319 position in the node. */
320 n_block_number =
321- B_N_CHILD_NUM(p_s_bh, p_s_last_element->pe_position);
322+ B_N_CHILD_NUM(bh, p_s_last_element->pe_position);
323
324 /* if we are going to read leaf nodes, try for read ahead as well */
325 if ((p_s_search_path->reada & PATH_READA) &&
326 n_node_level == DISK_LEAF_NODE_LEVEL + 1) {
327 int pos = p_s_last_element->pe_position;
328- int limit = B_NR_ITEMS(p_s_bh);
329+ int limit = B_NR_ITEMS(bh);
330 struct reiserfs_key *le_key;
331
332 if (p_s_search_path->reada & PATH_READA_BACK)
333@@ -741,7 +740,7 @@ int search_by_key(struct super_block *sb
334 if (pos == limit)
335 break;
336 reada_blocks[reada_count++] =
337- B_N_CHILD_NUM(p_s_bh, pos);
338+ B_N_CHILD_NUM(bh, pos);
339 if (p_s_search_path->reada & PATH_READA_BACK)
340 pos--;
341 else
342@@ -750,7 +749,7 @@ int search_by_key(struct super_block *sb
343 /*
344 * check to make sure we're in the same object
345 */
346- le_key = B_N_PDELIM_KEY(p_s_bh, pos);
347+ le_key = B_N_PDELIM_KEY(bh, pos);
348 if (le32_to_cpu(le_key->k_objectid) !=
349 p_s_key->on_disk_key.k_objectid) {
350 break;
351@@ -851,15 +850,15 @@ int search_for_position_by_key(struct su
352 /* Compare given item and item pointed to by the path. */
353 int comp_items(const struct item_head *stored_ih, const struct treepath *p_s_path)
354 {
355- struct buffer_head *p_s_bh;
356+ struct buffer_head *bh = PATH_PLAST_BUFFER(p_s_path);
357 struct item_head *ih;
358
359 /* Last buffer at the path is not in the tree. */
360- if (!B_IS_IN_TREE(p_s_bh = PATH_PLAST_BUFFER(p_s_path)))
361+ if (!B_IS_IN_TREE(bh))
362 return 1;
363
364 /* Last path position is invalid. */
365- if (PATH_LAST_POSITION(p_s_path) >= B_NR_ITEMS(p_s_bh))
366+ if (PATH_LAST_POSITION(p_s_path) >= B_NR_ITEMS(bh))
367 return 1;
368
369 /* we need only to know, whether it is the same item */
370@@ -959,7 +958,7 @@ static char prepare_for_delete_or_cut(st
371 {
372 struct super_block *sb = inode->i_sb;
373 struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_path);
374- struct buffer_head *p_s_bh = PATH_PLAST_BUFFER(p_s_path);
375+ struct buffer_head *bh = PATH_PLAST_BUFFER(p_s_path);
376
377 BUG_ON(!th->t_trans_id);
378
379@@ -1003,7 +1002,7 @@ static char prepare_for_delete_or_cut(st
380 do {
381 need_re_search = 0;
382 *p_n_cut_size = 0;
383- p_s_bh = PATH_PLAST_BUFFER(p_s_path);
384+ bh = PATH_PLAST_BUFFER(p_s_path);
385 copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
386 pos = I_UNFM_NUM(&s_ih);
387
388@@ -1019,13 +1018,13 @@ static char prepare_for_delete_or_cut(st
389 break;
390 }
391
392- unfm = (__le32 *)B_I_PITEM(p_s_bh, &s_ih) + pos - 1;
393+ unfm = (__le32 *)B_I_PITEM(bh, &s_ih) + pos - 1;
394 block = get_block_num(unfm, 0);
395
396 if (block != 0) {
397- reiserfs_prepare_for_journal(sb, p_s_bh, 1);
398+ reiserfs_prepare_for_journal(sb, bh, 1);
399 put_block_num(unfm, 0, 0);
400- journal_mark_dirty (th, sb, p_s_bh);
401+ journal_mark_dirty(th, sb, bh);
402 reiserfs_free_block(th, inode, block, 1);
403 }
404
405@@ -1049,7 +1048,7 @@ static char prepare_for_delete_or_cut(st
406 /* a trick. If the buffer has been logged, this will do nothing. If
407 ** we've broken the loop without logging it, it will restore the
408 ** buffer */
409- reiserfs_restore_prepared_buffer(sb, p_s_bh);
410+ reiserfs_restore_prepared_buffer(sb, bh);
411 } while (need_re_search &&
412 search_for_position_by_key(sb, p_s_item_key, p_s_path) == POSITION_FOUND);
413 pos_in_item(p_s_path) = pos * UNFM_P_SIZE;
414--- a/include/linux/reiserfs_fs.h
415+++ b/include/linux/reiserfs_fs.h
416@@ -751,25 +751,25 @@ struct block_head {
417 #define DISK_LEAF_NODE_LEVEL 1 /* Leaf node level. */
418
419 /* Given the buffer head of a formatted node, resolve to the block head of that node. */
420-#define B_BLK_HEAD(p_s_bh) ((struct block_head *)((p_s_bh)->b_data))
421+#define B_BLK_HEAD(bh) ((struct block_head *)((bh)->b_data))
422 /* Number of items that are in buffer. */
423-#define B_NR_ITEMS(p_s_bh) (blkh_nr_item(B_BLK_HEAD(p_s_bh)))
424-#define B_LEVEL(p_s_bh) (blkh_level(B_BLK_HEAD(p_s_bh)))
425-#define B_FREE_SPACE(p_s_bh) (blkh_free_space(B_BLK_HEAD(p_s_bh)))
426-
427-#define PUT_B_NR_ITEMS(p_s_bh,val) do { set_blkh_nr_item(B_BLK_HEAD(p_s_bh),val); } while (0)
428-#define PUT_B_LEVEL(p_s_bh,val) do { set_blkh_level(B_BLK_HEAD(p_s_bh),val); } while (0)
429-#define PUT_B_FREE_SPACE(p_s_bh,val) do { set_blkh_free_space(B_BLK_HEAD(p_s_bh),val); } while (0)
430+#define B_NR_ITEMS(bh) (blkh_nr_item(B_BLK_HEAD(bh)))
431+#define B_LEVEL(bh) (blkh_level(B_BLK_HEAD(bh)))
432+#define B_FREE_SPACE(bh) (blkh_free_space(B_BLK_HEAD(bh)))
433+
434+#define PUT_B_NR_ITEMS(bh, val) do { set_blkh_nr_item(B_BLK_HEAD(bh), val); } while (0)
435+#define PUT_B_LEVEL(bh, val) do { set_blkh_level(B_BLK_HEAD(bh), val); } while (0)
436+#define PUT_B_FREE_SPACE(bh, val) do { set_blkh_free_space(B_BLK_HEAD(bh), val); } while (0)
437
438 /* Get right delimiting key. -- little endian */
439-#define B_PRIGHT_DELIM_KEY(p_s_bh) (&(blk_right_delim_key(B_BLK_HEAD(p_s_bh))))
440+#define B_PRIGHT_DELIM_KEY(bh) (&(blk_right_delim_key(B_BLK_HEAD(bh))))
441
442 /* Does the buffer contain a disk leaf. */
443-#define B_IS_ITEMS_LEVEL(p_s_bh) (B_LEVEL(p_s_bh) == DISK_LEAF_NODE_LEVEL)
444+#define B_IS_ITEMS_LEVEL(bh) (B_LEVEL(bh) == DISK_LEAF_NODE_LEVEL)
445
446 /* Does the buffer contain a disk internal node */
447-#define B_IS_KEYS_LEVEL(p_s_bh) (B_LEVEL(p_s_bh) > DISK_LEAF_NODE_LEVEL \
448- && B_LEVEL(p_s_bh) <= MAX_HEIGHT)
449+#define B_IS_KEYS_LEVEL(bh) (B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL \
450+ && B_LEVEL(bh) <= MAX_HEIGHT)
451
452 /***************************************************************************/
453 /* STAT DATA */
454@@ -1119,12 +1119,13 @@ struct disk_child {
455 #define put_dc_size(dc_p, val) do { (dc_p)->dc_size = cpu_to_le16(val); } while(0)
456
457 /* Get disk child by buffer header and position in the tree node. */
458-#define B_N_CHILD(p_s_bh,n_pos) ((struct disk_child *)\
459-((p_s_bh)->b_data+BLKH_SIZE+B_NR_ITEMS(p_s_bh)*KEY_SIZE+DC_SIZE*(n_pos)))
460+#define B_N_CHILD(bh, n_pos) ((struct disk_child *)\
461+((bh)->b_data + BLKH_SIZE + B_NR_ITEMS(bh) * KEY_SIZE + DC_SIZE * (n_pos)))
462
463 /* Get disk child number by buffer header and position in the tree node. */
464-#define B_N_CHILD_NUM(p_s_bh,n_pos) (dc_block_number(B_N_CHILD(p_s_bh,n_pos)))
465-#define PUT_B_N_CHILD_NUM(p_s_bh,n_pos, val) (put_dc_block_number(B_N_CHILD(p_s_bh,n_pos), val ))
466+#define B_N_CHILD_NUM(bh, n_pos) (dc_block_number(B_N_CHILD(bh, n_pos)))
467+#define PUT_B_N_CHILD_NUM(bh, n_pos, val) \
468+ (put_dc_block_number(B_N_CHILD(bh, n_pos), val))
469
470 /* maximal value of field child_size in structure disk_child */
471 /* child size is the combined size of all items and their headers */
472@@ -1837,7 +1838,7 @@ int search_by_key(struct super_block *,
473 int search_for_position_by_key(struct super_block *sb,
474 const struct cpu_key *p_s_cpu_key,
475 struct treepath *p_s_search_path);
476-extern void decrement_bcount(struct buffer_head *p_s_bh);
477+extern void decrement_bcount(struct buffer_head *bh);
478 void decrement_counters_in_path(struct treepath *p_s_search_path);
479 void pathrelse(struct treepath *p_s_search_path);
480 int reiserfs_check_path(struct treepath *p);
481@@ -1978,7 +1979,7 @@ int reiserfs_global_version_in_proc(char
482 #define PROC_INFO_MAX( sb, field, value ) VOID_V
483 #define PROC_INFO_INC( sb, field ) VOID_V
484 #define PROC_INFO_ADD( sb, field, val ) VOID_V
485-#define PROC_INFO_BH_STAT(sb, p_s_bh, n_node_level) VOID_V
486+#define PROC_INFO_BH_STAT(sb, bh, n_node_level) VOID_V
487 #endif
488
489 /* dir.c */
IPFire 2.x development tree