[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] [PATCH 19/23] Replace use of qemuReportError with virReportError



From: "Daniel P. Berrange" <berrange redhat com>

Update the QEMU driver to use virReportError instead of
the qemuReportError custom macro

Signed-off-by: Daniel P. Berrange <berrange redhat com>
---
 cfg.mk                       |    1 -
 src/qemu/qemu_agent.c        |  142 ++--
 src/qemu/qemu_capabilities.c |   16 +-
 src/qemu/qemu_cgroup.c       |   26 +-
 src/qemu/qemu_command.c      | 1066 ++++++++++++------------
 src/qemu/qemu_conf.c         |   26 +-
 src/qemu/qemu_conf.h         |    4 -
 src/qemu/qemu_domain.c       |   94 +--
 src/qemu/qemu_driver.c       | 1834 +++++++++++++++++++++---------------------
 src/qemu/qemu_hostdev.c      |   59 +-
 src/qemu/qemu_hotplug.c      |  362 ++++-----
 src/qemu/qemu_migration.c    |  284 +++----
 src/qemu/qemu_monitor.c      |  384 ++++-----
 src/qemu/qemu_monitor_json.c |  546 ++++++-------
 src/qemu/qemu_monitor_text.c |  532 ++++++------
 src/qemu/qemu_process.c      |  216 ++---
 16 files changed, 2795 insertions(+), 2797 deletions(-)

diff --git a/cfg.mk b/cfg.mk
index 699aeac..6e1f6af 100644
--- a/cfg.mk
+++ b/cfg.mk
@@ -509,7 +509,6 @@ msg_gen_function =
 msg_gen_function += VIR_ERROR
 msg_gen_function += lxcError
 msg_gen_function += nodeReportError
-msg_gen_function += qemuReportError
 msg_gen_function += regerror
 msg_gen_function += vah_error
 msg_gen_function += vah_warning
diff --git a/src/qemu/qemu_agent.c b/src/qemu/qemu_agent.c
index 7a0381c..12b9499 100644
--- a/src/qemu/qemu_agent.c
+++ b/src/qemu/qemu_agent.c
@@ -204,22 +204,22 @@ qemuAgentOpenUnix(const char *monitor, pid_t cpid, bool *inProgress)
     }
 
     if (virSetNonBlock(monfd) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("Unable to put monitor into non-blocking mode"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Unable to put monitor into non-blocking mode"));
         goto error;
     }
 
     if (virSetCloseExec(monfd) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("Unable to set monitor close-on-exec flag"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Unable to set monitor close-on-exec flag"));
         goto error;
     }
 
     memset(&addr, 0, sizeof(addr));
     addr.sun_family = AF_UNIX;
     if (virStrcpyStatic(addr.sun_path, monitor) == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Agent path %s too big for destination"), monitor);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Agent path %s too big for destination"), monitor);
         goto error;
     }
 
@@ -269,14 +269,14 @@ qemuAgentOpenPty(const char *monitor)
     int monfd;
 
     if ((monfd = open(monitor, O_RDWR | O_NONBLOCK)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Unable to open monitor path %s"), monitor);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Unable to open monitor path %s"), monitor);
         return -1;
     }
 
     if (virSetCloseExec(monfd) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("Unable to set monitor close-on-exec flag"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Unable to set monitor close-on-exec flag"));
         goto error;
     }
 
@@ -331,8 +331,8 @@ qemuAgentIOProcessLine(qemuAgentPtr mon,
         goto cleanup;
 
     if (obj->type != VIR_JSON_TYPE_OBJECT) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Parsed JSON reply '%s' isn't an object"), line);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Parsed JSON reply '%s' isn't an object"), line);
         goto cleanup;
     }
 
@@ -362,12 +362,12 @@ qemuAgentIOProcessLine(qemuAgentPtr mon,
                 goto cleanup;
             }
 
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unexpected JSON reply '%s'"), line);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unexpected JSON reply '%s'"), line);
         }
     } else {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Unknown JSON reply '%s'"), line);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Unknown JSON reply '%s'"), line);
     }
 
 cleanup:
@@ -609,9 +609,9 @@ qemuAgentIO(int watch, int fd, int events, void *opaque) {
     if (mon->fd != fd || mon->watch != watch) {
         if (events & (VIR_EVENT_HANDLE_HANGUP | VIR_EVENT_HANDLE_ERROR))
             eof = true;
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("event from unexpected fd %d!=%d / watch %d!=%d"),
-                        mon->fd, fd, mon->watch, watch);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("event from unexpected fd %d!=%d / watch %d!=%d"),
+                       mon->fd, fd, mon->watch, watch);
         error = true;
     } else if (mon->lastError.code != VIR_ERR_OK) {
         if (events & (VIR_EVENT_HANDLE_HANGUP | VIR_EVENT_HANDLE_ERROR))
@@ -649,23 +649,23 @@ qemuAgentIO(int watch, int fd, int events, void *opaque) {
 
         if (!error &&
             events & VIR_EVENT_HANDLE_HANGUP) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("End of file from monitor"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("End of file from monitor"));
             eof = 1;
             events &= ~VIR_EVENT_HANDLE_HANGUP;
         }
 
         if (!error && !eof &&
             events & VIR_EVENT_HANDLE_ERROR) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Invalid file descriptor while waiting for monitor"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Invalid file descriptor while waiting for monitor"));
             eof = 1;
             events &= ~VIR_EVENT_HANDLE_ERROR;
         }
         if (!error && events) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unhandled event %d for monitor fd %d"),
-                            events, mon->fd);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unhandled event %d for monitor fd %d"),
+                           events, mon->fd);
             error = 1;
         }
     }
@@ -677,8 +677,8 @@ qemuAgentIO(int watch, int fd, int events, void *opaque) {
         } else {
             virErrorPtr err = virGetLastError();
             if (!err)
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("Error while processing monitor IO"));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Error while processing monitor IO"));
             virCopyLastError(&mon->lastError);
             virResetLastError();
         }
@@ -734,8 +734,8 @@ qemuAgentOpen(virDomainObjPtr vm,
     qemuAgentPtr mon;
 
     if (!cb || !cb->eofNotify) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("EOF notify callback must be supplied"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("EOF notify callback must be supplied"));
         return NULL;
     }
 
@@ -745,14 +745,14 @@ qemuAgentOpen(virDomainObjPtr vm,
     }
 
     if (virMutexInit(&mon->lock) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("cannot initialize monitor mutex"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cannot initialize monitor mutex"));
         VIR_FREE(mon);
         return NULL;
     }
     if (virCondInit(&mon->notify) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("cannot initialize monitor condition"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cannot initialize monitor condition"));
         virMutexDestroy(&mon->lock);
         VIR_FREE(mon);
         return NULL;
@@ -774,9 +774,9 @@ qemuAgentOpen(virDomainObjPtr vm,
         break;
 
     default:
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to handle monitor type: %s"),
-                        virDomainChrTypeToString(config->type));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to handle monitor type: %s"),
+                       virDomainChrTypeToString(config->type));
         goto cleanup;
     }
 
@@ -792,8 +792,8 @@ qemuAgentOpen(virDomainObjPtr vm,
                                          0),
                                         qemuAgentIO,
                                         mon, qemuAgentUnwatch)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("unable to register monitor events"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("unable to register monitor events"));
         goto cleanup;
     }
     qemuAgentRef(mon);
@@ -886,12 +886,12 @@ static int qemuAgentSend(qemuAgentPtr mon,
         if ((timeout && virCondWaitUntil(&mon->notify, &mon->lock, then) < 0) ||
             (!timeout && virCondWait(&mon->notify, &mon->lock) < 0)) {
             if (errno == ETIMEDOUT) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("Guest agent not available for now"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("Guest agent not available for now"));
                 ret = -2;
             } else {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("Unable to wait on monitor condition"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("Unable to wait on monitor condition"));
             }
             goto cleanup;
         }
@@ -959,23 +959,23 @@ qemuAgentGuestSync(qemuAgentPtr mon)
     }
 
     if (!sync_msg.rxObject) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Missing monitor reply object"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Missing monitor reply object"));
         goto cleanup;
     }
 
     if (virJSONValueObjectGetNumberUlong(sync_msg.rxObject,
                                          "return", &id_ret) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Malformed return value"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Malformed return value"));
         goto cleanup;
     }
 
     VIR_DEBUG("Guest returned ID: %llu", id_ret);
     if (id_ret != id) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Guest agent returned ID: %llu instead of %llu"),
-                        id_ret, id);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Guest agent returned ID: %llu instead of %llu"),
+                       id_ret, id);
         goto cleanup;
     }
     ret = 0;
@@ -1029,8 +1029,8 @@ qemuAgentCommand(qemuAgentPtr mon,
             if (await_event) {
                 VIR_DEBUG("Woken up by event %d", await_event);
             } else {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("Missing monitor reply object"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("Missing monitor reply object"));
                 ret = -1;
             }
         } else {
@@ -1128,14 +1128,14 @@ qemuAgentCheckError(virJSONValuePtr cmd,
 
         /* Only send the user the command name + friendly error */
         if (!error)
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unable to execute QEMU command '%s'"),
-                            qemuAgentCommandName(cmd));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unable to execute QEMU command '%s'"),
+                           qemuAgentCommandName(cmd));
         else
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unable to execute QEMU command '%s': %s"),
-                            qemuAgentCommandName(cmd),
-                            qemuAgentStringifyError(error));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unable to execute QEMU command '%s': %s"),
+                           qemuAgentCommandName(cmd),
+                           qemuAgentStringifyError(error));
 
         VIR_FREE(cmdstr);
         VIR_FREE(replystr);
@@ -1146,9 +1146,9 @@ qemuAgentCheckError(virJSONValuePtr cmd,
 
         VIR_DEBUG("Neither 'return' nor 'error' is set in the JSON reply %s: %s",
                   cmdstr, replystr);
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to execute QEMU command '%s'"),
-                        qemuAgentCommandName(cmd));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to execute QEMU command '%s'"),
+                       qemuAgentCommandName(cmd));
         VIR_FREE(cmdstr);
         VIR_FREE(replystr);
         return -1;
@@ -1178,9 +1178,9 @@ qemuAgentMakeCommand(const char *cmdname,
         char type;
 
         if (strlen(key) < 3) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("argument key '%s' is too short, missing type prefix"),
-                            key);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("argument key '%s' is too short, missing type prefix"),
+                           key);
             goto error;
         }
 
@@ -1232,8 +1232,8 @@ qemuAgentMakeCommand(const char *cmdname,
             ret = virJSONValueObjectAppendNull(jargs, key);
         }   break;
         default:
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unsupported data type '%c' for arg '%s'"), type, key - 2);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unsupported data type '%c' for arg '%s'"), type, key - 2);
             goto error;
         }
         if (ret < 0)
@@ -1332,8 +1332,8 @@ int qemuAgentFSFreeze(qemuAgentPtr mon)
         goto cleanup;
 
     if (virJSONValueObjectGetNumberInt(reply, "return", &ret) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("malformed return value"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("malformed return value"));
     }
 
 cleanup:
@@ -1369,8 +1369,8 @@ int qemuAgentFSThaw(qemuAgentPtr mon)
         goto cleanup;
 
     if (virJSONValueObjectGetNumberInt(reply, "return", &ret) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("malformed return value"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("malformed return value"));
     }
 
 cleanup:
diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index f93f2aa..7861bee 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -1226,9 +1226,9 @@ qemuCapsComputeCmdFlags(const char *help,
     if (version >= 15000 ||
         (version >= 12000 && strstr(help, "libvirt"))) {
         if (check_yajl) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("this qemu binary requires libvirt to be "
-                              "compiled with yajl"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("this qemu binary requires libvirt to be "
+                             "compiled with yajl"));
             return -1;
         }
         qemuCapsSet(flags, QEMU_CAPS_NETDEV);
@@ -1363,9 +1363,9 @@ fail:
     if (!p)
         p = strchr(help, '\0');
 
-    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                    _("cannot parse %s version number in '%.*s'"),
-                    qemu, (int) (p - help), help);
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   _("cannot parse %s version number in '%.*s'"),
+                   qemu, (int) (p - help), help);
 
 cleanup:
     return -1;
@@ -1589,8 +1589,8 @@ int qemuCapsExtractVersion(virCapsPtr caps,
                                                       "hvm",
                                                       ut.machine,
                                                       "qemu")) == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Cannot find suitable emulator for %s"), ut.machine);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Cannot find suitable emulator for %s"), ut.machine);
         return -1;
     }
 
diff --git a/src/qemu/qemu_cgroup.c b/src/qemu/qemu_cgroup.c
index e39f5e1..cedbc95 100644
--- a/src/qemu/qemu_cgroup.c
+++ b/src/qemu/qemu_cgroup.c
@@ -310,8 +310,8 @@ int qemuSetupCgroup(struct qemud_driver *driver,
                 goto cleanup;
             }
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("Block I/O tuning is not available on this host"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("Block I/O tuning is not available on this host"));
             goto cleanup;
         }
     }
@@ -333,8 +333,8 @@ int qemuSetupCgroup(struct qemud_driver *driver,
                 }
             }
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("Block I/O tuning is not available on this host"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("Block I/O tuning is not available on this host"));
             goto cleanup;
         }
     }
@@ -372,8 +372,8 @@ int qemuSetupCgroup(struct qemud_driver *driver,
                 }
             }
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("Memory cgroup is not available on this host"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("Memory cgroup is not available on this host"));
         }
     }
 
@@ -387,8 +387,8 @@ int qemuSetupCgroup(struct qemud_driver *driver,
                 goto cleanup;
             }
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("CPU tuning is not available on this host"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("CPU tuning is not available on this host"));
         }
     }
 
@@ -405,8 +405,8 @@ int qemuSetupCgroup(struct qemud_driver *driver,
             mask = virDomainCpuSetFormat(vm->def->numatune.memory.nodemask,
                                          VIR_DOMAIN_CPUMASK_LEN);
         if (!mask) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("failed to convert memory nodemask"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("failed to convert memory nodemask"));
             goto cleanup;
         }
 
@@ -585,9 +585,9 @@ int qemuRemoveCgroup(struct qemud_driver *driver,
     rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0);
     if (rc != 0) {
         if (!quiet)
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unable to find cgroup for %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unable to find cgroup for %s"),
+                           vm->def->name);
         return rc;
     }
 
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 09215af..447e0e5 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -202,9 +202,9 @@ qemuNetworkIfaceConnect(virDomainDefPtr def,
             fail = 1;
 
             if (active == 0)
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("Network '%s' is not active."),
-                                net->data.network.name);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Network '%s' is not active."),
+                               net->data.network.name);
         }
 
         if (!fail) {
@@ -228,9 +228,9 @@ qemuNetworkIfaceConnect(virDomainDefPtr def,
             return -1;
         }
     } else {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Network type %d is not supported"),
-                        virDomainNetGetActualType(net));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Network type %d is not supported"),
+                       virDomainNetGetActualType(net));
         return -1;
     }
 
@@ -273,9 +273,9 @@ qemuNetworkIfaceConnect(virDomainDefPtr def,
     if (tapfd >= 0 &&
         virNetDevBandwidthSet(net->ifname,
                               virDomainNetGetActualBandwidth(net)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot set bandwidth limits on %s"),
-                        net->ifname);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot set bandwidth limits on %s"),
+                       net->ifname);
         VIR_FORCE_CLOSE(tapfd);
         goto cleanup;
     }
@@ -314,9 +314,9 @@ qemuOpenVhostNet(virDomainDefPtr def,
           qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
           qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
         if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            "%s", _("vhost-net is not supported with "
-                                    "this QEMU binary"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           "%s", _("vhost-net is not supported with "
+                                   "this QEMU binary"));
             return -1;
         }
         return 0;
@@ -325,9 +325,9 @@ qemuOpenVhostNet(virDomainDefPtr def,
     /* If the nic model isn't virtio, don't try to open. */
     if (!(net->model && STREQ(net->model, "virtio"))) {
         if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            "%s", _("vhost-net is only supported for "
-                                    "virtio network interfaces"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           "%s", _("vhost-net is only supported for "
+                                   "virtio network interfaces"));
             return -1;
         }
         return 0;
@@ -341,9 +341,9 @@ qemuOpenVhostNet(virDomainDefPtr def,
      */
     if ((*vhostfd < 0) &&
         (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        "%s", _("vhost-net was requested for an interface, "
-                                "but is unavailable"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       "%s", _("vhost-net was requested for an interface, "
+                               "but is unavailable"));
         return -1;
     }
     return 0;
@@ -422,9 +422,9 @@ static int qemuAssignDeviceDiskAliasFixed(virDomainDiskDefPtr disk)
     char *dev_name;
 
     if (virDiskNameToBusDeviceIndex(disk, &busid, &devid) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot convert disk '%s' to bus/device index"),
-                        disk->dst);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot convert disk '%s' to bus/device index"),
+                       disk->dst);
         return -1;
     }
 
@@ -451,9 +451,9 @@ static int qemuAssignDeviceDiskAliasFixed(virDomainDiskDefPtr disk)
         ret = virAsprintf(&dev_name, "xenblk%d", devid);
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("Unsupported disk name mapping for bus '%s'"),
-                        virDomainDiskBusTypeToString(disk->bus));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Unsupported disk name mapping for bus '%s'"),
+                       virDomainDiskBusTypeToString(disk->bus));
         return -1;
     }
 
@@ -555,8 +555,8 @@ qemuAssignDeviceNetAlias(virDomainDefPtr def, virDomainNetDefPtr net, int idx)
                continue;
             }
             if ((thisidx = qemuDomainDeviceAliasIndex(&def->nets[i]->info, "net")) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("Unable to determine device index for network device"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("Unable to determine device index for network device"));
                 return -1;
             }
             if (thisidx >= idx)
@@ -582,8 +582,8 @@ qemuAssignDeviceHostdevAlias(virDomainDefPtr def, virDomainHostdevDefPtr hostdev
         for (i = 0 ; i < def->nhostdevs ; i++) {
             int thisidx;
             if ((thisidx = qemuDomainDeviceAliasIndex(def->hostdevs[i]->info, "hostdev")) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("Unable to determine device index for hostdev device"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("Unable to determine device index for hostdev device"));
                 return -1;
             }
             if (thisidx >= idx)
@@ -609,8 +609,8 @@ qemuAssignDeviceRedirdevAlias(virDomainDefPtr def, virDomainRedirdevDefPtr redir
         for (i = 0 ; i < def->nredirdevs ; i++) {
             int thisidx;
             if ((thisidx = qemuDomainDeviceAliasIndex(&def->redirdevs[i]->info, "redir")) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("Unable to determine device index for redirected device"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("Unable to determine device index for redirected device"));
                 return -1;
             }
             if (thisidx >= idx)
@@ -835,9 +835,9 @@ qemuAssignSpaprVIOAddress(virDomainDefPtr def, virDomainDeviceInfoPtr info,
     rc = virDomainDeviceInfoIterate(def, qemuSpaprVIOFindByReg, info);
     while (rc != 0) {
         if (user_reg) {
-            qemuReportError(VIR_ERR_XML_ERROR,
-                            _("spapr-vio address %#llx already in use"),
-                            info->addr.spaprvio.reg);
+            virReportError(VIR_ERR_XML_ERROR,
+                           _("spapr-vio address %#llx already in use"),
+                           info->addr.spaprvio.reg);
             return -EEXIST;
         }
 
@@ -911,8 +911,8 @@ static char *qemuPCIAddressAsString(virDomainDeviceInfoPtr dev)
 
     if (dev->addr.pci.domain != 0 ||
         dev->addr.pci.bus != 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Only PCI domain 0 and bus 0 are available"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Only PCI domain 0 and bus 0 are available"));
         return NULL;
     }
 
@@ -953,13 +953,13 @@ static int qemuCollectPCIAddress(virDomainDefPtr def ATTRIBUTE_UNUSED,
 
     if (virHashLookup(addrs->used, addr)) {
         if (info->addr.pci.function != 0) {
-            qemuReportError(VIR_ERR_XML_ERROR,
-                            _("Attempted double use of PCI Address '%s' "
-                              "(may need \"multifunction='on'\" for device on function 0)"),
-                            addr);
+            virReportError(VIR_ERR_XML_ERROR,
+                           _("Attempted double use of PCI Address '%s' "
+                             "(may need \"multifunction='on'\" for device on function 0)"),
+                           addr);
         } else {
-            qemuReportError(VIR_ERR_XML_ERROR,
-                            _("Attempted double use of PCI Address '%s'"), addr);
+            virReportError(VIR_ERR_XML_ERROR,
+                           _("Attempted double use of PCI Address '%s'"), addr);
         }
         goto cleanup;
     }
@@ -982,10 +982,10 @@ static int qemuCollectPCIAddress(virDomainDefPtr def ATTRIBUTE_UNUSED,
                 goto cleanup;
 
             if (virHashLookup(addrs->used, addr)) {
-                qemuReportError(VIR_ERR_XML_ERROR,
-                                _("Attempted double use of PCI Address '%s'"
-                                  "(need \"multifunction='off'\" for device on function 0)"),
-                                addr);
+                virReportError(VIR_ERR_XML_ERROR,
+                               _("Attempted double use of PCI Address '%s'"
+                                 "(need \"multifunction='off'\" for device on function 0)"),
+                               addr);
                 goto cleanup;
             }
 
@@ -1138,8 +1138,8 @@ int qemuDomainPCIAddressReserveAddr(qemuDomainPCIAddressSetPtr addrs,
     VIR_DEBUG("Reserving PCI addr %s", addr);
 
     if (virHashLookup(addrs->used, addr)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to reserve PCI address %s"), addr);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to reserve PCI address %s"), addr);
         VIR_FREE(addr);
         return -1;
     }
@@ -1199,9 +1199,9 @@ int qemuDomainPCIAddressEnsureAddr(qemuDomainPCIAddressSetPtr addrs,
          * reserve the whole slot. The function of the PCI device must be 0.
          */
         if (dev->addr.pci.function != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Only PCI device addresses with function=0"
-                              " are supported"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Only PCI device addresses with function=0"
+                             " are supported"));
             return -1;
         }
 
@@ -1316,8 +1316,8 @@ static int qemuDomainPCIAddressGetNextSlot(qemuDomainPCIAddressSetPtr addrs)
         return i;
     }
 
-    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                    "%s", _("No more available PCI addresses"));
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   "%s", _("No more available PCI addresses"));
     return -1;
 }
 
@@ -1407,8 +1407,8 @@ qemuAssignDevicePCISlots(virDomainDefPtr def, qemuDomainPCIAddressSetPtr addrs)
                     def->controllers[i]->info.addr.pci.bus != 0 ||
                     def->controllers[i]->info.addr.pci.slot != 1 ||
                     def->controllers[i]->info.addr.pci.function != 1) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("Primary IDE controller must have PCI address 0:0:1.1"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("Primary IDE controller must have PCI address 0:0:1.1"));
                     goto error;
                 }
                 /* If TYPE==PCI, then qemuCollectPCIAddress() function
@@ -1430,8 +1430,8 @@ qemuAssignDevicePCISlots(virDomainDefPtr def, qemuDomainPCIAddressSetPtr addrs)
                     def->controllers[i]->info.addr.pci.bus != 0 ||
                     def->controllers[i]->info.addr.pci.slot != 1 ||
                     def->controllers[i]->info.addr.pci.function != 2) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("PIIX3 USB controller must have PCI address 0:0:1.2"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("PIIX3 USB controller must have PCI address 0:0:1.2"));
                     goto error;
                 }
                 reservedUSB = true;
@@ -1465,8 +1465,8 @@ qemuAssignDevicePCISlots(virDomainDefPtr def, qemuDomainPCIAddressSetPtr addrs)
                 def->videos[0]->info.addr.pci.bus != 0 ||
                 def->videos[0]->info.addr.pci.slot != 2 ||
                 def->videos[0]->info.addr.pci.function != 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("Primary video card must have PCI address 0:0:2.0"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("Primary video card must have PCI address 0:0:2.0"));
                 goto error;
             }
             /* If TYPE==PCI, then qemuCollectPCIAddress() function
@@ -1616,8 +1616,8 @@ qemuAssignDevicePCISlots(virDomainDefPtr def, qemuDomainPCIAddressSetPtr addrs)
             continue;
 
         if (def->disks[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                          _("virtio only support device address type 'PCI'"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("virtio only support device address type 'PCI'"));
             goto error;
         }
 
@@ -1698,33 +1698,33 @@ qemuBuildDeviceAddressStr(virBufferPtr buf,
 {
     if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
         if (info->addr.pci.domain != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Only PCI device addresses with domain=0 are supported"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Only PCI device addresses with domain=0 are supported"));
             return -1;
         }
         if (info->addr.pci.bus != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Only PCI device addresses with bus=0 are supported"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Only PCI device addresses with bus=0 are supported"));
             return -1;
         }
         if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
             if (info->addr.pci.function > 7) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("The function of PCI device addresses must "
-                                  "less than 8"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("The function of PCI device addresses must "
+                                 "less than 8"));
                 return -1;
             }
         } else {
             if (info->addr.pci.function != 0) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("Only PCI device addresses with function=0 "
-                                  "are supported with this QEMU binary"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("Only PCI device addresses with function=0 "
+                                 "are supported with this QEMU binary"));
                 return -1;
             }
             if (info->addr.pci.multi == VIR_DOMAIN_DEVICE_ADDRESS_PCI_MULTI_ON) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("'multifunction=on' is not supported with "
-                                  "this QEMU binary"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("'multifunction=on' is not supported with "
+                                 "this QEMU binary"));
                 return -1;
             }
         }
@@ -1765,13 +1765,13 @@ qemuBuildRomStr(virBufferPtr buf,
 {
     if (info->rombar || info->romfile) {
         if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            "%s", _("rombar and romfile are supported only for PCI devices"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           "%s", _("rombar and romfile are supported only for PCI devices"));
             return -1;
         }
         if (!qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_ROMBAR)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            "%s", _("rombar and romfile not supported in this QEMU binary"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           "%s", _("rombar and romfile not supported in this QEMU binary"));
             return -1;
         }
 
@@ -1809,9 +1809,9 @@ static int
 qemuSafeSerialParamValue(const char *value)
 {
     if (strspn(value, QEMU_SERIAL_PARAM_ACCEPTED_CHARS) != strlen (value)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("driver serial '%s' contains unsafe characters"),
-                        value);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("driver serial '%s' contains unsafe characters"),
+                       value);
         return -1;
     }
 
@@ -1851,9 +1851,9 @@ qemuBuildRBDString(virConnectPtr conn,
             secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0,
                                                           VIR_SECRET_GET_VALUE_INTERNAL_CALL);
             if (secret == NULL) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("could not get the value of the secret for username %s"),
-                                disk->auth.username);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("could not get the value of the secret for username %s"),
+                               disk->auth.username);
                 goto error;
             }
             /* qemu/librbd wants it base64 encoded */
@@ -1867,9 +1867,9 @@ qemuBuildRBDString(virConnectPtr conn,
                             base64);
             VIR_FREE(base64);
         } else {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("rbd username '%s' specified but secret not found"),
-                            disk->auth.username);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("rbd username '%s' specified but secret not found"),
+                           disk->auth.username);
             goto error;
         }
     } else {
@@ -2020,16 +2020,16 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
     int busid = -1, unitid = -1;
 
     if (idx < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unsupported disk type '%s'"), disk->dst);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unsupported disk type '%s'"), disk->dst);
         goto error;
     }
 
     switch (disk->bus) {
     case VIR_DOMAIN_DISK_BUS_SCSI:
         if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("unexpected address type for scsi disk"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("unexpected address type for scsi disk"));
             goto error;
         }
 
@@ -2037,8 +2037,8 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
          * to be created. Yes this is slightly odd. It is not possible
          * to have > 1 bus on a SCSI controller (yet). */
         if (disk->info.addr.drive.bus != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("SCSI controller only supports 1 bus"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("SCSI controller only supports 1 bus"));
             goto error;
         }
         busid = disk->info.addr.drive.controller;
@@ -2047,14 +2047,14 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
 
     case VIR_DOMAIN_DISK_BUS_IDE:
         if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("unexpected address type for ide disk"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("unexpected address type for ide disk"));
             goto error;
         }
         /* We can only have 1 IDE controller (currently) */
         if (disk->info.addr.drive.controller != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Only 1 %s controller is supported"), bus);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Only 1 %s controller is supported"), bus);
             goto error;
         }
         busid = disk->info.addr.drive.bus;
@@ -2063,25 +2063,25 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
 
     case VIR_DOMAIN_DISK_BUS_FDC:
         if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("unexpected address type for fdc disk"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("unexpected address type for fdc disk"));
             goto error;
         }
         /* We can only have 1 FDC controller (currently) */
         if (disk->info.addr.drive.controller != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Only 1 %s controller is supported"), bus);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Only 1 %s controller is supported"), bus);
             goto error;
         }
         /* We can only have 1 FDC bus (currently) */
         if (disk->info.addr.drive.bus != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Only 1 %s bus is supported"), bus);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Only 1 %s bus is supported"), bus);
             goto error;
         }
         if (disk->info.addr.drive.target != 0) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("target must be 0 for controller fdc"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("target must be 0 for controller fdc"));
             goto error;
         }
         unitid = disk->info.addr.drive.unit;
@@ -2092,8 +2092,8 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
         if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390) &&
             (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390)) {
             /* Paranoia - leave in here for now */
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("unexpected address type for s390-virtio disk"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("unexpected address type for s390-virtio disk"));
             goto error;
         }
         idx = -1;
@@ -2115,14 +2115,14 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
             /* QEMU only supports magic FAT format for now */
             if (disk->driverType &&
                 STRNEQ(disk->driverType, "fat")) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("unsupported disk driver type for '%s'"),
-                                disk->driverType);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("unsupported disk driver type for '%s'"),
+                               disk->driverType);
                 goto error;
             }
             if (!disk->readonly) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("cannot create virtual FAT disks in read-write mode"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("cannot create virtual FAT disks in read-write mode"));
                 goto error;
             }
             if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)
@@ -2134,8 +2134,8 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
             switch (disk->protocol) {
             case VIR_DOMAIN_DISK_PROTOCOL_NBD:
                 if (disk->nhosts != 1) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("NBD accepts only one host"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("NBD accepts only one host"));
                     goto error;
                 }
                 virBufferAsprintf(&opt, "file=nbd:%s:%s,",
@@ -2162,9 +2162,9 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
         } else {
             if ((disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) &&
                 (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("tray status 'open' is invalid for "
-                                  "block type disk"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("tray status 'open' is invalid for "
+                                 "block type disk"));
                 goto error;
             }
             virBufferEscape(&opt, ',', ",", "file=%s,", disk->src);
@@ -2210,8 +2210,8 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
         qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_READONLY))
         virBufferAddLit(&opt, ",readonly=on");
     if (disk->transient) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("transient disks not supported yet"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("transient disks not supported yet"));
         goto error;
     }
     if (disk->driverType && *disk->driverType != '\0' &&
@@ -2233,15 +2233,15 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
 
             if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_DIRECTSYNC &&
                 !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("disk cache mode 'directsync' is not "
-                                  "supported by this QEMU"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("disk cache mode 'directsync' is not "
+                                 "supported by this QEMU"));
                 goto error;
             } else if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_UNSAFE &&
                 !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("disk cache mode 'unsafe' is not "
-                                  "supported by this QEMU"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("disk cache mode 'unsafe' is not "
+                                 "supported by this QEMU"));
                 goto error;
             }
         } else {
@@ -2258,8 +2258,8 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
             virBufferAsprintf(&opt, ",copy-on-read=%s",
                               virDomainDiskCopyOnReadTypeToString(disk->copy_on_read));
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("copy_on_read is not supported by this QEMU binary"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("copy_on_read is not supported by this QEMU binary"));
             goto error;
         }
     }
@@ -2294,9 +2294,9 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
             virBufferAsprintf(&opt, ",aio=%s",
                               virDomainDiskIoTypeToString(disk->iomode));
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("disk aio mode not supported with this "
-                              "QEMU binary"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("disk aio mode not supported with this "
+                             "QEMU binary"));
             goto error;
         }
     }
@@ -2309,9 +2309,9 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
          disk->blkdeviotune.read_iops_sec ||
          disk->blkdeviotune.write_iops_sec) &&
         !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("block I/O throttling not supported with this "
-                          "QEMU binary"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("block I/O throttling not supported with this "
+                         "QEMU binary"));
         goto error;
     }
 
@@ -2369,8 +2369,8 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
     int controllerModel;
 
     if (idx < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unsupported disk type '%s'"), disk->dst);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unsupported disk type '%s'"), disk->dst);
         goto error;
     }
 
@@ -2380,20 +2380,20 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
          */
         if (disk->bus != VIR_DOMAIN_DISK_BUS_VIRTIO &&
             disk->bus != VIR_DOMAIN_DISK_BUS_SCSI) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("disk device='lun' is not supported for bus='%s'"),
-                            bus);
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("disk device='lun' is not supported for bus='%s'"),
+                           bus);
             goto error;
         }
         if (disk->type != VIR_DOMAIN_DISK_TYPE_BLOCK) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("disk device='lun' is not supported for type='%s'"),
-                            virDomainDiskTypeToString(disk->type));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("disk device='lun' is not supported for type='%s'"),
+                           virDomainDiskTypeToString(disk->type));
             goto error;
         }
         if (!qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("disk device='lun' is not supported by this QEMU"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("disk device='lun' is not supported by this QEMU"));
             goto error;
         }
     }
@@ -2401,8 +2401,8 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
     switch (disk->bus) {
     case VIR_DOMAIN_DISK_BUS_IDE:
         if (disk->info.addr.drive.target != 0) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("target must be 0 for ide controller"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("target must be 0 for ide controller"));
             goto error;
         }
 
@@ -2422,9 +2422,9 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
     case VIR_DOMAIN_DISK_BUS_SCSI:
         if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_BLOCK)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("This QEMU doesn't support scsi-block for "
-                                  "lun passthrough"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("This QEMU doesn't support scsi-block for "
+                                 "lun passthrough"));
                 goto error;
             }
         }
@@ -2438,9 +2438,9 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
 
         if (controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
             if (disk->info.addr.drive.target != 0) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("target must be 0 for controller "
-                                   "model 'lsilogic'"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("target must be 0 for controller "
+                                 "model 'lsilogic'"));
                 goto error;
             }
 
@@ -2464,17 +2464,17 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
         } else {
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_CHANNEL)) {
                 if (disk->info.addr.drive.target > 7) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                    _("This QEMU doesn't support target "
-                                      "greater than 7"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                                   _("This QEMU doesn't support target "
+                                     "greater than 7"));
                     goto error;
                 }
 
                 if ((disk->info.addr.drive.bus != disk->info.addr.drive.unit) &&
                     (disk->info.addr.drive.bus != 0)) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                    _("This QEMU only supports both bus and "
-                                      "unit equal to 0"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                                   _("This QEMU only supports both bus and "
+                                     "unit equal to 0"));
                     goto error;
                 }
             }
@@ -2501,13 +2501,13 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
         break;
     case VIR_DOMAIN_DISK_BUS_SATA:
         if (disk->info.addr.drive.bus != 0) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("bus must be 0 for ide controller"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("bus must be 0 for ide controller"));
             goto error;
         }
         if (disk->info.addr.drive.target != 0) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("target must be 0 for ide controller"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("target must be 0 for ide controller"));
             goto error;
         }
 
@@ -2552,8 +2552,8 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
         virBufferAddLit(&opt, "usb-storage");
         break;
     default:
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unsupported disk bus '%s' with device setup"), bus);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unsupported disk bus '%s' with device setup"), bus);
         goto error;
     }
     virBufferAsprintf(&opt, ",drive=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
@@ -2582,14 +2582,14 @@ char *qemuBuildFSStr(virDomainFSDefPtr fs,
     const char *wrpolicy = virDomainFSWrpolicyTypeToString(fs->wrpolicy);
 
     if (fs->type != VIR_DOMAIN_FS_TYPE_MOUNT) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("only supports mount filesystem type"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("only supports mount filesystem type"));
         goto error;
     }
 
     if (!driver) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("Filesystem driver type not supported"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("Filesystem driver type not supported"));
         goto error;
     }
     virBufferAdd(&opt, driver, -1);
@@ -2607,8 +2607,8 @@ char *qemuBuildFSStr(virDomainFSDefPtr fs,
         /* For other fs drivers, default(passthru) should always
          * be supported */
         if (fs->accessmode != VIR_DOMAIN_FS_ACCESSMODE_PASSTHROUGH) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("only supports passthrough accessmode"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("only supports passthrough accessmode"));
             goto error;
         }
     }
@@ -2617,7 +2617,7 @@ char *qemuBuildFSStr(virDomainFSDefPtr fs,
        if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT)) {
            virBufferAsprintf(&opt, ",writeout=%s", wrpolicy);
        } else {
-           qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+           virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("filesystem writeout not supported"));
            goto error;
        }
@@ -2630,9 +2630,9 @@ char *qemuBuildFSStr(virDomainFSDefPtr fs,
         if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV_READONLY)) {
             virBufferAddLit(&opt, ",readonly");
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("readonly filesystem is not supported by this "
-                              "QEMU binary"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("readonly filesystem is not supported by this "
+                             "QEMU binary"));
             goto error;
         }
     }
@@ -2657,8 +2657,8 @@ qemuBuildFSDevStr(virDomainFSDefPtr fs,
     virBuffer opt = VIR_BUFFER_INITIALIZER;
 
     if (fs->type != VIR_DOMAIN_FS_TYPE_MOUNT) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("can only passthrough directories"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("can only passthrough directories"));
         goto error;
     }
 
@@ -2732,8 +2732,8 @@ qemuBuildUSBControllerDevStr(virDomainDefPtr domainDef,
     caps = qemuControllerModelUSBToCaps(model);
 
     if (caps == -1 || !qemuCapsGet(qemuCaps, caps)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("%s not supported in this QEMU binary"), smodel);
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("%s not supported in this QEMU binary"), smodel);
         return -1;
     }
 
@@ -2778,9 +2778,9 @@ qemuBuildControllerDevStr(virDomainDefPtr domainDef,
             virBufferAddLit(&buf, "spapr-vscsi");
             break;
         default:
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("Unsupported controller model: %s"),
-                            virDomainControllerModelSCSITypeToString(def->model));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("Unsupported controller model: %s"),
+                           virDomainControllerModelSCSITypeToString(def->model));
         }
         virBufferAsprintf(&buf, ",id=scsi%d", def->idx);
         break;
@@ -2826,9 +2826,9 @@ qemuBuildControllerDevStr(virDomainDefPtr domainDef,
     /* We always get an IDE controller, whether we want it or not. */
     case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("Unknown controller type: %s"),
-                        virDomainControllerTypeToString(def->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Unknown controller type: %s"),
+                       virDomainControllerTypeToString(def->type));
         goto error;
     }
 
@@ -2913,13 +2913,13 @@ qemuBuildNicDevStr(virDomainNetDefPtr net,
                     /* this should never happen, if it does, we need
                      * to add another case to this switch.
                      */
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("unrecognized virtio-net-pci 'tx' option"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("unrecognized virtio-net-pci 'tx' option"));
                     goto error;
             }
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("virtio-net-pci 'tx' option not supported in this QEMU binary"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("virtio-net-pci 'tx' option not supported in this QEMU binary"));
             goto error;
         }
     }
@@ -2972,9 +2972,9 @@ qemuBuildHostNetStr(virDomainNetDefPtr net,
     enum virDomainNetType netType = virDomainNetGetActualType(net);
 
     if (net->script && netType != VIR_DOMAIN_NET_TYPE_ETHERNET) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("scripts are not supported on interfaces of type %s"),
-                        virDomainNetTypeToString(netType));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("scripts are not supported on interfaces of type %s"),
+                       virDomainNetTypeToString(netType));
         return NULL;
     }
 
@@ -3066,8 +3066,8 @@ qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
 
     const char *model = virDomainWatchdogModelTypeToString(dev->model);
     if (!model) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("missing watchdog model"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("missing watchdog model"));
         goto error;
     }
 
@@ -3146,8 +3146,8 @@ qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
     const char *model = virDomainSoundModelTypeToString(sound->model);
 
     if (!model) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("invalid sound model"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("invalid sound model"));
         goto error;
     }
 
@@ -3204,8 +3204,8 @@ qemuBuildSoundCodecStr(virDomainSoundDefPtr sound,
     caps = qemuSoundCodecTypeToCaps(type);
 
     if (caps == -1 || !qemuCapsGet(qemuCaps, caps)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("%s not supported in this QEMU binary"), stype);
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("%s not supported in this QEMU binary"), stype);
         goto error;
     }
 
@@ -3227,8 +3227,8 @@ qemuBuildVideoDevStr(virDomainVideoDefPtr video,
     const char *model = qemuVideoTypeToString(video->type);
 
     if (!model) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("invalid video model"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("invalid video model"));
         goto error;
     }
 
@@ -3236,9 +3236,9 @@ qemuBuildVideoDevStr(virDomainVideoDefPtr video,
 
     if (video->type == VIR_DOMAIN_VIDEO_TYPE_QXL) {
         if (video->vram > (UINT_MAX / 1024)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("value for 'vram' must be less than '%u'"),
-                            UINT_MAX / 1024);
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("value for 'vram' must be less than '%u'"),
+                           UINT_MAX / 1024);
             goto error;
         }
 
@@ -3343,16 +3343,16 @@ qemuBuildRedirdevDevStr(virDomainRedirdevDefPtr dev,
     virBuffer buf = VIR_BUFFER_INITIALIZER;
 
     if (dev->bus != VIR_DOMAIN_REDIRDEV_BUS_USB) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("Redirection bus %s is not supported by QEMU"),
-                        virDomainRedirdevBusTypeToString(dev->bus));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Redirection bus %s is not supported by QEMU"),
+                       virDomainRedirdevBusTypeToString(dev->bus));
         goto error;
     }
 
     if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("USB redirection is not supported "
-                          "by this version of QEMU"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("USB redirection is not supported "
+                         "by this version of QEMU"));
         goto error;
     }
 
@@ -3383,8 +3383,8 @@ qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
 
     if (!dev->source.subsys.u.usb.bus &&
         !dev->source.subsys.u.usb.device) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("USB host device is missing bus/device information"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("USB host device is missing bus/device information"));
         return NULL;
     }
 
@@ -3416,15 +3416,15 @@ qemuBuildHubDevStr(virDomainHubDefPtr dev,
     virBuffer buf = VIR_BUFFER_INITIALIZER;
 
     if (dev->type != VIR_DOMAIN_HUB_TYPE_USB) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("hub type %s not supported"),
-                        virDomainHubTypeToString(dev->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("hub type %s not supported"),
+                       virDomainHubTypeToString(dev->type));
         goto error;
     }
 
     if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_HUB)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("usb-hub not supported by QEMU binary"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("usb-hub not supported by QEMU binary"));
         goto error;
     }
 
@@ -3453,8 +3453,8 @@ qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev)
 
     if (!dev->source.subsys.u.usb.bus &&
         !dev->source.subsys.u.usb.device) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("USB host device is missing bus/device information"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("USB host device is missing bus/device information"));
         return NULL;
     }
 
@@ -3552,8 +3552,8 @@ qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
 
     case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
         if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("spicevmc not supported in this QEMU binary"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("spicevmc not supported in this QEMU binary"));
             goto error;
         }
         virBufferAsprintf(&buf, "spicevmc,id=char%s,name=%s", alias,
@@ -3561,9 +3561,9 @@ qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
         break;
 
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("unsupported chardev '%s'"),
-                        virDomainChrTypeToString(dev->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("unsupported chardev '%s'"),
+                       virDomainChrTypeToString(dev->type));
         goto error;
     }
 
@@ -3689,8 +3689,8 @@ qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
         }
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("Cannot use virtio serial for parallel/serial devices"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("Cannot use virtio serial for parallel/serial devices"));
         return NULL;
     }
 
@@ -3700,8 +3700,8 @@ qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
         if (dev->info.type !=
             VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL)
         {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("virtio serial device has invalid address type"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("virtio serial device has invalid address type"));
             goto error;
         }
 
@@ -3717,9 +3717,9 @@ qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
     if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
         dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
         STRNEQ_NULLABLE(dev->target.name, "com.redhat.spice.0")) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("Unsupported spicevmc target name '%s'"),
-                        dev->target.name);
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Unsupported spicevmc target name '%s'"),
+                       dev->target.name);
         goto error;
     }
 
@@ -3849,9 +3849,9 @@ qemuBuildClockArgStr(virDomainClockDefPtr def)
         struct tm nowbits;
 
         if (def->data.variable.basis != VIR_DOMAIN_CLOCK_BASIS_UTC) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("unsupported clock basis '%s'"),
-                            virDomainClockBasisTypeToString(def->data.variable.basis));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("unsupported clock basis '%s'"),
+                           virDomainClockBasisTypeToString(def->data.variable.basis));
             goto error;
         }
         now += def->data.variable.adjustment;
@@ -3867,9 +3867,9 @@ qemuBuildClockArgStr(virDomainClockDefPtr def)
     }   break;
 
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("unsupported clock offset '%s'"),
-                        virDomainClockOffsetTypeToString(def->offset));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("unsupported clock offset '%s'"),
+                       virDomainClockOffsetTypeToString(def->offset));
         goto error;
     }
 
@@ -3881,9 +3881,9 @@ qemuBuildClockArgStr(virDomainClockDefPtr def)
             case -1: /* unspecified - use hypervisor default */
                 break;
             case VIR_DOMAIN_TIMER_TRACK_BOOT:
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("unsupported rtc timer track '%s'"),
-                                virDomainTimerTrackTypeToString(def->timers[i]->track));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("unsupported rtc timer track '%s'"),
+                               virDomainTimerTrackTypeToString(def->timers[i]->track));
                 goto error;
             case VIR_DOMAIN_TIMER_TRACK_GUEST:
                 virBufferAddLit(&buf, ",clock=vm");
@@ -3905,9 +3905,9 @@ qemuBuildClockArgStr(virDomainClockDefPtr def)
                 break;
             case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
             case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("unsupported rtc timer tickpolicy '%s'"),
-                                virDomainTimerTickpolicyTypeToString(def->timers[i]->tickpolicy));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("unsupported rtc timer tickpolicy '%s'"),
+                               virDomainTimerTickpolicyTypeToString(def->timers[i]->tickpolicy));
                 goto error;
             }
             break; /* no need to check other timers - there is only one rtc */
@@ -3969,8 +3969,8 @@ qemuBuildCpuArgStr(const struct qemud_driver *driver,
             goto cleanup;
 
         if (!ncpus || !host) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("CPU specification not supported by hypervisor"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("CPU specification not supported by hypervisor"));
             goto cleanup;
         }
 
@@ -3986,12 +3986,12 @@ qemuBuildCpuArgStr(const struct qemud_driver *driver,
         switch (cmp) {
         case VIR_CPU_COMPARE_INCOMPATIBLE:
             if (compare_msg) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("guest and host CPU are not compatible: %s"),
-                                compare_msg);
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("guest and host CPU are not compatible: %s"),
+                               compare_msg);
             } else {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("guest CPU is not compatible with host CPU"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("guest CPU is not compatible with host CPU"));
             }
             /* fall through */
         case VIR_CPU_COMPARE_ERROR:
@@ -4012,15 +4012,15 @@ qemuBuildCpuArgStr(const struct qemud_driver *driver,
         if (cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH) {
             const char *mode = virCPUModeTypeToString(cpu->mode);
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CPU_HOST)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("CPU mode '%s' is not supported by QEMU"
-                                  " binary"), mode);
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("CPU mode '%s' is not supported by QEMU"
+                                 " binary"), mode);
                 goto cleanup;
             }
             if (def->virtType != VIR_DOMAIN_VIRT_KVM) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("CPU mode '%s' is only supported with kvm"),
-                                mode);
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("CPU mode '%s' is only supported with kvm"),
+                               mode);
                 goto cleanup;
             }
             virBufferAddLit(&buf, "host");
@@ -4145,9 +4145,9 @@ qemuBuildSmpArgStr(const virDomainDefPtr def,
     } else if (def->vcpus != def->maxvcpus) {
         virBufferFreeAndReset(&buf);
         /* FIXME - consider hot-unplugging cpus after boot for older qemu */
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("setting current vcpu count less than maximum is "
-                          "not supported with this QEMU binary"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("setting current vcpu count less than maximum is "
+                         "not supported with this QEMU binary"));
         return NULL;
     }
 
@@ -4286,9 +4286,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         if (qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU)) {
             enableKQEMU = 1;
         } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("the QEMU binary %s does not support kqemu"),
-                            emulator);
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("the QEMU binary %s does not support kqemu"),
+                           emulator);
         }
         break;
 
@@ -4299,9 +4299,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         if (qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM)) {
             enableKVM = 1;
         } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("the QEMU binary %s does not support kvm"),
-                            emulator);
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("the QEMU binary %s does not support kvm"),
+                           emulator);
         }
         break;
 
@@ -4310,9 +4310,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         break;
 
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("the QEMU binary %s does not support %s"),
-                        emulator, virDomainVirtTypeToString(def->virtType));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("the QEMU binary %s does not support %s"),
+                       emulator, virDomainVirtTypeToString(def->virtType));
         break;
     }
 
@@ -4376,19 +4376,19 @@ qemuBuildCommandLine(virConnectPtr conn,
     virCommandAddArgFormat(cmd, "%llu", def->mem.max_balloon / 1024);
     if (def->mem.hugepage_backed) {
         if (!driver->hugetlbfs_mount) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("hugetlbfs filesystem is not mounted"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("hugetlbfs filesystem is not mounted"));
             goto error;
         }
         if (!driver->hugepage_path) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("hugepages are disabled by administrator config"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("hugepages are disabled by administrator config"));
             goto error;
         }
         if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MEM_PATH)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("hugepage backing not supported by '%s'"),
-                            def->emulator);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("hugepage backing not supported by '%s'"),
+                           def->emulator);
             goto error;
         }
         virCommandAddArgList(cmd, "-mem-prealloc", "-mem-path",
@@ -4418,9 +4418,9 @@ qemuBuildCommandLine(virConnectPtr conn,
             virCommandAddArg(cmd, "-xen-domid");
             virCommandAddArgFormat(cmd, "%d", def->id);
         } else {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("qemu emulator '%s' does not support xen"),
-                            def->emulator);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("qemu emulator '%s' does not support xen"),
+                           def->emulator);
             goto error;
         }
     }
@@ -4431,17 +4431,17 @@ qemuBuildCommandLine(virConnectPtr conn,
         bool skip_uuid = false;
 
         if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                    _("the QEMU binary %s does not support smbios settings"),
-                            emulator);
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("the QEMU binary %s does not support smbios settings"),
+                           emulator);
             goto error;
         }
 
         /* should we really error out or just warn in those cases ? */
         if (def->os.smbios_mode == VIR_DOMAIN_SMBIOS_HOST) {
             if (driver->hostsysinfo == NULL) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("Host SMBIOS information is not available"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("Host SMBIOS information is not available"));
                 goto error;
             }
             source = driver->hostsysinfo;
@@ -4449,8 +4449,8 @@ qemuBuildCommandLine(virConnectPtr conn,
             skip_uuid = true;
         } else if (def->os.smbios_mode == VIR_DOMAIN_SMBIOS_SYSINFO) {
             if (def->sysinfo == NULL) {
-                qemuReportError(VIR_ERR_XML_ERROR,
-                            _("Domain '%s' sysinfo are not available"),
+                virReportError(VIR_ERR_XML_ERROR,
+                               _("Domain '%s' sysinfo are not available"),
                                def->name);
                 goto error;
             }
@@ -4495,18 +4495,18 @@ qemuBuildCommandLine(virConnectPtr conn,
     /* Serial graphics adapter */
     if (def->os.bios.useserial == VIR_DOMAIN_BIOS_USESERIAL_YES) {
         if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("qemu does not support -device"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("qemu does not support -device"));
             goto error;
         }
         if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SGA)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("qemu does not support SGA"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("qemu does not support SGA"));
             goto error;
         }
         if (!def->nserials) {
-            qemuReportError(VIR_ERR_XML_ERROR, "%s",
-                            _("need at least one serial port to use SGA"));
+            virReportError(VIR_ERR_XML_ERROR, "%s",
+                           _("need at least one serial port to use SGA"));
             goto error;
         }
         virCommandAddArgList(cmd, "-device", "sga", NULL);
@@ -4560,9 +4560,9 @@ qemuBuildCommandLine(virConnectPtr conn,
             break;
 
         default:
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("unsupported clock offset '%s'"),
-                            virDomainClockOffsetTypeToString(def->clock.offset));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("unsupported clock offset '%s'"),
+                           virDomainClockOffsetTypeToString(def->clock.offset));
             goto error;
         }
     }
@@ -4576,9 +4576,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         default:
         case VIR_DOMAIN_TIMER_NAME_PLATFORM:
         case VIR_DOMAIN_TIMER_NAME_TSC:
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("unsupported timer type (name) '%s'"),
-                            virDomainTimerNameTypeToString(def->clock.timers[i]->name));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("unsupported timer type (name) '%s'"),
+                           virDomainTimerNameTypeToString(def->clock.timers[i]->name));
             goto error;
 
         case VIR_DOMAIN_TIMER_NAME_KVMCLOCK:
@@ -4600,9 +4600,9 @@ qemuBuildCommandLine(virConnectPtr conn,
                     break;
                 case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
                 case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    _("unsupported rtc tickpolicy '%s'"),
-                                    virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   _("unsupported rtc tickpolicy '%s'"),
+                                   virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
                 goto error;
                 }
             } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_RTC)
@@ -4611,9 +4611,9 @@ qemuBuildCommandLine(virConnectPtr conn,
                        && (def->clock.timers[i]->tickpolicy != -1)) {
                 /* a non-default rtc policy was given, but there is no
                    way to implement it in this version of qemu */
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("unsupported rtc tickpolicy '%s'"),
-                                virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("unsupported rtc tickpolicy '%s'"),
+                               virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
                 goto error;
             }
             break;
@@ -4635,18 +4635,18 @@ qemuBuildCommandLine(virConnectPtr conn,
                     virCommandAddArg(cmd, "-tdf");
                 } else {
                     /* can't catchup if we have neither pit mode */
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    _("unsupported pit tickpolicy '%s'"),
-                                    virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   _("unsupported pit tickpolicy '%s'"),
+                                   virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
                     goto error;
                 }
                 break;
             case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
             case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
                 /* no way to support these modes for pit in qemu */
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("unsupported pit tickpolicy '%s'"),
-                                virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("unsupported pit tickpolicy '%s'"),
+                               virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
                 goto error;
             }
             break;
@@ -4666,8 +4666,8 @@ qemuBuildCommandLine(virConnectPtr conn,
                 /* no hpet timer available. The only possible action
                    is to raise an error if present="yes" */
                 if (def->clock.timers[i]->present == 1) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    "%s", _("pit timer is not supported"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   "%s", _("pit timer is not supported"));
                 }
             }
             break;
@@ -4701,8 +4701,8 @@ qemuBuildCommandLine(virConnectPtr conn,
              * configuration is used
              */
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("hypervisor lacks deviceboot feature"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("hypervisor lacks deviceboot feature"));
                 goto error;
             }
             emitBootindex = true;
@@ -4767,9 +4767,9 @@ qemuBuildCommandLine(virConnectPtr conn,
 
         if (disk->driverName != NULL &&
             !STREQ(disk->driverName, "qemu")) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("unsupported driver name '%s' for disk '%s'"),
-                            disk->driverName, disk->src);
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("unsupported driver name '%s' for disk '%s'"),
+                           disk->driverName, disk->src);
             goto error;
         }
     }
@@ -4788,8 +4788,8 @@ qemuBuildCommandLine(virConnectPtr conn,
             /* Only recent QEMU implements a SATA (AHCI) controller */
             if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA) {
                 if (!qemuCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI)) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    "%s", _("SATA is not supported with this QEMU binary"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   "%s", _("SATA is not supported with this QEMU binary"));
                     goto error;
                 } else {
                     char *devstr;
@@ -4805,8 +4805,8 @@ qemuBuildCommandLine(virConnectPtr conn,
                 def->controllers[i]->model == -1 &&
                 !qemuCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
                 if (usblegacy) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    _("Multiple legacy USB controller not supported"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   _("Multiple legacy USB controller not supported"));
                     goto error;
                 }
                 usblegacy = true;
@@ -4861,9 +4861,9 @@ qemuBuildCommandLine(virConnectPtr conn,
                     virCommandAddArg(cmd, "-usbdevice");
                     virCommandAddArgFormat(cmd, "disk:%s", disk->src);
                 } else {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("unsupported usb disk type for '%s'"),
-                                    disk->src);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("unsupported usb disk type for '%s'"),
+                                   disk->src);
                     goto error;
                 }
                 continue;
@@ -4950,9 +4950,9 @@ qemuBuildCommandLine(virConnectPtr conn,
 
             if ((disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) &&
                 (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("tray status 'open' is invalid for "
-                                  "block type disk"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("tray status 'open' is invalid for "
+                                 "block type disk"));
                 goto error;
             }
 
@@ -4961,9 +4961,9 @@ qemuBuildCommandLine(virConnectPtr conn,
                     virCommandAddArg(cmd, "-usbdevice");
                     virCommandAddArgFormat(cmd, "disk:%s", disk->src);
                 } else {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("unsupported usb disk type for '%s'"),
-                                    disk->src);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("unsupported usb disk type for '%s'"),
+                                   disk->src);
                     goto error;
                 }
                 continue;
@@ -4981,8 +4981,8 @@ qemuBuildCommandLine(virConnectPtr conn,
                     STRPREFIX(disk->dst, "fd")) {
                     snprintf(dev, NAME_MAX, "-%s", disk->dst);
                 } else {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("unsupported disk type '%s'"), disk->dst);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("unsupported disk type '%s'"), disk->dst);
                     goto error;
                 }
             }
@@ -4991,14 +4991,14 @@ qemuBuildCommandLine(virConnectPtr conn,
                 /* QEMU only supports magic FAT format for now */
                 if (disk->driverType &&
                     STRNEQ(disk->driverType, "fat")) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("unsupported disk driver type for '%s'"),
-                                    disk->driverType);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("unsupported disk driver type for '%s'"),
+                                   disk->driverType);
                     goto error;
                 }
                 if (!disk->readonly) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("cannot create virtual FAT disks in read-write mode"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("cannot create virtual FAT disks in read-write mode"));
                     goto error;
                 }
                 if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)
@@ -5013,8 +5013,8 @@ qemuBuildCommandLine(virConnectPtr conn,
                 switch (disk->protocol) {
                 case VIR_DOMAIN_DISK_PROTOCOL_NBD:
                     if (disk->nhosts != 1) {
-                        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                        _("NBD accepts only one host"));
+                        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                       _("NBD accepts only one host"));
                         goto error;
                     }
                     if (virAsprintf(&file, "nbd:%s:%s,", disk->hosts->name,
@@ -5085,8 +5085,8 @@ qemuBuildCommandLine(virConnectPtr conn,
         }
     } else {
         if (def->nfss) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("filesystem passthrough not supported by this QEMU"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("filesystem passthrough not supported by this QEMU"));
             goto error;
         }
     }
@@ -5248,9 +5248,9 @@ qemuBuildCommandLine(virConnectPtr conn,
             smartcard->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCID ||
             smartcard->info.addr.ccid.controller != 0 ||
             smartcard->info.addr.ccid.slot != 0) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("this QEMU binary lacks multiple smartcard "
-                              "support"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("this QEMU binary lacks multiple smartcard "
+                             "support"));
             virBufferFreeAndReset(&opt);
             goto error;
         }
@@ -5259,9 +5259,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
                 !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("this QEMU binary lacks smartcard host "
-                                  "mode support"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("this QEMU binary lacks smartcard host "
+                                 "mode support"));
                 goto error;
             }
 
@@ -5271,9 +5271,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         case VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES:
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
                 !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("this QEMU binary lacks smartcard host "
-                                  "mode support"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("this QEMU binary lacks smartcard host "
+                                 "mode support"));
                 goto error;
             }
 
@@ -5281,9 +5281,9 @@ qemuBuildCommandLine(virConnectPtr conn,
             for (j = 0; j < VIR_DOMAIN_SMARTCARD_NUM_CERTIFICATES; j++) {
                 if (strchr(smartcard->data.cert.file[j], ',')) {
                     virBufferFreeAndReset(&opt);
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    _("invalid certificate name: %s"),
-                                    smartcard->data.cert.file[j]);
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   _("invalid certificate name: %s"),
+                                   smartcard->data.cert.file[j]);
                     goto error;
                 }
                 virBufferAsprintf(&opt, ",cert%d=%s", j + 1,
@@ -5292,9 +5292,9 @@ qemuBuildCommandLine(virConnectPtr conn,
             if (smartcard->data.cert.database) {
                 if (strchr(smartcard->data.cert.database, ',')) {
                     virBufferFreeAndReset(&opt);
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    _("invalid database name: %s"),
-                                    smartcard->data.cert.database);
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   _("invalid database name: %s"),
+                                   smartcard->data.cert.database);
                     goto error;
                 }
                 database = smartcard->data.cert.database;
@@ -5307,9 +5307,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         case VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH:
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
                 !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_PASSTHRU)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("this QEMU binary lacks smartcard "
-                                  "passthrough mode support"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("this QEMU binary lacks smartcard "
+                                 "passthrough mode support"));
                 goto error;
             }
 
@@ -5328,9 +5328,9 @@ qemuBuildCommandLine(virConnectPtr conn,
             break;
 
         default:
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unexpected smartcard type %d"),
-                            smartcard->type);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unexpected smartcard type %d"),
+                           smartcard->type);
             virBufferFreeAndReset(&opt);
             goto error;
         }
@@ -5420,8 +5420,8 @@ qemuBuildCommandLine(virConnectPtr conn,
         case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
                 !qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                "%s", _("guestfwd requires QEMU to support -chardev & -device"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               "%s", _("guestfwd requires QEMU to support -chardev & -device"));
                 goto error;
             }
 
@@ -5448,8 +5448,8 @@ qemuBuildCommandLine(virConnectPtr conn,
 
         case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                    _("virtio channel requires QEMU to support -device"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("virtio channel requires QEMU to support -device"));
                 goto error;
             }
 
@@ -5487,8 +5487,8 @@ qemuBuildCommandLine(virConnectPtr conn,
         switch(console->targetType) {
         case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                    _("virtio channel requires QEMU to support -device"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("virtio channel requires QEMU to support -device"));
                 goto error;
             }
 
@@ -5512,9 +5512,9 @@ qemuBuildCommandLine(virConnectPtr conn,
             break;
 
         default:
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("unsupported console target type %s"),
-                            NULLSTR(virDomainChrConsoleTargetTypeToString(console->targetType)));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("unsupported console target type %s"),
+                           NULLSTR(virDomainChrConsoleTargetTypeToString(console->targetType)));
             goto error;
         }
     }
@@ -5553,8 +5553,8 @@ qemuBuildCommandLine(virConnectPtr conn,
     }
 
     if (def->ngraphics > 1) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("only 1 graphics device is supported"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("only 1 graphics device is supported"));
         goto error;
     }
 
@@ -5592,15 +5592,15 @@ qemuBuildCommandLine(virConnectPtr conn,
                     break;
                 ret = networkGetNetworkAddress(listenNetwork, &netAddr);
                 if (ret <= -2) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    "%s", _("network-based listen not possible, "
-                                            "network driver not present"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   "%s", _("network-based listen not possible, "
+                                           "network driver not present"));
                     goto error;
                 }
                 if (ret < 0) {
-                    qemuReportError(VIR_ERR_XML_ERROR,
-                                    _("listen network '%s' had no usable address"),
-                                    listenNetwork);
+                    virReportError(VIR_ERR_XML_ERROR,
+                                   _("listen network '%s' had no usable address"),
+                                   listenNetwork);
                     goto error;
                 }
                 listenAddr = netAddr;
@@ -5676,9 +5676,9 @@ qemuBuildCommandLine(virConnectPtr conn,
                def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) {
         if (qemuCapsGet(qemuCaps, QEMU_CAPS_0_10) &&
             !qemuCapsGet(qemuCaps, QEMU_CAPS_SDL)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("sdl not supported by '%s'"),
-                            def->emulator);
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("sdl not supported by '%s'"),
+                           def->emulator);
             goto error;
         }
 
@@ -5714,8 +5714,8 @@ qemuBuildCommandLine(virConnectPtr conn,
         int defaultMode = def->graphics[0]->data.spice.defaultMode;
 
         if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SPICE)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("spice graphics are not supported with this QEMU"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("spice graphics are not supported with this QEMU"));
             goto error;
         }
 
@@ -5723,9 +5723,9 @@ qemuBuildCommandLine(virConnectPtr conn,
 
         if (def->graphics[0]->data.spice.tlsPort > 0) {
             if (!driver->spiceTLS) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("spice TLS port set in XML configuration,"
-                                  " but TLS is disabled in qemu.conf"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("spice TLS port set in XML configuration,"
+                                 " but TLS is disabled in qemu.conf"));
                 goto error;
             }
             virBufferAsprintf(&opt, ",tls-port=%u",
@@ -5743,15 +5743,15 @@ qemuBuildCommandLine(virConnectPtr conn,
                 break;
             ret = networkGetNetworkAddress(listenNetwork, &netAddr);
             if (ret <= -2) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                "%s", _("network-based listen not possible, "
-                                        "network driver not present"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               "%s", _("network-based listen not possible, "
+                                       "network driver not present"));
                 goto error;
             }
             if (ret < 0) {
-                qemuReportError(VIR_ERR_XML_ERROR,
-                                _("listen network '%s' had no usable address"),
-                                listenNetwork);
+                virReportError(VIR_ERR_XML_ERROR,
+                               _("listen network '%s' had no usable address"),
+                               listenNetwork);
                 goto error;
             }
             listenAddr = netAddr;
@@ -5812,8 +5812,8 @@ qemuBuildCommandLine(virConnectPtr conn,
             switch (mode) {
             case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
                 if (!driver->spiceTLS) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    _("spice secure channels set in XML configuration, but TLS is disabled in qemu.conf"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   _("spice secure channels set in XML configuration, but TLS is disabled in qemu.conf"));
                     goto error;
                 }
                 virBufferAsprintf(&opt, ",tls-channel=%s",
@@ -5854,9 +5854,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         virCommandAddEnvString(cmd, "QEMU_AUDIO_DRV=spice");
 
     } else if ((def->ngraphics == 1)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("unsupported graphics type '%s'"),
-                        virDomainGraphicsTypeToString(def->graphics[0]->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("unsupported graphics type '%s'"),
+                       virDomainGraphicsTypeToString(def->graphics[0]->type));
         goto error;
     }
 
@@ -5867,16 +5867,16 @@ qemuBuildCommandLine(virConnectPtr conn,
             } else {
                 if ((def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) &&
                     !qemuCapsGet(qemuCaps, QEMU_CAPS_VGA_QXL)) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                    _("This QEMU does not support QXL graphics adapters"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                                   _("This QEMU does not support QXL graphics adapters"));
                     goto error;
                 }
 
                 const char *vgastr = qemuVideoTypeToString(def->videos[0]->type);
                 if (!vgastr || STREQ(vgastr, "")) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    _("video type %s is not supported with QEMU"),
-                                    virDomainVideoTypeToString(def->videos[0]->type));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   _("video type %s is not supported with QEMU"),
+                                   virDomainVideoTypeToString(def->videos[0]->type));
                     goto error;
                 }
 
@@ -5886,9 +5886,9 @@ qemuBuildCommandLine(virConnectPtr conn,
                     if (def->videos[0]->vram &&
                         qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
                         if (def->videos[0]->vram > (UINT_MAX / 1024)) {
-                            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                            _("value for 'vram' must be less than '%u'"),
-                                            UINT_MAX / 1024);
+                            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                           _("value for 'vram' must be less than '%u'"),
+                                           UINT_MAX / 1024);
                             goto error;
                         }
 
@@ -5920,9 +5920,9 @@ qemuBuildCommandLine(virConnectPtr conn,
                 break;
 
             default:
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("video type %s is not supported with this QEMU"),
-                                virDomainVideoTypeToString(def->videos[0]->type));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("video type %s is not supported with this QEMU"),
+                               virDomainVideoTypeToString(def->videos[0]->type));
                 goto error;
             }
         }
@@ -5932,9 +5932,9 @@ qemuBuildCommandLine(virConnectPtr conn,
                 for (i = 1 ; i < def->nvideos ; i++) {
                     char *str;
                     if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
-                        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                        _("video type %s is only valid as primary video card"),
-                                        virDomainVideoTypeToString(def->videos[0]->type));
+                        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                       _("video type %s is only valid as primary video card"),
+                                       virDomainVideoTypeToString(def->videos[0]->type));
                         goto error;
                     }
 
@@ -5947,8 +5947,8 @@ qemuBuildCommandLine(virConnectPtr conn,
                     VIR_FREE(str);
                 }
             } else {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                "%s", _("only one video card is currently supported"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               "%s", _("only one video card is currently supported"));
                 goto error;
             }
         }
@@ -6022,15 +6022,15 @@ qemuBuildCommandLine(virConnectPtr conn,
                 const char *model = virDomainSoundModelTypeToString(sound->model);
                 if (!model) {
                     VIR_FREE(modstr);
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    "%s", _("invalid sound model"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   "%s", _("invalid sound model"));
                     goto error;
                 }
 
                 if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6) {
                     VIR_FREE(modstr);
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                    _("this QEMU binary lacks hda support"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                                   _("this QEMU binary lacks hda support"));
                     goto error;
                 }
 
@@ -6060,8 +6060,8 @@ qemuBuildCommandLine(virConnectPtr conn,
 
             const char *model = virDomainWatchdogModelTypeToString(watchdog->model);
             if (!model) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                "%s", _("missing watchdog model"));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               "%s", _("missing watchdog model"));
                 goto error;
             }
 
@@ -6076,8 +6076,8 @@ qemuBuildCommandLine(virConnectPtr conn,
             act = VIR_DOMAIN_WATCHDOG_ACTION_PAUSE;
         const char *action = virDomainWatchdogActionTypeToString(act);
         if (!action) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("invalid watchdog action"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("invalid watchdog action"));
             goto error;
         }
         virCommandAddArgList(cmd, "-watchdog-action", action, NULL);
@@ -6117,14 +6117,14 @@ qemuBuildCommandLine(virConnectPtr conn,
         if (hostdev->info->bootIndex) {
             if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
                 hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("booting from assigned devices is only"
-                                  " supported for PCI devices"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("booting from assigned devices is only"
+                                 " supported for PCI devices"));
                 goto error;
             } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_BOOTINDEX)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("booting from assigned PCI devices is not"
-                                  " supported with this version of qemu"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("booting from assigned PCI devices is not"
+                                 " supported with this version of qemu"));
                 goto error;
             }
         }
@@ -6179,8 +6179,8 @@ qemuBuildCommandLine(virConnectPtr conn,
                 virCommandAddArg(cmd, devstr);
                 VIR_FREE(devstr);
             } else {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("PCI device assignment is not supported by this version of qemu"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("PCI device assignment is not supported by this version of qemu"));
                 goto error;
             }
         }
@@ -6193,9 +6193,9 @@ qemuBuildCommandLine(virConnectPtr conn,
         virCommandAddArg(cmd, "-incoming");
         if (STRPREFIX(migrateFrom, "tcp")) {
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                "%s", _("TCP migration is not supported with "
-                                        "this QEMU binary"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               "%s", _("TCP migration is not supported with "
+                                       "this QEMU binary"));
                 goto error;
             }
             virCommandAddArg(cmd, migrateFrom);
@@ -6210,39 +6210,39 @@ qemuBuildCommandLine(virConnectPtr conn,
                 virCommandAddArg(cmd, migrateFrom);
                 virCommandSetInputFD(cmd, migrateFd);
             } else {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                "%s", _("STDIO migration is not supported "
-                                        "with this QEMU binary"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               "%s", _("STDIO migration is not supported "
+                                       "with this QEMU binary"));
                 goto error;
             }
         } else if (STRPREFIX(migrateFrom, "exec")) {
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                "%s", _("EXEC migration is not supported "
-                                        "with this QEMU binary"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               "%s", _("EXEC migration is not supported "
+                                       "with this QEMU binary"));
                 goto error;
             }
             virCommandAddArg(cmd, migrateFrom);
         } else if (STRPREFIX(migrateFrom, "fd")) {
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                "%s", _("FD migration is not supported "
-                                        "with this QEMU binary"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               "%s", _("FD migration is not supported "
+                                       "with this QEMU binary"));
                 goto error;
             }
             virCommandAddArg(cmd, migrateFrom);
             virCommandPreserveFD(cmd, migrateFd);
         } else if (STRPREFIX(migrateFrom, "unix")) {
             if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                "%s", _("UNIX migration is not supported "
-                                        "with this QEMU binary"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               "%s", _("UNIX migration is not supported "
+                                       "with this QEMU binary"));
                 goto error;
             }
             virCommandAddArg(cmd, migrateFrom);
         } else {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("unknown migration protocol"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("unknown migration protocol"));
             goto error;
         }
     }
@@ -6256,9 +6256,9 @@ qemuBuildCommandLine(virConnectPtr conn,
     if ((def->memballoon) &&
         (def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE)) {
         if (def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("Memory balloon device type '%s' is not supported by this version of qemu"),
-                            virDomainMemballoonModelTypeToString(def->memballoon->model));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("Memory balloon device type '%s' is not supported by this version of qemu"),
+                           virDomainMemballoonModelTypeToString(def->memballoon->model));
             goto error;
         }
         if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
@@ -6516,8 +6516,8 @@ qemuParseKeywords(const char *str,
 
         if (separator >= endmark) {
             if (!allowEmptyValue) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("malformed keyword arguments in '%s'"), str);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("malformed keyword arguments in '%s'"), str);
                 goto error;
             }
             separator = endmark;
@@ -6629,9 +6629,9 @@ qemuParseCommandLineDisk(virCapsPtr caps,
                     host = def->src + strlen("nbd:");
                     port = strchr(host, ':');
                     if (!port) {
-                        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                        _("cannot parse nbd filename '%s'"),
-                                        def->src);
+                        virReportError(VIR_ERR_INTERNAL_ERROR,
+                                       _("cannot parse nbd filename '%s'"),
+                                       def->src);
                         def = NULL;
                         goto cleanup;
                     }
@@ -6688,8 +6688,8 @@ qemuParseCommandLineDisk(virCapsPtr caps,
                         vdi = strchr(port, ':');
                         if (!vdi) {
                             def = NULL;
-                            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                            _("cannot parse sheepdog filename '%s'"), p);
+                            virReportError(VIR_ERR_INTERNAL_ERROR,
+                                           _("cannot parse sheepdog filename '%s'"), p);
                             goto cleanup;
                         }
                         *vdi++ = '\0';
@@ -6775,24 +6775,24 @@ qemuParseCommandLineDisk(virCapsPtr caps,
             if (virStrToLong_i(values[i], NULL, 10, &idx) < 0) {
                 virDomainDiskDefFree(def);
                 def = NULL;
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse drive index '%s'"), val);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse drive index '%s'"), val);
                 goto cleanup;
             }
         } else if (STREQ(keywords[i], "bus")) {
             if (virStrToLong_i(values[i], NULL, 10, &busid) < 0) {
                 virDomainDiskDefFree(def);
                 def = NULL;
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse drive bus '%s'"), val);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse drive bus '%s'"), val);
                 goto cleanup;
             }
         } else if (STREQ(keywords[i], "unit")) {
             if (virStrToLong_i(values[i], NULL, 10, &unitid) < 0) {
                 virDomainDiskDefFree(def);
                 def = NULL;
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse drive unit '%s'"), val);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse drive unit '%s'"), val);
                 goto cleanup;
             }
         } else if (STREQ(keywords[i], "readonly")) {
@@ -6800,8 +6800,8 @@ qemuParseCommandLineDisk(virCapsPtr caps,
                 def->readonly = 1;
         } else if (STREQ(keywords[i], "aio")) {
             if ((def->iomode = virDomainDiskIoTypeFromString(values[i])) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse io mode '%s'"), values[i]);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse io mode '%s'"), values[i]);
             }
         }
     }
@@ -6812,8 +6812,8 @@ qemuParseCommandLineDisk(virCapsPtr caps,
     if (!def->src &&
         def->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
         def->type != VIR_DOMAIN_DISK_TYPE_NETWORK) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("missing file parameter in drive '%s'"), val);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("missing file parameter in drive '%s'"), val);
         virDomainDiskDefFree(def);
         def = NULL;
         goto cleanup;
@@ -6825,8 +6825,8 @@ qemuParseCommandLineDisk(virCapsPtr caps,
     if (idx == -1 &&
         unitid == -1 &&
         busid == -1) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("missing index/unit/bus parameter in drive '%s'"), val);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("missing index/unit/bus parameter in drive '%s'"), val);
         virDomainDiskDefFree(def);
         def = NULL;
         goto cleanup;
@@ -6874,8 +6874,8 @@ qemuParseCommandLineDisk(virCapsPtr caps,
         def->dst[2] = 'a' + idx;
 
     if (virDomainDiskDefAssignAddress(caps, def) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("invalid device name '%s'"), def->dst);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("invalid device name '%s'"), def->dst);
         virDomainDiskDefFree(def);
         def = NULL;
         /* fall through to "cleanup" */
@@ -6910,8 +6910,8 @@ qemuFindNICForVLAN(int nnics,
         tmp += strlen("vlan=");
 
         if (virStrToLong_i(tmp, &end, 10, &gotvlan) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot parse NIC vlan in '%s'"), nics[i]);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot parse NIC vlan in '%s'"), nics[i]);
             return NULL;
         }
 
@@ -6922,8 +6922,8 @@ qemuFindNICForVLAN(int nnics,
     if (wantvlan == 0 && nnics > 0)
         return nics[0];
 
-    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                    _("cannot find NIC definition for vlan %d"), wantvlan);
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   _("cannot find NIC definition for vlan %d"), wantvlan);
     return NULL;
 }
 
@@ -6979,8 +6979,8 @@ qemuParseCommandLineNet(virCapsPtr caps,
     for (i = 0 ; i < nkeywords ; i++) {
         if (STREQ(keywords[i], "vlan")) {
             if (virStrToLong_i(values[i], NULL, 10, &wantvlan) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse vlan in '%s'"), val);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse vlan in '%s'"), val);
                 virDomainNetDefFree(def);
                 def = NULL;
                 goto cleanup;
@@ -7009,8 +7009,8 @@ qemuParseCommandLineNet(virCapsPtr caps,
     }
 
     if (!STRPREFIX(nic, "nic")) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot parse NIC definition '%s'"), nic);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot parse NIC definition '%s'"), nic);
         virDomainNetDefFree(def);
         def = NULL;
         goto cleanup;
@@ -7039,9 +7039,9 @@ qemuParseCommandLineNet(virCapsPtr caps,
         if (STREQ(keywords[i], "macaddr")) {
             genmac = 0;
             if (virMacAddrParse(values[i], &def->mac) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("unable to parse mac address '%s'"),
-                                values[i]);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("unable to parse mac address '%s'"),
+                               values[i]);
                 virDomainNetDefFree(def);
                 def = NULL;
                 goto cleanup;
@@ -7057,8 +7057,8 @@ qemuParseCommandLineNet(virCapsPtr caps,
             }
         } else if (STREQ(keywords[i], "sndbuf") && values[i]) {
             if (virStrToLong_ul(values[i], NULL, 10, &def->tune.sndbuf) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse sndbuf size in '%s'"), val);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse sndbuf size in '%s'"), val);
                 virDomainNetDefFree(def);
                 def = NULL;
                 goto cleanup;
@@ -7096,27 +7096,27 @@ qemuParseCommandLinePCI(const char *val)
        goto error;
 
     if (!STRPREFIX(val, "host=")) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unknown PCI device syntax '%s'"), val);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unknown PCI device syntax '%s'"), val);
         goto error;
     }
 
     start = val + strlen("host=");
     if (virStrToLong_i(start, &end, 16, &bus) < 0 || *end != ':') {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot extract PCI device bus '%s'"), val);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot extract PCI device bus '%s'"), val);
         goto error;
     }
     start = end + 1;
     if (virStrToLong_i(start, &end, 16, &slot) < 0 || *end != '.') {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot extract PCI device slot '%s'"), val);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot extract PCI device slot '%s'"), val);
         goto error;
     }
     start = end + 1;
     if (virStrToLong_i(start, NULL, 16, &func) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot extract PCI device function '%s'"), val);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot extract PCI device function '%s'"), val);
         goto error;
     }
 
@@ -7149,34 +7149,34 @@ qemuParseCommandLineUSB(const char *val)
        goto error;
 
     if (!STRPREFIX(val, "host:")) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unknown USB device syntax '%s'"), val);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unknown USB device syntax '%s'"), val);
         goto error;
     }
 
     start = val + strlen("host:");
     if (strchr(start, ':')) {
         if (virStrToLong_i(start, &end, 16, &first) < 0 || *end != ':') {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot extract USB device vendor '%s'"), val);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot extract USB device vendor '%s'"), val);
             goto error;
         }
         start = end + 1;
         if (virStrToLong_i(start, NULL, 16, &second) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot extract USB device product '%s'"), val);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot extract USB device product '%s'"), val);
             goto error;
         }
     } else {
         if (virStrToLong_i(start, &end, 10, &first) < 0 || *end != '.') {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                             _("cannot extract USB device bus '%s'"), val);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot extract USB device bus '%s'"), val);
             goto error;
         }
         start = end + 1;
         if (virStrToLong_i(start, NULL, 10, &second) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot extract USB device address '%s'"), val);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot extract USB device address '%s'"), val);
             goto error;
         }
     }
@@ -7280,8 +7280,8 @@ qemuParseCommandLineChr(virDomainChrSourceDefPtr source,
         }
         svc = strchr(val, ':');
         if (!svc) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find port number in character device %s"), val);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find port number in character device %s"), val);
             goto error;
         }
         opt = strchr(svc, ',');
@@ -7320,8 +7320,8 @@ qemuParseCommandLineChr(virDomainChrSourceDefPtr source,
         if (!source->data.file.path)
             goto no_memory;
     } else {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unknown character device syntax %s"), val);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unknown character device syntax %s"), val);
         goto error;
     }
 
@@ -7432,8 +7432,8 @@ qemuParseCommandLineCPU(virDomainDefPtr dom,
 
                 if (dom->clock.timers[i]->present != -1 &&
                     dom->clock.timers[i]->present != present) {
-                    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                    _("conflicting occurrences of kvmclock feature"));
+                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                                   _("conflicting occurrences of kvmclock feature"));
                     goto error;
                 }
                 dom->clock.timers[i]->present = present;
@@ -7482,8 +7482,8 @@ qemuParseCommandLineCPU(virDomainDefPtr dom,
     return 0;
 
 syntax:
-    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                    _("unknown CPU syntax '%s'"), val);
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   _("unknown CPU syntax '%s'"), val);
     goto error;
 
 no_memory:
@@ -7561,8 +7561,8 @@ cleanup:
     return ret;
 
 syntax:
-    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                    _("cannot parse CPU topology '%s'"), val);
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   _("cannot parse CPU topology '%s'"), val);
 error:
     ret = -1;
     goto cleanup;
@@ -7602,8 +7602,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
         *monJSON = false;
 
     if (!progargv[0]) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("no emulator path found"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("no emulator path found"));
         return NULL;
     }
 
@@ -7615,8 +7615,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
         goto no_memory;
 
     if (virUUIDGenerate(def->uuid) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("failed to generate uuid"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("failed to generate uuid"));
         goto error;
     }
 
@@ -7668,8 +7668,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
 #define WANT_VALUE()                                                   \
     const char *val = progargv[++i];                                   \
     if (!val) {                                                        \
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,                        \
-                        _("missing value for %s argument"), arg);      \
+        virReportError(VIR_ERR_INTERNAL_ERROR,                        \
+                       _("missing value for %s argument"), arg);       \
         goto error;                                                    \
     }
 
@@ -7728,15 +7728,15 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
                 tmp = strstr(val, sep);
                 if (!tmp) {
                     virDomainGraphicsDefFree(vnc);
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("missing VNC port number in '%s'"), val);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("missing VNC port number in '%s'"), val);
                     goto error;
                 }
                 if (virStrToLong_i(tmp+strlen(sep), &opts, 10,
                                    &vnc->data.vnc.port) < 0) {
                     virDomainGraphicsDefFree(vnc);
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("cannot parse VNC port '%s'"), tmp+1);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("cannot parse VNC port '%s'"), tmp+1);
                     goto error;
                 }
                 if (val[0] == '[')
@@ -7762,8 +7762,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
             int mem;
             WANT_VALUE();
             if (virStrToLong_i(val, NULL, 10, &mem) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, \
-                                _("cannot parse memory level '%s'"), val);
+                virReportError(VIR_ERR_INTERNAL_ERROR, \
+                               _("cannot parse memory level '%s'"), val);
                 goto error;
             }
             def->mem.cur_balloon = def->mem.max_balloon = mem * 1024;
@@ -7774,8 +7774,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
         } else if (STREQ(arg, "-uuid")) {
             WANT_VALUE();
             if (virUUIDParse(val, def->uuid) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, \
-                                _("cannot parse UUID '%s'"), val);
+                virReportError(VIR_ERR_INTERNAL_ERROR, \
+                               _("cannot parse UUID '%s'"), val);
                 goto error;
             }
         } else if (STRPREFIX(arg, "-hd") ||
@@ -7835,8 +7835,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
                     host = disk->src;
                     port = strchr(host, ':');
                     if (!port) {
-                        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                        _("cannot parse nbd filename '%s'"), disk->src);
+                        virReportError(VIR_ERR_INTERNAL_ERROR,
+                                       _("cannot parse nbd filename '%s'"), disk->src);
                         goto error;
                     }
                     *port++ = '\0';
@@ -7864,8 +7864,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
                         *port++ = '\0';
                         vdi = strchr(port, ':');
                         if (!vdi) {
-                            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                            _("cannot parse sheepdog filename '%s'"), val);
+                            virReportError(VIR_ERR_INTERNAL_ERROR,
+                                           _("cannot parse sheepdog filename '%s'"), val);
                             goto error;
                         }
                         *vdi++ = '\0';
@@ -8144,8 +8144,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
             if (STRNEQ(val, "none")) {
                 video = qemuVideoTypeFromString(val);
                 if (video < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("unknown video adapter type '%s'"), val);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("unknown video adapter type '%s'"), val);
                     goto error;
                 }
             }
@@ -8217,15 +8217,15 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
         }
 
         if (!first_rbd_disk) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("CEPH_ARGS was set without an rbd disk"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("CEPH_ARGS was set without an rbd disk"));
             goto error;
         }
 
         /* CEPH_ARGS should be: -m host1[:port1][,host2[:port2]]... */
         if (!STRPREFIX(ceph_args, "-m ")) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("could not parse CEPH_ARGS '%s'"), ceph_args);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("could not parse CEPH_ARGS '%s'"), ceph_args);
             goto error;
         }
         hosts = strdup(strchr(ceph_args, ' ') + 1);
@@ -8259,8 +8259,8 @@ virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
         VIR_FREE(hosts);
 
         if (first_rbd_disk->nhosts == 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("found no rbd hosts in CEPH_ARGS '%s'"), ceph_args);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("found no rbd hosts in CEPH_ARGS '%s'"), ceph_args);
             goto error;
         }
     }
diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c
index 88a04bc..7735ffe 100644
--- a/src/qemu/qemu_conf.c
+++ b/src/qemu/qemu_conf.c
@@ -140,9 +140,9 @@ int qemudLoadDriverConfig(struct qemud_driver *driver,
 
 
 #define CHECK_TYPE(name,typ) if (p && p->type != (typ)) {               \
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,                         \
-                        "%s: %s: expected type " #typ,                  \
-                        filename, (name));                              \
+        virReportError(VIR_ERR_INTERNAL_ERROR,                          \
+                       "%s: %s: expected type " #typ,                   \
+                       filename, (name));                               \
         virConfFree(conf);                                              \
         return -1;                                                      \
     }
@@ -535,16 +535,16 @@ qemuDriverCloseCallbackSet(struct qemud_driver *driver,
     closeDef = virHashLookup(driver->closeCallbacks, uuidstr);
     if (closeDef) {
         if (closeDef->conn != conn) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Close callback for domain %s already registered"
-                              " with another connection %p"),
-                            vm->def->name, closeDef->conn);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Close callback for domain %s already registered"
+                             " with another connection %p"),
+                           vm->def->name, closeDef->conn);
             return -1;
         }
         if (closeDef->cb && closeDef->cb != cb) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Another close callback is already defined for"
-                              " domain %s"), vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Another close callback is already defined for"
+                             " domain %s"), vm->def->name);
             return -1;
         }
 
@@ -582,9 +582,9 @@ qemuDriverCloseCallbackUnset(struct qemud_driver *driver,
         return -1;
 
     if (closeDef->cb && closeDef->cb != cb) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Trying to remove mismatching close callback for"
-                          " domain %s"), vm->def->name);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Trying to remove mismatching close callback for"
+                         " domain %s"), vm->def->name);
         return -1;
     }
 
diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h
index 482e6d3..4234807 100644
--- a/src/qemu/qemu_conf.h
+++ b/src/qemu/qemu_conf.h
@@ -167,10 +167,6 @@ struct _qemuDomainCmdlineDef {
 # define QEMUD_MIGRATION_FIRST_PORT 49152
 # define QEMUD_MIGRATION_NUM_PORTS 64
 
-# define qemuReportError(code, ...)                                      \
-    virReportErrorHelper(VIR_FROM_QEMU, code, __FILE__,                  \
-                         __FUNCTION__, __LINE__, __VA_ARGS__)
-
 
 void qemuDriverLock(struct qemud_driver *driver);
 void qemuDriverUnlock(struct qemud_driver *driver);
diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index 201ec03..42875b4 100644
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -344,8 +344,8 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
 
     if (!(monitorpath =
           virXPathString("string(./monitor[1]/@path)", ctxt))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("no monitor path"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("no monitor path"));
         goto error;
     }
 
@@ -371,9 +371,9 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
         break;
     default:
         VIR_FREE(monitorpath);
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unsupported monitor type '%s'"),
-                        virDomainChrTypeToString(priv->monConfig->type));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unsupported monitor type '%s'"),
+                       virDomainChrTypeToString(priv->monConfig->type));
         goto error;
     }
 
@@ -402,8 +402,8 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
     }
 
     if ((n = virXPathNodeSet("./qemuCaps/flag", ctxt, &nodes)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("failed to parse qemu capabilities flags"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("failed to parse qemu capabilities flags"));
         goto error;
     }
     if (n > 0) {
@@ -415,8 +415,8 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
             if (str) {
                 int flag = qemuCapsTypeFromString(str);
                 if (flag < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("Unknown qemu capabilities flag %s"), str);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("Unknown qemu capabilities flag %s"), str);
                     VIR_FREE(str);
                     goto error;
                 }
@@ -435,8 +435,8 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
         int type;
 
         if ((type = qemuDomainJobTypeFromString(tmp)) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unknown job type %s"), tmp);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unknown job type %s"), tmp);
             VIR_FREE(tmp);
             goto error;
         }
@@ -448,8 +448,8 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
         int async;
 
         if ((async = qemuDomainAsyncJobTypeFromString(tmp)) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unknown async job type %s"), tmp);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unknown async job type %s"), tmp);
             VIR_FREE(tmp);
             goto error;
         }
@@ -459,8 +459,8 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
         if ((tmp = virXPathString("string(./job[1]/@phase)", ctxt))) {
             priv->job.phase = qemuDomainAsyncJobPhaseFromString(async, tmp);
             if (priv->job.phase < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("Unknown job phase %s"), tmp);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Unknown job phase %s"), tmp);
                 VIR_FREE(tmp);
                 goto error;
             }
@@ -514,9 +514,9 @@ qemuDomainDefNamespaceParse(xmlDocPtr xml ATTRIBUTE_UNUSED,
     int n, i;
 
     if (xmlXPathRegisterNs(ctxt, BAD_CAST "qemu", BAD_CAST QEMU_NAMESPACE_HREF) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Failed to register xml namespace '%s'"),
-                        QEMU_NAMESPACE_HREF);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Failed to register xml namespace '%s'"),
+                       QEMU_NAMESPACE_HREF);
         return -1;
     }
 
@@ -537,8 +537,8 @@ qemuDomainDefNamespaceParse(xmlDocPtr xml ATTRIBUTE_UNUSED,
     for (i = 0; i < n; i++) {
         cmd->args[cmd->num_args] = virXMLPropString(nodes[i], "value");
         if (cmd->args[cmd->num_args] == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("No qemu command-line argument specified"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("No qemu command-line argument specified"));
             goto error;
         }
         cmd->num_args++;
@@ -563,23 +563,23 @@ qemuDomainDefNamespaceParse(xmlDocPtr xml ATTRIBUTE_UNUSED,
 
         tmp = virXMLPropString(nodes[i], "name");
         if (tmp == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("No qemu environment name specified"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("No qemu environment name specified"));
             goto error;
         }
         if (tmp[0] == '\0') {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("Empty qemu environment name specified"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("Empty qemu environment name specified"));
             goto error;
         }
         if (!c_isalpha(tmp[0]) && tmp[0] != '_') {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("Invalid environment name, it must begin with a letter or underscore"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("Invalid environment name, it must begin with a letter or underscore"));
             goto error;
         }
         if (strspn(tmp, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_") != strlen(tmp)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("Invalid environment name, it must contain only alphanumerics and underscore"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("Invalid environment name, it must contain only alphanumerics and underscore"));
             goto error;
         }
 
@@ -838,13 +838,13 @@ error:
              priv->job.owner, priv->job.asyncOwner);
 
     if (errno == ETIMEDOUT)
-        qemuReportError(VIR_ERR_OPERATION_TIMEOUT,
-                        "%s", _("cannot acquire state change lock"));
+        virReportError(VIR_ERR_OPERATION_TIMEOUT,
+                       "%s", _("cannot acquire state change lock"));
     else if (driver->max_queued &&
              priv->jobs_queued > driver->max_queued)
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("cannot acquire state change lock "
-                                "due to max_queued limit"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("cannot acquire state change lock "
+                               "due to max_queued limit"));
     else
         virReportSystemError(errno,
                              "%s", _("cannot acquire job mutex"));
@@ -899,8 +899,8 @@ int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
                                     enum qemuDomainJob job)
 {
     if (job <= QEMU_JOB_NONE || job >= QEMU_JOB_ASYNC) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Attempt to start invalid job"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Attempt to start invalid job"));
         return -1;
     }
 
@@ -971,8 +971,8 @@ qemuDomainObjEnterMonitorInternal(struct qemud_driver *driver,
 
     if (asyncJob != QEMU_ASYNC_JOB_NONE) {
         if (asyncJob != priv->job.asyncJob) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unexpected async job %d"), asyncJob);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unexpected async job %d"), asyncJob);
             return -1;
         }
         if (priv->job.asyncOwner != virThreadSelfID())
@@ -983,8 +983,8 @@ qemuDomainObjEnterMonitorInternal(struct qemud_driver *driver,
                                           QEMU_ASYNC_JOB_NONE) < 0)
             return -1;
         if (!virDomainObjIsActive(obj)) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("domain is no longer running"));
+            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                           _("domain is no longer running"));
             /* Still referenced by the containing async job.  */
             ignore_value(qemuDomainObjEndJob(driver, obj));
             return -1;
@@ -1241,8 +1241,8 @@ qemuDomainDefFormatBuf(struct qemud_driver *driver,
         def_cpu &&
         (def_cpu->mode != VIR_CPU_MODE_CUSTOM || def_cpu->model)) {
         if (!driver->caps || !driver->caps->host.cpu) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            "%s", _("cannot get host CPU capabilities"));
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           "%s", _("cannot get host CPU capabilities"));
             goto cleanup;
         }
 
@@ -1575,8 +1575,8 @@ qemuFindQemuImgBinary(struct qemud_driver *driver)
         if (!driver->qemuImgBinary)
             driver->qemuImgBinary = virFindFileInPath("qemu-img");
         if (!driver->qemuImgBinary)
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("unable to find kvm-img or qemu-img"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("unable to find kvm-img or qemu-img"));
     }
 
     return driver->qemuImgBinary;
@@ -1672,10 +1672,10 @@ qemuDomainSnapshotForEachQcow2Raw(struct qemud_driver *driver,
                     qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                       "-d", false, i);
                 }
-                qemuReportError(VIR_ERR_OPERATION_INVALID,
-                                _("Disk device '%s' does not support"
-                                  " snapshotting"),
-                                def->disks[i]->dst);
+                virReportError(VIR_ERR_OPERATION_INVALID,
+                               _("Disk device '%s' does not support"
+                                 " snapshotting"),
+                               def->disks[i]->dst);
                 return -1;
             }
 
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index d3988b8..e65f694 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -283,8 +283,8 @@ qemuCreateCapabilities(virCapsPtr oldcaps,
     qemuDomainSetNamespaceHooks(caps);
 
     if (virGetHostUUID(caps->host.host_uuid)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                         "%s", _("cannot get the host uuid"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot get the host uuid"));
         goto err_exit;
     }
 
@@ -930,33 +930,33 @@ static virDrvOpenStatus qemudOpen(virConnectPtr conn,
             return VIR_DRV_OPEN_DECLINED;
 
         if (qemu_driver == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("qemu state driver is not active"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("qemu state driver is not active"));
             return VIR_DRV_OPEN_ERROR;
         }
 
         if (conn->uri->path == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("no QEMU URI path given, try %s"),
-                            qemu_driver->privileged
-                            ? "qemu:///system"
-                            : "qemu:///session");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("no QEMU URI path given, try %s"),
+                           qemu_driver->privileged
+                           ? "qemu:///system"
+                           : "qemu:///session");
                 return VIR_DRV_OPEN_ERROR;
         }
 
         if (qemu_driver->privileged) {
             if (STRNEQ (conn->uri->path, "/system") &&
                 STRNEQ (conn->uri->path, "/session")) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("unexpected QEMU URI path '%s', try qemu:///system"),
-                                conn->uri->path);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("unexpected QEMU URI path '%s', try qemu:///system"),
+                               conn->uri->path);
                 return VIR_DRV_OPEN_ERROR;
             }
         } else {
             if (STRNEQ (conn->uri->path, "/session")) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("unexpected QEMU URI path '%s', try qemu:///session"),
-                                conn->uri->path);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("unexpected QEMU URI path '%s', try qemu:///session"),
+                               conn->uri->path);
                 return VIR_DRV_OPEN_ERROR;
             }
         }
@@ -1048,8 +1048,8 @@ qemuGetSysinfo(virConnectPtr conn, unsigned int flags)
     virCheckFlags(0, NULL);
 
     if (!driver->hostsysinfo) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("Host SMBIOS information is not available"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("Host SMBIOS information is not available"));
         return NULL;
     }
 
@@ -1075,8 +1075,8 @@ static int qemudGetMaxVCPUs(virConnectPtr conn ATTRIBUTE_UNUSED, const char *typ
     if (STRCASEEQ(type, "kqemu"))
         return 1;
 
-    qemuReportError(VIR_ERR_INVALID_ARG,
-                    _("unknown type '%s'"), type);
+    virReportError(VIR_ERR_INVALID_ARG,
+                   _("unknown type '%s'"), type);
     return -1;
 }
 
@@ -1194,8 +1194,8 @@ static virDomainPtr qemudDomainLookupByID(virConnectPtr conn,
     qemuDriverUnlock(driver);
 
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching id %d"), id);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching id %d"), id);
         goto cleanup;
     }
 
@@ -1221,8 +1221,8 @@ static virDomainPtr qemudDomainLookupByUUID(virConnectPtr conn,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1246,8 +1246,8 @@ static virDomainPtr qemudDomainLookupByName(virConnectPtr conn,
     qemuDriverUnlock(driver);
 
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching name '%s'"), name);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching name '%s'"), name);
         goto cleanup;
     }
 
@@ -1273,8 +1273,8 @@ static int qemuDomainIsActive(virDomainPtr dom)
     if (!obj) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
     ret = virDomainObjIsActive(obj);
@@ -1297,8 +1297,8 @@ static int qemuDomainIsPersistent(virDomainPtr dom)
     if (!obj) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
     ret = obj->persistent;
@@ -1321,8 +1321,8 @@ static int qemuDomainIsUpdated(virDomainPtr dom)
     if (!obj) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
     ret = obj->updated;
@@ -1478,13 +1478,13 @@ static int qemudDomainSuspend(virDomainPtr dom) {
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
@@ -1502,8 +1502,8 @@ static int qemudDomainSuspend(virDomainPtr dom) {
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
     if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) {
@@ -1545,8 +1545,8 @@ static int qemudDomainResume(virDomainPtr dom) {
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1554,8 +1554,8 @@ static int qemudDomainResume(virDomainPtr dom) {
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
     if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) {
@@ -1563,8 +1563,8 @@ static int qemudDomainResume(virDomainPtr dom) {
                                  VIR_DOMAIN_RUNNING_UNPAUSED,
                                  QEMU_ASYNC_JOB_NONE) < 0) {
             if (virGetLastError() == NULL)
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                "%s", _("resume operation failed"));
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               "%s", _("resume operation failed"));
             goto endjob;
         }
         event = virDomainEventNewFromObj(vm,
@@ -1605,8 +1605,8 @@ static int qemuDomainShutdownFlags(virDomainPtr dom, unsigned int flags) {
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1619,13 +1619,13 @@ static int qemuDomainShutdownFlags(virDomainPtr dom, unsigned int flags) {
 
     if (useAgent) {
         if (priv->agentError) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("QEMU guest agent is not available due to an error"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("QEMU guest agent is not available due to an error"));
             goto cleanup;
         }
         if (!priv->agent) {
-            qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                            _("QEMU guest agent is not configured"));
+            virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                           _("QEMU guest agent is not configured"));
             goto cleanup;
         }
     }
@@ -1634,8 +1634,8 @@ static int qemuDomainShutdownFlags(virDomainPtr dom, unsigned int flags) {
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -1686,8 +1686,8 @@ qemuDomainReboot(virDomainPtr dom, unsigned int flags)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1700,27 +1700,27 @@ qemuDomainReboot(virDomainPtr dom, unsigned int flags)
 
     if (useAgent) {
         if (priv->agentError) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("QEMU guest agent is not available due to an error"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("QEMU guest agent is not available due to an error"));
             goto cleanup;
         }
         if (!priv->agent) {
-            qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                            _("QEMU guest agent is not configured"));
+            virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                           _("QEMU guest agent is not configured"));
             goto cleanup;
         }
     } else {
 #if HAVE_YAJL
         if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
             if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("Reboot is not supported with this QEMU binary"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("Reboot is not supported with this QEMU binary"));
                 goto cleanup;
             }
         } else {
 #endif
-            qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                            _("Reboot is not supported without the JSON monitor"));
+            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                           _("Reboot is not supported without the JSON monitor"));
             goto cleanup;
 #if HAVE_YAJL
         }
@@ -1731,8 +1731,8 @@ qemuDomainReboot(virDomainPtr dom, unsigned int flags)
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -1777,8 +1777,8 @@ qemuDomainReset(virDomainPtr dom, unsigned int flags)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1786,8 +1786,8 @@ qemuDomainReset(virDomainPtr dom, unsigned int flags)
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -1839,8 +1839,8 @@ qemuDomainDestroyFlags(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1855,8 +1855,8 @@ qemuDomainDestroyFlags(virDomainPtr dom,
      */
     if (flags & VIR_DOMAIN_DESTROY_GRACEFUL) {
         if (qemuProcessKill(driver, vm, 0) < 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("failed to kill qemu process with SIGTERM"));
+            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                           _("failed to kill qemu process with SIGTERM"));
             goto cleanup;
         }
     } else {
@@ -1874,8 +1874,8 @@ qemuDomainDestroyFlags(virDomainPtr dom,
     priv->beingDestroyed = false;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -1923,8 +1923,8 @@ static char *qemudDomainGetOSType(virDomainPtr dom) {
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1952,8 +1952,8 @@ qemuDomainGetMaxMemory(virDomainPtr dom)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1983,8 +1983,8 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -1999,9 +1999,9 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
         /* resize the maximum memory */
 
         if (flags & VIR_DOMAIN_AFFECT_LIVE) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                            _("cannot resize the maximum memory on an "
-                              "active domain"));
+            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                           _("cannot resize the maximum memory on an "
+                             "active domain"));
             goto endjob;
         }
 
@@ -2019,8 +2019,8 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
         /* resize the current memory */
 
         if (newmem > vm->def->mem.max_balloon) {
-            qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                            _("cannot set memory higher than max memory"));
+            virReportError(VIR_ERR_INVALID_ARG, "%s",
+                           _("cannot set memory higher than max memory"));
             goto endjob;
         }
 
@@ -2036,9 +2036,9 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
 
             /* Lack of balloon support is a fatal error */
             if (r == 0) {
-                qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                                _("Unable to change memory of active domain without "
-                                  "the balloon device and guest OS balloon driver"));
+                virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                               _("Unable to change memory of active domain without "
+                                 "the balloon device and guest OS balloon driver"));
                 goto endjob;
             }
         }
@@ -2086,14 +2086,14 @@ static int qemuDomainInjectNMI(virDomainPtr domain, unsigned int flags)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
@@ -2103,8 +2103,8 @@ static int qemuDomainInjectNMI(virDomainPtr domain, unsigned int flags)
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -2148,10 +2148,10 @@ static int qemuDomainSendKey(virDomainPtr domain,
             keycode = virKeycodeValueTranslate(codeset, VIR_KEYCODE_SET_RFB,
                                                keycodes[i]);
             if (keycode < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-             _("cannot translate keycode %u of %s codeset to rfb keycode"),
-                                keycodes[i],
-                                virKeycodeSetTypeToString(codeset));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot translate keycode %u of %s codeset to rfb keycode"),
+                               keycodes[i],
+                               virKeycodeSetTypeToString(codeset));
                 return -1;
             }
             keycodes[i] = keycode;
@@ -2163,8 +2163,8 @@ static int qemuDomainSendKey(virDomainPtr domain,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -2174,8 +2174,8 @@ static int qemuDomainSendKey(virDomainPtr domain,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -2209,8 +2209,8 @@ static int qemudDomainGetInfo(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -2220,8 +2220,8 @@ static int qemudDomainGetInfo(virDomainPtr dom,
         info->cpuTime = 0;
     } else {
         if (qemudGetProcessInfo(&(info->cpuTime), NULL, NULL, vm->pid, 0) < 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("cannot read cputime for domain"));
+            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                           _("cannot read cputime for domain"));
             goto cleanup;
         }
     }
@@ -2298,8 +2298,8 @@ qemuDomainGetState(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -2331,14 +2331,14 @@ qemuDomainGetControlInfo(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
@@ -2431,16 +2431,16 @@ qemuDomainSaveHeader(int fd, const char *path, char *xml,
 
     if (safewrite(fd, header, sizeof(*header)) != sizeof(*header)) {
         ret = -errno;
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to write header to domain save file '%s'"),
-                        path);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to write header to domain save file '%s'"),
+                       path);
         goto endjob;
     }
 
     if (safewrite(fd, xml, header->xml_len) != header->xml_len) {
         ret = -errno;
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                         _("failed to write xml to '%s'"), path);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to write xml to '%s'"), path);
         goto endjob;
     }
 endjob:
@@ -2599,8 +2599,8 @@ qemuDomainSaveInternal(struct qemud_driver *driver, virDomainPtr dom,
     unsigned int wrapperFlags = VIR_FILE_WRAPPER_NON_BLOCKING;
 
     if (qemuProcessAutoDestroyActive(driver, vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is marked for auto destroy"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is marked for auto destroy"));
         goto cleanup;
     }
 
@@ -2627,8 +2627,8 @@ qemuDomainSaveInternal(struct qemud_driver *driver, virDomainPtr dom,
             goto endjob;
 
         if (!virDomainObjIsActive(vm)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("guest unexpectedly quit"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("guest unexpectedly quit"));
             goto endjob;
         }
     }
@@ -2659,8 +2659,8 @@ qemuDomainSaveInternal(struct qemud_driver *driver, virDomainPtr dom,
         xml = qemuDomainDefFormatLive(driver, vm->def, true, true);
     }
     if (!xml) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("failed to get domain xml"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("failed to get domain xml"));
         goto endjob;
     }
     len = strlen(xml) + 1;
@@ -2689,8 +2689,8 @@ qemuDomainSaveInternal(struct qemud_driver *driver, virDomainPtr dom,
         wrapperFlags |= VIR_FILE_WRAPPER_BYPASS_CACHE;
         directFlag = virFileDirectFdFlag();
         if (directFlag < 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("bypass cache unsupported by this system"));
+            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                           _("bypass cache unsupported by this system"));
             goto cleanup;
         }
     }
@@ -2818,15 +2818,15 @@ qemuDomainSaveFlags(virDomainPtr dom, const char *path, const char *dxml,
     else {
         compressed = qemudSaveCompressionTypeFromString(driver->saveImageFormat);
         if (compressed < 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            "%s", _("Invalid save image format specified "
-                                    "in configuration file"));
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           "%s", _("Invalid save image format specified "
+                                   "in configuration file"));
             goto cleanup;
         }
         if (!qemudCompressProgramAvailable(compressed)) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            "%s", _("Compression program for image format "
-                                    "in configuration file isn't available"));
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           "%s", _("Compression program for image format "
+                                   "in configuration file isn't available"));
             goto cleanup;
         }
     }
@@ -2835,14 +2835,14 @@ qemuDomainSaveFlags(virDomainPtr dom, const char *path, const char *dxml,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
@@ -2894,19 +2894,19 @@ qemuDomainManagedSave(virDomainPtr dom, unsigned int flags)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
     if (!vm->persistent) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("cannot do managed save for transient domain"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("cannot do managed save for transient domain"));
         goto cleanup;
     }
 
@@ -2967,8 +2967,8 @@ qemuDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -2996,8 +2996,8 @@ qemuDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -3023,8 +3023,8 @@ static int qemuDumpToFd(struct qemud_driver *driver, virDomainObjPtr vm,
     int ret = -1;
 
     if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DUMP_GUEST_MEMORY)) {
-        qemuReportError(VIR_ERR_NO_SUPPORT, "%s",
-                        _("dump-guest-memory is not supported"));
+        virReportError(VIR_ERR_NO_SUPPORT, "%s",
+                       _("dump-guest-memory is not supported"));
         return -1;
     }
 
@@ -3061,8 +3061,8 @@ doCoreDump(struct qemud_driver *driver,
         flags |= VIR_FILE_WRAPPER_BYPASS_CACHE;
         directFlag = virFileDirectFdFlag();
         if (directFlag < 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("bypass cache unsupported by this system"));
+            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                           _("bypass cache unsupported by this system"));
             goto cleanup;
         }
     }
@@ -3157,8 +3157,8 @@ static int qemudDomainCoreDump(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -3167,8 +3167,8 @@ static int qemudDomainCoreDump(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -3185,8 +3185,8 @@ static int qemudDomainCoreDump(virDomainPtr dom,
         paused = 1;
 
         if (!virDomainObjIsActive(vm)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("guest unexpectedly quit"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("guest unexpectedly quit"));
             goto endjob;
         }
     }
@@ -3222,8 +3222,8 @@ endjob:
                                            VIR_DOMAIN_RUNNING_UNPAUSED,
                                            QEMU_ASYNC_JOB_DUMP) < 0) {
             if (virGetLastError() == NULL)
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                "%s", _("resuming after dump failed"));
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               "%s", _("resuming after dump failed"));
         }
     }
 
@@ -3266,8 +3266,8 @@ qemuDomainScreenshot(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -3277,17 +3277,17 @@ qemuDomainScreenshot(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
     /* Well, even if qemu allows multiple graphic cards, heads, whatever,
      * screenshot command does not */
     if (screen) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        "%s", _("currently is supported only taking "
-                                "screenshots of screen ID 0"));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       "%s", _("currently is supported only taking "
+                               "screenshots of screen ID 0"));
         goto endjob;
     }
 
@@ -3317,8 +3317,8 @@ qemuDomainScreenshot(virDomainPtr dom,
     }
 
     if (virFDStreamOpenFile(st, tmp, 0, 0, O_RDONLY) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("unable to open stream"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("unable to open stream"));
         goto endjob;
     }
 
@@ -3369,8 +3369,8 @@ static void processWatchdogEvent(void *data, void *opaque)
             }
 
             if (!virDomainObjIsActive(wdEvent->vm)) {
-                qemuReportError(VIR_ERR_OPERATION_INVALID,
-                                "%s", _("domain is not running"));
+                virReportError(VIR_ERR_OPERATION_INVALID,
+                               "%s", _("domain is not running"));
                 VIR_FREE(dumpfile);
                 goto endjob;
             }
@@ -3379,16 +3379,16 @@ static void processWatchdogEvent(void *data, void *opaque)
             ret = doCoreDump(driver, wdEvent->vm, dumpfile,
                              getCompressionType(driver), flags);
             if (ret < 0)
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                "%s", _("Dump failed"));
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               "%s", _("Dump failed"));
 
             ret = qemuProcessStartCPUs(driver, wdEvent->vm, NULL,
                                        VIR_DOMAIN_RUNNING_UNPAUSED,
                                        QEMU_ASYNC_JOB_DUMP);
 
             if (ret < 0)
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                "%s", _("Resuming after dump failed"));
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               "%s", _("Resuming after dump failed"));
 
             VIR_FREE(dumpfile);
         }
@@ -3466,10 +3466,10 @@ static int qemudDomainHotplugVcpus(struct qemud_driver *driver,
     }
 
     if (ncpupids != vcpus) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("got wrong number of vCPU pids from QEMU monitor. "
-                          "got %d, wanted %d"),
-                        ncpupids, vcpus);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("got wrong number of vCPU pids from QEMU monitor. "
+                         "got %d, wanted %d"),
+                       ncpupids, vcpus);
         ret = -1;
         goto cleanup;
     }
@@ -3487,8 +3487,8 @@ cleanup:
     return ret;
 
 unsupported:
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("cannot change vcpu count of this domain"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("cannot change vcpu count of this domain"));
     goto cleanup;
 }
 
@@ -3510,8 +3510,8 @@ qemuDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
                   VIR_DOMAIN_VCPU_MAXIMUM, -1);
 
     if (!nvcpus || (unsigned short) nvcpus != nvcpus) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("argument out of range: %d"), nvcpus);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("argument out of range: %d"), nvcpus);
         return -1;
     }
 
@@ -3522,8 +3522,8 @@ qemuDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -3539,21 +3539,21 @@ qemuDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
 
     /* MAXIMUM cannot be mixed with LIVE.  */
     if (maximum && (flags & VIR_DOMAIN_AFFECT_LIVE)) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("cannot adjust maximum on running domain"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("cannot adjust maximum on running domain"));
         goto endjob;
     }
 
     if (!(type = virDomainVirtTypeToString(vm->def->virtType))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unknown virt type in domain definition '%d'"),
-                        vm->def->virtType);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unknown virt type in domain definition '%d'"),
+                       vm->def->virtType);
         goto endjob;
     }
 
     if ((max = qemudGetMaxVCPUs(NULL, type)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("could not determine max vcpus for the domain"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("could not determine max vcpus for the domain"));
         goto endjob;
     }
 
@@ -3562,9 +3562,9 @@ qemuDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
     }
 
     if (nvcpus > max) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("requested vcpus is greater than max allowable"
-                          " vcpus for the domain: %d > %d"), nvcpus, max);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("requested vcpus is greater than max allowable"
+                         " vcpus for the domain: %d > %d"), nvcpus, max);
         goto endjob;
     }
 
@@ -3632,8 +3632,8 @@ qemudDomainPinVcpuFlags(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -3644,9 +3644,9 @@ qemudDomainPinVcpuFlags(virDomainPtr dom,
     priv = vm->privateData;
 
     if (vcpu > (priv->nvcpupids-1)) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("vcpu number out of range %d > %d"),
-                        vcpu, priv->nvcpupids);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("vcpu number out of range %d > %d"),
+                       vcpu, priv->nvcpupids);
         goto cleanup;
     }
 
@@ -3673,23 +3673,23 @@ qemudDomainPinVcpuFlags(virDomainPtr dom,
                                           cpumap, maplen, maxcpu) < 0)
                 goto cleanup;
         } else {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("cpu affinity is not supported"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("cpu affinity is not supported"));
             goto cleanup;
         }
 
         if (canResetting) {
             if (virDomainVcpuPinDel(vm->def, vcpu) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("failed to delete vcpupin xml of "
-                                  "a running domain"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("failed to delete vcpupin xml of "
+                                 "a running domain"));
                 goto cleanup;
             }
         } else {
             if (virDomainVcpuPinAdd(vm->def, cpumap, maplen, vcpu) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("failed to update or add vcpupin xml of "
-                                  "a running domain"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("failed to update or add vcpupin xml of "
+                                 "a running domain"));
                 goto cleanup;
             }
         }
@@ -3702,16 +3702,16 @@ qemudDomainPinVcpuFlags(virDomainPtr dom,
 
         if (canResetting) {
             if (virDomainVcpuPinDel(persistentDef, vcpu) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("failed to delete vcpupin xml of "
-                                  "a persistent domain"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("failed to delete vcpupin xml of "
+                                 "a persistent domain"));
                 goto cleanup;
             }
         } else {
             if (virDomainVcpuPinAdd(persistentDef, cpumap, maplen, vcpu) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("failed to update or add vcpupin xml of "
-                                  "a persistent domain"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("failed to update or add vcpupin xml of "
+                                 "a persistent domain"));
                 goto cleanup;
             }
         }
@@ -3765,8 +3765,8 @@ qemudDomainGetVcpuPinInfo(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -3844,15 +3844,15 @@ qemudDomainGetVcpus(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s",
-                        _("cannot list vcpu pinning for an inactive domain"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s",
+                       _("cannot list vcpu pinning for an inactive domain"));
         goto cleanup;
     }
 
@@ -3901,8 +3901,8 @@ qemudDomainGetVcpus(virDomainPtr dom,
                         goto cleanup;
                 }
             } else {
-                qemuReportError(VIR_ERR_OPERATION_INVALID,
-                                "%s", _("cpu affinity is not available"));
+                virReportError(VIR_ERR_OPERATION_INVALID,
+                               "%s", _("cpu affinity is not available"));
                 goto cleanup;
             }
         }
@@ -3935,8 +3935,8 @@ qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -3976,15 +3976,15 @@ static int qemudDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr sec
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainVirtTypeToString(vm->def->virtType)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unknown virt type in domain definition '%d'"),
-                        vm->def->virtType);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unknown virt type in domain definition '%d'"),
+                       vm->def->virtType);
         goto cleanup;
     }
 
@@ -4005,8 +4005,8 @@ static int qemudDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr sec
     if (virDomainObjIsActive(vm)) {
         if (virSecurityManagerGetProcessLabel(driver->securityManager,
                                               vm->def, vm->pid, seclabel) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("Failed to get security label"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("Failed to get security label"));
             goto cleanup;
         }
     }
@@ -4037,9 +4037,9 @@ static int qemudNodeGetSecurityModel(virConnectPtr conn,
 
     p = driver->caps->host.secModel.model;
     if (strlen(p) >= VIR_SECURITY_MODEL_BUFLEN-1) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("security model string exceeds max %d bytes"),
-                        VIR_SECURITY_MODEL_BUFLEN-1);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("security model string exceeds max %d bytes"),
+                       VIR_SECURITY_MODEL_BUFLEN-1);
         ret = -1;
         goto cleanup;
     }
@@ -4047,9 +4047,9 @@ static int qemudNodeGetSecurityModel(virConnectPtr conn,
 
     p = driver->caps->host.secModel.doi;
     if (strlen(p) >= VIR_SECURITY_DOI_BUFLEN-1) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("security DOI string exceeds max %d bytes"),
-                        VIR_SECURITY_DOI_BUFLEN-1);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("security DOI string exceeds max %d bytes"),
+                       VIR_SECURITY_DOI_BUFLEN-1);
         ret = -1;
         goto cleanup;
     }
@@ -4083,8 +4083,8 @@ qemuDomainSaveImageOpen(struct qemud_driver *driver,
     if (bypass_cache) {
         int directFlag = virFileDirectFdFlag();
         if (directFlag < 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("bypass cache unsupported by this system"));
+            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                           _("bypass cache unsupported by this system"));
             goto error;
         }
         oflags |= directFlag;
@@ -4107,8 +4107,8 @@ qemuDomainSaveImageOpen(struct qemud_driver *driver,
             }
             return -3;
         }
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("failed to read qemu header"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("failed to read qemu header"));
         goto error;
     }
 
@@ -4128,7 +4128,7 @@ qemuDomainSaveImageOpen(struct qemud_driver *driver,
                 return -3;
             }
         }
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", msg);
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s", msg);
         goto error;
     }
 
@@ -4138,15 +4138,15 @@ qemuDomainSaveImageOpen(struct qemud_driver *driver,
     }
 
     if (header.version > QEMUD_SAVE_VERSION) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("image version is not supported (%d > %d)"),
-                        header.version, QEMUD_SAVE_VERSION);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("image version is not supported (%d > %d)"),
+                       header.version, QEMUD_SAVE_VERSION);
         goto error;
     }
 
     if (header.xml_len <= 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("invalid XML length: %d"), header.xml_len);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("invalid XML length: %d"), header.xml_len);
         goto error;
     }
 
@@ -4156,8 +4156,8 @@ qemuDomainSaveImageOpen(struct qemud_driver *driver,
     }
 
     if (saferead(fd, xml, header.xml_len) != header.xml_len) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("failed to read XML"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("failed to read XML"));
         goto error;
     }
 
@@ -4225,9 +4225,9 @@ qemuDomainSaveImageStartVM(virConnectPtr conn,
     if (header->version == 2) {
         const char *prog = qemudSaveCompressionTypeToString(header->compressed);
         if (prog == NULL) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("Invalid compressed save format %d"),
-                            header->compressed);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("Invalid compressed save format %d"),
+                           header->compressed);
             goto out;
         }
 
@@ -4240,9 +4240,9 @@ qemuDomainSaveImageStartVM(virConnectPtr conn,
             virCommandSetOutputFD(cmd, fd);
 
             if (virCommandRunAsync(cmd, NULL) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("Failed to start decompression binary %s"),
-                                prog);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Failed to start decompression binary %s"),
+                               prog);
                 *fd = intermediatefd;
                 goto out;
             }
@@ -4293,8 +4293,8 @@ qemuDomainSaveImageStartVM(virConnectPtr conn,
                                  VIR_DOMAIN_RUNNING_RESTORED,
                                  QEMU_ASYNC_JOB_NONE) < 0) {
             if (virGetLastError() == NULL)
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                "%s", _("failed to resume domain"));
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               "%s", _("failed to resume domain"));
             goto out;
         }
         if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0) {
@@ -4469,8 +4469,8 @@ qemuDomainSaveImageDefineXML(virConnectPtr conn, const char *path,
     len = strlen(xml) + 1;
 
     if (len > header.xml_len) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("new xml too large to fit in file"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("new xml too large to fit in file"));
         goto cleanup;
     }
     if (VIR_EXPAND_N(xml, len, header.xml_len - len) < 0) {
@@ -4530,11 +4530,11 @@ qemuDomainObjRestore(virConnectPtr conn,
         char def_uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(vm->def->uuid, vm_uuidstr);
         virUUIDFormat(def->uuid, def_uuidstr);
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot restore domain '%s' uuid %s from a file"
-                          " which belongs to domain '%s' uuid %s"),
-                        vm->def->name, vm_uuidstr,
-                        def->name, def_uuidstr);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot restore domain '%s' uuid %s from a file"
+                         " which belongs to domain '%s' uuid %s"),
+                       vm->def->name, vm_uuidstr,
+                       def->name, def_uuidstr);
         goto cleanup;
     }
 
@@ -4572,8 +4572,8 @@ static char *qemuDomainGetXMLDesc(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -4591,8 +4591,8 @@ static char *qemuDomainGetXMLDesc(virDomainPtr dom,
                 goto cleanup;
 
             if (!virDomainObjIsActive(vm)) {
-                qemuReportError(VIR_ERR_OPERATION_INVALID,
-                                "%s", _("domain is not running"));
+                virReportError(VIR_ERR_OPERATION_INVALID,
+                               "%s", _("domain is not running"));
                 goto endjob;
             }
 
@@ -4635,8 +4635,8 @@ static char *qemuDomainXMLFromNative(virConnectPtr conn,
     virCheckFlags(0, NULL);
 
     if (STRNEQ(format, QEMU_CONFIG_FORMAT_ARGV)) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("unsupported config type %s"), format);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("unsupported config type %s"), format);
         goto cleanup;
     }
 
@@ -4679,8 +4679,8 @@ static char *qemuDomainXMLToNative(virConnectPtr conn,
     qemuDriverLock(driver);
 
     if (STRNEQ(format, QEMU_CONFIG_FORMAT_ARGV)) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("unsupported config type %s"), format);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("unsupported config type %s"), format);
         goto cleanup;
     }
 
@@ -4910,8 +4910,8 @@ qemuDomainStartWithFlags(virDomainPtr dom, unsigned int flags)
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -4919,8 +4919,8 @@ qemuDomainStartWithFlags(virDomainPtr dom, unsigned int flags)
         goto cleanup;
 
     if (virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is already running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is already running"));
         goto endjob;
     }
 
@@ -5135,24 +5135,24 @@ qemuDomainUndefineFlags(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!vm->persistent) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("cannot undefine transient domain"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("cannot undefine transient domain"));
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm) &&
         (nsnapshots = virDomainSnapshotObjListNum(&vm->snapshots, NULL, 0))) {
         if (!(flags & VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("cannot delete inactive domain with %d "
-                              "snapshots"),
-                            nsnapshots);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("cannot delete inactive domain with %d "
+                             "snapshots"),
+                           nsnapshots);
             goto cleanup;
         }
         if (qemuDomainSnapshotDiscardAllMetadata(driver, vm) < 0)
@@ -5166,15 +5166,15 @@ qemuDomainUndefineFlags(virDomainPtr dom,
     if (virFileExists(name)) {
         if (flags & VIR_DOMAIN_UNDEFINE_MANAGED_SAVE) {
             if (unlink(name) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("Failed to remove domain managed "
-                                  "save image"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("Failed to remove domain managed "
+                                 "save image"));
                 goto cleanup;
             }
         } else {
-            qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                            _("Refusing to undefine while domain managed "
-                              "save image exists"));
+            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                           _("Refusing to undefine while domain managed "
+                             "save image exists"));
             goto cleanup;
         }
     }
@@ -5228,17 +5228,17 @@ qemuDomainAttachDeviceDiskLive(virConnectPtr conn,
     int ret = -1;
 
     if (disk->driverName != NULL && !STREQ(disk->driverName, "qemu")) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("unsupported driver name '%s' for disk '%s'"),
-                        disk->driverName, disk->src);
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("unsupported driver name '%s' for disk '%s'"),
+                       disk->driverName, disk->src);
         goto end;
     }
 
     if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unable to find cgroup for %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unable to find cgroup for %s"),
+                           vm->def->name);
             goto end;
         }
         if (qemuSetupDiskCgroup(driver, vm, cgroup, disk) < 0)
@@ -5253,8 +5253,8 @@ qemuDomainAttachDeviceDiskLive(virConnectPtr conn,
     case VIR_DOMAIN_DISK_DEVICE_LUN:
         if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
             if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("disk device='lun' is not supported for usb bus"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("disk device='lun' is not supported for usb bus"));
                 break;
             }
             ret = qemuDomainAttachUsbMassstorageDevice(conn, driver, vm,
@@ -5264,15 +5264,15 @@ qemuDomainAttachDeviceDiskLive(virConnectPtr conn,
         } else if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
             ret = qemuDomainAttachSCSIDisk(conn, driver, vm, disk);
         } else {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("disk bus '%s' cannot be hotplugged."),
-                            virDomainDiskBusTypeToString(disk->bus));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("disk bus '%s' cannot be hotplugged."),
+                           virDomainDiskBusTypeToString(disk->bus));
         }
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("disk device type '%s' cannot be hotplugged"),
-                        virDomainDiskDeviceTypeToString(disk->device));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("disk device type '%s' cannot be hotplugged"),
+                       virDomainDiskDeviceTypeToString(disk->device));
         break;
     }
 
@@ -5300,9 +5300,9 @@ qemuDomainAttachDeviceControllerLive(struct qemud_driver *driver,
         ret = qemuDomainAttachPciControllerDevice(driver, vm, cont);
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("disk controller bus '%s' cannot be hotplugged."),
-                        virDomainControllerTypeToString(cont->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("disk controller bus '%s' cannot be hotplugged."),
+                       virDomainControllerTypeToString(cont->type));
         break;
     }
     return ret;
@@ -5360,9 +5360,9 @@ qemuDomainAttachDeviceLive(virDomainObjPtr vm,
         break;
 
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("device type '%s' cannot be attached"),
-                        virDomainDeviceTypeToString(dev->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("device type '%s' cannot be attached"),
+                       virDomainDeviceTypeToString(dev->type));
         break;
     }
 
@@ -5387,13 +5387,13 @@ qemuDomainDetachDeviceDiskLive(struct qemud_driver *driver,
         else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB)
             ret = qemuDomainDetachDiskDevice(driver, vm, dev);
         else
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("This type of disk cannot be hot unplugged"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("This type of disk cannot be hot unplugged"));
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("disk device type '%s' cannot be detached"),
-                        virDomainDiskDeviceTypeToString(disk->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("disk device type '%s' cannot be detached"),
+                       virDomainDiskDeviceTypeToString(disk->type));
         break;
     }
     return ret;
@@ -5412,9 +5412,9 @@ qemuDomainDetachDeviceControllerLive(struct qemud_driver *driver,
         ret = qemuDomainDetachPciControllerDevice(driver, vm, dev);
         break;
     default :
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("disk controller bus '%s' cannot be hotunplugged."),
-                        virDomainControllerTypeToString(cont->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("disk controller bus '%s' cannot be hotunplugged."),
+                       virDomainControllerTypeToString(cont->type));
     }
     return ret;
 }
@@ -5444,8 +5444,8 @@ qemuDomainDetachDeviceLive(virDomainObjPtr vm,
         ret = qemuDomainDetachHostDevice(driver, vm, dev);
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        "%s", _("This type of device cannot be hot unplugged"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       "%s", _("This type of device cannot be hot unplugged"));
         break;
     }
 
@@ -5465,9 +5465,9 @@ qemuDomainChangeDiskMediaLive(virDomainObjPtr vm,
     if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
         if (virCgroupForDomain(driver->cgroup,
                                vm->def->name, &cgroup, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unable to find cgroup for %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unable to find cgroup for %s"),
+                           vm->def->name);
             goto end;
         }
         if (qemuSetupDiskCgroup(driver, vm, cgroup, disk) < 0)
@@ -5482,9 +5482,9 @@ qemuDomainChangeDiskMediaLive(virDomainObjPtr vm,
             dev->data.disk = NULL;
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("disk bus '%s' cannot be updated."),
-                        virDomainDiskBusTypeToString(disk->bus));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("disk bus '%s' cannot be updated."),
+                       virDomainDiskBusTypeToString(disk->bus));
         break;
     }
 
@@ -5519,9 +5519,9 @@ qemuDomainUpdateDeviceLive(virDomainObjPtr vm,
         ret = qemuDomainChangeNet(driver, vm, dom, dev->data.net);
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("device type '%s' cannot be updated"),
-                        virDomainDeviceTypeToString(dev->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("device type '%s' cannot be updated"),
+                       virDomainDeviceTypeToString(dev->type));
         break;
     }
 
@@ -5541,8 +5541,8 @@ qemuDomainAttachDeviceConfig(virDomainDefPtr vmdef,
     case VIR_DOMAIN_DEVICE_DISK:
         disk = dev->data.disk;
         if (virDomainDiskIndexByName(vmdef, disk->dst, true) >= 0) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("target %s already exists."), disk->dst);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("target %s already exists."), disk->dst);
             return -1;
         }
         if (virDomainDiskInsert(vmdef, disk)) {
@@ -5564,8 +5564,8 @@ qemuDomainAttachDeviceConfig(virDomainDefPtr vmdef,
             char macbuf[VIR_MAC_STRING_BUFLEN];
 
             virMacAddrFormat(&net->mac, macbuf);
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("mac %s already exists"), macbuf);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("mac %s already exists"), macbuf);
             return -1;
         }
         if (virDomainNetInsert(vmdef, net)) {
@@ -5580,8 +5580,8 @@ qemuDomainAttachDeviceConfig(virDomainDefPtr vmdef,
     case VIR_DOMAIN_DEVICE_HOSTDEV:
         hostdev = dev->data.hostdev;
         if (virDomainHostdevFind(vmdef, hostdev, NULL) >= 0) {
-            qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                            _("device is already in the domain configuration"));
+            virReportError(VIR_ERR_INVALID_ARG, "%s",
+                           _("device is already in the domain configuration"));
             return -1;
         }
         if (virDomainHostdevInsert(vmdef, hostdev)) {
@@ -5596,9 +5596,9 @@ qemuDomainAttachDeviceConfig(virDomainDefPtr vmdef,
     case VIR_DOMAIN_DEVICE_LEASE:
         lease = dev->data.lease;
         if (virDomainLeaseIndex(vmdef, lease) >= 0) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("Lease %s in lockspace %s already exists"),
-                            lease->key, NULLSTR(lease->lockspace));
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("Lease %s in lockspace %s already exists"),
+                           lease->key, NULLSTR(lease->lockspace));
             return -1;
         }
         if (virDomainLeaseInsert(vmdef, lease) < 0)
@@ -5609,8 +5609,8 @@ qemuDomainAttachDeviceConfig(virDomainDefPtr vmdef,
         break;
 
     default:
-         qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                         _("persistent attach of device is not supported"));
+         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                        _("persistent attach of device is not supported"));
          return -1;
     }
     return 0;
@@ -5630,8 +5630,8 @@ qemuDomainDetachDeviceConfig(virDomainDefPtr vmdef,
     case VIR_DOMAIN_DEVICE_DISK:
         disk = dev->data.disk;
         if (!(det_disk = virDomainDiskRemoveByName(vmdef, disk->dst))) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("no target device %s"), disk->dst);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("no target device %s"), disk->dst);
             return -1;
         }
         virDomainDiskDefFree(det_disk);
@@ -5643,8 +5643,8 @@ qemuDomainDetachDeviceConfig(virDomainDefPtr vmdef,
             char macbuf[VIR_MAC_STRING_BUFLEN];
 
             virMacAddrFormat(&net->mac, macbuf);
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("no nic of mac %s"), macbuf);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("no nic of mac %s"), macbuf);
             return -1;
         }
         virDomainNetDefFree(det_net);
@@ -5655,8 +5655,8 @@ qemuDomainDetachDeviceConfig(virDomainDefPtr vmdef,
 
         hostdev = dev->data.hostdev;
         if ((idx = virDomainHostdevFind(vmdef, hostdev, &det_hostdev)) < 0) {
-            qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                            _("device not present in domain configuration"));
+            virReportError(VIR_ERR_INVALID_ARG, "%s",
+                           _("device not present in domain configuration"));
             return -1;
         }
         virDomainHostdevRemove(vmdef, idx);
@@ -5667,17 +5667,17 @@ qemuDomainDetachDeviceConfig(virDomainDefPtr vmdef,
     case VIR_DOMAIN_DEVICE_LEASE:
         lease = dev->data.lease;
         if (!(det_lease = virDomainLeaseRemove(vmdef, lease))) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("Lease %s in lockspace %s does not exist"),
-                            lease->key, NULLSTR(lease->lockspace));
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("Lease %s in lockspace %s does not exist"),
+                           lease->key, NULLSTR(lease->lockspace));
             return -1;
         }
         virDomainLeaseDefFree(det_lease);
         break;
 
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("persistent detach of device is not supported"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("persistent detach of device is not supported"));
         return -1;
     }
     return 0;
@@ -5696,15 +5696,15 @@ qemuDomainUpdateDeviceConfig(virDomainDefPtr vmdef,
         disk = dev->data.disk;
         pos = virDomainDiskIndexByName(vmdef, disk->dst, false);
         if (pos < 0) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("target %s doesn't exist."), disk->dst);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("target %s doesn't exist."), disk->dst);
             return -1;
         }
         orig = vmdef->disks[pos];
         if (!(orig->device == VIR_DOMAIN_DISK_DEVICE_CDROM) &&
             !(orig->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("this disk doesn't support update"));
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("this disk doesn't support update"));
             return -1;
         }
         /*
@@ -5734,8 +5734,8 @@ qemuDomainUpdateDeviceConfig(virDomainDefPtr vmdef,
             char macbuf[VIR_MAC_STRING_BUFLEN];
 
             virMacAddrFormat(&net->mac, macbuf);
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("mac %s doesn't exist"), macbuf);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("mac %s doesn't exist"), macbuf);
             return -1;
         }
 
@@ -5749,8 +5749,8 @@ qemuDomainUpdateDeviceConfig(virDomainDefPtr vmdef,
         break;
 
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                         _("persistent update of device is not supported"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("persistent update of device is not supported"));
         return -1;
     }
     return 0;
@@ -5788,8 +5788,8 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -5804,17 +5804,17 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
             flags |= VIR_DOMAIN_AFFECT_CONFIG;
         /* check consistency between flags and the vm state */
         if (flags & VIR_DOMAIN_AFFECT_LIVE) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s",
-                            _("cannot do live update a device on "
-                              "inactive domain"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s",
+                           _("cannot do live update a device on "
+                             "inactive domain"));
             goto endjob;
         }
     }
 
     if ((flags & VIR_DOMAIN_AFFECT_CONFIG) && !vm->persistent) {
-         qemuReportError(VIR_ERR_OPERATION_INVALID,
-                         "%s", _("cannot modify device on transient domain"));
+         virReportError(VIR_ERR_OPERATION_INVALID,
+                        "%s", _("cannot modify device on transient domain"));
          goto endjob;
     }
 
@@ -5850,8 +5850,8 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
             ret = qemuDomainUpdateDeviceConfig(vmdef, dev);
             break;
         default:
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unknown domain modify action %d"), action);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unknown domain modify action %d"), action);
             break;
         }
 
@@ -5871,8 +5871,8 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
             ret = qemuDomainUpdateDeviceLive(vm, dev_copy, dom, force);
             break;
         default:
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unknown domain modify action %d"), action);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unknown domain modify action %d"), action);
             ret = -1;
             break;
         }
@@ -5959,8 +5959,8 @@ static int qemudDomainGetAutostart(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -5986,14 +5986,14 @@ static int qemudDomainSetAutostart(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!vm->persistent) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("cannot set autostart for transient domain"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("cannot set autostart for transient domain"));
         goto cleanup;
     }
 
@@ -6084,8 +6084,8 @@ static char *qemuGetSchedulerType(virDomainPtr dom,
 
     qemuDriverLock(driver);
     if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("cgroup CPU controller is not mounted"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("cgroup CPU controller is not mounted"));
         goto cleanup;
     }
 
@@ -6188,8 +6188,8 @@ qemuDomainParseDeviceWeightStr(char *deviceWeightStr,
     return 0;
 
 error:
-    qemuReportError(VIR_ERR_INVALID_ARG,
-                    _("unable to parse device weight '%s'"), deviceWeightStr);
+    virReportError(VIR_ERR_INVALID_ARG,
+                   _("unable to parse device weight '%s'"), deviceWeightStr);
 cleanup:
     virBlkioDeviceWeightArrayClear(result, ndevices);
     VIR_FREE(result);
@@ -6263,8 +6263,8 @@ qemuDomainSetBlkioParameters(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -6274,15 +6274,15 @@ qemuDomainSetBlkioParameters(virDomainPtr dom,
 
     if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_BLKIO)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("blkio cgroup isn't mounted"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("blkio cgroup isn't mounted"));
             goto cleanup;
         }
 
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find cgroup for domain %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find cgroup for domain %s"),
+                           vm->def->name);
             goto cleanup;
         }
     }
@@ -6295,8 +6295,8 @@ qemuDomainSetBlkioParameters(virDomainPtr dom,
 
             if (STREQ(param->field, VIR_DOMAIN_BLKIO_WEIGHT)) {
                 if (params[i].value.ui > 1000 || params[i].value.ui < 100) {
-                    qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                                    _("out of blkio weight range."));
+                    virReportError(VIR_ERR_INVALID_ARG, "%s",
+                                   _("out of blkio weight range."));
                     ret = -1;
                     continue;
                 }
@@ -6351,8 +6351,8 @@ qemuDomainSetBlkioParameters(virDomainPtr dom,
 
             if (STREQ(param->field, VIR_DOMAIN_BLKIO_WEIGHT)) {
                 if (params[i].value.ui > 1000 || params[i].value.ui < 100) {
-                    qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                                    _("out of blkio weight range."));
+                    virReportError(VIR_ERR_INVALID_ARG, "%s",
+                                   _("out of blkio weight range."));
                     ret = -1;
                     continue;
                 }
@@ -6417,8 +6417,8 @@ qemuDomainGetBlkioParameters(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -6435,13 +6435,13 @@ qemuDomainGetBlkioParameters(virDomainPtr dom,
 
     if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_BLKIO)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID, _("blkio cgroup isn't mounted"));
+            virReportError(VIR_ERR_OPERATION_INVALID, _("blkio cgroup isn't mounted"));
             goto cleanup;
         }
 
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find cgroup for domain %s"), vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find cgroup for domain %s"), vm->def->name);
             goto cleanup;
         }
     }
@@ -6507,9 +6507,9 @@ qemuDomainGetBlkioParameters(virDomainPtr dom,
             switch (i) {
             case 0: /* fill blkio weight here */
                 if (virStrcpyStatic(param->field, VIR_DOMAIN_BLKIO_WEIGHT) == NULL) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("Field name '%s' too long"),
-                                    VIR_DOMAIN_BLKIO_WEIGHT);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("Field name '%s' too long"),
+                                   VIR_DOMAIN_BLKIO_WEIGHT);
                     goto cleanup;
                 }
                 param->value.ui = persistentDef->blkio.weight;
@@ -6547,9 +6547,9 @@ qemuDomainGetBlkioParameters(virDomainPtr dom,
                 param->type = VIR_TYPED_PARAM_STRING;
                 if (virStrcpyStatic(param->field,
                                     VIR_DOMAIN_BLKIO_DEVICE_WEIGHT) == NULL) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("Field name '%s' too long"),
-                                    VIR_DOMAIN_BLKIO_DEVICE_WEIGHT);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("Field name '%s' too long"),
+                                   VIR_DOMAIN_BLKIO_DEVICE_WEIGHT);
                     goto cleanup;
                 }
                 break;
@@ -6605,8 +6605,8 @@ qemuDomainSetMemoryParameters(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -6616,14 +6616,14 @@ qemuDomainSetMemoryParameters(virDomainPtr dom,
 
     if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_MEMORY)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("cgroup memory controller is not mounted"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("cgroup memory controller is not mounted"));
             goto cleanup;
         }
 
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find cgroup for domain %s"), vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find cgroup for domain %s"), vm->def->name);
             goto cleanup;
         }
     }
@@ -6712,8 +6712,8 @@ qemuDomainGetMemoryParameters(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -6723,14 +6723,14 @@ qemuDomainGetMemoryParameters(virDomainPtr dom,
 
     if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_MEMORY)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("cgroup memory controller is not mounted"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("cgroup memory controller is not mounted"));
             goto cleanup;
         }
 
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find cgroup for domain %s"), vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find cgroup for domain %s"), vm->def->name);
             goto cleanup;
         }
     }
@@ -6874,8 +6874,8 @@ qemuDomainSetNumaParameters(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -6885,15 +6885,15 @@ qemuDomainSetNumaParameters(virDomainPtr dom,
 
     if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUSET)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("cgroup cpuset controller is not mounted"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("cgroup cpuset controller is not mounted"));
             goto cleanup;
         }
 
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find cgroup for domain %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find cgroup for domain %s"),
+                           vm->def->name);
             goto cleanup;
         }
     }
@@ -6905,8 +6905,8 @@ qemuDomainSetNumaParameters(virDomainPtr dom,
         if (STREQ(param->field, VIR_DOMAIN_NUMA_MODE)) {
             if ((flags & VIR_DOMAIN_AFFECT_LIVE) &&
                 vm->def->numatune.memory.mode != params[i].value.i) {
-                qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                                _("can't change numa mode for running domain"));
+                virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                               _("can't change numa mode for running domain"));
                 ret = -1;
                 goto cleanup;
             }
@@ -6922,9 +6922,9 @@ qemuDomainSetNumaParameters(virDomainPtr dom,
             if (flags & VIR_DOMAIN_AFFECT_LIVE) {
                 if (vm->def->numatune.memory.mode !=
                     VIR_DOMAIN_NUMATUNE_MEM_STRICT) {
-                    qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                                    _("change of nodeset for running domain "
-                                      "requires strict numa mode"));
+                    virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                                   _("change of nodeset for running domain "
+                                     "requires strict numa mode"));
                     ret = -1;
                     continue;
                 }
@@ -7037,8 +7037,8 @@ qemuDomainGetNumaParameters(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -7054,15 +7054,15 @@ qemuDomainGetNumaParameters(virDomainPtr dom,
 
     if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_MEMORY)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("cgroup memory controller is not mounted"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("cgroup memory controller is not mounted"));
             goto cleanup;
         }
 
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find cgroup for domain %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find cgroup for domain %s"),
+                           vm->def->name);
             goto cleanup;
         }
     }
@@ -7261,8 +7261,8 @@ qemuSetSchedulerParametersFlags(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -7279,14 +7279,14 @@ qemuSetSchedulerParametersFlags(virDomainPtr dom,
 
     if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("cgroup CPU controller is not mounted"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("cgroup CPU controller is not mounted"));
             goto cleanup;
         }
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find cgroup for domain %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find cgroup for domain %s"),
+                           vm->def->name);
             goto cleanup;
         }
     }
@@ -7475,8 +7475,8 @@ qemuGetSchedulerParametersFlags(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -7494,14 +7494,14 @@ qemuGetSchedulerParametersFlags(virDomainPtr dom,
     }
 
     if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("cgroup CPU controller is not mounted"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("cgroup CPU controller is not mounted"));
         goto cleanup;
     }
 
     if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot find cgroup for domain %s"), vm->def->name);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot find cgroup for domain %s"), vm->def->name);
         goto cleanup;
     }
 
@@ -7584,17 +7584,17 @@ qemuDomainBlockResize(virDomainPtr dom,
     virCheckFlags(VIR_DOMAIN_BLOCK_RESIZE_BYTES, -1);
 
     if (path[0] == '\0') {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        "%s", _("empty path"));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       "%s", _("empty path"));
         return -1;
     }
 
     /* We prefer operating on bytes.  */
     if ((flags & VIR_DOMAIN_BLOCK_RESIZE_BYTES) == 0) {
         if (size > ULLONG_MAX / 1024) {
-            qemuReportError(VIR_ERR_OVERFLOW,
-                            _("size must be less than %llu"),
-                            ULLONG_MAX / 1024);
+            virReportError(VIR_ERR_OVERFLOW,
+                           _("size must be less than %llu"),
+                           ULLONG_MAX / 1024);
             return -1;
         }
         size *= 1024;
@@ -7607,8 +7607,8 @@ qemuDomainBlockResize(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -7618,14 +7618,14 @@ qemuDomainBlockResize(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
     if ((i = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("invalid path: %s"), path);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("invalid path: %s"), path);
         goto endjob;
     }
     disk = vm->def->disks[i];
@@ -7677,27 +7677,27 @@ qemuDomainBlockStats(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
     if ((i = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("invalid path: %s"), path);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("invalid path: %s"), path);
         goto cleanup;
     }
     disk = vm->def->disks[i];
 
     if (!disk->info.alias) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("missing disk device alias name for %s"), disk->dst);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("missing disk device alias name for %s"), disk->dst);
         goto cleanup;
     }
 
@@ -7706,8 +7706,8 @@ qemuDomainBlockStats(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -7762,29 +7762,29 @@ qemuDomainBlockStatsFlags(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
     if (*nparams != 0) {
         if ((i = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("invalid path: %s"), path);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("invalid path: %s"), path);
             goto cleanup;
         }
         disk = vm->def->disks[i];
 
         if (!disk->info.alias) {
-             qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                             _("missing disk device alias name for %s"),
-                             disk->dst);
+             virReportError(VIR_ERR_INTERNAL_ERROR,
+                            _("missing disk device alias name for %s"),
+                            disk->dst);
              goto cleanup;
         }
     }
@@ -7796,8 +7796,8 @@ qemuDomainBlockStatsFlags(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -7931,14 +7931,14 @@ qemudDomainInterfaceStats (virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
@@ -7954,8 +7954,8 @@ qemudDomainInterfaceStats (virDomainPtr dom,
     if (ret == 0)
         ret = linuxDomainInterfaceStats(path, stats);
     else
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("invalid path, '%s' is not a known interface"), path);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("invalid path, '%s' is not a known interface"), path);
 
 cleanup:
     if (vm)
@@ -7968,8 +7968,8 @@ qemudDomainInterfaceStats (virDomainPtr dom,
                            const char *path ATTRIBUTE_UNUSED,
                            struct _virDomainInterfaceStats *stats ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                    _("interface stats not implemented on this platform"));
+    virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                   _("interface stats not implemented on this platform"));
     return -1;
 }
 #endif
@@ -8012,8 +8012,8 @@ qemuDomainSetInterfaceParameters(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -8024,16 +8024,16 @@ qemuDomainSetInterfaceParameters(virDomainPtr dom,
     if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         net = virDomainNetFind(vm->def, device);
         if (!net) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("Can't find device %s"), device);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("Can't find device %s"), device);
             goto cleanup;
         }
     }
     if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
         persistentNet = virDomainNetFind(persistentDef, device);
         if (!persistentNet) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("Can't find device %s"), device);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("Can't find device %s"), device);
             goto cleanup;
         }
     }
@@ -8106,9 +8106,9 @@ qemuDomainSetInterfaceParameters(virDomainPtr dom,
         }
 
         if (virNetDevBandwidthSet(net->ifname, newBandwidth) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot set bandwidth limits on %s"),
-                            device);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot set bandwidth limits on %s"),
+                           device);
             goto cleanup;
         }
 
@@ -8175,8 +8175,8 @@ qemuDomainGetInterfaceParameters(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
 
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), dom->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), dom->uuid);
         goto cleanup;
     }
 
@@ -8196,8 +8196,8 @@ qemuDomainGetInterfaceParameters(virDomainPtr dom,
 
     net = virDomainNetFind(def, device);
     if (!net) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("Can't find device %s"), device);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("Can't find device %s"), device);
         goto cleanup;
     }
 
@@ -8289,8 +8289,8 @@ qemudDomainMemoryStats (virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -8298,8 +8298,8 @@ qemudDomainMemoryStats (virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
     } else {
         qemuDomainObjPrivatePtr priv = vm->privateData;
         qemuDomainObjEnterMonitor(driver, vm);
@@ -8309,8 +8309,8 @@ qemudDomainMemoryStats (virDomainPtr dom,
         if (ret >= 0 && ret < nr_stats) {
             long rss;
             if (qemudGetProcessInfo(NULL, NULL, &rss, vm->pid, 0) < 0) {
-                qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("cannot get RSS for domain"));
+                virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                               _("cannot get RSS for domain"));
             } else {
                 stats[ret].tag = VIR_DOMAIN_MEMORY_STAT_RSS;
                 stats[ret].val = rss;
@@ -8350,21 +8350,21 @@ qemudDomainBlockPeek (virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!path || path[0] == '\0') {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        "%s", _("NULL or empty path"));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       "%s", _("NULL or empty path"));
         goto cleanup;
     }
 
     /* Check the path belongs to this domain.  */
     if (!(actual = virDomainDiskPathByName(vm->def, path))) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("invalid path '%s'"), path);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("invalid path '%s'"), path);
         goto cleanup;
     }
     path = actual;
@@ -8418,14 +8418,14 @@ qemudDomainMemoryPeek (virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (flags != VIR_MEMORY_VIRTUAL && flags != VIR_MEMORY_PHYSICAL) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        "%s", _("flags parameter must be VIR_MEMORY_VIRTUAL or VIR_MEMORY_PHYSICAL"));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       "%s", _("flags parameter must be VIR_MEMORY_VIRTUAL or VIR_MEMORY_PHYSICAL"));
         goto cleanup;
     }
 
@@ -8433,8 +8433,8 @@ qemudDomainMemoryPeek (virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -8515,28 +8515,28 @@ static int qemuDomainGetBlockInfo(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!path || path[0] == '\0') {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        "%s", _("NULL or empty path"));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       "%s", _("NULL or empty path"));
         goto cleanup;
     }
 
     /* Check the path belongs to this domain. */
     if ((i = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("invalid path %s not assigned to domain"), path);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("invalid path %s not assigned to domain"), path);
         goto cleanup;
     }
     disk = vm->def->disks[i];
     if (!disk->src) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("disk %s does not currently have a source assigned"),
-                        path);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("disk %s does not currently have a source assigned"),
+                       path);
         goto cleanup;
     }
     path = disk->src;
@@ -8552,9 +8552,9 @@ static int qemuDomainGetBlockInfo(virDomainPtr dom,
     /* Probe for magic formats */
     if (disk->driverType) {
         if ((format = virStorageFileFormatTypeFromString(disk->driverType)) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unknown disk format %s for %s"),
-                            disk->driverType, disk->src);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unknown disk format %s for %s"),
+                           disk->driverType, disk->src);
             goto cleanup;
         }
     } else {
@@ -8562,9 +8562,9 @@ static int qemuDomainGetBlockInfo(virDomainPtr dom,
             if ((format = virStorageFileProbeFormat(disk->src)) < 0)
                 goto cleanup;
         } else {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("no disk format for %s and probing is disabled"),
-                            disk->src);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("no disk format for %s and probing is disabled"),
+                           disk->src);
             goto cleanup;
         }
     }
@@ -8757,25 +8757,25 @@ qemudDomainMigratePrepareTunnel(virConnectPtr dconn,
     qemuDriverLock(driver);
 
     if (!dom_xml) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("no domain XML passed"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("no domain XML passed"));
         goto cleanup;
     }
     if (!(flags & VIR_MIGRATE_TUNNELLED)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                         "%s", _("PrepareTunnel called but no TUNNELLED flag set"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("PrepareTunnel called but no TUNNELLED flag set"));
         goto cleanup;
     }
     if (st == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("tunnelled migration requested but NULL stream passed"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("tunnelled migration requested but NULL stream passed"));
         goto cleanup;
     }
 
     if (virLockManagerPluginUsesState(driver->lockManager)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Cannot use migrate v2 protocol with lock manager %s"),
-                        virLockManagerPluginGetName(driver->lockManager));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Cannot use migrate v2 protocol with lock manager %s"),
+                       virLockManagerPluginGetName(driver->lockManager));
         goto cleanup;
     }
 
@@ -8813,9 +8813,9 @@ qemudDomainMigratePrepare2 (virConnectPtr dconn,
     qemuDriverLock(driver);
 
     if (virLockManagerPluginUsesState(driver->lockManager)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Cannot use migrate v2 protocol with lock manager %s"),
-                        virLockManagerPluginGetName(driver->lockManager));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Cannot use migrate v2 protocol with lock manager %s"),
+                       virLockManagerPluginGetName(driver->lockManager));
         goto cleanup;
     }
 
@@ -8823,14 +8823,14 @@ qemudDomainMigratePrepare2 (virConnectPtr dconn,
         /* this is a logical error; we never should have gotten here with
          * VIR_MIGRATE_TUNNELLED set
          */
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("Tunnelled migration requested but invalid RPC method called"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Tunnelled migration requested but invalid RPC method called"));
         goto cleanup;
     }
 
     if (!dom_xml) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("no domain XML passed"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("no domain XML passed"));
         goto cleanup;
     }
 
@@ -8868,9 +8868,9 @@ qemudDomainMigratePerform (virDomainPtr dom,
 
     qemuDriverLock(driver);
     if (virLockManagerPluginUsesState(driver->lockManager)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Cannot use migrate v2 protocol with lock manager %s"),
-                        virLockManagerPluginGetName(driver->lockManager));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Cannot use migrate v2 protocol with lock manager %s"),
+                       virLockManagerPluginGetName(driver->lockManager));
         goto cleanup;
     }
 
@@ -8878,8 +8878,8 @@ qemudDomainMigratePerform (virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -8924,8 +8924,8 @@ qemudDomainMigrateFinish2 (virConnectPtr dconn,
     qemuDriverLock(driver);
     vm = virDomainFindByName(&driver->domains, dname);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching name '%s'"), dname);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching name '%s'"), dname);
         goto cleanup;
     }
 
@@ -8968,8 +8968,8 @@ qemuDomainMigrateBegin3(virDomainPtr domain,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -8984,8 +8984,8 @@ qemuDomainMigrateBegin3(virDomainPtr domain,
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -9011,8 +9011,8 @@ qemuDomainMigrateBegin3(virDomainPtr domain,
             goto endjob;
         if (qemuMigrationJobContinue(vm) == 0) {
             vm = NULL;
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            "%s", _("domain disappeared"));
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           "%s", _("domain disappeared"));
             VIR_FREE(xml);
             if (cookieout)
                 VIR_FREE(*cookieout);
@@ -9063,14 +9063,14 @@ qemuDomainMigratePrepare3(virConnectPtr dconn,
         /* this is a logical error; we never should have gotten here with
          * VIR_MIGRATE_TUNNELLED set
          */
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("Tunnelled migration requested but invalid RPC method called"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Tunnelled migration requested but invalid RPC method called"));
         goto cleanup;
     }
 
     if (!dom_xml) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("no domain XML passed"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("no domain XML passed"));
         goto cleanup;
     }
 
@@ -9104,18 +9104,18 @@ qemuDomainMigratePrepareTunnel3(virConnectPtr dconn,
     virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
 
     if (!dom_xml) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("no domain XML passed"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("no domain XML passed"));
         goto cleanup;
     }
     if (!(flags & VIR_MIGRATE_TUNNELLED)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                         "%s", _("PrepareTunnel called but no TUNNELLED flag set"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("PrepareTunnel called but no TUNNELLED flag set"));
         goto cleanup;
     }
     if (st == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("tunnelled migration requested but NULL stream passed"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("tunnelled migration requested but NULL stream passed"));
         goto cleanup;
     }
 
@@ -9155,8 +9155,8 @@ qemuDomainMigratePerform3(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -9192,8 +9192,8 @@ qemuDomainMigrateFinish3(virConnectPtr dconn,
     qemuDriverLock(driver);
     vm = virDomainFindByName(&driver->domains, dname);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching name '%s'"), dname);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching name '%s'"), dname);
         goto cleanup;
     }
 
@@ -9226,8 +9226,8 @@ qemuDomainMigrateConfirm3(virDomainPtr domain,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -9298,8 +9298,8 @@ qemudNodeDeviceGetPciInfo (virNodeDevicePtr dev,
     }
 
     if (!cap) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("device %s is not a PCI device"), dev->name);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("device %s is not a PCI device"), dev->name);
         goto out;
     }
 
@@ -9362,13 +9362,13 @@ qemudNodeDeviceReAttach (virNodeDevicePtr dev)
         const char *other_name = pciDeviceGetUsedBy(other);
 
         if (other_name)
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("PCI device %s is still in use by domain %s"),
-                            pciDeviceGetName(pci), other_name);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("PCI device %s is still in use by domain %s"),
+                           pciDeviceGetName(pci), other_name);
         else
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("PCI device %s is still in use"),
-                            pciDeviceGetName(pci));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("PCI device %s is still in use"),
+                           pciDeviceGetName(pci));
     }
 
     pciDeviceReAttachInit(pci);
@@ -9426,8 +9426,8 @@ qemuCPUCompare(virConnectPtr conn,
     qemuDriverLock(driver);
 
     if (!driver->caps) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("cannot get host capabilities"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot get host capabilities"));
     } else if (!driver->caps->host.cpu) {
         VIR_WARN("cannot get host CPU capabilities");
         ret = VIR_CPU_COMPARE_INCOMPATIBLE;
@@ -9470,8 +9470,8 @@ static int qemuDomainGetJobInfo(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -9494,8 +9494,8 @@ static int qemuDomainGetJobInfo(virDomainPtr dom,
             info->type = VIR_DOMAIN_JOB_NONE;
         }
     } else {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
@@ -9520,8 +9520,8 @@ static int qemuDomainAbortJob(virDomainPtr dom) {
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -9529,21 +9529,21 @@ static int qemuDomainAbortJob(virDomainPtr dom) {
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
     priv = vm->privateData;
 
     if (!priv->job.asyncJob || priv->job.dump_memory_only) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("no job is active on the domain"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("no job is active on the domain"));
         goto endjob;
     } else if (priv->job.asyncJob == QEMU_ASYNC_JOB_MIGRATION_IN) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("cannot abort incoming migration;"
-                          " use virDomainDestroy instead"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("cannot abort incoming migration;"
+                         " use virDomainDestroy instead"));
         goto endjob;
     }
 
@@ -9582,8 +9582,8 @@ qemuDomainMigrateSetMaxDowntime(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         return -1;
     }
 
@@ -9591,16 +9591,16 @@ qemuDomainMigrateSetMaxDowntime(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
     priv = vm->privateData;
 
     if (priv->job.asyncJob != QEMU_ASYNC_JOB_MIGRATION_OUT) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not being migrated"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not being migrated"));
         goto endjob;
     }
 
@@ -9638,8 +9638,8 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         return -1;
     }
 
@@ -9649,8 +9649,8 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
             goto cleanup;
 
         if (!virDomainObjIsActive(vm)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("domain is not running"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("domain is not running"));
             goto endjob;
         }
 
@@ -9695,8 +9695,8 @@ qemuDomainMigrateGetMaxSpeed(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -9729,9 +9729,9 @@ qemuDomainSnapshotIsAllowed(virDomainObjPtr vm)
         if ((disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) ||
             (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
              STRNEQ_NULLABLE(disk->driverType, "qcow2"))) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("Disk '%s' does not support snapshotting"),
-                            disk->src);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("Disk '%s' does not support snapshotting"),
+                           disk->src);
             return false;
         }
     }
@@ -9746,14 +9746,14 @@ qemuDomainSnapshotFSFreeze(struct qemud_driver *driver,
     int freezed;
 
     if (priv->agentError) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("QEMU guest agent is not "
-                          "available due to an error"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("QEMU guest agent is not "
+                         "available due to an error"));
         return -1;
     }
     if (!priv->agent) {
-        qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                        _("QEMU guest agent is not configured"));
+        virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                       _("QEMU guest agent is not configured"));
         return -1;
     }
 
@@ -9774,15 +9774,15 @@ qemuDomainSnapshotFSThaw(struct qemud_driver *driver,
 
     if (priv->agentError) {
         if (report)
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("QEMU guest agent is not "
-                              "available due to an error"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("QEMU guest agent is not "
+                             "available due to an error"));
         return -1;
     }
     if (!priv->agent) {
         if (report)
-            qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                            _("QEMU guest agent is not configured"));
+            virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                           _("QEMU guest agent is not configured"));
         return -1;
     }
 
@@ -9824,8 +9824,8 @@ qemuDomainSnapshotCreateActive(virConnectPtr conn,
         return -1;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -9840,8 +9840,8 @@ qemuDomainSnapshotCreateActive(virConnectPtr conn,
 
         resume = true;
         if (!virDomainObjIsActive(vm)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("guest unexpectedly quit"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("guest unexpectedly quit"));
             goto cleanup;
         }
     }
@@ -9874,8 +9874,8 @@ cleanup:
                              VIR_DOMAIN_RUNNING_UNPAUSED,
                              QEMU_ASYNC_JOB_NONE) < 0 &&
         virGetLastError() == NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("resuming after snapshot failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("resuming after snapshot failed"));
     }
 
 endjob:
@@ -9904,8 +9904,8 @@ qemuDomainSnapshotDiskPrepare(virDomainObjPtr vm, virDomainSnapshotDefPtr def,
     qemuDomainObjPrivatePtr priv = vm->privateData;
 
     if (allow_reuse && !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("reuse is not supported with this QEMU binary"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("reuse is not supported with this QEMU binary"));
         goto cleanup;
     }
 
@@ -9915,19 +9915,19 @@ qemuDomainSnapshotDiskPrepare(virDomainObjPtr vm, virDomainSnapshotDefPtr def,
         switch (disk->snapshot) {
         case VIR_DOMAIN_DISK_SNAPSHOT_INTERNAL:
             if (active) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("active qemu domains require external disk "
-                                  "snapshots; disk %s requested internal"),
-                                disk->name);
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("active qemu domains require external disk "
+                                 "snapshots; disk %s requested internal"),
+                               disk->name);
                 goto cleanup;
             }
             if (!vm->def->disks[i]->driverType ||
                 STRNEQ(vm->def->disks[i]->driverType, "qcow2")) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("internal snapshot for disk %s unsupported "
-                                  "for storage type %s"),
-                                disk->name,
-                                NULLSTR(vm->def->disks[i]->driverType));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("internal snapshot for disk %s unsupported "
+                                 "for storage type %s"),
+                               disk->name,
+                               NULLSTR(vm->def->disks[i]->driverType));
                 goto cleanup;
             }
             found = true;
@@ -9941,10 +9941,10 @@ qemuDomainSnapshotDiskPrepare(virDomainObjPtr vm, virDomainSnapshotDefPtr def,
                 }
             } else if (STRNEQ(disk->driverType, "qcow2") &&
                        STRNEQ(disk->driverType, "qed")) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("external snapshot format for disk %s "
-                                  "is unsupported: %s"),
-                                disk->name, disk->driverType);
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("external snapshot format for disk %s "
+                                 "is unsupported: %s"),
+                               disk->name, disk->driverType);
                 goto cleanup;
             }
             if (stat(disk->file, &st) < 0) {
@@ -9955,10 +9955,10 @@ qemuDomainSnapshotDiskPrepare(virDomainObjPtr vm, virDomainSnapshotDefPtr def,
                     goto cleanup;
                 }
             } else if (!(S_ISBLK(st.st_mode) || !st.st_size || allow_reuse)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                                _("external snapshot file for disk %s already "
-                                  "exists and is not a block device: %s"),
-                                disk->name, disk->file);
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                               _("external snapshot file for disk %s already "
+                                 "exists and is not a block device: %s"),
+                               disk->name, disk->file);
                 goto cleanup;
             }
             found = true;
@@ -9970,16 +9970,16 @@ qemuDomainSnapshotDiskPrepare(virDomainObjPtr vm, virDomainSnapshotDefPtr def,
 
         case VIR_DOMAIN_DISK_SNAPSHOT_DEFAULT:
         default:
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("unexpected code path"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("unexpected code path"));
             goto cleanup;
         }
     }
 
     if (!found) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("disk snapshots require at least one disk to be "
-                          "selected for snapshot"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("disk snapshots require at least one disk to be "
+                         "selected for snapshot"));
         goto cleanup;
     }
     if (active) {
@@ -9987,9 +9987,9 @@ qemuDomainSnapshotDiskPrepare(virDomainObjPtr vm, virDomainSnapshotDefPtr def,
             qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
             *flags |= VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC;
         } else if (atomic && external > 1) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("atomic live snapshot of multiple disks "
-                              "is unsupported"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("atomic live snapshot of multiple disks "
+                             "is unsupported"));
             goto cleanup;
         }
     }
@@ -10024,8 +10024,8 @@ qemuDomainSnapshotCreateSingleDiskActive(struct qemud_driver *driver,
     bool need_unlink = false;
 
     if (snap->snapshot != VIR_DOMAIN_DISK_SNAPSHOT_EXTERNAL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("unexpected code path"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("unexpected code path"));
         return -1;
     }
 
@@ -10210,16 +10210,16 @@ qemuDomainSnapshotCreateDiskActive(virConnectPtr conn,
         return -1;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
     if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES) &&
         virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Unable to find cgroup for %s"),
-                        vm->def->name);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Unable to find cgroup for %s"),
+                       vm->def->name);
         goto endjob;
     }
     /* 'cgroup' is still NULL if cgroups are disabled.  */
@@ -10252,8 +10252,8 @@ qemuDomainSnapshotCreateDiskActive(virConnectPtr conn,
 
         resume = true;
         if (!virDomainObjIsActive(vm)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("guest unexpectedly quit"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("guest unexpectedly quit"));
             goto cleanup;
         }
     }
@@ -10349,8 +10349,8 @@ cleanup:
                                  VIR_DOMAIN_RUNNING_UNPAUSED,
                                  QEMU_ASYNC_JOB_NONE) < 0 &&
             virGetLastError() == NULL) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("resuming after snapshot failed"));
+            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                           _("resuming after snapshot failed"));
             goto endjob;
         }
     }
@@ -10409,8 +10409,8 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
 
     if ((flags & VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE) &&
         !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("quiesce requires disk-only"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("quiesce requires disk-only"));
         return NULL;
     }
 
@@ -10427,19 +10427,19 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
     virUUIDFormat(domain->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, domain->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (qemuProcessAutoDestroyActive(driver, vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is marked for auto destroy"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is marked for auto destroy"));
         goto cleanup;
     }
     if (!vm->persistent && (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("cannot halt after transient domain snapshot"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("cannot halt after transient domain snapshot"));
         goto cleanup;
     }
 
@@ -10452,23 +10452,23 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
         /* Prevent circular chains */
         if (def->parent) {
             if (STREQ(def->name, def->parent)) {
-                qemuReportError(VIR_ERR_INVALID_ARG,
-                                _("cannot set snapshot %s as its own parent"),
-                                def->name);
+                virReportError(VIR_ERR_INVALID_ARG,
+                               _("cannot set snapshot %s as its own parent"),
+                               def->name);
                 goto cleanup;
             }
             other = virDomainSnapshotFindByName(&vm->snapshots, def->parent);
             if (!other) {
-                qemuReportError(VIR_ERR_INVALID_ARG,
-                                _("parent %s for snapshot %s not found"),
-                                def->parent, def->name);
+                virReportError(VIR_ERR_INVALID_ARG,
+                               _("parent %s for snapshot %s not found"),
+                               def->parent, def->name);
                 goto cleanup;
             }
             while (other->def->parent) {
                 if (STREQ(other->def->parent, def->name)) {
-                    qemuReportError(VIR_ERR_INVALID_ARG,
-                                    _("parent %s would create cycle to %s"),
-                                    other->def->name, def->name);
+                    virReportError(VIR_ERR_INVALID_ARG,
+                                   _("parent %s would create cycle to %s"),
+                                   other->def->name, def->name);
                     goto cleanup;
                 }
                 other = virDomainSnapshotFindByName(&vm->snapshots,
@@ -10484,9 +10484,9 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
         /* Check that any replacement is compatible */
         if (def->dom &&
             memcmp(def->dom->uuid, domain->uuid, VIR_UUID_BUFLEN)) {
-            qemuReportError(VIR_ERR_INVALID_ARG,
-                            _("definition for snapshot %s must use uuid %s"),
-                            def->name, uuidstr);
+            virReportError(VIR_ERR_INVALID_ARG,
+                           _("definition for snapshot %s must use uuid %s"),
+                           def->name, uuidstr);
             goto cleanup;
         }
         other = virDomainSnapshotFindByName(&vm->snapshots, def->name);
@@ -10495,18 +10495,18 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
                  other->def->state == VIR_DOMAIN_PAUSED) !=
                 (def->state == VIR_DOMAIN_RUNNING ||
                  def->state == VIR_DOMAIN_PAUSED)) {
-                qemuReportError(VIR_ERR_INVALID_ARG,
-                                _("cannot change between online and offline "
-                                  "snapshot state in snapshot %s"),
-                                def->name);
+                virReportError(VIR_ERR_INVALID_ARG,
+                               _("cannot change between online and offline "
+                                 "snapshot state in snapshot %s"),
+                               def->name);
                 goto cleanup;
             }
             if ((other->def->state == VIR_DOMAIN_DISK_SNAPSHOT) !=
                 (def->state == VIR_DOMAIN_DISK_SNAPSHOT)) {
-                qemuReportError(VIR_ERR_INVALID_ARG,
-                                _("cannot change between disk snapshot and "
-                                  "system checkpoint in snapshot %s"),
-                                def->name);
+                virReportError(VIR_ERR_INVALID_ARG,
+                               _("cannot change between disk snapshot and "
+                                 "system checkpoint in snapshot %s"),
+                               def->name);
                 goto cleanup;
             }
             if (other->def->dom) {
@@ -10548,9 +10548,9 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
 
         if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) {
             if (!virDomainObjIsActive(vm)) {
-                qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                _("disk snapshots of inactive domains not "
-                                  "implemented yet"));
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("disk snapshots of inactive domains not "
+                                 "implemented yet"));
                 goto cleanup;
             }
             if (virDomainSnapshotAlignDisks(def,
@@ -10669,8 +10669,8 @@ static int qemuDomainSnapshotListNames(virDomainPtr domain, char **names,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -10699,8 +10699,8 @@ static int qemuDomainSnapshotNum(virDomainPtr domain,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -10729,8 +10729,8 @@ qemuDomainListAllSnapshots(virDomainPtr domain, virDomainSnapshotPtr **snaps,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -10762,16 +10762,16 @@ qemuDomainSnapshotListChildrenNames(virDomainSnapshotPtr snapshot,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(snapshot->domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
-                        snapshot->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
+                       snapshot->name);
         goto cleanup;
     }
 
@@ -10802,16 +10802,16 @@ qemuDomainSnapshotNumChildren(virDomainSnapshotPtr snapshot,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(snapshot->domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
-                        snapshot->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
+                       snapshot->name);
         goto cleanup;
     }
 
@@ -10842,16 +10842,16 @@ qemuDomainSnapshotListAllChildren(virDomainSnapshotPtr snapshot,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(snapshot->domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
-                        snapshot->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
+                       snapshot->name);
         goto cleanup;
     }
 
@@ -10881,15 +10881,15 @@ static virDomainSnapshotPtr qemuDomainSnapshotLookupByName(virDomainPtr domain,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no snapshot with matching name '%s'"), name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no snapshot with matching name '%s'"), name);
         goto cleanup;
     }
 
@@ -10916,8 +10916,8 @@ static int qemuDomainHasCurrentSnapshot(virDomainPtr domain,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -10946,23 +10946,23 @@ qemuDomainSnapshotGetParent(virDomainSnapshotPtr snapshot,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(snapshot->domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
-                        snapshot->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
+                       snapshot->name);
         goto cleanup;
     }
 
     if (!snap->def->parent) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("snapshot '%s' does not have a parent"),
-                        snap->def->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("snapshot '%s' does not have a parent"),
+                       snap->def->name);
         goto cleanup;
     }
 
@@ -10989,14 +10989,14 @@ static virDomainSnapshotPtr qemuDomainSnapshotCurrent(virDomainPtr domain,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!vm->current_snapshot) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT, "%s",
-                        _("the domain does not have a current snapshot"));
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT, "%s",
+                       _("the domain does not have a current snapshot"));
         goto cleanup;
     }
 
@@ -11024,16 +11024,16 @@ static char *qemuDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
     virUUIDFormat(snapshot->domain->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, snapshot->domain->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
-                        snapshot->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
+                       snapshot->name);
         goto cleanup;
     }
 
@@ -11062,15 +11062,15 @@ qemuDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot,
     virUUIDFormat(snapshot->domain->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, snapshot->domain->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
                         snapshot->name);
         goto cleanup;
     }
@@ -11102,16 +11102,16 @@ qemuDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
     virUUIDFormat(snapshot->domain->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, snapshot->domain->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
-                        snapshot->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
+                       snapshot->name);
         goto cleanup;
     }
 
@@ -11175,16 +11175,16 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
     virUUIDFormat(snapshot->domain->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, snapshot->domain->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
-                        snapshot->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
+                       snapshot->name);
         goto cleanup;
     }
 
@@ -11193,22 +11193,22 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
         snap->def->state != VIR_DOMAIN_PAUSED &&
         (flags & (VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
                   VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED)) == 0) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("transient domain needs to request run or pause "
-                          "to revert to inactive snapshot"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("transient domain needs to request run or pause "
+                         "to revert to inactive snapshot"));
         goto cleanup;
     }
     if (snap->def->state == VIR_DOMAIN_DISK_SNAPSHOT) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("revert to external disk snapshot not supported "
-                          "yet"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("revert to external disk snapshot not supported "
+                         "yet"));
         goto cleanup;
     }
     if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) {
         if (!snap->def->dom) {
-            qemuReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY,
-                            _("snapshot '%s' lacks domain '%s' rollback info"),
-                            snap->def->name, vm->def->name);
+            virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY,
+                           _("snapshot '%s' lacks domain '%s' rollback info"),
+                           snap->def->name, vm->def->name);
             goto cleanup;
         }
         if (virDomainObjIsActive(vm) &&
@@ -11216,8 +11216,8 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
               || snap->def->state == VIR_DOMAIN_PAUSED) &&
             (flags & (VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
                       VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED))) {
-            qemuReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY,
-                            _("must respawn qemu to start inactive snapshot"));
+            virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY,
+                           _("must respawn qemu to start inactive snapshot"));
             goto cleanup;
         }
     }
@@ -11278,8 +11278,8 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
                 if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) {
                     /* Re-spawn error using correct category. */
                     if (err->code == VIR_ERR_CONFIG_UNSUPPORTED)
-                        qemuReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, "%s",
-                                        err->str2);
+                        virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, "%s",
+                                       err->str2);
                     goto endjob;
                 }
                 virResetError(err);
@@ -11311,8 +11311,8 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
                                                  VIR_DOMAIN_EVENT_SUSPENDED,
                                                  detail);
                 if (!virDomainObjIsActive(vm)) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("guest unexpectedly quit"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("guest unexpectedly quit"));
                     goto endjob;
                 }
             }
@@ -11363,8 +11363,8 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
         } else {
             /* Transitions 2, 5, 8 */
             if (!virDomainObjIsActive(vm)) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("guest unexpectedly quit"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("guest unexpectedly quit"));
                 goto endjob;
             }
             rc = qemuProcessStartCPUs(driver, vm, snapshot->domain->conn,
@@ -11543,16 +11543,16 @@ static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
     virUUIDFormat(snapshot->domain->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, snapshot->domain->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name);
     if (!snap) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
-                        _("no domain snapshot with matching name '%s'"),
-                        snapshot->name);
+        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+                       _("no domain snapshot with matching name '%s'"),
+                       snapshot->name);
         goto cleanup;
     }
 
@@ -11565,9 +11565,9 @@ static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
                                                qemuDomainSnapshotCountExternal,
                                                &external);
         if (external) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("deletion of %d external disk snapshots not "
-                              "supported yet"), external);
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("deletion of %d external disk snapshots not "
+                             "supported yet"), external);
             goto cleanup;
         }
     }
@@ -11592,9 +11592,9 @@ static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
                 snap->def->current = true;
                 if (qemuDomainSnapshotWriteMetadata(vm, snap,
                                                     driver->snapshotDir) < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("failed to set snapshot '%s' as current"),
-                                    snap->def->name);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("failed to set snapshot '%s' as current"),
+                                   snap->def->name);
                     snap->def->current = false;
                     goto endjob;
                 }
@@ -11654,14 +11654,14 @@ static int qemuDomainMonitorCommand(virDomainPtr domain, const char *cmd,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(domain->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
    }
 
@@ -11669,8 +11669,8 @@ static int qemuDomainMonitorCommand(virDomainPtr domain, const char *cmd,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("domain is not running"));
         goto endjob;
     }
 
@@ -11719,16 +11719,16 @@ static virDomainPtr qemuDomainAttach(virConnectPtr conn,
         goto cleanup;
 
     if (!monConfig) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("No monitor connection for pid %u"), pid_value);
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("No monitor connection for pid %u"), pid_value);
         goto cleanup;
     }
     if (monConfig->type != VIR_DOMAIN_CHR_TYPE_UNIX) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("Cannot connect to monitor connection of type '%s' "
-                          "for pid %u"),
-                        virDomainChrTypeToString(monConfig->type),
-                        pid_value);
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Cannot connect to monitor connection of type '%s' "
+                         "for pid %u"),
+                       virDomainChrTypeToString(monConfig->type),
+                       pid_value);
         goto cleanup;
     }
 
@@ -11807,14 +11807,14 @@ qemuDomainOpenConsole(virDomainPtr dom,
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
     qemuDriverUnlock(driver);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
@@ -11842,16 +11842,16 @@ qemuDomainOpenConsole(virDomainPtr dom,
     }
 
     if (!chr) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot find character device %s"),
-                        NULLSTR(dev_name));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot find character device %s"),
+                       NULLSTR(dev_name));
         goto cleanup;
     }
 
     if (chr->source.type != VIR_DOMAIN_CHR_TYPE_PTY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("character device %s is not using a PTY"),
-                        NULLSTR(dev_name));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("character device %s is not using a PTY"),
+                       NULLSTR(dev_name));
         goto cleanup;
     }
 
@@ -11862,8 +11862,8 @@ qemuDomainOpenConsole(virDomainPtr dom,
                          (flags & VIR_DOMAIN_CONSOLE_FORCE) != 0);
 
     if (ret == 1) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("Active console session exists for this domain"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("Active console session exists for this domain"));
         ret = -1;
     }
 
@@ -11901,8 +11901,8 @@ qemuDiskPathToAlias(virDomainObjPtr vm, const char *path, int *idx)
 
 cleanup:
     if (!ret) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        "%s", _("No device found for specified path"));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       "%s", _("No device found for specified path"));
     }
     return ret;
 }
@@ -11927,13 +11927,13 @@ qemuDomainBlockJobImpl(virDomainPtr dom, const char *path, const char *base,
     virUUIDFormat(dom->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("domain is not running"));
         goto cleanup;
     }
 
@@ -11941,18 +11941,18 @@ qemuDomainBlockJobImpl(virDomainPtr dom, const char *path, const char *base,
     if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC)) {
         async = true;
     } else if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("block jobs not supported with this QEMU binary"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("block jobs not supported with this QEMU binary"));
         goto cleanup;
     } else if (base) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("partial block pull not supported with this "
-                          "QEMU binary"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("partial block pull not supported with this "
+                         "QEMU binary"));
         goto cleanup;
     } else if (mode == BLOCK_JOB_PULL && bandwidth) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("setting bandwidth at start of block pull not "
-                          "supported with this QEMU binary"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("setting bandwidth at start of block pull not "
+                         "supported with this QEMU binary"));
         goto cleanup;
     }
 
@@ -11965,8 +11965,8 @@ qemuDomainBlockJobImpl(virDomainPtr dom, const char *path, const char *base,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("domain is not running"));
         goto endjob;
     }
 
@@ -12016,8 +12016,8 @@ qemuDomainBlockJobImpl(virDomainPtr dom, const char *path, const char *base,
                 virDomainObjLock(vm);
 
                 if (!virDomainObjIsActive(vm)) {
-                    qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                                    _("domain is not running"));
+                    virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                                   _("domain is not running"));
                     ret = -1;
                     break;
                 }
@@ -12102,22 +12102,22 @@ qemuDomainOpenGraphics(virDomainPtr dom,
     virUUIDFormat(dom->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
     priv = vm->privateData;
 
     if (idx >= vm->def->ngraphics) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No graphics backend with index %d"), idx);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No graphics backend with index %d"), idx);
         goto cleanup;
     }
     switch (vm->def->graphics[idx]->type) {
@@ -12128,9 +12128,9 @@ qemuDomainOpenGraphics(virDomainPtr dom,
         protocol = "spice";
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("Can only open VNC or SPICE graphics backends, not %s"),
-                        virDomainGraphicsTypeToString(vm->def->graphics[idx]->type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Can only open VNC or SPICE graphics backends, not %s"),
+                       virDomainGraphicsTypeToString(vm->def->graphics[idx]->type));
         goto cleanup;
     }
 
@@ -12197,15 +12197,15 @@ qemuDomainSetBlockIoTune(virDomainPtr dom,
     virUUIDFormat(dom->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
     priv = vm->privateData;
     if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("block I/O throttling not supported with this "
-                          "QEMU binary"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("block I/O throttling not supported with this "
+                         "QEMU binary"));
         goto cleanup;
     }
 
@@ -12252,15 +12252,15 @@ qemuDomainSetBlockIoTune(virDomainPtr dom,
 
     if ((info.total_bytes_sec && info.read_bytes_sec) ||
         (info.total_bytes_sec && info.write_bytes_sec)) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("total and read/write of bytes_sec cannot be set at the same time"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("total and read/write of bytes_sec cannot be set at the same time"));
         goto endjob;
     }
 
     if ((info.total_iops_sec && info.read_iops_sec) ||
         (info.total_iops_sec && info.write_iops_sec)) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("total and read/write of iops_sec cannot be set at the same time"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("total and read/write of iops_sec cannot be set at the same time"));
         goto endjob;
     }
 
@@ -12306,7 +12306,7 @@ qemuDomainSetBlockIoTune(virDomainPtr dom,
         persistentDef->disks[idx]->blkdeviotune = info;
         ret = virDomainSaveConfig(driver->configDir, persistentDef);
         if (ret < 0) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
+            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                            _("Write to config file failed"));
             goto endjob;
         }
@@ -12352,8 +12352,8 @@ qemuDomainGetBlockIoTune(virDomainPtr dom,
     virUUIDFormat(dom->uuid, uuidstr);
     vm = virDomainFindByUUID(&driver->domains, dom->uuid);
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -12483,8 +12483,8 @@ qemuDomainGetDiskErrors(virDomainPtr dom,
     qemuDriverUnlock(driver);
 
     if (!vm) {
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -12494,8 +12494,8 @@ qemuDomainGetDiskErrors(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -12568,8 +12568,8 @@ qemuDomainSetMetadata(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -12592,14 +12592,14 @@ qemuDomainSetMetadata(virDomainPtr dom,
                 goto no_memory;
             break;
         case VIR_DOMAIN_METADATA_ELEMENT:
-            qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                            _("QEmu driver does not support modifying"
-                              "<metadata> element"));
+            virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                           _("QEmu driver does not support modifying"
+                             "<metadata> element"));
             goto cleanup;
             break;
         default:
-            qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                            _("unknown metadata type"));
+            virReportError(VIR_ERR_INVALID_ARG, "%s",
+                           _("unknown metadata type"));
             goto cleanup;
             break;
         }
@@ -12620,13 +12620,13 @@ qemuDomainSetMetadata(virDomainPtr dom,
                 goto no_memory;
             break;
         case VIR_DOMAIN_METADATA_ELEMENT:
-            qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                            _("QEMU driver does not support"
-                              "<metadata> element"));
+            virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                           _("QEMU driver does not support"
+                             "<metadata> element"));
             goto cleanup;
          default:
-            qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                            _("unknown metadata type"));
+            virReportError(VIR_ERR_INVALID_ARG, "%s",
+                           _("unknown metadata type"));
             goto cleanup;
             break;
         }
@@ -12668,8 +12668,8 @@ qemuDomainGetMetadata(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -12688,21 +12688,21 @@ qemuDomainGetMetadata(virDomainPtr dom,
         field = def->title;
         break;
     case VIR_DOMAIN_METADATA_ELEMENT:
-        qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                        _("QEMU driver does not support"
-                          "<metadata> element"));
+        virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                       _("QEMU driver does not support"
+                         "<metadata> element"));
         goto cleanup;
         break;
     default:
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("unknown metadata type"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("unknown metadata type"));
         goto cleanup;
         break;
     }
 
     if (!field) {
-        qemuReportError(VIR_ERR_NO_DOMAIN_METADATA, "%s",
-                        _("Requested metadata element is not present"));
+        virReportError(VIR_ERR_NO_DOMAIN_METADATA, "%s",
+                       _("Requested metadata element is not present"));
         goto cleanup;
     }
 
@@ -12797,8 +12797,8 @@ getSumVcpuPercpuStats(virCgroupPtr group,
         int j;
 
         if (virCgroupForVcpu(group, i, &group_vcpu, 0) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("error accessing cgroup cpuacct for vcpu"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("error accessing cgroup cpuacct for vcpu"));
             goto cleanup;
         }
 
@@ -12808,8 +12808,8 @@ getSumVcpuPercpuStats(virCgroupPtr group,
         pos = buf;
         for (j = 0; j < num; j++) {
             if (virStrToLong_ull(pos, &pos, 10, &tmp) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cpuacct parse error"));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cpuacct parse error"));
                 goto cleanup;
             }
             sum_cpu_time[j] += tmp;
@@ -12864,9 +12864,9 @@ qemuDomainGetPercpuStats(virDomainPtr domain,
     }
 
     if (start_cpu > max_id) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("start_cpu %d larger than maximum of %d"),
-                        start_cpu, max_id);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("start_cpu %d larger than maximum of %d"),
+                       start_cpu, max_id);
         goto cleanup;
     }
 
@@ -12886,8 +12886,8 @@ qemuDomainGetPercpuStats(virDomainPtr domain,
         if (!map[i]) {
             cpu_time = 0;
         } else if (virStrToLong_ull(pos, &pos, 10, &cpu_time) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cpuacct parse error"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cpuacct parse error"));
             goto cleanup;
         } else {
             n++;
@@ -12916,8 +12916,8 @@ qemuDomainGetPercpuStats(virDomainPtr domain,
     /* Check that the mapping of online cpus didn't change mid-parse.  */
     map2 = nodeGetCPUmap(domain->conn, &max_id, "present");
     if (!map2 || memcmp(map, map2, VIR_DOMAIN_CPUMASK_LEN) != 0) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("the set of online cpus changed while reading"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("the set of online cpus changed while reading"));
         goto cleanup;
     }
 
@@ -12967,27 +12967,27 @@ qemuDomainGetCPUStats(virDomainPtr domain,
 
     vm = virDomainFindByUUID(&driver->domains, domain->uuid);
     if (vm == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No such domain %s"), domain->uuid);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No such domain %s"), domain->uuid);
         goto cleanup;
     }
 
     isActive = virDomainObjIsActive(vm);
     if (!isActive) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("domain is not running"));
         goto cleanup;
     }
 
     if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUACCT)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("cgroup CPUACCT controller is not mounted"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("cgroup CPUACCT controller is not mounted"));
         goto cleanup;
     }
 
     if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot find cgroup for domain %s"), vm->def->name);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot find cgroup for domain %s"), vm->def->name);
         goto cleanup;
     }
 
@@ -13018,17 +13018,17 @@ qemuDomainPMSuspendForDuration(virDomainPtr dom,
     virCheckFlags(0, -1);
 
     if (duration) {
-        qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                        _("Duration not supported. Use 0 for now"));
+        virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                       _("Duration not supported. Use 0 for now"));
         return -1;
     }
 
     if (!(target == VIR_NODE_SUSPEND_TARGET_MEM ||
           target == VIR_NODE_SUSPEND_TARGET_DISK ||
           target == VIR_NODE_SUSPEND_TARGET_HYBRID)) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("Unknown suspend target: %u"),
-                        target);
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("Unknown suspend target: %u"),
+                       target);
         return -1;
     }
 
@@ -13039,37 +13039,37 @@ qemuDomainPMSuspendForDuration(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
     priv = vm->privateData;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto cleanup;
     }
 
     if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_WAKEUP) &&
         (target == VIR_NODE_SUSPEND_TARGET_MEM ||
          target == VIR_NODE_SUSPEND_TARGET_HYBRID)) {
-        qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                        _("Unable to suspend domain due to "
-                          "missing system_wakeup monitor command"));
+        virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                       _("Unable to suspend domain due to "
+                         "missing system_wakeup monitor command"));
         goto cleanup;
     }
 
     if (priv->agentError) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("QEMU guest agent is not available due to an error"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("QEMU guest agent is not available due to an error"));
         goto cleanup;
     }
 
     if (!priv->agent) {
-        qemuReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                        _("QEMU guest agent is not configured"));
+        virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
+                       _("QEMU guest agent is not configured"));
         goto cleanup;
     }
 
@@ -13077,8 +13077,8 @@ qemuDomainPMSuspendForDuration(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -13114,8 +13114,8 @@ qemuDomainPMWakeup(virDomainPtr dom,
     if (!vm) {
         char uuidstr[VIR_UUID_STRING_BUFLEN];
         virUUIDFormat(dom->uuid, uuidstr);
-        qemuReportError(VIR_ERR_NO_DOMAIN,
-                        _("no domain with matching uuid '%s'"), uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
         goto cleanup;
     }
 
@@ -13123,17 +13123,17 @@ qemuDomainPMWakeup(virDomainPtr dom,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
     priv = vm->privateData;
 
     if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_WAKEUP)) {
-       qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("Unable to wake up domain due to "
-                         "missing system_wakeup monitor command"));
+       virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                      _("Unable to wake up domain due to "
+                        "missing system_wakeup monitor command"));
        goto endjob;
     }
 
diff --git a/src/qemu/qemu_hostdev.c b/src/qemu/qemu_hostdev.c
index 434aa02..fb07c3c 100644
--- a/src/qemu/qemu_hostdev.c
+++ b/src/qemu/qemu_hostdev.c
@@ -31,6 +31,8 @@
 #include "hostusb.h"
 #include "virnetdev.h"
 
+#define VIR_FROM_THIS VIR_FROM_QEMU
+
 static pciDeviceList *
 qemuGetPciHostDeviceList(virDomainHostdevDefPtr *hostdevs, int nhostdevs)
 {
@@ -271,10 +273,11 @@ qemuDomainHostdevNetConfigVirtPortProfile(const char *linkdev, int vf,
     case VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH:
     case VIR_NETDEV_VPORT_PROFILE_8021QBG:
     case VIR_NETDEV_VPORT_PROFILE_LAST:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("virtualport type %s is "
-                        "currently not supported on interfaces of type "
-                        "hostdev"),
-                        virNetDevVPortTypeToString(virtPort->virtPortType));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("virtualport type %s is "
+                         "currently not supported on interfaces of type "
+                         "hostdev"),
+                       virNetDevVPortTypeToString(virtPort->virtPortType));
         break;
 
     case VIR_NETDEV_VPORT_PROFILE_8021QBH:
@@ -307,9 +310,9 @@ qemuDomainHostdevNetConfigReplace(virDomainHostdevDefPtr hostdev,
 
     isvf = qemuDomainHostdevIsVirtualFunction(hostdev);
     if (isvf <= 0) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("Interface type hostdev is currently supported on"
-                        " SR-IOV Virtual Functions only"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Interface type hostdev is currently supported on"
+                         " SR-IOV Virtual Functions only"));
         return ret;
     }
 
@@ -345,9 +348,9 @@ qemuDomainHostdevNetConfigRestore(virDomainHostdevDefPtr hostdev,
 
     isvf = qemuDomainHostdevIsVirtualFunction(hostdev);
     if (isvf <= 0) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("Interface type hostdev is currently supported on"
-                        " SR-IOV Virtual Functions only"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Interface type hostdev is currently supported on"
+                         " SR-IOV Virtual Functions only"));
         return ret;
     }
 
@@ -399,9 +402,9 @@ int qemuPrepareHostdevPCIDevices(struct qemud_driver *driver,
         pciDevice *other;
 
         if (!pciDeviceIsAssignable(dev, !driver->relaxedACS)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("PCI device %s is not assignable"),
-                            pciDeviceGetName(dev));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("PCI device %s is not assignable"),
+                           pciDeviceGetName(dev));
             goto cleanup;
         }
         /* The device is in use by other active domain if
@@ -411,13 +414,13 @@ int qemuPrepareHostdevPCIDevices(struct qemud_driver *driver,
             const char *other_name = pciDeviceGetUsedBy(other);
 
             if (other_name)
-                qemuReportError(VIR_ERR_OPERATION_INVALID,
-                                _("PCI device %s is in use by domain %s"),
-                                pciDeviceGetName(dev), other_name);
+                virReportError(VIR_ERR_OPERATION_INVALID,
+                               _("PCI device %s is in use by domain %s"),
+                               pciDeviceGetName(dev), other_name);
             else
-                qemuReportError(VIR_ERR_OPERATION_INVALID,
-                                _("PCI device %s is already in use"),
-                                pciDeviceGetName(dev));
+                virReportError(VIR_ERR_OPERATION_INVALID,
+                               _("PCI device %s is already in use"),
+                               pciDeviceGetName(dev));
             goto cleanup;
         }
     }
@@ -579,13 +582,13 @@ qemuPrepareHostdevUSBDevices(struct qemud_driver *driver,
             const char *other_name = usbDeviceGetUsedBy(tmp);
 
             if (other_name)
-                qemuReportError(VIR_ERR_OPERATION_INVALID,
-                                _("USB device %s is in use by domain %s"),
-                                usbDeviceGetName(tmp), other_name);
+                virReportError(VIR_ERR_OPERATION_INVALID,
+                               _("USB device %s is in use by domain %s"),
+                               usbDeviceGetName(tmp), other_name);
             else
-                qemuReportError(VIR_ERR_OPERATION_INVALID,
-                                _("USB device %s is already in use"),
-                                usbDeviceGetName(tmp));
+                virReportError(VIR_ERR_OPERATION_INVALID,
+                               _("USB device %s is already in use"),
+                               usbDeviceGetName(tmp));
             goto error;
         }
 
@@ -653,9 +656,9 @@ qemuPrepareHostUSBDevices(struct qemud_driver *driver,
                 goto cleanup;
 
             if (usbDeviceListCount(devs) > 1) {
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                _("multiple USB devices for %x:%x, "
-                                  "use <address> to specify one"), vendor, product);
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               _("multiple USB devices for %x:%x, "
+                                 "use <address> to specify one"), vendor, product);
                 usbDeviceListFree(devs);
                 goto cleanup;
             }
diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c
index 09c8c97..20aefce 100644
--- a/src/qemu/qemu_hotplug.c
+++ b/src/qemu/qemu_hotplug.c
@@ -66,23 +66,23 @@ int qemuDomainChangeEjectableMedia(struct qemud_driver *driver,
     }
 
     if (!origdisk) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("No device with bus '%s' and target '%s'"),
-                        virDomainDiskBusTypeToString(disk->bus),
-                        disk->dst);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("No device with bus '%s' and target '%s'"),
+                       virDomainDiskBusTypeToString(disk->bus),
+                       disk->dst);
         return -1;
     }
 
     if (!origdisk->info.alias) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("missing disk device alias name for %s"), origdisk->dst);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("missing disk device alias name for %s"), origdisk->dst);
         return -1;
     }
 
     if (origdisk->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
         origdisk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Removable media not supported for %s device"),
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Removable media not supported for %s device"),
                         virDomainDiskDeviceTypeToString(disk->device));
         return -1;
     }
@@ -210,8 +210,8 @@ int qemuDomainAttachPciDiskDevice(virConnectPtr conn,
 
     for (i = 0 ; i < vm->def->ndisks ; i++) {
         if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("target %s already exists"), disk->dst);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("target %s already exists"), disk->dst);
             return -1;
         }
     }
@@ -318,9 +318,9 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
     for (i = 0 ; i < vm->def->ncontrollers ; i++) {
         if ((vm->def->controllers[i]->type == controller->type) &&
             (vm->def->controllers[i]->idx == controller->idx)) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("target %s:%d already exists"),
-                            type, controller->idx);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("target %s:%d already exists"),
+                           type, controller->idx);
             return -1;
         }
     }
@@ -335,8 +335,8 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
         if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
             controller->model == -1 &&
             !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                            _("USB controller hotplug unsupported in this QEMU binary"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("USB controller hotplug unsupported in this QEMU binary"));
             goto cleanup;
         }
 
@@ -415,8 +415,8 @@ qemuDomainFindOrCreateSCSIDiskController(struct qemud_driver *driver,
     }
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("guest unexpectedly quit"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("guest unexpectedly quit"));
         /* cont doesn't need freeing here, since the reference
          * now held in def->controllers */
         return NULL;
@@ -440,8 +440,8 @@ int qemuDomainAttachSCSIDisk(virConnectPtr conn,
 
     for (i = 0 ; i < vm->def->ndisks ; i++) {
         if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("target %s already exists"), disk->dst);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("target %s already exists"), disk->dst);
             return -1;
         }
     }
@@ -458,9 +458,9 @@ int qemuDomainAttachSCSIDisk(virConnectPtr conn,
 
     /* We should have an address already, so make sure */
     if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unexpected disk address type %s"),
-                        virDomainDeviceAddressTypeToString(disk->info.type));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unexpected disk address type %s"),
+                       virDomainDeviceAddressTypeToString(disk->info.type));
         goto error;
     }
 
@@ -486,8 +486,8 @@ int qemuDomainAttachSCSIDisk(virConnectPtr conn,
     sa_assert (cont);
 
     if (cont->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("SCSI controller %d was missing its PCI address"), cont->idx);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("SCSI controller %d was missing its PCI address"), cont->idx);
         goto error;
     }
 
@@ -563,8 +563,8 @@ int qemuDomainAttachUsbMassstorageDevice(virConnectPtr conn,
 
     for (i = 0 ; i < vm->def->ndisks ; i++) {
         if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("target %s already exists"), disk->dst);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("target %s already exists"), disk->dst);
             return -1;
         }
     }
@@ -581,8 +581,8 @@ int qemuDomainAttachUsbMassstorageDevice(virConnectPtr conn,
 
     /* XXX not correct once we allow attaching a USB CDROM */
     if (!disk->src) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("disk source path is missing"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("disk source path is missing"));
         goto error;
     }
 
@@ -692,8 +692,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
     }
 
     if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_HOST_NET_ADD)) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("installed qemu version does not support host_net_add"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("installed qemu version does not support host_net_add"));
         goto cleanup;
     }
 
@@ -734,8 +734,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
         vlan = qemuDomainNetVLAN(net);
 
         if (vlan < 0) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("Unable to attach network devices without vlan"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("Unable to attach network devices without vlan"));
             goto cleanup;
         }
     }
@@ -784,8 +784,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
     VIR_FORCE_CLOSE(vhostfd);
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("guest unexpectedly quit"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("guest unexpectedly quit"));
         goto cleanup;
     }
 
@@ -820,8 +820,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
     /* set link state */
     if (net->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) {
         if (!net->info.alias) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("device alias not found: cannot set link state to down"));
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("device alias not found: cannot set link state to down"));
         } else {
             qemuDomainObjEnterMonitorWithDriver(driver, vm);
 
@@ -832,8 +832,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
                     goto try_remove;
                 }
             } else {
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                _("setting of link state not supported: Link is up"));
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               _("setting of link state not supported: Link is up"));
             }
 
             qemuDomainObjExitMonitorWithDriver(driver, vm);
@@ -953,8 +953,8 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
         }
 
         if (!virDomainObjIsActive(vm)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("guest unexpectedly quit during hotplug"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("guest unexpectedly quit during hotplug"));
             goto error;
         }
 
@@ -1077,9 +1077,9 @@ int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
         qemuCgroupData data;
 
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) !=0 ) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unable to find cgroup for %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unable to find cgroup for %s"),
+                           vm->def->name);
             goto error;
         }
 
@@ -1124,9 +1124,9 @@ int qemuDomainAttachHostDevice(struct qemud_driver *driver,
     usbDevice *usb = NULL;
 
     if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("hostdev mode '%s' not supported"),
-                        virDomainHostdevModeTypeToString(hostdev->mode));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("hostdev mode '%s' not supported"),
+                       virDomainHostdevModeTypeToString(hostdev->mode));
         return -1;
     }
 
@@ -1148,9 +1148,9 @@ int qemuDomainAttachHostDevice(struct qemud_driver *driver,
                 goto cleanup;
 
             if (usbDeviceListCount(devs) > 1) {
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                _("multiple USB devices for %x:%x, "
-                                  "use <address> to specify one"), vendor, product);
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               _("multiple USB devices for %x:%x, "
+                                 "use <address> to specify one"), vendor, product);
                 usbDeviceListFree(devs);
                 goto cleanup;
             }
@@ -1199,9 +1199,9 @@ int qemuDomainAttachHostDevice(struct qemud_driver *driver,
         break;
 
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("hostdev subsys type '%s' not supported"),
-                        virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("hostdev subsys type '%s' not supported"),
+                       virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
         goto error;
     }
 
@@ -1246,8 +1246,8 @@ int qemuDomainChangeNetBridge(virDomainObjPtr vm,
               olddev->ifname, oldbridge, newbridge);
 
     if (virNetDevExists(newbridge) != 1) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("bridge %s doesn't exist"), newbridge);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("bridge %s doesn't exist"), newbridge);
         return -1;
     }
 
@@ -1268,9 +1268,9 @@ int qemuDomainChangeNetBridge(virDomainObjPtr vm,
         ret = virNetDevBridgeAddPort(oldbridge, olddev->ifname);
         virDomainAuditNet(vm, NULL, olddev, "attach", ret == 0);
         if (ret < 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("unable to recover former state by adding port"
-                              "to bridge %s"), oldbridge);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("unable to recover former state by adding port"
+                             "to bridge %s"), oldbridge);
         }
         return -1;
     }
@@ -1291,8 +1291,8 @@ int qemuDomainChangeNetLinkState(struct qemud_driver *driver,
     VIR_DEBUG("dev: %s, state: %d", dev->info.alias, linkstate);
 
     if (!dev->info.alias) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("can't change link state: device alias not found"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("can't change link state: device alias not found"));
         return -1;
     }
 
@@ -1321,14 +1321,14 @@ int qemuDomainChangeNet(struct qemud_driver *driver,
     int ret = 0;
 
     if (!olddev) {
-        qemuReportError(VIR_ERR_NO_SUPPORT,
-                        _("cannot find existing network device to modify"));
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       _("cannot find existing network device to modify"));
         return -1;
     }
 
     if (olddev->type != dev->type) {
-        qemuReportError(VIR_ERR_NO_SUPPORT,
-                        _("cannot change network interface type"));
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       _("cannot change network interface type"));
         return -1;
     }
 
@@ -1340,8 +1340,8 @@ int qemuDomainChangeNet(struct qemud_driver *driver,
         if (STRNEQ_NULLABLE(olddev->data.ethernet.dev, dev->data.ethernet.dev) ||
             STRNEQ_NULLABLE(olddev->script, dev->script) ||
             STRNEQ_NULLABLE(olddev->data.ethernet.ipaddr, dev->data.ethernet.ipaddr)) {
-            qemuReportError(VIR_ERR_NO_SUPPORT,
-                            _("cannot modify ethernet network device configuration"));
+            virReportError(VIR_ERR_NO_SUPPORT,
+                           _("cannot modify ethernet network device configuration"));
             return -1;
         }
         break;
@@ -1351,8 +1351,8 @@ int qemuDomainChangeNet(struct qemud_driver *driver,
     case VIR_DOMAIN_NET_TYPE_MCAST:
         if (STRNEQ_NULLABLE(olddev->data.socket.address, dev->data.socket.address) ||
             olddev->data.socket.port != dev->data.socket.port) {
-            qemuReportError(VIR_ERR_NO_SUPPORT,
-                            _("cannot modify network socket device configuration"));
+            virReportError(VIR_ERR_NO_SUPPORT,
+                           _("cannot modify network socket device configuration"));
             return -1;
         }
         break;
@@ -1361,8 +1361,8 @@ int qemuDomainChangeNet(struct qemud_driver *driver,
         if (STRNEQ_NULLABLE(olddev->data.network.name, dev->data.network.name) ||
             STRNEQ_NULLABLE(olddev->data.network.portgroup, dev->data.network.portgroup) ||
             !virNetDevVPortProfileEqual(olddev->data.network.virtPortProfile, dev->data.network.virtPortProfile)) {
-            qemuReportError(VIR_ERR_NO_SUPPORT,
-                            _("cannot modify network device configuration"));
+            virReportError(VIR_ERR_NO_SUPPORT,
+                           _("cannot modify network device configuration"));
             return -1;
         }
 
@@ -1372,16 +1372,16 @@ int qemuDomainChangeNet(struct qemud_driver *driver,
        /* allow changing brname, but not portprofile */
        if (!virNetDevVPortProfileEqual(olddev->data.bridge.virtPortProfile,
                                        dev->data.bridge.virtPortProfile)) {
-           qemuReportError(VIR_ERR_NO_SUPPORT,
-                           _("cannot modify bridge network device configuration"));
+           virReportError(VIR_ERR_NO_SUPPORT,
+                          _("cannot modify bridge network device configuration"));
            return -1;
        }
        break;
 
     case VIR_DOMAIN_NET_TYPE_INTERNAL:
         if (STRNEQ_NULLABLE(olddev->data.internal.name, dev->data.internal.name)) {
-            qemuReportError(VIR_ERR_NO_SUPPORT,
-                            _("cannot modify internal network device configuration"));
+            virReportError(VIR_ERR_NO_SUPPORT,
+                           _("cannot modify internal network device configuration"));
             return -1;
         }
         break;
@@ -1390,16 +1390,16 @@ int qemuDomainChangeNet(struct qemud_driver *driver,
         if (STRNEQ_NULLABLE(olddev->data.direct.linkdev, dev->data.direct.linkdev) ||
             olddev->data.direct.mode != dev->data.direct.mode ||
             !virNetDevVPortProfileEqual(olddev->data.direct.virtPortProfile, dev->data.direct.virtPortProfile)) {
-            qemuReportError(VIR_ERR_NO_SUPPORT,
-                            _("cannot modify direct network device configuration"));
+            virReportError(VIR_ERR_NO_SUPPORT,
+                           _("cannot modify direct network device configuration"));
             return -1;
         }
         break;
 
     default:
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to change config on '%s' network type"),
-                        virDomainNetTypeToString(dev->type));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to change config on '%s' network type"),
+                       virDomainNetTypeToString(dev->type));
         break;
 
     }
@@ -1407,16 +1407,16 @@ int qemuDomainChangeNet(struct qemud_driver *driver,
     /* all other unmodifiable parameters */
     if (STRNEQ_NULLABLE(olddev->model, dev->model) ||
         STRNEQ_NULLABLE(olddev->filter, dev->filter)) {
-        qemuReportError(VIR_ERR_NO_SUPPORT,
-                        _("cannot modify network device configuration"));
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       _("cannot modify network device configuration"));
         return -1;
     }
 
     /* check if device name has been set, if no, retain the autogenerated one */
     if (dev->ifname &&
         STRNEQ_NULLABLE(olddev->ifname, dev->ifname)) {
-        qemuReportError(VIR_ERR_NO_SUPPORT,
-                        _("cannot modify network device configuration"));
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       _("cannot modify network device configuration"));
         return -1;
     }
 
@@ -1462,8 +1462,8 @@ qemuDomainChangeGraphics(struct qemud_driver *driver,
     int ret = -1;
 
     if (!olddev) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("cannot find existing graphics device to modify"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cannot find existing graphics device to modify"));
         return -1;
     }
 
@@ -1477,23 +1477,23 @@ qemuDomainChangeGraphics(struct qemud_driver *driver,
         if ((olddev->data.vnc.autoport != dev->data.vnc.autoport) ||
             (!dev->data.vnc.autoport &&
              (olddev->data.vnc.port != dev->data.vnc.port))) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot change port settings on vnc graphics"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot change port settings on vnc graphics"));
             return -1;
         }
         if (STRNEQ_NULLABLE(oldListenAddr,newListenAddr)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot change listen address setting on vnc graphics"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot change listen address setting on vnc graphics"));
             return -1;
         }
         if (STRNEQ_NULLABLE(oldListenNetwork,newListenNetwork)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot change listen network setting on vnc graphics"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot change listen network setting on vnc graphics"));
             return -1;
         }
         if (STRNEQ_NULLABLE(olddev->data.vnc.keymap, dev->data.vnc.keymap)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot change keymap setting on vnc graphics"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot change keymap setting on vnc graphics"));
             return -1;
         }
 
@@ -1530,23 +1530,23 @@ qemuDomainChangeGraphics(struct qemud_driver *driver,
              (olddev->data.spice.port != dev->data.spice.port)) ||
             (!dev->data.spice.autoport &&
              (olddev->data.spice.tlsPort != dev->data.spice.tlsPort))) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot change port settings on spice graphics"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot change port settings on spice graphics"));
             return -1;
         }
         if (STRNEQ_NULLABLE(oldListenAddr, newListenAddr)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot change listen address setting on spice graphics"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot change listen address setting on spice graphics"));
             return -1;
         }
         if (STRNEQ_NULLABLE(oldListenNetwork, newListenNetwork)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot change listen network setting on spice graphics"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot change listen network setting on spice graphics"));
             return -1;
         }
         if (STRNEQ_NULLABLE(olddev->data.spice.keymap,
                             dev->data.spice.keymap)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                             _("cannot change keymap setting on spice graphics"));
             return -1;
         }
@@ -1584,9 +1584,9 @@ qemuDomainChangeGraphics(struct qemud_driver *driver,
         break;
 
     default:
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to change config on '%s' graphics type"),
-                        virDomainGraphicsTypeToString(dev->type));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to change config on '%s' graphics type"),
+                       virDomainGraphicsTypeToString(dev->type));
         break;
     }
 
@@ -1646,33 +1646,33 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
     i = qemuFindDisk(vm->def, dev->data.disk->dst);
 
     if (i < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("disk %s not found"), dev->data.disk->dst);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("disk %s not found"), dev->data.disk->dst);
         goto cleanup;
     }
 
     detach = vm->def->disks[i];
 
     if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot hot unplug multifunction PCI device: %s"),
-                        dev->data.disk->dst);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot hot unplug multifunction PCI device: %s"),
+                       dev->data.disk->dst);
         goto cleanup;
     }
 
     if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unable to find cgroup for %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unable to find cgroup for %s"),
+                           vm->def->name);
             goto cleanup;
         }
     }
 
     if (!virDomainDeviceAddressIsValid(&detach->info,
                                        VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("device cannot be detached without a PCI address"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("device cannot be detached without a PCI address"));
         goto cleanup;
     }
 
@@ -1750,15 +1750,15 @@ int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
     i = qemuFindDisk(vm->def, dev->data.disk->dst);
 
     if (i < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("disk %s not found"), dev->data.disk->dst);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("disk %s not found"), dev->data.disk->dst);
         goto cleanup;
     }
 
     if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("Underlying qemu does not support %s disk removal"),
-                        virDomainDiskBusTypeToString(dev->data.disk->bus));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("Underlying qemu does not support %s disk removal"),
+                       virDomainDiskBusTypeToString(dev->data.disk->bus));
         goto cleanup;
     }
 
@@ -1766,9 +1766,9 @@ int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
 
     if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
         if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) != 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unable to find cgroup for %s"),
-                            vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unable to find cgroup for %s"),
+                           vm->def->name);
             goto cleanup;
         }
     }
@@ -1887,30 +1887,30 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
     }
 
     if (!detach) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("disk controller %s:%d not found"),
-                        virDomainControllerTypeToString(dev->data.controller->type),
-                        dev->data.controller->idx);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("disk controller %s:%d not found"),
+                       virDomainControllerTypeToString(dev->data.controller->type),
+                       dev->data.controller->idx);
         goto cleanup;
     }
 
     if (!virDomainDeviceAddressIsValid(&detach->info,
                                        VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("device cannot be detached without a PCI address"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("device cannot be detached without a PCI address"));
         goto cleanup;
     }
 
     if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot hot unplug multifunction PCI device: %s"),
-                        dev->data.disk->dst);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot hot unplug multifunction PCI device: %s"),
+                       dev->data.disk->dst);
         goto cleanup;
     }
 
     if (qemuDomainControllerIsBusy(vm, detach)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("device cannot be detached: device is busy"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("device cannot be detached: device is busy"));
         goto cleanup;
     }
 
@@ -1973,17 +1973,17 @@ qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
     pciDevice *activePci;
 
     if (qemuIsMultiFunctionDevice(vm->def, detach->info)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot hot unplug multifunction PCI device: %.4x:%.2x:%.2x.%.1x"),
-                        subsys->u.pci.domain, subsys->u.pci.bus,
-                        subsys->u.pci.slot,   subsys->u.pci.function);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot hot unplug multifunction PCI device: %.4x:%.2x:%.2x.%.1x"),
+                       subsys->u.pci.domain, subsys->u.pci.bus,
+                       subsys->u.pci.slot,   subsys->u.pci.function);
         return -1;
     }
 
     if (!virDomainDeviceAddressIsValid(detach->info,
                                        VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("device cannot be detached without a PCI address"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("device cannot be detached without a PCI address"));
         return -1;
     }
 
@@ -2042,14 +2042,14 @@ qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
     int ret;
 
     if (!detach->info->alias) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("device cannot be detached without a device alias"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("device cannot be detached without a device alias"));
         return -1;
     }
 
     if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("device cannot be detached with this QEMU version"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("device cannot be detached with this QEMU version"));
         return -1;
     }
 
@@ -2088,9 +2088,9 @@ int qemuDomainDetachThisHostDevice(struct qemud_driver *driver,
                 break;
         }
         if (idx >= vm->def->nhostdevs) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("device not found in hostdevs list (%d entries)"),
-                            vm->def->nhostdevs);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("device not found in hostdevs list (%d entries)"),
+                           vm->def->nhostdevs);
             return ret;
         }
     }
@@ -2103,9 +2103,9 @@ int qemuDomainDetachThisHostDevice(struct qemud_driver *driver,
         ret = qemuDomainDetachHostUsbDevice(driver, vm, detach);
         break;
     default:
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("hostdev subsys type '%s' not supported"),
-                        virDomainHostdevSubsysTypeToString(detach->source.subsys.type));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("hostdev subsys type '%s' not supported"),
+                       virDomainHostdevSubsysTypeToString(detach->source.subsys.type));
         return -1;
     }
 
@@ -2131,9 +2131,9 @@ int qemuDomainDetachHostDevice(struct qemud_driver *driver,
     int idx;
 
     if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("hostdev mode '%s' not supported"),
-                        virDomainHostdevModeTypeToString(hostdev->mode));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("hostdev mode '%s' not supported"),
+                       virDomainHostdevModeTypeToString(hostdev->mode));
         return -1;
     }
 
@@ -2142,25 +2142,25 @@ int qemuDomainDetachHostDevice(struct qemud_driver *driver,
     if (idx < 0) {
         switch(subsys->type) {
         case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("host pci device %.4x:%.2x:%.2x.%.1x not found"),
-                            subsys->u.pci.domain, subsys->u.pci.bus,
-                            subsys->u.pci.slot, subsys->u.pci.function);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("host pci device %.4x:%.2x:%.2x.%.1x not found"),
+                           subsys->u.pci.domain, subsys->u.pci.bus,
+                           subsys->u.pci.slot, subsys->u.pci.function);
             break;
         case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
             if (subsys->u.usb.bus && subsys->u.usb.device) {
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                _("host usb device %03d.%03d not found"),
-                                subsys->u.usb.bus, subsys->u.usb.device);
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               _("host usb device %03d.%03d not found"),
+                               subsys->u.usb.bus, subsys->u.usb.device);
             } else {
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                _("host usb device vendor=0x%.4x product=0x%.4x not found"),
-                                subsys->u.usb.vendor, subsys->u.usb.product);
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               _("host usb device vendor=0x%.4x product=0x%.4x not found"),
+                               subsys->u.usb.vendor, subsys->u.usb.product);
             }
             break;
         default:
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unexpected hostdev type %d"), subsys->type);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unexpected hostdev type %d"), subsys->type);
             break;
         }
         return -1;
@@ -2197,11 +2197,11 @@ qemuDomainDetachNetDevice(struct qemud_driver *driver,
     }
 
     if (!detach) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("network device %02x:%02x:%02x:%02x:%02x:%02x not found"),
-                        dev->data.net->mac.addr[0], dev->data.net->mac.addr[1],
-                        dev->data.net->mac.addr[2], dev->data.net->mac.addr[3],
-                        dev->data.net->mac.addr[4], dev->data.net->mac.addr[5]);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("network device %02x:%02x:%02x:%02x:%02x:%02x not found"),
+                       dev->data.net->mac.addr[0], dev->data.net->mac.addr[1],
+                       dev->data.net->mac.addr[2], dev->data.net->mac.addr[3],
+                       dev->data.net->mac.addr[4], dev->data.net->mac.addr[5]);
         goto cleanup;
     }
 
@@ -2214,21 +2214,21 @@ qemuDomainDetachNetDevice(struct qemud_driver *driver,
 
     if (!virDomainDeviceAddressIsValid(&detach->info,
                                        VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("device cannot be detached without a PCI address"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("device cannot be detached without a PCI address"));
         goto cleanup;
     }
 
     if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot hot unplug multifunction PCI device :%s"),
-                        dev->data.disk->dst);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot hot unplug multifunction PCI device :%s"),
+                       dev->data.disk->dst);
         goto cleanup;
     }
 
     if ((vlan = qemuDomainNetVLAN(detach)) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("unable to determine original VLAN"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("unable to determine original VLAN"));
         goto cleanup;
     }
 
@@ -2341,8 +2341,8 @@ qemuDomainChangeGraphicsPasswords(struct qemud_driver *driver,
 
     if (ret == -2) {
         if (type != VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Graphics password only supported for VNC"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Graphics password only supported for VNC"));
             ret = -1;
         } else {
             ret = qemuMonitorSetVNCPassword(priv->mon,
@@ -2367,8 +2367,8 @@ qemuDomainChangeGraphicsPasswords(struct qemud_driver *driver,
     if (ret == -2) {
         /* XXX we could fake this with a timer */
         if (auth->expires) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Expiry of passwords is not supported"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Expiry of passwords is not supported"));
             ret = -1;
         } else {
             ret = 0;
@@ -2405,9 +2405,9 @@ int qemuDomainDetachLease(struct qemud_driver *driver,
     int i;
 
     if ((i = virDomainLeaseIndex(vm->def, lease)) < 0) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("Lease %s in lockspace %s does not exist"),
-                        lease->key, NULLSTR(lease->lockspace));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("Lease %s in lockspace %s does not exist"),
+                       lease->key, NULLSTR(lease->lockspace));
         return -1;
     }
 
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index d176e7d..f8e2f90 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -164,16 +164,16 @@ qemuDomainExtractTLSSubject(const char *certdir)
         goto no_memory;
 
     if (virFileReadAll(certfile, 8192, &pemdata) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to read server cert %s"), certfile);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to read server cert %s"), certfile);
         goto error;
     }
 
     ret = gnutls_x509_crt_init(&cert);
     if (ret < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot initialize cert object: %s"),
-                        gnutls_strerror(ret));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot initialize cert object: %s"),
+                       gnutls_strerror(ret));
         goto error;
     }
 
@@ -182,9 +182,9 @@ qemuDomainExtractTLSSubject(const char *certdir)
 
     ret = gnutls_x509_crt_import(cert, &pemdatum, GNUTLS_X509_FMT_PEM);
     if (ret < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot load cert data from %s: %s"),
-                        certfile, gnutls_strerror(ret));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot load cert data from %s: %s"),
+                       certfile, gnutls_strerror(ret));
         goto error;
     }
 
@@ -277,8 +277,8 @@ qemuMigrationCookieNew(virDomainObjPtr dom)
     if (!(mig->localHostname = virGetHostname(NULL)))
         goto error;
     if (virGetHostUUID(mig->localHostuuid) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Unable to obtain host UUID"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Unable to obtain host UUID"));
         goto error;
     }
 
@@ -298,8 +298,8 @@ qemuMigrationCookieAddGraphics(qemuMigrationCookiePtr mig,
                                virDomainObjPtr dom)
 {
     if (mig->flags & QEMU_MIGRATION_COOKIE_GRAPHICS) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Migration graphics data already present"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Migration graphics data already present"));
         return -1;
     }
 
@@ -324,8 +324,8 @@ qemuMigrationCookieAddLockstate(qemuMigrationCookiePtr mig,
     qemuDomainObjPrivatePtr priv = dom->privateData;
 
     if (mig->flags & QEMU_MIGRATION_COOKIE_LOCKSTATE) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Migration lockstate data already present"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Migration lockstate data already present"));
         return -1;
     }
 
@@ -355,8 +355,8 @@ qemuMigrationCookieAddPersistent(qemuMigrationCookiePtr mig,
                                  virDomainObjPtr dom)
 {
     if (mig->flags & QEMU_MIGRATION_COOKIE_PERSISTENT) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Migration persistent data already present"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Migration persistent data already present"));
         return -1;
     }
 
@@ -474,32 +474,32 @@ qemuMigrationCookieGraphicsXMLParse(xmlXPathContextPtr ctxt)
         goto no_memory;
 
     if (!(tmp = virXPathString("string(./graphics/@type)", ctxt))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("missing type attribute in migration data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("missing type attribute in migration data"));
         goto error;
     }
     if ((grap->type = virDomainGraphicsTypeFromString(tmp)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unknown graphics type %s"), tmp);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unknown graphics type %s"), tmp);
         VIR_FREE(tmp);
         goto error;
     }
     VIR_FREE(tmp);
     if (virXPathInt("string(./graphics/@port)", ctxt, &grap->port) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("missing port attribute in migration data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("missing port attribute in migration data"));
         goto error;
     }
     if (grap->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
         if (virXPathInt("string(./graphics/@tlsPort)", ctxt, &grap->tlsPort) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("missing tlsPort attribute in migration data"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("missing tlsPort attribute in migration data"));
             goto error;
         }
     }
     if (!(grap->listen = virXPathString("string(./graphics/@listen)", ctxt))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("missing listen attribute in migration data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("missing listen attribute in migration data"));
         goto error;
     }
     /* Optional */
@@ -535,14 +535,14 @@ qemuMigrationCookieXMLParse(qemuMigrationCookiePtr mig,
 
     /* Extract domain name */
     if (!(tmp = virXPathString("string(./name[1])", ctxt))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("missing name element in migration data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("missing name element in migration data"));
         goto error;
     }
     if (STRNEQ(tmp, mig->name)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Incoming cookie data had unexpected name %s vs %s"),
-                        tmp, mig->name);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Incoming cookie data had unexpected name %s vs %s"),
+                       tmp, mig->name);
         goto error;
     }
     VIR_FREE(tmp);
@@ -550,45 +550,45 @@ qemuMigrationCookieXMLParse(qemuMigrationCookiePtr mig,
     /* Extract domain uuid */
     tmp = virXPathString("string(./uuid[1])", ctxt);
     if (!tmp) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("missing uuid element in migration data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("missing uuid element in migration data"));
         goto error;
     }
     virUUIDFormat(mig->uuid, uuidstr);
     if (STRNEQ(tmp, uuidstr)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Incoming cookie data had unexpected UUID %s vs %s"),
-                        tmp, uuidstr);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Incoming cookie data had unexpected UUID %s vs %s"),
+                       tmp, uuidstr);
     }
     VIR_FREE(tmp);
 
     /* Check & forbid "localhost" migration */
     if (!(mig->remoteHostname = virXPathString("string(./hostname[1])", ctxt))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("missing hostname element in migration data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("missing hostname element in migration data"));
         goto error;
     }
     if (STREQ(mig->remoteHostname, mig->localHostname)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Attempt to migrate guest to the same host %s"),
-                        mig->remoteHostname);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Attempt to migrate guest to the same host %s"),
+                       mig->remoteHostname);
         goto error;
     }
 
     if (!(tmp = virXPathString("string(./hostuuid[1])", ctxt))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("missing hostuuid element in migration data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("missing hostuuid element in migration data"));
         goto error;
     }
     if (virUUIDParse(tmp, mig->remoteHostuuid) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("malformed hostuuid element in migration data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("malformed hostuuid element in migration data"));
         goto error;
     }
     if (memcmp(mig->remoteHostuuid, mig->localHostuuid, VIR_UUID_BUFLEN) == 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Attempt to migrate guest to the same host %s"),
-                        tmp);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Attempt to migrate guest to the same host %s"),
+                       tmp);
         goto error;
     }
     VIR_FREE(tmp);
@@ -602,23 +602,23 @@ qemuMigrationCookieXMLParse(qemuMigrationCookiePtr mig,
         int val;
         char *str = virXMLPropString(nodes[i], "name");
         if (!str) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("missing feature name"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("missing feature name"));
             goto error;
         }
 
         if ((val = qemuMigrationCookieFlagTypeFromString(str)) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unknown migration cookie feature %s"),
-                            str);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unknown migration cookie feature %s"),
+                           str);
             VIR_FREE(str);
             goto error;
         }
 
         if ((flags & (1 << val)) == 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unsupported migration cookie feature %s"),
-                            str);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unsupported migration cookie feature %s"),
+                           str);
             VIR_FREE(str);
         }
         VIR_FREE(str);
@@ -634,8 +634,8 @@ qemuMigrationCookieXMLParse(qemuMigrationCookiePtr mig,
         virXPathBoolean("count(./lockstate) > 0", ctxt)) {
         mig->lockDriver = virXPathString("string(./lockstate[1]/@driver)", ctxt);
         if (!mig->lockDriver) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Missing lock driver name in migration cookie"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Missing lock driver name in migration cookie"));
             goto error;
         }
         mig->lockState = virXPathString("string(./lockstate[1]/leases[1])", ctxt);
@@ -646,10 +646,10 @@ qemuMigrationCookieXMLParse(qemuMigrationCookiePtr mig,
     if ((flags & QEMU_MIGRATION_COOKIE_PERSISTENT) &&
         virXPathBoolean("count(./domain) > 0", ctxt)) {
         if ((n = virXPathNodeSet("./domain", ctxt, &nodes)) > 1) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Too many domain elements in "
-                              "migration cookie: %d"),
-                            n);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Too many domain elements in "
+                             "migration cookie: %d"),
+                           n);
             goto error;
         }
         mig->persistent = virDomainDefParseNode(driver->caps, doc, nodes[0],
@@ -744,8 +744,8 @@ qemuMigrationEatCookie(struct qemud_driver *driver,
     /* Parse & validate incoming cookie (if any) */
     if (cookiein && cookieinlen &&
         cookiein[cookieinlen-1] != '\0') {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Migration cookie was not NULL terminated"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Migration cookie was not NULL terminated"));
         goto error;
     }
 
@@ -764,17 +764,17 @@ qemuMigrationEatCookie(struct qemud_driver *driver,
     if (mig->flags & QEMU_MIGRATION_COOKIE_LOCKSTATE) {
         if (!mig->lockDriver) {
             if (virLockManagerPluginUsesState(driver->lockManager)) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("Missing %s lock state for migration cookie"),
-                                virLockManagerPluginGetName(driver->lockManager));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Missing %s lock state for migration cookie"),
+                               virLockManagerPluginGetName(driver->lockManager));
                 goto error;
             }
         } else if (STRNEQ(mig->lockDriver,
                           virLockManagerPluginGetName(driver->lockManager))) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Source host lock driver %s different from target %s"),
-                            mig->lockDriver,
-                            virLockManagerPluginGetName(driver->lockManager));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Source host lock driver %s different from target %s"),
+                           mig->lockDriver,
+                           virLockManagerPluginGetName(driver->lockManager));
             goto error;
         }
     }
@@ -803,23 +803,23 @@ qemuMigrationIsAllowed(struct qemud_driver *driver, virDomainObjPtr vm,
 
     if (vm) {
         if (qemuProcessAutoDestroyActive(driver, vm)) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("domain is marked for auto destroy"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("domain is marked for auto destroy"));
             return false;
         }
         if ((nsnapshots = virDomainSnapshotObjListNum(&vm->snapshots, NULL,
                                                       0))) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("cannot migrate domain with %d snapshots"),
-                            nsnapshots);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("cannot migrate domain with %d snapshots"),
+                           nsnapshots);
             return false;
         }
 
         def = vm->def;
     }
     if (def->nhostdevs > 0) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-            "%s", _("Domain with assigned host devices cannot be migrated"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("Domain with assigned host devices cannot be migrated"));
         return false;
     }
 
@@ -852,9 +852,9 @@ qemuMigrationIsSafe(virDomainDefPtr def)
                 continue;
             }
 
-            qemuReportError(VIR_ERR_MIGRATE_UNSAFE, "%s",
-                            _("Migration may lead to data corruption if disks"
-                              " use cache != none"));
+            virReportError(VIR_ERR_MIGRATE_UNSAFE, "%s",
+                           _("Migration may lead to data corruption if disks"
+                             " use cache != none"));
             return false;
         }
     }
@@ -922,8 +922,8 @@ qemuMigrationUpdateJobStatus(struct qemud_driver *driver,
     switch (status) {
     case QEMU_MONITOR_MIGRATION_STATUS_INACTIVE:
         priv->job.info.type = VIR_DOMAIN_JOB_NONE;
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("%s: %s"), job, _("is not active"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("%s: %s"), job, _("is not active"));
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_ACTIVE:
@@ -945,14 +945,14 @@ qemuMigrationUpdateJobStatus(struct qemud_driver *driver,
 
     case QEMU_MONITOR_MIGRATION_STATUS_ERROR:
         priv->job.info.type = VIR_DOMAIN_JOB_FAILED;
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("%s: %s"), job, _("unexpectedly failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("%s: %s"), job, _("unexpectedly failed"));
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_CANCELLED:
         priv->job.info.type = VIR_DOMAIN_JOB_CANCELLED;
-        qemuReportError(VIR_ERR_OPERATION_ABORTED,
-                        _("%s: %s"), job, _("canceled by client"));
+        virReportError(VIR_ERR_OPERATION_ABORTED,
+                       _("%s: %s"), job, _("canceled by client"));
         break;
     }
 
@@ -992,8 +992,8 @@ qemuMigrationWaitForCompletion(struct qemud_driver *driver, virDomainObjPtr vm,
             goto cleanup;
 
         if (dconn && virConnectIsAlive(dconn) <= 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                            _("Lost connection to destination host"));
+            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                           _("Lost connection to destination host"));
             goto cleanup;
         }
 
@@ -1158,8 +1158,8 @@ char *qemuMigrationBegin(struct qemud_driver *driver,
             goto cleanup;
 
         if (STRNEQ(def->name, vm->def->name)) {
-            qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                            _("target domain name doesn't match source name"));
+            virReportError(VIR_ERR_INVALID_ARG, "%s",
+                           _("target domain name doesn't match source name"));
             goto cleanup;
         }
 
@@ -1371,8 +1371,8 @@ qemuMigrationPrepareAny(struct qemud_driver *driver,
      */
     if (qemuMigrationJobContinue(vm) == 0) {
         vm = NULL;
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("domain disappeared"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("domain disappeared"));
         goto cleanup;
     }
 
@@ -1480,9 +1480,9 @@ qemuMigrationPrepareDirect(struct qemud_driver *driver,
             goto cleanup;
 
         if (STRPREFIX(hostname, "localhost")) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("hostname on destination resolved to localhost,"
-                              " but migration requires an FQDN"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("hostname on destination resolved to localhost,"
+                             " but migration requires an FQDN"));
             goto cleanup;
         }
 
@@ -1502,9 +1502,9 @@ qemuMigrationPrepareDirect(struct qemud_driver *driver,
          * characters in hostname part don't matter.
          */
         if (!STRPREFIX (uri_in, "tcp:")) {
-            qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                            _("only tcp URIs are supported for KVM/QEMU"
-                              " migrations"));
+            virReportError(VIR_ERR_INVALID_ARG, "%s",
+                           _("only tcp URIs are supported for KVM/QEMU"
+                             " migrations"));
             goto cleanup;
         }
 
@@ -1526,8 +1526,8 @@ qemuMigrationPrepareDirect(struct qemud_driver *driver,
             p++; /* definitely has a ':' in it, see above */
             this_port = virParseNumber (&p);
             if (this_port == -1 || p-uri_in != strlen (uri_in)) {
-                qemuReportError(VIR_ERR_INVALID_ARG,
-                                "%s", _("URI ended with incorrect ':port'"));
+                virReportError(VIR_ERR_INVALID_ARG,
+                               "%s", _("URI ended with incorrect ':port'"));
                 goto cleanup;
             }
         }
@@ -1850,10 +1850,10 @@ qemuMigrationRun(struct qemud_driver *driver,
 
     if (virLockManagerPluginUsesState(driver->lockManager) &&
         !cookieout) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Migration with lock driver %s requires"
-                          " cookie support"),
-                        virLockManagerPluginGetName(driver->lockManager));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Migration with lock driver %s requires"
+                         " cookie support"),
+                       virLockManagerPluginGetName(driver->lockManager));
         return -1;
     }
 
@@ -1932,8 +1932,8 @@ qemuMigrationRun(struct qemud_driver *driver,
     ret = -1;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("guest unexpectedly quit"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("guest unexpectedly quit"));
         goto cleanup;
     }
 
@@ -2102,8 +2102,8 @@ static int doTunnelMigrate(struct qemud_driver *driver,
     if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
         !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
         !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("Source qemu is too old to support tunnelled migration"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("Source qemu is too old to support tunnelled migration"));
         return -1;
     }
 
@@ -2233,15 +2233,15 @@ static int doPeer2PeerMigrate2(struct qemud_driver *driver,
      * in qemuDomainObjEnterRemoteWithDriver, so check again
      */
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("guest unexpectedly quit"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("guest unexpectedly quit"));
         goto cleanup;
     }
 
     if (!(flags & VIR_MIGRATE_TUNNELLED) &&
         (uri_out == NULL)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("domainMigratePrepare2 did not set uri"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("domainMigratePrepare2 did not set uri"));
         cancelled = 1;
         goto finish;
     }
@@ -2378,8 +2378,8 @@ static int doPeer2PeerMigrate3(struct qemud_driver *driver,
 
     if (!(flags & VIR_MIGRATE_TUNNELLED) &&
         (uri_out == NULL)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("domainMigratePrepare3 did not set uri"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("domainMigratePrepare3 did not set uri"));
         cancelled = 1;
         goto finish;
     }
@@ -2529,8 +2529,8 @@ static int doPeer2PeerMigrate(struct qemud_driver *driver,
     dconn = virConnectOpen(dconnuri);
     qemuDomainObjExitRemoteWithDriver(driver, vm);
     if (dconn == NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("Failed to connect to remote libvirt URI %s"), dconnuri);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("Failed to connect to remote libvirt URI %s"), dconnuri);
         return -1;
     }
 
@@ -2550,15 +2550,15 @@ static int doPeer2PeerMigrate(struct qemud_driver *driver,
     qemuDomainObjExitRemoteWithDriver(driver, vm);
 
     if (!p2p) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("Destination libvirt does not support peer-to-peer migration protocol"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("Destination libvirt does not support peer-to-peer migration protocol"));
         goto cleanup;
     }
 
     /* domain may have been stopped while we were talking to remote daemon */
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("guest unexpectedly quit"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("guest unexpectedly quit"));
         goto cleanup;
     }
 
@@ -2620,8 +2620,8 @@ qemuMigrationPerformJob(struct qemud_driver *driver,
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("domain is not running"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("domain is not running"));
         goto endjob;
     }
 
@@ -2816,8 +2816,8 @@ qemuMigrationPerform(struct qemud_driver *driver,
 
     if ((flags & (VIR_MIGRATE_TUNNELLED | VIR_MIGRATE_PEER2PEER))) {
         if (cookieinlen) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            "%s", _("received unexpected cookie with P2P migration"));
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           "%s", _("received unexpected cookie with P2P migration"));
             return -1;
         }
 
@@ -2827,8 +2827,8 @@ qemuMigrationPerform(struct qemud_driver *driver,
                                        v3proto);
     } else {
         if (dconnuri) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("Unexpected dconnuri parameter with non-peer2peer migration"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("Unexpected dconnuri parameter with non-peer2peer migration"));
             return -1;
         }
 
@@ -2863,9 +2863,9 @@ qemuMigrationVPAssociatePortProfiles(virDomainDefPtr def) {
                                                def->uuid,
                                                VIR_NETDEV_VPORT_PROFILE_OP_MIGRATE_IN_FINISH,
                                                false) < 0) {
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                _("Port profile Associate failed for %s"),
-                                net->ifname);
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               _("Port profile Associate failed for %s"),
+                               net->ifname);
                 goto err_exit;
             }
             VIR_DEBUG("Port profile Associate succeeded for %s", net->ifname);
@@ -2943,8 +2943,8 @@ qemuMigrationFinish(struct qemud_driver *driver,
      */
     if (retcode == 0) {
         if (!virDomainObjIsActive(vm)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("guest unexpectedly quit"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("guest unexpectedly quit"));
             goto endjob;
         }
 
@@ -2990,8 +2990,8 @@ qemuMigrationFinish(struct qemud_driver *driver,
                         vm->persistent = 0;
                 }
                 if (!vmdef)
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("can't get vmdef"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("can't get vmdef"));
                 goto endjob;
             }
 
@@ -3014,8 +3014,8 @@ qemuMigrationFinish(struct qemud_driver *driver,
                                      VIR_DOMAIN_RUNNING_MIGRATED,
                                      QEMU_ASYNC_JOB_MIGRATION_IN) < 0) {
                 if (virGetLastError() == NULL)
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    "%s", _("resume operation failed"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   "%s", _("resume operation failed"));
                 /* Need to save the current error, in case shutting
                  * down the process overwrites it
                  */
@@ -3144,8 +3144,8 @@ int qemuMigrationConfirm(struct qemud_driver *driver,
                                  VIR_DOMAIN_RUNNING_MIGRATED,
                                  QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) {
             if (virGetLastError() == NULL)
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                "%s", _("resume operation failed"));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               "%s", _("resume operation failed"));
             goto cleanup;
         }
 
@@ -3214,9 +3214,9 @@ qemuMigrationToFile(struct qemud_driver *driver, virDomainObjPtr vm,
                                        VIR_CGROUP_CONTROLLER_DEVICES)) {
             if (virCgroupForDomain(driver->cgroup, vm->def->name,
                                    &cgroup, 0) != 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("Unable to find cgroup for %s"),
-                                vm->def->name);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Unable to find cgroup for %s"),
+                               vm->def->name);
                 goto cleanup;
             }
             rc = virCgroupAllowDevicePath(cgroup, path,
@@ -3401,7 +3401,7 @@ qemuMigrationJobIsActive(virDomainObjPtr vm,
         else
             msg = _("domain '%s' is not being migrated");
 
-        qemuReportError(VIR_ERR_OPERATION_INVALID, msg, vm->def->name);
+        virReportError(VIR_ERR_OPERATION_INVALID, msg, vm->def->name);
         return false;
     }
     return true;
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 42a5d6c..ac78b29 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -286,8 +286,8 @@ qemuMonitorOpenUnix(const char *monitor, pid_t cpid)
     memset(&addr, 0, sizeof(addr));
     addr.sun_family = AF_UNIX;
     if (virStrcpyStatic(addr.sun_path, monitor) == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Monitor path %s too big for destination"), monitor);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Monitor path %s too big for destination"), monitor);
         goto error;
     }
 
@@ -329,8 +329,8 @@ qemuMonitorOpenPty(const char *monitor)
     int monfd;
 
     if ((monfd = open(monitor, O_RDWR)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Unable to open monitor path %s"), monitor);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Unable to open monitor path %s"), monitor);
         return -1;
     }
 
@@ -451,8 +451,8 @@ qemuMonitorIOWrite(qemuMonitorPtr mon)
         return 0;
 
     if (mon->msg->txFD != -1 && !mon->hasSendFD) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Monitor does not support sending of file descriptors"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Monitor does not support sending of file descriptors"));
         return -1;
     }
 
@@ -577,9 +577,9 @@ qemuMonitorIO(int watch, int fd, int events, void *opaque) {
     if (mon->fd != fd || mon->watch != watch) {
         if (events & (VIR_EVENT_HANDLE_HANGUP | VIR_EVENT_HANDLE_ERROR))
             eof = true;
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("event from unexpected fd %d!=%d / watch %d!=%d"),
-                        mon->fd, fd, mon->watch, watch);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("event from unexpected fd %d!=%d / watch %d!=%d"),
+                       mon->fd, fd, mon->watch, watch);
         error = true;
     } else if (mon->lastError.code != VIR_ERR_OK) {
         if (events & (VIR_EVENT_HANDLE_HANGUP | VIR_EVENT_HANDLE_ERROR))
@@ -612,23 +612,23 @@ qemuMonitorIO(int watch, int fd, int events, void *opaque) {
 
         if (!error &&
             events & VIR_EVENT_HANDLE_HANGUP) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("End of file from monitor"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("End of file from monitor"));
             eof = 1;
             events &= ~VIR_EVENT_HANDLE_HANGUP;
         }
 
         if (!error && !eof &&
             events & VIR_EVENT_HANDLE_ERROR) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Invalid file descriptor while waiting for monitor"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Invalid file descriptor while waiting for monitor"));
             eof = 1;
             events &= ~VIR_EVENT_HANDLE_ERROR;
         }
         if (!error && events) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unhandled event %d for monitor fd %d"),
-                            events, mon->fd);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unhandled event %d for monitor fd %d"),
+                           events, mon->fd);
             error = 1;
         }
     }
@@ -640,8 +640,8 @@ qemuMonitorIO(int watch, int fd, int events, void *opaque) {
         } else {
             virErrorPtr err = virGetLastError();
             if (!err)
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("Error while processing monitor IO"));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Error while processing monitor IO"));
             virCopyLastError(&mon->lastError);
             virResetLastError();
         }
@@ -698,8 +698,8 @@ qemuMonitorOpen(virDomainObjPtr vm,
     qemuMonitorPtr mon;
 
     if (!cb || !cb->eofNotify) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("EOF notify callback must be supplied"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("EOF notify callback must be supplied"));
         return NULL;
     }
 
@@ -709,14 +709,14 @@ qemuMonitorOpen(virDomainObjPtr vm,
     }
 
     if (virMutexInit(&mon->lock) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("cannot initialize monitor mutex"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cannot initialize monitor mutex"));
         VIR_FREE(mon);
         return NULL;
     }
     if (virCondInit(&mon->notify) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("cannot initialize monitor condition"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cannot initialize monitor condition"));
         virMutexDestroy(&mon->lock);
         VIR_FREE(mon);
         return NULL;
@@ -739,22 +739,22 @@ qemuMonitorOpen(virDomainObjPtr vm,
         break;
 
     default:
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to handle monitor type: %s"),
-                        virDomainChrTypeToString(config->type));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to handle monitor type: %s"),
+                       virDomainChrTypeToString(config->type));
         goto cleanup;
     }
 
     if (mon->fd == -1) goto cleanup;
 
     if (virSetCloseExec(mon->fd) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("Unable to set monitor close-on-exec flag"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Unable to set monitor close-on-exec flag"));
         goto cleanup;
     }
     if (virSetNonBlock(mon->fd) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("Unable to put monitor into non-blocking mode"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Unable to put monitor into non-blocking mode"));
         goto cleanup;
     }
 
@@ -765,8 +765,8 @@ qemuMonitorOpen(virDomainObjPtr vm,
                                         VIR_EVENT_HANDLE_READABLE,
                                         qemuMonitorIO,
                                         mon, qemuMonitorUnwatch)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("unable to register monitor events"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("unable to register monitor events"));
         goto cleanup;
     }
     qemuMonitorRef(mon);
@@ -813,8 +813,8 @@ void qemuMonitorClose(qemuMonitorPtr mon)
         if (mon->lastError.code == VIR_ERR_OK) {
             virErrorPtr err = virSaveLastError();
 
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("Qemu monitor was closed"));
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("Qemu monitor was closed"));
             virCopyLastError(&mon->lastError);
             if (err) {
                 virSetError(err);
@@ -866,8 +866,8 @@ int qemuMonitorSend(qemuMonitorPtr mon,
 
     while (!mon->msg->finished) {
         if (virCondWait(&mon->notify, &mon->lock) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Unable to wait on monitor condition"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Unable to wait on monitor condition"));
             goto cleanup;
         }
     }
@@ -902,8 +902,8 @@ int qemuMonitorHMPCommandWithFd(qemuMonitorPtr mon,
         json_cmd = qemuMonitorUnescapeArg(cmd);
         if (!json_cmd) {
             VIR_DEBUG("Could not unescape command: %s", cmd);
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Unable to unescape command"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Unable to unescape command"));
             goto cleanup;
         }
         ret = qemuMonitorJSONHumanCommandWithFd(mon, json_cmd, scm_fd, reply);
@@ -1105,8 +1105,8 @@ int qemuMonitorSetCapabilities(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1155,8 +1155,8 @@ qemuMonitorStartCPUs(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1175,8 +1175,8 @@ qemuMonitorStopCPUs(qemuMonitorPtr mon)
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1197,8 +1197,8 @@ qemuMonitorGetStatus(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p, running=%p, reason=%p", mon, running, reason);
 
     if (!mon || !running) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("both monitor and running must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("both monitor and running must not be NULL"));
         return -1;
     }
 
@@ -1216,8 +1216,8 @@ int qemuMonitorSystemPowerdown(qemuMonitorPtr mon)
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1235,8 +1235,8 @@ int qemuMonitorSystemReset(qemuMonitorPtr mon)
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1255,8 +1255,8 @@ int qemuMonitorGetCPUInfo(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1275,8 +1275,8 @@ int qemuMonitorSetLink(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p, name=%p:%s, state=%u", mon, name, name, state);
 
     if (!mon || !name) {
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("monitor || name must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("monitor || name must not be NULL"));
         return -1;
     }
 
@@ -1294,8 +1294,8 @@ int qemuMonitorGetVirtType(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1314,8 +1314,8 @@ int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1335,8 +1335,8 @@ int qemuMonitorGetMemoryStats(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p stats=%p nstats=%u", mon, stats, nr_stats);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1353,8 +1353,8 @@ qemuMonitorBlockIOStatusToError(const char *status)
     int st = qemuMonitorBlockIOStatusTypeFromString(status);
 
     if (st < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unknown block IO status: %s"), status);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unknown block IO status: %s"), status);
         return -1;
     }
 
@@ -1382,8 +1382,8 @@ qemuMonitorGetBlockInfo(qemuMonitorPtr mon)
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return NULL;
     }
 
@@ -1412,9 +1412,9 @@ qemuMonitorBlockInfoLookup(virHashTablePtr blockInfo,
     VIR_DEBUG("blockInfo=%p dev=%s", blockInfo, NULLSTR(devname));
 
     if (!(info = virHashLookup(blockInfo, devname))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot find info for device '%s'"),
-                        NULLSTR(devname));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot find info for device '%s'"),
+                       NULLSTR(devname));
     }
 
     return info;
@@ -1436,8 +1436,8 @@ int qemuMonitorGetBlockStatsInfo(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p dev=%s", mon, dev_name);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1472,8 +1472,8 @@ int qemuMonitorGetBlockStatsParamsNumber(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p nparams=%p", mon, nparams);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1525,8 +1525,8 @@ int qemuMonitorSetVNCPassword(qemuMonitorPtr mon,
           mon, password);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1548,9 +1548,9 @@ static const char* qemuMonitorTypeToProtocol(int type)
     case VIR_DOMAIN_GRAPHICS_TYPE_SPICE:
         return "spice";
     default:
-        qemuReportError(VIR_ERR_INVALID_ARG,
-                        _("unsupported protocol type %s"),
-                        virDomainGraphicsTypeToString(type));
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("unsupported protocol type %s"),
+                       virDomainGraphicsTypeToString(type));
         return NULL;
     }
 }
@@ -1571,8 +1571,8 @@ int qemuMonitorSetPassword(qemuMonitorPtr mon,
           mon, protocol, password, action_if_connected);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1603,8 +1603,8 @@ int qemuMonitorExpirePassword(qemuMonitorPtr mon,
           mon, protocol, expire_time);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1625,8 +1625,8 @@ int qemuMonitorSetBalloon(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p newmem=%lu", mon, newmem);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1644,8 +1644,8 @@ int qemuMonitorSetCPU(qemuMonitorPtr mon, int cpu, int online)
     VIR_DEBUG("mon=%p cpu=%d online=%d", mon, cpu, online);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1665,8 +1665,8 @@ int qemuMonitorEjectMedia(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p dev_name=%s force=%d", mon, dev_name, force);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1688,8 +1688,8 @@ int qemuMonitorChangeMedia(qemuMonitorPtr mon,
           mon, dev_name, newmedia, format);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1711,8 +1711,8 @@ int qemuMonitorSaveVirtualMemory(qemuMonitorPtr mon,
           mon, offset, length, path);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1733,8 +1733,8 @@ int qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon,
           mon, offset, length, path);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1753,8 +1753,8 @@ int qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p bandwidth=%lu", mon, bandwidth);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1773,8 +1773,8 @@ int qemuMonitorSetMigrationDowntime(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p downtime=%llu", mon, downtime);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1796,8 +1796,8 @@ int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1824,8 +1824,8 @@ int qemuMonitorMigrateToFd(qemuMonitorPtr mon,
           mon, fd, flags);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1857,8 +1857,8 @@ int qemuMonitorMigrateToHost(qemuMonitorPtr mon,
           mon, hostname, port, flags);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1889,8 +1889,8 @@ int qemuMonitorMigrateToCommand(qemuMonitorPtr mon,
           mon, argv, flags);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -1931,15 +1931,15 @@ int qemuMonitorMigrateToFile(qemuMonitorPtr mon,
           mon, argv, target, offset, flags);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
     if (offset % QEMU_MONITOR_MIGRATE_TO_FILE_BS) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("file offset must be a multiple of %llu"),
-                        QEMU_MONITOR_MIGRATE_TO_FILE_BS);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("file offset must be a multiple of %llu"),
+                       QEMU_MONITOR_MIGRATE_TO_FILE_BS);
         return -1;
     }
 
@@ -1996,8 +1996,8 @@ int qemuMonitorMigrateToUnix(qemuMonitorPtr mon,
           mon, unixfile, flags);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2021,8 +2021,8 @@ int qemuMonitorMigrateCancel(qemuMonitorPtr mon)
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2044,8 +2044,8 @@ int qemuMonitorDumpToFd(qemuMonitorPtr mon,
               mon, fd, flags, begin, length);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2053,8 +2053,8 @@ int qemuMonitorDumpToFd(qemuMonitorPtr mon,
         /* We don't have qemuMonitorTextDump(), so we should check mon->json
          * here.
          */
-        qemuReportError(VIR_ERR_NO_SUPPORT, "%s",
-                        _("dump-guest-memory is not supported in text mode"));
+        virReportError(VIR_ERR_NO_SUPPORT, "%s",
+                       _("dump-guest-memory is not supported in text mode"));
         return -1;
     }
 
@@ -2108,8 +2108,8 @@ int qemuMonitorAddUSBDisk(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p path=%s", mon, path);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2129,8 +2129,8 @@ int qemuMonitorAddUSBDeviceExact(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p bus=%d dev=%d", mon, bus, dev);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2150,8 +2150,8 @@ int qemuMonitorAddUSBDeviceMatch(qemuMonitorPtr mon,
           mon, vendor, product);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2173,8 +2173,8 @@ int qemuMonitorAddPCIHostDevice(qemuMonitorPtr mon,
           hostAddr->domain, hostAddr->bus, hostAddr->slot, hostAddr->function);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2196,8 +2196,8 @@ int qemuMonitorAddPCIDisk(qemuMonitorPtr mon,
           mon, path, bus);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2217,8 +2217,8 @@ int qemuMonitorAddPCINetwork(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p nicstr=%s", mon, nicstr);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2239,8 +2239,8 @@ int qemuMonitorRemovePCIDevice(qemuMonitorPtr mon,
           guestAddr->slot, guestAddr->function);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2261,21 +2261,21 @@ int qemuMonitorSendFileHandle(qemuMonitorPtr mon,
           mon, fdname, fd);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
     if (fd < 0) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("fd must be valid"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("fd must be valid"));
         return -1;
     }
 
     if (!mon->hasSendFD) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                        _("qemu is not using a unix socket monitor, "
-                          "cannot send fd %s"), fdname);
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("qemu is not using a unix socket monitor, "
+                         "cannot send fd %s"), fdname);
         return -1;
     }
 
@@ -2299,8 +2299,8 @@ int qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
     error = virSaveLastError();
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         goto cleanup;
     }
 
@@ -2330,8 +2330,8 @@ int qemuMonitorAddHostNetwork(qemuMonitorPtr mon,
               vhostfd, NULLSTR(vhostfd_name));
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2369,8 +2369,8 @@ int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon,
           mon, netname);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2394,8 +2394,8 @@ int qemuMonitorAddNetdev(qemuMonitorPtr mon,
               vhostfd, NULLSTR(vhostfd_name));
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2431,8 +2431,8 @@ int qemuMonitorRemoveNetdev(qemuMonitorPtr mon,
           mon, alias);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2452,8 +2452,8 @@ int qemuMonitorGetPtyPaths(qemuMonitorPtr mon,
           mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2473,8 +2473,8 @@ int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2499,8 +2499,8 @@ int qemuMonitorAttachDrive(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2519,8 +2519,8 @@ int qemuMonitorGetAllPCIAddresses(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2538,8 +2538,8 @@ int qemuMonitorDriveDel(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2557,8 +2557,8 @@ int qemuMonitorDelDevice(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2580,8 +2580,8 @@ int qemuMonitorAddDeviceWithFd(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2614,8 +2614,8 @@ int qemuMonitorAddDrive(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2635,8 +2635,8 @@ int qemuMonitorSetDrivePassphrase(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2654,8 +2654,8 @@ int qemuMonitorCreateSnapshot(qemuMonitorPtr mon, const char *name)
     VIR_DEBUG("mon=%p, name=%s",mon,name);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2673,8 +2673,8 @@ int qemuMonitorLoadSnapshot(qemuMonitorPtr mon, const char *name)
     VIR_DEBUG("mon=%p, name=%s",mon,name);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2692,8 +2692,8 @@ int qemuMonitorDeleteSnapshot(qemuMonitorPtr mon, const char *name)
     VIR_DEBUG("mon=%p, name=%s",mon,name);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2718,8 +2718,8 @@ qemuMonitorDiskSnapshot(qemuMonitorPtr mon, virJSONValuePtr actions,
               mon, actions, device, file, format, reuse);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2728,8 +2728,8 @@ qemuMonitorDiskSnapshot(qemuMonitorPtr mon, virJSONValuePtr actions,
                                           reuse);
     } else {
         if (actions || STRNEQ(format, "qcow2") || reuse) {
-            qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                            _("text monitor lacks several snapshot features"));
+            virReportError(VIR_ERR_INVALID_ARG, "%s",
+                           _("text monitor lacks several snapshot features"));
             return -1;
         }
         ret = qemuMonitorTextDiskSnapshot(mon, device, file);
@@ -2748,8 +2748,8 @@ qemuMonitorTransaction(qemuMonitorPtr mon, virJSONValuePtr actions)
     if (mon->json)
         ret = qemuMonitorJSONTransaction(mon, actions);
     else
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("transaction requires JSON monitor"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("transaction requires JSON monitor"));
     return ret;
 }
 
@@ -2808,8 +2808,8 @@ int qemuMonitorScreendump(qemuMonitorPtr mon,
     VIR_DEBUG("mon=%p, file=%s", mon, file);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG,"%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG,"%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2839,9 +2839,9 @@ int qemuMonitorBlockJob(qemuMonitorPtr mon,
     /* Convert bandwidth MiB to bytes */
     speed = bandwidth;
     if (speed > ULLONG_MAX / 1024 / 1024) {
-        qemuReportError(VIR_ERR_OVERFLOW,
-                        _("bandwidth must be less than %llu"),
-                        ULLONG_MAX / 1024 / 1024);
+        virReportError(VIR_ERR_OVERFLOW,
+                       _("bandwidth must be less than %llu"),
+                       ULLONG_MAX / 1024 / 1024);
         return -1;
     }
     speed <<= 20;
@@ -2850,8 +2850,8 @@ int qemuMonitorBlockJob(qemuMonitorPtr mon,
         ret = qemuMonitorJSONBlockJob(mon, device, base, speed, info, mode,
                                       modern);
     else
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("block jobs require JSON monitor"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("block jobs require JSON monitor"));
     return ret;
 }
 
@@ -2950,8 +2950,8 @@ int qemuMonitorOpenGraphics(qemuMonitorPtr mon,
     int ret;
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
@@ -2976,14 +2976,14 @@ int qemuMonitorSystemWakeup(qemuMonitorPtr mon)
     VIR_DEBUG("mon=%p", mon);
 
     if (!mon) {
-        qemuReportError(VIR_ERR_INVALID_ARG, "%s",
-                        _("monitor must not be NULL"));
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("monitor must not be NULL"));
         return -1;
     }
 
     if (!mon->json) {
-        qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                        _("JSON monitor is required"));
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("JSON monitor is required"));
         return -1;
     }
 
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index a99bf60..5c16284 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -147,8 +147,8 @@ qemuMonitorJSONIOProcessLine(qemuMonitorPtr mon,
         goto cleanup;
 
     if (obj->type != VIR_JSON_TYPE_OBJECT) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Parsed JSON reply '%s' isn't an object"), line);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Parsed JSON reply '%s' isn't an object"), line);
         goto cleanup;
     }
 
@@ -168,12 +168,12 @@ qemuMonitorJSONIOProcessLine(qemuMonitorPtr mon,
             obj = NULL;
             ret = 0;
         } else {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Unexpected JSON reply '%s'"), line);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unexpected JSON reply '%s'"), line);
         }
     } else {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Unknown JSON reply '%s'"), line);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Unknown JSON reply '%s'"), line);
     }
 
 cleanup:
@@ -237,8 +237,8 @@ qemuMonitorJSONCommandWithFd(qemuMonitorPtr mon,
         if (!(id = qemuMonitorNextCommandID(mon)))
             goto cleanup;
         if (virJSONValueObjectAppendString(cmd, "id", id) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Unable to append command 'id' string"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Unable to append command 'id' string"));
             goto cleanup;
         }
     }
@@ -264,8 +264,8 @@ qemuMonitorJSONCommandWithFd(qemuMonitorPtr mon,
 
     if (ret == 0) {
         if (!msg.rxObject) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Missing monitor reply object"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Missing monitor reply object"));
             ret = -1;
         } else {
             *reply = msg.rxObject;
@@ -337,14 +337,14 @@ qemuMonitorJSONCheckError(virJSONValuePtr cmd,
 
         /* Only send the user the command name + friendly error */
         if (!error)
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unable to execute QEMU command '%s'"),
-                            qemuMonitorJSONCommandName(cmd));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unable to execute QEMU command '%s'"),
+                           qemuMonitorJSONCommandName(cmd));
         else
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unable to execute QEMU command '%s': %s"),
-                            qemuMonitorJSONCommandName(cmd),
-                            qemuMonitorJSONStringifyError(error));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unable to execute QEMU command '%s': %s"),
+                           qemuMonitorJSONCommandName(cmd),
+                           qemuMonitorJSONStringifyError(error));
 
         VIR_FREE(cmdstr);
         VIR_FREE(replystr);
@@ -355,9 +355,9 @@ qemuMonitorJSONCheckError(virJSONValuePtr cmd,
 
         VIR_DEBUG("Neither 'return' nor 'error' is set in the JSON reply %s: %s",
                   cmdstr, replystr);
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to execute QEMU command '%s'"),
-                        qemuMonitorJSONCommandName(cmd));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to execute QEMU command '%s'"),
+                       qemuMonitorJSONCommandName(cmd));
         VIR_FREE(cmdstr);
         VIR_FREE(replystr);
         return -1;
@@ -415,9 +415,9 @@ qemuMonitorJSONMakeCommandRaw(bool wrap, const char *cmdname, ...)
         char type;
 
         if (strlen(key) < 3) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("argument key '%s' is too short, missing type prefix"),
-                            key);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("argument key '%s' is too short, missing type prefix"),
+                           key);
             goto error;
         }
 
@@ -434,9 +434,9 @@ qemuMonitorJSONMakeCommandRaw(bool wrap, const char *cmdname, ...)
         case 's': {
             char *val = va_arg(args, char *);
             if (!val) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("argument key '%s' must not have null value"),
-                                key);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("argument key '%s' must not have null value"),
+                               key);
                 goto error;
             }
             ret = virJSONValueObjectAppendString(jargs, key, val);
@@ -478,8 +478,8 @@ qemuMonitorJSONMakeCommandRaw(bool wrap, const char *cmdname, ...)
             ret = virJSONValueObjectAppend(jargs, key, val);
         }   break;
         default:
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unsupported data type '%c' for arg '%s'"), type, key - 2);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unsupported data type '%c' for arg '%s'"), type, key - 2);
             goto error;
         }
         if (ret < 0)
@@ -538,8 +538,8 @@ qemuMonitorJSONKeywordStringToJSON(const char *str, const char *firstkeyword)
     for (i = 0 ; i < nkeywords ; i++) {
         if (values[i] == NULL) {
             if (i != 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("unexpected empty keyword in %s"), str);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("unexpected empty keyword in %s"), str);
                 goto error;
             } else {
                 /* This 3rd arg isn't a typo - the way the parser works is
@@ -912,8 +912,8 @@ qemuMonitorJSONHumanCommandWithFd(qemuMonitorPtr mon,
         goto cleanup;
 
     if (!(obj = virJSONValueObjectGet(reply, "return"))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("human monitor command was missing return data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("human monitor command was missing return data"));
         goto cleanup;
     }
 
@@ -1153,14 +1153,14 @@ qemuMonitorJSONGetStatus(qemuMonitorPtr mon,
     ret = -1;
 
     if (!(data = virJSONValueObjectGet(reply, "return"))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("query-status reply was missing return data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("query-status reply was missing return data"));
         goto cleanup;
     }
 
     if (virJSONValueObjectGetBoolean(data, "running", running) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("query-status reply was missing running state"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("query-status reply was missing running state"));
         goto cleanup;
     }
 
@@ -1256,20 +1256,20 @@ qemuMonitorJSONExtractCPUInfo(virJSONValuePtr reply,
     int ncpus;
 
     if (!(data = virJSONValueObjectGet(reply, "return"))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("cpu reply was missing return data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cpu reply was missing return data"));
         goto cleanup;
     }
 
     if (data->type != VIR_JSON_TYPE_ARRAY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("cpu information was not an array"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cpu information was not an array"));
         goto cleanup;
     }
 
     if ((ncpus = virJSONValueArraySize(data)) <= 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("cpu information was empty"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cpu information was empty"));
         goto cleanup;
     }
 
@@ -1283,14 +1283,14 @@ qemuMonitorJSONExtractCPUInfo(virJSONValuePtr reply,
         int cpu;
         int thread;
         if (!entry) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("character device information was missing array element"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("character device information was missing array element"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberInt(entry, "CPU", &cpu) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cpu information was missing cpu number"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cpu information was missing cpu number"));
             goto cleanup;
         }
 
@@ -1302,9 +1302,9 @@ qemuMonitorJSONExtractCPUInfo(virJSONValuePtr reply,
         }
 
         if (cpu != i) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unexpected cpu index %d expecting %d"),
-                            i, cpu);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unexpected cpu index %d expecting %d"),
+                           i, cpu);
             goto cleanup;
         }
 
@@ -1371,15 +1371,15 @@ int qemuMonitorJSONGetVirtType(qemuMonitorPtr mon,
         bool val = false;
 
         if (!(data = virJSONValueObjectGet(reply, "return"))) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("info kvm reply was missing return data"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("info kvm reply was missing return data"));
             ret = -1;
             goto cleanup;
         }
 
         if (virJSONValueObjectGetBoolean(data, "enabled", &val) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("info kvm reply missing 'running' field"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("info kvm reply missing 'running' field"));
             ret = -1;
             goto cleanup;
         }
@@ -1428,15 +1428,15 @@ int qemuMonitorJSONGetBalloonInfo(qemuMonitorPtr mon,
             unsigned long long mem;
 
             if (!(data = virJSONValueObjectGet(reply, "return"))) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("info balloon reply was missing return data"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("info balloon reply was missing return data"));
                 ret = -1;
                 goto cleanup;
             }
 
             if (virJSONValueObjectGetNumberUlong(data, "actual", &mem) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("info balloon reply was missing balloon data"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("info balloon reply was missing balloon data"));
                 ret = -1;
                 goto cleanup;
             }
@@ -1483,16 +1483,16 @@ int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
             unsigned long long mem;
 
             if (!(data = virJSONValueObjectGet(reply, "return"))) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                _("info balloon reply was missing return data"));
+                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                               _("info balloon reply was missing return data"));
                 ret = -1;
                 goto cleanup;
             }
 
             if (virJSONValueObjectHasKey(data, "actual") && (got < nr_stats)) {
                 if (virJSONValueObjectGetNumberUlong(data, "actual", &mem) < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("info balloon reply was missing balloon actual"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("info balloon reply was missing balloon actual"));
                     ret = -1;
                     goto cleanup;
                 }
@@ -1503,8 +1503,8 @@ int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
 
             if (virJSONValueObjectHasKey(data, "mem_swapped_in") && (got < nr_stats)) {
                 if (virJSONValueObjectGetNumberUlong(data, "mem_swapped_in", &mem) < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("info balloon reply was missing balloon mem_swapped_in"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("info balloon reply was missing balloon mem_swapped_in"));
                     ret = -1;
                     goto cleanup;
                 }
@@ -1514,8 +1514,8 @@ int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
             }
             if (virJSONValueObjectHasKey(data, "mem_swapped_out") && (got < nr_stats)) {
                 if (virJSONValueObjectGetNumberUlong(data, "mem_swapped_out", &mem) < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("info balloon reply was missing balloon mem_swapped_out"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("info balloon reply was missing balloon mem_swapped_out"));
                     ret = -1;
                     goto cleanup;
                 }
@@ -1525,8 +1525,8 @@ int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
             }
             if (virJSONValueObjectHasKey(data, "major_page_faults") && (got < nr_stats)) {
                 if (virJSONValueObjectGetNumberUlong(data, "major_page_faults", &mem) < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("info balloon reply was missing balloon major_page_faults"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("info balloon reply was missing balloon major_page_faults"));
                     ret = -1;
                     goto cleanup;
                 }
@@ -1536,8 +1536,8 @@ int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
             }
             if (virJSONValueObjectHasKey(data, "minor_page_faults") && (got < nr_stats)) {
                 if (virJSONValueObjectGetNumberUlong(data, "minor_page_faults", &mem) < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("info balloon reply was missing balloon minor_page_faults"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("info balloon reply was missing balloon minor_page_faults"));
                     ret = -1;
                     goto cleanup;
                 }
@@ -1547,8 +1547,8 @@ int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
             }
             if (virJSONValueObjectHasKey(data, "free_mem") && (got < nr_stats)) {
                 if (virJSONValueObjectGetNumberUlong(data, "free_mem", &mem) < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("info balloon reply was missing balloon free_mem"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("info balloon reply was missing balloon free_mem"));
                     ret = -1;
                     goto cleanup;
                 }
@@ -1558,8 +1558,8 @@ int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
             }
             if (virJSONValueObjectHasKey(data, "total_mem") && (got < nr_stats)) {
                 if (virJSONValueObjectGetNumberUlong(data, "total_mem", &mem) < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("info balloon reply was missing balloon total_mem"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("info balloon reply was missing balloon total_mem"));
                     ret = -1;
                     goto cleanup;
                 }
@@ -1604,7 +1604,7 @@ int qemuMonitorJSONGetBlockInfo(qemuMonitorPtr mon,
 
     devices = virJSONValueObjectGet(reply, "return");
     if (!devices || devices->type != VIR_JSON_TYPE_ARRAY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                        _("block info reply was missing device list"));
         goto cleanup;
     }
@@ -1616,14 +1616,14 @@ int qemuMonitorJSONGetBlockInfo(qemuMonitorPtr mon,
         const char *status;
 
         if (!dev || dev->type != VIR_JSON_TYPE_OBJECT) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("block info device entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("block info device entry was not in expected format"));
             goto cleanup;
         }
 
         if ((thisdev = virJSONValueObjectGetString(dev, "device")) == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("block info device entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("block info device entry was not in expected format"));
             goto cleanup;
         }
 
@@ -1641,16 +1641,16 @@ int qemuMonitorJSONGetBlockInfo(qemuMonitorPtr mon,
         }
 
         if (virJSONValueObjectGetBoolean(dev, "removable", &info->removable) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s value"),
-                            "removable");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s value"),
+                           "removable");
             goto cleanup;
         }
 
         if (virJSONValueObjectGetBoolean(dev, "locked", &info->locked) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s value"),
-                            "locked");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s value"),
+                           "locked");
             goto cleanup;
         }
 
@@ -1722,8 +1722,8 @@ int qemuMonitorJSONGetBlockStatsInfo(qemuMonitorPtr mon,
 
     devices = virJSONValueObjectGet(reply, "return");
     if (!devices || devices->type != VIR_JSON_TYPE_ARRAY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("blockstats reply was missing device list"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("blockstats reply was missing device list"));
         goto cleanup;
     }
 
@@ -1732,14 +1732,14 @@ int qemuMonitorJSONGetBlockStatsInfo(qemuMonitorPtr mon,
         virJSONValuePtr stats;
         const char *thisdev;
         if (!dev || dev->type != VIR_JSON_TYPE_OBJECT) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("blockstats device entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("blockstats device entry was not in expected format"));
             goto cleanup;
         }
 
         if ((thisdev = virJSONValueObjectGetString(dev, "device")) == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("blockstats device entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("blockstats device entry was not in expected format"));
             goto cleanup;
         }
 
@@ -1756,20 +1756,20 @@ int qemuMonitorJSONGetBlockStatsInfo(qemuMonitorPtr mon,
         found = 1;
         if ((stats = virJSONValueObjectGet(dev, "stats")) == NULL ||
             stats->type != VIR_JSON_TYPE_OBJECT) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("blockstats stats entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("blockstats stats entry was not in expected format"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberLong(stats, "rd_bytes", rd_bytes) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
-                            "rd_bytes");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
+                           "rd_bytes");
             goto cleanup;
         }
         if (virJSONValueObjectGetNumberLong(stats, "rd_operations", rd_req) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
                             "rd_operations");
             goto cleanup;
         }
@@ -1777,55 +1777,55 @@ int qemuMonitorJSONGetBlockStatsInfo(qemuMonitorPtr mon,
             virJSONValueObjectHasKey(stats, "rd_total_time_ns") &&
             (virJSONValueObjectGetNumberLong(stats, "rd_total_time_ns",
                                              rd_total_times) < 0)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
-                            "rd_total_time_ns");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
+                           "rd_total_time_ns");
             goto cleanup;
         }
         if (virJSONValueObjectGetNumberLong(stats, "wr_bytes", wr_bytes) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
-                            "wr_bytes");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
+                           "wr_bytes");
             goto cleanup;
         }
         if (virJSONValueObjectGetNumberLong(stats, "wr_operations", wr_req) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
-                            "wr_operations");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
+                           "wr_operations");
             goto cleanup;
         }
         if (wr_total_times &&
             virJSONValueObjectHasKey(stats, "wr_total_time_ns") &&
             (virJSONValueObjectGetNumberLong(stats, "wr_total_time_ns",
                                              wr_total_times) < 0)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
-                            "wr_total_time_ns");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
+                           "wr_total_time_ns");
             goto cleanup;
         }
         if (flush_req &&
             virJSONValueObjectHasKey(stats, "flush_operations") &&
             (virJSONValueObjectGetNumberLong(stats, "flush_operations",
                                             flush_req) < 0)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
-                            "flush_operations");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
+                           "flush_operations");
             goto cleanup;
         }
         if (flush_total_times &&
             virJSONValueObjectHasKey(stats, "flush_total_time_ns") &&
             (virJSONValueObjectGetNumberLong(stats, "flush_total_time_ns",
                                             flush_total_times) < 0)) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
-                            "flush_total_time_ns");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
+                           "flush_total_time_ns");
             goto cleanup;
         }
     }
 
     if (!found) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot find statistics for device '%s'"), dev_name);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot find statistics for device '%s'"), dev_name);
         goto cleanup;
     }
     ret = 0;
@@ -1861,23 +1861,23 @@ int qemuMonitorJSONGetBlockStatsParamsNumber(qemuMonitorPtr mon,
 
     devices = virJSONValueObjectGet(reply, "return");
     if (!devices || devices->type != VIR_JSON_TYPE_ARRAY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("blockstats reply was missing device list"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("blockstats reply was missing device list"));
         goto cleanup;
     }
 
     dev = virJSONValueArrayGet(devices, 0);
 
     if (!dev || dev->type != VIR_JSON_TYPE_OBJECT) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("blockstats device entry was not in expected format"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("blockstats device entry was not in expected format"));
         goto cleanup;
     }
 
     if ((stats = virJSONValueObjectGet(dev, "stats")) == NULL ||
         stats->type != VIR_JSON_TYPE_OBJECT) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("blockstats stats entry was not in expected format"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("blockstats stats entry was not in expected format"));
         goto cleanup;
     }
 
@@ -1936,8 +1936,8 @@ int qemuMonitorJSONGetBlockExtent(qemuMonitorPtr mon,
 
     devices = virJSONValueObjectGet(reply, "return");
     if (!devices || devices->type != VIR_JSON_TYPE_ARRAY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("blockstats reply was missing device list"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("blockstats reply was missing device list"));
         goto cleanup;
     }
 
@@ -1947,14 +1947,14 @@ int qemuMonitorJSONGetBlockExtent(qemuMonitorPtr mon,
         virJSONValuePtr parent;
         const char *thisdev;
         if (!dev || dev->type != VIR_JSON_TYPE_OBJECT) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("blockstats device entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("blockstats device entry was not in expected format"));
             goto cleanup;
         }
 
         if ((thisdev = virJSONValueObjectGetString(dev, "device")) == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("blockstats device entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("blockstats device entry was not in expected format"));
             goto cleanup;
         }
 
@@ -1971,29 +1971,29 @@ int qemuMonitorJSONGetBlockExtent(qemuMonitorPtr mon,
         found = 1;
         if ((parent = virJSONValueObjectGet(dev, "parent")) == NULL ||
             parent->type != VIR_JSON_TYPE_OBJECT) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("blockstats parent entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("blockstats parent entry was not in expected format"));
             goto cleanup;
         }
 
         if ((stats = virJSONValueObjectGet(parent, "stats")) == NULL ||
             stats->type != VIR_JSON_TYPE_OBJECT) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("blockstats stats entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("blockstats stats entry was not in expected format"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberUlong(stats, "wr_highest_offset", extent) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot read %s statistic"),
-                            "wr_highest_offset");
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot read %s statistic"),
+                           "wr_highest_offset");
             goto cleanup;
         }
     }
 
     if (!found) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot find statistics for device '%s'"), dev_name);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot find statistics for device '%s'"), dev_name);
         goto cleanup;
     }
     ret = 0;
@@ -2373,48 +2373,48 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
     unsigned long long t;
 
     if (!(ret = virJSONValueObjectGet(reply, "return"))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("info migration reply was missing return data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("info migration reply was missing return data"));
         return -1;
     }
 
     if (!(statusstr = virJSONValueObjectGetString(ret, "status"))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("info migration reply was missing return status"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("info migration reply was missing return status"));
         return -1;
     }
 
     if ((*status = qemuMonitorMigrationStatusTypeFromString(statusstr)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unexpected migration status in %s"), statusstr);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unexpected migration status in %s"), statusstr);
         return -1;
     }
 
     if (*status == QEMU_MONITOR_MIGRATION_STATUS_ACTIVE) {
         virJSONValuePtr ram = virJSONValueObjectGet(ret, "ram");
         if (!ram) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("migration was active, but no RAM info was set"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("migration was active, but no RAM info was set"));
             return -1;
         }
 
         if (virJSONValueObjectGetNumberUlong(ram, "transferred",
                                              transferred) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("migration was active, but RAM 'transferred' "
-                              "data was missing"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("migration was active, but RAM 'transferred' "
+                             "data was missing"));
             return -1;
         }
         if (virJSONValueObjectGetNumberUlong(ram, "remaining", remaining) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("migration was active, but RAM 'remaining' "
-                              "data was missing"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("migration was active, but RAM 'remaining' "
+                             "data was missing"));
             return -1;
         }
         if (virJSONValueObjectGetNumberUlong(ram, "total", total) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("migration was active, but RAM 'total' "
-                              "data was missing"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("migration was active, but RAM 'total' "
+                             "data was missing"));
             return -1;
         }
 
@@ -2424,23 +2424,23 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
         }
 
         if (virJSONValueObjectGetNumberUlong(disk, "transferred", &t) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("disk migration was active, but 'transferred' "
-                              "data was missing"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("disk migration was active, but 'transferred' "
+                             "data was missing"));
             return -1;
         }
         *transferred += t;
         if (virJSONValueObjectGetNumberUlong(disk, "remaining", &t) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("disk migration was active, but 'remaining' "
-                              "data was missing"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("disk migration was active, but 'remaining' "
+                             "data was missing"));
             return -1;
         }
         *remaining += t;
         if (virJSONValueObjectGetNumberUlong(disk, "total", &t) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("disk migration was active, but 'total' "
-                              "data was missing"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("disk migration was active, but 'total' "
+                             "data was missing"));
             return -1;
         }
         *total += t;
@@ -2601,8 +2601,8 @@ int qemuMonitorJSONGraphicsRelocate(qemuMonitorPtr mon,
 int qemuMonitorJSONAddUSBDisk(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                               const char *path ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("usb_add not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("usb_add not supported in JSON mode"));
     return -1;
 }
 
@@ -2611,8 +2611,8 @@ int qemuMonitorJSONAddUSBDeviceExact(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                      int bus ATTRIBUTE_UNUSED,
                                      int dev ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("usb_add not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("usb_add not supported in JSON mode"));
     return -1;
 }
 
@@ -2621,8 +2621,8 @@ int qemuMonitorJSONAddUSBDeviceMatch(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                      int vendor ATTRIBUTE_UNUSED,
                                      int product ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("usb_add not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("usb_add not supported in JSON mode"));
     return -1;
 }
 
@@ -2631,8 +2631,8 @@ int qemuMonitorJSONAddPCIHostDevice(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                     virDomainDevicePCIAddress *hostAddr ATTRIBUTE_UNUSED,
                                     virDomainDevicePCIAddress *guestAddr ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("pci_add not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("pci_add not supported in JSON mode"));
     return -1;
 }
 
@@ -2642,8 +2642,8 @@ int qemuMonitorJSONAddPCIDisk(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                               const char *bus ATTRIBUTE_UNUSED,
                               virDomainDevicePCIAddress *guestAddr ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("pci_add not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("pci_add not supported in JSON mode"));
     return -1;
 }
 
@@ -2652,8 +2652,8 @@ int qemuMonitorJSONAddPCINetwork(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                  const char *nicstr ATTRIBUTE_UNUSED,
                                  virDomainDevicePCIAddress *guestAddr ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("pci_add not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("pci_add not supported in JSON mode"));
     return -1;
 }
 
@@ -2661,8 +2661,8 @@ int qemuMonitorJSONAddPCINetwork(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
 int qemuMonitorJSONRemovePCIDevice(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                    virDomainDevicePCIAddress *guestAddr ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("pci_del not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("pci_del not supported in JSON mode"));
     return -1;
 }
 
@@ -2833,14 +2833,14 @@ static int qemuMonitorJSONExtractPtyPaths(virJSONValuePtr reply,
     int i;
 
     if (!(data = virJSONValueObjectGet(reply, "return"))) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("character device reply was missing return data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("character device reply was missing return data"));
         goto cleanup;
     }
 
     if (data->type != VIR_JSON_TYPE_ARRAY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("character device information was not an array"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("character device information was not an array"));
         goto cleanup;
     }
 
@@ -2849,20 +2849,20 @@ static int qemuMonitorJSONExtractPtyPaths(virJSONValuePtr reply,
         const char *type;
         const char *id;
         if (!entry) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("character device information was missing array element"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("character device information was missing array element"));
             goto cleanup;
         }
 
         if (!(type = virJSONValueObjectGetString(entry, "filename"))) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("character device information was missing filename"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("character device information was missing filename"));
             goto cleanup;
         }
 
         if (!(id = virJSONValueObjectGetString(entry, "label"))) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("character device information was missing filename"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("character device information was missing filename"));
             goto cleanup;
         }
 
@@ -2874,8 +2874,8 @@ static int qemuMonitorJSONExtractPtyPaths(virJSONValuePtr reply,
             }
 
             if (virHashAddEntry(paths, id, path) < 0) {
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
-                                _("failed to save chardev path '%s'"), path);
+                virReportError(VIR_ERR_OPERATION_FAILED,
+                               _("failed to save chardev path '%s'"), path);
                 VIR_FREE(path);
                 goto cleanup;
             }
@@ -2918,8 +2918,8 @@ int qemuMonitorJSONAttachPCIDiskController(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                            const char *bus ATTRIBUTE_UNUSED,
                                            virDomainDevicePCIAddress *guestAddr ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("pci_add not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("pci_add not supported in JSON mode"));
     return -1;
 }
 
@@ -2932,20 +2932,20 @@ qemuMonitorJSONGetGuestDriveAddress(virJSONValuePtr reply,
 
     addr = virJSONValueObjectGet(reply, "return");
     if (!addr || addr->type != VIR_JSON_TYPE_OBJECT) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("drive_add reply was missing device address"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("drive_add reply was missing device address"));
         return -1;
     }
 
     if (virJSONValueObjectGetNumberUint(addr, "bus", &driveAddr->bus) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("drive_add reply was missing device bus number"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("drive_add reply was missing device bus number"));
         return -1;
     }
 
     if (virJSONValueObjectGetNumberUint(addr, "unit", &driveAddr->unit) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("drive_add reply was missing device unit number"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("drive_add reply was missing device unit number"));
         return -1;
     }
 
@@ -2995,8 +2995,8 @@ int qemuMonitorJSONAttachDrive(qemuMonitorPtr mon,
 int qemuMonitorJSONGetAllPCIAddresses(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                       qemuMonitorPCIAddress **addrs ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("query-pci not supported in JSON mode"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("query-pci not supported in JSON mode"));
     return -1;
 }
 
@@ -3341,9 +3341,9 @@ int qemuMonitorJSONArbitraryCommand(qemuMonitorPtr mon,
 
     if (hmp) {
         if (!qemuMonitorCheckHMP(mon, NULL)) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("HMP passthrough is not supported by qemu"
-                              " process; only QMP commands can be used"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("HMP passthrough is not supported by qemu"
+                             " process; only QMP commands can be used"));
             return -1;
         }
         return qemuMonitorJSONHumanCommandWithFd(mon, cmd_str, -1, reply_str);
@@ -3441,8 +3441,8 @@ static int qemuMonitorJSONGetBlockJobInfoOne(virJSONValuePtr entry,
     unsigned long long speed_bytes;
 
     if ((this_dev = virJSONValueObjectGetString(entry, "device")) == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("entry was missing 'device'"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("entry was missing 'device'"));
         return -1;
     }
     if (!STREQ(this_dev, device))
@@ -3450,8 +3450,8 @@ static int qemuMonitorJSONGetBlockJobInfoOne(virJSONValuePtr entry,
 
     type = virJSONValueObjectGetString(entry, "type");
     if (!type) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("entry was missing 'type'"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("entry was missing 'type'"));
         return -1;
     }
     if (STREQ(type, "stream"))
@@ -3460,21 +3460,21 @@ static int qemuMonitorJSONGetBlockJobInfoOne(virJSONValuePtr entry,
         info->type = VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN;
 
     if (virJSONValueObjectGetNumberUlong(entry, "speed", &speed_bytes) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("entry was missing 'speed'"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("entry was missing 'speed'"));
         return -1;
     }
     info->bandwidth = speed_bytes / 1024ULL / 1024ULL;
 
     if (virJSONValueObjectGetNumberUlong(entry, "offset", &info->cur) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("entry was missing 'offset'"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("entry was missing 'offset'"));
         return -1;
     }
 
     if (virJSONValueObjectGetNumberUlong(entry, "len", &info->end) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("entry was missing 'len'"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("entry was missing 'len'"));
         return -1;
     }
     return 0;
@@ -3495,28 +3495,28 @@ static int qemuMonitorJSONGetBlockJobInfo(virJSONValuePtr reply,
         return -1;
 
     if ((data = virJSONValueObjectGet(reply, "return")) == NULL) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("reply was missing return data"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("reply was missing return data"));
         return -1;
     }
 
     if (data->type != VIR_JSON_TYPE_ARRAY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("unrecognized format of block job information"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("unrecognized format of block job information"));
         return -1;
     }
 
     if ((nr_results = virJSONValueArraySize(data)) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("unable to determine array size"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("unable to determine array size"));
         return -1;
     }
 
     for (i = 0; i < nr_results; i++) {
         virJSONValuePtr entry = virJSONValueArrayGet(data, i);
         if (!entry) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("missing array element"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("missing array element"));
             return -1;
         }
         if (qemuMonitorJSONGetBlockJobInfoOne(entry, device, info) == 0)
@@ -3543,14 +3543,14 @@ qemuMonitorJSONBlockJob(qemuMonitorPtr mon,
     const char *cmd_name = NULL;
 
     if (base && (mode != BLOCK_JOB_PULL || !modern)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("only modern block pull supports base: %s"), base);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("only modern block pull supports base: %s"), base);
         return -1;
     }
     if (speed && mode == BLOCK_JOB_PULL && !modern) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("only modern block pull supports speed: %llu"),
-                        speed);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("only modern block pull supports speed: %llu"),
+                       speed);
         return -1;
     }
 
@@ -3593,22 +3593,22 @@ qemuMonitorJSONBlockJob(qemuMonitorPtr mon,
     if (ret == 0 && virJSONValueObjectHasKey(reply, "error")) {
         ret = -1;
         if (qemuMonitorJSONHasError(reply, "DeviceNotActive")) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("No active operation on device: %s"),
-                            device);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("No active operation on device: %s"),
+                           device);
         } else if (qemuMonitorJSONHasError(reply, "DeviceInUse")){
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("Device %s in use"), device);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("Device %s in use"), device);
         } else if (qemuMonitorJSONHasError(reply, "NotSupported")) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("Operation is not supported for device: %s"),
-                            device);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("Operation is not supported for device: %s"),
+                           device);
         } else if (qemuMonitorJSONHasError(reply, "CommandNotFound")) {
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                            _("Command '%s' is not found"), cmd_name);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("Command '%s' is not found"), cmd_name);
         } else {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Unexpected error"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Unexpected error"));
         }
     }
 
@@ -3661,8 +3661,8 @@ qemuMonitorJSONBlockIoThrottleInfo(virJSONValuePtr result,
     io_throttle = virJSONValueObjectGet(result, "return");
 
     if (!io_throttle || io_throttle->type != VIR_JSON_TYPE_ARRAY) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _(" block_io_throttle reply was missing device list"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _(" block_io_throttle reply was missing device list"));
         goto cleanup;
     }
 
@@ -3672,14 +3672,14 @@ qemuMonitorJSONBlockIoThrottleInfo(virJSONValuePtr result,
         const char *current_dev;
 
         if (!temp_dev || temp_dev->type != VIR_JSON_TYPE_OBJECT) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("block_io_throttle device entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("block_io_throttle device entry was not in expected format"));
             goto cleanup;
         }
 
         if ((current_dev = virJSONValueObjectGetString(temp_dev, "device")) == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("block_io_throttle device entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("block_io_throttle device entry was not in expected format"));
             goto cleanup;
         }
 
@@ -3692,53 +3692,53 @@ qemuMonitorJSONBlockIoThrottleInfo(virJSONValuePtr result,
         found = 1;
         if ((inserted = virJSONValueObjectGet(temp_dev, "inserted")) == NULL ||
             inserted->type != VIR_JSON_TYPE_OBJECT) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("block_io_throttle inserted entry was not in expected format"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("block_io_throttle inserted entry was not in expected format"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberUlong(inserted, "bps", &reply->total_bytes_sec) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot read total_bytes_sec"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot read total_bytes_sec"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberUlong(inserted, "bps_rd", &reply->read_bytes_sec) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot read read_bytes_sec"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot read read_bytes_sec"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberUlong(inserted, "bps_wr", &reply->write_bytes_sec) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot read write_bytes_sec"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot read write_bytes_sec"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberUlong(inserted, "iops", &reply->total_iops_sec) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot read total_iops_sec"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot read total_iops_sec"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberUlong(inserted, "iops_rd", &reply->read_iops_sec) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot read read_iops_sec"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot read read_iops_sec"));
             goto cleanup;
         }
 
         if (virJSONValueObjectGetNumberUlong(inserted, "iops_wr", &reply->write_iops_sec) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("cannot read write_iops_sec"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("cannot read write_iops_sec"));
             goto cleanup;
         }
         break;
     }
 
     if (!found) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("cannot find throttling info for device '%s'"),
-                        device);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("cannot find throttling info for device '%s'"),
+                       device);
         goto cleanup;
     }
     ret = 0;
@@ -3771,14 +3771,14 @@ int qemuMonitorJSONSetBlockIoThrottle(qemuMonitorPtr mon,
 
     if (ret == 0 && virJSONValueObjectHasKey(result, "error")) {
         if (qemuMonitorJSONHasError(result, "DeviceNotActive"))
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                _("No active operation on device: %s"), device);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("No active operation on device: %s"), device);
         else if (qemuMonitorJSONHasError(result, "NotSupported"))
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                _("Operation is not supported for device: %s"), device);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("Operation is not supported for device: %s"), device);
         else
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Unexpected error"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Unexpected error"));
         ret = -1;
     }
 
@@ -3804,14 +3804,14 @@ int qemuMonitorJSONGetBlockIoThrottle(qemuMonitorPtr mon,
 
     if (ret == 0 && virJSONValueObjectHasKey(result, "error")) {
         if (qemuMonitorJSONHasError(result, "DeviceNotActive"))
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                _("No active operation on device: %s"), device);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("No active operation on device: %s"), device);
         else if (qemuMonitorJSONHasError(result, "NotSupported"))
-            qemuReportError(VIR_ERR_OPERATION_INVALID,
-                _("Operation is not supported for device: %s"), device);
+            virReportError(VIR_ERR_OPERATION_INVALID,
+                           _("Operation is not supported for device: %s"), device);
         else
-            qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Unexpected error"));
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Unexpected error"));
         ret = -1;
     }
 
diff --git a/src/qemu/qemu_monitor_text.c b/src/qemu/qemu_monitor_text.c
index 086b06b..c7de172 100644
--- a/src/qemu/qemu_monitor_text.c
+++ b/src/qemu/qemu_monitor_text.c
@@ -173,8 +173,8 @@ int qemuMonitorTextIOProcess(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                     /* Handled, so skip forward over password prompt */
                     start = passwd;
                 } else {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                    _("Password request seen, but no handler available"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                                   _("Password request seen, but no handler available"));
                     return -1;
                 }
             }
@@ -321,9 +321,9 @@ qemuMonitorSendDiskPassphrase(qemuMonitorPtr mon,
     pathStart = strstr(data, DISK_ENCRYPTION_PREFIX);
     pathEnd = strstr(data, DISK_ENCRYPTION_POSTFIX);
     if (!pathStart || !pathEnd || pathStart >= pathEnd) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("Unable to extract disk path from %s"),
-                        data);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Unable to extract disk path from %s"),
+                       data);
         return -1;
     }
 
@@ -389,8 +389,8 @@ qemuMonitorTextStopCPUs(qemuMonitorPtr mon) {
     char *info;
 
     if (qemuMonitorHMPCommand(mon, "stop", &info) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("cannot stop CPU execution"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("cannot stop CPU execution"));
         return -1;
     }
     VIR_FREE(info);
@@ -410,8 +410,8 @@ qemuMonitorTextGetStatus(qemuMonitorPtr mon,
         *reason = VIR_DOMAIN_PAUSED_UNKNOWN;
 
     if (qemuMonitorHMPCommand(mon, "info status", &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("cannot get status info"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("cannot get status info"));
         return -1;
     }
 
@@ -433,8 +433,8 @@ qemuMonitorTextGetStatus(qemuMonitorPtr mon,
             *reason = qemuMonitorVMStatusToPausedReason(status);
         *running = false;
     } else {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("unexpected reply from info status: %s"), reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("unexpected reply from info status: %s"), reply);
         goto cleanup;
     }
 
@@ -450,8 +450,8 @@ int qemuMonitorTextSystemPowerdown(qemuMonitorPtr mon) {
     char *info;
 
     if (qemuMonitorHMPCommand(mon, "system_powerdown", &info) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("system shutdown operation failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("system shutdown operation failed"));
         return -1;
     }
     VIR_FREE(info);
@@ -474,23 +474,23 @@ int qemuMonitorTextSetLink(qemuMonitorPtr mon, const char *name, enum virDomainN
         goto error;
     }
     if (qemuMonitorHMPCommand(mon, cmd, &info) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("set_link operation failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("set_link operation failed"));
         goto error;
     }
 
     /* check if set_link command is supported */
     if (strstr(info, "\nunknown ")) {
-        qemuReportError(VIR_ERR_NO_SUPPORT,
-                        "%s",
-                        _("\'set_link\' not supported by this qemu"));
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s",
+                       _("\'set_link\' not supported by this qemu"));
         goto error;
     }
 
     /* check if qemu didn't reject device name */
     if (strstr(info, "\nDevice ")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("device name rejected"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("device name rejected"));
         goto error;
     }
 
@@ -509,8 +509,8 @@ int qemuMonitorTextSystemReset(qemuMonitorPtr mon) {
     char *info;
 
     if (qemuMonitorHMPCommand(mon, "system_reset", &info) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("system reset operation failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("system reset operation failed"));
         return -1;
     }
     VIR_FREE(info);
@@ -528,8 +528,8 @@ int qemuMonitorTextGetCPUInfo(qemuMonitorPtr mon,
     size_t ncpupids = 0;
 
     if (qemuMonitorHMPCommand(mon, "info cpus", &qemucpus) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("cannot run monitor command to fetch CPU thread info"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot run monitor command to fetch CPU thread info"));
         return -1;
     }
 
@@ -609,8 +609,8 @@ int qemuMonitorTextGetVirtType(qemuMonitorPtr mon,
     *virtType = VIR_DOMAIN_VIRT_QEMU;
 
     if (qemuMonitorHMPCommand(mon, "info kvm", &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("could not query kvm status"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("could not query kvm status"));
         return -1;
     }
 
@@ -716,8 +716,8 @@ int qemuMonitorTextGetBalloonInfo(qemuMonitorPtr mon,
     char *offset;
 
     if (qemuMonitorHMPCommand(mon, "info balloon", &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("could not query memory balloon allocation"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("could not query memory balloon allocation"));
         return -1;
     }
 
@@ -726,14 +726,14 @@ int qemuMonitorTextGetBalloonInfo(qemuMonitorPtr mon,
         struct _virDomainMemoryStat stats[1];
 
         if (qemuMonitorParseBalloonInfo(offset, stats, 1) == 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unexpected balloon information '%s'"), reply);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unexpected balloon information '%s'"), reply);
             goto cleanup;
         }
 
         if (stats[0].tag != VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unexpected balloon information '%s'"), reply);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unexpected balloon information '%s'"), reply);
             goto cleanup;
         }
 
@@ -760,8 +760,8 @@ int qemuMonitorTextGetMemoryStats(qemuMonitorPtr mon,
     char *offset;
 
     if (qemuMonitorHMPCommand(mon, "info balloon", &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("could not query memory balloon statistics"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("could not query memory balloon statistics"));
         return -1;
     }
 
@@ -787,15 +787,15 @@ int qemuMonitorTextGetBlockInfo(qemuMonitorPtr mon,
     int tmp;
 
     if (qemuMonitorHMPCommand(mon, "info block", &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("info block command failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("info block command failed"));
         goto cleanup;
     }
 
     if (strstr(reply, "\ninfo ")) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s",
-                        _("info block not supported by this qemu"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s",
+                       _("info block not supported by this qemu"));
         goto cleanup;
     }
 
@@ -906,8 +906,8 @@ int qemuMonitorTextGetBlockStatsInfo(qemuMonitorPtr mon,
     int devnamelen = strlen(dev_name);
 
     if (qemuMonitorHMPCommand (mon, "info blockstats", &info) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("'info blockstats' command failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("'info blockstats' command failed"));
         goto cleanup;
     }
 
@@ -917,9 +917,9 @@ int qemuMonitorTextGetBlockStatsInfo(qemuMonitorPtr mon,
      * to detect if qemu supports the command.
      */
     if (strstr(info, "\ninfo ")) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s",
-                        _("'info blockstats' not supported by this qemu"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s",
+                       _("'info blockstats' not supported by this qemu"));
         goto cleanup;
     }
 
@@ -1016,8 +1016,8 @@ int qemuMonitorTextGetBlockStatsInfo(qemuMonitorPtr mon,
     }
 
     /* If we reach here then the device was not found. */
-    qemuReportError (VIR_ERR_INVALID_ARG,
-                     _("no stats found for device %s"), dev_name);
+    virReportError (VIR_ERR_INVALID_ARG,
+                    _("no stats found for device %s"), dev_name);
 
  cleanup:
     VIR_FREE(info);
@@ -1033,8 +1033,8 @@ int qemuMonitorTextGetBlockStatsParamsNumber(qemuMonitorPtr mon,
     const char *p, *eol;
 
     if (qemuMonitorHMPCommand (mon, "info blockstats", &info) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("'info blockstats' command failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("'info blockstats' command failed"));
         goto cleanup;
     }
 
@@ -1044,9 +1044,9 @@ int qemuMonitorTextGetBlockStatsParamsNumber(qemuMonitorPtr mon,
      * to detect if qemu supports the command.
      */
     if (strstr(info, "\ninfo ")) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s",
-                        _("'info blockstats' not supported by this qemu"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s",
+                       _("'info blockstats' not supported by this qemu"));
         goto cleanup;
     }
 
@@ -1096,8 +1096,8 @@ int qemuMonitorTextGetBlockExtent(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                   const char *dev_name ATTRIBUTE_UNUSED,
                                   unsigned long long *extent ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                    _("unable to query block extent with this QEMU"));
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("unable to query block extent with this QEMU"));
     return -1;
 }
 
@@ -1117,8 +1117,8 @@ int qemuMonitorTextBlockResize(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("failed to resize block"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("failed to resize block"));
         goto cleanup;
     }
 
@@ -1173,8 +1173,8 @@ int qemuMonitorTextSetVNCPassword(qemuMonitorPtr mon,
                                           qemuMonitorSendVNCPassphrase,
                                           (char *)password,
                                           -1, &info) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("setting VNC password failed"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("setting VNC password failed"));
         return -1;
     }
     VIR_FREE(info);
@@ -1198,8 +1198,8 @@ int qemuMonitorTextSetPassword(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("setting password failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("setting password failed"));
         goto cleanup;
     }
 
@@ -1232,8 +1232,8 @@ int qemuMonitorTextExpirePassword(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("expiring password failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("expiring password failed"));
         goto cleanup;
     }
 
@@ -1271,8 +1271,8 @@ int qemuMonitorTextSetBalloon(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("could not balloon memory allocation"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("could not balloon memory allocation"));
         VIR_FREE(cmd);
         return -1;
     }
@@ -1308,8 +1308,8 @@ int qemuMonitorTextSetCPU(qemuMonitorPtr mon, int cpu, int online)
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("could not change CPU online status"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("could not change CPU online status"));
         VIR_FREE(cmd);
         return -1;
     }
@@ -1343,8 +1343,8 @@ int qemuMonitorTextEjectMedia(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("could not eject media on %s"), dev_name);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("could not eject media on %s"), dev_name);
         goto cleanup;
     }
 
@@ -1352,8 +1352,8 @@ int qemuMonitorTextEjectMedia(qemuMonitorPtr mon,
      * device not found, device is locked ...
      * No message is printed on success it seems */
     if (c_strcasestr(reply, "device ")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("could not eject media on %s: %s"), dev_name, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("could not eject media on %s: %s"), dev_name, reply);
         goto cleanup;
     }
 
@@ -1387,8 +1387,8 @@ int qemuMonitorTextChangeMedia(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("could not change media on %s"), dev_name);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("could not change media on %s"), dev_name);
         goto cleanup;
     }
 
@@ -1396,15 +1396,15 @@ int qemuMonitorTextChangeMedia(qemuMonitorPtr mon,
      * device not found, device is locked ...
      * No message is printed on success it seems */
     if (c_strcasestr(reply, "device ")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("could not change media on %s: %s"), dev_name, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("could not change media on %s: %s"), dev_name, reply);
         goto cleanup;
     }
 
     /* Could not open message indicates bad filename */
     if (strstr(reply, "Could not open ")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("could not change media on %s: %s"), dev_name, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("could not change media on %s: %s"), dev_name, reply);
         goto cleanup;
     }
 
@@ -1439,8 +1439,8 @@ static int qemuMonitorTextSaveMemory(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("could not save memory region to '%s'"), path);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("could not save memory region to '%s'"), path);
         goto cleanup;
     }
 
@@ -1486,8 +1486,8 @@ int qemuMonitorTextSetMigrationSpeed(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &info) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("could not restrict migration speed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("could not restrict migration speed"));
         goto cleanup;
     }
 
@@ -1513,8 +1513,8 @@ int qemuMonitorTextSetMigrationDowntime(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &info) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("could not set maximum migration downtime"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("could not set maximum migration downtime"));
         goto cleanup;
     }
 
@@ -1554,8 +1554,8 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
     *total = 0;
 
     if (qemuMonitorHMPCommand(mon, "info migrate", &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("cannot query migration status"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("cannot query migration status"));
         return -1;
     }
 
@@ -1563,15 +1563,15 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
         tmp += strlen(MIGRATION_PREFIX);
         end = strchr(tmp, '\r');
         if (end == NULL) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unexpected migration status in %s"), reply);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unexpected migration status in %s"), reply);
             goto cleanup;
         }
         *end = '\0';
 
         if ((*status = qemuMonitorMigrationStatusTypeFromString(tmp)) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("unexpected migration status in %s"), reply);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("unexpected migration status in %s"), reply);
             goto cleanup;
         }
 
@@ -1583,9 +1583,9 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
             tmp += strlen(MIGRATION_TRANSFER_PREFIX);
 
             if (virStrToLong_ull(tmp, &end, 10, transferred) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse migration data transferred "
-                                  "statistic %s"), tmp);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse migration data transferred "
+                                 "statistic %s"), tmp);
                 goto cleanup;
             }
             *transferred *= 1024;
@@ -1596,9 +1596,9 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
             tmp += strlen(MIGRATION_REMAINING_PREFIX);
 
             if (virStrToLong_ull(tmp, &end, 10, remaining) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse migration data remaining "
-                                  "statistic %s"), tmp);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse migration data remaining "
+                                 "statistic %s"), tmp);
                 goto cleanup;
             }
             *remaining *= 1024;
@@ -1609,9 +1609,9 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
             tmp += strlen(MIGRATION_TOTAL_PREFIX);
 
             if (virStrToLong_ull(tmp, &end, 10, total) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse migration data total "
-                                  "statistic %s"), tmp);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse migration data total "
+                                 "statistic %s"), tmp);
                 goto cleanup;
             }
             *total *= 1024;
@@ -1625,9 +1625,9 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
             tmp += strlen(MIGRATION_DISK_TRANSFER_PREFIX);
 
             if (virStrToLong_ull(tmp, &end, 10, &disk_transferred) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse disk migration data "
-                                  "transferred statistic %s"), tmp);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse disk migration data "
+                                 "transferred statistic %s"), tmp);
                 goto cleanup;
             }
             *transferred += disk_transferred * 1024;
@@ -1638,9 +1638,9 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
             tmp += strlen(MIGRATION_DISK_REMAINING_PREFIX);
 
             if (virStrToLong_ull(tmp, &end, 10, &disk_remaining) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse disk migration data remaining "
-                                  "statistic %s"), tmp);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse disk migration data remaining "
+                                 "statistic %s"), tmp);
                 goto cleanup;
             }
             *remaining += disk_remaining * 1024;
@@ -1651,9 +1651,9 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
             tmp += strlen(MIGRATION_DISK_TOTAL_PREFIX);
 
             if (virStrToLong_ull(tmp, &end, 10, &disk_total) < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("cannot parse disk migration data total "
-                                  "statistic %s"), tmp);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("cannot parse disk migration data total "
+                                 "statistic %s"), tmp);
                 goto cleanup;
             }
             *total += disk_total * 1024;
@@ -1705,22 +1705,22 @@ int qemuMonitorTextMigrate(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &info) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to start migration to %s"), dest);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to start migration to %s"), dest);
         goto cleanup;
     }
 
     /* Now check for "fail" in the output string */
     if (strstr(info, "fail") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("migration to '%s' failed: %s"), dest, info);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("migration to '%s' failed: %s"), dest, info);
         goto cleanup;
     }
     /* If the command isn't supported then qemu prints:
      * unknown command: migrate" */
     if (strstr(info, "unknown command:")) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        _("migration to '%s' not supported by this qemu: %s"), dest, info);
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("migration to '%s' not supported by this qemu: %s"), dest, info);
         goto cleanup;
     }
 
@@ -1740,8 +1740,8 @@ int qemuMonitorTextMigrateCancel(qemuMonitorPtr mon)
     char *info = NULL;
 
     if (qemuMonitorHMPCommand(mon, "migrate_cancel", &info) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("cannot run monitor command to cancel migration"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot run monitor command to cancel migration"));
         return -1;
     }
     VIR_FREE(info);
@@ -1769,8 +1769,8 @@ int qemuMonitorTextGraphicsRelocate(qemuMonitorPtr mon,
 
     if (qemuMonitorHMPCommand(mon, cmd, &info) < 0) {
         VIR_FREE(cmd);
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("cannot run monitor command to relocate graphics client"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot run monitor command to relocate graphics client"));
         return -1;
     }
     VIR_FREE(cmd);
@@ -1800,16 +1800,16 @@ int qemuMonitorTextAddUSBDisk(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &info) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("cannot run monitor command to add usb disk"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot run monitor command to add usb disk"));
         goto cleanup;
     }
 
     /* If the command failed qemu prints:
      * Could not add ... */
     if (strstr(info, "Could not add ")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("unable to add USB disk %s: %s"), path, info);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("unable to add USB disk %s: %s"), path, info);
         goto cleanup;
     }
 
@@ -1836,16 +1836,16 @@ static int qemuMonitorTextAddUSBDevice(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("cannot attach usb device"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("cannot attach usb device"));
         goto cleanup;
     }
 
     /* If the command failed qemu prints:
      * Could not add ... */
     if (strstr(reply, "Could not add ")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("adding usb device failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("adding usb device failed"));
         goto cleanup;
     }
 
@@ -1977,20 +1977,20 @@ int qemuMonitorTextAddPCIHostDevice(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("cannot attach host pci device"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("cannot attach host pci device"));
         goto cleanup;
     }
 
     if (strstr(reply, "invalid type: host")) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("PCI device assignment is not supported by this version of qemu"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("PCI device assignment is not supported by this version of qemu"));
         goto cleanup;
     }
 
     if (qemuMonitorTextParsePciAddReply(mon, reply, guestAddr) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("parsing pci_add reply failed: %s"), reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("parsing pci_add reply failed: %s"), reply);
         goto cleanup;
     }
 
@@ -2028,8 +2028,8 @@ try_command:
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot attach %s disk %s"), bus, path);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot attach %s disk %s"), bus, path);
         goto cleanup;
     }
 
@@ -2041,8 +2041,8 @@ try_command:
             goto try_command;
         }
 
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("adding %s disk failed %s: %s"), bus, path, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("adding %s disk failed %s: %s"), bus, path, reply);
         goto cleanup;
     }
 
@@ -2070,14 +2070,14 @@ int qemuMonitorTextAddPCINetwork(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to add NIC with '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to add NIC with '%s'"), cmd);
         goto cleanup;
     }
 
     if (qemuMonitorTextParsePciAddReply(mon, reply, guestAddr) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("parsing pci_add reply failed: %s"), reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("parsing pci_add reply failed: %s"), reply);
         goto cleanup;
     }
 
@@ -2114,8 +2114,8 @@ try_command:
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("failed to remove PCI device"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("failed to remove PCI device"));
         goto cleanup;
     }
 
@@ -2133,9 +2133,9 @@ try_command:
      * nothing is printed on success */
     if (strstr(reply, "invalid slot") ||
         strstr(reply, "Invalid pci address")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to detach PCI device, invalid address %.4x:%.2x:%.2x: %s"),
-                        guestAddr->domain, guestAddr->bus, guestAddr->slot, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to detach PCI device, invalid address %.4x:%.2x:%.2x: %s"),
+                       guestAddr->domain, guestAddr->bus, guestAddr->slot, reply);
         goto cleanup;
     }
 
@@ -2162,23 +2162,23 @@ int qemuMonitorTextSendFileHandle(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommandWithFd(mon, cmd, fd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to pass fd to qemu with '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to pass fd to qemu with '%s'"), cmd);
         goto cleanup;
     }
 
     /* If the command isn't supported then qemu prints:
      * unknown command: getfd" */
     if (strstr(reply, "unknown command:")) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        _("qemu does not support sending of file handles: %s"),
-                        reply);
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("qemu does not support sending of file handles: %s"),
+                       reply);
         goto cleanup;
     }
 
     if (STRNEQ(reply, "")) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to send file handle '%s': %s"),
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to send file handle '%s': %s"),
                         fdname, reply);
         goto cleanup;
     }
@@ -2205,17 +2205,17 @@ int qemuMonitorTextCloseFileHandle(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to close fd in qemu with '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to close fd in qemu with '%s'"), cmd);
         goto cleanup;
     }
 
     /* If the command isn't supported then qemu prints:
      * unknown command: getfd" */
     if (strstr(reply, "unknown command:")) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        _("qemu does not support closing of file handles: %s"),
-                        reply);
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("qemu does not support closing of file handles: %s"),
+                       reply);
         goto cleanup;
     }
 
@@ -2241,15 +2241,15 @@ int qemuMonitorTextAddHostNetwork(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to add host net with '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to add host net with '%s'"), cmd);
         goto cleanup;
     }
 
     if (STRNEQ(reply, "")) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("unable to add host net: %s"),
-                        reply);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("unable to add host net: %s"),
+                       reply);
         goto cleanup;
     }
 
@@ -2276,8 +2276,8 @@ int qemuMonitorTextRemoveHostNetwork(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to remove host network in qemu with '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to remove host network in qemu with '%s'"), cmd);
         goto cleanup;
     }
 
@@ -2305,8 +2305,8 @@ int qemuMonitorTextAddNetdev(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to add netdev with '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to add netdev with '%s'"), cmd);
         goto cleanup;
     }
 
@@ -2334,8 +2334,8 @@ int qemuMonitorTextRemoveNetdev(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to remove netdev in qemu with '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to remove netdev in qemu with '%s'"), cmd);
         goto cleanup;
     }
 
@@ -2369,8 +2369,8 @@ int qemuMonitorTextGetPtyPaths(qemuMonitorPtr mon,
     int ret = -1;
 
     if (qemuMonitorHMPCommand(mon, "info chardev", &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("failed to retrieve chardev info in qemu with 'info chardev'"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("failed to retrieve chardev info in qemu with 'info chardev'"));
         return -1;
     }
 
@@ -2420,9 +2420,9 @@ int qemuMonitorTextGetPtyPaths(qemuMonitorPtr mon,
         }
 
         if (virHashAddEntry(paths, id, path) < 0) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("failed to save chardev path '%s'"),
-                            path);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("failed to save chardev path '%s'"),
+                           path);
             VIR_FREE(path);
             goto cleanup;
         }
@@ -2454,8 +2454,8 @@ try_command:
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot attach %s disk controller"), bus);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot attach %s disk controller"), bus);
         goto cleanup;
     }
 
@@ -2467,8 +2467,8 @@ try_command:
             goto try_command;
         }
 
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("adding %s disk controller failed: %s"), bus, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("adding %s disk controller failed: %s"), bus, reply);
         goto cleanup;
     }
 
@@ -2553,14 +2553,14 @@ try_command:
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to attach drive '%s'"), drivestr);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to attach drive '%s'"), drivestr);
         goto cleanup;
     }
 
     if (strstr(reply, "unknown command:")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("drive hotplug is not supported"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("drive hotplug is not supported"));
         goto cleanup;
     }
 
@@ -2571,8 +2571,8 @@ try_command:
             tryOldSyntax = 1;
             goto try_command;
         }
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("adding %s disk failed: %s"), drivestr, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("adding %s disk failed: %s"), drivestr, reply);
         goto cleanup;
     }
 
@@ -2626,8 +2626,8 @@ cleanup:
         (p) += strlen(lbl);
 #define GET_INT(p, base, val)                                           \
     if (virStrToLong_ui((p), &(p), (base), &(val)) < 0) {               \
-        qemuReportError(VIR_ERR_OPERATION_FAILED,                       \
-                        _("cannot parse value for %s"), #val);          \
+        virReportError(VIR_ERR_OPERATION_FAILED,                       \
+                       _("cannot parse value for %s"), #val);           \
         break;                                                          \
     }
 #define SKIP_SPACE(p)                           \
@@ -2644,8 +2644,8 @@ int qemuMonitorTextGetAllPCIAddresses(qemuMonitorPtr mon,
     *retaddrs = NULL;
 
     if (qemuMonitorHMPCommand(mon, "info pci", &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                         "%s", _("cannot query PCI addresses"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("cannot query PCI addresses"));
         return -1;
     }
 
@@ -2737,14 +2737,14 @@ int qemuMonitorTextDelDevice(qemuMonitorPtr mon,
 
     VIR_DEBUG("TextDelDevice devalias=%s", devalias);
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot detach %s device"), devalias);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot detach %s device"), devalias);
         goto cleanup;
     }
 
     if (STRNEQ(reply, "")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("detaching %s device failed: %s"), devalias, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("detaching %s device failed: %s"), devalias, reply);
         goto cleanup;
     }
 
@@ -2777,8 +2777,8 @@ int qemuMonitorTextAddDevice(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot attach %s device"), devicestr);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot attach %s device"), devicestr);
         goto cleanup;
     }
 
@@ -2793,8 +2793,8 @@ int qemuMonitorTextAddDevice(qemuMonitorPtr mon,
     /* Otherwise, if the command succeeds, no output is sent. So
      * any non-empty string shows an error */
     if (STRNEQ(reply, "")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("adding %s device failed: %s"), devicestr, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("adding %s device failed: %s"), devicestr, reply);
         goto cleanup;
     }
 
@@ -2830,20 +2830,20 @@ int qemuMonitorTextAddDrive(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to add drive '%s'"), drivestr);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to add drive '%s'"), drivestr);
         goto cleanup;
     }
 
     if (strstr(reply, "unknown command:")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("drive hotplug is not supported"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("drive hotplug is not supported"));
         goto cleanup;
     }
 
     if (strstr(reply, "could not open disk image")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("open disk image file failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("open disk image file failed"));
         goto cleanup;
     }
 
@@ -2878,8 +2878,8 @@ int qemuMonitorTextDriveDel(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("cannot delete %s drive"), drivestr);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("cannot delete %s drive"), drivestr);
         goto cleanup;
     }
 
@@ -2895,8 +2895,8 @@ int qemuMonitorTextDriveDel(qemuMonitorPtr mon,
         /* NB: device not found errors mean the drive was auto-deleted and we
          * ignore the error */
     } else if (STRNEQ(reply, "")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("deleting %s drive failed: %s"), drivestr, reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("deleting %s drive failed: %s"), drivestr, reply);
         goto cleanup;
     }
 
@@ -2931,18 +2931,18 @@ int qemuMonitorTextSetDrivePassphrase(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("failed to set disk password"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("failed to set disk password"));
         goto cleanup;
     }
 
     if (strstr(reply, "unknown command:")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("setting disk password is not supported"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("setting disk password is not supported"));
         goto cleanup;
     } else if (strstr(reply, "The entered password is invalid")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
-                        _("the disk password is incorrect"));
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+                       _("the disk password is incorrect"));
         goto cleanup;
     }
 
@@ -2969,28 +2969,28 @@ int qemuMonitorTextCreateSnapshot(qemuMonitorPtr mon, const char *name)
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to take snapshot using command '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to take snapshot using command '%s'"), cmd);
         goto cleanup;
     }
 
     if (strstr(reply, "Error while creating snapshot") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("Failed to take snapshot: %s"), reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("Failed to take snapshot: %s"), reply);
         goto cleanup;
     }
     else if (strstr(reply, "No block device can accept snapshots") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("this domain does not have a device to take snapshots"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("this domain does not have a device to take snapshots"));
         goto cleanup;
     }
     else if (strstr(reply, "Could not open VM state file") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
         goto cleanup;
     }
     else if (strstr(reply, "Error") != NULL
              && strstr(reply, "while writing VM") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
         goto cleanup;
     }
 
@@ -3017,39 +3017,39 @@ int qemuMonitorTextLoadSnapshot(qemuMonitorPtr mon, const char *name)
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                         _("failed to restore snapshot using command '%s'"),
-                         cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to restore snapshot using command '%s'"),
+                       cmd);
         goto cleanup;
     }
 
     if (strstr(reply, "No block device supports snapshots") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("this domain does not have a device to load snapshots"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("this domain does not have a device to load snapshots"));
         goto cleanup;
     }
     else if (strstr(reply, "Could not find snapshot") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                         _("the snapshot '%s' does not exist, and was not loaded"),
-                         name);
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("the snapshot '%s' does not exist, and was not loaded"),
+                       name);
         goto cleanup;
     }
     else if (strstr(reply, "Snapshots not supported on device") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", reply);
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s", reply);
         goto cleanup;
     }
     else if (strstr(reply, "Could not open VM state file") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
         goto cleanup;
     }
     else if (strstr(reply, "Error") != NULL
              && strstr(reply, "while loading VM state") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
         goto cleanup;
     }
     else if (strstr(reply, "Error") != NULL
              && strstr(reply, "while activating snapshot on") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
         goto cleanup;
     }
 
@@ -3075,24 +3075,24 @@ int qemuMonitorTextDeleteSnapshot(qemuMonitorPtr mon, const char *name)
         goto cleanup;
     }
     if (qemuMonitorHMPCommand(mon, cmd, &reply)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                         _("failed to delete snapshot using command '%s'"),
-                         cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to delete snapshot using command '%s'"),
+                       cmd);
         goto cleanup;
     }
 
     if (strstr(reply, "No block device supports snapshots") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("this domain does not have a device to delete snapshots"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("this domain does not have a device to delete snapshots"));
         goto cleanup;
     }
     else if (strstr(reply, "Snapshots not supported on device") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", reply);
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s", reply);
         goto cleanup;
     }
     else if (strstr(reply, "Error") != NULL
              && strstr(reply, "while deleting snapshot") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
+        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
         goto cleanup;
     }
 
@@ -3121,15 +3121,15 @@ qemuMonitorTextDiskSnapshot(qemuMonitorPtr mon, const char *device,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply)) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to take snapshot using command '%s'"), cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to take snapshot using command '%s'"), cmd);
         goto cleanup;
     }
 
     if (strstr(reply, "error while creating qcow2") != NULL ||
         strstr(reply, "unknown command:") != NULL) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("Failed to take snapshot: %s"), reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("Failed to take snapshot: %s"), reply);
         goto cleanup;
     }
 
@@ -3159,8 +3159,8 @@ int qemuMonitorTextArbitraryCommand(qemuMonitorPtr mon, const char *cmd,
 
     ret = qemuMonitorHMPCommand(mon, safecmd, reply);
     if (ret != 0)
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to run cmd '%s'"), safecmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to run cmd '%s'"), safecmd);
 
     VIR_FREE(safecmd);
 
@@ -3189,9 +3189,9 @@ int qemuMonitorTextInjectNMI(qemuMonitorPtr mon)
     return 0;
 
 fail:
-    qemuReportError(VIR_ERR_OPERATION_FAILED,
-                     _("failed to inject NMI using command '%s'"),
-                     cmd);
+    virReportError(VIR_ERR_OPERATION_FAILED,
+                   _("failed to inject NMI using command '%s'"),
+                   cmd);
     return -1;
 }
 
@@ -3211,9 +3211,9 @@ int qemuMonitorTextSendKey(qemuMonitorPtr mon,
     virBufferAddLit(&buf, "sendkey ");
     for (i = 0; i < nkeycodes; i++) {
         if (keycodes[i] > 0xffff) {
-            qemuReportError(VIR_ERR_OPERATION_FAILED,
-                            _("keycode %d is invalid: 0x%X"),
-                            i, keycodes[i]);
+            virReportError(VIR_ERR_OPERATION_FAILED,
+                           _("keycode %d is invalid: 0x%X"),
+                           i, keycodes[i]);
             virBufferFreeAndReset(&buf);
             return -1;
         }
@@ -3233,15 +3233,15 @@ int qemuMonitorTextSendKey(qemuMonitorPtr mon,
 
     cmd = virBufferContentAndReset(&buf);
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                         _("failed to send key using command '%s'"),
-                         cmd);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to send key using command '%s'"),
+                       cmd);
         goto cleanup;
     }
 
     if (STRNEQ(reply, "")) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        _("failed to send key '%s'"), reply);
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("failed to send key '%s'"), reply);
         goto cleanup;
     }
 
@@ -3266,8 +3266,8 @@ int qemuMonitorTextScreendump(qemuMonitorPtr mon, const char *file)
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("taking screenshot failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("taking screenshot failed"));
         goto cleanup;
     }
 
@@ -3300,8 +3300,8 @@ int qemuMonitorTextOpenGraphics(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
-        qemuReportError(VIR_ERR_OPERATION_FAILED,
-                        "%s", _("adding graphics client failed"));
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       "%s", _("adding graphics client failed"));
         goto cleanup;
     }
 
@@ -3339,15 +3339,15 @@ int qemuMonitorTextSetBlockIoThrottle(qemuMonitorPtr mon,
     }
 
     if (qemuMonitorHMPCommand(mon, cmd, &result) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("cannot run monitor command"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot run monitor command"));
         ret = -1;
         goto cleanup;
     }
 
     if (qemuMonitorTextCommandNotFound(cmd_name, result)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        _("Command '%s' is not found"), cmd_name);
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("Command '%s' is not found"), cmd_name);
         ret = -1;
         goto cleanup;
     }
@@ -3429,8 +3429,8 @@ qemuMonitorTextParseBlockIoThrottle(const char *result,
         p++;
     }
 
-    qemuReportError(VIR_ERR_INVALID_ARG,
-                    _("No info for device '%s'"), device);
+    virReportError(VIR_ERR_INVALID_ARG,
+                   _("No info for device '%s'"), device);
 
 cleanup:
     return ret;
@@ -3445,15 +3445,15 @@ int qemuMonitorTextGetBlockIoThrottle(qemuMonitorPtr mon,
     const char *cmd_name = "info block";
 
     if (qemuMonitorHMPCommand(mon, cmd_name, &result) < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("cannot run monitor command"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot run monitor command"));
         ret = -1;
         goto cleanup;
     }
 
     if (qemuMonitorTextCommandNotFound(cmd_name, result)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        _("Command '%s' is not found"), cmd_name);
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("Command '%s' is not found"), cmd_name);
         ret = -1;
         goto cleanup;
     }
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index d8169e8..97403be 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -368,9 +368,9 @@ qemuProcessFindDomainDiskByPath(virDomainObjPtr vm,
     if (i >= 0)
         return vm->def->disks[i];
 
-    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                    _("no disk found with path %s"),
-                    path);
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   _("no disk found with path %s"),
+                   path);
     return NULL;
 }
 
@@ -391,9 +391,9 @@ qemuProcessFindDomainDiskByAlias(virDomainObjPtr vm,
             return disk;
     }
 
-    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                    _("no disk found with alias %s"),
-                    alias);
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   _("no disk found with alias %s"),
+                   alias);
     return NULL;
 }
 
@@ -411,24 +411,24 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
     virStorageEncryptionPtr enc;
 
     if (!disk->encryption) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("disk %s does not have any encryption information"),
-                        disk->src);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("disk %s does not have any encryption information"),
+                       disk->src);
         return -1;
     }
     enc = disk->encryption;
 
     if (!conn) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("cannot find secrets without a connection"));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("cannot find secrets without a connection"));
         goto cleanup;
     }
 
     if (conn->secretDriver == NULL ||
         conn->secretDriver->lookupByUUID == NULL ||
         conn->secretDriver->getValue == NULL) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                        _("secret storage not supported"));
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("secret storage not supported"));
         goto cleanup;
     }
 
@@ -436,8 +436,8 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
         enc->nsecrets != 1 ||
         enc->secrets[0]->type !=
         VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE) {
-        qemuReportError(VIR_ERR_XML_ERROR,
-                        _("invalid <encryption> for volume %s"), disk->src);
+        virReportError(VIR_ERR_XML_ERROR,
+                       _("invalid <encryption> for volume %s"), disk->src);
         goto cleanup;
     }
 
@@ -454,9 +454,9 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
     if (memchr(data, '\0', size) != NULL) {
         memset(data, 0, size);
         VIR_FREE(data);
-        qemuReportError(VIR_ERR_XML_ERROR,
-                        _("format='qcow' passphrase for %s must not contain a "
-                          "'\\0'"), disk->src);
+        virReportError(VIR_ERR_XML_ERROR,
+                       _("format='qcow' passphrase for %s must not contain a "
+                         "'\\0'"), disk->src);
         goto cleanup;
     }
 
@@ -550,8 +550,8 @@ qemuProcessFakeReboot(void *opaque)
         goto cleanup;
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("guest unexpectedly quit"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("guest unexpectedly quit"));
         goto endjob;
     }
 
@@ -563,8 +563,8 @@ qemuProcessFakeReboot(void *opaque)
     qemuDomainObjExitMonitorWithDriver(driver, vm);
 
     if (!virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("guest unexpectedly quit"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("guest unexpectedly quit"));
         goto endjob;
     }
 
@@ -572,8 +572,8 @@ qemuProcessFakeReboot(void *opaque)
                              VIR_DOMAIN_RUNNING_BOOTED,
                              QEMU_ASYNC_JOB_NONE) < 0) {
         if (virGetLastError() == NULL)
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("resume operation failed"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("resume operation failed"));
         goto endjob;
     }
     priv->gotShutdown = false;
@@ -1326,16 +1326,16 @@ qemuProcessReadLogOutput(virDomainObjPtr vm,
         }
 
         if (got == buflen-1) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Out of space while reading %s log output: %s"),
-                            what, buf);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Out of space while reading %s log output: %s"),
+                           what, buf);
             goto cleanup;
         }
 
         if (isdead) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Process exited while reading %s log output: %s"),
-                            what, buf);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Process exited while reading %s log output: %s"),
+                           what, buf);
             goto cleanup;
         }
 
@@ -1348,9 +1348,9 @@ qemuProcessReadLogOutput(virDomainObjPtr vm,
         retries--;
     }
 
-    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                    _("Timed out while reading %s log output: %s"),
-                    what, buf);
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   _("Timed out while reading %s log output: %s"),
+                   what, buf);
 
 cleanup:
     VIR_FREE(debug);
@@ -1435,8 +1435,8 @@ qemuProcessLookupPTYs(virDomainChrDefPtr *devices,
                     /* neither the log output nor 'info chardev' had a
                      * pty path for this chardev, report an error
                      */
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    _("no assigned pty for device %s"), id);
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   _("no assigned pty for device %s"), id);
                     return -1;
                 } else {
                     /* 'info chardev' had no pty path for this chardev,
@@ -1627,9 +1627,9 @@ cleanup:
         /* VM is dead, any other error raised in the interim is probably
          * not as important as the qemu cmdline output */
         qemuProcessReadLogFD(logfd, buf, buf_size, strlen(buf));
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("process exited while connecting to monitor: %s"),
-                        buf);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("process exited while connecting to monitor: %s"),
+                       buf);
         ret = -1;
     }
 
@@ -1672,10 +1672,10 @@ qemuProcessDetectVcpuPIDs(struct qemud_driver *driver,
     qemuDomainObjExitMonitorWithDriver(driver, vm);
 
     if (ncpupids != vm->def->vcpus) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        _("got wrong number of vCPU pids from QEMU monitor. "
-                          "got %d, wanted %d"),
-                        ncpupids, vm->def->vcpus);
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("got wrong number of vCPU pids from QEMU monitor. "
+                         "got %d, wanted %d"),
+                       ncpupids, vm->def->vcpus);
         VIR_FREE(cpupids);
         return -1;
     }
@@ -1720,8 +1720,8 @@ qemuProcessInitNumaMemoryPolicy(virDomainObjPtr vm,
     }
 
     if (numa_available() < 0) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                        "%s", _("Host kernel is not aware of NUMA."));
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Host kernel is not aware of NUMA."));
         return -1;
     }
 
@@ -1731,8 +1731,8 @@ qemuProcessInitNumaMemoryPolicy(virDomainObjPtr vm,
     for (i = 0; i < VIR_DOMAIN_CPUMASK_LEN; i++) {
         if (tmp_nodemask[i]) {
             if (i > NUMA_NUM_NODES) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                _("Host cannot support NUMA node %d"), i);
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Host cannot support NUMA node %d"), i);
                 return -1;
             }
             if (i > maxnode && !warned) {
@@ -1760,9 +1760,9 @@ qemuProcessInitNumaMemoryPolicy(virDomainObjPtr vm,
         }
 
         if (nnodes != 1) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            "%s", _("NUMA memory tuning in 'preferred' mode "
-                                    "only supports single node"));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           "%s", _("NUMA memory tuning in 'preferred' mode "
+                                   "only supports single node"));
             goto cleanup;
         }
 
@@ -1774,8 +1774,8 @@ qemuProcessInitNumaMemoryPolicy(virDomainObjPtr vm,
         /* XXX: Shouldn't go here, as we already do checking when
          * parsing domain XML.
          */
-        qemuReportError(VIR_ERR_XML_ERROR,
-                        "%s", _("Invalid mode for memory NUMA tuning."));
+        virReportError(VIR_ERR_XML_ERROR,
+                       "%s", _("Invalid mode for memory NUMA tuning."));
         goto cleanup;
     }
 
@@ -1790,8 +1790,8 @@ qemuProcessInitNumaMemoryPolicy(virDomainObjPtr vm,
                                 const char *nodemask ATTRIBUTE_UNUSED)
 {
     if (vm->def->numatune.memory.nodemask) {
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("libvirt is compiled without NUMA tuning support"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("libvirt is compiled without NUMA tuning support"));
 
         return -1;
     }
@@ -1814,9 +1814,9 @@ qemuGetNumadAdvice(virDomainDefPtr def)
     virCommandSetOutputBuffer(cmd, &output);
 
     if (virCommandRun(cmd, NULL) < 0)
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Failed to query numad for the "
-                          "advisory nodeset"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Failed to query numad for the "
+                         "advisory nodeset"));
 
     virCommandFree(cmd);
     return output;
@@ -1825,8 +1825,8 @@ qemuGetNumadAdvice(virDomainDefPtr def)
 static char *
 qemuGetNumadAdvice(virDomainDefPtr def ATTRIBUTE_UNUSED)
 {
-    qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                    _("numad is not available on this host"));
+    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                   _("numad is not available on this host"));
     return NULL;
 }
 #endif
@@ -1920,8 +1920,8 @@ qemuProcessSetLinkStates(virDomainObjPtr vm)
             VIR_DEBUG("Setting link state: %s", def->nets[i]->info.alias);
 
             if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
-                qemuReportError(VIR_ERR_NO_SUPPORT,
-                                _("Setting of link state is not supported by this qemu"));
+                virReportError(VIR_ERR_NO_SUPPORT,
+                               _("Setting of link state is not supported by this qemu"));
                 return -1;
             }
 
@@ -1929,7 +1929,7 @@ qemuProcessSetLinkStates(virDomainObjPtr vm)
                                      def->nets[i]->info.alias,
                                      VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN);
             if (ret != 0) {
-                qemuReportError(VIR_ERR_OPERATION_FAILED,
+                virReportError(VIR_ERR_OPERATION_FAILED,
                                _("Couldn't set link state on interface: %s"), def->nets[i]->info.alias);
                 break;
             }
@@ -1961,8 +1961,8 @@ qemuProcessSetVcpuAffinites(virConnectPtr conn,
         return 0;
 
     if (priv->vcpupids == NULL) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("cpu affinity is not supported"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("cpu affinity is not supported"));
         return -1;
     }
 
@@ -2330,9 +2330,9 @@ qemuProcessDetectPCIAddresses(virDomainObjPtr vm,
         if (qemuProcessAssignNextPCIAddress(&(vm->def->disks[i]->info),
                                             vendor, product,
                                             addrs, naddrs) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find PCI address for VirtIO disk %s"),
-                            vm->def->disks[i]->dst);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find PCI address for VirtIO disk %s"),
+                           vm->def->disks[i]->dst);
             return -1;
         }
     }
@@ -2344,9 +2344,9 @@ qemuProcessDetectPCIAddresses(virDomainObjPtr vm,
         if (qemuProcessAssignNextPCIAddress(&(vm->def->nets[i]->info),
                                             vendor, product,
                                             addrs,  naddrs) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find PCI address for %s NIC"),
-                            vm->def->nets[i]->model);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find PCI address for %s NIC"),
+                           vm->def->nets[i]->model);
             return -1;
         }
     }
@@ -2358,9 +2358,9 @@ qemuProcessDetectPCIAddresses(virDomainObjPtr vm,
         if (qemuProcessAssignNextPCIAddress(&(vm->def->controllers[i]->info),
                                             vendor, product,
                                             addrs,  naddrs) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find PCI address for controller %s"),
-                            virDomainControllerTypeToString(vm->def->controllers[i]->type));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find PCI address for controller %s"),
+                           virDomainControllerTypeToString(vm->def->controllers[i]->type));
             return -1;
         }
     }
@@ -2372,9 +2372,9 @@ qemuProcessDetectPCIAddresses(virDomainObjPtr vm,
         if (qemuProcessAssignNextPCIAddress(&(vm->def->videos[i]->info),
                                             vendor, product,
                                             addrs,  naddrs) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find PCI address for video adapter %s"),
-                            virDomainVideoTypeToString(vm->def->videos[i]->type));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find PCI address for video adapter %s"),
+                           virDomainVideoTypeToString(vm->def->videos[i]->type));
             return -1;
         }
     }
@@ -2386,9 +2386,9 @@ qemuProcessDetectPCIAddresses(virDomainObjPtr vm,
         if (qemuProcessAssignNextPCIAddress(&(vm->def->sounds[i]->info),
                                     vendor, product,
                                      addrs,  naddrs) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find PCI address for sound adapter %s"),
-                            virDomainSoundModelTypeToString(vm->def->sounds[i]->model));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find PCI address for sound adapter %s"),
+                           virDomainSoundModelTypeToString(vm->def->sounds[i]->model));
             return -1;
         }
     }
@@ -2399,9 +2399,9 @@ qemuProcessDetectPCIAddresses(virDomainObjPtr vm,
         if (qemuProcessAssignNextPCIAddress(&(vm->def->watchdog->info),
                                             vendor, product,
                                             addrs,  naddrs) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find PCI address for watchdog %s"),
-                            virDomainWatchdogModelTypeToString(vm->def->watchdog->model));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find PCI address for watchdog %s"),
+                           virDomainWatchdogModelTypeToString(vm->def->watchdog->model));
             return -1;
         }
     }
@@ -2411,9 +2411,9 @@ qemuProcessDetectPCIAddresses(virDomainObjPtr vm,
         if (qemuProcessAssignNextPCIAddress(&(vm->def->memballoon->info),
                                             vendor, product,
                                             addrs, naddrs) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("cannot find PCI address for balloon %s"),
-                            virDomainMemballoonModelTypeToString(vm->def->memballoon->model));
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("cannot find PCI address for balloon %s"),
+                           virDomainMemballoonModelTypeToString(vm->def->memballoon->model));
             return -1;
         }
     }
@@ -3273,9 +3273,9 @@ qemuProcessReconnectHelper(void *payload,
 
         virConnectClose(data->conn);
 
-        qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Could not create thread. QEMU initialization "
-                          "might be incomplete"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Could not create thread. QEMU initialization "
+                         "might be incomplete"));
         if (qemuDomainObjEndJob(src->driver, obj) == 0) {
             obj = NULL;
         } else if (virDomainObjUnref(obj) > 0) {
@@ -3354,8 +3354,8 @@ int qemuProcessStart(virConnectPtr conn,
     VIR_DEBUG("Beginning VM startup process");
 
     if (virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("VM is already active"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("VM is already active"));
         return -1;
     }
 
@@ -3420,8 +3420,8 @@ int qemuProcessStart(virConnectPtr conn,
             vm->def->graphics[0]->data.vnc.autoport) {
             int port = qemuProcessNextFreePort(driver, QEMU_VNC_PORT_MIN);
             if (port < 0) {
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                "%s", _("Unable to find an unused VNC port"));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               "%s", _("Unable to find an unused VNC port"));
                 goto cleanup;
             }
             vm->def->graphics[0]->data.vnc.port = port;
@@ -3432,8 +3432,8 @@ int qemuProcessStart(virConnectPtr conn,
                 port = qemuProcessNextFreePort(driver, QEMU_VNC_PORT_MIN);
 
                 if (port < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    "%s", _("Unable to find an unused SPICE port"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   "%s", _("Unable to find an unused SPICE port"));
                     goto cleanup;
                 }
 
@@ -3446,8 +3446,8 @@ int qemuProcessStart(virConnectPtr conn,
                 int tlsPort = qemuProcessNextFreePort(driver,
                                                       vm->def->graphics[0]->data.spice.port + 1);
                 if (tlsPort < 0) {
-                    qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                    "%s", _("Unable to find an unused SPICE TLS port"));
+                    virReportError(VIR_ERR_INTERNAL_ERROR,
+                                   "%s", _("Unable to find an unused SPICE TLS port"));
                     qemuProcessReturnPort(driver, port);
                     goto cleanup;
                 }
@@ -3492,10 +3492,10 @@ int qemuProcessStart(virConnectPtr conn,
     if (vm->def->virtType == VIR_DOMAIN_VIRT_KVM) {
         VIR_DEBUG("Checking for KVM availability");
         if (access("/dev/kvm", F_OK) != 0) {
-            qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                            _("Domain requires KVM, but it is not available. "
-                              "Check that virtualization is enabled in the host BIOS, "
-                              "and host configuration is setup to load the kvm modules."));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("Domain requires KVM, but it is not available. "
+                             "Check that virtualization is enabled in the host BIOS, "
+                             "and host configuration is setup to load the kvm modules."));
             goto cleanup;
         }
     }
@@ -3658,8 +3658,8 @@ int qemuProcessStart(virConnectPtr conn,
     /* wait for qemu process to show up */
     if (ret == 0) {
         if (virPidFileReadPath(priv->pidfile, &vm->pid) < 0) {
-            qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                            _("Domain %s didn't show up"), vm->def->name);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Domain %s didn't show up"), vm->def->name);
             ret = -1;
         }
 #if 0
@@ -3790,9 +3790,9 @@ int qemuProcessStart(virConnectPtr conn,
     VIR_DEBUG("Setting initial memory amount");
     cur_balloon = vm->def->mem.cur_balloon;
     if (cur_balloon != vm->def->mem.cur_balloon) {
-        qemuReportError(VIR_ERR_OVERFLOW,
-                        _("unable to set balloon to %lld"),
-                        vm->def->mem.cur_balloon);
+        virReportError(VIR_ERR_OVERFLOW,
+                       _("unable to set balloon to %lld"),
+                       vm->def->mem.cur_balloon);
         goto cleanup;
     }
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
@@ -3809,8 +3809,8 @@ int qemuProcessStart(virConnectPtr conn,
                                  VIR_DOMAIN_RUNNING_BOOTED,
                                  QEMU_ASYNC_JOB_NONE) < 0) {
             if (virGetLastError() == NULL)
-                qemuReportError(VIR_ERR_INTERNAL_ERROR,
-                                "%s", _("resume operation failed"));
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               "%s", _("resume operation failed"));
             goto cleanup;
         }
     } else {
@@ -4199,8 +4199,8 @@ int qemuProcessAttach(virConnectPtr conn ATTRIBUTE_UNUSED,
     VIR_DEBUG("Beginning VM attach process");
 
     if (virDomainObjIsActive(vm)) {
-        qemuReportError(VIR_ERR_OPERATION_INVALID,
-                        "%s", _("VM is already active"));
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("VM is already active"));
         return -1;
     }
 
-- 
1.7.10.4


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]