[libvirt] [PATCH 15/15] Start of support for JSON based QEMU monitor protocol

Tuesday, 3 November 2009

Initial support for the new QEMU monitor protocol  using JSON
as the data encoding format instead of plain text

* src/qemu/qemu_conf.c, src/qemu/qemu_conf.h: Hack to turn on QMP
  mode
* src/qemu/qemu_monitor.c: Delegate to json monitor if enabled
* src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h: Add
  impl of QMP protocol
* src/Makefile.am: Add src/qemu/qemu_monitor_json.{c,h}
---
 po/POTFILES.in               |    1 +
 src/Makefile.am              |    2 +
 src/qemu/qemu_conf.c         |   10 +-
 src/qemu/qemu_conf.h         |    3 +
 src/qemu/qemu_monitor.c      |  260 +++++++++++---
 src/qemu/qemu_monitor_json.c |  817 ++++++++++++++++++++++++++++++++++++++++++
 src/qemu/qemu_monitor_json.h |  155 ++++++++
 7 files changed, 1201 insertions(+), 47 deletions(-)
 create mode 100644 src/qemu/qemu_monitor_json.c
 create mode 100644 src/qemu/qemu_monitor_json.h

diff --git a/po/POTFILES.in b/po/POTFILES.in
index 5b9a364..2fcb9bf 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -27,6 +27,7 @@ src/phyp/phyp_driver.c
 src/qemu/qemu_conf.c
 src/qemu/qemu_driver.c
 src/qemu/qemu_monitor.c
+src/qemu/qemu_monitor_json.c
 src/qemu/qemu_monitor_text.c
 src/remote/remote_driver.c
 src/secret/secret_driver.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 9660a99..dce5792 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -186,6 +186,8 @@ QEMU_DRIVER_SOURCES =						\
 		qemu/qemu_monitor.c qemu/qemu_monitor.h		\
 		qemu/qemu_monitor_text.c			\
 		qemu/qemu_monitor_text.h			\
+		qemu/qemu_monitor_json.c			\
+		qemu/qemu_monitor_json.h			\
 		qemu/qemu_driver.c qemu/qemu_driver.h
 
 UML_DRIVER_SOURCES =						\
diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c
index b01fddc..d03d522 100644
--- a/src/qemu/qemu_conf.c
+++ b/src/qemu/qemu_conf.c
@@ -1748,10 +1748,18 @@ int qemudBuildCommandLine(virConnectPtr conn,
         ADD_ARG_LIT("-nographic");
 
     if (monitor_chr) {
+        /* XXX gross hack for testing */
+#if QEMU_WITH_JSON
+        char buf[4096] = "control,";
+
+        if (qemudBuildCommandLineChrDevStr(monitor_chr, buf + 8, sizeof(buf)-8) < 0)
+            goto error;
+#else
         char buf[4096];
 
-        if (qemudBuildCommandLineChrDevStr(monitor_chr, buf, sizeof(buf)) < 0)
+        if (qemudBuildCommandLineChrDevStr(monitor_chr, buf, sizeof(buf)-8) < 0)
             goto error;
+#endif
 
         ADD_ARG_LIT("-monitor");
         ADD_ARG_LIT(buf);
diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h
index f9a970f..336e30d 100644
--- a/src/qemu/qemu_conf.h
+++ b/src/qemu/qemu_conf.h
@@ -39,6 +39,9 @@
 
 #define qemudDebug(fmt, ...) do {} while(0)
 
+/* XXX gross hack for testing purposes */
+#define QEMU_WITH_JSON 0
+
 #define QEMUD_CPUMASK_LEN CPU_SETSIZE
 
 /* Internal flags to keep track of qemu command line capabilities */
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 501cb3f..573bee9 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -30,6 +30,7 @@
 
 #include "qemu_monitor.h"
 #include "qemu_monitor_text.h"
+#include "qemu_monitor_json.h"
 #include "qemu_conf.h"
 #include "event.h"
 #include "virterror_internal.h"
@@ -71,6 +72,8 @@ struct _qemuMonitor {
     unsigned eofcb: 1;
     /* If the monitor callback should free the closed monitor */
     unsigned closed: 1;
+
+    unsigned json: 1;
 };
 
 void qemuMonitorLock(qemuMonitorPtr mon)
@@ -180,9 +183,14 @@ qemuMonitorIOProcess(qemuMonitorPtr mon)
         msg = mon->msg;
 
     VIR_DEBUG("Process %d", mon->bufferOffset);
-    len = qemuMonitorTextIOProcess(mon,
-                                   mon->buffer, mon->bufferOffset,
-                                   msg);
+    if (mon->json)
+        len = qemuMonitorJSONIOProcess(mon,
+                                       mon->buffer, mon->bufferOffset,
+                                       msg);
+    else
+        len = qemuMonitorTextIOProcess(mon,
+                                       mon->buffer, mon->bufferOffset,
+                                       msg);
 
     if (len < 0) {
         mon->lastErrno = errno;
@@ -455,6 +463,7 @@ qemuMonitorOpen(virDomainObjPtr vm,
     mon->fd = -1;
     mon->vm = vm;
     mon->eofCB = eofCB;
+    mon->json = QEMU_WITH_JSON;
     qemuMonitorLock(mon);
 
     switch (vm->monitor_chr->type) {
@@ -595,43 +604,68 @@ int
 qemuMonitorStartCPUs(qemuMonitorPtr mon,
                      virConnectPtr conn)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d", mon, mon->fd);
 
-    return qemuMonitorTextStartCPUs(mon, conn);
+    if (mon->json)
+        ret = qemuMonitorJSONStartCPUs(mon, conn);
+    else
+        ret = qemuMonitorTextStartCPUs(mon, conn);
+    return ret;
 }
 
 
 int
 qemuMonitorStopCPUs(qemuMonitorPtr mon)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d", mon, mon->fd);
 
-    return qemuMonitorTextStopCPUs(mon);
+    if (mon->json)
+        ret = qemuMonitorJSONStopCPUs(mon);
+    else
+        ret = qemuMonitorTextStopCPUs(mon);
+    return ret;
 }
 
 
 int qemuMonitorSystemPowerdown(qemuMonitorPtr mon)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d", mon, mon->fd);
 
-    return qemuMonitorTextSystemPowerdown(mon);
+    if (mon->json)
+        ret = qemuMonitorJSONSystemPowerdown(mon);
+    else
+        ret = qemuMonitorTextSystemPowerdown(mon);
+    return ret;
 }
 
 
 int qemuMonitorGetCPUInfo(qemuMonitorPtr mon,
                           int **pids)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d", mon, mon->fd);
 
-    return qemuMonitorTextGetCPUInfo(mon, pids);
+    if (mon->json)
+        ret = qemuMonitorJSONGetCPUInfo(mon, pids);
+    else
+        ret = qemuMonitorTextGetCPUInfo(mon, pids);
+    return ret;
 }
 
 int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon,
                               unsigned long *currmem)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d", mon, mon->fd);
 
