This patch adds a new public api that lists domains. The new approach is different from those used before. There are key points to this: 1) The list is acquired atomically 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 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 hypervisor calls. 3) The returned list is auto-allocated. This saves a lot of hassle for the users. 4) Built in support for filtering. The API call supports various filtering flags that modify the output list according to user needs. Available filter groups: Domain status: VIR_CONNECT_LIST_DOMAINS_ACTIVE, VIR_CONNECT_LIST_DOMAINS_INACTIVE Domain persistence: VIR_CONNECT_LIST_DOMAINS_PERSISTENT, VIR_CONNECT_LIST_DOMAINS_TRANSIENT Domain state: VIR_CONNECT_LIST_DOMAINS_RUNNING, VIR_CONNECT_LIST_DOMAINS_PAUSED, VIR_CONNECT_LIST_DOMAINS_SHUTOFF, VIR_CONNECT_LIST_DOMAINS_OTHER Existence of managed save image: VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE, VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE Auto-start option: VIR_CONNECT_LIST_DOMAINS_AUTOSTART, VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART Existence of snapshot: VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT, VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT 5) 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 manually. *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 --- Diff to v2: - doc tweaks and spelling corrections - return NULL in the return array on error --- include/libvirt/libvirt.h.in | 36 ++++++++++++- python/generator.py | 1 + src/driver.h | 11 +++- src/libvirt.c | 124 +++++++++++++++++++++++++++++++++++++++++- src/libvirt_public.syms | 1 + 5 files changed, 166 insertions(+), 7 deletions(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index fcb6695..48b6516 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -1759,8 +1759,40 @@ 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); +/** + * virConnectListAllDomainsFlags: + * + * Flags used to tune which domains are listed by virConnectListAllDomains(). + * Note that these flags come in groups; if all bits from a group are 0, + * then that group is not used to filter results. + */ +typedef enum { + VIR_CONNECT_LIST_DOMAINS_ACTIVE = 1 << 0, + VIR_CONNECT_LIST_DOMAINS_INACTIVE = 1 << 1, + + VIR_CONNECT_LIST_DOMAINS_PERSISTENT = 1 << 2, + VIR_CONNECT_LIST_DOMAINS_TRANSIENT = 1 << 3, + + VIR_CONNECT_LIST_DOMAINS_RUNNING = 1 << 4, + VIR_CONNECT_LIST_DOMAINS_PAUSED = 1 << 5, + VIR_CONNECT_LIST_DOMAINS_SHUTOFF = 1 << 6, + VIR_CONNECT_LIST_DOMAINS_OTHER = 1 << 7, + + VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = 1 << 8, + VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = 1 << 9, + + VIR_CONNECT_LIST_DOMAINS_AUTOSTART = 1 << 10, + VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = 1 << 11, + + VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = 1 << 12, + VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = 1 << 13, +} virConnectListAllDomainsFlags; + +int virConnectListAllDomains (virConnectPtr conn, + virDomainPtr **domains, + 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..0b6ac7c 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', #overridden 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 aa7a377..c4e558f 100644 --- a/src/driver.h +++ b/src/driver.h @@ -251,9 +251,13 @@ 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 + (*virDrvListAllDomains) (virConnectPtr conn, + virDomainPtr **domains, + unsigned int flags); typedef int (*virDrvNumOfDefinedDomains) (virConnectPtr conn); typedef int @@ -866,6 +870,7 @@ struct _virDriver { virDrvGetCapabilities getCapabilities; virDrvListDomains listDomains; virDrvNumOfDomains numOfDomains; + virDrvListAllDomains listAllDomains; virDrvDomainCreateXML domainCreateXML; virDrvDomainLookupByID domainLookupByID; virDrvDomainLookupByUUID domainLookupByUUID; diff --git a/src/libvirt.c b/src/libvirt.c index 00358d6..e390f39 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -1780,7 +1780,14 @@ error: * * Collect the list of active domains, and store their IDs in array @ids * - * Returns the number of domains found or -1 in case of error + * For inactive domains, see virConnectListDefinedDomains(). For more + * control over the results, see virConnectListAllDomains(). + * + * Returns the number of domains found or -1 in case of error. Note that + * this command is inherently racy; a domain can be started between a + * call to virConnectNumOfDomains() and this call; you are only guaranteed + * that all currently active domains were listed if the return is less + * than @maxids. */ int virConnectListDomains(virConnectPtr conn, int *ids, int maxids) @@ -7953,7 +7960,14 @@ error: * list the defined but inactive domains, stores the pointers to the names * in @names * - * Returns the number of names provided in the array or -1 in case of error + * For active domains, see virConnectListDomains(). For more control over + * the results, see virConnectListAllDomains(). + * + * Returns the number of names provided in the array or -1 in case of error. + * Note that this command is inherently racy; a domain can be defined between + * a call to virConnectNumOfDefinedDomains() and this call; you are only + * guaranteed that all currently defined domains were listed if the return + * is less than @maxids. The client must call free() on each returned name. */ int virConnectListDefinedDomains(virConnectPtr conn, char **const names, @@ -7987,6 +8001,112 @@ 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). + * @flags: bitwise-OR of virConnectListAllDomainsFlags + * + * Collect a possibly-filtered list of all domains, and return an allocated + * array of information for each. This API solves the race inherent in + * virConnectListDomains() and virConnectListDefinedDomains(). + * + * Normally, all domains are returned; however, @flags can be used to + * filter the results for a smaller list of targeted domains. The valid + * flags are divided into groups, where each group contains bits that + * describe mutually exclusive attributes of a domain, and where all bits + * within a group describe all possible domains. Some hypervisors might + * reject explicit bits from a group where the hypervisor cannot make a + * distinction (for example, not all hypervisors can tell whether domains + * have snapshots). For a group supported by a given hypervisor, the + * behavior when no bits of a group are set is identical to the behavior + * when all bits in that group are set. When setting bits from more than + * one group, it is possible to select an impossible combination (such + * as an inactive transient domain), in that case a hypervisor may return + * either 0 or an error. + * + * The first group of @flags is VIR_CONNECT_LIST_DOMAINS_ACTIVE (online + * domains) and VIR_CONNECT_LIST_DOMAINS_INACTIVE (offline domains). + * + * The next group of @flags is VIR_CONNECT_LIST_DOMAINS_PERSISTENT (defined + * domains) and VIR_CONNECT_LIST_DOMAINS_TRANSIENT (running but not defined). + * + * The next group of @flags covers various domain states: + * VIR_CONNECT_LIST_DOMAINS_RUNNING, VIR_CONNECT_LIST_DOMAINS_PAUSED, + * VIR_CONNECT_LIST_DOMAINS_SHUTOFF, and a catch-all for all other states + * (such as crashed, this catch-all covers the possibility of adding new + * states). + * + * The remaining groups cover boolean attributes commonly asked about + * domains; they include VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE and + * VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE, for filtering based on whether + * a managed save image exists; VIR_CONNECT_LIST_DOMAINS_AUTOSTART and + * VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART, for filtering based on autostart; + * VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT and + * VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT, for filtering based on whether + * a domain has snapshots. + * + * Returns the number of domains found or -1 and sets domains to NULL in case + * of error. On success, the array stored into @doms is guaranteed to have an + * extra allocated element set to NULL but not included in the return count, to + * make iteration easier. The caller is responsible for calling virDomainFree() + * on each array element, then calling free() on @doms. + * + * Example of usage: + * virDomainPtr *domains; + * virDomainPtr dom; + * int i; + * int ret; + * unsigned int flags = VIR_CONNECT_LIST_RUNNING | + * VIR_CONNECT_LIST_PERSISTENT; + * + * ret = virConnectListAllDomains(conn, &domains, flags); + * if (ret < 0) + * error(); + * + * for (i = 0; i < ret; i++) { + * do_something_with_domain(domains[i]); + * + * //here or in a separate loop if needed + * virDomainFree(domains[i]); + * } + * + * free(domains); + */ +int +virConnectListAllDomains(virConnectPtr conn, + virDomainPtr **domains, + unsigned int flags) +{ + VIR_DEBUG("conn=%p, domains=%p, flags=%x", conn, domains, flags); + + virResetLastError(); + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + + if (domains) + *domains = NULL; + + if (conn->driver->listAllDomains) { + int ret; + ret = conn->driver->listAllDomains(conn, domains, 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 ba61595..912f7ca 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -536,6 +536,7 @@ LIBVIRT_0.9.11 { LIBVIRT_0.9.13 { global: + virConnectListAllDomains; virDomainSnapshotRef; } LIBVIRT_0.9.11; -- 1.7.3.4

This patch makes use of the newly added api virConnectListAllDomains() to list domains in virsh. 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 function vshDomList was added 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. The helper function also simulates filtering by all currently supported flags added with virConnectListAllDomains(). This patch also cleans up the "list" command handler to use the new helpers and adds new command line flags to make use of filtering. --- Diff to v2: - moved this patch right after API implementation to make testing fallback easier - added support for all filtering flags both in fallback code and in "list" command - fixed messed up syntax check silencing :) - fixed spelling errors but probably introduced a ton of new as I've added new docs --- tools/virsh.c | 555 ++++++++++++++++++++++++++++++++++++++----------------- tools/virsh.pod | 91 +++++++--- 2 files changed, 449 insertions(+), 197 deletions(-) diff --git a/tools/virsh.c b/tools/virsh.c index abcfbff..8d86cb0 100644 --- a/tools/virsh.c +++ b/tools/virsh.c @@ -64,6 +64,7 @@ #include "util/bitmap.h" #include "conf/domain_conf.h" #include "virtypedparam.h" +#include "intprops.h" static char *progname; @@ -490,22 +491,307 @@ _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 inactive = (unsigned int) -1; + + 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; + int ndomains; +}; +typedef struct vshDomainList *vshDomainListPtr; + +#define MATCH(FLAG) (flags & (FLAG)) +static int +vshDomList(vshControl *ctl, vshDomainListPtr domlist, unsigned int flags) +{ + 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; + int count = 0; + int active; + int persistent; + int autostart; + int state; + int nsnap; + int mansave; + + domlist->domains = NULL; + domlist->ndomains = 0; + + /* try the list with flags support */ + if ((ndoms = virConnectListAllDomains(ctl->conn, &doms, flags)) >= 0) { + domlist->ndomains = ndoms; + domlist->domains = doms; + doms = NULL; + goto finished; + } + + /* check if the command is actualy supported */ + if ((err = virGetLastError()) && + err->code == VIR_ERR_NO_SUPPORT) + goto fallback; + + if ((err= virGetLastError()) && + err->code == VIR_ERR_INVALID_ARG) { + /* try again the new API but without flags this time */ + if ((ndoms = virConnectListAllDomains(ctl->conn, &doms, 0)) >= 0) + 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 */ + virResetLastError(); + + /* list active domains, if necessary */ + if (!MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE | + VIR_CONNECT_LIST_DOMAINS_INACTIVE) || + 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_DOMAINS_ACTIVE | + VIR_CONNECT_LIST_DOMAINS_INACTIVE) || + 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; + } + } + } + + doms = vshMalloc(ctl, sizeof(virDomainPtr) * (nids + nnames)); + ndoms = 0; + + /* 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; + } + +filter: + /* filter list the list if the list was acquired by fallback means */ + for (i = 0; i < ndoms; i++) { + dom = doms[i]; + + /* active state filter */ + if (MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE | + VIR_CONNECT_LIST_DOMAINS_INACTIVE)) { + if ((active = virDomainIsActive(dom)) < 0) { + vshError(ctl, "%s", _("Failed to get domain active state")); + goto cleanup; + } + + if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE) && active) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE) && !active))) + goto remove_entry; + } + + /* persistence filter */ + if (MATCH(VIR_CONNECT_LIST_DOMAINS_PERSISTENT | + VIR_CONNECT_LIST_DOMAINS_TRANSIENT)) { + 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_DOMAINS_RUNNING | + VIR_CONNECT_LIST_DOMAINS_PAUSED | + VIR_CONNECT_LIST_DOMAINS_SHUTOFF | + VIR_CONNECT_LIST_DOMAINS_OTHER)) { + 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_DOMAINS_AUTOSTART | + VIR_CONNECT_LIST_DOMAINS_NO_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_DOMAINS_MANAGEDSAVE | + VIR_CONNECT_LIST_DOMAINS_NO_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_DOMAINS_HAS_SNAPSHOT | + VIR_CONNECT_LIST_DOMAINS_NO_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, pack them at the front */ + doms[count++] = dom; + continue; + +remove_entry: + /* the domain has to be removed as it failed one of the filters */ + virDomainFree(doms[i]); + doms[i] = NULL; + } + + /* we're shortening the array, so it's safe to ignore value */ + ignore_value(VIR_REALLOC_N(doms, count)); + + domlist->domains = doms; + domlist->ndomains = count; + doms = NULL; + +finished: + /* sort the list */ + if (domlist->domains && domlist->ndomains > 0) + qsort(domlist->domains, domlist->ndomains, + sizeof(*domlist->domains), domsorter); + + rv = domlist->ndomains; + +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 int namesorter(const void *a, const void *b) { - const char **sa = (const char**)a; - const char **sb = (const char**)b; +#undef MATCH + +static void +vshDomListFree(vshDomainListPtr domlist) +{ + int i; + + if (!domlist || !domlist->domains) + return; - /* User visible sort, so we want locale-specific case comparison. */ - return strcasecmp(*sa, *sb); + for (i = 0; i < domlist->ndomains; i++) { + if (domlist->domains[i]) + virDomainFree(domlist->domains[i]); + } + + domlist->ndomains = 0; + VIR_FREE(domlist->domains); } static double @@ -977,6 +1263,21 @@ static const vshCmdOptDef opts_list[] = { {"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")}, + {"snapshot-yes", VSH_OT_BOOL, 0, + N_("list domains with existing snapshot")}, + {"snapshot-no", 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-yes", VSH_OT_BOOL, 0, + N_("list domains with autostart enabled")}, + {"autostart-no", VSH_OT_BOOL, 0, + N_("list domains with autostart disabled")}, + {"managedsave-yes", VSH_OT_BOOL, 0, + N_("list domains with managed save state")}, + {"managedsave-no", 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)")}, @@ -987,38 +1288,50 @@ static const vshCmdOptDef opts_list[] = { }; +#define FILTER(NAME, FLAG) \ + if (vshCommandOptBool(cmd, NAME)) \ + flags |= (FLAG) static bool 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"); bool optUUID = vshCommandOptBool(cmd, "uuid"); bool optName = vshCommandOptBool(cmd, "name"); - 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)]; + unsigned int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE; - inactive |= all; + /* construct filter flags */ + if (vshCommandOptBool(cmd, "inactive")) + flags = VIR_CONNECT_LIST_DOMAINS_INACTIVE; - /* process arguments */ - if (!optPersistent && !optTransient) { - optPersistent = true; - optTransient = true; - persistUsed = false; - } + 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("managedsave-yes", VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE); + FILTER("managedsave-no", VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE); + + FILTER("autostart-yes", VIR_CONNECT_LIST_DOMAINS_AUTOSTART); + FILTER("autostart-no", VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART); + + FILTER("snapshot-yes", VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT); + FILTER("snapshot-no", 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", @@ -1033,169 +1346,67 @@ 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 ((maxid = virConnectListDomains(ctl->conn, ids, maxid)) < 0) { - vshError(ctl, "%s", _("Failed to list active domains")); - goto cleanup; - } - - qsort(ids, maxid, sizeof(int), idsorter); - } - } - - if (inactive) { - maxname = virConnectNumOfDefinedDomains(ctl->conn); - if (maxname < 0) { - vshError(ctl, "%s", _("Failed to list inactive domains")); - 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 (vshDomList(ctl, &list, flags) < 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) - continue; + for (i = 0; i < list.ndomains; i++) { + if (virDomainGetID(list.domains[i]) != (unsigned int) -1) + snprintf(id, sizeof(id), "%d", virDomainGetID(list.domains[i])); + else + ignore_value(virStrcpyStatic(id, "-")); - if (persistUsed) { - persistent = virDomainIsPersistent(dom); - if (persistent < 0) { - vshError(ctl, "%s", - _("Failed to determine domain's persistent state")); - goto cleanup; - } + state = vshDomainState(ctl, list.domains[i], NULL); + if (optTable && managed && state == VIR_DOMAIN_SHUTOFF && + virDomainHasManagedSaveImage(list.domains[i], 0) > 0) + state = -2; - 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; + if (optTable) { + if (optTitle) { + if (!(title = vshGetDomainDescription(ctl, list.domains[i], true, 0))) + goto cleanup; - 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]); - } + 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; } +#undef FILTER /* * "desc" command for managing domain description and title diff --git a/tools/virsh.pod b/tools/virsh.pod index ef71717..7e7309d 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -306,9 +306,15 @@ The XML also show the NUMA topology information if available. Inject NMI to the guest. -=item B<list> [I<--inactive> | I<--all>] [I<--managed-save>] [I<--title>] - { [I<--table>] | I<--name> | I<--uuid> } [I<--persistent>] - [I<--transient>] +=item B<list> [I<--inactive> | I<--all>] + [I<--managed-save>] [I<--title>] + { [I<--table>] | I<--name> | I<--uuid> } + [I<--persistent>] [I<--transient>] + [I<--managedsave-yes>] [I<--managedsave-no>] + [I<--autostart-yes>] [I<--autostart-no>] + [I<--snapshot-yes>] [I<--snapshot-no>] + [I<--state-running>] [I<--state-paused>] + [I<--state-shutoff>] [I<--state-other>] Prints information about existing domains. If no options are specified it prints out information about running domains. @@ -316,13 +322,10 @@ specified it prints out information about running domains. An example format for the list is as follows: B<virsh> list - Id Name State - ----------------------------------- - - 0 Domain-0 running - 2 fedora paused - + Id Name State + ---------------------------------------------------- + 0 Domain-0 running + 2 fedora paused Name is the name of the domain. ID the domain numeric id. State is the run state (see below). @@ -380,11 +383,55 @@ into s3 state. =back -If I<--managed-save> is specified, then domains that have managed save -state (only possible if they are in the B<shut off> state, so you need to -specify I<--inactive> or I<--all> to actually list them) will instead -show as B<saved> in the listing. This flag is usable only with the -default I<--table> output. +Normally only active domains are listed. To list inactive domains specify +I<--inactive> or I<--all> to list both active and inactive domains. + +To filter the list of domains present on the hypervisor you may specify one or +more of filtering flags supported by the B<list> command. These flags are +grouped by function. Specifying one or more of flags from a group enables the +filter group. Supported filtering flags and groups: + +=over 4 + +=item B<Persistence> + +Flag I<--persistent> is used to include persistent domains in the returned +list. To include transient domains specify I<--transient>. + +=item B<Existence of managed save image> + +To list domains having a managed save image specify flag I<--managedsave-yes>. +For domains that don't have a managed save image specify I<--managedsave-no>. + +=item B<Domain state> + +Following filter flags to select domains by its state are available: +I<--state-running> for runnign domains, I<--state-paused> for paused domains, +I<--state-shutoff> for turned off domains and I<--state-other> for all +other states as a fallback. + +=item B<Autostarting domains> + +To list autostarting domains use the flag I<--autostart-yes>. To list domains +with this feature disabled use I<--autostart-no>. + +=item B<Snapshot existence> + +Domains that have snapshot images can be listed using flagI<--snapshot-yes>, +domains without a snapshot I<--snapshot-no>. + +=back + +First attempt to acquire the domain list is done by the non-racy listing API. +If this API is not available for the current connection the list is constructed +using fallback code that might miss domains transitioning states when the +fallback code is executed. + +If I<--managed-save> is specified, then domains that have managed save state +(only possible if they are in the B<shut off> state, so you need to specify +I<--inactive> or I<--all> to actually list them) will instead show as B<saved> +in the listing. This flag is usable only with the default I<--table> output. +Note that this flag does not filter the list of domains. If I<--name> is specified, domain names are printed instead of the table formatted one per line. If I<--uuid> is specified domain's UUID's are printed @@ -392,12 +439,6 @@ instead of names. Flag I<--table> specifies that the legacy table-formatted output should be used. This is the default. All of these are mutually exclusive. -Flag I<--persistent> specifies that persistent domains should be printed. -Similarly I<--transient> enables output of transient domains. These flags -may be combined. Default behavior is as though both were specified. (Note that -if any of these flags is specified, the check for the persistence state is done -and may fail. If none of these flags is specified, the check is skipped.) - If I<--title> is specified, then the short domain description (title) is printed in an extra column. This flag is usable only with the default I<--table> output. @@ -405,10 +446,10 @@ I<--table> output. Example: B<virsh> list --title - Id Name State Title - ----------------------------------------------- - 0 Domain-0 running Mailserver 1 - 2 fedora paused + Id Name State Title + -------------------------------------------------------------------------- + 0 Domain-0 running Mailserver 1 + 2 fedora paused =item B<freecell> [{ [I<--cellno>] B<cellno> | I<--all> }] -- 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. --- Diff to v2: - fixed spelling and style nits - changed the boolean flag that tells the remote side if the list is needed to ing - fixed returning of the correct count if no list is requested (I didn't fill and use ret.ret) --- daemon/remote.c | 54 +++++++++++++++++++++++++++++++++++ src/remote/remote_driver.c | 64 ++++++++++++++++++++++++++++++++++++++++++ src/remote/remote_protocol.x | 14 ++++++++- src/remote_protocol-structs | 12 ++++++++ 4 files changed, 143 insertions(+), 1 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index a02c09b..8dd5a4f 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -996,6 +996,60 @@ 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, + args->need_results ? &doms : NULL, + 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]); + } else { + ret->domains.domains_len = 0; + ret->domains.domains_val = NULL; + } + + ret->ret = ndomains; + + rv = 0; + +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 299cd69..53ddef3 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -1265,6 +1265,69 @@ done: return rv; } +static int +remoteConnectListAllDomains(virConnectPtr conn, + virDomainPtr **domains, + 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); + + args.need_results = !!domains; + 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 + 1) < 0) { + virReportOOMError(); + goto cleanup; + } + + for (i = 0; i < ret.domains.domains_len; i++) { + doms[i] = get_nonnull_domain(conn, ret.domains.domains_val[i]); + if (!doms[i]) { + virReportOOMError(); + goto cleanup; + } + } + *domains = doms; + doms = NULL; + } + + rv = ret.ret; + +cleanup: + if (doms) { + for (i = 0; i < ret.domains.domains_len; i++) + if (doms[i]) + virDomainFree(doms[i]); + VIR_FREE(doms); + } + + xdr_free((xdrproc_t) xdr_remote_connect_list_all_domains_ret, (char *) &ret); + +done: + remoteDriverUnlock(priv); + return rv; +} + /* Helper to free typed parameters. */ static void remoteFreeTypedParameters(remote_typed_param *args_params_val, @@ -5111,6 +5174,7 @@ static virDriver remote_driver = { .domainGetDiskErrors = remoteDomainGetDiskErrors, /* 0.9.10 */ .domainSetMetadata = remoteDomainSetMetadata, /* 0.9.10 */ .domainGetMetadata = remoteDomainGetMetadata, /* 0.9.10 */ + .listAllDomains = remoteConnectListAllDomains, /* 0.9.13 */ }; static virNetworkDriver network_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index d8a6576..e117ec3 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 need_results; + 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..9539509 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 need_results; + 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 common code to list domains in fashion used by virListAllDomains with all currently supported flags. The header file also contains macros that group filters together that are used to shorten filter conditions. --- Diff to v2: -added macros grouping filter flags -Added support for managed save filtering, now that virDomainObj holds this property - Removed the now unneeded filtering function - Changed allocation of the return list, now It's allocated before for the full length and it's trimmed afterwards - Added newline after the DOMAIN_LIST_SOURCES definition in Makefile.am --- src/Makefile.am | 8 ++- src/conf/virdomainlist.c | 182 ++++++++++++++++++++++++++++++++++++++++++++++ src/conf/virdomainlist.h | 66 +++++++++++++++++ src/libvirt_private.syms | 4 + 4 files changed, 259 insertions(+), 1 deletions(-) create mode 100644 src/conf/virdomainlist.c create mode 100644 src/conf/virdomainlist.h diff --git a/src/Makefile.am b/src/Makefile.am index 60f5442..7726e7e 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -190,10 +190,15 @@ ENCRYPTION_CONF_SOURCES = \ CPU_CONF_SOURCES = \ conf/cpu_conf.c conf/cpu_conf.h + # Safe console handling helper APIs CONSOLE_CONF_SOURCES = \ conf/virconsole.c conf/virconsole.h +# Domain listing helpers +DOMAIN_LIST_SOURCES = \ + conf/virdomainlist.c conf/virdomainlist.h + CONF_SOURCES = \ $(NETDEV_CONF_SOURCES) \ $(DOMAIN_CONF_SOURCES) \ @@ -206,7 +211,8 @@ CONF_SOURCES = \ $(INTERFACE_CONF_SOURCES) \ $(SECRET_CONF_SOURCES) \ $(CPU_CONF_SOURCES) \ - $(CONSOLE_CONF_SOURCES) + $(CONSOLE_CONF_SOURCES) \ + $(DOMAIN_LIST_SOURCES) # The remote RPC driver, covering domains, storage, networks, etc REMOTE_DRIVER_GENERATED = \ diff --git a/src/conf/virdomainlist.c b/src/conf/virdomainlist.c new file mode 100644 index 0000000..8889fee --- /dev/null +++ b/src/conf/virdomainlist.c @@ -0,0 +1,182 @@ +/** + * virdomainlist.c: Helpers for listing and filtering domains. + * + * Copyright (C) 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Peter Krempa <pkrempa@redhat.com> + */ + +#include <config.h> + +#include "virdomainlist.h" + +#include "internal.h" +#include "virhash.h" +#include "domain_conf.h" +#include "memory.h" +#include "datatypes.h" +#include "virterror_internal.h" +#include "ignore-value.h" + +#define VIR_FROM_THIS VIR_FROM_DOMAIN + +struct virDomainListData { + virConnectPtr conn; + virDomainPtr *domains; + unsigned int flags; + int ndomains; + bool error; +}; + +#define MATCH(FLAG) (data->flags & (FLAG)) +static void +virDomainListPopulate(void *payload, + const void *name ATTRIBUTE_UNUSED, + void *opaque) +{ + struct virDomainListData *data = opaque; + virDomainObjPtr vm = payload; + virDomainPtr dom; + + if (data->error) + return; + + virDomainObjLock(vm); + /* check if the domain matches the filter */ + + /* filter by active state */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_ACTIVE) && + !((MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE) && + virDomainObjIsActive(vm)) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE) && + !virDomainObjIsActive(vm)))) + goto cleanup; + + /* filter by persistence */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_PERSISTENT) && + !((MATCH(VIR_CONNECT_LIST_DOMAINS_PERSISTENT) && + vm->persistent) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_TRANSIENT) && + !vm->persistent))) + goto cleanup; + + /* filter by domain state */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_STATE)) { + int st = virDomainObjGetState(vm, NULL); + if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_RUNNING) && + st == VIR_DOMAIN_RUNNING) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_PAUSED) && + st == VIR_DOMAIN_PAUSED) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_SHUTOFF) && + st == VIR_DOMAIN_SHUTOFF) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_OTHER) && + (st != VIR_DOMAIN_RUNNING && + st != VIR_DOMAIN_PAUSED && + st != VIR_DOMAIN_SHUTOFF)))) + goto cleanup; + } + + /* managed save filter function is provided from the driver */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_MANAGEDSAVE) && + !((MATCH(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE) && + vm->hasManagedSave) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE) && + !vm->hasManagedSave))) + goto cleanup; + + /* filter by autostart option */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_AUTOSTART) && + !((MATCH(VIR_CONNECT_LIST_DOMAINS_AUTOSTART) && vm->autostart) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART) && !vm->autostart))) + goto cleanup; + + /* filter by snapshot existence */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_SNAPSHOT)) { + int nsnap = virDomainSnapshotObjListNum(&vm->snapshots, 0); + if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT) && nsnap > 0) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) && nsnap <= 0))) + goto cleanup; + } + + /* just count the machines */ + if (!data->domains) { + data->ndomains++; + return; + } + + if (!(dom = virGetDomain(data->conn, vm->def->name, vm->def->uuid))) + goto no_memory; + + dom->id = vm->def->id; + + data->domains[data->ndomains++] = dom; + +cleanup: + virDomainObjUnlock(vm); + return; + +no_memory: + virReportOOMError(); + data->error = true; + goto cleanup; +} +#undef MATCH + +int +virDomainList(virConnectPtr conn, + virHashTablePtr domobjs, + virDomainPtr **domains, + unsigned int flags) +{ + int ret = -1; + int i; + + struct virDomainListData data = { conn, NULL, flags, 0, false }; + + if (domains) { + if (VIR_ALLOC_N(data.domains, virHashSize(domobjs) + 1) < 0) { + virReportOOMError(); + goto cleanup; + } + } + + virHashForEach(domobjs, virDomainListPopulate, &data); + + if (data.error) + goto cleanup; + + if (data.domains) { + /* trim the array to the final size */ + ignore_value(VIR_REALLOC_N(data.domains, data.ndomains + 1)); + *domains = data.domains; + data.domains = NULL; + } + + ret = data.ndomains; + +cleanup: + if (data.domains) { + int count = virHashSize(domobjs); + for (i = 0; i < count; i++) { + if (data.domains[i]) + virDomainFree(data.domains[i]); + } + } + + VIR_FREE(data.domains); + return ret; +} diff --git a/src/conf/virdomainlist.h b/src/conf/virdomainlist.h new file mode 100644 index 0000000..caee592 --- /dev/null +++ b/src/conf/virdomainlist.h @@ -0,0 +1,66 @@ +/** + * virdomainlist.h: Helpers for listing and filtering domains. + * + * Copyright (C) 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Peter Krempa <pkrempa@redhat.com> + */ +#ifndef __VIR_DOMAIN_LIST_H__ +# define __VIR_DOMAIN_LIST_H__ + +# include "internal.h" +# include "virhash.h" +# include "domain_conf.h" + +# define VIR_CONNECT_LIST_FILTERS_ACTIVE \ + (VIR_CONNECT_LIST_DOMAINS_ACTIVE | \ + VIR_CONNECT_LIST_DOMAINS_INACTIVE) + +# define VIR_CONNECT_LIST_FILTERS_PERSISTENT \ + (VIR_CONNECT_LIST_DOMAINS_PERSISTENT | \ + VIR_CONNECT_LIST_DOMAINS_TRANSIENT) + +# define VIR_CONNECT_LIST_FILTERS_STATE \ + (VIR_CONNECT_LIST_DOMAINS_RUNNING | \ + VIR_CONNECT_LIST_DOMAINS_PAUSED | \ + VIR_CONNECT_LIST_DOMAINS_SHUTOFF | \ + VIR_CONNECT_LIST_DOMAINS_OTHER) + +# define VIR_CONNECT_LIST_FILTERS_MANAGEDSAVE \ + (VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE | \ + VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE) + +# define VIR_CONNECT_LIST_FILTERS_AUTOSTART \ + (VIR_CONNECT_LIST_DOMAINS_AUTOSTART | \ + VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART) + +# define VIR_CONNECT_LIST_FILTERS_SNAPSHOT \ + (VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT | \ + VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) + +# define VIR_CONNECT_LIST_FILTERS_ALL \ + (VIR_CONNECT_LIST_FILTERS_ACTIVE | \ + VIR_CONNECT_LIST_FILTERS_PERSISTENT | \ + VIR_CONNECT_LIST_FILTERS_STATE | \ + VIR_CONNECT_LIST_FILTERS_MANAGEDSAVE | \ + VIR_CONNECT_LIST_FILTERS_AUTOSTART | \ + VIR_CONNECT_LIST_FILTERS_SNAPSHOT) + +int virDomainList(virConnectPtr conn, virHashTablePtr domobjs, + virDomainPtr **domains, unsigned int flags); + +#endif /* __VIR_DOMAIN_LIST_H__ */ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index fdf2186..2e963f8 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -1237,6 +1237,10 @@ virConsoleOpen; virDBusGetSystemBus; +# virdomainlist.h +virDomainList; + + # virfile.h virFileClose; virFileDirectFdFlag; -- 1.7.3.4

