]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README | |
3 | */ | |
4 | ||
1da177e4 LT |
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 | ||
bd4c625c | 17 | static char *reiserfs_cpu_offset(struct cpu_key *key) |
1da177e4 | 18 | { |
bd4c625c LT |
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; | |
1da177e4 LT |
29 | } |
30 | ||
bd4c625c | 31 | static char *le_offset(struct reiserfs_key *key) |
1da177e4 | 32 | { |
bd4c625c | 33 | int version; |
1da177e4 | 34 | |
bd4c625c LT |
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; | |
1da177e4 LT |
46 | } |
47 | ||
bd4c625c | 48 | static char *cpu_type(struct cpu_key *key) |
1da177e4 | 49 | { |
bd4c625c LT |
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"; | |
1da177e4 LT |
59 | } |
60 | ||
bd4c625c | 61 | static char *le_type(struct reiserfs_key *key) |
1da177e4 | 62 | { |
bd4c625c | 63 | int version; |
1da177e4 | 64 | |
bd4c625c | 65 | version = le_key_version(key); |
1da177e4 | 66 | |
bd4c625c LT |
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 | } | |
1da177e4 LT |
77 | |
78 | /* %k */ | |
bd4c625c | 79 | static void sprintf_le_key(char *buf, struct reiserfs_key *key) |
1da177e4 | 80 | { |
bd4c625c LT |
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]"); | |
1da177e4 LT |
87 | } |
88 | ||
1da177e4 | 89 | /* %K */ |
bd4c625c | 90 | static void sprintf_cpu_key(char *buf, struct cpu_key *key) |
1da177e4 | 91 | { |
bd4c625c LT |
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]"); | |
1da177e4 LT |
98 | } |
99 | ||
bd4c625c | 100 | static void sprintf_de_head(char *buf, struct reiserfs_de_head *deh) |
1da177e4 | 101 | { |
bd4c625c LT |
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]"); | |
1da177e4 LT |
109 | |
110 | } | |
111 | ||
bd4c625c | 112 | static void sprintf_item_head(char *buf, struct item_head *ih) |
1da177e4 | 113 | { |
bd4c625c LT |
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]"); | |
1da177e4 LT |
123 | } |
124 | ||
bd4c625c | 125 | static void sprintf_direntry(char *buf, struct reiserfs_dir_entry *de) |
1da177e4 | 126 | { |
bd4c625c | 127 | char name[20]; |
1da177e4 | 128 | |
bd4c625c LT |
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); | |
1da177e4 LT |
132 | } |
133 | ||
bd4c625c | 134 | static void sprintf_block_head(char *buf, struct buffer_head *bh) |
1da177e4 | 135 | { |
bd4c625c LT |
136 | sprintf(buf, "level=%d, nr_items=%d, free_space=%d rdkey ", |
137 | B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh)); | |
1da177e4 LT |
138 | } |
139 | ||
bd4c625c | 140 | static void sprintf_buffer_head(char *buf, struct buffer_head *bh) |
1da177e4 | 141 | { |
bd4c625c | 142 | char b[BDEVNAME_SIZE]; |
1da177e4 | 143 | |
bd4c625c | 144 | sprintf(buf, |
205f87f6 | 145 | "dev %s, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)", |
bd4c625c LT |
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"); | |
1da177e4 LT |
152 | } |
153 | ||
bd4c625c | 154 | static void sprintf_disk_child(char *buf, struct disk_child *dc) |
1da177e4 | 155 | { |
bd4c625c LT |
156 | sprintf(buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc), |
157 | dc_size(dc)); | |
1da177e4 LT |
158 | } |
159 | ||
bd4c625c | 160 | static char *is_there_reiserfs_struct(char *fmt, int *what, int *skip) |
1da177e4 | 161 | { |
bd4c625c | 162 | char *k = fmt; |
1da177e4 | 163 | |
bd4c625c | 164 | *skip = 0; |
1da177e4 | 165 | |
bd4c625c LT |
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 | } | |
1da177e4 LT |
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 | ||
bd4c625c LT |
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); | |
1da177e4 LT |
246 | |
247 | } | |
248 | ||
1da177e4 LT |
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 | ||
bd4c625c | 267 | void reiserfs_warning(struct super_block *sb, const char *fmt, ...) |
1da177e4 | 268 | { |
bd4c625c LT |
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); | |
1da177e4 LT |
275 | } |
276 | ||
277 | /* No newline.. reiserfs_info calls can be followed by printk's */ | |
bd4c625c | 278 | void reiserfs_info(struct super_block *sb, const char *fmt, ...) |
1da177e4 | 279 | { |
bd4c625c LT |
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); | |
1da177e4 LT |
286 | } |
287 | ||
288 | /* No newline.. reiserfs_printk calls can be followed by printk's */ | |
bd4c625c | 289 | static void reiserfs_printk(const char *fmt, ...) |
1da177e4 | 290 | { |
bd4c625c LT |
291 | do_reiserfs_warning(fmt); |
292 | printk(error_buf); | |
1da177e4 LT |
293 | } |
294 | ||
bd4c625c | 295 | void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...) |
1da177e4 LT |
296 | { |
297 | #ifdef CONFIG_REISERFS_CHECK | |
bd4c625c LT |
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); | |
1da177e4 LT |
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 | ||
1da177e4 | 352 | #ifdef CONFIG_REISERFS_CHECK |
bd4c625c | 353 | extern struct tree_balance *cur_tb; |
1da177e4 LT |
354 | #endif |
355 | ||
bd4c625c | 356 | void reiserfs_panic(struct super_block *sb, const char *fmt, ...) |
1da177e4 | 357 | { |
bd4c625c LT |
358 | do_reiserfs_warning(fmt); |
359 | printk(KERN_EMERG "REISERFS: panic (device %s): %s\n", | |
360 | reiserfs_bdevname(sb), error_buf); | |
361 | BUG(); | |
1da177e4 | 362 | |
bd4c625c LT |
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); | |
1da177e4 LT |
366 | } |
367 | ||
bd4c625c | 368 | void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...) |
1da177e4 | 369 | { |
bd4c625c | 370 | do_reiserfs_warning(fmt); |
1da177e4 | 371 | |
bd4c625c LT |
372 | if (reiserfs_error_panic(sb)) { |
373 | panic(KERN_CRIT "REISERFS: panic (device %s): %s\n", | |
374 | reiserfs_bdevname(sb), error_buf); | |
375 | } | |
1da177e4 | 376 | |
bd4c625c LT |
377 | if (sb->s_flags & MS_RDONLY) |
378 | return; | |
1da177e4 | 379 | |
bd4c625c LT |
380 | printk(KERN_CRIT "REISERFS: abort (device %s): %s\n", |
381 | reiserfs_bdevname(sb), error_buf); | |
1da177e4 | 382 | |
bd4c625c LT |
383 | sb->s_flags |= MS_RDONLY; |
384 | reiserfs_journal_abort(sb, errno); | |
1da177e4 LT |
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)...*/ | |
bd4c625c | 390 | static int print_internal(struct buffer_head *bh, int first, int last) |
1da177e4 | 391 | { |
bd4c625c LT |
392 | struct reiserfs_key *key; |
393 | struct disk_child *dc; | |
394 | int i; | |
395 | int from, to; | |
1da177e4 | 396 | |
bd4c625c LT |
397 | if (!B_IS_KEYS_LEVEL(bh)) |
398 | return 1; | |
1da177e4 | 399 | |
bd4c625c | 400 | check_internal(bh); |
1da177e4 | 401 | |
bd4c625c LT |
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 | } | |
1da177e4 | 409 | |
bd4c625c | 410 | reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh); |
1da177e4 | 411 | |
bd4c625c LT |
412 | dc = B_N_CHILD(bh, from); |
413 | reiserfs_printk("PTR %d: %y ", from, dc); | |
1da177e4 | 414 | |
bd4c625c LT |
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 | } | |
1da177e4 | 424 | |
bd4c625c LT |
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; | |
1da177e4 | 432 | |
bd4c625c LT |
433 | if (!B_IS_ITEMS_LEVEL(bh)) |
434 | return 1; | |
1da177e4 | 435 | |
bd4c625c | 436 | check_leaf(bh); |
1da177e4 | 437 | |
bd4c625c LT |
438 | blkh = B_BLK_HEAD(bh); |
439 | ih = B_N_PITEM_HEAD(bh, 0); | |
440 | nr = blkh_nr_item(blkh); | |
1da177e4 | 441 | |
bd4c625c LT |
442 | printk |
443 | ("\n===================================================================\n"); | |
444 | reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh); | |
1da177e4 | 445 | |
bd4c625c LT |
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 | } | |
1da177e4 | 451 | |
bd4c625c LT |
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 | } | |
1da177e4 | 474 | |
bd4c625c LT |
475 | printk |
476 | ("===================================================================\n"); | |
1da177e4 | 477 | |
bd4c625c | 478 | return 0; |
1da177e4 LT |
479 | } |
480 | ||
bd4c625c | 481 | char *reiserfs_hashname(int code) |
1da177e4 | 482 | { |
bd4c625c LT |
483 | if (code == YURA_HASH) |
484 | return "rupasov"; | |
485 | if (code == TEA_HASH) | |
486 | return "tea"; | |
487 | if (code == R5_HASH) | |
488 | return "r5"; | |
1da177e4 | 489 | |
bd4c625c | 490 | return "unknown"; |
1da177e4 LT |
491 | } |
492 | ||
493 | /* return 1 if this is not super block */ | |
bd4c625c LT |
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 ;) | |
1da177e4 | 521 | // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs); |
bd4c625c LT |
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; | |
1da177e4 LT |
541 | } |
542 | ||
bd4c625c | 543 | static int print_desc_block(struct buffer_head *bh) |
1da177e4 | 544 | { |
bd4c625c | 545 | struct reiserfs_journal_desc *desc; |
1da177e4 | 546 | |
bd4c625c LT |
547 | if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8)) |
548 | return 1; | |
1da177e4 | 549 | |
bd4c625c LT |
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)); | |
1da177e4 | 554 | |
bd4c625c | 555 | return 0; |
1da177e4 LT |
556 | } |
557 | ||
bd4c625c | 558 | void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last) |
1da177e4 | 559 | { |
bd4c625c LT |
560 | va_list args; |
561 | int mode, first, last; | |
1da177e4 | 562 | |
bd4c625c | 563 | va_start(args, bh); |
1da177e4 | 564 | |
bd4c625c LT |
565 | if (!bh) { |
566 | printk("print_block: buffer is NULL\n"); | |
567 | return; | |
568 | } | |
1da177e4 | 569 | |
bd4c625c LT |
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); | |
1da177e4 LT |
580 | } |
581 | ||
1da177e4 LT |
582 | static char print_tb_buf[2048]; |
583 | ||
584 | /* this stores initial state of tree balance in the print_tb_buf */ | |
bd4c625c LT |
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 | ||
e8c96f8c | 603 | for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) { |
bd4c625c LT |
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)); | |
1da177e4 | 632 | } |
1da177e4 | 633 | |
bd4c625c LT |
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]); | |
1da177e4 | 652 | |
bd4c625c LT |
653 | sprintf(print_tb_buf + strlen(print_tb_buf), |
654 | "=====================================================================\n" | |
655 | "FEB list: "); | |
1da177e4 | 656 | |
bd4c625c LT |
657 | /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */ |
658 | h = 0; | |
e8c96f8c | 659 | for (i = 0; i < ARRAY_SIZE(tb->FEB); i++) |
bd4c625c LT |
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, | |
e8c96f8c | 665 | (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", "); |
1da177e4 | 666 | |
bd4c625c LT |
667 | sprintf(print_tb_buf + strlen(print_tb_buf), |
668 | "======================== the end ====================================\n"); | |
1da177e4 LT |
669 | } |
670 | ||
bd4c625c LT |
671 | void print_cur_tb(char *mes) |
672 | { | |
673 | printk("%s\n%s", mes, print_tb_buf); | |
674 | } | |
1da177e4 | 675 | |
bd4c625c | 676 | static void check_leaf_block_head(struct buffer_head *bh) |
1da177e4 | 677 | { |
bd4c625c LT |
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); | |
1da177e4 | 691 | |
1da177e4 LT |
692 | } |
693 | ||
bd4c625c LT |
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 | } | |
1da177e4 | 717 | |
bd4c625c | 718 | void check_leaf(struct buffer_head *bh) |
1da177e4 | 719 | { |
bd4c625c LT |
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)); | |
1da177e4 LT |
728 | } |
729 | ||
bd4c625c LT |
730 | void check_internal(struct buffer_head *bh) |
731 | { | |
732 | if (!bh) | |
733 | return; | |
734 | check_internal_block_head(bh); | |
735 | } | |
1da177e4 | 736 | |
bd4c625c | 737 | void print_statistics(struct super_block *s) |
1da177e4 LT |
738 | { |
739 | ||
bd4c625c LT |
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 | */ | |
1da177e4 LT |
747 | |
748 | } |