This patch adds a new public api that lists domains. The new approach is different from those used before. There are four key points to this: 1) The list is acquired atomicaly and contains both active and inactive domains (guests). This eliminates the need to call two different list APIs, where the state might change in between of the calls. 2) The returned list consists of virDomainPtrs instead of names or ID's that have to be converted to virDomainPtrs anyways using separate calls for each one of them. This is more convenient and saves resources and application code in most (all?) cases. 3) The returned list is auto-allocated. This saves a lot hassle for the users. 4) The python binding returns a list of domain objects that is very neat to work with. The only problem with this approach is no support from code generators so both RPC code and python bindings had to be written manualy. *include/libvirt/libvirt.h.in: - add API prototype - clean up whitespace mistakes nearby *python/generator.py: - inhibit generation of the bindings for the new api *src/driver.h: - add driver prototype - clean up some whitespace mistakes nearby *src/libvirt.c: - add public implementation *src/libvirt_public.syms: - export the new symbol --- include/libvirt/libvirt.h.in | 8 +++++- python/generator.py | 1 + src/driver.h | 12 ++++++++-- src/libvirt.c | 46 ++++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 5 ++++ 5 files changed, 67 insertions(+), 5 deletions(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index a817db8..2dacd45 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -1759,8 +1759,12 @@ int virDomainUndefineFlags (virDomainPtr domain, unsigned int flags); int virConnectNumOfDefinedDomains (virConnectPtr conn); int virConnectListDefinedDomains (virConnectPtr conn, - char **const names, - int maxnames); + char **const names, + int maxnames); +int virConnectListAllDomains (virConnectPtr conn, + virDomainPtr **domains, + int ndomains, + unsigned int flags); int virDomainCreate (virDomainPtr domain); int virDomainCreateWithFlags (virDomainPtr domain, unsigned int flags); diff --git a/python/generator.py b/python/generator.py index 9530867..a81fe4d 100755 --- a/python/generator.py +++ b/python/generator.py @@ -453,6 +453,7 @@ skip_function = ( 'virConnectDomainEventDeregisterAny', # overridden in virConnect.py 'virSaveLastError', # We have our own python error wrapper 'virFreeError', # Only needed if we use virSaveLastError + 'virConnectListAllDomains', #overriden in virConnect.py 'virStreamRecvAll', # Pure python libvirt-override-virStream.py 'virStreamSendAll', # Pure python libvirt-override-virStream.py diff --git a/src/driver.h b/src/driver.h index 03d249b..d5c5072 100644 --- a/src/driver.h +++ b/src/driver.h @@ -251,9 +251,14 @@ typedef char * const char *domainXml, unsigned int flags); typedef int - (*virDrvListDefinedDomains) (virConnectPtr conn, - char **const names, - int maxnames); + (*virDrvListDefinedDomains) (virConnectPtr conn, + char **const names, + int maxnames); +typedef int + (*virDrvConnectListAllDomains) (virConnectPtr conn, + virDomainPtr **domains, + int ndomains, + unsigned int flags); typedef int (*virDrvNumOfDefinedDomains) (virConnectPtr conn); typedef int @@ -1014,6 +1019,7 @@ struct _virDriver { virDrvDomainGetDiskErrors domainGetDiskErrors; virDrvDomainSetMetadata domainSetMetadata; virDrvDomainGetMetadata domainGetMetadata; + virDrvConnectListAllDomains connectListAllDomains; }; typedef int diff --git a/src/libvirt.c b/src/libvirt.c index 22fc863..09a6d95 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -8128,6 +8128,52 @@ error: } /** + * virConnectListAllDomains: + * @conn: Pointer to the hypervisor connection. + * @domains: Pointer to a variable to store the array containing domain objects + * or NULL if the list is not required (just returns number of guests). + * @ndomains: Maximum number of requested guests. Set to -1 for no limits. + * @flags: Not used yet. Callers must pass 0. + * + * List all guests (domains). This function allocates and returns a complete list + * of guests. Caller has to free the returned virDomainPtrs and the array. + * + * Returns number of guests found (and stored in *domains) or -1 on error. + */ +int +virConnectListAllDomains(virConnectPtr conn, + virDomainPtr **domains, + int ndomains, + unsigned int flags) +{ + VIR_DEBUG("conn=%p, domains=%p, ndomains=%d, flags=%x", + conn, domains, ndomains, flags); + + virResetLastError(); + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + + if (conn->driver->connectListAllDomains) { + int ret; + ret = conn->driver->connectListAllDomains(conn, domains, + ndomains, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(conn); + return -1; +} + +/** * virDomainCreate: * @domain: pointer to a defined domain * diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index 46c13fb..6fd4843 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -534,4 +534,9 @@ LIBVIRT_0.9.11 { virDomainPMWakeup; } LIBVIRT_0.9.10; +LIBVIRT_0.9.13 { + global: + virConnectListAllDomains; +} LIBVIRT_0.9.11; + # .... define new API here using predicted next version number .... -- 1.7.3.4

