Patchwork [05/15] monitor: Handle new and old style handlers

login
register
mail settings
Submitter Luiz Capitulino
Date Oct. 7, 2009, 12:27 a.m.
Message ID <1254875232-25012-6-git-send-email-lcapitulino@redhat.com>
Download mbox | patch
Permalink /patch/35177/
State Changes Requested
Headers show

Comments

Luiz Capitulino - Oct. 7, 2009, 12:27 a.m.
This commit changes monitor_handle_command() to support old style
_and_ new style handlers.

New style handlers are protocol independent, they return their
data to the Monitor, which in turn decides how to print them
(ie. user protocol vs. machine protocol).

Converted handlers will use the 'user_print' member of 'mon_cmd_t'
to define its user protocol function, which will be called to print
data in the user protocol format.

Handlers which don't have 'user_print' defined are not converted
and are handled as usual.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c |   32 ++++++++++++++++++++++++++------
 1 files changed, 26 insertions(+), 6 deletions(-)
Anthony Liguori - Oct. 7, 2009, 1:42 a.m.
Luiz Capitulino wrote:
> This commit changes monitor_handle_command() to support old style
> _and_ new style handlers.
>
> New style handlers are protocol independent, they return their
> data to the Monitor, which in turn decides how to print them
> (ie. user protocol vs. machine protocol).
>
> Converted handlers will use the 'user_print' member of 'mon_cmd_t'
> to define its user protocol function, which will be called to print
> data in the user protocol format.
>
> Handlers which don't have 'user_print' defined are not converted
> and are handled as usual.
>
> Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> ---
>  monitor.c |   32 ++++++++++++++++++++++++++------
>  1 files changed, 26 insertions(+), 6 deletions(-)
>
> diff --git a/monitor.c b/monitor.c
> index 9d4c168..c0ba5ee 100644
> --- a/monitor.c
> +++ b/monitor.c
> @@ -211,6 +211,11 @@ static int monitor_fprintf(FILE *stream, const char *fmt, ...)
>      return 0;
>  }
>
> +static inline int monitor_handler_ported(const mon_cmd_t *cmd)
> +{
> +    return cmd->user_print != NULL;
> +}
> +
>  static int compare_cmd(const char *name, const char *list)
>  {
>      const char *p, *pstart;
> @@ -3053,17 +3058,32 @@ static void monitor_handle_command(Monitor *mon, const char *cmdline)
>      qdict = qdict_new();
>
>      cmd = monitor_parse_command(mon, cmdline, qdict);
> -    if (cmd) {
> -        void (*handler)(Monitor *mon, const QDict *qdict);
> +    if (!cmd)
> +        goto out;
> +
> +    qemu_errors_to_mon(mon);
>
> -        qemu_errors_to_mon(mon);
> +    if (monitor_handler_ported(cmd)) {
> +        QObject *data = NULL;
> +        void (*handler_new)(Monitor *mon, const QDict *params,
> +                            QObject **ret_data);
>   

Screams to be a typedef.

> -        handler = cmd->handler;
> -        handler(mon, qdict);
> +        handler_new = cmd->handler;
> +        handler_new(mon, qdict, &data);
>   

At this point, couldn't cmd->handler be a union so we had a bit more 
type safety?
Luiz Capitulino - Oct. 7, 2009, 12:54 p.m.
On Tue, 06 Oct 2009 20:42:47 -0500
Anthony Liguori <aliguori@us.ibm.com> wrote:

> Luiz Capitulino wrote:
> > This commit changes monitor_handle_command() to support old style
> > _and_ new style handlers.
> >
> > New style handlers are protocol independent, they return their
> > data to the Monitor, which in turn decides how to print them
> > (ie. user protocol vs. machine protocol).
> >
> > Converted handlers will use the 'user_print' member of 'mon_cmd_t'
> > to define its user protocol function, which will be called to print
> > data in the user protocol format.
> >
> > Handlers which don't have 'user_print' defined are not converted
> > and are handled as usual.
> >
> > Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> > ---
> >  monitor.c |   32 ++++++++++++++++++++++++++------
> >  1 files changed, 26 insertions(+), 6 deletions(-)
> >
> > diff --git a/monitor.c b/monitor.c
> > index 9d4c168..c0ba5ee 100644
> > --- a/monitor.c
> > +++ b/monitor.c
> > @@ -211,6 +211,11 @@ static int monitor_fprintf(FILE *stream, const char *fmt, ...)
> >      return 0;
> >  }
> >
> > +static inline int monitor_handler_ported(const mon_cmd_t *cmd)
> > +{
> > +    return cmd->user_print != NULL;
> > +}
> > +
> >  static int compare_cmd(const char *name, const char *list)
> >  {
> >      const char *p, *pstart;
> > @@ -3053,17 +3058,32 @@ static void monitor_handle_command(Monitor *mon, const char *cmdline)
> >      qdict = qdict_new();
> >
> >      cmd = monitor_parse_command(mon, cmdline, qdict);
> > -    if (cmd) {
> > -        void (*handler)(Monitor *mon, const QDict *qdict);
> > +    if (!cmd)
> > +        goto out;
> > +
> > +    qemu_errors_to_mon(mon);
> >
> > -        qemu_errors_to_mon(mon);
> > +    if (monitor_handler_ported(cmd)) {
> > +        QObject *data = NULL;
> > +        void (*handler_new)(Monitor *mon, const QDict *params,
> > +                            QObject **ret_data);
> >   
> 
> Screams to be a typedef.
> 
> > -        handler = cmd->handler;
> > -        handler(mon, qdict);
> > +        handler_new = cmd->handler;
> > +        handler_new(mon, qdict, &data);
> >   
> 
> At this point, couldn't cmd->handler be a union so we had a bit more 
> type safety?

 Yes, will do.

Patch

diff --git a/monitor.c b/monitor.c
index 9d4c168..c0ba5ee 100644
--- a/monitor.c
+++ b/monitor.c
@@ -211,6 +211,11 @@  static int monitor_fprintf(FILE *stream, const char *fmt, ...)
     return 0;
 }
 
+static inline int monitor_handler_ported(const mon_cmd_t *cmd)
+{
+    return cmd->user_print != NULL;
+}
+
 static int compare_cmd(const char *name, const char *list)
 {
     const char *p, *pstart;
@@ -3053,17 +3058,32 @@  static void monitor_handle_command(Monitor *mon, const char *cmdline)
     qdict = qdict_new();
 
     cmd = monitor_parse_command(mon, cmdline, qdict);
-    if (cmd) {
-        void (*handler)(Monitor *mon, const QDict *qdict);
+    if (!cmd)
+        goto out;
+
+    qemu_errors_to_mon(mon);
 
-        qemu_errors_to_mon(mon);
+    if (monitor_handler_ported(cmd)) {
+        QObject *data = NULL;
+        void (*handler_new)(Monitor *mon, const QDict *params,
+                            QObject **ret_data);
 
-        handler = cmd->handler;
-        handler(mon, qdict);
+        handler_new = cmd->handler;
+        handler_new(mon, qdict, &data);
 
-        qemu_errors_to_previous();
+        if (data)
+            cmd->user_print(mon, data);
+
+        qobject_decref(data);
+    } else {
+        void (*handler_old)(Monitor *mon, const QDict *qdict);
+        handler_old = cmd->handler;
+        handler_old(mon, qdict);
     }
 
+   qemu_errors_to_previous();
+
+out:
     QDECREF(qdict);
 }