[Qemu-devel] [PATCH v0 00/17]: info handlers conversions to QObject

[Qemu-devel] [PATCH v0 00/17]: info handlers conversions to QObject

[Luiz Capitulino]

 Hi,

 Now that qjson has been merged, it's time to flush my queues..

 This series covers almost half of the info handlers conversions to the
QObject style, the other half is a bit more complicated as some handlers
can be defined by different machine types.

 Detailed conversion status can be found at:

http://www.linux-kvm.org/page/MonitorProtocol

 Thanks.

[Qemu-devel] [PATCH 01/17] Introduce qemu-objects.h header file

[Luiz Capitulino]

An easy way to include all QEMU objects.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 qemu-objects.h |   24 ++++++++++++++++++++++++
 1 files changed, 24 insertions(+), 0 deletions(-)
 create mode 100644 qemu-objects.h

diff --git a/qemu-objects.h b/qemu-objects.h
new file mode 100644
index 0000000..e1d1e0c
--- /dev/null
+++ b/qemu-objects.h
@@ -0,0 +1,24 @@
+/*
+ * Include all QEMU objects.
+ *
+ * Copyright (C) 2009 Red Hat Inc.
+ *
+ * Authors:
+ *  Luiz Capitulino <lcapitulino@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2.  See
+ * the COPYING file in the top-level directory.
+ */
+#ifndef QEMU_OBJECTS_H
+#define QEMU_OBJECTS_H
+
+#include "qobject.h"
+#include "qint.h"
+#include "qfloat.h"
+#include "qbool.h"
+#include "qstring.h"
+#include "qdict.h"
+#include "qlist.h"
+#include "qjson.h"
+
+#endif /* QEMU_OBJECTS_H */
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 02/17] Makefile: move QObject objs to their own entry

[Luiz Capitulino]

Other subsystems will need to link against them.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 Makefile |    8 ++++++--
 1 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index d770e2a..dd48a35 100644
--- a/Makefile
+++ b/Makefile
@@ -72,6 +72,11 @@ ALL_SUBDIRS=$(TARGET_DIRS) $(patsubst %,pc-bios/%, $(ROMS))
 recurse-all: $(SUBDIR_RULES) $(ROMSUBDIR_RULES)
 
 #######################################################################
+# QObject
+qobject-obj-y = qint.o qstring.o qdict.o qlist.o qfloat.o qbool.o
+qobject-obj-y += qjson.o json-lexer.o json-streamer.o json-parser.o
+
+#######################################################################
 # block-obj-y is code used by both qemu system emulation and qemu-img
 
 block-obj-y = cutils.o cache-utils.o qemu-malloc.o qemu-option.o module.o
@@ -106,6 +111,7 @@ net-obj-y += $(addprefix net/, $(net-nested-y))
 
 obj-y = $(block-obj-y)
 obj-y += $(net-obj-y)
+obj-y += $(qobject-obj-y)
 obj-y += readline.o console.o
 
 obj-y += tcg-runtime.o host-utils.o
@@ -137,8 +143,6 @@ obj-y += buffered_file.o migration.o migration-tcp.o qemu-sockets.o
 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 += qemu-config.o block-migration.o
 
 obj-$(CONFIG_BRLAPI) += baum.o
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 03/17] QDict: Introduce qdict_get_qbool()

[Luiz Capitulino]

This is a helper function that does type checking before retrieving
a QBool from the dictionary.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 Makefile |    2 +-
 qdict.c  |   15 +++++++++++++++
 qdict.h  |    1 +
 3 files changed, 17 insertions(+), 1 deletions(-)

diff --git a/Makefile b/Makefile
index dd48a35..fa41ac9 100644
--- a/Makefile
+++ b/Makefile
@@ -232,7 +232,7 @@ qemu-img-cmds.h: $(SRC_PATH)/qemu-img-cmds.hx
 
 check-qint: check-qint.o qint.o qemu-malloc.o
 check-qstring: check-qstring.o qstring.o qemu-malloc.o
-check-qdict: check-qdict.o qdict.o qint.o qstring.o qemu-malloc.o
+check-qdict: check-qdict.o qdict.o qint.o qstring.o qbool.o qemu-malloc.o
 check-qlist: check-qlist.o qlist.o qint.o qemu-malloc.o
 check-qfloat: check-qfloat.o qfloat.o qemu-malloc.o
 check-qjson: check-qjson.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o qjson.o json-streamer.o json-lexer.o json-parser.o qemu-malloc.o
diff --git a/qdict.c b/qdict.c
index 0e04cb1..45e08be 100644
--- a/qdict.c
+++ b/qdict.c
@@ -12,6 +12,7 @@
 
 #include "qint.h"
 #include "qdict.h"
+#include "qbool.h"
 #include "qstring.h"
 #include "qobject.h"
 #include "qemu-queue.h"
@@ -189,6 +190,20 @@ int64_t qdict_get_int(const QDict *qdict, const char *key)
 }
 
 /**
+ * qdict_get_bool(): Get a bool mapped by 'key'
+ *
+ * This function assumes that 'key' exists and it stores a
+ * QBool object.
+ *
+ * Return bool mapped by 'key'.
+ */
+int qdict_get_bool(const QDict *qdict, const char *key)
+{
+    QObject *obj = qdict_get_obj(qdict, key, QTYPE_QBOOL);
+    return qbool_get_int(qobject_to_qbool(obj));
+}
+
+/**
  * qdict_get_str(): Get a pointer to the stored string mapped
  * by 'key'
  *
diff --git a/qdict.h b/qdict.h
index 14b2633..1473c04 100644
--- a/qdict.h
+++ b/qdict.h
@@ -37,6 +37,7 @@ void qdict_iter(const QDict *qdict,
 
 /* High level helpers */
 int64_t qdict_get_int(const QDict *qdict, const char *key);
+int qdict_get_bool(const QDict *qdict, const char *key);
 const char *qdict_get_str(const QDict *qdict, const char *key);
 int64_t qdict_get_try_int(const QDict *qdict, const char *key,
                           int64_t err_value);
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 04/17] QDict: Introduce qdict_get_qlist()

[Luiz Capitulino]

A helper function to get a QList from a QDict.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 Makefile |    2 +-
 qdict.c  |   13 +++++++++++++
 qdict.h  |    2 ++
 3 files changed, 16 insertions(+), 1 deletions(-)

diff --git a/Makefile b/Makefile
index fa41ac9..6be75a1 100644
--- a/Makefile
+++ b/Makefile
@@ -232,7 +232,7 @@ qemu-img-cmds.h: $(SRC_PATH)/qemu-img-cmds.hx
 
 check-qint: check-qint.o qint.o qemu-malloc.o
 check-qstring: check-qstring.o qstring.o qemu-malloc.o
-check-qdict: check-qdict.o qdict.o qint.o qstring.o qbool.o qemu-malloc.o
+check-qdict: check-qdict.o qdict.o qint.o qstring.o qbool.o qemu-malloc.o qlist.o
 check-qlist: check-qlist.o qlist.o qint.o qemu-malloc.o
 check-qfloat: check-qfloat.o qfloat.o qemu-malloc.o
 check-qjson: check-qjson.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o qjson.o json-streamer.o json-lexer.o json-parser.o qemu-malloc.o
diff --git a/qdict.c b/qdict.c
index 45e08be..ef73265 100644
--- a/qdict.c
+++ b/qdict.c
@@ -204,6 +204,19 @@ int qdict_get_bool(const QDict *qdict, const char *key)
 }
 
 /**
+ * qdict_get_qlist(): Get the QList mapped by 'key'
+ *
+ * This function assumes that 'key' exists and it stores a
+ * QList object.
+ *
+ * Return QList mapped by 'key'.
+ */
+QList *qdict_get_qlist(const QDict *qdict, const char *key)
+{
+    return qobject_to_qlist(qdict_get_obj(qdict, key, QTYPE_QLIST));
+}
+
+/**
  * qdict_get_str(): Get a pointer to the stored string mapped
  * by 'key'
  *
diff --git a/qdict.h b/qdict.h
index 1473c04..5fef1ea 100644
--- a/qdict.h
+++ b/qdict.h
@@ -2,6 +2,7 @@
 #define QDICT_H
 
 #include "qobject.h"
+#include "qlist.h"
 #include "qemu-queue.h"
 #include <stdint.h>
 
@@ -38,6 +39,7 @@ void qdict_iter(const QDict *qdict,
 /* High level helpers */
 int64_t qdict_get_int(const QDict *qdict, const char *key);
 int qdict_get_bool(const QDict *qdict, const char *key);
+QList *qdict_get_qlist(const QDict *qdict, const char *key);
 const char *qdict_get_str(const QDict *qdict, const char *key);
 int64_t qdict_get_try_int(const QDict *qdict, const char *key,
                           int64_t err_value);
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 05/17] monitor: Convert do_info_status() to QObject

[Luiz Capitulino]

Return a QString with status information.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c |   33 +++++++++++++++++++++++++++------
 1 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/monitor.c b/monitor.c
index 3286ba2..72de320 100644
--- a/monitor.c
+++ b/monitor.c
@@ -1678,16 +1678,36 @@ static void do_inject_nmi(Monitor *mon, const QDict *qdict)
 }
 #endif
 
-static void do_info_status(Monitor *mon)
+static void do_info_status_print(Monitor *mon, const QObject *data)
 {
+    monitor_printf(mon, "VM status: %s\n",
+                   qstring_get_str(qobject_to_qstring(data)));
+}
+
+/**
+ * do_info_status(): VM status
+ *
+ * Return a QString with status information, which can be:
+ *
+ * - "running"
+ * - "running (single step mode)"
+ * - "paused"
+ */
+static void do_info_status(Monitor *mon, QObject **ret_data)
+{
+    QString *qs;
+
     if (vm_running) {
         if (singlestep) {
-            monitor_printf(mon, "VM status: running (single step mode)\n");
+            qs = qstring_from_str("running (single step mode)");
         } else {
-            monitor_printf(mon, "VM status: running\n");
+            qs = qstring_from_str("running");
         }
-    } else
-       monitor_printf(mon, "VM status: paused\n");
+    } else {
+       qs = qstring_from_str("paused");
+    }
+
+    *ret_data = QOBJECT(qs);
 }
 
 /**
@@ -2117,7 +2137,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show the current VM status (running|paused)",
-        .mhandler.info = do_info_status,
+        .user_print = do_info_status_print,
+        .mhandler.info_new = do_info_status,
     },
     {
         .name       = "pcmcia",
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 06/17] monitor: Convert do_info_kvm() to QObject

[Luiz Capitulino]

The returned QObject is a QString with kvm status information.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c |   31 +++++++++++++++++++++++++------
 1 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/monitor.c b/monitor.c
index 72de320..1a37be3 100644
--- a/monitor.c
+++ b/monitor.c
@@ -1551,17 +1551,35 @@ static void tlb_info(Monitor *mon)
 
 #endif
 
-static void do_info_kvm(Monitor *mon)
+static void do_info_kvm_print(Monitor *mon, const QObject *data)
 {
+    monitor_printf(mon, "kvm support: %s\n",
+                   qstring_get_str(qobject_to_qstring(data)));
+}
+
+/**
+ * do_info_kvm(): Show KVM information
+ *
+ * Return a QString with KVM information, which can be:
+ *
+ * - "enabled"
+ * - "disabled"
+ * - "not compiled"
+ */
+static void do_info_kvm(Monitor *mon, QObject **ret_data)
+{
+    QString *qs;
+
 #ifdef CONFIG_KVM
-    monitor_printf(mon, "kvm support: ");
     if (kvm_enabled())
-        monitor_printf(mon, "enabled\n");
+        qs = qstring_from_str("enabled");
     else
-        monitor_printf(mon, "disabled\n");
+        qs = qstring_from_str("disabled");
 #else
-    monitor_printf(mon, "kvm support: not compiled\n");
+    qs = qstring_from_str("not compiled");
 #endif
+
+    *ret_data = QOBJECT(qs);
 }
 
 static void do_info_numa(Monitor *mon)
@@ -2088,7 +2106,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show KVM information",
-        .mhandler.info = do_info_kvm,
+        .user_print = do_info_kvm_print,
+        .mhandler.info_new = do_info_kvm,
     },
     {
         .name       = "numa",
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 07/17] monitor: Convert do_info_name() to QObject

[Luiz Capitulino]

The returned QObject is a QString.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c |   12 +++++++++---
 1 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/monitor.c b/monitor.c
index 1a37be3..5140198 100644
--- a/monitor.c
+++ b/monitor.c
@@ -349,10 +349,15 @@ static void do_info_version(Monitor *mon, QObject **ret_data)
     *ret_data = QOBJECT(qstring_from_str(QEMU_VERSION QEMU_PKGVERSION));
 }
 
-static void do_info_name(Monitor *mon)
+/**
+ * do_info_name(): Show VM name
+ *
+ * Return a QString with the current VM name.
+ */
+static void do_info_name(Monitor *mon, QObject **ret_data)
 {
     if (qemu_name)
-        monitor_printf(mon, "%s\n", qemu_name);
+        *ret_data = QOBJECT(qstring_from_str(qemu_name));
 }
 
 #if defined(TARGET_I386)
@@ -2185,7 +2190,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show the current VM name",
-        .mhandler.info = do_info_name,
+        .user_print = monitor_print_qobject,
+        .mhandler.info_new = do_info_name,
     },
     {
         .name       = "uuid",
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 08/17] monitor: Convert do_info_hpet() to QObject

