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