util/error.c

   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 }