[Luiz Capitulino]

The returned QObject is a QString.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c |   24 +++++++++++++++++++++---
 1 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/monitor.c b/monitor.c
index 5140198..9ecf5ff 100644
--- a/monitor.c
+++ b/monitor.c
@@ -361,10 +361,27 @@ static void do_info_name(Monitor *mon, QObject **ret_data)
 }
 
 #if defined(TARGET_I386)
-static void do_info_hpet(Monitor *mon)
+static void do_info_hpet_print(Monitor *mon, const QObject *data)
 {
     monitor_printf(mon, "HPET is %s by QEMU\n",
-                   (no_hpet) ? "disabled" : "enabled");
+                   qstring_get_str(qobject_to_qstring(data)));
+}
+
+/**
+ * do_info_hpet(): Show HPET state
+ *
+ * Return a QString with HPET information, which can be:
+ *
+ * - "enabled"
+ * - "disabled"
+ */
+static void do_info_hpet(Monitor *mon, QObject **ret_data)
+{
+    if (no_hpet) {
+        *ret_data = QOBJECT(qstring_from_str("disabled"));
+    } else {
+        *ret_data = QOBJECT(qstring_from_str("enabled"));
+    }
 }
 #endif
 
@@ -2096,7 +2113,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show state of HPET",
-        .mhandler.info = do_info_hpet,
+        .user_print = do_info_hpet_print,
+        .mhandler.info_new = do_info_hpet,
     },
 #endif
     {
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 09/17] monitor: Convert do_info_uuid() to QObject

[Luiz Capitulino]

The returned QObject is a QString, snprintf() is used because the
UUID_FMT is too complex for qobject_from_jsonf().

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c |   15 ++++++++++++---
 1 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/monitor.c b/monitor.c
index 9ecf5ff..c86c7a5 100644
--- a/monitor.c
+++ b/monitor.c
@@ -385,13 +385,21 @@ static void do_info_hpet(Monitor *mon, QObject **ret_data)
 }
 #endif
 
-static void do_info_uuid(Monitor *mon)
+/**
+ * do_info_uuid(): Show VM UUID
+ *
+ * Return a QString with the current VM UUID.
+ */
+static void do_info_uuid(Monitor *mon, QObject **ret_data)
 {
-    monitor_printf(mon, UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1],
+    char uuid[64];
+
+    snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
                    qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
                    qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
                    qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
                    qemu_uuid[14], qemu_uuid[15]);
+    *ret_data = QOBJECT(qstring_from_str(uuid));
 }
 
 /* get the current CPU defined by the user */
@@ -2216,7 +2224,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show the current VM UUID",
-        .mhandler.info = do_info_uuid,
+        .user_print = monitor_print_qobject,
+        .mhandler.info_new = do_info_uuid,
     },
 #if defined(TARGET_PPC)
     {
-- 
1.6.5.2.180.gc5b3e

Re: [Qemu-devel] [PATCH 09/17] monitor: Convert do_info_uuid() to QObject

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> The returned QObject is a QString, snprintf() is used because the
> UUID_FMT is too complex for qobject_from_jsonf().

If this turns out to be a common problem, we should consider fixing it
at the source: qobject_from_jsonf().

[Qemu-devel] [PATCH 10/17] migration: Convert do_info_migrate() to QObject

[Luiz Capitulino]

Return a QDict, which may contain another QDict if the migration
process is active.

IMPORTANT: as a QInt stores a int64_t integer, RAM values are going
to be stored as int64_t and not as uint64_t as they are today. If
this is a problem QInt will have to be changed.

This commit should not change user output.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 migration.c |   61 ++++++++++++++++++++++++++++++++++++++++++++++++++--------
 migration.h |    4 ++-
 monitor.c   |    3 +-
 3 files changed, 57 insertions(+), 11 deletions(-)

diff --git a/migration.c b/migration.c
index 3ae0be8..a01adc0 100644
--- a/migration.c
+++ b/migration.c
@@ -18,6 +18,7 @@
 #include "sysemu.h"
 #include "block.h"
 #include "qemu_socket.h"
+#include "qemu-objects.h"
 
 //#define DEBUG_MIGRATION
 
@@ -157,29 +158,71 @@ void do_migrate_set_downtime(Monitor *mon, const QDict *qdict)
     max_downtime = (uint64_t)d;
 }
 
-void do_info_migrate(Monitor *mon)
+void do_info_migrate_print(Monitor *mon, const QObject *data)
+{
+    QDict *qdict;
+
+    qdict = qobject_to_qdict(data);
+
+    monitor_printf(mon, "Migration status: %s\n", qdict_get_str(qdict, "status"));
+
+    if (qdict_haskey(qdict, "ram")) {
+        QDict *qdict_ram = qobject_to_qdict(qdict_get(qdict, "ram"));
+        monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
+                       qdict_get_int(qdict_ram, "transferred") >> 10);
+        monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
+                       qdict_get_int(qdict_ram, "remaining") >> 10);
+        monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
+                       qdict_get_int(qdict_ram, "total") >> 10);
+    }
+}
+
+/**
+ * do_info_migrate(): Migration status
+ *
+ * Return a QDict. If migration is active there will be another
+ * QDict with RAM information.
+ *
+ * The main QDict contains the following:
+ *
+ * - "status": migration status
+ * - "ram": only present if "status" is "active", it is a QDict with the
+ *   following information (in bytes):
+ *          - "transferred": amount of RAM transferred
+ *          - "remaining": amount of RAM remaining
+ *          - "total": total RAM
+ *
+ * Examples:
+ *
+ * 1. If migration is "completed":
+ *
+ * { "status": "completed" }
+ *
+ * 2. If migration is "active":
+ *
+ * { "status": "active", "ram":
+ *             { "transferred": 123, "remaining": 123, "total": 246 } }
+ */
+void do_info_migrate(Monitor *mon, QObject **ret_data)
 {
     MigrationState *s = current_migration;
 
     if (s) {
-        monitor_printf(mon, "Migration status: ");
         switch (s->get_status(s)) {
         case MIG_STATE_ACTIVE:
-            monitor_printf(mon, "active\n");
-            monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n", ram_bytes_transferred() >> 10);
-            monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n", ram_bytes_remaining() >> 10);
-            monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n", ram_bytes_total() >> 10);
+            *ret_data = qobject_from_jsonf("{ 'status': 'active', 'ram': { 'transferred': %" PRId64 ", 'remaining': %" PRId64 ", 'total': %" PRId64 "} }", ram_bytes_transferred(), ram_bytes_remaining(), ram_bytes_total());
             break;
         case MIG_STATE_COMPLETED:
-            monitor_printf(mon, "completed\n");
+            *ret_data = qobject_from_jsonf("{ 'status': 'completed' }");
             break;
         case MIG_STATE_ERROR:
-            monitor_printf(mon, "failed\n");
+            *ret_data = qobject_from_jsonf("{ 'status': 'failed' }");
             break;
         case MIG_STATE_CANCELLED:
-            monitor_printf(mon, "cancelled\n");
+            *ret_data = qobject_from_jsonf("{ 'status': 'cancelled' }");
             break;
         }
+        assert(*ret_data != NULL);
     }
 }
 
diff --git a/migration.h b/migration.h
index 56adf05..08c3dcc 100644
--- a/migration.h
+++ b/migration.h
@@ -62,7 +62,9 @@ uint64_t migrate_max_downtime(void);
 
 void do_migrate_set_downtime(Monitor *mon, const QDict *qdict);
 
-void do_info_migrate(Monitor *mon);
+void do_info_migrate_print(Monitor *mon, const QObject *data);
+
+void do_info_migrate(Monitor *mon, QObject **ret_data);
 
 int exec_start_incoming_migration(const char *host_port);
 
diff --git a/monitor.c b/monitor.c
index c86c7a5..1528f08 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2250,7 +2250,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show migration status",
-        .mhandler.info = do_info_migrate,
+        .user_print = do_info_migrate_print,
+        .mhandler.info_new = do_info_migrate,
     },
     {
         .name       = "balloon",
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 11/17] block: Convert bdrv_info() to QObject

[Luiz Capitulino]

Each block device information is stored in a QDict and the
returned QObject is a QList of all devices.

This commit should not change user output.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 Makefile  |    2 +-
 block.c   |  123 +++++++++++++++++++++++++++++++++++++++++++++++++++----------
 block.h   |    4 +-
 monitor.c |    3 +-
 4 files changed, 109 insertions(+), 23 deletions(-)

diff --git a/Makefile b/Makefile
index 6be75a1..3424cdb 100644
--- a/Makefile
+++ b/Makefile
@@ -80,7 +80,7 @@ qobject-obj-y += qjson.o json-lexer.o json-streamer.o json-parser.o
 # block-obj-y is code used by both qemu system emulation and qemu-img
 
 block-obj-y = cutils.o cache-utils.o qemu-malloc.o qemu-option.o module.o
-block-obj-y += nbd.o block.o aio.o aes.o osdep.o
+block-obj-y += nbd.o block.o aio.o aes.o osdep.o $(qobject-obj-y)
 block-obj-$(CONFIG_POSIX) += posix-aio-compat.o
 block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o
 
diff --git a/block.c b/block.c
index 6fdabff..fc4e2f2 100644
--- a/block.c
+++ b/block.c
@@ -26,6 +26,7 @@
 #include "monitor.h"
 #include "block_int.h"
 #include "module.h"
+#include "qemu-objects.h"
 
 #ifdef CONFIG_BSD
 #include <sys/types.h>
@@ -1133,43 +1134,125 @@ int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
     return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
 }
 
-void bdrv_info(Monitor *mon)
+static void bdrv_print_dict(QObject *obj, void *opaque)
 {
+    QDict *bs_dict;
+    Monitor *mon = opaque;
+
+    bs_dict = qobject_to_qdict(obj);
+
+    monitor_printf(mon, "%s: type=%s removable=%d",
+                        qdict_get_str(bs_dict, "device"),
+                        qdict_get_str(bs_dict, "type"),
+                        qdict_get_bool(bs_dict, "removable"));
+
+    if (qdict_get_bool(bs_dict, "removable")) {
+        monitor_printf(mon, " locked=%d", (int)qdict_get_bool(bs_dict, "locked"));
+    }
+
+    if (qdict_haskey(bs_dict, "inserted")) {
+        QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
+
+        monitor_printf(mon, " file=");
+        monitor_print_filename(mon, qdict_get_str(qdict, "file"));
+        if (qdict_haskey(qdict, "backing_file")) {
+            monitor_printf(mon, " backing_file=");
+            monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
+        }
+        monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
+                            qdict_get_bool(qdict, "ro"),
+                            qdict_get_str(qdict, "drv"),
+                            qdict_get_bool(qdict, "encrypted"));
+    } else {
+        monitor_printf(mon, " [not inserted]");
+    }
+
+    monitor_printf(mon, "\n");
+}
+
+void bdrv_info_print(Monitor *mon, const QObject *data)
+{
+    qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
+}
+
+/**
+ * bdrv_info(): Block devices information
+ *
+ * Each block device information is stored in a QDict and the
+ * returned QObject is a QList of all devices.
+ *
+ * The QDict contains the following:
+ *
+ * - "device": device name
+ * - "type": device type
+ * - "removable": 1 if the device is removable 0 otherwise
+ * - "locked": 1 if the device is locked 0 otherwise
+ * - "inserted": only present if the device is inserted, it is a QDict
+ *    containing the following:
+ *          - "file": device file name
+ *          - "ro": 1 if read-only 0 otherwise
+ *          - "drv": driver format name
+ *          - "backing_file": backing file name if one is used
+ *          - "encrypted":  1 if encrypted 0 otherwise
+ *
+ * Example:
+ *
+ * [ { "device": "ide0-hd0", "type": "hd", "removable": 0,
+ *     "file": "/tmp/foobar", "ro": 0, "drv": "qcow2", "encrypted": 0 }
+ *   { "device": "floppy0", "type": "floppy", "removable": 1,
+ *     "locked": 0 } ]
+ */
+void bdrv_info(Monitor *mon, QObject **ret_data)
+{
+    QList *bs_list;
     BlockDriverState *bs;
 
+    bs_list = qlist_new();
+
     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
-        monitor_printf(mon, "%s:", bs->device_name);
-        monitor_printf(mon, " type=");
+        QObject *bs_obj;
+        const char *type = "unknown";
+
         switch(bs->type) {
         case BDRV_TYPE_HD:
-            monitor_printf(mon, "hd");
+            type = "hd";
             break;
         case BDRV_TYPE_CDROM:
-            monitor_printf(mon, "cdrom");
+            type = "cdrom";
             break;
         case BDRV_TYPE_FLOPPY:
-            monitor_printf(mon, "floppy");
+            type = "floppy";
             break;
         }
-        monitor_printf(mon, " removable=%d", bs->removable);
-        if (bs->removable) {
-            monitor_printf(mon, " locked=%d", bs->locked);
-        }
+
+        bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, "
+                                    "'removable': %i, 'locked': %i }",
+                                    bs->device_name, type, bs->removable,
+                                    bs->locked);
+        assert(bs_obj != NULL);
+
         if (bs->drv) {
-            monitor_printf(mon, " file=");
-            monitor_print_filename(mon, bs->filename);
+            QObject *obj;
+            QDict *bs_dict = qobject_to_qdict(bs_obj);
+
+            obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
+                                     "'encrypted': %i }",
+                                     bs->filename, bs->read_only,
+                                     bs->drv->format_name,
+                                     bdrv_is_encrypted(bs));
+            assert(obj != NULL);
             if (bs->backing_file[0] != '\0') {
-                monitor_printf(mon, " backing_file=");
-                monitor_print_filename(mon, bs->backing_file);
+                QDict *qdict = qobject_to_qdict(obj);
+                qdict_put(qdict, "backing_file",
+                          qstring_from_str(bs->backing_file));
             }