-    return qemuMonitorTextGetBalloonInfo(mon, currmem);
+    if (mon->json)
+        ret = qemuMonitorJSONGetBalloonInfo(mon, currmem);
+    else
+        ret = qemuMonitorTextGetBalloonInfo(mon, currmem);
+    return ret;
 }
 
 
@@ -643,38 +677,61 @@ int qemuMonitorGetBlockStatsInfo(qemuMonitorPtr mon,
                                  long long *wr_bytes,
                                  long long *errs)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d dev=%s", mon, mon->fd, devname);
 
-    return qemuMonitorTextGetBlockStatsInfo(mon, devname,
-                                            rd_req, rd_bytes,
-                                            wr_req, wr_bytes,
-                                            errs);
+    if (mon->json)
+        ret = qemuMonitorJSONGetBlockStatsInfo(mon, devname,
+                                               rd_req, rd_bytes,
+                                               wr_req, wr_bytes,
+                                               errs);
+    else
+        ret = qemuMonitorTextGetBlockStatsInfo(mon, devname,
+                                               rd_req, rd_bytes,
+                                               wr_req, wr_bytes,
+                                               errs);
+    return ret;
 }
 
 
 int qemuMonitorSetVNCPassword(qemuMonitorPtr mon,
                               const char *password)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d", mon, mon->fd);
 
-    return qemuMonitorTextSetVNCPassword(mon, password);
+    if (mon->json)
+        ret = qemuMonitorJSONSetVNCPassword(mon, password);
+    else
+        ret = qemuMonitorTextSetVNCPassword(mon, password);
+    return ret;
 }
 
 
 int qemuMonitorSetBalloon(qemuMonitorPtr mon,
                           unsigned long newmem)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d newmem=%lu", mon, mon->fd, newmem);
 
-    return qemuMonitorTextSetBalloon(mon, newmem);
+    if (mon->json)
+        ret = qemuMonitorJSONSetBalloon(mon, newmem);
+    else
+        ret = qemuMonitorTextSetBalloon(mon, newmem);
+    return ret;
 }
 
 int qemuMonitorEjectMedia(qemuMonitorPtr mon,
                           const char *devname)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d devname=%s", mon, mon->fd, devname);
 
-    return qemuMonitorTextEjectMedia(mon, devname);
+    if (mon->json)
+        ret = qemuMonitorJSONEjectMedia(mon, devname);
+    else
+        ret = qemuMonitorTextEjectMedia(mon, devname);
+    return ret;
 }
 
 
@@ -682,10 +739,15 @@ int qemuMonitorChangeMedia(qemuMonitorPtr mon,
                            const char *devname,
                            const char *newmedia)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d devname=%s newmedia=%s",
           mon, mon->fd, devname, newmedia);
 
-    return qemuMonitorTextChangeMedia(mon, devname, newmedia);
+    if (mon->json)
+        ret = qemuMonitorJSONChangeMedia(mon, devname, newmedia);
+    else
+        ret = qemuMonitorTextChangeMedia(mon, devname, newmedia);
+    return ret;
 }
 
 
