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

[libvirt] [PATCH 02/13] virsh: Split cmds for domain monitoring from virsh.c



This splits commands commands to monitor domain status into
virsh-domain-monitor.c. The helpers not for common use are moved too.
Standard copyright is added.

* tools/virsh.c:
  Remove commands for domain monitoring group and a few helpers (
  vshDomainIOErrorToString, vshGetDomainDescription,
  vshDomainControlStateToString, vshDomainStateToString) not for
  common use.

* tools/virsh-domain-monitor.c:
  New file, filled with commands of domain monitor group.
---
 tools/virsh-domain-monitor.c | 1685 +++++++++++++++++++++++++++++++++++++
 tools/virsh.c                | 1904 +++---------------------------------------
 2 files changed, 1807 insertions(+), 1782 deletions(-)
 create mode 100644 tools/virsh-domain-monitor.c

diff --git a/tools/virsh-domain-monitor.c b/tools/virsh-domain-monitor.c
new file mode 100644
index 0000000..1a61f62
--- /dev/null
+++ b/tools/virsh-domain-monitor.c
@@ -0,0 +1,1685 @@
+/*
+ * virsh-domain.c: Commands to monitor domain status
+ *
+ * Copyright (C) 2005, 2007-2012 Red Hat, Inc
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library;  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ *  Daniel Veillard <veillard redhat com>
+ *  Karel Zak <kzak redhat com>
+ *  Daniel P. Berrange <berrange redhat com>
+ *
+ */
+
+static const char *
+vshDomainIOErrorToString(int error)
+{
+    switch ((virDomainDiskErrorCode) error) {
+    case VIR_DOMAIN_DISK_ERROR_NONE:
+        return _("no error");
+    case VIR_DOMAIN_DISK_ERROR_UNSPEC:
+        return _("unspecified error");
+    case VIR_DOMAIN_DISK_ERROR_NO_SPACE:
+        return _("no space");
+    case VIR_DOMAIN_DISK_ERROR_LAST:
+        ;
+    }
+
+    return _("unknown error");
+}
+
+/* extract description or title from domain xml */
+static char *
+vshGetDomainDescription(vshControl *ctl, virDomainPtr dom, bool title,
+                        unsigned int flags)
+{
+    char *desc = NULL;
+    char *domxml = NULL;
+    virErrorPtr err = NULL;
+    xmlDocPtr doc = NULL;
+    xmlXPathContextPtr ctxt = NULL;
+    int type;
+
+    if (title)
+        type = VIR_DOMAIN_METADATA_TITLE;
+    else
+        type = VIR_DOMAIN_METADATA_DESCRIPTION;
+
+    if ((desc = virDomainGetMetadata(dom, type, NULL, flags))) {
+        return desc;
+    } else {
+        err = virGetLastError();
+
+        if (err && err->code == VIR_ERR_NO_DOMAIN_METADATA) {
+            desc = vshStrdup(ctl, "");
+            virResetLastError();
+            return desc;
+        }
+
+        if (err && err->code != VIR_ERR_NO_SUPPORT)
+            return desc;
+    }
+
+    /* fall back to xml */
+    /* get domain's xml description and extract the title/description */
+    if (!(domxml = virDomainGetXMLDesc(dom, flags))) {
+        vshError(ctl, "%s", _("Failed to retrieve domain XML"));
+        goto cleanup;
+    }
+    doc = virXMLParseStringCtxt(domxml, _("(domain_definition)"), &ctxt);
+    if (!doc) {
+        vshError(ctl, "%s", _("Couldn't parse domain XML"));
+        goto cleanup;
+    }
+    if (title)
+        desc = virXPathString("string(./title[1])", ctxt);
+    else
+        desc = virXPathString("string(./description[1])", ctxt);
+
+    if (!desc)
+        desc = vshStrdup(ctl, "");
+
+cleanup:
+    VIR_FREE(domxml);
+    xmlXPathFreeContext(ctxt);
+    xmlFreeDoc(doc);
+
+    return desc;
+}
+static const char *
+vshDomainControlStateToString(int state)
+{
+    switch ((virDomainControlState) state) {
+    case VIR_DOMAIN_CONTROL_OK:
+        return N_("ok");
+    case VIR_DOMAIN_CONTROL_JOB:
+        return N_("background job");
+    case VIR_DOMAIN_CONTROL_OCCUPIED:
+        return N_("occupied");
+    case VIR_DOMAIN_CONTROL_ERROR:
+        return N_("error");
+    default:
+        ;
+    }
+
+    return N_("unknown");
+}
+
+static const char *
+vshDomainStateToString(int state)
+{
+    /* Can't use virDomainStateTypeToString, because we want to mark
+ *      * strings for translation.  */
+    switch ((virDomainState) state) {
+    case VIR_DOMAIN_RUNNING:
+        return N_("running");
+    case VIR_DOMAIN_BLOCKED:
+        return N_("idle");
+    case VIR_DOMAIN_PAUSED:
+        return N_("paused");
+    case VIR_DOMAIN_SHUTDOWN:
+        return N_("in shutdown");
+    case VIR_DOMAIN_SHUTOFF:
+        return N_("shut off");
+    case VIR_DOMAIN_CRASHED:
+        return N_("crashed");
+    case VIR_DOMAIN_PMSUSPENDED:
+        return N_("pmsuspended");
+    case VIR_DOMAIN_NOSTATE:
+    default:
+        ;/*FALLTHROUGH*/
+    }
+    return N_("no state");  /* = dom0 state */
+}
+
+static const char *
+vshDomainStateReasonToString(int state, int reason)
+{
+    switch ((virDomainState) state) {
+    case VIR_DOMAIN_NOSTATE:
+        switch ((virDomainNostateReason) reason) {
+        case VIR_DOMAIN_NOSTATE_UNKNOWN:
+        case VIR_DOMAIN_NOSTATE_LAST:
+            ;
+        }
+        break;
+
+    case VIR_DOMAIN_RUNNING:
+        switch ((virDomainRunningReason) reason) {
+        case VIR_DOMAIN_RUNNING_BOOTED:
+            return N_("booted");
+        case VIR_DOMAIN_RUNNING_MIGRATED:
+            return N_("migrated");
+        case VIR_DOMAIN_RUNNING_RESTORED:
+            return N_("restored");
+        case VIR_DOMAIN_RUNNING_FROM_SNAPSHOT:
+            return N_("from snapshot");
+        case VIR_DOMAIN_RUNNING_UNPAUSED:
+            return N_("unpaused");
+        case VIR_DOMAIN_RUNNING_MIGRATION_CANCELED:
+            return N_("migration canceled");
+        case VIR_DOMAIN_RUNNING_SAVE_CANCELED:
+            return N_("save canceled");
+        case VIR_DOMAIN_RUNNING_WAKEUP:
+            return N_("event wakeup");
+        case VIR_DOMAIN_RUNNING_UNKNOWN:
+        case VIR_DOMAIN_RUNNING_LAST:
+            ;
+        }
+        break;
+
+    case VIR_DOMAIN_BLOCKED:
+        switch ((virDomainBlockedReason) reason) {
+        case VIR_DOMAIN_BLOCKED_UNKNOWN:
+        case VIR_DOMAIN_BLOCKED_LAST:
+            ;
+        }
+        break;
+
+    case VIR_DOMAIN_PAUSED:
+        switch ((virDomainPausedReason) reason) {
+        case VIR_DOMAIN_PAUSED_USER:
+            return N_("user");
+        case VIR_DOMAIN_PAUSED_MIGRATION:
+            return N_("migrating");
+        case VIR_DOMAIN_PAUSED_SAVE:
+            return N_("saving");
+        case VIR_DOMAIN_PAUSED_DUMP:
+            return N_("dumping");
+        case VIR_DOMAIN_PAUSED_IOERROR:
+            return N_("I/O error");
+        case VIR_DOMAIN_PAUSED_WATCHDOG:
+            return N_("watchdog");
+        case VIR_DOMAIN_PAUSED_FROM_SNAPSHOT:
+            return N_("from snapshot");
+        case VIR_DOMAIN_PAUSED_SHUTTING_DOWN:
+            return N_("shutting down");
+        case VIR_DOMAIN_PAUSED_UNKNOWN:
+        case VIR_DOMAIN_PAUSED_LAST:
+            ;
+        }
+        break;
+
+    case VIR_DOMAIN_SHUTDOWN:
+        switch ((virDomainShutdownReason) reason) {
+        case VIR_DOMAIN_SHUTDOWN_USER:
+            return N_("user");
+        case VIR_DOMAIN_SHUTDOWN_UNKNOWN:
+        case VIR_DOMAIN_SHUTDOWN_LAST:
+            ;
+        }
+        break;
+
+    case VIR_DOMAIN_SHUTOFF:
+        switch ((virDomainShutoffReason) reason) {
+        case VIR_DOMAIN_SHUTOFF_SHUTDOWN:
+            return N_("shutdown");
+        case VIR_DOMAIN_SHUTOFF_DESTROYED:
+            return N_("destroyed");
+        case VIR_DOMAIN_SHUTOFF_CRASHED:
+            return N_("crashed");
+        case VIR_DOMAIN_SHUTOFF_MIGRATED:
+            return N_("migrated");
+        case VIR_DOMAIN_SHUTOFF_SAVED:
+            return N_("saved");
+        case VIR_DOMAIN_SHUTOFF_FAILED:
+            return N_("failed");
+        case VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT:
+            return N_("from snapshot");
+        case VIR_DOMAIN_SHUTOFF_UNKNOWN:
+        case VIR_DOMAIN_SHUTOFF_LAST:
+            ;
+        }
+        break;
+
+    case VIR_DOMAIN_CRASHED:
+        switch ((virDomainCrashedReason) reason) {
+        case VIR_DOMAIN_CRASHED_UNKNOWN:
+        case VIR_DOMAIN_CRASHED_LAST:
+            ;
+        }
+        break;
+
+    case VIR_DOMAIN_PMSUSPENDED:
+        switch ((virDomainPMSuspendedReason) reason) {
+        case VIR_DOMAIN_PMSUSPENDED_UNKNOWN:
+        case VIR_DOMAIN_PMSUSPENDED_LAST:
+            ;
+        }
+        break;
+
+    case VIR_DOMAIN_LAST:
+        ;
+    }
+
+    return N_("unknown");
+}
+
+/*
+ * "dommemstats" command
+ */
+static const vshCmdInfo info_dommemstat[] = {
+    {"help", N_("get memory statistics for a domain")},
+    {"desc", N_("Get memory statistics for a running domain.")},
+    {NULL,NULL}
+};
+
+static const vshCmdOptDef opts_dommemstat[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomMemStat(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    const char *name;
+    struct _virDomainMemoryStat stats[VIR_DOMAIN_MEMORY_STAT_NR];
+    unsigned int nr_stats, i;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
+        return false;
+
+    nr_stats = virDomainMemoryStats(dom, stats, VIR_DOMAIN_MEMORY_STAT_NR, 0);
+    if (nr_stats == -1) {
+        vshError(ctl, _("Failed to get memory statistics for domain %s"), name);
+        virDomainFree(dom);
+        return false;
+    }
+
+    for (i = 0; i < nr_stats; i++) {
+        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_SWAP_IN)
+            vshPrint(ctl, "swap_in %llu\n", stats[i].val);
+        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_SWAP_OUT)
+            vshPrint(ctl, "swap_out %llu\n", stats[i].val);
+        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT)
+            vshPrint(ctl, "major_fault %llu\n", stats[i].val);
+        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT)
+            vshPrint(ctl, "minor_fault %llu\n", stats[i].val);
+        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_UNUSED)
+            vshPrint(ctl, "unused %llu\n", stats[i].val);
+        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_AVAILABLE)
+            vshPrint(ctl, "available %llu\n", stats[i].val);
+        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON)
+            vshPrint(ctl, "actual %llu\n", stats[i].val);
+        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_RSS)
+            vshPrint(ctl, "rss %llu\n", stats[i].val);
+    }
+
+    virDomainFree(dom);
+    return true;
+}
+
+/*
+ * "domblkinfo" command
+ */
+static const vshCmdInfo info_domblkinfo[] = {
+    {"help", N_("domain block device size information")},
+    {"desc", N_("Get block device size info for a domain.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_domblkinfo[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"device", VSH_OT_DATA, VSH_OFLAG_REQ, N_("block device")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomblkinfo(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainBlockInfo info;
+    virDomainPtr dom;
+    bool ret = true;
+    const char *device = NULL;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
+        return false;
+
+    if (vshCommandOptString(cmd, "device", &device) <= 0) {
+        virDomainFree(dom);
+        return false;
+    }
+
+    if (virDomainGetBlockInfo(dom, device, &info, 0) < 0) {
+        virDomainFree(dom);
+        return false;
+    }
+
+    vshPrint(ctl, "%-15s %llu\n", _("Capacity:"), info.capacity);
+    vshPrint(ctl, "%-15s %llu\n", _("Allocation:"), info.allocation);
+    vshPrint(ctl, "%-15s %llu\n", _("Physical:"), info.physical);
+
+    virDomainFree(dom);
+    return ret;
+}
+
+/*
+ * "domblklist" command
+ */
+static const vshCmdInfo info_domblklist[] = {
+    {"help", N_("list all domain blocks")},
+    {"desc", N_("Get the summary of block devices for a domain.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_domblklist[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"inactive", VSH_OT_BOOL, 0,
+     N_("get inactive rather than running configuration")},
+    {"details", VSH_OT_BOOL, 0,
+     N_("additionally display the type and device value")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomblklist(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    bool ret = false;
+    unsigned int flags = 0;
+    char *xml = NULL;
+    xmlDocPtr xmldoc = NULL;
+    xmlXPathContextPtr ctxt = NULL;
+    int ndisks;
+    xmlNodePtr *disks = NULL;
+    int i;
+    bool details = false;
+
+    if (vshCommandOptBool(cmd, "inactive"))
+        flags |= VIR_DOMAIN_XML_INACTIVE;
+
+    details = vshCommandOptBool(cmd, "details");
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
+        return false;
+
+    xml = virDomainGetXMLDesc(dom, flags);
+    if (!xml)
+        goto cleanup;
+
+    xmldoc = virXMLParseStringCtxt(xml, _("(domain_definition)"), &ctxt);
+    if (!xmldoc)
+        goto cleanup;
+
+    ndisks = virXPathNodeSet("./devices/disk", ctxt, &disks);
+    if (ndisks < 0)
+        goto cleanup;
+
+    if (details)
+        vshPrint(ctl, "%-10s %-10s %-10s %s\n", _("Type"),
+                 _("Device"), _("Target"), _("Source"));
+    else
+        vshPrint(ctl, "%-10s %s\n", _("Target"), _("Source"));
+
+    vshPrint(ctl, "------------------------------------------------\n");
+
+    for (i = 0; i < ndisks; i++) {
+        char *type;
+        char *device;
+        char *target;
+        char *source;
+
+        ctxt->node = disks[i];
+
+        if (details) {
+            type = virXPathString("string(./@type)", ctxt);
+            device = virXPathString("string(./@device)", ctxt);
+        }
+
+        target = virXPathString("string(./target/@dev)", ctxt);
+        if (!target) {
+            vshError(ctl, "unable to query block list");
+            goto cleanup;
+        }
+        source = virXPathString("string(./source/@file"
+                                "|./source/@dev"
+                                "|./source/@dir"
+                                "|./source/@name)", ctxt);
+        if (details) {
+            vshPrint(ctl, "%-10s %-10s %-10s %s\n", type, device,
+                     target, source ? source : "-");
+            VIR_FREE(type);
+            VIR_FREE(device);
+        } else {
+            vshPrint(ctl, "%-10s %s\n", target, source ? source : "-");
+        }
+
+        VIR_FREE(target);
+        VIR_FREE(source);
+    }
+
+    ret = true;
+
+cleanup:
+    VIR_FREE(disks);
+    virDomainFree(dom);
+    VIR_FREE(xml);
+    xmlFreeDoc(xmldoc);
+    xmlXPathFreeContext(ctxt);
+    return ret;
+}
+
+/*
+ * "domiflist" command
+ */
+static const vshCmdInfo info_domiflist[] = {
+    {"help", N_("list all domain virtual interfaces")},
+    {"desc", N_("Get the summary of virtual interfaces for a domain.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_domiflist[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"inactive", VSH_OT_BOOL, 0,
+     N_("get inactive rather than running configuration")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomiflist(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    bool ret = false;
+    unsigned int flags = 0;
+    char *xml = NULL;
+    xmlDocPtr xmldoc = NULL;
+    xmlXPathContextPtr ctxt = NULL;
+    int ninterfaces;
+    xmlNodePtr *interfaces = NULL;
+    int i;
+
+    if (vshCommandOptBool(cmd, "inactive"))
+        flags |= VIR_DOMAIN_XML_INACTIVE;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
+        return false;
+
+    xml = virDomainGetXMLDesc(dom, flags);
+    if (!xml)
+        goto cleanup;
+
+    xmldoc = virXMLParseStringCtxt(xml, _("(domain_definition)"), &ctxt);
+    if (!xmldoc)
+        goto cleanup;
+
+    ninterfaces = virXPathNodeSet("./devices/interface", ctxt, &interfaces);
+    if (ninterfaces < 0)
+        goto cleanup;
+
+    vshPrint(ctl, "%-10s %-10s %-10s %-11s %s\n", _("Interface"), _("Type"),
+             _("Source"), _("Model"), _("MAC"));
+    vshPrint(ctl, "-------------------------------------------------------\n");
+
+    for (i = 0; i < ninterfaces; i++) {
+        char *type = NULL;
+        char *source = NULL;
+        char *target = NULL;
+        char *model = NULL;
+        char *mac = NULL;
+
+        ctxt->node = interfaces[i];
+        type = virXPathString("string(./@type)", ctxt);
+
+        source = virXPathString("string(./source/@bridge"
+                                "|./source/@dev"
+                                "|./source/@network"
+                                "|./source/@name)", ctxt);
+
+        target = virXPathString("string(./target/@dev)", ctxt);
+        model = virXPathString("string(./model/@type)", ctxt);
+        mac = virXPathString("string(./mac/@address)", ctxt);
+
+        vshPrint(ctl, "%-10s %-10s %-10s %-11s %-10s\n",
+                 target ? target : "-",
+                 type,
+                 source ? source : "-",
+                 model ? model : "-",
+                 mac ? mac : "-");
+
+        VIR_FREE(type);
+        VIR_FREE(source);
+        VIR_FREE(target);
+        VIR_FREE(model);
+        VIR_FREE(mac);
+    }
+
+    ret = true;
+
+cleanup:
+    VIR_FREE(interfaces);
+    virDomainFree(dom);
+    VIR_FREE(xml);
+    xmlFreeDoc(xmldoc);
+    xmlXPathFreeContext(ctxt);
+    return ret;
+}
+
+/*
+ * "domif-getlink" command
+ */
+static const vshCmdInfo info_domif_getlink[] = {
+    {"help", N_("get link state of a virtual interface")},
+    {"desc", N_("Get link state of a domain's virtual interface.")},
+    {NULL,NULL}
+};
+
+static const vshCmdOptDef opts_domif_getlink[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"interface", VSH_OT_DATA, VSH_OFLAG_REQ, N_("interface device (MAC Address)")},
+    {"persistent", VSH_OT_ALIAS, 0, "config"},
+    {"config", VSH_OT_BOOL, 0, N_("Get persistent interface state")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomIfGetLink(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    const char *iface = NULL;
+    int flags = 0;
+    char *state = NULL;
+    char *value = NULL;
+    virMacAddr macaddr;
+    const char *element;
+    const char *attr;
+    bool ret = false;
+    int i;
+    char *desc;
+    xmlDocPtr xml = NULL;
+    xmlXPathContextPtr ctxt = NULL;
+    xmlNodePtr cur = NULL;
+    xmlXPathObjectPtr obj = NULL;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
+        return false;
+
+    if (vshCommandOptString(cmd, "interface", &iface) <= 0) {
+        virDomainFree(dom);
+        return false;
+    }
+
+    if (vshCommandOptBool(cmd, "config"))
+        flags = VIR_DOMAIN_XML_INACTIVE;
+
+    desc = virDomainGetXMLDesc(dom, flags);
+    if (desc == NULL) {
+        vshError(ctl, _("Failed to get domain description xml"));
+        goto cleanup;
+    }
+
+    xml = virXMLParseStringCtxt(desc, _("(domain_definition)"), &ctxt);
+    VIR_FREE(desc);
+    if (!xml) {
+        vshError(ctl, _("Failed to parse domain description xml"));
+        goto cleanup;
+    }
+
+    obj = xmlXPathEval(BAD_CAST "/domain/devices/interface", ctxt);
+    if (obj == NULL || obj->type != XPATH_NODESET ||
+        obj->nodesetval == NULL || obj->nodesetval->nodeNr == 0) {
+        vshError(ctl, _("Failed to extract interface information or no interfaces found"));
+        goto cleanup;
+    }
+
+    if (virMacAddrParse(iface, &macaddr) == 0) {
+        element = "mac";
+        attr = "address";
+    } else {
+        element = "target";
+        attr = "dev";
+    }
+
+    /* find interface with matching mac addr */
+    for (i = 0; i < obj->nodesetval->nodeNr; i++) {
+        cur = obj->nodesetval->nodeTab[i]->children;
+
+        while (cur) {
+            if (cur->type == XML_ELEMENT_NODE &&
+                xmlStrEqual(cur->name, BAD_CAST element)) {
+
+                value = virXMLPropString(cur, attr);
+
+                if (STRCASEEQ(value, iface)) {
+                    VIR_FREE(value);
+                    goto hit;
+                }
+                VIR_FREE(value);
+            }
+            cur = cur->next;
+        }
+    }
+
+    vshError(ctl, _("Interface (%s: %s) not found."), element, iface);
+    goto cleanup;
+
+hit:
+    cur = obj->nodesetval->nodeTab[i]->children;
+    while (cur) {
+        if (cur->type == XML_ELEMENT_NODE &&
+            xmlStrEqual(cur->name, BAD_CAST "link")) {
+
+            state = virXMLPropString(cur, "state");
+            vshPrint(ctl, "%s %s", iface, state);
+            VIR_FREE(state);
+
+            goto cleanup;
+        }
+        cur = cur->next;
+    }
+
+    /* attribute not found */
+    vshPrint(ctl, "%s default", iface);
+
+    ret = true;
+cleanup:
+    xmlXPathFreeObject(obj);
+    xmlXPathFreeContext(ctxt);
+    xmlFreeDoc(xml);
+    if (dom)
+        virDomainFree(dom);
+
+    return ret;
+}
+
+/*
+ * "domcontrol" command
+ */
+static const vshCmdInfo info_domcontrol[] = {
+    {"help", N_("domain control interface state")},
+    {"desc", N_("Returns state of a control interface to the domain.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_domcontrol[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomControl(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    bool ret = true;
+    virDomainControlInfo info;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
+        return false;
+
+    if (virDomainGetControlInfo(dom, &info, 0) < 0) {
+        ret = false;
+        goto cleanup;
+    }
+
+    if (info.state != VIR_DOMAIN_CONTROL_OK &&
+        info.state != VIR_DOMAIN_CONTROL_ERROR) {
+        vshPrint(ctl, "%s (%0.3fs)\n",
+                 _(vshDomainControlStateToString(info.state)),
+                 info.stateTime / 1000.0);
+    } else {
+        vshPrint(ctl, "%s\n",
+                 _(vshDomainControlStateToString(info.state)));
+    }
+
+cleanup:
+    virDomainFree(dom);
+    return ret;
+}
+
+/*
+ * "domblkstat" command
+ */
+static const vshCmdInfo info_domblkstat[] = {
+    {"help", N_("get device block stats for a domain")},
+    {"desc", N_("Get device block stats for a running domain. See man page or "
+                "use --human for explanation of fields")},
+    {NULL,NULL}
+};
+
+static const vshCmdOptDef opts_domblkstat[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"device", VSH_OT_DATA, VSH_OFLAG_REQ, N_("block device")},
+    {"human",  VSH_OT_BOOL, 0, N_("print a more human readable output")},
+    {NULL, 0, 0, NULL}
+};
+
+struct _domblkstat_sequence {
+    const char *field;  /* field name */
+    const char *legacy; /* legacy name from previous releases */
+    const char *human;  /* human-friendly explanation */
+};
+
+/* sequence of values for output to honor legacy format from previous
+ * versions */
+static const struct _domblkstat_sequence domblkstat_output[] = {
+    { VIR_DOMAIN_BLOCK_STATS_READ_REQ,          "rd_req",
+      N_("number of read operations:") }, /* 0 */
+    { VIR_DOMAIN_BLOCK_STATS_READ_BYTES,        "rd_bytes",
+      N_("number of bytes read:") }, /* 1 */
+    { VIR_DOMAIN_BLOCK_STATS_WRITE_REQ,         "wr_req",
+      N_("number of write operations:") }, /* 2 */
+    { VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES,       "wr_bytes",
+      N_("number of bytes written:") }, /* 3 */
+    { VIR_DOMAIN_BLOCK_STATS_ERRS,              "errs",
+      N_("error count:") }, /* 4 */
+    { VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ,         NULL,
+      N_("number of flush operations:") }, /* 5 */
+    { VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES,  NULL,
+      N_("total duration of reads (ns):") }, /* 6 */
+    { VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES, NULL,
+      N_("total duration of writes (ns):") }, /* 7 */
+    { VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES, NULL,
+      N_("total duration of flushes (ns):") }, /* 8 */
+    { NULL, NULL, NULL }
+};
+
+#define DOMBLKSTAT_LEGACY_PRINT(ID, VALUE)              \
+    if (VALUE >= 0)                                     \
+        vshPrint(ctl, "%s %-*s %lld\n", device,         \
+                 human ? 31 : 0,                        \
+                 human ? _(domblkstat_output[ID].human) \
+                 : domblkstat_output[ID].legacy,        \
+                 VALUE);
+
+static bool
+cmdDomblkstat(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    const char *name = NULL, *device = NULL;
+    struct _virDomainBlockStats stats;
+    virTypedParameterPtr params = NULL;
+    virTypedParameterPtr par = NULL;
+    char *value = NULL;
+    const char *field = NULL;
+    int rc, nparams = 0;
+    int i = 0;
+    bool ret = false;
+    bool human = vshCommandOptBool(cmd, "human"); /* human readable output */
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
+        return false;
+
+    if (vshCommandOptString(cmd, "device", &device) <= 0)
+        goto cleanup;
+
+    rc = virDomainBlockStatsFlags(dom, device, NULL, &nparams, 0);
+
+    /* It might fail when virDomainBlockStatsFlags is not
+     * supported on older libvirt, fallback to use virDomainBlockStats
+     * then.
+     */
+    if (rc < 0) {
+        /* try older API if newer is not supported */
+        if (last_error->code != VIR_ERR_NO_SUPPORT)
+            goto cleanup;
+
+        virFreeError(last_error);
+        last_error = NULL;
+
+        if (virDomainBlockStats(dom, device, &stats,
+                                sizeof(stats)) == -1) {
+            vshError(ctl, _("Failed to get block stats %s %s"),
+                     name, device);
+            goto cleanup;
+        }
+
+        /* human friendly output */
+        if (human) {
+            vshPrint(ctl, N_("Device: %s\n"), device);
+            device = "";
+        }
+
+        DOMBLKSTAT_LEGACY_PRINT(0, stats.rd_req);
+        DOMBLKSTAT_LEGACY_PRINT(1, stats.rd_bytes);
+        DOMBLKSTAT_LEGACY_PRINT(2, stats.wr_req);
+        DOMBLKSTAT_LEGACY_PRINT(3, stats.wr_bytes);
+        DOMBLKSTAT_LEGACY_PRINT(4, stats.errs);
+    } else {
+        params = vshCalloc(ctl, nparams, sizeof(*params));
+
+        if (virDomainBlockStatsFlags(dom, device, params, &nparams, 0) < 0) {
+            vshError(ctl, _("Failed to get block stats %s %s"), name, device);
+            goto cleanup;
+        }
+
+        /* set for prettier output */
+        if (human) {
+            vshPrint(ctl, N_("Device: %s\n"), device);
+            device = "";
+        }
+
+        /* at first print all known values in desired order */
+        for (i = 0; domblkstat_output[i].field != NULL; i++) {
+            if (!(par = vshFindTypedParamByName(domblkstat_output[i].field,
+                                                params,
+                                                nparams)))
+                continue;
+
+            value = vshGetTypedParamValue(ctl, par);
+
+            /* to print other not supported fields, mark the already printed */
+            par->field[0] = '\0'; /* set the name to empty string */
+
+            /* translate into human readable or legacy spelling */
+            field = NULL;
+            if (human)
+                field = _(domblkstat_output[i].human);
+            else
+                field = domblkstat_output[i].legacy;
+
+            /* use the provided spelling if no translation is available */
+            if (!field)
+                field = domblkstat_output[i].field;
+
+            vshPrint(ctl, "%s %-*s %s\n", device,
+                     human ? 31 : 0, field, value);
+
+            VIR_FREE(value);
+        }
+
+        /* go through the fields again, for remaining fields */
+        for (i = 0; i < nparams; i++) {
+            if (!*params[i].field)
+                continue;
+
+            value = vshGetTypedParamValue(ctl, params+i);
+            vshPrint(ctl, "%s %s %s\n", device, params[i].field, value);
+            VIR_FREE(value);
+        }
+    }
+
+    ret = true;
+
+cleanup:
+    VIR_FREE(params);
+    virDomainFree(dom);
+    return ret;
+}
+#undef DOMBLKSTAT_LEGACY_PRINT
+
+/*
+ * "domifstat" command
+ */
+static const vshCmdInfo info_domifstat[] = {
+    {"help", N_("get network interface stats for a domain")},
+    {"desc", N_("Get network interface stats for a running domain.")},
+    {NULL,NULL}
+};
+
+static const vshCmdOptDef opts_domifstat[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"interface", VSH_OT_DATA, VSH_OFLAG_REQ, N_("interface device")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomIfstat(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    const char *name = NULL, *device = NULL;
+    struct _virDomainInterfaceStats stats;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
+        return false;
+
+    if (vshCommandOptString(cmd, "interface", &device) <= 0) {
+        virDomainFree(dom);
+        return false;
+    }
+
+    if (virDomainInterfaceStats(dom, device, &stats, sizeof(stats)) == -1) {
+        vshError(ctl, _("Failed to get interface stats %s %s"), name, device);
+        virDomainFree(dom);
+        return false;
+    }
+
+    if (stats.rx_bytes >= 0)
+        vshPrint(ctl, "%s rx_bytes %lld\n", device, stats.rx_bytes);
+
+    if (stats.rx_packets >= 0)
+        vshPrint(ctl, "%s rx_packets %lld\n", device, stats.rx_packets);
+
+    if (stats.rx_errs >= 0)
+        vshPrint(ctl, "%s rx_errs %lld\n", device, stats.rx_errs);
+
+    if (stats.rx_drop >= 0)
+        vshPrint(ctl, "%s rx_drop %lld\n", device, stats.rx_drop);
+
+    if (stats.tx_bytes >= 0)
+        vshPrint(ctl, "%s tx_bytes %lld\n", device, stats.tx_bytes);
+
+    if (stats.tx_packets >= 0)
+        vshPrint(ctl, "%s tx_packets %lld\n", device, stats.tx_packets);
+
+    if (stats.tx_errs >= 0)
+        vshPrint(ctl, "%s tx_errs %lld\n", device, stats.tx_errs);
+
+    if (stats.tx_drop >= 0)
+        vshPrint(ctl, "%s tx_drop %lld\n", device, stats.tx_drop);
+
+    virDomainFree(dom);
+    return true;
+}
+
+/*
+ * "domblkerror" command
+ */
+static const vshCmdInfo info_domblkerror[] = {
+    {"help", N_("Show errors on block devices")},
+    {"desc", N_("Show block device errors")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_domblkerror[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id, or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomBlkError(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    virDomainDiskErrorPtr disks = NULL;
+    unsigned int ndisks;
+    int i;
+    int count;
+    bool ret = false;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
+        return false;
+
+    if ((count = virDomainGetDiskErrors(dom, NULL, 0, 0)) < 0)
+        goto cleanup;
+    ndisks = count;
+
+    if (ndisks) {
+        if (VIR_ALLOC_N(disks, ndisks) < 0)
+            goto cleanup;
+
+        if ((count = virDomainGetDiskErrors(dom, disks, ndisks, 0)) == -1)
+            goto cleanup;
+    }
+
+    if (count == 0) {
+        vshPrint(ctl, _("No errors found\n"));
+    } else {
+        for (i = 0; i < count; i++) {
+            vshPrint(ctl, "%s: %s\n",
+                     disks[i].disk,
+                     vshDomainIOErrorToString(disks[i].error));
+        }
+    }
+
+    ret = true;
+
+cleanup:
+    VIR_FREE(disks);
+    virDomainFree(dom);
+    return ret;
+}
+
+/*
+ * "dominfo" command
+ */
+static const vshCmdInfo info_dominfo[] = {
+    {"help", N_("domain information")},
+    {"desc", N_("Returns basic information about the domain.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_dominfo[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDominfo(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainInfo info;
+    virDomainPtr dom;
+    virSecurityModel secmodel;
+    virSecurityLabelPtr seclabel;
+    int persistent = 0;
+    bool ret = true;
+    int autostart;
+    unsigned int id;
+    char *str, uuid[VIR_UUID_STRING_BUFLEN];
+    int has_managed_save = 0;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
+        return false;
+
+    id = virDomainGetID(dom);
+    if (id == ((unsigned int)-1))
+        vshPrint(ctl, "%-15s %s\n", _("Id:"), "-");
+    else
+        vshPrint(ctl, "%-15s %d\n", _("Id:"), id);
+    vshPrint(ctl, "%-15s %s\n", _("Name:"), virDomainGetName(dom));
+
+    if (virDomainGetUUIDString(dom, &uuid[0])==0)
+        vshPrint(ctl, "%-15s %s\n", _("UUID:"), uuid);
+
+    if ((str = virDomainGetOSType(dom))) {
+        vshPrint(ctl, "%-15s %s\n", _("OS Type:"), str);
+        VIR_FREE(str);
+    }
+
+    if (virDomainGetInfo(dom, &info) == 0) {
+        vshPrint(ctl, "%-15s %s\n", _("State:"),
+                 _(vshDomainStateToString(info.state)));
+
+        vshPrint(ctl, "%-15s %d\n", _("CPU(s):"), info.nrVirtCpu);
+
+        if (info.cpuTime != 0) {
+            double cpuUsed = info.cpuTime;
+
+            cpuUsed /= 1000000000.0;
+
+            vshPrint(ctl, "%-15s %.1lfs\n", _("CPU time:"), cpuUsed);
+        }
+
+        if (info.maxMem != UINT_MAX)
+            vshPrint(ctl, "%-15s %lu KiB\n", _("Max memory:"),
+                 info.maxMem);
+        else
+            vshPrint(ctl, "%-15s %s\n", _("Max memory:"),
+                 _("no limit"));
+
+        vshPrint(ctl, "%-15s %lu KiB\n", _("Used memory:"),
+                 info.memory);
+
+    } else {
+        ret = false;
+    }
+
+    /* Check and display whether the domain is persistent or not */
+    persistent = virDomainIsPersistent(dom);
+    vshDebug(ctl, VSH_ERR_DEBUG, "Domain persistent flag value: %d\n",
+             persistent);
+    if (persistent < 0)
+        vshPrint(ctl, "%-15s %s\n", _("Persistent:"), _("unknown"));
+    else
+        vshPrint(ctl, "%-15s %s\n", _("Persistent:"), persistent ? _("yes") : _("no"));
+
+    /* Check and display whether the domain autostarts or not */
+    if (!virDomainGetAutostart(dom, &autostart)) {
+        vshPrint(ctl, "%-15s %s\n", _("Autostart:"),
+                 autostart ? _("enable") : _("disable") );
+    }
+
+    has_managed_save = virDomainHasManagedSaveImage(dom, 0);
+    if (has_managed_save < 0)
+        vshPrint(ctl, "%-15s %s\n", _("Managed save:"), _("unknown"));
+    else
+        vshPrint(ctl, "%-15s %s\n", _("Managed save:"),
+                 has_managed_save ? _("yes") : _("no"));
+
+    /* Security model and label information */
+    memset(&secmodel, 0, sizeof(secmodel));
+    if (virNodeGetSecurityModel(ctl->conn, &secmodel) == -1) {
+        if (last_error->code != VIR_ERR_NO_SUPPORT) {
+            virDomainFree(dom);
+            return false;
+        } else {
+            virFreeError(last_error);
+            last_error = NULL;
+        }
+    } else {
+        /* Only print something if a security model is active */
+        if (secmodel.model[0] != '\0') {
+            vshPrint(ctl, "%-15s %s\n", _("Security model:"), secmodel.model);
+            vshPrint(ctl, "%-15s %s\n", _("Security DOI:"), secmodel.doi);
+
+            /* Security labels are only valid for active domains */
+            if (VIR_ALLOC(seclabel) < 0) {
+                virDomainFree(dom);
+                return false;
+            }
+
+            if (virDomainGetSecurityLabel(dom, seclabel) == -1) {
+                virDomainFree(dom);
+                VIR_FREE(seclabel);
+                return false;
+            } else {
+                if (seclabel->label[0] != '\0')
+                    vshPrint(ctl, "%-15s %s (%s)\n", _("Security label:"),
+                             seclabel->label, seclabel->enforcing ? "enforcing" : "permissive");
+            }
+
+            VIR_FREE(seclabel);
+        }
+    }
+    virDomainFree(dom);
+    return ret;
+}
+
+/*
+ * "domstate" command
+ */
+static const vshCmdInfo info_domstate[] = {
+    {"help", N_("domain state")},
+    {"desc", N_("Returns state about a domain.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_domstate[] = {
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"reason", VSH_OT_BOOL, 0, N_("also print reason for the state")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDomstate(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    bool ret = true;
+    bool showReason = vshCommandOptBool(cmd, "reason");
+    int state, reason;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
+        return false;
+
+    if ((state = vshDomainState(ctl, dom, &reason)) < 0) {
+        ret = false;
+        goto cleanup;
+    }
+
+    if (showReason) {
+        vshPrint(ctl, "%s (%s)\n",
+                 _(vshDomainStateToString(state)),
+                 vshDomainStateReasonToString(state, reason));
+    } else {
+        vshPrint(ctl, "%s\n",
+                 _(vshDomainStateToString(state)));
+    }
+
+cleanup:
+    virDomainFree(dom);
+    return ret;
+}
+
+/*
+ * "list" command
+ */
+static const vshCmdInfo info_list[] = {
+    {"help", N_("list domains")},
+    {"desc", N_("Returns list of domains.")},
+    {NULL, NULL}
+};
+
+/* compare domains, pack NULLed ones at the end*/
+static int
+vshDomainSorter(const void *a, const void *b)
+{
+    virDomainPtr *da = (virDomainPtr *) a;
+    virDomainPtr *db = (virDomainPtr *) b;
+    unsigned int ida;
+    unsigned int idb;
+    unsigned int inactive = (unsigned int) -1;
+
+    if (*da && !*db)
+        return -1;
+
+    if (!*da)
+        return *db != NULL;
+
+    ida = virDomainGetID(*da);
+    idb = virDomainGetID(*db);
+
+    if (ida == inactive && idb == inactive)
+        return strcasecmp(virDomainGetName(*da), virDomainGetName(*db));
+
+    if (ida != inactive && idb != inactive) {
+        if (ida > idb)
+            return 1;
+        else if (ida < idb)
+            return -1;
+    }
+
+    if (ida != inactive)
+        return -1;
+    else
+        return 1;
+}
+
+struct vshDomainList {
+    virDomainPtr *domains;
+    size_t ndomains;
+};
+typedef struct vshDomainList *vshDomainListPtr;
+
+static void
+vshDomainListFree(vshDomainListPtr domlist)
+{
+    int i;
+
+    if (domlist && domlist->domains) {
+        for (i = 0; i < domlist->ndomains; i++) {
+            if (domlist->domains[i])
+                virDomainFree(domlist->domains[i]);
+        }
+        VIR_FREE(domlist->domains);
+    }
+    VIR_FREE(domlist);
+}
+
+#define MATCH(FLAG) (flags & (FLAG))
+static vshDomainListPtr
+vshDomainListCollect(vshControl *ctl, unsigned int flags)
+{
+    vshDomainListPtr list = vshMalloc(ctl, sizeof(*list));
+    int i;
+    int ret;
+    int *ids = NULL;
+    int nids = 0;
+    char **names = NULL;
+    int nnames = 0;
+    virDomainPtr dom;
+    bool success = false;
+    size_t deleted = 0;
+    int persistent;
+    int autostart;
+    int state;
+    int nsnap;
+    int mansave;
+
+    /* try the list with flags support (0.9.13 and later) */
+    if ((ret = virConnectListAllDomains(ctl->conn, &list->domains,
+                                        flags)) >= 0) {
+        list->ndomains = ret;
+        goto finished;
+    }
+
+    /* check if the command is actually supported */
+    if (last_error && last_error->code == VIR_ERR_NO_SUPPORT) {
+        virFreeError(last_error);
+        last_error = NULL;
+        goto fallback;
+    }
+
+    if (last_error && last_error->code ==  VIR_ERR_INVALID_ARG) {
+        /* try the new API again but mask non-guaranteed flags */
+        unsigned int newflags = flags & (VIR_CONNECT_LIST_DOMAINS_ACTIVE |
+                                         VIR_CONNECT_LIST_DOMAINS_INACTIVE);
+
+        virFreeError(last_error);
+        last_error = NULL;
+        if ((ret = virConnectListAllDomains(ctl->conn, &list->domains,
+                                            newflags)) >= 0) {
+            list->ndomains = ret;
+            goto filter;
+        }
+    }
+
+    /* there was an error during the first or second call */
+    vshError(ctl, "%s", _("Failed to list domains"));
+    goto cleanup;
+
+
+fallback:
+    /* fall back to old method (0.9.12 and older) */
+    virResetLastError();
+
+    /* list active domains, if necessary */
+    if (!MATCH(VIR_CONNECT_LIST_FILTERS_ACTIVE) ||
+        MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE)) {
+        if ((nids = virConnectNumOfDomains(ctl->conn)) < 0) {
+            vshError(ctl, "%s", _("Failed to list active domains"));
+            goto cleanup;
+        }
+
+        if (nids) {
+            ids = vshMalloc(ctl, sizeof(int) * nids);
+
+            if ((nids = virConnectListDomains(ctl->conn, ids, nids)) < 0) {
+                vshError(ctl, "%s", _("Failed to list active domains"));
+                goto cleanup;
+            }
+        }
+    }
+
+    if (!MATCH(VIR_CONNECT_LIST_FILTERS_ACTIVE) ||
+        MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE)) {
+        if ((nnames = virConnectNumOfDefinedDomains(ctl->conn)) < 0) {
+            vshError(ctl, "%s", _("Failed to list inactive domains"));
+            goto cleanup;
+        }
+
+        if (nnames) {
+            names = vshMalloc(ctl, sizeof(char *) * nnames);
+
+            if ((nnames = virConnectListDefinedDomains(ctl->conn, names,
+                                                      nnames)) < 0) {
+                vshError(ctl, "%s", _("Failed to list inactive domains"));
+                goto cleanup;
+            }
+        }
+    }
+
+    list->domains = vshMalloc(ctl, sizeof(virDomainPtr) * (nids + nnames));
+    list->ndomains = 0;
+
+    /* get active domains */
+    for (i = 0; i < nids; i++) {
+        if (!(dom = virDomainLookupByID(ctl->conn, ids[i])))
+            continue;
+        list->domains[list->ndomains++] = dom;
+    }
+
+    /* get inactive domains */
+    for (i = 0; i < nnames; i++) {
+        if (!(dom = virDomainLookupByName(ctl->conn, names[i])))
+            continue;
+        list->domains[list->ndomains++] = dom;
+    }
+
+    /* truncate domains that weren't found */
+    deleted = (nids + nnames) - list->ndomains;
+
+filter:
+    /* filter list the list if the list was acquired by fallback means */
+    for (i = 0; i < list->ndomains; i++) {
+        dom = list->domains[i];
+
+        /* persistence filter */
+        if (MATCH(VIR_CONNECT_LIST_FILTERS_PERSISTENT)) {
+            if ((persistent = virDomainIsPersistent(dom)) < 0) {
+                vshError(ctl, "%s", _("Failed to get domain persistence info"));
+                goto cleanup;
+            }
+
+            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_PERSISTENT) && persistent) ||
+                  (MATCH(VIR_CONNECT_LIST_DOMAINS_TRANSIENT) && !persistent)))
+                goto remove_entry;
+        }
+
+        /* domain state filter */
+        if (MATCH(VIR_CONNECT_LIST_FILTERS_STATE)) {
+            if (virDomainGetState(dom, &state, NULL, 0) < 0) {
+                vshError(ctl, "%s", _("Failed to get domain state"));
+                goto cleanup;
+            }
+
+            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_RUNNING) &&
+                   state == VIR_DOMAIN_RUNNING) ||
+                  (MATCH(VIR_CONNECT_LIST_DOMAINS_PAUSED) &&
+                   state == VIR_DOMAIN_PAUSED) ||
+                  (MATCH(VIR_CONNECT_LIST_DOMAINS_SHUTOFF) &&
+                   state == VIR_DOMAIN_SHUTOFF) ||
+                  (MATCH(VIR_CONNECT_LIST_DOMAINS_OTHER) &&
+                   (state != VIR_DOMAIN_RUNNING &&
+                    state != VIR_DOMAIN_PAUSED &&
+                    state != VIR_DOMAIN_SHUTOFF))))
+                goto remove_entry;
+        }
+
+        /* autostart filter */
+        if (MATCH(VIR_CONNECT_LIST_FILTERS_AUTOSTART)) {
+            if (virDomainGetAutostart(dom, &autostart) < 0) {
+                vshError(ctl, "%s", _("Failed to get domain autostart state"));
+                goto cleanup;
+            }
+
+            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_AUTOSTART) && autostart) ||
+                  (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART) && !autostart)))
+                goto remove_entry;
+        }
+
+        /* managed save filter */
+        if (MATCH(VIR_CONNECT_LIST_FILTERS_MANAGEDSAVE)) {
+            if ((mansave = virDomainHasManagedSaveImage(dom, 0)) < 0) {
+                vshError(ctl, "%s",
+                         _("Failed to check for managed save image"));
+                goto cleanup;
+            }
+
+            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE) && mansave) ||
+                  (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE) && !mansave)))
+                goto remove_entry;
+        }
+
+        /* snapshot filter */
+        if (MATCH(VIR_CONNECT_LIST_FILTERS_SNAPSHOT)) {
+            if ((nsnap = virDomainSnapshotNum(dom, 0)) < 0) {
+                vshError(ctl, "%s", _("Failed to get snapshot count"));
+                goto cleanup;
+            }
+            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT) && nsnap > 0) ||
+                  (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) && nsnap == 0)))
+                goto remove_entry;
+        }
+
+        /* the domain matched all filters, it may stay */
+        continue;
+
+remove_entry:
+        /* the domain has to be removed as it failed one of the filters */
+        virDomainFree(list->domains[i]);
+        list->domains[i] = NULL;
+        deleted++;
+    }
+
+finished:
+    /* sort the list */
+    if (list->domains && list->ndomains)
+        qsort(list->domains, list->ndomains, sizeof(*list->domains),
+              vshDomainSorter);
+
+    /* truncate the list if filter simulation deleted entries */
+    if (deleted)
+        VIR_SHRINK_N(list->domains, list->ndomains, deleted);
+
+    success = true;
+
+cleanup:
+    for (i = 0; i < nnames; i++)
+        VIR_FREE(names[i]);
+
+    if (!success) {
+        vshDomainListFree(list);
+        list = NULL;
+    }
+
+    VIR_FREE(names);
+    VIR_FREE(ids);
+    return list;
+}
+#undef MATCH
+
+static const vshCmdOptDef opts_list[] = {
+    {"inactive", VSH_OT_BOOL, 0, N_("list inactive domains")},
+    {"all", VSH_OT_BOOL, 0, N_("list inactive & active domains")},
+    {"transient", VSH_OT_BOOL, 0, N_("list transient domains")},
+    {"persistent", VSH_OT_BOOL, 0, N_("list persistent domains")},
+    {"with-snapshot", VSH_OT_BOOL, 0,
+     N_("list domains with existing snapshot")},
+    {"without-snapshot", VSH_OT_BOOL, 0,
+     N_("list domains without a snapshot")},
+    {"state-running", VSH_OT_BOOL, 0, N_("list domains in running state")},
+    {"state-paused", VSH_OT_BOOL, 0, N_("list domains in paused state")},
+    {"state-shutoff", VSH_OT_BOOL, 0, N_("list domains in shutoff state")},
+    {"state-other", VSH_OT_BOOL, 0, N_("list domains in other states")},
+    {"autostart", VSH_OT_BOOL, 0, N_("list domains with autostart enabled")},
+    {"no-autostart", VSH_OT_BOOL, 0,
+     N_("list domains with autostart disabled")},
+    {"with-managed-save", VSH_OT_BOOL, 0,
+     N_("list domains with managed save state")},
+    {"without-managed-save", VSH_OT_BOOL, 0,
+     N_("list domains without managed save")},
+    {"uuid", VSH_OT_BOOL, 0, N_("list uuid's only")},
+    {"name", VSH_OT_BOOL, 0, N_("list domain names only")},
+    {"table", VSH_OT_BOOL, 0, N_("list table (default)")},
+    {"managed-save", VSH_OT_BOOL, 0,
+     N_("mark inactive domains with managed save state")},
+    {"title", VSH_OT_BOOL, 0, N_("show short domain description")},
+    {NULL, 0, 0, NULL}
+};
+
+#define FILTER(NAME, FLAG)              \
+    if (vshCommandOptBool(cmd, NAME))   \
+        flags |= (FLAG)
+static bool
+cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
+{
+    bool managed = vshCommandOptBool(cmd, "managed-save");
+    bool optTitle = vshCommandOptBool(cmd, "title");
+    bool optTable = vshCommandOptBool(cmd, "table");
+    bool optUUID = vshCommandOptBool(cmd, "uuid");
+    bool optName = vshCommandOptBool(cmd, "name");
+    int i;
+    char *title;
+    char uuid[VIR_UUID_STRING_BUFLEN];
+    int state;
+    bool ret = false;
+    vshDomainListPtr list = NULL;
+    virDomainPtr dom;
+    char id_buf[INT_BUFSIZE_BOUND(unsigned int)];
+    unsigned int id;
+    unsigned int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE;
+
+    /* construct filter flags */
+    if (vshCommandOptBool(cmd, "inactive"))
+        flags = VIR_CONNECT_LIST_DOMAINS_INACTIVE;
+
+    if (vshCommandOptBool(cmd, "all"))
+        flags = VIR_CONNECT_LIST_DOMAINS_INACTIVE |
+                VIR_CONNECT_LIST_DOMAINS_ACTIVE;
+
+    FILTER("persistent", VIR_CONNECT_LIST_DOMAINS_PERSISTENT);
+    FILTER("transient",  VIR_CONNECT_LIST_DOMAINS_TRANSIENT);
+
+    FILTER("with-managed-save",    VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE);
+    FILTER("without-managed-save", VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE);
+
+    FILTER("autostart",    VIR_CONNECT_LIST_DOMAINS_AUTOSTART);
+    FILTER("no-autostart", VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART);
+
+    FILTER("with-snapshot",    VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT);
+    FILTER("without-snapshot", VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT);
+
+    FILTER("state-running", VIR_CONNECT_LIST_DOMAINS_RUNNING);
+    FILTER("state-paused",  VIR_CONNECT_LIST_DOMAINS_PAUSED);
+    FILTER("state-shutoff", VIR_CONNECT_LIST_DOMAINS_SHUTOFF);
+    FILTER("state-other",   VIR_CONNECT_LIST_DOMAINS_OTHER);
+
+    if (optTable + optName + optUUID > 1) {
+        vshError(ctl, "%s",
+                 _("Only one argument from --table, --name and --uuid "
+                   "may be specified."));
+        return false;
+    }
+
+    if (!optUUID && !optName)
+        optTable = true;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(list = vshDomainListCollect(ctl, flags)))
+        goto cleanup;
+
+    /* print table header in legacy mode */
+    if (optTable) {
+        if (optTitle)
+            vshPrintExtra(ctl, " %-5s %-30s %-10s %-20s\n%s\n",
+                          _("Id"), _("Name"), _("State"), _("Title"),
+                          "-----------------------------------------"
+                          "-----------------------------------------");
+        else
+            vshPrintExtra(ctl, " %-5s %-30s %s\n%s\n",
+                          _("Id"), _("Name"), _("State"),
+                          "-----------------------------------------"
+                          "-----------");
+    }
+
+    for (i = 0; i < list->ndomains; i++) {
+        dom = list->domains[i];
+        id = virDomainGetID(dom);
+        if (id != (unsigned int) -1)
+            snprintf(id_buf, sizeof(id_buf), "%d", id);
+        else
+            ignore_value(virStrcpyStatic(id_buf, "-"));
+
+        state = vshDomainState(ctl, dom, NULL);
+        if (optTable && managed && state == VIR_DOMAIN_SHUTOFF &&
+            virDomainHasManagedSaveImage(dom, 0) > 0)
+            state = -2;
+
+        if (optTable) {
+            if (optTitle) {
+                if (!(title = vshGetDomainDescription(ctl, dom, true, 0)))
+                    goto cleanup;
+
+                vshPrint(ctl, " %-5s %-30s %-10s %-20s\n", id_buf,
+                         virDomainGetName(dom),
+                         state == -2 ? _("saved") : _(vshDomainStateToString(state)),
+                         title);
+
+                VIR_FREE(title);
+            } else {
+                vshPrint(ctl, " %-5s %-30s %s\n", id_buf,
+                         virDomainGetName(dom),
+                         state == -2 ? _("saved") : _(vshDomainStateToString(state)));
+            }
+        } else if (optUUID) {
+            if (virDomainGetUUIDString(dom, uuid) < 0) {
+                vshError(ctl, "%s", _("Failed to get domain's UUID"));
+                goto cleanup;
+            }
+            vshPrint(ctl, "%s\n", uuid);
+        } else if (optName) {
+            vshPrint(ctl, "%s\n", virDomainGetName(dom));
+        }
+    }
+
+    ret = true;
+cleanup:
+    vshDomainListFree(list);
+    return ret;
+}
+#undef FILTER
diff --git a/tools/virsh.c b/tools/virsh.c
index 81976a0..85c171b 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -976,450 +976,6 @@ cleanup:
 
 #endif /* WIN32 */
 
