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 * 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 * 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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