From patchwork Thu Nov 12 20:42:30 2009 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luiz Capitulino X-Patchwork-Id: 38282 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [199.232.76.165]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 442A2B7088 for ; Fri, 13 Nov 2009 08:01:48 +1100 (EST) Received: from localhost ([127.0.0.1]:34948 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1N8gnZ-0004QT-5m for incoming@patchwork.ozlabs.org; Thu, 12 Nov 2009 16:01:45 -0500 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1N8gVX-0007sx-Gx for qemu-devel@nongnu.org; Thu, 12 Nov 2009 15:43:07 -0500 Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1N8gVS-0007qB-NM for qemu-devel@nongnu.org; Thu, 12 Nov 2009 15:43:06 -0500 Received: from [199.232.76.173] (port=33542 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1N8gVS-0007q4-69 for qemu-devel@nongnu.org; Thu, 12 Nov 2009 15:43:02 -0500 Received: from mx1.redhat.com ([209.132.183.28]:17991) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1N8gVR-0006hl-FM for qemu-devel@nongnu.org; Thu, 12 Nov 2009 15:43:01 -0500 Received: from int-mx05.intmail.prod.int.phx2.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.18]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id nACKh0sY018228 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Thu, 12 Nov 2009 15:43:00 -0500 Received: from localhost (vpn-10-7.rdu.redhat.com [10.11.10.7]) by int-mx05.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id nACKgwAc015258; Thu, 12 Nov 2009 15:42:59 -0500 From: Luiz Capitulino To: qemu-devel@nongnu.org Date: Thu, 12 Nov 2009 18:42:30 -0200 Message-Id: <1258058554-22872-6-git-send-email-lcapitulino@redhat.com> In-Reply-To: <1258058554-22872-1-git-send-email-lcapitulino@redhat.com> References: <1258058554-22872-1-git-send-email-lcapitulino@redhat.com> X-Scanned-By: MIMEDefang 2.67 on 10.5.11.18 X-detected-operating-system: by monty-python.gnu.org: Genre and OS details not recognized. Cc: aliguori@us.ibm.com, kraxel@redhat.com, armbru@redhat.com Subject: [Qemu-devel] [PATCH 5/9] Introduce QError X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org QError is a high-level data type which represents an exception in QEMU, it stores the following error information: - class Error class name (eg. "ServiceUnavailable") - description A detailed error description, which may contain references to run-time error data - filename The file name of where the error occurred - line number The exact line number of the error - run-time data Any run-time error data This commit adds the basic interface plus two error classes, one for 'device not found' errors and another one for 'service unavailable' errors. Signed-off-by: Luiz Capitulino --- Makefile | 2 +- qerror.c | 283 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ qerror.h | 46 ++++++++++ qobject.h | 1 + 4 files changed, 331 insertions(+), 1 deletions(-) create mode 100644 qerror.c create mode 100644 qerror.h diff --git a/Makefile b/Makefile index 4998226..98625e7 100644 --- a/Makefile +++ b/Makefile @@ -138,7 +138,7 @@ obj-y += qemu-char.o aio.o savevm.o obj-y += msmouse.o ps2.o obj-y += qdev.o qdev-properties.o obj-y += qint.o qstring.o qdict.o qlist.o qfloat.o qbool.o json-lexer.o -obj-y += json-streamer.o json-parser.o qjson.o +obj-y += json-streamer.o json-parser.o qjson.o qerror.o obj-y += qemu-config.o obj-$(CONFIG_BRLAPI) += baum.o diff --git a/qerror.c b/qerror.c new file mode 100644 index 0000000..91b0f72 --- /dev/null +++ b/qerror.c @@ -0,0 +1,283 @@ +/* + * QError: QEMU Error data-type. + * + * Copyright (C) 2009 Red Hat Inc. + * + * Authors: + * Luiz Capitulino + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + */ +#include "qjson.h" +#include "qerror.h" +#include "qstring.h" +#include "sysemu.h" +#include "qemu-common.h" + +static void qerror_destroy_obj(QObject *obj); + +static const QType qerror_type = { + .code = QTYPE_QERROR, + .destroy = qerror_destroy_obj, +}; + +/** + * The 'desc' parameter is a printf-like string, the format of the format + * string is: + * + * %(KEY)TYPE + * + * Where KEY is a QDict key and TYPE is the type of its value, KEY and + * its value must be passed to qerror_from_info(). + * + * Valid types are: + * + * s (string) + * d (integer) + * + * Example: + * + * "foo error on device: %(device)s slot: %(slot_nr)d" + * + * A single percent sign can be printed if followed by a second one, + * for example: + * + * "running out of foo: %(foo)d%%" + */ +const QErrorStringTable qerror_table[] = { + { + .error_fmt = QERR_DEVICE_NOT_FOUND, + .desc = "device \"%(name)s\" not found", + }, + { + .error_fmt = QERR_SERVICE_UNAVAILABLE, + .desc = "%(reason)s", + }, + {} +}; + +/** + * qerror_new(): Create a new QError + * + * Return strong reference. + */ +QError *qerror_new(void) +{ + QError *qerr; + + qerr = qemu_mallocz(sizeof(*qerr)); + QOBJECT_INIT(qerr, &qerror_type); + + return qerr; +} + +static void qerror_abort(const QError *qerr, const char *fmt, ...) +{ + va_list ap; + + fprintf(stderr, "qerror: "); + + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + + fprintf(stderr, " call at %s:%d\n", qerr->file, qerr->linenr); + abort(); +} + +static void qerror_set_data(QError *qerr, const char *fmt, va_list *va) +{ + QObject *obj; + + obj = qobject_from_json_va(fmt, va); + if (!obj) { + qerror_abort(qerr, "invalid format '%s'", fmt); + } + if (qobject_type(obj) != QTYPE_QDICT) { + qerror_abort(qerr, "error format is not a QDict '%s'", fmt); + } + + qerr->error = qobject_to_qdict(obj); + + obj = qdict_get(qerr->error, "class"); + if (!obj) { + qerror_abort(qerr, "missing 'class' key in '%s'", fmt); + } + if (qobject_type(obj) != QTYPE_QSTRING) { + qerror_abort(qerr, "'class' key value should be a QString"); + } + + obj = qdict_get(qerr->error, "data"); + if (!obj) { + qerror_abort(qerr, "missing 'data' key in '%s'", fmt); + } + if (qobject_type(obj) != QTYPE_QDICT) { + qerror_abort(qerr, "'data' key value should be a QDICT"); + } +} + +static void qerror_set_desc(const char *fmt, QError *qerr) +{ + int i; + + // FIXME: inefficient loop + + for (i = 0; qerror_table[i].error_fmt; i++) { + if (strcmp(qerror_table[i].error_fmt, fmt) == 0) { + qerr->entry = &qerror_table[i]; + return; + } + } + + qerror_abort(qerr, "error format '%s' not found", fmt); +} + +/** + * qerror_from_info(): Create a new QError from error information + * + * The information consists of: + * + * - file the file name of where the error occurred + * - linenr the line number of where the error occurred + * - fmt JSON printf-like dictionary, there must exist keys 'class' and + * 'data' + * - va va_list of all arguments specified by fmt + * + * Return strong reference. + */ +QError *qerror_from_info(const char *file, int linenr, const char *fmt, + va_list *va) +{ + QError *qerr; + + qerr = qerror_new(); + qerr->linenr = linenr; + qerr->file = file; + + if (!fmt) { + qerror_abort(qerr, "QDict not specified"); + } + + qerror_set_data(qerr, fmt, va); + qerror_set_desc(fmt, qerr); + + return qerr; +} + +static char *get_substr(const char *start, const char *end) +{ + char *str; + size_t length; + + length = end - start + 1; + str = qemu_malloc(length + 1); + memcpy(str, start, length); + str[length] = '\0'; + + return str; +} + +static void parse_error(const QError *qerror, int c) +{ + qerror_abort(qerror, "expected '%c' in '%s'", c, qerror->entry->desc); +} + +static const char *append_field(QString *qstring, const QError *qerror, + const char *start) +{ + int type; + char *name; + QDict *qdict; + const char *end; + + if (*start != '%') + parse_error(qerror, '%'); + start++; + if (*start != '(') + parse_error(qerror, '('); + start++; + + end = strchr(start, ')'); + if (!end) + parse_error(qerror, ')'); + + name = get_substr(start, end - 1); + qdict = qobject_to_qdict(qdict_get(qerror->error, "data")); + + if (!qdict_haskey(qdict, name)) { + qerror_abort(qerror, "key '%s' not found in QDict", name); + } + + type = *++end; + switch (type) { + case 's': + qstring_append(qstring, qdict_get_str(qdict, name)); + break; + case 'd': + qstring_append_int(qstring, qdict_get_int(qdict, name)); + break; + default: + qerror_abort(qerror, "invalid type '%c'", type); + } + + qemu_free(name); + return ++end; +} + +/** + * qerror_print(): Print QError data + * + * This function will print the member 'desc' of the specified QError object, + * it uses qemu_error() for this, so that the output is routed to the right + * place (ie. stderr ou Monitor's device). + */ +void qerror_print(const QError *qerror) +{ + const char *p; + QString *qstring; + + assert(qerror->entry != NULL); + + qstring = qstring_new(); + + for (p = qerror->entry->desc; *p != '\0';) { + if (*p != '%') { + qstring_append_chr(qstring, *p++); + } else if (*(p + 1) == '%') { + qstring_append_chr(qstring, '%'); + p += 2; + } else { + p = append_field(qstring, qerror, p); + } + } + + qemu_error("%s\n", qstring_get_str(qstring)); + QDECREF(qstring); +} + +/** + * qobject_to_qerror(): Convert a QObject into a QError + */ +QError *qobject_to_qerror(const QObject *obj) +{ + if (qobject_type(obj) != QTYPE_QERROR) { + return NULL; + } + + return container_of(obj, QError, base); +} + +/** + * qerror_destroy_obj(): Free all memory allocated by a QError + */ +static void qerror_destroy_obj(QObject *obj) +{ + QError *qerr; + + assert(obj != NULL); + qerr = qobject_to_qerror(obj); + + QDECREF(qerr->error); + qemu_free(qerr); +} diff --git a/qerror.h b/qerror.h new file mode 100644 index 0000000..dc1aa35 --- /dev/null +++ b/qerror.h @@ -0,0 +1,46 @@ +/* + * QError header file. + * + * Copyright (C) 2009 Red Hat Inc. + * + * Authors: + * Luiz Capitulino + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + */ +#ifndef QERROR_H +#define QERROR_H + +#include "qdict.h" +#include + +typedef struct QErrorStringTable { + const char *desc; + const char *error_fmt; +} QErrorStringTable; + +typedef struct QError { + QObject_HEAD; + QDict *error; + int linenr; + const char *file; + const QErrorStringTable *entry; +} QError; + +QError *qerror_new(void); +QError *qerror_from_info(const char *file, int linenr, const char *fmt, + va_list *va); +void qerror_print(const QError *qerror); +QError *qobject_to_qerror(const QObject *obj); + +/* + * QEMU error format list + */ +#define QERR_DEVICE_NOT_FOUND \ + "{ 'class': 'DeviceNotFound', 'data': { 'name': %s } }" + +#define QERR_SERVICE_UNAVAILABLE \ + "{ 'class': 'ServiceUnavailable', 'data': { 'reason': %s } }" + +#endif /* QERROR_H */ diff --git a/qobject.h b/qobject.h index 2270ec1..07de211 100644 --- a/qobject.h +++ b/qobject.h @@ -43,6 +43,7 @@ typedef enum { QTYPE_QLIST, QTYPE_QFLOAT, QTYPE_QBOOL, + QTYPE_QERROR, } qtype_code; struct QObject;