VirtualBox doesn't use the common virDomainObj implementation so this patch adds a separate implementation using the VirtualBox API. This driver implementation supports all currently defined flags. As VirtualBox does not support transient guests, managed save images and autostarting we assume all guests are persistent, don't have a managed save image and are not autostarted. Filtering for existence of those properities results in empty list. --- Diff to v2: -added support for all filter flags -changed allocation of domains array --- src/vbox/vbox_tmpl.c | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 170 insertions(+), 0 deletions(-) diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 4b0ee2e..bc3c4f8 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -57,6 +57,7 @@ #include "virfile.h" #include "fdstream.h" #include "viruri.h" +#include "virdomainlist.h" /* This one changes from version to version. */ #if VBOX_API_VERSION == 2002 @@ -9097,6 +9098,174 @@ endjob: } #endif /* VBOX_API_VERSION >= 4000 */ + +#define MATCH(FLAG) (flags & (FLAG)) +static int +vboxListAllDomains(virConnectPtr conn, + virDomainPtr **domains, + unsigned int flags) +{ + VBOX_OBJECT_CHECK(conn, int, -1); + vboxArray machines = VBOX_ARRAY_INITIALIZER; + char *machineNameUtf8 = NULL; + PRUnichar *machineNameUtf16 = NULL; + unsigned char uuid[VIR_UUID_BUFLEN]; + vboxIID iid = VBOX_IID_INITIALIZER; + PRUint32 state; + nsresult rc; + int i; + virDomainPtr dom; + virDomainPtr *doms = NULL; + int count = 0; + bool active; + PRUint32 snapshotCount; + + virCheckFlags(VIR_CONNECT_LIST_FILTERS_ALL, -1); + + /* filter out flag options that will produce 0 results in vbox driver: + * - managed save: vbox guests don't have managed save images + * - autostart: vbox doesn't support autostarting guests + * - persistance: vbox doesn't support transient guests + */ + if ((MATCH(VIR_CONNECT_LIST_DOMAINS_TRANSIENT) && + !MATCH(VIR_CONNECT_LIST_DOMAINS_PERSISTENT)) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_AUTOSTART) && + !MATCH(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART)) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE) && + !MATCH(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE))) { + if (domains && + VIR_ALLOC_N(*domains, 1) < 0) + goto no_memory; + + ret = 0; + goto cleanup; + } + + rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines); + if (NS_FAILED(rc)) { + vboxError(VIR_ERR_INTERNAL_ERROR, + _("Could not get list of domains, rc=%08x"), (unsigned)rc); + goto cleanup; + } + + if (domains && + VIR_ALLOC_N(doms, machines.count+1) < 0) + goto no_memory; + + for (i = 0; i < machines.count; i++) { + IMachine *machine = machines.items[i]; + + if (machine) { + PRBool isAccessible = PR_FALSE; + machine->vtbl->GetAccessible(machine, &isAccessible); + if (isAccessible) { + machine->vtbl->GetState(machine, &state); + + if (state >= MachineState_FirstOnline && + state <= MachineState_LastOnline) + active = true; + else + active = false; + + /* filter by active state */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_ACTIVE) && + !((MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE) && active) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE) && !active))) + continue; + + /* filter by snapshot existence */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_SNAPSHOT)) { + rc = machine->vtbl->GetSnapshotCount(machine, &snapshotCount); + if (NS_FAILED(rc)) { + vboxError(VIR_ERR_INTERNAL_ERROR, + _("could not get snapshot count for listed domains")); + goto cleanup; + } + if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT) && + snapshotCount > 0) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) && + snapshotCount == 0))) + continue; + } + + /* filter by machine state */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_STATE) && + !((MATCH(VIR_CONNECT_LIST_DOMAINS_RUNNING) && + state == MachineState_Running) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_PAUSED) && + state == MachineState_Paused) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_SHUTOFF) && + state == MachineState_PoweredOff) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_OTHER) && + (state != MachineState_Running && + state != MachineState_Paused && + state != MachineState_PoweredOff)))) + continue; + + /* just count the machines */ + if (!doms) { + count++; + continue; + } + + machine->vtbl->GetName(machine, &machineNameUtf16); + VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineNameUtf8); + machine->vtbl->GetId(machine, &iid.value); + vboxIIDToUUID(&iid, uuid); + vboxIIDUnalloc(&iid); + + dom = virGetDomain(conn, machineNameUtf8, uuid); + + if (machineNameUtf8) { + VBOX_UTF8_FREE(machineNameUtf8); + machineNameUtf8 = NULL; + } + + if (machineNameUtf16) { + VBOX_COM_UNALLOC_MEM(machineNameUtf16); + machineNameUtf16 = NULL; + } + + if (!dom) + goto no_memory; + + if (active) + dom->id = i + 1; + + doms[count++] = dom; + } + } + } + + if (doms) { + /* safe to ignore, new size will be less or equal than + * previous allocation*/ + ignore_value(VIR_REALLOC_N(doms, count+1)); + *domains = doms; + } + doms = NULL; + ret = count; + +cleanup: + if (doms) { + for (i = 0; i < count; i++) { + if (doms[i]) + virDomainFree(doms[i]); + } + } + VIR_FREE(doms); + + vboxArrayRelease(&machines); + return ret; + +no_memory: + virReportOOMError(); + goto cleanup; +} +#undef MATCH + + + /** * Function Tables */ @@ -9113,6 +9282,7 @@ virDriver NAME(Driver) = { .getCapabilities = vboxGetCapabilities, /* 0.6.3 */ .listDomains = vboxListDomains, /* 0.6.3 */ .numOfDomains = vboxNumOfDomains, /* 0.6.3 */ + .listAllDomains = vboxListAllDomains, /* 0.9.13 */ .domainCreateXML = vboxDomainCreateXML, /* 0.6.3 */ .domainLookupByID = vboxDomainLookupByID, /* 0.6.3 */ .domainLookupByUUID = vboxDomainLookupByUUID, /* 0.6.3 */ -- 1.7.3.4

