Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
20static 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
69struct xfs_errortag_attr {
70 struct attribute attr;
71 unsigned int tag;
72};
73
74static inline struct xfs_errortag_attr *
75to_attr(struct attribute *attr)
76{
77 return container_of(attr, struct xfs_errortag_attr, attr);
78}
79
80static inline struct xfs_mount *
81to_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
88STATIC ssize_t
89xfs_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
114STATIC ssize_t
115xfs_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
127static 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) \
133static 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
141XFS_ERRORTAG_ATTR_RW(noerror, XFS_ERRTAG_NOERROR);
142XFS_ERRORTAG_ATTR_RW(iflush1, XFS_ERRTAG_IFLUSH_1);
143XFS_ERRORTAG_ATTR_RW(iflush2, XFS_ERRTAG_IFLUSH_2);
144XFS_ERRORTAG_ATTR_RW(iflush3, XFS_ERRTAG_IFLUSH_3);
145XFS_ERRORTAG_ATTR_RW(iflush4, XFS_ERRTAG_IFLUSH_4);
146XFS_ERRORTAG_ATTR_RW(iflush5, XFS_ERRTAG_IFLUSH_5);
147XFS_ERRORTAG_ATTR_RW(iflush6, XFS_ERRTAG_IFLUSH_6);
148XFS_ERRORTAG_ATTR_RW(dareadbuf, XFS_ERRTAG_DA_READ_BUF);
149XFS_ERRORTAG_ATTR_RW(btree_chk_lblk, XFS_ERRTAG_BTREE_CHECK_LBLOCK);
150XFS_ERRORTAG_ATTR_RW(btree_chk_sblk, XFS_ERRTAG_BTREE_CHECK_SBLOCK);
151XFS_ERRORTAG_ATTR_RW(readagf, XFS_ERRTAG_ALLOC_READ_AGF);
152XFS_ERRORTAG_ATTR_RW(readagi, XFS_ERRTAG_IALLOC_READ_AGI);
153XFS_ERRORTAG_ATTR_RW(itobp, XFS_ERRTAG_ITOBP_INOTOBP);
154XFS_ERRORTAG_ATTR_RW(iunlink, XFS_ERRTAG_IUNLINK);
155XFS_ERRORTAG_ATTR_RW(iunlinkrm, XFS_ERRTAG_IUNLINK_REMOVE);
156XFS_ERRORTAG_ATTR_RW(dirinovalid, XFS_ERRTAG_DIR_INO_VALIDATE);
157XFS_ERRORTAG_ATTR_RW(bulkstat, XFS_ERRTAG_BULKSTAT_READ_CHUNK);
158XFS_ERRORTAG_ATTR_RW(logiodone, XFS_ERRTAG_IODONE_IOERR);
159XFS_ERRORTAG_ATTR_RW(stratread, XFS_ERRTAG_STRATREAD_IOERR);
160XFS_ERRORTAG_ATTR_RW(stratcmpl, XFS_ERRTAG_STRATCMPL_IOERR);
161XFS_ERRORTAG_ATTR_RW(diowrite, XFS_ERRTAG_DIOWRITE_IOERR);
162XFS_ERRORTAG_ATTR_RW(bmapifmt, XFS_ERRTAG_BMAPIFORMAT);
163XFS_ERRORTAG_ATTR_RW(free_extent, XFS_ERRTAG_FREE_EXTENT);
164XFS_ERRORTAG_ATTR_RW(rmap_finish_one, XFS_ERRTAG_RMAP_FINISH_ONE);
165XFS_ERRORTAG_ATTR_RW(refcount_continue_update, XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE);
166XFS_ERRORTAG_ATTR_RW(refcount_finish_one, XFS_ERRTAG_REFCOUNT_FINISH_ONE);
167XFS_ERRORTAG_ATTR_RW(bmap_finish_one, XFS_ERRTAG_BMAP_FINISH_ONE);
168XFS_ERRORTAG_ATTR_RW(ag_resv_critical, XFS_ERRTAG_AG_RESV_CRITICAL);
169XFS_ERRORTAG_ATTR_RW(log_bad_crc, XFS_ERRTAG_LOG_BAD_CRC);
170XFS_ERRORTAG_ATTR_RW(log_item_pin, XFS_ERRTAG_LOG_ITEM_PIN);
171XFS_ERRORTAG_ATTR_RW(buf_lru_ref, XFS_ERRTAG_BUF_LRU_REF);
172XFS_ERRORTAG_ATTR_RW(force_repair, XFS_ERRTAG_FORCE_SCRUB_REPAIR);
173XFS_ERRORTAG_ATTR_RW(bad_summary, XFS_ERRTAG_FORCE_SUMMARY_RECALC);
174XFS_ERRORTAG_ATTR_RW(iunlink_fallback, XFS_ERRTAG_IUNLINK_FALLBACK);
175XFS_ERRORTAG_ATTR_RW(buf_ioerror, XFS_ERRTAG_BUF_IOERROR);
176XFS_ERRORTAG_ATTR_RW(reduce_max_iextents, XFS_ERRTAG_REDUCE_MAX_IEXTENTS);
177XFS_ERRORTAG_ATTR_RW(bmap_alloc_minlen_extent, XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT);
178XFS_ERRORTAG_ATTR_RW(ag_resv_fail, XFS_ERRTAG_AG_RESV_FAIL);
179XFS_ERRORTAG_ATTR_RW(larp, XFS_ERRTAG_LARP);
180XFS_ERRORTAG_ATTR_RW(da_leaf_split, XFS_ERRTAG_DA_LEAF_SPLIT);
181XFS_ERRORTAG_ATTR_RW(attr_leaf_to_node, XFS_ERRTAG_ATTR_LEAF_TO_NODE);
182XFS_ERRORTAG_ATTR_RW(wb_delay_ms, XFS_ERRTAG_WB_DELAY_MS);
183XFS_ERRORTAG_ATTR_RW(write_delay_ms, XFS_ERRTAG_WRITE_DELAY_MS);
184XFS_ERRORTAG_ATTR_RW(exchmaps_finish_one, XFS_ERRTAG_EXCHMAPS_FINISH_ONE);
185XFS_ERRORTAG_ATTR_RW(metafile_resv_crit, XFS_ERRTAG_METAFILE_RESV_CRITICAL);
186
187static 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};
235ATTRIBUTE_GROUPS(xfs_errortag);
236
237static 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
243int
244xfs_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
261void
262xfs_errortag_del(
263 struct xfs_mount *mp)
264{
265 xfs_sysfs_del(&mp->m_errortag_kobj);
266 kfree(mp->m_errortag);
267}
268
269static bool
270xfs_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
282bool
283xfs_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
295bool
296xfs_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
329int
330xfs_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
340int
341xfs_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
353int
354xfs_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
367int
368xfs_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
376void
377xfs_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
394void
395xfs_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 */
418void
419xfs_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 */
439void
440xfs_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 */
477void
478xfs_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 */
491void
492xfs_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}