1 /* 2 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 #include "xfs.h" 19 #include "xfs_format.h" 20 #include "xfs_fs.h" 21 #include "xfs_log_format.h" 22 #include "xfs_trans_resv.h" 23 #include "xfs_mount.h" 24 #include "xfs_error.h" 25 #include "xfs_sysfs.h" 26 27 #ifdef DEBUG 28 29 static unsigned int xfs_errortag_random_default[] = { 30 XFS_RANDOM_DEFAULT, 31 XFS_RANDOM_IFLUSH_1, 32 XFS_RANDOM_IFLUSH_2, 33 XFS_RANDOM_IFLUSH_3, 34 XFS_RANDOM_IFLUSH_4, 35 XFS_RANDOM_IFLUSH_5, 36 XFS_RANDOM_IFLUSH_6, 37 XFS_RANDOM_DA_READ_BUF, 38 XFS_RANDOM_BTREE_CHECK_LBLOCK, 39 XFS_RANDOM_BTREE_CHECK_SBLOCK, 40 XFS_RANDOM_ALLOC_READ_AGF, 41 XFS_RANDOM_IALLOC_READ_AGI, 42 XFS_RANDOM_ITOBP_INOTOBP, 43 XFS_RANDOM_IUNLINK, 44 XFS_RANDOM_IUNLINK_REMOVE, 45 XFS_RANDOM_DIR_INO_VALIDATE, 46 XFS_RANDOM_BULKSTAT_READ_CHUNK, 47 XFS_RANDOM_IODONE_IOERR, 48 XFS_RANDOM_STRATREAD_IOERR, 49 XFS_RANDOM_STRATCMPL_IOERR, 50 XFS_RANDOM_DIOWRITE_IOERR, 51 XFS_RANDOM_BMAPIFORMAT, 52 XFS_RANDOM_FREE_EXTENT, 53 XFS_RANDOM_RMAP_FINISH_ONE, 54 XFS_RANDOM_REFCOUNT_CONTINUE_UPDATE, 55 XFS_RANDOM_REFCOUNT_FINISH_ONE, 56 XFS_RANDOM_BMAP_FINISH_ONE, 57 XFS_RANDOM_AG_RESV_CRITICAL, 58 XFS_RANDOM_DROP_WRITES, 59 XFS_RANDOM_LOG_BAD_CRC, 60 }; 61 62 struct xfs_errortag_attr { 63 struct attribute attr; 64 unsigned int tag; 65 }; 66 67 static inline struct xfs_errortag_attr * 68 to_attr(struct attribute *attr) 69 { 70 return container_of(attr, struct xfs_errortag_attr, attr); 71 } 72 73 static inline struct xfs_mount * 74 to_mp(struct kobject *kobject) 75 { 76 struct xfs_kobj *kobj = to_kobj(kobject); 77 78 return container_of(kobj, struct xfs_mount, m_errortag_kobj); 79 } 80 81 STATIC ssize_t 82 xfs_errortag_attr_store( 83 struct kobject *kobject, 84 struct attribute *attr, 85 const char *buf, 86 size_t count) 87 { 88 struct xfs_mount *mp = to_mp(kobject); 89 struct xfs_errortag_attr *xfs_attr = to_attr(attr); 90 int ret; 91 unsigned int val; 92 93 if (strcmp(buf, "default") == 0) { 94 val = xfs_errortag_random_default[xfs_attr->tag]; 95 } else { 96 ret = kstrtouint(buf, 0, &val); 97 if (ret) 98 return ret; 99 } 100 101 ret = xfs_errortag_set(mp, xfs_attr->tag, val); 102 if (ret) 103 return ret; 104 return count; 105 } 106 107 STATIC ssize_t 108 xfs_errortag_attr_show( 109 struct kobject *kobject, 110 struct attribute *attr, 111 char *buf) 112 { 113 struct xfs_mount *mp = to_mp(kobject); 114 struct xfs_errortag_attr *xfs_attr = to_attr(attr); 115 116 return snprintf(buf, PAGE_SIZE, "%u\n", 117 xfs_errortag_get(mp, xfs_attr->tag)); 118 } 119 120 static const struct sysfs_ops xfs_errortag_sysfs_ops = { 121 .show = xfs_errortag_attr_show, 122 .store = xfs_errortag_attr_store, 123 }; 124 125 #define XFS_ERRORTAG_ATTR_RW(_name, _tag) \ 126 static struct xfs_errortag_attr xfs_errortag_attr_##_name = { \ 127 .attr = {.name = __stringify(_name), \ 128 .mode = VERIFY_OCTAL_PERMISSIONS(S_IWUSR | S_IRUGO) }, \ 129 .tag = (_tag), \ 130 } 131 132 #define XFS_ERRORTAG_ATTR_LIST(_name) &xfs_errortag_attr_##_name.attr 133 134 XFS_ERRORTAG_ATTR_RW(noerror, XFS_ERRTAG_NOERROR); 135 XFS_ERRORTAG_ATTR_RW(iflush1, XFS_ERRTAG_IFLUSH_1); 136 XFS_ERRORTAG_ATTR_RW(iflush2, XFS_ERRTAG_IFLUSH_2); 137 XFS_ERRORTAG_ATTR_RW(iflush3, XFS_ERRTAG_IFLUSH_3); 138 XFS_ERRORTAG_ATTR_RW(iflush4, XFS_ERRTAG_IFLUSH_4); 139 XFS_ERRORTAG_ATTR_RW(iflush5, XFS_ERRTAG_IFLUSH_5); 140 XFS_ERRORTAG_ATTR_RW(iflush6, XFS_ERRTAG_IFLUSH_6); 141 XFS_ERRORTAG_ATTR_RW(dareadbuf, XFS_ERRTAG_DA_READ_BUF); 142 XFS_ERRORTAG_ATTR_RW(btree_chk_lblk, XFS_ERRTAG_BTREE_CHECK_LBLOCK); 143 XFS_ERRORTAG_ATTR_RW(btree_chk_sblk, XFS_ERRTAG_BTREE_CHECK_SBLOCK); 144 XFS_ERRORTAG_ATTR_RW(readagf, XFS_ERRTAG_ALLOC_READ_AGF); 145 XFS_ERRORTAG_ATTR_RW(readagi, XFS_ERRTAG_IALLOC_READ_AGI); 146 XFS_ERRORTAG_ATTR_RW(itobp, XFS_ERRTAG_ITOBP_INOTOBP); 147 XFS_ERRORTAG_ATTR_RW(iunlink, XFS_ERRTAG_IUNLINK); 148 XFS_ERRORTAG_ATTR_RW(iunlinkrm, XFS_ERRTAG_IUNLINK_REMOVE); 149 XFS_ERRORTAG_ATTR_RW(dirinovalid, XFS_ERRTAG_DIR_INO_VALIDATE); 150 XFS_ERRORTAG_ATTR_RW(bulkstat, XFS_ERRTAG_BULKSTAT_READ_CHUNK); 151 XFS_ERRORTAG_ATTR_RW(logiodone, XFS_ERRTAG_IODONE_IOERR); 152 XFS_ERRORTAG_ATTR_RW(stratread, XFS_ERRTAG_STRATREAD_IOERR); 153 XFS_ERRORTAG_ATTR_RW(stratcmpl, XFS_ERRTAG_STRATCMPL_IOERR); 154 XFS_ERRORTAG_ATTR_RW(diowrite, XFS_ERRTAG_DIOWRITE_IOERR); 155 XFS_ERRORTAG_ATTR_RW(bmapifmt, XFS_ERRTAG_BMAPIFORMAT); 156 XFS_ERRORTAG_ATTR_RW(free_extent, XFS_ERRTAG_FREE_EXTENT); 157 XFS_ERRORTAG_ATTR_RW(rmap_finish_one, XFS_ERRTAG_RMAP_FINISH_ONE); 158 XFS_ERRORTAG_ATTR_RW(refcount_continue_update, XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE); 159 XFS_ERRORTAG_ATTR_RW(refcount_finish_one, XFS_ERRTAG_REFCOUNT_FINISH_ONE); 160 XFS_ERRORTAG_ATTR_RW(bmap_finish_one, XFS_ERRTAG_BMAP_FINISH_ONE); 161 XFS_ERRORTAG_ATTR_RW(ag_resv_critical, XFS_ERRTAG_AG_RESV_CRITICAL); 162 XFS_ERRORTAG_ATTR_RW(drop_writes, XFS_ERRTAG_DROP_WRITES); 163 XFS_ERRORTAG_ATTR_RW(log_bad_crc, XFS_ERRTAG_LOG_BAD_CRC); 164 165 static struct attribute *xfs_errortag_attrs[] = { 166 XFS_ERRORTAG_ATTR_LIST(noerror), 167 XFS_ERRORTAG_ATTR_LIST(iflush1), 168 XFS_ERRORTAG_ATTR_LIST(iflush2), 169 XFS_ERRORTAG_ATTR_LIST(iflush3), 170 XFS_ERRORTAG_ATTR_LIST(iflush4), 171 XFS_ERRORTAG_ATTR_LIST(iflush5), 172 XFS_ERRORTAG_ATTR_LIST(iflush6), 173 XFS_ERRORTAG_ATTR_LIST(dareadbuf), 174 XFS_ERRORTAG_ATTR_LIST(btree_chk_lblk), 175 XFS_ERRORTAG_ATTR_LIST(btree_chk_sblk), 176 XFS_ERRORTAG_ATTR_LIST(readagf), 177 XFS_ERRORTAG_ATTR_LIST(readagi), 178 XFS_ERRORTAG_ATTR_LIST(itobp), 179 XFS_ERRORTAG_ATTR_LIST(iunlink), 180 XFS_ERRORTAG_ATTR_LIST(iunlinkrm), 181 XFS_ERRORTAG_ATTR_LIST(dirinovalid), 182 XFS_ERRORTAG_ATTR_LIST(bulkstat), 183 XFS_ERRORTAG_ATTR_LIST(logiodone), 184 XFS_ERRORTAG_ATTR_LIST(stratread), 185 XFS_ERRORTAG_ATTR_LIST(stratcmpl), 186 XFS_ERRORTAG_ATTR_LIST(diowrite), 187 XFS_ERRORTAG_ATTR_LIST(bmapifmt), 188 XFS_ERRORTAG_ATTR_LIST(free_extent), 189 XFS_ERRORTAG_ATTR_LIST(rmap_finish_one), 190 XFS_ERRORTAG_ATTR_LIST(refcount_continue_update), 191 XFS_ERRORTAG_ATTR_LIST(refcount_finish_one), 192 XFS_ERRORTAG_ATTR_LIST(bmap_finish_one), 193 XFS_ERRORTAG_ATTR_LIST(ag_resv_critical), 194 XFS_ERRORTAG_ATTR_LIST(drop_writes), 195 XFS_ERRORTAG_ATTR_LIST(log_bad_crc), 196 NULL, 197 }; 198 199 struct kobj_type xfs_errortag_ktype = { 200 .release = xfs_sysfs_release, 201 .sysfs_ops = &xfs_errortag_sysfs_ops, 202 .default_attrs = xfs_errortag_attrs, 203 }; 204 205 int 206 xfs_errortag_init( 207 struct xfs_mount *mp) 208 { 209 mp->m_errortag = kmem_zalloc(sizeof(unsigned int) * XFS_ERRTAG_MAX, 210 KM_SLEEP | KM_MAYFAIL); 211 if (!mp->m_errortag) 212 return -ENOMEM; 213 214 return xfs_sysfs_init(&mp->m_errortag_kobj, &xfs_errortag_ktype, 215 &mp->m_kobj, "errortag"); 216 } 217 218 void 219 xfs_errortag_del( 220 struct xfs_mount *mp) 221 { 222 xfs_sysfs_del(&mp->m_errortag_kobj); 223 kmem_free(mp->m_errortag); 224 } 225 226 bool 227 xfs_errortag_test( 228 struct xfs_mount *mp, 229 const char *expression, 230 const char *file, 231 int line, 232 unsigned int error_tag) 233 { 234 unsigned int randfactor; 235 236 /* 237 * To be able to use error injection anywhere, we need to ensure error 238 * injection mechanism is already initialized. 239 * 240 * Code paths like I/O completion can be called before the 241 * initialization is complete, but be able to inject errors in such 242 * places is still useful. 243 */ 244 if (!mp->m_errortag) 245 return false; 246 247 ASSERT(error_tag < XFS_ERRTAG_MAX); 248 randfactor = mp->m_errortag[error_tag]; 249 if (!randfactor || prandom_u32() % randfactor) 250 return false; 251 252 xfs_warn_ratelimited(mp, 253 "Injecting error (%s) at file %s, line %d, on filesystem \"%s\"", 254 expression, file, line, mp->m_fsname); 255 return true; 256 } 257 258 int 259 xfs_errortag_get( 260 struct xfs_mount *mp, 261 unsigned int error_tag) 262 { 263 if (error_tag >= XFS_ERRTAG_MAX) 264 return -EINVAL; 265 266 return mp->m_errortag[error_tag]; 267 } 268 269 int 270 xfs_errortag_set( 271 struct xfs_mount *mp, 272 unsigned int error_tag, 273 unsigned int tag_value) 274 { 275 if (error_tag >= XFS_ERRTAG_MAX) 276 return -EINVAL; 277 278 mp->m_errortag[error_tag] = tag_value; 279 return 0; 280 } 281 282 int 283 xfs_errortag_add( 284 struct xfs_mount *mp, 285 unsigned int error_tag) 286 { 287 if (error_tag >= XFS_ERRTAG_MAX) 288 return -EINVAL; 289 290 return xfs_errortag_set(mp, error_tag, 291 xfs_errortag_random_default[error_tag]); 292 } 293 294 int 295 xfs_errortag_clearall( 296 struct xfs_mount *mp) 297 { 298 memset(mp->m_errortag, 0, sizeof(unsigned int) * XFS_ERRTAG_MAX); 299 return 0; 300 } 301 #endif /* DEBUG */ 302 303 void 304 xfs_error_report( 305 const char *tag, 306 int level, 307 struct xfs_mount *mp, 308 const char *filename, 309 int linenum, 310 void *ra) 311 { 312 if (level <= xfs_error_level) { 313 xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT, 314 "Internal error %s at line %d of file %s. Caller %pS", 315 tag, linenum, filename, ra); 316 317 xfs_stack_trace(); 318 } 319 } 320 321 void 322 xfs_corruption_error( 323 const char *tag, 324 int level, 325 struct xfs_mount *mp, 326 void *p, 327 const char *filename, 328 int linenum, 329 void *ra) 330 { 331 if (level <= xfs_error_level) 332 xfs_hex_dump(p, 64); 333 xfs_error_report(tag, level, mp, filename, linenum, ra); 334 xfs_alert(mp, "Corruption detected. Unmount and run xfs_repair"); 335 } 336 337 /* 338 * Warnings specifically for verifier errors. Differentiate CRC vs. invalid 339 * values, and omit the stack trace unless the error level is tuned high. 340 */ 341 void 342 xfs_verifier_error( 343 struct xfs_buf *bp) 344 { 345 struct xfs_mount *mp = bp->b_target->bt_mount; 346 347 xfs_alert(mp, "Metadata %s detected at %pF, %s block 0x%llx", 348 bp->b_error == -EFSBADCRC ? "CRC error" : "corruption", 349 __return_address, bp->b_ops->name, bp->b_bn); 350 351 xfs_alert(mp, "Unmount and run xfs_repair"); 352 353 if (xfs_error_level >= XFS_ERRLEVEL_LOW) { 354 xfs_alert(mp, "First 64 bytes of corrupted metadata buffer:"); 355 xfs_hex_dump(xfs_buf_offset(bp, 0), 64); 356 } 357 358 if (xfs_error_level >= XFS_ERRLEVEL_HIGH) 359 xfs_stack_trace(); 360 } 361