2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
5 #include <linux/time.h>
7 #include <linux/reiserfs_fs.h>
8 #include <linux/string.h>
9 #include <linux/buffer_head.h>
13 static char error_buf[1024];
14 static char fmt_buf[1024];
15 static char off_buf[80];
17 static char *reiserfs_cpu_offset(struct cpu_key *key)
19 if (cpu_key_k_type(key) == TYPE_DIRENTRY)
20 sprintf(off_buf, "%Lu(%Lu)",
22 GET_HASH_VALUE(cpu_key_k_offset(key)),
24 GET_GENERATION_NUMBER(cpu_key_k_offset(key)));
26 sprintf(off_buf, "0x%Lx",
27 (unsigned long long)cpu_key_k_offset(key));
31 static char *le_offset(struct reiserfs_key *key)
35 version = le_key_version(key);
36 if (le_key_k_type(version, key) == TYPE_DIRENTRY)
37 sprintf(off_buf, "%Lu(%Lu)",
39 GET_HASH_VALUE(le_key_k_offset(version, key)),
41 GET_GENERATION_NUMBER(le_key_k_offset(version, key)));
43 sprintf(off_buf, "0x%Lx",
44 (unsigned long long)le_key_k_offset(version, key));
48 static char *cpu_type(struct cpu_key *key)
50 if (cpu_key_k_type(key) == TYPE_STAT_DATA)
52 if (cpu_key_k_type(key) == TYPE_DIRENTRY)
54 if (cpu_key_k_type(key) == TYPE_DIRECT)
56 if (cpu_key_k_type(key) == TYPE_INDIRECT)
61 static char *le_type(struct reiserfs_key *key)
65 version = le_key_version(key);
67 if (le_key_k_type(version, key) == TYPE_STAT_DATA)
69 if (le_key_k_type(version, key) == TYPE_DIRENTRY)
71 if (le_key_k_type(version, key) == TYPE_DIRECT)
73 if (le_key_k_type(version, key) == TYPE_INDIRECT)
79 static void sprintf_le_key(char *buf, struct reiserfs_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),
86 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)
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));
108 sprintf(buf, "[NULL]");
112 static void sprintf_item_head(char *buf, struct item_head *ih)
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));
122 sprintf(buf, "[NULL]");
125 static void sprintf_direntry(char *buf, struct reiserfs_dir_entry *de)
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);
134 static void sprintf_block_head(char *buf, struct buffer_head *bh)
136 sprintf(buf, "level=%d, nr_items=%d, free_space=%d rdkey ",
137 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];
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");
154 static void sprintf_disk_child(char *buf, struct disk_child *dc)
156 sprintf(buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc),
160 static char *is_there_reiserfs_struct(char *fmt, int *what, int *skip)
166 while ((k = strchr(k, '%')) != NULL) {
167 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
168 k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
178 /* debugging reiserfs we used to print out a lot of different
179 variables, like keys, item headers, buffer heads etc. Values of
180 most fields matter. So it took a long time just to write
181 appropriative printk. With this reiserfs_warning you can use format
182 specification for complex structures like you used to do with
183 printfs for integers, doubles and pointers. For instance, to print
184 out key structure you have to write just:
185 reiserfs_warning ("bad key %k", key);
187 printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
188 key->k_offset, key->k_uniqueness);
191 static void prepare_error_buf(const char *fmt, va_list args)
193 char *fmt1 = fmt_buf;
196 int i, j, what, skip;
200 while ((k = is_there_reiserfs_struct(fmt1, &what, &skip)) != NULL) {
203 p += vsprintf(p, fmt1, args);
205 for (i = 0; i < skip; i++)
206 j = va_arg(args, int);
210 sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
213 sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
216 sprintf_item_head(p, va_arg(args, struct item_head *));
221 struct reiserfs_dir_entry *));
224 sprintf_disk_child(p,
225 va_arg(args, struct disk_child *));
228 sprintf_block_head(p,
229 va_arg(args, struct buffer_head *));
232 sprintf_buffer_head(p,
233 va_arg(args, struct buffer_head *));
238 struct reiserfs_de_head *));
245 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(struct super_block *sb, const char *id,
268 const char *function, const char *fmt, ...)
270 do_reiserfs_warning(fmt);
272 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
273 "%s\n", sb->s_id, id ? id : "", id ? " " : "",
274 function, error_buf);
276 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
277 id ? id : "", id ? " " : "", function, error_buf);
280 /* No newline.. reiserfs_info calls can be followed by printk's */
281 void reiserfs_info(struct super_block *sb, const char *fmt, ...)
283 do_reiserfs_warning(fmt);
285 printk(KERN_NOTICE "REISERFS (device %s): %s",
286 sb->s_id, error_buf);
288 printk(KERN_NOTICE "REISERFS %s:", error_buf);
291 /* No newline.. reiserfs_printk calls can be followed by printk's */
292 static void reiserfs_printk(const char *fmt, ...)
294 do_reiserfs_warning(fmt);
298 void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
300 #ifdef CONFIG_REISERFS_CHECK
301 do_reiserfs_warning(fmt);
303 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
306 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
312 maintainer-errorid: [function-name:] message
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.
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 bogus location of a temp buffer (%p).",
329 Regular panic()s sometimes clear the screen before the message can
330 be read, thus the need for the while loop.
332 Numbering scheme for panic used by Vladimir and Anatoly( Hans completely ignores this scheme, and considers it
333 pointless complexity):
335 panics in reiserfs_fs.h have numbers from 1000 to 1999
337 preserve.c (unused) 3000 to 3999
338 bitmap.c 4000 to 4999
340 prints.c 6000 to 6999
342 fix_nodes.c 8000 to 8999
344 lbalance.c 10000 to 10999
345 ibalance.c 11000 to 11999 not ready
346 do_balan.c 12000 to 12999
347 inode.c 13000 to 13999
348 file.c 14000 to 14999
349 objectid.c 15000 - 15999
350 buffer.c 16000 - 16999
351 symlink.c 17000 - 17999
355 #ifdef CONFIG_REISERFS_CHECK
356 extern struct tree_balance *cur_tb;
359 void reiserfs_panic(struct super_block *sb, const char *fmt, ...)
361 do_reiserfs_warning(fmt);
365 panic(KERN_EMERG "REISERFS: panic (device %s): %s\n",
366 reiserfs_bdevname(sb), error_buf);
369 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
371 do_reiserfs_warning(fmt);
373 if (reiserfs_error_panic(sb)) {
374 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
378 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
381 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
384 sb->s_flags |= MS_RDONLY;
385 reiserfs_journal_abort(sb, errno);
388 /* this prints internal nodes (4 keys/items in line) (dc_number,
389 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
391 static int print_internal(struct buffer_head *bh, int first, int last)
393 struct reiserfs_key *key;
394 struct disk_child *dc;
398 if (!B_IS_KEYS_LEVEL(bh))
408 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
411 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
413 dc = B_N_CHILD(bh, from);
414 reiserfs_printk("PTR %d: %y ", from, dc);
416 for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
418 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
426 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
429 struct block_head *blkh;
430 struct item_head *ih;
434 if (!B_IS_ITEMS_LEVEL(bh))
439 blkh = B_BLK_HEAD(bh);
440 ih = B_N_PITEM_HEAD(bh, 0);
441 nr = blkh_nr_item(blkh);
444 ("\n===================================================================\n");
445 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
447 if (!(print_mode & PRINT_LEAF_ITEMS)) {
448 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
449 &(ih->ih_key), &((ih + nr - 1)->ih_key));
453 if (first < 0 || first > nr - 1)
458 if (last < 0 || last > nr)
465 ("-------------------------------------------------------------------------------\n");
467 ("|##| type | key | ilen | free_space | version | loc |\n");
468 for (i = from; i < to; i++, ih++) {
470 ("-------------------------------------------------------------------------------\n");
471 reiserfs_printk("|%2d| %h |\n", i, ih);
472 if (print_mode & PRINT_LEAF_ITEMS)
473 op_print_item(ih, B_I_PITEM(bh, ih));
477 ("===================================================================\n");
482 char *reiserfs_hashname(int code)
484 if (code == YURA_HASH)
486 if (code == TEA_HASH)
494 /* return 1 if this is not super block */
495 static int print_super_block(struct buffer_head *bh)
497 struct reiserfs_super_block *rs =
498 (struct reiserfs_super_block *)(bh->b_data);
499 int skipped, data_blocks;
501 char b[BDEVNAME_SIZE];
503 if (is_reiserfs_3_5(rs)) {
505 } else if (is_reiserfs_3_6(rs)) {
507 } else if (is_reiserfs_jr(rs)) {
508 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
514 printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
515 (unsigned long long)bh->b_blocknr);
516 printk("Reiserfs version %s\n", version);
517 printk("Block count %u\n", sb_block_count(rs));
518 printk("Blocksize %d\n", sb_blocksize(rs));
519 printk("Free blocks %u\n", sb_free_blocks(rs));
520 // FIXME: this would be confusing if
521 // someone stores reiserfs super block in some data block ;)
522 // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
523 skipped = bh->b_blocknr;
524 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
525 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
526 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
528 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
529 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
530 (!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),
554 get_desc_mount_id(desc), get_desc_trans_len(desc));
559 void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
562 int mode, first, last;
567 printk("print_block: buffer is NULL\n");
571 mode = va_arg(args, int);
572 first = va_arg(args, int);
573 last = va_arg(args, int);
574 if (print_leaf(bh, mode, first, last))
575 if (print_internal(bh, first, last))
576 if (print_super_block(bh))
577 if (print_desc_block(bh))
579 ("Block %llu contains unformatted data\n",
580 (unsigned long long)bh->b_blocknr);
585 static char print_tb_buf[2048];
587 /* this stores initial state of tree balance in the print_tb_buf */
588 void store_print_tb(struct tree_balance *tb)
592 struct buffer_head *tbSh, *tbFh;
597 sprintf(print_tb_buf, "\n"
599 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
600 "=====================================================================\n"
601 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
602 REISERFS_SB(tb->tb_sb)->s_do_balance,
603 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
604 tb->tb_path->pos_in_item);
606 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
607 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
608 tb->tb_path->path_length
609 && PATH_H_PATH_OFFSET(tb->tb_path,
610 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
611 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
612 tbFh = PATH_H_PPARENT(tb->tb_path, h);
617 sprintf(print_tb_buf + strlen(print_tb_buf),
618 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
620 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
621 (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
622 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
623 (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
624 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
625 (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
626 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
627 (tb->FL[h]) ? (long long)(tb->FL[h]->
629 (tb->FR[h]) ? (long long)(tb->FR[h]->
631 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
633 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
634 b_blocknr) : (-1LL));
637 sprintf(print_tb_buf + strlen(print_tb_buf),
638 "=====================================================================\n"
639 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
640 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
641 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
642 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
643 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
646 /* this prints balance parameters for non-leaf levels */
650 sprintf(print_tb_buf + strlen(print_tb_buf),
651 "* %d * %4d * %2d * * %2d * * %2d *\n",
652 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
654 } while (tb->insert_size[h]);
656 sprintf(print_tb_buf + strlen(print_tb_buf),
657 "=====================================================================\n"
660 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
662 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
663 sprintf(print_tb_buf + strlen(print_tb_buf),
664 "%p (%llu %d)%s", tb->FEB[i],
665 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
667 tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
668 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
670 sprintf(print_tb_buf + strlen(print_tb_buf),
671 "======================== the end ====================================\n");
674 void print_cur_tb(char *mes)
676 printk("%s\n%s", mes, print_tb_buf);
679 static void check_leaf_block_head(struct buffer_head *bh)
681 struct block_head *blkh;
684 blkh = B_BLK_HEAD(bh);
685 nr = blkh_nr_item(blkh);
686 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
688 "vs-6010: check_leaf_block_head: invalid item number %z",
690 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
692 "vs-6020: check_leaf_block_head: invalid free space %z",
697 static void check_internal_block_head(struct buffer_head *bh)
699 struct block_head *blkh;
701 blkh = B_BLK_HEAD(bh);
702 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
704 "vs-6025: check_internal_block_head: invalid level %z",
707 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
709 "vs-6030: check_internal_block_head: invalid item number %z",
712 if (B_FREE_SPACE(bh) !=
713 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
714 DC_SIZE * (B_NR_ITEMS(bh) + 1))
716 "vs-6040: check_internal_block_head: invalid free space %z",
721 void check_leaf(struct buffer_head *bh)
724 struct item_head *ih;
728 check_leaf_block_head(bh);
729 for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
730 op_check_item(ih, B_I_PITEM(bh, ih));
733 void check_internal(struct buffer_head *bh)
737 check_internal_block_head(bh);
740 void print_statistics(struct super_block *s)
744 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
745 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
746 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
747 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
748 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);