projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/home/rmk/linux-2.6-arm
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / reiserfs / prints.c
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
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, int *skip)
161 {
162 char *k = fmt;
163
164 *skip = 0;
165
166 while ((k = strchr(k, '%')) != NULL) {
167 if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
168 k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
169 *what = k[1];
170 break;
171 }
172 (*skip)++;
173 k++;
174 }
175 return k;
176 }
177
178 /* debugging reiserfs we used to print out a lot of different
179 variables, like keys, item headers, buffer heads etc. Values of
180 most fields matter. So it took a long time just to write
181 appropriative printk. With this reiserfs_warning you can use format
182 specification for complex structures like you used to do with
183 printfs for integers, doubles and pointers. For instance, to print
184 out key structure you have to write just:
185 reiserfs_warning ("bad key %k", key);
186 instead of
187 printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
188 key->k_offset, key->k_uniqueness);
189 */
190
191 static void prepare_error_buf(const char *fmt, va_list args)
192 {
193 char *fmt1 = fmt_buf;
194 char *k;
195 char *p = error_buf;
196 int i, j, what, skip;
197
198 strcpy(fmt1, fmt);
199
200 while ((k = is_there_reiserfs_struct(fmt1, &what, &skip)) != NULL) {
201 *k = 0;
202
203 p += vsprintf(p, fmt1, args);
204
205 for (i = 0; i < skip; i++)
206 j = va_arg(args, int);
207
208 switch (what) {
209 case 'k':
210 sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
211 break;
212 case 'K':
213 sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
214 break;
215 case 'h':
216 sprintf_item_head(p, va_arg(args, struct item_head *));
217 break;
218 case 't':
219 sprintf_direntry(p,
220 va_arg(args,
221 struct reiserfs_dir_entry *));
222 break;
223 case 'y':
224 sprintf_disk_child(p,
225 va_arg(args, struct disk_child *));
226 break;
227 case 'z':
228 sprintf_block_head(p,
229 va_arg(args, struct buffer_head *));
230 break;
231 case 'b':
232 sprintf_buffer_head(p,
233 va_arg(args, struct buffer_head *));
234 break;
235 case 'a':
236 sprintf_de_head(p,
237 va_arg(args,
238 struct reiserfs_de_head *));
239 break;
240 }
241
242 p += strlen(p);
243 fmt1 = k + 2;
244 }
245 vsprintf(p, fmt1, args);
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 #ifdef CONFIG_REISERFS_CHECK
353 extern struct tree_balance *cur_tb;
354 #endif
355
356 void reiserfs_panic(struct super_block *sb, const char *fmt, ...)
357 {
358 do_reiserfs_warning(fmt);
359 printk(KERN_EMERG "REISERFS: panic (device %s): %s\n",
360 reiserfs_bdevname(sb), error_buf);
361 BUG();
362
363 /* this is not actually called, but makes reiserfs_panic() "noreturn" */
364 panic("REISERFS: panic (device %s): %s\n",
365 reiserfs_bdevname(sb), error_buf);
366 }
367
368 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
369 {
370 do_reiserfs_warning(fmt);
371
372 if (reiserfs_error_panic(sb)) {
373 panic(KERN_CRIT "REISERFS: panic (device %s): %s\n",
374 reiserfs_bdevname(sb), error_buf);
375 }
376
377 if (sb->s_flags & MS_RDONLY)
378 return;
379
380 printk(KERN_CRIT "REISERFS: abort (device %s): %s\n",
381 reiserfs_bdevname(sb), error_buf);
382
383 sb->s_flags |= MS_RDONLY;
384 reiserfs_journal_abort(sb, errno);
385 }
386
387 /* this prints internal nodes (4 keys/items in line) (dc_number,
388 dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
389 dc_size)...*/
390 static int print_internal(struct buffer_head *bh, int first, int last)
391 {
392 struct reiserfs_key *key;
393 struct disk_child *dc;
394 int i;
395 int from, to;
396
397 if (!B_IS_KEYS_LEVEL(bh))
398 return 1;
399
400 check_internal(bh);
401
402 if (first == -1) {
403 from = 0;
404 to = B_NR_ITEMS(bh);
405 } else {
406 from = first;
407 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
408 }
409
410 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
411
412 dc = B_N_CHILD(bh, from);
413 reiserfs_printk("PTR %d: %y ", from, dc);
414
415 for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
416 i++, key++, dc++) {
417 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
418 if (i && i % 4 == 0)
419 printk("\n");
420 }
421 printk("\n");
422 return 0;
423 }
424
425 static int print_leaf(struct buffer_head *bh, int print_mode, int first,
426 int last)
427 {
428 struct block_head *blkh;
429 struct item_head *ih;
430 int i, nr;
431 int from, to;
432
433 if (!B_IS_ITEMS_LEVEL(bh))
434 return 1;
435
436 check_leaf(bh);
437
438 blkh = B_BLK_HEAD(bh);
439 ih = B_N_PITEM_HEAD(bh, 0);
440 nr = blkh_nr_item(blkh);
441
442 printk
443 ("\n===================================================================\n");
444 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
445
446 if (!(print_mode & PRINT_LEAF_ITEMS)) {
447 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
448 &(ih->ih_key), &((ih + nr - 1)->ih_key));
449 return 0;
450 }
451
452 if (first < 0 || first > nr - 1)
453 from = 0;
454 else
455 from = first;
456
457 if (last < 0 || last > nr)
458 to = nr;
459 else
460 to = last;
461
462 ih += from;
463 printk
464 ("-------------------------------------------------------------------------------\n");
465 printk
466 ("|##| type | key | ilen | free_space | version | loc |\n");
467 for (i = from; i < to; i++, ih++) {
468 printk
469 ("-------------------------------------------------------------------------------\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
476 ("===================================================================\n");
477
478 return 0;
479 }
480
481 char *reiserfs_hashname(int code)
482 {
483 if (code == YURA_HASH)
484 return "rupasov";
485 if (code == TEA_HASH)
486 return "tea";
487 if (code == R5_HASH)
488 return "r5";
489
490 return "unknown";
491 }
492
493 /* return 1 if this is not super block */
494 static int print_super_block(struct buffer_head *bh)
495 {
496 struct reiserfs_super_block *rs =
497 (struct reiserfs_super_block *)(bh->b_data);
498 int skipped, data_blocks;
499 char *version;
500 char b[BDEVNAME_SIZE];
501
502 if (is_reiserfs_3_5(rs)) {
503 version = "3.5";
504 } else if (is_reiserfs_3_6(rs)) {
505 version = "3.6";
506 } else if (is_reiserfs_jr(rs)) {
507 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
508 "3.6" : "3.5");
509 } else {
510 return 1;
511 }
512
513 printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
514 (unsigned long long)bh->b_blocknr);
515 printk("Reiserfs version %s\n", version);
516 printk("Block count %u\n", sb_block_count(rs));
517 printk("Blocksize %d\n", sb_blocksize(rs));
518 printk("Free blocks %u\n", sb_free_blocks(rs));
519 // FIXME: this would be confusing if
520 // someone stores reiserfs super block in some data block ;)
521 // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
522 skipped = bh->b_blocknr;
523 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
524 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
525 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
526 printk
527 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
528 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
529 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
530 sb_reserved_for_journal(rs)), data_blocks);
531 printk("Root block %u\n", sb_root_block(rs));
532 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
533 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
534 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
535 printk("FS state %d\n", sb_fs_state(rs));
536 printk("Hash function \"%s\"\n",
537 reiserfs_hashname(sb_hash_function_code(rs)));
538
539 printk("Tree height %d\n", sb_tree_height(rs));
540 return 0;
541 }
542
543 static int print_desc_block(struct buffer_head *bh)
544 {
545 struct reiserfs_journal_desc *desc;
546
547 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
548 return 1;
549
550 desc = (struct reiserfs_journal_desc *)(bh->b_data);
551 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
552 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
553 get_desc_mount_id(desc), get_desc_trans_len(desc));
554
555 return 0;
556 }
557
558 void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
559 {
560 va_list args;
561 int mode, first, last;
562
563 va_start(args, bh);
564
565 if (!bh) {
566 printk("print_block: buffer is NULL\n");
567 return;
568 }
569
570 mode = va_arg(args, int);
571 first = va_arg(args, int);
572 last = va_arg(args, int);
573 if (print_leaf(bh, mode, first, last))
574 if (print_internal(bh, first, last))
575 if (print_super_block(bh))
576 if (print_desc_block(bh))
577 printk
578 ("Block %llu contains unformatted data\n",
579 (unsigned long long)bh->b_blocknr);
580 }
581
582 static char print_tb_buf[2048];
583
584 /* this stores initial state of tree balance in the print_tb_buf */
585 void store_print_tb(struct tree_balance *tb)
586 {
587 int h = 0;
588 int i;
589 struct buffer_head *tbSh, *tbFh;
590
591 if (!tb)
592 return;
593
594 sprintf(print_tb_buf, "\n"
595 "BALANCING %d\n"
596 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
597 "=====================================================================\n"
598 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
599 REISERFS_SB(tb->tb_sb)->s_do_balance,
600 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
601 tb->tb_path->pos_in_item);
602
603 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
604 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
605 tb->tb_path->path_length
606 && PATH_H_PATH_OFFSET(tb->tb_path,
607 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
608 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
609 tbFh = PATH_H_PPARENT(tb->tb_path, h);
610 } else {
611 tbSh = NULL;
612 tbFh = NULL;
613 }
614 sprintf(print_tb_buf + strlen(print_tb_buf),
615 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
616 h,
617 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
618 (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
619 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
620 (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
621 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
622 (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
623 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
624 (tb->FL[h]) ? (long long)(tb->FL[h]->
625 b_blocknr) : (-1LL),
626 (tb->FR[h]) ? (long long)(tb->FR[h]->
627 b_blocknr) : (-1LL),
628 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
629 b_blocknr) : (-1LL),
630 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
631 b_blocknr) : (-1LL));
632 }
633
634 sprintf(print_tb_buf + strlen(print_tb_buf),
635 "=====================================================================\n"
636 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
637 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
638 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
639 tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
640 tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
641 tb->rkey[0]);
642
643 /* this prints balance parameters for non-leaf levels */
644 h = 0;
645 do {
646 h++;
647 sprintf(print_tb_buf + strlen(print_tb_buf),
648 "* %d * %4d * %2d * * %2d * * %2d *\n",
649 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
650 tb->blknum[h]);
651 } while (tb->insert_size[h]);
652
653 sprintf(print_tb_buf + strlen(print_tb_buf),
654 "=====================================================================\n"
655 "FEB list: ");
656
657 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
658 h = 0;
659 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
660 sprintf(print_tb_buf + strlen(print_tb_buf),
661 "%p (%llu %d)%s", tb->FEB[i],
662 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
663 b_blocknr : 0ULL,
664 tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
665 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
666
667 sprintf(print_tb_buf + strlen(print_tb_buf),
668 "======================== the end ====================================\n");
669 }
670
671 void print_cur_tb(char *mes)
672 {
673 printk("%s\n%s", mes, print_tb_buf);
674 }
675
676 static void check_leaf_block_head(struct buffer_head *bh)
677 {
678 struct block_head *blkh;
679 int nr;
680
681 blkh = B_BLK_HEAD(bh);
682 nr = blkh_nr_item(blkh);
683 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
684 reiserfs_panic(NULL,
685 "vs-6010: check_leaf_block_head: invalid item number %z",
686 bh);
687 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
688 reiserfs_panic(NULL,
689 "vs-6020: check_leaf_block_head: invalid free space %z",
690 bh);
691
692 }
693
694 static void check_internal_block_head(struct buffer_head *bh)
695 {
696 struct block_head *blkh;
697
698 blkh = B_BLK_HEAD(bh);
699 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
700 reiserfs_panic(NULL,
701 "vs-6025: check_internal_block_head: invalid level %z",
702 bh);
703
704 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
705 reiserfs_panic(NULL,
706 "vs-6030: check_internal_block_head: invalid item number %z",
707 bh);
708
709 if (B_FREE_SPACE(bh) !=
710 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
711 DC_SIZE * (B_NR_ITEMS(bh) + 1))
712 reiserfs_panic(NULL,
713 "vs-6040: check_internal_block_head: invalid free space %z",
714 bh);
715
716 }
717
718 void check_leaf(struct buffer_head *bh)
719 {
720 int i;
721 struct item_head *ih;
722
723 if (!bh)
724 return;
725 check_leaf_block_head(bh);
726 for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
727 op_check_item(ih, B_I_PITEM(bh, ih));
728 }
729
730 void check_internal(struct buffer_head *bh)
731 {
732 if (!bh)
733 return;
734 check_internal_block_head(bh);
735 }
736
737 void print_statistics(struct super_block *s)
738 {
739
740 /*
741 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
742 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
743 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
744 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
745 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
746 */
747
748 }
kernel source for telekom puls (alcatel/mediatek)