External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-01-12 07:42:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

snapshot: Factor out virDomainMomentDef class

Browse Source 
Pull out the common parts of virDomainSnapshotDef that will be reused
for virDomainCheckpointDef into a new base class.  Adjust all callers
that use the direct fields (some of it is churn that disappears when
the next patch refactors virDomainSnapshotObj; oh well...).

Someday, I hope to switch this type to be a subclass of virObject, but
that requires a more thorough audit of cleanup paths, and besides
minimal incremental changes are easier to review.

As for the choice of naming:
I promised my teenage daughter Evelyn that I'd give her credit for her
contribution to this commit. I asked her "What would be a good name
for a base class for DomainSnapshot and DomainCheckpoint". After
explaining what a base class was (using the classic OOB Square and
Circle inherit from Shape), she came up with "DomainMoment", which is
way better than my initial thought of "DomainPointInTime" or
"DomainPIT".

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
This commit is contained in:
Eric Blake 2019-03-21 21:02:19 -05:00
parent de80cdbcc9
commit ffc0fbebe2
14 changed files with 272 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/conf/Makefile.inc.am
View File

@ -22,6 +22,8 @@ DOMAIN_CONF_SOURCES = \
conf/domain_nwfilter.h \ conf/domain_nwfilter.h \
conf/virsavecookie.c \ conf/virsavecookie.c \
conf/virsavecookie.h \ conf/virsavecookie.h \
conf/moment_conf.c \
conf/moment_conf.h \
conf/snapshot_conf.c \ conf/snapshot_conf.c \
conf/snapshot_conf.h \ conf/snapshot_conf.h \
conf/numa_conf.c \ conf/numa_conf.c \

40
src/conf/moment_conf.c Normal file
View File

@ -0,0 +1,40 @@
/*
* moment_conf.c: domain snapshot/checkpoint base class
*
* Copyright (C) 2006-2019 Red Hat, Inc.
* Copyright (C) 2006-2008 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include "internal.h"
#include "moment_conf.h"
#include "domain_conf.h"
#include "virlog.h"
#include "viralloc.h"
#define VIR_FROM_THIS VIR_FROM_DOMAIN
VIR_LOG_INIT("conf.moment_conf");
void virDomainMomentDefClear(virDomainMomentDefPtr def)
{
VIR_FREE(def->name);
VIR_FREE(def->description);
VIR_FREE(def->parent);
virDomainDefFree(def->dom);
}

42
src/conf/moment_conf.h Normal file
View File

@ -0,0 +1,42 @@
/*
* moment_conf.h: domain snapshot/checkpoint base class
* (derived from snapshot_conf.h)
*
* Copyright (C) 2006-2019 Red Hat, Inc.
* Copyright (C) 2006-2008 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#ifndef LIBVIRT_MOMENT_CONF_H
# define LIBVIRT_MOMENT_CONF_H
# include "internal.h"
# include "virconftypes.h"
/* Base class for a domain moment */
struct _virDomainMomentDef {
/* Common portion of public XML. */
char *name;
char *description;
char *parent;
long long creationTime; /* in seconds */
virDomainDefPtr dom;
};
void virDomainMomentDefClear(virDomainMomentDefPtr def);
#endif /* LIBVIRT_MOMENT_CONF_H */

124
src/conf/snapshot_conf.c
View File

