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_fs.h" 20 #include "xfs_types.h" 21 #include "xfs_log.h" 22 #include "xfs_inum.h" 23 #include "xfs_trans.h" 24 #include "xfs_sb.h" 25 #include "xfs_dir2.h" 26 #include "xfs_dmapi.h" 27 #include "xfs_mount.h" 28 #include "xfs_bmap_btree.h" 29 #include "xfs_dir2_sf.h" 30 #include "xfs_attr_sf.h" 31 #include "xfs_dinode.h" 32 #include "xfs_inode.h" 33 #include "xfs_utils.h" 34 #include "xfs_error.h" 35 36 #ifdef DEBUG 37 38 int xfs_etrap[XFS_ERROR_NTRAP] = { 39 0, 40 }; 41 42 int 43 xfs_error_trap(int e) 44 { 45 int i; 46 47 if (!e) 48 return 0; 49 for (i = 0; i < XFS_ERROR_NTRAP; i++) { 50 if (xfs_etrap[i] == 0) 51 break; 52 if (e != xfs_etrap[i]) 53 continue; 54 cmn_err(CE_NOTE, "xfs_error_trap: error %d", e); 55 BUG(); 56 break; 57 } 58 return e; 59 } 60 #endif 61 62 #if (defined(DEBUG) || defined(INDUCE_IO_ERROR)) 63 64 int xfs_etest[XFS_NUM_INJECT_ERROR]; 65 int64_t xfs_etest_fsid[XFS_NUM_INJECT_ERROR]; 66 char * xfs_etest_fsname[XFS_NUM_INJECT_ERROR]; 67 68 void 69 xfs_error_test_init(void) 70 { 71 memset(xfs_etest, 0, sizeof(xfs_etest)); 72 memset(xfs_etest_fsid, 0, sizeof(xfs_etest_fsid)); 73 memset(xfs_etest_fsname, 0, sizeof(xfs_etest_fsname)); 74 } 75 76 int 77 xfs_error_test(int error_tag, int *fsidp, char *expression, 78 int line, char *file, unsigned long randfactor) 79 { 80 int i; 81 int64_t fsid; 82 83 if (random() % randfactor) 84 return 0; 85 86 memcpy(&fsid, fsidp, sizeof(xfs_fsid_t)); 87 88 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 89 if (xfs_etest[i] == error_tag && xfs_etest_fsid[i] == fsid) { 90 cmn_err(CE_WARN, 91 "Injecting error (%s) at file %s, line %d, on filesystem \"%s\"", 92 expression, file, line, xfs_etest_fsname[i]); 93 return 1; 94 } 95 } 96 97 return 0; 98 } 99 100 int 101 xfs_errortag_add(int error_tag, xfs_mount_t *mp) 102 { 103 int i; 104 int len; 105 int64_t fsid; 106 107 memcpy(&fsid, mp->m_fixedfsid, sizeof(xfs_fsid_t)); 108 109 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 110 if (xfs_etest_fsid[i] == fsid && xfs_etest[i] == error_tag) { 111 cmn_err(CE_WARN, "XFS error tag #%d on", error_tag); 112 return 0; 113 } 114 } 115 116 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 117 if (xfs_etest[i] == 0) { 118 cmn_err(CE_WARN, "Turned on XFS error tag #%d", 119 error_tag); 120 xfs_etest[i] = error_tag; 121 xfs_etest_fsid[i] = fsid; 122 len = strlen(mp->m_fsname); 123 xfs_etest_fsname[i] = kmem_alloc(len + 1, KM_SLEEP); 124 strcpy(xfs_etest_fsname[i], mp->m_fsname); 125 return 0; 126 } 127 } 128 129 cmn_err(CE_WARN, "error tag overflow, too many turned on"); 130 131 return 1; 132 } 133 134 int 135 xfs_errortag_clear(int error_tag, xfs_mount_t *mp) 136 { 137 int i; 138 int64_t fsid; 139 140 memcpy(&fsid, mp->m_fixedfsid, sizeof(xfs_fsid_t)); 141 142 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 143 if (xfs_etest_fsid[i] == fsid && xfs_etest[i] == error_tag) { 144 xfs_etest[i] = 0; 145 xfs_etest_fsid[i] = 0LL; 146 kmem_free(xfs_etest_fsname[i], 147 strlen(xfs_etest_fsname[i]) + 1); 148 xfs_etest_fsname[i] = NULL; 149 cmn_err(CE_WARN, "Cleared XFS error tag #%d", 150 error_tag); 151 return 0; 152 } 153 } 154 155 cmn_err(CE_WARN, "XFS error tag %d not on", error_tag); 156 157 return 1; 158 } 159 160 int 161 xfs_errortag_clearall_umount(int64_t fsid, char *fsname, int loud) 162 { 163 int i; 164 int cleared = 0; 165 166 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 167 if ((fsid == 0LL || xfs_etest_fsid[i] == fsid) && 168 xfs_etest[i] != 0) { 169 cleared = 1; 170 cmn_err(CE_WARN, "Clearing XFS error tag #%d", 171 xfs_etest[i]); 172 xfs_etest[i] = 0; 173 xfs_etest_fsid[i] = 0LL; 174 kmem_free(xfs_etest_fsname[i], 175 strlen(xfs_etest_fsname[i]) + 1); 176 xfs_etest_fsname[i] = NULL; 177 } 178 } 179 180 if (loud || cleared) 181 cmn_err(CE_WARN, 182 "Cleared all XFS error tags for filesystem \"%s\"", 183 fsname); 184 185 return 0; 186 } 187 188 int 189 xfs_errortag_clearall(xfs_mount_t *mp) 190 { 191 int64_t fsid; 192 193 memcpy(&fsid, mp->m_fixedfsid, sizeof(xfs_fsid_t)); 194 195 return xfs_errortag_clearall_umount(fsid, mp->m_fsname, 1); 196 } 197 #endif /* DEBUG || INDUCE_IO_ERROR */ 198 199 static void 200 xfs_fs_vcmn_err(int level, xfs_mount_t *mp, char *fmt, va_list ap) 201 { 202 if (mp != NULL) { 203 char *newfmt; 204 int len = 16 + mp->m_fsname_len + strlen(fmt); 205 206 newfmt = kmem_alloc(len, KM_SLEEP); 207 sprintf(newfmt, "Filesystem \"%s\": %s", mp->m_fsname, fmt); 208 icmn_err(level, newfmt, ap); 209 kmem_free(newfmt, len); 210 } else { 211 icmn_err(level, fmt, ap); 212 } 213 } 214 215 void 216 xfs_fs_cmn_err(int level, xfs_mount_t *mp, char *fmt, ...) 217 { 218 va_list ap; 219 220 va_start(ap, fmt); 221 xfs_fs_vcmn_err(level, mp, fmt, ap); 222 va_end(ap); 223 } 224 225 void 226 xfs_cmn_err(int panic_tag, int level, xfs_mount_t *mp, char *fmt, ...) 227 { 228 va_list ap; 229 230 #ifdef DEBUG 231 xfs_panic_mask |= XFS_PTAG_SHUTDOWN_CORRUPT; 232 #endif 233 234 if (xfs_panic_mask && (xfs_panic_mask & panic_tag) 235 && (level & CE_ALERT)) { 236 level &= ~CE_ALERT; 237 level |= CE_PANIC; 238 cmn_err(CE_ALERT, "XFS: Transforming an alert into a BUG."); 239 } 240 va_start(ap, fmt); 241 xfs_fs_vcmn_err(level, mp, fmt, ap); 242 va_end(ap); 243 } 244 245 void 246 xfs_error_report( 247 char *tag, 248 int level, 249 xfs_mount_t *mp, 250 char *fname, 251 int linenum, 252 inst_t *ra) 253 { 254 if (level <= xfs_error_level) { 255 xfs_cmn_err(XFS_PTAG_ERROR_REPORT, 256 CE_ALERT, mp, 257 "XFS internal error %s at line %d of file %s. Caller 0x%p\n", 258 tag, linenum, fname, ra); 259 260 xfs_stack_trace(); 261 } 262 } 263 264 STATIC void 265 xfs_hex_dump(void *p, int length) 266 { 267 __uint8_t *uip = (__uint8_t*)p; 268 int i; 269 char sbuf[128], *s; 270 271 s = sbuf; 272 *s = '\0'; 273 for (i=0; i<length; i++, uip++) { 274 if ((i % 16) == 0) { 275 if (*s != '\0') 276 cmn_err(CE_ALERT, "%s\n", sbuf); 277 s = sbuf; 278 sprintf(s, "0x%x: ", i); 279 while( *s != '\0') 280 s++; 281 } 282 sprintf(s, "%02x ", *uip); 283 284 /* 285 * the kernel sprintf is a void; user sprintf returns 286 * the sprintf'ed string's length. Find the new end- 287 * of-string 288 */ 289 while( *s != '\0') 290 s++; 291 } 292 cmn_err(CE_ALERT, "%s\n", sbuf); 293 } 294 295 void 296 xfs_corruption_error( 297 char *tag, 298 int level, 299 xfs_mount_t *mp, 300 void *p, 301 char *fname, 302 int linenum, 303 inst_t *ra) 304 { 305 if (level <= xfs_error_level) 306 xfs_hex_dump(p, 16); 307 xfs_error_report(tag, level, mp, fname, linenum, ra); 308 } 309