@@ -694,10 +756,15 @@ int qemuMonitorSaveVirtualMemory(qemuMonitorPtr mon,
                                  size_t length,
                                  const char *path)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d offset=%llu length=%zu path=%s",
           mon, mon->fd, offset, length, path);
 
-    return qemuMonitorTextSaveVirtualMemory(mon, offset, length, path);
+    if (mon->json)
+        ret = qemuMonitorJSONSaveVirtualMemory(mon, offset, length, path);
+    else
+        ret = qemuMonitorTextSaveVirtualMemory(mon, offset, length, path);
+    return ret;
 }
 
 int qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon,
@@ -705,19 +772,29 @@ int qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon,
                                   size_t length,
                                   const char *path)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d offset=%llu length=%zu path=%s",
           mon, mon->fd, offset, length, path);
 
-    return qemuMonitorTextSavePhysicalMemory(mon, offset, length, path);
+    if (mon->json)
+        ret = qemuMonitorJSONSavePhysicalMemory(mon, offset, length, path);
+    else
+        ret = qemuMonitorTextSavePhysicalMemory(mon, offset, length, path);
+    return ret;
 }
 
 
 int qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon,
                                  unsigned long bandwidth)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d bandwidth=%lu", mon, mon->fd, bandwidth);
 
-    return qemuMonitorTextSetMigrationSpeed(mon, bandwidth);
+    if (mon->json)
+        ret = qemuMonitorJSONSetMigrationSpeed(mon, bandwidth);
+    else
+        ret = qemuMonitorTextSetMigrationSpeed(mon, bandwidth);
+    return ret;
 }
 
 int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon,
@@ -726,12 +803,20 @@ int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon,
                                   unsigned long long *remaining,
                                   unsigned long long *total)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d", mon, mon->fd);
 
-    return qemuMonitorTextGetMigrationStatus(mon, status,
-                                             transferred,
-                                             remaining,
-                                             total);
+    if (mon->json)
+        ret = qemuMonitorJSONGetMigrationStatus(mon, status,
+                                                transferred,
+                                                remaining,
+                                                total);
+    else
+        ret = qemuMonitorTextGetMigrationStatus(mon, status,
+                                                transferred,
+                                                remaining,
+                                                total);
+    return ret;
 }
 
 
@@ -740,10 +825,15 @@ int qemuMonitorMigrateToHost(qemuMonitorPtr mon,
                              const char *hostname,
                              int port)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d hostname=%s port=%d",
           mon, mon->fd, hostname, port);
 
-    return qemuMonitorTextMigrateToHost(mon, background, hostname, port);
+    if (mon->json)
+        ret = qemuMonitorJSONMigrateToHost(mon, background, hostname, port);
+    else
+        ret = qemuMonitorTextMigrateToHost(mon, background, hostname, port);
+    return ret;
 }
 
 
@@ -752,35 +842,55 @@ int qemuMonitorMigrateToCommand(qemuMonitorPtr mon,
                                 const char * const *argv,
                                 const char *target)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d argv=%p target=%s",
           mon, mon->fd, argv, target);
 
-    return qemuMonitorTextMigrateToCommand(mon, background, argv, target);
+    if (mon->json)
+        ret = qemuMonitorJSONMigrateToCommand(mon, background, argv, target);
+    else
+        ret = qemuMonitorTextMigrateToCommand(mon, background, argv, target);
+    return ret;
 }
 
 int qemuMonitorMigrateToUnix(qemuMonitorPtr mon,
                              int background,
                              const char *unixfile)
 {
+    int ret;
     DEBUG("mon=%p fd=%d unixfile=%s",
           mon, mon->fd, unixfile);
 
-    return qemuMonitorTextMigrateToUnix(mon, background, unixfile);
+    if (mon->json)
+        ret = qemuMonitorJSONMigrateToUnix(mon, background, unixfile);
+    else
+        ret = qemuMonitorTextMigrateToUnix(mon, background, unixfile);
+    return ret;
 }
 
 int qemuMonitorMigrateCancel(qemuMonitorPtr mon)
 {
+    int ret;
     DEBUG("mon=%p fd=%d", mon, mon->fd);
 
-    return qemuMonitorTextMigrateCancel(mon);
+    if (mon->json)
+        ret = qemuMonitorJSONMigrateCancel(mon);
+    else
+        ret = qemuMonitorTextMigrateCancel(mon);
+    return ret;
 }
 
 int qemuMonitorAddUSBDisk(qemuMonitorPtr mon,
                           const char *path)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d path=%s", mon, mon->fd, path);
 
-    return qemuMonitorTextAddUSBDisk(mon, path);
+    if (mon->json)
+        ret = qemuMonitorJSONAddUSBDisk(mon, path);
+    else
+        ret = qemuMonitorTextAddUSBDisk(mon, path);
+    return ret;
 }
 
 
@@ -788,19 +898,29 @@ int qemuMonitorAddUSBDeviceExact(qemuMonitorPtr mon,
                                  int bus,
                                  int dev)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d bus=%d dev=%d", mon, mon->fd, bus, dev);
 
