fs/reiserfs/prints.c

   1 /*
   2  * Copyright 2000-2002 by Hans Reiser, licensing governed by reiserfs/README
   3  */
   4
   5 #include <linux/config.h>
   6 #include <linux/sched.h>
   7 #include <linux/fs.h>
   8 #include <linux/reiserfs_fs.h>
   9 #include <linux/string.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
  18 static char * reiserfs_cpu_offset (struct cpu_key * key)
  19 {
  20   if (cpu_key_k_type(key) == TYPE_DIRENTRY)
  21     sprintf (off_buf, "%Lu(%Lu)",
  22              (unsigned long long)GET_HASH_VALUE (cpu_key_k_offset (key)),
  23              (unsigned long long)GET_GENERATION_NUMBER (cpu_key_k_offset (key)));
  24   else
  25     sprintf (off_buf, "0x%Lx", (unsigned long long)cpu_key_k_offset (key));
  26   return off_buf;
  27 }
  28
  29
  30 static char * le_offset (struct key * key)
  31 {
  32   int version;
  33
  34   version = le_key_version (key);
  35   if (le_key_k_type (version, key) == TYPE_DIRENTRY)
  36     sprintf (off_buf, "%Lu(%Lu)",
  37              (unsigned long long)GET_HASH_VALUE (le_key_k_offset (version, key)),
  38              (unsigned long long)GET_GENERATION_NUMBER (le_key_k_offset (version, key)));
  39   else
  40     sprintf (off_buf, "0x%Lx", (unsigned long long)le_key_k_offset (version, key));
  41   return off_buf;
  42 }
  43
  44
  45 static char * cpu_type (struct cpu_key * key)
  46 {
  47     if (cpu_key_k_type (key) == TYPE_STAT_DATA)
  48         return "SD";
  49     if (cpu_key_k_type (key) == TYPE_DIRENTRY)
  50         return "DIR";
  51     if (cpu_key_k_type (key) == TYPE_DIRECT)
  52         return "DIRECT";
  53     if (cpu_key_k_type (key) == TYPE_INDIRECT)
  54         return "IND";
  55     return "UNKNOWN";
  56 }
  57
  58
  59 static char * le_type (struct key * key)
  60 {
  61     int version;
  62
  63     version = le_key_version (key);
  64
  65     if (le_key_k_type (version, key) == TYPE_STAT_DATA)
  66         return "SD";
  67     if (le_key_k_type (version, key) == TYPE_DIRENTRY)
  68         return "DIR";
  69     if (le_key_k_type (version, key) == TYPE_DIRECT)
  70         return "DIRECT";
  71     if (le_key_k_type (version, key) == TYPE_INDIRECT)
  72         return "IND";
  73     return "UNKNOWN";
  74 }
  75
  76
  77 /* %k */
  78 static void sprintf_le_key (char * buf, struct key * key)
  79 {
  80   if (key)
  81     sprintf (buf, "[%d %d %s %s]", le32_to_cpu (key->k_dir_id),
  82              le32_to_cpu (key->k_objectid), le_offset (key), le_type (key));
  83   else
  84     sprintf (buf, "[NULL]");
  85 }
  86
  87
  88 /* %K */
  89 static void sprintf_cpu_key (char * buf, struct cpu_key * key)
  90 {
  91   if (key)
  92     sprintf (buf, "[%d %d %s %s]", key->on_disk_key.k_dir_id,
  93              key->on_disk_key.k_objectid, reiserfs_cpu_offset (key),
  94              cpu_type (key));
  95   else
  96     sprintf (buf, "[NULL]");
  97 }
  98
  99 static void sprintf_de_head( char *buf, struct reiserfs_de_head *deh )
 100 {
 101     if( deh )
 102         sprintf( buf, "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]", deh_offset(deh), deh_dir_id(deh),
 103                  deh_objectid(deh), deh_location(deh), deh_state(deh) );
 104     else
 105         sprintf( buf, "[NULL]" );
 106
 107 }
 108
 109 static void sprintf_item_head (char * buf, struct item_head * ih)
 110 {
 111     if (ih) {
 112         sprintf (buf, "%s", (ih_version (ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*");
 113         sprintf_le_key (buf + strlen (buf), &(ih->ih_key));
 114         sprintf (buf + strlen (buf), ", item_len %d, item_location %d, "
 115                  "free_space(entry_count) %d",
 116                  ih_item_len(ih), ih_location(ih), ih_free_space (ih));
 117     } else
 118         sprintf (buf, "[NULL]");
 119 }
 120
 121
 122 static void sprintf_direntry (char * buf, struct reiserfs_dir_entry * de)
 123 {
 124   char name[20];
 125
 126   memcpy (name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen);
 127   name [de->de_namelen > 19 ? 19 : de->de_namelen] = 0;
 128   sprintf (buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid);
 129 }
 130
 131
 132 static void sprintf_block_head (char * buf, struct buffer_head * bh)
 133 {
 134   sprintf (buf, "level=%d, nr_items=%d, free_space=%d rdkey ",
 135            B_LEVEL (bh), B_NR_ITEMS (bh), B_FREE_SPACE (bh));
 136 }
 137
 138
 139 static void sprintf_buffer_head (char * buf, struct buffer_head * bh)
 140 {
 141   sprintf (buf, "dev %s, size %d, blocknr %ld, count %d, list %d, state 0x%lx, page %p, (%s, %s, %s)",
 142            kdevname (bh->b_dev), bh->b_size, bh->b_blocknr, atomic_read (&(bh->b_count)), bh->b_list,
 143            bh->b_state, bh->b_page,
 144            buffer_uptodate (bh) ? "UPTODATE" : "!UPTODATE",
 145            buffer_dirty (bh) ? "DIRTY" : "CLEAN",
 146            buffer_locked (bh) ? "LOCKED" : "UNLOCKED");
 147 }
 148
 149
 150 static void sprintf_disk_child (char * buf, struct disk_child * dc)
 151 {
 152   sprintf (buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc), dc_size(dc));
 153 }
 154
 155
 156 static char * is_there_reiserfs_struct (char * fmt, int * what, int * skip)
 157 {
 158   char * k = fmt;
 159
 160   *skip = 0;
 161
 162   while ((k = strstr (k, "%")) != NULL)
 163   {
 164     if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
 165               k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a' ) {
 166       *what = k[1];
 167       break;
 168     }
 169     (*skip) ++;
 170     k ++;
 171   }
 172   return k;
 173 }
 174
 175
 176 /* debugging reiserfs we used to print out a lot of different
 177    variables, like keys, item headers, buffer heads etc. Values of
 178    most fields matter. So it took a long time just to write
 179    appropriative printk. With this reiserfs_warning you can use format
 180    specification for complex structures like you used to do with
 181    printfs for integers, doubles and pointers. For instance, to print
 182    out key structure you have to write just:
 183    reiserfs_warning ("bad key %k", key);
 184    instead of
 185    printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
 186            key->k_offset, key->k_uniqueness);
 187 */
 188
 189
 190 static void
 191 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     {
 202         *k = 0;
 203
 204         p += vsprintf (p, fmt1, args);
 205
 206         for (i = 0; i < skip; i ++)
 207             j = va_arg (args, int);
 208
 209         switch (what) {
 210         case 'k':
 211             sprintf_le_key (p, va_arg(args, struct key *));
 212             break;
 213         case 'K':
 214             sprintf_cpu_key (p, va_arg(args, struct cpu_key *));
 215             break;
 216         case 'h':
 217             sprintf_item_head (p, va_arg(args, struct item_head *));
 218             break;
 219         case 't':
 220             sprintf_direntry (p, va_arg(args, struct reiserfs_dir_entry *));
 221             break;
 222         case 'y':
 223             sprintf_disk_child (p, va_arg(args, struct disk_child *));
 224             break;
 225         case 'z':
 226             sprintf_block_head (p, va_arg(args, struct buffer_head *));
 227             break;
 228         case 'b':
 229             sprintf_buffer_head (p, va_arg(args, struct buffer_head *));
 230             break;
 231         case 'a':
 232             sprintf_de_head (p, va_arg(args, struct reiserfs_de_head *));
 233             break;
 234         }
 235
 236         p += strlen (p);
 237         fmt1 = k + 2;
 238     }
 239     vsprintf (p, fmt1, args);
 240
 241 }
 242
 243
 244 /* in addition to usual conversion specifiers this accepts reiserfs
 245    specific conversion specifiers:
 246    %k to print little endian key,
 247    %K to print cpu key,
 248    %h to print item_head,
 249    %t to print directory entry
 250    %z to print block head (arg must be struct buffer_head *
 251    %b to print buffer_head
 252 */
 253
 254 #define do_reiserfs_warning(fmt)\
 255 {\
 256     va_list args;\
 257     va_start( args, fmt );\
 258     prepare_error_buf( fmt, args );\
 259     va_end( args );\
 260 }
 261
 262 void reiserfs_warning (const char * fmt, ...)
 263 {
 264   do_reiserfs_warning(fmt);
 265   /* console_print (error_buf); */
 266   printk (KERN_WARNING "%s", error_buf);
 267 }
 268
 269 void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...)
 270 {
 271 #ifdef CONFIG_REISERFS_CHECK
 272   do_reiserfs_warning(fmt);
 273   printk (KERN_DEBUG "%s", error_buf);
 274 #else
 275   ;
 276 #endif
 277 }
 278
 279 /* The format:
 280
 281            maintainer-errorid: [function-name:] message
 282
 283     where errorid is unique to the maintainer and function-name is
 284     optional, is recommended, so that anyone can easily find the bug
 285     with a simple grep for the short to type string
 286     maintainer-errorid.  Don't bother with reusing errorids, there are
 287     lots of numbers out there.
 288
 289     Example:
 290
 291     reiserfs_panic(
 292         p_sb, "reiser-29: reiserfs_new_blocknrs: "
 293         "one of search_start or rn(%d) is equal to MAX_B_NUM,"
 294         "which means that we are optimizing location based on the bogus location of a temp buffer (%p).",
 295         rn, bh
 296     );
 297
 298     Regular panic()s sometimes clear the screen before the message can
 299     be read, thus the need for the while loop.
 300
 301     Numbering scheme for panic used by Vladimir and Anatoly( Hans completely ignores this scheme, and considers it
 302     pointless complexity):
 303
 304     panics in reiserfs_fs.h have numbers from 1000 to 1999
 305     super.c                                     2000 to 2999
 306     preserve.c (unused)                     3000 to 3999
 307     bitmap.c                                4000 to 4999
 308     stree.c                                     5000 to 5999
 309     prints.c                                6000 to 6999
 310     namei.c                     7000 to 7999
 311     fix_nodes.c                 8000 to 8999
 312     dir.c                       9000 to 9999
 313         lbalance.c                                      10000 to 10999
 314         ibalance.c              11000 to 11999 not ready
 315         do_balan.c              12000 to 12999
 316         inode.c                 13000 to 13999
 317         file.c                  14000 to 14999
 318     objectid.c                       15000 - 15999
 319     buffer.c                         16000 - 16999
 320     symlink.c                        17000 - 17999
 321
 322    .  */
 323
 324
 325 #ifdef CONFIG_REISERFS_CHECK
 326 extern struct tree_balance * cur_tb;
 327 #endif
 328
 329 void reiserfs_panic (struct super_block * sb, const char * fmt, ...)
 330 {
 331   show_reiserfs_locks() ;
 332   do_reiserfs_warning(fmt);
 333   printk ( KERN_EMERG "%s", error_buf);
 334   BUG ();
 335
 336   /* this is not actually called, but makes reiserfs_panic() "noreturn" */
 337   panic ("REISERFS: panic (device %s): %s\n",
 338          sb ? kdevname(sb->s_dev) : "sb == 0", error_buf);
 339 }
 340
 341
 342 void print_virtual_node (struct virtual_node * vn)
 343 {
 344     int i;
 345     struct virtual_item * vi;
 346
 347     printk ("VIRTUAL NODE CONTAINS %d items, has size %d,%s,%s, ITEM_POS=%d POS_IN_ITEM=%d MODE=\'%c\'\n",
 348             vn->vn_nr_item, vn->vn_size,
 349             (vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE )? "left mergeable" : "",
 350             (vn->vn_vi[vn->vn_nr_item - 1].vi_type & VI_TYPE_RIGHT_MERGEABLE) ? "right mergeable" : "",
 351             vn->vn_affected_item_num, vn->vn_pos_in_item, vn->vn_mode);
 352
 353     vi = vn->vn_vi;
 354     for (i = 0; i < vn->vn_nr_item; i ++, vi ++)
 355         op_print_vi (vi);
 356
 357 }
 358
 359
 360 void print_path (struct tree_balance * tb, struct path * path)
 361 {
 362     int h = 0;
 363     struct buffer_head * bh;
 364
 365     if (tb) {
 366         while (tb->insert_size[h]) {
 367             bh = PATH_H_PBUFFER (path, h);
 368             printk ("block %lu (level=%d), position %d\n", bh ? bh->b_blocknr : 0,
 369                     bh ? B_LEVEL (bh) : 0, PATH_H_POSITION (path, h));
 370             h ++;
 371         }
 372   } else {
 373       int offset = path->path_length;
 374       struct buffer_head * bh;
 375       printk ("Offset    Bh     (b_blocknr, b_count) Position Nr_item\n");
 376       while ( offset > ILLEGAL_PATH_ELEMENT_OFFSET ) {
 377           bh = PATH_OFFSET_PBUFFER (path, offset);
 378           printk ("%6d %10p (%9lu, %7d) %8d %7d\n", offset,
 379                   bh, bh ? bh->b_blocknr : 0, bh ? atomic_read (&(bh->b_count)) : 0,
 380                   PATH_OFFSET_POSITION (path, offset), bh ? B_NR_ITEMS (bh) : -1);
 381
 382           offset --;
 383       }
 384   }
 385
 386 }
 387
 388
 389 /* this prints internal nodes (4 keys/items in line) (dc_number,
 390    dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
 391    dc_size)...*/
 392 static int print_internal (struct buffer_head * bh, int first, int last)
 393 {
 394     struct key * key;
 395     struct disk_child * dc;
 396     int i;
 397     int from, to;
 398
 399     if (!B_IS_KEYS_LEVEL (bh))
 400         return 1;
 401
 402     check_internal (bh);
 403
 404     if (first == -1) {
 405         from = 0;
 406         to = B_NR_ITEMS (bh);
 407     } else {
 408         from = first;
 409         to = last < B_NR_ITEMS (bh) ? last : B_NR_ITEMS (bh);
 410     }
 411
 412     reiserfs_warning ("INTERNAL NODE (%ld) contains %z\n",  bh->b_blocknr, bh);
 413
 414     dc = B_N_CHILD (bh, from);
 415     reiserfs_warning ("PTR %d: %y ", from, dc);
 416
 417     for (i = from, key = B_N_PDELIM_KEY (bh, from), dc ++; i < to; i ++, key ++, dc ++) {
 418         reiserfs_warning ("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
 419         if (i && i % 4 == 0)
 420             printk ("\n");
 421     }
 422     printk ("\n");
 423     return 0;
 424 }
 425
 426
 427
 428
 429
 430 static int print_leaf (struct buffer_head * bh, int print_mode, int first, int last)
 431 {
 432     struct block_head * blkh;
 433     struct item_head * ih;
 434     int i, nr;
 435     int from, to;
 436
 437     if (!B_IS_ITEMS_LEVEL (bh))
 438         return 1;
 439
 440     check_leaf (bh);
 441
 442     blkh = B_BLK_HEAD (bh);
 443     ih = B_N_PITEM_HEAD (bh,0);
 444     nr = blkh_nr_item(blkh);
 445
 446     printk ("\n===================================================================\n");
 447     reiserfs_warning ("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
 448
 449     if (!(print_mode & PRINT_LEAF_ITEMS)) {
 450         reiserfs_warning ("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
 451                           &(ih->ih_key), &((ih + nr - 1)->ih_key));
 452         return 0;
 453     }
 454
 455     if (first < 0 || first > nr - 1)
 456         from = 0;
 457     else
 458         from = first;
 459
 460     if (last < 0 || last > nr )
 461         to = nr;
 462     else
 463         to = last;
 464
 465     ih += from;
 466     printk ("-------------------------------------------------------------------------------\n");
 467     printk ("|##|   type    |           key           | ilen | free_space | version | loc  |\n");
 468     for (i = from; i < to; i++, ih ++) {
 469         printk ("-------------------------------------------------------------------------------\n");
 470         reiserfs_warning ("|%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 ("===================================================================\n");
 476
 477     return 0;
 478 }
 479
 480 char * reiserfs_hashname(int code)
 481 {
 482     if ( code == YURA_HASH)
 483         return "rupasov";
 484     if ( code == TEA_HASH)
 485         return "tea";
 486     if ( code == R5_HASH)
 487         return "r5";
 488
 489     return "unknown";
 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 = (struct reiserfs_super_block *)(bh->b_data);
 495     int skipped, data_blocks;
 496     char *version;
 497
 498
 499     if (strncmp (rs->s_magic,  REISERFS_SUPER_MAGIC_STRING,
 500                  strlen ( REISERFS_SUPER_MAGIC_STRING)) == 0) {
 501         version = "3.5";
 502     } else if( strncmp (rs->s_magic,  REISER2FS_SUPER_MAGIC_STRING,
 503                         strlen ( REISER2FS_SUPER_MAGIC_STRING)) == 0) {
 504         version = "3.6";
 505     } else {
 506         return 1;
 507     }
 508
 509     printk ("%s\'s super block in block %ld\n======================\n",
 510             kdevname (bh->b_dev), bh->b_blocknr);
 511     printk ("Reiserfs version %s\n", version );
 512     printk ("Block count %u\n", sb_block_count(rs));
 513     printk ("Blocksize %d\n", sb_blocksize(rs));
 514     printk ("Free blocks %u\n", sb_free_blocks(rs));
 515     // FIXME: this would be confusing if
 516     // someone stores reiserfs super block in some data block ;)
 517 //    skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
 518     skipped = bh->b_blocknr;
 519     data_blocks = sb_block_count(rs) - skipped - 1 -
 520                   sb_bmap_nr(rs) - (sb_orig_journal_size(rs) + 1) -
 521                   sb_free_blocks(rs);
 522     printk ("Busy blocks (skipped %d, bitmaps - %d, journal blocks - %d\n"
 523             "1 super blocks, %d data blocks\n",
 524             skipped, sb_bmap_nr(rs),
 525             (sb_orig_journal_size(rs) + 1), data_blocks);
 526     printk ("Root block %u\n", sb_root_block(rs));
 527     printk ("Journal block (first) %d\n", sb_journal_block(rs));
 528     printk ("Journal dev %d\n", sb_journal_dev(rs));
 529     printk ("Journal orig size %d\n", sb_orig_journal_size(rs));
 530     printk ("Filesystem state %s\n",
 531             (sb_state(rs) == REISERFS_VALID_FS) ? "VALID" : "ERROR");
 532     printk ("Hash function \"%s\"\n",
 533             reiserfs_hashname(sb_hash_function_code(rs)));
 534
 535     printk ("Tree height %d\n", sb_tree_height(rs));
 536     return 0;
 537 }
 538
 539
 540 static int print_desc_block (struct buffer_head * bh)
 541 {
 542     struct reiserfs_journal_desc * desc;
 543
 544     desc = (struct reiserfs_journal_desc *)(bh->b_data);
 545     if (memcmp(desc->j_magic, JOURNAL_DESC_MAGIC, 8))
 546         return 1;
 547
 548     printk ("Desc block %lu (j_trans_id %d, j_mount_id %d, j_len %d)",
 549             bh->b_blocknr, desc->j_trans_id, desc->j_mount_id, desc->j_len);
 550
 551     return 0;
 552 }
 553
 554
 555 void print_block (struct buffer_head * bh, ...)//int print_mode, int first, int last)
 556 {
 557     va_list args;
 558     int mode, first, last;
 559
 560     va_start (args, bh);
 561
 562     if ( ! bh ) {
 563         printk("print_block: buffer is NULL\n");
 564         return;
 565     }
 566
 567     mode = va_arg (args, int);
 568     first = va_arg (args, int);
 569     last = va_arg (args, int);
 570     if (print_leaf (bh, mode, first, last))
 571         if (print_internal (bh, first, last))
 572             if (print_super_block (bh))
 573                 if (print_desc_block (bh))
 574                     printk ("Block %ld contains unformatted data\n", bh->b_blocknr);
 575 }
 576
 577
 578
 579 char print_tb_buf[2048];
 580
 581 /* this stores initial state of tree balance in the print_tb_buf */
 582 void store_print_tb (struct tree_balance * tb)
 583 {
 584     int h = 0;
 585     int i;
 586     struct buffer_head * tbSh, * tbFh;
 587
 588     if (!tb)
 589         return;
 590
 591     sprintf (print_tb_buf, "\n"
 592              "BALANCING %d\n"
 593              "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
 594              "=====================================================================\n"
 595              "* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n",
 596              tb->tb_sb->u.reiserfs_sb.s_do_balance,
 597              tb->tb_mode, PATH_LAST_POSITION (tb->tb_path), tb->tb_path->pos_in_item);
 598
 599     for (h = 0; h < sizeof(tb->insert_size) / sizeof (tb->insert_size[0]); h ++) {
 600         if (PATH_H_PATH_OFFSET (tb->tb_path, h) <= tb->tb_path->path_length &&
 601             PATH_H_PATH_OFFSET (tb->tb_path, h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
 602             tbSh = PATH_H_PBUFFER (tb->tb_path, h);
 603             tbFh = PATH_H_PPARENT (tb->tb_path, h);
 604         } else {
 605             tbSh = 0;
 606             tbFh = 0;
 607         }
 608         sprintf (print_tb_buf + strlen (print_tb_buf),
 609                  "* %d * %3ld(%2d) * %3ld(%2d) * %3ld(%2d) * %5ld * %5ld * %5ld * %5ld * %5ld *\n",
 610                  h,
 611                  (tbSh) ? (tbSh->b_blocknr):(-1),
 612                  (tbSh) ? atomic_read (&(tbSh->b_count)) : -1,
 613                  (tb->L[h]) ? (tb->L[h]->b_blocknr):(-1),
 614                  (tb->L[h]) ? atomic_read (&(tb->L[h]->b_count)) : -1,
 615                  (tb->R[h]) ? (tb->R[h]->b_blocknr):(-1),
 616                  (tb->R[h]) ? atomic_read (&(tb->R[h]->b_count)) : -1,
 617                  (tbFh) ? (tbFh->b_blocknr):(-1),
 618                  (tb->FL[h]) ? (tb->FL[h]->b_blocknr):(-1),
 619                  (tb->FR[h]) ? (tb->FR[h]->b_blocknr):(-1),
 620                  (tb->CFL[h]) ? (tb->CFL[h]->b_blocknr):(-1),
 621                  (tb->CFR[h]) ? (tb->CFR[h]->b_blocknr):(-1));
 622     }
 623
 624     sprintf (print_tb_buf + strlen (print_tb_buf),
 625              "=====================================================================\n"
 626              "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
 627              "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
 628              tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],tb->rbytes, tb->blknum[0],
 629              tb->s0num, tb->s1num,tb->s1bytes,  tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0], tb->rkey[0]);
 630
 631     /* this prints balance parameters for non-leaf levels */
 632     h = 0;
 633     do {
 634         h++;
 635         sprintf (print_tb_buf + strlen (print_tb_buf),
 636                  "* %d * %4d * %2d *    * %2d *    * %2d *\n",
 637                 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h], tb->blknum[h]);
 638     } while (tb->insert_size[h]);
 639
 640     sprintf (print_tb_buf + strlen (print_tb_buf),
 641              "=====================================================================\n"
 642              "FEB list: ");
 643
 644     /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
 645     h = 0;
 646     for (i = 0; i < sizeof (tb->FEB) / sizeof (tb->FEB[0]); i ++)
 647         sprintf (print_tb_buf + strlen (print_tb_buf),
 648                  "%p (%lu %d)%s", tb->FEB[i], tb->FEB[i] ? tb->FEB[i]->b_blocknr : 0,
 649                  tb->FEB[i] ? atomic_read (&(tb->FEB[i]->b_count)) : 0,
 650                  (i == sizeof (tb->FEB) / sizeof (tb->FEB[0]) - 1) ? "\n" : ", ");
 651
 652     sprintf (print_tb_buf + strlen (print_tb_buf),
 653              "======================== the end ====================================\n");
 654 }
 655
 656 void print_cur_tb (char * mes)
 657 {
 658     printk ("%s\n%s", mes, print_tb_buf);
 659 }
 660
 661 static void check_leaf_block_head (struct buffer_head * bh)
 662 {
 663   struct block_head * blkh;
 664   int nr;
 665
 666   blkh = B_BLK_HEAD (bh);
 667   nr = blkh_nr_item(blkh);
 668   if ( nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
 669     reiserfs_panic (0, "vs-6010: check_leaf_block_head: invalid item number %z", bh);
 670   if ( blkh_free_space(blkh) >
 671       bh->b_size - BLKH_SIZE - IH_SIZE * nr )
 672     reiserfs_panic (0, "vs-6020: check_leaf_block_head: invalid free space %z", bh);
 673
 674 }
 675
 676 static void check_internal_block_head (struct buffer_head * bh)
 677 {
 678     struct block_head * blkh;
 679
 680     blkh = B_BLK_HEAD (bh);
 681     if (!(B_LEVEL (bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL (bh) <= MAX_HEIGHT))
 682         reiserfs_panic (0, "vs-6025: check_internal_block_head: invalid level %z", bh);
 683
 684     if (B_NR_ITEMS (bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
 685         reiserfs_panic (0, "vs-6030: check_internal_block_head: invalid item number %z", bh);
 686
 687     if (B_FREE_SPACE (bh) !=
 688         bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS (bh) - DC_SIZE * (B_NR_ITEMS (bh) + 1))
 689         reiserfs_panic (0, "vs-6040: check_internal_block_head: invalid free space %z", bh);
 690
 691 }
 692
 693
 694 void check_leaf (struct buffer_head * bh)
 695 {
 696     int i;
 697     struct item_head * ih;
 698
 699     if (!bh)
 700         return;
 701     check_leaf_block_head (bh);
 702     for (i = 0, ih = B_N_PITEM_HEAD (bh, 0); i < B_NR_ITEMS (bh); i ++, ih ++)
 703         op_check_item (ih, B_I_PITEM (bh, ih));
 704 }
 705
 706
 707 void check_internal (struct buffer_head * bh)
 708 {
 709   if (!bh)
 710     return;
 711   check_internal_block_head (bh);
 712 }
 713
 714
 715 void print_statistics (struct super_block * s)
 716 {
 717
 718   /*
 719   printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
 720 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
 721           s->u.reiserfs_sb.s_do_balance, s->u.reiserfs_sb.s_fix_nodes,
 722           s->u.reiserfs_sb.s_bmaps, s->u.reiserfs_sb.s_bmaps_without_search,
 723           s->u.reiserfs_sb.s_direct2indirect, s->u.reiserfs_sb.s_indirect2direct);
 724   */
 725
 726 }