This patch wires up the RPC protocol handlers for virConnectListAllDomains(). The RPC generator has no support for the way how virConnectListAllDomains() returns the results so the handler code had to be done manually. The new api is handled by REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS, with number 271 and marked with high priority. --- daemon/remote.c | 50 +++++++++++++++++++++++++++++++ src/remote/remote_driver.c | 66 ++++++++++++++++++++++++++++++++++++++++++ src/remote/remote_protocol.x | 14 ++++++++- src/remote_protocol-structs | 12 +++++++ 4 files changed, 141 insertions(+), 1 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index 16a8a05..8ac0568 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -996,6 +996,56 @@ no_memory: } static int +remoteDispatchConnectListAllDomains(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_connect_list_all_domains_args *args, + remote_connect_list_all_domains_ret *ret) +{ + virDomainPtr *doms = NULL; + int ndomains = 0; + int i; + int rv = -1; + struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virNetError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if ((ndomains = virConnectListAllDomains(priv->conn, + &doms, + args->ndomains, + args->flags)) < 0) + goto cleanup; + + if (doms) { + if (VIR_ALLOC_N(ret->domains.domains_val, ndomains) < 0) { + virReportOOMError(); + goto cleanup; + } + + ret->domains.domains_len = ndomains; + + for (i = 0; i < ndomains; i++) + make_nonnull_domain(ret->domains.domains_val+i, doms[i]); + } + + rv = ndomains; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + if (doms) { + for (i = 0; i < ndomains;i++) + virDomainFree(doms[i]); + VIR_FREE(doms); + } + return rv; +} + +static int remoteDispatchDomainGetSchedulerParametersFlags(virNetServerPtr server ATTRIBUTE_UNUSED, virNetServerClientPtr client ATTRIBUTE_UNUSED, virNetMessagePtr msg ATTRIBUTE_UNUSED, diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 5c87561..4cd02ec 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -1265,6 +1265,71 @@ done: return rv; } +static int +remoteConnectListAllDomains(virConnectPtr conn, + virDomainPtr **domains, + int ndomains, + unsigned int flags) +{ + int rv = -1; + int i; + virDomainPtr *doms = NULL; + remote_connect_list_all_domains_args args; + remote_connect_list_all_domains_ret ret; + + struct private_data *priv = conn->privateData; + + remoteDriverLock(priv); + + if (domains) + *domains = NULL; + + args.ndomains = ndomains; + args.flags = flags; + + memset(&ret, 0, sizeof(ret)); + if (call (conn, + priv, + 0, + REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS, + (xdrproc_t) xdr_remote_connect_list_all_domains_args, + (char *) &args, + (xdrproc_t) xdr_remote_connect_list_all_domains_ret, + (char *) &ret) == -1) + goto done; + + if (domains) { + if (VIR_ALLOC_N(doms, ret.domains.domains_len) < 0) + goto no_memory; + for (i = 0; i < ret.domains.domains_len; i++) { + doms[i] = get_nonnull_domain(conn, ret.domains.domains_val[i]); + if (!doms[i]) + goto no_memory; + } + + *domains = doms; + doms = NULL; + } + + rv = ret.domains.domains_len; + +cleanup: + xdr_free((xdrproc_t) xdr_remote_connect_list_all_domains_ret, (char *) &ret); + +done: + remoteDriverUnlock(priv); + return rv; + +no_memory: + if (doms) { + for (i = 0; i < ret.domains.domains_len; i++) + virDomainFree(*domains[i]); + VIR_FREE(doms); + } + virReportOOMError(); + goto cleanup; +} + /* Helper to free typed parameters. */ static void remoteFreeTypedParameters(remote_typed_param *args_params_val, @@ -5111,6 +5176,7 @@ static virDriver remote_driver = { .domainGetDiskErrors = remoteDomainGetDiskErrors, /* 0.9.10 */ .domainSetMetadata = remoteDomainSetMetadata, /* 0.9.10 */ .domainGetMetadata = remoteDomainGetMetadata, /* 0.9.10 */ + .connectListAllDomains = remoteConnectListAllDomains, /* 0.9.13 */ }; static virNetworkDriver network_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 2d57247..bc254bd 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2463,6 +2463,16 @@ struct remote_domain_get_disk_errors_ret { int nerrors; }; +struct remote_connect_list_all_domains_args { + int ndomains; + unsigned int flags; +}; + +struct remote_connect_list_all_domains_ret { + remote_nonnull_domain domains<>; + unsigned int ret; +}; + /*----- Protocol. -----*/ @@ -2782,7 +2792,9 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_PM_WAKEUP = 267, /* autogen autogen */ REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE = 268, /* autogen autogen */ REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP = 269, /* autogen autogen */ - REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND = 270 /* autogen autogen */ + REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND = 270, /* autogen autogen */ + + REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS = 271 /* skipgen skipgen priority:high */ /* * Notice how the entries are grouped in sets of 10 ? diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index 9b2414f..322a0e1 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -1921,6 +1921,17 @@ struct remote_domain_get_disk_errors_ret { } errors; int nerrors; }; +struct remote_connect_list_all_domains_args { + int ndomains; + u_int flags; +}; +struct remote_connect_list_all_domains_ret { + struct { + u_int domains_len; + remote_nonnull_domain * domains_val; + } domains; + u_int ret; +}; enum remote_procedure { REMOTE_PROC_OPEN = 1, REMOTE_PROC_CLOSE = 2, @@ -2192,4 +2203,5 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE = 268, REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP = 269, REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND = 270, + REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS = 271, }; -- 1.7.3.4

This patch adds a basic implementation of the listing code for virConnectListAllDomains() to qemu driver. The listing code does not support any filtering flags yet, but they may be easily added later. --- src/qemu/qemu_driver.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 97 insertions(+), 0 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index efbc421..e7b029f 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -12948,6 +12948,102 @@ cleanup: return ret; } +struct virDomainListData { + virConnectPtr conn; + virDomainPtr *domains; + int ndomains; + int size; + int limit; + bool error; + bool populate; +}; + +#define VIR_DOMAIN_LIST_POPULATION_INCREMENT 10 + +static void +qemuPopulateDomainList(void *payload, + const void *name ATTRIBUTE_UNUSED, + void *opaque) +{ + struct virDomainListData *data = opaque; + virDomainObjPtr vm = payload; + + if (data->error || + (data->limit >= 0 && + data->ndomains >= data->limit)) + return; + + if (!data->populate) { + data->ndomains++; + return; + } + + virDomainObjLock(vm); + + if (data->size == data->ndomains) { + if (VIR_REALLOC_N(data->domains, + data->size + VIR_DOMAIN_LIST_POPULATION_INCREMENT) < 0) + goto no_memory; + data->size += VIR_DOMAIN_LIST_POPULATION_INCREMENT; + } + + data->domains[data->ndomains] = virGetDomain(data->conn, + vm->def->name, + vm->def->uuid); + if (data->domains[data->ndomains] == NULL) + goto no_memory; + + data->domains[data->ndomains]->id = vm->def->id; + data->ndomains++; + +cleanup: + virDomainObjUnlock(vm); + return; + +no_memory: + virReportOOMError(); + data->error = true; + goto cleanup; +} + +static int +qemuListAllDomains(virConnectPtr conn, + virDomainPtr **domains, + int ndomains, + unsigned int flags) +{ + struct qemud_driver *driver = conn->privateData; + int ret = -1; + int i; + + struct virDomainListData data = { conn, NULL, 0, 0, ndomains, + false, !!domains}; + + virCheckFlags(0, -1); + + qemuDriverLock(driver); + + virHashForEach(driver->domains.objs, qemuPopulateDomainList, + (void *) &data); + + if (data.error) { + for (i = 0; i < data.size; i++) { + if (data.domains[i]) + virDomainFree(data.domains[i]); + } + VIR_FREE(data.domains); + data.ndomains = -1; + } + + if (domains) + *domains = data.domains; + + ret = data.ndomains; + + qemuDriverUnlock(driver); + return ret; +} + static virDriver qemuDriver = { .no = VIR_DRV_QEMU, .name = QEMU_DRIVER_NAME, @@ -13108,6 +13204,7 @@ static virDriver qemuDriver = { .domainPMSuspendForDuration = qemuDomainPMSuspendForDuration, /* 0.9.11 */ .domainPMWakeup = qemuDomainPMWakeup, /* 0.9.11 */ .domainGetCPUStats = qemuDomainGetCPUStats, /* 0.9.11 */ + .connectListAllDomains = qemuListAllDomains, /* 0.9.13 */ }; -- 1.7.3.4

