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