-            monitor_printf(mon, " ro=%d", bs->read_only);
-            monitor_printf(mon, " drv=%s", bs->drv->format_name);
-            monitor_printf(mon, " encrypted=%d", bdrv_is_encrypted(bs));
-        } else {
-            monitor_printf(mon, " [not inserted]");
+
+            qdict_put_obj(bs_dict, "inserted", obj);
         }
-        monitor_printf(mon, "\n");
+        qlist_append_obj(bs_list, bs_obj);
     }
+
+    *ret_data = QOBJECT(bs_list);
 }
 
 /* The "info blockstats" command. */
diff --git a/block.h b/block.h
index 2d4f066..3ca7112 100644
--- a/block.h
+++ b/block.h
@@ -4,6 +4,7 @@
 #include "qemu-aio.h"
 #include "qemu-common.h"
 #include "qemu-option.h"
+#include "qobject.h"
 
 /* block.c */
 typedef struct BlockDriver BlockDriver;
@@ -41,7 +42,8 @@ typedef struct QEMUSnapshotInfo {
 
 #define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB)
 
-void bdrv_info(Monitor *mon);
+void bdrv_info_print(Monitor *mon, const QObject *data);
+void bdrv_info(Monitor *mon, QObject **ret_data);
 void bdrv_info_stats(Monitor *mon);
 
 void bdrv_init(void);
diff --git a/monitor.c b/monitor.c
index 1528f08..e4fed10 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2047,7 +2047,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show the block devices",
-        .mhandler.info = bdrv_info,
+        .user_print = bdrv_info_print,
+        .mhandler.info_new = bdrv_info,
     },
     {
         .name       = "blockstats",
-- 
1.6.5.2.180.gc5b3e

Re: [Qemu-devel] [PATCH 11/17] block: Convert bdrv_info() to QObject

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> Each block device information is stored in a QDict and the
> returned QObject is a QList of all devices.
>
> This commit should not change user output.
>
> Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> ---
>  Makefile  |    2 +-
>  block.c   |  123 +++++++++++++++++++++++++++++++++++++++++++++++++++----------
>  block.h   |    4 +-
>  monitor.c |    3 +-
>  4 files changed, 109 insertions(+), 23 deletions(-)
>
> diff --git a/Makefile b/Makefile
> index 6be75a1..3424cdb 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -80,7 +80,7 @@ qobject-obj-y += qjson.o json-lexer.o json-streamer.o json-parser.o
>  # block-obj-y is code used by both qemu system emulation and qemu-img
>  
>  block-obj-y = cutils.o cache-utils.o qemu-malloc.o qemu-option.o module.o
> -block-obj-y += nbd.o block.o aio.o aes.o osdep.o
> +block-obj-y += nbd.o block.o aio.o aes.o osdep.o $(qobject-obj-y)
>  block-obj-$(CONFIG_POSIX) += posix-aio-compat.o
>  block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o
>  

Both $(block-obj-y) and $(qobject-obj-y) go into obj-y, which thus list
all the $(qobject-obj-y) objects twice.  Sure that's okay?

> diff --git a/block.c b/block.c
> index 6fdabff..fc4e2f2 100644
> --- a/block.c
> +++ b/block.c
> @@ -26,6 +26,7 @@
>  #include "monitor.h"
>  #include "block_int.h"
>  #include "module.h"
> +#include "qemu-objects.h"
>  
>  #ifdef CONFIG_BSD
>  #include <sys/types.h>
> @@ -1133,43 +1134,125 @@ int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
>      return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
>  }
>  
> -void bdrv_info(Monitor *mon)
> +static void bdrv_print_dict(QObject *obj, void *opaque)
>  {
> +    QDict *bs_dict;
> +    Monitor *mon = opaque;
> +
> +    bs_dict = qobject_to_qdict(obj);
> +
> +    monitor_printf(mon, "%s: type=%s removable=%d",
> +                        qdict_get_str(bs_dict, "device"),
> +                        qdict_get_str(bs_dict, "type"),
> +                        qdict_get_bool(bs_dict, "removable"));
> +
> +    if (qdict_get_bool(bs_dict, "removable")) {
> +        monitor_printf(mon, " locked=%d", (int)qdict_get_bool(bs_dict, "locked"));

qdict_get_bool() returns int, no need to cast.

> +    }
> +
> +    if (qdict_haskey(bs_dict, "inserted")) {
> +        QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
> +
> +        monitor_printf(mon, " file=");
> +        monitor_print_filename(mon, qdict_get_str(qdict, "file"));
> +        if (qdict_haskey(qdict, "backing_file")) {
> +            monitor_printf(mon, " backing_file=");
> +            monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
> +        }
> +        monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
> +                            qdict_get_bool(qdict, "ro"),
> +                            qdict_get_str(qdict, "drv"),
> +                            qdict_get_bool(qdict, "encrypted"));
> +    } else {
> +        monitor_printf(mon, " [not inserted]");
> +    }
> +
> +    monitor_printf(mon, "\n");
> +}
> +
> +void bdrv_info_print(Monitor *mon, const QObject *data)
> +{
> +    qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
> +}
> +
> +/**
> + * bdrv_info(): Block devices information
> + *
> + * Each block device information is stored in a QDict and the
> + * returned QObject is a QList of all devices.
> + *
> + * The QDict contains the following:
> + *
> + * - "device": device name
> + * - "type": device type
> + * - "removable": 1 if the device is removable 0 otherwise
> + * - "locked": 1 if the device is locked 0 otherwise

Use above and example below suggest that "locked" is only present if
device is removable.  Document?

> + * - "inserted": only present if the device is inserted, it is a QDict
> + *    containing the following:
> + *          - "file": device file name
> + *          - "ro": 1 if read-only 0 otherwise
> + *          - "drv": driver format name
> + *          - "backing_file": backing file name if one is used
> + *          - "encrypted":  1 if encrypted 0 otherwise
> + *
> + * Example:
> + *
> + * [ { "device": "ide0-hd0", "type": "hd", "removable": 0,
> + *     "file": "/tmp/foobar", "ro": 0, "drv": "qcow2", "encrypted": 0 }

Shouldn't "file" & friends ne in nested dictionary "inserted"?

> + *   { "device": "floppy0", "type": "floppy", "removable": 1,
> + *     "locked": 0 } ]
> + */
> +void bdrv_info(Monitor *mon, QObject **ret_data)
> +{
> +    QList *bs_list;
>      BlockDriverState *bs;
>  
> +    bs_list = qlist_new();
> +
>      for (bs = bdrv_first; bs != NULL; bs = bs->next) {
> -        monitor_printf(mon, "%s:", bs->device_name);
> -        monitor_printf(mon, " type=");
> +        QObject *bs_obj;
> +        const char *type = "unknown";
> +
>          switch(bs->type) {
>          case BDRV_TYPE_HD:
> -            monitor_printf(mon, "hd");
> +            type = "hd";
>              break;
>          case BDRV_TYPE_CDROM:
> -            monitor_printf(mon, "cdrom");
> +            type = "cdrom";
>              break;
>          case BDRV_TYPE_FLOPPY:
> -            monitor_printf(mon, "floppy");
> +            type = "floppy";
>              break;
>          }

This changes human-readable output for bad bs->type from "type=" to
"type=unknown".  Fine with me.

> -        monitor_printf(mon, " removable=%d", bs->removable);
> -        if (bs->removable) {
> -            monitor_printf(mon, " locked=%d", bs->locked);
> -        }
> +
> +        bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, "
> +                                    "'removable': %i, 'locked': %i }",
> +                                    bs->device_name, type, bs->removable,
> +                                    bs->locked);
> +        assert(bs_obj != NULL);

Failure modes of qobject_from_jsonf()?  I'm asking because depending on
the answer assert() may not be appropriate here.

> +
>          if (bs->drv) {
> -            monitor_printf(mon, " file=");
> -            monitor_print_filename(mon, bs->filename);
> +            QObject *obj;
> +            QDict *bs_dict = qobject_to_qdict(bs_obj);
> +
> +            obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
> +                                     "'encrypted': %i }",
> +                                     bs->filename, bs->read_only,
> +                                     bs->drv->format_name,
> +                                     bdrv_is_encrypted(bs));
> +            assert(obj != NULL);

Ditto.

>              if (bs->backing_file[0] != '\0') {
> -                monitor_printf(mon, " backing_file=");
> -                monitor_print_filename(mon, bs->backing_file);
> +                QDict *qdict = qobject_to_qdict(obj);
> +                qdict_put(qdict, "backing_file",
> +                          qstring_from_str(bs->backing_file));
>              }
> -            monitor_printf(mon, " ro=%d", bs->read_only);
> -            monitor_printf(mon, " drv=%s", bs->drv->format_name);
> -            monitor_printf(mon, " encrypted=%d", bdrv_is_encrypted(bs));
> -        } else {
> -            monitor_printf(mon, " [not inserted]");
> +
> +            qdict_put_obj(bs_dict, "inserted", obj);
>          }
> -        monitor_printf(mon, "\n");
> +        qlist_append_obj(bs_list, bs_obj);
>      }
> +
> +    *ret_data = QOBJECT(bs_list);
>  }
>  
>  /* The "info blockstats" command. */
> diff --git a/block.h b/block.h
> index 2d4f066..3ca7112 100644
> --- a/block.h
> +++ b/block.h
> @@ -4,6 +4,7 @@
>  #include "qemu-aio.h"
>  #include "qemu-common.h"
>  #include "qemu-option.h"
> +#include "qobject.h"
>  
>  /* block.c */
>  typedef struct BlockDriver BlockDriver;
> @@ -41,7 +42,8 @@ typedef struct QEMUSnapshotInfo {
>  
>  #define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB)
>  
> -void bdrv_info(Monitor *mon);
> +void bdrv_info_print(Monitor *mon, const QObject *data);
> +void bdrv_info(Monitor *mon, QObject **ret_data);
>  void bdrv_info_stats(Monitor *mon);
>  
>  void bdrv_init(void);
> diff --git a/monitor.c b/monitor.c
> index 1528f08..e4fed10 100644
> --- a/monitor.c
> +++ b/monitor.c
> @@ -2047,7 +2047,8 @@ static const mon_cmd_t info_cmds[] = {
>          .args_type  = "",
>          .params     = "",
>          .help       = "show the block devices",
> -        .mhandler.info = bdrv_info,
> +        .user_print = bdrv_info_print,
> +        .mhandler.info_new = bdrv_info,
>      },
>      {
>          .name       = "blockstats",

Re: [Qemu-devel] [PATCH 11/17] block: Convert bdrv_info() to QObject

[Luiz Capitulino]

On Fri, 20 Nov 2009 15:06:26 +0100
Markus Armbruster <armbru@redhat.com> wrote:

> Luiz Capitulino <lcapitulino@redhat.com> writes:
> 
> > Each block device information is stored in a QDict and the
> > returned QObject is a QList of all devices.
> >
> > This commit should not change user output.
> >
> > Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> > ---
> >  Makefile  |    2 +-
> >  block.c   |  123 +++++++++++++++++++++++++++++++++++++++++++++++++++----------
> >  block.h   |    4 +-
> >  monitor.c |    3 +-
> >  4 files changed, 109 insertions(+), 23 deletions(-)
> >
> > diff --git a/Makefile b/Makefile
> > index 6be75a1..3424cdb 100644
> > --- a/Makefile
> > +++ b/Makefile
> > @@ -80,7 +80,7 @@ qobject-obj-y += qjson.o json-lexer.o json-streamer.o json-parser.o
> >  # block-obj-y is code used by both qemu system emulation and qemu-img
> >  
> >  block-obj-y = cutils.o cache-utils.o qemu-malloc.o qemu-option.o module.o
> > -block-obj-y += nbd.o block.o aio.o aes.o osdep.o
> > +block-obj-y += nbd.o block.o aio.o aes.o osdep.o $(qobject-obj-y)
> >  block-obj-$(CONFIG_POSIX) += posix-aio-compat.o
> >  block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o
> >  
> 
> Both $(block-obj-y) and $(qobject-obj-y) go into obj-y, which thus list
> all the $(qobject-obj-y) objects twice.  Sure that's okay?

 $(qobject-obj-y) is a dependency of qemu- block tools, it can be moved
there then.

> > diff --git a/block.c b/block.c
> > index 6fdabff..fc4e2f2 100644
> > --- a/block.c
> > +++ b/block.c
> > @@ -26,6 +26,7 @@
> >  #include "monitor.h"
> >  #include "block_int.h"
> >  #include "module.h"
> > +#include "qemu-objects.h"
> >  
> >  #ifdef CONFIG_BSD
> >  #include <sys/types.h>
> > @@ -1133,43 +1134,125 @@ int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
> >      return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
> >  }
> >  
> > -void bdrv_info(Monitor *mon)
> > +static void bdrv_print_dict(QObject *obj, void *opaque)
> >  {
> > +    QDict *bs_dict;
> > +    Monitor *mon = opaque;
> > +
> > +    bs_dict = qobject_to_qdict(obj);
> > +
> > +    monitor_printf(mon, "%s: type=%s removable=%d",
> > +                        qdict_get_str(bs_dict, "device"),
> > +                        qdict_get_str(bs_dict, "type"),
> > +                        qdict_get_bool(bs_dict, "removable"));
> > +
> > +    if (qdict_get_bool(bs_dict, "removable")) {
> > +        monitor_printf(mon, " locked=%d", (int)qdict_get_bool(bs_dict, "locked"));
> 
> qdict_get_bool() returns int, no need to cast.

 Right.

> > +    }
> > +
> > +    if (qdict_haskey(bs_dict, "inserted")) {
> > +        QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
> > +
> > +        monitor_printf(mon, " file=");
> > +        monitor_print_filename(mon, qdict_get_str(qdict, "file"));
> > +        if (qdict_haskey(qdict, "backing_file")) {
> > +            monitor_printf(mon, " backing_file=");
> > +            monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
> > +        }
> > +        monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
> > +                            qdict_get_bool(qdict, "ro"),
> > +                            qdict_get_str(qdict, "drv"),
> > +                            qdict_get_bool(qdict, "encrypted"));
> > +    } else {
> > +        monitor_printf(mon, " [not inserted]");
> > +    }
> > +
> > +    monitor_printf(mon, "\n");
> > +}
> > +
> > +void bdrv_info_print(Monitor *mon, const QObject *data)
> > +{
> > +    qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
> > +}
> > +
> > +/**
> > + * bdrv_info(): Block devices information
> > + *
> > + * Each block device information is stored in a QDict and the
> > + * returned QObject is a QList of all devices.
> > + *
> > + * The QDict contains the following:
> > + *
> > + * - "device": device name
> > + * - "type": device type
> > + * - "removable": 1 if the device is removable 0 otherwise
> > + * - "locked": 1 if the device is locked 0 otherwise
> 
> Use above and example below suggest that "locked" is only present if
> device is removable.  Document?

 Yes.

> > + * - "inserted": only present if the device is inserted, it is a QDict
> > + *    containing the following:
> > + *          - "file": device file name
> > + *          - "ro": 1 if read-only 0 otherwise
> > + *          - "drv": driver format name
> > + *          - "backing_file": backing file name if one is used
> > + *          - "encrypted":  1 if encrypted 0 otherwise
> > + *
> > + * Example:
> > + *
> > + * [ { "device": "ide0-hd0", "type": "hd", "removable": 0,
> > + *     "file": "/tmp/foobar", "ro": 0, "drv": "qcow2", "encrypted": 0 }
> 
> Shouldn't "file" & friends ne in nested dictionary "inserted"?

 Yes, will fix.

> > -        monitor_printf(mon, " removable=%d", bs->removable);
> > -        if (bs->removable) {
> > -            monitor_printf(mon, " locked=%d", bs->locked);
> > -        }
> > +
> > +        bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, "
> > +                                    "'removable': %i, 'locked': %i }",
> > +                                    bs->device_name, type, bs->removable,
> > +                                    bs->locked);
> > +        assert(bs_obj != NULL);
> 
> Failure modes of qobject_from_jsonf()?  I'm asking because depending on
> the answer assert() may not be appropriate here.

 As far as I know it will fail on wrong syntax.

Re: [Qemu-devel] [PATCH 11/17] block: Convert bdrv_info() to QObject

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> On Fri, 20 Nov 2009 15:06:26 +0100
> Markus Armbruster <armbru@redhat.com> wrote:
>
>> Luiz Capitulino <lcapitulino@redhat.com> writes:
[...]
>> > diff --git a/block.c b/block.c
>> > index 6fdabff..fc4e2f2 100644
>> > --- a/block.c
>> > +++ b/block.c
[...]
>> > -        monitor_printf(mon, " removable=%d", bs->removable);
>> > -        if (bs->removable) {
>> > -            monitor_printf(mon, " locked=%d", bs->locked);
>> > -        }
>> > +
>> > +        bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, "
>> > +                                    "'removable': %i, 'locked': %i }",
>> > +                                    bs->device_name, type, bs->removable,
>> > +                                    bs->locked);
>> > +        assert(bs_obj != NULL);
>> 
>> Failure modes of qobject_from_jsonf()?  I'm asking because depending on
>> the answer assert() may not be appropriate here.
>
>  As far as I know it will fail on wrong syntax.

In that case, assert() catches a programming error.  That's fine.

[Qemu-devel] [PATCH 12/17] char: Convert qemu_chr_info() to QObject

[Luiz Capitulino]

Each device is represented by a QDict. The returned QObject is a QList
of all devices.

This commit should not change user output.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c   |    3 ++-
 qemu-char.c |   43 +++++++++++++++++++++++++++++++++++++++++--
 qemu-char.h |    4 +++-
 3 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/monitor.c b/monitor.c
index e4fed10..a0a9281 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2040,7 +2040,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show the character devices",
-        .mhandler.info = qemu_chr_info,
+        .user_print = qemu_chr_info_print,
+        .mhandler.info_new = qemu_chr_info,
     },
     {
         .name       = "block",
diff --git a/qemu-char.c b/qemu-char.c
index 5a81e8f..7fcde98 100644
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -32,6 +32,7 @@
 #include "hw/usb.h"
 #include "hw/baum.h"
 #include "hw/msmouse.h"
+#include "qemu-objects.h"
 
 #include <unistd.h>
 #include <fcntl.h>
@@ -2465,13 +2466,51 @@ void qemu_chr_close(CharDriverState *chr)
     qemu_free(chr);
 }
 
-void qemu_chr_info(Monitor *mon)
+static void qemu_chr_print_qlist(QObject *obj, void *opaque)
 {
+    QDict *chr_dict;
+    Monitor *mon = opaque;
+
+    chr_dict = qobject_to_qdict(obj);
+    monitor_printf(mon, "%s: filename=%s\n", qdict_get_str(chr_dict, "label"),
+                                         qdict_get_str(chr_dict, "filename"));
+}
+
+void qemu_chr_info_print(Monitor *mon, const QObject *ret_data)
+{
+    qlist_iter(qobject_to_qlist(ret_data), qemu_chr_print_qlist, mon);
+}
+
+/**
+ * qemu_chr_info(): Character devices information
+ *
+ * Each device is represented by a QDict. The returned QObject is a QList
+ * of all devices.
+ *
+ * The QDict contains the following:
+ *
+ * - "label": device's label
+ * - "filename": device's file
+ *
+ * Example:
+ *
+ * [ { "label": "monitor", "filename", "stdio" },
+ *   { "label": "serial0", "filename": "vc" } ]
+ */
+void qemu_chr_info(Monitor *mon, QObject **ret_data)
+{
+    QList *chr_list;
     CharDriverState *chr;
 
+    chr_list = qlist_new();
+
     QTAILQ_FOREACH(chr, &chardevs, next) {
-        monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename);
+        QObject *obj = qobject_from_jsonf("{ 'label': %s, 'filename': %s }",
+                                          chr->label, chr->filename);
+        qlist_append_obj(chr_list, obj);
     }
