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