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