Esx doesn't use the common virDomainObj implementation so this patch adds a separate implementation. This driver supports all currently defined filtering flags, but as with other drivers some combinations yield a empty result list. --- Diff to v2: -added support for all filtering flags WARNING!! Just compile-tested!! --- src/esx/esx_driver.c | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 194 insertions(+), 0 deletions(-) diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index b3f1948..09f09cc 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -45,6 +45,7 @@ #include "esx_vi_methods.h" #include "esx_util.h" #include "viruri.h" +#include "virdomainlist.h" #define VIR_FROM_THIS VIR_FROM_ESX @@ -4947,6 +4948,198 @@ esxDomainGetMemoryParameters(virDomainPtr domain, virTypedParameterPtr params, return result; } +#define MATCH(FLAG) (flags & (FLAG)) +static int +esxListAllDomains(virConnectPtr conn, + virDomainPtr **domains, + unsigned int flags) +{ + int ret = -1; + esxPrivate *priv = conn->privateData; + virDomainPtr dom; + virDomainPtr *doms = NULL; + size_t ndoms = 0; + esxVI_ObjectContent *virtualMachineList = NULL; + esxVI_ObjectContent *virtualMachine = NULL; + esxVI_String *propertyNameList = NULL; + esxVI_AutoStartDefaults *autostart_defaults = NULL; + esxVI_VirtualMachinePowerState powerState; + esxVI_AutoStartPowerInfo *powerInfoList = NULL; + esxVI_AutoStartPowerInfo *powerInfo = NULL; + esxVI_VirtualMachineSnapshotTree *rootSnapshotTreeList = NULL; + char *name = NULL; + int id; + unsigned char uuid[VIR_UUID_BUFLEN]; + int count = 0; + int snapshotCount; + bool autostart; + int state; + + virCheckFlags(VIR_CONNECT_LIST_FILTERS_ALL, -1); + + /* check for flags that would produce empty output lists: + * - persistence: all esx machines are persistent + * - managed save: esx doesn't support managed save + */ + if ((MATCH(VIR_CONNECT_LIST_DOMAINS_TRANSIENT) && + !MATCH(VIR_CONNECT_LIST_DOMAINS_PERSISTENT)) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE) && + !MATCH(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE))) { + if (domains && + VIR_ALLOC_N(*domains, 1) < 0) + goto no_memory; + + ret = 0; + goto cleanup; + } + + if (esxVI_EnsureSession(priv->primary) < 0) + return -1; + + /* check system default autostart value */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_AUTOSTART)) { + if (esxVI_LookupAutoStartDefaults(priv->primary, + &autostart_defaults) < 0) + goto cleanup; + + if (esxVI_LookupAutoStartPowerInfoList(priv->primary, + &powerInfoList) < 0) + goto cleanup; + } + + if (esxVI_String_AppendValueToList(&propertyNameList, + "runtime.powerState") < 0 || + esxVI_LookupVirtualMachineList(priv->primary, propertyNameList, + &virtualMachineList) < 0) + goto cleanup; + + if (domains) { + if (VIR_ALLOC_N(doms, 1) < 0) + goto no_memory; + ndoms = 1; + } + + for (virtualMachine = virtualMachineList; virtualMachine != NULL; + virtualMachine = virtualMachine->_next) { + + VIR_FREE(name); + + if (esxVI_GetVirtualMachineIdentity(virtualMachine, &id, &name, uuid) < 0 || + esxVI_GetVirtualMachinePowerState(virtualMachine, &powerState) < 0) + goto cleanup; + + /* filter by active state */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_ACTIVE) && + !((MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE) && + powerState != esxVI_VirtualMachinePowerState_PoweredOff) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE) && + powerState == esxVI_VirtualMachinePowerState_PoweredOff))) + continue; + + /* filter by snapshot existence */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_SNAPSHOT)) { + if (esxVI_LookupRootSnapshotTreeList(priv->primary, uuid, + &rootSnapshotTreeList) < 0) { + ESX_ERROR(VIR_ERR_INTERNAL_ERROR, + _("Could not retrieve snapshot list for domain")); + goto cleanup; + } + + snapshotCount = esxVI_GetNumberOfSnapshotTrees(rootSnapshotTreeList, + true, false); + + esxVI_VirtualMachineSnapshotTree_Free(&rootSnapshotTreeList); + + if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT) && + snapshotCount > 0) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) && + snapshotCount == 0))) + continue; + } + + /* filter by autostart */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_AUTOSTART)) { + autostart = false; + + for (powerInfo = powerInfoList; powerInfo != NULL; + powerInfo = powerInfo->_next) { + if (STREQ(powerInfo->key->value, virtualMachine->obj->value)) { + if (STRCASEEQ(powerInfo->startAction, "powerOn")) + autostart = true; + + break; + } + } + + autostart = autostart && + autostart_defaults->enabled == esxVI_Boolean_True; + + if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_AUTOSTART) && + autostart) || + (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART) && + !autostart))) + goto cleanup; + } + + /* filter by domain state */ + if (MATCH(VIR_CONNECT_LIST_FILTERS_STATE)) { + state = esxVI_VirtualMachinePowerState_ConvertToLibvirt(powerState); + 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 cleanup; + } + + /* just count the machines */ + if (!doms) { + count++; + continue; + } + + if (!(dom = virGetDomain(conn, name, uuid))) + goto no_memory; + + /* Only running/suspended virtual machines have an ID != -1 */ + if (powerState != esxVI_VirtualMachinePowerState_PoweredOff) + dom->id = id; + else + dom->id = -1; + + if (VIR_EXPAND_N(doms, ndoms, 1) < 0) + goto no_memory; + doms[count++] = dom; + } + + if (doms) + *domains = doms; + doms = NULL; + ret = count; + +cleanup: + if (doms) { + for (id = 0; id < count; id++) { + if (doms[id]) + virDomainFree(doms[id]); + } + } + VIR_FREE(doms); + VIR_FREE(name); + esxVI_String_Free(&propertyNameList); + esxVI_ObjectContent_Free(&virtualMachineList); + return ret; + +no_memory: + virReportOOMError(); + goto cleanup; +} +#undef MATCH static virDriver esxDriver = { @@ -4962,6 +5155,7 @@ static virDriver esxDriver = { .getCapabilities = esxGetCapabilities, /* 0.7.1 */ .listDomains = esxListDomains, /* 0.7.0 */ .numOfDomains = esxNumberOfDomains, /* 0.7.0 */ + .listAllDomains = esxListAllDomains, /* 0.9.13 */ .domainLookupByID = esxDomainLookupByID, /* 0.7.0 */ .domainLookupByUUID = esxDomainLookupByUUID, /* 0.7.0 */ .domainLookupByName = esxDomainLookupByName, /* 0.7.0 */ -- 1.7.3.4

