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);
188 static void prepare_error_buf(const char *fmt, va_list args)
190 char *fmt1 = fmt_buf;
197 while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
200 p += vsprintf(p, fmt1, args);
204 sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
207 sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
210 sprintf_item_head(p, va_arg(args, struct item_head *));
215 struct reiserfs_dir_entry *));
218 sprintf_disk_child(p,
219 va_arg(args, struct disk_child *));
222 sprintf_block_head(p,
223 va_arg(args, struct buffer_head *));
226 sprintf_buffer_head(p,
227 va_arg(args, struct buffer_head *));
232 struct reiserfs_de_head *));
239 vsprintf(p, fmt1, args);
243 /* in addition to usual conversion specifiers this accepts reiserfs
244 specific conversion specifiers:
245 %k to print little endian key,
247 %h to print item_head,
248 %t to print directory entry
249 %z to print block head (arg must be struct buffer_head *
250 %b to print buffer_head
253 #define do_reiserfs_warning(fmt)\
256 va_start( args, fmt );\
257 prepare_error_buf( fmt, args );\
261 void __reiserfs_warning(struct super_block *sb, const char *id,
262 const char *function, const char *fmt, ...)
264 do_reiserfs_warning(fmt);
266 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
267 "%s\n", sb->s_id, id ? id : "", id ? " " : "",
268 function, error_buf);
270 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
271 id ? id : "", id ? " " : "", function, error_buf);
274 /* No newline.. reiserfs_info calls can be followed by printk's */
275 void reiserfs_info(struct super_block *sb, const char *fmt, ...)
277 do_reiserfs_warning(fmt);
279 printk(KERN_NOTICE "REISERFS (device %s): %s",
280 sb->s_id, error_buf);
282 printk(KERN_NOTICE "REISERFS %s:", error_buf);
285 /* No newline.. reiserfs_printk calls can be followed by printk's */
286 static void reiserfs_printk(const char *fmt, ...)
288 do_reiserfs_warning(fmt);
292 void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
294 #ifdef CONFIG_REISERFS_CHECK
295 do_reiserfs_warning(fmt);
297 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
300 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
306 maintainer-errorid: [function-name:] message
308 where errorid is unique to the maintainer and function-name is
309 optional, is recommended, so that anyone can easily find the bug
310 with a simple grep for the short to type string
311 maintainer-errorid. Don't bother with reusing errorids, there are
312 lots of numbers out there.
317 p_sb, "reiser-29: reiserfs_new_blocknrs: "
318 "one of search_start or rn(%d) is equal to MAX_B_NUM,"
319 "which means that we are optimizing location based on the bogus location of a temp buffer (%p).",
323 Regular panic()s sometimes clear the screen before the message can
324 be read, thus the need for the while loop.
326 Numbering scheme for panic used by Vladimir and Anatoly( Hans completely ignores this scheme, and considers it
327 pointless complexity):
329 panics in reiserfs_fs.h have numbers from 1000 to 1999
331 preserve.c (unused) 3000 to 3999
332 bitmap.c 4000 to 4999
334 prints.c 6000 to 6999
336 fix_nodes.c 8000 to 8999
338 lbalance.c 10000 to 10999
339 ibalance.c 11000 to 11999 not ready
340 do_balan.c 12000 to 12999
341 inode.c 13000 to 13999
342 file.c 14000 to 14999
343 objectid.c 15000 - 15999
344 buffer.c 16000 - 16999
345 symlink.c 17000 - 17999
349 #ifdef CONFIG_REISERFS_CHECK
350 extern struct tree_balance *cur_tb;
353 void reiserfs_panic(struct super_block *sb, const char *fmt, ...)
355 do_reiserfs_warning(fmt);
359 panic(KERN_EMERG "REISERFS: panic (device %s): %s\n",
360 reiserfs_bdevname(sb), error_buf);
363 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
365 do_reiserfs_warning(fmt);
367 if (reiserfs_error_panic(sb)) {
368 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
372 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
375 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
378 sb->s_flags |= MS_RDONLY;
379 reiserfs_journal_abort(sb, errno);
382 /* this prints internal nodes (4 keys/items in line) (dc_number,
383 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
385 static int print_internal(struct buffer_head *bh, int first, int last)
387 struct reiserfs_key *key;
388 struct disk_child *dc;
392 if (!B_IS_KEYS_LEVEL(bh))
402 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
405 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
407 dc = B_N_CHILD(bh, from);
408 reiserfs_printk("PTR %d: %y ", from, dc);
410 for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
412 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
420 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
423 struct block_head *blkh;
424 struct item_head *ih;
428 if (!B_IS_ITEMS_LEVEL(bh))
433 blkh = B_BLK_HEAD(bh);
434 ih = B_N_PITEM_HEAD(bh, 0);
435 nr = blkh_nr_item(blkh);
438 ("\n===================================================================\n");
439 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
441 if (!(print_mode & PRINT_LEAF_ITEMS)) {
442 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
443 &(ih->ih_key), &((ih + nr - 1)->ih_key));
447 if (first < 0 || first > nr - 1)
452 if (last < 0 || last > nr)
459 ("-------------------------------------------------------------------------------\n");
461 ("|##| type | key | ilen | free_space | version | loc |\n");
462 for (i = from; i < to; i++, ih++) {
464 ("-------------------------------------------------------------------------------\n");
465 reiserfs_printk("|%2d| %h |\n", i, ih);
466 if (print_mode & PRINT_LEAF_ITEMS)
467 op_print_item(ih, B_I_PITEM(bh, ih));
471 ("===================================================================\n");
476 char *reiserfs_hashname(int code)
478 if (code == YURA_HASH)
480 if (code == TEA_HASH)
488 /* return 1 if this is not super block */
489 static int print_super_block(struct buffer_head *bh)
491 struct reiserfs_super_block *rs =
492 (struct reiserfs_super_block *)(bh->b_data);
493 int skipped, data_blocks;
495 char b[BDEVNAME_SIZE];
497 if (is_reiserfs_3_5(rs)) {
499 } else if (is_reiserfs_3_6(rs)) {
501 } else if (is_reiserfs_jr(rs)) {
502 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
508 printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
509 (unsigned long long)bh->b_blocknr);
510 printk("Reiserfs version %s\n", version);
511 printk("Block count %u\n", sb_block_count(rs));
512 printk("Blocksize %d\n", sb_blocksize(rs));
513 printk("Free blocks %u\n", sb_free_blocks(rs));
514 // FIXME: this would be confusing if
515 // someone stores reiserfs super block in some data block ;)
516 // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
517 skipped = bh->b_blocknr;
518 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
519 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
520 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
522 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
523 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
524 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
525 sb_reserved_for_journal(rs)), data_blocks);
526 printk("Root block %u\n", sb_root_block(rs));
527 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
528 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
529 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
530 printk("FS state %d\n", sb_fs_state(rs));
531 printk("Hash function \"%s\"\n",
532 reiserfs_hashname(sb_hash_function_code(rs)));
534 printk("Tree height %d\n", sb_tree_height(rs));
538 static int print_desc_block(struct buffer_head *bh)
540 struct reiserfs_journal_desc *desc;
542 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
545 desc = (struct reiserfs_journal_desc *)(bh->b_data);
546 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
547 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
548 get_desc_mount_id(desc), get_desc_trans_len(desc));
553 void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
556 int mode, first, last;
561 printk("print_block: buffer is NULL\n");
565 mode = va_arg(args, int);
566 first = va_arg(args, int);
567 last = va_arg(args, int);
568 if (print_leaf(bh, mode, first, last))
569 if (print_internal(bh, first, last))
570 if (print_super_block(bh))
571 if (print_desc_block(bh))
573 ("Block %llu contains unformatted data\n",
574 (unsigned long long)bh->b_blocknr);
579 static char print_tb_buf[2048];
581 /* this stores initial state of tree balance in the print_tb_buf */
582 void store_print_tb(struct tree_balance *tb)
586 struct buffer_head *tbSh, *tbFh;
591 sprintf(print_tb_buf, "\n"
593 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
594 "=====================================================================\n"
595 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
596 REISERFS_SB(tb->tb_sb)->s_do_balance,
597 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
598 tb->tb_path->pos_in_item);
600 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
601 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
602 tb->tb_path->path_length
603 && PATH_H_PATH_OFFSET(tb->tb_path,
604 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
605 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
606 tbFh = PATH_H_PPARENT(tb->tb_path, h);
611 sprintf(print_tb_buf + strlen(print_tb_buf),
612 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
614 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
615 (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
616 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
617 (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
618 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
619 (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
620 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
621 (tb->FL[h]) ? (long long)(tb->FL[h]->
623 (tb->FR[h]) ? (long long)(tb->FR[h]->
625 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
627 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
628 b_blocknr) : (-1LL));
631 sprintf(print_tb_buf + strlen(print_tb_buf),
632 "=====================================================================\n"
633 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
634 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
635 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
636 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
637 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
640 /* this prints balance parameters for non-leaf levels */
644 sprintf(print_tb_buf + strlen(print_tb_buf),
645 "* %d * %4d * %2d * * %2d * * %2d *\n",
646 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
648 } while (tb->insert_size[h]);
650 sprintf(print_tb_buf + strlen(print_tb_buf),
651 "=====================================================================\n"
654 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
656 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
657 sprintf(print_tb_buf + strlen(print_tb_buf),
658 "%p (%llu %d)%s", tb->FEB[i],
659 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
661 tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
662 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
664 sprintf(print_tb_buf + strlen(print_tb_buf),
665 "======================== the end ====================================\n");
668 void print_cur_tb(char *mes)
670 printk("%s\n%s", mes, print_tb_buf);
673 static void check_leaf_block_head(struct buffer_head *bh)
675 struct block_head *blkh;
678 blkh = B_BLK_HEAD(bh);
679 nr = blkh_nr_item(blkh);
680 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
682 "vs-6010: check_leaf_block_head: invalid item number %z",
684 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
686 "vs-6020: check_leaf_block_head: invalid free space %z",
691 static void check_internal_block_head(struct buffer_head *bh)
693 struct block_head *blkh;
695 blkh = B_BLK_HEAD(bh);
696 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
698 "vs-6025: check_internal_block_head: invalid level %z",
701 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
703 "vs-6030: check_internal_block_head: invalid item number %z",
706 if (B_FREE_SPACE(bh) !=
707 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
708 DC_SIZE * (B_NR_ITEMS(bh) + 1))
710 "vs-6040: check_internal_block_head: invalid free space %z",
715 void check_leaf(struct buffer_head *bh)
718 struct item_head *ih;
722 check_leaf_block_head(bh);
723 for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
724 op_check_item(ih, B_I_PITEM(bh, ih));
727 void check_internal(struct buffer_head *bh)
731 check_internal_block_head(bh);
734 void print_statistics(struct super_block *s)
738 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
739 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
740 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
741 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
742 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);