-
-/*
- * "list" command
- */
-static const vshCmdInfo info_list[] = {
-    {"help", N_("list domains")},
-    {"desc", N_("Returns list of domains.")},
-    {NULL, NULL}
-};
-
-/* compare domains, pack NULLed ones at the end*/
-static int
-vshDomainSorter(const void *a, const void *b)
-{
-    virDomainPtr *da = (virDomainPtr *) a;
-    virDomainPtr *db = (virDomainPtr *) b;
-    unsigned int ida;
-    unsigned int idb;
-    unsigned int inactive = (unsigned int) -1;
-
-    if (*da && !*db)
-        return -1;
-
-    if (!*da)
-        return *db != NULL;
-
-    ida = virDomainGetID(*da);
-    idb = virDomainGetID(*db);
-
-    if (ida == inactive && idb == inactive)
-        return strcasecmp(virDomainGetName(*da), virDomainGetName(*db));
-
-    if (ida != inactive && idb != inactive) {
-        if (ida > idb)
-            return 1;
-        else if (ida < idb)
-            return -1;
-    }
-
-    if (ida != inactive)
-        return -1;
-    else
-        return 1;
-}
-
-struct vshDomainList {
-    virDomainPtr *domains;
-    size_t ndomains;
-};
-typedef struct vshDomainList *vshDomainListPtr;
-
-static void
-vshDomainListFree(vshDomainListPtr domlist)
-{
-    int i;
-
-    if (domlist && domlist->domains) {
-        for (i = 0; i < domlist->ndomains; i++) {
-            if (domlist->domains[i])
-                virDomainFree(domlist->domains[i]);
-        }
-        VIR_FREE(domlist->domains);
-    }
-    VIR_FREE(domlist);
-}
-
-#define MATCH(FLAG) (flags & (FLAG))
-static vshDomainListPtr
-vshDomainListCollect(vshControl *ctl, unsigned int flags)
-{
-    vshDomainListPtr list = vshMalloc(ctl, sizeof(*list));
-    int i;
-    int ret;
-    int *ids = NULL;
-    int nids = 0;
-    char **names = NULL;
-    int nnames = 0;
-    virDomainPtr dom;
-    bool success = false;
-    size_t deleted = 0;
-    int persistent;
-    int autostart;
-    int state;
-    int nsnap;
-    int mansave;
-
-    /* try the list with flags support (0.9.13 and later) */
-    if ((ret = virConnectListAllDomains(ctl->conn, &list->domains,
-                                        flags)) >= 0) {
-        list->ndomains = ret;
-        goto finished;
-    }
-
-    /* check if the command is actually supported */
-    if (last_error && last_error->code == VIR_ERR_NO_SUPPORT) {
-        virFreeError(last_error);
-        last_error = NULL;
-        goto fallback;
-    }
-
-    if (last_error && last_error->code ==  VIR_ERR_INVALID_ARG) {
-        /* try the new API again but mask non-guaranteed flags */
-        unsigned int newflags = flags & (VIR_CONNECT_LIST_DOMAINS_ACTIVE |
-                                         VIR_CONNECT_LIST_DOMAINS_INACTIVE);
-
-        virFreeError(last_error);
-        last_error = NULL;
-        if ((ret = virConnectListAllDomains(ctl->conn, &list->domains,
-                                            newflags)) >= 0) {
-            list->ndomains = ret;
-            goto filter;
-        }
-    }
-
-    /* there was an error during the first or second call */
-    vshError(ctl, "%s", _("Failed to list domains"));
-    goto cleanup;
-
-
-fallback:
-    /* fall back to old method (0.9.12 and older) */
-    virResetLastError();
-
-    /* list active domains, if necessary */
-    if (!MATCH(VIR_CONNECT_LIST_FILTERS_ACTIVE) ||
-        MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE)) {
-        if ((nids = virConnectNumOfDomains(ctl->conn)) < 0) {
-            vshError(ctl, "%s", _("Failed to list active domains"));
-            goto cleanup;
-        }
-
-        if (nids) {
-            ids = vshMalloc(ctl, sizeof(int) * nids);
-
-            if ((nids = virConnectListDomains(ctl->conn, ids, nids)) < 0) {
-                vshError(ctl, "%s", _("Failed to list active domains"));
-                goto cleanup;
-            }
-        }
-    }
-
-    if (!MATCH(VIR_CONNECT_LIST_FILTERS_ACTIVE) ||
-        MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE)) {
-        if ((nnames = virConnectNumOfDefinedDomains(ctl->conn)) < 0) {
-            vshError(ctl, "%s", _("Failed to list inactive domains"));
-            goto cleanup;
-        }
-
-        if (nnames) {
-            names = vshMalloc(ctl, sizeof(char *) * nnames);
-
-            if ((nnames = virConnectListDefinedDomains(ctl->conn, names,
-                                                      nnames)) < 0) {
-                vshError(ctl, "%s", _("Failed to list inactive domains"));
-                goto cleanup;
-            }
-        }
-    }
-
-    list->domains = vshMalloc(ctl, sizeof(virDomainPtr) * (nids + nnames));
-    list->ndomains = 0;
-
-    /* get active domains */
-    for (i = 0; i < nids; i++) {
-        if (!(dom = virDomainLookupByID(ctl->conn, ids[i])))
-            continue;
-        list->domains[list->ndomains++] = dom;
-    }
-
-    /* get inactive domains */
-    for (i = 0; i < nnames; i++) {
-        if (!(dom = virDomainLookupByName(ctl->conn, names[i])))
-            continue;
-        list->domains[list->ndomains++] = dom;
-    }
-
-    /* truncate domains that weren't found */
-    deleted = (nids + nnames) - list->ndomains;
-
-filter:
-    /* filter list the list if the list was acquired by fallback means */
-    for (i = 0; i < list->ndomains; i++) {
-        dom = list->domains[i];
-
-        /* persistence filter */
-        if (MATCH(VIR_CONNECT_LIST_FILTERS_PERSISTENT)) {
-            if ((persistent = virDomainIsPersistent(dom)) < 0) {
-                vshError(ctl, "%s", _("Failed to get domain persistence info"));
-                goto cleanup;
-            }
-
-            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_PERSISTENT) && persistent) ||
-                  (MATCH(VIR_CONNECT_LIST_DOMAINS_TRANSIENT) && !persistent)))
-                goto remove_entry;
-        }
-
-        /* domain state filter */
-        if (MATCH(VIR_CONNECT_LIST_FILTERS_STATE)) {
-            if (virDomainGetState(dom, &state, NULL, 0) < 0) {
-                vshError(ctl, "%s", _("Failed to get domain state"));
-                goto cleanup;
-            }
-
-            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_RUNNING) &&
-                   state == VIR_DOMAIN_RUNNING) ||
-                  (MATCH(VIR_CONNECT_LIST_DOMAINS_PAUSED) &&
-                   state == VIR_DOMAIN_PAUSED) ||
-                  (MATCH(VIR_CONNECT_LIST_DOMAINS_SHUTOFF) &&
-                   state == VIR_DOMAIN_SHUTOFF) ||
-                  (MATCH(VIR_CONNECT_LIST_DOMAINS_OTHER) &&
-                   (state != VIR_DOMAIN_RUNNING &&
-                    state != VIR_DOMAIN_PAUSED &&
-                    state != VIR_DOMAIN_SHUTOFF))))
-                goto remove_entry;
-        }
-
-        /* autostart filter */
-        if (MATCH(VIR_CONNECT_LIST_FILTERS_AUTOSTART)) {
-            if (virDomainGetAutostart(dom, &autostart) < 0) {
-                vshError(ctl, "%s", _("Failed to get domain autostart state"));
-                goto cleanup;
-            }
-
-            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_AUTOSTART) && autostart) ||
-                  (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART) && !autostart)))
-                goto remove_entry;
-        }
-
-        /* managed save filter */
-        if (MATCH(VIR_CONNECT_LIST_FILTERS_MANAGEDSAVE)) {
-            if ((mansave = virDomainHasManagedSaveImage(dom, 0)) < 0) {
-                vshError(ctl, "%s",
-                         _("Failed to check for managed save image"));
-                goto cleanup;
-            }
-
-            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE) && mansave) ||
-                  (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE) && !mansave)))
-                goto remove_entry;
-        }
-
-        /* snapshot filter */
-        if (MATCH(VIR_CONNECT_LIST_FILTERS_SNAPSHOT)) {
-            if ((nsnap = virDomainSnapshotNum(dom, 0)) < 0) {
-                vshError(ctl, "%s", _("Failed to get snapshot count"));
-                goto cleanup;
-            }
-            if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT) && nsnap > 0) ||
-                  (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) && nsnap == 0)))
-                goto remove_entry;
-        }
-
-        /* the domain matched all filters, it may stay */
-        continue;
-
-remove_entry:
-        /* the domain has to be removed as it failed one of the filters */
-        virDomainFree(list->domains[i]);
-        list->domains[i] = NULL;
-        deleted++;
-    }
-
-finished:
-    /* sort the list */
-    if (list->domains && list->ndomains)
-        qsort(list->domains, list->ndomains, sizeof(*list->domains),
-              vshDomainSorter);
-
-    /* truncate the list if filter simulation deleted entries */
-    if (deleted)
-        VIR_SHRINK_N(list->domains, list->ndomains, deleted);
-
-    success = true;
-
-cleanup:
-    for (i = 0; i < nnames; i++)
-        VIR_FREE(names[i]);
-
-    if (!success) {
-        vshDomainListFree(list);
-        list = NULL;
-    }
-
-    VIR_FREE(names);
-    VIR_FREE(ids);
-    return list;
-}
-#undef MATCH
-
-
-static const vshCmdOptDef opts_list[] = {
-    {"inactive", VSH_OT_BOOL, 0, N_("list inactive domains")},
-    {"all", VSH_OT_BOOL, 0, N_("list inactive & active domains")},
-    {"transient", VSH_OT_BOOL, 0, N_("list transient domains")},
-    {"persistent", VSH_OT_BOOL, 0, N_("list persistent domains")},
-    {"with-snapshot", VSH_OT_BOOL, 0,
-     N_("list domains with existing snapshot")},
-    {"without-snapshot", VSH_OT_BOOL, 0,
-     N_("list domains without a snapshot")},
-    {"state-running", VSH_OT_BOOL, 0, N_("list domains in running state")},
-    {"state-paused", VSH_OT_BOOL, 0, N_("list domains in paused state")},
-    {"state-shutoff", VSH_OT_BOOL, 0, N_("list domains in shutoff state")},
-    {"state-other", VSH_OT_BOOL, 0, N_("list domains in other states")},
-    {"autostart", VSH_OT_BOOL, 0, N_("list domains with autostart enabled")},
-    {"no-autostart", VSH_OT_BOOL, 0,
-     N_("list domains with autostart disabled")},
-    {"with-managed-save", VSH_OT_BOOL, 0,
-     N_("list domains with managed save state")},
-    {"without-managed-save", VSH_OT_BOOL, 0,
-     N_("list domains without managed save")},
-    {"uuid", VSH_OT_BOOL, 0, N_("list uuid's only")},
-    {"name", VSH_OT_BOOL, 0, N_("list domain names only")},
-    {"table", VSH_OT_BOOL, 0, N_("list table (default)")},
-    {"managed-save", VSH_OT_BOOL, 0,
-     N_("mark inactive domains with managed save state")},
-    {"title", VSH_OT_BOOL, 0, N_("show short domain description")},
-    {NULL, 0, 0, NULL}
-};
-
-
-#define FILTER(NAME, FLAG)              \
-    if (vshCommandOptBool(cmd, NAME))   \
-        flags |= (FLAG)
-static bool
-cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
-{
-    bool managed = vshCommandOptBool(cmd, "managed-save");
-    bool optTitle = vshCommandOptBool(cmd, "title");
-    bool optTable = vshCommandOptBool(cmd, "table");
-    bool optUUID = vshCommandOptBool(cmd, "uuid");
-    bool optName = vshCommandOptBool(cmd, "name");
-    int i;
-    char *title;
-    char uuid[VIR_UUID_STRING_BUFLEN];
-    int state;
-    bool ret = false;
-    vshDomainListPtr list = NULL;
-    virDomainPtr dom;
-    char id_buf[INT_BUFSIZE_BOUND(unsigned int)];
-    unsigned int id;
-    unsigned int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE;
-
-    /* construct filter flags */
-    if (vshCommandOptBool(cmd, "inactive"))
-        flags = VIR_CONNECT_LIST_DOMAINS_INACTIVE;
-
-    if (vshCommandOptBool(cmd, "all"))
-        flags = VIR_CONNECT_LIST_DOMAINS_INACTIVE |
-                VIR_CONNECT_LIST_DOMAINS_ACTIVE;
-
-    FILTER("persistent", VIR_CONNECT_LIST_DOMAINS_PERSISTENT);
-    FILTER("transient",  VIR_CONNECT_LIST_DOMAINS_TRANSIENT);
-
-    FILTER("with-managed-save",    VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE);
-    FILTER("without-managed-save", VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE);
-
-    FILTER("autostart",    VIR_CONNECT_LIST_DOMAINS_AUTOSTART);
-    FILTER("no-autostart", VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART);
-
-    FILTER("with-snapshot",    VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT);
-    FILTER("without-snapshot", VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT);
-
-    FILTER("state-running", VIR_CONNECT_LIST_DOMAINS_RUNNING);
-    FILTER("state-paused",  VIR_CONNECT_LIST_DOMAINS_PAUSED);
-    FILTER("state-shutoff", VIR_CONNECT_LIST_DOMAINS_SHUTOFF);
-    FILTER("state-other",   VIR_CONNECT_LIST_DOMAINS_OTHER);
-
-    if (optTable + optName + optUUID > 1) {
-        vshError(ctl, "%s",
-                 _("Only one argument from --table, --name and --uuid "
-                   "may be specified."));
-        return false;
-    }
-
-    if (!optUUID && !optName)
-        optTable = true;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(list = vshDomainListCollect(ctl, flags)))
-        goto cleanup;
-
-    /* print table header in legacy mode */
-    if (optTable) {
-        if (optTitle)
-            vshPrintExtra(ctl, " %-5s %-30s %-10s %-20s\n%s\n",
-                          _("Id"), _("Name"), _("State"), _("Title"),
-                          "-----------------------------------------"
-                          "-----------------------------------------");
-        else
-            vshPrintExtra(ctl, " %-5s %-30s %s\n%s\n",
-                          _("Id"), _("Name"), _("State"),
-                          "-----------------------------------------"
-                          "-----------");
-    }
-
-    for (i = 0; i < list->ndomains; i++) {
-        dom = list->domains[i];
-        id = virDomainGetID(dom);
-        if (id != (unsigned int) -1)
-            snprintf(id_buf, sizeof(id_buf), "%d", id);
-        else
-            ignore_value(virStrcpyStatic(id_buf, "-"));
-
-        state = vshDomainState(ctl, dom, NULL);
-        if (optTable && managed && state == VIR_DOMAIN_SHUTOFF &&
-            virDomainHasManagedSaveImage(dom, 0) > 0)
-            state = -2;
-
-        if (optTable) {
-            if (optTitle) {
-                if (!(title = vshGetDomainDescription(ctl, dom, true, 0)))
-                    goto cleanup;
-
-                vshPrint(ctl, " %-5s %-30s %-10s %-20s\n", id_buf,
-                         virDomainGetName(dom),
-                         state == -2 ? _("saved") : _(vshDomainStateToString(state)),
-                         title);
-
-                VIR_FREE(title);
-            } else {
-                vshPrint(ctl, " %-5s %-30s %s\n", id_buf,
-                         virDomainGetName(dom),
-                         state == -2 ? _("saved") : _(vshDomainStateToString(state)));
-            }
-        } else if (optUUID) {
-            if (virDomainGetUUIDString(dom, uuid) < 0) {
-                vshError(ctl, "%s", _("Failed to get domain's UUID"));
-                goto cleanup;
-            }
-            vshPrint(ctl, "%s\n", uuid);
-        } else if (optName) {
-            vshPrint(ctl, "%s\n", virDomainGetName(dom));
-        }
-    }
-
-    ret = true;
-cleanup:
-    vshDomainListFree(list);
-    return ret;
-}
-#undef FILTER
-
 /*
  * "desc" command for managing domain description and title
  */
