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