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 } 778