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 *id,
 268                          const char *function, const char *fmt, ...)
 269 {
 270         do_reiserfs_warning(fmt);
 271         if (sb)
 272                 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
 273                        "%s\n", sb->s_id, id ? id : "", id ? " " : "",
 274                        function, error_buf);
 275         else
 276                 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
 277                        id ? id : "", id ? " " : "", function, error_buf);
 278 }
 279
 280 /* No newline.. reiserfs_info calls can be followed by printk's */
 281 void reiserfs_info(struct super_block *sb, const char *fmt, ...)
 282 {
 283         do_reiserfs_warning(fmt);
 284         if (sb)
 285                 printk(KERN_NOTICE "REISERFS (device %s): %s",
 286                        sb->s_id, error_buf);
 287         else
 288                 printk(KERN_NOTICE "REISERFS %s:", error_buf);
 289 }
 290
 291 /* No newline.. reiserfs_printk calls can be followed by printk's */
 292 static void reiserfs_printk(const char *fmt, ...)
 293 {
 294         do_reiserfs_warning(fmt);
 295         printk(error_buf);
 296 }
 297
 298 void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
 299 {
 300 #ifdef CONFIG_REISERFS_CHECK
 301         do_reiserfs_warning(fmt);
 302         if (s)
 303                 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
 304                        s->s_id, error_buf);
 305         else
 306                 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
 307 #endif
 308 }
 309
 310 /* The format:
 311
 312            maintainer-errorid: [function-name:] message
 313
 314     where errorid is unique to the maintainer and function-name is
 315     optional, is recommended, so that anyone can easily find the bug
 316     with a simple grep for the short to type string
 317     maintainer-errorid.  Don't bother with reusing errorids, there are
 318     lots of numbers out there.
 319
 320     Example:
 321
 322     reiserfs_panic(
 323         p_sb, "reiser-29: reiserfs_new_blocknrs: "
 324         "one of search_start or rn(%d) is equal to MAX_B_NUM,"
 325         "which means that we are optimizing location based on the bogus location of a temp buffer (%p).",
 326         rn, bh
 327     );
 328
 329     Regular panic()s sometimes clear the screen before the message can
 330     be read, thus the need for the while loop.
 331
 332     Numbering scheme for panic used by Vladimir and Anatoly( Hans completely ignores this scheme, and considers it
 333     pointless complexity):
 334
 335     panics in reiserfs_fs.h have numbers from 1000 to 1999
 336     super.c                                     2000 to 2999
 337     preserve.c (unused)                     3000 to 3999
 338     bitmap.c                                4000 to 4999
 339     stree.c                                     5000 to 5999
 340     prints.c                                6000 to 6999
 341     namei.c                     7000 to 7999
 342     fix_nodes.c                 8000 to 8999
 343     dir.c                       9000 to 9999
 344         lbalance.c                                      10000 to 10999
 345         ibalance.c              11000 to 11999 not ready
 346         do_balan.c              12000 to 12999
 347         inode.c                 13000 to 13999
 348         file.c                  14000 to 14999
 349     objectid.c                       15000 - 15999
 350     buffer.c                         16000 - 16999
 351     symlink.c                        17000 - 17999
 352
 353    .  */
 354
 355 #ifdef CONFIG_REISERFS_CHECK
 356 extern struct tree_balance *cur_tb;
 357 #endif
 358
 359 void __reiserfs_panic(struct super_block *sb, const char *id,
 360                       const char *function, const char *fmt, ...)
 361 {
 362         do_reiserfs_warning(fmt);
 363
 364 #ifdef CONFIG_REISERFS_CHECK
 365         dump_stack();
 366 #endif
 367         if (sb)
 368                 panic(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
 369                       sb->s_id, id ? id : "", id ? " " : "",
 370                       function, error_buf);
 371         else
 372                 panic(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
 373                       id ? id : "", id ? " " : "", function, error_buf);
 374 }
 375
 376 void __reiserfs_error(struct super_block *sb, const char *id,
 377                       const char *function, const char *fmt, ...)
 378 {
 379         do_reiserfs_warning(fmt);
 380
 381         BUG_ON(sb == NULL);
 382
 383         if (reiserfs_error_panic(sb))
 384                 __reiserfs_panic(sb, id, function, error_buf);
 385
 386         if (id && id[0])
 387                 printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
 388                        sb->s_id, id, function, error_buf);
 389         else
 390                 printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
 391                        sb->s_id, function, error_buf);
 392
 393         if (sb->s_flags & MS_RDONLY)
 394                 return;
 395
 396         reiserfs_info(sb, "Remounting filesystem read-only\n");
 397         sb->s_flags |= MS_RDONLY;
 398         reiserfs_abort_journal(sb, -EIO);
 399 }
 400
 401 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
 402 {
 403         do_reiserfs_warning(fmt);
 404
 405         if (reiserfs_error_panic(sb)) {
 406                 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
 407                       error_buf);
 408         }
 409
 410         if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
 411                 return;
 412
 413         printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
 414                error_buf);
 415
 416         sb->s_flags |= MS_RDONLY;
 417         reiserfs_abort_journal(sb, errno);
 418 }
 419
 420 /* this prints internal nodes (4 keys/items in line) (dc_number,
 421    dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
 422    dc_size)...*/
 423 static int print_internal(struct buffer_head *bh, int first, int last)
 424 {
 425         struct reiserfs_key *key;
 426         struct disk_child *dc;
 427         int i;
 428         int from, to;
 429
 430         if (!B_IS_KEYS_LEVEL(bh))
 431                 return 1;
 432
 433         check_internal(bh);
 434
 435         if (first == -1) {
 436                 from = 0;
 437                 to = B_NR_ITEMS(bh);
 438         } else {
 439                 from = first;
 440                 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
 441         }
 442
 443         reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
 444
 445         dc = B_N_CHILD(bh, from);
 446         reiserfs_printk("PTR %d: %y ", from, dc);
 447
 448         for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
 449              i++, key++, dc++) {
 450                 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
 451                 if (i && i % 4 == 0)
 452                         printk("\n");
 453         }
 454         printk("\n");
 455         return 0;
 456 }
 457
 458 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
 459                       int last)
 460 {
 461         struct block_head *blkh;
 462         struct item_head *ih;
 463         int i, nr;
 464         int from, to;
 465
 466         if (!B_IS_ITEMS_LEVEL(bh))
 467                 return 1;
 468
 469         check_leaf(bh);
 470
 471         blkh = B_BLK_HEAD(bh);
 472         ih = B_N_PITEM_HEAD(bh, 0);
 473         nr = blkh_nr_item(blkh);
 474
 475         printk
 476             ("\n===================================================================\n");
 477         reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
 478
 479         if (!(print_mode & PRINT_LEAF_ITEMS)) {
 480                 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
 481                                 &(ih->ih_key), &((ih + nr - 1)->ih_key));
 482                 return 0;
 483         }
 484
 485         if (first < 0 || first > nr - 1)
 486                 from = 0;
 487         else
 488                 from = first;
 489
 490         if (last < 0 || last > nr)
 491                 to = nr;
 492         else
 493                 to = last;
 494
 495         ih += from;
 496         printk
 497             ("-------------------------------------------------------------------------------\n");
 498         printk
 499             ("|##|   type    |           key           | ilen | free_space | version | loc  |\n");
 500         for (i = from; i < to; i++, ih++) {
 501                 printk
 502                     ("-------------------------------------------------------------------------------\n");
 503                 reiserfs_printk("|%2d| %h |\n", i, ih);
 504                 if (print_mode & PRINT_LEAF_ITEMS)
 505                         op_print_item(ih, B_I_PITEM(bh, ih));
 506         }
 507
 508         printk
 509             ("===================================================================\n");
 510
 511         return 0;
 512 }
 513
 514 char *reiserfs_hashname(int code)
 515 {
 516         if (code == YURA_HASH)
 517                 return "rupasov";
 518         if (code == TEA_HASH)
 519                 return "tea";
 520         if (code == R5_HASH)
 521                 return "r5";
 522
 523         return "unknown";
 524 }
 525
 526 /* return 1 if this is not super block */
 527 static int print_super_block(struct buffer_head *bh)
 528 {
 529         struct reiserfs_super_block *rs =
 530             (struct reiserfs_super_block *)(bh->b_data);
 531         int skipped, data_blocks;
 532         char *version;
 533         char b[BDEVNAME_SIZE];
 534
 535         if (is_reiserfs_3_5(rs)) {
 536                 version = "3.5";
 537         } else if (is_reiserfs_3_6(rs)) {
 538                 version = "3.6";
 539         } else if (is_reiserfs_jr(rs)) {
 540                 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
 541                            "3.6" : "3.5");
 542         } else {
 543                 return 1;
 544         }
 545
 546         printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
 547                (unsigned long long)bh->b_blocknr);
 548         printk("Reiserfs version %s\n", version);
 549         printk("Block count %u\n", sb_block_count(rs));
 550         printk("Blocksize %d\n", sb_blocksize(rs));
 551         printk("Free blocks %u\n", sb_free_blocks(rs));
 552         // FIXME: this would be confusing if
 553         // someone stores reiserfs super block in some data block ;)
 554 //    skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
 555         skipped = bh->b_blocknr;
 556         data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
 557             (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
 558              1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
 559         printk
 560             ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
 561              "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
 562              (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
 563               sb_reserved_for_journal(rs)), data_blocks);
 564         printk("Root block %u\n", sb_root_block(rs));
 565         printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
 566         printk("Journal dev %d\n", sb_jp_journal_dev(rs));
 567         printk("Journal orig size %d\n", sb_jp_journal_size(rs));
 568         printk("FS state %d\n", sb_fs_state(rs));
 569         printk("Hash function \"%s\"\n",
 570                reiserfs_hashname(sb_hash_function_code(rs)));
 571
 572         printk("Tree height %d\n", sb_tree_height(rs));
 573         return 0;
 574 }
 575
 576 static int print_desc_block(struct buffer_head *bh)
 577 {
 578         struct reiserfs_journal_desc *desc;
 579
 580         if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
 581                 return 1;
 582
 583         desc = (struct reiserfs_journal_desc *)(bh->b_data);
 584         printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
 585                (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
 586                get_desc_mount_id(desc), get_desc_trans_len(desc));
 587
 588         return 0;
 589 }
 590
 591 void print_block(struct buffer_head *bh, ...)   //int print_mode, int first, int last)
 592 {
 593         va_list args;
 594         int mode, first, last;
 595
 596         va_start(args, bh);
 597
 598         if (!bh) {
 599                 printk("print_block: buffer is NULL\n");
 600                 return;
 601         }
 602
 603         mode = va_arg(args, int);
 604         first = va_arg(args, int);
 605         last = va_arg(args, int);
 606         if (print_leaf(bh, mode, first, last))
 607                 if (print_internal(bh, first, last))
 608                         if (print_super_block(bh))
 609                                 if (print_desc_block(bh))
 610                                         printk
 611                                             ("Block %llu contains unformatted data\n",
 612                                              (unsigned long long)bh->b_blocknr);
 613
 614         va_end(args);
 615 }
 616
 617 static char print_tb_buf[2048];
 618
 619 /* this stores initial state of tree balance in the print_tb_buf */
 620 void store_print_tb(struct tree_balance *tb)
 621 {
 622         int h = 0;
 623         int i;
 624         struct buffer_head *tbSh, *tbFh;
 625
 626         if (!tb)
 627                 return;
 628
 629         sprintf(print_tb_buf, "\n"
 630                 "BALANCING %d\n"
 631                 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
 632                 "=====================================================================\n"
 633                 "* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n",
 634                 REISERFS_SB(tb->tb_sb)->s_do_balance,
 635                 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
 636                 tb->tb_path->pos_in_item);
 637
 638         for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
 639                 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
 640                     tb->tb_path->path_length
 641                     && PATH_H_PATH_OFFSET(tb->tb_path,
 642                                           h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
 643                         tbSh = PATH_H_PBUFFER(tb->tb_path, h);
 644                         tbFh = PATH_H_PPARENT(tb->tb_path, h);
 645                 } else {
 646                         tbSh = NULL;
 647                         tbFh = NULL;
 648                 }
 649                 sprintf(print_tb_buf + strlen(print_tb_buf),
 650                         "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
 651                         h,
 652                         (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
 653                         (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
 654                         (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
 655                         (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
 656                         (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
 657                         (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
 658                         (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
 659                         (tb->FL[h]) ? (long long)(tb->FL[h]->
 660                                                   b_blocknr) : (-1LL),
 661                         (tb->FR[h]) ? (long long)(tb->FR[h]->
 662                                                   b_blocknr) : (-1LL),
 663                         (tb->CFL[h]) ? (long long)(tb->CFL[h]->
 664                                                    b_blocknr) : (-1LL),
 665                         (tb->CFR[h]) ? (long long)(tb->CFR[h]->
 666                                                    b_blocknr) : (-1LL));
 667         }
 668
 669         sprintf(print_tb_buf + strlen(print_tb_buf),
 670                 "=====================================================================\n"
 671                 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
 672                 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
 673                 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
 674                 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
 675                 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
 676                 tb->rkey[0]);
 677
 678         /* this prints balance parameters for non-leaf levels */
 679         h = 0;
 680         do {
 681                 h++;
 682                 sprintf(print_tb_buf + strlen(print_tb_buf),
 683                         "* %d * %4d * %2d *    * %2d *    * %2d *\n",
 684                         h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
 685                         tb->blknum[h]);
 686         } while (tb->insert_size[h]);
 687
 688         sprintf(print_tb_buf + strlen(print_tb_buf),
 689                 "=====================================================================\n"
 690                 "FEB list: ");
 691
 692         /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
 693         h = 0;
 694         for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
 695                 sprintf(print_tb_buf + strlen(print_tb_buf),
 696                         "%p (%llu %d)%s", tb->FEB[i],
 697                         tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
 698                         b_blocknr : 0ULL,
 699                         tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
 700                         (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
 701
 702         sprintf(print_tb_buf + strlen(print_tb_buf),
 703                 "======================== the end ====================================\n");
 704 }
 705
 706 void print_cur_tb(char *mes)
 707 {
 708         printk("%s\n%s", mes, print_tb_buf);
 709 }
 710
 711 static void check_leaf_block_head(struct buffer_head *bh)
 712 {
 713         struct block_head *blkh;
 714         int nr;
 715
 716         blkh = B_BLK_HEAD(bh);
 717         nr = blkh_nr_item(blkh);
 718         if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
 719                 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
 720                                bh);
 721         if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
 722                 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
 723                                bh);
 724
 725 }
 726
 727 static void check_internal_block_head(struct buffer_head *bh)
 728 {
 729         struct block_head *blkh;
 730
 731         blkh = B_BLK_HEAD(bh);
 732         if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
 733                 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
 734
 735         if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
 736                 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
 737
 738         if (B_FREE_SPACE(bh) !=
 739             bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
 740             DC_SIZE * (B_NR_ITEMS(bh) + 1))
 741                 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
 742
 743 }
 744
 745 void check_leaf(struct buffer_head *bh)
 746 {
 747         int i;
 748         struct item_head *ih;
 749
 750         if (!bh)
 751                 return;
 752         check_leaf_block_head(bh);
 753         for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
 754                 op_check_item(ih, B_I_PITEM(bh, ih));
 755 }
 756
 757 void check_internal(struct buffer_head *bh)
 758 {
 759         if (!bh)
 760                 return;
 761         check_internal_block_head(bh);
 762 }
 763
 764 void print_statistics(struct super_block *s)
 765 {
 766
 767         /*
 768            printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
 769            bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
 770            REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
 771            REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
 772            REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
 773          */
 774
 775 }