This extends <domainsnapshot> XML to add a new element under each <disk> of a disk snapshot: <disk name='vda'> <source file='/path/to/live'/> <mirror file='/path/to/mirror'/> </disk> For now, if a <mirror> is requested, the snapshot must be external, and assumes the same driver format (qcow2 or qed) as the <source>. qemu allows more flexibility in mirror creation, which could possibly be added by further XML enhancements, but more likely would be better served by adding a new API to specifically target mirroring, as well as XML changes to represent the entire backing chain in <domain> rather than commandeering <domainsnapshot>. Meanwhile, the changes in this patch are sufficient for the oVirt use case of using a mirror for live storage migration. The new XML is parsed but rejected until later patches update the hypervisor drivers to act on mirror requests. The testsuite additions show that we can round-trip the XML. * docs/schemas/domainsnapshot.rng (disksnapshot): Add optional mirror. * docs/formatsnapshot.html.in: Document it. * src/conf/domain_conf.h (VIR_DOMAIN_SNAPSHOT_PARSE_MIRROR): New flag. (_virDomainSnapshotDiskDef): Add new member. * src/conf/domain_conf.c (virDomainSnapshotDiskDefParseXML): Add parameter, to parse or reject mirrors. (virDomainSnapshotDefParseString): Honor new flag. (virDomainSnapshotDefFormat): Output any mirrors. (virDomainSnapshotDiskDefClear): Clean up. * tests/domainsnapshotxml2xmltest.c (mymain): Add a test. (testCompareXMLToXMLFiles): Allow for mirrors. * tests/domainsnapshotxml2xmlout/disk_snapshot_mirror.xml: New file. * tests/domainsnapshotxml2xmlin/disk_snapshot_mirror.xml: Likewise. --- docs/formatsnapshot.html.in | 31 ++++++++++++ docs/schemas/domainsnapshot.rng | 8 +++ src/conf/domain_conf.c | 38 ++++++++++++++- src/conf/domain_conf.h | 2 + .../disk_snapshot_mirror.xml | 13 +++++ .../disk_snapshot_mirror.xml | 49 ++++++++++++++++++++ tests/domainsnapshotxml2xmltest.c | 4 +- 7 files changed, 141 insertions(+), 4 deletions(-) create mode 100644 tests/domainsnapshotxml2xmlin/disk_snapshot_mirror.xml create mode 100644 tests/domainsnapshotxml2xmlout/disk_snapshot_mirror.xml diff --git a/docs/formatsnapshot.html.in b/docs/formatsnapshot.html.in index ec5ebf3..cd39f1b 100644 --- a/docs/formatsnapshot.html.in +++ b/docs/formatsnapshot.html.in @@ -90,6 +90,30 @@ another snapshot. </p> <p> + External disk snapshots have another use of allowing live + storage migration across storage domains, while still + guaranteeing that at all points in time along the storage + migration, there exists a single storage domain with a + consistent view of the guest's data. This is done by adding the + concept of snapshot mirroring, where a snapshot request + specifies not only the new file name on the original storage + domain, but a secondary mirror file name on the target storage + domain. While the snapshot is active, reads are still tied to + the first storage domain, but all writes of changes from the + backing file are recorded in both storage domains; and the + management application can synchronize the backing files across + storage domains in parallel with the guest execution. Once the + second storage domain has all data in place, the management + application then deletes the snapshot, which stops the mirroring + and lets the hypervisor swap over to the second storage domain, + so that the first storage domain is no longer in active use. + Depending on the hypervisor, the use of a mirrored snapshots may + be restricted to transient domains, and the existence of a + mirrored snapshot can prevent migration, domain saves, disk hot + plug actions, and further snapshot manipulation until the + mirrored snapshot is deleted in order to stop the mirroring. + </p> + <p> The top-level <code>domainsnapshot</code> element may contain the following elements: </p> @@ -156,6 +180,13 @@ snapshots, the original file name becomes the read-only snapshot, and the new file name contains the read-write delta of all disk changes since the snapshot. + <span class="since">Since 0.9.11</span>, an external + snapshot may also have an optional + element <code>mirror</code>, which names a second file + alongside <code>source</code> that will mirror all changes + since the snapshot and using the same file format. A + mirror must have the <code>file</code> attribute listing + the file name to use. </dd> </dl> </dd> diff --git a/docs/schemas/domainsnapshot.rng b/docs/schemas/domainsnapshot.rng index 0ef0631..86193a7 100644 --- a/docs/schemas/domainsnapshot.rng +++ b/docs/schemas/domainsnapshot.rng @@ -121,6 +121,14 @@ <empty/> </element> </optional> + <optional> + <element name='mirror'> + <attribute name='file'> + <ref name='absFilePath'/> + </attribute> + <empty/> + </element> + </optional> </interleave> </group> </choice> diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index d5def1c..f84304c 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -13212,6 +13212,7 @@ virDomainSnapshotDiskDefClear(virDomainSnapshotDiskDefPtr disk) VIR_FREE(disk->name); VIR_FREE(disk->file); VIR_FREE(disk->driverType); + VIR_FREE(disk->mirror); } void virDomainSnapshotDefFree(virDomainSnapshotDefPtr def) @@ -13233,11 +13234,13 @@ void virDomainSnapshotDefFree(virDomainSnapshotDefPtr def) static int virDomainSnapshotDiskDefParseXML(xmlNodePtr node, - virDomainSnapshotDiskDefPtr def) + virDomainSnapshotDiskDefPtr def, + bool allow_mirror) { int ret = -1; char *snapshot = NULL; xmlNodePtr cur; + xmlNodePtr mirror = NULL; def->name = virXMLPropString(node, "name"); if (!def->name) { @@ -13266,14 +13269,38 @@ virDomainSnapshotDiskDefParseXML(xmlNodePtr node, } else if (!def->driverType && xmlStrEqual(cur->name, BAD_CAST "driver")) { def->driverType = virXMLPropString(cur, "type"); + } else if (!mirror && xmlStrEqual(cur->name, BAD_CAST "mirror")) { + mirror = cur; } } cur = cur->next; } - if (!def->snapshot && (def->file || def->driverType)) + if (!def->snapshot && (def->file || def->driverType || mirror)) def->snapshot = VIR_DOMAIN_DISK_SNAPSHOT_EXTERNAL; + if (mirror) { + if (!allow_mirror) { + virDomainReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, + _("unable to handle mirroring for '%s'"), + def->name); + goto cleanup; + } + def->mirror = virXMLPropString(mirror, "file"); + if (!def->mirror) { + virDomainReportError(VIR_ERR_XML_ERROR, + _("mirror for '%s' requires file attribute"), + def->name); + goto cleanup; + } + if (def->snapshot != VIR_DOMAIN_DISK_SNAPSHOT_EXTERNAL) { + virDomainReportError(VIR_ERR_XML_ERROR, + _("mirror for '%s' requires external snapshot"), + def->name); + goto cleanup; + } + } + ret = 0; cleanup: VIR_FREE(snapshot); @@ -13303,6 +13330,7 @@ virDomainSnapshotDefParseString(const char *xmlStr, int active; char *tmp; int keepBlanksDefault = xmlKeepBlanksDefault(0); + bool allow_mirror = (flags & VIR_DOMAIN_SNAPSHOT_PARSE_MIRROR) != 0; xml = virXMLParseCtxt(NULL, xmlStr, _("(domain_snapshot)"), &ctxt); if (!xml) { @@ -13406,7 +13434,8 @@ virDomainSnapshotDefParseString(const char *xmlStr, goto cleanup; } for (i = 0; i < def->ndisks; i++) { - if (virDomainSnapshotDiskDefParseXML(nodes[i], &def->disks[i]) < 0) + if (virDomainSnapshotDiskDefParseXML(nodes[i], &def->disks[i], + allow_mirror) < 0) goto cleanup; } VIR_FREE(nodes); @@ -13671,6 +13700,9 @@ char *virDomainSnapshotDefFormat(const char *domain_uuid, if (disk->file) virBufferEscapeString(&buf, " <source file='%s'/>\n", disk->file); + if (disk->mirror) + virBufferEscapeString(&buf, " <mirror file='%s'/>\n", + disk->mirror); virBufferAddLit(&buf, " </disk>\n"); } else { virBufferAddLit(&buf, "/>\n"); diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index f471e35..01a504b 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -1642,6 +1642,7 @@ struct _virDomainSnapshotDiskDef { int snapshot; /* enum virDomainDiskSnapshot */ char *file; /* new source file when snapshot is external */ char *driverType; /* file format type of new file */ + char *mirror; /* external snapshot mirror, of same file format as file */ }; /* Stores the complete snapshot metadata */ @@ -1690,6 +1691,7 @@ typedef enum { VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE = 1 << 0, VIR_DOMAIN_SNAPSHOT_PARSE_DISKS = 1 << 1, VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL = 1 << 2, + VIR_DOMAIN_SNAPSHOT_PARSE_MIRROR = 1 << 3, } virDomainSnapshotParseFlags; virDomainSnapshotDefPtr virDomainSnapshotDefParseString(const char *xmlStr, diff --git a/tests/domainsnapshotxml2xmlin/disk_snapshot_mirror.xml b/tests/domainsnapshotxml2xmlin/disk_snapshot_mirror.xml new file mode 100644 index 0000000..4085260 --- /dev/null +++ b/tests/domainsnapshotxml2xmlin/disk_snapshot_mirror.xml @@ -0,0 +1,13 @@ +<domainsnapshot> + <name>my snap name</name> + <description>!@#$%^</description> + <disks> + <disk name='hda' snapshot='external'> + <source file='/path/to/new'/> + <mirror file='/path/to/other'/> + </disk> + <disk name='hdb'> + <mirror file='/path/to/other2'/> + </disk> + </disks> +</domainsnapshot> diff --git a/tests/domainsnapshotxml2xmlout/disk_snapshot_mirror.xml b/tests/domainsnapshotxml2xmlout/disk_snapshot_mirror.xml new file mode 100644 index 0000000..c99fd5b --- /dev/null +++ b/tests/domainsnapshotxml2xmlout/disk_snapshot_mirror.xml @@ -0,0 +1,49 @@ +<domainsnapshot> + <name>my snap name</name> + <description>!@#$%^</description> + <state>disk-snapshot</state> + <creationTime>1272917631</creationTime> + <disks> + <disk name='hda' snapshot='external'> + <driver type='qcow2'/> + <source file='/path/to/new'/> + <mirror file='/path/to/other'/> + </disk> + <disk name='hdb' snapshot='external'> + <driver type='qcow2'/> + <source file='/path/to/generated'/> + <mirror file='/path/to/other2'/> + </disk> + </disks> + <domain type='qemu'> + <name>QEMUGuest1</name> + <uuid>c7a5fdbd-edaf-9455-926a-d65c16db1809</uuid> + <memory unit='KiB'>219100</memory> + <currentMemory unit='KiB'>219100</currentMemory> + <vcpu placement='static' cpuset='1-4,8-20,525'>1</vcpu> + <os> + <type arch='i686' machine='pc'>hvm</type> + <boot dev='hd'/> + </os> + <clock offset='utc'/> + <on_poweroff>destroy</on_poweroff> + <on_reboot>restart</on_reboot> + <on_crash>destroy</on_crash> + <devices> + <emulator>/usr/bin/qemu</emulator> + <disk type='block' device='disk'> + <source dev='/dev/HostVG/QEMUGuest1'/> + <target dev='hda' bus='ide'/> + <address type='drive' controller='0' bus='0' target='0' unit='0'/> + </disk> + <disk type='block' device='disk'> + <source dev='/dev/HostVG/QEMUGuest2'/> + <target dev='hdb' bus='ide'/> + <address type='drive' controller='0' bus='1' target='0' unit='0'/> + </disk> + <controller type='usb' index='0'/> + <controller type='ide' index='0'/> + <memballoon model='virtio'/> + </devices> + </domain> +</domainsnapshot> diff --git a/tests/domainsnapshotxml2xmltest.c b/tests/domainsnapshotxml2xmltest.c index 978a2d4..f706b8b 100644 --- a/tests/domainsnapshotxml2xmltest.c +++ b/tests/domainsnapshotxml2xmltest.c @@ -26,7 +26,8 @@ testCompareXMLToXMLFiles(const char *inxml, const char *uuid, int internal) int ret = -1; virDomainSnapshotDefPtr def = NULL; unsigned int flags = (VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE | - VIR_DOMAIN_SNAPSHOT_PARSE_DISKS); + VIR_DOMAIN_SNAPSHOT_PARSE_DISKS | + VIR_DOMAIN_SNAPSHOT_PARSE_MIRROR); if (virtTestLoadFile(inxml, &inXmlData) < 0) goto fail; @@ -105,6 +106,7 @@ mymain(void) DO_TEST("all_parameters", "9d37b878-a7cc-9f9a-b78f-49b3abad25a8", 1); DO_TEST("disk_snapshot", "c7a5fdbd-edaf-9455-926a-d65c16db1809", 1); + DO_TEST("disk_snapshot_mirror", "c7a5fdbd-edaf-9455-926a-d65c16db1809", 0); DO_TEST("full_domain", "c7a5fdbd-edaf-9455-926a-d65c16db1809", 1); DO_TEST("noparent_nodescription_noactive", NULL, 0); DO_TEST("noparent_nodescription", NULL, 1); -- 1.7.7.6

