1 /*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
4
5 #include <linux/config.h>
6 #include <linux/time.h>
7 #include <linux/fs.h>
8 #include <linux/reiserfs_fs.h>
9 #include <linux/string.h>
10 #include <linux/buffer_head.h>
11
12 #include <stdarg.h>
13
14 static char error_buf[1024];
15 static char fmt_buf[1024];
16 static char off_buf[80];
17
18
19 static char * reiserfs_cpu_offset (struct cpu_key * key)
20 {
21 if (cpu_key_k_type(key) == TYPE_DIRENTRY)
22 sprintf (off_buf, "%Lu(%Lu)",
23 (unsigned long long)GET_HASH_VALUE (cpu_key_k_offset (key)),
24 (unsigned long long)GET_GENERATION_NUMBER (cpu_key_k_offset (key)));
25 else
26 sprintf (off_buf, "0x%Lx", (unsigned long long)cpu_key_k_offset (key));
27 return off_buf;
28 }
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)GET_HASH_VALUE (le_key_k_offset (version, key)),
39 (unsigned long long)GET_GENERATION_NUMBER (le_key_k_offset (version, key)));
40 else
41 sprintf (off_buf, "0x%Lx", (unsigned long long)le_key_k_offset (version, key));
42 return off_buf;
43 }
44
45
46 static char * cpu_type (struct cpu_key * key)
47 {
48 if (cpu_key_k_type (key) == TYPE_STAT_DATA)
49 return "SD";
50 if (cpu_key_k_type (key) == TYPE_DIRENTRY)
51 return "DIR";
52 if (cpu_key_k_type (key) == TYPE_DIRECT)
53 return "DIRECT";
54 if (cpu_key_k_type (key) == TYPE_INDIRECT)
55 return "IND";
56 return "UNKNOWN";
57 }
58
59
60 static char * le_type (struct reiserfs_key * key)
61 {
62 int version;
63
64 version = le_key_version (key);
65
66 if (le_key_k_type (version, key) == TYPE_STAT_DATA)
67 return "SD";
68 if (le_key_k_type (version, key) == TYPE_DIRENTRY)
69 return "DIR";
70 if (le_key_k_type (version, key) == TYPE_DIRECT)
71 return "DIRECT";
72 if (le_key_k_type (version, key) == TYPE_INDIRECT)
73 return "IND";
74 return "UNKNOWN";
75 }
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), le_type (key));
84 else
85 sprintf (buf, "[NULL]");
86 }
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, "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]", deh_offset(deh), deh_dir_id(deh),
104 deh_objectid(deh), deh_location(deh), deh_state(deh) );
105 else
106 sprintf( buf, "[NULL]" );
107
108 }
109
110 static void sprintf_item_head (char * buf, struct item_head * ih)
111 {
112 if (ih) {
113 strcpy (buf, (ih_version (ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*");
114 sprintf_le_key (buf + strlen (buf), &(ih->ih_key));
115 sprintf (buf + strlen (buf), ", item_len %d, item_location %d, "
116 "free_space(entry_count) %d",
117 ih_item_len(ih), ih_location(ih), ih_free_space (ih));
118 } else
119 sprintf (buf, "[NULL]");
120 }
121
122
123 static void sprintf_direntry (char * buf, struct reiserfs_dir_entry * de)
124 {
125 char name[20];
126
127 memcpy (name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen);
128 name [de->de_namelen > 19 ? 19 : de->de_namelen] = 0;
129 sprintf (buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid);
130 }
131
132
133 static void sprintf_block_head (char * buf, struct buffer_head * bh)
134 {
135 sprintf (buf, "level=%d, nr_items=%d, free_space=%d rdkey ",
136 B_LEVEL (bh), B_NR_ITEMS (bh), B_FREE_SPACE (bh));
137 }
138
139
140 static void sprintf_buffer_head (char * buf, struct buffer_head * bh)
141 {
142 char b[BDEVNAME_SIZE];
143
144 sprintf (buf, "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
145 bdevname (bh->b_bdev, b), bh->b_size,
146 (unsigned long long)bh->b_blocknr,
147 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
155 static void sprintf_disk_child (char * buf, struct disk_child * dc)
156 {
157 sprintf (buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc), dc_size(dc));
158 }
159
160
161 static char * is_there_reiserfs_struct (char * fmt, int * what, int * skip)
162 {
163 char * k = fmt;
164
165 *skip = 0;
166
167 while ((k = strchr (k, '%')) != NULL)
168 {
169 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
170 k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a' ) {
171 *what = k[1];
172 break;
173 }
174 (*skip) ++;
175 k ++;
176 }
177 return k;
178 }
179
180
181 /* debugging reiserfs we used to print out a lot of different
182 variables, like keys, item headers, buffer heads etc. Values of
183 most fields matter. So it took a long time just to write
184 appropriative printk. With this reiserfs_warning you can use format
185 specification for complex structures like you used to do with
186 printfs for integers, doubles and pointers. For instance, to print
187 out key structure you have to write just:
188 reiserfs_warning ("bad key %k", key);
189 instead of
190 printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
191 key->k_offset, key->k_uniqueness);
192 */
193
194
195 static void
196 prepare_error_buf( const char *fmt, va_list args )
197 {
198 char * fmt1 = fmt_buf;
199 char * k;
200 char * p = error_buf;
201 int i, j, what, skip;
202
203 strcpy (fmt1, fmt);
204
205 while( (k = is_there_reiserfs_struct( fmt1, &what, &skip )) != NULL )
206 {
207 *k = 0;
208
209 p += vsprintf (p, fmt1, args);
210
211 for (i = 0; i < skip; i ++)
212 j = va_arg (args, int);
213
214 switch (what) {
215 case 'k':
216 sprintf_le_key (p, va_arg(args, struct reiserfs_key *));
217 break;
218 case 'K':
219 sprintf_cpu_key (p, va_arg(args, struct cpu_key *));
220 break;
221 case 'h':
222 sprintf_item_head (p, va_arg(args, struct item_head *));
223 break;
224 case 't':
225 sprintf_direntry (p, va_arg(args, struct reiserfs_dir_entry *));
226 break;
227 case 'y':
228 sprintf_disk_child (p, va_arg(args, struct disk_child *));
229 break;
230 case 'z':
231 sprintf_block_head (p, va_arg(args, struct buffer_head *));
232 break;
233 case 'b':
234 sprintf_buffer_head (p, va_arg(args, struct buffer_head *));
235 break;
236 case 'a':
237 sprintf_de_head (p, va_arg(args, struct reiserfs_de_head *));
238 break;
239 }
240
241 p += strlen (p);
242 fmt1 = k + 2;
243 }
244 vsprintf (p, fmt1, args);
245
246 }
247
248
249 /* in addition to usual conversion specifiers this accepts reiserfs
250 specific conversion specifiers:
251 %k to print little endian key,
252 %K to print cpu key,
253 %h to print item_head,
254 %t to print directory entry
255 %z to print block head (arg must be struct buffer_head *
256 %b to print buffer_head
257 */
258
259 #define do_reiserfs_warning(fmt)\
260 {\
261 va_list args;\
262 va_start( args, fmt );\
263 prepare_error_buf( fmt, args );\
264 va_end( args );\
265 }
266
267 void reiserfs_warning (struct super_block *sb, const char * fmt, ...)
268 {
269 do_reiserfs_warning(fmt);
270 if (sb)
271 printk (KERN_WARNING "ReiserFS: %s: warning: %s\n",
272 reiserfs_bdevname (sb), error_buf);
273 else
274 printk (KERN_WARNING "ReiserFS: warning: %s\n", 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: %s: %s",
283 reiserfs_bdevname (sb), 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: %s: %s\n",
301 reiserfs_bdevname (s), error_buf);
302 else
303 printk (KERN_DEBUG "ReiserFS: %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
352
353 #ifdef CONFIG_REISERFS_CHECK
354 extern struct tree_balance * cur_tb;
355 #endif
356
357 void reiserfs_panic (struct super_block * sb, const char * fmt, ...)
358 {
359 do_reiserfs_warning(fmt);
360 printk (KERN_EMERG "REISERFS: panic (device %s): %s\n",
361 reiserfs_bdevname (sb), error_buf);
362 BUG ();
363
364 /* this is not actually called, but makes reiserfs_panic() "noreturn" */
365 panic ("REISERFS: panic (device %s): %s\n",
366 reiserfs_bdevname (sb), error_buf);
367 }
368
369 void
370 reiserfs_abort (struct super_block *sb, int errno, const char *fmt, ...)
371 {
372 do_reiserfs_warning (fmt);
373
374 if (reiserfs_error_panic (sb)) {
375 panic (KERN_CRIT "REISERFS: panic (device %s): %s\n",
376 reiserfs_bdevname (sb), error_buf);
377 }
378
379 if (sb->s_flags & MS_RDONLY)
380 return;
381
382 printk (KERN_CRIT "REISERFS: abort (device %s): %s\n",
383 reiserfs_bdevname (sb), error_buf);
384
385 sb->s_flags |= MS_RDONLY;
386 reiserfs_journal_abort (sb, errno);
387 }
388
389 /* this prints internal nodes (4 keys/items in line) (dc_number,
390 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
391 dc_size)...*/
392 static int print_internal (struct buffer_head * bh, int first, int last)
393 {
394 struct reiserfs_key * key;
395 struct disk_child * dc;
396 int i;
397 int from, to;
398
399 if (!B_IS_KEYS_LEVEL (bh))
400 return 1;
401
402 check_internal (bh);
403
404 if (first == -1) {
405 from = 0;
406 to = B_NR_ITEMS (bh);
407 } else {
408 from = first;
409 to = last < B_NR_ITEMS (bh) ? last : B_NR_ITEMS (bh);
410 }
411
412 reiserfs_printk ("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
413
414 dc = B_N_CHILD (bh, from);
415 reiserfs_printk ("PTR %d: %y ", from, dc);
416
417 for (i = from, key = B_N_PDELIM_KEY (bh, from), dc ++; i < to; i ++, key ++, dc ++) {
418 reiserfs_printk ("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
419 if (i && i % 4 == 0)
420 printk ("\n");
421 }
422 printk ("\n");
423 return 0;
424 }
425
426
427
428
429
430 static int print_leaf (struct buffer_head * bh, int print_mode, int first, int last)
431 {
432 struct block_head * blkh;
433 struct item_head * ih;
434 int i, nr;
435 int from, to;
436
437 if (!B_IS_ITEMS_LEVEL (bh))
438 return 1;
439
440 check_leaf (bh);
441
442 blkh = B_BLK_HEAD (bh);
443 ih = B_N_PITEM_HEAD (bh,0);
444 nr = blkh_nr_item(blkh);
445
446 printk ("\n===================================================================\n");
447 reiserfs_printk ("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
448
449 if (!(print_mode & PRINT_LEAF_ITEMS)) {
450 reiserfs_printk ("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
451 &(ih->ih_key), &((ih + nr - 1)->ih_key));
452 return 0;
453 }
454
455 if (first < 0 || first > nr - 1)
456 from = 0;
457 else
458 from = first;
459
460 if (last < 0 || last > nr )
461 to = nr;
462 else
463 to = last;
464
465 ih += from;
466 printk ("-------------------------------------------------------------------------------\n");
467 printk ("|##| type | key | ilen | free_space | version | loc |\n");
468 for (i = from; i < to; i++, ih ++) {
469 printk ("-------------------------------------------------------------------------------\n");
470 reiserfs_printk ("|%2d| %h |\n", i, ih);
471 if (print_mode & PRINT_LEAF_ITEMS)
472 op_print_item (ih, B_I_PITEM (bh, ih));
473 }
474
475 printk ("===================================================================\n");
476
477 return 0;
478 }
479
480 char * reiserfs_hashname(int code)
481 {
482 if ( code == YURA_HASH)
483 return "rupasov";
484 if ( code == TEA_HASH)
485 return "tea";
486 if ( code == R5_HASH)
487 return "r5";
488
489 return "unknown";
490 }
491
492 /* return 1 if this is not super block */
493 static int print_super_block (struct buffer_head * bh)
494 {
495 struct reiserfs_super_block * rs = (struct reiserfs_super_block *)(bh->b_data);
496 int skipped, data_blocks;
497 char *version;
498 char b[BDEVNAME_SIZE];
499
500 if (is_reiserfs_3_5(rs)) {
501 version = "3.5";
502 } else if (is_reiserfs_3_6(rs)) {
503 version = "3.6";
504 } else if (is_reiserfs_jr(rs)) {
505 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
506 "3.6" : "3.5");
507 } else {
508 return 1;
509 }
510
511 printk ("%s\'s super block is in block %llu\n", bdevname (bh->b_bdev, b),
512 (unsigned long long)bh->b_blocknr);
513 printk ("Reiserfs version %s\n", version );
514 printk ("Block count %u\n", sb_block_count(rs));
515 printk ("Blocksize %d\n", sb_blocksize(rs));
516 printk ("Free blocks %u\n", sb_free_blocks(rs));
517 // FIXME: this would be confusing if
518 // someone stores reiserfs super block in some data block ;)
519 // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
520 skipped = bh->b_blocknr;
521 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
522 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) + 1 : sb_reserved_for_journal(rs)) -
523 sb_free_blocks(rs);
524 printk ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
525 "1 super block, %d data blocks\n",
526 skipped, sb_bmap_nr(rs), (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
527 sb_reserved_for_journal(rs)) , data_blocks);
528 printk ("Root block %u\n", sb_root_block(rs));
529 printk ("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
530 printk ("Journal dev %d\n", sb_jp_journal_dev(rs));
531 printk ("Journal orig size %d\n", sb_jp_journal_size(rs));
532 printk ("FS state %d\n", sb_fs_state(rs));
533 printk ("Hash function \"%s\"\n",
534 reiserfs_hashname(sb_hash_function_code(rs)));
535
536 printk ("Tree height %d\n", sb_tree_height(rs));
537 return 0;
538 }
539
540 static int print_desc_block (struct buffer_head * bh)
541 {
542 struct reiserfs_journal_desc * desc;
543
544 if (memcmp(get_journal_desc_magic (bh), JOURNAL_DESC_MAGIC, 8))
545 return 1;
546
547 desc = (struct reiserfs_journal_desc *)(bh->b_data);
548 printk ("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
549 (unsigned long long)bh->b_blocknr, get_desc_trans_id (desc), get_desc_mount_id (desc),
550 get_desc_trans_len (desc));
551
552 return 0;
553 }
554
555
556 void print_block (struct buffer_head * bh, ...)//int print_mode, int first, int last)
557 {
558 va_list args;
559 int mode, first, last;
560
561 va_start (args, bh);
562
563 if ( ! bh ) {
564 printk("print_block: buffer is NULL\n");
565 return;
566 }
567
568 mode = va_arg (args, int);
569 first = va_arg (args, int);
570 last = va_arg (args, int);
571 if (print_leaf (bh, mode, first, last))
572 if (print_internal (bh, first, last))
573 if (print_super_block (bh))
574 if (print_desc_block (bh))
575 printk ("Block %llu contains unformatted data\n", (unsigned long long)bh->b_blocknr);
576 }
577
578
579
580 static char print_tb_buf[2048];
581
582 /* this stores initial state of tree balance in the print_tb_buf */
583 void store_print_tb (struct tree_balance * tb)
584 {
585 int h = 0;
586 int i;
587 struct buffer_head * tbSh, * tbFh;
588
589 if (!tb)
590 return;
591
592 sprintf (print_tb_buf, "\n"
593 "BALANCING %d\n"
594 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
595 "=====================================================================\n"
596 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
597 REISERFS_SB(tb->tb_sb)->s_do_balance,
598 tb->tb_mode, PATH_LAST_POSITION (tb->tb_path), tb->tb_path->pos_in_item);
599
600 for (h = 0; h < sizeof(tb->insert_size) / sizeof (tb->insert_size[0]); h ++) {
601 if (PATH_H_PATH_OFFSET (tb->tb_path, h) <= tb->tb_path->path_length &&
602 PATH_H_PATH_OFFSET (tb->tb_path, h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
603 tbSh = PATH_H_PBUFFER (tb->tb_path, h);
604 tbFh = PATH_H_PPARENT (tb->tb_path, h);
605 } else {
606 tbSh = NULL;
607 tbFh = NULL;
608 }
609 sprintf (print_tb_buf + strlen (print_tb_buf),
610 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
611 h,
612 (tbSh) ? (long long)(tbSh->b_blocknr):(-1LL),
613 (tbSh) ? atomic_read (&(tbSh->b_count)) : -1,
614 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr):(-1LL),
615 (tb->L[h]) ? atomic_read (&(tb->L[h]->b_count)) : -1,
616 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr):(-1LL),
617 (tb->R[h]) ? atomic_read (&(tb->R[h]->b_count)) : -1,
618 (tbFh) ? (long long)(tbFh->b_blocknr):(-1LL),
619 (tb->FL[h]) ? (long long)(tb->FL[h]->b_blocknr):(-1LL),
620 (tb->FR[h]) ? (long long)(tb->FR[h]->b_blocknr):(-1LL),
621 (tb->CFL[h]) ? (long long)(tb->CFL[h]->b_blocknr):(-1LL),
622 (tb->CFR[h]) ? (long long)(tb->CFR[h]->b_blocknr):(-1LL));
623 }
624
625 sprintf (print_tb_buf + strlen (print_tb_buf),
626 "=====================================================================\n"
627 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
628 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
629 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],tb->rbytes, tb->blknum[0],
630 tb->s0num, tb->s1num,tb->s1bytes, tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0], tb->rkey[0]);
631
632 /* this prints balance parameters for non-leaf levels */
633 h = 0;
634 do {
635 h++;
636 sprintf (print_tb_buf + strlen (print_tb_buf),
637 "* %d * %4d * %2d * * %2d * * %2d *\n",
638 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h], tb->blknum[h]);
639 } while (tb->insert_size[h]);
640
641 sprintf (print_tb_buf + strlen (print_tb_buf),
642 "=====================================================================\n"
643 "FEB list: ");
644
645 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
646 h = 0;
647 for (i = 0; i < sizeof (tb->FEB) / sizeof (tb->FEB[0]); i ++)
648 sprintf (print_tb_buf + strlen (print_tb_buf),
649 "%p (%llu %d)%s", tb->FEB[i], tb->FEB[i] ? (unsigned long long)tb->FEB[i]->b_blocknr : 0ULL,
650 tb->FEB[i] ? atomic_read (&(tb->FEB[i]->b_count)) : 0,
651 (i == sizeof (tb->FEB) / sizeof (tb->FEB[0]) - 1) ? "\n" : ", ");
652
653 sprintf (print_tb_buf + strlen (print_tb_buf),
654 "======================== the end ====================================\n");
655 }
656
657 void print_cur_tb (char * mes)
658 {
659 printk ("%s\n%s", mes, print_tb_buf);
660 }
661
662 static void check_leaf_block_head (struct buffer_head * bh)
663 {
664 struct block_head * blkh;
665 int nr;
666
667 blkh = B_BLK_HEAD (bh);
668 nr = blkh_nr_item(blkh);
669 if ( nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
670 reiserfs_panic (NULL, "vs-6010: check_leaf_block_head: invalid item number %z", bh);
671 if ( blkh_free_space(blkh) >
672 bh->b_size - BLKH_SIZE - IH_SIZE * nr )
673 reiserfs_panic (NULL, "vs-6020: check_leaf_block_head: invalid free space %z", bh);
674
675 }
676
677 static void check_internal_block_head (struct buffer_head * bh)
678 {
679 struct block_head * blkh;
680
681 blkh = B_BLK_HEAD (bh);
682 if (!(B_LEVEL (bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL (bh) <= MAX_HEIGHT))
683 reiserfs_panic (NULL, "vs-6025: check_internal_block_head: invalid level %z", bh);
684
685 if (B_NR_ITEMS (bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
686 reiserfs_panic (NULL, "vs-6030: check_internal_block_head: invalid item number %z", bh);
687
688 if (B_FREE_SPACE (bh) !=
689 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS (bh) - DC_SIZE * (B_NR_ITEMS (bh) + 1))
690 reiserfs_panic (NULL, "vs-6040: check_internal_block_head: invalid free space %z", bh);
691
692 }
693
694
695 void check_leaf (struct buffer_head * bh)
696 {
697 int i;
698 struct item_head * ih;
699
700 if (!bh)
701 return;
702 check_leaf_block_head (bh);
703 for (i = 0, ih = B_N_PITEM_HEAD (bh, 0); i < B_NR_ITEMS (bh); i ++, ih ++)
704 op_check_item (ih, B_I_PITEM (bh, ih));
705 }
706
707
708 void check_internal (struct buffer_head * bh)
709 {
710 if (!bh)
711 return;
712 check_internal_block_head (bh);
713 }
714
715
716 void print_statistics (struct super_block * s)
717 {
718
719 /*
720 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
721 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
722 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
723 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
724 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
725 */
726
727 }
728
|
This page was automatically generated by the
LXR engine.
|