qemu/util/error.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

309 lines
6.6 KiB
C
Raw Normal View History

/*
* 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.
*/
#include "qemu/osdep.h"
2016-03-14 08:01:28 +00:00
#include "qapi/error.h"
#include "qemu/error-report.h"
struct Error
{
char *msg;
ErrorClass err_class;
const char *src, *func;
int line;
GString *hint;
};
Error *error_abort;
Error *error_fatal;
Error *error_warn;
static void error_handle(Error **errp, Error *err)
{
if (errp == &error_abort) {
fprintf(stderr, "Unexpected error in %s() at %s:%d:\n",
err->func, err->src, err->line);
error_report("%s", error_get_pretty(err));
if (err->hint) {
error_printf("%s", err->hint->str);
}
abort();
}
if (errp == &error_fatal) {
error_report_err(err);
exit(1);
}
if (errp == &error_warn) {
warn_report_err(err);
} else if (errp && !*errp) {
*errp = err;
} else {
error_free(err);
}
}
G_GNUC_PRINTF(6, 0)
static void error_setv(Error **errp,
const char *src, int line, const char *func,
ErrorClass err_class, const char *fmt, va_list ap,
const char *suffix)
{
Error *err;
int saved_errno = errno;
if (errp == NULL) {
return;
}
assert(*errp == NULL);
err = g_malloc0(sizeof(*err));
err->msg = g_strdup_vprintf(fmt, ap);
if (suffix) {
char *msg = err->msg;
err->msg = g_strdup_printf("%s: %s", msg, suffix);
g_free(msg);
}
err->err_class = err_class;
err->src = src;
err->line = line;
err->func = func;
error_handle(errp, err);
errno = saved_errno;
}
void error_set_internal(Error **errp,
const char *src, int line, const char *func,
ErrorClass err_class, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
error_setv(errp, src, line, func, err_class, fmt, ap, NULL);
va_end(ap);
}
void error_setg_internal(Error **errp,
const char *src, int line, const char *func,
const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR, fmt, ap, NULL);
va_end(ap);
}
void error_setg_errno_internal(Error **errp,
const char *src, int line, const char *func,
int os_errno, const char *fmt, ...)
{
va_list ap;
int saved_errno = errno;
va_start(ap, fmt);
error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR, fmt, ap,
os_errno != 0 ? strerror(os_errno) : NULL);
va_end(ap);
errno = saved_errno;
}
void error_setg_file_open_internal(Error **errp,
const char *src, int line, const char *func,
int os_errno, const char *filename)
{
error_setg_errno_internal(errp, src, line, func, os_errno,
"Could not open '%s'", filename);
}
void error_vprepend(Error *const *errp, const char *fmt, va_list ap)
{
GString *newmsg;
if (!errp) {
return;
}
newmsg = g_string_new(NULL);
g_string_vprintf(newmsg, fmt, ap);
g_string_append(newmsg, (*errp)->msg);
g_free((*errp)->msg);
(*errp)->msg = g_string_free(newmsg, 0);
}
void error_prepend(Error *const *errp, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
error_vprepend(errp, fmt, ap);
va_end(ap);
}
void error_append_hint(Error *const *errp, const char *fmt, ...)
{
va_list ap;
int saved_errno = errno;
Error *err;
if (!errp) {
return;
}
err = *errp;
assert(err && errp != &error_abort && errp != &error_fatal);
if (!err->hint) {
err->hint = g_string_new(NULL);
}
va_start(ap, fmt);
g_string_append_vprintf(err->hint, fmt, ap);
va_end(ap);
errno = saved_errno;
}
#ifdef _WIN32
void error_setg_win32_internal(Error **errp,
const char *src, int line, const char *func,
int win32_err, const char *fmt, ...)
{
va_list ap;
char *suffix = NULL;
if (errp == NULL) {
return;
}
if (win32_err != 0) {
suffix = g_win32_error_message(win32_err);
}
va_start(ap, fmt);
error_setv(errp, src, line, func, ERROR_CLASS_GENERIC_ERROR,
fmt, ap, suffix);
va_end(ap);
g_free(suffix);
}
#endif
Error *error_copy(const Error *err)
{
Error *err_new;
err_new = g_malloc0(sizeof(*err));
err_new->msg = g_strdup(err->msg);
err_new->err_class = err->err_class;
err_new->src = err->src;
err_new->line = err->line;
err_new->func = err->func;
if (err->hint) {
err_new->hint = g_string_new(err->hint->str);
}
return err_new;
}
ErrorClass error_get_class(const Error *err)
{
return err->err_class;
}
migration: add reporting of errors for outgoing migration Currently if an application initiates an outgoing migration, it may or may not, get an error reported back on failure. If the error occurs synchronously to the 'migrate' command execution, the client app will see the error message. This is the case for DNS lookup failures. If the error occurs asynchronously to the monitor command though, the error will be thrown away and the client left guessing about what went wrong. This is the case for failure to connect to the TCP server (eg due to wrong port, or firewall rules, or other similar errors). In the future we'll be adding more scope for errors to happen asynchronously with the TLS protocol handshake. TLS errors are hard to diagnose even when they are well reported, so discarding errors entirely will make it impossible to debug TLS connection problems. Management apps which do migration are already using 'query-migrate' / 'info migrate' to check up on progress of background migration operations and to see their end status. This is a fine place to also include the error message when things go wrong. This patch thus adds an 'error-desc' field to the MigrationInfo struct, which will be populated when the 'status' is set to 'failed': (qemu) migrate -d tcp:localhost:9001 (qemu) info migrate capabilities: xbzrle: off rdma-pin-all: off auto-converge: off zero-blocks: off compress: off events: off x-postcopy-ram: off Migration status: failed (Error connecting to socket: Connection refused) total time: 0 milliseconds In the HMP, when doing non-detached migration, it is also possible to display this error message directly to the app. (qemu) migrate tcp:localhost:9001 Error connecting to socket: Connection refused Or with QMP { "execute": "query-migrate", "arguments": {} } { "return": { "status": "failed", "error-desc": "address resolution failed for myhost:9000: No address associated with hostname" } } Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com> Signed-off-by: Daniel P. Berrange <berrange@redhat.com> Reviewed-by: Juan Quintela <quintela@redhat.com> Message-Id: <1461751518-12128-11-git-send-email-berrange@redhat.com> Signed-off-by: Amit Shah <amit.shah@redhat.com>
2016-04-27 10:05:00 +00:00
const char *error_get_pretty(const Error *err)
{
return err->msg;
}
void error_report_err(Error *err)
{
error_report("%s", error_get_pretty(err));
if (err->hint) {
error: Fix error_report_err(), warn_report_err() hint printing Before the from qerror_report() to error_setg(), hints looked like this: qerror_report(QERR_MACRO, ... arguments ...); error_printf_unless_qmp(... hint ...); error_printf_unless_qmp() made perfect sense: it printed exactly when qerror_report() did. After the conversion to error_setg(): error_setg(errp, QERR_MACRO, ... arguments ...); error_printf_unless_qmp(... hint ...); The "unless QMP part" still made some sense; in QMP context, the caller generally uses the error as QMP response instead of printing it. However, everything else is wrong. If the caller handles the error, the hint gets printed anyway (unless QMP). If the caller reports the error, the hint gets printed *before* the report (unless QMP) or not at all (if QMP). Commit 50b7b000c91 fixed this by making hints a member of Error. It kept printing hints with error_printf_unless_qmp(): void error_report_err(Error *err) { error_report("%s", error_get_pretty(err)); + if (err->hint) { + error_printf_unless_qmp("%s\n", err->hint->str); + } error_free(err); } This is wrong. We should (and now can) print the hint exactly when we print the error. The mistake has since been copied to warn_report_err() in commit e43ead1d0b9. Fix both to use error_printf(). Reported-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> Cc: Eric Blake <eblake@redhat.com> Signed-off-by: Markus Armbruster <armbru@redhat.com> Message-Id: <20190416153850.5186-1-armbru@redhat.com> Reviewed-by: Eric Blake <eblake@redhat.com> Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> [Commit message tweaked]
2019-04-16 15:38:50 +00:00
error_printf("%s", err->hint->str);
}
error_free(err);
}
void warn_report_err(Error *err)
{
warn_report("%s", error_get_pretty(err));
if (err->hint) {
error: Fix error_report_err(), warn_report_err() hint printing Before the from qerror_report() to error_setg(), hints looked like this: qerror_report(QERR_MACRO, ... arguments ...); error_printf_unless_qmp(... hint ...); error_printf_unless_qmp() made perfect sense: it printed exactly when qerror_report() did. After the conversion to error_setg(): error_setg(errp, QERR_MACRO, ... arguments ...); error_printf_unless_qmp(... hint ...); The "unless QMP part" still made some sense; in QMP context, the caller generally uses the error as QMP response instead of printing it. However, everything else is wrong. If the caller handles the error, the hint gets printed anyway (unless QMP). If the caller reports the error, the hint gets printed *before* the report (unless QMP) or not at all (if QMP). Commit 50b7b000c91 fixed this by making hints a member of Error. It kept printing hints with error_printf_unless_qmp(): void error_report_err(Error *err) { error_report("%s", error_get_pretty(err)); + if (err->hint) { + error_printf_unless_qmp("%s\n", err->hint->str); + } error_free(err); } This is wrong. We should (and now can) print the hint exactly when we print the error. The mistake has since been copied to warn_report_err() in commit e43ead1d0b9. Fix both to use error_printf(). Reported-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> Cc: Eric Blake <eblake@redhat.com> Signed-off-by: Markus Armbruster <armbru@redhat.com> Message-Id: <20190416153850.5186-1-armbru@redhat.com> Reviewed-by: Eric Blake <eblake@redhat.com> Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> [Commit message tweaked]
2019-04-16 15:38:50 +00:00
error_printf("%s", err->hint->str);
}
error_free(err);
}
void error_reportf_err(Error *err, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
error_vprepend(&err, fmt, ap);
va_end(ap);
error_report_err(err);
}
void warn_reportf_err(Error *err, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
error_vprepend(&err, fmt, ap);
va_end(ap);
warn_report_err(err);
}
void error_free(Error *err)
{
if (err) {
g_free(err->msg);
if (err->hint) {
g_string_free(err->hint, true);
}
g_free(err);
}
}
void error_free_or_abort(Error **errp)
{
assert(errp && *errp);
error_free(*errp);
*errp = NULL;
}
void error_propagate(Error **dst_errp, Error *local_err)
{
if (!local_err) {
return;
}
error_handle(dst_errp, local_err);
}
void error_propagate_prepend(Error **dst_errp, Error *err,
const char *fmt, ...)
{
va_list ap;
if (dst_errp && !*dst_errp) {
va_start(ap, fmt);
error_vprepend(&err, fmt, ap);
va_end(ap);
} /* else error is being ignored, don't bother with prepending */
error_propagate(dst_errp, err);
}