For now, disk migration via mirroring is not implemented. But when we do implement it, we have to deal with the fact that qemu does not provide an easy way to re-start a qemu process with mirroring still intact (it _might_ be possible by using qemu -S then an initial 'drive-mirror' with disk reuse before starting the domain, but that gets hairy). Even something like 'virDomainSave' becomes hairy, if you realize the implications that 'virDomainRestore' would be stuck with recreating the same mirror layout. But if we step back and look at the bigger picture, we realize that the initial client of live storage migration via disk mirroring is oVirt, which always uses transient domains, and that if a transient domain is destroyed while a mirror exists, oVirt can easily restart the storage migration by creating a new domain that visits just the source storage, with no loss in data. We can make life a lot easier by being cowards, and forbidding certain operations on a domain. This patch guarantees that there will be at most one snapshot with disk mirroring, that it will always be the current snapshot, and that the user cannot redefine that snapshot nor hot-plug or hot-unplug any domain disks - for now, the only way to delete such a snapshot is by destroying the transient domain it is attached to. A future patch will add the ability to also delete such snapshots under a condition of a flag which says how to end the mirroring with the 'drive-reopen' monitor command; and once that is in place, then we can finally implement creation of the mirroring via 'drive-mirror'. With just this patch applied, the only way you can ever get virDomainHasDiskMirror to return true is by manually playing with the libvirt internal directory and then restarting libvirtd. * src/conf/domain_conf.h (virDomainSnapshotHasDiskMirror) (virDomainHasDiskMirror): New prototypes. * src/conf/domain_conf.c (virDomainSnapshotHasDiskMirror) (virDomainHasDiskMirror): Implement them. * src/libvirt_private.syms (domain_conf.h): Export them. * src/qemu/qemu_driver.c (qemuDomainSaveInternal) (qemuDomainSnapshotCreateXML, qemuDomainRevertToSnapshot) (qemuDomainSnapshotDelete, qemuDomainAttachDeviceDiskLive) (qemuDomainDetachDeviceDiskLive): Use it. (qemuDomainSnapshotLoad): Allow libvirtd restarts with active disk mirroring, but sanity check for only a current image with mirrors. --- src/conf/domain_conf.c | 20 +++++++++++++++++ src/conf/domain_conf.h | 2 + src/libvirt_private.syms | 2 + src/qemu/qemu_driver.c | 53 +++++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 76 insertions(+), 1 deletions(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index f84304c..85abf32 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -13652,6 +13652,26 @@ cleanup: return ret; } +/* Determine if the given snapshot contains a disk mirror. */ +bool +virDomainSnapshotHasDiskMirror(virDomainSnapshotDefPtr snapshot) +{ + int i; + for (i = 0; i < snapshot->ndisks; i++) + if (snapshot->disks[i].mirror) + return true; + return false; +} + +/* Determine if the given domain has a current snapshot that contains + * a disk mirror. */ +bool virDomainHasDiskMirror(virDomainObjPtr vm) +{ + if (!vm->current_snapshot) + return false; + return virDomainSnapshotHasDiskMirror(vm->current_snapshot->def); +} + char *virDomainSnapshotDefFormat(const char *domain_uuid, virDomainSnapshotDefPtr def, unsigned int flags, diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index 01a504b..1ea7332 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -1706,6 +1706,7 @@ char *virDomainSnapshotDefFormat(const char *domain_uuid, int virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr snapshot, int default_snapshot, bool require_match); +bool virDomainSnapshotHasDiskMirror(virDomainSnapshotDefPtr snapshot); virDomainSnapshotObjPtr virDomainSnapshotAssignDef(virDomainSnapshotObjListPtr snapshots, const virDomainSnapshotDefPtr def); @@ -1931,6 +1932,7 @@ virDomainDiskDefPtr virDomainDiskRemove(virDomainDefPtr def, size_t i); virDomainDiskDefPtr virDomainDiskRemoveByName(virDomainDefPtr def, const char *name); +bool virDomainHasDiskMirror(virDomainObjPtr vm); int virDomainNetIndexByMac(virDomainDefPtr def, const unsigned char *mac); int virDomainNetInsert(virDomainDefPtr def, virDomainNetDefPtr net); diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 9a718b4..6739733 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -358,6 +358,7 @@ virDomainGraphicsSpiceZlibCompressionTypeFromString; virDomainGraphicsSpiceZlibCompressionTypeToString; virDomainGraphicsTypeFromString; virDomainGraphicsTypeToString; +virDomainHasDiskMirror; virDomainHostdevDefAlloc; virDomainHostdevDefClear; virDomainHostdevDefFree; @@ -450,6 +451,7 @@ virDomainSnapshotDropParent; virDomainSnapshotFindByName; virDomainSnapshotForEachChild; virDomainSnapshotForEachDescendant; +virDomainSnapshotHasDiskMirror; virDomainSnapshotObjListGetNames; virDomainSnapshotObjListGetNamesFrom; virDomainSnapshotObjListNum; diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 6dd1b32..89aa56c 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -320,7 +320,8 @@ static void qemuDomainSnapshotLoad(void *payload, char ebuf[1024]; unsigned int flags = (VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE | VIR_DOMAIN_SNAPSHOT_PARSE_DISKS | - VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL); + VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL | + VIR_DOMAIN_SNAPSHOT_PARSE_MIRROR); virDomainObjLock(vm); if (virAsprintf(&snapDir, "%s/%s", baseDir, vm->def->name) < 0) { @@ -373,6 +374,16 @@ static void qemuDomainSnapshotLoad(void *payload, VIR_FREE(xmlStr); continue; } + if (!def->current && virDomainSnapshotHasDiskMirror(def)) { + /* Someone must have hand-modified the directory; ignore them. */ + VIR_ERROR(_("Disk mirroring unexpected since snapshot file '%s' " + "does not claim to be the current snapshot"), + fullpath); + virDomainSnapshotDefFree(def); + VIR_FREE(fullpath); + VIR_FREE(xmlStr); + continue; + } snap = virDomainSnapshotAssignDef(&vm->snapshots, def); if (snap == NULL) { @@ -2536,6 +2547,11 @@ qemuDomainSaveInternal(struct qemud_driver *driver, virDomainPtr dom, "%s", _("domain is marked for auto destroy")); goto cleanup; } + if (virDomainHasDiskMirror(vm)) { + qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain has active disk mirrors")); + goto cleanup; + } memset(&header, 0, sizeof(header)); memcpy(header.magic, QEMUD_SAVE_PARTIAL, sizeof(header.magic)); @@ -5067,6 +5083,12 @@ qemuDomainAttachDeviceDiskLive(virConnectPtr conn, virCgroupPtr cgroup = NULL; int ret = -1; + if (virDomainHasDiskMirror(vm)) { + qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain has active disk mirrors")); + goto end; + } + if (disk->driverName != NULL && !STREQ(disk->driverName, "qemu")) { qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("unsupported driver name '%s' for disk '%s'"), @@ -5217,6 +5239,12 @@ qemuDomainDetachDeviceDiskLive(struct qemud_driver *driver, virDomainDiskDefPtr disk = dev->data.disk; int ret = -1; + if (virDomainHasDiskMirror(vm)) { + qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain has active disk mirrors")); + return -1; + } + switch (disk->device) { case VIR_DOMAIN_DISK_DEVICE_DISK: case VIR_DOMAIN_DISK_DEVICE_LUN: @@ -10239,6 +10267,12 @@ qemuDomainSnapshotCreateXML(virDomainPtr domain, "%s", _("domain is marked for auto destroy")); goto cleanup; } + if (virDomainHasDiskMirror(vm)) { + qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain has active disk mirrors")); + goto cleanup; + } + if (!vm->persistent && (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT)) { qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", _("cannot halt after transient domain snapshot")); @@ -10847,6 +10881,12 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, goto cleanup; } + if (virDomainHasDiskMirror(vm)) { + qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain has active disk mirrors")); + goto cleanup; + } + snap = virDomainSnapshotFindByName(&vm->snapshots, snapshot->name); if (!snap) { qemuReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT, @@ -11216,6 +11256,17 @@ static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot, goto cleanup; } + if (virDomainHasDiskMirror(vm)) { + if (snap != vm->current_snapshot) { + qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain has active disk mirrors")); + goto cleanup; + } + qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("deletion of active disk mirrors unimplemented")); + goto cleanup; + } + if (!(flags & VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY)) { if (!(flags & VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY) && snap->def->state == VIR_DOMAIN_DISK_SNAPSHOT) -- 1.7.7.6

Delete a mirrored snapshot by picking which of the two files in the mirror to reopen. This is not atomic, so we update the snapshot in place as we iterate through each successful disk. Since we limited mirrored snapshots to transient domains, there is no persistent configuration to update. This mode implies deleting the snapshot metadata but preserving the new file. * src/qemu/qemu_driver.c (qemuDomainSnapshotDelete): Honor new flags. (qemuDomainSnapshotDeleteMirror): New helper function. --- src/qemu/qemu_driver.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 73 insertions(+), 2 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 89aa56c..428ba0f 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -11222,6 +11222,61 @@ qemuDomainSnapshotReparentChildren(void *payload, rep->driver->snapshotDir); } +/* Must be called while holding a job. */ +static int +qemuDomainSnapshotDeleteMirror(struct qemud_driver *driver, + virDomainObjPtr vm, + virDomainSnapshotObjPtr snap, + bool pivot) +{ + int i; + int ret = 0; + qemuDomainObjPrivatePtr priv = vm->privateData; + char *device = NULL; + char *file; + + if (!virDomainObjIsActive(vm)) { + qemuReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + return -1; + } + + qemuDomainObjEnterMonitorWithDriver(driver, vm); + + for (i = 0; i < snap->def->ndisks; i++) { + if (!snap->def->disks[i].mirror) + continue; + VIR_FREE(device); + if (virAsprintf(&device, "drive-%s", + vm->def->disks[i]->info.alias) < 0) { + virReportOOMError(); + break; + } + file = pivot ? snap->def->disks[i].mirror : snap->def->disks[i].file; + if (qemuMonitorDriveReopen(priv->mon, device, file, + snap->def->disks[i].driverType) < 0) + break; + /* TODO: Release lock and reset label. */ + + VIR_FREE(vm->def->disks[i]->src); + vm->def->disks[i]->src = file; + if (pivot) + snap->def->disks[i].file = snap->def->disks[i].mirror; + snap->def->disks[i].mirror = NULL; + } + VIR_FREE(device); + if (i < snap->def->ndisks) + ret = -1; + + qemuDomainObjExitMonitorWithDriver(driver, vm); + + if (ret < 0 && + qemuDomainSnapshotWriteMetadata(vm, snap, driver->snapshotDir) < 0) + VIR_WARN("failed writing snapshot '%s' after partial mirror deletion", + snap->def->name); + return ret; +} + static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot, unsigned int flags) { @@ -11234,10 +11289,14 @@ static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot, struct snap_reparent rep; bool metadata_only = !!(flags & VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY); int external = 0; + bool mirror_abort = (flags & VIR_DOMAIN_SNAPSHOT_DELETE_MIRROR_ABORT) != 0; + bool mirror_pivot = (flags & VIR_DOMAIN_SNAPSHOT_DELETE_MIRROR_PIVOT) != 0; virCheckFlags(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN | VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY | - VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY, -1); + VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY | + VIR_DOMAIN_SNAPSHOT_DELETE_MIRROR_ABORT | + VIR_DOMAIN_SNAPSHOT_DELETE_MIRROR_PIVOT, -1); qemuDriverLock(driver); virUUIDFormat(snapshot->domain->uuid, uuidstr); @@ -11262,8 +11321,16 @@ static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot, _("domain has active disk mirrors")); goto cleanup; } + if (!(mirror_abort || mirror_pivot)) { + qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("must specify whether to abort or pivot " + "mirrors before deleting snapshot")); + goto cleanup; + } + flags |= VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY; + } else if (mirror_abort || mirror_pivot) { qemuReportError(VIR_ERR_OPERATION_INVALID, "%s", - _("deletion of active disk mirrors unimplemented")); + _("snapshot has no disk mirrors")); goto cleanup; } @@ -11286,6 +11353,10 @@ static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot, if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0) goto cleanup; + if ((mirror_abort || mirror_pivot) && + qemuDomainSnapshotDeleteMirror(driver, vm, snap, mirror_pivot) < 0) + goto endjob; + if (flags & (VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN | VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY)) { rem.driver = driver; -- 1.7.7.6