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