fs/reiserfs/prints.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
reiserfs_cpu_offset
le_offset
cpu_type
le_type
scnprintf_le_key
scnprintf_cpu_key
scnprintf_de_head
scnprintf_item_head
scnprintf_direntry
scnprintf_block_head
scnprintf_buffer_head
scnprintf_disk_child
is_there_reiserfs_struct
prepare_error_buf
__reiserfs_warning
reiserfs_info
reiserfs_printk
reiserfs_debug
__reiserfs_panic
__reiserfs_error
reiserfs_abort
print_internal
print_leaf
reiserfs_hashname
print_super_block
print_desc_block
print_block
store_print_tb
print_cur_tb
check_leaf_block_head
check_internal_block_head
check_leaf
check_internal
print_statistics
   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 int scnprintf_le_key(char *buf, size_t size, struct reiserfs_key *key)
  80 {
  81         if (key)
  82                 return scnprintf(buf, size, "[%d %d %s %s]",
  83                                  le32_to_cpu(key->k_dir_id),
  84                                  le32_to_cpu(key->k_objectid), le_offset(key),
  85                                  le_type(key));
  86         else
  87                 return scnprintf(buf, size, "[NULL]");
  88 }
  89 
  90 /* %K */
  91 static int scnprintf_cpu_key(char *buf, size_t size, struct cpu_key *key)
  92 {
  93         if (key)
  94                 return scnprintf(buf, size, "[%d %d %s %s]",
  95                                  key->on_disk_key.k_dir_id,
  96                                  key->on_disk_key.k_objectid,
  97                                  reiserfs_cpu_offset(key), cpu_type(key));
  98         else
  99                 return scnprintf(buf, size, "[NULL]");
 100 }
 101 
 102 static int scnprintf_de_head(char *buf, size_t size,
 103                              struct reiserfs_de_head *deh)
 104 {
 105         if (deh)
 106                 return scnprintf(buf, size,
 107                                  "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]",
 108                                  deh_offset(deh), deh_dir_id(deh),
 109                                  deh_objectid(deh), deh_location(deh),
 110                                  deh_state(deh));
 111         else
 112                 return scnprintf(buf, size, "[NULL]");
 113 
 114 }
 115 
 116 static int scnprintf_item_head(char *buf, size_t size, struct item_head *ih)
 117 {
 118         if (ih) {
 119                 char *p = buf;
 120                 char * const end = buf + size;
 121 
 122                 p += scnprintf(p, end - p, "%s",
 123                                (ih_version(ih) == KEY_FORMAT_3_6) ?
 124                                "*3.6* " : "*3.5*");
 125 
 126                 p += scnprintf_le_key(p, end - p, &ih->ih_key);
 127 
 128                 p += scnprintf(p, end - p,
 129                                ", item_len %d, item_location %d, free_space(entry_count) %d",
 130                                ih_item_len(ih), ih_location(ih),
 131                                ih_free_space(ih));
 132                 return p - buf;
 133         } else
 134                 return scnprintf(buf, size, "[NULL]");
 135 }
 136 
 137 static int scnprintf_direntry(char *buf, size_t size,
 138                               struct reiserfs_dir_entry *de)
 139 {
 140         char name[20];
 141 
 142         memcpy(name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen);
 143         name[de->de_namelen > 19 ? 19 : de->de_namelen] = 0;
 144         return scnprintf(buf, size, "\"%s\"==>[%d %d]",
 145                          name, de->de_dir_id, de->de_objectid);
 146 }
 147 
 148 static int scnprintf_block_head(char *buf, size_t size, struct buffer_head *bh)
 149 {
 150         return scnprintf(buf, size,
 151                          "level=%d, nr_items=%d, free_space=%d rdkey ",
 152                          B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh));
 153 }
 154 
 155 static int scnprintf_buffer_head(char *buf, size_t size, struct buffer_head *bh)
 156 {
 157         return scnprintf(buf, size,
 158                          "dev %pg, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
 159                          bh->b_bdev, bh->b_size,
 160                          (unsigned long long)bh->b_blocknr,
 161                          atomic_read(&(bh->b_count)),
 162                          bh->b_state, bh->b_page,
 163                          buffer_uptodate(bh) ? "UPTODATE" : "!UPTODATE",
 164                          buffer_dirty(bh) ? "DIRTY" : "CLEAN",
 165                          buffer_locked(bh) ? "LOCKED" : "UNLOCKED");
 166 }
 167 
 168 static int scnprintf_disk_child(char *buf, size_t size, struct disk_child *dc)
 169 {
 170         return scnprintf(buf, size, "[dc_number=%d, dc_size=%u]",
 171                          dc_block_number(dc), dc_size(dc));
 172 }
 173 
 174 static char *is_there_reiserfs_struct(char *fmt, int *what)
 175 {
 176         char *k = fmt;
 177 
 178         while ((k = strchr(k, '%')) != NULL) {
 179                 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
 180                     k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
 181                         *what = k[1];
 182                         break;
 183                 }
 184                 k++;
 185         }
 186         return k;
 187 }
 188 
 189 /*
 190  * debugging reiserfs we used to print out a lot of different
 191  * variables, like keys, item headers, buffer heads etc. Values of
 192  * most fields matter. So it took a long time just to write
 193  * appropriative printk. With this reiserfs_warning you can use format
 194  * specification for complex structures like you used to do with
 195  * printfs for integers, doubles and pointers. For instance, to print
 196  * out key structure you have to write just:
 197  * reiserfs_warning ("bad key %k", key);
 198  * instead of
 199  * printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
 200  *         key->k_offset, key->k_uniqueness);
 201  */
 202 static DEFINE_SPINLOCK(error_lock);
 203 static void prepare_error_buf(const char *fmt, va_list args)
 204 {
 205         char *fmt1 = fmt_buf;
 206         char *k;
 207         char *p = error_buf;
 208         char * const end = &error_buf[sizeof(error_buf)];
 209         int what;
 210 
 211         spin_lock(&error_lock);
 212 
 213         if (WARN_ON(strscpy(fmt_buf, fmt, sizeof(fmt_buf)) < 0)) {
 214                 strscpy(error_buf, "format string too long", end - error_buf);
 215                 goto out_unlock;
 216         }
 217 
 218         while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
 219                 *k = 0;
 220 
 221                 p += vscnprintf(p, end - p, fmt1, args);
 222 
 223                 switch (what) {
 224                 case 'k':
 225                         p += scnprintf_le_key(p, end - p,
 226                                               va_arg(args, struct reiserfs_key *));
 227                         break;
 228                 case 'K':
 229                         p += scnprintf_cpu_key(p, end - p,
 230                                                va_arg(args, struct cpu_key *));
 231                         break;
 232                 case 'h':
 233                         p += scnprintf_item_head(p, end - p,
 234                                                  va_arg(args, struct item_head *));
 235                         break;
 236                 case 't':
 237                         p += scnprintf_direntry(p, end - p,
 238                                                 va_arg(args, struct reiserfs_dir_entry *));
 239                         break;
 240                 case 'y':
 241                         p += scnprintf_disk_child(p, end - p,
 242                                                   va_arg(args, struct disk_child *));
 243                         break;
 244                 case 'z':
 245                         p += scnprintf_block_head(p, end - p,
 246                                                   va_arg(args, struct buffer_head *));
 247                         break;
 248                 case 'b':
 249                         p += scnprintf_buffer_head(p, end - p,
 250                                                    va_arg(args, struct buffer_head *));
 251                         break;
 252                 case 'a':
 253                         p += scnprintf_de_head(p, end - p,
 254                                                va_arg(args, struct reiserfs_de_head *));
 255                         break;
 256                 }
 257 
 258                 fmt1 = k + 2;
 259         }
 260         p += vscnprintf(p, end - p, fmt1, args);
 261 out_unlock:
 262         spin_unlock(&error_lock);
 263 
 264 }
 265 
 266 /*
 267  * in addition to usual conversion specifiers this accepts reiserfs
 268  * specific conversion specifiers:
 269  * %k to print little endian key,
 270  * %K to print cpu key,
 271  * %h to print item_head,
 272  * %t to print directory entry
 273  * %z to print block head (arg must be struct buffer_head *
 274  * %b to print buffer_head
 275  */
 276 
 277 #define do_reiserfs_warning(fmt)\
 278 {\
 279     va_list args;\
 280     va_start( args, fmt );\
 281     prepare_error_buf( fmt, args );\
 282     va_end( args );\
 283 }
 284 
 285 void __reiserfs_warning(struct super_block *sb, const char *id,
 286                          const char *function, const char *fmt, ...)
 287 {
 288         do_reiserfs_warning(fmt);
 289         if (sb)
 290                 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
 291                        "%s\n", sb->s_id, id ? id : "", id ? " " : "",
 292                        function, error_buf);
 293         else
 294                 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
 295                        id ? id : "", id ? " " : "", function, error_buf);
 296 }
 297 
 298 /* No newline.. reiserfs_info calls can be followed by printk's */
 299 void reiserfs_info(struct super_block *sb, const char *fmt, ...)
 300 {
 301         do_reiserfs_warning(fmt);
 302         if (sb)
 303                 printk(KERN_NOTICE "REISERFS (device %s): %s",
 304                        sb->s_id, error_buf);
 305         else
 306                 printk(KERN_NOTICE "REISERFS %s:", error_buf);
 307 }
 308 
 309 /* No newline.. reiserfs_printk calls can be followed by printk's */
 310 static void reiserfs_printk(const char *fmt, ...)
 311 {
 312         do_reiserfs_warning(fmt);
 313         printk(error_buf);
 314 }
 315 
 316 void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
 317 {
 318 #ifdef CONFIG_REISERFS_CHECK
 319         do_reiserfs_warning(fmt);
 320         if (s)
 321                 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
 322                        s->s_id, error_buf);
 323         else
 324                 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
 325 #endif
 326 }
 327 
 328 /*
 329  * The format:
 330  *
 331  *          maintainer-errorid: [function-name:] message
 332  *
 333  *   where errorid is unique to the maintainer and function-name is
 334  *   optional, is recommended, so that anyone can easily find the bug
 335  *   with a simple grep for the short to type string
 336  *   maintainer-errorid.  Don't bother with reusing errorids, there are
 337  *   lots of numbers out there.
 338  *
 339  *   Example:
 340  *
 341  *   reiserfs_panic(
 342  *     p_sb, "reiser-29: reiserfs_new_blocknrs: "
 343  *     "one of search_start or rn(%d) is equal to MAX_B_NUM,"
 344  *     "which means that we are optimizing location based on the "
 345  *     "bogus location of a temp buffer (%p).",
 346  *     rn, bh
 347  *   );
 348  *
 349  *   Regular panic()s sometimes clear the screen before the message can
 350  *   be read, thus the need for the while loop.
 351  *
 352  *   Numbering scheme for panic used by Vladimir and Anatoly( Hans completely
 353  *   ignores this scheme, and considers it pointless complexity):
 354  *
 355  *   panics in reiserfs_fs.h have numbers from 1000 to 1999
 356  *   super.c                    2000 to 2999
 357  *   preserve.c (unused)        3000 to 3999
 358  *   bitmap.c                   4000 to 4999
 359  *   stree.c                    5000 to 5999
 360  *   prints.c                   6000 to 6999
 361  *   namei.c                    7000 to 7999
 362  *   fix_nodes.c                8000 to 8999
 363  *   dir.c                      9000 to 9999
 364  *   lbalance.c                 10000 to 10999
 365  *   ibalance.c                 11000 to 11999 not ready
 366  *   do_balan.c                 12000 to 12999
 367  *   inode.c                    13000 to 13999
 368  *   file.c                     14000 to 14999
 369  *   objectid.c                 15000 - 15999
 370  *   buffer.c                   16000 - 16999
 371  *   symlink.c                  17000 - 17999
 372  *
 373  *  .  */
 374 
 375 void __reiserfs_panic(struct super_block *sb, const char *id,
 376                       const char *function, const char *fmt, ...)
 377 {
 378         do_reiserfs_warning(fmt);
 379 
 380 #ifdef CONFIG_REISERFS_CHECK
 381         dump_stack();
 382 #endif
 383         if (sb)
 384                 printk(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
 385                       sb->s_id, id ? id : "", id ? " " : "",
 386                       function, error_buf);
 387         else
 388                 printk(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
 389                       id ? id : "", id ? " " : "", function, error_buf);
 390         BUG();
 391 }
 392 
 393 void __reiserfs_error(struct super_block *sb, const char *id,
 394                       const char *function, const char *fmt, ...)
 395 {
 396         do_reiserfs_warning(fmt);
 397 
 398         BUG_ON(sb == NULL);
 399 
 400         if (reiserfs_error_panic(sb))
 401                 __reiserfs_panic(sb, id, function, error_buf);
 402 
 403         if (id && id[0])
 404                 printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
 405                        sb->s_id, id, function, error_buf);
 406         else
 407                 printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
 408                        sb->s_id, function, error_buf);
 409 
 410         if (sb_rdonly(sb))
 411                 return;
 412 
 413         reiserfs_info(sb, "Remounting filesystem read-only\n");
 414         sb->s_flags |= SB_RDONLY;
 415         reiserfs_abort_journal(sb, -EIO);
 416 }
 417 
 418 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
 419 {
 420         do_reiserfs_warning(fmt);
 421 
 422         if (reiserfs_error_panic(sb)) {
 423                 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
 424                       error_buf);
 425         }
 426 
 427         if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
 428                 return;
 429 
 430         printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
 431                error_buf);
 432 
 433         sb->s_flags |= SB_RDONLY;
 434         reiserfs_abort_journal(sb, errno);
 435 }
 436 
 437 /*
 438  * this prints internal nodes (4 keys/items in line) (dc_number,
 439  * dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
 440  * dc_size)...
 441  */
 442 static int print_internal(struct buffer_head *bh, int first, int last)
 443 {
 444         struct reiserfs_key *key;
 445         struct disk_child *dc;
 446         int i;
 447         int from, to;
 448 
 449         if (!B_IS_KEYS_LEVEL(bh))
 450                 return 1;
 451 
 452         check_internal(bh);
 453 
 454         if (first == -1) {
 455                 from = 0;
 456                 to = B_NR_ITEMS(bh);
 457         } else {
 458                 from = first;
 459                 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
 460         }
 461 
 462         reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
 463 
 464         dc = B_N_CHILD(bh, from);
 465         reiserfs_printk("PTR %d: %y ", from, dc);
 466 
 467         for (i = from, key = internal_key(bh, from), dc++; i < to;
 468              i++, key++, dc++) {
 469                 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
 470                 if (i && i % 4 == 0)
 471                         printk("\n");
 472         }
 473         printk("\n");
 474         return 0;
 475 }
 476 
 477 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
 478                       int last)
 479 {
 480         struct block_head *blkh;
 481         struct item_head *ih;
 482         int i, nr;
 483         int from, to;
 484 
 485         if (!B_IS_ITEMS_LEVEL(bh))
 486                 return 1;
 487 
 488         check_leaf(bh);
 489 
 490         blkh = B_BLK_HEAD(bh);
 491         ih = item_head(bh, 0);
 492         nr = blkh_nr_item(blkh);
 493 
 494         printk
 495             ("\n===================================================================\n");
 496         reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
 497 
 498         if (!(print_mode & PRINT_LEAF_ITEMS)) {
 499                 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
 500                                 &(ih->ih_key), &((ih + nr - 1)->ih_key));
 501                 return 0;
 502         }
 503 
 504         if (first < 0 || first > nr - 1)
 505                 from = 0;
 506         else
 507                 from = first;
 508 
 509         if (last < 0 || last > nr)
 510                 to = nr;
 511         else
 512                 to = last;
 513 
 514         ih += from;
 515         printk
 516             ("-------------------------------------------------------------------------------\n");
 517         printk
 518             ("|##|   type    |           key           | ilen | free_space | version | loc  |\n");
 519         for (i = from; i < to; i++, ih++) {
 520                 printk
 521                     ("-------------------------------------------------------------------------------\n");
 522                 reiserfs_printk("|%2d| %h |\n", i, ih);
 523                 if (print_mode & PRINT_LEAF_ITEMS)
 524                         op_print_item(ih, ih_item_body(bh, ih));
 525         }
 526 
 527         printk
 528             ("===================================================================\n");
 529 
 530         return 0;
 531 }
 532 
 533 char *reiserfs_hashname(int code)
 534 {
 535         if (code == YURA_HASH)
 536                 return "rupasov";
 537         if (code == TEA_HASH)
 538                 return "tea";
 539         if (code == R5_HASH)
 540                 return "r5";
 541 
 542         return "unknown";
 543 }
 544 
 545 /* return 1 if this is not super block */
 546 static int print_super_block(struct buffer_head *bh)
 547 {
 548         struct reiserfs_super_block *rs =
 549             (struct reiserfs_super_block *)(bh->b_data);
 550         int skipped, data_blocks;
 551         char *version;
 552 
 553         if (is_reiserfs_3_5(rs)) {
 554                 version = "3.5";
 555         } else if (is_reiserfs_3_6(rs)) {
 556                 version = "3.6";
 557         } else if (is_reiserfs_jr(rs)) {
 558                 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
 559                            "3.6" : "3.5");
 560         } else {
 561                 return 1;
 562         }
 563 
 564         printk("%pg\'s super block is in block %llu\n", bh->b_bdev,
 565                (unsigned long long)bh->b_blocknr);
 566         printk("Reiserfs version %s\n", version);
 567         printk("Block count %u\n", sb_block_count(rs));
 568         printk("Blocksize %d\n", sb_blocksize(rs));
 569         printk("Free blocks %u\n", sb_free_blocks(rs));
 570         /*
 571          * FIXME: this would be confusing if
 572          * someone stores reiserfs super block in some data block ;)
 573 //    skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
 574          */
 575         skipped = bh->b_blocknr;
 576         data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
 577             (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
 578              1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
 579         printk
 580             ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
 581              "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
 582              (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
 583               sb_reserved_for_journal(rs)), data_blocks);
 584         printk("Root block %u\n", sb_root_block(rs));
 585         printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
 586         printk("Journal dev %d\n", sb_jp_journal_dev(rs));
 587         printk("Journal orig size %d\n", sb_jp_journal_size(rs));
 588         printk("FS state %d\n", sb_fs_state(rs));
 589         printk("Hash function \"%s\"\n",
 590                reiserfs_hashname(sb_hash_function_code(rs)));
 591 
 592         printk("Tree height %d\n", sb_tree_height(rs));
 593         return 0;
 594 }
 595 
 596 static int print_desc_block(struct buffer_head *bh)
 597 {
 598         struct reiserfs_journal_desc *desc;
 599 
 600         if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
 601                 return 1;
 602 
 603         desc = (struct reiserfs_journal_desc *)(bh->b_data);
 604         printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
 605                (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
 606                get_desc_mount_id(desc), get_desc_trans_len(desc));
 607 
 608         return 0;
 609 }
 610 /* ..., int print_mode, int first, int last) */
 611 void print_block(struct buffer_head *bh, ...)
 612 {
 613         va_list args;
 614         int mode, first, last;
 615 
 616         if (!bh) {
 617                 printk("print_block: buffer is NULL\n");
 618                 return;
 619         }
 620 
 621         va_start(args, bh);
 622 
 623         mode = va_arg(args, int);
 624         first = va_arg(args, int);
 625         last = va_arg(args, int);
 626         if (print_leaf(bh, mode, first, last))
 627                 if (print_internal(bh, first, last))
 628                         if (print_super_block(bh))
 629                                 if (print_desc_block(bh))
 630                                         printk
 631                                             ("Block %llu contains unformatted data\n",
 632                                              (unsigned long long)bh->b_blocknr);
 633 
 634         va_end(args);
 635 }
 636 
 637 static char print_tb_buf[2048];
 638 
 639 /* this stores initial state of tree balance in the print_tb_buf */
 640 void store_print_tb(struct tree_balance *tb)
 641 {
 642         int h = 0;
 643         int i;
 644         struct buffer_head *tbSh, *tbFh;
 645 
 646         if (!tb)
 647                 return;
 648 
 649         sprintf(print_tb_buf, "\n"
 650                 "BALANCING %d\n"
 651                 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
 652                 "=====================================================================\n"
 653                 "* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n",
 654                 REISERFS_SB(tb->tb_sb)->s_do_balance,
 655                 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
 656                 tb->tb_path->pos_in_item);
 657 
 658         for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
 659                 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
 660                     tb->tb_path->path_length
 661                     && PATH_H_PATH_OFFSET(tb->tb_path,
 662                                           h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
 663                         tbSh = PATH_H_PBUFFER(tb->tb_path, h);
 664                         tbFh = PATH_H_PPARENT(tb->tb_path, h);
 665                 } else {
 666                         tbSh = NULL;
 667                         tbFh = NULL;
 668                 }
 669                 sprintf(print_tb_buf + strlen(print_tb_buf),
 670                         "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
 671                         h,
 672                         (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
 673                         (tbSh) ? atomic_read(&tbSh->b_count) : -1,
 674                         (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
 675                         (tb->L[h]) ? atomic_read(&tb->L[h]->b_count) : -1,
 676                         (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
 677                         (tb->R[h]) ? atomic_read(&tb->R[h]->b_count) : -1,
 678                         (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
 679                         (tb->FL[h]) ? (long long)(tb->FL[h]->
 680                                                   b_blocknr) : (-1LL),
 681                         (tb->FR[h]) ? (long long)(tb->FR[h]->
 682                                                   b_blocknr) : (-1LL),
 683                         (tb->CFL[h]) ? (long long)(tb->CFL[h]->
 684                                                    b_blocknr) : (-1LL),
 685                         (tb->CFR[h]) ? (long long)(tb->CFR[h]->
 686                                                    b_blocknr) : (-1LL));
 687         }
 688 
 689         sprintf(print_tb_buf + strlen(print_tb_buf),
 690                 "=====================================================================\n"
 691                 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
 692                 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
 693                 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
 694                 tb->rbytes, tb->blknum[0], tb->s0num, tb->snum[0],
 695                 tb->sbytes[0], tb->snum[1], tb->sbytes[1],
 696                 tb->cur_blknum, tb->lkey[0], tb->rkey[0]);
 697 
 698         /* this prints balance parameters for non-leaf levels */
 699         h = 0;
 700         do {
 701                 h++;
 702                 sprintf(print_tb_buf + strlen(print_tb_buf),
 703                         "* %d * %4d * %2d *    * %2d *    * %2d *\n",
 704                         h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
 705                         tb->blknum[h]);
 706         } while (tb->insert_size[h]);
 707 
 708         sprintf(print_tb_buf + strlen(print_tb_buf),
 709                 "=====================================================================\n"
 710                 "FEB list: ");
 711 
 712         /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
 713         h = 0;
 714         for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
 715                 sprintf(print_tb_buf + strlen(print_tb_buf),
 716                         "%p (%llu %d)%s", tb->FEB[i],
 717                         tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
 718                         b_blocknr : 0ULL,
 719                         tb->FEB[i] ? atomic_read(&tb->FEB[i]->b_count) : 0,
 720                         (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
 721 
 722         sprintf(print_tb_buf + strlen(print_tb_buf),
 723                 "======================== the end ====================================\n");
 724 }
 725 
 726 void print_cur_tb(char *mes)
 727 {
 728         printk("%s\n%s", mes, print_tb_buf);
 729 }
 730 
 731 static void check_leaf_block_head(struct buffer_head *bh)
 732 {
 733         struct block_head *blkh;
 734         int nr;
 735 
 736         blkh = B_BLK_HEAD(bh);
 737         nr = blkh_nr_item(blkh);
 738         if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
 739                 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
 740                                bh);
 741         if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
 742                 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
 743                                bh);
 744 
 745 }
 746 
 747 static void check_internal_block_head(struct buffer_head *bh)
 748 {
 749         if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
 750                 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
 751 
 752         if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
 753                 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
 754 
 755         if (B_FREE_SPACE(bh) !=
 756             bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
 757             DC_SIZE * (B_NR_ITEMS(bh) + 1))
 758                 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
 759 
 760 }
 761 
 762 void check_leaf(struct buffer_head *bh)
 763 {
 764         int i;
 765         struct item_head *ih;
 766 
 767         if (!bh)
 768                 return;
 769         check_leaf_block_head(bh);
 770         for (i = 0, ih = item_head(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
 771                 op_check_item(ih, ih_item_body(bh, ih));
 772 }
 773 
 774 void check_internal(struct buffer_head *bh)
 775 {
 776         if (!bh)
 777                 return;
 778         check_internal_block_head(bh);
 779 }
 780 
 781 void print_statistics(struct super_block *s)
 782 {
 783 
 784         /*
 785            printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
 786            bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
 787            REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
 788            REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
 789            REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
 790          */
 791 
 792 }
/* [<][>][^][v][top][bottom][index][help] */
root/fs/reiserfs/prints.c

DEFINITIONS
