For Backuping the disk image. It supports tree backup mode: full, top, incremental. Incremental backup mode must do full or top backup first, and it exists dirty bitmap to trace io. Signed-off-by: longyou <longyou(a)mogujie.com&gt; --- docs/apibuild.py | 3 ++- include/libvirt/libvirt-domain.h | 15 +++++++++++ src/driver-hypervisor.h | 9 +++++++ src/libvirt-domain.c | 56 ++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 5 ++++ src/remote/remote_driver.c | 1 + src/remote/remote_protocol.x | 17 +++++++++++- src/remote_protocol-structs | 9 +++++++ 8 files changed, 113 insertions(+), 2 deletions(-) diff --git a/docs/apibuild.py b/docs/apibuild.py index f5216ea..42ce538 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -1851,7 +1851,8 @@ class CParser: "virDomainBlockJobSetSpeed" : (False, ("bandwidth")), "virDomainBlockPull" : (False, ("bandwidth")), "virDomainBlockRebase" : (False, ("bandwidth")), - "virDomainMigrateGetMaxSpeed" : (False, ("bandwidth")) } + "virDomainMigrateGetMaxSpeed" : (False, ("bandwidth")), + "virDomainBlockBackup" : (False, ("bandwidth")) } def checkLongLegacyFunction(self, name, return_type, signature): if "long" in return_type and "long long" not in return_type: diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h index cba4fa5..3a9ab6c 100644 --- a/include/libvirt/libvirt-domain.h +++ b/include/libvirt/libvirt-domain.h @@ -2139,6 +2139,21 @@ int virDomainBlockCommit(virDomainPtr dom, const char *disk, const char *base, const char *top, unsigned long bandwidth, unsigned int flags); +/** + * virDomainBlockBackupFlags: + * + * Flags available for virDomainBlockBackup(). + */ +typedef enum { + VIR_DOMAIN_BLOCK_BACKUP_FULL = 1 << 1, /* Backup with full mode */ + VIR_DOMAIN_BLOCK_BACKUP_TOP = 1 << 2, /* Backup with top mode */ + VIR_DOMAIN_BLOCK_BACKUP_INCREMENTAL = 1 << 3, /* Backup with incremental + mode by dirty bitmap */ +} virDomainBlockBackupFlags; + +int virDomainBlockBackup(virDomainPtr dom, const char *path, const char *dest, + unsigned long bandwidth, const char *format, + unsigned int flags); /* Block I/O throttling support */ diff --git a/src/driver-hypervisor.h b/src/driver-hypervisor.h index d11ff7f..171eb14 100644 --- a/src/driver-hypervisor.h +++ b/src/driver-hypervisor.h @@ -1020,6 +1020,14 @@ typedef int unsigned int flags); typedef int +(*virDrvDomainBlockBackup)(virDomainPtr dom, + const char *path, + const char *dest, + unsigned long long bandwidth, + const char *format, + unsigned int flags); + +typedef int (*virDrvConnectSetKeepAlive)(virConnectPtr conn, int interval, unsigned int count); @@ -1436,6 +1444,7 @@ struct _virHypervisorDriver { virDrvDomainBlockRebase domainBlockRebase; virDrvDomainBlockCopy domainBlockCopy; virDrvDomainBlockCommit domainBlockCommit; + virDrvDomainBlockBackup domainBlockBackup; virDrvConnectSetKeepAlive connectSetKeepAlive; virDrvConnectIsAlive connectIsAlive; virDrvNodeSuspendForDuration nodeSuspendForDuration; diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c index 73ae369..18ef249 100644 --- a/src/libvirt-domain.c +++ b/src/libvirt-domain.c @@ -10473,6 +10473,62 @@ virDomainBlockCommit(virDomainPtr dom, const char *disk, /** + * virDomainBlockBackup: + * @dom: pointer to domain object + * @path: path to the block device, or device shorthand + * @dest: path to image for backup + * @bandwidth: (optional) specify bandwidth limit; flags determine the unit + * @format: (optional) the dest image format + * @flags: bitwise-OR of virDomainBlockBackupFlags + * + * Backup the path image to dest image, it supports three backup mode: + * "full" mode with flags VIR_DOMAIN_BLOCK_BACKUP_FULL, it will backup all + * data in the image chain. + * "top" mode with flags VIR_DOMAIN_BLOCK_BACKUP_TOP, it only backup the + * data of top image to dest image. + * "incremental" mode with flags VIR_DOMAIN_BLOCK_BACKUP_INCREMENTAL, it wosks + * with dirty bitmap when done the "full" or "top" mode backup. Incremental + * backup only backup the data in the dirty bitmap. + * + * Returns 0 if the operation has started, -1 on failure. + */ +int +virDomainBlockBackup(virDomainPtr dom, const char *path, + const char *dest, unsigned long bandwidth, + const char *format, unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(dom, "path=%s, dest=%s, bandwidth=%lu, format=%s, flags=%x", + path, dest, bandwidth, format, flags); + + virResetLastError(); + + virCheckDomainReturn(dom, -1); + conn = dom->conn; + + virCheckReadOnlyGoto(conn->flags, error); + virCheckNonNullArgGoto(path, error); + virCheckNonNullArgGoto(dest, error); + + if (conn->driver->domainBlockBackup) { + int ret; + ret = conn->driver->domainBlockBackup(dom, path, dest, + bandwidth, format, flags); + if (ret < 0) + goto error; + return ret; + } + + virReportUnsupportedError(); + +error: + virDispatchError(dom->conn); + return -1; +} + + +/** * virDomainOpenGraphics: * @dom: pointer to domain object * @idx: index of graphics config to open diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index 1e920d6..34a2fff 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -732,4 +732,9 @@ LIBVIRT_1.3.3 { virDomainSetPerfEvents; } LIBVIRT_1.2.19; +LIBVIRT_1.3.6 { + global: + virDomainBlockBackup; +} LIBVIRT_1.3.3; + # .... define new API here using predicted next version number .... diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index e3cf5fb..7513a7f 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -7796,6 +7796,7 @@ static virHypervisorDriver hypervisor_driver = { .domainBlockRebase = remoteDomainBlockRebase, /* 0.9.10 */ .domainBlockCopy = remoteDomainBlockCopy, /* 1.2.9 */ .domainBlockCommit = remoteDomainBlockCommit, /* 0.10.2 */ + .domainBlockBackup = remoteDomainBlockBackup, /* 1.3.6 */ .connectSetKeepAlive = remoteConnectSetKeepAlive, /* 0.9.8 */ .connectIsAlive = remoteConnectIsAlive, /* 0.9.8 */ .nodeSuspendForDuration = remoteNodeSuspendForDuration, /* 0.9.8 */ diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index bab8ef2..0f3b29c 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -1364,6 +1364,15 @@ struct remote_domain_block_commit_args { unsigned int flags; }; +struct remote_domain_block_backup_args { + remote_nonnull_domain dom; + remote_nonnull_string path; + remote_nonnull_string dest; + unsigned hyper bandwidth; + remote_string format; + unsigned int flags; +}; + struct remote_domain_set_block_io_tune_args { remote_nonnull_domain dom; remote_nonnull_string disk; @@ -5793,5 +5802,11 @@ enum remote_procedure { * @generate: both * @acl: none */ - REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVAL_FAILED = 367 + REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVAL_FAILED = 367, + + /** + * @generate: both + * @acl: domain:block_write + */ + REMOTE_PROC_DOMAIN_BLOCK_BACKUP = 368 }; diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index fe1b8a8..e3cc5c5 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -996,6 +996,14 @@ struct remote_domain_block_commit_args { uint64_t bandwidth; u_int flags; }; +struct remote_domain_block_backup_args { + remote_nonnull_domain dom; + remote_nonnull_string path; + remote_nonnull_string dest; + uint64_t bandwidth; + remote_string format; + u_int flags; +}; struct remote_domain_set_block_io_tune_args { remote_nonnull_domain dom; remote_nonnull_string disk; @@ -3103,4 +3111,5 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_GET_PERF_EVENTS = 365, REMOTE_PROC_DOMAIN_SET_PERF_EVENTS = 366, REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVAL_FAILED = 367, + REMOTE_PROC_DOMAIN_BLOCK_BACKUP = 358, }; -- 2.6.4

qemu drive support block backup, it use qmp command "drive-backup" to start the block, and use qmp command "block-dirty-bitmap-add"/ "block-dirty-bitmap-clear"/"block-dirty-bitmap-remove" to manage the bitmap. Bitmap is used to incremental backup. Signed-off-by: longyou <longyou(a)mogujie.com&gt; --- src/conf/domain_conf.h | 12 +++ src/qemu/qemu_blockjob.c | 2 + src/qemu/qemu_capabilities.c | 4 + src/qemu/qemu_capabilities.h | 5 ++ src/qemu/qemu_driver.c | 197 +++++++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_monitor.c | 59 +++++++++++++ src/qemu/qemu_monitor.h | 23 +++++ src/qemu/qemu_monitor_json.c | 124 +++++++++++++++++++++++++++ src/qemu/qemu_monitor_json.h | 23 +++++ 9 files changed, 449 insertions(+) diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index c182747..44cbefa 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -556,6 +556,15 @@ typedef enum { } virDomainDiskMirrorState; +typedef enum { + VIR_DOMAIN_DISK_BACKUP_STATE_NONE = 0, /* No job, or job not finished */ + VIR_DOMAIN_DISK_BACKUP_STATE_FINISH, /* Job already finish */ + VIR_DOMAIN_DISK_BACKUP_STATE_ABORT, /* Cause error, job aborted */ + + VIR_DOMAIN_DISK_BACKUP_STATE_LAST +} virDomainDiskBackupState; + + /* Stores the virtual disk configuration */ struct _virDomainDiskDef { virStorageSourcePtr src; /* non-NULL. XXX Allow NULL for empty cdrom? */ @@ -606,6 +615,9 @@ struct _virDomainDiskDef { int discard; /* enum virDomainDiskDiscard */ unsigned int iothread; /* unused = 0, > 0 specific thread # */ char *domain_name; /* backend domain name */ + + bool full_backup; /* done full backup or not */ + int backup_state; /* enum virDomainDiskBackupState */ }; diff --git a/src/qemu/qemu_blockjob.c b/src/qemu/qemu_blockjob.c index 83a5a3f..de8c0e4 100644 --- a/src/qemu/qemu_blockjob.c +++ b/src/qemu/qemu_blockjob.c @@ -162,6 +162,8 @@ qemuBlockJobEventProcess(virQEMUDriverPtr driver, disk->mirrorJob = VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN; ignore_value(qemuDomainDetermineDiskChain(driver, vm, disk, true, true)); + + disk->backup_state = VIR_DOMAIN_DISK_BACKUP_STATE_FINISH; diskPriv->blockjob = false; break; diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index d32e71f..52344f6 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -329,6 +329,9 @@ VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST, "nec-usb-xhci-ports", "virtio-scsi-pci.iothread", "name-guest", + + "drive-backup", /* 225 */ + "drive-backup-incremental", ); @@ -1452,6 +1455,7 @@ struct virQEMUCapsStringFlags virQEMUCapsCommands[] = { { "block-commit", QEMU_CAPS_BLOCK_COMMIT }, { "query-vnc", QEMU_CAPS_VNC }, { "drive-mirror", QEMU_CAPS_DRIVE_MIRROR }, + { "drive-backup", QEMU_CAPS_DRIVE_BACKUP }, { "blockdev-snapshot-sync", QEMU_CAPS_DISK_SNAPSHOT }, { "add-fd", QEMU_CAPS_ADD_FD }, { "nbd-server-start", QEMU_CAPS_NBD_SERVER }, diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h index 368996a..cd1d2ae 100644 --- a/src/qemu/qemu_capabilities.h +++ b/src/qemu/qemu_capabilities.h @@ -361,6 +361,11 @@ typedef enum { QEMU_CAPS_VIRTIO_SCSI_IOTHREAD, /* virtio-scsi-{pci,ccw}.iothread */ QEMU_CAPS_NAME_GUEST, /* -name guest= */ + /* 225 */ + QEMU_CAPS_DRIVE_BACKUP, /* drive-backup monitor command */ + QEMU_CAPS_DRIVE_BACKUP_INCREMENTAL, /* drive-backup works + with "incremental" */ + QEMU_CAPS_LAST /* this must always be the last item */ } virQEMUCapsFlags; diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 10d3e3d..aaa249a 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -16941,6 +16941,202 @@ qemuDomainBlockCommit(virDomainPtr dom, return ret; } +#define QEMU_DRIVE_BACKUP_BITMAP "drive-backup-bitmap" + +static int +qemuDomainDriveBackupReady(virQEMUDriverPtr driver, + virDomainObjPtr vm, + virDomainDiskDefPtr disk) +{ + int status; + + status = qemuBlockJobUpdate(driver, vm, disk); + if (status == VIR_DOMAIN_BLOCK_JOB_FAILED) { + virReportError(VIR_ERR_OPERATION_FAILED, + _("backup of disk %s failed"), + disk->dst); + return -1; + } + + if (disk->backup_state == VIR_DOMAIN_DISK_BACKUP_STATE_FINISH) { + VIR_DEBUG("disk backup are finished"); + return 1; + } else { + VIR_DEBUG("Waiting for disk backup to get ready"); + return 0; + } +} + +static int +qemuDomainBlockBackup(virDomainPtr dom, + const char *path, + const char *dest, + unsigned long long bandwidth, + const char *format, + unsigned int flags) +{ + int ret = -1; + virQEMUDriverPtr driver = dom->conn->privateData; + qemuDomainObjPrivatePtr priv; + virDomainObjPtr vm = NULL; + char *device = NULL; + char *mode = NULL; + char *bitmap = NULL; + virDomainDiskDefPtr disk = NULL; + unsigned long long speed = bandwidth; + int sync_begin = 0; + + virCheckFlags(VIR_DOMAIN_BLOCK_BACKUP_FULL | + VIR_DOMAIN_BLOCK_BACKUP_TOP | + VIR_DOMAIN_BLOCK_BACKUP_INCREMENTAL, -1); + + if (!(vm = qemuDomObjFromDomain(dom))) + goto cleanup; + priv = vm->privateData; + + if (virDomainBlockBackupEnsureACL(dom->conn, vm->def) < 0) + goto cleanup; + + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) + goto cleanup; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto endjob; + } + + if (!(virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_BACKUP) && + virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC))) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("online backup not supported with this QEMU binary")); + goto endjob; + } + + /* Convert bandwidth MiB to bytes, if necessary */ + if (speed > LLONG_MAX >> 20) { + virReportError(VIR_ERR_OVERFLOW, + _("bandwidth must be less than %llu"), + LLONG_MAX >> 20); + goto endjob; + } + speed <<= 20; + + if (!(disk = qemuDomainDiskByName(vm->def, path))) + goto endjob; + + if (!(device = qemuAliasFromDisk(disk))) + goto endjob; + + if (qemuDomainDiskBlockJobIsActive(disk)) + goto endjob; + + if (!flags || + (flags & VIR_DOMAIN_BLOCK_BACKUP_FULL) || + (flags & VIR_DOMAIN_BLOCK_BACKUP_TOP)) { + qemuDomainObjEnterMonitor(driver, vm); + if (disk->full_backup) { + /* clear bitmap */ + ret = qemuMonitorBlockDirtyBitmapClear(priv->mon, device, + QEMU_DRIVE_BACKUP_BITMAP); + } else { + /* add bitmap */ + disk->full_backup = true; + ret = qemuMonitorBlockDirtyBitmapAdd(priv->mon, device, + QEMU_DRIVE_BACKUP_BITMAP, 0); + } + + if (qemuDomainObjExitMonitor(driver, vm) < 0) { + ret = -1; + goto rollback; + } + + if (ret < 0) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("disk %s add or clear dirty bitmap failed"), + disk->dst); + goto rollback; + } + + if (flags & VIR_DOMAIN_BLOCK_BACKUP_TOP) { + ignore_value(VIR_STRDUP(mode, "top")); + } else { + ignore_value(VIR_STRDUP(mode, "full")); + } + } else if (flags & VIR_DOMAIN_BLOCK_BACKUP_INCREMENTAL) { + if (!disk->full_backup) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("disk %s has no bitmap, must do full backup firstly"), + disk->dst); + goto endjob; + } + ignore_value(VIR_STRDUP(mode, "incremental")); + ignore_value(VIR_STRDUP(bitmap, QEMU_DRIVE_BACKUP_BITMAP)); + } else { + goto endjob; + } + + qemuBlockJobSyncBegin(disk); + sync_begin = 1; + + qemuDomainObjEnterMonitor(driver, vm); + ret = qemuMonitorDriveBackup(priv->mon, device, dest, + mode, format, bitmap, speed); + if (qemuDomainObjExitMonitor(driver, vm) < 0) { + ret = -1; + goto rollback; + } + + if (ret == 0) + QEMU_DOMAIN_DISK_PRIVATE(disk)->blockjob = true; + else { + virReportError(VIR_ERR_OPERATION_INVALID, + _("disk %s do backup failed"), disk->dst); + goto rollback; + } + + /* reset backup state */ + disk->backup_state = VIR_DOMAIN_DISK_BACKUP_STATE_NONE; + while ((ret = qemuDomainDriveBackupReady(driver, vm, disk)) != 1) { + if (ret) + goto rollback; + + if (priv->job.abortJob) { + priv->job.current->type = VIR_DOMAIN_JOB_CANCELLED; + virReportError(VIR_ERR_OPERATION_ABORTED, _("%s: %s"), + qemuDomainAsyncJobTypeToString(priv->job.asyncJob), + _("canceled by client")); + goto rollback; + } + + if (virDomainObjWait(vm) < 0) + goto rollback; + } + +endjob: + if (sync_begin) + qemuBlockJobSyncEnd(driver, vm, disk); + + qemuDomainObjEndJob(driver, vm); + +cleanup: + VIR_FREE(device); + VIR_FREE(mode); + VIR_FREE(bitmap); + virDomainObjEndAPI(&vm); + return ret; + +rollback: + qemuDomainObjEnterMonitor(driver, vm); + qemuMonitorBlockDirtyBitmapRemove(priv->mon, device, + QEMU_DRIVE_BACKUP_BITMAP); + if (qemuDomainObjExitMonitor(driver, vm) < 0) + ret = -1; + + disk->full_backup = false; + goto endjob; +} + static int qemuDomainOpenGraphics(virDomainPtr dom, unsigned int idx, @@ -19912,6 +20108,7 @@ static virHypervisorDriver qemuHypervisorDriver = { .domainBlockRebase = qemuDomainBlockRebase, /* 0.9.10 */ .domainBlockCopy = qemuDomainBlockCopy, /* 1.2.9 */ .domainBlockCommit = qemuDomainBlockCommit, /* 1.0.0 */ + .domainBlockBackup = qemuDomainBlockBackup, /* 1.3.6 */ .connectIsAlive = qemuConnectIsAlive, /* 0.9.8 */ .nodeSuspendForDuration = qemuNodeSuspendForDuration, /* 0.9.8 */ .domainSetBlockIoTune = qemuDomainSetBlockIoTune, /* 0.9.8 */ diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index 597307f..ef52fa1 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -2935,6 +2935,65 @@ qemuMonitorSupportsActiveCommit(qemuMonitorPtr mon) } +/* Start a block-backup block job. bandwidth is in bytes/sec. */ +int +qemuMonitorDriveBackup(qemuMonitorPtr mon, const char *device, + const char *dest, const char *mode, + const char *format, const char *bitmap, + unsigned long long bandwidth) +{ + VIR_DEBUG("device=%s, dest=%s, mode=%s, " + "format=%s, bitmap=%s, bandwidth=%llu", + device, dest, mode, NULLSTR(format), + NULLSTR(bitmap), bandwidth); + + QEMU_CHECK_MONITOR_JSON(mon); + + return qemuMonitorJSONDriveBackup(mon, device, dest, mode, + format, bitmap, bandwidth); +} + + +/* add dirty bitmap for backup on the block device. */ +int +qemuMonitorBlockDirtyBitmapAdd(qemuMonitorPtr mon, const char *device, + const char *bitmap, unsigned int granularity) +{ + VIR_DEBUG("device=%s, bitmap=%s, granularity=%#x", + device, bitmap, granularity); + + QEMU_CHECK_MONITOR_JSON(mon); + + return qemuMonitorJSONBlockDirtyBitmapAdd(mon, device, bitmap, granularity); +} + + +/* remove dirty bitmap for backup on the block device. */ +int +qemuMonitorBlockDirtyBitmapRemove(qemuMonitorPtr mon, + const char *device, const char *bitmap) +{ + VIR_DEBUG("device=%s, bitmap=%s", device, bitmap); + + QEMU_CHECK_MONITOR_JSON(mon); + + return qemuMonitorJSONBlockDirtyBitmapRemove(mon, device, bitmap); +} + + +/* clear dirty bitmap for backup on the block device. */ +int +qemuMonitorBlockDirtyBitmapClear(qemuMonitorPtr mon, + const char *device, const char *bitmap) +{ + VIR_DEBUG("device=%s, bitmap=%s", device, bitmap); + + QEMU_CHECK_MONITOR_JSON(mon); + + return qemuMonitorJSONBlockDirtyBitmapClear(mon, device, bitmap); +} + + /* Determine the name that qemu is using for tracking the backing * element TARGET within the chain starting at TOP. */ char * diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index dd3587f..0dee9f6 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -736,6 +736,29 @@ int qemuMonitorBlockCommit(qemuMonitorPtr mon, unsigned long long bandwidth) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4); bool qemuMonitorSupportsActiveCommit(qemuMonitorPtr mon); + +int +qemuMonitorDriveBackup(qemuMonitorPtr mon, const char *device, + const char *dest, const char *mode, + const char *format, const char *bitmap, + unsigned long long bandwidth) + ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4); + +int +qemuMonitorBlockDirtyBitmapAdd(qemuMonitorPtr mon, const char *device, + const char *bitmap, unsigned int granularity) + ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3); + +int +qemuMonitorBlockDirtyBitmapRemove(qemuMonitorPtr mon, + const char *device, const char *bitmap) + ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3); + +int +qemuMonitorBlockDirtyBitmapClear(qemuMonitorPtr mon, + const char *device, const char *bitmap) + ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3); + char *qemuMonitorDiskNameLookup(qemuMonitorPtr mon, const char *device, virStorageSourcePtr top, diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 585b882..9b06229 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -3902,6 +3902,130 @@ qemuMonitorJSONBlockCommit(qemuMonitorPtr mon, const char *device, return ret; } +/* TODO: + */ +int +qemuMonitorJSONDriveBackup(qemuMonitorPtr mon, const char *device, + const char *dest, const char *mode, + const char *format, const char *bitmap, + unsigned long long speed) +{ + int ret = -1; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + + cmd = qemuMonitorJSONMakeCommand("drive-backup", + "s:device", device, + "s:target", dest, + "s:sync", mode, + "s:mode", "existing", + "Y:speed", speed, + "S:format", format, + "S:bitmap", bitmap, + NULL); + if (!cmd) + return -1; + + if ((ret = qemuMonitorJSONCommand(mon, cmd, &reply)) < 0) + goto cleanup; + + ret = qemuMonitorJSONCheckError(cmd, reply); + + cleanup: + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + +/* TODO: + */ +int +qemuMonitorJSONBlockDirtyBitmapAdd(qemuMonitorPtr mon, + const char *device, + const char *bitmap, + unsigned int granularity) +{ + int ret = -1; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + + cmd = qemuMonitorJSONMakeCommand("block-dirty-bitmap-add", + "s:node", device, + "s:name", bitmap, + "p:granularity", granularity, + NULL); + if (!cmd) + return -1; + + if ((ret = qemuMonitorJSONCommand(mon, cmd, &reply)) < 0) + goto cleanup; + + ret = qemuMonitorJSONCheckError(cmd, reply); + + cleanup: + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + +/* TODO: + */ +int +qemuMonitorJSONBlockDirtyBitmapRemove(qemuMonitorPtr mon, + const char *device, + const char *bitmap) +{ + int ret = -1; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + + cmd = qemuMonitorJSONMakeCommand("block-dirty-bitmap-remove", + "s:node", device, + "s:name", bitmap, + NULL); + if (!cmd) + return -1; + + if ((ret = qemuMonitorJSONCommand(mon, cmd, &reply)) < 0) + goto cleanup; + + ret = qemuMonitorJSONCheckError(cmd, reply); + + cleanup: + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + +/* TODO: + */ +int +qemuMonitorJSONBlockDirtyBitmapClear(qemuMonitorPtr mon, + const char *device, + const char *bitmap) +{ + int ret = -1; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + + cmd = qemuMonitorJSONMakeCommand("block-dirty-bitmap-clear", + "s:node", device, + "s:name", bitmap, + NULL); + if (!cmd) + return -1; + + if ((ret = qemuMonitorJSONCommand(mon, cmd, &reply)) < 0) + goto cleanup; + + ret = qemuMonitorJSONCheckError(cmd, reply); + + cleanup: + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + int qemuMonitorJSONDrivePivot(qemuMonitorPtr mon, const char *device) diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 76758db..5519e45 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -268,6 +268,29 @@ int qemuMonitorJSONBlockCommit(qemuMonitorPtr mon, unsigned long long bandwidth) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); +int qemuMonitorJSONDriveBackup(qemuMonitorPtr mon, const char *device, + const char *dest, const char *mode, + const char *format, const char *bitmap, + unsigned long long speed) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) + ATTRIBUTE_NONNULL(4); + +int qemuMonitorJSONBlockDirtyBitmapAdd(qemuMonitorPtr mon, + const char *device, + const char *bitmap, + unsigned int granularity) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3); + +int qemuMonitorJSONBlockDirtyBitmapRemove(qemuMonitorPtr mon, + const char *device, + const char *bitmap) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); + +int qemuMonitorJSONBlockDirtyBitmapClear(qemuMonitorPtr mon, + const char *device, + const char *bitmap) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); + char *qemuMonitorJSONDiskNameLookup(qemuMonitorPtr mon, const char *device, virStorageSourcePtr top, -- 2.6.4

libvirt test supports drive-backup. Signed-off-by: longyou <longyou(a)mogujie.com&gt; --- tests/qemucaps2xmldata/all_1.6.0-1.caps | 1 + tests/qemucaps2xmldata/nodisksnapshot_1.6.0-1.caps | 1 + 2 files changed, 2 insertions(+) diff --git a/tests/qemucaps2xmldata/all_1.6.0-1.caps b/tests/qemucaps2xmldata/all_1.6.0-1.caps index d39d0be..27ca24e 100644 --- a/tests/qemucaps2xmldata/all_1.6.0-1.caps +++ b/tests/qemucaps2xmldata/all_1.6.0-1.caps @@ -84,6 +84,7 @@ <flag name='block-commit'/> <flag name='vnc'/> <flag name='drive-mirror'/> + <flag name='drive-backup'/> <flag name='usb-host.bootindex'/> <flag name='blockdev-snapshot-sync'/> <flag name='qxl'/> diff --git a/tests/qemucaps2xmldata/nodisksnapshot_1.6.0-1.caps b/tests/qemucaps2xmldata/nodisksnapshot_1.6.0-1.caps index 5a0372c..8d8434f 100644 --- a/tests/qemucaps2xmldata/nodisksnapshot_1.6.0-1.caps +++ b/tests/qemucaps2xmldata/nodisksnapshot_1.6.0-1.caps @@ -84,6 +84,7 @@ <flag name='block-commit'/> <flag name='vnc'/> <flag name='drive-mirror'/> + <flag name='drive-backup'/> <flag name='usb-host.bootindex'/> <flag name='qxl'/> <flag name='VGA'/> -- 2.6.4