include/qapi/error.h

   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 /*
  16  * Error reporting system loosely patterned after Glib's GError.
  17  *
  18  * Create an error:
  19  *     error_setg(&err, "situation normal, all fouled up");
  20  *
  21  * Create an error and add additional explanation:
  22  *     error_setg(&err, "invalid quark");
  23  *     error_append_hint(&err, "Valid quarks are up, down, strange, "
  24  *                       "charm, top, bottom.\n");
  25  *
  26  * Do *not* contract this to
  27  *     error_setg(&err, "invalid quark\n"
  28  *                "Valid quarks are up, down, strange, charm, top, bottom.");
  29  *
  30  * Report an error to the current monitor if we have one, else stderr:
  31  *     error_report_err(err);
  32  * This frees the error object.
  33  *
  34  * Likewise, but with additional text prepended:
  35  *     error_reportf_err(err, "Could not frobnicate '%s': ", name);
  36  *
  37  * Report an error somewhere else:
  38  *     const char *msg = error_get_pretty(err);
  39  *     do with msg what needs to be done...
  40  *     error_free(err);
  41  * Note that this loses hints added with error_append_hint().
  42  *
  43  * Handle an error without reporting it (just for completeness):
  44  *     error_free(err);
  45  *
  46  * Assert that an expected error occurred, but clean it up without
  47  * reporting it (primarily useful in testsuites):
  48  *     error_free_or_abort(&err);
  49  *
  50  * Pass an existing error to the caller:
  51  *     error_propagate(errp, err);
  52  * where Error **errp is a parameter, by convention the last one.
  53  *
  54  * Pass an existing error to the caller with the message modified:
  55  *     error_propagate_prepend(errp, err);
  56  *
  57  * Avoid
  58  *     error_propagate(errp, err);
  59  *     error_prepend(errp, "Could not frobnicate '%s': ", name);
  60  * because this fails to prepend when @errp is &error_fatal.
  61  *
  62  * Create a new error and pass it to the caller:
  63  *     error_setg(errp, "situation normal, all fouled up");
  64  *
  65  * Call a function and receive an error from it:
  66  *     Error *err = NULL;
  67  *     foo(arg, &err);
  68  *     if (err) {
  69  *         handle the error...
  70  *     }
  71  *
  72  * Call a function ignoring errors:
  73  *     foo(arg, NULL);
  74  *
  75  * Call a function aborting on errors:
  76  *     foo(arg, &error_abort);
  77  *
  78  * Call a function treating errors as fatal:
  79  *     foo(arg, &error_fatal);
  80  *
  81  * Receive an error and pass it on to the caller:
  82  *     Error *err = NULL;
  83  *     foo(arg, &err);
  84  *     if (err) {
  85  *         handle the error...
  86  *         error_propagate(errp, err);
  87  *     }
  88  * where Error **errp is a parameter, by convention the last one.
  89  *
  90  * Do *not* "optimize" this to
  91  *     foo(arg, errp);
  92  *     if (*errp) { // WRONG!
  93  *         handle the error...
  94  *     }
  95  * because errp may be NULL!
  96  *
  97  * But when all you do with the error is pass it on, please use
  98  *     foo(arg, errp);
  99  * for readability.
 100  *
 101  * Receive and accumulate multiple errors (first one wins):
 102  *     Error *err = NULL, *local_err = NULL;
 103  *     foo(arg, &err);
 104  *     bar(arg, &local_err);
 105  *     error_propagate(&err, local_err);
 106  *     if (err) {
 107  *         handle the error...
 108  *     }
 109  *
 110  * Do *not* "optimize" this to
 111  *     foo(arg, &err);
 112  *     bar(arg, &err); // WRONG!
 113  *     if (err) {
 114  *         handle the error...
 115  *     }
 116  * because this may pass a non-null err to bar().
 117  */
 118
 119 #ifndef ERROR_H
 120 #define ERROR_H
 121
 122 #include "qapi/qapi-types-common.h"
 123
 124 /*
 125  * Overall category of an error.
 126  * Based on the qapi type QapiErrorClass, but reproduced here for nicer
 127  * enum names.
 128  */
 129 typedef enum ErrorClass {
 130     ERROR_CLASS_GENERIC_ERROR = QAPI_ERROR_CLASS_GENERICERROR,
 131     ERROR_CLASS_COMMAND_NOT_FOUND = QAPI_ERROR_CLASS_COMMANDNOTFOUND,
 132     ERROR_CLASS_DEVICE_NOT_ACTIVE = QAPI_ERROR_CLASS_DEVICENOTACTIVE,
 133     ERROR_CLASS_DEVICE_NOT_FOUND = QAPI_ERROR_CLASS_DEVICENOTFOUND,
 134     ERROR_CLASS_KVM_MISSING_CAP = QAPI_ERROR_CLASS_KVMMISSINGCAP,
 135 } ErrorClass;
 136
 137 /*
 138  * Get @err's human-readable error message.
 139  */
 140 const char *error_get_pretty(const Error *err);
 141
 142 /*
 143  * Get @err's error class.
 144  * Note: use of error classes other than ERROR_CLASS_GENERIC_ERROR is
 145  * strongly discouraged.
 146  */
 147 ErrorClass error_get_class(const Error *err);
 148
 149 /*
 150  * Create a new error object and assign it to *@errp.
 151  * If @errp is NULL, the error is ignored.  Don't bother creating one
 152  * then.
 153  * If @errp is &error_abort, print a suitable message and abort().
 154  * If @errp is &error_fatal, print a suitable message and exit(1).
 155  * If @errp is anything else, *@errp must be NULL.
 156  * The new error's class is ERROR_CLASS_GENERIC_ERROR, and its
 157  * human-readable error message is made from printf-style @fmt, ...
 158  * The resulting message should be a single phrase, with no newline or
 159  * trailing punctuation.
 160  * Please don't error_setg(&error_fatal, ...), use error_report() and
 161  * exit(), because that's more obvious.
 162  * Likewise, don't error_setg(&error_abort, ...), use assert().
 163  */
 164 #define error_setg(errp, fmt, ...)                              \
 165     error_setg_internal((errp), __FILE__, __LINE__, __func__,   \
 166                         (fmt), ## __VA_ARGS__)
 167 void error_setg_internal(Error **errp,
 168                          const char *src, int line, const char *func,
 169                          const char *fmt, ...)
 170     GCC_FMT_ATTR(5, 6);
 171
 172 /*
 173  * Just like error_setg(), with @os_error info added to the message.
 174  * If @os_error is non-zero, ": " + strerror(os_error) is appended to
 175  * the human-readable error message.
 176  *
 177  * The value of errno (which usually can get clobbered by almost any
 178  * function call) will be preserved.
 179  */
 180 #define error_setg_errno(errp, os_error, fmt, ...)                      \
 181     error_setg_errno_internal((errp), __FILE__, __LINE__, __func__,     \
 182                               (os_error), (fmt), ## __VA_ARGS__)
 183 void error_setg_errno_internal(Error **errp,
 184                                const char *fname, int line, const char *func,
 185                                int os_error, const char *fmt, ...)
 186     GCC_FMT_ATTR(6, 7);
 187
 188 #ifdef _WIN32
 189 /*
 190  * Just like error_setg(), with @win32_error info added to the message.
 191  * If @win32_error is non-zero, ": " + g_win32_error_message(win32_err)
 192  * is appended to the human-readable error message.
 193  */
 194 #define error_setg_win32(errp, win32_err, fmt, ...)                     \
 195     error_setg_win32_internal((errp), __FILE__, __LINE__, __func__,     \
 196                               (win32_err), (fmt), ## __VA_ARGS__)
 197 void error_setg_win32_internal(Error **errp,
 198                                const char *src, int line, const char *func,
 199                                int win32_err, const char *fmt, ...)
 200     GCC_FMT_ATTR(6, 7);
 201 #endif
 202
 203 /*
 204  * Propagate error object (if any) from @local_err to @dst_errp.
 205  * If @local_err is NULL, do nothing (because there's nothing to
 206  * propagate).
 207  * Else, if @dst_errp is NULL, errors are being ignored.  Free the
 208  * error object.
 209  * Else, if @dst_errp is &error_abort, print a suitable message and
 210  * abort().
 211  * Else, if @dst_errp is &error_fatal, print a suitable message and
 212  * exit(1).
 213  * Else, if @dst_errp already contains an error, ignore this one: free
 214  * the error object.
 215  * Else, move the error object from @local_err to *@dst_errp.
 216  * On return, @local_err is invalid.
 217  * Please don't error_propagate(&error_fatal, ...), use
 218  * error_report_err() and exit(), because that's more obvious.
 219  */
 220 void error_propagate(Error **dst_errp, Error *local_err);
 221
 222
 223 /*
 224  * Propagate error object (if any) with some text prepended.
 225  * Behaves like
 226  *     error_prepend(&local_err, fmt, ...);
 227  *     error_propagate(dst_errp, local_err);
 228  */
 229 void error_propagate_prepend(Error **dst_errp, Error *local_err,
 230                              const char *fmt, ...) GCC_FMT_ATTR(3, 4);
 231
 232 /*
 233  * Prepend some text to @errp's human-readable error message.
 234  * The text is made by formatting @fmt, @ap like vprintf().
 235  */
 236 void error_vprepend(Error **errp, const char *fmt, va_list ap)
 237     GCC_FMT_ATTR(2, 0);
 238
 239 /*
 240  * Prepend some text to @errp's human-readable error message.
 241  * The text is made by formatting @fmt, ... like printf().
 242  */
 243 void error_prepend(Error **errp, const char *fmt, ...)
 244     GCC_FMT_ATTR(2, 3);
 245
 246 /*
 247  * Append a printf-style human-readable explanation to an existing error.
 248  * If the error is later reported to a human user with
 249  * error_report_err() or warn_report_err(), the hints will be shown,
 250  * too.  If it's reported via QMP, the hints will be ignored.
 251  * Intended use is adding helpful hints on the human user interface,
 252  * e.g. a list of valid values.  It's not for clarifying a confusing
 253  * error message.
 254  * @errp may be NULL, but not &error_fatal or &error_abort.
 255  * Trivially the case if you call it only after error_setg() or
 256  * error_propagate().
 257  * May be called multiple times.  The resulting hint should end with a
 258  * newline.
 259  */
 260 void error_append_hint(Error **errp, const char *fmt, ...)
 261     GCC_FMT_ATTR(2, 3);
 262
 263 /*
 264  * Convenience function to report open() failure.
 265  */
 266 #define error_setg_file_open(errp, os_errno, filename)                  \
 267     error_setg_file_open_internal((errp), __FILE__, __LINE__, __func__, \
 268                                   (os_errno), (filename))
 269 void error_setg_file_open_internal(Error **errp,
 270                                    const char *src, int line, const char *func,
 271                                    int os_errno, const char *filename);
 272
 273 /*
 274  * Return an exact copy of @err.
 275  */
 276 Error *error_copy(const Error *err);
 277
 278 /*
 279  * Free @err.
 280  * @err may be NULL.
 281  */
 282 void error_free(Error *err);
 283
 284 /*
 285  * Convenience function to assert that *@errp is set, then silently free it.
 286  */
 287 void error_free_or_abort(Error **errp);
 288
 289 /*
 290  * Convenience function to warn_report() and free @err.
 291  * The report includes hints added with error_append_hint().
 292  */
 293 void warn_report_err(Error *err);
 294
 295 /*
 296  * Convenience function to error_report() and free @err.
 297  * The report includes hints added with error_append_hint().
 298  */
 299 void error_report_err(Error *err);
 300
 301 /*
 302  * Convenience function to error_prepend(), warn_report() and free @err.
 303  */
 304 void warn_reportf_err(Error *err, const char *fmt, ...)
 305     GCC_FMT_ATTR(2, 3);
 306
 307 /*
 308  * Convenience function to error_prepend(), error_report() and free @err.
 309  */
 310 void error_reportf_err(Error *err, const char *fmt, ...)
 311     GCC_FMT_ATTR(2, 3);
 312
 313 /*
 314  * Just like error_setg(), except you get to specify the error class.
 315  * Note: use of error classes other than ERROR_CLASS_GENERIC_ERROR is
 316  * strongly discouraged.
 317  */
 318 #define error_set(errp, err_class, fmt, ...)                    \
 319     error_set_internal((errp), __FILE__, __LINE__, __func__,    \
 320                        (err_class), (fmt), ## __VA_ARGS__)
 321 void error_set_internal(Error **errp,
 322                         const char *src, int line, const char *func,
 323                         ErrorClass err_class, const char *fmt, ...)
 324     GCC_FMT_ATTR(6, 7);
 325
 326 /*
 327  * Special error destination to abort on error.
 328  * See error_setg() and error_propagate() for details.
 329  */
 330 extern Error *error_abort;
 331
 332 /*
 333  * Special error destination to exit(1) on error.
 334  * See error_setg() and error_propagate() for details.
 335  */
 336 extern Error *error_fatal;
 337
 338 #endif