Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
prints.c
Go to the documentation of this file.
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  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 
369 void __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;
392 }
393 
394 void 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 
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)...*/
416 static 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 
451 static 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 
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 */
520 static 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) +
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",
564 
565  printk("Tree height %d\n", sb_tree_height(rs));
566  return 0;
567 }
568 
569 static int print_desc_block(struct buffer_head *bh)
570 {
571  struct reiserfs_journal_desc *desc;
572 
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),
580 
581  return 0;
582 }
583 
584 void 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 
610 static char print_tb_buf[2048];
611 
612 /* this stores initial state of tree balance in the print_tb_buf */
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,
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
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 
699 void print_cur_tb(char *mes)
700 {
701  printk("%s\n%s", mes, print_tb_buf);
702 }
703 
704 static 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 
720 static 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 
738 void 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 
750 void check_internal(struct buffer_head *bh)
751 {
752  if (!bh)
753  return;
754  check_internal_block_head(bh);
755 }
756 
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 }