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-common.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_err(err);
  37         abort();
  38     }
  39     if (errp == &error_fatal) {
  40         error_report_err(err);
  41         exit(1);
  42     }
  43 }
  44
  45 static GCC_FMT_ATTR(6, 0)
  46 void error_setv(Error **errp,
  47                 const char *src, int line, const char *func,
  48                 ErrorClass err_class, const char *fmt, va_list ap)
  49 {
  50     Error *err;
  51     int saved_errno = errno;
  52
  53     if (errp == NULL) {
  54         return;
  55     }
  56     assert(*errp == NULL);
  57
  58     err = g_malloc0(sizeof(*err));
  59     err->msg = g_strdup_vprintf(fmt, ap);
  60     err->err_class = err_class;
  61     err->src = src;
  62     err->line = line;
  63     err->func = func;
  64
  65     error_handle_fatal(errp, err);
  66     *errp = err;
  67
  68     errno = saved_errno;
  69 }
  70
  71 void error_set_internal(Error **errp,
  72                         const char *src, int line, const char *func,
  73                         ErrorClass err_class, const char *fmt, ...)
  74 {
  75     va_list ap;
  76
  77     va_start(ap, fmt);
  78     error_setv(errp, src, line, func, err_class, fmt, ap);
  79     va_end(ap);
  80 }
  81
  82 void error_setg_internal(Error **errp,
  83                          const char *src, int line, const char *func,
  84                          const char *fmt, ...)
  85 {
  86     va_list ap;
  87
  88     va_start(ap, fmt);
  89     error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR, fmt, ap);
  90     va_end(ap);
  91 }
  92
  93 void error_setg_errno_internal(Error **errp,
  94                                const char *src, int line, const char *func,
  95                                int os_errno, const char *fmt, ...)
  96 {
  97     va_list ap;
  98     char *msg;
  99     int saved_errno = errno;
 100
 101     if (errp == NULL) {
 102         return;
 103     }
 104
 105     va_start(ap, fmt);
 106     error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR, fmt, ap);
 107     va_end(ap);
 108
 109     if (os_errno != 0) {
 110         msg = (*errp)->msg;
 111         (*errp)->msg = g_strdup_printf("%s: %s", msg, strerror(os_errno));
 112         g_free(msg);
 113     }
 114
 115     errno = saved_errno;
 116 }
 117
 118 void error_setg_file_open_internal(Error **errp,
 119                                    const char *src, int line, const char *func,
 120                                    int os_errno, const char *filename)
 121 {
 122     error_setg_errno_internal(errp, src, line, func, os_errno,
 123                               "Could not open '%s'", filename);
 124 }
 125
 126 void error_append_hint(Error **errp, const char *fmt, ...)
 127 {
 128     va_list ap;
 129     int saved_errno = errno;
 130     Error *err;
 131
 132     if (!errp) {
 133         return;
 134     }
 135     err = *errp;
 136     assert(err && errp != &error_abort);
 137
 138     if (!err->hint) {
 139         err->hint = g_string_new(NULL);
 140     }
 141     va_start(ap, fmt);
 142     g_string_append_vprintf(err->hint, fmt, ap);
 143     va_end(ap);
 144
 145     errno = saved_errno;
 146 }
 147
 148 #ifdef _WIN32
 149
 150 void error_setg_win32_internal(Error **errp,
 151                                const char *src, int line, const char *func,
 152                                int win32_err, const char *fmt, ...)
 153 {
 154     va_list ap;
 155     char *msg1, *msg2;
 156
 157     if (errp == NULL) {
 158         return;
 159     }
 160
 161     va_start(ap, fmt);
 162     error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR, fmt, ap);
 163     va_end(ap);
 164
 165     if (win32_err != 0) {
 166         msg1 = (*errp)->msg;
 167         msg2 = g_win32_error_message(win32_err);
 168         (*errp)->msg = g_strdup_printf("%s: %s (error: %x)", msg1, msg2,
 169                                        (unsigned)win32_err);
 170         g_free(msg2);
 171         g_free(msg1);
 172     }
 173 }
 174
 175 #endif
 176
 177 Error *error_copy(const Error *err)
 178 {
 179     Error *err_new;
 180
 181     err_new = g_malloc0(sizeof(*err));
 182     err_new->msg = g_strdup(err->msg);
 183     err_new->err_class = err->err_class;
 184     err_new->src = err->src;
 185     err_new->line = err->line;
 186     err_new->func = err->func;
 187     if (err->hint) {
 188         err_new->hint = g_string_new(err->hint->str);
 189     }
 190
 191     return err_new;
 192 }
 193
 194 ErrorClass error_get_class(const Error *err)
 195 {
 196     return err->err_class;
 197 }
 198
 199 const char *error_get_pretty(Error *err)
 200 {
 201     return err->msg;
 202 }
 203
 204 void error_report_err(Error *err)
 205 {
 206     error_report("%s", error_get_pretty(err));
 207     if (err->hint) {
 208         error_printf_unless_qmp("%s\n", err->hint->str);
 209     }
 210     error_free(err);
 211 }
 212
 213 void error_free(Error *err)
 214 {
 215     if (err) {
 216         g_free(err->msg);
 217         if (err->hint) {
 218             g_string_free(err->hint, true);
 219         }
 220         g_free(err);
 221     }
 222 }
 223
 224 void error_free_or_abort(Error **errp)
 225 {
 226     assert(errp && *errp);
 227     error_free(*errp);
 228     *errp = NULL;
 229 }
 230
 231 void error_propagate(Error **dst_errp, Error *local_err)
 232 {
 233     if (!local_err) {
 234         return;
 235     }
 236     error_handle_fatal(dst_errp, local_err);
 237     if (dst_errp && !*dst_errp) {
 238         *dst_errp = local_err;
 239     } else {
 240         error_free(local_err);
 241     }
 242 }