xref: /openbmc/qemu/util/error.c (revision 1141159c) 
1 /*
2  * QEMU Error Objects
3  *
4  * Copyright IBM, Corp. 2011
5  * Copyright (C) 2011-2015 Red Hat, Inc.
6  *
7  * Authors:
8  *  Anthony Liguori   <aliguori@us.ibm.com>
9  *  Markus Armbruster <armbru@redhat.com>,
10  *
11  * This work is licensed under the terms of the GNU LGPL, version 2.  See
12  * the COPYING.LIB file in the top-level directory.
13  */
14 
15 #include "qemu/osdep.h"
16 #include "qapi/error.h"
17 #include "qemu/error-report.h"
18 
19 struct Error
20 {
21     char *msg;
22     ErrorClass err_class;
23     const char *src, *func;
24     int line;
25     GString *hint;
26 };
27 
28 Error *error_abort;
29 Error *error_fatal;
30 Error *error_warn;
31 
32 static void error_handle(Error **errp, Error *err)
33 {
34     if (errp == &error_abort) {
35         fprintf(stderr, "Unexpected error in %s() at %s:%d:\n",
36                 err->func, err->src, err->line);
37         error_report("%s", error_get_pretty(err));
38         if (err->hint) {
39             error_printf("%s", err->hint->str);
40         }
41         abort();
42     }
43     if (errp == &error_fatal) {
44         error_report_err(err);
45         exit(1);
46     }
47     if (errp == &error_warn) {
48         warn_report_err(err);
49     } else if (errp && !*errp) {
50         *errp = err;
51     } else {
52         error_free(err);
53     }
54 }
55 
56 G_GNUC_PRINTF(6, 0)
57 static void error_setv(Error **errp,
58                        const char *src, int line, const char *func,
59                        ErrorClass err_class, const char *fmt, va_list ap,
60                        const char *suffix)
61 {
62     Error *err;
63     int saved_errno = errno;
64 
65     if (errp == NULL) {
66         return;
67     }
68     assert(*errp == NULL);
69 
70     err = g_malloc0(sizeof(*err));
71     err->msg = g_strdup_vprintf(fmt, ap);
72     if (suffix) {
73         char *msg = err->msg;
74         err->msg = g_strdup_printf("%s: %s", msg, suffix);
75         g_free(msg);
76     }
77     err->err_class = err_class;
78     err->src = src;
79     err->line = line;
80     err->func = func;
81 
82     error_handle(errp, err);
83 
84     errno = saved_errno;
85 }
86 
87 void error_set_internal(Error **errp,
88                         const char *src, int line, const char *func,
89                         ErrorClass err_class, const char *fmt, ...)
90 {
91     va_list ap;
92 
93     va_start(ap, fmt);
94     error_setv(errp, src, line, func, err_class, fmt, ap, NULL);
95     va_end(ap);
96 }
97 
98 void error_setg_internal(Error **errp,
99                          const char *src, int line, const char *func,
100                          const char *fmt, ...)
101 {
102     va_list ap;
103 
104     va_start(ap, fmt);
105     error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR, fmt, ap, NULL);
106     va_end(ap);
107 }
108 
109 void error_setg_errno_internal(Error **errp,
110                                const char *src, int line, const char *func,
111                                int os_errno, const char *fmt, ...)
112 {
113     va_list ap;
114     int saved_errno = errno;
115 
116     va_start(ap, fmt);
117     error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR, fmt, ap,
118                os_errno != 0 ? strerror(os_errno) : NULL);
119     va_end(ap);
120 
121     errno = saved_errno;
122 }
123 
124 void error_setg_file_open_internal(Error **errp,
125                                    const char *src, int line, const char *func,
126                                    int os_errno, const char *filename)
127 {
128     error_setg_errno_internal(errp, src, line, func, os_errno,
129                               "Could not open '%s'", filename);
130 }
131 
132 void error_vprepend(Error *const *errp, const char *fmt, va_list ap)
133 {
134     GString *newmsg;
135 
136     if (!errp) {
137         return;
138     }
139 
140     newmsg = g_string_new(NULL);
141     g_string_vprintf(newmsg, fmt, ap);
142     g_string_append(newmsg, (*errp)->msg);
143     g_free((*errp)->msg);
144     (*errp)->msg = g_string_free(newmsg, 0);
145 }
146 
147 void error_prepend(Error *const *errp, const char *fmt, ...)
148 {
149     va_list ap;
150 
151     va_start(ap, fmt);
152     error_vprepend(errp, fmt, ap);
153     va_end(ap);
154 }
155 
156 void error_append_hint(Error *const *errp, const char *fmt, ...)
157 {
158     va_list ap;
159     int saved_errno = errno;
160     Error *err;
161 
162     if (!errp) {
163         return;
164     }
165     err = *errp;
166     assert(err && errp != &error_abort && errp != &error_fatal);
167 
168     if (!err->hint) {
169         err->hint = g_string_new(NULL);
170     }
171     va_start(ap, fmt);
172     g_string_append_vprintf(err->hint, fmt, ap);
173     va_end(ap);
174 
175     errno = saved_errno;
176 }
177 
178 #ifdef _WIN32
179 
180 void error_setg_win32_internal(Error **errp,
181                                const char *src, int line, const char *func,
182                                int win32_err, const char *fmt, ...)
183 {
184     va_list ap;
185     char *suffix = NULL;
186 
187     if (errp == NULL) {
188         return;
189     }
190 
191     if (win32_err != 0) {
192         suffix = g_win32_error_message(win32_err);
193     }
194 
195     va_start(ap, fmt);
196     error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR,
197                fmt, ap, suffix);
198     va_end(ap);
199 
200     g_free(suffix);
201 }
202 
203 #endif
204 
205 Error *error_copy(const Error *err)
206 {
207     Error *err_new;
208 
209     err_new = g_malloc0(sizeof(*err));
210     err_new->msg = g_strdup(err->msg);
211     err_new->err_class = err->err_class;
212     err_new->src = err->src;
213     err_new->line = err->line;
214     err_new->func = err->func;
215     if (err->hint) {
216         err_new->hint = g_string_new(err->hint->str);
217     }
218 
219     return err_new;
220 }
221 
222 ErrorClass error_get_class(const Error *err)
223 {
224     return err->err_class;
225 }
226 
227 const char *error_get_pretty(const Error *err)
228 {
229     return err->msg;
230 }
231 
232 void error_report_err(Error *err)
233 {
234     error_report("%s", error_get_pretty(err));
235     if (err->hint) {
236         error_printf("%s", err->hint->str);
237     }
238     error_free(err);
239 }
240 
241 void warn_report_err(Error *err)
242 {
243     warn_report("%s", error_get_pretty(err));
244     if (err->hint) {
245         error_printf("%s", err->hint->str);
246     }
247     error_free(err);
248 }
249 
250 void error_reportf_err(Error *err, const char *fmt, ...)
251 {
252     va_list ap;
253 
254     va_start(ap, fmt);
255     error_vprepend(&err, fmt, ap);
256     va_end(ap);
257     error_report_err(err);
258 }
259 
260 
261 void warn_reportf_err(Error *err, const char *fmt, ...)
262 {
263     va_list ap;
264 
265     va_start(ap, fmt);
266     error_vprepend(&err, fmt, ap);
267     va_end(ap);
268     warn_report_err(err);
269 }
270 
271 void error_free(Error *err)
272 {
273     if (err) {
274         g_free(err->msg);
275         if (err->hint) {
276             g_string_free(err->hint, true);
277         }
278         g_free(err);
279     }
280 }
281 
282 void error_free_or_abort(Error **errp)
283 {
284     assert(errp && *errp);
285     error_free(*errp);
286     *errp = NULL;
287 }
288 
289 void error_propagate(Error **dst_errp, Error *local_err)
290 {
291     if (!local_err) {
292         return;
293     }
294     error_handle(dst_errp, local_err);
295 }
296 
297 void error_propagate_prepend(Error **dst_errp, Error *err,
298                              const char *fmt, ...)
299 {
300     va_list ap;
301 
302     if (dst_errp && !*dst_errp) {
303         va_start(ap, fmt);
304         error_vprepend(&err, fmt, ap);
305         va_end(ap);
306     } /* else error is being ignored, don't bother with prepending */
307     error_propagate(dst_errp, err);
308 }
309