@@ -1576,28 +1132,43 @@ cleanup:
     return ret;
 }
 
-/*
- * "domstate" command
+/* "domif-setlink" command
  */
-static const vshCmdInfo info_domstate[] = {
-    {"help", N_("domain state")},
-    {"desc", N_("Returns state about a domain.")},
-    {NULL, NULL}
+static const vshCmdInfo info_domif_setlink[] = {
+    {"help", N_("set link state of a virtual interface")},
+    {"desc", N_("Set link state of a domain's virtual interface. This command wraps usage of update-device command.")},
+    {NULL,NULL}
 };
 
-static const vshCmdOptDef opts_domstate[] = {
+static const vshCmdOptDef opts_domif_setlink[] = {
     {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"reason", VSH_OT_BOOL, 0, N_("also print reason for the state")},
+    {"interface", VSH_OT_DATA, VSH_OFLAG_REQ, N_("interface device (MAC Address)")},
+    {"state", VSH_OT_DATA, VSH_OFLAG_REQ, N_("new state of the device")},
+    {"persistent", VSH_OT_ALIAS, 0, "config"},
+    {"config", VSH_OT_BOOL, 0, N_("affect next boot")},
     {NULL, 0, 0, NULL}
 };
 
 static bool
-cmdDomstate(vshControl *ctl, const vshCmd *cmd)
+cmdDomIfSetLink(vshControl *ctl, const vshCmd *cmd)
 {
     virDomainPtr dom;
-    bool ret = true;
-    bool showReason = vshCommandOptBool(cmd, "reason");
-    int state, reason;
+    const char *iface;
+    const char *state;
+    const char *value;
+    const char *desc;
+    virMacAddr macaddr;
+    const char *element;
+    const char *attr;
+    bool config;
+    bool ret = false;
+    unsigned int flags = 0;
+    int i;
+    xmlDocPtr xml = NULL;
+    xmlXPathContextPtr ctxt = NULL;
+    xmlXPathObjectPtr obj = NULL;
+    xmlNodePtr cur = NULL;
+    xmlBufferPtr xml_buf = NULL;
 
     if (!vshConnectionUsability(ctl, ctl->conn))
         return false;
@@ -1605,382 +1176,33 @@ cmdDomstate(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if ((state = vshDomainState(ctl, dom, &reason)) < 0) {
-        ret = false;
+    if (vshCommandOptString(cmd, "interface", &iface) <= 0)
         goto cleanup;
-    }
-
-    if (showReason) {
-        vshPrint(ctl, "%s (%s)\n",
-                 _(vshDomainStateToString(state)),
-                 vshDomainStateReasonToString(state, reason));
-    } else {
-        vshPrint(ctl, "%s\n",
-                 _(vshDomainStateToString(state)));
-    }
-
-cleanup:
-    virDomainFree(dom);
-    return ret;
-}
-
-/*
- * "domcontrol" command
- */
-static const vshCmdInfo info_domcontrol[] = {
-    {"help", N_("domain control interface state")},
-    {"desc", N_("Returns state of a control interface to the domain.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_domcontrol[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomControl(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    bool ret = true;
-    virDomainControlInfo info;
 
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
+    if (vshCommandOptString(cmd, "state", &state) <= 0)
+        goto cleanup;
 
-    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
-        return false;
+    config = vshCommandOptBool(cmd, "config");
 
-    if (virDomainGetControlInfo(dom, &info, 0) < 0) {
-        ret = false;
+    if (STRNEQ(state, "up") && STRNEQ(state, "down")) {
+        vshError(ctl, _("invalid link state '%s'"), state);
         goto cleanup;
     }
 
-    if (info.state != VIR_DOMAIN_CONTROL_OK &&
-        info.state != VIR_DOMAIN_CONTROL_ERROR) {
-        vshPrint(ctl, "%s (%0.3fs)\n",
-                 _(vshDomainControlStateToString(info.state)),
-                 info.stateTime / 1000.0);
-    } else {
-        vshPrint(ctl, "%s\n",
-                 _(vshDomainControlStateToString(info.state)));
+    /* get persistent or live description of network device */
+    desc = virDomainGetXMLDesc(dom, config ? VIR_DOMAIN_XML_INACTIVE : 0);
+    if (desc == NULL) {
+        vshError(ctl, _("Failed to get domain description xml"));
+        goto cleanup;
     }
 
-cleanup:
-    virDomainFree(dom);
-    return ret;
-}
+    if (config)
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
+    else
+        flags = VIR_DOMAIN_AFFECT_LIVE;
 
-/* "domblkstat" command
- */
-static const vshCmdInfo info_domblkstat[] = {
-    {"help", N_("get device block stats for a domain")},
-    {"desc", N_("Get device block stats for a running domain. See man page or "
-                "use --human for explanation of fields")},
-    {NULL,NULL}
-};
-
-static const vshCmdOptDef opts_domblkstat[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"device", VSH_OT_DATA, VSH_OFLAG_REQ, N_("block device")},
-    {"human",  VSH_OT_BOOL, 0, N_("print a more human readable output")},
-    {NULL, 0, 0, NULL}
-};
-
-struct _domblkstat_sequence {
-    const char *field;  /* field name */
-    const char *legacy; /* legacy name from previous releases */
-    const char *human;  /* human-friendly explanation */
-};
-
-/* sequence of values for output to honor legacy format from previous
- * versions */
-static const struct _domblkstat_sequence domblkstat_output[] = {
-    { VIR_DOMAIN_BLOCK_STATS_READ_REQ,          "rd_req",
-      N_("number of read operations:") }, /* 0 */
-    { VIR_DOMAIN_BLOCK_STATS_READ_BYTES,        "rd_bytes",
-      N_("number of bytes read:") }, /* 1 */
-    { VIR_DOMAIN_BLOCK_STATS_WRITE_REQ,         "wr_req",
-      N_("number of write operations:") }, /* 2 */
-    { VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES,       "wr_bytes",
-      N_("number of bytes written:") }, /* 3 */
-    { VIR_DOMAIN_BLOCK_STATS_ERRS,              "errs",
-      N_("error count:") }, /* 4 */
-    { VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ,         NULL,
-      N_("number of flush operations:") }, /* 5 */
-    { VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES,  NULL,
-      N_("total duration of reads (ns):") }, /* 6 */
-    { VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES, NULL,
-      N_("total duration of writes (ns):") }, /* 7 */
-    { VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES, NULL,
-      N_("total duration of flushes (ns):") }, /* 8 */
-    { NULL, NULL, NULL }
-};
-
-#define DOMBLKSTAT_LEGACY_PRINT(ID, VALUE)              \
-    if (VALUE >= 0)                                     \
-        vshPrint(ctl, "%s %-*s %lld\n", device,         \
-                 human ? 31 : 0,                        \
-                 human ? _(domblkstat_output[ID].human) \
-                 : domblkstat_output[ID].legacy,        \
-                 VALUE);
-
-static bool
-cmdDomblkstat(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    const char *name = NULL, *device = NULL;
-    struct _virDomainBlockStats stats;
-    virTypedParameterPtr params = NULL;
-    virTypedParameterPtr par = NULL;
-    char *value = NULL;
-    const char *field = NULL;
-    int rc, nparams = 0;
-    int i = 0;
-    bool ret = false;
-    bool human = vshCommandOptBool(cmd, "human"); /* human readable output */
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
-        return false;
-
-    if (vshCommandOptString(cmd, "device", &device) <= 0)
-        goto cleanup;
-
-    rc = virDomainBlockStatsFlags(dom, device, NULL, &nparams, 0);
-
-    /* It might fail when virDomainBlockStatsFlags is not
-     * supported on older libvirt, fallback to use virDomainBlockStats
-     * then.
-     */
-    if (rc < 0) {
-        /* try older API if newer is not supported */
-        if (last_error->code != VIR_ERR_NO_SUPPORT)
-            goto cleanup;
-
-        virFreeError(last_error);
-        last_error = NULL;
-
-        if (virDomainBlockStats(dom, device, &stats,
-                                sizeof(stats)) == -1) {
-            vshError(ctl, _("Failed to get block stats %s %s"),
-                     name, device);
-            goto cleanup;
-        }
-
-        /* human friendly output */
-        if (human) {
-            vshPrint(ctl, N_("Device: %s\n"), device);
-            device = "";
-        }
-
-        DOMBLKSTAT_LEGACY_PRINT(0, stats.rd_req);
-        DOMBLKSTAT_LEGACY_PRINT(1, stats.rd_bytes);
-        DOMBLKSTAT_LEGACY_PRINT(2, stats.wr_req);
-        DOMBLKSTAT_LEGACY_PRINT(3, stats.wr_bytes);
-        DOMBLKSTAT_LEGACY_PRINT(4, stats.errs);
-    } else {
-        params = vshCalloc(ctl, nparams, sizeof(*params));
-
-        if (virDomainBlockStatsFlags(dom, device, params, &nparams, 0) < 0) {
-            vshError(ctl, _("Failed to get block stats %s %s"), name, device);
-            goto cleanup;
-        }
-
-        /* set for prettier output */
-        if (human) {
-            vshPrint(ctl, N_("Device: %s\n"), device);
-            device = "";
-        }
-
-        /* at first print all known values in desired order */
-        for (i = 0; domblkstat_output[i].field != NULL; i++) {
-            if (!(par = vshFindTypedParamByName(domblkstat_output[i].field,
-                                                params,
-                                                nparams)))
-                continue;
-
-            value = vshGetTypedParamValue(ctl, par);
-
-            /* to print other not supported fields, mark the already printed */
-            par->field[0] = '\0'; /* set the name to empty string */
-
-            /* translate into human readable or legacy spelling */
-            field = NULL;
-            if (human)
-                field = _(domblkstat_output[i].human);
-            else
-                field = domblkstat_output[i].legacy;
-
-            /* use the provided spelling if no translation is available */
-            if (!field)
-                field = domblkstat_output[i].field;
-
-            vshPrint(ctl, "%s %-*s %s\n", device,
-                     human ? 31 : 0, field, value);
-
-            VIR_FREE(value);
-        }
-
-        /* go through the fields again, for remaining fields */
-        for (i = 0; i < nparams; i++) {
-            if (!*params[i].field)
-                continue;
-
-            value = vshGetTypedParamValue(ctl, params+i);
-            vshPrint(ctl, "%s %s %s\n", device, params[i].field, value);
-            VIR_FREE(value);
-        }
-    }
-
-    ret = true;
-
-cleanup:
-    VIR_FREE(params);
-    virDomainFree(dom);
-    return ret;
-}
-#undef DOMBLKSTAT_LEGACY_PRINT
-
-/* "domifstat" command
- */
-static const vshCmdInfo info_domifstat[] = {
-    {"help", N_("get network interface stats for a domain")},
-    {"desc", N_("Get network interface stats for a running domain.")},
-    {NULL,NULL}
-};
-
-static const vshCmdOptDef opts_domifstat[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"interface", VSH_OT_DATA, VSH_OFLAG_REQ, N_("interface device")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomIfstat(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    const char *name = NULL, *device = NULL;
-    struct _virDomainInterfaceStats stats;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
-        return false;
-
-    if (vshCommandOptString(cmd, "interface", &device) <= 0) {
-        virDomainFree(dom);
-        return false;
-    }
-
-    if (virDomainInterfaceStats(dom, device, &stats, sizeof(stats)) == -1) {
-        vshError(ctl, _("Failed to get interface stats %s %s"), name, device);
-        virDomainFree(dom);
-        return false;
-    }
-
-    if (stats.rx_bytes >= 0)
-        vshPrint(ctl, "%s rx_bytes %lld\n", device, stats.rx_bytes);
-
-    if (stats.rx_packets >= 0)
-        vshPrint(ctl, "%s rx_packets %lld\n", device, stats.rx_packets);
-
-    if (stats.rx_errs >= 0)
-        vshPrint(ctl, "%s rx_errs %lld\n", device, stats.rx_errs);
-
-    if (stats.rx_drop >= 0)
-        vshPrint(ctl, "%s rx_drop %lld\n", device, stats.rx_drop);
-
-    if (stats.tx_bytes >= 0)
-        vshPrint(ctl, "%s tx_bytes %lld\n", device, stats.tx_bytes);
-
-    if (stats.tx_packets >= 0)
-        vshPrint(ctl, "%s tx_packets %lld\n", device, stats.tx_packets);
-
-    if (stats.tx_errs >= 0)
-        vshPrint(ctl, "%s tx_errs %lld\n", device, stats.tx_errs);
-
-    if (stats.tx_drop >= 0)
-        vshPrint(ctl, "%s tx_drop %lld\n", device, stats.tx_drop);
-
-    virDomainFree(dom);
-    return true;
-}
-
-/* "domif-setlink" command
- */
-static const vshCmdInfo info_domif_setlink[] = {
-    {"help", N_("set link state of a virtual interface")},
-    {"desc", N_("Set link state of a domain's virtual interface. This command wraps usage of update-device command.")},
-    {NULL,NULL}
-};
-
-static const vshCmdOptDef opts_domif_setlink[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"interface", VSH_OT_DATA, VSH_OFLAG_REQ, N_("interface device (MAC Address)")},
-    {"state", VSH_OT_DATA, VSH_OFLAG_REQ, N_("new state of the device")},
-    {"persistent", VSH_OT_ALIAS, 0, "config"},
-    {"config", VSH_OT_BOOL, 0, N_("affect next boot")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomIfSetLink(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    const char *iface;
-    const char *state;
-    const char *value;
-    const char *desc;
-    virMacAddr macaddr;
-    const char *element;
-    const char *attr;
-    bool config;
-    bool ret = false;
-    unsigned int flags = 0;
-    int i;
-    xmlDocPtr xml = NULL;
-    xmlXPathContextPtr ctxt = NULL;
-    xmlXPathObjectPtr obj = NULL;
-    xmlNodePtr cur = NULL;
-    xmlBufferPtr xml_buf = NULL;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
-        return false;
-
-    if (vshCommandOptString(cmd, "interface", &iface) <= 0)
-        goto cleanup;
-
-    if (vshCommandOptString(cmd, "state", &state) <= 0)
-        goto cleanup;
-
-    config = vshCommandOptBool(cmd, "config");
-
-    if (STRNEQ(state, "up") && STRNEQ(state, "down")) {
-        vshError(ctl, _("invalid link state '%s'"), state);
-        goto cleanup;
-    }
-
-    /* get persistent or live description of network device */
-    desc = virDomainGetXMLDesc(dom, config ? VIR_DOMAIN_XML_INACTIVE : 0);
-    if (desc == NULL) {
-        vshError(ctl, _("Failed to get domain description xml"));
-        goto cleanup;
-    }
-
-    if (config)
-        flags = VIR_DOMAIN_AFFECT_CONFIG;
-    else
-        flags = VIR_DOMAIN_AFFECT_LIVE;
-
-    if (virDomainIsActive(dom) == 0)
-        flags = VIR_DOMAIN_AFFECT_CONFIG;
+    if (virDomainIsActive(dom) == 0)
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
 
     /* extract current network device description */
     xml = virXMLParseStringCtxt(desc, _("(domain_definition)"), &ctxt);
@@ -2050,166 +1272,37 @@ hit:
                           BAD_CAST "link",
                           NULL);
         if (!cur)
-            goto cleanup;
-
-        if (xmlNewProp(cur, BAD_CAST "state", BAD_CAST state) == NULL)
-            goto cleanup;
-    }
-
-    xml_buf = xmlBufferCreate();
-    if (!xml_buf) {
-        vshError(ctl, _("Failed to allocate memory"));
-        goto cleanup;
-    }
-
-    if (xmlNodeDump(xml_buf, xml, obj->nodesetval->nodeTab[i], 0, 0) < 0 ) {
-        vshError(ctl, _("Failed to create XML"));
-        goto cleanup;
-    }
-
-    if (virDomainUpdateDeviceFlags(dom, (char *)xmlBufferContent(xml_buf), flags) < 0) {
-        vshError(ctl, _("Failed to update interface link state"));
-        goto cleanup;
-    } else {
-        vshPrint(ctl, "%s", _("Device updated successfully\n"));
-        ret = true;
-    }
-
-cleanup:
-    xmlXPathFreeObject(obj);
-    xmlXPathFreeContext(ctxt);
-    xmlFreeDoc(xml);
-    xmlBufferFree(xml_buf);
-
-    if (dom)
-        virDomainFree(dom);
-
-    return ret;
-}
-
-/* "domif-getlink" command
- */
-static const vshCmdInfo info_domif_getlink[] = {
-    {"help", N_("get link state of a virtual interface")},
-    {"desc", N_("Get link state of a domain's virtual interface.")},
-    {NULL,NULL}
-};
-
-static const vshCmdOptDef opts_domif_getlink[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"interface", VSH_OT_DATA, VSH_OFLAG_REQ, N_("interface device (MAC Address)")},
-    {"persistent", VSH_OT_ALIAS, 0, "config"},
-    {"config", VSH_OT_BOOL, 0, N_("Get persistent interface state")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomIfGetLink(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    const char *iface = NULL;
-    int flags = 0;
-    char *state = NULL;
-    char *value = NULL;
-    virMacAddr macaddr;
-    const char *element;
-    const char *attr;
-    bool ret = false;
-    int i;
-    char *desc;
-    xmlDocPtr xml = NULL;
-    xmlXPathContextPtr ctxt = NULL;
-    xmlNodePtr cur = NULL;
-    xmlXPathObjectPtr obj = NULL;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
-        return false;
-
-    if (vshCommandOptString(cmd, "interface", &iface) <= 0) {
-        virDomainFree(dom);
-        return false;
-    }
-
-    if (vshCommandOptBool(cmd, "config"))
-        flags = VIR_DOMAIN_XML_INACTIVE;
-
-    desc = virDomainGetXMLDesc(dom, flags);
-    if (desc == NULL) {
-        vshError(ctl, _("Failed to get domain description xml"));
-        goto cleanup;
-    }
-
-    xml = virXMLParseStringCtxt(desc, _("(domain_definition)"), &ctxt);
-    VIR_FREE(desc);
-    if (!xml) {
-        vshError(ctl, _("Failed to parse domain description xml"));
-        goto cleanup;
-    }
-
-    obj = xmlXPathEval(BAD_CAST "/domain/devices/interface", ctxt);
-    if (obj == NULL || obj->type != XPATH_NODESET ||
-        obj->nodesetval == NULL || obj->nodesetval->nodeNr == 0) {
-        vshError(ctl, _("Failed to extract interface information or no interfaces found"));
-        goto cleanup;
-    }
-
-    if (virMacAddrParse(iface, &macaddr) == 0) {
-        element = "mac";
-        attr = "address";
-    } else {
-        element = "target";
-        attr = "dev";
-    }
-
-    /* find interface with matching mac addr */
-    for (i = 0; i < obj->nodesetval->nodeNr; i++) {
-        cur = obj->nodesetval->nodeTab[i]->children;
-
-        while (cur) {
-            if (cur->type == XML_ELEMENT_NODE &&
-                xmlStrEqual(cur->name, BAD_CAST element)) {
-
-                value = virXMLPropString(cur, attr);
-
-                if (STRCASEEQ(value, iface)) {
-                    VIR_FREE(value);
-                    goto hit;
-                }
-                VIR_FREE(value);
-            }
-            cur = cur->next;
-        }
-    }
-
-    vshError(ctl, _("Interface (%s: %s) not found."), element, iface);
-    goto cleanup;
-
-hit:
-    cur = obj->nodesetval->nodeTab[i]->children;
-    while (cur) {
-        if (cur->type == XML_ELEMENT_NODE &&
-            xmlStrEqual(cur->name, BAD_CAST "link")) {
-
-            state = virXMLPropString(cur, "state");
-            vshPrint(ctl, "%s %s", iface, state);
-            VIR_FREE(state);
+            goto cleanup;
 
+        if (xmlNewProp(cur, BAD_CAST "state", BAD_CAST state) == NULL)
             goto cleanup;
-        }
-        cur = cur->next;
     }
 
-    /* attribute not found */
-    vshPrint(ctl, "%s default", iface);
+    xml_buf = xmlBufferCreate();
+    if (!xml_buf) {
+        vshError(ctl, _("Failed to allocate memory"));
+        goto cleanup;
+    }
+
+    if (xmlNodeDump(xml_buf, xml, obj->nodesetval->nodeTab[i], 0, 0) < 0 ) {
+        vshError(ctl, _("Failed to create XML"));
+        goto cleanup;
+    }
+
+    if (virDomainUpdateDeviceFlags(dom, (char *)xmlBufferContent(xml_buf), flags) < 0) {
+        vshError(ctl, _("Failed to update interface link state"));
+        goto cleanup;
+    } else {
+        vshPrint(ctl, "%s", _("Device updated successfully\n"));
+        ret = true;
+    }
 
-    ret = true;
 cleanup:
     xmlXPathFreeObject(obj);
     xmlXPathFreeContext(ctxt);
     xmlFreeDoc(xml);
+    xmlBufferFree(xml_buf);
+
     if (dom)
         virDomainFree(dom);
 
@@ -2345,381 +1438,69 @@ cmdDomIftune(vshControl *ctl, const vshCmd *cmd)
         /* set the interface parameters */
         params = vshCalloc(ctl, nparams, sizeof(*params));
         if (!params) {
-            virReportOOMError();
-            goto cleanup;
-        }
-
-        for (i = 0; i < nparams; i++)
-            params[i].type = VIR_TYPED_PARAM_UINT;
-
-        i = 0;
-        if (inbound.average && i < nparams) {
-            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_IN_AVERAGE,
-                           sizeof(params[i].field)))
-                goto cleanup;
-            params[i].value.ui = inbound.average;
-            i++;
-        }
-        if (inbound.peak && i < nparams) {
-            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_IN_PEAK,
-                           sizeof(params[i].field)))
-                goto cleanup;
-            params[i].value.ui = inbound.peak;
-            i++;
-        }
-        if (inbound.burst && i < nparams) {
-            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_IN_BURST,
-                           sizeof(params[i].field)))
-                goto cleanup;
-            params[i].value.ui = inbound.burst;
-            i++;
-        }
-        if (outbound.average && i < nparams) {
-            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE,
-                           sizeof(params[i].field)))
-                goto cleanup;
-            params[i].value.ui = outbound.average;
-            i++;
-        }
-        if (outbound.peak && i < nparams) {
-            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_OUT_PEAK,
-                           sizeof(params[i].field)))
-                goto cleanup;
-            params[i].value.ui = outbound.peak;
-            i++;
-        }
-        if (outbound.burst && i < nparams) {
-            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_OUT_BURST,
-                           sizeof(params[i].field)))
-                goto cleanup;
-            params[i].value.ui = outbound.burst;
-            i++;
-        }
-
-        if (virDomainSetInterfaceParameters(dom, device, params, nparams, flags) != 0) {
-            vshError(ctl, "%s", _("Unable to set interface parameters"));
-            goto cleanup;
-        }
-    }
-
-    ret = true;
-
-cleanup:
-    virTypedParameterArrayClear(params, nparams);
-    VIR_FREE(params);
-    virDomainFree(dom);
-    return ret;
-}
-
-/*
- * "dommemstats" command
- */
-static const vshCmdInfo info_dommemstat[] = {
-    {"help", N_("get memory statistics for a domain")},
-    {"desc", N_("Get memory statistics for a running domain.")},
-    {NULL,NULL}
-};
-
-static const vshCmdOptDef opts_dommemstat[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomMemStat(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    const char *name;
-    struct _virDomainMemoryStat stats[VIR_DOMAIN_MEMORY_STAT_NR];
-    unsigned int nr_stats, i;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
-        return false;
-
-    nr_stats = virDomainMemoryStats(dom, stats, VIR_DOMAIN_MEMORY_STAT_NR, 0);
-    if (nr_stats == -1) {
-        vshError(ctl, _("Failed to get memory statistics for domain %s"), name);
-        virDomainFree(dom);
-        return false;
-    }
-
-    for (i = 0; i < nr_stats; i++) {
-        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_SWAP_IN)
-            vshPrint(ctl, "swap_in %llu\n", stats[i].val);
-        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_SWAP_OUT)
-            vshPrint(ctl, "swap_out %llu\n", stats[i].val);
-        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT)
-            vshPrint(ctl, "major_fault %llu\n", stats[i].val);
-        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT)
-            vshPrint(ctl, "minor_fault %llu\n", stats[i].val);
-        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_UNUSED)
-            vshPrint(ctl, "unused %llu\n", stats[i].val);
-        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_AVAILABLE)
-            vshPrint(ctl, "available %llu\n", stats[i].val);
-        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON)
-            vshPrint(ctl, "actual %llu\n", stats[i].val);
-        if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_RSS)
-            vshPrint(ctl, "rss %llu\n", stats[i].val);
-    }
-
-    virDomainFree(dom);
-    return true;
-}
-
-/*
- * "domblkinfo" command
- */
-static const vshCmdInfo info_domblkinfo[] = {
-    {"help", N_("domain block device size information")},
-    {"desc", N_("Get block device size info for a domain.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_domblkinfo[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"device", VSH_OT_DATA, VSH_OFLAG_REQ, N_("block device")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomblkinfo(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainBlockInfo info;
-    virDomainPtr dom;
-    bool ret = true;
-    const char *device = NULL;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
-        return false;
-
-    if (vshCommandOptString(cmd, "device", &device) <= 0) {
-        virDomainFree(dom);
-        return false;
-    }
-
-    if (virDomainGetBlockInfo(dom, device, &info, 0) < 0) {
-        virDomainFree(dom);
-        return false;
-    }
-
-    vshPrint(ctl, "%-15s %llu\n", _("Capacity:"), info.capacity);
-    vshPrint(ctl, "%-15s %llu\n", _("Allocation:"), info.allocation);
-    vshPrint(ctl, "%-15s %llu\n", _("Physical:"), info.physical);
-
-    virDomainFree(dom);
-    return ret;
-}
-
-/*
- * "domblklist" command
- */
-static const vshCmdInfo info_domblklist[] = {
-    {"help", N_("list all domain blocks")},
-    {"desc", N_("Get the summary of block devices for a domain.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_domblklist[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"inactive", VSH_OT_BOOL, 0,
-     N_("get inactive rather than running configuration")},
-    {"details", VSH_OT_BOOL, 0,
-     N_("additionally display the type and device value")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomblklist(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    bool ret = false;
-    unsigned int flags = 0;
-    char *xml = NULL;
-    xmlDocPtr xmldoc = NULL;
-    xmlXPathContextPtr ctxt = NULL;
-    int ndisks;
-    xmlNodePtr *disks = NULL;
-    int i;
-    bool details = false;
-
-    if (vshCommandOptBool(cmd, "inactive"))
-        flags |= VIR_DOMAIN_XML_INACTIVE;
-
-    details = vshCommandOptBool(cmd, "details");
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
-        return false;
-
-    xml = virDomainGetXMLDesc(dom, flags);
-    if (!xml)
-        goto cleanup;
-
-    xmldoc = virXMLParseStringCtxt(xml, _("(domain_definition)"), &ctxt);
-    if (!xmldoc)
-        goto cleanup;
-
-    ndisks = virXPathNodeSet("./devices/disk", ctxt, &disks);
-    if (ndisks < 0)
-        goto cleanup;
-
-    if (details)
-        vshPrint(ctl, "%-10s %-10s %-10s %s\n", _("Type"),
-                 _("Device"), _("Target"), _("Source"));
-    else
-        vshPrint(ctl, "%-10s %s\n", _("Target"), _("Source"));
-
-    vshPrint(ctl, "------------------------------------------------\n");
-
-    for (i = 0; i < ndisks; i++) {
-        char *type;
-        char *device;
-        char *target;
-        char *source;
-
-        ctxt->node = disks[i];
-
-        if (details) {
-            type = virXPathString("string(./@type)", ctxt);
-            device = virXPathString("string(./@device)", ctxt);
-        }
-
-        target = virXPathString("string(./target/@dev)", ctxt);
-        if (!target) {
-            vshError(ctl, "unable to query block list");
-            goto cleanup;
-        }
-        source = virXPathString("string(./source/@file"
-                                "|./source/@dev"
-                                "|./source/@dir"
-                                "|./source/@name)", ctxt);
-        if (details) {
-            vshPrint(ctl, "%-10s %-10s %-10s %s\n", type, device,
-                     target, source ? source : "-");
-            VIR_FREE(type);
-            VIR_FREE(device);
-        } else {
-            vshPrint(ctl, "%-10s %s\n", target, source ? source : "-");
-        }
-
-        VIR_FREE(target);
-        VIR_FREE(source);
-    }
-
-    ret = true;
-
-cleanup:
-    VIR_FREE(disks);
-    virDomainFree(dom);
-    VIR_FREE(xml);
-    xmlFreeDoc(xmldoc);
-    xmlXPathFreeContext(ctxt);
-    return ret;
-}
-
-/*
- * "domiflist" command
- */
-static const vshCmdInfo info_domiflist[] = {
-    {"help", N_("list all domain virtual interfaces")},
-    {"desc", N_("Get the summary of virtual interfaces for a domain.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_domiflist[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"inactive", VSH_OT_BOOL, 0,
-     N_("get inactive rather than running configuration")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomiflist(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    bool ret = false;
-    unsigned int flags = 0;
-    char *xml = NULL;
-    xmlDocPtr xmldoc = NULL;
-    xmlXPathContextPtr ctxt = NULL;
-    int ninterfaces;
-    xmlNodePtr *interfaces = NULL;
-    int i;
-
-    if (vshCommandOptBool(cmd, "inactive"))
-        flags |= VIR_DOMAIN_XML_INACTIVE;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
-        return false;
-
-    xml = virDomainGetXMLDesc(dom, flags);
-    if (!xml)
-        goto cleanup;
-
-    xmldoc = virXMLParseStringCtxt(xml, _("(domain_definition)"), &ctxt);
-    if (!xmldoc)
-        goto cleanup;
-
-    ninterfaces = virXPathNodeSet("./devices/interface", ctxt, &interfaces);
-    if (ninterfaces < 0)
-        goto cleanup;
-
-    vshPrint(ctl, "%-10s %-10s %-10s %-11s %s\n", _("Interface"), _("Type"),
-             _("Source"), _("Model"), _("MAC"));
-    vshPrint(ctl, "-------------------------------------------------------\n");
-
-    for (i = 0; i < ninterfaces; i++) {
-        char *type = NULL;
-        char *source = NULL;
-        char *target = NULL;
-        char *model = NULL;
-        char *mac = NULL;
-
-        ctxt->node = interfaces[i];
-        type = virXPathString("string(./@type)", ctxt);
-
-        source = virXPathString("string(./source/@bridge"
-                                "|./source/@dev"
-                                "|./source/@network"
-                                "|./source/@name)", ctxt);
+            virReportOOMError();
+            goto cleanup;
+        }
 
-        target = virXPathString("string(./target/@dev)", ctxt);
-        model = virXPathString("string(./model/@type)", ctxt);
-        mac = virXPathString("string(./mac/@address)", ctxt);
+        for (i = 0; i < nparams; i++)
+            params[i].type = VIR_TYPED_PARAM_UINT;
 
-        vshPrint(ctl, "%-10s %-10s %-10s %-11s %-10s\n",
-                 target ? target : "-",
-                 type,
-                 source ? source : "-",
-                 model ? model : "-",
-                 mac ? mac : "-");
+        i = 0;
+        if (inbound.average && i < nparams) {
+            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_IN_AVERAGE,
+                           sizeof(params[i].field)))
+                goto cleanup;
+            params[i].value.ui = inbound.average;
+            i++;
+        }
+        if (inbound.peak && i < nparams) {
+            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_IN_PEAK,
+                           sizeof(params[i].field)))
+                goto cleanup;
+            params[i].value.ui = inbound.peak;
+            i++;
+        }
+        if (inbound.burst && i < nparams) {
+            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_IN_BURST,
+                           sizeof(params[i].field)))
+                goto cleanup;
+            params[i].value.ui = inbound.burst;
+            i++;
+        }
+        if (outbound.average && i < nparams) {
+            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE,
+                           sizeof(params[i].field)))
+                goto cleanup;
+            params[i].value.ui = outbound.average;
+            i++;
+        }
+        if (outbound.peak && i < nparams) {
+            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_OUT_PEAK,
+                           sizeof(params[i].field)))
+                goto cleanup;
+            params[i].value.ui = outbound.peak;
+            i++;
+        }
+        if (outbound.burst && i < nparams) {
+            if (!virStrcpy(params[i].field, VIR_DOMAIN_BANDWIDTH_OUT_BURST,
+                           sizeof(params[i].field)))
+                goto cleanup;
+            params[i].value.ui = outbound.burst;
+            i++;
+        }
 