+
+    *ret_data = QOBJECT(chr_list);
 }
 
 CharDriverState *qemu_chr_find(const char *name)
diff --git a/qemu-char.h b/qemu-char.h
index 9957db1..48f54d8 100644
--- a/qemu-char.h
+++ b/qemu-char.h
@@ -5,6 +5,7 @@
 #include "qemu-queue.h"
 #include "qemu-option.h"
 #include "qemu-config.h"
+#include "qobject.h"
 
 /* character device */
 
@@ -87,7 +88,8 @@ int qemu_chr_can_read(CharDriverState *s);
 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len);
 int qemu_chr_get_msgfd(CharDriverState *s);
 void qemu_chr_accept_input(CharDriverState *s);
-void qemu_chr_info(Monitor *mon);
+void qemu_chr_info_print(Monitor *mon, const QObject *ret_data);
+void qemu_chr_info(Monitor *mon, QObject **ret_data);
 CharDriverState *qemu_chr_find(const char *name);
 
 extern int term_escape_char;
-- 
1.6.5.2.180.gc5b3e

Re: [Qemu-devel] [PATCH 12/17] char: Convert qemu_chr_info() to QObject

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> Each device is represented by a QDict. The returned QObject is a QList
> of all devices.
>
> This commit should not change user output.
>
> Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> ---
>  monitor.c   |    3 ++-
>  qemu-char.c |   43 +++++++++++++++++++++++++++++++++++++++++--
>  qemu-char.h |    4 +++-
>  3 files changed, 46 insertions(+), 4 deletions(-)
>
> diff --git a/monitor.c b/monitor.c
> index e4fed10..a0a9281 100644
> --- a/monitor.c
> +++ b/monitor.c
> @@ -2040,7 +2040,8 @@ static const mon_cmd_t info_cmds[] = {
>          .args_type  = "",
>          .params     = "",
>          .help       = "show the character devices",
> -        .mhandler.info = qemu_chr_info,
> +        .user_print = qemu_chr_info_print,
> +        .mhandler.info_new = qemu_chr_info,
>      },
>      {
>          .name       = "block",
> diff --git a/qemu-char.c b/qemu-char.c
> index 5a81e8f..7fcde98 100644
> --- a/qemu-char.c
> +++ b/qemu-char.c
> @@ -32,6 +32,7 @@
>  #include "hw/usb.h"
>  #include "hw/baum.h"
>  #include "hw/msmouse.h"
> +#include "qemu-objects.h"
>  
>  #include <unistd.h>
>  #include <fcntl.h>
> @@ -2465,13 +2466,51 @@ void qemu_chr_close(CharDriverState *chr)
>      qemu_free(chr);
>  }
>  
> -void qemu_chr_info(Monitor *mon)
> +static void qemu_chr_print_qlist(QObject *obj, void *opaque)

Why *_qlist?  It prints a qdict, which happens to be a list element, but
this function doesn't know that.

>  {
> +    QDict *chr_dict;
> +    Monitor *mon = opaque;
> +
> +    chr_dict = qobject_to_qdict(obj);
> +    monitor_printf(mon, "%s: filename=%s\n", qdict_get_str(chr_dict, "label"),
> +                                         qdict_get_str(chr_dict, "filename"));
> +}
> +
> +void qemu_chr_info_print(Monitor *mon, const QObject *ret_data)
> +{
> +    qlist_iter(qobject_to_qlist(ret_data), qemu_chr_print_qlist, mon);
> +}
[...]

Re: [Qemu-devel] [PATCH 12/17] char: Convert qemu_chr_info() to QObject

[Luiz Capitulino]

On Fri, 20 Nov 2009 15:10:20 +0100
Markus Armbruster <armbru@redhat.com> wrote:

> Luiz Capitulino <lcapitulino@redhat.com> writes:
> 
> > Each device is represented by a QDict. The returned QObject is a QList
> > of all devices.
> >
> > This commit should not change user output.
> >
> > Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> > ---
> >  monitor.c   |    3 ++-
> >  qemu-char.c |   43 +++++++++++++++++++++++++++++++++++++++++--
> >  qemu-char.h |    4 +++-
> >  3 files changed, 46 insertions(+), 4 deletions(-)
> >
> > diff --git a/monitor.c b/monitor.c
> > index e4fed10..a0a9281 100644
> > --- a/monitor.c
> > +++ b/monitor.c
> > @@ -2040,7 +2040,8 @@ static const mon_cmd_t info_cmds[] = {
> >          .args_type  = "",
> >          .params     = "",
> >          .help       = "show the character devices",
> > -        .mhandler.info = qemu_chr_info,
> > +        .user_print = qemu_chr_info_print,
> > +        .mhandler.info_new = qemu_chr_info,
> >      },
> >      {
> >          .name       = "block",
> > diff --git a/qemu-char.c b/qemu-char.c
> > index 5a81e8f..7fcde98 100644
> > --- a/qemu-char.c
> > +++ b/qemu-char.c
> > @@ -32,6 +32,7 @@
> >  #include "hw/usb.h"
> >  #include "hw/baum.h"
> >  #include "hw/msmouse.h"
> > +#include "qemu-objects.h"
> >  
> >  #include <unistd.h>
> >  #include <fcntl.h>
> > @@ -2465,13 +2466,51 @@ void qemu_chr_close(CharDriverState *chr)
> >      qemu_free(chr);
> >  }
> >  
> > -void qemu_chr_info(Monitor *mon)
> > +static void qemu_chr_print_qlist(QObject *obj, void *opaque)
> 
> Why *_qlist?  It prints a qdict, which happens to be a list element, but
> this function doesn't know that.

 It does know, as it was written with the purpose of printing the elements
of a qlist.

