aboutsummaryrefslogtreecommitdiffstats
path: root/fs/reiserfs/prints.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@g5.osdl.org>2005-07-12 23:21:28 -0400
committerLinus Torvalds <torvalds@g5.osdl.org>2005-07-12 23:21:28 -0400
commitbd4c625c061c2a38568d0add3478f59172455159 (patch)
tree1c44a17c55bce2ee7ad5ea3d15a208ecc0955f74 /fs/reiserfs/prints.c
parent7fa94c8868edfef8cb6a201fcc9a5078b7b961da (diff)
reiserfs: run scripts/Lindent on reiserfs code
This was a pure indentation change, using: scripts/Lindent fs/reiserfs/*.c include/linux/reiserfs_*.h to make reiserfs match the regular Linux indentation style. As Jeff Mahoney <jeffm@suse.com> writes: The ReiserFS code is a mix of a number of different coding styles, sometimes different even from line-to-line. Since the code has been relatively stable for quite some time and there are few outstanding patches to be applied, it is time to reformat the code to conform to the Linux style standard outlined in Documentation/CodingStyle. This patch contains the result of running scripts/Lindent against fs/reiserfs/*.c and include/linux/reiserfs_*.h. There are places where the code can be made to look better, but I'd rather keep those patches separate so that there isn't a subtle by-hand hand accident in the middle of a huge patch. To be clear: This patch is reformatting *only*. A number of patches may follow that continue to make the code more consistent with the Linux coding style. Hans wasn't particularly enthusiastic about these patches, but said he wouldn't really oppose them either. Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Diffstat (limited to 'fs/reiserfs/prints.c')
-rw-r--r--fs/reiserfs/prints.c1003
1 files changed, 514 insertions, 489 deletions
diff --git a/fs/reiserfs/prints.c b/fs/reiserfs/prints.c
index 16fdca1d4bd7..d55e164bd5c2 100644
--- a/fs/reiserfs/prints.c
+++ b/fs/reiserfs/prints.c
@@ -15,168 +15,166 @@ static char error_buf[1024];
15static char fmt_buf[1024]; 15static char fmt_buf[1024];
16static char off_buf[80]; 16static char off_buf[80];
17 17
18 18static char *reiserfs_cpu_offset(struct cpu_key *key)
19static char * reiserfs_cpu_offset (struct cpu_key * key)
20{ 19{
21 if (cpu_key_k_type(key) == TYPE_DIRENTRY) 20 if (cpu_key_k_type(key) == TYPE_DIRENTRY)
22 sprintf (off_buf, "%Lu(%Lu)", 21 sprintf(off_buf, "%Lu(%Lu)",
23 (unsigned long long)GET_HASH_VALUE (cpu_key_k_offset (key)), 22 (unsigned long long)
24 (unsigned long long)GET_GENERATION_NUMBER (cpu_key_k_offset (key))); 23 GET_HASH_VALUE(cpu_key_k_offset(key)),
25 else 24 (unsigned long long)
26 sprintf (off_buf, "0x%Lx", (unsigned long long)cpu_key_k_offset (key)); 25 GET_GENERATION_NUMBER(cpu_key_k_offset(key)));
27 return off_buf; 26 else
27 sprintf(off_buf, "0x%Lx",
28 (unsigned long long)cpu_key_k_offset(key));
29 return off_buf;
28} 30}
29 31
30 32static char *le_offset(struct reiserfs_key *key)
31static char * le_offset (struct reiserfs_key * key)
32{ 33{
33 int version; 34 int version;
34 35
35 version = le_key_version (key); 36 version = le_key_version(key);
36 if (le_key_k_type (version, key) == TYPE_DIRENTRY) 37 if (le_key_k_type(version, key) == TYPE_DIRENTRY)
37 sprintf (off_buf, "%Lu(%Lu)", 38 sprintf(off_buf, "%Lu(%Lu)",
38 (unsigned long long)GET_HASH_VALUE (le_key_k_offset (version, key)), 39 (unsigned long long)
39 (unsigned long long)GET_GENERATION_NUMBER (le_key_k_offset (version, key))); 40 GET_HASH_VALUE(le_key_k_offset(version, key)),
40 else 41 (unsigned long long)
41 sprintf (off_buf, "0x%Lx", (unsigned long long)le_key_k_offset (version, key)); 42 GET_GENERATION_NUMBER(le_key_k_offset(version, key)));
42 return off_buf; 43 else
44 sprintf(off_buf, "0x%Lx",
45 (unsigned long long)le_key_k_offset(version, key));
46 return off_buf;
43} 47}
44 48
45 49static char *cpu_type(struct cpu_key *key)
46static char * cpu_type (struct cpu_key * key)
47{ 50{
48 if (cpu_key_k_type (key) == TYPE_STAT_DATA) 51 if (cpu_key_k_type(key) == TYPE_STAT_DATA)
49 return "SD"; 52 return "SD";
50 if (cpu_key_k_type (key) == TYPE_DIRENTRY) 53 if (cpu_key_k_type(key) == TYPE_DIRENTRY)
51 return "DIR"; 54 return "DIR";
52 if (cpu_key_k_type (key) == TYPE_DIRECT) 55 if (cpu_key_k_type(key) == TYPE_DIRECT)
53 return "DIRECT"; 56 return "DIRECT";
54 if (cpu_key_k_type (key) == TYPE_INDIRECT) 57 if (cpu_key_k_type(key) == TYPE_INDIRECT)
55 return "IND"; 58 return "IND";
56 return "UNKNOWN"; 59 return "UNKNOWN";
57} 60}
58 61
59 62static char *le_type(struct reiserfs_key *key)
60static char * le_type (struct reiserfs_key * key)
61{ 63{
62 int version; 64 int version;
63
64 version = le_key_version (key);
65 65
66 if (le_key_k_type (version, key) == TYPE_STAT_DATA) 66 version = le_key_version(key);
67 return "SD";
68 if (le_key_k_type (version, key) == TYPE_DIRENTRY)
69 return "DIR";
70 if (le_key_k_type (version, key) == TYPE_DIRECT)
71 return "DIRECT";
72 if (le_key_k_type (version, key) == TYPE_INDIRECT)
73 return "IND";
74 return "UNKNOWN";
75}
76 67
68 if (le_key_k_type(version, key) == TYPE_STAT_DATA)
69 return "SD";
70 if (le_key_k_type(version, key) == TYPE_DIRENTRY)
71 return "DIR";
72 if (le_key_k_type(version, key) == TYPE_DIRECT)
73 return "DIRECT";
74 if (le_key_k_type(version, key) == TYPE_INDIRECT)
75 return "IND";
76 return "UNKNOWN";
77}
77 78
78/* %k */ 79/* %k */
79static void sprintf_le_key (char * buf, struct reiserfs_key * key) 80static void sprintf_le_key(char *buf, struct reiserfs_key *key)
80{ 81{
81 if (key) 82 if (key)
82 sprintf (buf, "[%d %d %s %s]", le32_to_cpu (key->k_dir_id), 83 sprintf(buf, "[%d %d %s %s]", le32_to_cpu(key->k_dir_id),
83 le32_to_cpu (key->k_objectid), le_offset (key), le_type (key)); 84 le32_to_cpu(key->k_objectid), le_offset(key),
84 else 85 le_type(key));
85 sprintf (buf, "[NULL]"); 86 else
87 sprintf(buf, "[NULL]");
86} 88}
87 89
88
89/* %K */ 90/* %K */
90static void sprintf_cpu_key (char * buf, struct cpu_key * key) 91static void sprintf_cpu_key(char *buf, struct cpu_key *key)
91{ 92{
92 if (key) 93 if (key)
93 sprintf (buf, "[%d %d %s %s]", key->on_disk_key.k_dir_id, 94 sprintf(buf, "[%d %d %s %s]", key->on_disk_key.k_dir_id,
94 key->on_disk_key.k_objectid, reiserfs_cpu_offset (key), 95 key->on_disk_key.k_objectid, reiserfs_cpu_offset(key),
95 cpu_type (key)); 96 cpu_type(key));
96 else 97 else
97 sprintf (buf, "[NULL]"); 98 sprintf(buf, "[NULL]");
98} 99}
99 100
100static void sprintf_de_head( char *buf, struct reiserfs_de_head *deh ) 101static void sprintf_de_head(char *buf, struct reiserfs_de_head *deh)
101{ 102{
102 if( deh ) 103 if (deh)
103 sprintf( buf, "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]", deh_offset(deh), deh_dir_id(deh), 104 sprintf(buf,
104 deh_objectid(deh), deh_location(deh), deh_state(deh) ); 105 "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]",
105 else 106 deh_offset(deh), deh_dir_id(deh), deh_objectid(deh),
106 sprintf( buf, "[NULL]" ); 107 deh_location(deh), deh_state(deh));
108 else
109 sprintf(buf, "[NULL]");
107 110
108} 111}
109 112
110static void sprintf_item_head (char * buf, struct item_head * ih) 113static void sprintf_item_head(char *buf, struct item_head *ih)
111{ 114{
112 if (ih) { 115 if (ih) {
113 strcpy (buf, (ih_version (ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*"); 116 strcpy(buf,
114 sprintf_le_key (buf + strlen (buf), &(ih->ih_key)); 117 (ih_version(ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*");
115 sprintf (buf + strlen (buf), ", item_len %d, item_location %d, " 118 sprintf_le_key(buf + strlen(buf), &(ih->ih_key));
116 "free_space(entry_count) %d", 119 sprintf(buf + strlen(buf), ", item_len %d, item_location %d, "
117 ih_item_len(ih), ih_location(ih), ih_free_space (ih)); 120 "free_space(entry_count) %d",
118 } else 121 ih_item_len(ih), ih_location(ih), ih_free_space(ih));
119 sprintf (buf, "[NULL]"); 122 } else
123 sprintf(buf, "[NULL]");
120} 124}
121 125
122 126static void sprintf_direntry(char *buf, struct reiserfs_dir_entry *de)
123static void sprintf_direntry (char * buf, struct reiserfs_dir_entry * de)
124{ 127{
125 char name[20]; 128 char name[20];
126 129
127 memcpy (name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen); 130 memcpy(name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen);
128 name [de->de_namelen > 19 ? 19 : de->de_namelen] = 0; 131 name[de->de_namelen > 19 ? 19 : de->de_namelen] = 0;
129 sprintf (buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid); 132 sprintf(buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid);
130} 133}
131 134
132 135static void sprintf_block_head(char *buf, struct buffer_head *bh)
133static void sprintf_block_head (char * buf, struct buffer_head * bh)
134{ 136{
135 sprintf (buf, "level=%d, nr_items=%d, free_space=%d rdkey ", 137 sprintf(buf, "level=%d, nr_items=%d, free_space=%d rdkey ",
136 B_LEVEL (bh), B_NR_ITEMS (bh), B_FREE_SPACE (bh)); 138 B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh));
137} 139}
138 140
139 141static void sprintf_buffer_head(char *buf, struct buffer_head *bh)
140static void sprintf_buffer_head (char * buf, struct buffer_head * bh)
141{ 142{
142 char b[BDEVNAME_SIZE]; 143 char b[BDEVNAME_SIZE];
143 144
144 sprintf (buf, "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)", 145 sprintf(buf,
145 bdevname (bh->b_bdev, b), bh->b_size, 146 "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
146 (unsigned long long)bh->b_blocknr, 147 bdevname(bh->b_bdev, b), bh->b_size,
147 atomic_read (&(bh->b_count)), 148 (unsigned long long)bh->b_blocknr, atomic_read(&(bh->b_count)),
148 bh->b_state, bh->b_page, 149 bh->b_state, bh->b_page,
149 buffer_uptodate (bh) ? "UPTODATE" : "!UPTODATE", 150 buffer_uptodate(bh) ? "UPTODATE" : "!UPTODATE",
150 buffer_dirty (bh) ? "DIRTY" : "CLEAN", 151 buffer_dirty(bh) ? "DIRTY" : "CLEAN",
151 buffer_locked (bh) ? "LOCKED" : "UNLOCKED"); 152 buffer_locked(bh) ? "LOCKED" : "UNLOCKED");
152} 153}
153 154
154 155static void sprintf_disk_child(char *buf, struct disk_child *dc)
155static void sprintf_disk_child (char * buf, struct disk_child * dc)
156{ 156{
157 sprintf (buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc), dc_size(dc)); 157 sprintf(buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc),
158 dc_size(dc));
158} 159}
159 160
160 161static char *is_there_reiserfs_struct(char *fmt, int *what, int *skip)
161static char * is_there_reiserfs_struct (char * fmt, int * what, int * skip)
162{ 162{
163 char * k = fmt; 163 char *k = fmt;
164 164
165 *skip = 0; 165 *skip = 0;
166
167 while ((k = strchr (k, '%')) != NULL)
168 {
169 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
170 k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a' ) {
171 *what = k[1];
172 break;
173 }
174 (*skip) ++;
175 k ++;
176 }
177 return k;
178}
179 166
167 while ((k = strchr(k, '%')) != NULL) {
168 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
169 k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
170 *what = k[1];
171 break;
172 }
173 (*skip)++;
174 k++;
175 }
176 return k;
177}
180 178
181/* debugging reiserfs we used to print out a lot of different 179/* debugging reiserfs we used to print out a lot of different
182 variables, like keys, item headers, buffer heads etc. Values of 180 variables, like keys, item headers, buffer heads etc. Values of
@@ -191,61 +189,64 @@ static char * is_there_reiserfs_struct (char * fmt, int * what, int * skip)
191 key->k_offset, key->k_uniqueness); 189 key->k_offset, key->k_uniqueness);
192*/ 190*/
193 191
194 192static void prepare_error_buf(const char *fmt, va_list args)
195static void 193{
196prepare_error_buf( const char *fmt, va_list args ) 194 char *fmt1 = fmt_buf;
197{ 195 char *k;
198 char * fmt1 = fmt_buf; 196 char *p = error_buf;
199 char * k; 197 int i, j, what, skip;
200 char * p = error_buf; 198
201 int i, j, what, skip; 199 strcpy(fmt1, fmt);
202 200
203 strcpy (fmt1, fmt); 201 while ((k = is_there_reiserfs_struct(fmt1, &what, &skip)) != NULL) {
204 202 *k = 0;
205 while( (k = is_there_reiserfs_struct( fmt1, &what, &skip )) != NULL ) 203
206 { 204 p += vsprintf(p, fmt1, args);
207 *k = 0; 205
208 206 for (i = 0; i < skip; i++)
209 p += vsprintf (p, fmt1, args); 207 j = va_arg(args, int);
210 208
211 for (i = 0; i < skip; i ++) 209 switch (what) {
212 j = va_arg (args, int); 210 case 'k':
213 211 sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
214 switch (what) { 212 break;
215 case 'k': 213 case 'K':
216 sprintf_le_key (p, va_arg(args, struct reiserfs_key *)); 214 sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
217 break; 215 break;
218 case 'K': 216 case 'h':
219 sprintf_cpu_key (p, va_arg(args, struct cpu_key *)); 217 sprintf_item_head(p, va_arg(args, struct item_head *));
220 break; 218 break;
221 case 'h': 219 case 't':
222 sprintf_item_head (p, va_arg(args, struct item_head *)); 220 sprintf_direntry(p,
223 break; 221 va_arg(args,
224 case 't': 222 struct reiserfs_dir_entry *));
225 sprintf_direntry (p, va_arg(args, struct reiserfs_dir_entry *)); 223 break;
226 break; 224 case 'y':
227 case 'y': 225 sprintf_disk_child(p,
228 sprintf_disk_child (p, va_arg(args, struct disk_child *)); 226 va_arg(args, struct disk_child *));
229 break; 227 break;
230 case 'z': 228 case 'z':
231 sprintf_block_head (p, va_arg(args, struct buffer_head *)); 229 sprintf_block_head(p,
232 break; 230 va_arg(args, struct buffer_head *));
233 case 'b': 231 break;
234 sprintf_buffer_head (p, va_arg(args, struct buffer_head *)); 232 case 'b':
235 break; 233 sprintf_buffer_head(p,
236 case 'a': 234 va_arg(args, struct buffer_head *));
237 sprintf_de_head (p, va_arg(args, struct reiserfs_de_head *)); 235 break;
238 break; 236 case 'a':
239 } 237 sprintf_de_head(p,
240 238 va_arg(args,
241 p += strlen (p); 239 struct reiserfs_de_head *));
242 fmt1 = k + 2; 240 break;
243 } 241 }
244 vsprintf (p, fmt1, args); 242
243 p += strlen(p);
244 fmt1 = k + 2;
245 }
246 vsprintf(p, fmt1, args);
245 247
246} 248}
247 249
248
249/* in addition to usual conversion specifiers this accepts reiserfs 250/* in addition to usual conversion specifiers this accepts reiserfs
250 specific conversion specifiers: 251 specific conversion specifiers:
251 %k to print little endian key, 252 %k to print little endian key,
@@ -264,43 +265,43 @@ prepare_error_buf( const char *fmt, va_list args )
264 va_end( args );\ 265 va_end( args );\
265} 266}
266 267
267void reiserfs_warning (struct super_block *sb, const char * fmt, ...) 268void reiserfs_warning(struct super_block *sb, const char *fmt, ...)
268{ 269{
269 do_reiserfs_warning(fmt); 270 do_reiserfs_warning(fmt);
270 if (sb) 271 if (sb)
271 printk (KERN_WARNING "ReiserFS: %s: warning: %s\n", 272 printk(KERN_WARNING "ReiserFS: %s: warning: %s\n",
272 reiserfs_bdevname (sb), error_buf); 273 reiserfs_bdevname(sb), error_buf);
273 else 274 else
274 printk (KERN_WARNING "ReiserFS: warning: %s\n", error_buf); 275 printk(KERN_WARNING "ReiserFS: warning: %s\n", error_buf);
275} 276}
276 277
277/* No newline.. reiserfs_info calls can be followed by printk's */ 278/* No newline.. reiserfs_info calls can be followed by printk's */
278void reiserfs_info (struct super_block *sb, const char * fmt, ...) 279void reiserfs_info(struct super_block *sb, const char *fmt, ...)
279{ 280{
280 do_reiserfs_warning(fmt); 281 do_reiserfs_warning(fmt);
281 if (sb) 282 if (sb)
282 printk (KERN_NOTICE "ReiserFS: %s: %s", 283 printk(KERN_NOTICE "ReiserFS: %s: %s",
283 reiserfs_bdevname (sb), error_buf); 284 reiserfs_bdevname(sb), error_buf);
284 else 285 else
285 printk (KERN_NOTICE "ReiserFS: %s", error_buf); 286 printk(KERN_NOTICE "ReiserFS: %s", error_buf);
286} 287}
287 288
288/* No newline.. reiserfs_printk calls can be followed by printk's */ 289/* No newline.. reiserfs_printk calls can be followed by printk's */
289static void reiserfs_printk (const char * fmt, ...) 290static void reiserfs_printk(const char *fmt, ...)
290{ 291{
291 do_reiserfs_warning(fmt); 292 do_reiserfs_warning(fmt);
292 printk (error_buf); 293 printk(error_buf);
293} 294}
294 295
295void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...) 296void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
296{ 297{
297#ifdef CONFIG_REISERFS_CHECK 298#ifdef CONFIG_REISERFS_CHECK
298 do_reiserfs_warning(fmt); 299 do_reiserfs_warning(fmt);
299 if (s) 300 if (s)
300 printk (KERN_DEBUG "ReiserFS: %s: %s\n", 301 printk(KERN_DEBUG "ReiserFS: %s: %s\n",
301 reiserfs_bdevname (s), error_buf); 302 reiserfs_bdevname(s), error_buf);
302 else 303 else
303 printk (KERN_DEBUG "ReiserFS: %s\n", error_buf); 304 printk(KERN_DEBUG "ReiserFS: %s\n", error_buf);
304#endif 305#endif
305} 306}
306 307
@@ -349,379 +350,403 @@ void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...)
349 350
350 . */ 351 . */
351 352
352
353#ifdef CONFIG_REISERFS_CHECK 353#ifdef CONFIG_REISERFS_CHECK
354extern struct tree_balance * cur_tb; 354extern struct tree_balance *cur_tb;
355#endif 355#endif
356 356
357void reiserfs_panic (struct super_block * sb, const char * fmt, ...) 357void reiserfs_panic(struct super_block *sb, const char *fmt, ...)
358{ 358{
359 do_reiserfs_warning(fmt); 359 do_reiserfs_warning(fmt);
360 printk (KERN_EMERG "REISERFS: panic (device %s): %s\n", 360 printk(KERN_EMERG "REISERFS: panic (device %s): %s\n",
361 reiserfs_bdevname (sb), error_buf); 361 reiserfs_bdevname(sb), error_buf);
362 BUG (); 362 BUG();
363 363
364 /* this is not actually called, but makes reiserfs_panic() "noreturn" */ 364 /* this is not actually called, but makes reiserfs_panic() "noreturn" */
365 panic ("REISERFS: panic (device %s): %s\n", 365 panic("REISERFS: panic (device %s): %s\n",
366 reiserfs_bdevname (sb), error_buf); 366 reiserfs_bdevname(sb), error_buf);
367} 367}
368 368
369void 369void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
370reiserfs_abort (struct super_block *sb, int errno, const char *fmt, ...)
371{ 370{
372 do_reiserfs_warning (fmt); 371 do_reiserfs_warning(fmt);
373 372
374 if (reiserfs_error_panic (sb)) { 373 if (reiserfs_error_panic(sb)) {
375 panic (KERN_CRIT "REISERFS: panic (device %s): %s\n", 374 panic(KERN_CRIT "REISERFS: panic (device %s): %s\n",
376 reiserfs_bdevname (sb), error_buf); 375 reiserfs_bdevname(sb), error_buf);
377 } 376 }
378 377
379 if (sb->s_flags & MS_RDONLY) 378 if (sb->s_flags & MS_RDONLY)
380 return; 379 return;
381 380
382 printk (KERN_CRIT "REISERFS: abort (device %s): %s\n", 381 printk(KERN_CRIT "REISERFS: abort (device %s): %s\n",
383 reiserfs_bdevname (sb), error_buf); 382 reiserfs_bdevname(sb), error_buf);
384 383
385 sb->s_flags |= MS_RDONLY; 384 sb->s_flags |= MS_RDONLY;
386 reiserfs_journal_abort (sb, errno); 385 reiserfs_journal_abort(sb, errno);
387} 386}
388 387
389/* this prints internal nodes (4 keys/items in line) (dc_number, 388/* this prints internal nodes (4 keys/items in line) (dc_number,
390 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number, 389 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
391 dc_size)...*/ 390 dc_size)...*/
392static int print_internal (struct buffer_head * bh, int first, int last) 391static int print_internal(struct buffer_head *bh, int first, int last)
393{ 392{
394 struct reiserfs_key * key; 393 struct reiserfs_key *key;
395 struct disk_child * dc; 394 struct disk_child *dc;
396 int i; 395 int i;
397 int from, to; 396 int from, to;
398
399 if (!B_IS_KEYS_LEVEL (bh))
400 return 1;
401
402 check_internal (bh);
403
404 if (first == -1) {
405 from = 0;
406 to = B_NR_ITEMS (bh);
407 } else {
408 from = first;
409 to = last < B_NR_ITEMS (bh) ? last : B_NR_ITEMS (bh);
410 }
411
412 reiserfs_printk ("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
413
414 dc = B_N_CHILD (bh, from);
415 reiserfs_printk ("PTR %d: %y ", from, dc);
416
417 for (i = from, key = B_N_PDELIM_KEY (bh, from), dc ++; i < to; i ++, key ++, dc ++) {
418 reiserfs_printk ("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
419 if (i && i % 4 == 0)
420 printk ("\n");
421 }
422 printk ("\n");
423 return 0;
424}
425 397
398 if (!B_IS_KEYS_LEVEL(bh))
399 return 1;
426 400
401 check_internal(bh);
427 402
403 if (first == -1) {
404 from = 0;
405 to = B_NR_ITEMS(bh);
406 } else {
407 from = first;
408 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
409 }
428 410
411 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
429 412
430static int print_leaf (struct buffer_head * bh, int print_mode, int first, int last) 413 dc = B_N_CHILD(bh, from);
431{ 414 reiserfs_printk("PTR %d: %y ", from, dc);
432 struct block_head * blkh;
433 struct item_head * ih;
434 int i, nr;
435 int from, to;
436 415
437 if (!B_IS_ITEMS_LEVEL (bh)) 416 for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
438 return 1; 417 i++, key++, dc++) {
418 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
419 if (i && i % 4 == 0)
420 printk("\n");
421 }
422 printk("\n");
423 return 0;
424}
439 425
440 check_leaf (bh); 426static int print_leaf(struct buffer_head *bh, int print_mode, int first,
427 int last)
428{
429 struct block_head *blkh;
430 struct item_head *ih;
431 int i, nr;
432 int from, to;
441 433
442 blkh = B_BLK_HEAD (bh); 434 if (!B_IS_ITEMS_LEVEL(bh))
443 ih = B_N_PITEM_HEAD (bh,0); 435 return 1;
444 nr = blkh_nr_item(blkh);
445 436
446 printk ("\n===================================================================\n"); 437 check_leaf(bh);
447 reiserfs_printk ("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
448 438
449 if (!(print_mode & PRINT_LEAF_ITEMS)) { 439 blkh = B_BLK_HEAD(bh);
450 reiserfs_printk ("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n", 440 ih = B_N_PITEM_HEAD(bh, 0);
451 &(ih->ih_key), &((ih + nr - 1)->ih_key)); 441 nr = blkh_nr_item(blkh);
452 return 0;
453 }
454 442
455 if (first < 0 || first > nr - 1) 443 printk
456 from = 0; 444 ("\n===================================================================\n");
457 else 445 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
458 from = first;
459 446
460 if (last < 0 || last > nr ) 447 if (!(print_mode & PRINT_LEAF_ITEMS)) {
461 to = nr; 448 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
462 else 449 &(ih->ih_key), &((ih + nr - 1)->ih_key));
463 to = last; 450 return 0;
451 }
464 452
465 ih += from; 453 if (first < 0 || first > nr - 1)
466 printk ("-------------------------------------------------------------------------------\n"); 454 from = 0;
467 printk ("|##| type | key | ilen | free_space | version | loc |\n"); 455 else
468 for (i = from; i < to; i++, ih ++) { 456 from = first;
469 printk ("-------------------------------------------------------------------------------\n"); 457
470 reiserfs_printk ("|%2d| %h |\n", i, ih); 458 if (last < 0 || last > nr)
471 if (print_mode & PRINT_LEAF_ITEMS) 459 to = nr;
472 op_print_item (ih, B_I_PITEM (bh, ih)); 460 else
473 } 461 to = last;
462
463 ih += from;
464 printk
465 ("-------------------------------------------------------------------------------\n");
466 printk
467 ("|##| type | key | ilen | free_space | version | loc |\n");
468 for (i = from; i < to; i++, ih++) {
469 printk
470 ("-------------------------------------------------------------------------------\n");
471 reiserfs_printk("|%2d| %h |\n", i, ih);
472 if (print_mode & PRINT_LEAF_ITEMS)
473 op_print_item(ih, B_I_PITEM(bh, ih));
474 }
474 475
475 printk ("===================================================================\n"); 476 printk
477 ("===================================================================\n");
476 478
477 return 0; 479 return 0;
478} 480}
479 481
480char * reiserfs_hashname(int code) 482char *reiserfs_hashname(int code)
481{ 483{
482 if ( code == YURA_HASH) 484 if (code == YURA_HASH)
483 return "rupasov"; 485 return "rupasov";
484 if ( code == TEA_HASH) 486 if (code == TEA_HASH)
485 return "tea"; 487 return "tea";
486 if ( code == R5_HASH) 488 if (code == R5_HASH)
487 return "r5"; 489 return "r5";
488 490
489 return "unknown"; 491 return "unknown";
490} 492}
491 493
492/* return 1 if this is not super block */ 494/* return 1 if this is not super block */
493static int print_super_block (struct buffer_head * bh) 495static int print_super_block(struct buffer_head *bh)
494{ 496{
495 struct reiserfs_super_block * rs = (struct reiserfs_super_block *)(bh->b_data); 497 struct reiserfs_super_block *rs =
496 int skipped, data_blocks; 498 (struct reiserfs_super_block *)(bh->b_data);
497 char *version; 499 int skipped, data_blocks;
498 char b[BDEVNAME_SIZE]; 500 char *version;
499 501 char b[BDEVNAME_SIZE];
500 if (is_reiserfs_3_5(rs)) { 502
501 version = "3.5"; 503 if (is_reiserfs_3_5(rs)) {
502 } else if (is_reiserfs_3_6(rs)) { 504 version = "3.5";
503 version = "3.6"; 505 } else if (is_reiserfs_3_6(rs)) {
504 } else if (is_reiserfs_jr(rs)) { 506 version = "3.6";
505 version = ((sb_version(rs) == REISERFS_VERSION_2) ? 507 } else if (is_reiserfs_jr(rs)) {
506 "3.6" : "3.5"); 508 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
507 } else { 509 "3.6" : "3.5");
508 return 1; 510 } else {
509 } 511 return 1;
510 512 }
511 printk ("%s\'s super block is in block %llu\n", bdevname (bh->b_bdev, b), 513
512 (unsigned long long)bh->b_blocknr); 514 printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
513 printk ("Reiserfs version %s\n", version ); 515 (unsigned long long)bh->b_blocknr);
514 printk ("Block count %u\n", sb_block_count(rs)); 516 printk("Reiserfs version %s\n", version);
515 printk ("Blocksize %d\n", sb_blocksize(rs)); 517 printk("Block count %u\n", sb_block_count(rs));
516 printk ("Free blocks %u\n", sb_free_blocks(rs)); 518 printk("Blocksize %d\n", sb_blocksize(rs));
517 // FIXME: this would be confusing if 519 printk("Free blocks %u\n", sb_free_blocks(rs));
518 // someone stores reiserfs super block in some data block ;) 520 // FIXME: this would be confusing if
521 // someone stores reiserfs super block in some data block ;)
519// skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs); 522// skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
520 skipped = bh->b_blocknr; 523 skipped = bh->b_blocknr;
521 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) - 524 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
522 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) + 1 : sb_reserved_for_journal(rs)) - 525 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
523 sb_free_blocks(rs); 526 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
524 printk ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n" 527 printk
525 "1 super block, %d data blocks\n", 528 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
526 skipped, sb_bmap_nr(rs), (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) : 529 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
527 sb_reserved_for_journal(rs)) , data_blocks); 530 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
528 printk ("Root block %u\n", sb_root_block(rs)); 531 sb_reserved_for_journal(rs)), data_blocks);
529 printk ("Journal block (first) %d\n", sb_jp_journal_1st_block(rs)); 532 printk("Root block %u\n", sb_root_block(rs));
530 printk ("Journal dev %d\n", sb_jp_journal_dev(rs)); 533 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
531 printk ("Journal orig size %d\n", sb_jp_journal_size(rs)); 534 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
532 printk ("FS state %d\n", sb_fs_state(rs)); 535 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
533 printk ("Hash function \"%s\"\n", 536 printk("FS state %d\n", sb_fs_state(rs));
534 reiserfs_hashname(sb_hash_function_code(rs))); 537 printk("Hash function \"%s\"\n",
535 538 reiserfs_hashname(sb_hash_function_code(rs)));
536 printk ("Tree height %d\n", sb_tree_height(rs)); 539
537 return 0; 540 printk("Tree height %d\n", sb_tree_height(rs));
541 return 0;
538} 542}
539 543
540static int print_desc_block (struct buffer_head * bh) 544static int print_desc_block(struct buffer_head *bh)
541{ 545{
542 struct reiserfs_journal_desc * desc; 546 struct reiserfs_journal_desc *desc;
543 547
544 if (memcmp(get_journal_desc_magic (bh), JOURNAL_DESC_MAGIC, 8)) 548 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
545 return 1; 549 return 1;
546 550
547 desc = (struct reiserfs_journal_desc *)(bh->b_data); 551 desc = (struct reiserfs_journal_desc *)(bh->b_data);
548 printk ("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)", 552 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
549 (unsigned long long)bh->b_blocknr, get_desc_trans_id (desc), get_desc_mount_id (desc), 553 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
550 get_desc_trans_len (desc)); 554 get_desc_mount_id(desc), get_desc_trans_len(desc));
551 555
552 return 0; 556 return 0;
553} 557}
554 558
555 559void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
556void print_block (struct buffer_head * bh, ...)//int print_mode, int first, int last)
557{ 560{
558 va_list args; 561 va_list args;
559 int mode, first, last; 562 int mode, first, last;
560 563
561 va_start (args, bh); 564 va_start(args, bh);
562 565
563 if ( ! bh ) { 566 if (!bh) {
564 printk("print_block: buffer is NULL\n"); 567 printk("print_block: buffer is NULL\n");
565 return; 568 return;
566 } 569 }
567 570
568 mode = va_arg (args, int); 571 mode = va_arg(args, int);
569 first = va_arg (args, int); 572 first = va_arg(args, int);
570 last = va_arg (args, int); 573 last = va_arg(args, int);
571 if (print_leaf (bh, mode, first, last)) 574 if (print_leaf(bh, mode, first, last))
572 if (print_internal (bh, first, last)) 575 if (print_internal(bh, first, last))
573 if (print_super_block (bh)) 576 if (print_super_block(bh))
574 if (print_desc_block (bh)) 577 if (print_desc_block(bh))
575 printk ("Block %llu contains unformatted data\n", (unsigned long long)bh->b_blocknr); 578 printk
579 ("Block %llu contains unformatted data\n",
580 (unsigned long long)bh->b_blocknr);
576} 581}
577 582
578
579
580static char print_tb_buf[2048]; 583static char print_tb_buf[2048];
581 584
582/* this stores initial state of tree balance in the print_tb_buf */ 585/* this stores initial state of tree balance in the print_tb_buf */
583void store_print_tb (struct tree_balance * tb) 586void store_print_tb(struct tree_balance *tb)
584{ 587{
585 int h = 0; 588 int h = 0;
586 int i; 589 int i;
587 struct buffer_head * tbSh, * tbFh; 590 struct buffer_head *tbSh, *tbFh;
588 591
589 if (!tb) 592 if (!tb)
590 return; 593 return;
591 594
592 sprintf (print_tb_buf, "\n" 595 sprintf(print_tb_buf, "\n"
593 "BALANCING %d\n" 596 "BALANCING %d\n"
594 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n" 597 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
595 "=====================================================================\n" 598 "=====================================================================\n"
596 "* h * S * L * R * F * FL * FR * CFL * CFR *\n", 599 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
597 REISERFS_SB(tb->tb_sb)->s_do_balance, 600 REISERFS_SB(tb->tb_sb)->s_do_balance,
598 tb->tb_mode, PATH_LAST_POSITION (tb->tb_path), tb->tb_path->pos_in_item); 601 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
599 602 tb->tb_path->pos_in_item);
600 for (h = 0; h < sizeof(tb->insert_size) / sizeof (tb->insert_size[0]); h ++) { 603
601 if (PATH_H_PATH_OFFSET (tb->tb_path, h) <= tb->tb_path->path_length && 604 for (h = 0; h < sizeof(tb->insert_size) / sizeof(tb->insert_size[0]);
602 PATH_H_PATH_OFFSET (tb->tb_path, h) > ILLEGAL_PATH_ELEMENT_OFFSET) { 605 h++) {
603 tbSh = PATH_H_PBUFFER (tb->tb_path, h); 606 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
604 tbFh = PATH_H_PPARENT (tb->tb_path, h); 607 tb->tb_path->path_length
605 } else { 608 && PATH_H_PATH_OFFSET(tb->tb_path,
606 tbSh = NULL; 609 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
607 tbFh = NULL; 610 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
611 tbFh = PATH_H_PPARENT(tb->tb_path, h);
612 } else {
613 tbSh = NULL;
614 tbFh = NULL;
615 }
616 sprintf(print_tb_buf + strlen(print_tb_buf),
617 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
618 h,
619 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
620 (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
621 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
622 (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
623 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
624 (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
625 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
626 (tb->FL[h]) ? (long long)(tb->FL[h]->
627 b_blocknr) : (-1LL),
628 (tb->FR[h]) ? (long long)(tb->FR[h]->
629 b_blocknr) : (-1LL),
630 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
631 b_blocknr) : (-1LL),
632 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
633 b_blocknr) : (-1LL));
608 } 634 }
609 sprintf (print_tb_buf + strlen (print_tb_buf),
610 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
611 h,
612 (tbSh) ? (long long)(tbSh->b_blocknr):(-1LL),
613 (tbSh) ? atomic_read (&(tbSh->b_count)) : -1,
614 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr):(-1LL),
615 (tb->L[h]) ? atomic_read (&(tb->L[h]->b_count)) : -1,
616 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr):(-1LL),
617 (tb->R[h]) ? atomic_read (&(tb->R[h]->b_count)) : -1,
618 (tbFh) ? (long long)(tbFh->b_blocknr):(-1LL),
619 (tb->FL[h]) ? (long long)(tb->FL[h]->b_blocknr):(-1LL),
620 (tb->FR[h]) ? (long long)(tb->FR[h]->b_blocknr):(-1LL),
621 (tb->CFL[h]) ? (long long)(tb->CFL[h]->b_blocknr):(-1LL),
622 (tb->CFR[h]) ? (long long)(tb->CFR[h]->b_blocknr):(-1LL));
623 }
624
625 sprintf (print_tb_buf + strlen (print_tb_buf),
626 "=====================================================================\n"
627 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
628 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
629 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],tb->rbytes, tb->blknum[0],
630 tb->s0num, tb->s1num,tb->s1bytes, tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0], tb->rkey[0]);
631
632 /* this prints balance parameters for non-leaf levels */
633 h = 0;
634 do {
635 h++;
636 sprintf (print_tb_buf + strlen (print_tb_buf),
637 "* %d * %4d * %2d * * %2d * * %2d *\n",
638 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h], tb->blknum[h]);
639 } while (tb->insert_size[h]);
640
641 sprintf (print_tb_buf + strlen (print_tb_buf),
642 "=====================================================================\n"
643 "FEB list: ");
644
645 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
646 h = 0;
647 for (i = 0; i < sizeof (tb->FEB) / sizeof (tb->FEB[0]); i ++)
648 sprintf (print_tb_buf + strlen (print_tb_buf),
649 "%p (%llu %d)%s", tb->FEB[i], tb->FEB[i] ? (unsigned long long)tb->FEB[i]->b_blocknr : 0ULL,
650 tb->FEB[i] ? atomic_read (&(tb->FEB[i]->b_count)) : 0,
651 (i == sizeof (tb->FEB) / sizeof (tb->FEB[0]) - 1) ? "\n" : ", ");
652
653 sprintf (print_tb_buf + strlen (print_tb_buf),
654 "======================== the end ====================================\n");
655}
656
657void print_cur_tb (char * mes)
658{
659 printk ("%s\n%s", mes, print_tb_buf);
660}
661
662static void check_leaf_block_head (struct buffer_head * bh)
663{
664 struct block_head * blkh;
665 int nr;
666
667 blkh = B_BLK_HEAD (bh);
668 nr = blkh_nr_item(blkh);
669 if ( nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
670 reiserfs_panic (NULL, "vs-6010: check_leaf_block_head: invalid item number %z", bh);
671 if ( blkh_free_space(blkh) >
672 bh->b_size - BLKH_SIZE - IH_SIZE * nr )
673 reiserfs_panic (NULL, "vs-6020: check_leaf_block_head: invalid free space %z", bh);
674
675}
676 635
677static void check_internal_block_head (struct buffer_head * bh) 636 sprintf(print_tb_buf + strlen(print_tb_buf),
678{ 637 "=====================================================================\n"
679 struct block_head * blkh; 638 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
680 639 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
681 blkh = B_BLK_HEAD (bh); 640 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
682 if (!(B_LEVEL (bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL (bh) <= MAX_HEIGHT)) 641 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
683 reiserfs_panic (NULL, "vs-6025: check_internal_block_head: invalid level %z", bh); 642 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
643 tb->rkey[0]);
644
645 /* this prints balance parameters for non-leaf levels */
646 h = 0;
647 do {
648 h++;
649 sprintf(print_tb_buf + strlen(print_tb_buf),
650 "* %d * %4d * %2d * * %2d * * %2d *\n",
651 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
652 tb->blknum[h]);
653 } while (tb->insert_size[h]);
684 654
685 if (B_NR_ITEMS (bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE) 655 sprintf(print_tb_buf + strlen(print_tb_buf),
686 reiserfs_panic (NULL, "vs-6030: check_internal_block_head: invalid item number %z", bh); 656 "=====================================================================\n"
657 "FEB list: ");
687 658
688 if (B_FREE_SPACE (bh) != 659 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
689 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS (bh) - DC_SIZE * (B_NR_ITEMS (bh) + 1)) 660 h = 0;
690 reiserfs_panic (NULL, "vs-6040: check_internal_block_head: invalid free space %z", bh); 661 for (i = 0; i < sizeof(tb->FEB) / sizeof(tb->FEB[0]); i++)
662 sprintf(print_tb_buf + strlen(print_tb_buf),
663 "%p (%llu %d)%s", tb->FEB[i],
664 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
665 b_blocknr : 0ULL,
666 tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
667 (i ==
668 sizeof(tb->FEB) / sizeof(tb->FEB[0]) -
669 1) ? "\n" : ", ");
691 670
671 sprintf(print_tb_buf + strlen(print_tb_buf),
672 "======================== the end ====================================\n");
692} 673}
693 674
675void print_cur_tb(char *mes)
676{
677 printk("%s\n%s", mes, print_tb_buf);
678}
694 679
695void check_leaf (struct buffer_head * bh) 680static void check_leaf_block_head(struct buffer_head *bh)
696{ 681{
697 int i; 682 struct block_head *blkh;
698 struct item_head * ih; 683 int nr;
684
685 blkh = B_BLK_HEAD(bh);
686 nr = blkh_nr_item(blkh);
687 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
688 reiserfs_panic(NULL,
689 "vs-6010: check_leaf_block_head: invalid item number %z",
690 bh);
691 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
692 reiserfs_panic(NULL,
693 "vs-6020: check_leaf_block_head: invalid free space %z",
694 bh);
699 695
700 if (!bh)
701 return;
702 check_leaf_block_head (bh);
703 for (i = 0, ih = B_N_PITEM_HEAD (bh, 0); i < B_NR_ITEMS (bh); i ++, ih ++)
704 op_check_item (ih, B_I_PITEM (bh, ih));
705} 696}
706 697
698static void check_internal_block_head(struct buffer_head *bh)
699{
700 struct block_head *blkh;
701
702 blkh = B_BLK_HEAD(bh);
703 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
704 reiserfs_panic(NULL,
705 "vs-6025: check_internal_block_head: invalid level %z",
706 bh);
707
708 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
709 reiserfs_panic(NULL,
710 "vs-6030: check_internal_block_head: invalid item number %z",
711 bh);
712
713 if (B_FREE_SPACE(bh) !=
714 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
715 DC_SIZE * (B_NR_ITEMS(bh) + 1))
716 reiserfs_panic(NULL,
717 "vs-6040: check_internal_block_head: invalid free space %z",
718 bh);
719
720}
707 721
708void check_internal (struct buffer_head * bh) 722void check_leaf(struct buffer_head *bh)
709{ 723{
710 if (!bh) 724 int i;
711 return; 725 struct item_head *ih;
712 check_internal_block_head (bh); 726
727 if (!bh)
728 return;
729 check_leaf_block_head(bh);
730 for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
731 op_check_item(ih, B_I_PITEM(bh, ih));
713} 732}
714 733
734void check_internal(struct buffer_head *bh)
735{
736 if (!bh)
737 return;
738 check_internal_block_head(bh);
739}
715 740
716void print_statistics (struct super_block * s) 741void print_statistics(struct super_block *s)
717{ 742{
718 743
719 /* 744 /*
720 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \ 745 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
721bmap with search %d, without %d, dir2ind %d, ind2dir %d\n", 746 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
722 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes, 747 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
723 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search, 748 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
724 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct); 749 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
725 */ 750 */
726 751
727} 752}
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-27 21:26:46 -0400