mirror of
https://github.com/yuzu-emu/unicorn.git
synced 2024-12-26 21:05:31 +00:00
11c66029b7
C11 allows errno to be clobbered by pretty much any library function call, so in general callers need to take care to save errno before calling other functions. However, for error reporting functions this is rather awkward and can make the code on the caller side more complicated than necessary. error_setg_errno() already takes care of preserving errno and some functions rely on that, so just promise that we continue to do so in the future. Backports commit 98cb89af4df7e1776ce418ed6167b6e214a64435 from qemu
252 lines
8 KiB
C
252 lines
8 KiB
C
/*
|
|
* QEMU Error Objects
|
|
*
|
|
* Copyright IBM, Corp. 2011
|
|
* Copyright (C) 2011-2015 Red Hat, Inc.
|
|
*
|
|
* Authors:
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
* Markus Armbruster <armbru@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU LGPL, version 2. See
|
|
* the COPYING.LIB file in the top-level directory.
|
|
*/
|
|
|
|
/*
|
|
* Error reporting system loosely patterned after Glib's GError.
|
|
*
|
|
* Create an error:
|
|
* error_setg(&err, "situation normal, all fouled up");
|
|
*
|
|
* Create an error and add additional explanation:
|
|
* error_setg(&err, "invalid quark");
|
|
* error_append_hint(&err, "Valid quarks are up, down, strange, "
|
|
* "charm, top, bottom.\n");
|
|
*
|
|
* Do *not* contract this to
|
|
* error_setg(&err, "invalid quark\n"
|
|
* "Valid quarks are up, down, strange, charm, top, bottom.");
|
|
*
|
|
*
|
|
* Report an error to the current monitor if we have one, else stderr:
|
|
* error_report_err(err);
|
|
* This frees the error object.
|
|
*
|
|
* Likewise, but with additional text prepended:
|
|
* error_reportf_err(err, "Could not frobnicate '%s': ", name);
|
|
*
|
|
* Report an error somewhere else:
|
|
* const char *msg = error_get_pretty(err);
|
|
* do with msg what needs to be done...
|
|
* error_free(err);
|
|
* Note that this loses hints added with error_append_hint().
|
|
*
|
|
* Handle an error without reporting it (just for completeness):
|
|
* error_free(err);
|
|
*
|
|
* Pass an existing error to the caller:
|
|
* error_propagate(errp, err);
|
|
* where Error **errp is a parameter, by convention the last one.
|
|
*
|
|
* Create a new error and pass it to the caller:
|
|
* error_setg(errp, "situation normal, all fouled up");
|
|
*
|
|
* Call a function and receive an error from it:
|
|
* Error *err = NULL;
|
|
* foo(arg, &err);
|
|
* if (err) {
|
|
* handle the error...
|
|
* }
|
|
*
|
|
* Call a function ignoring errors:
|
|
* foo(arg, NULL);
|
|
*
|
|
* Call a function aborting on errors:
|
|
* foo(arg, &error_abort);
|
|
*
|
|
* Call a function treating errors as fatal:
|
|
* foo(arg, &error_fatal);
|
|
*
|
|
* Receive an error and pass it on to the caller:
|
|
* Error *err = NULL;
|
|
* foo(arg, &err);
|
|
* if (err) {
|
|
* handle the error...
|
|
* error_propagate(errp, err);
|
|
* }
|
|
* where Error **errp is a parameter, by convention the last one.
|
|
*
|
|
* Do *not* "optimize" this to
|
|
* foo(arg, errp);
|
|
* if (*errp) { // WRONG!
|
|
* handle the error...
|
|
* }
|
|
* because errp may be NULL!
|
|
*
|
|
* But when all you do with the error is pass it on, please use
|
|
* foo(arg, errp);
|
|
* for readability.
|
|
*
|
|
* Receive and accumulate multiple errors (first one wins):
|
|
* Error *err = NULL, *local_err = NULL;
|
|
* foo(arg, &err);
|
|
* bar(arg, &local_err);
|
|
* error_propagate(&err, local_err);
|
|
* if (err) {
|
|
* handle the error...
|
|
* }
|
|
*
|
|
* Do *not* "optimize" this to
|
|
* foo(arg, &err);
|
|
* bar(arg, &err); // WRONG!
|
|
* if (err) {
|
|
* handle the error...
|
|
* }
|
|
* because this may pass a non-null err to bar().
|
|
*/
|
|
|
|
#ifndef ERROR_H
|
|
#define ERROR_H
|
|
|
|
#include "qemu/compiler.h"
|
|
#include "qapi-types.h"
|
|
#include "unicorn/platform.h"
|
|
|
|
/*
|
|
* Overall category of an error.
|
|
* Based on the qapi type QapiErrorClass, but reproduced here for nicer
|
|
* enum names.
|
|
*/
|
|
typedef enum ErrorClass {
|
|
ERROR_CLASS_GENERIC_ERROR = QAPI_ERROR_CLASS_GENERICERROR,
|
|
ERROR_CLASS_COMMAND_NOT_FOUND = QAPI_ERROR_CLASS_COMMANDNOTFOUND,
|
|
ERROR_CLASS_DEVICE_ENCRYPTED = QAPI_ERROR_CLASS_DEVICEENCRYPTED,
|
|
ERROR_CLASS_DEVICE_NOT_ACTIVE = QAPI_ERROR_CLASS_DEVICENOTACTIVE,
|
|
ERROR_CLASS_DEVICE_NOT_FOUND = QAPI_ERROR_CLASS_DEVICENOTFOUND,
|
|
ERROR_CLASS_KVM_MISSING_CAP = QAPI_ERROR_CLASS_KVMMISSINGCAP,
|
|
} ErrorClass;
|
|
|
|
/**
|
|
* Get @err's human-readable error message.
|
|
*/
|
|
const char *error_get_pretty(Error *err);
|
|
|
|
/*
|
|
* Get @err's error class.
|
|
* Note: use of error classes other than ERROR_CLASS_GENERIC_ERROR is
|
|
* strongly discouraged.
|
|
*/
|
|
ErrorClass error_get_class(const Error *err);
|
|
|
|
/**
|
|
* Set an indirect pointer to an error given a ErrorClass value and a
|
|
* printf-style human message, followed by a strerror() string if
|
|
* @os_error is not zero.
|
|
*/
|
|
void error_set_errno(Error **errp, int os_error, ErrorClass err_class,
|
|
const char *fmt, ...) GCC_FMT_ATTR(4, 5);
|
|
|
|
/*
|
|
* Create a new error object and assign it to *@errp.
|
|
* If @errp is NULL, the error is ignored. Don't bother creating one
|
|
* then.
|
|
* If @errp is &error_abort, print a suitable message and abort().
|
|
* If @errp is anything else, *@errp must be NULL.
|
|
* The new error's class is ERROR_CLASS_GENERIC_ERROR, and its
|
|
* human-readable error message is made from printf-style @fmt, ...
|
|
* The resulting message should be a single phrase, with no newline or
|
|
* trailing punctuation.
|
|
* Please don't error_setg(&error_fatal, ...), use error_report() and
|
|
* exit(), because that's more obvious.
|
|
* Likewise, don't error_setg(&error_abort, ...), use assert().
|
|
*/
|
|
#define error_setg(errp, fmt, ...) \
|
|
error_setg_internal((errp), __FILE__, __LINE__, __func__, \
|
|
(fmt), ## __VA_ARGS__)
|
|
void error_setg_internal(Error **errp,
|
|
const char *src, int line, const char *func,
|
|
const char *fmt, ...)
|
|
GCC_FMT_ATTR(5, 6);
|
|
|
|
/*
|
|
* Just like error_setg(), with @os_error info added to the message.
|
|
* If @os_error is non-zero, ": " + strerror(os_error) is appended to
|
|
* the human-readable error message.
|
|
*
|
|
* The value of errno (which usually can get clobbered by almost any
|
|
* function call) will be preserved.
|
|
*/
|
|
#define error_setg_errno(errp, os_error, fmt, ...) \
|
|
error_setg_errno_internal((errp), __FILE__, __LINE__, __func__, \
|
|
(os_error), (fmt), ## __VA_ARGS__)
|
|
void error_setg_errno_internal(Error **errp,
|
|
const char *fname, int line, const char *func,
|
|
int os_error, const char *fmt, ...)
|
|
GCC_FMT_ATTR(6, 7);
|
|
|
|
|
|
/*
|
|
* Propagate error object (if any) from @local_err to @dst_errp.
|
|
* If @local_err is NULL, do nothing (because there's nothing to
|
|
* propagate).
|
|
* Else, if @dst_errp is NULL, errors are being ignored. Free the
|
|
* error object.
|
|
* Else, if @dst_errp is &error_abort, print a suitable message and
|
|
* abort().
|
|
* Else, if @dst_errp already contains an error, ignore this one: free
|
|
* the error object.
|
|
* Else, move the error object from @local_err to *@dst_errp.
|
|
* On return, @local_err is invalid.
|
|
* Please don't error_propagate(&error_fatal, ...), use
|
|
* error_report_err() and exit(), because that's more obvious.
|
|
*/
|
|
void error_propagate(Error **dst_errp, Error *local_err);
|
|
|
|
/**
|
|
* Convenience function to report open() failure.
|
|
*/
|
|
#define error_setg_file_open(errp, os_errno, filename) \
|
|
error_setg_file_open_internal((errp), __FILE__, __LINE__, __func__, \
|
|
(os_errno), (filename))
|
|
void error_setg_file_open_internal(Error **errp,
|
|
const char *src, int line, const char *func,
|
|
int os_errno, const char *filename);
|
|
|
|
/**
|
|
* Return an exact copy of @err.
|
|
*/
|
|
Error *error_copy(const Error *err);
|
|
|
|
/**
|
|
* Free @err.
|
|
* @err may be NULL.
|
|
*/
|
|
void error_free(Error *err);
|
|
|
|
/*
|
|
* Just like error_setg(), except you get to specify the error class.
|
|
* Note: use of error classes other than ERROR_CLASS_GENERIC_ERROR is
|
|
* strongly discouraged.
|
|
*/
|
|
#define error_set(errp, err_class, fmt, ...) \
|
|
error_set_internal((errp), __FILE__, __LINE__, __func__, \
|
|
(err_class), (fmt), ## __VA_ARGS__)
|
|
void error_set_internal(Error **errp,
|
|
const char *src, int line, const char *func,
|
|
ErrorClass err_class, const char *fmt, ...)
|
|
GCC_FMT_ATTR(6, 7);
|
|
|
|
/*
|
|
* Special error destination to abort on error.
|
|
* See error_setg() and error_propagate() for details.
|
|
*/
|
|
extern Error *error_abort;
|
|
|
|
/*
|
|
* Special error destination to exit(1) on error.
|
|
* See error_setg() and error_propagate() for details.
|
|
*/
|
|
extern Error *error_fatal;
|
|
|
|
#endif
|