Merge branch 'tracing/urgent' into tracing/ftrace
[pandora-kernel.git] / 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)
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 }