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