fs/xfs/xfs_error.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
0004  * All Rights Reserved.
0005  */
0006 #include "xfs.h"
0007 #include "xfs_shared.h"
0008 #include "xfs_format.h"
0009 #include "xfs_fs.h"
0010 #include "xfs_log_format.h"
0011 #include "xfs_trans_resv.h"
0012 #include "xfs_mount.h"
0013 #include "xfs_errortag.h"
0014 #include "xfs_error.h"
0015 #include "xfs_sysfs.h"
0016 #include "xfs_inode.h"
0017
0018 #ifdef DEBUG
0019
0020 static unsigned int xfs_errortag_random_default[] = {
0021     XFS_RANDOM_DEFAULT,
0022     XFS_RANDOM_IFLUSH_1,
0023     XFS_RANDOM_IFLUSH_2,
0024     XFS_RANDOM_IFLUSH_3,
0025     XFS_RANDOM_IFLUSH_4,
0026     XFS_RANDOM_IFLUSH_5,
0027     XFS_RANDOM_IFLUSH_6,
0028     XFS_RANDOM_DA_READ_BUF,
0029     XFS_RANDOM_BTREE_CHECK_LBLOCK,
0030     XFS_RANDOM_BTREE_CHECK_SBLOCK,
0031     XFS_RANDOM_ALLOC_READ_AGF,
0032     XFS_RANDOM_IALLOC_READ_AGI,
0033     XFS_RANDOM_ITOBP_INOTOBP,
0034     XFS_RANDOM_IUNLINK,
0035     XFS_RANDOM_IUNLINK_REMOVE,
0036     XFS_RANDOM_DIR_INO_VALIDATE,
0037     XFS_RANDOM_BULKSTAT_READ_CHUNK,
0038     XFS_RANDOM_IODONE_IOERR,
0039     XFS_RANDOM_STRATREAD_IOERR,
0040     XFS_RANDOM_STRATCMPL_IOERR,
0041     XFS_RANDOM_DIOWRITE_IOERR,
0042     XFS_RANDOM_BMAPIFORMAT,
0043     XFS_RANDOM_FREE_EXTENT,
0044     XFS_RANDOM_RMAP_FINISH_ONE,
0045     XFS_RANDOM_REFCOUNT_CONTINUE_UPDATE,
0046     XFS_RANDOM_REFCOUNT_FINISH_ONE,
0047     XFS_RANDOM_BMAP_FINISH_ONE,
0048     XFS_RANDOM_AG_RESV_CRITICAL,
0049     XFS_RANDOM_DROP_WRITES,
0050     XFS_RANDOM_LOG_BAD_CRC,
0051     XFS_RANDOM_LOG_ITEM_PIN,
0052     XFS_RANDOM_BUF_LRU_REF,
0053     XFS_RANDOM_FORCE_SCRUB_REPAIR,
0054     XFS_RANDOM_FORCE_SUMMARY_RECALC,
0055     XFS_RANDOM_IUNLINK_FALLBACK,
0056     XFS_RANDOM_BUF_IOERROR,
0057     XFS_RANDOM_REDUCE_MAX_IEXTENTS,
0058     XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT,
0059     XFS_RANDOM_AG_RESV_FAIL,
0060     XFS_RANDOM_LARP,
0061     XFS_RANDOM_DA_LEAF_SPLIT,
0062     XFS_RANDOM_ATTR_LEAF_TO_NODE,
0063 };
0064
0065 struct xfs_errortag_attr {
0066     struct attribute    attr;
0067     unsigned int        tag;
0068 };
0069
0070 static inline struct xfs_errortag_attr *
0071 to_attr(struct attribute *attr)
0072 {
0073     return container_of(attr, struct xfs_errortag_attr, attr);
0074 }
0075
0076 static inline struct xfs_mount *
0077 to_mp(struct kobject *kobject)
0078 {
0079     struct xfs_kobj *kobj = to_kobj(kobject);
0080
0081     return container_of(kobj, struct xfs_mount, m_errortag_kobj);
0082 }
0083
0084 STATIC ssize_t
0085 xfs_errortag_attr_store(
0086     struct kobject      *kobject,
0087     struct attribute    *attr,
0088     const char      *buf,
0089     size_t          count)
0090 {
0091     struct xfs_mount    *mp = to_mp(kobject);
0092     struct xfs_errortag_attr *xfs_attr = to_attr(attr);
0093     int         ret;
0094     unsigned int        val;
0095
0096     if (strcmp(buf, "default") == 0) {
0097         val = xfs_errortag_random_default[xfs_attr->tag];
0098     } else {
0099         ret = kstrtouint(buf, 0, &val);
0100         if (ret)
0101             return ret;
0102     }
0103
0104     ret = xfs_errortag_set(mp, xfs_attr->tag, val);
0105     if (ret)
0106         return ret;
0107     return count;
0108 }
0109
0110 STATIC ssize_t
0111 xfs_errortag_attr_show(
0112     struct kobject      *kobject,
0113     struct attribute    *attr,
0114     char            *buf)
0115 {
0116     struct xfs_mount    *mp = to_mp(kobject);
0117     struct xfs_errortag_attr *xfs_attr = to_attr(attr);
0118
0119     return snprintf(buf, PAGE_SIZE, "%u\n",
0120             xfs_errortag_get(mp, xfs_attr->tag));
0121 }
0122
0123 static const struct sysfs_ops xfs_errortag_sysfs_ops = {
0124     .show = xfs_errortag_attr_show,
0125     .store = xfs_errortag_attr_store,
0126 };
0127
0128 #define XFS_ERRORTAG_ATTR_RW(_name, _tag) \
0129 static struct xfs_errortag_attr xfs_errortag_attr_##_name = {       \
0130     .attr = {.name = __stringify(_name),                \
0131          .mode = VERIFY_OCTAL_PERMISSIONS(S_IWUSR | S_IRUGO) }, \
0132     .tag    = (_tag),                       \
0133 }
0134
0135 #define XFS_ERRORTAG_ATTR_LIST(_name) &xfs_errortag_attr_##_name.attr
0136
0137 XFS_ERRORTAG_ATTR_RW(noerror,       XFS_ERRTAG_NOERROR);
0138 XFS_ERRORTAG_ATTR_RW(iflush1,       XFS_ERRTAG_IFLUSH_1);
0139 XFS_ERRORTAG_ATTR_RW(iflush2,       XFS_ERRTAG_IFLUSH_2);
0140 XFS_ERRORTAG_ATTR_RW(iflush3,       XFS_ERRTAG_IFLUSH_3);
0141 XFS_ERRORTAG_ATTR_RW(iflush4,       XFS_ERRTAG_IFLUSH_4);
0142 XFS_ERRORTAG_ATTR_RW(iflush5,       XFS_ERRTAG_IFLUSH_5);
0143 XFS_ERRORTAG_ATTR_RW(iflush6,       XFS_ERRTAG_IFLUSH_6);
0144 XFS_ERRORTAG_ATTR_RW(dareadbuf,     XFS_ERRTAG_DA_READ_BUF);
0145 XFS_ERRORTAG_ATTR_RW(btree_chk_lblk,    XFS_ERRTAG_BTREE_CHECK_LBLOCK);
0146 XFS_ERRORTAG_ATTR_RW(btree_chk_sblk,    XFS_ERRTAG_BTREE_CHECK_SBLOCK);
0147 XFS_ERRORTAG_ATTR_RW(readagf,       XFS_ERRTAG_ALLOC_READ_AGF);
0148 XFS_ERRORTAG_ATTR_RW(readagi,       XFS_ERRTAG_IALLOC_READ_AGI);
0149 XFS_ERRORTAG_ATTR_RW(itobp,     XFS_ERRTAG_ITOBP_INOTOBP);
0150 XFS_ERRORTAG_ATTR_RW(iunlink,       XFS_ERRTAG_IUNLINK);
0151 XFS_ERRORTAG_ATTR_RW(iunlinkrm,     XFS_ERRTAG_IUNLINK_REMOVE);
0152 XFS_ERRORTAG_ATTR_RW(dirinovalid,   XFS_ERRTAG_DIR_INO_VALIDATE);
0153 XFS_ERRORTAG_ATTR_RW(bulkstat,      XFS_ERRTAG_BULKSTAT_READ_CHUNK);
0154 XFS_ERRORTAG_ATTR_RW(logiodone,     XFS_ERRTAG_IODONE_IOERR);
0155 XFS_ERRORTAG_ATTR_RW(stratread,     XFS_ERRTAG_STRATREAD_IOERR);
0156 XFS_ERRORTAG_ATTR_RW(stratcmpl,     XFS_ERRTAG_STRATCMPL_IOERR);
0157 XFS_ERRORTAG_ATTR_RW(diowrite,      XFS_ERRTAG_DIOWRITE_IOERR);
0158 XFS_ERRORTAG_ATTR_RW(bmapifmt,      XFS_ERRTAG_BMAPIFORMAT);
0159 XFS_ERRORTAG_ATTR_RW(free_extent,   XFS_ERRTAG_FREE_EXTENT);
0160 XFS_ERRORTAG_ATTR_RW(rmap_finish_one,   XFS_ERRTAG_RMAP_FINISH_ONE);
0161 XFS_ERRORTAG_ATTR_RW(refcount_continue_update,  XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE);
0162 XFS_ERRORTAG_ATTR_RW(refcount_finish_one,   XFS_ERRTAG_REFCOUNT_FINISH_ONE);
0163 XFS_ERRORTAG_ATTR_RW(bmap_finish_one,   XFS_ERRTAG_BMAP_FINISH_ONE);
0164 XFS_ERRORTAG_ATTR_RW(ag_resv_critical,  XFS_ERRTAG_AG_RESV_CRITICAL);
0165 XFS_ERRORTAG_ATTR_RW(drop_writes,   XFS_ERRTAG_DROP_WRITES);
0166 XFS_ERRORTAG_ATTR_RW(log_bad_crc,   XFS_ERRTAG_LOG_BAD_CRC);
0167 XFS_ERRORTAG_ATTR_RW(log_item_pin,  XFS_ERRTAG_LOG_ITEM_PIN);
0168 XFS_ERRORTAG_ATTR_RW(buf_lru_ref,   XFS_ERRTAG_BUF_LRU_REF);
0169 XFS_ERRORTAG_ATTR_RW(force_repair,  XFS_ERRTAG_FORCE_SCRUB_REPAIR);
0170 XFS_ERRORTAG_ATTR_RW(bad_summary,   XFS_ERRTAG_FORCE_SUMMARY_RECALC);
0171 XFS_ERRORTAG_ATTR_RW(iunlink_fallback,  XFS_ERRTAG_IUNLINK_FALLBACK);
0172 XFS_ERRORTAG_ATTR_RW(buf_ioerror,   XFS_ERRTAG_BUF_IOERROR);
0173 XFS_ERRORTAG_ATTR_RW(reduce_max_iextents,   XFS_ERRTAG_REDUCE_MAX_IEXTENTS);
0174 XFS_ERRORTAG_ATTR_RW(bmap_alloc_minlen_extent,  XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT);
0175 XFS_ERRORTAG_ATTR_RW(ag_resv_fail, XFS_ERRTAG_AG_RESV_FAIL);
0176 XFS_ERRORTAG_ATTR_RW(larp,      XFS_ERRTAG_LARP);
0177 XFS_ERRORTAG_ATTR_RW(da_leaf_split, XFS_ERRTAG_DA_LEAF_SPLIT);
0178 XFS_ERRORTAG_ATTR_RW(attr_leaf_to_node, XFS_ERRTAG_ATTR_LEAF_TO_NODE);
0179
0180 static struct attribute *xfs_errortag_attrs[] = {
0181     XFS_ERRORTAG_ATTR_LIST(noerror),
0182     XFS_ERRORTAG_ATTR_LIST(iflush1),
0183     XFS_ERRORTAG_ATTR_LIST(iflush2),
0184     XFS_ERRORTAG_ATTR_LIST(iflush3),
0185     XFS_ERRORTAG_ATTR_LIST(iflush4),
0186     XFS_ERRORTAG_ATTR_LIST(iflush5),
0187     XFS_ERRORTAG_ATTR_LIST(iflush6),
0188     XFS_ERRORTAG_ATTR_LIST(dareadbuf),
0189     XFS_ERRORTAG_ATTR_LIST(btree_chk_lblk),
0190     XFS_ERRORTAG_ATTR_LIST(btree_chk_sblk),
0191     XFS_ERRORTAG_ATTR_LIST(readagf),
0192     XFS_ERRORTAG_ATTR_LIST(readagi),
0193     XFS_ERRORTAG_ATTR_LIST(itobp),
0194     XFS_ERRORTAG_ATTR_LIST(iunlink),
0195     XFS_ERRORTAG_ATTR_LIST(iunlinkrm),
0196     XFS_ERRORTAG_ATTR_LIST(dirinovalid),
0197     XFS_ERRORTAG_ATTR_LIST(bulkstat),
0198     XFS_ERRORTAG_ATTR_LIST(logiodone),
0199     XFS_ERRORTAG_ATTR_LIST(stratread),
0200     XFS_ERRORTAG_ATTR_LIST(stratcmpl),
0201     XFS_ERRORTAG_ATTR_LIST(diowrite),
0202     XFS_ERRORTAG_ATTR_LIST(bmapifmt),
0203     XFS_ERRORTAG_ATTR_LIST(free_extent),
0204     XFS_ERRORTAG_ATTR_LIST(rmap_finish_one),
0205     XFS_ERRORTAG_ATTR_LIST(refcount_continue_update),
0206     XFS_ERRORTAG_ATTR_LIST(refcount_finish_one),
0207     XFS_ERRORTAG_ATTR_LIST(bmap_finish_one),
0208     XFS_ERRORTAG_ATTR_LIST(ag_resv_critical),
0209     XFS_ERRORTAG_ATTR_LIST(drop_writes),
0210     XFS_ERRORTAG_ATTR_LIST(log_bad_crc),
0211     XFS_ERRORTAG_ATTR_LIST(log_item_pin),
0212     XFS_ERRORTAG_ATTR_LIST(buf_lru_ref),
0213     XFS_ERRORTAG_ATTR_LIST(force_repair),
0214     XFS_ERRORTAG_ATTR_LIST(bad_summary),
0215     XFS_ERRORTAG_ATTR_LIST(iunlink_fallback),
0216     XFS_ERRORTAG_ATTR_LIST(buf_ioerror),
0217     XFS_ERRORTAG_ATTR_LIST(reduce_max_iextents),
0218     XFS_ERRORTAG_ATTR_LIST(bmap_alloc_minlen_extent),
0219     XFS_ERRORTAG_ATTR_LIST(ag_resv_fail),
0220     XFS_ERRORTAG_ATTR_LIST(larp),
0221     XFS_ERRORTAG_ATTR_LIST(da_leaf_split),
0222     XFS_ERRORTAG_ATTR_LIST(attr_leaf_to_node),
0223     NULL,
0224 };
0225 ATTRIBUTE_GROUPS(xfs_errortag);
0226
0227 static struct kobj_type xfs_errortag_ktype = {
0228     .release = xfs_sysfs_release,
0229     .sysfs_ops = &xfs_errortag_sysfs_ops,
0230     .default_groups = xfs_errortag_groups,
0231 };
0232
0233 int
0234 xfs_errortag_init(
0235     struct xfs_mount    *mp)
0236 {
0237     mp->m_errortag = kmem_zalloc(sizeof(unsigned int) * XFS_ERRTAG_MAX,
0238             KM_MAYFAIL);
0239     if (!mp->m_errortag)
0240         return -ENOMEM;
0241
0242     return xfs_sysfs_init(&mp->m_errortag_kobj, &xfs_errortag_ktype,
0243                    &mp->m_kobj, "errortag");
0244 }
0245
0246 void
0247 xfs_errortag_del(
0248     struct xfs_mount    *mp)
0249 {
0250     xfs_sysfs_del(&mp->m_errortag_kobj);
0251     kmem_free(mp->m_errortag);
0252 }
0253
0254 bool
0255 xfs_errortag_test(
0256     struct xfs_mount    *mp,
0257     const char      *expression,
0258     const char      *file,
0259     int         line,
0260     unsigned int        error_tag)
0261 {
0262     unsigned int        randfactor;
0263
0264     /*
0265      * To be able to use error injection anywhere, we need to ensure error
0266      * injection mechanism is already initialized.
0267      *
0268      * Code paths like I/O completion can be called before the
0269      * initialization is complete, but be able to inject errors in such
0270      * places is still useful.
0271      */
0272     if (!mp->m_errortag)
0273         return false;
0274
0275     ASSERT(error_tag < XFS_ERRTAG_MAX);
0276     randfactor = mp->m_errortag[error_tag];
0277     if (!randfactor || prandom_u32() % randfactor)
0278         return false;
0279
0280     xfs_warn_ratelimited(mp,
0281 "Injecting error (%s) at file %s, line %d, on filesystem \"%s\"",
0282             expression, file, line, mp->m_super->s_id);
0283     return true;
0284 }
0285
0286 int
0287 xfs_errortag_get(
0288     struct xfs_mount    *mp,
0289     unsigned int        error_tag)
0290 {
0291     if (error_tag >= XFS_ERRTAG_MAX)
0292         return -EINVAL;
0293
0294     return mp->m_errortag[error_tag];
0295 }
0296
0297 int
0298 xfs_errortag_set(
0299     struct xfs_mount    *mp,
0300     unsigned int        error_tag,
0301     unsigned int        tag_value)
0302 {
0303     if (error_tag >= XFS_ERRTAG_MAX)
0304         return -EINVAL;
0305
0306     mp->m_errortag[error_tag] = tag_value;
0307     return 0;
0308 }
0309
0310 int
0311 xfs_errortag_add(
0312     struct xfs_mount    *mp,
0313     unsigned int        error_tag)
0314 {
0315     BUILD_BUG_ON(ARRAY_SIZE(xfs_errortag_random_default) != XFS_ERRTAG_MAX);
0316
0317     if (error_tag >= XFS_ERRTAG_MAX)
0318         return -EINVAL;
0319
0320     return xfs_errortag_set(mp, error_tag,
0321             xfs_errortag_random_default[error_tag]);
0322 }
0323
0324 int
0325 xfs_errortag_clearall(
0326     struct xfs_mount    *mp)
0327 {
0328     memset(mp->m_errortag, 0, sizeof(unsigned int) * XFS_ERRTAG_MAX);
0329     return 0;
0330 }
0331 #endif /* DEBUG */
0332
0333 void
0334 xfs_error_report(
0335     const char      *tag,
0336     int         level,
0337     struct xfs_mount    *mp,
0338     const char      *filename,
0339     int         linenum,
0340     xfs_failaddr_t      failaddr)
0341 {
0342     if (level <= xfs_error_level) {
0343         xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT,
0344         "Internal error %s at line %d of file %s.  Caller %pS",
0345                 tag, linenum, filename, failaddr);
0346
0347         xfs_stack_trace();
0348     }
0349 }
0350
0351 void
0352 xfs_corruption_error(
0353     const char      *tag,
0354     int         level,
0355     struct xfs_mount    *mp,
0356     const void      *buf,
0357     size_t          bufsize,
0358     const char      *filename,
0359     int         linenum,
0360     xfs_failaddr_t      failaddr)
0361 {
0362     if (buf && level <= xfs_error_level)
0363         xfs_hex_dump(buf, bufsize);
0364     xfs_error_report(tag, level, mp, filename, linenum, failaddr);
0365     xfs_alert(mp, "Corruption detected. Unmount and run xfs_repair");
0366 }
0367
0368 /*
0369  * Complain about the kinds of metadata corruption that we can't detect from a
0370  * verifier, such as incorrect inter-block relationship data.  Does not set
0371  * bp->b_error.
0372  *
0373  * Call xfs_buf_mark_corrupt, not this function.
0374  */
0375 void
0376 xfs_buf_corruption_error(
0377     struct xfs_buf      *bp,
0378     xfs_failaddr_t      fa)
0379 {
0380     struct xfs_mount    *mp = bp->b_mount;
0381
0382     xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
0383           "Metadata corruption detected at %pS, %s block 0x%llx",
0384           fa, bp->b_ops->name, xfs_buf_daddr(bp));
0385
0386     xfs_alert(mp, "Unmount and run xfs_repair");
0387
0388     if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
0389         xfs_stack_trace();
0390 }
0391
0392 /*
0393  * Warnings specifically for verifier errors.  Differentiate CRC vs. invalid
0394  * values, and omit the stack trace unless the error level is tuned high.
0395  */
0396 void
0397 xfs_buf_verifier_error(
0398     struct xfs_buf      *bp,
0399     int         error,
0400     const char      *name,
0401     const void      *buf,
0402     size_t          bufsz,
0403     xfs_failaddr_t      failaddr)
0404 {
0405     struct xfs_mount    *mp = bp->b_mount;
0406     xfs_failaddr_t      fa;
0407     int         sz;
0408
0409     fa = failaddr ? failaddr : __return_address;
0410     __xfs_buf_ioerror(bp, error, fa);
0411
0412     xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
0413           "Metadata %s detected at %pS, %s block 0x%llx %s",
0414           bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
0415           fa, bp->b_ops->name, xfs_buf_daddr(bp), name);
0416
0417     xfs_alert(mp, "Unmount and run xfs_repair");
0418
0419     if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
0420         sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
0421         xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
0422                 sz);
0423         xfs_hex_dump(buf, sz);
0424     }
0425
0426     if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
0427         xfs_stack_trace();
0428 }
0429
0430 /*
0431  * Warnings specifically for verifier errors.  Differentiate CRC vs. invalid
0432  * values, and omit the stack trace unless the error level is tuned high.
0433  */
0434 void
0435 xfs_verifier_error(
0436     struct xfs_buf      *bp,
0437     int         error,
0438     xfs_failaddr_t      failaddr)
0439 {
0440     return xfs_buf_verifier_error(bp, error, "", xfs_buf_offset(bp, 0),
0441             XFS_CORRUPTION_DUMP_LEN, failaddr);
0442 }
0443
0444 /*
0445  * Warnings for inode corruption problems.  Don't bother with the stack
0446  * trace unless the error level is turned up high.
0447  */
0448 void
0449 xfs_inode_verifier_error(
0450     struct xfs_inode    *ip,
0451     int         error,
0452     const char      *name,
0453     const void      *buf,
0454     size_t          bufsz,
0455     xfs_failaddr_t      failaddr)
0456 {
0457     struct xfs_mount    *mp = ip->i_mount;
0458     xfs_failaddr_t      fa;
0459     int         sz;
0460
0461     fa = failaddr ? failaddr : __return_address;
0462
0463     xfs_alert(mp, "Metadata %s detected at %pS, inode 0x%llx %s",
0464           error == -EFSBADCRC ? "CRC error" : "corruption",
0465           fa, ip->i_ino, name);
0466
0467     xfs_alert(mp, "Unmount and run xfs_repair");
0468
0469     if (buf && xfs_error_level >= XFS_ERRLEVEL_LOW) {
0470         sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
0471         xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
0472                 sz);
0473         xfs_hex_dump(buf, sz);
0474     }
0475
0476     if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
0477         xfs_stack_trace();
0478 }