We've dumped all the snapshot helpers and related code into
qemu_driver.c. It accounted for ~10% of overal size of qemu_driver.c.
Separate the code to qemu_snapshot.c/h.
Signed-off-by: Peter Krempa <pkrempa@xxxxxxxxxx>
---
po/POTFILES.in | 1 +
src/qemu/meson.build | 1 +
src/qemu/qemu_driver.c | 2487 +++-----------------------------------
src/qemu/qemu_snapshot.c | 2266 ++++++++++++++++++++++++++++++++++
src/qemu/qemu_snapshot.h | 55 +
5 files changed, 2475 insertions(+), 2335 deletions(-)
create mode 100644 src/qemu/qemu_snapshot.c
create mode 100644 src/qemu/qemu_snapshot.h
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 6f47371b01..3d6c20c55f 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -172,6 +172,7 @@
@SRCDIR@src/qemu/qemu_qapi.c
@SRCDIR@src/qemu/qemu_saveimage.c
@SRCDIR@src/qemu/qemu_slirp.c
+@SRCDIR@src/qemu/qemu_snapshot.c
@SRCDIR@src/qemu/qemu_tpm.c
@SRCDIR@src/qemu/qemu_validate.c
@SRCDIR@src/qemu/qemu_vhost_user.c
diff --git a/src/qemu/meson.build b/src/qemu/meson.build
index 7d5249978a..85d020465f 100644
--- a/src/qemu/meson.build
+++ b/src/qemu/meson.build
@@ -31,6 +31,7 @@ qemu_driver_sources = [
'qemu_qapi.c',
'qemu_saveimage.c',
'qemu_security.c',
+ 'qemu_snapshot.c',
'qemu_slirp.c',
'qemu_tpm.c',
'qemu_validate.c',
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index a6b8c79168..bc2879dee4 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -52,6 +52,7 @@
#include "qemu_backup.h"
#include "qemu_namespace.h"
#include "qemu_saveimage.h"
+#include "qemu_snapshot.h"
#include "virerror.h"
#include "virlog.h"
@@ -171,29 +172,6 @@ qemuDomObjFromSnapshot(virDomainSnapshotPtr snapshot)
}
-/* Looks up snapshot object from VM and name */
-static virDomainMomentObjPtr
-qemuSnapObjFromName(virDomainObjPtr vm,
- const char *name)
-{
- virDomainMomentObjPtr snap = NULL;
- snap = virDomainSnapshotFindByName(vm->snapshots, name);
- if (!snap)
- virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
- _("no domain snapshot with matching name '%s'"),
- name);
-
- return snap;
-}
-
-
-/* Looks up snapshot object from VM and snapshotPtr */
-static virDomainMomentObjPtr
-qemuSnapObjFromSnapshot(virDomainObjPtr vm,
- virDomainSnapshotPtr snapshot)
-{
- return qemuSnapObjFromName(vm, snapshot->name);
-}
static int
@@ -2218,20 +2196,6 @@ qemuDomainReset(virDomainPtr dom, unsigned int flags)
}
-/* Count how many snapshots in a set are external snapshots. */
-static int
-qemuDomainSnapshotCountExternal(void *payload,
- const void *name G_GNUC_UNUSED,
- void *data)
-{
- virDomainMomentObjPtr snap = payload;
- int *count = data;
-
- if (virDomainSnapshotIsExternal(snap))
- (*count)++;
- return 0;
-}
-
static int
qemuDomainDestroyFlags(virDomainPtr dom,
unsigned int flags)
@@ -13353,1820 +13317,230 @@ qemuDomainMigrateStartPostCopy(virDomainPtr dom,
}
-/* Return -1 if request is not sent to agent due to misconfig, -2 if request
- * is sent but failed, and number of frozen filesystems on success. If -2 is
- * returned, FSThaw should be called revert the quiesced status. */
-static int
-qemuDomainSnapshotFSFreeze(virDomainObjPtr vm,
- const char **mountpoints,
- unsigned int nmountpoints)
+static virDomainSnapshotPtr
+qemuDomainSnapshotCreateXML(virDomainPtr domain,
+ const char *xmlDesc,
+ unsigned int flags)
{
- qemuAgentPtr agent;
- int frozen;
+ virDomainObjPtr vm = NULL;
+ virDomainSnapshotPtr snapshot = NULL;
- if (!qemuDomainAgentAvailable(vm, true))
- return -1;
+ if (!(vm = qemuDomainObjFromDomain(domain)))
+ goto cleanup;
- agent = qemuDomainObjEnterAgent(vm);
- frozen = qemuAgentFSFreeze(agent, mountpoints, nmountpoints);
- qemuDomainObjExitAgent(vm, agent);
- return frozen < 0 ? -2 : frozen;
+ if (virDomainSnapshotCreateXMLEnsureACL(domain->conn, vm->def, flags) < 0)
+ goto cleanup;
+
+ snapshot = qemuSnapshotCreateXML(domain, vm, xmlDesc, flags);
+
+ cleanup:
+ virDomainObjEndAPI(&vm);
+ return snapshot;
}
-/* Return -1 on error, otherwise number of thawed filesystems. */
static int
-qemuDomainSnapshotFSThaw(virDomainObjPtr vm,
- bool report)
+qemuDomainSnapshotListNames(virDomainPtr domain,
+ char **names,
+ int nameslen,
+ unsigned int flags)
{
- qemuAgentPtr agent;
- int thawed;
- virErrorPtr err = NULL;
+ virDomainObjPtr vm = NULL;
+ int n = -1;
+
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
+ VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
+ VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
- if (!qemuDomainAgentAvailable(vm, report))
+ if (!(vm = qemuDomainObjFromDomain(domain)))
return -1;
- agent = qemuDomainObjEnterAgent(vm);
- if (!report)
- virErrorPreserveLast(&err);
- thawed = qemuAgentFSThaw(agent);
- qemuDomainObjExitAgent(vm, agent);
+ if (virDomainSnapshotListNamesEnsureACL(domain->conn, vm->def) < 0)
+ goto cleanup;
- virErrorRestore(&err);
+ n = virDomainSnapshotObjListGetNames(vm->snapshots, NULL, names, nameslen,
+ flags);
- return thawed;
+ cleanup:
+ virDomainObjEndAPI(&vm);
+ return n;
}
-/* The domain is expected to be locked and inactive. */
static int
-qemuDomainSnapshotCreateInactiveInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap)
+qemuDomainSnapshotNum(virDomainPtr domain,
+ unsigned int flags)
{
- return qemuDomainSnapshotForEachQcow2(driver, vm, snap, "-c", false);
-}
-
+ virDomainObjPtr vm = NULL;
+ int n = -1;
-/* The domain is expected to be locked and inactive. */
-static int
-qemuDomainSnapshotCreateInactiveExternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
- bool reuse)
-{
- size_t i;
- virDomainSnapshotDiskDefPtr snapdisk;
- virDomainDiskDefPtr defdisk;
- virCommandPtr cmd = NULL;
- const char *qemuImgPath;
- virBitmapPtr created = NULL;
- g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- int ret = -1;
- g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
+ VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
+ VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
- if (!(qemuImgPath = qemuFindQemuImgBinary(driver)))
- goto cleanup;
+ if (!(vm = qemuDomainObjFromDomain(domain)))
+ return -1;
- if (!(created = virBitmapNew(snapdef->ndisks)))
+ if (virDomainSnapshotNumEnsureACL(domain->conn, vm->def) < 0)
goto cleanup;
- /* If reuse is true, then qemuDomainSnapshotPrepare already
- * ensured that the new files exist, and it was up to the user to
- * create them correctly. */
- for (i = 0; i < snapdef->ndisks && !reuse; i++) {
- snapdisk = &(snapdef->disks[i]);
- defdisk = snapdef->parent.dom->disks[snapdisk->idx];
- if (snapdisk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)
- continue;
-
- if (!snapdisk->src->format)
- snapdisk->src->format = VIR_STORAGE_FILE_QCOW2;
-
- if (qemuDomainStorageSourceValidateDepth(defdisk->src, 1, defdisk->dst) < 0)
- goto cleanup;
+ n = virDomainSnapshotObjListNum(vm->snapshots, NULL, flags);
- /* creates cmd line args: qemu-img create -f qcow2 -o */
- if (!(cmd = virCommandNewArgList(qemuImgPath,
- "create",
- "-f",
- virStorageFileFormatTypeToString(snapdisk->src->format),
- "-o",
- NULL)))
- goto cleanup;
+ cleanup:
+ virDomainObjEndAPI(&vm);
+ return n;
+}
- /* adds cmd line arg: backing_fmt=format,backing_file=/path/to/backing/file */
- virBufferAsprintf(&buf, "backing_fmt=%s,backing_file=",
- virStorageFileFormatTypeToString(defdisk->src->format));
- virQEMUBuildBufferEscapeComma(&buf, defdisk->src->path);
- virCommandAddArgBuffer(cmd, &buf);
- /* adds cmd line args: /path/to/target/file */
- virQEMUBuildBufferEscapeComma(&buf, snapdisk->src->path);
- virCommandAddArgBuffer(cmd, &buf);
+static int
+qemuDomainListAllSnapshots(virDomainPtr domain,
+ virDomainSnapshotPtr **snaps,
+ unsigned int flags)
+{
+ virDomainObjPtr vm = NULL;
+ int n = -1;
- /* If the target does not exist, we're going to create it possibly */
- if (!virFileExists(snapdisk->src->path))
- ignore_value(virBitmapSetBit(created, i));
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
+ VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
+ VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
- if (virCommandRun(cmd, NULL) < 0)
- goto cleanup;
+ if (!(vm = qemuDomainObjFromDomain(domain)))
+ return -1;
- virCommandFree(cmd);
- cmd = NULL;
- }
+ if (virDomainListAllSnapshotsEnsureACL(domain->conn, vm->def) < 0)
+ goto cleanup;
- /* update disk definitions */
- for (i = 0; i < snapdef->ndisks; i++) {
- g_autoptr(virStorageSource) newsrc = NULL;
+ n = virDomainListSnapshots(vm->snapshots, NULL, domain, snaps, flags);
- snapdisk = &(snapdef->disks[i]);
- defdisk = vm->def->disks[snapdisk->idx];
+ cleanup:
+ virDomainObjEndAPI(&vm);
+ return n;
+}
- if (snapdisk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)
- continue;
- if (!(newsrc = virStorageSourceCopy(snapdisk->src, false)))
- goto cleanup;
+static int
+qemuDomainSnapshotListChildrenNames(virDomainSnapshotPtr snapshot,
+ char **names,
+ int nameslen,
+ unsigned int flags)
+{
+ virDomainObjPtr vm = NULL;
+ virDomainMomentObjPtr snap = NULL;
+ int n = -1;
- if (virStorageSourceInitChainElement(newsrc, defdisk->src, false) < 0)
- goto cleanup;
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
+ VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
+ VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
- if (!reuse &&
- virStorageSourceHasBacking(defdisk->src)) {
- defdisk->src->readonly = true;
- newsrc->backingStore = g_steal_pointer(&defdisk->src);
- } else {
- virObjectUnref(defdisk->src);
- }
+ if (!(vm = qemuDomObjFromSnapshot(snapshot)))
+ return -1;
- defdisk->src = g_steal_pointer(&newsrc);
- }
+ if (virDomainSnapshotListChildrenNamesEnsureACL(snapshot->domain->conn, vm->def) < 0)
+ goto cleanup;
- if (virDomainDefSave(vm->def, driver->xmlopt, cfg->configDir) < 0)
+ if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
goto cleanup;
- ret = 0;
+ n = virDomainSnapshotObjListGetNames(vm->snapshots, snap, names, nameslen,
+ flags);
cleanup:
- virCommandFree(cmd);
-
- /* unlink images if creation has failed */
- if (ret < 0 && created) {
- ssize_t bit = -1;
- while ((bit = virBitmapNextSetBit(created, bit)) >= 0) {
- snapdisk = &(snapdef->disks[bit]);
- if (unlink(snapdisk->src->path) < 0)
- VIR_WARN("Failed to remove snapshot image '%s'",
- snapdisk->src->path);
- }
- }
- virBitmapFree(created);
-
- return ret;
+ virDomainObjEndAPI(&vm);
+ return n;
}
-/* The domain is expected to be locked and active. */
static int
-qemuDomainSnapshotCreateActiveInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
- unsigned int flags)
+qemuDomainSnapshotNumChildren(virDomainSnapshotPtr snapshot,
+ unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virObjectEventPtr event = NULL;
- bool resume = false;
- virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
- int ret = -1;
-
- if (!qemuMigrationSrcIsAllowed(driver, vm, false, 0))
- goto cleanup;
-
- if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
- /* savevm monitor command pauses the domain emitting an event which
- * confuses libvirt since it's not notified when qemu resumes the
- * domain. Thus we stop and start CPUs ourselves.
- */
- if (qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_SAVE,
- QEMU_ASYNC_JOB_SNAPSHOT) < 0)
- goto cleanup;
+ virDomainObjPtr vm = NULL;
+ virDomainMomentObjPtr snap = NULL;
+ int n = -1;
- resume = true;
- if (!virDomainObjIsActive(vm)) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("guest unexpectedly quit"));
- goto cleanup;
- }
- }
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
+ VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
+ VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
- QEMU_ASYNC_JOB_SNAPSHOT) < 0) {
- resume = false;
- goto cleanup;
- }
+ if (!(vm = qemuDomObjFromSnapshot(snapshot)))
+ return -1;
- ret = qemuMonitorCreateSnapshot(priv->mon, snap->def->name);
- if (qemuDomainObjExitMonitor(driver, vm) < 0)
- ret = -1;
- if (ret < 0)
+ if (virDomainSnapshotNumChildrenEnsureACL(snapshot->domain->conn, vm->def) < 0)
goto cleanup;
- if (!(snapdef->cookie = (virObjectPtr) qemuDomainSaveCookieNew(vm)))
+ if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
goto cleanup;
- if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) {
- event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED,
- VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT);
- qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT,
- QEMU_ASYNC_JOB_SNAPSHOT, 0);
- virDomainAuditStop(vm, "from-snapshot");
- resume = false;
- }
+ n = virDomainSnapshotObjListNum(vm->snapshots, snap, flags);
cleanup:
- if (resume && virDomainObjIsActive(vm) &&
- qemuProcessStartCPUs(driver, vm,
- VIR_DOMAIN_RUNNING_UNPAUSED,
- QEMU_ASYNC_JOB_SNAPSHOT) < 0) {
- event = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_SUSPENDED,
- VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR);
- if (virGetLastErrorCode() == VIR_ERR_OK) {
- virReportError(VIR_ERR_OPERATION_FAILED, "%s",
- _("resuming after snapshot failed"));
- }
- }
-
- virObjectEventStateQueue(driver->domainEventState, event);
-
- return ret;
+ virDomainObjEndAPI(&vm);
+ return n;
}
static int
-qemuDomainSnapshotPrepareDiskShared(virDomainSnapshotDiskDefPtr snapdisk,
- virDomainDiskDefPtr domdisk)
+qemuDomainSnapshotListAllChildren(virDomainSnapshotPtr snapshot,
+ virDomainSnapshotPtr **snaps,
+ unsigned int flags)
{
- if (!domdisk->src->shared || domdisk->src->readonly)
- return 0;
+ virDomainObjPtr vm = NULL;
+ virDomainMomentObjPtr snap = NULL;
+ int n = -1;
- if (!qemuBlockStorageSourceSupportsConcurrentAccess(snapdisk->src)) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("shared access for disk '%s' requires use of "
- "supported storage format"), domdisk->dst);
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
+ VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
+ VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
+
+ if (!(vm = qemuDomObjFromSnapshot(snapshot)))
return -1;
- }
- return 0;
+ if (virDomainSnapshotListAllChildrenEnsureACL(snapshot->domain->conn, vm->def) < 0)
+ goto cleanup;
+
+ if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
+ goto cleanup;
+
+ n = virDomainListSnapshots(vm->snapshots, snap, snapshot->domain, snaps,
+ flags);
+
+ cleanup:
+ virDomainObjEndAPI(&vm);
+ return n;
}
-static int
-qemuDomainSnapshotPrepareDiskExternalInactive(virDomainSnapshotDiskDefPtr snapdisk,
- virDomainDiskDefPtr domdisk)
+static virDomainSnapshotPtr
+qemuDomainSnapshotLookupByName(virDomainPtr domain,
+ const char *name,
+ unsigned int flags)
{
- int domDiskType = virStorageSourceGetActualType(domdisk->src);
- int snapDiskType = virStorageSourceGetActualType(snapdisk->src);
-
- switch ((virStorageType)domDiskType) {
- case VIR_STORAGE_TYPE_BLOCK:
- case VIR_STORAGE_TYPE_FILE:
- break;
+ virDomainObjPtr vm;
+ virDomainMomentObjPtr snap = NULL;
+ virDomainSnapshotPtr snapshot = NULL;
- case VIR_STORAGE_TYPE_NETWORK:
- switch ((virStorageNetProtocol) domdisk->src->protocol) {
- case VIR_STORAGE_NET_PROTOCOL_NONE:
- case VIR_STORAGE_NET_PROTOCOL_NBD:
- case VIR_STORAGE_NET_PROTOCOL_RBD:
- case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
- case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
- case VIR_STORAGE_NET_PROTOCOL_ISCSI:
- case VIR_STORAGE_NET_PROTOCOL_HTTP:
- case VIR_STORAGE_NET_PROTOCOL_HTTPS:
- case VIR_STORAGE_NET_PROTOCOL_FTP:
- case VIR_STORAGE_NET_PROTOCOL_FTPS:
- case VIR_STORAGE_NET_PROTOCOL_TFTP:
- case VIR_STORAGE_NET_PROTOCOL_SSH:
- case VIR_STORAGE_NET_PROTOCOL_VXHS:
- case VIR_STORAGE_NET_PROTOCOL_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("external inactive snapshots are not supported on "
- "'network' disks using '%s' protocol"),
- virStorageNetProtocolTypeToString(domdisk->src->protocol));
- return -1;
- }
- break;
+ virCheckFlags(0, NULL);
- case VIR_STORAGE_TYPE_DIR:
- case VIR_STORAGE_TYPE_VOLUME:
- case VIR_STORAGE_TYPE_NVME:
- case VIR_STORAGE_TYPE_NONE:
- case VIR_STORAGE_TYPE_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("external inactive snapshots are not supported on "
- "'%s' disks"), virStorageTypeToString(domDiskType));
- return -1;
- }
+ if (!(vm = qemuDomainObjFromDomain(domain)))
+ return NULL;
- switch ((virStorageType)snapDiskType) {
- case VIR_STORAGE_TYPE_BLOCK:
- case VIR_STORAGE_TYPE_FILE:
- break;
+ if (virDomainSnapshotLookupByNameEnsureACL(domain->conn, vm->def) < 0)
+ goto cleanup;
- case VIR_STORAGE_TYPE_NETWORK:
- case VIR_STORAGE_TYPE_DIR:
- case VIR_STORAGE_TYPE_VOLUME:
- case VIR_STORAGE_TYPE_NVME:
- case VIR_STORAGE_TYPE_NONE:
- case VIR_STORAGE_TYPE_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("external inactive snapshots are not supported on "
- "'%s' disks"), virStorageTypeToString(snapDiskType));
- return -1;
- }
+ if (!(snap = qemuSnapObjFromName(vm, name)))
+ goto cleanup;
- if (qemuDomainSnapshotPrepareDiskShared(snapdisk, domdisk) < 0)
- return -1;
+ snapshot = virGetDomainSnapshot(domain, snap->def->name);
- return 0;
+ cleanup:
+ virDomainObjEndAPI(&vm);
+ return snapshot;
}
static int
-qemuDomainSnapshotPrepareDiskExternalActive(virDomainObjPtr vm,
- virDomainSnapshotDiskDefPtr snapdisk,
- virDomainDiskDefPtr domdisk,
- bool blockdev)
-{
- int actualType = virStorageSourceGetActualType(snapdisk->src);
-
- if (domdisk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- _("external active snapshots are not supported on scsi "
- "passthrough devices"));
- return -1;
- }
-
- if (!qemuDomainDiskBlockJobIsSupported(vm, domdisk))
- return -1;
-
- switch ((virStorageType)actualType) {
- case VIR_STORAGE_TYPE_BLOCK:
- case VIR_STORAGE_TYPE_FILE:
- break;
-
- case VIR_STORAGE_TYPE_NETWORK:
- /* defer all of the checking to either qemu or libvirt's blockdev code */
- if (blockdev)
- break;
-
- switch ((virStorageNetProtocol) snapdisk->src->protocol) {
- case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
- break;
-
- case VIR_STORAGE_NET_PROTOCOL_NONE:
- case VIR_STORAGE_NET_PROTOCOL_NBD:
- case VIR_STORAGE_NET_PROTOCOL_RBD:
- case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
- case VIR_STORAGE_NET_PROTOCOL_ISCSI:
- case VIR_STORAGE_NET_PROTOCOL_HTTP:
- case VIR_STORAGE_NET_PROTOCOL_HTTPS:
- case VIR_STORAGE_NET_PROTOCOL_FTP:
- case VIR_STORAGE_NET_PROTOCOL_FTPS:
- case VIR_STORAGE_NET_PROTOCOL_TFTP:
- case VIR_STORAGE_NET_PROTOCOL_SSH:
- case VIR_STORAGE_NET_PROTOCOL_VXHS:
- case VIR_STORAGE_NET_PROTOCOL_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("external active snapshots are not supported on "
- "'network' disks using '%s' protocol"),
- virStorageNetProtocolTypeToString(snapdisk->src->protocol));
- return -1;
-
- }
- break;
-
- case VIR_STORAGE_TYPE_DIR:
- case VIR_STORAGE_TYPE_VOLUME:
- case VIR_STORAGE_TYPE_NVME:
- case VIR_STORAGE_TYPE_NONE:
- case VIR_STORAGE_TYPE_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("external active snapshots are not supported on "
- "'%s' disks"), virStorageTypeToString(actualType));
- return -1;
- }
-
- if (qemuDomainSnapshotPrepareDiskShared(snapdisk, domdisk) < 0)
- return -1;
-
- return 0;
-}
-
-
-static int
-qemuDomainSnapshotPrepareDiskExternal(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virDomainSnapshotDiskDefPtr snapdisk,
- bool active,
- bool reuse,
- bool blockdev)
-{
- struct stat st;
- int err;
- int rc;
-
- if (disk->src->readonly && !(reuse || blockdev)) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("external snapshot for readonly disk %s "
- "is not supported"), disk->dst);
- return -1;
- }
-
- if (qemuTranslateSnapshotDiskSourcePool(snapdisk) < 0)
- return -1;
-
- if (!active) {
- if (virDomainDiskTranslateSourcePool(disk) < 0)
- return -1;
-
- if (qemuDomainSnapshotPrepareDiskExternalInactive(snapdisk, disk) < 0)
- return -1;
- } else {
- if (qemuDomainSnapshotPrepareDiskExternalActive(vm, snapdisk, disk, blockdev) < 0)
- return -1;
- }
-
- if (virStorageSourceIsLocalStorage(snapdisk->src)) {
- if (virStorageFileInit(snapdisk->src) < 0)
- return -1;
-
- rc = virStorageFileStat(snapdisk->src, &st);
- err = errno;
-
- virStorageFileDeinit(snapdisk->src);
-
- if (rc < 0) {
- if (err != ENOENT) {
- virReportSystemError(err,
- _("unable to stat for disk %s: %s"),
- snapdisk->name, snapdisk->src->path);
- return -1;
- } else if (reuse) {
- virReportSystemError(err,
- _("missing existing file for disk %s: %s"),
- snapdisk->name, snapdisk->src->path);
- return -1;
- }
- } else if (!S_ISBLK(st.st_mode) && st.st_size && !reuse) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("external snapshot file for disk %s already "
- "exists and is not a block device: %s"),
- snapdisk->name, snapdisk->src->path);
- return -1;
- }
- }
-
- return 0;
-}
-
-
-static int
-qemuDomainSnapshotPrepareDiskInternal(virDomainDiskDefPtr disk,
- bool active)
-{
- int actualType;
-
- /* active disks are handled by qemu itself so no need to worry about those */
- if (active)
- return 0;
-
- if (virDomainDiskTranslateSourcePool(disk) < 0)
- return -1;
-
- actualType = virStorageSourceGetActualType(disk->src);
-
- switch ((virStorageType)actualType) {
- case VIR_STORAGE_TYPE_BLOCK:
- case VIR_STORAGE_TYPE_FILE:
- return 0;
-
- case VIR_STORAGE_TYPE_NETWORK:
- switch ((virStorageNetProtocol) disk->src->protocol) {
- case VIR_STORAGE_NET_PROTOCOL_NONE:
- case VIR_STORAGE_NET_PROTOCOL_NBD:
- case VIR_STORAGE_NET_PROTOCOL_RBD:
- case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
- case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
- case VIR_STORAGE_NET_PROTOCOL_ISCSI:
- case VIR_STORAGE_NET_PROTOCOL_HTTP:
- case VIR_STORAGE_NET_PROTOCOL_HTTPS:
- case VIR_STORAGE_NET_PROTOCOL_FTP:
- case VIR_STORAGE_NET_PROTOCOL_FTPS:
- case VIR_STORAGE_NET_PROTOCOL_TFTP:
- case VIR_STORAGE_NET_PROTOCOL_SSH:
- case VIR_STORAGE_NET_PROTOCOL_VXHS:
- case VIR_STORAGE_NET_PROTOCOL_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("internal inactive snapshots are not supported on "
- "'network' disks using '%s' protocol"),
- virStorageNetProtocolTypeToString(disk->src->protocol));
- return -1;
- }
- break;
-
- case VIR_STORAGE_TYPE_DIR:
- case VIR_STORAGE_TYPE_VOLUME:
- case VIR_STORAGE_TYPE_NVME:
- case VIR_STORAGE_TYPE_NONE:
- case VIR_STORAGE_TYPE_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("internal inactive snapshots are not supported on "
- "'%s' disks"), virStorageTypeToString(actualType));
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-qemuDomainSnapshotPrepare(virDomainObjPtr vm,
- virDomainSnapshotDefPtr def,
- unsigned int *flags)
-{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
- size_t i;
- bool active = virDomainObjIsActive(vm);
- bool reuse = (*flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
- bool found_internal = false;
- bool forbid_internal = false;
- int external = 0;
-
- for (i = 0; i < def->ndisks; i++) {
- virDomainSnapshotDiskDefPtr disk = &def->disks[i];
- virDomainDiskDefPtr dom_disk = vm->def->disks[i];
-
- if (disk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_NONE &&
- qemuDomainDiskBlockJobIsActive(dom_disk))
- return -1;
-
- switch ((virDomainSnapshotLocation) disk->snapshot) {
- case VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL:
- found_internal = true;
-
- if (def->state == VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT && active) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("active qemu domains require external disk "
- "snapshots; disk %s requested internal"),
- disk->name);
- return -1;
- }
-
- if (qemuDomainSnapshotPrepareDiskInternal(dom_disk,
- active) < 0)
- return -1;
-
- if (dom_disk->src->format > 0 &&
- dom_disk->src->format != VIR_STORAGE_FILE_QCOW2) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("internal snapshot for disk %s unsupported "
- "for storage type %s"),
- disk->name,
- virStorageFileFormatTypeToString(dom_disk->src->format));
- return -1;
- }
- break;
-
- case VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL:
- if (!disk->src->format) {
- disk->src->format = VIR_STORAGE_FILE_QCOW2;
- } else if (disk->src->format != VIR_STORAGE_FILE_QCOW2 &&
- disk->src->format != VIR_STORAGE_FILE_QED) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("external snapshot format for disk %s "
- "is unsupported: %s"),
- disk->name,
- virStorageFileFormatTypeToString(disk->src->format));
- return -1;
- }
-
- if (qemuDomainSnapshotPrepareDiskExternal(vm, dom_disk, disk,
- active, reuse, blockdev) < 0)
- return -1;
-
- external++;
- break;
-
- case VIR_DOMAIN_SNAPSHOT_LOCATION_NONE:
- /* Remember seeing a disk that has snapshot disabled */
- if (!virStorageSourceIsEmpty(dom_disk->src) &&
- !dom_disk->src->readonly)
- forbid_internal = true;
- break;
-
- case VIR_DOMAIN_SNAPSHOT_LOCATION_DEFAULT:
- case VIR_DOMAIN_SNAPSHOT_LOCATION_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("unexpected code path"));
- return -1;
- }
- }
-
- if (!found_internal && !external &&
- def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_NONE) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- _("nothing selected for snapshot"));
- return -1;
- }
-
- /* internal snapshot requires a disk image to store the memory image to, and
- * also disks can't be excluded from an internal snapshot */
- if ((def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL && !found_internal) ||
- (found_internal && forbid_internal)) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- _("internal and full system snapshots require all "
- "disks to be selected for snapshot"));
- return -1;
- }
-
- /* disk snapshot requires at least one disk */
- if (def->state == VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT && !external) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- _("disk-only snapshots require at least "
- "one disk to be selected for snapshot"));
- return -1;
- }
-
- /* For now, we don't allow mixing internal and external disks.
- * XXX technically, we could mix internal and external disks for
- * offline snapshots */
- if ((found_internal && external) ||
- (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL && external) ||
- (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL && found_internal)) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- _("mixing internal and external targets for a snapshot "
- "is not yet supported"));
- return -1;
- }
-
- /* internal snapshots + pflash based loader have the following problems:
- * - if the variable store is raw, the snapshot fails
- * - allowing a qcow2 image as the varstore would make it eligible to receive
- * the vmstate dump, which would make it huge
- * - offline snapshot would not snapshot the varstore at all
- *
- * Avoid the issues by forbidding internal snapshot with pflash completely.
- */
- if (found_internal &&
- virDomainDefHasOldStyleUEFI(vm->def)) {
- virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
- _("internal snapshots of a VM with pflash based "
- "firmware are not supported"));
- return -1;
- }
-
- /* Alter flags to let later users know what we learned. */
- if (external && !active)
- *flags |= VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY;
-
- return 0;
-}
-
-
-struct _qemuDomainSnapshotDiskData {
- virStorageSourcePtr src;
- bool initialized; /* @src was initialized in the storage driver */
- bool created; /* @src was created by the snapshot code */
- bool prepared; /* @src was prepared using qemuDomainStorageSourceAccessAllow */
- virDomainDiskDefPtr disk;
- char *relPath; /* relative path component to fill into original disk */
- qemuBlockStorageSourceChainDataPtr crdata;
- bool blockdevadded;
-
- virStorageSourcePtr persistsrc;
- virDomainDiskDefPtr persistdisk;
-};
-
-typedef struct _qemuDomainSnapshotDiskData qemuDomainSnapshotDiskData;
-typedef qemuDomainSnapshotDiskData *qemuDomainSnapshotDiskDataPtr;
-
-
-static void
-qemuDomainSnapshotDiskCleanup(qemuDomainSnapshotDiskDataPtr data,
- size_t ndata,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuDomainAsyncJob asyncJob)
-{
- virErrorPtr orig_err;
- size_t i;
-
- if (!data)
- return;
-
- virErrorPreserveLast(&orig_err);
-
- for (i = 0; i < ndata; i++) {
- /* on success of the snapshot the 'src' and 'persistsrc' properties will
- * be set to NULL by qemuDomainSnapshotDiskUpdateSource */
- if (data[i].src) {
- if (data[i].blockdevadded) {
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
-
- qemuBlockStorageSourceAttachRollback(qemuDomainGetMonitor(vm),
- data[i].crdata->srcdata[0]);
- ignore_value(qemuDomainObjExitMonitor(driver, vm));
- }
- }
-
- if (data[i].created &&
- virStorageFileUnlink(data[i].src) < 0) {
- VIR_WARN("Unable to remove just-created %s",
- NULLSTR(data[i].src->path));
- }
-
- if (data[i].initialized)
- virStorageFileDeinit(data[i].src);
-
- if (data[i].prepared)
- qemuDomainStorageSourceAccessRevoke(driver, vm, data[i].src);
-
- virObjectUnref(data[i].src);
- }
- virObjectUnref(data[i].persistsrc);
- VIR_FREE(data[i].relPath);
- qemuBlockStorageSourceChainDataFree(data[i].crdata);
- }
-
- VIR_FREE(data);
- virErrorRestore(&orig_err);
-}
-
-
-/**
- * qemuDomainSnapshotDiskBitmapsPropagate:
- *
- * This function propagates any active persistent bitmap present in the original
- * image into the new snapshot. This is necessary to keep tracking the changed
- * blocks in the active bitmaps as the backing file will become read-only.
- * We leave the original bitmap active as in cases when the overlay is
- * discarded (snapshot revert with abandoning the history) everything works as
- * expected.
- */
-static int
-qemuDomainSnapshotDiskBitmapsPropagate(qemuDomainSnapshotDiskDataPtr dd,
- virJSONValuePtr actions,
- virHashTablePtr blockNamedNodeData)
-{
- qemuBlockNamedNodeDataPtr entry;
- size_t i;
-
- if (!(entry = virHashLookup(blockNamedNodeData, dd->disk->src->nodeformat)))
- return 0;
-
- for (i = 0; i < entry->nbitmaps; i++) {
- qemuBlockNamedNodeDataBitmapPtr bitmap = entry->bitmaps[i];
-
- /* we don't care about temporary, inconsistent, or disabled bitmaps */
- if (!bitmap->persistent || !bitmap->recording || bitmap->inconsistent)
- continue;
-
- if (qemuMonitorTransactionBitmapAdd(actions, dd->src->nodeformat,
- bitmap->name, true, false,
- bitmap->granularity) < 0)
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-qemuDomainSnapshotDiskPrepareOneBlockdev(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuDomainSnapshotDiskDataPtr dd,
- virQEMUDriverConfigPtr cfg,
- bool reuse,
- virHashTablePtr blockNamedNodeData,
- qemuDomainAsyncJob asyncJob)
-{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- g_autoptr(virStorageSource) terminator = NULL;
- int rc;
-
- /* create a terminator for the snapshot disks so that qemu does not try
- * to open them at first */
- if (!(terminator = virStorageSourceNew()))
- return -1;
-
- if (qemuDomainPrepareStorageSourceBlockdev(dd->disk, dd->src,
- priv, cfg) < 0)
- return -1;
-
- if (!(dd->crdata = qemuBuildStorageSourceChainAttachPrepareBlockdevTop(dd->src,
- terminator,
- priv->qemuCaps)))
- return -1;
-
- if (reuse) {
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
- return -1;
-
- rc = qemuBlockStorageSourceAttachApply(qemuDomainGetMonitor(vm),
- dd->crdata->srcdata[0]);
-
- if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
- return -1;
- } else {
- if (qemuBlockStorageSourceCreateDetectSize(blockNamedNodeData,
- dd->src, dd->disk->src) < 0)
- return -1;
-
- if (qemuBlockStorageSourceCreate(vm, dd->src, dd->disk->src,
- NULL, dd->crdata->srcdata[0],
- asyncJob) < 0)
- return -1;
- }
-
- dd->blockdevadded = true;
- return 0;
-}
-
-
-static int
-qemuDomainSnapshotDiskPrepareOne(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virQEMUDriverConfigPtr cfg,
- virDomainDiskDefPtr disk,
- virDomainSnapshotDiskDefPtr snapdisk,
- qemuDomainSnapshotDiskDataPtr dd,
- virHashTablePtr blockNamedNodeData,
- bool reuse,
- bool blockdev,
- qemuDomainAsyncJob asyncJob,
- virJSONValuePtr actions)
-{
- virDomainDiskDefPtr persistdisk;
- bool supportsCreate;
- bool updateRelativeBacking = false;
-
- dd->disk = disk;
-
- if (qemuDomainStorageSourceValidateDepth(disk->src, 1, disk->dst) < 0)
- return -1;
-
- if (!(dd->src = virStorageSourceCopy(snapdisk->src, false)))
- return -1;
-
- if (virStorageSourceInitChainElement(dd->src, dd->disk->src, false) < 0)
- return -1;
-
- /* modify disk in persistent definition only when the source is the same */
- if (vm->newDef &&
- (persistdisk = virDomainDiskByTarget(vm->newDef, dd->disk->dst)) &&
- virStorageSourceIsSameLocation(dd->disk->src, persistdisk->src)) {
-
- dd->persistdisk = persistdisk;
-
- if (!(dd->persistsrc = virStorageSourceCopy(dd->src, false)))
- return -1;
-
- if (virStorageSourceInitChainElement(dd->persistsrc,
- dd->persistdisk->src, false) < 0)
- return -1;
- }
-
- supportsCreate = virStorageFileSupportsCreate(dd->src);
-
- /* relative backing store paths need to be updated so that relative
- * block commit still works. With blockdev we must update it when doing
- * commit anyways so it's skipped here */
- if (!blockdev &&
- virStorageFileSupportsBackingChainTraversal(dd->src))
- updateRelativeBacking = true;
-
- if (supportsCreate || updateRelativeBacking) {
- if (qemuDomainStorageFileInit(driver, vm, dd->src, NULL) < 0)
- return -1;
-
- dd->initialized = true;
-
- if (reuse) {
- if (updateRelativeBacking) {
- g_autofree char *backingStoreStr = NULL;
-
- if (virStorageFileGetBackingStoreStr(dd->src, &backingStoreStr) < 0)
- return -1;
- if (backingStoreStr != NULL) {
- if (virStorageIsRelative(backingStoreStr))
- dd->relPath = g_steal_pointer(&backingStoreStr);
- }
- }
- } else {
- /* pre-create the image file so that we can label it before handing it to qemu */
- if (supportsCreate && dd->src->type != VIR_STORAGE_TYPE_BLOCK) {
- if (virStorageFileCreate(dd->src) < 0) {
- virReportSystemError(errno, _("failed to create image file '%s'"),
- NULLSTR(dd->src->path));
- return -1;
- }
- dd->created = true;
- }
- }
- }
-
- /* set correct security, cgroup and locking options on the new image */
- if (qemuDomainStorageSourceAccessAllow(driver, vm, dd->src,
- false, true, true) < 0)
- return -1;
-
- dd->prepared = true;
-
- if (blockdev) {
- if (qemuDomainSnapshotDiskPrepareOneBlockdev(driver, vm, dd, cfg, reuse,
- blockNamedNodeData, asyncJob) < 0)
- return -1;
-
- if (qemuDomainSnapshotDiskBitmapsPropagate(dd, actions, blockNamedNodeData) < 0)
- return -1;
-
- if (qemuBlockSnapshotAddBlockdev(actions, dd->disk, dd->src) < 0)
- return -1;
- } else {
- if (qemuBlockSnapshotAddLegacy(actions, dd->disk, dd->src, reuse) < 0)
- return -1;
- }
-
- return 0;
-}
-
-
-/**
- * qemuDomainSnapshotDiskPrepare:
- *
- * Collects and prepares a list of structures that hold information about disks
- * that are selected for the snapshot.
- */
-static int
-qemuDomainSnapshotDiskPrepare(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
- virQEMUDriverConfigPtr cfg,
- bool reuse,
- bool blockdev,
- virHashTablePtr blockNamedNodeData,
- qemuDomainAsyncJob asyncJob,
- qemuDomainSnapshotDiskDataPtr *rdata,
- size_t *rndata,
- virJSONValuePtr actions)
-{
- size_t i;
- qemuDomainSnapshotDiskDataPtr data;
- size_t ndata = 0;
- virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
- int ret = -1;
-
- if (VIR_ALLOC_N(data, snapdef->ndisks) < 0)
- return -1;
-
- for (i = 0; i < snapdef->ndisks; i++) {
- if (snapdef->disks[i].snapshot == VIR_DOMAIN_SNAPSHOT_LOCATION_NONE)
- continue;
-
- if (qemuDomainSnapshotDiskPrepareOne(driver, vm, cfg, vm->def->disks[i],
- snapdef->disks + i,
- data + ndata++,
- blockNamedNodeData,
- reuse, blockdev,
- asyncJob,
- actions) < 0)
- goto cleanup;
- }
-
- *rdata = g_steal_pointer(&data);
- *rndata = ndata;
- ret = 0;
-
- cleanup:
- qemuDomainSnapshotDiskCleanup(data, ndata, driver, vm, asyncJob);
- return ret;
-}
-
-
-static void
-qemuDomainSnapshotDiskUpdateSourceRenumber(virStorageSourcePtr src)
-{
- virStorageSourcePtr next;
- unsigned int idx = 1;
-
- for (next = src->backingStore; virStorageSourceIsBacking(next); next = next->backingStore)
- next->id = idx++;
-}
-
-
-/**
- * qemuDomainSnapshotDiskUpdateSource:
- * @driver: QEMU driver
- * @vm: domain object
- * @dd: snapshot disk data object
- * @blockdev: -blockdev is in use for the VM
- *
- * Updates disk definition after a successful snapshot.
- */
-static void
-qemuDomainSnapshotDiskUpdateSource(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuDomainSnapshotDiskDataPtr dd,
- bool blockdev)
-{
- /* storage driver access won'd be needed */
- if (dd->initialized)
- virStorageFileDeinit(dd->src);
-
- if (qemuSecurityMoveImageMetadata(driver, vm, dd->disk->src, dd->src) < 0)
- VIR_WARN("Unable to move disk metadata on vm %s", vm->def->name);
-
- /* unlock the write lock on the original image as qemu will no longer write to it */
- virDomainLockImageDetach(driver->lockManager, vm, dd->disk->src);
-
- /* unlock also the new image if the VM is paused to follow the locking semantics */
- if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING)
- virDomainLockImageDetach(driver->lockManager, vm, dd->src);
-
- /* the old disk image is now readonly */
- dd->disk->src->readonly = true;
-
- dd->disk->src->relPath = g_steal_pointer(&dd->relPath);
- dd->src->backingStore = g_steal_pointer(&dd->disk->src);
- dd->disk->src = g_steal_pointer(&dd->src);
-
- /* fix numbering of disks */
- if (!blockdev)
- qemuDomainSnapshotDiskUpdateSourceRenumber(dd->disk->src);
-
- if (dd->persistdisk) {
- dd->persistdisk->src->readonly = true;
- dd->persistsrc->backingStore = g_steal_pointer(&dd->persistdisk->src);
- dd->persistdisk->src = g_steal_pointer(&dd->persistsrc);
- }
-}
-
-
-/* The domain is expected to be locked and active. */
-static int
-qemuDomainSnapshotCreateDiskActive(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
- virHashTablePtr blockNamedNodeData,
- unsigned int flags,
- virQEMUDriverConfigPtr cfg,
- qemuDomainAsyncJob asyncJob)
-{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- g_autoptr(virJSONValue) actions = NULL;
- int rc;
- int ret = -1;
- size_t i;
- bool reuse = (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
- qemuDomainSnapshotDiskDataPtr diskdata = NULL;
- size_t ndiskdata = 0;
- bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
-
- if (virDomainObjCheckActive(vm) < 0)
- return -1;
-
- actions = virJSONValueNewArray();
-
- /* prepare a list of objects to use in the vm definition so that we don't
- * have to roll back later */
- if (qemuDomainSnapshotDiskPrepare(driver, vm, snap, cfg, reuse, blockdev,
- blockNamedNodeData, asyncJob,
- &diskdata, &ndiskdata, actions) < 0)
- goto cleanup;
-
- /* check whether there's anything to do */
- if (ndiskdata == 0) {
- ret = 0;
- goto cleanup;
- }
-
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
- goto cleanup;
-
- rc = qemuMonitorTransaction(priv->mon, &actions);
-
- if (qemuDomainObjExitMonitor(driver, vm) < 0)
- rc = -1;
-
- for (i = 0; i < ndiskdata; i++) {
- qemuDomainSnapshotDiskDataPtr dd = &diskdata[i];
-
- virDomainAuditDisk(vm, dd->disk->src, dd->src, "snapshot", rc >= 0);
-
- if (rc == 0)
- qemuDomainSnapshotDiskUpdateSource(driver, vm, dd, blockdev);
- }
-
- if (rc < 0)
- goto cleanup;
-
- if (virDomainObjSave(vm, driver->xmlopt, cfg->stateDir) < 0 ||
- (vm->newDef && virDomainDefSave(vm->newDef, driver->xmlopt,
- cfg->configDir) < 0))
- goto cleanup;
-
- ret = 0;
-
- cleanup:
- qemuDomainSnapshotDiskCleanup(diskdata, ndiskdata, driver, vm, asyncJob);
- return ret;
-}
-
-
-static int
-qemuDomainSnapshotCreateActiveExternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
- virQEMUDriverConfigPtr cfg,
- unsigned int flags)
-{
- virObjectEventPtr event;
- bool resume = false;
- int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- g_autofree char *xml = NULL;
- virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
- bool memory = snapdef->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
- bool memory_unlink = false;
- int thaw = 0; /* 1 if freeze succeeded, -1 if freeze failed */
- bool pmsuspended = false;
- int compressed;
- g_autoptr(virCommand) compressor = NULL;
- virQEMUSaveDataPtr data = NULL;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
-
- /* If quiesce was requested, then issue a freeze command, and a
- * counterpart thaw command when it is actually sent to agent.
- * The command will fail if the guest is paused or the guest agent
- * is not running, or is already quiesced. */
- if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE) {
- int freeze;
-
- if (qemuDomainObjBeginAgentJob(driver, vm, QEMU_AGENT_JOB_MODIFY) < 0)
- goto cleanup;
-
- if (virDomainObjCheckActive(vm) < 0) {
- qemuDomainObjEndAgentJob(vm);
- goto cleanup;
- }
-
- freeze = qemuDomainSnapshotFSFreeze(vm, NULL, 0);
- qemuDomainObjEndAgentJob(vm);
-
- if (freeze < 0) {
- /* the helper reported the error */
- if (freeze == -2)
- thaw = -1; /* the command is sent but agent failed */
- goto cleanup;
- }
- thaw = 1;
- }
-
- /* We need to track what state the guest is in, since taking the
- * snapshot may alter that state and we must restore it later. */
- if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PMSUSPENDED) {
- pmsuspended = true;
- } else if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
- /* For full system external snapshots (those with memory), the guest
- * must pause (either by libvirt up front, or by qemu after
- * _LIVE converges). */
- if (memory)
- resume = true;
-
- if (memory && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_LIVE)) {
- if (qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_SNAPSHOT,
- QEMU_ASYNC_JOB_SNAPSHOT) < 0)
- goto cleanup;
-
- if (!virDomainObjIsActive(vm)) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("guest unexpectedly quit"));
- goto cleanup;
- }
-
- resume = true;
- }
- }
-
- /* We need to collect reply from 'query-named-block-nodes' prior to the
- * migration step as qemu deactivates bitmaps after migration so the result
- * would be wrong */
- if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV) &&
- !(blockNamedNodeData = qemuBlockGetNamedNodeData(vm, QEMU_ASYNC_JOB_SNAPSHOT)))
- goto cleanup;
-
- /* do the memory snapshot if necessary */
- if (memory) {
- /* check if migration is possible */
- if (!qemuMigrationSrcIsAllowed(driver, vm, false, 0))
- goto cleanup;
-
- priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP;
-
- /* allow the migration job to be cancelled or the domain to be paused */
- qemuDomainObjSetAsyncJobMask(vm, (QEMU_JOB_DEFAULT_MASK |
- JOB_MASK(QEMU_JOB_SUSPEND) |
- JOB_MASK(QEMU_JOB_MIGRATION_OP)));
-
- if ((compressed = qemuSaveImageGetCompressionProgram(cfg->snapshotImageFormat,
- &compressor,
- "snapshot", false)) < 0)
- goto cleanup;
-
- if (!(xml = qemuDomainDefFormatLive(driver, priv->qemuCaps,
- vm->def, priv->origCPU,
- true, true)) ||
- !(snapdef->cookie = (virObjectPtr) qemuDomainSaveCookieNew(vm)))
- goto cleanup;
-
- if (!(data = virQEMUSaveDataNew(xml,
- (qemuDomainSaveCookiePtr) snapdef->cookie,
- resume, compressed, driver->xmlopt)))
- goto cleanup;
- xml = NULL;
-
- if ((ret = qemuSaveImageCreate(driver, vm, snapdef->file, data,
- compressor, 0,
- QEMU_ASYNC_JOB_SNAPSHOT)) < 0)
- goto cleanup;
-
- /* the memory image was created, remove it on errors */
- memory_unlink = true;
-
- /* forbid any further manipulation */
- qemuDomainObjSetAsyncJobMask(vm, QEMU_JOB_DEFAULT_MASK);
- }
-
- /* the domain is now paused if a memory snapshot was requested */
-
- if ((ret = qemuDomainSnapshotCreateDiskActive(driver, vm, snap,
- blockNamedNodeData, flags, cfg,
- QEMU_ASYNC_JOB_SNAPSHOT)) < 0)
- goto cleanup;
-
- /* the snapshot is complete now */
- if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) {
- event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED,
- VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT);
- qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT,
- QEMU_ASYNC_JOB_SNAPSHOT, 0);
- virDomainAuditStop(vm, "from-snapshot");
- resume = false;
- thaw = 0;
- virObjectEventStateQueue(driver->domainEventState, event);
- } else if (memory && pmsuspended) {
- /* qemu 1.3 is unable to save a domain in pm-suspended (S3)
- * state; so we must emit an event stating that it was
- * converted to paused. */
- virDomainObjSetState(vm, VIR_DOMAIN_PAUSED,
- VIR_DOMAIN_PAUSED_FROM_SNAPSHOT);
- event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED,
- VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT);
- virObjectEventStateQueue(driver->domainEventState, event);
- }
-
- ret = 0;
-
- cleanup:
- if (resume && virDomainObjIsActive(vm) &&
- qemuProcessStartCPUs(driver, vm,
- VIR_DOMAIN_RUNNING_UNPAUSED,
- QEMU_ASYNC_JOB_SNAPSHOT) < 0) {
- event = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_SUSPENDED,
- VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR);
- virObjectEventStateQueue(driver->domainEventState, event);
- if (virGetLastErrorCode() == VIR_ERR_OK) {
- virReportError(VIR_ERR_OPERATION_FAILED, "%s",
- _("resuming after snapshot failed"));
- }
-
- ret = -1;
- }
-
- if (thaw != 0 &&
- qemuDomainObjBeginAgentJob(driver, vm, QEMU_AGENT_JOB_MODIFY) >= 0 &&
- virDomainObjIsActive(vm)) {
- if (qemuDomainSnapshotFSThaw(vm, ret == 0 && thaw > 0) < 0) {
- /* helper reported the error, if it was needed */
- if (thaw > 0)
- ret = -1;
- }
-
- qemuDomainObjEndAgentJob(vm);
- }
-
- virQEMUSaveDataFree(data);
- if (memory_unlink && ret < 0)
- unlink(snapdef->file);
-
- return ret;
-}
-
-
-static virDomainSnapshotPtr
-qemuDomainSnapshotCreateXML(virDomainPtr domain,
- const char *xmlDesc,
- unsigned int flags)
-{
- virQEMUDriverPtr driver = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
- g_autofree char *xml = NULL;
- virDomainMomentObjPtr snap = NULL;
- virDomainSnapshotPtr snapshot = NULL;
- virDomainMomentObjPtr current = NULL;
- bool update_current = true;
- bool redefine = flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE;
- unsigned int parse_flags = VIR_DOMAIN_SNAPSHOT_PARSE_DISKS;
- int align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL;
- bool align_match = true;
- g_autoptr(virQEMUDriverConfig) cfg = NULL;
- qemuDomainObjPrivatePtr priv;
- virDomainSnapshotState state;
- g_autoptr(virDomainSnapshotDef) def = NULL;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE |
- VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT |
- VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA |
- VIR_DOMAIN_SNAPSHOT_CREATE_HALT |
- VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY |
- VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT |
- VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE |
- VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC |
- VIR_DOMAIN_SNAPSHOT_CREATE_LIVE |
- VIR_DOMAIN_SNAPSHOT_CREATE_VALIDATE, NULL);
-
- VIR_REQUIRE_FLAG_RET(VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE,
- VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY,
- NULL);
- VIR_EXCLUSIVE_FLAGS_RET(VIR_DOMAIN_SNAPSHOT_CREATE_LIVE,
- VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE,
- NULL);
-
- if ((redefine && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT)) ||
- (flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA))
- update_current = false;
- if (redefine)
- parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE;
-
- if (!(vm = qemuDomainObjFromDomain(domain)))
- goto cleanup;
-
- priv = vm->privateData;
- cfg = virQEMUDriverGetConfig(driver);
-
- if (virDomainSnapshotCreateXMLEnsureACL(domain->conn, vm->def, flags) < 0)
- goto cleanup;
-
- if (qemuDomainSupportsCheckpointsBlockjobs(vm) < 0)
- goto cleanup;
-
- if (!vm->persistent && (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT)) {
- virReportError(VIR_ERR_OPERATION_INVALID, "%s",
- _("cannot halt after transient domain snapshot"));
- goto cleanup;
- }
- if ((flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) ||
- !virDomainObjIsActive(vm))
- parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_OFFLINE;
-
- if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_VALIDATE)
- parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_VALIDATE;
-
- if (!(def = virDomainSnapshotDefParseString(xmlDesc, driver->xmlopt,
- priv->qemuCaps, NULL, parse_flags)))
- goto cleanup;
-
- /* reject snapshot names containing slashes or starting with dot as
- * snapshot definitions are saved in files named by the snapshot name */
- if (!(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) {
- if (strchr(def->parent.name, '/')) {
- virReportError(VIR_ERR_XML_DETAIL,
- _("invalid snapshot name '%s': "
- "name can't contain '/'"),
- def->parent.name);
- goto cleanup;
- }
-
- if (def->parent.name[0] == '.') {
- virReportError(VIR_ERR_XML_DETAIL,
- _("invalid snapshot name '%s': "
- "name can't start with '.'"),
- def->parent.name);
- goto cleanup;
- }
- }
-
- /* reject the VIR_DOMAIN_SNAPSHOT_CREATE_LIVE flag where not supported */
- if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_LIVE &&
- (!virDomainObjIsActive(vm) ||
- def->memory != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)) {
- virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
- _("live snapshot creation is supported only "
- "during full system snapshots"));
- goto cleanup;
- }
-
- /* allow snapshots only in certain states */
- state = redefine ? def->state : vm->state.state;
- switch (state) {
- /* valid states */
- case VIR_DOMAIN_SNAPSHOT_RUNNING:
- case VIR_DOMAIN_SNAPSHOT_PAUSED:
- case VIR_DOMAIN_SNAPSHOT_SHUTDOWN:
- case VIR_DOMAIN_SNAPSHOT_SHUTOFF:
- case VIR_DOMAIN_SNAPSHOT_CRASHED:
- break;
-
- case VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT:
- if (!redefine) {
- virReportError(VIR_ERR_INTERNAL_ERROR, _("Invalid domain state %s"),
- virDomainSnapshotStateTypeToString(state));
- goto cleanup;
- }
- break;
-
- case VIR_DOMAIN_SNAPSHOT_PMSUSPENDED:
- virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
- _("qemu doesn't support taking snapshots of "
- "PMSUSPENDED guests"));
- goto cleanup;
-
- /* invalid states */
- case VIR_DOMAIN_SNAPSHOT_NOSTATE:
- case VIR_DOMAIN_SNAPSHOT_BLOCKED: /* invalid state, unused in qemu */
- case VIR_DOMAIN_SNAPSHOT_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR, _("Invalid domain state %s"),
- virDomainSnapshotStateTypeToString(state));
- goto cleanup;
- }
-
- /* We are going to modify the domain below. Internal snapshots would use
- * a regular job, so we need to set the job mask to disallow query as
- * 'savevm' blocks the monitor. External snapshot will then modify the
- * job mask appropriately. */
- if (qemuDomainObjBeginAsyncJob(driver, vm, QEMU_ASYNC_JOB_SNAPSHOT,
- VIR_DOMAIN_JOB_OPERATION_SNAPSHOT, flags) < 0)
- goto cleanup;
-
- qemuDomainObjSetAsyncJobMask(vm, QEMU_JOB_NONE);
-
- if (redefine) {
- if (virDomainSnapshotRedefinePrep(vm, &def, &snap,
- driver->xmlopt,
- flags) < 0)
- goto endjob;
- } else {
- /* Easiest way to clone inactive portion of vm->def is via
- * conversion in and back out of xml. */
- if (!(xml = qemuDomainDefFormatLive(driver, priv->qemuCaps,
- vm->def, priv->origCPU,
- true, true)) ||
- !(def->parent.dom = virDomainDefParseString(xml, driver->xmlopt,
- priv->qemuCaps,
- VIR_DOMAIN_DEF_PARSE_INACTIVE |
- VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE)))
- goto endjob;
-
- if (vm->newDef) {
- def->parent.inactiveDom = virDomainDefCopy(vm->newDef,
- driver->xmlopt, priv->qemuCaps, true);
- if (!def->parent.inactiveDom)
- goto endjob;
- }
-
- if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) {
- align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
- align_match = false;
- if (virDomainObjIsActive(vm))
- def->state = VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT;
- else
- def->state = VIR_DOMAIN_SNAPSHOT_SHUTOFF;
- def->memory = VIR_DOMAIN_SNAPSHOT_LOCATION_NONE;
- } else if (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) {
- def->state = virDomainObjGetState(vm, NULL);
- align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
- align_match = false;
- } else {
- def->state = virDomainObjGetState(vm, NULL);
-
- if (virDomainObjIsActive(vm) &&
- def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_NONE) {
- virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
- _("internal snapshot of a running VM "
- "must include the memory state"));
- goto endjob;
- }
-
- def->memory = (def->state == VIR_DOMAIN_SNAPSHOT_SHUTOFF ?
- VIR_DOMAIN_SNAPSHOT_LOCATION_NONE :
- VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL);
- }
- if (virDomainSnapshotAlignDisks(def, align_location,
- align_match) < 0 ||
- qemuDomainSnapshotPrepare(vm, def, &flags) < 0)
- goto endjob;
- }
-
- if (!snap) {
- if (!(snap = virDomainSnapshotAssignDef(vm->snapshots, def)))
- goto endjob;
-
- def = NULL;
- }
-
- current = virDomainSnapshotGetCurrent(vm->snapshots);
- if (current) {
- if (!redefine)
- snap->def->parent_name = g_strdup(current->def->name);
- }
-
- /* actually do the snapshot */
- if (redefine) {
- /* XXX Should we validate that the redefined snapshot even
- * makes sense, such as checking that qemu-img recognizes the
- * snapshot name in at least one of the domain's disks? */
- } else if (virDomainObjIsActive(vm)) {
- if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY ||
- virDomainSnapshotObjGetDef(snap)->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) {
- /* external full system or disk snapshot */
- if (qemuDomainSnapshotCreateActiveExternal(driver,
- vm, snap, cfg, flags) < 0)
- goto endjob;
- } else {
- /* internal full system */
- if (qemuDomainSnapshotCreateActiveInternal(driver,
- vm, snap, flags) < 0)
- goto endjob;
- }
- } else {
- /* inactive; qemuDomainSnapshotPrepare guaranteed that we
- * aren't mixing internal and external, and altered flags to
- * contain DISK_ONLY if there is an external disk. */
- if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) {
- bool reuse = !!(flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT);
-
- if (qemuDomainSnapshotCreateInactiveExternal(driver, vm, snap,
- reuse) < 0)
- goto endjob;
- } else {
- if (qemuDomainSnapshotCreateInactiveInternal(driver, vm, snap) < 0)
- goto endjob;
- }
- }
-
- /* If we fail after this point, there's not a whole lot we can
- * do; we've successfully taken the snapshot, and we are now running
- * on it, so we have to go forward the best we can
- */
- snapshot = virGetDomainSnapshot(domain, snap->def->name);
-
- endjob:
- if (snapshot && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) {
- if (update_current)
- virDomainSnapshotSetCurrent(vm->snapshots, snap);
- if (qemuDomainSnapshotWriteMetadata(vm, snap,
- driver->xmlopt,
- cfg->snapshotDir) < 0) {
- /* if writing of metadata fails, error out rather than trying
- * to silently carry on without completing the snapshot */
- virObjectUnref(snapshot);
- snapshot = NULL;
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unable to save metadata for snapshot %s"),
- snap->def->name);
- virDomainSnapshotObjListRemove(vm->snapshots, snap);
- } else {
- virDomainSnapshotLinkParent(vm->snapshots, snap);
- }
- } else if (snap) {
- virDomainSnapshotObjListRemove(vm->snapshots, snap);
- }
-
- qemuDomainObjEndAsyncJob(driver, vm);
-
- cleanup:
- virDomainObjEndAPI(&vm);
- return snapshot;
-}
-
-
-static int
-qemuDomainSnapshotListNames(virDomainPtr domain,
- char **names,
- int nameslen,
- unsigned int flags)
-{
- virDomainObjPtr vm = NULL;
- int n = -1;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
- VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
- VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
-
- if (!(vm = qemuDomainObjFromDomain(domain)))
- return -1;
-
- if (virDomainSnapshotListNamesEnsureACL(domain->conn, vm->def) < 0)
- goto cleanup;
-
- n = virDomainSnapshotObjListGetNames(vm->snapshots, NULL, names, nameslen,
- flags);
-
- cleanup:
- virDomainObjEndAPI(&vm);
- return n;
-}
-
-
-static int
-qemuDomainSnapshotNum(virDomainPtr domain,
- unsigned int flags)
-{
- virDomainObjPtr vm = NULL;
- int n = -1;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
- VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
- VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
-
- if (!(vm = qemuDomainObjFromDomain(domain)))
- return -1;
-
- if (virDomainSnapshotNumEnsureACL(domain->conn, vm->def) < 0)
- goto cleanup;
-
- n = virDomainSnapshotObjListNum(vm->snapshots, NULL, flags);
-
- cleanup:
- virDomainObjEndAPI(&vm);
- return n;
-}
-
-
-static int
-qemuDomainListAllSnapshots(virDomainPtr domain,
- virDomainSnapshotPtr **snaps,
- unsigned int flags)
-{
- virDomainObjPtr vm = NULL;
- int n = -1;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
- VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
- VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
-
- if (!(vm = qemuDomainObjFromDomain(domain)))
- return -1;
-
- if (virDomainListAllSnapshotsEnsureACL(domain->conn, vm->def) < 0)
- goto cleanup;
-
- n = virDomainListSnapshots(vm->snapshots, NULL, domain, snaps, flags);
-
- cleanup:
- virDomainObjEndAPI(&vm);
- return n;
-}
-
-
-static int
-qemuDomainSnapshotListChildrenNames(virDomainSnapshotPtr snapshot,
- char **names,
- int nameslen,
- unsigned int flags)
-{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
- int n = -1;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
- VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
- VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
-
- if (!(vm = qemuDomObjFromSnapshot(snapshot)))
- return -1;
-
- if (virDomainSnapshotListChildrenNamesEnsureACL(snapshot->domain->conn, vm->def) < 0)
- goto cleanup;
-
- if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
- goto cleanup;
-
- n = virDomainSnapshotObjListGetNames(vm->snapshots, snap, names, nameslen,
- flags);
-
- cleanup:
- virDomainObjEndAPI(&vm);
- return n;
-}
-
-
-static int
-qemuDomainSnapshotNumChildren(virDomainSnapshotPtr snapshot,
- unsigned int flags)
-{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
- int n = -1;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
- VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
- VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
-
- if (!(vm = qemuDomObjFromSnapshot(snapshot)))
- return -1;
-
- if (virDomainSnapshotNumChildrenEnsureACL(snapshot->domain->conn, vm->def) < 0)
- goto cleanup;
-
- if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
- goto cleanup;
-
- n = virDomainSnapshotObjListNum(vm->snapshots, snap, flags);
-
- cleanup:
- virDomainObjEndAPI(&vm);
- return n;
-}
-
-
-static int
-qemuDomainSnapshotListAllChildren(virDomainSnapshotPtr snapshot,
- virDomainSnapshotPtr **snaps,
- unsigned int flags)
-{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
- int n = -1;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
- VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL |
- VIR_DOMAIN_SNAPSHOT_FILTERS_ALL, -1);
-
- if (!(vm = qemuDomObjFromSnapshot(snapshot)))
- return -1;
-
- if (virDomainSnapshotListAllChildrenEnsureACL(snapshot->domain->conn, vm->def) < 0)
- goto cleanup;
-
- if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
- goto cleanup;
-
- n = virDomainListSnapshots(vm->snapshots, snap, snapshot->domain, snaps,
- flags);
-
- cleanup:
- virDomainObjEndAPI(&vm);
- return n;
-}
-
-
-static virDomainSnapshotPtr
-qemuDomainSnapshotLookupByName(virDomainPtr domain,
- const char *name,
- unsigned int flags)
-{
- virDomainObjPtr vm;
- virDomainMomentObjPtr snap = NULL;
- virDomainSnapshotPtr snapshot = NULL;
-
- virCheckFlags(0, NULL);
-
- if (!(vm = qemuDomainObjFromDomain(domain)))
- return NULL;
-
- if (virDomainSnapshotLookupByNameEnsureACL(domain->conn, vm->def) < 0)
- goto cleanup;
-
- if (!(snap = qemuSnapObjFromName(vm, name)))
- goto cleanup;
-
- snapshot = virGetDomainSnapshot(domain, snap->def->name);
-
- cleanup:
- virDomainObjEndAPI(&vm);
- return snapshot;
-}
-
-
-static int
-qemuDomainHasCurrentSnapshot(virDomainPtr domain,
- unsigned int flags)
+qemuDomainHasCurrentSnapshot(virDomainPtr domain,
+ unsigned int flags)
{
virDomainObjPtr vm;
int ret = -1;
@@ -15342,601 +13716,44 @@ qemuDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
}
-/* The domain is expected to be locked and inactive. */
-static int
-qemuDomainSnapshotRevertInactive(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap)
-{
- /* Try all disks, but report failure if we skipped any. */
- int ret = qemuDomainSnapshotForEachQcow2(driver, vm, snap, "-a", true);
- return ret > 0 ? -1 : ret;
-}
-
-
static int
qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
- virDomainMomentObjPtr snap = NULL;
- virDomainSnapshotDefPtr snapdef;
- virObjectEventPtr event = NULL;
- virObjectEventPtr event2 = NULL;
- int detail;
- qemuDomainObjPrivatePtr priv;
- int rc;
- virDomainDefPtr config = NULL;
- virDomainDefPtr inactiveConfig = NULL;
- g_autoptr(virQEMUDriverConfig) cfg = NULL;
- bool was_stopped = false;
- qemuDomainSaveCookiePtr cookie;
- virCPUDefPtr origCPU = NULL;
- unsigned int start_flags = VIR_QEMU_PROCESS_START_GEN_VMID;
- qemuDomainAsyncJob jobType = QEMU_ASYNC_JOB_START;
- bool defined = false;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
- VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED |
- VIR_DOMAIN_SNAPSHOT_REVERT_FORCE, -1);
-
- /* We have the following transitions, which create the following events:
- * 1. inactive -> inactive: none
- * 2. inactive -> running: EVENT_STARTED
- * 3. inactive -> paused: EVENT_STARTED, EVENT_PAUSED
- * 4. running -> inactive: EVENT_STOPPED
- * 5. running -> running: none
- * 6. running -> paused: EVENT_PAUSED
- * 7. paused -> inactive: EVENT_STOPPED
- * 8. paused -> running: EVENT_RESUMED
- * 9. paused -> paused: none
- * Also, several transitions occur even if we fail partway through,
- * and use of FORCE can cause multiple transitions.
- */
virNWFilterReadLockFilterUpdates();
if (!(vm = qemuDomObjFromSnapshot(snapshot)))
goto cleanup;
- priv = vm->privateData;
- cfg = virQEMUDriverGetConfig(driver);
-
if (virDomainRevertToSnapshotEnsureACL(snapshot->domain->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainHasBlockjob(vm, false)) {
- virReportError(VIR_ERR_OPERATION_INVALID, "%s",
- _("domain has active block job"));
- goto cleanup;
- }
-
- if (qemuProcessBeginJob(driver, vm,
- VIR_DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT,
- flags) < 0)
- goto cleanup;
-
- if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
- goto endjob;
- snapdef = virDomainSnapshotObjGetDef(snap);
-
- if (!vm->persistent &&
- snapdef->state != VIR_DOMAIN_SNAPSHOT_RUNNING &&
- snapdef->state != VIR_DOMAIN_SNAPSHOT_PAUSED &&
- (flags & (VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
- VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED)) == 0) {
- virReportError(VIR_ERR_OPERATION_INVALID, "%s",
- _("transient domain needs to request run or pause "
- "to revert to inactive snapshot"));
- goto endjob;
- }
-
- if (virDomainSnapshotIsExternal(snap)) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- _("revert to external snapshot not supported yet"));
- goto endjob;
- }
-
- if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) {
- if (!snap->def->dom) {
- virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY,
- _("snapshot '%s' lacks domain '%s' rollback info"),
- snap->def->name, vm->def->name);
- goto endjob;
- }
- if (virDomainObjIsActive(vm) &&
- !(snapdef->state == VIR_DOMAIN_SNAPSHOT_RUNNING ||
- snapdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED) &&
- (flags & (VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
- VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED))) {
- virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, "%s",
- _("must respawn qemu to start inactive snapshot"));
- goto endjob;
- }
- if (vm->hasManagedSave &&
- !(snapdef->state == VIR_DOMAIN_SNAPSHOT_RUNNING ||
- snapdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED)) {
- virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, "%s",
- _("snapshot without memory state, removal of "
- "existing managed saved state strongly "
- "recommended to avoid corruption"));
- goto endjob;
- }
- }
-
- if (snap->def->dom) {
- config = virDomainDefCopy(snap->def->dom,
- driver->xmlopt, priv->qemuCaps, true);
- if (!config)
- goto endjob;
- }
-
- if (snap->def->inactiveDom) {
- inactiveConfig = virDomainDefCopy(snap->def->inactiveDom,
- driver->xmlopt, priv->qemuCaps, true);
- if (!inactiveConfig)
- goto endjob;
- } else {
- /* Inactive domain definition is missing:
- * - either this is an old active snapshot and we need to copy the
- * active definition as an inactive one
- * - or this is an inactive snapshot which means config contains the
- * inactive definition.
- */
- if (snapdef->state == VIR_DOMAIN_SNAPSHOT_RUNNING ||
- snapdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED) {
- inactiveConfig = virDomainDefCopy(snap->def->dom,
- driver->xmlopt, priv->qemuCaps, true);
- if (!inactiveConfig)
- goto endjob;
- } else {
- inactiveConfig = g_steal_pointer(&config);
- }
- }
-
- cookie = (qemuDomainSaveCookiePtr) snapdef->cookie;
-
- switch ((virDomainSnapshotState) snapdef->state) {
- case VIR_DOMAIN_SNAPSHOT_RUNNING:
- case VIR_DOMAIN_SNAPSHOT_PAUSED:
- start_flags |= VIR_QEMU_PROCESS_START_PAUSED;
-
- /* Transitions 2, 3, 5, 6, 8, 9 */
- /* When using the loadvm monitor command, qemu does not know
- * whether to pause or run the reverted domain, and just stays
- * in the same state as before the monitor command, whether
- * that is paused or running. We always pause before loadvm,
- * to have finer control. */
- if (virDomainObjIsActive(vm)) {
- /* Transitions 5, 6, 8, 9 */
- /* Check for ABI compatibility. We need to do this check against
- * the migratable XML or it will always fail otherwise */
- if (config) {
- bool compatible;
-
- /* Replace the CPU in config and put the original one in priv
- * once we're done. When we have the updated CPU def in the
- * cookie, we don't want to replace the CPU in migratable def
- * when doing ABI checks to make sure the current CPU exactly
- * matches the one used at the time the snapshot was taken.
- */
- if (cookie && cookie->cpu && config->cpu) {
- origCPU = config->cpu;
- if (!(config->cpu = virCPUDefCopy(cookie->cpu)))
- goto endjob;
-
- compatible = qemuDomainDefCheckABIStability(driver,
- priv->qemuCaps,
- vm->def,
- config);
- } else {
- compatible = qemuDomainCheckABIStability(driver, vm, config);
- }
-
- /* If using VM GenID, there is no way currently to change
- * the genid for the running guest, so set an error,
- * mark as incompatible, and don't allow change of genid
- * if the revert force flag would start the guest again. */
- if (compatible && config->genidRequested) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- _("domain genid update requires restart"));
- compatible = false;
- start_flags &= ~VIR_QEMU_PROCESS_START_GEN_VMID;
- }
-
- if (!compatible) {
- virErrorPtr err = virGetLastError();
-
- if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) {
- /* Re-spawn error using correct category. */
- if (err->code == VIR_ERR_CONFIG_UNSUPPORTED)
- virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, "%s",
- err->str2);
- goto endjob;
- }
- virResetError(err);
- qemuProcessStop(driver, vm,
- VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT,
- QEMU_ASYNC_JOB_START, 0);
- virDomainAuditStop(vm, "from-snapshot");
- detail = VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT;
- event = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_STOPPED,
- detail);
- virObjectEventStateQueue(driver->domainEventState, event);
- /* Start after stop won't be an async start job, so
- * reset to none */
- jobType = QEMU_ASYNC_JOB_NONE;
- goto load;
- }
- }
-
- if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
- /* Transitions 5, 6 */
- if (qemuProcessStopCPUs(driver, vm,
- VIR_DOMAIN_PAUSED_FROM_SNAPSHOT,
- QEMU_ASYNC_JOB_START) < 0)
- goto endjob;
- if (!virDomainObjIsActive(vm)) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("guest unexpectedly quit"));
- goto endjob;
- }
- }
-
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
- QEMU_ASYNC_JOB_START) < 0)
- goto endjob;
- rc = qemuMonitorLoadSnapshot(priv->mon, snap->def->name);
- if (qemuDomainObjExitMonitor(driver, vm) < 0)
- goto endjob;
- if (rc < 0) {
- /* XXX resume domain if it was running before the
- * failed loadvm attempt? */
- goto endjob;
- }
- if (config) {
- virCPUDefFree(priv->origCPU);
- priv->origCPU = g_steal_pointer(&origCPU);
- }
-
- if (cookie && !cookie->slirpHelper)
- priv->disableSlirp = true;
-
- if (inactiveConfig) {
- virDomainObjAssignDef(vm, inactiveConfig, false, NULL);
- inactiveConfig = NULL;
- defined = true;
- }
- } else {
- /* Transitions 2, 3 */
- load:
- was_stopped = true;
-
- if (inactiveConfig) {
- virDomainObjAssignDef(vm, inactiveConfig, false, NULL);
- inactiveConfig = NULL;
- defined = true;
- }
-
- if (config) {
- virDomainObjAssignDef(vm, config, true, NULL);
- config = NULL;
- }
-
- /* No cookie means libvirt which saved the domain was too old to
- * mess up the CPU definitions.
- */
- if (cookie &&
- qemuDomainFixupCPUs(vm, &cookie->cpu) < 0)
- goto cleanup;
-
- rc = qemuProcessStart(snapshot->domain->conn, driver, vm,
- cookie ? cookie->cpu : NULL,
- jobType, NULL, -1, NULL, snap,
- VIR_NETDEV_VPORT_PROFILE_OP_CREATE,
- start_flags);
- virDomainAuditStart(vm, "from-snapshot", rc >= 0);
- detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT;
- event = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_STARTED,
- detail);
- if (rc < 0)
- goto endjob;
- }
-
- /* Touch up domain state. */
- if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING) &&
- (snapdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED ||
- (flags & VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED))) {
- /* Transitions 3, 6, 9 */
- virDomainObjSetState(vm, VIR_DOMAIN_PAUSED,
- VIR_DOMAIN_PAUSED_FROM_SNAPSHOT);
- if (was_stopped) {
- /* Transition 3, use event as-is and add event2 */
- detail = VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT;
- event2 = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_SUSPENDED,
- detail);
- } /* else transition 6 and 9 use event as-is */
- } else {
- /* Transitions 2, 5, 8 */
- if (!virDomainObjIsActive(vm)) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("guest unexpectedly quit"));
- goto endjob;
- }
- rc = qemuProcessStartCPUs(driver, vm,
- VIR_DOMAIN_RUNNING_FROM_SNAPSHOT,
- jobType);
- if (rc < 0)
- goto endjob;
- virObjectUnref(event);
- event = NULL;
- if (was_stopped) {
- /* Transition 2 */
- detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT;
- event = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_STARTED,
- detail);
- }
- }
- break;
-
- case VIR_DOMAIN_SNAPSHOT_SHUTDOWN:
- case VIR_DOMAIN_SNAPSHOT_SHUTOFF:
- case VIR_DOMAIN_SNAPSHOT_CRASHED:
- /* Transitions 1, 4, 7 */
- /* Newer qemu -loadvm refuses to revert to the state of a snapshot
- * created by qemu-img snapshot -c. If the domain is running, we
- * must take it offline; then do the revert using qemu-img.
- */
-
- if (virDomainObjIsActive(vm)) {
- /* Transitions 4, 7 */
- qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT,
- QEMU_ASYNC_JOB_START, 0);
- virDomainAuditStop(vm, "from-snapshot");
- detail = VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT;
- event = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_STOPPED,
- detail);
- }
-
- if (qemuDomainSnapshotRevertInactive(driver, vm, snap) < 0) {
- qemuDomainRemoveInactive(driver, vm);
- qemuProcessEndJob(driver, vm);
- goto cleanup;
- }
-
- if (inactiveConfig) {
- virDomainObjAssignDef(vm, inactiveConfig, false, NULL);
- inactiveConfig = NULL;
- defined = true;
- }
-
- if (flags & (VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
- VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED)) {
- /* Flush first event, now do transition 2 or 3 */
- bool paused = (flags & VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED) != 0;
-
- start_flags |= paused ? VIR_QEMU_PROCESS_START_PAUSED : 0;
-
- virObjectEventStateQueue(driver->domainEventState, event);
- rc = qemuProcessStart(snapshot->domain->conn, driver, vm, NULL,
- QEMU_ASYNC_JOB_START, NULL, -1, NULL, NULL,
- VIR_NETDEV_VPORT_PROFILE_OP_CREATE,
- start_flags);
- virDomainAuditStart(vm, "from-snapshot", rc >= 0);
- if (rc < 0) {
- qemuDomainRemoveInactive(driver, vm);
- qemuProcessEndJob(driver, vm);
- goto cleanup;
- }
- detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT;
- event = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_STARTED,
- detail);
- if (paused) {
- detail = VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT;
- event2 = virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_SUSPENDED,
- detail);
- }
- }
- break;
-
- case VIR_DOMAIN_SNAPSHOT_PMSUSPENDED:
- virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
- _("qemu doesn't support reversion of snapshot taken in "
- "PMSUSPENDED state"));
- goto endjob;
-
- case VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT:
- /* Rejected earlier as an external snapshot */
- case VIR_DOMAIN_SNAPSHOT_NOSTATE:
- case VIR_DOMAIN_SNAPSHOT_BLOCKED:
- case VIR_DOMAIN_SNAPSHOT_LAST:
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Invalid target domain state '%s'. Refusing "
- "snapshot reversion"),
- virDomainSnapshotStateTypeToString(snapdef->state));
- goto endjob;
- }
-
- ret = 0;
-
- endjob:
- qemuProcessEndJob(driver, vm);
+ ret = qemuSnapshotRevert(vm, snapshot, flags);
cleanup:
- if (ret == 0) {
- virDomainSnapshotSetCurrent(vm->snapshots, snap);
- if (qemuDomainSnapshotWriteMetadata(vm, snap,
- driver->xmlopt,
- cfg->snapshotDir) < 0) {
- virDomainSnapshotSetCurrent(vm->snapshots, NULL);
- ret = -1;
- }
- }
- if (ret == 0 && defined && vm->persistent &&
- !(ret = virDomainDefSave(vm->newDef ? vm->newDef : vm->def,
- driver->xmlopt, cfg->configDir))) {
- detail = VIR_DOMAIN_EVENT_DEFINED_FROM_SNAPSHOT;
- virObjectEventStateQueue(driver->domainEventState,
- virDomainEventLifecycleNewFromObj(vm,
- VIR_DOMAIN_EVENT_DEFINED,
- detail));
- }
- virObjectEventStateQueue(driver->domainEventState, event);
- virObjectEventStateQueue(driver->domainEventState, event2);
virDomainObjEndAPI(&vm);
virNWFilterUnlockFilterUpdates();
- virCPUDefFree(origCPU);
- virDomainDefFree(config);
- virDomainDefFree(inactiveConfig);
-
return ret;
}
-typedef struct _virQEMUMomentReparent virQEMUMomentReparent;
-typedef virQEMUMomentReparent *virQEMUMomentReparentPtr;
-struct _virQEMUMomentReparent {
- const char *dir;
- virDomainMomentObjPtr parent;
- virDomainObjPtr vm;
- virDomainXMLOptionPtr xmlopt;
- int err;
- int (*writeMetadata)(virDomainObjPtr, virDomainMomentObjPtr,
- virDomainXMLOptionPtr, const char *);
-};
-
-
-static int
-qemuDomainMomentReparentChildren(void *payload,
- const void *name G_GNUC_UNUSED,
- void *data)
-{
- virDomainMomentObjPtr moment = payload;
- virQEMUMomentReparentPtr rep = data;
-
- if (rep->err < 0)
- return 0;
-
- VIR_FREE(moment->def->parent_name);
-
- if (rep->parent->def)
- moment->def->parent_name = g_strdup(rep->parent->def->name);
-
- rep->err = rep->writeMetadata(rep->vm, moment, rep->xmlopt,
- rep->dir);
- return 0;
-}
-
-
static int
qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
- virDomainMomentObjPtr snap = NULL;
- virQEMUMomentRemove rem;
- virQEMUMomentReparent rep;
- bool metadata_only = !!(flags & VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY);
- int external = 0;
- g_autoptr(virQEMUDriverConfig) cfg = NULL;
-
- virCheckFlags(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
- VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY |
- VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY, -1);
if (!(vm = qemuDomObjFromSnapshot(snapshot)))
return -1;
- cfg = virQEMUDriverGetConfig(driver);
-
if (virDomainSnapshotDeleteEnsureACL(snapshot->domain->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
- goto cleanup;
-
- if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
- goto endjob;
-
- if (!metadata_only) {
- if (!(flags & VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY) &&
- virDomainSnapshotIsExternal(snap))
- external++;
- if (flags & (VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
- VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY))
- virDomainMomentForEachDescendant(snap,
- qemuDomainSnapshotCountExternal,
- &external);
- if (external) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("deletion of %d external disk snapshots not "
- "supported yet"), external);
- goto endjob;
- }
- }
-
- if (flags & (VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
- VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY)) {
- rem.driver = driver;
- rem.vm = vm;
- rem.metadata_only = metadata_only;
- rem.err = 0;
- rem.current = virDomainSnapshotGetCurrent(vm->snapshots);
- rem.found = false;
- rem.momentDiscard = qemuDomainSnapshotDiscard;
- virDomainMomentForEachDescendant(snap, qemuDomainMomentDiscardAll,
- &rem);
- if (rem.err < 0)
- goto endjob;
- if (rem.found) {
- virDomainSnapshotSetCurrent(vm->snapshots, snap);
- if (flags & VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY) {
- if (qemuDomainSnapshotWriteMetadata(vm, snap,
- driver->xmlopt,
- cfg->snapshotDir) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("failed to set snapshot '%s' as current"),
- snap->def->name);
- virDomainSnapshotSetCurrent(vm->snapshots, NULL);
- goto endjob;
- }
- }
- }
- } else if (snap->nchildren) {
- rep.dir = cfg->snapshotDir;
- rep.parent = snap->parent;
- rep.vm = vm;
- rep.err = 0;
- rep.xmlopt = driver->xmlopt;
- rep.writeMetadata = qemuDomainSnapshotWriteMetadata;
- virDomainMomentForEachChild(snap,
- qemuDomainMomentReparentChildren,
- &rep);
- if (rep.err < 0)
- goto endjob;
- virDomainMomentMoveChildren(snap, snap->parent);
- }
-
- if (flags & VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY) {
- virDomainMomentDropChildren(snap);
- ret = 0;
- } else {
- ret = qemuDomainSnapshotDiscard(driver, vm, snap, true, metadata_only);
- }
-
- endjob:
- qemuDomainObjEndJob(driver, vm);
+ ret = qemuSnapshotDelete(vm, snapshot, flags);
cleanup:
virDomainObjEndAPI(&vm);
@@ -19593,7 +17410,7 @@ qemuDomainFSFreeze(virDomainPtr dom,
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
- ret = qemuDomainSnapshotFSFreeze(vm, mountpoints, nmountpoints);
+ ret = qemuSnapshotFSFreeze(vm, mountpoints, nmountpoints);
endjob:
qemuDomainObjEndAgentJob(vm);
@@ -19634,7 +17451,7 @@ qemuDomainFSThaw(virDomainPtr dom,
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
- ret = qemuDomainSnapshotFSThaw(vm, true);
+ ret = qemuSnapshotFSThaw(vm, true);
endjob:
qemuDomainObjEndAgentJob(vm);
diff --git a/src/qemu/qemu_snapshot.c b/src/qemu/qemu_snapshot.c
new file mode 100644
index 0000000000..1e8ea80b22
--- /dev/null
+++ b/src/qemu/qemu_snapshot.c
@@ -0,0 +1,2266 @@
+/*
+ * qemu_snapshot.c: snapshot related implementation
+ *
+ * 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 "qemu_snapshot.h"
+
+#include "qemu_monitor.h"
+#include "qemu_domain.h"
+#include "qemu_block.h"
+#include "qemu_process.h"
+#include "qemu_migration.h"
+#include "qemu_command.h"
+#include "qemu_security.h"
+#include "qemu_saveimage.h"
+
+#include "virerror.h"
+#include "virlog.h"
+#include "datatypes.h"
+#include "viralloc.h"
+#include "domain_conf.h"
+#include "domain_audit.h"
+#include "locking/domain_lock.h"
+#include "libvirt_internal.h"
+#include "virxml.h"
+#include "virstring.h"
+#include "virdomainsnapshotobjlist.h"
+#include "virqemu.h"
+
+#define VIR_FROM_THIS VIR_FROM_QEMU
+
+VIR_LOG_INIT("qemu.qemu_snapshot");
+
+
+/* Looks up snapshot object from VM and name */
+virDomainMomentObjPtr
+qemuSnapObjFromName(virDomainObjPtr vm,
+ const char *name)
+{
+ virDomainMomentObjPtr snap = NULL;
+ snap = virDomainSnapshotFindByName(vm->snapshots, name);
+ if (!snap)
+ virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
+ _("no domain snapshot with matching name '%s'"),
+ name);
+
+ return snap;
+}
+
+
+/* Looks up snapshot object from VM and snapshotPtr */
+virDomainMomentObjPtr
+qemuSnapObjFromSnapshot(virDomainObjPtr vm,
+ virDomainSnapshotPtr snapshot)
+{
+ return qemuSnapObjFromName(vm, snapshot->name);
+}
+
+
+/* Count how many snapshots in a set are external snapshots. */
+static int
+qemuSnapshotCountExternal(void *payload,
+ const void *name G_GNUC_UNUSED,
+ void *data)
+{
+ virDomainMomentObjPtr snap = payload;
+ int *count = data;
+
+ if (virDomainSnapshotIsExternal(snap))
+ (*count)++;
+ return 0;
+}
+
+
+/* Return -1 if request is not sent to agent due to misconfig, -2 if request
+ * is sent but failed, and number of frozen filesystems on success. If -2 is
+ * returned, FSThaw should be called revert the quiesced status. */
+int
+qemuSnapshotFSFreeze(virDomainObjPtr vm,
+ const char **mountpoints,
+ unsigned int nmountpoints)
+{
+ qemuAgentPtr agent;
+ int frozen;
+
+ if (!qemuDomainAgentAvailable(vm, true))
+ return -1;
+
+ agent = qemuDomainObjEnterAgent(vm);
+ frozen = qemuAgentFSFreeze(agent, mountpoints, nmountpoints);
+ qemuDomainObjExitAgent(vm, agent);
+ return frozen < 0 ? -2 : frozen;
+}
+
+
+/* Return -1 on error, otherwise number of thawed filesystems. */
+int
+qemuSnapshotFSThaw(virDomainObjPtr vm,
+ bool report)
+{
+ qemuAgentPtr agent;
+ int thawed;
+ virErrorPtr err = NULL;
+
+ if (!qemuDomainAgentAvailable(vm, report))
+ return -1;
+
+ agent = qemuDomainObjEnterAgent(vm);
+ if (!report)
+ virErrorPreserveLast(&err);
+ thawed = qemuAgentFSThaw(agent);
+ qemuDomainObjExitAgent(vm, agent);
+
+ virErrorRestore(&err);
+
+ return thawed;
+}
+
+
+/* The domain is expected to be locked and inactive. */
+static int
+qemuSnapshotCreateInactiveInternal(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainMomentObjPtr snap)
+{
+ return qemuDomainSnapshotForEachQcow2(driver, vm, snap, "-c", false);
+}
+
+
+/* The domain is expected to be locked and inactive. */
+static int
+qemuSnapshotCreateInactiveExternal(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainMomentObjPtr snap,
+ bool reuse)
+{
+ size_t i;
+ virDomainSnapshotDiskDefPtr snapdisk;
+ virDomainDiskDefPtr defdisk;
+ virCommandPtr cmd = NULL;
+ const char *qemuImgPath;
+ virBitmapPtr created = NULL;
+ g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
+ int ret = -1;
+ g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
+ virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+
+ if (!(qemuImgPath = qemuFindQemuImgBinary(driver)))
+ goto cleanup;
+
+ if (!(created = virBitmapNew(snapdef->ndisks)))
+ goto cleanup;
+
+ /* If reuse is true, then qemuSnapshotPrepare already
+ * ensured that the new files exist, and it was up to the user to
+ * create them correctly. */
+ for (i = 0; i < snapdef->ndisks && !reuse; i++) {
+ snapdisk = &(snapdef->disks[i]);
+ defdisk = snapdef->parent.dom->disks[snapdisk->idx];
+ if (snapdisk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)
+ continue;
+
+ if (!snapdisk->src->format)
+ snapdisk->src->format = VIR_STORAGE_FILE_QCOW2;
+
+ if (qemuDomainStorageSourceValidateDepth(defdisk->src, 1, defdisk->dst) < 0)
+ goto cleanup;
+
+ /* creates cmd line args: qemu-img create -f qcow2 -o */
+ if (!(cmd = virCommandNewArgList(qemuImgPath,
+ "create",
+ "-f",
+ virStorageFileFormatTypeToString(snapdisk->src->format),
+ "-o",
+ NULL)))
+ goto cleanup;
+
+ /* adds cmd line arg: backing_fmt=format,backing_file=/path/to/backing/file */
+ virBufferAsprintf(&buf, "backing_fmt=%s,backing_file=",
+ virStorageFileFormatTypeToString(defdisk->src->format));
+ virQEMUBuildBufferEscapeComma(&buf, defdisk->src->path);
+ virCommandAddArgBuffer(cmd, &buf);
+
+ /* adds cmd line args: /path/to/target/file */
+ virQEMUBuildBufferEscapeComma(&buf, snapdisk->src->path);
+ virCommandAddArgBuffer(cmd, &buf);
+
+ /* If the target does not exist, we're going to create it possibly */
+ if (!virFileExists(snapdisk->src->path))
+ ignore_value(virBitmapSetBit(created, i));
+
+ if (virCommandRun(cmd, NULL) < 0)
+ goto cleanup;
+
+ virCommandFree(cmd);
+ cmd = NULL;
+ }
+
+ /* update disk definitions */
+ for (i = 0; i < snapdef->ndisks; i++) {
+ g_autoptr(virStorageSource) newsrc = NULL;
+
+ snapdisk = &(snapdef->disks[i]);
+ defdisk = vm->def->disks[snapdisk->idx];
+
+ if (snapdisk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)
+ continue;
+
+ if (!(newsrc = virStorageSourceCopy(snapdisk->src, false)))
+ goto cleanup;
+
+ if (virStorageSourceInitChainElement(newsrc, defdisk->src, false) < 0)
+ goto cleanup;
+
+ if (!reuse &&
+ virStorageSourceHasBacking(defdisk->src)) {
+ defdisk->src->readonly = true;
+ newsrc->backingStore = g_steal_pointer(&defdisk->src);
+ } else {
+ virObjectUnref(defdisk->src);
+ }
+
+ defdisk->src = g_steal_pointer(&newsrc);
+ }
+
+ if (virDomainDefSave(vm->def, driver->xmlopt, cfg->configDir) < 0)
+ goto cleanup;
+
+ ret = 0;
+
+ cleanup:
+ virCommandFree(cmd);
+
+ /* unlink images if creation has failed */
+ if (ret < 0 && created) {
+ ssize_t bit = -1;
+ while ((bit = virBitmapNextSetBit(created, bit)) >= 0) {
+ snapdisk = &(snapdef->disks[bit]);
+ if (unlink(snapdisk->src->path) < 0)
+ VIR_WARN("Failed to remove snapshot image '%s'",
+ snapdisk->src->path);
+ }
+ }
+ virBitmapFree(created);
+
+ return ret;
+}
+
+
+/* The domain is expected to be locked and active. */
+static int
+qemuSnapshotCreateActiveInternal(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainMomentObjPtr snap,
+ unsigned int flags)
+{
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ virObjectEventPtr event = NULL;
+ bool resume = false;
+ virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+ int ret = -1;
+
+ if (!qemuMigrationSrcIsAllowed(driver, vm, false, 0))
+ goto cleanup;
+
+ if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
+ /* savevm monitor command pauses the domain emitting an event which
+ * confuses libvirt since it's not notified when qemu resumes the
+ * domain. Thus we stop and start CPUs ourselves.
+ */
+ if (qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_SAVE,
+ QEMU_ASYNC_JOB_SNAPSHOT) < 0)
+ goto cleanup;
+
+ resume = true;
+ if (!virDomainObjIsActive(vm)) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("guest unexpectedly quit"));
+ goto cleanup;
+ }
+ }
+
+ if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ QEMU_ASYNC_JOB_SNAPSHOT) < 0) {
+ resume = false;
+ goto cleanup;
+ }
+
+ ret = qemuMonitorCreateSnapshot(priv->mon, snap->def->name);
+ if (qemuDomainObjExitMonitor(driver, vm) < 0)
+ ret = -1;
+ if (ret < 0)
+ goto cleanup;
+
+ if (!(snapdef->cookie = (virObjectPtr) qemuDomainSaveCookieNew(vm)))
+ goto cleanup;
+
+ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) {
+ event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED,
+ VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT);
+ qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT,
+ QEMU_ASYNC_JOB_SNAPSHOT, 0);
+ virDomainAuditStop(vm, "from-snapshot");
+ resume = false;
+ }
+
+ cleanup:
+ if (resume && virDomainObjIsActive(vm) &&
+ qemuProcessStartCPUs(driver, vm,
+ VIR_DOMAIN_RUNNING_UNPAUSED,
+ QEMU_ASYNC_JOB_SNAPSHOT) < 0) {
+ event = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_SUSPENDED,
+ VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR);
+ if (virGetLastErrorCode() == VIR_ERR_OK) {
+ virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+ _("resuming after snapshot failed"));
+ }
+ }
+
+ virObjectEventStateQueue(driver->domainEventState, event);
+
+ return ret;
+}
+
+
+static int
+qemuSnapshotPrepareDiskShared(virDomainSnapshotDiskDefPtr snapdisk,
+ virDomainDiskDefPtr domdisk)
+{
+ if (!domdisk->src->shared || domdisk->src->readonly)
+ return 0;
+
+ if (!qemuBlockStorageSourceSupportsConcurrentAccess(snapdisk->src)) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("shared access for disk '%s' requires use of "
+ "supported storage format"), domdisk->dst);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+qemuSnapshotPrepareDiskExternalInactive(virDomainSnapshotDiskDefPtr snapdisk,
+ virDomainDiskDefPtr domdisk)
+{
+ int domDiskType = virStorageSourceGetActualType(domdisk->src);
+ int snapDiskType = virStorageSourceGetActualType(snapdisk->src);
+
+ switch ((virStorageType)domDiskType) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
+ break;
+
+ case VIR_STORAGE_TYPE_NETWORK:
+ switch ((virStorageNetProtocol) domdisk->src->protocol) {
+ case VIR_STORAGE_NET_PROTOCOL_NONE:
+ case VIR_STORAGE_NET_PROTOCOL_NBD:
+ case VIR_STORAGE_NET_PROTOCOL_RBD:
+ case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+ case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
+ case VIR_STORAGE_NET_PROTOCOL_ISCSI:
+ case VIR_STORAGE_NET_PROTOCOL_HTTP:
+ case VIR_STORAGE_NET_PROTOCOL_HTTPS:
+ case VIR_STORAGE_NET_PROTOCOL_FTP:
+ case VIR_STORAGE_NET_PROTOCOL_FTPS:
+ case VIR_STORAGE_NET_PROTOCOL_TFTP:
+ case VIR_STORAGE_NET_PROTOCOL_SSH:
+ case VIR_STORAGE_NET_PROTOCOL_VXHS:
+ case VIR_STORAGE_NET_PROTOCOL_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("external inactive snapshots are not supported on "
+ "'network' disks using '%s' protocol"),
+ virStorageNetProtocolTypeToString(domdisk->src->protocol));
+ return -1;
+ }
+ break;
+
+ case VIR_STORAGE_TYPE_DIR:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_NVME:
+ case VIR_STORAGE_TYPE_NONE:
+ case VIR_STORAGE_TYPE_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("external inactive snapshots are not supported on "
+ "'%s' disks"), virStorageTypeToString(domDiskType));
+ return -1;
+ }
+
+ switch ((virStorageType)snapDiskType) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
+ break;
+
+ case VIR_STORAGE_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_DIR:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_NVME:
+ case VIR_STORAGE_TYPE_NONE:
+ case VIR_STORAGE_TYPE_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("external inactive snapshots are not supported on "
+ "'%s' disks"), virStorageTypeToString(snapDiskType));
+ return -1;
+ }
+
+ if (qemuSnapshotPrepareDiskShared(snapdisk, domdisk) < 0)
+ return -1;
+
+ return 0;
+}
+
+
+static int
+qemuSnapshotPrepareDiskExternalActive(virDomainObjPtr vm,
+ virDomainSnapshotDiskDefPtr snapdisk,
+ virDomainDiskDefPtr domdisk,
+ bool blockdev)
+{
+ int actualType = virStorageSourceGetActualType(snapdisk->src);
+
+ if (domdisk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("external active snapshots are not supported on scsi "
+ "passthrough devices"));
+ return -1;
+ }
+
+ if (!qemuDomainDiskBlockJobIsSupported(vm, domdisk))
+ return -1;
+
+ switch ((virStorageType)actualType) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
+ break;
+
+ case VIR_STORAGE_TYPE_NETWORK:
+ /* defer all of the checking to either qemu or libvirt's blockdev code */
+ if (blockdev)
+ break;
+
+ switch ((virStorageNetProtocol) snapdisk->src->protocol) {
+ case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
+ break;
+
+ case VIR_STORAGE_NET_PROTOCOL_NONE:
+ case VIR_STORAGE_NET_PROTOCOL_NBD:
+ case VIR_STORAGE_NET_PROTOCOL_RBD:
+ case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+ case VIR_STORAGE_NET_PROTOCOL_ISCSI:
+ case VIR_STORAGE_NET_PROTOCOL_HTTP:
+ case VIR_STORAGE_NET_PROTOCOL_HTTPS:
+ case VIR_STORAGE_NET_PROTOCOL_FTP:
+ case VIR_STORAGE_NET_PROTOCOL_FTPS:
+ case VIR_STORAGE_NET_PROTOCOL_TFTP:
+ case VIR_STORAGE_NET_PROTOCOL_SSH:
+ case VIR_STORAGE_NET_PROTOCOL_VXHS:
+ case VIR_STORAGE_NET_PROTOCOL_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("external active snapshots are not supported on "
+ "'network' disks using '%s' protocol"),
+ virStorageNetProtocolTypeToString(snapdisk->src->protocol));
+ return -1;
+
+ }
+ break;
+
+ case VIR_STORAGE_TYPE_DIR:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_NVME:
+ case VIR_STORAGE_TYPE_NONE:
+ case VIR_STORAGE_TYPE_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("external active snapshots are not supported on "
+ "'%s' disks"), virStorageTypeToString(actualType));
+ return -1;
+ }
+
+ if (qemuSnapshotPrepareDiskShared(snapdisk, domdisk) < 0)
+ return -1;
+
+ return 0;
+}
+
+
+static int
+qemuSnapshotPrepareDiskExternal(virDomainObjPtr vm,
+ virDomainDiskDefPtr disk,
+ virDomainSnapshotDiskDefPtr snapdisk,
+ bool active,
+ bool reuse,
+ bool blockdev)
+{
+ struct stat st;
+ int err;
+ int rc;
+
+ if (disk->src->readonly && !(reuse || blockdev)) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("external snapshot for readonly disk %s "
+ "is not supported"), disk->dst);
+ return -1;
+ }
+
+ if (qemuTranslateSnapshotDiskSourcePool(snapdisk) < 0)
+ return -1;
+
+ if (!active) {
+ if (virDomainDiskTranslateSourcePool(disk) < 0)
+ return -1;
+
+ if (qemuSnapshotPrepareDiskExternalInactive(snapdisk, disk) < 0)
+ return -1;
+ } else {
+ if (qemuSnapshotPrepareDiskExternalActive(vm, snapdisk, disk, blockdev) < 0)
+ return -1;
+ }
+
+ if (virStorageSourceIsLocalStorage(snapdisk->src)) {
+ if (virStorageFileInit(snapdisk->src) < 0)
+ return -1;
+
+ rc = virStorageFileStat(snapdisk->src, &st);
+ err = errno;
+
+ virStorageFileDeinit(snapdisk->src);
+
+ if (rc < 0) {
+ if (err != ENOENT) {
+ virReportSystemError(err,
+ _("unable to stat for disk %s: %s"),
+ snapdisk->name, snapdisk->src->path);
+ return -1;
+ } else if (reuse) {
+ virReportSystemError(err,
+ _("missing existing file for disk %s: %s"),
+ snapdisk->name, snapdisk->src->path);
+ return -1;
+ }
+ } else if (!S_ISBLK(st.st_mode) && st.st_size && !reuse) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("external snapshot file for disk %s already "
+ "exists and is not a block device: %s"),
+ snapdisk->name, snapdisk->src->path);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+
+static int
+qemuSnapshotPrepareDiskInternal(virDomainDiskDefPtr disk,
+ bool active)
+{
+ int actualType;
+
+ /* active disks are handled by qemu itself so no need to worry about those */
+ if (active)
+ return 0;
+
+ if (virDomainDiskTranslateSourcePool(disk) < 0)
+ return -1;
+
+ actualType = virStorageSourceGetActualType(disk->src);
+
+ switch ((virStorageType)actualType) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
+ return 0;
+
+ case VIR_STORAGE_TYPE_NETWORK:
+ switch ((virStorageNetProtocol) disk->src->protocol) {
+ case VIR_STORAGE_NET_PROTOCOL_NONE:
+ case VIR_STORAGE_NET_PROTOCOL_NBD:
+ case VIR_STORAGE_NET_PROTOCOL_RBD:
+ case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+ case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
+ case VIR_STORAGE_NET_PROTOCOL_ISCSI:
+ case VIR_STORAGE_NET_PROTOCOL_HTTP:
+ case VIR_STORAGE_NET_PROTOCOL_HTTPS:
+ case VIR_STORAGE_NET_PROTOCOL_FTP:
+ case VIR_STORAGE_NET_PROTOCOL_FTPS:
+ case VIR_STORAGE_NET_PROTOCOL_TFTP:
+ case VIR_STORAGE_NET_PROTOCOL_SSH:
+ case VIR_STORAGE_NET_PROTOCOL_VXHS:
+ case VIR_STORAGE_NET_PROTOCOL_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("internal inactive snapshots are not supported on "
+ "'network' disks using '%s' protocol"),
+ virStorageNetProtocolTypeToString(disk->src->protocol));
+ return -1;
+ }
+ break;
+
+ case VIR_STORAGE_TYPE_DIR:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_NVME:
+ case VIR_STORAGE_TYPE_NONE:
+ case VIR_STORAGE_TYPE_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("internal inactive snapshots are not supported on "
+ "'%s' disks"), virStorageTypeToString(actualType));
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+qemuSnapshotPrepare(virDomainObjPtr vm,
+ virDomainSnapshotDefPtr def,
+ unsigned int *flags)
+{
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
+ size_t i;
+ bool active = virDomainObjIsActive(vm);
+ bool reuse = (*flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
+ bool found_internal = false;
+ bool forbid_internal = false;
+ int external = 0;
+
+ for (i = 0; i < def->ndisks; i++) {
+ virDomainSnapshotDiskDefPtr disk = &def->disks[i];
+ virDomainDiskDefPtr dom_disk = vm->def->disks[i];
+
+ if (disk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_NONE &&
+ qemuDomainDiskBlockJobIsActive(dom_disk))
+ return -1;
+
+ switch ((virDomainSnapshotLocation) disk->snapshot) {
+ case VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL:
+ found_internal = true;
+
+ if (def->state == VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT && active) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("active qemu domains require external disk "
+ "snapshots; disk %s requested internal"),
+ disk->name);
+ return -1;
+ }
+
+ if (qemuSnapshotPrepareDiskInternal(dom_disk,
+ active) < 0)
+ return -1;
+
+ if (dom_disk->src->format > 0 &&
+ dom_disk->src->format != VIR_STORAGE_FILE_QCOW2) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("internal snapshot for disk %s unsupported "
+ "for storage type %s"),
+ disk->name,
+ virStorageFileFormatTypeToString(dom_disk->src->format));
+ return -1;
+ }
+ break;
+
+ case VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL:
+ if (!disk->src->format) {
+ disk->src->format = VIR_STORAGE_FILE_QCOW2;
+ } else if (disk->src->format != VIR_STORAGE_FILE_QCOW2 &&
+ disk->src->format != VIR_STORAGE_FILE_QED) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("external snapshot format for disk %s "
+ "is unsupported: %s"),
+ disk->name,
+ virStorageFileFormatTypeToString(disk->src->format));
+ return -1;
+ }
+
+ if (qemuSnapshotPrepareDiskExternal(vm, dom_disk, disk,
+ active, reuse, blockdev) < 0)
+ return -1;
+
+ external++;
+ break;
+
+ case VIR_DOMAIN_SNAPSHOT_LOCATION_NONE:
+ /* Remember seeing a disk that has snapshot disabled */
+ if (!virStorageSourceIsEmpty(dom_disk->src) &&
+ !dom_disk->src->readonly)
+ forbid_internal = true;
+ break;
+
+ case VIR_DOMAIN_SNAPSHOT_LOCATION_DEFAULT:
+ case VIR_DOMAIN_SNAPSHOT_LOCATION_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("unexpected code path"));
+ return -1;
+ }
+ }
+
+ if (!found_internal && !external &&
+ def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_NONE) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("nothing selected for snapshot"));
+ return -1;
+ }
+
+ /* internal snapshot requires a disk image to store the memory image to, and
+ * also disks can't be excluded from an internal snapshot */
+ if ((def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL && !found_internal) ||
+ (found_internal && forbid_internal)) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("internal and full system snapshots require all "
+ "disks to be selected for snapshot"));
+ return -1;
+ }
+
+ /* disk snapshot requires at least one disk */
+ if (def->state == VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT && !external) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("disk-only snapshots require at least "
+ "one disk to be selected for snapshot"));
+ return -1;
+ }
+
+ /* For now, we don't allow mixing internal and external disks.
+ * XXX technically, we could mix internal and external disks for
+ * offline snapshots */
+ if ((found_internal && external) ||
+ (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL && external) ||
+ (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL && found_internal)) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("mixing internal and external targets for a snapshot "
+ "is not yet supported"));
+ return -1;
+ }
+
+ /* internal snapshots + pflash based loader have the following problems:
+ * - if the variable store is raw, the snapshot fails
+ * - allowing a qcow2 image as the varstore would make it eligible to receive
+ * the vmstate dump, which would make it huge
+ * - offline snapshot would not snapshot the varstore at all
+ *
+ * Avoid the issues by forbidding internal snapshot with pflash completely.
+ */
+ if (found_internal &&
+ virDomainDefHasOldStyleUEFI(vm->def)) {
+ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+ _("internal snapshots of a VM with pflash based "
+ "firmware are not supported"));
+ return -1;
+ }
+
+ /* Alter flags to let later users know what we learned. */
+ if (external && !active)
+ *flags |= VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY;
+
+ return 0;
+}
+
+
+struct _qemuSnapshotDiskData {
+ virStorageSourcePtr src;
+ bool initialized; /* @src was initialized in the storage driver */
+ bool created; /* @src was created by the snapshot code */
+ bool prepared; /* @src was prepared using qemuDomainStorageSourceAccessAllow */
+ virDomainDiskDefPtr disk;
+ char *relPath; /* relative path component to fill into original disk */
+ qemuBlockStorageSourceChainDataPtr crdata;
+ bool blockdevadded;
+
+ virStorageSourcePtr persistsrc;
+ virDomainDiskDefPtr persistdisk;
+};
+
+typedef struct _qemuSnapshotDiskData qemuSnapshotDiskData;
+typedef qemuSnapshotDiskData *qemuSnapshotDiskDataPtr;
+
+
+static void
+qemuSnapshotDiskCleanup(qemuSnapshotDiskDataPtr data,
+ size_t ndata,
+ virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ qemuDomainAsyncJob asyncJob)
+{
+ virErrorPtr orig_err;
+ size_t i;
+
+ if (!data)
+ return;
+
+ virErrorPreserveLast(&orig_err);
+
+ for (i = 0; i < ndata; i++) {
+ /* on success of the snapshot the 'src' and 'persistsrc' properties will
+ * be set to NULL by qemuSnapshotDiskUpdateSource */
+ if (data[i].src) {
+ if (data[i].blockdevadded) {
+ if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
+
+ qemuBlockStorageSourceAttachRollback(qemuDomainGetMonitor(vm),
+ data[i].crdata->srcdata[0]);
+ ignore_value(qemuDomainObjExitMonitor(driver, vm));
+ }
+ }
+
+ if (data[i].created &&
+ virStorageFileUnlink(data[i].src) < 0) {
+ VIR_WARN("Unable to remove just-created %s",
+ NULLSTR(data[i].src->path));
+ }
+
+ if (data[i].initialized)
+ virStorageFileDeinit(data[i].src);
+
+ if (data[i].prepared)
+ qemuDomainStorageSourceAccessRevoke(driver, vm, data[i].src);
+
+ virObjectUnref(data[i].src);
+ }
+ virObjectUnref(data[i].persistsrc);
+ VIR_FREE(data[i].relPath);
+ qemuBlockStorageSourceChainDataFree(data[i].crdata);
+ }
+
+ VIR_FREE(data);
+ virErrorRestore(&orig_err);
+}
+
+
+/**
+ * qemuSnapshotDiskBitmapsPropagate:
+ *
+ * This function propagates any active persistent bitmap present in the original
+ * image into the new snapshot. This is necessary to keep tracking the changed
+ * blocks in the active bitmaps as the backing file will become read-only.
+ * We leave the original bitmap active as in cases when the overlay is
+ * discarded (snapshot revert with abandoning the history) everything works as
+ * expected.
+ */
+static int
+qemuSnapshotDiskBitmapsPropagate(qemuSnapshotDiskDataPtr dd,
+ virJSONValuePtr actions,
+ virHashTablePtr blockNamedNodeData)
+{
+ qemuBlockNamedNodeDataPtr entry;
+ size_t i;
+
+ if (!(entry = virHashLookup(blockNamedNodeData, dd->disk->src->nodeformat)))
+ return 0;
+
+ for (i = 0; i < entry->nbitmaps; i++) {
+ qemuBlockNamedNodeDataBitmapPtr bitmap = entry->bitmaps[i];
+
+ /* we don't care about temporary, inconsistent, or disabled bitmaps */
+ if (!bitmap->persistent || !bitmap->recording || bitmap->inconsistent)
+ continue;
+
+ if (qemuMonitorTransactionBitmapAdd(actions, dd->src->nodeformat,
+ bitmap->name, true, false,
+ bitmap->granularity) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+qemuSnapshotDiskPrepareOneBlockdev(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ qemuSnapshotDiskDataPtr dd,
+ virQEMUDriverConfigPtr cfg,
+ bool reuse,
+ virHashTablePtr blockNamedNodeData,
+ qemuDomainAsyncJob asyncJob)
+{
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ g_autoptr(virStorageSource) terminator = NULL;
+ int rc;
+
+ /* create a terminator for the snapshot disks so that qemu does not try
+ * to open them at first */
+ if (!(terminator = virStorageSourceNew()))
+ return -1;
+
+ if (qemuDomainPrepareStorageSourceBlockdev(dd->disk, dd->src,
+ priv, cfg) < 0)
+ return -1;
+
+ if (!(dd->crdata = qemuBuildStorageSourceChainAttachPrepareBlockdevTop(dd->src,
+ terminator,
+ priv->qemuCaps)))
+ return -1;
+
+ if (reuse) {
+ if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ return -1;
+
+ rc = qemuBlockStorageSourceAttachApply(qemuDomainGetMonitor(vm),
+ dd->crdata->srcdata[0]);
+
+ if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
+ return -1;
+ } else {
+ if (qemuBlockStorageSourceCreateDetectSize(blockNamedNodeData,
+ dd->src, dd->disk->src) < 0)
+ return -1;
+
+ if (qemuBlockStorageSourceCreate(vm, dd->src, dd->disk->src,
+ NULL, dd->crdata->srcdata[0],
+ asyncJob) < 0)
+ return -1;
+ }
+
+ dd->blockdevadded = true;
+ return 0;
+}
+
+
+static int
+qemuSnapshotDiskPrepareOne(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virQEMUDriverConfigPtr cfg,
+ virDomainDiskDefPtr disk,
+ virDomainSnapshotDiskDefPtr snapdisk,
+ qemuSnapshotDiskDataPtr dd,
+ virHashTablePtr blockNamedNodeData,
+ bool reuse,
+ bool blockdev,
+ qemuDomainAsyncJob asyncJob,
+ virJSONValuePtr actions)
+{
+ virDomainDiskDefPtr persistdisk;
+ bool supportsCreate;
+ bool updateRelativeBacking = false;
+
+ dd->disk = disk;
+
+ if (qemuDomainStorageSourceValidateDepth(disk->src, 1, disk->dst) < 0)
+ return -1;
+
+ if (!(dd->src = virStorageSourceCopy(snapdisk->src, false)))
+ return -1;
+
+ if (virStorageSourceInitChainElement(dd->src, dd->disk->src, false) < 0)
+ return -1;
+
+ /* modify disk in persistent definition only when the source is the same */
+ if (vm->newDef &&
+ (persistdisk = virDomainDiskByTarget(vm->newDef, dd->disk->dst)) &&
+ virStorageSourceIsSameLocation(dd->disk->src, persistdisk->src)) {
+
+ dd->persistdisk = persistdisk;
+
+ if (!(dd->persistsrc = virStorageSourceCopy(dd->src, false)))
+ return -1;
+
+ if (virStorageSourceInitChainElement(dd->persistsrc,
+ dd->persistdisk->src, false) < 0)
+ return -1;
+ }
+
+ supportsCreate = virStorageFileSupportsCreate(dd->src);
+
+ /* relative backing store paths need to be updated so that relative
+ * block commit still works. With blockdev we must update it when doing
+ * commit anyways so it's skipped here */
+ if (!blockdev &&
+ virStorageFileSupportsBackingChainTraversal(dd->src))
+ updateRelativeBacking = true;
+
+ if (supportsCreate || updateRelativeBacking) {
+ if (qemuDomainStorageFileInit(driver, vm, dd->src, NULL) < 0)
+ return -1;
+
+ dd->initialized = true;
+
+ if (reuse) {
+ if (updateRelativeBacking) {
+ g_autofree char *backingStoreStr = NULL;
+
+ if (virStorageFileGetBackingStoreStr(dd->src, &backingStoreStr) < 0)
+ return -1;
+ if (backingStoreStr != NULL) {
+ if (virStorageIsRelative(backingStoreStr))
+ dd->relPath = g_steal_pointer(&backingStoreStr);
+ }
+ }
+ } else {
+ /* pre-create the image file so that we can label it before handing it to qemu */
+ if (supportsCreate && dd->src->type != VIR_STORAGE_TYPE_BLOCK) {
+ if (virStorageFileCreate(dd->src) < 0) {
+ virReportSystemError(errno, _("failed to create image file '%s'"),
+ NULLSTR(dd->src->path));
+ return -1;
+ }
+ dd->created = true;
+ }
+ }
+ }
+
+ /* set correct security, cgroup and locking options on the new image */
+ if (qemuDomainStorageSourceAccessAllow(driver, vm, dd->src,
+ false, true, true) < 0)
+ return -1;
+
+ dd->prepared = true;
+
+ if (blockdev) {
+ if (qemuSnapshotDiskPrepareOneBlockdev(driver, vm, dd, cfg, reuse,
+ blockNamedNodeData, asyncJob) < 0)
+ return -1;
+
+ if (qemuSnapshotDiskBitmapsPropagate(dd, actions, blockNamedNodeData) < 0)
+ return -1;
+
+ if (qemuBlockSnapshotAddBlockdev(actions, dd->disk, dd->src) < 0)
+ return -1;
+ } else {
+ if (qemuBlockSnapshotAddLegacy(actions, dd->disk, dd->src, reuse) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+
+/**
+ * qemuSnapshotDiskPrepare:
+ *
+ * Collects and prepares a list of structures that hold information about disks
+ * that are selected for the snapshot.
+ */
+static int
+qemuSnapshotDiskPrepare(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainMomentObjPtr snap,
+ virQEMUDriverConfigPtr cfg,
+ bool reuse,
+ bool blockdev,
+ virHashTablePtr blockNamedNodeData,
+ qemuDomainAsyncJob asyncJob,
+ qemuSnapshotDiskDataPtr *rdata,
+ size_t *rndata,
+ virJSONValuePtr actions)
+{
+ size_t i;
+ qemuSnapshotDiskDataPtr data;
+ size_t ndata = 0;
+ virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+ int ret = -1;
+
+ if (VIR_ALLOC_N(data, snapdef->ndisks) < 0)
+ return -1;
+
+ for (i = 0; i < snapdef->ndisks; i++) {
+ if (snapdef->disks[i].snapshot == VIR_DOMAIN_SNAPSHOT_LOCATION_NONE)
+ continue;
+
+ if (qemuSnapshotDiskPrepareOne(driver, vm, cfg, vm->def->disks[i],
+ snapdef->disks + i,
+ data + ndata++,
+ blockNamedNodeData,
+ reuse, blockdev,
+ asyncJob,
+ actions) < 0)
+ goto cleanup;
+ }
+
+ *rdata = g_steal_pointer(&data);
+ *rndata = ndata;
+ ret = 0;
+
+ cleanup:
+ qemuSnapshotDiskCleanup(data, ndata, driver, vm, asyncJob);
+ return ret;
+}
+
+
+static void
+qemuSnapshotDiskUpdateSourceRenumber(virStorageSourcePtr src)
+{
+ virStorageSourcePtr next;
+ unsigned int idx = 1;
+
+ for (next = src->backingStore; virStorageSourceIsBacking(next); next = next->backingStore)
+ next->id = idx++;
+}
+
+
+/**
+ * qemuSnapshotDiskUpdateSource:
+ * @driver: QEMU driver
+ * @vm: domain object
+ * @dd: snapshot disk data object
+ * @blockdev: -blockdev is in use for the VM
+ *
+ * Updates disk definition after a successful snapshot.
+ */
+static void
+qemuSnapshotDiskUpdateSource(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ qemuSnapshotDiskDataPtr dd,
+ bool blockdev)
+{
+ /* storage driver access won'd be needed */
+ if (dd->initialized)
+ virStorageFileDeinit(dd->src);
+
+ if (qemuSecurityMoveImageMetadata(driver, vm, dd->disk->src, dd->src) < 0)
+ VIR_WARN("Unable to move disk metadata on vm %s", vm->def->name);
+
+ /* unlock the write lock on the original image as qemu will no longer write to it */
+ virDomainLockImageDetach(driver->lockManager, vm, dd->disk->src);
+
+ /* unlock also the new image if the VM is paused to follow the locking semantics */
+ if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING)
+ virDomainLockImageDetach(driver->lockManager, vm, dd->src);
+
+ /* the old disk image is now readonly */
+ dd->disk->src->readonly = true;
+
+ dd->disk->src->relPath = g_steal_pointer(&dd->relPath);
+ dd->src->backingStore = g_steal_pointer(&dd->disk->src);
+ dd->disk->src = g_steal_pointer(&dd->src);
+
+ /* fix numbering of disks */
+ if (!blockdev)
+ qemuSnapshotDiskUpdateSourceRenumber(dd->disk->src);
+
+ if (dd->persistdisk) {
+ dd->persistdisk->src->readonly = true;
+ dd->persistsrc->backingStore = g_steal_pointer(&dd->persistdisk->src);
+ dd->persistdisk->src = g_steal_pointer(&dd->persistsrc);
+ }
+}
+
+
+/* The domain is expected to be locked and active. */
+static int
+qemuSnapshotCreateDiskActive(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainMomentObjPtr snap,
+ virHashTablePtr blockNamedNodeData,
+ unsigned int flags,
+ virQEMUDriverConfigPtr cfg,
+ qemuDomainAsyncJob asyncJob)
+{
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ g_autoptr(virJSONValue) actions = NULL;
+ int rc;
+ int ret = -1;
+ size_t i;
+ bool reuse = (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
+ qemuSnapshotDiskDataPtr diskdata = NULL;
+ size_t ndiskdata = 0;
+ bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
+
+ if (virDomainObjCheckActive(vm) < 0)
+ return -1;
+
+ actions = virJSONValueNewArray();
+
+ /* prepare a list of objects to use in the vm definition so that we don't
+ * have to roll back later */
+ if (qemuSnapshotDiskPrepare(driver, vm, snap, cfg, reuse, blockdev,
+ blockNamedNodeData, asyncJob,
+ &diskdata, &ndiskdata, actions) < 0)
+ goto cleanup;
+
+ /* check whether there's anything to do */
+ if (ndiskdata == 0) {
+ ret = 0;
+ goto cleanup;
+ }
+
+ if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ goto cleanup;
+
+ rc = qemuMonitorTransaction(priv->mon, &actions);
+
+ if (qemuDomainObjExitMonitor(driver, vm) < 0)
+ rc = -1;
+
+ for (i = 0; i < ndiskdata; i++) {
+ qemuSnapshotDiskDataPtr dd = &diskdata[i];
+
+ virDomainAuditDisk(vm, dd->disk->src, dd->src, "snapshot", rc >= 0);
+
+ if (rc == 0)
+ qemuSnapshotDiskUpdateSource(driver, vm, dd, blockdev);
+ }
+
+ if (rc < 0)
+ goto cleanup;
+
+ if (virDomainObjSave(vm, driver->xmlopt, cfg->stateDir) < 0 ||
+ (vm->newDef && virDomainDefSave(vm->newDef, driver->xmlopt,
+ cfg->configDir) < 0))
+ goto cleanup;
+
+ ret = 0;
+
+ cleanup:
+ qemuSnapshotDiskCleanup(diskdata, ndiskdata, driver, vm, asyncJob);
+ return ret;
+}
+
+
+static int
+qemuSnapshotCreateActiveExternal(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainMomentObjPtr snap,
+ virQEMUDriverConfigPtr cfg,
+ unsigned int flags)
+{
+ virObjectEventPtr event;
+ bool resume = false;
+ int ret = -1;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ g_autofree char *xml = NULL;
+ virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+ bool memory = snapdef->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
+ bool memory_unlink = false;
+ int thaw = 0; /* 1 if freeze succeeded, -1 if freeze failed */
+ bool pmsuspended = false;
+ int compressed;
+ g_autoptr(virCommand) compressor = NULL;
+ virQEMUSaveDataPtr data = NULL;
+ g_autoptr(virHashTable) blockNamedNodeData = NULL;
+
+ /* If quiesce was requested, then issue a freeze command, and a
+ * counterpart thaw command when it is actually sent to agent.
+ * The command will fail if the guest is paused or the guest agent
+ * is not running, or is already quiesced. */
+ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE) {
+ int freeze;
+
+ if (qemuDomainObjBeginAgentJob(driver, vm, QEMU_AGENT_JOB_MODIFY) < 0)
+ goto cleanup;
+
+ if (virDomainObjCheckActive(vm) < 0) {
+ qemuDomainObjEndAgentJob(vm);
+ goto cleanup;
+ }
+
+ freeze = qemuSnapshotFSFreeze(vm, NULL, 0);
+ qemuDomainObjEndAgentJob(vm);
+
+ if (freeze < 0) {
+ /* the helper reported the error */
+ if (freeze == -2)
+ thaw = -1; /* the command is sent but agent failed */
+ goto cleanup;
+ }
+ thaw = 1;
+ }
+
+ /* We need to track what state the guest is in, since taking the
+ * snapshot may alter that state and we must restore it later. */
+ if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PMSUSPENDED) {
+ pmsuspended = true;
+ } else if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
+ /* For full system external snapshots (those with memory), the guest
+ * must pause (either by libvirt up front, or by qemu after
+ * _LIVE converges). */
+ if (memory)
+ resume = true;
+
+ if (memory && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_LIVE)) {
+ if (qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_SNAPSHOT,
+ QEMU_ASYNC_JOB_SNAPSHOT) < 0)
+ goto cleanup;
+
+ if (!virDomainObjIsActive(vm)) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("guest unexpectedly quit"));
+ goto cleanup;
+ }
+
+ resume = true;
+ }
+ }
+
+ /* We need to collect reply from 'query-named-block-nodes' prior to the
+ * migration step as qemu deactivates bitmaps after migration so the result
+ * would be wrong */
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV) &&
+ !(blockNamedNodeData = qemuBlockGetNamedNodeData(vm, QEMU_ASYNC_JOB_SNAPSHOT)))
+ goto cleanup;
+
+ /* do the memory snapshot if necessary */
+ if (memory) {
+ /* check if migration is possible */
+ if (!qemuMigrationSrcIsAllowed(driver, vm, false, 0))
+ goto cleanup;
+
+ priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP;
+
+ /* allow the migration job to be cancelled or the domain to be paused */
+ qemuDomainObjSetAsyncJobMask(vm, (QEMU_JOB_DEFAULT_MASK |
+ JOB_MASK(QEMU_JOB_SUSPEND) |
+ JOB_MASK(QEMU_JOB_MIGRATION_OP)));
+
+ if ((compressed = qemuSaveImageGetCompressionProgram(cfg->snapshotImageFormat,
+ &compressor,
+ "snapshot", false)) < 0)
+ goto cleanup;
+
+ if (!(xml = qemuDomainDefFormatLive(driver, priv->qemuCaps,
+ vm->def, priv->origCPU,
+ true, true)) ||
+ !(snapdef->cookie = (virObjectPtr) qemuDomainSaveCookieNew(vm)))
+ goto cleanup;
+
+ if (!(data = virQEMUSaveDataNew(xml,
+ (qemuDomainSaveCookiePtr) snapdef->cookie,
+ resume, compressed, driver->xmlopt)))
+ goto cleanup;
+ xml = NULL;
+
+ if ((ret = qemuSaveImageCreate(driver, vm, snapdef->file, data,
+ compressor, 0,
+ QEMU_ASYNC_JOB_SNAPSHOT)) < 0)
+ goto cleanup;
+
+ /* the memory image was created, remove it on errors */
+ memory_unlink = true;
+
+ /* forbid any further manipulation */
+ qemuDomainObjSetAsyncJobMask(vm, QEMU_JOB_DEFAULT_MASK);
+ }
+
+ /* the domain is now paused if a memory snapshot was requested */
+
+ if ((ret = qemuSnapshotCreateDiskActive(driver, vm, snap,
+ blockNamedNodeData, flags, cfg,
+ QEMU_ASYNC_JOB_SNAPSHOT)) < 0)
+ goto cleanup;
+
+ /* the snapshot is complete now */
+ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) {
+ event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED,
+ VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT);
+ qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT,
+ QEMU_ASYNC_JOB_SNAPSHOT, 0);
+ virDomainAuditStop(vm, "from-snapshot");
+ resume = false;
+ thaw = 0;
+ virObjectEventStateQueue(driver->domainEventState, event);
+ } else if (memory && pmsuspended) {
+ /* qemu 1.3 is unable to save a domain in pm-suspended (S3)
+ * state; so we must emit an event stating that it was
+ * converted to paused. */
+ virDomainObjSetState(vm, VIR_DOMAIN_PAUSED,
+ VIR_DOMAIN_PAUSED_FROM_SNAPSHOT);
+ event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED,
+ VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT);
+ virObjectEventStateQueue(driver->domainEventState, event);
+ }
+
+ ret = 0;
+
+ cleanup:
+ if (resume && virDomainObjIsActive(vm) &&
+ qemuProcessStartCPUs(driver, vm,
+ VIR_DOMAIN_RUNNING_UNPAUSED,
+ QEMU_ASYNC_JOB_SNAPSHOT) < 0) {
+ event = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_SUSPENDED,
+ VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR);
+ virObjectEventStateQueue(driver->domainEventState, event);
+ if (virGetLastErrorCode() == VIR_ERR_OK) {
+ virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+ _("resuming after snapshot failed"));
+ }
+
+ ret = -1;
+ }
+
+ if (thaw != 0 &&
+ qemuDomainObjBeginAgentJob(driver, vm, QEMU_AGENT_JOB_MODIFY) >= 0 &&
+ virDomainObjIsActive(vm)) {
+ if (qemuSnapshotFSThaw(vm, ret == 0 && thaw > 0) < 0) {
+ /* helper reported the error, if it was needed */
+ if (thaw > 0)
+ ret = -1;
+ }
+
+ qemuDomainObjEndAgentJob(vm);
+ }
+
+ virQEMUSaveDataFree(data);
+ if (memory_unlink && ret < 0)
+ unlink(snapdef->file);
+
+ return ret;
+}
+
+
+virDomainSnapshotPtr
+qemuSnapshotCreateXML(virDomainPtr domain,
+ virDomainObjPtr vm,
+ const char *xmlDesc,
+ unsigned int flags)
+{
+ virQEMUDriverPtr driver = domain->conn->privateData;
+ g_autofree char *xml = NULL;
+ virDomainMomentObjPtr snap = NULL;
+ virDomainSnapshotPtr snapshot = NULL;
+ virDomainMomentObjPtr current = NULL;
+ bool update_current = true;
+ bool redefine = flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE;
+ unsigned int parse_flags = VIR_DOMAIN_SNAPSHOT_PARSE_DISKS;
+ int align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL;
+ bool align_match = true;
+ g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainSnapshotState state;
+ g_autoptr(virDomainSnapshotDef) def = NULL;
+
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE |
+ VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT |
+ VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA |
+ VIR_DOMAIN_SNAPSHOT_CREATE_HALT |
+ VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY |
+ VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT |
+ VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE |
+ VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC |
+ VIR_DOMAIN_SNAPSHOT_CREATE_LIVE |
+ VIR_DOMAIN_SNAPSHOT_CREATE_VALIDATE, NULL);
+
+ VIR_REQUIRE_FLAG_RET(VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE,
+ VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY,
+ NULL);
+ VIR_EXCLUSIVE_FLAGS_RET(VIR_DOMAIN_SNAPSHOT_CREATE_LIVE,
+ VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE,
+ NULL);
+
+ if ((redefine && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT)) ||
+ (flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA))
+ update_current = false;
+ if (redefine)
+ parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE;
+
+ if (qemuDomainSupportsCheckpointsBlockjobs(vm) < 0)
+ goto cleanup;
+
+ if (!vm->persistent && (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT)) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("cannot halt after transient domain snapshot"));
+ goto cleanup;
+ }
+ if ((flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) ||
+ !virDomainObjIsActive(vm))
+ parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_OFFLINE;
+
+ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_VALIDATE)
+ parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_VALIDATE;
+
+ if (!(def = virDomainSnapshotDefParseString(xmlDesc, driver->xmlopt,
+ priv->qemuCaps, NULL, parse_flags)))
+ goto cleanup;
+
+ /* reject snapshot names containing slashes or starting with dot as
+ * snapshot definitions are saved in files named by the snapshot name */
+ if (!(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) {
+ if (strchr(def->parent.name, '/')) {
+ virReportError(VIR_ERR_XML_DETAIL,
+ _("invalid snapshot name '%s': "
+ "name can't contain '/'"),
+ def->parent.name);
+ goto cleanup;
+ }
+
+ if (def->parent.name[0] == '.') {
+ virReportError(VIR_ERR_XML_DETAIL,
+ _("invalid snapshot name '%s': "
+ "name can't start with '.'"),
+ def->parent.name);
+ goto cleanup;
+ }
+ }
+
+ /* reject the VIR_DOMAIN_SNAPSHOT_CREATE_LIVE flag where not supported */
+ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_LIVE &&
+ (!virDomainObjIsActive(vm) ||
+ def->memory != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)) {
+ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+ _("live snapshot creation is supported only "
+ "during full system snapshots"));
+ goto cleanup;
+ }
+
+ /* allow snapshots only in certain states */
+ state = redefine ? def->state : vm->state.state;
+ switch (state) {
+ /* valid states */
+ case VIR_DOMAIN_SNAPSHOT_RUNNING:
+ case VIR_DOMAIN_SNAPSHOT_PAUSED:
+ case VIR_DOMAIN_SNAPSHOT_SHUTDOWN:
+ case VIR_DOMAIN_SNAPSHOT_SHUTOFF:
+ case VIR_DOMAIN_SNAPSHOT_CRASHED:
+ break;
+
+ case VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT:
+ if (!redefine) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, _("Invalid domain state %s"),
+ virDomainSnapshotStateTypeToString(state));
+ goto cleanup;
+ }
+ break;
+
+ case VIR_DOMAIN_SNAPSHOT_PMSUSPENDED:
+ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+ _("qemu doesn't support taking snapshots of "
+ "PMSUSPENDED guests"));
+ goto cleanup;
+
+ /* invalid states */
+ case VIR_DOMAIN_SNAPSHOT_NOSTATE:
+ case VIR_DOMAIN_SNAPSHOT_BLOCKED: /* invalid state, unused in qemu */
+ case VIR_DOMAIN_SNAPSHOT_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR, _("Invalid domain state %s"),
+ virDomainSnapshotStateTypeToString(state));
+ goto cleanup;
+ }
+
+ /* We are going to modify the domain below. Internal snapshots would use
+ * a regular job, so we need to set the job mask to disallow query as
+ * 'savevm' blocks the monitor. External snapshot will then modify the
+ * job mask appropriately. */
+ if (qemuDomainObjBeginAsyncJob(driver, vm, QEMU_ASYNC_JOB_SNAPSHOT,
+ VIR_DOMAIN_JOB_OPERATION_SNAPSHOT, flags) < 0)
+ goto cleanup;
+
+ qemuDomainObjSetAsyncJobMask(vm, QEMU_JOB_NONE);
+
+ if (redefine) {
+ if (virDomainSnapshotRedefinePrep(vm, &def, &snap,
+ driver->xmlopt,
+ flags) < 0)
+ goto endjob;
+ } else {
+ /* Easiest way to clone inactive portion of vm->def is via
+ * conversion in and back out of xml. */
+ if (!(xml = qemuDomainDefFormatLive(driver, priv->qemuCaps,
+ vm->def, priv->origCPU,
+ true, true)) ||
+ !(def->parent.dom = virDomainDefParseString(xml, driver->xmlopt,
+ priv->qemuCaps,
+ VIR_DOMAIN_DEF_PARSE_INACTIVE |
+ VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE)))
+ goto endjob;
+
+ if (vm->newDef) {
+ def->parent.inactiveDom = virDomainDefCopy(vm->newDef,
+ driver->xmlopt, priv->qemuCaps, true);
+ if (!def->parent.inactiveDom)
+ goto endjob;
+ }
+
+ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) {
+ align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
+ align_match = false;
+ if (virDomainObjIsActive(vm))
+ def->state = VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT;
+ else
+ def->state = VIR_DOMAIN_SNAPSHOT_SHUTOFF;
+ def->memory = VIR_DOMAIN_SNAPSHOT_LOCATION_NONE;
+ } else if (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) {
+ def->state = virDomainObjGetState(vm, NULL);
+ align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
+ align_match = false;
+ } else {
+ def->state = virDomainObjGetState(vm, NULL);
+
+ if (virDomainObjIsActive(vm) &&
+ def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_NONE) {
+ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+ _("internal snapshot of a running VM "
+ "must include the memory state"));
+ goto endjob;
+ }
+
+ def->memory = (def->state == VIR_DOMAIN_SNAPSHOT_SHUTOFF ?
+ VIR_DOMAIN_SNAPSHOT_LOCATION_NONE :
+ VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL);
+ }
+ if (virDomainSnapshotAlignDisks(def, align_location,
+ align_match) < 0 ||
+ qemuSnapshotPrepare(vm, def, &flags) < 0)
+ goto endjob;
+ }
+
+ if (!snap) {
+ if (!(snap = virDomainSnapshotAssignDef(vm->snapshots, def)))
+ goto endjob;
+
+ def = NULL;
+ }
+
+ current = virDomainSnapshotGetCurrent(vm->snapshots);
+ if (current) {
+ if (!redefine)
+ snap->def->parent_name = g_strdup(current->def->name);
+ }
+
+ /* actually do the snapshot */
+ if (redefine) {
+ /* XXX Should we validate that the redefined snapshot even
+ * makes sense, such as checking that qemu-img recognizes the
+ * snapshot name in at least one of the domain's disks? */
+ } else if (virDomainObjIsActive(vm)) {
+ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY ||
+ virDomainSnapshotObjGetDef(snap)->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) {
+ /* external full system or disk snapshot */
+ if (qemuSnapshotCreateActiveExternal(driver, vm, snap, cfg, flags) < 0)
+ goto endjob;
+ } else {
+ /* internal full system */
+ if (qemuSnapshotCreateActiveInternal(driver, vm, snap, flags) < 0)
+ goto endjob;
+ }
+ } else {
+ /* inactive; qemuSnapshotPrepare guaranteed that we
+ * aren't mixing internal and external, and altered flags to
+ * contain DISK_ONLY if there is an external disk. */
+ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) {
+ bool reuse = !!(flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT);
+
+ if (qemuSnapshotCreateInactiveExternal(driver, vm, snap, reuse) < 0)
+ goto endjob;
+ } else {
+ if (qemuSnapshotCreateInactiveInternal(driver, vm, snap) < 0)
+ goto endjob;
+ }
+ }
+
+ /* If we fail after this point, there's not a whole lot we can
+ * do; we've successfully taken the snapshot, and we are now running
+ * on it, so we have to go forward the best we can
+ */
+ snapshot = virGetDomainSnapshot(domain, snap->def->name);
+
+ endjob:
+ if (snapshot && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) {
+ if (update_current)
+ virDomainSnapshotSetCurrent(vm->snapshots, snap);
+ if (qemuDomainSnapshotWriteMetadata(vm, snap,
+ driver->xmlopt,
+ cfg->snapshotDir) < 0) {
+ /* if writing of metadata fails, error out rather than trying
+ * to silently carry on without completing the snapshot */
+ virObjectUnref(snapshot);
+ snapshot = NULL;
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("unable to save metadata for snapshot %s"),
+ snap->def->name);
+ virDomainSnapshotObjListRemove(vm->snapshots, snap);
+ } else {
+ virDomainSnapshotLinkParent(vm->snapshots, snap);
+ }
+ } else if (snap) {
+ virDomainSnapshotObjListRemove(vm->snapshots, snap);
+ }
+
+ qemuDomainObjEndAsyncJob(driver, vm);
+
+ cleanup:
+ return snapshot;
+}
+
+
+/* The domain is expected to be locked and inactive. */
+static int
+qemuSnapshotRevertInactive(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainMomentObjPtr snap)
+{
+ /* Try all disks, but report failure if we skipped any. */
+ int ret = qemuDomainSnapshotForEachQcow2(driver, vm, snap, "-a", true);
+ return ret > 0 ? -1 : ret;
+}
+
+
+int
+qemuSnapshotRevert(virDomainObjPtr vm,
+ virDomainSnapshotPtr snapshot,
+ unsigned int flags)
+{
+ virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
+ int ret = -1;
+ virDomainMomentObjPtr snap = NULL;
+ virDomainSnapshotDefPtr snapdef;
+ virObjectEventPtr event = NULL;
+ virObjectEventPtr event2 = NULL;
+ int detail;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ int rc;
+ virDomainDefPtr config = NULL;
+ virDomainDefPtr inactiveConfig = NULL;
+ g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
+ bool was_stopped = false;
+ qemuDomainSaveCookiePtr cookie;
+ virCPUDefPtr origCPU = NULL;
+ unsigned int start_flags = VIR_QEMU_PROCESS_START_GEN_VMID;
+ qemuDomainAsyncJob jobType = QEMU_ASYNC_JOB_START;
+ bool defined = false;
+
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
+ VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED |
+ VIR_DOMAIN_SNAPSHOT_REVERT_FORCE, -1);
+
+ /* We have the following transitions, which create the following events:
+ * 1. inactive -> inactive: none
+ * 2. inactive -> running: EVENT_STARTED
+ * 3. inactive -> paused: EVENT_STARTED, EVENT_PAUSED
+ * 4. running -> inactive: EVENT_STOPPED
+ * 5. running -> running: none
+ * 6. running -> paused: EVENT_PAUSED
+ * 7. paused -> inactive: EVENT_STOPPED
+ * 8. paused -> running: EVENT_RESUMED
+ * 9. paused -> paused: none
+ * Also, several transitions occur even if we fail partway through,
+ * and use of FORCE can cause multiple transitions.
+ */
+
+ if (qemuDomainHasBlockjob(vm, false)) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("domain has active block job"));
+ goto cleanup;
+ }
+
+ if (qemuProcessBeginJob(driver, vm,
+ VIR_DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT,
+ flags) < 0)
+ goto cleanup;
+
+ if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
+ goto endjob;
+ snapdef = virDomainSnapshotObjGetDef(snap);
+
+ if (!vm->persistent &&
+ snapdef->state != VIR_DOMAIN_SNAPSHOT_RUNNING &&
+ snapdef->state != VIR_DOMAIN_SNAPSHOT_PAUSED &&
+ (flags & (VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
+ VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED)) == 0) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("transient domain needs to request run or pause "
+ "to revert to inactive snapshot"));
+ goto endjob;
+ }
+
+ if (virDomainSnapshotIsExternal(snap)) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("revert to external snapshot not supported yet"));
+ goto endjob;
+ }
+
+ if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) {
+ if (!snap->def->dom) {
+ virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY,
+ _("snapshot '%s' lacks domain '%s' rollback info"),
+ snap->def->name, vm->def->name);
+ goto endjob;
+ }
+ if (virDomainObjIsActive(vm) &&
+ !(snapdef->state == VIR_DOMAIN_SNAPSHOT_RUNNING ||
+ snapdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED) &&
+ (flags & (VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
+ VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED))) {
+ virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, "%s",
+ _("must respawn qemu to start inactive snapshot"));
+ goto endjob;
+ }
+ if (vm->hasManagedSave &&
+ !(snapdef->state == VIR_DOMAIN_SNAPSHOT_RUNNING ||
+ snapdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED)) {
+ virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, "%s",
+ _("snapshot without memory state, removal of "
+ "existing managed saved state strongly "
+ "recommended to avoid corruption"));
+ goto endjob;
+ }
+ }
+
+ if (snap->def->dom) {
+ config = virDomainDefCopy(snap->def->dom,
+ driver->xmlopt, priv->qemuCaps, true);
+ if (!config)
+ goto endjob;
+ }
+
+ if (snap->def->inactiveDom) {
+ inactiveConfig = virDomainDefCopy(snap->def->inactiveDom,
+ driver->xmlopt, priv->qemuCaps, true);
+ if (!inactiveConfig)
+ goto endjob;
+ } else {
+ /* Inactive domain definition is missing:
+ * - either this is an old active snapshot and we need to copy the
+ * active definition as an inactive one
+ * - or this is an inactive snapshot which means config contains the
+ * inactive definition.
+ */
+ if (snapdef->state == VIR_DOMAIN_SNAPSHOT_RUNNING ||
+ snapdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED) {
+ inactiveConfig = virDomainDefCopy(snap->def->dom,
+ driver->xmlopt, priv->qemuCaps, true);
+ if (!inactiveConfig)
+ goto endjob;
+ } else {
+ inactiveConfig = g_steal_pointer(&config);
+ }
+ }
+
+ cookie = (qemuDomainSaveCookiePtr) snapdef->cookie;
+
+ switch ((virDomainSnapshotState) snapdef->state) {
+ case VIR_DOMAIN_SNAPSHOT_RUNNING:
+ case VIR_DOMAIN_SNAPSHOT_PAUSED:
+ start_flags |= VIR_QEMU_PROCESS_START_PAUSED;
+
+ /* Transitions 2, 3, 5, 6, 8, 9 */
+ /* When using the loadvm monitor command, qemu does not know
+ * whether to pause or run the reverted domain, and just stays
+ * in the same state as before the monitor command, whether
+ * that is paused or running. We always pause before loadvm,
+ * to have finer control. */
+ if (virDomainObjIsActive(vm)) {
+ /* Transitions 5, 6, 8, 9 */
+ /* Check for ABI compatibility. We need to do this check against
+ * the migratable XML or it will always fail otherwise */
+ if (config) {
+ bool compatible;
+
+ /* Replace the CPU in config and put the original one in priv
+ * once we're done. When we have the updated CPU def in the
+ * cookie, we don't want to replace the CPU in migratable def
+ * when doing ABI checks to make sure the current CPU exactly
+ * matches the one used at the time the snapshot was taken.
+ */
+ if (cookie && cookie->cpu && config->cpu) {
+ origCPU = config->cpu;
+ if (!(config->cpu = virCPUDefCopy(cookie->cpu)))
+ goto endjob;
+
+ compatible = qemuDomainDefCheckABIStability(driver,
+ priv->qemuCaps,
+ vm->def,
+ config);
+ } else {
+ compatible = qemuDomainCheckABIStability(driver, vm, config);
+ }
+
+ /* If using VM GenID, there is no way currently to change
+ * the genid for the running guest, so set an error,
+ * mark as incompatible, and don't allow change of genid
+ * if the revert force flag would start the guest again. */
+ if (compatible && config->genidRequested) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("domain genid update requires restart"));
+ compatible = false;
+ start_flags &= ~VIR_QEMU_PROCESS_START_GEN_VMID;
+ }
+
+ if (!compatible) {
+ virErrorPtr err = virGetLastError();
+
+ if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)) {
+ /* Re-spawn error using correct category. */
+ if (err->code == VIR_ERR_CONFIG_UNSUPPORTED)
+ virReportError(VIR_ERR_SNAPSHOT_REVERT_RISKY, "%s",
+ err->str2);
+ goto endjob;
+ }
+ virResetError(err);
+ qemuProcessStop(driver, vm,
+ VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT,
+ QEMU_ASYNC_JOB_START, 0);
+ virDomainAuditStop(vm, "from-snapshot");
+ detail = VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT;
+ event = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_STOPPED,
+ detail);
+ virObjectEventStateQueue(driver->domainEventState, event);
+ /* Start after stop won't be an async start job, so
+ * reset to none */
+ jobType = QEMU_ASYNC_JOB_NONE;
+ goto load;
+ }
+ }
+
+ if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
+ /* Transitions 5, 6 */
+ if (qemuProcessStopCPUs(driver, vm,
+ VIR_DOMAIN_PAUSED_FROM_SNAPSHOT,
+ QEMU_ASYNC_JOB_START) < 0)
+ goto endjob;
+ if (!virDomainObjIsActive(vm)) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("guest unexpectedly quit"));
+ goto endjob;
+ }
+ }
+
+ if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ QEMU_ASYNC_JOB_START) < 0)
+ goto endjob;
+ rc = qemuMonitorLoadSnapshot(priv->mon, snap->def->name);
+ if (qemuDomainObjExitMonitor(driver, vm) < 0)
+ goto endjob;
+ if (rc < 0) {
+ /* XXX resume domain if it was running before the
+ * failed loadvm attempt? */
+ goto endjob;
+ }
+ if (config) {
+ virCPUDefFree(priv->origCPU);
+ priv->origCPU = g_steal_pointer(&origCPU);
+ }
+
+ if (cookie && !cookie->slirpHelper)
+ priv->disableSlirp = true;
+
+ if (inactiveConfig) {
+ virDomainObjAssignDef(vm, inactiveConfig, false, NULL);
+ inactiveConfig = NULL;
+ defined = true;
+ }
+ } else {
+ /* Transitions 2, 3 */
+ load:
+ was_stopped = true;
+
+ if (inactiveConfig) {
+ virDomainObjAssignDef(vm, inactiveConfig, false, NULL);
+ inactiveConfig = NULL;
+ defined = true;
+ }
+
+ if (config) {
+ virDomainObjAssignDef(vm, config, true, NULL);
+ config = NULL;
+ }
+
+ /* No cookie means libvirt which saved the domain was too old to
+ * mess up the CPU definitions.
+ */
+ if (cookie &&
+ qemuDomainFixupCPUs(vm, &cookie->cpu) < 0)
+ goto cleanup;
+
+ rc = qemuProcessStart(snapshot->domain->conn, driver, vm,
+ cookie ? cookie->cpu : NULL,
+ jobType, NULL, -1, NULL, snap,
+ VIR_NETDEV_VPORT_PROFILE_OP_CREATE,
+ start_flags);
+ virDomainAuditStart(vm, "from-snapshot", rc >= 0);
+ detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT;
+ event = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_STARTED,
+ detail);
+ if (rc < 0)
+ goto endjob;
+ }
+
+ /* Touch up domain state. */
+ if (!(flags & VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING) &&
+ (snapdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED ||
+ (flags & VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED))) {
+ /* Transitions 3, 6, 9 */
+ virDomainObjSetState(vm, VIR_DOMAIN_PAUSED,
+ VIR_DOMAIN_PAUSED_FROM_SNAPSHOT);
+ if (was_stopped) {
+ /* Transition 3, use event as-is and add event2 */
+ detail = VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT;
+ event2 = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_SUSPENDED,
+ detail);
+ } /* else transition 6 and 9 use event as-is */
+ } else {
+ /* Transitions 2, 5, 8 */
+ if (!virDomainObjIsActive(vm)) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("guest unexpectedly quit"));
+ goto endjob;
+ }
+ rc = qemuProcessStartCPUs(driver, vm,
+ VIR_DOMAIN_RUNNING_FROM_SNAPSHOT,
+ jobType);
+ if (rc < 0)
+ goto endjob;
+ virObjectUnref(event);
+ event = NULL;
+ if (was_stopped) {
+ /* Transition 2 */
+ detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT;
+ event = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_STARTED,
+ detail);
+ }
+ }
+ break;
+
+ case VIR_DOMAIN_SNAPSHOT_SHUTDOWN:
+ case VIR_DOMAIN_SNAPSHOT_SHUTOFF:
+ case VIR_DOMAIN_SNAPSHOT_CRASHED:
+ /* Transitions 1, 4, 7 */
+ /* Newer qemu -loadvm refuses to revert to the state of a snapshot
+ * created by qemu-img snapshot -c. If the domain is running, we
+ * must take it offline; then do the revert using qemu-img.
+ */
+
+ if (virDomainObjIsActive(vm)) {
+ /* Transitions 4, 7 */
+ qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT,
+ QEMU_ASYNC_JOB_START, 0);
+ virDomainAuditStop(vm, "from-snapshot");
+ detail = VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT;
+ event = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_STOPPED,
+ detail);
+ }
+
+ if (qemuSnapshotRevertInactive(driver, vm, snap) < 0) {
+ qemuDomainRemoveInactive(driver, vm);
+ qemuProcessEndJob(driver, vm);
+ goto cleanup;
+ }
+
+ if (inactiveConfig) {
+ virDomainObjAssignDef(vm, inactiveConfig, false, NULL);
+ inactiveConfig = NULL;
+ defined = true;
+ }
+
+ if (flags & (VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
+ VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED)) {
+ /* Flush first event, now do transition 2 or 3 */
+ bool paused = (flags & VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED) != 0;
+
+ start_flags |= paused ? VIR_QEMU_PROCESS_START_PAUSED : 0;
+
+ virObjectEventStateQueue(driver->domainEventState, event);
+ rc = qemuProcessStart(snapshot->domain->conn, driver, vm, NULL,
+ QEMU_ASYNC_JOB_START, NULL, -1, NULL, NULL,
+ VIR_NETDEV_VPORT_PROFILE_OP_CREATE,
+ start_flags);
+ virDomainAuditStart(vm, "from-snapshot", rc >= 0);
+ if (rc < 0) {
+ qemuDomainRemoveInactive(driver, vm);
+ qemuProcessEndJob(driver, vm);
+ goto cleanup;
+ }
+ detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT;
+ event = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_STARTED,
+ detail);
+ if (paused) {
+ detail = VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT;
+ event2 = virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_SUSPENDED,
+ detail);
+ }
+ }
+ break;
+
+ case VIR_DOMAIN_SNAPSHOT_PMSUSPENDED:
+ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+ _("qemu doesn't support reversion of snapshot taken in "
+ "PMSUSPENDED state"));
+ goto endjob;
+
+ case VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT:
+ /* Rejected earlier as an external snapshot */
+ case VIR_DOMAIN_SNAPSHOT_NOSTATE:
+ case VIR_DOMAIN_SNAPSHOT_BLOCKED:
+ case VIR_DOMAIN_SNAPSHOT_LAST:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Invalid target domain state '%s'. Refusing "
+ "snapshot reversion"),
+ virDomainSnapshotStateTypeToString(snapdef->state));
+ goto endjob;
+ }
+
+ ret = 0;
+
+ endjob:
+ qemuProcessEndJob(driver, vm);
+
+ cleanup:
+ if (ret == 0) {
+ virDomainSnapshotSetCurrent(vm->snapshots, snap);
+ if (qemuDomainSnapshotWriteMetadata(vm, snap,
+ driver->xmlopt,
+ cfg->snapshotDir) < 0) {
+ virDomainSnapshotSetCurrent(vm->snapshots, NULL);
+ ret = -1;
+ }
+ }
+ if (ret == 0 && defined && vm->persistent &&
+ !(ret = virDomainDefSave(vm->newDef ? vm->newDef : vm->def,
+ driver->xmlopt, cfg->configDir))) {
+ detail = VIR_DOMAIN_EVENT_DEFINED_FROM_SNAPSHOT;
+ virObjectEventStateQueue(driver->domainEventState,
+ virDomainEventLifecycleNewFromObj(vm,
+ VIR_DOMAIN_EVENT_DEFINED,
+ detail));
+ }
+ virObjectEventStateQueue(driver->domainEventState, event);
+ virObjectEventStateQueue(driver->domainEventState, event2);
+ virCPUDefFree(origCPU);
+ virDomainDefFree(config);
+ virDomainDefFree(inactiveConfig);
+
+ return ret;
+}
+
+
+typedef struct _virQEMUMomentReparent virQEMUMomentReparent;
+typedef virQEMUMomentReparent *virQEMUMomentReparentPtr;
+struct _virQEMUMomentReparent {
+ const char *dir;
+ virDomainMomentObjPtr parent;
+ virDomainObjPtr vm;
+ virDomainXMLOptionPtr xmlopt;
+ int err;
+ int (*writeMetadata)(virDomainObjPtr, virDomainMomentObjPtr,
+ virDomainXMLOptionPtr, const char *);
+};
+
+
+static int
+qemuSnapshotChildrenReparent(void *payload,
+ const void *name G_GNUC_UNUSED,
+ void *data)
+{
+ virDomainMomentObjPtr moment = payload;
+ virQEMUMomentReparentPtr rep = data;
+
+ if (rep->err < 0)
+ return 0;
+
+ VIR_FREE(moment->def->parent_name);
+
+ if (rep->parent->def)
+ moment->def->parent_name = g_strdup(rep->parent->def->name);
+
+ rep->err = rep->writeMetadata(rep->vm, moment, rep->xmlopt,
+ rep->dir);
+ return 0;
+}
+
+
+int
+qemuSnapshotDelete(virDomainObjPtr vm,
+ virDomainSnapshotPtr snapshot,
+ unsigned int flags)
+{
+ virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
+ int ret = -1;
+ virDomainMomentObjPtr snap = NULL;
+ virQEMUMomentRemove rem;
+ virQEMUMomentReparent rep;
+ bool metadata_only = !!(flags & VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY);
+ int external = 0;
+ g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
+
+ virCheckFlags(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
+ VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY |
+ VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY, -1);
+
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
+ goto cleanup;
+
+ if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
+ goto endjob;
+
+ if (!metadata_only) {
+ if (!(flags & VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY) &&
+ virDomainSnapshotIsExternal(snap))
+ external++;
+ if (flags & (VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
+ VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY))
+ virDomainMomentForEachDescendant(snap,
+ qemuSnapshotCountExternal,
+ &external);
+ if (external) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("deletion of %d external disk snapshots not "
+ "supported yet"), external);
+ goto endjob;
+ }
+ }
+
+ if (flags & (VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
+ VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY)) {
+ rem.driver = driver;
+ rem.vm = vm;
+ rem.metadata_only = metadata_only;
+ rem.err = 0;
+ rem.current = virDomainSnapshotGetCurrent(vm->snapshots);
+ rem.found = false;
+ rem.momentDiscard = qemuDomainSnapshotDiscard;
+ virDomainMomentForEachDescendant(snap, qemuDomainMomentDiscardAll,
+ &rem);
+ if (rem.err < 0)
+ goto endjob;
+ if (rem.found) {
+ virDomainSnapshotSetCurrent(vm->snapshots, snap);
+ if (flags & VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY) {
+ if (qemuDomainSnapshotWriteMetadata(vm, snap,
+ driver->xmlopt,
+ cfg->snapshotDir) < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("failed to set snapshot '%s' as current"),
+ snap->def->name);
+ virDomainSnapshotSetCurrent(vm->snapshots, NULL);
+ goto endjob;
+ }
+ }
+ }
+ } else if (snap->nchildren) {
+ rep.dir = cfg->snapshotDir;
+ rep.parent = snap->parent;
+ rep.vm = vm;
+ rep.err = 0;
+ rep.xmlopt = driver->xmlopt;
+ rep.writeMetadata = qemuDomainSnapshotWriteMetadata;
+ virDomainMomentForEachChild(snap,
+ qemuSnapshotChildrenReparent,
+ &rep);
+ if (rep.err < 0)
+ goto endjob;
+ virDomainMomentMoveChildren(snap, snap->parent);
+ }
+
+ if (flags & VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY) {
+ virDomainMomentDropChildren(snap);
+ ret = 0;
+ } else {
+ ret = qemuDomainSnapshotDiscard(driver, vm, snap, true, metadata_only);
+ }
+
+ endjob:
+ qemuDomainObjEndJob(driver, vm);
+
+ cleanup:
+ return ret;
+}
diff --git a/src/qemu/qemu_snapshot.h b/src/qemu/qemu_snapshot.h
new file mode 100644
index 0000000000..8b3ebe87b1
--- /dev/null
+++ b/src/qemu/qemu_snapshot.h
@@ -0,0 +1,55 @@
+/*
+ * qemu_snapshot.h: Implementation and handling of snapshots
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include "virconftypes.h"
+#include "datatypes.h"
+#include "qemu_conf.h"
+
+virDomainMomentObjPtr
+qemuSnapObjFromName(virDomainObjPtr vm,
+ const char *name);
+
+virDomainMomentObjPtr
+qemuSnapObjFromSnapshot(virDomainObjPtr vm,
+ virDomainSnapshotPtr snapshot);
+
+int
+qemuSnapshotFSFreeze(virDomainObjPtr vm,
+ const char **mountpoints,
+ unsigned int nmountpoints);
+int
+qemuSnapshotFSThaw(virDomainObjPtr vm,
+ bool report);
+
+virDomainSnapshotPtr
+qemuSnapshotCreateXML(virDomainPtr domain,
+ virDomainObjPtr vm,
+ const char *xmlDesc,
+ unsigned int flags);
+
+int
+qemuSnapshotRevert(virDomainObjPtr vm,
+ virDomainSnapshotPtr snapshot,
+ unsigned int flags);
+
+int
+qemuSnapshotDelete(virDomainObjPtr vm,
+ virDomainSnapshotPtr snapshot,
+ unsigned int flags);
--
2.26.2