Re: [Qemu-devel] [PATCH 12/17] char: Convert qemu_chr_info() to QObject

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> On Fri, 20 Nov 2009 15:10:20 +0100
> Markus Armbruster <armbru@redhat.com> wrote:
>
>> Luiz Capitulino <lcapitulino@redhat.com> writes:
>> 
>> > Each device is represented by a QDict. The returned QObject is a QList
>> > of all devices.
>> >
>> > This commit should not change user output.
>> >
>> > Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
>> > ---
>> >  monitor.c   |    3 ++-
>> >  qemu-char.c |   43 +++++++++++++++++++++++++++++++++++++++++--
>> >  qemu-char.h |    4 +++-
>> >  3 files changed, 46 insertions(+), 4 deletions(-)
>> >
>> > diff --git a/monitor.c b/monitor.c
>> > index e4fed10..a0a9281 100644
>> > --- a/monitor.c
>> > +++ b/monitor.c
[...]
>> > @@ -2465,13 +2466,51 @@ void qemu_chr_close(CharDriverState *chr)
>> >      qemu_free(chr);
>> >  }
>> >  
>> > -void qemu_chr_info(Monitor *mon)
>> > +static void qemu_chr_print_qlist(QObject *obj, void *opaque)
>> 
>> Why *_qlist?  It prints a qdict, which happens to be a list element, but
>> this function doesn't know that.
>
>  It does know, as it was written with the purpose of printing the elements
> of a qlist.

You knew it when you wrote it, but the function itself has nothing to do
with lists.

Elsewhere, you call such functions *_dict(), which makes sense to me,
because it prints a dictionary, or *_iter(), which I is also okay.

[Qemu-devel] [PATCH 13/17] PCI: Convert pci_device_hot_add() to QObject

[Luiz Capitulino]

Return a QDict with information about the just added device.

This commit should not change user output.

Please, note that this patch does not do error handling
conversion. In error conditions the handler still calls
monitor_printf().

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 hw/pci-hotplug.c |   37 +++++++++++++++++++++++++++++++++----
 qemu-monitor.hx  |    3 ++-
 sysemu.h         |    3 ++-
 3 files changed, 37 insertions(+), 6 deletions(-)

diff --git a/hw/pci-hotplug.c b/hw/pci-hotplug.c
index a254498..93802a2 100644
--- a/hw/pci-hotplug.c
+++ b/hw/pci-hotplug.c
@@ -33,6 +33,7 @@
 #include "scsi.h"
 #include "virtio-blk.h"
 #include "qemu-config.h"
+#include "qemu-objects.h"
 
 #if defined(TARGET_I386)
 static PCIDevice *qemu_pci_hot_add_nic(Monitor *mon,
@@ -212,7 +213,36 @@ static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon,
     return dev;
 }
 
-void pci_device_hot_add(Monitor *mon, const QDict *qdict)
+void pci_device_hot_add_print(Monitor *mon, const QObject *data)
+{
+    QDict *qdict;
+
+    assert(qobject_type(data) == QTYPE_QDICT);
+    qdict = qobject_to_qdict(data);
+
+    monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
+                   (int) qdict_get_int(qdict, "domain"),
+                   (int) qdict_get_int(qdict, "bus"),
+                   (int) qdict_get_int(qdict, "slot"),
+                   (int) qdict_get_int(qdict, "function"));
+
+}
+
+/**
+ * pci_device_hot_add(): Hot add PCI device
+ *
+ * Return a QDict with the following device information:
+ *
+ * - "domain": domain number
+ * - "bus": bus number
+ * - "slot": slot number
+ * - "function": function number
+ *
+ * Example:
+ *
+ * { "domain": 0, "bus": 0, "slot": 5, "function": 0 }
+ */
+void pci_device_hot_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
 {
     PCIDevice *dev = NULL;
     const char *pci_addr = qdict_get_str(qdict, "pci_addr");
@@ -239,9 +269,8 @@ void pci_device_hot_add(Monitor *mon, const QDict *qdict)
         monitor_printf(mon, "invalid type: %s\n", type);
 
     if (dev) {
-        monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
-                       0, pci_bus_num(dev->bus), PCI_SLOT(dev->devfn),
-                       PCI_FUNC(dev->devfn));
+        *ret_data = qobject_from_jsonf("{ 'domain': 0, 'bus': %d, 'slot': %d, 'function': %d }", pci_bus_num(dev->bus), PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
+        assert(*ret_data != NULL);
     } else
         monitor_printf(mon, "failed to add %s\n", opts);
 }
diff --git a/qemu-monitor.hx b/qemu-monitor.hx
index 62e395b..b50a2da 100644
--- a/qemu-monitor.hx
+++ b/qemu-monitor.hx
@@ -809,7 +809,8 @@ ETEXI
         .args_type  = "pci_addr:s,type:s,opts:s?",
         .params     = "auto|[[<domain>:]<bus>:]<slot> nic|storage [[vlan=n][,macaddr=addr][,model=type]] [file=file][,if=type][,bus=nr]...",
         .help       = "hot-add PCI device",
-        .mhandler.cmd = pci_device_hot_add,
+        .user_print = pci_device_hot_add_print,
+        .mhandler.cmd_new = pci_device_hot_add,
     },
 #endif
 
diff --git a/sysemu.h b/sysemu.h
index b1887ef..4d685a0 100644
--- a/sysemu.h
+++ b/sysemu.h
@@ -201,7 +201,8 @@ extern DriveInfo *drive_init(QemuOpts *arg, void *machine, int *fatal_error);
 DriveInfo *add_init_drive(const char *opts);
 
 /* pci-hotplug */
-void pci_device_hot_add(Monitor *mon, const QDict *qdict);
+void pci_device_hot_add_print(Monitor *mon, const QObject *data);
+void pci_device_hot_add(Monitor *mon, const QDict *qdict, QObject **ret_data);
 void drive_hot_add(Monitor *mon, const QDict *qdict);
 void pci_device_hot_remove(Monitor *mon, const char *pci_addr);
 void do_pci_device_hot_remove(Monitor *mon, const QDict *qdict,
-- 
1.6.5.2.180.gc5b3e

Re: [Qemu-devel] [PATCH 13/17] PCI: Convert pci_device_hot_add() to QObject

[Markus Armbruster]

Luiz Capitulino <lcapitulino@redhat.com> writes:

> Return a QDict with information about the just added device.
>
> This commit should not change user output.
>
> Please, note that this patch does not do error handling
> conversion. In error conditions the handler still calls
> monitor_printf().
>
> Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> ---
>  hw/pci-hotplug.c |   37 +++++++++++++++++++++++++++++++++----
>  qemu-monitor.hx  |    3 ++-
>  sysemu.h         |    3 ++-
>  3 files changed, 37 insertions(+), 6 deletions(-)
>
> diff --git a/hw/pci-hotplug.c b/hw/pci-hotplug.c
> index a254498..93802a2 100644
> --- a/hw/pci-hotplug.c
> +++ b/hw/pci-hotplug.c
> @@ -33,6 +33,7 @@
>  #include "scsi.h"
>  #include "virtio-blk.h"
>  #include "qemu-config.h"
> +#include "qemu-objects.h"
>  
>  #if defined(TARGET_I386)
>  static PCIDevice *qemu_pci_hot_add_nic(Monitor *mon,
> @@ -212,7 +213,36 @@ static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon,
>      return dev;
>  }
>  
> -void pci_device_hot_add(Monitor *mon, const QDict *qdict)
> +void pci_device_hot_add_print(Monitor *mon, const QObject *data)
> +{
> +    QDict *qdict;
> +
> +    assert(qobject_type(data) == QTYPE_QDICT);
> +    qdict = qobject_to_qdict(data);
> +
> +    monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
> +                   (int) qdict_get_int(qdict, "domain"),
> +                   (int) qdict_get_int(qdict, "bus"),
> +                   (int) qdict_get_int(qdict, "slot"),
> +                   (int) qdict_get_int(qdict, "function"));

Despite its name, qdict_get_int() doesn't return int, but int64_t (trap
for the unwary, in my opinion), so these casts are actually needed.
The're safe, because the values put into the dictionary never overflow
the cast.

Would be nice if we could avoid this non-local argument and make the
code more obviously correct, but it's probably not worth the bother.

> +
> +}
> +
> +/**
> + * pci_device_hot_add(): Hot add PCI device
> + *
> + * Return a QDict with the following device information:
> + *
> + * - "domain": domain number
> + * - "bus": bus number
> + * - "slot": slot number
> + * - "function": function number
> + *
> + * Example:
> + *
> + * { "domain": 0, "bus": 0, "slot": 5, "function": 0 }
> + */
> +void pci_device_hot_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
>  {
>      PCIDevice *dev = NULL;
>      const char *pci_addr = qdict_get_str(qdict, "pci_addr");
> @@ -239,9 +269,8 @@ void pci_device_hot_add(Monitor *mon, const QDict *qdict)
>          monitor_printf(mon, "invalid type: %s\n", type);
>  
>      if (dev) {
> -        monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
> -                       0, pci_bus_num(dev->bus), PCI_SLOT(dev->devfn),
> -                       PCI_FUNC(dev->devfn));
> +        *ret_data = qobject_from_jsonf("{ 'domain': 0, 'bus': %d, 'slot': %d, 'function': %d }", pci_bus_num(dev->bus), PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
> +        assert(*ret_data != NULL);
>      } else
>          monitor_printf(mon, "failed to add %s\n", opts);
>  }
[...]

[Qemu-devel] Re: [PATCH 13/17] PCI: Convert pci_device_hot_add() to QObject

[Michael S. Tsirkin]

On Tue, Nov 17, 2009 at 06:32:20PM -0200, Luiz Capitulino wrote:
> Return a QDict with information about the just added device.
> 
> This commit should not change user output.
> 
> Please, note that this patch does not do error handling
> conversion. In error conditions the handler still calls
> monitor_printf().
> 
> Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> ---
>  hw/pci-hotplug.c |   37 +++++++++++++++++++++++++++++++++----
>  qemu-monitor.hx  |    3 ++-
>  sysemu.h         |    3 ++-
>  3 files changed, 37 insertions(+), 6 deletions(-)
> 
> diff --git a/hw/pci-hotplug.c b/hw/pci-hotplug.c
> index a254498..93802a2 100644
> --- a/hw/pci-hotplug.c
> +++ b/hw/pci-hotplug.c
> @@ -33,6 +33,7 @@
>  #include "scsi.h"
>  #include "virtio-blk.h"
>  #include "qemu-config.h"
> +#include "qemu-objects.h"
>  
>  #if defined(TARGET_I386)
>  static PCIDevice *qemu_pci_hot_add_nic(Monitor *mon,
> @@ -212,7 +213,36 @@ static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon,
>      return dev;
>  }
>  
> -void pci_device_hot_add(Monitor *mon, const QDict *qdict)
> +void pci_device_hot_add_print(Monitor *mon, const QObject *data)

it only prints - why the strange name?

> +{
> +    QDict *qdict;
> +
> +    assert(qobject_type(data) == QTYPE_QDICT);
> +    qdict = qobject_to_qdict(data);
> +
> +    monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
> +                   (int) qdict_get_int(qdict, "domain"),
> +                   (int) qdict_get_int(qdict, "bus"),
> +                   (int) qdict_get_int(qdict, "slot"),
> +                   (int) qdict_get_int(qdict, "function"));
> +
> +}
> +
> +/**
> + * pci_device_hot_add(): Hot add PCI device
> + *
> + * Return a QDict with the following device information:
> + *
> + * - "domain": domain number
> + * - "bus": bus number
> + * - "slot": slot number
> + * - "function": function number
> + *
> + * Example:
> + *
> + * { "domain": 0, "bus": 0, "slot": 5, "function": 0 }
> + */
> +void pci_device_hot_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
>  {
>      PCIDevice *dev = NULL;
>      const char *pci_addr = qdict_get_str(qdict, "pci_addr");
> @@ -239,9 +269,8 @@ void pci_device_hot_add(Monitor *mon, const QDict *qdict)
>          monitor_printf(mon, "invalid type: %s\n", type);
>  
>      if (dev) {
> -        monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
> -                       0, pci_bus_num(dev->bus), PCI_SLOT(dev->devfn),
> -                       PCI_FUNC(dev->devfn));
> +        *ret_data = qobject_from_jsonf("{ 'domain': 0, 'bus': %d, 'slot': %d, 'function': %d }", pci_bus_num(dev->bus), PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));

this line is waay too long.

> +        assert(*ret_data != NULL);
>      } else
>          monitor_printf(mon, "failed to add %s\n", opts);
>  }
> diff --git a/qemu-monitor.hx b/qemu-monitor.hx
> index 62e395b..b50a2da 100644
> --- a/qemu-monitor.hx
> +++ b/qemu-monitor.hx
> @@ -809,7 +809,8 @@ ETEXI
>          .args_type  = "pci_addr:s,type:s,opts:s?",
>          .params     = "auto|[[<domain>:]<bus>:]<slot> nic|storage [[vlan=n][,macaddr=addr][,model=type]] [file=file][,if=type][,bus=nr]...",


and this