-    return qemuMonitorTextAddUSBDeviceExact(mon, bus, dev);
+    if (mon->json)
+        ret = qemuMonitorJSONAddUSBDeviceExact(mon, bus, dev);
+    else
+        ret = qemuMonitorTextAddUSBDeviceExact(mon, bus, dev);
+    return ret;
 }
 
 int qemuMonitorAddUSBDeviceMatch(qemuMonitorPtr mon,
                                  int vendor,
                                  int product)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d vendor=%d product=%d",
           mon, mon->fd, vendor, product);
 
-    return qemuMonitorTextAddUSBDeviceMatch(mon, vendor, product);
+    if (mon->json)
+        ret = qemuMonitorJSONAddUSBDeviceMatch(mon, vendor, product);
+    else
+        ret = qemuMonitorTextAddUSBDeviceMatch(mon, vendor, product);
+    return ret;
 }
 
 
@@ -813,16 +933,26 @@ int qemuMonitorAddPCIHostDevice(qemuMonitorPtr mon,
                                 unsigned *guestBus,
                                 unsigned *guestSlot)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d domain=%d bus=%d slot=%d function=%d",
           mon, mon->fd,
           hostDomain, hostBus, hostSlot, hostFunction);
 
-    return qemuMonitorTextAddPCIHostDevice(mon, hostDomain,
-                                           hostBus, hostSlot,
-                                           hostFunction,
-                                           guestDomain,
-                                           guestBus,
-                                           guestSlot);
+    if (mon->json)
+        ret = qemuMonitorJSONAddPCIHostDevice(mon, hostDomain,
+                                              hostBus, hostSlot,
+                                              hostFunction,
+                                              guestDomain,
+                                              guestBus,
+                                              guestSlot);
+    else
+        ret = qemuMonitorTextAddPCIHostDevice(mon, hostDomain,
+                                              hostBus, hostSlot,
+                                              hostFunction,
+                                              guestDomain,
+                                              guestBus,
+                                              guestSlot);
+    return ret;
 }
 
 
@@ -833,11 +963,17 @@ int qemuMonitorAddPCIDisk(qemuMonitorPtr mon,
                           unsigned *guestBus,
                           unsigned *guestSlot)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d path=%s bus=%s",
           mon, mon->fd, path, bus);
 
-    return qemuMonitorTextAddPCIDisk(mon, path, bus,
-                                     guestDomain, guestBus, guestSlot);
+    if (mon->json)
+        ret = qemuMonitorJSONAddPCIDisk(mon, path, bus,
+                                        guestDomain, guestBus, guestSlot);
+    else
+        ret = qemuMonitorTextAddPCIDisk(mon, path, bus,
+                                        guestDomain, guestBus, guestSlot);
+    return ret;
 }
 
 
@@ -847,10 +983,16 @@ int qemuMonitorAddPCINetwork(qemuMonitorPtr mon,
                              unsigned *guestBus,
                              unsigned *guestSlot)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d nicstr=%s", mon, mon->fd, nicstr);
 
-    return qemuMonitorTextAddPCINetwork(mon, nicstr, guestDomain,
-                                        guestBus, guestSlot);
+    if (mon->json)
+        ret = qemuMonitorJSONAddPCINetwork(mon, nicstr, guestDomain,
+                                           guestBus, guestSlot);
+    else
+        ret = qemuMonitorTextAddPCINetwork(mon, nicstr, guestDomain,
+                                           guestBus, guestSlot);
+    return ret;
 }
 
 
@@ -859,11 +1001,17 @@ int qemuMonitorRemovePCIDevice(qemuMonitorPtr mon,
                                unsigned guestBus,
                                unsigned guestSlot)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d domain=%d bus=%d slot=%d",
           mon, mon->fd, guestDomain, guestBus, guestSlot);
 
-    return qemuMonitorTextRemovePCIDevice(mon, guestDomain,
-                                          guestBus, guestSlot);
+    if (mon->json)
+        ret = qemuMonitorJSONRemovePCIDevice(mon, guestDomain,
+                                             guestBus, guestSlot);
+    else
+        ret = qemuMonitorTextRemovePCIDevice(mon, guestDomain,
+                                             guestBus, guestSlot);
+    return ret;
 }
 
 
@@ -871,30 +1019,45 @@ int qemuMonitorSendFileHandle(qemuMonitorPtr mon,
                               const char *fdname,
                               int fd)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d fdname=%s fd=%d",
           mon, mon->fd, fdname, fd);
 
-    return qemuMonitorTextSendFileHandle(mon, fdname, fd);
+    if (mon->json)
+        ret = qemuMonitorJSONSendFileHandle(mon, fdname, fd);
+    else
+        ret = qemuMonitorTextSendFileHandle(mon, fdname, fd);
+    return ret;
 }
 
 
 int qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
                                const char *fdname)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d fdname=%s",
           mon, mon->fd, fdname);
 
-    return qemuMonitorTextCloseFileHandle(mon, fdname);
+    if (mon->json)
+        ret = qemuMonitorJSONCloseFileHandle(mon, fdname);
+    else
+        ret = qemuMonitorTextCloseFileHandle(mon, fdname);
+    return ret;
 }
 
 
 int qemuMonitorAddHostNetwork(qemuMonitorPtr mon,
                               const char *netstr)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d netstr=%s",
           mon, mon->fd, netstr);
 
