fs/reiserfs/prints.c

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