>          .help       = "hot-add PCI device",
> -        .mhandler.cmd = pci_device_hot_add,
> +        .user_print = pci_device_hot_add_print,
> +        .mhandler.cmd_new = pci_device_hot_add,
>      },
>  #endif
>  
> diff --git a/sysemu.h b/sysemu.h
> index b1887ef..4d685a0 100644
> --- a/sysemu.h
> +++ b/sysemu.h
> @@ -201,7 +201,8 @@ extern DriveInfo *drive_init(QemuOpts *arg, void *machine, int *fatal_error);
>  DriveInfo *add_init_drive(const char *opts);
>  
>  /* pci-hotplug */
> -void pci_device_hot_add(Monitor *mon, const QDict *qdict);
> +void pci_device_hot_add_print(Monitor *mon, const QObject *data);
> +void pci_device_hot_add(Monitor *mon, const QDict *qdict, QObject **ret_data);
>  void drive_hot_add(Monitor *mon, const QDict *qdict);
>  void pci_device_hot_remove(Monitor *mon, const char *pci_addr);
>  void do_pci_device_hot_remove(Monitor *mon, const QDict *qdict,
> -- 
> 1.6.5.2.180.gc5b3e
> 
> 

[Qemu-devel] Re: [PATCH 13/17] PCI: Convert pci_device_hot_add() to QObject

[Luiz Capitulino]

On Mon, 23 Nov 2009 11:44:57 +0200
"Michael S. Tsirkin" <mst@redhat.com> wrote:

> On Tue, Nov 17, 2009 at 06:32:20PM -0200, Luiz Capitulino wrote:
> > Return a QDict with information about the just added device.
> > 
> > This commit should not change user output.
> > 
> > Please, note that this patch does not do error handling
> > conversion. In error conditions the handler still calls
> > monitor_printf().
> > 
> > Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> > ---
> >  hw/pci-hotplug.c |   37 +++++++++++++++++++++++++++++++++----
> >  qemu-monitor.hx  |    3 ++-
> >  sysemu.h         |    3 ++-
> >  3 files changed, 37 insertions(+), 6 deletions(-)
> > 
> > diff --git a/hw/pci-hotplug.c b/hw/pci-hotplug.c
> > index a254498..93802a2 100644
> > --- a/hw/pci-hotplug.c
> > +++ b/hw/pci-hotplug.c
> > @@ -33,6 +33,7 @@
> >  #include "scsi.h"
> >  #include "virtio-blk.h"
> >  #include "qemu-config.h"
> > +#include "qemu-objects.h"
> >  
> >  #if defined(TARGET_I386)
> >  static PCIDevice *qemu_pci_hot_add_nic(Monitor *mon,
> > @@ -212,7 +213,36 @@ static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon,
> >      return dev;
> >  }
> >  
> > -void pci_device_hot_add(Monitor *mon, const QDict *qdict)
> > +void pci_device_hot_add_print(Monitor *mon, const QObject *data)
> 
> it only prints - why the strange name?

 I'm adding the _print suffix to the functions which print
handler data, that's, handle_name + _print.

 It may have strange results, indeed, but sometimes it's difficult
to come with good names as I'm converting several handlers.

 Also, I'd like to have standard names and haven't decided for
one yet.

> > +{
> > +    QDict *qdict;
> > +
> > +    assert(qobject_type(data) == QTYPE_QDICT);
> > +    qdict = qobject_to_qdict(data);
> > +
> > +    monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
> > +                   (int) qdict_get_int(qdict, "domain"),
> > +                   (int) qdict_get_int(qdict, "bus"),
> > +                   (int) qdict_get_int(qdict, "slot"),
> > +                   (int) qdict_get_int(qdict, "function"));
> > +
> > +}
> > +
> > +/**
> > + * pci_device_hot_add(): Hot add PCI device
> > + *
> > + * Return a QDict with the following device information:
> > + *
> > + * - "domain": domain number
> > + * - "bus": bus number
> > + * - "slot": slot number
> > + * - "function": function number
> > + *
> > + * Example:
> > + *
> > + * { "domain": 0, "bus": 0, "slot": 5, "function": 0 }
> > + */
> > +void pci_device_hot_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
> >  {
> >      PCIDevice *dev = NULL;
> >      const char *pci_addr = qdict_get_str(qdict, "pci_addr");
> > @@ -239,9 +269,8 @@ void pci_device_hot_add(Monitor *mon, const QDict *qdict)
> >          monitor_printf(mon, "invalid type: %s\n", type);
> >  
> >      if (dev) {
> > -        monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
> > -                       0, pci_bus_num(dev->bus), PCI_SLOT(dev->devfn),
> > -                       PCI_FUNC(dev->devfn));
> > +        *ret_data = qobject_from_jsonf("{ 'domain': 0, 'bus': %d, 'slot': %d, 'function': %d }", pci_bus_num(dev->bus), PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
> 
> this line is waay too long.

 I can brake it, although I don't think the result is going to be
prettier.

> > +        assert(*ret_data != NULL);
> >      } else
> >          monitor_printf(mon, "failed to add %s\n", opts);
> >  }
> > diff --git a/qemu-monitor.hx b/qemu-monitor.hx
> > index 62e395b..b50a2da 100644
> > --- a/qemu-monitor.hx
> > +++ b/qemu-monitor.hx
> > @@ -809,7 +809,8 @@ ETEXI
> >          .args_type  = "pci_addr:s,type:s,opts:s?",
> >          .params     = "auto|[[<domain>:]<bus>:]<slot> nic|storage [[vlan=n][,macaddr=addr][,model=type]] [file=file][,if=type][,bus=nr]...",
> 
> 
> and this

 This line is not part of the series.

[Qemu-devel] Re: [PATCH 13/17] PCI: Convert pci_device_hot_add() to QObject

[Michael S. Tsirkin]

On Mon, Nov 23, 2009 at 11:30:44AM -0200, Luiz Capitulino wrote:
> On Mon, 23 Nov 2009 11:44:57 +0200
> "Michael S. Tsirkin" <mst@redhat.com> wrote:
> 
> > On Tue, Nov 17, 2009 at 06:32:20PM -0200, Luiz Capitulino wrote:
> > > Return a QDict with information about the just added device.
> > > 
> > > This commit should not change user output.
> > > 
> > > Please, note that this patch does not do error handling
> > > conversion. In error conditions the handler still calls
> > > monitor_printf().
> > > 
> > > Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
> > > ---
> > >  hw/pci-hotplug.c |   37 +++++++++++++++++++++++++++++++++----
> > >  qemu-monitor.hx  |    3 ++-
> > >  sysemu.h         |    3 ++-
> > >  3 files changed, 37 insertions(+), 6 deletions(-)
> > > 
> > > diff --git a/hw/pci-hotplug.c b/hw/pci-hotplug.c
> > > index a254498..93802a2 100644
> > > --- a/hw/pci-hotplug.c
> > > +++ b/hw/pci-hotplug.c
> > > @@ -33,6 +33,7 @@
> > >  #include "scsi.h"
> > >  #include "virtio-blk.h"
> > >  #include "qemu-config.h"
> > > +#include "qemu-objects.h"
> > >  
> > >  #if defined(TARGET_I386)
> > >  static PCIDevice *qemu_pci_hot_add_nic(Monitor *mon,
> > > @@ -212,7 +213,36 @@ static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon,
> > >      return dev;
> > >  }
> > >  
> > > -void pci_device_hot_add(Monitor *mon, const QDict *qdict)
> > > +void pci_device_hot_add_print(Monitor *mon, const QObject *data)
> > 
> > it only prints - why the strange name?
> 
>  I'm adding the _print suffix to the functions which print
> handler data, that's, handle_name + _print.
> 
>  It may have strange results, indeed, but sometimes it's difficult
> to come with good names as I'm converting several handlers.
> 
>  Also, I'd like to have standard names and haven't decided for
> one yet.
> 
> > > +{
> > > +    QDict *qdict;
> > > +
> > > +    assert(qobject_type(data) == QTYPE_QDICT);
> > > +    qdict = qobject_to_qdict(data);
> > > +
> > > +    monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
> > > +                   (int) qdict_get_int(qdict, "domain"),
> > > +                   (int) qdict_get_int(qdict, "bus"),
> > > +                   (int) qdict_get_int(qdict, "slot"),
> > > +                   (int) qdict_get_int(qdict, "function"));
> > > +
> > > +}
> > > +
> > > +/**
> > > + * pci_device_hot_add(): Hot add PCI device
> > > + *
> > > + * Return a QDict with the following device information:
> > > + *
> > > + * - "domain": domain number
> > > + * - "bus": bus number
> > > + * - "slot": slot number
> > > + * - "function": function number
> > > + *
> > > + * Example:
> > > + *
> > > + * { "domain": 0, "bus": 0, "slot": 5, "function": 0 }
> > > + */
> > > +void pci_device_hot_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
> > >  {
> > >      PCIDevice *dev = NULL;
> > >      const char *pci_addr = qdict_get_str(qdict, "pci_addr");
> > > @@ -239,9 +269,8 @@ void pci_device_hot_add(Monitor *mon, const QDict *qdict)
> > >          monitor_printf(mon, "invalid type: %s\n", type);
> > >  
> > >      if (dev) {
> > > -        monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
> > > -                       0, pci_bus_num(dev->bus), PCI_SLOT(dev->devfn),
> > > -                       PCI_FUNC(dev->devfn));
> > > +        *ret_data = qobject_from_jsonf("{ 'domain': 0, 'bus': %d, 'slot': %d, 'function': %d }", pci_bus_num(dev->bus), PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
> > 
> > this line is waay too long.
> 
>  I can brake it, although I don't think the result is going to be
> prettier.

Here's one that looks decent to me.

        *ret_data = qobject_from_jsonf("{ 'domain': 0,"
                                        " 'bus': %d,"
                                        " 'slot': %d,"
			                " 'function': %d }",
				       pci_bus_num(dev->bus),
				       PCI_SLOT(dev->devfn),
				       PCI_FUNC(dev->devfn));


> > > +        assert(*ret_data != NULL);

BTW, pls make this assert(*ret_data);

> > >      } else
> > >          monitor_printf(mon, "failed to add %s\n", opts);
> > >  }
> > > diff --git a/qemu-monitor.hx b/qemu-monitor.hx
> > > index 62e395b..b50a2da 100644
> > > --- a/qemu-monitor.hx
> > > +++ b/qemu-monitor.hx
> > > @@ -809,7 +809,8 @@ ETEXI
> > >          .args_type  = "pci_addr:s,type:s,opts:s?",
> > >          .params     = "auto|[[<domain>:]<bus>:]<slot> nic|storage [[vlan=n][,macaddr=addr][,model=type]] [file=file][,if=type][,bus=nr]...",
> > 
> > 
> > and this
> 
>  This line is not part of the series.
> 

[Qemu-devel] [PATCH 14/17] block: Convert bdrv_info_stats() to QObject

[Luiz Capitulino]

Each device statistic information is stored in a QDict and
the returned QObject is a QList of all devices.

This commit should not change user output.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 block.c   |   82 ++++++++++++++++++++++++++++++++++++++++++++++++++++--------
 block.h   |    3 +-
 monitor.c |    3 +-
 3 files changed, 75 insertions(+), 13 deletions(-)

diff --git a/block.c b/block.c
index fc4e2f2..1fac98b 100644
--- a/block.c
+++ b/block.c
@@ -1255,22 +1255,82 @@ void bdrv_info(Monitor *mon, QObject **ret_data)
     *ret_data = QOBJECT(bs_list);
 }
 
-/* The "info blockstats" command. */
-void bdrv_info_stats(Monitor *mon)
+static void bdrv_stats_iter(QObject *data, void *opaque)
 {
+    QDict *qdict;
+    Monitor *mon = opaque;
+
+    qdict = qobject_to_qdict(data);
+    monitor_printf(mon, "%s:", qdict_get_str(qdict, "device"));
+
+    qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
+    monitor_printf(mon, " rd_bytes=%" PRId64
+                        " wr_bytes=%" PRId64
+                        " rd_operations=%" PRId64
+                        " wr_operations=%" PRId64
+                        "\n",
+                        qdict_get_int(qdict, "rd_bytes"),
+                        qdict_get_int(qdict, "wr_bytes"),
+                        qdict_get_int(qdict, "rd_operations"),
+                        qdict_get_int(qdict, "wr_operations"));
+}
+
+void bdrv_stats_print(Monitor *mon, const QObject *data)
+{
+    qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
+}
+
+/**
+ * bdrv_info_stats(): show block device statistics
+ *
+ * Each device statistic information is stored in a QDict and
+ * the returned QObject is a QList of all devices.
+ *
+ * The QDict contains the following:
+ *
+ * - "device": device name
+ * - "stats": QDict with the stats information, contains:
+ *     - "rd_bytes": bytes read
+ *     - "wr_bytes": bytes written
+ *     - "rd_operations": read operations
+ *     - "wr_operations": write operations
+ * 
+ * Example:
+ *
+ * [ { "device": "ide0-hd0",
+ *               "stats": { "rd_bytes": 512,
+ *                          "wr_bytes": 0,
+ *                          "rd_operations": 1,
+ *                          "wr_operations": 0 } },
+ *   { "device": "ide1-cd0",
+ *               "stats": { "rd_bytes": 0,
+ *                          "wr_bytes": 0,
+ *                          "rd_operations": 0,
+ *                          "wr_operations": 0 } } ]
+ */
+void bdrv_info_stats(Monitor *mon, QObject **ret_data)
+{
+    QObject *obj;
+    QList *devices;
     BlockDriverState *bs;
 
+    devices = qlist_new();
+
     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
-        monitor_printf(mon, "%s:"
-                       " rd_bytes=%" PRIu64
-                       " wr_bytes=%" PRIu64
-                       " rd_operations=%" PRIu64
-                       " wr_operations=%" PRIu64
-                       "\n",
-                       bs->device_name,
-                       bs->rd_bytes, bs->wr_bytes,
-                       bs->rd_ops, bs->wr_ops);
-    }
+        obj = qobject_from_jsonf("{ 'device': %s, 'stats': {"
+                                 "'rd_bytes': %" PRId64 ","
+                                 "'wr_bytes': %" PRId64 ","
+                                 "'rd_operations': %" PRId64 ","
+                                 "'wr_operations': %" PRId64
+                                 "} }",
+                                 bs->device_name,
+                                 bs->rd_bytes, bs->wr_bytes,
+                                 bs->rd_ops, bs->wr_ops);
+        assert(obj != NULL);
+        qlist_append_obj(devices, obj);
+    }
+
+    *ret_data = QOBJECT(devices);
 }
 
 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
