1
2
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
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
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
175
176
177
178
179
180
181
182
183
184
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
247
248
249
250
251
252
253
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
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
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
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
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
418
419
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
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
551
552
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
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
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
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
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
768
769
770
771
772
773
774}
775