From patchwork Fri Nov 27 00:59:01 2009 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luiz Capitulino X-Patchwork-Id: 39602 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 2DA3F1007D1 for ; Fri, 27 Nov 2009 12:19:11 +1100 (EST) Received: from localhost ([127.0.0.1]:59502 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NDpUJ-0004JO-Ny for incoming@patchwork.ozlabs.org; Thu, 26 Nov 2009 20:19:07 -0500 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NDpBe-0001oS-Pu for qemu-devel@nongnu.org; Thu, 26 Nov 2009 19:59:51 -0500 Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1NDpBa-0001k4-Pn for qemu-devel@nongnu.org; Thu, 26 Nov 2009 19:59:50 -0500 Received: from [199.232.76.173] (port=48299 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NDpBa-0001jr-Jr for qemu-devel@nongnu.org; Thu, 26 Nov 2009 19:59:46 -0500 Received: from mx1.redhat.com ([209.132.183.28]:29316) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1NDpBZ-0004S7-RD for qemu-devel@nongnu.org; Thu, 26 Nov 2009 19:59:46 -0500 Received: from int-mx08.intmail.prod.int.phx2.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id nAR0xjof022390 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Thu, 26 Nov 2009 19:59:45 -0500 Received: from localhost (vpn-10-232.rdu.redhat.com [10.11.10.232]) by int-mx08.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id nAR0xhkL009441; Thu, 26 Nov 2009 19:59:44 -0500 From: Luiz Capitulino To: qemu-devel@nongnu.org Date: Thu, 26 Nov 2009 22:59:01 -0200 Message-Id: <1259283550-3597-12-git-send-email-lcapitulino@redhat.com> In-Reply-To: <1259283550-3597-1-git-send-email-lcapitulino@redhat.com> References: <1259283550-3597-1-git-send-email-lcapitulino@redhat.com> X-Scanned-By: MIMEDefang 2.67 on 10.5.11.21 X-detected-operating-system: by monty-python.gnu.org: Genre and OS details not recognized. Cc: aliguori@us.ibm.com, avi@redhat.com, armbru@redhat.com Subject: [Qemu-devel] [PATCH 11/20] QMP: Input support 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 The JSON stream parser is used to do QMP input. When there are enough characters to be parsed it calls Monitor's handle_qmp_command() function to handle the input. This function's job is to check if the input is correct and call the appropriate handler. In other words, it does for QMP what handle_user_command() does for the user protocol. This means that handle_qmp_command() also has to parse the (ugly) "args_type" format to able to get the arguments names and types expected by the handler. The format to input commands in QMP is as follows: { "execute": json-string, "id": json-value, "arguments": json-object } Please, note that this commit also adds "id" support. Signed-off-by: Luiz Capitulino --- monitor.c | 241 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 240 insertions(+), 1 deletions(-) diff --git a/monitor.c b/monitor.c index de56201..c172343 100644 --- a/monitor.c +++ b/monitor.c @@ -48,9 +48,12 @@ #include "qint.h" #include "qlist.h" #include "qdict.h" +#include "qbool.h" #include "qstring.h" #include "qerror.h" #include "qjson.h" +#include "json-streamer.h" +#include "json-parser.h" //#define DEBUG //#define DEBUG_COMPLETION @@ -93,6 +96,11 @@ struct mon_fd_t { QLIST_ENTRY(mon_fd_t) next; }; +typedef struct MonitorControl { + QObject *id; + JSONMessageParser parser; +} MonitorControl; + struct Monitor { CharDriverState *chr; int mux_out; @@ -102,6 +110,7 @@ struct Monitor { uint8_t outbuf[1024]; int outbuf_index; ReadLineState *rs; + MonitorControl *mc; CPUState *mon_cpu; BlockDriverCompletionFunc *password_completion_cb; void *password_opaque; @@ -289,6 +298,11 @@ static void monitor_protocol_emitter(Monitor *mon, QObject *data) mon->error = NULL; } + if (mon->mc->id) { + qdict_put_obj(qmp, "id", mon->mc->id); + mon->mc->id = NULL; + } + monitor_json_emitter(mon, QOBJECT(qmp)); QDECREF(qmp); } @@ -3643,6 +3657,228 @@ static int monitor_can_read(void *opaque) return (mon->suspend_cnt == 0) ? 128 : 0; } +typedef struct CmdArgs { + QString *name; + int type; + int flag; + int optional; +} CmdArgs; + +static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args) +{ + if (!cmd_args->optional) { + qemu_error_new(QERR_MISSING_PARAMETER, name); + return -1; + } + + if (cmd_args->type == '-') { + /* handlers expect a value, they need to be changed */ + qdict_put(args, name, qint_from_int(0)); + } + + return 0; +} + +static int check_arg(const CmdArgs *cmd_args, QDict *args) +{ + QObject *value; + const char *name; + + name = qstring_get_str(cmd_args->name); + + if (!args) { + return check_opt(cmd_args, name, args); + } + + value = qdict_get(args, name); + if (!value) { + return check_opt(cmd_args, name, args); + } + + switch (cmd_args->type) { + case 'F': + case 'B': + case 's': + if (qobject_type(value) != QTYPE_QSTRING) { + qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "string"); + return -1; + } + break; + case '/': { + int i; + const char *keys[] = { "count", "format", "size", NULL }; + + for (i = 0; keys[i]; i++) { + QObject *obj = qdict_get(args, keys[i]); + if (!obj) { + qemu_error_new(QERR_MISSING_PARAMETER, name); + return -1; + } + if (qobject_type(obj) != QTYPE_QINT) { + qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "int"); + return -1; + } + } + break; + } + case 'i': + case 'l': + if (qobject_type(value) != QTYPE_QINT) { + qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "int"); + return -1; + } + break; + case '-': + if (qobject_type(value) != QTYPE_QINT && + qobject_type(value) != QTYPE_QBOOL) { + qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "bool"); + return -1; + } + if (qobject_type(value) == QTYPE_QBOOL) { + /* handlers expect a QInt, they need to be changed */ + qdict_put(args, name, + qint_from_int(qbool_get_int(qobject_to_qbool(value)))); + } + break; + default: + /* impossible */ + abort(); + } + + return 0; +} + +static void cmd_args_init(CmdArgs *cmd_args) +{ + cmd_args->name = qstring_new(); + cmd_args->type = cmd_args->flag = cmd_args->optional = 0; +} + +/* + * This is not trivial, we have to parse Monitor command's argument + * type syntax to be able to check the arguments provided by clients. + * + * In the near future we will be using an array for that and will be + * able to drop all this parsing... + */ +static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args) +{ + int err; + const char *p; + CmdArgs cmd_args; + + if (cmd->args_type == '\0') { + return (qdict_size(args) == 0 ? 0 : -1); + } + + err = 0; + cmd_args_init(&cmd_args); + + for (p = cmd->args_type;; p++) { + if (*p == ':') { + cmd_args.type = *++p; + p++; + if (cmd_args.type == '-') { + cmd_args.flag = *p++; + cmd_args.optional = 1; + } else if (*p == '?') { + cmd_args.optional = 1; + p++; + } + + assert(*p == ',' || *p == '\0'); + err = check_arg(&cmd_args, args); + + QDECREF(cmd_args.name); + cmd_args_init(&cmd_args); + + if (err < 0) { + break; + } + } else { + qstring_append_chr(cmd_args.name, *p); + } + + if (*p == '\0') { + break; + } + } + + QDECREF(cmd_args.name); + return err; +} + +static void handle_qmp_command(JSONMessageParser *parser, QList *tokens) +{ + int err; + QObject *obj; + QDict *input, *args; + const char *cmd_name; + const mon_cmd_t *cmd; + Monitor *mon = cur_mon; + + args = NULL; + qemu_errors_to_mon(mon); + + obj = json_parser_parse(tokens, NULL); + if (!obj) { + // FIXME: should be triggered in json_parser_parse() + qemu_error_new(QERR_JSON_PARSING); + goto err_out; + } else if (qobject_type(obj) != QTYPE_QDICT) { + qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "object"); + qobject_decref(obj); + goto err_out; + } + + input = qobject_to_qdict(obj); + + mon->mc->id = qdict_get(input, "id"); + qobject_incref(mon->mc->id); + + obj = qdict_get(input, "execute"); + if (!obj) { + qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "execute"); + goto err_input; + } else if (qobject_type(obj) != QTYPE_QSTRING) { + qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "string"); + goto err_input; + } + + cmd_name = qstring_get_str(qobject_to_qstring(obj)); + cmd = monitor_find_command(cmd_name); + if (!cmd) { + qemu_error_new(QERR_COMMAND_NOT_FOUND, cmd_name); + goto err_input; + } + + obj = qdict_get(input, "arguments"); + if (!obj) { + args = qdict_new(); + } else { + args = qobject_to_qdict(obj); + QINCREF(args); + } + + QDECREF(input); + + err = monitor_check_qmp_args(cmd, args); + if (err < 0) { + goto err_out; + } + + monitor_call_handler(mon, cmd, args); + goto out; + +err_input: + QDECREF(input); +err_out: + monitor_protocol_emitter(mon, NULL); +out: + QDECREF(args); + qemu_errors_to_previous(); +} + /** * monitor_control_read(): Read and handle QMP input */ @@ -3652,7 +3888,7 @@ static void monitor_control_read(void *opaque, const uint8_t *buf, int size) cur_mon = opaque; - // TODO: read QMP input + json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size); cur_mon = old_mon; } @@ -3709,6 +3945,8 @@ static void monitor_control_event(void *opaque, int event) QObject *data; Monitor *mon = opaque; + json_message_parser_init(&mon->mc->parser, handle_qmp_command); + data = qobject_from_jsonf("{ 'QMP': { 'capabilities': [] } }"); assert(data != NULL); @@ -3804,6 +4042,7 @@ void monitor_init(CharDriverState *chr, int flags) } if (monitor_ctrl_mode(mon)) { + mon->mc = qemu_mallocz(sizeof(MonitorControl)); /* Control mode requires special handlers */ qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read, monitor_control_event, mon);