diff --git a/block.h b/block.h
index 3ca7112..42087d2 100644
--- a/block.h
+++ b/block.h
@@ -44,7 +44,8 @@ typedef struct QEMUSnapshotInfo {
 
 void bdrv_info_print(Monitor *mon, const QObject *data);
 void bdrv_info(Monitor *mon, QObject **ret_data);
-void bdrv_info_stats(Monitor *mon);
+void bdrv_stats_print(Monitor *mon, const QObject *data);
+void bdrv_info_stats(Monitor *mon, QObject **ret_data);
 
 void bdrv_init(void);
 void bdrv_init_with_whitelist(void);
diff --git a/monitor.c b/monitor.c
index a0a9281..63274ba 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2056,7 +2056,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show block device statistics",
-        .mhandler.info = bdrv_info_stats,
+        .user_print = bdrv_stats_print,
+        .mhandler.info_new = bdrv_info_stats,
     },
     {
         .name       = "registers",
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 15/17] VNC: Convert do_info_vnc() to QObject

[Luiz Capitulino]

Return a QDict with server information. Connected clients are returned
as a QList of QDicts.

The new functions (vnc_qdict_remote_addr(), vnc_qdict_local_addr() and
put_addr_qdict()) are used to insert 'host' and 'service' information
in the returned QDict.

This patch is big, but I don't see how to split it.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 console.h |    3 +-
 monitor.c |    3 +-
 vnc.c     |  190 +++++++++++++++++++++++++++++++++++++++++++++++++++----------
 3 files changed, 163 insertions(+), 33 deletions(-)

diff --git a/console.h b/console.h
index 9615f56..9958860 100644
--- a/console.h
+++ b/console.h
@@ -322,7 +322,8 @@ void vnc_display_init(DisplayState *ds);
 void vnc_display_close(DisplayState *ds);
 int vnc_display_open(DisplayState *ds, const char *display);
 int vnc_display_password(DisplayState *ds, const char *password);
-void do_info_vnc(Monitor *mon);
+void do_info_vnc_print(Monitor *mon, const QObject *data);
+void do_info_vnc(Monitor *mon, QObject **ret_data);
 char *vnc_display_local_addr(DisplayState *ds);
 
 /* curses.c */
diff --git a/monitor.c b/monitor.c
index 63274ba..fb2f1c8 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2212,7 +2212,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show the vnc server status",
-        .mhandler.info = do_info_vnc,
+        .user_print = do_info_vnc_print,
+        .mhandler.info_new = do_info_vnc,
     },
     {
         .name       = "name",
diff --git a/vnc.c b/vnc.c
index 2bb8024..732a87b 100644
--- a/vnc.c
+++ b/vnc.c
@@ -29,6 +29,7 @@
 #include "qemu_socket.h"
 #include "qemu-timer.h"
 #include "acl.h"
+#include "qemu-objects.h"
 
 #define VNC_REFRESH_INTERVAL_BASE 30
 #define VNC_REFRESH_INTERVAL_INC  50
@@ -99,6 +100,52 @@ char *vnc_socket_remote_addr(const char *format, int fd) {
     return addr_to_string(format, &sa, salen);
 }
 
+static int put_addr_qdict(QDict *qdict, struct sockaddr_storage *sa,
+                          socklen_t salen)
+{
+    char host[NI_MAXHOST];
+    char serv[NI_MAXSERV];
+    int err;
+
+    if ((err = getnameinfo((struct sockaddr *)sa, salen,
+                           host, sizeof(host),
+                           serv, sizeof(serv),
+                           NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
+        VNC_DEBUG("Cannot resolve address %d: %s\n",
+                  err, gai_strerror(err));
+        return -1;
+    }
+
+    qdict_put(qdict, "host", qstring_from_str(host));
+    qdict_put(qdict, "service", qstring_from_str(serv));
+
+    return 0;
+}
+
+static int vnc_qdict_local_addr(QDict *qdict, int fd)
+{
+    struct sockaddr_storage sa;
+    socklen_t salen;
+
+    salen = sizeof(sa);
+    if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0)
+        return -1;
+
+    return put_addr_qdict(qdict, &sa, salen);
+}
+
+static int vnc_qdict_remote_addr(QDict *qdict, int fd)
+{
+    struct sockaddr_storage sa;
+    socklen_t salen;
+
+    salen = sizeof(sa);
+    if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0)
+        return -1;
+
+    return put_addr_qdict(qdict, &sa, salen);
+}
+
 static const char *vnc_auth_name(VncDisplay *vd) {
     switch (vd->auth) {
     case VNC_AUTH_INVALID:
@@ -150,58 +197,139 @@ static const char *vnc_auth_name(VncDisplay *vd) {
     return "unknown";
 }
 
-static void do_info_vnc_client(Monitor *mon, VncState *client)
+static QDict *do_info_vnc_client(Monitor *mon, VncState *client)
 {
-    char *clientAddr =
-        vnc_socket_remote_addr("     address: %s:%s\n",
-                               client->csock);
-    if (!clientAddr)
-        return;
+    QDict *qdict;
 
-    monitor_printf(mon, "Client:\n");
-    monitor_printf(mon, "%s", clientAddr);
-    free(clientAddr);
+    qdict = qdict_new();
+    if (vnc_qdict_remote_addr(qdict, client->csock) < 0) {
+        QDECREF(qdict);
+        return NULL;
+    }
 
 #ifdef CONFIG_VNC_TLS
     if (client->tls.session &&
-        client->tls.dname)
-        monitor_printf(mon, "  x509 dname: %s\n", client->tls.dname);
-    else
-        monitor_printf(mon, "  x509 dname: none\n");
+        client->tls.dname) {
+        qdict_put(qdict, "x509 dname", qstring_from_str(client->tls.dname));
+    } else {
+        qdict_put(qdict, "x509 dname", qstring_from_str("none"));
+    }
 #endif
 #ifdef CONFIG_VNC_SASL
     if (client->sasl.conn &&
-        client->sasl.username)
-        monitor_printf(mon, "    username: %s\n", client->sasl.username);
-    else
-        monitor_printf(mon, "    username: none\n");
+        client->sasl.username) {
+        qdict_put(qdict, "username", qstring_from_str(client->sasl.username));
+    } else {
+        qdict_put(qdict, "username", qstring_from_str("none"));
+    }
 #endif
+
+    return qdict;
 }
 
-void do_info_vnc(Monitor *mon)
+static void info_vnc_iter(QObject *obj, void *opaque)
 {
-    if (vnc_display == NULL || vnc_display->display == NULL) {
+    QDict *client;
+    Monitor *mon = opaque;
+
+    client = qobject_to_qdict(obj);
+    monitor_printf(mon, "Client:\n");
+    monitor_printf(mon, "     address: %s:%s\n",
+                   qdict_get_str(client, "host"),
+                   qdict_get_str(client, "service"));
+
+#ifdef CONFIG_VNC_TLS
+    monitor_printf(mon, "  x509 dname: %s\n",
+                   qdict_get_str(client, "x509 dname"));
+#endif
+#ifdef CONFIG_VNC_SASL
+    monitor_printf(mon, "    username: %s\n",
+                   qdict_get_str(client, "username"));
+#endif
+}
+
+void do_info_vnc_print(Monitor *mon, const QObject *data)
+{
+    QDict *server;
+    QList *clients;
+
+    server = qobject_to_qdict(data);
+    if (strcmp(qdict_get_str(server, "status"), "disabled") == 0) {
         monitor_printf(mon, "Server: disabled\n");
-    } else {
-        char *serverAddr = vnc_socket_local_addr("     address: %s:%s\n",
-                                                 vnc_display->lsock);
+        return;
+    }
 
-        if (!serverAddr)
-            return;
+    monitor_printf(mon, "Server:\n");
+    monitor_printf(mon, "     address: %s:%s\n",
+                   qdict_get_str(server, "host"),
+                   qdict_get_str(server, "service"));
+    monitor_printf(mon, "        auth: %s\n", qdict_get_str(server, "auth"));
 
-        monitor_printf(mon, "Server:\n");
-        monitor_printf(mon, "%s", serverAddr);
-        free(serverAddr);
-        monitor_printf(mon, "        auth: %s\n", vnc_auth_name(vnc_display));
+    clients = qdict_get_qlist(server, "clients");
+    if (qlist_empty(clients)) {
+        monitor_printf(mon, "Client: none\n");
+    } else {
+        qlist_iter(clients, info_vnc_iter, mon);
+    }
+}
 
+/**
+ * do_info_vnc(): Show VNC server information
+ *
+ * Return a QDict with server information. Connected clients are returned
+ * as a QList of QDicts.
+ *
+ * The main QDict contains the following:
+ *
+ * - "status": "disabled" or "enabled"
+ * - "host": server's IP address
+ * - "service": server's port number
+ * - "auth": authentication method
+ * - "clients": QList of all connected clients
+ *
+ * Clients are described by a QDict, with the following information:
+ *
+ * - "host": client's IP address
+ * - "service": client's port number
+ * - "x509 dname": TLS dname
+ * - "username": SASL username
+ *
+ * Example:
+ *
+ * { "status": "enabled", "host": "0.0.0.0", "service": "50402", "auth": "none",
+ *   "clients": [
+ *   { "host": "127.0.0.1", "service": "50401",
+ *     "x509 dname": "none", "username": "none" } ] }
+ */
+void do_info_vnc(Monitor *mon, QObject **ret_data)
+{
+    if (vnc_display == NULL || vnc_display->display == NULL) {
+        *ret_data = qobject_from_jsonf("{ 'status': 'disabled' }");
+    } else {
+        QDict *qdict;
+        QList *clist;
+
+        clist = qlist_new();
         if (vnc_display->clients) {
             VncState *client = vnc_display->clients;
             while (client) {
-                do_info_vnc_client(mon, client);
+                qdict = do_info_vnc_client(mon, client);
+                if (qdict)
+                    qlist_append(clist, qdict);
                 client = client->next;
             }
-        } else {
-            monitor_printf(mon, "Client: none\n");
+        }
+
+        *ret_data = qobject_from_jsonf("{ 'status': 'enabled', 'auth': %s, "
+                                       "'clients': %p }",
+                                       vnc_auth_name(vnc_display),
+                                       QOBJECT(clist));
+        assert(*ret_data != NULL);
+
+        qdict = qobject_to_qdict(*ret_data);
+        if (vnc_qdict_local_addr(qdict, vnc_display->lsock) < 0) {
+            qobject_decref(*ret_data);
+            *ret_data = NULL;
         }
     }
 }
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 16/17] net: Convert do_info_network() to QObject

[Luiz Capitulino]

Each VLAN is represented by a QDict, the returned QObject is a QList
of all VLANs.

This commit should not change user output.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 monitor.c |    3 +-
 net.c     |   72 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
 net.h     |    3 +-
 3 files changed, 72 insertions(+), 6 deletions(-)

diff --git a/monitor.c b/monitor.c
index fb2f1c8..de7a0f1 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2033,7 +2033,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show the network state",
-        .mhandler.info = do_info_network,
+        .user_print = do_info_network_print,
+        .mhandler.info_new = do_info_network,
     },
     {
         .name       = "chardev",
diff --git a/net.c b/net.c
index 9ea66e3..a0312af 100644
--- a/net.c
+++ b/net.c
@@ -106,6 +106,7 @@
 #include "qemu_socket.h"
 #include "qemu-log.h"
 #include "qemu-config.h"
+#include "qemu-objects.h"
 
 #include "slirp/libslirp.h"
 
@@ -2740,19 +2741,82 @@ void net_set_boot_mask(int net_boot_mask)
     }
 }
 
