?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: kvm: rename cpu_reset to avoid name clash
[linux-2.6.git] / fs / reiserfs / prints.c
blob54944d5a4a6e170fb55f507e9373456226eb23db
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
13 static char error_buf[1024];
14 static char fmt_buf[1024];
15 static char off_buf[80];
16
17 static 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
31 static 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
48 static 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
61 static 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 */
79 static 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 */
90 static 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
100 static 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
112 static 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
125 static 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
134 static 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
140 static 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
154 static 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
160 static 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 */
187 static DEFINE_SPINLOCK(error_lock);
188 static 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
264 void __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 */
278 void 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 */
289 static void reiserfs_printk(const char *fmt, ...)
290 {
291 do_reiserfs_warning(fmt);
292 printk(error_buf);
293 }
294
295 void 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.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
352 void __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 printk(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 printk(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
366 id ? id : "", id ? " " : "", function, error_buf);
367 BUG();
368 }
369
370 void __reiserfs_error(struct super_block *sb, const char *id,
371 const char *function, const char *fmt, ...)
372 {
373 do_reiserfs_warning(fmt);
374
375 BUG_ON(sb == NULL);
376
377 if (reiserfs_error_panic(sb))
378 __reiserfs_panic(sb, id, function, error_buf);
379
380 if (id && id[0])
381 printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
382 sb->s_id, id, function, error_buf);
383 else
384 printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
385 sb->s_id, function, error_buf);
386
387 if (sb->s_flags & MS_RDONLY)
388 return;
389
390 reiserfs_info(sb, "Remounting filesystem read-only\n");
391 sb->s_flags |= MS_RDONLY;
392 reiserfs_abort_journal(sb, -EIO);
393 }
394
395 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
396 {
397 do_reiserfs_warning(fmt);
398
399 if (reiserfs_error_panic(sb)) {
400 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
401 error_buf);
402 }
403
404 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
405 return;
406
407 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
408 error_buf);
409
410 sb->s_flags |= MS_RDONLY;
411 reiserfs_abort_journal(sb, errno);
412 }
413
414 /* this prints internal nodes (4 keys/items in line) (dc_number,
415 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
416 dc_size)...*/
417 static int print_internal(struct buffer_head *bh, int first, int last)
418 {
419 struct reiserfs_key *key;
420 struct disk_child *dc;
421 int i;
422 int from, to;
423
424 if (!B_IS_KEYS_LEVEL(bh))
425 return 1;
426
427 check_internal(bh);
428
429 if (first == -1) {
430 from = 0;
431 to = B_NR_ITEMS(bh);
432 } else {
433 from = first;
434 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
435 }
436
437 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
438
439 dc = B_N_CHILD(bh, from);
440 reiserfs_printk("PTR %d: %y ", from, dc);
441
442 for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
443 i++, key++, dc++) {
444 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
445 if (i && i % 4 == 0)
446 printk("\n");
447 }
448 printk("\n");
449 return 0;
450 }
451
452 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
453 int last)
454 {
455 struct block_head *blkh;
456 struct item_head *ih;
457 int i, nr;
458 int from, to;
459
460 if (!B_IS_ITEMS_LEVEL(bh))
461 return 1;
462
463 check_leaf(bh);
464
465 blkh = B_BLK_HEAD(bh);
466 ih = B_N_PITEM_HEAD(bh, 0);
467 nr = blkh_nr_item(blkh);
468
469 printk
470 ("\n===================================================================\n");
471 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
472
473 if (!(print_mode & PRINT_LEAF_ITEMS)) {
474 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
475 &(ih->ih_key), &((ih + nr - 1)->ih_key));
476 return 0;
477 }
478
479 if (first < 0 || first > nr - 1)
480 from = 0;
481 else
482 from = first;
483
484 if (last < 0 || last > nr)
485 to = nr;
486 else
487 to = last;
488
489 ih += from;
490 printk
491 ("-------------------------------------------------------------------------------\n");
492 printk
493 ("|##| type | key | ilen | free_space | version | loc |\n");
494 for (i = from; i < to; i++, ih++) {
495 printk
496 ("-------------------------------------------------------------------------------\n");
497 reiserfs_printk("|%2d| %h |\n", i, ih);
498 if (print_mode & PRINT_LEAF_ITEMS)
499 op_print_item(ih, B_I_PITEM(bh, ih));
500 }
501
502 printk
503 ("===================================================================\n");
504
505 return 0;
506 }
507
508 char *reiserfs_hashname(int code)
509 {
510 if (code == YURA_HASH)
511 return "rupasov";
512 if (code == TEA_HASH)
513 return "tea";
514 if (code == R5_HASH)
515 return "r5";
516
517 return "unknown";
518 }
519
520 /* return 1 if this is not super block */
521 static int print_super_block(struct buffer_head *bh)
522 {
523 struct reiserfs_super_block *rs =
524 (struct reiserfs_super_block *)(bh->b_data);
525 int skipped, data_blocks;
526 char *version;
527 char b[BDEVNAME_SIZE];
528
529 if (is_reiserfs_3_5(rs)) {
530 version = "3.5";
531 } else if (is_reiserfs_3_6(rs)) {
532 version = "3.6";
533 } else if (is_reiserfs_jr(rs)) {
534 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
535 "3.6" : "3.5");
536 } else {
537 return 1;
538 }
539
540 printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
541 (unsigned long long)bh->b_blocknr);
542 printk("Reiserfs version %s\n", version);
543 printk("Block count %u\n", sb_block_count(rs));
544 printk("Blocksize %d\n", sb_blocksize(rs));
545 printk("Free blocks %u\n", sb_free_blocks(rs));
546 // FIXME: this would be confusing if
547 // someone stores reiserfs super block in some data block ;)
548 // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
549 skipped = bh->b_blocknr;
550 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
551 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
552 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
553 printk
554 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
555 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
556 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
557 sb_reserved_for_journal(rs)), data_blocks);
558 printk("Root block %u\n", sb_root_block(rs));
559 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
560 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
561 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
562 printk("FS state %d\n", sb_fs_state(rs));
563 printk("Hash function \"%s\"\n",
564 reiserfs_hashname(sb_hash_function_code(rs)));
565
566 printk("Tree height %d\n", sb_tree_height(rs));
567 return 0;
568 }
569
570 static int print_desc_block(struct buffer_head *bh)
571 {
572 struct reiserfs_journal_desc *desc;
573
574 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
575 return 1;
576
577 desc = (struct reiserfs_journal_desc *)(bh->b_data);
578 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
579 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
580 get_desc_mount_id(desc), get_desc_trans_len(desc));
581
582 return 0;
583 }
584
585 void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
586 {
587 va_list args;
588 int mode, first, last;
589
590 if (!bh) {
591 printk("print_block: buffer is NULL\n");
592 return;
593 }
594
595 va_start(args, bh);
596
597 mode = va_arg(args, int);
598 first = va_arg(args, int);
599 last = va_arg(args, int);
600 if (print_leaf(bh, mode, first, last))
601 if (print_internal(bh, first, last))
602 if (print_super_block(bh))
603 if (print_desc_block(bh))
604 printk
605 ("Block %llu contains unformatted data\n",
606 (unsigned long long)bh->b_blocknr);
607
608 va_end(args);
609 }
610
611 static char print_tb_buf[2048];
612
613 /* this stores initial state of tree balance in the print_tb_buf */
614 void store_print_tb(struct tree_balance *tb)
615 {
616 int h = 0;
617 int i;
618 struct buffer_head *tbSh, *tbFh;
619
620 if (!tb)
621 return;
622
623 sprintf(print_tb_buf, "\n"
624 "BALANCING %d\n"
625 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
626 "=====================================================================\n"
627 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
628 REISERFS_SB(tb->tb_sb)->s_do_balance,
629 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
630 tb->tb_path->pos_in_item);
631
632 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
633 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
634 tb->tb_path->path_length
635 && PATH_H_PATH_OFFSET(tb->tb_path,
636 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
637 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
638 tbFh = PATH_H_PPARENT(tb->tb_path, h);
639 } else {
640 tbSh = NULL;
641 tbFh = NULL;
642 }
643 sprintf(print_tb_buf + strlen(print_tb_buf),
644 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
645 h,
646 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
647 (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
648 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
649 (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
650 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
651 (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
652 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
653 (tb->FL[h]) ? (long long)(tb->FL[h]->
654 b_blocknr) : (-1LL),
655 (tb->FR[h]) ? (long long)(tb->FR[h]->
656 b_blocknr) : (-1LL),
657 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
658 b_blocknr) : (-1LL),
659 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
660 b_blocknr) : (-1LL));
661 }
662
663 sprintf(print_tb_buf + strlen(print_tb_buf),
664 "=====================================================================\n"
665 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
666 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
667 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
668 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
669 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
670 tb->rkey[0]);
671
672 /* this prints balance parameters for non-leaf levels */
673 h = 0;
674 do {
675 h++;
676 sprintf(print_tb_buf + strlen(print_tb_buf),
677 "* %d * %4d * %2d * * %2d * * %2d *\n",
678 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
679 tb->blknum[h]);
680 } while (tb->insert_size[h]);
681
682 sprintf(print_tb_buf + strlen(print_tb_buf),
683 "=====================================================================\n"
684 "FEB list: ");
685
686 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
687 h = 0;
688 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
689 sprintf(print_tb_buf + strlen(print_tb_buf),
690 "%p (%llu %d)%s", tb->FEB[i],
691 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
692 b_blocknr : 0ULL,
693 tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
694 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
695
696 sprintf(print_tb_buf + strlen(print_tb_buf),
697 "======================== the end ====================================\n");
698 }
699
700 void print_cur_tb(char *mes)
701 {
702 printk("%s\n%s", mes, print_tb_buf);
703 }
704
705 static void check_leaf_block_head(struct buffer_head *bh)
706 {
707 struct block_head *blkh;
708 int nr;
709
710 blkh = B_BLK_HEAD(bh);
711 nr = blkh_nr_item(blkh);
712 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
713 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
714 bh);
715 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
716 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
717 bh);
718
719 }
720
721 static void check_internal_block_head(struct buffer_head *bh)
722 {
723 struct block_head *blkh;
724
725 blkh = B_BLK_HEAD(bh);
726 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
727 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
728
729 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
730 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
731
732 if (B_FREE_SPACE(bh) !=
733 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
734 DC_SIZE * (B_NR_ITEMS(bh) + 1))
735 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
736
737 }
738
739 void check_leaf(struct buffer_head *bh)
740 {
741 int i;
742 struct item_head *ih;
743
744 if (!bh)
745 return;
746 check_leaf_block_head(bh);
747 for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
748 op_check_item(ih, B_I_PITEM(bh, ih));
749 }
750
751 void check_internal(struct buffer_head *bh)
752 {
753 if (!bh)
754 return;
755 check_internal_block_head(bh);
756 }
757
758 void print_statistics(struct super_block *s)
759 {
760
761 /*
762 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
763 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
764 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
765 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
766 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
767 */
768
769 }
Linus' kernel tree