[NETNS]: Fix /proc/net breakage
[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_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 STATIC void
234 xfs_hex_dump(void *p, int length)
235 {
236         __uint8_t *uip = (__uint8_t*)p;
237         int     i;
238         char    sbuf[128], *s;
239
240         s = sbuf;
241         *s = '\0';
242         for (i=0; i<length; i++, uip++) {
243                 if ((i % 16) == 0) {
244                         if (*s != '\0')
245                                 cmn_err(CE_ALERT, "%s\n", sbuf);
246                         s = sbuf;
247                         sprintf(s, "0x%x: ", i);
248                         while( *s != '\0')
249                                 s++;
250                 }
251                 sprintf(s, "%02x ", *uip);
252
253                 /*
254                  * the kernel sprintf is a void; user sprintf returns
255                  * the sprintf'ed string's length.  Find the new end-
256                  * of-string
257                  */
258                 while( *s != '\0')
259                         s++;
260         }
261         cmn_err(CE_ALERT, "%s\n", sbuf);
262 }
263
264 void
265 xfs_corruption_error(
266         char            *tag,
267         int             level,
268         xfs_mount_t     *mp,
269         void            *p,
270         char            *fname,
271         int             linenum,
272         inst_t          *ra)
273 {
274         if (level <= xfs_error_level)
275                 xfs_hex_dump(p, 16);
276         xfs_error_report(tag, level, mp, fname, linenum, ra);
277 }