[Qemu-devel] [PATCH v1 0/3]: QMP: Human Monitor passthrough

[Qemu-devel] [PATCH v1 0/3]: QMP: Human Monitor passthrough

[Luiz Capitulino]

Simple example:

-> { "execute": "hmp_passthrough", "arguments": { "command-line": "print /i 10+25" } }
<- { "return": "35\r\n" }

Please, check individual patches for details. Also note that this series
depends on the script improvements one.

Thanks.

[Qemu-devel] [PATCH 1/3] qemu-char: Introduce Buffered driver

[Luiz Capitulino]

This driver handles in-memory chardev operations. That's, all writes
to this driver are stored in an internal buffer and it doesn't talk
to the external world in any way.

Right now it's very simple: it supports only writes. But it can be
easily extended to support more operations.

This is going to be used by the monitor's "HMP passthrough via QMP"
feature, which needs to run monitor handlers without a backing
device.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 qemu-char.c |   63 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 qemu-char.h |    6 +++++
 2 files changed, 69 insertions(+), 0 deletions(-)

diff --git a/qemu-char.c b/qemu-char.c
index 6d2dce7..a4bd09c 100644
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -2279,6 +2279,69 @@ static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
     return NULL;
 }
 
+/***********************************************************/
+/* Buffered chardev */
+typedef struct {
+    size_t outbuf_size;
+    size_t outbuf_capacity;
+    uint8_t *outbuf;
+} BufferedDriver;
+
+static int buffered_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
+{
+    BufferedDriver *d = chr->opaque;
+
+    if (d->outbuf_capacity < (d->outbuf_size + len)) {
+        /* grown outbuf */
+        d->outbuf_capacity += len;
+        d->outbuf_capacity *= 2;
+        d->outbuf = qemu_realloc(d->outbuf, d->outbuf_capacity);
+    }
+
+    memcpy(d->outbuf + d->outbuf_size, buf, len);
+    d->outbuf_size += len;
+
+    return len;
+}
+
+#define DEFAULT_BUF_SIZE 4096
+
+void qemu_chr_init_buffered(CharDriverState *chr)
+{
+    BufferedDriver *d;
+
+    d = qemu_malloc(sizeof(*d));
+    d->outbuf_size = 0;
+    d->outbuf_capacity = DEFAULT_BUF_SIZE;
+    d->outbuf = qemu_mallocz(d->outbuf_capacity);
+
+    memset(chr, 0, sizeof(*chr));
+    chr->opaque = d;
+    chr->chr_write = buffered_chr_write;
+}
+
+/* assumes the stored data is a string */
+QString *qemu_chr_buffered_to_qs(CharDriverState *chr)
+{
+    BufferedDriver *d = chr->opaque;
+
+    if (d->outbuf_size == 0) {
+        return NULL;
+    }
+
+    return qstring_from_substr((char *) d->outbuf, 0, d->outbuf_size - 1);
+}
+
+void qemu_chr_close_buffered(CharDriverState *chr)
+{
+    BufferedDriver *d = chr->opaque;
+
+    qemu_free(d->outbuf);
+    qemu_free(chr->opaque);
+    chr->opaque = NULL;
+    chr->chr_write = NULL;
+}
+
 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
 {
     char host[65], port[33], width[8], height[8];
diff --git a/qemu-char.h b/qemu-char.h
index 18ad12b..4467641 100644
--- a/qemu-char.h
+++ b/qemu-char.h
@@ -6,6 +6,7 @@
 #include "qemu-option.h"
 #include "qemu-config.h"
 #include "qobject.h"
+#include "qstring.h"
 
 /* character device */
 
@@ -100,6 +101,11 @@ CharDriverState *qemu_chr_open_eventfd(int eventfd);
 
 extern int term_escape_char;
 
+/* buffered chardev */
+void qemu_chr_init_buffered(CharDriverState *chr);
+void qemu_chr_close_buffered(CharDriverState *chr);
+QString *qemu_chr_buffered_to_qs(CharDriverState *chr);
+
 /* async I/O support */
 
 int qemu_set_fd_handler2(int fd,
-- 
1.7.3.2.145.g7ebee

[Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Luiz Capitulino]

This command allows QMP clients to execute HMP commands.

Please, check the documentation added to the qmp-commands.hx file
for additional details about the interface and its limitations.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c       |   42 ++++++++++++++++++++++++++++++++++++++++++
 qmp-commands.hx |   45 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+), 0 deletions(-)

diff --git a/monitor.c b/monitor.c
index 61607c5..4fe7f5d 100644
--- a/monitor.c
+++ b/monitor.c
@@ -490,6 +490,48 @@ static int do_qmp_capabilities(Monitor *mon, const QDict *params,
     return 0;
 }
 
+static int mon_set_cpu(int cpu_index);
+static void handle_user_command(Monitor *mon, const char *cmdline);
+
+static int do_hmp_passthrough(Monitor *mon, const QDict *params,
+                              QObject **ret_data)
+{
+    int ret = 0;
+    QString *qs;
+    Monitor *old_mon, hmp;
+    CharDriverState bufchr;
+
+    memset(&hmp, 0, sizeof(hmp));
+    hmp.chr = &bufchr;
+    qemu_chr_init_buffered(hmp.chr);
+
+    old_mon = cur_mon;
+    cur_mon = &hmp;
+
+    if (qdict_haskey(params, "cpu-index")) {
+        ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
+        if (ret < 0) {
+            goto out;
+        }
+    }
+
+    handle_user_command(&hmp, qdict_get_str(params, "command-line"));
+
+    qs = qemu_chr_buffered_to_qs(hmp.chr);
+    if (qs) {
+        *ret_data = QOBJECT(qs);
+    }
+
+out:
+    cur_mon = old_mon;
+    qemu_chr_close_buffered(hmp.chr);
+
+    if (ret < 0) {
+        qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index","a CPU number");
+    }
+    return ret;
+}
+
 static int compare_cmd(const char *name, const char *list)
 {
     const char *p, *pstart;
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 793cf1c..b344096 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -761,6 +761,51 @@ Example:
 
 Note: This command must be issued before issuing any other command.
 
+EQMP
+
+    {
+        .name       = "hmp_passthrough",
+        .args_type  = "command-line:s,cpu-index:i?",
+        .params     = "",
+        .help       = "",
+        .user_print = monitor_user_noop,
+        .mhandler.cmd_new = do_hmp_passthrough,
+    },
+
+SQMP
+hmp_passthrough
+---------------
+
+Execute a Human Monitor command.
+
+Arguments: 
+
+- command-line: the command name and its arguments, just like the
+                Human Monitor's shell (json-string)
+- cpu-index: select the CPU number to be used by commands which access CPU
+             data, like 'info registers'. The Monitor selects CPU 0 if this
+             argument is not provided (json-int, optional)
+
+Example:
+
+-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
+<- { "return": "kvm support: enabled\r\n" }
+
+Notes:
+
+(1) The Human Monitor is NOT an stable interface, this means that command
+    names, arguments and responses can change or be removed at ANY time.
+    Applications that rely on long term stability guarantees should NOT
+    use this command
+
+(2) Limitations:
+
+    o This command is stateless, this means that commands that depend
+      on state information (such as getfd) might not work
+
+    o Commands that prompt the user for data (eg. 'cont' when the block
+      device is encrypted) don't currently work
+
 3. Query Commands
 =================
 
-- 
1.7.3.2.145.g7ebee

[Qemu-devel] [PATCH 3/3] QMP/qmp-shell: Introduce HMP mode

[Luiz Capitulino]

In which qmp-shell will exclusively use the HMP passthrough feature,
this is useful for testing.

Example:

    (QEMU) info network
    VLAN 0 devices:
      user.0: net=10.0.2.0, restricted=n
        e1000.0: model=e1000,macaddr=52:54:00:12:34:56
        Devices not on any VLAN:
    (QEMU)

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 QMP/qmp-shell |   70 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 70 insertions(+), 0 deletions(-)

diff --git a/QMP/qmp-shell b/QMP/qmp-shell
index 1fb7e76..8eb5b3e 100755
--- a/QMP/qmp-shell
+++ b/QMP/qmp-shell
@@ -145,6 +145,72 @@ class QMPShell(qmp.QEMUMonitorProtocol):
         else:
             return self._execute_cmd(cmdline)
 
+class HMPShell(QMPShell):
+    def __init__(self, address):
+        QMPShell.__init__(self, address)
+        self.__cpu_index = 0
+
+    def __cmd_completion(self):
+        for cmd in self.__cmd_passthrough('help')['return'].split('\r\n'):
+            if cmd and cmd[0] != '[' and cmd[0] != '\t':
+                name = cmd.split()[0] # drop help text
+                if name == 'info':
+                    continue
+                if name.find('|') != -1:
+                    # Command in the form 'foobar|f' or 'f|foobar', take the
+                    # full name
+                    opt = name.split('|')
+                    if len(opt[0]) == 1:
+                        name = opt[1]
+                    else:
+                        name = opt[0]
+                self._completer.append(name)
+                self._completer.append('help ' + name) # help completion
+
+    def __info_completion(self):
+        for cmd in self.__cmd_passthrough('info')['return'].split('\r\n'):
+            if cmd:
+                self._completer.append('info ' + cmd.split()[1])
+
+    def __other_completion(self):
+        # special cases
+        self._completer.append('help info')
+
+    def _fill_completion(self):
+        self.__cmd_completion()
+        self.__info_completion()
+        self.__other_completion()
+
+    def __cmd_passthrough(self, cmdline):
+        return self.cmd_obj({ 'execute': 'hmp_passthrough', 'arguments':
+                              { 'command-line': cmdline,
+                                'cpu-index': self.__cpu_index } })
+
+    def _execute_cmd(self, cmdline):
+        if cmdline.split()[0] == "cpu":
+            # trap the cpu command, it requires special setting
+            try:
+                self.__cpu_index = int(cmdline.split()[1])
+            except ValueError:
+                print 'cpu command takes an integer argument'
+                return True
+        resp = self.__cmd_passthrough(cmdline)
+        if resp is None:
+            print 'Disconnected'
+            return False
+        assert 'return' in resp or 'error' in resp
+        if 'return' in resp:
+            # Success
+            if len(resp['return']) > 0:
+                print resp['return'],
+        else:
+            # Error
+            print '%s: %s' % (resp['error']['class'], resp['error']['desc'])
+        return True
+
+    def show_banner(self):
+        QMPShell.show_banner(self, msg='Welcome to the HMP shell!')
+
 def die(msg):
     sys.stderr.write('ERROR: %s\n' % msg)
     sys.exit(1)
@@ -159,6 +225,10 @@ def main():
     try:
         if len(sys.argv) == 2:
             qemu = QMPShell(sys.argv[1])
+        elif len(sys.argv) == 3:
+            if sys.argv[1] != '-H':
+                fail_cmdline(sys.argv[1])
+            qemu = HMPShell(sys.argv[2])
         else:
                 fail_cmdline()
     except QMPShellBadPort:
-- 
1.7.3.2.145.g7ebee

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> This command allows QMP clients to execute HMP commands.
>
> Please, check the documentation added to the qmp-commands.hx file
> for additional details about the interface and its limitations.
>
> Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> ---
>  monitor.c       |   42 ++++++++++++++++++++++++++++++++++++++++++
>  qmp-commands.hx |   45 +++++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 87 insertions(+), 0 deletions(-)
>
> diff --git a/monitor.c b/monitor.c
> index 61607c5..4fe7f5d 100644
> --- a/monitor.c
> +++ b/monitor.c
> @@ -490,6 +490,48 @@ static int do_qmp_capabilities(Monitor *mon, const QDict *params,
>      return 0;
>  }
>  
> +static int mon_set_cpu(int cpu_index);
> +static void handle_user_command(Monitor *mon, const char *cmdline);
> +
> +static int do_hmp_passthrough(Monitor *mon, const QDict *params,
> +                              QObject **ret_data)
> +{
> +    int ret = 0;
> +    QString *qs;
> +    Monitor *old_mon, hmp;
> +    CharDriverState bufchr;
> +
> +    memset(&hmp, 0, sizeof(hmp));
> +    hmp.chr = &bufchr;
> +    qemu_chr_init_buffered(hmp.chr);
> +
> +    old_mon = cur_mon;
> +    cur_mon = &hmp;
> +
> +    if (qdict_haskey(params, "cpu-index")) {
> +        ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
> +        if (ret < 0) {
> +            goto out;
> +        }
> +    }
> +
> +    handle_user_command(&hmp, qdict_get_str(params, "command-line"));
> +
> +    qs = qemu_chr_buffered_to_qs(hmp.chr);
> +    if (qs) {
> +        *ret_data = QOBJECT(qs);
> +    }
> +
> +out:
> +    cur_mon = old_mon;
> +    qemu_chr_close_buffered(hmp.chr);
> +
> +    if (ret < 0) {
> +        qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index","a CPU number");
> +    }

Emit the error right where ret becomes negative.  Cleaner, and allows
for other errors, should they become necessary.

> +    return ret;
> +}
> +
>  static int compare_cmd(const char *name, const char *list)
>  {
>      const char *p, *pstart;
> diff --git a/qmp-commands.hx b/qmp-commands.hx
> index 793cf1c..b344096 100644
> --- a/qmp-commands.hx
> +++ b/qmp-commands.hx
> @@ -761,6 +761,51 @@ Example:
>  
>  Note: This command must be issued before issuing any other command.
>  
> +EQMP
> +
> +    {
> +        .name       = "hmp_passthrough",
> +        .args_type  = "command-line:s,cpu-index:i?",
> +        .params     = "",
> +        .help       = "",
> +        .user_print = monitor_user_noop,
> +        .mhandler.cmd_new = do_hmp_passthrough,
> +    },
> +
> +SQMP
> +hmp_passthrough
> +---------------
> +
> +Execute a Human Monitor command.
> +
> +Arguments: 
> +
> +- command-line: the command name and its arguments, just like the
> +                Human Monitor's shell (json-string)
> +- cpu-index: select the CPU number to be used by commands which access CPU
> +             data, like 'info registers'. The Monitor selects CPU 0 if this
> +             argument is not provided (json-int, optional)
> +
> +Example:
> +
> +-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
> +<- { "return": "kvm support: enabled\r\n" }
> +
> +Notes:
> +
> +(1) The Human Monitor is NOT an stable interface, this means that command
> +    names, arguments and responses can change or be removed at ANY time.
> +    Applications that rely on long term stability guarantees should NOT
> +    use this command
> +
> +(2) Limitations:
> +
> +    o This command is stateless, this means that commands that depend
> +      on state information (such as getfd) might not work
> +
> +    o Commands that prompt the user for data (eg. 'cont' when the block
> +      device is encrypted) don't currently work
> +
>  3. Query Commands
>  =================

In the real human monitor, cpu-index is state (Monitor member mon_cpu).
For pass through, you shift that state into the client (argument
cpu-index).  Is there any other state that could need shifting?  You
mention getfd.

A possible alternative would be to keep the state around instead of
creating a new one for each pass through command.  Dunno, haven't
thought that through.  Maybe you did?

Regardless, this is clearly better than nothing.  We can work on
limitations later, should they turn out to be bothersome.

Re: [Qemu-devel] [PATCH 3/3] QMP/qmp-shell: Introduce HMP mode

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> In which qmp-shell will exclusively use the HMP passthrough feature,
> this is useful for testing.
>
> Example:
>

If you respin anyway, consider inserting something like "$ qmp-shell -H
..." here, to point to the new -H.

>     (QEMU) info network
>     VLAN 0 devices:
>       user.0: net=10.0.2.0, restricted=n
>         e1000.0: model=e1000,macaddr=52:54:00:12:34:56
>         Devices not on any VLAN:
>     (QEMU)
[...]

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Luiz Capitulino]

On Wed, 10 Nov 2010 14:20:12 +0100
Markus Armbruster <armbru@redhat.com> wrote:

> Luiz Capitulino <lcapitulino@redhat.com> writes:
> 
> > This command allows QMP clients to execute HMP commands.
> >
> > Please, check the documentation added to the qmp-commands.hx file
> > for additional details about the interface and its limitations.
> >
> > Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> > ---
> >  monitor.c       |   42 ++++++++++++++++++++++++++++++++++++++++++
> >  qmp-commands.hx |   45 +++++++++++++++++++++++++++++++++++++++++++++
> >  2 files changed, 87 insertions(+), 0 deletions(-)
> >
> > diff --git a/monitor.c b/monitor.c
> > index 61607c5..4fe7f5d 100644
> > --- a/monitor.c
> > +++ b/monitor.c
> > @@ -490,6 +490,48 @@ static int do_qmp_capabilities(Monitor *mon, const QDict *params,
> >      return 0;
> >  }
> >  
> > +static int mon_set_cpu(int cpu_index);
> > +static void handle_user_command(Monitor *mon, const char *cmdline);
> > +
> > +static int do_hmp_passthrough(Monitor *mon, const QDict *params,
> > +                              QObject **ret_data)
> > +{
> > +    int ret = 0;
> > +    QString *qs;
> > +    Monitor *old_mon, hmp;
> > +    CharDriverState bufchr;
> > +
> > +    memset(&hmp, 0, sizeof(hmp));
> > +    hmp.chr = &bufchr;
> > +    qemu_chr_init_buffered(hmp.chr);
> > +
> > +    old_mon = cur_mon;
> > +    cur_mon = &hmp;
> > +
> > +    if (qdict_haskey(params, "cpu-index")) {
> > +        ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
> > +        if (ret < 0) {
> > +            goto out;
> > +        }
> > +    }
> > +
> > +    handle_user_command(&hmp, qdict_get_str(params, "command-line"));
> > +
> > +    qs = qemu_chr_buffered_to_qs(hmp.chr);
> > +    if (qs) {
> > +        *ret_data = QOBJECT(qs);
> > +    }
> > +
> > +out:
> > +    cur_mon = old_mon;
> > +    qemu_chr_close_buffered(hmp.chr);
> > +
> > +    if (ret < 0) {
> > +        qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index","a CPU number");
> > +    }
> 
> Emit the error right where ret becomes negative.  Cleaner, and allows
> for other errors, should they become necessary.
> 
> > +    return ret;
> > +}
> > +
> >  static int compare_cmd(const char *name, const char *list)
> >  {
> >      const char *p, *pstart;
> > diff --git a/qmp-commands.hx b/qmp-commands.hx
> > index 793cf1c..b344096 100644
> > --- a/qmp-commands.hx
> > +++ b/qmp-commands.hx
> > @@ -761,6 +761,51 @@ Example:
> >  
> >  Note: This command must be issued before issuing any other command.
> >  
> > +EQMP
> > +
> > +    {
> > +        .name       = "hmp_passthrough",
> > +        .args_type  = "command-line:s,cpu-index:i?",
> > +        .params     = "",
> > +        .help       = "",
> > +        .user_print = monitor_user_noop,
> > +        .mhandler.cmd_new = do_hmp_passthrough,
> > +    },
> > +
> > +SQMP
> > +hmp_passthrough
> > +---------------
> > +
> > +Execute a Human Monitor command.
> > +
> > +Arguments: 
> > +
> > +- command-line: the command name and its arguments, just like the
> > +                Human Monitor's shell (json-string)
> > +- cpu-index: select the CPU number to be used by commands which access CPU
> > +             data, like 'info registers'. The Monitor selects CPU 0 if this
> > +             argument is not provided (json-int, optional)
> > +
> > +Example:
> > +
> > +-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
> > +<- { "return": "kvm support: enabled\r\n" }
> > +
> > +Notes:
> > +
> > +(1) The Human Monitor is NOT an stable interface, this means that command
> > +    names, arguments and responses can change or be removed at ANY time.
> > +    Applications that rely on long term stability guarantees should NOT
> > +    use this command
> > +
> > +(2) Limitations:
> > +
> > +    o This command is stateless, this means that commands that depend
> > +      on state information (such as getfd) might not work
> > +
> > +    o Commands that prompt the user for data (eg. 'cont' when the block
> > +      device is encrypted) don't currently work
> > +
> >  3. Query Commands
> >  =================
> 
> In the real human monitor, cpu-index is state (Monitor member mon_cpu).
> For pass through, you shift that state into the client (argument
> cpu-index).  Is there any other state that could need shifting?  You
> mention getfd.

Surprisingly or not, this is a very important question for QMP itself.

Anthony has said that we should make it stateless, and I do think this
is good because it seems to simplify things considerably.

However, I haven't thought about how to make things like getfd stateless.

> A possible alternative would be to keep the state around instead of
> creating a new one for each pass through command.  Dunno, haven't
> thought that through.  Maybe you did?

It's above ;) becoming stateless seems to be the way for QMP.

> Regardless, this is clearly better than nothing.  We can work on
> limitations later, should they turn out to be bothersome.

Agreed.

[Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Luiz Capitulino]

This command allows QMP clients to execute HMP commands.

Please, check the documentation added to the qmp-commands.hx file
for additional details about the interface and its limitations.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c       |   39 +++++++++++++++++++++++++++++++++++++++
 qmp-commands.hx |   45 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 0 deletions(-)

diff --git a/monitor.c b/monitor.c
index 8cee35d..89513be 100644
--- a/monitor.c
+++ b/monitor.c
@@ -491,6 +491,45 @@ static int do_qmp_capabilities(Monitor *mon, const QDict *params,
     return 0;
 }
 
+static int mon_set_cpu(int cpu_index);
+static void handle_user_command(Monitor *mon, const char *cmdline);
+
+static int do_hmp_passthrough(Monitor *mon, const QDict *params,
+                              QObject **ret_data)
+{
+    int ret = 0;
+    QString *qs;
+    Monitor *old_mon, hmp;
+    CharDriverState memchr;
+
+    memset(&hmp, 0, sizeof(hmp));
+    hmp.chr = &memchr;
+    qemu_chr_init_mem(hmp.chr);
+
+    old_mon = cur_mon;
+    cur_mon = &hmp;
+
+    if (qdict_haskey(params, "cpu-index")) {
+        ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
+        if (ret < 0) {
+            qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
+            goto out;
+        }
+    }
+
+    handle_user_command(&hmp, qdict_get_str(params, "command-line"));
+
+    qs = qemu_chr_mem_to_qs(hmp.chr);
+    if (qs) {
+        *ret_data = QOBJECT(qs);
+    }
+
+out:
+    cur_mon = old_mon;
+    qemu_chr_close_mem(hmp.chr);
+    return ret;
+}
+
 static int compare_cmd(const char *name, const char *list)
 {
     const char *p, *pstart;
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 793cf1c..b344096 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -761,6 +761,51 @@ Example:
 
 Note: This command must be issued before issuing any other command.
 
+EQMP
+
+    {
+        .name       = "hmp_passthrough",
+        .args_type  = "command-line:s,cpu-index:i?",
+        .params     = "",
+        .help       = "",
+        .user_print = monitor_user_noop,
+        .mhandler.cmd_new = do_hmp_passthrough,
+    },
+
+SQMP
+hmp_passthrough
+---------------
+
+Execute a Human Monitor command.
+
+Arguments: 
+
+- command-line: the command name and its arguments, just like the
+                Human Monitor's shell (json-string)
+- cpu-index: select the CPU number to be used by commands which access CPU
+             data, like 'info registers'. The Monitor selects CPU 0 if this
+             argument is not provided (json-int, optional)
+
+Example:
+
+-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
+<- { "return": "kvm support: enabled\r\n" }
+
+Notes:
+
+(1) The Human Monitor is NOT an stable interface, this means that command
+    names, arguments and responses can change or be removed at ANY time.
+    Applications that rely on long term stability guarantees should NOT
+    use this command
+
+(2) Limitations:
+
+    o This command is stateless, this means that commands that depend
+      on state information (such as getfd) might not work
+
+    o Commands that prompt the user for data (eg. 'cont' when the block
+      device is encrypted) don't currently work
+
 3. Query Commands
 =================
 
-- 
1.7.3.2.164.g6f10c

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> On Wed, 10 Nov 2010 14:20:12 +0100
> Markus Armbruster <armbru@redhat.com> wrote:
>
>> Luiz Capitulino <lcapitulino@redhat.com> writes:
[...]
>> > diff --git a/qmp-commands.hx b/qmp-commands.hx
>> > index 793cf1c..b344096 100644
>> > --- a/qmp-commands.hx
>> > +++ b/qmp-commands.hx
>> > @@ -761,6 +761,51 @@ Example:
>> >  
>> >  Note: This command must be issued before issuing any other command.
>> >  
>> > +EQMP
>> > +
>> > +    {
>> > +        .name       = "hmp_passthrough",
>> > +        .args_type  = "command-line:s,cpu-index:i?",
>> > +        .params     = "",
>> > +        .help       = "",
>> > +        .user_print = monitor_user_noop,
>> > +        .mhandler.cmd_new = do_hmp_passthrough,
>> > +    },
>> > +
>> > +SQMP
>> > +hmp_passthrough
>> > +---------------
>> > +
>> > +Execute a Human Monitor command.
>> > +
>> > +Arguments: 
>> > +
>> > +- command-line: the command name and its arguments, just like the
>> > +                Human Monitor's shell (json-string)
>> > +- cpu-index: select the CPU number to be used by commands which access CPU
>> > +             data, like 'info registers'. The Monitor selects CPU 0 if this
>> > +             argument is not provided (json-int, optional)
>> > +
>> > +Example:
>> > +
>> > +-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
>> > +<- { "return": "kvm support: enabled\r\n" }
>> > +
>> > +Notes:
>> > +
>> > +(1) The Human Monitor is NOT an stable interface, this means that command
>> > +    names, arguments and responses can change or be removed at ANY time.
>> > +    Applications that rely on long term stability guarantees should NOT
>> > +    use this command
>> > +
>> > +(2) Limitations:
>> > +
>> > +    o This command is stateless, this means that commands that depend
>> > +      on state information (such as getfd) might not work
>> > +
>> > +    o Commands that prompt the user for data (eg. 'cont' when the block
>> > +      device is encrypted) don't currently work
>> > +
>> >  3. Query Commands
>> >  =================
>> 
>> In the real human monitor, cpu-index is state (Monitor member mon_cpu).
>> For pass through, you shift that state into the client (argument
>> cpu-index).  Is there any other state that could need shifting?  You
>> mention getfd.
>
> Surprisingly or not, this is a very important question for QMP itself.
>
> Anthony has said that we should make it stateless, and I do think this
> is good because it seems to simplify things considerably.
>
> However, I haven't thought about how to make things like getfd stateless.

Hmm, that sounds like we should investigate the getfd problem sooner
rather than later.

[...]

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> This command allows QMP clients to execute HMP commands.
>
> Please, check the documentation added to the qmp-commands.hx file
> for additional details about the interface and its limitations.
>
> Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> ---
>  monitor.c       |   39 +++++++++++++++++++++++++++++++++++++++
>  qmp-commands.hx |   45 +++++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 84 insertions(+), 0 deletions(-)
>
> diff --git a/monitor.c b/monitor.c
> index 8cee35d..89513be 100644
> --- a/monitor.c
> +++ b/monitor.c
> @@ -491,6 +491,45 @@ static int do_qmp_capabilities(Monitor *mon, const QDict *params,
>      return 0;
>  }
>  
> +static int mon_set_cpu(int cpu_index);
> +static void handle_user_command(Monitor *mon, const char *cmdline);
> +
> +static int do_hmp_passthrough(Monitor *mon, const QDict *params,
> +                              QObject **ret_data)
> +{
> +    int ret = 0;
> +    QString *qs;
> +    Monitor *old_mon, hmp;
> +    CharDriverState memchr;

Uh, let's not shadow memchr() from string.h.

> +
> +    memset(&hmp, 0, sizeof(hmp));
> +    hmp.chr = &memchr;
> +    qemu_chr_init_mem(hmp.chr);
> +
> +    old_mon = cur_mon;
> +    cur_mon = &hmp;
> +
> +    if (qdict_haskey(params, "cpu-index")) {
> +        ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
> +        if (ret < 0) {
> +            qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
> +            goto out;
> +        }
> +    }
> +
> +    handle_user_command(&hmp, qdict_get_str(params, "command-line"));

It would sure be nice if handle_user_command() returned status...  But
fixing that is out of this patch series' scope.

> +
> +    qs = qemu_chr_mem_to_qs(hmp.chr);
> +    if (qs) {
> +        *ret_data = QOBJECT(qs);
> +    }

Conditional goes away when qemu_chr_mem_to_qs() is changed not to return
NULL for empty character device.

> +
> +out:
> +    cur_mon = old_mon;
> +    qemu_chr_close_mem(hmp.chr);
> +    return ret;
> +}
> +
>  static int compare_cmd(const char *name, const char *list)
>  {
>      const char *p, *pstart;
> diff --git a/qmp-commands.hx b/qmp-commands.hx
> index 793cf1c..b344096 100644
> --- a/qmp-commands.hx
> +++ b/qmp-commands.hx
> @@ -761,6 +761,51 @@ Example:
>  
>  Note: This command must be issued before issuing any other command.
>  
> +EQMP
> +
> +    {
> +        .name       = "hmp_passthrough",
> +        .args_type  = "command-line:s,cpu-index:i?",
> +        .params     = "",
> +        .help       = "",
> +        .user_print = monitor_user_noop,
> +        .mhandler.cmd_new = do_hmp_passthrough,
> +    },
> +
> +SQMP
> +hmp_passthrough
> +---------------
> +
> +Execute a Human Monitor command.
> +
> +Arguments: 
> +
> +- command-line: the command name and its arguments, just like the
> +                Human Monitor's shell (json-string)
> +- cpu-index: select the CPU number to be used by commands which access CPU
> +             data, like 'info registers'. The Monitor selects CPU 0 if this
> +             argument is not provided (json-int, optional)
> +
> +Example:
> +
> +-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
> +<- { "return": "kvm support: enabled\r\n" }
> +
> +Notes:
> +
> +(1) The Human Monitor is NOT an stable interface, this means that command
> +    names, arguments and responses can change or be removed at ANY time.
> +    Applications that rely on long term stability guarantees should NOT
> +    use this command
> +
> +(2) Limitations:
> +
> +    o This command is stateless, this means that commands that depend
> +      on state information (such as getfd) might not work
> +
> +    o Commands that prompt the user for data (eg. 'cont' when the block
> +      device is encrypted) don't currently work
> +
>  3. Query Commands
>  =================

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Daniel P. Berrange]

On Thu, Nov 11, 2010 at 04:47:41PM +0100, Markus Armbruster wrote:
> Luiz Capitulino <lcapitulino@redhat.com> writes:
> 
> > On Wed, 10 Nov 2010 14:20:12 +0100
> > Markus Armbruster <armbru@redhat.com> wrote:
> >
> >> Luiz Capitulino <lcapitulino@redhat.com> writes:
> [...]
> >> > diff --git a/qmp-commands.hx b/qmp-commands.hx
> >> > index 793cf1c..b344096 100644
> >> > --- a/qmp-commands.hx
> >> > +++ b/qmp-commands.hx
> >> > @@ -761,6 +761,51 @@ Example:
> >> >  
> >> >  Note: This command must be issued before issuing any other command.
> >> >  
> >> > +EQMP
> >> > +
> >> > +    {
> >> > +        .name       = "hmp_passthrough",
> >> > +        .args_type  = "command-line:s,cpu-index:i?",
> >> > +        .params     = "",
> >> > +        .help       = "",
> >> > +        .user_print = monitor_user_noop,
> >> > +        .mhandler.cmd_new = do_hmp_passthrough,
> >> > +    },
> >> > +
> >> > +SQMP
> >> > +hmp_passthrough
> >> > +---------------
> >> > +
> >> > +Execute a Human Monitor command.
> >> > +
> >> > +Arguments: 
> >> > +
> >> > +- command-line: the command name and its arguments, just like the
> >> > +                Human Monitor's shell (json-string)
> >> > +- cpu-index: select the CPU number to be used by commands which access CPU
> >> > +             data, like 'info registers'. The Monitor selects CPU 0 if this
> >> > +             argument is not provided (json-int, optional)
> >> > +
> >> > +Example:
> >> > +
> >> > +-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
> >> > +<- { "return": "kvm support: enabled\r\n" }
> >> > +
> >> > +Notes:
> >> > +
> >> > +(1) The Human Monitor is NOT an stable interface, this means that command
> >> > +    names, arguments and responses can change or be removed at ANY time.
> >> > +    Applications that rely on long term stability guarantees should NOT
> >> > +    use this command
> >> > +
> >> > +(2) Limitations:
> >> > +
> >> > +    o This command is stateless, this means that commands that depend
> >> > +      on state information (such as getfd) might not work
> >> > +
> >> > +    o Commands that prompt the user for data (eg. 'cont' when the block
> >> > +      device is encrypted) don't currently work
> >> > +
> >> >  3. Query Commands
> >> >  =================
> >> 
> >> In the real human monitor, cpu-index is state (Monitor member mon_cpu).
> >> For pass through, you shift that state into the client (argument
> >> cpu-index).  Is there any other state that could need shifting?  You
> >> mention getfd.
> >
> > Surprisingly or not, this is a very important question for QMP itself.
> >
> > Anthony has said that we should make it stateless, and I do think this
> > is good because it seems to simplify things considerably.
> >
> > However, I haven't thought about how to make things like getfd stateless.
> 
> Hmm, that sounds like we should investigate the getfd problem sooner
> rather than later.

The SCM_RIGHTS code allows you to send/receive multiple file handles in a 
single sendmsg/recvmsg  call. So why don't we just allow sending of the
file handles with the monitor command that actually needs them, instead of
ahead of time using send_fd. This simplifies life for the client because
they also don't have to worry about cleanup using close_fd if the command
using the FD fails.

Regards,
Daniel
-- 
|: Red Hat, Engineering, London    -o-   http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://deltacloud.org :|
|: http://autobuild.org        -o-         http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505  -o-   F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|

Re: [Qemu-devel] [PATCH v1 0/3]: QMP: Human Monitor passthrough

[Avi Kivity]

On 10/29/2010 04:28 PM, Luiz Capitulino wrote:
> Simple example:
>
> ->  { "execute": "hmp_passthrough", "arguments": { "command-line": "print /i 10+25" } }
> <- { "return": "35\r\n" }
>

Why are the names so cryptic?

-> { "execute": "human-monitor-command", ... }
<- { "return": "42\r\n" }

-- 
error compiling committee.c: too many arguments to function

Re: [Qemu-devel] [PATCH v1 0/3]: QMP: Human Monitor passthrough

[Luiz Capitulino]

On Thu, 11 Nov 2010 18:22:13 +0200
Avi Kivity <avi@redhat.com> wrote:

> On 10/29/2010 04:28 PM, Luiz Capitulino wrote:
> > Simple example:
> >
> > ->  { "execute": "hmp_passthrough", "arguments": { "command-line": "print /i 10+25" } }
> > <- { "return": "35\r\n" }
> >
> 
> Why are the names so cryptic?
> 
> -> { "execute": "human-monitor-command", ... }

Hm, Markus suggested something like it.

> <- { "return": "42\r\n" }

My examples are so boring...

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Anthony Liguori]

On 11/11/2010 09:55 AM, Daniel P. Berrange wrote:
> On Thu, Nov 11, 2010 at 04:47:41PM +0100, Markus Armbruster wrote:
>    
>> Luiz Capitulino<lcapitulino@redhat.com>  writes:
>>
>>      
>>> On Wed, 10 Nov 2010 14:20:12 +0100
>>> Markus Armbruster<armbru@redhat.com>  wrote:
>>>
>>>        
>>>> Luiz Capitulino<lcapitulino@redhat.com>  writes:
>>>>          
>> [...]
>>      
>>>>> diff --git a/qmp-commands.hx b/qmp-commands.hx
>>>>> index 793cf1c..b344096 100644
>>>>> --- a/qmp-commands.hx
>>>>> +++ b/qmp-commands.hx
>>>>> @@ -761,6 +761,51 @@ Example:
>>>>>
>>>>>   Note: This command must be issued before issuing any other command.
>>>>>
>>>>> +EQMP
>>>>> +
>>>>> +    {
>>>>> +        .name       = "hmp_passthrough",
>>>>> +        .args_type  = "command-line:s,cpu-index:i?",
>>>>> +        .params     = "",
>>>>> +        .help       = "",
>>>>> +        .user_print = monitor_user_noop,
>>>>> +        .mhandler.cmd_new = do_hmp_passthrough,
>>>>> +    },
>>>>> +
>>>>> +SQMP
>>>>> +hmp_passthrough
>>>>> +---------------
>>>>> +
>>>>> +Execute a Human Monitor command.
>>>>> +
>>>>> +Arguments:
>>>>> +
>>>>> +- command-line: the command name and its arguments, just like the
>>>>> +                Human Monitor's shell (json-string)
>>>>> +- cpu-index: select the CPU number to be used by commands which access CPU
>>>>> +             data, like 'info registers'. The Monitor selects CPU 0 if this
>>>>> +             argument is not provided (json-int, optional)
>>>>> +
>>>>> +Example:
>>>>> +
>>>>> +->  { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
>>>>> +<- { "return": "kvm support: enabled\r\n" }
>>>>> +
>>>>> +Notes:
>>>>> +
>>>>> +(1) The Human Monitor is NOT an stable interface, this means that command
>>>>> +    names, arguments and responses can change or be removed at ANY time.
>>>>> +    Applications that rely on long term stability guarantees should NOT
>>>>> +    use this command
>>>>> +
>>>>> +(2) Limitations:
>>>>> +
>>>>> +    o This command is stateless, this means that commands that depend
>>>>> +      on state information (such as getfd) might not work
>>>>> +
>>>>> +    o Commands that prompt the user for data (eg. 'cont' when the block
>>>>> +      device is encrypted) don't currently work
>>>>> +
>>>>>   3. Query Commands
>>>>>   =================
>>>>>            
>>>> In the real human monitor, cpu-index is state (Monitor member mon_cpu).
>>>> For pass through, you shift that state into the client (argument
>>>> cpu-index).  Is there any other state that could need shifting?  You
>>>> mention getfd.
>>>>          
>>> Surprisingly or not, this is a very important question for QMP itself.
>>>
>>> Anthony has said that we should make it stateless, and I do think this
>>> is good because it seems to simplify things considerably.
>>>
>>> However, I haven't thought about how to make things like getfd stateless.
>>>        
>> Hmm, that sounds like we should investigate the getfd problem sooner
>> rather than later.
>>      
> The SCM_RIGHTS code allows you to send/receive multiple file handles in a
> single sendmsg/recvmsg  call. So why don't we just allow sending of the
> file handles with the monitor command that actually needs them, instead of
> ahead of time using send_fd. This simplifies life for the client because
> they also don't have to worry about cleanup using close_fd if the command
> using the FD fails.
>    

How do we identify file descriptors and then map them to a command?

Regards,

Anthony Liguori

> Regards,
> Daniel
>    

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Daniel P. Berrange]

On Thu, Nov 11, 2010 at 10:30:47AM -0600, Anthony Liguori wrote:
> On 11/11/2010 09:55 AM, Daniel P. Berrange wrote:
> >On Thu, Nov 11, 2010 at 04:47:41PM +0100, Markus Armbruster wrote:
> >>>>>  3. Query Commands
> >>>>>  =================
> >>>>>           
> >>>>In the real human monitor, cpu-index is state (Monitor member mon_cpu).
> >>>>For pass through, you shift that state into the client (argument
> >>>>cpu-index).  Is there any other state that could need shifting?  You
> >>>>mention getfd.
> >>>>         
> >>>Surprisingly or not, this is a very important question for QMP itself.
> >>>
> >>>Anthony has said that we should make it stateless, and I do think this
> >>>is good because it seems to simplify things considerably.
> >>>
> >>>However, I haven't thought about how to make things like getfd stateless.
> >>>       
> >>Hmm, that sounds like we should investigate the getfd problem sooner
> >>rather than later.
> >>     
> >The SCM_RIGHTS code allows you to send/receive multiple file handles in a
> >single sendmsg/recvmsg  call. So why don't we just allow sending of the
> >file handles with the monitor command that actually needs them, instead of
> >ahead of time using send_fd. This simplifies life for the client because
> >they also don't have to worry about cleanup using close_fd if the command
> >using the FD fails.
> 
> How do we identify file descriptors and then map them to a command?

IIUC, the FDs sent/received via struct cmsghdr are in a strictly
ordered array, so why not just define a placeholder syntax for
the commands that maps to the array indexes. eg

  netdev_add tap,fd=$0,vhost_fd=$1,id=hostnet0 

The '$' sign is not valid for a normal FD number, so use of a $0,
$1, $2, etc can reliably be substituted with the real FD number from
the cmsghdr array elements 0, 1, 2, etc

Regards,
Daniel
-- 
|: Red Hat, Engineering, London    -o-   http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://deltacloud.org :|
|: http://autobuild.org        -o-         http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505  -o-   F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Luiz Capitulino]

On Thu, 11 Nov 2010 16:39:52 +0000
"Daniel P. Berrange" <berrange@redhat.com> wrote:

> On Thu, Nov 11, 2010 at 10:30:47AM -0600, Anthony Liguori wrote:
> > On 11/11/2010 09:55 AM, Daniel P. Berrange wrote:
> > >On Thu, Nov 11, 2010 at 04:47:41PM +0100, Markus Armbruster wrote:
> > >>>>>  3. Query Commands
> > >>>>>  =================
> > >>>>>           
> > >>>>In the real human monitor, cpu-index is state (Monitor member mon_cpu).
> > >>>>For pass through, you shift that state into the client (argument
> > >>>>cpu-index).  Is there any other state that could need shifting?  You
> > >>>>mention getfd.
> > >>>>         
> > >>>Surprisingly or not, this is a very important question for QMP itself.
> > >>>
> > >>>Anthony has said that we should make it stateless, and I do think this
> > >>>is good because it seems to simplify things considerably.
> > >>>
> > >>>However, I haven't thought about how to make things like getfd stateless.
> > >>>       
> > >>Hmm, that sounds like we should investigate the getfd problem sooner
> > >>rather than later.
> > >>     
> > >The SCM_RIGHTS code allows you to send/receive multiple file handles in a
> > >single sendmsg/recvmsg  call. So why don't we just allow sending of the
> > >file handles with the monitor command that actually needs them, instead of
> > >ahead of time using send_fd. This simplifies life for the client because
> > >they also don't have to worry about cleanup using close_fd if the command
> > >using the FD fails.
> > 
> > How do we identify file descriptors and then map them to a command?
> 
> IIUC, the FDs sent/received via struct cmsghdr are in a strictly
> ordered array, so why not just define a placeholder syntax for
> the commands that maps to the array indexes. eg
> 
>   netdev_add tap,fd=$0,vhost_fd=$1,id=hostnet0 
> 
> The '$' sign is not valid for a normal FD number, so use of a $0,
> $1, $2, etc can reliably be substituted with the real FD number from
> the cmsghdr array elements 0, 1, 2, etc

I have the impression that the real problem is that they are being
stored in the wrong place (ie. the monitor), *maybe* they should be stored
somewhere else, ie. a special chardev or something.

Today those fds are linked to a given monitor session..

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Luiz Capitulino]

On Thu, 11 Nov 2010 16:47:41 +0100
Markus Armbruster <armbru@redhat.com> wrote:

> Luiz Capitulino <lcapitulino@redhat.com> writes:
> 
> > On Wed, 10 Nov 2010 14:20:12 +0100
> > Markus Armbruster <armbru@redhat.com> wrote:
> >
> >> Luiz Capitulino <lcapitulino@redhat.com> writes:
> [...]
> >> > diff --git a/qmp-commands.hx b/qmp-commands.hx
> >> > index 793cf1c..b344096 100644
> >> > --- a/qmp-commands.hx
> >> > +++ b/qmp-commands.hx
> >> > @@ -761,6 +761,51 @@ Example:
> >> >  
> >> >  Note: This command must be issued before issuing any other command.
> >> >  
> >> > +EQMP
> >> > +
> >> > +    {
> >> > +        .name       = "hmp_passthrough",
> >> > +        .args_type  = "command-line:s,cpu-index:i?",
> >> > +        .params     = "",
> >> > +        .help       = "",
> >> > +        .user_print = monitor_user_noop,
> >> > +        .mhandler.cmd_new = do_hmp_passthrough,
> >> > +    },
> >> > +
> >> > +SQMP
> >> > +hmp_passthrough
> >> > +---------------
> >> > +
> >> > +Execute a Human Monitor command.
> >> > +
> >> > +Arguments: 
> >> > +
> >> > +- command-line: the command name and its arguments, just like the
> >> > +                Human Monitor's shell (json-string)
> >> > +- cpu-index: select the CPU number to be used by commands which access CPU
> >> > +             data, like 'info registers'. The Monitor selects CPU 0 if this
> >> > +             argument is not provided (json-int, optional)
> >> > +
> >> > +Example:
> >> > +
> >> > +-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
> >> > +<- { "return": "kvm support: enabled\r\n" }
> >> > +
> >> > +Notes:
> >> > +
> >> > +(1) The Human Monitor is NOT an stable interface, this means that command
> >> > +    names, arguments and responses can change or be removed at ANY time.
> >> > +    Applications that rely on long term stability guarantees should NOT
> >> > +    use this command
> >> > +
> >> > +(2) Limitations:
> >> > +
> >> > +    o This command is stateless, this means that commands that depend
> >> > +      on state information (such as getfd) might not work
> >> > +
> >> > +    o Commands that prompt the user for data (eg. 'cont' when the block
> >> > +      device is encrypted) don't currently work
> >> > +
> >> >  3. Query Commands
> >> >  =================
> >> 
> >> In the real human monitor, cpu-index is state (Monitor member mon_cpu).
> >> For pass through, you shift that state into the client (argument
> >> cpu-index).  Is there any other state that could need shifting?  You
> >> mention getfd.
> >
> > Surprisingly or not, this is a very important question for QMP itself.
> >
> > Anthony has said that we should make it stateless, and I do think this
> > is good because it seems to simplify things considerably.
> >
> > However, I haven't thought about how to make things like getfd stateless.
> 
> Hmm, that sounds like we should investigate the getfd problem sooner
> rather than later.

Absolutely, but this shouldn't prevent this series of being merged, right?

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Anthony Liguori]

On 11/11/2010 10:39 AM, Daniel P. Berrange wrote:
> IIUC, the FDs sent/received via struct cmsghdr are in a strictly
> ordered array, so why not just define a placeholder syntax for
> the commands that maps to the array indexes. eg
>
>    netdev_add tap,fd=$0,vhost_fd=$1,id=hostnet0
>
> The '$' sign is not valid for a normal FD number, so use of a $0,
> $1, $2, etc can reliably be substituted with the real FD number from
> the cmsghdr array elements 0, 1, 2, etc
>    

Character devices are streaming so it's hard to refer to array indexes 
in a single message.  You could count it for the entire session but 
session boundaries aren't really well defined.

I don't think it's an obvious win.

Regards,

Anthony Liguori

> Regards,
> Daniel
>    

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Anthony Liguori]