@ -87,14 +87,11 @@ void virDomainSnapshotDefFree(virDomainSnapshotDefPtr def)
if (!def) if (!def)
return; return;
VIR_FREE(def->name); virDomainMomentDefClear(&def->common);
VIR_FREE(def->description);
VIR_FREE(def->parent);
VIR_FREE(def->file); VIR_FREE(def->file);
for (i = 0; i < def->ndisks; i++) for (i = 0; i < def->ndisks; i++)
virDomainSnapshotDiskDefClear(&def->disks[i]); virDomainSnapshotDiskDefClear(&def->disks[i]);
VIR_FREE(def->disks); VIR_FREE(def->disks);
virDomainDefFree(def->dom);
virObjectUnref(def->cookie); virObjectUnref(def->cookie);
VIR_FREE(def); VIR_FREE(def);
} }
@ -213,28 +210,28 @@ virDomainSnapshotDefParse(xmlXPathContextPtr ctxt,
gettimeofday(&tv, NULL); gettimeofday(&tv, NULL);
def->name = virXPathString("string(./name)", ctxt); def->common.name = virXPathString("string(./name)", ctxt);
if (def->name == NULL) { if (def->common.name == NULL) {
if (flags & VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE) { if (flags & VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE) {
virReportError(VIR_ERR_XML_ERROR, "%s", virReportError(VIR_ERR_XML_ERROR, "%s",
_("a redefined snapshot must have a name")); _("a redefined snapshot must have a name"));
goto cleanup; goto cleanup;
} }
if (virAsprintf(&def->name, "%lld", (long long)tv.tv_sec) < 0) if (virAsprintf(&def->common.name, "%lld", (long long)tv.tv_sec) < 0)
goto cleanup; goto cleanup;
} }
def->description = virXPathString("string(./description)", ctxt); def->common.description = virXPathString("string(./description)", ctxt);
if (flags & VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE) { if (flags & VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE) {
if (virXPathLongLong("string(./creationTime)", ctxt, if (virXPathLongLong("string(./creationTime)", ctxt,
&def->creationTime) < 0) { &def->common.creationTime) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("missing creationTime from existing snapshot")); _("missing creationTime from existing snapshot"));
goto cleanup; goto cleanup;
} }
def->parent = virXPathString("string(./parent/name)", ctxt); def->common.parent = virXPathString("string(./parent/name)", ctxt);
state = virXPathString("string(./state)", ctxt); state = virXPathString("string(./state)", ctxt);
if (state == NULL) { if (state == NULL) {
@ -270,15 +267,15 @@ virDomainSnapshotDefParse(xmlXPathContextPtr ctxt,
_("missing domain in snapshot")); _("missing domain in snapshot"));
goto cleanup; goto cleanup;
} }
def->dom = virDomainDefParseNode(ctxt->node->doc, domainNode, def->common.dom = virDomainDefParseNode(ctxt->node->doc, domainNode,
caps, xmlopt, NULL, domainflags); caps, xmlopt, NULL, domainflags);
if (!def->dom) if (!def->common.dom)
goto cleanup; goto cleanup;
} else { } else {
VIR_WARN("parsing older snapshot that lacks domain"); VIR_WARN("parsing older snapshot that lacks domain");
} }
} else { } else {
def->creationTime = tv.tv_sec; def->common.creationTime = tv.tv_sec;
} }
memorySnapshot = virXPathString("string(./memory/@snapshot)", ctxt); memorySnapshot = virXPathString("string(./memory/@snapshot)", ctxt);
@ -429,7 +426,7 @@ virDomainSnapshotDefParseString(const char *xmlStr,
/* Perform sanity checking on a redefined snapshot definition. If /* Perform sanity checking on a redefined snapshot definition. If
* @other is non-NULL, this may include swapping def->dom from other * @other is non-NULL, this may include swapping def->common.dom from other
* into def. */ * into def. */
int int
virDomainSnapshotRedefineValidate(virDomainSnapshotDefPtr def, virDomainSnapshotRedefineValidate(virDomainSnapshotDefPtr def,
@ -447,16 +444,17 @@ virDomainSnapshotRedefineValidate(virDomainSnapshotDefPtr def,
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("disk-only flag for snapshot %s requires " _("disk-only flag for snapshot %s requires "
"disk-snapshot state"), "disk-snapshot state"),
def->name); def->common.name);
return -1; return -1;
} }
if (def->dom && memcmp(def->dom->uuid, domain_uuid, VIR_UUID_BUFLEN)) { if (def->common.dom && memcmp(def->common.dom->uuid, domain_uuid,
VIR_UUID_BUFLEN)) {
char uuidstr[VIR_UUID_STRING_BUFLEN]; char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(domain_uuid, uuidstr); virUUIDFormat(domain_uuid, uuidstr);
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("definition for snapshot %s must use uuid %s"), _("definition for snapshot %s must use uuid %s"),
def->name, uuidstr); def->common.name, uuidstr);
return -1; return -1;
} }
@ -470,7 +468,7 @@ virDomainSnapshotRedefineValidate(virDomainSnapshotDefPtr def,
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("cannot change between online and offline " _("cannot change between online and offline "
"snapshot state in snapshot %s"), "snapshot state in snapshot %s"),
def->name); def->common.name);
return -1; return -1;
} }
@ -479,23 +477,23 @@ virDomainSnapshotRedefineValidate(virDomainSnapshotDefPtr def,
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("cannot change between disk only and " _("cannot change between disk only and "
"full system in snapshot %s"), "full system in snapshot %s"),
def->name); def->common.name);
return -1; return -1;
} }
if (otherdef->dom) { if (otherdef->common.dom) {
if (def->dom) { if (def->common.dom) {
if (!virDomainDefCheckABIStability(otherdef->dom, if (!virDomainDefCheckABIStability(otherdef->common.dom,
def->dom, xmlopt)) def->common.dom, xmlopt))
return -1; return -1;
} else { } else {
/* Transfer the domain def */ /* Transfer the domain def */
VIR_STEAL_PTR(def->dom, otherdef->dom); VIR_STEAL_PTR(def->common.dom, otherdef->common.dom);
} }
} }
} }
if (def->dom) { if (def->common.dom) {
if (external) { if (external) {
align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL; align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
align_match = false; align_match = false;
@ -542,7 +540,7 @@ virDomainSnapshotDefAssignExternalNames(virDomainSnapshotDefPtr def)
return -1; return -1;
} }
if (!(origpath = virDomainDiskGetSource(def->dom->disks[i]))) { if (!(origpath = virDomainDiskGetSource(def->common.dom->disks[i]))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("cannot generate external snapshot name " _("cannot generate external snapshot name "
"for disk '%s' without source"), "for disk '%s' without source"),
@ -566,7 +564,7 @@ virDomainSnapshotDefAssignExternalNames(virDomainSnapshotDefPtr def)
if ((tmp = strrchr(tmppath, '.')) && !strchr(tmp, '/')) if ((tmp = strrchr(tmppath, '.')) && !strchr(tmp, '/'))
*tmp = '\0'; *tmp = '\0';
if (virAsprintf(&disk->src->path, "%s.%s", tmppath, def->name) < 0) { if (virAsprintf(&disk->src->path, "%s.%s", tmppath, def->common.name) < 0) {
VIR_FREE(tmppath); VIR_FREE(tmppath);
return -1; return -1;
} }
@ -599,7 +597,7 @@ virDomainSnapshotCompareDiskIndex(const void *a, const void *b)
return diska->idx - diskb->idx; return diska->idx - diskb->idx;
} }
/* Align def->disks to def->domain. Sort the list of def->disks, /* Align def->disks to def->common.dom. Sort the list of def->disks,
* filling in any missing disks or snapshot state defaults given by * filling in any missing disks or snapshot state defaults given by
* the domain, with a fallback to a passed in default. Convert paths * the domain, with a fallback to a passed in default. Convert paths
* to disk targets for uniformity. Issue an error and return -1 if * to disk targets for uniformity. Issue an error and return -1 if
@ -616,31 +614,31 @@ virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr def,
size_t i; size_t i;
int ndisks; int ndisks;
if (!def->dom) { if (!def->common.dom) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("missing domain in snapshot")); _("missing domain in snapshot"));
goto cleanup; goto cleanup;
} }
if (def->ndisks > def->dom->ndisks) { if (def->ndisks > def->common.dom->ndisks) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("too many disk snapshot requests for domain")); _("too many disk snapshot requests for domain"));
goto cleanup; goto cleanup;
} }
/* Unlikely to have a guest without disks but technically possible. */ /* Unlikely to have a guest without disks but technically possible. */
if (!def->dom->ndisks) { if (!def->common.dom->ndisks) {
ret = 0; ret = 0;
goto cleanup; goto cleanup;
} }
if (!(map = virBitmapNew(def->dom->ndisks))) if (!(map = virBitmapNew(def->common.dom->ndisks)))
goto cleanup; goto cleanup;
/* Double check requested disks. */ /* Double check requested disks. */
for (i = 0; i < def->ndisks; i++) { for (i = 0; i < def->ndisks; i++) {
virDomainSnapshotDiskDefPtr disk = &def->disks[i]; virDomainSnapshotDiskDefPtr disk = &def->disks[i];
int idx = virDomainDiskIndexByName(def->dom, disk->name, false); int idx = virDomainDiskIndexByName(def->common.dom, disk->name, false);
int disk_snapshot; int disk_snapshot;
if (idx < 0) { if (idx < 0) {
@ -658,7 +656,7 @@ virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr def,
ignore_value(virBitmapSetBit(map, idx)); ignore_value(virBitmapSetBit(map, idx));
disk->idx = idx; disk->idx = idx;
disk_snapshot = def->dom->disks[idx]->snapshot; disk_snapshot = def->common.dom->disks[idx]->snapshot;
if (!disk->snapshot) { if (!disk->snapshot) {
if (disk_snapshot && if (disk_snapshot &&
(!require_match || (!require_match ||
@ -686,9 +684,9 @@ virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr def,
disk->src->path, disk->name); disk->src->path, disk->name);
goto cleanup; goto cleanup;
} }
if (STRNEQ(disk->name, def->dom->disks[idx]->dst)) { if (STRNEQ(disk->name, def->common.dom->disks[idx]->dst)) {
VIR_FREE(disk->name); VIR_FREE(disk->name);
if (VIR_STRDUP(disk->name, def->dom->disks[idx]->dst) < 0) if (VIR_STRDUP(disk->name, def->common.dom->disks[idx]->dst) < 0)
goto cleanup; goto cleanup;
} }
} }
@ -696,10 +694,10 @@ virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr def,
/* Provide defaults for all remaining disks. */ /* Provide defaults for all remaining disks. */
ndisks = def->ndisks; ndisks = def->ndisks;
if (VIR_EXPAND_N(def->disks, def->ndisks, if (VIR_EXPAND_N(def->disks, def->ndisks,
def->dom->ndisks - def->ndisks) < 0) def->common.dom->ndisks - def->ndisks) < 0)
goto cleanup; goto cleanup;
for (i = 0; i < def->dom->ndisks; i++) { for (i = 0; i < def->common.dom->ndisks; i++) {
virDomainSnapshotDiskDefPtr disk; virDomainSnapshotDiskDefPtr disk;
if (virBitmapIsBitSet(map, i)) if (virBitmapIsBitSet(map, i))
@ -707,15 +705,15 @@ virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr def,
disk = &def->disks[ndisks++]; disk = &def->disks[ndisks++];
if (!(disk->src = virStorageSourceNew())) if (!(disk->src = virStorageSourceNew()))
goto cleanup; goto cleanup;
if (VIR_STRDUP(disk->name, def->dom->disks[i]->dst) < 0) if (VIR_STRDUP(disk->name, def->common.dom->disks[i]->dst) < 0)
goto cleanup; goto cleanup;
disk->idx = i; disk->idx = i;
/* Don't snapshot empty drives */ /* Don't snapshot empty drives */
if (virStorageSourceIsEmpty(def->dom->disks[i]->src)) if (virStorageSourceIsEmpty(def->common.dom->disks[i]->src))
disk->snapshot = VIR_DOMAIN_SNAPSHOT_LOCATION_NONE; disk->snapshot = VIR_DOMAIN_SNAPSHOT_LOCATION_NONE;
else else
disk->snapshot = def->dom->disks[i]->snapshot; disk->snapshot = def->common.dom->disks[i]->snapshot;
disk->src->type = VIR_STORAGE_TYPE_FILE; disk->src->type = VIR_STORAGE_TYPE_FILE;
if (!disk->snapshot) if (!disk->snapshot)
@ -806,23 +804,23 @@ virDomainSnapshotDefFormatInternal(virBufferPtr buf,
virBufferAddLit(buf, "<domainsnapshot>\n"); virBufferAddLit(buf, "<domainsnapshot>\n");
virBufferAdjustIndent(buf, 2); virBufferAdjustIndent(buf, 2);
virBufferEscapeString(buf, "<name>%s</name>\n", def->name); virBufferEscapeString(buf, "<name>%s</name>\n", def->common.name);
if (def->description) if (def->common.description)
virBufferEscapeString(buf, "<description>%s</description>\n", virBufferEscapeString(buf, "<description>%s</description>\n",
def->description); def->common.description);
virBufferAsprintf(buf, "<state>%s</state>\n", virBufferAsprintf(buf, "<state>%s</state>\n",
virDomainSnapshotStateTypeToString(def->state)); virDomainSnapshotStateTypeToString(def->state));
if (def->parent) { if (def->common.parent) {
virBufferAddLit(buf, "<parent>\n"); virBufferAddLit(buf, "<parent>\n");
virBufferAdjustIndent(buf, 2); virBufferAdjustIndent(buf, 2);
virBufferEscapeString(buf, "<name>%s</name>\n", def->parent); virBufferEscapeString(buf, "<name>%s</name>\n", def->common.parent);
virBufferAdjustIndent(buf, -2); virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</parent>\n"); virBufferAddLit(buf, "</parent>\n");
} }
virBufferAsprintf(buf, "<creationTime>%lld</creationTime>\n", virBufferAsprintf(buf, "<creationTime>%lld</creationTime>\n",
def->creationTime); def->common.creationTime);
if (def->memory) { if (def->memory) {
virBufferAsprintf(buf, "<memory snapshot='%s'", virBufferAsprintf(buf, "<memory snapshot='%s'",
@ -842,8 +840,8 @@ virDomainSnapshotDefFormatInternal(virBufferPtr buf,
virBufferAddLit(buf, "</disks>\n"); virBufferAddLit(buf, "</disks>\n");
} }
if (def->dom) { if (def->common.dom) {
if (virDomainDefFormatInternal(def->dom, caps, domainflags, buf, if (virDomainDefFormatInternal(def->common.dom, caps, domainflags, buf,
xmlopt) < 0) xmlopt) < 0)
goto error; goto error;
} else if (uuidstr) { } else if (uuidstr) {
@ -935,30 +933,30 @@ virDomainSnapshotRedefinePrep(virDomainPtr domain,
bool check_if_stolen; bool check_if_stolen;
/* Prevent circular chains */ /* Prevent circular chains */
if (def->parent) { if (def->common.parent) {
if (STREQ(def->name, def->parent)) { if (STREQ(def->common.name, def->common.parent)) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("cannot set snapshot %s as its own parent"), _("cannot set snapshot %s as its own parent"),
def->name); def->common.name);
return -1; return -1;
} }
other = virDomainSnapshotFindByName(vm->snapshots, def->parent); other = virDomainSnapshotFindByName(vm->snapshots, def->common.parent);
if (!other) { if (!other) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("parent %s for snapshot %s not found"), _("parent %s for snapshot %s not found"),
def->parent, def->name); def->common.parent, def->common.name);
return -1; return -1;
} }
otherdef = virDomainSnapshotObjGetDef(other); otherdef = virDomainSnapshotObjGetDef(other);
while (otherdef->parent) { while (otherdef->common.parent) {
if (STREQ(otherdef->parent, def->name)) { if (STREQ(otherdef->common.parent, def->common.name)) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("parent %s would create cycle to %s"), _("parent %s would create cycle to %s"),
otherdef->name, def->name); otherdef->common.name, def->common.name);
return -1; return -1;
} }
other = virDomainSnapshotFindByName(vm->snapshots, other = virDomainSnapshotFindByName(vm->snapshots,
otherdef->parent); otherdef->common.parent);
if (!other) { if (!other) {
VIR_WARN("snapshots are inconsistent for %s", VIR_WARN("snapshots are inconsistent for %s",
vm->def->name); vm->def->name);
@ -967,14 +965,14 @@ virDomainSnapshotRedefinePrep(virDomainPtr domain,
} }
} }
other = virDomainSnapshotFindByName(vm->snapshots, def->name); other = virDomainSnapshotFindByName(vm->snapshots, def->common.name);
otherdef = other ? virDomainSnapshotObjGetDef(other) : NULL; otherdef = other ? virDomainSnapshotObjGetDef(other) : NULL;
check_if_stolen = other && otherdef->dom; check_if_stolen = other && otherdef->common.dom;
if (virDomainSnapshotRedefineValidate(def, domain->uuid, other, xmlopt, if (virDomainSnapshotRedefineValidate(def, domain->uuid, other, xmlopt,
flags) < 0) { flags) < 0) {
/* revert any stealing of the snapshot domain definition */ /* revert any stealing of the snapshot domain definition */
if (check_if_stolen && def->dom && !otherdef->dom) if (check_if_stolen && def->common.dom && !otherdef->common.dom)
VIR_STEAL_PTR(otherdef->dom, def->dom); VIR_STEAL_PTR(otherdef->common.dom, def->common.dom);
return -1; return -1;
} }
if (other) { if (other) {

11
src/conf/snapshot_conf.h
View File

@ -24,6 +24,7 @@
# include "internal.h" # include "internal.h"
# include "domain_conf.h" # include "domain_conf.h"
# include "moment_conf.h"
/* Items related to snapshot state */ /* Items related to snapshot state */
@ -72,11 +73,9 @@ struct _virDomainSnapshotDiskDef {
/* Stores the complete snapshot metadata */ /* Stores the complete snapshot metadata */
struct _virDomainSnapshotDef { struct _virDomainSnapshotDef {
/* Public XML. */ virDomainMomentDef common;
char *name;
char *description; /* Additional public XML. */
char *parent;
long long creationTime; /* in seconds */
int state; /* virDomainSnapshotState */ int state; /* virDomainSnapshotState */
int memory; /* virDomainMemorySnapshot */ int memory; /* virDomainMemorySnapshot */
@ -85,8 +84,6 @@ struct _virDomainSnapshotDef {
size_t ndisks; /* should not exceed dom->ndisks */ size_t ndisks; /* should not exceed dom->ndisks */
virDomainSnapshotDiskDef *disks; virDomainSnapshotDiskDef *disks;
virDomainDefPtr dom;
virObjectPtr cookie; virObjectPtr cookie;
}; };

3
src/conf/virconftypes.h
View File

@ -217,6 +217,9 @@ typedef virDomainMemoryDef *virDomainMemoryDefPtr;
typedef struct _virDomainMemtune virDomainMemtune; typedef struct _virDomainMemtune virDomainMemtune;
typedef virDomainMemtune *virDomainMemtunePtr; typedef virDomainMemtune *virDomainMemtunePtr;
typedef struct _virDomainMomentDef virDomainMomentDef;
typedef virDomainMomentDef *virDomainMomentDefPtr;
typedef struct _virDomainNVRAMDef virDomainNVRAMDef; typedef struct _virDomainNVRAMDef virDomainNVRAMDef;
typedef virDomainNVRAMDef *virDomainNVRAMDefPtr; typedef virDomainNVRAMDef *virDomainNVRAMDefPtr;

2
src/conf/virdomainsnapshotobj.c
View File

@ -45,7 +45,7 @@ virDomainSnapshotForEachChild(virDomainSnapshotObjPtr snapshot,
while (child) { while (child) {
virDomainSnapshotObjPtr next = child->sibling; virDomainSnapshotObjPtr next = child->sibling;
(iter)(child, child->def->name, data); (iter)(child, child->def->common.name, data);
child = next; child = next;
} }

21
src/conf/virdomainsnapshotobjlist.c
View File

@ -239,17 +239,17 @@ virDomainSnapshotObjPtr virDomainSnapshotAssignDef(virDomainSnapshotObjListPtr s
{ {
virDomainSnapshotObjPtr snap; virDomainSnapshotObjPtr snap;
if (virHashLookup(snapshots->objs, def->name) != NULL) { if (virHashLookup(snapshots->objs, def->common.name) != NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected domain snapshot %s already exists"), _("unexpected domain snapshot %s already exists"),
def->name); def->common.name);
return NULL; return NULL;
} }
if (!(snap = virDomainSnapshotObjNew())) if (!(snap = virDomainSnapshotObjNew()))
return NULL; return NULL;
if (virHashAddEntry(snapshots->objs, snap->def->name, snap) < 0) { if (virHashAddEntry(snapshots->objs, snap->def->common.name, snap) < 0) {
VIR_FREE(snap); VIR_FREE(snap);
return NULL; return NULL;
} }
@ -353,7 +353,7 @@ static int virDomainSnapshotObjListCopyNames(void *payload,
return 0; return 0;
if (data->names && data->count < data->maxnames && if (data->names && data->count < data->maxnames &&
VIR_STRDUP(data->names[data->count], obj->def->name) < 0) { VIR_STRDUP(data->names[data->count], obj->def->common.name) < 0) {
data->error = true; data->error = true;
return 0; return 0;
} }
@ -474,7 +474,7 @@ const char *
virDomainSnapshotGetCurrentName(virDomainSnapshotObjListPtr snapshots) virDomainSnapshotGetCurrentName(virDomainSnapshotObjListPtr snapshots)
{ {
if (snapshots->current) if (snapshots->current)
return snapshots->current->def->name; return snapshots->current->def->common.name;
return NULL; return NULL;
} }
@ -484,7 +484,8 @@ bool
virDomainSnapshotIsCurrentName(virDomainSnapshotObjListPtr snapshots, virDomainSnapshotIsCurrentName(virDomainSnapshotObjListPtr snapshots,
const char *name) const char *name)
{ {
return snapshots->current && STREQ(snapshots->current->def->name, name); return snapshots->current && STREQ(snapshots->current->def->common.name,
name);
} }
@ -503,7 +504,7 @@ virDomainSnapshotObjListRemove(virDomainSnapshotObjListPtr snapshots,
virDomainSnapshotObjPtr snapshot) virDomainSnapshotObjPtr snapshot)
{ {
bool ret = snapshots->current == snapshot; bool ret = snapshots->current == snapshot;
virHashRemoveEntry(snapshots->objs, snapshot->def->name); virHashRemoveEntry(snapshots->objs, snapshot->def->common.name);
if (ret) if (ret)
snapshots->current = NULL; snapshots->current = NULL;
return ret; return ret;
@ -547,18 +548,18 @@ virDomainSnapshotSetRelations(void *payload,
virDomainSnapshotObjPtr tmp; virDomainSnapshotObjPtr tmp;
virDomainSnapshotObjPtr parent; virDomainSnapshotObjPtr parent;
parent = virDomainSnapshotFindByName(curr->snapshots, obj->def->parent); parent = virDomainSnapshotFindByName(curr->snapshots, obj->def->common.parent);
if (!parent) { if (!parent) {
curr->err = -1; curr->err = -1;
parent = &curr->snapshots->metaroot; parent = &curr->snapshots->metaroot;
VIR_WARN("snapshot %s lacks parent", obj->def->name); VIR_WARN("snapshot %s lacks parent", obj->def->common.name);
} else { } else {
tmp = parent; tmp = parent;
while (tmp && tmp->def) { while (tmp && tmp->def) {
if (tmp == obj) { if (tmp == obj) {
curr->err = -1; curr->err = -1;
parent = &curr->snapshots->metaroot; parent = &curr->snapshots->metaroot;
VIR_WARN("snapshot %s in circular chain", obj->def->name); VIR_WARN("snapshot %s in circular chain", obj->def->common.name);
break; break;
} }
tmp = tmp->parent; tmp = tmp->parent;

16
src/esx/esx_driver.c
View File

@ -4118,7 +4118,7 @@ esxDomainSnapshotCreateXML(virDomainPtr domain, const char *xmlDesc,
priv->parsedUri->autoAnswer) < 0 || priv->parsedUri->autoAnswer) < 0 ||
esxVI_LookupRootSnapshotTreeList(priv->primary, domain->uuid, esxVI_LookupRootSnapshotTreeList(priv->primary, domain->uuid,
&rootSnapshotList) < 0 || &rootSnapshotList) < 0 ||
esxVI_GetSnapshotTreeByName(rootSnapshotList, def->name, esxVI_GetSnapshotTreeByName(rootSnapshotList, def->common.name,
&snapshotTree, NULL, &snapshotTree, NULL,
esxVI_Occurrence_OptionalItem) < 0) { esxVI_Occurrence_OptionalItem) < 0) {
goto cleanup; goto cleanup;
@ -4126,12 +4126,12 @@ esxDomainSnapshotCreateXML(virDomainPtr domain, const char *xmlDesc,
if (snapshotTree) { if (snapshotTree) {
virReportError(VIR_ERR_OPERATION_INVALID, virReportError(VIR_ERR_OPERATION_INVALID,
_("Snapshot '%s' already exists"), def->name); _("Snapshot '%s' already exists"), def->common.name);
goto cleanup; goto cleanup;
} }
if (esxVI_CreateSnapshot_Task(priv->primary, virtualMachine->obj, if (esxVI_CreateSnapshot_Task(priv->primary, virtualMachine->obj,
def->name, def->description, def->common.name, def->common.description,
diskOnly ? esxVI_Boolean_False : esxVI_Boolean_True, diskOnly ? esxVI_Boolean_False : esxVI_Boolean_True,
quiesce ? esxVI_Boolean_True : esxVI_Boolean_False, quiesce ? esxVI_Boolean_True : esxVI_Boolean_False,
&task) < 0 || &task) < 0 ||
@ -4148,7 +4148,7 @@ esxDomainSnapshotCreateXML(virDomainPtr domain, const char *xmlDesc,
goto cleanup; goto cleanup;
} }
snapshot = virGetDomainSnapshot(domain, def->name); snapshot = virGetDomainSnapshot(domain, def->common.name);
cleanup: cleanup:
virDomainSnapshotDefFree(def); virDomainSnapshotDefFree(def);
@ -4189,12 +4189,12 @@ esxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
goto cleanup; goto cleanup;
} }
def.name = snapshot->name; def.common.name = snapshot->name;
def.description = snapshotTree->description; def.common.description = snapshotTree->description;
def.parent = snapshotTreeParent ? snapshotTreeParent->name : NULL; def.common.parent = snapshotTreeParent ? snapshotTreeParent->name : NULL;
if (esxVI_DateTime_ConvertToCalendarTime(snapshotTree->createTime, if (esxVI_DateTime_ConvertToCalendarTime(snapshotTree->createTime,
&def.creationTime) < 0) { &def.common.creationTime) < 0) {
goto cleanup; goto cleanup;
} }

2
src/qemu/qemu_command.c
View File

@ -10859,7 +10859,7 @@ qemuBuildCommandLine(virQEMUDriverPtr driver,
goto error; goto error;
if (snapshot) if (snapshot)
virCommandAddArgList(cmd, "-loadvm", snapshot->def->name, NULL); virCommandAddArgList(cmd, "-loadvm", snapshot->def->common.name, NULL);
if (def->namespaceData) { if (def->namespaceData) {
qemuDomainCmdlineDefPtr qemucmd; qemuDomainCmdlineDefPtr qemucmd;

18
src/qemu/qemu_domain.c
View File

@ -8477,7 +8477,7 @@ qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
goto cleanup; goto cleanup;
} }
if (virAsprintf(&snapFile, "%s/%s.xml", snapDir, def->name) < 0) if (virAsprintf(&snapFile, "%s/%s.xml", snapDir, def->common.name) < 0)
goto cleanup; goto cleanup;
ret = virXMLSaveFile(snapFile, NULL, "snapshot-edit", newxml); ret = virXMLSaveFile(snapFile, NULL, "snapshot-edit", newxml);
@ -8573,11 +8573,11 @@ qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
/* Prefer action on the disks in use at the time the snapshot was /* Prefer action on the disks in use at the time the snapshot was
* created; but fall back to current definition if dealing with a * created; but fall back to current definition if dealing with a
* snapshot created prior to libvirt 0.9.5. */ * snapshot created prior to libvirt 0.9.5. */
virDomainDefPtr def = snap->def->dom; virDomainDefPtr def = snap->def->common.dom;
if (!def) if (!def)
def = vm->def; def = vm->def;
return qemuDomainSnapshotForEachQcow2Raw(driver, def, snap->def->name, return qemuDomainSnapshotForEachQcow2Raw(driver, def, snap->def->common.name,
op, try_all, def->ndisks); op, try_all, def->ndisks);
} }
@ -8605,30 +8605,30 @@ qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
priv = vm->privateData; priv = vm->privateData;
qemuDomainObjEnterMonitor(driver, vm); qemuDomainObjEnterMonitor(driver, vm);
/* we continue on even in the face of error */ /* we continue on even in the face of error */
qemuMonitorDeleteSnapshot(priv->mon, snap->def->name); qemuMonitorDeleteSnapshot(priv->mon, snap->def->common.name);
ignore_value(qemuDomainObjExitMonitor(driver, vm)); ignore_value(qemuDomainObjExitMonitor(driver, vm));
} }
} }
if (virAsprintf(&snapFile, "%s/%s/%s.xml", cfg->snapshotDir, if (virAsprintf(&snapFile, "%s/%s/%s.xml", cfg->snapshotDir,
vm->def->name, snap->def->name) < 0) vm->def->name, snap->def->common.name) < 0)
goto cleanup; goto cleanup;
if (snap == virDomainSnapshotGetCurrent(vm->snapshots)) { if (snap == virDomainSnapshotGetCurrent(vm->snapshots)) {
virDomainSnapshotSetCurrent(vm->snapshots, NULL); virDomainSnapshotSetCurrent(vm->snapshots, NULL);
if (update_parent && snap->def->parent) { if (update_parent && snap->def->common.parent) {
parentsnap = virDomainSnapshotFindByName(vm->snapshots, parentsnap = virDomainSnapshotFindByName(vm->snapshots,
snap->def->parent); snap->def->common.parent);
if (!parentsnap) { if (!parentsnap) {
VIR_WARN("missing parent snapshot matching name '%s'", VIR_WARN("missing parent snapshot matching name '%s'",
snap->def->parent); snap->def->common.parent);
} else { } else {
virDomainSnapshotSetCurrent(vm->snapshots, parentsnap); virDomainSnapshotSetCurrent(vm->snapshots, parentsnap);
if (qemuDomainSnapshotWriteMetadata(vm, parentsnap, driver->caps, if (qemuDomainSnapshotWriteMetadata(vm, parentsnap, driver->caps,
driver->xmlopt, driver->xmlopt,
cfg->snapshotDir) < 0) { cfg->snapshotDir) < 0) {
VIR_WARN("failed to set parent snapshot '%s' as current", VIR_WARN("failed to set parent snapshot '%s' as current",
snap->def->parent); snap->def->common.parent);
virDomainSnapshotSetCurrent(vm->snapshots, NULL); virDomainSnapshotSetCurrent(vm->snapshots, NULL);
} }
} }

50
src/qemu/qemu_driver.c
View File

@ -14547,7 +14547,7 @@ qemuDomainSnapshotCreateInactiveExternal(virQEMUDriverPtr driver,
* create them correctly. */ * create them correctly. */
for (i = 0; i < snap->def->ndisks && !reuse; i++) { for (i = 0; i < snap->def->ndisks && !reuse; i++) {
snapdisk = &(snap->def->disks[i]); snapdisk = &(snap->def->disks[i]);
defdisk = snap->def->dom->disks[snapdisk->idx]; defdisk = snap->def->common.dom->disks[snapdisk->idx];
if (snapdisk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) if (snapdisk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)
continue; continue;
@ -14663,7 +14663,7 @@ qemuDomainSnapshotCreateActiveInternal(virQEMUDriverPtr driver,
goto cleanup; goto cleanup;
} }
ret = qemuMonitorCreateSnapshot(priv->mon, snap->def->name); ret = qemuMonitorCreateSnapshot(priv->mon, snap->def->common.name);
if (qemuDomainObjExitMonitor(driver, vm) < 0) if (qemuDomainObjExitMonitor(driver, vm) < 0)
ret = -1; ret = -1;
if (ret < 0) if (ret < 0)
@ -15726,19 +15726,19 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
/* reject snapshot names containing slashes or starting with dot as /* reject snapshot names containing slashes or starting with dot as
* snapshot definitions are saved in files named by the snapshot name */ * snapshot definitions are saved in files named by the snapshot name */
if (!(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) { if (!(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) {
if (strchr(def->name, '/')) { if (strchr(def->common.name, '/')) {
virReportError(VIR_ERR_XML_DETAIL, virReportError(VIR_ERR_XML_DETAIL,
_("invalid snapshot name '%s': " _("invalid snapshot name '%s': "
"name can't contain '/'"), "name can't contain '/'"),
def->name); def->common.name);
goto cleanup; goto cleanup;
} }
if (def->name[0] == '.') { if (def->common.name[0] == '.') {
virReportError(VIR_ERR_XML_DETAIL, virReportError(VIR_ERR_XML_DETAIL,
_("invalid snapshot name '%s': " _("invalid snapshot name '%s': "
"name can't start with '.'"), "name can't start with '.'"),
def->name); def->common.name);
goto cleanup; goto cleanup;
} }
} }
@ -15809,9 +15809,9 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
* conversion in and back out of xml. */ * conversion in and back out of xml. */
if (!(xml = qemuDomainDefFormatLive(driver, vm->def, priv->origCPU, if (!(xml = qemuDomainDefFormatLive(driver, vm->def, priv->origCPU,
true, true)) || true, true)) ||
!(def->dom = virDomainDefParseString(xml, caps, driver->xmlopt, NULL, !(def->common.dom = virDomainDefParseString(xml, caps, driver->xmlopt, NULL,
VIR_DOMAIN_DEF_PARSE_INACTIVE | VIR_DOMAIN_DEF_PARSE_INACTIVE |
VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE))) VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE)))
goto endjob; goto endjob;
if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) { if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) {
@ -15857,7 +15857,7 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
current = virDomainSnapshotGetCurrent(vm->snapshots); current = virDomainSnapshotGetCurrent(vm->snapshots);
if (current) { if (current) {
if (!redefine && if (!redefine &&
VIR_STRDUP(snap->def->parent, current->def->name) < 0) VIR_STRDUP(snap->def->common.parent, current->def->common.name) < 0)
goto endjob; goto endjob;
if (update_current) { if (update_current) {
virDomainSnapshotSetCurrent(vm->snapshots, NULL); virDomainSnapshotSetCurrent(vm->snapshots, NULL);
@ -15906,7 +15906,7 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
* do; we've successfully taken the snapshot, and we are now running * do; we've successfully taken the snapshot, and we are now running
* on it, so we have to go forward the best we can * on it, so we have to go forward the best we can
*/ */
snapshot = virGetDomainSnapshot(domain, snap->def->name); snapshot = virGetDomainSnapshot(domain, snap->def->common.name);
endjob: endjob:
if (snapshot && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) { if (snapshot && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) {
@ -15921,11 +15921,11 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain,
snapshot = NULL; snapshot = NULL;
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unable to save metadata for snapshot %s"), _("unable to save metadata for snapshot %s"),
snap->def->name); snap->def->common.name);
virDomainSnapshotObjListRemove(vm->snapshots, snap); virDomainSnapshotObjListRemove(vm->snapshots, snap);
} else { } else {
other = virDomainSnapshotFindByName(vm->snapshots, other = virDomainSnapshotFindByName(vm->snapshots,
snap->def->parent); snap->def->common.parent);
virDomainSnapshotSetParent(snap, other); virDomainSnapshotSetParent(snap, other);
} }
} else if (snap) { } else if (snap) {
@ -16135,7 +16135,7 @@ qemuDomainSnapshotLookupByName(virDomainPtr domain,
if (!(snap = qemuSnapObjFromName(vm, name))) if (!(snap = qemuSnapObjFromName(vm, name)))
goto cleanup; goto cleanup;
snapshot = virGetDomainSnapshot(domain, snap->def->name); snapshot = virGetDomainSnapshot(domain, snap->def->common.name);
cleanup: cleanup:
virDomainObjEndAPI(&vm); virDomainObjEndAPI(&vm);
@ -16185,14 +16185,14 @@ qemuDomainSnapshotGetParent(virDomainSnapshotPtr snapshot,
if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot))) if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
goto cleanup; goto cleanup;
if (!snap->def->parent) { if (!snap->def->common.parent) {
virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT, virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
_("snapshot '%s' does not have a parent"), _("snapshot '%s' does not have a parent"),
snap->def->name); snap->def->common.name);
goto cleanup; goto cleanup;
} }
parent = virGetDomainSnapshot(snapshot->domain, snap->def->parent); parent = virGetDomainSnapshot(snapshot->domain, snap->def->common.parent);
cleanup: cleanup:
virDomainObjEndAPI(&vm); virDomainObjEndAPI(&vm);
@ -16417,10 +16417,10 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
} }
if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) { if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) {
if (!snap->def->dom) { if (!snap->def->common.dom) {
virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY,
_("snapshot '%s' lacks domain '%s' rollback info"), _("snapshot '%s' lacks domain '%s' rollback info"),
snap->def->name, vm->def->name); snap->def->common.name, vm->def->name);
goto endjob; goto endjob;
} }
if (virDomainObjIsActive(vm) && if (virDomainObjIsActive(vm) &&
@ -16450,8 +16450,8 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
* *
* XXX Should domain snapshots track live xml rather * XXX Should domain snapshots track live xml rather
* than inactive xml? */ * than inactive xml? */
if (snap->def->dom) { if (snap->def->common.dom) {
config = virDomainDefCopy(snap->def->dom, caps, config = virDomainDefCopy(snap->def->common.dom, caps,
driver->xmlopt, NULL, true); driver->xmlopt, NULL, true);
if (!config) if (!config)
goto endjob; goto endjob;
@ -16557,7 +16557,7 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
if (qemuDomainObjEnterMonitorAsync(driver, vm, if (qemuDomainObjEnterMonitorAsync(driver, vm,
QEMU_ASYNC_JOB_START) < 0) QEMU_ASYNC_JOB_START) < 0)
goto endjob; goto endjob;
rc = qemuMonitorLoadSnapshot(priv->mon, snap->def->name); rc = qemuMonitorLoadSnapshot(priv->mon, snap->def->common.name);
if (qemuDomainObjExitMonitor(driver, vm) < 0) if (qemuDomainObjExitMonitor(driver, vm) < 0)
goto endjob; goto endjob;
if (rc < 0) { if (rc < 0) {
@ -16774,10 +16774,10 @@ qemuDomainSnapshotReparentChildren(void *payload,
if (rep->err < 0) if (rep->err < 0)
return 0; return 0;
VIR_FREE(snap->def->parent); VIR_FREE(snap->def->common.parent);
if (rep->parent->def && if (rep->parent->def &&
VIR_STRDUP(snap->def->parent, rep->parent->def->name) < 0) { VIR_STRDUP(snap->def->common.parent, rep->parent->def->common.name) < 0) {
rep->err = -1; rep->err = -1;
return 0; return 0;
} }
@ -16858,7 +16858,7 @@ qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
cfg->snapshotDir) < 0) { cfg->snapshotDir) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("failed to set snapshot '%s' as current"), _("failed to set snapshot '%s' as current"),
snap->def->name); snap->def->common.name);
virDomainSnapshotSetCurrent(vm->snapshots, NULL); virDomainSnapshotSetCurrent(vm->snapshots, NULL);
goto endjob; goto endjob;
} }

42
src/test/test_driver.c
View File

@ -6132,7 +6132,7 @@ testDomainSnapshotLookupByName(virDomainPtr domain,
if (!(snap = testSnapObjFromName(vm, name))) if (!(snap = testSnapObjFromName(vm, name)))
goto cleanup; goto cleanup;
snapshot = virGetDomainSnapshot(domain, snap->def->name); snapshot = virGetDomainSnapshot(domain, snap->def->common.name);
cleanup: cleanup:
virDomainObjEndAPI(&vm); virDomainObjEndAPI(&vm);
@ -6173,14 +6173,14 @@ testDomainSnapshotGetParent(virDomainSnapshotPtr snapshot,
if (!(snap = testSnapObjFromSnapshot(vm, snapshot))) if (!(snap = testSnapObjFromSnapshot(vm, snapshot)))
goto cleanup; goto cleanup;
if (!snap->def->parent) { if (!snap->def->common.parent) {
virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT, virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
_("snapshot '%s' does not have a parent"), _("snapshot '%s' does not have a parent"),
snap->def->name); snap->def->common.name);
goto cleanup; goto cleanup;
} }
parent = virGetDomainSnapshot(snapshot->domain, snap->def->parent); parent = virGetDomainSnapshot(snapshot->domain, snap->def->common.parent);
cleanup: cleanup:
virDomainObjEndAPI(&vm); virDomainObjEndAPI(&vm);
@ -6207,7 +6207,7 @@ testDomainSnapshotCurrent(virDomainPtr domain,
goto cleanup; goto cleanup;
} }
snapshot = virGetDomainSnapshot(domain, current->def->name); snapshot = virGetDomainSnapshot(domain, current->def->common.name);
cleanup: cleanup:
virDomainObjEndAPI(&vm); virDomainObjEndAPI(&vm);
@ -6376,11 +6376,11 @@ testDomainSnapshotCreateXML(virDomainPtr domain,
&update_current, flags) < 0) &update_current, flags) < 0)
goto cleanup; goto cleanup;
} else { } else {
if (!(def->dom = virDomainDefCopy(vm->def, if (!(def->common.dom = virDomainDefCopy(vm->def,
privconn->caps, privconn->caps,
privconn->xmlopt, privconn->xmlopt,
NULL, NULL,
true))) true)))
goto cleanup; goto cleanup;
if (testDomainSnapshotAlignDisks(vm, def, flags) < 0) if (testDomainSnapshotAlignDisks(vm, def, flags) < 0)
@ -6394,7 +6394,7 @@ testDomainSnapshotCreateXML(virDomainPtr domain,
} }
if (!redefine) { if (!redefine) {
if (VIR_STRDUP(snap->def->parent, if (VIR_STRDUP(snap->def->common.parent,
virDomainSnapshotGetCurrentName(vm->snapshots)) < 0) virDomainSnapshotGetCurrentName(vm->snapshots)) < 0)
goto cleanup; goto cleanup;
@ -6407,7 +6407,7 @@ testDomainSnapshotCreateXML(virDomainPtr domain,
} }
} }
snapshot = virGetDomainSnapshot(domain, snap->def->name); snapshot = virGetDomainSnapshot(domain, snap->def->common.name);
cleanup: cleanup:
if (vm) { if (vm) {
if (snapshot) { if (snapshot) {
@ -6415,7 +6415,7 @@ testDomainSnapshotCreateXML(virDomainPtr domain,
if (update_current) if (update_current)
virDomainSnapshotSetCurrent(vm->snapshots, snap); virDomainSnapshotSetCurrent(vm->snapshots, snap);
other = virDomainSnapshotFindByName(vm->snapshots, other = virDomainSnapshotFindByName(vm->snapshots,
snap->def->parent); snap->def->common.parent);
virDomainSnapshotSetParent(snap, other); virDomainSnapshotSetParent(snap, other);
} }
virDomainObjEndAPI(&vm); virDomainObjEndAPI(&vm);
@ -6464,10 +6464,10 @@ testDomainSnapshotReparentChildren(void *payload,
if (rep->err < 0) if (rep->err < 0)
return 0; return 0;
VIR_FREE(snap->def->parent); VIR_FREE(snap->def->common.parent);
if (rep->parent->def && if (rep->parent->def &&
VIR_STRDUP(snap->def->parent, rep->parent->def->name) < 0) { VIR_STRDUP(snap->def->common.parent, rep->parent->def->common.name) < 0) {
rep->err = -1; rep->err = -1;
return 0; return 0;
} }
@ -6522,12 +6522,12 @@ testDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
} else { } else {
virDomainSnapshotDropParent(snap); virDomainSnapshotDropParent(snap);
if (snap == virDomainSnapshotGetCurrent(vm->snapshots)) { if (snap == virDomainSnapshotGetCurrent(vm->snapshots)) {
if (snap->def->parent) { if (snap->def->common.parent) {
parentsnap = virDomainSnapshotFindByName(vm->snapshots, parentsnap = virDomainSnapshotFindByName(vm->snapshots,
snap->def->parent); snap->def->common.parent);
if (!parentsnap) if (!parentsnap)
VIR_WARN("missing parent snapshot matching name '%s'", VIR_WARN("missing parent snapshot matching name '%s'",
snap->def->parent); snap->def->common.parent);
} }
virDomainSnapshotSetCurrent(vm->snapshots, parentsnap); virDomainSnapshotSetCurrent(vm->snapshots, parentsnap);
} }
@ -6588,10 +6588,10 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
} }
if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) { if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) {
if (!snap->def->dom) { if (!snap->def->common.dom) {
virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY,
_("snapshot '%s' lacks domain '%s' rollback info"), _("snapshot '%s' lacks domain '%s' rollback info"),
snap->def->name, vm->def->name); snap->def->common.name, vm->def->name);
goto cleanup; goto cleanup;
} }
if (virDomainObjIsActive(vm) && if (virDomainObjIsActive(vm) &&
@ -6607,7 +6607,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
virDomainSnapshotSetCurrent(vm->snapshots, NULL); virDomainSnapshotSetCurrent(vm->snapshots, NULL);
config = virDomainDefCopy(snap->def->dom, privconn->caps, config = virDomainDefCopy(snap->def->common.dom, privconn->caps,
privconn->xmlopt, NULL, true); privconn->xmlopt, NULL, true);
if (!config) if (!config)
goto cleanup; goto cleanup;

88
src/vbox/vbox_common.c
View File

@ -4814,7 +4814,7 @@ vboxSnapshotRedefine(virDomainPtr dom,
* read-only disks are in the redefined snapshot's media registry (the disks need to * read-only disks are in the redefined snapshot's media registry (the disks need to
* be open to query their uuid). * be open to query their uuid).
*/ */
for (it = 0; it < def->dom->ndisks; it++) { for (it = 0; it < def->common.dom->ndisks; it++) {
int diskInMediaRegistry = 0; int diskInMediaRegistry = 0;
IMedium *readOnlyMedium = NULL; IMedium *readOnlyMedium = NULL;
PRUnichar *locationUtf = NULL; PRUnichar *locationUtf = NULL;
@ -4828,7 +4828,7 @@ vboxSnapshotRedefine(virDomainPtr dom,
VBOX_IID_INITIALIZE(&iid); VBOX_IID_INITIALIZE(&iid);
VBOX_IID_INITIALIZE(&parentiid); VBOX_IID_INITIALIZE(&parentiid);
diskInMediaRegistry = virVBoxSnapshotConfDiskIsInMediaRegistry(snapshotMachineDesc, diskInMediaRegistry = virVBoxSnapshotConfDiskIsInMediaRegistry(snapshotMachineDesc,
def->dom->disks[it]->src->path); def->common.dom->disks[it]->src->path);
if (diskInMediaRegistry == -1) { if (diskInMediaRegistry == -1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to know if disk is in media registry")); _("Unable to know if disk is in media registry"));
@ -4838,7 +4838,7 @@ vboxSnapshotRedefine(virDomainPtr dom,
continue; continue;
/*The read only disk is not in the media registry*/ /*The read only disk is not in the media registry*/
VBOX_UTF8_TO_UTF16(def->dom->disks[it]->src->path, &locationUtf); VBOX_UTF8_TO_UTF16(def->common.dom->disks[it]->src->path, &locationUtf);
rc = gVBoxAPI.UIVirtualBox.OpenMedium(data->vboxObj, rc = gVBoxAPI.UIVirtualBox.OpenMedium(data->vboxObj,
locationUtf, locationUtf,
DeviceType_HardDisk, DeviceType_HardDisk,
@ -4911,7 +4911,7 @@ vboxSnapshotRedefine(virDomainPtr dom,
readOnlyDisk->format = format; readOnlyDisk->format = format;
readOnlyDisk->uuid = uuid; readOnlyDisk->uuid = uuid;
if (VIR_STRDUP(readOnlyDisk->location, def->dom->disks[it]->src->path) < 0) { if (VIR_STRDUP(readOnlyDisk->location, def->common.dom->disks[it]->src->path) < 0) {
VIR_FREE(readOnlyDisk); VIR_FREE(readOnlyDisk);
goto cleanup; goto cleanup;
} }
@ -5016,12 +5016,12 @@ vboxSnapshotRedefine(virDomainPtr dom,
goto cleanup; goto cleanup;
VIR_DEBUG("New snapshot UUID: %s", newSnapshotPtr->uuid); VIR_DEBUG("New snapshot UUID: %s", newSnapshotPtr->uuid);
if (VIR_STRDUP(newSnapshotPtr->name, def->name) < 0) if (VIR_STRDUP(newSnapshotPtr->name, def->common.name) < 0)
goto cleanup; goto cleanup;
newSnapshotPtr->timeStamp = virTimeStringThen(def->creationTime * 1000); newSnapshotPtr->timeStamp = virTimeStringThen(def->common.creationTime * 1000);
if (VIR_STRDUP(newSnapshotPtr->description, def->description) < 0) if (VIR_STRDUP(newSnapshotPtr->description, def->common.description) < 0)
goto cleanup; goto cleanup;
if (VIR_STRDUP(newSnapshotPtr->hardware, snapshotMachineDesc->hardware) < 0) if (VIR_STRDUP(newSnapshotPtr->hardware, snapshotMachineDesc->hardware) < 0)
@ -5031,12 +5031,12 @@ vboxSnapshotRedefine(virDomainPtr dom,
goto cleanup; goto cleanup;
/*We get the parent disk uuid from the parent disk location to correctly fill the storage controller.*/ /*We get the parent disk uuid from the parent disk location to correctly fill the storage controller.*/
for (it = 0; it < def->dom->ndisks; it++) { for (it = 0; it < def->common.dom->ndisks; it++) {
char *location = NULL; char *location = NULL;
const char *uuidReplacing = NULL; const char *uuidReplacing = NULL;
char *tmp = NULL; char *tmp = NULL;
location = def->dom->disks[it]->src->path; location = def->common.dom->disks[it]->src->path;
if (!location) if (!location)
goto cleanup; goto cleanup;
/*Replacing the uuid*/ /*Replacing the uuid*/
@ -5064,7 +5064,7 @@ vboxSnapshotRedefine(virDomainPtr dom,
VIR_FREE(tmp); VIR_FREE(tmp);
} }
if (virVBoxSnapshotConfAddSnapshotToXmlMachine(newSnapshotPtr, snapshotMachineDesc, def->parent) < 0) { if (virVBoxSnapshotConfAddSnapshotToXmlMachine(newSnapshotPtr, snapshotMachineDesc, def->common.parent) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to add the snapshot to the machine description")); _("Unable to add the snapshot to the machine description"));
goto cleanup; goto cleanup;
@ -5084,10 +5084,10 @@ vboxSnapshotRedefine(virDomainPtr dom,
* Open the snapshot's read-write disk's full ancestry to allow opening the * Open the snapshot's read-write disk's full ancestry to allow opening the
* read-write disk itself. * read-write disk itself.
*/ */
for (it = 0; it < def->dom->ndisks; it++) { for (it = 0; it < def->common.dom->ndisks; it++) {
char *location = NULL; char *location = NULL;
location = def->dom->disks[it]->src->path; location = def->common.dom->disks[it]->src->path;
if (!location) if (!location)
goto cleanup; goto cleanup;
@ -5231,7 +5231,7 @@ vboxSnapshotRedefine(virDomainPtr dom,
} }
} else { } else {
/*Create a "fake" disk to avoid corrupting children snapshot disks.*/ /*Create a "fake" disk to avoid corrupting children snapshot disks.*/
for (it = 0; it < def->dom->ndisks; it++) { for (it = 0; it < def->common.dom->ndisks; it++) {
IMedium *medium = NULL; IMedium *medium = NULL;
PRUnichar *locationUtf16 = NULL; PRUnichar *locationUtf16 = NULL;
char *parentUuid = NULL; char *parentUuid = NULL;
@ -5247,7 +5247,7 @@ vboxSnapshotRedefine(virDomainPtr dom,
VBOX_IID_INITIALIZE(&iid); VBOX_IID_INITIALIZE(&iid);
VBOX_IID_INITIALIZE(&parentiid); VBOX_IID_INITIALIZE(&parentiid);
VBOX_UTF8_TO_UTF16(def->dom->disks[it]->src->path, &locationUtf16); VBOX_UTF8_TO_UTF16(def->common.dom->disks[it]->src->path, &locationUtf16);
rc = gVBoxAPI.UIVirtualBox.OpenMedium(data->vboxObj, rc = gVBoxAPI.UIVirtualBox.OpenMedium(data->vboxObj,
locationUtf16, locationUtf16,
DeviceType_HardDisk, DeviceType_HardDisk,
@ -5396,8 +5396,8 @@ vboxSnapshotRedefine(virDomainPtr dom,
* All the snapshot structure manipulation is done, we close the disks we have * All the snapshot structure manipulation is done, we close the disks we have
* previously opened. * previously opened.
*/ */
for (it = 0; it < def->dom->ndisks; it++) { for (it = 0; it < def->common.dom->ndisks; it++) {
char *location = def->dom->disks[it]->src->path; char *location = def->common.dom->disks[it]->src->path;
if (!location) if (!location)
goto cleanup; goto cleanup;
@ -5516,7 +5516,7 @@ vboxDomainSnapshotCreateXML(virDomainPtr dom,
if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE) { if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE) {
if (vboxSnapshotRedefine(dom, def, isCurrent) < 0) if (vboxSnapshotRedefine(dom, def, isCurrent) < 0)
goto cleanup; goto cleanup;
ret = virGetDomainSnapshot(dom, def->name); ret = virGetDomainSnapshot(dom, def->common.name);
goto cleanup; goto cleanup;
} }
} }
@ -5543,14 +5543,14 @@ vboxDomainSnapshotCreateXML(virDomainPtr dom,
goto cleanup; goto cleanup;
} }
VBOX_UTF8_TO_UTF16(def->name, &name); VBOX_UTF8_TO_UTF16(def->common.name, &name);
if (!name) { if (!name) {
virReportOOMError(); virReportOOMError();
goto cleanup; goto cleanup;
} }
if (def->description) { if (def->common.description) {
VBOX_UTF8_TO_UTF16(def->description, &description); VBOX_UTF8_TO_UTF16(def->common.description, &description);
if (!description) { if (!description) {
virReportOOMError(); virReportOOMError();
goto cleanup; goto cleanup;
@ -5580,7 +5580,7 @@ vboxDomainSnapshotCreateXML(virDomainPtr dom,
goto cleanup; goto cleanup;
} }
ret = virGetDomainSnapshot(dom, def->name); ret = virGetDomainSnapshot(dom, def->common.name);
cleanup: cleanup:
VBOX_RELEASE(progress); VBOX_RELEASE(progress);
@ -5984,7 +5984,7 @@ vboxSnapshotGetReadOnlyDisks(virDomainSnapshotDefPtr def,
vboxArray mediumAttachments = VBOX_ARRAY_INITIALIZER; vboxArray mediumAttachments = VBOX_ARRAY_INITIALIZER;
size_t i = 0, diskCount = 0, sdCount = 0; size_t i = 0, diskCount = 0, sdCount = 0;
int ret = -1; int ret = -1;
virDomainDefPtr defdom = def->dom; virDomainDefPtr defdom = def->common.dom;
if (!data->vboxObj) if (!data->vboxObj)
return ret; return ret;
@ -6223,10 +6223,10 @@ static char *vboxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
if (!(snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name))) if (!(snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name)))
goto cleanup; goto cleanup;
if (VIR_ALLOC(def) < 0 || !(def->dom = virDomainDefNew())) if (VIR_ALLOC(def) < 0 || !(def->common.dom = virDomainDefNew()))
goto cleanup; goto cleanup;
defdom = def->dom; defdom = def->common.dom;
if (VIR_STRDUP(def->name, snapshot->name) < 0) if (VIR_STRDUP(def->common.name, snapshot->name) < 0)
goto cleanup; goto cleanup;
if (gVBoxAPI.vboxSnapshotRedefine) { if (gVBoxAPI.vboxSnapshotRedefine) {
@ -6274,7 +6274,7 @@ static char *vboxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
if (str16) { if (str16) {
VBOX_UTF16_TO_UTF8(str16, &str8); VBOX_UTF16_TO_UTF8(str16, &str8);
VBOX_UTF16_FREE(str16); VBOX_UTF16_FREE(str16);
if (VIR_STRDUP(def->description, str8) < 0) { if (VIR_STRDUP(def->common.description, str8) < 0) {
VBOX_UTF8_FREE(str8); VBOX_UTF8_FREE(str8);
goto cleanup; goto cleanup;
} }
@ -6289,7 +6289,7 @@ static char *vboxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
goto cleanup; goto cleanup;
} }
/* timestamp is in milliseconds while creationTime in seconds */ /* timestamp is in milliseconds while creationTime in seconds */
def->creationTime = timestamp / 1000; def->common.creationTime = timestamp / 1000;
rc = gVBoxAPI.UISnapshot.GetParent(snap, &parent); rc = gVBoxAPI.UISnapshot.GetParent(snap, &parent);
if (NS_FAILED(rc)) { if (NS_FAILED(rc)) {
@ -6308,7 +6308,7 @@ static char *vboxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
} }
VBOX_UTF16_TO_UTF8(str16, &str8); VBOX_UTF16_TO_UTF8(str16, &str8);
VBOX_UTF16_FREE(str16); VBOX_UTF16_FREE(str16);
if (VIR_STRDUP(def->parent, str8) < 0) { if (VIR_STRDUP(def->common.parent, str8) < 0) {
VBOX_UTF8_FREE(str8); VBOX_UTF8_FREE(str8);
goto cleanup; goto cleanup;
} }
@ -6990,7 +6990,7 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot)
goto cleanup; goto cleanup;
} }
isCurrent = virVBoxSnapshotConfIsCurrentSnapshot(snapshotMachineDesc, def->name); isCurrent = virVBoxSnapshotConfIsCurrentSnapshot(snapshotMachineDesc, def->common.name);
if (isCurrent < 0) { if (isCurrent < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to know if the snapshot is the current snapshot")); _("Unable to know if the snapshot is the current snapshot"));
@ -7002,8 +7002,8 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot)
* disks. The first thing to do is to manipulate VirtualBox API to create * disks. The first thing to do is to manipulate VirtualBox API to create
* differential read-write disks if the parent snapshot is not null. * differential read-write disks if the parent snapshot is not null.
*/ */
if (def->parent != NULL) { if (def->common.parent != NULL) {
for (it = 0; it < def->dom->ndisks; it++) { for (it = 0; it < def->common.dom->ndisks; it++) {
virVBoxSnapshotConfHardDiskPtr readOnly = NULL; virVBoxSnapshotConfHardDiskPtr readOnly = NULL;
IMedium *medium = NULL; IMedium *medium = NULL;
PRUnichar *locationUtf16 = NULL; PRUnichar *locationUtf16 = NULL;
@ -7023,7 +7023,7 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot)
VBOX_IID_INITIALIZE(&iid); VBOX_IID_INITIALIZE(&iid);
VBOX_IID_INITIALIZE(&parentiid); VBOX_IID_INITIALIZE(&parentiid);
readOnly = virVBoxSnapshotConfHardDiskPtrByLocation(snapshotMachineDesc, readOnly = virVBoxSnapshotConfHardDiskPtrByLocation(snapshotMachineDesc,
def->dom->disks[it]->src->path); def->common.dom->disks[it]->src->path);
if (!readOnly) { if (!readOnly) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Cannot get hard disk by location")); _("Cannot get hard disk by location"));
@ -7061,7 +7061,7 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot)
VBOX_UTF8_TO_UTF16("VDI", &formatUtf16); VBOX_UTF8_TO_UTF16("VDI", &formatUtf16);
if (virAsprintf(&newLocationUtf8, "%sfakedisk-%s-%d.vdi", if (virAsprintf(&newLocationUtf8, "%sfakedisk-%s-%d.vdi",
machineLocationPath, def->parent, it) < 0) machineLocationPath, def->common.parent, it) < 0)
goto cleanup; goto cleanup;
VBOX_UTF8_TO_UTF16(newLocationUtf8, &newLocation); VBOX_UTF8_TO_UTF16(newLocationUtf8, &newLocation);
rc = gVBoxAPI.UIVirtualBox.CreateHardDisk(data->vboxObj, rc = gVBoxAPI.UIVirtualBox.CreateHardDisk(data->vboxObj,
@ -7159,15 +7159,15 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot)
} }
} }
} else { } else {
for (it = 0; it < def->dom->ndisks; it++) { for (it = 0; it < def->common.dom->ndisks; it++) {
const char *uuidRO = NULL; const char *uuidRO = NULL;
char *tmp = NULL; char *tmp = NULL;
uuidRO = virVBoxSnapshotConfHardDiskUuidByLocation(snapshotMachineDesc, uuidRO = virVBoxSnapshotConfHardDiskUuidByLocation(snapshotMachineDesc,
def->dom->disks[it]->src->path); def->common.dom->disks[it]->src->path);
if (!uuidRO) { if (!uuidRO) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("No such disk in media registry %s"), _("No such disk in media registry %s"),
def->dom->disks[it]->src->path); def->common.dom->disks[it]->src->path);
goto cleanup; goto cleanup;
} }
@ -7212,14 +7212,14 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot)
} }
} }
/*If the parent snapshot is not NULL, we remove the-read only disks from the media registry*/ /*If the parent snapshot is not NULL, we remove the-read only disks from the media registry*/
if (def->parent != NULL) { if (def->common.parent != NULL) {
for (it = 0; it < def->dom->ndisks; it++) { for (it = 0; it < def->common.dom->ndisks; it++) {
const char *uuidRO = const char *uuidRO =
virVBoxSnapshotConfHardDiskUuidByLocation(snapshotMachineDesc, virVBoxSnapshotConfHardDiskUuidByLocation(snapshotMachineDesc,
def->dom->disks[it]->src->path); def->common.dom->disks[it]->src->path);
if (!uuidRO) { if (!uuidRO) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unable to find UUID for location %s"), def->dom->disks[it]->src->path); _("Unable to find UUID for location %s"), def->common.dom->disks[it]->src->path);
goto cleanup; goto cleanup;
} }
if (virVBoxSnapshotConfRemoveHardDisk(snapshotMachineDesc->mediaRegistry, uuidRO) < 0) { if (virVBoxSnapshotConfRemoveHardDisk(snapshotMachineDesc->mediaRegistry, uuidRO) < 0) {
@ -7284,16 +7284,16 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot)
} }
/*removing the snapshot*/ /*removing the snapshot*/
if (virVBoxSnapshotConfRemoveSnapshot(snapshotMachineDesc, def->name) < 0) { if (virVBoxSnapshotConfRemoveSnapshot(snapshotMachineDesc, def->common.name) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unable to remove snapshot %s"), def->name); _("Unable to remove snapshot %s"), def->common.name);
goto cleanup; goto cleanup;
} }
if (isCurrent) { if (isCurrent) {
VIR_FREE(snapshotMachineDesc->currentSnapshot); VIR_FREE(snapshotMachineDesc->currentSnapshot);
if (def->parent != NULL) { if (def->common.parent != NULL) {
virVBoxSnapshotConfSnapshotPtr snap = virVBoxSnapshotConfSnapshotByName(snapshotMachineDesc->snapshot, def->parent); virVBoxSnapshotConfSnapshotPtr snap = virVBoxSnapshotConfSnapshotByName(snapshotMachineDesc->snapshot, def->common.parent);
if (!snap) { if (!snap) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to get the snapshot to remove")); _("Unable to get the snapshot to remove"));