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 <linux/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(buf: off_buf, fmt: "%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(buf: off_buf, fmt: "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(buf: off_buf, fmt: "%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(buf: off_buf, fmt: "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 int scnprintf_le_key(char *buf, size_t size, struct reiserfs_key *key) |
80 | { |
81 | if (key) |
82 | return scnprintf(buf, size, fmt: "[%d %d %s %s]" , |
83 | le32_to_cpu(key->k_dir_id), |
84 | le32_to_cpu(key->k_objectid), le_offset(key), |
85 | le_type(key)); |
86 | else |
87 | return scnprintf(buf, size, fmt: "[NULL]" ); |
88 | } |
89 | |
90 | /* %K */ |
91 | static int scnprintf_cpu_key(char *buf, size_t size, struct cpu_key *key) |
92 | { |
93 | if (key) |
94 | return scnprintf(buf, size, fmt: "[%d %d %s %s]" , |
95 | key->on_disk_key.k_dir_id, |
96 | key->on_disk_key.k_objectid, |
97 | reiserfs_cpu_offset(key), cpu_type(key)); |
98 | else |
99 | return scnprintf(buf, size, fmt: "[NULL]" ); |
100 | } |
101 | |
102 | static int scnprintf_de_head(char *buf, size_t size, |
103 | struct reiserfs_de_head *deh) |
104 | { |
105 | if (deh) |
106 | return scnprintf(buf, size, |
107 | fmt: "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]" , |
108 | deh_offset(deh), deh_dir_id(deh), |
109 | deh_objectid(deh), deh_location(deh), |
110 | deh_state(deh)); |
111 | else |
112 | return scnprintf(buf, size, fmt: "[NULL]" ); |
113 | |
114 | } |
115 | |
116 | static int scnprintf_item_head(char *buf, size_t size, struct item_head *ih) |
117 | { |
118 | if (ih) { |
119 | char *p = buf; |
120 | char * const end = buf + size; |
121 | |
122 | p += scnprintf(buf: p, size: end - p, fmt: "%s" , |
123 | (ih_version(ih) == KEY_FORMAT_3_6) ? |
124 | "*3.6* " : "*3.5*" ); |
125 | |
126 | p += scnprintf_le_key(buf: p, size: end - p, key: &ih->ih_key); |
127 | |
128 | p += scnprintf(buf: p, size: end - p, |
129 | fmt: ", item_len %d, item_location %d, free_space(entry_count) %d" , |
130 | ih_item_len(ih), ih_location(ih), |
131 | ih_free_space(ih)); |
132 | return p - buf; |
133 | } else |
134 | return scnprintf(buf, size, fmt: "[NULL]" ); |
135 | } |
136 | |
137 | static int scnprintf_direntry(char *buf, size_t size, |
138 | struct reiserfs_dir_entry *de) |
139 | { |
140 | char name[20]; |
141 | |
142 | memcpy(name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen); |
143 | name[de->de_namelen > 19 ? 19 : de->de_namelen] = 0; |
144 | return scnprintf(buf, size, fmt: "\"%s\"==>[%d %d]" , |
145 | name, de->de_dir_id, de->de_objectid); |
146 | } |
147 | |
148 | static int scnprintf_block_head(char *buf, size_t size, struct buffer_head *bh) |
149 | { |
150 | return scnprintf(buf, size, |
151 | fmt: "level=%d, nr_items=%d, free_space=%d rdkey " , |
152 | B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh)); |
153 | } |
154 | |
155 | static int scnprintf_buffer_head(char *buf, size_t size, struct buffer_head *bh) |
156 | { |
157 | return scnprintf(buf, size, |
158 | fmt: "dev %pg, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)" , |
159 | bh->b_bdev, bh->b_size, |
160 | (unsigned long long)bh->b_blocknr, |
161 | atomic_read(v: &(bh->b_count)), |
162 | bh->b_state, bh->b_page, |
163 | buffer_uptodate(bh) ? "UPTODATE" : "!UPTODATE" , |
164 | buffer_dirty(bh) ? "DIRTY" : "CLEAN" , |
165 | buffer_locked(bh) ? "LOCKED" : "UNLOCKED" ); |
166 | } |
167 | |
168 | static int scnprintf_disk_child(char *buf, size_t size, struct disk_child *dc) |
169 | { |
170 | return scnprintf(buf, size, fmt: "[dc_number=%d, dc_size=%u]" , |
171 | dc_block_number(dc), dc_size(dc)); |
172 | } |
173 | |
174 | static char *is_there_reiserfs_struct(char *fmt, int *what) |
175 | { |
176 | char *k = fmt; |
177 | |
178 | while ((k = strchr(k, '%')) != NULL) { |
179 | if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' || |
180 | k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') { |
181 | *what = k[1]; |
182 | break; |
183 | } |
184 | k++; |
185 | } |
186 | return k; |
187 | } |
188 | |
189 | /* |
190 | * debugging reiserfs we used to print out a lot of different |
191 | * variables, like keys, item headers, buffer heads etc. Values of |
192 | * most fields matter. So it took a long time just to write |
193 | * appropriative printk. With this reiserfs_warning you can use format |
194 | * specification for complex structures like you used to do with |
195 | * printfs for integers, doubles and pointers. For instance, to print |
196 | * out key structure you have to write just: |
197 | * reiserfs_warning ("bad key %k", key); |
198 | * instead of |
199 | * printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid, |
200 | * key->k_offset, key->k_uniqueness); |
201 | */ |
202 | static DEFINE_SPINLOCK(error_lock); |
203 | static void prepare_error_buf(const char *fmt, va_list args) |
204 | { |
205 | char *fmt1 = fmt_buf; |
206 | char *k; |
207 | char *p = error_buf; |
208 | char * const end = &error_buf[sizeof(error_buf)]; |
209 | int what; |
210 | |
211 | spin_lock(lock: &error_lock); |
212 | |
213 | if (WARN_ON(strscpy(fmt_buf, fmt, sizeof(fmt_buf)) < 0)) { |
214 | strscpy(p: error_buf, q: "format string too long" , size: end - error_buf); |
215 | goto out_unlock; |
216 | } |
217 | |
218 | while ((k = is_there_reiserfs_struct(fmt: fmt1, what: &what)) != NULL) { |
219 | *k = 0; |
220 | |
221 | p += vscnprintf(buf: p, size: end - p, fmt: fmt1, args); |
222 | |
223 | switch (what) { |
224 | case 'k': |
225 | p += scnprintf_le_key(buf: p, size: end - p, |
226 | va_arg(args, struct reiserfs_key *)); |
227 | break; |
228 | case 'K': |
229 | p += scnprintf_cpu_key(buf: p, size: end - p, |
230 | va_arg(args, struct cpu_key *)); |
231 | break; |
232 | case 'h': |
233 | p += scnprintf_item_head(buf: p, size: end - p, |
234 | va_arg(args, struct item_head *)); |
235 | break; |
236 | case 't': |
237 | p += scnprintf_direntry(buf: p, size: end - p, |
238 | va_arg(args, struct reiserfs_dir_entry *)); |
239 | break; |
240 | case 'y': |
241 | p += scnprintf_disk_child(buf: p, size: end - p, |
242 | va_arg(args, struct disk_child *)); |
243 | break; |
244 | case 'z': |
245 | p += scnprintf_block_head(buf: p, size: end - p, |
246 | va_arg(args, struct buffer_head *)); |
247 | break; |
248 | case 'b': |
249 | p += scnprintf_buffer_head(buf: p, size: end - p, |
250 | va_arg(args, struct buffer_head *)); |
251 | break; |
252 | case 'a': |
253 | p += scnprintf_de_head(buf: p, size: end - p, |
254 | va_arg(args, struct reiserfs_de_head *)); |
255 | break; |
256 | } |
257 | |
258 | fmt1 = k + 2; |
259 | } |
260 | p += vscnprintf(buf: p, size: end - p, fmt: fmt1, args); |
261 | out_unlock: |
262 | spin_unlock(lock: &error_lock); |
263 | |
264 | } |
265 | |
266 | /* |
267 | * in addition to usual conversion specifiers this accepts reiserfs |
268 | * specific conversion specifiers: |
269 | * %k to print little endian key, |
270 | * %K to print cpu key, |
271 | * %h to print item_head, |
272 | * %t to print directory entry |
273 | * %z to print block head (arg must be struct buffer_head * |
274 | * %b to print buffer_head |
275 | */ |
276 | |
277 | #define do_reiserfs_warning(fmt)\ |
278 | {\ |
279 | va_list args;\ |
280 | va_start( args, fmt );\ |
281 | prepare_error_buf( fmt, args );\ |
282 | va_end( args );\ |
283 | } |
284 | |
285 | void __reiserfs_warning(struct super_block *sb, const char *id, |
286 | const char *function, const char *fmt, ...) |
287 | { |
288 | do_reiserfs_warning(fmt); |
289 | if (sb) |
290 | printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: " |
291 | "%s\n" , sb->s_id, id ? id : "" , id ? " " : "" , |
292 | function, error_buf); |
293 | else |
294 | printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n" , |
295 | id ? id : "" , id ? " " : "" , function, error_buf); |
296 | } |
297 | |
298 | /* No newline.. reiserfs_info calls can be followed by printk's */ |
299 | void reiserfs_info(struct super_block *sb, const char *fmt, ...) |
300 | { |
301 | do_reiserfs_warning(fmt); |
302 | if (sb) |
303 | printk(KERN_NOTICE "REISERFS (device %s): %s" , |
304 | sb->s_id, error_buf); |
305 | else |
306 | printk(KERN_NOTICE "REISERFS %s:" , error_buf); |
307 | } |
308 | |
309 | /* No newline.. reiserfs_printk calls can be followed by printk's */ |
310 | static void reiserfs_printk(const char *fmt, ...) |
311 | { |
312 | do_reiserfs_warning(fmt); |
313 | printk(error_buf); |
314 | } |
315 | |
316 | void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...) |
317 | { |
318 | #ifdef CONFIG_REISERFS_CHECK |
319 | do_reiserfs_warning(fmt); |
320 | if (s) |
321 | printk(KERN_DEBUG "REISERFS debug (device %s): %s\n" , |
322 | s->s_id, error_buf); |
323 | else |
324 | printk(KERN_DEBUG "REISERFS debug: %s\n" , error_buf); |
325 | #endif |
326 | } |
327 | |
328 | /* |
329 | * The format: |
330 | * |
331 | * maintainer-errorid: [function-name:] message |
332 | * |
333 | * where errorid is unique to the maintainer and function-name is |
334 | * optional, is recommended, so that anyone can easily find the bug |
335 | * with a simple grep for the short to type string |
336 | * maintainer-errorid. Don't bother with reusing errorids, there are |
337 | * lots of numbers out there. |
338 | * |
339 | * Example: |
340 | * |
341 | * reiserfs_panic( |
342 | * p_sb, "reiser-29: reiserfs_new_blocknrs: " |
343 | * "one of search_start or rn(%d) is equal to MAX_B_NUM," |
344 | * "which means that we are optimizing location based on the " |
345 | * "bogus location of a temp buffer (%p).", |
346 | * rn, bh |
347 | * ); |
348 | * |
349 | * Regular panic()s sometimes clear the screen before the message can |
350 | * be read, thus the need for the while loop. |
351 | * |
352 | * Numbering scheme for panic used by Vladimir and Anatoly( Hans completely |
353 | * ignores this scheme, and considers it pointless complexity): |
354 | * |
355 | * panics in reiserfs_fs.h have numbers from 1000 to 1999 |
356 | * super.c 2000 to 2999 |
357 | * preserve.c (unused) 3000 to 3999 |
358 | * bitmap.c 4000 to 4999 |
359 | * stree.c 5000 to 5999 |
360 | * prints.c 6000 to 6999 |
361 | * namei.c 7000 to 7999 |
362 | * fix_nodes.c 8000 to 8999 |
363 | * dir.c 9000 to 9999 |
364 | * lbalance.c 10000 to 10999 |
365 | * ibalance.c 11000 to 11999 not ready |
366 | * do_balan.c 12000 to 12999 |
367 | * inode.c 13000 to 13999 |
368 | * file.c 14000 to 14999 |
369 | * objectid.c 15000 - 15999 |
370 | * buffer.c 16000 - 16999 |
371 | * symlink.c 17000 - 17999 |
372 | * |
373 | * . */ |
374 | |
375 | void __reiserfs_panic(struct super_block *sb, const char *id, |
376 | const char *function, const char *fmt, ...) |
377 | { |
378 | do_reiserfs_warning(fmt); |
379 | |
380 | #ifdef CONFIG_REISERFS_CHECK |
381 | dump_stack(); |
382 | #endif |
383 | if (sb) |
384 | printk(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n" , |
385 | sb->s_id, id ? id : "" , id ? " " : "" , |
386 | function, error_buf); |
387 | else |
388 | printk(KERN_WARNING "REISERFS panic: %s%s%s: %s\n" , |
389 | id ? id : "" , id ? " " : "" , function, error_buf); |
390 | BUG(); |
391 | } |
392 | |
393 | void __reiserfs_error(struct super_block *sb, const char *id, |
394 | const char *function, const char *fmt, ...) |
395 | { |
396 | do_reiserfs_warning(fmt); |
397 | |
398 | BUG_ON(sb == NULL); |
399 | |
400 | if (reiserfs_error_panic(sb)) |
401 | __reiserfs_panic(sb, id, function, fmt: error_buf); |
402 | |
403 | if (id && id[0]) |
404 | printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n" , |
405 | sb->s_id, id, function, error_buf); |
406 | else |
407 | printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n" , |
408 | sb->s_id, function, error_buf); |
409 | |
410 | if (sb_rdonly(sb)) |
411 | return; |
412 | |
413 | reiserfs_info(sb, fmt: "Remounting filesystem read-only\n" ); |
414 | sb->s_flags |= SB_RDONLY; |
415 | reiserfs_abort_journal(sb, errno: -EIO); |
416 | } |
417 | |
418 | void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...) |
419 | { |
420 | do_reiserfs_warning(fmt); |
421 | |
422 | if (reiserfs_error_panic(sb)) { |
423 | panic(KERN_CRIT "REISERFS panic (device %s): %s\n" , sb->s_id, |
424 | error_buf); |
425 | } |
426 | |
427 | if (reiserfs_is_journal_aborted(SB_JOURNAL(sb))) |
428 | return; |
429 | |
430 | printk(KERN_CRIT "REISERFS abort (device %s): %s\n" , sb->s_id, |
431 | error_buf); |
432 | |
433 | sb->s_flags |= SB_RDONLY; |
434 | reiserfs_abort_journal(sb, errno); |
435 | } |
436 | |
437 | /* |
438 | * this prints internal nodes (4 keys/items in line) (dc_number, |
439 | * dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number, |
440 | * dc_size)... |
441 | */ |
442 | static int print_internal(struct buffer_head *bh, int first, int last) |
443 | { |
444 | struct reiserfs_key *key; |
445 | struct disk_child *dc; |
446 | int i; |
447 | int from, to; |
448 | |
449 | if (!B_IS_KEYS_LEVEL(bh)) |
450 | return 1; |
451 | |
452 | check_internal(bh); |
453 | |
454 | if (first == -1) { |
455 | from = 0; |
456 | to = B_NR_ITEMS(bh); |
457 | } else { |
458 | from = first; |
459 | to = min_t(int, last, B_NR_ITEMS(bh)); |
460 | } |
461 | |
462 | reiserfs_printk(fmt: "INTERNAL NODE (%ld) contains %z\n" , bh->b_blocknr, bh); |
463 | |
464 | dc = B_N_CHILD(bh, from); |
465 | reiserfs_printk(fmt: "PTR %d: %y " , from, dc); |
466 | |
467 | for (i = from, key = internal_key(bh, item_num: from), dc++; i < to; |
468 | i++, key++, dc++) { |
469 | reiserfs_printk(fmt: "KEY %d: %k PTR %d: %y " , i, key, i + 1, dc); |
470 | if (i && i % 4 == 0) |
471 | printk("\n" ); |
472 | } |
473 | printk("\n" ); |
474 | return 0; |
475 | } |
476 | |
477 | static int print_leaf(struct buffer_head *bh, int print_mode, int first, |
478 | int last) |
479 | { |
480 | struct block_head *blkh; |
481 | struct item_head *ih; |
482 | int i, nr; |
483 | int from, to; |
484 | |
485 | if (!B_IS_ITEMS_LEVEL(bh)) |
486 | return 1; |
487 | |
488 | check_leaf(bh); |
489 | |
490 | blkh = B_BLK_HEAD(bh); |
491 | ih = item_head(bh, item_num: 0); |
492 | nr = blkh_nr_item(blkh); |
493 | |
494 | printk |
495 | ("\n===================================================================\n" ); |
496 | reiserfs_printk(fmt: "LEAF NODE (%ld) contains %z\n" , bh->b_blocknr, bh); |
497 | |
498 | if (!(print_mode & PRINT_LEAF_ITEMS)) { |
499 | reiserfs_printk(fmt: "FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n" , |
500 | &(ih->ih_key), &((ih + nr - 1)->ih_key)); |
501 | return 0; |
502 | } |
503 | |
504 | if (first < 0 || first > nr - 1) |
505 | from = 0; |
506 | else |
507 | from = first; |
508 | |
509 | if (last < 0 || last > nr) |
510 | to = nr; |
511 | else |
512 | to = last; |
513 | |
514 | ih += from; |
515 | printk |
516 | ("-------------------------------------------------------------------------------\n" ); |
517 | printk |
518 | ("|##| type | key | ilen | free_space | version | loc |\n" ); |
519 | for (i = from; i < to; i++, ih++) { |
520 | printk |
521 | ("-------------------------------------------------------------------------------\n" ); |
522 | reiserfs_printk(fmt: "|%2d| %h |\n" , i, ih); |
523 | if (print_mode & PRINT_LEAF_ITEMS) |
524 | op_print_item(ih, ih_item_body(bh, ih)); |
525 | } |
526 | |
527 | printk |
528 | ("===================================================================\n" ); |
529 | |
530 | return 0; |
531 | } |
532 | |
533 | char *reiserfs_hashname(int code) |
534 | { |
535 | if (code == YURA_HASH) |
536 | return "rupasov" ; |
537 | if (code == TEA_HASH) |
538 | return "tea" ; |
539 | if (code == R5_HASH) |
540 | return "r5" ; |
541 | |
542 | return "unknown" ; |
543 | } |
544 | |
545 | /* return 1 if this is not super block */ |
546 | static int print_super_block(struct buffer_head *bh) |
547 | { |
548 | struct reiserfs_super_block *rs = |
549 | (struct reiserfs_super_block *)(bh->b_data); |
550 | int skipped, data_blocks; |
551 | char *version; |
552 | |
553 | if (is_reiserfs_3_5(rs)) { |
554 | version = "3.5" ; |
555 | } else if (is_reiserfs_3_6(rs)) { |
556 | version = "3.6" ; |
557 | } else if (is_reiserfs_jr(rs)) { |
558 | version = ((sb_version(rs) == REISERFS_VERSION_2) ? |
559 | "3.6" : "3.5" ); |
560 | } else { |
561 | return 1; |
562 | } |
563 | |
564 | printk("%pg\'s super block is in block %llu\n" , bh->b_bdev, |
565 | (unsigned long long)bh->b_blocknr); |
566 | printk("Reiserfs version %s\n" , version); |
567 | printk("Block count %u\n" , sb_block_count(rs)); |
568 | printk("Blocksize %d\n" , sb_blocksize(rs)); |
569 | printk("Free blocks %u\n" , sb_free_blocks(rs)); |
570 | /* |
571 | * FIXME: this would be confusing if |
572 | * someone stores reiserfs super block in some data block ;) |
573 | // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs); |
574 | */ |
575 | skipped = bh->b_blocknr; |
576 | data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) - |
577 | (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) + |
578 | 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs); |
579 | printk |
580 | ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n" |
581 | "1 super block, %d data blocks\n" , skipped, sb_bmap_nr(rs), |
582 | (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) : |
583 | sb_reserved_for_journal(rs)), data_blocks); |
584 | printk("Root block %u\n" , sb_root_block(rs)); |
585 | printk("Journal block (first) %d\n" , sb_jp_journal_1st_block(rs)); |
586 | printk("Journal dev %d\n" , sb_jp_journal_dev(rs)); |
587 | printk("Journal orig size %d\n" , sb_jp_journal_size(rs)); |
588 | printk("FS state %d\n" , sb_fs_state(rs)); |
589 | printk("Hash function \"%s\"\n" , |
590 | reiserfs_hashname(sb_hash_function_code(rs))); |
591 | |
592 | printk("Tree height %d\n" , sb_tree_height(rs)); |
593 | return 0; |
594 | } |
595 | |
596 | static int print_desc_block(struct buffer_head *bh) |
597 | { |
598 | struct reiserfs_journal_desc *desc; |
599 | |
600 | if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, size: 8)) |
601 | return 1; |
602 | |
603 | desc = (struct reiserfs_journal_desc *)(bh->b_data); |
604 | printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)" , |
605 | (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc), |
606 | get_desc_mount_id(desc), get_desc_trans_len(desc)); |
607 | |
608 | return 0; |
609 | } |
610 | /* ..., int print_mode, int first, int last) */ |
611 | void print_block(struct buffer_head *bh, ...) |
612 | { |
613 | va_list args; |
614 | int mode, first, last; |
615 | |
616 | if (!bh) { |
617 | printk("print_block: buffer is NULL\n" ); |
618 | return; |
619 | } |
620 | |
621 | va_start(args, bh); |
622 | |
623 | mode = va_arg(args, int); |
624 | first = va_arg(args, int); |
625 | last = va_arg(args, int); |
626 | if (print_leaf(bh, print_mode: mode, first, last)) |
627 | if (print_internal(bh, first, last)) |
628 | if (print_super_block(bh)) |
629 | if (print_desc_block(bh)) |
630 | printk |
631 | ("Block %llu contains unformatted data\n" , |
632 | (unsigned long long)bh->b_blocknr); |
633 | |
634 | va_end(args); |
635 | } |
636 | |
637 | static char print_tb_buf[2048]; |
638 | |
639 | /* this stores initial state of tree balance in the print_tb_buf */ |
640 | void store_print_tb(struct tree_balance *tb) |
641 | { |
642 | int h = 0; |
643 | int i; |
644 | struct buffer_head *tbSh, *tbFh; |
645 | |
646 | if (!tb) |
647 | return; |
648 | |
649 | sprintf(buf: print_tb_buf, fmt: "\n" |
650 | "BALANCING %d\n" |
651 | "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n" |
652 | "=====================================================================\n" |
653 | "* h * S * L * R * F * FL * FR * CFL * CFR *\n" , |
654 | REISERFS_SB(sb: tb->tb_sb)->s_do_balance, |
655 | tb->tb_mode, PATH_LAST_POSITION(tb->tb_path), |
656 | tb->tb_path->pos_in_item); |
657 | |
658 | for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) { |
659 | if (PATH_H_PATH_OFFSET(tb->tb_path, h) <= |
660 | tb->tb_path->path_length |
661 | && PATH_H_PATH_OFFSET(tb->tb_path, |
662 | h) > ILLEGAL_PATH_ELEMENT_OFFSET) { |
663 | tbSh = PATH_H_PBUFFER(tb->tb_path, h); |
664 | tbFh = PATH_H_PPARENT(tb->tb_path, h); |
665 | } else { |
666 | tbSh = NULL; |
667 | tbFh = NULL; |
668 | } |
669 | sprintf(buf: print_tb_buf + strlen(print_tb_buf), |
670 | fmt: "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n" , |
671 | h, |
672 | (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL), |
673 | (tbSh) ? atomic_read(v: &tbSh->b_count) : -1, |
674 | (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL), |
675 | (tb->L[h]) ? atomic_read(v: &tb->L[h]->b_count) : -1, |
676 | (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL), |
677 | (tb->R[h]) ? atomic_read(v: &tb->R[h]->b_count) : -1, |
678 | (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL), |
679 | (tb->FL[h]) ? (long long)(tb->FL[h]-> |
680 | b_blocknr) : (-1LL), |
681 | (tb->FR[h]) ? (long long)(tb->FR[h]-> |
682 | b_blocknr) : (-1LL), |
683 | (tb->CFL[h]) ? (long long)(tb->CFL[h]-> |
684 | b_blocknr) : (-1LL), |
685 | (tb->CFR[h]) ? (long long)(tb->CFR[h]-> |
686 | b_blocknr) : (-1LL)); |
687 | } |
688 | |
689 | sprintf(buf: print_tb_buf + strlen(print_tb_buf), |
690 | fmt: "=====================================================================\n" |
691 | "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n" |
692 | "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n" , |
693 | tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0], |
694 | tb->rbytes, tb->blknum[0], tb->s0num, tb->snum[0], |
695 | tb->sbytes[0], tb->snum[1], tb->sbytes[1], |
696 | tb->cur_blknum, tb->lkey[0], tb->rkey[0]); |
697 | |
698 | /* this prints balance parameters for non-leaf levels */ |
699 | h = 0; |
700 | do { |
701 | h++; |
702 | sprintf(buf: print_tb_buf + strlen(print_tb_buf), |
703 | fmt: "* %d * %4d * %2d * * %2d * * %2d *\n" , |
704 | h, tb->insert_size[h], tb->lnum[h], tb->rnum[h], |
705 | tb->blknum[h]); |
706 | } while (tb->insert_size[h]); |
707 | |
708 | sprintf(buf: print_tb_buf + strlen(print_tb_buf), |
709 | fmt: "=====================================================================\n" |
710 | "FEB list: " ); |
711 | |
712 | /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */ |
713 | h = 0; |
714 | for (i = 0; i < ARRAY_SIZE(tb->FEB); i++) |
715 | sprintf(buf: print_tb_buf + strlen(print_tb_buf), |
716 | fmt: "%p (%llu %d)%s" , tb->FEB[i], |
717 | tb->FEB[i] ? (unsigned long long)tb->FEB[i]-> |
718 | b_blocknr : 0ULL, |
719 | tb->FEB[i] ? atomic_read(v: &tb->FEB[i]->b_count) : 0, |
720 | (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", " ); |
721 | |
722 | sprintf(buf: print_tb_buf + strlen(print_tb_buf), |
723 | fmt: "======================== the end ====================================\n" ); |
724 | } |
725 | |
726 | void print_cur_tb(char *mes) |
727 | { |
728 | printk("%s\n%s" , mes, print_tb_buf); |
729 | } |
730 | |
731 | static void check_leaf_block_head(struct buffer_head *bh) |
732 | { |
733 | struct block_head *blkh; |
734 | int nr; |
735 | |
736 | blkh = B_BLK_HEAD(bh); |
737 | nr = blkh_nr_item(blkh); |
738 | if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE) |
739 | reiserfs_panic(NULL, "vs-6010" , "invalid item number %z" , |
740 | bh); |
741 | if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr) |
742 | reiserfs_panic(NULL, "vs-6020" , "invalid free space %z" , |
743 | bh); |
744 | |
745 | } |
746 | |
747 | static void check_internal_block_head(struct buffer_head *bh) |
748 | { |
749 | if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT)) |
750 | reiserfs_panic(NULL, "vs-6025" , "invalid level %z" , bh); |
751 | |
752 | if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE) |
753 | reiserfs_panic(NULL, "vs-6030" , "invalid item number %z" , bh); |
754 | |
755 | if (B_FREE_SPACE(bh) != |
756 | bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) - |
757 | DC_SIZE * (B_NR_ITEMS(bh) + 1)) |
758 | reiserfs_panic(NULL, "vs-6040" , "invalid free space %z" , bh); |
759 | |
760 | } |
761 | |
762 | void check_leaf(struct buffer_head *bh) |
763 | { |
764 | int i; |
765 | struct item_head *ih; |
766 | |
767 | if (!bh) |
768 | return; |
769 | check_leaf_block_head(bh); |
770 | for (i = 0, ih = item_head(bh, item_num: 0); i < B_NR_ITEMS(bh); i++, ih++) |
771 | op_check_item(ih, ih_item_body(bh, ih)); |
772 | } |
773 | |
774 | void check_internal(struct buffer_head *bh) |
775 | { |
776 | if (!bh) |
777 | return; |
778 | check_internal_block_head(bh); |
779 | } |
780 | |
781 | void print_statistics(struct super_block *s) |
782 | { |
783 | |
784 | /* |
785 | printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \ |
786 | bmap with search %d, without %d, dir2ind %d, ind2dir %d\n", |
787 | REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes, |
788 | REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search, |
789 | REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct); |
790 | */ |
791 | |
792 | } |
793 | |