SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 *fmt, ...)
 360 {
 361         do_reiserfs_warning(fmt);
 362
 363         dump_stack();
 364
 365         panic(KERN_EMERG "REISERFS: panic (device %s): %s\n",
 366                reiserfs_bdevname(sb), error_buf);
 367 }
 368
 369 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
 370 {
 371         do_reiserfs_warning(fmt);
 372
 373         if (reiserfs_error_panic(sb)) {
 374                 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
 375                       error_buf);
 376         }
 377
 378         if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
 379                 return;
 380
 381         printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
 382                error_buf);
 383
 384         sb->s_flags |= MS_RDONLY;
 385         reiserfs_journal_abort(sb, errno);
 386 }
 387
 388 /* this prints internal nodes (4 keys/items in line) (dc_number,
 389    dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
 390    dc_size)...*/
 391 static int print_internal(struct buffer_head *bh, int first, int last)
 392 {
 393         struct reiserfs_key *key;
 394         struct disk_child *dc;
 395         int i;
 396         int from, to;
 397
 398         if (!B_IS_KEYS_LEVEL(bh))
 399                 return 1;
 400
 401         check_internal(bh);
 402
 403         if (first == -1) {
 404                 from = 0;
 405                 to = B_NR_ITEMS(bh);
 406         } else {
 407                 from = first;
 408                 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
 409         }
 410
 411         reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
 412
 413         dc = B_N_CHILD(bh, from);
 414         reiserfs_printk("PTR %d: %y ", from, dc);
 415
 416         for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
 417              i++, key++, dc++) {
 418                 reiserfs_printk("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 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
 427                       int last)
 428 {
 429         struct block_head *blkh;
 430         struct item_head *ih;
 431         int i, nr;
 432         int from, to;
 433
 434         if (!B_IS_ITEMS_LEVEL(bh))
 435                 return 1;
 436
 437         check_leaf(bh);
 438
 439         blkh = B_BLK_HEAD(bh);
 440         ih = B_N_PITEM_HEAD(bh, 0);
 441         nr = blkh_nr_item(blkh);
 442
 443         printk
 444             ("\n===================================================================\n");
 445         reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
 446
 447         if (!(print_mode & PRINT_LEAF_ITEMS)) {
 448                 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
 449                                 &(ih->ih_key), &((ih + nr - 1)->ih_key));
 450                 return 0;
 451         }
 452
 453         if (first < 0 || first > nr - 1)
 454                 from = 0;
 455         else
 456                 from = first;
 457
 458         if (last < 0 || last > nr)
 459                 to = nr;
 460         else
 461                 to = last;
 462
 463         ih += from;
 464         printk
 465             ("-------------------------------------------------------------------------------\n");
 466         printk
 467             ("|##|   type    |           key           | ilen | free_space | version | loc  |\n");
 468         for (i = from; i < to; i++, ih++) {
 469                 printk
 470                     ("-------------------------------------------------------------------------------\n");
 471                 reiserfs_printk("|%2d| %h |\n", i, ih);
 472                 if (print_mode & PRINT_LEAF_ITEMS)
 473                         op_print_item(ih, B_I_PITEM(bh, ih));
 474         }
 475
 476         printk
 477             ("===================================================================\n");
 478
 479         return 0;
 480 }
 481
 482 char *reiserfs_hashname(int code)
 483 {
 484         if (code == YURA_HASH)
 485                 return "rupasov";
 486         if (code == TEA_HASH)
 487                 return "tea";
 488         if (code == R5_HASH)
 489                 return "r5";
 490
 491         return "unknown";
 492 }
 493
 494 /* return 1 if this is not super block */
 495 static int print_super_block(struct buffer_head *bh)
 496 {
 497         struct reiserfs_super_block *rs =
 498             (struct reiserfs_super_block *)(bh->b_data);
 499         int skipped, data_blocks;
 500         char *version;
 501         char b[BDEVNAME_SIZE];
 502
 503         if (is_reiserfs_3_5(rs)) {
 504                 version = "3.5";
 505         } else if (is_reiserfs_3_6(rs)) {
 506                 version = "3.6";
 507         } else if (is_reiserfs_jr(rs)) {
 508                 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
 509                            "3.6" : "3.5");
 510         } else {
 511                 return 1;
 512         }
 513
 514         printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
 515                (unsigned long long)bh->b_blocknr);
 516         printk("Reiserfs version %s\n", version);
 517         printk("Block count %u\n", sb_block_count(rs));
 518         printk("Blocksize %d\n", sb_blocksize(rs));
 519         printk("Free blocks %u\n", sb_free_blocks(rs));
 520         // FIXME: this would be confusing if
 521         // someone stores reiserfs super block in some data block ;)
 522 //    skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
 523         skipped = bh->b_blocknr;
 524         data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
 525             (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
 526              1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
 527         printk
 528             ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
 529              "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
 530              (!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),
 554                get_desc_mount_id(desc), get_desc_trans_len(desc));
 555
 556         return 0;
 557 }
 558
 559 void print_block(struct buffer_head *bh, ...)   //int print_mode, int first, int last)
 560 {
 561         va_list args;
 562         int mode, first, last;
 563
 564         va_start(args, bh);
 565
 566         if (!bh) {
 567                 printk("print_block: buffer is NULL\n");
 568                 return;
 569         }
 570
 571         mode = va_arg(args, int);
 572         first = va_arg(args, int);
 573         last = va_arg(args, int);
 574         if (print_leaf(bh, mode, first, last))
 575                 if (print_internal(bh, first, last))
 576                         if (print_super_block(bh))
 577                                 if (print_desc_block(bh))
 578                                         printk
 579                                             ("Block %llu contains unformatted data\n",
 580                                              (unsigned long long)bh->b_blocknr);
 581
 582         va_end(args);
 583 }
 584
 585 static char print_tb_buf[2048];
 586
 587 /* this stores initial state of tree balance in the print_tb_buf */
 588 void store_print_tb(struct tree_balance *tb)
 589 {
 590         int h = 0;
 591         int i;
 592         struct buffer_head *tbSh, *tbFh;
 593
 594         if (!tb)
 595                 return;
 596
 597         sprintf(print_tb_buf, "\n"
 598                 "BALANCING %d\n"
 599                 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
 600                 "=====================================================================\n"
 601                 "* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n",
 602                 REISERFS_SB(tb->tb_sb)->s_do_balance,
 603                 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
 604                 tb->tb_path->pos_in_item);
 605
 606         for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
 607                 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
 608                     tb->tb_path->path_length
 609                     && PATH_H_PATH_OFFSET(tb->tb_path,
 610                                           h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
 611                         tbSh = PATH_H_PBUFFER(tb->tb_path, h);
 612                         tbFh = PATH_H_PPARENT(tb->tb_path, h);
 613                 } else {
 614                         tbSh = NULL;
 615                         tbFh = NULL;
 616                 }
 617                 sprintf(print_tb_buf + strlen(print_tb_buf),
 618                         "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
 619                         h,
 620                         (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
 621                         (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
 622                         (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
 623                         (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
 624                         (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
 625                         (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
 626                         (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
 627                         (tb->FL[h]) ? (long long)(tb->FL[h]->
 628                                                   b_blocknr) : (-1LL),
 629                         (tb->FR[h]) ? (long long)(tb->FR[h]->
 630                                                   b_blocknr) : (-1LL),
 631                         (tb->CFL[h]) ? (long long)(tb->CFL[h]->
 632                                                    b_blocknr) : (-1LL),
 633                         (tb->CFR[h]) ? (long long)(tb->CFR[h]->
 634                                                    b_blocknr) : (-1LL));
 635         }
 636
 637         sprintf(print_tb_buf + strlen(print_tb_buf),
 638                 "=====================================================================\n"
 639                 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
 640                 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
 641                 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
 642                 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
 643                 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
 644                 tb->rkey[0]);
 645
 646         /* this prints balance parameters for non-leaf levels */
 647         h = 0;
 648         do {
 649                 h++;
 650                 sprintf(print_tb_buf + strlen(print_tb_buf),
 651                         "* %d * %4d * %2d *    * %2d *    * %2d *\n",
 652                         h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
 653                         tb->blknum[h]);
 654         } while (tb->insert_size[h]);
 655
 656         sprintf(print_tb_buf + strlen(print_tb_buf),
 657                 "=====================================================================\n"
 658                 "FEB list: ");
 659
 660         /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
 661         h = 0;
 662         for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
 663                 sprintf(print_tb_buf + strlen(print_tb_buf),
 664                         "%p (%llu %d)%s", tb->FEB[i],
 665                         tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
 666                         b_blocknr : 0ULL,
 667                         tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
 668                         (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
 669
 670         sprintf(print_tb_buf + strlen(print_tb_buf),
 671                 "======================== the end ====================================\n");
 672 }
 673
 674 void print_cur_tb(char *mes)
 675 {
 676         printk("%s\n%s", mes, print_tb_buf);
 677 }
 678
 679 static void check_leaf_block_head(struct buffer_head *bh)
 680 {
 681         struct block_head *blkh;
 682         int nr;
 683
 684         blkh = B_BLK_HEAD(bh);
 685         nr = blkh_nr_item(blkh);
 686         if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
 687                 reiserfs_panic(NULL,
 688                                "vs-6010: check_leaf_block_head: invalid item number %z",
 689                                bh);
 690         if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
 691                 reiserfs_panic(NULL,
 692                                "vs-6020: check_leaf_block_head: invalid free space %z",
 693                                bh);
 694
 695 }
 696
 697 static void check_internal_block_head(struct buffer_head *bh)
 698 {
 699         struct block_head *blkh;
 700
 701         blkh = B_BLK_HEAD(bh);
 702         if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
 703                 reiserfs_panic(NULL,
 704                                "vs-6025: check_internal_block_head: invalid level %z",
 705                                bh);
 706
 707         if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
 708                 reiserfs_panic(NULL,
 709                                "vs-6030: check_internal_block_head: invalid item number %z",
 710                                bh);
 711
 712         if (B_FREE_SPACE(bh) !=
 713             bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
 714             DC_SIZE * (B_NR_ITEMS(bh) + 1))
 715                 reiserfs_panic(NULL,
 716                                "vs-6040: check_internal_block_head: invalid free space %z",
 717                                bh);
 718
 719 }
 720
 721 void check_leaf(struct buffer_head *bh)
 722 {
 723         int i;
 724         struct item_head *ih;
 725
 726         if (!bh)
 727                 return;
 728         check_leaf_block_head(bh);
 729         for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
 730                 op_check_item(ih, B_I_PITEM(bh, ih));
 731 }
 732
 733 void check_internal(struct buffer_head *bh)
 734 {
 735         if (!bh)
 736                 return;
 737         check_internal_block_head(bh);
 738 }
 739
 740 void print_statistics(struct super_block *s)
 741 {
 742
 743         /*
 744            printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
 745            bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
 746            REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
 747            REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
 748            REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
 749          */
 750
 751 }