blob: ae1dc841db3af85bfef8391449cbea7ef2a13428 [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>
Al Virof466c6f2012-03-17 01:16:43 -04007#include "reiserfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#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)
Fabian Frederick53872ed2014-08-08 14:21:10 -070020 sprintf(off_buf, "%llu(%llu)",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070021 (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)
Fabian Frederick53872ed2014-08-08 14:21:10 -070037 sprintf(off_buf, "%llu(%llu)",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070038 (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
Jeff Mahoney098297b2014-04-23 10:00:36 -0400175/*
176 * debugging reiserfs we used to print out a lot of different
177 * variables, like keys, item headers, buffer heads etc. Values of
178 * most fields matter. So it took a long time just to write
179 * appropriative printk. With this reiserfs_warning you can use format
180 * specification for complex structures like you used to do with
181 * printfs for integers, doubles and pointers. For instance, to print
182 * out key structure you have to write just:
183 * reiserfs_warning ("bad key %k", key);
184 * instead of
185 * printk ("bad key %lu %lu %lu %lu", key->k_dir_id, key->k_objectid,
186 * key->k_offset, key->k_uniqueness);
187 */
Jeff Mahoney78b65132009-03-30 14:02:24 -0400188static DEFINE_SPINLOCK(error_lock);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700189static void prepare_error_buf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700191 char *fmt1 = fmt_buf;
192 char *k;
193 char *p = error_buf;
Jeff Mahoneycacbe3d2009-03-30 14:02:22 -0400194 int what;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Jeff Mahoney78b65132009-03-30 14:02:24 -0400196 spin_lock(&error_lock);
197
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700198 strcpy(fmt1, fmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Jeff Mahoneycacbe3d2009-03-30 14:02:22 -0400200 while ((k = is_there_reiserfs_struct(fmt1, &what)) != NULL) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700201 *k = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700203 p += vsprintf(p, fmt1, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700205 switch (what) {
206 case 'k':
207 sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
208 break;
209 case 'K':
210 sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
211 break;
212 case 'h':
213 sprintf_item_head(p, va_arg(args, struct item_head *));
214 break;
215 case 't':
216 sprintf_direntry(p,
217 va_arg(args,
218 struct reiserfs_dir_entry *));
219 break;
220 case 'y':
221 sprintf_disk_child(p,
222 va_arg(args, struct disk_child *));
223 break;
224 case 'z':
225 sprintf_block_head(p,
226 va_arg(args, struct buffer_head *));
227 break;
228 case 'b':
229 sprintf_buffer_head(p,
230 va_arg(args, struct buffer_head *));
231 break;
232 case 'a':
233 sprintf_de_head(p,
234 va_arg(args,
235 struct reiserfs_de_head *));
236 break;
237 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700239 p += strlen(p);
240 fmt1 = k + 2;
241 }
242 vsprintf(p, fmt1, args);
Jeff Mahoney78b65132009-03-30 14:02:24 -0400243 spin_unlock(&error_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245}
246
Jeff Mahoney098297b2014-04-23 10:00:36 -0400247/*
248 * in addition to usual conversion specifiers this accepts reiserfs
249 * specific conversion specifiers:
250 * %k to print little endian key,
251 * %K to print cpu key,
252 * %h to print item_head,
253 * %t to print directory entry
254 * %z to print block head (arg must be struct buffer_head *
255 * %b to print buffer_head
256 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
258#define do_reiserfs_warning(fmt)\
259{\
260 va_list args;\
261 va_start( args, fmt );\
262 prepare_error_buf( fmt, args );\
263 va_end( args );\
264}
265
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400266void __reiserfs_warning(struct super_block *sb, const char *id,
267 const char *function, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700269 do_reiserfs_warning(fmt);
270 if (sb)
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400271 printk(KERN_WARNING "REISERFS warning (device %s): %s%s%s: "
272 "%s\n", sb->s_id, id ? id : "", id ? " " : "",
273 function, error_buf);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700274 else
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400275 printk(KERN_WARNING "REISERFS warning: %s%s%s: %s\n",
276 id ? id : "", id ? " " : "", function, error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277}
278
279/* No newline.. reiserfs_info calls can be followed by printk's */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700280void reiserfs_info(struct super_block *sb, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700282 do_reiserfs_warning(fmt);
283 if (sb)
Jeff Mahoneya5437152009-03-30 14:02:19 -0400284 printk(KERN_NOTICE "REISERFS (device %s): %s",
285 sb->s_id, error_buf);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700286 else
Jeff Mahoneya5437152009-03-30 14:02:19 -0400287 printk(KERN_NOTICE "REISERFS %s:", error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288}
289
290/* No newline.. reiserfs_printk calls can be followed by printk's */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700291static void reiserfs_printk(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700293 do_reiserfs_warning(fmt);
294 printk(error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700297void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298{
299#ifdef CONFIG_REISERFS_CHECK
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700300 do_reiserfs_warning(fmt);
301 if (s)
Jeff Mahoneya5437152009-03-30 14:02:19 -0400302 printk(KERN_DEBUG "REISERFS debug (device %s): %s\n",
303 s->s_id, error_buf);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700304 else
Jeff Mahoneya5437152009-03-30 14:02:19 -0400305 printk(KERN_DEBUG "REISERFS debug: %s\n", error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306#endif
307}
308
Jeff Mahoney098297b2014-04-23 10:00:36 -0400309/*
310 * The format:
311 *
312 * maintainer-errorid: [function-name:] message
313 *
314 * where errorid is unique to the maintainer and function-name is
315 * optional, is recommended, so that anyone can easily find the bug
316 * with a simple grep for the short to type string
317 * maintainer-errorid. Don't bother with reusing errorids, there are
318 * lots of numbers out there.
319 *
320 * Example:
321 *
322 * reiserfs_panic(
323 * p_sb, "reiser-29: reiserfs_new_blocknrs: "
324 * "one of search_start or rn(%d) is equal to MAX_B_NUM,"
325 * "which means that we are optimizing location based on the "
326 * "bogus location of a temp buffer (%p).",
327 * rn, bh
328 * );
329 *
330 * Regular panic()s sometimes clear the screen before the message can
331 * be read, thus the need for the while loop.
332 *
333 * Numbering scheme for panic used by Vladimir and Anatoly( Hans completely
334 * ignores this scheme, and considers it pointless complexity):
335 *
336 * panics in reiserfs_fs.h have numbers from 1000 to 1999
337 * super.c 2000 to 2999
338 * preserve.c (unused) 3000 to 3999
339 * bitmap.c 4000 to 4999
340 * stree.c 5000 to 5999
341 * prints.c 6000 to 6999
342 * namei.c 7000 to 7999
343 * fix_nodes.c 8000 to 8999
344 * dir.c 9000 to 9999
345 * lbalance.c 10000 to 10999
346 * ibalance.c 11000 to 11999 not ready
347 * do_balan.c 12000 to 12999
348 * inode.c 13000 to 13999
349 * file.c 14000 to 14999
350 * objectid.c 15000 - 15999
351 * buffer.c 16000 - 16999
352 * symlink.c 17000 - 17999
353 *
354 * . */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400356void __reiserfs_panic(struct super_block *sb, const char *id,
357 const char *function, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700359 do_reiserfs_warning(fmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400361#ifdef CONFIG_REISERFS_CHECK
Jeff Mahoney8e186e42007-10-18 23:39:24 -0700362 dump_stack();
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400363#endif
364 if (sb)
Jeff Mahoney278f6672013-08-08 17:34:46 -0400365 printk(KERN_WARNING "REISERFS panic (device %s): %s%s%s: %s\n",
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400366 sb->s_id, id ? id : "", id ? " " : "",
367 function, error_buf);
368 else
Jeff Mahoney278f6672013-08-08 17:34:46 -0400369 printk(KERN_WARNING "REISERFS panic: %s%s%s: %s\n",
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400370 id ? id : "", id ? " " : "", function, error_buf);
Jeff Mahoney278f6672013-08-08 17:34:46 -0400371 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372}
373
Jeff Mahoney1e5e59d2009-03-30 14:02:27 -0400374void __reiserfs_error(struct super_block *sb, const char *id,
375 const char *function, const char *fmt, ...)
376{
377 do_reiserfs_warning(fmt);
378
379 BUG_ON(sb == NULL);
380
381 if (reiserfs_error_panic(sb))
382 __reiserfs_panic(sb, id, function, error_buf);
383
384 if (id && id[0])
385 printk(KERN_CRIT "REISERFS error (device %s): %s %s: %s\n",
386 sb->s_id, id, function, error_buf);
387 else
388 printk(KERN_CRIT "REISERFS error (device %s): %s: %s\n",
389 sb->s_id, function, error_buf);
390
391 if (sb->s_flags & MS_RDONLY)
392 return;
393
394 reiserfs_info(sb, "Remounting filesystem read-only\n");
395 sb->s_flags |= MS_RDONLY;
396 reiserfs_abort_journal(sb, -EIO);
397}
398
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700399void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700401 do_reiserfs_warning(fmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700403 if (reiserfs_error_panic(sb)) {
Jeff Mahoneya5437152009-03-30 14:02:19 -0400404 panic(KERN_CRIT "REISERFS panic (device %s): %s\n", sb->s_id,
405 error_buf);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700406 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
Jeff Mahoneya5437152009-03-30 14:02:19 -0400408 if (reiserfs_is_journal_aborted(SB_JOURNAL(sb)))
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700409 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Jeff Mahoneya5437152009-03-30 14:02:19 -0400411 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
412 error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700414 sb->s_flags |= MS_RDONLY;
Jeff Mahoney32e8b102009-03-30 14:02:26 -0400415 reiserfs_abort_journal(sb, errno);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416}
417
Jeff Mahoney098297b2014-04-23 10:00:36 -0400418/*
419 * this prints internal nodes (4 keys/items in line) (dc_number,
420 * dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
421 * dc_size)...
422 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700423static int print_internal(struct buffer_head *bh, int first, int last)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700425 struct reiserfs_key *key;
426 struct disk_child *dc;
427 int i;
428 int from, to;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700430 if (!B_IS_KEYS_LEVEL(bh))
431 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700433 check_internal(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700435 if (first == -1) {
436 from = 0;
437 to = B_NR_ITEMS(bh);
438 } else {
439 from = first;
440 to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
441 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700443 reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700445 dc = B_N_CHILD(bh, from);
446 reiserfs_printk("PTR %d: %y ", from, dc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
Jeff Mahoney4cf5f7a2014-04-23 10:00:35 -0400448 for (i = from, key = internal_key(bh, from), dc++; i < to;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700449 i++, key++, dc++) {
450 reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
451 if (i && i % 4 == 0)
452 printk("\n");
453 }
454 printk("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456}
457
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700458static int print_leaf(struct buffer_head *bh, int print_mode, int first,
459 int last)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700461 struct block_head *blkh;
462 struct item_head *ih;
463 int i, nr;
464 int from, to;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700466 if (!B_IS_ITEMS_LEVEL(bh))
467 return 1;
468
469 check_leaf(bh);
470
471 blkh = B_BLK_HEAD(bh);
Jeff Mahoney4cf5f7a2014-04-23 10:00:35 -0400472 ih = item_head(bh, 0);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700473 nr = blkh_nr_item(blkh);
474
475 printk
476 ("\n===================================================================\n");
477 reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
478
479 if (!(print_mode & PRINT_LEAF_ITEMS)) {
480 reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
481 &(ih->ih_key), &((ih + nr - 1)->ih_key));
482 return 0;
483 }
484
485 if (first < 0 || first > nr - 1)
486 from = 0;
487 else
488 from = first;
489
490 if (last < 0 || last > nr)
491 to = nr;
492 else
493 to = last;
494
495 ih += from;
496 printk
497 ("-------------------------------------------------------------------------------\n");
498 printk
499 ("|##| type | key | ilen | free_space | version | loc |\n");
500 for (i = from; i < to; i++, ih++) {
501 printk
502 ("-------------------------------------------------------------------------------\n");
503 reiserfs_printk("|%2d| %h |\n", i, ih);
504 if (print_mode & PRINT_LEAF_ITEMS)
Jeff Mahoney4cf5f7a2014-04-23 10:00:35 -0400505 op_print_item(ih, ih_item_body(bh, ih));
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700506 }
507
508 printk
509 ("===================================================================\n");
510
511 return 0;
512}
513
514char *reiserfs_hashname(int code)
515{
516 if (code == YURA_HASH)
517 return "rupasov";
518 if (code == TEA_HASH)
519 return "tea";
520 if (code == R5_HASH)
521 return "r5";
522
523 return "unknown";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
526/* return 1 if this is not super block */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700527static int print_super_block(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700529 struct reiserfs_super_block *rs =
530 (struct reiserfs_super_block *)(bh->b_data);
531 int skipped, data_blocks;
532 char *version;
533 char b[BDEVNAME_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700535 if (is_reiserfs_3_5(rs)) {
536 version = "3.5";
537 } else if (is_reiserfs_3_6(rs)) {
538 version = "3.6";
539 } else if (is_reiserfs_jr(rs)) {
540 version = ((sb_version(rs) == REISERFS_VERSION_2) ?
541 "3.6" : "3.5");
542 } else {
543 return 1;
544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700546 printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
547 (unsigned long long)bh->b_blocknr);
548 printk("Reiserfs version %s\n", version);
549 printk("Block count %u\n", sb_block_count(rs));
550 printk("Blocksize %d\n", sb_blocksize(rs));
551 printk("Free blocks %u\n", sb_free_blocks(rs));
Jeff Mahoney098297b2014-04-23 10:00:36 -0400552 /*
553 * FIXME: this would be confusing if
554 * someone stores reiserfs super block in some data block ;)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555// skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
Jeff Mahoney098297b2014-04-23 10:00:36 -0400556 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700557 skipped = bh->b_blocknr;
558 data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
559 (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
560 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
561 printk
562 ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
563 "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
564 (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
565 sb_reserved_for_journal(rs)), data_blocks);
566 printk("Root block %u\n", sb_root_block(rs));
567 printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
568 printk("Journal dev %d\n", sb_jp_journal_dev(rs));
569 printk("Journal orig size %d\n", sb_jp_journal_size(rs));
570 printk("FS state %d\n", sb_fs_state(rs));
571 printk("Hash function \"%s\"\n",
572 reiserfs_hashname(sb_hash_function_code(rs)));
573
574 printk("Tree height %d\n", sb_tree_height(rs));
575 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576}
577
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700578static int print_desc_block(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700580 struct reiserfs_journal_desc *desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700582 if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
583 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700585 desc = (struct reiserfs_journal_desc *)(bh->b_data);
586 printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
587 (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
588 get_desc_mount_id(desc), get_desc_trans_len(desc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700590 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591}
Jeff Mahoney098297b2014-04-23 10:00:36 -0400592/* ..., int print_mode, int first, int last) */
593void print_block(struct buffer_head *bh, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700595 va_list args;
596 int mode, first, last;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700598 if (!bh) {
599 printk("print_block: buffer is NULL\n");
600 return;
601 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Jesper Juhl566538a2011-01-12 17:00:27 -0800603 va_start(args, bh);
604
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700605 mode = va_arg(args, int);
606 first = va_arg(args, int);
607 last = va_arg(args, int);
608 if (print_leaf(bh, mode, first, last))
609 if (print_internal(bh, first, last))
610 if (print_super_block(bh))
611 if (print_desc_block(bh))
612 printk
613 ("Block %llu contains unformatted data\n",
614 (unsigned long long)bh->b_blocknr);
Richard Knutsson774ed222008-02-06 01:37:15 -0800615
616 va_end(args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617}
618
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619static char print_tb_buf[2048];
620
621/* this stores initial state of tree balance in the print_tb_buf */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700622void store_print_tb(struct tree_balance *tb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700624 int h = 0;
625 int i;
626 struct buffer_head *tbSh, *tbFh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700628 if (!tb)
629 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700631 sprintf(print_tb_buf, "\n"
632 "BALANCING %d\n"
633 "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
634 "=====================================================================\n"
635 "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
636 REISERFS_SB(tb->tb_sb)->s_do_balance,
637 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
638 tb->tb_path->pos_in_item);
639
Tobias Klausere8c96f82006-03-24 03:15:34 -0800640 for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700641 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
642 tb->tb_path->path_length
643 && PATH_H_PATH_OFFSET(tb->tb_path,
644 h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
645 tbSh = PATH_H_PBUFFER(tb->tb_path, h);
646 tbFh = PATH_H_PPARENT(tb->tb_path, h);
647 } else {
648 tbSh = NULL;
649 tbFh = NULL;
650 }
651 sprintf(print_tb_buf + strlen(print_tb_buf),
652 "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
653 h,
654 (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
Jeff Mahoneya228bf82014-04-23 10:00:42 -0400655 (tbSh) ? atomic_read(&tbSh->b_count) : -1,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700656 (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
Jeff Mahoneya228bf82014-04-23 10:00:42 -0400657 (tb->L[h]) ? atomic_read(&tb->L[h]->b_count) : -1,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700658 (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
Jeff Mahoneya228bf82014-04-23 10:00:42 -0400659 (tb->R[h]) ? atomic_read(&tb->R[h]->b_count) : -1,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700660 (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
661 (tb->FL[h]) ? (long long)(tb->FL[h]->
662 b_blocknr) : (-1LL),
663 (tb->FR[h]) ? (long long)(tb->FR[h]->
664 b_blocknr) : (-1LL),
665 (tb->CFL[h]) ? (long long)(tb->CFL[h]->
666 b_blocknr) : (-1LL),
667 (tb->CFR[h]) ? (long long)(tb->CFR[h]->
668 b_blocknr) : (-1LL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700671 sprintf(print_tb_buf + strlen(print_tb_buf),
672 "=====================================================================\n"
673 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
674 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
675 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
Jeff Mahoneyb49fb112014-04-23 10:00:46 -0400676 tb->rbytes, tb->blknum[0], tb->s0num, tb->snum[0],
677 tb->sbytes[0], tb->snum[1], tb->sbytes[1],
678 tb->cur_blknum, tb->lkey[0], tb->rkey[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700680 /* this prints balance parameters for non-leaf levels */
681 h = 0;
682 do {
683 h++;
684 sprintf(print_tb_buf + strlen(print_tb_buf),
685 "* %d * %4d * %2d * * %2d * * %2d *\n",
686 h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
687 tb->blknum[h]);
688 } while (tb->insert_size[h]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700690 sprintf(print_tb_buf + strlen(print_tb_buf),
691 "=====================================================================\n"
692 "FEB list: ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700694 /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
695 h = 0;
Tobias Klausere8c96f82006-03-24 03:15:34 -0800696 for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700697 sprintf(print_tb_buf + strlen(print_tb_buf),
698 "%p (%llu %d)%s", tb->FEB[i],
699 tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
700 b_blocknr : 0ULL,
Jeff Mahoneya228bf82014-04-23 10:00:42 -0400701 tb->FEB[i] ? atomic_read(&tb->FEB[i]->b_count) : 0,
Tobias Klausere8c96f82006-03-24 03:15:34 -0800702 (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700704 sprintf(print_tb_buf + strlen(print_tb_buf),
705 "======================== the end ====================================\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706}
707
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700708void print_cur_tb(char *mes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700710 printk("%s\n%s", mes, print_tb_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700713static void check_leaf_block_head(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700715 struct block_head *blkh;
716 int nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700718 blkh = B_BLK_HEAD(bh);
719 nr = blkh_nr_item(blkh);
720 if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400721 reiserfs_panic(NULL, "vs-6010", "invalid item number %z",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700722 bh);
723 if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400724 reiserfs_panic(NULL, "vs-6020", "invalid free space %z",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700725 bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
727}
728
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700729static void check_internal_block_head(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700731 struct block_head *blkh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700733 blkh = B_BLK_HEAD(bh);
734 if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400735 reiserfs_panic(NULL, "vs-6025", "invalid level %z", bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700736
737 if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400738 reiserfs_panic(NULL, "vs-6030", "invalid item number %z", bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700739
740 if (B_FREE_SPACE(bh) !=
741 bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
742 DC_SIZE * (B_NR_ITEMS(bh) + 1))
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400743 reiserfs_panic(NULL, "vs-6040", "invalid free space %z", bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700744
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}
746
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700747void check_leaf(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700749 int i;
750 struct item_head *ih;
751
752 if (!bh)
753 return;
754 check_leaf_block_head(bh);
Jeff Mahoney4cf5f7a2014-04-23 10:00:35 -0400755 for (i = 0, ih = item_head(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
756 op_check_item(ih, ih_item_body(bh, ih));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757}
758
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700759void check_internal(struct buffer_head *bh)
760{
761 if (!bh)
762 return;
763 check_internal_block_head(bh);
764}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700766void print_statistics(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767{
768
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700769 /*
770 printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
771 bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
772 REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
773 REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
774 REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);
775 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
777}