On 11/11/2010 10:55 AM, Luiz Capitulino wrote:
> On Thu, 11 Nov 2010 16:47:41 +0100
> Markus Armbruster<armbru@redhat.com>  wrote:
>
>    
>> Luiz Capitulino<lcapitulino@redhat.com>  writes:
>>
>>      
>>> On Wed, 10 Nov 2010 14:20:12 +0100
>>> Markus Armbruster<armbru@redhat.com>  wrote:
>>>
>>>        
>>>> Luiz Capitulino<lcapitulino@redhat.com>  writes:
>>>>          
>> [...]
>>      
>>>>> diff --git a/qmp-commands.hx b/qmp-commands.hx
>>>>> index 793cf1c..b344096 100644
>>>>> --- a/qmp-commands.hx
>>>>> +++ b/qmp-commands.hx
>>>>> @@ -761,6 +761,51 @@ Example:
>>>>>
>>>>>   Note: This command must be issued before issuing any other command.
>>>>>
>>>>> +EQMP
>>>>> +
>>>>> +    {
>>>>> +        .name       = "hmp_passthrough",
>>>>> +        .args_type  = "command-line:s,cpu-index:i?",
>>>>> +        .params     = "",
>>>>> +        .help       = "",
>>>>> +        .user_print = monitor_user_noop,
>>>>> +        .mhandler.cmd_new = do_hmp_passthrough,
>>>>> +    },
>>>>> +
>>>>> +SQMP
>>>>> +hmp_passthrough
>>>>> +---------------
>>>>> +
>>>>> +Execute a Human Monitor command.
>>>>> +
>>>>> +Arguments:
>>>>> +
>>>>> +- command-line: the command name and its arguments, just like the
>>>>> +                Human Monitor's shell (json-string)
>>>>> +- cpu-index: select the CPU number to be used by commands which access CPU
>>>>> +             data, like 'info registers'. The Monitor selects CPU 0 if this
>>>>> +             argument is not provided (json-int, optional)
>>>>> +
>>>>> +Example:
>>>>> +
>>>>> +->  { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
>>>>> +<- { "return": "kvm support: enabled\r\n" }
>>>>> +
>>>>> +Notes:
>>>>> +
>>>>> +(1) The Human Monitor is NOT an stable interface, this means that command
>>>>> +    names, arguments and responses can change or be removed at ANY time.
>>>>> +    Applications that rely on long term stability guarantees should NOT
>>>>> +    use this command
>>>>> +
>>>>> +(2) Limitations:
>>>>> +
>>>>> +    o This command is stateless, this means that commands that depend
>>>>> +      on state information (such as getfd) might not work
>>>>> +
>>>>> +    o Commands that prompt the user for data (eg. 'cont' when the block
>>>>> +      device is encrypted) don't currently work
>>>>> +
>>>>>   3. Query Commands
>>>>>   =================
>>>>>            
>>>> In the real human monitor, cpu-index is state (Monitor member mon_cpu).
>>>> For pass through, you shift that state into the client (argument
>>>> cpu-index).  Is there any other state that could need shifting?  You
>>>> mention getfd.
>>>>          
>>> Surprisingly or not, this is a very important question for QMP itself.
>>>
>>> Anthony has said that we should make it stateless, and I do think this
>>> is good because it seems to simplify things considerably.
>>>
>>> However, I haven't thought about how to make things like getfd stateless.
>>>        
>> Hmm, that sounds like we should investigate the getfd problem sooner
>> rather than later.
>>      
> Absolutely, but this shouldn't prevent this series of being merged, right?
>    

BTW, don't we have all of the fd= commands covered in QMP already?

Regards,

Anthony Liguori

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Luiz Capitulino]

