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)
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') {
175 /* debugging reiserfs we used to print out a lot of different
176 variables, like keys, item headers, buffer heads etc. Values of
177 most fields matter. So it took a long time just to write
178 appropriative printk. With this reiserfs_warning you can use format
179 specification for complex structures like you used to do with
180 printfs for integers, doubles and pointers. For instance, to print
181 out key structure you have to write just:
182 reiserfs_warning ("bad key %k", key);
184 printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
185 key->k_offset, key->k_uniqueness);
187 static DEFINE_SPINLOCK(error_lock);
188 static void prepare_error_buf(const char *fmt, va_list args)
190 char *fmt1 = fmt_buf;
195 spin_lock(&error_lock);
199 while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
202 p += vsprintf(p, fmt1, args);
206 sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
209 sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
212 sprintf_item_head(p, va_arg(args, struct item_head *));
217 struct reiserfs_dir_entry *));
220 sprintf_disk_child(p,
221 va_arg(args, struct disk_child *));
224 sprintf_block_head(p,
225 va_arg(args, struct buffer_head *));
228 sprintf_buffer_head(p,
229 va_arg(args, struct buffer_head *));
234 struct reiserfs_de_head *));
241 vsprintf(p, fmt1, args);
242 spin_unlock(&error_lock);
246 /* in addition to usual conversion specifiers this accepts reiserfs
247 specific conversion specifiers:
248 %k to print little endian key,
250 %h to print item_head,
251 %t to print directory entry
252 %z to print block head (arg must be struct buffer_head *
253 %b to print buffer_head
256 #define do_reiserfs_warning(fmt)\
259 va_start( args, fmt );\
260 prepare_error_buf( fmt, args );\
264 void __reiserfs_warning(struct super_block *sb, const char *id,
265 const char *function, const char *fmt, ...)
267 do_reiserfs_warning(fmt);
269 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
270 "%s\n", sb->s_id, id ? id : "", id ? " " : "",
271 function, error_buf);
273 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
274 id ? id : "", id ? " " : "", function, error_buf);
277 /* No newline.. reiserfs_info calls can be followed by printk's */
278 void reiserfs_info(struct super_block *sb, const char *fmt, ...)
280 do_reiserfs_warning(fmt);
282 printk(KERN_NOTICE "REISERFS (device %s): %s",
283 sb->s_id, error_buf);
285 printk(KERN_NOTICE "REISERFS %s:", error_buf);
288 /* No newline.. reiserfs_printk calls can be followed by printk's */
289 static void reiserfs_printk(const char *fmt, ...)
291 do_reiserfs_warning(fmt);
295 void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
297 #ifdef CONFIG_REISERFS_CHECK
298 do_reiserfs_warning(fmt);
300 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
303 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
309 maintainer-errorid: [function-name:] message
311 where errorid is unique to the maintainer and function-name is
312 optional, is recommended, so that anyone can easily find the bug
313 with a simple grep for the short to type string
314 maintainer-errorid. Don't bother with reusing errorids, there are
315 lots of numbers out there.
320 p_sb, "reiser-29: reiserfs_new_blocknrs: "
321 "one of search_start or rn(%d) is equal to MAX_B_NUM,"
322 "which means that we are optimizing location based on the bogus location of a temp buffer (%p).",
326 Regular panic()s sometimes clear the screen before the message can
327 be read, thus the need for the while loop.
329 Numbering scheme for panic used by Vladimir and Anatoly( Hans completely ignores this scheme, and considers it
330 pointless complexity):
332 panics in reiserfs_fs.h have numbers from 1000 to 1999
334 preserve.c (unused) 3000 to 3999
335 bitmap.c 4000 to 4999
337 prints.c 6000 to 6999
339 fix_nodes.c 8000 to 8999
341 lbalance.c 10000 to 10999
342 ibalance.c 11000 to 11999 not ready
343 do_balan.c 12000 to 12999
344 inode.c 13000 to 13999
345 file.c 14000 to 14999
346 objectid.c 15000 - 15999
347 buffer.c 16000 - 16999
348 symlink.c 17000 - 17999
352 #ifdef CONFIG_REISERFS_CHECK
353 extern struct tree_balance *cur_tb;
356 void __reiserfs_panic(struct super_block *sb, const char *id,
357 const char *function, const char *fmt, ...)
359 do_reiserfs_warning(fmt);
361 #ifdef CONFIG_REISERFS_CHECK
365 panic(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
366 sb->s_id, id ? id : "", id ? " " : "",
367 function, error_buf);
369 panic(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
370 id ? id : "", id ? " " : "", function, error_buf);
373 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
375 do_reiserfs_warning(fmt);
377 if (reiserfs_error_panic(sb)) {
378 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
382 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
385 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
388 sb->s_flags |= MS_RDONLY;
389 reiserfs_journal_abort(sb, errno);
392 /* this prints internal nodes (4 keys/items in line) (dc_number,
393 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
395 static int print_internal(struct buffer_head *bh, int first, int last)
397 struct reiserfs_key *key;
398 struct disk_child *dc;
402 if (!B_IS_KEYS_LEVEL(bh))
412 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
415 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
417 dc = B_N_CHILD(bh, from);
418 reiserfs_printk("PTR %d: %y ", from, dc);
420 for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
422 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
430 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
433 struct block_head *blkh;
434 struct item_head *ih;
438 if (!B_IS_ITEMS_LEVEL(bh))
443 blkh = B_BLK_HEAD(bh);
444 ih = B_N_PITEM_HEAD(bh, 0);
445 nr = blkh_nr_item(blkh);
448 ("\n===================================================================\n");
449 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
451 if (!(print_mode & PRINT_LEAF_ITEMS)) {
452 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
453 &(ih->ih_key), &((ih + nr - 1)->ih_key));
457 if (first < 0 || first > nr - 1)
462 if (last < 0 || last > nr)
469 ("-------------------------------------------------------------------------------\n");
471 ("|##| type | key | ilen | free_space | version | loc |\n");
472 for (i = from; i < to; i++, ih++) {
474 ("-------------------------------------------------------------------------------\n");
475 reiserfs_printk("|%2d| %h |\n", i, ih);
476 if (print_mode & PRINT_LEAF_ITEMS)
477 op_print_item(ih, B_I_PITEM(bh, ih));
481 ("===================================================================\n");
486 char *reiserfs_hashname(int code)
488 if (code == YURA_HASH)
490 if (code == TEA_HASH)
498 /* return 1 if this is not super block */
499 static int print_super_block(struct buffer_head *bh)
501 struct reiserfs_super_block *rs =
502 (struct reiserfs_super_block *)(bh->b_data);
503 int skipped, data_blocks;
505 char b[BDEVNAME_SIZE];
507 if (is_reiserfs_3_5(rs)) {
509 } else if (is_reiserfs_3_6(rs)) {
511 } else if (is_reiserfs_jr(rs)) {
512 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
518 printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
519 (unsigned long long)bh->b_blocknr);
520 printk("Reiserfs version %s\n", version);
521 printk("Block count %u\n", sb_block_count(rs));
522 printk("Blocksize %d\n", sb_blocksize(rs));
523 printk("Free blocks %u\n", sb_free_blocks(rs));
524 // FIXME: this would be confusing if
525 // someone stores reiserfs super block in some data block ;)
526 // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
527 skipped = bh->b_blocknr;
528 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
529 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
530 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
532 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
533 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
534 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
535 sb_reserved_for_journal(rs)), data_blocks);
536 printk("Root block %u\n", sb_root_block(rs));
537 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
538 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
539 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
540 printk("FS state %d\n", sb_fs_state(rs));
541 printk("Hash function \"%s\"\n",
542 reiserfs_hashname(sb_hash_function_code(rs)));
544 printk("Tree height %d\n", sb_tree_height(rs));
548 static int print_desc_block(struct buffer_head *bh)
550 struct reiserfs_journal_desc *desc;
552 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
555 desc = (struct reiserfs_journal_desc *)(bh->b_data);
556 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
557 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
558 get_desc_mount_id(desc), get_desc_trans_len(desc));
563 void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
566 int mode, first, last;
571 printk("print_block: buffer is NULL\n");
575 mode = va_arg(args, int);
576 first = va_arg(args, int);
577 last = va_arg(args, int);
578 if (print_leaf(bh, mode, first, last))
579 if (print_internal(bh, first, last))
580 if (print_super_block(bh))
581 if (print_desc_block(bh))
583 ("Block %llu contains unformatted data\n",
584 (unsigned long long)bh->b_blocknr);
589 static char print_tb_buf[2048];
591 /* this stores initial state of tree balance in the print_tb_buf */
592 void store_print_tb(struct tree_balance *tb)
596 struct buffer_head *tbSh, *tbFh;
601 sprintf(print_tb_buf, "\n"
603 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
604 "=====================================================================\n"
605 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
606 REISERFS_SB(tb->tb_sb)->s_do_balance,
607 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
608 tb->tb_path->pos_in_item);
610 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
611 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
612 tb->tb_path->path_length
613 && PATH_H_PATH_OFFSET(tb->tb_path,
614 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
615 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
616 tbFh = PATH_H_PPARENT(tb->tb_path, h);
621 sprintf(print_tb_buf + strlen(print_tb_buf),
622 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
624 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
625 (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
626 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
627 (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
628 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
629 (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
630 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
631 (tb->FL[h]) ? (long long)(tb->FL[h]->
633 (tb->FR[h]) ? (long long)(tb->FR[h]->
635 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
637 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
638 b_blocknr) : (-1LL));
641 sprintf(print_tb_buf + strlen(print_tb_buf),
642 "=====================================================================\n"
643 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
644 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
645 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
646 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
647 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
650 /* this prints balance parameters for non-leaf levels */
654 sprintf(print_tb_buf + strlen(print_tb_buf),
655 "* %d * %4d * %2d * * %2d * * %2d *\n",
656 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
658 } while (tb->insert_size[h]);
660 sprintf(print_tb_buf + strlen(print_tb_buf),
661 "=====================================================================\n"
664 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
666 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
667 sprintf(print_tb_buf + strlen(print_tb_buf),
668 "%p (%llu %d)%s", tb->FEB[i],
669 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
671 tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
672 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
674 sprintf(print_tb_buf + strlen(print_tb_buf),
675 "======================== the end ====================================\n");
678 void print_cur_tb(char *mes)
680 printk("%s\n%s", mes, print_tb_buf);
683 static void check_leaf_block_head(struct buffer_head *bh)
685 struct block_head *blkh;
688 blkh = B_BLK_HEAD(bh);
689 nr = blkh_nr_item(blkh);
690 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
691 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
693 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
694 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
699 static void check_internal_block_head(struct buffer_head *bh)
701 struct block_head *blkh;
703 blkh = B_BLK_HEAD(bh);
704 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
705 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
707 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
708 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
710 if (B_FREE_SPACE(bh) !=
711 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
712 DC_SIZE * (B_NR_ITEMS(bh) + 1))
713 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
717 void check_leaf(struct buffer_head *bh)
720 struct item_head *ih;
724 check_leaf_block_head(bh);
725 for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
726 op_check_item(ih, B_I_PITEM(bh, ih));
729 void check_internal(struct buffer_head *bh)
733 check_internal_block_head(bh);
736 void print_statistics(struct super_block *s)
740 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
741 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
742 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
743 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
744 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);