2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
5 #include <linux/config.h>
6 #include <linux/time.h>
8 #include <linux/reiserfs_fs.h>
9 #include <linux/string.h>
10 #include <linux/buffer_head.h>
14 static char error_buf[1024];
15 static char fmt_buf[1024];
16 static char off_buf[80];
19 static char * reiserfs_cpu_offset (struct cpu_key * key)
21 if (cpu_key_k_type(key) == TYPE_DIRENTRY)
22 sprintf (off_buf, "%Lu(%Lu)",
23 (unsigned long long)GET_HASH_VALUE (cpu_key_k_offset (key)),
24 (unsigned long long)GET_GENERATION_NUMBER (cpu_key_k_offset (key)));
26 sprintf (off_buf, "0x%Lx", (unsigned long long)cpu_key_k_offset (key));
31 static char * le_offset (struct key * key)
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)GET_HASH_VALUE (le_key_k_offset (version, key)),
39 (unsigned long long)GET_GENERATION_NUMBER (le_key_k_offset (version, key)));
41 sprintf (off_buf, "0x%Lx", (unsigned long long)le_key_k_offset (version, key));
46 static char * cpu_type (struct cpu_key * key)
48 if (cpu_key_k_type (key) == TYPE_STAT_DATA)
50 if (cpu_key_k_type (key) == TYPE_DIRENTRY)
52 if (cpu_key_k_type (key) == TYPE_DIRECT)
54 if (cpu_key_k_type (key) == TYPE_INDIRECT)
60 static char * le_type (struct key * key)
64 version = le_key_version (key);
66 if (le_key_k_type (version, key) == TYPE_STAT_DATA)
68 if (le_key_k_type (version, key) == TYPE_DIRENTRY)
70 if (le_key_k_type (version, key) == TYPE_DIRECT)
72 if (le_key_k_type (version, key) == TYPE_INDIRECT)
79 static void sprintf_le_key (char * buf, struct key * 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), le_type (key));
85 sprintf (buf, "[NULL]");
90 static void sprintf_cpu_key (char * buf, struct cpu_key * 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),
97 sprintf (buf, "[NULL]");
100 static void sprintf_de_head( char *buf, struct reiserfs_de_head *deh )
103 sprintf( buf, "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]", deh_offset(deh), deh_dir_id(deh),
104 deh_objectid(deh), deh_location(deh), deh_state(deh) );
106 sprintf( buf, "[NULL]" );
110 static void sprintf_item_head (char * buf, struct item_head * ih)
113 strcpy (buf, (ih_version (ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*");
114 sprintf_le_key (buf + strlen (buf), &(ih->ih_key));
115 sprintf (buf + strlen (buf), ", item_len %d, item_location %d, "
116 "free_space(entry_count) %d",
117 ih_item_len(ih), ih_location(ih), ih_free_space (ih));
119 sprintf (buf, "[NULL]");
123 static void sprintf_direntry (char * buf, struct reiserfs_dir_entry * de)
127 memcpy (name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen);
128 name [de->de_namelen > 19 ? 19 : de->de_namelen] = 0;
129 sprintf (buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid);
133 static void sprintf_block_head (char * buf, struct buffer_head * bh)
135 sprintf (buf, "level=%d, nr_items=%d, free_space=%d rdkey ",
136 B_LEVEL (bh), B_NR_ITEMS (bh), B_FREE_SPACE (bh));
140 static void sprintf_buffer_head (char * buf, struct buffer_head * bh)
142 char b[BDEVNAME_SIZE];
144 sprintf (buf, "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
145 bdevname (bh->b_bdev, b), bh->b_size,
146 (unsigned long long)bh->b_blocknr,
147 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");
155 static void sprintf_disk_child (char * buf, struct disk_child * dc)
157 sprintf (buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc), dc_size(dc));
161 static char * is_there_reiserfs_struct (char * fmt, int * what, int * skip)
167 while ((k = strchr (k, '%')) != NULL)
169 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
170 k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a' ) {
181 /* debugging reiserfs we used to print out a lot of different
182 variables, like keys, item headers, buffer heads etc. Values of
183 most fields matter. So it took a long time just to write
184 appropriative printk. With this reiserfs_warning you can use format
185 specification for complex structures like you used to do with
186 printfs for integers, doubles and pointers. For instance, to print
187 out key structure you have to write just:
188 reiserfs_warning ("bad key %k", key);
190 printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
191 key->k_offset, key->k_uniqueness);
196 prepare_error_buf( const char *fmt, va_list args )
198 char * fmt1 = fmt_buf;
200 char * p = error_buf;
201 int i, j, what, skip;
205 while( (k = is_there_reiserfs_struct( fmt1, &what, &skip )) != NULL )
209 p += vsprintf (p, fmt1, args);
211 for (i = 0; i < skip; i ++)
212 j = va_arg (args, int);
216 sprintf_le_key (p, va_arg(args, struct key *));
219 sprintf_cpu_key (p, va_arg(args, struct cpu_key *));
222 sprintf_item_head (p, va_arg(args, struct item_head *));
225 sprintf_direntry (p, va_arg(args, struct reiserfs_dir_entry *));
228 sprintf_disk_child (p, va_arg(args, struct disk_child *));
231 sprintf_block_head (p, va_arg(args, struct buffer_head *));
234 sprintf_buffer_head (p, va_arg(args, struct buffer_head *));
237 sprintf_de_head (p, va_arg(args, struct reiserfs_de_head *));
244 vsprintf (p, fmt1, args);
249 /* in addition to usual conversion specifiers this accepts reiserfs
250 specific conversion specifiers:
251 %k to print little endian 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
259 #define do_reiserfs_warning(fmt)\
262 va_start( args, fmt );\
263 prepare_error_buf( fmt, args );\
267 void reiserfs_warning (const char * fmt, ...)
269 do_reiserfs_warning(fmt);
270 /* console_print (error_buf); */
271 printk (KERN_WARNING "%s", error_buf);
274 void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...)
276 #ifdef CONFIG_REISERFS_CHECK
277 do_reiserfs_warning(fmt);
278 printk (KERN_DEBUG "%s", error_buf);
286 maintainer-errorid: [function-name:] message
288 where errorid is unique to the maintainer and function-name is
289 optional, is recommended, so that anyone can easily find the bug
290 with a simple grep for the short to type string
291 maintainer-errorid. Don't bother with reusing errorids, there are
292 lots of numbers out there.
297 p_sb, "reiser-29: reiserfs_new_blocknrs: "
298 "one of search_start or rn(%d) is equal to MAX_B_NUM,"
299 "which means that we are optimizing location based on the bogus location of a temp buffer (%p).",
303 Regular panic()s sometimes clear the screen before the message can
304 be read, thus the need for the while loop.
306 Numbering scheme for panic used by Vladimir and Anatoly( Hans completely ignores this scheme, and considers it
307 pointless complexity):
309 panics in reiserfs_fs.h have numbers from 1000 to 1999
311 preserve.c (unused) 3000 to 3999
312 bitmap.c 4000 to 4999
314 prints.c 6000 to 6999
316 fix_nodes.c 8000 to 8999
318 lbalance.c 10000 to 10999
319 ibalance.c 11000 to 11999 not ready
320 do_balan.c 12000 to 12999
321 inode.c 13000 to 13999
322 file.c 14000 to 14999
323 objectid.c 15000 - 15999
324 buffer.c 16000 - 16999
325 symlink.c 17000 - 17999
330 #ifdef CONFIG_REISERFS_CHECK
331 extern struct tree_balance * cur_tb;
334 void reiserfs_panic (struct super_block * sb, const char * fmt, ...)
336 do_reiserfs_warning(fmt);
337 printk ( KERN_EMERG "%s", error_buf);
340 /* this is not actually called, but makes reiserfs_panic() "noreturn" */
341 panic ("REISERFS: panic (device %s): %s\n",
342 reiserfs_bdevname (sb), error_buf);
346 void print_virtual_node (struct virtual_node * vn)
349 struct virtual_item * vi;
351 printk ("VIRTUAL NODE CONTAINS %d items, has size %d,%s,%s, ITEM_POS=%d POS_IN_ITEM=%d MODE=\'%c\'\n",
352 vn->vn_nr_item, vn->vn_size,
353 (vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE )? "left mergeable" : "",
354 (vn->vn_vi[vn->vn_nr_item - 1].vi_type & VI_TYPE_RIGHT_MERGEABLE) ? "right mergeable" : "",
355 vn->vn_affected_item_num, vn->vn_pos_in_item, vn->vn_mode);
358 for (i = 0; i < vn->vn_nr_item; i ++, vi ++)
364 void print_path (struct tree_balance * tb, struct path * path)
367 struct buffer_head * bh;
370 while (tb->insert_size[h]) {
371 bh = PATH_H_PBUFFER (path, h);
372 printk ("block %llu (level=%d), position %d\n", bh ? (unsigned long long)bh->b_blocknr : 0LL,
373 bh ? B_LEVEL (bh) : 0, PATH_H_POSITION (path, h));
377 int offset = path->path_length;
378 struct buffer_head * bh;
379 printk ("Offset Bh (b_blocknr, b_count) Position Nr_item\n");
380 while ( offset > ILLEGAL_PATH_ELEMENT_OFFSET ) {
381 bh = PATH_OFFSET_PBUFFER (path, offset);
382 printk ("%6d %10p (%9llu, %7d) %8d %7d\n", offset,
383 bh, bh ? (unsigned long long)bh->b_blocknr : 0LL, bh ? atomic_read (&(bh->b_count)) : 0,
384 PATH_OFFSET_POSITION (path, offset), bh ? B_NR_ITEMS (bh) : -1);
393 /* this prints internal nodes (4 keys/items in line) (dc_number,
394 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
396 static int print_internal (struct buffer_head * bh, int first, int last)
399 struct disk_child * dc;
403 if (!B_IS_KEYS_LEVEL (bh))
410 to = B_NR_ITEMS (bh);
413 to = last < B_NR_ITEMS (bh) ? last : B_NR_ITEMS (bh);
416 reiserfs_warning ("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
418 dc = B_N_CHILD (bh, from);
419 reiserfs_warning ("PTR %d: %y ", from, dc);
421 for (i = from, key = B_N_PDELIM_KEY (bh, from), dc ++; i < to; i ++, key ++, dc ++) {
422 reiserfs_warning ("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
434 static int print_leaf (struct buffer_head * bh, int print_mode, int first, int last)
436 struct block_head * blkh;
437 struct item_head * ih;
441 if (!B_IS_ITEMS_LEVEL (bh))
446 blkh = B_BLK_HEAD (bh);
447 ih = B_N_PITEM_HEAD (bh,0);
448 nr = blkh_nr_item(blkh);
450 printk ("\n===================================================================\n");
451 reiserfs_warning ("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
453 if (!(print_mode & PRINT_LEAF_ITEMS)) {
454 reiserfs_warning ("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
455 &(ih->ih_key), &((ih + nr - 1)->ih_key));
459 if (first < 0 || first > nr - 1)
464 if (last < 0 || last > nr )
470 printk ("-------------------------------------------------------------------------------\n");
471 printk ("|##| type | key | ilen | free_space | version | loc |\n");
472 for (i = from; i < to; i++, ih ++) {
473 printk ("-------------------------------------------------------------------------------\n");
474 reiserfs_warning ("|%2d| %h |\n", i, ih);
475 if (print_mode & PRINT_LEAF_ITEMS)
476 op_print_item (ih, B_I_PITEM (bh, ih));
479 printk ("===================================================================\n");
484 char * reiserfs_hashname(int code)
486 if ( code == YURA_HASH)
488 if ( code == TEA_HASH)
490 if ( code == R5_HASH)
496 /* return 1 if this is not super block */
497 static int print_super_block (struct buffer_head * bh)
499 struct reiserfs_super_block * rs = (struct reiserfs_super_block *)(bh->b_data);
500 int skipped, data_blocks;
502 char b[BDEVNAME_SIZE];
504 if (is_reiserfs_3_5(rs)) {
506 } else if (is_reiserfs_3_6(rs)) {
508 } else if (is_reiserfs_jr(rs)) {
509 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
515 printk ("%s\'s super block is in block %llu\n", bdevname (bh->b_bdev, b),
516 (unsigned long long)bh->b_blocknr);
517 printk ("Reiserfs version %s\n", version );
518 printk ("Block count %u\n", sb_block_count(rs));
519 printk ("Blocksize %d\n", sb_blocksize(rs));
520 printk ("Free blocks %u\n", sb_free_blocks(rs));
521 // FIXME: this would be confusing if
522 // someone stores reiserfs super block in some data block ;)
523 // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
524 skipped = bh->b_blocknr;
525 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
526 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) + 1 : sb_reserved_for_journal(rs)) -
528 printk ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
529 "1 super block, %d data blocks\n",
530 skipped, sb_bmap_nr(rs), (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
531 sb_reserved_for_journal(rs)) , data_blocks);
532 printk ("Root block %u\n", sb_root_block(rs));
533 printk ("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
534 printk ("Journal dev %d\n", sb_jp_journal_dev(rs));
535 printk ("Journal orig size %d\n", sb_jp_journal_size(rs));
536 printk ("FS state %d\n", sb_fs_state(rs));
537 printk ("Hash function \"%s\"\n",
538 reiserfs_hashname(sb_hash_function_code(rs)));
540 printk ("Tree height %d\n", sb_tree_height(rs));
544 static int print_desc_block (struct buffer_head * bh)
546 struct reiserfs_journal_desc * desc;
548 if (memcmp(get_journal_desc_magic (bh), JOURNAL_DESC_MAGIC, 8))
551 desc = (struct reiserfs_journal_desc *)(bh->b_data);
552 printk ("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
553 (unsigned long long)bh->b_blocknr, get_desc_trans_id (desc), get_desc_mount_id (desc),
554 get_desc_trans_len (desc));
560 void print_block (struct buffer_head * bh, ...)//int print_mode, int first, int last)
563 int mode, first, last;
568 printk("print_block: buffer is NULL\n");
572 mode = va_arg (args, int);
573 first = va_arg (args, int);
574 last = va_arg (args, int);
575 if (print_leaf (bh, mode, first, last))
576 if (print_internal (bh, first, last))
577 if (print_super_block (bh))
578 if (print_desc_block (bh))
579 printk ("Block %llu contains unformatted data\n", (unsigned long long)bh->b_blocknr);
584 char print_tb_buf[2048];
586 /* this stores initial state of tree balance in the print_tb_buf */
587 void store_print_tb (struct tree_balance * tb)
591 struct buffer_head * tbSh, * tbFh;
596 sprintf (print_tb_buf, "\n"
598 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
599 "=====================================================================\n"
600 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
601 REISERFS_SB(tb->tb_sb)->s_do_balance,
602 tb->tb_mode, PATH_LAST_POSITION (tb->tb_path), tb->tb_path->pos_in_item);
604 for (h = 0; h < sizeof(tb->insert_size) / sizeof (tb->insert_size[0]); h ++) {
605 if (PATH_H_PATH_OFFSET (tb->tb_path, h) <= tb->tb_path->path_length &&
606 PATH_H_PATH_OFFSET (tb->tb_path, h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
607 tbSh = PATH_H_PBUFFER (tb->tb_path, h);
608 tbFh = PATH_H_PPARENT (tb->tb_path, h);
613 sprintf (print_tb_buf + strlen (print_tb_buf),
614 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
616 (tbSh) ? (long long)(tbSh->b_blocknr):(-1LL),
617 (tbSh) ? atomic_read (&(tbSh->b_count)) : -1,
618 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr):(-1LL),
619 (tb->L[h]) ? atomic_read (&(tb->L[h]->b_count)) : -1,
620 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr):(-1LL),
621 (tb->R[h]) ? atomic_read (&(tb->R[h]->b_count)) : -1,
622 (tbFh) ? (long long)(tbFh->b_blocknr):(-1LL),
623 (tb->FL[h]) ? (long long)(tb->FL[h]->b_blocknr):(-1LL),
624 (tb->FR[h]) ? (long long)(tb->FR[h]->b_blocknr):(-1LL),
625 (tb->CFL[h]) ? (long long)(tb->CFL[h]->b_blocknr):(-1LL),
626 (tb->CFR[h]) ? (long long)(tb->CFR[h]->b_blocknr):(-1LL));
629 sprintf (print_tb_buf + strlen (print_tb_buf),
630 "=====================================================================\n"
631 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
632 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
633 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],tb->rbytes, tb->blknum[0],
634 tb->s0num, tb->s1num,tb->s1bytes, tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0], tb->rkey[0]);
636 /* this prints balance parameters for non-leaf levels */
640 sprintf (print_tb_buf + strlen (print_tb_buf),
641 "* %d * %4d * %2d * * %2d * * %2d *\n",
642 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h], tb->blknum[h]);
643 } while (tb->insert_size[h]);
645 sprintf (print_tb_buf + strlen (print_tb_buf),
646 "=====================================================================\n"
649 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
651 for (i = 0; i < sizeof (tb->FEB) / sizeof (tb->FEB[0]); i ++)
652 sprintf (print_tb_buf + strlen (print_tb_buf),
653 "%p (%llu %d)%s", tb->FEB[i], tb->FEB[i] ? (unsigned long long)tb->FEB[i]->b_blocknr : 0ULL,
654 tb->FEB[i] ? atomic_read (&(tb->FEB[i]->b_count)) : 0,
655 (i == sizeof (tb->FEB) / sizeof (tb->FEB[0]) - 1) ? "\n" : ", ");
657 sprintf (print_tb_buf + strlen (print_tb_buf),
658 "======================== the end ====================================\n");
661 void print_cur_tb (char * mes)
663 printk ("%s\n%s", mes, print_tb_buf);
666 static void check_leaf_block_head (struct buffer_head * bh)
668 struct block_head * blkh;
671 blkh = B_BLK_HEAD (bh);
672 nr = blkh_nr_item(blkh);
673 if ( nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
674 reiserfs_panic (0, "vs-6010: check_leaf_block_head: invalid item number %z", bh);
675 if ( blkh_free_space(blkh) >
676 bh->b_size - BLKH_SIZE - IH_SIZE * nr )
677 reiserfs_panic (0, "vs-6020: check_leaf_block_head: invalid free space %z", bh);
681 static void check_internal_block_head (struct buffer_head * bh)
683 struct block_head * blkh;
685 blkh = B_BLK_HEAD (bh);
686 if (!(B_LEVEL (bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL (bh) <= MAX_HEIGHT))
687 reiserfs_panic (0, "vs-6025: check_internal_block_head: invalid level %z", bh);
689 if (B_NR_ITEMS (bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
690 reiserfs_panic (0, "vs-6030: check_internal_block_head: invalid item number %z", bh);
692 if (B_FREE_SPACE (bh) !=
693 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS (bh) - DC_SIZE * (B_NR_ITEMS (bh) + 1))
694 reiserfs_panic (0, "vs-6040: check_internal_block_head: invalid free space %z", bh);
699 void check_leaf (struct buffer_head * bh)
702 struct item_head * ih;
706 check_leaf_block_head (bh);
707 for (i = 0, ih = B_N_PITEM_HEAD (bh, 0); i < B_NR_ITEMS (bh); i ++, ih ++)
708 op_check_item (ih, B_I_PITEM (bh, ih));
712 void check_internal (struct buffer_head * bh)
716 check_internal_block_head (bh);
720 void print_statistics (struct super_block * s)
724 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
725 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
726 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
727 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
728 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);