-    return qemuMonitorTextAddHostNetwork(mon, netstr);
+    if (mon->json)
+        ret = qemuMonitorJSONAddHostNetwork(mon, netstr);
+    else
+        ret = qemuMonitorTextAddHostNetwork(mon, netstr);
+    return ret;
 }
 
 
@@ -902,8 +1065,13 @@ int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon,
                                  int vlan,
                                  const char *netname)
 {
+    int ret;
     DEBUG("mon=%p, fd=%d netname=%s",
           mon, mon->fd, netname);
 
-    return qemuMonitorTextRemoveHostNetwork(mon, vlan, netname);
+    if (mon->json)
+        ret = qemuMonitorJSONRemoveHostNetwork(mon, vlan, netname);
+    else
+        ret = qemuMonitorTextRemoveHostNetwork(mon, vlan, netname);
+    return ret;
 }
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
new file mode 100644
index 0000000..95f74fa
--- /dev/null
+++ b/src/qemu/qemu_monitor_json.c
@@ -0,0 +1,817 @@
+/*
+ * qemu_monitor_json.c: interaction with QEMU monitor console
+ *
+ * Copyright (C) 2006-2009 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange(a)redhat.com&gt;
+ */
+
+#include <config.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <poll.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "qemu_monitor_json.h"
+#include "qemu_conf.h"
+#include "memory.h"
+#include "logging.h"
+#include "driver.h"
+#include "datatypes.h"
+#include "virterror_internal.h"
+#include "json.h"
+
+#define VIR_FROM_THIS VIR_FROM_QEMU
+
+
+#define LINE_ENDING "\r\n"
+
+static int
+qemuMonitorJSONIOProcessLine(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
+                             const char *line,
+                             qemuMonitorMessagePtr msg)
+{
+    json_t *obj = NULL;
+    json_t *val;
+    int ret = -1;
+
+    VIR_DEBUG("Line [%s]", line);
+
+    if (json_parse_document(&obj, line) != JSON_OK) {
+        VIR_DEBUG0("Parsing JSON string failed");
+        errno = EINVAL;
+        goto cleanup;
+    }
+
+    if (obj->type != JSON_OBJECT) {
+        VIR_DEBUG0("Parsed JSON string isn't an object");
+        errno = EINVAL;
+    }
+
+    if (json_find_first_label(obj, "QMP", &val) == JSON_OK) {
+        VIR_DEBUG0("Got QMP capabilities data");
+        ret = 0;
+        goto cleanup;
+    }
+
+    if (json_find_first_label(obj, "event", &val) == JSON_OK) {
+        VIR_DEBUG0("Got an event");
+        ret = 0;
+        goto cleanup;
+    }
+
+    if (msg) {
+        msg->rxBuffer = strdup(line);
+        msg->rxLength = strlen(line);
+        msg->finished = 1;
+    } else {
+        VIR_DEBUG("Ignoring unexpected JSON message [%s]", line);
+    }
+
+    ret = 0;
+
+cleanup:
+    if (obj)
+        json_free_value(&obj);
+    return ret;
+}
+
+int qemuMonitorJSONIOProcess(qemuMonitorPtr mon,
+                             const char *data,
+                             size_t len,
+                             qemuMonitorMessagePtr msg)
+{
+    int used = 0;
+    VIR_DEBUG("Data %d bytes [%s]", len, data);
+
+    while (used < len) {
+        char *nl = strstr(data + used, LINE_ENDING);
+
+        if (nl) {
+            int got = nl - (data + used);
+            char *line = strndup(data + used, got);
+            used += got + strlen(LINE_ENDING);
+
+            if (qemuMonitorJSONIOProcessLine(mon, line, msg) < 0) {
+                VIR_FREE(line);
+                return -1;
+            }
+
+            VIR_FREE(line);
+        } else {
+            break;
+        }
+    }
+
+    VIR_DEBUG("Total used %d", used);
+    return used;
+}
+
+static int
+qemuMonitorCommandWithFd(qemuMonitorPtr mon,
+                         json_t *cmd,
+                         int scm_fd,
+                         json_t **reply)
+{
+    int ret = -1;
+    qemuMonitorMessage msg;
+    char *cmdstr = NULL;
+
+    *reply = NULL;
+
+    memset(&msg, 0, sizeof msg);
+
+    if (json_tree_to_string(cmd, &cmdstr) != JSON_OK) {
+        virReportOOMError(NULL);
+        goto cleanup;
+    }
+    if (virAsprintf(&msg.txBuffer, "%s\r\n", cmdstr) < 0) {
+        virReportOOMError(NULL);
+        goto cleanup;
+    }
+    msg.txLength = strlen(msg.txBuffer);
+    msg.txFD = scm_fd;
+
+    VIR_DEBUG("Send command '%s' for write with FD %d", cmdstr,
scm_fd);
+
+    ret = qemuMonitorSend(mon, &msg);
+
+    VIR_DEBUG("Receive command reply ret=%d errno=%d %d bytes '%s'",
+              ret, msg.lastErrno, msg.rxLength, msg.rxBuffer);
+
+
+    /* To make life safer for callers, already ensure there's at least an empty
string */
+    if (msg.rxBuffer && ret == 0) {
+        if (json_parse_document(reply, msg.rxBuffer) != JSON_OK) {
+            qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
+                             _("cannot parse JSON doc '%s'"),
msg.rxBuffer);
+            goto cleanup;
+        }
+    }
+
+    if (ret < 0)
+        virReportSystemError(NULL, msg.lastErrno,
+                             _("cannot send monitor command '%s'"),
cmdstr);
+
+cleanup:
+    VIR_FREE(cmdstr);
+    VIR_FREE(msg.txBuffer);
+    VIR_FREE(msg.rxBuffer);
+
+    return ret;
+}
+
+
+static int
+qemuMonitorCommand(qemuMonitorPtr mon,
+                   json_t *cmd,
+                   json_t **reply) {
+    return qemuMonitorCommandWithFd(mon, cmd, -1, reply);
+}
+
+
+static json_t *
+qemuMonitorJSONMakeCommand(const char *cmdname,
+                           ...)
+{
+    json_t *obj;
+    json_t *jargs = NULL;
+    va_list args;
+    char *key;
+    char *val;
+
+    va_start(args, cmdname);
+
+    if (!(obj  = json_new_object()))
+        goto no_memory;
+
+    if (json_insert_string_pair_into_object(obj, "execute", cmdname) !=
JSON_OK)
+        goto no_memory;
+
+    while ((key = va_arg(args, char *)) != NULL) {
+        val = va_arg(args, char *);
+        if (!val)
+            goto error;
+
+        if (!jargs &&
+            !(jargs = json_new_object()))
+            goto no_memory;
+
+        if (json_insert_string_pair_into_object(obj, key, val) != JSON_OK)
+            goto no_memory;
+    }
+
+    if (jargs &&
+        json_insert_pair_into_object(obj, "arguments", jargs) != JSON_OK)
+        goto no_memory;
+
+    va_end(args);
+
+    return obj;
+
+no_memory:
+    virReportOOMError(NULL);
+error:
+    if (obj)
+        json_free_value(&obj);
+    if (jargs)
+        json_free_value(&jargs);
+    va_end(args);
+    return NULL;
+}
+
+
+int
+qemuMonitorJSONStartCPUs(qemuMonitorPtr mon,
+                         virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("cont", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int
+qemuMonitorJSONStopCPUs(qemuMonitorPtr mon)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("stop", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONSystemPowerdown(qemuMonitorPtr mon)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("system_powerdown", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONGetCPUInfo(qemuMonitorPtr mon,
+                              int **pids)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("info", "type",
"cpus", NULL);
+    json_t *reply = NULL;
+
+    *pids = NULL;
+
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+
+/*
+ * Returns: 0 if balloon not supported, +1 if balloon query worked
+ * or -1 on failure
+ */
+int qemuMonitorJSONGetBalloonInfo(qemuMonitorPtr mon,
+                                  unsigned long *currmem)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("info", "type",
"balloon", NULL);
+    json_t *reply = NULL;
+
+    *currmem = 0;
+
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONGetBlockStatsInfo(qemuMonitorPtr mon,
+                                     const char *devname ATTRIBUTE_UNUSED,
+                                     long long *rd_req,
+                                     long long *rd_bytes,
+                                     long long *wr_req,
+                                     long long *wr_bytes,
+                                     long long *errs)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("info", "type",
"blockstats", NULL);
+    json_t *reply = NULL;
+
+    *rd_req = *rd_bytes = *wr_req = *wr_bytes = *errs = 0;
+
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONSetVNCPassword(qemuMonitorPtr mon,
+                                  const char *password)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("change", "type",
"vnc", "password", password, NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+/*
+ * Returns: 0 if balloon not supported, +1 if balloon adjust worked
+ * or -1 on failure
+ */
+int qemuMonitorJSONSetBalloon(qemuMonitorPtr mon,
+                              unsigned long newmem ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("balloon", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+int qemuMonitorJSONEjectMedia(qemuMonitorPtr mon,
+                              const char *devname)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("eject", "device",
devname, NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONChangeMedia(qemuMonitorPtr mon,
+                               const char *devname,
+                               const char *newmedia)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("change", "device",
devname, "media", newmedia, NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+static int qemuMonitorJSONSaveMemory(qemuMonitorPtr mon,
+                                     const char *cmdtype,
+                                     unsigned long long offset ATTRIBUTE_UNUSED,
+                                     size_t length ATTRIBUTE_UNUSED,
+                                     const char *path ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand(cmdtype, NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONSaveVirtualMemory(qemuMonitorPtr mon,
+                                     unsigned long long offset,
+                                     size_t length,
+                                     const char *path)
+{
+    return qemuMonitorJSONSaveMemory(mon, "memsave", offset, length, path);
+}
+
+int qemuMonitorJSONSavePhysicalMemory(qemuMonitorPtr mon,
+                                      unsigned long long offset,
+                                      size_t length,
+                                      const char *path)
+{
+    return qemuMonitorJSONSaveMemory(mon, "pmemsave", offset, length, path);
+}
+
+
+int qemuMonitorJSONSetMigrationSpeed(qemuMonitorPtr mon,
+                                     unsigned long bandwidth ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("migrate_set_speed", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon,
+                                      int *status,
+                                      unsigned long long *transferred,
+                                      unsigned long long *remaining,
+                                      unsigned long long *total) {
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("info migration", NULL);
+    json_t *reply = NULL;
+
+    *status = 0;
+    *transferred = *remaining = *total = 0;
+
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONMigrateToHost(qemuMonitorPtr mon,
+                                 int background ATTRIBUTE_UNUSED,
+                                 const char *hostname ATTRIBUTE_UNUSED,
+                                 int port ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("migrate", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONMigrateToCommand(qemuMonitorPtr mon,
+                                    int background ATTRIBUTE_UNUSED,
+                                    const char * const *argv ATTRIBUTE_UNUSED,
+                                    const char *target ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("migrate", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+int qemuMonitorJSONMigrateToUnix(qemuMonitorPtr mon,
+                                 int background ATTRIBUTE_UNUSED,
+                                 const char *unixfile ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("migrate", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+int qemuMonitorJSONMigrateCancel(qemuMonitorPtr mon)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("migrate", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+int qemuMonitorJSONAddUSBDisk(qemuMonitorPtr mon,
+                              const char *path)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("usb_add", "type",
"disk", "path", path, NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONAddUSBDeviceExact(qemuMonitorPtr mon,
+                                     int bus ATTRIBUTE_UNUSED,
+                                     int dev ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("usb_add", "type",
"host", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+
+}
+
+int qemuMonitorJSONAddUSBDeviceMatch(qemuMonitorPtr mon,
+                                     int vendor ATTRIBUTE_UNUSED,
+                                     int product ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("usb_add", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONAddPCIHostDevice(qemuMonitorPtr mon,
+                                    unsigned hostDomain ATTRIBUTE_UNUSED,
+                                    unsigned hostBus ATTRIBUTE_UNUSED,
+                                    unsigned hostSlot ATTRIBUTE_UNUSED,
+                                    unsigned hostFunction ATTRIBUTE_UNUSED,
+                                    unsigned *guestDomain,
+                                    unsigned *guestBus,
+                                    unsigned *guestSlot)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("pci_add", NULL);
+    json_t *reply = NULL;
+
+    *guestDomain = *guestBus = *guestSlot = 0;
+
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONAddPCIDisk(qemuMonitorPtr mon,
+                              const char *path ATTRIBUTE_UNUSED,
+                              const char *bus ATTRIBUTE_UNUSED,
+                              unsigned *guestDomain,
+                              unsigned *guestBus,
+                              unsigned *guestSlot) {
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("pci_add", NULL);
+    json_t *reply = NULL;
+
+    *guestDomain = *guestBus = *guestSlot = 0;
+
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONAddPCINetwork(qemuMonitorPtr mon,
+                                 const char *nicstr ATTRIBUTE_UNUSED,
+                                 unsigned *guestDomain,
+                                 unsigned *guestBus,
+                                 unsigned *guestSlot)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("pci_add", NULL);
+    json_t *reply = NULL;
+
+    *guestDomain = *guestBus = *guestSlot = 0;
+
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONRemovePCIDevice(qemuMonitorPtr mon,
+                                   unsigned guestDomain ATTRIBUTE_UNUSED,
+                                   unsigned guestBus ATTRIBUTE_UNUSED,
+                                   unsigned guestSlot ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("pci_del", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONSendFileHandle(qemuMonitorPtr mon,
+                                  const char *fdname ATTRIBUTE_UNUSED,
+                                  int fd)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("getfd", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommandWithFd(mon, cmd, fd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONCloseFileHandle(qemuMonitorPtr mon,
+                                   const char *fdname ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("closefd", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONAddHostNetwork(qemuMonitorPtr mon,
+                                  const char *netstr ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("host_net_add", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
+
+
+int qemuMonitorJSONRemoveHostNetwork(qemuMonitorPtr mon,
+                                     int vlan ATTRIBUTE_UNUSED,
+                                     const char *netname ATTRIBUTE_UNUSED)
+{
+    int ret;
+    json_t *cmd = qemuMonitorJSONMakeCommand("host_net_remove", NULL);
+    json_t *reply = NULL;
+    if (!cmd)
+        return -1;
+
+    ret = qemuMonitorCommand(mon, cmd, &reply);
+
+    json_free_value(&cmd);
+    if (reply)
+        json_free_value(&reply);
+    return ret;
+}
diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h
new file mode 100644
index 0000000..a44158a
--- /dev/null
+++ b/src/qemu/qemu_monitor_json.h
@@ -0,0 +1,155 @@
+/*
+ * qemu_monitor_json.h: interaction with QEMU monitor console
+ *
+ * Copyright (C) 2006-2009 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange(a)redhat.com&gt;
+ */
+
+
+#ifndef QEMU_MONITOR_JSON_H
+#define QEMU_MONITOR_JSON_H
+
+#include "internal.h"
+
+#include "qemu_monitor.h"
+
+int qemuMonitorJSONIOProcess(qemuMonitorPtr mon,
+                             const char *data,
+                             size_t len,
+                             qemuMonitorMessagePtr msg);
+
+int qemuMonitorJSONStartCPUs(qemuMonitorPtr mon,
+                             virConnectPtr conn);
+int qemuMonitorJSONStopCPUs(qemuMonitorPtr mon);
+
+int qemuMonitorJSONSystemPowerdown(qemuMonitorPtr mon);
+
+int qemuMonitorJSONGetCPUInfo(qemuMonitorPtr mon,
+                              int **pids);
+int qemuMonitorJSONGetBalloonInfo(qemuMonitorPtr mon,
+                                  unsigned long *currmem);
+int qemuMonitorJSONGetBlockStatsInfo(qemuMonitorPtr mon,
+                                     const char *devname,
+                                     long long *rd_req,
+                                     long long *rd_bytes,
+                                     long long *wr_req,
+                                     long long *wr_bytes,
+                                     long long *errs);
+
+
+int qemuMonitorJSONSetVNCPassword(qemuMonitorPtr mon,
+                                  const char *password);
+int qemuMonitorJSONSetBalloon(qemuMonitorPtr mon,
+                              unsigned long newmem);
+
+int qemuMonitorJSONEjectMedia(qemuMonitorPtr mon,
+                              const char *devname);
+int qemuMonitorJSONChangeMedia(qemuMonitorPtr mon,
+                               const char *devname,
+                               const char *newmedia);
+
+
+int qemuMonitorJSONSaveVirtualMemory(qemuMonitorPtr mon,
+                                     unsigned long long offset,
+                                     size_t length,
+                                     const char *path);
+int qemuMonitorJSONSavePhysicalMemory(qemuMonitorPtr mon,
+                                      unsigned long long offset,
+                                      size_t length,
+                                      const char *path);
+
+int qemuMonitorJSONSetMigrationSpeed(qemuMonitorPtr mon,
+                                     unsigned long bandwidth);
+
+int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon,
+                                      int *status,
+                                      unsigned long long *transferred,
+                                      unsigned long long *remaining,
+                                      unsigned long long *total);
+
+int qemuMonitorJSONMigrateToHost(qemuMonitorPtr mon,
+                                 int background,
+                                 const char *hostname,
+                                 int port);
+
+int qemuMonitorJSONMigrateToCommand(qemuMonitorPtr mon,
+                                    int background,
+                                    const char * const *argv,
+                                    const char *target);
+
+int qemuMonitorJSONMigrateToUnix(qemuMonitorPtr mon,
+                                 int background,
+                                 const char *unixfile);
+
+int qemuMonitorJSONMigrateCancel(qemuMonitorPtr mon);
+
+int qemuMonitorJSONAddUSBDisk(qemuMonitorPtr mon,
+                              const char *path);
+
+int qemuMonitorJSONAddUSBDeviceExact(qemuMonitorPtr mon,
+                                     int bus,
+                                     int dev);
+int qemuMonitorJSONAddUSBDeviceMatch(qemuMonitorPtr mon,
+                                     int vendor,
+                                     int product);
+
+
+int qemuMonitorJSONAddPCIHostDevice(qemuMonitorPtr mon,
+                                    unsigned hostDomain,
+                                    unsigned hostBus,
+                                    unsigned hostSlot,
+                                    unsigned hostFunction,
+                                    unsigned *guestDomain,
+                                    unsigned *guestBus,
+                                    unsigned *guestSlot);
+
+int qemuMonitorJSONAddPCIDisk(qemuMonitorPtr mon,
+                              const char *path,
+                              const char *bus,
+                              unsigned *guestDomain,
+                              unsigned *guestBus,
+                              unsigned *guestSlot);
+
+int qemuMonitorJSONAddPCINetwork(qemuMonitorPtr mon,
+                                 const char *nicstr,
+                                 unsigned *guestDomain,
+                                 unsigned *guestBus,
+                                 unsigned *guestSlot);
+
+int qemuMonitorJSONRemovePCIDevice(qemuMonitorPtr mon,
+                                   unsigned guestDomain,
+                                   unsigned guestBus,
+                                   unsigned guestSlot);
+
+
+int qemuMonitorJSONSendFileHandle(qemuMonitorPtr mon,
+                                  const char *fdname,
+                                  int fd);
+
+int qemuMonitorJSONCloseFileHandle(qemuMonitorPtr mon,
+                                   const char *fdname);
+
+int qemuMonitorJSONAddHostNetwork(qemuMonitorPtr mon,
+                                  const char *netstr);
+
+int qemuMonitorJSONRemoveHostNetwork(qemuMonitorPtr mon,
+                                     int vlan,
+                                     const char *netname);
+
+#endif /* QEMU_MONITOR_JSON_H */
-- 
1.6.2.5


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

[libvirt] [PATCH 15/15] Start of support for JSON based QEMU monitor protocol