]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README | |
3 | */ | |
4 | ||
5 | #include <linux/config.h> | |
6 | #include <linux/time.h> | |
7 | #include <linux/fs.h> | |
8 | #include <linux/reiserfs_fs.h> | |
9 | #include <linux/string.h> | |
10 | #include <linux/buffer_head.h> | |
11 | ||
12 | #include <stdarg.h> | |
13 | ||
14 | static char error_buf[1024]; | |
15 | static char fmt_buf[1024]; | |
16 | static char off_buf[80]; | |
17 | ||
18 | ||
19 | static char * reiserfs_cpu_offset (struct cpu_key * key) | |
20 | { | |
21 | if (cpu_key_k_type(key) == TYPE_DIRENTRY) | |
22 | sprintf (off_buf, "%Lu(%Lu)", | |
23 | (unsigned long long)GET_HASH_VALUE (cpu_key_k_offset (key)), | |
24 | (unsigned long long)GET_GENERATION_NUMBER (cpu_key_k_offset (key))); | |
25 | else | |
26 | sprintf (off_buf, "0x%Lx", (unsigned long long)cpu_key_k_offset (key)); | |
27 | return off_buf; | |
28 | } | |
29 | ||
30 | ||
31 | static char * le_offset (struct reiserfs_key * key) | |
32 | { | |
33 | int version; | |
34 | ||
35 | version = le_key_version (key); | |
36 | if (le_key_k_type (version, key) == TYPE_DIRENTRY) | |
37 | sprintf (off_buf, "%Lu(%Lu)", | |
38 | (unsigned long long)GET_HASH_VALUE (le_key_k_offset (version, key)), | |
39 | (unsigned long long)GET_GENERATION_NUMBER (le_key_k_offset (version, key))); | |
40 | else | |
41 | sprintf (off_buf, "0x%Lx", (unsigned long long)le_key_k_offset (version, key)); | |
42 | return off_buf; | |
43 | } | |
44 | ||
45 | ||
46 | static char * cpu_type (struct cpu_key * key) | |
47 | { | |
48 | if (cpu_key_k_type (key) == TYPE_STAT_DATA) | |
49 | return "SD"; | |
50 | if (cpu_key_k_type (key) == TYPE_DIRENTRY) | |
51 | return "DIR"; | |
52 | if (cpu_key_k_type (key) == TYPE_DIRECT) | |
53 | return "DIRECT"; | |
54 | if (cpu_key_k_type (key) == TYPE_INDIRECT) | |
55 | return "IND"; | |
56 | return "UNKNOWN"; | |
57 | } | |
58 | ||
59 | ||
60 | static char * le_type (struct reiserfs_key * key) | |
61 | { | |
62 | int version; | |
63 | ||
64 | version = le_key_version (key); | |
65 | ||
66 | if (le_key_k_type (version, key) == TYPE_STAT_DATA) | |
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 | ||
77 | ||
78 | /* %k */ | |
79 | static void sprintf_le_key (char * buf, struct reiserfs_key * key) | |
80 | { | |
81 | if (key) | |
82 | 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 | else | |
85 | sprintf (buf, "[NULL]"); | |
86 | } | |
87 | ||
88 | ||
89 | /* %K */ | |
90 | static void sprintf_cpu_key (char * buf, struct cpu_key * key) | |
91 | { | |
92 | if (key) | |
93 | 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 | cpu_type (key)); | |
96 | else | |
97 | sprintf (buf, "[NULL]"); | |
98 | } | |
99 | ||
100 | static void sprintf_de_head( char *buf, struct reiserfs_de_head *deh ) | |
101 | { | |
102 | if( deh ) | |
103 | sprintf( buf, "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]", deh_offset(deh), deh_dir_id(deh), | |
104 | deh_objectid(deh), deh_location(deh), deh_state(deh) ); | |
105 | else | |
106 | sprintf( buf, "[NULL]" ); | |
107 | ||
108 | } | |
109 | ||
110 | static void sprintf_item_head (char * buf, struct item_head * ih) | |
111 | { | |
112 | if (ih) { | |
113 | strcpy (buf, (ih_version (ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*"); | |
114 | sprintf_le_key (buf + strlen (buf), &(ih->ih_key)); | |
115 | sprintf (buf + strlen (buf), ", item_len %d, item_location %d, " | |
116 | "free_space(entry_count) %d", | |
117 | ih_item_len(ih), ih_location(ih), ih_free_space (ih)); | |
118 | } else | |
119 | sprintf (buf, "[NULL]"); | |
120 | } | |
121 | ||
122 | ||
123 | static void sprintf_direntry (char * buf, struct reiserfs_dir_entry * de) | |
124 | { | |
125 | char name[20]; | |
126 | ||
127 | memcpy (name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen); | |
128 | name [de->de_namelen > 19 ? 19 : de->de_namelen] = 0; | |
129 | sprintf (buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid); | |
130 | } | |
131 | ||
132 | ||
133 | static void sprintf_block_head (char * buf, struct buffer_head * bh) | |
134 | { | |
135 | sprintf (buf, "level=%d, nr_items=%d, free_space=%d rdkey ", | |
136 | B_LEVEL (bh), B_NR_ITEMS (bh), B_FREE_SPACE (bh)); | |
137 | } | |
138 | ||
139 | ||
140 | static void sprintf_buffer_head (char * buf, struct buffer_head * bh) | |
141 | { | |
142 | char b[BDEVNAME_SIZE]; | |
143 | ||
144 | sprintf (buf, "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)", | |
145 | bdevname (bh->b_bdev, b), bh->b_size, | |
146 | (unsigned long long)bh->b_blocknr, | |
147 | atomic_read (&(bh->b_count)), | |
148 | bh->b_state, bh->b_page, | |
149 | buffer_uptodate (bh) ? "UPTODATE" : "!UPTODATE", | |
150 | buffer_dirty (bh) ? "DIRTY" : "CLEAN", | |
151 | buffer_locked (bh) ? "LOCKED" : "UNLOCKED"); | |
152 | } | |
153 | ||
154 | ||
155 | static void sprintf_disk_child (char * buf, struct disk_child * dc) | |
156 | { | |
157 | sprintf (buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc), dc_size(dc)); | |
158 | } | |
159 | ||
160 | ||
161 | static char * is_there_reiserfs_struct (char * fmt, int * what, int * skip) | |
162 | { | |
163 | char * k = fmt; | |
164 | ||
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 | ||
180 | ||
181 | /* debugging reiserfs we used to print out a lot of different | |
182 | variables, like keys, item headers, buffer heads etc. Values of | |
183 | most fields matter. So it took a long time just to write | |
184 | appropriative printk. With this reiserfs_warning you can use format | |
185 | specification for complex structures like you used to do with | |
186 | printfs for integers, doubles and pointers. For instance, to print | |
187 | out key structure you have to write just: | |
188 | reiserfs_warning ("bad key %k", key); | |
189 | instead of | |
190 | printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid, | |
191 | key->k_offset, key->k_uniqueness); | |
192 | */ | |
193 | ||
194 | ||
195 | static void | |
196 | prepare_error_buf( const char *fmt, va_list args ) | |
197 | { | |
198 | char * fmt1 = fmt_buf; | |
199 | char * k; | |
200 | char * p = error_buf; | |
201 | int i, j, what, skip; | |
202 | ||
203 | strcpy (fmt1, fmt); | |
204 | ||
205 | while( (k = is_there_reiserfs_struct( fmt1, &what, &skip )) != NULL ) | |
206 | { | |
207 | *k = 0; | |
208 | ||
209 | p += vsprintf (p, fmt1, args); | |
210 | ||
211 | for (i = 0; i < skip; i ++) | |
212 | j = va_arg (args, int); | |
213 | ||
214 | switch (what) { | |
215 | case 'k': | |
216 | sprintf_le_key (p, va_arg(args, struct reiserfs_key *)); | |
217 | break; | |
218 | case 'K': | |
219 | sprintf_cpu_key (p, va_arg(args, struct cpu_key *)); | |
220 | break; | |
221 | case 'h': | |
222 | sprintf_item_head (p, va_arg(args, struct item_head *)); | |
223 | break; | |
224 | case 't': | |
225 | sprintf_direntry (p, va_arg(args, struct reiserfs_dir_entry *)); | |
226 | break; | |
227 | case 'y': | |
228 | sprintf_disk_child (p, va_arg(args, struct disk_child *)); | |
229 | break; | |
230 | case 'z': | |
231 | sprintf_block_head (p, va_arg(args, struct buffer_head *)); | |
232 | break; | |
233 | case 'b': | |
234 | sprintf_buffer_head (p, va_arg(args, struct buffer_head *)); | |
235 | break; | |
236 | case 'a': | |
237 | sprintf_de_head (p, va_arg(args, struct reiserfs_de_head *)); | |
238 | break; | |
239 | } | |
240 | ||
241 | p += strlen (p); | |
242 | fmt1 = k + 2; | |
243 | } | |
244 | vsprintf (p, fmt1, args); | |
245 | ||
246 | } | |
247 | ||
248 | ||
249 | /* in addition to usual conversion specifiers this accepts reiserfs | |
250 | specific conversion specifiers: | |
251 | %k to print little endian key, | |
252 | %K to print cpu key, | |
253 | %h to print item_head, | |
254 | %t to print directory entry | |
255 | %z to print block head (arg must be struct buffer_head * | |
256 | %b to print buffer_head | |
257 | */ | |
258 | ||
259 | #define do_reiserfs_warning(fmt)\ | |
260 | {\ | |
261 | va_list args;\ | |
262 | va_start( args, fmt );\ | |
263 | prepare_error_buf( fmt, args );\ | |
264 | va_end( args );\ | |
265 | } | |
266 | ||
267 | void reiserfs_warning (struct super_block *sb, const char * fmt, ...) | |
268 | { | |
269 | do_reiserfs_warning(fmt); | |
270 | if (sb) | |
271 | printk (KERN_WARNING "ReiserFS: %s: warning: %s\n", | |
272 | reiserfs_bdevname (sb), error_buf); | |
273 | else | |
274 | printk (KERN_WARNING "ReiserFS: warning: %s\n", error_buf); | |
275 | } | |
276 | ||
277 | /* No newline.. reiserfs_info calls can be followed by printk's */ | |
278 | void reiserfs_info (struct super_block *sb, const char * fmt, ...) | |
279 | { | |
280 | do_reiserfs_warning(fmt); | |
281 | if (sb) | |
282 | printk (KERN_NOTICE "ReiserFS: %s: %s", | |
283 | reiserfs_bdevname (sb), error_buf); | |
284 | else | |
285 | printk (KERN_NOTICE "ReiserFS: %s", error_buf); | |
286 | } | |
287 | ||
288 | /* No newline.. reiserfs_printk calls can be followed by printk's */ | |
289 | static void reiserfs_printk (const char * fmt, ...) | |
290 | { | |
291 | do_reiserfs_warning(fmt); | |
292 | printk (error_buf); | |
293 | } | |
294 | ||
295 | void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...) | |
296 | { | |
297 | #ifdef CONFIG_REISERFS_CHECK | |
298 | do_reiserfs_warning(fmt); | |
299 | if (s) | |
300 | printk (KERN_DEBUG "ReiserFS: %s: %s\n", | |
301 | reiserfs_bdevname (s), error_buf); | |
302 | else | |
303 | printk (KERN_DEBUG "ReiserFS: %s\n", error_buf); | |
304 | #endif | |
305 | } | |
306 | ||
307 | /* The format: | |
308 | ||
309 | maintainer-errorid: [function-name:] message | |
310 | ||
311 | where errorid is unique to the maintainer and function-name is | |
312 | optional, is recommended, so that anyone can easily find the bug | |
313 | with a simple grep for the short to type string | |
314 | maintainer-errorid. Don't bother with reusing errorids, there are | |
315 | lots of numbers out there. | |
316 | ||
317 | Example: | |
318 | ||
319 | reiserfs_panic( | |
320 | p_sb, "reiser-29: reiserfs_new_blocknrs: " | |
321 | "one of search_start or rn(%d) is equal to MAX_B_NUM," | |
322 | "which means that we are optimizing location based on the bogus location of a temp buffer (%p).", | |
323 | rn, bh | |
324 | ); | |
325 | ||
326 | Regular panic()s sometimes clear the screen before the message can | |
327 | be read, thus the need for the while loop. | |
328 | ||
329 | Numbering scheme for panic used by Vladimir and Anatoly( Hans completely ignores this scheme, and considers it | |
330 | pointless complexity): | |
331 | ||
332 | panics in reiserfs_fs.h have numbers from 1000 to 1999 | |
333 | super.c 2000 to 2999 | |
334 | preserve.c (unused) 3000 to 3999 | |
335 | bitmap.c 4000 to 4999 | |
336 | stree.c 5000 to 5999 | |
337 | prints.c 6000 to 6999 | |
338 | namei.c 7000 to 7999 | |
339 | fix_nodes.c 8000 to 8999 | |
340 | dir.c 9000 to 9999 | |
341 | lbalance.c 10000 to 10999 | |
342 | ibalance.c 11000 to 11999 not ready | |
343 | do_balan.c 12000 to 12999 | |
344 | inode.c 13000 to 13999 | |
345 | file.c 14000 to 14999 | |
346 | objectid.c 15000 - 15999 | |
347 | buffer.c 16000 - 16999 | |
348 | symlink.c 17000 - 17999 | |
349 | ||
350 | . */ | |
351 | ||
352 | ||
353 | #ifdef CONFIG_REISERFS_CHECK | |
354 | extern struct tree_balance * cur_tb; | |
355 | #endif | |
356 | ||
357 | void reiserfs_panic (struct super_block * sb, const char * fmt, ...) | |
358 | { | |
359 | do_reiserfs_warning(fmt); | |
360 | printk (KERN_EMERG "REISERFS: panic (device %s): %s\n", | |
361 | reiserfs_bdevname (sb), error_buf); | |
362 | BUG (); | |
363 | ||
364 | /* this is not actually called, but makes reiserfs_panic() "noreturn" */ | |
365 | panic ("REISERFS: panic (device %s): %s\n", | |
366 | reiserfs_bdevname (sb), error_buf); | |
367 | } | |
368 | ||
369 | void | |
370 | reiserfs_abort (struct super_block *sb, int errno, const char *fmt, ...) | |
371 | { | |
372 | do_reiserfs_warning (fmt); | |
373 | ||
374 | if (reiserfs_error_panic (sb)) { | |
375 | panic (KERN_CRIT "REISERFS: panic (device %s): %s\n", | |
376 | reiserfs_bdevname (sb), error_buf); | |
377 | } | |
378 | ||
379 | if (sb->s_flags & MS_RDONLY) | |
380 | return; | |
381 | ||
382 | printk (KERN_CRIT "REISERFS: abort (device %s): %s\n", | |
383 | reiserfs_bdevname (sb), error_buf); | |
384 | ||
385 | sb->s_flags |= MS_RDONLY; | |
386 | reiserfs_journal_abort (sb, errno); | |
387 | } | |
388 | ||
389 | /* this prints internal nodes (4 keys/items in line) (dc_number, | |
390 | dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number, | |
391 | dc_size)...*/ | |
392 | static int print_internal (struct buffer_head * bh, int first, int last) | |
393 | { | |
394 | struct reiserfs_key * key; | |
395 | struct disk_child * dc; | |
396 | int i; | |
397 | 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 | ||
426 | ||
427 | ||
428 | ||
429 | ||
430 | static int print_leaf (struct buffer_head * bh, int print_mode, int first, int last) | |
431 | { | |
432 | struct block_head * blkh; | |
433 | struct item_head * ih; | |
434 | int i, nr; | |
435 | int from, to; | |
436 | ||
437 | if (!B_IS_ITEMS_LEVEL (bh)) | |
438 | return 1; | |
439 | ||
440 | check_leaf (bh); | |
441 | ||
442 | blkh = B_BLK_HEAD (bh); | |
443 | ih = B_N_PITEM_HEAD (bh,0); | |
444 | nr = blkh_nr_item(blkh); | |
445 | ||
446 | printk ("\n===================================================================\n"); | |
447 | reiserfs_printk ("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh); | |
448 | ||
449 | if (!(print_mode & PRINT_LEAF_ITEMS)) { | |
450 | reiserfs_printk ("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n", | |
451 | &(ih->ih_key), &((ih + nr - 1)->ih_key)); | |
452 | return 0; | |
453 | } | |
454 | ||
455 | if (first < 0 || first > nr - 1) | |
456 | from = 0; | |
457 | else | |
458 | from = first; | |
459 | ||
460 | if (last < 0 || last > nr ) | |
461 | to = nr; | |
462 | else | |
463 | to = last; | |
464 | ||
465 | ih += from; | |
466 | printk ("-------------------------------------------------------------------------------\n"); | |
467 | printk ("|##| type | key | ilen | free_space | version | loc |\n"); | |
468 | for (i = from; i < to; i++, ih ++) { | |
469 | printk ("-------------------------------------------------------------------------------\n"); | |
470 | reiserfs_printk ("|%2d| %h |\n", i, ih); | |
471 | if (print_mode & PRINT_LEAF_ITEMS) | |
472 | op_print_item (ih, B_I_PITEM (bh, ih)); | |
473 | } | |
474 | ||
475 | printk ("===================================================================\n"); | |
476 | ||
477 | return 0; | |
478 | } | |
479 | ||
480 | char * reiserfs_hashname(int code) | |
481 | { | |
482 | if ( code == YURA_HASH) | |
483 | return "rupasov"; | |
484 | if ( code == TEA_HASH) | |
485 | return "tea"; | |
486 | if ( code == R5_HASH) | |
487 | return "r5"; | |
488 | ||
489 | return "unknown"; | |
490 | } | |
491 | ||
492 | /* return 1 if this is not super block */ | |
493 | static int print_super_block (struct buffer_head * bh) | |
494 | { | |
495 | struct reiserfs_super_block * rs = (struct reiserfs_super_block *)(bh->b_data); | |
496 | int skipped, data_blocks; | |
497 | char *version; | |
498 | char b[BDEVNAME_SIZE]; | |
499 | ||
500 | if (is_reiserfs_3_5(rs)) { | |
501 | version = "3.5"; | |
502 | } else if (is_reiserfs_3_6(rs)) { | |
503 | version = "3.6"; | |
504 | } else if (is_reiserfs_jr(rs)) { | |
505 | version = ((sb_version(rs) == REISERFS_VERSION_2) ? | |
506 | "3.6" : "3.5"); | |
507 | } else { | |
508 | return 1; | |
509 | } | |
510 | ||
511 | printk ("%s\'s super block is in block %llu\n", bdevname (bh->b_bdev, b), | |
512 | (unsigned long long)bh->b_blocknr); | |
513 | printk ("Reiserfs version %s\n", version ); | |
514 | printk ("Block count %u\n", sb_block_count(rs)); | |
515 | printk ("Blocksize %d\n", sb_blocksize(rs)); | |
516 | printk ("Free blocks %u\n", sb_free_blocks(rs)); | |
517 | // FIXME: this would be confusing if | |
518 | // someone stores reiserfs super block in some data block ;) | |
519 | // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs); | |
520 | skipped = bh->b_blocknr; | |
521 | 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)) - | |
523 | sb_free_blocks(rs); | |
524 | printk ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n" | |
525 | "1 super block, %d data blocks\n", | |
526 | skipped, sb_bmap_nr(rs), (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) : | |
527 | sb_reserved_for_journal(rs)) , data_blocks); | |
528 | printk ("Root block %u\n", sb_root_block(rs)); | |
529 | printk ("Journal block (first) %d\n", sb_jp_journal_1st_block(rs)); | |
530 | printk ("Journal dev %d\n", sb_jp_journal_dev(rs)); | |
531 | printk ("Journal orig size %d\n", sb_jp_journal_size(rs)); | |
532 | printk ("FS state %d\n", sb_fs_state(rs)); | |
533 | printk ("Hash function \"%s\"\n", | |
534 | reiserfs_hashname(sb_hash_function_code(rs))); | |
535 | ||
536 | printk ("Tree height %d\n", sb_tree_height(rs)); | |
537 | return 0; | |
538 | } | |
539 | ||
540 | static int print_desc_block (struct buffer_head * bh) | |
541 | { | |
542 | struct reiserfs_journal_desc * desc; | |
543 | ||
544 | if (memcmp(get_journal_desc_magic (bh), JOURNAL_DESC_MAGIC, 8)) | |
545 | return 1; | |
546 | ||
547 | desc = (struct reiserfs_journal_desc *)(bh->b_data); | |
548 | 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), | |
550 | get_desc_trans_len (desc)); | |
551 | ||
552 | return 0; | |
553 | } | |
554 | ||
555 | ||
556 | void print_block (struct buffer_head * bh, ...)//int print_mode, int first, int last) | |
557 | { | |
558 | va_list args; | |
559 | int mode, first, last; | |
560 | ||
561 | va_start (args, bh); | |
562 | ||
563 | if ( ! bh ) { | |
564 | printk("print_block: buffer is NULL\n"); | |
565 | return; | |
566 | } | |
567 | ||
568 | mode = va_arg (args, int); | |
569 | first = va_arg (args, int); | |
570 | last = va_arg (args, int); | |
571 | if (print_leaf (bh, mode, first, last)) | |
572 | if (print_internal (bh, first, last)) | |
573 | if (print_super_block (bh)) | |
574 | if (print_desc_block (bh)) | |
575 | printk ("Block %llu contains unformatted data\n", (unsigned long long)bh->b_blocknr); | |
576 | } | |
577 | ||
578 | ||
579 | ||
580 | static char print_tb_buf[2048]; | |
581 | ||
582 | /* this stores initial state of tree balance in the print_tb_buf */ | |
583 | void store_print_tb (struct tree_balance * tb) | |
584 | { | |
585 | int h = 0; | |
586 | int i; | |
587 | struct buffer_head * tbSh, * tbFh; | |
588 | ||
589 | if (!tb) | |
590 | return; | |
591 | ||
592 | sprintf (print_tb_buf, "\n" | |
593 | "BALANCING %d\n" | |
594 | "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n" | |
595 | "=====================================================================\n" | |
596 | "* h * S * L * R * F * FL * FR * CFL * CFR *\n", | |
597 | REISERFS_SB(tb->tb_sb)->s_do_balance, | |
598 | tb->tb_mode, PATH_LAST_POSITION (tb->tb_path), tb->tb_path->pos_in_item); | |
599 | ||
600 | for (h = 0; h < sizeof(tb->insert_size) / sizeof (tb->insert_size[0]); h ++) { | |
601 | if (PATH_H_PATH_OFFSET (tb->tb_path, h) <= tb->tb_path->path_length && | |
602 | PATH_H_PATH_OFFSET (tb->tb_path, h) > ILLEGAL_PATH_ELEMENT_OFFSET) { | |
603 | tbSh = PATH_H_PBUFFER (tb->tb_path, h); | |
604 | tbFh = PATH_H_PPARENT (tb->tb_path, h); | |
605 | } else { | |
606 | tbSh = NULL; | |
607 | tbFh = NULL; | |
608 | } | |
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 | ||
657 | void print_cur_tb (char * mes) | |
658 | { | |
659 | printk ("%s\n%s", mes, print_tb_buf); | |
660 | } | |
661 | ||
662 | static 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 | ||
677 | static void check_internal_block_head (struct buffer_head * bh) | |
678 | { | |
679 | struct block_head * blkh; | |
680 | ||
681 | blkh = B_BLK_HEAD (bh); | |
682 | if (!(B_LEVEL (bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL (bh) <= MAX_HEIGHT)) | |
683 | reiserfs_panic (NULL, "vs-6025: check_internal_block_head: invalid level %z", bh); | |
684 | ||
685 | if (B_NR_ITEMS (bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE) | |
686 | reiserfs_panic (NULL, "vs-6030: check_internal_block_head: invalid item number %z", bh); | |
687 | ||
688 | if (B_FREE_SPACE (bh) != | |
689 | bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS (bh) - DC_SIZE * (B_NR_ITEMS (bh) + 1)) | |
690 | reiserfs_panic (NULL, "vs-6040: check_internal_block_head: invalid free space %z", bh); | |
691 | ||
692 | } | |
693 | ||
694 | ||
695 | void check_leaf (struct buffer_head * bh) | |
696 | { | |
697 | int i; | |
698 | struct item_head * ih; | |
699 | ||
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 | } | |
706 | ||
707 | ||
708 | void check_internal (struct buffer_head * bh) | |
709 | { | |
710 | if (!bh) | |
711 | return; | |
712 | check_internal_block_head (bh); | |
713 | } | |
714 | ||
715 | ||
716 | void print_statistics (struct super_block * s) | |
717 | { | |
718 | ||
719 | /* | |
720 | printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \ | |
721 | bmap with search %d, without %d, dir2ind %d, ind2dir %d\n", | |
722 | 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, | |
724 | REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct); | |
725 | */ | |
726 | ||
727 | } |