-void do_info_network(Monitor *mon)
+static void info_clients_iter(QObject *data, void *opaque)
 {
+    QDict *qdict;
+    Monitor *mon = opaque;
+
+    qdict = qobject_to_qdict(data);
+    monitor_printf(mon, "  %s: %s\n", qdict_get_str(qdict, "name"),
+                                      qdict_get_str(qdict, "info"));
+}
+
+static void info_network_iter(QObject *data, void *opaque)
+{
+    QDict *qdict;
+    Monitor *mon = opaque;
+
+    qdict = qobject_to_qdict(data);
+    monitor_printf(mon, "VLAN %" PRId64 " devices:\n",
+                   qdict_get_int(qdict, "id"));
+
+    qlist_iter(qdict_get_qlist(qdict, "devices"), info_clients_iter, opaque);
+}
+
+void do_info_network_print(Monitor *mon, const QObject *data)
+{
+    qlist_iter(qobject_to_qlist(data), info_network_iter, mon);
+}
+
+/**
+ * do_info_network(): Show VLANs and associated devices information
+ *
+ * Each VLAN is represented by a QDict, the returned QObject is a QList
+ * of all VLANs.
+ *
+ * Devices are also represented by a QDict and each VLAN contains a QList
+ * of its devices. 
+ *
+ * The VLAN QDict contains the following:
+ *
+ * - "id": VLAN id
+ * - "devices": a QList of all devices
+ *
+ *  The device QDict contains the following:
+ *
+ * - "name": device's name
+ * - "info": device's specific info string
+ *
+ * Example:
+ *
+ * [ { "id": 1, "devices": [
+ *     { "name": "e1000.1", "info": "model=e1000,macaddr=52:54:00:12:34:56" },
+ *     { "name": "socket.0", "info": "socket: connect to 127.0.0.1:8010" } ] } ]
+ */
+void do_info_network(Monitor *mon, QObject **ret_data)
+{
+    QObject *obj;
     VLANState *vlan;
+    QList *vlan_list;
+
+    vlan_list = qlist_new();
 
     QTAILQ_FOREACH(vlan, &vlans, next) {
         VLANClientState *vc;
-
-        monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
+        QList *clients = qlist_new();
 
         QTAILQ_FOREACH(vc, &vlan->clients, next) {
-            monitor_printf(mon, "  %s: %s\n", vc->name, vc->info_str);
+            obj = qobject_from_jsonf("{ 'name': %s, 'info': %s }",
+                                     vc->name, vc->info_str);
+            qlist_append_obj(clients, obj);
         }
+
+        obj = qobject_from_jsonf("{ 'id': %d, 'devices': %p }",
+                                 vlan->id, QOBJECT(clients));
+        qlist_append_obj(vlan_list, obj);
     }
+
+    *ret_data = QOBJECT(vlan_list);
 }
 
 void do_set_link(Monitor *mon, const QDict *qdict)
diff --git a/net.h b/net.h
index 4ffce91..66da212 100644
--- a/net.h
+++ b/net.h
@@ -105,7 +105,8 @@ void qemu_check_nic_model(NICInfo *nd, const char *model);
 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
                         const char *default_model);
 
-void do_info_network(Monitor *mon);
+void do_info_network_print(Monitor *mon, const QObject *data);
+void do_info_network(Monitor *mon, QObject **ret_data);
 void do_set_link(Monitor *mon, const QDict *qdict);
 
 void do_info_usernet(Monitor *mon);
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH 17/17] monitor: Convert do_info_mice() to QObject

[Luiz Capitulino]

Each mouse is represented by a QDict, the returned QObject is a QList of
all mice.

This commit should not change user output.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 console.h |    3 +-
 monitor.c |    3 +-
 vl.c      |   62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++------
 3 files changed, 59 insertions(+), 9 deletions(-)

diff --git a/console.h b/console.h
index 9958860..dfc8ae4 100644
--- a/console.h
+++ b/console.h
@@ -44,7 +44,8 @@ struct MouseTransformInfo {
     int a[7];
 };
 
-void do_info_mice(Monitor *mon);
+void do_info_mice_print(Monitor *mon, const QObject *data);
+void do_info_mice(Monitor *mon, QObject **ret_data);
 void do_mouse_set(Monitor *mon, const QDict *qdict);
 
 /* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
diff --git a/monitor.c b/monitor.c
index de7a0f1..c73d948 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2206,7 +2206,8 @@ static const mon_cmd_t info_cmds[] = {
         .args_type  = "",
         .params     = "",
         .help       = "show which guest mouse is receiving events",
-        .mhandler.info = do_info_mice,
+        .user_print = do_info_mice_print,
+        .mhandler.info_new = do_info_mice,
     },
     {
         .name       = "vnc",
diff --git a/vl.c b/vl.c
index c3f3c8f..73fe68d 100644
--- a/vl.c
+++ b/vl.c
@@ -157,6 +157,7 @@ int main(int argc, char **argv)
 #include "balloon.h"
 #include "qemu-option.h"
 #include "qemu-config.h"
+#include "qemu-objects.h"
 
 #include "disas.h"
 
@@ -459,25 +460,72 @@ int kbd_mouse_is_absolute(void)
     return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
 }
 
-void do_info_mice(Monitor *mon)
+static void info_mice_iter(QObject *data, void *opaque)
+{
+    QDict *mouse;
+    Monitor *mon = opaque;
+
+    mouse = qobject_to_qdict(data);
+    monitor_printf(mon, "%c Mouse #%" PRId64 ": %s\n",
+                  (qdict_get_bool(mouse, "current") ? '*' : ' '),
+                  qdict_get_int(mouse, "index"), qdict_get_str(mouse, "name"));
+}
+
+void do_info_mice_print(Monitor *mon, const QObject *data)
+{
+    QList *mice_list;
+
+    mice_list = qobject_to_qlist(data);
+    if (qlist_empty(mice_list)) {
+        monitor_printf(mon, "No mouse devices connected\n");
+        return;
+    }
+
+    qlist_iter(mice_list, info_mice_iter, mon);
+}
+
+/**
+ * do_info_mice(): Show VM mice information
+ *
+ * Each mouse is represented by a QDict, the returned QObject is a QList of
+ * all mice.
+ *
+ * The mouse QDict contains the following:
+ *
+ * - "name": mouse's name
+ * - "index": mouse's index
+ * - "current": true if this mouse isreceiving events, false otherwise
+ *
+ * Example:
+ *
+ * [ { "name": "QEMU Microsoft Mouse", "index": 0, "current": false },
+ *   { "name": "QEMU PS/2 Mouse", "index": 1, "current": true } ]
+ */
+void do_info_mice(Monitor *mon, QObject **ret_data)
 {
     QEMUPutMouseEntry *cursor;
+    QList *mice_list;
     int index = 0;
 
+    mice_list = qlist_new();
+
     if (!qemu_put_mouse_event_head) {
-        monitor_printf(mon, "No mouse devices connected\n");
-        return;
+        goto out;
     }
 
-    monitor_printf(mon, "Mouse devices available:\n");
     cursor = qemu_put_mouse_event_head;
     while (cursor != NULL) {
-        monitor_printf(mon, "%c Mouse #%d: %s\n",
-                       (cursor == qemu_put_mouse_event_current ? '*' : ' '),
-                       index, cursor->qemu_put_mouse_event_name);
+        QObject *obj;
+        obj = qobject_from_jsonf("{ 'name': %s, 'index': %d, 'current': %i }",
+                                 cursor->qemu_put_mouse_event_name,
+                                 index, cursor == qemu_put_mouse_event_current);
+        qlist_append_obj(mice_list, obj);
         index++;
         cursor = cursor->next;
     }
+
+out:
+    *ret_data = QOBJECT(mice_list);
 }
 
 void do_mouse_set(Monitor *mon, const QDict *qdict)
-- 
1.6.5.2.180.gc5b3e

[Qemu-devel] [PATCH v1 00/17]: info handlers conversions to QObject

[Luiz Capitulino]

 Hi,

 This series covers almost half of the info handlers conversions to the
QObject style, the other half is a bit more complicated as some handlers
can be defined by different machine types.

changelog
---------

v0 -> v1

- Minor fixes (indentation, casts, etc)
- Improved some documentation and changelogs
- Dropped do_info_network() conversion, it still needs work

[Qemu-devel] [PATCH 04/17] QDict: Introduce qdict_get_qlist()

[Luiz Capitulino]

A helper function to get a QList from a QDict.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 Makefile |    2 +-
 qdict.c  |   13 +++++++++++++
 qdict.h  |    2 ++
 3 files changed, 16 insertions(+), 1 deletions(-)

diff --git a/Makefile b/Makefile
index 8b4c4e6..89fbdc6 100644
--- a/Makefile
+++ b/Makefile
@@ -243,7 +243,7 @@ qemu-img-cmds.h: $(SRC_PATH)/qemu-img-cmds.hx
 
 check-qint: check-qint.o qint.o qemu-malloc.o
 check-qstring: check-qstring.o qstring.o qemu-malloc.o
-check-qdict: check-qdict.o qdict.o qint.o qstring.o qbool.o qemu-malloc.o
+check-qdict: check-qdict.o qdict.o qint.o qstring.o qbool.o qemu-malloc.o qlist.o
 check-qlist: check-qlist.o qlist.o qint.o qemu-malloc.o
 check-qfloat: check-qfloat.o qfloat.o qemu-malloc.o
 check-qjson: check-qjson.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o qjson.o json-streamer.o json-lexer.o json-parser.o qemu-malloc.o
diff --git a/qdict.c b/qdict.c
index 45e08be..ef73265 100644
--- a/qdict.c
+++ b/qdict.c
@@ -204,6 +204,19 @@ int qdict_get_bool(const QDict *qdict, const char *key)
 }
 
 /**
+ * qdict_get_qlist(): Get the QList mapped by 'key'
+ *
+ * This function assumes that 'key' exists and it stores a
+ * QList object.
+ *
+ * Return QList mapped by 'key'.
+ */
+QList *qdict_get_qlist(const QDict *qdict, const char *key)
+{
+    return qobject_to_qlist(qdict_get_obj(qdict, key, QTYPE_QLIST));
+}
+
+/**
  * qdict_get_str(): Get a pointer to the stored string mapped
  * by 'key'
  *
diff --git a/qdict.h b/qdict.h
index 1473c04..5fef1ea 100644
--- a/qdict.h
+++ b/qdict.h
@@ -2,6 +2,7 @@
 #define QDICT_H
 
 #include "qobject.h"
+#include "qlist.h"
 #include "qemu-queue.h"
 #include <stdint.h>
 
@@ -38,6 +39,7 @@ void qdict_iter(const QDict *qdict,
 /* High level helpers */
 int64_t qdict_get_int(const QDict *qdict, const char *key);
 int qdict_get_bool(const QDict *qdict, const char *key);
+QList *qdict_get_qlist(const QDict *qdict, const char *key);
 const char *qdict_get_str(const QDict *qdict, const char *key);
 int64_t qdict_get_try_int(const QDict *qdict, const char *key,
                           int64_t err_value);
-- 
1.6.5.3.148.g785c5

[Qemu-devel] [FOR 0.12 v2 00/17]: info handlers conversions to QObject

[Luiz Capitulino]

 Hi,

 This series covers almost half of the info handlers conversions to the
QObject style, the other half is a bit more complicated as some handlers
can be defined by different machine types.

changelog
---------

v1 -> v2

- Rebase
- do_info_vnc(): drop keys with 'none' strings

v0 -> v1

- Minor fixes (indentation, casts, etc)
- Improved some documentation and changelogs
- Dropped do_info_network() conversion, it still needs work

[Qemu-devel] [PATCH 04/17] QDict: Introduce qdict_get_qlist()

[Luiz Capitulino]

A helper function to get a QList from a QDict.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
---
 Makefile |    2 +-
 qdict.c  |   13 +++++++++++++
 qdict.h  |    2 ++
 3 files changed, 16 insertions(+), 1 deletions(-)

diff --git a/Makefile b/Makefile
index b4356ae..f1b0131 100644
--- a/Makefile
+++ b/Makefile
@@ -246,7 +246,7 @@ qemu-img-cmds.h: $(SRC_PATH)/qemu-img-cmds.hx
 
 check-qint: check-qint.o qint.o qemu-malloc.o
 check-qstring: check-qstring.o qstring.o qemu-malloc.o
-check-qdict: check-qdict.o qdict.o qint.o qstring.o qbool.o qemu-malloc.o
+check-qdict: check-qdict.o qdict.o qint.o qstring.o qbool.o qemu-malloc.o qlist.o
 check-qlist: check-qlist.o qlist.o qint.o qemu-malloc.o
 check-qfloat: check-qfloat.o qfloat.o qemu-malloc.o
 check-qjson: check-qjson.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o qjson.o json-streamer.o json-lexer.o json-parser.o qemu-malloc.o
diff --git a/qdict.c b/qdict.c
index 45e08be..ef73265 100644
--- a/qdict.c
+++ b/qdict.c
@@ -204,6 +204,19 @@ int qdict_get_bool(const QDict *qdict, const char *key)
 }
 
 /**
+ * qdict_get_qlist(): Get the QList mapped by 'key'
+ *
+ * This function assumes that 'key' exists and it stores a
+ * QList object.
+ *
+ * Return QList mapped by 'key'.
+ */
+QList *qdict_get_qlist(const QDict *qdict, const char *key)
+{
+    return qobject_to_qlist(qdict_get_obj(qdict, key, QTYPE_QLIST));
+}
+
+/**
  * qdict_get_str(): Get a pointer to the stored string mapped
  * by 'key'
  *
diff --git a/qdict.h b/qdict.h
index 1473c04..5fef1ea 100644
--- a/qdict.h
+++ b/qdict.h
@@ -2,6 +2,7 @@
 #define QDICT_H
 
 #include "qobject.h"
+#include "qlist.h"
 #include "qemu-queue.h"
 #include <stdint.h>
 
@@ -38,6 +39,7 @@ void qdict_iter(const QDict *qdict,
 /* High level helpers */
 int64_t qdict_get_int(const QDict *qdict, const char *key);
 int qdict_get_bool(const QDict *qdict, const char *key);
+QList *qdict_get_qlist(const QDict *qdict, const char *key);
 const char *qdict_get_str(const QDict *qdict, const char *key);
 int64_t qdict_get_try_int(const QDict *qdict, const char *key,
                           int64_t err_value);
-- 
1.6.6.rc1.5.ge21a85