xref: /openbmc/linux/fs/xfs/xfs_error.c (revision 7b73a9c8) 
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 	XFS_RANDOM_DROP_WRITES,
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 };
57 
58 struct xfs_errortag_attr {
59 	struct attribute	attr;
60 	unsigned int		tag;
61 };
62 
63 static inline struct xfs_errortag_attr *
64 to_attr(struct attribute *attr)
65 {
66 	return container_of(attr, struct xfs_errortag_attr, attr);
67 }
68 
69 static inline struct xfs_mount *
70 to_mp(struct kobject *kobject)
71 {
72 	struct xfs_kobj *kobj = to_kobj(kobject);
73 
74 	return container_of(kobj, struct xfs_mount, m_errortag_kobj);
75 }
76 
77 STATIC ssize_t
78 xfs_errortag_attr_store(
79 	struct kobject		*kobject,
80 	struct attribute	*attr,
81 	const char		*buf,
82 	size_t			count)
83 {
84 	struct xfs_mount	*mp = to_mp(kobject);
85 	struct xfs_errortag_attr *xfs_attr = to_attr(attr);
86 	int			ret;
87 	unsigned int		val;
88 
89 	if (strcmp(buf, "default") == 0) {
90 		val = xfs_errortag_random_default[xfs_attr->tag];
91 	} else {
92 		ret = kstrtouint(buf, 0, &val);
93 		if (ret)
94 			return ret;
95 	}
96 
97 	ret = xfs_errortag_set(mp, xfs_attr->tag, val);
98 	if (ret)
99 		return ret;
100 	return count;
101 }
102 
103 STATIC ssize_t
104 xfs_errortag_attr_show(
105 	struct kobject		*kobject,
106 	struct attribute	*attr,
107 	char			*buf)
108 {
109 	struct xfs_mount	*mp = to_mp(kobject);
110 	struct xfs_errortag_attr *xfs_attr = to_attr(attr);
111 
112 	return snprintf(buf, PAGE_SIZE, "%u\n",
113 			xfs_errortag_get(mp, xfs_attr->tag));
114 }
115 
116 static const struct sysfs_ops xfs_errortag_sysfs_ops = {
117 	.show = xfs_errortag_attr_show,
118 	.store = xfs_errortag_attr_store,
119 };
120 
121 #define XFS_ERRORTAG_ATTR_RW(_name, _tag) \
122 static struct xfs_errortag_attr xfs_errortag_attr_##_name = {		\
123 	.attr = {.name = __stringify(_name),				\
124 		 .mode = VERIFY_OCTAL_PERMISSIONS(S_IWUSR | S_IRUGO) },	\
125 	.tag	= (_tag),						\
126 }
127 
128 #define XFS_ERRORTAG_ATTR_LIST(_name) &xfs_errortag_attr_##_name.attr
129 
130 XFS_ERRORTAG_ATTR_RW(noerror,		XFS_ERRTAG_NOERROR);
131 XFS_ERRORTAG_ATTR_RW(iflush1,		XFS_ERRTAG_IFLUSH_1);
132 XFS_ERRORTAG_ATTR_RW(iflush2,		XFS_ERRTAG_IFLUSH_2);
133 XFS_ERRORTAG_ATTR_RW(iflush3,		XFS_ERRTAG_IFLUSH_3);
134 XFS_ERRORTAG_ATTR_RW(iflush4,		XFS_ERRTAG_IFLUSH_4);
135 XFS_ERRORTAG_ATTR_RW(iflush5,		XFS_ERRTAG_IFLUSH_5);
136 XFS_ERRORTAG_ATTR_RW(iflush6,		XFS_ERRTAG_IFLUSH_6);
137 XFS_ERRORTAG_ATTR_RW(dareadbuf,		XFS_ERRTAG_DA_READ_BUF);
138 XFS_ERRORTAG_ATTR_RW(btree_chk_lblk,	XFS_ERRTAG_BTREE_CHECK_LBLOCK);
139 XFS_ERRORTAG_ATTR_RW(btree_chk_sblk,	XFS_ERRTAG_BTREE_CHECK_SBLOCK);
140 XFS_ERRORTAG_ATTR_RW(readagf,		XFS_ERRTAG_ALLOC_READ_AGF);
141 XFS_ERRORTAG_ATTR_RW(readagi,		XFS_ERRTAG_IALLOC_READ_AGI);
142 XFS_ERRORTAG_ATTR_RW(itobp,		XFS_ERRTAG_ITOBP_INOTOBP);
143 XFS_ERRORTAG_ATTR_RW(iunlink,		XFS_ERRTAG_IUNLINK);
144 XFS_ERRORTAG_ATTR_RW(iunlinkrm,		XFS_ERRTAG_IUNLINK_REMOVE);
145 XFS_ERRORTAG_ATTR_RW(dirinovalid,	XFS_ERRTAG_DIR_INO_VALIDATE);
146 XFS_ERRORTAG_ATTR_RW(bulkstat,		XFS_ERRTAG_BULKSTAT_READ_CHUNK);
147 XFS_ERRORTAG_ATTR_RW(logiodone,		XFS_ERRTAG_IODONE_IOERR);
148 XFS_ERRORTAG_ATTR_RW(stratread,		XFS_ERRTAG_STRATREAD_IOERR);
149 XFS_ERRORTAG_ATTR_RW(stratcmpl,		XFS_ERRTAG_STRATCMPL_IOERR);
150 XFS_ERRORTAG_ATTR_RW(diowrite,		XFS_ERRTAG_DIOWRITE_IOERR);
151 XFS_ERRORTAG_ATTR_RW(bmapifmt,		XFS_ERRTAG_BMAPIFORMAT);
152 XFS_ERRORTAG_ATTR_RW(free_extent,	XFS_ERRTAG_FREE_EXTENT);
153 XFS_ERRORTAG_ATTR_RW(rmap_finish_one,	XFS_ERRTAG_RMAP_FINISH_ONE);
154 XFS_ERRORTAG_ATTR_RW(refcount_continue_update,	XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE);
155 XFS_ERRORTAG_ATTR_RW(refcount_finish_one,	XFS_ERRTAG_REFCOUNT_FINISH_ONE);
156 XFS_ERRORTAG_ATTR_RW(bmap_finish_one,	XFS_ERRTAG_BMAP_FINISH_ONE);
157 XFS_ERRORTAG_ATTR_RW(ag_resv_critical,	XFS_ERRTAG_AG_RESV_CRITICAL);
158 XFS_ERRORTAG_ATTR_RW(drop_writes,	XFS_ERRTAG_DROP_WRITES);
159 XFS_ERRORTAG_ATTR_RW(log_bad_crc,	XFS_ERRTAG_LOG_BAD_CRC);
160 XFS_ERRORTAG_ATTR_RW(log_item_pin,	XFS_ERRTAG_LOG_ITEM_PIN);
161 XFS_ERRORTAG_ATTR_RW(buf_lru_ref,	XFS_ERRTAG_BUF_LRU_REF);
162 XFS_ERRORTAG_ATTR_RW(force_repair,	XFS_ERRTAG_FORCE_SCRUB_REPAIR);
163 XFS_ERRORTAG_ATTR_RW(bad_summary,	XFS_ERRTAG_FORCE_SUMMARY_RECALC);
164 XFS_ERRORTAG_ATTR_RW(iunlink_fallback,	XFS_ERRTAG_IUNLINK_FALLBACK);
165 
166 static struct attribute *xfs_errortag_attrs[] = {
167 	XFS_ERRORTAG_ATTR_LIST(noerror),
168 	XFS_ERRORTAG_ATTR_LIST(iflush1),
169 	XFS_ERRORTAG_ATTR_LIST(iflush2),
170 	XFS_ERRORTAG_ATTR_LIST(iflush3),
171 	XFS_ERRORTAG_ATTR_LIST(iflush4),
172 	XFS_ERRORTAG_ATTR_LIST(iflush5),
173 	XFS_ERRORTAG_ATTR_LIST(iflush6),
174 	XFS_ERRORTAG_ATTR_LIST(dareadbuf),
175 	XFS_ERRORTAG_ATTR_LIST(btree_chk_lblk),
176 	XFS_ERRORTAG_ATTR_LIST(btree_chk_sblk),
177 	XFS_ERRORTAG_ATTR_LIST(readagf),
178 	XFS_ERRORTAG_ATTR_LIST(readagi),
179 	XFS_ERRORTAG_ATTR_LIST(itobp),
180 	XFS_ERRORTAG_ATTR_LIST(iunlink),
181 	XFS_ERRORTAG_ATTR_LIST(iunlinkrm),
182 	XFS_ERRORTAG_ATTR_LIST(dirinovalid),
183 	XFS_ERRORTAG_ATTR_LIST(bulkstat),
184 	XFS_ERRORTAG_ATTR_LIST(logiodone),
185 	XFS_ERRORTAG_ATTR_LIST(stratread),
186 	XFS_ERRORTAG_ATTR_LIST(stratcmpl),
187 	XFS_ERRORTAG_ATTR_LIST(diowrite),
188 	XFS_ERRORTAG_ATTR_LIST(bmapifmt),
189 	XFS_ERRORTAG_ATTR_LIST(free_extent),
190 	XFS_ERRORTAG_ATTR_LIST(rmap_finish_one),
191 	XFS_ERRORTAG_ATTR_LIST(refcount_continue_update),
192 	XFS_ERRORTAG_ATTR_LIST(refcount_finish_one),
193 	XFS_ERRORTAG_ATTR_LIST(bmap_finish_one),
194 	XFS_ERRORTAG_ATTR_LIST(ag_resv_critical),
195 	XFS_ERRORTAG_ATTR_LIST(drop_writes),
196 	XFS_ERRORTAG_ATTR_LIST(log_bad_crc),
197 	XFS_ERRORTAG_ATTR_LIST(log_item_pin),
198 	XFS_ERRORTAG_ATTR_LIST(buf_lru_ref),
199 	XFS_ERRORTAG_ATTR_LIST(force_repair),
200 	XFS_ERRORTAG_ATTR_LIST(bad_summary),
201 	XFS_ERRORTAG_ATTR_LIST(iunlink_fallback),
202 	NULL,
203 };
204 
205 static struct kobj_type xfs_errortag_ktype = {
206 	.release = xfs_sysfs_release,
207 	.sysfs_ops = &xfs_errortag_sysfs_ops,
208 	.default_attrs = xfs_errortag_attrs,
209 };
210 
211 int
212 xfs_errortag_init(
213 	struct xfs_mount	*mp)
214 {
215 	mp->m_errortag = kmem_zalloc(sizeof(unsigned int) * XFS_ERRTAG_MAX,
216 			KM_MAYFAIL);
217 	if (!mp->m_errortag)
218 		return -ENOMEM;
219 
220 	return xfs_sysfs_init(&mp->m_errortag_kobj, &xfs_errortag_ktype,
221 			       &mp->m_kobj, "errortag");
222 }
223 
224 void
225 xfs_errortag_del(
226 	struct xfs_mount	*mp)
227 {
228 	xfs_sysfs_del(&mp->m_errortag_kobj);
229 	kmem_free(mp->m_errortag);
230 }
231 
232 bool
233 xfs_errortag_test(
234 	struct xfs_mount	*mp,
235 	const char		*expression,
236 	const char		*file,
237 	int			line,
238 	unsigned int		error_tag)
239 {
240 	unsigned int		randfactor;
241 
242 	/*
243 	 * To be able to use error injection anywhere, we need to ensure error
244 	 * injection mechanism is already initialized.
245 	 *
246 	 * Code paths like I/O completion can be called before the
247 	 * initialization is complete, but be able to inject errors in such
248 	 * places is still useful.
249 	 */
250 	if (!mp->m_errortag)
251 		return false;
252 
253 	ASSERT(error_tag < XFS_ERRTAG_MAX);
254 	randfactor = mp->m_errortag[error_tag];
255 	if (!randfactor || prandom_u32() % randfactor)
256 		return false;
257 
258 	xfs_warn_ratelimited(mp,
259 "Injecting error (%s) at file %s, line %d, on filesystem \"%s\"",
260 			expression, file, line, mp->m_super->s_id);
261 	return true;
262 }
263 
264 int
265 xfs_errortag_get(
266 	struct xfs_mount	*mp,
267 	unsigned int		error_tag)
268 {
269 	if (error_tag >= XFS_ERRTAG_MAX)
270 		return -EINVAL;
271 
272 	return mp->m_errortag[error_tag];
273 }
274 
275 int
276 xfs_errortag_set(
277 	struct xfs_mount	*mp,
278 	unsigned int		error_tag,
279 	unsigned int		tag_value)
280 {
281 	if (error_tag >= XFS_ERRTAG_MAX)
282 		return -EINVAL;
283 
284 	mp->m_errortag[error_tag] = tag_value;
285 	return 0;
286 }
287 
288 int
289 xfs_errortag_add(
290 	struct xfs_mount	*mp,
291 	unsigned int		error_tag)
292 {
293 	if (error_tag >= XFS_ERRTAG_MAX)
294 		return -EINVAL;
295 
296 	return xfs_errortag_set(mp, error_tag,
297 			xfs_errortag_random_default[error_tag]);
298 }
299 
300 int
301 xfs_errortag_clearall(
302 	struct xfs_mount	*mp)
303 {
304 	memset(mp->m_errortag, 0, sizeof(unsigned int) * XFS_ERRTAG_MAX);
305 	return 0;
306 }
307 #endif /* DEBUG */
308 
309 void
310 xfs_error_report(
311 	const char		*tag,
312 	int			level,
313 	struct xfs_mount	*mp,
314 	const char		*filename,
315 	int			linenum,
316 	xfs_failaddr_t		failaddr)
317 {
318 	if (level <= xfs_error_level) {
319 		xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT,
320 		"Internal error %s at line %d of file %s.  Caller %pS",
321 			    tag, linenum, filename, failaddr);
322 
323 		xfs_stack_trace();
324 	}
325 }
326 
327 void
328 xfs_corruption_error(
329 	const char		*tag,
330 	int			level,
331 	struct xfs_mount	*mp,
332 	const void		*buf,
333 	size_t			bufsize,
334 	const char		*filename,
335 	int			linenum,
336 	xfs_failaddr_t		failaddr)
337 {
338 	if (buf && level <= xfs_error_level)
339 		xfs_hex_dump(buf, bufsize);
340 	xfs_error_report(tag, level, mp, filename, linenum, failaddr);
341 	xfs_alert(mp, "Corruption detected. Unmount and run xfs_repair");
342 }
343 
344 /*
345  * Complain about the kinds of metadata corruption that we can't detect from a
346  * verifier, such as incorrect inter-block relationship data.  Does not set
347  * bp->b_error.
348  */
349 void
350 xfs_buf_corruption_error(
351 	struct xfs_buf		*bp)
352 {
353 	struct xfs_mount	*mp = bp->b_mount;
354 
355 	xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
356 		  "Metadata corruption detected at %pS, %s block 0x%llx",
357 		  __return_address, bp->b_ops->name, bp->b_bn);
358 
359 	xfs_alert(mp, "Unmount and run xfs_repair");
360 
361 	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
362 		xfs_stack_trace();
363 }
364 
365 /*
366  * Warnings specifically for verifier errors.  Differentiate CRC vs. invalid
367  * values, and omit the stack trace unless the error level is tuned high.
368  */
369 void
370 xfs_buf_verifier_error(
371 	struct xfs_buf		*bp,
372 	int			error,
373 	const char		*name,
374 	const void		*buf,
375 	size_t			bufsz,
376 	xfs_failaddr_t		failaddr)
377 {
378 	struct xfs_mount	*mp = bp->b_mount;
379 	xfs_failaddr_t		fa;
380 	int			sz;
381 
382 	fa = failaddr ? failaddr : __return_address;
383 	__xfs_buf_ioerror(bp, error, fa);
384 
385 	xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
386 		  "Metadata %s detected at %pS, %s block 0x%llx %s",
387 		  bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
388 		  fa, bp->b_ops->name, bp->b_bn, name);
389 
390 	xfs_alert(mp, "Unmount and run xfs_repair");
391 
392 	if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
393 		sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
394 		xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
395 				sz);
396 		xfs_hex_dump(buf, sz);
397 	}
398 
399 	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
400 		xfs_stack_trace();
401 }
402 
403 /*
404  * Warnings specifically for verifier errors.  Differentiate CRC vs. invalid
405  * values, and omit the stack trace unless the error level is tuned high.
406  */
407 void
408 xfs_verifier_error(
409 	struct xfs_buf		*bp,
410 	int			error,
411 	xfs_failaddr_t		failaddr)
412 {
413 	return xfs_buf_verifier_error(bp, error, "", xfs_buf_offset(bp, 0),
414 			XFS_CORRUPTION_DUMP_LEN, failaddr);
415 }
416 
417 /*
418  * Warnings for inode corruption problems.  Don't bother with the stack
419  * trace unless the error level is turned up high.
420  */
421 void
422 xfs_inode_verifier_error(
423 	struct xfs_inode	*ip,
424 	int			error,
425 	const char		*name,
426 	const void		*buf,
427 	size_t			bufsz,
428 	xfs_failaddr_t		failaddr)
429 {
430 	struct xfs_mount	*mp = ip->i_mount;
431 	xfs_failaddr_t		fa;
432 	int			sz;
433 
434 	fa = failaddr ? failaddr : __return_address;
435 
436 	xfs_alert(mp, "Metadata %s detected at %pS, inode 0x%llx %s",
437 		  error == -EFSBADCRC ? "CRC error" : "corruption",
438 		  fa, ip->i_ino, name);
439 
440 	xfs_alert(mp, "Unmount and run xfs_repair");
441 
442 	if (buf && xfs_error_level >= XFS_ERRLEVEL_LOW) {
443 		sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
444 		xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
445 				sz);
446 		xfs_hex_dump(buf, sz);
447 	}
448 
449 	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
450 		xfs_stack_trace();
451 }
452