xfs_error.c 12 KB

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