blob: adbc6f538515e15f7d7982d97ab1d3fb30728551 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
4
Linus Torvalds1da177e2005-04-16 15:20:36 -07005#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
13static char error_buf[1024];
14static char fmt_buf[1024];
15static char off_buf[80];
16
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070017static char *reiserfs_cpu_offset(struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -070018{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070019 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070029}
30
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070031static char *le_offset(struct reiserfs_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -070032{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070033 int version;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070035 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046}
47
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070048static char *cpu_type(struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070050 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";
Linus Torvalds1da177e2005-04-16 15:20:36 -070059}
60
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070061static char *le_type(struct reiserfs_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070063 int version;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070065 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";
Linus Torvalds1da177e2005-04-16 15:20:36 -070076}
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078/* %k */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070079static void sprintf_le_key(char *buf, struct reiserfs_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070081 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]");
Linus Torvalds1da177e2005-04-16 15:20:36 -070087}
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089/* %K */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070090static void sprintf_cpu_key(char *buf, struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070092 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]");
Linus Torvalds1da177e2005-04-16 15:20:36 -070098}
99
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700100static void sprintf_de_head(char *buf, struct reiserfs_de_head *deh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700102 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]");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110}
111
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700112static void sprintf_item_head(char *buf, struct item_head *ih)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700114 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]");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
124
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700125static void sprintf_direntry(char *buf, struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700127 char name[20];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700129 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132}
133
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700134static void sprintf_block_head(char *buf, struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700136 sprintf(buf, "level=%d, nr_items=%d, free_space=%d rdkey ",
137 B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138}
139
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700140static void sprintf_buffer_head(char *buf, struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700142 char b[BDEVNAME_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700144 sprintf(buf,
Badari Pulavarty205f87f2006-03-26 01:38:00 -0800145 "dev %s, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700146 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
153
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700154static void sprintf_disk_child(char *buf, struct disk_child *dc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700156 sprintf(buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc),
157 dc_size(dc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158}
159
Jeff Mahoneycacbe3d2009-03-30 14:02:22 -0400160static char *is_there_reiserfs_struct(char *fmt, int *what)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700162 char *k = fmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700164 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 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700170 k++;
171 }
172 return k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173}
174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175/* 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
Jeff Mahoney0222e652009-03-30 14:02:44 -0400181 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186*/
Jeff Mahoney78b65132009-03-30 14:02:24 -0400187static DEFINE_SPINLOCK(error_lock);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700188static void prepare_error_buf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700190 char *fmt1 = fmt_buf;
191 char *k;
192 char *p = error_buf;
Jeff Mahoneycacbe3d2009-03-30 14:02:22 -0400193 int what;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Jeff Mahoney78b65132009-03-30 14:02:24 -0400195 spin_lock(&error_lock);
196
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700197 strcpy(fmt1, fmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Jeff Mahoneycacbe3d2009-03-30 14:02:22 -0400199 while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700200 *k = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700202 p += vsprintf(p, fmt1, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700204 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700238 p += strlen(p);
239 fmt1 = k + 2;
240 }
241 vsprintf(p, fmt1, args);
Jeff Mahoney78b65132009-03-30 14:02:24 -0400242 spin_unlock(&error_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244}
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246/* in addition to usual conversion specifiers this accepts reiserfs
Jeff Mahoney0222e652009-03-30 14:02:44 -0400247 specific conversion specifiers:
248 %k to print little endian key,
249 %K to print cpu key,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 %h to print item_head,
Jeff Mahoney0222e652009-03-30 14:02:44 -0400251 %t to print directory entry
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 %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
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400264void __reiserfs_warning(struct super_block *sb, const char *id,
265 const char *function, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700267 do_reiserfs_warning(fmt);
268 if (sb)
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400269 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
270 "%s\n", sb->s_id, id ? id : "", id ? " " : "",
271 function, error_buf);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700272 else
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400273 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
274 id ? id : "", id ? " " : "", function, error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275}
276
277/* No newline.. reiserfs_info calls can be followed by printk's */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700278void reiserfs_info(struct super_block *sb, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700280 do_reiserfs_warning(fmt);
281 if (sb)
Jeff Mahoneya5437152009-03-30 14:02:19 -0400282 printk(KERN_NOTICE "REISERFS (device %s): %s",
283 sb->s_id, error_buf);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700284 else
Jeff Mahoneya5437152009-03-30 14:02:19 -0400285 printk(KERN_NOTICE "REISERFS %s:", error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286}
287
288/* No newline.. reiserfs_printk calls can be followed by printk's */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700289static void reiserfs_printk(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700291 do_reiserfs_warning(fmt);
292 printk(error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293}
294
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700295void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296{
297#ifdef CONFIG_REISERFS_CHECK
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700298 do_reiserfs_warning(fmt);
299 if (s)
Jeff Mahoneya5437152009-03-30 14:02:19 -0400300 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
301 s->s_id, error_buf);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700302 else
Jeff Mahoneya5437152009-03-30 14:02:19 -0400303 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304#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
Jeff Mahoney0222e652009-03-30 14:02:44 -0400317 Example:
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 reiserfs_panic(
320 p_sb, "reiser-29: reiserfs_new_blocknrs: "
321 "one of search_start or rn(%d) is equal to MAX_B_NUM,"
Jeff Mahoney0222e652009-03-30 14:02:44 -0400322 "which means that we are optimizing location based on the bogus location of a temp buffer (%p).",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 rn, bh
324 );
325
326 Regular panic()s sometimes clear the screen before the message can
Jeff Mahoney0222e652009-03-30 14:02:44 -0400327 be read, thus the need for the while loop.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
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
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400352void __reiserfs_panic(struct super_block *sb, const char *id,
353 const char *function, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700355 do_reiserfs_warning(fmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400357#ifdef CONFIG_REISERFS_CHECK
Jeff Mahoney8e186e42007-10-18 23:39:24 -0700358 dump_stack();
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400359#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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367}
368
Jeff Mahoney1e5e59d2009-03-30 14:02:27 -0400369void __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;
391 reiserfs_abort_journal(sb, -EIO);
392}
393
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700394void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700396 do_reiserfs_warning(fmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700398 if (reiserfs_error_panic(sb)) {
Jeff Mahoneya5437152009-03-30 14:02:19 -0400399 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
400 error_buf);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700401 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Jeff Mahoneya5437152009-03-30 14:02:19 -0400403 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700404 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Jeff Mahoneya5437152009-03-30 14:02:19 -0400406 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
407 error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700409 sb->s_flags |= MS_RDONLY;
Jeff Mahoney32e8b102009-03-30 14:02:26 -0400410 reiserfs_abort_journal(sb, errno);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411}
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)...*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700416static int print_internal(struct buffer_head *bh, int first, int last)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700418 struct reiserfs_key *key;
419 struct disk_child *dc;
420 int i;
421 int from, to;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700423 if (!B_IS_KEYS_LEVEL(bh))
424 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700426 check_internal(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700428 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700436 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700438 dc = B_N_CHILD(bh, from);
439 reiserfs_printk("PTR %d: %y ", from, dc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700441 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449}
450
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700451static int print_leaf(struct buffer_head *bh, int print_mode, int first,
452 int last)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700454 struct block_head *blkh;
455 struct item_head *ih;
456 int i, nr;
457 int from, to;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700459 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
507char *reiserfs_hashname(int code)
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";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517}
518
519/* return 1 if this is not super block */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700520static int print_super_block(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700522 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];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700528 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700539 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 ;)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547// skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700548 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) +
551 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(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",
563 reiserfs_hashname(sb_hash_function_code(rs)));
564
565 printk("Tree height %d\n", sb_tree_height(rs));
566 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
568
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700569static int print_desc_block(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700571 struct reiserfs_journal_desc *desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700573 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
574 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700576 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),
579 get_desc_mount_id(desc), get_desc_trans_len(desc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700581 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700584void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700586 va_list args;
587 int mode, first, last;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700589 va_start(args, bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700591 if (!bh) {
592 printk("print_block: buffer is NULL\n");
593 return;
594 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700596 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);
Richard Knutsson774ed222008-02-06 01:37:15 -0800606
607 va_end(args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608}
609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610static char print_tb_buf[2048];
611
612/* this stores initial state of tree balance in the print_tb_buf */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700613void store_print_tb(struct tree_balance *tb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700615 int h = 0;
616 int i;
617 struct buffer_head *tbSh, *tbFh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700619 if (!tb)
620 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700622 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,
628 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
629 tb->tb_path->pos_in_item);
630
Tobias Klausere8c96f82006-03-24 03:15:34 -0800631 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700632 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
633 tb->tb_path->path_length
634 && PATH_H_PATH_OFFSET(tb->tb_path,
635 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700662 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]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700671 /* 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]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700681 sprintf(print_tb_buf + strlen(print_tb_buf),
682 "=====================================================================\n"
683 "FEB list: ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700685 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
686 h = 0;
Tobias Klausere8c96f82006-03-24 03:15:34 -0800687 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700688 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,
Tobias Klausere8c96f82006-03-24 03:15:34 -0800693 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700695 sprintf(print_tb_buf + strlen(print_tb_buf),
696 "======================== the end ====================================\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697}
698
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700699void print_cur_tb(char *mes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700701 printk("%s\n%s", mes, print_tb_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
703
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700704static void check_leaf_block_head(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700706 struct block_head *blkh;
707 int nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700709 blkh = B_BLK_HEAD(bh);
710 nr = blkh_nr_item(blkh);
711 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400712 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700713 bh);
714 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400715 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700716 bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
718}
719
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700720static void check_internal_block_head(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700722 struct block_head *blkh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700724 blkh = B_BLK_HEAD(bh);
725 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400726 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700727
728 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400729 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700730
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))
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400734 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736}
737
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700738void check_leaf(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700740 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748}
749
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700750void check_internal(struct buffer_head *bh)
751{
752 if (!bh)
753 return;
754 check_internal_block_head(bh);
755}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700757void print_statistics(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758{
759
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700760 /*
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
768}