1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6 #include "xfs.h"
7 #include "xfs_shared.h"
8 #include "xfs_format.h"
9 #include "xfs_fs.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_errortag.h"
14 #include "xfs_error.h"
15 #include "xfs_sysfs.h"
16 #include "xfs_inode.h"
17
18 #ifdef DEBUG
19
20 static unsigned int xfs_errortag_random_default[] = {
21 XFS_RANDOM_DEFAULT,
22 XFS_RANDOM_IFLUSH_1,
23 XFS_RANDOM_IFLUSH_2,
24 XFS_RANDOM_IFLUSH_3,
25 XFS_RANDOM_IFLUSH_4,
26 XFS_RANDOM_IFLUSH_5,
27 XFS_RANDOM_IFLUSH_6,
28 XFS_RANDOM_DA_READ_BUF,
29 XFS_RANDOM_BTREE_CHECK_LBLOCK,
30 XFS_RANDOM_BTREE_CHECK_SBLOCK,
31 XFS_RANDOM_ALLOC_READ_AGF,
32 XFS_RANDOM_IALLOC_READ_AGI,
33 XFS_RANDOM_ITOBP_INOTOBP,
34 XFS_RANDOM_IUNLINK,
35 XFS_RANDOM_IUNLINK_REMOVE,
36 XFS_RANDOM_DIR_INO_VALIDATE,
37 XFS_RANDOM_BULKSTAT_READ_CHUNK,
38 XFS_RANDOM_IODONE_IOERR,
39 XFS_RANDOM_STRATREAD_IOERR,
40 XFS_RANDOM_STRATCMPL_IOERR,
41 XFS_RANDOM_DIOWRITE_IOERR,
42 XFS_RANDOM_BMAPIFORMAT,
43 XFS_RANDOM_FREE_EXTENT,
44 XFS_RANDOM_RMAP_FINISH_ONE,
45 XFS_RANDOM_REFCOUNT_CONTINUE_UPDATE,
46 XFS_RANDOM_REFCOUNT_FINISH_ONE,
47 XFS_RANDOM_BMAP_FINISH_ONE,
48 XFS_RANDOM_AG_RESV_CRITICAL,
49 0, /* XFS_RANDOM_DROP_WRITES has been removed */
50 XFS_RANDOM_LOG_BAD_CRC,
51 XFS_RANDOM_LOG_ITEM_PIN,
52 XFS_RANDOM_BUF_LRU_REF,
53 XFS_RANDOM_FORCE_SCRUB_REPAIR,
54 XFS_RANDOM_FORCE_SUMMARY_RECALC,
55 XFS_RANDOM_IUNLINK_FALLBACK,
56 XFS_RANDOM_BUF_IOERROR,
57 XFS_RANDOM_REDUCE_MAX_IEXTENTS,
58 XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT,
59 XFS_RANDOM_AG_RESV_FAIL,
60 XFS_RANDOM_LARP,
61 XFS_RANDOM_DA_LEAF_SPLIT,
62 XFS_RANDOM_ATTR_LEAF_TO_NODE,
63 XFS_RANDOM_WB_DELAY_MS,
64 XFS_RANDOM_WRITE_DELAY_MS,
65 XFS_RANDOM_EXCHMAPS_FINISH_ONE,
66 XFS_RANDOM_METAFILE_RESV_CRITICAL,
67 };
68
69 struct xfs_errortag_attr {
70 struct attribute attr;
71 unsigned int tag;
72 };
73
74 static inline struct xfs_errortag_attr *
to_attr(struct attribute * attr)75 to_attr(struct attribute *attr)
76 {
77 return container_of(attr, struct xfs_errortag_attr, attr);
78 }
79
80 static inline struct xfs_mount *
to_mp(struct kobject * kobject)81 to_mp(struct kobject *kobject)
82 {
83 struct xfs_kobj *kobj = to_kobj(kobject);
84
85 return container_of(kobj, struct xfs_mount, m_errortag_kobj);
86 }
87
88 STATIC ssize_t
xfs_errortag_attr_store(struct kobject * kobject,struct attribute * attr,const char * buf,size_t count)89 xfs_errortag_attr_store(
90 struct kobject *kobject,
91 struct attribute *attr,
92 const char *buf,
93 size_t count)
94 {
95 struct xfs_mount *mp = to_mp(kobject);
96 struct xfs_errortag_attr *xfs_attr = to_attr(attr);
97 int ret;
98 unsigned int val;
99
100 if (strcmp(buf, "default") == 0) {
101 val = xfs_errortag_random_default[xfs_attr->tag];
102 } else {
103 ret = kstrtouint(buf, 0, &val);
104 if (ret)
105 return ret;
106 }
107
108 ret = xfs_errortag_set(mp, xfs_attr->tag, val);
109 if (ret)
110 return ret;
111 return count;
112 }
113
114 STATIC ssize_t
xfs_errortag_attr_show(struct kobject * kobject,struct attribute * attr,char * buf)115 xfs_errortag_attr_show(
116 struct kobject *kobject,
117 struct attribute *attr,
118 char *buf)
119 {
120 struct xfs_mount *mp = to_mp(kobject);
121 struct xfs_errortag_attr *xfs_attr = to_attr(attr);
122
123 return snprintf(buf, PAGE_SIZE, "%u\n",
124 xfs_errortag_get(mp, xfs_attr->tag));
125 }
126
127 static const struct sysfs_ops xfs_errortag_sysfs_ops = {
128 .show = xfs_errortag_attr_show,
129 .store = xfs_errortag_attr_store,
130 };
131
132 #define XFS_ERRORTAG_ATTR_RW(_name, _tag) \
133 static struct xfs_errortag_attr xfs_errortag_attr_##_name = { \
134 .attr = {.name = __stringify(_name), \
135 .mode = VERIFY_OCTAL_PERMISSIONS(S_IWUSR | S_IRUGO) }, \
136 .tag = (_tag), \
137 }
138
139 #define XFS_ERRORTAG_ATTR_LIST(_name) &xfs_errortag_attr_##_name.attr
140
141 XFS_ERRORTAG_ATTR_RW(noerror, XFS_ERRTAG_NOERROR);
142 XFS_ERRORTAG_ATTR_RW(iflush1, XFS_ERRTAG_IFLUSH_1);
143 XFS_ERRORTAG_ATTR_RW(iflush2, XFS_ERRTAG_IFLUSH_2);
144 XFS_ERRORTAG_ATTR_RW(iflush3, XFS_ERRTAG_IFLUSH_3);
145 XFS_ERRORTAG_ATTR_RW(iflush4, XFS_ERRTAG_IFLUSH_4);
146 XFS_ERRORTAG_ATTR_RW(iflush5, XFS_ERRTAG_IFLUSH_5);
147 XFS_ERRORTAG_ATTR_RW(iflush6, XFS_ERRTAG_IFLUSH_6);
148 XFS_ERRORTAG_ATTR_RW(dareadbuf, XFS_ERRTAG_DA_READ_BUF);
149 XFS_ERRORTAG_ATTR_RW(btree_chk_lblk, XFS_ERRTAG_BTREE_CHECK_LBLOCK);
150 XFS_ERRORTAG_ATTR_RW(btree_chk_sblk, XFS_ERRTAG_BTREE_CHECK_SBLOCK);
151 XFS_ERRORTAG_ATTR_RW(readagf, XFS_ERRTAG_ALLOC_READ_AGF);
152 XFS_ERRORTAG_ATTR_RW(readagi, XFS_ERRTAG_IALLOC_READ_AGI);
153 XFS_ERRORTAG_ATTR_RW(itobp, XFS_ERRTAG_ITOBP_INOTOBP);
154 XFS_ERRORTAG_ATTR_RW(iunlink, XFS_ERRTAG_IUNLINK);
155 XFS_ERRORTAG_ATTR_RW(iunlinkrm, XFS_ERRTAG_IUNLINK_REMOVE);
156 XFS_ERRORTAG_ATTR_RW(dirinovalid, XFS_ERRTAG_DIR_INO_VALIDATE);
157 XFS_ERRORTAG_ATTR_RW(bulkstat, XFS_ERRTAG_BULKSTAT_READ_CHUNK);
158 XFS_ERRORTAG_ATTR_RW(logiodone, XFS_ERRTAG_IODONE_IOERR);
159 XFS_ERRORTAG_ATTR_RW(stratread, XFS_ERRTAG_STRATREAD_IOERR);
160 XFS_ERRORTAG_ATTR_RW(stratcmpl, XFS_ERRTAG_STRATCMPL_IOERR);
161 XFS_ERRORTAG_ATTR_RW(diowrite, XFS_ERRTAG_DIOWRITE_IOERR);
162 XFS_ERRORTAG_ATTR_RW(bmapifmt, XFS_ERRTAG_BMAPIFORMAT);
163 XFS_ERRORTAG_ATTR_RW(free_extent, XFS_ERRTAG_FREE_EXTENT);
164 XFS_ERRORTAG_ATTR_RW(rmap_finish_one, XFS_ERRTAG_RMAP_FINISH_ONE);
165 XFS_ERRORTAG_ATTR_RW(refcount_continue_update, XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE);
166 XFS_ERRORTAG_ATTR_RW(refcount_finish_one, XFS_ERRTAG_REFCOUNT_FINISH_ONE);
167 XFS_ERRORTAG_ATTR_RW(bmap_finish_one, XFS_ERRTAG_BMAP_FINISH_ONE);
168 XFS_ERRORTAG_ATTR_RW(ag_resv_critical, XFS_ERRTAG_AG_RESV_CRITICAL);
169 XFS_ERRORTAG_ATTR_RW(log_bad_crc, XFS_ERRTAG_LOG_BAD_CRC);
170 XFS_ERRORTAG_ATTR_RW(log_item_pin, XFS_ERRTAG_LOG_ITEM_PIN);
171 XFS_ERRORTAG_ATTR_RW(buf_lru_ref, XFS_ERRTAG_BUF_LRU_REF);
172 XFS_ERRORTAG_ATTR_RW(force_repair, XFS_ERRTAG_FORCE_SCRUB_REPAIR);
173 XFS_ERRORTAG_ATTR_RW(bad_summary, XFS_ERRTAG_FORCE_SUMMARY_RECALC);
174 XFS_ERRORTAG_ATTR_RW(iunlink_fallback, XFS_ERRTAG_IUNLINK_FALLBACK);
175 XFS_ERRORTAG_ATTR_RW(buf_ioerror, XFS_ERRTAG_BUF_IOERROR);
176 XFS_ERRORTAG_ATTR_RW(reduce_max_iextents, XFS_ERRTAG_REDUCE_MAX_IEXTENTS);
177 XFS_ERRORTAG_ATTR_RW(bmap_alloc_minlen_extent, XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT);
178 XFS_ERRORTAG_ATTR_RW(ag_resv_fail, XFS_ERRTAG_AG_RESV_FAIL);
179 XFS_ERRORTAG_ATTR_RW(larp, XFS_ERRTAG_LARP);
180 XFS_ERRORTAG_ATTR_RW(da_leaf_split, XFS_ERRTAG_DA_LEAF_SPLIT);
181 XFS_ERRORTAG_ATTR_RW(attr_leaf_to_node, XFS_ERRTAG_ATTR_LEAF_TO_NODE);
182 XFS_ERRORTAG_ATTR_RW(wb_delay_ms, XFS_ERRTAG_WB_DELAY_MS);
183 XFS_ERRORTAG_ATTR_RW(write_delay_ms, XFS_ERRTAG_WRITE_DELAY_MS);
184 XFS_ERRORTAG_ATTR_RW(exchmaps_finish_one, XFS_ERRTAG_EXCHMAPS_FINISH_ONE);
185 XFS_ERRORTAG_ATTR_RW(metafile_resv_crit, XFS_ERRTAG_METAFILE_RESV_CRITICAL);
186
187 static struct attribute *xfs_errortag_attrs[] = {
188 XFS_ERRORTAG_ATTR_LIST(noerror),
189 XFS_ERRORTAG_ATTR_LIST(iflush1),
190 XFS_ERRORTAG_ATTR_LIST(iflush2),
191 XFS_ERRORTAG_ATTR_LIST(iflush3),
192 XFS_ERRORTAG_ATTR_LIST(iflush4),
193 XFS_ERRORTAG_ATTR_LIST(iflush5),
194 XFS_ERRORTAG_ATTR_LIST(iflush6),
195 XFS_ERRORTAG_ATTR_LIST(dareadbuf),
196 XFS_ERRORTAG_ATTR_LIST(btree_chk_lblk),
197 XFS_ERRORTAG_ATTR_LIST(btree_chk_sblk),
198 XFS_ERRORTAG_ATTR_LIST(readagf),
199 XFS_ERRORTAG_ATTR_LIST(readagi),
200 XFS_ERRORTAG_ATTR_LIST(itobp),
201 XFS_ERRORTAG_ATTR_LIST(iunlink),
202 XFS_ERRORTAG_ATTR_LIST(iunlinkrm),
203 XFS_ERRORTAG_ATTR_LIST(dirinovalid),
204 XFS_ERRORTAG_ATTR_LIST(bulkstat),
205 XFS_ERRORTAG_ATTR_LIST(logiodone),
206 XFS_ERRORTAG_ATTR_LIST(stratread),
207 XFS_ERRORTAG_ATTR_LIST(stratcmpl),
208 XFS_ERRORTAG_ATTR_LIST(diowrite),
209 XFS_ERRORTAG_ATTR_LIST(bmapifmt),
210 XFS_ERRORTAG_ATTR_LIST(free_extent),
211 XFS_ERRORTAG_ATTR_LIST(rmap_finish_one),
212 XFS_ERRORTAG_ATTR_LIST(refcount_continue_update),
213 XFS_ERRORTAG_ATTR_LIST(refcount_finish_one),
214 XFS_ERRORTAG_ATTR_LIST(bmap_finish_one),
215 XFS_ERRORTAG_ATTR_LIST(ag_resv_critical),
216 XFS_ERRORTAG_ATTR_LIST(log_bad_crc),
217 XFS_ERRORTAG_ATTR_LIST(log_item_pin),
218 XFS_ERRORTAG_ATTR_LIST(buf_lru_ref),
219 XFS_ERRORTAG_ATTR_LIST(force_repair),
220 XFS_ERRORTAG_ATTR_LIST(bad_summary),
221 XFS_ERRORTAG_ATTR_LIST(iunlink_fallback),
222 XFS_ERRORTAG_ATTR_LIST(buf_ioerror),
223 XFS_ERRORTAG_ATTR_LIST(reduce_max_iextents),
224 XFS_ERRORTAG_ATTR_LIST(bmap_alloc_minlen_extent),
225 XFS_ERRORTAG_ATTR_LIST(ag_resv_fail),
226 XFS_ERRORTAG_ATTR_LIST(larp),
227 XFS_ERRORTAG_ATTR_LIST(da_leaf_split),
228 XFS_ERRORTAG_ATTR_LIST(attr_leaf_to_node),
229 XFS_ERRORTAG_ATTR_LIST(wb_delay_ms),
230 XFS_ERRORTAG_ATTR_LIST(write_delay_ms),
231 XFS_ERRORTAG_ATTR_LIST(exchmaps_finish_one),
232 XFS_ERRORTAG_ATTR_LIST(metafile_resv_crit),
233 NULL,
234 };
235 ATTRIBUTE_GROUPS(xfs_errortag);
236
237 static const struct kobj_type xfs_errortag_ktype = {
238 .release = xfs_sysfs_release,
239 .sysfs_ops = &xfs_errortag_sysfs_ops,
240 .default_groups = xfs_errortag_groups,
241 };
242
243 int
xfs_errortag_init(struct xfs_mount * mp)244 xfs_errortag_init(
245 struct xfs_mount *mp)
246 {
247 int ret;
248
249 mp->m_errortag = kzalloc(sizeof(unsigned int) * XFS_ERRTAG_MAX,
250 GFP_KERNEL | __GFP_RETRY_MAYFAIL);
251 if (!mp->m_errortag)
252 return -ENOMEM;
253
254 ret = xfs_sysfs_init(&mp->m_errortag_kobj, &xfs_errortag_ktype,
255 &mp->m_kobj, "errortag");
256 if (ret)
257 kfree(mp->m_errortag);
258 return ret;
259 }
260
261 void
xfs_errortag_del(struct xfs_mount * mp)262 xfs_errortag_del(
263 struct xfs_mount *mp)
264 {
265 xfs_sysfs_del(&mp->m_errortag_kobj);
266 kfree(mp->m_errortag);
267 }
268
269 static bool
xfs_errortag_valid(unsigned int error_tag)270 xfs_errortag_valid(
271 unsigned int error_tag)
272 {
273 if (error_tag >= XFS_ERRTAG_MAX)
274 return false;
275
276 /* Error out removed injection types */
277 if (error_tag == XFS_ERRTAG_DROP_WRITES)
278 return false;
279 return true;
280 }
281
282 bool
xfs_errortag_enabled(struct xfs_mount * mp,unsigned int tag)283 xfs_errortag_enabled(
284 struct xfs_mount *mp,
285 unsigned int tag)
286 {
287 if (!mp->m_errortag)
288 return false;
289 if (!xfs_errortag_valid(tag))
290 return false;
291
292 return mp->m_errortag[tag] != 0;
293 }
294
295 bool
xfs_errortag_test(struct xfs_mount * mp,const char * expression,const char * file,int line,unsigned int error_tag)296 xfs_errortag_test(
297 struct xfs_mount *mp,
298 const char *expression,
299 const char *file,
300 int line,
301 unsigned int error_tag)
302 {
303 unsigned int randfactor;
304
305 /*
306 * To be able to use error injection anywhere, we need to ensure error
307 * injection mechanism is already initialized.
308 *
309 * Code paths like I/O completion can be called before the
310 * initialization is complete, but be able to inject errors in such
311 * places is still useful.
312 */
313 if (!mp->m_errortag)
314 return false;
315
316 if (!xfs_errortag_valid(error_tag))
317 return false;
318
319 randfactor = mp->m_errortag[error_tag];
320 if (!randfactor || get_random_u32_below(randfactor))
321 return false;
322
323 xfs_warn_ratelimited(mp,
324 "Injecting error (%s) at file %s, line %d, on filesystem \"%s\"",
325 expression, file, line, mp->m_super->s_id);
326 return true;
327 }
328
329 int
xfs_errortag_get(struct xfs_mount * mp,unsigned int error_tag)330 xfs_errortag_get(
331 struct xfs_mount *mp,
332 unsigned int error_tag)
333 {
334 if (!xfs_errortag_valid(error_tag))
335 return -EINVAL;
336
337 return mp->m_errortag[error_tag];
338 }
339
340 int
xfs_errortag_set(struct xfs_mount * mp,unsigned int error_tag,unsigned int tag_value)341 xfs_errortag_set(
342 struct xfs_mount *mp,
343 unsigned int error_tag,
344 unsigned int tag_value)
345 {
346 if (!xfs_errortag_valid(error_tag))
347 return -EINVAL;
348
349 mp->m_errortag[error_tag] = tag_value;
350 return 0;
351 }
352
353 int
xfs_errortag_add(struct xfs_mount * mp,unsigned int error_tag)354 xfs_errortag_add(
355 struct xfs_mount *mp,
356 unsigned int error_tag)
357 {
358 BUILD_BUG_ON(ARRAY_SIZE(xfs_errortag_random_default) != XFS_ERRTAG_MAX);
359
360 if (!xfs_errortag_valid(error_tag))
361 return -EINVAL;
362
363 return xfs_errortag_set(mp, error_tag,
364 xfs_errortag_random_default[error_tag]);
365 }
366
367 int
xfs_errortag_clearall(struct xfs_mount * mp)368 xfs_errortag_clearall(
369 struct xfs_mount *mp)
370 {
371 memset(mp->m_errortag, 0, sizeof(unsigned int) * XFS_ERRTAG_MAX);
372 return 0;
373 }
374 #endif /* DEBUG */
375
376 void
xfs_error_report(const char * tag,int level,struct xfs_mount * mp,const char * filename,int linenum,xfs_failaddr_t failaddr)377 xfs_error_report(
378 const char *tag,
379 int level,
380 struct xfs_mount *mp,
381 const char *filename,
382 int linenum,
383 xfs_failaddr_t failaddr)
384 {
385 if (level <= xfs_error_level) {
386 xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT,
387 "Internal error %s at line %d of file %s. Caller %pS",
388 tag, linenum, filename, failaddr);
389
390 xfs_stack_trace();
391 }
392 }
393
394 void
xfs_corruption_error(const char * tag,int level,struct xfs_mount * mp,const void * buf,size_t bufsize,const char * filename,int linenum,xfs_failaddr_t failaddr)395 xfs_corruption_error(
396 const char *tag,
397 int level,
398 struct xfs_mount *mp,
399 const void *buf,
400 size_t bufsize,
401 const char *filename,
402 int linenum,
403 xfs_failaddr_t failaddr)
404 {
405 if (buf && level <= xfs_error_level)
406 xfs_hex_dump(buf, bufsize);
407 xfs_error_report(tag, level, mp, filename, linenum, failaddr);
408 xfs_alert(mp, "Corruption detected. Unmount and run xfs_repair");
409 }
410
411 /*
412 * Complain about the kinds of metadata corruption that we can't detect from a
413 * verifier, such as incorrect inter-block relationship data. Does not set
414 * bp->b_error.
415 *
416 * Call xfs_buf_mark_corrupt, not this function.
417 */
418 void
xfs_buf_corruption_error(struct xfs_buf * bp,xfs_failaddr_t fa)419 xfs_buf_corruption_error(
420 struct xfs_buf *bp,
421 xfs_failaddr_t fa)
422 {
423 struct xfs_mount *mp = bp->b_mount;
424
425 xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
426 "Metadata corruption detected at %pS, %s block 0x%llx",
427 fa, bp->b_ops->name, xfs_buf_daddr(bp));
428
429 xfs_alert(mp, "Unmount and run xfs_repair");
430
431 if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
432 xfs_stack_trace();
433 }
434
435 /*
436 * Warnings specifically for verifier errors. Differentiate CRC vs. invalid
437 * values, and omit the stack trace unless the error level is tuned high.
438 */
439 void
xfs_buf_verifier_error(struct xfs_buf * bp,int error,const char * name,const void * buf,size_t bufsz,xfs_failaddr_t failaddr)440 xfs_buf_verifier_error(
441 struct xfs_buf *bp,
442 int error,
443 const char *name,
444 const void *buf,
445 size_t bufsz,
446 xfs_failaddr_t failaddr)
447 {
448 struct xfs_mount *mp = bp->b_mount;
449 xfs_failaddr_t fa;
450 int sz;
451
452 fa = failaddr ? failaddr : __return_address;
453 __xfs_buf_ioerror(bp, error, fa);
454
455 xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
456 "Metadata %s detected at %pS, %s block 0x%llx %s",
457 bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
458 fa, bp->b_ops->name, xfs_buf_daddr(bp), name);
459
460 xfs_alert(mp, "Unmount and run xfs_repair");
461
462 if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
463 sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
464 xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
465 sz);
466 xfs_hex_dump(buf, sz);
467 }
468
469 if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
470 xfs_stack_trace();
471 }
472
473 /*
474 * Warnings specifically for verifier errors. Differentiate CRC vs. invalid
475 * values, and omit the stack trace unless the error level is tuned high.
476 */
477 void
xfs_verifier_error(struct xfs_buf * bp,int error,xfs_failaddr_t failaddr)478 xfs_verifier_error(
479 struct xfs_buf *bp,
480 int error,
481 xfs_failaddr_t failaddr)
482 {
483 return xfs_buf_verifier_error(bp, error, "", xfs_buf_offset(bp, 0),
484 XFS_CORRUPTION_DUMP_LEN, failaddr);
485 }
486
487 /*
488 * Warnings for inode corruption problems. Don't bother with the stack
489 * trace unless the error level is turned up high.
490 */
491 void
xfs_inode_verifier_error(struct xfs_inode * ip,int error,const char * name,const void * buf,size_t bufsz,xfs_failaddr_t failaddr)492 xfs_inode_verifier_error(
493 struct xfs_inode *ip,
494 int error,
495 const char *name,
496 const void *buf,
497 size_t bufsz,
498 xfs_failaddr_t failaddr)
499 {
500 struct xfs_mount *mp = ip->i_mount;
501 xfs_failaddr_t fa;
502 int sz;
503
504 fa = failaddr ? failaddr : __return_address;
505
506 xfs_alert(mp, "Metadata %s detected at %pS, inode 0x%llx %s",
507 error == -EFSBADCRC ? "CRC error" : "corruption",
508 fa, ip->i_ino, name);
509
510 xfs_alert(mp, "Unmount and run xfs_repair");
511
512 if (buf && xfs_error_level >= XFS_ERRLEVEL_LOW) {
513 sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
514 xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
515 sz);
516 xfs_hex_dump(buf, sz);
517 }
518
519 if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
520 xfs_stack_trace();
521 }
522