]>
Commit | Line | Data |
---|---|---|
4d1e5b62 AF |
1 | From: Jeff Mahoney <jeffm@suse.com> |
2 | Subject: reiserfs: rename p_._ variables | |
3 | ||
4 | This patch is a simple s/p_._//g to the reiserfs code. This is the fifth | |
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/file.c | 6 | |
13 | fs/reiserfs/fix_node.c | 169 +++++++-------- | |
14 | fs/reiserfs/stree.c | 472 +++++++++++++++++++++--------------------- | |
15 | fs/reiserfs/tail_conversion.c | 28 +- | |
16 | include/linux/reiserfs_fs.h | 46 ++-- | |
17 | 5 files changed, 365 insertions(+), 356 deletions(-) | |
18 | ||
19 | --- a/fs/reiserfs/file.c | |
20 | +++ b/fs/reiserfs/file.c | |
21 | @@ -134,10 +134,10 @@ static void reiserfs_vfs_truncate_file(s | |
22 | * be removed... | |
23 | */ | |
24 | ||
25 | -static int reiserfs_sync_file(struct file *p_s_filp, | |
26 | - struct dentry *p_s_dentry, int datasync) | |
27 | +static int reiserfs_sync_file(struct file *filp, | |
28 | + struct dentry *dentry, int datasync) | |
29 | { | |
30 | - struct inode *inode = p_s_dentry->d_inode; | |
31 | + struct inode *inode = dentry->d_inode; | |
32 | int n_err; | |
33 | int barrier_done; | |
34 | ||
35 | --- a/fs/reiserfs/fix_node.c | |
36 | +++ b/fs/reiserfs/fix_node.c | |
37 | @@ -780,9 +780,9 @@ static void free_buffers_in_tb(struct tr | |
38 | /* The function is NOT SCHEDULE-SAFE! */ | |
39 | static int get_empty_nodes(struct tree_balance *tb, int n_h) | |
40 | { | |
41 | - struct buffer_head *p_s_new_bh, | |
42 | - *p_s_Sh = PATH_H_PBUFFER(tb->tb_path, n_h); | |
43 | - b_blocknr_t *p_n_blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, }; | |
44 | + struct buffer_head *new_bh, | |
45 | + *Sh = PATH_H_PBUFFER(tb->tb_path, n_h); | |
46 | + b_blocknr_t *blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, }; | |
47 | int n_counter, n_number_of_freeblk, n_amount_needed, /* number of needed empty blocks */ | |
48 | n_retval = CARRY_ON; | |
49 | struct super_block *sb = tb->tb_sb; | |
50 | @@ -810,8 +810,8 @@ static int get_empty_nodes(struct tree_b | |
51 | 1) : 0; | |
52 | ||
53 | /* Allocate missing empty blocks. */ | |
54 | - /* if p_s_Sh == 0 then we are getting a new root */ | |
55 | - n_amount_needed = (p_s_Sh) ? (tb->blknum[n_h] - 1) : 1; | |
56 | + /* if Sh == 0 then we are getting a new root */ | |
57 | + n_amount_needed = (Sh) ? (tb->blknum[n_h] - 1) : 1; | |
58 | /* Amount_needed = the amount that we need more than the amount that we have. */ | |
59 | if (n_amount_needed > n_number_of_freeblk) | |
60 | n_amount_needed -= n_number_of_freeblk; | |
61 | @@ -824,25 +824,25 @@ static int get_empty_nodes(struct tree_b | |
62 | return NO_DISK_SPACE; | |
63 | ||
64 | /* for each blocknumber we just got, get a buffer and stick it on FEB */ | |
65 | - for (p_n_blocknr = a_n_blocknrs, n_counter = 0; | |
66 | - n_counter < n_amount_needed; p_n_blocknr++, n_counter++) { | |
67 | + for (blocknr = a_n_blocknrs, n_counter = 0; | |
68 | + n_counter < n_amount_needed; blocknr++, n_counter++) { | |
69 | ||
70 | - RFALSE(!*p_n_blocknr, | |
71 | + RFALSE(!*blocknr, | |
72 | "PAP-8135: reiserfs_new_blocknrs failed when got new blocks"); | |
73 | ||
74 | - p_s_new_bh = sb_getblk(sb, *p_n_blocknr); | |
75 | - RFALSE(buffer_dirty(p_s_new_bh) || | |
76 | - buffer_journaled(p_s_new_bh) || | |
77 | - buffer_journal_dirty(p_s_new_bh), | |
78 | + new_bh = sb_getblk(sb, *blocknr); | |
79 | + RFALSE(buffer_dirty(new_bh) || | |
80 | + buffer_journaled(new_bh) || | |
81 | + buffer_journal_dirty(new_bh), | |
82 | "PAP-8140: journlaled or dirty buffer %b for the new block", | |
83 | - p_s_new_bh); | |
84 | + new_bh); | |
85 | ||
86 | /* Put empty buffers into the array. */ | |
87 | RFALSE(tb->FEB[tb->cur_blknum], | |
88 | "PAP-8141: busy slot for new buffer"); | |
89 | ||
90 | - set_buffer_journal_new(p_s_new_bh); | |
91 | - tb->FEB[tb->cur_blknum++] = p_s_new_bh; | |
92 | + set_buffer_journal_new(new_bh); | |
93 | + tb->FEB[tb->cur_blknum++] = new_bh; | |
94 | } | |
95 | ||
96 | if (n_retval == CARRY_ON && FILESYSTEM_CHANGED_TB(tb)) | |
97 | @@ -898,7 +898,7 @@ static int get_rfree(struct tree_balance | |
98 | /* Check whether left neighbor is in memory. */ | |
99 | static int is_left_neighbor_in_cache(struct tree_balance *tb, int n_h) | |
100 | { | |
101 | - struct buffer_head *p_s_father, *left; | |
102 | + struct buffer_head *father, *left; | |
103 | struct super_block *sb = tb->tb_sb; | |
104 | b_blocknr_t n_left_neighbor_blocknr; | |
105 | int n_left_neighbor_position; | |
106 | @@ -908,18 +908,18 @@ static int is_left_neighbor_in_cache(str | |
107 | return 0; | |
108 | ||
109 | /* Calculate father of the node to be balanced. */ | |
110 | - p_s_father = PATH_H_PBUFFER(tb->tb_path, n_h + 1); | |
111 | + father = PATH_H_PBUFFER(tb->tb_path, n_h + 1); | |
112 | ||
113 | - RFALSE(!p_s_father || | |
114 | - !B_IS_IN_TREE(p_s_father) || | |
115 | + RFALSE(!father || | |
116 | + !B_IS_IN_TREE(father) || | |
117 | !B_IS_IN_TREE(tb->FL[n_h]) || | |
118 | - !buffer_uptodate(p_s_father) || | |
119 | + !buffer_uptodate(father) || | |
120 | !buffer_uptodate(tb->FL[n_h]), | |
121 | "vs-8165: F[h] (%b) or FL[h] (%b) is invalid", | |
122 | - p_s_father, tb->FL[n_h]); | |
123 | + father, tb->FL[n_h]); | |
124 | ||
125 | /* Get position of the pointer to the left neighbor into the left father. */ | |
126 | - n_left_neighbor_position = (p_s_father == tb->FL[n_h]) ? | |
127 | + n_left_neighbor_position = (father == tb->FL[n_h]) ? | |
128 | tb->lkey[n_h] : B_NR_ITEMS(tb->FL[n_h]); | |
129 | /* Get left neighbor block number. */ | |
130 | n_left_neighbor_blocknr = | |
131 | @@ -940,10 +940,10 @@ static int is_left_neighbor_in_cache(str | |
132 | #define LEFT_PARENTS 'l' | |
133 | #define RIGHT_PARENTS 'r' | |
134 | ||
135 | -static void decrement_key(struct cpu_key *p_s_key) | |
136 | +static void decrement_key(struct cpu_key *key) | |
137 | { | |
138 | // call item specific function for this key | |
139 | - item_ops[cpu_key_k_type(p_s_key)]->decrement_key(p_s_key); | |
140 | + item_ops[cpu_key_k_type(key)]->decrement_key(key); | |
141 | } | |
142 | ||
143 | /* Calculate far left/right parent of the left/right neighbor of the current node, that | |
144 | @@ -956,17 +956,17 @@ static void decrement_key(struct cpu_key | |
145 | */ | |
146 | static int get_far_parent(struct tree_balance *tb, | |
147 | int n_h, | |
148 | - struct buffer_head **pp_s_father, | |
149 | - struct buffer_head **pp_s_com_father, char c_lr_par) | |
150 | + struct buffer_head **pfather, | |
151 | + struct buffer_head **pcom_father, char c_lr_par) | |
152 | { | |
153 | - struct buffer_head *p_s_parent; | |
154 | + struct buffer_head *parent; | |
155 | INITIALIZE_PATH(s_path_to_neighbor_father); | |
156 | - struct treepath *p_s_path = tb->tb_path; | |
157 | + struct treepath *path = tb->tb_path; | |
158 | struct cpu_key s_lr_father_key; | |
159 | int n_counter, | |
160 | n_position = INT_MAX, | |
161 | n_first_last_position = 0, | |
162 | - n_path_offset = PATH_H_PATH_OFFSET(p_s_path, n_h); | |
163 | + n_path_offset = PATH_H_PATH_OFFSET(path, n_h); | |
164 | ||
165 | /* Starting from F[n_h] go upwards in the tree, and look for the common | |
166 | ancestor of F[n_h], and its neighbor l/r, that should be obtained. */ | |
167 | @@ -979,25 +979,25 @@ static int get_far_parent(struct tree_ba | |
168 | for (; n_counter > FIRST_PATH_ELEMENT_OFFSET; n_counter--) { | |
169 | /* Check whether parent of the current buffer in the path is really parent in the tree. */ | |
170 | if (!B_IS_IN_TREE | |
171 | - (p_s_parent = PATH_OFFSET_PBUFFER(p_s_path, n_counter - 1))) | |
172 | + (parent = PATH_OFFSET_PBUFFER(path, n_counter - 1))) | |
173 | return REPEAT_SEARCH; | |
174 | /* Check whether position in the parent is correct. */ | |
175 | if ((n_position = | |
176 | - PATH_OFFSET_POSITION(p_s_path, | |
177 | + PATH_OFFSET_POSITION(path, | |
178 | n_counter - 1)) > | |
179 | - B_NR_ITEMS(p_s_parent)) | |
180 | + B_NR_ITEMS(parent)) | |
181 | return REPEAT_SEARCH; | |
182 | /* Check whether parent at the path really points to the child. */ | |
183 | - if (B_N_CHILD_NUM(p_s_parent, n_position) != | |
184 | - PATH_OFFSET_PBUFFER(p_s_path, n_counter)->b_blocknr) | |
185 | + if (B_N_CHILD_NUM(parent, n_position) != | |
186 | + PATH_OFFSET_PBUFFER(path, n_counter)->b_blocknr) | |
187 | return REPEAT_SEARCH; | |
188 | /* Return delimiting key if position in the parent is not equal to first/last one. */ | |
189 | if (c_lr_par == RIGHT_PARENTS) | |
190 | - n_first_last_position = B_NR_ITEMS(p_s_parent); | |
191 | + n_first_last_position = B_NR_ITEMS(parent); | |
192 | if (n_position != n_first_last_position) { | |
193 | - *pp_s_com_father = p_s_parent; | |
194 | - get_bh(*pp_s_com_father); | |
195 | - /*(*pp_s_com_father = p_s_parent)->b_count++; */ | |
196 | + *pcom_father = parent; | |
197 | + get_bh(*pcom_father); | |
198 | + /*(*pcom_father = parent)->b_count++; */ | |
199 | break; | |
200 | } | |
201 | } | |
202 | @@ -1009,22 +1009,22 @@ static int get_far_parent(struct tree_ba | |
203 | (tb->tb_path, | |
204 | FIRST_PATH_ELEMENT_OFFSET)->b_blocknr == | |
205 | SB_ROOT_BLOCK(tb->tb_sb)) { | |
206 | - *pp_s_father = *pp_s_com_father = NULL; | |
207 | + *pfather = *pcom_father = NULL; | |
208 | return CARRY_ON; | |
209 | } | |
210 | return REPEAT_SEARCH; | |
211 | } | |
212 | ||
213 | - RFALSE(B_LEVEL(*pp_s_com_father) <= DISK_LEAF_NODE_LEVEL, | |
214 | + RFALSE(B_LEVEL(*pcom_father) <= DISK_LEAF_NODE_LEVEL, | |
215 | "PAP-8185: (%b %z) level too small", | |
216 | - *pp_s_com_father, *pp_s_com_father); | |
217 | + *pcom_father, *pcom_father); | |
218 | ||
219 | /* Check whether the common parent is locked. */ | |
220 | ||
221 | - if (buffer_locked(*pp_s_com_father)) { | |
222 | - __wait_on_buffer(*pp_s_com_father); | |
223 | + if (buffer_locked(*pcom_father)) { | |
224 | + __wait_on_buffer(*pcom_father); | |
225 | if (FILESYSTEM_CHANGED_TB(tb)) { | |
226 | - brelse(*pp_s_com_father); | |
227 | + brelse(*pcom_father); | |
228 | return REPEAT_SEARCH; | |
229 | } | |
230 | } | |
231 | @@ -1034,7 +1034,7 @@ static int get_far_parent(struct tree_ba | |
232 | ||
233 | /* Form key to get parent of the left/right neighbor. */ | |
234 | le_key2cpu_key(&s_lr_father_key, | |
235 | - B_N_PDELIM_KEY(*pp_s_com_father, | |
236 | + B_N_PDELIM_KEY(*pcom_father, | |
237 | (c_lr_par == | |
238 | LEFT_PARENTS) ? (tb->lkey[n_h - 1] = | |
239 | n_position - | |
240 | @@ -1053,14 +1053,14 @@ static int get_far_parent(struct tree_ba | |
241 | ||
242 | if (FILESYSTEM_CHANGED_TB(tb)) { | |
243 | pathrelse(&s_path_to_neighbor_father); | |
244 | - brelse(*pp_s_com_father); | |
245 | + brelse(*pcom_father); | |
246 | return REPEAT_SEARCH; | |
247 | } | |
248 | ||
249 | - *pp_s_father = PATH_PLAST_BUFFER(&s_path_to_neighbor_father); | |
250 | + *pfather = PATH_PLAST_BUFFER(&s_path_to_neighbor_father); | |
251 | ||
252 | - RFALSE(B_LEVEL(*pp_s_father) != n_h + 1, | |
253 | - "PAP-8190: (%b %z) level too small", *pp_s_father, *pp_s_father); | |
254 | + RFALSE(B_LEVEL(*pfather) != n_h + 1, | |
255 | + "PAP-8190: (%b %z) level too small", *pfather, *pfather); | |
256 | RFALSE(s_path_to_neighbor_father.path_length < | |
257 | FIRST_PATH_ELEMENT_OFFSET, "PAP-8192: path length is too small"); | |
258 | ||
259 | @@ -1078,11 +1078,11 @@ static int get_far_parent(struct tree_ba | |
260 | */ | |
261 | static int get_parents(struct tree_balance *tb, int n_h) | |
262 | { | |
263 | - struct treepath *p_s_path = tb->tb_path; | |
264 | + struct treepath *path = tb->tb_path; | |
265 | int n_position, | |
266 | n_ret_value, | |
267 | n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h); | |
268 | - struct buffer_head *p_s_curf, *p_s_curcf; | |
269 | + struct buffer_head *curf, *curcf; | |
270 | ||
271 | /* Current node is the root of the tree or will be root of the tree */ | |
272 | if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) { | |
273 | @@ -1100,66 +1100,65 @@ static int get_parents(struct tree_balan | |
274 | } | |
275 | ||
276 | /* Get parent FL[n_path_offset] of L[n_path_offset]. */ | |
277 | - if ((n_position = PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1))) { | |
278 | + n_position = PATH_OFFSET_POSITION(path, n_path_offset - 1); | |
279 | + if (n_position) { | |
280 | /* Current node is not the first child of its parent. */ | |
281 | - /*(p_s_curf = p_s_curcf = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1))->b_count += 2; */ | |
282 | - p_s_curf = p_s_curcf = | |
283 | - PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1); | |
284 | - get_bh(p_s_curf); | |
285 | - get_bh(p_s_curf); | |
286 | + curf = PATH_OFFSET_PBUFFER(path, n_path_offset - 1); | |
287 | + curcf = PATH_OFFSET_PBUFFER(path, n_path_offset - 1); | |
288 | + get_bh(curf); | |
289 | + get_bh(curf); | |
290 | tb->lkey[n_h] = n_position - 1; | |
291 | } else { | |
292 | /* Calculate current parent of L[n_path_offset], which is the left neighbor of the current node. | |
293 | Calculate current common parent of L[n_path_offset] and the current node. Note that | |
294 | CFL[n_path_offset] not equal FL[n_path_offset] and CFL[n_path_offset] not equal F[n_path_offset]. | |
295 | Calculate lkey[n_path_offset]. */ | |
296 | - if ((n_ret_value = get_far_parent(tb, n_h + 1, &p_s_curf, | |
297 | - &p_s_curcf, | |
298 | + if ((n_ret_value = get_far_parent(tb, n_h + 1, &curf, | |
299 | + &curcf, | |
300 | LEFT_PARENTS)) != CARRY_ON) | |
301 | return n_ret_value; | |
302 | } | |
303 | ||
304 | brelse(tb->FL[n_h]); | |
305 | - tb->FL[n_h] = p_s_curf; /* New initialization of FL[n_h]. */ | |
306 | + tb->FL[n_h] = curf; /* New initialization of FL[n_h]. */ | |
307 | brelse(tb->CFL[n_h]); | |
308 | - tb->CFL[n_h] = p_s_curcf; /* New initialization of CFL[n_h]. */ | |
309 | + tb->CFL[n_h] = curcf; /* New initialization of CFL[n_h]. */ | |
310 | ||
311 | - RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) || | |
312 | - (p_s_curcf && !B_IS_IN_TREE(p_s_curcf)), | |
313 | - "PAP-8195: FL (%b) or CFL (%b) is invalid", p_s_curf, p_s_curcf); | |
314 | + RFALSE((curf && !B_IS_IN_TREE(curf)) || | |
315 | + (curcf && !B_IS_IN_TREE(curcf)), | |
316 | + "PAP-8195: FL (%b) or CFL (%b) is invalid", curf, curcf); | |
317 | ||
318 | /* Get parent FR[n_h] of R[n_h]. */ | |
319 | ||
320 | /* Current node is the last child of F[n_h]. FR[n_h] != F[n_h]. */ | |
321 | - if (n_position == B_NR_ITEMS(PATH_H_PBUFFER(p_s_path, n_h + 1))) { | |
322 | + if (n_position == B_NR_ITEMS(PATH_H_PBUFFER(path, n_h + 1))) { | |
323 | /* Calculate current parent of R[n_h], which is the right neighbor of F[n_h]. | |
324 | Calculate current common parent of R[n_h] and current node. Note that CFR[n_h] | |
325 | not equal FR[n_path_offset] and CFR[n_h] not equal F[n_h]. */ | |
326 | if ((n_ret_value = | |
327 | - get_far_parent(tb, n_h + 1, &p_s_curf, &p_s_curcf, | |
328 | + get_far_parent(tb, n_h + 1, &curf, &curcf, | |
329 | RIGHT_PARENTS)) != CARRY_ON) | |
330 | return n_ret_value; | |
331 | } else { | |
332 | /* Current node is not the last child of its parent F[n_h]. */ | |
333 | - /*(p_s_curf = p_s_curcf = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1))->b_count += 2; */ | |
334 | - p_s_curf = p_s_curcf = | |
335 | - PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1); | |
336 | - get_bh(p_s_curf); | |
337 | - get_bh(p_s_curf); | |
338 | + curf = PATH_OFFSET_PBUFFER(path, n_path_offset - 1); | |
339 | + curcf = PATH_OFFSET_PBUFFER(path, n_path_offset - 1); | |
340 | + get_bh(curf); | |
341 | + get_bh(curf); | |
342 | tb->rkey[n_h] = n_position; | |
343 | } | |
344 | ||
345 | brelse(tb->FR[n_h]); | |
346 | /* New initialization of FR[n_path_offset]. */ | |
347 | - tb->FR[n_h] = p_s_curf; | |
348 | + tb->FR[n_h] = curf; | |
349 | ||
350 | brelse(tb->CFR[n_h]); | |
351 | /* New initialization of CFR[n_path_offset]. */ | |
352 | - tb->CFR[n_h] = p_s_curcf; | |
353 | + tb->CFR[n_h] = curcf; | |
354 | ||
355 | - RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) || | |
356 | - (p_s_curcf && !B_IS_IN_TREE(p_s_curcf)), | |
357 | - "PAP-8205: FR (%b) or CFR (%b) is invalid", p_s_curf, p_s_curcf); | |
358 | + RFALSE((curf && !B_IS_IN_TREE(curf)) || | |
359 | + (curcf && !B_IS_IN_TREE(curcf)), | |
360 | + "PAP-8205: FR (%b) or CFR (%b) is invalid", curf, curcf); | |
361 | ||
362 | return CARRY_ON; | |
363 | } | |
364 | @@ -1893,7 +1892,7 @@ static int check_balance(int mode, | |
365 | static int get_direct_parent(struct tree_balance *tb, int n_h) | |
366 | { | |
367 | struct buffer_head *bh; | |
368 | - struct treepath *p_s_path = tb->tb_path; | |
369 | + struct treepath *path = tb->tb_path; | |
370 | int n_position, | |
371 | n_path_offset = PATH_H_PATH_OFFSET(tb->tb_path, n_h); | |
372 | ||
373 | @@ -1903,27 +1902,27 @@ static int get_direct_parent(struct tree | |
374 | RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET - 1, | |
375 | "PAP-8260: invalid offset in the path"); | |
376 | ||
377 | - if (PATH_OFFSET_PBUFFER(p_s_path, FIRST_PATH_ELEMENT_OFFSET)-> | |
378 | + if (PATH_OFFSET_PBUFFER(path, FIRST_PATH_ELEMENT_OFFSET)-> | |
379 | b_blocknr == SB_ROOT_BLOCK(tb->tb_sb)) { | |
380 | /* Root is not changed. */ | |
381 | - PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1) = NULL; | |
382 | - PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1) = 0; | |
383 | + PATH_OFFSET_PBUFFER(path, n_path_offset - 1) = NULL; | |
384 | + PATH_OFFSET_POSITION(path, n_path_offset - 1) = 0; | |
385 | return CARRY_ON; | |
386 | } | |
387 | return REPEAT_SEARCH; /* Root is changed and we must recalculate the path. */ | |
388 | } | |
389 | ||
390 | if (!B_IS_IN_TREE | |
391 | - (bh = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1))) | |
392 | + (bh = PATH_OFFSET_PBUFFER(path, n_path_offset - 1))) | |
393 | return REPEAT_SEARCH; /* Parent in the path is not in the tree. */ | |
394 | ||
395 | if ((n_position = | |
396 | - PATH_OFFSET_POSITION(p_s_path, | |
397 | + PATH_OFFSET_POSITION(path, | |
398 | n_path_offset - 1)) > B_NR_ITEMS(bh)) | |
399 | return REPEAT_SEARCH; | |
400 | ||
401 | if (B_N_CHILD_NUM(bh, n_position) != | |
402 | - PATH_OFFSET_PBUFFER(p_s_path, n_path_offset)->b_blocknr) | |
403 | + PATH_OFFSET_PBUFFER(path, n_path_offset)->b_blocknr) | |
404 | /* Parent in the path is not parent of the current node in the tree. */ | |
405 | return REPEAT_SEARCH; | |
406 | ||
407 | @@ -2319,7 +2318,7 @@ static int wait_tb_buffers_until_unlocke | |
408 | */ | |
409 | ||
410 | int fix_nodes(int n_op_mode, struct tree_balance *tb, | |
411 | - struct item_head *p_s_ins_ih, const void *data) | |
412 | + struct item_head *ins_ih, const void *data) | |
413 | { | |
414 | int n_ret_value, n_h, n_item_num = PATH_LAST_POSITION(tb->tb_path); | |
415 | int n_pos_in_item; | |
416 | @@ -2405,7 +2404,7 @@ int fix_nodes(int n_op_mode, struct tree | |
417 | goto repeat; | |
418 | ||
419 | n_ret_value = check_balance(n_op_mode, tb, n_h, n_item_num, | |
420 | - n_pos_in_item, p_s_ins_ih, data); | |
421 | + n_pos_in_item, ins_ih, data); | |
422 | if (n_ret_value != CARRY_ON) { | |
423 | if (n_ret_value == NO_BALANCING_NEEDED) { | |
424 | /* No balancing for higher levels needed. */ | |
425 | --- a/fs/reiserfs/stree.c | |
426 | +++ b/fs/reiserfs/stree.c | |
427 | @@ -68,10 +68,10 @@ inline int B_IS_IN_TREE(const struct buf | |
428 | // | |
429 | // to gets item head in le form | |
430 | // | |
431 | -inline void copy_item_head(struct item_head *p_v_to, | |
432 | - const struct item_head *p_v_from) | |
433 | +inline void copy_item_head(struct item_head *to, | |
434 | + const struct item_head *from) | |
435 | { | |
436 | - memcpy(p_v_to, p_v_from, IH_SIZE); | |
437 | + memcpy(to, from, IH_SIZE); | |
438 | } | |
439 | ||
440 | /* k1 is pointer to on-disk structure which is stored in little-endian | |
441 | @@ -135,15 +135,15 @@ static inline int comp_keys(const struct | |
442 | inline int comp_short_le_keys(const struct reiserfs_key *key1, | |
443 | const struct reiserfs_key *key2) | |
444 | { | |
445 | - __u32 *p_s_1_u32, *p_s_2_u32; | |
446 | + __u32 *k1_u32, *k2_u32; | |
447 | int n_key_length = REISERFS_SHORT_KEY_LEN; | |
448 | ||
449 | - p_s_1_u32 = (__u32 *) key1; | |
450 | - p_s_2_u32 = (__u32 *) key2; | |
451 | - for (; n_key_length--; ++p_s_1_u32, ++p_s_2_u32) { | |
452 | - if (le32_to_cpu(*p_s_1_u32) < le32_to_cpu(*p_s_2_u32)) | |
453 | + k1_u32 = (__u32 *) key1; | |
454 | + k2_u32 = (__u32 *) key2; | |
455 | + for (; n_key_length--; ++k1_u32, ++k2_u32) { | |
456 | + if (le32_to_cpu(*k1_u32) < le32_to_cpu(*k2_u32)) | |
457 | return -1; | |
458 | - if (le32_to_cpu(*p_s_1_u32) > le32_to_cpu(*p_s_2_u32)) | |
459 | + if (le32_to_cpu(*k1_u32) > le32_to_cpu(*k2_u32)) | |
460 | return 1; | |
461 | } | |
462 | return 0; | |
463 | @@ -174,8 +174,8 @@ inline int comp_le_keys(const struct rei | |
464 | * Binary search toolkit function * | |
465 | * Search for an item in the array by the item key * | |
466 | * Returns: 1 if found, 0 if not found; * | |
467 | - * *p_n_pos = number of the searched element if found, else the * | |
468 | - * number of the first element that is larger than p_v_key. * | |
469 | + * *pos = number of the searched element if found, else the * | |
470 | + * number of the first element that is larger than key. * | |
471 | **************************************************************************/ | |
472 | /* For those not familiar with binary search: n_lbound is the leftmost item that it | |
473 | could be, n_rbound the rightmost item that it could be. We examine the item | |
474 | @@ -184,28 +184,28 @@ inline int comp_le_keys(const struct rei | |
475 | there are no possible items, and we have not found it. With each examination we | |
476 | cut the number of possible items it could be by one more than half rounded down, | |
477 | or we find it. */ | |
478 | -static inline int bin_search(const void *p_v_key, /* Key to search for. */ | |
479 | - const void *p_v_base, /* First item in the array. */ | |
480 | - int p_n_num, /* Number of items in the array. */ | |
481 | - int p_n_width, /* Item size in the array. | |
482 | - searched. Lest the reader be | |
483 | - confused, note that this is crafted | |
484 | - as a general function, and when it | |
485 | - is applied specifically to the array | |
486 | - of item headers in a node, p_n_width | |
487 | - is actually the item header size not | |
488 | - the item size. */ | |
489 | - int *p_n_pos /* Number of the searched for element. */ | |
490 | +static inline int bin_search(const void *key, /* Key to search for. */ | |
491 | + const void *base, /* First item in the array. */ | |
492 | + int num, /* Number of items in the array. */ | |
493 | + int width, /* Item size in the array. | |
494 | + searched. Lest the reader be | |
495 | + confused, note that this is crafted | |
496 | + as a general function, and when it | |
497 | + is applied specifically to the array | |
498 | + of item headers in a node, width | |
499 | + is actually the item header size not | |
500 | + the item size. */ | |
501 | + int *pos /* Number of the searched for element. */ | |
502 | ) | |
503 | { | |
504 | int n_rbound, n_lbound, n_j; | |
505 | ||
506 | - for (n_j = ((n_rbound = p_n_num - 1) + (n_lbound = 0)) / 2; | |
507 | + for (n_j = ((n_rbound = num - 1) + (n_lbound = 0)) / 2; | |
508 | n_lbound <= n_rbound; n_j = (n_rbound + n_lbound) / 2) | |
509 | switch (comp_keys | |
510 | - ((struct reiserfs_key *)((char *)p_v_base + | |
511 | - n_j * p_n_width), | |
512 | - (struct cpu_key *)p_v_key)) { | |
513 | + ((struct reiserfs_key *)((char *)base + | |
514 | + n_j * width), | |
515 | + (struct cpu_key *)key)) { | |
516 | case -1: | |
517 | n_lbound = n_j + 1; | |
518 | continue; | |
519 | @@ -213,13 +213,13 @@ static inline int bin_search(const void | |
520 | n_rbound = n_j - 1; | |
521 | continue; | |
522 | case 0: | |
523 | - *p_n_pos = n_j; | |
524 | + *pos = n_j; | |
525 | return ITEM_FOUND; /* Key found in the array. */ | |
526 | } | |
527 | ||
528 | /* bin_search did not find given key, it returns position of key, | |
529 | that is minimal and greater than the given one. */ | |
530 | - *p_n_pos = n_lbound; | |
531 | + *pos = n_lbound; | |
532 | return ITEM_NOT_FOUND; | |
533 | } | |
534 | ||
535 | @@ -243,12 +243,12 @@ static const struct reiserfs_key MAX_KEY | |
536 | the path, there is no delimiting key in the tree (buffer is first or last buffer in tree), and in this | |
537 | case we return a special key, either MIN_KEY or MAX_KEY. */ | |
538 | static inline const struct reiserfs_key *get_lkey(const struct treepath | |
539 | - *p_s_chk_path, | |
540 | + *chk_path, | |
541 | const struct super_block | |
542 | *sb) | |
543 | { | |
544 | - int n_position, n_path_offset = p_s_chk_path->path_length; | |
545 | - struct buffer_head *p_s_parent; | |
546 | + int n_position, n_path_offset = chk_path->path_length; | |
547 | + struct buffer_head *parent; | |
548 | ||
549 | RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET, | |
550 | "PAP-5010: invalid offset in the path"); | |
551 | @@ -257,42 +257,42 @@ static inline const struct reiserfs_key | |
552 | while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) { | |
553 | ||
554 | RFALSE(!buffer_uptodate | |
555 | - (PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)), | |
556 | + (PATH_OFFSET_PBUFFER(chk_path, n_path_offset)), | |
557 | "PAP-5020: parent is not uptodate"); | |
558 | ||
559 | /* Parent at the path is not in the tree now. */ | |
560 | if (!B_IS_IN_TREE | |
561 | - (p_s_parent = | |
562 | - PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset))) | |
563 | + (parent = | |
564 | + PATH_OFFSET_PBUFFER(chk_path, n_path_offset))) | |
565 | return &MAX_KEY; | |
566 | /* Check whether position in the parent is correct. */ | |
567 | if ((n_position = | |
568 | - PATH_OFFSET_POSITION(p_s_chk_path, | |
569 | + PATH_OFFSET_POSITION(chk_path, | |
570 | n_path_offset)) > | |
571 | - B_NR_ITEMS(p_s_parent)) | |
572 | + B_NR_ITEMS(parent)) | |
573 | return &MAX_KEY; | |
574 | /* Check whether parent at the path really points to the child. */ | |
575 | - if (B_N_CHILD_NUM(p_s_parent, n_position) != | |
576 | - PATH_OFFSET_PBUFFER(p_s_chk_path, | |
577 | + if (B_N_CHILD_NUM(parent, n_position) != | |
578 | + PATH_OFFSET_PBUFFER(chk_path, | |
579 | n_path_offset + 1)->b_blocknr) | |
580 | return &MAX_KEY; | |
581 | /* Return delimiting key if position in the parent is not equal to zero. */ | |
582 | if (n_position) | |
583 | - return B_N_PDELIM_KEY(p_s_parent, n_position - 1); | |
584 | + return B_N_PDELIM_KEY(parent, n_position - 1); | |
585 | } | |
586 | /* Return MIN_KEY if we are in the root of the buffer tree. */ | |
587 | - if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)-> | |
588 | + if (PATH_OFFSET_PBUFFER(chk_path, FIRST_PATH_ELEMENT_OFFSET)-> | |
589 | b_blocknr == SB_ROOT_BLOCK(sb)) | |
590 | return &MIN_KEY; | |
591 | return &MAX_KEY; | |
592 | } | |
593 | ||
594 | /* Get delimiting key of the buffer at the path and its right neighbor. */ | |
595 | -inline const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path, | |
596 | +inline const struct reiserfs_key *get_rkey(const struct treepath *chk_path, | |
597 | const struct super_block *sb) | |
598 | { | |
599 | - int n_position, n_path_offset = p_s_chk_path->path_length; | |
600 | - struct buffer_head *p_s_parent; | |
601 | + int n_position, n_path_offset = chk_path->path_length; | |
602 | + struct buffer_head *parent; | |
603 | ||
604 | RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET, | |
605 | "PAP-5030: invalid offset in the path"); | |
606 | @@ -300,31 +300,31 @@ inline const struct reiserfs_key *get_rk | |
607 | while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) { | |
608 | ||
609 | RFALSE(!buffer_uptodate | |
610 | - (PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)), | |
611 | + (PATH_OFFSET_PBUFFER(chk_path, n_path_offset)), | |
612 | "PAP-5040: parent is not uptodate"); | |
613 | ||
614 | /* Parent at the path is not in the tree now. */ | |
615 | if (!B_IS_IN_TREE | |
616 | - (p_s_parent = | |
617 | - PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset))) | |
618 | + (parent = | |
619 | + PATH_OFFSET_PBUFFER(chk_path, n_path_offset))) | |
620 | return &MIN_KEY; | |
621 | /* Check whether position in the parent is correct. */ | |
622 | if ((n_position = | |
623 | - PATH_OFFSET_POSITION(p_s_chk_path, | |
624 | + PATH_OFFSET_POSITION(chk_path, | |
625 | n_path_offset)) > | |
626 | - B_NR_ITEMS(p_s_parent)) | |
627 | + B_NR_ITEMS(parent)) | |
628 | return &MIN_KEY; | |
629 | /* Check whether parent at the path really points to the child. */ | |
630 | - if (B_N_CHILD_NUM(p_s_parent, n_position) != | |
631 | - PATH_OFFSET_PBUFFER(p_s_chk_path, | |
632 | + if (B_N_CHILD_NUM(parent, n_position) != | |
633 | + PATH_OFFSET_PBUFFER(chk_path, | |
634 | n_path_offset + 1)->b_blocknr) | |
635 | return &MIN_KEY; | |
636 | /* Return delimiting key if position in the parent is not the last one. */ | |
637 | - if (n_position != B_NR_ITEMS(p_s_parent)) | |
638 | - return B_N_PDELIM_KEY(p_s_parent, n_position); | |
639 | + if (n_position != B_NR_ITEMS(parent)) | |
640 | + return B_N_PDELIM_KEY(parent, n_position); | |
641 | } | |
642 | /* Return MAX_KEY if we are in the root of the buffer tree. */ | |
643 | - if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)-> | |
644 | + if (PATH_OFFSET_PBUFFER(chk_path, FIRST_PATH_ELEMENT_OFFSET)-> | |
645 | b_blocknr == SB_ROOT_BLOCK(sb)) | |
646 | return &MAX_KEY; | |
647 | return &MIN_KEY; | |
648 | @@ -335,25 +335,25 @@ inline const struct reiserfs_key *get_rk | |
649 | the path. These delimiting keys are stored at least one level above that buffer in the tree. If the | |
650 | buffer is the first or last node in the tree order then one of the delimiting keys may be absent, and in | |
651 | this case get_lkey and get_rkey return a special key which is MIN_KEY or MAX_KEY. */ | |
652 | -static inline int key_in_buffer(struct treepath *p_s_chk_path, /* Path which should be checked. */ | |
653 | - const struct cpu_key *p_s_key, /* Key which should be checked. */ | |
654 | - struct super_block *sb /* Super block pointer. */ | |
655 | +static inline int key_in_buffer(struct treepath *chk_path, /* Path which should be checked. */ | |
656 | + const struct cpu_key *key, /* Key which should be checked. */ | |
657 | + struct super_block *sb | |
658 | ) | |
659 | { | |
660 | ||
661 | - RFALSE(!p_s_key || p_s_chk_path->path_length < FIRST_PATH_ELEMENT_OFFSET | |
662 | - || p_s_chk_path->path_length > MAX_HEIGHT, | |
663 | + RFALSE(!key || chk_path->path_length < FIRST_PATH_ELEMENT_OFFSET | |
664 | + || chk_path->path_length > MAX_HEIGHT, | |
665 | "PAP-5050: pointer to the key(%p) is NULL or invalid path length(%d)", | |
666 | - p_s_key, p_s_chk_path->path_length); | |
667 | - RFALSE(!PATH_PLAST_BUFFER(p_s_chk_path)->b_bdev, | |
668 | + key, chk_path->path_length); | |
669 | + RFALSE(!PATH_PLAST_BUFFER(chk_path)->b_bdev, | |
670 | "PAP-5060: device must not be NODEV"); | |
671 | ||
672 | - if (comp_keys(get_lkey(p_s_chk_path, sb), p_s_key) == 1) | |
673 | + if (comp_keys(get_lkey(chk_path, sb), key) == 1) | |
674 | /* left delimiting key is bigger, that the key we look for */ | |
675 | return 0; | |
676 | - // if ( comp_keys(p_s_key, get_rkey(p_s_chk_path, sb)) != -1 ) | |
677 | - if (comp_keys(get_rkey(p_s_chk_path, sb), p_s_key) != 1) | |
678 | - /* p_s_key must be less than right delimitiing key */ | |
679 | + /* if ( comp_keys(key, get_rkey(chk_path, sb)) != -1 ) */ | |
680 | + if (comp_keys(get_rkey(chk_path, sb), key) != 1) | |
681 | + /* key must be less than right delimitiing key */ | |
682 | return 0; | |
683 | return 1; | |
684 | } | |
685 | @@ -369,34 +369,34 @@ int reiserfs_check_path(struct treepath | |
686 | * dirty bits clean when preparing the buffer for the log. | |
687 | * This version should only be called from fix_nodes() */ | |
688 | void pathrelse_and_restore(struct super_block *sb, | |
689 | - struct treepath *p_s_search_path) | |
690 | + struct treepath *search_path) | |
691 | { | |
692 | - int n_path_offset = p_s_search_path->path_length; | |
693 | + int n_path_offset = search_path->path_length; | |
694 | ||
695 | RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET, | |
696 | "clm-4000: invalid path offset"); | |
697 | ||
698 | while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) { | |
699 | struct buffer_head *bh; | |
700 | - bh = PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--); | |
701 | + bh = PATH_OFFSET_PBUFFER(search_path, n_path_offset--); | |
702 | reiserfs_restore_prepared_buffer(sb, bh); | |
703 | brelse(bh); | |
704 | } | |
705 | - p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET; | |
706 | + search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET; | |
707 | } | |
708 | ||
709 | /* Drop the reference to each buffer in a path */ | |
710 | -void pathrelse(struct treepath *p_s_search_path) | |
711 | +void pathrelse(struct treepath *search_path) | |
712 | { | |
713 | - int n_path_offset = p_s_search_path->path_length; | |
714 | + int n_path_offset = search_path->path_length; | |
715 | ||
716 | RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET, | |
717 | "PAP-5090: invalid path offset"); | |
718 | ||
719 | while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) | |
720 | - brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--)); | |
721 | + brelse(PATH_OFFSET_PBUFFER(search_path, n_path_offset--)); | |
722 | ||
723 | - p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET; | |
724 | + search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET; | |
725 | } | |
726 | ||
727 | static int is_leaf(char *buf, int blocksize, struct buffer_head *bh) | |
728 | @@ -547,9 +547,9 @@ static void search_by_key_reada(struct s | |
729 | * Algorithm SearchByKey * | |
730 | * look for item in the Disk S+Tree by its key * | |
731 | * Input: sb - super block * | |
732 | - * p_s_key - pointer to the key to search * | |
733 | + * key - pointer to the key to search * | |
734 | * Output: ITEM_FOUND, ITEM_NOT_FOUND or IO_ERROR * | |
735 | - * p_s_search_path - path from the root to the needed leaf * | |
736 | + * search_path - path from the root to the needed leaf * | |
737 | **************************************************************************/ | |
738 | ||
739 | /* This function fills up the path from the root to the leaf as it | |
740 | @@ -566,8 +566,8 @@ static void search_by_key_reada(struct s | |
741 | correctness of the top of the path but need not be checked for the | |
742 | correctness of the bottom of the path */ | |
743 | /* The function is NOT SCHEDULE-SAFE! */ | |
744 | -int search_by_key(struct super_block *sb, const struct cpu_key *p_s_key, /* Key to search. */ | |
745 | - struct treepath *p_s_search_path,/* This structure was | |
746 | +int search_by_key(struct super_block *sb, const struct cpu_key *key, /* Key to search. */ | |
747 | + struct treepath *search_path,/* This structure was | |
748 | allocated and initialized | |
749 | by the calling | |
750 | function. It is filled up | |
751 | @@ -580,7 +580,7 @@ int search_by_key(struct super_block *sb | |
752 | b_blocknr_t n_block_number; | |
753 | int expected_level; | |
754 | struct buffer_head *bh; | |
755 | - struct path_element *p_s_last_element; | |
756 | + struct path_element *last_element; | |
757 | int n_node_level, n_retval; | |
758 | int right_neighbor_of_leaf_node; | |
759 | int fs_gen; | |
760 | @@ -598,7 +598,7 @@ int search_by_key(struct super_block *sb | |
761 | we must be careful to release all nodes in a path before we either | |
762 | discard the path struct or re-use the path struct, as we do here. */ | |
763 | ||
764 | - pathrelse(p_s_search_path); | |
765 | + pathrelse(search_path); | |
766 | ||
767 | right_neighbor_of_leaf_node = 0; | |
768 | ||
769 | @@ -615,18 +615,18 @@ int search_by_key(struct super_block *sb | |
770 | "%s: there were %d iterations of " | |
771 | "while loop looking for key %K", | |
772 | current->comm, n_repeat_counter, | |
773 | - p_s_key); | |
774 | + key); | |
775 | #endif | |
776 | ||
777 | /* prep path to have another element added to it. */ | |
778 | - p_s_last_element = | |
779 | - PATH_OFFSET_PELEMENT(p_s_search_path, | |
780 | - ++p_s_search_path->path_length); | |
781 | + last_element = | |
782 | + PATH_OFFSET_PELEMENT(search_path, | |
783 | + ++search_path->path_length); | |
784 | fs_gen = get_generation(sb); | |
785 | ||
786 | /* Read the next tree node, and set the last element in the path to | |
787 | have a pointer to it. */ | |
788 | - if ((bh = p_s_last_element->pe_buffer = | |
789 | + if ((bh = last_element->pe_buffer = | |
790 | sb_getblk(sb, n_block_number))) { | |
791 | if (!buffer_uptodate(bh) && reada_count > 1) | |
792 | search_by_key_reada(sb, reada_bh, | |
793 | @@ -637,8 +637,8 @@ int search_by_key(struct super_block *sb | |
794 | goto io_error; | |
795 | } else { | |
796 | io_error: | |
797 | - p_s_search_path->path_length--; | |
798 | - pathrelse(p_s_search_path); | |
799 | + search_path->path_length--; | |
800 | + pathrelse(search_path); | |
801 | return IO_ERROR; | |
802 | } | |
803 | reada_count = 0; | |
804 | @@ -652,12 +652,12 @@ int search_by_key(struct super_block *sb | |
805 | if (fs_changed(fs_gen, sb) && | |
806 | (!B_IS_IN_TREE(bh) || | |
807 | B_LEVEL(bh) != expected_level || | |
808 | - !key_in_buffer(p_s_search_path, p_s_key, sb))) { | |
809 | + !key_in_buffer(search_path, key, sb))) { | |
810 | PROC_INFO_INC(sb, search_by_key_fs_changed); | |
811 | PROC_INFO_INC(sb, search_by_key_restarted); | |
812 | PROC_INFO_INC(sb, | |
813 | sbk_restarted[expected_level - 1]); | |
814 | - pathrelse(p_s_search_path); | |
815 | + pathrelse(search_path); | |
816 | ||
817 | /* Get the root block number so that we can repeat the search | |
818 | starting from the root. */ | |
819 | @@ -669,11 +669,11 @@ int search_by_key(struct super_block *sb | |
820 | continue; | |
821 | } | |
822 | ||
823 | - /* only check that the key is in the buffer if p_s_key is not | |
824 | + /* only check that the key is in the buffer if key is not | |
825 | equal to the MAX_KEY. Latter case is only possible in | |
826 | "finish_unfinished()" processing during mount. */ | |
827 | - RFALSE(comp_keys(&MAX_KEY, p_s_key) && | |
828 | - !key_in_buffer(p_s_search_path, p_s_key, sb), | |
829 | + RFALSE(comp_keys(&MAX_KEY, key) && | |
830 | + !key_in_buffer(search_path, key, sb), | |
831 | "PAP-5130: key is not in the buffer"); | |
832 | #ifdef CONFIG_REISERFS_CHECK | |
833 | if (cur_tb) { | |
834 | @@ -689,7 +689,7 @@ int search_by_key(struct super_block *sb | |
835 | reiserfs_error(sb, "vs-5150", | |
836 | "invalid format found in block %ld. " | |
837 | "Fsck?", bh->b_blocknr); | |
838 | - pathrelse(p_s_search_path); | |
839 | + pathrelse(search_path); | |
840 | return IO_ERROR; | |
841 | } | |
842 | ||
843 | @@ -702,12 +702,12 @@ int search_by_key(struct super_block *sb | |
844 | "vs-5152: tree level (%d) is less than stop level (%d)", | |
845 | n_node_level, n_stop_level); | |
846 | ||
847 | - n_retval = bin_search(p_s_key, B_N_PITEM_HEAD(bh, 0), | |
848 | + n_retval = bin_search(key, B_N_PITEM_HEAD(bh, 0), | |
849 | B_NR_ITEMS(bh), | |
850 | (n_node_level == | |
851 | DISK_LEAF_NODE_LEVEL) ? IH_SIZE : | |
852 | KEY_SIZE, | |
853 | - &(p_s_last_element->pe_position)); | |
854 | + &(last_element->pe_position)); | |
855 | if (n_node_level == n_stop_level) { | |
856 | return n_retval; | |
857 | } | |
858 | @@ -715,7 +715,7 @@ int search_by_key(struct super_block *sb | |
859 | /* we are not in the stop level */ | |
860 | if (n_retval == ITEM_FOUND) | |
861 | /* item has been found, so we choose the pointer which is to the right of the found one */ | |
862 | - p_s_last_element->pe_position++; | |
863 | + last_element->pe_position++; | |
864 | ||
865 | /* if item was not found we choose the position which is to | |
866 | the left of the found item. This requires no code, | |
867 | @@ -725,23 +725,23 @@ int search_by_key(struct super_block *sb | |
868 | an internal node. Now we calculate child block number by | |
869 | position in the node. */ | |
870 | n_block_number = | |
871 | - B_N_CHILD_NUM(bh, p_s_last_element->pe_position); | |
872 | + B_N_CHILD_NUM(bh, last_element->pe_position); | |
873 | ||
874 | /* if we are going to read leaf nodes, try for read ahead as well */ | |
875 | - if ((p_s_search_path->reada & PATH_READA) && | |
876 | + if ((search_path->reada & PATH_READA) && | |
877 | n_node_level == DISK_LEAF_NODE_LEVEL + 1) { | |
878 | - int pos = p_s_last_element->pe_position; | |
879 | + int pos = last_element->pe_position; | |
880 | int limit = B_NR_ITEMS(bh); | |
881 | struct reiserfs_key *le_key; | |
882 | ||
883 | - if (p_s_search_path->reada & PATH_READA_BACK) | |
884 | + if (search_path->reada & PATH_READA_BACK) | |
885 | limit = 0; | |
886 | while (reada_count < SEARCH_BY_KEY_READA) { | |
887 | if (pos == limit) | |
888 | break; | |
889 | reada_blocks[reada_count++] = | |
890 | B_N_CHILD_NUM(bh, pos); | |
891 | - if (p_s_search_path->reada & PATH_READA_BACK) | |
892 | + if (search_path->reada & PATH_READA_BACK) | |
893 | pos--; | |
894 | else | |
895 | pos++; | |
896 | @@ -751,7 +751,7 @@ int search_by_key(struct super_block *sb | |
897 | */ | |
898 | le_key = B_N_PDELIM_KEY(bh, pos); | |
899 | if (le32_to_cpu(le_key->k_objectid) != | |
900 | - p_s_key->on_disk_key.k_objectid) { | |
901 | + key->on_disk_key.k_objectid) { | |
902 | break; | |
903 | } | |
904 | } | |
905 | @@ -760,11 +760,11 @@ int search_by_key(struct super_block *sb | |
906 | } | |
907 | ||
908 | /* Form the path to an item and position in this item which contains | |
909 | - file byte defined by p_s_key. If there is no such item | |
910 | + file byte defined by key. If there is no such item | |
911 | corresponding to the key, we point the path to the item with | |
912 | - maximal key less than p_s_key, and *p_n_pos_in_item is set to one | |
913 | + maximal key less than key, and *pos_in_item is set to one | |
914 | past the last entry/byte in the item. If searching for entry in a | |
915 | - directory item, and it is not found, *p_n_pos_in_item is set to one | |
916 | + directory item, and it is not found, *pos_in_item is set to one | |
917 | entry more than the entry with maximal key which is less than the | |
918 | sought key. | |
919 | ||
920 | @@ -777,7 +777,7 @@ int search_by_key(struct super_block *sb | |
921 | /* The function is NOT SCHEDULE-SAFE! */ | |
922 | int search_for_position_by_key(struct super_block *sb, /* Pointer to the super block. */ | |
923 | const struct cpu_key *p_cpu_key, /* Key to search (cpu variable) */ | |
924 | - struct treepath *p_s_search_path /* Filled up by this function. */ | |
925 | + struct treepath *search_path /* Filled up by this function. */ | |
926 | ) | |
927 | { | |
928 | struct item_head *p_le_ih; /* pointer to on-disk structure */ | |
929 | @@ -788,34 +788,34 @@ int search_for_position_by_key(struct su | |
930 | ||
931 | /* If searching for directory entry. */ | |
932 | if (is_direntry_cpu_key(p_cpu_key)) | |
933 | - return search_by_entry_key(sb, p_cpu_key, p_s_search_path, | |
934 | + return search_by_entry_key(sb, p_cpu_key, search_path, | |
935 | &de); | |
936 | ||
937 | /* If not searching for directory entry. */ | |
938 | ||
939 | /* If item is found. */ | |
940 | - retval = search_item(sb, p_cpu_key, p_s_search_path); | |
941 | + retval = search_item(sb, p_cpu_key, search_path); | |
942 | if (retval == IO_ERROR) | |
943 | return retval; | |
944 | if (retval == ITEM_FOUND) { | |
945 | ||
946 | RFALSE(!ih_item_len | |
947 | (B_N_PITEM_HEAD | |
948 | - (PATH_PLAST_BUFFER(p_s_search_path), | |
949 | - PATH_LAST_POSITION(p_s_search_path))), | |
950 | + (PATH_PLAST_BUFFER(search_path), | |
951 | + PATH_LAST_POSITION(search_path))), | |
952 | "PAP-5165: item length equals zero"); | |
953 | ||
954 | - pos_in_item(p_s_search_path) = 0; | |
955 | + pos_in_item(search_path) = 0; | |
956 | return POSITION_FOUND; | |
957 | } | |
958 | ||
959 | - RFALSE(!PATH_LAST_POSITION(p_s_search_path), | |
960 | + RFALSE(!PATH_LAST_POSITION(search_path), | |
961 | "PAP-5170: position equals zero"); | |
962 | ||
963 | /* Item is not found. Set path to the previous item. */ | |
964 | p_le_ih = | |
965 | - B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_search_path), | |
966 | - --PATH_LAST_POSITION(p_s_search_path)); | |
967 | + B_N_PITEM_HEAD(PATH_PLAST_BUFFER(search_path), | |
968 | + --PATH_LAST_POSITION(search_path)); | |
969 | n_blk_size = sb->s_blocksize; | |
970 | ||
971 | if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) { | |
972 | @@ -829,9 +829,9 @@ int search_for_position_by_key(struct su | |
973 | /* Needed byte is contained in the item pointed to by the path. */ | |
974 | if (item_offset <= offset && | |
975 | item_offset + op_bytes_number(p_le_ih, n_blk_size) > offset) { | |
976 | - pos_in_item(p_s_search_path) = offset - item_offset; | |
977 | + pos_in_item(search_path) = offset - item_offset; | |
978 | if (is_indirect_le_ih(p_le_ih)) { | |
979 | - pos_in_item(p_s_search_path) /= n_blk_size; | |
980 | + pos_in_item(search_path) /= n_blk_size; | |
981 | } | |
982 | return POSITION_FOUND; | |
983 | } | |
984 | @@ -839,18 +839,18 @@ int search_for_position_by_key(struct su | |
985 | /* Needed byte is not contained in the item pointed to by the | |
986 | path. Set pos_in_item out of the item. */ | |
987 | if (is_indirect_le_ih(p_le_ih)) | |
988 | - pos_in_item(p_s_search_path) = | |
989 | + pos_in_item(search_path) = | |
990 | ih_item_len(p_le_ih) / UNFM_P_SIZE; | |
991 | else | |
992 | - pos_in_item(p_s_search_path) = ih_item_len(p_le_ih); | |
993 | + pos_in_item(search_path) = ih_item_len(p_le_ih); | |
994 | ||
995 | return POSITION_NOT_FOUND; | |
996 | } | |
997 | ||
998 | /* Compare given item and item pointed to by the path. */ | |
999 | -int comp_items(const struct item_head *stored_ih, const struct treepath *p_s_path) | |
1000 | +int comp_items(const struct item_head *stored_ih, const struct treepath *path) | |
1001 | { | |
1002 | - struct buffer_head *bh = PATH_PLAST_BUFFER(p_s_path); | |
1003 | + struct buffer_head *bh = PATH_PLAST_BUFFER(path); | |
1004 | struct item_head *ih; | |
1005 | ||
1006 | /* Last buffer at the path is not in the tree. */ | |
1007 | @@ -858,11 +858,11 @@ int comp_items(const struct item_head *s | |
1008 | return 1; | |
1009 | ||
1010 | /* Last path position is invalid. */ | |
1011 | - if (PATH_LAST_POSITION(p_s_path) >= B_NR_ITEMS(bh)) | |
1012 | + if (PATH_LAST_POSITION(path) >= B_NR_ITEMS(bh)) | |
1013 | return 1; | |
1014 | ||
1015 | /* we need only to know, whether it is the same item */ | |
1016 | - ih = get_ih(p_s_path); | |
1017 | + ih = get_ih(path); | |
1018 | return memcmp(stored_ih, ih, IH_SIZE); | |
1019 | } | |
1020 | ||
1021 | @@ -951,14 +951,14 @@ static inline int prepare_for_direntry_i | |
1022 | In case of file truncate calculate whether this item must be deleted/truncated or last | |
1023 | unformatted node of this item will be converted to a direct item. | |
1024 | This function returns a determination of what balance mode the calling function should employ. */ | |
1025 | -static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, struct inode *inode, struct treepath *p_s_path, const struct cpu_key *p_s_item_key, int *p_n_removed, /* Number of unformatted nodes which were removed | |
1026 | +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 | |
1027 | from end of the file. */ | |
1028 | - int *p_n_cut_size, unsigned long long n_new_file_length /* MAX_KEY_OFFSET in case of delete. */ | |
1029 | + int *cut_size, unsigned long long n_new_file_length /* MAX_KEY_OFFSET in case of delete. */ | |
1030 | ) | |
1031 | { | |
1032 | struct super_block *sb = inode->i_sb; | |
1033 | - struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_path); | |
1034 | - struct buffer_head *bh = PATH_PLAST_BUFFER(p_s_path); | |
1035 | + struct item_head *p_le_ih = PATH_PITEM_HEAD(path); | |
1036 | + struct buffer_head *bh = PATH_PLAST_BUFFER(path); | |
1037 | ||
1038 | BUG_ON(!th->t_trans_id); | |
1039 | ||
1040 | @@ -968,20 +968,20 @@ static char prepare_for_delete_or_cut(st | |
1041 | RFALSE(n_new_file_length != max_reiserfs_offset(inode), | |
1042 | "PAP-5210: mode must be M_DELETE"); | |
1043 | ||
1044 | - *p_n_cut_size = -(IH_SIZE + ih_item_len(p_le_ih)); | |
1045 | + *cut_size = -(IH_SIZE + ih_item_len(p_le_ih)); | |
1046 | return M_DELETE; | |
1047 | } | |
1048 | ||
1049 | /* Directory item. */ | |
1050 | if (is_direntry_le_ih(p_le_ih)) | |
1051 | - return prepare_for_direntry_item(p_s_path, p_le_ih, inode, | |
1052 | + return prepare_for_direntry_item(path, p_le_ih, inode, | |
1053 | n_new_file_length, | |
1054 | - p_n_cut_size); | |
1055 | + cut_size); | |
1056 | ||
1057 | /* Direct item. */ | |
1058 | if (is_direct_le_ih(p_le_ih)) | |
1059 | - return prepare_for_direct_item(p_s_path, p_le_ih, inode, | |
1060 | - n_new_file_length, p_n_cut_size); | |
1061 | + return prepare_for_direct_item(path, p_le_ih, inode, | |
1062 | + n_new_file_length, cut_size); | |
1063 | ||
1064 | /* Case of an indirect item. */ | |
1065 | { | |
1066 | @@ -1001,9 +1001,9 @@ static char prepare_for_delete_or_cut(st | |
1067 | ||
1068 | do { | |
1069 | need_re_search = 0; | |
1070 | - *p_n_cut_size = 0; | |
1071 | - bh = PATH_PLAST_BUFFER(p_s_path); | |
1072 | - copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path)); | |
1073 | + *cut_size = 0; | |
1074 | + bh = PATH_PLAST_BUFFER(path); | |
1075 | + copy_item_head(&s_ih, PATH_PITEM_HEAD(path)); | |
1076 | pos = I_UNFM_NUM(&s_ih); | |
1077 | ||
1078 | while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > n_new_file_length) { | |
1079 | @@ -1013,10 +1013,9 @@ static char prepare_for_delete_or_cut(st | |
1080 | /* Each unformatted block deletion may involve one additional | |
1081 | * bitmap block into the transaction, thereby the initial | |
1082 | * journal space reservation might not be enough. */ | |
1083 | - if (!delete && (*p_n_cut_size) != 0 && | |
1084 | - reiserfs_transaction_free_space(th) < JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) { | |
1085 | + if (!delete && (*cut_size) != 0 && | |
1086 | + reiserfs_transaction_free_space(th) < JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) | |
1087 | break; | |
1088 | - } | |
1089 | ||
1090 | unfm = (__le32 *)B_I_PITEM(bh, &s_ih) + pos - 1; | |
1091 | block = get_block_num(unfm, 0); | |
1092 | @@ -1030,17 +1029,17 @@ static char prepare_for_delete_or_cut(st | |
1093 | ||
1094 | cond_resched(); | |
1095 | ||
1096 | - if (item_moved (&s_ih, p_s_path)) { | |
1097 | + if (item_moved (&s_ih, path)) { | |
1098 | need_re_search = 1; | |
1099 | break; | |
1100 | } | |
1101 | ||
1102 | pos --; | |
1103 | - (*p_n_removed) ++; | |
1104 | - (*p_n_cut_size) -= UNFM_P_SIZE; | |
1105 | + (*removed)++; | |
1106 | + (*cut_size) -= UNFM_P_SIZE; | |
1107 | ||
1108 | if (pos == 0) { | |
1109 | - (*p_n_cut_size) -= IH_SIZE; | |
1110 | + (*cut_size) -= IH_SIZE; | |
1111 | result = M_DELETE; | |
1112 | break; | |
1113 | } | |
1114 | @@ -1050,10 +1049,10 @@ static char prepare_for_delete_or_cut(st | |
1115 | ** buffer */ | |
1116 | reiserfs_restore_prepared_buffer(sb, bh); | |
1117 | } while (need_re_search && | |
1118 | - search_for_position_by_key(sb, p_s_item_key, p_s_path) == POSITION_FOUND); | |
1119 | - pos_in_item(p_s_path) = pos * UNFM_P_SIZE; | |
1120 | + search_for_position_by_key(sb, item_key, path) == POSITION_FOUND); | |
1121 | + pos_in_item(path) = pos * UNFM_P_SIZE; | |
1122 | ||
1123 | - if (*p_n_cut_size == 0) { | |
1124 | + if (*cut_size == 0) { | |
1125 | /* Nothing were cut. maybe convert last unformatted node to the | |
1126 | * direct item? */ | |
1127 | result = M_CONVERT; | |
1128 | @@ -1091,7 +1090,7 @@ static int calc_deleted_bytes_number(str | |
1129 | static void init_tb_struct(struct reiserfs_transaction_handle *th, | |
1130 | struct tree_balance *tb, | |
1131 | struct super_block *sb, | |
1132 | - struct treepath *p_s_path, int n_size) | |
1133 | + struct treepath *path, int n_size) | |
1134 | { | |
1135 | ||
1136 | BUG_ON(!th->t_trans_id); | |
1137 | @@ -1099,9 +1098,9 @@ static void init_tb_struct(struct reiser | |
1138 | memset(tb, '\0', sizeof(struct tree_balance)); | |
1139 | tb->transaction_handle = th; | |
1140 | tb->tb_sb = sb; | |
1141 | - tb->tb_path = p_s_path; | |
1142 | - PATH_OFFSET_PBUFFER(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL; | |
1143 | - PATH_OFFSET_POSITION(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0; | |
1144 | + tb->tb_path = path; | |
1145 | + PATH_OFFSET_PBUFFER(path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL; | |
1146 | + PATH_OFFSET_POSITION(path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0; | |
1147 | tb->insert_size[0] = n_size; | |
1148 | } | |
1149 | ||
1150 | @@ -1141,13 +1140,17 @@ char head2type(struct item_head *ih) | |
1151 | } | |
1152 | #endif | |
1153 | ||
1154 | -/* Delete object item. */ | |
1155 | -int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath *p_s_path, /* Path to the deleted item. */ | |
1156 | - const struct cpu_key *p_s_item_key, /* Key to search for the deleted item. */ | |
1157 | - struct inode *inode, /* inode is here just to update | |
1158 | - * i_blocks and quotas */ | |
1159 | - struct buffer_head *p_s_un_bh) | |
1160 | -{ /* NULL or unformatted node pointer. */ | |
1161 | +/* Delete object item. | |
1162 | + * th - active transaction handle | |
1163 | + * path - path to the deleted item | |
1164 | + * item_key - key to search for the deleted item | |
1165 | + * indode - used for updating i_blocks and quotas | |
1166 | + * un_bh - NULL or unformatted node pointer | |
1167 | + */ | |
1168 | +int reiserfs_delete_item(struct reiserfs_transaction_handle *th, | |
1169 | + struct treepath *path, const struct cpu_key *item_key, | |
1170 | + struct inode *inode, struct buffer_head *un_bh) | |
1171 | +{ | |
1172 | struct super_block *sb = inode->i_sb; | |
1173 | struct tree_balance s_del_balance; | |
1174 | struct item_head s_ih; | |
1175 | @@ -1162,7 +1165,7 @@ int reiserfs_delete_item(struct reiserfs | |
1176 | ||
1177 | BUG_ON(!th->t_trans_id); | |
1178 | ||
1179 | - init_tb_struct(th, &s_del_balance, sb, p_s_path, | |
1180 | + init_tb_struct(th, &s_del_balance, sb, path, | |
1181 | 0 /*size is unknown */ ); | |
1182 | ||
1183 | while (1) { | |
1184 | @@ -1172,14 +1175,14 @@ int reiserfs_delete_item(struct reiserfs | |
1185 | n_iter++; | |
1186 | c_mode = | |
1187 | #endif | |
1188 | - prepare_for_delete_or_cut(th, inode, p_s_path, | |
1189 | - p_s_item_key, &n_removed, | |
1190 | + prepare_for_delete_or_cut(th, inode, path, | |
1191 | + item_key, &n_removed, | |
1192 | &n_del_size, | |
1193 | max_reiserfs_offset(inode)); | |
1194 | ||
1195 | RFALSE(c_mode != M_DELETE, "PAP-5320: mode must be M_DELETE"); | |
1196 | ||
1197 | - copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path)); | |
1198 | + copy_item_head(&s_ih, PATH_PITEM_HEAD(path)); | |
1199 | s_del_balance.insert_size[0] = n_del_size; | |
1200 | ||
1201 | n_ret_value = fix_nodes(M_DELETE, &s_del_balance, NULL, NULL); | |
1202 | @@ -1190,13 +1193,13 @@ int reiserfs_delete_item(struct reiserfs | |
1203 | ||
1204 | // file system changed, repeat search | |
1205 | n_ret_value = | |
1206 | - search_for_position_by_key(sb, p_s_item_key, p_s_path); | |
1207 | + search_for_position_by_key(sb, item_key, path); | |
1208 | if (n_ret_value == IO_ERROR) | |
1209 | break; | |
1210 | if (n_ret_value == FILE_NOT_FOUND) { | |
1211 | reiserfs_warning(sb, "vs-5340", | |
1212 | "no items of the file %K found", | |
1213 | - p_s_item_key); | |
1214 | + item_key); | |
1215 | break; | |
1216 | } | |
1217 | } /* while (1) */ | |
1218 | @@ -1207,7 +1210,7 @@ int reiserfs_delete_item(struct reiserfs | |
1219 | } | |
1220 | // reiserfs_delete_item returns item length when success | |
1221 | n_ret_value = calc_deleted_bytes_number(&s_del_balance, M_DELETE); | |
1222 | - q_ih = get_ih(p_s_path); | |
1223 | + q_ih = get_ih(path); | |
1224 | quota_cut_bytes = ih_item_len(q_ih); | |
1225 | ||
1226 | /* hack so the quota code doesn't have to guess if the file | |
1227 | @@ -1224,7 +1227,7 @@ int reiserfs_delete_item(struct reiserfs | |
1228 | } | |
1229 | } | |
1230 | ||
1231 | - if (p_s_un_bh) { | |
1232 | + if (un_bh) { | |
1233 | int off; | |
1234 | char *data; | |
1235 | ||
1236 | @@ -1242,16 +1245,16 @@ int reiserfs_delete_item(struct reiserfs | |
1237 | ** The unformatted node must be dirtied later on. We can't be | |
1238 | ** sure here if the entire tail has been deleted yet. | |
1239 | ** | |
1240 | - ** p_s_un_bh is from the page cache (all unformatted nodes are | |
1241 | + ** un_bh is from the page cache (all unformatted nodes are | |
1242 | ** from the page cache) and might be a highmem page. So, we | |
1243 | - ** can't use p_s_un_bh->b_data. | |
1244 | + ** can't use un_bh->b_data. | |
1245 | ** -clm | |
1246 | */ | |
1247 | ||
1248 | - data = kmap_atomic(p_s_un_bh->b_page, KM_USER0); | |
1249 | + data = kmap_atomic(un_bh->b_page, KM_USER0); | |
1250 | off = ((le_ih_k_offset(&s_ih) - 1) & (PAGE_CACHE_SIZE - 1)); | |
1251 | memcpy(data + off, | |
1252 | - B_I_PITEM(PATH_PLAST_BUFFER(p_s_path), &s_ih), | |
1253 | + B_I_PITEM(PATH_PLAST_BUFFER(path), &s_ih), | |
1254 | n_ret_value); | |
1255 | kunmap_atomic(data, KM_USER0); | |
1256 | } | |
1257 | @@ -1427,9 +1430,9 @@ static void unmap_buffers(struct page *p | |
1258 | static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th, | |
1259 | struct inode *inode, | |
1260 | struct page *page, | |
1261 | - struct treepath *p_s_path, | |
1262 | - const struct cpu_key *p_s_item_key, | |
1263 | - loff_t n_new_file_size, char *p_c_mode) | |
1264 | + struct treepath *path, | |
1265 | + const struct cpu_key *item_key, | |
1266 | + loff_t n_new_file_size, char *mode) | |
1267 | { | |
1268 | struct super_block *sb = inode->i_sb; | |
1269 | int n_block_size = sb->s_blocksize; | |
1270 | @@ -1445,17 +1448,17 @@ static int maybe_indirect_to_direct(stru | |
1271 | !tail_has_to_be_packed(inode) || | |
1272 | !page || (REISERFS_I(inode)->i_flags & i_nopack_mask)) { | |
1273 | /* leave tail in an unformatted node */ | |
1274 | - *p_c_mode = M_SKIP_BALANCING; | |
1275 | + *mode = M_SKIP_BALANCING; | |
1276 | cut_bytes = | |
1277 | n_block_size - (n_new_file_size & (n_block_size - 1)); | |
1278 | - pathrelse(p_s_path); | |
1279 | + pathrelse(path); | |
1280 | return cut_bytes; | |
1281 | } | |
1282 | - /* Permorm the conversion to a direct_item. */ | |
1283 | - /* return indirect_to_direct(inode, p_s_path, p_s_item_key, | |
1284 | - n_new_file_size, p_c_mode); */ | |
1285 | - return indirect2direct(th, inode, page, p_s_path, p_s_item_key, | |
1286 | - n_new_file_size, p_c_mode); | |
1287 | + /* Perform the conversion to a direct_item. */ | |
1288 | + /* return indirect_to_direct(inode, path, item_key, | |
1289 | + n_new_file_size, mode); */ | |
1290 | + return indirect2direct(th, inode, page, path, item_key, | |
1291 | + n_new_file_size, mode); | |
1292 | } | |
1293 | ||
1294 | /* we did indirect_to_direct conversion. And we have inserted direct | |
1295 | @@ -1506,8 +1509,8 @@ static void indirect_to_direct_roll_back | |
1296 | ||
1297 | /* (Truncate or cut entry) or delete object item. Returns < 0 on failure */ | |
1298 | int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th, | |
1299 | - struct treepath *p_s_path, | |
1300 | - struct cpu_key *p_s_item_key, | |
1301 | + struct treepath *path, | |
1302 | + struct cpu_key *item_key, | |
1303 | struct inode *inode, | |
1304 | struct page *page, loff_t n_new_file_size) | |
1305 | { | |
1306 | @@ -1528,7 +1531,7 @@ int reiserfs_cut_from_item(struct reiser | |
1307 | ||
1308 | BUG_ON(!th->t_trans_id); | |
1309 | ||
1310 | - init_tb_struct(th, &s_cut_balance, inode->i_sb, p_s_path, | |
1311 | + init_tb_struct(th, &s_cut_balance, inode->i_sb, path, | |
1312 | n_cut_size); | |
1313 | ||
1314 | /* Repeat this loop until we either cut the item without needing | |
1315 | @@ -1540,8 +1543,8 @@ int reiserfs_cut_from_item(struct reiser | |
1316 | pointers. */ | |
1317 | ||
1318 | c_mode = | |
1319 | - prepare_for_delete_or_cut(th, inode, p_s_path, | |
1320 | - p_s_item_key, &n_removed, | |
1321 | + prepare_for_delete_or_cut(th, inode, path, | |
1322 | + item_key, &n_removed, | |
1323 | &n_cut_size, n_new_file_size); | |
1324 | if (c_mode == M_CONVERT) { | |
1325 | /* convert last unformatted node to direct item or leave | |
1326 | @@ -1551,7 +1554,7 @@ int reiserfs_cut_from_item(struct reiser | |
1327 | ||
1328 | n_ret_value = | |
1329 | maybe_indirect_to_direct(th, inode, page, | |
1330 | - p_s_path, p_s_item_key, | |
1331 | + path, item_key, | |
1332 | n_new_file_size, &c_mode); | |
1333 | if (c_mode == M_SKIP_BALANCING) | |
1334 | /* tail has been left in the unformatted node */ | |
1335 | @@ -1568,26 +1571,26 @@ int reiserfs_cut_from_item(struct reiser | |
1336 | inserting the new direct item. Now we are removing the | |
1337 | last unformatted node pointer. Set key to search for | |
1338 | it. */ | |
1339 | - set_cpu_key_k_type(p_s_item_key, TYPE_INDIRECT); | |
1340 | - p_s_item_key->key_length = 4; | |
1341 | + set_cpu_key_k_type(item_key, TYPE_INDIRECT); | |
1342 | + item_key->key_length = 4; | |
1343 | n_new_file_size -= | |
1344 | (n_new_file_size & (sb->s_blocksize - 1)); | |
1345 | tail_pos = n_new_file_size; | |
1346 | - set_cpu_key_k_offset(p_s_item_key, n_new_file_size + 1); | |
1347 | + set_cpu_key_k_offset(item_key, n_new_file_size + 1); | |
1348 | if (search_for_position_by_key | |
1349 | - (sb, p_s_item_key, | |
1350 | - p_s_path) == POSITION_NOT_FOUND) { | |
1351 | - print_block(PATH_PLAST_BUFFER(p_s_path), 3, | |
1352 | - PATH_LAST_POSITION(p_s_path) - 1, | |
1353 | - PATH_LAST_POSITION(p_s_path) + 1); | |
1354 | + (sb, item_key, | |
1355 | + path) == POSITION_NOT_FOUND) { | |
1356 | + print_block(PATH_PLAST_BUFFER(path), 3, | |
1357 | + PATH_LAST_POSITION(path) - 1, | |
1358 | + PATH_LAST_POSITION(path) + 1); | |
1359 | reiserfs_panic(sb, "PAP-5580", "item to " | |
1360 | "convert does not exist (%K)", | |
1361 | - p_s_item_key); | |
1362 | + item_key); | |
1363 | } | |
1364 | continue; | |
1365 | } | |
1366 | if (n_cut_size == 0) { | |
1367 | - pathrelse(p_s_path); | |
1368 | + pathrelse(path); | |
1369 | return 0; | |
1370 | } | |
1371 | ||
1372 | @@ -1600,12 +1603,12 @@ int reiserfs_cut_from_item(struct reiser | |
1373 | PROC_INFO_INC(sb, cut_from_item_restarted); | |
1374 | ||
1375 | n_ret_value = | |
1376 | - search_for_position_by_key(sb, p_s_item_key, p_s_path); | |
1377 | + search_for_position_by_key(sb, item_key, path); | |
1378 | if (n_ret_value == POSITION_FOUND) | |
1379 | continue; | |
1380 | ||
1381 | reiserfs_warning(sb, "PAP-5610", "item %K not found", | |
1382 | - p_s_item_key); | |
1383 | + item_key); | |
1384 | unfix_nodes(&s_cut_balance); | |
1385 | return (n_ret_value == IO_ERROR) ? -EIO : -ENOENT; | |
1386 | } /* while */ | |
1387 | @@ -1615,7 +1618,7 @@ int reiserfs_cut_from_item(struct reiser | |
1388 | if (n_is_inode_locked) { | |
1389 | // FIXME: this seems to be not needed: we are always able | |
1390 | // to cut item | |
1391 | - indirect_to_direct_roll_back(th, inode, p_s_path); | |
1392 | + indirect_to_direct_roll_back(th, inode, path); | |
1393 | } | |
1394 | if (n_ret_value == NO_DISK_SPACE) | |
1395 | reiserfs_warning(sb, "reiserfs-5092", | |
1396 | @@ -1631,7 +1634,7 @@ int reiserfs_cut_from_item(struct reiser | |
1397 | /* Calculate number of bytes that need to be cut from the item. */ | |
1398 | quota_cut_bytes = | |
1399 | (c_mode == | |
1400 | - M_DELETE) ? ih_item_len(get_ih(p_s_path)) : -s_cut_balance. | |
1401 | + M_DELETE) ? ih_item_len(get_ih(path)) : -s_cut_balance. | |
1402 | insert_size[0]; | |
1403 | if (retval2 == -1) | |
1404 | n_ret_value = calc_deleted_bytes_number(&s_cut_balance, c_mode); | |
1405 | @@ -1878,7 +1881,7 @@ int reiserfs_do_truncate(struct reiserfs | |
1406 | #ifdef CONFIG_REISERFS_CHECK | |
1407 | // this makes sure, that we __append__, not overwrite or add holes | |
1408 | static void check_research_for_paste(struct treepath *path, | |
1409 | - const struct cpu_key *p_s_key) | |
1410 | + const struct cpu_key *key) | |
1411 | { | |
1412 | struct item_head *found_ih = get_ih(path); | |
1413 | ||
1414 | @@ -1886,35 +1889,35 @@ static void check_research_for_paste(str | |
1415 | if (le_ih_k_offset(found_ih) + | |
1416 | op_bytes_number(found_ih, | |
1417 | get_last_bh(path)->b_size) != | |
1418 | - cpu_key_k_offset(p_s_key) | |
1419 | + cpu_key_k_offset(key) | |
1420 | || op_bytes_number(found_ih, | |
1421 | get_last_bh(path)->b_size) != | |
1422 | pos_in_item(path)) | |
1423 | reiserfs_panic(NULL, "PAP-5720", "found direct item " | |
1424 | "%h or position (%d) does not match " | |
1425 | "to key %K", found_ih, | |
1426 | - pos_in_item(path), p_s_key); | |
1427 | + pos_in_item(path), key); | |
1428 | } | |
1429 | if (is_indirect_le_ih(found_ih)) { | |
1430 | if (le_ih_k_offset(found_ih) + | |
1431 | op_bytes_number(found_ih, | |
1432 | get_last_bh(path)->b_size) != | |
1433 | - cpu_key_k_offset(p_s_key) | |
1434 | + cpu_key_k_offset(key) | |
1435 | || I_UNFM_NUM(found_ih) != pos_in_item(path) | |
1436 | || get_ih_free_space(found_ih) != 0) | |
1437 | reiserfs_panic(NULL, "PAP-5730", "found indirect " | |
1438 | "item (%h) or position (%d) does not " | |
1439 | "match to key (%K)", | |
1440 | - found_ih, pos_in_item(path), p_s_key); | |
1441 | + found_ih, pos_in_item(path), key); | |
1442 | } | |
1443 | } | |
1444 | #endif /* config reiserfs check */ | |
1445 | ||
1446 | /* Paste bytes to the existing item. Returns bytes number pasted into the item. */ | |
1447 | -int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct treepath *p_s_search_path, /* Path to the pasted item. */ | |
1448 | - const struct cpu_key *p_s_key, /* Key to search for the needed item. */ | |
1449 | +int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct treepath *search_path, /* Path to the pasted item. */ | |
1450 | + const struct cpu_key *key, /* Key to search for the needed item. */ | |
1451 | struct inode *inode, /* Inode item belongs to */ | |
1452 | - const char *p_c_body, /* Pointer to the bytes to paste. */ | |
1453 | + const char *body, /* Pointer to the bytes to paste. */ | |
1454 | int n_pasted_size) | |
1455 | { /* Size of pasted bytes. */ | |
1456 | struct tree_balance s_paste_balance; | |
1457 | @@ -1929,17 +1932,17 @@ int reiserfs_paste_into_item(struct reis | |
1458 | reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE, | |
1459 | "reiserquota paste_into_item(): allocating %u id=%u type=%c", | |
1460 | n_pasted_size, inode->i_uid, | |
1461 | - key2type(&(p_s_key->on_disk_key))); | |
1462 | + key2type(&(key->on_disk_key))); | |
1463 | #endif | |
1464 | ||
1465 | if (DQUOT_ALLOC_SPACE_NODIRTY(inode, n_pasted_size)) { | |
1466 | - pathrelse(p_s_search_path); | |
1467 | + pathrelse(search_path); | |
1468 | return -EDQUOT; | |
1469 | } | |
1470 | - init_tb_struct(th, &s_paste_balance, th->t_super, p_s_search_path, | |
1471 | + init_tb_struct(th, &s_paste_balance, th->t_super, search_path, | |
1472 | n_pasted_size); | |
1473 | #ifdef DISPLACE_NEW_PACKING_LOCALITIES | |
1474 | - s_paste_balance.key = p_s_key->on_disk_key; | |
1475 | + s_paste_balance.key = key->on_disk_key; | |
1476 | #endif | |
1477 | ||
1478 | /* DQUOT_* can schedule, must check before the fix_nodes */ | |
1479 | @@ -1949,13 +1952,13 @@ int reiserfs_paste_into_item(struct reis | |
1480 | ||
1481 | while ((retval = | |
1482 | fix_nodes(M_PASTE, &s_paste_balance, NULL, | |
1483 | - p_c_body)) == REPEAT_SEARCH) { | |
1484 | + body)) == REPEAT_SEARCH) { | |
1485 | search_again: | |
1486 | /* file system changed while we were in the fix_nodes */ | |
1487 | PROC_INFO_INC(th->t_super, paste_into_item_restarted); | |
1488 | retval = | |
1489 | - search_for_position_by_key(th->t_super, p_s_key, | |
1490 | - p_s_search_path); | |
1491 | + search_for_position_by_key(th->t_super, key, | |
1492 | + search_path); | |
1493 | if (retval == IO_ERROR) { | |
1494 | retval = -EIO; | |
1495 | goto error_out; | |
1496 | @@ -1963,19 +1966,19 @@ int reiserfs_paste_into_item(struct reis | |
1497 | if (retval == POSITION_FOUND) { | |
1498 | reiserfs_warning(inode->i_sb, "PAP-5710", | |
1499 | "entry or pasted byte (%K) exists", | |
1500 | - p_s_key); | |
1501 | + key); | |
1502 | retval = -EEXIST; | |
1503 | goto error_out; | |
1504 | } | |
1505 | #ifdef CONFIG_REISERFS_CHECK | |
1506 | - check_research_for_paste(p_s_search_path, p_s_key); | |
1507 | + check_research_for_paste(search_path, key); | |
1508 | #endif | |
1509 | } | |
1510 | ||
1511 | /* Perform balancing after all resources are collected by fix_nodes, and | |
1512 | accessing them will not risk triggering schedule. */ | |
1513 | if (retval == CARRY_ON) { | |
1514 | - do_balance(&s_paste_balance, NULL /*ih */ , p_c_body, M_PASTE); | |
1515 | + do_balance(&s_paste_balance, NULL /*ih */ , body, M_PASTE); | |
1516 | return 0; | |
1517 | } | |
1518 | retval = (retval == NO_DISK_SPACE) ? -ENOSPC : -EIO; | |
1519 | @@ -1986,17 +1989,23 @@ int reiserfs_paste_into_item(struct reis | |
1520 | reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE, | |
1521 | "reiserquota paste_into_item(): freeing %u id=%u type=%c", | |
1522 | n_pasted_size, inode->i_uid, | |
1523 | - key2type(&(p_s_key->on_disk_key))); | |
1524 | + key2type(&(key->on_disk_key))); | |
1525 | #endif | |
1526 | DQUOT_FREE_SPACE_NODIRTY(inode, n_pasted_size); | |
1527 | return retval; | |
1528 | } | |
1529 | ||
1530 | -/* Insert new item into the buffer at the path. */ | |
1531 | -int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct treepath *p_s_path, /* Path to the inserteded item. */ | |
1532 | - const struct cpu_key *key, struct item_head *p_s_ih, /* Pointer to the item header to insert. */ | |
1533 | - struct inode *inode, const char *p_c_body) | |
1534 | -{ /* Pointer to the bytes to insert. */ | |
1535 | +/* Insert new item into the buffer at the path. | |
1536 | + * th - active transaction handle | |
1537 | + * path - path to the inserted item | |
1538 | + * ih - pointer to the item header to insert | |
1539 | + * body - pointer to the bytes to insert | |
1540 | + */ | |
1541 | +int reiserfs_insert_item(struct reiserfs_transaction_handle *th, | |
1542 | + struct treepath *path, const struct cpu_key *key, | |
1543 | + struct item_head *ih, struct inode *inode, | |
1544 | + const char *body) | |
1545 | +{ | |
1546 | struct tree_balance s_ins_balance; | |
1547 | int retval; | |
1548 | int fs_gen = 0; | |
1549 | @@ -2006,28 +2015,27 @@ int reiserfs_insert_item(struct reiserfs | |
1550 | ||
1551 | if (inode) { /* Do we count quotas for item? */ | |
1552 | fs_gen = get_generation(inode->i_sb); | |
1553 | - quota_bytes = ih_item_len(p_s_ih); | |
1554 | + quota_bytes = ih_item_len(ih); | |
1555 | ||
1556 | /* hack so the quota code doesn't have to guess if the file has | |
1557 | ** a tail, links are always tails, so there's no guessing needed | |
1558 | */ | |
1559 | - if (!S_ISLNK(inode->i_mode) && is_direct_le_ih(p_s_ih)) { | |
1560 | + if (!S_ISLNK(inode->i_mode) && is_direct_le_ih(ih)) | |
1561 | quota_bytes = inode->i_sb->s_blocksize + UNFM_P_SIZE; | |
1562 | - } | |
1563 | #ifdef REISERQUOTA_DEBUG | |
1564 | reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE, | |
1565 | "reiserquota insert_item(): allocating %u id=%u type=%c", | |
1566 | - quota_bytes, inode->i_uid, head2type(p_s_ih)); | |
1567 | + quota_bytes, inode->i_uid, head2type(ih)); | |
1568 | #endif | |
1569 | /* We can't dirty inode here. It would be immediately written but | |
1570 | * appropriate stat item isn't inserted yet... */ | |
1571 | if (DQUOT_ALLOC_SPACE_NODIRTY(inode, quota_bytes)) { | |
1572 | - pathrelse(p_s_path); | |
1573 | + pathrelse(path); | |
1574 | return -EDQUOT; | |
1575 | } | |
1576 | } | |
1577 | - init_tb_struct(th, &s_ins_balance, th->t_super, p_s_path, | |
1578 | - IH_SIZE + ih_item_len(p_s_ih)); | |
1579 | + init_tb_struct(th, &s_ins_balance, th->t_super, path, | |
1580 | + IH_SIZE + ih_item_len(ih)); | |
1581 | #ifdef DISPLACE_NEW_PACKING_LOCALITIES | |
1582 | s_ins_balance.key = key->on_disk_key; | |
1583 | #endif | |
1584 | @@ -2037,12 +2045,12 @@ int reiserfs_insert_item(struct reiserfs | |
1585 | } | |
1586 | ||
1587 | while ((retval = | |
1588 | - fix_nodes(M_INSERT, &s_ins_balance, p_s_ih, | |
1589 | - p_c_body)) == REPEAT_SEARCH) { | |
1590 | + fix_nodes(M_INSERT, &s_ins_balance, ih, | |
1591 | + body)) == REPEAT_SEARCH) { | |
1592 | search_again: | |
1593 | /* file system changed while we were in the fix_nodes */ | |
1594 | PROC_INFO_INC(th->t_super, insert_item_restarted); | |
1595 | - retval = search_item(th->t_super, key, p_s_path); | |
1596 | + retval = search_item(th->t_super, key, path); | |
1597 | if (retval == IO_ERROR) { | |
1598 | retval = -EIO; | |
1599 | goto error_out; | |
1600 | @@ -2058,7 +2066,7 @@ int reiserfs_insert_item(struct reiserfs | |
1601 | ||
1602 | /* make balancing after all resources will be collected at a time */ | |
1603 | if (retval == CARRY_ON) { | |
1604 | - do_balance(&s_ins_balance, p_s_ih, p_c_body, M_INSERT); | |
1605 | + do_balance(&s_ins_balance, ih, body, M_INSERT); | |
1606 | return 0; | |
1607 | } | |
1608 | ||
1609 | @@ -2069,7 +2077,7 @@ int reiserfs_insert_item(struct reiserfs | |
1610 | #ifdef REISERQUOTA_DEBUG | |
1611 | reiserfs_debug(th->t_super, REISERFS_DEBUG_CODE, | |
1612 | "reiserquota insert_item(): freeing %u id=%u type=%c", | |
1613 | - quota_bytes, inode->i_uid, head2type(p_s_ih)); | |
1614 | + quota_bytes, inode->i_uid, head2type(ih)); | |
1615 | #endif | |
1616 | if (inode) | |
1617 | DQUOT_FREE_SPACE_NODIRTY(inode, quota_bytes); | |
1618 | --- a/fs/reiserfs/tail_conversion.c | |
1619 | +++ b/fs/reiserfs/tail_conversion.c | |
1620 | @@ -172,10 +172,12 @@ void reiserfs_unmap_buffer(struct buffer | |
1621 | inode */ | |
1622 | int indirect2direct(struct reiserfs_transaction_handle *th, | |
1623 | struct inode *inode, struct page *page, | |
1624 | - struct treepath *p_s_path, /* path to the indirect item. */ | |
1625 | - const struct cpu_key *p_s_item_key, /* Key to look for unformatted node pointer to be cut. */ | |
1626 | + struct treepath *path, /* path to the indirect item. */ | |
1627 | + const struct cpu_key *item_key, /* Key to look for | |
1628 | + * unformatted node | |
1629 | + * pointer to be cut. */ | |
1630 | loff_t n_new_file_size, /* New file size. */ | |
1631 | - char *p_c_mode) | |
1632 | + char *mode) | |
1633 | { | |
1634 | struct super_block *sb = inode->i_sb; | |
1635 | struct item_head s_ih; | |
1636 | @@ -189,10 +191,10 @@ int indirect2direct(struct reiserfs_tran | |
1637 | ||
1638 | REISERFS_SB(sb)->s_indirect2direct++; | |
1639 | ||
1640 | - *p_c_mode = M_SKIP_BALANCING; | |
1641 | + *mode = M_SKIP_BALANCING; | |
1642 | ||
1643 | /* store item head path points to. */ | |
1644 | - copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path)); | |
1645 | + copy_item_head(&s_ih, PATH_PITEM_HEAD(path)); | |
1646 | ||
1647 | tail_len = (n_new_file_size & (n_block_size - 1)); | |
1648 | if (get_inode_sd_version(inode) == STAT_DATA_V2) | |
1649 | @@ -211,14 +213,14 @@ int indirect2direct(struct reiserfs_tran | |
1650 | ||
1651 | tail = (char *)kmap(page); /* this can schedule */ | |
1652 | ||
1653 | - if (path_changed(&s_ih, p_s_path)) { | |
1654 | + if (path_changed(&s_ih, path)) { | |
1655 | /* re-search indirect item */ | |
1656 | - if (search_for_position_by_key(sb, p_s_item_key, p_s_path) | |
1657 | + if (search_for_position_by_key(sb, item_key, path) | |
1658 | == POSITION_NOT_FOUND) | |
1659 | reiserfs_panic(sb, "PAP-5520", | |
1660 | "item to be converted %K does not exist", | |
1661 | - p_s_item_key); | |
1662 | - copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path)); | |
1663 | + item_key); | |
1664 | + copy_item_head(&s_ih, PATH_PITEM_HEAD(path)); | |
1665 | #ifdef CONFIG_REISERFS_CHECK | |
1666 | pos = le_ih_k_offset(&s_ih) - 1 + | |
1667 | (ih_item_len(&s_ih) / UNFM_P_SIZE - | |
1668 | @@ -240,13 +242,13 @@ int indirect2direct(struct reiserfs_tran | |
1669 | */ | |
1670 | tail = tail + (pos & (PAGE_CACHE_SIZE - 1)); | |
1671 | ||
1672 | - PATH_LAST_POSITION(p_s_path)++; | |
1673 | + PATH_LAST_POSITION(path)++; | |
1674 | ||
1675 | - key = *p_s_item_key; | |
1676 | + key = *item_key; | |
1677 | set_cpu_key_k_type(&key, TYPE_DIRECT); | |
1678 | key.key_length = 4; | |
1679 | /* Insert tail as new direct item in the tree */ | |
1680 | - if (reiserfs_insert_item(th, p_s_path, &key, &s_ih, inode, | |
1681 | + if (reiserfs_insert_item(th, path, &key, &s_ih, inode, | |
1682 | tail ? tail : NULL) < 0) { | |
1683 | /* No disk memory. So we can not convert last unformatted node | |
1684 | to the direct item. In this case we used to adjust | |
1685 | @@ -268,7 +270,7 @@ int indirect2direct(struct reiserfs_tran | |
1686 | ||
1687 | /* We have inserted new direct item and must remove last | |
1688 | unformatted node. */ | |
1689 | - *p_c_mode = M_CUT; | |
1690 | + *mode = M_CUT; | |
1691 | ||
1692 | /* we store position of first direct item in the in-core inode */ | |
1693 | /* mark_file_with_tail (inode, pos1 + 1); */ | |
1694 | --- a/include/linux/reiserfs_fs.h | |
1695 | +++ b/include/linux/reiserfs_fs.h | |
1696 | @@ -694,9 +694,9 @@ static inline void cpu_key_k_offset_dec( | |
1697 | #define is_indirect_cpu_ih(ih) (is_indirect_cpu_key (&((ih)->ih_key))) | |
1698 | #define is_statdata_cpu_ih(ih) (is_statdata_cpu_key (&((ih)->ih_key))) | |
1699 | ||
1700 | -#define I_K_KEY_IN_ITEM(p_s_ih, p_s_key, n_blocksize) \ | |
1701 | - ( ! COMP_SHORT_KEYS(p_s_ih, p_s_key) && \ | |
1702 | - I_OFF_BYTE_IN_ITEM(p_s_ih, k_offset (p_s_key), n_blocksize) ) | |
1703 | +#define I_K_KEY_IN_ITEM(ih, key, n_blocksize) \ | |
1704 | + (!COMP_SHORT_KEYS(ih, key) && \ | |
1705 | + I_OFF_BYTE_IN_ITEM(ih, k_offset(key), n_blocksize)) | |
1706 | ||
1707 | /* maximal length of item */ | |
1708 | #define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE) | |
1709 | @@ -1196,33 +1196,33 @@ struct treepath { | |
1710 | struct treepath var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,} | |
1711 | ||
1712 | /* Get path element by path and path position. */ | |
1713 | -#define PATH_OFFSET_PELEMENT(p_s_path,n_offset) ((p_s_path)->path_elements +(n_offset)) | |
1714 | +#define PATH_OFFSET_PELEMENT(path, n_offset) ((path)->path_elements + (n_offset)) | |
1715 | ||
1716 | /* Get buffer header at the path by path and path position. */ | |
1717 | -#define PATH_OFFSET_PBUFFER(p_s_path,n_offset) (PATH_OFFSET_PELEMENT(p_s_path,n_offset)->pe_buffer) | |
1718 | +#define PATH_OFFSET_PBUFFER(path, n_offset) (PATH_OFFSET_PELEMENT(path, n_offset)->pe_buffer) | |
1719 | ||
1720 | /* Get position in the element at the path by path and path position. */ | |
1721 | -#define PATH_OFFSET_POSITION(p_s_path,n_offset) (PATH_OFFSET_PELEMENT(p_s_path,n_offset)->pe_position) | |
1722 | +#define PATH_OFFSET_POSITION(path, n_offset) (PATH_OFFSET_PELEMENT(path, n_offset)->pe_position) | |
1723 | ||
1724 | -#define PATH_PLAST_BUFFER(p_s_path) (PATH_OFFSET_PBUFFER((p_s_path), (p_s_path)->path_length)) | |
1725 | +#define PATH_PLAST_BUFFER(path) (PATH_OFFSET_PBUFFER((path), (path)->path_length)) | |
1726 | /* you know, to the person who didn't | |
1727 | write this the macro name does not | |
1728 | at first suggest what it does. | |
1729 | Maybe POSITION_FROM_PATH_END? Or | |
1730 | maybe we should just focus on | |
1731 | dumping paths... -Hans */ | |
1732 | -#define PATH_LAST_POSITION(p_s_path) (PATH_OFFSET_POSITION((p_s_path), (p_s_path)->path_length)) | |
1733 | +#define PATH_LAST_POSITION(path) (PATH_OFFSET_POSITION((path), (path)->path_length)) | |
1734 | ||
1735 | -#define PATH_PITEM_HEAD(p_s_path) B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_path),PATH_LAST_POSITION(p_s_path)) | |
1736 | +#define PATH_PITEM_HEAD(path) B_N_PITEM_HEAD(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path)) | |
1737 | ||
1738 | /* in do_balance leaf has h == 0 in contrast with path structure, | |
1739 | where root has level == 0. That is why we need these defines */ | |
1740 | -#define PATH_H_PBUFFER(p_s_path, h) PATH_OFFSET_PBUFFER (p_s_path, p_s_path->path_length - (h)) /* tb->S[h] */ | |
1741 | +#define PATH_H_PBUFFER(path, h) PATH_OFFSET_PBUFFER (path, path->path_length - (h)) /* tb->S[h] */ | |
1742 | #define PATH_H_PPARENT(path, h) PATH_H_PBUFFER (path, (h) + 1) /* tb->F[h] or tb->S[0]->b_parent */ | |
1743 | #define PATH_H_POSITION(path, h) PATH_OFFSET_POSITION (path, path->path_length - (h)) | |
1744 | #define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1) /* tb->S[h]->b_item_order */ | |
1745 | ||
1746 | -#define PATH_H_PATH_OFFSET(p_s_path, n_h) ((p_s_path)->path_length - (n_h)) | |
1747 | +#define PATH_H_PATH_OFFSET(path, n_h) ((path)->path_length - (n_h)) | |
1748 | ||
1749 | #define get_last_bh(path) PATH_PLAST_BUFFER(path) | |
1750 | #define get_ih(path) PATH_PITEM_HEAD(path) | |
1751 | @@ -1512,7 +1512,7 @@ extern struct item_operations *item_ops[ | |
1752 | #define COMP_SHORT_KEYS comp_short_keys | |
1753 | ||
1754 | /* number of blocks pointed to by the indirect item */ | |
1755 | -#define I_UNFM_NUM(p_s_ih) ( ih_item_len(p_s_ih) / UNFM_P_SIZE ) | |
1756 | +#define I_UNFM_NUM(ih) (ih_item_len(ih) / UNFM_P_SIZE) | |
1757 | ||
1758 | /* the used space within the unformatted node corresponding to pos within the item pointed to by ih */ | |
1759 | #define I_POS_UNFM_SIZE(ih,pos,size) (((pos) == I_UNFM_NUM(ih) - 1 ) ? (size) - ih_free_space(ih) : (size)) | |
1760 | @@ -1793,8 +1793,8 @@ int reiserfs_convert_objectid_map_v1(str | |
1761 | ||
1762 | /* stree.c */ | |
1763 | int B_IS_IN_TREE(const struct buffer_head *); | |
1764 | -extern void copy_item_head(struct item_head *p_v_to, | |
1765 | - const struct item_head *p_v_from); | |
1766 | +extern void copy_item_head(struct item_head *to, | |
1767 | + const struct item_head *from); | |
1768 | ||
1769 | // first key is in cpu form, second - le | |
1770 | extern int comp_short_keys(const struct reiserfs_key *le_key, | |
1771 | @@ -1829,20 +1829,20 @@ static inline void copy_key(struct reise | |
1772 | memcpy(to, from, KEY_SIZE); | |
1773 | } | |
1774 | ||
1775 | -int comp_items(const struct item_head *stored_ih, const struct treepath *p_s_path); | |
1776 | -const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path, | |
1777 | +int comp_items(const struct item_head *stored_ih, const struct treepath *path); | |
1778 | +const struct reiserfs_key *get_rkey(const struct treepath *chk_path, | |
1779 | const struct super_block *sb); | |
1780 | int search_by_key(struct super_block *, const struct cpu_key *, | |
1781 | struct treepath *, int); | |
1782 | #define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL) | |
1783 | int search_for_position_by_key(struct super_block *sb, | |
1784 | - const struct cpu_key *p_s_cpu_key, | |
1785 | - struct treepath *p_s_search_path); | |
1786 | + const struct cpu_key *cpu_key, | |
1787 | + struct treepath *search_path); | |
1788 | extern void decrement_bcount(struct buffer_head *bh); | |
1789 | -void decrement_counters_in_path(struct treepath *p_s_search_path); | |
1790 | -void pathrelse(struct treepath *p_s_search_path); | |
1791 | +void decrement_counters_in_path(struct treepath *search_path); | |
1792 | +void pathrelse(struct treepath *search_path); | |
1793 | int reiserfs_check_path(struct treepath *p); | |
1794 | -void pathrelse_and_restore(struct super_block *s, struct treepath *p_s_search_path); | |
1795 | +void pathrelse_and_restore(struct super_block *s, struct treepath *search_path); | |
1796 | ||
1797 | int reiserfs_insert_item(struct reiserfs_transaction_handle *th, | |
1798 | struct treepath *path, | |
1799 | @@ -1865,7 +1865,7 @@ int reiserfs_cut_from_item(struct reiser | |
1800 | int reiserfs_delete_item(struct reiserfs_transaction_handle *th, | |
1801 | struct treepath *path, | |
1802 | const struct cpu_key *key, | |
1803 | - struct inode *inode, struct buffer_head *p_s_un_bh); | |
1804 | + struct inode *inode, struct buffer_head *un_bh); | |
1805 | ||
1806 | void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th, | |
1807 | struct inode *inode, struct reiserfs_key *key); | |
1808 | @@ -2005,7 +2005,7 @@ extern const struct address_space_operat | |
1809 | /* fix_nodes.c */ | |
1810 | ||
1811 | int fix_nodes(int n_op_mode, struct tree_balance *tb, | |
1812 | - struct item_head *p_s_ins_ih, const void *); | |
1813 | + struct item_head *ins_ih, const void *); | |
1814 | void unfix_nodes(struct tree_balance *); | |
1815 | ||
1816 | /* prints.c */ |