Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[linux-2.6] / fs / reiserfs / prints.c
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, int *skip)
161 {
162         char *k = fmt;
163
164         *skip = 0;
165
166         while ((k = strchr(k, '%')) != NULL) {
167                 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
168                     k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
169                         *what = k[1];
170                         break;
171                 }
172                 (*skip)++;
173                 k++;
174         }
175         return k;
176 }
177
178 /* debugging reiserfs we used to print out a lot of different
179    variables, like keys, item headers, buffer heads etc. Values of
180    most fields matter. So it took a long time just to write
181    appropriative printk. With this reiserfs_warning you can use format
182    specification for complex structures like you used to do with
183    printfs for integers, doubles and pointers. For instance, to print
184    out key structure you have to write just: 
185    reiserfs_warning ("bad key %k", key); 
186    instead of 
187    printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid, 
188            key->k_offset, key->k_uniqueness); 
189 */
190
191 static void prepare_error_buf(const char *fmt, va_list args)
192 {
193         char *fmt1 = fmt_buf;
194         char *k;
195         char *p = error_buf;
196         int i, j, what, skip;
197
198         strcpy(fmt1, fmt);
199
200         while ((k = is_there_reiserfs_struct(fmt1, &what, &skip)) != NULL) {
201                 *k = 0;
202
203                 p += vsprintf(p, fmt1, args);
204
205                 for (i = 0; i < skip; i++)
206                         j = va_arg(args, int);
207
208                 switch (what) {
209                 case 'k':
210                         sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
211                         break;
212                 case 'K':
213                         sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
214                         break;
215                 case 'h':
216                         sprintf_item_head(p, va_arg(args, struct item_head *));
217                         break;
218                 case 't':
219                         sprintf_direntry(p,
220                                          va_arg(args,
221                                                 struct reiserfs_dir_entry *));
222                         break;
223                 case 'y':
224                         sprintf_disk_child(p,
225                                            va_arg(args, struct disk_child *));
226                         break;
227                 case 'z':
228                         sprintf_block_head(p,
229                                            va_arg(args, struct buffer_head *));
230                         break;
231                 case 'b':
232                         sprintf_buffer_head(p,
233                                             va_arg(args, struct buffer_head *));
234                         break;
235                 case 'a':
236                         sprintf_de_head(p,
237                                         va_arg(args,
238                                                struct reiserfs_de_head *));
239                         break;
240                 }
241
242                 p += strlen(p);
243                 fmt1 = k + 2;
244         }
245         vsprintf(p, fmt1, args);
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 #ifdef CONFIG_REISERFS_CHECK
353 extern struct tree_balance *cur_tb;
354 #endif
355
356 void reiserfs_panic(struct super_block *sb, const char *fmt, ...)
357 {
358         do_reiserfs_warning(fmt);
359         printk(KERN_EMERG "REISERFS: panic (device %s): %s\n",
360                reiserfs_bdevname(sb), error_buf);
361         BUG();
362
363         /* this is not actually called, but makes reiserfs_panic() "noreturn" */
364         panic("REISERFS: panic (device %s): %s\n",
365               reiserfs_bdevname(sb), error_buf);
366 }
367
368 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
369 {
370         do_reiserfs_warning(fmt);
371
372         if (reiserfs_error_panic(sb)) {
373                 panic(KERN_CRIT "REISERFS: panic (device %s): %s\n",
374                       reiserfs_bdevname(sb), error_buf);
375         }
376
377         if (sb->s_flags & MS_RDONLY)
378                 return;
379
380         printk(KERN_CRIT "REISERFS: abort (device %s): %s\n",
381                reiserfs_bdevname(sb), error_buf);
382
383         sb->s_flags |= MS_RDONLY;
384         reiserfs_journal_abort(sb, errno);
385 }
386
387 /* this prints internal nodes (4 keys/items in line) (dc_number,
388    dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
389    dc_size)...*/
390 static int print_internal(struct buffer_head *bh, int first, int last)
391 {
392         struct reiserfs_key *key;
393         struct disk_child *dc;
394         int i;
395         int from, to;
396
397         if (!B_IS_KEYS_LEVEL(bh))
398                 return 1;
399
400         check_internal(bh);
401
402         if (first == -1) {
403                 from = 0;
404                 to = B_NR_ITEMS(bh);
405         } else {
406                 from = first;
407                 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
408         }
409
410         reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
411
412         dc = B_N_CHILD(bh, from);
413         reiserfs_printk("PTR %d: %y ", from, dc);
414
415         for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
416              i++, key++, dc++) {
417                 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
418                 if (i && i % 4 == 0)
419                         printk("\n");
420         }
421         printk("\n");
422         return 0;
423 }
424
425 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
426                       int last)
427 {
428         struct block_head *blkh;
429         struct item_head *ih;
430         int i, nr;
431         int from, to;
432
433         if (!B_IS_ITEMS_LEVEL(bh))
434                 return 1;
435
436         check_leaf(bh);
437
438         blkh = B_BLK_HEAD(bh);
439         ih = B_N_PITEM_HEAD(bh, 0);
440         nr = blkh_nr_item(blkh);
441
442         printk
443             ("\n===================================================================\n");
444         reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
445
446         if (!(print_mode & PRINT_LEAF_ITEMS)) {
447                 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
448                                 &(ih->ih_key), &((ih + nr - 1)->ih_key));
449                 return 0;
450         }
451
452         if (first < 0 || first > nr - 1)
453                 from = 0;
454         else
455                 from = first;
456
457         if (last < 0 || last > nr)
458                 to = nr;
459         else
460                 to = last;
461
462         ih += from;
463         printk
464             ("-------------------------------------------------------------------------------\n");
465         printk
466             ("|##|   type    |           key           | ilen | free_space | version | loc  |\n");
467         for (i = from; i < to; i++, ih++) {
468                 printk
469                     ("-------------------------------------------------------------------------------\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
476             ("===================================================================\n");
477
478         return 0;
479 }
480
481 char *reiserfs_hashname(int code)
482 {
483         if (code == YURA_HASH)
484                 return "rupasov";
485         if (code == TEA_HASH)
486                 return "tea";
487         if (code == R5_HASH)
488                 return "r5";
489
490         return "unknown";
491 }
492
493 /* return 1 if this is not super block */
494 static int print_super_block(struct buffer_head *bh)
495 {
496         struct reiserfs_super_block *rs =
497             (struct reiserfs_super_block *)(bh->b_data);
498         int skipped, data_blocks;
499         char *version;
500         char b[BDEVNAME_SIZE];
501
502         if (is_reiserfs_3_5(rs)) {
503                 version = "3.5";
504         } else if (is_reiserfs_3_6(rs)) {
505                 version = "3.6";
506         } else if (is_reiserfs_jr(rs)) {
507                 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
508                            "3.6" : "3.5");
509         } else {
510                 return 1;
511         }
512
513         printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
514                (unsigned long long)bh->b_blocknr);
515         printk("Reiserfs version %s\n", version);
516         printk("Block count %u\n", sb_block_count(rs));
517         printk("Blocksize %d\n", sb_blocksize(rs));
518         printk("Free blocks %u\n", sb_free_blocks(rs));
519         // FIXME: this would be confusing if
520         // someone stores reiserfs super block in some data block ;)
521 //    skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
522         skipped = bh->b_blocknr;
523         data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
524             (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
525              1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
526         printk
527             ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
528              "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
529              (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
530               sb_reserved_for_journal(rs)), data_blocks);
531         printk("Root block %u\n", sb_root_block(rs));
532         printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
533         printk("Journal dev %d\n", sb_jp_journal_dev(rs));
534         printk("Journal orig size %d\n", sb_jp_journal_size(rs));
535         printk("FS state %d\n", sb_fs_state(rs));
536         printk("Hash function \"%s\"\n",
537                reiserfs_hashname(sb_hash_function_code(rs)));
538
539         printk("Tree height %d\n", sb_tree_height(rs));
540         return 0;
541 }
542
543 static int print_desc_block(struct buffer_head *bh)
544 {
545         struct reiserfs_journal_desc *desc;
546
547         if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
548                 return 1;
549
550         desc = (struct reiserfs_journal_desc *)(bh->b_data);
551         printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
552                (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
553                get_desc_mount_id(desc), get_desc_trans_len(desc));
554
555         return 0;
556 }
557
558 void print_block(struct buffer_head *bh, ...)   //int print_mode, int first, int last)
559 {
560         va_list args;
561         int mode, first, last;
562
563         va_start(args, bh);
564
565         if (!bh) {
566                 printk("print_block: buffer is NULL\n");
567                 return;
568         }
569
570         mode = va_arg(args, int);
571         first = va_arg(args, int);
572         last = va_arg(args, int);
573         if (print_leaf(bh, mode, first, last))
574                 if (print_internal(bh, first, last))
575                         if (print_super_block(bh))
576                                 if (print_desc_block(bh))
577                                         printk
578                                             ("Block %llu contains unformatted data\n",
579                                              (unsigned long long)bh->b_blocknr);
580 }
581
582 static char print_tb_buf[2048];
583
584 /* this stores initial state of tree balance in the print_tb_buf */
585 void store_print_tb(struct tree_balance *tb)
586 {
587         int h = 0;
588         int i;
589         struct buffer_head *tbSh, *tbFh;
590
591         if (!tb)
592                 return;
593
594         sprintf(print_tb_buf, "\n"
595                 "BALANCING %d\n"
596                 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
597                 "=====================================================================\n"
598                 "* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n",
599                 REISERFS_SB(tb->tb_sb)->s_do_balance,
600                 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
601                 tb->tb_path->pos_in_item);
602
603         for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
604                 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
605                     tb->tb_path->path_length
606                     && PATH_H_PATH_OFFSET(tb->tb_path,
607                                           h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
608                         tbSh = PATH_H_PBUFFER(tb->tb_path, h);
609                         tbFh = PATH_H_PPARENT(tb->tb_path, h);
610                 } else {
611                         tbSh = NULL;
612                         tbFh = NULL;
613                 }
614                 sprintf(print_tb_buf + strlen(print_tb_buf),
615                         "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
616                         h,
617                         (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
618                         (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
619                         (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
620                         (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
621                         (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
622                         (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
623                         (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
624                         (tb->FL[h]) ? (long long)(tb->FL[h]->
625                                                   b_blocknr) : (-1LL),
626                         (tb->FR[h]) ? (long long)(tb->FR[h]->
627                                                   b_blocknr) : (-1LL),
628                         (tb->CFL[h]) ? (long long)(tb->CFL[h]->
629                                                    b_blocknr) : (-1LL),
630                         (tb->CFR[h]) ? (long long)(tb->CFR[h]->
631                                                    b_blocknr) : (-1LL));
632         }
633
634         sprintf(print_tb_buf + strlen(print_tb_buf),
635                 "=====================================================================\n"
636                 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
637                 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
638                 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
639                 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
640                 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
641                 tb->rkey[0]);
642
643         /* this prints balance parameters for non-leaf levels */
644         h = 0;
645         do {
646                 h++;
647                 sprintf(print_tb_buf + strlen(print_tb_buf),
648                         "* %d * %4d * %2d *    * %2d *    * %2d *\n",
649                         h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
650                         tb->blknum[h]);
651         } while (tb->insert_size[h]);
652
653         sprintf(print_tb_buf + strlen(print_tb_buf),
654                 "=====================================================================\n"
655                 "FEB list: ");
656
657         /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
658         h = 0;
659         for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
660                 sprintf(print_tb_buf + strlen(print_tb_buf),
661                         "%p (%llu %d)%s", tb->FEB[i],
662                         tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
663                         b_blocknr : 0ULL,
664                         tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
665                         (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
666
667         sprintf(print_tb_buf + strlen(print_tb_buf),
668                 "======================== the end ====================================\n");
669 }
670
671 void print_cur_tb(char *mes)
672 {
673         printk("%s\n%s", mes, print_tb_buf);
674 }
675
676 static void check_leaf_block_head(struct buffer_head *bh)
677 {
678         struct block_head *blkh;
679         int nr;
680
681         blkh = B_BLK_HEAD(bh);
682         nr = blkh_nr_item(blkh);
683         if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
684                 reiserfs_panic(NULL,
685                                "vs-6010: check_leaf_block_head: invalid item number %z",
686                                bh);
687         if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
688                 reiserfs_panic(NULL,
689                                "vs-6020: check_leaf_block_head: invalid free space %z",
690                                bh);
691
692 }
693
694 static void check_internal_block_head(struct buffer_head *bh)
695 {
696         struct block_head *blkh;
697
698         blkh = B_BLK_HEAD(bh);
699         if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
700                 reiserfs_panic(NULL,
701                                "vs-6025: check_internal_block_head: invalid level %z",
702                                bh);
703
704         if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
705                 reiserfs_panic(NULL,
706                                "vs-6030: check_internal_block_head: invalid item number %z",
707                                bh);
708
709         if (B_FREE_SPACE(bh) !=
710             bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
711             DC_SIZE * (B_NR_ITEMS(bh) + 1))
712                 reiserfs_panic(NULL,
713                                "vs-6040: check_internal_block_head: invalid free space %z",
714                                bh);
715
716 }
717
718 void check_leaf(struct buffer_head *bh)
719 {
720         int i;
721         struct item_head *ih;
722
723         if (!bh)
724                 return;
725         check_leaf_block_head(bh);
726         for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
727                 op_check_item(ih, B_I_PITEM(bh, ih));
728 }
729
730 void check_internal(struct buffer_head *bh)
731 {
732         if (!bh)
733                 return;
734         check_internal_block_head(bh);
735 }
736
737 void print_statistics(struct super_block *s)
738 {
739
740         /*
741            printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
742            bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
743            REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
744            REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
745            REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
746          */
747
748 }