The ignore_value macro is used across libvirt. This patch includes it in the internal header and cleans all other includes. --- New in series, optional. --- src/conf/domain_audit.c | 1 - src/conf/domain_conf.c | 1 - src/conf/virdomainlist.c | 1 - src/internal.h | 1 + src/network/bridge_driver.c | 1 - src/node_device/node_device_hal.c | 1 - src/openvz/openvz_conf.c | 1 - src/qemu/qemu_domain.c | 1 - src/qemu/qemu_monitor_json.c | 1 - src/util/command.c | 1 - src/util/event_poll.c | 1 - src/util/logging.c | 1 - src/util/memory.c | 1 - src/util/threadpool.c | 1 - src/util/virfile.h | 1 - src/util/virnetdevbandwidth.c | 1 - src/xenapi/xenapi_driver.c | 1 - tests/shunloadtest.c | 1 - 18 files changed, 1 insertions(+), 17 deletions(-) diff --git a/src/conf/domain_audit.c b/src/conf/domain_audit.c index 653657b..e3f3681 100644 --- a/src/conf/domain_audit.c +++ b/src/conf/domain_audit.c @@ -31,7 +31,6 @@ #include "uuid.h" #include "logging.h" #include "memory.h" -#include "ignore-value.h" /* Return nn:mm in hex for block and character devices, and NULL * for other file types, stat failure, or allocation failure. */ diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 221e1d0..ada517b 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -44,7 +44,6 @@ #include "c-ctype.h" #include "logging.h" #include "nwfilter_conf.h" -#include "ignore-value.h" #include "storage_file.h" #include "virfile.h" #include "bitmap.h" diff --git a/src/conf/virdomainlist.c b/src/conf/virdomainlist.c index 8889fee..5a399fd 100644 --- a/src/conf/virdomainlist.c +++ b/src/conf/virdomainlist.c @@ -30,7 +30,6 @@ #include "memory.h" #include "datatypes.h" #include "virterror_internal.h" -#include "ignore-value.h" #define VIR_FROM_THIS VIR_FROM_DOMAIN diff --git a/src/internal.h b/src/internal.h index 1b1598b..856b1ee 100644 --- a/src/internal.h +++ b/src/internal.h @@ -45,6 +45,7 @@ # include "libvirt_internal.h" # include "c-strcase.h" +# include "ignore-value.h" /* On architectures which lack these limits, define them (ie. Cygwin). * Note that the libvirt code should be robust enough to handle the diff --git a/src/network/bridge_driver.c b/src/network/bridge_driver.c index 5f3132c..bebb255 100644 --- a/src/network/bridge_driver.c +++ b/src/network/bridge_driver.c @@ -58,7 +58,6 @@ #include "logging.h" #include "dnsmasq.h" #include "configmake.h" -#include "ignore-value.h" #include "virnetdev.h" #include "virnetdevbridge.h" #include "virnetdevtap.h" diff --git a/src/node_device/node_device_hal.c b/src/node_device/node_device_hal.c index b2e502e..7f8b076 100644 --- a/src/node_device/node_device_hal.c +++ b/src/node_device/node_device_hal.c @@ -38,7 +38,6 @@ #include "pci.h" #include "logging.h" #include "node_device_driver.h" -#include "ignore-value.h" #include "virdbus.h" #define VIR_FROM_THIS VIR_FROM_NODEDEV diff --git a/src/openvz/openvz_conf.c b/src/openvz/openvz_conf.c index 72cd1e6..31556be 100644 --- a/src/openvz/openvz_conf.c +++ b/src/openvz/openvz_conf.c @@ -53,7 +53,6 @@ #include "nodeinfo.h" #include "virfile.h" #include "command.h" -#include "ignore-value.h" #define VIR_FROM_THIS VIR_FROM_OPENVZ diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index 3752ddf..d0a65fd 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -32,7 +32,6 @@ #include "virterror_internal.h" #include "c-ctype.h" #include "cpu/cpu.h" -#include "ignore-value.h" #include "uuid.h" #include "virfile.h" #include "domain_event.h" diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 9030347..6ea61cd 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -41,7 +41,6 @@ #include "datatypes.h" #include "virterror_internal.h" #include "json.h" -#include "ignore-value.h" #ifdef WITH_DTRACE_PROBES # include "libvirt_qemu_probes.h" diff --git a/src/util/command.c b/src/util/command.c index 62848cd..5838d45 100644 --- a/src/util/command.c +++ b/src/util/command.c @@ -41,7 +41,6 @@ #include "virfile.h" #include "virpidfile.h" #include "buf.h" -#include "ignore-value.h" #define VIR_FROM_THIS VIR_FROM_NONE diff --git a/src/util/event_poll.c b/src/util/event_poll.c index 038e75f..3841673 100644 --- a/src/util/event_poll.c +++ b/src/util/event_poll.c @@ -37,7 +37,6 @@ #include "memory.h" #include "util.h" #include "virfile.h" -#include "ignore-value.h" #include "virterror_internal.h" #include "virtime.h" diff --git a/src/util/logging.c b/src/util/logging.c index cf62184..f8233cd 100644 --- a/src/util/logging.c +++ b/src/util/logging.c @@ -38,7 +38,6 @@ # include <execinfo.h> #endif -#include "ignore-value.h" #include "virterror_internal.h" #include "logging.h" #include "memory.h" diff --git a/src/util/memory.c b/src/util/memory.c index bfa32a8..90ca29a 100644 --- a/src/util/memory.c +++ b/src/util/memory.c @@ -24,7 +24,6 @@ #include <stdlib.h> #include "memory.h" -#include "ignore-value.h" #if TEST_OOM diff --git a/src/util/threadpool.c b/src/util/threadpool.c index e8689d9..305a22f 100644 --- a/src/util/threadpool.c +++ b/src/util/threadpool.c @@ -29,7 +29,6 @@ #include "memory.h" #include "threads.h" #include "virterror_internal.h" -#include "ignore-value.h" #define VIR_FROM_THIS VIR_FROM_NONE diff --git a/src/util/virfile.h b/src/util/virfile.h index 6882a73..fb8109b 100644 --- a/src/util/virfile.h +++ b/src/util/virfile.h @@ -29,7 +29,6 @@ # include <stdio.h> # include "internal.h" -# include "ignore-value.h" typedef enum virFileCloseFlags { VIR_FILE_CLOSE_PRESERVE_ERRNO = 1 << 0, diff --git a/src/util/virnetdevbandwidth.c b/src/util/virnetdevbandwidth.c index b9bd2e3..596ffd6 100644 --- a/src/util/virnetdevbandwidth.c +++ b/src/util/virnetdevbandwidth.c @@ -26,7 +26,6 @@ #include "command.h" #include "memory.h" #include "virterror_internal.h" -#include "ignore-value.h" #define VIR_FROM_THIS VIR_FROM_NONE diff --git a/src/xenapi/xenapi_driver.c b/src/xenapi/xenapi_driver.c index 0ad6aff..298ab21 100644 --- a/src/xenapi/xenapi_driver.c +++ b/src/xenapi/xenapi_driver.c @@ -40,7 +40,6 @@ #include "xenapi_driver.h" #include "xenapi_driver_private.h" #include "xenapi_utils.h" -#include "ignore-value.h" #define VIR_FROM_THIS VIR_FROM_XENAPI diff --git a/tests/shunloadtest.c b/tests/shunloadtest.c index 8113ef3..45ef0a1 100644 --- a/tests/shunloadtest.c +++ b/tests/shunloadtest.c @@ -50,7 +50,6 @@ # include <signal.h> # include "internal.h" -# include "ignore-value.h" # include "testutils.h" pthread_cond_t cond = PTHREAD_COND_INITIALIZER; -- 1.7.3.4