This patch makes use of the newly added api virConnectListAllDomains() to list domains in virsh. To enable fallback virsh now represents lists of domains using an internal structure vshDomainList. This structure contains the virDomainPtr list as provided by virConnectListAllDomains() and the count of domains in the list. For backwards compatiblity I've added function vshDomList that tries to enumerate the domains using the new API and if the API is not supported falls back to the older approach with the two list functions. This patch also adds helpers to filter domain lists provided by vshDomList(). As a last improvement I've cleaned up code that handles the "list" command using the newly added helper and filter functions. --- tools/virsh.c | 423 +++++++++++++++++++++++++++++++++++++-------------------- 1 files changed, 273 insertions(+), 150 deletions(-) diff --git a/tools/virsh.c b/tools/virsh.c index 46239fa..7f3f9ac 100644 --- a/tools/virsh.c +++ b/tools/virsh.c @@ -63,6 +63,7 @@ #include "util/bitmap.h" #include "conf/domain_conf.h" #include "virtypedparam.h" +#include "intprops.h" static char *progname; @@ -489,22 +490,225 @@ _vshStrdup(vshControl *ctl, const char *s, const char *filename, int line) #define realloc use_vshRealloc_instead_of_realloc #define strdup use_vshStrdup_instead_of_strdup -static int idsorter(const void *a, const void *b) { - const int *ia = (const int *)a; - const int *ib = (const int *)b; +static int +namesorter(const void *a, const void *b) +{ + const char **sa = (const char**)a; + const char **sb = (const char**)b; - if (*ia > *ib) - return 1; - else if (*ia < *ib) - return -1; - return 0; + /* User visible sort, so we want locale-specific case comparison. */ + return strcasecmp(*sa, *sb); +} + +static int +domsorter(const void *a, const void *b) +{ + virDomainPtr *da = (virDomainPtr *) a; + virDomainPtr *db = (virDomainPtr *) b; + unsigned int ida = virDomainGetID(*da); + unsigned int idb = virDomainGetID(*db); + unsigned int err = (unsigned int) -1; + + if (ida == err && idb == err) { + if (virDomainGetName(*da) || + virDomainGetName(*db)) + return strcasecmp(virDomainGetName(*da), + virDomainGetName(*db)); + else + return 0; + } + + if (ida != err && idb != err) { + if (ida > idb) + return 1; + else if (ida < idb) + return -1; + + return 0; + } + + if (ida != err) + return -1; + else + return 1; +} + +struct vshDomainList { + virDomainPtr *domains; + int ndomains; +}; +typedef struct vshDomainList *vshDomainListPtr; + +static int +vshDomList(vshControl *ctl, vshDomainListPtr domlist) +{ + int ret; + int rv = -1; + virErrorPtr err = NULL; + int i; + int *ids = NULL; + int nids = 0; + char **names = NULL; + int nnames = 0; + virDomainPtr dom; + virDomainPtr *doms = NULL; + int ndoms = 0; + + domlist->domains = NULL; + domlist->ndomains = 0; + + if ((ret = virConnectListAllDomains(ctl->conn, + &(domlist->domains), + -1, 0)) >= 0) { + domlist->ndomains = ret; + qsort(domlist->domains, domlist->ndomains, + sizeof(virDomainPtr), domsorter); + return ret; + } + + if ((err = virGetLastError()) && + err->code != VIR_ERR_NO_SUPPORT) { + vshError(ctl, "%s", _("Failed to list domains")); + goto cleanup; + } + + /* fall back to old method */ + virResetLastError(); + + 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 ((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; + } + } + + doms = vshMalloc(ctl, sizeof(virDomainPtr) * (nids + nnames)); + + /* get active domains */ + for (i = 0; i < nids; i++) { + if (!(dom = virDomainLookupByID(ctl->conn, ids[i]))) + continue; + + doms[ndoms++] = dom; + } + + /* get inctive domains */ + for (i = 0; i < nnames; i++) { + if (!(dom = virDomainLookupByName(ctl->conn, names[i]))) + continue; + + doms[ndoms++] = dom; + } + + qsort(doms, ndoms, sizeof(virDomainPtr), domsorter); + + domlist->domains = doms; + doms = NULL; + domlist->ndomains = ndoms; + rv = ndoms; + +cleanup: + for (i = 0; i < nnames; i++) + VIR_FREE(names[i]); + if (doms) { + for (i = 0; i < ndoms; i++) { + if (doms[i]) + virDomainFree(doms[i]); + } + } + VIR_FREE(doms); + VIR_FREE(names); + VIR_FREE(ids); + return rv; +} + +static void +vshDomListFree(vshDomainListPtr domlist) +{ + int i; + + if (!domlist || !domlist->domains) + return; + + for (i = 0; i < domlist->ndomains; i++) { + if (domlist->domains[i]) + virDomainFree(domlist->domains[i]); + } + + domlist->ndomains = 0; + VIR_FREE(domlist->domains); +} + +/* return 0 if false, 1 if true -1 if error */ +typedef int (*vshDomainListFilter)(vshControl *ctl, virDomainPtr dom); + +/* collection of filters */ +static int +vshDomainListActiveFilter(vshControl *ctl ATTRIBUTE_UNUSED, + virDomainPtr dom) +{ + return virDomainGetID(dom) != (unsigned int) -1; } -static int namesorter(const void *a, const void *b) { - const char **sa = (const char**)a; - const char **sb = (const char**)b; - /* User visible sort, so we want locale-specific case comparison. */ - return strcasecmp(*sa, *sb); +static int +vshDomainListPersistentFilter(vshControl *ctl, + virDomainPtr dom) +{ + int persistent = virDomainIsPersistent(dom); + if (persistent < 0) { + vshError(ctl, "%s", + _("Failed to determine domain's persistent state")); + return -1; + } + return persistent; +} + +static int +vshDomListFreeFilter(vshControl *ctl, + vshDomainListPtr domlist, + vshDomainListFilter filter, + bool expect_result) +{ + int i; + int ret; + + for (i = 0; i < domlist->ndomains; i++) { + if (!domlist->domains[i]) + continue; + + ret = filter(ctl, domlist->domains[i]); + if (ret < 0) + return -1; + + if (!ret == !expect_result) { + virDomainFree(domlist->domains[i]); + domlist->domains[i] = NULL; + } + } + return 0; } static double @@ -936,9 +1140,6 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED) bool inactive = vshCommandOptBool(cmd, "inactive"); bool all = vshCommandOptBool(cmd, "all"); bool active = !inactive || all; - int *ids = NULL, maxid = 0, i; - char **names = NULL; - int maxname = 0; bool managed = vshCommandOptBool(cmd, "managed-save"); bool optTitle = vshCommandOptBool(cmd, "title"); bool optTable = vshCommandOptBool(cmd, "table"); @@ -947,12 +1148,13 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED) bool optPersistent = vshCommandOptBool(cmd, "persistent"); bool optTransient = vshCommandOptBool(cmd, "transient"); bool persistUsed = true; - virDomainPtr dom = NULL; + int i; char *title; char uuid[VIR_UUID_STRING_BUFLEN]; int state; - int persistent; bool ret = false; + struct vshDomainList list; + char id[INT_BUFSIZE_BOUND(unsigned int)]; inactive |= all; @@ -976,167 +1178,88 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED) if (!vshConnectionUsability(ctl, ctl->conn)) return false; - if (active) { - maxid = virConnectNumOfDomains(ctl->conn); - if (maxid < 0) { - vshError(ctl, "%s", _("Failed to list active domains")); - return false; - } - if (maxid) { - ids = vshMalloc(ctl, sizeof(int) * maxid); + if (vshDomList(ctl, &list) < 0) + goto cleanup; - if ((maxid = virConnectListDomains(ctl->conn, ids, maxid)) < 0) { - vshError(ctl, "%s", _("Failed to list active domains")); - goto cleanup; - } + if (!active) + vshDomListFreeFilter(ctl, &list, vshDomainListActiveFilter, true); - qsort(ids, maxid, sizeof(int), idsorter); - } - } + if (!inactive) + vshDomListFreeFilter(ctl, &list, vshDomainListActiveFilter, false); - if (inactive) { - maxname = virConnectNumOfDefinedDomains(ctl->conn); - if (maxname < 0) { - vshError(ctl, "%s", _("Failed to list inactive domains")); + if (persistUsed) { + if (!optPersistent && + vshDomListFreeFilter(ctl, &list, + vshDomainListPersistentFilter, true) < 0) goto cleanup; - } - if (maxname) { - names = vshMalloc(ctl, sizeof(char *) * maxname); - if ((maxname = virConnectListDefinedDomains(ctl->conn, - names, - maxname)) < 0) { - vshError(ctl, "%s", _("Failed to list inactive domains")); - goto cleanup; - } - - qsort(&names[0], maxname, sizeof(char*), namesorter); - } + if (!optTransient && + vshDomListFreeFilter(ctl, &list, + vshDomainListPersistentFilter, false) < 0) + goto cleanup; } /* print table header in legacy mode */ if (optTable) { - if (optTitle) { + if (optTitle) vshPrintExtra(ctl, " %-5s %-30s %-10s %-20s\n%s\n", _("Id"), _("Name"), _("State"), _("Title"), "-----------------------------------------" "-----------------------------------------"); - } else { + else vshPrintExtra(ctl, " %-5s %-30s %s\n%s\n", _("Id"), _("Name"), _("State"), "-----------------------------------------" "-----------"); - } } - for (i = 0; i < maxid; i++) { - dom = virDomainLookupByID(ctl->conn, ids[i]); - - /* this kind of work with domains is not atomic operation */ - if (!dom) + for (i = 0; i < list.ndomains; i++) { + if (!list.domains[i]) continue; - if (persistUsed) { - persistent = virDomainIsPersistent(dom); - if (persistent < 0) { - vshError(ctl, "%s", - _("Failed to determine domain's persistent state")); - goto cleanup; - } + if (virDomainGetID(list.domains[i]) != (unsigned int) -1) + snprintf(id, sizeof(id), "%d", virDomainGetID(list.domains[i])); + else + strncpy(id, "-", sizeof(id)); - if (!(persistent ? optPersistent : optTransient)) { - virDomainFree(dom); - dom = NULL; - continue; - } - } - - if (optTable) { - if (optTitle) { - if (!(title = vshGetDomainDescription(ctl, dom, true, 0))) - goto cleanup; - - vshPrint(ctl, " %-5d %-30s %-10s %-20s\n", - virDomainGetID(dom), - virDomainGetName(dom), - _(vshDomainStateToString(vshDomainState(ctl, dom, NULL))), - title); - VIR_FREE(title); - } else { - vshPrint(ctl, " %-5d %-30s %s\n", - virDomainGetID(dom), - virDomainGetName(dom), - _(vshDomainStateToString(vshDomainState(ctl, dom, NULL)))); - } - } 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)); - } - - virDomainFree(dom); - dom = NULL; - } - - if (optPersistent) { - for (i = 0; i < maxname; i++) { - dom = virDomainLookupByName(ctl->conn, names[i]); - - /* this kind of work with domains is not atomic operation */ - if (!dom) - continue; + state = vshDomainState(ctl, list.domains[i], NULL); + if (managed && state == VIR_DOMAIN_SHUTOFF && + virDomainHasManagedSaveImage(list.domains[i], 0) > 0) + state = -2; - if (optTable) { - state = vshDomainState(ctl, dom, NULL); - if (managed && state == VIR_DOMAIN_SHUTOFF && - virDomainHasManagedSaveImage(dom, 0) > 0) - state = -2; - - if (optTitle) { - if (!(title = vshGetDomainDescription(ctl, dom, true, 0))) - goto cleanup; - - vshPrint(ctl, " %-5s %-30s %-10s %-20s\n", - "-", - names[i], - state == -2 ? _("saved") : _(vshDomainStateToString(state)), - title); - VIR_FREE(title); - } else { - vshPrint(ctl, " %-5s %-30s %s\n", - "-", - names[i], - 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", names[i]); - } + if (optTable) { + if (optTitle) { + if (!(title = vshGetDomainDescription(ctl, list.domains[i], true, 0))) + goto cleanup; + + vshPrint(ctl, " %-5s %-30s %-10s %-20s\n", + id, + virDomainGetName(list.domains[i]), + state == -2 ? _("saved") : _(vshDomainStateToString(state)), + title); - virDomainFree(dom); - dom = NULL; + VIR_FREE(title); + } else { + vshPrint(ctl, " %-5s %-30s %s\n", + id, + virDomainGetName(list.domains[i]), + state == -2 ? _("saved") : _(vshDomainStateToString(state))); + } + } else if (optUUID) { + if (virDomainGetUUIDString(list.domains[i], 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(list.domains[i])); } } ret = true; cleanup: - if (dom) - virDomainFree(dom); - VIR_FREE(ids); - for (i = 0; i < maxname; i++) - VIR_FREE(names[i]); - VIR_FREE(names); + vshDomListFree(&list); return ret; } -- 1.7.3.4