On Thu, 11 Nov 2010 16:47:52 +0100
Markus Armbruster <armbru@redhat.com> wrote:

> Luiz Capitulino <lcapitulino@redhat.com> writes:
> 
> > This command allows QMP clients to execute HMP commands.
> >
> > Please, check the documentation added to the qmp-commands.hx file
> > for additional details about the interface and its limitations.
> >
> > Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> > ---
> >  monitor.c       |   39 +++++++++++++++++++++++++++++++++++++++
> >  qmp-commands.hx |   45 +++++++++++++++++++++++++++++++++++++++++++++
> >  2 files changed, 84 insertions(+), 0 deletions(-)
> >
> > diff --git a/monitor.c b/monitor.c
> > index 8cee35d..89513be 100644
> > --- a/monitor.c
> > +++ b/monitor.c
> > @@ -491,6 +491,45 @@ static int do_qmp_capabilities(Monitor *mon, const QDict *params,
> >      return 0;
> >  }
> >  
> > +static int mon_set_cpu(int cpu_index);
> > +static void handle_user_command(Monitor *mon, const char *cmdline);
> > +
> > +static int do_hmp_passthrough(Monitor *mon, const QDict *params,
> > +                              QObject **ret_data)
> > +{
> > +    int ret = 0;
> > +    QString *qs;
> > +    Monitor *old_mon, hmp;
> > +    CharDriverState memchr;
> 
> Uh, let's not shadow memchr() from string.h.

Ah, good catch.

> 
> > +
> > +    memset(&hmp, 0, sizeof(hmp));
> > +    hmp.chr = &memchr;
> > +    qemu_chr_init_mem(hmp.chr);
> > +
> > +    old_mon = cur_mon;
> > +    cur_mon = &hmp;
> > +
> > +    if (qdict_haskey(params, "cpu-index")) {
> > +        ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
> > +        if (ret < 0) {
> > +            qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
> > +            goto out;
> > +        }
> > +    }
> > +
> > +    handle_user_command(&hmp, qdict_get_str(params, "command-line"));
> 
> It would sure be nice if handle_user_command() returned status...  But
> fixing that is out of this patch series' scope.
> 
> > +
> > +    qs = qemu_chr_mem_to_qs(hmp.chr);
> > +    if (qs) {
> > +        *ret_data = QOBJECT(qs);
> > +    }
> 
> Conditional goes away when qemu_chr_mem_to_qs() is changed not to return
> NULL for empty character device.

If we do this, then our success response is going to be "", like:

{ "execute": "execute": "hmp_passthrough", "arguments": { "command-line": "stop" } }
{ "return": "" }

Today, it's:

{ "execute": "execute": "hmp_passthrough", "arguments": { "command-line": "stop" } }
{ "return": {} }

Which is what we should expect.

In any case, it's not a big deal to fix that.

> > +
> > +out:
> > +    cur_mon = old_mon;
> > +    qemu_chr_close_mem(hmp.chr);
> > +    return ret;
> > +}
> > +
> >  static int compare_cmd(const char *name, const char *list)
> >  {
> >      const char *p, *pstart;
> > diff --git a/qmp-commands.hx b/qmp-commands.hx
> > index 793cf1c..b344096 100644
> > --- a/qmp-commands.hx
> > +++ b/qmp-commands.hx
> > @@ -761,6 +761,51 @@ Example:
> >  
> >  Note: This command must be issued before issuing any other command.
> >  
> > +EQMP
> > +
> > +    {
> > +        .name       = "hmp_passthrough",
> > +        .args_type  = "command-line:s,cpu-index:i?",
> > +        .params     = "",
> > +        .help       = "",
> > +        .user_print = monitor_user_noop,
> > +        .mhandler.cmd_new = do_hmp_passthrough,
> > +    },
> > +
> > +SQMP
> > +hmp_passthrough
> > +---------------
> > +
> > +Execute a Human Monitor command.
> > +
> > +Arguments: 
> > +
> > +- command-line: the command name and its arguments, just like the
> > +                Human Monitor's shell (json-string)
> > +- cpu-index: select the CPU number to be used by commands which access CPU
> > +             data, like 'info registers'. The Monitor selects CPU 0 if this
> > +             argument is not provided (json-int, optional)
> > +
> > +Example:
> > +
> > +-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
> > +<- { "return": "kvm support: enabled\r\n" }
> > +
> > +Notes:
> > +
> > +(1) The Human Monitor is NOT an stable interface, this means that command
> > +    names, arguments and responses can change or be removed at ANY time.
> > +    Applications that rely on long term stability guarantees should NOT
> > +    use this command
> > +
> > +(2) Limitations:
> > +
> > +    o This command is stateless, this means that commands that depend
> > +      on state information (such as getfd) might not work
> > +
> > +    o Commands that prompt the user for data (eg. 'cont' when the block
> > +      device is encrypted) don't currently work
> > +
> >  3. Query Commands
> >  =================
> 

Re: [Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> On Thu, 11 Nov 2010 16:47:41 +0100
> Markus Armbruster <armbru@redhat.com> wrote:
>
>> Luiz Capitulino <lcapitulino@redhat.com> writes:
>> 
>> > On Wed, 10 Nov 2010 14:20:12 +0100
>> > Markus Armbruster <armbru@redhat.com> wrote:
>> >
>> >> Luiz Capitulino <lcapitulino@redhat.com> writes:
>> [...]
>> >> > diff --git a/qmp-commands.hx b/qmp-commands.hx
>> >> > index 793cf1c..b344096 100644
>> >> > --- a/qmp-commands.hx
>> >> > +++ b/qmp-commands.hx
>> >> > @@ -761,6 +761,51 @@ Example:
>> >> >  
>> >> >  Note: This command must be issued before issuing any other command.
>> >> >  
>> >> > +EQMP
>> >> > +
>> >> > +    {
>> >> > +        .name       = "hmp_passthrough",
>> >> > +        .args_type  = "command-line:s,cpu-index:i?",
>> >> > +        .params     = "",
>> >> > +        .help       = "",
>> >> > +        .user_print = monitor_user_noop,
>> >> > +        .mhandler.cmd_new = do_hmp_passthrough,
>> >> > +    },
>> >> > +
>> >> > +SQMP
>> >> > +hmp_passthrough
>> >> > +---------------
>> >> > +
>> >> > +Execute a Human Monitor command.
>> >> > +
>> >> > +Arguments: 
>> >> > +
>> >> > +- command-line: the command name and its arguments, just like the
>> >> > +                Human Monitor's shell (json-string)
>> >> > +- cpu-index: select the CPU number to be used by commands which access CPU
>> >> > +             data, like 'info registers'. The Monitor selects CPU 0 if this
>> >> > +             argument is not provided (json-int, optional)
>> >> > +
>> >> > +Example:
>> >> > +
>> >> > +-> { "execute": "hmp_passthrough", "arguments": { "command-line": "info kvm" } }
>> >> > +<- { "return": "kvm support: enabled\r\n" }
>> >> > +
>> >> > +Notes:
>> >> > +
>> >> > +(1) The Human Monitor is NOT an stable interface, this means that command
>> >> > +    names, arguments and responses can change or be removed at ANY time.
>> >> > +    Applications that rely on long term stability guarantees should NOT
>> >> > +    use this command
>> >> > +
>> >> > +(2) Limitations:
>> >> > +
>> >> > +    o This command is stateless, this means that commands that depend
>> >> > +      on state information (such as getfd) might not work
>> >> > +
>> >> > +    o Commands that prompt the user for data (eg. 'cont' when the block
>> >> > +      device is encrypted) don't currently work
>> >> > +
>> >> >  3. Query Commands
>> >> >  =================
>> >> 
>> >> In the real human monitor, cpu-index is state (Monitor member mon_cpu).
>> >> For pass through, you shift that state into the client (argument
>> >> cpu-index).  Is there any other state that could need shifting?  You
>> >> mention getfd.
>> >
>> > Surprisingly or not, this is a very important question for QMP itself.
>> >
>> > Anthony has said that we should make it stateless, and I do think this
>> > is good because it seems to simplify things considerably.
>> >
>> > However, I haven't thought about how to make things like getfd stateless.
>> 
>> Hmm, that sounds like we should investigate the getfd problem sooner
>> rather than later.
>
> Absolutely, but this shouldn't prevent this series of being merged, right?

Right.

[Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Luiz Capitulino]

This command allows QMP clients to execute HMP commands.

Please, check the documentation added to the qmp-commands.hx file
for additional details about the interface and its limitations.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c       |   38 ++++++++++++++++++++++++++++++++++++++
 qmp-commands.hx |   45 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 0 deletions(-)

diff --git a/monitor.c b/monitor.c
index 8cee35d..ec31eac 100644
--- a/monitor.c
+++ b/monitor.c
@@ -491,6 +491,44 @@ static int do_qmp_capabilities(Monitor *mon, const QDict *params,
     return 0;
 }
 
+static int mon_set_cpu(int cpu_index);
+static void handle_user_command(Monitor *mon, const char *cmdline);
+
+static int do_hmp_passthrough(Monitor *mon, const QDict *params,
+                              QObject **ret_data)
+{
+    int ret = 0;
+    Monitor *old_mon, hmp;
+    CharDriverState mchar;
+
+    memset(&hmp, 0, sizeof(hmp));
+    qemu_chr_init_mem(&mchar);
+    hmp.chr = &mchar;
+
+    old_mon = cur_mon;
+    cur_mon = &hmp;
+
+    if (qdict_haskey(params, "cpu-index")) {
+        ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
+        if (ret < 0) {
+            cur_mon = old_mon;
+            qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
+            goto out;
+        }
+    }
+
+    handle_user_command(&hmp, qdict_get_str(params, "command-line"));
+    cur_mon = old_mon;
+
+    if (qemu_chr_mem_osize(hmp.chr) > 0) {
+        *ret_data = QOBJECT(qemu_chr_mem_to_qs(hmp.chr));
+    }
+
+out:
+    qemu_chr_close_mem(hmp.chr);
+    return ret;
+}
+
 static int compare_cmd(const char *name, const char *list)
 {
     const char *p, *pstart;
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 793cf1c..e5f157f 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -761,6 +761,51 @@ Example:
 
 Note: This command must be issued before issuing any other command.
 
+EQMP
+
+    {
+        .name       = "human-monitor-command",
+        .args_type  = "command-line:s,cpu-index:i?",
+        .params     = "",
+        .help       = "",
+        .user_print = monitor_user_noop,
+        .mhandler.cmd_new = do_hmp_passthrough,
+    },
+
+SQMP
+human-monitor-command
+---------------------
+
+Execute a Human Monitor command.
+
+Arguments: 
+
+- command-line: the command name and its arguments, just like the
+                Human Monitor's shell (json-string)
+- cpu-index: select the CPU number to be used by commands which access CPU
+             data, like 'info registers'. The Monitor selects CPU 0 if this
+             argument is not provided (json-int, optional)
+
+Example:
+
+-> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
+<- { "return": "kvm support: enabled\r\n" }
+
+Notes:
+
+(1) The Human Monitor is NOT an stable interface, this means that command
+    names, arguments and responses can change or be removed at ANY time.
+    Applications that rely on long term stability guarantees should NOT
+    use this command
+
+(2) Limitations:
+
+    o This command is stateless, this means that commands that depend
+      on state information (such as getfd) might not work
+
+    o Commands that prompt the user for data (eg. 'cont' when the block
+      device is encrypted) don't currently work
+
 3. Query Commands
 =================
 
-- 
1.7.3.2.164.g6f10c

[Qemu-devel] [PATCH 2/3] QMP: Introduce Human Monitor passthrough command

[Luiz Capitulino]

This command allows QMP clients to execute HMP commands.

Please, check the documentation added to the qmp-commands.hx file
for additional details about the interface and its limitations.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c       |   38 ++++++++++++++++++++++++++++++++++++++
 qmp-commands.hx |   45 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 0 deletions(-)

diff --git a/monitor.c b/monitor.c
index 8cee35d..ec31eac 100644
--- a/monitor.c
+++ b/monitor.c
@@ -491,6 +491,44 @@ static int do_qmp_capabilities(Monitor *mon, const QDict *params,
     return 0;
 }
 
+static int mon_set_cpu(int cpu_index);
+static void handle_user_command(Monitor *mon, const char *cmdline);
+
+static int do_hmp_passthrough(Monitor *mon, const QDict *params,
+                              QObject **ret_data)
+{
+    int ret = 0;
+    Monitor *old_mon, hmp;
+    CharDriverState mchar;
+
+    memset(&hmp, 0, sizeof(hmp));
+    qemu_chr_init_mem(&mchar);
+    hmp.chr = &mchar;
+
+    old_mon = cur_mon;
+    cur_mon = &hmp;
+
+    if (qdict_haskey(params, "cpu-index")) {
+        ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
+        if (ret < 0) {
+            cur_mon = old_mon;
+            qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
+            goto out;
+        }
+    }
+
+    handle_user_command(&hmp, qdict_get_str(params, "command-line"));
+    cur_mon = old_mon;
+
+    if (qemu_chr_mem_osize(hmp.chr) > 0) {
+        *ret_data = QOBJECT(qemu_chr_mem_to_qs(hmp.chr));
+    }
+
+out:
+    qemu_chr_close_mem(hmp.chr);
+    return ret;
+}
+
 static int compare_cmd(const char *name, const char *list)
 {
     const char *p, *pstart;
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 793cf1c..e5f157f 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -761,6 +761,51 @@ Example:
 
 Note: This command must be issued before issuing any other command.
 
+EQMP
+
+    {
+        .name       = "human-monitor-command",
+        .args_type  = "command-line:s,cpu-index:i?",
+        .params     = "",
+        .help       = "",
+        .user_print = monitor_user_noop,
+        .mhandler.cmd_new = do_hmp_passthrough,
+    },
+
+SQMP
+human-monitor-command
+---------------------
+
+Execute a Human Monitor command.
+
+Arguments: 
+
+- command-line: the command name and its arguments, just like the
+                Human Monitor's shell (json-string)
+- cpu-index: select the CPU number to be used by commands which access CPU
+             data, like 'info registers'. The Monitor selects CPU 0 if this
+             argument is not provided (json-int, optional)
+
+Example:
+
+-> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
+<- { "return": "kvm support: enabled\r\n" }
+
+Notes:
+
+(1) The Human Monitor is NOT an stable interface, this means that command
+    names, arguments and responses can change or be removed at ANY time.
+    Applications that rely on long term stability guarantees should NOT
+    use this command
+
+(2) Limitations:
+
+    o This command is stateless, this means that commands that depend
+      on state information (such as getfd) might not work
+
+    o Commands that prompt the user for data (eg. 'cont' when the block
+      device is encrypted) don't currently work
+
 3. Query Commands
 =================
 
-- 
1.7.3.2.168.gd6b63