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