blob: d7b6b5d16704f29c547ca7152c5c715e823c3d08 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_trans.h"
Nathan Scotta844f452005-11-02 14:38:42 +110024#include "xfs_sb.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "xfs_dir_sf.h"
31#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110032#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_dinode.h"
34#include "xfs_inode.h"
35#include "xfs_utils.h"
36#include "xfs_error.h"
37
38#ifdef DEBUG
39
40int xfs_etrap[XFS_ERROR_NTRAP] = {
41 0,
42};
43
44int
45xfs_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
67int xfs_etest[XFS_NUM_INJECT_ERROR];
68int64_t xfs_etest_fsid[XFS_NUM_INJECT_ERROR];
69char * xfs_etest_fsname[XFS_NUM_INJECT_ERROR];
70
71void
72xfs_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
79int
80xfs_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
103int
104xfs_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
137int
138xfs_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
163int
164xfs_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
191int
192xfs_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
202static void
203xfs_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
218void
219xfs_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
228void
229xfs_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
248void
249xfs_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
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000267STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268xfs_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
298void
299xfs_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}