xref: /openbmc/linux/fs/xfs/xfs_error.c (revision 22246614)
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