Merge branches 'release' and 'ppc-workaround' into release
[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
360         dump_stack();
361
362         panic(KERN_EMERG "REISERFS: panic (device %s): %s\n",
363                reiserfs_bdevname(sb), error_buf);
364 }
365
366 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
367 {
368         do_reiserfs_warning(fmt);
369
370         if (reiserfs_error_panic(sb)) {
371                 panic(KERN_CRIT "REISERFS: panic (device %s): %s\n",
372                       reiserfs_bdevname(sb), error_buf);
373         }
374
375         if (sb->s_flags & MS_RDONLY)
376                 return;
377
378         printk(KERN_CRIT "REISERFS: abort (device %s): %s\n",
379                reiserfs_bdevname(sb), error_buf);
380
381         sb->s_flags |= MS_RDONLY;
382         reiserfs_journal_abort(sb, errno);
383 }
384
385 /* this prints internal nodes (4 keys/items in line) (dc_number,
386    dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
387    dc_size)...*/
388 static int print_internal(struct buffer_head *bh, int first, int last)
389 {
390         struct reiserfs_key *key;
391         struct disk_child *dc;
392         int i;
393         int from, to;
394
395         if (!B_IS_KEYS_LEVEL(bh))
396                 return 1;
397
398         check_internal(bh);
399
400         if (first == -1) {
401                 from = 0;
402                 to = B_NR_ITEMS(bh);
403         } else {
404                 from = first;
405                 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
406         }
407
408         reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
409
410         dc = B_N_CHILD(bh, from);
411         reiserfs_printk("PTR %d: %y ", from, dc);
412
413         for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
414              i++, key++, dc++) {
415                 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
416                 if (i && i % 4 == 0)
417                         printk("\n");
418         }
419         printk("\n");
420         return 0;
421 }
422
423 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
424                       int last)
425 {
426         struct block_head *blkh;
427         struct item_head *ih;
428         int i, nr;
429         int from, to;
430
431         if (!B_IS_ITEMS_LEVEL(bh))
432                 return 1;
433
434         check_leaf(bh);
435
436         blkh = B_BLK_HEAD(bh);
437         ih = B_N_PITEM_HEAD(bh, 0);
438         nr = blkh_nr_item(blkh);
439
440         printk
441             ("\n===================================================================\n");
442         reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
443
444         if (!(print_mode & PRINT_LEAF_ITEMS)) {
445                 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
446                                 &(ih->ih_key), &((ih + nr - 1)->ih_key));
447                 return 0;
448         }
449
450         if (first < 0 || first > nr - 1)
451                 from = 0;
452         else
453                 from = first;
454
455         if (last < 0 || last > nr)
456                 to = nr;
457         else
458                 to = last;
459
460         ih += from;
461         printk
462             ("-------------------------------------------------------------------------------\n");
463         printk
464             ("|##|   type    |           key           | ilen | free_space | version | loc  |\n");
465         for (i = from; i < to; i++, ih++) {
466                 printk
467                     ("-------------------------------------------------------------------------------\n");
468                 reiserfs_printk("|%2d| %h |\n", i, ih);
469                 if (print_mode & PRINT_LEAF_ITEMS)
470                         op_print_item(ih, B_I_PITEM(bh, ih));
471         }
472
473         printk
474             ("===================================================================\n");
475
476         return 0;
477 }
478
479 char *reiserfs_hashname(int code)
480 {
481         if (code == YURA_HASH)
482                 return "rupasov";
483         if (code == TEA_HASH)
484                 return "tea";
485         if (code == R5_HASH)
486                 return "r5";
487
488         return "unknown";
489 }
490
491 /* return 1 if this is not super block */
492 static int print_super_block(struct buffer_head *bh)
493 {
494         struct reiserfs_super_block *rs =
495             (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) +
523              1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
524         printk
525             ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
526              "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
527              (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
528               sb_reserved_for_journal(rs)), data_blocks);
529         printk("Root block %u\n", sb_root_block(rs));
530         printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
531         printk("Journal dev %d\n", sb_jp_journal_dev(rs));
532         printk("Journal orig size %d\n", sb_jp_journal_size(rs));
533         printk("FS state %d\n", sb_fs_state(rs));
534         printk("Hash function \"%s\"\n",
535                reiserfs_hashname(sb_hash_function_code(rs)));
536
537         printk("Tree height %d\n", sb_tree_height(rs));
538         return 0;
539 }
540
541 static int print_desc_block(struct buffer_head *bh)
542 {
543         struct reiserfs_journal_desc *desc;
544
545         if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
546                 return 1;
547
548         desc = (struct reiserfs_journal_desc *)(bh->b_data);
549         printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
550                (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
551                get_desc_mount_id(desc), get_desc_trans_len(desc));
552
553         return 0;
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
576                                             ("Block %llu contains unformatted data\n",
577                                              (unsigned long long)bh->b_blocknr);
578
579         va_end(args);
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 }