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