Loading...
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
13static char error_buf[1024];
14static char fmt_buf[1024];
15static char off_buf[80];
16
17static 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
31static 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
48static 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
61static 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 */
79static int scnprintf_le_key(char *buf, size_t size, struct reiserfs_key *key)
80{
81 if (key)
82 return scnprintf(buf, size, "[%d %d %s %s]",
83 le32_to_cpu(key->k_dir_id),
84 le32_to_cpu(key->k_objectid), le_offset(key),
85 le_type(key));
86 else
87 return scnprintf(buf, size, "[NULL]");
88}
89
90/* %K */
91static int scnprintf_cpu_key(char *buf, size_t size, struct cpu_key *key)
92{
93 if (key)
94 return scnprintf(buf, size, "[%d %d %s %s]",
95 key->on_disk_key.k_dir_id,
96 key->on_disk_key.k_objectid,
97 reiserfs_cpu_offset(key), cpu_type(key));
98 else
99 return scnprintf(buf, size, "[NULL]");
100}
101
102static int scnprintf_de_head(char *buf, size_t size,
103 struct reiserfs_de_head *deh)
104{
105 if (deh)
106 return scnprintf(buf, size,
107 "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]",
108 deh_offset(deh), deh_dir_id(deh),
109 deh_objectid(deh), deh_location(deh),
110 deh_state(deh));
111 else
112 return scnprintf(buf, size, "[NULL]");
113
114}
115
116static int scnprintf_item_head(char *buf, size_t size, struct item_head *ih)
117{
118 if (ih) {
119 char *p = buf;
120 char * const end = buf + size;
121
122 p += scnprintf(p, end - p, "%s",
123 (ih_version(ih) == KEY_FORMAT_3_6) ?
124 "*3.6* " : "*3.5*");
125
126 p += scnprintf_le_key(p, end - p, &ih->ih_key);
127
128 p += scnprintf(p, end - p,
129 ", item_len %d, item_location %d, free_space(entry_count) %d",
130 ih_item_len(ih), ih_location(ih),
131 ih_free_space(ih));
132 return p - buf;
133 } else
134 return scnprintf(buf, size, "[NULL]");
135}
136
137static int scnprintf_direntry(char *buf, size_t size,
138 struct reiserfs_dir_entry *de)
139{
140 char name[20];
141
142 memcpy(name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen);
143 name[de->de_namelen > 19 ? 19 : de->de_namelen] = 0;
144 return scnprintf(buf, size, "\"%s\"==>[%d %d]",
145 name, de->de_dir_id, de->de_objectid);
146}
147
148static int scnprintf_block_head(char *buf, size_t size, struct buffer_head *bh)
149{
150 return scnprintf(buf, size,
151 "level=%d, nr_items=%d, free_space=%d rdkey ",
152 B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh));
153}
154
155static int scnprintf_buffer_head(char *buf, size_t size, struct buffer_head *bh)
156{
157 return scnprintf(buf, size,
158 "dev %pg, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
159 bh->b_bdev, bh->b_size,
160 (unsigned long long)bh->b_blocknr,
161 atomic_read(&(bh->b_count)),
162 bh->b_state, bh->b_page,
163 buffer_uptodate(bh) ? "UPTODATE" : "!UPTODATE",
164 buffer_dirty(bh) ? "DIRTY" : "CLEAN",
165 buffer_locked(bh) ? "LOCKED" : "UNLOCKED");
166}
167
168static int scnprintf_disk_child(char *buf, size_t size, struct disk_child *dc)
169{
170 return scnprintf(buf, size, "[dc_number=%d, dc_size=%u]",
171 dc_block_number(dc), dc_size(dc));
172}
173
174static char *is_there_reiserfs_struct(char *fmt, int *what)
175{
176 char *k = fmt;
177
178 while ((k = strchr(k, '%')) != NULL) {
179 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
180 k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
181 *what = k[1];
182 break;
183 }
184 k++;
185 }
186 return k;
187}
188
189/*
190 * debugging reiserfs we used to print out a lot of different
191 * variables, like keys, item headers, buffer heads etc. Values of
192 * most fields matter. So it took a long time just to write
193 * appropriative printk. With this reiserfs_warning you can use format
194 * specification for complex structures like you used to do with
195 * printfs for integers, doubles and pointers. For instance, to print
196 * out key structure you have to write just:
197 * reiserfs_warning ("bad key %k", key);
198 * instead of
199 * printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
200 * key->k_offset, key->k_uniqueness);
201 */
202static DEFINE_SPINLOCK(error_lock);
203static void prepare_error_buf(const char *fmt, va_list args)
204{
205 char *fmt1 = fmt_buf;
206 char *k;
207 char *p = error_buf;
208 char * const end = &error_buf[sizeof(error_buf)];
209 int what;
210
211 spin_lock(&error_lock);
212
213 if (WARN_ON(strscpy(fmt_buf, fmt, sizeof(fmt_buf)) < 0)) {
214 strscpy(error_buf, "format string too long", end - error_buf);
215 goto out_unlock;
216 }
217
218 while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
219 *k = 0;
220
221 p += vscnprintf(p, end - p, fmt1, args);
222
223 switch (what) {
224 case 'k':
225 p += scnprintf_le_key(p, end - p,
226 va_arg(args, struct reiserfs_key *));
227 break;
228 case 'K':
229 p += scnprintf_cpu_key(p, end - p,
230 va_arg(args, struct cpu_key *));
231 break;
232 case 'h':
233 p += scnprintf_item_head(p, end - p,
234 va_arg(args, struct item_head *));
235 break;
236 case 't':
237 p += scnprintf_direntry(p, end - p,
238 va_arg(args, struct reiserfs_dir_entry *));
239 break;
240 case 'y':
241 p += scnprintf_disk_child(p, end - p,
242 va_arg(args, struct disk_child *));
243 break;
244 case 'z':
245 p += scnprintf_block_head(p, end - p,
246 va_arg(args, struct buffer_head *));
247 break;
248 case 'b':
249 p += scnprintf_buffer_head(p, end - p,
250 va_arg(args, struct buffer_head *));
251 break;
252 case 'a':
253 p += scnprintf_de_head(p, end - p,
254 va_arg(args, struct reiserfs_de_head *));
255 break;
256 }
257
258 fmt1 = k + 2;
259 }
260 p += vscnprintf(p, end - p, fmt1, args);
261out_unlock:
262 spin_unlock(&error_lock);
263
264}
265
266/*
267 * in addition to usual conversion specifiers this accepts reiserfs
268 * specific conversion specifiers:
269 * %k to print little endian key,
270 * %K to print cpu key,
271 * %h to print item_head,
272 * %t to print directory entry
273 * %z to print block head (arg must be struct buffer_head *
274 * %b to print buffer_head
275 */
276
277#define do_reiserfs_warning(fmt)\
278{\
279 va_list args;\
280 va_start( args, fmt );\
281 prepare_error_buf( fmt, args );\
282 va_end( args );\
283}
284
285void __reiserfs_warning(struct super_block *sb, const char *id,
286 const char *function, const char *fmt, ...)
287{
288 do_reiserfs_warning(fmt);
289 if (sb)
290 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
291 "%s\n", sb->s_id, id ? id : "", id ? " " : "",
292 function, error_buf);
293 else
294 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
295 id ? id : "", id ? " " : "", function, error_buf);
296}
297
298/* No newline.. reiserfs_info calls can be followed by printk's */
299void reiserfs_info(struct super_block *sb, const char *fmt, ...)
300{
301 do_reiserfs_warning(fmt);
302 if (sb)
303 printk(KERN_NOTICE "REISERFS (device %s): %s",
304 sb->s_id, error_buf);
305 else
306 printk(KERN_NOTICE "REISERFS %s:", error_buf);
307}
308
309/* No newline.. reiserfs_printk calls can be followed by printk's */
310static void reiserfs_printk(const char *fmt, ...)
311{
312 do_reiserfs_warning(fmt);
313 printk(error_buf);
314}
315
316void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
317{
318#ifdef CONFIG_REISERFS_CHECK
319 do_reiserfs_warning(fmt);
320 if (s)
321 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
322 s->s_id, error_buf);
323 else
324 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
325#endif
326}
327
328/*
329 * The format:
330 *
331 * maintainer-errorid: [function-name:] message
332 *
333 * where errorid is unique to the maintainer and function-name is
334 * optional, is recommended, so that anyone can easily find the bug
335 * with a simple grep for the short to type string
336 * maintainer-errorid. Don't bother with reusing errorids, there are
337 * lots of numbers out there.
338 *
339 * Example:
340 *
341 * reiserfs_panic(
342 * p_sb, "reiser-29: reiserfs_new_blocknrs: "
343 * "one of search_start or rn(%d) is equal to MAX_B_NUM,"
344 * "which means that we are optimizing location based on the "
345 * "bogus location of a temp buffer (%p).",
346 * rn, bh
347 * );
348 *
349 * Regular panic()s sometimes clear the screen before the message can
350 * be read, thus the need for the while loop.
351 *
352 * Numbering scheme for panic used by Vladimir and Anatoly( Hans completely
353 * ignores this scheme, and considers it pointless complexity):
354 *
355 * panics in reiserfs_fs.h have numbers from 1000 to 1999
356 * super.c 2000 to 2999
357 * preserve.c (unused) 3000 to 3999
358 * bitmap.c 4000 to 4999
359 * stree.c 5000 to 5999
360 * prints.c 6000 to 6999
361 * namei.c 7000 to 7999
362 * fix_nodes.c 8000 to 8999
363 * dir.c 9000 to 9999
364 * lbalance.c 10000 to 10999
365 * ibalance.c 11000 to 11999 not ready
366 * do_balan.c 12000 to 12999
367 * inode.c 13000 to 13999
368 * file.c 14000 to 14999
369 * objectid.c 15000 - 15999
370 * buffer.c 16000 - 16999
371 * symlink.c 17000 - 17999
372 *
373 * . */
374
375void __reiserfs_panic(struct super_block *sb, const char *id,
376 const char *function, const char *fmt, ...)
377{
378 do_reiserfs_warning(fmt);
379
380#ifdef CONFIG_REISERFS_CHECK
381 dump_stack();
382#endif
383 if (sb)
384 printk(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
385 sb->s_id, id ? id : "", id ? " " : "",
386 function, error_buf);
387 else
388 printk(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
389 id ? id : "", id ? " " : "", function, error_buf);
390 BUG();
391}
392
393void __reiserfs_error(struct super_block *sb, const char *id,
394 const char *function, const char *fmt, ...)
395{
396 do_reiserfs_warning(fmt);
397
398 BUG_ON(sb == NULL);
399
400 if (reiserfs_error_panic(sb))
401 __reiserfs_panic(sb, id, function, error_buf);
402
403 if (id && id[0])
404 printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
405 sb->s_id, id, function, error_buf);
406 else
407 printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
408 sb->s_id, function, error_buf);
409
410 if (sb_rdonly(sb))
411 return;
412
413 reiserfs_info(sb, "Remounting filesystem read-only\n");
414 sb->s_flags |= SB_RDONLY;
415 reiserfs_abort_journal(sb, -EIO);
416}
417
418void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
419{
420 do_reiserfs_warning(fmt);
421
422 if (reiserfs_error_panic(sb)) {
423 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
424 error_buf);
425 }
426
427 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
428 return;
429
430 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
431 error_buf);
432
433 sb->s_flags |= SB_RDONLY;
434 reiserfs_abort_journal(sb, errno);
435}
436
437/*
438 * this prints internal nodes (4 keys/items in line) (dc_number,
439 * dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
440 * dc_size)...
441 */
442static int print_internal(struct buffer_head *bh, int first, int last)
443{
444 struct reiserfs_key *key;
445 struct disk_child *dc;
446 int i;
447 int from, to;
448
449 if (!B_IS_KEYS_LEVEL(bh))
450 return 1;
451
452 check_internal(bh);
453
454 if (first == -1) {
455 from = 0;
456 to = B_NR_ITEMS(bh);
457 } else {
458 from = first;
459 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
460 }
461
462 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
463
464 dc = B_N_CHILD(bh, from);
465 reiserfs_printk("PTR %d: %y ", from, dc);
466
467 for (i = from, key = internal_key(bh, from), dc++; i < to;
468 i++, key++, dc++) {
469 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
470 if (i && i % 4 == 0)
471 printk("\n");
472 }
473 printk("\n");
474 return 0;
475}
476
477static int print_leaf(struct buffer_head *bh, int print_mode, int first,
478 int last)
479{
480 struct block_head *blkh;
481 struct item_head *ih;
482 int i, nr;
483 int from, to;
484
485 if (!B_IS_ITEMS_LEVEL(bh))
486 return 1;
487
488 check_leaf(bh);
489
490 blkh = B_BLK_HEAD(bh);
491 ih = item_head(bh, 0);
492 nr = blkh_nr_item(blkh);
493
494 printk
495 ("\n===================================================================\n");
496 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
497
498 if (!(print_mode & PRINT_LEAF_ITEMS)) {
499 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
500 &(ih->ih_key), &((ih + nr - 1)->ih_key));
501 return 0;
502 }
503
504 if (first < 0 || first > nr - 1)
505 from = 0;
506 else
507 from = first;
508
509 if (last < 0 || last > nr)
510 to = nr;
511 else
512 to = last;
513
514 ih += from;
515 printk
516 ("-------------------------------------------------------------------------------\n");
517 printk
518 ("|##| type | key | ilen | free_space | version | loc |\n");
519 for (i = from; i < to; i++, ih++) {
520 printk
521 ("-------------------------------------------------------------------------------\n");
522 reiserfs_printk("|%2d| %h |\n", i, ih);
523 if (print_mode & PRINT_LEAF_ITEMS)
524 op_print_item(ih, ih_item_body(bh, ih));
525 }
526
527 printk
528 ("===================================================================\n");
529
530 return 0;
531}
532
533char *reiserfs_hashname(int code)
534{
535 if (code == YURA_HASH)
536 return "rupasov";
537 if (code == TEA_HASH)
538 return "tea";
539 if (code == R5_HASH)
540 return "r5";
541
542 return "unknown";
543}
544
545/* return 1 if this is not super block */
546static int print_super_block(struct buffer_head *bh)
547{
548 struct reiserfs_super_block *rs =
549 (struct reiserfs_super_block *)(bh->b_data);
550 int skipped, data_blocks;
551 char *version;
552
553 if (is_reiserfs_3_5(rs)) {
554 version = "3.5";
555 } else if (is_reiserfs_3_6(rs)) {
556 version = "3.6";
557 } else if (is_reiserfs_jr(rs)) {
558 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
559 "3.6" : "3.5");
560 } else {
561 return 1;
562 }
563
564 printk("%pg\'s super block is in block %llu\n", bh->b_bdev,
565 (unsigned long long)bh->b_blocknr);
566 printk("Reiserfs version %s\n", version);
567 printk("Block count %u\n", sb_block_count(rs));
568 printk("Blocksize %d\n", sb_blocksize(rs));
569 printk("Free blocks %u\n", sb_free_blocks(rs));
570 /*
571 * FIXME: this would be confusing if
572 * someone stores reiserfs super block in some data block ;)
573// skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
574 */
575 skipped = bh->b_blocknr;
576 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
577 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
578 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
579 printk
580 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
581 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
582 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
583 sb_reserved_for_journal(rs)), data_blocks);
584 printk("Root block %u\n", sb_root_block(rs));
585 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
586 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
587 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
588 printk("FS state %d\n", sb_fs_state(rs));
589 printk("Hash function \"%s\"\n",
590 reiserfs_hashname(sb_hash_function_code(rs)));
591
592 printk("Tree height %d\n", sb_tree_height(rs));
593 return 0;
594}
595
596static int print_desc_block(struct buffer_head *bh)
597{
598 struct reiserfs_journal_desc *desc;
599
600 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
601 return 1;
602
603 desc = (struct reiserfs_journal_desc *)(bh->b_data);
604 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
605 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
606 get_desc_mount_id(desc), get_desc_trans_len(desc));
607
608 return 0;
609}
610/* ..., int print_mode, int first, int last) */
611void print_block(struct buffer_head *bh, ...)
612{
613 va_list args;
614 int mode, first, last;
615
616 if (!bh) {
617 printk("print_block: buffer is NULL\n");
618 return;
619 }
620
621 va_start(args, bh);
622
623 mode = va_arg(args, int);
624 first = va_arg(args, int);
625 last = va_arg(args, int);
626 if (print_leaf(bh, mode, first, last))
627 if (print_internal(bh, first, last))
628 if (print_super_block(bh))
629 if (print_desc_block(bh))
630 printk
631 ("Block %llu contains unformatted data\n",
632 (unsigned long long)bh->b_blocknr);
633
634 va_end(args);
635}
636
637static char print_tb_buf[2048];
638
639/* this stores initial state of tree balance in the print_tb_buf */
640void store_print_tb(struct tree_balance *tb)
641{
642 int h = 0;
643 int i;
644 struct buffer_head *tbSh, *tbFh;
645
646 if (!tb)
647 return;
648
649 sprintf(print_tb_buf, "\n"
650 "BALANCING %d\n"
651 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
652 "=====================================================================\n"
653 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
654 REISERFS_SB(tb->tb_sb)->s_do_balance,
655 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
656 tb->tb_path->pos_in_item);
657
658 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
659 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
660 tb->tb_path->path_length
661 && PATH_H_PATH_OFFSET(tb->tb_path,
662 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
663 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
664 tbFh = PATH_H_PPARENT(tb->tb_path, h);
665 } else {
666 tbSh = NULL;
667 tbFh = NULL;
668 }
669 sprintf(print_tb_buf + strlen(print_tb_buf),
670 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
671 h,
672 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
673 (tbSh) ? atomic_read(&tbSh->b_count) : -1,
674 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
675 (tb->L[h]) ? atomic_read(&tb->L[h]->b_count) : -1,
676 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
677 (tb->R[h]) ? atomic_read(&tb->R[h]->b_count) : -1,
678 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
679 (tb->FL[h]) ? (long long)(tb->FL[h]->
680 b_blocknr) : (-1LL),
681 (tb->FR[h]) ? (long long)(tb->FR[h]->
682 b_blocknr) : (-1LL),
683 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
684 b_blocknr) : (-1LL),
685 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
686 b_blocknr) : (-1LL));
687 }
688
689 sprintf(print_tb_buf + strlen(print_tb_buf),
690 "=====================================================================\n"
691 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
692 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
693 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
694 tb->rbytes, tb->blknum[0], tb->s0num, tb->snum[0],
695 tb->sbytes[0], tb->snum[1], tb->sbytes[1],
696 tb->cur_blknum, tb->lkey[0], tb->rkey[0]);
697
698 /* this prints balance parameters for non-leaf levels */
699 h = 0;
700 do {
701 h++;
702 sprintf(print_tb_buf + strlen(print_tb_buf),
703 "* %d * %4d * %2d * * %2d * * %2d *\n",
704 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
705 tb->blknum[h]);
706 } while (tb->insert_size[h]);
707
708 sprintf(print_tb_buf + strlen(print_tb_buf),
709 "=====================================================================\n"
710 "FEB list: ");
711
712 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
713 h = 0;
714 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
715 sprintf(print_tb_buf + strlen(print_tb_buf),
716 "%p (%llu %d)%s", tb->FEB[i],
717 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
718 b_blocknr : 0ULL,
719 tb->FEB[i] ? atomic_read(&tb->FEB[i]->b_count) : 0,
720 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
721
722 sprintf(print_tb_buf + strlen(print_tb_buf),
723 "======================== the end ====================================\n");
724}
725
726void print_cur_tb(char *mes)
727{
728 printk("%s\n%s", mes, print_tb_buf);
729}
730
731static void check_leaf_block_head(struct buffer_head *bh)
732{
733 struct block_head *blkh;
734 int nr;
735
736 blkh = B_BLK_HEAD(bh);
737 nr = blkh_nr_item(blkh);
738 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
739 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
740 bh);
741 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
742 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
743 bh);
744
745}
746
747static void check_internal_block_head(struct buffer_head *bh)
748{
749 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
750 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
751
752 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
753 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
754
755 if (B_FREE_SPACE(bh) !=
756 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
757 DC_SIZE * (B_NR_ITEMS(bh) + 1))
758 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
759
760}
761
762void check_leaf(struct buffer_head *bh)
763{
764 int i;
765 struct item_head *ih;
766
767 if (!bh)
768 return;
769 check_leaf_block_head(bh);
770 for (i = 0, ih = item_head(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
771 op_check_item(ih, ih_item_body(bh, ih));
772}
773
774void check_internal(struct buffer_head *bh)
775{
776 if (!bh)
777 return;
778 check_internal_block_head(bh);
779}
780
781void print_statistics(struct super_block *s)
782{
783
784 /*
785 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
786 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
787 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
788 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
789 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
790 */
791
792}
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
13static char error_buf[1024];
14static char fmt_buf[1024];
15static char off_buf[80];
16
17static 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
31static 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
48static 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
61static 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 */
79static 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 */
90static 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
100static 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
112static 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
125static 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
134static 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
140static void sprintf_buffer_head(char *buf, struct buffer_head *bh)
141{
142 sprintf(buf,
143 "dev %pg, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
144 bh->b_bdev, bh->b_size,
145 (unsigned long long)bh->b_blocknr, atomic_read(&(bh->b_count)),
146 bh->b_state, bh->b_page,
147 buffer_uptodate(bh) ? "UPTODATE" : "!UPTODATE",
148 buffer_dirty(bh) ? "DIRTY" : "CLEAN",
149 buffer_locked(bh) ? "LOCKED" : "UNLOCKED");
150}
151
152static void sprintf_disk_child(char *buf, struct disk_child *dc)
153{
154 sprintf(buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc),
155 dc_size(dc));
156}
157
158static char *is_there_reiserfs_struct(char *fmt, int *what)
159{
160 char *k = fmt;
161
162 while ((k = strchr(k, '%')) != NULL) {
163 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
164 k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
165 *what = k[1];
166 break;
167 }
168 k++;
169 }
170 return k;
171}
172
173/*
174 * debugging reiserfs we used to print out a lot of different
175 * variables, like keys, item headers, buffer heads etc. Values of
176 * most fields matter. So it took a long time just to write
177 * appropriative printk. With this reiserfs_warning you can use format
178 * specification for complex structures like you used to do with
179 * printfs for integers, doubles and pointers. For instance, to print
180 * out key structure you have to write just:
181 * reiserfs_warning ("bad key %k", key);
182 * instead of
183 * printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
184 * key->k_offset, key->k_uniqueness);
185 */
186static DEFINE_SPINLOCK(error_lock);
187static void prepare_error_buf(const char *fmt, va_list args)
188{
189 char *fmt1 = fmt_buf;
190 char *k;
191 char *p = error_buf;
192 int what;
193
194 spin_lock(&error_lock);
195
196 strcpy(fmt1, fmt);
197
198 while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
199 *k = 0;
200
201 p += vsprintf(p, fmt1, args);
202
203 switch (what) {
204 case 'k':
205 sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
206 break;
207 case 'K':
208 sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
209 break;
210 case 'h':
211 sprintf_item_head(p, va_arg(args, struct item_head *));
212 break;
213 case 't':
214 sprintf_direntry(p,
215 va_arg(args,
216 struct reiserfs_dir_entry *));
217 break;
218 case 'y':
219 sprintf_disk_child(p,
220 va_arg(args, struct disk_child *));
221 break;
222 case 'z':
223 sprintf_block_head(p,
224 va_arg(args, struct buffer_head *));
225 break;
226 case 'b':
227 sprintf_buffer_head(p,
228 va_arg(args, struct buffer_head *));
229 break;
230 case 'a':
231 sprintf_de_head(p,
232 va_arg(args,
233 struct reiserfs_de_head *));
234 break;
235 }
236
237 p += strlen(p);
238 fmt1 = k + 2;
239 }
240 vsprintf(p, fmt1, args);
241 spin_unlock(&error_lock);
242
243}
244
245/*
246 * in addition to usual conversion specifiers this accepts reiserfs
247 * specific conversion specifiers:
248 * %k to print little endian key,
249 * %K to print cpu 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
254 */
255
256#define do_reiserfs_warning(fmt)\
257{\
258 va_list args;\
259 va_start( args, fmt );\
260 prepare_error_buf( fmt, args );\
261 va_end( args );\
262}
263
264void __reiserfs_warning(struct super_block *sb, const char *id,
265 const char *function, const char *fmt, ...)
266{
267 do_reiserfs_warning(fmt);
268 if (sb)
269 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
270 "%s\n", sb->s_id, id ? id : "", id ? " " : "",
271 function, error_buf);
272 else
273 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
274 id ? id : "", id ? " " : "", function, error_buf);
275}
276
277/* No newline.. reiserfs_info calls can be followed by printk's */
278void reiserfs_info(struct super_block *sb, const char *fmt, ...)
279{
280 do_reiserfs_warning(fmt);
281 if (sb)
282 printk(KERN_NOTICE "REISERFS (device %s): %s",
283 sb->s_id, error_buf);
284 else
285 printk(KERN_NOTICE "REISERFS %s:", error_buf);
286}
287
288/* No newline.. reiserfs_printk calls can be followed by printk's */
289static void reiserfs_printk(const char *fmt, ...)
290{
291 do_reiserfs_warning(fmt);
292 printk(error_buf);
293}
294
295void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
296{
297#ifdef CONFIG_REISERFS_CHECK
298 do_reiserfs_warning(fmt);
299 if (s)
300 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
301 s->s_id, error_buf);
302 else
303 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
304#endif
305}
306
307/*
308 * The format:
309 *
310 * maintainer-errorid: [function-name:] message
311 *
312 * where errorid is unique to the maintainer and function-name is
313 * optional, is recommended, so that anyone can easily find the bug
314 * with a simple grep for the short to type string
315 * maintainer-errorid. Don't bother with reusing errorids, there are
316 * lots of numbers out there.
317 *
318 * Example:
319 *
320 * reiserfs_panic(
321 * p_sb, "reiser-29: reiserfs_new_blocknrs: "
322 * "one of search_start or rn(%d) is equal to MAX_B_NUM,"
323 * "which means that we are optimizing location based on the "
324 * "bogus location of a temp buffer (%p).",
325 * rn, bh
326 * );
327 *
328 * Regular panic()s sometimes clear the screen before the message can
329 * be read, thus the need for the while loop.
330 *
331 * Numbering scheme for panic used by Vladimir and Anatoly( Hans completely
332 * ignores this scheme, and considers it pointless complexity):
333 *
334 * panics in reiserfs_fs.h have numbers from 1000 to 1999
335 * super.c 2000 to 2999
336 * preserve.c (unused) 3000 to 3999
337 * bitmap.c 4000 to 4999
338 * stree.c 5000 to 5999
339 * prints.c 6000 to 6999
340 * namei.c 7000 to 7999
341 * fix_nodes.c 8000 to 8999
342 * dir.c 9000 to 9999
343 * lbalance.c 10000 to 10999
344 * ibalance.c 11000 to 11999 not ready
345 * do_balan.c 12000 to 12999
346 * inode.c 13000 to 13999
347 * file.c 14000 to 14999
348 * objectid.c 15000 - 15999
349 * buffer.c 16000 - 16999
350 * symlink.c 17000 - 17999
351 *
352 * . */
353
354void __reiserfs_panic(struct super_block *sb, const char *id,
355 const char *function, const char *fmt, ...)
356{
357 do_reiserfs_warning(fmt);
358
359#ifdef CONFIG_REISERFS_CHECK
360 dump_stack();
361#endif
362 if (sb)
363 printk(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
364 sb->s_id, id ? id : "", id ? " " : "",
365 function, error_buf);
366 else
367 printk(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
368 id ? id : "", id ? " " : "", function, error_buf);
369 BUG();
370}
371
372void __reiserfs_error(struct super_block *sb, const char *id,
373 const char *function, const char *fmt, ...)
374{
375 do_reiserfs_warning(fmt);
376
377 BUG_ON(sb == NULL);
378
379 if (reiserfs_error_panic(sb))
380 __reiserfs_panic(sb, id, function, error_buf);
381
382 if (id && id[0])
383 printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
384 sb->s_id, id, function, error_buf);
385 else
386 printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
387 sb->s_id, function, error_buf);
388
389 if (sb->s_flags & MS_RDONLY)
390 return;
391
392 reiserfs_info(sb, "Remounting filesystem read-only\n");
393 sb->s_flags |= MS_RDONLY;
394 reiserfs_abort_journal(sb, -EIO);
395}
396
397void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
398{
399 do_reiserfs_warning(fmt);
400
401 if (reiserfs_error_panic(sb)) {
402 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
403 error_buf);
404 }
405
406 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
407 return;
408
409 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
410 error_buf);
411
412 sb->s_flags |= MS_RDONLY;
413 reiserfs_abort_journal(sb, errno);
414}
415
416/*
417 * this prints internal nodes (4 keys/items in line) (dc_number,
418 * dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
419 * dc_size)...
420 */
421static int print_internal(struct buffer_head *bh, int first, int last)
422{
423 struct reiserfs_key *key;
424 struct disk_child *dc;
425 int i;
426 int from, to;
427
428 if (!B_IS_KEYS_LEVEL(bh))
429 return 1;
430
431 check_internal(bh);
432
433 if (first == -1) {
434 from = 0;
435 to = B_NR_ITEMS(bh);
436 } else {
437 from = first;
438 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
439 }
440
441 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
442
443 dc = B_N_CHILD(bh, from);
444 reiserfs_printk("PTR %d: %y ", from, dc);
445
446 for (i = from, key = internal_key(bh, from), dc++; i < to;
447 i++, key++, dc++) {
448 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
449 if (i && i % 4 == 0)
450 printk("\n");
451 }
452 printk("\n");
453 return 0;
454}
455
456static int print_leaf(struct buffer_head *bh, int print_mode, int first,
457 int last)
458{
459 struct block_head *blkh;
460 struct item_head *ih;
461 int i, nr;
462 int from, to;
463
464 if (!B_IS_ITEMS_LEVEL(bh))
465 return 1;
466
467 check_leaf(bh);
468
469 blkh = B_BLK_HEAD(bh);
470 ih = item_head(bh, 0);
471 nr = blkh_nr_item(blkh);
472
473 printk
474 ("\n===================================================================\n");
475 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
476
477 if (!(print_mode & PRINT_LEAF_ITEMS)) {
478 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
479 &(ih->ih_key), &((ih + nr - 1)->ih_key));
480 return 0;
481 }
482
483 if (first < 0 || first > nr - 1)
484 from = 0;
485 else
486 from = first;
487
488 if (last < 0 || last > nr)
489 to = nr;
490 else
491 to = last;
492
493 ih += from;
494 printk
495 ("-------------------------------------------------------------------------------\n");
496 printk
497 ("|##| type | key | ilen | free_space | version | loc |\n");
498 for (i = from; i < to; i++, ih++) {
499 printk
500 ("-------------------------------------------------------------------------------\n");
501 reiserfs_printk("|%2d| %h |\n", i, ih);
502 if (print_mode & PRINT_LEAF_ITEMS)
503 op_print_item(ih, ih_item_body(bh, ih));
504 }
505
506 printk
507 ("===================================================================\n");
508
509 return 0;
510}
511
512char *reiserfs_hashname(int code)
513{
514 if (code == YURA_HASH)
515 return "rupasov";
516 if (code == TEA_HASH)
517 return "tea";
518 if (code == R5_HASH)
519 return "r5";
520
521 return "unknown";
522}
523
524/* return 1 if this is not super block */
525static int print_super_block(struct buffer_head *bh)
526{
527 struct reiserfs_super_block *rs =
528 (struct reiserfs_super_block *)(bh->b_data);
529 int skipped, data_blocks;
530 char *version;
531
532 if (is_reiserfs_3_5(rs)) {
533 version = "3.5";
534 } else if (is_reiserfs_3_6(rs)) {
535 version = "3.6";
536 } else if (is_reiserfs_jr(rs)) {
537 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
538 "3.6" : "3.5");
539 } else {
540 return 1;
541 }
542
543 printk("%pg\'s super block is in block %llu\n", bh->b_bdev,
544 (unsigned long long)bh->b_blocknr);
545 printk("Reiserfs version %s\n", version);
546 printk("Block count %u\n", sb_block_count(rs));
547 printk("Blocksize %d\n", sb_blocksize(rs));
548 printk("Free blocks %u\n", sb_free_blocks(rs));
549 /*
550 * FIXME: this would be confusing if
551 * someone stores reiserfs super block in some data block ;)
552// skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
553 */
554 skipped = bh->b_blocknr;
555 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
556 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
557 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
558 printk
559 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
560 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
561 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
562 sb_reserved_for_journal(rs)), data_blocks);
563 printk("Root block %u\n", sb_root_block(rs));
564 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
565 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
566 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
567 printk("FS state %d\n", sb_fs_state(rs));
568 printk("Hash function \"%s\"\n",
569 reiserfs_hashname(sb_hash_function_code(rs)));
570
571 printk("Tree height %d\n", sb_tree_height(rs));
572 return 0;
573}
574
575static int print_desc_block(struct buffer_head *bh)
576{
577 struct reiserfs_journal_desc *desc;
578
579 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
580 return 1;
581
582 desc = (struct reiserfs_journal_desc *)(bh->b_data);
583 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
584 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
585 get_desc_mount_id(desc), get_desc_trans_len(desc));
586
587 return 0;
588}
589/* ..., int print_mode, int first, int last) */
590void print_block(struct buffer_head *bh, ...)
591{
592 va_list args;
593 int mode, first, last;
594
595 if (!bh) {
596 printk("print_block: buffer is NULL\n");
597 return;
598 }
599
600 va_start(args, bh);
601
602 mode = va_arg(args, int);
603 first = va_arg(args, int);
604 last = va_arg(args, int);
605 if (print_leaf(bh, mode, first, last))
606 if (print_internal(bh, first, last))
607 if (print_super_block(bh))
608 if (print_desc_block(bh))
609 printk
610 ("Block %llu contains unformatted data\n",
611 (unsigned long long)bh->b_blocknr);
612
613 va_end(args);
614}
615
616static char print_tb_buf[2048];
617
618/* this stores initial state of tree balance in the print_tb_buf */
619void store_print_tb(struct tree_balance *tb)
620{
621 int h = 0;
622 int i;
623 struct buffer_head *tbSh, *tbFh;
624
625 if (!tb)
626 return;
627
628 sprintf(print_tb_buf, "\n"
629 "BALANCING %d\n"
630 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
631 "=====================================================================\n"
632 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
633 REISERFS_SB(tb->tb_sb)->s_do_balance,
634 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
635 tb->tb_path->pos_in_item);
636
637 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
638 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
639 tb->tb_path->path_length
640 && PATH_H_PATH_OFFSET(tb->tb_path,
641 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
642 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
643 tbFh = PATH_H_PPARENT(tb->tb_path, h);
644 } else {
645 tbSh = NULL;
646 tbFh = NULL;
647 }
648 sprintf(print_tb_buf + strlen(print_tb_buf),
649 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
650 h,
651 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
652 (tbSh) ? atomic_read(&tbSh->b_count) : -1,
653 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
654 (tb->L[h]) ? atomic_read(&tb->L[h]->b_count) : -1,
655 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
656 (tb->R[h]) ? atomic_read(&tb->R[h]->b_count) : -1,
657 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
658 (tb->FL[h]) ? (long long)(tb->FL[h]->
659 b_blocknr) : (-1LL),
660 (tb->FR[h]) ? (long long)(tb->FR[h]->
661 b_blocknr) : (-1LL),
662 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
663 b_blocknr) : (-1LL),
664 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
665 b_blocknr) : (-1LL));
666 }
667
668 sprintf(print_tb_buf + strlen(print_tb_buf),
669 "=====================================================================\n"
670 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
671 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
672 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
673 tb->rbytes, tb->blknum[0], tb->s0num, tb->snum[0],
674 tb->sbytes[0], tb->snum[1], tb->sbytes[1],
675 tb->cur_blknum, tb->lkey[0], tb->rkey[0]);
676
677 /* this prints balance parameters for non-leaf levels */
678 h = 0;
679 do {
680 h++;
681 sprintf(print_tb_buf + strlen(print_tb_buf),
682 "* %d * %4d * %2d * * %2d * * %2d *\n",
683 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
684 tb->blknum[h]);
685 } while (tb->insert_size[h]);
686
687 sprintf(print_tb_buf + strlen(print_tb_buf),
688 "=====================================================================\n"
689 "FEB list: ");
690
691 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
692 h = 0;
693 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
694 sprintf(print_tb_buf + strlen(print_tb_buf),
695 "%p (%llu %d)%s", tb->FEB[i],
696 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
697 b_blocknr : 0ULL,
698 tb->FEB[i] ? atomic_read(&tb->FEB[i]->b_count) : 0,
699 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
700
701 sprintf(print_tb_buf + strlen(print_tb_buf),
702 "======================== the end ====================================\n");
703}
704
705void print_cur_tb(char *mes)
706{
707 printk("%s\n%s", mes, print_tb_buf);
708}
709
710static void check_leaf_block_head(struct buffer_head *bh)
711{
712 struct block_head *blkh;
713 int nr;
714
715 blkh = B_BLK_HEAD(bh);
716 nr = blkh_nr_item(blkh);
717 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
718 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
719 bh);
720 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
721 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
722 bh);
723
724}
725
726static void check_internal_block_head(struct buffer_head *bh)
727{
728 struct block_head *blkh;
729
730 blkh = B_BLK_HEAD(bh);
731 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
732 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
733
734 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
735 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
736
737 if (B_FREE_SPACE(bh) !=
738 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
739 DC_SIZE * (B_NR_ITEMS(bh) + 1))
740 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
741
742}
743
744void check_leaf(struct buffer_head *bh)
745{
746 int i;
747 struct item_head *ih;
748
749 if (!bh)
750 return;
751 check_leaf_block_head(bh);
752 for (i = 0, ih = item_head(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
753 op_check_item(ih, ih_item_body(bh, ih));
754}
755
756void check_internal(struct buffer_head *bh)
757{
758 if (!bh)
759 return;
760 check_internal_block_head(bh);
761}
762
763void print_statistics(struct super_block *s)
764{
765
766 /*
767 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
768 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
769 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
770 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
771 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
772 */
773
774}