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 "reiserfs.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 
reiserfs_cpu_offset(struct cpu_key * key)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 
le_offset(struct reiserfs_key * key)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 
cpu_type(struct cpu_key * key)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 
le_type(struct reiserfs_key * key)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 */
sprintf_le_key(char * buf,struct reiserfs_key * key)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 */
sprintf_cpu_key(char * buf,struct cpu_key * key)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 
sprintf_de_head(char * buf,struct reiserfs_de_head * deh)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 
sprintf_item_head(char * buf,struct item_head * ih)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 
sprintf_direntry(char * buf,struct reiserfs_dir_entry * de)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 
sprintf_block_head(char * buf,struct buffer_head * bh)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 
sprintf_buffer_head(char * buf,struct buffer_head * bh)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 
sprintf_disk_child(char * buf,struct disk_child * dc)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 
is_there_reiserfs_struct(char * fmt,int * what)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);
prepare_error_buf(const char * fmt,va_list args)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 
__reiserfs_warning(struct super_block * sb,const char * id,const char * function,const char * fmt,...)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 */
reiserfs_info(struct super_block * sb,const char * fmt,...)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 */
reiserfs_printk(const char * fmt,...)289 static void reiserfs_printk(const char *fmt, ...)
290 {
291 	do_reiserfs_warning(fmt);
292 	printk(error_buf);
293 }
294 
reiserfs_debug(struct super_block * s,int level,const char * fmt,...)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.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 
__reiserfs_panic(struct super_block * sb,const char * id,const char * function,const char * fmt,...)352 void __reiserfs_panic(struct super_block *sb, const char *id,
353 		      const char *function, const char *fmt, ...)
354 {
355 	do_reiserfs_warning(fmt);
356 
357 #ifdef CONFIG_REISERFS_CHECK
358 	dump_stack();
359 #endif
360 	if (sb)
361 		panic(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
362 		      sb->s_id, id ? id : "", id ? " " : "",
363 		      function, error_buf);
364 	else
365 		panic(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
366 		      id ? id : "", id ? " " : "", function, error_buf);
367 }
368 
__reiserfs_error(struct super_block * sb,const char * id,const char * function,const char * fmt,...)369 void __reiserfs_error(struct super_block *sb, const char *id,
370 		      const char *function, const char *fmt, ...)
371 {
372 	do_reiserfs_warning(fmt);
373 
374 	BUG_ON(sb == NULL);
375 
376 	if (reiserfs_error_panic(sb))
377 		__reiserfs_panic(sb, id, function, error_buf);
378 
379 	if (id && id[0])
380 		printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
381 		       sb->s_id, id, function, error_buf);
382 	else
383 		printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
384 		       sb->s_id, function, error_buf);
385 
386 	if (sb->s_flags & MS_RDONLY)
387 		return;
388 
389 	reiserfs_info(sb, "Remounting filesystem read-only\n");
390 	sb->s_flags |= MS_RDONLY;
391 	reiserfs_abort_journal(sb, -EIO);
392 }
393 
reiserfs_abort(struct super_block * sb,int errno,const char * fmt,...)394 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
395 {
396 	do_reiserfs_warning(fmt);
397 
398 	if (reiserfs_error_panic(sb)) {
399 		panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
400 		      error_buf);
401 	}
402 
403 	if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
404 		return;
405 
406 	printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
407 	       error_buf);
408 
409 	sb->s_flags |= MS_RDONLY;
410 	reiserfs_abort_journal(sb, errno);
411 }
412 
413 /* this prints internal nodes (4 keys/items in line) (dc_number,
414    dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
415    dc_size)...*/
print_internal(struct buffer_head * bh,int first,int last)416 static int print_internal(struct buffer_head *bh, int first, int last)
417 {
418 	struct reiserfs_key *key;
419 	struct disk_child *dc;
420 	int i;
421 	int from, to;
422 
423 	if (!B_IS_KEYS_LEVEL(bh))
424 		return 1;
425 
426 	check_internal(bh);
427 
428 	if (first == -1) {
429 		from = 0;
430 		to = B_NR_ITEMS(bh);
431 	} else {
432 		from = first;
433 		to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
434 	}
435 
436 	reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
437 
438 	dc = B_N_CHILD(bh, from);
439 	reiserfs_printk("PTR %d: %y ", from, dc);
440 
441 	for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
442 	     i++, key++, dc++) {
443 		reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
444 		if (i && i % 4 == 0)
445 			printk("\n");
446 	}
447 	printk("\n");
448 	return 0;
449 }
450 
print_leaf(struct buffer_head * bh,int print_mode,int first,int last)451 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
452 		      int last)
453 {
454 	struct block_head *blkh;
455 	struct item_head *ih;
456 	int i, nr;
457 	int from, to;
458 
459 	if (!B_IS_ITEMS_LEVEL(bh))
460 		return 1;
461 
462 	check_leaf(bh);
463 
464 	blkh = B_BLK_HEAD(bh);
465 	ih = B_N_PITEM_HEAD(bh, 0);
466 	nr = blkh_nr_item(blkh);
467 
468 	printk
469 	    ("\n===================================================================\n");
470 	reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
471 
472 	if (!(print_mode & PRINT_LEAF_ITEMS)) {
473 		reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
474 				&(ih->ih_key), &((ih + nr - 1)->ih_key));
475 		return 0;
476 	}
477 
478 	if (first < 0 || first > nr - 1)
479 		from = 0;
480 	else
481 		from = first;
482 
483 	if (last < 0 || last > nr)
484 		to = nr;
485 	else
486 		to = last;
487 
488 	ih += from;
489 	printk
490 	    ("-------------------------------------------------------------------------------\n");
491 	printk
492 	    ("|##|   type    |           key           | ilen | free_space | version | loc  |\n");
493 	for (i = from; i < to; i++, ih++) {
494 		printk
495 		    ("-------------------------------------------------------------------------------\n");
496 		reiserfs_printk("|%2d| %h |\n", i, ih);
497 		if (print_mode & PRINT_LEAF_ITEMS)
498 			op_print_item(ih, B_I_PITEM(bh, ih));
499 	}
500 
501 	printk
502 	    ("===================================================================\n");
503 
504 	return 0;
505 }
506 
reiserfs_hashname(int code)507 char *reiserfs_hashname(int code)
508 {
509 	if (code == YURA_HASH)
510 		return "rupasov";
511 	if (code == TEA_HASH)
512 		return "tea";
513 	if (code == R5_HASH)
514 		return "r5";
515 
516 	return "unknown";
517 }
518 
519 /* return 1 if this is not super block */
print_super_block(struct buffer_head * bh)520 static int print_super_block(struct buffer_head *bh)
521 {
522 	struct reiserfs_super_block *rs =
523 	    (struct reiserfs_super_block *)(bh->b_data);
524 	int skipped, data_blocks;
525 	char *version;
526 	char b[BDEVNAME_SIZE];
527 
528 	if (is_reiserfs_3_5(rs)) {
529 		version = "3.5";
530 	} else if (is_reiserfs_3_6(rs)) {
531 		version = "3.6";
532 	} else if (is_reiserfs_jr(rs)) {
533 		version = ((sb_version(rs) == REISERFS_VERSION_2) ?
534 			   "3.6" : "3.5");
535 	} else {
536 		return 1;
537 	}
538 
539 	printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
540 	       (unsigned long long)bh->b_blocknr);
541 	printk("Reiserfs version %s\n", version);
542 	printk("Block count %u\n", sb_block_count(rs));
543 	printk("Blocksize %d\n", sb_blocksize(rs));
544 	printk("Free blocks %u\n", sb_free_blocks(rs));
545 	// FIXME: this would be confusing if
546 	// someone stores reiserfs super block in some data block ;)
547 //    skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
548 	skipped = bh->b_blocknr;
549 	data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
550 	    (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
551 	     1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
552 	printk
553 	    ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
554 	     "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
555 	     (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
556 	      sb_reserved_for_journal(rs)), data_blocks);
557 	printk("Root block %u\n", sb_root_block(rs));
558 	printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
559 	printk("Journal dev %d\n", sb_jp_journal_dev(rs));
560 	printk("Journal orig size %d\n", sb_jp_journal_size(rs));
561 	printk("FS state %d\n", sb_fs_state(rs));
562 	printk("Hash function \"%s\"\n",
563 	       reiserfs_hashname(sb_hash_function_code(rs)));
564 
565 	printk("Tree height %d\n", sb_tree_height(rs));
566 	return 0;
567 }
568 
print_desc_block(struct buffer_head * bh)569 static int print_desc_block(struct buffer_head *bh)
570 {
571 	struct reiserfs_journal_desc *desc;
572 
573 	if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
574 		return 1;
575 
576 	desc = (struct reiserfs_journal_desc *)(bh->b_data);
577 	printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
578 	       (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
579 	       get_desc_mount_id(desc), get_desc_trans_len(desc));
580 
581 	return 0;
582 }
583 
print_block(struct buffer_head * bh,...)584 void print_block(struct buffer_head *bh, ...)	//int print_mode, int first, int last)
585 {
586 	va_list args;
587 	int mode, first, last;
588 
589 	if (!bh) {
590 		printk("print_block: buffer is NULL\n");
591 		return;
592 	}
593 
594 	va_start(args, bh);
595 
596 	mode = va_arg(args, int);
597 	first = va_arg(args, int);
598 	last = va_arg(args, int);
599 	if (print_leaf(bh, mode, first, last))
600 		if (print_internal(bh, first, last))
601 			if (print_super_block(bh))
602 				if (print_desc_block(bh))
603 					printk
604 					    ("Block %llu contains unformatted data\n",
605 					     (unsigned long long)bh->b_blocknr);
606 
607 	va_end(args);
608 }
609 
610 static char print_tb_buf[2048];
611 
612 /* this stores initial state of tree balance in the print_tb_buf */
store_print_tb(struct tree_balance * tb)613 void store_print_tb(struct tree_balance *tb)
614 {
615 	int h = 0;
616 	int i;
617 	struct buffer_head *tbSh, *tbFh;
618 
619 	if (!tb)
620 		return;
621 
622 	sprintf(print_tb_buf, "\n"
623 		"BALANCING %d\n"
624 		"MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
625 		"=====================================================================\n"
626 		"* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n",
627 		REISERFS_SB(tb->tb_sb)->s_do_balance,
628 		tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
629 		tb->tb_path->pos_in_item);
630 
631 	for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
632 		if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
633 		    tb->tb_path->path_length
634 		    && PATH_H_PATH_OFFSET(tb->tb_path,
635 					  h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
636 			tbSh = PATH_H_PBUFFER(tb->tb_path, h);
637 			tbFh = PATH_H_PPARENT(tb->tb_path, h);
638 		} else {
639 			tbSh = NULL;
640 			tbFh = NULL;
641 		}
642 		sprintf(print_tb_buf + strlen(print_tb_buf),
643 			"* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
644 			h,
645 			(tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
646 			(tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
647 			(tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
648 			(tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
649 			(tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
650 			(tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
651 			(tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
652 			(tb->FL[h]) ? (long long)(tb->FL[h]->
653 						  b_blocknr) : (-1LL),
654 			(tb->FR[h]) ? (long long)(tb->FR[h]->
655 						  b_blocknr) : (-1LL),
656 			(tb->CFL[h]) ? (long long)(tb->CFL[h]->
657 						   b_blocknr) : (-1LL),
658 			(tb->CFR[h]) ? (long long)(tb->CFR[h]->
659 						   b_blocknr) : (-1LL));
660 	}
661 
662 	sprintf(print_tb_buf + strlen(print_tb_buf),
663 		"=====================================================================\n"
664 		"* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
665 		"* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
666 		tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
667 		tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
668 		tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
669 		tb->rkey[0]);
670 
671 	/* this prints balance parameters for non-leaf levels */
672 	h = 0;
673 	do {
674 		h++;
675 		sprintf(print_tb_buf + strlen(print_tb_buf),
676 			"* %d * %4d * %2d *    * %2d *    * %2d *\n",
677 			h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
678 			tb->blknum[h]);
679 	} while (tb->insert_size[h]);
680 
681 	sprintf(print_tb_buf + strlen(print_tb_buf),
682 		"=====================================================================\n"
683 		"FEB list: ");
684 
685 	/* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
686 	h = 0;
687 	for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
688 		sprintf(print_tb_buf + strlen(print_tb_buf),
689 			"%p (%llu %d)%s", tb->FEB[i],
690 			tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
691 			b_blocknr : 0ULL,
692 			tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
693 			(i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
694 
695 	sprintf(print_tb_buf + strlen(print_tb_buf),
696 		"======================== the end ====================================\n");
697 }
698 
print_cur_tb(char * mes)699 void print_cur_tb(char *mes)
700 {
701 	printk("%s\n%s", mes, print_tb_buf);
702 }
703 
check_leaf_block_head(struct buffer_head * bh)704 static void check_leaf_block_head(struct buffer_head *bh)
705 {
706 	struct block_head *blkh;
707 	int nr;
708 
709 	blkh = B_BLK_HEAD(bh);
710 	nr = blkh_nr_item(blkh);
711 	if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
712 		reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
713 			       bh);
714 	if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
715 		reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
716 			       bh);
717 
718 }
719 
check_internal_block_head(struct buffer_head * bh)720 static void check_internal_block_head(struct buffer_head *bh)
721 {
722 	struct block_head *blkh;
723 
724 	blkh = B_BLK_HEAD(bh);
725 	if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
726 		reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
727 
728 	if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
729 		reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
730 
731 	if (B_FREE_SPACE(bh) !=
732 	    bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
733 	    DC_SIZE * (B_NR_ITEMS(bh) + 1))
734 		reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
735 
736 }
737 
check_leaf(struct buffer_head * bh)738 void check_leaf(struct buffer_head *bh)
739 {
740 	int i;
741 	struct item_head *ih;
742 
743 	if (!bh)
744 		return;
745 	check_leaf_block_head(bh);
746 	for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
747 		op_check_item(ih, B_I_PITEM(bh, ih));
748 }
749 
check_internal(struct buffer_head * bh)750 void check_internal(struct buffer_head *bh)
751 {
752 	if (!bh)
753 		return;
754 	check_internal_block_head(bh);
755 }
756 
print_statistics(struct super_block * s)757 void print_statistics(struct super_block *s)
758 {
759 
760 	/*
761 	   printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
762 	   bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
763 	   REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
764 	   REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
765 	   REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
766 	 */
767 
768 }
769