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_ag.h" 26 #include "xfs_dir2.h" 27 #include "xfs_dmapi.h" 28 #include "xfs_mount.h" 29 #include "xfs_bmap_btree.h" 30 #include "xfs_dir2_sf.h" 31 #include "xfs_attr_sf.h" 32 #include "xfs_dinode.h" 33 #include "xfs_inode.h" 34 #include "xfs_utils.h" 35 #include "xfs_error.h" 36 37 #ifdef DEBUG 38 39 int xfs_etrap[XFS_ERROR_NTRAP] = { 40 0, 41 }; 42 43 int 44 xfs_error_trap(int e) 45 { 46 int i; 47 48 if (!e) 49 return 0; 50 for (i = 0; i < XFS_ERROR_NTRAP; i++) { 51 if (xfs_etrap[i] == 0) 52 break; 53 if (e != xfs_etrap[i]) 54 continue; 55 cmn_err(CE_NOTE, "xfs_error_trap: error %d", e); 56 BUG(); 57 break; 58 } 59 return e; 60 } 61 #endif 62 63 #if (defined(DEBUG) || defined(INDUCE_IO_ERROR)) 64 65 int xfs_etest[XFS_NUM_INJECT_ERROR]; 66 int64_t xfs_etest_fsid[XFS_NUM_INJECT_ERROR]; 67 char * xfs_etest_fsname[XFS_NUM_INJECT_ERROR]; 68 69 void 70 xfs_error_test_init(void) 71 { 72 memset(xfs_etest, 0, sizeof(xfs_etest)); 73 memset(xfs_etest_fsid, 0, sizeof(xfs_etest_fsid)); 74 memset(xfs_etest_fsname, 0, sizeof(xfs_etest_fsname)); 75 } 76 77 int 78 xfs_error_test(int error_tag, int *fsidp, char *expression, 79 int line, char *file, unsigned long randfactor) 80 { 81 int i; 82 int64_t fsid; 83 84 if (random32() % randfactor) 85 return 0; 86 87 memcpy(&fsid, fsidp, sizeof(xfs_fsid_t)); 88 89 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 90 if (xfs_etest[i] == error_tag && xfs_etest_fsid[i] == fsid) { 91 cmn_err(CE_WARN, 92 "Injecting error (%s) at file %s, line %d, on filesystem \"%s\"", 93 expression, file, line, xfs_etest_fsname[i]); 94 return 1; 95 } 96 } 97 98 return 0; 99 } 100 101 int 102 xfs_errortag_add(int error_tag, xfs_mount_t *mp) 103 { 104 int i; 105 int len; 106 int64_t fsid; 107 108 memcpy(&fsid, mp->m_fixedfsid, sizeof(xfs_fsid_t)); 109 110 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 111 if (xfs_etest_fsid[i] == fsid && xfs_etest[i] == error_tag) { 112 cmn_err(CE_WARN, "XFS error tag #%d on", error_tag); 113 return 0; 114 } 115 } 116 117 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 118 if (xfs_etest[i] == 0) { 119 cmn_err(CE_WARN, "Turned on XFS error tag #%d", 120 error_tag); 121 xfs_etest[i] = error_tag; 122 xfs_etest_fsid[i] = fsid; 123 len = strlen(mp->m_fsname); 124 xfs_etest_fsname[i] = kmem_alloc(len + 1, KM_SLEEP); 125 strcpy(xfs_etest_fsname[i], mp->m_fsname); 126 return 0; 127 } 128 } 129 130 cmn_err(CE_WARN, "error tag overflow, too many turned on"); 131 132 return 1; 133 } 134 135 int 136 xfs_errortag_clearall(xfs_mount_t *mp, int loud) 137 { 138 int64_t fsid; 139 int cleared = 0; 140 int i; 141 142 memcpy(&fsid, mp->m_fixedfsid, sizeof(xfs_fsid_t)); 143 144 145 for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) { 146 if ((fsid == 0LL || xfs_etest_fsid[i] == fsid) && 147 xfs_etest[i] != 0) { 148 cleared = 1; 149 cmn_err(CE_WARN, "Clearing XFS error tag #%d", 150 xfs_etest[i]); 151 xfs_etest[i] = 0; 152 xfs_etest_fsid[i] = 0LL; 153 kmem_free(xfs_etest_fsname[i], 154 strlen(xfs_etest_fsname[i]) + 1); 155 xfs_etest_fsname[i] = NULL; 156 } 157 } 158 159 if (loud || cleared) 160 cmn_err(CE_WARN, 161 "Cleared all XFS error tags for filesystem \"%s\"", 162 mp->m_fsname); 163 164 return 0; 165 } 166 #endif /* DEBUG || INDUCE_IO_ERROR */ 167 168 static void 169 xfs_fs_vcmn_err(int level, xfs_mount_t *mp, char *fmt, va_list ap) 170 { 171 if (mp != NULL) { 172 char *newfmt; 173 int len = 16 + mp->m_fsname_len + strlen(fmt); 174 175 newfmt = kmem_alloc(len, KM_SLEEP); 176 sprintf(newfmt, "Filesystem \"%s\": %s", mp->m_fsname, fmt); 177 icmn_err(level, newfmt, ap); 178 kmem_free(newfmt, len); 179 } else { 180 icmn_err(level, fmt, ap); 181 } 182 } 183 184 void 185 xfs_fs_cmn_err(int level, xfs_mount_t *mp, char *fmt, ...) 186 { 187 va_list ap; 188 189 va_start(ap, fmt); 190 xfs_fs_vcmn_err(level, mp, fmt, ap); 191 va_end(ap); 192 } 193 194 void 195 xfs_cmn_err(int panic_tag, int level, xfs_mount_t *mp, char *fmt, ...) 196 { 197 va_list ap; 198 199 #ifdef DEBUG 200 xfs_panic_mask |= XFS_PTAG_SHUTDOWN_CORRUPT; 201 #endif 202 203 if (xfs_panic_mask && (xfs_panic_mask & panic_tag) 204 && (level & CE_ALERT)) { 205 level &= ~CE_ALERT; 206 level |= CE_PANIC; 207 cmn_err(CE_ALERT, "XFS: Transforming an alert into a BUG."); 208 } 209 va_start(ap, fmt); 210 xfs_fs_vcmn_err(level, mp, fmt, ap); 211 va_end(ap); 212 } 213 214 void 215 xfs_error_report( 216 char *tag, 217 int level, 218 xfs_mount_t *mp, 219 char *fname, 220 int linenum, 221 inst_t *ra) 222 { 223 if (level <= xfs_error_level) { 224 xfs_cmn_err(XFS_PTAG_ERROR_REPORT, 225 CE_ALERT, mp, 226 "XFS internal error %s at line %d of file %s. Caller 0x%p\n", 227 tag, linenum, fname, ra); 228 229 xfs_stack_trace(); 230 } 231 } 232 233 void 234 xfs_corruption_error( 235 char *tag, 236 int level, 237 xfs_mount_t *mp, 238 void *p, 239 char *fname, 240 int linenum, 241 inst_t *ra) 242 { 243 if (level <= xfs_error_level) 244 xfs_hex_dump(p, 16); 245 xfs_error_report(tag, level, mp, fname, linenum, ra); 246 } 247