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 <linux/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 = min_t(int, 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 <linux/reiserfs_fs.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, "%Lu(%Lu)",
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, "%Lu(%Lu)",
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 char b[BDEVNAME_SIZE];
143
144 sprintf(buf,
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");
152}
153
154static void sprintf_disk_child(char *buf, struct disk_child *dc)
155{
156 sprintf(buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc),
157 dc_size(dc));
158}
159
160static char *is_there_reiserfs_struct(char *fmt, int *what)
161{
162 char *k = fmt;
163
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') {
167 *what = k[1];
168 break;
169 }
170 k++;
171 }
172 return k;
173}
174
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);
183 instead of
184 printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
185 key->k_offset, key->k_uniqueness);
186*/
187static DEFINE_SPINLOCK(error_lock);
188static void prepare_error_buf(const char *fmt, va_list args)
189{
190 char *fmt1 = fmt_buf;
191 char *k;
192 char *p = error_buf;
193 int what;
194
195 spin_lock(&error_lock);
196
197 strcpy(fmt1, fmt);
198
199 while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
200 *k = 0;
201
202 p += vsprintf(p, fmt1, args);
203
204 switch (what) {
205 case 'k':
206 sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
207 break;
208 case 'K':
209 sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
210 break;
211 case 'h':
212 sprintf_item_head(p, va_arg(args, struct item_head *));
213 break;
214 case 't':
215 sprintf_direntry(p,
216 va_arg(args,
217 struct reiserfs_dir_entry *));
218 break;
219 case 'y':
220 sprintf_disk_child(p,
221 va_arg(args, struct disk_child *));
222 break;
223 case 'z':
224 sprintf_block_head(p,
225 va_arg(args, struct buffer_head *));
226 break;
227 case 'b':
228 sprintf_buffer_head(p,
229 va_arg(args, struct buffer_head *));
230 break;
231 case 'a':
232 sprintf_de_head(p,
233 va_arg(args,
234 struct reiserfs_de_head *));
235 break;
236 }
237
238 p += strlen(p);
239 fmt1 = k + 2;
240 }
241 vsprintf(p, fmt1, args);
242 spin_unlock(&error_lock);
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/* The format:
308
309 maintainer-errorid: [function-name:] message
310
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.
316
317 Example:
318
319 reiserfs_panic(
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).",
323 rn, bh
324 );
325
326 Regular panic()s sometimes clear the screen before the message can
327 be read, thus the need for the while loop.
328
329 Numbering scheme for panic used by Vladimir and Anatoly( Hans completely ignores this scheme, and considers it
330 pointless complexity):
331
332 panics in reiserfs_fs.h have numbers from 1000 to 1999
333 super.c 2000 to 2999
334 preserve.c (unused) 3000 to 3999
335 bitmap.c 4000 to 4999
336 stree.c 5000 to 5999
337 prints.c 6000 to 6999
338 namei.c 7000 to 7999
339 fix_nodes.c 8000 to 8999
340 dir.c 9000 to 9999
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
349
350 . */
351
352void __reiserfs_panic(struct super_block *sb, const char *id,
353 const char *function, const char *fmt, ...)
354{
355 do_reiserfs_warning(fmt);
356
357#ifdef CONFIG_REISERFS_CHECK
358 dump_stack();
359#endif
360 if (sb)
361 panic(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
362 sb->s_id, id ? id : "", id ? " " : "",
363 function, error_buf);
364 else
365 panic(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
366 id ? id : "", id ? " " : "", function, error_buf);
367}
368
369void __reiserfs_error(struct super_block *sb, const char *id,
370 const char *function, const char *fmt, ...)
371{
372 do_reiserfs_warning(fmt);
373
374 BUG_ON(sb == NULL);
375
376 if (reiserfs_error_panic(sb))
377 __reiserfs_panic(sb, id, function, error_buf);
378
379 if (id && id[0])
380 printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
381 sb->s_id, id, function, error_buf);
382 else
383 printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
384 sb->s_id, function, error_buf);
385
386 if (sb->s_flags & MS_RDONLY)
387 return;
388
389 reiserfs_info(sb, "Remounting filesystem read-only\n");
390 sb->s_flags |= MS_RDONLY;
391 reiserfs_abort_journal(sb, -EIO);
392}
393
394void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
395{
396 do_reiserfs_warning(fmt);
397
398 if (reiserfs_error_panic(sb)) {
399 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
400 error_buf);
401 }
402
403 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
404 return;
405
406 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
407 error_buf);
408
409 sb->s_flags |= MS_RDONLY;
410 reiserfs_abort_journal(sb, errno);
411}
412
413/* this prints internal nodes (4 keys/items in line) (dc_number,
414 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
415 dc_size)...*/
416static int print_internal(struct buffer_head *bh, int first, int last)
417{
418 struct reiserfs_key *key;
419 struct disk_child *dc;
420 int i;
421 int from, to;
422
423 if (!B_IS_KEYS_LEVEL(bh))
424 return 1;
425
426 check_internal(bh);
427
428 if (first == -1) {
429 from = 0;
430 to = B_NR_ITEMS(bh);
431 } else {
432 from = first;
433 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
434 }
435
436 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
437
438 dc = B_N_CHILD(bh, from);
439 reiserfs_printk("PTR %d: %y ", from, dc);
440
441 for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
442 i++, key++, dc++) {
443 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
444 if (i && i % 4 == 0)
445 printk("\n");
446 }
447 printk("\n");
448 return 0;
449}
450
451static int print_leaf(struct buffer_head *bh, int print_mode, int first,
452 int last)
453{
454 struct block_head *blkh;
455 struct item_head *ih;
456 int i, nr;
457 int from, to;
458
459 if (!B_IS_ITEMS_LEVEL(bh))
460 return 1;
461
462 check_leaf(bh);
463
464 blkh = B_BLK_HEAD(bh);
465 ih = B_N_PITEM_HEAD(bh, 0);
466 nr = blkh_nr_item(blkh);
467
468 printk
469 ("\n===================================================================\n");
470 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
471
472 if (!(print_mode & PRINT_LEAF_ITEMS)) {
473 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
474 &(ih->ih_key), &((ih + nr - 1)->ih_key));
475 return 0;
476 }
477
478 if (first < 0 || first > nr - 1)
479 from = 0;
480 else
481 from = first;
482
483 if (last < 0 || last > nr)
484 to = nr;
485 else
486 to = last;
487
488 ih += from;
489 printk
490 ("-------------------------------------------------------------------------------\n");
491 printk
492 ("|##| type | key | ilen | free_space | version | loc |\n");
493 for (i = from; i < to; i++, ih++) {
494 printk
495 ("-------------------------------------------------------------------------------\n");
496 reiserfs_printk("|%2d| %h |\n", i, ih);
497 if (print_mode & PRINT_LEAF_ITEMS)
498 op_print_item(ih, B_I_PITEM(bh, ih));
499 }
500
501 printk
502 ("===================================================================\n");
503
504 return 0;
505}
506
507char *reiserfs_hashname(int code)
508{
509 if (code == YURA_HASH)
510 return "rupasov";
511 if (code == TEA_HASH)
512 return "tea";
513 if (code == R5_HASH)
514 return "r5";
515
516 return "unknown";
517}
518
519/* return 1 if this is not super block */
520static int print_super_block(struct buffer_head *bh)
521{
522 struct reiserfs_super_block *rs =
523 (struct reiserfs_super_block *)(bh->b_data);
524 int skipped, data_blocks;
525 char *version;
526 char b[BDEVNAME_SIZE];
527
528 if (is_reiserfs_3_5(rs)) {
529 version = "3.5";
530 } else if (is_reiserfs_3_6(rs)) {
531 version = "3.6";
532 } else if (is_reiserfs_jr(rs)) {
533 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
534 "3.6" : "3.5");
535 } else {
536 return 1;
537 }
538
539 printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
540 (unsigned long long)bh->b_blocknr);
541 printk("Reiserfs version %s\n", version);
542 printk("Block count %u\n", sb_block_count(rs));
543 printk("Blocksize %d\n", sb_blocksize(rs));
544 printk("Free blocks %u\n", sb_free_blocks(rs));
545 // FIXME: this would be confusing if
546 // someone stores reiserfs super block in some data block ;)
547// skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
548 skipped = bh->b_blocknr;
549 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
550 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
551 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
552 printk
553 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
554 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
555 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
556 sb_reserved_for_journal(rs)), data_blocks);
557 printk("Root block %u\n", sb_root_block(rs));
558 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
559 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
560 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
561 printk("FS state %d\n", sb_fs_state(rs));
562 printk("Hash function \"%s\"\n",
563 reiserfs_hashname(sb_hash_function_code(rs)));
564
565 printk("Tree height %d\n", sb_tree_height(rs));
566 return 0;
567}
568
569static int print_desc_block(struct buffer_head *bh)
570{
571 struct reiserfs_journal_desc *desc;
572
573 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
574 return 1;
575
576 desc = (struct reiserfs_journal_desc *)(bh->b_data);
577 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
578 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
579 get_desc_mount_id(desc), get_desc_trans_len(desc));
580
581 return 0;
582}
583
584void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
585{
586 va_list args;
587 int mode, first, last;
588
589 if (!bh) {
590 printk("print_block: buffer is NULL\n");
591 return;
592 }
593
594 va_start(args, bh);
595
596 mode = va_arg(args, int);
597 first = va_arg(args, int);
598 last = va_arg(args, int);
599 if (print_leaf(bh, mode, first, last))
600 if (print_internal(bh, first, last))
601 if (print_super_block(bh))
602 if (print_desc_block(bh))
603 printk
604 ("Block %llu contains unformatted data\n",
605 (unsigned long long)bh->b_blocknr);
606
607 va_end(args);
608}
609
610static char print_tb_buf[2048];
611
612/* this stores initial state of tree balance in the print_tb_buf */
613void store_print_tb(struct tree_balance *tb)
614{
615 int h = 0;
616 int i;
617 struct buffer_head *tbSh, *tbFh;
618
619 if (!tb)
620 return;
621
622 sprintf(print_tb_buf, "\n"
623 "BALANCING %d\n"
624 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
625 "=====================================================================\n"
626 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
627 REISERFS_SB(tb->tb_sb)->s_do_balance,
628 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
629 tb->tb_path->pos_in_item);
630
631 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
632 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
633 tb->tb_path->path_length
634 && PATH_H_PATH_OFFSET(tb->tb_path,
635 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
636 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
637 tbFh = PATH_H_PPARENT(tb->tb_path, h);
638 } else {
639 tbSh = NULL;
640 tbFh = NULL;
641 }
642 sprintf(print_tb_buf + strlen(print_tb_buf),
643 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
644 h,
645 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
646 (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
647 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
648 (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
649 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
650 (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
651 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
652 (tb->FL[h]) ? (long long)(tb->FL[h]->
653 b_blocknr) : (-1LL),
654 (tb->FR[h]) ? (long long)(tb->FR[h]->
655 b_blocknr) : (-1LL),
656 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
657 b_blocknr) : (-1LL),
658 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
659 b_blocknr) : (-1LL));
660 }
661
662 sprintf(print_tb_buf + strlen(print_tb_buf),
663 "=====================================================================\n"
664 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
665 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
666 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
667 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
668 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
669 tb->rkey[0]);
670
671 /* this prints balance parameters for non-leaf levels */
672 h = 0;
673 do {
674 h++;
675 sprintf(print_tb_buf + strlen(print_tb_buf),
676 "* %d * %4d * %2d * * %2d * * %2d *\n",
677 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
678 tb->blknum[h]);
679 } while (tb->insert_size[h]);
680
681 sprintf(print_tb_buf + strlen(print_tb_buf),
682 "=====================================================================\n"
683 "FEB list: ");
684
685 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
686 h = 0;
687 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
688 sprintf(print_tb_buf + strlen(print_tb_buf),
689 "%p (%llu %d)%s", tb->FEB[i],
690 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
691 b_blocknr : 0ULL,
692 tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
693 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
694
695 sprintf(print_tb_buf + strlen(print_tb_buf),
696 "======================== the end ====================================\n");
697}
698
699void print_cur_tb(char *mes)
700{
701 printk("%s\n%s", mes, print_tb_buf);
702}
703
704static void check_leaf_block_head(struct buffer_head *bh)
705{
706 struct block_head *blkh;
707 int nr;
708
709 blkh = B_BLK_HEAD(bh);
710 nr = blkh_nr_item(blkh);
711 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
712 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
713 bh);
714 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
715 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
716 bh);
717
718}
719
720static void check_internal_block_head(struct buffer_head *bh)
721{
722 struct block_head *blkh;
723
724 blkh = B_BLK_HEAD(bh);
725 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
726 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
727
728 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
729 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
730
731 if (B_FREE_SPACE(bh) !=
732 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
733 DC_SIZE * (B_NR_ITEMS(bh) + 1))
734 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
735
736}
737
738void check_leaf(struct buffer_head *bh)
739{
740 int i;
741 struct item_head *ih;
742
743 if (!bh)
744 return;
745 check_leaf_block_head(bh);
746 for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
747 op_check_item(ih, B_I_PITEM(bh, ih));
748}
749
750void check_internal(struct buffer_head *bh)
751{
752 if (!bh)
753 return;
754 check_internal_block_head(bh);
755}
756
757void print_statistics(struct super_block *s)
758{
759
760 /*
761 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
762 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
763 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
764 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
765 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
766 */
767
768}