-        VIR_FREE(type);
-        VIR_FREE(source);
-        VIR_FREE(target);
-        VIR_FREE(model);
-        VIR_FREE(mac);
+        if (virDomainSetInterfaceParameters(dom, device, params, nparams, flags) != 0) {
+            vshError(ctl, "%s", _("Unable to set interface parameters"));
+            goto cleanup;
+        }
     }
 
     ret = true;
 
 cleanup:
-    VIR_FREE(interfaces);
+    virTypedParameterArrayClear(params, nparams);
+    VIR_FREE(params);
     virDomainFree(dom);
-    VIR_FREE(xml);
-    xmlFreeDoc(xmldoc);
-    xmlXPathFreeContext(ctxt);
     return ret;
 }
 
@@ -4731,144 +3512,6 @@ cmdDestroy(vshControl *ctl, const vshCmd *cmd)
 }
 
 /*
- * "dominfo" command
- */
-static const vshCmdInfo info_dominfo[] = {
-    {"help", N_("domain information")},
-    {"desc", N_("Returns basic information about the domain.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_dominfo[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDominfo(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainInfo info;
-    virDomainPtr dom;
-    virSecurityModel secmodel;
-    virSecurityLabelPtr seclabel;
-    int persistent = 0;
-    bool ret = true;
-    int autostart;
-    unsigned int id;
-    char *str, uuid[VIR_UUID_STRING_BUFLEN];
-    int has_managed_save = 0;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
-        return false;
-
-    id = virDomainGetID(dom);
-    if (id == ((unsigned int)-1))
-        vshPrint(ctl, "%-15s %s\n", _("Id:"), "-");
-    else
-        vshPrint(ctl, "%-15s %d\n", _("Id:"), id);
-    vshPrint(ctl, "%-15s %s\n", _("Name:"), virDomainGetName(dom));
-
-    if (virDomainGetUUIDString(dom, &uuid[0])==0)
-        vshPrint(ctl, "%-15s %s\n", _("UUID:"), uuid);
-
-    if ((str = virDomainGetOSType(dom))) {
-        vshPrint(ctl, "%-15s %s\n", _("OS Type:"), str);
-        VIR_FREE(str);
-    }
-
-    if (virDomainGetInfo(dom, &info) == 0) {
-        vshPrint(ctl, "%-15s %s\n", _("State:"),
-                 _(vshDomainStateToString(info.state)));
-
-        vshPrint(ctl, "%-15s %d\n", _("CPU(s):"), info.nrVirtCpu);
-
-        if (info.cpuTime != 0) {
-            double cpuUsed = info.cpuTime;
-
-            cpuUsed /= 1000000000.0;
-
-            vshPrint(ctl, "%-15s %.1lfs\n", _("CPU time:"), cpuUsed);
-        }
-
-        if (info.maxMem != UINT_MAX)
-            vshPrint(ctl, "%-15s %lu KiB\n", _("Max memory:"),
-                 info.maxMem);
-        else
-            vshPrint(ctl, "%-15s %s\n", _("Max memory:"),
-                 _("no limit"));
-
-        vshPrint(ctl, "%-15s %lu KiB\n", _("Used memory:"),
-                 info.memory);
-
-    } else {
-        ret = false;
-    }
-
-    /* Check and display whether the domain is persistent or not */
-    persistent = virDomainIsPersistent(dom);
-    vshDebug(ctl, VSH_ERR_DEBUG, "Domain persistent flag value: %d\n",
-             persistent);
-    if (persistent < 0)
-        vshPrint(ctl, "%-15s %s\n", _("Persistent:"), _("unknown"));
-    else
-        vshPrint(ctl, "%-15s %s\n", _("Persistent:"), persistent ? _("yes") : _("no"));
-
-    /* Check and display whether the domain autostarts or not */
-    if (!virDomainGetAutostart(dom, &autostart)) {
-        vshPrint(ctl, "%-15s %s\n", _("Autostart:"),
-                 autostart ? _("enable") : _("disable") );
-    }
-
-    has_managed_save = virDomainHasManagedSaveImage(dom, 0);
-    if (has_managed_save < 0)
-        vshPrint(ctl, "%-15s %s\n", _("Managed save:"), _("unknown"));
-    else
-        vshPrint(ctl, "%-15s %s\n", _("Managed save:"),
-                 has_managed_save ? _("yes") : _("no"));
-
-    /* Security model and label information */
-    memset(&secmodel, 0, sizeof(secmodel));
-    if (virNodeGetSecurityModel(ctl->conn, &secmodel) == -1) {
-        if (last_error->code != VIR_ERR_NO_SUPPORT) {
-            virDomainFree(dom);
-            return false;
-        } else {
-            virFreeError(last_error);
-            last_error = NULL;
-        }
-    } else {
-        /* Only print something if a security model is active */
-        if (secmodel.model[0] != '\0') {
-            vshPrint(ctl, "%-15s %s\n", _("Security model:"), secmodel.model);
-            vshPrint(ctl, "%-15s %s\n", _("Security DOI:"), secmodel.doi);
-
-            /* Security labels are only valid for active domains */
-            if (VIR_ALLOC(seclabel) < 0) {
-                virDomainFree(dom);
-                return false;
-            }
-
-            if (virDomainGetSecurityLabel(dom, seclabel) == -1) {
-                virDomainFree(dom);
-                VIR_FREE(seclabel);
-                return false;
-            } else {
-                if (seclabel->label[0] != '\0')
-                    vshPrint(ctl, "%-15s %s (%s)\n", _("Security label:"),
-                             seclabel->label, seclabel->enforcing ? "enforcing" : "permissive");
-            }
-
-            VIR_FREE(seclabel);
-        }
-    }
-    virDomainFree(dom);
-    return ret;
-}
-
-/*
  * "domjobinfo" command
  */
 static const vshCmdInfo info_domjobinfo[] = {
@@ -17995,83 +16638,6 @@ cleanup:
 }
 
 /*
- * "domblkerror" command
- */
-static const char *
-vshDomainIOErrorToString(int error)
-{
-    switch ((virDomainDiskErrorCode) error) {
-    case VIR_DOMAIN_DISK_ERROR_NONE:
-        return _("no error");
-    case VIR_DOMAIN_DISK_ERROR_UNSPEC:
-        return _("unspecified error");
-    case VIR_DOMAIN_DISK_ERROR_NO_SPACE:
-        return _("no space");
-    case VIR_DOMAIN_DISK_ERROR_LAST:
-        ;
-    }
-
-    return _("unknown error");
-}
-
-static const vshCmdInfo info_domblkerror[] = {
-    {"help", N_("Show errors on block devices")},
-    {"desc", N_("Show block device errors")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_domblkerror[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id, or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdDomBlkError(vshControl *ctl, const vshCmd *cmd)
-{
-    virDomainPtr dom;
-    virDomainDiskErrorPtr disks = NULL;
-    unsigned int ndisks;
-    int i;
-    int count;
-    bool ret = false;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
-        return false;
-
-    if ((count = virDomainGetDiskErrors(dom, NULL, 0, 0)) < 0)
-        goto cleanup;
-    ndisks = count;
-
-    if (ndisks) {
-        if (VIR_ALLOC_N(disks, ndisks) < 0)
-            goto cleanup;
-
-        if ((count = virDomainGetDiskErrors(dom, disks, ndisks, 0)) == -1)
-            goto cleanup;
-    }
-
-    if (count == 0) {
-        vshPrint(ctl, _("No errors found\n"));
-    } else {
-        for (i = 0; i < count; i++) {
-            vshPrint(ctl, "%s: %s\n",
-                     disks[i].disk,
-                     vshDomainIOErrorToString(disks[i].error));
-        }
-    }
-
-    ret = true;
-
-cleanup:
-    VIR_FREE(disks);
-    virDomainFree(dom);
-    return ret;
-}
-
-/*
  * "qemu-monitor-command" command
  */
 static const vshCmdInfo info_qemu_monitor_command[] = {
@@ -19536,215 +18102,6 @@ vshDomainState(vshControl *ctl, virDomainPtr dom, int *reason)
         return info.state;
 }
 
-static const char *
-vshDomainStateToString(int state)
-{
-    /* Can't use virDomainStateTypeToString, because we want to mark
-     * strings for translation.  */
-    switch ((virDomainState) state) {
-    case VIR_DOMAIN_RUNNING:
-        return N_("running");
-    case VIR_DOMAIN_BLOCKED:
-        return N_("idle");
-    case VIR_DOMAIN_PAUSED:
-        return N_("paused");
-    case VIR_DOMAIN_SHUTDOWN:
-        return N_("in shutdown");
-    case VIR_DOMAIN_SHUTOFF:
-        return N_("shut off");
-    case VIR_DOMAIN_CRASHED:
-        return N_("crashed");
-    case VIR_DOMAIN_PMSUSPENDED:
-        return N_("pmsuspended");
-    case VIR_DOMAIN_NOSTATE:
-    default:
-        ;/*FALLTHROUGH*/
-    }
-    return N_("no state");  /* = dom0 state */
-}
-
-static const char *
-vshDomainStateReasonToString(int state, int reason)
-{
-    switch ((virDomainState) state) {
-    case VIR_DOMAIN_NOSTATE:
-        switch ((virDomainNostateReason) reason) {
-        case VIR_DOMAIN_NOSTATE_UNKNOWN:
-        case VIR_DOMAIN_NOSTATE_LAST:
-            ;
-        }
-        break;
-
-    case VIR_DOMAIN_RUNNING:
-        switch ((virDomainRunningReason) reason) {
-        case VIR_DOMAIN_RUNNING_BOOTED:
-            return N_("booted");
-        case VIR_DOMAIN_RUNNING_MIGRATED:
-            return N_("migrated");
-        case VIR_DOMAIN_RUNNING_RESTORED:
-            return N_("restored");
-        case VIR_DOMAIN_RUNNING_FROM_SNAPSHOT:
-            return N_("from snapshot");
-        case VIR_DOMAIN_RUNNING_UNPAUSED:
-            return N_("unpaused");
-        case VIR_DOMAIN_RUNNING_MIGRATION_CANCELED:
-            return N_("migration canceled");
-        case VIR_DOMAIN_RUNNING_SAVE_CANCELED:
-            return N_("save canceled");
-        case VIR_DOMAIN_RUNNING_WAKEUP:
-            return N_("event wakeup");
-        case VIR_DOMAIN_RUNNING_UNKNOWN:
-        case VIR_DOMAIN_RUNNING_LAST:
-            ;
-        }
-        break;
-
-    case VIR_DOMAIN_BLOCKED:
-        switch ((virDomainBlockedReason) reason) {
-        case VIR_DOMAIN_BLOCKED_UNKNOWN:
-        case VIR_DOMAIN_BLOCKED_LAST:
-            ;
-        }
-        break;
-
-    case VIR_DOMAIN_PAUSED:
-        switch ((virDomainPausedReason) reason) {
-        case VIR_DOMAIN_PAUSED_USER:
-            return N_("user");
-        case VIR_DOMAIN_PAUSED_MIGRATION:
-            return N_("migrating");
-        case VIR_DOMAIN_PAUSED_SAVE:
-            return N_("saving");
-        case VIR_DOMAIN_PAUSED_DUMP:
-            return N_("dumping");
-        case VIR_DOMAIN_PAUSED_IOERROR:
-            return N_("I/O error");
-        case VIR_DOMAIN_PAUSED_WATCHDOG:
-            return N_("watchdog");
-        case VIR_DOMAIN_PAUSED_FROM_SNAPSHOT:
-            return N_("from snapshot");
-        case VIR_DOMAIN_PAUSED_SHUTTING_DOWN:
-            return N_("shutting down");
-        case VIR_DOMAIN_PAUSED_UNKNOWN:
-        case VIR_DOMAIN_PAUSED_LAST:
-            ;
-        }
-        break;
-
-    case VIR_DOMAIN_SHUTDOWN:
-        switch ((virDomainShutdownReason) reason) {
-        case VIR_DOMAIN_SHUTDOWN_USER:
-            return N_("user");
-        case VIR_DOMAIN_SHUTDOWN_UNKNOWN:
-        case VIR_DOMAIN_SHUTDOWN_LAST:
-            ;
-        }
-        break;
-
-    case VIR_DOMAIN_SHUTOFF:
-        switch ((virDomainShutoffReason) reason) {
-        case VIR_DOMAIN_SHUTOFF_SHUTDOWN:
-            return N_("shutdown");
-        case VIR_DOMAIN_SHUTOFF_DESTROYED:
-            return N_("destroyed");
-        case VIR_DOMAIN_SHUTOFF_CRASHED:
-            return N_("crashed");
-        case VIR_DOMAIN_SHUTOFF_MIGRATED:
-            return N_("migrated");
-        case VIR_DOMAIN_SHUTOFF_SAVED:
-            return N_("saved");
-        case VIR_DOMAIN_SHUTOFF_FAILED:
-            return N_("failed");
-        case VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT:
-            return N_("from snapshot");
-        case VIR_DOMAIN_SHUTOFF_UNKNOWN:
-        case VIR_DOMAIN_SHUTOFF_LAST:
-            ;
-        }
-        break;
-
-    case VIR_DOMAIN_CRASHED:
-        switch ((virDomainCrashedReason) reason) {
-        case VIR_DOMAIN_CRASHED_UNKNOWN:
-        case VIR_DOMAIN_CRASHED_LAST:
-            ;
-        }
-        break;
-
-    case VIR_DOMAIN_PMSUSPENDED:
-        switch ((virDomainPMSuspendedReason) reason) {
-        case VIR_DOMAIN_PMSUSPENDED_UNKNOWN:
-        case VIR_DOMAIN_PMSUSPENDED_LAST:
-            ;
-        }
-        break;
-
-    case VIR_DOMAIN_LAST:
-        ;
-    }
-
-    return N_("unknown");
-}
-
-/* extract description or title from domain xml */
-static char *
-vshGetDomainDescription(vshControl *ctl, virDomainPtr dom, bool title,
-                        unsigned int flags)
-{
-    char *desc = NULL;
-    char *domxml = NULL;
-    virErrorPtr err = NULL;
-    xmlDocPtr doc = NULL;
-    xmlXPathContextPtr ctxt = NULL;
-    int type;
-
-    if (title)
-        type = VIR_DOMAIN_METADATA_TITLE;
-    else
-        type = VIR_DOMAIN_METADATA_DESCRIPTION;
-
-    if ((desc = virDomainGetMetadata(dom, type, NULL, flags))) {
-        return desc;
-    } else {
-        err = virGetLastError();
-
-        if (err && err->code == VIR_ERR_NO_DOMAIN_METADATA) {
-            desc = vshStrdup(ctl, "");
-            virResetLastError();
-            return desc;
-        }
-
-        if (err && err->code != VIR_ERR_NO_SUPPORT)
-            return desc;
-    }
-
-    /* fall back to xml */
-    /* get domain's xml description and extract the title/description */
-    if (!(domxml = virDomainGetXMLDesc(dom, flags))) {
-        vshError(ctl, "%s", _("Failed to retrieve domain XML"));
-        goto cleanup;
-    }
-    doc = virXMLParseStringCtxt(domxml, _("(domain_definition)"), &ctxt);
-    if (!doc) {
-        vshError(ctl, "%s", _("Couldn't parse domain XML"));
-        goto cleanup;
-    }
-    if (title)
-        desc = virXPathString("string(./title[1])", ctxt);
-    else
-        desc = virXPathString("string(./description[1])", ctxt);
-
-    if (!desc)
-        desc = vshStrdup(ctl, "");
-
-cleanup:
-    VIR_FREE(domxml);
-    xmlXPathFreeContext(ctxt);
-    xmlFreeDoc(doc);
-
-    return desc;
-}
-
 /* Return a non-NULL string representation of a typed parameter; exit
  * if we are out of memory.  */
 static char *
@@ -19814,25 +18171,6 @@ vshFindTypedParamByName(const char *name, virTypedParameterPtr list, int count)
 }
 
 static const char *
-vshDomainControlStateToString(int state)
-{
-    switch ((virDomainControlState) state) {
-    case VIR_DOMAIN_CONTROL_OK:
-        return N_("ok");
-    case VIR_DOMAIN_CONTROL_JOB:
-        return N_("background job");
-    case VIR_DOMAIN_CONTROL_OCCUPIED:
-        return N_("occupied");
-    case VIR_DOMAIN_CONTROL_ERROR:
-        return N_("error");
-    default:
-        ;
-    }
-
-    return N_("unknown");
-}
-
-static const char *
 vshDomainVcpuStateToString(int state)
 {
     switch (state) {
@@ -20815,6 +19153,8 @@ static const vshCmdDef domManagementCmds[] = {
     {NULL, NULL, NULL, NULL, 0}
 };
 
+#include "virsh-domain-monitor.c"
+
 static const vshCmdDef domMonitoringCmds[] = {
     {"domblkerror", cmdDomBlkError, opts_domblkerror, info_domblkerror, 0},
     {"domblkinfo", cmdDomblkinfo, opts_domblkinfo, info_domblkinfo, 0},
-- 
1.7.7.3


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