[libvirt] [PATCH 14/16] snapshot: Move snapshot list code into generic file

Finish the code motion of generic moment list handling. Well, mostly - we need to convert to using virObject to get polymorphic cleanup functions (so for now there are still a few lingering ties specific to snapshots). In this case, I kept virDomainSnapshotObjList as a wrapper type around the new generic virDomainMomentObjList; the bulk of the algorithms move, but the old functions remain and forward to the generic helpers. Signed-off-by: Eric Blake <eblake(a)redhat.com&gt; --- src/conf/virconftypes.h | 3 + src/conf/virdomainmomentobjlist.h | 32 +++ src/conf/virdomainsnapshotobjlist.h | 6 - src/conf/virdomainmomentobjlist.c | 356 ++++++++++++++++++++++++++++ src/conf/virdomainsnapshotobjlist.c | 266 +++------------------ 5 files changed, 422 insertions(+), 241 deletions(-) diff --git a/src/conf/virconftypes.h b/src/conf/virconftypes.h index 574815cf04..6a8267c422 100644 --- a/src/conf/virconftypes.h +++ b/src/conf/virconftypes.h @@ -223,6 +223,9 @@ typedef virDomainMomentDef *virDomainMomentDefPtr; typedef struct _virDomainMomentObj virDomainMomentObj; typedef virDomainMomentObj *virDomainMomentObjPtr; +typedef struct _virDomainMomentObjList virDomainMomentObjList; +typedef virDomainMomentObjList *virDomainMomentObjListPtr; + typedef struct _virDomainNVRAMDef virDomainNVRAMDef; typedef virDomainNVRAMDef *virDomainNVRAMDefPtr; diff --git a/src/conf/virdomainmomentobjlist.h b/src/conf/virdomainmomentobjlist.h index dceb55fca2..4d765c552f 100644 --- a/src/conf/virdomainmomentobjlist.h +++ b/src/conf/virdomainmomentobjlist.h @@ -27,6 +27,10 @@ # include "virconftypes.h" # include "virhash.h" +/* Filter that returns true if a given moment matches the filter flags */ +typedef bool (*virDomainMomentObjListFilter)(virDomainMomentObjPtr obj, + unsigned int flags); + /* Struct that allows tracing hierarchical relationships between * multiple virDomainMoment objects. The opaque type * virDomainMomentObjList then maintains both a hash of these structs @@ -60,4 +64,32 @@ void virDomainMomentMoveChildren(virDomainMomentObjPtr from, void virDomainMomentSetParent(virDomainMomentObjPtr moment, virDomainMomentObjPtr parent); +virDomainMomentObjListPtr virDomainMomentObjListNew(virDomainMomentObjListFilter filter); +void virDomainMomentObjListFree(virDomainMomentObjListPtr moments); + +virDomainMomentObjPtr virDomainMomentAssignDef(virDomainMomentObjListPtr moments, + virDomainMomentDefPtr def); + +int virDomainMomentObjListGetNames(virDomainMomentObjListPtr moments, + virDomainMomentObjPtr from, + char **const names, + int maxnames, + unsigned int flags); +virDomainMomentObjPtr virDomainMomentFindByName(virDomainMomentObjListPtr moments, + const char *name); +int virDomainMomentObjListSize(virDomainMomentObjListPtr moments); +virDomainMomentObjPtr virDomainMomentGetCurrent(virDomainMomentObjListPtr moments); +const char *virDomainMomentGetCurrentName(virDomainMomentObjListPtr moments); +bool virDomainMomentIsCurrentName(virDomainMomentObjListPtr moments, + const char *name); +void virDomainMomentSetCurrent(virDomainMomentObjListPtr moments, + virDomainMomentObjPtr moment); +bool virDomainMomentObjListRemove(virDomainMomentObjListPtr moments, + virDomainMomentObjPtr moment); +void virDomainMomentObjListRemoveAll(virDomainMomentObjListPtr moments); +int virDomainMomentForEach(virDomainMomentObjListPtr moments, + virHashIterator iter, + void *data); +int virDomainMomentUpdateRelations(virDomainMomentObjListPtr moments); + #endif /* LIBVIRT_VIRDOMAINMOMENTOBJLIST_H */ diff --git a/src/conf/virdomainsnapshotobjlist.h b/src/conf/virdomainsnapshotobjlist.h index c36b498751..9daecacfdc 100644 --- a/src/conf/virdomainsnapshotobjlist.h +++ b/src/conf/virdomainsnapshotobjlist.h @@ -27,10 +27,6 @@ # include "virdomainmomentobjlist.h" # include "virbuffer.h" -/* Filter that returns true if a given moment matches the filter flags */ -typedef bool (*virDomainMomentObjListFilter)(virDomainMomentObjPtr obj, - unsigned int flags); - virDomainSnapshotObjListPtr virDomainSnapshotObjListNew(void); void virDomainSnapshotObjListFree(virDomainSnapshotObjListPtr snapshots); @@ -59,7 +55,6 @@ int virDomainSnapshotObjListNum(virDomainSnapshotObjListPtr snapshots, unsigned int flags); virDomainMomentObjPtr virDomainSnapshotFindByName(virDomainSnapshotObjListPtr snapshots, const char *name); -int virDomainSnapshotObjListSize(virDomainSnapshotObjListPtr snapshots); virDomainMomentObjPtr virDomainSnapshotGetCurrent(virDomainSnapshotObjListPtr snapshots); const char *virDomainSnapshotGetCurrentName(virDomainSnapshotObjListPtr snapshots); bool virDomainSnapshotIsCurrentName(virDomainSnapshotObjListPtr snapshots, @@ -68,7 +63,6 @@ void virDomainSnapshotSetCurrent(virDomainSnapshotObjListPtr snapshots, virDomainMomentObjPtr snapshot); bool virDomainSnapshotObjListRemove(virDomainSnapshotObjListPtr snapshots, virDomainMomentObjPtr snapshot); -void virDomainSnapshotObjListRemoveAll(virDomainSnapshotObjListPtr snapshots); int virDomainSnapshotForEach(virDomainSnapshotObjListPtr snapshots, virHashIterator iter, void *data); diff --git a/src/conf/virdomainmomentobjlist.c b/src/conf/virdomainmomentobjlist.c index 766d7fe2e4..f987329a6b 100644 --- a/src/conf/virdomainmomentobjlist.c +++ b/src/conf/virdomainmomentobjlist.c @@ -29,10 +29,27 @@ #include "virstring.h" #include "moment_conf.h" +/* FIXME: using virObject would allow us to not need this */ +#include "snapshot_conf.h" +#include "virdomainsnapshotobjlist.h" + #define VIR_FROM_THIS VIR_FROM_DOMAIN VIR_LOG_INIT("conf.virdomainmomentobjlist"); +/* Opaque struct */ +struct _virDomainMomentObjList { + /* name string -> virDomainMomentObj mapping + * for O(1), lockless lookup-by-name */ + virHashTable *objs; + + virDomainMomentObj metaroot; /* Special parent of all root snapshots */ + virDomainMomentObjPtr current; /* The current snapshot, if any */ + + virDomainMomentObjListFilter filter; +}; + + /* Run iter(data) on all direct children of moment, while ignoring all * other entries in moments. Return the number of children * visited. No particular ordering is guaranteed. */ @@ -163,3 +180,342 @@ virDomainMomentMoveChildren(virDomainMomentObjPtr from, from->nchildren = 0; from->first_child = NULL; } + + +static virDomainMomentObjPtr +virDomainMomentObjNew(void) +{ + virDomainMomentObjPtr snapshot; + + if (VIR_ALLOC(snapshot) < 0) + return NULL; + + VIR_DEBUG("obj=%p", snapshot); + + return snapshot; +} + +static void +virDomainMomentObjFree(virDomainMomentObjPtr snapshot) +{ + if (!snapshot) + return; + + VIR_DEBUG("obj=%p", snapshot); + + /* FIXME: Make this polymorphic by inheriting from virObject */ + virDomainSnapshotDefFree(virDomainSnapshotObjGetDef(snapshot)); + VIR_FREE(snapshot); +} + + +/* Add def to the list and return a matching object, or NULL on error */ +virDomainMomentObjPtr +virDomainMomentAssignDef(virDomainMomentObjListPtr moments, + virDomainMomentDefPtr def) +{ + virDomainMomentObjPtr moment; + + if (virHashLookup(moments->objs, def->name) != NULL) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("unexpected domain moment %s already exists"), + def->name); + return NULL; + } + + if (!(moment = virDomainMomentObjNew())) + return NULL; + moment->def = def; + + if (virHashAddEntry(moments->objs, moment->def->name, moment) < 0) { + VIR_FREE(moment); + return NULL; + } + + return moment; +} + + +static void +virDomainMomentObjListDataFree(void *payload, + const void *name ATTRIBUTE_UNUSED) +{ + virDomainMomentObjPtr obj = payload; + + virDomainMomentObjFree(obj); +} + + +virDomainMomentObjListPtr +virDomainMomentObjListNew(virDomainMomentObjListFilter filter) +{ + virDomainMomentObjListPtr moments; + + if (VIR_ALLOC(moments) < 0) + return NULL; + moments->objs = virHashCreate(50, virDomainMomentObjListDataFree); + if (!moments->objs) { + VIR_FREE(moments); + return NULL; + } + moments->filter = filter; + return moments; +} + +void +virDomainMomentObjListFree(virDomainMomentObjListPtr moments) +{ + if (!moments) + return; + virHashFree(moments->objs); + VIR_FREE(moments); +} + + +/* Struct and callback for collecting a list of names of moments that + * meet a particular filter. */ +struct virDomainMomentNameData { + char **const names; + int maxnames; + unsigned int flags; + int count; + bool error; + virDomainMomentObjListFilter filter; +}; + +static int virDomainMomentObjListCopyNames(void *payload, + const void *name ATTRIBUTE_UNUSED, + void *opaque) +{ + virDomainMomentObjPtr obj = payload; + struct virDomainMomentNameData *data = opaque; + + if (data->error) + return 0; + /* Caller already sanitized flags. Filtering on DESCENDANTS was + * done by choice of iteration in the caller. */ + if ((data->flags & VIR_DOMAIN_SNAPSHOT_LIST_LEAVES) && obj->nchildren) + return 0; + if ((data->flags & VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES) && !obj->nchildren) + return 0; + + if (!data->filter(obj, data->flags)) + return 0; + + if (data->names && data->count < data->maxnames && + VIR_STRDUP(data->names[data->count], obj->def->name) < 0) { + data->error = true; + return 0; + } + data->count++; + return 0; +} + + +int +virDomainMomentObjListGetNames(virDomainMomentObjListPtr moments, + virDomainMomentObjPtr from, + char **const names, + int maxnames, + unsigned int flags) +{ + struct virDomainMomentNameData data = { names, maxnames, flags, 0, + false, moments->filter }; + size_t i; + + if (!from) { + /* LIST_ROOTS and LIST_DESCENDANTS have the same bit value, + * but opposite semantics. Toggle here to get the correct + * traversal on the metaroot. */ + flags ^= VIR_DOMAIN_SNAPSHOT_LIST_ROOTS; + from = &moments->metaroot; + } + + /* We handle LIST_ROOT/LIST_DESCENDANTS and LIST_TOPOLOGICAL directly, + * mask those bits out to determine when we must use the filter callback. */ + data.flags &= ~(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS | + VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL); + + /* If this common code is being used, we assume that all snapshots + * have metadata, and thus can handle METADATA up front as an + * all-or-none filter. XXX This might not always be true, if we + * add the ability to track qcow2 internal snapshots without the + * use of metadata. */ + if ((data.flags & VIR_DOMAIN_SNAPSHOT_FILTERS_METADATA) == + VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA) + return 0; + data.flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_METADATA; + + if (flags & VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS) { + /* We could just always do a topological visit; but it is + * possible to optimize for less stack usage and time when a + * simpler full hashtable visit or counter will do. */ + if (from->def || (names && + (flags & VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL))) + virDomainMomentForEachDescendant(from, + virDomainMomentObjListCopyNames, + &data); + else if (names || data.flags) + virHashForEach(moments->objs, virDomainMomentObjListCopyNames, + &data); + else + data.count = virHashSize(moments->objs); + } else if (names || data.flags) { + virDomainMomentForEachChild(from, + virDomainMomentObjListCopyNames, &data); + } else { + data.count = from->nchildren; + } + + if (data.error) { + for (i = 0; i < data.count; i++) + VIR_FREE(names[i]); + return -1; + } + + return data.count; +} + + +virDomainMomentObjPtr +virDomainMomentFindByName(virDomainMomentObjListPtr moments, + const char *name) +{ + return name ? virHashLookup(moments->objs, name) : &moments->metaroot; +} + + +/* Return the current moment, or NULL */ +virDomainMomentObjPtr +virDomainMomentGetCurrent(virDomainMomentObjListPtr moments) +{ + return moments->current; +} + + +/* Return the current moment's name, or NULL */ +const char * +virDomainMomentGetCurrentName(virDomainMomentObjListPtr moments) +{ + if (moments->current) + return moments->current->def->name; + return NULL; +} + + +/* Return true if name matches the current moment */ +bool +virDomainMomentIsCurrentName(virDomainMomentObjListPtr moments, + const char *name) +{ + return moments->current && STREQ(moments->current->def->name, name); +} + + +/* Update the current moment, using NULL if no current remains */ +void +virDomainMomentSetCurrent(virDomainMomentObjListPtr moments, + virDomainMomentObjPtr moment) +{ + moments->current = moment; +} + + +/* Return the number of moments in the list */ +int +virDomainMomentObjListSize(virDomainMomentObjListPtr moments) +{ + return virHashSize(moments->objs); +} + + +/* Remove moment from the list; return true if it was current */ +bool +virDomainMomentObjListRemove(virDomainMomentObjListPtr moments, + virDomainMomentObjPtr moment) +{ + bool ret = moments->current == moment; + + virHashRemoveEntry(moments->objs, moment->def->name); + if (ret) + moments->current = NULL; + return ret; +} + + +/* Remove all moments tracked in the list */ +void +virDomainMomentObjListRemoveAll(virDomainMomentObjListPtr moments) +{ + virHashRemoveAll(moments->objs); + virDomainMomentDropChildren(&moments->metaroot); +} + + +/* Call iter on each member of the list, in unspecified order */ +int +virDomainMomentForEach(virDomainMomentObjListPtr moments, + virHashIterator iter, + void *data) +{ + return virHashForEach(moments->objs, iter, data); +} + + +/* Struct and callback function used as a hash table callback; each call + * inspects the pre-existing moment->def->parent field, and adjusts + * the moment->parent field as well as the parent's child fields to + * wire up the hierarchical relations for the given snapshot. The error + * indicator gets set if a parent is missing or a requested parent would + * cause a circular parent chain. */ +struct moment_set_relation { + virDomainMomentObjListPtr moments; + int err; +}; +static int +virDomainMomentSetRelations(void *payload, + const void *name ATTRIBUTE_UNUSED, + void *data) +{ + virDomainMomentObjPtr obj = payload; + struct moment_set_relation *curr = data; + virDomainMomentObjPtr tmp; + virDomainMomentObjPtr parent; + + parent = virDomainMomentFindByName(curr->moments, obj->def->parent); + if (!parent) { + curr->err = -1; + parent = &curr->moments->metaroot; + VIR_WARN("snapshot %s lacks parent", obj->def->name); + } else { + tmp = parent; + while (tmp && tmp->def) { + if (tmp == obj) { + curr->err = -1; + parent = &curr->moments->metaroot; + VIR_WARN("snapshot %s in circular chain", obj->def->name); + break; + } + tmp = tmp->parent; + } + } + virDomainMomentSetParent(obj, parent); + return 0; +} + + +/* Populate parent link and child count of all snapshots, with all + * assigned defs having relations starting as 0/NULL. Return 0 on + * success, -1 if a parent is missing or if a circular relationship + * was requested. */ +int +virDomainMomentUpdateRelations(virDomainMomentObjListPtr moments) +{ + struct moment_set_relation act = { moments, 0 }; + + virDomainMomentDropChildren(&moments->metaroot); + virHashForEach(moments->objs, virDomainMomentSetRelations, &act); + if (act.err) + moments->current = NULL; + return act.err; +} diff --git a/src/conf/virdomainsnapshotobjlist.c b/src/conf/virdomainsnapshotobjlist.c index 8ecb131176..31ed1c672d 100644 --- a/src/conf/virdomainsnapshotobjlist.c +++ b/src/conf/virdomainsnapshotobjlist.c @@ -35,12 +35,7 @@ VIR_LOG_INIT("conf.virdomainsnapshotobjlist"); struct _virDomainSnapshotObjList { - /* name string -> virDomainMomentObj mapping - * for O(1), lockless lookup-by-name */ - virHashTable *objs; - - virDomainMomentObj metaroot; /* Special parent of all root snapshots */ - virDomainMomentObjPtr current; /* The current snapshot, if any */ + virDomainMomentObjListPtr base; }; @@ -72,7 +67,7 @@ virDomainSnapshotObjListParse(const char *xmlStr, _("incorrect flags for bulk parse")); return -1; } - if (virDomainSnapshotObjListSize(snapshots)) { + if (virDomainMomentObjListSize(snapshots->base)) { virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", _("bulk define of snapshots only possible with " "no existing snapshot")); @@ -143,7 +138,7 @@ virDomainSnapshotObjListParse(const char *xmlStr, if (ret < 0) { /* There were no snapshots before this call; so on error, just * blindly delete anything created before the failure. */ - virDomainSnapshotObjListRemoveAll(snapshots); + virDomainMomentObjListRemoveAll(snapshots->base); } xmlXPathFreeContext(ctxt); xmlFreeDoc(xml); @@ -211,55 +206,14 @@ virDomainSnapshotObjListFormat(virBufferPtr buf, } -/* Snapshot Obj functions */ -static virDomainMomentObjPtr virDomainMomentObjNew(void) +virDomainMomentObjPtr +virDomainSnapshotAssignDef(virDomainSnapshotObjListPtr snapshots, + virDomainSnapshotDefPtr def) { - virDomainMomentObjPtr snapshot; - - if (VIR_ALLOC(snapshot) < 0) - return NULL; - - VIR_DEBUG("obj=%p", snapshot); - - return snapshot; -} - -static void virDomainMomentObjFree(virDomainMomentObjPtr snapshot) -{ - if (!snapshot) - return; - - VIR_DEBUG("obj=%p", snapshot); - - virDomainSnapshotDefFree(virDomainSnapshotObjGetDef(snapshot)); - VIR_FREE(snapshot); + return virDomainMomentAssignDef(snapshots->base, &def->common); } -virDomainMomentObjPtr virDomainSnapshotAssignDef(virDomainSnapshotObjListPtr snapshots, - virDomainSnapshotDefPtr def) -{ - virDomainMomentObjPtr snap; - - if (virHashLookup(snapshots->objs, def->common.name) != NULL) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("unexpected domain snapshot %s already exists"), - def->common.name); - return NULL; - } - - if (!(snap = virDomainMomentObjNew())) - return NULL; - snap->def = &def->common; - - if (virHashAddEntry(snapshots->objs, snap->def->name, snap) < 0) { - VIR_FREE(snap); - return NULL; - } - - return snap; -} -/* Snapshot Obj List functions */ static bool virDomainSnapshotFilter(virDomainMomentObjPtr obj, unsigned int flags) @@ -292,76 +246,30 @@ virDomainSnapshotFilter(virDomainMomentObjPtr obj, } -static void -virDomainSnapshotObjListDataFree(void *payload, - const void *name ATTRIBUTE_UNUSED) -{ - virDomainMomentObjPtr obj = payload; - - virDomainMomentObjFree(obj); -} - virDomainSnapshotObjListPtr virDomainSnapshotObjListNew(void) { virDomainSnapshotObjListPtr snapshots; + if (VIR_ALLOC(snapshots) < 0) return NULL; - snapshots->objs = virHashCreate(50, virDomainSnapshotObjListDataFree); - if (!snapshots->objs) { + snapshots->base = virDomainMomentObjListNew(virDomainSnapshotFilter); + if (!snapshots->base) { VIR_FREE(snapshots); return NULL; } return snapshots; } + void virDomainSnapshotObjListFree(virDomainSnapshotObjListPtr snapshots) { - if (!snapshots) - return; - virHashFree(snapshots->objs); + virDomainMomentObjListFree(snapshots->base); VIR_FREE(snapshots); } -struct virDomainMomentNameData { - char **const names; - int maxnames; - unsigned int flags; - int count; - bool error; - virDomainMomentObjListFilter filter; -}; - -static int virDomainMomentObjListCopyNames(void *payload, - const void *name ATTRIBUTE_UNUSED, - void *opaque) -{ - virDomainMomentObjPtr obj = payload; - struct virDomainMomentNameData *data = opaque; - - if (data->error) - return 0; - /* Caller already sanitized flags. Filtering on DESCENDANTS was - * done by choice of iteration in the caller. */ - if ((data->flags & VIR_DOMAIN_SNAPSHOT_LIST_LEAVES) && obj->nchildren) - return 0; - if ((data->flags & VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES) && !obj->nchildren) - return 0; - - if (data->filter(obj, data->flags)) - return 0; - - if (data->names && data->count < data->maxnames && - VIR_STRDUP(data->names[data->count], obj->def->name) < 0) { - data->error = true; - return 0; - } - data->count++; - return 0; -} - int virDomainSnapshotObjListGetNames(virDomainSnapshotObjListPtr snapshots, virDomainMomentObjPtr from, @@ -369,73 +277,29 @@ virDomainSnapshotObjListGetNames(virDomainSnapshotObjListPtr snapshots, int maxnames, unsigned int flags) { - struct virDomainMomentNameData data = { names, maxnames, flags, 0, - false, virDomainSnapshotFilter }; - size_t i; - - if (!from) { - /* LIST_ROOTS and LIST_DESCENDANTS have the same bit value, - * but opposite semantics. Toggle here to get the correct - * traversal on the metaroot. */ - flags ^= VIR_DOMAIN_SNAPSHOT_LIST_ROOTS; - from = &snapshots->metaroot; - } - - /* We handle LIST_ROOT/LIST_DESCENDANTS and LIST_TOPOLOGICAL directly, - * mask those bits out to determine when we must use the filter callback. */ - data.flags &= ~(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS | - VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL); - /* If this common code is being used, we assume that all snapshots * have metadata, and thus can handle METADATA up front as an * all-or-none filter. XXX This might not always be true, if we * add the ability to track qcow2 internal snapshots without the * use of metadata. */ - if ((data.flags & VIR_DOMAIN_SNAPSHOT_FILTERS_METADATA) == + if ((flags & VIR_DOMAIN_SNAPSHOT_FILTERS_METADATA) == VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA) return 0; - data.flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_METADATA; + flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_METADATA; /* For ease of coding the visitor, it is easier to zero each group * where all of the bits are set. */ - if ((data.flags & VIR_DOMAIN_SNAPSHOT_FILTERS_LEAVES) == + if ((flags & VIR_DOMAIN_SNAPSHOT_FILTERS_LEAVES) == VIR_DOMAIN_SNAPSHOT_FILTERS_LEAVES) - data.flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_LEAVES; - if ((data.flags & VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS) == + flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_LEAVES; + if ((flags & VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS) == VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS) - data.flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS; - if ((data.flags & VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION) == + flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS; + if ((flags & VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION) == VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION) - data.flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION; - - if (flags & VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS) { - /* We could just always do a topological visit; but it is - * possible to optimize for less stack usage and time when a - * simpler full hashtable visit or counter will do. */ - if (from->def || (names && - (flags & VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL))) - virDomainMomentForEachDescendant(from, - virDomainMomentObjListCopyNames, - &data); - else if (names || data.flags) - virHashForEach(snapshots->objs, virDomainMomentObjListCopyNames, - &data); - else - data.count = virHashSize(snapshots->objs); - } else if (names || data.flags) { - virDomainMomentForEachChild(from, - virDomainMomentObjListCopyNames, &data); - } else { - data.count = from->nchildren; - } - - if (data.error) { - for (i = 0; i < data.count; i++) - VIR_FREE(names[i]); - return -1; - } - - return data.count; + flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION; + return virDomainMomentObjListGetNames(snapshots->base, from, names, + maxnames, flags); } int @@ -446,19 +310,12 @@ virDomainSnapshotObjListNum(virDomainSnapshotObjListPtr snapshots, return virDomainSnapshotObjListGetNames(snapshots, from, NULL, 0, flags); } + virDomainMomentObjPtr virDomainSnapshotFindByName(virDomainSnapshotObjListPtr snapshots, const char *name) { - return name ? virHashLookup(snapshots->objs, name) : &snapshots->metaroot; -} - - -/* Return the number of objects currently in the list */ -int -virDomainSnapshotObjListSize(virDomainSnapshotObjListPtr snapshots) -{ - return virHashSize(snapshots->objs); + return virDomainMomentFindByName(snapshots->base, name); } @@ -466,7 +323,7 @@ virDomainSnapshotObjListSize(virDomainSnapshotObjListPtr snapshots) virDomainMomentObjPtr virDomainSnapshotGetCurrent(virDomainSnapshotObjListPtr snapshots) { - return snapshots->current; + return virDomainMomentGetCurrent(snapshots->base); } @@ -474,9 +331,7 @@ virDomainSnapshotGetCurrent(virDomainSnapshotObjListPtr snapshots) const char * virDomainSnapshotGetCurrentName(virDomainSnapshotObjListPtr snapshots) { - if (snapshots->current) - return snapshots->current->def->name; - return NULL; + return virDomainMomentGetCurrentName(snapshots->base); } @@ -485,7 +340,7 @@ bool virDomainSnapshotIsCurrentName(virDomainSnapshotObjListPtr snapshots, const char *name) { - return snapshots->current && STREQ(snapshots->current->def->name, name); + return virDomainMomentIsCurrentName(snapshots->base, name); } @@ -494,7 +349,7 @@ void virDomainSnapshotSetCurrent(virDomainSnapshotObjListPtr snapshots, virDomainMomentObjPtr snapshot) { - snapshots->current = snapshot; + virDomainMomentSetCurrent(snapshots->base, snapshot); } @@ -502,19 +357,7 @@ virDomainSnapshotSetCurrent(virDomainSnapshotObjListPtr snapshots, bool virDomainSnapshotObjListRemove(virDomainSnapshotObjListPtr snapshots, virDomainMomentObjPtr snapshot) { - bool ret = snapshots->current == snapshot; - virHashRemoveEntry(snapshots->objs, snapshot->def->name); - if (ret) - snapshots->current = NULL; - return ret; -} - -/* Remove all snapshots tracked in the list */ -void -virDomainSnapshotObjListRemoveAll(virDomainSnapshotObjListPtr snapshots) -{ - virHashRemoveAll(snapshots->objs); - virDomainMomentDropChildren(&snapshots->metaroot); + return virDomainMomentObjListRemove(snapshots->base, snapshot); } @@ -523,51 +366,10 @@ virDomainSnapshotForEach(virDomainSnapshotObjListPtr snapshots, virHashIterator iter, void *data) { - return virHashForEach(snapshots->objs, iter, data); + return virDomainMomentForEach(snapshots->base, iter, data); } -/* Struct and callback function used as a hash table callback; each call - * inspects the pre-existing snapshot->def->parent field, and adjusts - * the snapshot->parent field as well as the parent's child fields to - * wire up the hierarchical relations for the given snapshot. The error - * indicator gets set if a parent is missing or a requested parent would - * cause a circular parent chain. */ -struct moment_set_relation { - virDomainSnapshotObjListPtr snapshots; - int err; -}; -static int -virDomainMomentSetRelations(void *payload, - const void *name ATTRIBUTE_UNUSED, - void *data) -{ - virDomainMomentObjPtr obj = payload; - struct moment_set_relation *curr = data; - virDomainMomentObjPtr tmp; - virDomainMomentObjPtr parent; - - parent = virDomainSnapshotFindByName(curr->snapshots, obj->def->parent); - if (!parent) { - curr->err = -1; - parent = &curr->snapshots->metaroot; - VIR_WARN("snapshot %s lacks parent", obj->def->name); - } else { - tmp = parent; - while (tmp && tmp->def) { - if (tmp == obj) { - curr->err = -1; - parent = &curr->snapshots->metaroot; - VIR_WARN("snapshot %s in circular chain", obj->def->name); - break; - } - tmp = tmp->parent; - } - } - virDomainMomentSetParent(obj, parent); - return 0; -} - /* Populate parent link and child count of all snapshots, with all * assigned defs having relations starting as 0/NULL. Return 0 on * success, -1 if a parent is missing or if a circular relationship @@ -575,13 +377,7 @@ virDomainMomentSetRelations(void *payload, int virDomainSnapshotUpdateRelations(virDomainSnapshotObjListPtr snapshots) { - struct moment_set_relation act = { snapshots, 0 }; - - virDomainMomentDropChildren(&snapshots->metaroot); - virHashForEach(snapshots->objs, virDomainMomentSetRelations, &act); - if (act.err) - snapshots->current = NULL; - return act.err; + return virDomainMomentUpdateRelations(snapshots->base); } -- 2.20.1