xref: /openbmc/linux/fs/reiserfs/prints.c (revision fd589a8f)
1 /*
2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3  */
4 
5 #include <linux/time.h>
6 #include <linux/fs.h>
7 #include <linux/reiserfs_fs.h>
8 #include <linux/string.h>
9 #include <linux/buffer_head.h>
10 
11 #include <stdarg.h>
12 
13 static char error_buf[1024];
14 static char fmt_buf[1024];
15 static char off_buf[80];
16 
17 static char *reiserfs_cpu_offset(struct cpu_key *key)
18 {
19 	if (cpu_key_k_type(key) == TYPE_DIRENTRY)
20 		sprintf(off_buf, "%Lu(%Lu)",
21 			(unsigned long long)
22 			GET_HASH_VALUE(cpu_key_k_offset(key)),
23 			(unsigned long long)
24 			GET_GENERATION_NUMBER(cpu_key_k_offset(key)));
25 	else
26 		sprintf(off_buf, "0x%Lx",
27 			(unsigned long long)cpu_key_k_offset(key));
28 	return off_buf;
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)
39 			GET_HASH_VALUE(le_key_k_offset(version, key)),
40 			(unsigned long long)
41 			GET_GENERATION_NUMBER(le_key_k_offset(version, key)));
42 	else
43 		sprintf(off_buf, "0x%Lx",
44 			(unsigned long long)le_key_k_offset(version, key));
45 	return off_buf;
46 }
47 
48 static char *cpu_type(struct cpu_key *key)
49 {
50 	if (cpu_key_k_type(key) == TYPE_STAT_DATA)
51 		return "SD";
52 	if (cpu_key_k_type(key) == TYPE_DIRENTRY)
53 		return "DIR";
54 	if (cpu_key_k_type(key) == TYPE_DIRECT)
55 		return "DIRECT";
56 	if (cpu_key_k_type(key) == TYPE_INDIRECT)
57 		return "IND";
58 	return "UNKNOWN";
59 }
60 
61 static char *le_type(struct reiserfs_key *key)
62 {
63 	int version;
64 
65 	version = le_key_version(key);
66 
67 	if (le_key_k_type(version, key) == TYPE_STAT_DATA)
68 		return "SD";
69 	if (le_key_k_type(version, key) == TYPE_DIRENTRY)
70 		return "DIR";
71 	if (le_key_k_type(version, key) == TYPE_DIRECT)
72 		return "DIRECT";
73 	if (le_key_k_type(version, key) == TYPE_INDIRECT)
74 		return "IND";
75 	return "UNKNOWN";
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),
84 			le_type(key));
85 	else
86 		sprintf(buf, "[NULL]");
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,
104 			"[offset=%d dir_id=%d objectid=%d location=%d state=%04x]",
105 			deh_offset(deh), deh_dir_id(deh), deh_objectid(deh),
106 			deh_location(deh), deh_state(deh));
107 	else
108 		sprintf(buf, "[NULL]");
109 
110 }
111 
112 static void sprintf_item_head(char *buf, struct item_head *ih)
113 {
114 	if (ih) {
115 		strcpy(buf,
116 		       (ih_version(ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*");
117 		sprintf_le_key(buf + strlen(buf), &(ih->ih_key));
118 		sprintf(buf + strlen(buf), ", item_len %d, item_location %d, "
119 			"free_space(entry_count) %d",
120 			ih_item_len(ih), ih_location(ih), ih_free_space(ih));
121 	} else
122 		sprintf(buf, "[NULL]");
123 }
124 
125 static void sprintf_direntry(char *buf, struct reiserfs_dir_entry *de)
126 {
127 	char name[20];
128 
129 	memcpy(name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen);
130 	name[de->de_namelen > 19 ? 19 : de->de_namelen] = 0;
131 	sprintf(buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid);
132 }
133 
134 static void sprintf_block_head(char *buf, struct buffer_head *bh)
135 {
136 	sprintf(buf, "level=%d, nr_items=%d, free_space=%d rdkey ",
137 		B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh));
138 }
139 
140 static void sprintf_buffer_head(char *buf, struct buffer_head *bh)
141 {
142 	char b[BDEVNAME_SIZE];
143 
144 	sprintf(buf,
145 		"dev %s, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
146 		bdevname(bh->b_bdev, b), bh->b_size,
147 		(unsigned long long)bh->b_blocknr, 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 static void sprintf_disk_child(char *buf, struct disk_child *dc)
155 {
156 	sprintf(buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc),
157 		dc_size(dc));
158 }
159 
160 static char *is_there_reiserfs_struct(char *fmt, int *what)
161 {
162 	char *k = fmt;
163 
164 	while ((k = strchr(k, '%')) != NULL) {
165 		if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
166 		    k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
167 			*what = k[1];
168 			break;
169 		}
170 		k++;
171 	}
172 	return k;
173 }
174 
175 /* debugging reiserfs we used to print out a lot of different
176    variables, like keys, item headers, buffer heads etc. Values of
177    most fields matter. So it took a long time just to write
178    appropriative printk. With this reiserfs_warning you can use format
179    specification for complex structures like you used to do with
180    printfs for integers, doubles and pointers. For instance, to print
181    out key structure you have to write just:
182    reiserfs_warning ("bad key %k", key);
183    instead of
184    printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
185            key->k_offset, key->k_uniqueness);
186 */
187 static DEFINE_SPINLOCK(error_lock);
188 static void prepare_error_buf(const char *fmt, va_list args)
189 {
190 	char *fmt1 = fmt_buf;
191 	char *k;
192 	char *p = error_buf;
193 	int what;
194 
195 	spin_lock(&error_lock);
196 
197 	strcpy(fmt1, fmt);
198 
199 	while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
200 		*k = 0;
201 
202 		p += vsprintf(p, fmt1, args);
203 
204 		switch (what) {
205 		case 'k':
206 			sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
207 			break;
208 		case 'K':
209 			sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
210 			break;
211 		case 'h':
212 			sprintf_item_head(p, va_arg(args, struct item_head *));
213 			break;
214 		case 't':
215 			sprintf_direntry(p,
216 					 va_arg(args,
217 						struct reiserfs_dir_entry *));
218 			break;
219 		case 'y':
220 			sprintf_disk_child(p,
221 					   va_arg(args, struct disk_child *));
222 			break;
223 		case 'z':
224 			sprintf_block_head(p,
225 					   va_arg(args, struct buffer_head *));
226 			break;
227 		case 'b':
228 			sprintf_buffer_head(p,
229 					    va_arg(args, struct buffer_head *));
230 			break;
231 		case 'a':
232 			sprintf_de_head(p,
233 					va_arg(args,
234 					       struct reiserfs_de_head *));
235 			break;
236 		}
237 
238 		p += strlen(p);
239 		fmt1 = k + 2;
240 	}
241 	vsprintf(p, fmt1, args);
242 	spin_unlock(&error_lock);
243 
244 }
245 
246 /* in addition to usual conversion specifiers this accepts reiserfs
247    specific conversion specifiers:
248    %k to print little endian key,
249    %K to print cpu key,
250    %h to print item_head,
251    %t to print directory entry
252    %z to print block head (arg must be struct buffer_head *
253    %b to print buffer_head
254 */
255 
256 #define do_reiserfs_warning(fmt)\
257 {\
258     va_list args;\
259     va_start( args, fmt );\
260     prepare_error_buf( fmt, args );\
261     va_end( args );\
262 }
263 
264 void __reiserfs_warning(struct super_block *sb, const char *id,
265 			 const char *function, const char *fmt, ...)
266 {
267 	do_reiserfs_warning(fmt);
268 	if (sb)
269 		printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
270 		       "%s\n", sb->s_id, id ? id : "", id ? " " : "",
271 		       function, error_buf);
272 	else
273 		printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
274 		       id ? id : "", id ? " " : "", function, 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 (device %s): %s",
283 		       sb->s_id, 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 debug (device %s): %s\n",
301 		       s->s_id, error_buf);
302 	else
303 		printk(KERN_DEBUG "REISERFS debug: %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 #ifdef CONFIG_REISERFS_CHECK
353 extern struct tree_balance *cur_tb;
354 #endif
355 
356 void __reiserfs_panic(struct super_block *sb, const char *id,
357 		      const char *function, const char *fmt, ...)
358 {
359 	do_reiserfs_warning(fmt);
360 
361 #ifdef CONFIG_REISERFS_CHECK
362 	dump_stack();
363 #endif
364 	if (sb)
365 		panic(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
366 		      sb->s_id, id ? id : "", id ? " " : "",
367 		      function, error_buf);
368 	else
369 		panic(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
370 		      id ? id : "", id ? " " : "", function, error_buf);
371 }
372 
373 void __reiserfs_error(struct super_block *sb, const char *id,
374 		      const char *function, const char *fmt, ...)
375 {
376 	do_reiserfs_warning(fmt);
377 
378 	BUG_ON(sb == NULL);
379 
380 	if (reiserfs_error_panic(sb))
381 		__reiserfs_panic(sb, id, function, error_buf);
382 
383 	if (id && id[0])
384 		printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
385 		       sb->s_id, id, function, error_buf);
386 	else
387 		printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
388 		       sb->s_id, function, error_buf);
389 
390 	if (sb->s_flags & MS_RDONLY)
391 		return;
392 
393 	reiserfs_info(sb, "Remounting filesystem read-only\n");
394 	sb->s_flags |= MS_RDONLY;
395 	reiserfs_abort_journal(sb, -EIO);
396 }
397 
398 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
399 {
400 	do_reiserfs_warning(fmt);
401 
402 	if (reiserfs_error_panic(sb)) {
403 		panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
404 		      error_buf);
405 	}
406 
407 	if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
408 		return;
409 
410 	printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
411 	       error_buf);
412 
413 	sb->s_flags |= MS_RDONLY;
414 	reiserfs_abort_journal(sb, errno);
415 }
416 
417 /* this prints internal nodes (4 keys/items in line) (dc_number,
418    dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
419    dc_size)...*/
420 static int print_internal(struct buffer_head *bh, int first, int last)
421 {
422 	struct reiserfs_key *key;
423 	struct disk_child *dc;
424 	int i;
425 	int from, to;
426 
427 	if (!B_IS_KEYS_LEVEL(bh))
428 		return 1;
429 
430 	check_internal(bh);
431 
432 	if (first == -1) {
433 		from = 0;
434 		to = B_NR_ITEMS(bh);
435 	} else {
436 		from = first;
437 		to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
438 	}
439 
440 	reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
441 
442 	dc = B_N_CHILD(bh, from);
443 	reiserfs_printk("PTR %d: %y ", from, dc);
444 
445 	for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
446 	     i++, key++, dc++) {
447 		reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
448 		if (i && i % 4 == 0)
449 			printk("\n");
450 	}
451 	printk("\n");
452 	return 0;
453 }
454 
455 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
456 		      int last)
457 {
458 	struct block_head *blkh;
459 	struct item_head *ih;
460 	int i, nr;
461 	int from, to;
462 
463 	if (!B_IS_ITEMS_LEVEL(bh))
464 		return 1;
465 
466 	check_leaf(bh);
467 
468 	blkh = B_BLK_HEAD(bh);
469 	ih = B_N_PITEM_HEAD(bh, 0);
470 	nr = blkh_nr_item(blkh);
471 
472 	printk
473 	    ("\n===================================================================\n");
474 	reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
475 
476 	if (!(print_mode & PRINT_LEAF_ITEMS)) {
477 		reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
478 				&(ih->ih_key), &((ih + nr - 1)->ih_key));
479 		return 0;
480 	}
481 
482 	if (first < 0 || first > nr - 1)
483 		from = 0;
484 	else
485 		from = first;
486 
487 	if (last < 0 || last > nr)
488 		to = nr;
489 	else
490 		to = last;
491 
492 	ih += from;
493 	printk
494 	    ("-------------------------------------------------------------------------------\n");
495 	printk
496 	    ("|##|   type    |           key           | ilen | free_space | version | loc  |\n");
497 	for (i = from; i < to; i++, ih++) {
498 		printk
499 		    ("-------------------------------------------------------------------------------\n");
500 		reiserfs_printk("|%2d| %h |\n", i, ih);
501 		if (print_mode & PRINT_LEAF_ITEMS)
502 			op_print_item(ih, B_I_PITEM(bh, ih));
503 	}
504 
505 	printk
506 	    ("===================================================================\n");
507 
508 	return 0;
509 }
510 
511 char *reiserfs_hashname(int code)
512 {
513 	if (code == YURA_HASH)
514 		return "rupasov";
515 	if (code == TEA_HASH)
516 		return "tea";
517 	if (code == R5_HASH)
518 		return "r5";
519 
520 	return "unknown";
521 }
522 
523 /* return 1 if this is not super block */
524 static int print_super_block(struct buffer_head *bh)
525 {
526 	struct reiserfs_super_block *rs =
527 	    (struct reiserfs_super_block *)(bh->b_data);
528 	int skipped, data_blocks;
529 	char *version;
530 	char b[BDEVNAME_SIZE];
531 
532 	if (is_reiserfs_3_5(rs)) {
533 		version = "3.5";
534 	} else if (is_reiserfs_3_6(rs)) {
535 		version = "3.6";
536 	} else if (is_reiserfs_jr(rs)) {
537 		version = ((sb_version(rs) == REISERFS_VERSION_2) ?
538 			   "3.6" : "3.5");
539 	} else {
540 		return 1;
541 	}
542 
543 	printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
544 	       (unsigned long long)bh->b_blocknr);
545 	printk("Reiserfs version %s\n", version);
546 	printk("Block count %u\n", sb_block_count(rs));
547 	printk("Blocksize %d\n", sb_blocksize(rs));
548 	printk("Free blocks %u\n", sb_free_blocks(rs));
549 	// FIXME: this would be confusing if
550 	// someone stores reiserfs super block in some data block ;)
551 //    skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
552 	skipped = bh->b_blocknr;
553 	data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
554 	    (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
555 	     1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
556 	printk
557 	    ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
558 	     "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
559 	     (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
560 	      sb_reserved_for_journal(rs)), data_blocks);
561 	printk("Root block %u\n", sb_root_block(rs));
562 	printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
563 	printk("Journal dev %d\n", sb_jp_journal_dev(rs));
564 	printk("Journal orig size %d\n", sb_jp_journal_size(rs));
565 	printk("FS state %d\n", sb_fs_state(rs));
566 	printk("Hash function \"%s\"\n",
567 	       reiserfs_hashname(sb_hash_function_code(rs)));
568 
569 	printk("Tree height %d\n", sb_tree_height(rs));
570 	return 0;
571 }
572 
573 static int print_desc_block(struct buffer_head *bh)
574 {
575 	struct reiserfs_journal_desc *desc;
576 
577 	if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
578 		return 1;
579 
580 	desc = (struct reiserfs_journal_desc *)(bh->b_data);
581 	printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
582 	       (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
583 	       get_desc_mount_id(desc), get_desc_trans_len(desc));
584 
585 	return 0;
586 }
587 
588 void print_block(struct buffer_head *bh, ...)	//int print_mode, int first, int last)
589 {
590 	va_list args;
591 	int mode, first, last;
592 
593 	va_start(args, bh);
594 
595 	if (!bh) {
596 		printk("print_block: buffer is NULL\n");
597 		return;
598 	}
599 
600 	mode = va_arg(args, int);
601 	first = va_arg(args, int);
602 	last = va_arg(args, int);
603 	if (print_leaf(bh, mode, first, last))
604 		if (print_internal(bh, first, last))
605 			if (print_super_block(bh))
606 				if (print_desc_block(bh))
607 					printk
608 					    ("Block %llu contains unformatted data\n",
609 					     (unsigned long long)bh->b_blocknr);
610 
611 	va_end(args);
612 }
613 
614 static char print_tb_buf[2048];
615 
616 /* this stores initial state of tree balance in the print_tb_buf */
617 void store_print_tb(struct tree_balance *tb)
618 {
619 	int h = 0;
620 	int i;
621 	struct buffer_head *tbSh, *tbFh;
622 
623 	if (!tb)
624 		return;
625 
626 	sprintf(print_tb_buf, "\n"
627 		"BALANCING %d\n"
628 		"MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
629 		"=====================================================================\n"
630 		"* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n",
631 		REISERFS_SB(tb->tb_sb)->s_do_balance,
632 		tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
633 		tb->tb_path->pos_in_item);
634 
635 	for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
636 		if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
637 		    tb->tb_path->path_length
638 		    && PATH_H_PATH_OFFSET(tb->tb_path,
639 					  h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
640 			tbSh = PATH_H_PBUFFER(tb->tb_path, h);
641 			tbFh = PATH_H_PPARENT(tb->tb_path, h);
642 		} else {
643 			tbSh = NULL;
644 			tbFh = NULL;
645 		}
646 		sprintf(print_tb_buf + strlen(print_tb_buf),
647 			"* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
648 			h,
649 			(tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
650 			(tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
651 			(tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
652 			(tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
653 			(tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
654 			(tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
655 			(tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
656 			(tb->FL[h]) ? (long long)(tb->FL[h]->
657 						  b_blocknr) : (-1LL),
658 			(tb->FR[h]) ? (long long)(tb->FR[h]->
659 						  b_blocknr) : (-1LL),
660 			(tb->CFL[h]) ? (long long)(tb->CFL[h]->
661 						   b_blocknr) : (-1LL),
662 			(tb->CFR[h]) ? (long long)(tb->CFR[h]->
663 						   b_blocknr) : (-1LL));
664 	}
665 
666 	sprintf(print_tb_buf + strlen(print_tb_buf),
667 		"=====================================================================\n"
668 		"* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
669 		"* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
670 		tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
671 		tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
672 		tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
673 		tb->rkey[0]);
674 
675 	/* this prints balance parameters for non-leaf levels */
676 	h = 0;
677 	do {
678 		h++;
679 		sprintf(print_tb_buf + strlen(print_tb_buf),
680 			"* %d * %4d * %2d *    * %2d *    * %2d *\n",
681 			h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
682 			tb->blknum[h]);
683 	} while (tb->insert_size[h]);
684 
685 	sprintf(print_tb_buf + strlen(print_tb_buf),
686 		"=====================================================================\n"
687 		"FEB list: ");
688 
689 	/* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
690 	h = 0;
691 	for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
692 		sprintf(print_tb_buf + strlen(print_tb_buf),
693 			"%p (%llu %d)%s", tb->FEB[i],
694 			tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
695 			b_blocknr : 0ULL,
696 			tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
697 			(i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
698 
699 	sprintf(print_tb_buf + strlen(print_tb_buf),
700 		"======================== the end ====================================\n");
701 }
702 
703 void print_cur_tb(char *mes)
704 {
705 	printk("%s\n%s", mes, print_tb_buf);
706 }
707 
708 static void check_leaf_block_head(struct buffer_head *bh)
709 {
710 	struct block_head *blkh;
711 	int nr;
712 
713 	blkh = B_BLK_HEAD(bh);
714 	nr = blkh_nr_item(blkh);
715 	if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
716 		reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
717 			       bh);
718 	if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
719 		reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
720 			       bh);
721 
722 }
723 
724 static void check_internal_block_head(struct buffer_head *bh)
725 {
726 	struct block_head *blkh;
727 
728 	blkh = B_BLK_HEAD(bh);
729 	if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
730 		reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
731 
732 	if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
733 		reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
734 
735 	if (B_FREE_SPACE(bh) !=
736 	    bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
737 	    DC_SIZE * (B_NR_ITEMS(bh) + 1))
738 		reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
739 
740 }
741 
742 void check_leaf(struct buffer_head *bh)
743 {
744 	int i;
745 	struct item_head *ih;
746 
747 	if (!bh)
748 		return;
749 	check_leaf_block_head(bh);
750 	for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
751 		op_check_item(ih, B_I_PITEM(bh, ih));
752 }
753 
754 void check_internal(struct buffer_head *bh)
755 {
756 	if (!bh)
757 		return;
758 	check_internal_block_head(bh);
759 }
760 
761 void print_statistics(struct super_block *s)
762 {
763 
764 	/*
765 	   printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
766 	   bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
767 	   REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
768 	   REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
769 	   REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
770 	 */
771 
772 }
773